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),
  68                         GFP_KERNEL);
  69         if (!adapter->priv[0]) {
  70                 dev_err(adapter->dev, "%s: failed to alloc priv[0]\n",
  71                        __func__);
  72                 goto error;
  73         }
  74
  75         adapter->priv_num++;
  76
  77         adapter->priv[0]->adapter = adapter;
  78         mwifiex_init_lock_list(adapter);
  79
  80         init_timer(&adapter->cmd_timer);
  81         adapter->cmd_timer.function = mwifiex_cmd_timeout_func;
  82         adapter->cmd_timer.data = (unsigned long) adapter;
  83
  84         return 0;
  85
  86 error:
  87         dev_dbg(adapter->dev, "info: leave mwifiex_register with error\n");
  88
  89         for (i = 0; i < adapter->priv_num; i++)
  90                 kfree(adapter->priv[i]);
  91
  92         kfree(adapter);
  93
  94         return -1;
  95 }
  96
  97 /*
  98  * This function unregisters the device and performs all the necessary
  99  * cleanups.
 100  *
 101  * The following cleanup operations are performed -
 102  *      - Free the timers
 103  *      - Free beacon buffers
 104  *      - Free private structures
 105  *      - Free adapter structure
 106  */
 107 static int mwifiex_unregister(struct mwifiex_adapter *adapter)
 108 {
 109         s32 i;
 110
 111         del_timer(&adapter->cmd_timer);
 112
 113         /* Free private structures */
 114         for (i = 0; i < adapter->priv_num; i++) {
 115                 if (adapter->priv[i]) {
 116                         mwifiex_free_curr_bcn(adapter->priv[i]);
 117                         kfree(adapter->priv[i]);
 118                 }
 119         }
 120
 121         kfree(adapter);
 122         return 0;
 123 }
 124
 125 /*
 126  * The main process.
 127  *
 128  * This function is the main procedure of the driver and handles various driver
 129  * operations. It runs in a loop and provides the core functionalities.
 130  *
 131  * The main responsibilities of this function are -
 132  *      - Ensure concurrency control
 133  *      - Handle pending interrupts and call interrupt handlers
 134  *      - Wake up the card if required
 135  *      - Handle command responses and call response handlers
 136  *      - Handle events and call event handlers
 137  *      - Execute pending commands
 138  *      - Transmit pending data packets
 139  */
 140 int mwifiex_main_process(struct mwifiex_adapter *adapter)
 141 {
 142         int ret = 0;
 143         unsigned long flags;
 144
 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                         adapter->if_ops.process_int_status(adapter);
 166                 }
 167
 168                 /* Need to wake up the card ? */
 169                 if ((adapter->ps_state == PS_STATE_SLEEP) &&
 170                     (adapter->pm_wakeup_card_req &&
 171                      !adapter->pm_wakeup_fw_try) &&
 172                     (is_command_pending(adapter)
 173                      || !mwifiex_wmm_lists_empty(adapter))) {
 174                         adapter->pm_wakeup_fw_try = true;
 175                         adapter->if_ops.wakeup(adapter);
 176                         continue;
 177                 }
 178                 if (IS_CARD_RX_RCVD(adapter)) {
 179                         adapter->pm_wakeup_fw_try = false;
 180                         if (adapter->ps_state == PS_STATE_SLEEP)
 181                                 adapter->ps_state = PS_STATE_AWAKE;
 182                 } else {
 183                         /* We have tried to wakeup the card already */
 184                         if (adapter->pm_wakeup_fw_try)
 185                                 break;
 186                         if (adapter->ps_state != PS_STATE_AWAKE ||
 187                             adapter->tx_lock_flag)
 188                                 break;
 189
 190                         if (adapter->scan_processing || adapter->data_sent
 191                             || mwifiex_wmm_lists_empty(adapter)) {
 192                                 if (adapter->cmd_sent || adapter->curr_cmd
 193                                     || (!is_command_pending(adapter)))
 194                                         break;
 195                         }
 196                 }
 197
 198                 /* Check for Cmd Resp */
 199                 if (adapter->cmd_resp_received) {
 200                         adapter->cmd_resp_received = false;
 201                         mwifiex_process_cmdresp(adapter);
 202
 203                         /* call mwifiex back when init_fw is done */
 204                         if (adapter->hw_status == MWIFIEX_HW_STATUS_INIT_DONE) {
 205                                 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
 206                                 mwifiex_init_fw_complete(adapter);
 207                         }
 208                 }
 209
 210                 /* Check for event */
 211                 if (adapter->event_received) {
 212                         adapter->event_received = false;
 213                         mwifiex_process_event(adapter);
 214                 }
 215
 216                 /* Check if we need to confirm Sleep Request
 217                    received previously */
 218                 if (adapter->ps_state == PS_STATE_PRE_SLEEP) {
 219                         if (!adapter->cmd_sent && !adapter->curr_cmd)
 220                                 mwifiex_check_ps_cond(adapter);
 221                 }
 222
 223                 /* * The ps_state may have been changed during processing of
 224                  * Sleep Request event.
 225                  */
 226                 if ((adapter->ps_state == PS_STATE_SLEEP)
 227                     || (adapter->ps_state == PS_STATE_PRE_SLEEP)
 228                     || (adapter->ps_state == PS_STATE_SLEEP_CFM)
 229                     || adapter->tx_lock_flag)
 230                         continue;
 231
 232                 if (!adapter->cmd_sent && !adapter->curr_cmd) {
 233                         if (mwifiex_exec_next_cmd(adapter) == -1) {
 234                                 ret = -1;
 235                                 break;
 236                         }
 237                 }
 238
 239                 if (!adapter->scan_processing && !adapter->data_sent &&
 240                     !mwifiex_wmm_lists_empty(adapter)) {
 241                         mwifiex_wmm_process_tx(adapter);
 242                         if (adapter->hs_activated) {
 243                                 adapter->is_hs_configured = false;
 244                                 mwifiex_hs_activated_event
 245                                         (mwifiex_get_priv
 246                                          (adapter, MWIFIEX_BSS_ROLE_ANY),
 247                                          false);
 248                         }
 249                 }
 250
 251                 if (adapter->delay_null_pkt && !adapter->cmd_sent &&
 252                     !adapter->curr_cmd && !is_command_pending(adapter)
 253                     && mwifiex_wmm_lists_empty(adapter)) {
 254                         if (!mwifiex_send_null_packet
 255                             (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
 256                              MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET |
 257                              MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET)) {
 258                                 adapter->delay_null_pkt = false;
 259                                 adapter->ps_state = PS_STATE_SLEEP;
 260                         }
 261                         break;
 262                 }
 263         } while (true);
 264
 265         if ((adapter->int_status) || IS_CARD_RX_RCVD(adapter))
 266                 goto process_start;
 267
 268         spin_lock_irqsave(&adapter->main_proc_lock, flags);
 269         adapter->mwifiex_processing = false;
 270         spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
 271
 272 exit_main_proc:
 273         if (adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING)
 274                 mwifiex_shutdown_drv(adapter);
 275         return ret;
 276 }
 277
 278 /*
 279  * This function frees the adapter structure.
 280  *
 281  * Additionally, this closes the netlink socket, frees the timers
 282  * and private structures.
 283  */
 284 static void mwifiex_free_adapter(struct mwifiex_adapter *adapter)
 285 {
 286         if (!adapter) {
 287                 pr_err("%s: adapter is NULL\n", __func__);
 288                 return;
 289         }
 290
 291         mwifiex_unregister(adapter);
 292         pr_debug("info: %s: free adapter\n", __func__);
 293 }
 294
 295 /*
 296  * This function initializes the hardware and firmware.
 297  *
 298  * The main initialization steps followed are -
 299  *      - Download the correct firmware to card
 300  *      - Allocate and initialize the adapter structure
 301  *      - Initialize the private structures
 302  *      - Issue the init commands to firmware
 303  */
 304 static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter)
 305 {
 306         int ret, err;
 307         struct mwifiex_fw_image fw;
 308
 309         memset(&fw, 0, sizeof(struct mwifiex_fw_image));
 310
 311         err = request_firmware(&adapter->firmware, adapter->fw_name,
 312                                adapter->dev);
 313         if (err < 0) {
 314                 dev_err(adapter->dev, "request_firmware() returned"
 315                                 " error code %#x\n", err);
 316                 ret = -1;
 317                 goto done;
 318         }
 319         fw.fw_buf = (u8 *) adapter->firmware->data;
 320         fw.fw_len = adapter->firmware->size;
 321
 322         ret = mwifiex_dnld_fw(adapter, &fw);
 323         if (ret == -1)
 324                 goto done;
 325
 326         dev_notice(adapter->dev, "WLAN FW is active\n");
 327
 328         adapter->init_wait_q_woken = false;
 329         ret = mwifiex_init_fw(adapter);
 330         if (ret == -1) {
 331                 goto done;
 332         } else if (!ret) {
 333                 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
 334                 goto done;
 335         }
 336         /* Wait for mwifiex_init to complete */
 337         wait_event_interruptible(adapter->init_wait_q,
 338                                  adapter->init_wait_q_woken);
 339         if (adapter->hw_status != MWIFIEX_HW_STATUS_READY) {
 340                 ret = -1;
 341                 goto done;
 342         }
 343         ret = 0;
 344
 345 done:
 346         if (adapter->firmware)
 347                 release_firmware(adapter->firmware);
 348         if (ret)
 349                 ret = -1;
 350         return ret;
 351 }
 352
 353 /*
 354  * This function fills a driver buffer.
 355  *
 356  * The function associates a given SKB with the provided driver buffer
 357  * and also updates some of the SKB parameters, including IP header,
 358  * priority and timestamp.
 359  */
 360 static void
 361 mwifiex_fill_buffer(struct sk_buff *skb)
 362 {
 363         struct ethhdr *eth;
 364         struct iphdr *iph;
 365         struct timeval tv;
 366         u8 tid = 0;
 367
 368         eth = (struct ethhdr *) skb->data;
 369         switch (eth->h_proto) {
 370         case __constant_htons(ETH_P_IP):
 371                 iph = ip_hdr(skb);
 372                 tid = IPTOS_PREC(iph->tos);
 373                 pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n",
 374                        eth->h_proto, tid, skb->priority);
 375                 break;
 376         case __constant_htons(ETH_P_ARP):
 377                 pr_debug("data: ARP packet: %04x\n", eth->h_proto);
 378         default:
 379                 break;
 380         }
 381 /* Offset for TOS field in the IP header */
 382 #define IPTOS_OFFSET 5
 383         tid = (tid >> IPTOS_OFFSET);
 384         skb->priority = tid;
 385         /* Record the current time the packet was queued; used to
 386            determine the amount of time the packet was queued in
 387            the driver before it was sent to the firmware.
 388            The delay is then sent along with the packet to the
 389            firmware for aggregate delay calculation for stats and
 390            MSDU lifetime expiry.
 391          */
 392         do_gettimeofday(&tv);
 393         skb->tstamp = timeval_to_ktime(tv);
 394 }
 395
 396 /*
 397  * CFG802.11 network device handler for open.
 398  *
 399  * Starts the data queue.
 400  */
 401 static int
 402 mwifiex_open(struct net_device *dev)
 403 {
 404         netif_tx_start_all_queues(dev);
 405         return 0;
 406 }
 407
 408 /*
 409  * CFG802.11 network device handler for close.
 410  */
 411 static int
 412 mwifiex_close(struct net_device *dev)
 413 {
 414         return 0;
 415 }
 416
 417 /*
 418  * CFG802.11 network device handler for data transmission.
 419  */
 420 static int
 421 mwifiex_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 422 {
 423         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
 424         struct sk_buff *new_skb;
 425         struct mwifiex_txinfo *tx_info;
 426
 427         dev_dbg(priv->adapter->dev, "data: %lu BSS(%d): Data <= kernel\n",
 428                                 jiffies, priv->bss_index);
 429
 430         if (priv->adapter->surprise_removed) {
 431                 kfree_skb(skb);
 432                 priv->stats.tx_dropped++;
 433                 return 0;
 434         }
 435         if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
 436                 dev_err(priv->adapter->dev, "Tx: bad skb len %d\n", skb->len);
 437                 kfree_skb(skb);
 438                 priv->stats.tx_dropped++;
 439                 return 0;
 440         }
 441         if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) {
 442                 dev_dbg(priv->adapter->dev,
 443                         "data: Tx: insufficient skb headroom %d\n",
 444                        skb_headroom(skb));
 445                 /* Insufficient skb headroom - allocate a new skb */
 446                 new_skb =
 447                         skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN);
 448                 if (unlikely(!new_skb)) {
 449                         dev_err(priv->adapter->dev, "Tx: cannot alloca new_skb\n");
 450                         kfree_skb(skb);
 451                         priv->stats.tx_dropped++;
 452                         return 0;
 453                 }
 454                 kfree_skb(skb);
 455                 skb = new_skb;
 456                 dev_dbg(priv->adapter->dev, "info: new skb headroomd %d\n",
 457                                 skb_headroom(skb));
 458         }
 459
 460         tx_info = MWIFIEX_SKB_TXCB(skb);
 461         tx_info->bss_index = priv->bss_index;
 462         mwifiex_fill_buffer(skb);
 463
 464         mwifiex_wmm_add_buf_txqueue(priv->adapter, 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, "set mac address failed: ret=%d"
 497                                             "\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_index=%d\n",
 535                                 jiffies, priv->bss_index);
 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 function returns the correct private structure pointer based
 609  * upon the BSS number.
 610  */
 611 struct mwifiex_private *
 612 mwifiex_bss_index_to_priv(struct mwifiex_adapter *adapter, u8 bss_index)
 613 {
 614         if (!adapter || (bss_index >= adapter->priv_num))
 615                 return NULL;
 616         return adapter->priv[bss_index];
 617 }
 618
 619 /*
 620  * This is the main work queue function.
 621  *
 622  * It handles the main process, which in turn handles the complete
 623  * driver operations.
 624  */
 625 static void mwifiex_main_work_queue(struct work_struct *work)
 626 {
 627         struct mwifiex_adapter *adapter =
 628                 container_of(work, struct mwifiex_adapter, main_work);
 629
 630         if (adapter->surprise_removed)
 631                 return;
 632         mwifiex_main_process(adapter);
 633 }
 634
 635 /*
 636  * This function cancels all works in the queue and destroys
 637  * the main workqueue.
 638  */
 639 static void
 640 mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
 641 {
 642         flush_workqueue(adapter->workqueue);
 643         destroy_workqueue(adapter->workqueue);
 644         adapter->workqueue = NULL;
 645 }
 646
 647 /*
 648  * This function adds the card.
 649  *
 650  * This function follows the following major steps to set up the device -
 651  *      - Initialize software. This includes probing the card, registering
 652  *        the interface operations table, and allocating/initializing the
 653  *        adapter structure
 654  *      - Set up the netlink socket
 655  *      - Create and start the main work queue
 656  *      - Register the device
 657  *      - Initialize firmware and hardware
 658  *      - Add logical interfaces
 659  */
 660 int
 661 mwifiex_add_card(void *card, struct semaphore *sem,
 662                  struct mwifiex_if_ops *if_ops, u8 iface_type)
 663 {
 664         struct mwifiex_adapter *adapter;
 665         char fmt[64];
 666         struct mwifiex_private *priv;
 667
 668         if (down_interruptible(sem))
 669                 goto exit_sem_err;
 670
 671         if (mwifiex_register(card, if_ops, (void **)&adapter)) {
 672                 pr_err("%s: software init failed\n", __func__);
 673                 goto err_init_sw;
 674         }
 675
 676         adapter->iface_type = iface_type;
 677
 678         adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
 679         adapter->surprise_removed = false;
 680         init_waitqueue_head(&adapter->init_wait_q);
 681         adapter->is_suspended = false;
 682         adapter->hs_activated = false;
 683         init_waitqueue_head(&adapter->hs_activate_wait_q);
 684         adapter->cmd_wait_q_required = false;
 685         init_waitqueue_head(&adapter->cmd_wait_q.wait);
 686         adapter->cmd_wait_q.status = 0;
 687         adapter->scan_wait_q_woken = false;
 688
 689         adapter->workqueue = create_workqueue("MWIFIEX_WORK_QUEUE");
 690         if (!adapter->workqueue)
 691                 goto err_kmalloc;
 692
 693         INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
 694
 695         /* Register the device. Fill up the private data structure with relevant
 696            information from the card and request for the required IRQ. */
 697         if (adapter->if_ops.register_dev(adapter)) {
 698                 pr_err("%s: failed to register mwifiex device\n", __func__);
 699                 goto err_registerdev;
 700         }
 701
 702         if (mwifiex_init_hw_fw(adapter)) {
 703                 pr_err("%s: firmware init failed\n", __func__);
 704                 goto err_init_fw;
 705         }
 706
 707         priv = adapter->priv[0];
 708
 709         if (mwifiex_register_cfg80211(priv) != 0) {
 710                 dev_err(adapter->dev, "cannot register netdevice"
 711                                " with cfg80211\n");
 712                         goto err_init_fw;
 713         }
 714
 715         rtnl_lock();
 716         /* Create station interface by default */
 717         if (!mwifiex_add_virtual_intf(priv->wdev->wiphy, "mlan%d",
 718                                 NL80211_IFTYPE_STATION, NULL, NULL)) {
 719                 rtnl_unlock();
 720                 dev_err(adapter->dev, "cannot create default station"
 721                                 " interface\n");
 722                 goto err_add_intf;
 723         }
 724
 725         rtnl_unlock();
 726
 727         up(sem);
 728
 729         mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
 730         dev_notice(adapter->dev, "driver_version = %s\n", fmt);
 731
 732         return 0;
 733
 734 err_add_intf:
 735         rtnl_lock();
 736         mwifiex_del_virtual_intf(priv->wdev->wiphy, priv->netdev);
 737         rtnl_unlock();
 738 err_init_fw:
 739         pr_debug("info: %s: unregister device\n", __func__);
 740         adapter->if_ops.unregister_dev(adapter);
 741 err_registerdev:
 742         adapter->surprise_removed = true;
 743         mwifiex_terminate_workqueue(adapter);
 744 err_kmalloc:
 745         if ((adapter->hw_status == MWIFIEX_HW_STATUS_FW_READY) ||
 746             (adapter->hw_status == MWIFIEX_HW_STATUS_READY)) {
 747                 pr_debug("info: %s: shutdown mwifiex\n", __func__);
 748                 adapter->init_wait_q_woken = false;
 749
 750                 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
 751                         wait_event_interruptible(adapter->init_wait_q,
 752                                                  adapter->init_wait_q_woken);
 753         }
 754
 755         mwifiex_free_adapter(adapter);
 756
 757 err_init_sw:
 758         up(sem);
 759
 760 exit_sem_err:
 761         return -1;
 762 }
 763 EXPORT_SYMBOL_GPL(mwifiex_add_card);
 764
 765 /*
 766  * This function removes the card.
 767  *
 768  * This function follows the following major steps to remove the device -
 769  *      - Stop data traffic
 770  *      - Shutdown firmware
 771  *      - Remove the logical interfaces
 772  *      - Terminate the work queue
 773  *      - Unregister the device
 774  *      - Free the adapter structure
 775  */
 776 int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem)
 777 {
 778         struct mwifiex_private *priv = NULL;
 779         int i;
 780
 781         if (down_interruptible(sem))
 782                 goto exit_sem_err;
 783
 784         if (!adapter)
 785                 goto exit_remove;
 786
 787         adapter->surprise_removed = true;
 788
 789         /* Stop data */
 790         for (i = 0; i < adapter->priv_num; i++) {
 791                 priv = adapter->priv[i];
 792                 if (priv && priv->netdev) {
 793                         if (!netif_queue_stopped(priv->netdev))
 794                                 mwifiex_stop_net_dev_queue(priv->netdev,
 795                                                                 adapter);
 796                         if (netif_carrier_ok(priv->netdev))
 797                                 netif_carrier_off(priv->netdev);
 798                 }
 799         }
 800
 801         dev_dbg(adapter->dev, "cmd: calling mwifiex_shutdown_drv...\n");
 802         adapter->init_wait_q_woken = false;
 803
 804         if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
 805                 wait_event_interruptible(adapter->init_wait_q,
 806                                          adapter->init_wait_q_woken);
 807         dev_dbg(adapter->dev, "cmd: mwifiex_shutdown_drv done\n");
 808         if (atomic_read(&adapter->rx_pending) ||
 809             atomic_read(&adapter->tx_pending) ||
 810             atomic_read(&adapter->cmd_pending)) {
 811                 dev_err(adapter->dev, "rx_pending=%d, tx_pending=%d, "
 812                        "cmd_pending=%d\n",
 813                        atomic_read(&adapter->rx_pending),
 814                        atomic_read(&adapter->tx_pending),
 815                        atomic_read(&adapter->cmd_pending));
 816         }
 817
 818         for (i = 0; i < adapter->priv_num; i++) {
 819                 priv = adapter->priv[i];
 820
 821                 if (!priv)
 822                         continue;
 823
 824                 rtnl_lock();
 825                 if (priv->wdev && priv->netdev)
 826                         mwifiex_del_virtual_intf(priv->wdev->wiphy,
 827                                                  priv->netdev);
 828                 rtnl_unlock();
 829         }
 830
 831         priv = adapter->priv[0];
 832         if (!priv)
 833                 goto exit_remove;
 834
 835         if (priv->wdev) {
 836                 wiphy_unregister(priv->wdev->wiphy);
 837                 wiphy_free(priv->wdev->wiphy);
 838                 kfree(priv->wdev);
 839         }
 840
 841         mwifiex_terminate_workqueue(adapter);
 842
 843         /* Unregister device */
 844         dev_dbg(adapter->dev, "info: unregister device\n");
 845         adapter->if_ops.unregister_dev(adapter);
 846         /* Free adapter structure */
 847         dev_dbg(adapter->dev, "info: free adapter\n");
 848         mwifiex_free_adapter(adapter);
 849
 850 exit_remove:
 851         up(sem);
 852 exit_sem_err:
 853         return 0;
 854 }
 855 EXPORT_SYMBOL_GPL(mwifiex_remove_card);
 856
 857 /*
 858  * This function initializes the module.
 859  *
 860  * The debug FS is also initialized if configured.
 861  */
 862 static int
 863 mwifiex_init_module(void)
 864 {
 865 #ifdef CONFIG_DEBUG_FS
 866         mwifiex_debugfs_init();
 867 #endif
 868         return 0;
 869 }
 870
 871 /*
 872  * This function cleans up the module.
 873  *
 874  * The debug FS is removed if available.
 875  */
 876 static void
 877 mwifiex_cleanup_module(void)
 878 {
 879 #ifdef CONFIG_DEBUG_FS
 880         mwifiex_debugfs_remove();
 881 #endif
 882 }
 883
 884 module_init(mwifiex_init_module);
 885 module_exit(mwifiex_cleanup_module);
 886
 887 MODULE_AUTHOR("Marvell International Ltd.");
 888 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION);
 889 MODULE_VERSION(VERSION);
 890 MODULE_LICENSE("GPL v2");