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