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 <linux/kfifo.h>
   7 #include <linux/sched.h>
   8 #include <linux/slab.h>
   9 #include <linux/if_arp.h>
  10
  11 #include "decl.h"
  12 #include "cfg.h"
  13 #include "cmd.h"
  14
  15 #define CAL_NF(nf)              ((s32)(-(s32)(nf)))
  16 #define CAL_RSSI(snr, nf)       ((s32)((s32)(snr) + CAL_NF(nf)))
  17
  18 /**
  19  *  @brief Simple callback that copies response back into command
  20  *
  21  *  @param priv         A pointer to struct lbs_private structure
  22  *  @param extra        A pointer to the original command structure for which
  23  *                      'resp' is a response
  24  *  @param resp         A pointer to the command response
  25  *
  26  *  @return             0 on success, error on failure
  27  */
  28 int lbs_cmd_copyback(struct lbs_private *priv, unsigned long extra,
  29                      struct cmd_header *resp)
  30 {
  31         struct cmd_header *buf = (void *)extra;
  32         uint16_t copy_len;
  33
  34         copy_len = min(le16_to_cpu(buf->size), le16_to_cpu(resp->size));
  35         memcpy(buf, resp, copy_len);
  36         return 0;
  37 }
  38 EXPORT_SYMBOL_GPL(lbs_cmd_copyback);
  39
  40 /**
  41  *  @brief Simple callback that ignores the result. Use this if
  42  *  you just want to send a command to the hardware, but don't
  43  *  care for the result.
  44  *
  45  *  @param priv         ignored
  46  *  @param extra        ignored
  47  *  @param resp         ignored
  48  *
  49  *  @return             0 for success
  50  */
  51 static int lbs_cmd_async_callback(struct lbs_private *priv, unsigned long extra,
  52                      struct cmd_header *resp)
  53 {
  54         return 0;
  55 }
  56
  57
  58 /**
  59  *  @brief Checks whether a command is allowed in Power Save mode
  60  *
  61  *  @param command the command ID
  62  *  @return        1 if allowed, 0 if not allowed
  63  */
  64 static u8 is_command_allowed_in_ps(u16 cmd)
  65 {
  66         switch (cmd) {
  67         case CMD_802_11_RSSI:
  68                 return 1;
  69         case CMD_802_11_HOST_SLEEP_CFG:
  70                 return 1;
  71         default:
  72                 break;
  73         }
  74         return 0;
  75 }
  76
  77 /**
  78  *  @brief Updates the hardware details like MAC address and regulatory region
  79  *
  80  *  @param priv         A pointer to struct lbs_private structure
  81  *
  82  *  @return             0 on success, error on failure
  83  */
  84 int lbs_update_hw_spec(struct lbs_private *priv)
  85 {
  86         struct cmd_ds_get_hw_spec cmd;
  87         int ret = -1;
  88         u32 i;
  89
  90         lbs_deb_enter(LBS_DEB_CMD);
  91
  92         memset(&cmd, 0, sizeof(cmd));
  93         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
  94         memcpy(cmd.permanentaddr, priv->current_addr, ETH_ALEN);
  95         ret = lbs_cmd_with_response(priv, CMD_GET_HW_SPEC, &cmd);
  96         if (ret)
  97                 goto out;
  98
  99         priv->fwcapinfo = le32_to_cpu(cmd.fwcapinfo);
 100
 101         /* The firmware release is in an interesting format: the patch
 102          * level is in the most significant nibble ... so fix that: */
 103         priv->fwrelease = le32_to_cpu(cmd.fwrelease);
 104         priv->fwrelease = (priv->fwrelease << 8) |
 105                 (priv->fwrelease >> 24 & 0xff);
 106
 107         /* Some firmware capabilities:
 108          * CF card    firmware 5.0.16p0:   cap 0x00000303
 109          * USB dongle firmware 5.110.17p2: cap 0x00000303
 110          */
 111         lbs_pr_info("%pM, fw %u.%u.%up%u, cap 0x%08x\n",
 112                 cmd.permanentaddr,
 113                 priv->fwrelease >> 24 & 0xff,
 114                 priv->fwrelease >> 16 & 0xff,
 115                 priv->fwrelease >>  8 & 0xff,
 116                 priv->fwrelease       & 0xff,
 117                 priv->fwcapinfo);
 118         lbs_deb_cmd("GET_HW_SPEC: hardware interface 0x%x, hardware spec 0x%04x\n",
 119                     cmd.hwifversion, cmd.version);
 120
 121         /* Clamp region code to 8-bit since FW spec indicates that it should
 122          * only ever be 8-bit, even though the field size is 16-bit.  Some firmware
 123          * returns non-zero high 8 bits here.
 124          *
 125          * Firmware version 4.0.102 used in CF8381 has region code shifted.  We
 126          * need to check for this problem and handle it properly.
 127          */
 128         if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V4)
 129                 priv->regioncode = (le16_to_cpu(cmd.regioncode) >> 8) & 0xFF;
 130         else
 131                 priv->regioncode = le16_to_cpu(cmd.regioncode) & 0xFF;
 132
 133         for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
 134                 /* use the region code to search for the index */
 135                 if (priv->regioncode == lbs_region_code_to_index[i])
 136                         break;
 137         }
 138
 139         /* if it's unidentified region code, use the default (USA) */
 140         if (i >= MRVDRV_MAX_REGION_CODE) {
 141                 priv->regioncode = 0x10;
 142                 lbs_pr_info("unidentified region code; using the default (USA)\n");
 143         }
 144
 145         if (priv->current_addr[0] == 0xff)
 146                 memmove(priv->current_addr, cmd.permanentaddr, ETH_ALEN);
 147
 148         if (!priv->copied_hwaddr) {
 149                 memcpy(priv->dev->dev_addr, priv->current_addr, ETH_ALEN);
 150                 if (priv->mesh_dev)
 151                         memcpy(priv->mesh_dev->dev_addr,
 152                                 priv->current_addr, ETH_ALEN);
 153                 priv->copied_hwaddr = 1;
 154         }
 155
 156 out:
 157         lbs_deb_leave(LBS_DEB_CMD);
 158         return ret;
 159 }
 160
 161 static int lbs_ret_host_sleep_cfg(struct lbs_private *priv, unsigned long dummy,
 162                         struct cmd_header *resp)
 163 {
 164         lbs_deb_enter(LBS_DEB_CMD);
 165         if (priv->is_host_sleep_activated) {
 166                 priv->is_host_sleep_configured = 0;
 167                 if (priv->psstate == PS_STATE_FULL_POWER) {
 168                         priv->is_host_sleep_activated = 0;
 169                         wake_up_interruptible(&priv->host_sleep_q);
 170                 }
 171         } else {
 172                 priv->is_host_sleep_configured = 1;
 173         }
 174         lbs_deb_leave(LBS_DEB_CMD);
 175         return 0;
 176 }
 177
 178 int lbs_host_sleep_cfg(struct lbs_private *priv, uint32_t criteria,
 179                 struct wol_config *p_wol_config)
 180 {
 181         struct cmd_ds_host_sleep cmd_config;
 182         int ret;
 183
 184         /*
 185          * Certain firmware versions do not support EHS_REMOVE_WAKEUP command
 186          * and the card will return a failure.  Since we need to be
 187          * able to reset the mask, in those cases we set a 0 mask instead.
 188          */
 189         if (criteria == EHS_REMOVE_WAKEUP && !priv->ehs_remove_supported)
 190                 criteria = 0;
 191
 192         cmd_config.hdr.size = cpu_to_le16(sizeof(cmd_config));
 193         cmd_config.criteria = cpu_to_le32(criteria);
 194         cmd_config.gpio = priv->wol_gpio;
 195         cmd_config.gap = priv->wol_gap;
 196
 197         if (p_wol_config != NULL)
 198                 memcpy((uint8_t *)&cmd_config.wol_conf, (uint8_t *)p_wol_config,
 199                                 sizeof(struct wol_config));
 200         else
 201                 cmd_config.wol_conf.action = CMD_ACT_ACTION_NONE;
 202
 203         ret = __lbs_cmd(priv, CMD_802_11_HOST_SLEEP_CFG, &cmd_config.hdr,
 204                         le16_to_cpu(cmd_config.hdr.size),
 205                         lbs_ret_host_sleep_cfg, 0);
 206         if (!ret) {
 207                 if (p_wol_config)
 208                         memcpy((uint8_t *) p_wol_config,
 209                                         (uint8_t *)&cmd_config.wol_conf,
 210                                         sizeof(struct wol_config));
 211         } else {
 212                 lbs_pr_info("HOST_SLEEP_CFG failed %d\n", ret);
 213         }
 214
 215         return ret;
 216 }
 217 EXPORT_SYMBOL_GPL(lbs_host_sleep_cfg);
 218
 219 /**
 220  *  @brief Sets the Power Save mode
 221  *
 222  *  @param priv         A pointer to struct lbs_private structure
 223  *  @param cmd_action   The Power Save operation (PS_MODE_ACTION_ENTER_PS or
 224  *                         PS_MODE_ACTION_EXIT_PS)
 225  *  @param block        Whether to block on a response or not
 226  *
 227  *  @return             0 on success, error on failure
 228  */
 229 int lbs_set_ps_mode(struct lbs_private *priv, u16 cmd_action, bool block)
 230 {
 231         struct cmd_ds_802_11_ps_mode cmd;
 232         int ret = 0;
 233
 234         lbs_deb_enter(LBS_DEB_CMD);
 235
 236         memset(&cmd, 0, sizeof(cmd));
 237         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 238         cmd.action = cpu_to_le16(cmd_action);
 239
 240         if (cmd_action == PS_MODE_ACTION_ENTER_PS) {
 241                 lbs_deb_cmd("PS_MODE: action ENTER_PS\n");
 242                 cmd.multipledtim = cpu_to_le16(1);  /* Default DTIM multiple */
 243         } else if (cmd_action == PS_MODE_ACTION_EXIT_PS) {
 244                 lbs_deb_cmd("PS_MODE: action EXIT_PS\n");
 245         } else {
 246                 /* We don't handle CONFIRM_SLEEP here because it needs to
 247                  * be fastpathed to the firmware.
 248                  */
 249                 lbs_deb_cmd("PS_MODE: unknown action 0x%X\n", cmd_action);
 250                 ret = -EOPNOTSUPP;
 251                 goto out;
 252         }
 253
 254         if (block)
 255                 ret = lbs_cmd_with_response(priv, CMD_802_11_PS_MODE, &cmd);
 256         else
 257                 lbs_cmd_async(priv, CMD_802_11_PS_MODE, &cmd.hdr, sizeof (cmd));
 258
 259 out:
 260         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 261         return ret;
 262 }
 263
 264 int lbs_cmd_802_11_sleep_params(struct lbs_private *priv, uint16_t cmd_action,
 265                                 struct sleep_params *sp)
 266 {
 267         struct cmd_ds_802_11_sleep_params cmd;
 268         int ret;
 269
 270         lbs_deb_enter(LBS_DEB_CMD);
 271
 272         if (cmd_action == CMD_ACT_GET) {
 273                 memset(&cmd, 0, sizeof(cmd));
 274         } else {
 275                 cmd.error = cpu_to_le16(sp->sp_error);
 276                 cmd.offset = cpu_to_le16(sp->sp_offset);
 277                 cmd.stabletime = cpu_to_le16(sp->sp_stabletime);
 278                 cmd.calcontrol = sp->sp_calcontrol;
 279                 cmd.externalsleepclk = sp->sp_extsleepclk;
 280                 cmd.reserved = cpu_to_le16(sp->sp_reserved);
 281         }
 282         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 283         cmd.action = cpu_to_le16(cmd_action);
 284
 285         ret = lbs_cmd_with_response(priv, CMD_802_11_SLEEP_PARAMS, &cmd);
 286
 287         if (!ret) {
 288                 lbs_deb_cmd("error 0x%x, offset 0x%x, stabletime 0x%x, "
 289                             "calcontrol 0x%x extsleepclk 0x%x\n",
 290                             le16_to_cpu(cmd.error), le16_to_cpu(cmd.offset),
 291                             le16_to_cpu(cmd.stabletime), cmd.calcontrol,
 292                             cmd.externalsleepclk);
 293
 294                 sp->sp_error = le16_to_cpu(cmd.error);
 295                 sp->sp_offset = le16_to_cpu(cmd.offset);
 296                 sp->sp_stabletime = le16_to_cpu(cmd.stabletime);
 297                 sp->sp_calcontrol = cmd.calcontrol;
 298                 sp->sp_extsleepclk = cmd.externalsleepclk;
 299                 sp->sp_reserved = le16_to_cpu(cmd.reserved);
 300         }
 301
 302         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 303         return 0;
 304 }
 305
 306 static int lbs_wait_for_ds_awake(struct lbs_private *priv)
 307 {
 308         int ret = 0;
 309
 310         lbs_deb_enter(LBS_DEB_CMD);
 311
 312         if (priv->is_deep_sleep) {
 313                 if (!wait_event_interruptible_timeout(priv->ds_awake_q,
 314                                         !priv->is_deep_sleep, (10 * HZ))) {
 315                         lbs_pr_err("ds_awake_q: timer expired\n");
 316                         ret = -1;
 317                 }
 318         }
 319
 320         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 321         return ret;
 322 }
 323
 324 int lbs_set_deep_sleep(struct lbs_private *priv, int deep_sleep)
 325 {
 326         int ret =  0;
 327
 328         lbs_deb_enter(LBS_DEB_CMD);
 329
 330         if (deep_sleep) {
 331                 if (priv->is_deep_sleep != 1) {
 332                         lbs_deb_cmd("deep sleep: sleep\n");
 333                         BUG_ON(!priv->enter_deep_sleep);
 334                         ret = priv->enter_deep_sleep(priv);
 335                         if (!ret) {
 336                                 netif_stop_queue(priv->dev);
 337                                 netif_carrier_off(priv->dev);
 338                         }
 339                 } else {
 340                         lbs_pr_err("deep sleep: already enabled\n");
 341                 }
 342         } else {
 343                 if (priv->is_deep_sleep) {
 344                         lbs_deb_cmd("deep sleep: wakeup\n");
 345                         BUG_ON(!priv->exit_deep_sleep);
 346                         ret = priv->exit_deep_sleep(priv);
 347                         if (!ret) {
 348                                 ret = lbs_wait_for_ds_awake(priv);
 349                                 if (ret)
 350                                         lbs_pr_err("deep sleep: wakeup"
 351                                                         "failed\n");
 352                         }
 353                 }
 354         }
 355
 356         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 357         return ret;
 358 }
 359
 360 static int lbs_ret_host_sleep_activate(struct lbs_private *priv,
 361                 unsigned long dummy,
 362                 struct cmd_header *cmd)
 363 {
 364         lbs_deb_enter(LBS_DEB_FW);
 365         priv->is_host_sleep_activated = 1;
 366         wake_up_interruptible(&priv->host_sleep_q);
 367         lbs_deb_leave(LBS_DEB_FW);
 368         return 0;
 369 }
 370
 371 int lbs_set_host_sleep(struct lbs_private *priv, int host_sleep)
 372 {
 373         struct cmd_header cmd;
 374         int ret = 0;
 375         uint32_t criteria = EHS_REMOVE_WAKEUP;
 376
 377         lbs_deb_enter(LBS_DEB_CMD);
 378
 379         if (host_sleep) {
 380                 if (priv->is_host_sleep_activated != 1) {
 381                         memset(&cmd, 0, sizeof(cmd));
 382                         ret = lbs_host_sleep_cfg(priv, priv->wol_criteria,
 383                                         (struct wol_config *)NULL);
 384                         if (ret) {
 385                                 lbs_pr_info("Host sleep configuration failed: "
 386                                                 "%d\n", ret);
 387                                 return ret;
 388                         }
 389                         if (priv->psstate == PS_STATE_FULL_POWER) {
 390                                 ret = __lbs_cmd(priv,
 391                                                 CMD_802_11_HOST_SLEEP_ACTIVATE,
 392                                                 &cmd,
 393                                                 sizeof(cmd),
 394                                                 lbs_ret_host_sleep_activate, 0);
 395                                 if (ret)
 396                                         lbs_pr_info("HOST_SLEEP_ACTIVATE "
 397                                                         "failed: %d\n", ret);
 398                         }
 399
 400                         if (!wait_event_interruptible_timeout(
 401                                                 priv->host_sleep_q,
 402                                                 priv->is_host_sleep_activated,
 403                                                 (10 * HZ))) {
 404                                 lbs_pr_err("host_sleep_q: timer expired\n");
 405                                 ret = -1;
 406                         }
 407                 } else {
 408                         lbs_pr_err("host sleep: already enabled\n");
 409                 }
 410         } else {
 411                 if (priv->is_host_sleep_activated)
 412                         ret = lbs_host_sleep_cfg(priv, criteria,
 413                                         (struct wol_config *)NULL);
 414         }
 415
 416         return ret;
 417 }
 418
 419 /**
 420  *  @brief Set an SNMP MIB value
 421  *
 422  *  @param priv         A pointer to struct lbs_private structure
 423  *  @param oid          The OID to set in the firmware
 424  *  @param val          Value to set the OID to
 425  *
 426  *  @return             0 on success, error on failure
 427  */
 428 int lbs_set_snmp_mib(struct lbs_private *priv, u32 oid, u16 val)
 429 {
 430         struct cmd_ds_802_11_snmp_mib cmd;
 431         int ret;
 432
 433         lbs_deb_enter(LBS_DEB_CMD);
 434
 435         memset(&cmd, 0, sizeof (cmd));
 436         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 437         cmd.action = cpu_to_le16(CMD_ACT_SET);
 438         cmd.oid = cpu_to_le16((u16) oid);
 439
 440         switch (oid) {
 441         case SNMP_MIB_OID_BSS_TYPE:
 442                 cmd.bufsize = cpu_to_le16(sizeof(u8));
 443                 cmd.value[0] = val;
 444                 break;
 445         case SNMP_MIB_OID_11D_ENABLE:
 446         case SNMP_MIB_OID_FRAG_THRESHOLD:
 447         case SNMP_MIB_OID_RTS_THRESHOLD:
 448         case SNMP_MIB_OID_SHORT_RETRY_LIMIT:
 449         case SNMP_MIB_OID_LONG_RETRY_LIMIT:
 450                 cmd.bufsize = cpu_to_le16(sizeof(u16));
 451                 *((__le16 *)(&cmd.value)) = cpu_to_le16(val);
 452                 break;
 453         default:
 454                 lbs_deb_cmd("SNMP_CMD: (set) unhandled OID 0x%x\n", oid);
 455                 ret = -EINVAL;
 456                 goto out;
 457         }
 458
 459         lbs_deb_cmd("SNMP_CMD: (set) oid 0x%x, oid size 0x%x, value 0x%x\n",
 460                     le16_to_cpu(cmd.oid), le16_to_cpu(cmd.bufsize), val);
 461
 462         ret = lbs_cmd_with_response(priv, CMD_802_11_SNMP_MIB, &cmd);
 463
 464 out:
 465         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 466         return ret;
 467 }
 468
 469 /**
 470  *  @brief Get an SNMP MIB value
 471  *
 472  *  @param priv         A pointer to struct lbs_private structure
 473  *  @param oid          The OID to retrieve from the firmware
 474  *  @param out_val      Location for the returned value
 475  *
 476  *  @return             0 on success, error on failure
 477  */
 478 int lbs_get_snmp_mib(struct lbs_private *priv, u32 oid, u16 *out_val)
 479 {
 480         struct cmd_ds_802_11_snmp_mib cmd;
 481         int ret;
 482
 483         lbs_deb_enter(LBS_DEB_CMD);
 484
 485         memset(&cmd, 0, sizeof (cmd));
 486         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 487         cmd.action = cpu_to_le16(CMD_ACT_GET);
 488         cmd.oid = cpu_to_le16(oid);
 489
 490         ret = lbs_cmd_with_response(priv, CMD_802_11_SNMP_MIB, &cmd);
 491         if (ret)
 492                 goto out;
 493
 494         switch (le16_to_cpu(cmd.bufsize)) {
 495         case sizeof(u8):
 496                 *out_val = cmd.value[0];
 497                 break;
 498         case sizeof(u16):
 499                 *out_val = le16_to_cpu(*((__le16 *)(&cmd.value)));
 500                 break;
 501         default:
 502                 lbs_deb_cmd("SNMP_CMD: (get) unhandled OID 0x%x size %d\n",
 503                             oid, le16_to_cpu(cmd.bufsize));
 504                 break;
 505         }
 506
 507 out:
 508         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 509         return ret;
 510 }
 511
 512 /**
 513  *  @brief Get the min, max, and current TX power
 514  *
 515  *  @param priv         A pointer to struct lbs_private structure
 516  *  @param curlevel     Current power level in dBm
 517  *  @param minlevel     Minimum supported power level in dBm (optional)
 518  *  @param maxlevel     Maximum supported power level in dBm (optional)
 519  *
 520  *  @return             0 on success, error on failure
 521  */
 522 int lbs_get_tx_power(struct lbs_private *priv, s16 *curlevel, s16 *minlevel,
 523                      s16 *maxlevel)
 524 {
 525         struct cmd_ds_802_11_rf_tx_power cmd;
 526         int ret;
 527
 528         lbs_deb_enter(LBS_DEB_CMD);
 529
 530         memset(&cmd, 0, sizeof(cmd));
 531         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 532         cmd.action = cpu_to_le16(CMD_ACT_GET);
 533
 534         ret = lbs_cmd_with_response(priv, CMD_802_11_RF_TX_POWER, &cmd);
 535         if (ret == 0) {
 536                 *curlevel = le16_to_cpu(cmd.curlevel);
 537                 if (minlevel)
 538                         *minlevel = cmd.minlevel;
 539                 if (maxlevel)
 540                         *maxlevel = cmd.maxlevel;
 541         }
 542
 543         lbs_deb_leave(LBS_DEB_CMD);
 544         return ret;
 545 }
 546
 547 /**
 548  *  @brief Set the TX power
 549  *
 550  *  @param priv         A pointer to struct lbs_private structure
 551  *  @param dbm          The desired power level in dBm
 552  *
 553  *  @return             0 on success, error on failure
 554  */
 555 int lbs_set_tx_power(struct lbs_private *priv, s16 dbm)
 556 {
 557         struct cmd_ds_802_11_rf_tx_power cmd;
 558         int ret;
 559
 560         lbs_deb_enter(LBS_DEB_CMD);
 561
 562         memset(&cmd, 0, sizeof(cmd));
 563         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 564         cmd.action = cpu_to_le16(CMD_ACT_SET);
 565         cmd.curlevel = cpu_to_le16(dbm);
 566
 567         lbs_deb_cmd("SET_RF_TX_POWER: %d dBm\n", dbm);
 568
 569         ret = lbs_cmd_with_response(priv, CMD_802_11_RF_TX_POWER, &cmd);
 570
 571         lbs_deb_leave(LBS_DEB_CMD);
 572         return ret;
 573 }
 574
 575 /**
 576  *  @brief Enable or disable monitor mode (only implemented on OLPC usb8388 FW)
 577  *
 578  *  @param priv        A pointer to struct lbs_private structure
 579  *  @param enable      1 to enable monitor mode, 0 to disable
 580  *
 581  *  @return            0 on success, error on failure
 582  */
 583 int lbs_set_monitor_mode(struct lbs_private *priv, int enable)
 584 {
 585         struct cmd_ds_802_11_monitor_mode cmd;
 586         int ret;
 587
 588         memset(&cmd, 0, sizeof(cmd));
 589         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 590         cmd.action = cpu_to_le16(CMD_ACT_SET);
 591         if (enable)
 592                 cmd.mode = cpu_to_le16(0x1);
 593
 594         lbs_deb_cmd("SET_MONITOR_MODE: %d\n", enable);
 595
 596         ret = lbs_cmd_with_response(priv, CMD_802_11_MONITOR_MODE, &cmd);
 597         if (ret == 0) {
 598                 priv->dev->type = enable ? ARPHRD_IEEE80211_RADIOTAP :
 599                                                 ARPHRD_ETHER;
 600         }
 601
 602         lbs_deb_leave(LBS_DEB_CMD);
 603         return ret;
 604 }
 605
 606 /**
 607  *  @brief Get the radio channel
 608  *
 609  *  @param priv         A pointer to struct lbs_private structure
 610  *
 611  *  @return             The channel on success, error on failure
 612  */
 613 static int lbs_get_channel(struct lbs_private *priv)
 614 {
 615         struct cmd_ds_802_11_rf_channel cmd;
 616         int ret = 0;
 617
 618         lbs_deb_enter(LBS_DEB_CMD);
 619
 620         memset(&cmd, 0, sizeof(cmd));
 621         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 622         cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_GET);
 623
 624         ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
 625         if (ret)
 626                 goto out;
 627
 628         ret = le16_to_cpu(cmd.channel);
 629         lbs_deb_cmd("current radio channel is %d\n", ret);
 630
 631 out:
 632         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 633         return ret;
 634 }
 635
 636 int lbs_update_channel(struct lbs_private *priv)
 637 {
 638         int ret;
 639
 640         /* the channel in f/w could be out of sync; get the current channel */
 641         lbs_deb_enter(LBS_DEB_ASSOC);
 642
 643         ret = lbs_get_channel(priv);
 644         if (ret > 0) {
 645                 priv->channel = ret;
 646                 ret = 0;
 647         }
 648         lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
 649         return ret;
 650 }
 651
 652 /**
 653  *  @brief Set the radio channel
 654  *
 655  *  @param priv         A pointer to struct lbs_private structure
 656  *  @param channel      The desired channel, or 0 to clear a locked channel
 657  *
 658  *  @return             0 on success, error on failure
 659  */
 660 int lbs_set_channel(struct lbs_private *priv, u8 channel)
 661 {
 662         struct cmd_ds_802_11_rf_channel cmd;
 663 #ifdef DEBUG
 664         u8 old_channel = priv->channel;
 665 #endif
 666         int ret = 0;
 667
 668         lbs_deb_enter(LBS_DEB_CMD);
 669
 670         memset(&cmd, 0, sizeof(cmd));
 671         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 672         cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_SET);
 673         cmd.channel = cpu_to_le16(channel);
 674
 675         ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
 676         if (ret)
 677                 goto out;
 678
 679         priv->channel = (uint8_t) le16_to_cpu(cmd.channel);
 680         lbs_deb_cmd("channel switch from %d to %d\n", old_channel,
 681                 priv->channel);
 682
 683 out:
 684         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 685         return ret;
 686 }
 687
 688 /**
 689  *  @brief Get current RSSI and noise floor
 690  *
 691  *  @param priv         A pointer to struct lbs_private structure
 692  *  @param rssi         On successful return, signal level in mBm
 693  *
 694  *  @return             The channel on success, error on failure
 695  */
 696 int lbs_get_rssi(struct lbs_private *priv, s8 *rssi, s8 *nf)
 697 {
 698         struct cmd_ds_802_11_rssi cmd;
 699         int ret = 0;
 700
 701         lbs_deb_enter(LBS_DEB_CMD);
 702
 703         BUG_ON(rssi == NULL);
 704         BUG_ON(nf == NULL);
 705
 706         memset(&cmd, 0, sizeof(cmd));
 707         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 708         /* Average SNR over last 8 beacons */
 709         cmd.n_or_snr = cpu_to_le16(8);
 710
 711         ret = lbs_cmd_with_response(priv, CMD_802_11_RSSI, &cmd);
 712         if (ret == 0) {
 713                 *nf = CAL_NF(le16_to_cpu(cmd.nf));
 714                 *rssi = CAL_RSSI(le16_to_cpu(cmd.n_or_snr), le16_to_cpu(cmd.nf));
 715         }
 716
 717         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 718         return ret;
 719 }
 720
 721 /**
 722  *  @brief Send regulatory and 802.11d domain information to the firmware
 723  *
 724  *  @param priv         pointer to struct lbs_private
 725  *  @param request      cfg80211 regulatory request structure
 726  *  @param bands        the device's supported bands and channels
 727  *
 728  *  @return             0 on success, error code on failure
 729 */
 730 int lbs_set_11d_domain_info(struct lbs_private *priv,
 731                             struct regulatory_request *request,
 732                             struct ieee80211_supported_band **bands)
 733 {
 734         struct cmd_ds_802_11d_domain_info cmd;
 735         struct mrvl_ie_domain_param_set *domain = &cmd.domain;
 736         struct ieee80211_country_ie_triplet *t;
 737         enum ieee80211_band band;
 738         struct ieee80211_channel *ch;
 739         u8 num_triplet = 0;
 740         u8 num_parsed_chan = 0;
 741         u8 first_channel = 0, next_chan = 0, max_pwr = 0;
 742         u8 i, flag = 0;
 743         size_t triplet_size;
 744         int ret;
 745
 746         lbs_deb_enter(LBS_DEB_11D);
 747
 748         memset(&cmd, 0, sizeof(cmd));
 749         cmd.action = cpu_to_le16(CMD_ACT_SET);
 750
 751         lbs_deb_11d("Setting country code '%c%c'\n",
 752                     request->alpha2[0], request->alpha2[1]);
 753
 754         domain->header.type = cpu_to_le16(TLV_TYPE_DOMAIN);
 755
 756         /* Set country code */
 757         domain->country_code[0] = request->alpha2[0];
 758         domain->country_code[1] = request->alpha2[1];
 759         domain->country_code[2] = ' ';
 760
 761         /* Now set up the channel triplets; firmware is somewhat picky here
 762          * and doesn't validate channel numbers and spans; hence it would
 763          * interpret a triplet of (36, 4, 20) as channels 36, 37, 38, 39.  Since
 764          * the last 3 aren't valid channels, the driver is responsible for
 765          * splitting that up into 4 triplet pairs of (36, 1, 20) + (40, 1, 20)
 766          * etc.
 767          */
 768         for (band = 0;
 769              (band < IEEE80211_NUM_BANDS) && (num_triplet < MAX_11D_TRIPLETS);
 770              band++) {
 771
 772                 if (!bands[band])
 773                         continue;
 774
 775                 for (i = 0;
 776                      (i < bands[band]->n_channels) && (num_triplet < MAX_11D_TRIPLETS);
 777                      i++) {
 778                         ch = &bands[band]->channels[i];
 779                         if (ch->flags & IEEE80211_CHAN_DISABLED)
 780                                 continue;
 781
 782                         if (!flag) {
 783                                 flag = 1;
 784                                 next_chan = first_channel = (u32) ch->hw_value;
 785                                 max_pwr = ch->max_power;
 786                                 num_parsed_chan = 1;
 787                                 continue;
 788                         }
 789
 790                         if ((ch->hw_value == next_chan + 1) &&
 791                                         (ch->max_power == max_pwr)) {
 792                                 /* Consolidate adjacent channels */
 793                                 next_chan++;
 794                                 num_parsed_chan++;
 795                         } else {
 796                                 /* Add this triplet */
 797                                 lbs_deb_11d("11D triplet (%d, %d, %d)\n",
 798                                         first_channel, num_parsed_chan,
 799                                         max_pwr);
 800                                 t = &domain->triplet[num_triplet];
 801                                 t->chans.first_channel = first_channel;
 802                                 t->chans.num_channels = num_parsed_chan;
 803                                 t->chans.max_power = max_pwr;
 804                                 num_triplet++;
 805                                 flag = 0;
 806                         }
 807                 }
 808
 809                 if (flag) {
 810                         /* Add last triplet */
 811                         lbs_deb_11d("11D triplet (%d, %d, %d)\n", first_channel,
 812                                 num_parsed_chan, max_pwr);
 813                         t = &domain->triplet[num_triplet];
 814                         t->chans.first_channel = first_channel;
 815                         t->chans.num_channels = num_parsed_chan;
 816                         t->chans.max_power = max_pwr;
 817                         num_triplet++;
 818                 }
 819         }
 820
 821         lbs_deb_11d("# triplets %d\n", num_triplet);
 822
 823         /* Set command header sizes */
 824         triplet_size = num_triplet * sizeof(struct ieee80211_country_ie_triplet);
 825         domain->header.len = cpu_to_le16(sizeof(domain->country_code) +
 826                                         triplet_size);
 827
 828         lbs_deb_hex(LBS_DEB_11D, "802.11D domain param set",
 829                         (u8 *) &cmd.domain.country_code,
 830                         le16_to_cpu(domain->header.len));
 831
 832         cmd.hdr.size = cpu_to_le16(sizeof(cmd.hdr) +
 833                                    sizeof(cmd.action) +
 834                                    sizeof(cmd.domain.header) +
 835                                    sizeof(cmd.domain.country_code) +
 836                                    triplet_size);
 837
 838         ret = lbs_cmd_with_response(priv, CMD_802_11D_DOMAIN_INFO, &cmd);
 839
 840         lbs_deb_leave_args(LBS_DEB_11D, "ret %d", ret);
 841         return ret;
 842 }
 843
 844 /**
 845  *  @brief Read a MAC, Baseband, or RF register
 846  *
 847  *  @param priv         pointer to struct lbs_private
 848  *  @param cmd          register command, one of CMD_MAC_REG_ACCESS,
 849  *                        CMD_BBP_REG_ACCESS, or CMD_RF_REG_ACCESS
 850  *  @param offset       byte offset of the register to get
 851  *  @param value        on success, the value of the register at 'offset'
 852  *
 853  *  @return             0 on success, error code on failure
 854 */
 855 int lbs_get_reg(struct lbs_private *priv, u16 reg, u16 offset, u32 *value)
 856 {
 857         struct cmd_ds_reg_access cmd;
 858         int ret = 0;
 859
 860         lbs_deb_enter(LBS_DEB_CMD);
 861
 862         BUG_ON(value == NULL);
 863
 864         memset(&cmd, 0, sizeof(cmd));
 865         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 866         cmd.action = cpu_to_le16(CMD_ACT_GET);
 867
 868         if (reg != CMD_MAC_REG_ACCESS &&
 869             reg != CMD_BBP_REG_ACCESS &&
 870             reg != CMD_RF_REG_ACCESS) {
 871                 ret = -EINVAL;
 872                 goto out;
 873         }
 874
 875         ret = lbs_cmd_with_response(priv, reg, &cmd);
 876         if (ret) {
 877                 if (reg == CMD_BBP_REG_ACCESS || reg == CMD_RF_REG_ACCESS)
 878                         *value = cmd.value.bbp_rf;
 879                 else if (reg == CMD_MAC_REG_ACCESS)
 880                         *value = le32_to_cpu(cmd.value.mac);
 881         }
 882
 883 out:
 884         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 885         return ret;
 886 }
 887
 888 /**
 889  *  @brief Write a MAC, Baseband, or RF register
 890  *
 891  *  @param priv         pointer to struct lbs_private
 892  *  @param cmd          register command, one of CMD_MAC_REG_ACCESS,
 893  *                        CMD_BBP_REG_ACCESS, or CMD_RF_REG_ACCESS
 894  *  @param offset       byte offset of the register to set
 895  *  @param value        the value to write to the register at 'offset'
 896  *
 897  *  @return             0 on success, error code on failure
 898 */
 899 int lbs_set_reg(struct lbs_private *priv, u16 reg, u16 offset, u32 value)
 900 {
 901         struct cmd_ds_reg_access cmd;
 902         int ret = 0;
 903
 904         lbs_deb_enter(LBS_DEB_CMD);
 905
 906         memset(&cmd, 0, sizeof(cmd));
 907         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
 908         cmd.action = cpu_to_le16(CMD_ACT_SET);
 909
 910         if (reg == CMD_BBP_REG_ACCESS || reg == CMD_RF_REG_ACCESS)
 911                 cmd.value.bbp_rf = (u8) (value & 0xFF);
 912         else if (reg == CMD_MAC_REG_ACCESS)
 913                 cmd.value.mac = cpu_to_le32(value);
 914         else {
 915                 ret = -EINVAL;
 916                 goto out;
 917         }
 918
 919         ret = lbs_cmd_with_response(priv, reg, &cmd);
 920
 921 out:
 922         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
 923         return ret;
 924 }
 925
 926 static void lbs_queue_cmd(struct lbs_private *priv,
 927                           struct cmd_ctrl_node *cmdnode)
 928 {
 929         unsigned long flags;
 930         int addtail = 1;
 931
 932         lbs_deb_enter(LBS_DEB_HOST);
 933
 934         if (!cmdnode) {
 935                 lbs_deb_host("QUEUE_CMD: cmdnode is NULL\n");
 936                 goto done;
 937         }
 938         if (!cmdnode->cmdbuf->size) {
 939                 lbs_deb_host("DNLD_CMD: cmd size is zero\n");
 940                 goto done;
 941         }
 942         cmdnode->result = 0;
 943
 944         /* Exit_PS command needs to be queued in the header always. */
 945         if (le16_to_cpu(cmdnode->cmdbuf->command) == CMD_802_11_PS_MODE) {
 946                 struct cmd_ds_802_11_ps_mode *psm = (void *) &cmdnode->cmdbuf;
 947
 948                 if (psm->action == cpu_to_le16(PS_MODE_ACTION_EXIT_PS)) {
 949                         if (priv->psstate != PS_STATE_FULL_POWER)
 950                                 addtail = 0;
 951                 }
 952         }
 953
 954         if (le16_to_cpu(cmdnode->cmdbuf->command) == CMD_802_11_WAKEUP_CONFIRM)
 955                 addtail = 0;
 956
 957         spin_lock_irqsave(&priv->driver_lock, flags);
 958
 959         if (addtail)
 960                 list_add_tail(&cmdnode->list, &priv->cmdpendingq);
 961         else
 962                 list_add(&cmdnode->list, &priv->cmdpendingq);
 963
 964         spin_unlock_irqrestore(&priv->driver_lock, flags);
 965
 966         lbs_deb_host("QUEUE_CMD: inserted command 0x%04x into cmdpendingq\n",
 967                      le16_to_cpu(cmdnode->cmdbuf->command));
 968
 969 done:
 970         lbs_deb_leave(LBS_DEB_HOST);
 971 }
 972
 973 static void lbs_submit_command(struct lbs_private *priv,
 974                                struct cmd_ctrl_node *cmdnode)
 975 {
 976         unsigned long flags;
 977         struct cmd_header *cmd;
 978         uint16_t cmdsize;
 979         uint16_t command;
 980         int timeo = 3 * HZ;
 981         int ret;
 982
 983         lbs_deb_enter(LBS_DEB_HOST);
 984
 985         cmd = cmdnode->cmdbuf;
 986
 987         spin_lock_irqsave(&priv->driver_lock, flags);
 988         priv->cur_cmd = cmdnode;
 989         spin_unlock_irqrestore(&priv->driver_lock, flags);
 990
 991         cmdsize = le16_to_cpu(cmd->size);
 992         command = le16_to_cpu(cmd->command);
 993
 994         /* These commands take longer */
 995         if (command == CMD_802_11_SCAN || command == CMD_802_11_ASSOCIATE)
 996                 timeo = 5 * HZ;
 997
 998         lbs_deb_cmd("DNLD_CMD: command 0x%04x, seq %d, size %d\n",
 999                      command, le16_to_cpu(cmd->seqnum), cmdsize);
1000         lbs_deb_hex(LBS_DEB_CMD, "DNLD_CMD", (void *) cmdnode->cmdbuf, cmdsize);
1001
1002         ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmd, cmdsize);
1003
1004         if (ret) {
1005                 lbs_pr_info("DNLD_CMD: hw_host_to_card failed: %d\n", ret);
1006                 /* Let the timer kick in and retry, and potentially reset
1007                    the whole thing if the condition persists */
1008                 timeo = HZ/4;
1009         }
1010
1011         if (command == CMD_802_11_DEEP_SLEEP) {
1012                 if (priv->is_auto_deep_sleep_enabled) {
1013                         priv->wakeup_dev_required = 1;
1014                         priv->dnld_sent = 0;
1015                 }
1016                 priv->is_deep_sleep = 1;
1017                 lbs_complete_command(priv, cmdnode, 0);
1018         } else {
1019                 /* Setup the timer after transmit command */
1020                 mod_timer(&priv->command_timer, jiffies + timeo);
1021         }
1022
1023         lbs_deb_leave(LBS_DEB_HOST);
1024 }
1025
1026 /**
1027  *  This function inserts command node to cmdfreeq
1028  *  after cleans it. Requires priv->driver_lock held.
1029  */
1030 static void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
1031                                          struct cmd_ctrl_node *cmdnode)
1032 {
1033         lbs_deb_enter(LBS_DEB_HOST);
1034
1035         if (!cmdnode)
1036                 goto out;
1037
1038         cmdnode->callback = NULL;
1039         cmdnode->callback_arg = 0;
1040
1041         memset(cmdnode->cmdbuf, 0, LBS_CMD_BUFFER_SIZE);
1042
1043         list_add_tail(&cmdnode->list, &priv->cmdfreeq);
1044  out:
1045         lbs_deb_leave(LBS_DEB_HOST);
1046 }
1047
1048 static void lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
1049         struct cmd_ctrl_node *ptempcmd)
1050 {
1051         unsigned long flags;
1052
1053         spin_lock_irqsave(&priv->driver_lock, flags);
1054         __lbs_cleanup_and_insert_cmd(priv, ptempcmd);
1055         spin_unlock_irqrestore(&priv->driver_lock, flags);
1056 }
1057
1058 void lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd,
1059                           int result)
1060 {
1061         cmd->result = result;
1062         cmd->cmdwaitqwoken = 1;
1063         wake_up_interruptible(&cmd->cmdwait_q);
1064
1065         if (!cmd->callback || cmd->callback == lbs_cmd_async_callback)
1066                 __lbs_cleanup_and_insert_cmd(priv, cmd);
1067         priv->cur_cmd = NULL;
1068 }
1069
1070 int lbs_set_radio(struct lbs_private *priv, u8 preamble, u8 radio_on)
1071 {
1072         struct cmd_ds_802_11_radio_control cmd;
1073         int ret = -EINVAL;
1074
1075         lbs_deb_enter(LBS_DEB_CMD);
1076
1077         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1078         cmd.action = cpu_to_le16(CMD_ACT_SET);
1079
1080         /* Only v8 and below support setting the preamble */
1081         if (priv->fwrelease < 0x09000000) {
1082                 switch (preamble) {
1083                 case RADIO_PREAMBLE_SHORT:
1084                 case RADIO_PREAMBLE_AUTO:
1085                 case RADIO_PREAMBLE_LONG:
1086                         cmd.control = cpu_to_le16(preamble);
1087                         break;
1088                 default:
1089                         goto out;
1090                 }
1091         }
1092
1093         if (radio_on)
1094                 cmd.control |= cpu_to_le16(0x1);
1095         else {
1096                 cmd.control &= cpu_to_le16(~0x1);
1097                 priv->txpower_cur = 0;
1098         }
1099
1100         lbs_deb_cmd("RADIO_CONTROL: radio %s, preamble %d\n",
1101                     radio_on ? "ON" : "OFF", preamble);
1102
1103         priv->radio_on = radio_on;
1104
1105         ret = lbs_cmd_with_response(priv, CMD_802_11_RADIO_CONTROL, &cmd);
1106
1107 out:
1108         lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1109         return ret;
1110 }
1111
1112 void lbs_set_mac_control(struct lbs_private *priv)
1113 {
1114         struct cmd_ds_mac_control cmd;
1115
1116         lbs_deb_enter(LBS_DEB_CMD);
1117
1118         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1119         cmd.action = cpu_to_le16(priv->mac_control);
1120         cmd.reserved = 0;
1121
1122         lbs_cmd_async(priv, CMD_MAC_CONTROL, &cmd.hdr, sizeof(cmd));
1123
1124         lbs_deb_leave(LBS_DEB_CMD);
1125 }
1126
1127 /**
1128  *  @brief This function allocates the command buffer and link
1129  *  it to command free queue.
1130  *
1131  *  @param priv         A pointer to struct lbs_private structure
1132  *  @return             0 or -1
1133  */
1134 int lbs_allocate_cmd_buffer(struct lbs_private *priv)
1135 {
1136         int ret = 0;
1137         u32 bufsize;
1138         u32 i;
1139         struct cmd_ctrl_node *cmdarray;
1140
1141         lbs_deb_enter(LBS_DEB_HOST);
1142
1143         /* Allocate and initialize the command array */
1144         bufsize = sizeof(struct cmd_ctrl_node) * LBS_NUM_CMD_BUFFERS;
1145         if (!(cmdarray = kzalloc(bufsize, GFP_KERNEL))) {
1146                 lbs_deb_host("ALLOC_CMD_BUF: tempcmd_array is NULL\n");
1147                 ret = -1;
1148                 goto done;
1149         }
1150         priv->cmd_array = cmdarray;
1151
1152         /* Allocate and initialize each command buffer in the command array */
1153         for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1154                 cmdarray[i].cmdbuf = kzalloc(LBS_CMD_BUFFER_SIZE, GFP_KERNEL);
1155                 if (!cmdarray[i].cmdbuf) {
1156                         lbs_deb_host("ALLOC_CMD_BUF: ptempvirtualaddr is NULL\n");
1157                         ret = -1;
1158                         goto done;
1159                 }
1160         }
1161
1162         for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1163                 init_waitqueue_head(&cmdarray[i].cmdwait_q);
1164                 lbs_cleanup_and_insert_cmd(priv, &cmdarray[i]);
1165         }
1166         ret = 0;
1167
1168 done:
1169         lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1170         return ret;
1171 }
1172
1173 /**
1174  *  @brief This function frees the command buffer.
1175  *
1176  *  @param priv         A pointer to struct lbs_private structure
1177  *  @return             0 or -1
1178  */
1179 int lbs_free_cmd_buffer(struct lbs_private *priv)
1180 {
1181         struct cmd_ctrl_node *cmdarray;
1182         unsigned int i;
1183
1184         lbs_deb_enter(LBS_DEB_HOST);
1185
1186         /* need to check if cmd array is allocated or not */
1187         if (priv->cmd_array == NULL) {
1188                 lbs_deb_host("FREE_CMD_BUF: cmd_array is NULL\n");
1189                 goto done;
1190         }
1191
1192         cmdarray = priv->cmd_array;
1193
1194         /* Release shared memory buffers */
1195         for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1196                 if (cmdarray[i].cmdbuf) {
1197                         kfree(cmdarray[i].cmdbuf);
1198                         cmdarray[i].cmdbuf = NULL;
1199                 }
1200         }
1201
1202         /* Release cmd_ctrl_node */
1203         if (priv->cmd_array) {
1204                 kfree(priv->cmd_array);
1205                 priv->cmd_array = NULL;
1206         }
1207
1208 done:
1209         lbs_deb_leave(LBS_DEB_HOST);
1210         return 0;
1211 }
1212
1213 /**
1214  *  @brief This function gets a free command node if available in
1215  *  command free queue.
1216  *
1217  *  @param priv         A pointer to struct lbs_private structure
1218  *  @return cmd_ctrl_node A pointer to cmd_ctrl_node structure or NULL
1219  */
1220 static struct cmd_ctrl_node *lbs_get_free_cmd_node(struct lbs_private *priv)
1221 {
1222         struct cmd_ctrl_node *tempnode;
1223         unsigned long flags;
1224
1225         lbs_deb_enter(LBS_DEB_HOST);
1226
1227         if (!priv)
1228                 return NULL;
1229
1230         spin_lock_irqsave(&priv->driver_lock, flags);
1231
1232         if (!list_empty(&priv->cmdfreeq)) {
1233                 tempnode = list_first_entry(&priv->cmdfreeq,
1234                                             struct cmd_ctrl_node, list);
1235                 list_del(&tempnode->list);
1236         } else {
1237                 lbs_deb_host("GET_CMD_NODE: cmd_ctrl_node is not available\n");
1238                 tempnode = NULL;
1239         }
1240
1241         spin_unlock_irqrestore(&priv->driver_lock, flags);
1242
1243         lbs_deb_leave(LBS_DEB_HOST);
1244         return tempnode;
1245 }
1246
1247 /**
1248  *  @brief This function executes next command in command
1249  *  pending queue. It will put firmware back to PS mode
1250  *  if applicable.
1251  *
1252  *  @param priv     A pointer to struct lbs_private structure
1253  *  @return        0 or -1
1254  */
1255 int lbs_execute_next_command(struct lbs_private *priv)
1256 {
1257         struct cmd_ctrl_node *cmdnode = NULL;
1258         struct cmd_header *cmd;
1259         unsigned long flags;
1260         int ret = 0;
1261
1262         /* Debug group is LBS_DEB_THREAD and not LBS_DEB_HOST, because the
1263          * only caller to us is lbs_thread() and we get even when a
1264          * data packet is received */
1265         lbs_deb_enter(LBS_DEB_THREAD);
1266
1267         spin_lock_irqsave(&priv->driver_lock, flags);
1268
1269         if (priv->cur_cmd) {
1270                 lbs_pr_alert( "EXEC_NEXT_CMD: already processing command!\n");
1271                 spin_unlock_irqrestore(&priv->driver_lock, flags);
1272                 ret = -1;
1273                 goto done;
1274         }
1275
1276         if (!list_empty(&priv->cmdpendingq)) {
1277                 cmdnode = list_first_entry(&priv->cmdpendingq,
1278                                            struct cmd_ctrl_node, list);
1279         }
1280
1281         spin_unlock_irqrestore(&priv->driver_lock, flags);
1282
1283         if (cmdnode) {
1284                 cmd = cmdnode->cmdbuf;
1285
1286                 if (is_command_allowed_in_ps(le16_to_cpu(cmd->command))) {
1287                         if ((priv->psstate == PS_STATE_SLEEP) ||
1288                             (priv->psstate == PS_STATE_PRE_SLEEP)) {
1289                                 lbs_deb_host(
1290                                        "EXEC_NEXT_CMD: cannot send cmd 0x%04x in psstate %d\n",
1291                                        le16_to_cpu(cmd->command),
1292                                        priv->psstate);
1293                                 ret = -1;
1294                                 goto done;
1295                         }
1296                         lbs_deb_host("EXEC_NEXT_CMD: OK to send command "
1297                                      "0x%04x in psstate %d\n",
1298                                      le16_to_cpu(cmd->command), priv->psstate);
1299                 } else if (priv->psstate != PS_STATE_FULL_POWER) {
1300                         /*
1301                          * 1. Non-PS command:
1302                          * Queue it. set needtowakeup to TRUE if current state
1303                          * is SLEEP, otherwise call send EXIT_PS.
1304                          * 2. PS command but not EXIT_PS:
1305                          * Ignore it.
1306                          * 3. PS command EXIT_PS:
1307                          * Set needtowakeup to TRUE if current state is SLEEP,
1308                          * otherwise send this command down to firmware
1309                          * immediately.
1310                          */
1311                         if (cmd->command != cpu_to_le16(CMD_802_11_PS_MODE)) {
1312                                 /*  Prepare to send Exit PS,
1313                                  *  this non PS command will be sent later */
1314                                 if ((priv->psstate == PS_STATE_SLEEP)
1315                                     || (priv->psstate == PS_STATE_PRE_SLEEP)
1316                                     ) {
1317                                         /* w/ new scheme, it will not reach here.
1318                                            since it is blocked in main_thread. */
1319                                         priv->needtowakeup = 1;
1320                                 } else {
1321                                         lbs_set_ps_mode(priv,
1322                                                         PS_MODE_ACTION_EXIT_PS,
1323                                                         false);
1324                                 }
1325
1326                                 ret = 0;
1327                                 goto done;
1328                         } else {
1329                                 /*
1330                                  * PS command. Ignore it if it is not Exit_PS.
1331                                  * otherwise send it down immediately.
1332                                  */
1333                                 struct cmd_ds_802_11_ps_mode *psm = (void *)&cmd[1];
1334
1335                                 lbs_deb_host(
1336                                        "EXEC_NEXT_CMD: PS cmd, action 0x%02x\n",
1337                                        psm->action);
1338                                 if (psm->action !=
1339                                     cpu_to_le16(PS_MODE_ACTION_EXIT_PS)) {
1340                                         lbs_deb_host(
1341                                                "EXEC_NEXT_CMD: ignore ENTER_PS cmd\n");
1342                                         spin_lock_irqsave(&priv->driver_lock, flags);
1343                                         list_del(&cmdnode->list);
1344                                         lbs_complete_command(priv, cmdnode, 0);
1345                                         spin_unlock_irqrestore(&priv->driver_lock, flags);
1346
1347                                         ret = 0;
1348                                         goto done;
1349                                 }
1350
1351                                 if ((priv->psstate == PS_STATE_SLEEP) ||
1352                                     (priv->psstate == PS_STATE_PRE_SLEEP)) {
1353                                         lbs_deb_host(
1354                                                "EXEC_NEXT_CMD: ignore EXIT_PS cmd in sleep\n");
1355                                         spin_lock_irqsave(&priv->driver_lock, flags);
1356                                         list_del(&cmdnode->list);
1357                                         lbs_complete_command(priv, cmdnode, 0);
1358                                         spin_unlock_irqrestore(&priv->driver_lock, flags);
1359                                         priv->needtowakeup = 1;
1360
1361                                         ret = 0;
1362                                         goto done;
1363                                 }
1364
1365                                 lbs_deb_host(
1366                                        "EXEC_NEXT_CMD: sending EXIT_PS\n");
1367                         }
1368                 }
1369                 spin_lock_irqsave(&priv->driver_lock, flags);
1370                 list_del(&cmdnode->list);
1371                 spin_unlock_irqrestore(&priv->driver_lock, flags);
1372                 lbs_deb_host("EXEC_NEXT_CMD: sending command 0x%04x\n",
1373                             le16_to_cpu(cmd->command));
1374                 lbs_submit_command(priv, cmdnode);
1375         } else {
1376                 /*
1377                  * check if in power save mode, if yes, put the device back
1378                  * to PS mode
1379                  */
1380 #ifdef TODO
1381                 /*
1382                  * This was the old code for libertas+wext. Someone that
1383                  * understands this beast should re-code it in a sane way.
1384                  *
1385                  * I actually don't understand why this is related to WPA
1386                  * and to connection status, shouldn't powering should be
1387                  * independ of such things?
1388                  */
1389                 if ((priv->psmode != LBS802_11POWERMODECAM) &&
1390                     (priv->psstate == PS_STATE_FULL_POWER) &&
1391                     ((priv->connect_status == LBS_CONNECTED) ||
1392                     lbs_mesh_connected(priv))) {
1393                         if (priv->secinfo.WPAenabled ||
1394                             priv->secinfo.WPA2enabled) {
1395                                 /* check for valid WPA group keys */
1396                                 if (priv->wpa_mcast_key.len ||
1397                                     priv->wpa_unicast_key.len) {
1398                                         lbs_deb_host(
1399                                                "EXEC_NEXT_CMD: WPA enabled and GTK_SET"
1400                                                " go back to PS_SLEEP");
1401                                         lbs_set_ps_mode(priv,
1402                                                         PS_MODE_ACTION_ENTER_PS,
1403                                                         false);
1404                                 }
1405                         } else {
1406                                 lbs_deb_host(
1407                                        "EXEC_NEXT_CMD: cmdpendingq empty, "
1408                                        "go back to PS_SLEEP");
1409                                 lbs_set_ps_mode(priv, PS_MODE_ACTION_ENTER_PS,
1410                                                 false);
1411                         }
1412                 }
1413 #endif
1414         }
1415
1416         ret = 0;
1417 done:
1418         lbs_deb_leave(LBS_DEB_THREAD);
1419         return ret;
1420 }
1421
1422 static void lbs_send_confirmsleep(struct lbs_private *priv)
1423 {
1424         unsigned long flags;
1425         int ret;
1426
1427         lbs_deb_enter(LBS_DEB_HOST);
1428         lbs_deb_hex(LBS_DEB_HOST, "sleep confirm", (u8 *) &confirm_sleep,
1429                 sizeof(confirm_sleep));
1430
1431         ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) &confirm_sleep,
1432                 sizeof(confirm_sleep));
1433         if (ret) {
1434                 lbs_pr_alert("confirm_sleep failed\n");
1435                 goto out;
1436         }
1437
1438         spin_lock_irqsave(&priv->driver_lock, flags);
1439
1440         /* We don't get a response on the sleep-confirmation */
1441         priv->dnld_sent = DNLD_RES_RECEIVED;
1442
1443         if (priv->is_host_sleep_configured) {
1444                 priv->is_host_sleep_activated = 1;
1445                 wake_up_interruptible(&priv->host_sleep_q);
1446         }
1447
1448         /* If nothing to do, go back to sleep (?) */
1449         if (!kfifo_len(&priv->event_fifo) && !priv->resp_len[priv->resp_idx])
1450                 priv->psstate = PS_STATE_SLEEP;
1451
1452         spin_unlock_irqrestore(&priv->driver_lock, flags);
1453
1454 out:
1455         lbs_deb_leave(LBS_DEB_HOST);
1456 }
1457
1458 /**
1459  *  @brief This function checks condition and prepares to
1460  *  send sleep confirm command to firmware if ok.
1461  *
1462  *  @param priv         A pointer to struct lbs_private structure
1463  *  @param psmode       Power Saving mode
1464  *  @return             n/a
1465  */
1466 void lbs_ps_confirm_sleep(struct lbs_private *priv)
1467 {
1468         unsigned long flags =0;
1469         int allowed = 1;
1470
1471         lbs_deb_enter(LBS_DEB_HOST);
1472
1473         spin_lock_irqsave(&priv->driver_lock, flags);
1474         if (priv->dnld_sent) {
1475                 allowed = 0;
1476                 lbs_deb_host("dnld_sent was set\n");
1477         }
1478
1479         /* In-progress command? */
1480         if (priv->cur_cmd) {
1481                 allowed = 0;
1482                 lbs_deb_host("cur_cmd was set\n");
1483         }
1484
1485         /* Pending events or command responses? */
1486         if (kfifo_len(&priv->event_fifo) || priv->resp_len[priv->resp_idx]) {
1487                 allowed = 0;
1488                 lbs_deb_host("pending events or command responses\n");
1489         }
1490         spin_unlock_irqrestore(&priv->driver_lock, flags);
1491
1492         if (allowed) {
1493                 lbs_deb_host("sending lbs_ps_confirm_sleep\n");
1494                 lbs_send_confirmsleep(priv);
1495         } else {
1496                 lbs_deb_host("sleep confirm has been delayed\n");
1497         }
1498
1499         lbs_deb_leave(LBS_DEB_HOST);
1500 }
1501
1502
1503 /**
1504  * @brief Configures the transmission power control functionality.
1505  *
1506  * @param priv          A pointer to struct lbs_private structure
1507  * @param enable        Transmission power control enable
1508  * @param p0            Power level when link quality is good (dBm).
1509  * @param p1            Power level when link quality is fair (dBm).
1510  * @param p2            Power level when link quality is poor (dBm).
1511  * @param usesnr        Use Signal to Noise Ratio in TPC
1512  *
1513  * @return 0 on success
1514  */
1515 int lbs_set_tpc_cfg(struct lbs_private *priv, int enable, int8_t p0, int8_t p1,
1516                 int8_t p2, int usesnr)
1517 {
1518         struct cmd_ds_802_11_tpc_cfg cmd;
1519         int ret;
1520
1521         memset(&cmd, 0, sizeof(cmd));
1522         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1523         cmd.action = cpu_to_le16(CMD_ACT_SET);
1524         cmd.enable = !!enable;
1525         cmd.usesnr = !!usesnr;
1526         cmd.P0 = p0;
1527         cmd.P1 = p1;
1528         cmd.P2 = p2;
1529
1530         ret = lbs_cmd_with_response(priv, CMD_802_11_TPC_CFG, &cmd);
1531
1532         return ret;
1533 }
1534
1535 /**
1536  * @brief Configures the power adaptation settings.
1537  *
1538  * @param priv          A pointer to struct lbs_private structure
1539  * @param enable        Power adaptation enable
1540  * @param p0            Power level for 1, 2, 5.5 and 11 Mbps (dBm).
1541  * @param p1            Power level for 6, 9, 12, 18, 22, 24 and 36 Mbps (dBm).
1542  * @param p2            Power level for 48 and 54 Mbps (dBm).
1543  *
1544  * @return 0 on Success
1545  */
1546
1547 int lbs_set_power_adapt_cfg(struct lbs_private *priv, int enable, int8_t p0,
1548                 int8_t p1, int8_t p2)
1549 {
1550         struct cmd_ds_802_11_pa_cfg cmd;
1551         int ret;
1552
1553         memset(&cmd, 0, sizeof(cmd));
1554         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1555         cmd.action = cpu_to_le16(CMD_ACT_SET);
1556         cmd.enable = !!enable;
1557         cmd.P0 = p0;
1558         cmd.P1 = p1;
1559         cmd.P2 = p2;
1560
1561         ret = lbs_cmd_with_response(priv, CMD_802_11_PA_CFG , &cmd);
1562
1563         return ret;
1564 }
1565
1566
1567 struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv,
1568         uint16_t command, struct cmd_header *in_cmd, int in_cmd_size,
1569         int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
1570         unsigned long callback_arg)
1571 {
1572         struct cmd_ctrl_node *cmdnode;
1573
1574         lbs_deb_enter(LBS_DEB_HOST);
1575
1576         if (priv->surpriseremoved) {
1577                 lbs_deb_host("PREP_CMD: card removed\n");
1578                 cmdnode = ERR_PTR(-ENOENT);
1579                 goto done;
1580         }
1581
1582         /* No commands are allowed in Deep Sleep until we toggle the GPIO
1583          * to wake up the card and it has signaled that it's ready.
1584          */
1585         if (!priv->is_auto_deep_sleep_enabled) {
1586                 if (priv->is_deep_sleep) {
1587                         lbs_deb_cmd("command not allowed in deep sleep\n");
1588                         cmdnode = ERR_PTR(-EBUSY);
1589                         goto done;
1590                 }
1591         }
1592
1593         cmdnode = lbs_get_free_cmd_node(priv);
1594         if (cmdnode == NULL) {
1595                 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
1596
1597                 /* Wake up main thread to execute next command */
1598                 wake_up_interruptible(&priv->waitq);
1599                 cmdnode = ERR_PTR(-ENOBUFS);
1600                 goto done;
1601         }
1602
1603         cmdnode->callback = callback;
1604         cmdnode->callback_arg = callback_arg;
1605
1606         /* Copy the incoming command to the buffer */
1607         memcpy(cmdnode->cmdbuf, in_cmd, in_cmd_size);
1608
1609         /* Set sequence number, clean result, move to buffer */
1610         priv->seqnum++;
1611         cmdnode->cmdbuf->command = cpu_to_le16(command);
1612         cmdnode->cmdbuf->size    = cpu_to_le16(in_cmd_size);
1613         cmdnode->cmdbuf->seqnum  = cpu_to_le16(priv->seqnum);
1614         cmdnode->cmdbuf->result  = 0;
1615
1616         lbs_deb_host("PREP_CMD: command 0x%04x\n", command);
1617
1618         cmdnode->cmdwaitqwoken = 0;
1619         lbs_queue_cmd(priv, cmdnode);
1620         wake_up_interruptible(&priv->waitq);
1621
1622  done:
1623         lbs_deb_leave_args(LBS_DEB_HOST, "ret %p", cmdnode);
1624         return cmdnode;
1625 }
1626
1627 void lbs_cmd_async(struct lbs_private *priv, uint16_t command,
1628         struct cmd_header *in_cmd, int in_cmd_size)
1629 {
1630         lbs_deb_enter(LBS_DEB_CMD);
1631         __lbs_cmd_async(priv, command, in_cmd, in_cmd_size,
1632                 lbs_cmd_async_callback, 0);
1633         lbs_deb_leave(LBS_DEB_CMD);
1634 }
1635
1636 int __lbs_cmd(struct lbs_private *priv, uint16_t command,
1637               struct cmd_header *in_cmd, int in_cmd_size,
1638               int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
1639               unsigned long callback_arg)
1640 {
1641         struct cmd_ctrl_node *cmdnode;
1642         unsigned long flags;
1643         int ret = 0;
1644
1645         lbs_deb_enter(LBS_DEB_HOST);
1646
1647         cmdnode = __lbs_cmd_async(priv, command, in_cmd, in_cmd_size,
1648                                   callback, callback_arg);
1649         if (IS_ERR(cmdnode)) {
1650                 ret = PTR_ERR(cmdnode);
1651                 goto done;
1652         }
1653
1654         might_sleep();
1655         wait_event_interruptible(cmdnode->cmdwait_q, cmdnode->cmdwaitqwoken);
1656
1657         spin_lock_irqsave(&priv->driver_lock, flags);
1658         ret = cmdnode->result;
1659         if (ret)
1660                 lbs_pr_info("PREP_CMD: command 0x%04x failed: %d\n",
1661                             command, ret);
1662
1663         __lbs_cleanup_and_insert_cmd(priv, cmdnode);
1664         spin_unlock_irqrestore(&priv->driver_lock, flags);
1665
1666 done:
1667         lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1668         return ret;
1669 }
1670 EXPORT_SYMBOL_GPL(__lbs_cmd);