1 /* 2 * Marvell Wireless LAN device driver: major functions 3 * 4 * Copyright (C) 2011-2014, Marvell International Ltd. 5 * 6 * This software file (the "File") is distributed by Marvell International 7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991 8 * (the "License"). You may use, redistribute and/or modify this File in 9 * accordance with the terms and conditions of the License, a copy of which 10 * is available by writing to the Free Software Foundation, Inc., 11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the 12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. 13 * 14 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE 16 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about 17 * this warranty disclaimer. 18 */ 19 20 #include "main.h" 21 #include "wmm.h" 22 #include "cfg80211.h" 23 #include "11n.h" 24 25 #define VERSION "1.0" 26 #define MFG_FIRMWARE "mwifiex_mfg.bin" 27 28 static unsigned int debug_mask = MWIFIEX_DEFAULT_DEBUG_MASK; 29 module_param(debug_mask, uint, 0); 30 MODULE_PARM_DESC(debug_mask, "bitmap for debug flags"); 31 32 const char driver_version[] = "mwifiex " VERSION " (%s) "; 33 static char *cal_data_cfg; 34 module_param(cal_data_cfg, charp, 0); 35 36 static unsigned short driver_mode; 37 module_param(driver_mode, ushort, 0); 38 MODULE_PARM_DESC(driver_mode, 39 "station=0x1(default), ap-sta=0x3, station-p2p=0x5, ap-sta-p2p=0x7"); 40 41 bool mfg_mode; 42 module_param(mfg_mode, bool, 0); 43 MODULE_PARM_DESC(mfg_mode, "manufacturing mode enable:1, disable:0"); 44 45 /* 46 * This function registers the device and performs all the necessary 47 * initializations. 48 * 49 * The following initialization operations are performed - 50 * - Allocate adapter structure 51 * - Save interface specific operations table in adapter 52 * - Call interface specific initialization routine 53 * - Allocate private structures 54 * - Set default adapter structure parameters 55 * - Initialize locks 56 * 57 * In case of any errors during inittialization, this function also ensures 58 * proper cleanup before exiting. 59 */ 60 static int mwifiex_register(void *card, struct mwifiex_if_ops *if_ops, 61 void **padapter) 62 { 63 struct mwifiex_adapter *adapter; 64 int i; 65 66 adapter = kzalloc(sizeof(struct mwifiex_adapter), GFP_KERNEL); 67 if (!adapter) 68 return -ENOMEM; 69 70 *padapter = adapter; 71 adapter->card = card; 72 73 /* Save interface specific operations in adapter */ 74 memmove(&adapter->if_ops, if_ops, sizeof(struct mwifiex_if_ops)); 75 adapter->debug_mask = debug_mask; 76 77 /* card specific initialization has been deferred until now .. */ 78 if (adapter->if_ops.init_if) 79 if (adapter->if_ops.init_if(adapter)) 80 goto error; 81 82 adapter->priv_num = 0; 83 84 for (i = 0; i < MWIFIEX_MAX_BSS_NUM; i++) { 85 /* Allocate memory for private structure */ 86 adapter->priv[i] = 87 kzalloc(sizeof(struct mwifiex_private), GFP_KERNEL); 88 if (!adapter->priv[i]) 89 goto error; 90 91 adapter->priv[i]->adapter = adapter; 92 adapter->priv_num++; 93 } 94 mwifiex_init_lock_list(adapter); 95 96 setup_timer(&adapter->cmd_timer, mwifiex_cmd_timeout_func, 97 (unsigned long)adapter); 98 99 return 0; 100 101 error: 102 mwifiex_dbg(adapter, ERROR, 103 "info: leave mwifiex_register with error\n"); 104 105 for (i = 0; i < adapter->priv_num; i++) 106 kfree(adapter->priv[i]); 107 108 kfree(adapter); 109 110 return -1; 111 } 112 113 /* 114 * This function unregisters the device and performs all the necessary 115 * cleanups. 116 * 117 * The following cleanup operations are performed - 118 * - Free the timers 119 * - Free beacon buffers 120 * - Free private structures 121 * - Free adapter structure 122 */ 123 static int mwifiex_unregister(struct mwifiex_adapter *adapter) 124 { 125 s32 i; 126 127 if (adapter->if_ops.cleanup_if) 128 adapter->if_ops.cleanup_if(adapter); 129 130 del_timer_sync(&adapter->cmd_timer); 131 132 /* Free private structures */ 133 for (i = 0; i < adapter->priv_num; i++) { 134 if (adapter->priv[i]) { 135 mwifiex_free_curr_bcn(adapter->priv[i]); 136 kfree(adapter->priv[i]); 137 } 138 } 139 140 if (adapter->nd_info) { 141 for (i = 0 ; i < adapter->nd_info->n_matches ; i++) 142 kfree(adapter->nd_info->matches[i]); 143 kfree(adapter->nd_info); 144 adapter->nd_info = NULL; 145 } 146 147 kfree(adapter->regd); 148 149 vfree(adapter->chan_stats); 150 kfree(adapter); 151 return 0; 152 } 153 154 void mwifiex_queue_main_work(struct mwifiex_adapter *adapter) 155 { 156 unsigned long flags; 157 158 spin_lock_irqsave(&adapter->main_proc_lock, flags); 159 if (adapter->mwifiex_processing) { 160 adapter->more_task_flag = true; 161 spin_unlock_irqrestore(&adapter->main_proc_lock, flags); 162 } else { 163 spin_unlock_irqrestore(&adapter->main_proc_lock, flags); 164 queue_work(adapter->workqueue, &adapter->main_work); 165 } 166 } 167 EXPORT_SYMBOL_GPL(mwifiex_queue_main_work); 168 169 static void mwifiex_queue_rx_work(struct mwifiex_adapter *adapter) 170 { 171 unsigned long flags; 172 173 spin_lock_irqsave(&adapter->rx_proc_lock, flags); 174 if (adapter->rx_processing) { 175 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags); 176 } else { 177 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags); 178 queue_work(adapter->rx_workqueue, &adapter->rx_work); 179 } 180 } 181 182 static int mwifiex_process_rx(struct mwifiex_adapter *adapter) 183 { 184 unsigned long flags; 185 struct sk_buff *skb; 186 struct mwifiex_rxinfo *rx_info; 187 188 spin_lock_irqsave(&adapter->rx_proc_lock, flags); 189 if (adapter->rx_processing || adapter->rx_locked) { 190 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags); 191 goto exit_rx_proc; 192 } else { 193 adapter->rx_processing = true; 194 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags); 195 } 196 197 /* Check for Rx data */ 198 while ((skb = skb_dequeue(&adapter->rx_data_q))) { 199 atomic_dec(&adapter->rx_pending); 200 if ((adapter->delay_main_work || 201 adapter->iface_type == MWIFIEX_USB) && 202 (atomic_read(&adapter->rx_pending) < LOW_RX_PENDING)) { 203 if (adapter->if_ops.submit_rem_rx_urbs) 204 adapter->if_ops.submit_rem_rx_urbs(adapter); 205 adapter->delay_main_work = false; 206 mwifiex_queue_main_work(adapter); 207 } 208 rx_info = MWIFIEX_SKB_RXCB(skb); 209 if (rx_info->buf_type == MWIFIEX_TYPE_AGGR_DATA) { 210 if (adapter->if_ops.deaggr_pkt) 211 adapter->if_ops.deaggr_pkt(adapter, skb); 212 dev_kfree_skb_any(skb); 213 } else { 214 mwifiex_handle_rx_packet(adapter, skb); 215 } 216 } 217 spin_lock_irqsave(&adapter->rx_proc_lock, flags); 218 adapter->rx_processing = false; 219 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags); 220 221 exit_rx_proc: 222 return 0; 223 } 224 225 /* 226 * The main process. 227 * 228 * This function is the main procedure of the driver and handles various driver 229 * operations. It runs in a loop and provides the core functionalities. 230 * 231 * The main responsibilities of this function are - 232 * - Ensure concurrency control 233 * - Handle pending interrupts and call interrupt handlers 234 * - Wake up the card if required 235 * - Handle command responses and call response handlers 236 * - Handle events and call event handlers 237 * - Execute pending commands 238 * - Transmit pending data packets 239 */ 240 int mwifiex_main_process(struct mwifiex_adapter *adapter) 241 { 242 int ret = 0; 243 unsigned long flags; 244 245 spin_lock_irqsave(&adapter->main_proc_lock, flags); 246 247 /* Check if already processing */ 248 if (adapter->mwifiex_processing || adapter->main_locked) { 249 adapter->more_task_flag = true; 250 spin_unlock_irqrestore(&adapter->main_proc_lock, flags); 251 goto exit_main_proc; 252 } else { 253 adapter->mwifiex_processing = true; 254 spin_unlock_irqrestore(&adapter->main_proc_lock, flags); 255 } 256 process_start: 257 do { 258 if ((adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING) || 259 (adapter->hw_status == MWIFIEX_HW_STATUS_NOT_READY)) 260 break; 261 262 /* For non-USB interfaces, If we process interrupts first, it 263 * would increase RX pending even further. Avoid this by 264 * checking if rx_pending has crossed high threshold and 265 * schedule rx work queue and then process interrupts. 266 * For USB interface, there are no interrupts. We already have 267 * HIGH_RX_PENDING check in usb.c 268 */ 269 if (atomic_read(&adapter->rx_pending) >= HIGH_RX_PENDING && 270 adapter->iface_type != MWIFIEX_USB) { 271 adapter->delay_main_work = true; 272 mwifiex_queue_rx_work(adapter); 273 break; 274 } 275 276 /* Handle pending interrupt if any */ 277 if (adapter->int_status) { 278 if (adapter->hs_activated) 279 mwifiex_process_hs_config(adapter); 280 if (adapter->if_ops.process_int_status) 281 adapter->if_ops.process_int_status(adapter); 282 } 283 284 if (adapter->rx_work_enabled && adapter->data_received) 285 mwifiex_queue_rx_work(adapter); 286 287 /* Need to wake up the card ? */ 288 if ((adapter->ps_state == PS_STATE_SLEEP) && 289 (adapter->pm_wakeup_card_req && 290 !adapter->pm_wakeup_fw_try) && 291 (is_command_pending(adapter) || 292 !skb_queue_empty(&adapter->tx_data_q) || 293 !mwifiex_bypass_txlist_empty(adapter) || 294 !mwifiex_wmm_lists_empty(adapter))) { 295 adapter->pm_wakeup_fw_try = true; 296 mod_timer(&adapter->wakeup_timer, jiffies + (HZ*3)); 297 adapter->if_ops.wakeup(adapter); 298 continue; 299 } 300 301 if (IS_CARD_RX_RCVD(adapter)) { 302 adapter->data_received = false; 303 adapter->pm_wakeup_fw_try = false; 304 del_timer(&adapter->wakeup_timer); 305 if (adapter->ps_state == PS_STATE_SLEEP) 306 adapter->ps_state = PS_STATE_AWAKE; 307 } else { 308 /* We have tried to wakeup the card already */ 309 if (adapter->pm_wakeup_fw_try) 310 break; 311 if (adapter->ps_state != PS_STATE_AWAKE) 312 break; 313 if (adapter->tx_lock_flag) { 314 if (adapter->iface_type == MWIFIEX_USB) { 315 if (!adapter->usb_mc_setup) 316 break; 317 } else 318 break; 319 } 320 321 if ((!adapter->scan_chan_gap_enabled && 322 adapter->scan_processing) || adapter->data_sent || 323 mwifiex_is_tdls_chan_switching 324 (mwifiex_get_priv(adapter, 325 MWIFIEX_BSS_ROLE_STA)) || 326 (mwifiex_wmm_lists_empty(adapter) && 327 mwifiex_bypass_txlist_empty(adapter) && 328 skb_queue_empty(&adapter->tx_data_q))) { 329 if (adapter->cmd_sent || adapter->curr_cmd || 330 !mwifiex_is_send_cmd_allowed 331 (mwifiex_get_priv(adapter, 332 MWIFIEX_BSS_ROLE_STA)) || 333 (!is_command_pending(adapter))) 334 break; 335 } 336 } 337 338 /* Check for event */ 339 if (adapter->event_received) { 340 adapter->event_received = false; 341 mwifiex_process_event(adapter); 342 } 343 344 /* Check for Cmd Resp */ 345 if (adapter->cmd_resp_received) { 346 adapter->cmd_resp_received = false; 347 mwifiex_process_cmdresp(adapter); 348 349 /* call mwifiex back when init_fw is done */ 350 if (adapter->hw_status == MWIFIEX_HW_STATUS_INIT_DONE) { 351 adapter->hw_status = MWIFIEX_HW_STATUS_READY; 352 mwifiex_init_fw_complete(adapter); 353 } 354 } 355 356 /* Check if we need to confirm Sleep Request 357 received previously */ 358 if (adapter->ps_state == PS_STATE_PRE_SLEEP) { 359 if (!adapter->cmd_sent && !adapter->curr_cmd) 360 mwifiex_check_ps_cond(adapter); 361 } 362 363 /* * The ps_state may have been changed during processing of 364 * Sleep Request event. 365 */ 366 if ((adapter->ps_state == PS_STATE_SLEEP) || 367 (adapter->ps_state == PS_STATE_PRE_SLEEP) || 368 (adapter->ps_state == PS_STATE_SLEEP_CFM)) { 369 continue; 370 } 371 372 if (adapter->tx_lock_flag) { 373 if (adapter->iface_type == MWIFIEX_USB) { 374 if (!adapter->usb_mc_setup) 375 continue; 376 } else 377 continue; 378 } 379 380 if (!adapter->cmd_sent && !adapter->curr_cmd && 381 mwifiex_is_send_cmd_allowed 382 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) { 383 if (mwifiex_exec_next_cmd(adapter) == -1) { 384 ret = -1; 385 break; 386 } 387 } 388 389 /** If USB Multi channel setup ongoing, 390 * wait for ready to tx data. 391 */ 392 if (adapter->iface_type == MWIFIEX_USB && 393 adapter->usb_mc_setup) 394 continue; 395 396 if ((adapter->scan_chan_gap_enabled || 397 !adapter->scan_processing) && 398 !adapter->data_sent && 399 !skb_queue_empty(&adapter->tx_data_q)) { 400 mwifiex_process_tx_queue(adapter); 401 if (adapter->hs_activated) { 402 adapter->is_hs_configured = false; 403 mwifiex_hs_activated_event 404 (mwifiex_get_priv 405 (adapter, MWIFIEX_BSS_ROLE_ANY), 406 false); 407 } 408 } 409 410 if ((adapter->scan_chan_gap_enabled || 411 !adapter->scan_processing) && 412 !adapter->data_sent && 413 !mwifiex_bypass_txlist_empty(adapter) && 414 !mwifiex_is_tdls_chan_switching 415 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) { 416 mwifiex_process_bypass_tx(adapter); 417 if (adapter->hs_activated) { 418 adapter->is_hs_configured = false; 419 mwifiex_hs_activated_event 420 (mwifiex_get_priv 421 (adapter, MWIFIEX_BSS_ROLE_ANY), 422 false); 423 } 424 } 425 426 if ((adapter->scan_chan_gap_enabled || 427 !adapter->scan_processing) && 428 !adapter->data_sent && !mwifiex_wmm_lists_empty(adapter) && 429 !mwifiex_is_tdls_chan_switching 430 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) { 431 mwifiex_wmm_process_tx(adapter); 432 if (adapter->hs_activated) { 433 adapter->is_hs_configured = false; 434 mwifiex_hs_activated_event 435 (mwifiex_get_priv 436 (adapter, MWIFIEX_BSS_ROLE_ANY), 437 false); 438 } 439 } 440 441 if (adapter->delay_null_pkt && !adapter->cmd_sent && 442 !adapter->curr_cmd && !is_command_pending(adapter) && 443 (mwifiex_wmm_lists_empty(adapter) && 444 mwifiex_bypass_txlist_empty(adapter) && 445 skb_queue_empty(&adapter->tx_data_q))) { 446 if (!mwifiex_send_null_packet 447 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA), 448 MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET | 449 MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET)) { 450 adapter->delay_null_pkt = false; 451 adapter->ps_state = PS_STATE_SLEEP; 452 } 453 break; 454 } 455 } while (true); 456 457 spin_lock_irqsave(&adapter->main_proc_lock, flags); 458 if (adapter->more_task_flag) { 459 adapter->more_task_flag = false; 460 spin_unlock_irqrestore(&adapter->main_proc_lock, flags); 461 goto process_start; 462 } 463 adapter->mwifiex_processing = false; 464 spin_unlock_irqrestore(&adapter->main_proc_lock, flags); 465 466 exit_main_proc: 467 if (adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING) 468 mwifiex_shutdown_drv(adapter); 469 return ret; 470 } 471 EXPORT_SYMBOL_GPL(mwifiex_main_process); 472 473 /* 474 * This function frees the adapter structure. 475 * 476 * Additionally, this closes the netlink socket, frees the timers 477 * and private structures. 478 */ 479 static void mwifiex_free_adapter(struct mwifiex_adapter *adapter) 480 { 481 if (!adapter) { 482 pr_err("%s: adapter is NULL\n", __func__); 483 return; 484 } 485 486 mwifiex_unregister(adapter); 487 pr_debug("info: %s: free adapter\n", __func__); 488 } 489 490 /* 491 * This function cancels all works in the queue and destroys 492 * the main workqueue. 493 */ 494 static void mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter) 495 { 496 if (adapter->workqueue) { 497 flush_workqueue(adapter->workqueue); 498 destroy_workqueue(adapter->workqueue); 499 adapter->workqueue = NULL; 500 } 501 502 if (adapter->rx_workqueue) { 503 flush_workqueue(adapter->rx_workqueue); 504 destroy_workqueue(adapter->rx_workqueue); 505 adapter->rx_workqueue = NULL; 506 } 507 } 508 509 /* 510 * This function gets firmware and initializes it. 511 * 512 * The main initialization steps followed are - 513 * - Download the correct firmware to card 514 * - Issue the init commands to firmware 515 */ 516 static void mwifiex_fw_dpc(const struct firmware *firmware, void *context) 517 { 518 int ret; 519 char fmt[64]; 520 struct mwifiex_private *priv; 521 struct mwifiex_adapter *adapter = context; 522 struct mwifiex_fw_image fw; 523 struct semaphore *sem = adapter->card_sem; 524 bool init_failed = false; 525 struct wireless_dev *wdev; 526 527 if (!firmware) { 528 mwifiex_dbg(adapter, ERROR, 529 "Failed to get firmware %s\n", adapter->fw_name); 530 goto err_dnld_fw; 531 } 532 533 memset(&fw, 0, sizeof(struct mwifiex_fw_image)); 534 adapter->firmware = firmware; 535 fw.fw_buf = (u8 *) adapter->firmware->data; 536 fw.fw_len = adapter->firmware->size; 537 538 if (adapter->if_ops.dnld_fw) { 539 ret = adapter->if_ops.dnld_fw(adapter, &fw); 540 } else { 541 ret = mwifiex_dnld_fw(adapter, &fw); 542 } 543 544 if (ret == -1) 545 goto err_dnld_fw; 546 547 mwifiex_dbg(adapter, MSG, "WLAN FW is active\n"); 548 549 if (cal_data_cfg) { 550 if ((request_firmware(&adapter->cal_data, cal_data_cfg, 551 adapter->dev)) < 0) 552 mwifiex_dbg(adapter, ERROR, 553 "Cal data request_firmware() failed\n"); 554 } 555 556 /* enable host interrupt after fw dnld is successful */ 557 if (adapter->if_ops.enable_int) { 558 if (adapter->if_ops.enable_int(adapter)) 559 goto err_dnld_fw; 560 } 561 562 adapter->init_wait_q_woken = false; 563 ret = mwifiex_init_fw(adapter); 564 if (ret == -1) { 565 goto err_init_fw; 566 } else if (!ret) { 567 adapter->hw_status = MWIFIEX_HW_STATUS_READY; 568 goto done; 569 } 570 /* Wait for mwifiex_init to complete */ 571 if (!adapter->mfg_mode) { 572 wait_event_interruptible(adapter->init_wait_q, 573 adapter->init_wait_q_woken); 574 if (adapter->hw_status != MWIFIEX_HW_STATUS_READY) 575 goto err_init_fw; 576 } 577 578 priv = adapter->priv[MWIFIEX_BSS_ROLE_STA]; 579 580 if (!adapter->wiphy) { 581 if (mwifiex_register_cfg80211(adapter)) { 582 mwifiex_dbg(adapter, ERROR, 583 "cannot register with cfg80211\n"); 584 goto err_init_fw; 585 } 586 } 587 588 if (mwifiex_init_channel_scan_gap(adapter)) { 589 mwifiex_dbg(adapter, ERROR, 590 "could not init channel stats table\n"); 591 goto err_init_fw; 592 } 593 594 if (driver_mode) { 595 driver_mode &= MWIFIEX_DRIVER_MODE_BITMASK; 596 driver_mode |= MWIFIEX_DRIVER_MODE_STA; 597 } 598 599 rtnl_lock(); 600 /* Create station interface by default */ 601 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "mlan%d", NET_NAME_ENUM, 602 NL80211_IFTYPE_STATION, NULL, NULL); 603 if (IS_ERR(wdev)) { 604 mwifiex_dbg(adapter, ERROR, 605 "cannot create default STA interface\n"); 606 rtnl_unlock(); 607 goto err_add_intf; 608 } 609 610 if (driver_mode & MWIFIEX_DRIVER_MODE_UAP) { 611 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "uap%d", NET_NAME_ENUM, 612 NL80211_IFTYPE_AP, NULL, NULL); 613 if (IS_ERR(wdev)) { 614 mwifiex_dbg(adapter, ERROR, 615 "cannot create AP interface\n"); 616 rtnl_unlock(); 617 goto err_add_intf; 618 } 619 } 620 621 if (driver_mode & MWIFIEX_DRIVER_MODE_P2P) { 622 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "p2p%d", NET_NAME_ENUM, 623 NL80211_IFTYPE_P2P_CLIENT, NULL, 624 NULL); 625 if (IS_ERR(wdev)) { 626 mwifiex_dbg(adapter, ERROR, 627 "cannot create p2p client interface\n"); 628 rtnl_unlock(); 629 goto err_add_intf; 630 } 631 } 632 rtnl_unlock(); 633 634 mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1); 635 mwifiex_dbg(adapter, MSG, "driver_version = %s\n", fmt); 636 goto done; 637 638 err_add_intf: 639 wiphy_unregister(adapter->wiphy); 640 wiphy_free(adapter->wiphy); 641 err_init_fw: 642 if (adapter->if_ops.disable_int) 643 adapter->if_ops.disable_int(adapter); 644 err_dnld_fw: 645 mwifiex_dbg(adapter, ERROR, 646 "info: %s: unregister device\n", __func__); 647 if (adapter->if_ops.unregister_dev) 648 adapter->if_ops.unregister_dev(adapter); 649 650 if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) { 651 pr_debug("info: %s: shutdown mwifiex\n", __func__); 652 adapter->init_wait_q_woken = false; 653 654 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS) 655 wait_event_interruptible(adapter->init_wait_q, 656 adapter->init_wait_q_woken); 657 } 658 adapter->surprise_removed = true; 659 mwifiex_terminate_workqueue(adapter); 660 init_failed = true; 661 done: 662 if (adapter->cal_data) { 663 release_firmware(adapter->cal_data); 664 adapter->cal_data = NULL; 665 } 666 if (adapter->firmware) { 667 release_firmware(adapter->firmware); 668 adapter->firmware = NULL; 669 } 670 if (init_failed) 671 mwifiex_free_adapter(adapter); 672 up(sem); 673 return; 674 } 675 676 /* 677 * This function initializes the hardware and gets firmware. 678 */ 679 static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter, 680 bool req_fw_nowait) 681 { 682 int ret; 683 684 /* Override default firmware with manufacturing one if 685 * manufacturing mode is enabled 686 */ 687 if (mfg_mode) { 688 if (strlcpy(adapter->fw_name, MFG_FIRMWARE, 689 sizeof(adapter->fw_name)) >= 690 sizeof(adapter->fw_name)) { 691 pr_err("%s: fw_name too long!\n", __func__); 692 return -1; 693 } 694 } 695 696 if (req_fw_nowait) { 697 ret = request_firmware_nowait(THIS_MODULE, 1, adapter->fw_name, 698 adapter->dev, GFP_KERNEL, adapter, 699 mwifiex_fw_dpc); 700 if (ret < 0) 701 mwifiex_dbg(adapter, ERROR, 702 "request_firmware_nowait error %d\n", ret); 703 } else { 704 ret = request_firmware(&adapter->firmware, 705 adapter->fw_name, 706 adapter->dev); 707 if (ret < 0) 708 mwifiex_dbg(adapter, ERROR, 709 "request_firmware error %d\n", ret); 710 else 711 mwifiex_fw_dpc(adapter->firmware, (void *)adapter); 712 } 713 714 return ret; 715 } 716 717 /* 718 * CFG802.11 network device handler for open. 719 * 720 * Starts the data queue. 721 */ 722 static int 723 mwifiex_open(struct net_device *dev) 724 { 725 netif_carrier_off(dev); 726 727 return 0; 728 } 729 730 /* 731 * CFG802.11 network device handler for close. 732 */ 733 static int 734 mwifiex_close(struct net_device *dev) 735 { 736 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev); 737 738 if (priv->scan_request) { 739 struct cfg80211_scan_info info = { 740 .aborted = true, 741 }; 742 743 mwifiex_dbg(priv->adapter, INFO, 744 "aborting scan on ndo_stop\n"); 745 cfg80211_scan_done(priv->scan_request, &info); 746 priv->scan_request = NULL; 747 priv->scan_aborting = true; 748 } 749 750 if (priv->sched_scanning) { 751 mwifiex_dbg(priv->adapter, INFO, 752 "aborting bgscan on ndo_stop\n"); 753 mwifiex_stop_bg_scan(priv); 754 cfg80211_sched_scan_stopped(priv->wdev.wiphy); 755 } 756 757 return 0; 758 } 759 760 static bool 761 mwifiex_bypass_tx_queue(struct mwifiex_private *priv, 762 struct sk_buff *skb) 763 { 764 struct ethhdr *eth_hdr = (struct ethhdr *)skb->data; 765 766 if (ntohs(eth_hdr->h_proto) == ETH_P_PAE || 767 mwifiex_is_skb_mgmt_frame(skb) || 768 (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA && 769 ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) && 770 (ntohs(eth_hdr->h_proto) == ETH_P_TDLS))) { 771 mwifiex_dbg(priv->adapter, DATA, 772 "bypass txqueue; eth type %#x, mgmt %d\n", 773 ntohs(eth_hdr->h_proto), 774 mwifiex_is_skb_mgmt_frame(skb)); 775 return true; 776 } 777 778 return false; 779 } 780 /* 781 * Add buffer into wmm tx queue and queue work to transmit it. 782 */ 783 int mwifiex_queue_tx_pkt(struct mwifiex_private *priv, struct sk_buff *skb) 784 { 785 struct netdev_queue *txq; 786 int index = mwifiex_1d_to_wmm_queue[skb->priority]; 787 788 if (atomic_inc_return(&priv->wmm_tx_pending[index]) >= MAX_TX_PENDING) { 789 txq = netdev_get_tx_queue(priv->netdev, index); 790 if (!netif_tx_queue_stopped(txq)) { 791 netif_tx_stop_queue(txq); 792 mwifiex_dbg(priv->adapter, DATA, 793 "stop queue: %d\n", index); 794 } 795 } 796 797 if (mwifiex_bypass_tx_queue(priv, skb)) { 798 atomic_inc(&priv->adapter->tx_pending); 799 atomic_inc(&priv->adapter->bypass_tx_pending); 800 mwifiex_wmm_add_buf_bypass_txqueue(priv, skb); 801 } else { 802 atomic_inc(&priv->adapter->tx_pending); 803 mwifiex_wmm_add_buf_txqueue(priv, skb); 804 } 805 806 mwifiex_queue_main_work(priv->adapter); 807 808 return 0; 809 } 810 811 struct sk_buff * 812 mwifiex_clone_skb_for_tx_status(struct mwifiex_private *priv, 813 struct sk_buff *skb, u8 flag, u64 *cookie) 814 { 815 struct sk_buff *orig_skb = skb; 816 struct mwifiex_txinfo *tx_info, *orig_tx_info; 817 818 skb = skb_clone(skb, GFP_ATOMIC); 819 if (skb) { 820 unsigned long flags; 821 int id; 822 823 spin_lock_irqsave(&priv->ack_status_lock, flags); 824 id = idr_alloc(&priv->ack_status_frames, orig_skb, 825 1, 0x10, GFP_ATOMIC); 826 spin_unlock_irqrestore(&priv->ack_status_lock, flags); 827 828 if (id >= 0) { 829 tx_info = MWIFIEX_SKB_TXCB(skb); 830 tx_info->ack_frame_id = id; 831 tx_info->flags |= flag; 832 orig_tx_info = MWIFIEX_SKB_TXCB(orig_skb); 833 orig_tx_info->ack_frame_id = id; 834 orig_tx_info->flags |= flag; 835 836 if (flag == MWIFIEX_BUF_FLAG_ACTION_TX_STATUS && cookie) 837 orig_tx_info->cookie = *cookie; 838 839 } else if (skb_shared(skb)) { 840 kfree_skb(orig_skb); 841 } else { 842 kfree_skb(skb); 843 skb = orig_skb; 844 } 845 } else { 846 /* couldn't clone -- lose tx status ... */ 847 skb = orig_skb; 848 } 849 850 return skb; 851 } 852 853 /* 854 * CFG802.11 network device handler for data transmission. 855 */ 856 static int 857 mwifiex_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 858 { 859 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev); 860 struct sk_buff *new_skb; 861 struct mwifiex_txinfo *tx_info; 862 bool multicast; 863 864 mwifiex_dbg(priv->adapter, DATA, 865 "data: %lu BSS(%d-%d): Data <= kernel\n", 866 jiffies, priv->bss_type, priv->bss_num); 867 868 if (priv->adapter->surprise_removed) { 869 kfree_skb(skb); 870 priv->stats.tx_dropped++; 871 return 0; 872 } 873 if (!skb->len || (skb->len > ETH_FRAME_LEN)) { 874 mwifiex_dbg(priv->adapter, ERROR, 875 "Tx: bad skb len %d\n", skb->len); 876 kfree_skb(skb); 877 priv->stats.tx_dropped++; 878 return 0; 879 } 880 if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) { 881 mwifiex_dbg(priv->adapter, DATA, 882 "data: Tx: insufficient skb headroom %d\n", 883 skb_headroom(skb)); 884 /* Insufficient skb headroom - allocate a new skb */ 885 new_skb = 886 skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN); 887 if (unlikely(!new_skb)) { 888 mwifiex_dbg(priv->adapter, ERROR, 889 "Tx: cannot alloca new_skb\n"); 890 kfree_skb(skb); 891 priv->stats.tx_dropped++; 892 return 0; 893 } 894 kfree_skb(skb); 895 skb = new_skb; 896 mwifiex_dbg(priv->adapter, INFO, 897 "info: new skb headroomd %d\n", 898 skb_headroom(skb)); 899 } 900 901 tx_info = MWIFIEX_SKB_TXCB(skb); 902 memset(tx_info, 0, sizeof(*tx_info)); 903 tx_info->bss_num = priv->bss_num; 904 tx_info->bss_type = priv->bss_type; 905 tx_info->pkt_len = skb->len; 906 907 multicast = is_multicast_ether_addr(skb->data); 908 909 if (unlikely(!multicast && skb->sk && 910 skb_shinfo(skb)->tx_flags & SKBTX_WIFI_STATUS && 911 priv->adapter->fw_api_ver == MWIFIEX_FW_V15)) 912 skb = mwifiex_clone_skb_for_tx_status(priv, 913 skb, 914 MWIFIEX_BUF_FLAG_EAPOL_TX_STATUS, NULL); 915 916 /* Record the current time the packet was queued; used to 917 * determine the amount of time the packet was queued in 918 * the driver before it was sent to the firmware. 919 * The delay is then sent along with the packet to the 920 * firmware for aggregate delay calculation for stats and 921 * MSDU lifetime expiry. 922 */ 923 __net_timestamp(skb); 924 925 if (ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) && 926 priv->bss_type == MWIFIEX_BSS_TYPE_STA && 927 !ether_addr_equal_unaligned(priv->cfg_bssid, skb->data)) { 928 if (priv->adapter->auto_tdls && priv->check_tdls_tx) 929 mwifiex_tdls_check_tx(priv, skb); 930 } 931 932 mwifiex_queue_tx_pkt(priv, skb); 933 934 return 0; 935 } 936 937 /* 938 * CFG802.11 network device handler for setting MAC address. 939 */ 940 static int 941 mwifiex_set_mac_address(struct net_device *dev, void *addr) 942 { 943 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev); 944 struct sockaddr *hw_addr = addr; 945 int ret; 946 947 memcpy(priv->curr_addr, hw_addr->sa_data, ETH_ALEN); 948 949 /* Send request to firmware */ 950 ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_MAC_ADDRESS, 951 HostCmd_ACT_GEN_SET, 0, NULL, true); 952 953 if (!ret) 954 memcpy(priv->netdev->dev_addr, priv->curr_addr, ETH_ALEN); 955 else 956 mwifiex_dbg(priv->adapter, ERROR, 957 "set mac address failed: ret=%d\n", ret); 958 959 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN); 960 961 return ret; 962 } 963 964 /* 965 * CFG802.11 network device handler for setting multicast list. 966 */ 967 static void mwifiex_set_multicast_list(struct net_device *dev) 968 { 969 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev); 970 struct mwifiex_multicast_list mcast_list; 971 972 if (dev->flags & IFF_PROMISC) { 973 mcast_list.mode = MWIFIEX_PROMISC_MODE; 974 } else if (dev->flags & IFF_ALLMULTI || 975 netdev_mc_count(dev) > MWIFIEX_MAX_MULTICAST_LIST_SIZE) { 976 mcast_list.mode = MWIFIEX_ALL_MULTI_MODE; 977 } else { 978 mcast_list.mode = MWIFIEX_MULTICAST_MODE; 979 mcast_list.num_multicast_addr = 980 mwifiex_copy_mcast_addr(&mcast_list, dev); 981 } 982 mwifiex_request_set_multicast_list(priv, &mcast_list); 983 } 984 985 /* 986 * CFG802.11 network device handler for transmission timeout. 987 */ 988 static void 989 mwifiex_tx_timeout(struct net_device *dev) 990 { 991 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev); 992 993 priv->num_tx_timeout++; 994 priv->tx_timeout_cnt++; 995 mwifiex_dbg(priv->adapter, ERROR, 996 "%lu : Tx timeout(#%d), bss_type-num = %d-%d\n", 997 jiffies, priv->tx_timeout_cnt, priv->bss_type, 998 priv->bss_num); 999 mwifiex_set_trans_start(dev); 1000 1001 if (priv->tx_timeout_cnt > TX_TIMEOUT_THRESHOLD && 1002 priv->adapter->if_ops.card_reset) { 1003 mwifiex_dbg(priv->adapter, ERROR, 1004 "tx_timeout_cnt exceeds threshold.\t" 1005 "Triggering card reset!\n"); 1006 priv->adapter->if_ops.card_reset(priv->adapter); 1007 } 1008 } 1009 1010 void mwifiex_multi_chan_resync(struct mwifiex_adapter *adapter) 1011 { 1012 struct usb_card_rec *card = adapter->card; 1013 struct mwifiex_private *priv; 1014 u16 tx_buf_size; 1015 int i, ret; 1016 1017 card->mc_resync_flag = true; 1018 for (i = 0; i < MWIFIEX_TX_DATA_PORT; i++) { 1019 if (atomic_read(&card->port[i].tx_data_urb_pending)) { 1020 mwifiex_dbg(adapter, WARN, "pending data urb in sys\n"); 1021 return; 1022 } 1023 } 1024 1025 card->mc_resync_flag = false; 1026 tx_buf_size = 0xffff; 1027 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY); 1028 ret = mwifiex_send_cmd(priv, HostCmd_CMD_RECONFIGURE_TX_BUFF, 1029 HostCmd_ACT_GEN_SET, 0, &tx_buf_size, false); 1030 if (ret) 1031 mwifiex_dbg(adapter, ERROR, 1032 "send reconfig tx buf size cmd err\n"); 1033 } 1034 EXPORT_SYMBOL_GPL(mwifiex_multi_chan_resync); 1035 1036 void mwifiex_drv_info_dump(struct mwifiex_adapter *adapter) 1037 { 1038 void *p; 1039 char drv_version[64]; 1040 struct usb_card_rec *cardp; 1041 struct sdio_mmc_card *sdio_card; 1042 struct mwifiex_private *priv; 1043 int i, idx; 1044 struct netdev_queue *txq; 1045 struct mwifiex_debug_info *debug_info; 1046 1047 if (adapter->drv_info_dump) { 1048 vfree(adapter->drv_info_dump); 1049 adapter->drv_info_dump = NULL; 1050 adapter->drv_info_size = 0; 1051 } 1052 1053 mwifiex_dbg(adapter, MSG, "===mwifiex driverinfo dump start===\n"); 1054 1055 adapter->drv_info_dump = vzalloc(MWIFIEX_DRV_INFO_SIZE_MAX); 1056 1057 if (!adapter->drv_info_dump) 1058 return; 1059 1060 p = (char *)(adapter->drv_info_dump); 1061 p += sprintf(p, "driver_name = " "\"mwifiex\"\n"); 1062 1063 mwifiex_drv_get_driver_version(adapter, drv_version, 1064 sizeof(drv_version) - 1); 1065 p += sprintf(p, "driver_version = %s\n", drv_version); 1066 1067 if (adapter->iface_type == MWIFIEX_USB) { 1068 cardp = (struct usb_card_rec *)adapter->card; 1069 p += sprintf(p, "tx_cmd_urb_pending = %d\n", 1070 atomic_read(&cardp->tx_cmd_urb_pending)); 1071 p += sprintf(p, "tx_data_urb_pending_port_0 = %d\n", 1072 atomic_read(&cardp->port[0].tx_data_urb_pending)); 1073 p += sprintf(p, "tx_data_urb_pending_port_1 = %d\n", 1074 atomic_read(&cardp->port[1].tx_data_urb_pending)); 1075 p += sprintf(p, "rx_cmd_urb_pending = %d\n", 1076 atomic_read(&cardp->rx_cmd_urb_pending)); 1077 p += sprintf(p, "rx_data_urb_pending = %d\n", 1078 atomic_read(&cardp->rx_data_urb_pending)); 1079 } 1080 1081 p += sprintf(p, "tx_pending = %d\n", 1082 atomic_read(&adapter->tx_pending)); 1083 p += sprintf(p, "rx_pending = %d\n", 1084 atomic_read(&adapter->rx_pending)); 1085 1086 if (adapter->iface_type == MWIFIEX_SDIO) { 1087 sdio_card = (struct sdio_mmc_card *)adapter->card; 1088 p += sprintf(p, "\nmp_rd_bitmap=0x%x curr_rd_port=0x%x\n", 1089 sdio_card->mp_rd_bitmap, sdio_card->curr_rd_port); 1090 p += sprintf(p, "mp_wr_bitmap=0x%x curr_wr_port=0x%x\n", 1091 sdio_card->mp_wr_bitmap, sdio_card->curr_wr_port); 1092 } 1093 1094 for (i = 0; i < adapter->priv_num; i++) { 1095 if (!adapter->priv[i] || !adapter->priv[i]->netdev) 1096 continue; 1097 priv = adapter->priv[i]; 1098 p += sprintf(p, "\n[interface : \"%s\"]\n", 1099 priv->netdev->name); 1100 p += sprintf(p, "wmm_tx_pending[0] = %d\n", 1101 atomic_read(&priv->wmm_tx_pending[0])); 1102 p += sprintf(p, "wmm_tx_pending[1] = %d\n", 1103 atomic_read(&priv->wmm_tx_pending[1])); 1104 p += sprintf(p, "wmm_tx_pending[2] = %d\n", 1105 atomic_read(&priv->wmm_tx_pending[2])); 1106 p += sprintf(p, "wmm_tx_pending[3] = %d\n", 1107 atomic_read(&priv->wmm_tx_pending[3])); 1108 p += sprintf(p, "media_state=\"%s\"\n", !priv->media_connected ? 1109 "Disconnected" : "Connected"); 1110 p += sprintf(p, "carrier %s\n", (netif_carrier_ok(priv->netdev) 1111 ? "on" : "off")); 1112 for (idx = 0; idx < priv->netdev->num_tx_queues; idx++) { 1113 txq = netdev_get_tx_queue(priv->netdev, idx); 1114 p += sprintf(p, "tx queue %d:%s ", idx, 1115 netif_tx_queue_stopped(txq) ? 1116 "stopped" : "started"); 1117 } 1118 p += sprintf(p, "\n%s: num_tx_timeout = %d\n", 1119 priv->netdev->name, priv->num_tx_timeout); 1120 } 1121 1122 if (adapter->iface_type == MWIFIEX_SDIO || 1123 adapter->iface_type == MWIFIEX_PCIE) { 1124 p += sprintf(p, "\n=== %s register dump===\n", 1125 adapter->iface_type == MWIFIEX_SDIO ? 1126 "SDIO" : "PCIE"); 1127 if (adapter->if_ops.reg_dump) 1128 p += adapter->if_ops.reg_dump(adapter, p); 1129 } 1130 p += sprintf(p, "\n=== more debug information\n"); 1131 debug_info = kzalloc(sizeof(*debug_info), GFP_KERNEL); 1132 if (debug_info) { 1133 for (i = 0; i < adapter->priv_num; i++) { 1134 if (!adapter->priv[i] || !adapter->priv[i]->netdev) 1135 continue; 1136 priv = adapter->priv[i]; 1137 mwifiex_get_debug_info(priv, debug_info); 1138 p += mwifiex_debug_info_to_buffer(priv, p, debug_info); 1139 break; 1140 } 1141 kfree(debug_info); 1142 } 1143 1144 adapter->drv_info_size = p - adapter->drv_info_dump; 1145 mwifiex_dbg(adapter, MSG, "===mwifiex driverinfo dump end===\n"); 1146 } 1147 EXPORT_SYMBOL_GPL(mwifiex_drv_info_dump); 1148 1149 void mwifiex_upload_device_dump(struct mwifiex_adapter *adapter) 1150 { 1151 u8 idx, *dump_data, *fw_dump_ptr; 1152 u32 dump_len; 1153 1154 dump_len = (strlen("========Start dump driverinfo========\n") + 1155 adapter->drv_info_size + 1156 strlen("\n========End dump========\n")); 1157 1158 for (idx = 0; idx < adapter->num_mem_types; idx++) { 1159 struct memory_type_mapping *entry = 1160 &adapter->mem_type_mapping_tbl[idx]; 1161 1162 if (entry->mem_ptr) { 1163 dump_len += (strlen("========Start dump ") + 1164 strlen(entry->mem_name) + 1165 strlen("========\n") + 1166 (entry->mem_size + 1) + 1167 strlen("\n========End dump========\n")); 1168 } 1169 } 1170 1171 dump_data = vzalloc(dump_len + 1); 1172 if (!dump_data) 1173 goto done; 1174 1175 fw_dump_ptr = dump_data; 1176 1177 /* Dump all the memory data into single file, a userspace script will 1178 * be used to split all the memory data to multiple files 1179 */ 1180 mwifiex_dbg(adapter, MSG, 1181 "== mwifiex dump information to /sys/class/devcoredump start"); 1182 1183 strcpy(fw_dump_ptr, "========Start dump driverinfo========\n"); 1184 fw_dump_ptr += strlen("========Start dump driverinfo========\n"); 1185 memcpy(fw_dump_ptr, adapter->drv_info_dump, adapter->drv_info_size); 1186 fw_dump_ptr += adapter->drv_info_size; 1187 strcpy(fw_dump_ptr, "\n========End dump========\n"); 1188 fw_dump_ptr += strlen("\n========End dump========\n"); 1189 1190 for (idx = 0; idx < adapter->num_mem_types; idx++) { 1191 struct memory_type_mapping *entry = 1192 &adapter->mem_type_mapping_tbl[idx]; 1193 1194 if (entry->mem_ptr) { 1195 strcpy(fw_dump_ptr, "========Start dump "); 1196 fw_dump_ptr += strlen("========Start dump "); 1197 1198 strcpy(fw_dump_ptr, entry->mem_name); 1199 fw_dump_ptr += strlen(entry->mem_name); 1200 1201 strcpy(fw_dump_ptr, "========\n"); 1202 fw_dump_ptr += strlen("========\n"); 1203 1204 memcpy(fw_dump_ptr, entry->mem_ptr, entry->mem_size); 1205 fw_dump_ptr += entry->mem_size; 1206 1207 strcpy(fw_dump_ptr, "\n========End dump========\n"); 1208 fw_dump_ptr += strlen("\n========End dump========\n"); 1209 } 1210 } 1211 1212 /* device dump data will be free in device coredump release function 1213 * after 5 min 1214 */ 1215 dev_coredumpv(adapter->dev, dump_data, dump_len, GFP_KERNEL); 1216 mwifiex_dbg(adapter, MSG, 1217 "== mwifiex dump information to /sys/class/devcoredump end"); 1218 1219 done: 1220 for (idx = 0; idx < adapter->num_mem_types; idx++) { 1221 struct memory_type_mapping *entry = 1222 &adapter->mem_type_mapping_tbl[idx]; 1223 1224 if (entry->mem_ptr) { 1225 vfree(entry->mem_ptr); 1226 entry->mem_ptr = NULL; 1227 } 1228 entry->mem_size = 0; 1229 } 1230 1231 if (adapter->drv_info_dump) { 1232 vfree(adapter->drv_info_dump); 1233 adapter->drv_info_dump = NULL; 1234 adapter->drv_info_size = 0; 1235 } 1236 } 1237 EXPORT_SYMBOL_GPL(mwifiex_upload_device_dump); 1238 1239 /* 1240 * CFG802.11 network device handler for statistics retrieval. 1241 */ 1242 static struct net_device_stats *mwifiex_get_stats(struct net_device *dev) 1243 { 1244 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev); 1245 1246 return &priv->stats; 1247 } 1248 1249 static u16 1250 mwifiex_netdev_select_wmm_queue(struct net_device *dev, struct sk_buff *skb, 1251 void *accel_priv, select_queue_fallback_t fallback) 1252 { 1253 skb->priority = cfg80211_classify8021d(skb, NULL); 1254 return mwifiex_1d_to_wmm_queue[skb->priority]; 1255 } 1256 1257 /* Network device handlers */ 1258 static const struct net_device_ops mwifiex_netdev_ops = { 1259 .ndo_open = mwifiex_open, 1260 .ndo_stop = mwifiex_close, 1261 .ndo_start_xmit = mwifiex_hard_start_xmit, 1262 .ndo_set_mac_address = mwifiex_set_mac_address, 1263 .ndo_validate_addr = eth_validate_addr, 1264 .ndo_tx_timeout = mwifiex_tx_timeout, 1265 .ndo_get_stats = mwifiex_get_stats, 1266 .ndo_set_rx_mode = mwifiex_set_multicast_list, 1267 .ndo_select_queue = mwifiex_netdev_select_wmm_queue, 1268 }; 1269 1270 /* 1271 * This function initializes the private structure parameters. 1272 * 1273 * The following wait queues are initialized - 1274 * - IOCTL wait queue 1275 * - Command wait queue 1276 * - Statistics wait queue 1277 * 1278 * ...and the following default parameters are set - 1279 * - Current key index : Set to 0 1280 * - Rate index : Set to auto 1281 * - Media connected : Set to disconnected 1282 * - Adhoc link sensed : Set to false 1283 * - Nick name : Set to null 1284 * - Number of Tx timeout : Set to 0 1285 * - Device address : Set to current address 1286 * - Rx histogram statistc : Set to 0 1287 * 1288 * In addition, the CFG80211 work queue is also created. 1289 */ 1290 void mwifiex_init_priv_params(struct mwifiex_private *priv, 1291 struct net_device *dev) 1292 { 1293 dev->netdev_ops = &mwifiex_netdev_ops; 1294 dev->destructor = free_netdev; 1295 /* Initialize private structure */ 1296 priv->current_key_index = 0; 1297 priv->media_connected = false; 1298 memset(priv->mgmt_ie, 0, 1299 sizeof(struct mwifiex_ie) * MAX_MGMT_IE_INDEX); 1300 priv->beacon_idx = MWIFIEX_AUTO_IDX_MASK; 1301 priv->proberesp_idx = MWIFIEX_AUTO_IDX_MASK; 1302 priv->assocresp_idx = MWIFIEX_AUTO_IDX_MASK; 1303 priv->gen_idx = MWIFIEX_AUTO_IDX_MASK; 1304 priv->num_tx_timeout = 0; 1305 ether_addr_copy(priv->curr_addr, priv->adapter->perm_addr); 1306 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN); 1307 1308 if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA || 1309 GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) { 1310 priv->hist_data = kmalloc(sizeof(*priv->hist_data), GFP_KERNEL); 1311 if (priv->hist_data) 1312 mwifiex_hist_data_reset(priv); 1313 } 1314 } 1315 1316 /* 1317 * This function check if command is pending. 1318 */ 1319 int is_command_pending(struct mwifiex_adapter *adapter) 1320 { 1321 unsigned long flags; 1322 int is_cmd_pend_q_empty; 1323 1324 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags); 1325 is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q); 1326 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags); 1327 1328 return !is_cmd_pend_q_empty; 1329 } 1330 1331 /* 1332 * This is the RX work queue function. 1333 * 1334 * It handles the RX operations. 1335 */ 1336 static void mwifiex_rx_work_queue(struct work_struct *work) 1337 { 1338 struct mwifiex_adapter *adapter = 1339 container_of(work, struct mwifiex_adapter, rx_work); 1340 1341 if (adapter->surprise_removed) 1342 return; 1343 mwifiex_process_rx(adapter); 1344 } 1345 1346 /* 1347 * This is the main work queue function. 1348 * 1349 * It handles the main process, which in turn handles the complete 1350 * driver operations. 1351 */ 1352 static void mwifiex_main_work_queue(struct work_struct *work) 1353 { 1354 struct mwifiex_adapter *adapter = 1355 container_of(work, struct mwifiex_adapter, main_work); 1356 1357 if (adapter->surprise_removed) 1358 return; 1359 mwifiex_main_process(adapter); 1360 } 1361 1362 /* 1363 * This function gets called during PCIe function level reset. Required 1364 * code is extracted from mwifiex_remove_card() 1365 */ 1366 static int 1367 mwifiex_shutdown_sw(struct mwifiex_adapter *adapter, struct semaphore *sem) 1368 { 1369 struct mwifiex_private *priv; 1370 int i; 1371 1372 if (!adapter) 1373 goto exit_return; 1374 1375 if (down_interruptible(sem)) 1376 goto exit_sem_err; 1377 1378 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY); 1379 mwifiex_deauthenticate(priv, NULL); 1380 1381 /* We can no longer handle interrupts once we start doing the teardown 1382 * below. 1383 */ 1384 if (adapter->if_ops.disable_int) 1385 adapter->if_ops.disable_int(adapter); 1386 1387 adapter->surprise_removed = true; 1388 mwifiex_terminate_workqueue(adapter); 1389 1390 /* Stop data */ 1391 for (i = 0; i < adapter->priv_num; i++) { 1392 priv = adapter->priv[i]; 1393 if (priv && priv->netdev) { 1394 mwifiex_stop_net_dev_queue(priv->netdev, adapter); 1395 if (netif_carrier_ok(priv->netdev)) 1396 netif_carrier_off(priv->netdev); 1397 netif_device_detach(priv->netdev); 1398 } 1399 } 1400 1401 mwifiex_dbg(adapter, CMD, "cmd: calling mwifiex_shutdown_drv...\n"); 1402 adapter->init_wait_q_woken = false; 1403 1404 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS) 1405 wait_event_interruptible(adapter->init_wait_q, 1406 adapter->init_wait_q_woken); 1407 if (adapter->if_ops.down_dev) 1408 adapter->if_ops.down_dev(adapter); 1409 1410 mwifiex_dbg(adapter, CMD, "cmd: mwifiex_shutdown_drv done\n"); 1411 if (atomic_read(&adapter->rx_pending) || 1412 atomic_read(&adapter->tx_pending) || 1413 atomic_read(&adapter->cmd_pending)) { 1414 mwifiex_dbg(adapter, ERROR, 1415 "rx_pending=%d, tx_pending=%d,\t" 1416 "cmd_pending=%d\n", 1417 atomic_read(&adapter->rx_pending), 1418 atomic_read(&adapter->tx_pending), 1419 atomic_read(&adapter->cmd_pending)); 1420 } 1421 1422 for (i = 0; i < adapter->priv_num; i++) { 1423 priv = adapter->priv[i]; 1424 if (!priv) 1425 continue; 1426 rtnl_lock(); 1427 if (priv->netdev && 1428 priv->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED) 1429 mwifiex_del_virtual_intf(adapter->wiphy, &priv->wdev); 1430 rtnl_unlock(); 1431 } 1432 1433 up(sem); 1434 exit_sem_err: 1435 mwifiex_dbg(adapter, INFO, "%s, successful\n", __func__); 1436 exit_return: 1437 return 0; 1438 } 1439 1440 /* This function gets called during PCIe function level reset. Required 1441 * code is extracted from mwifiex_add_card() 1442 */ 1443 static int 1444 mwifiex_reinit_sw(struct mwifiex_adapter *adapter, struct semaphore *sem, 1445 struct mwifiex_if_ops *if_ops, u8 iface_type) 1446 { 1447 char fw_name[32]; 1448 struct pcie_service_card *card = adapter->card; 1449 1450 if (down_interruptible(sem)) 1451 goto exit_sem_err; 1452 1453 mwifiex_init_lock_list(adapter); 1454 if (adapter->if_ops.up_dev) 1455 adapter->if_ops.up_dev(adapter); 1456 1457 adapter->iface_type = iface_type; 1458 adapter->card_sem = sem; 1459 1460 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING; 1461 adapter->surprise_removed = false; 1462 init_waitqueue_head(&adapter->init_wait_q); 1463 adapter->is_suspended = false; 1464 adapter->hs_activated = false; 1465 init_waitqueue_head(&adapter->hs_activate_wait_q); 1466 init_waitqueue_head(&adapter->cmd_wait_q.wait); 1467 adapter->cmd_wait_q.status = 0; 1468 adapter->scan_wait_q_woken = false; 1469 1470 if ((num_possible_cpus() > 1) || adapter->iface_type == MWIFIEX_USB) 1471 adapter->rx_work_enabled = true; 1472 1473 adapter->workqueue = 1474 alloc_workqueue("MWIFIEX_WORK_QUEUE", 1475 WQ_HIGHPRI | WQ_MEM_RECLAIM | WQ_UNBOUND, 1); 1476 if (!adapter->workqueue) 1477 goto err_kmalloc; 1478 1479 INIT_WORK(&adapter->main_work, mwifiex_main_work_queue); 1480 1481 if (adapter->rx_work_enabled) { 1482 adapter->rx_workqueue = alloc_workqueue("MWIFIEX_RX_WORK_QUEUE", 1483 WQ_HIGHPRI | 1484 WQ_MEM_RECLAIM | 1485 WQ_UNBOUND, 1); 1486 if (!adapter->rx_workqueue) 1487 goto err_kmalloc; 1488 INIT_WORK(&adapter->rx_work, mwifiex_rx_work_queue); 1489 } 1490 1491 /* Register the device. Fill up the private data structure with 1492 * relevant information from the card. Some code extracted from 1493 * mwifiex_register_dev() 1494 */ 1495 mwifiex_dbg(adapter, INFO, "%s, mwifiex_init_hw_fw()...\n", __func__); 1496 strcpy(fw_name, adapter->fw_name); 1497 strcpy(adapter->fw_name, PCIE8997_DEFAULT_WIFIFW_NAME); 1498 1499 adapter->tx_buf_size = card->pcie.tx_buf_size; 1500 adapter->ext_scan = card->pcie.can_ext_scan; 1501 if (mwifiex_init_hw_fw(adapter, false)) { 1502 strcpy(adapter->fw_name, fw_name); 1503 mwifiex_dbg(adapter, ERROR, 1504 "%s: firmware init failed\n", __func__); 1505 goto err_init_fw; 1506 } 1507 strcpy(adapter->fw_name, fw_name); 1508 mwifiex_dbg(adapter, INFO, "%s, successful\n", __func__); 1509 up(sem); 1510 return 0; 1511 1512 err_init_fw: 1513 mwifiex_dbg(adapter, ERROR, "info: %s: unregister device\n", __func__); 1514 if (adapter->if_ops.unregister_dev) 1515 adapter->if_ops.unregister_dev(adapter); 1516 if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) { 1517 mwifiex_dbg(adapter, ERROR, 1518 "info: %s: shutdown mwifiex\n", __func__); 1519 adapter->init_wait_q_woken = false; 1520 1521 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS) 1522 wait_event_interruptible(adapter->init_wait_q, 1523 adapter->init_wait_q_woken); 1524 } 1525 1526 err_kmalloc: 1527 mwifiex_terminate_workqueue(adapter); 1528 adapter->surprise_removed = true; 1529 up(sem); 1530 exit_sem_err: 1531 mwifiex_dbg(adapter, INFO, "%s, error\n", __func__); 1532 1533 return -1; 1534 } 1535 1536 /* This function processes pre and post PCIe function level resets. 1537 * It performs software cleanup without touching PCIe specific code. 1538 * Also, during initialization PCIe stuff is skipped. 1539 */ 1540 void mwifiex_do_flr(struct mwifiex_adapter *adapter, bool prepare) 1541 { 1542 struct mwifiex_if_ops if_ops; 1543 1544 if (!prepare) { 1545 mwifiex_reinit_sw(adapter, adapter->card_sem, &if_ops, 1546 adapter->iface_type); 1547 } else { 1548 memcpy(&if_ops, &adapter->if_ops, 1549 sizeof(struct mwifiex_if_ops)); 1550 mwifiex_shutdown_sw(adapter, adapter->card_sem); 1551 } 1552 } 1553 EXPORT_SYMBOL_GPL(mwifiex_do_flr); 1554 1555 /* 1556 * This function adds the card. 1557 * 1558 * This function follows the following major steps to set up the device - 1559 * - Initialize software. This includes probing the card, registering 1560 * the interface operations table, and allocating/initializing the 1561 * adapter structure 1562 * - Set up the netlink socket 1563 * - Create and start the main work queue 1564 * - Register the device 1565 * - Initialize firmware and hardware 1566 * - Add logical interfaces 1567 */ 1568 int 1569 mwifiex_add_card(void *card, struct semaphore *sem, 1570 struct mwifiex_if_ops *if_ops, u8 iface_type) 1571 { 1572 struct mwifiex_adapter *adapter; 1573 1574 if (down_interruptible(sem)) 1575 goto exit_sem_err; 1576 1577 if (mwifiex_register(card, if_ops, (void **)&adapter)) { 1578 pr_err("%s: software init failed\n", __func__); 1579 goto err_init_sw; 1580 } 1581 1582 adapter->iface_type = iface_type; 1583 adapter->card_sem = sem; 1584 1585 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING; 1586 adapter->surprise_removed = false; 1587 init_waitqueue_head(&adapter->init_wait_q); 1588 adapter->is_suspended = false; 1589 adapter->hs_activated = false; 1590 init_waitqueue_head(&adapter->hs_activate_wait_q); 1591 init_waitqueue_head(&adapter->cmd_wait_q.wait); 1592 adapter->cmd_wait_q.status = 0; 1593 adapter->scan_wait_q_woken = false; 1594 1595 if ((num_possible_cpus() > 1) || adapter->iface_type == MWIFIEX_USB) { 1596 adapter->rx_work_enabled = true; 1597 pr_notice("rx work enabled, cpus %d\n", num_possible_cpus()); 1598 } 1599 1600 adapter->workqueue = 1601 alloc_workqueue("MWIFIEX_WORK_QUEUE", 1602 WQ_HIGHPRI | WQ_MEM_RECLAIM | WQ_UNBOUND, 1); 1603 if (!adapter->workqueue) 1604 goto err_kmalloc; 1605 1606 INIT_WORK(&adapter->main_work, mwifiex_main_work_queue); 1607 1608 if (adapter->rx_work_enabled) { 1609 adapter->rx_workqueue = alloc_workqueue("MWIFIEX_RX_WORK_QUEUE", 1610 WQ_HIGHPRI | 1611 WQ_MEM_RECLAIM | 1612 WQ_UNBOUND, 1); 1613 if (!adapter->rx_workqueue) 1614 goto err_kmalloc; 1615 1616 INIT_WORK(&adapter->rx_work, mwifiex_rx_work_queue); 1617 } 1618 1619 /* Register the device. Fill up the private data structure with relevant 1620 information from the card. */ 1621 if (adapter->if_ops.register_dev(adapter)) { 1622 pr_err("%s: failed to register mwifiex device\n", __func__); 1623 goto err_registerdev; 1624 } 1625 1626 if (mwifiex_init_hw_fw(adapter, true)) { 1627 pr_err("%s: firmware init failed\n", __func__); 1628 goto err_init_fw; 1629 } 1630 1631 return 0; 1632 1633 err_init_fw: 1634 pr_debug("info: %s: unregister device\n", __func__); 1635 if (adapter->if_ops.unregister_dev) 1636 adapter->if_ops.unregister_dev(adapter); 1637 if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) { 1638 pr_debug("info: %s: shutdown mwifiex\n", __func__); 1639 adapter->init_wait_q_woken = false; 1640 1641 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS) 1642 wait_event_interruptible(adapter->init_wait_q, 1643 adapter->init_wait_q_woken); 1644 } 1645 err_registerdev: 1646 adapter->surprise_removed = true; 1647 mwifiex_terminate_workqueue(adapter); 1648 err_kmalloc: 1649 mwifiex_free_adapter(adapter); 1650 1651 err_init_sw: 1652 up(sem); 1653 1654 exit_sem_err: 1655 return -1; 1656 } 1657 EXPORT_SYMBOL_GPL(mwifiex_add_card); 1658 1659 /* 1660 * This function removes the card. 1661 * 1662 * This function follows the following major steps to remove the device - 1663 * - Stop data traffic 1664 * - Shutdown firmware 1665 * - Remove the logical interfaces 1666 * - Terminate the work queue 1667 * - Unregister the device 1668 * - Free the adapter structure 1669 */ 1670 int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem) 1671 { 1672 struct mwifiex_private *priv = NULL; 1673 int i; 1674 1675 if (down_trylock(sem)) 1676 goto exit_sem_err; 1677 1678 if (!adapter) 1679 goto exit_remove; 1680 1681 /* We can no longer handle interrupts once we start doing the teardown 1682 * below. */ 1683 if (adapter->if_ops.disable_int) 1684 adapter->if_ops.disable_int(adapter); 1685 1686 adapter->surprise_removed = true; 1687 1688 mwifiex_terminate_workqueue(adapter); 1689 1690 /* Stop data */ 1691 for (i = 0; i < adapter->priv_num; i++) { 1692 priv = adapter->priv[i]; 1693 if (priv && priv->netdev) { 1694 mwifiex_stop_net_dev_queue(priv->netdev, adapter); 1695 if (netif_carrier_ok(priv->netdev)) 1696 netif_carrier_off(priv->netdev); 1697 } 1698 } 1699 1700 mwifiex_dbg(adapter, CMD, 1701 "cmd: calling mwifiex_shutdown_drv...\n"); 1702 adapter->init_wait_q_woken = false; 1703 1704 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS) 1705 wait_event_interruptible(adapter->init_wait_q, 1706 adapter->init_wait_q_woken); 1707 mwifiex_dbg(adapter, CMD, 1708 "cmd: mwifiex_shutdown_drv done\n"); 1709 if (atomic_read(&adapter->rx_pending) || 1710 atomic_read(&adapter->tx_pending) || 1711 atomic_read(&adapter->cmd_pending)) { 1712 mwifiex_dbg(adapter, ERROR, 1713 "rx_pending=%d, tx_pending=%d,\t" 1714 "cmd_pending=%d\n", 1715 atomic_read(&adapter->rx_pending), 1716 atomic_read(&adapter->tx_pending), 1717 atomic_read(&adapter->cmd_pending)); 1718 } 1719 1720 for (i = 0; i < adapter->priv_num; i++) { 1721 priv = adapter->priv[i]; 1722 1723 if (!priv) 1724 continue; 1725 1726 rtnl_lock(); 1727 if (priv->netdev && 1728 priv->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED) 1729 mwifiex_del_virtual_intf(adapter->wiphy, &priv->wdev); 1730 rtnl_unlock(); 1731 } 1732 1733 wiphy_unregister(adapter->wiphy); 1734 wiphy_free(adapter->wiphy); 1735 1736 /* Unregister device */ 1737 mwifiex_dbg(adapter, INFO, 1738 "info: unregister device\n"); 1739 if (adapter->if_ops.unregister_dev) 1740 adapter->if_ops.unregister_dev(adapter); 1741 /* Free adapter structure */ 1742 mwifiex_dbg(adapter, INFO, 1743 "info: free adapter\n"); 1744 mwifiex_free_adapter(adapter); 1745 1746 exit_remove: 1747 up(sem); 1748 exit_sem_err: 1749 return 0; 1750 } 1751 EXPORT_SYMBOL_GPL(mwifiex_remove_card); 1752 1753 void _mwifiex_dbg(const struct mwifiex_adapter *adapter, int mask, 1754 const char *fmt, ...) 1755 { 1756 struct va_format vaf; 1757 va_list args; 1758 1759 if (!adapter->dev || !(adapter->debug_mask & mask)) 1760 return; 1761 1762 va_start(args, fmt); 1763 1764 vaf.fmt = fmt; 1765 vaf.va = &args; 1766 1767 dev_info(adapter->dev, "%pV", &vaf); 1768 1769 va_end(args); 1770 } 1771 EXPORT_SYMBOL_GPL(_mwifiex_dbg); 1772 1773 /* 1774 * This function initializes the module. 1775 * 1776 * The debug FS is also initialized if configured. 1777 */ 1778 static int 1779 mwifiex_init_module(void) 1780 { 1781 #ifdef CONFIG_DEBUG_FS 1782 mwifiex_debugfs_init(); 1783 #endif 1784 return 0; 1785 } 1786 1787 /* 1788 * This function cleans up the module. 1789 * 1790 * The debug FS is removed if available. 1791 */ 1792 static void 1793 mwifiex_cleanup_module(void) 1794 { 1795 #ifdef CONFIG_DEBUG_FS 1796 mwifiex_debugfs_remove(); 1797 #endif 1798 } 1799 1800 module_init(mwifiex_init_module); 1801 module_exit(mwifiex_cleanup_module); 1802 1803 MODULE_AUTHOR("Marvell International Ltd."); 1804 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION); 1805 MODULE_VERSION(VERSION); 1806 MODULE_LICENSE("GPL v2"); 1807