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[MWIFIEX_BSS_ROLE_STA];
 353         if (mwifiex_register_cfg80211(adapter)) {
 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(adapter->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
 366         /* Create AP interface by default */
 367         if (!mwifiex_add_virtual_intf(adapter->wiphy, "uap%d",
 368                                       NL80211_IFTYPE_AP, NULL, NULL)) {
 369                 dev_err(adapter->dev, "cannot create default AP interface\n");
 370                 goto err_add_intf;
 371         }
 372         rtnl_unlock();
 373
 374         mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
 375         dev_notice(adapter->dev, "driver_version = %s\n", fmt);
 376         goto done;
 377
 378 err_add_intf:
 379         mwifiex_del_virtual_intf(adapter->wiphy, priv->netdev);
 380         rtnl_unlock();
 381 err_init_fw:
 382         pr_debug("info: %s: unregister device\n", __func__);
 383         adapter->if_ops.unregister_dev(adapter);
 384 done:
 385         release_firmware(adapter->firmware);
 386         complete(&adapter->fw_load);
 387         return;
 388 }
 389
 390 /*
 391  * This function initializes the hardware and gets firmware.
 392  */
 393 static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter)
 394 {
 395         int ret;
 396
 397         init_completion(&adapter->fw_load);
 398         ret = request_firmware_nowait(THIS_MODULE, 1, adapter->fw_name,
 399                                       adapter->dev, GFP_KERNEL, adapter,
 400                                       mwifiex_fw_dpc);
 401         if (ret < 0)
 402                 dev_err(adapter->dev,
 403                         "request_firmware_nowait() returned error %d\n", ret);
 404         return ret;
 405 }
 406
 407 /*
 408  * This function fills a driver buffer.
 409  *
 410  * The function associates a given SKB with the provided driver buffer
 411  * and also updates some of the SKB parameters, including IP header,
 412  * priority and timestamp.
 413  */
 414 static void
 415 mwifiex_fill_buffer(struct sk_buff *skb)
 416 {
 417         struct ethhdr *eth;
 418         struct iphdr *iph;
 419         struct timeval tv;
 420         u8 tid = 0;
 421
 422         eth = (struct ethhdr *) skb->data;
 423         switch (eth->h_proto) {
 424         case __constant_htons(ETH_P_IP):
 425                 iph = ip_hdr(skb);
 426                 tid = IPTOS_PREC(iph->tos);
 427                 pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n",
 428                          eth->h_proto, tid, skb->priority);
 429                 break;
 430         case __constant_htons(ETH_P_ARP):
 431                 pr_debug("data: ARP packet: %04x\n", eth->h_proto);
 432         default:
 433                 break;
 434         }
 435 /* Offset for TOS field in the IP header */
 436 #define IPTOS_OFFSET 5
 437         tid = (tid >> IPTOS_OFFSET);
 438         skb->priority = tid;
 439         /* Record the current time the packet was queued; used to
 440            determine the amount of time the packet was queued in
 441            the driver before it was sent to the firmware.
 442            The delay is then sent along with the packet to the
 443            firmware for aggregate delay calculation for stats and
 444            MSDU lifetime expiry.
 445          */
 446         do_gettimeofday(&tv);
 447         skb->tstamp = timeval_to_ktime(tv);
 448 }
 449
 450 /*
 451  * CFG802.11 network device handler for open.
 452  *
 453  * Starts the data queue.
 454  */
 455 static int
 456 mwifiex_open(struct net_device *dev)
 457 {
 458         netif_tx_start_all_queues(dev);
 459         return 0;
 460 }
 461
 462 /*
 463  * CFG802.11 network device handler for close.
 464  */
 465 static int
 466 mwifiex_close(struct net_device *dev)
 467 {
 468         return 0;
 469 }
 470
 471 /*
 472  * CFG802.11 network device handler for data transmission.
 473  */
 474 static int
 475 mwifiex_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 476 {
 477         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 478         struct sk_buff *new_skb;
 479         struct mwifiex_txinfo *tx_info;
 480
 481         dev_dbg(priv->adapter->dev, "data: %lu BSS(%d-%d): Data <= kernel\n",
 482                 jiffies, priv->bss_type, priv->bss_num);
 483
 484         if (priv->adapter->surprise_removed) {
 485                 kfree_skb(skb);
 486                 priv->stats.tx_dropped++;
 487                 return 0;
 488         }
 489         if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
 490                 dev_err(priv->adapter->dev, "Tx: bad skb len %d\n", skb->len);
 491                 kfree_skb(skb);
 492                 priv->stats.tx_dropped++;
 493                 return 0;
 494         }
 495         if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) {
 496                 dev_dbg(priv->adapter->dev,
 497                         "data: Tx: insufficient skb headroom %d\n",
 498                         skb_headroom(skb));
 499                 /* Insufficient skb headroom - allocate a new skb */
 500                 new_skb =
 501                         skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN);
 502                 if (unlikely(!new_skb)) {
 503                         dev_err(priv->adapter->dev, "Tx: cannot alloca new_skb\n");
 504                         kfree_skb(skb);
 505                         priv->stats.tx_dropped++;
 506                         return 0;
 507                 }
 508                 kfree_skb(skb);
 509                 skb = new_skb;
 510                 dev_dbg(priv->adapter->dev, "info: new skb headroomd %d\n",
 511                         skb_headroom(skb));
 512         }
 513
 514         tx_info = MWIFIEX_SKB_TXCB(skb);
 515         tx_info->bss_num = priv->bss_num;
 516         tx_info->bss_type = priv->bss_type;
 517         mwifiex_fill_buffer(skb);
 518
 519         mwifiex_wmm_add_buf_txqueue(priv, skb);
 520         atomic_inc(&priv->adapter->tx_pending);
 521
 522         if (atomic_read(&priv->adapter->tx_pending) >= MAX_TX_PENDING) {
 523                 mwifiex_set_trans_start(dev);
 524                 mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
 525         }
 526
 527         queue_work(priv->adapter->workqueue, &priv->adapter->main_work);
 528
 529         return 0;
 530 }
 531
 532 /*
 533  * CFG802.11 network device handler for setting MAC address.
 534  */
 535 static int
 536 mwifiex_set_mac_address(struct net_device *dev, void *addr)
 537 {
 538         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 539         struct sockaddr *hw_addr = addr;
 540         int ret;
 541
 542         memcpy(priv->curr_addr, hw_addr->sa_data, ETH_ALEN);
 543
 544         /* Send request to firmware */
 545         ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_MAC_ADDRESS,
 546                                     HostCmd_ACT_GEN_SET, 0, NULL);
 547
 548         if (!ret)
 549                 memcpy(priv->netdev->dev_addr, priv->curr_addr, ETH_ALEN);
 550         else
 551                 dev_err(priv->adapter->dev,
 552                         "set mac address failed: ret=%d\n", ret);
 553
 554         memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
 555
 556         return ret;
 557 }
 558
 559 /*
 560  * CFG802.11 network device handler for setting multicast list.
 561  */
 562 static void mwifiex_set_multicast_list(struct net_device *dev)
 563 {
 564         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 565         struct mwifiex_multicast_list mcast_list;
 566
 567         if (dev->flags & IFF_PROMISC) {
 568                 mcast_list.mode = MWIFIEX_PROMISC_MODE;
 569         } else if (dev->flags & IFF_ALLMULTI ||
 570                    netdev_mc_count(dev) > MWIFIEX_MAX_MULTICAST_LIST_SIZE) {
 571                 mcast_list.mode = MWIFIEX_ALL_MULTI_MODE;
 572         } else {
 573                 mcast_list.mode = MWIFIEX_MULTICAST_MODE;
 574                 if (netdev_mc_count(dev))
 575                         mcast_list.num_multicast_addr =
 576                                 mwifiex_copy_mcast_addr(&mcast_list, dev);
 577         }
 578         mwifiex_request_set_multicast_list(priv, &mcast_list);
 579 }
 580
 581 /*
 582  * CFG802.11 network device handler for transmission timeout.
 583  */
 584 static void
 585 mwifiex_tx_timeout(struct net_device *dev)
 586 {
 587         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 588
 589         dev_err(priv->adapter->dev, "%lu : Tx timeout, bss_type-num = %d-%d\n",
 590                 jiffies, priv->bss_type, priv->bss_num);
 591         mwifiex_set_trans_start(dev);
 592         priv->num_tx_timeout++;
 593 }
 594
 595 /*
 596  * CFG802.11 network device handler for statistics retrieval.
 597  */
 598 static struct net_device_stats *mwifiex_get_stats(struct net_device *dev)
 599 {
 600         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 601
 602         return &priv->stats;
 603 }
 604
 605 /* Network device handlers */
 606 static const struct net_device_ops mwifiex_netdev_ops = {
 607         .ndo_open = mwifiex_open,
 608         .ndo_stop = mwifiex_close,
 609         .ndo_start_xmit = mwifiex_hard_start_xmit,
 610         .ndo_set_mac_address = mwifiex_set_mac_address,
 611         .ndo_tx_timeout = mwifiex_tx_timeout,
 612         .ndo_get_stats = mwifiex_get_stats,
 613         .ndo_set_rx_mode = mwifiex_set_multicast_list,
 614 };
 615
 616 /*
 617  * This function initializes the private structure parameters.
 618  *
 619  * The following wait queues are initialized -
 620  *      - IOCTL wait queue
 621  *      - Command wait queue
 622  *      - Statistics wait queue
 623  *
 624  * ...and the following default parameters are set -
 625  *      - Current key index     : Set to 0
 626  *      - Rate index            : Set to auto
 627  *      - Media connected       : Set to disconnected
 628  *      - Adhoc link sensed     : Set to false
 629  *      - Nick name             : Set to null
 630  *      - Number of Tx timeout  : Set to 0
 631  *      - Device address        : Set to current address
 632  *
 633  * In addition, the CFG80211 work queue is also created.
 634  */
 635 void mwifiex_init_priv_params(struct mwifiex_private *priv,
 636                                                 struct net_device *dev)
 637 {
 638         dev->netdev_ops = &mwifiex_netdev_ops;
 639         /* Initialize private structure */
 640         priv->current_key_index = 0;
 641         priv->media_connected = false;
 642         memset(&priv->nick_name, 0, sizeof(priv->nick_name));
 643         memset(priv->mgmt_ie, 0,
 644                sizeof(struct mwifiex_ie) * MAX_MGMT_IE_INDEX);
 645         priv->num_tx_timeout = 0;
 646         memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
 647 }
 648
 649 /*
 650  * This function check if command is pending.
 651  */
 652 int is_command_pending(struct mwifiex_adapter *adapter)
 653 {
 654         unsigned long flags;
 655         int is_cmd_pend_q_empty;
 656
 657         spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
 658         is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
 659         spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
 660
 661         return !is_cmd_pend_q_empty;
 662 }
 663
 664 /*
 665  * This is the main work queue function.
 666  *
 667  * It handles the main process, which in turn handles the complete
 668  * driver operations.
 669  */
 670 static void mwifiex_main_work_queue(struct work_struct *work)
 671 {
 672         struct mwifiex_adapter *adapter =
 673                 container_of(work, struct mwifiex_adapter, main_work);
 674
 675         if (adapter->surprise_removed)
 676                 return;
 677         mwifiex_main_process(adapter);
 678 }
 679
 680 /*
 681  * This function cancels all works in the queue and destroys
 682  * the main workqueue.
 683  */
 684 static void
 685 mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
 686 {
 687         flush_workqueue(adapter->workqueue);
 688         destroy_workqueue(adapter->workqueue);
 689         adapter->workqueue = NULL;
 690 }
 691
 692 /*
 693  * This function adds the card.
 694  *
 695  * This function follows the following major steps to set up the device -
 696  *      - Initialize software. This includes probing the card, registering
 697  *        the interface operations table, and allocating/initializing the
 698  *        adapter structure
 699  *      - Set up the netlink socket
 700  *      - Create and start the main work queue
 701  *      - Register the device
 702  *      - Initialize firmware and hardware
 703  *      - Add logical interfaces
 704  */
 705 int
 706 mwifiex_add_card(void *card, struct semaphore *sem,
 707                  struct mwifiex_if_ops *if_ops, u8 iface_type)
 708 {
 709         struct mwifiex_adapter *adapter;
 710
 711         if (down_interruptible(sem))
 712                 goto exit_sem_err;
 713
 714         if (mwifiex_register(card, if_ops, (void **)&adapter)) {
 715                 pr_err("%s: software init failed\n", __func__);
 716                 goto err_init_sw;
 717         }
 718
 719         adapter->iface_type = iface_type;
 720
 721         adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
 722         adapter->surprise_removed = false;
 723         init_waitqueue_head(&adapter->init_wait_q);
 724         adapter->is_suspended = false;
 725         adapter->hs_activated = false;
 726         init_waitqueue_head(&adapter->hs_activate_wait_q);
 727         adapter->cmd_wait_q_required = false;
 728         init_waitqueue_head(&adapter->cmd_wait_q.wait);
 729         adapter->cmd_wait_q.status = 0;
 730         adapter->scan_wait_q_woken = false;
 731
 732         adapter->workqueue = create_workqueue("MWIFIEX_WORK_QUEUE");
 733         if (!adapter->workqueue)
 734                 goto err_kmalloc;
 735
 736         INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
 737
 738         /* Register the device. Fill up the private data structure with relevant
 739            information from the card and request for the required IRQ. */
 740         if (adapter->if_ops.register_dev(adapter)) {
 741                 pr_err("%s: failed to register mwifiex device\n", __func__);
 742                 goto err_registerdev;
 743         }
 744
 745         if (mwifiex_init_hw_fw(adapter)) {
 746                 pr_err("%s: firmware init failed\n", __func__);
 747                 goto err_init_fw;
 748         }
 749
 750         up(sem);
 751         return 0;
 752
 753 err_init_fw:
 754         pr_debug("info: %s: unregister device\n", __func__);
 755         if (adapter->if_ops.unregister_dev)
 756                 adapter->if_ops.unregister_dev(adapter);
 757 err_registerdev:
 758         adapter->surprise_removed = true;
 759         mwifiex_terminate_workqueue(adapter);
 760 err_kmalloc:
 761         if ((adapter->hw_status == MWIFIEX_HW_STATUS_FW_READY) ||
 762             (adapter->hw_status == MWIFIEX_HW_STATUS_READY)) {
 763                 pr_debug("info: %s: shutdown mwifiex\n", __func__);
 764                 adapter->init_wait_q_woken = false;
 765
 766                 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
 767                         wait_event_interruptible(adapter->init_wait_q,
 768                                                  adapter->init_wait_q_woken);
 769         }
 770
 771         mwifiex_free_adapter(adapter);
 772
 773 err_init_sw:
 774         up(sem);
 775
 776 exit_sem_err:
 777         return -1;
 778 }
 779 EXPORT_SYMBOL_GPL(mwifiex_add_card);
 780
 781 /*
 782  * This function removes the card.
 783  *
 784  * This function follows the following major steps to remove the device -
 785  *      - Stop data traffic
 786  *      - Shutdown firmware
 787  *      - Remove the logical interfaces
 788  *      - Terminate the work queue
 789  *      - Unregister the device
 790  *      - Free the adapter structure
 791  */
 792 int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem)
 793 {
 794         struct mwifiex_private *priv = NULL;
 795         int i;
 796
 797         if (down_interruptible(sem))
 798                 goto exit_sem_err;
 799
 800         if (!adapter)
 801                 goto exit_remove;
 802
 803         adapter->surprise_removed = true;
 804
 805         /* Stop data */
 806         for (i = 0; i < adapter->priv_num; i++) {
 807                 priv = adapter->priv[i];
 808                 if (priv && priv->netdev) {
 809                         if (!netif_queue_stopped(priv->netdev))
 810                                 mwifiex_stop_net_dev_queue(priv->netdev,
 811                                                            adapter);
 812                         if (netif_carrier_ok(priv->netdev))
 813                                 netif_carrier_off(priv->netdev);
 814                 }
 815         }
 816
 817         dev_dbg(adapter->dev, "cmd: calling mwifiex_shutdown_drv...\n");
 818         adapter->init_wait_q_woken = false;
 819
 820         if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
 821                 wait_event_interruptible(adapter->init_wait_q,
 822                                          adapter->init_wait_q_woken);
 823         dev_dbg(adapter->dev, "cmd: mwifiex_shutdown_drv done\n");
 824         if (atomic_read(&adapter->rx_pending) ||
 825             atomic_read(&adapter->tx_pending) ||
 826             atomic_read(&adapter->cmd_pending)) {
 827                 dev_err(adapter->dev, "rx_pending=%d, tx_pending=%d, "
 828                        "cmd_pending=%d\n",
 829                        atomic_read(&adapter->rx_pending),
 830                        atomic_read(&adapter->tx_pending),
 831                        atomic_read(&adapter->cmd_pending));
 832         }
 833
 834         for (i = 0; i < adapter->priv_num; i++) {
 835                 priv = adapter->priv[i];
 836
 837                 if (!priv)
 838                         continue;
 839
 840                 rtnl_lock();
 841                 if (priv->wdev && priv->netdev)
 842                         mwifiex_del_virtual_intf(adapter->wiphy, priv->netdev);
 843                 rtnl_unlock();
 844         }
 845
 846         priv = adapter->priv[0];
 847         if (!priv || !priv->wdev)
 848                 goto exit_remove;
 849
 850         wiphy_unregister(priv->wdev->wiphy);
 851         wiphy_free(priv->wdev->wiphy);
 852
 853         for (i = 0; i < adapter->priv_num; i++) {
 854                 priv = adapter->priv[i];
 855                 if (priv)
 856                         kfree(priv->wdev);
 857         }
 858
 859         mwifiex_terminate_workqueue(adapter);
 860
 861         /* Unregister device */
 862         dev_dbg(adapter->dev, "info: unregister device\n");
 863         if (adapter->if_ops.unregister_dev)
 864                 adapter->if_ops.unregister_dev(adapter);
 865         /* Free adapter structure */
 866         dev_dbg(adapter->dev, "info: free adapter\n");
 867         mwifiex_free_adapter(adapter);
 868
 869 exit_remove:
 870         up(sem);
 871 exit_sem_err:
 872         return 0;
 873 }
 874 EXPORT_SYMBOL_GPL(mwifiex_remove_card);
 875
 876 /*
 877  * This function initializes the module.
 878  *
 879  * The debug FS is also initialized if configured.
 880  */
 881 static int
 882 mwifiex_init_module(void)
 883 {
 884 #ifdef CONFIG_DEBUG_FS
 885         mwifiex_debugfs_init();
 886 #endif
 887         return 0;
 888 }
 889
 890 /*
 891  * This function cleans up the module.
 892  *
 893  * The debug FS is removed if available.
 894  */
 895 static void
 896 mwifiex_cleanup_module(void)
 897 {
 898 #ifdef CONFIG_DEBUG_FS
 899         mwifiex_debugfs_remove();
 900 #endif
 901 }
 902
 903 module_init(mwifiex_init_module);
 904 module_exit(mwifiex_cleanup_module);
 905
 906 MODULE_AUTHOR("Marvell International Ltd.");
 907 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION);
 908 MODULE_VERSION(VERSION);
 909 MODULE_LICENSE("GPL v2");