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