projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx: Unset bssid filter, ssid and bssid from firmware on disassoc
[deliverable/linux.git] / drivers / net / wireless / wl12xx / main.c
CommitLineData
f5fc0f86
LC		 1/*
2 * This file is part of wl1271
3 *
8bf29b0e 4 * Copyright (C) 2008-2010 Nokia Corporation
f5fc0f86
LC		 5 *
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 *
22 */
23
24#include <linux/module.h>
f5fc0f86
LC		 25#include <linux/firmware.h>
26#include <linux/delay.h>
f5fc0f86
LC		 27#include <linux/spi/spi.h>
28#include <linux/crc32.h>
29#include <linux/etherdevice.h>
1fba4974 30#include <linux/vmalloc.h>
a1dd8187 31#include <linux/platform_device.h>
5a0e3ad6 32#include <linux/slab.h>
f5fc0f86 33
00d20100 34#include "wl12xx.h"
f5fc0f86 35#include "wl12xx_80211.h"
00d20100
SL		 36#include "reg.h"
37#include "io.h"
38#include "event.h"
39#include "tx.h"
40#include "rx.h"
41#include "ps.h"
42#include "init.h"
43#include "debugfs.h"
44#include "cmd.h"
45#include "boot.h"
46#include "testmode.h"
47#include "scan.h"
f5fc0f86 48
9ccd9217
JO		 49#define WL1271_BOOT_RETRIES 3
50
8a08048a
JO		 51static struct conf_drv_settings default_conf = {
52 .sg = {
1b00f546
JO		 53 .params = {
54 [CONF_SG_BT_PER_THRESHOLD] = 7500,
55 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
56 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
57 [CONF_SG_BT_LOAD_RATIO] = 50,
8d2ef7bd 58 [CONF_SG_AUTO_PS_MODE] = 1,
1b00f546
JO		 59 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
60 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
61 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
62 [CONF_SG_BEACON_MISS_PERCENT] = 60,
63 [CONF_SG_RATE_ADAPT_THRESH] = 12,
64 [CONF_SG_RATE_ADAPT_SNR] = 0,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
67 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
70 /* Note: with UPSD, this should be 4 */
71 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
74 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
75 /* Note: with UPDS, this should be 15 */
76 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
77 /* Note: with UPDS, this should be 50 */
78 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
79 /* Note: with UPDS, this should be 10 */
80 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
81 [CONF_SG_RXT] = 1200,
82 [CONF_SG_TXT] = 1000,
83 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
84 [CONF_SG_PS_POLL_TIMEOUT] = 10,
85 [CONF_SG_UPSD_TIMEOUT] = 10,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
91 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
94 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
97 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
98 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
99 [CONF_SG_HV3_MAX_SERVED] = 6,
100 [CONF_SG_DHCP_TIME] = 5000,
101 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
102 },
103 .state = CONF_SG_PROTECTIVE,
8a08048a
JO		 104 },
105 .rx = {
106 .rx_msdu_life_time = 512000,
107 .packet_detection_threshold = 0,
108 .ps_poll_timeout = 15,
109 .upsd_timeout = 15,
110 .rts_threshold = 2347,
3ed8f2c6
LC		 111 .rx_cca_threshold = 0,
112 .irq_blk_threshold = 0xFFFF,
113 .irq_pkt_threshold = 0,
114 .irq_timeout = 600,
8a08048a
JO		 115 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
116 },
117 .tx = {
118 .tx_energy_detection = 0,
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 */
68d069c4 428 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
12419cce
LC		 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
68d069c4
AN		 1748static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
1749{
1750 struct wl1271 *wl = hw->priv;
1751 int ret = 0;
1752
1753 mutex_lock(&wl->mutex);
1754
1755 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1756 ret = -EAGAIN;
1757 goto out;
1758 }
1759
1760 ret = wl1271_ps_elp_wakeup(wl, false);
1761 if (ret < 0)
1762 goto out;
1763
1764 ret = wl1271_acx_frag_threshold(wl, (u16)value);
1765 if (ret < 0)
1766 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
1767
1768 wl1271_ps_elp_sleep(wl);
1769
1770out:
1771 mutex_unlock(&wl->mutex);
1772
1773 return ret;
1774}
1775
f5fc0f86
LC		 1776static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1777{
1778 struct wl1271 *wl = hw->priv;
aecb0565 1779 int ret = 0;
f5fc0f86
LC		 1780
1781 mutex_lock(&wl->mutex);
1782
f8d9802f
JO		 1783 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1784 ret = -EAGAIN;
aecb0565 1785 goto out;
f8d9802f 1786 }
aecb0565 1787
f5fc0f86
LC		 1788 ret = wl1271_ps_elp_wakeup(wl, false);
1789 if (ret < 0)
1790 goto out;
1791
1792 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1793 if (ret < 0)
1794 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1795
1796 wl1271_ps_elp_sleep(wl);
1797
1798out:
1799 mutex_unlock(&wl->mutex);
1800
1801 return ret;
1802}
1803
30240fc7
JO		 1804static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1805{
1806 u8 *ptr = beacon->data +
1807 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1808
1809 /* find the location of the ssid in the beacon */
1810 while (ptr < beacon->data + beacon->len) {
1811 if (ptr[0] == WLAN_EID_SSID) {
1812 wl->ssid_len = ptr[1];
1813 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1814 return;
1815 }
1816 ptr += ptr[1];
1817 }
1818 wl1271_error("ad-hoc beacon template has no SSID!\n");
1819}
1820
f5fc0f86
LC		 1821static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1822 struct ieee80211_vif *vif,
1823 struct ieee80211_bss_conf *bss_conf,
1824 u32 changed)
1825{
1826 enum wl1271_cmd_ps_mode mode;
1827 struct wl1271 *wl = hw->priv;
18357850 1828 struct ieee80211_sta *sta = ieee80211_find_sta(vif, bss_conf->bssid);
8bf29b0e 1829 bool do_join = false;
69e5434c 1830 bool set_assoc = false;
f5fc0f86
LC		 1831 int ret;
1832
1833 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1834
1835 mutex_lock(&wl->mutex);
1836
f8d9802f
JO		 1837 if (unlikely(wl->state == WL1271_STATE_OFF))
1838 goto out;
1839
f5fc0f86
LC		 1840 ret = wl1271_ps_elp_wakeup(wl, false);
1841 if (ret < 0)
1842 goto out;
1843
9ee82d54 1844 if ((changed & BSS_CHANGED_BEACON_INT) &&
60e84c2e
JO		 1845 (wl->bss_type == BSS_TYPE_IBSS)) {
1846 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1847 bss_conf->beacon_int);
1848
1849 wl->beacon_int = bss_conf->beacon_int;
1850 do_join = true;
1851 }
1852
9ee82d54 1853 if ((changed & BSS_CHANGED_BEACON) &&
5da11dcd 1854 (wl->bss_type == BSS_TYPE_IBSS)) {
e0d8bbf0
JO		 1855 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1856
5da11dcd
JO		 1857 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1858
e0d8bbf0
JO		 1859 if (beacon) {
1860 struct ieee80211_hdr *hdr;
30240fc7
JO		 1861
1862 wl1271_ssid_set(wl, beacon);
e0d8bbf0
JO		 1863 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1864 beacon->data,
606c1487
JO		 1865 beacon->len, 0,
1866 wl1271_min_rate_get(wl));
e0d8bbf0
JO		 1867
1868 if (ret < 0) {
1869 dev_kfree_skb(beacon);
1870 goto out_sleep;
1871 }
1872
1873 hdr = (struct ieee80211_hdr *) beacon->data;
1874 hdr->frame_control = cpu_to_le16(
1875 IEEE80211_FTYPE_MGMT |
1876 IEEE80211_STYPE_PROBE_RESP);
1877
1878 ret = wl1271_cmd_template_set(wl,
1879 CMD_TEMPL_PROBE_RESPONSE,
1880 beacon->data,
606c1487
JO		 1881 beacon->len, 0,
1882 wl1271_min_rate_get(wl));
e0d8bbf0
JO		 1883 dev_kfree_skb(beacon);
1884 if (ret < 0)
1885 goto out_sleep;
8bf29b0e
JO		 1886
1887 /* Need to update the SSID (for filtering etc) */
1888 do_join = true;
e0d8bbf0
JO		 1889 }
1890 }
1891
5da11dcd
JO		 1892 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1893 (wl->bss_type == BSS_TYPE_IBSS)) {
1894 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1895 bss_conf->enable_beacon ? "enabled" : "disabled");
1896
1897 if (bss_conf->enable_beacon)
1898 wl->set_bss_type = BSS_TYPE_IBSS;
1899 else
1900 wl->set_bss_type = BSS_TYPE_STA_BSS;
1901 do_join = true;
1902 }
1903
00236aed
JO		 1904 if (changed & BSS_CHANGED_CQM) {
1905 bool enable = false;
1906 if (bss_conf->cqm_rssi_thold)
1907 enable = true;
1908 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1909 bss_conf->cqm_rssi_thold,
1910 bss_conf->cqm_rssi_hyst);
1911 if (ret < 0)
1912 goto out;
1913 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1914 }
1915
30240fc7
JO		 1916 if ((changed & BSS_CHANGED_BSSID) &&
1917 /*
1918 * Now we know the correct bssid, so we send a new join command
1919 * and enable the BSSID filter
1920 */
1921 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
30240fc7 1922 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 1923
30240fc7 1924 ret = wl1271_cmd_build_null_data(wl);
a0cb7be4 1925 if (ret < 0)
30240fc7 1926 goto out_sleep;
30240fc7 1927
141418c7 1928 ret = wl1271_build_qos_null_data(wl);
a0cb7be4 1929 if (ret < 0)
30240fc7 1930 goto out_sleep;
30240fc7 1931
14b228a0
JO		 1932 /* filter out all packets not from this BSSID */
1933 wl1271_configure_filters(wl, 0);
1934
8bf29b0e
JO		 1935 /* Need to update the BSSID (for filtering etc) */
1936 do_join = true;
30240fc7
JO		 1937 }
1938
f5fc0f86
LC		 1939 if (changed & BSS_CHANGED_ASSOC) {
1940 if (bss_conf->assoc) {
ebba60c6 1941 u32 rates;
f5fc0f86 1942 wl->aid = bss_conf->aid;
69e5434c 1943 set_assoc = true;
f5fc0f86 1944
90494a90
JO		 1945 wl->ps_poll_failures = 0;
1946
ebba60c6
JO		 1947 /*
1948 * use basic rates from AP, and determine lowest rate
1949 * to use with control frames.
1950 */
1951 rates = bss_conf->basic_rates;
1952 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1953 rates);
1954 wl->basic_rate = wl1271_min_rate_get(wl);
1955 ret = wl1271_acx_rate_policies(wl);
1956 if (ret < 0)
1957 goto out_sleep;
1958
ae751bab
LC		 1959 /*
1960 * with wl1271, we don't need to update the
1961 * beacon_int and dtim_period, because the firmware
1962 * updates it by itself when the first beacon is
1963 * received after a join.
1964 */
f5fc0f86
LC		 1965 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1966 if (ret < 0)
1967 goto out_sleep;
1968
c2b2d99b
JO		 1969 /*
1970 * The SSID is intentionally set to NULL here - the
1971 * firmware will set the probe request with a
1972 * broadcast SSID regardless of what we set in the
1973 * template.
1974 */
1975 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1976 NULL, 0, wl->band);
1977
6ccbb92e
JO		 1978 /* enable the connection monitoring feature */
1979 ret = wl1271_acx_conn_monit_params(wl, true);
f5fc0f86
LC		 1980 if (ret < 0)
1981 goto out_sleep;
1982
1983 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 1984 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1985 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
f5fc0f86 1986 mode = STATION_POWER_SAVE_MODE;
65cddbf1 1987 ret = wl1271_ps_set_mode(wl, mode,
8eab7b47 1988 wl->basic_rate,
65cddbf1 1989 true);
f5fc0f86
LC		 1990 if (ret < 0)
1991 goto out_sleep;
1992 }
d94cd297
JO		 1993 } else {
1994 /* use defaults when not associated */
c2c192ac 1995 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
830fb67b 1996 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
d94cd297 1997 wl->aid = 0;
6ccbb92e 1998
8d2ef7bd 1999 /* re-enable dynamic ps - just in case */
f532be6d 2000 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 2001
ebba60c6
JO		 2002 /* revert back to minimum rates for the current band */
2003 wl1271_set_band_rate(wl);
2004 wl->basic_rate = wl1271_min_rate_get(wl);
2005 ret = wl1271_acx_rate_policies(wl);
2006 if (ret < 0)
2007 goto out_sleep;
2008
6ccbb92e
JO		 2009 /* disable connection monitor features */
2010 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 2011
2012 /* Disable the keep-alive feature */
2013 ret = wl1271_acx_keep_alive_mode(wl, false);
6ccbb92e
JO		 2014 if (ret < 0)
2015 goto out_sleep;
b84a7d3d
JO		 2016
2017 /* restore the bssid filter and go to dummy bssid */
2018 wl1271_unjoin(wl);
2019 wl1271_dummy_join(wl);
f5fc0f86 2020 }
d94cd297 2021
f5fc0f86 2022 }
8a5a37a6 2023
f5fc0f86
LC		 2024 if (changed & BSS_CHANGED_ERP_SLOT) {
2025 if (bss_conf->use_short_slot)
2026 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2027 else
2028 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2029 if (ret < 0) {
2030 wl1271_warning("Set slot time failed %d", ret);
2031 goto out_sleep;
2032 }
2033 }
2034
2035 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2036 if (bss_conf->use_short_preamble)
2037 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2038 else
2039 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2040 }
2041
2042 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2043 if (bss_conf->use_cts_prot)
2044 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2045 else
2046 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2047 if (ret < 0) {
2048 wl1271_warning("Set ctsprotect failed %d", ret);
2049 goto out_sleep;
2050 }
2051 }
2052
18357850
SL		 2053 /*
2054 * Takes care of: New association with HT enable,
2055 * HT information change in beacon.
2056 */
2057 if (sta &&
2058 (changed & BSS_CHANGED_HT) &&
2059 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2060 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true);
2061 if (ret < 0) {
2062 wl1271_warning("Set ht cap true failed %d", ret);
2063 goto out_sleep;
2064 }
2065 ret = wl1271_acx_set_ht_information(wl,
2066 bss_conf->ht_operation_mode);
2067 if (ret < 0) {
2068 wl1271_warning("Set ht information failed %d", ret);
2069 goto out_sleep;
2070 }
2071 }
2072 /*
2073 * Takes care of: New association without HT,
2074 * Disassociation.
2075 */
2076 else if (sta && (changed & BSS_CHANGED_ASSOC)) {
2077 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, false);
2078 if (ret < 0) {
2079 wl1271_warning("Set ht cap false failed %d", ret);
2080 goto out_sleep;
2081 }
2082 }
2083
ca52a5eb
JO		 2084 if (changed & BSS_CHANGED_ARP_FILTER) {
2085 __be32 addr = bss_conf->arp_addr_list[0];
2086 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2087
2088 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
2089 ret = wl1271_acx_arp_ip_filter(wl, true, addr);
2090 else
2091 ret = wl1271_acx_arp_ip_filter(wl, false, addr);
2092
2093 if (ret < 0)
2094 goto out_sleep;
2095 }
2096
8bf29b0e 2097 if (do_join) {
69e5434c 2098 ret = wl1271_join(wl, set_assoc);
8bf29b0e
JO		 2099 if (ret < 0) {
2100 wl1271_warning("cmd join failed %d", ret);
2101 goto out_sleep;
2102 }
c1899554
JO		 2103 }
2104
f5fc0f86
LC		 2105out_sleep:
2106 wl1271_ps_elp_sleep(wl);
2107
2108out:
2109 mutex_unlock(&wl->mutex);
2110}
2111
c6999d83
KV		 2112static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2113 const struct ieee80211_tx_queue_params *params)
2114{
2115 struct wl1271 *wl = hw->priv;
4695dc91 2116 u8 ps_scheme;
c6999d83
KV		 2117 int ret;
2118
2119 mutex_lock(&wl->mutex);
2120
2121 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2122
f8d9802f
JO		 2123 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2124 ret = -EAGAIN;
2125 goto out;
2126 }
2127
c82c1dde
KV		 2128 ret = wl1271_ps_elp_wakeup(wl, false);
2129 if (ret < 0)
2130 goto out;
2131
b43316db 2132 /* the txop is confed in units of 32us by the mac80211, we need us */
c6999d83
KV		 2133 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
2134 params->cw_min, params->cw_max,
b43316db 2135 params->aifs, params->txop << 5);
c6999d83 2136 if (ret < 0)
c82c1dde 2137 goto out_sleep;
c6999d83 2138
4695dc91
KV		 2139 if (params->uapsd)
2140 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2141 else
2142 ps_scheme = CONF_PS_SCHEME_LEGACY;
2143
c6999d83
KV		 2144 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
2145 CONF_CHANNEL_TYPE_EDCF,
2146 wl1271_tx_get_queue(queue),
4695dc91 2147 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
c6999d83 2148 if (ret < 0)
c82c1dde
KV		 2149 goto out_sleep;
2150
2151out_sleep:
2152 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 2153
2154out:
2155 mutex_unlock(&wl->mutex);
2156
2157 return ret;
2158}
2159
bbbb538e
JO		 2160static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2161{
2162
2163 struct wl1271 *wl = hw->priv;
2164 u64 mactime = ULLONG_MAX;
2165 int ret;
2166
2167 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2168
2169 mutex_lock(&wl->mutex);
2170
f8d9802f
JO		 2171 if (unlikely(wl->state == WL1271_STATE_OFF))
2172 goto out;
2173
bbbb538e
JO		 2174 ret = wl1271_ps_elp_wakeup(wl, false);
2175 if (ret < 0)
2176 goto out;
2177
2178 ret = wl1271_acx_tsf_info(wl, &mactime);
2179 if (ret < 0)
2180 goto out_sleep;
2181
2182out_sleep:
2183 wl1271_ps_elp_sleep(wl);
2184
2185out:
2186 mutex_unlock(&wl->mutex);
2187 return mactime;
2188}
f5fc0f86 2189
ece550d0
JL		 2190static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2191 struct survey_info *survey)
2192{
2193 struct wl1271 *wl = hw->priv;
2194 struct ieee80211_conf *conf = &hw->conf;
b739a42c 2195
ece550d0
JL		 2196 if (idx != 0)
2197 return -ENOENT;
b739a42c 2198
ece550d0
JL		 2199 survey->channel = conf->channel;
2200 survey->filled = SURVEY_INFO_NOISE_DBM;
2201 survey->noise = wl->noise;
b739a42c 2202
ece550d0
JL		 2203 return 0;
2204}
2205
f5fc0f86
LC		 2206/* can't be const, mac80211 writes to this */
2207static struct ieee80211_rate wl1271_rates[] = {
2208 { .bitrate = 10,
2b60100b
JO		 2209 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2210 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 2211 { .bitrate = 20,
2b60100b
JO		 2212 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2213 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 2214 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2215 { .bitrate = 55,
2b60100b
JO		 2216 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2217 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 2218 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2219 { .bitrate = 110,
2b60100b
JO		 2220 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2221 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 2222 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2223 { .bitrate = 60,
2b60100b
JO		 2224 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2225 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 2226 { .bitrate = 90,
2b60100b
JO		 2227 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2228 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 2229 { .bitrate = 120,
2b60100b
JO		 2230 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2231 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 2232 { .bitrate = 180,
2b60100b
JO		 2233 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2234 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 2235 { .bitrate = 240,
2b60100b
JO		 2236 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2237 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 2238 { .bitrate = 360,
2b60100b
JO		 2239 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2240 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 2241 { .bitrate = 480,
2b60100b
JO		 2242 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2243 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 2244 { .bitrate = 540,
2b60100b
JO		 2245 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2246 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 2247};
2248
fa97f46b 2249/* can't be const, mac80211 writes to this */
f5fc0f86 2250static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 2251 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
fa21c7a9 2252 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
fa97f46b
JO		 2253 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2254 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2255 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
fa21c7a9 2256 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
fa97f46b
JO		 2257 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2258 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2259 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
fa21c7a9 2260 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
fa97f46b
JO		 2261 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2262 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2263 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
f5fc0f86
LC		 2264};
2265
f876bb9a 2266/* mapping to indexes for wl1271_rates */
a0ea9493 2267static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a 2268 /* MCS rates are used only with 11n */
18357850
SL		 2269 7, /* CONF_HW_RXTX_RATE_MCS7 */
2270 6, /* CONF_HW_RXTX_RATE_MCS6 */
2271 5, /* CONF_HW_RXTX_RATE_MCS5 */
2272 4, /* CONF_HW_RXTX_RATE_MCS4 */
2273 3, /* CONF_HW_RXTX_RATE_MCS3 */
2274 2, /* CONF_HW_RXTX_RATE_MCS2 */
2275 1, /* CONF_HW_RXTX_RATE_MCS1 */
2276 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 2277
2278 11, /* CONF_HW_RXTX_RATE_54 */
2279 10, /* CONF_HW_RXTX_RATE_48 */
2280 9, /* CONF_HW_RXTX_RATE_36 */
2281 8, /* CONF_HW_RXTX_RATE_24 */
2282
2283 /* TI-specific rate */
2284 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2285
2286 7, /* CONF_HW_RXTX_RATE_18 */
2287 6, /* CONF_HW_RXTX_RATE_12 */
2288 3, /* CONF_HW_RXTX_RATE_11 */
2289 5, /* CONF_HW_RXTX_RATE_9 */
2290 4, /* CONF_HW_RXTX_RATE_6 */
2291 2, /* CONF_HW_RXTX_RATE_5_5 */
2292 1, /* CONF_HW_RXTX_RATE_2 */
2293 0 /* CONF_HW_RXTX_RATE_1 */
2294};
2295
e8b03a2b
SL		 2296/* 11n STA capabilities */
2297#define HW_RX_HIGHEST_RATE 72
2298
00d20100
SL		 2299#ifdef CONFIG_WL12XX_HT
2300#define WL12XX_HT_CAP { \
e8b03a2b
SL		 2301 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
2302 .ht_supported = true, \
2303 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
2304 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
2305 .mcs = { \
2306 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
2307 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
2308 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
2309 }, \
2310}
18357850 2311#else
00d20100 2312#define WL12XX_HT_CAP { \
18357850
SL		 2313 .ht_supported = false, \
2314}
2315#endif
e8b03a2b 2316
f5fc0f86
LC		 2317/* can't be const, mac80211 writes to this */
2318static struct ieee80211_supported_band wl1271_band_2ghz = {
2319 .channels = wl1271_channels,
2320 .n_channels = ARRAY_SIZE(wl1271_channels),
2321 .bitrates = wl1271_rates,
2322 .n_bitrates = ARRAY_SIZE(wl1271_rates),
00d20100 2323 .ht_cap = WL12XX_HT_CAP,
f5fc0f86
LC		 2324};
2325
1ebec3d7
TP		 2326/* 5 GHz data rates for WL1273 */
2327static struct ieee80211_rate wl1271_rates_5ghz[] = {
2328 { .bitrate = 60,
2329 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2330 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2331 { .bitrate = 90,
2332 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2333 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2334 { .bitrate = 120,
2335 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2336 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2337 { .bitrate = 180,
2338 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2339 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2340 { .bitrate = 240,
2341 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2342 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2343 { .bitrate = 360,
2344 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2345 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2346 { .bitrate = 480,
2347 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2348 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2349 { .bitrate = 540,
2350 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2351 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2352};
2353
fa97f46b 2354/* 5 GHz band channels for WL1273 */
1ebec3d7
TP		 2355static struct ieee80211_channel wl1271_channels_5ghz[] = {
2356 { .hw_value = 183, .center_freq = 4915},
fa21c7a9 2357 { .hw_value = 184, .center_freq = 4920},
fa97f46b
JO		 2358 { .hw_value = 185, .center_freq = 4925},
2359 { .hw_value = 187, .center_freq = 4935},
2360 { .hw_value = 188, .center_freq = 4940},
fa21c7a9 2361 { .hw_value = 189, .center_freq = 4945},
fa21c7a9 2362 { .hw_value = 192, .center_freq = 4960},
fa21c7a9 2363 { .hw_value = 196, .center_freq = 4980},
fa21c7a9 2364 { .hw_value = 7, .center_freq = 5035},
fa97f46b
JO		 2365 { .hw_value = 8, .center_freq = 5040},
2366 { .hw_value = 9, .center_freq = 5045},
2367 { .hw_value = 11, .center_freq = 5055},
2368 { .hw_value = 12, .center_freq = 5060},
fa21c7a9 2369 { .hw_value = 16, .center_freq = 5080},
fa97f46b
JO		 2370 { .hw_value = 34, .center_freq = 5170},
2371 { .hw_value = 36, .center_freq = 5180},
2372 { .hw_value = 38, .center_freq = 5190},
2373 { .hw_value = 40, .center_freq = 5200},
fa21c7a9 2374 { .hw_value = 42, .center_freq = 5210},
fa97f46b
JO		 2375 { .hw_value = 44, .center_freq = 5220},
2376 { .hw_value = 46, .center_freq = 5230},
2377 { .hw_value = 48, .center_freq = 5240},
2378 { .hw_value = 52, .center_freq = 5260},
fa21c7a9 2379 { .hw_value = 56, .center_freq = 5280},
fa97f46b
JO		 2380 { .hw_value = 60, .center_freq = 5300},
2381 { .hw_value = 64, .center_freq = 5320},
2382 { .hw_value = 100, .center_freq = 5500},
2383 { .hw_value = 104, .center_freq = 5520},
fa21c7a9 2384 { .hw_value = 108, .center_freq = 5540},
fa97f46b
JO		 2385 { .hw_value = 112, .center_freq = 5560},
2386 { .hw_value = 116, .center_freq = 5580},
2387 { .hw_value = 120, .center_freq = 5600},
2388 { .hw_value = 124, .center_freq = 5620},
fa21c7a9 2389 { .hw_value = 128, .center_freq = 5640},
fa97f46b
JO		 2390 { .hw_value = 132, .center_freq = 5660},
2391 { .hw_value = 136, .center_freq = 5680},
2392 { .hw_value = 140, .center_freq = 5700},
2393 { .hw_value = 149, .center_freq = 5745},
fa21c7a9 2394 { .hw_value = 153, .center_freq = 5765},
fa97f46b
JO		 2395 { .hw_value = 157, .center_freq = 5785},
2396 { .hw_value = 161, .center_freq = 5805},
1ebec3d7
TP		 2397 { .hw_value = 165, .center_freq = 5825},
2398};
2399
f876bb9a 2400/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 2401static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a 2402 /* MCS rates are used only with 11n */
18357850
SL		 2403 7, /* CONF_HW_RXTX_RATE_MCS7 */
2404 6, /* CONF_HW_RXTX_RATE_MCS6 */
2405 5, /* CONF_HW_RXTX_RATE_MCS5 */
2406 4, /* CONF_HW_RXTX_RATE_MCS4 */
2407 3, /* CONF_HW_RXTX_RATE_MCS3 */
2408 2, /* CONF_HW_RXTX_RATE_MCS2 */
2409 1, /* CONF_HW_RXTX_RATE_MCS1 */
2410 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 2411
2412 7, /* CONF_HW_RXTX_RATE_54 */
2413 6, /* CONF_HW_RXTX_RATE_48 */
2414 5, /* CONF_HW_RXTX_RATE_36 */
2415 4, /* CONF_HW_RXTX_RATE_24 */
2416
2417 /* TI-specific rate */
2418 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2419
2420 3, /* CONF_HW_RXTX_RATE_18 */
2421 2, /* CONF_HW_RXTX_RATE_12 */
2422 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2423 1, /* CONF_HW_RXTX_RATE_9 */
2424 0, /* CONF_HW_RXTX_RATE_6 */
2425 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2426 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2427 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2428};
1ebec3d7
TP		 2429
2430static struct ieee80211_supported_band wl1271_band_5ghz = {
2431 .channels = wl1271_channels_5ghz,
2432 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2433 .bitrates = wl1271_rates_5ghz,
2434 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
00d20100 2435 .ht_cap = WL12XX_HT_CAP,
1ebec3d7
TP		 2436};
2437
a0ea9493 2438static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 2439 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2440 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2441};
2442
f5fc0f86
LC		 2443static const struct ieee80211_ops wl1271_ops = {
2444 .start = wl1271_op_start,
2445 .stop = wl1271_op_stop,
2446 .add_interface = wl1271_op_add_interface,
2447 .remove_interface = wl1271_op_remove_interface,
2448 .config = wl1271_op_config,
c87dec9f 2449 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 2450 .configure_filter = wl1271_op_configure_filter,
2451 .tx = wl1271_op_tx,
2452 .set_key = wl1271_op_set_key,
2453 .hw_scan = wl1271_op_hw_scan,
2454 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 2455 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 2456 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 2457 .conf_tx = wl1271_op_conf_tx,
bbbb538e 2458 .get_tsf = wl1271_op_get_tsf,
ece550d0 2459 .get_survey = wl1271_op_get_survey,
c8c90873 2460 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 2461};
2462
f876bb9a 2463
6a2de93b 2464u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
f876bb9a
JO		 2465{
2466 u8 idx;
2467
6a2de93b 2468 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
f876bb9a
JO		 2469
2470 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2471 wl1271_error("Illegal RX rate from HW: %d", rate);
2472 return 0;
2473 }
2474
6a2de93b 2475 idx = wl1271_band_rate_to_idx[band][rate];
f876bb9a
JO		 2476 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2477 wl1271_error("Unsupported RX rate from HW: %d", rate);
2478 return 0;
2479 }
2480
2481 return idx;
2482}
2483
7fc3a864
JO		 2484static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2485 struct device_attribute *attr,
2486 char *buf)
2487{
2488 struct wl1271 *wl = dev_get_drvdata(dev);
2489 ssize_t len;
2490
2f63b011 2491 len = PAGE_SIZE;
7fc3a864
JO		 2492
2493 mutex_lock(&wl->mutex);
2494 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2495 wl->sg_enabled);
2496 mutex_unlock(&wl->mutex);
2497
2498 return len;
2499
2500}
2501
2502static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2503 struct device_attribute *attr,
2504 const char *buf, size_t count)
2505{
2506 struct wl1271 *wl = dev_get_drvdata(dev);
2507 unsigned long res;
2508 int ret;
2509
2510 ret = strict_strtoul(buf, 10, &res);
2511
2512 if (ret < 0) {
2513 wl1271_warning("incorrect value written to bt_coex_mode");
2514 return count;
2515 }
2516
2517 mutex_lock(&wl->mutex);
2518
2519 res = !!res;
2520
2521 if (res == wl->sg_enabled)
2522 goto out;
2523
2524 wl->sg_enabled = res;
2525
2526 if (wl->state == WL1271_STATE_OFF)
2527 goto out;
2528
2529 ret = wl1271_ps_elp_wakeup(wl, false);
2530 if (ret < 0)
2531 goto out;
2532
2533 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2534 wl1271_ps_elp_sleep(wl);
2535
2536 out:
2537 mutex_unlock(&wl->mutex);
2538 return count;
2539}
2540
2541static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2542 wl1271_sysfs_show_bt_coex_state,
2543 wl1271_sysfs_store_bt_coex_state);
2544
d717fd61
JO		 2545static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2546 struct device_attribute *attr,
2547 char *buf)
2548{
2549 struct wl1271 *wl = dev_get_drvdata(dev);
2550 ssize_t len;
2551
2f63b011 2552 len = PAGE_SIZE;
d717fd61
JO		 2553
2554 mutex_lock(&wl->mutex);
2555 if (wl->hw_pg_ver >= 0)
2556 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2557 else
2558 len = snprintf(buf, len, "n/a\n");
2559 mutex_unlock(&wl->mutex);
2560
2561 return len;
2562}
2563
2564static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2565 wl1271_sysfs_show_hw_pg_ver, NULL);
2566
2d5e82b8 2567int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 2568{
2569 int ret;
2570
2571 if (wl->mac80211_registered)
2572 return 0;
2573
2574 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2575
2576 ret = ieee80211_register_hw(wl->hw);
2577 if (ret < 0) {
2578 wl1271_error("unable to register mac80211 hw: %d", ret);
2579 return ret;
2580 }
2581
2582 wl->mac80211_registered = true;
2583
c2c192ac
JO		 2584 register_netdevice_notifier(&wl1271_dev_notifier);
2585
f5fc0f86
LC		 2586 wl1271_notice("loaded");
2587
2588 return 0;
2589}
50b3eb4b 2590EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 2591
3b56dd6a
TP		 2592void wl1271_unregister_hw(struct wl1271 *wl)
2593{
c2c192ac 2594 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 2595 ieee80211_unregister_hw(wl->hw);
2596 wl->mac80211_registered = false;
2597
2598}
2599EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2600
2d5e82b8 2601int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 2602{
7a55724e
JO		 2603 static const u32 cipher_suites[] = {
2604 WLAN_CIPHER_SUITE_WEP40,
2605 WLAN_CIPHER_SUITE_WEP104,
2606 WLAN_CIPHER_SUITE_TKIP,
2607 WLAN_CIPHER_SUITE_CCMP,
2608 WL1271_CIPHER_SUITE_GEM,
2609 };
2610
1e2b7976
JO		 2611 /* The tx descriptor buffer and the TKIP space. */
2612 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2613 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 2614
2615 /* unit us */
2616 /* FIXME: find a proper value */
2617 wl->hw->channel_change_time = 10000;
50c500ad 2618 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 2619
2620 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 2621 IEEE80211_HW_BEACON_FILTER |
0a34332f 2622 IEEE80211_HW_SUPPORTS_PS |
4695dc91 2623 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 2624 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed
JO		 2625 IEEE80211_HW_CONNECTION_MONITOR |
2626 IEEE80211_HW_SUPPORTS_CQM_RSSI;
f5fc0f86 2627
7a55724e
JO		 2628 wl->hw->wiphy->cipher_suites = cipher_suites;
2629 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
2630
e0d8bbf0
JO		 2631 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2632 BIT(NL80211_IFTYPE_ADHOC);
f5fc0f86
LC		 2633 wl->hw->wiphy->max_scan_ssids = 1;
2634 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
11eb5429 2635 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
1ebec3d7 2636
12bd8949 2637 wl->hw->queues = 4;
31627dc5 2638 wl->hw->max_rates = 1;
12bd8949 2639
b7417d93
JO		 2640 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
2641
8197b711 2642 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 2643
2644 return 0;
2645}
50b3eb4b 2646EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 2647
f5fc0f86 2648#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 2649
2d5e82b8 2650struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 2651{
f5fc0f86 2652 struct ieee80211_hw *hw;
3b56dd6a 2653 struct platform_device *plat_dev = NULL;
f5fc0f86 2654 struct wl1271 *wl;
a1dd8187 2655 int i, ret;
1f37cbc9 2656 unsigned int order;
f5fc0f86
LC		 2657
2658 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2659 if (!hw) {
2660 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 2661 ret = -ENOMEM;
3b56dd6a
TP		 2662 goto err_hw_alloc;
2663 }
2664
929ebd30 2665 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3b56dd6a
TP		 2666 if (!plat_dev) {
2667 wl1271_error("could not allocate platform_device");
2668 ret = -ENOMEM;
2669 goto err_plat_alloc;
f5fc0f86
LC		 2670 }
2671
2672 wl = hw->priv;
2673 memset(wl, 0, sizeof(*wl));
2674
01c09162
JO		 2675 INIT_LIST_HEAD(&wl->list);
2676
f5fc0f86 2677 wl->hw = hw;
3b56dd6a 2678 wl->plat_dev = plat_dev;
f5fc0f86
LC		 2679
2680 skb_queue_head_init(&wl->tx_queue);
2681
37b70a81 2682 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
90494a90 2683 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
117b38d0
JO		 2684 INIT_WORK(&wl->irq_work, wl1271_irq_work);
2685 INIT_WORK(&wl->tx_work, wl1271_tx_work);
2686 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
2687 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
f5fc0f86 2688 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 2689 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 2690 wl->default_key = 0;
f5fc0f86
LC		 2691 wl->rx_counter = 0;
2692 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2693 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
19ad0715 2694 wl->psm_entry_retry = 0;
f5fc0f86 2695 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 2696 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 2697 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b
JO		 2698 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2699 wl->sta_rate_set = 0;
8a5a37a6 2700 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 2701 wl->vif = NULL;
830fb67b 2702 wl->flags = 0;
7fc3a864 2703 wl->sg_enabled = true;
d717fd61 2704 wl->hw_pg_ver = -1;
f5fc0f86 2705
25eeb9e3 2706 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
be7078c2 2707 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 2708 wl->tx_frames[i] = NULL;
2709
2710 spin_lock_init(&wl->wl_lock);
2711
f5fc0f86
LC		 2712 wl->state = WL1271_STATE_OFF;
2713 mutex_init(&wl->mutex);
2714
c332a4b8
TP		 2715 /* Apply default driver configuration. */
2716 wl1271_conf_init(wl);
2717
2d5e82b8
TP		 2718 wl1271_debugfs_init(wl);
2719
1f37cbc9
IY		 2720 order = get_order(WL1271_AGGR_BUFFER_SIZE);
2721 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
2722 if (!wl->aggr_buf) {
2723 ret = -ENOMEM;
2724 goto err_hw;
2725 }
2726
a1dd8187 2727 /* Register platform device */
3b56dd6a 2728 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 2729 if (ret) {
2730 wl1271_error("couldn't register platform device");
1f37cbc9 2731 goto err_aggr;
a1dd8187 2732 }
3b56dd6a 2733 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 2734
7fc3a864 2735 /* Create sysfs file to control bt coex state */
3b56dd6a 2736 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 2737 if (ret < 0) {
2738 wl1271_error("failed to create sysfs file bt_coex_state");
2739 goto err_platform;
2740 }
a1dd8187 2741
d717fd61
JO		 2742 /* Create sysfs file to get HW PG version */
2743 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2744 if (ret < 0) {
2745 wl1271_error("failed to create sysfs file hw_pg_ver");
2746 goto err_bt_coex_state;
2747 }
2748
c332a4b8 2749 return hw;
a1dd8187 2750
d717fd61
JO		 2751err_bt_coex_state:
2752 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2753
7fc3a864 2754err_platform:
3b56dd6a 2755 platform_device_unregister(wl->plat_dev);
7fc3a864 2756
1f37cbc9
IY		 2757err_aggr:
2758 free_pages((unsigned long)wl->aggr_buf, order);
2759
a1dd8187 2760err_hw:
3b56dd6a
TP		 2761 wl1271_debugfs_exit(wl);
2762 kfree(plat_dev);
2763
2764err_plat_alloc:
2765 ieee80211_free_hw(hw);
2766
2767err_hw_alloc:
a1dd8187 2768
a1dd8187 2769 return ERR_PTR(ret);
c332a4b8 2770}
50b3eb4b 2771EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 2772
2773int wl1271_free_hw(struct wl1271 *wl)
2774{
3b56dd6a 2775 platform_device_unregister(wl->plat_dev);
1f37cbc9
IY		 2776 free_pages((unsigned long)wl->aggr_buf,
2777 get_order(WL1271_AGGR_BUFFER_SIZE));
3b56dd6a 2778 kfree(wl->plat_dev);
c332a4b8
TP		 2779
2780 wl1271_debugfs_exit(wl);
2781
c332a4b8
TP		 2782 vfree(wl->fw);
2783 wl->fw = NULL;
2784 kfree(wl->nvs);
2785 wl->nvs = NULL;
2786
2787 kfree(wl->fw_status);
2788 kfree(wl->tx_res_if);
2789
2790 ieee80211_free_hw(wl->hw);
2791
2792 return 0;
2793}
50b3eb4b
TP		 2794EXPORT_SYMBOL_GPL(wl1271_free_hw);
2795
2796MODULE_LICENSE("GPL");
2797MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2798MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux kernel - Deliverables
This page took 0.411781 seconds and 5 git commands to generate.