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         case CMD_RET(CMD_802_11_TX_RATE_QUERY):
 706                 priv->adapter->txrate = resp->params.txrate.txrate;
 707                 break;
 708         default:
 709                 lbs_deb_host("CMD_RESP: unknown cmd response 0x%04x\n",
 710                             resp->command);
 711                 break;
 712         }
 713         lbs_deb_leave(LBS_DEB_HOST);
 714         return ret;
 715 }
 716
 717 int libertas_process_rx_command(wlan_private * priv)
 718 {
 719         u16 respcmd;
 720         struct cmd_ds_command *resp;
 721         wlan_adapter *adapter = priv->adapter;
 722         int ret = 0;
 723         ulong flags;
 724         u16 result;
 725
 726         lbs_deb_enter(LBS_DEB_HOST);
 727
 728         /* Now we got response from FW, cancel the command timer */
 729         del_timer(&adapter->command_timer);
 730
 731         mutex_lock(&adapter->lock);
 732         spin_lock_irqsave(&adapter->driver_lock, flags);
 733
 734         if (!adapter->cur_cmd) {
 735                 lbs_deb_host("CMD_RESP: cur_cmd is NULL\n");
 736                 ret = -1;
 737                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 738                 goto done;
 739         }
 740         resp = (struct cmd_ds_command *)(adapter->cur_cmd->bufvirtualaddr);
 741
 742         respcmd = le16_to_cpu(resp->command);
 743         result = le16_to_cpu(resp->result);
 744
 745         lbs_deb_host("CMD_RESP: response 0x%04x, size %d, jiffies %lu\n",
 746                 respcmd, priv->upld_len, jiffies);
 747         lbs_deb_hex(LBS_DEB_HOST, "CMD_RESP", adapter->cur_cmd->bufvirtualaddr,
 748                     priv->upld_len);
 749
 750         if (!(respcmd & 0x8000)) {
 751                 lbs_deb_host("invalid response!\n");
 752                 adapter->cur_cmd_retcode = -1;
 753                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 754                 adapter->nr_cmd_pending--;
 755                 adapter->cur_cmd = NULL;
 756                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 757                 ret = -1;
 758                 goto done;
 759         }
 760
 761         /* Store the response code to cur_cmd_retcode. */
 762         adapter->cur_cmd_retcode = result;;
 763
 764         if (respcmd == CMD_RET(CMD_802_11_PS_MODE)) {
 765                 struct cmd_ds_802_11_ps_mode *psmode = &resp->params.psmode;
 766                 u16 action = le16_to_cpu(psmode->action);
 767
 768                 lbs_deb_host(
 769                        "CMD_RESP: PS_MODE cmd reply result 0x%x, action 0x%x\n",
 770                        result, action);
 771
 772                 if (result) {
 773                         lbs_deb_host("CMD_RESP: PS command failed with 0x%x\n",
 774                                     result);
 775                         /*
 776                          * We should not re-try enter-ps command in
 777                          * ad-hoc mode. It takes place in
 778                          * libertas_execute_next_command().
 779                          */
 780                         if (adapter->mode == IW_MODE_ADHOC &&
 781                             action == CMD_SUBCMD_ENTER_PS)
 782                                 adapter->psmode = WLAN802_11POWERMODECAM;
 783                 } else if (action == CMD_SUBCMD_ENTER_PS) {
 784                         adapter->needtowakeup = 0;
 785                         adapter->psstate = PS_STATE_AWAKE;
 786
 787                         lbs_deb_host("CMD_RESP: ENTER_PS command response\n");
 788                         if (adapter->connect_status != LIBERTAS_CONNECTED) {
 789                                 /*
 790                                  * When Deauth Event received before Enter_PS command
 791                                  * response, We need to wake up the firmware.
 792                                  */
 793                                 lbs_deb_host(
 794                                        "disconnected, invoking libertas_ps_wakeup\n");
 795
 796                                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 797                                 mutex_unlock(&adapter->lock);
 798                                 libertas_ps_wakeup(priv, 0);
 799                                 mutex_lock(&adapter->lock);
 800                                 spin_lock_irqsave(&adapter->driver_lock, flags);
 801                         }
 802                 } else if (action == CMD_SUBCMD_EXIT_PS) {
 803                         adapter->needtowakeup = 0;
 804                         adapter->psstate = PS_STATE_FULL_POWER;
 805                         lbs_deb_host("CMD_RESP: EXIT_PS command response\n");
 806                 } else {
 807                         lbs_deb_host("CMD_RESP: PS action 0x%X\n", action);
 808                 }
 809
 810                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 811                 adapter->nr_cmd_pending--;
 812                 adapter->cur_cmd = NULL;
 813                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 814
 815                 ret = 0;
 816                 goto done;
 817         }
 818
 819         if (adapter->cur_cmd->cmdflags & CMD_F_HOSTCMD) {
 820                 /* Copy the response back to response buffer */
 821                 memcpy(adapter->cur_cmd->pdata_buf, resp, resp->size);
 822
 823                 adapter->cur_cmd->cmdflags &= ~CMD_F_HOSTCMD;
 824         }
 825
 826         /* If the command is not successful, cleanup and return failure */
 827         if ((result != 0 || !(respcmd & 0x8000))) {
 828                 lbs_deb_host("CMD_RESP: error 0x%04x in command reply 0x%04x\n",
 829                        result, respcmd);
 830                 /*
 831                  * Handling errors here
 832                  */
 833                 switch (respcmd) {
 834                 case CMD_RET(CMD_GET_HW_SPEC):
 835                 case CMD_RET(CMD_802_11_RESET):
 836                         lbs_deb_host("CMD_RESP: reset failed\n");
 837                         break;
 838
 839                 }
 840
 841                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 842                 adapter->nr_cmd_pending--;
 843                 adapter->cur_cmd = NULL;
 844                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 845
 846                 ret = -1;
 847                 goto done;
 848         }
 849
 850         spin_unlock_irqrestore(&adapter->driver_lock, flags);
 851
 852         ret = handle_cmd_response(respcmd, resp, priv);
 853
 854         spin_lock_irqsave(&adapter->driver_lock, flags);
 855         if (adapter->cur_cmd) {
 856                 /* Clean up and Put current command back to cmdfreeq */
 857                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 858                 adapter->nr_cmd_pending--;
 859                 WARN_ON(adapter->nr_cmd_pending > 128);
 860                 adapter->cur_cmd = NULL;
 861         }
 862         spin_unlock_irqrestore(&adapter->driver_lock, flags);
 863
 864 done:
 865         mutex_unlock(&adapter->lock);
 866         lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
 867         return ret;
 868 }
 869
 870 int libertas_process_event(wlan_private * priv)
 871 {
 872         int ret = 0;
 873         wlan_adapter *adapter = priv->adapter;
 874         u32 eventcause;
 875
 876         spin_lock_irq(&adapter->driver_lock);
 877         eventcause = adapter->eventcause;
 878         spin_unlock_irq(&adapter->driver_lock);
 879
 880         lbs_deb_enter(LBS_DEB_CMD);
 881
 882         lbs_deb_cmd("event cause 0x%x\n", eventcause);
 883
 884         switch (eventcause >> SBI_EVENT_CAUSE_SHIFT) {
 885         case MACREG_INT_CODE_LINK_SENSED:
 886                 lbs_deb_cmd("EVENT: MACREG_INT_CODE_LINK_SENSED\n");
 887                 break;
 888
 889         case MACREG_INT_CODE_DEAUTHENTICATED:
 890                 lbs_deb_cmd("EVENT: deauthenticated\n");
 891                 libertas_mac_event_disconnected(priv);
 892                 break;
 893
 894         case MACREG_INT_CODE_DISASSOCIATED:
 895                 lbs_deb_cmd("EVENT: disassociated\n");
 896                 libertas_mac_event_disconnected(priv);
 897                 break;
 898
 899         case MACREG_INT_CODE_LINK_LOSE_NO_SCAN:
 900                 lbs_deb_cmd("EVENT: link lost\n");
 901                 libertas_mac_event_disconnected(priv);
 902                 break;
 903
 904         case MACREG_INT_CODE_PS_SLEEP:
 905                 lbs_deb_cmd("EVENT: sleep\n");
 906
 907                 /* handle unexpected PS SLEEP event */
 908                 if (adapter->psstate == PS_STATE_FULL_POWER) {
 909                         lbs_deb_cmd(
 910                                "EVENT: in FULL POWER mode, ignoreing PS_SLEEP\n");
 911                         break;
 912                 }
 913                 adapter->psstate = PS_STATE_PRE_SLEEP;
 914
 915                 libertas_ps_confirm_sleep(priv, (u16) adapter->psmode);
 916
 917                 break;
 918
 919         case MACREG_INT_CODE_PS_AWAKE:
 920                 lbs_deb_cmd("EVENT: awake\n");
 921
 922                 /* handle unexpected PS AWAKE event */
 923                 if (adapter->psstate == PS_STATE_FULL_POWER) {
 924                         lbs_deb_cmd(
 925                                "EVENT: In FULL POWER mode - ignore PS AWAKE\n");
 926                         break;
 927                 }
 928
 929                 adapter->psstate = PS_STATE_AWAKE;
 930
 931                 if (adapter->needtowakeup) {
 932                         /*
 933                          * wait for the command processing to finish
 934                          * before resuming sending
 935                          * adapter->needtowakeup will be set to FALSE
 936                          * in libertas_ps_wakeup()
 937                          */
 938                         lbs_deb_cmd("waking up ...\n");
 939                         libertas_ps_wakeup(priv, 0);
 940                 }
 941                 break;
 942
 943         case MACREG_INT_CODE_MIC_ERR_UNICAST:
 944                 lbs_deb_cmd("EVENT: UNICAST MIC ERROR\n");
 945                 handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_UNICAST);
 946                 break;
 947
 948         case MACREG_INT_CODE_MIC_ERR_MULTICAST:
 949                 lbs_deb_cmd("EVENT: MULTICAST MIC ERROR\n");
 950                 handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_MULTICAST);
 951                 break;
 952         case MACREG_INT_CODE_MIB_CHANGED:
 953         case MACREG_INT_CODE_INIT_DONE:
 954                 break;
 955
 956         case MACREG_INT_CODE_ADHOC_BCN_LOST:
 957                 lbs_deb_cmd("EVENT: ADHOC beacon lost\n");
 958                 break;
 959
 960         case MACREG_INT_CODE_RSSI_LOW:
 961                 lbs_pr_alert("EVENT: rssi low\n");
 962                 break;
 963         case MACREG_INT_CODE_SNR_LOW:
 964                 lbs_pr_alert("EVENT: snr low\n");
 965                 break;
 966         case MACREG_INT_CODE_MAX_FAIL:
 967                 lbs_pr_alert("EVENT: max fail\n");
 968                 break;
 969         case MACREG_INT_CODE_RSSI_HIGH:
 970                 lbs_pr_alert("EVENT: rssi high\n");
 971                 break;
 972         case MACREG_INT_CODE_SNR_HIGH:
 973                 lbs_pr_alert("EVENT: snr high\n");
 974                 break;
 975
 976         case MACREG_INT_CODE_MESH_AUTO_STARTED:
 977                 lbs_pr_info("EVENT: MESH_AUTO_STARTED\n");
 978                 adapter->connect_status = LIBERTAS_CONNECTED;
 979                 if (priv->mesh_open == 1) {
 980                         netif_wake_queue(priv->mesh_dev);
 981                         netif_carrier_on(priv->mesh_dev);
 982                 }
 983                 adapter->mode = IW_MODE_ADHOC;
 984                 schedule_work(&priv->sync_channel);
 985                 break;
 986
 987         default:
 988                 lbs_pr_alert("EVENT: unknown event id 0x%04x\n",
 989                        eventcause >> SBI_EVENT_CAUSE_SHIFT);
 990                 break;
 991         }
 992
 993         spin_lock_irq(&adapter->driver_lock);
 994         adapter->eventcause = 0;
 995         spin_unlock_irq(&adapter->driver_lock);
 996
 997         lbs_deb_enter_args(LBS_DEB_CMD, "ret %d", ret);
 998         return ret;
 999 }