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