projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-4.9/block' into for-next
[deliverable/linux.git] / drivers / net / wireless / marvell / mwifiex / main.c
1 /*
2 * Marvell Wireless LAN device driver: major functions
3 *
4 * Copyright (C) 2011-2014, 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 static unsigned int debug_mask = MWIFIEX_DEFAULT_DEBUG_MASK;
28 module_param(debug_mask, uint, 0);
29 MODULE_PARM_DESC(debug_mask, "bitmap for debug flags");
30
31 const char driver_version[] = "mwifiex " VERSION " (%s) ";
32 static char *cal_data_cfg;
33 module_param(cal_data_cfg, charp, 0);
34
35 static unsigned short driver_mode;
36 module_param(driver_mode, ushort, 0);
37 MODULE_PARM_DESC(driver_mode,
38 "station=0x1(default), ap-sta=0x3, station-p2p=0x5, ap-sta-p2p=0x7");
39
40 /*
41 * This function registers the device and performs all the necessary
42 * initializations.
43 *
44 * The following initialization operations are performed -
45 * - Allocate adapter structure
46 * - Save interface specific operations table in adapter
47 * - Call interface specific initialization routine
48 * - Allocate private structures
49 * - Set default adapter structure parameters
50 * - Initialize locks
51 *
52 * In case of any errors during inittialization, this function also ensures
53 * proper cleanup before exiting.
54 */
55 static int mwifiex_register(void *card, struct mwifiex_if_ops *if_ops,
56 void **padapter)
57 {
58 struct mwifiex_adapter *adapter;
59 int i;
60
61 adapter = kzalloc(sizeof(struct mwifiex_adapter), GFP_KERNEL);
62 if (!adapter)
63 return -ENOMEM;
64
65 *padapter = adapter;
66 adapter->card = card;
67
68 /* Save interface specific operations in adapter */
69 memmove(&adapter->if_ops, if_ops, sizeof(struct mwifiex_if_ops));
70 adapter->debug_mask = debug_mask;
71
72 /* card specific initialization has been deferred until now .. */
73 if (adapter->if_ops.init_if)
74 if (adapter->if_ops.init_if(adapter))
75 goto error;
76
77 adapter->priv_num = 0;
78
79 for (i = 0; i < MWIFIEX_MAX_BSS_NUM; i++) {
80 /* Allocate memory for private structure */
81 adapter->priv[i] =
82 kzalloc(sizeof(struct mwifiex_private), GFP_KERNEL);
83 if (!adapter->priv[i])
84 goto error;
85
86 adapter->priv[i]->adapter = adapter;
87 adapter->priv_num++;
88 }
89 mwifiex_init_lock_list(adapter);
90
91 setup_timer(&adapter->cmd_timer, mwifiex_cmd_timeout_func,
92 (unsigned long)adapter);
93
94 return 0;
95
96 error:
97 mwifiex_dbg(adapter, ERROR,
98 "info: leave mwifiex_register with error\n");
99
100 for (i = 0; i < adapter->priv_num; i++)
101 kfree(adapter->priv[i]);
102
103 kfree(adapter);
104
105 return -1;
106 }
107
108 /*
109 * This function unregisters the device and performs all the necessary
110 * cleanups.
111 *
112 * The following cleanup operations are performed -
113 * - Free the timers
114 * - Free beacon buffers
115 * - Free private structures
116 * - Free adapter structure
117 */
118 static int mwifiex_unregister(struct mwifiex_adapter *adapter)
119 {
120 s32 i;
121
122 if (adapter->if_ops.cleanup_if)
123 adapter->if_ops.cleanup_if(adapter);
124
125 del_timer_sync(&adapter->cmd_timer);
126
127 /* Free private structures */
128 for (i = 0; i < adapter->priv_num; i++) {
129 if (adapter->priv[i]) {
130 mwifiex_free_curr_bcn(adapter->priv[i]);
131 kfree(adapter->priv[i]);
132 }
133 }
134
135 if (adapter->nd_info) {
136 for (i = 0 ; i < adapter->nd_info->n_matches ; i++)
137 kfree(adapter->nd_info->matches[i]);
138 kfree(adapter->nd_info);
139 adapter->nd_info = NULL;
140 }
141
142 vfree(adapter->chan_stats);
143 kfree(adapter);
144 return 0;
145 }
146
147 void mwifiex_queue_main_work(struct mwifiex_adapter *adapter)
148 {
149 unsigned long flags;
150
151 spin_lock_irqsave(&adapter->main_proc_lock, flags);
152 if (adapter->mwifiex_processing) {
153 adapter->more_task_flag = true;
154 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
155 } else {
156 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
157 queue_work(adapter->workqueue, &adapter->main_work);
158 }
159 }
160 EXPORT_SYMBOL_GPL(mwifiex_queue_main_work);
161
162 static void mwifiex_queue_rx_work(struct mwifiex_adapter *adapter)
163 {
164 unsigned long flags;
165
166 spin_lock_irqsave(&adapter->rx_proc_lock, flags);
167 if (adapter->rx_processing) {
168 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
169 } else {
170 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
171 queue_work(adapter->rx_workqueue, &adapter->rx_work);
172 }
173 }
174
175 static int mwifiex_process_rx(struct mwifiex_adapter *adapter)
176 {
177 unsigned long flags;
178 struct sk_buff *skb;
179 struct mwifiex_rxinfo *rx_info;
180
181 spin_lock_irqsave(&adapter->rx_proc_lock, flags);
182 if (adapter->rx_processing || adapter->rx_locked) {
183 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
184 goto exit_rx_proc;
185 } else {
186 adapter->rx_processing = true;
187 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
188 }
189
190 /* Check for Rx data */
191 while ((skb = skb_dequeue(&adapter->rx_data_q))) {
192 atomic_dec(&adapter->rx_pending);
193 if ((adapter->delay_main_work ||
194 adapter->iface_type == MWIFIEX_USB) &&
195 (atomic_read(&adapter->rx_pending) < LOW_RX_PENDING)) {
196 if (adapter->if_ops.submit_rem_rx_urbs)
197 adapter->if_ops.submit_rem_rx_urbs(adapter);
198 adapter->delay_main_work = false;
199 mwifiex_queue_main_work(adapter);
200 }
201 rx_info = MWIFIEX_SKB_RXCB(skb);
202 if (rx_info->buf_type == MWIFIEX_TYPE_AGGR_DATA) {
203 if (adapter->if_ops.deaggr_pkt)
204 adapter->if_ops.deaggr_pkt(adapter, skb);
205 dev_kfree_skb_any(skb);
206 } else {
207 mwifiex_handle_rx_packet(adapter, skb);
208 }
209 }
210 spin_lock_irqsave(&adapter->rx_proc_lock, flags);
211 adapter->rx_processing = false;
212 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
213
214 exit_rx_proc:
215 return 0;
216 }
217
218 /*
219 * The main process.
220 *
221 * This function is the main procedure of the driver and handles various driver
222 * operations. It runs in a loop and provides the core functionalities.
223 *
224 * The main responsibilities of this function are -
225 * - Ensure concurrency control
226 * - Handle pending interrupts and call interrupt handlers
227 * - Wake up the card if required
228 * - Handle command responses and call response handlers
229 * - Handle events and call event handlers
230 * - Execute pending commands
231 * - Transmit pending data packets
232 */
233 int mwifiex_main_process(struct mwifiex_adapter *adapter)
234 {
235 int ret = 0;
236 unsigned long flags;
237
238 spin_lock_irqsave(&adapter->main_proc_lock, flags);
239
240 /* Check if already processing */
241 if (adapter->mwifiex_processing || adapter->main_locked) {
242 adapter->more_task_flag = true;
243 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
244 goto exit_main_proc;
245 } else {
246 adapter->mwifiex_processing = true;
247 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
248 }
249 process_start:
250 do {
251 if ((adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING) ||
252 (adapter->hw_status == MWIFIEX_HW_STATUS_NOT_READY))
253 break;
254
255 /* For non-USB interfaces, If we process interrupts first, it
256 * would increase RX pending even further. Avoid this by
257 * checking if rx_pending has crossed high threshold and
258 * schedule rx work queue and then process interrupts.
259 * For USB interface, there are no interrupts. We already have
260 * HIGH_RX_PENDING check in usb.c
261 */
262 if (atomic_read(&adapter->rx_pending) >= HIGH_RX_PENDING &&
263 adapter->iface_type != MWIFIEX_USB) {
264 adapter->delay_main_work = true;
265 mwifiex_queue_rx_work(adapter);
266 break;
267 }
268
269 /* Handle pending interrupt if any */
270 if (adapter->int_status) {
271 if (adapter->hs_activated)
272 mwifiex_process_hs_config(adapter);
273 if (adapter->if_ops.process_int_status)
274 adapter->if_ops.process_int_status(adapter);
275 }
276
277 if (adapter->rx_work_enabled && adapter->data_received)
278 mwifiex_queue_rx_work(adapter);
279
280 /* Need to wake up the card ? */
281 if ((adapter->ps_state == PS_STATE_SLEEP) &&
282 (adapter->pm_wakeup_card_req &&
283 !adapter->pm_wakeup_fw_try) &&
284 (is_command_pending(adapter) ||
285 !skb_queue_empty(&adapter->tx_data_q) ||
286 !mwifiex_bypass_txlist_empty(adapter) ||
287 !mwifiex_wmm_lists_empty(adapter))) {
288 adapter->pm_wakeup_fw_try = true;
289 mod_timer(&adapter->wakeup_timer, jiffies + (HZ*3));
290 adapter->if_ops.wakeup(adapter);
291 continue;
292 }
293
294 if (IS_CARD_RX_RCVD(adapter)) {
295 adapter->data_received = false;
296 adapter->pm_wakeup_fw_try = false;
297 del_timer(&adapter->wakeup_timer);
298 if (adapter->ps_state == PS_STATE_SLEEP)
299 adapter->ps_state = PS_STATE_AWAKE;
300 } else {
301 /* We have tried to wakeup the card already */
302 if (adapter->pm_wakeup_fw_try)
303 break;
304 if (adapter->ps_state != PS_STATE_AWAKE)
305 break;
306 if (adapter->tx_lock_flag) {
307 if (adapter->iface_type == MWIFIEX_USB) {
308 if (!adapter->usb_mc_setup)
309 break;
310 } else
311 break;
312 }
313
314 if ((!adapter->scan_chan_gap_enabled &&
315 adapter->scan_processing) || adapter->data_sent ||
316 mwifiex_is_tdls_chan_switching
317 (mwifiex_get_priv(adapter,
318 MWIFIEX_BSS_ROLE_STA)) ||
319 (mwifiex_wmm_lists_empty(adapter) &&
320 mwifiex_bypass_txlist_empty(adapter) &&
321 skb_queue_empty(&adapter->tx_data_q))) {
322 if (adapter->cmd_sent || adapter->curr_cmd ||
323 !mwifiex_is_send_cmd_allowed
324 (mwifiex_get_priv(adapter,
325 MWIFIEX_BSS_ROLE_STA)) ||
326 (!is_command_pending(adapter)))
327 break;
328 }
329 }
330
331 /* Check for event */
332 if (adapter->event_received) {
333 adapter->event_received = false;
334 mwifiex_process_event(adapter);
335 }
336
337 /* Check for Cmd Resp */
338 if (adapter->cmd_resp_received) {
339 adapter->cmd_resp_received = false;
340 mwifiex_process_cmdresp(adapter);
341
342 /* call mwifiex back when init_fw is done */
343 if (adapter->hw_status == MWIFIEX_HW_STATUS_INIT_DONE) {
344 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
345 mwifiex_init_fw_complete(adapter);
346 }
347 }
348
349 /* Check if we need to confirm Sleep Request
350 received previously */
351 if (adapter->ps_state == PS_STATE_PRE_SLEEP) {
352 if (!adapter->cmd_sent && !adapter->curr_cmd)
353 mwifiex_check_ps_cond(adapter);
354 }
355
356 /* * The ps_state may have been changed during processing of
357 * Sleep Request event.
358 */
359 if ((adapter->ps_state == PS_STATE_SLEEP) ||
360 (adapter->ps_state == PS_STATE_PRE_SLEEP) ||
361 (adapter->ps_state == PS_STATE_SLEEP_CFM)) {
362 continue;
363 }
364
365 if (adapter->tx_lock_flag) {
366 if (adapter->iface_type == MWIFIEX_USB) {
367 if (!adapter->usb_mc_setup)
368 continue;
369 } else
370 continue;
371 }
372
373 if (!adapter->cmd_sent && !adapter->curr_cmd &&
374 mwifiex_is_send_cmd_allowed
375 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) {
376 if (mwifiex_exec_next_cmd(adapter) == -1) {
377 ret = -1;
378 break;
379 }
380 }
381
382 /** If USB Multi channel setup ongoing,
383 * wait for ready to tx data.
384 */
385 if (adapter->iface_type == MWIFIEX_USB &&
386 adapter->usb_mc_setup)
387 continue;
388
389 if ((adapter->scan_chan_gap_enabled ||
390 !adapter->scan_processing) &&
391 !adapter->data_sent &&
392 !skb_queue_empty(&adapter->tx_data_q)) {
393 mwifiex_process_tx_queue(adapter);
394 if (adapter->hs_activated) {
395 adapter->is_hs_configured = false;
396 mwifiex_hs_activated_event
397 (mwifiex_get_priv
398 (adapter, MWIFIEX_BSS_ROLE_ANY),
399 false);
400 }
401 }
402
403 if ((adapter->scan_chan_gap_enabled ||
404 !adapter->scan_processing) &&
405 !adapter->data_sent &&
406 !mwifiex_bypass_txlist_empty(adapter) &&
407 !mwifiex_is_tdls_chan_switching
408 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) {
409 mwifiex_process_bypass_tx(adapter);
410 if (adapter->hs_activated) {
411 adapter->is_hs_configured = false;
412 mwifiex_hs_activated_event
413 (mwifiex_get_priv
414 (adapter, MWIFIEX_BSS_ROLE_ANY),
415 false);
416 }
417 }
418
419 if ((adapter->scan_chan_gap_enabled ||
420 !adapter->scan_processing) &&
421 !adapter->data_sent && !mwifiex_wmm_lists_empty(adapter) &&
422 !mwifiex_is_tdls_chan_switching
423 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) {
424 mwifiex_wmm_process_tx(adapter);
425 if (adapter->hs_activated) {
426 adapter->is_hs_configured = false;
427 mwifiex_hs_activated_event
428 (mwifiex_get_priv
429 (adapter, MWIFIEX_BSS_ROLE_ANY),
430 false);
431 }
432 }
433
434 if (adapter->delay_null_pkt && !adapter->cmd_sent &&
435 !adapter->curr_cmd && !is_command_pending(adapter) &&
436 (mwifiex_wmm_lists_empty(adapter) &&
437 mwifiex_bypass_txlist_empty(adapter) &&
438 skb_queue_empty(&adapter->tx_data_q))) {
439 if (!mwifiex_send_null_packet
440 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
441 MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET |
442 MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET)) {
443 adapter->delay_null_pkt = false;
444 adapter->ps_state = PS_STATE_SLEEP;
445 }
446 break;
447 }
448 } while (true);
449
450 spin_lock_irqsave(&adapter->main_proc_lock, flags);
451 if (adapter->more_task_flag) {
452 adapter->more_task_flag = false;
453 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
454 goto process_start;
455 }
456 adapter->mwifiex_processing = false;
457 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
458
459 exit_main_proc:
460 if (adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING)
461 mwifiex_shutdown_drv(adapter);
462 return ret;
463 }
464 EXPORT_SYMBOL_GPL(mwifiex_main_process);
465
466 /*
467 * This function frees the adapter structure.
468 *
469 * Additionally, this closes the netlink socket, frees the timers
470 * and private structures.
471 */
472 static void mwifiex_free_adapter(struct mwifiex_adapter *adapter)
473 {
474 if (!adapter) {
475 pr_err("%s: adapter is NULL\n", __func__);
476 return;
477 }
478
479 mwifiex_unregister(adapter);
480 pr_debug("info: %s: free adapter\n", __func__);
481 }
482
483 /*
484 * This function cancels all works in the queue and destroys
485 * the main workqueue.
486 */
487 static void mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
488 {
489 flush_workqueue(adapter->workqueue);
490 destroy_workqueue(adapter->workqueue);
491 adapter->workqueue = NULL;
492
493 if (adapter->rx_workqueue) {
494 flush_workqueue(adapter->rx_workqueue);
495 destroy_workqueue(adapter->rx_workqueue);
496 adapter->rx_workqueue = NULL;
497 }
498 }
499
500 /*
501 * This function gets firmware and initializes it.
502 *
503 * The main initialization steps followed are -
504 * - Download the correct firmware to card
505 * - Issue the init commands to firmware
506 */
507 static void mwifiex_fw_dpc(const struct firmware *firmware, void *context)
508 {
509 int ret;
510 char fmt[64];
511 struct mwifiex_private *priv;
512 struct mwifiex_adapter *adapter = context;
513 struct mwifiex_fw_image fw;
514 struct semaphore *sem = adapter->card_sem;
515 bool init_failed = false;
516 struct wireless_dev *wdev;
517
518 if (!firmware) {
519 mwifiex_dbg(adapter, ERROR,
520 "Failed to get firmware %s\n", adapter->fw_name);
521 goto err_dnld_fw;
522 }
523
524 memset(&fw, 0, sizeof(struct mwifiex_fw_image));
525 adapter->firmware = firmware;
526 fw.fw_buf = (u8 *) adapter->firmware->data;
527 fw.fw_len = adapter->firmware->size;
528
529 if (adapter->if_ops.dnld_fw) {
530 ret = adapter->if_ops.dnld_fw(adapter, &fw);
531 } else {
532 ret = mwifiex_dnld_fw(adapter, &fw);
533 }
534
535 if (ret == -1)
536 goto err_dnld_fw;
537
538 mwifiex_dbg(adapter, MSG, "WLAN FW is active\n");
539
540 if (cal_data_cfg) {
541 if ((request_firmware(&adapter->cal_data, cal_data_cfg,
542 adapter->dev)) < 0)
543 mwifiex_dbg(adapter, ERROR,
544 "Cal data request_firmware() failed\n");
545 }
546
547 /* enable host interrupt after fw dnld is successful */
548 if (adapter->if_ops.enable_int) {
549 if (adapter->if_ops.enable_int(adapter))
550 goto err_dnld_fw;
551 }
552
553 adapter->init_wait_q_woken = false;
554 ret = mwifiex_init_fw(adapter);
555 if (ret == -1) {
556 goto err_init_fw;
557 } else if (!ret) {
558 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
559 goto done;
560 }
561 /* Wait for mwifiex_init to complete */
562 wait_event_interruptible(adapter->init_wait_q,
563 adapter->init_wait_q_woken);
564 if (adapter->hw_status != MWIFIEX_HW_STATUS_READY)
565 goto err_init_fw;
566
567 priv = adapter->priv[MWIFIEX_BSS_ROLE_STA];
568 if (mwifiex_register_cfg80211(adapter)) {
569 mwifiex_dbg(adapter, ERROR,
570 "cannot register with cfg80211\n");
571 goto err_init_fw;
572 }
573
574 if (mwifiex_init_channel_scan_gap(adapter)) {
575 mwifiex_dbg(adapter, ERROR,
576 "could not init channel stats table\n");
577 goto err_init_fw;
578 }
579
580 if (driver_mode) {
581 driver_mode &= MWIFIEX_DRIVER_MODE_BITMASK;
582 driver_mode |= MWIFIEX_DRIVER_MODE_STA;
583 }
584
585 rtnl_lock();
586 /* Create station interface by default */
587 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "mlan%d", NET_NAME_ENUM,
588 NL80211_IFTYPE_STATION, NULL, NULL);
589 if (IS_ERR(wdev)) {
590 mwifiex_dbg(adapter, ERROR,
591 "cannot create default STA interface\n");
592 rtnl_unlock();
593 goto err_add_intf;
594 }
595
596 if (driver_mode & MWIFIEX_DRIVER_MODE_UAP) {
597 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "uap%d", NET_NAME_ENUM,
598 NL80211_IFTYPE_AP, NULL, NULL);
599 if (IS_ERR(wdev)) {
600 mwifiex_dbg(adapter, ERROR,
601 "cannot create AP interface\n");
602 rtnl_unlock();
603 goto err_add_intf;
604 }
605 }
606
607 if (driver_mode & MWIFIEX_DRIVER_MODE_P2P) {
608 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "p2p%d", NET_NAME_ENUM,
609 NL80211_IFTYPE_P2P_CLIENT, NULL,
610 NULL);
611 if (IS_ERR(wdev)) {
612 mwifiex_dbg(adapter, ERROR,
613 "cannot create p2p client interface\n");
614 rtnl_unlock();
615 goto err_add_intf;
616 }
617 }
618 rtnl_unlock();
619
620 mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
621 mwifiex_dbg(adapter, MSG, "driver_version = %s\n", fmt);
622 goto done;
623
624 err_add_intf:
625 wiphy_unregister(adapter->wiphy);
626 wiphy_free(adapter->wiphy);
627 err_init_fw:
628 if (adapter->if_ops.disable_int)
629 adapter->if_ops.disable_int(adapter);
630 err_dnld_fw:
631 mwifiex_dbg(adapter, ERROR,
632 "info: %s: unregister device\n", __func__);
633 if (adapter->if_ops.unregister_dev)
634 adapter->if_ops.unregister_dev(adapter);
635
636 if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) {
637 pr_debug("info: %s: shutdown mwifiex\n", __func__);
638 adapter->init_wait_q_woken = false;
639
640 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
641 wait_event_interruptible(adapter->init_wait_q,
642 adapter->init_wait_q_woken);
643 }
644 adapter->surprise_removed = true;
645 mwifiex_terminate_workqueue(adapter);
646 init_failed = true;
647 done:
648 if (adapter->cal_data) {
649 release_firmware(adapter->cal_data);
650 adapter->cal_data = NULL;
651 }
652 if (adapter->firmware) {
653 release_firmware(adapter->firmware);
654 adapter->firmware = NULL;
655 }
656 if (init_failed)
657 mwifiex_free_adapter(adapter);
658 up(sem);
659 return;
660 }
661
662 /*
663 * This function initializes the hardware and gets firmware.
664 */
665 static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter)
666 {
667 int ret;
668
669 ret = request_firmware_nowait(THIS_MODULE, 1, adapter->fw_name,
670 adapter->dev, GFP_KERNEL, adapter,
671 mwifiex_fw_dpc);
672 if (ret < 0)
673 mwifiex_dbg(adapter, ERROR,
674 "request_firmware_nowait error %d\n", ret);
675 return ret;
676 }
677
678 /*
679 * CFG802.11 network device handler for open.
680 *
681 * Starts the data queue.
682 */
683 static int
684 mwifiex_open(struct net_device *dev)
685 {
686 netif_carrier_off(dev);
687
688 return 0;
689 }
690
691 /*
692 * CFG802.11 network device handler for close.
693 */
694 static int
695 mwifiex_close(struct net_device *dev)
696 {
697 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
698
699 if (priv->scan_request) {
700 struct cfg80211_scan_info info = {
701 .aborted = true,
702 };
703
704 mwifiex_dbg(priv->adapter, INFO,
705 "aborting scan on ndo_stop\n");
706 cfg80211_scan_done(priv->scan_request, &info);
707 priv->scan_request = NULL;
708 priv->scan_aborting = true;
709 }
710
711 if (priv->sched_scanning) {
712 mwifiex_dbg(priv->adapter, INFO,
713 "aborting bgscan on ndo_stop\n");
714 mwifiex_stop_bg_scan(priv);
715 cfg80211_sched_scan_stopped(priv->wdev.wiphy);
716 }
717
718 return 0;
719 }
720
721 static bool
722 mwifiex_bypass_tx_queue(struct mwifiex_private *priv,
723 struct sk_buff *skb)
724 {
725 struct ethhdr *eth_hdr = (struct ethhdr *)skb->data;
726
727 if (ntohs(eth_hdr->h_proto) == ETH_P_PAE ||
728 mwifiex_is_skb_mgmt_frame(skb) ||
729 (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA &&
730 ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) &&
731 (ntohs(eth_hdr->h_proto) == ETH_P_TDLS))) {
732 mwifiex_dbg(priv->adapter, DATA,
733 "bypass txqueue; eth type %#x, mgmt %d\n",
734 ntohs(eth_hdr->h_proto),
735 mwifiex_is_skb_mgmt_frame(skb));
736 return true;
737 }
738
739 return false;
740 }
741 /*
742 * Add buffer into wmm tx queue and queue work to transmit it.
743 */
744 int mwifiex_queue_tx_pkt(struct mwifiex_private *priv, struct sk_buff *skb)
745 {
746 struct netdev_queue *txq;
747 int index = mwifiex_1d_to_wmm_queue[skb->priority];
748
749 if (atomic_inc_return(&priv->wmm_tx_pending[index]) >= MAX_TX_PENDING) {
750 txq = netdev_get_tx_queue(priv->netdev, index);
751 if (!netif_tx_queue_stopped(txq)) {
752 netif_tx_stop_queue(txq);
753 mwifiex_dbg(priv->adapter, DATA,
754 "stop queue: %d\n", index);
755 }
756 }
757
758 if (mwifiex_bypass_tx_queue(priv, skb)) {
759 atomic_inc(&priv->adapter->tx_pending);
760 atomic_inc(&priv->adapter->bypass_tx_pending);
761 mwifiex_wmm_add_buf_bypass_txqueue(priv, skb);
762 } else {
763 atomic_inc(&priv->adapter->tx_pending);
764 mwifiex_wmm_add_buf_txqueue(priv, skb);
765 }
766
767 mwifiex_queue_main_work(priv->adapter);
768
769 return 0;
770 }
771
772 struct sk_buff *
773 mwifiex_clone_skb_for_tx_status(struct mwifiex_private *priv,
774 struct sk_buff *skb, u8 flag, u64 *cookie)
775 {
776 struct sk_buff *orig_skb = skb;
777 struct mwifiex_txinfo *tx_info, *orig_tx_info;
778
779 skb = skb_clone(skb, GFP_ATOMIC);
780 if (skb) {
781 unsigned long flags;
782 int id;
783
784 spin_lock_irqsave(&priv->ack_status_lock, flags);
785 id = idr_alloc(&priv->ack_status_frames, orig_skb,
786 1, 0x10, GFP_ATOMIC);
787 spin_unlock_irqrestore(&priv->ack_status_lock, flags);
788
789 if (id >= 0) {
790 tx_info = MWIFIEX_SKB_TXCB(skb);
791 tx_info->ack_frame_id = id;
792 tx_info->flags |= flag;
793 orig_tx_info = MWIFIEX_SKB_TXCB(orig_skb);
794 orig_tx_info->ack_frame_id = id;
795 orig_tx_info->flags |= flag;
796
797 if (flag == MWIFIEX_BUF_FLAG_ACTION_TX_STATUS && cookie)
798 orig_tx_info->cookie = *cookie;
799
800 } else if (skb_shared(skb)) {
801 kfree_skb(orig_skb);
802 } else {
803 kfree_skb(skb);
804 skb = orig_skb;
805 }
806 } else {
807 /* couldn't clone -- lose tx status ... */
808 skb = orig_skb;
809 }
810
811 return skb;
812 }
813
814 /*
815 * CFG802.11 network device handler for data transmission.
816 */
817 static int
818 mwifiex_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
819 {
820 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
821 struct sk_buff *new_skb;
822 struct mwifiex_txinfo *tx_info;
823 bool multicast;
824
825 mwifiex_dbg(priv->adapter, DATA,
826 "data: %lu BSS(%d-%d): Data <= kernel\n",
827 jiffies, priv->bss_type, priv->bss_num);
828
829 if (priv->adapter->surprise_removed) {
830 kfree_skb(skb);
831 priv->stats.tx_dropped++;
832 return 0;
833 }
834 if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
835 mwifiex_dbg(priv->adapter, ERROR,
836 "Tx: bad skb len %d\n", skb->len);
837 kfree_skb(skb);
838 priv->stats.tx_dropped++;
839 return 0;
840 }
841 if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) {
842 mwifiex_dbg(priv->adapter, DATA,
843 "data: Tx: insufficient skb headroom %d\n",
844 skb_headroom(skb));
845 /* Insufficient skb headroom - allocate a new skb */
846 new_skb =
847 skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN);
848 if (unlikely(!new_skb)) {
849 mwifiex_dbg(priv->adapter, ERROR,
850 "Tx: cannot alloca new_skb\n");
851 kfree_skb(skb);
852 priv->stats.tx_dropped++;
853 return 0;
854 }
855 kfree_skb(skb);
856 skb = new_skb;
857 mwifiex_dbg(priv->adapter, INFO,
858 "info: new skb headroomd %d\n",
859 skb_headroom(skb));
860 }
861
862 tx_info = MWIFIEX_SKB_TXCB(skb);
863 memset(tx_info, 0, sizeof(*tx_info));
864 tx_info->bss_num = priv->bss_num;
865 tx_info->bss_type = priv->bss_type;
866 tx_info->pkt_len = skb->len;
867
868 multicast = is_multicast_ether_addr(skb->data);
869
870 if (unlikely(!multicast && skb->sk &&
871 skb_shinfo(skb)->tx_flags & SKBTX_WIFI_STATUS &&
872 priv->adapter->fw_api_ver == MWIFIEX_FW_V15))
873 skb = mwifiex_clone_skb_for_tx_status(priv,
874 skb,
875 MWIFIEX_BUF_FLAG_EAPOL_TX_STATUS, NULL);
876
877 /* Record the current time the packet was queued; used to
878 * determine the amount of time the packet was queued in
879 * the driver before it was sent to the firmware.
880 * The delay is then sent along with the packet to the
881 * firmware for aggregate delay calculation for stats and
882 * MSDU lifetime expiry.
883 */
884 __net_timestamp(skb);
885
886 if (ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) &&
887 priv->bss_type == MWIFIEX_BSS_TYPE_STA &&
888 !ether_addr_equal_unaligned(priv->cfg_bssid, skb->data)) {
889 if (priv->adapter->auto_tdls && priv->check_tdls_tx)
890 mwifiex_tdls_check_tx(priv, skb);
891 }
892
893 mwifiex_queue_tx_pkt(priv, skb);
894
895 return 0;
896 }
897
898 /*
899 * CFG802.11 network device handler for setting MAC address.
900 */
901 static int
902 mwifiex_set_mac_address(struct net_device *dev, void *addr)
903 {
904 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
905 struct sockaddr *hw_addr = addr;
906 int ret;
907
908 memcpy(priv->curr_addr, hw_addr->sa_data, ETH_ALEN);
909
910 /* Send request to firmware */
911 ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_MAC_ADDRESS,
912 HostCmd_ACT_GEN_SET, 0, NULL, true);
913
914 if (!ret)
915 memcpy(priv->netdev->dev_addr, priv->curr_addr, ETH_ALEN);
916 else
917 mwifiex_dbg(priv->adapter, ERROR,
918 "set mac address failed: ret=%d\n", ret);
919
920 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
921
922 return ret;
923 }
924
925 /*
926 * CFG802.11 network device handler for setting multicast list.
927 */
928 static void mwifiex_set_multicast_list(struct net_device *dev)
929 {
930 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
931 struct mwifiex_multicast_list mcast_list;
932
933 if (dev->flags & IFF_PROMISC) {
934 mcast_list.mode = MWIFIEX_PROMISC_MODE;
935 } else if (dev->flags & IFF_ALLMULTI ||
936 netdev_mc_count(dev) > MWIFIEX_MAX_MULTICAST_LIST_SIZE) {
937 mcast_list.mode = MWIFIEX_ALL_MULTI_MODE;
938 } else {
939 mcast_list.mode = MWIFIEX_MULTICAST_MODE;
940 mcast_list.num_multicast_addr =
941 mwifiex_copy_mcast_addr(&mcast_list, dev);
942 }
943 mwifiex_request_set_multicast_list(priv, &mcast_list);
944 }
945
946 /*
947 * CFG802.11 network device handler for transmission timeout.
948 */
949 static void
950 mwifiex_tx_timeout(struct net_device *dev)
951 {
952 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
953
954 priv->num_tx_timeout++;
955 priv->tx_timeout_cnt++;
956 mwifiex_dbg(priv->adapter, ERROR,
957 "%lu : Tx timeout(#%d), bss_type-num = %d-%d\n",
958 jiffies, priv->tx_timeout_cnt, priv->bss_type,
959 priv->bss_num);
960 mwifiex_set_trans_start(dev);
961
962 if (priv->tx_timeout_cnt > TX_TIMEOUT_THRESHOLD &&
963 priv->adapter->if_ops.card_reset) {
964 mwifiex_dbg(priv->adapter, ERROR,
965 "tx_timeout_cnt exceeds threshold.\t"
966 "Triggering card reset!\n");
967 priv->adapter->if_ops.card_reset(priv->adapter);
968 }
969 }
970
971 void mwifiex_multi_chan_resync(struct mwifiex_adapter *adapter)
972 {
973 struct usb_card_rec *card = adapter->card;
974 struct mwifiex_private *priv;
975 u16 tx_buf_size;
976 int i, ret;
977
978 card->mc_resync_flag = true;
979 for (i = 0; i < MWIFIEX_TX_DATA_PORT; i++) {
980 if (atomic_read(&card->port[i].tx_data_urb_pending)) {
981 mwifiex_dbg(adapter, WARN, "pending data urb in sys\n");
982 return;
983 }
984 }
985
986 card->mc_resync_flag = false;
987 tx_buf_size = 0xffff;
988 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
989 ret = mwifiex_send_cmd(priv, HostCmd_CMD_RECONFIGURE_TX_BUFF,
990 HostCmd_ACT_GEN_SET, 0, &tx_buf_size, false);
991 if (ret)
992 mwifiex_dbg(adapter, ERROR,
993 "send reconfig tx buf size cmd err\n");
994 }
995 EXPORT_SYMBOL_GPL(mwifiex_multi_chan_resync);
996
997 void mwifiex_drv_info_dump(struct mwifiex_adapter *adapter)
998 {
999 void *p;
1000 char drv_version[64];
1001 struct usb_card_rec *cardp;
1002 struct sdio_mmc_card *sdio_card;
1003 struct mwifiex_private *priv;
1004 int i, idx;
1005 struct netdev_queue *txq;
1006 struct mwifiex_debug_info *debug_info;
1007
1008 if (adapter->drv_info_dump) {
1009 vfree(adapter->drv_info_dump);
1010 adapter->drv_info_dump = NULL;
1011 adapter->drv_info_size = 0;
1012 }
1013
1014 mwifiex_dbg(adapter, MSG, "===mwifiex driverinfo dump start===\n");
1015
1016 adapter->drv_info_dump = vzalloc(MWIFIEX_DRV_INFO_SIZE_MAX);
1017
1018 if (!adapter->drv_info_dump)
1019 return;
1020
1021 p = (char *)(adapter->drv_info_dump);
1022 p += sprintf(p, "driver_name = " "\"mwifiex\"\n");
1023
1024 mwifiex_drv_get_driver_version(adapter, drv_version,
1025 sizeof(drv_version) - 1);
1026 p += sprintf(p, "driver_version = %s\n", drv_version);
1027
1028 if (adapter->iface_type == MWIFIEX_USB) {
1029 cardp = (struct usb_card_rec *)adapter->card;
1030 p += sprintf(p, "tx_cmd_urb_pending = %d\n",
1031 atomic_read(&cardp->tx_cmd_urb_pending));
1032 p += sprintf(p, "tx_data_urb_pending_port_0 = %d\n",
1033 atomic_read(&cardp->port[0].tx_data_urb_pending));
1034 p += sprintf(p, "tx_data_urb_pending_port_1 = %d\n",
1035 atomic_read(&cardp->port[1].tx_data_urb_pending));
1036 p += sprintf(p, "rx_cmd_urb_pending = %d\n",
1037 atomic_read(&cardp->rx_cmd_urb_pending));
1038 p += sprintf(p, "rx_data_urb_pending = %d\n",
1039 atomic_read(&cardp->rx_data_urb_pending));
1040 }
1041
1042 p += sprintf(p, "tx_pending = %d\n",
1043 atomic_read(&adapter->tx_pending));
1044 p += sprintf(p, "rx_pending = %d\n",
1045 atomic_read(&adapter->rx_pending));
1046
1047 if (adapter->iface_type == MWIFIEX_SDIO) {
1048 sdio_card = (struct sdio_mmc_card *)adapter->card;
1049 p += sprintf(p, "\nmp_rd_bitmap=0x%x curr_rd_port=0x%x\n",
1050 sdio_card->mp_rd_bitmap, sdio_card->curr_rd_port);
1051 p += sprintf(p, "mp_wr_bitmap=0x%x curr_wr_port=0x%x\n",
1052 sdio_card->mp_wr_bitmap, sdio_card->curr_wr_port);
1053 }
1054
1055 for (i = 0; i < adapter->priv_num; i++) {
1056 if (!adapter->priv[i] || !adapter->priv[i]->netdev)
1057 continue;
1058 priv = adapter->priv[i];
1059 p += sprintf(p, "\n[interface : \"%s\"]\n",
1060 priv->netdev->name);
1061 p += sprintf(p, "wmm_tx_pending[0] = %d\n",
1062 atomic_read(&priv->wmm_tx_pending[0]));
1063 p += sprintf(p, "wmm_tx_pending[1] = %d\n",
1064 atomic_read(&priv->wmm_tx_pending[1]));
1065 p += sprintf(p, "wmm_tx_pending[2] = %d\n",
1066 atomic_read(&priv->wmm_tx_pending[2]));
1067 p += sprintf(p, "wmm_tx_pending[3] = %d\n",
1068 atomic_read(&priv->wmm_tx_pending[3]));
1069 p += sprintf(p, "media_state=\"%s\"\n", !priv->media_connected ?
1070 "Disconnected" : "Connected");
1071 p += sprintf(p, "carrier %s\n", (netif_carrier_ok(priv->netdev)
1072 ? "on" : "off"));
1073 for (idx = 0; idx < priv->netdev->num_tx_queues; idx++) {
1074 txq = netdev_get_tx_queue(priv->netdev, idx);
1075 p += sprintf(p, "tx queue %d:%s ", idx,
1076 netif_tx_queue_stopped(txq) ?
1077 "stopped" : "started");
1078 }
1079 p += sprintf(p, "\n%s: num_tx_timeout = %d\n",
1080 priv->netdev->name, priv->num_tx_timeout);
1081 }
1082
1083 if (adapter->iface_type == MWIFIEX_SDIO ||
1084 adapter->iface_type == MWIFIEX_PCIE) {
1085 p += sprintf(p, "\n=== %s register dump===\n",
1086 adapter->iface_type == MWIFIEX_SDIO ?
1087 "SDIO" : "PCIE");
1088 if (adapter->if_ops.reg_dump)
1089 p += adapter->if_ops.reg_dump(adapter, p);
1090 }
1091 p += sprintf(p, "\n=== more debug information\n");
1092 debug_info = kzalloc(sizeof(*debug_info), GFP_KERNEL);
1093 if (debug_info) {
1094 for (i = 0; i < adapter->priv_num; i++) {
1095 if (!adapter->priv[i] || !adapter->priv[i]->netdev)
1096 continue;
1097 priv = adapter->priv[i];
1098 mwifiex_get_debug_info(priv, debug_info);
1099 p += mwifiex_debug_info_to_buffer(priv, p, debug_info);
1100 break;
1101 }
1102 kfree(debug_info);
1103 }
1104
1105 adapter->drv_info_size = p - adapter->drv_info_dump;
1106 mwifiex_dbg(adapter, MSG, "===mwifiex driverinfo dump end===\n");
1107 }
1108 EXPORT_SYMBOL_GPL(mwifiex_drv_info_dump);
1109
1110 void mwifiex_upload_device_dump(struct mwifiex_adapter *adapter)
1111 {
1112 u8 idx, *dump_data, *fw_dump_ptr;
1113 u32 dump_len;
1114
1115 dump_len = (strlen("========Start dump driverinfo========\n") +
1116 adapter->drv_info_size +
1117 strlen("\n========End dump========\n"));
1118
1119 for (idx = 0; idx < adapter->num_mem_types; idx++) {
1120 struct memory_type_mapping *entry =
1121 &adapter->mem_type_mapping_tbl[idx];
1122
1123 if (entry->mem_ptr) {
1124 dump_len += (strlen("========Start dump ") +
1125 strlen(entry->mem_name) +
1126 strlen("========\n") +
1127 (entry->mem_size + 1) +
1128 strlen("\n========End dump========\n"));
1129 }
1130 }
1131
1132 dump_data = vzalloc(dump_len + 1);
1133 if (!dump_data)
1134 goto done;
1135
1136 fw_dump_ptr = dump_data;
1137
1138 /* Dump all the memory data into single file, a userspace script will
1139 * be used to split all the memory data to multiple files
1140 */
1141 mwifiex_dbg(adapter, MSG,
1142 "== mwifiex dump information to /sys/class/devcoredump start");
1143
1144 strcpy(fw_dump_ptr, "========Start dump driverinfo========\n");
1145 fw_dump_ptr += strlen("========Start dump driverinfo========\n");
1146 memcpy(fw_dump_ptr, adapter->drv_info_dump, adapter->drv_info_size);
1147 fw_dump_ptr += adapter->drv_info_size;
1148 strcpy(fw_dump_ptr, "\n========End dump========\n");
1149 fw_dump_ptr += strlen("\n========End dump========\n");
1150
1151 for (idx = 0; idx < adapter->num_mem_types; idx++) {
1152 struct memory_type_mapping *entry =
1153 &adapter->mem_type_mapping_tbl[idx];
1154
1155 if (entry->mem_ptr) {
1156 strcpy(fw_dump_ptr, "========Start dump ");
1157 fw_dump_ptr += strlen("========Start dump ");
1158
1159 strcpy(fw_dump_ptr, entry->mem_name);
1160 fw_dump_ptr += strlen(entry->mem_name);
1161
1162 strcpy(fw_dump_ptr, "========\n");
1163 fw_dump_ptr += strlen("========\n");
1164
1165 memcpy(fw_dump_ptr, entry->mem_ptr, entry->mem_size);
1166 fw_dump_ptr += entry->mem_size;
1167
1168 strcpy(fw_dump_ptr, "\n========End dump========\n");
1169 fw_dump_ptr += strlen("\n========End dump========\n");
1170 }
1171 }
1172
1173 /* device dump data will be free in device coredump release function
1174 * after 5 min
1175 */
1176 dev_coredumpv(adapter->dev, dump_data, dump_len, GFP_KERNEL);
1177 mwifiex_dbg(adapter, MSG,
1178 "== mwifiex dump information to /sys/class/devcoredump end");
1179
1180 done:
1181 for (idx = 0; idx < adapter->num_mem_types; idx++) {
1182 struct memory_type_mapping *entry =
1183 &adapter->mem_type_mapping_tbl[idx];
1184
1185 if (entry->mem_ptr) {
1186 vfree(entry->mem_ptr);
1187 entry->mem_ptr = NULL;
1188 }
1189 entry->mem_size = 0;
1190 }
1191
1192 if (adapter->drv_info_dump) {
1193 vfree(adapter->drv_info_dump);
1194 adapter->drv_info_dump = NULL;
1195 adapter->drv_info_size = 0;
1196 }
1197 }
1198 EXPORT_SYMBOL_GPL(mwifiex_upload_device_dump);
1199
1200 /*
1201 * CFG802.11 network device handler for statistics retrieval.
1202 */
1203 static struct net_device_stats *mwifiex_get_stats(struct net_device *dev)
1204 {
1205 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1206
1207 return &priv->stats;
1208 }
1209
1210 static u16
1211 mwifiex_netdev_select_wmm_queue(struct net_device *dev, struct sk_buff *skb,
1212 void *accel_priv, select_queue_fallback_t fallback)
1213 {
1214 skb->priority = cfg80211_classify8021d(skb, NULL);
1215 return mwifiex_1d_to_wmm_queue[skb->priority];
1216 }
1217
1218 /* Network device handlers */
1219 static const struct net_device_ops mwifiex_netdev_ops = {
1220 .ndo_open = mwifiex_open,
1221 .ndo_stop = mwifiex_close,
1222 .ndo_start_xmit = mwifiex_hard_start_xmit,
1223 .ndo_set_mac_address = mwifiex_set_mac_address,
1224 .ndo_validate_addr = eth_validate_addr,
1225 .ndo_tx_timeout = mwifiex_tx_timeout,
1226 .ndo_get_stats = mwifiex_get_stats,
1227 .ndo_set_rx_mode = mwifiex_set_multicast_list,
1228 .ndo_select_queue = mwifiex_netdev_select_wmm_queue,
1229 };
1230
1231 /*
1232 * This function initializes the private structure parameters.
1233 *
1234 * The following wait queues are initialized -
1235 * - IOCTL wait queue
1236 * - Command wait queue
1237 * - Statistics wait queue
1238 *
1239 * ...and the following default parameters are set -
1240 * - Current key index : Set to 0
1241 * - Rate index : Set to auto
1242 * - Media connected : Set to disconnected
1243 * - Adhoc link sensed : Set to false
1244 * - Nick name : Set to null
1245 * - Number of Tx timeout : Set to 0
1246 * - Device address : Set to current address
1247 * - Rx histogram statistc : Set to 0
1248 *
1249 * In addition, the CFG80211 work queue is also created.
1250 */
1251 void mwifiex_init_priv_params(struct mwifiex_private *priv,
1252 struct net_device *dev)
1253 {
1254 dev->netdev_ops = &mwifiex_netdev_ops;
1255 dev->destructor = free_netdev;
1256 /* Initialize private structure */
1257 priv->current_key_index = 0;
1258 priv->media_connected = false;
1259 memset(priv->mgmt_ie, 0,
1260 sizeof(struct mwifiex_ie) * MAX_MGMT_IE_INDEX);
1261 priv->beacon_idx = MWIFIEX_AUTO_IDX_MASK;
1262 priv->proberesp_idx = MWIFIEX_AUTO_IDX_MASK;
1263 priv->assocresp_idx = MWIFIEX_AUTO_IDX_MASK;
1264 priv->gen_idx = MWIFIEX_AUTO_IDX_MASK;
1265 priv->num_tx_timeout = 0;
1266 ether_addr_copy(priv->curr_addr, priv->adapter->perm_addr);
1267 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
1268
1269 if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA ||
1270 GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) {
1271 priv->hist_data = kmalloc(sizeof(*priv->hist_data), GFP_KERNEL);
1272 if (priv->hist_data)
1273 mwifiex_hist_data_reset(priv);
1274 }
1275 }
1276
1277 /*
1278 * This function check if command is pending.
1279 */
1280 int is_command_pending(struct mwifiex_adapter *adapter)
1281 {
1282 unsigned long flags;
1283 int is_cmd_pend_q_empty;
1284
1285 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
1286 is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
1287 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
1288
1289 return !is_cmd_pend_q_empty;
1290 }
1291
1292 /*
1293 * This is the RX work queue function.
1294 *
1295 * It handles the RX operations.
1296 */
1297 static void mwifiex_rx_work_queue(struct work_struct *work)
1298 {
1299 struct mwifiex_adapter *adapter =
1300 container_of(work, struct mwifiex_adapter, rx_work);
1301
1302 if (adapter->surprise_removed)
1303 return;
1304 mwifiex_process_rx(adapter);
1305 }
1306
1307 /*
1308 * This is the main work queue function.
1309 *
1310 * It handles the main process, which in turn handles the complete
1311 * driver operations.
1312 */
1313 static void mwifiex_main_work_queue(struct work_struct *work)
1314 {
1315 struct mwifiex_adapter *adapter =
1316 container_of(work, struct mwifiex_adapter, main_work);
1317
1318 if (adapter->surprise_removed)
1319 return;
1320 mwifiex_main_process(adapter);
1321 }
1322
1323 /*
1324 * This function adds the card.
1325 *
1326 * This function follows the following major steps to set up the device -
1327 * - Initialize software. This includes probing the card, registering
1328 * the interface operations table, and allocating/initializing the
1329 * adapter structure
1330 * - Set up the netlink socket
1331 * - Create and start the main work queue
1332 * - Register the device
1333 * - Initialize firmware and hardware
1334 * - Add logical interfaces
1335 */
1336 int
1337 mwifiex_add_card(void *card, struct semaphore *sem,
1338 struct mwifiex_if_ops *if_ops, u8 iface_type)
1339 {
1340 struct mwifiex_adapter *adapter;
1341
1342 if (down_interruptible(sem))
1343 goto exit_sem_err;
1344
1345 if (mwifiex_register(card, if_ops, (void **)&adapter)) {
1346 pr_err("%s: software init failed\n", __func__);
1347 goto err_init_sw;
1348 }
1349
1350 adapter->iface_type = iface_type;
1351 adapter->card_sem = sem;
1352
1353 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
1354 adapter->surprise_removed = false;
1355 init_waitqueue_head(&adapter->init_wait_q);
1356 adapter->is_suspended = false;
1357 adapter->hs_activated = false;
1358 init_waitqueue_head(&adapter->hs_activate_wait_q);
1359 init_waitqueue_head(&adapter->cmd_wait_q.wait);
1360 adapter->cmd_wait_q.status = 0;
1361 adapter->scan_wait_q_woken = false;
1362
1363 if ((num_possible_cpus() > 1) || adapter->iface_type == MWIFIEX_USB) {
1364 adapter->rx_work_enabled = true;
1365 pr_notice("rx work enabled, cpus %d\n", num_possible_cpus());
1366 }
1367
1368 adapter->workqueue =
1369 alloc_workqueue("MWIFIEX_WORK_QUEUE",
1370 WQ_HIGHPRI | WQ_MEM_RECLAIM | WQ_UNBOUND, 1);
1371 if (!adapter->workqueue)
1372 goto err_kmalloc;
1373
1374 INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
1375
1376 if (adapter->rx_work_enabled) {
1377 adapter->rx_workqueue = alloc_workqueue("MWIFIEX_RX_WORK_QUEUE",
1378 WQ_HIGHPRI |
1379 WQ_MEM_RECLAIM |
1380 WQ_UNBOUND, 1);
1381 if (!adapter->rx_workqueue)
1382 goto err_kmalloc;
1383
1384 INIT_WORK(&adapter->rx_work, mwifiex_rx_work_queue);
1385 }
1386
1387 /* Register the device. Fill up the private data structure with relevant
1388 information from the card. */
1389 if (adapter->if_ops.register_dev(adapter)) {
1390 pr_err("%s: failed to register mwifiex device\n", __func__);
1391 goto err_registerdev;
1392 }
1393
1394 if (mwifiex_init_hw_fw(adapter)) {
1395 pr_err("%s: firmware init failed\n", __func__);
1396 goto err_init_fw;
1397 }
1398
1399 return 0;
1400
1401 err_init_fw:
1402 pr_debug("info: %s: unregister device\n", __func__);
1403 if (adapter->if_ops.unregister_dev)
1404 adapter->if_ops.unregister_dev(adapter);
1405 if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) {
1406 pr_debug("info: %s: shutdown mwifiex\n", __func__);
1407 adapter->init_wait_q_woken = false;
1408
1409 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
1410 wait_event_interruptible(adapter->init_wait_q,
1411 adapter->init_wait_q_woken);
1412 }
1413 err_registerdev:
1414 adapter->surprise_removed = true;
1415 mwifiex_terminate_workqueue(adapter);
1416 err_kmalloc:
1417 mwifiex_free_adapter(adapter);
1418
1419 err_init_sw:
1420 up(sem);
1421
1422 exit_sem_err:
1423 return -1;
1424 }
1425 EXPORT_SYMBOL_GPL(mwifiex_add_card);
1426
1427 /*
1428 * This function removes the card.
1429 *
1430 * This function follows the following major steps to remove the device -
1431 * - Stop data traffic
1432 * - Shutdown firmware
1433 * - Remove the logical interfaces
1434 * - Terminate the work queue
1435 * - Unregister the device
1436 * - Free the adapter structure
1437 */
1438 int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem)
1439 {
1440 struct mwifiex_private *priv = NULL;
1441 int i;
1442
1443 if (down_trylock(sem))
1444 goto exit_sem_err;
1445
1446 if (!adapter)
1447 goto exit_remove;
1448
1449 /* We can no longer handle interrupts once we start doing the teardown
1450 * below. */
1451 if (adapter->if_ops.disable_int)
1452 adapter->if_ops.disable_int(adapter);
1453
1454 adapter->surprise_removed = true;
1455
1456 mwifiex_terminate_workqueue(adapter);
1457
1458 /* Stop data */
1459 for (i = 0; i < adapter->priv_num; i++) {
1460 priv = adapter->priv[i];
1461 if (priv && priv->netdev) {
1462 mwifiex_stop_net_dev_queue(priv->netdev, adapter);
1463 if (netif_carrier_ok(priv->netdev))
1464 netif_carrier_off(priv->netdev);
1465 }
1466 }
1467
1468 mwifiex_dbg(adapter, CMD,
1469 "cmd: calling mwifiex_shutdown_drv...\n");
1470 adapter->init_wait_q_woken = false;
1471
1472 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
1473 wait_event_interruptible(adapter->init_wait_q,
1474 adapter->init_wait_q_woken);
1475 mwifiex_dbg(adapter, CMD,
1476 "cmd: mwifiex_shutdown_drv done\n");
1477 if (atomic_read(&adapter->rx_pending) ||
1478 atomic_read(&adapter->tx_pending) ||
1479 atomic_read(&adapter->cmd_pending)) {
1480 mwifiex_dbg(adapter, ERROR,
1481 "rx_pending=%d, tx_pending=%d,\t"
1482 "cmd_pending=%d\n",
1483 atomic_read(&adapter->rx_pending),
1484 atomic_read(&adapter->tx_pending),
1485 atomic_read(&adapter->cmd_pending));
1486 }
1487
1488 for (i = 0; i < adapter->priv_num; i++) {
1489 priv = adapter->priv[i];
1490
1491 if (!priv)
1492 continue;
1493
1494 rtnl_lock();
1495 if (priv->netdev &&
1496 priv->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED)
1497 mwifiex_del_virtual_intf(adapter->wiphy, &priv->wdev);
1498 rtnl_unlock();
1499 }
1500
1501 wiphy_unregister(adapter->wiphy);
1502 wiphy_free(adapter->wiphy);
1503
1504 /* Unregister device */
1505 mwifiex_dbg(adapter, INFO,
1506 "info: unregister device\n");
1507 if (adapter->if_ops.unregister_dev)
1508 adapter->if_ops.unregister_dev(adapter);
1509 /* Free adapter structure */
1510 mwifiex_dbg(adapter, INFO,
1511 "info: free adapter\n");
1512 mwifiex_free_adapter(adapter);
1513
1514 exit_remove:
1515 up(sem);
1516 exit_sem_err:
1517 return 0;
1518 }
1519 EXPORT_SYMBOL_GPL(mwifiex_remove_card);
1520
1521 void _mwifiex_dbg(const struct mwifiex_adapter *adapter, int mask,
1522 const char *fmt, ...)
1523 {
1524 struct va_format vaf;
1525 va_list args;
1526
1527 if (!adapter->dev || !(adapter->debug_mask & mask))
1528 return;
1529
1530 va_start(args, fmt);
1531
1532 vaf.fmt = fmt;
1533 vaf.va = &args;
1534
1535 dev_info(adapter->dev, "%pV", &vaf);
1536
1537 va_end(args);
1538 }
1539 EXPORT_SYMBOL_GPL(_mwifiex_dbg);
1540
1541 /*
1542 * This function initializes the module.
1543 *
1544 * The debug FS is also initialized if configured.
1545 */
1546 static int
1547 mwifiex_init_module(void)
1548 {
1549 #ifdef CONFIG_DEBUG_FS
1550 mwifiex_debugfs_init();
1551 #endif
1552 return 0;
1553 }
1554
1555 /*
1556 * This function cleans up the module.
1557 *
1558 * The debug FS is removed if available.
1559 */
1560 static void
1561 mwifiex_cleanup_module(void)
1562 {
1563 #ifdef CONFIG_DEBUG_FS
1564 mwifiex_debugfs_remove();
1565 #endif
1566 }
1567
1568 module_init(mwifiex_init_module);
1569 module_exit(mwifiex_cleanup_module);
1570
1571 MODULE_AUTHOR("Marvell International Ltd.");
1572 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION);
1573 MODULE_VERSION(VERSION);
1574 MODULE_LICENSE("GPL v2");
Linux kernel - Deliverables
This page took 0.093688 seconds and 5 git commands to generate.