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 initializes the hardware and firmware.
297 * The main initialization steps followed are -
298 * - Download the correct firmware to card
299 * - Allocate and initialize the adapter structure
300 * - Initialize the private structures
301 * - Issue the init commands to firmware
303 static int mwifiex_init_hw_fw(struct mwifiex_adapter
*adapter
)
306 struct mwifiex_fw_image fw
;
308 memset(&fw
, 0, sizeof(struct mwifiex_fw_image
));
310 err
= request_firmware(&adapter
->firmware
, adapter
->fw_name
,
313 dev_err(adapter
->dev
, "request_firmware() returned"
314 " error code %#x\n", err
);
318 fw
.fw_buf
= (u8
*) adapter
->firmware
->data
;
319 fw
.fw_len
= adapter
->firmware
->size
;
321 ret
= mwifiex_dnld_fw(adapter
, &fw
);
325 dev_notice(adapter
->dev
, "WLAN FW is active\n");
327 adapter
->init_wait_q_woken
= false;
328 ret
= mwifiex_init_fw(adapter
);
332 adapter
->hw_status
= MWIFIEX_HW_STATUS_READY
;
335 /* Wait for mwifiex_init to complete */
336 wait_event_interruptible(adapter
->init_wait_q
,
337 adapter
->init_wait_q_woken
);
338 if (adapter
->hw_status
!= MWIFIEX_HW_STATUS_READY
) {
345 if (adapter
->firmware
)
346 release_firmware(adapter
->firmware
);
353 * This function fills a driver buffer.
355 * The function associates a given SKB with the provided driver buffer
356 * and also updates some of the SKB parameters, including IP header,
357 * priority and timestamp.
360 mwifiex_fill_buffer(struct sk_buff
*skb
)
367 eth
= (struct ethhdr
*) skb
->data
;
368 switch (eth
->h_proto
) {
369 case __constant_htons(ETH_P_IP
):
371 tid
= IPTOS_PREC(iph
->tos
);
372 pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n",
373 eth
->h_proto
, tid
, skb
->priority
);
375 case __constant_htons(ETH_P_ARP
):
376 pr_debug("data: ARP packet: %04x\n", eth
->h_proto
);
380 /* Offset for TOS field in the IP header */
381 #define IPTOS_OFFSET 5
382 tid
= (tid
>> IPTOS_OFFSET
);
384 /* Record the current time the packet was queued; used to
385 determine the amount of time the packet was queued in
386 the driver before it was sent to the firmware.
387 The delay is then sent along with the packet to the
388 firmware for aggregate delay calculation for stats and
389 MSDU lifetime expiry.
391 do_gettimeofday(&tv
);
392 skb
->tstamp
= timeval_to_ktime(tv
);
396 * CFG802.11 network device handler for open.
398 * Starts the data queue.
401 mwifiex_open(struct net_device
*dev
)
403 netif_tx_start_all_queues(dev
);
408 * CFG802.11 network device handler for close.
411 mwifiex_close(struct net_device
*dev
)
417 * CFG802.11 network device handler for data transmission.
420 mwifiex_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
422 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
423 struct sk_buff
*new_skb
;
424 struct mwifiex_txinfo
*tx_info
;
426 dev_dbg(priv
->adapter
->dev
, "data: %lu BSS(%d-%d): Data <= kernel\n",
427 jiffies
, priv
->bss_type
, priv
->bss_num
);
429 if (priv
->adapter
->surprise_removed
) {
431 priv
->stats
.tx_dropped
++;
434 if (!skb
->len
|| (skb
->len
> ETH_FRAME_LEN
)) {
435 dev_err(priv
->adapter
->dev
, "Tx: bad skb len %d\n", skb
->len
);
437 priv
->stats
.tx_dropped
++;
440 if (skb_headroom(skb
) < MWIFIEX_MIN_DATA_HEADER_LEN
) {
441 dev_dbg(priv
->adapter
->dev
,
442 "data: Tx: insufficient skb headroom %d\n",
444 /* Insufficient skb headroom - allocate a new skb */
446 skb_realloc_headroom(skb
, MWIFIEX_MIN_DATA_HEADER_LEN
);
447 if (unlikely(!new_skb
)) {
448 dev_err(priv
->adapter
->dev
, "Tx: cannot alloca new_skb\n");
450 priv
->stats
.tx_dropped
++;
455 dev_dbg(priv
->adapter
->dev
, "info: new skb headroomd %d\n",
459 tx_info
= MWIFIEX_SKB_TXCB(skb
);
460 tx_info
->bss_num
= priv
->bss_num
;
461 tx_info
->bss_type
= priv
->bss_type
;
462 mwifiex_fill_buffer(skb
);
464 mwifiex_wmm_add_buf_txqueue(priv
, skb
);
465 atomic_inc(&priv
->adapter
->tx_pending
);
467 if (atomic_read(&priv
->adapter
->tx_pending
) >= MAX_TX_PENDING
) {
468 mwifiex_set_trans_start(dev
);
469 mwifiex_stop_net_dev_queue(priv
->netdev
, priv
->adapter
);
472 queue_work(priv
->adapter
->workqueue
, &priv
->adapter
->main_work
);
478 * CFG802.11 network device handler for setting MAC address.
481 mwifiex_set_mac_address(struct net_device
*dev
, void *addr
)
483 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
484 struct sockaddr
*hw_addr
= addr
;
487 memcpy(priv
->curr_addr
, hw_addr
->sa_data
, ETH_ALEN
);
489 /* Send request to firmware */
490 ret
= mwifiex_send_cmd_sync(priv
, HostCmd_CMD_802_11_MAC_ADDRESS
,
491 HostCmd_ACT_GEN_SET
, 0, NULL
);
494 memcpy(priv
->netdev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
496 dev_err(priv
->adapter
->dev
,
497 "set mac address failed: ret=%d\n", ret
);
499 memcpy(dev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
505 * CFG802.11 network device handler for setting multicast list.
507 static void mwifiex_set_multicast_list(struct net_device
*dev
)
509 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
510 struct mwifiex_multicast_list mcast_list
;
512 if (dev
->flags
& IFF_PROMISC
) {
513 mcast_list
.mode
= MWIFIEX_PROMISC_MODE
;
514 } else if (dev
->flags
& IFF_ALLMULTI
||
515 netdev_mc_count(dev
) > MWIFIEX_MAX_MULTICAST_LIST_SIZE
) {
516 mcast_list
.mode
= MWIFIEX_ALL_MULTI_MODE
;
518 mcast_list
.mode
= MWIFIEX_MULTICAST_MODE
;
519 if (netdev_mc_count(dev
))
520 mcast_list
.num_multicast_addr
=
521 mwifiex_copy_mcast_addr(&mcast_list
, dev
);
523 mwifiex_request_set_multicast_list(priv
, &mcast_list
);
527 * CFG802.11 network device handler for transmission timeout.
530 mwifiex_tx_timeout(struct net_device
*dev
)
532 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
534 dev_err(priv
->adapter
->dev
, "%lu : Tx timeout, bss_type-num = %d-%d\n",
535 jiffies
, priv
->bss_type
, priv
->bss_num
);
536 mwifiex_set_trans_start(dev
);
537 priv
->num_tx_timeout
++;
541 * CFG802.11 network device handler for statistics retrieval.
543 static struct net_device_stats
*mwifiex_get_stats(struct net_device
*dev
)
545 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
550 /* Network device handlers */
551 static const struct net_device_ops mwifiex_netdev_ops
= {
552 .ndo_open
= mwifiex_open
,
553 .ndo_stop
= mwifiex_close
,
554 .ndo_start_xmit
= mwifiex_hard_start_xmit
,
555 .ndo_set_mac_address
= mwifiex_set_mac_address
,
556 .ndo_tx_timeout
= mwifiex_tx_timeout
,
557 .ndo_get_stats
= mwifiex_get_stats
,
558 .ndo_set_rx_mode
= mwifiex_set_multicast_list
,
562 * This function initializes the private structure parameters.
564 * The following wait queues are initialized -
566 * - Command wait queue
567 * - Statistics wait queue
569 * ...and the following default parameters are set -
570 * - Current key index : Set to 0
571 * - Rate index : Set to auto
572 * - Media connected : Set to disconnected
573 * - Adhoc link sensed : Set to false
574 * - Nick name : Set to null
575 * - Number of Tx timeout : Set to 0
576 * - Device address : Set to current address
578 * In addition, the CFG80211 work queue is also created.
580 void mwifiex_init_priv_params(struct mwifiex_private
*priv
,
581 struct net_device
*dev
)
583 dev
->netdev_ops
= &mwifiex_netdev_ops
;
584 /* Initialize private structure */
585 priv
->current_key_index
= 0;
586 priv
->media_connected
= false;
587 memset(&priv
->nick_name
, 0, sizeof(priv
->nick_name
));
588 priv
->num_tx_timeout
= 0;
589 memcpy(dev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
593 * This function check if command is pending.
595 int is_command_pending(struct mwifiex_adapter
*adapter
)
598 int is_cmd_pend_q_empty
;
600 spin_lock_irqsave(&adapter
->cmd_pending_q_lock
, flags
);
601 is_cmd_pend_q_empty
= list_empty(&adapter
->cmd_pending_q
);
602 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
, flags
);
604 return !is_cmd_pend_q_empty
;
608 * This is the main work queue function.
610 * It handles the main process, which in turn handles the complete
613 static void mwifiex_main_work_queue(struct work_struct
*work
)
615 struct mwifiex_adapter
*adapter
=
616 container_of(work
, struct mwifiex_adapter
, main_work
);
618 if (adapter
->surprise_removed
)
620 mwifiex_main_process(adapter
);
624 * This function cancels all works in the queue and destroys
625 * the main workqueue.
628 mwifiex_terminate_workqueue(struct mwifiex_adapter
*adapter
)
630 flush_workqueue(adapter
->workqueue
);
631 destroy_workqueue(adapter
->workqueue
);
632 adapter
->workqueue
= NULL
;
636 * This function adds the card.
638 * This function follows the following major steps to set up the device -
639 * - Initialize software. This includes probing the card, registering
640 * the interface operations table, and allocating/initializing the
642 * - Set up the netlink socket
643 * - Create and start the main work queue
644 * - Register the device
645 * - Initialize firmware and hardware
646 * - Add logical interfaces
649 mwifiex_add_card(void *card
, struct semaphore
*sem
,
650 struct mwifiex_if_ops
*if_ops
, u8 iface_type
)
652 struct mwifiex_adapter
*adapter
;
654 struct mwifiex_private
*priv
;
656 if (down_interruptible(sem
))
659 if (mwifiex_register(card
, if_ops
, (void **)&adapter
)) {
660 pr_err("%s: software init failed\n", __func__
);
664 adapter
->iface_type
= iface_type
;
666 adapter
->hw_status
= MWIFIEX_HW_STATUS_INITIALIZING
;
667 adapter
->surprise_removed
= false;
668 init_waitqueue_head(&adapter
->init_wait_q
);
669 adapter
->is_suspended
= false;
670 adapter
->hs_activated
= false;
671 init_waitqueue_head(&adapter
->hs_activate_wait_q
);
672 adapter
->cmd_wait_q_required
= false;
673 init_waitqueue_head(&adapter
->cmd_wait_q
.wait
);
674 adapter
->cmd_wait_q
.status
= 0;
675 adapter
->scan_wait_q_woken
= false;
677 adapter
->workqueue
= create_workqueue("MWIFIEX_WORK_QUEUE");
678 if (!adapter
->workqueue
)
681 INIT_WORK(&adapter
->main_work
, mwifiex_main_work_queue
);
683 /* Register the device. Fill up the private data structure with relevant
684 information from the card and request for the required IRQ. */
685 if (adapter
->if_ops
.register_dev(adapter
)) {
686 pr_err("%s: failed to register mwifiex device\n", __func__
);
687 goto err_registerdev
;
690 if (mwifiex_init_hw_fw(adapter
)) {
691 pr_err("%s: firmware init failed\n", __func__
);
695 priv
= adapter
->priv
[0];
697 if (mwifiex_register_cfg80211(priv
) != 0) {
698 dev_err(adapter
->dev
, "cannot register netdevice"
704 /* Create station interface by default */
705 if (!mwifiex_add_virtual_intf(priv
->wdev
->wiphy
, "mlan%d",
706 NL80211_IFTYPE_STATION
, NULL
, NULL
)) {
708 dev_err(adapter
->dev
, "cannot create default station"
717 mwifiex_drv_get_driver_version(adapter
, fmt
, sizeof(fmt
) - 1);
718 dev_notice(adapter
->dev
, "driver_version = %s\n", fmt
);
724 mwifiex_del_virtual_intf(priv
->wdev
->wiphy
, priv
->netdev
);
727 pr_debug("info: %s: unregister device\n", __func__
);
728 adapter
->if_ops
.unregister_dev(adapter
);
730 adapter
->surprise_removed
= true;
731 mwifiex_terminate_workqueue(adapter
);
733 if ((adapter
->hw_status
== MWIFIEX_HW_STATUS_FW_READY
) ||
734 (adapter
->hw_status
== MWIFIEX_HW_STATUS_READY
)) {
735 pr_debug("info: %s: shutdown mwifiex\n", __func__
);
736 adapter
->init_wait_q_woken
= false;
738 if (mwifiex_shutdown_drv(adapter
) == -EINPROGRESS
)
739 wait_event_interruptible(adapter
->init_wait_q
,
740 adapter
->init_wait_q_woken
);
743 mwifiex_free_adapter(adapter
);
751 EXPORT_SYMBOL_GPL(mwifiex_add_card
);
754 * This function removes the card.
756 * This function follows the following major steps to remove the device -
757 * - Stop data traffic
758 * - Shutdown firmware
759 * - Remove the logical interfaces
760 * - Terminate the work queue
761 * - Unregister the device
762 * - Free the adapter structure
764 int mwifiex_remove_card(struct mwifiex_adapter
*adapter
, struct semaphore
*sem
)
766 struct mwifiex_private
*priv
= NULL
;
769 if (down_interruptible(sem
))
775 adapter
->surprise_removed
= true;
778 for (i
= 0; i
< adapter
->priv_num
; i
++) {
779 priv
= adapter
->priv
[i
];
780 if (priv
&& priv
->netdev
) {
781 if (!netif_queue_stopped(priv
->netdev
))
782 mwifiex_stop_net_dev_queue(priv
->netdev
,
784 if (netif_carrier_ok(priv
->netdev
))
785 netif_carrier_off(priv
->netdev
);
789 dev_dbg(adapter
->dev
, "cmd: calling mwifiex_shutdown_drv...\n");
790 adapter
->init_wait_q_woken
= false;
792 if (mwifiex_shutdown_drv(adapter
) == -EINPROGRESS
)
793 wait_event_interruptible(adapter
->init_wait_q
,
794 adapter
->init_wait_q_woken
);
795 dev_dbg(adapter
->dev
, "cmd: mwifiex_shutdown_drv done\n");
796 if (atomic_read(&adapter
->rx_pending
) ||
797 atomic_read(&adapter
->tx_pending
) ||
798 atomic_read(&adapter
->cmd_pending
)) {
799 dev_err(adapter
->dev
, "rx_pending=%d, tx_pending=%d, "
801 atomic_read(&adapter
->rx_pending
),
802 atomic_read(&adapter
->tx_pending
),
803 atomic_read(&adapter
->cmd_pending
));
806 for (i
= 0; i
< adapter
->priv_num
; i
++) {
807 priv
= adapter
->priv
[i
];
813 if (priv
->wdev
&& priv
->netdev
)
814 mwifiex_del_virtual_intf(priv
->wdev
->wiphy
,
819 priv
= adapter
->priv
[0];
824 wiphy_unregister(priv
->wdev
->wiphy
);
825 wiphy_free(priv
->wdev
->wiphy
);
829 mwifiex_terminate_workqueue(adapter
);
831 /* Unregister device */
832 dev_dbg(adapter
->dev
, "info: unregister device\n");
833 adapter
->if_ops
.unregister_dev(adapter
);
834 /* Free adapter structure */
835 dev_dbg(adapter
->dev
, "info: free adapter\n");
836 mwifiex_free_adapter(adapter
);
843 EXPORT_SYMBOL_GPL(mwifiex_remove_card
);
846 * This function initializes the module.
848 * The debug FS is also initialized if configured.
851 mwifiex_init_module(void)
853 #ifdef CONFIG_DEBUG_FS
854 mwifiex_debugfs_init();
860 * This function cleans up the module.
862 * The debug FS is removed if available.
865 mwifiex_cleanup_module(void)
867 #ifdef CONFIG_DEBUG_FS
868 mwifiex_debugfs_remove();
872 module_init(mwifiex_init_module
);
873 module_exit(mwifiex_cleanup_module
);
875 MODULE_AUTHOR("Marvell International Ltd.");
876 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION
);
877 MODULE_VERSION(VERSION
);
878 MODULE_LICENSE("GPL v2");