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