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