diff options
author | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
---|---|---|
committer | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
commit | fcc9d2e5a6c89d22b8b773a64fb4ad21ac318446 (patch) | |
tree | a57612d1888735a2ec7972891b68c1ac5ec8faea /drivers/net/wireless/wl12xx/main.c | |
parent | 8dea78da5cee153b8af9c07a2745f6c55057fe12 (diff) |
Diffstat (limited to 'drivers/net/wireless/wl12xx/main.c')
-rw-r--r-- | drivers/net/wireless/wl12xx/main.c | 4561 |
1 files changed, 4561 insertions, 0 deletions
diff --git a/drivers/net/wireless/wl12xx/main.c b/drivers/net/wireless/wl12xx/main.c new file mode 100644 index 00000000000..b70ae40ad66 --- /dev/null +++ b/drivers/net/wireless/wl12xx/main.c | |||
@@ -0,0 +1,4561 @@ | |||
1 | /* | ||
2 | * This file is part of wl1271 | ||
3 | * | ||
4 | * Copyright (C) 2008-2010 Nokia Corporation | ||
5 | * | ||
6 | * Contact: Luciano Coelho <luciano.coelho@nokia.com> | ||
7 | * | ||
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. | ||
11 | * | ||
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. | ||
16 | * | ||
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 | ||
20 | * 02110-1301 USA | ||
21 | * | ||
22 | */ | ||
23 | |||
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> | ||
34 | #include <linux/sched.h> | ||
35 | |||
36 | #include "wl12xx.h" | ||
37 | #include "wl12xx_80211.h" | ||
38 | #include "reg.h" | ||
39 | #include "io.h" | ||
40 | #include "event.h" | ||
41 | #include "tx.h" | ||
42 | #include "rx.h" | ||
43 | #include "ps.h" | ||
44 | #include "init.h" | ||
45 | #include "debugfs.h" | ||
46 | #include "cmd.h" | ||
47 | #include "boot.h" | ||
48 | #include "testmode.h" | ||
49 | #include "scan.h" | ||
50 | |||
51 | #define WL1271_BOOT_RETRIES 3 | ||
52 | |||
53 | static struct conf_drv_settings default_conf = { | ||
54 | .sg = { | ||
55 | .sta_params = { | ||
56 | [CONF_SG_BT_PER_THRESHOLD] = 7500, | ||
57 | [CONF_SG_HV3_MAX_OVERRIDE] = 0, | ||
58 | [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400, | ||
59 | [CONF_SG_BT_LOAD_RATIO] = 200, | ||
60 | [CONF_SG_AUTO_PS_MODE] = 1, | ||
61 | [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170, | ||
62 | [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50, | ||
63 | [CONF_SG_ANTENNA_CONFIGURATION] = 0, | ||
64 | [CONF_SG_BEACON_MISS_PERCENT] = 60, | ||
65 | [CONF_SG_RATE_ADAPT_THRESH] = 12, | ||
66 | [CONF_SG_RATE_ADAPT_SNR] = 0, | ||
67 | [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10, | ||
68 | [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30, | ||
69 | [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8, | ||
70 | [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20, | ||
71 | [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50, | ||
72 | /* Note: with UPSD, this should be 4 */ | ||
73 | [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8, | ||
74 | [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7, | ||
75 | [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25, | ||
76 | [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20, | ||
77 | /* Note: with UPDS, this should be 15 */ | ||
78 | [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8, | ||
79 | /* Note: with UPDS, this should be 50 */ | ||
80 | [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40, | ||
81 | /* Note: with UPDS, this should be 10 */ | ||
82 | [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20, | ||
83 | [CONF_SG_RXT] = 1200, | ||
84 | [CONF_SG_TXT] = 1000, | ||
85 | [CONF_SG_ADAPTIVE_RXT_TXT] = 1, | ||
86 | [CONF_SG_PS_POLL_TIMEOUT] = 10, | ||
87 | [CONF_SG_UPSD_TIMEOUT] = 10, | ||
88 | [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7, | ||
89 | [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15, | ||
90 | [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15, | ||
91 | [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8, | ||
92 | [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20, | ||
93 | [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15, | ||
94 | [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20, | ||
95 | [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50, | ||
96 | [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10, | ||
97 | [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200, | ||
98 | [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800, | ||
99 | [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75, | ||
100 | [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15, | ||
101 | [CONF_SG_HV3_MAX_SERVED] = 6, | ||
102 | [CONF_SG_DHCP_TIME] = 5000, | ||
103 | [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100, | ||
104 | }, | ||
105 | .ap_params = { | ||
106 | [CONF_SG_BT_PER_THRESHOLD] = 7500, | ||
107 | [CONF_SG_HV3_MAX_OVERRIDE] = 0, | ||
108 | [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400, | ||
109 | [CONF_SG_BT_LOAD_RATIO] = 50, | ||
110 | [CONF_SG_AUTO_PS_MODE] = 1, | ||
111 | [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170, | ||
112 | [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50, | ||
113 | [CONF_SG_ANTENNA_CONFIGURATION] = 0, | ||
114 | [CONF_SG_BEACON_MISS_PERCENT] = 60, | ||
115 | [CONF_SG_RATE_ADAPT_THRESH] = 64, | ||
116 | [CONF_SG_RATE_ADAPT_SNR] = 1, | ||
117 | [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10, | ||
118 | [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 25, | ||
119 | [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 25, | ||
120 | [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20, | ||
121 | [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 25, | ||
122 | [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 25, | ||
123 | [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7, | ||
124 | [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25, | ||
125 | [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 25, | ||
126 | [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8, | ||
127 | [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 25, | ||
128 | [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 25, | ||
129 | [CONF_SG_RXT] = 1200, | ||
130 | [CONF_SG_TXT] = 1000, | ||
131 | [CONF_SG_ADAPTIVE_RXT_TXT] = 1, | ||
132 | [CONF_SG_PS_POLL_TIMEOUT] = 10, | ||
133 | [CONF_SG_UPSD_TIMEOUT] = 10, | ||
134 | [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7, | ||
135 | [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15, | ||
136 | [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15, | ||
137 | [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8, | ||
138 | [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20, | ||
139 | [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15, | ||
140 | [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20, | ||
141 | [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50, | ||
142 | [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10, | ||
143 | [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200, | ||
144 | [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800, | ||
145 | [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75, | ||
146 | [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15, | ||
147 | [CONF_SG_HV3_MAX_SERVED] = 6, | ||
148 | [CONF_SG_DHCP_TIME] = 5000, | ||
149 | [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100, | ||
150 | [CONF_SG_TEMP_PARAM_1] = 0, | ||
151 | [CONF_SG_TEMP_PARAM_2] = 0, | ||
152 | [CONF_SG_TEMP_PARAM_3] = 0, | ||
153 | [CONF_SG_TEMP_PARAM_4] = 0, | ||
154 | [CONF_SG_TEMP_PARAM_5] = 0, | ||
155 | [CONF_SG_AP_BEACON_MISS_TX] = 3, | ||
156 | [CONF_SG_RX_WINDOW_LENGTH] = 6, | ||
157 | [CONF_SG_AP_CONNECTION_PROTECTION_TIME] = 50, | ||
158 | [CONF_SG_TEMP_PARAM_6] = 1, | ||
159 | }, | ||
160 | .state = CONF_SG_PROTECTIVE, | ||
161 | }, | ||
162 | .rx = { | ||
163 | .rx_msdu_life_time = 512000, | ||
164 | .packet_detection_threshold = 0, | ||
165 | .ps_poll_timeout = 15, | ||
166 | .upsd_timeout = 15, | ||
167 | .rts_threshold = IEEE80211_MAX_RTS_THRESHOLD, | ||
168 | .rx_cca_threshold = 0, | ||
169 | .irq_blk_threshold = 0xFFFF, | ||
170 | .irq_pkt_threshold = 0, | ||
171 | .irq_timeout = 600, | ||
172 | .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY, | ||
173 | }, | ||
174 | .tx = { | ||
175 | .tx_energy_detection = 0, | ||
176 | .sta_rc_conf = { | ||
177 | .enabled_rates = 0, | ||
178 | .short_retry_limit = 10, | ||
179 | .long_retry_limit = 10, | ||
180 | .aflags = 0, | ||
181 | }, | ||
182 | .ac_conf_count = 4, | ||
183 | .ac_conf = { | ||
184 | [CONF_TX_AC_BE] = { | ||
185 | .ac = CONF_TX_AC_BE, | ||
186 | .cw_min = 15, | ||
187 | .cw_max = 63, | ||
188 | .aifsn = 3, | ||
189 | .tx_op_limit = 0, | ||
190 | }, | ||
191 | [CONF_TX_AC_BK] = { | ||
192 | .ac = CONF_TX_AC_BK, | ||
193 | .cw_min = 15, | ||
194 | .cw_max = 63, | ||
195 | .aifsn = 7, | ||
196 | .tx_op_limit = 0, | ||
197 | }, | ||
198 | [CONF_TX_AC_VI] = { | ||
199 | .ac = CONF_TX_AC_VI, | ||
200 | .cw_min = 15, | ||
201 | .cw_max = 63, | ||
202 | .aifsn = CONF_TX_AIFS_PIFS, | ||
203 | .tx_op_limit = 3008, | ||
204 | }, | ||
205 | [CONF_TX_AC_VO] = { | ||
206 | .ac = CONF_TX_AC_VO, | ||
207 | .cw_min = 15, | ||
208 | .cw_max = 63, | ||
209 | .aifsn = CONF_TX_AIFS_PIFS, | ||
210 | .tx_op_limit = 1504, | ||
211 | }, | ||
212 | }, | ||
213 | .max_tx_retries = 100, | ||
214 | .ap_aging_period = 300, | ||
215 | .tid_conf_count = 4, | ||
216 | .tid_conf = { | ||
217 | [CONF_TX_AC_BE] = { | ||
218 | .queue_id = CONF_TX_AC_BE, | ||
219 | .channel_type = CONF_CHANNEL_TYPE_EDCF, | ||
220 | .tsid = CONF_TX_AC_BE, | ||
221 | .ps_scheme = CONF_PS_SCHEME_LEGACY, | ||
222 | .ack_policy = CONF_ACK_POLICY_LEGACY, | ||
223 | .apsd_conf = {0, 0}, | ||
224 | }, | ||
225 | [CONF_TX_AC_BK] = { | ||
226 | .queue_id = CONF_TX_AC_BK, | ||
227 | .channel_type = CONF_CHANNEL_TYPE_EDCF, | ||
228 | .tsid = CONF_TX_AC_BK, | ||
229 | .ps_scheme = CONF_PS_SCHEME_LEGACY, | ||
230 | .ack_policy = CONF_ACK_POLICY_LEGACY, | ||
231 | .apsd_conf = {0, 0}, | ||
232 | }, | ||
233 | [CONF_TX_AC_VI] = { | ||
234 | .queue_id = CONF_TX_AC_VI, | ||
235 | .channel_type = CONF_CHANNEL_TYPE_EDCF, | ||
236 | .tsid = CONF_TX_AC_VI, | ||
237 | .ps_scheme = CONF_PS_SCHEME_LEGACY, | ||
238 | .ack_policy = CONF_ACK_POLICY_LEGACY, | ||
239 | .apsd_conf = {0, 0}, | ||
240 | }, | ||
241 | [CONF_TX_AC_VO] = { | ||
242 | .queue_id = CONF_TX_AC_VO, | ||
243 | .channel_type = CONF_CHANNEL_TYPE_EDCF, | ||
244 | .tsid = CONF_TX_AC_VO, | ||
245 | .ps_scheme = CONF_PS_SCHEME_LEGACY, | ||
246 | .ack_policy = CONF_ACK_POLICY_LEGACY, | ||
247 | .apsd_conf = {0, 0}, | ||
248 | }, | ||
249 | }, | ||
250 | .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD, | ||
251 | .tx_compl_timeout = 700, | ||
252 | .tx_compl_threshold = 4, | ||
253 | .basic_rate = CONF_HW_BIT_RATE_1MBPS, | ||
254 | .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS, | ||
255 | .tmpl_short_retry_limit = 10, | ||
256 | .tmpl_long_retry_limit = 10, | ||
257 | }, | ||
258 | .conn = { | ||
259 | .wake_up_event = CONF_WAKE_UP_EVENT_DTIM, | ||
260 | .listen_interval = 1, | ||
261 | .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED, | ||
262 | .bcn_filt_ie_count = 2, | ||
263 | .bcn_filt_ie = { | ||
264 | [0] = { | ||
265 | .ie = WLAN_EID_CHANNEL_SWITCH, | ||
266 | .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE, | ||
267 | }, | ||
268 | [1] = { | ||
269 | .ie = WLAN_EID_HT_INFORMATION, | ||
270 | .rule = CONF_BCN_RULE_PASS_ON_CHANGE, | ||
271 | }, | ||
272 | }, | ||
273 | .synch_fail_thold = 10, | ||
274 | .bss_lose_timeout = 100, | ||
275 | .beacon_rx_timeout = 10000, | ||
276 | .broadcast_timeout = 20000, | ||
277 | .rx_broadcast_in_ps = 1, | ||
278 | .ps_poll_threshold = 10, | ||
279 | .ps_poll_recovery_period = 700, | ||
280 | .bet_enable = CONF_BET_MODE_ENABLE, | ||
281 | .bet_max_consecutive = 50, | ||
282 | .psm_entry_retries = 5, | ||
283 | .psm_exit_retries = 16, | ||
284 | .psm_entry_nullfunc_retries = 3, | ||
285 | .psm_entry_hangover_period = 1, | ||
286 | .keep_alive_interval = 55000, | ||
287 | .max_listen_interval = 20, | ||
288 | }, | ||
289 | .itrim = { | ||
290 | .enable = false, | ||
291 | .timeout = 50000, | ||
292 | }, | ||
293 | .pm_config = { | ||
294 | .host_clk_settling_time = 5000, | ||
295 | .host_fast_wakeup_support = false | ||
296 | }, | ||
297 | .roam_trigger = { | ||
298 | .trigger_pacing = 1, | ||
299 | .avg_weight_rssi_beacon = 20, | ||
300 | .avg_weight_rssi_data = 10, | ||
301 | .avg_weight_snr_beacon = 20, | ||
302 | .avg_weight_snr_data = 10, | ||
303 | }, | ||
304 | .scan = { | ||
305 | .min_dwell_time_active = 7500, | ||
306 | .max_dwell_time_active = 30000, | ||
307 | .min_dwell_time_passive = 100000, | ||
308 | .max_dwell_time_passive = 100000, | ||
309 | .num_probe_reqs = 2, | ||
310 | }, | ||
311 | .sched_scan = { | ||
312 | /* sched_scan requires dwell times in TU instead of TU/1000 */ | ||
313 | .min_dwell_time_active = 8, | ||
314 | .max_dwell_time_active = 30, | ||
315 | .dwell_time_passive = 100, | ||
316 | .dwell_time_dfs = 150, | ||
317 | .num_probe_reqs = 2, | ||
318 | .rssi_threshold = -90, | ||
319 | .snr_threshold = 0, | ||
320 | }, | ||
321 | .rf = { | ||
322 | .tx_per_channel_power_compensation_2 = { | ||
323 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | ||
324 | }, | ||
325 | .tx_per_channel_power_compensation_5 = { | ||
326 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | ||
327 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | ||
328 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | ||
329 | }, | ||
330 | }, | ||
331 | .ht = { | ||
332 | .tx_ba_win_size = 64, | ||
333 | .inactivity_timeout = 10000, | ||
334 | }, | ||
335 | .mem_wl127x = { | ||
336 | .num_stations = 1, | ||
337 | .ssid_profiles = 1, | ||
338 | .rx_block_num = 70, | ||
339 | .tx_min_block_num = 40, | ||
340 | .dynamic_memory = 1, | ||
341 | .min_req_tx_blocks = 100, | ||
342 | .min_req_rx_blocks = 22, | ||
343 | .tx_min = 27, | ||
344 | }, | ||
345 | .mem_wl128x = { | ||
346 | .num_stations = 1, | ||
347 | .ssid_profiles = 1, | ||
348 | .rx_block_num = 40, | ||
349 | .tx_min_block_num = 40, | ||
350 | .dynamic_memory = 1, | ||
351 | .min_req_tx_blocks = 45, | ||
352 | .min_req_rx_blocks = 22, | ||
353 | .tx_min = 27, | ||
354 | }, | ||
355 | .fm_coex = { | ||
356 | .enable = true, | ||
357 | .swallow_period = 5, | ||
358 | .n_divider_fref_set_1 = 0xff, /* default */ | ||
359 | .n_divider_fref_set_2 = 12, | ||
360 | .m_divider_fref_set_1 = 148, | ||
361 | .m_divider_fref_set_2 = 0xffff, /* default */ | ||
362 | .coex_pll_stabilization_time = 0xffffffff, /* default */ | ||
363 | .ldo_stabilization_time = 0xffff, /* default */ | ||
364 | .fm_disturbed_band_margin = 0xff, /* default */ | ||
365 | .swallow_clk_diff = 0xff, /* default */ | ||
366 | }, | ||
367 | .rx_streaming = { | ||
368 | .duration = 150, | ||
369 | .queues = 0x1, | ||
370 | .interval = 20, | ||
371 | .always = 0, | ||
372 | }, | ||
373 | .fwlog = { | ||
374 | .mode = WL12XX_FWLOG_ON_DEMAND, | ||
375 | .mem_blocks = 2, | ||
376 | .severity = 0, | ||
377 | .timestamp = WL12XX_FWLOG_TIMESTAMP_DISABLED, | ||
378 | .output = WL12XX_FWLOG_OUTPUT_HOST, | ||
379 | .threshold = 0, | ||
380 | }, | ||
381 | .hci_io_ds = HCI_IO_DS_6MA, | ||
382 | }; | ||
383 | |||
384 | static char *fwlog_param; | ||
385 | |||
386 | static void __wl1271_op_remove_interface(struct wl1271 *wl, | ||
387 | bool reset_tx_queues); | ||
388 | static void wl1271_free_ap_keys(struct wl1271 *wl); | ||
389 | |||
390 | |||
391 | static void wl1271_device_release(struct device *dev) | ||
392 | { | ||
393 | |||
394 | } | ||
395 | |||
396 | static struct platform_device wl1271_device = { | ||
397 | .name = "wl1271", | ||
398 | .id = -1, | ||
399 | |||
400 | /* device model insists to have a release function */ | ||
401 | .dev = { | ||
402 | .release = wl1271_device_release, | ||
403 | }, | ||
404 | }; | ||
405 | |||
406 | static DEFINE_MUTEX(wl_list_mutex); | ||
407 | static LIST_HEAD(wl_list); | ||
408 | |||
409 | static int wl1271_check_operstate(struct wl1271 *wl, unsigned char operstate) | ||
410 | { | ||
411 | int ret; | ||
412 | if (operstate != IF_OPER_UP) | ||
413 | return 0; | ||
414 | |||
415 | if (test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) | ||
416 | return 0; | ||
417 | |||
418 | ret = wl1271_cmd_set_sta_state(wl); | ||
419 | if (ret < 0) | ||
420 | return ret; | ||
421 | |||
422 | wl1271_info("Association completed."); | ||
423 | return 0; | ||
424 | } | ||
425 | static int wl1271_dev_notify(struct notifier_block *me, unsigned long what, | ||
426 | void *arg) | ||
427 | { | ||
428 | struct net_device *dev = arg; | ||
429 | struct wireless_dev *wdev; | ||
430 | struct wiphy *wiphy; | ||
431 | struct ieee80211_hw *hw; | ||
432 | struct wl1271 *wl; | ||
433 | struct wl1271 *wl_temp; | ||
434 | int ret = 0; | ||
435 | |||
436 | /* Check that this notification is for us. */ | ||
437 | if (what != NETDEV_CHANGE) | ||
438 | return NOTIFY_DONE; | ||
439 | |||
440 | wdev = dev->ieee80211_ptr; | ||
441 | if (wdev == NULL) | ||
442 | return NOTIFY_DONE; | ||
443 | |||
444 | wiphy = wdev->wiphy; | ||
445 | if (wiphy == NULL) | ||
446 | return NOTIFY_DONE; | ||
447 | |||
448 | hw = wiphy_priv(wiphy); | ||
449 | if (hw == NULL) | ||
450 | return NOTIFY_DONE; | ||
451 | |||
452 | wl_temp = hw->priv; | ||
453 | mutex_lock(&wl_list_mutex); | ||
454 | list_for_each_entry(wl, &wl_list, list) { | ||
455 | if (wl == wl_temp) | ||
456 | break; | ||
457 | } | ||
458 | mutex_unlock(&wl_list_mutex); | ||
459 | if (wl != wl_temp) | ||
460 | return NOTIFY_DONE; | ||
461 | |||
462 | mutex_lock(&wl->mutex); | ||
463 | |||
464 | if (wl->state == WL1271_STATE_OFF) | ||
465 | goto out; | ||
466 | |||
467 | if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) | ||
468 | goto out; | ||
469 | |||
470 | ret = wl1271_ps_elp_wakeup(wl); | ||
471 | if (ret < 0) | ||
472 | goto out; | ||
473 | |||
474 | wl1271_check_operstate(wl, dev->operstate); | ||
475 | |||
476 | wl1271_ps_elp_sleep(wl); | ||
477 | |||
478 | out: | ||
479 | mutex_unlock(&wl->mutex); | ||
480 | |||
481 | return NOTIFY_OK; | ||
482 | } | ||
483 | |||
484 | static int wl1271_reg_notify(struct wiphy *wiphy, | ||
485 | struct regulatory_request *request) | ||
486 | { | ||
487 | struct ieee80211_supported_band *band; | ||
488 | struct ieee80211_channel *ch; | ||
489 | int i; | ||
490 | |||
491 | band = wiphy->bands[IEEE80211_BAND_5GHZ]; | ||
492 | for (i = 0; i < band->n_channels; i++) { | ||
493 | ch = &band->channels[i]; | ||
494 | if (ch->flags & IEEE80211_CHAN_DISABLED) | ||
495 | continue; | ||
496 | |||
497 | if (ch->flags & IEEE80211_CHAN_RADAR) | ||
498 | ch->flags |= IEEE80211_CHAN_NO_IBSS | | ||
499 | IEEE80211_CHAN_PASSIVE_SCAN; | ||
500 | |||
501 | } | ||
502 | |||
503 | return 0; | ||
504 | } | ||
505 | |||
506 | static int wl1271_set_rx_streaming(struct wl1271 *wl, bool enable) | ||
507 | { | ||
508 | int ret = 0; | ||
509 | |||
510 | /* we should hold wl->mutex */ | ||
511 | ret = wl1271_acx_ps_rx_streaming(wl, enable); | ||
512 | if (ret < 0) | ||
513 | goto out; | ||
514 | |||
515 | if (enable) | ||
516 | set_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags); | ||
517 | else | ||
518 | clear_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags); | ||
519 | out: | ||
520 | return ret; | ||
521 | } | ||
522 | |||
523 | /* | ||
524 | * this function is being called when the rx_streaming interval | ||
525 | * has beed changed or rx_streaming should be disabled | ||
526 | */ | ||
527 | int wl1271_recalc_rx_streaming(struct wl1271 *wl) | ||
528 | { | ||
529 | int ret = 0; | ||
530 | int period = wl->conf.rx_streaming.interval; | ||
531 | |||
532 | /* don't reconfigure if rx_streaming is disabled */ | ||
533 | if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags)) | ||
534 | goto out; | ||
535 | |||
536 | /* reconfigure/disable according to new streaming_period */ | ||
537 | if (period && | ||
538 | test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) && | ||
539 | (wl->conf.rx_streaming.always || | ||
540 | test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags))) | ||
541 | ret = wl1271_set_rx_streaming(wl, true); | ||
542 | else { | ||
543 | ret = wl1271_set_rx_streaming(wl, false); | ||
544 | /* don't cancel_work_sync since we might deadlock */ | ||
545 | del_timer_sync(&wl->rx_streaming_timer); | ||
546 | } | ||
547 | out: | ||
548 | return ret; | ||
549 | } | ||
550 | |||
551 | static void wl1271_rx_streaming_enable_work(struct work_struct *work) | ||
552 | { | ||
553 | int ret; | ||
554 | struct wl1271 *wl = | ||
555 | container_of(work, struct wl1271, rx_streaming_enable_work); | ||
556 | |||
557 | mutex_lock(&wl->mutex); | ||
558 | |||
559 | if (test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags) || | ||
560 | !test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) || | ||
561 | (!wl->conf.rx_streaming.always && | ||
562 | !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags))) | ||
563 | goto out; | ||
564 | |||
565 | if (!wl->conf.rx_streaming.interval) | ||
566 | goto out; | ||
567 | |||
568 | ret = wl1271_ps_elp_wakeup(wl); | ||
569 | if (ret < 0) | ||
570 | goto out; | ||
571 | |||
572 | ret = wl1271_set_rx_streaming(wl, true); | ||
573 | if (ret < 0) | ||
574 | goto out_sleep; | ||
575 | |||
576 | /* stop it after some time of inactivity */ | ||
577 | mod_timer(&wl->rx_streaming_timer, | ||
578 | jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration)); | ||
579 | |||
580 | out_sleep: | ||
581 | wl1271_ps_elp_sleep(wl); | ||
582 | out: | ||
583 | mutex_unlock(&wl->mutex); | ||
584 | } | ||
585 | |||
586 | static void wl1271_rx_streaming_disable_work(struct work_struct *work) | ||
587 | { | ||
588 | int ret; | ||
589 | struct wl1271 *wl = | ||
590 | container_of(work, struct wl1271, rx_streaming_disable_work); | ||
591 | |||
592 | mutex_lock(&wl->mutex); | ||
593 | |||
594 | if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags)) | ||
595 | goto out; | ||
596 | |||
597 | ret = wl1271_ps_elp_wakeup(wl); | ||
598 | if (ret < 0) | ||
599 | goto out; | ||
600 | |||
601 | ret = wl1271_set_rx_streaming(wl, false); | ||
602 | if (ret) | ||
603 | goto out_sleep; | ||
604 | |||
605 | out_sleep: | ||
606 | wl1271_ps_elp_sleep(wl); | ||
607 | out: | ||
608 | mutex_unlock(&wl->mutex); | ||
609 | } | ||
610 | |||
611 | static void wl1271_rx_streaming_timer(unsigned long data) | ||
612 | { | ||
613 | struct wl1271 *wl = (struct wl1271 *)data; | ||
614 | ieee80211_queue_work(wl->hw, &wl->rx_streaming_disable_work); | ||
615 | } | ||
616 | |||
617 | static void wl1271_conf_init(struct wl1271 *wl) | ||
618 | { | ||
619 | |||
620 | /* | ||
621 | * This function applies the default configuration to the driver. This | ||
622 | * function is invoked upon driver load (spi probe.) | ||
623 | * | ||
624 | * The configuration is stored in a run-time structure in order to | ||
625 | * facilitate for run-time adjustment of any of the parameters. Making | ||
626 | * changes to the configuration structure will apply the new values on | ||
627 | * the next interface up (wl1271_op_start.) | ||
628 | */ | ||
629 | |||
630 | /* apply driver default configuration */ | ||
631 | memcpy(&wl->conf, &default_conf, sizeof(default_conf)); | ||
632 | |||
633 | /* Adjust settings according to optional module parameters */ | ||
634 | if (fwlog_param) { | ||
635 | if (!strcmp(fwlog_param, "continuous")) { | ||
636 | wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS; | ||
637 | } else if (!strcmp(fwlog_param, "ondemand")) { | ||
638 | wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND; | ||
639 | } else if (!strcmp(fwlog_param, "dbgpins")) { | ||
640 | wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS; | ||
641 | wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS; | ||
642 | } else if (!strcmp(fwlog_param, "disable")) { | ||
643 | wl->conf.fwlog.mem_blocks = 0; | ||
644 | wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE; | ||
645 | } else { | ||
646 | wl1271_error("Unknown fwlog parameter %s", fwlog_param); | ||
647 | } | ||
648 | } | ||
649 | } | ||
650 | |||
651 | static int wl1271_plt_init(struct wl1271 *wl) | ||
652 | { | ||
653 | struct conf_tx_ac_category *conf_ac; | ||
654 | struct conf_tx_tid *conf_tid; | ||
655 | int ret, i; | ||
656 | |||
657 | if (wl->chip.id == CHIP_ID_1283_PG20) | ||
658 | ret = wl128x_cmd_general_parms(wl); | ||
659 | else | ||
660 | ret = wl1271_cmd_general_parms(wl); | ||
661 | if (ret < 0) | ||
662 | return ret; | ||
663 | |||
664 | if (wl->chip.id == CHIP_ID_1283_PG20) | ||
665 | ret = wl128x_cmd_radio_parms(wl); | ||
666 | else | ||
667 | ret = wl1271_cmd_radio_parms(wl); | ||
668 | if (ret < 0) | ||
669 | return ret; | ||
670 | |||
671 | if (wl->chip.id != CHIP_ID_1283_PG20) { | ||
672 | ret = wl1271_cmd_ext_radio_parms(wl); | ||
673 | if (ret < 0) | ||
674 | return ret; | ||
675 | } | ||
676 | if (ret < 0) | ||
677 | return ret; | ||
678 | |||
679 | /* Chip-specific initializations */ | ||
680 | ret = wl1271_chip_specific_init(wl); | ||
681 | if (ret < 0) | ||
682 | return ret; | ||
683 | |||
684 | ret = wl1271_sta_init_templates_config(wl); | ||
685 | if (ret < 0) | ||
686 | return ret; | ||
687 | |||
688 | ret = wl1271_acx_init_mem_config(wl); | ||
689 | if (ret < 0) | ||
690 | return ret; | ||
691 | |||
692 | /* PHY layer config */ | ||
693 | ret = wl1271_init_phy_config(wl); | ||
694 | if (ret < 0) | ||
695 | goto out_free_memmap; | ||
696 | |||
697 | ret = wl1271_acx_dco_itrim_params(wl); | ||
698 | if (ret < 0) | ||
699 | goto out_free_memmap; | ||
700 | |||
701 | /* Initialize connection monitoring thresholds */ | ||
702 | ret = wl1271_acx_conn_monit_params(wl, false); | ||
703 | if (ret < 0) | ||
704 | goto out_free_memmap; | ||
705 | |||
706 | /* Bluetooth WLAN coexistence */ | ||
707 | ret = wl1271_init_pta(wl); | ||
708 | if (ret < 0) | ||
709 | goto out_free_memmap; | ||
710 | |||
711 | /* FM WLAN coexistence */ | ||
712 | ret = wl1271_acx_fm_coex(wl); | ||
713 | if (ret < 0) | ||
714 | goto out_free_memmap; | ||
715 | |||
716 | /* Energy detection */ | ||
717 | ret = wl1271_init_energy_detection(wl); | ||
718 | if (ret < 0) | ||
719 | goto out_free_memmap; | ||
720 | |||
721 | ret = wl1271_acx_sta_mem_cfg(wl); | ||
722 | if (ret < 0) | ||
723 | goto out_free_memmap; | ||
724 | |||
725 | /* Default fragmentation threshold */ | ||
726 | ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold); | ||
727 | if (ret < 0) | ||
728 | goto out_free_memmap; | ||
729 | |||
730 | /* Default TID/AC configuration */ | ||
731 | BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count); | ||
732 | for (i = 0; i < wl->conf.tx.tid_conf_count; i++) { | ||
733 | conf_ac = &wl->conf.tx.ac_conf[i]; | ||
734 | ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min, | ||
735 | conf_ac->cw_max, conf_ac->aifsn, | ||
736 | conf_ac->tx_op_limit); | ||
737 | if (ret < 0) | ||
738 | goto out_free_memmap; | ||
739 | |||
740 | conf_tid = &wl->conf.tx.tid_conf[i]; | ||
741 | ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id, | ||
742 | conf_tid->channel_type, | ||
743 | conf_tid->tsid, | ||
744 | conf_tid->ps_scheme, | ||
745 | conf_tid->ack_policy, | ||
746 | conf_tid->apsd_conf[0], | ||
747 | conf_tid->apsd_conf[1]); | ||
748 | if (ret < 0) | ||
749 | goto out_free_memmap; | ||
750 | } | ||
751 | |||
752 | /* Enable data path */ | ||
753 | ret = wl1271_cmd_data_path(wl, 1); | ||
754 | if (ret < 0) | ||
755 | goto out_free_memmap; | ||
756 | |||
757 | /* Configure for CAM power saving (ie. always active) */ | ||
758 | ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM); | ||
759 | if (ret < 0) | ||
760 | goto out_free_memmap; | ||
761 | |||
762 | /* configure PM */ | ||
763 | ret = wl1271_acx_pm_config(wl); | ||
764 | if (ret < 0) | ||
765 | goto out_free_memmap; | ||
766 | |||
767 | return 0; | ||
768 | |||
769 | out_free_memmap: | ||
770 | kfree(wl->target_mem_map); | ||
771 | wl->target_mem_map = NULL; | ||
772 | |||
773 | return ret; | ||
774 | } | ||
775 | |||
776 | static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks) | ||
777 | { | ||
778 | bool fw_ps; | ||
779 | |||
780 | /* only regulate station links */ | ||
781 | if (hlid < WL1271_AP_STA_HLID_START) | ||
782 | return; | ||
783 | |||
784 | fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map); | ||
785 | |||
786 | /* | ||
787 | * Wake up from high level PS if the STA is asleep with too little | ||
788 | * blocks in FW or if the STA is awake. | ||
789 | */ | ||
790 | if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS) | ||
791 | wl1271_ps_link_end(wl, hlid); | ||
792 | |||
793 | /* Start high-level PS if the STA is asleep with enough blocks in FW */ | ||
794 | else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS) | ||
795 | wl1271_ps_link_start(wl, hlid, true); | ||
796 | } | ||
797 | |||
798 | static void wl1271_irq_update_links_status(struct wl1271 *wl, | ||
799 | struct wl1271_fw_ap_status *status) | ||
800 | { | ||
801 | u32 cur_fw_ps_map; | ||
802 | u8 hlid; | ||
803 | |||
804 | cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap); | ||
805 | if (wl->ap_fw_ps_map != cur_fw_ps_map) { | ||
806 | wl1271_debug(DEBUG_PSM, | ||
807 | "link ps prev 0x%x cur 0x%x changed 0x%x", | ||
808 | wl->ap_fw_ps_map, cur_fw_ps_map, | ||
809 | wl->ap_fw_ps_map ^ cur_fw_ps_map); | ||
810 | |||
811 | wl->ap_fw_ps_map = cur_fw_ps_map; | ||
812 | } | ||
813 | |||
814 | for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) { | ||
815 | u8 cnt = status->tx_lnk_free_blks[hlid] - | ||
816 | wl->links[hlid].prev_freed_blks; | ||
817 | |||
818 | wl->links[hlid].prev_freed_blks = | ||
819 | status->tx_lnk_free_blks[hlid]; | ||
820 | wl->links[hlid].allocated_blks -= cnt; | ||
821 | |||
822 | wl1271_irq_ps_regulate_link(wl, hlid, | ||
823 | wl->links[hlid].allocated_blks); | ||
824 | } | ||
825 | } | ||
826 | |||
827 | static u32 wl1271_tx_allocated_blocks(struct wl1271 *wl) | ||
828 | { | ||
829 | int i; | ||
830 | u32 total_alloc_blocks = 0; | ||
831 | |||
832 | for (i = 0; i < NUM_TX_QUEUES; i++) | ||
833 | total_alloc_blocks += wl->tx_allocated_blocks[i]; | ||
834 | |||
835 | return total_alloc_blocks; | ||
836 | } | ||
837 | |||
838 | static void wl1271_fw_status(struct wl1271 *wl, | ||
839 | struct wl1271_fw_full_status *full_status) | ||
840 | { | ||
841 | struct wl1271_fw_common_status *status = &full_status->common; | ||
842 | struct timespec ts; | ||
843 | u32 old_tx_blk_count = wl->tx_blocks_available; | ||
844 | u32 freed_blocks = 0, ac_freed_blocks; | ||
845 | int i; | ||
846 | |||
847 | if (wl->bss_type == BSS_TYPE_AP_BSS) { | ||
848 | wl1271_raw_read(wl, FW_STATUS_ADDR, status, | ||
849 | sizeof(struct wl1271_fw_ap_status), false); | ||
850 | } else { | ||
851 | wl1271_raw_read(wl, FW_STATUS_ADDR, status, | ||
852 | sizeof(struct wl1271_fw_sta_status), false); | ||
853 | } | ||
854 | |||
855 | wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, " | ||
856 | "drv_rx_counter = %d, tx_results_counter = %d)", | ||
857 | status->intr, | ||
858 | status->fw_rx_counter, | ||
859 | status->drv_rx_counter, | ||
860 | status->tx_results_counter); | ||
861 | |||
862 | /* update number of available TX blocks */ | ||
863 | for (i = 0; i < NUM_TX_QUEUES; i++) { | ||
864 | ac_freed_blocks = le32_to_cpu(status->tx_released_blks[i]) - | ||
865 | wl->tx_blocks_freed[i]; | ||
866 | freed_blocks += ac_freed_blocks; | ||
867 | |||
868 | wl->tx_allocated_blocks[i] -= ac_freed_blocks; | ||
869 | |||
870 | wl->tx_blocks_freed[i] = | ||
871 | le32_to_cpu(status->tx_released_blks[i]); | ||
872 | } | ||
873 | |||
874 | if (wl->bss_type == BSS_TYPE_AP_BSS) { | ||
875 | /* Update num of allocated TX blocks per link and ps status */ | ||
876 | wl1271_irq_update_links_status(wl, &full_status->ap); | ||
877 | wl->tx_blocks_available += freed_blocks; | ||
878 | } else { | ||
879 | int avail = full_status->sta.tx_total - | ||
880 | wl1271_tx_allocated_blocks(wl); | ||
881 | |||
882 | /* | ||
883 | * The FW might change the total number of TX memblocks before | ||
884 | * we get a notification about blocks being released. Thus, the | ||
885 | * available blocks calculation might yield a temporary result | ||
886 | * which is lower than the actual available blocks. Keeping in | ||
887 | * mind that only blocks that were allocated can be moved from | ||
888 | * TX to RX, tx_blocks_available should never decrease here. | ||
889 | */ | ||
890 | wl->tx_blocks_available = max((int)wl->tx_blocks_available, | ||
891 | avail); | ||
892 | } | ||
893 | |||
894 | /* if more blocks are available now, tx work can be scheduled */ | ||
895 | if (wl->tx_blocks_available > old_tx_blk_count) | ||
896 | clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags); | ||
897 | |||
898 | /* update the host-chipset time offset */ | ||
899 | getnstimeofday(&ts); | ||
900 | wl->time_offset = (timespec_to_ns(&ts) >> 10) - | ||
901 | (s64)le32_to_cpu(status->fw_localtime); | ||
902 | } | ||
903 | |||
904 | static void wl1271_flush_deferred_work(struct wl1271 *wl) | ||
905 | { | ||
906 | struct sk_buff *skb; | ||
907 | |||
908 | /* Pass all received frames to the network stack */ | ||
909 | while ((skb = skb_dequeue(&wl->deferred_rx_queue))) | ||
910 | ieee80211_rx_ni(wl->hw, skb); | ||
911 | |||
912 | /* Return sent skbs to the network stack */ | ||
913 | while ((skb = skb_dequeue(&wl->deferred_tx_queue))) | ||
914 | ieee80211_tx_status_ni(wl->hw, skb); | ||
915 | } | ||
916 | |||
917 | static void wl1271_netstack_work(struct work_struct *work) | ||
918 | { | ||
919 | struct wl1271 *wl = | ||
920 | container_of(work, struct wl1271, netstack_work); | ||
921 | |||
922 | do { | ||
923 | wl1271_flush_deferred_work(wl); | ||
924 | } while (skb_queue_len(&wl->deferred_rx_queue)); | ||
925 | } | ||
926 | |||
927 | #define WL1271_IRQ_MAX_LOOPS 256 | ||
928 | |||
929 | irqreturn_t wl1271_irq(int irq, void *cookie) | ||
930 | { | ||
931 | int ret; | ||
932 | u32 intr; | ||
933 | int loopcount = WL1271_IRQ_MAX_LOOPS; | ||
934 | struct wl1271 *wl = (struct wl1271 *)cookie; | ||
935 | bool done = false; | ||
936 | unsigned int defer_count; | ||
937 | unsigned long flags; | ||
938 | |||
939 | /* TX might be handled here, avoid redundant work */ | ||
940 | set_bit(WL1271_FLAG_TX_PENDING, &wl->flags); | ||
941 | cancel_work_sync(&wl->tx_work); | ||
942 | |||
943 | /* | ||
944 | * In case edge triggered interrupt must be used, we cannot iterate | ||
945 | * more than once without introducing race conditions with the hardirq. | ||
946 | */ | ||
947 | if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ) | ||
948 | loopcount = 1; | ||
949 | |||
950 | mutex_lock(&wl->mutex); | ||
951 | |||
952 | wl1271_debug(DEBUG_IRQ, "IRQ work"); | ||
953 | |||
954 | if (unlikely(wl->state == WL1271_STATE_OFF)) | ||
955 | goto out; | ||
956 | |||
957 | ret = wl1271_ps_elp_wakeup(wl); | ||
958 | if (ret < 0) | ||
959 | goto out; | ||
960 | |||
961 | while (!done && loopcount--) { | ||
962 | /* | ||
963 | * In order to avoid a race with the hardirq, clear the flag | ||
964 | * before acknowledging the chip. Since the mutex is held, | ||
965 | * wl1271_ps_elp_wakeup cannot be called concurrently. | ||
966 | */ | ||
967 | clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags); | ||
968 | smp_mb__after_clear_bit(); | ||
969 | |||
970 | wl1271_fw_status(wl, wl->fw_status); | ||
971 | intr = le32_to_cpu(wl->fw_status->common.intr); | ||
972 | intr &= WL1271_INTR_MASK; | ||
973 | if (!intr) { | ||
974 | done = true; | ||
975 | continue; | ||
976 | } | ||
977 | |||
978 | if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) { | ||
979 | wl1271_error("watchdog interrupt received! " | ||
980 | "starting recovery."); | ||
981 | wl12xx_queue_recovery_work(wl); | ||
982 | |||
983 | /* restarting the chip. ignore any other interrupt. */ | ||
984 | goto out; | ||
985 | } | ||
986 | |||
987 | if (likely(intr & WL1271_ACX_INTR_DATA)) { | ||
988 | wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA"); | ||
989 | |||
990 | wl1271_rx(wl, &wl->fw_status->common); | ||
991 | |||
992 | /* Check if any tx blocks were freed */ | ||
993 | spin_lock_irqsave(&wl->wl_lock, flags); | ||
994 | if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) && | ||
995 | wl1271_tx_total_queue_count(wl) > 0) { | ||
996 | spin_unlock_irqrestore(&wl->wl_lock, flags); | ||
997 | /* | ||
998 | * In order to avoid starvation of the TX path, | ||
999 | * call the work function directly. | ||
1000 | */ | ||
1001 | wl1271_tx_work_locked(wl); | ||
1002 | } else { | ||
1003 | spin_unlock_irqrestore(&wl->wl_lock, flags); | ||
1004 | } | ||
1005 | |||
1006 | /* check for tx results */ | ||
1007 | if (wl->fw_status->common.tx_results_counter != | ||
1008 | (wl->tx_results_count & 0xff)) | ||
1009 | wl1271_tx_complete(wl); | ||
1010 | |||
1011 | /* Make sure the deferred queues don't get too long */ | ||
1012 | defer_count = skb_queue_len(&wl->deferred_tx_queue) + | ||
1013 | skb_queue_len(&wl->deferred_rx_queue); | ||
1014 | if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT) | ||
1015 | wl1271_flush_deferred_work(wl); | ||
1016 | } | ||
1017 | |||
1018 | if (intr & WL1271_ACX_INTR_EVENT_A) { | ||
1019 | wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A"); | ||
1020 | wl1271_event_handle(wl, 0); | ||
1021 | } | ||
1022 | |||
1023 | if (intr & WL1271_ACX_INTR_EVENT_B) { | ||
1024 | wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B"); | ||
1025 | wl1271_event_handle(wl, 1); | ||
1026 | } | ||
1027 | |||
1028 | if (intr & WL1271_ACX_INTR_INIT_COMPLETE) | ||
1029 | wl1271_debug(DEBUG_IRQ, | ||
1030 | "WL1271_ACX_INTR_INIT_COMPLETE"); | ||
1031 | |||
1032 | if (intr & WL1271_ACX_INTR_HW_AVAILABLE) | ||
1033 | wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE"); | ||
1034 | } | ||
1035 | |||
1036 | wl1271_ps_elp_sleep(wl); | ||
1037 | |||
1038 | out: | ||
1039 | spin_lock_irqsave(&wl->wl_lock, flags); | ||
1040 | /* In case TX was not handled here, queue TX work */ | ||
1041 | clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags); | ||
1042 | if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) && | ||
1043 | wl1271_tx_total_queue_count(wl) > 0) | ||
1044 | ieee80211_queue_work(wl->hw, &wl->tx_work); | ||
1045 | spin_unlock_irqrestore(&wl->wl_lock, flags); | ||
1046 | |||
1047 | mutex_unlock(&wl->mutex); | ||
1048 | |||
1049 | return IRQ_HANDLED; | ||
1050 | } | ||
1051 | EXPORT_SYMBOL_GPL(wl1271_irq); | ||
1052 | |||
1053 | static int wl1271_fetch_firmware(struct wl1271 *wl) | ||
1054 | { | ||
1055 | const struct firmware *fw; | ||
1056 | const char *fw_name; | ||
1057 | int ret; | ||
1058 | |||
1059 | switch (wl->bss_type) { | ||
1060 | case BSS_TYPE_AP_BSS: | ||
1061 | if (wl->chip.id == CHIP_ID_1283_PG20) | ||
1062 | fw_name = WL128X_AP_FW_NAME; | ||
1063 | else | ||
1064 | fw_name = WL127X_AP_FW_NAME; | ||
1065 | break; | ||
1066 | case BSS_TYPE_IBSS: | ||
1067 | case BSS_TYPE_STA_BSS: | ||
1068 | if (wl->chip.id == CHIP_ID_1283_PG20) | ||
1069 | fw_name = WL128X_FW_NAME; | ||
1070 | else | ||
1071 | fw_name = WL1271_FW_NAME; | ||
1072 | break; | ||
1073 | default: | ||
1074 | wl1271_error("no compatible firmware for bss_type %d", | ||
1075 | wl->bss_type); | ||
1076 | return -EINVAL; | ||
1077 | } | ||
1078 | |||
1079 | wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name); | ||
1080 | |||
1081 | ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl)); | ||
1082 | |||
1083 | if (ret < 0) { | ||
1084 | wl1271_error("could not get firmware: %d", ret); | ||
1085 | return ret; | ||
1086 | } | ||
1087 | |||
1088 | if (fw->size % 4) { | ||
1089 | wl1271_error("firmware size is not multiple of 32 bits: %zu", | ||
1090 | fw->size); | ||
1091 | ret = -EILSEQ; | ||
1092 | goto out; | ||
1093 | } | ||
1094 | |||
1095 | vfree(wl->fw); | ||
1096 | wl->fw_len = fw->size; | ||
1097 | wl->fw = vmalloc(wl->fw_len); | ||
1098 | |||
1099 | if (!wl->fw) { | ||
1100 | wl1271_error("could not allocate memory for the firmware"); | ||
1101 | ret = -ENOMEM; | ||
1102 | goto out; | ||
1103 | } | ||
1104 | |||
1105 | memcpy(wl->fw, fw->data, wl->fw_len); | ||
1106 | wl->fw_bss_type = wl->bss_type; | ||
1107 | ret = 0; | ||
1108 | |||
1109 | out: | ||
1110 | release_firmware(fw); | ||
1111 | |||
1112 | return ret; | ||
1113 | } | ||
1114 | |||
1115 | static int wl1271_fetch_nvs(struct wl1271 *wl) | ||
1116 | { | ||
1117 | const struct firmware *fw; | ||
1118 | int ret; | ||
1119 | |||
1120 | ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl)); | ||
1121 | |||
1122 | if (ret < 0) { | ||
1123 | wl1271_error("could not get nvs file: %d", ret); | ||
1124 | return ret; | ||
1125 | } | ||
1126 | |||
1127 | wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL); | ||
1128 | |||
1129 | if (!wl->nvs) { | ||
1130 | wl1271_error("could not allocate memory for the nvs file"); | ||
1131 | ret = -ENOMEM; | ||
1132 | goto out; | ||
1133 | } | ||
1134 | |||
1135 | wl->nvs_len = fw->size; | ||
1136 | |||
1137 | out: | ||
1138 | release_firmware(fw); | ||
1139 | |||
1140 | return ret; | ||
1141 | } | ||
1142 | |||
1143 | void wl12xx_queue_recovery_work(struct wl1271 *wl) | ||
1144 | { | ||
1145 | if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) | ||
1146 | ieee80211_queue_work(wl->hw, &wl->recovery_work); | ||
1147 | } | ||
1148 | |||
1149 | size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen) | ||
1150 | { | ||
1151 | size_t len = 0; | ||
1152 | |||
1153 | /* The FW log is a length-value list, find where the log end */ | ||
1154 | while (len < maxlen) { | ||
1155 | if (memblock[len] == 0) | ||
1156 | break; | ||
1157 | if (len + memblock[len] + 1 > maxlen) | ||
1158 | break; | ||
1159 | len += memblock[len] + 1; | ||
1160 | } | ||
1161 | |||
1162 | /* Make sure we have enough room */ | ||
1163 | len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size)); | ||
1164 | |||
1165 | /* Fill the FW log file, consumed by the sysfs fwlog entry */ | ||
1166 | memcpy(wl->fwlog + wl->fwlog_size, memblock, len); | ||
1167 | wl->fwlog_size += len; | ||
1168 | |||
1169 | return len; | ||
1170 | } | ||
1171 | |||
1172 | static void wl12xx_read_fwlog_panic(struct wl1271 *wl) | ||
1173 | { | ||
1174 | u32 addr; | ||
1175 | u32 first_addr; | ||
1176 | u8 *block; | ||
1177 | |||
1178 | if ((wl->quirks & WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED) || | ||
1179 | (wl->conf.fwlog.mode != WL12XX_FWLOG_ON_DEMAND) || | ||
1180 | (wl->conf.fwlog.mem_blocks == 0)) | ||
1181 | return; | ||
1182 | |||
1183 | wl1271_info("Reading FW panic log"); | ||
1184 | |||
1185 | block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL); | ||
1186 | if (!block) | ||
1187 | return; | ||
1188 | |||
1189 | /* | ||
1190 | * Make sure the chip is awake and the logger isn't active. | ||
1191 | * This might fail if the firmware hanged. | ||
1192 | */ | ||
1193 | if (!wl1271_ps_elp_wakeup(wl)) | ||
1194 | wl12xx_cmd_stop_fwlog(wl); | ||
1195 | |||
1196 | /* Read the first memory block address */ | ||
1197 | wl1271_fw_status(wl, wl->fw_status); | ||
1198 | first_addr = __le32_to_cpu(wl->fw_status->sta.log_start_addr); | ||
1199 | if (!first_addr) | ||
1200 | goto out; | ||
1201 | |||
1202 | /* Traverse the memory blocks linked list */ | ||
1203 | addr = first_addr; | ||
1204 | do { | ||
1205 | memset(block, 0, WL12XX_HW_BLOCK_SIZE); | ||
1206 | wl1271_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE, | ||
1207 | false); | ||
1208 | |||
1209 | /* | ||
1210 | * Memory blocks are linked to one another. The first 4 bytes | ||
1211 | * of each memory block hold the hardware address of the next | ||
1212 | * one. The last memory block points to the first one. | ||
1213 | */ | ||
1214 | addr = __le32_to_cpup((__le32 *)block); | ||
1215 | if (!wl12xx_copy_fwlog(wl, block + sizeof(addr), | ||
1216 | WL12XX_HW_BLOCK_SIZE - sizeof(addr))) | ||
1217 | break; | ||
1218 | } while (addr && (addr != first_addr)); | ||
1219 | |||
1220 | wake_up_interruptible(&wl->fwlog_waitq); | ||
1221 | |||
1222 | out: | ||
1223 | kfree(block); | ||
1224 | } | ||
1225 | |||
1226 | static void wl1271_recovery_work(struct work_struct *work) | ||
1227 | { | ||
1228 | struct wl1271 *wl = | ||
1229 | container_of(work, struct wl1271, recovery_work); | ||
1230 | |||
1231 | mutex_lock(&wl->mutex); | ||
1232 | |||
1233 | if (wl->state != WL1271_STATE_ON) | ||
1234 | goto out; | ||
1235 | |||
1236 | /* Avoid a recursive recovery */ | ||
1237 | set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags); | ||
1238 | |||
1239 | wl12xx_read_fwlog_panic(wl); | ||
1240 | |||
1241 | wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x", | ||
1242 | wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4)); | ||
1243 | |||
1244 | /* | ||
1245 | * Advance security sequence number to overcome potential progress | ||
1246 | * in the firmware during recovery. This doens't hurt if the network is | ||
1247 | * not encrypted. | ||
1248 | */ | ||
1249 | if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) || | ||
1250 | test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) | ||
1251 | wl->tx_security_seq += WL1271_TX_SQN_POST_RECOVERY_PADDING; | ||
1252 | |||
1253 | if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) | ||
1254 | ieee80211_connection_loss(wl->vif); | ||
1255 | |||
1256 | /* Prevent spurious TX during FW restart */ | ||
1257 | ieee80211_stop_queues(wl->hw); | ||
1258 | |||
1259 | if (wl->sched_scanning) { | ||
1260 | ieee80211_sched_scan_stopped(wl->hw); | ||
1261 | wl->sched_scanning = false; | ||
1262 | } | ||
1263 | |||
1264 | /* reboot the chipset */ | ||
1265 | __wl1271_op_remove_interface(wl, false); | ||
1266 | |||
1267 | clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags); | ||
1268 | |||
1269 | ieee80211_restart_hw(wl->hw); | ||
1270 | |||
1271 | /* | ||
1272 | * Its safe to enable TX now - the queues are stopped after a request | ||
1273 | * to restart the HW. | ||
1274 | */ | ||
1275 | ieee80211_wake_queues(wl->hw); | ||
1276 | |||
1277 | out: | ||
1278 | mutex_unlock(&wl->mutex); | ||
1279 | } | ||
1280 | |||
1281 | static void wl1271_fw_wakeup(struct wl1271 *wl) | ||
1282 | { | ||
1283 | u32 elp_reg; | ||
1284 | |||
1285 | elp_reg = ELPCTRL_WAKE_UP; | ||
1286 | wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg); | ||
1287 | } | ||
1288 | |||
1289 | static int wl1271_setup(struct wl1271 *wl) | ||
1290 | { | ||
1291 | wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL); | ||
1292 | if (!wl->fw_status) | ||
1293 | return -ENOMEM; | ||
1294 | |||
1295 | wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL); | ||
1296 | if (!wl->tx_res_if) { | ||
1297 | kfree(wl->fw_status); | ||
1298 | return -ENOMEM; | ||
1299 | } | ||
1300 | |||
1301 | return 0; | ||
1302 | } | ||
1303 | |||
1304 | static int wl1271_chip_wakeup(struct wl1271 *wl) | ||
1305 | { | ||
1306 | struct wl1271_partition_set partition; | ||
1307 | int ret = 0; | ||
1308 | |||
1309 | msleep(WL1271_PRE_POWER_ON_SLEEP); | ||
1310 | ret = wl1271_power_on(wl); | ||
1311 | if (ret < 0) | ||
1312 | goto out; | ||
1313 | msleep(WL1271_POWER_ON_SLEEP); | ||
1314 | wl1271_io_reset(wl); | ||
1315 | wl1271_io_init(wl); | ||
1316 | |||
1317 | /* We don't need a real memory partition here, because we only want | ||
1318 | * to use the registers at this point. */ | ||
1319 | memset(&partition, 0, sizeof(partition)); | ||
1320 | partition.reg.start = REGISTERS_BASE; | ||
1321 | partition.reg.size = REGISTERS_DOWN_SIZE; | ||
1322 | wl1271_set_partition(wl, &partition); | ||
1323 | |||
1324 | /* ELP module wake up */ | ||
1325 | wl1271_fw_wakeup(wl); | ||
1326 | |||
1327 | /* whal_FwCtrl_BootSm() */ | ||
1328 | |||
1329 | /* 0. read chip id from CHIP_ID */ | ||
1330 | wl->chip.id = wl1271_read32(wl, CHIP_ID_B); | ||
1331 | |||
1332 | /* 1. check if chip id is valid */ | ||
1333 | |||
1334 | switch (wl->chip.id) { | ||
1335 | case CHIP_ID_1271_PG10: | ||
1336 | wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete", | ||
1337 | wl->chip.id); | ||
1338 | |||
1339 | ret = wl1271_setup(wl); | ||
1340 | if (ret < 0) | ||
1341 | goto out; | ||
1342 | break; | ||
1343 | case CHIP_ID_1271_PG20: | ||
1344 | wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)", | ||
1345 | wl->chip.id); | ||
1346 | |||
1347 | /* | ||
1348 | * 'end-of-transaction flag' and 'LPD mode flag' | ||
1349 | * should be set in wl127x AP mode only | ||
1350 | */ | ||
1351 | if (wl->bss_type == BSS_TYPE_AP_BSS) | ||
1352 | wl->quirks |= (WL12XX_QUIRK_END_OF_TRANSACTION | | ||
1353 | WL12XX_QUIRK_LPD_MODE); | ||
1354 | |||
1355 | ret = wl1271_setup(wl); | ||
1356 | if (ret < 0) | ||
1357 | goto out; | ||
1358 | break; | ||
1359 | case CHIP_ID_1283_PG20: | ||
1360 | wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)", | ||
1361 | wl->chip.id); | ||
1362 | |||
1363 | ret = wl1271_setup(wl); | ||
1364 | if (ret < 0) | ||
1365 | goto out; | ||
1366 | |||
1367 | if (wl1271_set_block_size(wl)) | ||
1368 | wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT; | ||
1369 | break; | ||
1370 | case CHIP_ID_1283_PG10: | ||
1371 | default: | ||
1372 | wl1271_warning("unsupported chip id: 0x%x", wl->chip.id); | ||
1373 | ret = -ENODEV; | ||
1374 | goto out; | ||
1375 | } | ||
1376 | |||
1377 | /* Make sure the firmware type matches the BSS type */ | ||
1378 | if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) { | ||
1379 | ret = wl1271_fetch_firmware(wl); | ||
1380 | if (ret < 0) | ||
1381 | goto out; | ||
1382 | } | ||
1383 | |||
1384 | /* No NVS from netlink, try to get it from the filesystem */ | ||
1385 | if (wl->nvs == NULL) { | ||
1386 | ret = wl1271_fetch_nvs(wl); | ||
1387 | if (ret < 0) | ||
1388 | goto out; | ||
1389 | } | ||
1390 | |||
1391 | out: | ||
1392 | return ret; | ||
1393 | } | ||
1394 | |||
1395 | int wl1271_plt_start(struct wl1271 *wl) | ||
1396 | { | ||
1397 | int retries = WL1271_BOOT_RETRIES; | ||
1398 | int ret; | ||
1399 | |||
1400 | mutex_lock(&wl->mutex); | ||
1401 | |||
1402 | wl1271_notice("power up"); | ||
1403 | |||
1404 | if (wl->state != WL1271_STATE_OFF) { | ||
1405 | wl1271_error("cannot go into PLT state because not " | ||
1406 | "in off state: %d", wl->state); | ||
1407 | ret = -EBUSY; | ||
1408 | goto out; | ||
1409 | } | ||
1410 | |||
1411 | wl->bss_type = BSS_TYPE_STA_BSS; | ||
1412 | |||
1413 | while (retries) { | ||
1414 | retries--; | ||
1415 | ret = wl1271_chip_wakeup(wl); | ||
1416 | if (ret < 0) | ||
1417 | goto power_off; | ||
1418 | |||
1419 | ret = wl1271_boot(wl); | ||
1420 | if (ret < 0) | ||
1421 | goto power_off; | ||
1422 | |||
1423 | ret = wl1271_plt_init(wl); | ||
1424 | if (ret < 0) | ||
1425 | goto irq_disable; | ||
1426 | |||
1427 | wl->state = WL1271_STATE_PLT; | ||
1428 | wl1271_notice("firmware booted in PLT mode (%s)", | ||
1429 | wl->chip.fw_ver_str); | ||
1430 | |||
1431 | goto out; | ||
1432 | |||
1433 | irq_disable: | ||
1434 | mutex_unlock(&wl->mutex); | ||
1435 | /* Unlocking the mutex in the middle of handling is | ||
1436 | inherently unsafe. In this case we deem it safe to do, | ||
1437 | because we need to let any possibly pending IRQ out of | ||
1438 | the system (and while we are WL1271_STATE_OFF the IRQ | ||
1439 | work function will not do anything.) Also, any other | ||
1440 | possible concurrent operations will fail due to the | ||
1441 | current state, hence the wl1271 struct should be safe. */ | ||
1442 | wl1271_disable_interrupts(wl); | ||
1443 | wl1271_flush_deferred_work(wl); | ||
1444 | cancel_work_sync(&wl->netstack_work); | ||
1445 | mutex_lock(&wl->mutex); | ||
1446 | power_off: | ||
1447 | wl1271_power_off(wl); | ||
1448 | } | ||
1449 | |||
1450 | wl1271_error("firmware boot in PLT mode failed despite %d retries", | ||
1451 | WL1271_BOOT_RETRIES); | ||
1452 | out: | ||
1453 | mutex_unlock(&wl->mutex); | ||
1454 | |||
1455 | return ret; | ||
1456 | } | ||
1457 | |||
1458 | static int __wl1271_plt_stop(struct wl1271 *wl) | ||
1459 | { | ||
1460 | int ret = 0; | ||
1461 | |||
1462 | wl1271_notice("power down"); | ||
1463 | |||
1464 | if (wl->state != WL1271_STATE_PLT) { | ||
1465 | wl1271_error("cannot power down because not in PLT " | ||
1466 | "state: %d", wl->state); | ||
1467 | ret = -EBUSY; | ||
1468 | goto out; | ||
1469 | } | ||
1470 | |||
1471 | wl1271_power_off(wl); | ||
1472 | |||
1473 | wl->state = WL1271_STATE_OFF; | ||
1474 | wl->rx_counter = 0; | ||
1475 | |||
1476 | mutex_unlock(&wl->mutex); | ||
1477 | wl1271_disable_interrupts(wl); | ||
1478 | wl1271_flush_deferred_work(wl); | ||
1479 | cancel_work_sync(&wl->netstack_work); | ||
1480 | cancel_work_sync(&wl->recovery_work); | ||
1481 | mutex_lock(&wl->mutex); | ||
1482 | out: | ||
1483 | return ret; | ||
1484 | } | ||
1485 | |||
1486 | int wl1271_plt_stop(struct wl1271 *wl) | ||
1487 | { | ||
1488 | int ret; | ||
1489 | |||
1490 | mutex_lock(&wl->mutex); | ||
1491 | ret = __wl1271_plt_stop(wl); | ||
1492 | mutex_unlock(&wl->mutex); | ||
1493 | return ret; | ||
1494 | } | ||
1495 | |||
1496 | static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb) | ||
1497 | { | ||
1498 | struct wl1271 *wl = hw->priv; | ||
1499 | unsigned long flags; | ||
1500 | int q, mapping; | ||
1501 | u8 hlid = 0; | ||
1502 | |||
1503 | mapping = skb_get_queue_mapping(skb); | ||
1504 | q = wl1271_tx_get_queue(mapping); | ||
1505 | |||
1506 | if (wl->bss_type == BSS_TYPE_AP_BSS) | ||
1507 | hlid = wl1271_tx_get_hlid(skb); | ||
1508 | |||
1509 | spin_lock_irqsave(&wl->wl_lock, flags); | ||
1510 | |||
1511 | wl->tx_queue_count[q]++; | ||
1512 | |||
1513 | /* | ||
1514 | * The workqueue is slow to process the tx_queue and we need stop | ||
1515 | * the queue here, otherwise the queue will get too long. | ||
1516 | */ | ||
1517 | if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) { | ||
1518 | wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q); | ||
1519 | ieee80211_stop_queue(wl->hw, mapping); | ||
1520 | set_bit(q, &wl->stopped_queues_map); | ||
1521 | } | ||
1522 | |||
1523 | /* queue the packet */ | ||
1524 | if (wl->bss_type == BSS_TYPE_AP_BSS) { | ||
1525 | wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q); | ||
1526 | skb_queue_tail(&wl->links[hlid].tx_queue[q], skb); | ||
1527 | } else { | ||
1528 | skb_queue_tail(&wl->tx_queue[q], skb); | ||
1529 | } | ||
1530 | |||
1531 | /* | ||
1532 | * The chip specific setup must run before the first TX packet - | ||
1533 | * before that, the tx_work will not be initialized! | ||
1534 | */ | ||
1535 | |||
1536 | if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) && | ||
1537 | !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags)) | ||
1538 | ieee80211_queue_work(wl->hw, &wl->tx_work); | ||
1539 | |||
1540 | spin_unlock_irqrestore(&wl->wl_lock, flags); | ||
1541 | } | ||
1542 | |||
1543 | int wl1271_tx_dummy_packet(struct wl1271 *wl) | ||
1544 | { | ||
1545 | unsigned long flags; | ||
1546 | int q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet)); | ||
1547 | |||
1548 | spin_lock_irqsave(&wl->wl_lock, flags); | ||
1549 | set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags); | ||
1550 | wl->tx_queue_count[q]++; | ||
1551 | spin_unlock_irqrestore(&wl->wl_lock, flags); | ||
1552 | |||
1553 | /* The FW is low on RX memory blocks, so send the dummy packet asap */ | ||
1554 | if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags)) | ||
1555 | wl1271_tx_work_locked(wl); | ||
1556 | |||
1557 | /* | ||
1558 | * If the FW TX is busy, TX work will be scheduled by the threaded | ||
1559 | * interrupt handler function | ||
1560 | */ | ||
1561 | return 0; | ||
1562 | } | ||
1563 | |||
1564 | /* | ||
1565 | * The size of the dummy packet should be at least 1400 bytes. However, in | ||
1566 | * order to minimize the number of bus transactions, aligning it to 512 bytes | ||
1567 | * boundaries could be beneficial, performance wise | ||
1568 | */ | ||
1569 | #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512)) | ||
1570 | |||
1571 | static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl) | ||
1572 | { | ||
1573 | struct sk_buff *skb; | ||
1574 | struct ieee80211_hdr_3addr *hdr; | ||
1575 | unsigned int dummy_packet_size; | ||
1576 | |||
1577 | dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE - | ||
1578 | sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr); | ||
1579 | |||
1580 | skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE); | ||
1581 | if (!skb) { | ||
1582 | wl1271_warning("Failed to allocate a dummy packet skb"); | ||
1583 | return NULL; | ||
1584 | } | ||
1585 | |||
1586 | skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr)); | ||
1587 | |||
1588 | hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr)); | ||
1589 | memset(hdr, 0, sizeof(*hdr)); | ||
1590 | hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | | ||
1591 | IEEE80211_STYPE_NULLFUNC | | ||
1592 | IEEE80211_FCTL_TODS); | ||
1593 | |||
1594 | memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size); | ||
1595 | |||
1596 | /* Dummy packets require the TID to be management */ | ||
1597 | skb->priority = WL1271_TID_MGMT; | ||
1598 | |||
1599 | /* Initialize all fields that might be used */ | ||
1600 | skb_set_queue_mapping(skb, 0); | ||
1601 | memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info)); | ||
1602 | |||
1603 | return skb; | ||
1604 | } | ||
1605 | |||
1606 | |||
1607 | static struct notifier_block wl1271_dev_notifier = { | ||
1608 | .notifier_call = wl1271_dev_notify, | ||
1609 | }; | ||
1610 | |||
1611 | #ifdef CONFIG_PM | ||
1612 | static int wl1271_configure_suspend_sta(struct wl1271 *wl) | ||
1613 | { | ||
1614 | int ret = 0; | ||
1615 | |||
1616 | mutex_lock(&wl->mutex); | ||
1617 | |||
1618 | if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) | ||
1619 | goto out_unlock; | ||
1620 | |||
1621 | ret = wl1271_ps_elp_wakeup(wl); | ||
1622 | if (ret < 0) | ||
1623 | goto out_unlock; | ||
1624 | |||
1625 | /* enter psm if needed*/ | ||
1626 | if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) { | ||
1627 | DECLARE_COMPLETION_ONSTACK(compl); | ||
1628 | |||
1629 | wl->ps_compl = &compl; | ||
1630 | ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE, | ||
1631 | wl->basic_rate, true); | ||
1632 | if (ret < 0) | ||
1633 | goto out_sleep; | ||
1634 | |||
1635 | /* we must unlock here so we will be able to get events */ | ||
1636 | wl1271_ps_elp_sleep(wl); | ||
1637 | mutex_unlock(&wl->mutex); | ||
1638 | |||
1639 | ret = wait_for_completion_timeout( | ||
1640 | &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT)); | ||
1641 | if (ret <= 0) { | ||
1642 | wl1271_warning("couldn't enter ps mode!"); | ||
1643 | ret = -EBUSY; | ||
1644 | goto out; | ||
1645 | } | ||
1646 | |||
1647 | /* take mutex again, and wakeup */ | ||
1648 | mutex_lock(&wl->mutex); | ||
1649 | |||
1650 | ret = wl1271_ps_elp_wakeup(wl); | ||
1651 | if (ret < 0) | ||
1652 | goto out_unlock; | ||
1653 | } | ||
1654 | out_sleep: | ||
1655 | wl1271_ps_elp_sleep(wl); | ||
1656 | out_unlock: | ||
1657 | mutex_unlock(&wl->mutex); | ||
1658 | out: | ||
1659 | return ret; | ||
1660 | |||
1661 | } | ||
1662 | |||
1663 | static int wl1271_configure_suspend_ap(struct wl1271 *wl) | ||
1664 | { | ||
1665 | int ret = 0; | ||
1666 | |||
1667 | mutex_lock(&wl->mutex); | ||
1668 | |||
1669 | if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) | ||
1670 | goto out_unlock; | ||
1671 | |||
1672 | ret = wl1271_ps_elp_wakeup(wl); | ||
1673 | if (ret < 0) | ||
1674 | goto out_unlock; | ||
1675 | |||
1676 | ret = wl1271_acx_set_ap_beacon_filter(wl, true); | ||
1677 | |||
1678 | wl1271_ps_elp_sleep(wl); | ||
1679 | out_unlock: | ||
1680 | mutex_unlock(&wl->mutex); | ||
1681 | return ret; | ||
1682 | |||
1683 | } | ||
1684 | |||
1685 | static int wl1271_configure_suspend(struct wl1271 *wl) | ||
1686 | { | ||
1687 | if (wl->bss_type == BSS_TYPE_STA_BSS) | ||
1688 | return wl1271_configure_suspend_sta(wl); | ||
1689 | if (wl->bss_type == BSS_TYPE_AP_BSS) | ||
1690 | return wl1271_configure_suspend_ap(wl); | ||
1691 | return 0; | ||
1692 | } | ||
1693 | |||
1694 | static void wl1271_configure_resume(struct wl1271 *wl) | ||
1695 | { | ||
1696 | int ret; | ||
1697 | bool is_sta = wl->bss_type == BSS_TYPE_STA_BSS; | ||
1698 | bool is_ap = wl->bss_type == BSS_TYPE_AP_BSS; | ||
1699 | |||
1700 | if (!is_sta && !is_ap) | ||
1701 | return; | ||
1702 | |||
1703 | mutex_lock(&wl->mutex); | ||
1704 | ret = wl1271_ps_elp_wakeup(wl); | ||
1705 | if (ret < 0) | ||
1706 | goto out; | ||
1707 | |||
1708 | if (is_sta) { | ||
1709 | /* exit psm if it wasn't configured */ | ||
1710 | if (!test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) | ||
1711 | wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE, | ||
1712 | wl->basic_rate, true); | ||
1713 | } else if (is_ap) { | ||
1714 | wl1271_acx_set_ap_beacon_filter(wl, false); | ||
1715 | } | ||
1716 | |||
1717 | wl1271_ps_elp_sleep(wl); | ||
1718 | out: | ||
1719 | mutex_unlock(&wl->mutex); | ||
1720 | } | ||
1721 | |||
1722 | static int wl1271_op_suspend(struct ieee80211_hw *hw, | ||
1723 | struct cfg80211_wowlan *wow) | ||
1724 | { | ||
1725 | struct wl1271 *wl = hw->priv; | ||
1726 | int ret; | ||
1727 | |||
1728 | wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow); | ||
1729 | WARN_ON(!wow || !wow->any); | ||
1730 | |||
1731 | wl->wow_enabled = true; | ||
1732 | ret = wl1271_configure_suspend(wl); | ||
1733 | if (ret < 0) { | ||
1734 | wl1271_warning("couldn't prepare device to suspend"); | ||
1735 | return ret; | ||
1736 | } | ||
1737 | /* flush any remaining work */ | ||
1738 | wl1271_debug(DEBUG_MAC80211, "flushing remaining works"); | ||
1739 | |||
1740 | /* | ||
1741 | * disable and re-enable interrupts in order to flush | ||
1742 | * the threaded_irq | ||
1743 | */ | ||
1744 | wl1271_disable_interrupts(wl); | ||
1745 | |||
1746 | /* | ||
1747 | * set suspended flag to avoid triggering a new threaded_irq | ||
1748 | * work. no need for spinlock as interrupts are disabled. | ||
1749 | */ | ||
1750 | set_bit(WL1271_FLAG_SUSPENDED, &wl->flags); | ||
1751 | |||
1752 | wl1271_enable_interrupts(wl); | ||
1753 | flush_work(&wl->tx_work); | ||
1754 | flush_delayed_work(&wl->pspoll_work); | ||
1755 | flush_delayed_work(&wl->elp_work); | ||
1756 | |||
1757 | return 0; | ||
1758 | } | ||
1759 | |||
1760 | static int wl1271_op_resume(struct ieee80211_hw *hw) | ||
1761 | { | ||
1762 | struct wl1271 *wl = hw->priv; | ||
1763 | unsigned long flags; | ||
1764 | bool run_irq_work = false; | ||
1765 | |||
1766 | wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d", | ||
1767 | wl->wow_enabled); | ||
1768 | WARN_ON(!wl->wow_enabled); | ||
1769 | |||
1770 | /* | ||
1771 | * re-enable irq_work enqueuing, and call irq_work directly if | ||
1772 | * there is a pending work. | ||
1773 | */ | ||
1774 | spin_lock_irqsave(&wl->wl_lock, flags); | ||
1775 | clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags); | ||
1776 | if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags)) | ||
1777 | run_irq_work = true; | ||
1778 | spin_unlock_irqrestore(&wl->wl_lock, flags); | ||
1779 | |||
1780 | if (run_irq_work) { | ||
1781 | wl1271_debug(DEBUG_MAC80211, | ||
1782 | "run postponed irq_work directly"); | ||
1783 | wl1271_irq(0, wl); | ||
1784 | wl1271_enable_interrupts(wl); | ||
1785 | } | ||
1786 | wl1271_configure_resume(wl); | ||
1787 | wl->wow_enabled = false; | ||
1788 | |||
1789 | return 0; | ||
1790 | } | ||
1791 | #endif | ||
1792 | |||
1793 | static int wl1271_op_start(struct ieee80211_hw *hw) | ||
1794 | { | ||
1795 | wl1271_debug(DEBUG_MAC80211, "mac80211 start"); | ||
1796 | |||
1797 | /* | ||
1798 | * We have to delay the booting of the hardware because | ||
1799 | * we need to know the local MAC address before downloading and | ||
1800 | * initializing the firmware. The MAC address cannot be changed | ||
1801 | * after boot, and without the proper MAC address, the firmware | ||
1802 | * will not function properly. | ||
1803 | * | ||
1804 | * The MAC address is first known when the corresponding interface | ||
1805 | * is added. That is where we will initialize the hardware. | ||
1806 | * | ||
1807 | * In addition, we currently have different firmwares for AP and managed | ||
1808 | * operation. We will know which to boot according to interface type. | ||
1809 | */ | ||
1810 | |||
1811 | return 0; | ||
1812 | } | ||
1813 | |||
1814 | static void wl1271_op_stop(struct ieee80211_hw *hw) | ||
1815 | { | ||
1816 | wl1271_debug(DEBUG_MAC80211, "mac80211 stop"); | ||
1817 | } | ||
1818 | |||
1819 | static int wl1271_op_add_interface(struct ieee80211_hw *hw, | ||
1820 | struct ieee80211_vif *vif) | ||
1821 | { | ||
1822 | struct wl1271 *wl = hw->priv; | ||
1823 | struct wiphy *wiphy = hw->wiphy; | ||
1824 | int retries = WL1271_BOOT_RETRIES; | ||
1825 | int ret = 0; | ||
1826 | bool booted = false; | ||
1827 | |||
1828 | wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM", | ||
1829 | vif->type, vif->addr); | ||
1830 | |||
1831 | mutex_lock(&wl->mutex); | ||
1832 | if (wl->vif) { | ||
1833 | wl1271_debug(DEBUG_MAC80211, | ||
1834 | "multiple vifs are not supported yet"); | ||
1835 | ret = -EBUSY; | ||
1836 | goto out; | ||
1837 | } | ||
1838 | |||
1839 | /* | ||
1840 | * in some very corner case HW recovery scenarios its possible to | ||
1841 | * get here before __wl1271_op_remove_interface is complete, so | ||
1842 | * opt out if that is the case. | ||
1843 | */ | ||
1844 | if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) { | ||
1845 | ret = -EBUSY; | ||
1846 | goto out; | ||
1847 | } | ||
1848 | |||
1849 | switch (vif->type) { | ||
1850 | case NL80211_IFTYPE_STATION: | ||
1851 | wl->bss_type = BSS_TYPE_STA_BSS; | ||
1852 | wl->set_bss_type = BSS_TYPE_STA_BSS; | ||
1853 | break; | ||
1854 | case NL80211_IFTYPE_ADHOC: | ||
1855 | wl->bss_type = BSS_TYPE_IBSS; | ||
1856 | wl->set_bss_type = BSS_TYPE_STA_BSS; | ||
1857 | break; | ||
1858 | case NL80211_IFTYPE_AP: | ||
1859 | wl->bss_type = BSS_TYPE_AP_BSS; | ||
1860 | break; | ||
1861 | default: | ||
1862 | ret = -EOPNOTSUPP; | ||
1863 | goto out; | ||
1864 | } | ||
1865 | |||
1866 | memcpy(wl->mac_addr, vif->addr, ETH_ALEN); | ||
1867 | |||
1868 | if (wl->state != WL1271_STATE_OFF) { | ||
1869 | wl1271_error("cannot start because not in off state: %d", | ||
1870 | wl->state); | ||
1871 | ret = -EBUSY; | ||
1872 | goto out; | ||
1873 | } | ||
1874 | |||
1875 | while (retries) { | ||
1876 | retries--; | ||
1877 | ret = wl1271_chip_wakeup(wl); | ||
1878 | if (ret < 0) | ||
1879 | goto power_off; | ||
1880 | |||
1881 | ret = wl1271_boot(wl); | ||
1882 | if (ret < 0) | ||
1883 | goto power_off; | ||
1884 | |||
1885 | ret = wl1271_hw_init(wl); | ||
1886 | if (ret < 0) | ||
1887 | goto irq_disable; | ||
1888 | |||
1889 | booted = true; | ||
1890 | break; | ||
1891 | |||
1892 | irq_disable: | ||
1893 | mutex_unlock(&wl->mutex); | ||
1894 | /* Unlocking the mutex in the middle of handling is | ||
1895 | inherently unsafe. In this case we deem it safe to do, | ||
1896 | because we need to let any possibly pending IRQ out of | ||
1897 | the system (and while we are WL1271_STATE_OFF the IRQ | ||
1898 | work function will not do anything.) Also, any other | ||
1899 | possible concurrent operations will fail due to the | ||
1900 | current state, hence the wl1271 struct should be safe. */ | ||
1901 | wl1271_disable_interrupts(wl); | ||
1902 | wl1271_flush_deferred_work(wl); | ||
1903 | cancel_work_sync(&wl->netstack_work); | ||
1904 | mutex_lock(&wl->mutex); | ||
1905 | power_off: | ||
1906 | wl1271_power_off(wl); | ||
1907 | } | ||
1908 | |||
1909 | if (!booted) { | ||
1910 | wl1271_error("firmware boot failed despite %d retries", | ||
1911 | WL1271_BOOT_RETRIES); | ||
1912 | goto out; | ||
1913 | } | ||
1914 | |||
1915 | wl->vif = vif; | ||
1916 | wl->state = WL1271_STATE_ON; | ||
1917 | set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags); | ||
1918 | wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str); | ||
1919 | |||
1920 | /* update hw/fw version info in wiphy struct */ | ||
1921 | wiphy->hw_version = wl->chip.id; | ||
1922 | strncpy(wiphy->fw_version, wl->chip.fw_ver_str, | ||
1923 | sizeof(wiphy->fw_version)); | ||
1924 | |||
1925 | /* | ||
1926 | * Now we know if 11a is supported (info from the NVS), so disable | ||
1927 | * 11a channels if not supported | ||
1928 | */ | ||
1929 | if (!wl->enable_11a) | ||
1930 | wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0; | ||
1931 | |||
1932 | wl1271_debug(DEBUG_MAC80211, "11a is %ssupported", | ||
1933 | wl->enable_11a ? "" : "not "); | ||
1934 | |||
1935 | out: | ||
1936 | mutex_unlock(&wl->mutex); | ||
1937 | |||
1938 | mutex_lock(&wl_list_mutex); | ||
1939 | if (!ret) | ||
1940 | list_add(&wl->list, &wl_list); | ||
1941 | mutex_unlock(&wl_list_mutex); | ||
1942 | |||
1943 | return ret; | ||
1944 | } | ||
1945 | |||
1946 | static void __wl1271_op_remove_interface(struct wl1271 *wl, | ||
1947 | bool reset_tx_queues) | ||
1948 | { | ||
1949 | int i; | ||
1950 | |||
1951 | wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface"); | ||
1952 | |||
1953 | /* because of hardware recovery, we may get here twice */ | ||
1954 | if (wl->state != WL1271_STATE_ON) | ||
1955 | return; | ||
1956 | |||
1957 | wl1271_info("down"); | ||
1958 | |||
1959 | mutex_lock(&wl_list_mutex); | ||
1960 | list_del(&wl->list); | ||
1961 | mutex_unlock(&wl_list_mutex); | ||
1962 | |||
1963 | /* enable dyn ps just in case (if left on due to fw crash etc) */ | ||
1964 | if (wl->bss_type == BSS_TYPE_STA_BSS) | ||
1965 | ieee80211_enable_dyn_ps(wl->vif); | ||
1966 | |||
1967 | if (wl->scan.state != WL1271_SCAN_STATE_IDLE) { | ||
1968 | wl->scan.state = WL1271_SCAN_STATE_IDLE; | ||
1969 | memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch)); | ||
1970 | wl->scan.req = NULL; | ||
1971 | ieee80211_scan_completed(wl->hw, true); | ||
1972 | } | ||
1973 | |||
1974 | /* | ||
1975 | * this must be before the cancel_work calls below, so that the work | ||
1976 | * functions don't perform further work. | ||
1977 | */ | ||
1978 | wl->state = WL1271_STATE_OFF; | ||
1979 | |||
1980 | mutex_unlock(&wl->mutex); | ||
1981 | |||
1982 | wl1271_disable_interrupts(wl); | ||
1983 | wl1271_flush_deferred_work(wl); | ||
1984 | cancel_delayed_work_sync(&wl->scan_complete_work); | ||
1985 | cancel_work_sync(&wl->netstack_work); | ||
1986 | cancel_work_sync(&wl->tx_work); | ||
1987 | del_timer_sync(&wl->rx_streaming_timer); | ||
1988 | cancel_work_sync(&wl->rx_streaming_enable_work); | ||
1989 | cancel_work_sync(&wl->rx_streaming_disable_work); | ||
1990 | cancel_delayed_work_sync(&wl->pspoll_work); | ||
1991 | cancel_delayed_work_sync(&wl->elp_work); | ||
1992 | |||
1993 | mutex_lock(&wl->mutex); | ||
1994 | |||
1995 | /* let's notify MAC80211 about the remaining pending TX frames */ | ||
1996 | wl1271_tx_reset(wl, reset_tx_queues); | ||
1997 | wl1271_power_off(wl); | ||
1998 | |||
1999 | memset(wl->bssid, 0, ETH_ALEN); | ||
2000 | memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1); | ||
2001 | wl->ssid_len = 0; | ||
2002 | wl->bss_type = MAX_BSS_TYPE; | ||
2003 | wl->set_bss_type = MAX_BSS_TYPE; | ||
2004 | wl->band = IEEE80211_BAND_2GHZ; | ||
2005 | |||
2006 | wl->rx_counter = 0; | ||
2007 | wl->psm_entry_retry = 0; | ||
2008 | wl->power_level = WL1271_DEFAULT_POWER_LEVEL; | ||
2009 | wl->tx_blocks_available = 0; | ||
2010 | wl->tx_results_count = 0; | ||
2011 | wl->tx_packets_count = 0; | ||
2012 | wl->time_offset = 0; | ||
2013 | wl->session_counter = 0; | ||
2014 | wl->rate_set = CONF_TX_RATE_MASK_BASIC; | ||
2015 | wl->vif = NULL; | ||
2016 | wl->filters = 0; | ||
2017 | wl1271_free_ap_keys(wl); | ||
2018 | memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map)); | ||
2019 | wl->ap_fw_ps_map = 0; | ||
2020 | wl->ap_ps_map = 0; | ||
2021 | wl->sched_scanning = false; | ||
2022 | |||
2023 | /* | ||
2024 | * this is performed after the cancel_work calls and the associated | ||
2025 | * mutex_lock, so that wl1271_op_add_interface does not accidentally | ||
2026 | * get executed before all these vars have been reset. | ||
2027 | */ | ||
2028 | wl->flags = 0; | ||
2029 | |||
2030 | for (i = 0; i < NUM_TX_QUEUES; i++) { | ||
2031 | wl->tx_blocks_freed[i] = 0; | ||
2032 | wl->tx_allocated_blocks[i] = 0; | ||
2033 | } | ||
2034 | |||
2035 | wl1271_debugfs_reset(wl); | ||
2036 | |||
2037 | kfree(wl->fw_status); | ||
2038 | wl->fw_status = NULL; | ||
2039 | kfree(wl->tx_res_if); | ||
2040 | wl->tx_res_if = NULL; | ||
2041 | kfree(wl->target_mem_map); | ||
2042 | wl->target_mem_map = NULL; | ||
2043 | } | ||
2044 | |||
2045 | static void wl1271_op_remove_interface(struct ieee80211_hw *hw, | ||
2046 | struct ieee80211_vif *vif) | ||
2047 | { | ||
2048 | struct wl1271 *wl = hw->priv; | ||
2049 | |||
2050 | mutex_lock(&wl->mutex); | ||
2051 | /* | ||
2052 | * wl->vif can be null here if someone shuts down the interface | ||
2053 | * just when hardware recovery has been started. | ||
2054 | */ | ||
2055 | if (wl->vif) { | ||
2056 | WARN_ON(wl->vif != vif); | ||
2057 | __wl1271_op_remove_interface(wl, true); | ||
2058 | } | ||
2059 | |||
2060 | mutex_unlock(&wl->mutex); | ||
2061 | cancel_work_sync(&wl->recovery_work); | ||
2062 | } | ||
2063 | |||
2064 | void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters) | ||
2065 | { | ||
2066 | wl1271_set_default_filters(wl); | ||
2067 | |||
2068 | /* combine requested filters with current filter config */ | ||
2069 | filters = wl->filters | filters; | ||
2070 | |||
2071 | wl1271_debug(DEBUG_FILTERS, "RX filters set: "); | ||
2072 | |||
2073 | if (filters & FIF_PROMISC_IN_BSS) { | ||
2074 | wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS"); | ||
2075 | wl->rx_config &= ~CFG_UNI_FILTER_EN; | ||
2076 | wl->rx_config |= CFG_BSSID_FILTER_EN; | ||
2077 | } | ||
2078 | if (filters & FIF_BCN_PRBRESP_PROMISC) { | ||
2079 | wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC"); | ||
2080 | wl->rx_config &= ~CFG_BSSID_FILTER_EN; | ||
2081 | wl->rx_config &= ~CFG_SSID_FILTER_EN; | ||
2082 | } | ||
2083 | if (filters & FIF_OTHER_BSS) { | ||
2084 | wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS"); | ||
2085 | wl->rx_config &= ~CFG_BSSID_FILTER_EN; | ||
2086 | } | ||
2087 | if (filters & FIF_CONTROL) { | ||
2088 | wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL"); | ||
2089 | wl->rx_filter |= CFG_RX_CTL_EN; | ||
2090 | } | ||
2091 | if (filters & FIF_FCSFAIL) { | ||
2092 | wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL"); | ||
2093 | wl->rx_filter |= CFG_RX_FCS_ERROR; | ||
2094 | } | ||
2095 | } | ||
2096 | |||
2097 | static int wl1271_dummy_join(struct wl1271 *wl) | ||
2098 | { | ||
2099 | int ret = 0; | ||
2100 | /* we need to use a dummy BSSID for now */ | ||
2101 | static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde, | ||
2102 | 0xad, 0xbe, 0xef }; | ||
2103 | |||
2104 | memcpy(wl->bssid, dummy_bssid, ETH_ALEN); | ||
2105 | |||
2106 | /* pass through frames from all BSS */ | ||
2107 | wl1271_configure_filters(wl, FIF_OTHER_BSS); | ||
2108 | |||
2109 | ret = wl1271_cmd_join(wl, wl->set_bss_type); | ||
2110 | if (ret < 0) | ||
2111 | goto out; | ||
2112 | |||
2113 | set_bit(WL1271_FLAG_JOINED, &wl->flags); | ||
2114 | |||
2115 | out: | ||
2116 | return ret; | ||
2117 | } | ||
2118 | |||
2119 | static int wl1271_join(struct wl1271 *wl, bool set_assoc) | ||
2120 | { | ||
2121 | int ret; | ||
2122 | |||
2123 | /* | ||
2124 | * One of the side effects of the JOIN command is that is clears | ||
2125 | * WPA/WPA2 keys from the chipset. Performing a JOIN while associated | ||
2126 | * to a WPA/WPA2 access point will therefore kill the data-path. | ||
2127 | * Currently the only valid scenario for JOIN during association | ||
2128 | * is on roaming, in which case we will also be given new keys. | ||
2129 | * Keep the below message for now, unless it starts bothering | ||
2130 | * users who really like to roam a lot :) | ||
2131 | */ | ||
2132 | if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) | ||
2133 | wl1271_info("JOIN while associated."); | ||
2134 | |||
2135 | if (set_assoc) | ||
2136 | set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags); | ||
2137 | |||
2138 | ret = wl1271_cmd_join(wl, wl->set_bss_type); | ||
2139 | if (ret < 0) | ||
2140 | goto out; | ||
2141 | |||
2142 | set_bit(WL1271_FLAG_JOINED, &wl->flags); | ||
2143 | |||
2144 | if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) | ||
2145 | goto out; | ||
2146 | |||
2147 | /* | ||
2148 | * The join command disable the keep-alive mode, shut down its process, | ||
2149 | * and also clear the template config, so we need to reset it all after | ||
2150 | * the join. The acx_aid starts the keep-alive process, and the order | ||
2151 | * of the commands below is relevant. | ||
2152 | */ | ||
2153 | ret = wl1271_acx_keep_alive_mode(wl, true); | ||
2154 | if (ret < 0) | ||
2155 | goto out; | ||
2156 | |||
2157 | ret = wl1271_acx_aid(wl, wl->aid); | ||
2158 | if (ret < 0) | ||
2159 | goto out; | ||
2160 | |||
2161 | ret = wl1271_cmd_build_klv_null_data(wl); | ||
2162 | if (ret < 0) | ||
2163 | goto out; | ||
2164 | |||
2165 | ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA, | ||
2166 | ACX_KEEP_ALIVE_TPL_VALID); | ||
2167 | if (ret < 0) | ||
2168 | goto out; | ||
2169 | |||
2170 | out: | ||
2171 | return ret; | ||
2172 | } | ||
2173 | |||
2174 | static int wl1271_unjoin(struct wl1271 *wl) | ||
2175 | { | ||
2176 | int ret; | ||
2177 | |||
2178 | /* to stop listening to a channel, we disconnect */ | ||
2179 | ret = wl1271_cmd_disconnect(wl); | ||
2180 | if (ret < 0) | ||
2181 | goto out; | ||
2182 | |||
2183 | clear_bit(WL1271_FLAG_JOINED, &wl->flags); | ||
2184 | memset(wl->bssid, 0, ETH_ALEN); | ||
2185 | |||
2186 | /* reset TX security counters on a clean disconnect */ | ||
2187 | wl->tx_security_last_seq_lsb = 0; | ||
2188 | wl->tx_security_seq = 0; | ||
2189 | |||
2190 | /* stop filtering packets based on bssid */ | ||
2191 | wl1271_configure_filters(wl, FIF_OTHER_BSS); | ||
2192 | |||
2193 | out: | ||
2194 | return ret; | ||
2195 | } | ||
2196 | |||
2197 | static void wl1271_set_band_rate(struct wl1271 *wl) | ||
2198 | { | ||
2199 | if (wl->band == IEEE80211_BAND_2GHZ) | ||
2200 | wl->basic_rate_set = wl->conf.tx.basic_rate; | ||
2201 | else | ||
2202 | wl->basic_rate_set = wl->conf.tx.basic_rate_5; | ||
2203 | } | ||
2204 | |||
2205 | static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle) | ||
2206 | { | ||
2207 | int ret; | ||
2208 | |||
2209 | if (idle) { | ||
2210 | if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) { | ||
2211 | ret = wl1271_unjoin(wl); | ||
2212 | if (ret < 0) | ||
2213 | goto out; | ||
2214 | } | ||
2215 | wl->rate_set = wl1271_tx_min_rate_get(wl); | ||
2216 | ret = wl1271_acx_sta_rate_policies(wl); | ||
2217 | if (ret < 0) | ||
2218 | goto out; | ||
2219 | ret = wl1271_acx_keep_alive_config( | ||
2220 | wl, CMD_TEMPL_KLV_IDX_NULL_DATA, | ||
2221 | ACX_KEEP_ALIVE_TPL_INVALID); | ||
2222 | if (ret < 0) | ||
2223 | goto out; | ||
2224 | set_bit(WL1271_FLAG_IDLE, &wl->flags); | ||
2225 | } else { | ||
2226 | /* increment the session counter */ | ||
2227 | wl->session_counter++; | ||
2228 | if (wl->session_counter >= SESSION_COUNTER_MAX) | ||
2229 | wl->session_counter = 0; | ||
2230 | |||
2231 | /* The current firmware only supports sched_scan in idle */ | ||
2232 | if (wl->sched_scanning) { | ||
2233 | wl1271_scan_sched_scan_stop(wl); | ||
2234 | ieee80211_sched_scan_stopped(wl->hw); | ||
2235 | } | ||
2236 | |||
2237 | ret = wl1271_dummy_join(wl); | ||
2238 | if (ret < 0) | ||
2239 | goto out; | ||
2240 | clear_bit(WL1271_FLAG_IDLE, &wl->flags); | ||
2241 | } | ||
2242 | |||
2243 | out: | ||
2244 | return ret; | ||
2245 | } | ||
2246 | |||
2247 | static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed) | ||
2248 | { | ||
2249 | struct wl1271 *wl = hw->priv; | ||
2250 | struct ieee80211_conf *conf = &hw->conf; | ||
2251 | int channel, ret = 0; | ||
2252 | bool is_ap; | ||
2253 | |||
2254 | channel = ieee80211_frequency_to_channel(conf->channel->center_freq); | ||
2255 | |||
2256 | wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s" | ||
2257 | " changed 0x%x", | ||
2258 | channel, | ||
2259 | conf->flags & IEEE80211_CONF_PS ? "on" : "off", | ||
2260 | conf->power_level, | ||
2261 | conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use", | ||
2262 | changed); | ||
2263 | |||
2264 | /* | ||
2265 | * mac80211 will go to idle nearly immediately after transmitting some | ||
2266 | * frames, such as the deauth. To make sure those frames reach the air, | ||
2267 | * wait here until the TX queue is fully flushed. | ||
2268 | */ | ||
2269 | if ((changed & IEEE80211_CONF_CHANGE_IDLE) && | ||
2270 | (conf->flags & IEEE80211_CONF_IDLE)) | ||
2271 | wl1271_tx_flush(wl); | ||
2272 | |||
2273 | mutex_lock(&wl->mutex); | ||
2274 | |||
2275 | if (unlikely(wl->state == WL1271_STATE_OFF)) { | ||
2276 | /* we support configuring the channel and band while off */ | ||
2277 | if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) { | ||
2278 | wl->band = conf->channel->band; | ||
2279 | wl->channel = channel; | ||
2280 | } | ||
2281 | |||
2282 | if ((changed & IEEE80211_CONF_CHANGE_POWER)) | ||
2283 | wl->power_level = conf->power_level; | ||
2284 | |||
2285 | goto out; | ||
2286 | } | ||
2287 | |||
2288 | is_ap = (wl->bss_type == BSS_TYPE_AP_BSS); | ||
2289 | |||
2290 | ret = wl1271_ps_elp_wakeup(wl); | ||
2291 | if (ret < 0) | ||
2292 | goto out; | ||
2293 | |||
2294 | /* if the channel changes while joined, join again */ | ||
2295 | if (changed & IEEE80211_CONF_CHANGE_CHANNEL && | ||
2296 | ((wl->band != conf->channel->band) || | ||
2297 | (wl->channel != channel))) { | ||
2298 | wl->band = conf->channel->band; | ||
2299 | wl->channel = channel; | ||
2300 | |||
2301 | if (!is_ap) { | ||
2302 | /* | ||
2303 | * FIXME: the mac80211 should really provide a fixed | ||
2304 | * rate to use here. for now, just use the smallest | ||
2305 | * possible rate for the band as a fixed rate for | ||
2306 | * association frames and other control messages. | ||
2307 | */ | ||
2308 | if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) | ||
2309 | wl1271_set_band_rate(wl); | ||
2310 | |||
2311 | wl->basic_rate = wl1271_tx_min_rate_get(wl); | ||
2312 | ret = wl1271_acx_sta_rate_policies(wl); | ||
2313 | if (ret < 0) | ||
2314 | wl1271_warning("rate policy for channel " | ||
2315 | "failed %d", ret); | ||
2316 | |||
2317 | if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) { | ||
2318 | ret = wl1271_join(wl, false); | ||
2319 | if (ret < 0) | ||
2320 | wl1271_warning("cmd join on channel " | ||
2321 | "failed %d", ret); | ||
2322 | } | ||
2323 | } | ||
2324 | } | ||
2325 | |||
2326 | if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) { | ||
2327 | ret = wl1271_sta_handle_idle(wl, | ||
2328 | conf->flags & IEEE80211_CONF_IDLE); | ||
2329 | if (ret < 0) | ||
2330 | wl1271_warning("idle mode change failed %d", ret); | ||
2331 | } | ||
2332 | |||
2333 | /* | ||
2334 | * if mac80211 changes the PSM mode, make sure the mode is not | ||
2335 | * incorrectly changed after the pspoll failure active window. | ||
2336 | */ | ||
2337 | if (changed & IEEE80211_CONF_CHANGE_PS) | ||
2338 | clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags); | ||
2339 | |||
2340 | if (conf->flags & IEEE80211_CONF_PS && | ||
2341 | !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) { | ||
2342 | set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags); | ||
2343 | |||
2344 | /* | ||
2345 | * We enter PSM only if we're already associated. | ||
2346 | * If we're not, we'll enter it when joining an SSID, | ||
2347 | * through the bss_info_changed() hook. | ||
2348 | */ | ||
2349 | if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) { | ||
2350 | wl1271_debug(DEBUG_PSM, "psm enabled"); | ||
2351 | ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE, | ||
2352 | wl->basic_rate, true); | ||
2353 | } | ||
2354 | } else if (!(conf->flags & IEEE80211_CONF_PS) && | ||
2355 | test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) { | ||
2356 | wl1271_debug(DEBUG_PSM, "psm disabled"); | ||
2357 | |||
2358 | clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags); | ||
2359 | |||
2360 | if (test_bit(WL1271_FLAG_PSM, &wl->flags)) | ||
2361 | ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE, | ||
2362 | wl->basic_rate, true); | ||
2363 | } | ||
2364 | |||
2365 | if (conf->power_level != wl->power_level) { | ||
2366 | ret = wl1271_acx_tx_power(wl, conf->power_level); | ||
2367 | if (ret < 0) | ||
2368 | goto out_sleep; | ||
2369 | |||
2370 | wl->power_level = conf->power_level; | ||
2371 | } | ||
2372 | |||
2373 | out_sleep: | ||
2374 | wl1271_ps_elp_sleep(wl); | ||
2375 | |||
2376 | out: | ||
2377 | mutex_unlock(&wl->mutex); | ||
2378 | |||
2379 | return ret; | ||
2380 | } | ||
2381 | |||
2382 | struct wl1271_filter_params { | ||
2383 | bool enabled; | ||
2384 | int mc_list_length; | ||
2385 | u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN]; | ||
2386 | }; | ||
2387 | |||
2388 | static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, | ||
2389 | struct netdev_hw_addr_list *mc_list) | ||
2390 | { | ||
2391 | struct wl1271_filter_params *fp; | ||
2392 | struct netdev_hw_addr *ha; | ||
2393 | struct wl1271 *wl = hw->priv; | ||
2394 | |||
2395 | if (unlikely(wl->state == WL1271_STATE_OFF)) | ||
2396 | return 0; | ||
2397 | |||
2398 | fp = kzalloc(sizeof(*fp), GFP_ATOMIC); | ||
2399 | if (!fp) { | ||
2400 | wl1271_error("Out of memory setting filters."); | ||
2401 | return 0; | ||
2402 | } | ||
2403 | |||
2404 | /* update multicast filtering parameters */ | ||
2405 | fp->mc_list_length = 0; | ||
2406 | if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) { | ||
2407 | fp->enabled = false; | ||
2408 | } else { | ||
2409 | fp->enabled = true; | ||
2410 | netdev_hw_addr_list_for_each(ha, mc_list) { | ||
2411 | memcpy(fp->mc_list[fp->mc_list_length], | ||
2412 | ha->addr, ETH_ALEN); | ||
2413 | fp->mc_list_length++; | ||
2414 | } | ||
2415 | } | ||
2416 | |||
2417 | return (u64)(unsigned long)fp; | ||
2418 | } | ||
2419 | |||
2420 | #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \ | ||
2421 | FIF_ALLMULTI | \ | ||
2422 | FIF_FCSFAIL | \ | ||
2423 | FIF_BCN_PRBRESP_PROMISC | \ | ||
2424 | FIF_CONTROL | \ | ||
2425 | FIF_OTHER_BSS) | ||
2426 | |||
2427 | static void wl1271_op_configure_filter(struct ieee80211_hw *hw, | ||
2428 | unsigned int changed, | ||
2429 | unsigned int *total, u64 multicast) | ||
2430 | { | ||
2431 | struct wl1271_filter_params *fp = (void *)(unsigned long)multicast; | ||
2432 | struct wl1271 *wl = hw->priv; | ||
2433 | int ret; | ||
2434 | |||
2435 | wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x" | ||
2436 | " total %x", changed, *total); | ||
2437 | |||
2438 | mutex_lock(&wl->mutex); | ||
2439 | |||
2440 | *total &= WL1271_SUPPORTED_FILTERS; | ||
2441 | changed &= WL1271_SUPPORTED_FILTERS; | ||
2442 | |||
2443 | if (unlikely(wl->state == WL1271_STATE_OFF)) | ||
2444 | goto out; | ||
2445 | |||
2446 | ret = wl1271_ps_elp_wakeup(wl); | ||
2447 | if (ret < 0) | ||
2448 | goto out; | ||
2449 | |||
2450 | if (wl->bss_type != BSS_TYPE_AP_BSS) { | ||
2451 | if (*total & FIF_ALLMULTI) | ||
2452 | ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0); | ||
2453 | else if (fp) | ||
2454 | ret = wl1271_acx_group_address_tbl(wl, fp->enabled, | ||
2455 | fp->mc_list, | ||
2456 | fp->mc_list_length); | ||
2457 | if (ret < 0) | ||
2458 | goto out_sleep; | ||
2459 | } | ||
2460 | |||
2461 | /* determine, whether supported filter values have changed */ | ||
2462 | if (changed == 0) | ||
2463 | goto out_sleep; | ||
2464 | |||
2465 | /* configure filters */ | ||
2466 | wl->filters = *total; | ||
2467 | wl1271_configure_filters(wl, 0); | ||
2468 | |||
2469 | /* apply configured filters */ | ||
2470 | ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter); | ||
2471 | if (ret < 0) | ||
2472 | goto out_sleep; | ||
2473 | |||
2474 | out_sleep: | ||
2475 | wl1271_ps_elp_sleep(wl); | ||
2476 | |||
2477 | out: | ||
2478 | mutex_unlock(&wl->mutex); | ||
2479 | kfree(fp); | ||
2480 | } | ||
2481 | |||
2482 | static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type, | ||
2483 | u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32, | ||
2484 | u16 tx_seq_16) | ||
2485 | { | ||
2486 | struct wl1271_ap_key *ap_key; | ||
2487 | int i; | ||
2488 | |||
2489 | wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id); | ||
2490 | |||
2491 | if (key_size > MAX_KEY_SIZE) | ||
2492 | return -EINVAL; | ||
2493 | |||
2494 | /* | ||
2495 | * Find next free entry in ap_keys. Also check we are not replacing | ||
2496 | * an existing key. | ||
2497 | */ | ||
2498 | for (i = 0; i < MAX_NUM_KEYS; i++) { | ||
2499 | if (wl->recorded_ap_keys[i] == NULL) | ||
2500 | break; | ||
2501 | |||
2502 | if (wl->recorded_ap_keys[i]->id == id) { | ||
2503 | wl1271_warning("trying to record key replacement"); | ||
2504 | return -EINVAL; | ||
2505 | } | ||
2506 | } | ||
2507 | |||
2508 | if (i == MAX_NUM_KEYS) | ||
2509 | return -EBUSY; | ||
2510 | |||
2511 | ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL); | ||
2512 | if (!ap_key) | ||
2513 | return -ENOMEM; | ||
2514 | |||
2515 | ap_key->id = id; | ||
2516 | ap_key->key_type = key_type; | ||
2517 | ap_key->key_size = key_size; | ||
2518 | memcpy(ap_key->key, key, key_size); | ||
2519 | ap_key->hlid = hlid; | ||
2520 | ap_key->tx_seq_32 = tx_seq_32; | ||
2521 | ap_key->tx_seq_16 = tx_seq_16; | ||
2522 | |||
2523 | wl->recorded_ap_keys[i] = ap_key; | ||
2524 | return 0; | ||
2525 | } | ||
2526 | |||
2527 | static void wl1271_free_ap_keys(struct wl1271 *wl) | ||
2528 | { | ||
2529 | int i; | ||
2530 | |||
2531 | for (i = 0; i < MAX_NUM_KEYS; i++) { | ||
2532 | kfree(wl->recorded_ap_keys[i]); | ||
2533 | wl->recorded_ap_keys[i] = NULL; | ||
2534 | } | ||
2535 | } | ||
2536 | |||
2537 | static int wl1271_ap_init_hwenc(struct wl1271 *wl) | ||
2538 | { | ||
2539 | int i, ret = 0; | ||
2540 | struct wl1271_ap_key *key; | ||
2541 | bool wep_key_added = false; | ||
2542 | |||
2543 | for (i = 0; i < MAX_NUM_KEYS; i++) { | ||
2544 | if (wl->recorded_ap_keys[i] == NULL) | ||
2545 | break; | ||
2546 | |||
2547 | key = wl->recorded_ap_keys[i]; | ||
2548 | ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE, | ||
2549 | key->id, key->key_type, | ||
2550 | key->key_size, key->key, | ||
2551 | key->hlid, key->tx_seq_32, | ||
2552 | key->tx_seq_16); | ||
2553 | if (ret < 0) | ||
2554 | goto out; | ||
2555 | |||
2556 | if (key->key_type == KEY_WEP) | ||
2557 | wep_key_added = true; | ||
2558 | } | ||
2559 | |||
2560 | if (wep_key_added) { | ||
2561 | ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key); | ||
2562 | if (ret < 0) | ||
2563 | goto out; | ||
2564 | } | ||
2565 | |||
2566 | out: | ||
2567 | wl1271_free_ap_keys(wl); | ||
2568 | return ret; | ||
2569 | } | ||
2570 | |||
2571 | static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type, | ||
2572 | u8 key_size, const u8 *key, u32 tx_seq_32, | ||
2573 | u16 tx_seq_16, struct ieee80211_sta *sta) | ||
2574 | { | ||
2575 | int ret; | ||
2576 | bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS); | ||
2577 | |||
2578 | if (is_ap) { | ||
2579 | struct wl1271_station *wl_sta; | ||
2580 | u8 hlid; | ||
2581 | |||
2582 | if (sta) { | ||
2583 | wl_sta = (struct wl1271_station *)sta->drv_priv; | ||
2584 | hlid = wl_sta->hlid; | ||
2585 | } else { | ||
2586 | hlid = WL1271_AP_BROADCAST_HLID; | ||
2587 | } | ||
2588 | |||
2589 | if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) { | ||
2590 | /* | ||
2591 | * We do not support removing keys after AP shutdown. | ||
2592 | * Pretend we do to make mac80211 happy. | ||
2593 | */ | ||
2594 | if (action != KEY_ADD_OR_REPLACE) | ||
2595 | return 0; | ||
2596 | |||
2597 | ret = wl1271_record_ap_key(wl, id, | ||
2598 | key_type, key_size, | ||
2599 | key, hlid, tx_seq_32, | ||
2600 | tx_seq_16); | ||
2601 | } else { | ||
2602 | ret = wl1271_cmd_set_ap_key(wl, action, | ||
2603 | id, key_type, key_size, | ||
2604 | key, hlid, tx_seq_32, | ||
2605 | tx_seq_16); | ||
2606 | } | ||
2607 | |||
2608 | if (ret < 0) | ||
2609 | return ret; | ||
2610 | } else { | ||
2611 | const u8 *addr; | ||
2612 | static const u8 bcast_addr[ETH_ALEN] = { | ||
2613 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff | ||
2614 | }; | ||
2615 | |||
2616 | addr = sta ? sta->addr : bcast_addr; | ||
2617 | |||
2618 | if (is_zero_ether_addr(addr)) { | ||
2619 | /* We dont support TX only encryption */ | ||
2620 | return -EOPNOTSUPP; | ||
2621 | } | ||
2622 | |||
2623 | /* The wl1271 does not allow to remove unicast keys - they | ||
2624 | will be cleared automatically on next CMD_JOIN. Ignore the | ||
2625 | request silently, as we dont want the mac80211 to emit | ||
2626 | an error message. */ | ||
2627 | if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr)) | ||
2628 | return 0; | ||
2629 | |||
2630 | ret = wl1271_cmd_set_sta_key(wl, action, | ||
2631 | id, key_type, key_size, | ||
2632 | key, addr, tx_seq_32, | ||
2633 | tx_seq_16); | ||
2634 | if (ret < 0) | ||
2635 | return ret; | ||
2636 | |||
2637 | /* the default WEP key needs to be configured at least once */ | ||
2638 | if (key_type == KEY_WEP) { | ||
2639 | ret = wl1271_cmd_set_sta_default_wep_key(wl, | ||
2640 | wl->default_key); | ||
2641 | if (ret < 0) | ||
2642 | return ret; | ||
2643 | } | ||
2644 | } | ||
2645 | |||
2646 | return 0; | ||
2647 | } | ||
2648 | |||
2649 | static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, | ||
2650 | struct ieee80211_vif *vif, | ||
2651 | struct ieee80211_sta *sta, | ||
2652 | struct ieee80211_key_conf *key_conf) | ||
2653 | { | ||
2654 | struct wl1271 *wl = hw->priv; | ||
2655 | int ret; | ||
2656 | u32 tx_seq_32 = 0; | ||
2657 | u16 tx_seq_16 = 0; | ||
2658 | u8 key_type; | ||
2659 | |||
2660 | wl1271_debug(DEBUG_MAC80211, "mac80211 set key"); | ||
2661 | |||
2662 | wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta); | ||
2663 | wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x", | ||
2664 | key_conf->cipher, key_conf->keyidx, | ||
2665 | key_conf->keylen, key_conf->flags); | ||
2666 | wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen); | ||
2667 | |||
2668 | mutex_lock(&wl->mutex); | ||
2669 | |||
2670 | if (unlikely(wl->state == WL1271_STATE_OFF)) { | ||
2671 | ret = -EAGAIN; | ||
2672 | goto out_unlock; | ||
2673 | } | ||
2674 | |||
2675 | ret = wl1271_ps_elp_wakeup(wl); | ||
2676 | if (ret < 0) | ||
2677 | goto out_unlock; | ||
2678 | |||
2679 | switch (key_conf->cipher) { | ||
2680 | case WLAN_CIPHER_SUITE_WEP40: | ||
2681 | case WLAN_CIPHER_SUITE_WEP104: | ||
2682 | key_type = KEY_WEP; | ||
2683 | |||
2684 | key_conf->hw_key_idx = key_conf->keyidx; | ||
2685 | break; | ||
2686 | case WLAN_CIPHER_SUITE_TKIP: | ||
2687 | key_type = KEY_TKIP; | ||
2688 | |||
2689 | key_conf->hw_key_idx = key_conf->keyidx; | ||
2690 | tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq); | ||
2691 | tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq); | ||
2692 | break; | ||
2693 | case WLAN_CIPHER_SUITE_CCMP: | ||
2694 | key_type = KEY_AES; | ||
2695 | |||
2696 | key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; | ||
2697 | tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq); | ||
2698 | tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq); | ||
2699 | break; | ||
2700 | case WL1271_CIPHER_SUITE_GEM: | ||
2701 | key_type = KEY_GEM; | ||
2702 | tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq); | ||
2703 | tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq); | ||
2704 | break; | ||
2705 | default: | ||
2706 | wl1271_error("Unknown key algo 0x%x", key_conf->cipher); | ||
2707 | |||
2708 | ret = -EOPNOTSUPP; | ||
2709 | goto out_sleep; | ||
2710 | } | ||
2711 | |||
2712 | switch (cmd) { | ||
2713 | case SET_KEY: | ||
2714 | ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE, | ||
2715 | key_conf->keyidx, key_type, | ||
2716 | key_conf->keylen, key_conf->key, | ||
2717 | tx_seq_32, tx_seq_16, sta); | ||
2718 | if (ret < 0) { | ||
2719 | wl1271_error("Could not add or replace key"); | ||
2720 | goto out_sleep; | ||
2721 | } | ||
2722 | break; | ||
2723 | |||
2724 | case DISABLE_KEY: | ||
2725 | ret = wl1271_set_key(wl, KEY_REMOVE, | ||
2726 | key_conf->keyidx, key_type, | ||
2727 | key_conf->keylen, key_conf->key, | ||
2728 | 0, 0, sta); | ||
2729 | if (ret < 0) { | ||
2730 | wl1271_error("Could not remove key"); | ||
2731 | goto out_sleep; | ||
2732 | } | ||
2733 | break; | ||
2734 | |||
2735 | default: | ||
2736 | wl1271_error("Unsupported key cmd 0x%x", cmd); | ||
2737 | ret = -EOPNOTSUPP; | ||
2738 | break; | ||
2739 | } | ||
2740 | |||
2741 | out_sleep: | ||
2742 | wl1271_ps_elp_sleep(wl); | ||
2743 | |||
2744 | out_unlock: | ||
2745 | mutex_unlock(&wl->mutex); | ||
2746 | |||
2747 | return ret; | ||
2748 | } | ||
2749 | |||
2750 | static int wl1271_op_hw_scan(struct ieee80211_hw *hw, | ||
2751 | struct ieee80211_vif *vif, | ||
2752 | struct cfg80211_scan_request *req) | ||
2753 | { | ||
2754 | struct wl1271 *wl = hw->priv; | ||
2755 | int ret; | ||
2756 | u8 *ssid = NULL; | ||
2757 | size_t len = 0; | ||
2758 | |||
2759 | wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan"); | ||
2760 | |||
2761 | if (req->n_ssids) { | ||
2762 | ssid = req->ssids[0].ssid; | ||
2763 | len = req->ssids[0].ssid_len; | ||
2764 | } | ||
2765 | |||
2766 | mutex_lock(&wl->mutex); | ||
2767 | |||
2768 | if (wl->state == WL1271_STATE_OFF) { | ||
2769 | /* | ||
2770 | * We cannot return -EBUSY here because cfg80211 will expect | ||
2771 | * a call to ieee80211_scan_completed if we do - in this case | ||
2772 | * there won't be any call. | ||
2773 | */ | ||
2774 | ret = -EAGAIN; | ||
2775 | goto out; | ||
2776 | } | ||
2777 | |||
2778 | ret = wl1271_ps_elp_wakeup(wl); | ||
2779 | if (ret < 0) | ||
2780 | goto out; | ||
2781 | |||
2782 | ret = wl1271_scan(hw->priv, ssid, len, req); | ||
2783 | |||
2784 | wl1271_ps_elp_sleep(wl); | ||
2785 | |||
2786 | out: | ||
2787 | mutex_unlock(&wl->mutex); | ||
2788 | |||
2789 | return ret; | ||
2790 | } | ||
2791 | |||
2792 | static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw, | ||
2793 | struct ieee80211_vif *vif) | ||
2794 | { | ||
2795 | struct wl1271 *wl = hw->priv; | ||
2796 | int ret; | ||
2797 | |||
2798 | wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan"); | ||
2799 | |||
2800 | mutex_lock(&wl->mutex); | ||
2801 | |||
2802 | if (wl->state == WL1271_STATE_OFF) | ||
2803 | goto out; | ||
2804 | |||
2805 | if (wl->scan.state == WL1271_SCAN_STATE_IDLE) | ||
2806 | goto out; | ||
2807 | |||
2808 | ret = wl1271_ps_elp_wakeup(wl); | ||
2809 | if (ret < 0) | ||
2810 | goto out; | ||
2811 | |||
2812 | if (wl->scan.state != WL1271_SCAN_STATE_DONE) { | ||
2813 | ret = wl1271_scan_stop(wl); | ||
2814 | if (ret < 0) | ||
2815 | goto out_sleep; | ||
2816 | } | ||
2817 | wl->scan.state = WL1271_SCAN_STATE_IDLE; | ||
2818 | memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch)); | ||
2819 | wl->scan.req = NULL; | ||
2820 | ieee80211_scan_completed(wl->hw, true); | ||
2821 | |||
2822 | out_sleep: | ||
2823 | wl1271_ps_elp_sleep(wl); | ||
2824 | out: | ||
2825 | mutex_unlock(&wl->mutex); | ||
2826 | |||
2827 | cancel_delayed_work_sync(&wl->scan_complete_work); | ||
2828 | } | ||
2829 | |||
2830 | static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw, | ||
2831 | struct ieee80211_vif *vif, | ||
2832 | struct cfg80211_sched_scan_request *req, | ||
2833 | struct ieee80211_sched_scan_ies *ies) | ||
2834 | { | ||
2835 | struct wl1271 *wl = hw->priv; | ||
2836 | int ret; | ||
2837 | |||
2838 | wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start"); | ||
2839 | |||
2840 | mutex_lock(&wl->mutex); | ||
2841 | |||
2842 | ret = wl1271_ps_elp_wakeup(wl); | ||
2843 | if (ret < 0) | ||
2844 | goto out; | ||
2845 | |||
2846 | ret = wl1271_scan_sched_scan_config(wl, req, ies); | ||
2847 | if (ret < 0) | ||
2848 | goto out_sleep; | ||
2849 | |||
2850 | ret = wl1271_scan_sched_scan_start(wl); | ||
2851 | if (ret < 0) | ||
2852 | goto out_sleep; | ||
2853 | |||
2854 | wl->sched_scanning = true; | ||
2855 | |||
2856 | out_sleep: | ||
2857 | wl1271_ps_elp_sleep(wl); | ||
2858 | out: | ||
2859 | mutex_unlock(&wl->mutex); | ||
2860 | return ret; | ||
2861 | } | ||
2862 | |||
2863 | static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw, | ||
2864 | struct ieee80211_vif *vif) | ||
2865 | { | ||
2866 | struct wl1271 *wl = hw->priv; | ||
2867 | int ret; | ||
2868 | |||
2869 | wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop"); | ||
2870 | |||
2871 | mutex_lock(&wl->mutex); | ||
2872 | |||
2873 | ret = wl1271_ps_elp_wakeup(wl); | ||
2874 | if (ret < 0) | ||
2875 | goto out; | ||
2876 | |||
2877 | wl1271_scan_sched_scan_stop(wl); | ||
2878 | |||
2879 | wl1271_ps_elp_sleep(wl); | ||
2880 | out: | ||
2881 | mutex_unlock(&wl->mutex); | ||
2882 | } | ||
2883 | |||
2884 | static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) | ||
2885 | { | ||
2886 | struct wl1271 *wl = hw->priv; | ||
2887 | int ret = 0; | ||
2888 | |||
2889 | mutex_lock(&wl->mutex); | ||
2890 | |||
2891 | if (unlikely(wl->state == WL1271_STATE_OFF)) { | ||
2892 | ret = -EAGAIN; | ||
2893 | goto out; | ||
2894 | } | ||
2895 | |||
2896 | ret = wl1271_ps_elp_wakeup(wl); | ||
2897 | if (ret < 0) | ||
2898 | goto out; | ||
2899 | |||
2900 | ret = wl1271_acx_frag_threshold(wl, value); | ||
2901 | if (ret < 0) | ||
2902 | wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret); | ||
2903 | |||
2904 | wl1271_ps_elp_sleep(wl); | ||
2905 | |||
2906 | out: | ||
2907 | mutex_unlock(&wl->mutex); | ||
2908 | |||
2909 | return ret; | ||
2910 | } | ||
2911 | |||
2912 | static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) | ||
2913 | { | ||
2914 | struct wl1271 *wl = hw->priv; | ||
2915 | int ret = 0; | ||
2916 | |||
2917 | mutex_lock(&wl->mutex); | ||
2918 | |||
2919 | if (unlikely(wl->state == WL1271_STATE_OFF)) { | ||
2920 | ret = -EAGAIN; | ||
2921 | goto out; | ||
2922 | } | ||
2923 | |||
2924 | ret = wl1271_ps_elp_wakeup(wl); | ||
2925 | if (ret < 0) | ||
2926 | goto out; | ||
2927 | |||
2928 | ret = wl1271_acx_rts_threshold(wl, value); | ||
2929 | if (ret < 0) | ||
2930 | wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret); | ||
2931 | |||
2932 | wl1271_ps_elp_sleep(wl); | ||
2933 | |||
2934 | out: | ||
2935 | mutex_unlock(&wl->mutex); | ||
2936 | |||
2937 | return ret; | ||
2938 | } | ||
2939 | |||
2940 | static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb, | ||
2941 | int offset) | ||
2942 | { | ||
2943 | u8 ssid_len; | ||
2944 | const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset, | ||
2945 | skb->len - offset); | ||
2946 | |||
2947 | if (!ptr) { | ||
2948 | wl1271_error("No SSID in IEs!"); | ||
2949 | return -ENOENT; | ||
2950 | } | ||
2951 | |||
2952 | ssid_len = ptr[1]; | ||
2953 | if (ssid_len > IEEE80211_MAX_SSID_LEN) { | ||
2954 | wl1271_error("SSID is too long!"); | ||
2955 | return -EINVAL; | ||
2956 | } | ||
2957 | |||
2958 | wl->ssid_len = ssid_len; | ||
2959 | memcpy(wl->ssid, ptr+2, ssid_len); | ||
2960 | return 0; | ||
2961 | } | ||
2962 | |||
2963 | static int wl1271_bss_erp_info_changed(struct wl1271 *wl, | ||
2964 | struct ieee80211_bss_conf *bss_conf, | ||
2965 | u32 changed) | ||
2966 | { | ||
2967 | int ret = 0; | ||
2968 | |||
2969 | if (changed & BSS_CHANGED_ERP_SLOT) { | ||
2970 | if (bss_conf->use_short_slot) | ||
2971 | ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT); | ||
2972 | else | ||
2973 | ret = wl1271_acx_slot(wl, SLOT_TIME_LONG); | ||
2974 | if (ret < 0) { | ||
2975 | wl1271_warning("Set slot time failed %d", ret); | ||
2976 | goto out; | ||
2977 | } | ||
2978 | } | ||
2979 | |||
2980 | if (changed & BSS_CHANGED_ERP_PREAMBLE) { | ||
2981 | if (bss_conf->use_short_preamble) | ||
2982 | wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT); | ||
2983 | else | ||
2984 | wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG); | ||
2985 | } | ||
2986 | |||
2987 | if (changed & BSS_CHANGED_ERP_CTS_PROT) { | ||
2988 | if (bss_conf->use_cts_prot) | ||
2989 | ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE); | ||
2990 | else | ||
2991 | ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE); | ||
2992 | if (ret < 0) { | ||
2993 | wl1271_warning("Set ctsprotect failed %d", ret); | ||
2994 | goto out; | ||
2995 | } | ||
2996 | } | ||
2997 | |||
2998 | out: | ||
2999 | return ret; | ||
3000 | } | ||
3001 | |||
3002 | static int wl1271_bss_beacon_info_changed(struct wl1271 *wl, | ||
3003 | struct ieee80211_vif *vif, | ||
3004 | struct ieee80211_bss_conf *bss_conf, | ||
3005 | u32 changed) | ||
3006 | { | ||
3007 | bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS); | ||
3008 | int ret = 0; | ||
3009 | |||
3010 | if ((changed & BSS_CHANGED_BEACON_INT)) { | ||
3011 | wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d", | ||
3012 | bss_conf->beacon_int); | ||
3013 | |||
3014 | wl->beacon_int = bss_conf->beacon_int; | ||
3015 | } | ||
3016 | |||
3017 | if ((changed & BSS_CHANGED_BEACON)) { | ||
3018 | struct ieee80211_hdr *hdr; | ||
3019 | int ieoffset = offsetof(struct ieee80211_mgmt, | ||
3020 | u.beacon.variable); | ||
3021 | struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif); | ||
3022 | u16 tmpl_id; | ||
3023 | |||
3024 | if (!beacon) | ||
3025 | goto out; | ||
3026 | |||
3027 | wl1271_debug(DEBUG_MASTER, "beacon updated"); | ||
3028 | |||
3029 | ret = wl1271_ssid_set(wl, beacon, ieoffset); | ||
3030 | if (ret < 0) { | ||
3031 | dev_kfree_skb(beacon); | ||
3032 | goto out; | ||
3033 | } | ||
3034 | tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON : | ||
3035 | CMD_TEMPL_BEACON; | ||
3036 | ret = wl1271_cmd_template_set(wl, tmpl_id, | ||
3037 | beacon->data, | ||
3038 | beacon->len, 0, | ||
3039 | wl1271_tx_min_rate_get(wl)); | ||
3040 | if (ret < 0) { | ||
3041 | dev_kfree_skb(beacon); | ||
3042 | goto out; | ||
3043 | } | ||
3044 | |||
3045 | hdr = (struct ieee80211_hdr *) beacon->data; | ||
3046 | hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | | ||
3047 | IEEE80211_STYPE_PROBE_RESP); | ||
3048 | |||
3049 | tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE : | ||
3050 | CMD_TEMPL_PROBE_RESPONSE; | ||
3051 | ret = wl1271_cmd_template_set(wl, | ||
3052 | tmpl_id, | ||
3053 | beacon->data, | ||
3054 | beacon->len, 0, | ||
3055 | wl1271_tx_min_rate_get(wl)); | ||
3056 | dev_kfree_skb(beacon); | ||
3057 | if (ret < 0) | ||
3058 | goto out; | ||
3059 | } | ||
3060 | |||
3061 | out: | ||
3062 | return ret; | ||
3063 | } | ||
3064 | |||
3065 | /* AP mode changes */ | ||
3066 | static void wl1271_bss_info_changed_ap(struct wl1271 *wl, | ||
3067 | struct ieee80211_vif *vif, | ||
3068 | struct ieee80211_bss_conf *bss_conf, | ||
3069 | u32 changed) | ||
3070 | { | ||
3071 | int ret = 0; | ||
3072 | |||
3073 | if ((changed & BSS_CHANGED_BASIC_RATES)) { | ||
3074 | u32 rates = bss_conf->basic_rates; | ||
3075 | |||
3076 | wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates); | ||
3077 | wl->basic_rate = wl1271_tx_min_rate_get(wl); | ||
3078 | |||
3079 | ret = wl1271_init_ap_rates(wl); | ||
3080 | if (ret < 0) { | ||
3081 | wl1271_error("AP rate policy change failed %d", ret); | ||
3082 | goto out; | ||
3083 | } | ||
3084 | |||
3085 | ret = wl1271_ap_init_templates(wl); | ||
3086 | if (ret < 0) | ||
3087 | goto out; | ||
3088 | } | ||
3089 | |||
3090 | ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed); | ||
3091 | if (ret < 0) | ||
3092 | goto out; | ||
3093 | |||
3094 | if ((changed & BSS_CHANGED_BEACON_ENABLED)) { | ||
3095 | if (bss_conf->enable_beacon) { | ||
3096 | if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) { | ||
3097 | ret = wl1271_cmd_start_bss(wl); | ||
3098 | if (ret < 0) | ||
3099 | goto out; | ||
3100 | |||
3101 | set_bit(WL1271_FLAG_AP_STARTED, &wl->flags); | ||
3102 | wl1271_debug(DEBUG_AP, "started AP"); | ||
3103 | |||
3104 | ret = wl1271_ap_init_hwenc(wl); | ||
3105 | if (ret < 0) | ||
3106 | goto out; | ||
3107 | } | ||
3108 | } else { | ||
3109 | if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) { | ||
3110 | ret = wl1271_cmd_stop_bss(wl); | ||
3111 | if (ret < 0) | ||
3112 | goto out; | ||
3113 | |||
3114 | clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags); | ||
3115 | wl1271_debug(DEBUG_AP, "stopped AP"); | ||
3116 | } | ||
3117 | } | ||
3118 | } | ||
3119 | |||
3120 | ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed); | ||
3121 | if (ret < 0) | ||
3122 | goto out; | ||
3123 | out: | ||
3124 | return; | ||
3125 | } | ||
3126 | |||
3127 | /* STA/IBSS mode changes */ | ||
3128 | static void wl1271_bss_info_changed_sta(struct wl1271 *wl, | ||
3129 | struct ieee80211_vif *vif, | ||
3130 | struct ieee80211_bss_conf *bss_conf, | ||
3131 | u32 changed) | ||
3132 | { | ||
3133 | bool do_join = false, set_assoc = false; | ||
3134 | bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS); | ||
3135 | u32 sta_rate_set = 0; | ||
3136 | int ret; | ||
3137 | struct ieee80211_sta *sta; | ||
3138 | bool sta_exists = false; | ||
3139 | struct ieee80211_sta_ht_cap sta_ht_cap; | ||
3140 | |||
3141 | if (is_ibss) { | ||
3142 | ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, | ||
3143 | changed); | ||
3144 | if (ret < 0) | ||
3145 | goto out; | ||
3146 | } | ||
3147 | |||
3148 | if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss) | ||
3149 | do_join = true; | ||
3150 | |||
3151 | /* Need to update the SSID (for filtering etc) */ | ||
3152 | if ((changed & BSS_CHANGED_BEACON) && is_ibss) | ||
3153 | do_join = true; | ||
3154 | |||
3155 | if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) { | ||
3156 | wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s", | ||
3157 | bss_conf->enable_beacon ? "enabled" : "disabled"); | ||
3158 | |||
3159 | if (bss_conf->enable_beacon) | ||
3160 | wl->set_bss_type = BSS_TYPE_IBSS; | ||
3161 | else | ||
3162 | wl->set_bss_type = BSS_TYPE_STA_BSS; | ||
3163 | do_join = true; | ||
3164 | } | ||
3165 | |||
3166 | if ((changed & BSS_CHANGED_CQM)) { | ||
3167 | bool enable = false; | ||
3168 | if (bss_conf->cqm_rssi_thold) | ||
3169 | enable = true; | ||
3170 | ret = wl1271_acx_rssi_snr_trigger(wl, enable, | ||
3171 | bss_conf->cqm_rssi_thold, | ||
3172 | bss_conf->cqm_rssi_hyst); | ||
3173 | if (ret < 0) | ||
3174 | goto out; | ||
3175 | wl->rssi_thold = bss_conf->cqm_rssi_thold; | ||
3176 | } | ||
3177 | |||
3178 | if ((changed & BSS_CHANGED_BSSID) && | ||
3179 | /* | ||
3180 | * Now we know the correct bssid, so we send a new join command | ||
3181 | * and enable the BSSID filter | ||
3182 | */ | ||
3183 | memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) { | ||
3184 | memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN); | ||
3185 | |||
3186 | if (!is_zero_ether_addr(wl->bssid)) { | ||
3187 | ret = wl1271_cmd_build_null_data(wl); | ||
3188 | if (ret < 0) | ||
3189 | goto out; | ||
3190 | |||
3191 | ret = wl1271_build_qos_null_data(wl); | ||
3192 | if (ret < 0) | ||
3193 | goto out; | ||
3194 | |||
3195 | /* filter out all packets not from this BSSID */ | ||
3196 | wl1271_configure_filters(wl, 0); | ||
3197 | |||
3198 | /* Need to update the BSSID (for filtering etc) */ | ||
3199 | do_join = true; | ||
3200 | } | ||
3201 | } | ||
3202 | |||
3203 | rcu_read_lock(); | ||
3204 | sta = ieee80211_find_sta(vif, bss_conf->bssid); | ||
3205 | if (sta) { | ||
3206 | /* save the supp_rates of the ap */ | ||
3207 | sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band]; | ||
3208 | if (sta->ht_cap.ht_supported) | ||
3209 | sta_rate_set |= | ||
3210 | (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET); | ||
3211 | sta_ht_cap = sta->ht_cap; | ||
3212 | sta_exists = true; | ||
3213 | } | ||
3214 | rcu_read_unlock(); | ||
3215 | |||
3216 | if (sta_exists) { | ||
3217 | /* handle new association with HT and HT information change */ | ||
3218 | if ((changed & BSS_CHANGED_HT) && | ||
3219 | (bss_conf->channel_type != NL80211_CHAN_NO_HT)) { | ||
3220 | ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap, | ||
3221 | true); | ||
3222 | if (ret < 0) { | ||
3223 | wl1271_warning("Set ht cap true failed %d", | ||
3224 | ret); | ||
3225 | goto out; | ||
3226 | } | ||
3227 | ret = wl1271_acx_set_ht_information(wl, | ||
3228 | bss_conf->ht_operation_mode); | ||
3229 | if (ret < 0) { | ||
3230 | wl1271_warning("Set ht information failed %d", | ||
3231 | ret); | ||
3232 | goto out; | ||
3233 | } | ||
3234 | } | ||
3235 | /* handle new association without HT and disassociation */ | ||
3236 | else if (changed & BSS_CHANGED_ASSOC) { | ||
3237 | ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap, | ||
3238 | false); | ||
3239 | if (ret < 0) { | ||
3240 | wl1271_warning("Set ht cap false failed %d", | ||
3241 | ret); | ||
3242 | goto out; | ||
3243 | } | ||
3244 | } | ||
3245 | } | ||
3246 | |||
3247 | if ((changed & BSS_CHANGED_ASSOC)) { | ||
3248 | if (bss_conf->assoc) { | ||
3249 | u32 rates; | ||
3250 | int ieoffset; | ||
3251 | wl->aid = bss_conf->aid; | ||
3252 | set_assoc = true; | ||
3253 | |||
3254 | wl->ps_poll_failures = 0; | ||
3255 | |||
3256 | /* | ||
3257 | * use basic rates from AP, and determine lowest rate | ||
3258 | * to use with control frames. | ||
3259 | */ | ||
3260 | rates = bss_conf->basic_rates; | ||
3261 | wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, | ||
3262 | rates); | ||
3263 | wl->basic_rate = wl1271_tx_min_rate_get(wl); | ||
3264 | if (sta_rate_set) | ||
3265 | wl->rate_set = wl1271_tx_enabled_rates_get(wl, | ||
3266 | sta_rate_set); | ||
3267 | ret = wl1271_acx_sta_rate_policies(wl); | ||
3268 | if (ret < 0) | ||
3269 | goto out; | ||
3270 | |||
3271 | /* | ||
3272 | * with wl1271, we don't need to update the | ||
3273 | * beacon_int and dtim_period, because the firmware | ||
3274 | * updates it by itself when the first beacon is | ||
3275 | * received after a join. | ||
3276 | */ | ||
3277 | ret = wl1271_cmd_build_ps_poll(wl, wl->aid); | ||
3278 | if (ret < 0) | ||
3279 | goto out; | ||
3280 | |||
3281 | /* | ||
3282 | * Get a template for hardware connection maintenance | ||
3283 | */ | ||
3284 | dev_kfree_skb(wl->probereq); | ||
3285 | wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL); | ||
3286 | ieoffset = offsetof(struct ieee80211_mgmt, | ||
3287 | u.probe_req.variable); | ||
3288 | wl1271_ssid_set(wl, wl->probereq, ieoffset); | ||
3289 | |||
3290 | /* enable the connection monitoring feature */ | ||
3291 | ret = wl1271_acx_conn_monit_params(wl, true); | ||
3292 | if (ret < 0) | ||
3293 | goto out; | ||
3294 | |||
3295 | /* If we want to go in PSM but we're not there yet */ | ||
3296 | if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) && | ||
3297 | !test_bit(WL1271_FLAG_PSM, &wl->flags)) { | ||
3298 | enum wl1271_cmd_ps_mode mode; | ||
3299 | |||
3300 | mode = STATION_POWER_SAVE_MODE; | ||
3301 | ret = wl1271_ps_set_mode(wl, mode, | ||
3302 | wl->basic_rate, | ||
3303 | true); | ||
3304 | if (ret < 0) | ||
3305 | goto out; | ||
3306 | } | ||
3307 | } else { | ||
3308 | /* use defaults when not associated */ | ||
3309 | bool was_assoc = | ||
3310 | !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED, | ||
3311 | &wl->flags); | ||
3312 | clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags); | ||
3313 | wl->aid = 0; | ||
3314 | |||
3315 | /* free probe-request template */ | ||
3316 | dev_kfree_skb(wl->probereq); | ||
3317 | wl->probereq = NULL; | ||
3318 | |||
3319 | /* re-enable dynamic ps - just in case */ | ||
3320 | ieee80211_enable_dyn_ps(wl->vif); | ||
3321 | |||
3322 | /* revert back to minimum rates for the current band */ | ||
3323 | wl1271_set_band_rate(wl); | ||
3324 | wl->basic_rate = wl1271_tx_min_rate_get(wl); | ||
3325 | ret = wl1271_acx_sta_rate_policies(wl); | ||
3326 | if (ret < 0) | ||
3327 | goto out; | ||
3328 | |||
3329 | /* disable connection monitor features */ | ||
3330 | ret = wl1271_acx_conn_monit_params(wl, false); | ||
3331 | |||
3332 | /* Disable the keep-alive feature */ | ||
3333 | ret = wl1271_acx_keep_alive_mode(wl, false); | ||
3334 | if (ret < 0) | ||
3335 | goto out; | ||
3336 | |||
3337 | /* restore the bssid filter and go to dummy bssid */ | ||
3338 | if (was_assoc) { | ||
3339 | wl1271_unjoin(wl); | ||
3340 | wl1271_dummy_join(wl); | ||
3341 | } | ||
3342 | } | ||
3343 | } | ||
3344 | |||
3345 | if (changed & BSS_CHANGED_IBSS) { | ||
3346 | wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d", | ||
3347 | bss_conf->ibss_joined); | ||
3348 | |||
3349 | if (bss_conf->ibss_joined) { | ||
3350 | u32 rates = bss_conf->basic_rates; | ||
3351 | wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, | ||
3352 | rates); | ||
3353 | wl->basic_rate = wl1271_tx_min_rate_get(wl); | ||
3354 | |||
3355 | /* by default, use 11b rates */ | ||
3356 | wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES; | ||
3357 | ret = wl1271_acx_sta_rate_policies(wl); | ||
3358 | if (ret < 0) | ||
3359 | goto out; | ||
3360 | } | ||
3361 | } | ||
3362 | |||
3363 | ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed); | ||
3364 | if (ret < 0) | ||
3365 | goto out; | ||
3366 | |||
3367 | if (changed & BSS_CHANGED_ARP_FILTER) { | ||
3368 | __be32 addr = bss_conf->arp_addr_list[0]; | ||
3369 | WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS); | ||
3370 | |||
3371 | if (bss_conf->arp_addr_cnt == 1 && | ||
3372 | bss_conf->arp_filter_enabled) { | ||
3373 | /* | ||
3374 | * The template should have been configured only upon | ||
3375 | * association. however, it seems that the correct ip | ||
3376 | * isn't being set (when sending), so we have to | ||
3377 | * reconfigure the template upon every ip change. | ||
3378 | */ | ||
3379 | ret = wl1271_cmd_build_arp_rsp(wl, addr); | ||
3380 | if (ret < 0) { | ||
3381 | wl1271_warning("build arp rsp failed: %d", ret); | ||
3382 | goto out; | ||
3383 | } | ||
3384 | |||
3385 | ret = wl1271_acx_arp_ip_filter(wl, | ||
3386 | ACX_ARP_FILTER_ARP_FILTERING, | ||
3387 | addr); | ||
3388 | } else | ||
3389 | ret = wl1271_acx_arp_ip_filter(wl, 0, addr); | ||
3390 | |||
3391 | if (ret < 0) | ||
3392 | goto out; | ||
3393 | } | ||
3394 | |||
3395 | if (do_join) { | ||
3396 | ret = wl1271_join(wl, set_assoc); | ||
3397 | if (ret < 0) { | ||
3398 | wl1271_warning("cmd join failed %d", ret); | ||
3399 | goto out; | ||
3400 | } | ||
3401 | wl1271_check_operstate(wl, ieee80211_get_operstate(vif)); | ||
3402 | } | ||
3403 | |||
3404 | out: | ||
3405 | return; | ||
3406 | } | ||
3407 | |||
3408 | static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw, | ||
3409 | struct ieee80211_vif *vif, | ||
3410 | struct ieee80211_bss_conf *bss_conf, | ||
3411 | u32 changed) | ||
3412 | { | ||
3413 | struct wl1271 *wl = hw->priv; | ||
3414 | bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS); | ||
3415 | int ret; | ||
3416 | |||
3417 | wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x", | ||
3418 | (int)changed); | ||
3419 | |||
3420 | mutex_lock(&wl->mutex); | ||
3421 | |||
3422 | if (unlikely(wl->state == WL1271_STATE_OFF)) | ||
3423 | goto out; | ||
3424 | |||
3425 | ret = wl1271_ps_elp_wakeup(wl); | ||
3426 | if (ret < 0) | ||
3427 | goto out; | ||
3428 | |||
3429 | if (is_ap) | ||
3430 | wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed); | ||
3431 | else | ||
3432 | wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed); | ||
3433 | |||
3434 | wl1271_ps_elp_sleep(wl); | ||
3435 | |||
3436 | out: | ||
3437 | mutex_unlock(&wl->mutex); | ||
3438 | } | ||
3439 | |||
3440 | static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue, | ||
3441 | const struct ieee80211_tx_queue_params *params) | ||
3442 | { | ||
3443 | struct wl1271 *wl = hw->priv; | ||
3444 | u8 ps_scheme; | ||
3445 | int ret = 0; | ||
3446 | |||
3447 | mutex_lock(&wl->mutex); | ||
3448 | |||
3449 | wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue); | ||
3450 | |||
3451 | if (params->uapsd) | ||
3452 | ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER; | ||
3453 | else | ||
3454 | ps_scheme = CONF_PS_SCHEME_LEGACY; | ||
3455 | |||
3456 | if (wl->state == WL1271_STATE_OFF) { | ||
3457 | /* | ||
3458 | * If the state is off, the parameters will be recorded and | ||
3459 | * configured on init. This happens in AP-mode. | ||
3460 | */ | ||
3461 | struct conf_tx_ac_category *conf_ac = | ||
3462 | &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)]; | ||
3463 | struct conf_tx_tid *conf_tid = | ||
3464 | &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)]; | ||
3465 | |||
3466 | conf_ac->ac = wl1271_tx_get_queue(queue); | ||
3467 | conf_ac->cw_min = (u8)params->cw_min; | ||
3468 | conf_ac->cw_max = params->cw_max; | ||
3469 | conf_ac->aifsn = params->aifs; | ||
3470 | conf_ac->tx_op_limit = params->txop << 5; | ||
3471 | |||
3472 | conf_tid->queue_id = wl1271_tx_get_queue(queue); | ||
3473 | conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF; | ||
3474 | conf_tid->tsid = wl1271_tx_get_queue(queue); | ||
3475 | conf_tid->ps_scheme = ps_scheme; | ||
3476 | conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY; | ||
3477 | conf_tid->apsd_conf[0] = 0; | ||
3478 | conf_tid->apsd_conf[1] = 0; | ||
3479 | goto out; | ||
3480 | } | ||
3481 | |||
3482 | ret = wl1271_ps_elp_wakeup(wl); | ||
3483 | if (ret < 0) | ||
3484 | goto out; | ||
3485 | |||
3486 | /* | ||
3487 | * the txop is confed in units of 32us by the mac80211, | ||
3488 | * we need us | ||
3489 | */ | ||
3490 | ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue), | ||
3491 | params->cw_min, params->cw_max, | ||
3492 | params->aifs, params->txop << 5); | ||
3493 | if (ret < 0) | ||
3494 | goto out_sleep; | ||
3495 | |||
3496 | ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue), | ||
3497 | CONF_CHANNEL_TYPE_EDCF, | ||
3498 | wl1271_tx_get_queue(queue), | ||
3499 | ps_scheme, CONF_ACK_POLICY_LEGACY, | ||
3500 | 0, 0); | ||
3501 | |||
3502 | out_sleep: | ||
3503 | wl1271_ps_elp_sleep(wl); | ||
3504 | |||
3505 | out: | ||
3506 | mutex_unlock(&wl->mutex); | ||
3507 | |||
3508 | return ret; | ||
3509 | } | ||
3510 | |||
3511 | static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw) | ||
3512 | { | ||
3513 | |||
3514 | struct wl1271 *wl = hw->priv; | ||
3515 | u64 mactime = ULLONG_MAX; | ||
3516 | int ret; | ||
3517 | |||
3518 | wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf"); | ||
3519 | |||
3520 | mutex_lock(&wl->mutex); | ||
3521 | |||
3522 | if (unlikely(wl->state == WL1271_STATE_OFF)) | ||
3523 | goto out; | ||
3524 | |||
3525 | ret = wl1271_ps_elp_wakeup(wl); | ||
3526 | if (ret < 0) | ||
3527 | goto out; | ||
3528 | |||
3529 | ret = wl1271_acx_tsf_info(wl, &mactime); | ||
3530 | if (ret < 0) | ||
3531 | goto out_sleep; | ||
3532 | |||
3533 | out_sleep: | ||
3534 | wl1271_ps_elp_sleep(wl); | ||
3535 | |||
3536 | out: | ||
3537 | mutex_unlock(&wl->mutex); | ||
3538 | return mactime; | ||
3539 | } | ||
3540 | |||
3541 | static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx, | ||
3542 | struct survey_info *survey) | ||
3543 | { | ||
3544 | struct wl1271 *wl = hw->priv; | ||
3545 | struct ieee80211_conf *conf = &hw->conf; | ||
3546 | |||
3547 | if (idx != 0) | ||
3548 | return -ENOENT; | ||
3549 | |||
3550 | survey->channel = conf->channel; | ||
3551 | survey->filled = SURVEY_INFO_NOISE_DBM; | ||
3552 | survey->noise = wl->noise; | ||
3553 | |||
3554 | return 0; | ||
3555 | } | ||
3556 | |||
3557 | static int wl1271_allocate_sta(struct wl1271 *wl, | ||
3558 | struct ieee80211_sta *sta, | ||
3559 | u8 *hlid) | ||
3560 | { | ||
3561 | struct wl1271_station *wl_sta; | ||
3562 | int id; | ||
3563 | |||
3564 | id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS); | ||
3565 | if (id >= AP_MAX_STATIONS) { | ||
3566 | wl1271_warning("could not allocate HLID - too much stations"); | ||
3567 | return -EBUSY; | ||
3568 | } | ||
3569 | |||
3570 | wl_sta = (struct wl1271_station *)sta->drv_priv; | ||
3571 | __set_bit(id, wl->ap_hlid_map); | ||
3572 | wl_sta->hlid = WL1271_AP_STA_HLID_START + id; | ||
3573 | *hlid = wl_sta->hlid; | ||
3574 | memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN); | ||
3575 | return 0; | ||
3576 | } | ||
3577 | |||
3578 | static void wl1271_free_sta(struct wl1271 *wl, u8 hlid) | ||
3579 | { | ||
3580 | int id = hlid - WL1271_AP_STA_HLID_START; | ||
3581 | |||
3582 | if (WARN_ON(!test_bit(id, wl->ap_hlid_map))) | ||
3583 | return; | ||
3584 | |||
3585 | __clear_bit(id, wl->ap_hlid_map); | ||
3586 | memset(wl->links[hlid].addr, 0, ETH_ALEN); | ||
3587 | wl1271_tx_reset_link_queues(wl, hlid); | ||
3588 | __clear_bit(hlid, &wl->ap_ps_map); | ||
3589 | __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map); | ||
3590 | } | ||
3591 | |||
3592 | bool wl1271_is_active_sta(struct wl1271 *wl, u8 hlid) | ||
3593 | { | ||
3594 | int id = hlid - WL1271_AP_STA_HLID_START; | ||
3595 | return test_bit(id, wl->ap_hlid_map); | ||
3596 | } | ||
3597 | |||
3598 | static int wl1271_op_sta_add(struct ieee80211_hw *hw, | ||
3599 | struct ieee80211_vif *vif, | ||
3600 | struct ieee80211_sta *sta) | ||
3601 | { | ||
3602 | struct wl1271 *wl = hw->priv; | ||
3603 | int ret = 0; | ||
3604 | u8 hlid; | ||
3605 | |||
3606 | mutex_lock(&wl->mutex); | ||
3607 | |||
3608 | if (unlikely(wl->state == WL1271_STATE_OFF)) | ||
3609 | goto out; | ||
3610 | |||
3611 | if (wl->bss_type != BSS_TYPE_AP_BSS) | ||
3612 | goto out; | ||
3613 | |||
3614 | wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid); | ||
3615 | |||
3616 | ret = wl1271_allocate_sta(wl, sta, &hlid); | ||
3617 | if (ret < 0) | ||
3618 | goto out; | ||
3619 | |||
3620 | ret = wl1271_ps_elp_wakeup(wl); | ||
3621 | if (ret < 0) | ||
3622 | goto out_free_sta; | ||
3623 | |||
3624 | ret = wl1271_cmd_add_sta(wl, sta, hlid); | ||
3625 | if (ret < 0) | ||
3626 | goto out_sleep; | ||
3627 | |||
3628 | out_sleep: | ||
3629 | wl1271_ps_elp_sleep(wl); | ||
3630 | |||
3631 | out_free_sta: | ||
3632 | if (ret < 0) | ||
3633 | wl1271_free_sta(wl, hlid); | ||
3634 | |||
3635 | out: | ||
3636 | mutex_unlock(&wl->mutex); | ||
3637 | return ret; | ||
3638 | } | ||
3639 | |||
3640 | static int wl1271_op_sta_remove(struct ieee80211_hw *hw, | ||
3641 | struct ieee80211_vif *vif, | ||
3642 | struct ieee80211_sta *sta) | ||
3643 | { | ||
3644 | struct wl1271 *wl = hw->priv; | ||
3645 | struct wl1271_station *wl_sta; | ||
3646 | int ret = 0, id; | ||
3647 | |||
3648 | mutex_lock(&wl->mutex); | ||
3649 | |||
3650 | if (unlikely(wl->state == WL1271_STATE_OFF)) | ||
3651 | goto out; | ||
3652 | |||
3653 | if (wl->bss_type != BSS_TYPE_AP_BSS) | ||
3654 | goto out; | ||
3655 | |||
3656 | wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid); | ||
3657 | |||
3658 | wl_sta = (struct wl1271_station *)sta->drv_priv; | ||
3659 | id = wl_sta->hlid - WL1271_AP_STA_HLID_START; | ||
3660 | if (WARN_ON(!test_bit(id, wl->ap_hlid_map))) | ||
3661 | goto out; | ||
3662 | |||
3663 | ret = wl1271_ps_elp_wakeup(wl); | ||
3664 | if (ret < 0) | ||
3665 | goto out; | ||
3666 | |||
3667 | ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid); | ||
3668 | if (ret < 0) | ||
3669 | goto out_sleep; | ||
3670 | |||
3671 | wl1271_free_sta(wl, wl_sta->hlid); | ||
3672 | |||
3673 | out_sleep: | ||
3674 | wl1271_ps_elp_sleep(wl); | ||
3675 | |||
3676 | out: | ||
3677 | mutex_unlock(&wl->mutex); | ||
3678 | return ret; | ||
3679 | } | ||
3680 | |||
3681 | static int wl1271_op_ampdu_action(struct ieee80211_hw *hw, | ||
3682 | struct ieee80211_vif *vif, | ||
3683 | enum ieee80211_ampdu_mlme_action action, | ||
3684 | struct ieee80211_sta *sta, u16 tid, u16 *ssn, | ||
3685 | u8 buf_size) | ||
3686 | { | ||
3687 | struct wl1271 *wl = hw->priv; | ||
3688 | int ret; | ||
3689 | |||
3690 | mutex_lock(&wl->mutex); | ||
3691 | |||
3692 | if (unlikely(wl->state == WL1271_STATE_OFF)) { | ||
3693 | ret = -EAGAIN; | ||
3694 | goto out; | ||
3695 | } | ||
3696 | |||
3697 | ret = wl1271_ps_elp_wakeup(wl); | ||
3698 | if (ret < 0) | ||
3699 | goto out; | ||
3700 | |||
3701 | wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d", | ||
3702 | tid, action); | ||
3703 | |||
3704 | switch (action) { | ||
3705 | case IEEE80211_AMPDU_RX_START: | ||
3706 | if ((wl->ba_support) && (wl->ba_allowed)) { | ||
3707 | ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn, | ||
3708 | true); | ||
3709 | if (!ret) | ||
3710 | wl->ba_rx_bitmap |= BIT(tid); | ||
3711 | } else { | ||
3712 | ret = -ENOTSUPP; | ||
3713 | } | ||
3714 | break; | ||
3715 | |||
3716 | case IEEE80211_AMPDU_RX_STOP: | ||
3717 | ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false); | ||
3718 | if (!ret) | ||
3719 | wl->ba_rx_bitmap &= ~BIT(tid); | ||
3720 | break; | ||
3721 | |||
3722 | /* | ||
3723 | * The BA initiator session management in FW independently. | ||
3724 | * Falling break here on purpose for all TX APDU commands. | ||
3725 | */ | ||
3726 | case IEEE80211_AMPDU_TX_START: | ||
3727 | case IEEE80211_AMPDU_TX_STOP: | ||
3728 | case IEEE80211_AMPDU_TX_OPERATIONAL: | ||
3729 | ret = -EINVAL; | ||
3730 | break; | ||
3731 | |||
3732 | default: | ||
3733 | wl1271_error("Incorrect ampdu action id=%x\n", action); | ||
3734 | ret = -EINVAL; | ||
3735 | } | ||
3736 | |||
3737 | wl1271_ps_elp_sleep(wl); | ||
3738 | |||
3739 | out: | ||
3740 | mutex_unlock(&wl->mutex); | ||
3741 | |||
3742 | return ret; | ||
3743 | } | ||
3744 | |||
3745 | static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw) | ||
3746 | { | ||
3747 | struct wl1271 *wl = hw->priv; | ||
3748 | bool ret = false; | ||
3749 | |||
3750 | mutex_lock(&wl->mutex); | ||
3751 | |||
3752 | if (unlikely(wl->state == WL1271_STATE_OFF)) | ||
3753 | goto out; | ||
3754 | |||
3755 | /* packets are considered pending if in the TX queue or the FW */ | ||
3756 | ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0); | ||
3757 | |||
3758 | /* the above is appropriate for STA mode for PS purposes */ | ||
3759 | WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS); | ||
3760 | |||
3761 | out: | ||
3762 | mutex_unlock(&wl->mutex); | ||
3763 | |||
3764 | return ret; | ||
3765 | } | ||
3766 | |||
3767 | /* can't be const, mac80211 writes to this */ | ||
3768 | static struct ieee80211_rate wl1271_rates[] = { | ||
3769 | { .bitrate = 10, | ||
3770 | .hw_value = CONF_HW_BIT_RATE_1MBPS, | ||
3771 | .hw_value_short = CONF_HW_BIT_RATE_1MBPS, }, | ||
3772 | { .bitrate = 20, | ||
3773 | .hw_value = CONF_HW_BIT_RATE_2MBPS, | ||
3774 | .hw_value_short = CONF_HW_BIT_RATE_2MBPS, | ||
3775 | .flags = IEEE80211_RATE_SHORT_PREAMBLE }, | ||
3776 | { .bitrate = 55, | ||
3777 | .hw_value = CONF_HW_BIT_RATE_5_5MBPS, | ||
3778 | .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS, | ||
3779 | .flags = IEEE80211_RATE_SHORT_PREAMBLE }, | ||
3780 | { .bitrate = 110, | ||
3781 | .hw_value = CONF_HW_BIT_RATE_11MBPS, | ||
3782 | .hw_value_short = CONF_HW_BIT_RATE_11MBPS, | ||
3783 | .flags = IEEE80211_RATE_SHORT_PREAMBLE }, | ||
3784 | { .bitrate = 60, | ||
3785 | .hw_value = CONF_HW_BIT_RATE_6MBPS, | ||
3786 | .hw_value_short = CONF_HW_BIT_RATE_6MBPS, }, | ||
3787 | { .bitrate = 90, | ||
3788 | .hw_value = CONF_HW_BIT_RATE_9MBPS, | ||
3789 | .hw_value_short = CONF_HW_BIT_RATE_9MBPS, }, | ||
3790 | { .bitrate = 120, | ||
3791 | .hw_value = CONF_HW_BIT_RATE_12MBPS, | ||
3792 | .hw_value_short = CONF_HW_BIT_RATE_12MBPS, }, | ||
3793 | { .bitrate = 180, | ||
3794 | .hw_value = CONF_HW_BIT_RATE_18MBPS, | ||
3795 | .hw_value_short = CONF_HW_BIT_RATE_18MBPS, }, | ||
3796 | { .bitrate = 240, | ||
3797 | .hw_value = CONF_HW_BIT_RATE_24MBPS, | ||
3798 | .hw_value_short = CONF_HW_BIT_RATE_24MBPS, }, | ||
3799 | { .bitrate = 360, | ||
3800 | .hw_value = CONF_HW_BIT_RATE_36MBPS, | ||
3801 | .hw_value_short = CONF_HW_BIT_RATE_36MBPS, }, | ||
3802 | { .bitrate = 480, | ||
3803 | .hw_value = CONF_HW_BIT_RATE_48MBPS, | ||
3804 | .hw_value_short = CONF_HW_BIT_RATE_48MBPS, }, | ||
3805 | { .bitrate = 540, | ||
3806 | .hw_value = CONF_HW_BIT_RATE_54MBPS, | ||
3807 | .hw_value_short = CONF_HW_BIT_RATE_54MBPS, }, | ||
3808 | }; | ||
3809 | |||
3810 | /* can't be const, mac80211 writes to this */ | ||
3811 | static struct ieee80211_channel wl1271_channels[] = { | ||
3812 | { .hw_value = 1, .center_freq = 2412, .max_power = 25 }, | ||
3813 | { .hw_value = 2, .center_freq = 2417, .max_power = 25 }, | ||
3814 | { .hw_value = 3, .center_freq = 2422, .max_power = 25 }, | ||
3815 | { .hw_value = 4, .center_freq = 2427, .max_power = 25 }, | ||
3816 | { .hw_value = 5, .center_freq = 2432, .max_power = 25 }, | ||
3817 | { .hw_value = 6, .center_freq = 2437, .max_power = 25 }, | ||
3818 | { .hw_value = 7, .center_freq = 2442, .max_power = 25 }, | ||
3819 | { .hw_value = 8, .center_freq = 2447, .max_power = 25 }, | ||
3820 | { .hw_value = 9, .center_freq = 2452, .max_power = 25 }, | ||
3821 | { .hw_value = 10, .center_freq = 2457, .max_power = 25 }, | ||
3822 | { .hw_value = 11, .center_freq = 2462, .max_power = 25 }, | ||
3823 | { .hw_value = 12, .center_freq = 2467, .max_power = 25 }, | ||
3824 | { .hw_value = 13, .center_freq = 2472, .max_power = 25 }, | ||
3825 | { .hw_value = 14, .center_freq = 2484, .max_power = 25 }, | ||
3826 | }; | ||
3827 | |||
3828 | /* mapping to indexes for wl1271_rates */ | ||
3829 | static const u8 wl1271_rate_to_idx_2ghz[] = { | ||
3830 | /* MCS rates are used only with 11n */ | ||
3831 | 7, /* CONF_HW_RXTX_RATE_MCS7 */ | ||
3832 | 6, /* CONF_HW_RXTX_RATE_MCS6 */ | ||
3833 | 5, /* CONF_HW_RXTX_RATE_MCS5 */ | ||
3834 | 4, /* CONF_HW_RXTX_RATE_MCS4 */ | ||
3835 | 3, /* CONF_HW_RXTX_RATE_MCS3 */ | ||
3836 | 2, /* CONF_HW_RXTX_RATE_MCS2 */ | ||
3837 | 1, /* CONF_HW_RXTX_RATE_MCS1 */ | ||
3838 | 0, /* CONF_HW_RXTX_RATE_MCS0 */ | ||
3839 | |||
3840 | 11, /* CONF_HW_RXTX_RATE_54 */ | ||
3841 | 10, /* CONF_HW_RXTX_RATE_48 */ | ||
3842 | 9, /* CONF_HW_RXTX_RATE_36 */ | ||
3843 | 8, /* CONF_HW_RXTX_RATE_24 */ | ||
3844 | |||
3845 | /* TI-specific rate */ | ||
3846 | CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */ | ||
3847 | |||
3848 | 7, /* CONF_HW_RXTX_RATE_18 */ | ||
3849 | 6, /* CONF_HW_RXTX_RATE_12 */ | ||
3850 | 3, /* CONF_HW_RXTX_RATE_11 */ | ||
3851 | 5, /* CONF_HW_RXTX_RATE_9 */ | ||
3852 | 4, /* CONF_HW_RXTX_RATE_6 */ | ||
3853 | 2, /* CONF_HW_RXTX_RATE_5_5 */ | ||
3854 | 1, /* CONF_HW_RXTX_RATE_2 */ | ||
3855 | 0 /* CONF_HW_RXTX_RATE_1 */ | ||
3856 | }; | ||
3857 | |||
3858 | /* 11n STA capabilities */ | ||
3859 | #define HW_RX_HIGHEST_RATE 72 | ||
3860 | |||
3861 | #ifdef CONFIG_WL12XX_HT | ||
3862 | #define WL12XX_HT_CAP { \ | ||
3863 | .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \ | ||
3864 | (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \ | ||
3865 | .ht_supported = true, \ | ||
3866 | .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \ | ||
3867 | .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \ | ||
3868 | .mcs = { \ | ||
3869 | .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \ | ||
3870 | .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \ | ||
3871 | .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \ | ||
3872 | }, \ | ||
3873 | } | ||
3874 | #else | ||
3875 | #define WL12XX_HT_CAP { \ | ||
3876 | .ht_supported = false, \ | ||
3877 | } | ||
3878 | #endif | ||
3879 | |||
3880 | /* can't be const, mac80211 writes to this */ | ||
3881 | static struct ieee80211_supported_band wl1271_band_2ghz = { | ||
3882 | .channels = wl1271_channels, | ||
3883 | .n_channels = ARRAY_SIZE(wl1271_channels), | ||
3884 | .bitrates = wl1271_rates, | ||
3885 | .n_bitrates = ARRAY_SIZE(wl1271_rates), | ||
3886 | .ht_cap = WL12XX_HT_CAP, | ||
3887 | }; | ||
3888 | |||
3889 | /* 5 GHz data rates for WL1273 */ | ||
3890 | static struct ieee80211_rate wl1271_rates_5ghz[] = { | ||
3891 | { .bitrate = 60, | ||
3892 | .hw_value = CONF_HW_BIT_RATE_6MBPS, | ||
3893 | .hw_value_short = CONF_HW_BIT_RATE_6MBPS, }, | ||
3894 | { .bitrate = 90, | ||
3895 | .hw_value = CONF_HW_BIT_RATE_9MBPS, | ||
3896 | .hw_value_short = CONF_HW_BIT_RATE_9MBPS, }, | ||
3897 | { .bitrate = 120, | ||
3898 | .hw_value = CONF_HW_BIT_RATE_12MBPS, | ||
3899 | .hw_value_short = CONF_HW_BIT_RATE_12MBPS, }, | ||
3900 | { .bitrate = 180, | ||
3901 | .hw_value = CONF_HW_BIT_RATE_18MBPS, | ||
3902 | .hw_value_short = CONF_HW_BIT_RATE_18MBPS, }, | ||
3903 | { .bitrate = 240, | ||
3904 | .hw_value = CONF_HW_BIT_RATE_24MBPS, | ||
3905 | .hw_value_short = CONF_HW_BIT_RATE_24MBPS, }, | ||
3906 | { .bitrate = 360, | ||
3907 | .hw_value = CONF_HW_BIT_RATE_36MBPS, | ||
3908 | .hw_value_short = CONF_HW_BIT_RATE_36MBPS, }, | ||
3909 | { .bitrate = 480, | ||
3910 | .hw_value = CONF_HW_BIT_RATE_48MBPS, | ||
3911 | .hw_value_short = CONF_HW_BIT_RATE_48MBPS, }, | ||
3912 | { .bitrate = 540, | ||
3913 | .hw_value = CONF_HW_BIT_RATE_54MBPS, | ||
3914 | .hw_value_short = CONF_HW_BIT_RATE_54MBPS, }, | ||
3915 | }; | ||
3916 | |||
3917 | /* 5 GHz band channels for WL1273 */ | ||
3918 | static struct ieee80211_channel wl1271_channels_5ghz[] = { | ||
3919 | { .hw_value = 7, .center_freq = 5035, .max_power = 25 }, | ||
3920 | { .hw_value = 8, .center_freq = 5040, .max_power = 25 }, | ||
3921 | { .hw_value = 9, .center_freq = 5045, .max_power = 25 }, | ||
3922 | { .hw_value = 11, .center_freq = 5055, .max_power = 25 }, | ||
3923 | { .hw_value = 12, .center_freq = 5060, .max_power = 25 }, | ||
3924 | { .hw_value = 16, .center_freq = 5080, .max_power = 25 }, | ||
3925 | { .hw_value = 34, .center_freq = 5170, .max_power = 25 }, | ||
3926 | { .hw_value = 36, .center_freq = 5180, .max_power = 25 }, | ||
3927 | { .hw_value = 38, .center_freq = 5190, .max_power = 25 }, | ||
3928 | { .hw_value = 40, .center_freq = 5200, .max_power = 25 }, | ||
3929 | { .hw_value = 42, .center_freq = 5210, .max_power = 25 }, | ||
3930 | { .hw_value = 44, .center_freq = 5220, .max_power = 25 }, | ||
3931 | { .hw_value = 46, .center_freq = 5230, .max_power = 25 }, | ||
3932 | { .hw_value = 48, .center_freq = 5240, .max_power = 25 }, | ||
3933 | { .hw_value = 52, .center_freq = 5260, .max_power = 25 }, | ||
3934 | { .hw_value = 56, .center_freq = 5280, .max_power = 25 }, | ||
3935 | { .hw_value = 60, .center_freq = 5300, .max_power = 25 }, | ||
3936 | { .hw_value = 64, .center_freq = 5320, .max_power = 25 }, | ||
3937 | { .hw_value = 100, .center_freq = 5500, .max_power = 25 }, | ||
3938 | { .hw_value = 104, .center_freq = 5520, .max_power = 25 }, | ||
3939 | { .hw_value = 108, .center_freq = 5540, .max_power = 25 }, | ||
3940 | { .hw_value = 112, .center_freq = 5560, .max_power = 25 }, | ||
3941 | { .hw_value = 116, .center_freq = 5580, .max_power = 25 }, | ||
3942 | { .hw_value = 120, .center_freq = 5600, .max_power = 25 }, | ||
3943 | { .hw_value = 124, .center_freq = 5620, .max_power = 25 }, | ||
3944 | { .hw_value = 128, .center_freq = 5640, .max_power = 25 }, | ||
3945 | { .hw_value = 132, .center_freq = 5660, .max_power = 25 }, | ||
3946 | { .hw_value = 136, .center_freq = 5680, .max_power = 25 }, | ||
3947 | { .hw_value = 140, .center_freq = 5700, .max_power = 25 }, | ||
3948 | { .hw_value = 149, .center_freq = 5745, .max_power = 25 }, | ||
3949 | { .hw_value = 153, .center_freq = 5765, .max_power = 25 }, | ||
3950 | { .hw_value = 157, .center_freq = 5785, .max_power = 25 }, | ||
3951 | { .hw_value = 161, .center_freq = 5805, .max_power = 25 }, | ||
3952 | { .hw_value = 165, .center_freq = 5825, .max_power = 25 }, | ||
3953 | }; | ||
3954 | |||
3955 | /* mapping to indexes for wl1271_rates_5ghz */ | ||
3956 | static const u8 wl1271_rate_to_idx_5ghz[] = { | ||
3957 | /* MCS rates are used only with 11n */ | ||
3958 | 7, /* CONF_HW_RXTX_RATE_MCS7 */ | ||
3959 | 6, /* CONF_HW_RXTX_RATE_MCS6 */ | ||
3960 | 5, /* CONF_HW_RXTX_RATE_MCS5 */ | ||
3961 | 4, /* CONF_HW_RXTX_RATE_MCS4 */ | ||
3962 | 3, /* CONF_HW_RXTX_RATE_MCS3 */ | ||
3963 | 2, /* CONF_HW_RXTX_RATE_MCS2 */ | ||
3964 | 1, /* CONF_HW_RXTX_RATE_MCS1 */ | ||
3965 | 0, /* CONF_HW_RXTX_RATE_MCS0 */ | ||
3966 | |||
3967 | 7, /* CONF_HW_RXTX_RATE_54 */ | ||
3968 | 6, /* CONF_HW_RXTX_RATE_48 */ | ||
3969 | 5, /* CONF_HW_RXTX_RATE_36 */ | ||
3970 | 4, /* CONF_HW_RXTX_RATE_24 */ | ||
3971 | |||
3972 | /* TI-specific rate */ | ||
3973 | CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */ | ||
3974 | |||
3975 | 3, /* CONF_HW_RXTX_RATE_18 */ | ||
3976 | 2, /* CONF_HW_RXTX_RATE_12 */ | ||
3977 | CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */ | ||
3978 | 1, /* CONF_HW_RXTX_RATE_9 */ | ||
3979 | 0, /* CONF_HW_RXTX_RATE_6 */ | ||
3980 | CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */ | ||
3981 | CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */ | ||
3982 | CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */ | ||
3983 | }; | ||
3984 | |||
3985 | static struct ieee80211_supported_band wl1271_band_5ghz = { | ||
3986 | .channels = wl1271_channels_5ghz, | ||
3987 | .n_channels = ARRAY_SIZE(wl1271_channels_5ghz), | ||
3988 | .bitrates = wl1271_rates_5ghz, | ||
3989 | .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz), | ||
3990 | .ht_cap = WL12XX_HT_CAP, | ||
3991 | }; | ||
3992 | |||
3993 | static const u8 *wl1271_band_rate_to_idx[] = { | ||
3994 | [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz, | ||
3995 | [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz | ||
3996 | }; | ||
3997 | |||
3998 | static const struct ieee80211_ops wl1271_ops = { | ||
3999 | .start = wl1271_op_start, | ||
4000 | .stop = wl1271_op_stop, | ||
4001 | .add_interface = wl1271_op_add_interface, | ||
4002 | .remove_interface = wl1271_op_remove_interface, | ||
4003 | #ifdef CONFIG_PM | ||
4004 | .suspend = wl1271_op_suspend, | ||
4005 | .resume = wl1271_op_resume, | ||
4006 | #endif | ||
4007 | .config = wl1271_op_config, | ||
4008 | .prepare_multicast = wl1271_op_prepare_multicast, | ||
4009 | .configure_filter = wl1271_op_configure_filter, | ||
4010 | .tx = wl1271_op_tx, | ||
4011 | .set_key = wl1271_op_set_key, | ||
4012 | .hw_scan = wl1271_op_hw_scan, | ||
4013 | .cancel_hw_scan = wl1271_op_cancel_hw_scan, | ||
4014 | .sched_scan_start = wl1271_op_sched_scan_start, | ||
4015 | .sched_scan_stop = wl1271_op_sched_scan_stop, | ||
4016 | .bss_info_changed = wl1271_op_bss_info_changed, | ||
4017 | .set_frag_threshold = wl1271_op_set_frag_threshold, | ||
4018 | .set_rts_threshold = wl1271_op_set_rts_threshold, | ||
4019 | .conf_tx = wl1271_op_conf_tx, | ||
4020 | .get_tsf = wl1271_op_get_tsf, | ||
4021 | .get_survey = wl1271_op_get_survey, | ||
4022 | .sta_add = wl1271_op_sta_add, | ||
4023 | .sta_remove = wl1271_op_sta_remove, | ||
4024 | .ampdu_action = wl1271_op_ampdu_action, | ||
4025 | .tx_frames_pending = wl1271_tx_frames_pending, | ||
4026 | CFG80211_TESTMODE_CMD(wl1271_tm_cmd) | ||
4027 | }; | ||
4028 | |||
4029 | |||
4030 | u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band) | ||
4031 | { | ||
4032 | u8 idx; | ||
4033 | |||
4034 | BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *)); | ||
4035 | |||
4036 | if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) { | ||
4037 | wl1271_error("Illegal RX rate from HW: %d", rate); | ||
4038 | return 0; | ||
4039 | } | ||
4040 | |||
4041 | idx = wl1271_band_rate_to_idx[band][rate]; | ||
4042 | if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) { | ||
4043 | wl1271_error("Unsupported RX rate from HW: %d", rate); | ||
4044 | return 0; | ||
4045 | } | ||
4046 | |||
4047 | return idx; | ||
4048 | } | ||
4049 | |||
4050 | static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev, | ||
4051 | struct device_attribute *attr, | ||
4052 | char *buf) | ||
4053 | { | ||
4054 | struct wl1271 *wl = dev_get_drvdata(dev); | ||
4055 | ssize_t len; | ||
4056 | |||
4057 | len = PAGE_SIZE; | ||
4058 | |||
4059 | mutex_lock(&wl->mutex); | ||
4060 | len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n", | ||
4061 | wl->sg_enabled); | ||
4062 | mutex_unlock(&wl->mutex); | ||
4063 | |||
4064 | return len; | ||
4065 | |||
4066 | } | ||
4067 | |||
4068 | static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev, | ||
4069 | struct device_attribute *attr, | ||
4070 | const char *buf, size_t count) | ||
4071 | { | ||
4072 | struct wl1271 *wl = dev_get_drvdata(dev); | ||
4073 | unsigned long res; | ||
4074 | int ret; | ||
4075 | |||
4076 | ret = kstrtoul(buf, 10, &res); | ||
4077 | if (ret < 0) { | ||
4078 | wl1271_warning("incorrect value written to bt_coex_mode"); | ||
4079 | return count; | ||
4080 | } | ||
4081 | |||
4082 | mutex_lock(&wl->mutex); | ||
4083 | |||
4084 | res = !!res; | ||
4085 | |||
4086 | if (res == wl->sg_enabled) | ||
4087 | goto out; | ||
4088 | |||
4089 | wl->sg_enabled = res; | ||
4090 | |||
4091 | if (wl->state == WL1271_STATE_OFF) | ||
4092 | goto out; | ||
4093 | |||
4094 | ret = wl1271_ps_elp_wakeup(wl); | ||
4095 | if (ret < 0) | ||
4096 | goto out; | ||
4097 | |||
4098 | wl1271_acx_sg_enable(wl, wl->sg_enabled); | ||
4099 | wl1271_ps_elp_sleep(wl); | ||
4100 | |||
4101 | out: | ||
4102 | mutex_unlock(&wl->mutex); | ||
4103 | return count; | ||
4104 | } | ||
4105 | |||
4106 | static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR, | ||
4107 | wl1271_sysfs_show_bt_coex_state, | ||
4108 | wl1271_sysfs_store_bt_coex_state); | ||
4109 | |||
4110 | static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev, | ||
4111 | struct device_attribute *attr, | ||
4112 | char *buf) | ||
4113 | { | ||
4114 | struct wl1271 *wl = dev_get_drvdata(dev); | ||
4115 | ssize_t len; | ||
4116 | |||
4117 | len = PAGE_SIZE; | ||
4118 | |||
4119 | mutex_lock(&wl->mutex); | ||
4120 | if (wl->hw_pg_ver >= 0) | ||
4121 | len = snprintf(buf, len, "%d\n", wl->hw_pg_ver); | ||
4122 | else | ||
4123 | len = snprintf(buf, len, "n/a\n"); | ||
4124 | mutex_unlock(&wl->mutex); | ||
4125 | |||
4126 | return len; | ||
4127 | } | ||
4128 | |||
4129 | static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR, | ||
4130 | wl1271_sysfs_show_hw_pg_ver, NULL); | ||
4131 | |||
4132 | static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj, | ||
4133 | struct bin_attribute *bin_attr, | ||
4134 | char *buffer, loff_t pos, size_t count) | ||
4135 | { | ||
4136 | struct device *dev = container_of(kobj, struct device, kobj); | ||
4137 | struct wl1271 *wl = dev_get_drvdata(dev); | ||
4138 | ssize_t len; | ||
4139 | int ret; | ||
4140 | |||
4141 | ret = mutex_lock_interruptible(&wl->mutex); | ||
4142 | if (ret < 0) | ||
4143 | return -ERESTARTSYS; | ||
4144 | |||
4145 | /* Let only one thread read the log at a time, blocking others */ | ||
4146 | while (wl->fwlog_size == 0) { | ||
4147 | DEFINE_WAIT(wait); | ||
4148 | |||
4149 | prepare_to_wait_exclusive(&wl->fwlog_waitq, | ||
4150 | &wait, | ||
4151 | TASK_INTERRUPTIBLE); | ||
4152 | |||
4153 | if (wl->fwlog_size != 0) { | ||
4154 | finish_wait(&wl->fwlog_waitq, &wait); | ||
4155 | break; | ||
4156 | } | ||
4157 | |||
4158 | mutex_unlock(&wl->mutex); | ||
4159 | |||
4160 | schedule(); | ||
4161 | finish_wait(&wl->fwlog_waitq, &wait); | ||
4162 | |||
4163 | if (signal_pending(current)) | ||
4164 | return -ERESTARTSYS; | ||
4165 | |||
4166 | ret = mutex_lock_interruptible(&wl->mutex); | ||
4167 | if (ret < 0) | ||
4168 | return -ERESTARTSYS; | ||
4169 | } | ||
4170 | |||
4171 | /* Check if the fwlog is still valid */ | ||
4172 | if (wl->fwlog_size < 0) { | ||
4173 | mutex_unlock(&wl->mutex); | ||
4174 | return 0; | ||
4175 | } | ||
4176 | |||
4177 | /* Seeking is not supported - old logs are not kept. Disregard pos. */ | ||
4178 | len = min(count, (size_t)wl->fwlog_size); | ||
4179 | wl->fwlog_size -= len; | ||
4180 | memcpy(buffer, wl->fwlog, len); | ||
4181 | |||
4182 | /* Make room for new messages */ | ||
4183 | memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size); | ||
4184 | |||
4185 | mutex_unlock(&wl->mutex); | ||
4186 | |||
4187 | return len; | ||
4188 | } | ||
4189 | |||
4190 | static struct bin_attribute fwlog_attr = { | ||
4191 | .attr = {.name = "fwlog", .mode = S_IRUSR}, | ||
4192 | .read = wl1271_sysfs_read_fwlog, | ||
4193 | }; | ||
4194 | |||
4195 | int wl1271_register_hw(struct wl1271 *wl) | ||
4196 | { | ||
4197 | int ret; | ||
4198 | |||
4199 | if (wl->mac80211_registered) | ||
4200 | return 0; | ||
4201 | |||
4202 | ret = wl1271_fetch_nvs(wl); | ||
4203 | if (ret == 0) { | ||
4204 | /* NOTE: The wl->nvs->nvs element must be first, in | ||
4205 | * order to simplify the casting, we assume it is at | ||
4206 | * the beginning of the wl->nvs structure. | ||
4207 | */ | ||
4208 | u8 *nvs_ptr = (u8 *)wl->nvs; | ||
4209 | |||
4210 | wl->mac_addr[0] = nvs_ptr[11]; | ||
4211 | wl->mac_addr[1] = nvs_ptr[10]; | ||
4212 | wl->mac_addr[2] = nvs_ptr[6]; | ||
4213 | wl->mac_addr[3] = nvs_ptr[5]; | ||
4214 | wl->mac_addr[4] = nvs_ptr[4]; | ||
4215 | wl->mac_addr[5] = nvs_ptr[3]; | ||
4216 | } | ||
4217 | |||
4218 | SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr); | ||
4219 | |||
4220 | ret = ieee80211_register_hw(wl->hw); | ||
4221 | if (ret < 0) { | ||
4222 | wl1271_error("unable to register mac80211 hw: %d", ret); | ||
4223 | return ret; | ||
4224 | } | ||
4225 | |||
4226 | wl->mac80211_registered = true; | ||
4227 | |||
4228 | wl1271_debugfs_init(wl); | ||
4229 | |||
4230 | register_netdevice_notifier(&wl1271_dev_notifier); | ||
4231 | |||
4232 | wl1271_notice("loaded"); | ||
4233 | |||
4234 | return 0; | ||
4235 | } | ||
4236 | EXPORT_SYMBOL_GPL(wl1271_register_hw); | ||
4237 | |||
4238 | void wl1271_unregister_hw(struct wl1271 *wl) | ||
4239 | { | ||
4240 | if (wl->state == WL1271_STATE_PLT) | ||
4241 | __wl1271_plt_stop(wl); | ||
4242 | |||
4243 | unregister_netdevice_notifier(&wl1271_dev_notifier); | ||
4244 | ieee80211_unregister_hw(wl->hw); | ||
4245 | wl->mac80211_registered = false; | ||
4246 | |||
4247 | } | ||
4248 | EXPORT_SYMBOL_GPL(wl1271_unregister_hw); | ||
4249 | |||
4250 | int wl1271_init_ieee80211(struct wl1271 *wl) | ||
4251 | { | ||
4252 | static const u32 cipher_suites[] = { | ||
4253 | WLAN_CIPHER_SUITE_WEP40, | ||
4254 | WLAN_CIPHER_SUITE_WEP104, | ||
4255 | WLAN_CIPHER_SUITE_TKIP, | ||
4256 | WLAN_CIPHER_SUITE_CCMP, | ||
4257 | WL1271_CIPHER_SUITE_GEM, | ||
4258 | }; | ||
4259 | |||
4260 | /* The tx descriptor buffer and the TKIP space. */ | ||
4261 | wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE + | ||
4262 | sizeof(struct wl1271_tx_hw_descr); | ||
4263 | |||
4264 | /* unit us */ | ||
4265 | /* FIXME: find a proper value */ | ||
4266 | wl->hw->channel_change_time = 10000; | ||
4267 | wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval; | ||
4268 | |||
4269 | wl->hw->flags = IEEE80211_HW_SIGNAL_DBM | | ||
4270 | IEEE80211_HW_BEACON_FILTER | | ||
4271 | IEEE80211_HW_SUPPORTS_PS | | ||
4272 | IEEE80211_HW_SUPPORTS_UAPSD | | ||
4273 | IEEE80211_HW_HAS_RATE_CONTROL | | ||
4274 | IEEE80211_HW_CONNECTION_MONITOR | | ||
4275 | IEEE80211_HW_SUPPORTS_CQM_RSSI | | ||
4276 | IEEE80211_HW_REPORTS_TX_ACK_STATUS | | ||
4277 | IEEE80211_HW_SPECTRUM_MGMT | | ||
4278 | IEEE80211_HW_AP_LINK_PS; | ||
4279 | |||
4280 | wl->hw->wiphy->cipher_suites = cipher_suites; | ||
4281 | wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); | ||
4282 | |||
4283 | wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | | ||
4284 | BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP); | ||
4285 | wl->hw->wiphy->max_scan_ssids = 1; | ||
4286 | wl->hw->wiphy->max_sched_scan_ssids = 1; | ||
4287 | /* | ||
4288 | * Maximum length of elements in scanning probe request templates | ||
4289 | * should be the maximum length possible for a template, without | ||
4290 | * the IEEE80211 header of the template | ||
4291 | */ | ||
4292 | wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE - | ||
4293 | sizeof(struct ieee80211_header); | ||
4294 | |||
4295 | /* make sure all our channels fit in the scanned_ch bitmask */ | ||
4296 | BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) + | ||
4297 | ARRAY_SIZE(wl1271_channels_5ghz) > | ||
4298 | WL1271_MAX_CHANNELS); | ||
4299 | /* | ||
4300 | * We keep local copies of the band structs because we need to | ||
4301 | * modify them on a per-device basis. | ||
4302 | */ | ||
4303 | memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz, | ||
4304 | sizeof(wl1271_band_2ghz)); | ||
4305 | memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz, | ||
4306 | sizeof(wl1271_band_5ghz)); | ||
4307 | |||
4308 | wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = | ||
4309 | &wl->bands[IEEE80211_BAND_2GHZ]; | ||
4310 | wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = | ||
4311 | &wl->bands[IEEE80211_BAND_5GHZ]; | ||
4312 | |||
4313 | wl->hw->queues = 4; | ||
4314 | wl->hw->max_rates = 1; | ||
4315 | |||
4316 | wl->hw->wiphy->reg_notifier = wl1271_reg_notify; | ||
4317 | |||
4318 | SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl)); | ||
4319 | |||
4320 | wl->hw->sta_data_size = sizeof(struct wl1271_station); | ||
4321 | |||
4322 | wl->hw->max_rx_aggregation_subframes = 8; | ||
4323 | |||
4324 | return 0; | ||
4325 | } | ||
4326 | EXPORT_SYMBOL_GPL(wl1271_init_ieee80211); | ||
4327 | |||
4328 | #define WL1271_DEFAULT_CHANNEL 0 | ||
4329 | |||
4330 | struct ieee80211_hw *wl1271_alloc_hw(void) | ||
4331 | { | ||
4332 | struct ieee80211_hw *hw; | ||
4333 | struct platform_device *plat_dev = NULL; | ||
4334 | struct wl1271 *wl; | ||
4335 | int i, j, ret; | ||
4336 | unsigned int order; | ||
4337 | |||
4338 | hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops); | ||
4339 | if (!hw) { | ||
4340 | wl1271_error("could not alloc ieee80211_hw"); | ||
4341 | ret = -ENOMEM; | ||
4342 | goto err_hw_alloc; | ||
4343 | } | ||
4344 | |||
4345 | plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL); | ||
4346 | if (!plat_dev) { | ||
4347 | wl1271_error("could not allocate platform_device"); | ||
4348 | ret = -ENOMEM; | ||
4349 | goto err_plat_alloc; | ||
4350 | } | ||
4351 | |||
4352 | wl = hw->priv; | ||
4353 | memset(wl, 0, sizeof(*wl)); | ||
4354 | |||
4355 | INIT_LIST_HEAD(&wl->list); | ||
4356 | |||
4357 | wl->hw = hw; | ||
4358 | wl->plat_dev = plat_dev; | ||
4359 | |||
4360 | for (i = 0; i < NUM_TX_QUEUES; i++) | ||
4361 | skb_queue_head_init(&wl->tx_queue[i]); | ||
4362 | |||
4363 | for (i = 0; i < NUM_TX_QUEUES; i++) | ||
4364 | for (j = 0; j < AP_MAX_LINKS; j++) | ||
4365 | skb_queue_head_init(&wl->links[j].tx_queue[i]); | ||
4366 | |||
4367 | skb_queue_head_init(&wl->deferred_rx_queue); | ||
4368 | skb_queue_head_init(&wl->deferred_tx_queue); | ||
4369 | |||
4370 | INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work); | ||
4371 | INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work); | ||
4372 | INIT_WORK(&wl->netstack_work, wl1271_netstack_work); | ||
4373 | INIT_WORK(&wl->tx_work, wl1271_tx_work); | ||
4374 | INIT_WORK(&wl->recovery_work, wl1271_recovery_work); | ||
4375 | INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work); | ||
4376 | INIT_WORK(&wl->rx_streaming_enable_work, | ||
4377 | wl1271_rx_streaming_enable_work); | ||
4378 | INIT_WORK(&wl->rx_streaming_disable_work, | ||
4379 | wl1271_rx_streaming_disable_work); | ||
4380 | |||
4381 | wl->freezable_wq = create_freezable_workqueue("wl12xx_wq"); | ||
4382 | if (!wl->freezable_wq) { | ||
4383 | ret = -ENOMEM; | ||
4384 | goto err_hw; | ||
4385 | } | ||
4386 | |||
4387 | wl->channel = WL1271_DEFAULT_CHANNEL; | ||
4388 | wl->beacon_int = WL1271_DEFAULT_BEACON_INT; | ||
4389 | wl->default_key = 0; | ||
4390 | wl->rx_counter = 0; | ||
4391 | wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG; | ||
4392 | wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER; | ||
4393 | wl->psm_entry_retry = 0; | ||
4394 | wl->power_level = WL1271_DEFAULT_POWER_LEVEL; | ||
4395 | wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC; | ||
4396 | wl->basic_rate = CONF_TX_RATE_MASK_BASIC; | ||
4397 | wl->rate_set = CONF_TX_RATE_MASK_BASIC; | ||
4398 | wl->band = IEEE80211_BAND_2GHZ; | ||
4399 | wl->vif = NULL; | ||
4400 | wl->flags = 0; | ||
4401 | wl->sg_enabled = true; | ||
4402 | wl->hw_pg_ver = -1; | ||
4403 | wl->bss_type = MAX_BSS_TYPE; | ||
4404 | wl->set_bss_type = MAX_BSS_TYPE; | ||
4405 | wl->fw_bss_type = MAX_BSS_TYPE; | ||
4406 | wl->last_tx_hlid = 0; | ||
4407 | wl->ap_ps_map = 0; | ||
4408 | wl->ap_fw_ps_map = 0; | ||
4409 | wl->quirks = 0; | ||
4410 | wl->platform_quirks = 0; | ||
4411 | wl->sched_scanning = false; | ||
4412 | wl->tx_security_seq = 0; | ||
4413 | wl->tx_security_last_seq_lsb = 0; | ||
4414 | |||
4415 | setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer, | ||
4416 | (unsigned long) wl); | ||
4417 | wl->fwlog_size = 0; | ||
4418 | init_waitqueue_head(&wl->fwlog_waitq); | ||
4419 | |||
4420 | memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map)); | ||
4421 | for (i = 0; i < ACX_TX_DESCRIPTORS; i++) | ||
4422 | wl->tx_frames[i] = NULL; | ||
4423 | |||
4424 | spin_lock_init(&wl->wl_lock); | ||
4425 | |||
4426 | wl->state = WL1271_STATE_OFF; | ||
4427 | mutex_init(&wl->mutex); | ||
4428 | |||
4429 | /* Apply default driver configuration. */ | ||
4430 | wl1271_conf_init(wl); | ||
4431 | |||
4432 | order = get_order(WL1271_AGGR_BUFFER_SIZE); | ||
4433 | wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order); | ||
4434 | if (!wl->aggr_buf) { | ||
4435 | ret = -ENOMEM; | ||
4436 | goto err_wq; | ||
4437 | } | ||
4438 | |||
4439 | wl->dummy_packet = wl12xx_alloc_dummy_packet(wl); | ||
4440 | if (!wl->dummy_packet) { | ||
4441 | ret = -ENOMEM; | ||
4442 | goto err_aggr; | ||
4443 | } | ||
4444 | |||
4445 | /* Allocate one page for the FW log */ | ||
4446 | wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL); | ||
4447 | if (!wl->fwlog) { | ||
4448 | ret = -ENOMEM; | ||
4449 | goto err_dummy_packet; | ||
4450 | } | ||
4451 | |||
4452 | /* Register platform device */ | ||
4453 | ret = platform_device_register(wl->plat_dev); | ||
4454 | if (ret) { | ||
4455 | wl1271_error("couldn't register platform device"); | ||
4456 | goto err_fwlog; | ||
4457 | } | ||
4458 | dev_set_drvdata(&wl->plat_dev->dev, wl); | ||
4459 | |||
4460 | /* Create sysfs file to control bt coex state */ | ||
4461 | ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state); | ||
4462 | if (ret < 0) { | ||
4463 | wl1271_error("failed to create sysfs file bt_coex_state"); | ||
4464 | goto err_platform; | ||
4465 | } | ||
4466 | |||
4467 | /* Create sysfs file to get HW PG version */ | ||
4468 | ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver); | ||
4469 | if (ret < 0) { | ||
4470 | wl1271_error("failed to create sysfs file hw_pg_ver"); | ||
4471 | goto err_bt_coex_state; | ||
4472 | } | ||
4473 | |||
4474 | /* Create sysfs file for the FW log */ | ||
4475 | ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr); | ||
4476 | if (ret < 0) { | ||
4477 | wl1271_error("failed to create sysfs file fwlog"); | ||
4478 | goto err_hw_pg_ver; | ||
4479 | } | ||
4480 | |||
4481 | return hw; | ||
4482 | |||
4483 | err_hw_pg_ver: | ||
4484 | device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver); | ||
4485 | |||
4486 | err_bt_coex_state: | ||
4487 | device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state); | ||
4488 | |||
4489 | err_platform: | ||
4490 | platform_device_unregister(wl->plat_dev); | ||
4491 | |||
4492 | err_fwlog: | ||
4493 | free_page((unsigned long)wl->fwlog); | ||
4494 | |||
4495 | err_dummy_packet: | ||
4496 | dev_kfree_skb(wl->dummy_packet); | ||
4497 | |||
4498 | err_aggr: | ||
4499 | free_pages((unsigned long)wl->aggr_buf, order); | ||
4500 | |||
4501 | err_wq: | ||
4502 | destroy_workqueue(wl->freezable_wq); | ||
4503 | |||
4504 | err_hw: | ||
4505 | wl1271_debugfs_exit(wl); | ||
4506 | kfree(plat_dev); | ||
4507 | |||
4508 | err_plat_alloc: | ||
4509 | ieee80211_free_hw(hw); | ||
4510 | |||
4511 | err_hw_alloc: | ||
4512 | |||
4513 | return ERR_PTR(ret); | ||
4514 | } | ||
4515 | EXPORT_SYMBOL_GPL(wl1271_alloc_hw); | ||
4516 | |||
4517 | int wl1271_free_hw(struct wl1271 *wl) | ||
4518 | { | ||
4519 | /* Unblock any fwlog readers */ | ||
4520 | mutex_lock(&wl->mutex); | ||
4521 | wl->fwlog_size = -1; | ||
4522 | wake_up_interruptible_all(&wl->fwlog_waitq); | ||
4523 | mutex_unlock(&wl->mutex); | ||
4524 | |||
4525 | device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr); | ||
4526 | platform_device_unregister(wl->plat_dev); | ||
4527 | free_page((unsigned long)wl->fwlog); | ||
4528 | dev_kfree_skb(wl->dummy_packet); | ||
4529 | free_pages((unsigned long)wl->aggr_buf, | ||
4530 | get_order(WL1271_AGGR_BUFFER_SIZE)); | ||
4531 | kfree(wl->plat_dev); | ||
4532 | |||
4533 | wl1271_debugfs_exit(wl); | ||
4534 | |||
4535 | vfree(wl->fw); | ||
4536 | wl->fw = NULL; | ||
4537 | kfree(wl->nvs); | ||
4538 | wl->nvs = NULL; | ||
4539 | |||
4540 | kfree(wl->fw_status); | ||
4541 | kfree(wl->tx_res_if); | ||
4542 | destroy_workqueue(wl->freezable_wq); | ||
4543 | |||
4544 | ieee80211_free_hw(wl->hw); | ||
4545 | |||
4546 | return 0; | ||
4547 | } | ||
4548 | EXPORT_SYMBOL_GPL(wl1271_free_hw); | ||
4549 | |||
4550 | u32 wl12xx_debug_level = DEBUG_NONE; | ||
4551 | EXPORT_SYMBOL_GPL(wl12xx_debug_level); | ||
4552 | module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR); | ||
4553 | MODULE_PARM_DESC(debug_level, "wl12xx debugging level"); | ||
4554 | |||
4555 | module_param_named(fwlog, fwlog_param, charp, 0); | ||
4556 | MODULE_PARM_DESC(keymap, | ||
4557 | "FW logger options: continuous, ondemand, dbgpins or disable"); | ||
4558 | |||
4559 | MODULE_LICENSE("GPL"); | ||
4560 | MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>"); | ||
4561 | MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>"); | ||