drivers/net/wireless/mwifiex/main.c

   1 /*
   2  * Marvell Wireless LAN device driver: major functions
   3  *
   4  * Copyright (C) 2011, 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
  29 /*
  30  * This function registers the device and performs all the necessary
  31  * initializations.
  32  *
  33  * The following initialization operations are performed -
  34  *      - Allocate adapter structure
  35  *      - Save interface specific operations table in adapter
  36  *      - Call interface specific initialization routine
  37  *      - Allocate private structures
  38  *      - Set default adapter structure parameters
  39  *      - Initialize locks
  40  *
  41  * In case of any errors during inittialization, this function also ensures
  42  * proper cleanup before exiting.
  43  */
  44 static int mwifiex_register(void *card, struct mwifiex_if_ops *if_ops,
  45                             void **padapter)
  46 {
  47         struct mwifiex_adapter *adapter;
  48         int i;
  49
  50         adapter = kzalloc(sizeof(struct mwifiex_adapter), GFP_KERNEL);
  51         if (!adapter)
  52                 return -ENOMEM;
  53
  54         *padapter = adapter;
  55         adapter->card = card;
  56
  57         /* Save interface specific operations in adapter */
  58         memmove(&adapter->if_ops, if_ops, sizeof(struct mwifiex_if_ops));
  59
  60         /* card specific initialization has been deferred until now .. */
  61         if (adapter->if_ops.init_if(adapter))
  62                 goto error;
  63
  64         adapter->priv_num = 0;
  65
  66         /* Allocate memory for private structure */
  67         adapter->priv[0] = kzalloc(sizeof(struct mwifiex_private), GFP_KERNEL);
  68         if (!adapter->priv[0]) {
  69                 dev_err(adapter->dev,
  70                         "%s: failed to alloc priv[0]\n", __func__);
  71                 goto error;
  72         }
  73
  74         adapter->priv_num++;
  75
  76         adapter->priv[0]->adapter = adapter;
  77         mwifiex_init_lock_list(adapter);
  78
  79         init_timer(&adapter->cmd_timer);
  80         adapter->cmd_timer.function = mwifiex_cmd_timeout_func;
  81         adapter->cmd_timer.data = (unsigned long) adapter;
  82
  83         return 0;
  84
  85 error:
  86         dev_dbg(adapter->dev, "info: leave mwifiex_register with error\n");
  87
  88         for (i = 0; i < adapter->priv_num; i++)
  89                 kfree(adapter->priv[i]);
  90
  91         kfree(adapter);
  92
  93         return -1;
  94 }
  95
  96 /*
  97  * This function unregisters the device and performs all the necessary
  98  * cleanups.
  99  *
 100  * The following cleanup operations are performed -
 101  *      - Free the timers
 102  *      - Free beacon buffers
 103  *      - Free private structures
 104  *      - Free adapter structure
 105  */
 106 static int mwifiex_unregister(struct mwifiex_adapter *adapter)
 107 {
 108         s32 i;
 109
 110         del_timer(&adapter->cmd_timer);
 111
 112         /* Free private structures */
 113         for (i = 0; i < adapter->priv_num; i++) {
 114                 if (adapter->priv[i]) {
 115                         mwifiex_free_curr_bcn(adapter->priv[i]);
 116                         kfree(adapter->priv[i]);
 117                 }
 118         }
 119
 120         kfree(adapter);
 121         return 0;
 122 }
 123
 124 /*
 125  * The main process.
 126  *
 127  * This function is the main procedure of the driver and handles various driver
 128  * operations. It runs in a loop and provides the core functionalities.
 129  *
 130  * The main responsibilities of this function are -
 131  *      - Ensure concurrency control
 132  *      - Handle pending interrupts and call interrupt handlers
 133  *      - Wake up the card if required
 134  *      - Handle command responses and call response handlers
 135  *      - Handle events and call event handlers
 136  *      - Execute pending commands
 137  *      - Transmit pending data packets
 138  */
 139 int mwifiex_main_process(struct mwifiex_adapter *adapter)
 140 {
 141         int ret = 0;
 142         unsigned long flags;
 143
 144         spin_lock_irqsave(&adapter->main_proc_lock, flags);
 145
 146         /* Check if already processing */
 147         if (adapter->mwifiex_processing) {
 148                 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
 149                 goto exit_main_proc;
 150         } else {
 151                 adapter->mwifiex_processing = true;
 152                 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
 153         }
 154 process_start:
 155         do {
 156                 if ((adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING) ||
 157                     (adapter->hw_status == MWIFIEX_HW_STATUS_NOT_READY))
 158                         break;
 159
 160                 /* Handle pending interrupt if any */
 161                 if (adapter->int_status) {
 162                         if (adapter->hs_activated)
 163                                 mwifiex_process_hs_config(adapter);
 164                         adapter->if_ops.process_int_status(adapter);
 165                 }
 166
 167                 /* Need to wake up the card ? */
 168                 if ((adapter->ps_state == PS_STATE_SLEEP) &&
 169                     (adapter->pm_wakeup_card_req &&
 170                      !adapter->pm_wakeup_fw_try) &&
 171                     (is_command_pending(adapter) ||
 172                      !mwifiex_wmm_lists_empty(adapter))) {
 173                         adapter->pm_wakeup_fw_try = true;
 174                         adapter->if_ops.wakeup(adapter);
 175                         continue;
 176                 }
 177                 if (IS_CARD_RX_RCVD(adapter)) {
 178                         adapter->pm_wakeup_fw_try = false;
 179                         if (adapter->ps_state == PS_STATE_SLEEP)
 180                                 adapter->ps_state = PS_STATE_AWAKE;
 181                 } else {
 182                         /* We have tried to wakeup the card already */
 183                         if (adapter->pm_wakeup_fw_try)
 184                                 break;
 185                         if (adapter->ps_state != PS_STATE_AWAKE ||
 186                             adapter->tx_lock_flag)
 187                                 break;
 188
 189                         if ((adapter->scan_processing &&
 190                              !adapter->scan_delay_cnt) || adapter->data_sent ||
 191                             mwifiex_wmm_lists_empty(adapter)) {
 192                                 if (adapter->cmd_sent || adapter->curr_cmd ||
 193                                     (!is_command_pending(adapter)))
 194                                         break;
 195                         }
 196                 }
 197
 198                 /* Check for Cmd Resp */
 199                 if (adapter->cmd_resp_received) {
 200                         adapter->cmd_resp_received = false;
 201                         mwifiex_process_cmdresp(adapter);
 202
 203                         /* call mwifiex back when init_fw is done */
 204                         if (adapter->hw_status == MWIFIEX_HW_STATUS_INIT_DONE) {
 205                                 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
 206                                 mwifiex_init_fw_complete(adapter);
 207                         }
 208                 }
 209
 210                 /* Check for event */
 211                 if (adapter->event_received) {
 212                         adapter->event_received = false;
 213                         mwifiex_process_event(adapter);
 214                 }
 215
 216                 /* Check if we need to confirm Sleep Request
 217                    received previously */
 218                 if (adapter->ps_state == PS_STATE_PRE_SLEEP) {
 219                         if (!adapter->cmd_sent && !adapter->curr_cmd)
 220                                 mwifiex_check_ps_cond(adapter);
 221                 }
 222
 223                 /* * The ps_state may have been changed during processing of
 224                  * Sleep Request event.
 225                  */
 226                 if ((adapter->ps_state == PS_STATE_SLEEP) ||
 227                     (adapter->ps_state == PS_STATE_PRE_SLEEP) ||
 228                     (adapter->ps_state == PS_STATE_SLEEP_CFM) ||
 229                     adapter->tx_lock_flag)
 230                         continue;
 231
 232                 if (!adapter->cmd_sent && !adapter->curr_cmd) {
 233                         if (mwifiex_exec_next_cmd(adapter) == -1) {
 234                                 ret = -1;
 235                                 break;
 236                         }
 237                 }
 238
 239                 if ((!adapter->scan_processing || adapter->scan_delay_cnt) &&
 240                     !adapter->data_sent && !mwifiex_wmm_lists_empty(adapter)) {
 241                         mwifiex_wmm_process_tx(adapter);
 242                         if (adapter->hs_activated) {
 243                                 adapter->is_hs_configured = false;
 244                                 mwifiex_hs_activated_event
 245                                         (mwifiex_get_priv
 246                                          (adapter, MWIFIEX_BSS_ROLE_ANY),
 247                                          false);
 248                         }
 249                 }
 250
 251                 if (adapter->delay_null_pkt && !adapter->cmd_sent &&
 252                     !adapter->curr_cmd && !is_command_pending(adapter) &&
 253                     mwifiex_wmm_lists_empty(adapter)) {
 254                         if (!mwifiex_send_null_packet
 255                             (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
 256                              MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET |
 257                              MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET)) {
 258                                 adapter->delay_null_pkt = false;
 259                                 adapter->ps_state = PS_STATE_SLEEP;
 260                         }
 261                         break;
 262                 }
 263         } while (true);
 264
 265         if ((adapter->int_status) || IS_CARD_RX_RCVD(adapter))
 266                 goto process_start;
 267
 268         spin_lock_irqsave(&adapter->main_proc_lock, flags);
 269         adapter->mwifiex_processing = false;
 270         spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
 271
 272 exit_main_proc:
 273         if (adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING)
 274                 mwifiex_shutdown_drv(adapter);
 275         return ret;
 276 }
 277
 278 /*
 279  * This function frees the adapter structure.
 280  *
 281  * Additionally, this closes the netlink socket, frees the timers
 282  * and private structures.
 283  */
 284 static void mwifiex_free_adapter(struct mwifiex_adapter *adapter)
 285 {
 286         if (!adapter) {
 287                 pr_err("%s: adapter is NULL\n", __func__);
 288                 return;
 289         }
 290
 291         mwifiex_unregister(adapter);
 292         pr_debug("info: %s: free adapter\n", __func__);
 293 }
 294
 295 /*
 296  * This function gets firmware and initializes it.
 297  *
 298  * The main initialization steps followed are -
 299  *      - Download the correct firmware to card
 300  *      - Issue the init commands to firmware
 301  */
 302 static void mwifiex_fw_dpc(const struct firmware *firmware, void *context)
 303 {
 304         int ret;
 305         char fmt[64];
 306         struct mwifiex_private *priv;
 307         struct mwifiex_adapter *adapter = context;
 308         struct mwifiex_fw_image fw;
 309
 310         if (!firmware) {
 311                 dev_err(adapter->dev,
 312                         "Failed to get firmware %s\n", adapter->fw_name);
 313                 goto done;
 314         }
 315
 316         memset(&fw, 0, sizeof(struct mwifiex_fw_image));
 317         adapter->firmware = firmware;
 318         fw.fw_buf = (u8 *) adapter->firmware->data;
 319         fw.fw_len = adapter->firmware->size;
 320
 321         ret = mwifiex_dnld_fw(adapter, &fw);
 322         if (ret == -1)
 323                 goto done;
 324
 325         dev_notice(adapter->dev, "WLAN FW is active\n");
 326
 327         adapter->init_wait_q_woken = false;
 328         ret = mwifiex_init_fw(adapter);
 329         if (ret == -1) {
 330                 goto done;
 331         } else if (!ret) {
 332                 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
 333                 goto done;
 334         }
 335         /* Wait for mwifiex_init to complete */
 336         wait_event_interruptible(adapter->init_wait_q,
 337                                  adapter->init_wait_q_woken);
 338         if (adapter->hw_status != MWIFIEX_HW_STATUS_READY)
 339                 goto done;
 340
 341         priv = adapter->priv[0];
 342         if (mwifiex_register_cfg80211(priv) != 0) {
 343                 dev_err(adapter->dev, "cannot register with cfg80211\n");
 344                 goto err_init_fw;
 345         }
 346
 347         rtnl_lock();
 348         /* Create station interface by default */
 349         if (!mwifiex_add_virtual_intf(priv->wdev->wiphy, "mlan%d",
 350                                       NL80211_IFTYPE_STATION, NULL, NULL)) {
 351                 dev_err(adapter->dev, "cannot create default STA interface\n");
 352                 goto err_add_intf;
 353         }
 354         rtnl_unlock();
 355
 356         mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
 357         dev_notice(adapter->dev, "driver_version = %s\n", fmt);
 358         goto done;
 359
 360 err_add_intf:
 361         mwifiex_del_virtual_intf(priv->wdev->wiphy, priv->netdev);
 362         rtnl_unlock();
 363 err_init_fw:
 364         pr_debug("info: %s: unregister device\n", __func__);
 365         adapter->if_ops.unregister_dev(adapter);
 366 done:
 367         release_firmware(adapter->firmware);
 368         complete(&adapter->fw_load);
 369         return;
 370 }
 371
 372 /*
 373  * This function initializes the hardware and gets firmware.
 374  */
 375 static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter)
 376 {
 377         int ret;
 378
 379         init_completion(&adapter->fw_load);
 380         ret = request_firmware_nowait(THIS_MODULE, 1, adapter->fw_name,
 381                                       adapter->dev, GFP_KERNEL, adapter,
 382                                       mwifiex_fw_dpc);
 383         if (ret < 0)
 384                 dev_err(adapter->dev,
 385                         "request_firmware_nowait() returned error %d\n", ret);
 386         return ret;
 387 }
 388
 389 /*
 390  * This function fills a driver buffer.
 391  *
 392  * The function associates a given SKB with the provided driver buffer
 393  * and also updates some of the SKB parameters, including IP header,
 394  * priority and timestamp.
 395  */
 396 static void
 397 mwifiex_fill_buffer(struct sk_buff *skb)
 398 {
 399         struct ethhdr *eth;
 400         struct iphdr *iph;
 401         struct timeval tv;
 402         u8 tid = 0;
 403
 404         eth = (struct ethhdr *) skb->data;
 405         switch (eth->h_proto) {
 406         case __constant_htons(ETH_P_IP):
 407                 iph = ip_hdr(skb);
 408                 tid = IPTOS_PREC(iph->tos);
 409                 pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n",
 410                          eth->h_proto, tid, skb->priority);
 411                 break;
 412         case __constant_htons(ETH_P_ARP):
 413                 pr_debug("data: ARP packet: %04x\n", eth->h_proto);
 414         default:
 415                 break;
 416         }
 417 /* Offset for TOS field in the IP header */
 418 #define IPTOS_OFFSET 5
 419         tid = (tid >> IPTOS_OFFSET);
 420         skb->priority = tid;
 421         /* Record the current time the packet was queued; used to
 422            determine the amount of time the packet was queued in
 423            the driver before it was sent to the firmware.
 424            The delay is then sent along with the packet to the
 425            firmware for aggregate delay calculation for stats and
 426            MSDU lifetime expiry.
 427          */
 428         do_gettimeofday(&tv);
 429         skb->tstamp = timeval_to_ktime(tv);
 430 }
 431
 432 /*
 433  * CFG802.11 network device handler for open.
 434  *
 435  * Starts the data queue.
 436  */
 437 static int
 438 mwifiex_open(struct net_device *dev)
 439 {
 440         netif_tx_start_all_queues(dev);
 441         return 0;
 442 }
 443
 444 /*
 445  * CFG802.11 network device handler for close.
 446  */
 447 static int
 448 mwifiex_close(struct net_device *dev)
 449 {
 450         return 0;
 451 }
 452
 453 /*
 454  * CFG802.11 network device handler for data transmission.
 455  */
 456 static int
 457 mwifiex_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 458 {
 459         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 460         struct sk_buff *new_skb;
 461         struct mwifiex_txinfo *tx_info;
 462
 463         dev_dbg(priv->adapter->dev, "data: %lu BSS(%d-%d): Data <= kernel\n",
 464                 jiffies, priv->bss_type, priv->bss_num);
 465
 466         if (priv->adapter->surprise_removed) {
 467                 kfree_skb(skb);
 468                 priv->stats.tx_dropped++;
 469                 return 0;
 470         }
 471         if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
 472                 dev_err(priv->adapter->dev, "Tx: bad skb len %d\n", skb->len);
 473                 kfree_skb(skb);
 474                 priv->stats.tx_dropped++;
 475                 return 0;
 476         }
 477         if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) {
 478                 dev_dbg(priv->adapter->dev,
 479                         "data: Tx: insufficient skb headroom %d\n",
 480                         skb_headroom(skb));
 481                 /* Insufficient skb headroom - allocate a new skb */
 482                 new_skb =
 483                         skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN);
 484                 if (unlikely(!new_skb)) {
 485                         dev_err(priv->adapter->dev, "Tx: cannot alloca new_skb\n");
 486                         kfree_skb(skb);
 487                         priv->stats.tx_dropped++;
 488                         return 0;
 489                 }
 490                 kfree_skb(skb);
 491                 skb = new_skb;
 492                 dev_dbg(priv->adapter->dev, "info: new skb headroomd %d\n",
 493                         skb_headroom(skb));
 494         }
 495
 496         tx_info = MWIFIEX_SKB_TXCB(skb);
 497         tx_info->bss_num = priv->bss_num;
 498         tx_info->bss_type = priv->bss_type;
 499         mwifiex_fill_buffer(skb);
 500
 501         mwifiex_wmm_add_buf_txqueue(priv, skb);
 502         atomic_inc(&priv->adapter->tx_pending);
 503
 504         if (priv->adapter->scan_delay_cnt)
 505                 atomic_set(&priv->adapter->is_tx_received, true);
 506
 507         if (atomic_read(&priv->adapter->tx_pending) >= MAX_TX_PENDING) {
 508                 mwifiex_set_trans_start(dev);
 509                 mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
 510         }
 511
 512         queue_work(priv->adapter->workqueue, &priv->adapter->main_work);
 513
 514         return 0;
 515 }
 516
 517 /*
 518  * CFG802.11 network device handler for setting MAC address.
 519  */
 520 static int
 521 mwifiex_set_mac_address(struct net_device *dev, void *addr)
 522 {
 523         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 524         struct sockaddr *hw_addr = addr;
 525         int ret;
 526
 527         memcpy(priv->curr_addr, hw_addr->sa_data, ETH_ALEN);
 528
 529         /* Send request to firmware */
 530         ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_MAC_ADDRESS,
 531                                     HostCmd_ACT_GEN_SET, 0, NULL);
 532
 533         if (!ret)
 534                 memcpy(priv->netdev->dev_addr, priv->curr_addr, ETH_ALEN);
 535         else
 536                 dev_err(priv->adapter->dev,
 537                         "set mac address failed: ret=%d\n", ret);
 538
 539         memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
 540
 541         return ret;
 542 }
 543
 544 /*
 545  * CFG802.11 network device handler for setting multicast list.
 546  */
 547 static void mwifiex_set_multicast_list(struct net_device *dev)
 548 {
 549         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 550         struct mwifiex_multicast_list mcast_list;
 551
 552         if (dev->flags & IFF_PROMISC) {
 553                 mcast_list.mode = MWIFIEX_PROMISC_MODE;
 554         } else if (dev->flags & IFF_ALLMULTI ||
 555                    netdev_mc_count(dev) > MWIFIEX_MAX_MULTICAST_LIST_SIZE) {
 556                 mcast_list.mode = MWIFIEX_ALL_MULTI_MODE;
 557         } else {
 558                 mcast_list.mode = MWIFIEX_MULTICAST_MODE;
 559                 if (netdev_mc_count(dev))
 560                         mcast_list.num_multicast_addr =
 561                                 mwifiex_copy_mcast_addr(&mcast_list, dev);
 562         }
 563         mwifiex_request_set_multicast_list(priv, &mcast_list);
 564 }
 565
 566 /*
 567  * CFG802.11 network device handler for transmission timeout.
 568  */
 569 static void
 570 mwifiex_tx_timeout(struct net_device *dev)
 571 {
 572         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 573
 574         dev_err(priv->adapter->dev, "%lu : Tx timeout, bss_type-num = %d-%d\n",
 575                 jiffies, priv->bss_type, priv->bss_num);
 576         mwifiex_set_trans_start(dev);
 577         priv->num_tx_timeout++;
 578 }
 579
 580 /*
 581  * CFG802.11 network device handler for statistics retrieval.
 582  */
 583 static struct net_device_stats *mwifiex_get_stats(struct net_device *dev)
 584 {
 585         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 586
 587         return &priv->stats;
 588 }
 589
 590 /* Network device handlers */
 591 static const struct net_device_ops mwifiex_netdev_ops = {
 592         .ndo_open = mwifiex_open,
 593         .ndo_stop = mwifiex_close,
 594         .ndo_start_xmit = mwifiex_hard_start_xmit,
 595         .ndo_set_mac_address = mwifiex_set_mac_address,
 596         .ndo_tx_timeout = mwifiex_tx_timeout,
 597         .ndo_get_stats = mwifiex_get_stats,
 598         .ndo_set_rx_mode = mwifiex_set_multicast_list,
 599 };
 600
 601 /*
 602  * This function initializes the private structure parameters.
 603  *
 604  * The following wait queues are initialized -
 605  *      - IOCTL wait queue
 606  *      - Command wait queue
 607  *      - Statistics wait queue
 608  *
 609  * ...and the following default parameters are set -
 610  *      - Current key index     : Set to 0
 611  *      - Rate index            : Set to auto
 612  *      - Media connected       : Set to disconnected
 613  *      - Adhoc link sensed     : Set to false
 614  *      - Nick name             : Set to null
 615  *      - Number of Tx timeout  : Set to 0
 616  *      - Device address        : Set to current address
 617  *
 618  * In addition, the CFG80211 work queue is also created.
 619  */
 620 void mwifiex_init_priv_params(struct mwifiex_private *priv,
 621                                                 struct net_device *dev)
 622 {
 623         dev->netdev_ops = &mwifiex_netdev_ops;
 624         /* Initialize private structure */
 625         priv->current_key_index = 0;
 626         priv->media_connected = false;
 627         memset(&priv->nick_name, 0, sizeof(priv->nick_name));
 628         priv->num_tx_timeout = 0;
 629         memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
 630 }
 631
 632 /*
 633  * This function check if command is pending.
 634  */
 635 int is_command_pending(struct mwifiex_adapter *adapter)
 636 {
 637         unsigned long flags;
 638         int is_cmd_pend_q_empty;
 639
 640         spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
 641         is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
 642         spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
 643
 644         return !is_cmd_pend_q_empty;
 645 }
 646
 647 /*
 648  * This is the main work queue function.
 649  *
 650  * It handles the main process, which in turn handles the complete
 651  * driver operations.
 652  */
 653 static void mwifiex_main_work_queue(struct work_struct *work)
 654 {
 655         struct mwifiex_adapter *adapter =
 656                 container_of(work, struct mwifiex_adapter, main_work);
 657
 658         if (adapter->surprise_removed)
 659                 return;
 660         mwifiex_main_process(adapter);
 661 }
 662
 663 /*
 664  * This function cancels all works in the queue and destroys
 665  * the main workqueue.
 666  */
 667 static void
 668 mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
 669 {
 670         flush_workqueue(adapter->workqueue);
 671         destroy_workqueue(adapter->workqueue);
 672         adapter->workqueue = NULL;
 673 }
 674
 675 /*
 676  * This function adds the card.
 677  *
 678  * This function follows the following major steps to set up the device -
 679  *      - Initialize software. This includes probing the card, registering
 680  *        the interface operations table, and allocating/initializing the
 681  *        adapter structure
 682  *      - Set up the netlink socket
 683  *      - Create and start the main work queue
 684  *      - Register the device
 685  *      - Initialize firmware and hardware
 686  *      - Add logical interfaces
 687  */
 688 int
 689 mwifiex_add_card(void *card, struct semaphore *sem,
 690                  struct mwifiex_if_ops *if_ops, u8 iface_type)
 691 {
 692         struct mwifiex_adapter *adapter;
 693
 694         if (down_interruptible(sem))
 695                 goto exit_sem_err;
 696
 697         if (mwifiex_register(card, if_ops, (void **)&adapter)) {
 698                 pr_err("%s: software init failed\n", __func__);
 699                 goto err_init_sw;
 700         }
 701
 702         adapter->iface_type = iface_type;
 703
 704         adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
 705         adapter->surprise_removed = false;
 706         init_waitqueue_head(&adapter->init_wait_q);
 707         adapter->is_suspended = false;
 708         adapter->hs_activated = false;
 709         init_waitqueue_head(&adapter->hs_activate_wait_q);
 710         adapter->cmd_wait_q_required = false;
 711         init_waitqueue_head(&adapter->cmd_wait_q.wait);
 712         adapter->cmd_wait_q.status = 0;
 713         adapter->scan_wait_q_woken = false;
 714
 715         adapter->workqueue = create_workqueue("MWIFIEX_WORK_QUEUE");
 716         if (!adapter->workqueue)
 717                 goto err_kmalloc;
 718
 719         INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
 720
 721         /* Register the device. Fill up the private data structure with relevant
 722            information from the card and request for the required IRQ. */
 723         if (adapter->if_ops.register_dev(adapter)) {
 724                 pr_err("%s: failed to register mwifiex device\n", __func__);
 725                 goto err_registerdev;
 726         }
 727
 728         if (mwifiex_init_hw_fw(adapter)) {
 729                 pr_err("%s: firmware init failed\n", __func__);
 730                 goto err_init_fw;
 731         }
 732
 733         up(sem);
 734         return 0;
 735
 736 err_init_fw:
 737         pr_debug("info: %s: unregister device\n", __func__);
 738         adapter->if_ops.unregister_dev(adapter);
 739 err_registerdev:
 740         adapter->surprise_removed = true;
 741         mwifiex_terminate_workqueue(adapter);
 742 err_kmalloc:
 743         if ((adapter->hw_status == MWIFIEX_HW_STATUS_FW_READY) ||
 744             (adapter->hw_status == MWIFIEX_HW_STATUS_READY)) {
 745                 pr_debug("info: %s: shutdown mwifiex\n", __func__);
 746                 adapter->init_wait_q_woken = false;
 747
 748                 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
 749                         wait_event_interruptible(adapter->init_wait_q,
 750                                                  adapter->init_wait_q_woken);
 751         }
 752
 753         mwifiex_free_adapter(adapter);
 754
 755 err_init_sw:
 756         up(sem);
 757
 758 exit_sem_err:
 759         return -1;
 760 }
 761 EXPORT_SYMBOL_GPL(mwifiex_add_card);
 762
 763 /*
 764  * This function removes the card.
 765  *
 766  * This function follows the following major steps to remove the device -
 767  *      - Stop data traffic
 768  *      - Shutdown firmware
 769  *      - Remove the logical interfaces
 770  *      - Terminate the work queue
 771  *      - Unregister the device
 772  *      - Free the adapter structure
 773  */
 774 int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem)
 775 {
 776         struct mwifiex_private *priv = NULL;
 777         int i;
 778
 779         if (down_interruptible(sem))
 780                 goto exit_sem_err;
 781
 782         if (!adapter)
 783                 goto exit_remove;
 784
 785         adapter->surprise_removed = true;
 786
 787         /* Stop data */
 788         for (i = 0; i < adapter->priv_num; i++) {
 789                 priv = adapter->priv[i];
 790                 if (priv && priv->netdev) {
 791                         if (!netif_queue_stopped(priv->netdev))
 792                                 mwifiex_stop_net_dev_queue(priv->netdev,
 793                                                            adapter);
 794                         if (netif_carrier_ok(priv->netdev))
 795                                 netif_carrier_off(priv->netdev);
 796                 }
 797         }
 798
 799         dev_dbg(adapter->dev, "cmd: calling mwifiex_shutdown_drv...\n");
 800         adapter->init_wait_q_woken = false;
 801
 802         if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
 803                 wait_event_interruptible(adapter->init_wait_q,
 804                                          adapter->init_wait_q_woken);
 805         dev_dbg(adapter->dev, "cmd: mwifiex_shutdown_drv done\n");
 806         if (atomic_read(&adapter->rx_pending) ||
 807             atomic_read(&adapter->tx_pending) ||
 808             atomic_read(&adapter->cmd_pending)) {
 809                 dev_err(adapter->dev, "rx_pending=%d, tx_pending=%d, "
 810                        "cmd_pending=%d\n",
 811                        atomic_read(&adapter->rx_pending),
 812                        atomic_read(&adapter->tx_pending),
 813                        atomic_read(&adapter->cmd_pending));
 814         }
 815
 816         for (i = 0; i < adapter->priv_num; i++) {
 817                 priv = adapter->priv[i];
 818
 819                 if (!priv)
 820                         continue;
 821
 822                 rtnl_lock();
 823                 if (priv->wdev && priv->netdev)
 824                         mwifiex_del_virtual_intf(priv->wdev->wiphy,
 825                                                  priv->netdev);
 826                 rtnl_unlock();
 827         }
 828
 829         priv = adapter->priv[0];
 830         if (!priv)
 831                 goto exit_remove;
 832
 833         if (priv->wdev) {
 834                 wiphy_unregister(priv->wdev->wiphy);
 835                 wiphy_free(priv->wdev->wiphy);
 836                 kfree(priv->wdev);
 837         }
 838
 839         mwifiex_terminate_workqueue(adapter);
 840
 841         /* Unregister device */
 842         dev_dbg(adapter->dev, "info: unregister device\n");
 843         adapter->if_ops.unregister_dev(adapter);
 844         /* Free adapter structure */
 845         dev_dbg(adapter->dev, "info: free adapter\n");
 846         mwifiex_free_adapter(adapter);
 847
 848 exit_remove:
 849         up(sem);
 850 exit_sem_err:
 851         return 0;
 852 }
 853 EXPORT_SYMBOL_GPL(mwifiex_remove_card);
 854
 855 /*
 856  * This function initializes the module.
 857  *
 858  * The debug FS is also initialized if configured.
 859  */
 860 static int
 861 mwifiex_init_module(void)
 862 {
 863 #ifdef CONFIG_DEBUG_FS
 864         mwifiex_debugfs_init();
 865 #endif
 866         return 0;
 867 }
 868
 869 /*
 870  * This function cleans up the module.
 871  *
 872  * The debug FS is removed if available.
 873  */
 874 static void
 875 mwifiex_cleanup_module(void)
 876 {
 877 #ifdef CONFIG_DEBUG_FS
 878         mwifiex_debugfs_remove();
 879 #endif
 880 }
 881
 882 module_init(mwifiex_init_module);
 883 module_exit(mwifiex_cleanup_module);
 884
 885 MODULE_AUTHOR("Marvell International Ltd.");
 886 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION);
 887 MODULE_VERSION(VERSION);
 888 MODULE_LICENSE("GPL v2");