cmd.c revision 2ae1b8b35faba31a59b153cbad07f9c15de99740
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 */ 28int 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} 38EXPORT_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 */ 51static 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 */ 64static 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 */ 84int 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 156out: 157 lbs_deb_leave(LBS_DEB_CMD); 158 return ret; 159} 160 161static 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 178int 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} 217EXPORT_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 */ 229int 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 259out: 260 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); 261 return ret; 262} 263 264int 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 306static 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 324int 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 360static 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 371int 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 */ 428int 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 464out: 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 */ 478int 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 507out: 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 */ 522int 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 */ 555int 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 */ 583int 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 */ 613static 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 631out: 632 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); 633 return ret; 634} 635 636int 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 */ 660int 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 683out: 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 */ 696int 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*/ 730int 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*/ 855int 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 883out: 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*/ 899int 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 921out: 922 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); 923 return ret; 924} 925 926static 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 969done: 970 lbs_deb_leave(LBS_DEB_HOST); 971} 972 973static 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 */ 1030static 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 1048static 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 1058void 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 1070int 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 1107out: 1108 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret); 1109 return ret; 1110} 1111 1112void 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 */ 1134int 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 1168done: 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 */ 1179int 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 1208done: 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 */ 1220static 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 */ 1255int 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; 1417done: 1418 lbs_deb_leave(LBS_DEB_THREAD); 1419 return ret; 1420} 1421 1422static 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 1454out: 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 */ 1466void 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 */ 1515int 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 1547int 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 1567struct 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 1627void 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 1636int __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 1666done: 1667 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret); 1668 return ret; 1669} 1670EXPORT_SYMBOL_GPL(__lbs_cmd); 1671