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