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) ";
29 struct mwifiex_adapter
*g_adapter
;
30 EXPORT_SYMBOL_GPL(g_adapter
);
32 static struct mwifiex_bss_attr mwifiex_bss_sta
[] = {
33 {MWIFIEX_BSS_TYPE_STA
, MWIFIEX_DATA_FRAME_TYPE_ETH_II
, true, 0, 0},
36 static int drv_mode
= DRV_MODE_STA
;
38 static char fw_name
[32] = DEFAULT_FW_NAME
;
40 /* Supported drv_mode table */
41 static struct mwifiex_drv_mode mwifiex_drv_mode_tbl
[] = {
43 .drv_mode
= DRV_MODE_STA
,
44 .intf_num
= ARRAY_SIZE(mwifiex_bss_sta
),
45 .bss_attr
= mwifiex_bss_sta
,
50 * This function registers the device and performs all the necessary
53 * The following initialization operations are performed -
54 * - Allocate adapter structure
55 * - Save interface specific operations table in adapter
56 * - Call interface specific initialization routine
57 * - Allocate private structures
58 * - Set default adapter structure parameters
61 * In case of any errors during inittialization, this function also ensures
62 * proper cleanup before exiting.
64 static int mwifiex_register(void *card
, struct mwifiex_if_ops
*if_ops
,
65 struct mwifiex_drv_mode
*drv_mode_ptr
)
67 struct mwifiex_adapter
*adapter
;
70 adapter
= kzalloc(sizeof(struct mwifiex_adapter
), GFP_KERNEL
);
77 /* Save interface specific operations in adapter */
78 memmove(&adapter
->if_ops
, if_ops
, sizeof(struct mwifiex_if_ops
));
80 /* card specific initialization has been deferred until now .. */
81 if (adapter
->if_ops
.init_if(adapter
))
84 adapter
->priv_num
= 0;
85 for (i
= 0; i
< drv_mode_ptr
->intf_num
; i
++) {
86 adapter
->priv
[i
] = NULL
;
88 if (!drv_mode_ptr
->bss_attr
[i
].active
)
91 /* Allocate memory for private structure */
92 adapter
->priv
[i
] = kzalloc(sizeof(struct mwifiex_private
),
94 if (!adapter
->priv
[i
]) {
95 dev_err(adapter
->dev
, "%s: failed to alloc priv[%d]\n",
101 adapter
->priv
[i
]->adapter
= adapter
;
102 /* Save bss_type, frame_type & bss_priority */
103 adapter
->priv
[i
]->bss_type
= drv_mode_ptr
->bss_attr
[i
].bss_type
;
104 adapter
->priv
[i
]->frame_type
=
105 drv_mode_ptr
->bss_attr
[i
].frame_type
;
106 adapter
->priv
[i
]->bss_priority
=
107 drv_mode_ptr
->bss_attr
[i
].bss_priority
;
109 if (drv_mode_ptr
->bss_attr
[i
].bss_type
== MWIFIEX_BSS_TYPE_STA
)
110 adapter
->priv
[i
]->bss_role
= MWIFIEX_BSS_ROLE_STA
;
111 else if (drv_mode_ptr
->bss_attr
[i
].bss_type
==
112 MWIFIEX_BSS_TYPE_UAP
)
113 adapter
->priv
[i
]->bss_role
= MWIFIEX_BSS_ROLE_UAP
;
115 /* Save bss_index & bss_num */
116 adapter
->priv
[i
]->bss_index
= i
;
117 adapter
->priv
[i
]->bss_num
= drv_mode_ptr
->bss_attr
[i
].bss_num
;
119 adapter
->drv_mode
= drv_mode_ptr
;
121 if (mwifiex_init_lock_list(adapter
))
124 init_timer(&adapter
->cmd_timer
);
125 adapter
->cmd_timer
.function
= mwifiex_cmd_timeout_func
;
126 adapter
->cmd_timer
.data
= (unsigned long) adapter
;
131 dev_dbg(adapter
->dev
, "info: leave mwifiex_register with error\n");
133 mwifiex_free_lock_list(adapter
);
134 for (i
= 0; i
< drv_mode_ptr
->intf_num
; i
++)
135 kfree(adapter
->priv
[i
]);
142 * This function unregisters the device and performs all the necessary
145 * The following cleanup operations are performed -
147 * - Free beacon buffers
148 * - Free private structures
149 * - Free adapter structure
151 static int mwifiex_unregister(struct mwifiex_adapter
*adapter
)
155 del_timer(&adapter
->cmd_timer
);
157 /* Free private structures */
158 for (i
= 0; i
< adapter
->priv_num
; i
++) {
159 if (adapter
->priv
[i
]) {
160 mwifiex_free_curr_bcn(adapter
->priv
[i
]);
161 kfree(adapter
->priv
[i
]);
172 * This function is the main procedure of the driver and handles various driver
173 * operations. It runs in a loop and provides the core functionalities.
175 * The main responsibilities of this function are -
176 * - Ensure concurrency control
177 * - Handle pending interrupts and call interrupt handlers
178 * - Wake up the card if required
179 * - Handle command responses and call response handlers
180 * - Handle events and call event handlers
181 * - Execute pending commands
182 * - Transmit pending data packets
184 int mwifiex_main_process(struct mwifiex_adapter
*adapter
)
189 spin_lock_irqsave(&adapter
->main_proc_lock
, flags
);
191 /* Check if already processing */
192 if (adapter
->mwifiex_processing
) {
193 spin_unlock_irqrestore(&adapter
->main_proc_lock
, flags
);
196 adapter
->mwifiex_processing
= true;
197 spin_unlock_irqrestore(&adapter
->main_proc_lock
, flags
);
201 if ((adapter
->hw_status
== MWIFIEX_HW_STATUS_CLOSING
) ||
202 (adapter
->hw_status
== MWIFIEX_HW_STATUS_NOT_READY
))
205 /* Handle pending interrupt if any */
206 if (adapter
->int_status
) {
207 if (adapter
->hs_activated
)
208 mwifiex_process_hs_config(adapter
);
209 adapter
->if_ops
.process_int_status(adapter
);
212 /* Need to wake up the card ? */
213 if ((adapter
->ps_state
== PS_STATE_SLEEP
) &&
214 (adapter
->pm_wakeup_card_req
&&
215 !adapter
->pm_wakeup_fw_try
) &&
216 (is_command_pending(adapter
)
217 || !mwifiex_wmm_lists_empty(adapter
))) {
218 adapter
->pm_wakeup_fw_try
= true;
219 adapter
->if_ops
.wakeup(adapter
);
222 if (IS_CARD_RX_RCVD(adapter
)) {
223 adapter
->pm_wakeup_fw_try
= false;
224 if (adapter
->ps_state
== PS_STATE_SLEEP
)
225 adapter
->ps_state
= PS_STATE_AWAKE
;
227 /* We have tried to wakeup the card already */
228 if (adapter
->pm_wakeup_fw_try
)
230 if (adapter
->ps_state
!= PS_STATE_AWAKE
||
231 adapter
->tx_lock_flag
)
234 if (adapter
->scan_processing
|| adapter
->data_sent
235 || mwifiex_wmm_lists_empty(adapter
)) {
236 if (adapter
->cmd_sent
|| adapter
->curr_cmd
237 || (!is_command_pending(adapter
)))
242 /* Check for Cmd Resp */
243 if (adapter
->cmd_resp_received
) {
244 adapter
->cmd_resp_received
= false;
245 mwifiex_process_cmdresp(adapter
);
247 /* call mwifiex back when init_fw is done */
248 if (adapter
->hw_status
== MWIFIEX_HW_STATUS_INIT_DONE
) {
249 adapter
->hw_status
= MWIFIEX_HW_STATUS_READY
;
250 mwifiex_init_fw_complete(adapter
);
254 /* Check for event */
255 if (adapter
->event_received
) {
256 adapter
->event_received
= false;
257 mwifiex_process_event(adapter
);
260 /* Check if we need to confirm Sleep Request
261 received previously */
262 if (adapter
->ps_state
== PS_STATE_PRE_SLEEP
) {
263 if (!adapter
->cmd_sent
&& !adapter
->curr_cmd
)
264 mwifiex_check_ps_cond(adapter
);
267 /* * The ps_state may have been changed during processing of
268 * Sleep Request event.
270 if ((adapter
->ps_state
== PS_STATE_SLEEP
)
271 || (adapter
->ps_state
== PS_STATE_PRE_SLEEP
)
272 || (adapter
->ps_state
== PS_STATE_SLEEP_CFM
)
273 || adapter
->tx_lock_flag
)
276 if (!adapter
->cmd_sent
&& !adapter
->curr_cmd
) {
277 if (mwifiex_exec_next_cmd(adapter
) == -1) {
283 if (!adapter
->scan_processing
&& !adapter
->data_sent
&&
284 !mwifiex_wmm_lists_empty(adapter
)) {
285 mwifiex_wmm_process_tx(adapter
);
286 if (adapter
->hs_activated
) {
287 adapter
->is_hs_configured
= false;
288 mwifiex_hs_activated_event
290 (adapter
, MWIFIEX_BSS_ROLE_ANY
),
295 if (adapter
->delay_null_pkt
&& !adapter
->cmd_sent
&&
296 !adapter
->curr_cmd
&& !is_command_pending(adapter
)
297 && mwifiex_wmm_lists_empty(adapter
)) {
298 if (!mwifiex_send_null_packet
299 (mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_STA
),
300 MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET
|
301 MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET
)) {
302 adapter
->delay_null_pkt
= false;
303 adapter
->ps_state
= PS_STATE_SLEEP
;
309 if ((adapter
->int_status
) || IS_CARD_RX_RCVD(adapter
))
312 spin_lock_irqsave(&adapter
->main_proc_lock
, flags
);
313 adapter
->mwifiex_processing
= false;
314 spin_unlock_irqrestore(&adapter
->main_proc_lock
, flags
);
317 if (adapter
->hw_status
== MWIFIEX_HW_STATUS_CLOSING
)
318 mwifiex_shutdown_drv(adapter
);
323 * This function initializes the software.
325 * The main work includes allocating and initializing the adapter structure
326 * and initializing the private structures.
329 mwifiex_init_sw(void *card
, struct mwifiex_if_ops
*if_ops
)
332 struct mwifiex_drv_mode
*drv_mode_ptr
;
334 /* find mwifiex_drv_mode entry from mwifiex_drv_mode_tbl */
336 for (i
= 0; i
< ARRAY_SIZE(mwifiex_drv_mode_tbl
); i
++) {
337 if (mwifiex_drv_mode_tbl
[i
].drv_mode
== drv_mode
) {
338 drv_mode_ptr
= &mwifiex_drv_mode_tbl
[i
];
344 pr_err("invalid drv_mode=%d\n", drv_mode
);
348 if (mwifiex_register(card
, if_ops
, drv_mode_ptr
))
355 * This function frees the adapter structure.
357 * Additionally, this closes the netlink socket, frees the timers
358 * and private structures.
360 static void mwifiex_free_adapter(struct mwifiex_adapter
*adapter
)
363 pr_err("%s: adapter is NULL\n", __func__
);
367 mwifiex_unregister(adapter
);
368 pr_debug("info: %s: free adapter\n", __func__
);
372 * This function initializes the hardware and firmware.
374 * The main initialization steps followed are -
375 * - Download the correct firmware to card
376 * - Allocate and initialize the adapter structure
377 * - Initialize the private structures
378 * - Issue the init commands to firmware
380 static int mwifiex_init_hw_fw(struct mwifiex_adapter
*adapter
)
383 struct mwifiex_fw_image fw
;
385 memset(&fw
, 0, sizeof(struct mwifiex_fw_image
));
387 switch (adapter
->revision_id
) {
390 strcpy(fw_name
, SD8787_W1_FW_NAME
);
394 strcpy(fw_name
, SD8787_AX_FW_NAME
);
400 err
= request_firmware(&adapter
->firmware
, fw_name
, adapter
->dev
);
402 dev_err(adapter
->dev
, "request_firmware() returned"
403 " error code %#x\n", err
);
407 fw
.fw_buf
= (u8
*) adapter
->firmware
->data
;
408 fw
.fw_len
= adapter
->firmware
->size
;
410 ret
= mwifiex_dnld_fw(adapter
, &fw
);
414 dev_notice(adapter
->dev
, "WLAN FW is active\n");
416 adapter
->init_wait_q_woken
= false;
417 ret
= mwifiex_init_fw(adapter
);
421 adapter
->hw_status
= MWIFIEX_HW_STATUS_READY
;
424 /* Wait for mwifiex_init to complete */
425 wait_event_interruptible(adapter
->init_wait_q
,
426 adapter
->init_wait_q_woken
);
427 if (adapter
->hw_status
!= MWIFIEX_HW_STATUS_READY
) {
434 if (adapter
->firmware
)
435 release_firmware(adapter
->firmware
);
442 * This function fills a driver buffer.
444 * The function associates a given SKB with the provided driver buffer
445 * and also updates some of the SKB parameters, including IP header,
446 * priority and timestamp.
449 mwifiex_fill_buffer(struct sk_buff
*skb
)
456 eth
= (struct ethhdr
*) skb
->data
;
457 switch (eth
->h_proto
) {
458 case __constant_htons(ETH_P_IP
):
460 tid
= IPTOS_PREC(iph
->tos
);
461 pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n",
462 eth
->h_proto
, tid
, skb
->priority
);
464 case __constant_htons(ETH_P_ARP
):
465 pr_debug("data: ARP packet: %04x\n", eth
->h_proto
);
469 /* Offset for TOS field in the IP header */
470 #define IPTOS_OFFSET 5
471 tid
= (tid
>> IPTOS_OFFSET
);
473 /* Record the current time the packet was queued; used to
474 determine the amount of time the packet was queued in
475 the driver before it was sent to the firmware.
476 The delay is then sent along with the packet to the
477 firmware for aggregate delay calculation for stats and
478 MSDU lifetime expiry.
480 do_gettimeofday(&tv
);
481 skb
->tstamp
= timeval_to_ktime(tv
);
485 * CFG802.11 network device handler for open.
487 * Starts the data queue.
490 mwifiex_open(struct net_device
*dev
)
492 netif_start_queue(dev
);
497 * CFG802.11 network device handler for close.
500 mwifiex_close(struct net_device
*dev
)
506 * CFG802.11 network device handler for data transmission.
509 mwifiex_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
511 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
512 struct sk_buff
*new_skb
;
513 struct mwifiex_txinfo
*tx_info
;
515 dev_dbg(priv
->adapter
->dev
, "data: %lu BSS(%d): Data <= kernel\n",
516 jiffies
, priv
->bss_index
);
518 if (priv
->adapter
->surprise_removed
) {
520 priv
->stats
.tx_dropped
++;
523 if (!skb
->len
|| (skb
->len
> ETH_FRAME_LEN
)) {
524 dev_err(priv
->adapter
->dev
, "Tx: bad skb len %d\n", skb
->len
);
526 priv
->stats
.tx_dropped
++;
529 if (skb_headroom(skb
) < MWIFIEX_MIN_DATA_HEADER_LEN
) {
530 dev_dbg(priv
->adapter
->dev
,
531 "data: Tx: insufficient skb headroom %d\n",
533 /* Insufficient skb headroom - allocate a new skb */
535 skb_realloc_headroom(skb
, MWIFIEX_MIN_DATA_HEADER_LEN
);
536 if (unlikely(!new_skb
)) {
537 dev_err(priv
->adapter
->dev
, "Tx: cannot alloca new_skb\n");
539 priv
->stats
.tx_dropped
++;
544 dev_dbg(priv
->adapter
->dev
, "info: new skb headroomd %d\n",
548 tx_info
= MWIFIEX_SKB_TXCB(skb
);
549 tx_info
->bss_index
= priv
->bss_index
;
550 mwifiex_fill_buffer(skb
);
552 mwifiex_wmm_add_buf_txqueue(priv
->adapter
, skb
);
553 atomic_inc(&priv
->adapter
->tx_pending
);
555 if (atomic_read(&priv
->adapter
->tx_pending
) >= MAX_TX_PENDING
) {
556 netif_stop_queue(priv
->netdev
);
557 dev
->trans_start
= jiffies
;
560 queue_work(priv
->adapter
->workqueue
, &priv
->adapter
->main_work
);
566 * CFG802.11 network device handler for setting MAC address.
569 mwifiex_set_mac_address(struct net_device
*dev
, void *addr
)
571 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
572 struct sockaddr
*hw_addr
= (struct sockaddr
*) addr
;
575 memcpy(priv
->curr_addr
, hw_addr
->sa_data
, ETH_ALEN
);
577 /* Send request to firmware */
578 ret
= mwifiex_send_cmd_sync(priv
, HostCmd_CMD_802_11_MAC_ADDRESS
,
579 HostCmd_ACT_GEN_SET
, 0, NULL
);
582 memcpy(priv
->netdev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
584 dev_err(priv
->adapter
->dev
, "set mac address failed: ret=%d"
587 memcpy(dev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
593 * CFG802.11 network device handler for setting multicast list.
595 static void mwifiex_set_multicast_list(struct net_device
*dev
)
597 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
598 struct mwifiex_multicast_list mcast_list
;
600 if (dev
->flags
& IFF_PROMISC
) {
601 mcast_list
.mode
= MWIFIEX_PROMISC_MODE
;
602 } else if (dev
->flags
& IFF_ALLMULTI
||
603 netdev_mc_count(dev
) > MWIFIEX_MAX_MULTICAST_LIST_SIZE
) {
604 mcast_list
.mode
= MWIFIEX_ALL_MULTI_MODE
;
606 mcast_list
.mode
= MWIFIEX_MULTICAST_MODE
;
607 if (netdev_mc_count(dev
))
608 mcast_list
.num_multicast_addr
=
609 mwifiex_copy_mcast_addr(&mcast_list
, dev
);
611 mwifiex_request_set_multicast_list(priv
, &mcast_list
);
615 * CFG802.11 network device handler for transmission timeout.
618 mwifiex_tx_timeout(struct net_device
*dev
)
620 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
622 dev_err(priv
->adapter
->dev
, "%lu : Tx timeout, bss_index=%d\n",
623 jiffies
, priv
->bss_index
);
624 dev
->trans_start
= jiffies
;
625 priv
->num_tx_timeout
++;
629 * CFG802.11 network device handler for statistics retrieval.
631 static struct net_device_stats
*mwifiex_get_stats(struct net_device
*dev
)
633 struct mwifiex_private
*priv
= mwifiex_netdev_get_priv(dev
);
638 /* Network device handlers */
639 static const struct net_device_ops mwifiex_netdev_ops
= {
640 .ndo_open
= mwifiex_open
,
641 .ndo_stop
= mwifiex_close
,
642 .ndo_start_xmit
= mwifiex_hard_start_xmit
,
643 .ndo_set_mac_address
= mwifiex_set_mac_address
,
644 .ndo_tx_timeout
= mwifiex_tx_timeout
,
645 .ndo_get_stats
= mwifiex_get_stats
,
646 .ndo_set_multicast_list
= mwifiex_set_multicast_list
,
650 * This function initializes the private structure parameters.
652 * The following wait queues are initialized -
654 * - Command wait queue
655 * - Statistics wait queue
657 * ...and the following default parameters are set -
658 * - Current key index : Set to 0
659 * - Rate index : Set to auto
660 * - Media connected : Set to disconnected
661 * - Adhoc link sensed : Set to false
662 * - Nick name : Set to null
663 * - Number of Tx timeout : Set to 0
664 * - Device address : Set to current address
666 * In addition, the CFG80211 work queue is also created.
669 mwifiex_init_priv_params(struct mwifiex_private
*priv
, struct net_device
*dev
)
671 dev
->netdev_ops
= &mwifiex_netdev_ops
;
672 /* Initialize private structure */
673 priv
->current_key_index
= 0;
674 priv
->media_connected
= false;
675 memset(&priv
->nick_name
, 0, sizeof(priv
->nick_name
));
676 priv
->num_tx_timeout
= 0;
677 priv
->workqueue
= create_singlethread_workqueue("cfg80211_wq");
678 INIT_WORK(&priv
->cfg_workqueue
, mwifiex_cfg80211_results
);
679 memcpy(dev
->dev_addr
, priv
->curr_addr
, ETH_ALEN
);
683 * This function adds a new logical interface.
685 * It allocates, initializes and registers the interface by performing
686 * the following opearations -
687 * - Allocate a new net device structure
688 * - Assign device name
689 * - Register the new device with CFG80211 subsystem
690 * - Initialize semaphore and private structure
691 * - Register the new device with kernel
692 * - Create the complete debug FS structure if configured
694 static struct mwifiex_private
*mwifiex_add_interface(
695 struct mwifiex_adapter
*adapter
,
696 u8 bss_index
, u8 bss_type
)
698 struct net_device
*dev
;
699 struct mwifiex_private
*priv
;
702 dev
= alloc_netdev_mq(sizeof(struct mwifiex_private
*), "mlan%d",
705 dev_err(adapter
->dev
, "no memory available for netdevice\n");
709 if (mwifiex_register_cfg80211(dev
, adapter
->priv
[bss_index
]->curr_addr
,
710 adapter
->priv
[bss_index
]) != 0) {
711 dev_err(adapter
->dev
, "cannot register netdevice with cfg80211\n");
714 /* Save the priv pointer in netdev */
715 priv
= adapter
->priv
[bss_index
];
716 mdev_priv
= netdev_priv(dev
);
717 *((unsigned long *) mdev_priv
) = (unsigned long) priv
;
721 sema_init(&priv
->async_sem
, 1);
722 priv
->scan_pending_on_block
= false;
724 mwifiex_init_priv_params(priv
, dev
);
726 SET_NETDEV_DEV(dev
, adapter
->dev
);
728 /* Register network device */
729 if (register_netdev(dev
)) {
730 dev_err(adapter
->dev
, "cannot register virtual network device\n");
734 dev_dbg(adapter
->dev
, "info: %s: Marvell 802.11 Adapter\n", dev
->name
);
735 #ifdef CONFIG_DEBUG_FS
736 mwifiex_dev_debugfs_init(priv
);
746 * This function removes a logical interface.
748 * It deregisters, resets and frees the interface by performing
749 * the following operations -
750 * - Disconnect the device if connected, send wireless event to
751 * notify applications.
752 * - Remove the debug FS structure if configured
753 * - Unregister the device from kernel
754 * - Free the net device structure
755 * - Cancel all works and destroy work queue
756 * - Unregister and free the wireless device from CFG80211 subsystem
759 mwifiex_remove_interface(struct mwifiex_adapter
*adapter
, u8 bss_index
)
761 struct net_device
*dev
;
762 struct mwifiex_private
*priv
= adapter
->priv
[bss_index
];
768 if (priv
->media_connected
)
769 priv
->media_connected
= false;
771 #ifdef CONFIG_DEBUG_FS
772 mwifiex_dev_debugfs_remove(priv
);
774 /* Last reference is our one */
775 dev_dbg(adapter
->dev
, "info: %s: refcnt = %d\n",
776 dev
->name
, netdev_refcnt_read(dev
));
778 if (dev
->reg_state
== NETREG_REGISTERED
)
779 unregister_netdev(dev
);
781 /* Clear the priv in adapter */
786 cancel_work_sync(&priv
->cfg_workqueue
);
787 flush_workqueue(priv
->workqueue
);
788 destroy_workqueue(priv
->workqueue
);
789 wiphy_unregister(priv
->wdev
->wiphy
);
790 wiphy_free(priv
->wdev
->wiphy
);
795 * This function check if command is pending.
797 int is_command_pending(struct mwifiex_adapter
*adapter
)
800 int is_cmd_pend_q_empty
;
802 spin_lock_irqsave(&adapter
->cmd_pending_q_lock
, flags
);
803 is_cmd_pend_q_empty
= list_empty(&adapter
->cmd_pending_q
);
804 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
, flags
);
806 return !is_cmd_pend_q_empty
;
810 * This function returns the correct private structure pointer based
811 * upon the BSS number.
813 struct mwifiex_private
*
814 mwifiex_bss_index_to_priv(struct mwifiex_adapter
*adapter
, u8 bss_index
)
816 if (!adapter
|| (bss_index
>= adapter
->priv_num
))
818 return adapter
->priv
[bss_index
];
822 * This is the main work queue function.
824 * It handles the main process, which in turn handles the complete
827 static void mwifiex_main_work_queue(struct work_struct
*work
)
829 struct mwifiex_adapter
*adapter
=
830 container_of(work
, struct mwifiex_adapter
, main_work
);
832 if (adapter
->surprise_removed
)
834 mwifiex_main_process(adapter
);
838 * This function cancels all works in the queue and destroys
839 * the main workqueue.
842 mwifiex_terminate_workqueue(struct mwifiex_adapter
*adapter
)
844 flush_workqueue(adapter
->workqueue
);
845 destroy_workqueue(adapter
->workqueue
);
846 adapter
->workqueue
= NULL
;
850 * This function adds the card.
852 * This function follows the following major steps to set up the device -
853 * - Initialize software. This includes probing the card, registering
854 * the interface operations table, and allocating/initializing the
856 * - Set up the netlink socket
857 * - Create and start the main work queue
858 * - Register the device
859 * - Initialize firmware and hardware
860 * - Add logical interfaces
863 mwifiex_add_card(void *card
, struct semaphore
*sem
,
864 struct mwifiex_if_ops
*if_ops
)
867 struct mwifiex_adapter
*adapter
;
869 if (down_interruptible(sem
))
872 if (mwifiex_init_sw(card
, if_ops
)) {
873 pr_err("%s: software init failed\n", __func__
);
879 adapter
->hw_status
= MWIFIEX_HW_STATUS_INITIALIZING
;
880 adapter
->surprise_removed
= false;
881 init_waitqueue_head(&adapter
->init_wait_q
);
882 adapter
->is_suspended
= false;
883 adapter
->hs_activated
= false;
884 init_waitqueue_head(&adapter
->hs_activate_wait_q
);
885 adapter
->cmd_wait_q_required
= false;
886 init_waitqueue_head(&adapter
->cmd_wait_q
.wait
);
887 adapter
->cmd_wait_q
.condition
= false;
888 adapter
->cmd_wait_q
.status
= 0;
890 adapter
->workqueue
= create_workqueue("MWIFIEX_WORK_QUEUE");
891 if (!adapter
->workqueue
)
894 INIT_WORK(&adapter
->main_work
, mwifiex_main_work_queue
);
896 /* Register the device. Fill up the private data structure with relevant
897 information from the card and request for the required IRQ. */
898 if (adapter
->if_ops
.register_dev(adapter
)) {
899 pr_err("%s: failed to register mwifiex device\n", __func__
);
900 goto err_registerdev
;
903 if (mwifiex_init_hw_fw(adapter
)) {
904 pr_err("%s: firmware init failed\n", __func__
);
909 for (i
= 0; i
< adapter
->drv_mode
->intf_num
; i
++) {
910 if (!mwifiex_add_interface(adapter
, i
,
911 adapter
->drv_mode
->bss_attr
[i
].bss_type
)) {
921 for (i
= 0; i
< adapter
->priv_num
; i
++)
922 mwifiex_remove_interface(adapter
, i
);
924 pr_debug("info: %s: unregister device\n", __func__
);
925 adapter
->if_ops
.unregister_dev(adapter
);
927 adapter
->surprise_removed
= true;
928 mwifiex_terminate_workqueue(adapter
);
930 if ((adapter
->hw_status
== MWIFIEX_HW_STATUS_FW_READY
) ||
931 (adapter
->hw_status
== MWIFIEX_HW_STATUS_READY
)) {
932 pr_debug("info: %s: shutdown mwifiex\n", __func__
);
933 adapter
->init_wait_q_woken
= false;
935 if (mwifiex_shutdown_drv(adapter
) == -EINPROGRESS
)
936 wait_event_interruptible(adapter
->init_wait_q
,
937 adapter
->init_wait_q_woken
);
940 mwifiex_free_adapter(adapter
);
948 EXPORT_SYMBOL_GPL(mwifiex_add_card
);
951 * This function removes the card.
953 * This function follows the following major steps to remove the device -
954 * - Stop data traffic
955 * - Shutdown firmware
956 * - Remove the logical interfaces
957 * - Terminate the work queue
958 * - Unregister the device
959 * - Free the adapter structure
961 int mwifiex_remove_card(struct mwifiex_adapter
*adapter
, struct semaphore
*sem
)
963 struct mwifiex_private
*priv
= NULL
;
966 if (down_interruptible(sem
))
972 adapter
->surprise_removed
= true;
975 for (i
= 0; i
< adapter
->priv_num
; i
++) {
976 priv
= adapter
->priv
[i
];
978 if (!netif_queue_stopped(priv
->netdev
))
979 netif_stop_queue(priv
->netdev
);
980 if (netif_carrier_ok(priv
->netdev
))
981 netif_carrier_off(priv
->netdev
);
985 dev_dbg(adapter
->dev
, "cmd: calling mwifiex_shutdown_drv...\n");
986 adapter
->init_wait_q_woken
= false;
988 if (mwifiex_shutdown_drv(adapter
) == -EINPROGRESS
)
989 wait_event_interruptible(adapter
->init_wait_q
,
990 adapter
->init_wait_q_woken
);
991 dev_dbg(adapter
->dev
, "cmd: mwifiex_shutdown_drv done\n");
992 if (atomic_read(&adapter
->rx_pending
) ||
993 atomic_read(&adapter
->tx_pending
) ||
994 atomic_read(&adapter
->cmd_pending
)) {
995 dev_err(adapter
->dev
, "rx_pending=%d, tx_pending=%d, "
997 atomic_read(&adapter
->rx_pending
),
998 atomic_read(&adapter
->tx_pending
),
999 atomic_read(&adapter
->cmd_pending
));
1002 /* Remove interface */
1003 for (i
= 0; i
< adapter
->priv_num
; i
++)
1004 mwifiex_remove_interface(adapter
, i
);
1006 mwifiex_terminate_workqueue(adapter
);
1008 /* Unregister device */
1009 dev_dbg(adapter
->dev
, "info: unregister device\n");
1010 adapter
->if_ops
.unregister_dev(adapter
);
1011 /* Free adapter structure */
1012 dev_dbg(adapter
->dev
, "info: free adapter\n");
1013 mwifiex_free_adapter(adapter
);
1020 EXPORT_SYMBOL_GPL(mwifiex_remove_card
);
1023 * This function initializes the module.
1025 * The debug FS is also initialized if configured.
1028 mwifiex_init_module(void)
1030 #ifdef CONFIG_DEBUG_FS
1031 mwifiex_debugfs_init();
1037 * This function cleans up the module.
1039 * The debug FS is removed if available.
1042 mwifiex_cleanup_module(void)
1044 #ifdef CONFIG_DEBUG_FS
1045 mwifiex_debugfs_remove();
1049 module_init(mwifiex_init_module
);
1050 module_exit(mwifiex_cleanup_module
);
1052 MODULE_AUTHOR("Marvell International Ltd.");
1053 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION
);
1054 MODULE_VERSION(VERSION
);
1055 MODULE_LICENSE("GPL v2");