1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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) ";
28static char *cal_data_cfg;
29module_param(cal_data_cfg, charp, 0);
30
31static void scan_delay_timer_fn(unsigned long data)
32{
33 struct mwifiex_private *priv = (struct mwifiex_private *)data;
34 struct mwifiex_adapter *adapter = priv->adapter;
35 struct cmd_ctrl_node *cmd_node, *tmp_node;
36 unsigned long flags;
37
38 if (adapter->surprise_removed)
39 return;
40
41 if (adapter->scan_delay_cnt == MWIFIEX_MAX_SCAN_DELAY_CNT) {
42
43
44
45
46 spin_lock_irqsave(&adapter->scan_pending_q_lock, flags);
47 list_for_each_entry_safe(cmd_node, tmp_node,
48 &adapter->scan_pending_q, list) {
49 list_del(&cmd_node->list);
50 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
51 }
52 spin_unlock_irqrestore(&adapter->scan_pending_q_lock, flags);
53
54 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
55 adapter->scan_processing = false;
56 adapter->scan_delay_cnt = 0;
57 adapter->empty_tx_q_cnt = 0;
58 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
59
60 if (priv->scan_request) {
61 dev_dbg(adapter->dev, "info: aborting scan\n");
62 cfg80211_scan_done(priv->scan_request, 1);
63 priv->scan_request = NULL;
64 } else {
65 priv->scan_aborting = false;
66 dev_dbg(adapter->dev, "info: scan already aborted\n");
67 }
68 goto done;
69 }
70
71 if (!atomic_read(&priv->adapter->is_tx_received)) {
72 adapter->empty_tx_q_cnt++;
73 if (adapter->empty_tx_q_cnt == MWIFIEX_MAX_EMPTY_TX_Q_CNT) {
74
75
76
77
78
79 adapter->scan_delay_cnt = 0;
80 adapter->empty_tx_q_cnt = 0;
81 spin_lock_irqsave(&adapter->scan_pending_q_lock, flags);
82 cmd_node = list_first_entry(&adapter->scan_pending_q,
83 struct cmd_ctrl_node, list);
84 list_del(&cmd_node->list);
85 spin_unlock_irqrestore(&adapter->scan_pending_q_lock,
86 flags);
87
88 mwifiex_insert_cmd_to_pending_q(adapter, cmd_node,
89 true);
90 queue_work(adapter->workqueue, &adapter->main_work);
91 goto done;
92 }
93 } else {
94 adapter->empty_tx_q_cnt = 0;
95 }
96
97
98 mod_timer(&priv->scan_delay_timer, jiffies +
99 msecs_to_jiffies(MWIFIEX_SCAN_DELAY_MSEC));
100 adapter->scan_delay_cnt++;
101
102done:
103 if (atomic_read(&priv->adapter->is_tx_received))
104 atomic_set(&priv->adapter->is_tx_received, false);
105
106 return;
107}
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124static int mwifiex_register(void *card, struct mwifiex_if_ops *if_ops,
125 void **padapter)
126{
127 struct mwifiex_adapter *adapter;
128 int i;
129
130 adapter = kzalloc(sizeof(struct mwifiex_adapter), GFP_KERNEL);
131 if (!adapter)
132 return -ENOMEM;
133
134 *padapter = adapter;
135 adapter->card = card;
136
137
138 memmove(&adapter->if_ops, if_ops, sizeof(struct mwifiex_if_ops));
139
140
141 if (adapter->if_ops.init_if)
142 if (adapter->if_ops.init_if(adapter))
143 goto error;
144
145 adapter->priv_num = 0;
146
147 for (i = 0; i < MWIFIEX_MAX_BSS_NUM; i++) {
148
149 adapter->priv[i] =
150 kzalloc(sizeof(struct mwifiex_private), GFP_KERNEL);
151 if (!adapter->priv[i])
152 goto error;
153
154 adapter->priv[i]->adapter = adapter;
155 adapter->priv_num++;
156
157 setup_timer(&adapter->priv[i]->scan_delay_timer,
158 scan_delay_timer_fn,
159 (unsigned long)adapter->priv[i]);
160 }
161 mwifiex_init_lock_list(adapter);
162
163 init_timer(&adapter->cmd_timer);
164 adapter->cmd_timer.function = mwifiex_cmd_timeout_func;
165 adapter->cmd_timer.data = (unsigned long) adapter;
166
167 return 0;
168
169error:
170 dev_dbg(adapter->dev, "info: leave mwifiex_register with error\n");
171
172 for (i = 0; i < adapter->priv_num; i++)
173 kfree(adapter->priv[i]);
174
175 kfree(adapter);
176
177 return -1;
178}
179
180
181
182
183
184
185
186
187
188
189
190static int mwifiex_unregister(struct mwifiex_adapter *adapter)
191{
192 s32 i;
193
194 if (adapter->if_ops.cleanup_if)
195 adapter->if_ops.cleanup_if(adapter);
196
197 del_timer(&adapter->cmd_timer);
198
199
200 for (i = 0; i < adapter->priv_num; i++) {
201 if (adapter->priv[i]) {
202 mwifiex_free_curr_bcn(adapter->priv[i]);
203 del_timer_sync(&adapter->priv[i]->scan_delay_timer);
204 kfree(adapter->priv[i]);
205 }
206 }
207
208 kfree(adapter);
209 return 0;
210}
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227int mwifiex_main_process(struct mwifiex_adapter *adapter)
228{
229 int ret = 0;
230 unsigned long flags;
231 struct sk_buff *skb;
232
233 spin_lock_irqsave(&adapter->main_proc_lock, flags);
234
235
236 if (adapter->mwifiex_processing) {
237 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
238 goto exit_main_proc;
239 } else {
240 adapter->mwifiex_processing = true;
241 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
242 }
243process_start:
244 do {
245 if ((adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING) ||
246 (adapter->hw_status == MWIFIEX_HW_STATUS_NOT_READY))
247 break;
248
249
250 if (adapter->int_status) {
251 if (adapter->hs_activated)
252 mwifiex_process_hs_config(adapter);
253 if (adapter->if_ops.process_int_status)
254 adapter->if_ops.process_int_status(adapter);
255 }
256
257
258 if ((adapter->ps_state == PS_STATE_SLEEP) &&
259 (adapter->pm_wakeup_card_req &&
260 !adapter->pm_wakeup_fw_try) &&
261 (is_command_pending(adapter) ||
262 !mwifiex_wmm_lists_empty(adapter))) {
263 adapter->pm_wakeup_fw_try = true;
264 adapter->if_ops.wakeup(adapter);
265 continue;
266 }
267
268 if (IS_CARD_RX_RCVD(adapter)) {
269 adapter->pm_wakeup_fw_try = false;
270 if (adapter->ps_state == PS_STATE_SLEEP)
271 adapter->ps_state = PS_STATE_AWAKE;
272 } else {
273
274 if (adapter->pm_wakeup_fw_try)
275 break;
276 if (adapter->ps_state != PS_STATE_AWAKE ||
277 adapter->tx_lock_flag)
278 break;
279
280 if ((adapter->scan_processing &&
281 !adapter->scan_delay_cnt) || adapter->data_sent ||
282 mwifiex_wmm_lists_empty(adapter)) {
283 if (adapter->cmd_sent || adapter->curr_cmd ||
284 (!is_command_pending(adapter)))
285 break;
286 }
287 }
288
289
290 if (adapter->iface_type == MWIFIEX_USB)
291 while ((skb = skb_dequeue(&adapter->usb_rx_data_q)))
292 mwifiex_handle_rx_packet(adapter, skb);
293
294
295 if (adapter->cmd_resp_received) {
296 adapter->cmd_resp_received = false;
297 mwifiex_process_cmdresp(adapter);
298
299
300 if (adapter->hw_status == MWIFIEX_HW_STATUS_INIT_DONE) {
301 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
302 mwifiex_init_fw_complete(adapter);
303 }
304 }
305
306
307 if (adapter->event_received) {
308 adapter->event_received = false;
309 mwifiex_process_event(adapter);
310 }
311
312
313
314 if (adapter->ps_state == PS_STATE_PRE_SLEEP) {
315 if (!adapter->cmd_sent && !adapter->curr_cmd)
316 mwifiex_check_ps_cond(adapter);
317 }
318
319
320
321
322 if ((adapter->ps_state == PS_STATE_SLEEP) ||
323 (adapter->ps_state == PS_STATE_PRE_SLEEP) ||
324 (adapter->ps_state == PS_STATE_SLEEP_CFM) ||
325 adapter->tx_lock_flag)
326 continue;
327
328 if (!adapter->cmd_sent && !adapter->curr_cmd) {
329 if (mwifiex_exec_next_cmd(adapter) == -1) {
330 ret = -1;
331 break;
332 }
333 }
334
335 if ((!adapter->scan_processing || adapter->scan_delay_cnt) &&
336 !adapter->data_sent && !mwifiex_wmm_lists_empty(adapter)) {
337 mwifiex_wmm_process_tx(adapter);
338 if (adapter->hs_activated) {
339 adapter->is_hs_configured = false;
340 mwifiex_hs_activated_event
341 (mwifiex_get_priv
342 (adapter, MWIFIEX_BSS_ROLE_ANY),
343 false);
344 }
345 }
346
347 if (adapter->delay_null_pkt && !adapter->cmd_sent &&
348 !adapter->curr_cmd && !is_command_pending(adapter) &&
349 mwifiex_wmm_lists_empty(adapter)) {
350 if (!mwifiex_send_null_packet
351 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
352 MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET |
353 MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET)) {
354 adapter->delay_null_pkt = false;
355 adapter->ps_state = PS_STATE_SLEEP;
356 }
357 break;
358 }
359 } while (true);
360
361 spin_lock_irqsave(&adapter->main_proc_lock, flags);
362 if ((adapter->int_status) || IS_CARD_RX_RCVD(adapter)) {
363 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
364 goto process_start;
365 }
366
367 adapter->mwifiex_processing = false;
368 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
369
370exit_main_proc:
371 if (adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING)
372 mwifiex_shutdown_drv(adapter);
373 return ret;
374}
375EXPORT_SYMBOL_GPL(mwifiex_main_process);
376
377
378
379
380
381
382
383static void mwifiex_free_adapter(struct mwifiex_adapter *adapter)
384{
385 if (!adapter) {
386 pr_err("%s: adapter is NULL\n", __func__);
387 return;
388 }
389
390 mwifiex_unregister(adapter);
391 pr_debug("info: %s: free adapter\n", __func__);
392}
393
394
395
396
397
398static void mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
399{
400 flush_workqueue(adapter->workqueue);
401 destroy_workqueue(adapter->workqueue);
402 adapter->workqueue = NULL;
403}
404
405
406
407
408
409
410
411
412static void mwifiex_fw_dpc(const struct firmware *firmware, void *context)
413{
414 int ret, i;
415 char fmt[64];
416 struct mwifiex_private *priv;
417 struct mwifiex_adapter *adapter = context;
418 struct mwifiex_fw_image fw;
419 struct semaphore *sem = adapter->card_sem;
420 bool init_failed = false;
421
422 if (!firmware) {
423 dev_err(adapter->dev,
424 "Failed to get firmware %s\n", adapter->fw_name);
425 goto err_dnld_fw;
426 }
427
428 memset(&fw, 0, sizeof(struct mwifiex_fw_image));
429 adapter->firmware = firmware;
430 fw.fw_buf = (u8 *) adapter->firmware->data;
431 fw.fw_len = adapter->firmware->size;
432
433 if (adapter->if_ops.dnld_fw)
434 ret = adapter->if_ops.dnld_fw(adapter, &fw);
435 else
436 ret = mwifiex_dnld_fw(adapter, &fw);
437 if (ret == -1)
438 goto err_dnld_fw;
439
440 dev_notice(adapter->dev, "WLAN FW is active\n");
441
442 if (cal_data_cfg) {
443 if ((request_firmware(&adapter->cal_data, cal_data_cfg,
444 adapter->dev)) < 0)
445 dev_err(adapter->dev,
446 "Cal data request_firmware() failed\n");
447 }
448
449
450 if (adapter->if_ops.enable_int) {
451 if (adapter->if_ops.enable_int(adapter))
452 goto err_dnld_fw;
453 }
454
455 adapter->init_wait_q_woken = false;
456 ret = mwifiex_init_fw(adapter);
457 if (ret == -1) {
458 goto err_init_fw;
459 } else if (!ret) {
460 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
461 goto done;
462 }
463
464 wait_event_interruptible(adapter->init_wait_q,
465 adapter->init_wait_q_woken);
466 if (adapter->hw_status != MWIFIEX_HW_STATUS_READY)
467 goto err_init_fw;
468
469 priv = adapter->priv[MWIFIEX_BSS_ROLE_STA];
470 if (mwifiex_register_cfg80211(adapter)) {
471 dev_err(adapter->dev, "cannot register with cfg80211\n");
472 goto err_register_cfg80211;
473 }
474
475 rtnl_lock();
476
477 if (!mwifiex_add_virtual_intf(adapter->wiphy, "mlan%d",
478 NL80211_IFTYPE_STATION, NULL, NULL)) {
479 dev_err(adapter->dev, "cannot create default STA interface\n");
480 goto err_add_intf;
481 }
482 rtnl_unlock();
483
484 mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
485 dev_notice(adapter->dev, "driver_version = %s\n", fmt);
486 goto done;
487
488err_add_intf:
489 for (i = 0; i < adapter->priv_num; i++) {
490 priv = adapter->priv[i];
491
492 if (!priv)
493 continue;
494
495 if (priv->wdev && priv->netdev)
496 mwifiex_del_virtual_intf(adapter->wiphy, priv->wdev);
497 }
498 rtnl_unlock();
499err_register_cfg80211:
500 wiphy_unregister(adapter->wiphy);
501 wiphy_free(adapter->wiphy);
502err_init_fw:
503 if (adapter->if_ops.disable_int)
504 adapter->if_ops.disable_int(adapter);
505err_dnld_fw:
506 pr_debug("info: %s: unregister device\n", __func__);
507 if (adapter->if_ops.unregister_dev)
508 adapter->if_ops.unregister_dev(adapter);
509
510 if ((adapter->hw_status == MWIFIEX_HW_STATUS_FW_READY) ||
511 (adapter->hw_status == MWIFIEX_HW_STATUS_READY)) {
512 pr_debug("info: %s: shutdown mwifiex\n", __func__);
513 adapter->init_wait_q_woken = false;
514
515 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
516 wait_event_interruptible(adapter->init_wait_q,
517 adapter->init_wait_q_woken);
518 }
519 adapter->surprise_removed = true;
520 mwifiex_terminate_workqueue(adapter);
521 init_failed = true;
522done:
523 if (adapter->cal_data) {
524 release_firmware(adapter->cal_data);
525 adapter->cal_data = NULL;
526 }
527 if (adapter->firmware) {
528 release_firmware(adapter->firmware);
529 adapter->firmware = NULL;
530 }
531 complete(&adapter->fw_load);
532 if (init_failed)
533 mwifiex_free_adapter(adapter);
534 up(sem);
535 return;
536}
537
538
539
540
541static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter)
542{
543 int ret;
544
545 init_completion(&adapter->fw_load);
546 ret = request_firmware_nowait(THIS_MODULE, 1, adapter->fw_name,
547 adapter->dev, GFP_KERNEL, adapter,
548 mwifiex_fw_dpc);
549 if (ret < 0)
550 dev_err(adapter->dev,
551 "request_firmware_nowait() returned error %d\n", ret);
552 return ret;
553}
554
555
556
557
558
559
560static int
561mwifiex_open(struct net_device *dev)
562{
563 netif_tx_start_all_queues(dev);
564 return 0;
565}
566
567
568
569
570static int
571mwifiex_close(struct net_device *dev)
572{
573 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
574
575 if (priv->scan_request) {
576 dev_dbg(priv->adapter->dev, "aborting scan on ndo_stop\n");
577 cfg80211_scan_done(priv->scan_request, 1);
578 priv->scan_request = NULL;
579 priv->scan_aborting = true;
580 }
581
582 return 0;
583}
584
585
586
587
588int mwifiex_queue_tx_pkt(struct mwifiex_private *priv, struct sk_buff *skb)
589{
590 struct netdev_queue *txq;
591 int index = mwifiex_1d_to_wmm_queue[skb->priority];
592
593 if (atomic_inc_return(&priv->wmm_tx_pending[index]) >= MAX_TX_PENDING) {
594 txq = netdev_get_tx_queue(priv->netdev, index);
595 if (!netif_tx_queue_stopped(txq)) {
596 netif_tx_stop_queue(txq);
597 dev_dbg(priv->adapter->dev, "stop queue: %d\n", index);
598 }
599 }
600
601 atomic_inc(&priv->adapter->tx_pending);
602 mwifiex_wmm_add_buf_txqueue(priv, skb);
603
604 if (priv->adapter->scan_delay_cnt)
605 atomic_set(&priv->adapter->is_tx_received, true);
606
607 queue_work(priv->adapter->workqueue, &priv->adapter->main_work);
608
609 return 0;
610}
611
612
613
614
615static int
616mwifiex_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
617{
618 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
619 struct sk_buff *new_skb;
620 struct mwifiex_txinfo *tx_info;
621 struct timeval tv;
622
623 dev_dbg(priv->adapter->dev, "data: %lu BSS(%d-%d): Data <= kernel\n",
624 jiffies, priv->bss_type, priv->bss_num);
625
626 if (priv->adapter->surprise_removed) {
627 kfree_skb(skb);
628 priv->stats.tx_dropped++;
629 return 0;
630 }
631 if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
632 dev_err(priv->adapter->dev, "Tx: bad skb len %d\n", skb->len);
633 kfree_skb(skb);
634 priv->stats.tx_dropped++;
635 return 0;
636 }
637 if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) {
638 dev_dbg(priv->adapter->dev,
639 "data: Tx: insufficient skb headroom %d\n",
640 skb_headroom(skb));
641
642 new_skb =
643 skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN);
644 if (unlikely(!new_skb)) {
645 dev_err(priv->adapter->dev, "Tx: cannot alloca new_skb\n");
646 kfree_skb(skb);
647 priv->stats.tx_dropped++;
648 return 0;
649 }
650 kfree_skb(skb);
651 skb = new_skb;
652 dev_dbg(priv->adapter->dev, "info: new skb headroomd %d\n",
653 skb_headroom(skb));
654 }
655
656 tx_info = MWIFIEX_SKB_TXCB(skb);
657 tx_info->bss_num = priv->bss_num;
658 tx_info->bss_type = priv->bss_type;
659
660
661
662
663
664
665
666
667 do_gettimeofday(&tv);
668 skb->tstamp = timeval_to_ktime(tv);
669
670 mwifiex_queue_tx_pkt(priv, skb);
671
672 return 0;
673}
674
675
676
677
678static int
679mwifiex_set_mac_address(struct net_device *dev, void *addr)
680{
681 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
682 struct sockaddr *hw_addr = addr;
683 int ret;
684
685 memcpy(priv->curr_addr, hw_addr->sa_data, ETH_ALEN);
686
687
688 ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_MAC_ADDRESS,
689 HostCmd_ACT_GEN_SET, 0, NULL);
690
691 if (!ret)
692 memcpy(priv->netdev->dev_addr, priv->curr_addr, ETH_ALEN);
693 else
694 dev_err(priv->adapter->dev,
695 "set mac address failed: ret=%d\n", ret);
696
697 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
698
699 return ret;
700}
701
702
703
704
705static void mwifiex_set_multicast_list(struct net_device *dev)
706{
707 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
708 struct mwifiex_multicast_list mcast_list;
709
710 if (dev->flags & IFF_PROMISC) {
711 mcast_list.mode = MWIFIEX_PROMISC_MODE;
712 } else if (dev->flags & IFF_ALLMULTI ||
713 netdev_mc_count(dev) > MWIFIEX_MAX_MULTICAST_LIST_SIZE) {
714 mcast_list.mode = MWIFIEX_ALL_MULTI_MODE;
715 } else {
716 mcast_list.mode = MWIFIEX_MULTICAST_MODE;
717 mcast_list.num_multicast_addr =
718 mwifiex_copy_mcast_addr(&mcast_list, dev);
719 }
720 mwifiex_request_set_multicast_list(priv, &mcast_list);
721}
722
723
724
725
726static void
727mwifiex_tx_timeout(struct net_device *dev)
728{
729 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
730
731 priv->num_tx_timeout++;
732 priv->tx_timeout_cnt++;
733 dev_err(priv->adapter->dev,
734 "%lu : Tx timeout(#%d), bss_type-num = %d-%d\n",
735 jiffies, priv->tx_timeout_cnt, priv->bss_type, priv->bss_num);
736 mwifiex_set_trans_start(dev);
737
738 if (priv->tx_timeout_cnt > TX_TIMEOUT_THRESHOLD &&
739 priv->adapter->if_ops.card_reset) {
740 dev_err(priv->adapter->dev,
741 "tx_timeout_cnt exceeds threshold. Triggering card reset!\n");
742 priv->adapter->if_ops.card_reset(priv->adapter);
743 }
744}
745
746
747
748
749static struct net_device_stats *mwifiex_get_stats(struct net_device *dev)
750{
751 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
752
753 return &priv->stats;
754}
755
756static u16
757mwifiex_netdev_select_wmm_queue(struct net_device *dev, struct sk_buff *skb)
758{
759 skb->priority = cfg80211_classify8021d(skb);
760 return mwifiex_1d_to_wmm_queue[skb->priority];
761}
762
763
764static const struct net_device_ops mwifiex_netdev_ops = {
765 .ndo_open = mwifiex_open,
766 .ndo_stop = mwifiex_close,
767 .ndo_start_xmit = mwifiex_hard_start_xmit,
768 .ndo_set_mac_address = mwifiex_set_mac_address,
769 .ndo_tx_timeout = mwifiex_tx_timeout,
770 .ndo_get_stats = mwifiex_get_stats,
771 .ndo_set_rx_mode = mwifiex_set_multicast_list,
772 .ndo_select_queue = mwifiex_netdev_select_wmm_queue,
773};
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794void mwifiex_init_priv_params(struct mwifiex_private *priv,
795 struct net_device *dev)
796{
797 dev->netdev_ops = &mwifiex_netdev_ops;
798 dev->destructor = free_netdev;
799
800 priv->current_key_index = 0;
801 priv->media_connected = false;
802 memset(&priv->nick_name, 0, sizeof(priv->nick_name));
803 memset(priv->mgmt_ie, 0,
804 sizeof(struct mwifiex_ie) * MAX_MGMT_IE_INDEX);
805 priv->beacon_idx = MWIFIEX_AUTO_IDX_MASK;
806 priv->proberesp_idx = MWIFIEX_AUTO_IDX_MASK;
807 priv->assocresp_idx = MWIFIEX_AUTO_IDX_MASK;
808 priv->rsn_idx = MWIFIEX_AUTO_IDX_MASK;
809 priv->num_tx_timeout = 0;
810 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
811}
812
813
814
815
816int is_command_pending(struct mwifiex_adapter *adapter)
817{
818 unsigned long flags;
819 int is_cmd_pend_q_empty;
820
821 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
822 is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
823 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
824
825 return !is_cmd_pend_q_empty;
826}
827
828
829
830
831
832
833
834static void mwifiex_main_work_queue(struct work_struct *work)
835{
836 struct mwifiex_adapter *adapter =
837 container_of(work, struct mwifiex_adapter, main_work);
838
839 if (adapter->surprise_removed)
840 return;
841 mwifiex_main_process(adapter);
842}
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857int
858mwifiex_add_card(void *card, struct semaphore *sem,
859 struct mwifiex_if_ops *if_ops, u8 iface_type)
860{
861 struct mwifiex_adapter *adapter;
862
863 if (down_interruptible(sem))
864 goto exit_sem_err;
865
866 if (mwifiex_register(card, if_ops, (void **)&adapter)) {
867 pr_err("%s: software init failed\n", __func__);
868 goto err_init_sw;
869 }
870
871 adapter->iface_type = iface_type;
872 adapter->card_sem = sem;
873
874 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
875 adapter->surprise_removed = false;
876 init_waitqueue_head(&adapter->init_wait_q);
877 adapter->is_suspended = false;
878 adapter->hs_activated = false;
879 init_waitqueue_head(&adapter->hs_activate_wait_q);
880 adapter->cmd_wait_q_required = false;
881 init_waitqueue_head(&adapter->cmd_wait_q.wait);
882 adapter->cmd_wait_q.status = 0;
883 adapter->scan_wait_q_woken = false;
884
885 adapter->workqueue = create_workqueue("MWIFIEX_WORK_QUEUE");
886 if (!adapter->workqueue)
887 goto err_kmalloc;
888
889 INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
890
891
892
893 if (adapter->if_ops.register_dev(adapter)) {
894 pr_err("%s: failed to register mwifiex device\n", __func__);
895 goto err_registerdev;
896 }
897
898 if (mwifiex_init_hw_fw(adapter)) {
899 pr_err("%s: firmware init failed\n", __func__);
900 goto err_init_fw;
901 }
902
903 return 0;
904
905err_init_fw:
906 pr_debug("info: %s: unregister device\n", __func__);
907 if (adapter->if_ops.unregister_dev)
908 adapter->if_ops.unregister_dev(adapter);
909 if ((adapter->hw_status == MWIFIEX_HW_STATUS_FW_READY) ||
910 (adapter->hw_status == MWIFIEX_HW_STATUS_READY)) {
911 pr_debug("info: %s: shutdown mwifiex\n", __func__);
912 adapter->init_wait_q_woken = false;
913
914 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
915 wait_event_interruptible(adapter->init_wait_q,
916 adapter->init_wait_q_woken);
917 }
918err_registerdev:
919 adapter->surprise_removed = true;
920 mwifiex_terminate_workqueue(adapter);
921err_kmalloc:
922 mwifiex_free_adapter(adapter);
923
924err_init_sw:
925 up(sem);
926
927exit_sem_err:
928 return -1;
929}
930EXPORT_SYMBOL_GPL(mwifiex_add_card);
931
932
933
934
935
936
937
938
939
940
941
942
943int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem)
944{
945 struct mwifiex_private *priv = NULL;
946 int i;
947
948 if (down_interruptible(sem))
949 goto exit_sem_err;
950
951 if (!adapter)
952 goto exit_remove;
953
954
955
956 if (adapter->if_ops.disable_int)
957 adapter->if_ops.disable_int(adapter);
958
959 adapter->surprise_removed = true;
960
961
962 for (i = 0; i < adapter->priv_num; i++) {
963 priv = adapter->priv[i];
964 if (priv && priv->netdev) {
965 mwifiex_stop_net_dev_queue(priv->netdev, adapter);
966 if (netif_carrier_ok(priv->netdev))
967 netif_carrier_off(priv->netdev);
968 }
969 }
970
971 dev_dbg(adapter->dev, "cmd: calling mwifiex_shutdown_drv...\n");
972 adapter->init_wait_q_woken = false;
973
974 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
975 wait_event_interruptible(adapter->init_wait_q,
976 adapter->init_wait_q_woken);
977 dev_dbg(adapter->dev, "cmd: mwifiex_shutdown_drv done\n");
978 if (atomic_read(&adapter->rx_pending) ||
979 atomic_read(&adapter->tx_pending) ||
980 atomic_read(&adapter->cmd_pending)) {
981 dev_err(adapter->dev, "rx_pending=%d, tx_pending=%d, "
982 "cmd_pending=%d\n",
983 atomic_read(&adapter->rx_pending),
984 atomic_read(&adapter->tx_pending),
985 atomic_read(&adapter->cmd_pending));
986 }
987
988 for (i = 0; i < adapter->priv_num; i++) {
989 priv = adapter->priv[i];
990
991 if (!priv)
992 continue;
993
994 rtnl_lock();
995 if (priv->wdev && priv->netdev)
996 mwifiex_del_virtual_intf(adapter->wiphy, priv->wdev);
997 rtnl_unlock();
998 }
999
1000 priv = adapter->priv[0];
1001 if (!priv || !priv->wdev)
1002 goto exit_remove;
1003
1004 wiphy_unregister(priv->wdev->wiphy);
1005 wiphy_free(priv->wdev->wiphy);
1006
1007 for (i = 0; i < adapter->priv_num; i++) {
1008 priv = adapter->priv[i];
1009 if (priv)
1010 kfree(priv->wdev);
1011 }
1012
1013 mwifiex_terminate_workqueue(adapter);
1014
1015
1016 dev_dbg(adapter->dev, "info: unregister device\n");
1017 if (adapter->if_ops.unregister_dev)
1018 adapter->if_ops.unregister_dev(adapter);
1019
1020 dev_dbg(adapter->dev, "info: free adapter\n");
1021 mwifiex_free_adapter(adapter);
1022
1023exit_remove:
1024 up(sem);
1025exit_sem_err:
1026 return 0;
1027}
1028EXPORT_SYMBOL_GPL(mwifiex_remove_card);
1029
1030
1031
1032
1033
1034
1035static int
1036mwifiex_init_module(void)
1037{
1038#ifdef CONFIG_DEBUG_FS
1039 mwifiex_debugfs_init();
1040#endif
1041 return 0;
1042}
1043
1044
1045
1046
1047
1048
1049static void
1050mwifiex_cleanup_module(void)
1051{
1052#ifdef CONFIG_DEBUG_FS
1053 mwifiex_debugfs_remove();
1054#endif
1055}
1056
1057module_init(mwifiex_init_module);
1058module_exit(mwifiex_cleanup_module);
1059
1060MODULE_AUTHOR("Marvell International Ltd.");
1061MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION);
1062MODULE_VERSION(VERSION);
1063MODULE_LICENSE("GPL v2");
1064