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