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