Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless
[linux-2.6.git] / 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-%d): Data <= kernel\n",
428                                 jiffies, priv->bss_type, priv->bss_num);
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_num = priv->bss_num;
462         tx_info->bss_type = priv->bss_type;
463         mwifiex_fill_buffer(skb);
464
465         mwifiex_wmm_add_buf_txqueue(priv, skb);
466         atomic_inc(&priv->adapter->tx_pending);
467
468         if (atomic_read(&priv->adapter->tx_pending) >= MAX_TX_PENDING) {
469                 mwifiex_set_trans_start(dev);
470                 mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
471         }
472
473         queue_work(priv->adapter->workqueue, &priv->adapter->main_work);
474
475         return 0;
476 }
477
478 /*
479  * CFG802.11 network device handler for setting MAC address.
480  */
481 static int
482 mwifiex_set_mac_address(struct net_device *dev, void *addr)
483 {
484         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
485         struct sockaddr *hw_addr = addr;
486         int ret;
487
488         memcpy(priv->curr_addr, hw_addr->sa_data, ETH_ALEN);
489
490         /* Send request to firmware */
491         ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_MAC_ADDRESS,
492                                     HostCmd_ACT_GEN_SET, 0, NULL);
493
494         if (!ret)
495                 memcpy(priv->netdev->dev_addr, priv->curr_addr, ETH_ALEN);
496         else
497                 dev_err(priv->adapter->dev, "set mac address failed: ret=%d"
498                                             "\n", ret);
499
500         memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
501
502         return ret;
503 }
504
505 /*
506  * CFG802.11 network device handler for setting multicast list.
507  */
508 static void mwifiex_set_multicast_list(struct net_device *dev)
509 {
510         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
511         struct mwifiex_multicast_list mcast_list;
512
513         if (dev->flags & IFF_PROMISC) {
514                 mcast_list.mode = MWIFIEX_PROMISC_MODE;
515         } else if (dev->flags & IFF_ALLMULTI ||
516                    netdev_mc_count(dev) > MWIFIEX_MAX_MULTICAST_LIST_SIZE) {
517                 mcast_list.mode = MWIFIEX_ALL_MULTI_MODE;
518         } else {
519                 mcast_list.mode = MWIFIEX_MULTICAST_MODE;
520                 if (netdev_mc_count(dev))
521                         mcast_list.num_multicast_addr =
522                                 mwifiex_copy_mcast_addr(&mcast_list, dev);
523         }
524         mwifiex_request_set_multicast_list(priv, &mcast_list);
525 }
526
527 /*
528  * CFG802.11 network device handler for transmission timeout.
529  */
530 static void
531 mwifiex_tx_timeout(struct net_device *dev)
532 {
533         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
534
535         dev_err(priv->adapter->dev, "%lu : Tx timeout, bss_type-num = %d-%d\n",
536                                 jiffies, priv->bss_type, priv->bss_num);
537         mwifiex_set_trans_start(dev);
538         priv->num_tx_timeout++;
539 }
540
541 /*
542  * CFG802.11 network device handler for statistics retrieval.
543  */
544 static struct net_device_stats *mwifiex_get_stats(struct net_device *dev)
545 {
546         struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
547
548         return &priv->stats;
549 }
550
551 /* Network device handlers */
552 static const struct net_device_ops mwifiex_netdev_ops = {
553         .ndo_open = mwifiex_open,
554         .ndo_stop = mwifiex_close,
555         .ndo_start_xmit = mwifiex_hard_start_xmit,
556         .ndo_set_mac_address = mwifiex_set_mac_address,
557         .ndo_tx_timeout = mwifiex_tx_timeout,
558         .ndo_get_stats = mwifiex_get_stats,
559         .ndo_set_rx_mode = mwifiex_set_multicast_list,
560 };
561
562 /*
563  * This function initializes the private structure parameters.
564  *
565  * The following wait queues are initialized -
566  *      - IOCTL wait queue
567  *      - Command wait queue
568  *      - Statistics wait queue
569  *
570  * ...and the following default parameters are set -
571  *      - Current key index     : Set to 0
572  *      - Rate index            : Set to auto
573  *      - Media connected       : Set to disconnected
574  *      - Adhoc link sensed     : Set to false
575  *      - Nick name             : Set to null
576  *      - Number of Tx timeout  : Set to 0
577  *      - Device address        : Set to current address
578  *
579  * In addition, the CFG80211 work queue is also created.
580  */
581 void mwifiex_init_priv_params(struct mwifiex_private *priv,
582                                                 struct net_device *dev)
583 {
584         dev->netdev_ops = &mwifiex_netdev_ops;
585         /* Initialize private structure */
586         priv->current_key_index = 0;
587         priv->media_connected = false;
588         memset(&priv->nick_name, 0, sizeof(priv->nick_name));
589         priv->num_tx_timeout = 0;
590         memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
591 }
592
593 /*
594  * This function check if command is pending.
595  */
596 int is_command_pending(struct mwifiex_adapter *adapter)
597 {
598         unsigned long flags;
599         int is_cmd_pend_q_empty;
600
601         spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
602         is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
603         spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
604
605         return !is_cmd_pend_q_empty;
606 }
607
608 /*
609  * This is the main work queue function.
610  *
611  * It handles the main process, which in turn handles the complete
612  * driver operations.
613  */
614 static void mwifiex_main_work_queue(struct work_struct *work)
615 {
616         struct mwifiex_adapter *adapter =
617                 container_of(work, struct mwifiex_adapter, main_work);
618
619         if (adapter->surprise_removed)
620                 return;
621         mwifiex_main_process(adapter);
622 }
623
624 /*
625  * This function cancels all works in the queue and destroys
626  * the main workqueue.
627  */
628 static void
629 mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
630 {
631         flush_workqueue(adapter->workqueue);
632         destroy_workqueue(adapter->workqueue);
633         adapter->workqueue = NULL;
634 }
635
636 /*
637  * This function adds the card.
638  *
639  * This function follows the following major steps to set up the device -
640  *      - Initialize software. This includes probing the card, registering
641  *        the interface operations table, and allocating/initializing the
642  *        adapter structure
643  *      - Set up the netlink socket
644  *      - Create and start the main work queue
645  *      - Register the device
646  *      - Initialize firmware and hardware
647  *      - Add logical interfaces
648  */
649 int
650 mwifiex_add_card(void *card, struct semaphore *sem,
651                  struct mwifiex_if_ops *if_ops, u8 iface_type)
652 {
653         struct mwifiex_adapter *adapter;
654         char fmt[64];
655         struct mwifiex_private *priv;
656
657         if (down_interruptible(sem))
658                 goto exit_sem_err;
659
660         if (mwifiex_register(card, if_ops, (void **)&adapter)) {
661                 pr_err("%s: software init failed\n", __func__);
662                 goto err_init_sw;
663         }
664
665         adapter->iface_type = iface_type;
666
667         adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
668         adapter->surprise_removed = false;
669         init_waitqueue_head(&adapter->init_wait_q);
670         adapter->is_suspended = false;
671         adapter->hs_activated = false;
672         init_waitqueue_head(&adapter->hs_activate_wait_q);
673         adapter->cmd_wait_q_required = false;
674         init_waitqueue_head(&adapter->cmd_wait_q.wait);
675         adapter->cmd_wait_q.status = 0;
676         adapter->scan_wait_q_woken = false;
677
678         adapter->workqueue = create_workqueue("MWIFIEX_WORK_QUEUE");
679         if (!adapter->workqueue)
680                 goto err_kmalloc;
681
682         INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
683
684         /* Register the device. Fill up the private data structure with relevant
685            information from the card and request for the required IRQ. */
686         if (adapter->if_ops.register_dev(adapter)) {
687                 pr_err("%s: failed to register mwifiex device\n", __func__);
688                 goto err_registerdev;
689         }
690
691         if (mwifiex_init_hw_fw(adapter)) {
692                 pr_err("%s: firmware init failed\n", __func__);
693                 goto err_init_fw;
694         }
695
696         priv = adapter->priv[0];
697
698         if (mwifiex_register_cfg80211(priv) != 0) {
699                 dev_err(adapter->dev, "cannot register netdevice"
700                                " with cfg80211\n");
701                         goto err_init_fw;
702         }
703
704         rtnl_lock();
705         /* Create station interface by default */
706         if (!mwifiex_add_virtual_intf(priv->wdev->wiphy, "mlan%d",
707                                 NL80211_IFTYPE_STATION, NULL, NULL)) {
708                 rtnl_unlock();
709                 dev_err(adapter->dev, "cannot create default station"
710                                 " interface\n");
711                 goto err_add_intf;
712         }
713
714         rtnl_unlock();
715
716         up(sem);
717
718         mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
719         dev_notice(adapter->dev, "driver_version = %s\n", fmt);
720
721         return 0;
722
723 err_add_intf:
724         rtnl_lock();
725         mwifiex_del_virtual_intf(priv->wdev->wiphy, priv->netdev);
726         rtnl_unlock();
727 err_init_fw:
728         pr_debug("info: %s: unregister device\n", __func__);
729         adapter->if_ops.unregister_dev(adapter);
730 err_registerdev:
731         adapter->surprise_removed = true;
732         mwifiex_terminate_workqueue(adapter);
733 err_kmalloc:
734         if ((adapter->hw_status == MWIFIEX_HW_STATUS_FW_READY) ||
735             (adapter->hw_status == MWIFIEX_HW_STATUS_READY)) {
736                 pr_debug("info: %s: shutdown mwifiex\n", __func__);
737                 adapter->init_wait_q_woken = false;
738
739                 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
740                         wait_event_interruptible(adapter->init_wait_q,
741                                                  adapter->init_wait_q_woken);
742         }
743
744         mwifiex_free_adapter(adapter);
745
746 err_init_sw:
747         up(sem);
748
749 exit_sem_err:
750         return -1;
751 }
752 EXPORT_SYMBOL_GPL(mwifiex_add_card);
753
754 /*
755  * This function removes the card.
756  *
757  * This function follows the following major steps to remove the device -
758  *      - Stop data traffic
759  *      - Shutdown firmware
760  *      - Remove the logical interfaces
761  *      - Terminate the work queue
762  *      - Unregister the device
763  *      - Free the adapter structure
764  */
765 int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem)
766 {
767         struct mwifiex_private *priv = NULL;
768         int i;
769
770         if (down_interruptible(sem))
771                 goto exit_sem_err;
772
773         if (!adapter)
774                 goto exit_remove;
775
776         adapter->surprise_removed = true;
777
778         /* Stop data */
779         for (i = 0; i < adapter->priv_num; i++) {
780                 priv = adapter->priv[i];
781                 if (priv && priv->netdev) {
782                         if (!netif_queue_stopped(priv->netdev))
783                                 mwifiex_stop_net_dev_queue(priv->netdev,
784                                                                 adapter);
785                         if (netif_carrier_ok(priv->netdev))
786                                 netif_carrier_off(priv->netdev);
787                 }
788         }
789
790         dev_dbg(adapter->dev, "cmd: calling mwifiex_shutdown_drv...\n");
791         adapter->init_wait_q_woken = false;
792
793         if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
794                 wait_event_interruptible(adapter->init_wait_q,
795                                          adapter->init_wait_q_woken);
796         dev_dbg(adapter->dev, "cmd: mwifiex_shutdown_drv done\n");
797         if (atomic_read(&adapter->rx_pending) ||
798             atomic_read(&adapter->tx_pending) ||
799             atomic_read(&adapter->cmd_pending)) {
800                 dev_err(adapter->dev, "rx_pending=%d, tx_pending=%d, "
801                        "cmd_pending=%d\n",
802                        atomic_read(&adapter->rx_pending),
803                        atomic_read(&adapter->tx_pending),
804                        atomic_read(&adapter->cmd_pending));
805         }
806
807         for (i = 0; i < adapter->priv_num; i++) {
808                 priv = adapter->priv[i];
809
810                 if (!priv)
811                         continue;
812
813                 rtnl_lock();
814                 if (priv->wdev && priv->netdev)
815                         mwifiex_del_virtual_intf(priv->wdev->wiphy,
816                                                  priv->netdev);
817                 rtnl_unlock();
818         }
819
820         priv = adapter->priv[0];
821         if (!priv)
822                 goto exit_remove;
823
824         if (priv->wdev) {
825                 wiphy_unregister(priv->wdev->wiphy);
826                 wiphy_free(priv->wdev->wiphy);
827                 kfree(priv->wdev);
828         }
829
830         mwifiex_terminate_workqueue(adapter);
831
832         /* Unregister device */
833         dev_dbg(adapter->dev, "info: unregister device\n");
834         adapter->if_ops.unregister_dev(adapter);
835         /* Free adapter structure */
836         dev_dbg(adapter->dev, "info: free adapter\n");
837         mwifiex_free_adapter(adapter);
838
839 exit_remove:
840         up(sem);
841 exit_sem_err:
842         return 0;
843 }
844 EXPORT_SYMBOL_GPL(mwifiex_remove_card);
845
846 /*
847  * This function initializes the module.
848  *
849  * The debug FS is also initialized if configured.
850  */
851 static int
852 mwifiex_init_module(void)
853 {
854 #ifdef CONFIG_DEBUG_FS
855         mwifiex_debugfs_init();
856 #endif
857         return 0;
858 }
859
860 /*
861  * This function cleans up the module.
862  *
863  * The debug FS is removed if available.
864  */
865 static void
866 mwifiex_cleanup_module(void)
867 {
868 #ifdef CONFIG_DEBUG_FS
869         mwifiex_debugfs_remove();
870 #endif
871 }
872
873 module_init(mwifiex_init_module);
874 module_exit(mwifiex_cleanup_module);
875
876 MODULE_AUTHOR("Marvell International Ltd.");
877 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION);
878 MODULE_VERSION(VERSION);
879 MODULE_LICENSE("GPL v2");