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