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