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