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
27const 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 */
44static 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
85error:
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 */
106static 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 */
139int 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	}
154process_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
271exit_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 */
283static 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 */
303static 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
344done:
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 */
359static void
360mwifiex_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 */
400static int
401mwifiex_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 */
410static int
411mwifiex_close(struct net_device *dev)
412{
413	return 0;
414}
415
416/*
417 * CFG802.11 network device handler for data transmission.
418 */
419static int
420mwifiex_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 */
480static int
481mwifiex_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 */
507static 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 */
529static void
530mwifiex_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 */
543static 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 */
551static 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 */
580void 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 */
595int 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 */
613static 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 */
627static void
628mwifiex_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 */
648int
649mwifiex_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
722err_add_intf:
723	rtnl_lock();
724	mwifiex_del_virtual_intf(priv->wdev->wiphy, priv->netdev);
725	rtnl_unlock();
726err_init_fw:
727	pr_debug("info: %s: unregister device\n", __func__);
728	adapter->if_ops.unregister_dev(adapter);
729err_registerdev:
730	adapter->surprise_removed = true;
731	mwifiex_terminate_workqueue(adapter);
732err_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
745err_init_sw:
746	up(sem);
747
748exit_sem_err:
749	return -1;
750}
751EXPORT_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 */
764int 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
838exit_remove:
839	up(sem);
840exit_sem_err:
841	return 0;
842}
843EXPORT_SYMBOL_GPL(mwifiex_remove_card);
844
845/*
846 * This function initializes the module.
847 *
848 * The debug FS is also initialized if configured.
849 */
850static int
851mwifiex_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 */
864static void
865mwifiex_cleanup_module(void)
866{
867#ifdef CONFIG_DEBUG_FS
868	mwifiex_debugfs_remove();
869#endif
870}
871
872module_init(mwifiex_init_module);
873module_exit(mwifiex_cleanup_module);
874
875MODULE_AUTHOR("Marvell International Ltd.");
876MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION);
877MODULE_VERSION(VERSION);
878MODULE_LICENSE("GPL v2");
879