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