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