kernel/drivers/net/wireless/mwifiex/main.c

   1 /*
   2  * Marvell Wireless LAN device driver: major functions
   3  *
   4  * Copyright (C) 2011-2014, Marvell International Ltd.
   5  *
   6  * This software file (the "File") is distributed by Marvell International
   7  * Ltd. under the terms of the GNU General Public License Version 2, June 1991
   8  * (the "License").  You may use, redistribute and/or modify this File in
   9  * accordance with the terms and conditions of the License, a copy of which
  10  * is available by writing to the Free Software Foundation, Inc.,
  11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
  12  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
  13  *
  14  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
  17  * this warranty disclaimer.
  18  */
  19
  20 #include "main.h"
  21 #include "wmm.h"
  22 #include "cfg80211.h"
  23 #include "11n.h"
  24
  25 #define VERSION "1.0"
  26
  27 const char driver_version[] = "mwifiex " VERSION " (%s) ";
  28 static char *cal_data_cfg;
  29 module_param(cal_data_cfg, charp, 0);
  30
  31 static unsigned short driver_mode;
  32 module_param(driver_mode, ushort, 0);
  33 MODULE_PARM_DESC(driver_mode,
  34                  "station=0x1(default), ap-sta=0x3, station-p2p=0x5, ap-sta-p2p=0x7");
  35
  36 /*
  37  * This function registers the device and performs all the necessary
  38  * initializations.
  39  *
  40  * The following initialization operations are performed -
  41  *      - Allocate adapter structure
  42  *      - Save interface specific operations table in adapter
  43  *      - Call interface specific initialization routine
  44  *      - Allocate private structures
  45  *      - Set default adapter structure parameters
  46  *      - Initialize locks
  47  *
  48  * In case of any errors during inittialization, this function also ensures
  49  * proper cleanup before exiting.
  50  */
  51 static int mwifiex_register(void *card, struct mwifiex_if_ops *if_ops,
  52                             void **padapter)
  53 {
  54         struct mwifiex_adapter *adapter;
  55         int i;
  56
  57         adapter = kzalloc(sizeof(struct mwifiex_adapter), GFP_KERNEL);
  58         if (!adapter)
  59                 return -ENOMEM;
  60
  61         *padapter = adapter;
  62         adapter->card = card;
  63
  64         /* Save interface specific operations in adapter */
  65         memmove(&adapter->if_ops, if_ops, sizeof(struct mwifiex_if_ops));
  66
  67         /* card specific initialization has been deferred until now .. */
  68         if (adapter->if_ops.init_if)
  69                 if (adapter->if_ops.init_if(adapter))
  70                         goto error;
  71
  72         adapter->priv_num = 0;
  73
  74         for (i = 0; i < MWIFIEX_MAX_BSS_NUM; i++) {
  75                 /* Allocate memory for private structure */
  76                 adapter->priv[i] =
  77                         kzalloc(sizeof(struct mwifiex_private), GFP_KERNEL);
  78                 if (!adapter->priv[i])
  79                         goto error;
  80
  81                 adapter->priv[i]->adapter = adapter;
  82                 adapter->priv_num++;
  83         }
  84         mwifiex_init_lock_list(adapter);
  85
  86         setup_timer(&adapter->cmd_timer, mwifiex_cmd_timeout_func,
  87                     (unsigned long)adapter);
  88
  89         return 0;
  90
  91 error:
  92         dev_dbg(adapter->dev, "info: leave mwifiex_register with error\n");
  93
  94         for (i = 0; i < adapter->priv_num; i++)
  95                 kfree(adapter->priv[i]);
  96
  97         kfree(adapter);
  98
  99         return -1;
 100 }
 101
 102 /*
 103  * This function unregisters the device and performs all the necessary
 104  * cleanups.
 105  *
 106  * The following cleanup operations are performed -
 107  *      - Free the timers
 108  *      - Free beacon buffers
 109  *      - Free private structures
 110  *      - Free adapter structure
 111  */
 112 static int mwifiex_unregister(struct mwifiex_adapter *adapter)
 113 {
 114         s32 i;
 115
 116         if (adapter->if_ops.cleanup_if)
 117                 adapter->if_ops.cleanup_if(adapter);
 118
 119         del_timer_sync(&adapter->cmd_timer);
 120
 121         /* Free private structures */
 122         for (i = 0; i < adapter->priv_num; i++) {
 123                 if (adapter->priv[i]) {
 124                         mwifiex_free_curr_bcn(adapter->priv[i]);
 125                         kfree(adapter->priv[i]);
 126                 }
 127         }
 128
 129         vfree(adapter->chan_stats);
 130         kfree(adapter);
 131         return 0;
 132 }
 133
 134 void mwifiex_queue_main_work(struct mwifiex_adapter *adapter)
 135 {
 136         unsigned long flags;
 137
 138         spin_lock_irqsave(&adapter->main_proc_lock, flags);
 139         if (adapter->mwifiex_processing) {
 140                 adapter->more_task_flag = true;
 141                 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
 142         } else {
 143                 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
 144                 queue_work(adapter->workqueue, &adapter->main_work);
 145         }
 146 }
 147 EXPORT_SYMBOL_GPL(mwifiex_queue_main_work);
 148
 149 static void mwifiex_queue_rx_work(struct mwifiex_adapter *adapter)
 150 {
 151         unsigned long flags;
 152
 153         spin_lock_irqsave(&adapter->rx_proc_lock, flags);
 154         if (adapter->rx_processing) {
 155                 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
 156         } else {
 157                 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
 158                 queue_work(adapter->rx_workqueue, &adapter->rx_work);
 159         }
 160 }
 161
 162 static int mwifiex_process_rx(struct mwifiex_adapter *adapter)
 163 {
 164         unsigned long flags;
 165         struct sk_buff *skb;
 166         struct mwifiex_rxinfo *rx_info;
 167
 168         spin_lock_irqsave(&adapter->rx_proc_lock, flags);
 169         if (adapter->rx_processing || adapter->rx_locked) {
 170                 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
 171                 goto exit_rx_proc;
 172         } else {
 173                 adapter->rx_processing = true;
 174                 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
 175         }
 176
 177         /* Check for Rx data */
 178         while ((skb = skb_dequeue(&adapter->rx_data_q))) {
 179                 atomic_dec(&adapter->rx_pending);
 180                 if ((adapter->delay_main_work ||
 181                      adapter->iface_type == MWIFIEX_USB) &&
 182                     (atomic_read(&adapter->rx_pending) < LOW_RX_PENDING)) {
 183                         if (adapter->if_ops.submit_rem_rx_urbs)
 184                                 adapter->if_ops.submit_rem_rx_urbs(adapter);
 185                         adapter->delay_main_work = false;
 186                         mwifiex_queue_main_work(adapter);
 187                 }
 188                 rx_info = MWIFIEX_SKB_RXCB(skb);
 189                 if (rx_info->buf_type == MWIFIEX_TYPE_AGGR_DATA) {
 190                         if (adapter->if_ops.deaggr_pkt)
 191                                 adapter->if_ops.deaggr_pkt(adapter, skb);
 192                         dev_kfree_skb_any(skb);
 193                 } else {
 194                         mwifiex_handle_rx_packet(adapter, skb);
 195                 }
 196         }
 197         spin_lock_irqsave(&adapter->rx_proc_lock, flags);
 198         adapter->rx_processing = false;
 199         spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
 200
 201 exit_rx_proc:
 202         return 0;
 203 }
 204
 205 /*
 206  * The main process.
 207  *
 208  * This function is the main procedure of the driver and handles various driver
 209  * operations. It runs in a loop and provides the core functionalities.
 210  *
 211  * The main responsibilities of this function are -
 212  *      - Ensure concurrency control
 213  *      - Handle pending interrupts and call interrupt handlers
 214  *      - Wake up the card if required
 215  *      - Handle command responses and call response handlers
 216  *      - Handle events and call event handlers
 217  *      - Execute pending commands
 218  *      - Transmit pending data packets
 219  */
 220 int mwifiex_main_process(struct mwifiex_adapter *adapter)
 221 {
 222         int ret = 0;
 223         unsigned long flags;
 224
 225         spin_lock_irqsave(&adapter->main_proc_lock, flags);
 226
 227         /* Check if already processing */
 228         if (adapter->mwifiex_processing || adapter->main_locked) {
 229                 adapter->more_task_flag = true;
 230                 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
 231                 goto exit_main_proc;
 232         } else {
 233                 adapter->mwifiex_processing = true;
 234         }
 235 process_start:
 236         do {
 237                 adapter->more_task_flag = false;
 238                 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
 239                 if ((adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING) ||
 240                     (adapter->hw_status == MWIFIEX_HW_STATUS_NOT_READY))
 241                         break;
 242
 243                 /* For non-USB interfaces, If we process interrupts first, it
 244                  * would increase RX pending even further. Avoid this by
 245                  * checking if rx_pending has crossed high threshold and
 246                  * schedule rx work queue and then process interrupts.
 247                  * For USB interface, there are no interrupts. We already have
 248                  * HIGH_RX_PENDING check in usb.c
 249                  */
 250                 if (atomic_read(&adapter->rx_pending) >= HIGH_RX_PENDING &&
 251                     adapter->iface_type != MWIFIEX_USB) {
 252                         adapter->delay_main_work = true;
 253                         mwifiex_queue_rx_work(adapter);
 254                         break;
 255                 }
 256
 257                 /* Handle pending interrupt if any */
 258                 if (adapter->int_status) {
 259                         if (adapter->hs_activated)
 260                                 mwifiex_process_hs_config(adapter);
 261                         if (adapter->if_ops.process_int_status)
 262                                 adapter->if_ops.process_int_status(adapter);
 263                 }
 264
 265                 if (adapter->rx_work_enabled && adapter->data_received)
 266                         mwifiex_queue_rx_work(adapter);
 267
 268                 /* Need to wake up the card ? */
 269                 if ((adapter->ps_state == PS_STATE_SLEEP) &&
 270                     (adapter->pm_wakeup_card_req &&
 271                      !adapter->pm_wakeup_fw_try) &&
 272                     (is_command_pending(adapter) ||
 273                      !skb_queue_empty(&adapter->tx_data_q) ||
 274                      !mwifiex_wmm_lists_empty(adapter))) {
 275                         adapter->pm_wakeup_fw_try = true;
 276                         mod_timer(&adapter->wakeup_timer, jiffies + (HZ*3));
 277                         adapter->if_ops.wakeup(adapter);
 278                         spin_lock_irqsave(&adapter->main_proc_lock, flags);
 279                         continue;
 280                 }
 281
 282                 if (IS_CARD_RX_RCVD(adapter)) {
 283                         adapter->data_received = false;
 284                         adapter->pm_wakeup_fw_try = false;
 285                         del_timer(&adapter->wakeup_timer);
 286                         if (adapter->ps_state == PS_STATE_SLEEP)
 287                                 adapter->ps_state = PS_STATE_AWAKE;
 288                 } else {
 289                         /* We have tried to wakeup the card already */
 290                         if (adapter->pm_wakeup_fw_try)
 291                                 break;
 292                         if (adapter->ps_state != PS_STATE_AWAKE ||
 293                             adapter->tx_lock_flag)
 294                                 break;
 295
 296                         if ((!adapter->scan_chan_gap_enabled &&
 297                              adapter->scan_processing) || adapter->data_sent ||
 298                             (mwifiex_wmm_lists_empty(adapter) &&
 299                              skb_queue_empty(&adapter->tx_data_q))) {
 300                                 if (adapter->cmd_sent || adapter->curr_cmd ||
 301                                     (!is_command_pending(adapter)))
 302                                         break;
 303                         }
 304                 }
 305
 306                 /* Check for event */
 307                 if (adapter->event_received) {
 308                         adapter->event_received = false;
 309                         mwifiex_process_event(adapter);
 310                 }
 311
 312                 /* Check for Cmd Resp */
 313                 if (adapter->cmd_resp_received) {
 314                         adapter->cmd_resp_received = false;
 315                         mwifiex_process_cmdresp(adapter);
 316
 317                         /* call mwifiex back when init_fw is done */
 318                         if (adapter->hw_status == MWIFIEX_HW_STATUS_INIT_DONE) {
 319                                 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
 320                                 mwifiex_init_fw_complete(adapter);
 321                         }
 322                 }
 323
 324                 /* Check if we need to confirm Sleep Request
 325                    received previously */
 326                 if (adapter->ps_state == PS_STATE_PRE_SLEEP) {
 327                         if (!adapter->cmd_sent && !adapter->curr_cmd)
 328                                 mwifiex_check_ps_cond(adapter);
 329                 }
 330
 331                 /* * The ps_state may have been changed during processing of
 332                  * Sleep Request event.
 333                  */
 334                 if ((adapter->ps_state == PS_STATE_SLEEP) ||
 335                     (adapter->ps_state == PS_STATE_PRE_SLEEP) ||
 336                     (adapter->ps_state == PS_STATE_SLEEP_CFM) ||
 337                     adapter->tx_lock_flag){
 338                         spin_lock_irqsave(&adapter->main_proc_lock, flags);
 339                         continue;
 340                 }
 341
 342                 if (!adapter->cmd_sent && !adapter->curr_cmd) {
 343                         if (mwifiex_exec_next_cmd(adapter) == -1) {
 344                                 ret = -1;
 345                                 break;
 346                         }
 347                 }
 348
 349                 if ((adapter->scan_chan_gap_enabled ||
 350                      !adapter->scan_processing) &&
 351                     !adapter->data_sent &&
 352                     !skb_queue_empty(&adapter->tx_data_q)) {
 353                         mwifiex_process_tx_queue(adapter);
 354                         if (adapter->hs_activated) {
 355                                 adapter->is_hs_configured = false;
 356                                 mwifiex_hs_activated_event
 357                                         (mwifiex_get_priv
 358                                         (adapter, MWIFIEX_BSS_ROLE_ANY),
 359                                         false);
 360                         }
 361                 }
 362
 363                 if ((adapter->scan_chan_gap_enabled ||
 364                      !adapter->scan_processing) &&
 365                     !adapter->data_sent && !mwifiex_wmm_lists_empty(adapter)) {
 366                         mwifiex_wmm_process_tx(adapter);
 367                         if (adapter->hs_activated) {
 368                                 adapter->is_hs_configured = false;
 369                                 mwifiex_hs_activated_event
 370                                         (mwifiex_get_priv
 371                                          (adapter, MWIFIEX_BSS_ROLE_ANY),
 372                                          false);
 373                         }
 374                 }
 375
 376                 if (adapter->delay_null_pkt && !adapter->cmd_sent &&
 377                     !adapter->curr_cmd && !is_command_pending(adapter) &&
 378                     (mwifiex_wmm_lists_empty(adapter) &&
 379                      skb_queue_empty(&adapter->tx_data_q))) {
 380                         if (!mwifiex_send_null_packet
 381                             (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
 382                              MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET |
 383                              MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET)) {
 384                                 adapter->delay_null_pkt = false;
 385                                 adapter->ps_state = PS_STATE_SLEEP;
 386                         }
 387                         break;
 388                 }
 389                 spin_lock_irqsave(&adapter->main_proc_lock, flags);
 390         } while (true);
 391
 392         spin_lock_irqsave(&adapter->main_proc_lock, flags);
 393         if (adapter->more_task_flag)
 394                 goto process_start;
 395         adapter->mwifiex_processing = false;
 396         spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
 397
 398 exit_main_proc:
 399         if (adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING)
 400                 mwifiex_shutdown_drv(adapter);
 401         return ret;
 402 }
 403 EXPORT_SYMBOL_GPL(mwifiex_main_process);
 404
 405 /*
 406  * This function frees the adapter structure.
 407  *
 408  * Additionally, this closes the netlink socket, frees the timers
 409  * and private structures.
 410  */
 411 static void mwifiex_free_adapter(struct mwifiex_adapter *adapter)
 412 {
 413         if (!adapter) {
 414                 pr_err("%s: adapter is NULL\n", __func__);
 415                 return;
 416         }
 417
 418         mwifiex_unregister(adapter);
 419         pr_debug("info: %s: free adapter\n", __func__);
 420 }
 421
 422 /*
 423  * This function cancels all works in the queue and destroys
 424  * the main workqueue.
 425  */
 426 static void mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
 427 {
 428         flush_workqueue(adapter->workqueue);
 429         destroy_workqueue(adapter->workqueue);
 430         adapter->workqueue = NULL;
 431
 432         if (adapter->rx_workqueue) {
 433                 flush_workqueue(adapter->rx_workqueue);
 434                 destroy_workqueue(adapter->rx_workqueue);
 435                 adapter->rx_workqueue = NULL;
 436         }
 437 }
 438
 439 /*
 440  * This function gets firmware and initializes it.
 441  *
 442  * The main initialization steps followed are -
 443  *      - Download the correct firmware to card
 444  *      - Issue the init commands to firmware
 445  */
 446 static void mwifiex_fw_dpc(const struct firmware *firmware, void *context)
 447 {
 448         int ret;
 449         char fmt[64];
 450         struct mwifiex_private *priv;
 451         struct mwifiex_adapter *adapter = context;
 452         struct mwifiex_fw_image fw;
 453         struct semaphore *sem = adapter->card_sem;
 454         bool init_failed = false;
 455         struct wireless_dev *wdev;
 456
 457         if (!firmware) {
 458                 dev_err(adapter->dev,
 459                         "Failed to get firmware %s\n", adapter->fw_name);
 460                 goto err_dnld_fw;
 461         }
 462
 463         memset(&fw, 0, sizeof(struct mwifiex_fw_image));
 464         adapter->firmware = firmware;
 465         fw.fw_buf = (u8 *) adapter->firmware->data;
 466         fw.fw_len = adapter->firmware->size;
 467
 468         if (adapter->if_ops.dnld_fw)
 469                 ret = adapter->if_ops.dnld_fw(adapter, &fw);
 470         else
 471                 ret = mwifiex_dnld_fw(adapter, &fw);
 472         if (ret == -1)
 473                 goto err_dnld_fw;
 474
 475         dev_notice(adapter->dev, "WLAN FW is active\n");
 476
 477         if (cal_data_cfg) {
 478                 if ((request_firmware(&adapter->cal_data, cal_data_cfg,
 479                                       adapter->dev)) < 0)
 480                         dev_err(adapter->dev,
 481                                 "Cal data request_firmware() failed\n");
 482         }
 483
 484         /* enable host interrupt after fw dnld is successful */
 485         if (adapter->if_ops.enable_int) {
 486                 if (adapter->if_ops.enable_int(adapter))
 487                         goto err_dnld_fw;
 488         }
 489
 490         adapter->init_wait_q_woken = false;
 491         ret = mwifiex_init_fw(adapter);
 492         if (ret == -1) {
 493                 goto err_init_fw;
 494         } else if (!ret) {
 495                 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
 496                 goto done;
 497         }
 498         /* Wait for mwifiex_init to complete */
 499         wait_event_interruptible(adapter->init_wait_q,
 500                                  adapter->init_wait_q_woken);
 501         if (adapter->hw_status != MWIFIEX_HW_STATUS_READY)
 502                 goto err_init_fw;
 503
 504         priv = adapter->priv[MWIFIEX_BSS_ROLE_STA];
 505         if (mwifiex_register_cfg80211(adapter)) {
 506                 dev_err(adapter->dev, "cannot register with cfg80211\n");
 507                 goto err_init_fw;
 508         }
 509
 510         if (mwifiex_init_channel_scan_gap(adapter)) {
 511                 dev_err(adapter->dev, "could not init channel stats table\n");
 512                 goto err_init_fw;
 513         }
 514
 515         if (driver_mode) {
 516                 driver_mode &= MWIFIEX_DRIVER_MODE_BITMASK;
 517                 driver_mode |= MWIFIEX_DRIVER_MODE_STA;
 518         }
 519
 520         rtnl_lock();
 521         /* Create station interface by default */
 522         wdev = mwifiex_add_virtual_intf(adapter->wiphy, "mlan%d", NET_NAME_ENUM,
 523                                         NL80211_IFTYPE_STATION, NULL, NULL);
 524         if (IS_ERR(wdev)) {
 525                 dev_err(adapter->dev, "cannot create default STA interface\n");
 526                 rtnl_unlock();
 527                 goto err_add_intf;
 528         }
 529
 530         if (driver_mode & MWIFIEX_DRIVER_MODE_UAP) {
 531                 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "uap%d", NET_NAME_ENUM,
 532                                                 NL80211_IFTYPE_AP, NULL, NULL);
 533                 if (IS_ERR(wdev)) {
 534                         dev_err(adapter->dev, "cannot create AP interface\n");
 535                         rtnl_unlock();
 536                         goto err_add_intf;
 537                 }
 538         }
 539
 540         if (driver_mode & MWIFIEX_DRIVER_MODE_P2P) {
 541                 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "p2p%d", NET_NAME_ENUM,
 542                                                 NL80211_IFTYPE_P2P_CLIENT, NULL,
 543                                                 NULL);
 544                 if (IS_ERR(wdev)) {
 545                         dev_err(adapter->dev,
 546                                 "cannot create p2p client interface\n");
 547                         rtnl_unlock();
 548                         goto err_add_intf;
 549                 }
 550         }
 551         rtnl_unlock();
 552
 553         mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
 554         dev_notice(adapter->dev, "driver_version = %s\n", fmt);
 555         goto done;
 556
 557 err_add_intf:
 558         wiphy_unregister(adapter->wiphy);
 559         wiphy_free(adapter->wiphy);
 560 err_init_fw:
 561         if (adapter->if_ops.disable_int)
 562                 adapter->if_ops.disable_int(adapter);
 563 err_dnld_fw:
 564         pr_debug("info: %s: unregister device\n", __func__);
 565         if (adapter->if_ops.unregister_dev)
 566                 adapter->if_ops.unregister_dev(adapter);
 567
 568         if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) {
 569                 pr_debug("info: %s: shutdown mwifiex\n", __func__);
 570                 adapter->init_wait_q_woken = false;
 571
 572                 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
 573                         wait_event_interruptible(adapter->init_wait_q,
 574                                                  adapter->init_wait_q_woken);
 575         }
 576         adapter->surprise_removed = true;
 577         mwifiex_terminate_workqueue(adapter);
 578         init_failed = true;
 579 done:
 580         if (adapter->cal_data) {
 581                 release_firmware(adapter->cal_data);
 582                 adapter->cal_data = NULL;
 583         }
 584         if (adapter->firmware) {
 585                 release_firmware(adapter->firmware);
 586                 adapter->firmware = NULL;
 587         }
 588         if (init_failed)
 589                 mwifiex_free_adapter(adapter);
 590         up(sem);
 591         return;
 592 }
 593
 594 /*
 595  * This function initializes the hardware and gets firmware.
 596  */
 597 static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter)
 598 {
 599         int ret;
 600
 601         ret = request_firmware_nowait(THIS_MODULE, 1, adapter->fw_name,
 602                                       adapter->dev, GFP_KERNEL, adapter,
 603                                       mwifiex_fw_dpc);
 604         if (ret < 0)
 605                 dev_err(adapter->dev,
 606                         "request_firmware_nowait() returned error %d\n", ret);
 607         return ret;
 608 }
 609
 610 /*
 611  * CFG802.11 network device handler for open.
 612  *
 613  * Starts the data queue.
 614  */
 615 static int
 616 mwifiex_open(struct net_device *dev)
 617 {
 618         netif_carrier_off(dev);
 619
 620         return 0;
 621 }
 622
 623 /*
 624  * CFG802.11 network device handler for close.
 625  */
 626 static int
 627 mwifiex_close(struct net_device *dev)
 628 {
 629         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 630
 631         if (priv->scan_request) {
 632                 dev_dbg(priv->adapter->dev, "aborting scan on ndo_stop\n");
 633                 cfg80211_scan_done(priv->scan_request, 1);
 634                 priv->scan_request = NULL;
 635                 priv->scan_aborting = true;
 636         }
 637
 638         return 0;
 639 }
 640
 641 /*
 642  * Add buffer into wmm tx queue and queue work to transmit it.
 643  */
 644 int mwifiex_queue_tx_pkt(struct mwifiex_private *priv, struct sk_buff *skb)
 645 {
 646         struct netdev_queue *txq;
 647         int index = mwifiex_1d_to_wmm_queue[skb->priority];
 648
 649         if (atomic_inc_return(&priv->wmm_tx_pending[index]) >= MAX_TX_PENDING) {
 650                 txq = netdev_get_tx_queue(priv->netdev, index);
 651                 if (!netif_tx_queue_stopped(txq)) {
 652                         netif_tx_stop_queue(txq);
 653                         dev_dbg(priv->adapter->dev, "stop queue: %d\n", index);
 654                 }
 655         }
 656
 657         atomic_inc(&priv->adapter->tx_pending);
 658         mwifiex_wmm_add_buf_txqueue(priv, skb);
 659
 660         mwifiex_queue_main_work(priv->adapter);
 661
 662         return 0;
 663 }
 664
 665 struct sk_buff *
 666 mwifiex_clone_skb_for_tx_status(struct mwifiex_private *priv,
 667                                 struct sk_buff *skb, u8 flag, u64 *cookie)
 668 {
 669         struct sk_buff *orig_skb = skb;
 670         struct mwifiex_txinfo *tx_info, *orig_tx_info;
 671
 672         skb = skb_clone(skb, GFP_ATOMIC);
 673         if (skb) {
 674                 unsigned long flags;
 675                 int id;
 676
 677                 spin_lock_irqsave(&priv->ack_status_lock, flags);
 678                 id = idr_alloc(&priv->ack_status_frames, orig_skb,
 679                                1, 0xff, GFP_ATOMIC);
 680                 spin_unlock_irqrestore(&priv->ack_status_lock, flags);
 681
 682                 if (id >= 0) {
 683                         tx_info = MWIFIEX_SKB_TXCB(skb);
 684                         tx_info->ack_frame_id = id;
 685                         tx_info->flags |= flag;
 686                         orig_tx_info = MWIFIEX_SKB_TXCB(orig_skb);
 687                         orig_tx_info->ack_frame_id = id;
 688                         orig_tx_info->flags |= flag;
 689
 690                         if (flag == MWIFIEX_BUF_FLAG_ACTION_TX_STATUS && cookie)
 691                                 orig_tx_info->cookie = *cookie;
 692
 693                 } else if (skb_shared(skb)) {
 694                         kfree_skb(orig_skb);
 695                 } else {
 696                         kfree_skb(skb);
 697                         skb = orig_skb;
 698                 }
 699         } else {
 700                 /* couldn't clone -- lose tx status ... */
 701                 skb = orig_skb;
 702         }
 703
 704         return skb;
 705 }
 706
 707 /*
 708  * CFG802.11 network device handler for data transmission.
 709  */
 710 static int
 711 mwifiex_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 712 {
 713         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 714         struct sk_buff *new_skb;
 715         struct mwifiex_txinfo *tx_info;
 716         bool multicast;
 717
 718         dev_dbg(priv->adapter->dev, "data: %lu BSS(%d-%d): Data <= kernel\n",
 719                 jiffies, priv->bss_type, priv->bss_num);
 720
 721         if (priv->adapter->surprise_removed) {
 722                 kfree_skb(skb);
 723                 priv->stats.tx_dropped++;
 724                 return 0;
 725         }
 726         if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
 727                 dev_err(priv->adapter->dev, "Tx: bad skb len %d\n", skb->len);
 728                 kfree_skb(skb);
 729                 priv->stats.tx_dropped++;
 730                 return 0;
 731         }
 732         if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) {
 733                 dev_dbg(priv->adapter->dev,
 734                         "data: Tx: insufficient skb headroom %d\n",
 735                         skb_headroom(skb));
 736                 /* Insufficient skb headroom - allocate a new skb */
 737                 new_skb =
 738                         skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN);
 739                 if (unlikely(!new_skb)) {
 740                         dev_err(priv->adapter->dev, "Tx: cannot alloca new_skb\n");
 741                         kfree_skb(skb);
 742                         priv->stats.tx_dropped++;
 743                         return 0;
 744                 }
 745                 kfree_skb(skb);
 746                 skb = new_skb;
 747                 dev_dbg(priv->adapter->dev, "info: new skb headroomd %d\n",
 748                         skb_headroom(skb));
 749         }
 750
 751         tx_info = MWIFIEX_SKB_TXCB(skb);
 752         memset(tx_info, 0, sizeof(*tx_info));
 753         tx_info->bss_num = priv->bss_num;
 754         tx_info->bss_type = priv->bss_type;
 755         tx_info->pkt_len = skb->len;
 756
 757         multicast = is_multicast_ether_addr(skb->data);
 758
 759         if (unlikely(!multicast && skb->sk &&
 760                      skb_shinfo(skb)->tx_flags & SKBTX_WIFI_STATUS &&
 761                      priv->adapter->fw_api_ver == MWIFIEX_FW_V15))
 762                 skb = mwifiex_clone_skb_for_tx_status(priv,
 763                                                       skb,
 764                                         MWIFIEX_BUF_FLAG_EAPOL_TX_STATUS, NULL);
 765
 766         /* Record the current time the packet was queued; used to
 767          * determine the amount of time the packet was queued in
 768          * the driver before it was sent to the firmware.
 769          * The delay is then sent along with the packet to the
 770          * firmware for aggregate delay calculation for stats and
 771          * MSDU lifetime expiry.
 772          */
 773         __net_timestamp(skb);
 774
 775         if (ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) &&
 776             priv->bss_type == MWIFIEX_BSS_TYPE_STA &&
 777             !ether_addr_equal_unaligned(priv->cfg_bssid, skb->data)) {
 778                 if (priv->adapter->auto_tdls && priv->check_tdls_tx)
 779                         mwifiex_tdls_check_tx(priv, skb);
 780         }
 781
 782         mwifiex_queue_tx_pkt(priv, skb);
 783
 784         return 0;
 785 }
 786
 787 /*
 788  * CFG802.11 network device handler for setting MAC address.
 789  */
 790 static int
 791 mwifiex_set_mac_address(struct net_device *dev, void *addr)
 792 {
 793         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 794         struct sockaddr *hw_addr = addr;
 795         int ret;
 796
 797         memcpy(priv->curr_addr, hw_addr->sa_data, ETH_ALEN);
 798
 799         /* Send request to firmware */
 800         ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_MAC_ADDRESS,
 801                                HostCmd_ACT_GEN_SET, 0, NULL, true);
 802
 803         if (!ret)
 804                 memcpy(priv->netdev->dev_addr, priv->curr_addr, ETH_ALEN);
 805         else
 806                 dev_err(priv->adapter->dev,
 807                         "set mac address failed: ret=%d\n", ret);
 808
 809         memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
 810
 811         return ret;
 812 }
 813
 814 /*
 815  * CFG802.11 network device handler for setting multicast list.
 816  */
 817 static void mwifiex_set_multicast_list(struct net_device *dev)
 818 {
 819         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 820         struct mwifiex_multicast_list mcast_list;
 821
 822         if (dev->flags & IFF_PROMISC) {
 823                 mcast_list.mode = MWIFIEX_PROMISC_MODE;
 824         } else if (dev->flags & IFF_ALLMULTI ||
 825                    netdev_mc_count(dev) > MWIFIEX_MAX_MULTICAST_LIST_SIZE) {
 826                 mcast_list.mode = MWIFIEX_ALL_MULTI_MODE;
 827         } else {
 828                 mcast_list.mode = MWIFIEX_MULTICAST_MODE;
 829                 mcast_list.num_multicast_addr =
 830                         mwifiex_copy_mcast_addr(&mcast_list, dev);
 831         }
 832         mwifiex_request_set_multicast_list(priv, &mcast_list);
 833 }
 834
 835 /*
 836  * CFG802.11 network device handler for transmission timeout.
 837  */
 838 static void
 839 mwifiex_tx_timeout(struct net_device *dev)
 840 {
 841         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 842
 843         priv->num_tx_timeout++;
 844         priv->tx_timeout_cnt++;
 845         dev_err(priv->adapter->dev,
 846                 "%lu : Tx timeout(#%d), bss_type-num = %d-%d\n",
 847                 jiffies, priv->tx_timeout_cnt, priv->bss_type, priv->bss_num);
 848         mwifiex_set_trans_start(dev);
 849
 850         if (priv->tx_timeout_cnt > TX_TIMEOUT_THRESHOLD &&
 851             priv->adapter->if_ops.card_reset) {
 852                 dev_err(priv->adapter->dev,
 853                         "tx_timeout_cnt exceeds threshold. Triggering card reset!\n");
 854                 priv->adapter->if_ops.card_reset(priv->adapter);
 855         }
 856 }
 857
 858 void mwifiex_dump_drv_info(struct mwifiex_adapter *adapter)
 859 {
 860         void *p;
 861         char drv_version[64];
 862         struct usb_card_rec *cardp;
 863         struct sdio_mmc_card *sdio_card;
 864         struct mwifiex_private *priv;
 865         int i, idx;
 866         struct netdev_queue *txq;
 867         struct mwifiex_debug_info *debug_info;
 868
 869         if (adapter->drv_info_dump) {
 870                 vfree(adapter->drv_info_dump);
 871                 adapter->drv_info_size = 0;
 872         }
 873
 874         dev_info(adapter->dev, "=== DRIVER INFO DUMP START===\n");
 875
 876         adapter->drv_info_dump = vzalloc(MWIFIEX_DRV_INFO_SIZE_MAX);
 877
 878         if (!adapter->drv_info_dump)
 879                 return;
 880
 881         p = (char *)(adapter->drv_info_dump);
 882         p += sprintf(p, "driver_name = " "\"mwifiex\"\n");
 883
 884         mwifiex_drv_get_driver_version(adapter, drv_version,
 885                                        sizeof(drv_version) - 1);
 886         p += sprintf(p, "driver_version = %s\n", drv_version);
 887
 888         if (adapter->iface_type == MWIFIEX_USB) {
 889                 cardp = (struct usb_card_rec *)adapter->card;
 890                 p += sprintf(p, "tx_cmd_urb_pending = %d\n",
 891                              atomic_read(&cardp->tx_cmd_urb_pending));
 892                 p += sprintf(p, "tx_data_urb_pending = %d\n",
 893                              atomic_read(&cardp->tx_data_urb_pending));
 894                 p += sprintf(p, "rx_cmd_urb_pending = %d\n",
 895                              atomic_read(&cardp->rx_cmd_urb_pending));
 896                 p += sprintf(p, "rx_data_urb_pending = %d\n",
 897                              atomic_read(&cardp->rx_data_urb_pending));
 898         }
 899
 900         p += sprintf(p, "tx_pending = %d\n",
 901                      atomic_read(&adapter->tx_pending));
 902         p += sprintf(p, "rx_pending = %d\n",
 903                      atomic_read(&adapter->rx_pending));
 904
 905         if (adapter->iface_type == MWIFIEX_SDIO) {
 906                 sdio_card = (struct sdio_mmc_card *)adapter->card;
 907                 p += sprintf(p, "\nmp_rd_bitmap=0x%x curr_rd_port=0x%x\n",
 908                              sdio_card->mp_rd_bitmap, sdio_card->curr_rd_port);
 909                 p += sprintf(p, "mp_wr_bitmap=0x%x curr_wr_port=0x%x\n",
 910                              sdio_card->mp_wr_bitmap, sdio_card->curr_wr_port);
 911         }
 912
 913         for (i = 0; i < adapter->priv_num; i++) {
 914                 if (!adapter->priv[i] || !adapter->priv[i]->netdev)
 915                         continue;
 916                 priv = adapter->priv[i];
 917                 p += sprintf(p, "\n[interface  : \"%s\"]\n",
 918                              priv->netdev->name);
 919                 p += sprintf(p, "wmm_tx_pending[0] = %d\n",
 920                              atomic_read(&priv->wmm_tx_pending[0]));
 921                 p += sprintf(p, "wmm_tx_pending[1] = %d\n",
 922                              atomic_read(&priv->wmm_tx_pending[1]));
 923                 p += sprintf(p, "wmm_tx_pending[2] = %d\n",
 924                              atomic_read(&priv->wmm_tx_pending[2]));
 925                 p += sprintf(p, "wmm_tx_pending[3] = %d\n",
 926                              atomic_read(&priv->wmm_tx_pending[3]));
 927                 p += sprintf(p, "media_state=\"%s\"\n", !priv->media_connected ?
 928                              "Disconnected" : "Connected");
 929                 p += sprintf(p, "carrier %s\n", (netif_carrier_ok(priv->netdev)
 930                              ? "on" : "off"));
 931                 for (idx = 0; idx < priv->netdev->num_tx_queues; idx++) {
 932                         txq = netdev_get_tx_queue(priv->netdev, idx);
 933                         p += sprintf(p, "tx queue %d:%s  ", idx,
 934                                      netif_tx_queue_stopped(txq) ?
 935                                      "stopped" : "started");
 936                 }
 937                 p += sprintf(p, "\n%s: num_tx_timeout = %d\n",
 938                              priv->netdev->name, priv->num_tx_timeout);
 939         }
 940
 941         if (adapter->iface_type == MWIFIEX_SDIO) {
 942                 p += sprintf(p, "\n=== SDIO register DUMP===\n");
 943                 if (adapter->if_ops.reg_dump)
 944                         p += adapter->if_ops.reg_dump(adapter, p);
 945         }
 946
 947         p += sprintf(p, "\n=== MORE DEBUG INFORMATION\n");
 948         debug_info = kzalloc(sizeof(*debug_info), GFP_KERNEL);
 949         if (debug_info) {
 950                 for (i = 0; i < adapter->priv_num; i++) {
 951                         if (!adapter->priv[i] || !adapter->priv[i]->netdev)
 952                                 continue;
 953                         priv = adapter->priv[i];
 954                         mwifiex_get_debug_info(priv, debug_info);
 955                         p += mwifiex_debug_info_to_buffer(priv, p, debug_info);
 956                         break;
 957                 }
 958                 kfree(debug_info);
 959         }
 960
 961         adapter->drv_info_size = p - adapter->drv_info_dump;
 962         dev_info(adapter->dev, "=== DRIVER INFO DUMP END===\n");
 963 }
 964 EXPORT_SYMBOL_GPL(mwifiex_dump_drv_info);
 965
 966 /*
 967  * CFG802.11 network device handler for statistics retrieval.
 968  */
 969 static struct net_device_stats *mwifiex_get_stats(struct net_device *dev)
 970 {
 971         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 972
 973         return &priv->stats;
 974 }
 975
 976 static u16
 977 mwifiex_netdev_select_wmm_queue(struct net_device *dev, struct sk_buff *skb,
 978                                 void *accel_priv, select_queue_fallback_t fallback)
 979 {
 980         skb->priority = cfg80211_classify8021d(skb, NULL);
 981         return mwifiex_1d_to_wmm_queue[skb->priority];
 982 }
 983
 984 /* Network device handlers */
 985 static const struct net_device_ops mwifiex_netdev_ops = {
 986         .ndo_open = mwifiex_open,
 987         .ndo_stop = mwifiex_close,
 988         .ndo_start_xmit = mwifiex_hard_start_xmit,
 989         .ndo_set_mac_address = mwifiex_set_mac_address,
 990         .ndo_tx_timeout = mwifiex_tx_timeout,
 991         .ndo_get_stats = mwifiex_get_stats,
 992         .ndo_set_rx_mode = mwifiex_set_multicast_list,
 993         .ndo_select_queue = mwifiex_netdev_select_wmm_queue,
 994 };
 995
 996 /*
 997  * This function initializes the private structure parameters.
 998  *
 999  * The following wait queues are initialized -
1000  *      - IOCTL wait queue
1001  *      - Command wait queue
1002  *      - Statistics wait queue
1003  *
1004  * ...and the following default parameters are set -
1005  *      - Current key index     : Set to 0
1006  *      - Rate index            : Set to auto
1007  *      - Media connected       : Set to disconnected
1008  *      - Adhoc link sensed     : Set to false
1009  *      - Nick name             : Set to null
1010  *      - Number of Tx timeout  : Set to 0
1011  *      - Device address        : Set to current address
1012  *      - Rx histogram statistc : Set to 0
1013  *
1014  * In addition, the CFG80211 work queue is also created.
1015  */
1016 void mwifiex_init_priv_params(struct mwifiex_private *priv,
1017                               struct net_device *dev)
1018 {
1019         dev->netdev_ops = &mwifiex_netdev_ops;
1020         dev->destructor = free_netdev;
1021         /* Initialize private structure */
1022         priv->current_key_index = 0;
1023         priv->media_connected = false;
1024         memset(priv->mgmt_ie, 0,
1025                sizeof(struct mwifiex_ie) * MAX_MGMT_IE_INDEX);
1026         priv->beacon_idx = MWIFIEX_AUTO_IDX_MASK;
1027         priv->proberesp_idx = MWIFIEX_AUTO_IDX_MASK;
1028         priv->assocresp_idx = MWIFIEX_AUTO_IDX_MASK;
1029         priv->gen_idx = MWIFIEX_AUTO_IDX_MASK;
1030         priv->num_tx_timeout = 0;
1031         ether_addr_copy(priv->curr_addr, priv->adapter->perm_addr);
1032         memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
1033
1034         if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA ||
1035             GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) {
1036                 priv->hist_data = kmalloc(sizeof(*priv->hist_data), GFP_KERNEL);
1037                 if (priv->hist_data)
1038                         mwifiex_hist_data_reset(priv);
1039         }
1040 }
1041
1042 /*
1043  * This function check if command is pending.
1044  */
1045 int is_command_pending(struct mwifiex_adapter *adapter)
1046 {
1047         unsigned long flags;
1048         int is_cmd_pend_q_empty;
1049
1050         spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
1051         is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
1052         spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
1053
1054         return !is_cmd_pend_q_empty;
1055 }
1056
1057 /*
1058  * This is the RX work queue function.
1059  *
1060  * It handles the RX operations.
1061  */
1062 static void mwifiex_rx_work_queue(struct work_struct *work)
1063 {
1064         struct mwifiex_adapter *adapter =
1065                 container_of(work, struct mwifiex_adapter, rx_work);
1066
1067         if (adapter->surprise_removed)
1068                 return;
1069         mwifiex_process_rx(adapter);
1070 }
1071
1072 /*
1073  * This is the main work queue function.
1074  *
1075  * It handles the main process, which in turn handles the complete
1076  * driver operations.
1077  */
1078 static void mwifiex_main_work_queue(struct work_struct *work)
1079 {
1080         struct mwifiex_adapter *adapter =
1081                 container_of(work, struct mwifiex_adapter, main_work);
1082
1083         if (adapter->surprise_removed)
1084                 return;
1085         mwifiex_main_process(adapter);
1086 }
1087
1088 /*
1089  * This function adds the card.
1090  *
1091  * This function follows the following major steps to set up the device -
1092  *      - Initialize software. This includes probing the card, registering
1093  *        the interface operations table, and allocating/initializing the
1094  *        adapter structure
1095  *      - Set up the netlink socket
1096  *      - Create and start the main work queue
1097  *      - Register the device
1098  *      - Initialize firmware and hardware
1099  *      - Add logical interfaces
1100  */
1101 int
1102 mwifiex_add_card(void *card, struct semaphore *sem,
1103                  struct mwifiex_if_ops *if_ops, u8 iface_type)
1104 {
1105         struct mwifiex_adapter *adapter;
1106
1107         if (down_interruptible(sem))
1108                 goto exit_sem_err;
1109
1110         if (mwifiex_register(card, if_ops, (void **)&adapter)) {
1111                 pr_err("%s: software init failed\n", __func__);
1112                 goto err_init_sw;
1113         }
1114
1115         adapter->iface_type = iface_type;
1116         adapter->card_sem = sem;
1117
1118         adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
1119         adapter->surprise_removed = false;
1120         init_waitqueue_head(&adapter->init_wait_q);
1121         adapter->is_suspended = false;
1122         adapter->hs_activated = false;
1123         init_waitqueue_head(&adapter->hs_activate_wait_q);
1124         init_waitqueue_head(&adapter->cmd_wait_q.wait);
1125         adapter->cmd_wait_q.status = 0;
1126         adapter->scan_wait_q_woken = false;
1127
1128         if ((num_possible_cpus() > 1) || adapter->iface_type == MWIFIEX_USB) {
1129                 adapter->rx_work_enabled = true;
1130                 pr_notice("rx work enabled, cpus %d\n", num_possible_cpus());
1131         }
1132
1133         adapter->workqueue =
1134                 alloc_workqueue("MWIFIEX_WORK_QUEUE",
1135                                 WQ_HIGHPRI | WQ_MEM_RECLAIM | WQ_UNBOUND, 1);
1136         if (!adapter->workqueue)
1137                 goto err_kmalloc;
1138
1139         INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
1140
1141         if (adapter->rx_work_enabled) {
1142                 adapter->rx_workqueue = alloc_workqueue("MWIFIEX_RX_WORK_QUEUE",
1143                                                         WQ_HIGHPRI |
1144                                                         WQ_MEM_RECLAIM |
1145                                                         WQ_UNBOUND, 1);
1146                 if (!adapter->rx_workqueue)
1147                         goto err_kmalloc;
1148
1149                 INIT_WORK(&adapter->rx_work, mwifiex_rx_work_queue);
1150         }
1151
1152         /* Register the device. Fill up the private data structure with relevant
1153            information from the card. */
1154         if (adapter->if_ops.register_dev(adapter)) {
1155                 pr_err("%s: failed to register mwifiex device\n", __func__);
1156                 goto err_registerdev;
1157         }
1158
1159         if (mwifiex_init_hw_fw(adapter)) {
1160                 pr_err("%s: firmware init failed\n", __func__);
1161                 goto err_init_fw;
1162         }
1163
1164         return 0;
1165
1166 err_init_fw:
1167         pr_debug("info: %s: unregister device\n", __func__);
1168         if (adapter->if_ops.unregister_dev)
1169                 adapter->if_ops.unregister_dev(adapter);
1170         if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) {
1171                 pr_debug("info: %s: shutdown mwifiex\n", __func__);
1172                 adapter->init_wait_q_woken = false;
1173
1174                 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
1175                         wait_event_interruptible(adapter->init_wait_q,
1176                                                  adapter->init_wait_q_woken);
1177         }
1178 err_registerdev:
1179         adapter->surprise_removed = true;
1180         mwifiex_terminate_workqueue(adapter);
1181 err_kmalloc:
1182         mwifiex_free_adapter(adapter);
1183
1184 err_init_sw:
1185         up(sem);
1186
1187 exit_sem_err:
1188         return -1;
1189 }
1190 EXPORT_SYMBOL_GPL(mwifiex_add_card);
1191
1192 /*
1193  * This function removes the card.
1194  *
1195  * This function follows the following major steps to remove the device -
1196  *      - Stop data traffic
1197  *      - Shutdown firmware
1198  *      - Remove the logical interfaces
1199  *      - Terminate the work queue
1200  *      - Unregister the device
1201  *      - Free the adapter structure
1202  */
1203 int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem)
1204 {
1205         struct mwifiex_private *priv = NULL;
1206         int i;
1207
1208         if (down_interruptible(sem))
1209                 goto exit_sem_err;
1210
1211         if (!adapter)
1212                 goto exit_remove;
1213
1214         /* We can no longer handle interrupts once we start doing the teardown
1215          * below. */
1216         if (adapter->if_ops.disable_int)
1217                 adapter->if_ops.disable_int(adapter);
1218
1219         adapter->surprise_removed = true;
1220
1221         mwifiex_terminate_workqueue(adapter);
1222
1223         /* Stop data */
1224         for (i = 0; i < adapter->priv_num; i++) {
1225                 priv = adapter->priv[i];
1226                 if (priv && priv->netdev) {
1227                         mwifiex_stop_net_dev_queue(priv->netdev, adapter);
1228                         if (netif_carrier_ok(priv->netdev))
1229                                 netif_carrier_off(priv->netdev);
1230                 }
1231         }
1232
1233         dev_dbg(adapter->dev, "cmd: calling mwifiex_shutdown_drv...\n");
1234         adapter->init_wait_q_woken = false;
1235
1236         if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
1237                 wait_event_interruptible(adapter->init_wait_q,
1238                                          adapter->init_wait_q_woken);
1239         dev_dbg(adapter->dev, "cmd: mwifiex_shutdown_drv done\n");
1240         if (atomic_read(&adapter->rx_pending) ||
1241             atomic_read(&adapter->tx_pending) ||
1242             atomic_read(&adapter->cmd_pending)) {
1243                 dev_err(adapter->dev, "rx_pending=%d, tx_pending=%d, "
1244                        "cmd_pending=%d\n",
1245                        atomic_read(&adapter->rx_pending),
1246                        atomic_read(&adapter->tx_pending),
1247                        atomic_read(&adapter->cmd_pending));
1248         }
1249
1250         for (i = 0; i < adapter->priv_num; i++) {
1251                 priv = adapter->priv[i];
1252
1253                 if (!priv)
1254                         continue;
1255
1256                 rtnl_lock();
1257                 if (priv->netdev &&
1258                     priv->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED)
1259                         mwifiex_del_virtual_intf(adapter->wiphy, &priv->wdev);
1260                 rtnl_unlock();
1261         }
1262
1263         wiphy_unregister(adapter->wiphy);
1264         wiphy_free(adapter->wiphy);
1265
1266         /* Unregister device */
1267         dev_dbg(adapter->dev, "info: unregister device\n");
1268         if (adapter->if_ops.unregister_dev)
1269                 adapter->if_ops.unregister_dev(adapter);
1270         /* Free adapter structure */
1271         dev_dbg(adapter->dev, "info: free adapter\n");
1272         mwifiex_free_adapter(adapter);
1273
1274 exit_remove:
1275         up(sem);
1276 exit_sem_err:
1277         return 0;
1278 }
1279 EXPORT_SYMBOL_GPL(mwifiex_remove_card);
1280
1281 /*
1282  * This function initializes the module.
1283  *
1284  * The debug FS is also initialized if configured.
1285  */
1286 static int
1287 mwifiex_init_module(void)
1288 {
1289 #ifdef CONFIG_DEBUG_FS
1290         mwifiex_debugfs_init();
1291 #endif
1292         return 0;
1293 }
1294
1295 /*
1296  * This function cleans up the module.
1297  *
1298  * The debug FS is removed if available.
1299  */
1300 static void
1301 mwifiex_cleanup_module(void)
1302 {
1303 #ifdef CONFIG_DEBUG_FS
1304         mwifiex_debugfs_remove();
1305 #endif
1306 }
1307
1308 module_init(mwifiex_init_module);
1309 module_exit(mwifiex_cleanup_module);
1310
1311 MODULE_AUTHOR("Marvell International Ltd.");
1312 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION);
1313 MODULE_VERSION(VERSION);
1314 MODULE_LICENSE("GPL v2");