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
)
62 if (adapter
->if_ops
.init_if(adapter
))
65 adapter
->priv_num
= 0;
67 for (i
= 0; i
< MWIFIEX_MAX_BSS_NUM
; i
++) {
68 /* Allocate memory for private structure */
70 kzalloc(sizeof(struct mwifiex_private
), GFP_KERNEL
);
71 if (!adapter
->priv
[i
])
74 adapter
->priv
[i
]->adapter
= adapter
;
75 adapter
->priv
[i
]->bss_priority
= i
;
78 mwifiex_init_lock_list(adapter
);
80 init_timer(&adapter
->cmd_timer
);
81 adapter
->cmd_timer
.function
= mwifiex_cmd_timeout_func
;
82 adapter
->cmd_timer
.data
= (unsigned long) adapter
;
87 dev_dbg(adapter
->dev
, "info: leave mwifiex_register with error\n");
89 for (i
= 0; i
< adapter
->priv_num
; i
++)
90 kfree(adapter
->priv
[i
]);
98 * This function unregisters the device and performs all the necessary
101 * The following cleanup operations are performed -
103 * - Free beacon buffers
104 * - Free private structures
105 * - Free adapter structure
107 static int mwifiex_unregister(struct mwifiex_adapter
*adapter
)
111 del_timer(&adapter
->cmd_timer
);
113 /* Free private structures */
114 for (i
= 0; i
< adapter
->priv_num
; i
++) {
115 if (adapter
->priv
[i
]) {
116 mwifiex_free_curr_bcn(adapter
->priv
[i
]);
117 kfree(adapter
->priv
[i
]);
128 * This function is the main procedure of the driver and handles various driver
129 * operations. It runs in a loop and provides the core functionalities.
131 * The main responsibilities of this function are -
132 * - Ensure concurrency control
133 * - Handle pending interrupts and call interrupt handlers
134 * - Wake up the card if required
135 * - Handle command responses and call response handlers
136 * - Handle events and call event handlers
137 * - Execute pending commands
138 * - Transmit pending data packets
140 int mwifiex_main_process(struct mwifiex_adapter
*adapter
)
146 spin_lock_irqsave(&adapter
->main_proc_lock
, flags
);
148 /* Check if already processing */
149 if (adapter
->mwifiex_processing
) {
150 spin_unlock_irqrestore(&adapter
->main_proc_lock
, flags
);
153 adapter
->mwifiex_processing
= true;
154 spin_unlock_irqrestore(&adapter
->main_proc_lock
, flags
);
158 if ((adapter
->hw_status
== MWIFIEX_HW_STATUS_CLOSING
) ||
159 (adapter
->hw_status
== MWIFIEX_HW_STATUS_NOT_READY
))
162 /* Handle pending interrupt if any */
163 if (adapter
->int_status
) {
164 if (adapter
->hs_activated
)
165 mwifiex_process_hs_config(adapter
);
166 if (adapter
->if_ops
.process_int_status
)
167 adapter
->if_ops
.process_int_status(adapter
);
170 /* Need to wake up the card ? */
171 if ((adapter
->ps_state
== PS_STATE_SLEEP
) &&
172 (adapter
->pm_wakeup_card_req
&&
173 !adapter
->pm_wakeup_fw_try
) &&
174 (is_command_pending(adapter
) ||
175 !mwifiex_wmm_lists_empty(adapter
))) {
176 adapter
->pm_wakeup_fw_try
= true;
177 adapter
->if_ops
.wakeup(adapter
);
181 if (IS_CARD_RX_RCVD(adapter
)) {
182 adapter
->pm_wakeup_fw_try
= false;
183 if (adapter
->ps_state
== PS_STATE_SLEEP
)
184 adapter
->ps_state
= PS_STATE_AWAKE
;
186 /* We have tried to wakeup the card already */
187 if (adapter
->pm_wakeup_fw_try
)
189 if (adapter
->ps_state
!= PS_STATE_AWAKE
||
190 adapter
->tx_lock_flag
)
193 if (adapter
->scan_processing
|| adapter
->data_sent
||
194 mwifiex_wmm_lists_empty(adapter
)) {
195 if (adapter
->cmd_sent
|| adapter
->curr_cmd
||
196 (!is_command_pending(adapter
)))
201 /* Check Rx data for USB */
202 if (adapter
->iface_type
== MWIFIEX_USB
)
203 while ((skb
= skb_dequeue(&adapter
->usb_rx_data_q
)))
204 mwifiex_handle_rx_packet(adapter
, skb
);
206 /* Check for Cmd Resp */
207 if (adapter
->cmd_resp_received
) {
208 adapter
->cmd_resp_received
= false;
209 mwifiex_process_cmdresp(adapter
);
211 /* call mwifiex back when init_fw is done */
212 if (adapter
->hw_status
== MWIFIEX_HW_STATUS_INIT_DONE
) {
213 adapter
->hw_status
= MWIFIEX_HW_STATUS_READY
;
214 mwifiex_init_fw_complete(adapter
);
218 /* Check for event */
219 if (adapter
->event_received
) {
220 adapter
->event_received
= false;
221 mwifiex_process_event(adapter
);
224 /* Check if we need to confirm Sleep Request
225 received previously */
226 if (adapter
->ps_state
== PS_STATE_PRE_SLEEP
) {
227 if (!adapter
->cmd_sent
&& !adapter
->curr_cmd
)
228 mwifiex_check_ps_cond(adapter
);
231 /* * The ps_state may have been changed during processing of
232 * Sleep Request event.
234 if ((adapter
->ps_state
== PS_STATE_SLEEP
) ||
235 (adapter
->ps_state
== PS_STATE_PRE_SLEEP
) ||
236 (adapter
->ps_state
== PS_STATE_SLEEP_CFM
) ||
237 adapter
->tx_lock_flag
)
240 if (!adapter
->cmd_sent
&& !adapter
->curr_cmd
) {
241 if (mwifiex_exec_next_cmd(adapter
) == -1) {
247 if (!adapter
->scan_processing
&& !adapter
->data_sent
&&
248 !mwifiex_wmm_lists_empty(adapter
)) {
249 mwifiex_wmm_process_tx(adapter
);
250 if (adapter
->hs_activated
) {
251 adapter
->is_hs_configured
= false;
252 mwifiex_hs_activated_event
254 (adapter
, MWIFIEX_BSS_ROLE_ANY
),
259 if (adapter
->delay_null_pkt
&& !adapter
->cmd_sent
&&
260 !adapter
->curr_cmd
&& !is_command_pending(adapter
) &&
261 mwifiex_wmm_lists_empty(adapter
)) {
262 if (!mwifiex_send_null_packet
263 (mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_STA
),
264 MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET
|
265 MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET
)) {
266 adapter
->delay_null_pkt
= false;
267 adapter
->ps_state
= PS_STATE_SLEEP
;
273 if ((adapter
->int_status
) || IS_CARD_RX_RCVD(adapter
))
276 spin_lock_irqsave(&adapter
->main_proc_lock
, flags
);
277 adapter
->mwifiex_processing
= false;
278 spin_unlock_irqrestore(&adapter
->main_proc_lock
, flags
);
281 if (adapter
->hw_status
== MWIFIEX_HW_STATUS_CLOSING
)
282 mwifiex_shutdown_drv(adapter
);
287 * This function frees the adapter structure.
289 * Additionally, this closes the netlink socket, frees the timers
290 * and private structures.
292 static void mwifiex_free_adapter(struct mwifiex_adapter
*adapter
)
295 pr_err("%s: adapter is NULL\n", __func__
);
299 mwifiex_unregister(adapter
);
300 pr_debug("info: %s: free adapter\n", __func__
);
304 * This function gets firmware and initializes it.
306 * The main initialization steps followed are -
307 * - Download the correct firmware to card
308 * - Issue the init commands to firmware
310 static void mwifiex_fw_dpc(const struct firmware
*firmware
, void *context
)
314 struct mwifiex_private
*priv
;
315 struct mwifiex_adapter
*adapter
= context
;
316 struct mwifiex_fw_image fw
;
319 dev_err(adapter
->dev
,
320 "Failed to get firmware %s\n", adapter
->fw_name
);
324 memset(&fw
, 0, sizeof(struct mwifiex_fw_image
));
325 adapter
->firmware
= firmware
;
326 fw
.fw_buf
= (u8
*) adapter
->firmware
->data
;
327 fw
.fw_len
= adapter
->firmware
->size
;
329 if (adapter
->if_ops
.dnld_fw
)
330 ret
= adapter
->if_ops
.dnld_fw(adapter
, &fw
);
332 ret
= mwifiex_dnld_fw(adapter
, &fw
);
336 dev_notice(adapter
->dev
, "WLAN FW is active\n");
338 adapter
->init_wait_q_woken
= false;
339 ret
= mwifiex_init_fw(adapter
);
343 adapter
->hw_status
= MWIFIEX_HW_STATUS_READY
;
346 /* Wait for mwifiex_init to complete */
347 wait_event_interruptible(adapter
->init_wait_q
,
348 adapter
->init_wait_q_woken
);
349 if (adapter
->hw_status
!= MWIFIEX_HW_STATUS_READY
)
352 priv
= adapter
->priv
[MWIFIEX_BSS_ROLE_STA
];
353 if (mwifiex_register_cfg80211(adapter
)) {
354 dev_err(adapter
->dev
, "cannot register with cfg80211\n");
359 /* Create station interface by default */
360 if (!mwifiex_add_virtual_intf(adapter
->wiphy
, "mlan%d",
361 NL80211_IFTYPE_STATION
, NULL
, NULL
)) {
362 dev_err(adapter
->dev
, "cannot create default STA interface\n");
366 /* Create AP interface by default */
367 if (!mwifiex_add_virtual_intf(adapter
->wiphy
, "uap%d",
368 NL80211_IFTYPE_AP
, NULL
, NULL
)) {
369 dev_err(adapter
->dev
, "cannot create default AP interface\n");
374 mwifiex_drv_get_driver_version(adapter
, fmt
, sizeof(fmt
) - 1);
375 dev_notice(adapter
->dev
, "driver_version = %s\n", fmt
);
379 mwifiex_del_virtual_intf(adapter
->wiphy
, priv
->netdev
);
382 pr_debug("info: %s: unregister device\n", __func__
);
383 adapter
->if_ops
.unregister_dev(adapter
);
385 release_firmware(adapter
->firmware
);
386 complete(&adapter
->fw_load
);
391 * This function initializes the hardware and gets firmware.
393 static int mwifiex_init_hw_fw(struct mwifiex_adapter
*adapter
)
397 init_completion(&adapter
->fw_load
);
398 ret
= request_firmware_nowait(THIS_MODULE
, 1, adapter
->fw_name
,
399 adapter
->dev
, GFP_KERNEL
, adapter
,
402 dev_err(adapter
->dev
,
403 "request_firmware_nowait() returned error %d\n", ret
);
408 * This function fills a driver buffer.
410 * The function associates a given SKB with the provided driver buffer
411 * and also updates some of the SKB parameters, including IP header,
412 * priority and timestamp.
415 mwifiex_fill_buffer(struct sk_buff
*skb
)
422 eth
= (struct ethhdr
*) skb
->data
;
423 switch (eth
->h_proto
) {
424 case __constant_htons(ETH_P_IP
):
426 tid
= IPTOS_PREC(iph
->tos
);
427 pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n",
428 eth
->h_proto
, tid
, skb
->priority
);
430 case __constant_htons(ETH_P_ARP
):
431 pr_debug("data: ARP packet: %04x\n", eth
->h_proto
);
435 /* Offset for TOS field in the IP header */
436 #define IPTOS_OFFSET 5
437 tid
= (tid
>> IPTOS_OFFSET
);
439 /* Record the current time the packet was queued; used to
440 determine the amount of time the packet was queued in
441 the driver before it was sent to the firmware.
442 The delay is then sent along with the packet to the
443 firmware for aggregate delay calculation for stats and
444 MSDU lifetime expiry.
446 do_gettimeofday(&tv
);
447 skb
->tstamp
= timeval_to_ktime(tv
);
451 * CFG802.11 network device handler for open.
453 * Starts the data queue.
456 mwifiex_open(struct net_device
*dev
)
458 netif_tx_start_all_queues(dev
);
463 * CFG802.11 network device handler for close.
466 mwifiex_close(struct net_device
*dev
)
472 * CFG802.11 network device handler for data transmission.
475 mwifiex_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
477 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
478 struct sk_buff
*new_skb
;
479 struct mwifiex_txinfo
*tx_info
;
481 dev_dbg(priv
->adapter
->dev
, "data: %lu BSS(%d-%d): Data <= kernel\n",
482 jiffies
, priv
->bss_type
, priv
->bss_num
);
484 if (priv
->adapter
->surprise_removed
) {
486 priv
->stats
.tx_dropped
++;
489 if (!skb
->len
|| (skb
->len
> ETH_FRAME_LEN
)) {
490 dev_err(priv
->adapter
->dev
, "Tx: bad skb len %d\n", skb
->len
);
492 priv
->stats
.tx_dropped
++;
495 if (skb_headroom(skb
) < MWIFIEX_MIN_DATA_HEADER_LEN
) {
496 dev_dbg(priv
->adapter
->dev
,
497 "data: Tx: insufficient skb headroom %d\n",
499 /* Insufficient skb headroom - allocate a new skb */
501 skb_realloc_headroom(skb
, MWIFIEX_MIN_DATA_HEADER_LEN
);
502 if (unlikely(!new_skb
)) {
503 dev_err(priv
->adapter
->dev
, "Tx: cannot alloca new_skb\n");
505 priv
->stats
.tx_dropped
++;
510 dev_dbg(priv
->adapter
->dev
, "info: new skb headroomd %d\n",
514 tx_info
= MWIFIEX_SKB_TXCB(skb
);
515 tx_info
->bss_num
= priv
->bss_num
;
516 tx_info
->bss_type
= priv
->bss_type
;
517 mwifiex_fill_buffer(skb
);
519 mwifiex_wmm_add_buf_txqueue(priv
, skb
);
520 atomic_inc(&priv
->adapter
->tx_pending
);
522 if (atomic_read(&priv
->adapter
->tx_pending
) >= MAX_TX_PENDING
) {
523 mwifiex_set_trans_start(dev
);
524 mwifiex_stop_net_dev_queue(priv
->netdev
, priv
->adapter
);
527 queue_work(priv
->adapter
->workqueue
, &priv
->adapter
->main_work
);
533 * CFG802.11 network device handler for setting MAC address.
536 mwifiex_set_mac_address(struct net_device
*dev
, void *addr
)
538 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
539 struct sockaddr
*hw_addr
= addr
;
542 memcpy(priv
->curr_addr
, hw_addr
->sa_data
, ETH_ALEN
);
544 /* Send request to firmware */
545 ret
= mwifiex_send_cmd_sync(priv
, HostCmd_CMD_802_11_MAC_ADDRESS
,
546 HostCmd_ACT_GEN_SET
, 0, NULL
);
549 memcpy(priv
->netdev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
551 dev_err(priv
->adapter
->dev
,
552 "set mac address failed: ret=%d\n", ret
);
554 memcpy(dev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
560 * CFG802.11 network device handler for setting multicast list.
562 static void mwifiex_set_multicast_list(struct net_device
*dev
)
564 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
565 struct mwifiex_multicast_list mcast_list
;
567 if (dev
->flags
& IFF_PROMISC
) {
568 mcast_list
.mode
= MWIFIEX_PROMISC_MODE
;
569 } else if (dev
->flags
& IFF_ALLMULTI
||
570 netdev_mc_count(dev
) > MWIFIEX_MAX_MULTICAST_LIST_SIZE
) {
571 mcast_list
.mode
= MWIFIEX_ALL_MULTI_MODE
;
573 mcast_list
.mode
= MWIFIEX_MULTICAST_MODE
;
574 if (netdev_mc_count(dev
))
575 mcast_list
.num_multicast_addr
=
576 mwifiex_copy_mcast_addr(&mcast_list
, dev
);
578 mwifiex_request_set_multicast_list(priv
, &mcast_list
);
582 * CFG802.11 network device handler for transmission timeout.
585 mwifiex_tx_timeout(struct net_device
*dev
)
587 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
589 dev_err(priv
->adapter
->dev
, "%lu : Tx timeout, bss_type-num = %d-%d\n",
590 jiffies
, priv
->bss_type
, priv
->bss_num
);
591 mwifiex_set_trans_start(dev
);
592 priv
->num_tx_timeout
++;
596 * CFG802.11 network device handler for statistics retrieval.
598 static struct net_device_stats
*mwifiex_get_stats(struct net_device
*dev
)
600 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
605 /* Network device handlers */
606 static const struct net_device_ops mwifiex_netdev_ops
= {
607 .ndo_open
= mwifiex_open
,
608 .ndo_stop
= mwifiex_close
,
609 .ndo_start_xmit
= mwifiex_hard_start_xmit
,
610 .ndo_set_mac_address
= mwifiex_set_mac_address
,
611 .ndo_tx_timeout
= mwifiex_tx_timeout
,
612 .ndo_get_stats
= mwifiex_get_stats
,
613 .ndo_set_rx_mode
= mwifiex_set_multicast_list
,
617 * This function initializes the private structure parameters.
619 * The following wait queues are initialized -
621 * - Command wait queue
622 * - Statistics wait queue
624 * ...and the following default parameters are set -
625 * - Current key index : Set to 0
626 * - Rate index : Set to auto
627 * - Media connected : Set to disconnected
628 * - Adhoc link sensed : Set to false
629 * - Nick name : Set to null
630 * - Number of Tx timeout : Set to 0
631 * - Device address : Set to current address
633 * In addition, the CFG80211 work queue is also created.
635 void mwifiex_init_priv_params(struct mwifiex_private
*priv
,
636 struct net_device
*dev
)
638 dev
->netdev_ops
= &mwifiex_netdev_ops
;
639 /* Initialize private structure */
640 priv
->current_key_index
= 0;
641 priv
->media_connected
= false;
642 memset(&priv
->nick_name
, 0, sizeof(priv
->nick_name
));
643 priv
->num_tx_timeout
= 0;
644 memcpy(dev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
648 * This function check if command is pending.
650 int is_command_pending(struct mwifiex_adapter
*adapter
)
653 int is_cmd_pend_q_empty
;
655 spin_lock_irqsave(&adapter
->cmd_pending_q_lock
, flags
);
656 is_cmd_pend_q_empty
= list_empty(&adapter
->cmd_pending_q
);
657 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
, flags
);
659 return !is_cmd_pend_q_empty
;
663 * This is the main work queue function.
665 * It handles the main process, which in turn handles the complete
668 static void mwifiex_main_work_queue(struct work_struct
*work
)
670 struct mwifiex_adapter
*adapter
=
671 container_of(work
, struct mwifiex_adapter
, main_work
);
673 if (adapter
->surprise_removed
)
675 mwifiex_main_process(adapter
);
679 * This function cancels all works in the queue and destroys
680 * the main workqueue.
683 mwifiex_terminate_workqueue(struct mwifiex_adapter
*adapter
)
685 flush_workqueue(adapter
->workqueue
);
686 destroy_workqueue(adapter
->workqueue
);
687 adapter
->workqueue
= NULL
;
691 * This function adds the card.
693 * This function follows the following major steps to set up the device -
694 * - Initialize software. This includes probing the card, registering
695 * the interface operations table, and allocating/initializing the
697 * - Set up the netlink socket
698 * - Create and start the main work queue
699 * - Register the device
700 * - Initialize firmware and hardware
701 * - Add logical interfaces
704 mwifiex_add_card(void *card
, struct semaphore
*sem
,
705 struct mwifiex_if_ops
*if_ops
, u8 iface_type
)
707 struct mwifiex_adapter
*adapter
;
709 if (down_interruptible(sem
))
712 if (mwifiex_register(card
, if_ops
, (void **)&adapter
)) {
713 pr_err("%s: software init failed\n", __func__
);
717 adapter
->iface_type
= iface_type
;
719 adapter
->hw_status
= MWIFIEX_HW_STATUS_INITIALIZING
;
720 adapter
->surprise_removed
= false;
721 init_waitqueue_head(&adapter
->init_wait_q
);
722 adapter
->is_suspended
= false;
723 adapter
->hs_activated
= false;
724 init_waitqueue_head(&adapter
->hs_activate_wait_q
);
725 adapter
->cmd_wait_q_required
= false;
726 init_waitqueue_head(&adapter
->cmd_wait_q
.wait
);
727 adapter
->cmd_wait_q
.status
= 0;
728 adapter
->scan_wait_q_woken
= false;
730 adapter
->workqueue
= create_workqueue("MWIFIEX_WORK_QUEUE");
731 if (!adapter
->workqueue
)
734 INIT_WORK(&adapter
->main_work
, mwifiex_main_work_queue
);
736 /* Register the device. Fill up the private data structure with relevant
737 information from the card and request for the required IRQ. */
738 if (adapter
->if_ops
.register_dev(adapter
)) {
739 pr_err("%s: failed to register mwifiex device\n", __func__
);
740 goto err_registerdev
;
743 if (mwifiex_init_hw_fw(adapter
)) {
744 pr_err("%s: firmware init failed\n", __func__
);
752 pr_debug("info: %s: unregister device\n", __func__
);
753 if (adapter
->if_ops
.unregister_dev
)
754 adapter
->if_ops
.unregister_dev(adapter
);
756 adapter
->surprise_removed
= true;
757 mwifiex_terminate_workqueue(adapter
);
759 if ((adapter
->hw_status
== MWIFIEX_HW_STATUS_FW_READY
) ||
760 (adapter
->hw_status
== MWIFIEX_HW_STATUS_READY
)) {
761 pr_debug("info: %s: shutdown mwifiex\n", __func__
);
762 adapter
->init_wait_q_woken
= false;
764 if (mwifiex_shutdown_drv(adapter
) == -EINPROGRESS
)
765 wait_event_interruptible(adapter
->init_wait_q
,
766 adapter
->init_wait_q_woken
);
769 mwifiex_free_adapter(adapter
);
777 EXPORT_SYMBOL_GPL(mwifiex_add_card
);
780 * This function removes the card.
782 * This function follows the following major steps to remove the device -
783 * - Stop data traffic
784 * - Shutdown firmware
785 * - Remove the logical interfaces
786 * - Terminate the work queue
787 * - Unregister the device
788 * - Free the adapter structure
790 int mwifiex_remove_card(struct mwifiex_adapter
*adapter
, struct semaphore
*sem
)
792 struct mwifiex_private
*priv
= NULL
;
795 if (down_interruptible(sem
))
801 adapter
->surprise_removed
= true;
804 for (i
= 0; i
< adapter
->priv_num
; i
++) {
805 priv
= adapter
->priv
[i
];
806 if (priv
&& priv
->netdev
) {
807 if (!netif_queue_stopped(priv
->netdev
))
808 mwifiex_stop_net_dev_queue(priv
->netdev
,
810 if (netif_carrier_ok(priv
->netdev
))
811 netif_carrier_off(priv
->netdev
);
815 dev_dbg(adapter
->dev
, "cmd: calling mwifiex_shutdown_drv...\n");
816 adapter
->init_wait_q_woken
= false;
818 if (mwifiex_shutdown_drv(adapter
) == -EINPROGRESS
)
819 wait_event_interruptible(adapter
->init_wait_q
,
820 adapter
->init_wait_q_woken
);
821 dev_dbg(adapter
->dev
, "cmd: mwifiex_shutdown_drv done\n");
822 if (atomic_read(&adapter
->rx_pending
) ||
823 atomic_read(&adapter
->tx_pending
) ||
824 atomic_read(&adapter
->cmd_pending
)) {
825 dev_err(adapter
->dev
, "rx_pending=%d, tx_pending=%d, "
827 atomic_read(&adapter
->rx_pending
),
828 atomic_read(&adapter
->tx_pending
),
829 atomic_read(&adapter
->cmd_pending
));
832 for (i
= 0; i
< adapter
->priv_num
; i
++) {
833 priv
= adapter
->priv
[i
];
839 if (priv
->wdev
&& priv
->netdev
)
840 mwifiex_del_virtual_intf(adapter
->wiphy
, priv
->netdev
);
844 priv
= adapter
->priv
[0];
845 if (!priv
|| !priv
->wdev
)
848 wiphy_unregister(priv
->wdev
->wiphy
);
849 wiphy_free(priv
->wdev
->wiphy
);
851 for (i
= 0; i
< adapter
->priv_num
; i
++) {
852 priv
= adapter
->priv
[i
];
857 mwifiex_terminate_workqueue(adapter
);
859 /* Unregister device */
860 dev_dbg(adapter
->dev
, "info: unregister device\n");
861 if (adapter
->if_ops
.unregister_dev
)
862 adapter
->if_ops
.unregister_dev(adapter
);
863 /* Free adapter structure */
864 dev_dbg(adapter
->dev
, "info: free adapter\n");
865 mwifiex_free_adapter(adapter
);
872 EXPORT_SYMBOL_GPL(mwifiex_remove_card
);
875 * This function initializes the module.
877 * The debug FS is also initialized if configured.
880 mwifiex_init_module(void)
882 #ifdef CONFIG_DEBUG_FS
883 mwifiex_debugfs_init();
889 * This function cleans up the module.
891 * The debug FS is removed if available.
894 mwifiex_cleanup_module(void)
896 #ifdef CONFIG_DEBUG_FS
897 mwifiex_debugfs_remove();
901 module_init(mwifiex_init_module
);
902 module_exit(mwifiex_cleanup_module
);
904 MODULE_AUTHOR("Marvell International Ltd.");
905 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION
);
906 MODULE_VERSION(VERSION
);
907 MODULE_LICENSE("GPL v2");