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