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