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