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