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