2 * Marvell Wireless LAN device driver: major functions
4 * Copyright (C) 2011, Marvell International Ltd.
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.
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.
27 const char driver_version
[] = "mwifiex " VERSION
" (%s) ";
30 * This function registers the device and performs all the necessary
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
41 * In case of any errors during inittialization, this function also ensures
42 * proper cleanup before exiting.
44 static int mwifiex_register(void *card
, struct mwifiex_if_ops
*if_ops
,
47 struct mwifiex_adapter
*adapter
;
50 adapter
= kzalloc(sizeof(struct mwifiex_adapter
), GFP_KERNEL
);
57 /* Save interface specific operations in adapter */
58 memmove(&adapter
->if_ops
, if_ops
, sizeof(struct mwifiex_if_ops
));
60 /* card specific initialization has been deferred until now .. */
61 if (adapter
->if_ops
.init_if(adapter
))
64 adapter
->priv_num
= 0;
66 /* Allocate memory for private structure */
67 adapter
->priv
[0] = kzalloc(sizeof(struct mwifiex_private
), GFP_KERNEL
);
68 if (!adapter
->priv
[0]) {
70 "%s: failed to alloc priv[0]\n", __func__
);
76 adapter
->priv
[0]->adapter
= adapter
;
77 mwifiex_init_lock_list(adapter
);
79 init_timer(&adapter
->cmd_timer
);
80 adapter
->cmd_timer
.function
= mwifiex_cmd_timeout_func
;
81 adapter
->cmd_timer
.data
= (unsigned long) adapter
;
86 dev_dbg(adapter
->dev
, "info: leave mwifiex_register with error\n");
88 for (i
= 0; i
< adapter
->priv_num
; i
++)
89 kfree(adapter
->priv
[i
]);
97 * This function unregisters the device and performs all the necessary
100 * The following cleanup operations are performed -
102 * - Free beacon buffers
103 * - Free private structures
104 * - Free adapter structure
106 static int mwifiex_unregister(struct mwifiex_adapter
*adapter
)
110 del_timer(&adapter
->cmd_timer
);
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
]);
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.
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
139 int mwifiex_main_process(struct mwifiex_adapter
*adapter
)
144 spin_lock_irqsave(&adapter
->main_proc_lock
, flags
);
146 /* Check if already processing */
147 if (adapter
->mwifiex_processing
) {
148 spin_unlock_irqrestore(&adapter
->main_proc_lock
, flags
);
151 adapter
->mwifiex_processing
= true;
152 spin_unlock_irqrestore(&adapter
->main_proc_lock
, flags
);
156 if ((adapter
->hw_status
== MWIFIEX_HW_STATUS_CLOSING
) ||
157 (adapter
->hw_status
== MWIFIEX_HW_STATUS_NOT_READY
))
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
);
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
);
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
;
182 /* We have tried to wakeup the card already */
183 if (adapter
->pm_wakeup_fw_try
)
185 if (adapter
->ps_state
!= PS_STATE_AWAKE
||
186 adapter
->tx_lock_flag
)
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
)))
197 /* Check for Cmd Resp */
198 if (adapter
->cmd_resp_received
) {
199 adapter
->cmd_resp_received
= false;
200 mwifiex_process_cmdresp(adapter
);
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
);
209 /* Check for event */
210 if (adapter
->event_received
) {
211 adapter
->event_received
= false;
212 mwifiex_process_event(adapter
);
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
);
222 /* * The ps_state may have been changed during processing of
223 * Sleep Request event.
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
)
231 if (!adapter
->cmd_sent
&& !adapter
->curr_cmd
) {
232 if (mwifiex_exec_next_cmd(adapter
) == -1) {
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
245 (adapter
, MWIFIEX_BSS_ROLE_ANY
),
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
;
264 if ((adapter
->int_status
) || IS_CARD_RX_RCVD(adapter
))
267 spin_lock_irqsave(&adapter
->main_proc_lock
, flags
);
268 adapter
->mwifiex_processing
= false;
269 spin_unlock_irqrestore(&adapter
->main_proc_lock
, flags
);
272 if (adapter
->hw_status
== MWIFIEX_HW_STATUS_CLOSING
)
273 mwifiex_shutdown_drv(adapter
);
278 * This function frees the adapter structure.
280 * Additionally, this closes the netlink socket, frees the timers
281 * and private structures.
283 static void mwifiex_free_adapter(struct mwifiex_adapter
*adapter
)
286 pr_err("%s: adapter is NULL\n", __func__
);
290 mwifiex_unregister(adapter
);
291 pr_debug("info: %s: free adapter\n", __func__
);
295 * This function gets firmware and initializes it.
297 * The main initialization steps followed are -
298 * - Download the correct firmware to card
299 * - Issue the init commands to firmware
301 static void mwifiex_fw_dpc(const struct firmware
*firmware
, void *context
)
305 struct mwifiex_private
*priv
;
306 struct mwifiex_adapter
*adapter
= context
;
307 struct mwifiex_fw_image fw
;
310 dev_err(adapter
->dev
,
311 "Failed to get firmware %s\n", adapter
->fw_name
);
315 memset(&fw
, 0, sizeof(struct mwifiex_fw_image
));
316 adapter
->firmware
= firmware
;
317 fw
.fw_buf
= (u8
*) adapter
->firmware
->data
;
318 fw
.fw_len
= adapter
->firmware
->size
;
320 ret
= mwifiex_dnld_fw(adapter
, &fw
);
324 dev_notice(adapter
->dev
, "WLAN FW is active\n");
326 adapter
->init_wait_q_woken
= false;
327 ret
= mwifiex_init_fw(adapter
);
331 adapter
->hw_status
= MWIFIEX_HW_STATUS_READY
;
334 /* Wait for mwifiex_init to complete */
335 wait_event_interruptible(adapter
->init_wait_q
,
336 adapter
->init_wait_q_woken
);
337 if (adapter
->hw_status
!= MWIFIEX_HW_STATUS_READY
)
340 priv
= adapter
->priv
[0];
341 if (mwifiex_register_cfg80211(priv
) != 0) {
342 dev_err(adapter
->dev
, "cannot register with cfg80211\n");
347 /* Create station interface by default */
348 if (!mwifiex_add_virtual_intf(priv
->wdev
->wiphy
, "mlan%d",
349 NL80211_IFTYPE_STATION
, NULL
, NULL
)) {
350 dev_err(adapter
->dev
, "cannot create default STA interface\n");
355 mwifiex_drv_get_driver_version(adapter
, fmt
, sizeof(fmt
) - 1);
356 dev_notice(adapter
->dev
, "driver_version = %s\n", fmt
);
360 mwifiex_del_virtual_intf(priv
->wdev
->wiphy
, priv
->netdev
);
363 pr_debug("info: %s: unregister device\n", __func__
);
364 adapter
->if_ops
.unregister_dev(adapter
);
366 release_firmware(adapter
->firmware
);
367 complete(&adapter
->fw_load
);
372 * This function initializes the hardware and gets firmware.
374 static int mwifiex_init_hw_fw(struct mwifiex_adapter
*adapter
)
378 init_completion(&adapter
->fw_load
);
379 ret
= request_firmware_nowait(THIS_MODULE
, 1, adapter
->fw_name
,
380 adapter
->dev
, GFP_KERNEL
, adapter
,
383 dev_err(adapter
->dev
,
384 "request_firmware_nowait() returned error %d\n", ret
);
389 * This function fills a driver buffer.
391 * The function associates a given SKB with the provided driver buffer
392 * and also updates some of the SKB parameters, including IP header,
393 * priority and timestamp.
396 mwifiex_fill_buffer(struct sk_buff
*skb
)
403 eth
= (struct ethhdr
*) skb
->data
;
404 switch (eth
->h_proto
) {
405 case __constant_htons(ETH_P_IP
):
407 tid
= IPTOS_PREC(iph
->tos
);
408 pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n",
409 eth
->h_proto
, tid
, skb
->priority
);
411 case __constant_htons(ETH_P_ARP
):
412 pr_debug("data: ARP packet: %04x\n", eth
->h_proto
);
416 /* Offset for TOS field in the IP header */
417 #define IPTOS_OFFSET 5
418 tid
= (tid
>> IPTOS_OFFSET
);
420 /* Record the current time the packet was queued; used to
421 determine the amount of time the packet was queued in
422 the driver before it was sent to the firmware.
423 The delay is then sent along with the packet to the
424 firmware for aggregate delay calculation for stats and
425 MSDU lifetime expiry.
427 do_gettimeofday(&tv
);
428 skb
->tstamp
= timeval_to_ktime(tv
);
432 * CFG802.11 network device handler for open.
434 * Starts the data queue.
437 mwifiex_open(struct net_device
*dev
)
439 netif_tx_start_all_queues(dev
);
444 * CFG802.11 network device handler for close.
447 mwifiex_close(struct net_device
*dev
)
453 * CFG802.11 network device handler for data transmission.
456 mwifiex_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
458 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
459 struct sk_buff
*new_skb
;
460 struct mwifiex_txinfo
*tx_info
;
462 dev_dbg(priv
->adapter
->dev
, "data: %lu BSS(%d-%d): Data <= kernel\n",
463 jiffies
, priv
->bss_type
, priv
->bss_num
);
465 if (priv
->adapter
->surprise_removed
) {
467 priv
->stats
.tx_dropped
++;
470 if (!skb
->len
|| (skb
->len
> ETH_FRAME_LEN
)) {
471 dev_err(priv
->adapter
->dev
, "Tx: bad skb len %d\n", skb
->len
);
473 priv
->stats
.tx_dropped
++;
476 if (skb_headroom(skb
) < MWIFIEX_MIN_DATA_HEADER_LEN
) {
477 dev_dbg(priv
->adapter
->dev
,
478 "data: Tx: insufficient skb headroom %d\n",
480 /* Insufficient skb headroom - allocate a new skb */
482 skb_realloc_headroom(skb
, MWIFIEX_MIN_DATA_HEADER_LEN
);
483 if (unlikely(!new_skb
)) {
484 dev_err(priv
->adapter
->dev
, "Tx: cannot alloca new_skb\n");
486 priv
->stats
.tx_dropped
++;
491 dev_dbg(priv
->adapter
->dev
, "info: new skb headroomd %d\n",
495 tx_info
= MWIFIEX_SKB_TXCB(skb
);
496 tx_info
->bss_num
= priv
->bss_num
;
497 tx_info
->bss_type
= priv
->bss_type
;
498 mwifiex_fill_buffer(skb
);
500 mwifiex_wmm_add_buf_txqueue(priv
, skb
);
501 atomic_inc(&priv
->adapter
->tx_pending
);
503 if (atomic_read(&priv
->adapter
->tx_pending
) >= MAX_TX_PENDING
) {
504 mwifiex_set_trans_start(dev
);
505 mwifiex_stop_net_dev_queue(priv
->netdev
, priv
->adapter
);
508 queue_work(priv
->adapter
->workqueue
, &priv
->adapter
->main_work
);
514 * CFG802.11 network device handler for setting MAC address.
517 mwifiex_set_mac_address(struct net_device
*dev
, void *addr
)
519 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
520 struct sockaddr
*hw_addr
= addr
;
523 memcpy(priv
->curr_addr
, hw_addr
->sa_data
, ETH_ALEN
);
525 /* Send request to firmware */
526 ret
= mwifiex_send_cmd_sync(priv
, HostCmd_CMD_802_11_MAC_ADDRESS
,
527 HostCmd_ACT_GEN_SET
, 0, NULL
);
530 memcpy(priv
->netdev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
532 dev_err(priv
->adapter
->dev
,
533 "set mac address failed: ret=%d\n", ret
);
535 memcpy(dev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
541 * CFG802.11 network device handler for setting multicast list.
543 static void mwifiex_set_multicast_list(struct net_device
*dev
)
545 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
546 struct mwifiex_multicast_list mcast_list
;
548 if (dev
->flags
& IFF_PROMISC
) {
549 mcast_list
.mode
= MWIFIEX_PROMISC_MODE
;
550 } else if (dev
->flags
& IFF_ALLMULTI
||
551 netdev_mc_count(dev
) > MWIFIEX_MAX_MULTICAST_LIST_SIZE
) {
552 mcast_list
.mode
= MWIFIEX_ALL_MULTI_MODE
;
554 mcast_list
.mode
= MWIFIEX_MULTICAST_MODE
;
555 if (netdev_mc_count(dev
))
556 mcast_list
.num_multicast_addr
=
557 mwifiex_copy_mcast_addr(&mcast_list
, dev
);
559 mwifiex_request_set_multicast_list(priv
, &mcast_list
);
563 * CFG802.11 network device handler for transmission timeout.
566 mwifiex_tx_timeout(struct net_device
*dev
)
568 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
570 dev_err(priv
->adapter
->dev
, "%lu : Tx timeout, bss_type-num = %d-%d\n",
571 jiffies
, priv
->bss_type
, priv
->bss_num
);
572 mwifiex_set_trans_start(dev
);
573 priv
->num_tx_timeout
++;
577 * CFG802.11 network device handler for statistics retrieval.
579 static struct net_device_stats
*mwifiex_get_stats(struct net_device
*dev
)
581 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
586 /* Network device handlers */
587 static const struct net_device_ops mwifiex_netdev_ops
= {
588 .ndo_open
= mwifiex_open
,
589 .ndo_stop
= mwifiex_close
,
590 .ndo_start_xmit
= mwifiex_hard_start_xmit
,
591 .ndo_set_mac_address
= mwifiex_set_mac_address
,
592 .ndo_tx_timeout
= mwifiex_tx_timeout
,
593 .ndo_get_stats
= mwifiex_get_stats
,
594 .ndo_set_rx_mode
= mwifiex_set_multicast_list
,
598 * This function initializes the private structure parameters.
600 * The following wait queues are initialized -
602 * - Command wait queue
603 * - Statistics wait queue
605 * ...and the following default parameters are set -
606 * - Current key index : Set to 0
607 * - Rate index : Set to auto
608 * - Media connected : Set to disconnected
609 * - Adhoc link sensed : Set to false
610 * - Nick name : Set to null
611 * - Number of Tx timeout : Set to 0
612 * - Device address : Set to current address
614 * In addition, the CFG80211 work queue is also created.
616 void mwifiex_init_priv_params(struct mwifiex_private
*priv
,
617 struct net_device
*dev
)
619 dev
->netdev_ops
= &mwifiex_netdev_ops
;
620 /* Initialize private structure */
621 priv
->current_key_index
= 0;
622 priv
->media_connected
= false;
623 memset(&priv
->nick_name
, 0, sizeof(priv
->nick_name
));
624 priv
->num_tx_timeout
= 0;
625 memcpy(dev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
629 * This function check if command is pending.
631 int is_command_pending(struct mwifiex_adapter
*adapter
)
634 int is_cmd_pend_q_empty
;
636 spin_lock_irqsave(&adapter
->cmd_pending_q_lock
, flags
);
637 is_cmd_pend_q_empty
= list_empty(&adapter
->cmd_pending_q
);
638 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
, flags
);
640 return !is_cmd_pend_q_empty
;
644 * This is the main work queue function.
646 * It handles the main process, which in turn handles the complete
649 static void mwifiex_main_work_queue(struct work_struct
*work
)
651 struct mwifiex_adapter
*adapter
=
652 container_of(work
, struct mwifiex_adapter
, main_work
);
654 if (adapter
->surprise_removed
)
656 mwifiex_main_process(adapter
);
660 * This function cancels all works in the queue and destroys
661 * the main workqueue.
664 mwifiex_terminate_workqueue(struct mwifiex_adapter
*adapter
)
666 flush_workqueue(adapter
->workqueue
);
667 destroy_workqueue(adapter
->workqueue
);
668 adapter
->workqueue
= NULL
;
672 * This function adds the card.
674 * This function follows the following major steps to set up the device -
675 * - Initialize software. This includes probing the card, registering
676 * the interface operations table, and allocating/initializing the
678 * - Set up the netlink socket
679 * - Create and start the main work queue
680 * - Register the device
681 * - Initialize firmware and hardware
682 * - Add logical interfaces
685 mwifiex_add_card(void *card
, struct semaphore
*sem
,
686 struct mwifiex_if_ops
*if_ops
, u8 iface_type
)
688 struct mwifiex_adapter
*adapter
;
690 if (down_interruptible(sem
))
693 if (mwifiex_register(card
, if_ops
, (void **)&adapter
)) {
694 pr_err("%s: software init failed\n", __func__
);
698 adapter
->iface_type
= iface_type
;
700 adapter
->hw_status
= MWIFIEX_HW_STATUS_INITIALIZING
;
701 adapter
->surprise_removed
= false;
702 init_waitqueue_head(&adapter
->init_wait_q
);
703 adapter
->is_suspended
= false;
704 adapter
->hs_activated
= false;
705 init_waitqueue_head(&adapter
->hs_activate_wait_q
);
706 adapter
->cmd_wait_q_required
= false;
707 init_waitqueue_head(&adapter
->cmd_wait_q
.wait
);
708 adapter
->cmd_wait_q
.status
= 0;
709 adapter
->scan_wait_q_woken
= false;
711 adapter
->workqueue
= create_workqueue("MWIFIEX_WORK_QUEUE");
712 if (!adapter
->workqueue
)
715 INIT_WORK(&adapter
->main_work
, mwifiex_main_work_queue
);
717 /* Register the device. Fill up the private data structure with relevant
718 information from the card and request for the required IRQ. */
719 if (adapter
->if_ops
.register_dev(adapter
)) {
720 pr_err("%s: failed to register mwifiex device\n", __func__
);
721 goto err_registerdev
;
724 if (mwifiex_init_hw_fw(adapter
)) {
725 pr_err("%s: firmware init failed\n", __func__
);
733 pr_debug("info: %s: unregister device\n", __func__
);
734 adapter
->if_ops
.unregister_dev(adapter
);
736 adapter
->surprise_removed
= true;
737 mwifiex_terminate_workqueue(adapter
);
739 if ((adapter
->hw_status
== MWIFIEX_HW_STATUS_FW_READY
) ||
740 (adapter
->hw_status
== MWIFIEX_HW_STATUS_READY
)) {
741 pr_debug("info: %s: shutdown mwifiex\n", __func__
);
742 adapter
->init_wait_q_woken
= false;
744 if (mwifiex_shutdown_drv(adapter
) == -EINPROGRESS
)
745 wait_event_interruptible(adapter
->init_wait_q
,
746 adapter
->init_wait_q_woken
);
749 mwifiex_free_adapter(adapter
);
757 EXPORT_SYMBOL_GPL(mwifiex_add_card
);
760 * This function removes the card.
762 * This function follows the following major steps to remove the device -
763 * - Stop data traffic
764 * - Shutdown firmware
765 * - Remove the logical interfaces
766 * - Terminate the work queue
767 * - Unregister the device
768 * - Free the adapter structure
770 int mwifiex_remove_card(struct mwifiex_adapter
*adapter
, struct semaphore
*sem
)
772 struct mwifiex_private
*priv
= NULL
;
775 if (down_interruptible(sem
))
781 adapter
->surprise_removed
= true;
784 for (i
= 0; i
< adapter
->priv_num
; i
++) {
785 priv
= adapter
->priv
[i
];
786 if (priv
&& priv
->netdev
) {
787 if (!netif_queue_stopped(priv
->netdev
))
788 mwifiex_stop_net_dev_queue(priv
->netdev
,
790 if (netif_carrier_ok(priv
->netdev
))
791 netif_carrier_off(priv
->netdev
);
795 dev_dbg(adapter
->dev
, "cmd: calling mwifiex_shutdown_drv...\n");
796 adapter
->init_wait_q_woken
= false;
798 if (mwifiex_shutdown_drv(adapter
) == -EINPROGRESS
)
799 wait_event_interruptible(adapter
->init_wait_q
,
800 adapter
->init_wait_q_woken
);
801 dev_dbg(adapter
->dev
, "cmd: mwifiex_shutdown_drv done\n");
802 if (atomic_read(&adapter
->rx_pending
) ||
803 atomic_read(&adapter
->tx_pending
) ||
804 atomic_read(&adapter
->cmd_pending
)) {
805 dev_err(adapter
->dev
, "rx_pending=%d, tx_pending=%d, "
807 atomic_read(&adapter
->rx_pending
),
808 atomic_read(&adapter
->tx_pending
),
809 atomic_read(&adapter
->cmd_pending
));
812 for (i
= 0; i
< adapter
->priv_num
; i
++) {
813 priv
= adapter
->priv
[i
];
819 if (priv
->wdev
&& priv
->netdev
)
820 mwifiex_del_virtual_intf(priv
->wdev
->wiphy
,
825 priv
= adapter
->priv
[0];
830 wiphy_unregister(priv
->wdev
->wiphy
);
831 wiphy_free(priv
->wdev
->wiphy
);
835 mwifiex_terminate_workqueue(adapter
);
837 /* Unregister device */
838 dev_dbg(adapter
->dev
, "info: unregister device\n");
839 adapter
->if_ops
.unregister_dev(adapter
);
840 /* Free adapter structure */
841 dev_dbg(adapter
->dev
, "info: free adapter\n");
842 mwifiex_free_adapter(adapter
);
849 EXPORT_SYMBOL_GPL(mwifiex_remove_card
);
852 * This function initializes the module.
854 * The debug FS is also initialized if configured.
857 mwifiex_init_module(void)
859 #ifdef CONFIG_DEBUG_FS
860 mwifiex_debugfs_init();
866 * This function cleans up the module.
868 * The debug FS is removed if available.
871 mwifiex_cleanup_module(void)
873 #ifdef CONFIG_DEBUG_FS
874 mwifiex_debugfs_remove();
878 module_init(mwifiex_init_module
);
879 module_exit(mwifiex_cleanup_module
);
881 MODULE_AUTHOR("Marvell International Ltd.");
882 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION
);
883 MODULE_VERSION(VERSION
);
884 MODULE_LICENSE("GPL v2");