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