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