git.oblomov.eu Git - linux-2.6/blob - drivers/net/wireless/libertas/cmd.c

   1 /**
   2   * This file contains the handling of command.
   3   * It prepares command and sends it to firmware when it is ready.
   4   */
   5
   6 #include <net/iw_handler.h>
   7 #include "host.h"
   8 #include "hostcmd.h"
   9 #include "decl.h"
  10 #include "defs.h"
  11 #include "dev.h"
  12 #include "join.h"
  13 #include "wext.h"
  14
  15 static void cleanup_cmdnode(struct cmd_ctrl_node *ptempnode);
  16
  17 static u16 commands_allowed_in_ps[] = {
  18         CMD_802_11_RSSI,
  19 };
  20
  21 /**
  22  *  @brief This function checks if the commans is allowed
  23  *  in PS mode not.
  24  *
  25  *  @param command the command ID
  26  *  @return        TRUE or FALSE
  27  */
  28 static u8 is_command_allowed_in_ps(__le16 command)
  29 {
  30         int i;
  31
  32         for (i = 0; i < ARRAY_SIZE(commands_allowed_in_ps); i++) {
  33                 if (command == cpu_to_le16(commands_allowed_in_ps[i]))
  34                         return 1;
  35         }
  36
  37         return 0;
  38 }
  39
  40 static int wlan_cmd_hw_spec(wlan_private * priv, struct cmd_ds_command *cmd)
  41 {
  42         struct cmd_ds_get_hw_spec *hwspec = &cmd->params.hwspec;
  43
  44         lbs_deb_enter(LBS_DEB_CMD);
  45
  46         cmd->command = cpu_to_le16(CMD_GET_HW_SPEC);
  47         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_get_hw_spec) + S_DS_GEN);
  48         memcpy(hwspec->permanentaddr, priv->adapter->current_addr, ETH_ALEN);
  49
  50         lbs_deb_leave(LBS_DEB_CMD);
  51         return 0;
  52 }
  53
  54 static int wlan_cmd_802_11_ps_mode(wlan_private * priv,
  55                                    struct cmd_ds_command *cmd,
  56                                    u16 cmd_action)
  57 {
  58         struct cmd_ds_802_11_ps_mode *psm = &cmd->params.psmode;
  59         wlan_adapter *adapter = priv->adapter;
  60
  61         lbs_deb_enter(LBS_DEB_CMD);
  62
  63         cmd->command = cpu_to_le16(CMD_802_11_PS_MODE);
  64         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_ps_mode) +
  65                                 S_DS_GEN);
  66         psm->action = cpu_to_le16(cmd_action);
  67         psm->multipledtim = 0;
  68         switch (cmd_action) {
  69         case CMD_SUBCMD_ENTER_PS:
  70                 lbs_deb_cmd("PS command:" "SubCode- Enter PS\n");
  71                 lbs_deb_cmd("locallisteninterval = %d\n",
  72                        adapter->locallisteninterval);
  73
  74                 psm->locallisteninterval =
  75                     cpu_to_le16(adapter->locallisteninterval);
  76                 psm->nullpktinterval =
  77                     cpu_to_le16(adapter->nullpktinterval);
  78                 psm->multipledtim =
  79                     cpu_to_le16(priv->adapter->multipledtim);
  80                 break;
  81
  82         case CMD_SUBCMD_EXIT_PS:
  83                 lbs_deb_cmd("PS command:" "SubCode- Exit PS\n");
  84                 break;
  85
  86         case CMD_SUBCMD_SLEEP_CONFIRMED:
  87                 lbs_deb_cmd("PS command: SubCode- sleep confirm\n");
  88                 break;
  89
  90         default:
  91                 break;
  92         }
  93
  94         lbs_deb_leave(LBS_DEB_CMD);
  95         return 0;
  96 }
  97
  98 static int wlan_cmd_802_11_inactivity_timeout(wlan_private * priv,
  99                                               struct cmd_ds_command *cmd,
 100                                               u16 cmd_action, void *pdata_buf)
 101 {
 102         u16 *timeout = pdata_buf;
 103
 104         cmd->command = cpu_to_le16(CMD_802_11_INACTIVITY_TIMEOUT);
 105         cmd->size =
 106             cpu_to_le16(sizeof(struct cmd_ds_802_11_inactivity_timeout)
 107                              + S_DS_GEN);
 108
 109         cmd->params.inactivity_timeout.action = cpu_to_le16(cmd_action);
 110
 111         if (cmd_action)
 112                 cmd->params.inactivity_timeout.timeout = cpu_to_le16(*timeout);
 113         else
 114                 cmd->params.inactivity_timeout.timeout = 0;
 115
 116         return 0;
 117 }
 118
 119 static int wlan_cmd_802_11_sleep_params(wlan_private * priv,
 120                                         struct cmd_ds_command *cmd,
 121                                         u16 cmd_action)
 122 {
 123         wlan_adapter *adapter = priv->adapter;
 124         struct cmd_ds_802_11_sleep_params *sp = &cmd->params.sleep_params;
 125
 126         lbs_deb_enter(LBS_DEB_CMD);
 127
 128         cmd->size = cpu_to_le16((sizeof(struct cmd_ds_802_11_sleep_params)) +
 129                                 S_DS_GEN);
 130         cmd->command = cpu_to_le16(CMD_802_11_SLEEP_PARAMS);
 131
 132         if (cmd_action == CMD_ACT_GET) {
 133                 memset(&adapter->sp, 0, sizeof(struct sleep_params));
 134                 memset(sp, 0, sizeof(struct cmd_ds_802_11_sleep_params));
 135                 sp->action = cpu_to_le16(cmd_action);
 136         } else if (cmd_action == CMD_ACT_SET) {
 137                 sp->action = cpu_to_le16(cmd_action);
 138                 sp->error = cpu_to_le16(adapter->sp.sp_error);
 139                 sp->offset = cpu_to_le16(adapter->sp.sp_offset);
 140                 sp->stabletime = cpu_to_le16(adapter->sp.sp_stabletime);
 141                 sp->calcontrol = (u8) adapter->sp.sp_calcontrol;
 142                 sp->externalsleepclk = (u8) adapter->sp.sp_extsleepclk;
 143                 sp->reserved = cpu_to_le16(adapter->sp.sp_reserved);
 144         }
 145
 146         lbs_deb_leave(LBS_DEB_CMD);
 147         return 0;
 148 }
 149
 150 static int wlan_cmd_802_11_set_wep(wlan_private * priv,
 151                                    struct cmd_ds_command *cmd,
 152                                    u32 cmd_act,
 153                                    void * pdata_buf)
 154 {
 155         struct cmd_ds_802_11_set_wep *wep = &cmd->params.wep;
 156         wlan_adapter *adapter = priv->adapter;
 157         int ret = 0;
 158         struct assoc_request * assoc_req = pdata_buf;
 159
 160         lbs_deb_enter(LBS_DEB_CMD);
 161
 162         cmd->command = cpu_to_le16(CMD_802_11_SET_WEP);
 163         cmd->size = cpu_to_le16(sizeof(*wep) + S_DS_GEN);
 164
 165         if (cmd_act == CMD_ACT_ADD) {
 166                 int i;
 167
 168                 if (!assoc_req) {
 169                         lbs_deb_cmd("Invalid association request!");
 170                         ret = -1;
 171                         goto done;
 172                 }
 173
 174                 wep->action = cpu_to_le16(CMD_ACT_ADD);
 175
 176                 /* default tx key index */
 177                 wep->keyindex = cpu_to_le16((u16)(assoc_req->wep_tx_keyidx &
 178                                                   (u32)CMD_WEP_KEY_INDEX_MASK));
 179
 180                 lbs_deb_cmd("Tx key Index: %u\n", le16_to_cpu(wep->keyindex));
 181
 182                 /* Copy key types and material to host command structure */
 183                 for (i = 0; i < 4; i++) {
 184                         struct enc_key * pkey = &assoc_req->wep_keys[i];
 185
 186                         switch (pkey->len) {
 187                         case KEY_LEN_WEP_40:
 188                                 wep->keytype[i] =
 189                                         cpu_to_le16(CMD_TYPE_WEP_40_BIT);
 190                                 memmove(&wep->keymaterial[i], pkey->key,
 191                                         pkey->len);
 192                                 break;
 193                         case KEY_LEN_WEP_104:
 194                                 wep->keytype[i] =
 195                                         cpu_to_le16(CMD_TYPE_WEP_104_BIT);
 196                                 memmove(&wep->keymaterial[i], pkey->key,
 197                                         pkey->len);
 198                                 break;
 199                         case 0:
 200                                 break;
 201                         default:
 202                                 lbs_deb_cmd("Invalid WEP key %d length of %d\n",
 203                                        i, pkey->len);
 204                                 ret = -1;
 205                                 goto done;
 206                                 break;
 207                         }
 208                 }
 209         } else if (cmd_act == CMD_ACT_REMOVE) {
 210                 /* ACT_REMOVE clears _all_ WEP keys */
 211                 wep->action = cpu_to_le16(CMD_ACT_REMOVE);
 212
 213                 /* default tx key index */
 214                 wep->keyindex = cpu_to_le16((u16)(adapter->wep_tx_keyidx &
 215                                                   (u32)CMD_WEP_KEY_INDEX_MASK));
 216         }
 217
 218         ret = 0;
 219
 220 done:
 221         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 222         return ret;
 223 }
 224
 225 static int wlan_cmd_802_11_enable_rsn(wlan_private * priv,
 226                                       struct cmd_ds_command *cmd,
 227                                       u16 cmd_action,
 228                                       void * pdata_buf)
 229 {
 230         struct cmd_ds_802_11_enable_rsn *penableRSN = &cmd->params.enbrsn;
 231         u32 * enable = pdata_buf;
 232
 233         lbs_deb_enter(LBS_DEB_CMD);
 234
 235         cmd->command = cpu_to_le16(CMD_802_11_ENABLE_RSN);
 236         cmd->size = cpu_to_le16(sizeof(*penableRSN) + S_DS_GEN);
 237         penableRSN->action = cpu_to_le16(cmd_action);
 238
 239         if (cmd_action == CMD_ACT_SET) {
 240                 if (*enable)
 241                         penableRSN->enable = cpu_to_le16(CMD_ENABLE_RSN);
 242                 else
 243                         penableRSN->enable = cpu_to_le16(CMD_DISABLE_RSN);
 244         }
 245
 246         lbs_deb_leave(LBS_DEB_CMD);
 247         return 0;
 248 }
 249
 250
 251 static void set_one_wpa_key(struct MrvlIEtype_keyParamSet * pkeyparamset,
 252                             struct enc_key * pkey)
 253 {
 254         if (pkey->flags & KEY_INFO_WPA_ENABLED) {
 255                 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_ENABLED);
 256         }
 257         if (pkey->flags & KEY_INFO_WPA_UNICAST) {
 258                 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_UNICAST);
 259         }
 260         if (pkey->flags & KEY_INFO_WPA_MCAST) {
 261                 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_MCAST);
 262         }
 263
 264         pkeyparamset->type = cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
 265         pkeyparamset->keytypeid = cpu_to_le16(pkey->type);
 266         pkeyparamset->keylen = cpu_to_le16(pkey->len);
 267         memcpy(pkeyparamset->key, pkey->key, pkey->len);
 268         pkeyparamset->length = cpu_to_le16(  sizeof(pkeyparamset->keytypeid)
 269                                                 + sizeof(pkeyparamset->keyinfo)
 270                                                 + sizeof(pkeyparamset->keylen)
 271                                                 + sizeof(pkeyparamset->key));
 272 }
 273
 274 static int wlan_cmd_802_11_key_material(wlan_private * priv,
 275                                         struct cmd_ds_command *cmd,
 276                                         u16 cmd_action,
 277                                         u32 cmd_oid, void *pdata_buf)
 278 {
 279         struct cmd_ds_802_11_key_material *pkeymaterial =
 280             &cmd->params.keymaterial;
 281         struct assoc_request * assoc_req = pdata_buf;
 282         int ret = 0;
 283         int index = 0;
 284
 285         lbs_deb_enter(LBS_DEB_CMD);
 286
 287         cmd->command = cpu_to_le16(CMD_802_11_KEY_MATERIAL);
 288         pkeymaterial->action = cpu_to_le16(cmd_action);
 289
 290         if (cmd_action == CMD_ACT_GET) {
 291                 cmd->size = cpu_to_le16(S_DS_GEN + sizeof (pkeymaterial->action));
 292                 ret = 0;
 293                 goto done;
 294         }
 295
 296         memset(&pkeymaterial->keyParamSet, 0, sizeof(pkeymaterial->keyParamSet));
 297
 298         if (test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
 299                 set_one_wpa_key(&pkeymaterial->keyParamSet[index],
 300                                 &assoc_req->wpa_unicast_key);
 301                 index++;
 302         }
 303
 304         if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
 305                 set_one_wpa_key(&pkeymaterial->keyParamSet[index],
 306                                 &assoc_req->wpa_mcast_key);
 307                 index++;
 308         }
 309
 310         cmd->size = cpu_to_le16(  S_DS_GEN
 311                                 + sizeof (pkeymaterial->action)
 312                                 + (index * sizeof(struct MrvlIEtype_keyParamSet)));
 313
 314         ret = 0;
 315
 316 done:
 317         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 318         return ret;
 319 }
 320
 321 static int wlan_cmd_802_11_reset(wlan_private * priv,
 322                                  struct cmd_ds_command *cmd, int cmd_action)
 323 {
 324         struct cmd_ds_802_11_reset *reset = &cmd->params.reset;
 325
 326         cmd->command = cpu_to_le16(CMD_802_11_RESET);
 327         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset) + S_DS_GEN);
 328         reset->action = cpu_to_le16(cmd_action);
 329
 330         return 0;
 331 }
 332
 333 static int wlan_cmd_802_11_get_log(wlan_private * priv,
 334                                    struct cmd_ds_command *cmd)
 335 {
 336         cmd->command = cpu_to_le16(CMD_802_11_GET_LOG);
 337         cmd->size =
 338                 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_log) + S_DS_GEN);
 339
 340         return 0;
 341 }
 342
 343 static int wlan_cmd_802_11_get_stat(wlan_private * priv,
 344                                     struct cmd_ds_command *cmd)
 345 {
 346         cmd->command = cpu_to_le16(CMD_802_11_GET_STAT);
 347         cmd->size =
 348             cpu_to_le16(sizeof(struct cmd_ds_802_11_get_stat) + S_DS_GEN);
 349
 350         return 0;
 351 }
 352
 353 static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
 354                                     struct cmd_ds_command *cmd,
 355                                     int cmd_action,
 356                                     int cmd_oid, void *pdata_buf)
 357 {
 358         struct cmd_ds_802_11_snmp_mib *pSNMPMIB = &cmd->params.smib;
 359         wlan_adapter *adapter = priv->adapter;
 360         u8 ucTemp;
 361
 362         lbs_deb_enter(LBS_DEB_CMD);
 363
 364         lbs_deb_cmd("SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid);
 365
 366         cmd->command = cpu_to_le16(CMD_802_11_SNMP_MIB);
 367         cmd->size = cpu_to_le16(sizeof(*pSNMPMIB) + S_DS_GEN);
 368
 369         switch (cmd_oid) {
 370         case OID_802_11_INFRASTRUCTURE_MODE:
 371         {
 372                 u8 mode = (u8) (size_t) pdata_buf;
 373                 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
 374                 pSNMPMIB->oid = cpu_to_le16((u16) DESIRED_BSSTYPE_I);
 375                 pSNMPMIB->bufsize = sizeof(u8);
 376                 if (mode == IW_MODE_ADHOC) {
 377                         ucTemp = SNMP_MIB_VALUE_ADHOC;
 378                 } else {
 379                         /* Infra and Auto modes */
 380                         ucTemp = SNMP_MIB_VALUE_INFRA;
 381                 }
 382
 383                 memmove(pSNMPMIB->value, &ucTemp, sizeof(u8));
 384
 385                 break;
 386         }
 387
 388         case OID_802_11D_ENABLE:
 389                 {
 390                         u32 ulTemp;
 391
 392                         pSNMPMIB->oid = cpu_to_le16((u16) DOT11D_I);
 393
 394                         if (cmd_action == CMD_ACT_SET) {
 395                                 pSNMPMIB->querytype = CMD_ACT_SET;
 396                                 pSNMPMIB->bufsize = sizeof(u16);
 397                                 ulTemp = *(u32 *)pdata_buf;
 398                                 *((__le16 *)(pSNMPMIB->value)) =
 399                                     cpu_to_le16((u16) ulTemp);
 400                         }
 401                         break;
 402                 }
 403
 404         case OID_802_11_FRAGMENTATION_THRESHOLD:
 405                 {
 406                         u32 ulTemp;
 407
 408                         pSNMPMIB->oid = cpu_to_le16((u16) FRAGTHRESH_I);
 409
 410                         if (cmd_action == CMD_ACT_GET) {
 411                                 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
 412                         } else if (cmd_action == CMD_ACT_SET) {
 413                                 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
 414                                 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
 415                                 ulTemp = *((u32 *) pdata_buf);
 416                                 *((__le16 *)(pSNMPMIB->value)) =
 417                                     cpu_to_le16((u16) ulTemp);
 418
 419                         }
 420
 421                         break;
 422                 }
 423
 424         case OID_802_11_RTS_THRESHOLD:
 425                 {
 426
 427                         u32 ulTemp;
 428                         pSNMPMIB->oid = le16_to_cpu((u16) RTSTHRESH_I);
 429
 430                         if (cmd_action == CMD_ACT_GET) {
 431                                 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
 432                         } else if (cmd_action == CMD_ACT_SET) {
 433                                 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
 434                                 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
 435                                 ulTemp = *((u32 *)pdata_buf);
 436                                 *(__le16 *)(pSNMPMIB->value) =
 437                                     cpu_to_le16((u16) ulTemp);
 438
 439                         }
 440                         break;
 441                 }
 442         case OID_802_11_TX_RETRYCOUNT:
 443                 pSNMPMIB->oid = cpu_to_le16((u16) SHORT_RETRYLIM_I);
 444
 445                 if (cmd_action == CMD_ACT_GET) {
 446                         pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
 447                 } else if (cmd_action == CMD_ACT_SET) {
 448                         pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
 449                         pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
 450                         *((__le16 *)(pSNMPMIB->value)) =
 451                             cpu_to_le16((u16) adapter->txretrycount);
 452                 }
 453
 454                 break;
 455         default:
 456                 break;
 457         }
 458
 459         lbs_deb_cmd(
 460                "SNMP_CMD: command=0x%x, size=0x%x, seqnum=0x%x, result=0x%x\n",
 461                le16_to_cpu(cmd->command), le16_to_cpu(cmd->size),
 462                le16_to_cpu(cmd->seqnum), le16_to_cpu(cmd->result));
 463
 464         lbs_deb_cmd(
 465                "SNMP_CMD: action=0x%x, oid=0x%x, oidsize=0x%x, value=0x%x\n",
 466                le16_to_cpu(pSNMPMIB->querytype), le16_to_cpu(pSNMPMIB->oid),
 467                le16_to_cpu(pSNMPMIB->bufsize),
 468                le16_to_cpu(*(__le16 *) pSNMPMIB->value));
 469
 470         lbs_deb_leave(LBS_DEB_CMD);
 471         return 0;
 472 }
 473
 474 static int wlan_cmd_802_11_radio_control(wlan_private * priv,
 475                                          struct cmd_ds_command *cmd,
 476                                          int cmd_action)
 477 {
 478         wlan_adapter *adapter = priv->adapter;
 479         struct cmd_ds_802_11_radio_control *pradiocontrol = &cmd->params.radio;
 480
 481         lbs_deb_enter(LBS_DEB_CMD);
 482
 483         cmd->size =
 484             cpu_to_le16((sizeof(struct cmd_ds_802_11_radio_control)) +
 485                              S_DS_GEN);
 486         cmd->command = cpu_to_le16(CMD_802_11_RADIO_CONTROL);
 487
 488         pradiocontrol->action = cpu_to_le16(cmd_action);
 489
 490         switch (adapter->preamble) {
 491         case CMD_TYPE_SHORT_PREAMBLE:
 492                 pradiocontrol->control = cpu_to_le16(SET_SHORT_PREAMBLE);
 493                 break;
 494
 495         case CMD_TYPE_LONG_PREAMBLE:
 496                 pradiocontrol->control = cpu_to_le16(SET_LONG_PREAMBLE);
 497                 break;
 498
 499         case CMD_TYPE_AUTO_PREAMBLE:
 500         default:
 501                 pradiocontrol->control = cpu_to_le16(SET_AUTO_PREAMBLE);
 502                 break;
 503         }
 504
 505         if (adapter->radioon)
 506                 pradiocontrol->control |= cpu_to_le16(TURN_ON_RF);
 507         else
 508                 pradiocontrol->control &= cpu_to_le16(~TURN_ON_RF);
 509
 510         lbs_deb_leave(LBS_DEB_CMD);
 511         return 0;
 512 }
 513
 514 static int wlan_cmd_802_11_rf_tx_power(wlan_private * priv,
 515                                        struct cmd_ds_command *cmd,
 516                                        u16 cmd_action, void *pdata_buf)
 517 {
 518
 519         struct cmd_ds_802_11_rf_tx_power *prtp = &cmd->params.txp;
 520
 521         lbs_deb_enter(LBS_DEB_CMD);
 522
 523         cmd->size =
 524             cpu_to_le16((sizeof(struct cmd_ds_802_11_rf_tx_power)) + S_DS_GEN);
 525         cmd->command = cpu_to_le16(CMD_802_11_RF_TX_POWER);
 526         prtp->action = cpu_to_le16(cmd_action);
 527
 528         lbs_deb_cmd("RF_TX_POWER_CMD: size:%d cmd:0x%x Act:%d\n",
 529                     le16_to_cpu(cmd->size), le16_to_cpu(cmd->command),
 530                     le16_to_cpu(prtp->action));
 531
 532         switch (cmd_action) {
 533         case CMD_ACT_TX_POWER_OPT_GET:
 534                 prtp->action = cpu_to_le16(CMD_ACT_GET);
 535                 prtp->currentlevel = 0;
 536                 break;
 537
 538         case CMD_ACT_TX_POWER_OPT_SET_HIGH:
 539                 prtp->action = cpu_to_le16(CMD_ACT_SET);
 540                 prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_HIGH);
 541                 break;
 542
 543         case CMD_ACT_TX_POWER_OPT_SET_MID:
 544                 prtp->action = cpu_to_le16(CMD_ACT_SET);
 545                 prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_MID);
 546                 break;
 547
 548         case CMD_ACT_TX_POWER_OPT_SET_LOW:
 549                 prtp->action = cpu_to_le16(CMD_ACT_SET);
 550                 prtp->currentlevel = cpu_to_le16(*((u16 *) pdata_buf));
 551                 break;
 552         }
 553
 554         lbs_deb_leave(LBS_DEB_CMD);
 555         return 0;
 556 }
 557
 558 static int wlan_cmd_802_11_rf_antenna(wlan_private * priv,
 559                                       struct cmd_ds_command *cmd,
 560                                       u16 cmd_action, void *pdata_buf)
 561 {
 562         struct cmd_ds_802_11_rf_antenna *rant = &cmd->params.rant;
 563
 564         cmd->command = cpu_to_le16(CMD_802_11_RF_ANTENNA);
 565         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_antenna) +
 566                                 S_DS_GEN);
 567
 568         rant->action = cpu_to_le16(cmd_action);
 569         if ((cmd_action == CMD_ACT_SET_rx) || (cmd_action == CMD_ACT_SET_tx)) {
 570                 rant->antennamode = cpu_to_le16((u16) (*(u32 *) pdata_buf));
 571         }
 572
 573         return 0;
 574 }
 575
 576 static int wlan_cmd_802_11_rate_adapt_rateset(wlan_private * priv,
 577                                               struct cmd_ds_command *cmd,
 578                                               u16 cmd_action)
 579 {
 580         struct cmd_ds_802_11_rate_adapt_rateset
 581         *rateadapt = &cmd->params.rateset;
 582         wlan_adapter *adapter = priv->adapter;
 583
 584         cmd->size =
 585             cpu_to_le16(sizeof(struct cmd_ds_802_11_rate_adapt_rateset)
 586                              + S_DS_GEN);
 587         cmd->command = cpu_to_le16(CMD_802_11_RATE_ADAPT_RATESET);
 588
 589         lbs_deb_enter(LBS_DEB_CMD);
 590
 591         rateadapt->action = cpu_to_le16(cmd_action);
 592         rateadapt->enablehwauto = cpu_to_le16(adapter->enablehwauto);
 593         rateadapt->bitmap = cpu_to_le16(adapter->ratebitmap);
 594
 595         lbs_deb_leave(LBS_DEB_CMD);
 596         return 0;
 597 }
 598
 599 static int wlan_cmd_802_11_data_rate(wlan_private * priv,
 600                                      struct cmd_ds_command *cmd,
 601                                      u16 cmd_action)
 602 {
 603         struct cmd_ds_802_11_data_rate *pdatarate = &cmd->params.drate;
 604         wlan_adapter *adapter = priv->adapter;
 605
 606         lbs_deb_enter(LBS_DEB_CMD);
 607
 608         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_data_rate) +
 609                              S_DS_GEN);
 610
 611         cmd->command = cpu_to_le16(CMD_802_11_DATA_RATE);
 612
 613         memset(pdatarate, 0, sizeof(struct cmd_ds_802_11_data_rate));
 614
 615         pdatarate->action = cpu_to_le16(cmd_action);
 616
 617         if (cmd_action == CMD_ACT_SET_tx_fix_rate) {
 618                 pdatarate->datarate[0] = libertas_data_rate_to_index(adapter->datarate);
 619                 lbs_deb_cmd("Setting FW for fixed rate 0x%02X\n",
 620                        adapter->datarate);
 621         } else if (cmd_action == CMD_ACT_SET_tx_auto) {
 622                 lbs_deb_cmd("Setting FW for AUTO rate\n");
 623         }
 624
 625         lbs_deb_leave(LBS_DEB_CMD);
 626         return 0;
 627 }
 628
 629 static int wlan_cmd_mac_multicast_adr(wlan_private * priv,
 630                                       struct cmd_ds_command *cmd,
 631                                       u16 cmd_action)
 632 {
 633         struct cmd_ds_mac_multicast_adr *pMCastAdr = &cmd->params.madr;
 634         wlan_adapter *adapter = priv->adapter;
 635
 636         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) +
 637                              S_DS_GEN);
 638         cmd->command = cpu_to_le16(CMD_MAC_MULTICAST_ADR);
 639
 640         pMCastAdr->action = cpu_to_le16(cmd_action);
 641         pMCastAdr->nr_of_adrs =
 642             cpu_to_le16((u16) adapter->nr_of_multicastmacaddr);
 643         memcpy(pMCastAdr->maclist, adapter->multicastlist,
 644                adapter->nr_of_multicastmacaddr * ETH_ALEN);
 645
 646         return 0;
 647 }
 648
 649 static int wlan_cmd_802_11_rf_channel(wlan_private * priv,
 650                                       struct cmd_ds_command *cmd,
 651                                       int option, void *pdata_buf)
 652 {
 653         struct cmd_ds_802_11_rf_channel *rfchan = &cmd->params.rfchannel;
 654
 655         cmd->command = cpu_to_le16(CMD_802_11_RF_CHANNEL);
 656         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_channel) +
 657                                 S_DS_GEN);
 658
 659         if (option == CMD_OPT_802_11_RF_CHANNEL_SET) {
 660                 rfchan->currentchannel = cpu_to_le16(*((u16 *) pdata_buf));
 661         }
 662
 663         rfchan->action = cpu_to_le16(option);
 664
 665         return 0;
 666 }
 667
 668 static int wlan_cmd_802_11_rssi(wlan_private * priv,
 669                                 struct cmd_ds_command *cmd)
 670 {
 671         wlan_adapter *adapter = priv->adapter;
 672
 673         cmd->command = cpu_to_le16(CMD_802_11_RSSI);
 674         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rssi) + S_DS_GEN);
 675         cmd->params.rssi.N = cpu_to_le16(priv->adapter->bcn_avg_factor);
 676
 677         /* reset Beacon SNR/NF/RSSI values */
 678         adapter->SNR[TYPE_BEACON][TYPE_NOAVG] = 0;
 679         adapter->SNR[TYPE_BEACON][TYPE_AVG] = 0;
 680         adapter->NF[TYPE_BEACON][TYPE_NOAVG] = 0;
 681         adapter->NF[TYPE_BEACON][TYPE_AVG] = 0;
 682         adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] = 0;
 683         adapter->RSSI[TYPE_BEACON][TYPE_AVG] = 0;
 684
 685         return 0;
 686 }
 687
 688 static int wlan_cmd_reg_access(wlan_private * priv,
 689                                struct cmd_ds_command *cmdptr,
 690                                u8 cmd_action, void *pdata_buf)
 691 {
 692         struct wlan_offset_value *offval;
 693
 694         lbs_deb_enter(LBS_DEB_CMD);
 695
 696         offval = (struct wlan_offset_value *)pdata_buf;
 697
 698         switch (cmdptr->command) {
 699         case CMD_MAC_REG_ACCESS:
 700                 {
 701                         struct cmd_ds_mac_reg_access *macreg;
 702
 703                         cmdptr->size =
 704                             cpu_to_le16(sizeof (struct cmd_ds_mac_reg_access)
 705                                         + S_DS_GEN);
 706                         macreg =
 707                             (struct cmd_ds_mac_reg_access *)&cmdptr->params.
 708                             macreg;
 709
 710                         macreg->action = cpu_to_le16(cmd_action);
 711                         macreg->offset = cpu_to_le16((u16) offval->offset);
 712                         macreg->value = cpu_to_le32(offval->value);
 713
 714                         break;
 715                 }
 716
 717         case CMD_BBP_REG_ACCESS:
 718                 {
 719                         struct cmd_ds_bbp_reg_access *bbpreg;
 720
 721                         cmdptr->size =
 722                             cpu_to_le16(sizeof
 723                                              (struct cmd_ds_bbp_reg_access)
 724                                              + S_DS_GEN);
 725                         bbpreg =
 726                             (struct cmd_ds_bbp_reg_access *)&cmdptr->params.
 727                             bbpreg;
 728
 729                         bbpreg->action = cpu_to_le16(cmd_action);
 730                         bbpreg->offset = cpu_to_le16((u16) offval->offset);
 731                         bbpreg->value = (u8) offval->value;
 732
 733                         break;
 734                 }
 735
 736         case CMD_RF_REG_ACCESS:
 737                 {
 738                         struct cmd_ds_rf_reg_access *rfreg;
 739
 740                         cmdptr->size =
 741                             cpu_to_le16(sizeof
 742                                              (struct cmd_ds_rf_reg_access) +
 743                                              S_DS_GEN);
 744                         rfreg =
 745                             (struct cmd_ds_rf_reg_access *)&cmdptr->params.
 746                             rfreg;
 747
 748                         rfreg->action = cpu_to_le16(cmd_action);
 749                         rfreg->offset = cpu_to_le16((u16) offval->offset);
 750                         rfreg->value = (u8) offval->value;
 751
 752                         break;
 753                 }
 754
 755         default:
 756                 break;
 757         }
 758
 759         lbs_deb_leave(LBS_DEB_CMD);
 760         return 0;
 761 }
 762
 763 static int wlan_cmd_802_11_mac_address(wlan_private * priv,
 764                                        struct cmd_ds_command *cmd,
 765                                        u16 cmd_action)
 766 {
 767         wlan_adapter *adapter = priv->adapter;
 768
 769         cmd->command = cpu_to_le16(CMD_802_11_MAC_ADDRESS);
 770         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_mac_address) +
 771                              S_DS_GEN);
 772         cmd->result = 0;
 773
 774         cmd->params.macadd.action = cpu_to_le16(cmd_action);
 775
 776         if (cmd_action == CMD_ACT_SET) {
 777                 memcpy(cmd->params.macadd.macadd,
 778                        adapter->current_addr, ETH_ALEN);
 779                 lbs_dbg_hex("SET_CMD: MAC ADDRESS-", adapter->current_addr, 6);
 780         }
 781
 782         return 0;
 783 }
 784
 785 static int wlan_cmd_802_11_eeprom_access(wlan_private * priv,
 786                                          struct cmd_ds_command *cmd,
 787                                          int cmd_action, void *pdata_buf)
 788 {
 789         struct wlan_ioctl_regrdwr *ea = pdata_buf;
 790
 791         lbs_deb_enter(LBS_DEB_CMD);
 792
 793         cmd->command = cpu_to_le16(CMD_802_11_EEPROM_ACCESS);
 794         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_eeprom_access) +
 795                                 S_DS_GEN);
 796         cmd->result = 0;
 797
 798         cmd->params.rdeeprom.action = cpu_to_le16(ea->action);
 799         cmd->params.rdeeprom.offset = cpu_to_le16(ea->offset);
 800         cmd->params.rdeeprom.bytecount = cpu_to_le16(ea->NOB);
 801         cmd->params.rdeeprom.value = 0;
 802
 803         return 0;
 804 }
 805
 806 static int wlan_cmd_bt_access(wlan_private * priv,
 807                                struct cmd_ds_command *cmd,
 808                                u16 cmd_action, void *pdata_buf)
 809 {
 810         struct cmd_ds_bt_access *bt_access = &cmd->params.bt;
 811         lbs_deb_cmd("BT CMD(%d)\n", cmd_action);
 812
 813         cmd->command = cpu_to_le16(CMD_BT_ACCESS);
 814         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_bt_access) + S_DS_GEN);
 815         cmd->result = 0;
 816         bt_access->action = cpu_to_le16(cmd_action);
 817
 818         switch (cmd_action) {
 819         case CMD_ACT_BT_ACCESS_ADD:
 820                 memcpy(bt_access->addr1, pdata_buf, 2 * ETH_ALEN);
 821                 lbs_dbg_hex("BT_ADD: blinded mac address-", bt_access->addr1, 6);
 822                 break;
 823         case CMD_ACT_BT_ACCESS_DEL:
 824                 memcpy(bt_access->addr1, pdata_buf, 1 * ETH_ALEN);
 825                 lbs_dbg_hex("BT_DEL: blinded mac address-", bt_access->addr1, 6);
 826                 break;
 827         case CMD_ACT_BT_ACCESS_LIST:
 828                 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
 829                 break;
 830         case CMD_ACT_BT_ACCESS_RESET:
 831                 break;
 832         case CMD_ACT_BT_ACCESS_SET_INVERT:
 833                 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
 834                 break;
 835         case CMD_ACT_BT_ACCESS_GET_INVERT:
 836                 break;
 837         default:
 838                 break;
 839         }
 840         return 0;
 841 }
 842
 843 static int wlan_cmd_fwt_access(wlan_private * priv,
 844                                struct cmd_ds_command *cmd,
 845                                u16 cmd_action, void *pdata_buf)
 846 {
 847         struct cmd_ds_fwt_access *fwt_access = &cmd->params.fwt;
 848         lbs_deb_cmd("FWT CMD(%d)\n", cmd_action);
 849
 850         cmd->command = cpu_to_le16(CMD_FWT_ACCESS);
 851         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access) + S_DS_GEN);
 852         cmd->result = 0;
 853
 854         if (pdata_buf)
 855                 memcpy(fwt_access, pdata_buf, sizeof(*fwt_access));
 856         else
 857                 memset(fwt_access, 0, sizeof(*fwt_access));
 858
 859         fwt_access->action = cpu_to_le16(cmd_action);
 860
 861         return 0;
 862 }
 863
 864 static int wlan_cmd_mesh_access(wlan_private * priv,
 865                                 struct cmd_ds_command *cmd,
 866                                 u16 cmd_action, void *pdata_buf)
 867 {
 868         struct cmd_ds_mesh_access *mesh_access = &cmd->params.mesh;
 869         lbs_deb_cmd("FWT CMD(%d)\n", cmd_action);
 870
 871         cmd->command = cpu_to_le16(CMD_MESH_ACCESS);
 872         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mesh_access) + S_DS_GEN);
 873         cmd->result = 0;
 874
 875         if (pdata_buf)
 876                 memcpy(mesh_access, pdata_buf, sizeof(*mesh_access));
 877         else
 878                 memset(mesh_access, 0, sizeof(*mesh_access));
 879
 880         mesh_access->action = cpu_to_le16(cmd_action);
 881
 882         return 0;
 883 }
 884
 885 void libertas_queue_cmd(wlan_adapter * adapter, struct cmd_ctrl_node *cmdnode, u8 addtail)
 886 {
 887         unsigned long flags;
 888         struct cmd_ds_command *cmdptr;
 889
 890         lbs_deb_enter(LBS_DEB_CMD);
 891
 892         if (!cmdnode) {
 893                 lbs_deb_cmd("QUEUE_CMD: cmdnode is NULL\n");
 894                 goto done;
 895         }
 896
 897         cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr;
 898         if (!cmdptr) {
 899                 lbs_deb_cmd("QUEUE_CMD: cmdptr is NULL\n");
 900                 goto done;
 901         }
 902
 903         /* Exit_PS command needs to be queued in the header always. */
 904         if (cmdptr->command == CMD_802_11_PS_MODE) {
 905                 struct cmd_ds_802_11_ps_mode *psm = &cmdptr->params.psmode;
 906                 if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
 907                         if (adapter->psstate != PS_STATE_FULL_POWER)
 908                                 addtail = 0;
 909                 }
 910         }
 911
 912         spin_lock_irqsave(&adapter->driver_lock, flags);
 913
 914         if (addtail)
 915                 list_add_tail((struct list_head *)cmdnode,
 916                               &adapter->cmdpendingq);
 917         else
 918                 list_add((struct list_head *)cmdnode, &adapter->cmdpendingq);
 919
 920         spin_unlock_irqrestore(&adapter->driver_lock, flags);
 921
 922         lbs_deb_cmd("QUEUE_CMD: Inserted node=%p, cmd=0x%x in cmdpendingq\n",
 923                cmdnode,
 924                le16_to_cpu(((struct cmd_ds_gen*)cmdnode->bufvirtualaddr)->command));
 925
 926 done:
 927         lbs_deb_leave(LBS_DEB_CMD);
 928 }
 929
 930 /*
 931  * TODO: Fix the issue when DownloadcommandToStation is being called the
 932  * second time when the command timesout. All the cmdptr->xxx are in little
 933  * endian and therefore all the comparissions will fail.
 934  * For now - we are not performing the endian conversion the second time - but
 935  * for PS and DEEP_SLEEP we need to worry
 936  */
 937 static int DownloadcommandToStation(wlan_private * priv,
 938                                     struct cmd_ctrl_node *cmdnode)
 939 {
 940         unsigned long flags;
 941         struct cmd_ds_command *cmdptr;
 942         wlan_adapter *adapter = priv->adapter;
 943         int ret = 0;
 944         u16 cmdsize;
 945         u16 command;
 946
 947         lbs_deb_enter(LBS_DEB_CMD);
 948
 949         if (!adapter || !cmdnode) {
 950                 lbs_deb_cmd("DNLD_CMD: adapter = %p, cmdnode = %p\n",
 951                        adapter, cmdnode);
 952                 if (cmdnode) {
 953                         spin_lock_irqsave(&adapter->driver_lock, flags);
 954                         __libertas_cleanup_and_insert_cmd(priv, cmdnode);
 955                         spin_unlock_irqrestore(&adapter->driver_lock, flags);
 956                 }
 957                 ret = -1;
 958                 goto done;
 959         }
 960
 961         cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr;
 962
 963
 964         spin_lock_irqsave(&adapter->driver_lock, flags);
 965         if (!cmdptr || !cmdptr->size) {
 966                 lbs_deb_cmd("DNLD_CMD: cmdptr is Null or cmd size is Zero, "
 967                        "Not sending\n");
 968                 __libertas_cleanup_and_insert_cmd(priv, cmdnode);
 969                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 970                 ret = -1;
 971                 goto done;
 972         }
 973
 974         adapter->cur_cmd = cmdnode;
 975         adapter->cur_cmd_retcode = 0;
 976         spin_unlock_irqrestore(&adapter->driver_lock, flags);
 977         lbs_deb_cmd("DNLD_CMD:: Before download, size of cmd = %d\n",
 978                     le16_to_cpu(cmdptr->size));
 979
 980         cmdsize = cmdptr->size;
 981
 982         command = cpu_to_le16(cmdptr->command);
 983
 984         cmdnode->cmdwaitqwoken = 0;
 985         cmdsize = cpu_to_le16(cmdsize);
 986
 987         ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmdptr, cmdsize);
 988
 989         if (ret != 0) {
 990                 lbs_deb_cmd("DNLD_CMD: Host to Card failed\n");
 991                 spin_lock_irqsave(&adapter->driver_lock, flags);
 992                 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
 993                 adapter->cur_cmd = NULL;
 994                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
 995                 ret = -1;
 996                 goto done;
 997         }
 998
 999         lbs_deb_cmd("DNLD_CMD: Sent command 0x%x @ %lu\n", command, jiffies);
1000         lbs_dbg_hex("DNLD_CMD: command", cmdnode->bufvirtualaddr, cmdsize);
1001
1002         /* Setup the timer after transmit command */
1003         if (command == CMD_802_11_SCAN || command == CMD_802_11_AUTHENTICATE
1004             || command == CMD_802_11_ASSOCIATE)
1005                 mod_timer(&adapter->command_timer, jiffies + (10*HZ));
1006         else
1007                 mod_timer(&adapter->command_timer, jiffies + (5*HZ));
1008
1009         ret = 0;
1010
1011 done:
1012         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1013         return ret;
1014 }
1015
1016 static int wlan_cmd_mac_control(wlan_private * priv,
1017                                 struct cmd_ds_command *cmd)
1018 {
1019         struct cmd_ds_mac_control *mac = &cmd->params.macctrl;
1020
1021         lbs_deb_enter(LBS_DEB_CMD);
1022
1023         cmd->command = cpu_to_le16(CMD_MAC_CONTROL);
1024         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_control) + S_DS_GEN);
1025         mac->action = cpu_to_le16(priv->adapter->currentpacketfilter);
1026
1027         lbs_deb_cmd("wlan_cmd_mac_control(): action=0x%X size=%d\n",
1028                     le16_to_cpu(mac->action), le16_to_cpu(cmd->size));
1029
1030         lbs_deb_leave(LBS_DEB_CMD);
1031         return 0;
1032 }
1033
1034 /**
1035  *  This function inserts command node to cmdfreeq
1036  *  after cleans it. Requires adapter->driver_lock held.
1037  */
1038 void __libertas_cleanup_and_insert_cmd(wlan_private * priv, struct cmd_ctrl_node *ptempcmd)
1039 {
1040         wlan_adapter *adapter = priv->adapter;
1041
1042         if (!ptempcmd)
1043                 goto done;
1044
1045         cleanup_cmdnode(ptempcmd);
1046         list_add_tail((struct list_head *)ptempcmd, &adapter->cmdfreeq);
1047 done:
1048         return;
1049 }
1050
1051 void libertas_cleanup_and_insert_cmd(wlan_private * priv, struct cmd_ctrl_node *ptempcmd)
1052 {
1053         unsigned long flags;
1054
1055         spin_lock_irqsave(&priv->adapter->driver_lock, flags);
1056         __libertas_cleanup_and_insert_cmd(priv, ptempcmd);
1057         spin_unlock_irqrestore(&priv->adapter->driver_lock, flags);
1058 }
1059
1060 int libertas_set_radio_control(wlan_private * priv)
1061 {
1062         int ret = 0;
1063
1064         lbs_deb_enter(LBS_DEB_CMD);
1065
1066         ret = libertas_prepare_and_send_command(priv,
1067                                     CMD_802_11_RADIO_CONTROL,
1068                                     CMD_ACT_SET,
1069                                     CMD_OPTION_WAITFORRSP, 0, NULL);
1070
1071         lbs_deb_cmd("RADIO_SET: on or off: 0x%X, preamble = 0x%X\n",
1072                priv->adapter->radioon, priv->adapter->preamble);
1073
1074         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1075         return ret;
1076 }
1077
1078 int libertas_set_mac_packet_filter(wlan_private * priv)
1079 {
1080         int ret = 0;
1081
1082         lbs_deb_enter(LBS_DEB_CMD);
1083
1084         lbs_deb_cmd("libertas_set_mac_packet_filter value = %x\n",
1085                priv->adapter->currentpacketfilter);
1086
1087         /* Send MAC control command to station */
1088         ret = libertas_prepare_and_send_command(priv,
1089                                     CMD_MAC_CONTROL, 0, 0, 0, NULL);
1090
1091         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1092         return ret;
1093 }
1094
1095 /**
1096  *  @brief This function prepare the command before send to firmware.
1097  *
1098  *  @param priv         A pointer to wlan_private structure
1099  *  @param cmd_no       command number
1100  *  @param cmd_action   command action: GET or SET
1101  *  @param wait_option  wait option: wait response or not
1102  *  @param cmd_oid      cmd oid: treated as sub command
1103  *  @param pdata_buf    A pointer to informaion buffer
1104  *  @return             0 or -1
1105  */
1106 int libertas_prepare_and_send_command(wlan_private * priv,
1107                           u16 cmd_no,
1108                           u16 cmd_action,
1109                           u16 wait_option, u32 cmd_oid, void *pdata_buf)
1110 {
1111         int ret = 0;
1112         wlan_adapter *adapter = priv->adapter;
1113         struct cmd_ctrl_node *cmdnode;
1114         struct cmd_ds_command *cmdptr;
1115         unsigned long flags;
1116
1117         lbs_deb_enter(LBS_DEB_CMD);
1118
1119         if (!adapter) {
1120                 lbs_deb_cmd("PREP_CMD: adapter is Null\n");
1121                 ret = -1;
1122                 goto done;
1123         }
1124
1125         if (adapter->surpriseremoved) {
1126                 lbs_deb_cmd("PREP_CMD: Card is Removed\n");
1127                 ret = -1;
1128                 goto done;
1129         }
1130
1131         cmdnode = libertas_get_free_cmd_ctrl_node(priv);
1132
1133         if (cmdnode == NULL) {
1134                 lbs_deb_cmd("PREP_CMD: No free cmdnode\n");
1135
1136                 /* Wake up main thread to execute next command */
1137                 wake_up_interruptible(&priv->mainthread.waitq);
1138                 ret = -1;
1139                 goto done;
1140         }
1141
1142         libertas_set_cmd_ctrl_node(priv, cmdnode, cmd_oid, wait_option, pdata_buf);
1143
1144         cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr;
1145
1146         lbs_deb_cmd("PREP_CMD: Val of cmd ptr=%p, command=0x%X\n",
1147                cmdptr, cmd_no);
1148
1149         if (!cmdptr) {
1150                 lbs_deb_cmd("PREP_CMD: bufvirtualaddr of cmdnode is NULL\n");
1151                 libertas_cleanup_and_insert_cmd(priv, cmdnode);
1152                 ret = -1;
1153                 goto done;
1154         }
1155
1156         /* Set sequence number, command and INT option */
1157         adapter->seqnum++;
1158         cmdptr->seqnum = cpu_to_le16(adapter->seqnum);
1159
1160         cmdptr->command = cpu_to_le16(cmd_no);
1161         cmdptr->result = 0;
1162
1163         switch (cmd_no) {
1164         case CMD_GET_HW_SPEC:
1165                 ret = wlan_cmd_hw_spec(priv, cmdptr);
1166                 break;
1167         case CMD_802_11_PS_MODE:
1168                 ret = wlan_cmd_802_11_ps_mode(priv, cmdptr, cmd_action);
1169                 break;
1170
1171         case CMD_802_11_SCAN:
1172                 ret = libertas_cmd_80211_scan(priv, cmdptr, pdata_buf);
1173                 break;
1174
1175         case CMD_MAC_CONTROL:
1176                 ret = wlan_cmd_mac_control(priv, cmdptr);
1177                 break;
1178
1179         case CMD_802_11_ASSOCIATE:
1180         case CMD_802_11_REASSOCIATE:
1181                 ret = libertas_cmd_80211_associate(priv, cmdptr, pdata_buf);
1182                 break;
1183
1184         case CMD_802_11_DEAUTHENTICATE:
1185                 ret = libertas_cmd_80211_deauthenticate(priv, cmdptr);
1186                 break;
1187
1188         case CMD_802_11_SET_WEP:
1189                 ret = wlan_cmd_802_11_set_wep(priv, cmdptr, cmd_action, pdata_buf);
1190                 break;
1191
1192         case CMD_802_11_AD_HOC_START:
1193                 ret = libertas_cmd_80211_ad_hoc_start(priv, cmdptr, pdata_buf);
1194                 break;
1195         case CMD_CODE_DNLD:
1196                 break;
1197
1198         case CMD_802_11_RESET:
1199                 ret = wlan_cmd_802_11_reset(priv, cmdptr, cmd_action);
1200                 break;
1201
1202         case CMD_802_11_GET_LOG:
1203                 ret = wlan_cmd_802_11_get_log(priv, cmdptr);
1204                 break;
1205
1206         case CMD_802_11_AUTHENTICATE:
1207                 ret = libertas_cmd_80211_authenticate(priv, cmdptr, pdata_buf);
1208                 break;
1209
1210         case CMD_802_11_GET_STAT:
1211                 ret = wlan_cmd_802_11_get_stat(priv, cmdptr);
1212                 break;
1213
1214         case CMD_802_11_SNMP_MIB:
1215                 ret = wlan_cmd_802_11_snmp_mib(priv, cmdptr,
1216                                                cmd_action, cmd_oid, pdata_buf);
1217                 break;
1218
1219         case CMD_MAC_REG_ACCESS:
1220         case CMD_BBP_REG_ACCESS:
1221         case CMD_RF_REG_ACCESS:
1222                 ret = wlan_cmd_reg_access(priv, cmdptr, cmd_action, pdata_buf);
1223                 break;
1224
1225         case CMD_802_11_RF_CHANNEL:
1226                 ret = wlan_cmd_802_11_rf_channel(priv, cmdptr,
1227                                                  cmd_action, pdata_buf);
1228                 break;
1229
1230         case CMD_802_11_RF_TX_POWER:
1231                 ret = wlan_cmd_802_11_rf_tx_power(priv, cmdptr,
1232                                                   cmd_action, pdata_buf);
1233                 break;
1234
1235         case CMD_802_11_RADIO_CONTROL:
1236                 ret = wlan_cmd_802_11_radio_control(priv, cmdptr, cmd_action);
1237                 break;
1238
1239         case CMD_802_11_RF_ANTENNA:
1240                 ret = wlan_cmd_802_11_rf_antenna(priv, cmdptr,
1241                                                  cmd_action, pdata_buf);
1242                 break;
1243
1244         case CMD_802_11_DATA_RATE:
1245                 ret = wlan_cmd_802_11_data_rate(priv, cmdptr, cmd_action);
1246                 break;
1247         case CMD_802_11_RATE_ADAPT_RATESET:
1248                 ret = wlan_cmd_802_11_rate_adapt_rateset(priv,
1249                                                          cmdptr, cmd_action);
1250                 break;
1251
1252         case CMD_MAC_MULTICAST_ADR:
1253                 ret = wlan_cmd_mac_multicast_adr(priv, cmdptr, cmd_action);
1254                 break;
1255
1256         case CMD_802_11_AD_HOC_JOIN:
1257                 ret = libertas_cmd_80211_ad_hoc_join(priv, cmdptr, pdata_buf);
1258                 break;
1259
1260         case CMD_802_11_RSSI:
1261                 ret = wlan_cmd_802_11_rssi(priv, cmdptr);
1262                 break;
1263
1264         case CMD_802_11_AD_HOC_STOP:
1265                 ret = libertas_cmd_80211_ad_hoc_stop(priv, cmdptr);
1266                 break;
1267
1268         case CMD_802_11_ENABLE_RSN:
1269                 ret = wlan_cmd_802_11_enable_rsn(priv, cmdptr, cmd_action,
1270                                 pdata_buf);
1271                 break;
1272
1273         case CMD_802_11_KEY_MATERIAL:
1274                 ret = wlan_cmd_802_11_key_material(priv, cmdptr, cmd_action,
1275                                 cmd_oid, pdata_buf);
1276                 break;
1277
1278         case CMD_802_11_PAIRWISE_TSC:
1279                 break;
1280         case CMD_802_11_GROUP_TSC:
1281                 break;
1282
1283         case CMD_802_11_MAC_ADDRESS:
1284                 ret = wlan_cmd_802_11_mac_address(priv, cmdptr, cmd_action);
1285                 break;
1286
1287         case CMD_802_11_EEPROM_ACCESS:
1288                 ret = wlan_cmd_802_11_eeprom_access(priv, cmdptr,
1289                                                     cmd_action, pdata_buf);
1290                 break;
1291
1292         case CMD_802_11_SET_AFC:
1293         case CMD_802_11_GET_AFC:
1294
1295                 cmdptr->command = cpu_to_le16(cmd_no);
1296                 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_afc) +
1297                                            S_DS_GEN);
1298
1299                 memmove(&cmdptr->params.afc,
1300                         pdata_buf, sizeof(struct cmd_ds_802_11_afc));
1301
1302                 ret = 0;
1303                 goto done;
1304
1305         case CMD_802_11D_DOMAIN_INFO:
1306                 ret = libertas_cmd_802_11d_domain_info(priv, cmdptr,
1307                                                    cmd_no, cmd_action);
1308                 break;
1309
1310         case CMD_802_11_SLEEP_PARAMS:
1311                 ret = wlan_cmd_802_11_sleep_params(priv, cmdptr, cmd_action);
1312                 break;
1313         case CMD_802_11_INACTIVITY_TIMEOUT:
1314                 ret = wlan_cmd_802_11_inactivity_timeout(priv, cmdptr,
1315                                                          cmd_action, pdata_buf);
1316                 libertas_set_cmd_ctrl_node(priv, cmdnode, 0, 0, pdata_buf);
1317                 break;
1318
1319         case CMD_802_11_TPC_CFG:
1320                 cmdptr->command = cpu_to_le16(CMD_802_11_TPC_CFG);
1321                 cmdptr->size =
1322                     cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) +
1323                                      S_DS_GEN);
1324
1325                 memmove(&cmdptr->params.tpccfg,
1326                         pdata_buf, sizeof(struct cmd_ds_802_11_tpc_cfg));
1327
1328                 ret = 0;
1329                 break;
1330         case CMD_802_11_LED_GPIO_CTRL:
1331                 {
1332                         struct mrvlietypes_ledgpio *gpio =
1333                             (struct mrvlietypes_ledgpio*)
1334                             cmdptr->params.ledgpio.data;
1335
1336                         memmove(&cmdptr->params.ledgpio,
1337                                 pdata_buf,
1338                                 sizeof(struct cmd_ds_802_11_led_ctrl));
1339
1340                         cmdptr->command =
1341                             cpu_to_le16(CMD_802_11_LED_GPIO_CTRL);
1342
1343 #define ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN 8
1344                         cmdptr->size =
1345                             cpu_to_le16(gpio->header.len + S_DS_GEN +
1346                                              ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN);
1347                         gpio->header.len = cpu_to_le16(gpio->header.len);
1348
1349                         ret = 0;
1350                         break;
1351                 }
1352         case CMD_802_11_PWR_CFG:
1353                 cmdptr->command = cpu_to_le16(CMD_802_11_PWR_CFG);
1354                 cmdptr->size =
1355                     cpu_to_le16(sizeof(struct cmd_ds_802_11_pwr_cfg) +
1356                                      S_DS_GEN);
1357                 memmove(&cmdptr->params.pwrcfg, pdata_buf,
1358                         sizeof(struct cmd_ds_802_11_pwr_cfg));
1359
1360                 ret = 0;
1361                 break;
1362         case CMD_BT_ACCESS:
1363                 ret = wlan_cmd_bt_access(priv, cmdptr, cmd_action, pdata_buf);
1364                 break;
1365
1366         case CMD_FWT_ACCESS:
1367                 ret = wlan_cmd_fwt_access(priv, cmdptr, cmd_action, pdata_buf);
1368                 break;
1369
1370         case CMD_MESH_ACCESS:
1371                 ret = wlan_cmd_mesh_access(priv, cmdptr, cmd_action, pdata_buf);
1372                 break;
1373
1374         case CMD_GET_TSF:
1375                 cmdptr->command = cpu_to_le16(CMD_GET_TSF);
1376                 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_get_tsf) +
1377                                            S_DS_GEN);
1378                 ret = 0;
1379                 break;
1380         case CMD_802_11_TX_RATE_QUERY:
1381                 cmdptr->command = cpu_to_le16(CMD_802_11_TX_RATE_QUERY);
1382                 cmdptr->size = cpu_to_le16(sizeof(struct cmd_tx_rate_query) +
1383                                            S_DS_GEN);
1384                 adapter->txrate = 0;
1385                 ret = 0;
1386                 break;
1387         default:
1388                 lbs_deb_cmd("PREP_CMD: unknown command- %#x\n", cmd_no);
1389                 ret = -1;
1390                 break;
1391         }
1392
1393         /* return error, since the command preparation failed */
1394         if (ret != 0) {
1395                 lbs_deb_cmd("PREP_CMD: command preparation failed\n");
1396                 libertas_cleanup_and_insert_cmd(priv, cmdnode);
1397                 ret = -1;
1398                 goto done;
1399         }
1400
1401         cmdnode->cmdwaitqwoken = 0;
1402
1403         libertas_queue_cmd(adapter, cmdnode, 1);
1404         adapter->nr_cmd_pending++;
1405         wake_up_interruptible(&priv->mainthread.waitq);
1406
1407         if (wait_option & CMD_OPTION_WAITFORRSP) {
1408                 lbs_deb_cmd("PREP_CMD: Wait for CMD response\n");
1409                 might_sleep();
1410                 wait_event_interruptible(cmdnode->cmdwait_q,
1411                                          cmdnode->cmdwaitqwoken);
1412         }
1413
1414         spin_lock_irqsave(&adapter->driver_lock, flags);
1415         if (adapter->cur_cmd_retcode) {
1416                 lbs_deb_cmd("PREP_CMD: command failed with return code=%d\n",
1417                        adapter->cur_cmd_retcode);
1418                 adapter->cur_cmd_retcode = 0;
1419                 ret = -1;
1420         }
1421         spin_unlock_irqrestore(&adapter->driver_lock, flags);
1422
1423 done:
1424         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1425         return ret;
1426 }
1427 EXPORT_SYMBOL_GPL(libertas_prepare_and_send_command);
1428
1429 /**
1430  *  @brief This function allocates the command buffer and link
1431  *  it to command free queue.
1432  *
1433  *  @param priv         A pointer to wlan_private structure
1434  *  @return             0 or -1
1435  */
1436 int libertas_allocate_cmd_buffer(wlan_private * priv)
1437 {
1438         int ret = 0;
1439         u32 ulbufsize;
1440         u32 i;
1441         struct cmd_ctrl_node *tempcmd_array;
1442         u8 *ptempvirtualaddr;
1443         wlan_adapter *adapter = priv->adapter;
1444
1445         lbs_deb_enter(LBS_DEB_CMD);
1446
1447         /* Allocate and initialize cmdCtrlNode */
1448         ulbufsize = sizeof(struct cmd_ctrl_node) * MRVDRV_NUM_OF_CMD_BUFFER;
1449
1450         if (!(tempcmd_array = kzalloc(ulbufsize, GFP_KERNEL))) {
1451                 lbs_deb_cmd(
1452                        "ALLOC_CMD_BUF: failed to allocate tempcmd_array\n");
1453                 ret = -1;
1454                 goto done;
1455         }
1456         adapter->cmd_array = tempcmd_array;
1457
1458         /* Allocate and initialize command buffers */
1459         ulbufsize = MRVDRV_SIZE_OF_CMD_BUFFER;
1460         for (i = 0; i < MRVDRV_NUM_OF_CMD_BUFFER; i++) {
1461                 if (!(ptempvirtualaddr = kzalloc(ulbufsize, GFP_KERNEL))) {
1462                         lbs_deb_cmd(
1463                                "ALLOC_CMD_BUF: ptempvirtualaddr: out of memory\n");
1464                         ret = -1;
1465                         goto done;
1466                 }
1467
1468                 /* Update command buffer virtual */
1469                 tempcmd_array[i].bufvirtualaddr = ptempvirtualaddr;
1470         }
1471
1472         for (i = 0; i < MRVDRV_NUM_OF_CMD_BUFFER; i++) {
1473                 init_waitqueue_head(&tempcmd_array[i].cmdwait_q);
1474                 libertas_cleanup_and_insert_cmd(priv, &tempcmd_array[i]);
1475         }
1476
1477         ret = 0;
1478
1479 done:
1480         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1481         return ret;
1482 }
1483
1484 /**
1485  *  @brief This function frees the command buffer.
1486  *
1487  *  @param priv         A pointer to wlan_private structure
1488  *  @return             0 or -1
1489  */
1490 int libertas_free_cmd_buffer(wlan_private * priv)
1491 {
1492         u32 ulbufsize; /* Someone needs to die for this. Slowly and painfully */
1493         unsigned int i;
1494         struct cmd_ctrl_node *tempcmd_array;
1495         wlan_adapter *adapter = priv->adapter;
1496
1497         lbs_deb_enter(LBS_DEB_CMD);
1498
1499         /* need to check if cmd array is allocated or not */
1500         if (adapter->cmd_array == NULL) {
1501                 lbs_deb_cmd("FREE_CMD_BUF: cmd_array is Null\n");
1502                 goto done;
1503         }
1504
1505         tempcmd_array = adapter->cmd_array;
1506
1507         /* Release shared memory buffers */
1508         ulbufsize = MRVDRV_SIZE_OF_CMD_BUFFER;
1509         for (i = 0; i < MRVDRV_NUM_OF_CMD_BUFFER; i++) {
1510                 if (tempcmd_array[i].bufvirtualaddr) {
1511                         lbs_deb_cmd("Free all the array\n");
1512                         kfree(tempcmd_array[i].bufvirtualaddr);
1513                         tempcmd_array[i].bufvirtualaddr = NULL;
1514                 }
1515         }
1516
1517         /* Release cmd_ctrl_node */
1518         if (adapter->cmd_array) {
1519                 lbs_deb_cmd("Free cmd_array\n");
1520                 kfree(adapter->cmd_array);
1521                 adapter->cmd_array = NULL;
1522         }
1523
1524 done:
1525         lbs_deb_leave(LBS_DEB_CMD);
1526         return 0;
1527 }
1528
1529 /**
1530  *  @brief This function gets a free command node if available in
1531  *  command free queue.
1532  *
1533  *  @param priv         A pointer to wlan_private structure
1534  *  @return cmd_ctrl_node A pointer to cmd_ctrl_node structure or NULL
1535  */
1536 struct cmd_ctrl_node *libertas_get_free_cmd_ctrl_node(wlan_private * priv)
1537 {
1538         struct cmd_ctrl_node *tempnode;
1539         wlan_adapter *adapter = priv->adapter;
1540         unsigned long flags;
1541
1542         if (!adapter)
1543                 return NULL;
1544
1545         spin_lock_irqsave(&adapter->driver_lock, flags);
1546
1547         if (!list_empty(&adapter->cmdfreeq)) {
1548                 tempnode = (struct cmd_ctrl_node *)adapter->cmdfreeq.next;
1549                 list_del((struct list_head *)tempnode);
1550         } else {
1551                 lbs_deb_cmd("GET_CMD_NODE: cmd_ctrl_node is not available\n");
1552                 tempnode = NULL;
1553         }
1554
1555         spin_unlock_irqrestore(&adapter->driver_lock, flags);
1556
1557         if (tempnode) {
1558                 /*
1559                 lbs_pr_debug(3, "GET_CMD_NODE: cmdCtrlNode available\n");
1560                 lbs_pr_debug(3, "GET_CMD_NODE: cmdCtrlNode Address = %p\n",
1561                        tempnode);
1562                 */
1563                 cleanup_cmdnode(tempnode);
1564         }
1565
1566         return tempnode;
1567 }
1568
1569 /**
1570  *  @brief This function cleans command node.
1571  *
1572  *  @param ptempnode    A pointer to cmdCtrlNode structure
1573  *  @return             n/a
1574  */
1575 static void cleanup_cmdnode(struct cmd_ctrl_node *ptempnode)
1576 {
1577         if (!ptempnode)
1578                 return;
1579         ptempnode->cmdwaitqwoken = 1;
1580         wake_up_interruptible(&ptempnode->cmdwait_q);
1581         ptempnode->status = 0;
1582         ptempnode->cmd_oid = (u32) 0;
1583         ptempnode->wait_option = 0;
1584         ptempnode->pdata_buf = NULL;
1585
1586         if (ptempnode->bufvirtualaddr != NULL)
1587                 memset(ptempnode->bufvirtualaddr, 0, MRVDRV_SIZE_OF_CMD_BUFFER);
1588         return;
1589 }
1590
1591 /**
1592  *  @brief This function initializes the command node.
1593  *
1594  *  @param priv         A pointer to wlan_private structure
1595  *  @param ptempnode    A pointer to cmd_ctrl_node structure
1596  *  @param cmd_oid      cmd oid: treated as sub command
1597  *  @param wait_option  wait option: wait response or not
1598  *  @param pdata_buf    A pointer to informaion buffer
1599  *  @return             0 or -1
1600  */
1601 void libertas_set_cmd_ctrl_node(wlan_private * priv,
1602                     struct cmd_ctrl_node *ptempnode,
1603                     u32 cmd_oid, u16 wait_option, void *pdata_buf)
1604 {
1605         lbs_deb_enter(LBS_DEB_CMD);
1606
1607         if (!ptempnode)
1608                 return;
1609
1610         ptempnode->cmd_oid = cmd_oid;
1611         ptempnode->wait_option = wait_option;
1612         ptempnode->pdata_buf = pdata_buf;
1613
1614         lbs_deb_leave(LBS_DEB_CMD);
1615 }
1616
1617 /**
1618  *  @brief This function executes next command in command
1619  *  pending queue. It will put fimware back to PS mode
1620  *  if applicable.
1621  *
1622  *  @param priv     A pointer to wlan_private structure
1623  *  @return        0 or -1
1624  */
1625 int libertas_execute_next_command(wlan_private * priv)
1626 {
1627         wlan_adapter *adapter = priv->adapter;
1628         struct cmd_ctrl_node *cmdnode = NULL;
1629         struct cmd_ds_command *cmdptr;
1630         unsigned long flags;
1631         int ret = 0;
1632
1633         lbs_deb_enter(LBS_DEB_CMD);
1634
1635         spin_lock_irqsave(&adapter->driver_lock, flags);
1636
1637         if (adapter->cur_cmd) {
1638                 lbs_pr_alert( "EXEC_NEXT_CMD: there is command in processing!\n");
1639                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
1640                 ret = -1;
1641                 goto done;
1642         }
1643
1644         if (!list_empty(&adapter->cmdpendingq)) {
1645                 cmdnode = (struct cmd_ctrl_node *)
1646                     adapter->cmdpendingq.next;
1647         }
1648
1649         spin_unlock_irqrestore(&adapter->driver_lock, flags);
1650
1651         if (cmdnode) {
1652                 lbs_deb_cmd(
1653                        "EXEC_NEXT_CMD: Got next command from cmdpendingq\n");
1654                 cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr;
1655
1656                 if (is_command_allowed_in_ps(cmdptr->command)) {
1657                         if ((adapter->psstate == PS_STATE_SLEEP) ||
1658                             (adapter->psstate == PS_STATE_PRE_SLEEP)) {
1659                                 lbs_deb_cmd(
1660                                        "EXEC_NEXT_CMD: Cannot send cmd 0x%x in psstate %d\n",
1661                                        le16_to_cpu(cmdptr->command),
1662                                        adapter->psstate);
1663                                 ret = -1;
1664                                 goto done;
1665                         }
1666                         lbs_deb_cmd("EXEC_NEXT_CMD: OK to send command "
1667                                "0x%x in psstate %d\n",
1668                                     le16_to_cpu(cmdptr->command),
1669                                     adapter->psstate);
1670                 } else if (adapter->psstate != PS_STATE_FULL_POWER) {
1671                         /*
1672                          * 1. Non-PS command:
1673                          * Queue it. set needtowakeup to TRUE if current state
1674                          * is SLEEP, otherwise call libertas_ps_wakeup to send Exit_PS.
1675                          * 2. PS command but not Exit_PS:
1676                          * Ignore it.
1677                          * 3. PS command Exit_PS:
1678                          * Set needtowakeup to TRUE if current state is SLEEP,
1679                          * otherwise send this command down to firmware
1680                          * immediately.
1681                          */
1682                         if (cmdptr->command !=
1683                             cpu_to_le16(CMD_802_11_PS_MODE)) {
1684                                 /*  Prepare to send Exit PS,
1685                                  *  this non PS command will be sent later */
1686                                 if ((adapter->psstate == PS_STATE_SLEEP)
1687                                     || (adapter->psstate == PS_STATE_PRE_SLEEP)
1688                                     ) {
1689                                         /* w/ new scheme, it will not reach here.
1690                                            since it is blocked in main_thread. */
1691                                         adapter->needtowakeup = 1;
1692                                 } else
1693                                         libertas_ps_wakeup(priv, 0);
1694
1695                                 ret = 0;
1696                                 goto done;
1697                         } else {
1698                                 /*
1699                                  * PS command. Ignore it if it is not Exit_PS.
1700                                  * otherwise send it down immediately.
1701                                  */
1702                                 struct cmd_ds_802_11_ps_mode *psm =
1703                                     &cmdptr->params.psmode;
1704
1705                                 lbs_deb_cmd(
1706                                        "EXEC_NEXT_CMD: PS cmd- action=0x%x\n",
1707                                        psm->action);
1708                                 if (psm->action !=
1709                                     cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
1710                                         lbs_deb_cmd(
1711                                                "EXEC_NEXT_CMD: Ignore Enter PS cmd\n");
1712                                         list_del((struct list_head *)cmdnode);
1713                                         libertas_cleanup_and_insert_cmd(priv, cmdnode);
1714
1715                                         ret = 0;
1716                                         goto done;
1717                                 }
1718
1719                                 if ((adapter->psstate == PS_STATE_SLEEP) ||
1720                                     (adapter->psstate == PS_STATE_PRE_SLEEP)) {
1721                                         lbs_deb_cmd(
1722                                                "EXEC_NEXT_CMD: Ignore ExitPS cmd in sleep\n");
1723                                         list_del((struct list_head *)cmdnode);
1724                                         libertas_cleanup_and_insert_cmd(priv, cmdnode);
1725                                         adapter->needtowakeup = 1;
1726
1727                                         ret = 0;
1728                                         goto done;
1729                                 }
1730
1731                                 lbs_deb_cmd(
1732                                        "EXEC_NEXT_CMD: Sending Exit_PS down...\n");
1733                         }
1734                 }
1735                 list_del((struct list_head *)cmdnode);
1736                 lbs_deb_cmd("EXEC_NEXT_CMD: Sending 0x%04X command\n",
1737                             le16_to_cpu(cmdptr->command));
1738                 DownloadcommandToStation(priv, cmdnode);
1739         } else {
1740                 /*
1741                  * check if in power save mode, if yes, put the device back
1742                  * to PS mode
1743                  */
1744                 if ((adapter->psmode != WLAN802_11POWERMODECAM) &&
1745                     (adapter->psstate == PS_STATE_FULL_POWER) &&
1746                     (adapter->connect_status == LIBERTAS_CONNECTED)) {
1747                         if (adapter->secinfo.WPAenabled ||
1748                             adapter->secinfo.WPA2enabled) {
1749                                 /* check for valid WPA group keys */
1750                                 if (adapter->wpa_mcast_key.len ||
1751                                     adapter->wpa_unicast_key.len) {
1752                                         lbs_deb_cmd(
1753                                                "EXEC_NEXT_CMD: WPA enabled and GTK_SET"
1754                                                " go back to PS_SLEEP");
1755                                         libertas_ps_sleep(priv, 0);
1756                                 }
1757                         } else {
1758                                 lbs_deb_cmd(
1759                                        "EXEC_NEXT_CMD: command PendQ is empty,"
1760                                        " go back to PS_SLEEP");
1761                                 libertas_ps_sleep(priv, 0);
1762                         }
1763                 }
1764         }
1765
1766         ret = 0;
1767 done:
1768         lbs_deb_leave(LBS_DEB_CMD);
1769         return ret;
1770 }
1771
1772 void libertas_send_iwevcustom_event(wlan_private * priv, s8 * str)
1773 {
1774         union iwreq_data iwrq;
1775         u8 buf[50];
1776
1777         lbs_deb_enter(LBS_DEB_CMD);
1778
1779         memset(&iwrq, 0, sizeof(union iwreq_data));
1780         memset(buf, 0, sizeof(buf));
1781
1782         snprintf(buf, sizeof(buf) - 1, "%s", str);
1783
1784         iwrq.data.length = strlen(buf) + 1 + IW_EV_LCP_LEN;
1785
1786         /* Send Event to upper layer */
1787         lbs_deb_cmd("Event Indication string = %s\n", (char *)buf);
1788         lbs_deb_cmd("Event Indication String length = %d\n", iwrq.data.length);
1789
1790         lbs_deb_cmd("Sending wireless event IWEVCUSTOM for %s\n", str);
1791         wireless_send_event(priv->dev, IWEVCUSTOM, &iwrq, buf);
1792
1793         lbs_deb_leave(LBS_DEB_CMD);
1794 }
1795
1796 static int sendconfirmsleep(wlan_private * priv, u8 * cmdptr, u16 size)
1797 {
1798         unsigned long flags;
1799         wlan_adapter *adapter = priv->adapter;
1800         int ret = 0;
1801
1802         lbs_deb_enter(LBS_DEB_CMD);
1803
1804         lbs_deb_cmd("SEND_SLEEPC_CMD: Before download, size of cmd = %d\n",
1805                size);
1806
1807         lbs_dbg_hex("SEND_SLEEPC_CMD: Sleep confirm command", cmdptr, size);
1808
1809         ret = priv->hw_host_to_card(priv, MVMS_CMD, cmdptr, size);
1810         priv->dnld_sent = DNLD_RES_RECEIVED;
1811
1812         spin_lock_irqsave(&adapter->driver_lock, flags);
1813         if (adapter->intcounter || adapter->currenttxskb)
1814                 lbs_deb_cmd("SEND_SLEEPC_CMD: intcounter=%d currenttxskb=%p\n",
1815                        adapter->intcounter, adapter->currenttxskb);
1816         spin_unlock_irqrestore(&adapter->driver_lock, flags);
1817
1818         if (ret) {
1819                 lbs_pr_alert(
1820                        "SEND_SLEEPC_CMD: Host to Card failed for Confirm Sleep\n");
1821         } else {
1822                 spin_lock_irqsave(&adapter->driver_lock, flags);
1823                 if (!adapter->intcounter) {
1824                         adapter->psstate = PS_STATE_SLEEP;
1825                 } else {
1826                         lbs_deb_cmd("SEND_SLEEPC_CMD: After sent,IntC=%d\n",
1827                                adapter->intcounter);
1828                 }
1829                 spin_unlock_irqrestore(&adapter->driver_lock, flags);
1830
1831                 lbs_deb_cmd("SEND_SLEEPC_CMD: Sent Confirm Sleep command\n");
1832                 lbs_deb_cmd("+");
1833         }
1834
1835         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1836         return ret;
1837 }
1838
1839 void libertas_ps_sleep(wlan_private * priv, int wait_option)
1840 {
1841         lbs_deb_enter(LBS_DEB_CMD);
1842
1843         /*
1844          * PS is currently supported only in Infrastructure mode
1845          * Remove this check if it is to be supported in IBSS mode also
1846          */
1847
1848         libertas_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1849                               CMD_SUBCMD_ENTER_PS, wait_option, 0, NULL);
1850
1851         lbs_deb_leave(LBS_DEB_CMD);
1852 }
1853
1854 /**
1855  *  @brief This function sends Eixt_PS command to firmware.
1856  *
1857  *  @param priv         A pointer to wlan_private structure
1858  *  @param wait_option  wait response or not
1859  *  @return             n/a
1860  */
1861 void libertas_ps_wakeup(wlan_private * priv, int wait_option)
1862 {
1863         __le32 Localpsmode;
1864
1865         lbs_deb_enter(LBS_DEB_CMD);
1866
1867         Localpsmode = cpu_to_le32(WLAN802_11POWERMODECAM);
1868
1869         lbs_deb_cmd("Exit_PS: Localpsmode = %d\n", WLAN802_11POWERMODECAM);
1870
1871         libertas_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1872                               CMD_SUBCMD_EXIT_PS,
1873                               wait_option, 0, &Localpsmode);
1874
1875         lbs_deb_leave(LBS_DEB_CMD);
1876 }
1877
1878 /**
1879  *  @brief This function checks condition and prepares to
1880  *  send sleep confirm command to firmware if ok.
1881  *
1882  *  @param priv         A pointer to wlan_private structure
1883  *  @param psmode       Power Saving mode
1884  *  @return             n/a
1885  */
1886 void libertas_ps_confirm_sleep(wlan_private * priv, u16 psmode)
1887 {
1888         unsigned long flags =0;
1889         wlan_adapter *adapter = priv->adapter;
1890         u8 allowed = 1;
1891
1892         lbs_deb_enter(LBS_DEB_CMD);
1893
1894         if (priv->dnld_sent) {
1895                 allowed = 0;
1896                 lbs_deb_cmd("D");
1897         }
1898
1899         spin_lock_irqsave(&adapter->driver_lock, flags);
1900         if (adapter->cur_cmd) {
1901                 allowed = 0;
1902                 lbs_deb_cmd("C");
1903         }
1904         if (adapter->intcounter > 0) {
1905                 allowed = 0;
1906                 lbs_deb_cmd("I%d", adapter->intcounter);
1907         }
1908         spin_unlock_irqrestore(&adapter->driver_lock, flags);
1909
1910         if (allowed) {
1911                 lbs_deb_cmd("Sending libertas_ps_confirm_sleep\n");
1912                 sendconfirmsleep(priv, (u8 *) & adapter->libertas_ps_confirm_sleep,
1913                                  sizeof(struct PS_CMD_ConfirmSleep));
1914         } else {
1915                 lbs_deb_cmd("Sleep Confirm has been delayed\n");
1916         }
1917
1918         lbs_deb_leave(LBS_DEB_CMD);
1919 }