projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'batman-adv-for-davem' of git://git.open-mesh.org/linux-merge
[deliverable/linux.git] / drivers / net / wireless / wl12xx / main.c
1
2 /*
3 * This file is part of wl1271
4 *
5 * Copyright (C) 2008-2010 Nokia Corporation
6 *
7 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * version 2 as published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21 * 02110-1301 USA
22 *
23 */
24
25 #include <linux/module.h>
26 #include <linux/firmware.h>
27 #include <linux/delay.h>
28 #include <linux/spi/spi.h>
29 #include <linux/crc32.h>
30 #include <linux/etherdevice.h>
31 #include <linux/vmalloc.h>
32 #include <linux/platform_device.h>
33 #include <linux/slab.h>
34 #include <linux/wl12xx.h>
35 #include <linux/sched.h>
36 #include <linux/interrupt.h>
37
38 #include "wl12xx.h"
39 #include "debug.h"
40 #include "wl12xx_80211.h"
41 #include "reg.h"
42 #include "io.h"
43 #include "event.h"
44 #include "tx.h"
45 #include "rx.h"
46 #include "ps.h"
47 #include "init.h"
48 #include "debugfs.h"
49 #include "cmd.h"
50 #include "boot.h"
51 #include "testmode.h"
52 #include "scan.h"
53
54 #define WL1271_BOOT_RETRIES 3
55
56 static struct conf_drv_settings default_conf = {
57 .sg = {
58 .params = {
59 [CONF_SG_ACL_BT_MASTER_MIN_BR] = 10,
60 [CONF_SG_ACL_BT_MASTER_MAX_BR] = 180,
61 [CONF_SG_ACL_BT_SLAVE_MIN_BR] = 10,
62 [CONF_SG_ACL_BT_SLAVE_MAX_BR] = 180,
63 [CONF_SG_ACL_BT_MASTER_MIN_EDR] = 10,
64 [CONF_SG_ACL_BT_MASTER_MAX_EDR] = 80,
65 [CONF_SG_ACL_BT_SLAVE_MIN_EDR] = 10,
66 [CONF_SG_ACL_BT_SLAVE_MAX_EDR] = 80,
67 [CONF_SG_ACL_WLAN_PS_MASTER_BR] = 8,
68 [CONF_SG_ACL_WLAN_PS_SLAVE_BR] = 8,
69 [CONF_SG_ACL_WLAN_PS_MASTER_EDR] = 20,
70 [CONF_SG_ACL_WLAN_PS_SLAVE_EDR] = 20,
71 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_BR] = 20,
72 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_BR] = 35,
73 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_BR] = 16,
74 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_BR] = 35,
75 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_EDR] = 32,
76 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_EDR] = 50,
77 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_EDR] = 28,
78 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_EDR] = 50,
79 [CONF_SG_ACL_ACTIVE_SCAN_WLAN_BR] = 10,
80 [CONF_SG_ACL_ACTIVE_SCAN_WLAN_EDR] = 20,
81 [CONF_SG_ACL_PASSIVE_SCAN_BT_BR] = 75,
82 [CONF_SG_ACL_PASSIVE_SCAN_WLAN_BR] = 15,
83 [CONF_SG_ACL_PASSIVE_SCAN_BT_EDR] = 27,
84 [CONF_SG_ACL_PASSIVE_SCAN_WLAN_EDR] = 17,
85 /* active scan params */
86 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
87 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
88 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
89 /* passive scan params */
90 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_BR] = 800,
91 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_EDR] = 200,
92 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
93 /* passive scan in dual antenna params */
94 [CONF_SG_CONSECUTIVE_HV3_IN_PASSIVE_SCAN] = 0,
95 [CONF_SG_BCN_HV3_COLLISION_THRESH_IN_PASSIVE_SCAN] = 0,
96 [CONF_SG_TX_RX_PROTECTION_BWIDTH_IN_PASSIVE_SCAN] = 0,
97 /* general params */
98 [CONF_SG_STA_FORCE_PS_IN_BT_SCO] = 1,
99 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
100 [CONF_SG_BEACON_MISS_PERCENT] = 60,
101 [CONF_SG_DHCP_TIME] = 5000,
102 [CONF_SG_RXT] = 1200,
103 [CONF_SG_TXT] = 1000,
104 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
105 [CONF_SG_GENERAL_USAGE_BIT_MAP] = 3,
106 [CONF_SG_HV3_MAX_SERVED] = 6,
107 [CONF_SG_PS_POLL_TIMEOUT] = 10,
108 [CONF_SG_UPSD_TIMEOUT] = 10,
109 [CONF_SG_CONSECUTIVE_CTS_THRESHOLD] = 2,
110 [CONF_SG_STA_RX_WINDOW_AFTER_DTIM] = 5,
111 [CONF_SG_STA_CONNECTION_PROTECTION_TIME] = 30,
112 /* AP params */
113 [CONF_AP_BEACON_MISS_TX] = 3,
114 [CONF_AP_RX_WINDOW_AFTER_BEACON] = 10,
115 [CONF_AP_BEACON_WINDOW_INTERVAL] = 2,
116 [CONF_AP_CONNECTION_PROTECTION_TIME] = 0,
117 [CONF_AP_BT_ACL_VAL_BT_SERVE_TIME] = 25,
118 [CONF_AP_BT_ACL_VAL_WL_SERVE_TIME] = 25,
119 /* CTS Diluting params */
120 [CONF_SG_CTS_DILUTED_BAD_RX_PACKETS_TH] = 0,
121 [CONF_SG_CTS_CHOP_IN_DUAL_ANT_SCO_MASTER] = 0,
122 },
123 .state = CONF_SG_PROTECTIVE,
124 },
125 .rx = {
126 .rx_msdu_life_time = 512000,
127 .packet_detection_threshold = 0,
128 .ps_poll_timeout = 15,
129 .upsd_timeout = 15,
130 .rts_threshold = IEEE80211_MAX_RTS_THRESHOLD,
131 .rx_cca_threshold = 0,
132 .irq_blk_threshold = 0xFFFF,
133 .irq_pkt_threshold = 0,
134 .irq_timeout = 600,
135 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
136 },
137 .tx = {
138 .tx_energy_detection = 0,
139 .sta_rc_conf = {
140 .enabled_rates = 0,
141 .short_retry_limit = 10,
142 .long_retry_limit = 10,
143 .aflags = 0,
144 },
145 .ac_conf_count = 4,
146 .ac_conf = {
147 [CONF_TX_AC_BE] = {
148 .ac = CONF_TX_AC_BE,
149 .cw_min = 15,
150 .cw_max = 63,
151 .aifsn = 3,
152 .tx_op_limit = 0,
153 },
154 [CONF_TX_AC_BK] = {
155 .ac = CONF_TX_AC_BK,
156 .cw_min = 15,
157 .cw_max = 63,
158 .aifsn = 7,
159 .tx_op_limit = 0,
160 },
161 [CONF_TX_AC_VI] = {
162 .ac = CONF_TX_AC_VI,
163 .cw_min = 15,
164 .cw_max = 63,
165 .aifsn = CONF_TX_AIFS_PIFS,
166 .tx_op_limit = 3008,
167 },
168 [CONF_TX_AC_VO] = {
169 .ac = CONF_TX_AC_VO,
170 .cw_min = 15,
171 .cw_max = 63,
172 .aifsn = CONF_TX_AIFS_PIFS,
173 .tx_op_limit = 1504,
174 },
175 },
176 .max_tx_retries = 100,
177 .ap_aging_period = 300,
178 .tid_conf_count = 4,
179 .tid_conf = {
180 [CONF_TX_AC_BE] = {
181 .queue_id = CONF_TX_AC_BE,
182 .channel_type = CONF_CHANNEL_TYPE_EDCF,
183 .tsid = CONF_TX_AC_BE,
184 .ps_scheme = CONF_PS_SCHEME_LEGACY,
185 .ack_policy = CONF_ACK_POLICY_LEGACY,
186 .apsd_conf = {0, 0},
187 },
188 [CONF_TX_AC_BK] = {
189 .queue_id = CONF_TX_AC_BK,
190 .channel_type = CONF_CHANNEL_TYPE_EDCF,
191 .tsid = CONF_TX_AC_BK,
192 .ps_scheme = CONF_PS_SCHEME_LEGACY,
193 .ack_policy = CONF_ACK_POLICY_LEGACY,
194 .apsd_conf = {0, 0},
195 },
196 [CONF_TX_AC_VI] = {
197 .queue_id = CONF_TX_AC_VI,
198 .channel_type = CONF_CHANNEL_TYPE_EDCF,
199 .tsid = CONF_TX_AC_VI,
200 .ps_scheme = CONF_PS_SCHEME_LEGACY,
201 .ack_policy = CONF_ACK_POLICY_LEGACY,
202 .apsd_conf = {0, 0},
203 },
204 [CONF_TX_AC_VO] = {
205 .queue_id = CONF_TX_AC_VO,
206 .channel_type = CONF_CHANNEL_TYPE_EDCF,
207 .tsid = CONF_TX_AC_VO,
208 .ps_scheme = CONF_PS_SCHEME_LEGACY,
209 .ack_policy = CONF_ACK_POLICY_LEGACY,
210 .apsd_conf = {0, 0},
211 },
212 },
213 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
214 .tx_compl_timeout = 700,
215 .tx_compl_threshold = 4,
216 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
217 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
218 .tmpl_short_retry_limit = 10,
219 .tmpl_long_retry_limit = 10,
220 .tx_watchdog_timeout = 5000,
221 },
222 .conn = {
223 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
224 .listen_interval = 1,
225 .suspend_wake_up_event = CONF_WAKE_UP_EVENT_N_DTIM,
226 .suspend_listen_interval = 3,
227 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
228 .bcn_filt_ie_count = 2,
229 .bcn_filt_ie = {
230 [0] = {
231 .ie = WLAN_EID_CHANNEL_SWITCH,
232 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
233 },
234 [1] = {
235 .ie = WLAN_EID_HT_OPERATION,
236 .rule = CONF_BCN_RULE_PASS_ON_CHANGE,
237 },
238 },
239 .synch_fail_thold = 10,
240 .bss_lose_timeout = 100,
241 .beacon_rx_timeout = 10000,
242 .broadcast_timeout = 20000,
243 .rx_broadcast_in_ps = 1,
244 .ps_poll_threshold = 10,
245 .bet_enable = CONF_BET_MODE_ENABLE,
246 .bet_max_consecutive = 50,
247 .psm_entry_retries = 8,
248 .psm_exit_retries = 16,
249 .psm_entry_nullfunc_retries = 3,
250 .dynamic_ps_timeout = 200,
251 .forced_ps = false,
252 .keep_alive_interval = 55000,
253 .max_listen_interval = 20,
254 },
255 .itrim = {
256 .enable = false,
257 .timeout = 50000,
258 },
259 .pm_config = {
260 .host_clk_settling_time = 5000,
261 .host_fast_wakeup_support = false
262 },
263 .roam_trigger = {
264 .trigger_pacing = 1,
265 .avg_weight_rssi_beacon = 20,
266 .avg_weight_rssi_data = 10,
267 .avg_weight_snr_beacon = 20,
268 .avg_weight_snr_data = 10,
269 },
270 .scan = {
271 .min_dwell_time_active = 7500,
272 .max_dwell_time_active = 30000,
273 .min_dwell_time_passive = 100000,
274 .max_dwell_time_passive = 100000,
275 .num_probe_reqs = 2,
276 .split_scan_timeout = 50000,
277 },
278 .sched_scan = {
279 /* sched_scan requires dwell times in TU instead of TU/1000 */
280 .min_dwell_time_active = 30,
281 .max_dwell_time_active = 60,
282 .dwell_time_passive = 100,
283 .dwell_time_dfs = 150,
284 .num_probe_reqs = 2,
285 .rssi_threshold = -90,
286 .snr_threshold = 0,
287 },
288 .rf = {
289 .tx_per_channel_power_compensation_2 = {
290 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
291 },
292 .tx_per_channel_power_compensation_5 = {
293 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
294 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
295 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
296 },
297 },
298 .ht = {
299 .rx_ba_win_size = 8,
300 .tx_ba_win_size = 64,
301 .inactivity_timeout = 10000,
302 .tx_ba_tid_bitmap = CONF_TX_BA_ENABLED_TID_BITMAP,
303 },
304 .mem_wl127x = {
305 .num_stations = 1,
306 .ssid_profiles = 1,
307 .rx_block_num = 70,
308 .tx_min_block_num = 40,
309 .dynamic_memory = 1,
310 .min_req_tx_blocks = 100,
311 .min_req_rx_blocks = 22,
312 .tx_min = 27,
313 },
314 .mem_wl128x = {
315 .num_stations = 1,
316 .ssid_profiles = 1,
317 .rx_block_num = 40,
318 .tx_min_block_num = 40,
319 .dynamic_memory = 1,
320 .min_req_tx_blocks = 45,
321 .min_req_rx_blocks = 22,
322 .tx_min = 27,
323 },
324 .fm_coex = {
325 .enable = true,
326 .swallow_period = 5,
327 .n_divider_fref_set_1 = 0xff, /* default */
328 .n_divider_fref_set_2 = 12,
329 .m_divider_fref_set_1 = 148,
330 .m_divider_fref_set_2 = 0xffff, /* default */
331 .coex_pll_stabilization_time = 0xffffffff, /* default */
332 .ldo_stabilization_time = 0xffff, /* default */
333 .fm_disturbed_band_margin = 0xff, /* default */
334 .swallow_clk_diff = 0xff, /* default */
335 },
336 .rx_streaming = {
337 .duration = 150,
338 .queues = 0x1,
339 .interval = 20,
340 .always = 0,
341 },
342 .fwlog = {
343 .mode = WL12XX_FWLOG_ON_DEMAND,
344 .mem_blocks = 2,
345 .severity = 0,
346 .timestamp = WL12XX_FWLOG_TIMESTAMP_DISABLED,
347 .output = WL12XX_FWLOG_OUTPUT_HOST,
348 .threshold = 0,
349 },
350 .hci_io_ds = HCI_IO_DS_6MA,
351 .rate = {
352 .rate_retry_score = 32000,
353 .per_add = 8192,
354 .per_th1 = 2048,
355 .per_th2 = 4096,
356 .max_per = 8100,
357 .inverse_curiosity_factor = 5,
358 .tx_fail_low_th = 4,
359 .tx_fail_high_th = 10,
360 .per_alpha_shift = 4,
361 .per_add_shift = 13,
362 .per_beta1_shift = 10,
363 .per_beta2_shift = 8,
364 .rate_check_up = 2,
365 .rate_check_down = 12,
366 .rate_retry_policy = {
367 0x00, 0x00, 0x00, 0x00, 0x00,
368 0x00, 0x00, 0x00, 0x00, 0x00,
369 0x00, 0x00, 0x00,
370 },
371 },
372 .hangover = {
373 .recover_time = 0,
374 .hangover_period = 20,
375 .dynamic_mode = 1,
376 .early_termination_mode = 1,
377 .max_period = 20,
378 .min_period = 1,
379 .increase_delta = 1,
380 .decrease_delta = 2,
381 .quiet_time = 4,
382 .increase_time = 1,
383 .window_size = 16,
384 },
385 };
386
387 static char *fwlog_param;
388 static bool bug_on_recovery;
389
390 static void __wl1271_op_remove_interface(struct wl1271 *wl,
391 struct ieee80211_vif *vif,
392 bool reset_tx_queues);
393 static void wl1271_op_stop(struct ieee80211_hw *hw);
394 static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif);
395
396 static int wl12xx_set_authorized(struct wl1271 *wl,
397 struct wl12xx_vif *wlvif)
398 {
399 int ret;
400
401 if (WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS))
402 return -EINVAL;
403
404 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
405 return 0;
406
407 if (test_and_set_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags))
408 return 0;
409
410 ret = wl12xx_cmd_set_peer_state(wl, wlvif->sta.hlid);
411 if (ret < 0)
412 return ret;
413
414 wl12xx_croc(wl, wlvif->role_id);
415
416 wl1271_info("Association completed.");
417 return 0;
418 }
419
420 static int wl1271_reg_notify(struct wiphy *wiphy,
421 struct regulatory_request *request)
422 {
423 struct ieee80211_supported_band *band;
424 struct ieee80211_channel *ch;
425 int i;
426
427 band = wiphy->bands[IEEE80211_BAND_5GHZ];
428 for (i = 0; i < band->n_channels; i++) {
429 ch = &band->channels[i];
430 if (ch->flags & IEEE80211_CHAN_DISABLED)
431 continue;
432
433 if (ch->flags & IEEE80211_CHAN_RADAR)
434 ch->flags |= IEEE80211_CHAN_NO_IBSS |
435 IEEE80211_CHAN_PASSIVE_SCAN;
436
437 }
438
439 return 0;
440 }
441
442 static int wl1271_set_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif,
443 bool enable)
444 {
445 int ret = 0;
446
447 /* we should hold wl->mutex */
448 ret = wl1271_acx_ps_rx_streaming(wl, wlvif, enable);
449 if (ret < 0)
450 goto out;
451
452 if (enable)
453 set_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
454 else
455 clear_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
456 out:
457 return ret;
458 }
459
460 /*
461 * this function is being called when the rx_streaming interval
462 * has beed changed or rx_streaming should be disabled
463 */
464 int wl1271_recalc_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif)
465 {
466 int ret = 0;
467 int period = wl->conf.rx_streaming.interval;
468
469 /* don't reconfigure if rx_streaming is disabled */
470 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
471 goto out;
472
473 /* reconfigure/disable according to new streaming_period */
474 if (period &&
475 test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
476 (wl->conf.rx_streaming.always ||
477 test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
478 ret = wl1271_set_rx_streaming(wl, wlvif, true);
479 else {
480 ret = wl1271_set_rx_streaming(wl, wlvif, false);
481 /* don't cancel_work_sync since we might deadlock */
482 del_timer_sync(&wlvif->rx_streaming_timer);
483 }
484 out:
485 return ret;
486 }
487
488 static void wl1271_rx_streaming_enable_work(struct work_struct *work)
489 {
490 int ret;
491 struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
492 rx_streaming_enable_work);
493 struct wl1271 *wl = wlvif->wl;
494
495 mutex_lock(&wl->mutex);
496
497 if (test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags) ||
498 !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
499 (!wl->conf.rx_streaming.always &&
500 !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
501 goto out;
502
503 if (!wl->conf.rx_streaming.interval)
504 goto out;
505
506 ret = wl1271_ps_elp_wakeup(wl);
507 if (ret < 0)
508 goto out;
509
510 ret = wl1271_set_rx_streaming(wl, wlvif, true);
511 if (ret < 0)
512 goto out_sleep;
513
514 /* stop it after some time of inactivity */
515 mod_timer(&wlvif->rx_streaming_timer,
516 jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));
517
518 out_sleep:
519 wl1271_ps_elp_sleep(wl);
520 out:
521 mutex_unlock(&wl->mutex);
522 }
523
524 static void wl1271_rx_streaming_disable_work(struct work_struct *work)
525 {
526 int ret;
527 struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
528 rx_streaming_disable_work);
529 struct wl1271 *wl = wlvif->wl;
530
531 mutex_lock(&wl->mutex);
532
533 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
534 goto out;
535
536 ret = wl1271_ps_elp_wakeup(wl);
537 if (ret < 0)
538 goto out;
539
540 ret = wl1271_set_rx_streaming(wl, wlvif, false);
541 if (ret)
542 goto out_sleep;
543
544 out_sleep:
545 wl1271_ps_elp_sleep(wl);
546 out:
547 mutex_unlock(&wl->mutex);
548 }
549
550 static void wl1271_rx_streaming_timer(unsigned long data)
551 {
552 struct wl12xx_vif *wlvif = (struct wl12xx_vif *)data;
553 struct wl1271 *wl = wlvif->wl;
554 ieee80211_queue_work(wl->hw, &wlvif->rx_streaming_disable_work);
555 }
556
557 /* wl->mutex must be taken */
558 void wl12xx_rearm_tx_watchdog_locked(struct wl1271 *wl)
559 {
560 /* if the watchdog is not armed, don't do anything */
561 if (wl->tx_allocated_blocks == 0)
562 return;
563
564 cancel_delayed_work(&wl->tx_watchdog_work);
565 ieee80211_queue_delayed_work(wl->hw, &wl->tx_watchdog_work,
566 msecs_to_jiffies(wl->conf.tx.tx_watchdog_timeout));
567 }
568
569 static void wl12xx_tx_watchdog_work(struct work_struct *work)
570 {
571 struct delayed_work *dwork;
572 struct wl1271 *wl;
573
574 dwork = container_of(work, struct delayed_work, work);
575 wl = container_of(dwork, struct wl1271, tx_watchdog_work);
576
577 mutex_lock(&wl->mutex);
578
579 if (unlikely(wl->state == WL1271_STATE_OFF))
580 goto out;
581
582 /* Tx went out in the meantime - everything is ok */
583 if (unlikely(wl->tx_allocated_blocks == 0))
584 goto out;
585
586 /*
587 * if a ROC is in progress, we might not have any Tx for a long
588 * time (e.g. pending Tx on the non-ROC channels)
589 */
590 if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
591 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to ROC",
592 wl->conf.tx.tx_watchdog_timeout);
593 wl12xx_rearm_tx_watchdog_locked(wl);
594 goto out;
595 }
596
597 /*
598 * if a scan is in progress, we might not have any Tx for a long
599 * time
600 */
601 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
602 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to scan",
603 wl->conf.tx.tx_watchdog_timeout);
604 wl12xx_rearm_tx_watchdog_locked(wl);
605 goto out;
606 }
607
608 /*
609 * AP might cache a frame for a long time for a sleeping station,
610 * so rearm the timer if there's an AP interface with stations. If
611 * Tx is genuinely stuck we will most hopefully discover it when all
612 * stations are removed due to inactivity.
613 */
614 if (wl->active_sta_count) {
615 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms. AP has "
616 " %d stations",
617 wl->conf.tx.tx_watchdog_timeout,
618 wl->active_sta_count);
619 wl12xx_rearm_tx_watchdog_locked(wl);
620 goto out;
621 }
622
623 wl1271_error("Tx stuck (in FW) for %d ms. Starting recovery",
624 wl->conf.tx.tx_watchdog_timeout);
625 wl12xx_queue_recovery_work(wl);
626
627 out:
628 mutex_unlock(&wl->mutex);
629 }
630
631 static void wl1271_conf_init(struct wl1271 *wl)
632 {
633
634 /*
635 * This function applies the default configuration to the driver. This
636 * function is invoked upon driver load (spi probe.)
637 *
638 * The configuration is stored in a run-time structure in order to
639 * facilitate for run-time adjustment of any of the parameters. Making
640 * changes to the configuration structure will apply the new values on
641 * the next interface up (wl1271_op_start.)
642 */
643
644 /* apply driver default configuration */
645 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
646
647 /* Adjust settings according to optional module parameters */
648 if (fwlog_param) {
649 if (!strcmp(fwlog_param, "continuous")) {
650 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
651 } else if (!strcmp(fwlog_param, "ondemand")) {
652 wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND;
653 } else if (!strcmp(fwlog_param, "dbgpins")) {
654 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
655 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS;
656 } else if (!strcmp(fwlog_param, "disable")) {
657 wl->conf.fwlog.mem_blocks = 0;
658 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
659 } else {
660 wl1271_error("Unknown fwlog parameter %s", fwlog_param);
661 }
662 }
663 }
664
665 static int wl1271_plt_init(struct wl1271 *wl)
666 {
667 int ret;
668
669 if (wl->chip.id == CHIP_ID_1283_PG20)
670 ret = wl128x_cmd_general_parms(wl);
671 else
672 ret = wl1271_cmd_general_parms(wl);
673 if (ret < 0)
674 return ret;
675
676 if (wl->chip.id == CHIP_ID_1283_PG20)
677 ret = wl128x_cmd_radio_parms(wl);
678 else
679 ret = wl1271_cmd_radio_parms(wl);
680 if (ret < 0)
681 return ret;
682
683 if (wl->chip.id != CHIP_ID_1283_PG20) {
684 ret = wl1271_cmd_ext_radio_parms(wl);
685 if (ret < 0)
686 return ret;
687 }
688
689 /* Chip-specific initializations */
690 ret = wl1271_chip_specific_init(wl);
691 if (ret < 0)
692 return ret;
693
694 ret = wl1271_acx_init_mem_config(wl);
695 if (ret < 0)
696 return ret;
697
698 ret = wl12xx_acx_mem_cfg(wl);
699 if (ret < 0)
700 goto out_free_memmap;
701
702 /* Enable data path */
703 ret = wl1271_cmd_data_path(wl, 1);
704 if (ret < 0)
705 goto out_free_memmap;
706
707 /* Configure for CAM power saving (ie. always active) */
708 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
709 if (ret < 0)
710 goto out_free_memmap;
711
712 /* configure PM */
713 ret = wl1271_acx_pm_config(wl);
714 if (ret < 0)
715 goto out_free_memmap;
716
717 return 0;
718
719 out_free_memmap:
720 kfree(wl->target_mem_map);
721 wl->target_mem_map = NULL;
722
723 return ret;
724 }
725
726 static void wl12xx_irq_ps_regulate_link(struct wl1271 *wl,
727 struct wl12xx_vif *wlvif,
728 u8 hlid, u8 tx_pkts)
729 {
730 bool fw_ps, single_sta;
731
732 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
733 single_sta = (wl->active_sta_count == 1);
734
735 /*
736 * Wake up from high level PS if the STA is asleep with too little
737 * packets in FW or if the STA is awake.
738 */
739 if (!fw_ps || tx_pkts < WL1271_PS_STA_MAX_PACKETS)
740 wl12xx_ps_link_end(wl, wlvif, hlid);
741
742 /*
743 * Start high-level PS if the STA is asleep with enough blocks in FW.
744 * Make an exception if this is the only connected station. In this
745 * case FW-memory congestion is not a problem.
746 */
747 else if (!single_sta && fw_ps && tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
748 wl12xx_ps_link_start(wl, wlvif, hlid, true);
749 }
750
751 static void wl12xx_irq_update_links_status(struct wl1271 *wl,
752 struct wl12xx_vif *wlvif,
753 struct wl12xx_fw_status *status)
754 {
755 struct wl1271_link *lnk;
756 u32 cur_fw_ps_map;
757 u8 hlid, cnt;
758
759 /* TODO: also use link_fast_bitmap here */
760
761 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
762 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
763 wl1271_debug(DEBUG_PSM,
764 "link ps prev 0x%x cur 0x%x changed 0x%x",
765 wl->ap_fw_ps_map, cur_fw_ps_map,
766 wl->ap_fw_ps_map ^ cur_fw_ps_map);
767
768 wl->ap_fw_ps_map = cur_fw_ps_map;
769 }
770
771 for_each_set_bit(hlid, wlvif->ap.sta_hlid_map, WL12XX_MAX_LINKS) {
772 lnk = &wl->links[hlid];
773 cnt = status->tx_lnk_free_pkts[hlid] - lnk->prev_freed_pkts;
774
775 lnk->prev_freed_pkts = status->tx_lnk_free_pkts[hlid];
776 lnk->allocated_pkts -= cnt;
777
778 wl12xx_irq_ps_regulate_link(wl, wlvif, hlid,
779 lnk->allocated_pkts);
780 }
781 }
782
783 static void wl12xx_fw_status(struct wl1271 *wl,
784 struct wl12xx_fw_status *status)
785 {
786 struct wl12xx_vif *wlvif;
787 struct timespec ts;
788 u32 old_tx_blk_count = wl->tx_blocks_available;
789 int avail, freed_blocks;
790 int i;
791
792 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
793
794 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
795 "drv_rx_counter = %d, tx_results_counter = %d)",
796 status->intr,
797 status->fw_rx_counter,
798 status->drv_rx_counter,
799 status->tx_results_counter);
800
801 for (i = 0; i < NUM_TX_QUEUES; i++) {
802 /* prevent wrap-around in freed-packets counter */
803 wl->tx_allocated_pkts[i] -=
804 (status->tx_released_pkts[i] -
805 wl->tx_pkts_freed[i]) & 0xff;
806
807 wl->tx_pkts_freed[i] = status->tx_released_pkts[i];
808 }
809
810 /* prevent wrap-around in total blocks counter */
811 if (likely(wl->tx_blocks_freed <=
812 le32_to_cpu(status->total_released_blks)))
813 freed_blocks = le32_to_cpu(status->total_released_blks) -
814 wl->tx_blocks_freed;
815 else
816 freed_blocks = 0x100000000LL - wl->tx_blocks_freed +
817 le32_to_cpu(status->total_released_blks);
818
819 wl->tx_blocks_freed = le32_to_cpu(status->total_released_blks);
820
821 wl->tx_allocated_blocks -= freed_blocks;
822
823 /*
824 * If the FW freed some blocks:
825 * If we still have allocated blocks - re-arm the timer, Tx is
826 * not stuck. Otherwise, cancel the timer (no Tx currently).
827 */
828 if (freed_blocks) {
829 if (wl->tx_allocated_blocks)
830 wl12xx_rearm_tx_watchdog_locked(wl);
831 else
832 cancel_delayed_work(&wl->tx_watchdog_work);
833 }
834
835 avail = le32_to_cpu(status->tx_total) - wl->tx_allocated_blocks;
836
837 /*
838 * The FW might change the total number of TX memblocks before
839 * we get a notification about blocks being released. Thus, the
840 * available blocks calculation might yield a temporary result
841 * which is lower than the actual available blocks. Keeping in
842 * mind that only blocks that were allocated can be moved from
843 * TX to RX, tx_blocks_available should never decrease here.
844 */
845 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
846 avail);
847
848 /* if more blocks are available now, tx work can be scheduled */
849 if (wl->tx_blocks_available > old_tx_blk_count)
850 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
851
852 /* for AP update num of allocated TX blocks per link and ps status */
853 wl12xx_for_each_wlvif_ap(wl, wlvif) {
854 wl12xx_irq_update_links_status(wl, wlvif, status);
855 }
856
857 /* update the host-chipset time offset */
858 getnstimeofday(&ts);
859 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
860 (s64)le32_to_cpu(status->fw_localtime);
861 }
862
863 static void wl1271_flush_deferred_work(struct wl1271 *wl)
864 {
865 struct sk_buff *skb;
866
867 /* Pass all received frames to the network stack */
868 while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
869 ieee80211_rx_ni(wl->hw, skb);
870
871 /* Return sent skbs to the network stack */
872 while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
873 ieee80211_tx_status_ni(wl->hw, skb);
874 }
875
876 static void wl1271_netstack_work(struct work_struct *work)
877 {
878 struct wl1271 *wl =
879 container_of(work, struct wl1271, netstack_work);
880
881 do {
882 wl1271_flush_deferred_work(wl);
883 } while (skb_queue_len(&wl->deferred_rx_queue));
884 }
885
886 #define WL1271_IRQ_MAX_LOOPS 256
887
888 static irqreturn_t wl1271_irq(int irq, void *cookie)
889 {
890 int ret;
891 u32 intr;
892 int loopcount = WL1271_IRQ_MAX_LOOPS;
893 struct wl1271 *wl = (struct wl1271 *)cookie;
894 bool done = false;
895 unsigned int defer_count;
896 unsigned long flags;
897
898 /* TX might be handled here, avoid redundant work */
899 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
900 cancel_work_sync(&wl->tx_work);
901
902 /*
903 * In case edge triggered interrupt must be used, we cannot iterate
904 * more than once without introducing race conditions with the hardirq.
905 */
906 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
907 loopcount = 1;
908
909 mutex_lock(&wl->mutex);
910
911 wl1271_debug(DEBUG_IRQ, "IRQ work");
912
913 if (unlikely(wl->state == WL1271_STATE_OFF))
914 goto out;
915
916 ret = wl1271_ps_elp_wakeup(wl);
917 if (ret < 0)
918 goto out;
919
920 while (!done && loopcount--) {
921 /*
922 * In order to avoid a race with the hardirq, clear the flag
923 * before acknowledging the chip. Since the mutex is held,
924 * wl1271_ps_elp_wakeup cannot be called concurrently.
925 */
926 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
927 smp_mb__after_clear_bit();
928
929 wl12xx_fw_status(wl, wl->fw_status);
930 intr = le32_to_cpu(wl->fw_status->intr);
931 intr &= WL1271_INTR_MASK;
932 if (!intr) {
933 done = true;
934 continue;
935 }
936
937 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
938 wl1271_error("watchdog interrupt received! "
939 "starting recovery.");
940 wl12xx_queue_recovery_work(wl);
941
942 /* restarting the chip. ignore any other interrupt. */
943 goto out;
944 }
945
946 if (likely(intr & WL1271_ACX_INTR_DATA)) {
947 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
948
949 wl12xx_rx(wl, wl->fw_status);
950
951 /* Check if any tx blocks were freed */
952 spin_lock_irqsave(&wl->wl_lock, flags);
953 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
954 wl1271_tx_total_queue_count(wl) > 0) {
955 spin_unlock_irqrestore(&wl->wl_lock, flags);
956 /*
957 * In order to avoid starvation of the TX path,
958 * call the work function directly.
959 */
960 wl1271_tx_work_locked(wl);
961 } else {
962 spin_unlock_irqrestore(&wl->wl_lock, flags);
963 }
964
965 /* check for tx results */
966 if (wl->fw_status->tx_results_counter !=
967 (wl->tx_results_count & 0xff))
968 wl1271_tx_complete(wl);
969
970 /* Make sure the deferred queues don't get too long */
971 defer_count = skb_queue_len(&wl->deferred_tx_queue) +
972 skb_queue_len(&wl->deferred_rx_queue);
973 if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
974 wl1271_flush_deferred_work(wl);
975 }
976
977 if (intr & WL1271_ACX_INTR_EVENT_A) {
978 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
979 wl1271_event_handle(wl, 0);
980 }
981
982 if (intr & WL1271_ACX_INTR_EVENT_B) {
983 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
984 wl1271_event_handle(wl, 1);
985 }
986
987 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
988 wl1271_debug(DEBUG_IRQ,
989 "WL1271_ACX_INTR_INIT_COMPLETE");
990
991 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
992 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
993 }
994
995 wl1271_ps_elp_sleep(wl);
996
997 out:
998 spin_lock_irqsave(&wl->wl_lock, flags);
999 /* In case TX was not handled here, queue TX work */
1000 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
1001 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1002 wl1271_tx_total_queue_count(wl) > 0)
1003 ieee80211_queue_work(wl->hw, &wl->tx_work);
1004 spin_unlock_irqrestore(&wl->wl_lock, flags);
1005
1006 mutex_unlock(&wl->mutex);
1007
1008 return IRQ_HANDLED;
1009 }
1010
1011 struct vif_counter_data {
1012 u8 counter;
1013
1014 struct ieee80211_vif *cur_vif;
1015 bool cur_vif_running;
1016 };
1017
1018 static void wl12xx_vif_count_iter(void *data, u8 *mac,
1019 struct ieee80211_vif *vif)
1020 {
1021 struct vif_counter_data *counter = data;
1022
1023 counter->counter++;
1024 if (counter->cur_vif == vif)
1025 counter->cur_vif_running = true;
1026 }
1027
1028 /* caller must not hold wl->mutex, as it might deadlock */
1029 static void wl12xx_get_vif_count(struct ieee80211_hw *hw,
1030 struct ieee80211_vif *cur_vif,
1031 struct vif_counter_data *data)
1032 {
1033 memset(data, 0, sizeof(*data));
1034 data->cur_vif = cur_vif;
1035
1036 ieee80211_iterate_active_interfaces(hw,
1037 wl12xx_vif_count_iter, data);
1038 }
1039
1040 static int wl12xx_fetch_firmware(struct wl1271 *wl, bool plt)
1041 {
1042 const struct firmware *fw;
1043 const char *fw_name;
1044 enum wl12xx_fw_type fw_type;
1045 int ret;
1046
1047 if (plt) {
1048 fw_type = WL12XX_FW_TYPE_PLT;
1049 if (wl->chip.id == CHIP_ID_1283_PG20)
1050 fw_name = WL128X_PLT_FW_NAME;
1051 else
1052 fw_name = WL127X_PLT_FW_NAME;
1053 } else {
1054 /*
1055 * we can't call wl12xx_get_vif_count() here because
1056 * wl->mutex is taken, so use the cached last_vif_count value
1057 */
1058 if (wl->last_vif_count > 1) {
1059 fw_type = WL12XX_FW_TYPE_MULTI;
1060 if (wl->chip.id == CHIP_ID_1283_PG20)
1061 fw_name = WL128X_FW_NAME_MULTI;
1062 else
1063 fw_name = WL127X_FW_NAME_MULTI;
1064 } else {
1065 fw_type = WL12XX_FW_TYPE_NORMAL;
1066 if (wl->chip.id == CHIP_ID_1283_PG20)
1067 fw_name = WL128X_FW_NAME_SINGLE;
1068 else
1069 fw_name = WL127X_FW_NAME_SINGLE;
1070 }
1071 }
1072
1073 if (wl->fw_type == fw_type)
1074 return 0;
1075
1076 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
1077
1078 ret = request_firmware(&fw, fw_name, wl->dev);
1079
1080 if (ret < 0) {
1081 wl1271_error("could not get firmware %s: %d", fw_name, ret);
1082 return ret;
1083 }
1084
1085 if (fw->size % 4) {
1086 wl1271_error("firmware size is not multiple of 32 bits: %zu",
1087 fw->size);
1088 ret = -EILSEQ;
1089 goto out;
1090 }
1091
1092 vfree(wl->fw);
1093 wl->fw_type = WL12XX_FW_TYPE_NONE;
1094 wl->fw_len = fw->size;
1095 wl->fw = vmalloc(wl->fw_len);
1096
1097 if (!wl->fw) {
1098 wl1271_error("could not allocate memory for the firmware");
1099 ret = -ENOMEM;
1100 goto out;
1101 }
1102
1103 memcpy(wl->fw, fw->data, wl->fw_len);
1104 ret = 0;
1105 wl->fw_type = fw_type;
1106 out:
1107 release_firmware(fw);
1108
1109 return ret;
1110 }
1111
1112 static int wl1271_fetch_nvs(struct wl1271 *wl)
1113 {
1114 const struct firmware *fw;
1115 int ret;
1116
1117 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl->dev);
1118
1119 if (ret < 0) {
1120 wl1271_error("could not get nvs file %s: %d", WL12XX_NVS_NAME,
1121 ret);
1122 return ret;
1123 }
1124
1125 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
1126
1127 if (!wl->nvs) {
1128 wl1271_error("could not allocate memory for the nvs file");
1129 ret = -ENOMEM;
1130 goto out;
1131 }
1132
1133 wl->nvs_len = fw->size;
1134
1135 out:
1136 release_firmware(fw);
1137
1138 return ret;
1139 }
1140
1141 void wl12xx_queue_recovery_work(struct wl1271 *wl)
1142 {
1143 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1144 ieee80211_queue_work(wl->hw, &wl->recovery_work);
1145 }
1146
1147 size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
1148 {
1149 size_t len = 0;
1150
1151 /* The FW log is a length-value list, find where the log end */
1152 while (len < maxlen) {
1153 if (memblock[len] == 0)
1154 break;
1155 if (len + memblock[len] + 1 > maxlen)
1156 break;
1157 len += memblock[len] + 1;
1158 }
1159
1160 /* Make sure we have enough room */
1161 len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size));
1162
1163 /* Fill the FW log file, consumed by the sysfs fwlog entry */
1164 memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
1165 wl->fwlog_size += len;
1166
1167 return len;
1168 }
1169
1170 static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
1171 {
1172 u32 addr;
1173 u32 first_addr;
1174 u8 *block;
1175
1176 if ((wl->quirks & WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED) ||
1177 (wl->conf.fwlog.mode != WL12XX_FWLOG_ON_DEMAND) ||
1178 (wl->conf.fwlog.mem_blocks == 0))
1179 return;
1180
1181 wl1271_info("Reading FW panic log");
1182
1183 block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL);
1184 if (!block)
1185 return;
1186
1187 /*
1188 * Make sure the chip is awake and the logger isn't active.
1189 * This might fail if the firmware hanged.
1190 */
1191 if (!wl1271_ps_elp_wakeup(wl))
1192 wl12xx_cmd_stop_fwlog(wl);
1193
1194 /* Read the first memory block address */
1195 wl12xx_fw_status(wl, wl->fw_status);
1196 first_addr = le32_to_cpu(wl->fw_status->log_start_addr);
1197 if (!first_addr)
1198 goto out;
1199
1200 /* Traverse the memory blocks linked list */
1201 addr = first_addr;
1202 do {
1203 memset(block, 0, WL12XX_HW_BLOCK_SIZE);
1204 wl1271_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE,
1205 false);
1206
1207 /*
1208 * Memory blocks are linked to one another. The first 4 bytes
1209 * of each memory block hold the hardware address of the next
1210 * one. The last memory block points to the first one.
1211 */
1212 addr = le32_to_cpup((__le32 *)block);
1213 if (!wl12xx_copy_fwlog(wl, block + sizeof(addr),
1214 WL12XX_HW_BLOCK_SIZE - sizeof(addr)))
1215 break;
1216 } while (addr && (addr != first_addr));
1217
1218 wake_up_interruptible(&wl->fwlog_waitq);
1219
1220 out:
1221 kfree(block);
1222 }
1223
1224 static void wl1271_recovery_work(struct work_struct *work)
1225 {
1226 struct wl1271 *wl =
1227 container_of(work, struct wl1271, recovery_work);
1228 struct wl12xx_vif *wlvif;
1229 struct ieee80211_vif *vif;
1230
1231 mutex_lock(&wl->mutex);
1232
1233 if (wl->state != WL1271_STATE_ON || wl->plt)
1234 goto out_unlock;
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 BUG_ON(bug_on_recovery &&
1245 !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags));
1246
1247 /*
1248 * Advance security sequence number to overcome potential progress
1249 * in the firmware during recovery. This doens't hurt if the network is
1250 * not encrypted.
1251 */
1252 wl12xx_for_each_wlvif(wl, wlvif) {
1253 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
1254 test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
1255 wlvif->tx_security_seq +=
1256 WL1271_TX_SQN_POST_RECOVERY_PADDING;
1257 }
1258
1259 /* Prevent spurious TX during FW restart */
1260 ieee80211_stop_queues(wl->hw);
1261
1262 if (wl->sched_scanning) {
1263 ieee80211_sched_scan_stopped(wl->hw);
1264 wl->sched_scanning = false;
1265 }
1266
1267 /* reboot the chipset */
1268 while (!list_empty(&wl->wlvif_list)) {
1269 wlvif = list_first_entry(&wl->wlvif_list,
1270 struct wl12xx_vif, list);
1271 vif = wl12xx_wlvif_to_vif(wlvif);
1272 __wl1271_op_remove_interface(wl, vif, false);
1273 }
1274 mutex_unlock(&wl->mutex);
1275 wl1271_op_stop(wl->hw);
1276
1277 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
1278
1279 ieee80211_restart_hw(wl->hw);
1280
1281 /*
1282 * Its safe to enable TX now - the queues are stopped after a request
1283 * to restart the HW.
1284 */
1285 ieee80211_wake_queues(wl->hw);
1286 return;
1287 out_unlock:
1288 mutex_unlock(&wl->mutex);
1289 }
1290
1291 static void wl1271_fw_wakeup(struct wl1271 *wl)
1292 {
1293 u32 elp_reg;
1294
1295 elp_reg = ELPCTRL_WAKE_UP;
1296 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
1297 }
1298
1299 static int wl1271_setup(struct wl1271 *wl)
1300 {
1301 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
1302 if (!wl->fw_status)
1303 return -ENOMEM;
1304
1305 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1306 if (!wl->tx_res_if) {
1307 kfree(wl->fw_status);
1308 return -ENOMEM;
1309 }
1310
1311 return 0;
1312 }
1313
1314 static int wl12xx_set_power_on(struct wl1271 *wl)
1315 {
1316 int ret;
1317
1318 msleep(WL1271_PRE_POWER_ON_SLEEP);
1319 ret = wl1271_power_on(wl);
1320 if (ret < 0)
1321 goto out;
1322 msleep(WL1271_POWER_ON_SLEEP);
1323 wl1271_io_reset(wl);
1324 wl1271_io_init(wl);
1325
1326 wl1271_set_partition(wl, &wl12xx_part_table[PART_DOWN]);
1327
1328 /* ELP module wake up */
1329 wl1271_fw_wakeup(wl);
1330
1331 out:
1332 return ret;
1333 }
1334
1335 static int wl12xx_chip_wakeup(struct wl1271 *wl, bool plt)
1336 {
1337 int ret = 0;
1338
1339 ret = wl12xx_set_power_on(wl);
1340 if (ret < 0)
1341 goto out;
1342
1343 /*
1344 * For wl127x based devices we could use the default block
1345 * size (512 bytes), but due to a bug in the sdio driver, we
1346 * need to set it explicitly after the chip is powered on. To
1347 * simplify the code and since the performance impact is
1348 * negligible, we use the same block size for all different
1349 * chip types.
1350 */
1351 if (!wl1271_set_block_size(wl))
1352 wl->quirks |= WL12XX_QUIRK_NO_BLOCKSIZE_ALIGNMENT;
1353
1354 switch (wl->chip.id) {
1355 case CHIP_ID_1271_PG10:
1356 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1357 wl->chip.id);
1358
1359 ret = wl1271_setup(wl);
1360 if (ret < 0)
1361 goto out;
1362 wl->quirks |= WL12XX_QUIRK_NO_BLOCKSIZE_ALIGNMENT;
1363 break;
1364
1365 case CHIP_ID_1271_PG20:
1366 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1367 wl->chip.id);
1368
1369 ret = wl1271_setup(wl);
1370 if (ret < 0)
1371 goto out;
1372 wl->quirks |= WL12XX_QUIRK_NO_BLOCKSIZE_ALIGNMENT;
1373 break;
1374
1375 case CHIP_ID_1283_PG20:
1376 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1377 wl->chip.id);
1378
1379 ret = wl1271_setup(wl);
1380 if (ret < 0)
1381 goto out;
1382 break;
1383 case CHIP_ID_1283_PG10:
1384 default:
1385 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
1386 ret = -ENODEV;
1387 goto out;
1388 }
1389
1390 ret = wl12xx_fetch_firmware(wl, plt);
1391 if (ret < 0)
1392 goto out;
1393
1394 /* No NVS from netlink, try to get it from the filesystem */
1395 if (wl->nvs == NULL) {
1396 ret = wl1271_fetch_nvs(wl);
1397 if (ret < 0)
1398 goto out;
1399 }
1400
1401 out:
1402 return ret;
1403 }
1404
1405 int wl1271_plt_start(struct wl1271 *wl)
1406 {
1407 int retries = WL1271_BOOT_RETRIES;
1408 struct wiphy *wiphy = wl->hw->wiphy;
1409 int ret;
1410
1411 mutex_lock(&wl->mutex);
1412
1413 wl1271_notice("power up");
1414
1415 if (wl->state != WL1271_STATE_OFF) {
1416 wl1271_error("cannot go into PLT state because not "
1417 "in off state: %d", wl->state);
1418 ret = -EBUSY;
1419 goto out;
1420 }
1421
1422 while (retries) {
1423 retries--;
1424 ret = wl12xx_chip_wakeup(wl, true);
1425 if (ret < 0)
1426 goto power_off;
1427
1428 ret = wl1271_boot(wl);
1429 if (ret < 0)
1430 goto power_off;
1431
1432 ret = wl1271_plt_init(wl);
1433 if (ret < 0)
1434 goto irq_disable;
1435
1436 wl->plt = true;
1437 wl->state = WL1271_STATE_ON;
1438 wl1271_notice("firmware booted in PLT mode (%s)",
1439 wl->chip.fw_ver_str);
1440
1441 /* update hw/fw version info in wiphy struct */
1442 wiphy->hw_version = wl->chip.id;
1443 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1444 sizeof(wiphy->fw_version));
1445
1446 goto out;
1447
1448 irq_disable:
1449 mutex_unlock(&wl->mutex);
1450 /* Unlocking the mutex in the middle of handling is
1451 inherently unsafe. In this case we deem it safe to do,
1452 because we need to let any possibly pending IRQ out of
1453 the system (and while we are WL1271_STATE_OFF the IRQ
1454 work function will not do anything.) Also, any other
1455 possible concurrent operations will fail due to the
1456 current state, hence the wl1271 struct should be safe. */
1457 wl1271_disable_interrupts(wl);
1458 wl1271_flush_deferred_work(wl);
1459 cancel_work_sync(&wl->netstack_work);
1460 mutex_lock(&wl->mutex);
1461 power_off:
1462 wl1271_power_off(wl);
1463 }
1464
1465 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1466 WL1271_BOOT_RETRIES);
1467 out:
1468 mutex_unlock(&wl->mutex);
1469
1470 return ret;
1471 }
1472
1473 int wl1271_plt_stop(struct wl1271 *wl)
1474 {
1475 int ret = 0;
1476
1477 wl1271_notice("power down");
1478
1479 /*
1480 * Interrupts must be disabled before setting the state to OFF.
1481 * Otherwise, the interrupt handler might be called and exit without
1482 * reading the interrupt status.
1483 */
1484 wl1271_disable_interrupts(wl);
1485 mutex_lock(&wl->mutex);
1486 if (!wl->plt) {
1487 mutex_unlock(&wl->mutex);
1488
1489 /*
1490 * This will not necessarily enable interrupts as interrupts
1491 * may have been disabled when op_stop was called. It will,
1492 * however, balance the above call to disable_interrupts().
1493 */
1494 wl1271_enable_interrupts(wl);
1495
1496 wl1271_error("cannot power down because not in PLT "
1497 "state: %d", wl->state);
1498 ret = -EBUSY;
1499 goto out;
1500 }
1501
1502 mutex_unlock(&wl->mutex);
1503
1504 wl1271_flush_deferred_work(wl);
1505 cancel_work_sync(&wl->netstack_work);
1506 cancel_work_sync(&wl->recovery_work);
1507 cancel_delayed_work_sync(&wl->elp_work);
1508 cancel_delayed_work_sync(&wl->tx_watchdog_work);
1509
1510 mutex_lock(&wl->mutex);
1511 wl1271_power_off(wl);
1512 wl->flags = 0;
1513 wl->state = WL1271_STATE_OFF;
1514 wl->plt = false;
1515 wl->rx_counter = 0;
1516 mutex_unlock(&wl->mutex);
1517
1518 out:
1519 return ret;
1520 }
1521
1522 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1523 {
1524 struct wl1271 *wl = hw->priv;
1525 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1526 struct ieee80211_vif *vif = info->control.vif;
1527 struct wl12xx_vif *wlvif = NULL;
1528 unsigned long flags;
1529 int q, mapping;
1530 u8 hlid;
1531
1532 if (vif)
1533 wlvif = wl12xx_vif_to_data(vif);
1534
1535 mapping = skb_get_queue_mapping(skb);
1536 q = wl1271_tx_get_queue(mapping);
1537
1538 hlid = wl12xx_tx_get_hlid(wl, wlvif, skb);
1539
1540 spin_lock_irqsave(&wl->wl_lock, flags);
1541
1542 /* queue the packet */
1543 if (hlid == WL12XX_INVALID_LINK_ID ||
1544 (wlvif && !test_bit(hlid, wlvif->links_map))) {
1545 wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d", hlid, q);
1546 ieee80211_free_txskb(hw, skb);
1547 goto out;
1548 }
1549
1550 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d len %d",
1551 hlid, q, skb->len);
1552 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1553
1554 wl->tx_queue_count[q]++;
1555
1556 /*
1557 * The workqueue is slow to process the tx_queue and we need stop
1558 * the queue here, otherwise the queue will get too long.
1559 */
1560 if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1561 wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
1562 ieee80211_stop_queue(wl->hw, mapping);
1563 set_bit(q, &wl->stopped_queues_map);
1564 }
1565
1566 /*
1567 * The chip specific setup must run before the first TX packet -
1568 * before that, the tx_work will not be initialized!
1569 */
1570
1571 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1572 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1573 ieee80211_queue_work(wl->hw, &wl->tx_work);
1574
1575 out:
1576 spin_unlock_irqrestore(&wl->wl_lock, flags);
1577 }
1578
1579 int wl1271_tx_dummy_packet(struct wl1271 *wl)
1580 {
1581 unsigned long flags;
1582 int q;
1583
1584 /* no need to queue a new dummy packet if one is already pending */
1585 if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags))
1586 return 0;
1587
1588 q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
1589
1590 spin_lock_irqsave(&wl->wl_lock, flags);
1591 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1592 wl->tx_queue_count[q]++;
1593 spin_unlock_irqrestore(&wl->wl_lock, flags);
1594
1595 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1596 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1597 wl1271_tx_work_locked(wl);
1598
1599 /*
1600 * If the FW TX is busy, TX work will be scheduled by the threaded
1601 * interrupt handler function
1602 */
1603 return 0;
1604 }
1605
1606 /*
1607 * The size of the dummy packet should be at least 1400 bytes. However, in
1608 * order to minimize the number of bus transactions, aligning it to 512 bytes
1609 * boundaries could be beneficial, performance wise
1610 */
1611 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1612
1613 static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1614 {
1615 struct sk_buff *skb;
1616 struct ieee80211_hdr_3addr *hdr;
1617 unsigned int dummy_packet_size;
1618
1619 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1620 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1621
1622 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1623 if (!skb) {
1624 wl1271_warning("Failed to allocate a dummy packet skb");
1625 return NULL;
1626 }
1627
1628 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1629
1630 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1631 memset(hdr, 0, sizeof(*hdr));
1632 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1633 IEEE80211_STYPE_NULLFUNC |
1634 IEEE80211_FCTL_TODS);
1635
1636 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1637
1638 /* Dummy packets require the TID to be management */
1639 skb->priority = WL1271_TID_MGMT;
1640
1641 /* Initialize all fields that might be used */
1642 skb_set_queue_mapping(skb, 0);
1643 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1644
1645 return skb;
1646 }
1647
1648
1649 #ifdef CONFIG_PM
1650 static int wl1271_configure_suspend_sta(struct wl1271 *wl,
1651 struct wl12xx_vif *wlvif)
1652 {
1653 int ret = 0;
1654
1655 mutex_lock(&wl->mutex);
1656
1657 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
1658 goto out_unlock;
1659
1660 ret = wl1271_ps_elp_wakeup(wl);
1661 if (ret < 0)
1662 goto out_unlock;
1663
1664 ret = wl1271_acx_wake_up_conditions(wl, wlvif,
1665 wl->conf.conn.suspend_wake_up_event,
1666 wl->conf.conn.suspend_listen_interval);
1667
1668 if (ret < 0)
1669 wl1271_error("suspend: set wake up conditions failed: %d", ret);
1670
1671
1672 wl1271_ps_elp_sleep(wl);
1673
1674 out_unlock:
1675 mutex_unlock(&wl->mutex);
1676 return ret;
1677
1678 }
1679
1680 static int wl1271_configure_suspend_ap(struct wl1271 *wl,
1681 struct wl12xx_vif *wlvif)
1682 {
1683 int ret = 0;
1684
1685 mutex_lock(&wl->mutex);
1686
1687 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
1688 goto out_unlock;
1689
1690 ret = wl1271_ps_elp_wakeup(wl);
1691 if (ret < 0)
1692 goto out_unlock;
1693
1694 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
1695
1696 wl1271_ps_elp_sleep(wl);
1697 out_unlock:
1698 mutex_unlock(&wl->mutex);
1699 return ret;
1700
1701 }
1702
1703 static int wl1271_configure_suspend(struct wl1271 *wl,
1704 struct wl12xx_vif *wlvif)
1705 {
1706 if (wlvif->bss_type == BSS_TYPE_STA_BSS)
1707 return wl1271_configure_suspend_sta(wl, wlvif);
1708 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
1709 return wl1271_configure_suspend_ap(wl, wlvif);
1710 return 0;
1711 }
1712
1713 static void wl1271_configure_resume(struct wl1271 *wl,
1714 struct wl12xx_vif *wlvif)
1715 {
1716 int ret = 0;
1717 bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
1718 bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
1719
1720 if ((!is_ap) && (!is_sta))
1721 return;
1722
1723 mutex_lock(&wl->mutex);
1724 ret = wl1271_ps_elp_wakeup(wl);
1725 if (ret < 0)
1726 goto out;
1727
1728 if (is_sta) {
1729 ret = wl1271_acx_wake_up_conditions(wl, wlvif,
1730 wl->conf.conn.wake_up_event,
1731 wl->conf.conn.listen_interval);
1732
1733 if (ret < 0)
1734 wl1271_error("resume: wake up conditions failed: %d",
1735 ret);
1736
1737 } else if (is_ap) {
1738 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, false);
1739 }
1740
1741 wl1271_ps_elp_sleep(wl);
1742 out:
1743 mutex_unlock(&wl->mutex);
1744 }
1745
1746 static int wl1271_op_suspend(struct ieee80211_hw *hw,
1747 struct cfg80211_wowlan *wow)
1748 {
1749 struct wl1271 *wl = hw->priv;
1750 struct wl12xx_vif *wlvif;
1751 int ret;
1752
1753 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1754 WARN_ON(!wow || !wow->any);
1755
1756 wl1271_tx_flush(wl);
1757
1758 wl->wow_enabled = true;
1759 wl12xx_for_each_wlvif(wl, wlvif) {
1760 ret = wl1271_configure_suspend(wl, wlvif);
1761 if (ret < 0) {
1762 wl1271_warning("couldn't prepare device to suspend");
1763 return ret;
1764 }
1765 }
1766 /* flush any remaining work */
1767 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1768
1769 /*
1770 * disable and re-enable interrupts in order to flush
1771 * the threaded_irq
1772 */
1773 wl1271_disable_interrupts(wl);
1774
1775 /*
1776 * set suspended flag to avoid triggering a new threaded_irq
1777 * work. no need for spinlock as interrupts are disabled.
1778 */
1779 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1780
1781 wl1271_enable_interrupts(wl);
1782 flush_work(&wl->tx_work);
1783 flush_delayed_work(&wl->elp_work);
1784
1785 return 0;
1786 }
1787
1788 static int wl1271_op_resume(struct ieee80211_hw *hw)
1789 {
1790 struct wl1271 *wl = hw->priv;
1791 struct wl12xx_vif *wlvif;
1792 unsigned long flags;
1793 bool run_irq_work = false;
1794
1795 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1796 wl->wow_enabled);
1797 WARN_ON(!wl->wow_enabled);
1798
1799 /*
1800 * re-enable irq_work enqueuing, and call irq_work directly if
1801 * there is a pending work.
1802 */
1803 spin_lock_irqsave(&wl->wl_lock, flags);
1804 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1805 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1806 run_irq_work = true;
1807 spin_unlock_irqrestore(&wl->wl_lock, flags);
1808
1809 if (run_irq_work) {
1810 wl1271_debug(DEBUG_MAC80211,
1811 "run postponed irq_work directly");
1812 wl1271_irq(0, wl);
1813 wl1271_enable_interrupts(wl);
1814 }
1815 wl12xx_for_each_wlvif(wl, wlvif) {
1816 wl1271_configure_resume(wl, wlvif);
1817 }
1818 wl->wow_enabled = false;
1819
1820 return 0;
1821 }
1822 #endif
1823
1824 static int wl1271_op_start(struct ieee80211_hw *hw)
1825 {
1826 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1827
1828 /*
1829 * We have to delay the booting of the hardware because
1830 * we need to know the local MAC address before downloading and
1831 * initializing the firmware. The MAC address cannot be changed
1832 * after boot, and without the proper MAC address, the firmware
1833 * will not function properly.
1834 *
1835 * The MAC address is first known when the corresponding interface
1836 * is added. That is where we will initialize the hardware.
1837 */
1838
1839 return 0;
1840 }
1841
1842 static void wl1271_op_stop(struct ieee80211_hw *hw)
1843 {
1844 struct wl1271 *wl = hw->priv;
1845 int i;
1846
1847 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1848
1849 /*
1850 * Interrupts must be disabled before setting the state to OFF.
1851 * Otherwise, the interrupt handler might be called and exit without
1852 * reading the interrupt status.
1853 */
1854 wl1271_disable_interrupts(wl);
1855 mutex_lock(&wl->mutex);
1856 if (wl->state == WL1271_STATE_OFF) {
1857 mutex_unlock(&wl->mutex);
1858
1859 /*
1860 * This will not necessarily enable interrupts as interrupts
1861 * may have been disabled when op_stop was called. It will,
1862 * however, balance the above call to disable_interrupts().
1863 */
1864 wl1271_enable_interrupts(wl);
1865 return;
1866 }
1867
1868 /*
1869 * this must be before the cancel_work calls below, so that the work
1870 * functions don't perform further work.
1871 */
1872 wl->state = WL1271_STATE_OFF;
1873 mutex_unlock(&wl->mutex);
1874
1875 wl1271_flush_deferred_work(wl);
1876 cancel_delayed_work_sync(&wl->scan_complete_work);
1877 cancel_work_sync(&wl->netstack_work);
1878 cancel_work_sync(&wl->tx_work);
1879 cancel_delayed_work_sync(&wl->elp_work);
1880 cancel_delayed_work_sync(&wl->tx_watchdog_work);
1881
1882 /* let's notify MAC80211 about the remaining pending TX frames */
1883 wl12xx_tx_reset(wl, true);
1884 mutex_lock(&wl->mutex);
1885
1886 wl1271_power_off(wl);
1887
1888 wl->band = IEEE80211_BAND_2GHZ;
1889
1890 wl->rx_counter = 0;
1891 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1892 wl->tx_blocks_available = 0;
1893 wl->tx_allocated_blocks = 0;
1894 wl->tx_results_count = 0;
1895 wl->tx_packets_count = 0;
1896 wl->time_offset = 0;
1897 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
1898 wl->ap_fw_ps_map = 0;
1899 wl->ap_ps_map = 0;
1900 wl->sched_scanning = false;
1901 memset(wl->roles_map, 0, sizeof(wl->roles_map));
1902 memset(wl->links_map, 0, sizeof(wl->links_map));
1903 memset(wl->roc_map, 0, sizeof(wl->roc_map));
1904 wl->active_sta_count = 0;
1905
1906 /* The system link is always allocated */
1907 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
1908
1909 /*
1910 * this is performed after the cancel_work calls and the associated
1911 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1912 * get executed before all these vars have been reset.
1913 */
1914 wl->flags = 0;
1915
1916 wl->tx_blocks_freed = 0;
1917
1918 for (i = 0; i < NUM_TX_QUEUES; i++) {
1919 wl->tx_pkts_freed[i] = 0;
1920 wl->tx_allocated_pkts[i] = 0;
1921 }
1922
1923 wl1271_debugfs_reset(wl);
1924
1925 kfree(wl->fw_status);
1926 wl->fw_status = NULL;
1927 kfree(wl->tx_res_if);
1928 wl->tx_res_if = NULL;
1929 kfree(wl->target_mem_map);
1930 wl->target_mem_map = NULL;
1931
1932 mutex_unlock(&wl->mutex);
1933 }
1934
1935 static int wl12xx_allocate_rate_policy(struct wl1271 *wl, u8 *idx)
1936 {
1937 u8 policy = find_first_zero_bit(wl->rate_policies_map,
1938 WL12XX_MAX_RATE_POLICIES);
1939 if (policy >= WL12XX_MAX_RATE_POLICIES)
1940 return -EBUSY;
1941
1942 __set_bit(policy, wl->rate_policies_map);
1943 *idx = policy;
1944 return 0;
1945 }
1946
1947 static void wl12xx_free_rate_policy(struct wl1271 *wl, u8 *idx)
1948 {
1949 if (WARN_ON(*idx >= WL12XX_MAX_RATE_POLICIES))
1950 return;
1951
1952 __clear_bit(*idx, wl->rate_policies_map);
1953 *idx = WL12XX_MAX_RATE_POLICIES;
1954 }
1955
1956 static u8 wl12xx_get_role_type(struct wl1271 *wl, struct wl12xx_vif *wlvif)
1957 {
1958 switch (wlvif->bss_type) {
1959 case BSS_TYPE_AP_BSS:
1960 if (wlvif->p2p)
1961 return WL1271_ROLE_P2P_GO;
1962 else
1963 return WL1271_ROLE_AP;
1964
1965 case BSS_TYPE_STA_BSS:
1966 if (wlvif->p2p)
1967 return WL1271_ROLE_P2P_CL;
1968 else
1969 return WL1271_ROLE_STA;
1970
1971 case BSS_TYPE_IBSS:
1972 return WL1271_ROLE_IBSS;
1973
1974 default:
1975 wl1271_error("invalid bss_type: %d", wlvif->bss_type);
1976 }
1977 return WL12XX_INVALID_ROLE_TYPE;
1978 }
1979
1980 static int wl12xx_init_vif_data(struct wl1271 *wl, struct ieee80211_vif *vif)
1981 {
1982 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
1983 int i;
1984
1985 /* clear everything but the persistent data */
1986 memset(wlvif, 0, offsetof(struct wl12xx_vif, persistent));
1987
1988 switch (ieee80211_vif_type_p2p(vif)) {
1989 case NL80211_IFTYPE_P2P_CLIENT:
1990 wlvif->p2p = 1;
1991 /* fall-through */
1992 case NL80211_IFTYPE_STATION:
1993 wlvif->bss_type = BSS_TYPE_STA_BSS;
1994 break;
1995 case NL80211_IFTYPE_ADHOC:
1996 wlvif->bss_type = BSS_TYPE_IBSS;
1997 break;
1998 case NL80211_IFTYPE_P2P_GO:
1999 wlvif->p2p = 1;
2000 /* fall-through */
2001 case NL80211_IFTYPE_AP:
2002 wlvif->bss_type = BSS_TYPE_AP_BSS;
2003 break;
2004 default:
2005 wlvif->bss_type = MAX_BSS_TYPE;
2006 return -EOPNOTSUPP;
2007 }
2008
2009 wlvif->role_id = WL12XX_INVALID_ROLE_ID;
2010 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
2011 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
2012
2013 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2014 wlvif->bss_type == BSS_TYPE_IBSS) {
2015 /* init sta/ibss data */
2016 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
2017 wl12xx_allocate_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2018 wl12xx_allocate_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2019 wl12xx_allocate_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
2020 } else {
2021 /* init ap data */
2022 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2023 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
2024 wl12xx_allocate_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2025 wl12xx_allocate_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2026 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2027 wl12xx_allocate_rate_policy(wl,
2028 &wlvif->ap.ucast_rate_idx[i]);
2029 }
2030
2031 wlvif->bitrate_masks[IEEE80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
2032 wlvif->bitrate_masks[IEEE80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
2033 wlvif->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2034 wlvif->basic_rate = CONF_TX_RATE_MASK_BASIC;
2035 wlvif->rate_set = CONF_TX_RATE_MASK_BASIC;
2036 wlvif->beacon_int = WL1271_DEFAULT_BEACON_INT;
2037
2038 /*
2039 * mac80211 configures some values globally, while we treat them
2040 * per-interface. thus, on init, we have to copy them from wl
2041 */
2042 wlvif->band = wl->band;
2043 wlvif->channel = wl->channel;
2044 wlvif->power_level = wl->power_level;
2045
2046 INIT_WORK(&wlvif->rx_streaming_enable_work,
2047 wl1271_rx_streaming_enable_work);
2048 INIT_WORK(&wlvif->rx_streaming_disable_work,
2049 wl1271_rx_streaming_disable_work);
2050 INIT_LIST_HEAD(&wlvif->list);
2051
2052 setup_timer(&wlvif->rx_streaming_timer, wl1271_rx_streaming_timer,
2053 (unsigned long) wlvif);
2054 return 0;
2055 }
2056
2057 static bool wl12xx_init_fw(struct wl1271 *wl)
2058 {
2059 int retries = WL1271_BOOT_RETRIES;
2060 bool booted = false;
2061 struct wiphy *wiphy = wl->hw->wiphy;
2062 int ret;
2063
2064 while (retries) {
2065 retries--;
2066 ret = wl12xx_chip_wakeup(wl, false);
2067 if (ret < 0)
2068 goto power_off;
2069
2070 ret = wl1271_boot(wl);
2071 if (ret < 0)
2072 goto power_off;
2073
2074 ret = wl1271_hw_init(wl);
2075 if (ret < 0)
2076 goto irq_disable;
2077
2078 booted = true;
2079 break;
2080
2081 irq_disable:
2082 mutex_unlock(&wl->mutex);
2083 /* Unlocking the mutex in the middle of handling is
2084 inherently unsafe. In this case we deem it safe to do,
2085 because we need to let any possibly pending IRQ out of
2086 the system (and while we are WL1271_STATE_OFF the IRQ
2087 work function will not do anything.) Also, any other
2088 possible concurrent operations will fail due to the
2089 current state, hence the wl1271 struct should be safe. */
2090 wl1271_disable_interrupts(wl);
2091 wl1271_flush_deferred_work(wl);
2092 cancel_work_sync(&wl->netstack_work);
2093 mutex_lock(&wl->mutex);
2094 power_off:
2095 wl1271_power_off(wl);
2096 }
2097
2098 if (!booted) {
2099 wl1271_error("firmware boot failed despite %d retries",
2100 WL1271_BOOT_RETRIES);
2101 goto out;
2102 }
2103
2104 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
2105
2106 /* update hw/fw version info in wiphy struct */
2107 wiphy->hw_version = wl->chip.id;
2108 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
2109 sizeof(wiphy->fw_version));
2110
2111 /*
2112 * Now we know if 11a is supported (info from the NVS), so disable
2113 * 11a channels if not supported
2114 */
2115 if (!wl->enable_11a)
2116 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
2117
2118 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
2119 wl->enable_11a ? "" : "not ");
2120
2121 wl->state = WL1271_STATE_ON;
2122 out:
2123 return booted;
2124 }
2125
2126 static bool wl12xx_dev_role_started(struct wl12xx_vif *wlvif)
2127 {
2128 return wlvif->dev_hlid != WL12XX_INVALID_LINK_ID;
2129 }
2130
2131 /*
2132 * Check whether a fw switch (i.e. moving from one loaded
2133 * fw to another) is needed. This function is also responsible
2134 * for updating wl->last_vif_count, so it must be called before
2135 * loading a non-plt fw (so the correct fw (single-role/multi-role)
2136 * will be used).
2137 */
2138 static bool wl12xx_need_fw_change(struct wl1271 *wl,
2139 struct vif_counter_data vif_counter_data,
2140 bool add)
2141 {
2142 enum wl12xx_fw_type current_fw = wl->fw_type;
2143 u8 vif_count = vif_counter_data.counter;
2144
2145 if (test_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags))
2146 return false;
2147
2148 /* increase the vif count if this is a new vif */
2149 if (add && !vif_counter_data.cur_vif_running)
2150 vif_count++;
2151
2152 wl->last_vif_count = vif_count;
2153
2154 /* no need for fw change if the device is OFF */
2155 if (wl->state == WL1271_STATE_OFF)
2156 return false;
2157
2158 if (vif_count > 1 && current_fw == WL12XX_FW_TYPE_NORMAL)
2159 return true;
2160 if (vif_count <= 1 && current_fw == WL12XX_FW_TYPE_MULTI)
2161 return true;
2162
2163 return false;
2164 }
2165
2166 /*
2167 * Enter "forced psm". Make sure the sta is in psm against the ap,
2168 * to make the fw switch a bit more disconnection-persistent.
2169 */
2170 static void wl12xx_force_active_psm(struct wl1271 *wl)
2171 {
2172 struct wl12xx_vif *wlvif;
2173
2174 wl12xx_for_each_wlvif_sta(wl, wlvif) {
2175 wl1271_ps_set_mode(wl, wlvif, STATION_POWER_SAVE_MODE);
2176 }
2177 }
2178
2179 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
2180 struct ieee80211_vif *vif)
2181 {
2182 struct wl1271 *wl = hw->priv;
2183 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2184 struct vif_counter_data vif_count;
2185 int ret = 0;
2186 u8 role_type;
2187 bool booted = false;
2188
2189 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
2190 IEEE80211_VIF_SUPPORTS_CQM_RSSI;
2191
2192 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
2193 ieee80211_vif_type_p2p(vif), vif->addr);
2194
2195 wl12xx_get_vif_count(hw, vif, &vif_count);
2196
2197 mutex_lock(&wl->mutex);
2198 ret = wl1271_ps_elp_wakeup(wl);
2199 if (ret < 0)
2200 goto out_unlock;
2201
2202 /*
2203 * in some very corner case HW recovery scenarios its possible to
2204 * get here before __wl1271_op_remove_interface is complete, so
2205 * opt out if that is the case.
2206 */
2207 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) ||
2208 test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) {
2209 ret = -EBUSY;
2210 goto out;
2211 }
2212
2213
2214 ret = wl12xx_init_vif_data(wl, vif);
2215 if (ret < 0)
2216 goto out;
2217
2218 wlvif->wl = wl;
2219 role_type = wl12xx_get_role_type(wl, wlvif);
2220 if (role_type == WL12XX_INVALID_ROLE_TYPE) {
2221 ret = -EINVAL;
2222 goto out;
2223 }
2224
2225 if (wl12xx_need_fw_change(wl, vif_count, true)) {
2226 wl12xx_force_active_psm(wl);
2227 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2228 mutex_unlock(&wl->mutex);
2229 wl1271_recovery_work(&wl->recovery_work);
2230 return 0;
2231 }
2232
2233 /*
2234 * TODO: after the nvs issue will be solved, move this block
2235 * to start(), and make sure here the driver is ON.
2236 */
2237 if (wl->state == WL1271_STATE_OFF) {
2238 /*
2239 * we still need this in order to configure the fw
2240 * while uploading the nvs
2241 */
2242 memcpy(wl->addresses[0].addr, vif->addr, ETH_ALEN);
2243
2244 booted = wl12xx_init_fw(wl);
2245 if (!booted) {
2246 ret = -EINVAL;
2247 goto out;
2248 }
2249 }
2250
2251 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2252 wlvif->bss_type == BSS_TYPE_IBSS) {
2253 /*
2254 * The device role is a special role used for
2255 * rx and tx frames prior to association (as
2256 * the STA role can get packets only from
2257 * its associated bssid)
2258 */
2259 ret = wl12xx_cmd_role_enable(wl, vif->addr,
2260 WL1271_ROLE_DEVICE,
2261 &wlvif->dev_role_id);
2262 if (ret < 0)
2263 goto out;
2264 }
2265
2266 ret = wl12xx_cmd_role_enable(wl, vif->addr,
2267 role_type, &wlvif->role_id);
2268 if (ret < 0)
2269 goto out;
2270
2271 ret = wl1271_init_vif_specific(wl, vif);
2272 if (ret < 0)
2273 goto out;
2274
2275 list_add(&wlvif->list, &wl->wlvif_list);
2276 set_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags);
2277
2278 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2279 wl->ap_count++;
2280 else
2281 wl->sta_count++;
2282 out:
2283 wl1271_ps_elp_sleep(wl);
2284 out_unlock:
2285 mutex_unlock(&wl->mutex);
2286
2287 return ret;
2288 }
2289
2290 static void __wl1271_op_remove_interface(struct wl1271 *wl,
2291 struct ieee80211_vif *vif,
2292 bool reset_tx_queues)
2293 {
2294 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2295 int i, ret;
2296
2297 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
2298
2299 if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2300 return;
2301
2302 /* because of hardware recovery, we may get here twice */
2303 if (wl->state != WL1271_STATE_ON)
2304 return;
2305
2306 wl1271_info("down");
2307
2308 if (wl->scan.state != WL1271_SCAN_STATE_IDLE &&
2309 wl->scan_vif == vif) {
2310 /*
2311 * Rearm the tx watchdog just before idling scan. This
2312 * prevents just-finished scans from triggering the watchdog
2313 */
2314 wl12xx_rearm_tx_watchdog_locked(wl);
2315
2316 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2317 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2318 wl->scan_vif = NULL;
2319 wl->scan.req = NULL;
2320 ieee80211_scan_completed(wl->hw, true);
2321 }
2322
2323 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2324 /* disable active roles */
2325 ret = wl1271_ps_elp_wakeup(wl);
2326 if (ret < 0)
2327 goto deinit;
2328
2329 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2330 wlvif->bss_type == BSS_TYPE_IBSS) {
2331 if (wl12xx_dev_role_started(wlvif))
2332 wl12xx_stop_dev(wl, wlvif);
2333
2334 ret = wl12xx_cmd_role_disable(wl, &wlvif->dev_role_id);
2335 if (ret < 0)
2336 goto deinit;
2337 }
2338
2339 ret = wl12xx_cmd_role_disable(wl, &wlvif->role_id);
2340 if (ret < 0)
2341 goto deinit;
2342
2343 wl1271_ps_elp_sleep(wl);
2344 }
2345 deinit:
2346 /* clear all hlids (except system_hlid) */
2347 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
2348
2349 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2350 wlvif->bss_type == BSS_TYPE_IBSS) {
2351 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
2352 wl12xx_free_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2353 wl12xx_free_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2354 wl12xx_free_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
2355 } else {
2356 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2357 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
2358 wl12xx_free_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2359 wl12xx_free_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2360 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2361 wl12xx_free_rate_policy(wl,
2362 &wlvif->ap.ucast_rate_idx[i]);
2363 }
2364
2365 wl12xx_tx_reset_wlvif(wl, wlvif);
2366 wl1271_free_ap_keys(wl, wlvif);
2367 if (wl->last_wlvif == wlvif)
2368 wl->last_wlvif = NULL;
2369 list_del(&wlvif->list);
2370 memset(wlvif->ap.sta_hlid_map, 0, sizeof(wlvif->ap.sta_hlid_map));
2371 wlvif->role_id = WL12XX_INVALID_ROLE_ID;
2372 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
2373
2374 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2375 wl->ap_count--;
2376 else
2377 wl->sta_count--;
2378
2379 mutex_unlock(&wl->mutex);
2380
2381 del_timer_sync(&wlvif->rx_streaming_timer);
2382 cancel_work_sync(&wlvif->rx_streaming_enable_work);
2383 cancel_work_sync(&wlvif->rx_streaming_disable_work);
2384
2385 mutex_lock(&wl->mutex);
2386 }
2387
2388 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2389 struct ieee80211_vif *vif)
2390 {
2391 struct wl1271 *wl = hw->priv;
2392 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2393 struct wl12xx_vif *iter;
2394 struct vif_counter_data vif_count;
2395 bool cancel_recovery = true;
2396
2397 wl12xx_get_vif_count(hw, vif, &vif_count);
2398 mutex_lock(&wl->mutex);
2399
2400 if (wl->state == WL1271_STATE_OFF ||
2401 !test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2402 goto out;
2403
2404 /*
2405 * wl->vif can be null here if someone shuts down the interface
2406 * just when hardware recovery has been started.
2407 */
2408 wl12xx_for_each_wlvif(wl, iter) {
2409 if (iter != wlvif)
2410 continue;
2411
2412 __wl1271_op_remove_interface(wl, vif, true);
2413 break;
2414 }
2415 WARN_ON(iter != wlvif);
2416 if (wl12xx_need_fw_change(wl, vif_count, false)) {
2417 wl12xx_force_active_psm(wl);
2418 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2419 wl12xx_queue_recovery_work(wl);
2420 cancel_recovery = false;
2421 }
2422 out:
2423 mutex_unlock(&wl->mutex);
2424 if (cancel_recovery)
2425 cancel_work_sync(&wl->recovery_work);
2426 }
2427
2428 static int wl12xx_op_change_interface(struct ieee80211_hw *hw,
2429 struct ieee80211_vif *vif,
2430 enum nl80211_iftype new_type, bool p2p)
2431 {
2432 struct wl1271 *wl = hw->priv;
2433 int ret;
2434
2435 set_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
2436 wl1271_op_remove_interface(hw, vif);
2437
2438 vif->type = new_type;
2439 vif->p2p = p2p;
2440 ret = wl1271_op_add_interface(hw, vif);
2441
2442 clear_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
2443 return ret;
2444 }
2445
2446 static int wl1271_join(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2447 bool set_assoc)
2448 {
2449 int ret;
2450 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
2451
2452 /*
2453 * One of the side effects of the JOIN command is that is clears
2454 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2455 * to a WPA/WPA2 access point will therefore kill the data-path.
2456 * Currently the only valid scenario for JOIN during association
2457 * is on roaming, in which case we will also be given new keys.
2458 * Keep the below message for now, unless it starts bothering
2459 * users who really like to roam a lot :)
2460 */
2461 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2462 wl1271_info("JOIN while associated.");
2463
2464 /* clear encryption type */
2465 wlvif->encryption_type = KEY_NONE;
2466
2467 if (set_assoc)
2468 set_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags);
2469
2470 if (is_ibss)
2471 ret = wl12xx_cmd_role_start_ibss(wl, wlvif);
2472 else
2473 ret = wl12xx_cmd_role_start_sta(wl, wlvif);
2474 if (ret < 0)
2475 goto out;
2476
2477 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2478 goto out;
2479
2480 /*
2481 * The join command disable the keep-alive mode, shut down its process,
2482 * and also clear the template config, so we need to reset it all after
2483 * the join. The acx_aid starts the keep-alive process, and the order
2484 * of the commands below is relevant.
2485 */
2486 ret = wl1271_acx_keep_alive_mode(wl, wlvif, true);
2487 if (ret < 0)
2488 goto out;
2489
2490 ret = wl1271_acx_aid(wl, wlvif, wlvif->aid);
2491 if (ret < 0)
2492 goto out;
2493
2494 ret = wl12xx_cmd_build_klv_null_data(wl, wlvif);
2495 if (ret < 0)
2496 goto out;
2497
2498 ret = wl1271_acx_keep_alive_config(wl, wlvif,
2499 CMD_TEMPL_KLV_IDX_NULL_DATA,
2500 ACX_KEEP_ALIVE_TPL_VALID);
2501 if (ret < 0)
2502 goto out;
2503
2504 out:
2505 return ret;
2506 }
2507
2508 static int wl1271_unjoin(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2509 {
2510 int ret;
2511
2512 if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags)) {
2513 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2514
2515 wl12xx_cmd_stop_channel_switch(wl);
2516 ieee80211_chswitch_done(vif, false);
2517 }
2518
2519 /* to stop listening to a channel, we disconnect */
2520 ret = wl12xx_cmd_role_stop_sta(wl, wlvif);
2521 if (ret < 0)
2522 goto out;
2523
2524 /* reset TX security counters on a clean disconnect */
2525 wlvif->tx_security_last_seq_lsb = 0;
2526 wlvif->tx_security_seq = 0;
2527
2528 out:
2529 return ret;
2530 }
2531
2532 static void wl1271_set_band_rate(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2533 {
2534 wlvif->basic_rate_set = wlvif->bitrate_masks[wlvif->band];
2535 wlvif->rate_set = wlvif->basic_rate_set;
2536 }
2537
2538 static int wl1271_sta_handle_idle(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2539 bool idle)
2540 {
2541 int ret;
2542 bool cur_idle = !test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
2543
2544 if (idle == cur_idle)
2545 return 0;
2546
2547 if (idle) {
2548 /* no need to croc if we weren't busy (e.g. during boot) */
2549 if (wl12xx_dev_role_started(wlvif)) {
2550 ret = wl12xx_stop_dev(wl, wlvif);
2551 if (ret < 0)
2552 goto out;
2553 }
2554 wlvif->rate_set =
2555 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
2556 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
2557 if (ret < 0)
2558 goto out;
2559 ret = wl1271_acx_keep_alive_config(
2560 wl, wlvif, CMD_TEMPL_KLV_IDX_NULL_DATA,
2561 ACX_KEEP_ALIVE_TPL_INVALID);
2562 if (ret < 0)
2563 goto out;
2564 clear_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
2565 } else {
2566 /* The current firmware only supports sched_scan in idle */
2567 if (wl->sched_scanning) {
2568 wl1271_scan_sched_scan_stop(wl);
2569 ieee80211_sched_scan_stopped(wl->hw);
2570 }
2571
2572 ret = wl12xx_start_dev(wl, wlvif);
2573 if (ret < 0)
2574 goto out;
2575 set_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
2576 }
2577
2578 out:
2579 return ret;
2580 }
2581
2582 static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2583 struct ieee80211_conf *conf, u32 changed)
2584 {
2585 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
2586 int channel, ret;
2587
2588 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2589
2590 /* if the channel changes while joined, join again */
2591 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2592 ((wlvif->band != conf->channel->band) ||
2593 (wlvif->channel != channel))) {
2594 /* send all pending packets */
2595 wl1271_tx_work_locked(wl);
2596 wlvif->band = conf->channel->band;
2597 wlvif->channel = channel;
2598
2599 if (!is_ap) {
2600 /*
2601 * FIXME: the mac80211 should really provide a fixed
2602 * rate to use here. for now, just use the smallest
2603 * possible rate for the band as a fixed rate for
2604 * association frames and other control messages.
2605 */
2606 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2607 wl1271_set_band_rate(wl, wlvif);
2608
2609 wlvif->basic_rate =
2610 wl1271_tx_min_rate_get(wl,
2611 wlvif->basic_rate_set);
2612 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
2613 if (ret < 0)
2614 wl1271_warning("rate policy for channel "
2615 "failed %d", ret);
2616
2617 /*
2618 * change the ROC channel. do it only if we are
2619 * not idle. otherwise, CROC will be called
2620 * anyway.
2621 */
2622 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED,
2623 &wlvif->flags) &&
2624 wl12xx_dev_role_started(wlvif) &&
2625 !(conf->flags & IEEE80211_CONF_IDLE)) {
2626 ret = wl12xx_stop_dev(wl, wlvif);
2627 if (ret < 0)
2628 return ret;
2629
2630 ret = wl12xx_start_dev(wl, wlvif);
2631 if (ret < 0)
2632 return ret;
2633 }
2634 }
2635 }
2636
2637 if ((changed & IEEE80211_CONF_CHANGE_PS) && !is_ap) {
2638
2639 if ((conf->flags & IEEE80211_CONF_PS) &&
2640 test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
2641 !test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
2642
2643 int ps_mode;
2644 char *ps_mode_str;
2645
2646 if (wl->conf.conn.forced_ps) {
2647 ps_mode = STATION_POWER_SAVE_MODE;
2648 ps_mode_str = "forced";
2649 } else {
2650 ps_mode = STATION_AUTO_PS_MODE;
2651 ps_mode_str = "auto";
2652 }
2653
2654 wl1271_debug(DEBUG_PSM, "%s ps enabled", ps_mode_str);
2655
2656 ret = wl1271_ps_set_mode(wl, wlvif, ps_mode);
2657
2658 if (ret < 0)
2659 wl1271_warning("enter %s ps failed %d",
2660 ps_mode_str, ret);
2661
2662 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
2663 test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
2664
2665 wl1271_debug(DEBUG_PSM, "auto ps disabled");
2666
2667 ret = wl1271_ps_set_mode(wl, wlvif,
2668 STATION_ACTIVE_MODE);
2669 if (ret < 0)
2670 wl1271_warning("exit auto ps failed %d", ret);
2671 }
2672 }
2673
2674 if (conf->power_level != wlvif->power_level) {
2675 ret = wl1271_acx_tx_power(wl, wlvif, conf->power_level);
2676 if (ret < 0)
2677 return ret;
2678
2679 wlvif->power_level = conf->power_level;
2680 }
2681
2682 return 0;
2683 }
2684
2685 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2686 {
2687 struct wl1271 *wl = hw->priv;
2688 struct wl12xx_vif *wlvif;
2689 struct ieee80211_conf *conf = &hw->conf;
2690 int channel, ret = 0;
2691
2692 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2693
2694 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2695 " changed 0x%x",
2696 channel,
2697 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
2698 conf->power_level,
2699 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2700 changed);
2701
2702 /*
2703 * mac80211 will go to idle nearly immediately after transmitting some
2704 * frames, such as the deauth. To make sure those frames reach the air,
2705 * wait here until the TX queue is fully flushed.
2706 */
2707 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2708 (conf->flags & IEEE80211_CONF_IDLE))
2709 wl1271_tx_flush(wl);
2710
2711 mutex_lock(&wl->mutex);
2712
2713 /* we support configuring the channel and band even while off */
2714 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2715 wl->band = conf->channel->band;
2716 wl->channel = channel;
2717 }
2718
2719 if (changed & IEEE80211_CONF_CHANGE_POWER)
2720 wl->power_level = conf->power_level;
2721
2722 if (unlikely(wl->state == WL1271_STATE_OFF))
2723 goto out;
2724
2725 ret = wl1271_ps_elp_wakeup(wl);
2726 if (ret < 0)
2727 goto out;
2728
2729 /* configure each interface */
2730 wl12xx_for_each_wlvif(wl, wlvif) {
2731 ret = wl12xx_config_vif(wl, wlvif, conf, changed);
2732 if (ret < 0)
2733 goto out_sleep;
2734 }
2735
2736 out_sleep:
2737 wl1271_ps_elp_sleep(wl);
2738
2739 out:
2740 mutex_unlock(&wl->mutex);
2741
2742 return ret;
2743 }
2744
2745 struct wl1271_filter_params {
2746 bool enabled;
2747 int mc_list_length;
2748 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2749 };
2750
2751 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2752 struct netdev_hw_addr_list *mc_list)
2753 {
2754 struct wl1271_filter_params *fp;
2755 struct netdev_hw_addr *ha;
2756 struct wl1271 *wl = hw->priv;
2757
2758 if (unlikely(wl->state == WL1271_STATE_OFF))
2759 return 0;
2760
2761 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2762 if (!fp) {
2763 wl1271_error("Out of memory setting filters.");
2764 return 0;
2765 }
2766
2767 /* update multicast filtering parameters */
2768 fp->mc_list_length = 0;
2769 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2770 fp->enabled = false;
2771 } else {
2772 fp->enabled = true;
2773 netdev_hw_addr_list_for_each(ha, mc_list) {
2774 memcpy(fp->mc_list[fp->mc_list_length],
2775 ha->addr, ETH_ALEN);
2776 fp->mc_list_length++;
2777 }
2778 }
2779
2780 return (u64)(unsigned long)fp;
2781 }
2782
2783 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2784 FIF_ALLMULTI | \
2785 FIF_FCSFAIL | \
2786 FIF_BCN_PRBRESP_PROMISC | \
2787 FIF_CONTROL | \
2788 FIF_OTHER_BSS)
2789
2790 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2791 unsigned int changed,
2792 unsigned int *total, u64 multicast)
2793 {
2794 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2795 struct wl1271 *wl = hw->priv;
2796 struct wl12xx_vif *wlvif;
2797
2798 int ret;
2799
2800 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2801 " total %x", changed, *total);
2802
2803 mutex_lock(&wl->mutex);
2804
2805 *total &= WL1271_SUPPORTED_FILTERS;
2806 changed &= WL1271_SUPPORTED_FILTERS;
2807
2808 if (unlikely(wl->state == WL1271_STATE_OFF))
2809 goto out;
2810
2811 ret = wl1271_ps_elp_wakeup(wl);
2812 if (ret < 0)
2813 goto out;
2814
2815 wl12xx_for_each_wlvif(wl, wlvif) {
2816 if (wlvif->bss_type != BSS_TYPE_AP_BSS) {
2817 if (*total & FIF_ALLMULTI)
2818 ret = wl1271_acx_group_address_tbl(wl, wlvif,
2819 false,
2820 NULL, 0);
2821 else if (fp)
2822 ret = wl1271_acx_group_address_tbl(wl, wlvif,
2823 fp->enabled,
2824 fp->mc_list,
2825 fp->mc_list_length);
2826 if (ret < 0)
2827 goto out_sleep;
2828 }
2829 }
2830
2831 /*
2832 * the fw doesn't provide an api to configure the filters. instead,
2833 * the filters configuration is based on the active roles / ROC
2834 * state.
2835 */
2836
2837 out_sleep:
2838 wl1271_ps_elp_sleep(wl);
2839
2840 out:
2841 mutex_unlock(&wl->mutex);
2842 kfree(fp);
2843 }
2844
2845 static int wl1271_record_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2846 u8 id, u8 key_type, u8 key_size,
2847 const u8 *key, u8 hlid, u32 tx_seq_32,
2848 u16 tx_seq_16)
2849 {
2850 struct wl1271_ap_key *ap_key;
2851 int i;
2852
2853 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2854
2855 if (key_size > MAX_KEY_SIZE)
2856 return -EINVAL;
2857
2858 /*
2859 * Find next free entry in ap_keys. Also check we are not replacing
2860 * an existing key.
2861 */
2862 for (i = 0; i < MAX_NUM_KEYS; i++) {
2863 if (wlvif->ap.recorded_keys[i] == NULL)
2864 break;
2865
2866 if (wlvif->ap.recorded_keys[i]->id == id) {
2867 wl1271_warning("trying to record key replacement");
2868 return -EINVAL;
2869 }
2870 }
2871
2872 if (i == MAX_NUM_KEYS)
2873 return -EBUSY;
2874
2875 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2876 if (!ap_key)
2877 return -ENOMEM;
2878
2879 ap_key->id = id;
2880 ap_key->key_type = key_type;
2881 ap_key->key_size = key_size;
2882 memcpy(ap_key->key, key, key_size);
2883 ap_key->hlid = hlid;
2884 ap_key->tx_seq_32 = tx_seq_32;
2885 ap_key->tx_seq_16 = tx_seq_16;
2886
2887 wlvif->ap.recorded_keys[i] = ap_key;
2888 return 0;
2889 }
2890
2891 static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2892 {
2893 int i;
2894
2895 for (i = 0; i < MAX_NUM_KEYS; i++) {
2896 kfree(wlvif->ap.recorded_keys[i]);
2897 wlvif->ap.recorded_keys[i] = NULL;
2898 }
2899 }
2900
2901 static int wl1271_ap_init_hwenc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2902 {
2903 int i, ret = 0;
2904 struct wl1271_ap_key *key;
2905 bool wep_key_added = false;
2906
2907 for (i = 0; i < MAX_NUM_KEYS; i++) {
2908 u8 hlid;
2909 if (wlvif->ap.recorded_keys[i] == NULL)
2910 break;
2911
2912 key = wlvif->ap.recorded_keys[i];
2913 hlid = key->hlid;
2914 if (hlid == WL12XX_INVALID_LINK_ID)
2915 hlid = wlvif->ap.bcast_hlid;
2916
2917 ret = wl1271_cmd_set_ap_key(wl, wlvif, KEY_ADD_OR_REPLACE,
2918 key->id, key->key_type,
2919 key->key_size, key->key,
2920 hlid, key->tx_seq_32,
2921 key->tx_seq_16);
2922 if (ret < 0)
2923 goto out;
2924
2925 if (key->key_type == KEY_WEP)
2926 wep_key_added = true;
2927 }
2928
2929 if (wep_key_added) {
2930 ret = wl12xx_cmd_set_default_wep_key(wl, wlvif->default_key,
2931 wlvif->ap.bcast_hlid);
2932 if (ret < 0)
2933 goto out;
2934 }
2935
2936 out:
2937 wl1271_free_ap_keys(wl, wlvif);
2938 return ret;
2939 }
2940
2941 static int wl1271_set_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2942 u16 action, u8 id, u8 key_type,
2943 u8 key_size, const u8 *key, u32 tx_seq_32,
2944 u16 tx_seq_16, struct ieee80211_sta *sta)
2945 {
2946 int ret;
2947 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
2948
2949 if (is_ap) {
2950 struct wl1271_station *wl_sta;
2951 u8 hlid;
2952
2953 if (sta) {
2954 wl_sta = (struct wl1271_station *)sta->drv_priv;
2955 hlid = wl_sta->hlid;
2956 } else {
2957 hlid = wlvif->ap.bcast_hlid;
2958 }
2959
2960 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
2961 /*
2962 * We do not support removing keys after AP shutdown.
2963 * Pretend we do to make mac80211 happy.
2964 */
2965 if (action != KEY_ADD_OR_REPLACE)
2966 return 0;
2967
2968 ret = wl1271_record_ap_key(wl, wlvif, id,
2969 key_type, key_size,
2970 key, hlid, tx_seq_32,
2971 tx_seq_16);
2972 } else {
2973 ret = wl1271_cmd_set_ap_key(wl, wlvif, action,
2974 id, key_type, key_size,
2975 key, hlid, tx_seq_32,
2976 tx_seq_16);
2977 }
2978
2979 if (ret < 0)
2980 return ret;
2981 } else {
2982 const u8 *addr;
2983 static const u8 bcast_addr[ETH_ALEN] = {
2984 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2985 };
2986
2987 /*
2988 * A STA set to GEM cipher requires 2 tx spare blocks.
2989 * Return to default value when GEM cipher key is removed
2990 */
2991 if (key_type == KEY_GEM) {
2992 if (action == KEY_ADD_OR_REPLACE)
2993 wl->tx_spare_blocks = 2;
2994 else if (action == KEY_REMOVE)
2995 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
2996 }
2997
2998 addr = sta ? sta->addr : bcast_addr;
2999
3000 if (is_zero_ether_addr(addr)) {
3001 /* We dont support TX only encryption */
3002 return -EOPNOTSUPP;
3003 }
3004
3005 /* The wl1271 does not allow to remove unicast keys - they
3006 will be cleared automatically on next CMD_JOIN. Ignore the
3007 request silently, as we dont want the mac80211 to emit
3008 an error message. */
3009 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
3010 return 0;
3011
3012 /* don't remove key if hlid was already deleted */
3013 if (action == KEY_REMOVE &&
3014 wlvif->sta.hlid == WL12XX_INVALID_LINK_ID)
3015 return 0;
3016
3017 ret = wl1271_cmd_set_sta_key(wl, wlvif, action,
3018 id, key_type, key_size,
3019 key, addr, tx_seq_32,
3020 tx_seq_16);
3021 if (ret < 0)
3022 return ret;
3023
3024 /* the default WEP key needs to be configured at least once */
3025 if (key_type == KEY_WEP) {
3026 ret = wl12xx_cmd_set_default_wep_key(wl,
3027 wlvif->default_key,
3028 wlvif->sta.hlid);
3029 if (ret < 0)
3030 return ret;
3031 }
3032 }
3033
3034 return 0;
3035 }
3036
3037 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3038 struct ieee80211_vif *vif,
3039 struct ieee80211_sta *sta,
3040 struct ieee80211_key_conf *key_conf)
3041 {
3042 struct wl1271 *wl = hw->priv;
3043 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3044 int ret;
3045 u32 tx_seq_32 = 0;
3046 u16 tx_seq_16 = 0;
3047 u8 key_type;
3048
3049 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
3050
3051 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
3052 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
3053 key_conf->cipher, key_conf->keyidx,
3054 key_conf->keylen, key_conf->flags);
3055 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
3056
3057 mutex_lock(&wl->mutex);
3058
3059 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3060 ret = -EAGAIN;
3061 goto out_unlock;
3062 }
3063
3064 ret = wl1271_ps_elp_wakeup(wl);
3065 if (ret < 0)
3066 goto out_unlock;
3067
3068 switch (key_conf->cipher) {
3069 case WLAN_CIPHER_SUITE_WEP40:
3070 case WLAN_CIPHER_SUITE_WEP104:
3071 key_type = KEY_WEP;
3072
3073 key_conf->hw_key_idx = key_conf->keyidx;
3074 break;
3075 case WLAN_CIPHER_SUITE_TKIP:
3076 key_type = KEY_TKIP;
3077
3078 key_conf->hw_key_idx = key_conf->keyidx;
3079 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
3080 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
3081 break;
3082 case WLAN_CIPHER_SUITE_CCMP:
3083 key_type = KEY_AES;
3084
3085 key_conf->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
3086 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
3087 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
3088 break;
3089 case WL1271_CIPHER_SUITE_GEM:
3090 key_type = KEY_GEM;
3091 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
3092 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
3093 break;
3094 default:
3095 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
3096
3097 ret = -EOPNOTSUPP;
3098 goto out_sleep;
3099 }
3100
3101 switch (cmd) {
3102 case SET_KEY:
3103 ret = wl1271_set_key(wl, wlvif, KEY_ADD_OR_REPLACE,
3104 key_conf->keyidx, key_type,
3105 key_conf->keylen, key_conf->key,
3106 tx_seq_32, tx_seq_16, sta);
3107 if (ret < 0) {
3108 wl1271_error("Could not add or replace key");
3109 goto out_sleep;
3110 }
3111
3112 /*
3113 * reconfiguring arp response if the unicast (or common)
3114 * encryption key type was changed
3115 */
3116 if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
3117 (sta || key_type == KEY_WEP) &&
3118 wlvif->encryption_type != key_type) {
3119 wlvif->encryption_type = key_type;
3120 ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
3121 if (ret < 0) {
3122 wl1271_warning("build arp rsp failed: %d", ret);
3123 goto out_sleep;
3124 }
3125 }
3126 break;
3127
3128 case DISABLE_KEY:
3129 ret = wl1271_set_key(wl, wlvif, KEY_REMOVE,
3130 key_conf->keyidx, key_type,
3131 key_conf->keylen, key_conf->key,
3132 0, 0, sta);
3133 if (ret < 0) {
3134 wl1271_error("Could not remove key");
3135 goto out_sleep;
3136 }
3137 break;
3138
3139 default:
3140 wl1271_error("Unsupported key cmd 0x%x", cmd);
3141 ret = -EOPNOTSUPP;
3142 break;
3143 }
3144
3145 out_sleep:
3146 wl1271_ps_elp_sleep(wl);
3147
3148 out_unlock:
3149 mutex_unlock(&wl->mutex);
3150
3151 return ret;
3152 }
3153
3154 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
3155 struct ieee80211_vif *vif,
3156 struct cfg80211_scan_request *req)
3157 {
3158 struct wl1271 *wl = hw->priv;
3159 int ret;
3160 u8 *ssid = NULL;
3161 size_t len = 0;
3162
3163 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
3164
3165 if (req->n_ssids) {
3166 ssid = req->ssids[0].ssid;
3167 len = req->ssids[0].ssid_len;
3168 }
3169
3170 mutex_lock(&wl->mutex);
3171
3172 if (wl->state == WL1271_STATE_OFF) {
3173 /*
3174 * We cannot return -EBUSY here because cfg80211 will expect
3175 * a call to ieee80211_scan_completed if we do - in this case
3176 * there won't be any call.
3177 */
3178 ret = -EAGAIN;
3179 goto out;
3180 }
3181
3182 ret = wl1271_ps_elp_wakeup(wl);
3183 if (ret < 0)
3184 goto out;
3185
3186 /* fail if there is any role in ROC */
3187 if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
3188 /* don't allow scanning right now */
3189 ret = -EBUSY;
3190 goto out_sleep;
3191 }
3192
3193 ret = wl1271_scan(hw->priv, vif, ssid, len, req);
3194 out_sleep:
3195 wl1271_ps_elp_sleep(wl);
3196 out:
3197 mutex_unlock(&wl->mutex);
3198
3199 return ret;
3200 }
3201
3202 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
3203 struct ieee80211_vif *vif)
3204 {
3205 struct wl1271 *wl = hw->priv;
3206 int ret;
3207
3208 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
3209
3210 mutex_lock(&wl->mutex);
3211
3212 if (wl->state == WL1271_STATE_OFF)
3213 goto out;
3214
3215 if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
3216 goto out;
3217
3218 ret = wl1271_ps_elp_wakeup(wl);
3219 if (ret < 0)
3220 goto out;
3221
3222 if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
3223 ret = wl1271_scan_stop(wl);
3224 if (ret < 0)
3225 goto out_sleep;
3226 }
3227
3228 /*
3229 * Rearm the tx watchdog just before idling scan. This
3230 * prevents just-finished scans from triggering the watchdog
3231 */
3232 wl12xx_rearm_tx_watchdog_locked(wl);
3233
3234 wl->scan.state = WL1271_SCAN_STATE_IDLE;
3235 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
3236 wl->scan_vif = NULL;
3237 wl->scan.req = NULL;
3238 ieee80211_scan_completed(wl->hw, true);
3239
3240 out_sleep:
3241 wl1271_ps_elp_sleep(wl);
3242 out:
3243 mutex_unlock(&wl->mutex);
3244
3245 cancel_delayed_work_sync(&wl->scan_complete_work);
3246 }
3247
3248 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
3249 struct ieee80211_vif *vif,
3250 struct cfg80211_sched_scan_request *req,
3251 struct ieee80211_sched_scan_ies *ies)
3252 {
3253 struct wl1271 *wl = hw->priv;
3254 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3255 int ret;
3256
3257 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
3258
3259 mutex_lock(&wl->mutex);
3260
3261 if (wl->state == WL1271_STATE_OFF) {
3262 ret = -EAGAIN;
3263 goto out;
3264 }
3265
3266 ret = wl1271_ps_elp_wakeup(wl);
3267 if (ret < 0)
3268 goto out;
3269
3270 ret = wl1271_scan_sched_scan_config(wl, wlvif, req, ies);
3271 if (ret < 0)
3272 goto out_sleep;
3273
3274 ret = wl1271_scan_sched_scan_start(wl, wlvif);
3275 if (ret < 0)
3276 goto out_sleep;
3277
3278 wl->sched_scanning = true;
3279
3280 out_sleep:
3281 wl1271_ps_elp_sleep(wl);
3282 out:
3283 mutex_unlock(&wl->mutex);
3284 return ret;
3285 }
3286
3287 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
3288 struct ieee80211_vif *vif)
3289 {
3290 struct wl1271 *wl = hw->priv;
3291 int ret;
3292
3293 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
3294
3295 mutex_lock(&wl->mutex);
3296
3297 if (wl->state == WL1271_STATE_OFF)
3298 goto out;
3299
3300 ret = wl1271_ps_elp_wakeup(wl);
3301 if (ret < 0)
3302 goto out;
3303
3304 wl1271_scan_sched_scan_stop(wl);
3305
3306 wl1271_ps_elp_sleep(wl);
3307 out:
3308 mutex_unlock(&wl->mutex);
3309 }
3310
3311 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3312 {
3313 struct wl1271 *wl = hw->priv;
3314 int ret = 0;
3315
3316 mutex_lock(&wl->mutex);
3317
3318 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3319 ret = -EAGAIN;
3320 goto out;
3321 }
3322
3323 ret = wl1271_ps_elp_wakeup(wl);
3324 if (ret < 0)
3325 goto out;
3326
3327 ret = wl1271_acx_frag_threshold(wl, value);
3328 if (ret < 0)
3329 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
3330
3331 wl1271_ps_elp_sleep(wl);
3332
3333 out:
3334 mutex_unlock(&wl->mutex);
3335
3336 return ret;
3337 }
3338
3339 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3340 {
3341 struct wl1271 *wl = hw->priv;
3342 struct wl12xx_vif *wlvif;
3343 int ret = 0;
3344
3345 mutex_lock(&wl->mutex);
3346
3347 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3348 ret = -EAGAIN;
3349 goto out;
3350 }
3351
3352 ret = wl1271_ps_elp_wakeup(wl);
3353 if (ret < 0)
3354 goto out;
3355
3356 wl12xx_for_each_wlvif(wl, wlvif) {
3357 ret = wl1271_acx_rts_threshold(wl, wlvif, value);
3358 if (ret < 0)
3359 wl1271_warning("set rts threshold failed: %d", ret);
3360 }
3361 wl1271_ps_elp_sleep(wl);
3362
3363 out:
3364 mutex_unlock(&wl->mutex);
3365
3366 return ret;
3367 }
3368
3369 static int wl1271_ssid_set(struct ieee80211_vif *vif, struct sk_buff *skb,
3370 int offset)
3371 {
3372 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3373 u8 ssid_len;
3374 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
3375 skb->len - offset);
3376
3377 if (!ptr) {
3378 wl1271_error("No SSID in IEs!");
3379 return -ENOENT;
3380 }
3381
3382 ssid_len = ptr[1];
3383 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
3384 wl1271_error("SSID is too long!");
3385 return -EINVAL;
3386 }
3387
3388 wlvif->ssid_len = ssid_len;
3389 memcpy(wlvif->ssid, ptr+2, ssid_len);
3390 return 0;
3391 }
3392
3393 static void wl12xx_remove_ie(struct sk_buff *skb, u8 eid, int ieoffset)
3394 {
3395 int len;
3396 const u8 *next, *end = skb->data + skb->len;
3397 u8 *ie = (u8 *)cfg80211_find_ie(eid, skb->data + ieoffset,
3398 skb->len - ieoffset);
3399 if (!ie)
3400 return;
3401 len = ie[1] + 2;
3402 next = ie + len;
3403 memmove(ie, next, end - next);
3404 skb_trim(skb, skb->len - len);
3405 }
3406
3407 static void wl12xx_remove_vendor_ie(struct sk_buff *skb,
3408 unsigned int oui, u8 oui_type,
3409 int ieoffset)
3410 {
3411 int len;
3412 const u8 *next, *end = skb->data + skb->len;
3413 u8 *ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
3414 skb->data + ieoffset,
3415 skb->len - ieoffset);
3416 if (!ie)
3417 return;
3418 len = ie[1] + 2;
3419 next = ie + len;
3420 memmove(ie, next, end - next);
3421 skb_trim(skb, skb->len - len);
3422 }
3423
3424 static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl, u32 rates,
3425 struct ieee80211_vif *vif)
3426 {
3427 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3428 struct sk_buff *skb;
3429 int ret;
3430
3431 skb = ieee80211_proberesp_get(wl->hw, vif);
3432 if (!skb)
3433 return -EOPNOTSUPP;
3434
3435 ret = wl1271_cmd_template_set(wl, wlvif->role_id,
3436 CMD_TEMPL_AP_PROBE_RESPONSE,
3437 skb->data,
3438 skb->len, 0,
3439 rates);
3440
3441 dev_kfree_skb(skb);
3442 return ret;
3443 }
3444
3445 static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271 *wl,
3446 struct ieee80211_vif *vif,
3447 u8 *probe_rsp_data,
3448 size_t probe_rsp_len,
3449 u32 rates)
3450 {
3451 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3452 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
3453 u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE];
3454 int ssid_ie_offset, ie_offset, templ_len;
3455 const u8 *ptr;
3456
3457 /* no need to change probe response if the SSID is set correctly */
3458 if (wlvif->ssid_len > 0)
3459 return wl1271_cmd_template_set(wl, wlvif->role_id,
3460 CMD_TEMPL_AP_PROBE_RESPONSE,
3461 probe_rsp_data,
3462 probe_rsp_len, 0,
3463 rates);
3464
3465 if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) {
3466 wl1271_error("probe_rsp template too big");
3467 return -EINVAL;
3468 }
3469
3470 /* start searching from IE offset */
3471 ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
3472
3473 ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset,
3474 probe_rsp_len - ie_offset);
3475 if (!ptr) {
3476 wl1271_error("No SSID in beacon!");
3477 return -EINVAL;
3478 }
3479
3480 ssid_ie_offset = ptr - probe_rsp_data;
3481 ptr += (ptr[1] + 2);
3482
3483 memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset);
3484
3485 /* insert SSID from bss_conf */
3486 probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID;
3487 probe_rsp_templ[ssid_ie_offset + 1] = bss_conf->ssid_len;
3488 memcpy(probe_rsp_templ + ssid_ie_offset + 2,
3489 bss_conf->ssid, bss_conf->ssid_len);
3490 templ_len = ssid_ie_offset + 2 + bss_conf->ssid_len;
3491
3492 memcpy(probe_rsp_templ + ssid_ie_offset + 2 + bss_conf->ssid_len,
3493 ptr, probe_rsp_len - (ptr - probe_rsp_data));
3494 templ_len += probe_rsp_len - (ptr - probe_rsp_data);
3495
3496 return wl1271_cmd_template_set(wl, wlvif->role_id,
3497 CMD_TEMPL_AP_PROBE_RESPONSE,
3498 probe_rsp_templ,
3499 templ_len, 0,
3500 rates);
3501 }
3502
3503 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
3504 struct ieee80211_vif *vif,
3505 struct ieee80211_bss_conf *bss_conf,
3506 u32 changed)
3507 {
3508 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3509 int ret = 0;
3510
3511 if (changed & BSS_CHANGED_ERP_SLOT) {
3512 if (bss_conf->use_short_slot)
3513 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT);
3514 else
3515 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG);
3516 if (ret < 0) {
3517 wl1271_warning("Set slot time failed %d", ret);
3518 goto out;
3519 }
3520 }
3521
3522 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3523 if (bss_conf->use_short_preamble)
3524 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT);
3525 else
3526 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG);
3527 }
3528
3529 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3530 if (bss_conf->use_cts_prot)
3531 ret = wl1271_acx_cts_protect(wl, wlvif,
3532 CTSPROTECT_ENABLE);
3533 else
3534 ret = wl1271_acx_cts_protect(wl, wlvif,
3535 CTSPROTECT_DISABLE);
3536 if (ret < 0) {
3537 wl1271_warning("Set ctsprotect failed %d", ret);
3538 goto out;
3539 }
3540 }
3541
3542 out:
3543 return ret;
3544 }
3545
3546 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3547 struct ieee80211_vif *vif,
3548 struct ieee80211_bss_conf *bss_conf,
3549 u32 changed)
3550 {
3551 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3552 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
3553 int ret = 0;
3554
3555 if ((changed & BSS_CHANGED_BEACON_INT)) {
3556 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
3557 bss_conf->beacon_int);
3558
3559 wlvif->beacon_int = bss_conf->beacon_int;
3560 }
3561
3562 if ((changed & BSS_CHANGED_AP_PROBE_RESP) && is_ap) {
3563 u32 rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
3564 if (!wl1271_ap_set_probe_resp_tmpl(wl, rate, vif)) {
3565 wl1271_debug(DEBUG_AP, "probe response updated");
3566 set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags);
3567 }
3568 }
3569
3570 if ((changed & BSS_CHANGED_BEACON)) {
3571 struct ieee80211_hdr *hdr;
3572 u32 min_rate;
3573 int ieoffset = offsetof(struct ieee80211_mgmt,
3574 u.beacon.variable);
3575 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3576 u16 tmpl_id;
3577
3578 if (!beacon) {
3579 ret = -EINVAL;
3580 goto out;
3581 }
3582
3583 wl1271_debug(DEBUG_MASTER, "beacon updated");
3584
3585 ret = wl1271_ssid_set(vif, beacon, ieoffset);
3586 if (ret < 0) {
3587 dev_kfree_skb(beacon);
3588 goto out;
3589 }
3590 min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
3591 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3592 CMD_TEMPL_BEACON;
3593 ret = wl1271_cmd_template_set(wl, wlvif->role_id, tmpl_id,
3594 beacon->data,
3595 beacon->len, 0,
3596 min_rate);
3597 if (ret < 0) {
3598 dev_kfree_skb(beacon);
3599 goto out;
3600 }
3601
3602 /*
3603 * In case we already have a probe-resp beacon set explicitly
3604 * by usermode, don't use the beacon data.
3605 */
3606 if (test_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags))
3607 goto end_bcn;
3608
3609 /* remove TIM ie from probe response */
3610 wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset);
3611
3612 /*
3613 * remove p2p ie from probe response.
3614 * the fw reponds to probe requests that don't include
3615 * the p2p ie. probe requests with p2p ie will be passed,
3616 * and will be responded by the supplicant (the spec
3617 * forbids including the p2p ie when responding to probe
3618 * requests that didn't include it).
3619 */
3620 wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA,
3621 WLAN_OUI_TYPE_WFA_P2P, ieoffset);
3622
3623 hdr = (struct ieee80211_hdr *) beacon->data;
3624 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3625 IEEE80211_STYPE_PROBE_RESP);
3626 if (is_ap)
3627 ret = wl1271_ap_set_probe_resp_tmpl_legacy(wl, vif,
3628 beacon->data,
3629 beacon->len,
3630 min_rate);
3631 else
3632 ret = wl1271_cmd_template_set(wl, wlvif->role_id,
3633 CMD_TEMPL_PROBE_RESPONSE,
3634 beacon->data,
3635 beacon->len, 0,
3636 min_rate);
3637 end_bcn:
3638 dev_kfree_skb(beacon);
3639 if (ret < 0)
3640 goto out;
3641 }
3642
3643 out:
3644 if (ret != 0)
3645 wl1271_error("beacon info change failed: %d", ret);
3646 return ret;
3647 }
3648
3649 /* AP mode changes */
3650 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3651 struct ieee80211_vif *vif,
3652 struct ieee80211_bss_conf *bss_conf,
3653 u32 changed)
3654 {
3655 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3656 int ret = 0;
3657
3658 if ((changed & BSS_CHANGED_BASIC_RATES)) {
3659 u32 rates = bss_conf->basic_rates;
3660
3661 wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates,
3662 wlvif->band);
3663 wlvif->basic_rate = wl1271_tx_min_rate_get(wl,
3664 wlvif->basic_rate_set);
3665
3666 ret = wl1271_init_ap_rates(wl, wlvif);
3667 if (ret < 0) {
3668 wl1271_error("AP rate policy change failed %d", ret);
3669 goto out;
3670 }
3671
3672 ret = wl1271_ap_init_templates(wl, vif);
3673 if (ret < 0)
3674 goto out;
3675 }
3676
3677 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3678 if (ret < 0)
3679 goto out;
3680
3681 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3682 if (bss_conf->enable_beacon) {
3683 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
3684 ret = wl12xx_cmd_role_start_ap(wl, wlvif);
3685 if (ret < 0)
3686 goto out;
3687
3688 ret = wl1271_ap_init_hwenc(wl, wlvif);
3689 if (ret < 0)
3690 goto out;
3691
3692 set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
3693 wl1271_debug(DEBUG_AP, "started AP");
3694 }
3695 } else {
3696 if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
3697 ret = wl12xx_cmd_role_stop_ap(wl, wlvif);
3698 if (ret < 0)
3699 goto out;
3700
3701 clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
3702 clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET,
3703 &wlvif->flags);
3704 wl1271_debug(DEBUG_AP, "stopped AP");
3705 }
3706 }
3707 }
3708
3709 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
3710 if (ret < 0)
3711 goto out;
3712
3713 /* Handle HT information change */
3714 if ((changed & BSS_CHANGED_HT) &&
3715 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3716 ret = wl1271_acx_set_ht_information(wl, wlvif,
3717 bss_conf->ht_operation_mode);
3718 if (ret < 0) {
3719 wl1271_warning("Set ht information failed %d", ret);
3720 goto out;
3721 }
3722 }
3723
3724 out:
3725 return;
3726 }
3727
3728 /* STA/IBSS mode changes */
3729 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3730 struct ieee80211_vif *vif,
3731 struct ieee80211_bss_conf *bss_conf,
3732 u32 changed)
3733 {
3734 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3735 bool do_join = false, set_assoc = false;
3736 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
3737 bool ibss_joined = false;
3738 u32 sta_rate_set = 0;
3739 int ret;
3740 struct ieee80211_sta *sta;
3741 bool sta_exists = false;
3742 struct ieee80211_sta_ht_cap sta_ht_cap;
3743
3744 if (is_ibss) {
3745 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3746 changed);
3747 if (ret < 0)
3748 goto out;
3749 }
3750
3751 if (changed & BSS_CHANGED_IBSS) {
3752 if (bss_conf->ibss_joined) {
3753 set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags);
3754 ibss_joined = true;
3755 } else {
3756 if (test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED,
3757 &wlvif->flags))
3758 wl1271_unjoin(wl, wlvif);
3759 }
3760 }
3761
3762 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
3763 do_join = true;
3764
3765 /* Need to update the SSID (for filtering etc) */
3766 if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
3767 do_join = true;
3768
3769 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
3770 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3771 bss_conf->enable_beacon ? "enabled" : "disabled");
3772
3773 do_join = true;
3774 }
3775
3776 if (changed & BSS_CHANGED_IDLE && !is_ibss) {
3777 ret = wl1271_sta_handle_idle(wl, wlvif, bss_conf->idle);
3778 if (ret < 0)
3779 wl1271_warning("idle mode change failed %d", ret);
3780 }
3781
3782 if ((changed & BSS_CHANGED_CQM)) {
3783 bool enable = false;
3784 if (bss_conf->cqm_rssi_thold)
3785 enable = true;
3786 ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable,
3787 bss_conf->cqm_rssi_thold,
3788 bss_conf->cqm_rssi_hyst);
3789 if (ret < 0)
3790 goto out;
3791 wlvif->rssi_thold = bss_conf->cqm_rssi_thold;
3792 }
3793
3794 if (changed & BSS_CHANGED_BSSID &&
3795 (is_ibss || bss_conf->assoc))
3796 if (!is_zero_ether_addr(bss_conf->bssid)) {
3797 ret = wl12xx_cmd_build_null_data(wl, wlvif);
3798 if (ret < 0)
3799 goto out;
3800
3801 ret = wl1271_build_qos_null_data(wl, vif);
3802 if (ret < 0)
3803 goto out;
3804
3805 /* Need to update the BSSID (for filtering etc) */
3806 do_join = true;
3807 }
3808
3809 if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
3810 rcu_read_lock();
3811 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3812 if (!sta)
3813 goto sta_not_found;
3814
3815 /* save the supp_rates of the ap */
3816 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3817 if (sta->ht_cap.ht_supported)
3818 sta_rate_set |=
3819 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
3820 sta_ht_cap = sta->ht_cap;
3821 sta_exists = true;
3822
3823 sta_not_found:
3824 rcu_read_unlock();
3825 }
3826
3827 if ((changed & BSS_CHANGED_ASSOC)) {
3828 if (bss_conf->assoc) {
3829 u32 rates;
3830 int ieoffset;
3831 wlvif->aid = bss_conf->aid;
3832 wlvif->beacon_int = bss_conf->beacon_int;
3833 set_assoc = true;
3834
3835 /*
3836 * use basic rates from AP, and determine lowest rate
3837 * to use with control frames.
3838 */
3839 rates = bss_conf->basic_rates;
3840 wlvif->basic_rate_set =
3841 wl1271_tx_enabled_rates_get(wl, rates,
3842 wlvif->band);
3843 wlvif->basic_rate =
3844 wl1271_tx_min_rate_get(wl,
3845 wlvif->basic_rate_set);
3846 if (sta_rate_set)
3847 wlvif->rate_set =
3848 wl1271_tx_enabled_rates_get(wl,
3849 sta_rate_set,
3850 wlvif->band);
3851 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3852 if (ret < 0)
3853 goto out;
3854
3855 /*
3856 * with wl1271, we don't need to update the
3857 * beacon_int and dtim_period, because the firmware
3858 * updates it by itself when the first beacon is
3859 * received after a join.
3860 */
3861 ret = wl1271_cmd_build_ps_poll(wl, wlvif, wlvif->aid);
3862 if (ret < 0)
3863 goto out;
3864
3865 /*
3866 * Get a template for hardware connection maintenance
3867 */
3868 dev_kfree_skb(wlvif->probereq);
3869 wlvif->probereq = wl1271_cmd_build_ap_probe_req(wl,
3870 wlvif,
3871 NULL);
3872 ieoffset = offsetof(struct ieee80211_mgmt,
3873 u.probe_req.variable);
3874 wl1271_ssid_set(vif, wlvif->probereq, ieoffset);
3875
3876 /* enable the connection monitoring feature */
3877 ret = wl1271_acx_conn_monit_params(wl, wlvif, true);
3878 if (ret < 0)
3879 goto out;
3880 } else {
3881 /* use defaults when not associated */
3882 bool was_assoc =
3883 !!test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED,
3884 &wlvif->flags);
3885 bool was_ifup =
3886 !!test_and_clear_bit(WLVIF_FLAG_STA_STATE_SENT,
3887 &wlvif->flags);
3888 wlvif->aid = 0;
3889
3890 /* free probe-request template */
3891 dev_kfree_skb(wlvif->probereq);
3892 wlvif->probereq = NULL;
3893
3894 /* revert back to minimum rates for the current band */
3895 wl1271_set_band_rate(wl, wlvif);
3896 wlvif->basic_rate =
3897 wl1271_tx_min_rate_get(wl,
3898 wlvif->basic_rate_set);
3899 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3900 if (ret < 0)
3901 goto out;
3902
3903 /* disable connection monitor features */
3904 ret = wl1271_acx_conn_monit_params(wl, wlvif, false);
3905
3906 /* Disable the keep-alive feature */
3907 ret = wl1271_acx_keep_alive_mode(wl, wlvif, false);
3908 if (ret < 0)
3909 goto out;
3910
3911 /* restore the bssid filter and go to dummy bssid */
3912 if (was_assoc) {
3913 /*
3914 * we might have to disable roc, if there was
3915 * no IF_OPER_UP notification.
3916 */
3917 if (!was_ifup) {
3918 ret = wl12xx_croc(wl, wlvif->role_id);
3919 if (ret < 0)
3920 goto out;
3921 }
3922 /*
3923 * (we also need to disable roc in case of
3924 * roaming on the same channel. until we will
3925 * have a better flow...)
3926 */
3927 if (test_bit(wlvif->dev_role_id, wl->roc_map)) {
3928 ret = wl12xx_croc(wl,
3929 wlvif->dev_role_id);
3930 if (ret < 0)
3931 goto out;
3932 }
3933
3934 wl1271_unjoin(wl, wlvif);
3935 if (!bss_conf->idle)
3936 wl12xx_start_dev(wl, wlvif);
3937 }
3938 }
3939 }
3940
3941 if (changed & BSS_CHANGED_IBSS) {
3942 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3943 bss_conf->ibss_joined);
3944
3945 if (bss_conf->ibss_joined) {
3946 u32 rates = bss_conf->basic_rates;
3947 wlvif->basic_rate_set =
3948 wl1271_tx_enabled_rates_get(wl, rates,
3949 wlvif->band);
3950 wlvif->basic_rate =
3951 wl1271_tx_min_rate_get(wl,
3952 wlvif->basic_rate_set);
3953
3954 /* by default, use 11b + OFDM rates */
3955 wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3956 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3957 if (ret < 0)
3958 goto out;
3959 }
3960 }
3961
3962 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
3963 if (ret < 0)
3964 goto out;
3965
3966 if (do_join) {
3967 ret = wl1271_join(wl, wlvif, set_assoc);
3968 if (ret < 0) {
3969 wl1271_warning("cmd join failed %d", ret);
3970 goto out;
3971 }
3972
3973 /* ROC until connected (after EAPOL exchange) */
3974 if (!is_ibss) {
3975 ret = wl12xx_roc(wl, wlvif, wlvif->role_id);
3976 if (ret < 0)
3977 goto out;
3978
3979 if (test_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags))
3980 wl12xx_set_authorized(wl, wlvif);
3981 }
3982 /*
3983 * stop device role if started (we might already be in
3984 * STA/IBSS role).
3985 */
3986 if (wl12xx_dev_role_started(wlvif)) {
3987 ret = wl12xx_stop_dev(wl, wlvif);
3988 if (ret < 0)
3989 goto out;
3990 }
3991 }
3992
3993 /* Handle new association with HT. Do this after join. */
3994 if (sta_exists) {
3995 if ((changed & BSS_CHANGED_HT) &&
3996 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3997 ret = wl1271_acx_set_ht_capabilities(wl,
3998 &sta_ht_cap,
3999 true,
4000 wlvif->sta.hlid);
4001 if (ret < 0) {
4002 wl1271_warning("Set ht cap true failed %d",
4003 ret);
4004 goto out;
4005 }
4006 }
4007 /* handle new association without HT and disassociation */
4008 else if (changed & BSS_CHANGED_ASSOC) {
4009 ret = wl1271_acx_set_ht_capabilities(wl,
4010 &sta_ht_cap,
4011 false,
4012 wlvif->sta.hlid);
4013 if (ret < 0) {
4014 wl1271_warning("Set ht cap false failed %d",
4015 ret);
4016 goto out;
4017 }
4018 }
4019 }
4020
4021 /* Handle HT information change. Done after join. */
4022 if ((changed & BSS_CHANGED_HT) &&
4023 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
4024 ret = wl1271_acx_set_ht_information(wl, wlvif,
4025 bss_conf->ht_operation_mode);
4026 if (ret < 0) {
4027 wl1271_warning("Set ht information failed %d", ret);
4028 goto out;
4029 }
4030 }
4031
4032 /* Handle arp filtering. Done after join. */
4033 if ((changed & BSS_CHANGED_ARP_FILTER) ||
4034 (!is_ibss && (changed & BSS_CHANGED_QOS))) {
4035 __be32 addr = bss_conf->arp_addr_list[0];
4036 wlvif->sta.qos = bss_conf->qos;
4037 WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS);
4038
4039 if (bss_conf->arp_addr_cnt == 1 &&
4040 bss_conf->arp_filter_enabled) {
4041 wlvif->ip_addr = addr;
4042 /*
4043 * The template should have been configured only upon
4044 * association. however, it seems that the correct ip
4045 * isn't being set (when sending), so we have to
4046 * reconfigure the template upon every ip change.
4047 */
4048 ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
4049 if (ret < 0) {
4050 wl1271_warning("build arp rsp failed: %d", ret);
4051 goto out;
4052 }
4053
4054 ret = wl1271_acx_arp_ip_filter(wl, wlvif,
4055 (ACX_ARP_FILTER_ARP_FILTERING |
4056 ACX_ARP_FILTER_AUTO_ARP),
4057 addr);
4058 } else {
4059 wlvif->ip_addr = 0;
4060 ret = wl1271_acx_arp_ip_filter(wl, wlvif, 0, addr);
4061 }
4062
4063 if (ret < 0)
4064 goto out;
4065 }
4066
4067 out:
4068 return;
4069 }
4070
4071 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
4072 struct ieee80211_vif *vif,
4073 struct ieee80211_bss_conf *bss_conf,
4074 u32 changed)
4075 {
4076 struct wl1271 *wl = hw->priv;
4077 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4078 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
4079 int ret;
4080
4081 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
4082 (int)changed);
4083
4084 mutex_lock(&wl->mutex);
4085
4086 if (unlikely(wl->state == WL1271_STATE_OFF))
4087 goto out;
4088
4089 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
4090 goto out;
4091
4092 ret = wl1271_ps_elp_wakeup(wl);
4093 if (ret < 0)
4094 goto out;
4095
4096 if (is_ap)
4097 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
4098 else
4099 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
4100
4101 wl1271_ps_elp_sleep(wl);
4102
4103 out:
4104 mutex_unlock(&wl->mutex);
4105 }
4106
4107 static int wl1271_op_conf_tx(struct ieee80211_hw *hw,
4108 struct ieee80211_vif *vif, u16 queue,
4109 const struct ieee80211_tx_queue_params *params)
4110 {
4111 struct wl1271 *wl = hw->priv;
4112 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4113 u8 ps_scheme;
4114 int ret = 0;
4115
4116 mutex_lock(&wl->mutex);
4117
4118 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
4119
4120 if (params->uapsd)
4121 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
4122 else
4123 ps_scheme = CONF_PS_SCHEME_LEGACY;
4124
4125 if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
4126 goto out;
4127
4128 ret = wl1271_ps_elp_wakeup(wl);
4129 if (ret < 0)
4130 goto out;
4131
4132 /*
4133 * the txop is confed in units of 32us by the mac80211,
4134 * we need us
4135 */
4136 ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4137 params->cw_min, params->cw_max,
4138 params->aifs, params->txop << 5);
4139 if (ret < 0)
4140 goto out_sleep;
4141
4142 ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4143 CONF_CHANNEL_TYPE_EDCF,
4144 wl1271_tx_get_queue(queue),
4145 ps_scheme, CONF_ACK_POLICY_LEGACY,
4146 0, 0);
4147
4148 out_sleep:
4149 wl1271_ps_elp_sleep(wl);
4150
4151 out:
4152 mutex_unlock(&wl->mutex);
4153
4154 return ret;
4155 }
4156
4157 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw,
4158 struct ieee80211_vif *vif)
4159 {
4160
4161 struct wl1271 *wl = hw->priv;
4162 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4163 u64 mactime = ULLONG_MAX;
4164 int ret;
4165
4166 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
4167
4168 mutex_lock(&wl->mutex);
4169
4170 if (unlikely(wl->state == WL1271_STATE_OFF))
4171 goto out;
4172
4173 ret = wl1271_ps_elp_wakeup(wl);
4174 if (ret < 0)
4175 goto out;
4176
4177 ret = wl12xx_acx_tsf_info(wl, wlvif, &mactime);
4178 if (ret < 0)
4179 goto out_sleep;
4180
4181 out_sleep:
4182 wl1271_ps_elp_sleep(wl);
4183
4184 out:
4185 mutex_unlock(&wl->mutex);
4186 return mactime;
4187 }
4188
4189 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
4190 struct survey_info *survey)
4191 {
4192 struct wl1271 *wl = hw->priv;
4193 struct ieee80211_conf *conf = &hw->conf;
4194
4195 if (idx != 0)
4196 return -ENOENT;
4197
4198 survey->channel = conf->channel;
4199 survey->filled = SURVEY_INFO_NOISE_DBM;
4200 survey->noise = wl->noise;
4201
4202 return 0;
4203 }
4204
4205 static int wl1271_allocate_sta(struct wl1271 *wl,
4206 struct wl12xx_vif *wlvif,
4207 struct ieee80211_sta *sta)
4208 {
4209 struct wl1271_station *wl_sta;
4210 int ret;
4211
4212
4213 if (wl->active_sta_count >= AP_MAX_STATIONS) {
4214 wl1271_warning("could not allocate HLID - too much stations");
4215 return -EBUSY;
4216 }
4217
4218 wl_sta = (struct wl1271_station *)sta->drv_priv;
4219 ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid);
4220 if (ret < 0) {
4221 wl1271_warning("could not allocate HLID - too many links");
4222 return -EBUSY;
4223 }
4224
4225 set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map);
4226 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
4227 wl->active_sta_count++;
4228 return 0;
4229 }
4230
4231 void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid)
4232 {
4233 if (!test_bit(hlid, wlvif->ap.sta_hlid_map))
4234 return;
4235
4236 clear_bit(hlid, wlvif->ap.sta_hlid_map);
4237 memset(wl->links[hlid].addr, 0, ETH_ALEN);
4238 wl->links[hlid].ba_bitmap = 0;
4239 __clear_bit(hlid, &wl->ap_ps_map);
4240 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
4241 wl12xx_free_link(wl, wlvif, &hlid);
4242 wl->active_sta_count--;
4243
4244 /*
4245 * rearm the tx watchdog when the last STA is freed - give the FW a
4246 * chance to return STA-buffered packets before complaining.
4247 */
4248 if (wl->active_sta_count == 0)
4249 wl12xx_rearm_tx_watchdog_locked(wl);
4250 }
4251
4252 static int wl12xx_sta_add(struct wl1271 *wl,
4253 struct wl12xx_vif *wlvif,
4254 struct ieee80211_sta *sta)
4255 {
4256 struct wl1271_station *wl_sta;
4257 int ret = 0;
4258 u8 hlid;
4259
4260 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
4261
4262 ret = wl1271_allocate_sta(wl, wlvif, sta);
4263 if (ret < 0)
4264 return ret;
4265
4266 wl_sta = (struct wl1271_station *)sta->drv_priv;
4267 hlid = wl_sta->hlid;
4268
4269 ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid);
4270 if (ret < 0)
4271 wl1271_free_sta(wl, wlvif, hlid);
4272
4273 return ret;
4274 }
4275
4276 static int wl12xx_sta_remove(struct wl1271 *wl,
4277 struct wl12xx_vif *wlvif,
4278 struct ieee80211_sta *sta)
4279 {
4280 struct wl1271_station *wl_sta;
4281 int ret = 0, id;
4282
4283 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
4284
4285 wl_sta = (struct wl1271_station *)sta->drv_priv;
4286 id = wl_sta->hlid;
4287 if (WARN_ON(!test_bit(id, wlvif->ap.sta_hlid_map)))
4288 return -EINVAL;
4289
4290 ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
4291 if (ret < 0)
4292 return ret;
4293
4294 wl1271_free_sta(wl, wlvif, wl_sta->hlid);
4295 return ret;
4296 }
4297
4298 static int wl12xx_update_sta_state(struct wl1271 *wl,
4299 struct wl12xx_vif *wlvif,
4300 struct ieee80211_sta *sta,
4301 enum ieee80211_sta_state old_state,
4302 enum ieee80211_sta_state new_state)
4303 {
4304 struct wl1271_station *wl_sta;
4305 u8 hlid;
4306 bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
4307 bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
4308 int ret;
4309
4310 wl_sta = (struct wl1271_station *)sta->drv_priv;
4311 hlid = wl_sta->hlid;
4312
4313 /* Add station (AP mode) */
4314 if (is_ap &&
4315 old_state == IEEE80211_STA_NOTEXIST &&
4316 new_state == IEEE80211_STA_NONE)
4317 return wl12xx_sta_add(wl, wlvif, sta);
4318
4319 /* Remove station (AP mode) */
4320 if (is_ap &&
4321 old_state == IEEE80211_STA_NONE &&
4322 new_state == IEEE80211_STA_NOTEXIST) {
4323 /* must not fail */
4324 wl12xx_sta_remove(wl, wlvif, sta);
4325 return 0;
4326 }
4327
4328 /* Authorize station (AP mode) */
4329 if (is_ap &&
4330 new_state == IEEE80211_STA_AUTHORIZED) {
4331 ret = wl12xx_cmd_set_peer_state(wl, hlid);
4332 if (ret < 0)
4333 return ret;
4334
4335 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true,
4336 hlid);
4337 return ret;
4338 }
4339
4340 /* Authorize station */
4341 if (is_sta &&
4342 new_state == IEEE80211_STA_AUTHORIZED) {
4343 set_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
4344 return wl12xx_set_authorized(wl, wlvif);
4345 }
4346
4347 if (is_sta &&
4348 old_state == IEEE80211_STA_AUTHORIZED &&
4349 new_state == IEEE80211_STA_ASSOC) {
4350 clear_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
4351 return 0;
4352 }
4353
4354 return 0;
4355 }
4356
4357 static int wl12xx_op_sta_state(struct ieee80211_hw *hw,
4358 struct ieee80211_vif *vif,
4359 struct ieee80211_sta *sta,
4360 enum ieee80211_sta_state old_state,
4361 enum ieee80211_sta_state new_state)
4362 {
4363 struct wl1271 *wl = hw->priv;
4364 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4365 int ret;
4366
4367 wl1271_debug(DEBUG_MAC80211, "mac80211 sta %d state=%d->%d",
4368 sta->aid, old_state, new_state);
4369
4370 mutex_lock(&wl->mutex);
4371
4372 if (unlikely(wl->state == WL1271_STATE_OFF)) {
4373 ret = -EBUSY;
4374 goto out;
4375 }
4376
4377 ret = wl1271_ps_elp_wakeup(wl);
4378 if (ret < 0)
4379 goto out;
4380
4381 ret = wl12xx_update_sta_state(wl, wlvif, sta, old_state, new_state);
4382
4383 wl1271_ps_elp_sleep(wl);
4384 out:
4385 mutex_unlock(&wl->mutex);
4386 if (new_state < old_state)
4387 return 0;
4388 return ret;
4389 }
4390
4391 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
4392 struct ieee80211_vif *vif,
4393 enum ieee80211_ampdu_mlme_action action,
4394 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4395 u8 buf_size)
4396 {
4397 struct wl1271 *wl = hw->priv;
4398 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4399 int ret;
4400 u8 hlid, *ba_bitmap;
4401
4402 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
4403 tid);
4404
4405 /* sanity check - the fields in FW are only 8bits wide */
4406 if (WARN_ON(tid > 0xFF))
4407 return -ENOTSUPP;
4408
4409 mutex_lock(&wl->mutex);
4410
4411 if (unlikely(wl->state == WL1271_STATE_OFF)) {
4412 ret = -EAGAIN;
4413 goto out;
4414 }
4415
4416 if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
4417 hlid = wlvif->sta.hlid;
4418 ba_bitmap = &wlvif->sta.ba_rx_bitmap;
4419 } else if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
4420 struct wl1271_station *wl_sta;
4421
4422 wl_sta = (struct wl1271_station *)sta->drv_priv;
4423 hlid = wl_sta->hlid;
4424 ba_bitmap = &wl->links[hlid].ba_bitmap;
4425 } else {
4426 ret = -EINVAL;
4427 goto out;
4428 }
4429
4430 ret = wl1271_ps_elp_wakeup(wl);
4431 if (ret < 0)
4432 goto out;
4433
4434 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
4435 tid, action);
4436
4437 switch (action) {
4438 case IEEE80211_AMPDU_RX_START:
4439 if (!wlvif->ba_support || !wlvif->ba_allowed) {
4440 ret = -ENOTSUPP;
4441 break;
4442 }
4443
4444 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
4445 ret = -EBUSY;
4446 wl1271_error("exceeded max RX BA sessions");
4447 break;
4448 }
4449
4450 if (*ba_bitmap & BIT(tid)) {
4451 ret = -EINVAL;
4452 wl1271_error("cannot enable RX BA session on active "
4453 "tid: %d", tid);
4454 break;
4455 }
4456
4457 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
4458 hlid);
4459 if (!ret) {
4460 *ba_bitmap |= BIT(tid);
4461 wl->ba_rx_session_count++;
4462 }
4463 break;
4464
4465 case IEEE80211_AMPDU_RX_STOP:
4466 if (!(*ba_bitmap & BIT(tid))) {
4467 ret = -EINVAL;
4468 wl1271_error("no active RX BA session on tid: %d",
4469 tid);
4470 break;
4471 }
4472
4473 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
4474 hlid);
4475 if (!ret) {
4476 *ba_bitmap &= ~BIT(tid);
4477 wl->ba_rx_session_count--;
4478 }
4479 break;
4480
4481 /*
4482 * The BA initiator session management in FW independently.
4483 * Falling break here on purpose for all TX APDU commands.
4484 */
4485 case IEEE80211_AMPDU_TX_START:
4486 case IEEE80211_AMPDU_TX_STOP:
4487 case IEEE80211_AMPDU_TX_OPERATIONAL:
4488 ret = -EINVAL;
4489 break;
4490
4491 default:
4492 wl1271_error("Incorrect ampdu action id=%x\n", action);
4493 ret = -EINVAL;
4494 }
4495
4496 wl1271_ps_elp_sleep(wl);
4497
4498 out:
4499 mutex_unlock(&wl->mutex);
4500
4501 return ret;
4502 }
4503
4504 static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
4505 struct ieee80211_vif *vif,
4506 const struct cfg80211_bitrate_mask *mask)
4507 {
4508 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4509 struct wl1271 *wl = hw->priv;
4510 int i, ret = 0;
4511
4512 wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x",
4513 mask->control[NL80211_BAND_2GHZ].legacy,
4514 mask->control[NL80211_BAND_5GHZ].legacy);
4515
4516 mutex_lock(&wl->mutex);
4517
4518 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
4519 wlvif->bitrate_masks[i] =
4520 wl1271_tx_enabled_rates_get(wl,
4521 mask->control[i].legacy,
4522 i);
4523
4524 if (unlikely(wl->state == WL1271_STATE_OFF))
4525 goto out;
4526
4527 if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
4528 !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
4529
4530 ret = wl1271_ps_elp_wakeup(wl);
4531 if (ret < 0)
4532 goto out;
4533
4534 wl1271_set_band_rate(wl, wlvif);
4535 wlvif->basic_rate =
4536 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
4537 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4538
4539 wl1271_ps_elp_sleep(wl);
4540 }
4541 out:
4542 mutex_unlock(&wl->mutex);
4543
4544 return ret;
4545 }
4546
4547 static void wl12xx_op_channel_switch(struct ieee80211_hw *hw,
4548 struct ieee80211_channel_switch *ch_switch)
4549 {
4550 struct wl1271 *wl = hw->priv;
4551 struct wl12xx_vif *wlvif;
4552 int ret;
4553
4554 wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch");
4555
4556 wl1271_tx_flush(wl);
4557
4558 mutex_lock(&wl->mutex);
4559
4560 if (unlikely(wl->state == WL1271_STATE_OFF)) {
4561 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4562 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
4563 ieee80211_chswitch_done(vif, false);
4564 }
4565 goto out;
4566 }
4567
4568 ret = wl1271_ps_elp_wakeup(wl);
4569 if (ret < 0)
4570 goto out;
4571
4572 /* TODO: change mac80211 to pass vif as param */
4573 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4574 ret = wl12xx_cmd_channel_switch(wl, wlvif, ch_switch);
4575
4576 if (!ret)
4577 set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);
4578 }
4579
4580 wl1271_ps_elp_sleep(wl);
4581
4582 out:
4583 mutex_unlock(&wl->mutex);
4584 }
4585
4586 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
4587 {
4588 struct wl1271 *wl = hw->priv;
4589 bool ret = false;
4590
4591 mutex_lock(&wl->mutex);
4592
4593 if (unlikely(wl->state == WL1271_STATE_OFF))
4594 goto out;
4595
4596 /* packets are considered pending if in the TX queue or the FW */
4597 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
4598 out:
4599 mutex_unlock(&wl->mutex);
4600
4601 return ret;
4602 }
4603
4604 /* can't be const, mac80211 writes to this */
4605 static struct ieee80211_rate wl1271_rates[] = {
4606 { .bitrate = 10,
4607 .hw_value = CONF_HW_BIT_RATE_1MBPS,
4608 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
4609 { .bitrate = 20,
4610 .hw_value = CONF_HW_BIT_RATE_2MBPS,
4611 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
4612 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4613 { .bitrate = 55,
4614 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
4615 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
4616 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4617 { .bitrate = 110,
4618 .hw_value = CONF_HW_BIT_RATE_11MBPS,
4619 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
4620 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4621 { .bitrate = 60,
4622 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4623 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4624 { .bitrate = 90,
4625 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4626 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4627 { .bitrate = 120,
4628 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4629 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4630 { .bitrate = 180,
4631 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4632 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4633 { .bitrate = 240,
4634 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4635 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4636 { .bitrate = 360,
4637 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4638 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4639 { .bitrate = 480,
4640 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4641 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4642 { .bitrate = 540,
4643 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4644 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4645 };
4646
4647 /* can't be const, mac80211 writes to this */
4648 static struct ieee80211_channel wl1271_channels[] = {
4649 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
4650 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
4651 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
4652 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
4653 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
4654 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
4655 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
4656 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
4657 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
4658 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
4659 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
4660 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
4661 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
4662 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
4663 };
4664
4665 /* mapping to indexes for wl1271_rates */
4666 static const u8 wl1271_rate_to_idx_2ghz[] = {
4667 /* MCS rates are used only with 11n */
4668 7, /* CONF_HW_RXTX_RATE_MCS7_SGI */
4669 7, /* CONF_HW_RXTX_RATE_MCS7 */
4670 6, /* CONF_HW_RXTX_RATE_MCS6 */
4671 5, /* CONF_HW_RXTX_RATE_MCS5 */
4672 4, /* CONF_HW_RXTX_RATE_MCS4 */
4673 3, /* CONF_HW_RXTX_RATE_MCS3 */
4674 2, /* CONF_HW_RXTX_RATE_MCS2 */
4675 1, /* CONF_HW_RXTX_RATE_MCS1 */
4676 0, /* CONF_HW_RXTX_RATE_MCS0 */
4677
4678 11, /* CONF_HW_RXTX_RATE_54 */
4679 10, /* CONF_HW_RXTX_RATE_48 */
4680 9, /* CONF_HW_RXTX_RATE_36 */
4681 8, /* CONF_HW_RXTX_RATE_24 */
4682
4683 /* TI-specific rate */
4684 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4685
4686 7, /* CONF_HW_RXTX_RATE_18 */
4687 6, /* CONF_HW_RXTX_RATE_12 */
4688 3, /* CONF_HW_RXTX_RATE_11 */
4689 5, /* CONF_HW_RXTX_RATE_9 */
4690 4, /* CONF_HW_RXTX_RATE_6 */
4691 2, /* CONF_HW_RXTX_RATE_5_5 */
4692 1, /* CONF_HW_RXTX_RATE_2 */
4693 0 /* CONF_HW_RXTX_RATE_1 */
4694 };
4695
4696 /* 11n STA capabilities */
4697 #define HW_RX_HIGHEST_RATE 72
4698
4699 #define WL12XX_HT_CAP { \
4700 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
4701 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
4702 .ht_supported = true, \
4703 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
4704 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
4705 .mcs = { \
4706 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
4707 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
4708 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
4709 }, \
4710 }
4711
4712 /* can't be const, mac80211 writes to this */
4713 static struct ieee80211_supported_band wl1271_band_2ghz = {
4714 .channels = wl1271_channels,
4715 .n_channels = ARRAY_SIZE(wl1271_channels),
4716 .bitrates = wl1271_rates,
4717 .n_bitrates = ARRAY_SIZE(wl1271_rates),
4718 .ht_cap = WL12XX_HT_CAP,
4719 };
4720
4721 /* 5 GHz data rates for WL1273 */
4722 static struct ieee80211_rate wl1271_rates_5ghz[] = {
4723 { .bitrate = 60,
4724 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4725 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4726 { .bitrate = 90,
4727 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4728 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4729 { .bitrate = 120,
4730 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4731 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4732 { .bitrate = 180,
4733 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4734 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4735 { .bitrate = 240,
4736 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4737 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4738 { .bitrate = 360,
4739 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4740 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4741 { .bitrate = 480,
4742 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4743 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4744 { .bitrate = 540,
4745 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4746 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4747 };
4748
4749 /* 5 GHz band channels for WL1273 */
4750 static struct ieee80211_channel wl1271_channels_5ghz[] = {
4751 { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
4752 { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
4753 { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
4754 { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
4755 { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
4756 { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
4757 { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
4758 { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
4759 { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
4760 { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
4761 { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
4762 { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
4763 { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
4764 { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
4765 { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
4766 { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
4767 { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
4768 { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
4769 { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
4770 { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
4771 { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
4772 { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
4773 { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
4774 { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
4775 { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
4776 { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
4777 { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
4778 { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
4779 { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
4780 { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
4781 { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
4782 { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
4783 { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
4784 { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
4785 };
4786
4787 /* mapping to indexes for wl1271_rates_5ghz */
4788 static const u8 wl1271_rate_to_idx_5ghz[] = {
4789 /* MCS rates are used only with 11n */
4790 7, /* CONF_HW_RXTX_RATE_MCS7_SGI */
4791 7, /* CONF_HW_RXTX_RATE_MCS7 */
4792 6, /* CONF_HW_RXTX_RATE_MCS6 */
4793 5, /* CONF_HW_RXTX_RATE_MCS5 */
4794 4, /* CONF_HW_RXTX_RATE_MCS4 */
4795 3, /* CONF_HW_RXTX_RATE_MCS3 */
4796 2, /* CONF_HW_RXTX_RATE_MCS2 */
4797 1, /* CONF_HW_RXTX_RATE_MCS1 */
4798 0, /* CONF_HW_RXTX_RATE_MCS0 */
4799
4800 7, /* CONF_HW_RXTX_RATE_54 */
4801 6, /* CONF_HW_RXTX_RATE_48 */
4802 5, /* CONF_HW_RXTX_RATE_36 */
4803 4, /* CONF_HW_RXTX_RATE_24 */
4804
4805 /* TI-specific rate */
4806 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4807
4808 3, /* CONF_HW_RXTX_RATE_18 */
4809 2, /* CONF_HW_RXTX_RATE_12 */
4810 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
4811 1, /* CONF_HW_RXTX_RATE_9 */
4812 0, /* CONF_HW_RXTX_RATE_6 */
4813 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
4814 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
4815 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
4816 };
4817
4818 static struct ieee80211_supported_band wl1271_band_5ghz = {
4819 .channels = wl1271_channels_5ghz,
4820 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4821 .bitrates = wl1271_rates_5ghz,
4822 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
4823 .ht_cap = WL12XX_HT_CAP,
4824 };
4825
4826 static const u8 *wl1271_band_rate_to_idx[] = {
4827 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
4828 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
4829 };
4830
4831 static const struct ieee80211_ops wl1271_ops = {
4832 .start = wl1271_op_start,
4833 .stop = wl1271_op_stop,
4834 .add_interface = wl1271_op_add_interface,
4835 .remove_interface = wl1271_op_remove_interface,
4836 .change_interface = wl12xx_op_change_interface,
4837 #ifdef CONFIG_PM
4838 .suspend = wl1271_op_suspend,
4839 .resume = wl1271_op_resume,
4840 #endif
4841 .config = wl1271_op_config,
4842 .prepare_multicast = wl1271_op_prepare_multicast,
4843 .configure_filter = wl1271_op_configure_filter,
4844 .tx = wl1271_op_tx,
4845 .set_key = wl1271_op_set_key,
4846 .hw_scan = wl1271_op_hw_scan,
4847 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
4848 .sched_scan_start = wl1271_op_sched_scan_start,
4849 .sched_scan_stop = wl1271_op_sched_scan_stop,
4850 .bss_info_changed = wl1271_op_bss_info_changed,
4851 .set_frag_threshold = wl1271_op_set_frag_threshold,
4852 .set_rts_threshold = wl1271_op_set_rts_threshold,
4853 .conf_tx = wl1271_op_conf_tx,
4854 .get_tsf = wl1271_op_get_tsf,
4855 .get_survey = wl1271_op_get_survey,
4856 .sta_state = wl12xx_op_sta_state,
4857 .ampdu_action = wl1271_op_ampdu_action,
4858 .tx_frames_pending = wl1271_tx_frames_pending,
4859 .set_bitrate_mask = wl12xx_set_bitrate_mask,
4860 .channel_switch = wl12xx_op_channel_switch,
4861 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
4862 };
4863
4864
4865 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
4866 {
4867 u8 idx;
4868
4869 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
4870
4871 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4872 wl1271_error("Illegal RX rate from HW: %d", rate);
4873 return 0;
4874 }
4875
4876 idx = wl1271_band_rate_to_idx[band][rate];
4877 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4878 wl1271_error("Unsupported RX rate from HW: %d", rate);
4879 return 0;
4880 }
4881
4882 return idx;
4883 }
4884
4885 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4886 struct device_attribute *attr,
4887 char *buf)
4888 {
4889 struct wl1271 *wl = dev_get_drvdata(dev);
4890 ssize_t len;
4891
4892 len = PAGE_SIZE;
4893
4894 mutex_lock(&wl->mutex);
4895 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4896 wl->sg_enabled);
4897 mutex_unlock(&wl->mutex);
4898
4899 return len;
4900
4901 }
4902
4903 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4904 struct device_attribute *attr,
4905 const char *buf, size_t count)
4906 {
4907 struct wl1271 *wl = dev_get_drvdata(dev);
4908 unsigned long res;
4909 int ret;
4910
4911 ret = kstrtoul(buf, 10, &res);
4912 if (ret < 0) {
4913 wl1271_warning("incorrect value written to bt_coex_mode");
4914 return count;
4915 }
4916
4917 mutex_lock(&wl->mutex);
4918
4919 res = !!res;
4920
4921 if (res == wl->sg_enabled)
4922 goto out;
4923
4924 wl->sg_enabled = res;
4925
4926 if (wl->state == WL1271_STATE_OFF)
4927 goto out;
4928
4929 ret = wl1271_ps_elp_wakeup(wl);
4930 if (ret < 0)
4931 goto out;
4932
4933 wl1271_acx_sg_enable(wl, wl->sg_enabled);
4934 wl1271_ps_elp_sleep(wl);
4935
4936 out:
4937 mutex_unlock(&wl->mutex);
4938 return count;
4939 }
4940
4941 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4942 wl1271_sysfs_show_bt_coex_state,
4943 wl1271_sysfs_store_bt_coex_state);
4944
4945 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4946 struct device_attribute *attr,
4947 char *buf)
4948 {
4949 struct wl1271 *wl = dev_get_drvdata(dev);
4950 ssize_t len;
4951
4952 len = PAGE_SIZE;
4953
4954 mutex_lock(&wl->mutex);
4955 if (wl->hw_pg_ver >= 0)
4956 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4957 else
4958 len = snprintf(buf, len, "n/a\n");
4959 mutex_unlock(&wl->mutex);
4960
4961 return len;
4962 }
4963
4964 static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
4965 wl1271_sysfs_show_hw_pg_ver, NULL);
4966
4967 static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4968 struct bin_attribute *bin_attr,
4969 char *buffer, loff_t pos, size_t count)
4970 {
4971 struct device *dev = container_of(kobj, struct device, kobj);
4972 struct wl1271 *wl = dev_get_drvdata(dev);
4973 ssize_t len;
4974 int ret;
4975
4976 ret = mutex_lock_interruptible(&wl->mutex);
4977 if (ret < 0)
4978 return -ERESTARTSYS;
4979
4980 /* Let only one thread read the log at a time, blocking others */
4981 while (wl->fwlog_size == 0) {
4982 DEFINE_WAIT(wait);
4983
4984 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4985 &wait,
4986 TASK_INTERRUPTIBLE);
4987
4988 if (wl->fwlog_size != 0) {
4989 finish_wait(&wl->fwlog_waitq, &wait);
4990 break;
4991 }
4992
4993 mutex_unlock(&wl->mutex);
4994
4995 schedule();
4996 finish_wait(&wl->fwlog_waitq, &wait);
4997
4998 if (signal_pending(current))
4999 return -ERESTARTSYS;
5000
5001 ret = mutex_lock_interruptible(&wl->mutex);
5002 if (ret < 0)
5003 return -ERESTARTSYS;
5004 }
5005
5006 /* Check if the fwlog is still valid */
5007 if (wl->fwlog_size < 0) {
5008 mutex_unlock(&wl->mutex);
5009 return 0;
5010 }
5011
5012 /* Seeking is not supported - old logs are not kept. Disregard pos. */
5013 len = min(count, (size_t)wl->fwlog_size);
5014 wl->fwlog_size -= len;
5015 memcpy(buffer, wl->fwlog, len);
5016
5017 /* Make room for new messages */
5018 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
5019
5020 mutex_unlock(&wl->mutex);
5021
5022 return len;
5023 }
5024
5025 static struct bin_attribute fwlog_attr = {
5026 .attr = {.name = "fwlog", .mode = S_IRUSR},
5027 .read = wl1271_sysfs_read_fwlog,
5028 };
5029
5030 static bool wl12xx_mac_in_fuse(struct wl1271 *wl)
5031 {
5032 bool supported = false;
5033 u8 major, minor;
5034
5035 if (wl->chip.id == CHIP_ID_1283_PG20) {
5036 major = WL128X_PG_GET_MAJOR(wl->hw_pg_ver);
5037 minor = WL128X_PG_GET_MINOR(wl->hw_pg_ver);
5038
5039 /* in wl128x we have the MAC address if the PG is >= (2, 1) */
5040 if (major > 2 || (major == 2 && minor >= 1))
5041 supported = true;
5042 } else {
5043 major = WL127X_PG_GET_MAJOR(wl->hw_pg_ver);
5044 minor = WL127X_PG_GET_MINOR(wl->hw_pg_ver);
5045
5046 /* in wl127x we have the MAC address if the PG is >= (3, 1) */
5047 if (major == 3 && minor >= 1)
5048 supported = true;
5049 }
5050
5051 wl1271_debug(DEBUG_PROBE,
5052 "PG Ver major = %d minor = %d, MAC %s present",
5053 major, minor, supported ? "is" : "is not");
5054
5055 return supported;
5056 }
5057
5058 static void wl12xx_derive_mac_addresses(struct wl1271 *wl,
5059 u32 oui, u32 nic, int n)
5060 {
5061 int i;
5062
5063 wl1271_debug(DEBUG_PROBE, "base address: oui %06x nic %06x, n %d",
5064 oui, nic, n);
5065
5066 if (nic + n - 1 > 0xffffff)
5067 wl1271_warning("NIC part of the MAC address wraps around!");
5068
5069 for (i = 0; i < n; i++) {
5070 wl->addresses[i].addr[0] = (u8)(oui >> 16);
5071 wl->addresses[i].addr[1] = (u8)(oui >> 8);
5072 wl->addresses[i].addr[2] = (u8) oui;
5073 wl->addresses[i].addr[3] = (u8)(nic >> 16);
5074 wl->addresses[i].addr[4] = (u8)(nic >> 8);
5075 wl->addresses[i].addr[5] = (u8) nic;
5076 nic++;
5077 }
5078
5079 wl->hw->wiphy->n_addresses = n;
5080 wl->hw->wiphy->addresses = wl->addresses;
5081 }
5082
5083 static void wl12xx_get_fuse_mac(struct wl1271 *wl)
5084 {
5085 u32 mac1, mac2;
5086
5087 wl1271_set_partition(wl, &wl12xx_part_table[PART_DRPW]);
5088
5089 mac1 = wl1271_read32(wl, WL12XX_REG_FUSE_BD_ADDR_1);
5090 mac2 = wl1271_read32(wl, WL12XX_REG_FUSE_BD_ADDR_2);
5091
5092 /* these are the two parts of the BD_ADDR */
5093 wl->fuse_oui_addr = ((mac2 & 0xffff) << 8) +
5094 ((mac1 & 0xff000000) >> 24);
5095 wl->fuse_nic_addr = mac1 & 0xffffff;
5096
5097 wl1271_set_partition(wl, &wl12xx_part_table[PART_DOWN]);
5098 }
5099
5100 static int wl12xx_get_hw_info(struct wl1271 *wl)
5101 {
5102 int ret;
5103 u32 die_info;
5104
5105 ret = wl12xx_set_power_on(wl);
5106 if (ret < 0)
5107 goto out;
5108
5109 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
5110
5111 if (wl->chip.id == CHIP_ID_1283_PG20)
5112 die_info = wl1271_top_reg_read(wl, WL128X_REG_FUSE_DATA_2_1);
5113 else
5114 die_info = wl1271_top_reg_read(wl, WL127X_REG_FUSE_DATA_2_1);
5115
5116 wl->hw_pg_ver = (s8) (die_info & PG_VER_MASK) >> PG_VER_OFFSET;
5117
5118 if (!wl12xx_mac_in_fuse(wl)) {
5119 wl->fuse_oui_addr = 0;
5120 wl->fuse_nic_addr = 0;
5121 } else {
5122 wl12xx_get_fuse_mac(wl);
5123 }
5124
5125 wl1271_power_off(wl);
5126 out:
5127 return ret;
5128 }
5129
5130 static int wl1271_register_hw(struct wl1271 *wl)
5131 {
5132 int ret;
5133 u32 oui_addr = 0, nic_addr = 0;
5134
5135 if (wl->mac80211_registered)
5136 return 0;
5137
5138 ret = wl12xx_get_hw_info(wl);
5139 if (ret < 0) {
5140 wl1271_error("couldn't get hw info");
5141 goto out;
5142 }
5143
5144 ret = wl1271_fetch_nvs(wl);
5145 if (ret == 0) {
5146 /* NOTE: The wl->nvs->nvs element must be first, in
5147 * order to simplify the casting, we assume it is at
5148 * the beginning of the wl->nvs structure.
5149 */
5150 u8 *nvs_ptr = (u8 *)wl->nvs;
5151
5152 oui_addr =
5153 (nvs_ptr[11] << 16) + (nvs_ptr[10] << 8) + nvs_ptr[6];
5154 nic_addr =
5155 (nvs_ptr[5] << 16) + (nvs_ptr[4] << 8) + nvs_ptr[3];
5156 }
5157
5158 /* if the MAC address is zeroed in the NVS derive from fuse */
5159 if (oui_addr == 0 && nic_addr == 0) {
5160 oui_addr = wl->fuse_oui_addr;
5161 /* fuse has the BD_ADDR, the WLAN addresses are the next two */
5162 nic_addr = wl->fuse_nic_addr + 1;
5163 }
5164
5165 wl12xx_derive_mac_addresses(wl, oui_addr, nic_addr, 2);
5166
5167 ret = ieee80211_register_hw(wl->hw);
5168 if (ret < 0) {
5169 wl1271_error("unable to register mac80211 hw: %d", ret);
5170 goto out;
5171 }
5172
5173 wl->mac80211_registered = true;
5174
5175 wl1271_debugfs_init(wl);
5176
5177 wl1271_notice("loaded");
5178
5179 out:
5180 return ret;
5181 }
5182
5183 static void wl1271_unregister_hw(struct wl1271 *wl)
5184 {
5185 if (wl->plt)
5186 wl1271_plt_stop(wl);
5187
5188 ieee80211_unregister_hw(wl->hw);
5189 wl->mac80211_registered = false;
5190
5191 }
5192
5193 static int wl1271_init_ieee80211(struct wl1271 *wl)
5194 {
5195 static const u32 cipher_suites[] = {
5196 WLAN_CIPHER_SUITE_WEP40,
5197 WLAN_CIPHER_SUITE_WEP104,
5198 WLAN_CIPHER_SUITE_TKIP,
5199 WLAN_CIPHER_SUITE_CCMP,
5200 WL1271_CIPHER_SUITE_GEM,
5201 };
5202
5203 /* The tx descriptor buffer and the TKIP space. */
5204 wl->hw->extra_tx_headroom = WL1271_EXTRA_SPACE_TKIP +
5205 sizeof(struct wl1271_tx_hw_descr);
5206
5207 /* unit us */
5208 /* FIXME: find a proper value */
5209 wl->hw->channel_change_time = 10000;
5210 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
5211
5212 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
5213 IEEE80211_HW_SUPPORTS_PS |
5214 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
5215 IEEE80211_HW_SUPPORTS_UAPSD |
5216 IEEE80211_HW_HAS_RATE_CONTROL |
5217 IEEE80211_HW_CONNECTION_MONITOR |
5218 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
5219 IEEE80211_HW_SPECTRUM_MGMT |
5220 IEEE80211_HW_AP_LINK_PS |
5221 IEEE80211_HW_AMPDU_AGGREGATION |
5222 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW |
5223 IEEE80211_HW_SCAN_WHILE_IDLE;
5224
5225 wl->hw->wiphy->cipher_suites = cipher_suites;
5226 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
5227
5228 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
5229 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP) |
5230 BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO);
5231 wl->hw->wiphy->max_scan_ssids = 1;
5232 wl->hw->wiphy->max_sched_scan_ssids = 16;
5233 wl->hw->wiphy->max_match_sets = 16;
5234 /*
5235 * Maximum length of elements in scanning probe request templates
5236 * should be the maximum length possible for a template, without
5237 * the IEEE80211 header of the template
5238 */
5239 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
5240 sizeof(struct ieee80211_header);
5241
5242 wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
5243 sizeof(struct ieee80211_header);
5244
5245 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD |
5246 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
5247
5248 /* make sure all our channels fit in the scanned_ch bitmask */
5249 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
5250 ARRAY_SIZE(wl1271_channels_5ghz) >
5251 WL1271_MAX_CHANNELS);
5252 /*
5253 * We keep local copies of the band structs because we need to
5254 * modify them on a per-device basis.
5255 */
5256 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
5257 sizeof(wl1271_band_2ghz));
5258 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
5259 sizeof(wl1271_band_5ghz));
5260
5261 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
5262 &wl->bands[IEEE80211_BAND_2GHZ];
5263 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
5264 &wl->bands[IEEE80211_BAND_5GHZ];
5265
5266 wl->hw->queues = 4;
5267 wl->hw->max_rates = 1;
5268
5269 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
5270
5271 /* the FW answers probe-requests in AP-mode */
5272 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
5273 wl->hw->wiphy->probe_resp_offload =
5274 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
5275 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
5276 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
5277
5278 SET_IEEE80211_DEV(wl->hw, wl->dev);
5279
5280 wl->hw->sta_data_size = sizeof(struct wl1271_station);
5281 wl->hw->vif_data_size = sizeof(struct wl12xx_vif);
5282
5283 wl->hw->max_rx_aggregation_subframes = 8;
5284
5285 return 0;
5286 }
5287
5288 #define WL1271_DEFAULT_CHANNEL 0
5289
5290 static struct ieee80211_hw *wl1271_alloc_hw(void)
5291 {
5292 struct ieee80211_hw *hw;
5293 struct wl1271 *wl;
5294 int i, j, ret;
5295 unsigned int order;
5296
5297 BUILD_BUG_ON(AP_MAX_STATIONS > WL12XX_MAX_LINKS);
5298
5299 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
5300 if (!hw) {
5301 wl1271_error("could not alloc ieee80211_hw");
5302 ret = -ENOMEM;
5303 goto err_hw_alloc;
5304 }
5305
5306 wl = hw->priv;
5307 memset(wl, 0, sizeof(*wl));
5308
5309 INIT_LIST_HEAD(&wl->wlvif_list);
5310
5311 wl->hw = hw;
5312
5313 for (i = 0; i < NUM_TX_QUEUES; i++)
5314 for (j = 0; j < WL12XX_MAX_LINKS; j++)
5315 skb_queue_head_init(&wl->links[j].tx_queue[i]);
5316
5317 skb_queue_head_init(&wl->deferred_rx_queue);
5318 skb_queue_head_init(&wl->deferred_tx_queue);
5319
5320 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
5321 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
5322 INIT_WORK(&wl->tx_work, wl1271_tx_work);
5323 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
5324 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
5325 INIT_DELAYED_WORK(&wl->tx_watchdog_work, wl12xx_tx_watchdog_work);
5326
5327 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
5328 if (!wl->freezable_wq) {
5329 ret = -ENOMEM;
5330 goto err_hw;
5331 }
5332
5333 wl->channel = WL1271_DEFAULT_CHANNEL;
5334 wl->rx_counter = 0;
5335 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
5336 wl->band = IEEE80211_BAND_2GHZ;
5337 wl->flags = 0;
5338 wl->sg_enabled = true;
5339 wl->hw_pg_ver = -1;
5340 wl->ap_ps_map = 0;
5341 wl->ap_fw_ps_map = 0;
5342 wl->quirks = 0;
5343 wl->platform_quirks = 0;
5344 wl->sched_scanning = false;
5345 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
5346 wl->system_hlid = WL12XX_SYSTEM_HLID;
5347 wl->active_sta_count = 0;
5348 wl->fwlog_size = 0;
5349 init_waitqueue_head(&wl->fwlog_waitq);
5350
5351 /* The system link is always allocated */
5352 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
5353
5354 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
5355 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
5356 wl->tx_frames[i] = NULL;
5357
5358 spin_lock_init(&wl->wl_lock);
5359
5360 wl->state = WL1271_STATE_OFF;
5361 wl->fw_type = WL12XX_FW_TYPE_NONE;
5362 mutex_init(&wl->mutex);
5363
5364 /* Apply default driver configuration. */
5365 wl1271_conf_init(wl);
5366
5367 order = get_order(WL1271_AGGR_BUFFER_SIZE);
5368 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
5369 if (!wl->aggr_buf) {
5370 ret = -ENOMEM;
5371 goto err_wq;
5372 }
5373
5374 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
5375 if (!wl->dummy_packet) {
5376 ret = -ENOMEM;
5377 goto err_aggr;
5378 }
5379
5380 /* Allocate one page for the FW log */
5381 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
5382 if (!wl->fwlog) {
5383 ret = -ENOMEM;
5384 goto err_dummy_packet;
5385 }
5386
5387 return hw;
5388
5389 err_dummy_packet:
5390 dev_kfree_skb(wl->dummy_packet);
5391
5392 err_aggr:
5393 free_pages((unsigned long)wl->aggr_buf, order);
5394
5395 err_wq:
5396 destroy_workqueue(wl->freezable_wq);
5397
5398 err_hw:
5399 wl1271_debugfs_exit(wl);
5400 ieee80211_free_hw(hw);
5401
5402 err_hw_alloc:
5403
5404 return ERR_PTR(ret);
5405 }
5406
5407 static int wl1271_free_hw(struct wl1271 *wl)
5408 {
5409 /* Unblock any fwlog readers */
5410 mutex_lock(&wl->mutex);
5411 wl->fwlog_size = -1;
5412 wake_up_interruptible_all(&wl->fwlog_waitq);
5413 mutex_unlock(&wl->mutex);
5414
5415 device_remove_bin_file(wl->dev, &fwlog_attr);
5416
5417 device_remove_file(wl->dev, &dev_attr_hw_pg_ver);
5418
5419 device_remove_file(wl->dev, &dev_attr_bt_coex_state);
5420 free_page((unsigned long)wl->fwlog);
5421 dev_kfree_skb(wl->dummy_packet);
5422 free_pages((unsigned long)wl->aggr_buf,
5423 get_order(WL1271_AGGR_BUFFER_SIZE));
5424
5425 wl1271_debugfs_exit(wl);
5426
5427 vfree(wl->fw);
5428 wl->fw = NULL;
5429 wl->fw_type = WL12XX_FW_TYPE_NONE;
5430 kfree(wl->nvs);
5431 wl->nvs = NULL;
5432
5433 kfree(wl->fw_status);
5434 kfree(wl->tx_res_if);
5435 destroy_workqueue(wl->freezable_wq);
5436
5437 ieee80211_free_hw(wl->hw);
5438
5439 return 0;
5440 }
5441
5442 static irqreturn_t wl12xx_hardirq(int irq, void *cookie)
5443 {
5444 struct wl1271 *wl = cookie;
5445 unsigned long flags;
5446
5447 wl1271_debug(DEBUG_IRQ, "IRQ");
5448
5449 /* complete the ELP completion */
5450 spin_lock_irqsave(&wl->wl_lock, flags);
5451 set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
5452 if (wl->elp_compl) {
5453 complete(wl->elp_compl);
5454 wl->elp_compl = NULL;
5455 }
5456
5457 if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {
5458 /* don't enqueue a work right now. mark it as pending */
5459 set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);
5460 wl1271_debug(DEBUG_IRQ, "should not enqueue work");
5461 disable_irq_nosync(wl->irq);
5462 pm_wakeup_event(wl->dev, 0);
5463 spin_unlock_irqrestore(&wl->wl_lock, flags);
5464 return IRQ_HANDLED;
5465 }
5466 spin_unlock_irqrestore(&wl->wl_lock, flags);
5467
5468 return IRQ_WAKE_THREAD;
5469 }
5470
5471 static int __devinit wl12xx_probe(struct platform_device *pdev)
5472 {
5473 struct wl12xx_platform_data *pdata = pdev->dev.platform_data;
5474 struct ieee80211_hw *hw;
5475 struct wl1271 *wl;
5476 unsigned long irqflags;
5477 int ret = -ENODEV;
5478
5479 hw = wl1271_alloc_hw();
5480 if (IS_ERR(hw)) {
5481 wl1271_error("can't allocate hw");
5482 ret = PTR_ERR(hw);
5483 goto out;
5484 }
5485
5486 wl = hw->priv;
5487 wl->irq = platform_get_irq(pdev, 0);
5488 wl->ref_clock = pdata->board_ref_clock;
5489 wl->tcxo_clock = pdata->board_tcxo_clock;
5490 wl->platform_quirks = pdata->platform_quirks;
5491 wl->set_power = pdata->set_power;
5492 wl->dev = &pdev->dev;
5493 wl->if_ops = pdata->ops;
5494
5495 platform_set_drvdata(pdev, wl);
5496
5497 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
5498 irqflags = IRQF_TRIGGER_RISING;
5499 else
5500 irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;
5501
5502 ret = request_threaded_irq(wl->irq, wl12xx_hardirq, wl1271_irq,
5503 irqflags,
5504 pdev->name, wl);
5505 if (ret < 0) {
5506 wl1271_error("request_irq() failed: %d", ret);
5507 goto out_free_hw;
5508 }
5509
5510 ret = enable_irq_wake(wl->irq);
5511 if (!ret) {
5512 wl->irq_wake_enabled = true;
5513 device_init_wakeup(wl->dev, 1);
5514 if (pdata->pwr_in_suspend)
5515 hw->wiphy->wowlan.flags = WIPHY_WOWLAN_ANY;
5516
5517 }
5518 disable_irq(wl->irq);
5519
5520 ret = wl1271_init_ieee80211(wl);
5521 if (ret)
5522 goto out_irq;
5523
5524 ret = wl1271_register_hw(wl);
5525 if (ret)
5526 goto out_irq;
5527
5528 /* Create sysfs file to control bt coex state */
5529 ret = device_create_file(wl->dev, &dev_attr_bt_coex_state);
5530 if (ret < 0) {
5531 wl1271_error("failed to create sysfs file bt_coex_state");
5532 goto out_irq;
5533 }
5534
5535 /* Create sysfs file to get HW PG version */
5536 ret = device_create_file(wl->dev, &dev_attr_hw_pg_ver);
5537 if (ret < 0) {
5538 wl1271_error("failed to create sysfs file hw_pg_ver");
5539 goto out_bt_coex_state;
5540 }
5541
5542 /* Create sysfs file for the FW log */
5543 ret = device_create_bin_file(wl->dev, &fwlog_attr);
5544 if (ret < 0) {
5545 wl1271_error("failed to create sysfs file fwlog");
5546 goto out_hw_pg_ver;
5547 }
5548
5549 return 0;
5550
5551 out_hw_pg_ver:
5552 device_remove_file(wl->dev, &dev_attr_hw_pg_ver);
5553
5554 out_bt_coex_state:
5555 device_remove_file(wl->dev, &dev_attr_bt_coex_state);
5556
5557 out_irq:
5558 free_irq(wl->irq, wl);
5559
5560 out_free_hw:
5561 wl1271_free_hw(wl);
5562
5563 out:
5564 return ret;
5565 }
5566
5567 static int __devexit wl12xx_remove(struct platform_device *pdev)
5568 {
5569 struct wl1271 *wl = platform_get_drvdata(pdev);
5570
5571 if (wl->irq_wake_enabled) {
5572 device_init_wakeup(wl->dev, 0);
5573 disable_irq_wake(wl->irq);
5574 }
5575 wl1271_unregister_hw(wl);
5576 free_irq(wl->irq, wl);
5577 wl1271_free_hw(wl);
5578
5579 return 0;
5580 }
5581
5582 static const struct platform_device_id wl12xx_id_table[] __devinitconst = {
5583 { "wl12xx", 0 },
5584 { } /* Terminating Entry */
5585 };
5586 MODULE_DEVICE_TABLE(platform, wl12xx_id_table);
5587
5588 static struct platform_driver wl12xx_driver = {
5589 .probe = wl12xx_probe,
5590 .remove = __devexit_p(wl12xx_remove),
5591 .id_table = wl12xx_id_table,
5592 .driver = {
5593 .name = "wl12xx_driver",
5594 .owner = THIS_MODULE,
5595 }
5596 };
5597
5598 static int __init wl12xx_init(void)
5599 {
5600 return platform_driver_register(&wl12xx_driver);
5601 }
5602 module_init(wl12xx_init);
5603
5604 static void __exit wl12xx_exit(void)
5605 {
5606 platform_driver_unregister(&wl12xx_driver);
5607 }
5608 module_exit(wl12xx_exit);
5609
5610 u32 wl12xx_debug_level = DEBUG_NONE;
5611 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
5612 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
5613 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
5614
5615 module_param_named(fwlog, fwlog_param, charp, 0);
5616 MODULE_PARM_DESC(fwlog,
5617 "FW logger options: continuous, ondemand, dbgpins or disable");
5618
5619 module_param(bug_on_recovery, bool, S_IRUSR | S_IWUSR);
5620 MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
5621
5622 MODULE_LICENSE("GPL");
5623 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
5624 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux kernel - Deliverables
This page took 0.163974 seconds and 5 git commands to generate.