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_rate_adapt_rateset(wlan_private * priv,
 387                                               struct cmd_ds_command *resp)
 388 {
 389         struct cmd_ds_802_11_rate_adapt_rateset *rates = &resp->params.rateset;
 390         wlan_adapter *adapter = priv->adapter;
 391
 392         lbs_deb_enter(LBS_DEB_CMD);
 393
 394         if (rates->action == CMD_ACT_GET) {
 395                 adapter->enablehwauto = le16_to_cpu(rates->enablehwauto);
 396                 adapter->ratebitmap = le16_to_cpu(rates->bitmap);
 397         }
 398
 399         lbs_deb_leave(LBS_DEB_CMD);
 400         return 0;
 401 }
 402
 403 static int wlan_ret_802_11_data_rate(wlan_private * priv,
 404                                      struct cmd_ds_command *resp)
 405 {
 406         struct cmd_ds_802_11_data_rate *pdatarate = &resp->params.drate;
 407         wlan_adapter *adapter = priv->adapter;
 408
 409         lbs_deb_enter(LBS_DEB_CMD);
 410
 411         lbs_deb_hex(LBS_DEB_CMD, "DATA_RATE_RESP", (u8 *) pdatarate,
 412                 sizeof(struct cmd_ds_802_11_data_rate));
 413
 414         /* FIXME: get actual rates FW can do if this command actually returns
 415          * all data rates supported.
 416          */
 417         adapter->cur_rate = libertas_fw_index_to_data_rate(pdatarate->rates[0]);
 418         lbs_deb_cmd("DATA_RATE: current rate 0x%02x\n", adapter->cur_rate);
 419
 420         lbs_deb_leave(LBS_DEB_CMD);
 421         return 0;
 422 }
 423
 424 static int wlan_ret_802_11_rf_channel(wlan_private * priv,
 425                                       struct cmd_ds_command *resp)
 426 {
 427         struct cmd_ds_802_11_rf_channel *rfchannel = &resp->params.rfchannel;
 428         wlan_adapter *adapter = priv->adapter;
 429         u16 action = le16_to_cpu(rfchannel->action);
 430         u16 newchannel = le16_to_cpu(rfchannel->currentchannel);
 431
 432         lbs_deb_enter(LBS_DEB_CMD);
 433
 434         if (action == CMD_OPT_802_11_RF_CHANNEL_GET
 435             && adapter->curbssparams.channel != newchannel) {
 436                 lbs_deb_cmd("channel switch from %d to %d\n",
 437                        adapter->curbssparams.channel, newchannel);
 438
 439                 /* Update the channel again */
 440                 adapter->curbssparams.channel = newchannel;
 441         }
 442
 443         lbs_deb_enter(LBS_DEB_CMD);
 444         return 0;
 445 }
 446
 447 static int wlan_ret_802_11_rssi(wlan_private * priv,
 448                                 struct cmd_ds_command *resp)
 449 {
 450         struct cmd_ds_802_11_rssi_rsp *rssirsp = &resp->params.rssirsp;
 451         wlan_adapter *adapter = priv->adapter;
 452
 453         lbs_deb_enter(LBS_DEB_CMD);
 454
 455         /* store the non average value */
 456         adapter->SNR[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->SNR);
 457         adapter->NF[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->noisefloor);
 458
 459         adapter->SNR[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgSNR);
 460         adapter->NF[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgnoisefloor);
 461
 462         adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] =
 463             CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_NOAVG],
 464                      adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
 465
 466         adapter->RSSI[TYPE_BEACON][TYPE_AVG] =
 467             CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_AVG] / AVG_SCALE,
 468                      adapter->NF[TYPE_BEACON][TYPE_AVG] / AVG_SCALE);
 469
 470         lbs_deb_cmd("RSSI: beacon %d, avg %d\n",
 471                adapter->RSSI[TYPE_BEACON][TYPE_NOAVG],
 472                adapter->RSSI[TYPE_BEACON][TYPE_AVG]);
 473
 474         lbs_deb_leave(LBS_DEB_CMD);
 475         return 0;
 476 }
 477
 478 static int wlan_ret_802_11_eeprom_access(wlan_private * priv,
 479                                   struct cmd_ds_command *resp)
 480 {
 481         wlan_adapter *adapter = priv->adapter;
 482         struct wlan_ioctl_regrdwr *pbuf;
 483         pbuf = (struct wlan_ioctl_regrdwr *) adapter->prdeeprom;
 484
 485         lbs_deb_enter_args(LBS_DEB_CMD, "len %d",
 486                le16_to_cpu(resp->params.rdeeprom.bytecount));
 487         if (pbuf->NOB < le16_to_cpu(resp->params.rdeeprom.bytecount)) {
 488                 pbuf->NOB = 0;
 489                 lbs_deb_cmd("EEPROM read length too big\n");
 490                 return -1;
 491         }
 492         pbuf->NOB = le16_to_cpu(resp->params.rdeeprom.bytecount);
 493         if (pbuf->NOB > 0) {
 494
 495                 memcpy(&pbuf->value, (u8 *) & resp->params.rdeeprom.value,
 496                        le16_to_cpu(resp->params.rdeeprom.bytecount));
 497                 lbs_deb_hex(LBS_DEB_CMD, "EEPROM", (char *)&pbuf->value,
 498                         le16_to_cpu(resp->params.rdeeprom.bytecount));
 499         }
 500         lbs_deb_leave(LBS_DEB_CMD);
 501         return 0;
 502 }
 503
 504 static int wlan_ret_get_log(wlan_private * priv,
 505                             struct cmd_ds_command *resp)
 506 {
 507         struct cmd_ds_802_11_get_log *logmessage = &resp->params.glog;
 508         wlan_adapter *adapter = priv->adapter;
 509
 510         lbs_deb_enter(LBS_DEB_CMD);
 511
 512         /* Stored little-endian */
 513         memcpy(&adapter->logmsg, logmessage, sizeof(struct cmd_ds_802_11_get_log));
 514
 515         lbs_deb_leave(LBS_DEB_CMD);
 516         return 0;
 517 }
 518
 519 static int libertas_ret_802_11_enable_rsn(wlan_private * priv,
 520                                           struct cmd_ds_command *resp)
 521 {
 522         struct cmd_ds_802_11_enable_rsn *enable_rsn = &resp->params.enbrsn;
 523         wlan_adapter *adapter = priv->adapter;
 524         u32 * pdata_buf = adapter->cur_cmd->pdata_buf;
 525
 526         lbs_deb_enter(LBS_DEB_CMD);
 527
 528         if (enable_rsn->action == cpu_to_le16(CMD_ACT_GET)) {
 529                 if (pdata_buf)
 530                         *pdata_buf = (u32) le16_to_cpu(enable_rsn->enable);
 531         }
 532
 533         lbs_deb_leave(LBS_DEB_CMD);
 534         return 0;
 535 }
 536
 537 static inline int handle_cmd_response(u16 respcmd,
 538                                       struct cmd_ds_command *resp,
 539                                       wlan_private *priv)
 540 {
 541         int ret = 0;
 542         unsigned long flags;
 543         wlan_adapter *adapter = priv->adapter;
 544
 545         lbs_deb_enter(LBS_DEB_HOST);
 546
 547         switch (respcmd) {
 548         case CMD_RET(CMD_MAC_REG_ACCESS):
 549         case CMD_RET(CMD_BBP_REG_ACCESS):
 550         case CMD_RET(CMD_RF_REG_ACCESS):
 551                 ret = wlan_ret_reg_access(priv, respcmd, resp);
 552                 break;
 553
 554         case CMD_RET(CMD_GET_HW_SPEC):
 555                 ret = wlan_ret_get_hw_spec(priv, resp);
 556                 break;
 557
 558         case CMD_RET(CMD_802_11_SCAN):
 559                 ret = libertas_ret_80211_scan(priv, resp);
 560                 break;
 561
 562         case CMD_RET(CMD_802_11_GET_LOG):
 563                 ret = wlan_ret_get_log(priv, resp);
 564                 break;
 565
 566         case CMD_RET_802_11_ASSOCIATE:
 567         case CMD_RET(CMD_802_11_ASSOCIATE):
 568         case CMD_RET(CMD_802_11_REASSOCIATE):
 569                 ret = libertas_ret_80211_associate(priv, resp);
 570                 break;
 571
 572         case CMD_RET(CMD_802_11_DISASSOCIATE):
 573         case CMD_RET(CMD_802_11_DEAUTHENTICATE):
 574                 ret = libertas_ret_80211_disassociate(priv, resp);
 575                 break;
 576
 577         case CMD_RET(CMD_802_11_AD_HOC_START):
 578         case CMD_RET(CMD_802_11_AD_HOC_JOIN):
 579                 ret = libertas_ret_80211_ad_hoc_start(priv, resp);
 580                 break;
 581
 582         case CMD_RET(CMD_802_11_GET_STAT):
 583                 ret = wlan_ret_802_11_stat(priv, resp);
 584                 break;
 585
 586         case CMD_RET(CMD_802_11_SNMP_MIB):
 587                 ret = wlan_ret_802_11_snmp_mib(priv, resp);
 588                 break;
 589
 590         case CMD_RET(CMD_802_11_RF_TX_POWER):
 591                 ret = wlan_ret_802_11_rf_tx_power(priv, resp);
 592                 break;
 593
 594         case CMD_RET(CMD_802_11_SET_AFC):
 595         case CMD_RET(CMD_802_11_GET_AFC):
 596                 spin_lock_irqsave(&adapter->driver_lock, flags);
 597                 memmove(adapter->cur_cmd->pdata_buf, &resp->params.afc,
 598                         sizeof(struct cmd_ds_802_11_afc));
 599                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 600
 601                 break;
 602
 603         case CMD_RET(CMD_MAC_MULTICAST_ADR):
 604         case CMD_RET(CMD_MAC_CONTROL):
 605         case CMD_RET(CMD_802_11_SET_WEP):
 606         case CMD_RET(CMD_802_11_RESET):
 607         case CMD_RET(CMD_802_11_AUTHENTICATE):
 608         case CMD_RET(CMD_802_11_RADIO_CONTROL):
 609         case CMD_RET(CMD_802_11_BEACON_STOP):
 610                 break;
 611
 612         case CMD_RET(CMD_802_11_ENABLE_RSN):
 613                 ret = libertas_ret_802_11_enable_rsn(priv, resp);
 614                 break;
 615
 616         case CMD_RET(CMD_802_11_DATA_RATE):
 617                 ret = wlan_ret_802_11_data_rate(priv, resp);
 618                 break;
 619         case CMD_RET(CMD_802_11_RATE_ADAPT_RATESET):
 620                 ret = wlan_ret_802_11_rate_adapt_rateset(priv, resp);
 621                 break;
 622         case CMD_RET(CMD_802_11_RF_CHANNEL):
 623                 ret = wlan_ret_802_11_rf_channel(priv, resp);
 624                 break;
 625
 626         case CMD_RET(CMD_802_11_RSSI):
 627                 ret = wlan_ret_802_11_rssi(priv, resp);
 628                 break;
 629
 630         case CMD_RET(CMD_802_11_MAC_ADDRESS):
 631                 ret = wlan_ret_802_11_mac_address(priv, resp);
 632                 break;
 633
 634         case CMD_RET(CMD_802_11_AD_HOC_STOP):
 635                 ret = libertas_ret_80211_ad_hoc_stop(priv, resp);
 636                 break;
 637
 638         case CMD_RET(CMD_802_11_KEY_MATERIAL):
 639                 ret = wlan_ret_802_11_key_material(priv, resp);
 640                 break;
 641
 642         case CMD_RET(CMD_802_11_EEPROM_ACCESS):
 643                 ret = wlan_ret_802_11_eeprom_access(priv, resp);
 644                 break;
 645
 646         case CMD_RET(CMD_802_11D_DOMAIN_INFO):
 647                 ret = libertas_ret_802_11d_domain_info(priv, resp);
 648                 break;
 649
 650         case CMD_RET(CMD_802_11_SLEEP_PARAMS):
 651                 ret = wlan_ret_802_11_sleep_params(priv, resp);
 652                 break;
 653         case CMD_RET(CMD_802_11_INACTIVITY_TIMEOUT):
 654                 spin_lock_irqsave(&adapter->driver_lock, flags);
 655                 *((u16 *) adapter->cur_cmd->pdata_buf) =
 656                     le16_to_cpu(resp->params.inactivity_timeout.timeout);
 657                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 658                 break;
 659
 660         case CMD_RET(CMD_802_11_TPC_CFG):
 661                 spin_lock_irqsave(&adapter->driver_lock, flags);
 662                 memmove(adapter->cur_cmd->pdata_buf, &resp->params.tpccfg,
 663                         sizeof(struct cmd_ds_802_11_tpc_cfg));
 664                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 665                 break;
 666         case CMD_RET(CMD_802_11_LED_GPIO_CTRL):
 667                 spin_lock_irqsave(&adapter->driver_lock, flags);
 668                 memmove(adapter->cur_cmd->pdata_buf, &resp->params.ledgpio,
 669                         sizeof(struct cmd_ds_802_11_led_ctrl));
 670                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 671                 break;
 672         case CMD_RET(CMD_802_11_PWR_CFG):
 673                 spin_lock_irqsave(&adapter->driver_lock, flags);
 674                 memmove(adapter->cur_cmd->pdata_buf, &resp->params.pwrcfg,
 675                         sizeof(struct cmd_ds_802_11_pwr_cfg));
 676                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 677
 678                 break;
 679
 680         case CMD_RET(CMD_GET_TSF):
 681                 spin_lock_irqsave(&adapter->driver_lock, flags);
 682                 memcpy(priv->adapter->cur_cmd->pdata_buf,
 683                        &resp->params.gettsf.tsfvalue, sizeof(u64));
 684                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 685                 break;
 686         case CMD_RET(CMD_BT_ACCESS):
 687                 spin_lock_irqsave(&adapter->driver_lock, flags);
 688                 if (adapter->cur_cmd->pdata_buf)
 689                         memcpy(adapter->cur_cmd->pdata_buf,
 690                                &resp->params.bt.addr1, 2 * ETH_ALEN);
 691                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 692                 break;
 693         case CMD_RET(CMD_FWT_ACCESS):
 694                 spin_lock_irqsave(&adapter->driver_lock, flags);
 695                 if (adapter->cur_cmd->pdata_buf)
 696                         memcpy(adapter->cur_cmd->pdata_buf, &resp->params.fwt,
 697                                sizeof(resp->params.fwt));
 698                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 699                 break;
 700         case CMD_RET(CMD_MESH_ACCESS):
 701                 if (adapter->cur_cmd->pdata_buf)
 702                         memcpy(adapter->cur_cmd->pdata_buf, &resp->params.mesh,
 703                                sizeof(resp->params.mesh));
 704                 break;
 705         default:
 706                 lbs_deb_host("CMD_RESP: unknown cmd response 0x%04x\n",
 707                             resp->command);
 708                 break;
 709         }
 710         lbs_deb_leave(LBS_DEB_HOST);
 711         return ret;
 712 }
 713
 714 int libertas_process_rx_command(wlan_private * priv)
 715 {
 716         u16 respcmd;
 717         struct cmd_ds_command *resp;
 718         wlan_adapter *adapter = priv->adapter;
 719         int ret = 0;
 720         ulong flags;
 721         u16 result;
 722
 723         lbs_deb_enter(LBS_DEB_HOST);
 724
 725         /* Now we got response from FW, cancel the command timer */
 726         del_timer(&adapter->command_timer);
 727
 728         mutex_lock(&adapter->lock);
 729         spin_lock_irqsave(&adapter->driver_lock, flags);
 730
 731         if (!adapter->cur_cmd) {
 732                 lbs_deb_host("CMD_RESP: cur_cmd is NULL\n");
 733                 ret = -1;
 734                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 735                 goto done;
 736         }
 737         resp = (struct cmd_ds_command *)(adapter->cur_cmd->bufvirtualaddr);
 738
 739         respcmd = le16_to_cpu(resp->command);
 740         result = le16_to_cpu(resp->result);
 741
 742         lbs_deb_host("CMD_RESP: response 0x%04x, size %d, jiffies %lu\n",
 743                 respcmd, priv->upld_len, jiffies);
 744         lbs_deb_hex(LBS_DEB_HOST, "CMD_RESP", adapter->cur_cmd->bufvirtualaddr,
 745                     priv->upld_len);
 746
 747         if (!(respcmd & 0x8000)) {
 748                 lbs_deb_host("invalid response!\n");
 749                 adapter->cur_cmd_retcode = -1;
 750                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 751                 adapter->nr_cmd_pending--;
 752                 adapter->cur_cmd = NULL;
 753                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 754                 ret = -1;
 755                 goto done;
 756         }
 757
 758         /* Store the response code to cur_cmd_retcode. */
 759         adapter->cur_cmd_retcode = result;;
 760
 761         if (respcmd == CMD_RET(CMD_802_11_PS_MODE)) {
 762                 struct cmd_ds_802_11_ps_mode *psmode = &resp->params.psmode;
 763                 u16 action = le16_to_cpu(psmode->action);
 764
 765                 lbs_deb_host(
 766                        "CMD_RESP: PS_MODE cmd reply result 0x%x, action 0x%x\n",
 767                        result, action);
 768
 769                 if (result) {
 770                         lbs_deb_host("CMD_RESP: PS command failed with 0x%x\n",
 771                                     result);
 772                         /*
 773                          * We should not re-try enter-ps command in
 774                          * ad-hoc mode. It takes place in
 775                          * libertas_execute_next_command().
 776                          */
 777                         if (adapter->mode == IW_MODE_ADHOC &&
 778                             action == CMD_SUBCMD_ENTER_PS)
 779                                 adapter->psmode = WLAN802_11POWERMODECAM;
 780                 } else if (action == CMD_SUBCMD_ENTER_PS) {
 781                         adapter->needtowakeup = 0;
 782                         adapter->psstate = PS_STATE_AWAKE;
 783
 784                         lbs_deb_host("CMD_RESP: ENTER_PS command response\n");
 785                         if (adapter->connect_status != LIBERTAS_CONNECTED) {
 786                                 /*
 787                                  * When Deauth Event received before Enter_PS command
 788                                  * response, We need to wake up the firmware.
 789                                  */
 790                                 lbs_deb_host(
 791                                        "disconnected, invoking libertas_ps_wakeup\n");
 792
 793                                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 794                                 mutex_unlock(&adapter->lock);
 795                                 libertas_ps_wakeup(priv, 0);
 796                                 mutex_lock(&adapter->lock);
 797                                 spin_lock_irqsave(&adapter->driver_lock, flags);
 798                         }
 799                 } else if (action == CMD_SUBCMD_EXIT_PS) {
 800                         adapter->needtowakeup = 0;
 801                         adapter->psstate = PS_STATE_FULL_POWER;
 802                         lbs_deb_host("CMD_RESP: EXIT_PS command response\n");
 803                 } else {
 804                         lbs_deb_host("CMD_RESP: PS action 0x%X\n", action);
 805                 }
 806
 807                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 808                 adapter->nr_cmd_pending--;
 809                 adapter->cur_cmd = NULL;
 810                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 811
 812                 ret = 0;
 813                 goto done;
 814         }
 815
 816         if (adapter->cur_cmd->cmdflags & CMD_F_HOSTCMD) {
 817                 /* Copy the response back to response buffer */
 818                 memcpy(adapter->cur_cmd->pdata_buf, resp, resp->size);
 819
 820                 adapter->cur_cmd->cmdflags &= ~CMD_F_HOSTCMD;
 821         }
 822
 823         /* If the command is not successful, cleanup and return failure */
 824         if ((result != 0 || !(respcmd & 0x8000))) {
 825                 lbs_deb_host("CMD_RESP: error 0x%04x in command reply 0x%04x\n",
 826                        result, respcmd);
 827                 /*
 828                  * Handling errors here
 829                  */
 830                 switch (respcmd) {
 831                 case CMD_RET(CMD_GET_HW_SPEC):
 832                 case CMD_RET(CMD_802_11_RESET):
 833                         lbs_deb_host("CMD_RESP: reset failed\n");
 834                         break;
 835
 836                 }
 837
 838                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 839                 adapter->nr_cmd_pending--;
 840                 adapter->cur_cmd = NULL;
 841                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 842
 843                 ret = -1;
 844                 goto done;
 845         }
 846
 847         spin_unlock_irqrestore(&adapter->driver_lock, flags);
 848
 849         ret = handle_cmd_response(respcmd, resp, priv);
 850
 851         spin_lock_irqsave(&adapter->driver_lock, flags);
 852         if (adapter->cur_cmd) {
 853                 /* Clean up and Put current command back to cmdfreeq */
 854                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 855                 adapter->nr_cmd_pending--;
 856                 WARN_ON(adapter->nr_cmd_pending > 128);
 857                 adapter->cur_cmd = NULL;
 858         }
 859         spin_unlock_irqrestore(&adapter->driver_lock, flags);
 860
 861 done:
 862         mutex_unlock(&adapter->lock);
 863         lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
 864         return ret;
 865 }
 866
 867 int libertas_process_event(wlan_private * priv)
 868 {
 869         int ret = 0;
 870         wlan_adapter *adapter = priv->adapter;
 871         u32 eventcause;
 872
 873         spin_lock_irq(&adapter->driver_lock);
 874         eventcause = adapter->eventcause;
 875         spin_unlock_irq(&adapter->driver_lock);
 876
 877         lbs_deb_enter(LBS_DEB_CMD);
 878
 879         lbs_deb_cmd("event cause 0x%x\n", eventcause);
 880
 881         switch (eventcause >> SBI_EVENT_CAUSE_SHIFT) {
 882         case MACREG_INT_CODE_LINK_SENSED:
 883                 lbs_deb_cmd("EVENT: MACREG_INT_CODE_LINK_SENSED\n");
 884                 break;
 885
 886         case MACREG_INT_CODE_DEAUTHENTICATED:
 887                 lbs_deb_cmd("EVENT: deauthenticated\n");
 888                 libertas_mac_event_disconnected(priv);
 889                 break;
 890
 891         case MACREG_INT_CODE_DISASSOCIATED:
 892                 lbs_deb_cmd("EVENT: disassociated\n");
 893                 libertas_mac_event_disconnected(priv);
 894                 break;
 895
 896         case MACREG_INT_CODE_LINK_LOSE_NO_SCAN:
 897                 lbs_deb_cmd("EVENT: link lost\n");
 898                 libertas_mac_event_disconnected(priv);
 899                 break;
 900
 901         case MACREG_INT_CODE_PS_SLEEP:
 902                 lbs_deb_cmd("EVENT: sleep\n");
 903
 904                 /* handle unexpected PS SLEEP event */
 905                 if (adapter->psstate == PS_STATE_FULL_POWER) {
 906                         lbs_deb_cmd(
 907                                "EVENT: in FULL POWER mode, ignoreing PS_SLEEP\n");
 908                         break;
 909                 }
 910                 adapter->psstate = PS_STATE_PRE_SLEEP;
 911
 912                 libertas_ps_confirm_sleep(priv, (u16) adapter->psmode);
 913
 914                 break;
 915
 916         case MACREG_INT_CODE_PS_AWAKE:
 917                 lbs_deb_cmd("EVENT: awake\n");
 918
 919                 /* handle unexpected PS AWAKE event */
 920                 if (adapter->psstate == PS_STATE_FULL_POWER) {
 921                         lbs_deb_cmd(
 922                                "EVENT: In FULL POWER mode - ignore PS AWAKE\n");
 923                         break;
 924                 }
 925
 926                 adapter->psstate = PS_STATE_AWAKE;
 927
 928                 if (adapter->needtowakeup) {
 929                         /*
 930                          * wait for the command processing to finish
 931                          * before resuming sending
 932                          * adapter->needtowakeup will be set to FALSE
 933                          * in libertas_ps_wakeup()
 934                          */
 935                         lbs_deb_cmd("waking up ...\n");
 936                         libertas_ps_wakeup(priv, 0);
 937                 }
 938                 break;
 939
 940         case MACREG_INT_CODE_MIC_ERR_UNICAST:
 941                 lbs_deb_cmd("EVENT: UNICAST MIC ERROR\n");
 942                 handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_UNICAST);
 943                 break;
 944
 945         case MACREG_INT_CODE_MIC_ERR_MULTICAST:
 946                 lbs_deb_cmd("EVENT: MULTICAST MIC ERROR\n");
 947                 handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_MULTICAST);
 948                 break;
 949         case MACREG_INT_CODE_MIB_CHANGED:
 950         case MACREG_INT_CODE_INIT_DONE:
 951                 break;
 952
 953         case MACREG_INT_CODE_ADHOC_BCN_LOST:
 954                 lbs_deb_cmd("EVENT: ADHOC beacon lost\n");
 955                 break;
 956
 957         case MACREG_INT_CODE_RSSI_LOW:
 958                 lbs_pr_alert("EVENT: rssi low\n");
 959                 break;
 960         case MACREG_INT_CODE_SNR_LOW:
 961                 lbs_pr_alert("EVENT: snr low\n");
 962                 break;
 963         case MACREG_INT_CODE_MAX_FAIL:
 964                 lbs_pr_alert("EVENT: max fail\n");
 965                 break;
 966         case MACREG_INT_CODE_RSSI_HIGH:
 967                 lbs_pr_alert("EVENT: rssi high\n");
 968                 break;
 969         case MACREG_INT_CODE_SNR_HIGH:
 970                 lbs_pr_alert("EVENT: snr high\n");
 971                 break;
 972
 973         case MACREG_INT_CODE_MESH_AUTO_STARTED:
 974                 lbs_pr_info("EVENT: MESH_AUTO_STARTED\n");
 975                 adapter->connect_status = LIBERTAS_CONNECTED;
 976                 if (priv->mesh_open == 1) {
 977                         netif_wake_queue(priv->mesh_dev);
 978                         netif_carrier_on(priv->mesh_dev);
 979                 }
 980                 adapter->mode = IW_MODE_ADHOC;
 981                 schedule_work(&priv->sync_channel);
 982                 break;
 983
 984         default:
 985                 lbs_pr_alert("EVENT: unknown event id 0x%04x\n",
 986                        eventcause >> SBI_EVENT_CAUSE_SHIFT);
 987                 break;
 988         }
 989
 990         spin_lock_irq(&adapter->driver_lock);
 991         adapter->eventcause = 0;
 992         spin_unlock_irq(&adapter->driver_lock);
 993
 994         lbs_deb_enter_args(LBS_DEB_CMD, "ret %d", ret);
 995         return ret;
 996 }