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 */
371 .hci_io_ds = HCI_IO_DS_6MA,
374 static void __wl1271_op_remove_interface(struct wl1271 *wl,
375 bool reset_tx_queues);
376 static void wl1271_free_ap_keys(struct wl1271 *wl);
379 static void wl1271_device_release(struct device *dev)
384 static struct platform_device wl1271_device = {
388 /* device model insists to have a release function */
390 .release = wl1271_device_release,
394 static DEFINE_MUTEX(wl_list_mutex);
395 static LIST_HEAD(wl_list);
397 static int wl1271_check_operstate(struct wl1271 *wl, unsigned char operstate)
400 if (operstate != IF_OPER_UP)
403 if (test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags))
406 ret = wl1271_cmd_set_sta_state(wl);
410 wl1271_info("Association completed.");
413 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
416 struct net_device *dev = arg;
417 struct wireless_dev *wdev;
419 struct ieee80211_hw *hw;
421 struct wl1271 *wl_temp;
424 /* Check that this notification is for us. */
425 if (what != NETDEV_CHANGE)
428 wdev = dev->ieee80211_ptr;
436 hw = wiphy_priv(wiphy);
441 mutex_lock(&wl_list_mutex);
442 list_for_each_entry(wl, &wl_list, list) {
446 mutex_unlock(&wl_list_mutex);
450 mutex_lock(&wl->mutex);
452 if (wl->state == WL1271_STATE_OFF)
455 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
458 ret = wl1271_ps_elp_wakeup(wl);
462 wl1271_check_operstate(wl, dev->operstate);
464 wl1271_ps_elp_sleep(wl);
467 mutex_unlock(&wl->mutex);
472 static int wl1271_reg_notify(struct wiphy *wiphy,
473 struct regulatory_request *request)
475 struct ieee80211_supported_band *band;
476 struct ieee80211_channel *ch;
479 band = wiphy->bands[IEEE80211_BAND_5GHZ];
480 for (i = 0; i < band->n_channels; i++) {
481 ch = &band->channels[i];
482 if (ch->flags & IEEE80211_CHAN_DISABLED)
485 if (ch->flags & IEEE80211_CHAN_RADAR)
486 ch->flags |= IEEE80211_CHAN_NO_IBSS |
487 IEEE80211_CHAN_PASSIVE_SCAN;
494 static int wl1271_set_rx_streaming(struct wl1271 *wl, bool enable)
498 /* we should hold wl->mutex */
499 ret = wl1271_acx_ps_rx_streaming(wl, enable);
504 set_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags);
506 clear_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags);
512 * this function is being called when the rx_streaming interval
513 * has beed changed or rx_streaming should be disabled
515 int wl1271_recalc_rx_streaming(struct wl1271 *wl)
518 int period = wl->conf.rx_streaming.interval;
520 /* don't reconfigure if rx_streaming is disabled */
521 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
524 /* reconfigure/disable according to new streaming_period */
526 test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) &&
527 (wl->conf.rx_streaming.always ||
528 test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
529 ret = wl1271_set_rx_streaming(wl, true);
531 ret = wl1271_set_rx_streaming(wl, false);
532 /* don't cancel_work_sync since we might deadlock */
533 del_timer_sync(&wl->rx_streaming_timer);
539 static void wl1271_rx_streaming_enable_work(struct work_struct *work)
543 container_of(work, struct wl1271, rx_streaming_enable_work);
545 mutex_lock(&wl->mutex);
547 if (test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags) ||
548 !test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) ||
549 (!wl->conf.rx_streaming.always &&
550 !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
553 if (!wl->conf.rx_streaming.interval)
556 ret = wl1271_ps_elp_wakeup(wl);
560 ret = wl1271_set_rx_streaming(wl, true);
564 /* stop it after some time of inactivity */
565 mod_timer(&wl->rx_streaming_timer,
566 jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));
569 wl1271_ps_elp_sleep(wl);
571 mutex_unlock(&wl->mutex);
574 static void wl1271_rx_streaming_disable_work(struct work_struct *work)
578 container_of(work, struct wl1271, rx_streaming_disable_work);
580 mutex_lock(&wl->mutex);
582 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
585 ret = wl1271_ps_elp_wakeup(wl);
589 ret = wl1271_set_rx_streaming(wl, false);
594 wl1271_ps_elp_sleep(wl);
596 mutex_unlock(&wl->mutex);
599 static void wl1271_rx_streaming_timer(unsigned long data)
601 struct wl1271 *wl = (struct wl1271 *)data;
602 ieee80211_queue_work(wl->hw, &wl->rx_streaming_disable_work);
605 static void wl1271_conf_init(struct wl1271 *wl)
609 * This function applies the default configuration to the driver. This
610 * function is invoked upon driver load (spi probe.)
612 * The configuration is stored in a run-time structure in order to
613 * facilitate for run-time adjustment of any of the parameters. Making
614 * changes to the configuration structure will apply the new values on
615 * the next interface up (wl1271_op_start.)
618 /* apply driver default configuration */
619 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
623 static int wl1271_plt_init(struct wl1271 *wl)
625 struct conf_tx_ac_category *conf_ac;
626 struct conf_tx_tid *conf_tid;
629 if (wl->chip.id == CHIP_ID_1283_PG20)
630 ret = wl128x_cmd_general_parms(wl);
632 ret = wl1271_cmd_general_parms(wl);
636 if (wl->chip.id == CHIP_ID_1283_PG20)
637 ret = wl128x_cmd_radio_parms(wl);
639 ret = wl1271_cmd_radio_parms(wl);
643 if (wl->chip.id != CHIP_ID_1283_PG20) {
644 ret = wl1271_cmd_ext_radio_parms(wl);
651 /* Chip-specific initializations */
652 ret = wl1271_chip_specific_init(wl);
656 ret = wl1271_sta_init_templates_config(wl);
660 ret = wl1271_acx_init_mem_config(wl);
664 /* PHY layer config */
665 ret = wl1271_init_phy_config(wl);
667 goto out_free_memmap;
669 ret = wl1271_acx_dco_itrim_params(wl);
671 goto out_free_memmap;
673 /* Initialize connection monitoring thresholds */
674 ret = wl1271_acx_conn_monit_params(wl, false);
676 goto out_free_memmap;
678 /* Bluetooth WLAN coexistence */
679 ret = wl1271_init_pta(wl);
681 goto out_free_memmap;
683 /* FM WLAN coexistence */
684 ret = wl1271_acx_fm_coex(wl);
686 goto out_free_memmap;
688 /* Energy detection */
689 ret = wl1271_init_energy_detection(wl);
691 goto out_free_memmap;
693 ret = wl1271_acx_sta_mem_cfg(wl);
695 goto out_free_memmap;
697 /* Default fragmentation threshold */
698 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
700 goto out_free_memmap;
702 /* Default TID/AC configuration */
703 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
704 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
705 conf_ac = &wl->conf.tx.ac_conf[i];
706 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
707 conf_ac->cw_max, conf_ac->aifsn,
708 conf_ac->tx_op_limit);
710 goto out_free_memmap;
712 conf_tid = &wl->conf.tx.tid_conf[i];
713 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
714 conf_tid->channel_type,
717 conf_tid->ack_policy,
718 conf_tid->apsd_conf[0],
719 conf_tid->apsd_conf[1]);
721 goto out_free_memmap;
724 /* Enable data path */
725 ret = wl1271_cmd_data_path(wl, 1);
727 goto out_free_memmap;
729 /* Configure for CAM power saving (ie. always active) */
730 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
732 goto out_free_memmap;
735 ret = wl1271_acx_pm_config(wl);
737 goto out_free_memmap;
742 kfree(wl->target_mem_map);
743 wl->target_mem_map = NULL;
748 static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks)
752 /* only regulate station links */
753 if (hlid < WL1271_AP_STA_HLID_START)
756 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
759 * Wake up from high level PS if the STA is asleep with too little
760 * blocks in FW or if the STA is awake.
762 if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS)
763 wl1271_ps_link_end(wl, hlid);
765 /* Start high-level PS if the STA is asleep with enough blocks in FW */
766 else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
767 wl1271_ps_link_start(wl, hlid, true);
770 static void wl1271_irq_update_links_status(struct wl1271 *wl,
771 struct wl1271_fw_ap_status *status)
776 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
777 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
778 wl1271_debug(DEBUG_PSM,
779 "link ps prev 0x%x cur 0x%x changed 0x%x",
780 wl->ap_fw_ps_map, cur_fw_ps_map,
781 wl->ap_fw_ps_map ^ cur_fw_ps_map);
783 wl->ap_fw_ps_map = cur_fw_ps_map;
786 for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
787 u8 cnt = status->tx_lnk_free_blks[hlid] -
788 wl->links[hlid].prev_freed_blks;
790 wl->links[hlid].prev_freed_blks =
791 status->tx_lnk_free_blks[hlid];
792 wl->links[hlid].allocated_blks -= cnt;
794 wl1271_irq_ps_regulate_link(wl, hlid,
795 wl->links[hlid].allocated_blks);
799 static void wl1271_fw_status(struct wl1271 *wl,
800 struct wl1271_fw_full_status *full_status)
802 struct wl1271_fw_common_status *status = &full_status->common;
804 u32 old_tx_blk_count = wl->tx_blocks_available;
805 u32 freed_blocks = 0;
808 if (wl->bss_type == BSS_TYPE_AP_BSS) {
809 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
810 sizeof(struct wl1271_fw_ap_status), false);
812 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
813 sizeof(struct wl1271_fw_sta_status), false);
816 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
817 "drv_rx_counter = %d, tx_results_counter = %d)",
819 status->fw_rx_counter,
820 status->drv_rx_counter,
821 status->tx_results_counter);
823 /* update number of available TX blocks */
824 for (i = 0; i < NUM_TX_QUEUES; i++) {
825 freed_blocks += le32_to_cpu(status->tx_released_blks[i]) -
826 wl->tx_blocks_freed[i];
828 wl->tx_blocks_freed[i] =
829 le32_to_cpu(status->tx_released_blks[i]);
832 wl->tx_allocated_blocks -= freed_blocks;
834 if (wl->bss_type == BSS_TYPE_AP_BSS) {
835 /* Update num of allocated TX blocks per link and ps status */
836 wl1271_irq_update_links_status(wl, &full_status->ap);
837 wl->tx_blocks_available += freed_blocks;
839 int avail = full_status->sta.tx_total - wl->tx_allocated_blocks;
842 * The FW might change the total number of TX memblocks before
843 * we get a notification about blocks being released. Thus, the
844 * available blocks calculation might yield a temporary result
845 * which is lower than the actual available blocks. Keeping in
846 * mind that only blocks that were allocated can be moved from
847 * TX to RX, tx_blocks_available should never decrease here.
849 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
853 /* if more blocks are available now, tx work can be scheduled */
854 if (wl->tx_blocks_available > old_tx_blk_count)
855 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
857 /* update the host-chipset time offset */
859 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
860 (s64)le32_to_cpu(status->fw_localtime);
863 static void wl1271_flush_deferred_work(struct wl1271 *wl)
867 /* Pass all received frames to the network stack */
868 while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
869 ieee80211_rx_ni(wl->hw, skb);
871 /* Return sent skbs to the network stack */
872 while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
873 ieee80211_tx_status_ni(wl->hw, skb);
876 static void wl1271_netstack_work(struct work_struct *work)
879 container_of(work, struct wl1271, netstack_work);
882 wl1271_flush_deferred_work(wl);
883 } while (skb_queue_len(&wl->deferred_rx_queue));
886 #define WL1271_IRQ_MAX_LOOPS 256
888 irqreturn_t wl1271_irq(int irq, void *cookie)
892 int loopcount = WL1271_IRQ_MAX_LOOPS;
893 struct wl1271 *wl = (struct wl1271 *)cookie;
895 unsigned int defer_count;
898 /* TX might be handled here, avoid redundant work */
899 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
900 cancel_work_sync(&wl->tx_work);
903 * In case edge triggered interrupt must be used, we cannot iterate
904 * more than once without introducing race conditions with the hardirq.
906 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
909 mutex_lock(&wl->mutex);
911 wl1271_debug(DEBUG_IRQ, "IRQ work");
913 if (unlikely(wl->state == WL1271_STATE_OFF))
916 ret = wl1271_ps_elp_wakeup(wl);
920 while (!done && loopcount--) {
922 * In order to avoid a race with the hardirq, clear the flag
923 * before acknowledging the chip. Since the mutex is held,
924 * wl1271_ps_elp_wakeup cannot be called concurrently.
926 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
927 smp_mb__after_clear_bit();
929 wl1271_fw_status(wl, wl->fw_status);
930 intr = le32_to_cpu(wl->fw_status->common.intr);
931 intr &= WL1271_INTR_MASK;
937 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
938 wl1271_error("watchdog interrupt received! "
939 "starting recovery.");
940 ieee80211_queue_work(wl->hw, &wl->recovery_work);
942 /* restarting the chip. ignore any other interrupt. */
946 if (likely(intr & WL1271_ACX_INTR_DATA)) {
947 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
949 wl1271_rx(wl, &wl->fw_status->common);
951 /* Check if any tx blocks were freed */
952 spin_lock_irqsave(&wl->wl_lock, flags);
953 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
954 wl->tx_queue_count) {
955 spin_unlock_irqrestore(&wl->wl_lock, flags);
957 * In order to avoid starvation of the TX path,
958 * call the work function directly.
960 wl1271_tx_work_locked(wl);
962 spin_unlock_irqrestore(&wl->wl_lock, flags);
965 /* check for tx results */
966 if (wl->fw_status->common.tx_results_counter !=
967 (wl->tx_results_count & 0xff))
968 wl1271_tx_complete(wl);
970 /* Make sure the deferred queues don't get too long */
971 defer_count = skb_queue_len(&wl->deferred_tx_queue) +
972 skb_queue_len(&wl->deferred_rx_queue);
973 if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
974 wl1271_flush_deferred_work(wl);
977 if (intr & WL1271_ACX_INTR_EVENT_A) {
978 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
979 wl1271_event_handle(wl, 0);
982 if (intr & WL1271_ACX_INTR_EVENT_B) {
983 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
984 wl1271_event_handle(wl, 1);
987 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
988 wl1271_debug(DEBUG_IRQ,
989 "WL1271_ACX_INTR_INIT_COMPLETE");
991 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
992 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
995 wl1271_ps_elp_sleep(wl);
998 spin_lock_irqsave(&wl->wl_lock, flags);
999 /* In case TX was not handled here, queue TX work */
1000 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
1001 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1003 ieee80211_queue_work(wl->hw, &wl->tx_work);
1004 spin_unlock_irqrestore(&wl->wl_lock, flags);
1006 mutex_unlock(&wl->mutex);
1010 EXPORT_SYMBOL_GPL(wl1271_irq);
1012 static int wl1271_fetch_firmware(struct wl1271 *wl)
1014 const struct firmware *fw;
1015 const char *fw_name;
1018 switch (wl->bss_type) {
1019 case BSS_TYPE_AP_BSS:
1020 if (wl->chip.id == CHIP_ID_1283_PG20)
1021 fw_name = WL128X_AP_FW_NAME;
1023 fw_name = WL127X_AP_FW_NAME;
1026 case BSS_TYPE_STA_BSS:
1027 if (wl->chip.id == CHIP_ID_1283_PG20)
1028 fw_name = WL128X_FW_NAME;
1030 fw_name = WL1271_FW_NAME;
1033 wl1271_error("no compatible firmware for bss_type %d",
1038 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
1040 ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
1043 wl1271_error("could not get firmware: %d", ret);
1048 wl1271_error("firmware size is not multiple of 32 bits: %zu",
1055 wl->fw_len = fw->size;
1056 wl->fw = vmalloc(wl->fw_len);
1059 wl1271_error("could not allocate memory for the firmware");
1064 memcpy(wl->fw, fw->data, wl->fw_len);
1065 wl->fw_bss_type = wl->bss_type;
1069 release_firmware(fw);
1074 static int wl1271_fetch_nvs(struct wl1271 *wl)
1076 const struct firmware *fw;
1079 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
1082 wl1271_error("could not get nvs file: %d", ret);
1086 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
1089 wl1271_error("could not allocate memory for the nvs file");
1094 wl->nvs_len = fw->size;
1097 release_firmware(fw);
1102 static void wl1271_recovery_work(struct work_struct *work)
1105 container_of(work, struct wl1271, recovery_work);
1107 mutex_lock(&wl->mutex);
1109 if (wl->state != WL1271_STATE_ON)
1112 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
1113 wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
1115 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1116 ieee80211_connection_loss(wl->vif);
1118 /* Prevent spurious TX during FW restart */
1119 ieee80211_stop_queues(wl->hw);
1121 if (wl->sched_scanning) {
1122 ieee80211_sched_scan_stopped(wl->hw);
1123 wl->sched_scanning = false;
1126 /* reboot the chipset */
1127 __wl1271_op_remove_interface(wl, false);
1128 ieee80211_restart_hw(wl->hw);
1131 * Its safe to enable TX now - the queues are stopped after a request
1132 * to restart the HW.
1134 ieee80211_wake_queues(wl->hw);
1137 mutex_unlock(&wl->mutex);
1140 static void wl1271_fw_wakeup(struct wl1271 *wl)
1144 elp_reg = ELPCTRL_WAKE_UP;
1145 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
1148 static int wl1271_setup(struct wl1271 *wl)
1150 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
1154 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1155 if (!wl->tx_res_if) {
1156 kfree(wl->fw_status);
1163 static int wl1271_chip_wakeup(struct wl1271 *wl)
1165 struct wl1271_partition_set partition;
1168 msleep(WL1271_PRE_POWER_ON_SLEEP);
1169 ret = wl1271_power_on(wl);
1172 msleep(WL1271_POWER_ON_SLEEP);
1173 wl1271_io_reset(wl);
1176 /* We don't need a real memory partition here, because we only want
1177 * to use the registers at this point. */
1178 memset(&partition, 0, sizeof(partition));
1179 partition.reg.start = REGISTERS_BASE;
1180 partition.reg.size = REGISTERS_DOWN_SIZE;
1181 wl1271_set_partition(wl, &partition);
1183 /* ELP module wake up */
1184 wl1271_fw_wakeup(wl);
1186 /* whal_FwCtrl_BootSm() */
1188 /* 0. read chip id from CHIP_ID */
1189 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
1191 /* 1. check if chip id is valid */
1193 switch (wl->chip.id) {
1194 case CHIP_ID_1271_PG10:
1195 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1198 ret = wl1271_setup(wl);
1202 case CHIP_ID_1271_PG20:
1203 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1207 * 'end-of-transaction flag' and 'LPD mode flag'
1208 * should be set in wl127x AP mode only
1210 if (wl->bss_type == BSS_TYPE_AP_BSS)
1211 wl->quirks |= (WL12XX_QUIRK_END_OF_TRANSACTION |
1212 WL12XX_QUIRK_LPD_MODE);
1214 ret = wl1271_setup(wl);
1218 case CHIP_ID_1283_PG20:
1219 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1222 ret = wl1271_setup(wl);
1226 if (wl1271_set_block_size(wl))
1227 wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
1229 case CHIP_ID_1283_PG10:
1231 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
1236 /* Make sure the firmware type matches the BSS type */
1237 if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
1238 ret = wl1271_fetch_firmware(wl);
1243 /* No NVS from netlink, try to get it from the filesystem */
1244 if (wl->nvs == NULL) {
1245 ret = wl1271_fetch_nvs(wl);
1254 static unsigned int wl1271_get_fw_ver_quirks(struct wl1271 *wl)
1256 unsigned int quirks = 0;
1257 unsigned int *fw_ver = wl->chip.fw_ver;
1259 /* Only for wl127x */
1260 if ((fw_ver[FW_VER_CHIP] == FW_VER_CHIP_WL127X) &&
1261 /* Check STA version */
1262 (((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_STA) &&
1263 (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_STA_MIN)) ||
1264 /* Check AP version */
1265 ((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_AP) &&
1266 (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_AP_MIN))))
1267 quirks |= WL12XX_QUIRK_USE_2_SPARE_BLOCKS;
1272 int wl1271_plt_start(struct wl1271 *wl)
1274 int retries = WL1271_BOOT_RETRIES;
1277 mutex_lock(&wl->mutex);
1279 wl1271_notice("power up");
1281 if (wl->state != WL1271_STATE_OFF) {
1282 wl1271_error("cannot go into PLT state because not "
1283 "in off state: %d", wl->state);
1288 wl->bss_type = BSS_TYPE_STA_BSS;
1292 ret = wl1271_chip_wakeup(wl);
1296 ret = wl1271_boot(wl);
1300 ret = wl1271_plt_init(wl);
1304 wl->state = WL1271_STATE_PLT;
1305 wl1271_notice("firmware booted in PLT mode (%s)",
1306 wl->chip.fw_ver_str);
1308 /* Check if any quirks are needed with older fw versions */
1309 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1313 mutex_unlock(&wl->mutex);
1314 /* Unlocking the mutex in the middle of handling is
1315 inherently unsafe. In this case we deem it safe to do,
1316 because we need to let any possibly pending IRQ out of
1317 the system (and while we are WL1271_STATE_OFF the IRQ
1318 work function will not do anything.) Also, any other
1319 possible concurrent operations will fail due to the
1320 current state, hence the wl1271 struct should be safe. */
1321 wl1271_disable_interrupts(wl);
1322 wl1271_flush_deferred_work(wl);
1323 cancel_work_sync(&wl->netstack_work);
1324 mutex_lock(&wl->mutex);
1326 wl1271_power_off(wl);
1329 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1330 WL1271_BOOT_RETRIES);
1332 mutex_unlock(&wl->mutex);
1337 static int __wl1271_plt_stop(struct wl1271 *wl)
1341 wl1271_notice("power down");
1343 if (wl->state != WL1271_STATE_PLT) {
1344 wl1271_error("cannot power down because not in PLT "
1345 "state: %d", wl->state);
1350 wl1271_power_off(wl);
1352 wl->state = WL1271_STATE_OFF;
1355 mutex_unlock(&wl->mutex);
1356 wl1271_disable_interrupts(wl);
1357 wl1271_flush_deferred_work(wl);
1358 cancel_work_sync(&wl->netstack_work);
1359 cancel_work_sync(&wl->recovery_work);
1360 mutex_lock(&wl->mutex);
1365 int wl1271_plt_stop(struct wl1271 *wl)
1369 mutex_lock(&wl->mutex);
1370 ret = __wl1271_plt_stop(wl);
1371 mutex_unlock(&wl->mutex);
1375 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1377 struct wl1271 *wl = hw->priv;
1378 unsigned long flags;
1382 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
1384 if (wl->bss_type == BSS_TYPE_AP_BSS)
1385 hlid = wl1271_tx_get_hlid(skb);
1387 spin_lock_irqsave(&wl->wl_lock, flags);
1389 wl->tx_queue_count++;
1392 * The workqueue is slow to process the tx_queue and we need stop
1393 * the queue here, otherwise the queue will get too long.
1395 if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1396 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
1397 ieee80211_stop_queues(wl->hw);
1398 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
1401 /* queue the packet */
1402 if (wl->bss_type == BSS_TYPE_AP_BSS) {
1403 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1404 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1406 skb_queue_tail(&wl->tx_queue[q], skb);
1410 * The chip specific setup must run before the first TX packet -
1411 * before that, the tx_work will not be initialized!
1414 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1415 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1416 ieee80211_queue_work(wl->hw, &wl->tx_work);
1418 spin_unlock_irqrestore(&wl->wl_lock, flags);
1421 int wl1271_tx_dummy_packet(struct wl1271 *wl)
1423 unsigned long flags;
1425 spin_lock_irqsave(&wl->wl_lock, flags);
1426 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1427 wl->tx_queue_count++;
1428 spin_unlock_irqrestore(&wl->wl_lock, flags);
1430 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1431 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1432 wl1271_tx_work_locked(wl);
1435 * If the FW TX is busy, TX work will be scheduled by the threaded
1436 * interrupt handler function
1442 * The size of the dummy packet should be at least 1400 bytes. However, in
1443 * order to minimize the number of bus transactions, aligning it to 512 bytes
1444 * boundaries could be beneficial, performance wise
1446 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1448 static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1450 struct sk_buff *skb;
1451 struct ieee80211_hdr_3addr *hdr;
1452 unsigned int dummy_packet_size;
1454 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1455 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1457 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1459 wl1271_warning("Failed to allocate a dummy packet skb");
1463 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1465 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1466 memset(hdr, 0, sizeof(*hdr));
1467 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1468 IEEE80211_STYPE_NULLFUNC |
1469 IEEE80211_FCTL_TODS);
1471 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1473 /* Dummy packets require the TID to be management */
1474 skb->priority = WL1271_TID_MGMT;
1476 /* Initialize all fields that might be used */
1477 skb_set_queue_mapping(skb, 0);
1478 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1484 static struct notifier_block wl1271_dev_notifier = {
1485 .notifier_call = wl1271_dev_notify,
1489 static int wl1271_configure_suspend_sta(struct wl1271 *wl)
1493 mutex_lock(&wl->mutex);
1495 ret = wl1271_ps_elp_wakeup(wl);
1499 /* enter psm if needed*/
1500 if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1501 DECLARE_COMPLETION_ONSTACK(compl);
1503 wl->ps_compl = &compl;
1504 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1505 wl->basic_rate, true);
1509 /* we must unlock here so we will be able to get events */
1510 wl1271_ps_elp_sleep(wl);
1511 mutex_unlock(&wl->mutex);
1513 ret = wait_for_completion_timeout(
1514 &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT));
1516 wl1271_warning("couldn't enter ps mode!");
1521 /* take mutex again, and wakeup */
1522 mutex_lock(&wl->mutex);
1524 ret = wl1271_ps_elp_wakeup(wl);
1529 wl1271_ps_elp_sleep(wl);
1531 mutex_unlock(&wl->mutex);
1537 static int wl1271_configure_suspend_ap(struct wl1271 *wl)
1541 mutex_lock(&wl->mutex);
1543 ret = wl1271_ps_elp_wakeup(wl);
1547 ret = wl1271_acx_set_ap_beacon_filter(wl, true);
1549 wl1271_ps_elp_sleep(wl);
1551 mutex_unlock(&wl->mutex);
1556 static int wl1271_configure_suspend(struct wl1271 *wl)
1558 if (wl->bss_type == BSS_TYPE_STA_BSS)
1559 return wl1271_configure_suspend_sta(wl);
1560 if (wl->bss_type == BSS_TYPE_AP_BSS)
1561 return wl1271_configure_suspend_ap(wl);
1565 static void wl1271_configure_resume(struct wl1271 *wl)
1568 bool is_sta = wl->bss_type == BSS_TYPE_STA_BSS;
1569 bool is_ap = wl->bss_type == BSS_TYPE_AP_BSS;
1571 if (!is_sta && !is_ap)
1574 mutex_lock(&wl->mutex);
1575 ret = wl1271_ps_elp_wakeup(wl);
1580 /* exit psm if it wasn't configured */
1581 if (!test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags))
1582 wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1583 wl->basic_rate, true);
1585 wl1271_acx_set_ap_beacon_filter(wl, false);
1588 wl1271_ps_elp_sleep(wl);
1590 mutex_unlock(&wl->mutex);
1593 static int wl1271_op_suspend(struct ieee80211_hw *hw,
1594 struct cfg80211_wowlan *wow)
1596 struct wl1271 *wl = hw->priv;
1599 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1600 WARN_ON(!wow || !wow->any);
1602 wl->wow_enabled = true;
1603 ret = wl1271_configure_suspend(wl);
1605 wl1271_warning("couldn't prepare device to suspend");
1608 /* flush any remaining work */
1609 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1610 flush_delayed_work(&wl->scan_complete_work);
1613 * disable and re-enable interrupts in order to flush
1616 wl1271_disable_interrupts(wl);
1619 * set suspended flag to avoid triggering a new threaded_irq
1620 * work. no need for spinlock as interrupts are disabled.
1622 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1624 wl1271_enable_interrupts(wl);
1625 flush_work(&wl->tx_work);
1626 flush_delayed_work(&wl->pspoll_work);
1627 flush_delayed_work(&wl->elp_work);
1632 static int wl1271_op_resume(struct ieee80211_hw *hw)
1634 struct wl1271 *wl = hw->priv;
1635 unsigned long flags;
1636 bool run_irq_work = false;
1638 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1640 WARN_ON(!wl->wow_enabled);
1643 * re-enable irq_work enqueuing, and call irq_work directly if
1644 * there is a pending work.
1646 spin_lock_irqsave(&wl->wl_lock, flags);
1647 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1648 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1649 run_irq_work = true;
1650 spin_unlock_irqrestore(&wl->wl_lock, flags);
1653 wl1271_debug(DEBUG_MAC80211,
1654 "run postponed irq_work directly");
1656 wl1271_enable_interrupts(wl);
1658 wl1271_configure_resume(wl);
1659 wl->wow_enabled = false;
1665 static int wl1271_op_start(struct ieee80211_hw *hw)
1667 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1670 * We have to delay the booting of the hardware because
1671 * we need to know the local MAC address before downloading and
1672 * initializing the firmware. The MAC address cannot be changed
1673 * after boot, and without the proper MAC address, the firmware
1674 * will not function properly.
1676 * The MAC address is first known when the corresponding interface
1677 * is added. That is where we will initialize the hardware.
1679 * In addition, we currently have different firmwares for AP and managed
1680 * operation. We will know which to boot according to interface type.
1686 static void wl1271_op_stop(struct ieee80211_hw *hw)
1688 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1691 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1692 struct ieee80211_vif *vif)
1694 struct wl1271 *wl = hw->priv;
1695 struct wiphy *wiphy = hw->wiphy;
1696 int retries = WL1271_BOOT_RETRIES;
1698 bool booted = false;
1700 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1701 vif->type, vif->addr);
1703 mutex_lock(&wl->mutex);
1705 wl1271_debug(DEBUG_MAC80211,
1706 "multiple vifs are not supported yet");
1712 * in some very corner case HW recovery scenarios its possible to
1713 * get here before __wl1271_op_remove_interface is complete, so
1714 * opt out if that is the case.
1716 if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1721 switch (vif->type) {
1722 case NL80211_IFTYPE_STATION:
1723 wl->bss_type = BSS_TYPE_STA_BSS;
1724 wl->set_bss_type = BSS_TYPE_STA_BSS;
1726 case NL80211_IFTYPE_ADHOC:
1727 wl->bss_type = BSS_TYPE_IBSS;
1728 wl->set_bss_type = BSS_TYPE_STA_BSS;
1730 case NL80211_IFTYPE_AP:
1731 wl->bss_type = BSS_TYPE_AP_BSS;
1738 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1740 if (wl->state != WL1271_STATE_OFF) {
1741 wl1271_error("cannot start because not in off state: %d",
1749 ret = wl1271_chip_wakeup(wl);
1753 ret = wl1271_boot(wl);
1757 ret = wl1271_hw_init(wl);
1765 mutex_unlock(&wl->mutex);
1766 /* Unlocking the mutex in the middle of handling is
1767 inherently unsafe. In this case we deem it safe to do,
1768 because we need to let any possibly pending IRQ out of
1769 the system (and while we are WL1271_STATE_OFF the IRQ
1770 work function will not do anything.) Also, any other
1771 possible concurrent operations will fail due to the
1772 current state, hence the wl1271 struct should be safe. */
1773 wl1271_disable_interrupts(wl);
1774 wl1271_flush_deferred_work(wl);
1775 cancel_work_sync(&wl->netstack_work);
1776 mutex_lock(&wl->mutex);
1778 wl1271_power_off(wl);
1782 wl1271_error("firmware boot failed despite %d retries",
1783 WL1271_BOOT_RETRIES);
1788 wl->state = WL1271_STATE_ON;
1789 set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
1790 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1792 /* update hw/fw version info in wiphy struct */
1793 wiphy->hw_version = wl->chip.id;
1794 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1795 sizeof(wiphy->fw_version));
1797 /* Check if any quirks are needed with older fw versions */
1798 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1801 * Now we know if 11a is supported (info from the NVS), so disable
1802 * 11a channels if not supported
1804 if (!wl->enable_11a)
1805 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1807 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1808 wl->enable_11a ? "" : "not ");
1811 mutex_unlock(&wl->mutex);
1813 mutex_lock(&wl_list_mutex);
1815 list_add(&wl->list, &wl_list);
1816 mutex_unlock(&wl_list_mutex);
1821 static void __wl1271_op_remove_interface(struct wl1271 *wl,
1822 bool reset_tx_queues)
1826 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1828 /* because of hardware recovery, we may get here twice */
1829 if (wl->state != WL1271_STATE_ON)
1832 wl1271_info("down");
1834 mutex_lock(&wl_list_mutex);
1835 list_del(&wl->list);
1836 mutex_unlock(&wl_list_mutex);
1838 /* enable dyn ps just in case (if left on due to fw crash etc) */
1839 if (wl->bss_type == BSS_TYPE_STA_BSS)
1840 ieee80211_enable_dyn_ps(wl->vif);
1842 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1843 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1844 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
1845 wl->scan.req = NULL;
1846 ieee80211_scan_completed(wl->hw, true);
1850 * this must be before the cancel_work calls below, so that the work
1851 * functions don't perform further work.
1853 wl->state = WL1271_STATE_OFF;
1855 mutex_unlock(&wl->mutex);
1857 wl1271_disable_interrupts(wl);
1858 wl1271_flush_deferred_work(wl);
1859 cancel_delayed_work_sync(&wl->scan_complete_work);
1860 cancel_work_sync(&wl->netstack_work);
1861 cancel_work_sync(&wl->tx_work);
1862 del_timer_sync(&wl->rx_streaming_timer);
1863 cancel_work_sync(&wl->rx_streaming_enable_work);
1864 cancel_work_sync(&wl->rx_streaming_disable_work);
1865 cancel_delayed_work_sync(&wl->pspoll_work);
1866 cancel_delayed_work_sync(&wl->elp_work);
1868 mutex_lock(&wl->mutex);
1870 /* let's notify MAC80211 about the remaining pending TX frames */
1871 wl1271_tx_reset(wl, reset_tx_queues);
1872 wl1271_power_off(wl);
1874 memset(wl->bssid, 0, ETH_ALEN);
1875 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1877 wl->bss_type = MAX_BSS_TYPE;
1878 wl->set_bss_type = MAX_BSS_TYPE;
1879 wl->band = IEEE80211_BAND_2GHZ;
1882 wl->psm_entry_retry = 0;
1883 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1884 wl->tx_blocks_available = 0;
1885 wl->tx_allocated_blocks = 0;
1886 wl->tx_results_count = 0;
1887 wl->tx_packets_count = 0;
1888 wl->tx_security_last_seq = 0;
1889 wl->tx_security_seq = 0;
1890 wl->time_offset = 0;
1891 wl->session_counter = 0;
1892 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1895 wl1271_free_ap_keys(wl);
1896 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
1897 wl->ap_fw_ps_map = 0;
1899 wl->sched_scanning = false;
1902 * this is performed after the cancel_work calls and the associated
1903 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1904 * get executed before all these vars have been reset.
1908 for (i = 0; i < NUM_TX_QUEUES; i++)
1909 wl->tx_blocks_freed[i] = 0;
1911 wl1271_debugfs_reset(wl);
1913 kfree(wl->fw_status);
1914 wl->fw_status = NULL;
1915 kfree(wl->tx_res_if);
1916 wl->tx_res_if = NULL;
1917 kfree(wl->target_mem_map);
1918 wl->target_mem_map = NULL;
1921 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1922 struct ieee80211_vif *vif)
1924 struct wl1271 *wl = hw->priv;
1926 mutex_lock(&wl->mutex);
1928 * wl->vif can be null here if someone shuts down the interface
1929 * just when hardware recovery has been started.
1932 WARN_ON(wl->vif != vif);
1933 __wl1271_op_remove_interface(wl, true);
1936 mutex_unlock(&wl->mutex);
1937 cancel_work_sync(&wl->recovery_work);
1940 void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1942 wl1271_set_default_filters(wl);
1944 /* combine requested filters with current filter config */
1945 filters = wl->filters | filters;
1947 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1949 if (filters & FIF_PROMISC_IN_BSS) {
1950 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1951 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1952 wl->rx_config |= CFG_BSSID_FILTER_EN;
1954 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1955 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1956 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1957 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1959 if (filters & FIF_OTHER_BSS) {
1960 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1961 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1963 if (filters & FIF_CONTROL) {
1964 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1965 wl->rx_filter |= CFG_RX_CTL_EN;
1967 if (filters & FIF_FCSFAIL) {
1968 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1969 wl->rx_filter |= CFG_RX_FCS_ERROR;
1973 static int wl1271_dummy_join(struct wl1271 *wl)
1976 /* we need to use a dummy BSSID for now */
1977 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1980 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1982 /* pass through frames from all BSS */
1983 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1985 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1989 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1995 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
2000 * One of the side effects of the JOIN command is that is clears
2001 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2002 * to a WPA/WPA2 access point will therefore kill the data-path.
2003 * Currently the only valid scenario for JOIN during association
2004 * is on roaming, in which case we will also be given new keys.
2005 * Keep the below message for now, unless it starts bothering
2006 * users who really like to roam a lot :)
2008 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2009 wl1271_info("JOIN while associated.");
2012 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2014 ret = wl1271_cmd_join(wl, wl->set_bss_type);
2018 set_bit(WL1271_FLAG_JOINED, &wl->flags);
2020 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2024 * The join command disable the keep-alive mode, shut down its process,
2025 * and also clear the template config, so we need to reset it all after
2026 * the join. The acx_aid starts the keep-alive process, and the order
2027 * of the commands below is relevant.
2029 ret = wl1271_acx_keep_alive_mode(wl, true);
2033 ret = wl1271_acx_aid(wl, wl->aid);
2037 ret = wl1271_cmd_build_klv_null_data(wl);
2041 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2042 ACX_KEEP_ALIVE_TPL_VALID);
2050 static int wl1271_unjoin(struct wl1271 *wl)
2054 /* to stop listening to a channel, we disconnect */
2055 ret = wl1271_cmd_disconnect(wl);
2059 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
2060 memset(wl->bssid, 0, ETH_ALEN);
2062 /* stop filtering packets based on bssid */
2063 wl1271_configure_filters(wl, FIF_OTHER_BSS);
2069 static void wl1271_set_band_rate(struct wl1271 *wl)
2071 if (wl->band == IEEE80211_BAND_2GHZ)
2072 wl->basic_rate_set = wl->conf.tx.basic_rate;
2074 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
2077 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
2082 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
2083 ret = wl1271_unjoin(wl);
2087 wl->rate_set = wl1271_tx_min_rate_get(wl);
2088 ret = wl1271_acx_sta_rate_policies(wl);
2091 ret = wl1271_acx_keep_alive_config(
2092 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2093 ACX_KEEP_ALIVE_TPL_INVALID);
2096 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2098 /* increment the session counter */
2099 wl->session_counter++;
2100 if (wl->session_counter >= SESSION_COUNTER_MAX)
2101 wl->session_counter = 0;
2103 /* The current firmware only supports sched_scan in idle */
2104 if (wl->sched_scanning) {
2105 wl1271_scan_sched_scan_stop(wl);
2106 ieee80211_sched_scan_stopped(wl->hw);
2109 ret = wl1271_dummy_join(wl);
2112 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2119 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2121 struct wl1271 *wl = hw->priv;
2122 struct ieee80211_conf *conf = &hw->conf;
2123 int channel, ret = 0;
2126 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2128 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2131 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
2133 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2137 * mac80211 will go to idle nearly immediately after transmitting some
2138 * frames, such as the deauth. To make sure those frames reach the air,
2139 * wait here until the TX queue is fully flushed.
2141 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2142 (conf->flags & IEEE80211_CONF_IDLE))
2143 wl1271_tx_flush(wl);
2145 mutex_lock(&wl->mutex);
2147 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2148 /* we support configuring the channel and band while off */
2149 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
2150 wl->band = conf->channel->band;
2151 wl->channel = channel;
2157 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2159 ret = wl1271_ps_elp_wakeup(wl);
2163 /* if the channel changes while joined, join again */
2164 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2165 ((wl->band != conf->channel->band) ||
2166 (wl->channel != channel))) {
2167 wl->band = conf->channel->band;
2168 wl->channel = channel;
2172 * FIXME: the mac80211 should really provide a fixed
2173 * rate to use here. for now, just use the smallest
2174 * possible rate for the band as a fixed rate for
2175 * association frames and other control messages.
2177 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2178 wl1271_set_band_rate(wl);
2180 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2181 ret = wl1271_acx_sta_rate_policies(wl);
2183 wl1271_warning("rate policy for channel "
2186 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
2187 ret = wl1271_join(wl, false);
2189 wl1271_warning("cmd join on channel "
2195 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2196 ret = wl1271_sta_handle_idle(wl,
2197 conf->flags & IEEE80211_CONF_IDLE);
2199 wl1271_warning("idle mode change failed %d", ret);
2203 * if mac80211 changes the PSM mode, make sure the mode is not
2204 * incorrectly changed after the pspoll failure active window.
2206 if (changed & IEEE80211_CONF_CHANGE_PS)
2207 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2209 if (conf->flags & IEEE80211_CONF_PS &&
2210 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2211 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2214 * We enter PSM only if we're already associated.
2215 * If we're not, we'll enter it when joining an SSID,
2216 * through the bss_info_changed() hook.
2218 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2219 wl1271_debug(DEBUG_PSM, "psm enabled");
2220 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
2221 wl->basic_rate, true);
2223 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
2224 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2225 wl1271_debug(DEBUG_PSM, "psm disabled");
2227 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2229 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
2230 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
2231 wl->basic_rate, true);
2234 if (conf->power_level != wl->power_level) {
2235 ret = wl1271_acx_tx_power(wl, conf->power_level);
2239 wl->power_level = conf->power_level;
2243 wl1271_ps_elp_sleep(wl);
2246 mutex_unlock(&wl->mutex);
2251 struct wl1271_filter_params {
2254 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2257 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2258 struct netdev_hw_addr_list *mc_list)
2260 struct wl1271_filter_params *fp;
2261 struct netdev_hw_addr *ha;
2262 struct wl1271 *wl = hw->priv;
2264 if (unlikely(wl->state == WL1271_STATE_OFF))
2267 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2269 wl1271_error("Out of memory setting filters.");
2273 /* update multicast filtering parameters */
2274 fp->mc_list_length = 0;
2275 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2276 fp->enabled = false;
2279 netdev_hw_addr_list_for_each(ha, mc_list) {
2280 memcpy(fp->mc_list[fp->mc_list_length],
2281 ha->addr, ETH_ALEN);
2282 fp->mc_list_length++;
2286 return (u64)(unsigned long)fp;
2289 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2292 FIF_BCN_PRBRESP_PROMISC | \
2296 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2297 unsigned int changed,
2298 unsigned int *total, u64 multicast)
2300 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2301 struct wl1271 *wl = hw->priv;
2304 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2305 " total %x", changed, *total);
2307 mutex_lock(&wl->mutex);
2309 *total &= WL1271_SUPPORTED_FILTERS;
2310 changed &= WL1271_SUPPORTED_FILTERS;
2312 if (unlikely(wl->state == WL1271_STATE_OFF))
2315 ret = wl1271_ps_elp_wakeup(wl);
2319 if (wl->bss_type != BSS_TYPE_AP_BSS) {
2320 if (*total & FIF_ALLMULTI)
2321 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2323 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2325 fp->mc_list_length);
2330 /* determine, whether supported filter values have changed */
2334 /* configure filters */
2335 wl->filters = *total;
2336 wl1271_configure_filters(wl, 0);
2338 /* apply configured filters */
2339 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
2344 wl1271_ps_elp_sleep(wl);
2347 mutex_unlock(&wl->mutex);
2351 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2352 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2355 struct wl1271_ap_key *ap_key;
2358 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2360 if (key_size > MAX_KEY_SIZE)
2364 * Find next free entry in ap_keys. Also check we are not replacing
2367 for (i = 0; i < MAX_NUM_KEYS; i++) {
2368 if (wl->recorded_ap_keys[i] == NULL)
2371 if (wl->recorded_ap_keys[i]->id == id) {
2372 wl1271_warning("trying to record key replacement");
2377 if (i == MAX_NUM_KEYS)
2380 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2385 ap_key->key_type = key_type;
2386 ap_key->key_size = key_size;
2387 memcpy(ap_key->key, key, key_size);
2388 ap_key->hlid = hlid;
2389 ap_key->tx_seq_32 = tx_seq_32;
2390 ap_key->tx_seq_16 = tx_seq_16;
2392 wl->recorded_ap_keys[i] = ap_key;
2396 static void wl1271_free_ap_keys(struct wl1271 *wl)
2400 for (i = 0; i < MAX_NUM_KEYS; i++) {
2401 kfree(wl->recorded_ap_keys[i]);
2402 wl->recorded_ap_keys[i] = NULL;
2406 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2409 struct wl1271_ap_key *key;
2410 bool wep_key_added = false;
2412 for (i = 0; i < MAX_NUM_KEYS; i++) {
2413 if (wl->recorded_ap_keys[i] == NULL)
2416 key = wl->recorded_ap_keys[i];
2417 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2418 key->id, key->key_type,
2419 key->key_size, key->key,
2420 key->hlid, key->tx_seq_32,
2425 if (key->key_type == KEY_WEP)
2426 wep_key_added = true;
2429 if (wep_key_added) {
2430 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
2436 wl1271_free_ap_keys(wl);
2440 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2441 u8 key_size, const u8 *key, u32 tx_seq_32,
2442 u16 tx_seq_16, struct ieee80211_sta *sta)
2445 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2448 struct wl1271_station *wl_sta;
2452 wl_sta = (struct wl1271_station *)sta->drv_priv;
2453 hlid = wl_sta->hlid;
2455 hlid = WL1271_AP_BROADCAST_HLID;
2458 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2460 * We do not support removing keys after AP shutdown.
2461 * Pretend we do to make mac80211 happy.
2463 if (action != KEY_ADD_OR_REPLACE)
2466 ret = wl1271_record_ap_key(wl, id,
2468 key, hlid, tx_seq_32,
2471 ret = wl1271_cmd_set_ap_key(wl, action,
2472 id, key_type, key_size,
2473 key, hlid, tx_seq_32,
2481 static const u8 bcast_addr[ETH_ALEN] = {
2482 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2485 addr = sta ? sta->addr : bcast_addr;
2487 if (is_zero_ether_addr(addr)) {
2488 /* We dont support TX only encryption */
2492 /* The wl1271 does not allow to remove unicast keys - they
2493 will be cleared automatically on next CMD_JOIN. Ignore the
2494 request silently, as we dont want the mac80211 to emit
2495 an error message. */
2496 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2499 ret = wl1271_cmd_set_sta_key(wl, action,
2500 id, key_type, key_size,
2501 key, addr, tx_seq_32,
2506 /* the default WEP key needs to be configured at least once */
2507 if (key_type == KEY_WEP) {
2508 ret = wl1271_cmd_set_sta_default_wep_key(wl,
2518 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2519 struct ieee80211_vif *vif,
2520 struct ieee80211_sta *sta,
2521 struct ieee80211_key_conf *key_conf)
2523 struct wl1271 *wl = hw->priv;
2529 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2531 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2532 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2533 key_conf->cipher, key_conf->keyidx,
2534 key_conf->keylen, key_conf->flags);
2535 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2537 mutex_lock(&wl->mutex);
2539 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2544 ret = wl1271_ps_elp_wakeup(wl);
2548 switch (key_conf->cipher) {
2549 case WLAN_CIPHER_SUITE_WEP40:
2550 case WLAN_CIPHER_SUITE_WEP104:
2553 key_conf->hw_key_idx = key_conf->keyidx;
2555 case WLAN_CIPHER_SUITE_TKIP:
2556 key_type = KEY_TKIP;
2558 key_conf->hw_key_idx = key_conf->keyidx;
2559 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2560 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2562 case WLAN_CIPHER_SUITE_CCMP:
2565 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2566 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2567 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2569 case WL1271_CIPHER_SUITE_GEM:
2571 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2572 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2575 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2583 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2584 key_conf->keyidx, key_type,
2585 key_conf->keylen, key_conf->key,
2586 tx_seq_32, tx_seq_16, sta);
2588 wl1271_error("Could not add or replace key");
2594 ret = wl1271_set_key(wl, KEY_REMOVE,
2595 key_conf->keyidx, key_type,
2596 key_conf->keylen, key_conf->key,
2599 wl1271_error("Could not remove key");
2605 wl1271_error("Unsupported key cmd 0x%x", cmd);
2611 wl1271_ps_elp_sleep(wl);
2614 mutex_unlock(&wl->mutex);
2619 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
2620 struct ieee80211_vif *vif,
2621 struct cfg80211_scan_request *req)
2623 struct wl1271 *wl = hw->priv;
2628 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2631 ssid = req->ssids[0].ssid;
2632 len = req->ssids[0].ssid_len;
2635 mutex_lock(&wl->mutex);
2637 if (wl->state == WL1271_STATE_OFF) {
2639 * We cannot return -EBUSY here because cfg80211 will expect
2640 * a call to ieee80211_scan_completed if we do - in this case
2641 * there won't be any call.
2647 ret = wl1271_ps_elp_wakeup(wl);
2651 ret = wl1271_scan(hw->priv, ssid, len, req);
2653 wl1271_ps_elp_sleep(wl);
2656 mutex_unlock(&wl->mutex);
2661 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2662 struct ieee80211_vif *vif,
2663 struct cfg80211_sched_scan_request *req,
2664 struct ieee80211_sched_scan_ies *ies)
2666 struct wl1271 *wl = hw->priv;
2669 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2671 mutex_lock(&wl->mutex);
2673 ret = wl1271_ps_elp_wakeup(wl);
2677 ret = wl1271_scan_sched_scan_config(wl, req, ies);
2681 ret = wl1271_scan_sched_scan_start(wl);
2685 wl->sched_scanning = true;
2688 wl1271_ps_elp_sleep(wl);
2690 mutex_unlock(&wl->mutex);
2694 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2695 struct ieee80211_vif *vif)
2697 struct wl1271 *wl = hw->priv;
2700 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2702 mutex_lock(&wl->mutex);
2704 ret = wl1271_ps_elp_wakeup(wl);
2708 wl1271_scan_sched_scan_stop(wl);
2710 wl1271_ps_elp_sleep(wl);
2712 mutex_unlock(&wl->mutex);
2715 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2717 struct wl1271 *wl = hw->priv;
2720 mutex_lock(&wl->mutex);
2722 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2727 ret = wl1271_ps_elp_wakeup(wl);
2731 ret = wl1271_acx_frag_threshold(wl, value);
2733 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2735 wl1271_ps_elp_sleep(wl);
2738 mutex_unlock(&wl->mutex);
2743 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2745 struct wl1271 *wl = hw->priv;
2748 mutex_lock(&wl->mutex);
2750 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2755 ret = wl1271_ps_elp_wakeup(wl);
2759 ret = wl1271_acx_rts_threshold(wl, value);
2761 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2763 wl1271_ps_elp_sleep(wl);
2766 mutex_unlock(&wl->mutex);
2771 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2775 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2779 wl1271_error("No SSID in IEs!");
2784 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2785 wl1271_error("SSID is too long!");
2789 wl->ssid_len = ssid_len;
2790 memcpy(wl->ssid, ptr+2, ssid_len);
2794 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
2795 struct ieee80211_bss_conf *bss_conf,
2800 if (changed & BSS_CHANGED_ERP_SLOT) {
2801 if (bss_conf->use_short_slot)
2802 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2804 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2806 wl1271_warning("Set slot time failed %d", ret);
2811 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2812 if (bss_conf->use_short_preamble)
2813 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2815 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2818 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2819 if (bss_conf->use_cts_prot)
2820 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2822 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2824 wl1271_warning("Set ctsprotect failed %d", ret);
2833 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2834 struct ieee80211_vif *vif,
2835 struct ieee80211_bss_conf *bss_conf,
2838 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2841 if ((changed & BSS_CHANGED_BEACON_INT)) {
2842 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
2843 bss_conf->beacon_int);
2845 wl->beacon_int = bss_conf->beacon_int;
2848 if ((changed & BSS_CHANGED_BEACON)) {
2849 struct ieee80211_hdr *hdr;
2850 int ieoffset = offsetof(struct ieee80211_mgmt,
2852 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2858 wl1271_debug(DEBUG_MASTER, "beacon updated");
2860 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2862 dev_kfree_skb(beacon);
2865 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2867 ret = wl1271_cmd_template_set(wl, tmpl_id,
2870 wl1271_tx_min_rate_get(wl));
2872 dev_kfree_skb(beacon);
2876 hdr = (struct ieee80211_hdr *) beacon->data;
2877 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2878 IEEE80211_STYPE_PROBE_RESP);
2880 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2881 CMD_TEMPL_PROBE_RESPONSE;
2882 ret = wl1271_cmd_template_set(wl,
2886 wl1271_tx_min_rate_get(wl));
2887 dev_kfree_skb(beacon);
2896 /* AP mode changes */
2897 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2898 struct ieee80211_vif *vif,
2899 struct ieee80211_bss_conf *bss_conf,
2904 if ((changed & BSS_CHANGED_BASIC_RATES)) {
2905 u32 rates = bss_conf->basic_rates;
2907 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2908 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2910 ret = wl1271_init_ap_rates(wl);
2912 wl1271_error("AP rate policy change failed %d", ret);
2916 ret = wl1271_ap_init_templates(wl);
2921 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2925 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2926 if (bss_conf->enable_beacon) {
2927 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2928 ret = wl1271_cmd_start_bss(wl);
2932 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2933 wl1271_debug(DEBUG_AP, "started AP");
2935 ret = wl1271_ap_init_hwenc(wl);
2940 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2941 ret = wl1271_cmd_stop_bss(wl);
2945 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2946 wl1271_debug(DEBUG_AP, "stopped AP");
2951 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2958 /* STA/IBSS mode changes */
2959 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2960 struct ieee80211_vif *vif,
2961 struct ieee80211_bss_conf *bss_conf,
2964 bool do_join = false, set_assoc = false;
2965 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2966 u32 sta_rate_set = 0;
2968 struct ieee80211_sta *sta;
2969 bool sta_exists = false;
2970 struct ieee80211_sta_ht_cap sta_ht_cap;
2973 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2979 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
2982 /* Need to update the SSID (for filtering etc) */
2983 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2986 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
2987 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2988 bss_conf->enable_beacon ? "enabled" : "disabled");
2990 if (bss_conf->enable_beacon)
2991 wl->set_bss_type = BSS_TYPE_IBSS;
2993 wl->set_bss_type = BSS_TYPE_STA_BSS;
2997 if ((changed & BSS_CHANGED_CQM)) {
2998 bool enable = false;
2999 if (bss_conf->cqm_rssi_thold)
3001 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
3002 bss_conf->cqm_rssi_thold,
3003 bss_conf->cqm_rssi_hyst);
3006 wl->rssi_thold = bss_conf->cqm_rssi_thold;
3009 if ((changed & BSS_CHANGED_BSSID) &&
3011 * Now we know the correct bssid, so we send a new join command
3012 * and enable the BSSID filter
3014 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
3015 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
3017 if (!is_zero_ether_addr(wl->bssid)) {
3018 ret = wl1271_cmd_build_null_data(wl);
3022 ret = wl1271_build_qos_null_data(wl);
3026 /* filter out all packets not from this BSSID */
3027 wl1271_configure_filters(wl, 0);
3029 /* Need to update the BSSID (for filtering etc) */
3035 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3037 /* save the supp_rates of the ap */
3038 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3039 if (sta->ht_cap.ht_supported)
3041 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
3042 sta_ht_cap = sta->ht_cap;
3048 /* handle new association with HT and HT information change */
3049 if ((changed & BSS_CHANGED_HT) &&
3050 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3051 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
3054 wl1271_warning("Set ht cap true failed %d",
3058 ret = wl1271_acx_set_ht_information(wl,
3059 bss_conf->ht_operation_mode);
3061 wl1271_warning("Set ht information failed %d",
3066 /* handle new association without HT and disassociation */
3067 else if (changed & BSS_CHANGED_ASSOC) {
3068 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
3071 wl1271_warning("Set ht cap false failed %d",
3078 if ((changed & BSS_CHANGED_ASSOC)) {
3079 if (bss_conf->assoc) {
3082 wl->aid = bss_conf->aid;
3085 wl->ps_poll_failures = 0;
3088 * use basic rates from AP, and determine lowest rate
3089 * to use with control frames.
3091 rates = bss_conf->basic_rates;
3092 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3094 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3096 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
3098 ret = wl1271_acx_sta_rate_policies(wl);
3103 * with wl1271, we don't need to update the
3104 * beacon_int and dtim_period, because the firmware
3105 * updates it by itself when the first beacon is
3106 * received after a join.
3108 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
3113 * Get a template for hardware connection maintenance
3115 dev_kfree_skb(wl->probereq);
3116 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
3117 ieoffset = offsetof(struct ieee80211_mgmt,
3118 u.probe_req.variable);
3119 wl1271_ssid_set(wl, wl->probereq, ieoffset);
3121 /* enable the connection monitoring feature */
3122 ret = wl1271_acx_conn_monit_params(wl, true);
3126 /* If we want to go in PSM but we're not there yet */
3127 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
3128 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
3129 enum wl1271_cmd_ps_mode mode;
3131 mode = STATION_POWER_SAVE_MODE;
3132 ret = wl1271_ps_set_mode(wl, mode,
3139 /* use defaults when not associated */
3141 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
3143 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
3146 /* free probe-request template */
3147 dev_kfree_skb(wl->probereq);
3148 wl->probereq = NULL;
3150 /* re-enable dynamic ps - just in case */
3151 ieee80211_enable_dyn_ps(wl->vif);
3153 /* revert back to minimum rates for the current band */
3154 wl1271_set_band_rate(wl);
3155 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3156 ret = wl1271_acx_sta_rate_policies(wl);
3160 /* disable connection monitor features */
3161 ret = wl1271_acx_conn_monit_params(wl, false);
3163 /* Disable the keep-alive feature */
3164 ret = wl1271_acx_keep_alive_mode(wl, false);
3168 /* restore the bssid filter and go to dummy bssid */
3171 wl1271_dummy_join(wl);
3176 if (changed & BSS_CHANGED_IBSS) {
3177 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3178 bss_conf->ibss_joined);
3180 if (bss_conf->ibss_joined) {
3181 u32 rates = bss_conf->basic_rates;
3182 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3184 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3186 /* by default, use 11b rates */
3187 wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3188 ret = wl1271_acx_sta_rate_policies(wl);
3194 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3198 if (changed & BSS_CHANGED_ARP_FILTER) {
3199 __be32 addr = bss_conf->arp_addr_list[0];
3200 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3202 if (bss_conf->arp_addr_cnt == 1 &&
3203 bss_conf->arp_filter_enabled) {
3205 * The template should have been configured only upon
3206 * association. however, it seems that the correct ip
3207 * isn't being set (when sending), so we have to
3208 * reconfigure the template upon every ip change.
3210 ret = wl1271_cmd_build_arp_rsp(wl, addr);
3212 wl1271_warning("build arp rsp failed: %d", ret);
3216 ret = wl1271_acx_arp_ip_filter(wl,
3217 ACX_ARP_FILTER_ARP_FILTERING,
3220 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
3227 ret = wl1271_join(wl, set_assoc);
3229 wl1271_warning("cmd join failed %d", ret);
3232 wl1271_check_operstate(wl, ieee80211_get_operstate(vif));
3239 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3240 struct ieee80211_vif *vif,
3241 struct ieee80211_bss_conf *bss_conf,
3244 struct wl1271 *wl = hw->priv;
3245 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3248 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3251 mutex_lock(&wl->mutex);
3253 if (unlikely(wl->state == WL1271_STATE_OFF))
3256 ret = wl1271_ps_elp_wakeup(wl);
3261 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3263 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3265 wl1271_ps_elp_sleep(wl);
3268 mutex_unlock(&wl->mutex);
3271 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3272 const struct ieee80211_tx_queue_params *params)
3274 struct wl1271 *wl = hw->priv;
3278 mutex_lock(&wl->mutex);
3280 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3283 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3285 ps_scheme = CONF_PS_SCHEME_LEGACY;
3287 if (wl->state == WL1271_STATE_OFF) {
3289 * If the state is off, the parameters will be recorded and
3290 * configured on init. This happens in AP-mode.
3292 struct conf_tx_ac_category *conf_ac =
3293 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3294 struct conf_tx_tid *conf_tid =
3295 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3297 conf_ac->ac = wl1271_tx_get_queue(queue);
3298 conf_ac->cw_min = (u8)params->cw_min;
3299 conf_ac->cw_max = params->cw_max;
3300 conf_ac->aifsn = params->aifs;
3301 conf_ac->tx_op_limit = params->txop << 5;
3303 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3304 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3305 conf_tid->tsid = wl1271_tx_get_queue(queue);
3306 conf_tid->ps_scheme = ps_scheme;
3307 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3308 conf_tid->apsd_conf[0] = 0;
3309 conf_tid->apsd_conf[1] = 0;
3313 ret = wl1271_ps_elp_wakeup(wl);
3318 * the txop is confed in units of 32us by the mac80211,
3321 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3322 params->cw_min, params->cw_max,
3323 params->aifs, params->txop << 5);
3327 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3328 CONF_CHANNEL_TYPE_EDCF,
3329 wl1271_tx_get_queue(queue),
3330 ps_scheme, CONF_ACK_POLICY_LEGACY,
3334 wl1271_ps_elp_sleep(wl);
3337 mutex_unlock(&wl->mutex);
3342 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3345 struct wl1271 *wl = hw->priv;
3346 u64 mactime = ULLONG_MAX;
3349 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3351 mutex_lock(&wl->mutex);
3353 if (unlikely(wl->state == WL1271_STATE_OFF))
3356 ret = wl1271_ps_elp_wakeup(wl);
3360 ret = wl1271_acx_tsf_info(wl, &mactime);
3365 wl1271_ps_elp_sleep(wl);
3368 mutex_unlock(&wl->mutex);
3372 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3373 struct survey_info *survey)
3375 struct wl1271 *wl = hw->priv;
3376 struct ieee80211_conf *conf = &hw->conf;
3381 survey->channel = conf->channel;
3382 survey->filled = SURVEY_INFO_NOISE_DBM;
3383 survey->noise = wl->noise;
3388 static int wl1271_allocate_sta(struct wl1271 *wl,
3389 struct ieee80211_sta *sta,
3392 struct wl1271_station *wl_sta;
3395 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3396 if (id >= AP_MAX_STATIONS) {
3397 wl1271_warning("could not allocate HLID - too much stations");
3401 wl_sta = (struct wl1271_station *)sta->drv_priv;
3402 __set_bit(id, wl->ap_hlid_map);
3403 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3404 *hlid = wl_sta->hlid;
3405 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
3409 static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
3411 int id = hlid - WL1271_AP_STA_HLID_START;
3413 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3416 __clear_bit(id, wl->ap_hlid_map);
3417 memset(wl->links[hlid].addr, 0, ETH_ALEN);
3418 wl1271_tx_reset_link_queues(wl, hlid);
3419 __clear_bit(hlid, &wl->ap_ps_map);
3420 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
3423 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3424 struct ieee80211_vif *vif,
3425 struct ieee80211_sta *sta)
3427 struct wl1271 *wl = hw->priv;
3431 mutex_lock(&wl->mutex);
3433 if (unlikely(wl->state == WL1271_STATE_OFF))
3436 if (wl->bss_type != BSS_TYPE_AP_BSS)
3439 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3441 ret = wl1271_allocate_sta(wl, sta, &hlid);
3445 ret = wl1271_ps_elp_wakeup(wl);
3449 ret = wl1271_cmd_add_sta(wl, sta, hlid);
3454 wl1271_ps_elp_sleep(wl);
3458 wl1271_free_sta(wl, hlid);
3461 mutex_unlock(&wl->mutex);
3465 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3466 struct ieee80211_vif *vif,
3467 struct ieee80211_sta *sta)
3469 struct wl1271 *wl = hw->priv;
3470 struct wl1271_station *wl_sta;
3473 mutex_lock(&wl->mutex);
3475 if (unlikely(wl->state == WL1271_STATE_OFF))
3478 if (wl->bss_type != BSS_TYPE_AP_BSS)
3481 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3483 wl_sta = (struct wl1271_station *)sta->drv_priv;
3484 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3485 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3488 ret = wl1271_ps_elp_wakeup(wl);
3492 ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
3496 wl1271_free_sta(wl, wl_sta->hlid);
3499 wl1271_ps_elp_sleep(wl);
3502 mutex_unlock(&wl->mutex);
3506 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3507 struct ieee80211_vif *vif,
3508 enum ieee80211_ampdu_mlme_action action,
3509 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3512 struct wl1271 *wl = hw->priv;
3515 mutex_lock(&wl->mutex);
3517 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3522 ret = wl1271_ps_elp_wakeup(wl);
3526 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
3530 case IEEE80211_AMPDU_RX_START:
3531 if ((wl->ba_support) && (wl->ba_allowed)) {
3532 ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
3535 wl->ba_rx_bitmap |= BIT(tid);
3541 case IEEE80211_AMPDU_RX_STOP:
3542 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
3544 wl->ba_rx_bitmap &= ~BIT(tid);
3548 * The BA initiator session management in FW independently.
3549 * Falling break here on purpose for all TX APDU commands.
3551 case IEEE80211_AMPDU_TX_START:
3552 case IEEE80211_AMPDU_TX_STOP:
3553 case IEEE80211_AMPDU_TX_OPERATIONAL:
3558 wl1271_error("Incorrect ampdu action id=%x\n", action);
3562 wl1271_ps_elp_sleep(wl);
3565 mutex_unlock(&wl->mutex);
3570 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3572 struct wl1271 *wl = hw->priv;
3575 mutex_lock(&wl->mutex);
3577 if (unlikely(wl->state == WL1271_STATE_OFF))
3580 /* packets are considered pending if in the TX queue or the FW */
3581 ret = (wl->tx_queue_count > 0) || (wl->tx_frames_cnt > 0);
3583 /* the above is appropriate for STA mode for PS purposes */
3584 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3587 mutex_unlock(&wl->mutex);
3592 /* can't be const, mac80211 writes to this */
3593 static struct ieee80211_rate wl1271_rates[] = {
3595 .hw_value = CONF_HW_BIT_RATE_1MBPS,
3596 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
3598 .hw_value = CONF_HW_BIT_RATE_2MBPS,
3599 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
3600 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3602 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3603 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
3604 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3606 .hw_value = CONF_HW_BIT_RATE_11MBPS,
3607 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
3608 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3610 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3611 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3613 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3614 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3616 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3617 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3619 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3620 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3622 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3623 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3625 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3626 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3628 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3629 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3631 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3632 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3635 /* can't be const, mac80211 writes to this */
3636 static struct ieee80211_channel wl1271_channels[] = {
3637 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
3638 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
3639 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3640 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3641 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
3642 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
3643 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3644 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3645 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
3646 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
3647 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3648 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3649 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
3650 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
3653 /* mapping to indexes for wl1271_rates */
3654 static const u8 wl1271_rate_to_idx_2ghz[] = {
3655 /* MCS rates are used only with 11n */
3656 7, /* CONF_HW_RXTX_RATE_MCS7 */
3657 6, /* CONF_HW_RXTX_RATE_MCS6 */
3658 5, /* CONF_HW_RXTX_RATE_MCS5 */
3659 4, /* CONF_HW_RXTX_RATE_MCS4 */
3660 3, /* CONF_HW_RXTX_RATE_MCS3 */
3661 2, /* CONF_HW_RXTX_RATE_MCS2 */
3662 1, /* CONF_HW_RXTX_RATE_MCS1 */
3663 0, /* CONF_HW_RXTX_RATE_MCS0 */
3665 11, /* CONF_HW_RXTX_RATE_54 */
3666 10, /* CONF_HW_RXTX_RATE_48 */
3667 9, /* CONF_HW_RXTX_RATE_36 */
3668 8, /* CONF_HW_RXTX_RATE_24 */
3670 /* TI-specific rate */
3671 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3673 7, /* CONF_HW_RXTX_RATE_18 */
3674 6, /* CONF_HW_RXTX_RATE_12 */
3675 3, /* CONF_HW_RXTX_RATE_11 */
3676 5, /* CONF_HW_RXTX_RATE_9 */
3677 4, /* CONF_HW_RXTX_RATE_6 */
3678 2, /* CONF_HW_RXTX_RATE_5_5 */
3679 1, /* CONF_HW_RXTX_RATE_2 */
3680 0 /* CONF_HW_RXTX_RATE_1 */
3683 /* 11n STA capabilities */
3684 #define HW_RX_HIGHEST_RATE 72
3686 #ifdef CONFIG_WL12XX_HT
3687 #define WL12XX_HT_CAP { \
3688 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3689 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
3690 .ht_supported = true, \
3691 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3692 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3694 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3695 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3696 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3700 #define WL12XX_HT_CAP { \
3701 .ht_supported = false, \
3705 /* can't be const, mac80211 writes to this */
3706 static struct ieee80211_supported_band wl1271_band_2ghz = {
3707 .channels = wl1271_channels,
3708 .n_channels = ARRAY_SIZE(wl1271_channels),
3709 .bitrates = wl1271_rates,
3710 .n_bitrates = ARRAY_SIZE(wl1271_rates),
3711 .ht_cap = WL12XX_HT_CAP,
3714 /* 5 GHz data rates for WL1273 */
3715 static struct ieee80211_rate wl1271_rates_5ghz[] = {
3717 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3718 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3720 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3721 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3723 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3724 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3726 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3727 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3729 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3730 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3732 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3733 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3735 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3736 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3738 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3739 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3742 /* 5 GHz band channels for WL1273 */
3743 static struct ieee80211_channel wl1271_channels_5ghz[] = {
3744 { .hw_value = 7, .center_freq = 5035},
3745 { .hw_value = 8, .center_freq = 5040},
3746 { .hw_value = 9, .center_freq = 5045},
3747 { .hw_value = 11, .center_freq = 5055},
3748 { .hw_value = 12, .center_freq = 5060},
3749 { .hw_value = 16, .center_freq = 5080},
3750 { .hw_value = 34, .center_freq = 5170},
3751 { .hw_value = 36, .center_freq = 5180},
3752 { .hw_value = 38, .center_freq = 5190},
3753 { .hw_value = 40, .center_freq = 5200},
3754 { .hw_value = 42, .center_freq = 5210},
3755 { .hw_value = 44, .center_freq = 5220},
3756 { .hw_value = 46, .center_freq = 5230},
3757 { .hw_value = 48, .center_freq = 5240},
3758 { .hw_value = 52, .center_freq = 5260},
3759 { .hw_value = 56, .center_freq = 5280},
3760 { .hw_value = 60, .center_freq = 5300},
3761 { .hw_value = 64, .center_freq = 5320},
3762 { .hw_value = 100, .center_freq = 5500},
3763 { .hw_value = 104, .center_freq = 5520},
3764 { .hw_value = 108, .center_freq = 5540},
3765 { .hw_value = 112, .center_freq = 5560},
3766 { .hw_value = 116, .center_freq = 5580},
3767 { .hw_value = 120, .center_freq = 5600},
3768 { .hw_value = 124, .center_freq = 5620},
3769 { .hw_value = 128, .center_freq = 5640},
3770 { .hw_value = 132, .center_freq = 5660},
3771 { .hw_value = 136, .center_freq = 5680},
3772 { .hw_value = 140, .center_freq = 5700},
3773 { .hw_value = 149, .center_freq = 5745},
3774 { .hw_value = 153, .center_freq = 5765},
3775 { .hw_value = 157, .center_freq = 5785},
3776 { .hw_value = 161, .center_freq = 5805},
3777 { .hw_value = 165, .center_freq = 5825},
3780 /* mapping to indexes for wl1271_rates_5ghz */
3781 static const u8 wl1271_rate_to_idx_5ghz[] = {
3782 /* MCS rates are used only with 11n */
3783 7, /* CONF_HW_RXTX_RATE_MCS7 */
3784 6, /* CONF_HW_RXTX_RATE_MCS6 */
3785 5, /* CONF_HW_RXTX_RATE_MCS5 */
3786 4, /* CONF_HW_RXTX_RATE_MCS4 */
3787 3, /* CONF_HW_RXTX_RATE_MCS3 */
3788 2, /* CONF_HW_RXTX_RATE_MCS2 */
3789 1, /* CONF_HW_RXTX_RATE_MCS1 */
3790 0, /* CONF_HW_RXTX_RATE_MCS0 */
3792 7, /* CONF_HW_RXTX_RATE_54 */
3793 6, /* CONF_HW_RXTX_RATE_48 */
3794 5, /* CONF_HW_RXTX_RATE_36 */
3795 4, /* CONF_HW_RXTX_RATE_24 */
3797 /* TI-specific rate */
3798 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3800 3, /* CONF_HW_RXTX_RATE_18 */
3801 2, /* CONF_HW_RXTX_RATE_12 */
3802 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
3803 1, /* CONF_HW_RXTX_RATE_9 */
3804 0, /* CONF_HW_RXTX_RATE_6 */
3805 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
3806 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
3807 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
3810 static struct ieee80211_supported_band wl1271_band_5ghz = {
3811 .channels = wl1271_channels_5ghz,
3812 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3813 .bitrates = wl1271_rates_5ghz,
3814 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
3815 .ht_cap = WL12XX_HT_CAP,
3818 static const u8 *wl1271_band_rate_to_idx[] = {
3819 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3820 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3823 static const struct ieee80211_ops wl1271_ops = {
3824 .start = wl1271_op_start,
3825 .stop = wl1271_op_stop,
3826 .add_interface = wl1271_op_add_interface,
3827 .remove_interface = wl1271_op_remove_interface,
3829 .suspend = wl1271_op_suspend,
3830 .resume = wl1271_op_resume,
3832 .config = wl1271_op_config,
3833 .prepare_multicast = wl1271_op_prepare_multicast,
3834 .configure_filter = wl1271_op_configure_filter,
3836 .set_key = wl1271_op_set_key,
3837 .hw_scan = wl1271_op_hw_scan,
3838 .sched_scan_start = wl1271_op_sched_scan_start,
3839 .sched_scan_stop = wl1271_op_sched_scan_stop,
3840 .bss_info_changed = wl1271_op_bss_info_changed,
3841 .set_frag_threshold = wl1271_op_set_frag_threshold,
3842 .set_rts_threshold = wl1271_op_set_rts_threshold,
3843 .conf_tx = wl1271_op_conf_tx,
3844 .get_tsf = wl1271_op_get_tsf,
3845 .get_survey = wl1271_op_get_survey,
3846 .sta_add = wl1271_op_sta_add,
3847 .sta_remove = wl1271_op_sta_remove,
3848 .ampdu_action = wl1271_op_ampdu_action,
3849 .tx_frames_pending = wl1271_tx_frames_pending,
3850 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
3854 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
3858 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
3860 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3861 wl1271_error("Illegal RX rate from HW: %d", rate);
3865 idx = wl1271_band_rate_to_idx[band][rate];
3866 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3867 wl1271_error("Unsupported RX rate from HW: %d", rate);
3874 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3875 struct device_attribute *attr,
3878 struct wl1271 *wl = dev_get_drvdata(dev);
3883 mutex_lock(&wl->mutex);
3884 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3886 mutex_unlock(&wl->mutex);
3892 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3893 struct device_attribute *attr,
3894 const char *buf, size_t count)
3896 struct wl1271 *wl = dev_get_drvdata(dev);
3900 ret = kstrtoul(buf, 10, &res);
3902 wl1271_warning("incorrect value written to bt_coex_mode");
3906 mutex_lock(&wl->mutex);
3910 if (res == wl->sg_enabled)
3913 wl->sg_enabled = res;
3915 if (wl->state == WL1271_STATE_OFF)
3918 ret = wl1271_ps_elp_wakeup(wl);
3922 wl1271_acx_sg_enable(wl, wl->sg_enabled);
3923 wl1271_ps_elp_sleep(wl);
3926 mutex_unlock(&wl->mutex);
3930 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3931 wl1271_sysfs_show_bt_coex_state,
3932 wl1271_sysfs_store_bt_coex_state);
3934 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3935 struct device_attribute *attr,
3938 struct wl1271 *wl = dev_get_drvdata(dev);
3943 mutex_lock(&wl->mutex);
3944 if (wl->hw_pg_ver >= 0)
3945 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3947 len = snprintf(buf, len, "n/a\n");
3948 mutex_unlock(&wl->mutex);
3953 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3954 wl1271_sysfs_show_hw_pg_ver, NULL);
3956 int wl1271_register_hw(struct wl1271 *wl)
3960 if (wl->mac80211_registered)
3963 ret = wl1271_fetch_nvs(wl);
3965 /* NOTE: The wl->nvs->nvs element must be first, in
3966 * order to simplify the casting, we assume it is at
3967 * the beginning of the wl->nvs structure.
3969 u8 *nvs_ptr = (u8 *)wl->nvs;
3971 wl->mac_addr[0] = nvs_ptr[11];
3972 wl->mac_addr[1] = nvs_ptr[10];
3973 wl->mac_addr[2] = nvs_ptr[6];
3974 wl->mac_addr[3] = nvs_ptr[5];
3975 wl->mac_addr[4] = nvs_ptr[4];
3976 wl->mac_addr[5] = nvs_ptr[3];
3979 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3981 ret = ieee80211_register_hw(wl->hw);
3983 wl1271_error("unable to register mac80211 hw: %d", ret);
3987 wl->mac80211_registered = true;
3989 wl1271_debugfs_init(wl);
3991 register_netdevice_notifier(&wl1271_dev_notifier);
3993 wl1271_notice("loaded");
3997 EXPORT_SYMBOL_GPL(wl1271_register_hw);
3999 void wl1271_unregister_hw(struct wl1271 *wl)
4001 if (wl->state == WL1271_STATE_PLT)
4002 __wl1271_plt_stop(wl);
4004 unregister_netdevice_notifier(&wl1271_dev_notifier);
4005 ieee80211_unregister_hw(wl->hw);
4006 wl->mac80211_registered = false;
4009 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
4011 int wl1271_init_ieee80211(struct wl1271 *wl)
4013 static const u32 cipher_suites[] = {
4014 WLAN_CIPHER_SUITE_WEP40,
4015 WLAN_CIPHER_SUITE_WEP104,
4016 WLAN_CIPHER_SUITE_TKIP,
4017 WLAN_CIPHER_SUITE_CCMP,
4018 WL1271_CIPHER_SUITE_GEM,
4021 /* The tx descriptor buffer and the TKIP space. */
4022 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4023 sizeof(struct wl1271_tx_hw_descr);
4026 /* FIXME: find a proper value */
4027 wl->hw->channel_change_time = 10000;
4028 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
4030 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4031 IEEE80211_HW_BEACON_FILTER |
4032 IEEE80211_HW_SUPPORTS_PS |
4033 IEEE80211_HW_SUPPORTS_UAPSD |
4034 IEEE80211_HW_HAS_RATE_CONTROL |
4035 IEEE80211_HW_CONNECTION_MONITOR |
4036 IEEE80211_HW_SUPPORTS_CQM_RSSI |
4037 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4038 IEEE80211_HW_SPECTRUM_MGMT |
4039 IEEE80211_HW_AP_LINK_PS;
4041 wl->hw->wiphy->cipher_suites = cipher_suites;
4042 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4044 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
4045 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
4046 wl->hw->wiphy->max_scan_ssids = 1;
4048 * Maximum length of elements in scanning probe request templates
4049 * should be the maximum length possible for a template, without
4050 * the IEEE80211 header of the template
4052 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
4053 sizeof(struct ieee80211_header);
4055 /* make sure all our channels fit in the scanned_ch bitmask */
4056 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4057 ARRAY_SIZE(wl1271_channels_5ghz) >
4058 WL1271_MAX_CHANNELS);
4060 * We keep local copies of the band structs because we need to
4061 * modify them on a per-device basis.
4063 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4064 sizeof(wl1271_band_2ghz));
4065 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4066 sizeof(wl1271_band_5ghz));
4068 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4069 &wl->bands[IEEE80211_BAND_2GHZ];
4070 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4071 &wl->bands[IEEE80211_BAND_5GHZ];
4074 wl->hw->max_rates = 1;
4076 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4078 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
4080 wl->hw->sta_data_size = sizeof(struct wl1271_station);
4082 wl->hw->max_rx_aggregation_subframes = 8;
4086 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
4088 #define WL1271_DEFAULT_CHANNEL 0
4090 struct ieee80211_hw *wl1271_alloc_hw(void)
4092 struct ieee80211_hw *hw;
4093 struct platform_device *plat_dev = NULL;
4098 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4100 wl1271_error("could not alloc ieee80211_hw");
4105 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
4107 wl1271_error("could not allocate platform_device");
4109 goto err_plat_alloc;
4113 memset(wl, 0, sizeof(*wl));
4115 INIT_LIST_HEAD(&wl->list);
4118 wl->plat_dev = plat_dev;
4120 for (i = 0; i < NUM_TX_QUEUES; i++)
4121 skb_queue_head_init(&wl->tx_queue[i]);
4123 for (i = 0; i < NUM_TX_QUEUES; i++)
4124 for (j = 0; j < AP_MAX_LINKS; j++)
4125 skb_queue_head_init(&wl->links[j].tx_queue[i]);
4127 skb_queue_head_init(&wl->deferred_rx_queue);
4128 skb_queue_head_init(&wl->deferred_tx_queue);
4130 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
4131 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
4132 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
4133 INIT_WORK(&wl->tx_work, wl1271_tx_work);
4134 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
4135 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
4136 INIT_WORK(&wl->rx_streaming_enable_work,
4137 wl1271_rx_streaming_enable_work);
4138 INIT_WORK(&wl->rx_streaming_disable_work,
4139 wl1271_rx_streaming_disable_work);
4141 wl->channel = WL1271_DEFAULT_CHANNEL;
4142 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
4143 wl->default_key = 0;
4145 wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
4146 wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
4147 wl->psm_entry_retry = 0;
4148 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
4149 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
4150 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
4151 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
4152 wl->band = IEEE80211_BAND_2GHZ;
4155 wl->sg_enabled = true;
4157 wl->bss_type = MAX_BSS_TYPE;
4158 wl->set_bss_type = MAX_BSS_TYPE;
4159 wl->fw_bss_type = MAX_BSS_TYPE;
4160 wl->last_tx_hlid = 0;
4162 wl->ap_fw_ps_map = 0;
4164 wl->platform_quirks = 0;
4165 wl->sched_scanning = false;
4166 setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer,
4167 (unsigned long) wl);
4169 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
4170 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
4171 wl->tx_frames[i] = NULL;
4173 spin_lock_init(&wl->wl_lock);
4175 wl->state = WL1271_STATE_OFF;
4176 mutex_init(&wl->mutex);
4178 /* Apply default driver configuration. */
4179 wl1271_conf_init(wl);
4181 order = get_order(WL1271_AGGR_BUFFER_SIZE);
4182 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4183 if (!wl->aggr_buf) {
4188 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4189 if (!wl->dummy_packet) {
4194 /* Register platform device */
4195 ret = platform_device_register(wl->plat_dev);
4197 wl1271_error("couldn't register platform device");
4198 goto err_dummy_packet;
4200 dev_set_drvdata(&wl->plat_dev->dev, wl);
4202 /* Create sysfs file to control bt coex state */
4203 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4205 wl1271_error("failed to create sysfs file bt_coex_state");
4209 /* Create sysfs file to get HW PG version */
4210 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4212 wl1271_error("failed to create sysfs file hw_pg_ver");
4213 goto err_bt_coex_state;
4219 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4222 platform_device_unregister(wl->plat_dev);
4225 dev_kfree_skb(wl->dummy_packet);
4228 free_pages((unsigned long)wl->aggr_buf, order);
4231 wl1271_debugfs_exit(wl);
4235 ieee80211_free_hw(hw);
4239 return ERR_PTR(ret);
4241 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
4243 int wl1271_free_hw(struct wl1271 *wl)
4245 platform_device_unregister(wl->plat_dev);
4246 dev_kfree_skb(wl->dummy_packet);
4247 free_pages((unsigned long)wl->aggr_buf,
4248 get_order(WL1271_AGGR_BUFFER_SIZE));
4249 kfree(wl->plat_dev);
4251 wl1271_debugfs_exit(wl);
4258 kfree(wl->fw_status);
4259 kfree(wl->tx_res_if);
4261 ieee80211_free_hw(wl->hw);
4265 EXPORT_SYMBOL_GPL(wl1271_free_hw);
4267 u32 wl12xx_debug_level = DEBUG_NONE;
4268 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
4269 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
4270 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4272 MODULE_LICENSE("GPL");
4273 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4274 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");