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
[0];
353 if (mwifiex_register_cfg80211(priv
) != 0) {
354 dev_err(adapter
->dev
, "cannot register with cfg80211\n");
359 /* Create station interface by default */
360 if (!mwifiex_add_virtual_intf(priv
->wdev
->wiphy
, "mlan%d",
361 NL80211_IFTYPE_STATION
, NULL
, NULL
)) {
362 dev_err(adapter
->dev
, "cannot create default STA interface\n");
367 mwifiex_drv_get_driver_version(adapter
, fmt
, sizeof(fmt
) - 1);
368 dev_notice(adapter
->dev
, "driver_version = %s\n", fmt
);
372 mwifiex_del_virtual_intf(priv
->wdev
->wiphy
, priv
->netdev
);
375 pr_debug("info: %s: unregister device\n", __func__
);
376 adapter
->if_ops
.unregister_dev(adapter
);
378 release_firmware(adapter
->firmware
);
379 complete(&adapter
->fw_load
);
384 * This function initializes the hardware and gets firmware.
386 static int mwifiex_init_hw_fw(struct mwifiex_adapter
*adapter
)
390 init_completion(&adapter
->fw_load
);
391 ret
= request_firmware_nowait(THIS_MODULE
, 1, adapter
->fw_name
,
392 adapter
->dev
, GFP_KERNEL
, adapter
,
395 dev_err(adapter
->dev
,
396 "request_firmware_nowait() returned error %d\n", ret
);
401 * This function fills a driver buffer.
403 * The function associates a given SKB with the provided driver buffer
404 * and also updates some of the SKB parameters, including IP header,
405 * priority and timestamp.
408 mwifiex_fill_buffer(struct sk_buff
*skb
)
415 eth
= (struct ethhdr
*) skb
->data
;
416 switch (eth
->h_proto
) {
417 case __constant_htons(ETH_P_IP
):
419 tid
= IPTOS_PREC(iph
->tos
);
420 pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n",
421 eth
->h_proto
, tid
, skb
->priority
);
423 case __constant_htons(ETH_P_ARP
):
424 pr_debug("data: ARP packet: %04x\n", eth
->h_proto
);
428 /* Offset for TOS field in the IP header */
429 #define IPTOS_OFFSET 5
430 tid
= (tid
>> IPTOS_OFFSET
);
432 /* Record the current time the packet was queued; used to
433 determine the amount of time the packet was queued in
434 the driver before it was sent to the firmware.
435 The delay is then sent along with the packet to the
436 firmware for aggregate delay calculation for stats and
437 MSDU lifetime expiry.
439 do_gettimeofday(&tv
);
440 skb
->tstamp
= timeval_to_ktime(tv
);
444 * CFG802.11 network device handler for open.
446 * Starts the data queue.
449 mwifiex_open(struct net_device
*dev
)
451 netif_tx_start_all_queues(dev
);
456 * CFG802.11 network device handler for close.
459 mwifiex_close(struct net_device
*dev
)
465 * CFG802.11 network device handler for data transmission.
468 mwifiex_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
470 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
471 struct sk_buff
*new_skb
;
472 struct mwifiex_txinfo
*tx_info
;
474 dev_dbg(priv
->adapter
->dev
, "data: %lu BSS(%d-%d): Data <= kernel\n",
475 jiffies
, priv
->bss_type
, priv
->bss_num
);
477 if (priv
->adapter
->surprise_removed
) {
479 priv
->stats
.tx_dropped
++;
482 if (!skb
->len
|| (skb
->len
> ETH_FRAME_LEN
)) {
483 dev_err(priv
->adapter
->dev
, "Tx: bad skb len %d\n", skb
->len
);
485 priv
->stats
.tx_dropped
++;
488 if (skb_headroom(skb
) < MWIFIEX_MIN_DATA_HEADER_LEN
) {
489 dev_dbg(priv
->adapter
->dev
,
490 "data: Tx: insufficient skb headroom %d\n",
492 /* Insufficient skb headroom - allocate a new skb */
494 skb_realloc_headroom(skb
, MWIFIEX_MIN_DATA_HEADER_LEN
);
495 if (unlikely(!new_skb
)) {
496 dev_err(priv
->adapter
->dev
, "Tx: cannot alloca new_skb\n");
498 priv
->stats
.tx_dropped
++;
503 dev_dbg(priv
->adapter
->dev
, "info: new skb headroomd %d\n",
507 tx_info
= MWIFIEX_SKB_TXCB(skb
);
508 tx_info
->bss_num
= priv
->bss_num
;
509 tx_info
->bss_type
= priv
->bss_type
;
510 mwifiex_fill_buffer(skb
);
512 mwifiex_wmm_add_buf_txqueue(priv
, skb
);
513 atomic_inc(&priv
->adapter
->tx_pending
);
515 if (atomic_read(&priv
->adapter
->tx_pending
) >= MAX_TX_PENDING
) {
516 mwifiex_set_trans_start(dev
);
517 mwifiex_stop_net_dev_queue(priv
->netdev
, priv
->adapter
);
520 queue_work(priv
->adapter
->workqueue
, &priv
->adapter
->main_work
);
526 * CFG802.11 network device handler for setting MAC address.
529 mwifiex_set_mac_address(struct net_device
*dev
, void *addr
)
531 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
532 struct sockaddr
*hw_addr
= addr
;
535 memcpy(priv
->curr_addr
, hw_addr
->sa_data
, ETH_ALEN
);
537 /* Send request to firmware */
538 ret
= mwifiex_send_cmd_sync(priv
, HostCmd_CMD_802_11_MAC_ADDRESS
,
539 HostCmd_ACT_GEN_SET
, 0, NULL
);
542 memcpy(priv
->netdev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
544 dev_err(priv
->adapter
->dev
,
545 "set mac address failed: ret=%d\n", ret
);
547 memcpy(dev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
553 * CFG802.11 network device handler for setting multicast list.
555 static void mwifiex_set_multicast_list(struct net_device
*dev
)
557 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
558 struct mwifiex_multicast_list mcast_list
;
560 if (dev
->flags
& IFF_PROMISC
) {
561 mcast_list
.mode
= MWIFIEX_PROMISC_MODE
;
562 } else if (dev
->flags
& IFF_ALLMULTI
||
563 netdev_mc_count(dev
) > MWIFIEX_MAX_MULTICAST_LIST_SIZE
) {
564 mcast_list
.mode
= MWIFIEX_ALL_MULTI_MODE
;
566 mcast_list
.mode
= MWIFIEX_MULTICAST_MODE
;
567 if (netdev_mc_count(dev
))
568 mcast_list
.num_multicast_addr
=
569 mwifiex_copy_mcast_addr(&mcast_list
, dev
);
571 mwifiex_request_set_multicast_list(priv
, &mcast_list
);
575 * CFG802.11 network device handler for transmission timeout.
578 mwifiex_tx_timeout(struct net_device
*dev
)
580 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
582 dev_err(priv
->adapter
->dev
, "%lu : Tx timeout, bss_type-num = %d-%d\n",
583 jiffies
, priv
->bss_type
, priv
->bss_num
);
584 mwifiex_set_trans_start(dev
);
585 priv
->num_tx_timeout
++;
589 * CFG802.11 network device handler for statistics retrieval.
591 static struct net_device_stats
*mwifiex_get_stats(struct net_device
*dev
)
593 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
598 /* Network device handlers */
599 static const struct net_device_ops mwifiex_netdev_ops
= {
600 .ndo_open
= mwifiex_open
,
601 .ndo_stop
= mwifiex_close
,
602 .ndo_start_xmit
= mwifiex_hard_start_xmit
,
603 .ndo_set_mac_address
= mwifiex_set_mac_address
,
604 .ndo_tx_timeout
= mwifiex_tx_timeout
,
605 .ndo_get_stats
= mwifiex_get_stats
,
606 .ndo_set_rx_mode
= mwifiex_set_multicast_list
,
610 * This function initializes the private structure parameters.
612 * The following wait queues are initialized -
614 * - Command wait queue
615 * - Statistics wait queue
617 * ...and the following default parameters are set -
618 * - Current key index : Set to 0
619 * - Rate index : Set to auto
620 * - Media connected : Set to disconnected
621 * - Adhoc link sensed : Set to false
622 * - Nick name : Set to null
623 * - Number of Tx timeout : Set to 0
624 * - Device address : Set to current address
626 * In addition, the CFG80211 work queue is also created.
628 void mwifiex_init_priv_params(struct mwifiex_private
*priv
,
629 struct net_device
*dev
)
631 dev
->netdev_ops
= &mwifiex_netdev_ops
;
632 /* Initialize private structure */
633 priv
->current_key_index
= 0;
634 priv
->media_connected
= false;
635 memset(&priv
->nick_name
, 0, sizeof(priv
->nick_name
));
636 priv
->num_tx_timeout
= 0;
637 memcpy(dev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
641 * This function check if command is pending.
643 int is_command_pending(struct mwifiex_adapter
*adapter
)
646 int is_cmd_pend_q_empty
;
648 spin_lock_irqsave(&adapter
->cmd_pending_q_lock
, flags
);
649 is_cmd_pend_q_empty
= list_empty(&adapter
->cmd_pending_q
);
650 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
, flags
);
652 return !is_cmd_pend_q_empty
;
656 * This is the main work queue function.
658 * It handles the main process, which in turn handles the complete
661 static void mwifiex_main_work_queue(struct work_struct
*work
)
663 struct mwifiex_adapter
*adapter
=
664 container_of(work
, struct mwifiex_adapter
, main_work
);
666 if (adapter
->surprise_removed
)
668 mwifiex_main_process(adapter
);
672 * This function cancels all works in the queue and destroys
673 * the main workqueue.
676 mwifiex_terminate_workqueue(struct mwifiex_adapter
*adapter
)
678 flush_workqueue(adapter
->workqueue
);
679 destroy_workqueue(adapter
->workqueue
);
680 adapter
->workqueue
= NULL
;
684 * This function adds the card.
686 * This function follows the following major steps to set up the device -
687 * - Initialize software. This includes probing the card, registering
688 * the interface operations table, and allocating/initializing the
690 * - Set up the netlink socket
691 * - Create and start the main work queue
692 * - Register the device
693 * - Initialize firmware and hardware
694 * - Add logical interfaces
697 mwifiex_add_card(void *card
, struct semaphore
*sem
,
698 struct mwifiex_if_ops
*if_ops
, u8 iface_type
)
700 struct mwifiex_adapter
*adapter
;
702 if (down_interruptible(sem
))
705 if (mwifiex_register(card
, if_ops
, (void **)&adapter
)) {
706 pr_err("%s: software init failed\n", __func__
);
710 adapter
->iface_type
= iface_type
;
712 adapter
->hw_status
= MWIFIEX_HW_STATUS_INITIALIZING
;
713 adapter
->surprise_removed
= false;
714 init_waitqueue_head(&adapter
->init_wait_q
);
715 adapter
->is_suspended
= false;
716 adapter
->hs_activated
= false;
717 init_waitqueue_head(&adapter
->hs_activate_wait_q
);
718 adapter
->cmd_wait_q_required
= false;
719 init_waitqueue_head(&adapter
->cmd_wait_q
.wait
);
720 adapter
->cmd_wait_q
.status
= 0;
721 adapter
->scan_wait_q_woken
= false;
723 adapter
->workqueue
= create_workqueue("MWIFIEX_WORK_QUEUE");
724 if (!adapter
->workqueue
)
727 INIT_WORK(&adapter
->main_work
, mwifiex_main_work_queue
);
729 /* Register the device. Fill up the private data structure with relevant
730 information from the card and request for the required IRQ. */
731 if (adapter
->if_ops
.register_dev(adapter
)) {
732 pr_err("%s: failed to register mwifiex device\n", __func__
);
733 goto err_registerdev
;
736 if (mwifiex_init_hw_fw(adapter
)) {
737 pr_err("%s: firmware init failed\n", __func__
);
745 pr_debug("info: %s: unregister device\n", __func__
);
746 if (adapter
->if_ops
.unregister_dev
)
747 adapter
->if_ops
.unregister_dev(adapter
);
749 adapter
->surprise_removed
= true;
750 mwifiex_terminate_workqueue(adapter
);
752 if ((adapter
->hw_status
== MWIFIEX_HW_STATUS_FW_READY
) ||
753 (adapter
->hw_status
== MWIFIEX_HW_STATUS_READY
)) {
754 pr_debug("info: %s: shutdown mwifiex\n", __func__
);
755 adapter
->init_wait_q_woken
= false;
757 if (mwifiex_shutdown_drv(adapter
) == -EINPROGRESS
)
758 wait_event_interruptible(adapter
->init_wait_q
,
759 adapter
->init_wait_q_woken
);
762 mwifiex_free_adapter(adapter
);
770 EXPORT_SYMBOL_GPL(mwifiex_add_card
);
773 * This function removes the card.
775 * This function follows the following major steps to remove the device -
776 * - Stop data traffic
777 * - Shutdown firmware
778 * - Remove the logical interfaces
779 * - Terminate the work queue
780 * - Unregister the device
781 * - Free the adapter structure
783 int mwifiex_remove_card(struct mwifiex_adapter
*adapter
, struct semaphore
*sem
)
785 struct mwifiex_private
*priv
= NULL
;
788 if (down_interruptible(sem
))
794 adapter
->surprise_removed
= true;
797 for (i
= 0; i
< adapter
->priv_num
; i
++) {
798 priv
= adapter
->priv
[i
];
799 if (priv
&& priv
->netdev
) {
800 if (!netif_queue_stopped(priv
->netdev
))
801 mwifiex_stop_net_dev_queue(priv
->netdev
,
803 if (netif_carrier_ok(priv
->netdev
))
804 netif_carrier_off(priv
->netdev
);
808 dev_dbg(adapter
->dev
, "cmd: calling mwifiex_shutdown_drv...\n");
809 adapter
->init_wait_q_woken
= false;
811 if (mwifiex_shutdown_drv(adapter
) == -EINPROGRESS
)
812 wait_event_interruptible(adapter
->init_wait_q
,
813 adapter
->init_wait_q_woken
);
814 dev_dbg(adapter
->dev
, "cmd: mwifiex_shutdown_drv done\n");
815 if (atomic_read(&adapter
->rx_pending
) ||
816 atomic_read(&adapter
->tx_pending
) ||
817 atomic_read(&adapter
->cmd_pending
)) {
818 dev_err(adapter
->dev
, "rx_pending=%d, tx_pending=%d, "
820 atomic_read(&adapter
->rx_pending
),
821 atomic_read(&adapter
->tx_pending
),
822 atomic_read(&adapter
->cmd_pending
));
825 for (i
= 0; i
< adapter
->priv_num
; i
++) {
826 priv
= adapter
->priv
[i
];
832 if (priv
->wdev
&& priv
->netdev
)
833 mwifiex_del_virtual_intf(priv
->wdev
->wiphy
,
838 priv
= adapter
->priv
[0];
839 if (!priv
|| !priv
->wdev
)
842 wiphy_unregister(priv
->wdev
->wiphy
);
843 wiphy_free(priv
->wdev
->wiphy
);
845 for (i
= 0; i
< adapter
->priv_num
; i
++) {
846 priv
= adapter
->priv
[i
];
851 mwifiex_terminate_workqueue(adapter
);
853 /* Unregister device */
854 dev_dbg(adapter
->dev
, "info: unregister device\n");
855 if (adapter
->if_ops
.unregister_dev
)
856 adapter
->if_ops
.unregister_dev(adapter
);
857 /* Free adapter structure */
858 dev_dbg(adapter
->dev
, "info: free adapter\n");
859 mwifiex_free_adapter(adapter
);
866 EXPORT_SYMBOL_GPL(mwifiex_remove_card
);
869 * This function initializes the module.
871 * The debug FS is also initialized if configured.
874 mwifiex_init_module(void)
876 #ifdef CONFIG_DEBUG_FS
877 mwifiex_debugfs_init();
883 * This function cleans up the module.
885 * The debug FS is removed if available.
888 mwifiex_cleanup_module(void)
890 #ifdef CONFIG_DEBUG_FS
891 mwifiex_debugfs_remove();
895 module_init(mwifiex_init_module
);
896 module_exit(mwifiex_cleanup_module
);
898 MODULE_AUTHOR("Marvell International Ltd.");
899 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION
);
900 MODULE_VERSION(VERSION
);
901 MODULE_LICENSE("GPL v2");