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  */
mwifiex_register(void * card,struct mwifiex_if_ops * if_ops,void ** padapter)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  */
mwifiex_unregister(struct mwifiex_adapter * adapter)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  */
mwifiex_main_process(struct mwifiex_adapter * adapter)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  */
mwifiex_free_adapter(struct mwifiex_adapter * adapter)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  */
mwifiex_init_hw_fw(struct mwifiex_adapter * adapter)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
mwifiex_fill_buffer(struct sk_buff * skb)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
mwifiex_open(struct net_device * dev)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
mwifiex_close(struct net_device * dev)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
mwifiex_hard_start_xmit(struct sk_buff * skb,struct net_device * dev)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
mwifiex_set_mac_address(struct net_device * dev,void * addr)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  */
mwifiex_set_multicast_list(struct net_device * dev)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
mwifiex_tx_timeout(struct net_device * dev)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  */
mwifiex_get_stats(struct net_device * dev)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  */
mwifiex_init_priv_params(struct mwifiex_private * priv,struct net_device * dev)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  */
is_command_pending(struct mwifiex_adapter * adapter)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 *
mwifiex_bss_index_to_priv(struct mwifiex_adapter * adapter,u8 bss_index)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  */
mwifiex_main_work_queue(struct work_struct * work)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
mwifiex_terminate_workqueue(struct mwifiex_adapter * adapter)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
mwifiex_add_card(void * card,struct semaphore * sem,struct mwifiex_if_ops * if_ops,u8 iface_type)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  */
mwifiex_remove_card(struct mwifiex_adapter * adapter,struct semaphore * sem)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
mwifiex_init_module(void)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
mwifiex_cleanup_module(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");
891