drivers/net/wireless/mwifiex/main.c

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