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