1 /*
2 * Marvell Wireless LAN device driver: HW/FW Initialization
3 *
4 * Copyright (C) 2011-2014, Marvell International Ltd.
5 *
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.
13 *
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.
18 */
19
20 #include "decl.h"
21 #include "ioctl.h"
22 #include "util.h"
23 #include "fw.h"
24 #include "main.h"
25 #include "wmm.h"
26 #include "11n.h"
27
28 /*
29 * This function adds a BSS priority table to the table list.
30 *
31 * The function allocates a new BSS priority table node and adds it to
32 * the end of BSS priority table list, kept in driver memory.
33 */
mwifiex_add_bss_prio_tbl(struct mwifiex_private * priv)34 static int mwifiex_add_bss_prio_tbl(struct mwifiex_private *priv)
35 {
36 struct mwifiex_adapter *adapter = priv->adapter;
37 struct mwifiex_bss_prio_node *bss_prio;
38 struct mwifiex_bss_prio_tbl *tbl = adapter->bss_prio_tbl;
39 unsigned long flags;
40
41 bss_prio = kzalloc(sizeof(struct mwifiex_bss_prio_node), GFP_KERNEL);
42 if (!bss_prio)
43 return -ENOMEM;
44
45 bss_prio->priv = priv;
46 INIT_LIST_HEAD(&bss_prio->list);
47
48 spin_lock_irqsave(&tbl[priv->bss_priority].bss_prio_lock, flags);
49 list_add_tail(&bss_prio->list, &tbl[priv->bss_priority].bss_prio_head);
50 spin_unlock_irqrestore(&tbl[priv->bss_priority].bss_prio_lock, flags);
51
52 return 0;
53 }
54
wakeup_timer_fn(unsigned long data)55 static void wakeup_timer_fn(unsigned long data)
56 {
57 struct mwifiex_adapter *adapter = (struct mwifiex_adapter *)data;
58
59 mwifiex_dbg(adapter, ERROR, "Firmware wakeup failed\n");
60 adapter->hw_status = MWIFIEX_HW_STATUS_RESET;
61 mwifiex_cancel_all_pending_cmd(adapter);
62
63 if (adapter->if_ops.card_reset && !adapter->hs_activated)
64 adapter->if_ops.card_reset(adapter);
65 }
66
67 /*
68 * This function initializes the private structure and sets default
69 * values to the members.
70 *
71 * Additionally, it also initializes all the locks and sets up all the
72 * lists.
73 */
mwifiex_init_priv(struct mwifiex_private * priv)74 int mwifiex_init_priv(struct mwifiex_private *priv)
75 {
76 u32 i;
77
78 priv->media_connected = false;
79 eth_broadcast_addr(priv->curr_addr);
80 priv->port_open = false;
81 priv->usb_port = MWIFIEX_USB_EP_DATA;
82 priv->pkt_tx_ctrl = 0;
83 priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
84 priv->data_rate = 0; /* Initially indicate the rate as auto */
85 priv->is_data_rate_auto = true;
86 priv->bcn_avg_factor = DEFAULT_BCN_AVG_FACTOR;
87 priv->data_avg_factor = DEFAULT_DATA_AVG_FACTOR;
88
89 priv->sec_info.wep_enabled = 0;
90 priv->sec_info.authentication_mode = NL80211_AUTHTYPE_OPEN_SYSTEM;
91 priv->sec_info.encryption_mode = 0;
92 for (i = 0; i < ARRAY_SIZE(priv->wep_key); i++)
93 memset(&priv->wep_key[i], 0, sizeof(struct mwifiex_wep_key));
94 priv->wep_key_curr_index = 0;
95 priv->curr_pkt_filter = HostCmd_ACT_MAC_RX_ON | HostCmd_ACT_MAC_TX_ON |
96 HostCmd_ACT_MAC_ETHERNETII_ENABLE;
97
98 priv->beacon_period = 100; /* beacon interval */
99 priv->attempted_bss_desc = NULL;
100 memset(&priv->curr_bss_params, 0, sizeof(priv->curr_bss_params));
101 priv->listen_interval = MWIFIEX_DEFAULT_LISTEN_INTERVAL;
102
103 memset(&priv->prev_ssid, 0, sizeof(priv->prev_ssid));
104 memset(&priv->prev_bssid, 0, sizeof(priv->prev_bssid));
105 memset(&priv->assoc_rsp_buf, 0, sizeof(priv->assoc_rsp_buf));
106 priv->assoc_rsp_size = 0;
107 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL;
108 priv->atim_window = 0;
109 priv->adhoc_state = ADHOC_IDLE;
110 priv->tx_power_level = 0;
111 priv->max_tx_power_level = 0;
112 priv->min_tx_power_level = 0;
113 priv->tx_ant = 0;
114 priv->rx_ant = 0;
115 priv->tx_rate = 0;
116 priv->rxpd_htinfo = 0;
117 priv->rxpd_rate = 0;
118 priv->rate_bitmap = 0;
119 priv->data_rssi_last = 0;
120 priv->data_rssi_avg = 0;
121 priv->data_nf_avg = 0;
122 priv->data_nf_last = 0;
123 priv->bcn_rssi_last = 0;
124 priv->bcn_rssi_avg = 0;
125 priv->bcn_nf_avg = 0;
126 priv->bcn_nf_last = 0;
127 memset(&priv->wpa_ie, 0, sizeof(priv->wpa_ie));
128 memset(&priv->aes_key, 0, sizeof(priv->aes_key));
129 priv->wpa_ie_len = 0;
130 priv->wpa_is_gtk_set = false;
131
132 memset(&priv->assoc_tlv_buf, 0, sizeof(priv->assoc_tlv_buf));
133 priv->assoc_tlv_buf_len = 0;
134 memset(&priv->wps, 0, sizeof(priv->wps));
135 memset(&priv->gen_ie_buf, 0, sizeof(priv->gen_ie_buf));
136 priv->gen_ie_buf_len = 0;
137 memset(priv->vs_ie, 0, sizeof(priv->vs_ie));
138
139 priv->wmm_required = true;
140 priv->wmm_enabled = false;
141 priv->wmm_qosinfo = 0;
142 priv->curr_bcn_buf = NULL;
143 priv->curr_bcn_size = 0;
144 priv->wps_ie = NULL;
145 priv->wps_ie_len = 0;
146 priv->ap_11n_enabled = 0;
147 memset(&priv->roc_cfg, 0, sizeof(priv->roc_cfg));
148
149 priv->scan_block = false;
150
151 priv->csa_chan = 0;
152 priv->csa_expire_time = 0;
153 priv->del_list_idx = 0;
154 priv->hs2_enabled = false;
155 priv->check_tdls_tx = false;
156 memcpy(priv->tos_to_tid_inv, tos_to_tid_inv, MAX_NUM_TID);
157
158 mwifiex_init_11h_params(priv);
159
160 return mwifiex_add_bss_prio_tbl(priv);
161 }
162
163 /*
164 * This function allocates buffers for members of the adapter
165 * structure.
166 *
167 * The memory allocated includes scan table, command buffers, and
168 * sleep confirm command buffer. In addition, the queues are
169 * also initialized.
170 */
mwifiex_allocate_adapter(struct mwifiex_adapter * adapter)171 static int mwifiex_allocate_adapter(struct mwifiex_adapter *adapter)
172 {
173 int ret;
174
175 /* Allocate command buffer */
176 ret = mwifiex_alloc_cmd_buffer(adapter);
177 if (ret) {
178 mwifiex_dbg(adapter, ERROR,
179 "%s: failed to alloc cmd buffer\n",
180 __func__);
181 return -1;
182 }
183
184 adapter->sleep_cfm =
185 dev_alloc_skb(sizeof(struct mwifiex_opt_sleep_confirm)
186 + INTF_HEADER_LEN);
187
188 if (!adapter->sleep_cfm) {
189 mwifiex_dbg(adapter, ERROR,
190 "%s: failed to alloc sleep cfm\t"
191 " cmd buffer\n", __func__);
192 return -1;
193 }
194 skb_reserve(adapter->sleep_cfm, INTF_HEADER_LEN);
195
196 return 0;
197 }
198
199 /*
200 * This function initializes the adapter structure and sets default
201 * values to the members of adapter.
202 *
203 * This also initializes the WMM related parameters in the driver private
204 * structures.
205 */
mwifiex_init_adapter(struct mwifiex_adapter * adapter)206 static void mwifiex_init_adapter(struct mwifiex_adapter *adapter)
207 {
208 struct mwifiex_opt_sleep_confirm *sleep_cfm_buf = NULL;
209
210 skb_put(adapter->sleep_cfm, sizeof(struct mwifiex_opt_sleep_confirm));
211
212 adapter->cmd_sent = false;
213
214 if (adapter->iface_type == MWIFIEX_SDIO)
215 adapter->data_sent = true;
216 else
217 adapter->data_sent = false;
218
219 adapter->cmd_resp_received = false;
220 adapter->event_received = false;
221 adapter->data_received = false;
222
223 adapter->surprise_removed = false;
224
225 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
226
227 adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_CAM;
228 adapter->ps_state = PS_STATE_AWAKE;
229 adapter->need_to_wakeup = false;
230
231 adapter->scan_mode = HostCmd_BSS_MODE_ANY;
232 adapter->specific_scan_time = MWIFIEX_SPECIFIC_SCAN_CHAN_TIME;
233 adapter->active_scan_time = MWIFIEX_ACTIVE_SCAN_CHAN_TIME;
234 adapter->passive_scan_time = MWIFIEX_PASSIVE_SCAN_CHAN_TIME;
235 adapter->scan_chan_gap_time = MWIFIEX_DEF_SCAN_CHAN_GAP_TIME;
236
237 adapter->scan_probes = 1;
238
239 adapter->multiple_dtim = 1;
240
241 adapter->local_listen_interval = 0; /* default value in firmware
242 will be used */
243
244 adapter->is_deep_sleep = false;
245
246 adapter->delay_null_pkt = false;
247 adapter->delay_to_ps = 1000;
248 adapter->enhanced_ps_mode = PS_MODE_AUTO;
249
250 adapter->gen_null_pkt = false; /* Disable NULL Pkg generation by
251 default */
252 adapter->pps_uapsd_mode = false; /* Disable pps/uapsd mode by
253 default */
254 adapter->pm_wakeup_card_req = false;
255
256 adapter->pm_wakeup_fw_try = false;
257
258 adapter->curr_tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_2K;
259
260 adapter->is_hs_configured = false;
261 adapter->hs_cfg.conditions = cpu_to_le32(HS_CFG_COND_DEF);
262 adapter->hs_cfg.gpio = HS_CFG_GPIO_DEF;
263 adapter->hs_cfg.gap = HS_CFG_GAP_DEF;
264 adapter->hs_activated = false;
265
266 memset(adapter->event_body, 0, sizeof(adapter->event_body));
267 adapter->hw_dot_11n_dev_cap = 0;
268 adapter->hw_dev_mcs_support = 0;
269 adapter->sec_chan_offset = 0;
270 adapter->adhoc_11n_enabled = false;
271
272 mwifiex_wmm_init(adapter);
273
274 sleep_cfm_buf = (struct mwifiex_opt_sleep_confirm *)
275 adapter->sleep_cfm->data;
276 memset(sleep_cfm_buf, 0, adapter->sleep_cfm->len);
277 sleep_cfm_buf->command = cpu_to_le16(HostCmd_CMD_802_11_PS_MODE_ENH);
278 sleep_cfm_buf->size = cpu_to_le16(adapter->sleep_cfm->len);
279 sleep_cfm_buf->result = 0;
280 sleep_cfm_buf->action = cpu_to_le16(SLEEP_CONFIRM);
281 sleep_cfm_buf->resp_ctrl = cpu_to_le16(RESP_NEEDED);
282
283 memset(&adapter->sleep_params, 0, sizeof(adapter->sleep_params));
284 memset(&adapter->sleep_period, 0, sizeof(adapter->sleep_period));
285 adapter->tx_lock_flag = false;
286 adapter->null_pkt_interval = 0;
287 adapter->fw_bands = 0;
288 adapter->config_bands = 0;
289 adapter->adhoc_start_band = 0;
290 adapter->scan_channels = NULL;
291 adapter->fw_release_number = 0;
292 adapter->fw_cap_info = 0;
293 memset(&adapter->upld_buf, 0, sizeof(adapter->upld_buf));
294 adapter->event_cause = 0;
295 adapter->region_code = 0;
296 adapter->bcn_miss_time_out = DEFAULT_BCN_MISS_TIMEOUT;
297 adapter->adhoc_awake_period = 0;
298 memset(&adapter->arp_filter, 0, sizeof(adapter->arp_filter));
299 adapter->arp_filter_size = 0;
300 adapter->max_mgmt_ie_index = MAX_MGMT_IE_INDEX;
301 adapter->mfg_mode = mfg_mode;
302 adapter->key_api_major_ver = 0;
303 adapter->key_api_minor_ver = 0;
304 eth_broadcast_addr(adapter->perm_addr);
305 adapter->iface_limit.sta_intf = MWIFIEX_MAX_STA_NUM;
306 adapter->iface_limit.uap_intf = MWIFIEX_MAX_UAP_NUM;
307 adapter->iface_limit.p2p_intf = MWIFIEX_MAX_P2P_NUM;
308 adapter->active_scan_triggered = false;
309 setup_timer(&adapter->wakeup_timer, wakeup_timer_fn,
310 (unsigned long)adapter);
311 }
312
313 /*
314 * This function sets trans_start per tx_queue
315 */
mwifiex_set_trans_start(struct net_device * dev)316 void mwifiex_set_trans_start(struct net_device *dev)
317 {
318 int i;
319
320 for (i = 0; i < dev->num_tx_queues; i++)
321 netdev_get_tx_queue(dev, i)->trans_start = jiffies;
322
323 netif_trans_update(dev);
324 }
325
326 /*
327 * This function wakes up all queues in net_device
328 */
mwifiex_wake_up_net_dev_queue(struct net_device * netdev,struct mwifiex_adapter * adapter)329 void mwifiex_wake_up_net_dev_queue(struct net_device *netdev,
330 struct mwifiex_adapter *adapter)
331 {
332 unsigned long dev_queue_flags;
333 unsigned int i;
334
335 spin_lock_irqsave(&adapter->queue_lock, dev_queue_flags);
336
337 for (i = 0; i < netdev->num_tx_queues; i++) {
338 struct netdev_queue *txq = netdev_get_tx_queue(netdev, i);
339
340 if (netif_tx_queue_stopped(txq))
341 netif_tx_wake_queue(txq);
342 }
343
344 spin_unlock_irqrestore(&adapter->queue_lock, dev_queue_flags);
345 }
346
347 /*
348 * This function stops all queues in net_device
349 */
mwifiex_stop_net_dev_queue(struct net_device * netdev,struct mwifiex_adapter * adapter)350 void mwifiex_stop_net_dev_queue(struct net_device *netdev,
351 struct mwifiex_adapter *adapter)
352 {
353 unsigned long dev_queue_flags;
354 unsigned int i;
355
356 spin_lock_irqsave(&adapter->queue_lock, dev_queue_flags);
357
358 for (i = 0; i < netdev->num_tx_queues; i++) {
359 struct netdev_queue *txq = netdev_get_tx_queue(netdev, i);
360
361 if (!netif_tx_queue_stopped(txq))
362 netif_tx_stop_queue(txq);
363 }
364
365 spin_unlock_irqrestore(&adapter->queue_lock, dev_queue_flags);
366 }
367
368 /*
369 * This function releases the lock variables and frees the locks and
370 * associated locks.
371 */
mwifiex_free_lock_list(struct mwifiex_adapter * adapter)372 static void mwifiex_free_lock_list(struct mwifiex_adapter *adapter)
373 {
374 struct mwifiex_private *priv;
375 s32 i, j;
376
377 /* Free lists */
378 list_del(&adapter->cmd_free_q);
379 list_del(&adapter->cmd_pending_q);
380 list_del(&adapter->scan_pending_q);
381
382 for (i = 0; i < adapter->priv_num; i++)
383 list_del(&adapter->bss_prio_tbl[i].bss_prio_head);
384
385 for (i = 0; i < adapter->priv_num; i++) {
386 if (adapter->priv[i]) {
387 priv = adapter->priv[i];
388 for (j = 0; j < MAX_NUM_TID; ++j)
389 list_del(&priv->wmm.tid_tbl_ptr[j].ra_list);
390 list_del(&priv->tx_ba_stream_tbl_ptr);
391 list_del(&priv->rx_reorder_tbl_ptr);
392 list_del(&priv->sta_list);
393 list_del(&priv->auto_tdls_list);
394 }
395 }
396 }
397
398 /*
399 * This function performs cleanup for adapter structure.
400 *
401 * The cleanup is done recursively, by canceling all pending
402 * commands, freeing the member buffers previously allocated
403 * (command buffers, scan table buffer, sleep confirm command
404 * buffer), stopping the timers and calling the cleanup routines
405 * for every interface.
406 */
407 static void
mwifiex_adapter_cleanup(struct mwifiex_adapter * adapter)408 mwifiex_adapter_cleanup(struct mwifiex_adapter *adapter)
409 {
410 int idx;
411
412 if (!adapter) {
413 pr_err("%s: adapter is NULL\n", __func__);
414 return;
415 }
416
417 del_timer(&adapter->wakeup_timer);
418 mwifiex_cancel_all_pending_cmd(adapter);
419 wake_up_interruptible(&adapter->cmd_wait_q.wait);
420 wake_up_interruptible(&adapter->hs_activate_wait_q);
421
422 /* Free lock variables */
423 mwifiex_free_lock_list(adapter);
424
425 /* Free command buffer */
426 mwifiex_dbg(adapter, INFO, "info: free cmd buffer\n");
427 mwifiex_free_cmd_buffer(adapter);
428
429 for (idx = 0; idx < adapter->num_mem_types; idx++) {
430 struct memory_type_mapping *entry =
431 &adapter->mem_type_mapping_tbl[idx];
432
433 if (entry->mem_ptr) {
434 vfree(entry->mem_ptr);
435 entry->mem_ptr = NULL;
436 }
437 entry->mem_size = 0;
438 }
439
440 if (adapter->drv_info_dump) {
441 vfree(adapter->drv_info_dump);
442 adapter->drv_info_dump = NULL;
443 adapter->drv_info_size = 0;
444 }
445
446 if (adapter->sleep_cfm)
447 dev_kfree_skb_any(adapter->sleep_cfm);
448 }
449
450 /*
451 * This function intializes the lock variables and
452 * the list heads.
453 */
mwifiex_init_lock_list(struct mwifiex_adapter * adapter)454 int mwifiex_init_lock_list(struct mwifiex_adapter *adapter)
455 {
456 struct mwifiex_private *priv;
457 s32 i, j;
458
459 spin_lock_init(&adapter->mwifiex_lock);
460 spin_lock_init(&adapter->int_lock);
461 spin_lock_init(&adapter->main_proc_lock);
462 spin_lock_init(&adapter->mwifiex_cmd_lock);
463 spin_lock_init(&adapter->queue_lock);
464 for (i = 0; i < adapter->priv_num; i++) {
465 if (adapter->priv[i]) {
466 priv = adapter->priv[i];
467 spin_lock_init(&priv->rx_pkt_lock);
468 spin_lock_init(&priv->wmm.ra_list_spinlock);
469 spin_lock_init(&priv->curr_bcn_buf_lock);
470 spin_lock_init(&priv->sta_list_spinlock);
471 spin_lock_init(&priv->auto_tdls_lock);
472 }
473 }
474
475 /* Initialize cmd_free_q */
476 INIT_LIST_HEAD(&adapter->cmd_free_q);
477 /* Initialize cmd_pending_q */
478 INIT_LIST_HEAD(&adapter->cmd_pending_q);
479 /* Initialize scan_pending_q */
480 INIT_LIST_HEAD(&adapter->scan_pending_q);
481
482 spin_lock_init(&adapter->cmd_free_q_lock);
483 spin_lock_init(&adapter->cmd_pending_q_lock);
484 spin_lock_init(&adapter->scan_pending_q_lock);
485 spin_lock_init(&adapter->rx_proc_lock);
486
487 skb_queue_head_init(&adapter->rx_data_q);
488 skb_queue_head_init(&adapter->tx_data_q);
489
490 for (i = 0; i < adapter->priv_num; ++i) {
491 INIT_LIST_HEAD(&adapter->bss_prio_tbl[i].bss_prio_head);
492 spin_lock_init(&adapter->bss_prio_tbl[i].bss_prio_lock);
493 }
494
495 for (i = 0; i < adapter->priv_num; i++) {
496 if (!adapter->priv[i])
497 continue;
498 priv = adapter->priv[i];
499 for (j = 0; j < MAX_NUM_TID; ++j)
500 INIT_LIST_HEAD(&priv->wmm.tid_tbl_ptr[j].ra_list);
501 INIT_LIST_HEAD(&priv->tx_ba_stream_tbl_ptr);
502 INIT_LIST_HEAD(&priv->rx_reorder_tbl_ptr);
503 INIT_LIST_HEAD(&priv->sta_list);
504 INIT_LIST_HEAD(&priv->auto_tdls_list);
505 skb_queue_head_init(&priv->tdls_txq);
506 skb_queue_head_init(&priv->bypass_txq);
507
508 spin_lock_init(&priv->tx_ba_stream_tbl_lock);
509 spin_lock_init(&priv->rx_reorder_tbl_lock);
510
511 spin_lock_init(&priv->ack_status_lock);
512 idr_init(&priv->ack_status_frames);
513 }
514
515 return 0;
516 }
517
518 /*
519 * This function initializes the firmware.
520 *
521 * The following operations are performed sequentially -
522 * - Allocate adapter structure
523 * - Initialize the adapter structure
524 * - Initialize the private structure
525 * - Add BSS priority tables to the adapter structure
526 * - For each interface, send the init commands to firmware
527 * - Send the first command in command pending queue, if available
528 */
mwifiex_init_fw(struct mwifiex_adapter * adapter)529 int mwifiex_init_fw(struct mwifiex_adapter *adapter)
530 {
531 int ret;
532 struct mwifiex_private *priv;
533 u8 i, first_sta = true;
534 int is_cmd_pend_q_empty;
535 unsigned long flags;
536
537 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
538
539 /* Allocate memory for member of adapter structure */
540 ret = mwifiex_allocate_adapter(adapter);
541 if (ret)
542 return -1;
543
544 /* Initialize adapter structure */
545 mwifiex_init_adapter(adapter);
546
547 for (i = 0; i < adapter->priv_num; i++) {
548 if (adapter->priv[i]) {
549 priv = adapter->priv[i];
550
551 /* Initialize private structure */
552 ret = mwifiex_init_priv(priv);
553 if (ret)
554 return -1;
555 }
556 }
557 if (adapter->mfg_mode) {
558 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
559 ret = -EINPROGRESS;
560 } else {
561 for (i = 0; i < adapter->priv_num; i++) {
562 if (adapter->priv[i]) {
563 ret = mwifiex_sta_init_cmd(adapter->priv[i],
564 first_sta, true);
565 if (ret == -1)
566 return -1;
567
568 first_sta = false;
569 }
570
571
572
573 }
574 }
575
576 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
577 is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
578 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
579 if (!is_cmd_pend_q_empty) {
580 /* Send the first command in queue and return */
581 if (mwifiex_main_process(adapter) != -1)
582 ret = -EINPROGRESS;
583 } else {
584 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
585 }
586
587 return ret;
588 }
589
590 /*
591 * This function deletes the BSS priority tables.
592 *
593 * The function traverses through all the allocated BSS priority nodes
594 * in every BSS priority table and frees them.
595 */
mwifiex_delete_bss_prio_tbl(struct mwifiex_private * priv)596 static void mwifiex_delete_bss_prio_tbl(struct mwifiex_private *priv)
597 {
598 int i;
599 struct mwifiex_adapter *adapter = priv->adapter;
600 struct mwifiex_bss_prio_node *bssprio_node, *tmp_node;
601 struct list_head *head;
602 spinlock_t *lock; /* bss priority lock */
603 unsigned long flags;
604
605 for (i = 0; i < adapter->priv_num; ++i) {
606 head = &adapter->bss_prio_tbl[i].bss_prio_head;
607 lock = &adapter->bss_prio_tbl[i].bss_prio_lock;
608 mwifiex_dbg(adapter, INFO,
609 "info: delete BSS priority table,\t"
610 "bss_type = %d, bss_num = %d, i = %d,\t"
611 "head = %p\n",
612 priv->bss_type, priv->bss_num, i, head);
613
614 {
615 spin_lock_irqsave(lock, flags);
616 if (list_empty(head)) {
617 spin_unlock_irqrestore(lock, flags);
618 continue;
619 }
620 list_for_each_entry_safe(bssprio_node, tmp_node, head,
621 list) {
622 if (bssprio_node->priv == priv) {
623 mwifiex_dbg(adapter, INFO,
624 "info: Delete\t"
625 "node %p, next = %p\n",
626 bssprio_node, tmp_node);
627 list_del(&bssprio_node->list);
628 kfree(bssprio_node);
629 }
630 }
631 spin_unlock_irqrestore(lock, flags);
632 }
633 }
634 }
635
636 /*
637 * This function frees the private structure, including cleans
638 * up the TX and RX queues and frees the BSS priority tables.
639 */
mwifiex_free_priv(struct mwifiex_private * priv)640 void mwifiex_free_priv(struct mwifiex_private *priv)
641 {
642 mwifiex_clean_txrx(priv);
643 mwifiex_delete_bss_prio_tbl(priv);
644 mwifiex_free_curr_bcn(priv);
645 }
646
647 /*
648 * This function is used to shutdown the driver.
649 *
650 * The following operations are performed sequentially -
651 * - Check if already shut down
652 * - Make sure the main process has stopped
653 * - Clean up the Tx and Rx queues
654 * - Delete BSS priority tables
655 * - Free the adapter
656 * - Notify completion
657 */
658 int
mwifiex_shutdown_drv(struct mwifiex_adapter * adapter)659 mwifiex_shutdown_drv(struct mwifiex_adapter *adapter)
660 {
661 int ret = -EINPROGRESS;
662 struct mwifiex_private *priv;
663 s32 i;
664 unsigned long flags;
665 struct sk_buff *skb;
666
667 /* mwifiex already shutdown */
668 if (adapter->hw_status == MWIFIEX_HW_STATUS_NOT_READY)
669 return 0;
670
671 adapter->hw_status = MWIFIEX_HW_STATUS_CLOSING;
672 /* wait for mwifiex_process to complete */
673 if (adapter->mwifiex_processing) {
674 mwifiex_dbg(adapter, WARN,
675 "main process is still running\n");
676 return ret;
677 }
678
679 /* cancel current command */
680 if (adapter->curr_cmd) {
681 mwifiex_dbg(adapter, WARN,
682 "curr_cmd is still in processing\n");
683 del_timer_sync(&adapter->cmd_timer);
684 mwifiex_recycle_cmd_node(adapter, adapter->curr_cmd);
685 adapter->curr_cmd = NULL;
686 }
687
688 /* shut down mwifiex */
689 mwifiex_dbg(adapter, MSG,
690 "info: shutdown mwifiex...\n");
691
692 /* Clean up Tx/Rx queues and delete BSS priority table */
693 for (i = 0; i < adapter->priv_num; i++) {
694 if (adapter->priv[i]) {
695 priv = adapter->priv[i];
696
697 mwifiex_clean_auto_tdls(priv);
698 mwifiex_abort_cac(priv);
699 mwifiex_clean_txrx(priv);
700 mwifiex_delete_bss_prio_tbl(priv);
701 }
702 }
703
704 atomic_set(&adapter->tx_queued, 0);
705 while ((skb = skb_dequeue(&adapter->tx_data_q)))
706 mwifiex_write_data_complete(adapter, skb, 0, 0);
707
708 spin_lock_irqsave(&adapter->rx_proc_lock, flags);
709
710 while ((skb = skb_dequeue(&adapter->rx_data_q))) {
711 struct mwifiex_rxinfo *rx_info = MWIFIEX_SKB_RXCB(skb);
712
713 atomic_dec(&adapter->rx_pending);
714 priv = adapter->priv[rx_info->bss_num];
715 if (priv)
716 priv->stats.rx_dropped++;
717
718 dev_kfree_skb_any(skb);
719 }
720
721 spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
722
723 spin_lock(&adapter->mwifiex_lock);
724
725 mwifiex_adapter_cleanup(adapter);
726
727 spin_unlock(&adapter->mwifiex_lock);
728
729 /* Notify completion */
730 ret = mwifiex_shutdown_fw_complete(adapter);
731
732 return ret;
733 }
734
735 /*
736 * This function downloads the firmware to the card.
737 *
738 * The actual download is preceded by two sanity checks -
739 * - Check if firmware is already running
740 * - Check if the interface is the winner to download the firmware
741 *
742 * ...and followed by another -
743 * - Check if the firmware is downloaded successfully
744 *
745 * After download is successfully completed, the host interrupts are enabled.
746 */
mwifiex_dnld_fw(struct mwifiex_adapter * adapter,struct mwifiex_fw_image * pmfw)747 int mwifiex_dnld_fw(struct mwifiex_adapter *adapter,
748 struct mwifiex_fw_image *pmfw)
749 {
750 int ret;
751 u32 poll_num = 1;
752
753 if (adapter->if_ops.check_fw_status) {
754 /* check if firmware is already running */
755 ret = adapter->if_ops.check_fw_status(adapter, poll_num);
756 if (!ret) {
757 mwifiex_dbg(adapter, MSG,
758 "WLAN FW already running! Skip FW dnld\n");
759 return 0;
760 }
761 }
762
763 /* check if we are the winner for downloading FW */
764 if (adapter->if_ops.check_winner_status) {
765 adapter->winner = 0;
766 ret = adapter->if_ops.check_winner_status(adapter);
767
768 poll_num = MAX_FIRMWARE_POLL_TRIES;
769 if (ret) {
770 mwifiex_dbg(adapter, MSG,
771 "WLAN read winner status failed!\n");
772 return ret;
773 }
774
775 if (!adapter->winner) {
776 mwifiex_dbg(adapter, MSG,
777 "WLAN is not the winner! Skip FW dnld\n");
778 goto poll_fw;
779 }
780 }
781
782 if (pmfw) {
783 /* Download firmware with helper */
784 ret = adapter->if_ops.prog_fw(adapter, pmfw);
785 if (ret) {
786 mwifiex_dbg(adapter, ERROR,
787 "prog_fw failed ret=%#x\n", ret);
788 return ret;
789 }
790 }
791
792 poll_fw:
793 /* Check if the firmware is downloaded successfully or not */
794 ret = adapter->if_ops.check_fw_status(adapter, poll_num);
795 if (ret)
796 mwifiex_dbg(adapter, ERROR,
797 "FW failed to be active in time\n");
798
799 return ret;
800 }
801 EXPORT_SYMBOL_GPL(mwifiex_dnld_fw);
802