2 * This file is part of wl1271
4 * Copyright (C) 2008-2010 Nokia Corporation
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <linux/delay.h>
27 #include <linux/spi/spi.h>
28 #include <linux/crc32.h>
29 #include <linux/etherdevice.h>
30 #include <linux/vmalloc.h>
31 #include <linux/platform_device.h>
32 #include <linux/slab.h>
33 #include <linux/wl12xx.h>
36 #include "wl12xx_80211.h"
50 #define WL1271_BOOT_RETRIES 3
52 static struct conf_drv_settings default_conf = {
55 [CONF_SG_BT_PER_THRESHOLD] = 7500,
56 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
57 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
58 [CONF_SG_BT_LOAD_RATIO] = 200,
59 [CONF_SG_AUTO_PS_MODE] = 1,
60 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
61 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
62 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
63 [CONF_SG_BEACON_MISS_PERCENT] = 60,
64 [CONF_SG_RATE_ADAPT_THRESH] = 12,
65 [CONF_SG_RATE_ADAPT_SNR] = 0,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
67 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
68 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
70 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
71 /* Note: with UPSD, this should be 4 */
72 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
74 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
75 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
76 /* Note: with UPDS, this should be 15 */
77 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
78 /* Note: with UPDS, this should be 50 */
79 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
80 /* Note: with UPDS, this should be 10 */
81 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
84 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
85 [CONF_SG_PS_POLL_TIMEOUT] = 10,
86 [CONF_SG_UPSD_TIMEOUT] = 10,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
88 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
91 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
92 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
94 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
95 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
97 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
98 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
99 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
100 [CONF_SG_HV3_MAX_SERVED] = 6,
101 [CONF_SG_DHCP_TIME] = 5000,
102 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
105 [CONF_SG_BT_PER_THRESHOLD] = 7500,
106 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
107 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
108 [CONF_SG_BT_LOAD_RATIO] = 50,
109 [CONF_SG_AUTO_PS_MODE] = 1,
110 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
111 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
112 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
113 [CONF_SG_BEACON_MISS_PERCENT] = 60,
114 [CONF_SG_RATE_ADAPT_THRESH] = 64,
115 [CONF_SG_RATE_ADAPT_SNR] = 1,
116 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
117 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 25,
118 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 25,
119 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
120 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 25,
121 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 25,
122 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
123 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
124 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 25,
125 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
126 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 25,
127 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 25,
128 [CONF_SG_RXT] = 1200,
129 [CONF_SG_TXT] = 1000,
130 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
131 [CONF_SG_PS_POLL_TIMEOUT] = 10,
132 [CONF_SG_UPSD_TIMEOUT] = 10,
133 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
134 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
135 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
136 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
137 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
138 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
139 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
140 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
141 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
142 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
143 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
144 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
145 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
146 [CONF_SG_HV3_MAX_SERVED] = 6,
147 [CONF_SG_DHCP_TIME] = 5000,
148 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
149 [CONF_SG_TEMP_PARAM_1] = 0,
150 [CONF_SG_TEMP_PARAM_2] = 0,
151 [CONF_SG_TEMP_PARAM_3] = 0,
152 [CONF_SG_TEMP_PARAM_4] = 0,
153 [CONF_SG_TEMP_PARAM_5] = 0,
154 [CONF_SG_AP_BEACON_MISS_TX] = 3,
155 [CONF_SG_RX_WINDOW_LENGTH] = 6,
156 [CONF_SG_AP_CONNECTION_PROTECTION_TIME] = 50,
157 [CONF_SG_TEMP_PARAM_6] = 1,
159 .state = CONF_SG_PROTECTIVE,
162 .rx_msdu_life_time = 512000,
163 .packet_detection_threshold = 0,
164 .ps_poll_timeout = 15,
166 .rts_threshold = IEEE80211_MAX_RTS_THRESHOLD,
167 .rx_cca_threshold = 0,
168 .irq_blk_threshold = 0xFFFF,
169 .irq_pkt_threshold = 0,
171 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
174 .tx_energy_detection = 0,
177 .short_retry_limit = 10,
178 .long_retry_limit = 10,
201 .aifsn = CONF_TX_AIFS_PIFS,
208 .aifsn = CONF_TX_AIFS_PIFS,
212 .ap_max_tx_retries = 100,
216 .queue_id = CONF_TX_AC_BE,
217 .channel_type = CONF_CHANNEL_TYPE_EDCF,
218 .tsid = CONF_TX_AC_BE,
219 .ps_scheme = CONF_PS_SCHEME_LEGACY,
220 .ack_policy = CONF_ACK_POLICY_LEGACY,
224 .queue_id = CONF_TX_AC_BK,
225 .channel_type = CONF_CHANNEL_TYPE_EDCF,
226 .tsid = CONF_TX_AC_BK,
227 .ps_scheme = CONF_PS_SCHEME_LEGACY,
228 .ack_policy = CONF_ACK_POLICY_LEGACY,
232 .queue_id = CONF_TX_AC_VI,
233 .channel_type = CONF_CHANNEL_TYPE_EDCF,
234 .tsid = CONF_TX_AC_VI,
235 .ps_scheme = CONF_PS_SCHEME_LEGACY,
236 .ack_policy = CONF_ACK_POLICY_LEGACY,
240 .queue_id = CONF_TX_AC_VO,
241 .channel_type = CONF_CHANNEL_TYPE_EDCF,
242 .tsid = CONF_TX_AC_VO,
243 .ps_scheme = CONF_PS_SCHEME_LEGACY,
244 .ack_policy = CONF_ACK_POLICY_LEGACY,
248 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
249 .tx_compl_timeout = 700,
250 .tx_compl_threshold = 4,
251 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
252 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
253 .tmpl_short_retry_limit = 10,
254 .tmpl_long_retry_limit = 10,
257 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
258 .listen_interval = 1,
259 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
260 .bcn_filt_ie_count = 2,
263 .ie = WLAN_EID_CHANNEL_SWITCH,
264 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
267 .ie = WLAN_EID_HT_INFORMATION,
268 .rule = CONF_BCN_RULE_PASS_ON_CHANGE,
271 .synch_fail_thold = 10,
272 .bss_lose_timeout = 100,
273 .beacon_rx_timeout = 10000,
274 .broadcast_timeout = 20000,
275 .rx_broadcast_in_ps = 1,
276 .ps_poll_threshold = 10,
277 .ps_poll_recovery_period = 700,
278 .bet_enable = CONF_BET_MODE_ENABLE,
279 .bet_max_consecutive = 50,
280 .psm_entry_retries = 5,
281 .psm_exit_retries = 16,
282 .psm_entry_nullfunc_retries = 3,
283 .psm_entry_hangover_period = 1,
284 .keep_alive_interval = 55000,
285 .max_listen_interval = 20,
292 .host_clk_settling_time = 5000,
293 .host_fast_wakeup_support = false
297 .avg_weight_rssi_beacon = 20,
298 .avg_weight_rssi_data = 10,
299 .avg_weight_snr_beacon = 20,
300 .avg_weight_snr_data = 10,
303 .min_dwell_time_active = 7500,
304 .max_dwell_time_active = 30000,
305 .min_dwell_time_passive = 100000,
306 .max_dwell_time_passive = 100000,
310 /* sched_scan requires dwell times in TU instead of TU/1000 */
311 .min_dwell_time_active = 8,
312 .max_dwell_time_active = 30,
313 .dwell_time_passive = 100,
314 .dwell_time_dfs = 150,
316 .rssi_threshold = -90,
320 .tx_per_channel_power_compensation_2 = {
321 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
323 .tx_per_channel_power_compensation_5 = {
324 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
325 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
330 .tx_ba_win_size = 64,
331 .inactivity_timeout = 10000,
337 .tx_min_block_num = 40,
339 .min_req_tx_blocks = 100,
340 .min_req_rx_blocks = 22,
347 .tx_min_block_num = 40,
349 .min_req_tx_blocks = 45,
350 .min_req_rx_blocks = 22,
356 .n_divider_fref_set_1 = 0xff, /* default */
357 .n_divider_fref_set_2 = 12,
358 .m_divider_fref_set_1 = 148,
359 .m_divider_fref_set_2 = 0xffff, /* default */
360 .coex_pll_stabilization_time = 0xffffffff, /* default */
361 .ldo_stabilization_time = 0xffff, /* default */
362 .fm_disturbed_band_margin = 0xff, /* default */
363 .swallow_clk_diff = 0xff, /* default */
365 .hci_io_ds = HCI_IO_DS_6MA,
368 static void __wl1271_op_remove_interface(struct wl1271 *wl,
369 bool reset_tx_queues);
370 static void wl1271_free_ap_keys(struct wl1271 *wl);
373 static void wl1271_device_release(struct device *dev)
378 static struct platform_device wl1271_device = {
382 /* device model insists to have a release function */
384 .release = wl1271_device_release,
388 static DEFINE_MUTEX(wl_list_mutex);
389 static LIST_HEAD(wl_list);
391 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
394 struct net_device *dev = arg;
395 struct wireless_dev *wdev;
397 struct ieee80211_hw *hw;
399 struct wl1271 *wl_temp;
402 /* Check that this notification is for us. */
403 if (what != NETDEV_CHANGE)
406 wdev = dev->ieee80211_ptr;
414 hw = wiphy_priv(wiphy);
419 mutex_lock(&wl_list_mutex);
420 list_for_each_entry(wl, &wl_list, list) {
424 mutex_unlock(&wl_list_mutex);
428 mutex_lock(&wl->mutex);
430 if (wl->state == WL1271_STATE_OFF)
433 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
436 ret = wl1271_ps_elp_wakeup(wl);
440 if ((dev->operstate == IF_OPER_UP) &&
441 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
442 wl1271_cmd_set_sta_state(wl);
443 wl1271_info("Association completed.");
446 wl1271_ps_elp_sleep(wl);
449 mutex_unlock(&wl->mutex);
454 static int wl1271_reg_notify(struct wiphy *wiphy,
455 struct regulatory_request *request)
457 struct ieee80211_supported_band *band;
458 struct ieee80211_channel *ch;
461 band = wiphy->bands[IEEE80211_BAND_5GHZ];
462 for (i = 0; i < band->n_channels; i++) {
463 ch = &band->channels[i];
464 if (ch->flags & IEEE80211_CHAN_DISABLED)
467 if (ch->flags & IEEE80211_CHAN_RADAR)
468 ch->flags |= IEEE80211_CHAN_NO_IBSS |
469 IEEE80211_CHAN_PASSIVE_SCAN;
476 static void wl1271_conf_init(struct wl1271 *wl)
480 * This function applies the default configuration to the driver. This
481 * function is invoked upon driver load (spi probe.)
483 * The configuration is stored in a run-time structure in order to
484 * facilitate for run-time adjustment of any of the parameters. Making
485 * changes to the configuration structure will apply the new values on
486 * the next interface up (wl1271_op_start.)
489 /* apply driver default configuration */
490 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
494 static int wl1271_plt_init(struct wl1271 *wl)
496 struct conf_tx_ac_category *conf_ac;
497 struct conf_tx_tid *conf_tid;
500 if (wl->chip.id == CHIP_ID_1283_PG20)
501 ret = wl128x_cmd_general_parms(wl);
503 ret = wl1271_cmd_general_parms(wl);
507 if (wl->chip.id == CHIP_ID_1283_PG20)
508 ret = wl128x_cmd_radio_parms(wl);
510 ret = wl1271_cmd_radio_parms(wl);
514 if (wl->chip.id != CHIP_ID_1283_PG20) {
515 ret = wl1271_cmd_ext_radio_parms(wl);
522 /* Chip-specific initializations */
523 ret = wl1271_chip_specific_init(wl);
527 ret = wl1271_sta_init_templates_config(wl);
531 ret = wl1271_acx_init_mem_config(wl);
535 /* PHY layer config */
536 ret = wl1271_init_phy_config(wl);
538 goto out_free_memmap;
540 ret = wl1271_acx_dco_itrim_params(wl);
542 goto out_free_memmap;
544 /* Initialize connection monitoring thresholds */
545 ret = wl1271_acx_conn_monit_params(wl, false);
547 goto out_free_memmap;
549 /* Bluetooth WLAN coexistence */
550 ret = wl1271_init_pta(wl);
552 goto out_free_memmap;
554 /* FM WLAN coexistence */
555 ret = wl1271_acx_fm_coex(wl);
557 goto out_free_memmap;
559 /* Energy detection */
560 ret = wl1271_init_energy_detection(wl);
562 goto out_free_memmap;
564 ret = wl1271_acx_sta_mem_cfg(wl);
566 goto out_free_memmap;
568 /* Default fragmentation threshold */
569 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
571 goto out_free_memmap;
573 /* Default TID/AC configuration */
574 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
575 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
576 conf_ac = &wl->conf.tx.ac_conf[i];
577 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
578 conf_ac->cw_max, conf_ac->aifsn,
579 conf_ac->tx_op_limit);
581 goto out_free_memmap;
583 conf_tid = &wl->conf.tx.tid_conf[i];
584 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
585 conf_tid->channel_type,
588 conf_tid->ack_policy,
589 conf_tid->apsd_conf[0],
590 conf_tid->apsd_conf[1]);
592 goto out_free_memmap;
595 /* Enable data path */
596 ret = wl1271_cmd_data_path(wl, 1);
598 goto out_free_memmap;
600 /* Configure for CAM power saving (ie. always active) */
601 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
603 goto out_free_memmap;
606 ret = wl1271_acx_pm_config(wl);
608 goto out_free_memmap;
613 kfree(wl->target_mem_map);
614 wl->target_mem_map = NULL;
619 static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks)
623 /* only regulate station links */
624 if (hlid < WL1271_AP_STA_HLID_START)
627 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
630 * Wake up from high level PS if the STA is asleep with too little
631 * blocks in FW or if the STA is awake.
633 if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS)
634 wl1271_ps_link_end(wl, hlid);
636 /* Start high-level PS if the STA is asleep with enough blocks in FW */
637 else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
638 wl1271_ps_link_start(wl, hlid, true);
641 static void wl1271_irq_update_links_status(struct wl1271 *wl,
642 struct wl1271_fw_ap_status *status)
647 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
648 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
649 wl1271_debug(DEBUG_PSM,
650 "link ps prev 0x%x cur 0x%x changed 0x%x",
651 wl->ap_fw_ps_map, cur_fw_ps_map,
652 wl->ap_fw_ps_map ^ cur_fw_ps_map);
654 wl->ap_fw_ps_map = cur_fw_ps_map;
657 for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
658 u8 cnt = status->tx_lnk_free_blks[hlid] -
659 wl->links[hlid].prev_freed_blks;
661 wl->links[hlid].prev_freed_blks =
662 status->tx_lnk_free_blks[hlid];
663 wl->links[hlid].allocated_blks -= cnt;
665 wl1271_irq_ps_regulate_link(wl, hlid,
666 wl->links[hlid].allocated_blks);
670 static void wl1271_fw_status(struct wl1271 *wl,
671 struct wl1271_fw_full_status *full_status)
673 struct wl1271_fw_common_status *status = &full_status->common;
675 u32 old_tx_blk_count = wl->tx_blocks_available;
676 u32 freed_blocks = 0;
679 if (wl->bss_type == BSS_TYPE_AP_BSS) {
680 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
681 sizeof(struct wl1271_fw_ap_status), false);
683 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
684 sizeof(struct wl1271_fw_sta_status), false);
687 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
688 "drv_rx_counter = %d, tx_results_counter = %d)",
690 status->fw_rx_counter,
691 status->drv_rx_counter,
692 status->tx_results_counter);
694 /* update number of available TX blocks */
695 for (i = 0; i < NUM_TX_QUEUES; i++) {
696 freed_blocks += le32_to_cpu(status->tx_released_blks[i]) -
697 wl->tx_blocks_freed[i];
699 wl->tx_blocks_freed[i] =
700 le32_to_cpu(status->tx_released_blks[i]);
703 wl->tx_allocated_blocks -= freed_blocks;
705 if (wl->bss_type == BSS_TYPE_AP_BSS) {
706 /* Update num of allocated TX blocks per link and ps status */
707 wl1271_irq_update_links_status(wl, &full_status->ap);
708 wl->tx_blocks_available += freed_blocks;
710 int avail = full_status->sta.tx_total - wl->tx_allocated_blocks;
713 * The FW might change the total number of TX memblocks before
714 * we get a notification about blocks being released. Thus, the
715 * available blocks calculation might yield a temporary result
716 * which is lower than the actual available blocks. Keeping in
717 * mind that only blocks that were allocated can be moved from
718 * TX to RX, tx_blocks_available should never decrease here.
720 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
724 /* if more blocks are available now, tx work can be scheduled */
725 if (wl->tx_blocks_available > old_tx_blk_count)
726 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
728 /* update the host-chipset time offset */
730 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
731 (s64)le32_to_cpu(status->fw_localtime);
734 static void wl1271_flush_deferred_work(struct wl1271 *wl)
738 /* Pass all received frames to the network stack */
739 while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
740 ieee80211_rx_ni(wl->hw, skb);
742 /* Return sent skbs to the network stack */
743 while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
744 ieee80211_tx_status(wl->hw, skb);
747 static void wl1271_netstack_work(struct work_struct *work)
750 container_of(work, struct wl1271, netstack_work);
753 wl1271_flush_deferred_work(wl);
754 } while (skb_queue_len(&wl->deferred_rx_queue));
757 #define WL1271_IRQ_MAX_LOOPS 256
759 irqreturn_t wl1271_irq(int irq, void *cookie)
763 int loopcount = WL1271_IRQ_MAX_LOOPS;
764 struct wl1271 *wl = (struct wl1271 *)cookie;
766 unsigned int defer_count;
769 /* TX might be handled here, avoid redundant work */
770 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
771 cancel_work_sync(&wl->tx_work);
774 * In case edge triggered interrupt must be used, we cannot iterate
775 * more than once without introducing race conditions with the hardirq.
777 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
780 mutex_lock(&wl->mutex);
782 wl1271_debug(DEBUG_IRQ, "IRQ work");
784 if (unlikely(wl->state == WL1271_STATE_OFF))
787 ret = wl1271_ps_elp_wakeup(wl);
791 while (!done && loopcount--) {
793 * In order to avoid a race with the hardirq, clear the flag
794 * before acknowledging the chip. Since the mutex is held,
795 * wl1271_ps_elp_wakeup cannot be called concurrently.
797 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
798 smp_mb__after_clear_bit();
800 wl1271_fw_status(wl, wl->fw_status);
801 intr = le32_to_cpu(wl->fw_status->common.intr);
802 intr &= WL1271_INTR_MASK;
808 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
809 wl1271_error("watchdog interrupt received! "
810 "starting recovery.");
811 ieee80211_queue_work(wl->hw, &wl->recovery_work);
813 /* restarting the chip. ignore any other interrupt. */
817 if (likely(intr & WL1271_ACX_INTR_DATA)) {
818 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
820 wl1271_rx(wl, &wl->fw_status->common);
822 /* Check if any tx blocks were freed */
823 spin_lock_irqsave(&wl->wl_lock, flags);
824 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
825 wl->tx_queue_count) {
826 spin_unlock_irqrestore(&wl->wl_lock, flags);
828 * In order to avoid starvation of the TX path,
829 * call the work function directly.
831 wl1271_tx_work_locked(wl);
833 spin_unlock_irqrestore(&wl->wl_lock, flags);
836 /* check for tx results */
837 if (wl->fw_status->common.tx_results_counter !=
838 (wl->tx_results_count & 0xff))
839 wl1271_tx_complete(wl);
841 /* Make sure the deferred queues don't get too long */
842 defer_count = skb_queue_len(&wl->deferred_tx_queue) +
843 skb_queue_len(&wl->deferred_rx_queue);
844 if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
845 wl1271_flush_deferred_work(wl);
848 if (intr & WL1271_ACX_INTR_EVENT_A) {
849 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
850 wl1271_event_handle(wl, 0);
853 if (intr & WL1271_ACX_INTR_EVENT_B) {
854 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
855 wl1271_event_handle(wl, 1);
858 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
859 wl1271_debug(DEBUG_IRQ,
860 "WL1271_ACX_INTR_INIT_COMPLETE");
862 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
863 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
866 wl1271_ps_elp_sleep(wl);
869 spin_lock_irqsave(&wl->wl_lock, flags);
870 /* In case TX was not handled here, queue TX work */
871 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
872 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
874 ieee80211_queue_work(wl->hw, &wl->tx_work);
875 spin_unlock_irqrestore(&wl->wl_lock, flags);
877 mutex_unlock(&wl->mutex);
881 EXPORT_SYMBOL_GPL(wl1271_irq);
883 static int wl1271_fetch_firmware(struct wl1271 *wl)
885 const struct firmware *fw;
889 switch (wl->bss_type) {
890 case BSS_TYPE_AP_BSS:
891 if (wl->chip.id == CHIP_ID_1283_PG20)
892 fw_name = WL128X_AP_FW_NAME;
894 fw_name = WL127X_AP_FW_NAME;
897 case BSS_TYPE_STA_BSS:
898 if (wl->chip.id == CHIP_ID_1283_PG20)
899 fw_name = WL128X_FW_NAME;
901 fw_name = WL1271_FW_NAME;
904 wl1271_error("no compatible firmware for bss_type %d",
909 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
911 ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
914 wl1271_error("could not get firmware: %d", ret);
919 wl1271_error("firmware size is not multiple of 32 bits: %zu",
926 wl->fw_len = fw->size;
927 wl->fw = vmalloc(wl->fw_len);
930 wl1271_error("could not allocate memory for the firmware");
935 memcpy(wl->fw, fw->data, wl->fw_len);
936 wl->fw_bss_type = wl->bss_type;
940 release_firmware(fw);
945 static int wl1271_fetch_nvs(struct wl1271 *wl)
947 const struct firmware *fw;
950 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
953 wl1271_error("could not get nvs file: %d", ret);
957 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
960 wl1271_error("could not allocate memory for the nvs file");
965 wl->nvs_len = fw->size;
968 release_firmware(fw);
973 static void wl1271_recovery_work(struct work_struct *work)
976 container_of(work, struct wl1271, recovery_work);
978 mutex_lock(&wl->mutex);
980 if (wl->state != WL1271_STATE_ON)
983 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
984 wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
986 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
987 ieee80211_connection_loss(wl->vif);
989 /* Prevent spurious TX during FW restart */
990 ieee80211_stop_queues(wl->hw);
992 if (wl->sched_scanning) {
993 ieee80211_sched_scan_stopped(wl->hw);
994 wl->sched_scanning = false;
997 /* reboot the chipset */
998 __wl1271_op_remove_interface(wl, false);
999 ieee80211_restart_hw(wl->hw);
1002 * Its safe to enable TX now - the queues are stopped after a request
1003 * to restart the HW.
1005 ieee80211_wake_queues(wl->hw);
1008 mutex_unlock(&wl->mutex);
1011 static void wl1271_fw_wakeup(struct wl1271 *wl)
1015 elp_reg = ELPCTRL_WAKE_UP;
1016 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
1019 static int wl1271_setup(struct wl1271 *wl)
1021 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
1025 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1026 if (!wl->tx_res_if) {
1027 kfree(wl->fw_status);
1034 static int wl1271_chip_wakeup(struct wl1271 *wl)
1036 struct wl1271_partition_set partition;
1039 msleep(WL1271_PRE_POWER_ON_SLEEP);
1040 ret = wl1271_power_on(wl);
1043 msleep(WL1271_POWER_ON_SLEEP);
1044 wl1271_io_reset(wl);
1047 /* We don't need a real memory partition here, because we only want
1048 * to use the registers at this point. */
1049 memset(&partition, 0, sizeof(partition));
1050 partition.reg.start = REGISTERS_BASE;
1051 partition.reg.size = REGISTERS_DOWN_SIZE;
1052 wl1271_set_partition(wl, &partition);
1054 /* ELP module wake up */
1055 wl1271_fw_wakeup(wl);
1057 /* whal_FwCtrl_BootSm() */
1059 /* 0. read chip id from CHIP_ID */
1060 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
1062 /* 1. check if chip id is valid */
1064 switch (wl->chip.id) {
1065 case CHIP_ID_1271_PG10:
1066 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1069 ret = wl1271_setup(wl);
1073 case CHIP_ID_1271_PG20:
1074 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1077 /* end-of-transaction flag should be set in wl127x AP mode */
1078 if (wl->bss_type == BSS_TYPE_AP_BSS)
1079 wl->quirks |= WL12XX_QUIRK_END_OF_TRANSACTION;
1081 ret = wl1271_setup(wl);
1085 case CHIP_ID_1283_PG20:
1086 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1089 ret = wl1271_setup(wl);
1092 if (wl1271_set_block_size(wl))
1093 wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
1095 case CHIP_ID_1283_PG10:
1097 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
1102 /* Make sure the firmware type matches the BSS type */
1103 if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
1104 ret = wl1271_fetch_firmware(wl);
1109 /* No NVS from netlink, try to get it from the filesystem */
1110 if (wl->nvs == NULL) {
1111 ret = wl1271_fetch_nvs(wl);
1120 static unsigned int wl1271_get_fw_ver_quirks(struct wl1271 *wl)
1122 unsigned int quirks = 0;
1123 unsigned int *fw_ver = wl->chip.fw_ver;
1125 /* Only for wl127x */
1126 if ((fw_ver[FW_VER_CHIP] == FW_VER_CHIP_WL127X) &&
1127 /* Check STA version */
1128 (((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_STA) &&
1129 (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_STA_MIN)) ||
1130 /* Check AP version */
1131 ((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_AP) &&
1132 (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_AP_MIN))))
1133 quirks |= WL12XX_QUIRK_USE_2_SPARE_BLOCKS;
1138 int wl1271_plt_start(struct wl1271 *wl)
1140 int retries = WL1271_BOOT_RETRIES;
1143 mutex_lock(&wl->mutex);
1145 wl1271_notice("power up");
1147 if (wl->state != WL1271_STATE_OFF) {
1148 wl1271_error("cannot go into PLT state because not "
1149 "in off state: %d", wl->state);
1154 wl->bss_type = BSS_TYPE_STA_BSS;
1158 ret = wl1271_chip_wakeup(wl);
1162 ret = wl1271_boot(wl);
1166 ret = wl1271_plt_init(wl);
1170 wl->state = WL1271_STATE_PLT;
1171 wl1271_notice("firmware booted in PLT mode (%s)",
1172 wl->chip.fw_ver_str);
1174 /* Check if any quirks are needed with older fw versions */
1175 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1179 mutex_unlock(&wl->mutex);
1180 /* Unlocking the mutex in the middle of handling is
1181 inherently unsafe. In this case we deem it safe to do,
1182 because we need to let any possibly pending IRQ out of
1183 the system (and while we are WL1271_STATE_OFF the IRQ
1184 work function will not do anything.) Also, any other
1185 possible concurrent operations will fail due to the
1186 current state, hence the wl1271 struct should be safe. */
1187 wl1271_disable_interrupts(wl);
1188 wl1271_flush_deferred_work(wl);
1189 cancel_work_sync(&wl->netstack_work);
1190 mutex_lock(&wl->mutex);
1192 wl1271_power_off(wl);
1195 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1196 WL1271_BOOT_RETRIES);
1198 mutex_unlock(&wl->mutex);
1203 static int __wl1271_plt_stop(struct wl1271 *wl)
1207 wl1271_notice("power down");
1209 if (wl->state != WL1271_STATE_PLT) {
1210 wl1271_error("cannot power down because not in PLT "
1211 "state: %d", wl->state);
1216 wl1271_power_off(wl);
1218 wl->state = WL1271_STATE_OFF;
1221 mutex_unlock(&wl->mutex);
1222 wl1271_disable_interrupts(wl);
1223 wl1271_flush_deferred_work(wl);
1224 cancel_work_sync(&wl->netstack_work);
1225 cancel_work_sync(&wl->recovery_work);
1226 mutex_lock(&wl->mutex);
1231 int wl1271_plt_stop(struct wl1271 *wl)
1235 mutex_lock(&wl->mutex);
1236 ret = __wl1271_plt_stop(wl);
1237 mutex_unlock(&wl->mutex);
1241 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1243 struct wl1271 *wl = hw->priv;
1244 unsigned long flags;
1248 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
1250 if (wl->bss_type == BSS_TYPE_AP_BSS)
1251 hlid = wl1271_tx_get_hlid(skb);
1253 spin_lock_irqsave(&wl->wl_lock, flags);
1255 wl->tx_queue_count++;
1258 * The workqueue is slow to process the tx_queue and we need stop
1259 * the queue here, otherwise the queue will get too long.
1261 if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1262 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
1263 ieee80211_stop_queues(wl->hw);
1264 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
1267 /* queue the packet */
1268 if (wl->bss_type == BSS_TYPE_AP_BSS) {
1269 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1270 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1272 skb_queue_tail(&wl->tx_queue[q], skb);
1276 * The chip specific setup must run before the first TX packet -
1277 * before that, the tx_work will not be initialized!
1280 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1281 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1282 ieee80211_queue_work(wl->hw, &wl->tx_work);
1284 spin_unlock_irqrestore(&wl->wl_lock, flags);
1287 int wl1271_tx_dummy_packet(struct wl1271 *wl)
1289 unsigned long flags;
1291 spin_lock_irqsave(&wl->wl_lock, flags);
1292 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1293 wl->tx_queue_count++;
1294 spin_unlock_irqrestore(&wl->wl_lock, flags);
1296 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1297 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1298 wl1271_tx_work_locked(wl);
1301 * If the FW TX is busy, TX work will be scheduled by the threaded
1302 * interrupt handler function
1308 * The size of the dummy packet should be at least 1400 bytes. However, in
1309 * order to minimize the number of bus transactions, aligning it to 512 bytes
1310 * boundaries could be beneficial, performance wise
1312 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1314 static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1316 struct sk_buff *skb;
1317 struct ieee80211_hdr_3addr *hdr;
1318 unsigned int dummy_packet_size;
1320 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1321 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1323 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1325 wl1271_warning("Failed to allocate a dummy packet skb");
1329 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1331 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1332 memset(hdr, 0, sizeof(*hdr));
1333 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1334 IEEE80211_STYPE_NULLFUNC |
1335 IEEE80211_FCTL_TODS);
1337 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1339 /* Dummy packets require the TID to be management */
1340 skb->priority = WL1271_TID_MGMT;
1342 /* Initialize all fields that might be used */
1343 skb_set_queue_mapping(skb, 0);
1344 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1350 static struct notifier_block wl1271_dev_notifier = {
1351 .notifier_call = wl1271_dev_notify,
1355 static int wl1271_configure_suspend(struct wl1271 *wl)
1359 if (wl->bss_type != BSS_TYPE_STA_BSS)
1362 mutex_lock(&wl->mutex);
1364 ret = wl1271_ps_elp_wakeup(wl);
1368 /* enter psm if needed*/
1369 if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1370 DECLARE_COMPLETION_ONSTACK(compl);
1372 wl->ps_compl = &compl;
1373 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1374 wl->basic_rate, true);
1378 /* we must unlock here so we will be able to get events */
1379 wl1271_ps_elp_sleep(wl);
1380 mutex_unlock(&wl->mutex);
1382 ret = wait_for_completion_timeout(
1383 &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT));
1385 wl1271_warning("couldn't enter ps mode!");
1390 /* take mutex again, and wakeup */
1391 mutex_lock(&wl->mutex);
1393 ret = wl1271_ps_elp_wakeup(wl);
1398 wl1271_ps_elp_sleep(wl);
1400 mutex_unlock(&wl->mutex);
1406 static void wl1271_configure_resume(struct wl1271 *wl)
1410 if (wl->bss_type != BSS_TYPE_STA_BSS)
1413 mutex_lock(&wl->mutex);
1414 ret = wl1271_ps_elp_wakeup(wl);
1418 /* exit psm if it wasn't configured */
1419 if (!test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags))
1420 wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1421 wl->basic_rate, true);
1423 wl1271_ps_elp_sleep(wl);
1425 mutex_unlock(&wl->mutex);
1428 static int wl1271_op_suspend(struct ieee80211_hw *hw,
1429 struct cfg80211_wowlan *wow)
1431 struct wl1271 *wl = hw->priv;
1432 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1433 wl->wow_enabled = !!wow;
1434 if (wl->wow_enabled) {
1436 ret = wl1271_configure_suspend(wl);
1438 wl1271_warning("couldn't prepare device to suspend");
1441 /* flush any remaining work */
1442 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1443 flush_delayed_work(&wl->scan_complete_work);
1446 * disable and re-enable interrupts in order to flush
1449 wl1271_disable_interrupts(wl);
1452 * set suspended flag to avoid triggering a new threaded_irq
1453 * work. no need for spinlock as interrupts are disabled.
1455 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1457 wl1271_enable_interrupts(wl);
1458 flush_work(&wl->tx_work);
1459 flush_delayed_work(&wl->pspoll_work);
1460 flush_delayed_work(&wl->elp_work);
1465 static int wl1271_op_resume(struct ieee80211_hw *hw)
1467 struct wl1271 *wl = hw->priv;
1468 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1472 * re-enable irq_work enqueuing, and call irq_work directly if
1473 * there is a pending work.
1475 if (wl->wow_enabled) {
1476 struct wl1271 *wl = hw->priv;
1477 unsigned long flags;
1478 bool run_irq_work = false;
1480 spin_lock_irqsave(&wl->wl_lock, flags);
1481 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1482 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1483 run_irq_work = true;
1484 spin_unlock_irqrestore(&wl->wl_lock, flags);
1487 wl1271_debug(DEBUG_MAC80211,
1488 "run postponed irq_work directly");
1490 wl1271_enable_interrupts(wl);
1493 wl1271_configure_resume(wl);
1500 static int wl1271_op_start(struct ieee80211_hw *hw)
1502 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1505 * We have to delay the booting of the hardware because
1506 * we need to know the local MAC address before downloading and
1507 * initializing the firmware. The MAC address cannot be changed
1508 * after boot, and without the proper MAC address, the firmware
1509 * will not function properly.
1511 * The MAC address is first known when the corresponding interface
1512 * is added. That is where we will initialize the hardware.
1514 * In addition, we currently have different firmwares for AP and managed
1515 * operation. We will know which to boot according to interface type.
1521 static void wl1271_op_stop(struct ieee80211_hw *hw)
1523 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1526 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1527 struct ieee80211_vif *vif)
1529 struct wl1271 *wl = hw->priv;
1530 struct wiphy *wiphy = hw->wiphy;
1531 int retries = WL1271_BOOT_RETRIES;
1533 bool booted = false;
1535 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1536 vif->type, vif->addr);
1538 mutex_lock(&wl->mutex);
1540 wl1271_debug(DEBUG_MAC80211,
1541 "multiple vifs are not supported yet");
1547 * in some very corner case HW recovery scenarios its possible to
1548 * get here before __wl1271_op_remove_interface is complete, so
1549 * opt out if that is the case.
1551 if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1556 switch (vif->type) {
1557 case NL80211_IFTYPE_STATION:
1558 wl->bss_type = BSS_TYPE_STA_BSS;
1559 wl->set_bss_type = BSS_TYPE_STA_BSS;
1561 case NL80211_IFTYPE_ADHOC:
1562 wl->bss_type = BSS_TYPE_IBSS;
1563 wl->set_bss_type = BSS_TYPE_STA_BSS;
1565 case NL80211_IFTYPE_AP:
1566 wl->bss_type = BSS_TYPE_AP_BSS;
1573 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1575 if (wl->state != WL1271_STATE_OFF) {
1576 wl1271_error("cannot start because not in off state: %d",
1584 ret = wl1271_chip_wakeup(wl);
1588 ret = wl1271_boot(wl);
1592 ret = wl1271_hw_init(wl);
1600 mutex_unlock(&wl->mutex);
1601 /* Unlocking the mutex in the middle of handling is
1602 inherently unsafe. In this case we deem it safe to do,
1603 because we need to let any possibly pending IRQ out of
1604 the system (and while we are WL1271_STATE_OFF the IRQ
1605 work function will not do anything.) Also, any other
1606 possible concurrent operations will fail due to the
1607 current state, hence the wl1271 struct should be safe. */
1608 wl1271_disable_interrupts(wl);
1609 wl1271_flush_deferred_work(wl);
1610 cancel_work_sync(&wl->netstack_work);
1611 mutex_lock(&wl->mutex);
1613 wl1271_power_off(wl);
1617 wl1271_error("firmware boot failed despite %d retries",
1618 WL1271_BOOT_RETRIES);
1623 wl->state = WL1271_STATE_ON;
1624 set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
1625 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1627 /* update hw/fw version info in wiphy struct */
1628 wiphy->hw_version = wl->chip.id;
1629 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1630 sizeof(wiphy->fw_version));
1632 /* Check if any quirks are needed with older fw versions */
1633 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1636 * Now we know if 11a is supported (info from the NVS), so disable
1637 * 11a channels if not supported
1639 if (!wl->enable_11a)
1640 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1642 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1643 wl->enable_11a ? "" : "not ");
1646 mutex_unlock(&wl->mutex);
1648 mutex_lock(&wl_list_mutex);
1650 list_add(&wl->list, &wl_list);
1651 mutex_unlock(&wl_list_mutex);
1656 static void __wl1271_op_remove_interface(struct wl1271 *wl,
1657 bool reset_tx_queues)
1661 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1663 /* because of hardware recovery, we may get here twice */
1664 if (wl->state != WL1271_STATE_ON)
1667 wl1271_info("down");
1669 mutex_lock(&wl_list_mutex);
1670 list_del(&wl->list);
1671 mutex_unlock(&wl_list_mutex);
1673 /* enable dyn ps just in case (if left on due to fw crash etc) */
1674 if (wl->bss_type == BSS_TYPE_STA_BSS)
1675 ieee80211_enable_dyn_ps(wl->vif);
1677 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1678 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1679 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
1680 wl->scan.req = NULL;
1681 ieee80211_scan_completed(wl->hw, true);
1685 * this must be before the cancel_work calls below, so that the work
1686 * functions don't perform further work.
1688 wl->state = WL1271_STATE_OFF;
1690 mutex_unlock(&wl->mutex);
1692 wl1271_disable_interrupts(wl);
1693 wl1271_flush_deferred_work(wl);
1694 cancel_delayed_work_sync(&wl->scan_complete_work);
1695 cancel_work_sync(&wl->netstack_work);
1696 cancel_work_sync(&wl->tx_work);
1697 cancel_delayed_work_sync(&wl->pspoll_work);
1698 cancel_delayed_work_sync(&wl->elp_work);
1700 mutex_lock(&wl->mutex);
1702 /* let's notify MAC80211 about the remaining pending TX frames */
1703 wl1271_tx_reset(wl, reset_tx_queues);
1704 wl1271_power_off(wl);
1706 memset(wl->bssid, 0, ETH_ALEN);
1707 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1709 wl->bss_type = MAX_BSS_TYPE;
1710 wl->set_bss_type = MAX_BSS_TYPE;
1711 wl->band = IEEE80211_BAND_2GHZ;
1714 wl->psm_entry_retry = 0;
1715 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1716 wl->tx_blocks_available = 0;
1717 wl->tx_allocated_blocks = 0;
1718 wl->tx_results_count = 0;
1719 wl->tx_packets_count = 0;
1720 wl->tx_security_last_seq = 0;
1721 wl->tx_security_seq = 0;
1722 wl->time_offset = 0;
1723 wl->session_counter = 0;
1724 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1727 wl1271_free_ap_keys(wl);
1728 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
1729 wl->ap_fw_ps_map = 0;
1731 wl->sched_scanning = false;
1734 * this is performed after the cancel_work calls and the associated
1735 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1736 * get executed before all these vars have been reset.
1740 for (i = 0; i < NUM_TX_QUEUES; i++)
1741 wl->tx_blocks_freed[i] = 0;
1743 wl1271_debugfs_reset(wl);
1745 kfree(wl->fw_status);
1746 wl->fw_status = NULL;
1747 kfree(wl->tx_res_if);
1748 wl->tx_res_if = NULL;
1749 kfree(wl->target_mem_map);
1750 wl->target_mem_map = NULL;
1753 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1754 struct ieee80211_vif *vif)
1756 struct wl1271 *wl = hw->priv;
1758 mutex_lock(&wl->mutex);
1760 * wl->vif can be null here if someone shuts down the interface
1761 * just when hardware recovery has been started.
1764 WARN_ON(wl->vif != vif);
1765 __wl1271_op_remove_interface(wl, true);
1768 mutex_unlock(&wl->mutex);
1769 cancel_work_sync(&wl->recovery_work);
1772 void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1774 wl1271_set_default_filters(wl);
1776 /* combine requested filters with current filter config */
1777 filters = wl->filters | filters;
1779 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1781 if (filters & FIF_PROMISC_IN_BSS) {
1782 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1783 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1784 wl->rx_config |= CFG_BSSID_FILTER_EN;
1786 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1787 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1788 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1789 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1791 if (filters & FIF_OTHER_BSS) {
1792 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1793 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1795 if (filters & FIF_CONTROL) {
1796 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1797 wl->rx_filter |= CFG_RX_CTL_EN;
1799 if (filters & FIF_FCSFAIL) {
1800 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1801 wl->rx_filter |= CFG_RX_FCS_ERROR;
1805 static int wl1271_dummy_join(struct wl1271 *wl)
1808 /* we need to use a dummy BSSID for now */
1809 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1812 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1814 /* pass through frames from all BSS */
1815 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1817 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1821 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1827 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1832 * One of the side effects of the JOIN command is that is clears
1833 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1834 * to a WPA/WPA2 access point will therefore kill the data-path.
1835 * Currently the only valid scenario for JOIN during association
1836 * is on roaming, in which case we will also be given new keys.
1837 * Keep the below message for now, unless it starts bothering
1838 * users who really like to roam a lot :)
1840 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1841 wl1271_info("JOIN while associated.");
1844 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1846 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1850 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1852 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1856 * The join command disable the keep-alive mode, shut down its process,
1857 * and also clear the template config, so we need to reset it all after
1858 * the join. The acx_aid starts the keep-alive process, and the order
1859 * of the commands below is relevant.
1861 ret = wl1271_acx_keep_alive_mode(wl, true);
1865 ret = wl1271_acx_aid(wl, wl->aid);
1869 ret = wl1271_cmd_build_klv_null_data(wl);
1873 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1874 ACX_KEEP_ALIVE_TPL_VALID);
1882 static int wl1271_unjoin(struct wl1271 *wl)
1886 /* to stop listening to a channel, we disconnect */
1887 ret = wl1271_cmd_disconnect(wl);
1891 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1892 memset(wl->bssid, 0, ETH_ALEN);
1894 /* stop filtering packets based on bssid */
1895 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1901 static void wl1271_set_band_rate(struct wl1271 *wl)
1903 if (wl->band == IEEE80211_BAND_2GHZ)
1904 wl->basic_rate_set = wl->conf.tx.basic_rate;
1906 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1909 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
1914 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1915 ret = wl1271_unjoin(wl);
1919 wl->rate_set = wl1271_tx_min_rate_get(wl);
1920 ret = wl1271_acx_sta_rate_policies(wl);
1923 ret = wl1271_acx_keep_alive_config(
1924 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1925 ACX_KEEP_ALIVE_TPL_INVALID);
1928 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1930 /* increment the session counter */
1931 wl->session_counter++;
1932 if (wl->session_counter >= SESSION_COUNTER_MAX)
1933 wl->session_counter = 0;
1935 /* The current firmware only supports sched_scan in idle */
1936 if (wl->sched_scanning) {
1937 wl1271_scan_sched_scan_stop(wl);
1938 ieee80211_sched_scan_stopped(wl->hw);
1941 ret = wl1271_dummy_join(wl);
1944 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1951 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1953 struct wl1271 *wl = hw->priv;
1954 struct ieee80211_conf *conf = &hw->conf;
1955 int channel, ret = 0;
1958 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1960 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
1963 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1965 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1969 * mac80211 will go to idle nearly immediately after transmitting some
1970 * frames, such as the deauth. To make sure those frames reach the air,
1971 * wait here until the TX queue is fully flushed.
1973 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1974 (conf->flags & IEEE80211_CONF_IDLE))
1975 wl1271_tx_flush(wl);
1977 mutex_lock(&wl->mutex);
1979 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1980 /* we support configuring the channel and band while off */
1981 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
1982 wl->band = conf->channel->band;
1983 wl->channel = channel;
1989 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1991 ret = wl1271_ps_elp_wakeup(wl);
1995 /* if the channel changes while joined, join again */
1996 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1997 ((wl->band != conf->channel->band) ||
1998 (wl->channel != channel))) {
1999 wl->band = conf->channel->band;
2000 wl->channel = channel;
2004 * FIXME: the mac80211 should really provide a fixed
2005 * rate to use here. for now, just use the smallest
2006 * possible rate for the band as a fixed rate for
2007 * association frames and other control messages.
2009 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2010 wl1271_set_band_rate(wl);
2012 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2013 ret = wl1271_acx_sta_rate_policies(wl);
2015 wl1271_warning("rate policy for channel "
2018 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
2019 ret = wl1271_join(wl, false);
2021 wl1271_warning("cmd join on channel "
2027 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2028 ret = wl1271_sta_handle_idle(wl,
2029 conf->flags & IEEE80211_CONF_IDLE);
2031 wl1271_warning("idle mode change failed %d", ret);
2035 * if mac80211 changes the PSM mode, make sure the mode is not
2036 * incorrectly changed after the pspoll failure active window.
2038 if (changed & IEEE80211_CONF_CHANGE_PS)
2039 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2041 if (conf->flags & IEEE80211_CONF_PS &&
2042 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2043 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2046 * We enter PSM only if we're already associated.
2047 * If we're not, we'll enter it when joining an SSID,
2048 * through the bss_info_changed() hook.
2050 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2051 wl1271_debug(DEBUG_PSM, "psm enabled");
2052 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
2053 wl->basic_rate, true);
2055 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
2056 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2057 wl1271_debug(DEBUG_PSM, "psm disabled");
2059 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2061 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
2062 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
2063 wl->basic_rate, true);
2066 if (conf->power_level != wl->power_level) {
2067 ret = wl1271_acx_tx_power(wl, conf->power_level);
2071 wl->power_level = conf->power_level;
2075 wl1271_ps_elp_sleep(wl);
2078 mutex_unlock(&wl->mutex);
2083 struct wl1271_filter_params {
2086 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2089 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2090 struct netdev_hw_addr_list *mc_list)
2092 struct wl1271_filter_params *fp;
2093 struct netdev_hw_addr *ha;
2094 struct wl1271 *wl = hw->priv;
2096 if (unlikely(wl->state == WL1271_STATE_OFF))
2099 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2101 wl1271_error("Out of memory setting filters.");
2105 /* update multicast filtering parameters */
2106 fp->mc_list_length = 0;
2107 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2108 fp->enabled = false;
2111 netdev_hw_addr_list_for_each(ha, mc_list) {
2112 memcpy(fp->mc_list[fp->mc_list_length],
2113 ha->addr, ETH_ALEN);
2114 fp->mc_list_length++;
2118 return (u64)(unsigned long)fp;
2121 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2124 FIF_BCN_PRBRESP_PROMISC | \
2128 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2129 unsigned int changed,
2130 unsigned int *total, u64 multicast)
2132 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2133 struct wl1271 *wl = hw->priv;
2136 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2137 " total %x", changed, *total);
2139 mutex_lock(&wl->mutex);
2141 *total &= WL1271_SUPPORTED_FILTERS;
2142 changed &= WL1271_SUPPORTED_FILTERS;
2144 if (unlikely(wl->state == WL1271_STATE_OFF))
2147 ret = wl1271_ps_elp_wakeup(wl);
2151 if (wl->bss_type != BSS_TYPE_AP_BSS) {
2152 if (*total & FIF_ALLMULTI)
2153 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2155 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2157 fp->mc_list_length);
2162 /* determine, whether supported filter values have changed */
2166 /* configure filters */
2167 wl->filters = *total;
2168 wl1271_configure_filters(wl, 0);
2170 /* apply configured filters */
2171 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
2176 wl1271_ps_elp_sleep(wl);
2179 mutex_unlock(&wl->mutex);
2183 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2184 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2187 struct wl1271_ap_key *ap_key;
2190 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2192 if (key_size > MAX_KEY_SIZE)
2196 * Find next free entry in ap_keys. Also check we are not replacing
2199 for (i = 0; i < MAX_NUM_KEYS; i++) {
2200 if (wl->recorded_ap_keys[i] == NULL)
2203 if (wl->recorded_ap_keys[i]->id == id) {
2204 wl1271_warning("trying to record key replacement");
2209 if (i == MAX_NUM_KEYS)
2212 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2217 ap_key->key_type = key_type;
2218 ap_key->key_size = key_size;
2219 memcpy(ap_key->key, key, key_size);
2220 ap_key->hlid = hlid;
2221 ap_key->tx_seq_32 = tx_seq_32;
2222 ap_key->tx_seq_16 = tx_seq_16;
2224 wl->recorded_ap_keys[i] = ap_key;
2228 static void wl1271_free_ap_keys(struct wl1271 *wl)
2232 for (i = 0; i < MAX_NUM_KEYS; i++) {
2233 kfree(wl->recorded_ap_keys[i]);
2234 wl->recorded_ap_keys[i] = NULL;
2238 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2241 struct wl1271_ap_key *key;
2242 bool wep_key_added = false;
2244 for (i = 0; i < MAX_NUM_KEYS; i++) {
2245 if (wl->recorded_ap_keys[i] == NULL)
2248 key = wl->recorded_ap_keys[i];
2249 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2250 key->id, key->key_type,
2251 key->key_size, key->key,
2252 key->hlid, key->tx_seq_32,
2257 if (key->key_type == KEY_WEP)
2258 wep_key_added = true;
2261 if (wep_key_added) {
2262 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
2268 wl1271_free_ap_keys(wl);
2272 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2273 u8 key_size, const u8 *key, u32 tx_seq_32,
2274 u16 tx_seq_16, struct ieee80211_sta *sta)
2277 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2280 struct wl1271_station *wl_sta;
2284 wl_sta = (struct wl1271_station *)sta->drv_priv;
2285 hlid = wl_sta->hlid;
2287 hlid = WL1271_AP_BROADCAST_HLID;
2290 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2292 * We do not support removing keys after AP shutdown.
2293 * Pretend we do to make mac80211 happy.
2295 if (action != KEY_ADD_OR_REPLACE)
2298 ret = wl1271_record_ap_key(wl, id,
2300 key, hlid, tx_seq_32,
2303 ret = wl1271_cmd_set_ap_key(wl, action,
2304 id, key_type, key_size,
2305 key, hlid, tx_seq_32,
2313 static const u8 bcast_addr[ETH_ALEN] = {
2314 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2317 addr = sta ? sta->addr : bcast_addr;
2319 if (is_zero_ether_addr(addr)) {
2320 /* We dont support TX only encryption */
2324 /* The wl1271 does not allow to remove unicast keys - they
2325 will be cleared automatically on next CMD_JOIN. Ignore the
2326 request silently, as we dont want the mac80211 to emit
2327 an error message. */
2328 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2331 ret = wl1271_cmd_set_sta_key(wl, action,
2332 id, key_type, key_size,
2333 key, addr, tx_seq_32,
2338 /* the default WEP key needs to be configured at least once */
2339 if (key_type == KEY_WEP) {
2340 ret = wl1271_cmd_set_sta_default_wep_key(wl,
2350 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2351 struct ieee80211_vif *vif,
2352 struct ieee80211_sta *sta,
2353 struct ieee80211_key_conf *key_conf)
2355 struct wl1271 *wl = hw->priv;
2361 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2363 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2364 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2365 key_conf->cipher, key_conf->keyidx,
2366 key_conf->keylen, key_conf->flags);
2367 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2369 mutex_lock(&wl->mutex);
2371 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2376 ret = wl1271_ps_elp_wakeup(wl);
2380 switch (key_conf->cipher) {
2381 case WLAN_CIPHER_SUITE_WEP40:
2382 case WLAN_CIPHER_SUITE_WEP104:
2385 key_conf->hw_key_idx = key_conf->keyidx;
2387 case WLAN_CIPHER_SUITE_TKIP:
2388 key_type = KEY_TKIP;
2390 key_conf->hw_key_idx = key_conf->keyidx;
2391 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2392 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2394 case WLAN_CIPHER_SUITE_CCMP:
2397 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2398 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2399 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2401 case WL1271_CIPHER_SUITE_GEM:
2403 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2404 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2407 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2415 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2416 key_conf->keyidx, key_type,
2417 key_conf->keylen, key_conf->key,
2418 tx_seq_32, tx_seq_16, sta);
2420 wl1271_error("Could not add or replace key");
2426 ret = wl1271_set_key(wl, KEY_REMOVE,
2427 key_conf->keyidx, key_type,
2428 key_conf->keylen, key_conf->key,
2431 wl1271_error("Could not remove key");
2437 wl1271_error("Unsupported key cmd 0x%x", cmd);
2443 wl1271_ps_elp_sleep(wl);
2446 mutex_unlock(&wl->mutex);
2451 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
2452 struct ieee80211_vif *vif,
2453 struct cfg80211_scan_request *req)
2455 struct wl1271 *wl = hw->priv;
2460 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2463 ssid = req->ssids[0].ssid;
2464 len = req->ssids[0].ssid_len;
2467 mutex_lock(&wl->mutex);
2469 if (wl->state == WL1271_STATE_OFF) {
2471 * We cannot return -EBUSY here because cfg80211 will expect
2472 * a call to ieee80211_scan_completed if we do - in this case
2473 * there won't be any call.
2479 ret = wl1271_ps_elp_wakeup(wl);
2483 ret = wl1271_scan(hw->priv, ssid, len, req);
2485 wl1271_ps_elp_sleep(wl);
2488 mutex_unlock(&wl->mutex);
2493 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2494 struct ieee80211_vif *vif,
2495 struct cfg80211_sched_scan_request *req,
2496 struct ieee80211_sched_scan_ies *ies)
2498 struct wl1271 *wl = hw->priv;
2501 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2503 mutex_lock(&wl->mutex);
2505 ret = wl1271_ps_elp_wakeup(wl);
2509 ret = wl1271_scan_sched_scan_config(wl, req, ies);
2513 ret = wl1271_scan_sched_scan_start(wl);
2517 wl->sched_scanning = true;
2520 wl1271_ps_elp_sleep(wl);
2522 mutex_unlock(&wl->mutex);
2526 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2527 struct ieee80211_vif *vif)
2529 struct wl1271 *wl = hw->priv;
2532 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2534 mutex_lock(&wl->mutex);
2536 ret = wl1271_ps_elp_wakeup(wl);
2540 wl1271_scan_sched_scan_stop(wl);
2542 wl1271_ps_elp_sleep(wl);
2544 mutex_unlock(&wl->mutex);
2547 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2549 struct wl1271 *wl = hw->priv;
2552 mutex_lock(&wl->mutex);
2554 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2559 ret = wl1271_ps_elp_wakeup(wl);
2563 ret = wl1271_acx_frag_threshold(wl, value);
2565 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2567 wl1271_ps_elp_sleep(wl);
2570 mutex_unlock(&wl->mutex);
2575 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2577 struct wl1271 *wl = hw->priv;
2580 mutex_lock(&wl->mutex);
2582 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2587 ret = wl1271_ps_elp_wakeup(wl);
2591 ret = wl1271_acx_rts_threshold(wl, value);
2593 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2595 wl1271_ps_elp_sleep(wl);
2598 mutex_unlock(&wl->mutex);
2603 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2607 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2611 wl1271_error("No SSID in IEs!");
2616 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2617 wl1271_error("SSID is too long!");
2621 wl->ssid_len = ssid_len;
2622 memcpy(wl->ssid, ptr+2, ssid_len);
2626 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
2627 struct ieee80211_bss_conf *bss_conf,
2632 if (changed & BSS_CHANGED_ERP_SLOT) {
2633 if (bss_conf->use_short_slot)
2634 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2636 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2638 wl1271_warning("Set slot time failed %d", ret);
2643 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2644 if (bss_conf->use_short_preamble)
2645 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2647 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2650 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2651 if (bss_conf->use_cts_prot)
2652 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2654 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2656 wl1271_warning("Set ctsprotect failed %d", ret);
2665 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2666 struct ieee80211_vif *vif,
2667 struct ieee80211_bss_conf *bss_conf,
2670 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2673 if ((changed & BSS_CHANGED_BEACON_INT)) {
2674 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
2675 bss_conf->beacon_int);
2677 wl->beacon_int = bss_conf->beacon_int;
2680 if ((changed & BSS_CHANGED_BEACON)) {
2681 struct ieee80211_hdr *hdr;
2682 int ieoffset = offsetof(struct ieee80211_mgmt,
2684 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2690 wl1271_debug(DEBUG_MASTER, "beacon updated");
2692 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2694 dev_kfree_skb(beacon);
2697 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2699 ret = wl1271_cmd_template_set(wl, tmpl_id,
2702 wl1271_tx_min_rate_get(wl));
2704 dev_kfree_skb(beacon);
2708 hdr = (struct ieee80211_hdr *) beacon->data;
2709 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2710 IEEE80211_STYPE_PROBE_RESP);
2712 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2713 CMD_TEMPL_PROBE_RESPONSE;
2714 ret = wl1271_cmd_template_set(wl,
2718 wl1271_tx_min_rate_get(wl));
2719 dev_kfree_skb(beacon);
2728 /* AP mode changes */
2729 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2730 struct ieee80211_vif *vif,
2731 struct ieee80211_bss_conf *bss_conf,
2736 if ((changed & BSS_CHANGED_BASIC_RATES)) {
2737 u32 rates = bss_conf->basic_rates;
2739 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2740 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2742 ret = wl1271_init_ap_rates(wl);
2744 wl1271_error("AP rate policy change failed %d", ret);
2748 ret = wl1271_ap_init_templates(wl);
2753 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2757 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2758 if (bss_conf->enable_beacon) {
2759 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2760 ret = wl1271_cmd_start_bss(wl);
2764 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2765 wl1271_debug(DEBUG_AP, "started AP");
2767 ret = wl1271_ap_init_hwenc(wl);
2772 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2773 ret = wl1271_cmd_stop_bss(wl);
2777 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2778 wl1271_debug(DEBUG_AP, "stopped AP");
2783 if (changed & BSS_CHANGED_IBSS) {
2784 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
2785 bss_conf->ibss_joined);
2787 if (bss_conf->ibss_joined) {
2788 u32 rates = bss_conf->basic_rates;
2789 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2791 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2793 /* by default, use 11b rates */
2794 wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
2795 ret = wl1271_acx_sta_rate_policies(wl);
2801 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2808 /* STA/IBSS mode changes */
2809 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2810 struct ieee80211_vif *vif,
2811 struct ieee80211_bss_conf *bss_conf,
2814 bool do_join = false, set_assoc = false;
2815 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2816 u32 sta_rate_set = 0;
2818 struct ieee80211_sta *sta;
2819 bool sta_exists = false;
2820 struct ieee80211_sta_ht_cap sta_ht_cap;
2823 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2829 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
2832 /* Need to update the SSID (for filtering etc) */
2833 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2836 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
2837 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2838 bss_conf->enable_beacon ? "enabled" : "disabled");
2840 if (bss_conf->enable_beacon)
2841 wl->set_bss_type = BSS_TYPE_IBSS;
2843 wl->set_bss_type = BSS_TYPE_STA_BSS;
2847 if ((changed & BSS_CHANGED_CQM)) {
2848 bool enable = false;
2849 if (bss_conf->cqm_rssi_thold)
2851 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2852 bss_conf->cqm_rssi_thold,
2853 bss_conf->cqm_rssi_hyst);
2856 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2859 if ((changed & BSS_CHANGED_BSSID) &&
2861 * Now we know the correct bssid, so we send a new join command
2862 * and enable the BSSID filter
2864 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
2865 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
2867 if (!is_zero_ether_addr(wl->bssid)) {
2868 ret = wl1271_cmd_build_null_data(wl);
2872 ret = wl1271_build_qos_null_data(wl);
2876 /* filter out all packets not from this BSSID */
2877 wl1271_configure_filters(wl, 0);
2879 /* Need to update the BSSID (for filtering etc) */
2885 sta = ieee80211_find_sta(vif, bss_conf->bssid);
2887 /* save the supp_rates of the ap */
2888 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
2889 if (sta->ht_cap.ht_supported)
2891 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
2892 sta_ht_cap = sta->ht_cap;
2898 /* handle new association with HT and HT information change */
2899 if ((changed & BSS_CHANGED_HT) &&
2900 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2901 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2904 wl1271_warning("Set ht cap true failed %d",
2908 ret = wl1271_acx_set_ht_information(wl,
2909 bss_conf->ht_operation_mode);
2911 wl1271_warning("Set ht information failed %d",
2916 /* handle new association without HT and disassociation */
2917 else if (changed & BSS_CHANGED_ASSOC) {
2918 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2921 wl1271_warning("Set ht cap false failed %d",
2928 if ((changed & BSS_CHANGED_ASSOC)) {
2929 if (bss_conf->assoc) {
2932 wl->aid = bss_conf->aid;
2935 wl->ps_poll_failures = 0;
2938 * use basic rates from AP, and determine lowest rate
2939 * to use with control frames.
2941 rates = bss_conf->basic_rates;
2942 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2944 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2946 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
2948 ret = wl1271_acx_sta_rate_policies(wl);
2953 * with wl1271, we don't need to update the
2954 * beacon_int and dtim_period, because the firmware
2955 * updates it by itself when the first beacon is
2956 * received after a join.
2958 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2963 * Get a template for hardware connection maintenance
2965 dev_kfree_skb(wl->probereq);
2966 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2967 ieoffset = offsetof(struct ieee80211_mgmt,
2968 u.probe_req.variable);
2969 wl1271_ssid_set(wl, wl->probereq, ieoffset);
2971 /* enable the connection monitoring feature */
2972 ret = wl1271_acx_conn_monit_params(wl, true);
2976 /* If we want to go in PSM but we're not there yet */
2977 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2978 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
2979 enum wl1271_cmd_ps_mode mode;
2981 mode = STATION_POWER_SAVE_MODE;
2982 ret = wl1271_ps_set_mode(wl, mode,
2989 /* use defaults when not associated */
2991 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
2993 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
2996 /* free probe-request template */
2997 dev_kfree_skb(wl->probereq);
2998 wl->probereq = NULL;
3000 /* re-enable dynamic ps - just in case */
3001 ieee80211_enable_dyn_ps(wl->vif);
3003 /* revert back to minimum rates for the current band */
3004 wl1271_set_band_rate(wl);
3005 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3006 ret = wl1271_acx_sta_rate_policies(wl);
3010 /* disable connection monitor features */
3011 ret = wl1271_acx_conn_monit_params(wl, false);
3013 /* Disable the keep-alive feature */
3014 ret = wl1271_acx_keep_alive_mode(wl, false);
3018 /* restore the bssid filter and go to dummy bssid */
3021 wl1271_dummy_join(wl);
3026 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3030 if (changed & BSS_CHANGED_ARP_FILTER) {
3031 __be32 addr = bss_conf->arp_addr_list[0];
3032 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3034 if (bss_conf->arp_addr_cnt == 1 &&
3035 bss_conf->arp_filter_enabled) {
3037 * The template should have been configured only upon
3038 * association. however, it seems that the correct ip
3039 * isn't being set (when sending), so we have to
3040 * reconfigure the template upon every ip change.
3042 ret = wl1271_cmd_build_arp_rsp(wl, addr);
3044 wl1271_warning("build arp rsp failed: %d", ret);
3048 ret = wl1271_acx_arp_ip_filter(wl,
3049 ACX_ARP_FILTER_ARP_FILTERING,
3052 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
3059 ret = wl1271_join(wl, set_assoc);
3061 wl1271_warning("cmd join failed %d", ret);
3070 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3071 struct ieee80211_vif *vif,
3072 struct ieee80211_bss_conf *bss_conf,
3075 struct wl1271 *wl = hw->priv;
3076 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3079 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3082 mutex_lock(&wl->mutex);
3084 if (unlikely(wl->state == WL1271_STATE_OFF))
3087 ret = wl1271_ps_elp_wakeup(wl);
3092 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3094 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3096 wl1271_ps_elp_sleep(wl);
3099 mutex_unlock(&wl->mutex);
3102 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3103 const struct ieee80211_tx_queue_params *params)
3105 struct wl1271 *wl = hw->priv;
3109 mutex_lock(&wl->mutex);
3111 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3114 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3116 ps_scheme = CONF_PS_SCHEME_LEGACY;
3118 if (wl->state == WL1271_STATE_OFF) {
3120 * If the state is off, the parameters will be recorded and
3121 * configured on init. This happens in AP-mode.
3123 struct conf_tx_ac_category *conf_ac =
3124 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3125 struct conf_tx_tid *conf_tid =
3126 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3128 conf_ac->ac = wl1271_tx_get_queue(queue);
3129 conf_ac->cw_min = (u8)params->cw_min;
3130 conf_ac->cw_max = params->cw_max;
3131 conf_ac->aifsn = params->aifs;
3132 conf_ac->tx_op_limit = params->txop << 5;
3134 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3135 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3136 conf_tid->tsid = wl1271_tx_get_queue(queue);
3137 conf_tid->ps_scheme = ps_scheme;
3138 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3139 conf_tid->apsd_conf[0] = 0;
3140 conf_tid->apsd_conf[1] = 0;
3144 ret = wl1271_ps_elp_wakeup(wl);
3149 * the txop is confed in units of 32us by the mac80211,
3152 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3153 params->cw_min, params->cw_max,
3154 params->aifs, params->txop << 5);
3158 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3159 CONF_CHANNEL_TYPE_EDCF,
3160 wl1271_tx_get_queue(queue),
3161 ps_scheme, CONF_ACK_POLICY_LEGACY,
3165 wl1271_ps_elp_sleep(wl);
3168 mutex_unlock(&wl->mutex);
3173 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3176 struct wl1271 *wl = hw->priv;
3177 u64 mactime = ULLONG_MAX;
3180 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3182 mutex_lock(&wl->mutex);
3184 if (unlikely(wl->state == WL1271_STATE_OFF))
3187 ret = wl1271_ps_elp_wakeup(wl);
3191 ret = wl1271_acx_tsf_info(wl, &mactime);
3196 wl1271_ps_elp_sleep(wl);
3199 mutex_unlock(&wl->mutex);
3203 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3204 struct survey_info *survey)
3206 struct wl1271 *wl = hw->priv;
3207 struct ieee80211_conf *conf = &hw->conf;
3212 survey->channel = conf->channel;
3213 survey->filled = SURVEY_INFO_NOISE_DBM;
3214 survey->noise = wl->noise;
3219 static int wl1271_allocate_sta(struct wl1271 *wl,
3220 struct ieee80211_sta *sta,
3223 struct wl1271_station *wl_sta;
3226 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3227 if (id >= AP_MAX_STATIONS) {
3228 wl1271_warning("could not allocate HLID - too much stations");
3232 wl_sta = (struct wl1271_station *)sta->drv_priv;
3233 __set_bit(id, wl->ap_hlid_map);
3234 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3235 *hlid = wl_sta->hlid;
3236 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
3240 static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
3242 int id = hlid - WL1271_AP_STA_HLID_START;
3244 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3247 __clear_bit(id, wl->ap_hlid_map);
3248 memset(wl->links[hlid].addr, 0, ETH_ALEN);
3249 wl1271_tx_reset_link_queues(wl, hlid);
3250 __clear_bit(hlid, &wl->ap_ps_map);
3251 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
3254 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3255 struct ieee80211_vif *vif,
3256 struct ieee80211_sta *sta)
3258 struct wl1271 *wl = hw->priv;
3262 mutex_lock(&wl->mutex);
3264 if (unlikely(wl->state == WL1271_STATE_OFF))
3267 if (wl->bss_type != BSS_TYPE_AP_BSS)
3270 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3272 ret = wl1271_allocate_sta(wl, sta, &hlid);
3276 ret = wl1271_ps_elp_wakeup(wl);
3280 ret = wl1271_cmd_add_sta(wl, sta, hlid);
3285 wl1271_ps_elp_sleep(wl);
3289 wl1271_free_sta(wl, hlid);
3292 mutex_unlock(&wl->mutex);
3296 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3297 struct ieee80211_vif *vif,
3298 struct ieee80211_sta *sta)
3300 struct wl1271 *wl = hw->priv;
3301 struct wl1271_station *wl_sta;
3304 mutex_lock(&wl->mutex);
3306 if (unlikely(wl->state == WL1271_STATE_OFF))
3309 if (wl->bss_type != BSS_TYPE_AP_BSS)
3312 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3314 wl_sta = (struct wl1271_station *)sta->drv_priv;
3315 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3316 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3319 ret = wl1271_ps_elp_wakeup(wl);
3323 ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
3327 wl1271_free_sta(wl, wl_sta->hlid);
3330 wl1271_ps_elp_sleep(wl);
3333 mutex_unlock(&wl->mutex);
3337 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3338 struct ieee80211_vif *vif,
3339 enum ieee80211_ampdu_mlme_action action,
3340 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3343 struct wl1271 *wl = hw->priv;
3346 mutex_lock(&wl->mutex);
3348 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3353 ret = wl1271_ps_elp_wakeup(wl);
3358 case IEEE80211_AMPDU_RX_START:
3359 if (wl->ba_support) {
3360 ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
3363 wl->ba_rx_bitmap |= BIT(tid);
3369 case IEEE80211_AMPDU_RX_STOP:
3370 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
3372 wl->ba_rx_bitmap &= ~BIT(tid);
3376 * The BA initiator session management in FW independently.
3377 * Falling break here on purpose for all TX APDU commands.
3379 case IEEE80211_AMPDU_TX_START:
3380 case IEEE80211_AMPDU_TX_STOP:
3381 case IEEE80211_AMPDU_TX_OPERATIONAL:
3386 wl1271_error("Incorrect ampdu action id=%x\n", action);
3390 wl1271_ps_elp_sleep(wl);
3393 mutex_unlock(&wl->mutex);
3398 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3400 struct wl1271 *wl = hw->priv;
3403 mutex_lock(&wl->mutex);
3405 if (unlikely(wl->state == WL1271_STATE_OFF))
3408 /* packets are considered pending if in the TX queue or the FW */
3409 ret = (wl->tx_queue_count > 0) || (wl->tx_frames_cnt > 0);
3411 /* the above is appropriate for STA mode for PS purposes */
3412 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3415 mutex_unlock(&wl->mutex);
3420 /* can't be const, mac80211 writes to this */
3421 static struct ieee80211_rate wl1271_rates[] = {
3423 .hw_value = CONF_HW_BIT_RATE_1MBPS,
3424 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
3426 .hw_value = CONF_HW_BIT_RATE_2MBPS,
3427 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
3428 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3430 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3431 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
3432 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3434 .hw_value = CONF_HW_BIT_RATE_11MBPS,
3435 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
3436 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3438 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3439 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3441 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3442 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3444 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3445 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3447 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3448 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3450 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3451 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3453 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3454 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3456 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3457 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3459 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3460 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3463 /* can't be const, mac80211 writes to this */
3464 static struct ieee80211_channel wl1271_channels[] = {
3465 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
3466 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
3467 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3468 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3469 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
3470 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
3471 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3472 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3473 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
3474 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
3475 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3476 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3477 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
3478 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
3481 /* mapping to indexes for wl1271_rates */
3482 static const u8 wl1271_rate_to_idx_2ghz[] = {
3483 /* MCS rates are used only with 11n */
3484 7, /* CONF_HW_RXTX_RATE_MCS7 */
3485 6, /* CONF_HW_RXTX_RATE_MCS6 */
3486 5, /* CONF_HW_RXTX_RATE_MCS5 */
3487 4, /* CONF_HW_RXTX_RATE_MCS4 */
3488 3, /* CONF_HW_RXTX_RATE_MCS3 */
3489 2, /* CONF_HW_RXTX_RATE_MCS2 */
3490 1, /* CONF_HW_RXTX_RATE_MCS1 */
3491 0, /* CONF_HW_RXTX_RATE_MCS0 */
3493 11, /* CONF_HW_RXTX_RATE_54 */
3494 10, /* CONF_HW_RXTX_RATE_48 */
3495 9, /* CONF_HW_RXTX_RATE_36 */
3496 8, /* CONF_HW_RXTX_RATE_24 */
3498 /* TI-specific rate */
3499 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3501 7, /* CONF_HW_RXTX_RATE_18 */
3502 6, /* CONF_HW_RXTX_RATE_12 */
3503 3, /* CONF_HW_RXTX_RATE_11 */
3504 5, /* CONF_HW_RXTX_RATE_9 */
3505 4, /* CONF_HW_RXTX_RATE_6 */
3506 2, /* CONF_HW_RXTX_RATE_5_5 */
3507 1, /* CONF_HW_RXTX_RATE_2 */
3508 0 /* CONF_HW_RXTX_RATE_1 */
3511 /* 11n STA capabilities */
3512 #define HW_RX_HIGHEST_RATE 72
3514 #ifdef CONFIG_WL12XX_HT
3515 #define WL12XX_HT_CAP { \
3516 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3517 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
3518 .ht_supported = true, \
3519 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3520 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3522 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3523 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3524 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3528 #define WL12XX_HT_CAP { \
3529 .ht_supported = false, \
3533 /* can't be const, mac80211 writes to this */
3534 static struct ieee80211_supported_band wl1271_band_2ghz = {
3535 .channels = wl1271_channels,
3536 .n_channels = ARRAY_SIZE(wl1271_channels),
3537 .bitrates = wl1271_rates,
3538 .n_bitrates = ARRAY_SIZE(wl1271_rates),
3539 .ht_cap = WL12XX_HT_CAP,
3542 /* 5 GHz data rates for WL1273 */
3543 static struct ieee80211_rate wl1271_rates_5ghz[] = {
3545 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3546 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3548 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3549 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3551 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3552 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3554 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3555 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3557 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3558 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3560 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3561 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3563 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3564 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3566 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3567 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3570 /* 5 GHz band channels for WL1273 */
3571 static struct ieee80211_channel wl1271_channels_5ghz[] = {
3572 { .hw_value = 7, .center_freq = 5035},
3573 { .hw_value = 8, .center_freq = 5040},
3574 { .hw_value = 9, .center_freq = 5045},
3575 { .hw_value = 11, .center_freq = 5055},
3576 { .hw_value = 12, .center_freq = 5060},
3577 { .hw_value = 16, .center_freq = 5080},
3578 { .hw_value = 34, .center_freq = 5170},
3579 { .hw_value = 36, .center_freq = 5180},
3580 { .hw_value = 38, .center_freq = 5190},
3581 { .hw_value = 40, .center_freq = 5200},
3582 { .hw_value = 42, .center_freq = 5210},
3583 { .hw_value = 44, .center_freq = 5220},
3584 { .hw_value = 46, .center_freq = 5230},
3585 { .hw_value = 48, .center_freq = 5240},
3586 { .hw_value = 52, .center_freq = 5260},
3587 { .hw_value = 56, .center_freq = 5280},
3588 { .hw_value = 60, .center_freq = 5300},
3589 { .hw_value = 64, .center_freq = 5320},
3590 { .hw_value = 100, .center_freq = 5500},
3591 { .hw_value = 104, .center_freq = 5520},
3592 { .hw_value = 108, .center_freq = 5540},
3593 { .hw_value = 112, .center_freq = 5560},
3594 { .hw_value = 116, .center_freq = 5580},
3595 { .hw_value = 120, .center_freq = 5600},
3596 { .hw_value = 124, .center_freq = 5620},
3597 { .hw_value = 128, .center_freq = 5640},
3598 { .hw_value = 132, .center_freq = 5660},
3599 { .hw_value = 136, .center_freq = 5680},
3600 { .hw_value = 140, .center_freq = 5700},
3601 { .hw_value = 149, .center_freq = 5745},
3602 { .hw_value = 153, .center_freq = 5765},
3603 { .hw_value = 157, .center_freq = 5785},
3604 { .hw_value = 161, .center_freq = 5805},
3605 { .hw_value = 165, .center_freq = 5825},
3608 /* mapping to indexes for wl1271_rates_5ghz */
3609 static const u8 wl1271_rate_to_idx_5ghz[] = {
3610 /* MCS rates are used only with 11n */
3611 7, /* CONF_HW_RXTX_RATE_MCS7 */
3612 6, /* CONF_HW_RXTX_RATE_MCS6 */
3613 5, /* CONF_HW_RXTX_RATE_MCS5 */
3614 4, /* CONF_HW_RXTX_RATE_MCS4 */
3615 3, /* CONF_HW_RXTX_RATE_MCS3 */
3616 2, /* CONF_HW_RXTX_RATE_MCS2 */
3617 1, /* CONF_HW_RXTX_RATE_MCS1 */
3618 0, /* CONF_HW_RXTX_RATE_MCS0 */
3620 7, /* CONF_HW_RXTX_RATE_54 */
3621 6, /* CONF_HW_RXTX_RATE_48 */
3622 5, /* CONF_HW_RXTX_RATE_36 */
3623 4, /* CONF_HW_RXTX_RATE_24 */
3625 /* TI-specific rate */
3626 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3628 3, /* CONF_HW_RXTX_RATE_18 */
3629 2, /* CONF_HW_RXTX_RATE_12 */
3630 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
3631 1, /* CONF_HW_RXTX_RATE_9 */
3632 0, /* CONF_HW_RXTX_RATE_6 */
3633 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
3634 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
3635 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
3638 static struct ieee80211_supported_band wl1271_band_5ghz = {
3639 .channels = wl1271_channels_5ghz,
3640 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3641 .bitrates = wl1271_rates_5ghz,
3642 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
3643 .ht_cap = WL12XX_HT_CAP,
3646 static const u8 *wl1271_band_rate_to_idx[] = {
3647 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3648 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3651 static const struct ieee80211_ops wl1271_ops = {
3652 .start = wl1271_op_start,
3653 .stop = wl1271_op_stop,
3654 .add_interface = wl1271_op_add_interface,
3655 .remove_interface = wl1271_op_remove_interface,
3657 .suspend = wl1271_op_suspend,
3658 .resume = wl1271_op_resume,
3660 .config = wl1271_op_config,
3661 .prepare_multicast = wl1271_op_prepare_multicast,
3662 .configure_filter = wl1271_op_configure_filter,
3664 .set_key = wl1271_op_set_key,
3665 .hw_scan = wl1271_op_hw_scan,
3666 .sched_scan_start = wl1271_op_sched_scan_start,
3667 .sched_scan_stop = wl1271_op_sched_scan_stop,
3668 .bss_info_changed = wl1271_op_bss_info_changed,
3669 .set_frag_threshold = wl1271_op_set_frag_threshold,
3670 .set_rts_threshold = wl1271_op_set_rts_threshold,
3671 .conf_tx = wl1271_op_conf_tx,
3672 .get_tsf = wl1271_op_get_tsf,
3673 .get_survey = wl1271_op_get_survey,
3674 .sta_add = wl1271_op_sta_add,
3675 .sta_remove = wl1271_op_sta_remove,
3676 .ampdu_action = wl1271_op_ampdu_action,
3677 .tx_frames_pending = wl1271_tx_frames_pending,
3678 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
3682 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
3686 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
3688 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3689 wl1271_error("Illegal RX rate from HW: %d", rate);
3693 idx = wl1271_band_rate_to_idx[band][rate];
3694 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3695 wl1271_error("Unsupported RX rate from HW: %d", rate);
3702 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3703 struct device_attribute *attr,
3706 struct wl1271 *wl = dev_get_drvdata(dev);
3711 mutex_lock(&wl->mutex);
3712 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3714 mutex_unlock(&wl->mutex);
3720 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3721 struct device_attribute *attr,
3722 const char *buf, size_t count)
3724 struct wl1271 *wl = dev_get_drvdata(dev);
3728 ret = kstrtoul(buf, 10, &res);
3730 wl1271_warning("incorrect value written to bt_coex_mode");
3734 mutex_lock(&wl->mutex);
3738 if (res == wl->sg_enabled)
3741 wl->sg_enabled = res;
3743 if (wl->state == WL1271_STATE_OFF)
3746 ret = wl1271_ps_elp_wakeup(wl);
3750 wl1271_acx_sg_enable(wl, wl->sg_enabled);
3751 wl1271_ps_elp_sleep(wl);
3754 mutex_unlock(&wl->mutex);
3758 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3759 wl1271_sysfs_show_bt_coex_state,
3760 wl1271_sysfs_store_bt_coex_state);
3762 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3763 struct device_attribute *attr,
3766 struct wl1271 *wl = dev_get_drvdata(dev);
3771 mutex_lock(&wl->mutex);
3772 if (wl->hw_pg_ver >= 0)
3773 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3775 len = snprintf(buf, len, "n/a\n");
3776 mutex_unlock(&wl->mutex);
3781 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3782 wl1271_sysfs_show_hw_pg_ver, NULL);
3784 int wl1271_register_hw(struct wl1271 *wl)
3788 if (wl->mac80211_registered)
3791 ret = wl1271_fetch_nvs(wl);
3793 /* NOTE: The wl->nvs->nvs element must be first, in
3794 * order to simplify the casting, we assume it is at
3795 * the beginning of the wl->nvs structure.
3797 u8 *nvs_ptr = (u8 *)wl->nvs;
3799 wl->mac_addr[0] = nvs_ptr[11];
3800 wl->mac_addr[1] = nvs_ptr[10];
3801 wl->mac_addr[2] = nvs_ptr[6];
3802 wl->mac_addr[3] = nvs_ptr[5];
3803 wl->mac_addr[4] = nvs_ptr[4];
3804 wl->mac_addr[5] = nvs_ptr[3];
3807 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3809 ret = ieee80211_register_hw(wl->hw);
3811 wl1271_error("unable to register mac80211 hw: %d", ret);
3815 wl->mac80211_registered = true;
3817 wl1271_debugfs_init(wl);
3819 register_netdevice_notifier(&wl1271_dev_notifier);
3821 wl1271_notice("loaded");
3825 EXPORT_SYMBOL_GPL(wl1271_register_hw);
3827 void wl1271_unregister_hw(struct wl1271 *wl)
3829 if (wl->state == WL1271_STATE_PLT)
3830 __wl1271_plt_stop(wl);
3832 unregister_netdevice_notifier(&wl1271_dev_notifier);
3833 ieee80211_unregister_hw(wl->hw);
3834 wl->mac80211_registered = false;
3837 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
3839 int wl1271_init_ieee80211(struct wl1271 *wl)
3841 static const u32 cipher_suites[] = {
3842 WLAN_CIPHER_SUITE_WEP40,
3843 WLAN_CIPHER_SUITE_WEP104,
3844 WLAN_CIPHER_SUITE_TKIP,
3845 WLAN_CIPHER_SUITE_CCMP,
3846 WL1271_CIPHER_SUITE_GEM,
3849 /* The tx descriptor buffer and the TKIP space. */
3850 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
3851 sizeof(struct wl1271_tx_hw_descr);
3854 /* FIXME: find a proper value */
3855 wl->hw->channel_change_time = 10000;
3856 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
3858 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3859 IEEE80211_HW_BEACON_FILTER |
3860 IEEE80211_HW_SUPPORTS_PS |
3861 IEEE80211_HW_SUPPORTS_UAPSD |
3862 IEEE80211_HW_HAS_RATE_CONTROL |
3863 IEEE80211_HW_CONNECTION_MONITOR |
3864 IEEE80211_HW_SUPPORTS_CQM_RSSI |
3865 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3866 IEEE80211_HW_SPECTRUM_MGMT |
3867 IEEE80211_HW_AP_LINK_PS;
3869 wl->hw->wiphy->cipher_suites = cipher_suites;
3870 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3872 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3873 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
3874 wl->hw->wiphy->max_scan_ssids = 1;
3876 * Maximum length of elements in scanning probe request templates
3877 * should be the maximum length possible for a template, without
3878 * the IEEE80211 header of the template
3880 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
3881 sizeof(struct ieee80211_header);
3883 /* make sure all our channels fit in the scanned_ch bitmask */
3884 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
3885 ARRAY_SIZE(wl1271_channels_5ghz) >
3886 WL1271_MAX_CHANNELS);
3888 * We keep local copies of the band structs because we need to
3889 * modify them on a per-device basis.
3891 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
3892 sizeof(wl1271_band_2ghz));
3893 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
3894 sizeof(wl1271_band_5ghz));
3896 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
3897 &wl->bands[IEEE80211_BAND_2GHZ];
3898 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
3899 &wl->bands[IEEE80211_BAND_5GHZ];
3902 wl->hw->max_rates = 1;
3904 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
3906 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
3908 wl->hw->sta_data_size = sizeof(struct wl1271_station);
3910 wl->hw->max_rx_aggregation_subframes = 8;
3914 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
3916 #define WL1271_DEFAULT_CHANNEL 0
3918 struct ieee80211_hw *wl1271_alloc_hw(void)
3920 struct ieee80211_hw *hw;
3921 struct platform_device *plat_dev = NULL;
3926 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
3928 wl1271_error("could not alloc ieee80211_hw");
3933 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3935 wl1271_error("could not allocate platform_device");
3937 goto err_plat_alloc;
3941 memset(wl, 0, sizeof(*wl));
3943 INIT_LIST_HEAD(&wl->list);
3946 wl->plat_dev = plat_dev;
3948 for (i = 0; i < NUM_TX_QUEUES; i++)
3949 skb_queue_head_init(&wl->tx_queue[i]);
3951 for (i = 0; i < NUM_TX_QUEUES; i++)
3952 for (j = 0; j < AP_MAX_LINKS; j++)
3953 skb_queue_head_init(&wl->links[j].tx_queue[i]);
3955 skb_queue_head_init(&wl->deferred_rx_queue);
3956 skb_queue_head_init(&wl->deferred_tx_queue);
3958 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
3959 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
3960 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
3961 INIT_WORK(&wl->tx_work, wl1271_tx_work);
3962 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
3963 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
3964 wl->channel = WL1271_DEFAULT_CHANNEL;
3965 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
3966 wl->default_key = 0;
3968 wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
3969 wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
3970 wl->psm_entry_retry = 0;
3971 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
3972 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
3973 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
3974 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
3975 wl->band = IEEE80211_BAND_2GHZ;
3978 wl->sg_enabled = true;
3980 wl->bss_type = MAX_BSS_TYPE;
3981 wl->set_bss_type = MAX_BSS_TYPE;
3982 wl->fw_bss_type = MAX_BSS_TYPE;
3983 wl->last_tx_hlid = 0;
3985 wl->ap_fw_ps_map = 0;
3987 wl->platform_quirks = 0;
3988 wl->sched_scanning = false;
3990 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
3991 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
3992 wl->tx_frames[i] = NULL;
3994 spin_lock_init(&wl->wl_lock);
3996 wl->state = WL1271_STATE_OFF;
3997 mutex_init(&wl->mutex);
3999 /* Apply default driver configuration. */
4000 wl1271_conf_init(wl);
4002 order = get_order(WL1271_AGGR_BUFFER_SIZE);
4003 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4004 if (!wl->aggr_buf) {
4009 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4010 if (!wl->dummy_packet) {
4015 /* Register platform device */
4016 ret = platform_device_register(wl->plat_dev);
4018 wl1271_error("couldn't register platform device");
4019 goto err_dummy_packet;
4021 dev_set_drvdata(&wl->plat_dev->dev, wl);
4023 /* Create sysfs file to control bt coex state */
4024 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4026 wl1271_error("failed to create sysfs file bt_coex_state");
4030 /* Create sysfs file to get HW PG version */
4031 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4033 wl1271_error("failed to create sysfs file hw_pg_ver");
4034 goto err_bt_coex_state;
4040 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4043 platform_device_unregister(wl->plat_dev);
4046 dev_kfree_skb(wl->dummy_packet);
4049 free_pages((unsigned long)wl->aggr_buf, order);
4052 wl1271_debugfs_exit(wl);
4056 ieee80211_free_hw(hw);
4060 return ERR_PTR(ret);
4062 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
4064 int wl1271_free_hw(struct wl1271 *wl)
4066 platform_device_unregister(wl->plat_dev);
4067 dev_kfree_skb(wl->dummy_packet);
4068 free_pages((unsigned long)wl->aggr_buf,
4069 get_order(WL1271_AGGR_BUFFER_SIZE));
4070 kfree(wl->plat_dev);
4072 wl1271_debugfs_exit(wl);
4079 kfree(wl->fw_status);
4080 kfree(wl->tx_res_if);
4082 ieee80211_free_hw(wl->hw);
4086 EXPORT_SYMBOL_GPL(wl1271_free_hw);
4088 u32 wl12xx_debug_level = DEBUG_NONE;
4089 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
4090 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
4091 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4093 MODULE_LICENSE("GPL");
4094 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4095 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");