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