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");
added
removed
drivers/net/wireless/mwifiex/main.c
