projects / deliverable / linux.git / blob
? search:


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