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