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