drivers/net/wireless/libertas/cmdresp.c

   1 /**
   2   * This file contains the handling of command
   3   * responses as well as events generated by firmware.
   4   */
   5 #include <linux/delay.h>
   6 #include <linux/if_arp.h>
   7 #include <linux/netdevice.h>
   8
   9 #include <net/iw_handler.h>
  10
  11 #include "host.h"
  12 #include "decl.h"
  13 #include "defs.h"
  14 #include "dev.h"
  15 #include "join.h"
  16 #include "wext.h"
  17
  18 /**
  19  *  @brief This function handles disconnect event. it
  20  *  reports disconnect to upper layer, clean tx/rx packets,
  21  *  reset link state etc.
  22  *
  23  *  @param priv    A pointer to wlan_private structure
  24  *  @return        n/a
  25  */
  26 void libertas_mac_event_disconnected(wlan_private * priv)
  27 {
  28         wlan_adapter *adapter = priv->adapter;
  29         union iwreq_data wrqu;
  30
  31         if (adapter->connect_status != LIBERTAS_CONNECTED)
  32                 return;
  33
  34         lbs_deb_enter(LBS_DEB_CMD);
  35
  36         memset(wrqu.ap_addr.sa_data, 0x00, ETH_ALEN);
  37         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  38
  39         /*
  40          * Cisco AP sends EAP failure and de-auth in less than 0.5 ms.
  41          * It causes problem in the Supplicant
  42          */
  43
  44         msleep_interruptible(1000);
  45         wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
  46
  47         /* Free Tx and Rx packets */
  48         kfree_skb(priv->adapter->currenttxskb);
  49         priv->adapter->currenttxskb = NULL;
  50
  51         /* report disconnect to upper layer */
  52         netif_stop_queue(priv->dev);
  53         netif_carrier_off(priv->dev);
  54
  55         /* reset SNR/NF/RSSI values */
  56         memset(adapter->SNR, 0x00, sizeof(adapter->SNR));
  57         memset(adapter->NF, 0x00, sizeof(adapter->NF));
  58         memset(adapter->RSSI, 0x00, sizeof(adapter->RSSI));
  59         memset(adapter->rawSNR, 0x00, sizeof(adapter->rawSNR));
  60         memset(adapter->rawNF, 0x00, sizeof(adapter->rawNF));
  61         adapter->nextSNRNF = 0;
  62         adapter->numSNRNF = 0;
  63         adapter->rxpd_rate = 0;
  64         lbs_deb_cmd("current SSID '%s', length %u\n",
  65                     escape_essid(adapter->curbssparams.ssid,
  66                                  adapter->curbssparams.ssid_len),
  67                     adapter->curbssparams.ssid_len);
  68
  69         adapter->connect_status = LIBERTAS_DISCONNECTED;
  70
  71         /* Clear out associated SSID and BSSID since connection is
  72          * no longer valid.
  73          */
  74         memset(&adapter->curbssparams.bssid, 0, ETH_ALEN);
  75         memset(&adapter->curbssparams.ssid, 0, IW_ESSID_MAX_SIZE);
  76         adapter->curbssparams.ssid_len = 0;
  77
  78         if (adapter->psstate != PS_STATE_FULL_POWER) {
  79                 /* make firmware to exit PS mode */
  80                 lbs_deb_cmd("disconnected, so exit PS mode\n");
  81                 libertas_ps_wakeup(priv, 0);
  82         }
  83         lbs_deb_leave(LBS_DEB_CMD);
  84 }
  85
  86 /**
  87  *  @brief This function handles MIC failure event.
  88  *
  89  *  @param priv    A pointer to wlan_private structure
  90  *  @para  event   the event id
  91  *  @return        n/a
  92  */
  93 static void handle_mic_failureevent(wlan_private * priv, u32 event)
  94 {
  95         char buf[50];
  96
  97         lbs_deb_enter(LBS_DEB_CMD);
  98         memset(buf, 0, sizeof(buf));
  99
 100         sprintf(buf, "%s", "MLME-MICHAELMICFAILURE.indication ");
 101
 102         if (event == MACREG_INT_CODE_MIC_ERR_UNICAST) {
 103                 strcat(buf, "unicast ");
 104         } else {
 105                 strcat(buf, "multicast ");
 106         }
 107
 108         libertas_send_iwevcustom_event(priv, buf);
 109         lbs_deb_leave(LBS_DEB_CMD);
 110 }
 111
 112 static int wlan_ret_reg_access(wlan_private * priv,
 113                                u16 type, struct cmd_ds_command *resp)
 114 {
 115         int ret = 0;
 116         wlan_adapter *adapter = priv->adapter;
 117
 118         lbs_deb_enter(LBS_DEB_CMD);
 119
 120         switch (type) {
 121         case CMD_RET(CMD_MAC_REG_ACCESS):
 122                 {
 123                         struct cmd_ds_mac_reg_access *reg = &resp->params.macreg;
 124
 125                         adapter->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
 126                         adapter->offsetvalue.value = le32_to_cpu(reg->value);
 127                         break;
 128                 }
 129
 130         case CMD_RET(CMD_BBP_REG_ACCESS):
 131                 {
 132                         struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg;
 133
 134                         adapter->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
 135                         adapter->offsetvalue.value = reg->value;
 136                         break;
 137                 }
 138
 139         case CMD_RET(CMD_RF_REG_ACCESS):
 140                 {
 141                         struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg;
 142
 143                         adapter->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
 144                         adapter->offsetvalue.value = reg->value;
 145                         break;
 146                 }
 147
 148         default:
 149                 ret = -1;
 150         }
 151
 152         lbs_deb_enter_args(LBS_DEB_CMD, "ret %d", ret);
 153         return ret;
 154 }
 155
 156 static int wlan_ret_get_hw_spec(wlan_private * priv,
 157                                 struct cmd_ds_command *resp)
 158 {
 159         u32 i;
 160         struct cmd_ds_get_hw_spec *hwspec = &resp->params.hwspec;
 161         wlan_adapter *adapter = priv->adapter;
 162         int ret = 0;
 163
 164         lbs_deb_enter(LBS_DEB_CMD);
 165
 166         adapter->fwcapinfo = le32_to_cpu(hwspec->fwcapinfo);
 167
 168         memcpy(adapter->fwreleasenumber, hwspec->fwreleasenumber, 4);
 169
 170         lbs_deb_cmd("GET_HW_SPEC: firmware release %u.%u.%up%u\n",
 171                     adapter->fwreleasenumber[2], adapter->fwreleasenumber[1],
 172                     adapter->fwreleasenumber[0], adapter->fwreleasenumber[3]);
 173         lbs_deb_cmd("GET_HW_SPEC: MAC addr " MAC_FMT "\n",
 174                MAC_ARG(hwspec->permanentaddr));
 175         lbs_deb_cmd("GET_HW_SPEC: hardware interface 0x%x, hardware spec 0x%04x\n",
 176                hwspec->hwifversion, hwspec->version);
 177
 178         adapter->regioncode = le16_to_cpu(hwspec->regioncode);
 179
 180         for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
 181                 /* use the region code to search for the index */
 182                 if (adapter->regioncode == libertas_region_code_to_index[i]) {
 183                         adapter->regiontableindex = (u16) i;
 184                         break;
 185                 }
 186         }
 187
 188         /* if it's unidentified region code, use the default (USA) */
 189         if (i >= MRVDRV_MAX_REGION_CODE) {
 190                 adapter->regioncode = 0x10;
 191                 adapter->regiontableindex = 0;
 192                 lbs_pr_info("unidentified region code; using the default (USA)\n");
 193         }
 194
 195         if (adapter->current_addr[0] == 0xff)
 196                 memmove(adapter->current_addr, hwspec->permanentaddr, ETH_ALEN);
 197
 198         memcpy(priv->dev->dev_addr, adapter->current_addr, ETH_ALEN);
 199         if (priv->mesh_dev)
 200                 memcpy(priv->mesh_dev->dev_addr, adapter->current_addr, ETH_ALEN);
 201
 202         if (libertas_set_regiontable(priv, adapter->regioncode, 0)) {
 203                 ret = -1;
 204                 goto done;
 205         }
 206
 207         if (libertas_set_universaltable(priv, 0)) {
 208                 ret = -1;
 209                 goto done;
 210         }
 211
 212 done:
 213         lbs_deb_enter_args(LBS_DEB_CMD, "ret %d", ret);
 214         return ret;
 215 }
 216
 217 static int wlan_ret_802_11_sleep_params(wlan_private * priv,
 218                                         struct cmd_ds_command *resp)
 219 {
 220         struct cmd_ds_802_11_sleep_params *sp = &resp->params.sleep_params;
 221         wlan_adapter *adapter = priv->adapter;
 222
 223         lbs_deb_enter(LBS_DEB_CMD);
 224
 225         lbs_deb_cmd("error 0x%x, offset 0x%x, stabletime 0x%x, calcontrol 0x%x "
 226                     "extsleepclk 0x%x\n", le16_to_cpu(sp->error),
 227                     le16_to_cpu(sp->offset), le16_to_cpu(sp->stabletime),
 228                     sp->calcontrol, sp->externalsleepclk);
 229
 230         adapter->sp.sp_error = le16_to_cpu(sp->error);
 231         adapter->sp.sp_offset = le16_to_cpu(sp->offset);
 232         adapter->sp.sp_stabletime = le16_to_cpu(sp->stabletime);
 233         adapter->sp.sp_calcontrol = sp->calcontrol;
 234         adapter->sp.sp_extsleepclk = sp->externalsleepclk;
 235         adapter->sp.sp_reserved = le16_to_cpu(sp->reserved);
 236
 237         lbs_deb_enter(LBS_DEB_CMD);
 238         return 0;
 239 }
 240
 241 static int wlan_ret_802_11_stat(wlan_private * priv,
 242                                 struct cmd_ds_command *resp)
 243 {
 244         lbs_deb_enter(LBS_DEB_CMD);
 245 /*      currently adapter->wlan802_11Stat is unused
 246
 247         struct cmd_ds_802_11_get_stat *p11Stat = &resp->params.gstat;
 248         wlan_adapter *adapter = priv->adapter;
 249
 250         // TODO Convert it to Big endian befor copy
 251         memcpy(&adapter->wlan802_11Stat,
 252                p11Stat, sizeof(struct cmd_ds_802_11_get_stat));
 253 */
 254         lbs_deb_leave(LBS_DEB_CMD);
 255         return 0;
 256 }
 257
 258 static int wlan_ret_802_11_snmp_mib(wlan_private * priv,
 259                                     struct cmd_ds_command *resp)
 260 {
 261         struct cmd_ds_802_11_snmp_mib *smib = &resp->params.smib;
 262         u16 oid = le16_to_cpu(smib->oid);
 263         u16 querytype = le16_to_cpu(smib->querytype);
 264
 265         lbs_deb_enter(LBS_DEB_CMD);
 266
 267         lbs_deb_cmd("SNMP_RESP: oid 0x%x, querytype 0x%x\n", oid,
 268                querytype);
 269         lbs_deb_cmd("SNMP_RESP: Buf size %d\n", le16_to_cpu(smib->bufsize));
 270
 271         if (querytype == CMD_ACT_GET) {
 272                 switch (oid) {
 273                 case FRAGTHRESH_I:
 274                         priv->adapter->fragthsd =
 275                                 le16_to_cpu(*((__le16 *)(smib->value)));
 276                         lbs_deb_cmd("SNMP_RESP: frag threshold %u\n",
 277                                     priv->adapter->fragthsd);
 278                         break;
 279                 case RTSTHRESH_I:
 280                         priv->adapter->rtsthsd =
 281                                 le16_to_cpu(*((__le16 *)(smib->value)));
 282                         lbs_deb_cmd("SNMP_RESP: rts threshold %u\n",
 283                                     priv->adapter->rtsthsd);
 284                         break;
 285                 case SHORT_RETRYLIM_I:
 286                         priv->adapter->txretrycount =
 287                                 le16_to_cpu(*((__le16 *)(smib->value)));
 288                         lbs_deb_cmd("SNMP_RESP: tx retry count %u\n",
 289                                     priv->adapter->rtsthsd);
 290                         break;
 291                 default:
 292                         break;
 293                 }
 294         }
 295
 296         lbs_deb_enter(LBS_DEB_CMD);
 297         return 0;
 298 }
 299
 300 static int wlan_ret_802_11_key_material(wlan_private * priv,
 301                                         struct cmd_ds_command *resp)
 302 {
 303         struct cmd_ds_802_11_key_material *pkeymaterial =
 304             &resp->params.keymaterial;
 305         wlan_adapter *adapter = priv->adapter;
 306         u16 action = le16_to_cpu(pkeymaterial->action);
 307
 308         lbs_deb_enter(LBS_DEB_CMD);
 309
 310         /* Copy the returned key to driver private data */
 311         if (action == CMD_ACT_GET) {
 312                 u8 * buf_ptr = (u8 *) &pkeymaterial->keyParamSet;
 313                 u8 * resp_end = (u8 *) (resp + le16_to_cpu(resp->size));
 314
 315                 while (buf_ptr < resp_end) {
 316                         struct MrvlIEtype_keyParamSet * pkeyparamset =
 317                             (struct MrvlIEtype_keyParamSet *) buf_ptr;
 318                         struct enc_key * pkey;
 319                         u16 param_set_len = le16_to_cpu(pkeyparamset->length);
 320                         u16 key_len = le16_to_cpu(pkeyparamset->keylen);
 321                         u16 key_flags = le16_to_cpu(pkeyparamset->keyinfo);
 322                         u16 key_type = le16_to_cpu(pkeyparamset->keytypeid);
 323                         u8 * end;
 324
 325                         end = (u8 *) pkeyparamset + sizeof (pkeyparamset->type)
 326                                                   + sizeof (pkeyparamset->length)
 327                                                   + param_set_len;
 328                         /* Make sure we don't access past the end of the IEs */
 329                         if (end > resp_end)
 330                                 break;
 331
 332                         if (key_flags & KEY_INFO_WPA_UNICAST)
 333                                 pkey = &adapter->wpa_unicast_key;
 334                         else if (key_flags & KEY_INFO_WPA_MCAST)
 335                                 pkey = &adapter->wpa_mcast_key;
 336                         else
 337                                 break;
 338
 339                         /* Copy returned key into driver */
 340                         memset(pkey, 0, sizeof(struct enc_key));
 341                         if (key_len > sizeof(pkey->key))
 342                                 break;
 343                         pkey->type = key_type;
 344                         pkey->flags = key_flags;
 345                         pkey->len = key_len;
 346                         memcpy(pkey->key, pkeyparamset->key, pkey->len);
 347
 348                         buf_ptr = end + 1;
 349                 }
 350         }
 351
 352         lbs_deb_enter(LBS_DEB_CMD);
 353         return 0;
 354 }
 355
 356 static int wlan_ret_802_11_mac_address(wlan_private * priv,
 357                                        struct cmd_ds_command *resp)
 358 {
 359         struct cmd_ds_802_11_mac_address *macadd = &resp->params.macadd;
 360         wlan_adapter *adapter = priv->adapter;
 361
 362         lbs_deb_enter(LBS_DEB_CMD);
 363
 364         memcpy(adapter->current_addr, macadd->macadd, ETH_ALEN);
 365
 366         lbs_deb_enter(LBS_DEB_CMD);
 367         return 0;
 368 }
 369
 370 static int wlan_ret_802_11_rf_tx_power(wlan_private * priv,
 371                                        struct cmd_ds_command *resp)
 372 {
 373         struct cmd_ds_802_11_rf_tx_power *rtp = &resp->params.txp;
 374         wlan_adapter *adapter = priv->adapter;
 375
 376         lbs_deb_enter(LBS_DEB_CMD);
 377
 378         adapter->txpowerlevel = le16_to_cpu(rtp->currentlevel);
 379
 380         lbs_deb_cmd("TX power currently %d\n", adapter->txpowerlevel);
 381
 382         lbs_deb_leave(LBS_DEB_CMD);
 383         return 0;
 384 }
 385
 386 static int wlan_ret_802_11_rf_antenna(wlan_private * priv,
 387                                       struct cmd_ds_command *resp)
 388 {
 389         struct cmd_ds_802_11_rf_antenna *pAntenna = &resp->params.rant;
 390         wlan_adapter *adapter = priv->adapter;
 391         u16 action = le16_to_cpu(pAntenna->action);
 392
 393         lbs_deb_enter(LBS_DEB_CMD);
 394         if (action == CMD_ACT_GET_RX)
 395                 adapter->rxantennamode = le16_to_cpu(pAntenna->antennamode);
 396
 397         if (action == CMD_ACT_GET_TX)
 398                 adapter->txantennamode = le16_to_cpu(pAntenna->antennamode);
 399
 400         lbs_deb_cmd("RF_ANT_RESP: action 0x%x, mode 0x%04x\n",
 401                action, le16_to_cpu(pAntenna->antennamode));
 402
 403         lbs_deb_leave(LBS_DEB_CMD);
 404         return 0;
 405 }
 406
 407 static int wlan_ret_802_11_rate_adapt_rateset(wlan_private * priv,
 408                                               struct cmd_ds_command *resp)
 409 {
 410         struct cmd_ds_802_11_rate_adapt_rateset *rates = &resp->params.rateset;
 411         wlan_adapter *adapter = priv->adapter;
 412
 413         lbs_deb_enter(LBS_DEB_CMD);
 414
 415         if (rates->action == CMD_ACT_GET) {
 416                 adapter->enablehwauto = le16_to_cpu(rates->enablehwauto);
 417                 adapter->ratebitmap = le16_to_cpu(rates->bitmap);
 418         }
 419
 420         lbs_deb_leave(LBS_DEB_CMD);
 421         return 0;
 422 }
 423
 424 static int wlan_ret_802_11_data_rate(wlan_private * priv,
 425                                      struct cmd_ds_command *resp)
 426 {
 427         struct cmd_ds_802_11_data_rate *pdatarate = &resp->params.drate;
 428         wlan_adapter *adapter = priv->adapter;
 429
 430         lbs_deb_enter(LBS_DEB_CMD);
 431
 432         lbs_deb_hex(LBS_DEB_CMD, "DATA_RATE_RESP", (u8 *) pdatarate,
 433                 sizeof(struct cmd_ds_802_11_data_rate));
 434
 435         /* FIXME: get actual rates FW can do if this command actually returns
 436          * all data rates supported.
 437          */
 438         adapter->cur_rate = libertas_fw_index_to_data_rate(pdatarate->rates[0]);
 439         lbs_deb_cmd("DATA_RATE: current rate 0x%02x\n", adapter->cur_rate);
 440
 441         lbs_deb_leave(LBS_DEB_CMD);
 442         return 0;
 443 }
 444
 445 static int wlan_ret_802_11_rf_channel(wlan_private * priv,
 446                                       struct cmd_ds_command *resp)
 447 {
 448         struct cmd_ds_802_11_rf_channel *rfchannel = &resp->params.rfchannel;
 449         wlan_adapter *adapter = priv->adapter;
 450         u16 action = le16_to_cpu(rfchannel->action);
 451         u16 newchannel = le16_to_cpu(rfchannel->currentchannel);
 452
 453         lbs_deb_enter(LBS_DEB_CMD);
 454
 455         if (action == CMD_OPT_802_11_RF_CHANNEL_GET
 456             && adapter->curbssparams.channel != newchannel) {
 457                 lbs_deb_cmd("channel switch from %d to %d\n",
 458                        adapter->curbssparams.channel, newchannel);
 459
 460                 /* Update the channel again */
 461                 adapter->curbssparams.channel = newchannel;
 462         }
 463
 464         lbs_deb_enter(LBS_DEB_CMD);
 465         return 0;
 466 }
 467
 468 static int wlan_ret_802_11_rssi(wlan_private * priv,
 469                                 struct cmd_ds_command *resp)
 470 {
 471         struct cmd_ds_802_11_rssi_rsp *rssirsp = &resp->params.rssirsp;
 472         wlan_adapter *adapter = priv->adapter;
 473
 474         lbs_deb_enter(LBS_DEB_CMD);
 475
 476         /* store the non average value */
 477         adapter->SNR[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->SNR);
 478         adapter->NF[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->noisefloor);
 479
 480         adapter->SNR[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgSNR);
 481         adapter->NF[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgnoisefloor);
 482
 483         adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] =
 484             CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_NOAVG],
 485                      adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
 486
 487         adapter->RSSI[TYPE_BEACON][TYPE_AVG] =
 488             CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_AVG] / AVG_SCALE,
 489                      adapter->NF[TYPE_BEACON][TYPE_AVG] / AVG_SCALE);
 490
 491         lbs_deb_cmd("RSSI: beacon %d, avg %d\n",
 492                adapter->RSSI[TYPE_BEACON][TYPE_NOAVG],
 493                adapter->RSSI[TYPE_BEACON][TYPE_AVG]);
 494
 495         lbs_deb_leave(LBS_DEB_CMD);
 496         return 0;
 497 }
 498
 499 static int wlan_ret_802_11_eeprom_access(wlan_private * priv,
 500                                   struct cmd_ds_command *resp)
 501 {
 502         wlan_adapter *adapter = priv->adapter;
 503         struct wlan_ioctl_regrdwr *pbuf;
 504         pbuf = (struct wlan_ioctl_regrdwr *) adapter->prdeeprom;
 505
 506         lbs_deb_enter_args(LBS_DEB_CMD, "len %d",
 507                le16_to_cpu(resp->params.rdeeprom.bytecount));
 508         if (pbuf->NOB < le16_to_cpu(resp->params.rdeeprom.bytecount)) {
 509                 pbuf->NOB = 0;
 510                 lbs_deb_cmd("EEPROM read length too big\n");
 511                 return -1;
 512         }
 513         pbuf->NOB = le16_to_cpu(resp->params.rdeeprom.bytecount);
 514         if (pbuf->NOB > 0) {
 515
 516                 memcpy(&pbuf->value, (u8 *) & resp->params.rdeeprom.value,
 517                        le16_to_cpu(resp->params.rdeeprom.bytecount));
 518                 lbs_deb_hex(LBS_DEB_CMD, "EEPROM", (char *)&pbuf->value,
 519                         le16_to_cpu(resp->params.rdeeprom.bytecount));
 520         }
 521         lbs_deb_leave(LBS_DEB_CMD);
 522         return 0;
 523 }
 524
 525 static int wlan_ret_get_log(wlan_private * priv,
 526                             struct cmd_ds_command *resp)
 527 {
 528         struct cmd_ds_802_11_get_log *logmessage = &resp->params.glog;
 529         wlan_adapter *adapter = priv->adapter;
 530
 531         lbs_deb_enter(LBS_DEB_CMD);
 532
 533         /* Stored little-endian */
 534         memcpy(&adapter->logmsg, logmessage, sizeof(struct cmd_ds_802_11_get_log));
 535
 536         lbs_deb_leave(LBS_DEB_CMD);
 537         return 0;
 538 }
 539
 540 static int libertas_ret_802_11_enable_rsn(wlan_private * priv,
 541                                           struct cmd_ds_command *resp)
 542 {
 543         struct cmd_ds_802_11_enable_rsn *enable_rsn = &resp->params.enbrsn;
 544         wlan_adapter *adapter = priv->adapter;
 545         u32 * pdata_buf = adapter->cur_cmd->pdata_buf;
 546
 547         lbs_deb_enter(LBS_DEB_CMD);
 548
 549         if (enable_rsn->action == cpu_to_le16(CMD_ACT_GET)) {
 550                 if (pdata_buf)
 551                         *pdata_buf = (u32) le16_to_cpu(enable_rsn->enable);
 552         }
 553
 554         lbs_deb_leave(LBS_DEB_CMD);
 555         return 0;
 556 }
 557
 558 static inline int handle_cmd_response(u16 respcmd,
 559                                       struct cmd_ds_command *resp,
 560                                       wlan_private *priv)
 561 {
 562         int ret = 0;
 563         unsigned long flags;
 564         wlan_adapter *adapter = priv->adapter;
 565
 566         lbs_deb_enter(LBS_DEB_HOST);
 567
 568         switch (respcmd) {
 569         case CMD_RET(CMD_MAC_REG_ACCESS):
 570         case CMD_RET(CMD_BBP_REG_ACCESS):
 571         case CMD_RET(CMD_RF_REG_ACCESS):
 572                 ret = wlan_ret_reg_access(priv, respcmd, resp);
 573                 break;
 574
 575         case CMD_RET(CMD_GET_HW_SPEC):
 576                 ret = wlan_ret_get_hw_spec(priv, resp);
 577                 break;
 578
 579         case CMD_RET(CMD_802_11_SCAN):
 580                 ret = libertas_ret_80211_scan(priv, resp);
 581                 break;
 582
 583         case CMD_RET(CMD_802_11_GET_LOG):
 584                 ret = wlan_ret_get_log(priv, resp);
 585                 break;
 586
 587         case CMD_RET_802_11_ASSOCIATE:
 588         case CMD_RET(CMD_802_11_ASSOCIATE):
 589         case CMD_RET(CMD_802_11_REASSOCIATE):
 590                 ret = libertas_ret_80211_associate(priv, resp);
 591                 break;
 592
 593         case CMD_RET(CMD_802_11_DISASSOCIATE):
 594         case CMD_RET(CMD_802_11_DEAUTHENTICATE):
 595                 ret = libertas_ret_80211_disassociate(priv, resp);
 596                 break;
 597
 598         case CMD_RET(CMD_802_11_AD_HOC_START):
 599         case CMD_RET(CMD_802_11_AD_HOC_JOIN):
 600                 ret = libertas_ret_80211_ad_hoc_start(priv, resp);
 601                 break;
 602
 603         case CMD_RET(CMD_802_11_GET_STAT):
 604                 ret = wlan_ret_802_11_stat(priv, resp);
 605                 break;
 606
 607         case CMD_RET(CMD_802_11_SNMP_MIB):
 608                 ret = wlan_ret_802_11_snmp_mib(priv, resp);
 609                 break;
 610
 611         case CMD_RET(CMD_802_11_RF_TX_POWER):
 612                 ret = wlan_ret_802_11_rf_tx_power(priv, resp);
 613                 break;
 614
 615         case CMD_RET(CMD_802_11_SET_AFC):
 616         case CMD_RET(CMD_802_11_GET_AFC):
 617                 spin_lock_irqsave(&adapter->driver_lock, flags);
 618                 memmove(adapter->cur_cmd->pdata_buf, &resp->params.afc,
 619                         sizeof(struct cmd_ds_802_11_afc));
 620                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 621
 622                 break;
 623         case CMD_RET(CMD_802_11_RF_ANTENNA):
 624                 ret = wlan_ret_802_11_rf_antenna(priv, resp);
 625                 break;
 626
 627         case CMD_RET(CMD_MAC_MULTICAST_ADR):
 628         case CMD_RET(CMD_MAC_CONTROL):
 629         case CMD_RET(CMD_802_11_SET_WEP):
 630         case CMD_RET(CMD_802_11_RESET):
 631         case CMD_RET(CMD_802_11_AUTHENTICATE):
 632         case CMD_RET(CMD_802_11_RADIO_CONTROL):
 633         case CMD_RET(CMD_802_11_BEACON_STOP):
 634                 break;
 635
 636         case CMD_RET(CMD_802_11_ENABLE_RSN):
 637                 ret = libertas_ret_802_11_enable_rsn(priv, resp);
 638                 break;
 639
 640         case CMD_RET(CMD_802_11_DATA_RATE):
 641                 ret = wlan_ret_802_11_data_rate(priv, resp);
 642                 break;
 643         case CMD_RET(CMD_802_11_RATE_ADAPT_RATESET):
 644                 ret = wlan_ret_802_11_rate_adapt_rateset(priv, resp);
 645                 break;
 646         case CMD_RET(CMD_802_11_RF_CHANNEL):
 647                 ret = wlan_ret_802_11_rf_channel(priv, resp);
 648                 break;
 649
 650         case CMD_RET(CMD_802_11_RSSI):
 651                 ret = wlan_ret_802_11_rssi(priv, resp);
 652                 break;
 653
 654         case CMD_RET(CMD_802_11_MAC_ADDRESS):
 655                 ret = wlan_ret_802_11_mac_address(priv, resp);
 656                 break;
 657
 658         case CMD_RET(CMD_802_11_AD_HOC_STOP):
 659                 ret = libertas_ret_80211_ad_hoc_stop(priv, resp);
 660                 break;
 661
 662         case CMD_RET(CMD_802_11_KEY_MATERIAL):
 663                 ret = wlan_ret_802_11_key_material(priv, resp);
 664                 break;
 665
 666         case CMD_RET(CMD_802_11_EEPROM_ACCESS):
 667                 ret = wlan_ret_802_11_eeprom_access(priv, resp);
 668                 break;
 669
 670         case CMD_RET(CMD_802_11D_DOMAIN_INFO):
 671                 ret = libertas_ret_802_11d_domain_info(priv, resp);
 672                 break;
 673
 674         case CMD_RET(CMD_802_11_SLEEP_PARAMS):
 675                 ret = wlan_ret_802_11_sleep_params(priv, resp);
 676                 break;
 677         case CMD_RET(CMD_802_11_INACTIVITY_TIMEOUT):
 678                 spin_lock_irqsave(&adapter->driver_lock, flags);
 679                 *((u16 *) adapter->cur_cmd->pdata_buf) =
 680                     le16_to_cpu(resp->params.inactivity_timeout.timeout);
 681                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 682                 break;
 683
 684         case CMD_RET(CMD_802_11_TPC_CFG):
 685                 spin_lock_irqsave(&adapter->driver_lock, flags);
 686                 memmove(adapter->cur_cmd->pdata_buf, &resp->params.tpccfg,
 687                         sizeof(struct cmd_ds_802_11_tpc_cfg));
 688                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 689                 break;
 690         case CMD_RET(CMD_802_11_LED_GPIO_CTRL):
 691                 spin_lock_irqsave(&adapter->driver_lock, flags);
 692                 memmove(adapter->cur_cmd->pdata_buf, &resp->params.ledgpio,
 693                         sizeof(struct cmd_ds_802_11_led_ctrl));
 694                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 695                 break;
 696         case CMD_RET(CMD_802_11_PWR_CFG):
 697                 spin_lock_irqsave(&adapter->driver_lock, flags);
 698                 memmove(adapter->cur_cmd->pdata_buf, &resp->params.pwrcfg,
 699                         sizeof(struct cmd_ds_802_11_pwr_cfg));
 700                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 701
 702                 break;
 703
 704         case CMD_RET(CMD_GET_TSF):
 705                 spin_lock_irqsave(&adapter->driver_lock, flags);
 706                 memcpy(priv->adapter->cur_cmd->pdata_buf,
 707                        &resp->params.gettsf.tsfvalue, sizeof(u64));
 708                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 709                 break;
 710         case CMD_RET(CMD_BT_ACCESS):
 711                 spin_lock_irqsave(&adapter->driver_lock, flags);
 712                 if (adapter->cur_cmd->pdata_buf)
 713                         memcpy(adapter->cur_cmd->pdata_buf,
 714                                &resp->params.bt.addr1, 2 * ETH_ALEN);
 715                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 716                 break;
 717         case CMD_RET(CMD_FWT_ACCESS):
 718                 spin_lock_irqsave(&adapter->driver_lock, flags);
 719                 if (adapter->cur_cmd->pdata_buf)
 720                         memcpy(adapter->cur_cmd->pdata_buf, &resp->params.fwt,
 721                                sizeof(resp->params.fwt));
 722                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 723                 break;
 724         case CMD_RET(CMD_MESH_ACCESS):
 725                 if (adapter->cur_cmd->pdata_buf)
 726                         memcpy(adapter->cur_cmd->pdata_buf, &resp->params.mesh,
 727                                sizeof(resp->params.mesh));
 728                 break;
 729         case CMD_RET(CMD_802_11_TX_RATE_QUERY):
 730                 priv->adapter->txrate = resp->params.txrate.txrate;
 731                 break;
 732         default:
 733                 lbs_deb_host("CMD_RESP: unknown cmd response 0x%04x\n",
 734                             resp->command);
 735                 break;
 736         }
 737         lbs_deb_leave(LBS_DEB_HOST);
 738         return ret;
 739 }
 740
 741 int libertas_process_rx_command(wlan_private * priv)
 742 {
 743         u16 respcmd;
 744         struct cmd_ds_command *resp;
 745         wlan_adapter *adapter = priv->adapter;
 746         int ret = 0;
 747         ulong flags;
 748         u16 result;
 749
 750         lbs_deb_enter(LBS_DEB_HOST);
 751
 752         /* Now we got response from FW, cancel the command timer */
 753         del_timer(&adapter->command_timer);
 754
 755         mutex_lock(&adapter->lock);
 756         spin_lock_irqsave(&adapter->driver_lock, flags);
 757
 758         if (!adapter->cur_cmd) {
 759                 lbs_deb_host("CMD_RESP: cur_cmd is NULL\n");
 760                 ret = -1;
 761                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 762                 goto done;
 763         }
 764         resp = (struct cmd_ds_command *)(adapter->cur_cmd->bufvirtualaddr);
 765
 766         respcmd = le16_to_cpu(resp->command);
 767         result = le16_to_cpu(resp->result);
 768
 769         lbs_deb_host("CMD_RESP: response 0x%04x, size %d, jiffies %lu\n",
 770                 respcmd, priv->upld_len, jiffies);
 771         lbs_deb_hex(LBS_DEB_HOST, "CMD_RESP", adapter->cur_cmd->bufvirtualaddr,
 772                     priv->upld_len);
 773
 774         if (!(respcmd & 0x8000)) {
 775                 lbs_deb_host("invalid response!\n");
 776                 adapter->cur_cmd_retcode = -1;
 777                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 778                 adapter->nr_cmd_pending--;
 779                 adapter->cur_cmd = NULL;
 780                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 781                 ret = -1;
 782                 goto done;
 783         }
 784
 785         /* Store the response code to cur_cmd_retcode. */
 786         adapter->cur_cmd_retcode = result;;
 787
 788         if (respcmd == CMD_RET(CMD_802_11_PS_MODE)) {
 789                 struct cmd_ds_802_11_ps_mode *psmode = &resp->params.psmode;
 790                 u16 action = le16_to_cpu(psmode->action);
 791
 792                 lbs_deb_host(
 793                        "CMD_RESP: PS_MODE cmd reply result 0x%x, action 0x%x\n",
 794                        result, action);
 795
 796                 if (result) {
 797                         lbs_deb_host("CMD_RESP: PS command failed with 0x%x\n",
 798                                     result);
 799                         /*
 800                          * We should not re-try enter-ps command in
 801                          * ad-hoc mode. It takes place in
 802                          * libertas_execute_next_command().
 803                          */
 804                         if (adapter->mode == IW_MODE_ADHOC &&
 805                             action == CMD_SUBCMD_ENTER_PS)
 806                                 adapter->psmode = WLAN802_11POWERMODECAM;
 807                 } else if (action == CMD_SUBCMD_ENTER_PS) {
 808                         adapter->needtowakeup = 0;
 809                         adapter->psstate = PS_STATE_AWAKE;
 810
 811                         lbs_deb_host("CMD_RESP: ENTER_PS command response\n");
 812                         if (adapter->connect_status != LIBERTAS_CONNECTED) {
 813                                 /*
 814                                  * When Deauth Event received before Enter_PS command
 815                                  * response, We need to wake up the firmware.
 816                                  */
 817                                 lbs_deb_host(
 818                                        "disconnected, invoking libertas_ps_wakeup\n");
 819
 820                                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 821                                 mutex_unlock(&adapter->lock);
 822                                 libertas_ps_wakeup(priv, 0);
 823                                 mutex_lock(&adapter->lock);
 824                                 spin_lock_irqsave(&adapter->driver_lock, flags);
 825                         }
 826                 } else if (action == CMD_SUBCMD_EXIT_PS) {
 827                         adapter->needtowakeup = 0;
 828                         adapter->psstate = PS_STATE_FULL_POWER;
 829                         lbs_deb_host("CMD_RESP: EXIT_PS command response\n");
 830                 } else {
 831                         lbs_deb_host("CMD_RESP: PS action 0x%X\n", action);
 832                 }
 833
 834                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 835                 adapter->nr_cmd_pending--;
 836                 adapter->cur_cmd = NULL;
 837                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 838
 839                 ret = 0;
 840                 goto done;
 841         }
 842
 843         if (adapter->cur_cmd->cmdflags & CMD_F_HOSTCMD) {
 844                 /* Copy the response back to response buffer */
 845                 memcpy(adapter->cur_cmd->pdata_buf, resp, resp->size);
 846
 847                 adapter->cur_cmd->cmdflags &= ~CMD_F_HOSTCMD;
 848         }
 849
 850         /* If the command is not successful, cleanup and return failure */
 851         if ((result != 0 || !(respcmd & 0x8000))) {
 852                 lbs_deb_host("CMD_RESP: error 0x%04x in command reply 0x%04x\n",
 853                        result, respcmd);
 854                 /*
 855                  * Handling errors here
 856                  */
 857                 switch (respcmd) {
 858                 case CMD_RET(CMD_GET_HW_SPEC):
 859                 case CMD_RET(CMD_802_11_RESET):
 860                         lbs_deb_host("CMD_RESP: reset failed\n");
 861                         break;
 862
 863                 }
 864
 865                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 866                 adapter->nr_cmd_pending--;
 867                 adapter->cur_cmd = NULL;
 868                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 869
 870                 ret = -1;
 871                 goto done;
 872         }
 873
 874         spin_unlock_irqrestore(&adapter->driver_lock, flags);
 875
 876         ret = handle_cmd_response(respcmd, resp, priv);
 877
 878         spin_lock_irqsave(&adapter->driver_lock, flags);
 879         if (adapter->cur_cmd) {
 880                 /* Clean up and Put current command back to cmdfreeq */
 881                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 882                 adapter->nr_cmd_pending--;
 883                 WARN_ON(adapter->nr_cmd_pending > 128);
 884                 adapter->cur_cmd = NULL;
 885         }
 886         spin_unlock_irqrestore(&adapter->driver_lock, flags);
 887
 888 done:
 889         mutex_unlock(&adapter->lock);
 890         lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
 891         return ret;
 892 }
 893
 894 int libertas_process_event(wlan_private * priv)
 895 {
 896         int ret = 0;
 897         wlan_adapter *adapter = priv->adapter;
 898         u32 eventcause;
 899
 900         spin_lock_irq(&adapter->driver_lock);
 901         eventcause = adapter->eventcause;
 902         spin_unlock_irq(&adapter->driver_lock);
 903
 904         lbs_deb_enter(LBS_DEB_CMD);
 905
 906         lbs_deb_cmd("event cause 0x%x\n", eventcause);
 907
 908         switch (eventcause >> SBI_EVENT_CAUSE_SHIFT) {
 909         case MACREG_INT_CODE_LINK_SENSED:
 910                 lbs_deb_cmd("EVENT: MACREG_INT_CODE_LINK_SENSED\n");
 911                 break;
 912
 913         case MACREG_INT_CODE_DEAUTHENTICATED:
 914                 lbs_deb_cmd("EVENT: deauthenticated\n");
 915                 libertas_mac_event_disconnected(priv);
 916                 break;
 917
 918         case MACREG_INT_CODE_DISASSOCIATED:
 919                 lbs_deb_cmd("EVENT: disassociated\n");
 920                 libertas_mac_event_disconnected(priv);
 921                 break;
 922
 923         case MACREG_INT_CODE_LINK_LOSE_NO_SCAN:
 924                 lbs_deb_cmd("EVENT: link lost\n");
 925                 libertas_mac_event_disconnected(priv);
 926                 break;
 927
 928         case MACREG_INT_CODE_PS_SLEEP:
 929                 lbs_deb_cmd("EVENT: sleep\n");
 930
 931                 /* handle unexpected PS SLEEP event */
 932                 if (adapter->psstate == PS_STATE_FULL_POWER) {
 933                         lbs_deb_cmd(
 934                                "EVENT: in FULL POWER mode, ignoreing PS_SLEEP\n");
 935                         break;
 936                 }
 937                 adapter->psstate = PS_STATE_PRE_SLEEP;
 938
 939                 libertas_ps_confirm_sleep(priv, (u16) adapter->psmode);
 940
 941                 break;
 942
 943         case MACREG_INT_CODE_PS_AWAKE:
 944                 lbs_deb_cmd("EVENT: awake\n");
 945
 946                 /* handle unexpected PS AWAKE event */
 947                 if (adapter->psstate == PS_STATE_FULL_POWER) {
 948                         lbs_deb_cmd(
 949                                "EVENT: In FULL POWER mode - ignore PS AWAKE\n");
 950                         break;
 951                 }
 952
 953                 adapter->psstate = PS_STATE_AWAKE;
 954
 955                 if (adapter->needtowakeup) {
 956                         /*
 957                          * wait for the command processing to finish
 958                          * before resuming sending
 959                          * adapter->needtowakeup will be set to FALSE
 960                          * in libertas_ps_wakeup()
 961                          */
 962                         lbs_deb_cmd("waking up ...\n");
 963                         libertas_ps_wakeup(priv, 0);
 964                 }
 965                 break;
 966
 967         case MACREG_INT_CODE_MIC_ERR_UNICAST:
 968                 lbs_deb_cmd("EVENT: UNICAST MIC ERROR\n");
 969                 handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_UNICAST);
 970                 break;
 971
 972         case MACREG_INT_CODE_MIC_ERR_MULTICAST:
 973                 lbs_deb_cmd("EVENT: MULTICAST MIC ERROR\n");
 974                 handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_MULTICAST);
 975                 break;
 976         case MACREG_INT_CODE_MIB_CHANGED:
 977         case MACREG_INT_CODE_INIT_DONE:
 978                 break;
 979
 980         case MACREG_INT_CODE_ADHOC_BCN_LOST:
 981                 lbs_deb_cmd("EVENT: ADHOC beacon lost\n");
 982                 break;
 983
 984         case MACREG_INT_CODE_RSSI_LOW:
 985                 lbs_pr_alert("EVENT: rssi low\n");
 986                 break;
 987         case MACREG_INT_CODE_SNR_LOW:
 988                 lbs_pr_alert("EVENT: snr low\n");
 989                 break;
 990         case MACREG_INT_CODE_MAX_FAIL:
 991                 lbs_pr_alert("EVENT: max fail\n");
 992                 break;
 993         case MACREG_INT_CODE_RSSI_HIGH:
 994                 lbs_pr_alert("EVENT: rssi high\n");
 995                 break;
 996         case MACREG_INT_CODE_SNR_HIGH:
 997                 lbs_pr_alert("EVENT: snr high\n");
 998                 break;
 999
1000         case MACREG_INT_CODE_MESH_AUTO_STARTED:
1001                 lbs_pr_info("EVENT: MESH_AUTO_STARTED\n");
1002                 adapter->connect_status = LIBERTAS_CONNECTED;
1003                 if (priv->mesh_open == 1) {
1004                         netif_wake_queue(priv->mesh_dev);
1005                         netif_carrier_on(priv->mesh_dev);
1006                 }
1007                 adapter->mode = IW_MODE_ADHOC;
1008                 schedule_work(&priv->sync_channel);
1009                 break;
1010
1011         default:
1012                 lbs_pr_alert("EVENT: unknown event id 0x%04x\n",
1013                        eventcause >> SBI_EVENT_CAUSE_SHIFT);
1014                 break;
1015         }
1016
1017         spin_lock_irq(&adapter->driver_lock);
1018         adapter->eventcause = 0;
1019         spin_unlock_irq(&adapter->driver_lock);
1020
1021         lbs_deb_enter_args(LBS_DEB_CMD, "ret %d", ret);
1022         return ret;
1023 }