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 #include "cmd.h"
  15
  16 static struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv);
  17 static void lbs_set_cmd_ctrl_node(struct lbs_private *priv,
  18                     struct cmd_ctrl_node *ptempnode,
  19                     void *pdata_buf);
  20
  21
  22 /**
  23  *  @brief Checks whether a command is allowed in Power Save mode
  24  *
  25  *  @param command the command ID
  26  *  @return        1 if allowed, 0 if not allowed
  27  */
  28 static u8 is_command_allowed_in_ps(u16 cmd)
  29 {
  30         switch (cmd) {
  31         case CMD_802_11_RSSI:
  32                 return 1;
  33         default:
  34                 break;
  35         }
  36         return 0;
  37 }
  38
  39 /**
  40  *  @brief Updates the hardware details like MAC address and regulatory region
  41  *
  42  *  @param priv         A pointer to struct lbs_private structure
  43  *
  44  *  @return             0 on success, error on failure
  45  */
  46 int lbs_update_hw_spec(struct lbs_private *priv)
  47 {
  48         struct cmd_ds_get_hw_spec cmd;
  49         int ret = -1;
  50         u32 i;
  51         DECLARE_MAC_BUF(mac);
  52
  53         lbs_deb_enter(LBS_DEB_CMD);
  54
  55         memset(&cmd, 0, sizeof(cmd));
  56         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
  57         memcpy(cmd.permanentaddr, priv->current_addr, ETH_ALEN);
  58         ret = lbs_cmd_with_response(priv, CMD_GET_HW_SPEC, &cmd);
  59         if (ret)
  60                 goto out;
  61
  62         priv->fwcapinfo = le32_to_cpu(cmd.fwcapinfo);
  63         memcpy(priv->fwreleasenumber, cmd.fwreleasenumber, 4);
  64
  65         lbs_deb_cmd("GET_HW_SPEC: firmware release %u.%u.%up%u\n",
  66                     priv->fwreleasenumber[2], priv->fwreleasenumber[1],
  67                     priv->fwreleasenumber[0], priv->fwreleasenumber[3]);
  68         lbs_deb_cmd("GET_HW_SPEC: MAC addr %s\n",
  69                     print_mac(mac, cmd.permanentaddr));
  70         lbs_deb_cmd("GET_HW_SPEC: hardware interface 0x%x, hardware spec 0x%04x\n",
  71                     cmd.hwifversion, cmd.version);
  72
  73         /* Clamp region code to 8-bit since FW spec indicates that it should
  74          * only ever be 8-bit, even though the field size is 16-bit.  Some firmware
  75          * returns non-zero high 8 bits here.
  76          */
  77         priv->regioncode = le16_to_cpu(cmd.regioncode) & 0xFF;
  78
  79         for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
  80                 /* use the region code to search for the index */
  81                 if (priv->regioncode == lbs_region_code_to_index[i])
  82                         break;
  83         }
  84
  85         /* if it's unidentified region code, use the default (USA) */
  86         if (i >= MRVDRV_MAX_REGION_CODE) {
  87                 priv->regioncode = 0x10;
  88                 lbs_pr_info("unidentified region code; using the default (USA)\n");
  89         }
  90
  91         if (priv->current_addr[0] == 0xff)
  92                 memmove(priv->current_addr, cmd.permanentaddr, ETH_ALEN);
  93
  94         memcpy(priv->dev->dev_addr, priv->current_addr, ETH_ALEN);
  95         if (priv->mesh_dev)
  96                 memcpy(priv->mesh_dev->dev_addr, priv->current_addr, ETH_ALEN);
  97
  98         if (lbs_set_regiontable(priv, priv->regioncode, 0)) {
  99                 ret = -1;
 100                 goto out;
 101         }
 102
 103         if (lbs_set_universaltable(priv, 0)) {
 104                 ret = -1;
 105                 goto out;
 106         }
 107
 108 out:
 109         lbs_deb_leave(LBS_DEB_CMD);
 110         return ret;
 111 }
 112
 113 int lbs_host_sleep_cfg(struct lbs_private *priv, uint32_t criteria)
 114 {
 115         struct cmd_ds_host_sleep cmd_config;
 116         int ret;
 117
 118         cmd_config.hdr.size = cpu_to_le16(sizeof(cmd_config));
 119         cmd_config.criteria = cpu_to_le32(criteria);
 120         cmd_config.gpio = priv->wol_gpio;
 121         cmd_config.gap = priv->wol_gap;
 122
 123         ret = lbs_cmd_with_response(priv, CMD_802_11_HOST_SLEEP_CFG, &cmd_config);
 124         if (!ret) {
 125                 lbs_deb_cmd("Set WOL criteria to %x\n", criteria);
 126                 priv->wol_criteria = criteria;
 127         } else {
 128                 lbs_pr_info("HOST_SLEEP_CFG failed %d\n", ret);
 129         }
 130
 131         return ret;
 132 }
 133 EXPORT_SYMBOL_GPL(lbs_host_sleep_cfg);
 134
 135 static int lbs_cmd_802_11_ps_mode(struct lbs_private *priv,
 136                                    struct cmd_ds_command *cmd,
 137                                    u16 cmd_action)
 138 {
 139         struct cmd_ds_802_11_ps_mode *psm = &cmd->params.psmode;
 140
 141         lbs_deb_enter(LBS_DEB_CMD);
 142
 143         cmd->command = cpu_to_le16(CMD_802_11_PS_MODE);
 144         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_ps_mode) +
 145                                 S_DS_GEN);
 146         psm->action = cpu_to_le16(cmd_action);
 147         psm->multipledtim = 0;
 148         switch (cmd_action) {
 149         case CMD_SUBCMD_ENTER_PS:
 150                 lbs_deb_cmd("PS command:" "SubCode- Enter PS\n");
 151
 152                 psm->locallisteninterval = 0;
 153                 psm->nullpktinterval = 0;
 154                 psm->multipledtim =
 155                     cpu_to_le16(MRVDRV_DEFAULT_MULTIPLE_DTIM);
 156                 break;
 157
 158         case CMD_SUBCMD_EXIT_PS:
 159                 lbs_deb_cmd("PS command:" "SubCode- Exit PS\n");
 160                 break;
 161
 162         case CMD_SUBCMD_SLEEP_CONFIRMED:
 163                 lbs_deb_cmd("PS command: SubCode- sleep confirm\n");
 164                 break;
 165
 166         default:
 167                 break;
 168         }
 169
 170         lbs_deb_leave(LBS_DEB_CMD);
 171         return 0;
 172 }
 173
 174 int lbs_cmd_802_11_inactivity_timeout(struct lbs_private *priv,
 175                                       uint16_t cmd_action, uint16_t *timeout)
 176 {
 177         struct cmd_ds_802_11_inactivity_timeout cmd;
 178         int ret;
 179
 180         lbs_deb_enter(LBS_DEB_CMD);
 181
 182         cmd.hdr.command = cpu_to_le16(CMD_802_11_INACTIVITY_TIMEOUT);
 183         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 184
 185         cmd.action = cpu_to_le16(cmd_action);
 186
 187         if (cmd_action == CMD_ACT_SET)
 188                 cmd.timeout = cpu_to_le16(*timeout);
 189         else
 190                 cmd.timeout = 0;
 191
 192         ret = lbs_cmd_with_response(priv, CMD_802_11_INACTIVITY_TIMEOUT, &cmd);
 193
 194         if (!ret)
 195                 *timeout = le16_to_cpu(cmd.timeout);
 196
 197         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 198         return 0;
 199 }
 200
 201 int lbs_cmd_802_11_sleep_params(struct lbs_private *priv, uint16_t cmd_action,
 202                                 struct sleep_params *sp)
 203 {
 204         struct cmd_ds_802_11_sleep_params cmd;
 205         int ret;
 206
 207         lbs_deb_enter(LBS_DEB_CMD);
 208
 209         if (cmd_action == CMD_ACT_GET) {
 210                 memset(&cmd, 0, sizeof(cmd));
 211         } else {
 212                 cmd.error = cpu_to_le16(sp->sp_error);
 213                 cmd.offset = cpu_to_le16(sp->sp_offset);
 214                 cmd.stabletime = cpu_to_le16(sp->sp_stabletime);
 215                 cmd.calcontrol = sp->sp_calcontrol;
 216                 cmd.externalsleepclk = sp->sp_extsleepclk;
 217                 cmd.reserved = cpu_to_le16(sp->sp_reserved);
 218         }
 219         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 220         cmd.action = cpu_to_le16(cmd_action);
 221
 222         ret = lbs_cmd_with_response(priv, CMD_802_11_SLEEP_PARAMS, &cmd);
 223
 224         if (!ret) {
 225                 lbs_deb_cmd("error 0x%x, offset 0x%x, stabletime 0x%x, "
 226                             "calcontrol 0x%x extsleepclk 0x%x\n",
 227                             le16_to_cpu(cmd.error), le16_to_cpu(cmd.offset),
 228                             le16_to_cpu(cmd.stabletime), cmd.calcontrol,
 229                             cmd.externalsleepclk);
 230
 231                 sp->sp_error = le16_to_cpu(cmd.error);
 232                 sp->sp_offset = le16_to_cpu(cmd.offset);
 233                 sp->sp_stabletime = le16_to_cpu(cmd.stabletime);
 234                 sp->sp_calcontrol = cmd.calcontrol;
 235                 sp->sp_extsleepclk = cmd.externalsleepclk;
 236                 sp->sp_reserved = le16_to_cpu(cmd.reserved);
 237         }
 238
 239         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 240         return 0;
 241 }
 242
 243 int lbs_cmd_802_11_set_wep(struct lbs_private *priv, uint16_t cmd_action,
 244                            struct assoc_request *assoc)
 245 {
 246         struct cmd_ds_802_11_set_wep cmd;
 247         int ret = 0;
 248
 249         lbs_deb_enter(LBS_DEB_CMD);
 250
 251         cmd.hdr.command = cpu_to_le16(CMD_802_11_SET_WEP);
 252         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 253
 254         cmd.action = cpu_to_le16(cmd_action);
 255
 256         if (cmd_action == CMD_ACT_ADD) {
 257                 int i;
 258
 259                 /* default tx key index */
 260                 cmd.keyindex = cpu_to_le16(assoc->wep_tx_keyidx &
 261                                            CMD_WEP_KEY_INDEX_MASK);
 262
 263                 /* Copy key types and material to host command structure */
 264                 for (i = 0; i < 4; i++) {
 265                         struct enc_key *pkey = &assoc->wep_keys[i];
 266
 267                         switch (pkey->len) {
 268                         case KEY_LEN_WEP_40:
 269                                 cmd.keytype[i] = CMD_TYPE_WEP_40_BIT;
 270                                 memmove(cmd.keymaterial[i], pkey->key, pkey->len);
 271                                 lbs_deb_cmd("SET_WEP: add key %d (40 bit)\n", i);
 272                                 break;
 273                         case KEY_LEN_WEP_104:
 274                                 cmd.keytype[i] = CMD_TYPE_WEP_104_BIT;
 275                                 memmove(cmd.keymaterial[i], pkey->key, pkey->len);
 276                                 lbs_deb_cmd("SET_WEP: add key %d (104 bit)\n", i);
 277                                 break;
 278                         case 0:
 279                                 break;
 280                         default:
 281                                 lbs_deb_cmd("SET_WEP: invalid key %d, length %d\n",
 282                                             i, pkey->len);
 283                                 ret = -1;
 284                                 goto done;
 285                                 break;
 286                         }
 287                 }
 288         } else if (cmd_action == CMD_ACT_REMOVE) {
 289                 /* ACT_REMOVE clears _all_ WEP keys */
 290
 291                 /* default tx key index */
 292                 cmd.keyindex = cpu_to_le16(priv->wep_tx_keyidx &
 293                                            CMD_WEP_KEY_INDEX_MASK);
 294                 lbs_deb_cmd("SET_WEP: remove key %d\n", priv->wep_tx_keyidx);
 295         }
 296
 297         ret = lbs_cmd_with_response(priv, CMD_802_11_SET_WEP, &cmd);
 298 done:
 299         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 300         return ret;
 301 }
 302
 303 static int lbs_cmd_802_11_enable_rsn(struct lbs_private *priv,
 304                                       struct cmd_ds_command *cmd,
 305                                       u16 cmd_action,
 306                                       void * pdata_buf)
 307 {
 308         struct cmd_ds_802_11_enable_rsn *penableRSN = &cmd->params.enbrsn;
 309         u32 * enable = pdata_buf;
 310
 311         lbs_deb_enter(LBS_DEB_CMD);
 312
 313         cmd->command = cpu_to_le16(CMD_802_11_ENABLE_RSN);
 314         cmd->size = cpu_to_le16(sizeof(*penableRSN) + S_DS_GEN);
 315         penableRSN->action = cpu_to_le16(cmd_action);
 316
 317         if (cmd_action == CMD_ACT_SET) {
 318                 if (*enable)
 319                         penableRSN->enable = cpu_to_le16(CMD_ENABLE_RSN);
 320                 else
 321                         penableRSN->enable = cpu_to_le16(CMD_DISABLE_RSN);
 322                 lbs_deb_cmd("ENABLE_RSN: %d\n", *enable);
 323         }
 324
 325         lbs_deb_leave(LBS_DEB_CMD);
 326         return 0;
 327 }
 328
 329
 330 static ssize_t lbs_tlv_size(const u8 *tlv, u16 size)
 331 {
 332         ssize_t pos = 0;
 333         struct mrvlietypesheader *tlv_h;
 334         while (pos < size) {
 335                 u16 length;
 336                 tlv_h = (struct mrvlietypesheader *) tlv;
 337                 if (tlv_h->len == 0)
 338                         return pos;
 339                 length = le16_to_cpu(tlv_h->len) +
 340                         sizeof(struct mrvlietypesheader);
 341                 pos += length;
 342                 tlv += length;
 343         }
 344         return pos;
 345 }
 346
 347
 348 static void lbs_cmd_802_11_subscribe_event(struct lbs_private *priv,
 349         struct cmd_ds_command *cmd, u16 cmd_action,
 350         void *pdata_buf)
 351 {
 352         struct cmd_ds_802_11_subscribe_event *events =
 353                 (struct cmd_ds_802_11_subscribe_event *) pdata_buf;
 354
 355         /* pdata_buf points to a struct cmd_ds_802_11_subscribe_event and room
 356          * for various Marvell TLVs */
 357
 358         lbs_deb_enter(LBS_DEB_CMD);
 359
 360         cmd->size = cpu_to_le16(sizeof(*events)
 361                         - sizeof(events->tlv)
 362                         + S_DS_GEN);
 363         cmd->params.subscribe_event.action = cpu_to_le16(cmd_action);
 364         if (cmd_action == CMD_ACT_GET) {
 365                 cmd->params.subscribe_event.events = 0;
 366         } else {
 367                 ssize_t sz = lbs_tlv_size(events->tlv, sizeof(events->tlv));
 368                 cmd->size = cpu_to_le16(le16_to_cpu(cmd->size) + sz);
 369                 cmd->params.subscribe_event.events = events->events;
 370                 memcpy(cmd->params.subscribe_event.tlv, events->tlv, sz);
 371         }
 372
 373         lbs_deb_leave(LBS_DEB_CMD);
 374 }
 375
 376 static void set_one_wpa_key(struct MrvlIEtype_keyParamSet * pkeyparamset,
 377                             struct enc_key * pkey)
 378 {
 379         lbs_deb_enter(LBS_DEB_CMD);
 380
 381         if (pkey->flags & KEY_INFO_WPA_ENABLED) {
 382                 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_ENABLED);
 383         }
 384         if (pkey->flags & KEY_INFO_WPA_UNICAST) {
 385                 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_UNICAST);
 386         }
 387         if (pkey->flags & KEY_INFO_WPA_MCAST) {
 388                 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_MCAST);
 389         }
 390
 391         pkeyparamset->type = cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
 392         pkeyparamset->keytypeid = cpu_to_le16(pkey->type);
 393         pkeyparamset->keylen = cpu_to_le16(pkey->len);
 394         memcpy(pkeyparamset->key, pkey->key, pkey->len);
 395         pkeyparamset->length = cpu_to_le16(  sizeof(pkeyparamset->keytypeid)
 396                                                 + sizeof(pkeyparamset->keyinfo)
 397                                                 + sizeof(pkeyparamset->keylen)
 398                                                 + sizeof(pkeyparamset->key));
 399         lbs_deb_leave(LBS_DEB_CMD);
 400 }
 401
 402 static int lbs_cmd_802_11_key_material(struct lbs_private *priv,
 403                                         struct cmd_ds_command *cmd,
 404                                         u16 cmd_action,
 405                                         u32 cmd_oid, void *pdata_buf)
 406 {
 407         struct cmd_ds_802_11_key_material *pkeymaterial =
 408             &cmd->params.keymaterial;
 409         struct assoc_request * assoc_req = pdata_buf;
 410         int ret = 0;
 411         int index = 0;
 412
 413         lbs_deb_enter(LBS_DEB_CMD);
 414
 415         cmd->command = cpu_to_le16(CMD_802_11_KEY_MATERIAL);
 416         pkeymaterial->action = cpu_to_le16(cmd_action);
 417
 418         if (cmd_action == CMD_ACT_GET) {
 419                 cmd->size = cpu_to_le16(S_DS_GEN + sizeof (pkeymaterial->action));
 420                 ret = 0;
 421                 goto done;
 422         }
 423
 424         memset(&pkeymaterial->keyParamSet, 0, sizeof(pkeymaterial->keyParamSet));
 425
 426         if (test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
 427                 set_one_wpa_key(&pkeymaterial->keyParamSet[index],
 428                                 &assoc_req->wpa_unicast_key);
 429                 index++;
 430         }
 431
 432         if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
 433                 set_one_wpa_key(&pkeymaterial->keyParamSet[index],
 434                                 &assoc_req->wpa_mcast_key);
 435                 index++;
 436         }
 437
 438         cmd->size = cpu_to_le16(  S_DS_GEN
 439                                 + sizeof (pkeymaterial->action)
 440                                 + (index * sizeof(struct MrvlIEtype_keyParamSet)));
 441
 442         ret = 0;
 443
 444 done:
 445         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 446         return ret;
 447 }
 448
 449 static int lbs_cmd_802_11_reset(struct lbs_private *priv,
 450                                  struct cmd_ds_command *cmd, int cmd_action)
 451 {
 452         struct cmd_ds_802_11_reset *reset = &cmd->params.reset;
 453
 454         lbs_deb_enter(LBS_DEB_CMD);
 455
 456         cmd->command = cpu_to_le16(CMD_802_11_RESET);
 457         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset) + S_DS_GEN);
 458         reset->action = cpu_to_le16(cmd_action);
 459
 460         lbs_deb_leave(LBS_DEB_CMD);
 461         return 0;
 462 }
 463
 464 static int lbs_cmd_802_11_get_log(struct lbs_private *priv,
 465                                    struct cmd_ds_command *cmd)
 466 {
 467         lbs_deb_enter(LBS_DEB_CMD);
 468         cmd->command = cpu_to_le16(CMD_802_11_GET_LOG);
 469         cmd->size =
 470                 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_log) + S_DS_GEN);
 471
 472         lbs_deb_leave(LBS_DEB_CMD);
 473         return 0;
 474 }
 475
 476 static int lbs_cmd_802_11_get_stat(struct lbs_private *priv,
 477                                     struct cmd_ds_command *cmd)
 478 {
 479         lbs_deb_enter(LBS_DEB_CMD);
 480         cmd->command = cpu_to_le16(CMD_802_11_GET_STAT);
 481         cmd->size =
 482             cpu_to_le16(sizeof(struct cmd_ds_802_11_get_stat) + S_DS_GEN);
 483
 484         lbs_deb_leave(LBS_DEB_CMD);
 485         return 0;
 486 }
 487
 488 static int lbs_cmd_802_11_snmp_mib(struct lbs_private *priv,
 489                                     struct cmd_ds_command *cmd,
 490                                     int cmd_action,
 491                                     int cmd_oid, void *pdata_buf)
 492 {
 493         struct cmd_ds_802_11_snmp_mib *pSNMPMIB = &cmd->params.smib;
 494         u8 ucTemp;
 495
 496         lbs_deb_enter(LBS_DEB_CMD);
 497
 498         lbs_deb_cmd("SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid);
 499
 500         cmd->command = cpu_to_le16(CMD_802_11_SNMP_MIB);
 501         cmd->size = cpu_to_le16(sizeof(*pSNMPMIB) + S_DS_GEN);
 502
 503         switch (cmd_oid) {
 504         case OID_802_11_INFRASTRUCTURE_MODE:
 505         {
 506                 u8 mode = (u8) (size_t) pdata_buf;
 507                 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
 508                 pSNMPMIB->oid = cpu_to_le16((u16) DESIRED_BSSTYPE_I);
 509                 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u8));
 510                 if (mode == IW_MODE_ADHOC) {
 511                         ucTemp = SNMP_MIB_VALUE_ADHOC;
 512                 } else {
 513                         /* Infra and Auto modes */
 514                         ucTemp = SNMP_MIB_VALUE_INFRA;
 515                 }
 516
 517                 memmove(pSNMPMIB->value, &ucTemp, sizeof(u8));
 518
 519                 break;
 520         }
 521
 522         case OID_802_11D_ENABLE:
 523                 {
 524                         u32 ulTemp;
 525
 526                         pSNMPMIB->oid = cpu_to_le16((u16) DOT11D_I);
 527
 528                         if (cmd_action == CMD_ACT_SET) {
 529                                 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
 530                                 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
 531                                 ulTemp = *(u32 *)pdata_buf;
 532                                 *((__le16 *)(pSNMPMIB->value)) =
 533                                     cpu_to_le16((u16) ulTemp);
 534                         }
 535                         break;
 536                 }
 537
 538         case OID_802_11_FRAGMENTATION_THRESHOLD:
 539                 {
 540                         u32 ulTemp;
 541
 542                         pSNMPMIB->oid = cpu_to_le16((u16) FRAGTHRESH_I);
 543
 544                         if (cmd_action == CMD_ACT_GET) {
 545                                 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
 546                         } else if (cmd_action == CMD_ACT_SET) {
 547                                 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
 548                                 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
 549                                 ulTemp = *((u32 *) pdata_buf);
 550                                 *((__le16 *)(pSNMPMIB->value)) =
 551                                     cpu_to_le16((u16) ulTemp);
 552
 553                         }
 554
 555                         break;
 556                 }
 557
 558         case OID_802_11_RTS_THRESHOLD:
 559                 {
 560
 561                         u32 ulTemp;
 562                         pSNMPMIB->oid = cpu_to_le16(RTSTHRESH_I);
 563
 564                         if (cmd_action == CMD_ACT_GET) {
 565                                 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
 566                         } else if (cmd_action == CMD_ACT_SET) {
 567                                 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
 568                                 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
 569                                 ulTemp = *((u32 *)pdata_buf);
 570                                 *(__le16 *)(pSNMPMIB->value) =
 571                                     cpu_to_le16((u16) ulTemp);
 572
 573                         }
 574                         break;
 575                 }
 576         case OID_802_11_TX_RETRYCOUNT:
 577                 pSNMPMIB->oid = cpu_to_le16((u16) SHORT_RETRYLIM_I);
 578
 579                 if (cmd_action == CMD_ACT_GET) {
 580                         pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
 581                 } else if (cmd_action == CMD_ACT_SET) {
 582                         pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
 583                         pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
 584                         *((__le16 *)(pSNMPMIB->value)) =
 585                             cpu_to_le16((u16) priv->txretrycount);
 586                 }
 587
 588                 break;
 589         default:
 590                 break;
 591         }
 592
 593         lbs_deb_cmd(
 594                "SNMP_CMD: command=0x%x, size=0x%x, seqnum=0x%x, result=0x%x\n",
 595                le16_to_cpu(cmd->command), le16_to_cpu(cmd->size),
 596                le16_to_cpu(cmd->seqnum), le16_to_cpu(cmd->result));
 597
 598         lbs_deb_cmd(
 599                "SNMP_CMD: action 0x%x, oid 0x%x, oidsize 0x%x, value 0x%x\n",
 600                le16_to_cpu(pSNMPMIB->querytype), le16_to_cpu(pSNMPMIB->oid),
 601                le16_to_cpu(pSNMPMIB->bufsize),
 602                le16_to_cpu(*(__le16 *) pSNMPMIB->value));
 603
 604         lbs_deb_leave(LBS_DEB_CMD);
 605         return 0;
 606 }
 607
 608 static int lbs_cmd_802_11_rf_tx_power(struct lbs_private *priv,
 609                                        struct cmd_ds_command *cmd,
 610                                        u16 cmd_action, void *pdata_buf)
 611 {
 612
 613         struct cmd_ds_802_11_rf_tx_power *prtp = &cmd->params.txp;
 614
 615         lbs_deb_enter(LBS_DEB_CMD);
 616
 617         cmd->size =
 618             cpu_to_le16((sizeof(struct cmd_ds_802_11_rf_tx_power)) + S_DS_GEN);
 619         cmd->command = cpu_to_le16(CMD_802_11_RF_TX_POWER);
 620         prtp->action = cpu_to_le16(cmd_action);
 621
 622         lbs_deb_cmd("RF_TX_POWER_CMD: size:%d cmd:0x%x Act:%d\n",
 623                     le16_to_cpu(cmd->size), le16_to_cpu(cmd->command),
 624                     le16_to_cpu(prtp->action));
 625
 626         switch (cmd_action) {
 627         case CMD_ACT_TX_POWER_OPT_GET:
 628                 prtp->action = cpu_to_le16(CMD_ACT_GET);
 629                 prtp->currentlevel = 0;
 630                 break;
 631
 632         case CMD_ACT_TX_POWER_OPT_SET_HIGH:
 633                 prtp->action = cpu_to_le16(CMD_ACT_SET);
 634                 prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_HIGH);
 635                 break;
 636
 637         case CMD_ACT_TX_POWER_OPT_SET_MID:
 638                 prtp->action = cpu_to_le16(CMD_ACT_SET);
 639                 prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_MID);
 640                 break;
 641
 642         case CMD_ACT_TX_POWER_OPT_SET_LOW:
 643                 prtp->action = cpu_to_le16(CMD_ACT_SET);
 644                 prtp->currentlevel = cpu_to_le16(*((u16 *) pdata_buf));
 645                 break;
 646         }
 647
 648         lbs_deb_leave(LBS_DEB_CMD);
 649         return 0;
 650 }
 651
 652 static int lbs_cmd_802_11_monitor_mode(struct lbs_private *priv,
 653                                       struct cmd_ds_command *cmd,
 654                                       u16 cmd_action, void *pdata_buf)
 655 {
 656         struct cmd_ds_802_11_monitor_mode *monitor = &cmd->params.monitor;
 657
 658         cmd->command = cpu_to_le16(CMD_802_11_MONITOR_MODE);
 659         cmd->size =
 660             cpu_to_le16(sizeof(struct cmd_ds_802_11_monitor_mode) +
 661                              S_DS_GEN);
 662
 663         monitor->action = cpu_to_le16(cmd_action);
 664         if (cmd_action == CMD_ACT_SET) {
 665                 monitor->mode =
 666                     cpu_to_le16((u16) (*(u32 *) pdata_buf));
 667         }
 668
 669         return 0;
 670 }
 671
 672 static int lbs_cmd_802_11_rate_adapt_rateset(struct lbs_private *priv,
 673                                               struct cmd_ds_command *cmd,
 674                                               u16 cmd_action)
 675 {
 676         struct cmd_ds_802_11_rate_adapt_rateset
 677         *rateadapt = &cmd->params.rateset;
 678
 679         lbs_deb_enter(LBS_DEB_CMD);
 680         cmd->size =
 681             cpu_to_le16(sizeof(struct cmd_ds_802_11_rate_adapt_rateset)
 682                              + S_DS_GEN);
 683         cmd->command = cpu_to_le16(CMD_802_11_RATE_ADAPT_RATESET);
 684
 685         rateadapt->action = cpu_to_le16(cmd_action);
 686         rateadapt->enablehwauto = cpu_to_le16(priv->enablehwauto);
 687         rateadapt->bitmap = cpu_to_le16(priv->ratebitmap);
 688
 689         lbs_deb_leave(LBS_DEB_CMD);
 690         return 0;
 691 }
 692
 693 /**
 694  *  @brief Get the current data rate
 695  *
 696  *  @param priv         A pointer to struct lbs_private structure
 697  *
 698  *  @return             The data rate on success, error on failure
 699  */
 700 int lbs_get_data_rate(struct lbs_private *priv)
 701 {
 702         struct cmd_ds_802_11_data_rate cmd;
 703         int ret = -1;
 704
 705         lbs_deb_enter(LBS_DEB_CMD);
 706
 707         memset(&cmd, 0, sizeof(cmd));
 708         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 709         cmd.action = cpu_to_le16(CMD_ACT_GET_TX_RATE);
 710
 711         ret = lbs_cmd_with_response(priv, CMD_802_11_DATA_RATE, &cmd);
 712         if (ret)
 713                 goto out;
 714
 715         lbs_deb_hex(LBS_DEB_CMD, "DATA_RATE_RESP", (u8 *) &cmd, sizeof (cmd));
 716
 717         ret = (int) lbs_fw_index_to_data_rate(cmd.rates[0]);
 718         lbs_deb_cmd("DATA_RATE: current rate 0x%02x\n", ret);
 719
 720 out:
 721         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 722         return ret;
 723 }
 724
 725 /**
 726  *  @brief Set the data rate
 727  *
 728  *  @param priv         A pointer to struct lbs_private structure
 729  *  @param rate         The desired data rate, or 0 to clear a locked rate
 730  *
 731  *  @return             0 on success, error on failure
 732  */
 733 int lbs_set_data_rate(struct lbs_private *priv, u8 rate)
 734 {
 735         struct cmd_ds_802_11_data_rate cmd;
 736         int ret = 0;
 737
 738         lbs_deb_enter(LBS_DEB_CMD);
 739
 740         memset(&cmd, 0, sizeof(cmd));
 741         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 742
 743         if (rate > 0) {
 744                 cmd.action = cpu_to_le16(CMD_ACT_SET_TX_FIX_RATE);
 745                 cmd.rates[0] = lbs_data_rate_to_fw_index(rate);
 746                 if (cmd.rates[0] == 0) {
 747                         lbs_deb_cmd("DATA_RATE: invalid requested rate of"
 748                                     " 0x%02X\n", rate);
 749                         ret = 0;
 750                         goto out;
 751                 }
 752                 lbs_deb_cmd("DATA_RATE: set fixed 0x%02X\n", cmd.rates[0]);
 753         } else {
 754                 cmd.action = cpu_to_le16(CMD_ACT_SET_TX_AUTO);
 755                 lbs_deb_cmd("DATA_RATE: setting auto\n");
 756         }
 757
 758         ret = lbs_cmd_with_response(priv, CMD_802_11_DATA_RATE, &cmd);
 759         if (ret)
 760                 goto out;
 761
 762         lbs_deb_hex(LBS_DEB_CMD, "DATA_RATE_RESP", (u8 *) &cmd, sizeof (cmd));
 763
 764         /* FIXME: get actual rates FW can do if this command actually returns
 765          * all data rates supported.
 766          */
 767         priv->cur_rate = lbs_fw_index_to_data_rate(cmd.rates[0]);
 768         lbs_deb_cmd("DATA_RATE: current rate is 0x%02x\n", priv->cur_rate);
 769
 770 out:
 771         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 772         return ret;
 773 }
 774
 775 static int lbs_cmd_mac_multicast_adr(struct lbs_private *priv,
 776                                       struct cmd_ds_command *cmd,
 777                                       u16 cmd_action)
 778 {
 779         struct cmd_ds_mac_multicast_adr *pMCastAdr = &cmd->params.madr;
 780
 781         lbs_deb_enter(LBS_DEB_CMD);
 782         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) +
 783                              S_DS_GEN);
 784         cmd->command = cpu_to_le16(CMD_MAC_MULTICAST_ADR);
 785
 786         lbs_deb_cmd("MULTICAST_ADR: setting %d addresses\n", pMCastAdr->nr_of_adrs);
 787         pMCastAdr->action = cpu_to_le16(cmd_action);
 788         pMCastAdr->nr_of_adrs =
 789             cpu_to_le16((u16) priv->nr_of_multicastmacaddr);
 790         memcpy(pMCastAdr->maclist, priv->multicastlist,
 791                priv->nr_of_multicastmacaddr * ETH_ALEN);
 792
 793         lbs_deb_leave(LBS_DEB_CMD);
 794         return 0;
 795 }
 796
 797 /**
 798  *  @brief Get the radio channel
 799  *
 800  *  @param priv         A pointer to struct lbs_private structure
 801  *
 802  *  @return             The channel on success, error on failure
 803  */
 804 int lbs_get_channel(struct lbs_private *priv)
 805 {
 806         struct cmd_ds_802_11_rf_channel cmd;
 807         int ret = 0;
 808
 809         lbs_deb_enter(LBS_DEB_CMD);
 810
 811         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 812         cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_GET);
 813
 814         ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
 815         if (ret)
 816                 goto out;
 817
 818         ret = le16_to_cpu(cmd.channel);
 819         lbs_deb_cmd("current radio channel is %d\n", ret);
 820
 821 out:
 822         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 823         return ret;
 824 }
 825
 826 /**
 827  *  @brief Set the radio channel
 828  *
 829  *  @param priv         A pointer to struct lbs_private structure
 830  *  @param channel      The desired channel, or 0 to clear a locked channel
 831  *
 832  *  @return             0 on success, error on failure
 833  */
 834 int lbs_set_channel(struct lbs_private *priv, u8 channel)
 835 {
 836         struct cmd_ds_802_11_rf_channel cmd;
 837         u8 old_channel = priv->curbssparams.channel;
 838         int ret = 0;
 839
 840         lbs_deb_enter(LBS_DEB_CMD);
 841
 842         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 843         cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_SET);
 844         cmd.channel = cpu_to_le16(channel);
 845
 846         ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
 847         if (ret)
 848                 goto out;
 849
 850         priv->curbssparams.channel = (uint8_t) le16_to_cpu(cmd.channel);
 851         lbs_deb_cmd("channel switch from %d to %d\n", old_channel,
 852                 priv->curbssparams.channel);
 853
 854 out:
 855         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 856         return ret;
 857 }
 858
 859 static int lbs_cmd_802_11_rssi(struct lbs_private *priv,
 860                                 struct cmd_ds_command *cmd)
 861 {
 862
 863         lbs_deb_enter(LBS_DEB_CMD);
 864         cmd->command = cpu_to_le16(CMD_802_11_RSSI);
 865         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rssi) + S_DS_GEN);
 866         cmd->params.rssi.N = cpu_to_le16(DEFAULT_BCN_AVG_FACTOR);
 867
 868         /* reset Beacon SNR/NF/RSSI values */
 869         priv->SNR[TYPE_BEACON][TYPE_NOAVG] = 0;
 870         priv->SNR[TYPE_BEACON][TYPE_AVG] = 0;
 871         priv->NF[TYPE_BEACON][TYPE_NOAVG] = 0;
 872         priv->NF[TYPE_BEACON][TYPE_AVG] = 0;
 873         priv->RSSI[TYPE_BEACON][TYPE_NOAVG] = 0;
 874         priv->RSSI[TYPE_BEACON][TYPE_AVG] = 0;
 875
 876         lbs_deb_leave(LBS_DEB_CMD);
 877         return 0;
 878 }
 879
 880 static int lbs_cmd_reg_access(struct lbs_private *priv,
 881                                struct cmd_ds_command *cmdptr,
 882                                u8 cmd_action, void *pdata_buf)
 883 {
 884         struct lbs_offset_value *offval;
 885
 886         lbs_deb_enter(LBS_DEB_CMD);
 887
 888         offval = (struct lbs_offset_value *)pdata_buf;
 889
 890         switch (le16_to_cpu(cmdptr->command)) {
 891         case CMD_MAC_REG_ACCESS:
 892                 {
 893                         struct cmd_ds_mac_reg_access *macreg;
 894
 895                         cmdptr->size =
 896                             cpu_to_le16(sizeof (struct cmd_ds_mac_reg_access)
 897                                         + S_DS_GEN);
 898                         macreg =
 899                             (struct cmd_ds_mac_reg_access *)&cmdptr->params.
 900                             macreg;
 901
 902                         macreg->action = cpu_to_le16(cmd_action);
 903                         macreg->offset = cpu_to_le16((u16) offval->offset);
 904                         macreg->value = cpu_to_le32(offval->value);
 905
 906                         break;
 907                 }
 908
 909         case CMD_BBP_REG_ACCESS:
 910                 {
 911                         struct cmd_ds_bbp_reg_access *bbpreg;
 912
 913                         cmdptr->size =
 914                             cpu_to_le16(sizeof
 915                                              (struct cmd_ds_bbp_reg_access)
 916                                              + S_DS_GEN);
 917                         bbpreg =
 918                             (struct cmd_ds_bbp_reg_access *)&cmdptr->params.
 919                             bbpreg;
 920
 921                         bbpreg->action = cpu_to_le16(cmd_action);
 922                         bbpreg->offset = cpu_to_le16((u16) offval->offset);
 923                         bbpreg->value = (u8) offval->value;
 924
 925                         break;
 926                 }
 927
 928         case CMD_RF_REG_ACCESS:
 929                 {
 930                         struct cmd_ds_rf_reg_access *rfreg;
 931
 932                         cmdptr->size =
 933                             cpu_to_le16(sizeof
 934                                              (struct cmd_ds_rf_reg_access) +
 935                                              S_DS_GEN);
 936                         rfreg =
 937                             (struct cmd_ds_rf_reg_access *)&cmdptr->params.
 938                             rfreg;
 939
 940                         rfreg->action = cpu_to_le16(cmd_action);
 941                         rfreg->offset = cpu_to_le16((u16) offval->offset);
 942                         rfreg->value = (u8) offval->value;
 943
 944                         break;
 945                 }
 946
 947         default:
 948                 break;
 949         }
 950
 951         lbs_deb_leave(LBS_DEB_CMD);
 952         return 0;
 953 }
 954
 955 static int lbs_cmd_802_11_mac_address(struct lbs_private *priv,
 956                                        struct cmd_ds_command *cmd,
 957                                        u16 cmd_action)
 958 {
 959
 960         lbs_deb_enter(LBS_DEB_CMD);
 961         cmd->command = cpu_to_le16(CMD_802_11_MAC_ADDRESS);
 962         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_mac_address) +
 963                              S_DS_GEN);
 964         cmd->result = 0;
 965
 966         cmd->params.macadd.action = cpu_to_le16(cmd_action);
 967
 968         if (cmd_action == CMD_ACT_SET) {
 969                 memcpy(cmd->params.macadd.macadd,
 970                        priv->current_addr, ETH_ALEN);
 971                 lbs_deb_hex(LBS_DEB_CMD, "SET_CMD: MAC addr", priv->current_addr, 6);
 972         }
 973
 974         lbs_deb_leave(LBS_DEB_CMD);
 975         return 0;
 976 }
 977
 978 static int lbs_cmd_802_11_eeprom_access(struct lbs_private *priv,
 979                                          struct cmd_ds_command *cmd,
 980                                          int cmd_action, void *pdata_buf)
 981 {
 982         struct lbs_ioctl_regrdwr *ea = pdata_buf;
 983
 984         lbs_deb_enter(LBS_DEB_CMD);
 985
 986         cmd->command = cpu_to_le16(CMD_802_11_EEPROM_ACCESS);
 987         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_eeprom_access) +
 988                                 S_DS_GEN);
 989         cmd->result = 0;
 990
 991         cmd->params.rdeeprom.action = cpu_to_le16(ea->action);
 992         cmd->params.rdeeprom.offset = cpu_to_le16(ea->offset);
 993         cmd->params.rdeeprom.bytecount = cpu_to_le16(ea->NOB);
 994         cmd->params.rdeeprom.value = 0;
 995
 996         lbs_deb_leave(LBS_DEB_CMD);
 997         return 0;
 998 }
 999
1000 static int lbs_cmd_bt_access(struct lbs_private *priv,
1001                                struct cmd_ds_command *cmd,
1002                                u16 cmd_action, void *pdata_buf)
1003 {
1004         struct cmd_ds_bt_access *bt_access = &cmd->params.bt;
1005         lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
1006
1007         cmd->command = cpu_to_le16(CMD_BT_ACCESS);
1008         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_bt_access) + S_DS_GEN);
1009         cmd->result = 0;
1010         bt_access->action = cpu_to_le16(cmd_action);
1011
1012         switch (cmd_action) {
1013         case CMD_ACT_BT_ACCESS_ADD:
1014                 memcpy(bt_access->addr1, pdata_buf, 2 * ETH_ALEN);
1015                 lbs_deb_hex(LBS_DEB_MESH, "BT_ADD: blinded MAC addr", bt_access->addr1, 6);
1016                 break;
1017         case CMD_ACT_BT_ACCESS_DEL:
1018                 memcpy(bt_access->addr1, pdata_buf, 1 * ETH_ALEN);
1019                 lbs_deb_hex(LBS_DEB_MESH, "BT_DEL: blinded MAC addr", bt_access->addr1, 6);
1020                 break;
1021         case CMD_ACT_BT_ACCESS_LIST:
1022                 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
1023                 break;
1024         case CMD_ACT_BT_ACCESS_RESET:
1025                 break;
1026         case CMD_ACT_BT_ACCESS_SET_INVERT:
1027                 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
1028                 break;
1029         case CMD_ACT_BT_ACCESS_GET_INVERT:
1030                 break;
1031         default:
1032                 break;
1033         }
1034         lbs_deb_leave(LBS_DEB_CMD);
1035         return 0;
1036 }
1037
1038 static int lbs_cmd_fwt_access(struct lbs_private *priv,
1039                                struct cmd_ds_command *cmd,
1040                                u16 cmd_action, void *pdata_buf)
1041 {
1042         struct cmd_ds_fwt_access *fwt_access = &cmd->params.fwt;
1043         lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
1044
1045         cmd->command = cpu_to_le16(CMD_FWT_ACCESS);
1046         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access) + S_DS_GEN);
1047         cmd->result = 0;
1048
1049         if (pdata_buf)
1050                 memcpy(fwt_access, pdata_buf, sizeof(*fwt_access));
1051         else
1052                 memset(fwt_access, 0, sizeof(*fwt_access));
1053
1054         fwt_access->action = cpu_to_le16(cmd_action);
1055
1056         lbs_deb_leave(LBS_DEB_CMD);
1057         return 0;
1058 }
1059
1060 int lbs_mesh_access(struct lbs_private *priv, uint16_t cmd_action,
1061                     struct cmd_ds_mesh_access *cmd)
1062 {
1063         int ret;
1064
1065         lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
1066
1067         cmd->hdr.command = cpu_to_le16(CMD_MESH_ACCESS);
1068         cmd->hdr.size = cpu_to_le16(sizeof(*cmd));
1069         cmd->hdr.result = 0;
1070
1071         cmd->action = cpu_to_le16(cmd_action);
1072
1073         ret = lbs_cmd_with_response(priv, CMD_MESH_ACCESS, cmd);
1074
1075         lbs_deb_leave(LBS_DEB_CMD);
1076         return ret;
1077 }
1078 EXPORT_SYMBOL_GPL(lbs_mesh_access);
1079
1080 int lbs_mesh_config(struct lbs_private *priv, uint16_t enable, uint16_t chan)
1081 {
1082         struct cmd_ds_mesh_config cmd;
1083
1084         memset(&cmd, 0, sizeof(cmd));
1085         cmd.action = cpu_to_le16(enable);
1086         cmd.channel = cpu_to_le16(chan);
1087         cmd.type = cpu_to_le16(priv->mesh_tlv);
1088         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1089
1090         if (enable) {
1091                 cmd.length = cpu_to_le16(priv->mesh_ssid_len);
1092                 memcpy(cmd.data, priv->mesh_ssid, priv->mesh_ssid_len);
1093         }
1094         lbs_deb_cmd("mesh config enable %d TLV %x channel %d SSID %s\n",
1095                     enable, priv->mesh_tlv, chan,
1096                     escape_essid(priv->mesh_ssid, priv->mesh_ssid_len));
1097         return lbs_cmd_with_response(priv, CMD_MESH_CONFIG, &cmd);
1098 }
1099
1100 static int lbs_cmd_bcn_ctrl(struct lbs_private * priv,
1101                                 struct cmd_ds_command *cmd,
1102                                 u16 cmd_action)
1103 {
1104         struct cmd_ds_802_11_beacon_control
1105                 *bcn_ctrl = &cmd->params.bcn_ctrl;
1106
1107         lbs_deb_enter(LBS_DEB_CMD);
1108         cmd->size =
1109             cpu_to_le16(sizeof(struct cmd_ds_802_11_beacon_control)
1110                              + S_DS_GEN);
1111         cmd->command = cpu_to_le16(CMD_802_11_BEACON_CTRL);
1112
1113         bcn_ctrl->action = cpu_to_le16(cmd_action);
1114         bcn_ctrl->beacon_enable = cpu_to_le16(priv->beacon_enable);
1115         bcn_ctrl->beacon_period = cpu_to_le16(priv->beacon_period);
1116
1117         lbs_deb_leave(LBS_DEB_CMD);
1118         return 0;
1119 }
1120
1121 static void lbs_queue_cmd(struct lbs_private *priv,
1122                           struct cmd_ctrl_node *cmdnode)
1123 {
1124         unsigned long flags;
1125         int addtail = 1;
1126
1127         lbs_deb_enter(LBS_DEB_HOST);
1128
1129         if (!cmdnode) {
1130                 lbs_deb_host("QUEUE_CMD: cmdnode is NULL\n");
1131                 goto done;
1132         }
1133         if (!cmdnode->cmdbuf->size) {
1134                 lbs_deb_host("DNLD_CMD: cmd size is zero\n");
1135                 goto done;
1136         }
1137         cmdnode->result = 0;
1138
1139         /* Exit_PS command needs to be queued in the header always. */
1140         if (le16_to_cpu(cmdnode->cmdbuf->command) == CMD_802_11_PS_MODE) {
1141                 struct cmd_ds_802_11_ps_mode *psm = (void *) &cmdnode->cmdbuf[1];
1142
1143                 if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
1144                         if (priv->psstate != PS_STATE_FULL_POWER)
1145                                 addtail = 0;
1146                 }
1147         }
1148
1149         spin_lock_irqsave(&priv->driver_lock, flags);
1150
1151         if (addtail)
1152                 list_add_tail(&cmdnode->list, &priv->cmdpendingq);
1153         else
1154                 list_add(&cmdnode->list, &priv->cmdpendingq);
1155
1156         spin_unlock_irqrestore(&priv->driver_lock, flags);
1157
1158         lbs_deb_host("QUEUE_CMD: inserted command 0x%04x into cmdpendingq\n",
1159                      le16_to_cpu(cmdnode->cmdbuf->command));
1160
1161 done:
1162         lbs_deb_leave(LBS_DEB_HOST);
1163 }
1164
1165 static void lbs_submit_command(struct lbs_private *priv,
1166                                struct cmd_ctrl_node *cmdnode)
1167 {
1168         unsigned long flags;
1169         struct cmd_header *cmd;
1170         uint16_t cmdsize;
1171         uint16_t command;
1172         int timeo = 5 * HZ;
1173         int ret;
1174
1175         lbs_deb_enter(LBS_DEB_HOST);
1176
1177         cmd = cmdnode->cmdbuf;
1178
1179         spin_lock_irqsave(&priv->driver_lock, flags);
1180         priv->cur_cmd = cmdnode;
1181         priv->cur_cmd_retcode = 0;
1182         spin_unlock_irqrestore(&priv->driver_lock, flags);
1183
1184         cmdsize = le16_to_cpu(cmd->size);
1185         command = le16_to_cpu(cmd->command);
1186
1187         /* These commands take longer */
1188         if (command == CMD_802_11_SCAN || command == CMD_802_11_ASSOCIATE ||
1189             command == CMD_802_11_AUTHENTICATE)
1190                 timeo = 10 * HZ;
1191
1192         lbs_deb_host("DNLD_CMD: command 0x%04x, seq %d, size %d, jiffies %lu\n",
1193                      command, le16_to_cpu(cmd->seqnum), cmdsize, jiffies);
1194         lbs_deb_hex(LBS_DEB_HOST, "DNLD_CMD", (void *) cmdnode->cmdbuf, cmdsize);
1195
1196         ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmd, cmdsize);
1197
1198         if (ret) {
1199                 lbs_pr_info("DNLD_CMD: hw_host_to_card failed: %d\n", ret);
1200                 /* Let the timer kick in and retry, and potentially reset
1201                    the whole thing if the condition persists */
1202                 timeo = HZ;
1203         } else
1204                 lbs_deb_cmd("DNLD_CMD: sent command 0x%04x, jiffies %lu\n",
1205                             command, jiffies);
1206
1207         /* Setup the timer after transmit command */
1208         mod_timer(&priv->command_timer, jiffies + timeo);
1209
1210         lbs_deb_leave(LBS_DEB_HOST);
1211 }
1212
1213 static int lbs_cmd_mac_control(struct lbs_private *priv,
1214                                 struct cmd_ds_command *cmd)
1215 {
1216         struct cmd_ds_mac_control *mac = &cmd->params.macctrl;
1217
1218         lbs_deb_enter(LBS_DEB_CMD);
1219
1220         cmd->command = cpu_to_le16(CMD_MAC_CONTROL);
1221         cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_control) + S_DS_GEN);
1222         mac->action = cpu_to_le16(priv->currentpacketfilter);
1223
1224         lbs_deb_cmd("MAC_CONTROL: action 0x%x, size %d\n",
1225                     le16_to_cpu(mac->action), le16_to_cpu(cmd->size));
1226
1227         lbs_deb_leave(LBS_DEB_CMD);
1228         return 0;
1229 }
1230
1231 /**
1232  *  This function inserts command node to cmdfreeq
1233  *  after cleans it. Requires priv->driver_lock held.
1234  */
1235 static void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
1236                                          struct cmd_ctrl_node *cmdnode)
1237 {
1238         lbs_deb_enter(LBS_DEB_HOST);
1239
1240         if (!cmdnode)
1241                 goto out;
1242
1243         cmdnode->callback = NULL;
1244         cmdnode->callback_arg = 0;
1245
1246         memset(cmdnode->cmdbuf, 0, LBS_CMD_BUFFER_SIZE);
1247
1248         list_add_tail(&cmdnode->list, &priv->cmdfreeq);
1249  out:
1250         lbs_deb_leave(LBS_DEB_HOST);
1251 }
1252
1253 static void lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
1254         struct cmd_ctrl_node *ptempcmd)
1255 {
1256         unsigned long flags;
1257
1258         spin_lock_irqsave(&priv->driver_lock, flags);
1259         __lbs_cleanup_and_insert_cmd(priv, ptempcmd);
1260         spin_unlock_irqrestore(&priv->driver_lock, flags);
1261 }
1262
1263 void lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd,
1264                           int result)
1265 {
1266         if (cmd == priv->cur_cmd)
1267                 priv->cur_cmd_retcode = result;
1268
1269         cmd->result = result;
1270         cmd->cmdwaitqwoken = 1;
1271         wake_up_interruptible(&cmd->cmdwait_q);
1272
1273         if (!cmd->callback)
1274                 __lbs_cleanup_and_insert_cmd(priv, cmd);
1275         priv->cur_cmd = NULL;
1276 }
1277
1278 int lbs_set_radio_control(struct lbs_private *priv)
1279 {
1280         int ret = 0;
1281         struct cmd_ds_802_11_radio_control cmd;
1282
1283         lbs_deb_enter(LBS_DEB_CMD);
1284
1285         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1286         cmd.action = cpu_to_le16(CMD_ACT_SET);
1287
1288         switch (priv->preamble) {
1289         case CMD_TYPE_SHORT_PREAMBLE:
1290                 cmd.control = cpu_to_le16(SET_SHORT_PREAMBLE);
1291                 break;
1292
1293         case CMD_TYPE_LONG_PREAMBLE:
1294                 cmd.control = cpu_to_le16(SET_LONG_PREAMBLE);
1295                 break;
1296
1297         case CMD_TYPE_AUTO_PREAMBLE:
1298         default:
1299                 cmd.control = cpu_to_le16(SET_AUTO_PREAMBLE);
1300                 break;
1301         }
1302
1303         if (priv->radioon)
1304                 cmd.control |= cpu_to_le16(TURN_ON_RF);
1305         else
1306                 cmd.control &= cpu_to_le16(~TURN_ON_RF);
1307
1308         lbs_deb_cmd("RADIO_SET: radio %d, preamble %d\n", priv->radioon,
1309                     priv->preamble);
1310
1311         ret = lbs_cmd_with_response(priv, CMD_802_11_RADIO_CONTROL, &cmd);
1312
1313         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1314         return ret;
1315 }
1316
1317 int lbs_set_mac_packet_filter(struct lbs_private *priv)
1318 {
1319         int ret = 0;
1320
1321         lbs_deb_enter(LBS_DEB_CMD);
1322
1323         /* Send MAC control command to station */
1324         ret = lbs_prepare_and_send_command(priv,
1325                                     CMD_MAC_CONTROL, 0, 0, 0, NULL);
1326
1327         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1328         return ret;
1329 }
1330
1331 /**
1332  *  @brief This function prepare the command before send to firmware.
1333  *
1334  *  @param priv         A pointer to struct lbs_private structure
1335  *  @param cmd_no       command number
1336  *  @param cmd_action   command action: GET or SET
1337  *  @param wait_option  wait option: wait response or not
1338  *  @param cmd_oid      cmd oid: treated as sub command
1339  *  @param pdata_buf    A pointer to informaion buffer
1340  *  @return             0 or -1
1341  */
1342 int lbs_prepare_and_send_command(struct lbs_private *priv,
1343                           u16 cmd_no,
1344                           u16 cmd_action,
1345                           u16 wait_option, u32 cmd_oid, void *pdata_buf)
1346 {
1347         int ret = 0;
1348         struct cmd_ctrl_node *cmdnode;
1349         struct cmd_ds_command *cmdptr;
1350         unsigned long flags;
1351
1352         lbs_deb_enter(LBS_DEB_HOST);
1353
1354         if (!priv) {
1355                 lbs_deb_host("PREP_CMD: priv is NULL\n");
1356                 ret = -1;
1357                 goto done;
1358         }
1359
1360         if (priv->surpriseremoved) {
1361                 lbs_deb_host("PREP_CMD: card removed\n");
1362                 ret = -1;
1363                 goto done;
1364         }
1365
1366         cmdnode = lbs_get_cmd_ctrl_node(priv);
1367
1368         if (cmdnode == NULL) {
1369                 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
1370
1371                 /* Wake up main thread to execute next command */
1372                 wake_up_interruptible(&priv->waitq);
1373                 ret = -1;
1374                 goto done;
1375         }
1376
1377         lbs_set_cmd_ctrl_node(priv, cmdnode, pdata_buf);
1378
1379         cmdptr = (struct cmd_ds_command *)cmdnode->cmdbuf;
1380
1381         lbs_deb_host("PREP_CMD: command 0x%04x\n", cmd_no);
1382
1383         /* Set sequence number, command and INT option */
1384         priv->seqnum++;
1385         cmdptr->seqnum = cpu_to_le16(priv->seqnum);
1386
1387         cmdptr->command = cpu_to_le16(cmd_no);
1388         cmdptr->result = 0;
1389
1390         switch (cmd_no) {
1391         case CMD_802_11_PS_MODE:
1392                 ret = lbs_cmd_802_11_ps_mode(priv, cmdptr, cmd_action);
1393                 break;
1394
1395         case CMD_802_11_SCAN:
1396                 ret = lbs_cmd_80211_scan(priv, cmdptr, pdata_buf);
1397                 break;
1398
1399         case CMD_MAC_CONTROL:
1400                 ret = lbs_cmd_mac_control(priv, cmdptr);
1401                 break;
1402
1403         case CMD_802_11_ASSOCIATE:
1404         case CMD_802_11_REASSOCIATE:
1405                 ret = lbs_cmd_80211_associate(priv, cmdptr, pdata_buf);
1406                 break;
1407
1408         case CMD_802_11_DEAUTHENTICATE:
1409                 ret = lbs_cmd_80211_deauthenticate(priv, cmdptr);
1410                 break;
1411
1412         case CMD_802_11_AD_HOC_START:
1413                 ret = lbs_cmd_80211_ad_hoc_start(priv, cmdptr, pdata_buf);
1414                 break;
1415         case CMD_CODE_DNLD:
1416                 break;
1417
1418         case CMD_802_11_RESET:
1419                 ret = lbs_cmd_802_11_reset(priv, cmdptr, cmd_action);
1420                 break;
1421
1422         case CMD_802_11_GET_LOG:
1423                 ret = lbs_cmd_802_11_get_log(priv, cmdptr);
1424                 break;
1425
1426         case CMD_802_11_AUTHENTICATE:
1427                 ret = lbs_cmd_80211_authenticate(priv, cmdptr, pdata_buf);
1428                 break;
1429
1430         case CMD_802_11_GET_STAT:
1431                 ret = lbs_cmd_802_11_get_stat(priv, cmdptr);
1432                 break;
1433
1434         case CMD_802_11_SNMP_MIB:
1435                 ret = lbs_cmd_802_11_snmp_mib(priv, cmdptr,
1436                                                cmd_action, cmd_oid, pdata_buf);
1437                 break;
1438
1439         case CMD_MAC_REG_ACCESS:
1440         case CMD_BBP_REG_ACCESS:
1441         case CMD_RF_REG_ACCESS:
1442                 ret = lbs_cmd_reg_access(priv, cmdptr, cmd_action, pdata_buf);
1443                 break;
1444
1445         case CMD_802_11_RF_TX_POWER:
1446                 ret = lbs_cmd_802_11_rf_tx_power(priv, cmdptr,
1447                                                   cmd_action, pdata_buf);
1448                 break;
1449
1450         case CMD_802_11_RATE_ADAPT_RATESET:
1451                 ret = lbs_cmd_802_11_rate_adapt_rateset(priv,
1452                                                          cmdptr, cmd_action);
1453                 break;
1454
1455         case CMD_MAC_MULTICAST_ADR:
1456                 ret = lbs_cmd_mac_multicast_adr(priv, cmdptr, cmd_action);
1457                 break;
1458
1459         case CMD_802_11_MONITOR_MODE:
1460                 ret = lbs_cmd_802_11_monitor_mode(priv, cmdptr,
1461                                           cmd_action, pdata_buf);
1462                 break;
1463
1464         case CMD_802_11_AD_HOC_JOIN:
1465                 ret = lbs_cmd_80211_ad_hoc_join(priv, cmdptr, pdata_buf);
1466                 break;
1467
1468         case CMD_802_11_RSSI:
1469                 ret = lbs_cmd_802_11_rssi(priv, cmdptr);
1470                 break;
1471
1472         case CMD_802_11_AD_HOC_STOP:
1473                 ret = lbs_cmd_80211_ad_hoc_stop(priv, cmdptr);
1474                 break;
1475
1476         case CMD_802_11_ENABLE_RSN:
1477                 ret = lbs_cmd_802_11_enable_rsn(priv, cmdptr, cmd_action,
1478                                 pdata_buf);
1479                 break;
1480
1481         case CMD_802_11_KEY_MATERIAL:
1482                 ret = lbs_cmd_802_11_key_material(priv, cmdptr, cmd_action,
1483                                 cmd_oid, pdata_buf);
1484                 break;
1485
1486         case CMD_802_11_PAIRWISE_TSC:
1487                 break;
1488         case CMD_802_11_GROUP_TSC:
1489                 break;
1490
1491         case CMD_802_11_MAC_ADDRESS:
1492                 ret = lbs_cmd_802_11_mac_address(priv, cmdptr, cmd_action);
1493                 break;
1494
1495         case CMD_802_11_EEPROM_ACCESS:
1496                 ret = lbs_cmd_802_11_eeprom_access(priv, cmdptr,
1497                                                     cmd_action, pdata_buf);
1498                 break;
1499
1500         case CMD_802_11_SET_AFC:
1501         case CMD_802_11_GET_AFC:
1502
1503                 cmdptr->command = cpu_to_le16(cmd_no);
1504                 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_afc) +
1505                                            S_DS_GEN);
1506
1507                 memmove(&cmdptr->params.afc,
1508                         pdata_buf, sizeof(struct cmd_ds_802_11_afc));
1509
1510                 ret = 0;
1511                 goto done;
1512
1513         case CMD_802_11D_DOMAIN_INFO:
1514                 ret = lbs_cmd_802_11d_domain_info(priv, cmdptr,
1515                                                    cmd_no, cmd_action);
1516                 break;
1517
1518         case CMD_802_11_TPC_CFG:
1519                 cmdptr->command = cpu_to_le16(CMD_802_11_TPC_CFG);
1520                 cmdptr->size =
1521                     cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) +
1522                                      S_DS_GEN);
1523
1524                 memmove(&cmdptr->params.tpccfg,
1525                         pdata_buf, sizeof(struct cmd_ds_802_11_tpc_cfg));
1526
1527                 ret = 0;
1528                 break;
1529         case CMD_802_11_LED_GPIO_CTRL:
1530                 {
1531                         struct mrvlietypes_ledgpio *gpio =
1532                             (struct mrvlietypes_ledgpio*)
1533                             cmdptr->params.ledgpio.data;
1534
1535                         memmove(&cmdptr->params.ledgpio,
1536                                 pdata_buf,
1537                                 sizeof(struct cmd_ds_802_11_led_ctrl));
1538
1539                         cmdptr->command =
1540                             cpu_to_le16(CMD_802_11_LED_GPIO_CTRL);
1541
1542 #define ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN 8
1543                         cmdptr->size =
1544                             cpu_to_le16(le16_to_cpu(gpio->header.len)
1545                                 + S_DS_GEN
1546                                 + ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN);
1547                         gpio->header.len = gpio->header.len;
1548
1549                         ret = 0;
1550                         break;
1551                 }
1552         case CMD_802_11_SUBSCRIBE_EVENT:
1553                 lbs_cmd_802_11_subscribe_event(priv, cmdptr,
1554                         cmd_action, pdata_buf);
1555                 break;
1556         case CMD_802_11_PWR_CFG:
1557                 cmdptr->command = cpu_to_le16(CMD_802_11_PWR_CFG);
1558                 cmdptr->size =
1559                     cpu_to_le16(sizeof(struct cmd_ds_802_11_pwr_cfg) +
1560                                      S_DS_GEN);
1561                 memmove(&cmdptr->params.pwrcfg, pdata_buf,
1562                         sizeof(struct cmd_ds_802_11_pwr_cfg));
1563
1564                 ret = 0;
1565                 break;
1566         case CMD_BT_ACCESS:
1567                 ret = lbs_cmd_bt_access(priv, cmdptr, cmd_action, pdata_buf);
1568                 break;
1569
1570         case CMD_FWT_ACCESS:
1571                 ret = lbs_cmd_fwt_access(priv, cmdptr, cmd_action, pdata_buf);
1572                 break;
1573
1574         case CMD_GET_TSF:
1575                 cmdptr->command = cpu_to_le16(CMD_GET_TSF);
1576                 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_get_tsf) +
1577                                            S_DS_GEN);
1578                 ret = 0;
1579                 break;
1580         case CMD_802_11_BEACON_CTRL:
1581                 ret = lbs_cmd_bcn_ctrl(priv, cmdptr, cmd_action);
1582                 break;
1583         default:
1584                 lbs_deb_host("PREP_CMD: unknown command 0x%04x\n", cmd_no);
1585                 ret = -1;
1586                 break;
1587         }
1588
1589         /* return error, since the command preparation failed */
1590         if (ret != 0) {
1591                 lbs_deb_host("PREP_CMD: command preparation failed\n");
1592                 lbs_cleanup_and_insert_cmd(priv, cmdnode);
1593                 ret = -1;
1594                 goto done;
1595         }
1596
1597         cmdnode->cmdwaitqwoken = 0;
1598
1599         lbs_queue_cmd(priv, cmdnode);
1600         wake_up_interruptible(&priv->waitq);
1601
1602         if (wait_option & CMD_OPTION_WAITFORRSP) {
1603                 lbs_deb_host("PREP_CMD: wait for response\n");
1604                 might_sleep();
1605                 wait_event_interruptible(cmdnode->cmdwait_q,
1606                                          cmdnode->cmdwaitqwoken);
1607         }
1608
1609         spin_lock_irqsave(&priv->driver_lock, flags);
1610         if (priv->cur_cmd_retcode) {
1611                 lbs_deb_host("PREP_CMD: command failed with return code %d\n",
1612                        priv->cur_cmd_retcode);
1613                 priv->cur_cmd_retcode = 0;
1614                 ret = -1;
1615         }
1616         spin_unlock_irqrestore(&priv->driver_lock, flags);
1617
1618 done:
1619         lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1620         return ret;
1621 }
1622 EXPORT_SYMBOL_GPL(lbs_prepare_and_send_command);
1623
1624 /**
1625  *  @brief This function allocates the command buffer and link
1626  *  it to command free queue.
1627  *
1628  *  @param priv         A pointer to struct lbs_private structure
1629  *  @return             0 or -1
1630  */
1631 int lbs_allocate_cmd_buffer(struct lbs_private *priv)
1632 {
1633         int ret = 0;
1634         u32 bufsize;
1635         u32 i;
1636         struct cmd_ctrl_node *cmdarray;
1637
1638         lbs_deb_enter(LBS_DEB_HOST);
1639
1640         /* Allocate and initialize the command array */
1641         bufsize = sizeof(struct cmd_ctrl_node) * LBS_NUM_CMD_BUFFERS;
1642         if (!(cmdarray = kzalloc(bufsize, GFP_KERNEL))) {
1643                 lbs_deb_host("ALLOC_CMD_BUF: tempcmd_array is NULL\n");
1644                 ret = -1;
1645                 goto done;
1646         }
1647         priv->cmd_array = cmdarray;
1648
1649         /* Allocate and initialize each command buffer in the command array */
1650         for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1651                 cmdarray[i].cmdbuf = kzalloc(LBS_CMD_BUFFER_SIZE, GFP_KERNEL);
1652                 if (!cmdarray[i].cmdbuf) {
1653                         lbs_deb_host("ALLOC_CMD_BUF: ptempvirtualaddr is NULL\n");
1654                         ret = -1;
1655                         goto done;
1656                 }
1657         }
1658
1659         for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1660                 init_waitqueue_head(&cmdarray[i].cmdwait_q);
1661                 lbs_cleanup_and_insert_cmd(priv, &cmdarray[i]);
1662         }
1663         ret = 0;
1664
1665 done:
1666         lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1667         return ret;
1668 }
1669
1670 /**
1671  *  @brief This function frees the command buffer.
1672  *
1673  *  @param priv         A pointer to struct lbs_private structure
1674  *  @return             0 or -1
1675  */
1676 int lbs_free_cmd_buffer(struct lbs_private *priv)
1677 {
1678         struct cmd_ctrl_node *cmdarray;
1679         unsigned int i;
1680
1681         lbs_deb_enter(LBS_DEB_HOST);
1682
1683         /* need to check if cmd array is allocated or not */
1684         if (priv->cmd_array == NULL) {
1685                 lbs_deb_host("FREE_CMD_BUF: cmd_array is NULL\n");
1686                 goto done;
1687         }
1688
1689         cmdarray = priv->cmd_array;
1690
1691         /* Release shared memory buffers */
1692         for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1693                 if (cmdarray[i].cmdbuf) {
1694                         kfree(cmdarray[i].cmdbuf);
1695                         cmdarray[i].cmdbuf = NULL;
1696                 }
1697         }
1698
1699         /* Release cmd_ctrl_node */
1700         if (priv->cmd_array) {
1701                 kfree(priv->cmd_array);
1702                 priv->cmd_array = NULL;
1703         }
1704
1705 done:
1706         lbs_deb_leave(LBS_DEB_HOST);
1707         return 0;
1708 }
1709
1710 /**
1711  *  @brief This function gets a free command node if available in
1712  *  command free queue.
1713  *
1714  *  @param priv         A pointer to struct lbs_private structure
1715  *  @return cmd_ctrl_node A pointer to cmd_ctrl_node structure or NULL
1716  */
1717 static struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv)
1718 {
1719         struct cmd_ctrl_node *tempnode;
1720         unsigned long flags;
1721
1722         lbs_deb_enter(LBS_DEB_HOST);
1723
1724         if (!priv)
1725                 return NULL;
1726
1727         spin_lock_irqsave(&priv->driver_lock, flags);
1728
1729         if (!list_empty(&priv->cmdfreeq)) {
1730                 tempnode = list_first_entry(&priv->cmdfreeq,
1731                                             struct cmd_ctrl_node, list);
1732                 list_del(&tempnode->list);
1733         } else {
1734                 lbs_deb_host("GET_CMD_NODE: cmd_ctrl_node is not available\n");
1735                 tempnode = NULL;
1736         }
1737
1738         spin_unlock_irqrestore(&priv->driver_lock, flags);
1739
1740         lbs_deb_leave(LBS_DEB_HOST);
1741         return tempnode;
1742 }
1743
1744 /**
1745  *  @brief This function cleans command node.
1746  *
1747  *  @param ptempnode    A pointer to cmdCtrlNode structure
1748  *  @return             n/a
1749  */
1750
1751 /**
1752  *  @brief This function initializes the command node.
1753  *
1754  *  @param priv         A pointer to struct lbs_private structure
1755  *  @param ptempnode    A pointer to cmd_ctrl_node structure
1756  *  @param pdata_buf    A pointer to informaion buffer
1757  *  @return             0 or -1
1758  */
1759 static void lbs_set_cmd_ctrl_node(struct lbs_private *priv,
1760                                   struct cmd_ctrl_node *ptempnode,
1761                                   void *pdata_buf)
1762 {
1763         lbs_deb_enter(LBS_DEB_HOST);
1764
1765         if (!ptempnode)
1766                 return;
1767
1768         ptempnode->callback = NULL;
1769         ptempnode->callback_arg = (unsigned long)pdata_buf;
1770
1771         lbs_deb_leave(LBS_DEB_HOST);
1772 }
1773
1774 /**
1775  *  @brief This function executes next command in command
1776  *  pending queue. It will put fimware back to PS mode
1777  *  if applicable.
1778  *
1779  *  @param priv     A pointer to struct lbs_private structure
1780  *  @return        0 or -1
1781  */
1782 int lbs_execute_next_command(struct lbs_private *priv)
1783 {
1784         struct cmd_ctrl_node *cmdnode = NULL;
1785         struct cmd_header *cmd;
1786         unsigned long flags;
1787         int ret = 0;
1788
1789         // Debug group is LBS_DEB_THREAD and not LBS_DEB_HOST, because the
1790         // only caller to us is lbs_thread() and we get even when a
1791         // data packet is received
1792         lbs_deb_enter(LBS_DEB_THREAD);
1793
1794         spin_lock_irqsave(&priv->driver_lock, flags);
1795
1796         if (priv->cur_cmd) {
1797                 lbs_pr_alert( "EXEC_NEXT_CMD: already processing command!\n");
1798                 spin_unlock_irqrestore(&priv->driver_lock, flags);
1799                 ret = -1;
1800                 goto done;
1801         }
1802
1803         if (!list_empty(&priv->cmdpendingq)) {
1804                 cmdnode = list_first_entry(&priv->cmdpendingq,
1805                                            struct cmd_ctrl_node, list);
1806         }
1807
1808         spin_unlock_irqrestore(&priv->driver_lock, flags);
1809
1810         if (cmdnode) {
1811                 cmd = cmdnode->cmdbuf;
1812
1813                 if (is_command_allowed_in_ps(le16_to_cpu(cmd->command))) {
1814                         if ((priv->psstate == PS_STATE_SLEEP) ||
1815                             (priv->psstate == PS_STATE_PRE_SLEEP)) {
1816                                 lbs_deb_host(
1817                                        "EXEC_NEXT_CMD: cannot send cmd 0x%04x in psstate %d\n",
1818                                        le16_to_cpu(cmd->command),
1819                                        priv->psstate);
1820                                 ret = -1;
1821                                 goto done;
1822                         }
1823                         lbs_deb_host("EXEC_NEXT_CMD: OK to send command "
1824                                      "0x%04x in psstate %d\n",
1825                                      le16_to_cpu(cmd->command), priv->psstate);
1826                 } else if (priv->psstate != PS_STATE_FULL_POWER) {
1827                         /*
1828                          * 1. Non-PS command:
1829                          * Queue it. set needtowakeup to TRUE if current state
1830                          * is SLEEP, otherwise call lbs_ps_wakeup to send Exit_PS.
1831                          * 2. PS command but not Exit_PS:
1832                          * Ignore it.
1833                          * 3. PS command Exit_PS:
1834                          * Set needtowakeup to TRUE if current state is SLEEP,
1835                          * otherwise send this command down to firmware
1836                          * immediately.
1837                          */
1838                         if (cmd->command != cpu_to_le16(CMD_802_11_PS_MODE)) {
1839                                 /*  Prepare to send Exit PS,
1840                                  *  this non PS command will be sent later */
1841                                 if ((priv->psstate == PS_STATE_SLEEP)
1842                                     || (priv->psstate == PS_STATE_PRE_SLEEP)
1843                                     ) {
1844                                         /* w/ new scheme, it will not reach here.
1845                                            since it is blocked in main_thread. */
1846                                         priv->needtowakeup = 1;
1847                                 } else
1848                                         lbs_ps_wakeup(priv, 0);
1849
1850                                 ret = 0;
1851                                 goto done;
1852                         } else {
1853                                 /*
1854                                  * PS command. Ignore it if it is not Exit_PS.
1855                                  * otherwise send it down immediately.
1856                                  */
1857                                 struct cmd_ds_802_11_ps_mode *psm = (void *)&cmd[1];
1858
1859                                 lbs_deb_host(
1860                                        "EXEC_NEXT_CMD: PS cmd, action 0x%02x\n",
1861                                        psm->action);
1862                                 if (psm->action !=
1863                                     cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
1864                                         lbs_deb_host(
1865                                                "EXEC_NEXT_CMD: ignore ENTER_PS cmd\n");
1866                                         list_del(&cmdnode->list);
1867                                         spin_lock_irqsave(&priv->driver_lock, flags);
1868                                         lbs_complete_command(priv, cmdnode, 0);
1869                                         spin_unlock_irqrestore(&priv->driver_lock, flags);
1870
1871                                         ret = 0;
1872                                         goto done;
1873                                 }
1874
1875                                 if ((priv->psstate == PS_STATE_SLEEP) ||
1876                                     (priv->psstate == PS_STATE_PRE_SLEEP)) {
1877                                         lbs_deb_host(
1878                                                "EXEC_NEXT_CMD: ignore EXIT_PS cmd in sleep\n");
1879                                         list_del(&cmdnode->list);
1880                                         spin_lock_irqsave(&priv->driver_lock, flags);
1881                                         lbs_complete_command(priv, cmdnode, 0);
1882                                         spin_unlock_irqrestore(&priv->driver_lock, flags);
1883                                         priv->needtowakeup = 1;
1884
1885                                         ret = 0;
1886                                         goto done;
1887                                 }
1888
1889                                 lbs_deb_host(
1890                                        "EXEC_NEXT_CMD: sending EXIT_PS\n");
1891                         }
1892                 }
1893                 list_del(&cmdnode->list);
1894                 lbs_deb_host("EXEC_NEXT_CMD: sending command 0x%04x\n",
1895                             le16_to_cpu(cmd->command));
1896                 lbs_submit_command(priv, cmdnode);
1897         } else {
1898                 /*
1899                  * check if in power save mode, if yes, put the device back
1900                  * to PS mode
1901                  */
1902                 if ((priv->psmode != LBS802_11POWERMODECAM) &&
1903                     (priv->psstate == PS_STATE_FULL_POWER) &&
1904                     ((priv->connect_status == LBS_CONNECTED) ||
1905                     (priv->mesh_connect_status == LBS_CONNECTED))) {
1906                         if (priv->secinfo.WPAenabled ||
1907                             priv->secinfo.WPA2enabled) {
1908                                 /* check for valid WPA group keys */
1909                                 if (priv->wpa_mcast_key.len ||
1910                                     priv->wpa_unicast_key.len) {
1911                                         lbs_deb_host(
1912                                                "EXEC_NEXT_CMD: WPA enabled and GTK_SET"
1913                                                " go back to PS_SLEEP");
1914                                         lbs_ps_sleep(priv, 0);
1915                                 }
1916                         } else {
1917                                 lbs_deb_host(
1918                                        "EXEC_NEXT_CMD: cmdpendingq empty, "
1919                                        "go back to PS_SLEEP");
1920                                 lbs_ps_sleep(priv, 0);
1921                         }
1922                 }
1923         }
1924
1925         ret = 0;
1926 done:
1927         lbs_deb_leave(LBS_DEB_THREAD);
1928         return ret;
1929 }
1930
1931 void lbs_send_iwevcustom_event(struct lbs_private *priv, s8 *str)
1932 {
1933         union iwreq_data iwrq;
1934         u8 buf[50];
1935
1936         lbs_deb_enter(LBS_DEB_WEXT);
1937
1938         memset(&iwrq, 0, sizeof(union iwreq_data));
1939         memset(buf, 0, sizeof(buf));
1940
1941         snprintf(buf, sizeof(buf) - 1, "%s", str);
1942
1943         iwrq.data.length = strlen(buf) + 1 + IW_EV_LCP_LEN;
1944
1945         /* Send Event to upper layer */
1946         lbs_deb_wext("event indication string %s\n", (char *)buf);
1947         lbs_deb_wext("event indication length %d\n", iwrq.data.length);
1948         lbs_deb_wext("sending wireless event IWEVCUSTOM for %s\n", str);
1949
1950         wireless_send_event(priv->dev, IWEVCUSTOM, &iwrq, buf);
1951
1952         lbs_deb_leave(LBS_DEB_WEXT);
1953 }
1954
1955 static int sendconfirmsleep(struct lbs_private *priv, u8 *cmdptr, u16 size)
1956 {
1957         unsigned long flags;
1958         int ret = 0;
1959
1960         lbs_deb_enter(LBS_DEB_HOST);
1961
1962         lbs_deb_host("SEND_SLEEPC_CMD: before download, cmd size %d\n",
1963                size);
1964
1965         lbs_deb_hex(LBS_DEB_HOST, "sleep confirm command", cmdptr, size);
1966
1967         ret = priv->hw_host_to_card(priv, MVMS_CMD, cmdptr, size);
1968
1969         spin_lock_irqsave(&priv->driver_lock, flags);
1970         if (priv->intcounter || priv->currenttxskb)
1971                 lbs_deb_host("SEND_SLEEPC_CMD: intcounter %d, currenttxskb %p\n",
1972                        priv->intcounter, priv->currenttxskb);
1973         spin_unlock_irqrestore(&priv->driver_lock, flags);
1974
1975         if (ret) {
1976                 lbs_pr_alert(
1977                        "SEND_SLEEPC_CMD: Host to Card failed for Confirm Sleep\n");
1978         } else {
1979                 spin_lock_irqsave(&priv->driver_lock, flags);
1980                 if (!priv->intcounter) {
1981                         priv->psstate = PS_STATE_SLEEP;
1982                 } else {
1983                         lbs_deb_host("SEND_SLEEPC_CMD: after sent, intcounter %d\n",
1984                                priv->intcounter);
1985                 }
1986                 spin_unlock_irqrestore(&priv->driver_lock, flags);
1987
1988                 lbs_deb_host("SEND_SLEEPC_CMD: sent confirm sleep\n");
1989         }
1990
1991         lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1992         return ret;
1993 }
1994
1995 void lbs_ps_sleep(struct lbs_private *priv, int wait_option)
1996 {
1997         lbs_deb_enter(LBS_DEB_HOST);
1998
1999         /*
2000          * PS is currently supported only in Infrastructure mode
2001          * Remove this check if it is to be supported in IBSS mode also
2002          */
2003
2004         lbs_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
2005                               CMD_SUBCMD_ENTER_PS, wait_option, 0, NULL);
2006
2007         lbs_deb_leave(LBS_DEB_HOST);
2008 }
2009
2010 /**
2011  *  @brief This function sends Exit_PS command to firmware.
2012  *
2013  *  @param priv         A pointer to struct lbs_private structure
2014  *  @param wait_option  wait response or not
2015  *  @return             n/a
2016  */
2017 void lbs_ps_wakeup(struct lbs_private *priv, int wait_option)
2018 {
2019         __le32 Localpsmode;
2020
2021         lbs_deb_enter(LBS_DEB_HOST);
2022
2023         Localpsmode = cpu_to_le32(LBS802_11POWERMODECAM);
2024
2025         lbs_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
2026                               CMD_SUBCMD_EXIT_PS,
2027                               wait_option, 0, &Localpsmode);
2028
2029         lbs_deb_leave(LBS_DEB_HOST);
2030 }
2031
2032 /**
2033  *  @brief This function checks condition and prepares to
2034  *  send sleep confirm command to firmware if ok.
2035  *
2036  *  @param priv         A pointer to struct lbs_private structure
2037  *  @param psmode       Power Saving mode
2038  *  @return             n/a
2039  */
2040 void lbs_ps_confirm_sleep(struct lbs_private *priv, u16 psmode)
2041 {
2042         unsigned long flags =0;
2043         u8 allowed = 1;
2044
2045         lbs_deb_enter(LBS_DEB_HOST);
2046
2047         if (priv->dnld_sent) {
2048                 allowed = 0;
2049                 lbs_deb_host("dnld_sent was set\n");
2050         }
2051
2052         spin_lock_irqsave(&priv->driver_lock, flags);
2053         if (priv->cur_cmd) {
2054                 allowed = 0;
2055                 lbs_deb_host("cur_cmd was set\n");
2056         }
2057         if (priv->intcounter > 0) {
2058                 allowed = 0;
2059                 lbs_deb_host("intcounter %d\n", priv->intcounter);
2060         }
2061         spin_unlock_irqrestore(&priv->driver_lock, flags);
2062
2063         if (allowed) {
2064                 lbs_deb_host("sending lbs_ps_confirm_sleep\n");
2065                 sendconfirmsleep(priv, (u8 *) & priv->lbs_ps_confirm_sleep,
2066                                  sizeof(struct PS_CMD_ConfirmSleep));
2067         } else {
2068                 lbs_deb_host("sleep confirm has been delayed\n");
2069         }
2070
2071         lbs_deb_leave(LBS_DEB_HOST);
2072 }
2073
2074
2075 /**
2076  *  @brief Simple callback that copies response back into command
2077  *
2078  *  @param priv         A pointer to struct lbs_private structure
2079  *  @param extra        A pointer to the original command structure for which
2080  *                      'resp' is a response
2081  *  @param resp         A pointer to the command response
2082  *
2083  *  @return             0 on success, error on failure
2084  */
2085 int lbs_cmd_copyback(struct lbs_private *priv, unsigned long extra,
2086                      struct cmd_header *resp)
2087 {
2088         struct cmd_header *buf = (void *)extra;
2089         uint16_t copy_len;
2090
2091         lbs_deb_enter(LBS_DEB_CMD);
2092
2093         copy_len = min(le16_to_cpu(buf->size), le16_to_cpu(resp->size));
2094         lbs_deb_cmd("Copying back %u bytes; command response was %u bytes, "
2095                     "copy back buffer was %u bytes\n", copy_len,
2096                     le16_to_cpu(resp->size), le16_to_cpu(buf->size));
2097         memcpy(buf, resp, copy_len);
2098
2099         lbs_deb_leave(LBS_DEB_CMD);
2100         return 0;
2101 }
2102 EXPORT_SYMBOL_GPL(lbs_cmd_copyback);
2103
2104 struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv, uint16_t command,
2105                                       struct cmd_header *in_cmd, int in_cmd_size,
2106                                       int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
2107                                       unsigned long callback_arg)
2108 {
2109         struct cmd_ctrl_node *cmdnode;
2110
2111         lbs_deb_enter(LBS_DEB_HOST);
2112
2113         if (priv->surpriseremoved) {
2114                 lbs_deb_host("PREP_CMD: card removed\n");
2115                 cmdnode = ERR_PTR(-ENOENT);
2116                 goto done;
2117         }
2118
2119         cmdnode = lbs_get_cmd_ctrl_node(priv);
2120         if (cmdnode == NULL) {
2121                 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
2122
2123                 /* Wake up main thread to execute next command */
2124                 wake_up_interruptible(&priv->waitq);
2125                 cmdnode = ERR_PTR(-ENOBUFS);
2126                 goto done;
2127         }
2128
2129         cmdnode->callback = callback;
2130         cmdnode->callback_arg = callback_arg;
2131
2132         /* Copy the incoming command to the buffer */
2133         memcpy(cmdnode->cmdbuf, in_cmd, in_cmd_size);
2134
2135         /* Set sequence number, clean result, move to buffer */
2136         priv->seqnum++;
2137         cmdnode->cmdbuf->command = cpu_to_le16(command);
2138         cmdnode->cmdbuf->size    = cpu_to_le16(in_cmd_size);
2139         cmdnode->cmdbuf->seqnum  = cpu_to_le16(priv->seqnum);
2140         cmdnode->cmdbuf->result  = 0;
2141
2142         lbs_deb_host("PREP_CMD: command 0x%04x\n", command);
2143
2144         /* here was the big old switch() statement, which is now obsolete,
2145          * because the caller of lbs_cmd() sets up all of *cmd for us. */
2146
2147         cmdnode->cmdwaitqwoken = 0;
2148         lbs_queue_cmd(priv, cmdnode);
2149         wake_up_interruptible(&priv->waitq);
2150
2151  done:
2152         lbs_deb_leave_args(LBS_DEB_HOST, "ret %p", cmdnode);
2153         return cmdnode;
2154 }
2155
2156 int __lbs_cmd(struct lbs_private *priv, uint16_t command,
2157               struct cmd_header *in_cmd, int in_cmd_size,
2158               int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
2159               unsigned long callback_arg)
2160 {
2161         struct cmd_ctrl_node *cmdnode;
2162         unsigned long flags;
2163         int ret = 0;
2164
2165         lbs_deb_enter(LBS_DEB_HOST);
2166
2167         cmdnode = __lbs_cmd_async(priv, command, in_cmd, in_cmd_size,
2168                                   callback, callback_arg);
2169         if (IS_ERR(cmdnode)) {
2170                 ret = PTR_ERR(cmdnode);
2171                 goto done;
2172         }
2173
2174         might_sleep();
2175         wait_event_interruptible(cmdnode->cmdwait_q, cmdnode->cmdwaitqwoken);
2176
2177         spin_lock_irqsave(&priv->driver_lock, flags);
2178         ret = cmdnode->result;
2179         if (ret)
2180                 lbs_pr_info("PREP_CMD: command 0x%04x failed: %d\n",
2181                             command, ret);
2182
2183         __lbs_cleanup_and_insert_cmd(priv, cmdnode);
2184         spin_unlock_irqrestore(&priv->driver_lock, flags);
2185
2186 done:
2187         lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
2188         return ret;
2189 }
2190 EXPORT_SYMBOL_GPL(__lbs_cmd);
2191
2192