projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx: Fix kernel crash related to hw recovery and interface shutdown
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / wireless / wl12xx / main.c
CommitLineData
f5fc0f86
LC		 1/*
2 * This file is part of wl1271
3 *
8bf29b0e 4 * Copyright (C) 2008-2010 Nokia Corporation
f5fc0f86
LC		 5 *
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 *
22 */
23
24#include <linux/module.h>
f5fc0f86
LC		 25#include <linux/firmware.h>
26#include <linux/delay.h>
f5fc0f86
LC		 27#include <linux/spi/spi.h>
28#include <linux/crc32.h>
29#include <linux/etherdevice.h>
1fba4974 30#include <linux/vmalloc.h>
a1dd8187 31#include <linux/platform_device.h>
5a0e3ad6 32#include <linux/slab.h>
f5fc0f86 33
00d20100 34#include "wl12xx.h"
f5fc0f86 35#include "wl12xx_80211.h"
00d20100
SL		 36#include "reg.h"
37#include "io.h"
38#include "event.h"
39#include "tx.h"
40#include "rx.h"
41#include "ps.h"
42#include "init.h"
43#include "debugfs.h"
44#include "cmd.h"
45#include "boot.h"
46#include "testmode.h"
47#include "scan.h"
f5fc0f86 48
9ccd9217
JO		 49#define WL1271_BOOT_RETRIES 3
50
8a08048a
JO		 51static struct conf_drv_settings default_conf = {
52 .sg = {
1b00f546
JO		 53 .params = {
54 [CONF_SG_BT_PER_THRESHOLD] = 7500,
55 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
56 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
57 [CONF_SG_BT_LOAD_RATIO] = 50,
8d2ef7bd 58 [CONF_SG_AUTO_PS_MODE] = 1,
1b00f546
JO		 59 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
60 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
61 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
62 [CONF_SG_BEACON_MISS_PERCENT] = 60,
63 [CONF_SG_RATE_ADAPT_THRESH] = 12,
64 [CONF_SG_RATE_ADAPT_SNR] = 0,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
67 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
70 /* Note: with UPSD, this should be 4 */
71 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
74 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
75 /* Note: with UPDS, this should be 15 */
76 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
77 /* Note: with UPDS, this should be 50 */
78 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
79 /* Note: with UPDS, this should be 10 */
80 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
81 [CONF_SG_RXT] = 1200,
82 [CONF_SG_TXT] = 1000,
83 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
84 [CONF_SG_PS_POLL_TIMEOUT] = 10,
85 [CONF_SG_UPSD_TIMEOUT] = 10,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
91 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
94 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
97 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
98 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
99 [CONF_SG_HV3_MAX_SERVED] = 6,
100 [CONF_SG_DHCP_TIME] = 5000,
101 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
102 },
103 .state = CONF_SG_PROTECTIVE,
8a08048a
JO		 104 },
105 .rx = {
106 .rx_msdu_life_time = 512000,
107 .packet_detection_threshold = 0,
108 .ps_poll_timeout = 15,
109 .upsd_timeout = 15,
110 .rts_threshold = 2347,
3ed8f2c6
LC		 111 .rx_cca_threshold = 0,
112 .irq_blk_threshold = 0xFFFF,
113 .irq_pkt_threshold = 0,
114 .irq_timeout = 600,
8a08048a
JO		 115 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
116 },
117 .tx = {
118 .tx_energy_detection = 0,
119 .rc_conf = {
ebba60c6 120 .enabled_rates = 0,
8a08048a
JO		 121 .short_retry_limit = 10,
122 .long_retry_limit = 10,
123 .aflags = 0
45b531a8 124 },
8a08048a
JO		 125 .ac_conf_count = 4,
126 .ac_conf = {
9987a9da 127 [CONF_TX_AC_BE] = {
8a08048a
JO		 128 .ac = CONF_TX_AC_BE,
129 .cw_min = 15,
130 .cw_max = 63,
131 .aifsn = 3,
132 .tx_op_limit = 0,
45b531a8 133 },
9987a9da 134 [CONF_TX_AC_BK] = {
8a08048a
JO		 135 .ac = CONF_TX_AC_BK,
136 .cw_min = 15,
137 .cw_max = 63,
138 .aifsn = 7,
139 .tx_op_limit = 0,
45b531a8 140 },
9987a9da 141 [CONF_TX_AC_VI] = {
8a08048a
JO		 142 .ac = CONF_TX_AC_VI,
143 .cw_min = 15,
144 .cw_max = 63,
145 .aifsn = CONF_TX_AIFS_PIFS,
146 .tx_op_limit = 3008,
147 },
9987a9da 148 [CONF_TX_AC_VO] = {
8a08048a
JO		 149 .ac = CONF_TX_AC_VO,
150 .cw_min = 15,
151 .cw_max = 63,
152 .aifsn = CONF_TX_AIFS_PIFS,
153 .tx_op_limit = 1504,
45b531a8 154 },
51f2be24 155 },
9987a9da 156 .tid_conf_count = 4,
8a08048a 157 .tid_conf = {
9987a9da
JO		 158 [CONF_TX_AC_BE] = {
159 .queue_id = CONF_TX_AC_BE,
160 .channel_type = CONF_CHANNEL_TYPE_EDCF,
8a08048a
JO		 161 .tsid = CONF_TX_AC_BE,
162 .ps_scheme = CONF_PS_SCHEME_LEGACY,
163 .ack_policy = CONF_ACK_POLICY_LEGACY,
164 .apsd_conf = {0, 0},
51f2be24 165 },
9987a9da
JO		 166 [CONF_TX_AC_BK] = {
167 .queue_id = CONF_TX_AC_BK,
168 .channel_type = CONF_CHANNEL_TYPE_EDCF,
169 .tsid = CONF_TX_AC_BK,
8a08048a
JO		 170 .ps_scheme = CONF_PS_SCHEME_LEGACY,
171 .ack_policy = CONF_ACK_POLICY_LEGACY,
172 .apsd_conf = {0, 0},
173 },
9987a9da
JO		 174 [CONF_TX_AC_VI] = {
175 .queue_id = CONF_TX_AC_VI,
176 .channel_type = CONF_CHANNEL_TYPE_EDCF,
177 .tsid = CONF_TX_AC_VI,
8a08048a
JO		 178 .ps_scheme = CONF_PS_SCHEME_LEGACY,
179 .ack_policy = CONF_ACK_POLICY_LEGACY,
180 .apsd_conf = {0, 0},
181 },
9987a9da
JO		 182 [CONF_TX_AC_VO] = {
183 .queue_id = CONF_TX_AC_VO,
184 .channel_type = CONF_CHANNEL_TYPE_EDCF,
185 .tsid = CONF_TX_AC_VO,
8a08048a
JO		 186 .ps_scheme = CONF_PS_SCHEME_LEGACY,
187 .ack_policy = CONF_ACK_POLICY_LEGACY,
188 .apsd_conf = {0, 0},
189 },
8a08048a
JO		 190 },
191 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
3ed8f2c6 192 .tx_compl_timeout = 700,
ebba60c6
JO		 193 .tx_compl_threshold = 4,
194 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
195 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
8a08048a
JO		 196 },
197 .conn = {
198 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
50c500ad 199 .listen_interval = 1,
8a08048a
JO		 200 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
201 .bcn_filt_ie_count = 1,
202 .bcn_filt_ie = {
203 [0] = {
204 .ie = WLAN_EID_CHANNEL_SWITCH,
205 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
51f2be24 206 }
47fab7d5 207 },
3ed8f2c6 208 .synch_fail_thold = 10,
8a08048a
JO		 209 .bss_lose_timeout = 100,
210 .beacon_rx_timeout = 10000,
211 .broadcast_timeout = 20000,
212 .rx_broadcast_in_ps = 1,
90494a90
JO		 213 .ps_poll_threshold = 10,
214 .ps_poll_recovery_period = 700,
11f70f97 215 .bet_enable = CONF_BET_MODE_ENABLE,
84502563 216 .bet_max_consecutive = 10,
8eab7b47
JO		 217 .psm_entry_retries = 5,
218 .psm_entry_nullfunc_retries = 3,
219 .psm_entry_hangover_period = 1,
50c500ad
JO		 220 .keep_alive_interval = 55000,
221 .max_listen_interval = 20,
8a08048a 222 },
6e92b416
LC		 223 .itrim = {
224 .enable = false,
225 .timeout = 50000,
38ad2d87
JO		 226 },
227 .pm_config = {
228 .host_clk_settling_time = 5000,
229 .host_fast_wakeup_support = false
00236aed
JO		 230 },
231 .roam_trigger = {
00236aed
JO		 232 .trigger_pacing = 1,
233 .avg_weight_rssi_beacon = 20,
234 .avg_weight_rssi_data = 10,
235 .avg_weight_snr_beacon = 20,
236 .avg_weight_snr_data = 10
bea39d6a
JO		 237 },
238 .scan = {
239 .min_dwell_time_active = 7500,
240 .max_dwell_time_active = 30000,
241 .min_dwell_time_passive = 30000,
242 .max_dwell_time_passive = 60000,
243 .num_probe_reqs = 2,
244 },
644a4860
JO		 245 .rf = {
246 .tx_per_channel_power_compensation_2 = {
247 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
248 },
249 .tx_per_channel_power_compensation_5 = {
250 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
251 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
252 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
253 },
254 },
8a08048a
JO		 255};
256
52b0e7a6
JO		 257static void __wl1271_op_remove_interface(struct wl1271 *wl);
258
259
a1dd8187
JO		 260static void wl1271_device_release(struct device *dev)
261{
262
263}
264
265static struct platform_device wl1271_device = {
266 .name = "wl1271",
267 .id = -1,
268
269 /* device model insists to have a release function */
270 .dev = {
271 .release = wl1271_device_release,
272 },
273};
274
01c09162
JO		 275static LIST_HEAD(wl_list);
276
c2c192ac
JO		 277static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
278 void *arg)
279{
280 struct net_device *dev = arg;
281 struct wireless_dev *wdev;
282 struct wiphy *wiphy;
283 struct ieee80211_hw *hw;
284 struct wl1271 *wl;
285 struct wl1271 *wl_temp;
286 int ret = 0;
287
288 /* Check that this notification is for us. */
289 if (what != NETDEV_CHANGE)
290 return NOTIFY_DONE;
291
292 wdev = dev->ieee80211_ptr;
293 if (wdev == NULL)
294 return NOTIFY_DONE;
295
296 wiphy = wdev->wiphy;
297 if (wiphy == NULL)
298 return NOTIFY_DONE;
299
300 hw = wiphy_priv(wiphy);
301 if (hw == NULL)
302 return NOTIFY_DONE;
303
304 wl_temp = hw->priv;
305 list_for_each_entry(wl, &wl_list, list) {
306 if (wl == wl_temp)
307 break;
308 }
309 if (wl != wl_temp)
310 return NOTIFY_DONE;
311
312 mutex_lock(&wl->mutex);
313
314 if (wl->state == WL1271_STATE_OFF)
315 goto out;
316
317 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
318 goto out;
319
320 ret = wl1271_ps_elp_wakeup(wl, false);
321 if (ret < 0)
322 goto out;
323
324 if ((dev->operstate == IF_OPER_UP) &&
325 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
326 wl1271_cmd_set_sta_state(wl);
327 wl1271_info("Association completed.");
328 }
329
330 wl1271_ps_elp_sleep(wl);
331
332out:
333 mutex_unlock(&wl->mutex);
334
335 return NOTIFY_OK;
336}
337
b7417d93
JO		 338static int wl1271_reg_notify(struct wiphy *wiphy,
339 struct regulatory_request *request) {
340 struct ieee80211_supported_band *band;
341 struct ieee80211_channel *ch;
342 int i;
343
344 band = wiphy->bands[IEEE80211_BAND_5GHZ];
345 for (i = 0; i < band->n_channels; i++) {
346 ch = &band->channels[i];
347 if (ch->flags & IEEE80211_CHAN_DISABLED)
348 continue;
349
350 if (ch->flags & IEEE80211_CHAN_RADAR)
351 ch->flags |= IEEE80211_CHAN_NO_IBSS |
352 IEEE80211_CHAN_PASSIVE_SCAN;
353
354 }
355
356 return 0;
357}
358
8a08048a
JO		 359static void wl1271_conf_init(struct wl1271 *wl)
360{
2b60100b
JO		 361
362 /*
363 * This function applies the default configuration to the driver. This
364 * function is invoked upon driver load (spi probe.)
365 *
366 * The configuration is stored in a run-time structure in order to
367 * facilitate for run-time adjustment of any of the parameters. Making
368 * changes to the configuration structure will apply the new values on
369 * the next interface up (wl1271_op_start.)
370 */
371
372 /* apply driver default configuration */
8a08048a 373 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
2b60100b
JO		 374}
375
376
f5fc0f86
LC		 377static int wl1271_plt_init(struct wl1271 *wl)
378{
12419cce
LC		 379 struct conf_tx_ac_category *conf_ac;
380 struct conf_tx_tid *conf_tid;
381 int ret, i;
f5fc0f86 382
98b5dd5d 383 ret = wl1271_cmd_general_parms(wl);
4a90406b 384 if (ret < 0)
cc7defa3
LC		 385 return ret;
386
98b5dd5d 387 ret = wl1271_cmd_radio_parms(wl);
4a90406b 388 if (ret < 0)
cc7defa3
LC		 389 return ret;
390
644a4860
JO		 391 ret = wl1271_cmd_ext_radio_parms(wl);
392 if (ret < 0)
393 return ret;
394
12419cce
LC		 395 ret = wl1271_init_templates_config(wl);
396 if (ret < 0)
397 return ret;
398
f5fc0f86
LC		 399 ret = wl1271_acx_init_mem_config(wl);
400 if (ret < 0)
401 return ret;
402
12419cce
LC		 403 /* PHY layer config */
404 ret = wl1271_init_phy_config(wl);
405 if (ret < 0)
406 goto out_free_memmap;
407
408 ret = wl1271_acx_dco_itrim_params(wl);
409 if (ret < 0)
410 goto out_free_memmap;
411
412 /* Initialize connection monitoring thresholds */
6ccbb92e 413 ret = wl1271_acx_conn_monit_params(wl, false);
12419cce
LC		 414 if (ret < 0)
415 goto out_free_memmap;
416
417 /* Bluetooth WLAN coexistence */
418 ret = wl1271_init_pta(wl);
419 if (ret < 0)
420 goto out_free_memmap;
421
422 /* Energy detection */
423 ret = wl1271_init_energy_detection(wl);
424 if (ret < 0)
425 goto out_free_memmap;
426
427 /* Default fragmentation threshold */
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);
67353299
JO		 1160 /*
1161 * wl->vif can be null here if someone shuts down the interface
1162 * just when hardware recovery has been started.
1163 */
1164 if (wl->vif) {
1165 WARN_ON(wl->vif != vif);
1166 __wl1271_op_remove_interface(wl);
1167 }
52b0e7a6 1168
67353299 1169 mutex_unlock(&wl->mutex);
52b0e7a6 1170 cancel_work_sync(&wl->recovery_work);
f5fc0f86
LC		 1171}
1172
14b228a0
JO		 1173static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1174{
1175 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1176 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1177
1178 /* combine requested filters with current filter config */
1179 filters = wl->filters | filters;
1180
1181 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1182
1183 if (filters & FIF_PROMISC_IN_BSS) {
1184 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1185 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1186 wl->rx_config |= CFG_BSSID_FILTER_EN;
1187 }
1188 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1189 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1190 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1191 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1192 }
1193 if (filters & FIF_OTHER_BSS) {
1194 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1195 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1196 }
1197 if (filters & FIF_CONTROL) {
1198 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1199 wl->rx_filter |= CFG_RX_CTL_EN;
1200 }
1201 if (filters & FIF_FCSFAIL) {
1202 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1203 wl->rx_filter |= CFG_RX_FCS_ERROR;
1204 }
1205}
1206
82429d32 1207static int wl1271_dummy_join(struct wl1271 *wl)
c7f43e45 1208{
e0d8bbf0 1209 int ret = 0;
c7f43e45
LC		 1210 /* we need to use a dummy BSSID for now */
1211 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1212 0xad, 0xbe, 0xef };
1213
c7f43e45
LC		 1214 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1215
14b228a0
JO		 1216 /* pass through frames from all BSS */
1217 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1218
5da11dcd 1219 ret = wl1271_cmd_join(wl, wl->set_bss_type);
c7f43e45
LC		 1220 if (ret < 0)
1221 goto out;
1222
71449f8d 1223 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1224
1225out:
1226 return ret;
1227}
1228
69e5434c 1229static int wl1271_join(struct wl1271 *wl, bool set_assoc)
82429d32
JO		 1230{
1231 int ret;
1232
69e5434c
JO		 1233 /*
1234 * One of the side effects of the JOIN command is that is clears
1235 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1236 * to a WPA/WPA2 access point will therefore kill the data-path.
1237 * Currently there is no supported scenario for JOIN during
1238 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1239 * must be handled somehow.
1240 *
1241 */
1242 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1243 wl1271_info("JOIN while associated.");
1244
1245 if (set_assoc)
1246 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1247
82429d32
JO		 1248 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1249 if (ret < 0)
1250 goto out;
1251
1252 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1253
1254 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1255 goto out;
1256
1257 /*
1258 * The join command disable the keep-alive mode, shut down its process,
1259 * and also clear the template config, so we need to reset it all after
1260 * the join. The acx_aid starts the keep-alive process, and the order
1261 * of the commands below is relevant.
1262 */
1263 ret = wl1271_acx_keep_alive_mode(wl, true);
1264 if (ret < 0)
1265 goto out;
1266
1267 ret = wl1271_acx_aid(wl, wl->aid);
1268 if (ret < 0)
1269 goto out;
1270
1271 ret = wl1271_cmd_build_klv_null_data(wl);
1272 if (ret < 0)
1273 goto out;
1274
1275 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1276 ACX_KEEP_ALIVE_TPL_VALID);
1277 if (ret < 0)
1278 goto out;
1279
1280out:
1281 return ret;
1282}
1283
1284static int wl1271_unjoin(struct wl1271 *wl)
c7f43e45
LC		 1285{
1286 int ret;
1287
1288 /* to stop listening to a channel, we disconnect */
1289 ret = wl1271_cmd_disconnect(wl);
1290 if (ret < 0)
1291 goto out;
1292
71449f8d 1293 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45 1294 memset(wl->bssid, 0, ETH_ALEN);
14b228a0
JO		 1295
1296 /* stop filterting packets based on bssid */
1297 wl1271_configure_filters(wl, FIF_OTHER_BSS);
c7f43e45
LC		 1298
1299out:
1300 return ret;
1301}
1302
ebba60c6
JO		 1303static void wl1271_set_band_rate(struct wl1271 *wl)
1304{
1305 if (wl->band == IEEE80211_BAND_2GHZ)
1306 wl->basic_rate_set = wl->conf.tx.basic_rate;
1307 else
1308 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1309}
1310
1311static u32 wl1271_min_rate_get(struct wl1271 *wl)
1312{
1313 int i;
1314 u32 rate = 0;
1315
1316 if (!wl->basic_rate_set) {
1317 WARN_ON(1);
1318 wl->basic_rate_set = wl->conf.tx.basic_rate;
1319 }
1320
1321 for (i = 0; !rate; i++) {
1322 if ((wl->basic_rate_set >> i) & 0x1)
1323 rate = 1 << i;
1324 }
1325
1326 return rate;
1327}
1328
0d58cbff
JO		 1329static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1330{
1331 int ret;
1332
1333 if (idle) {
1334 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1335 ret = wl1271_unjoin(wl);
1336 if (ret < 0)
1337 goto out;
1338 }
1339 wl->rate_set = wl1271_min_rate_get(wl);
1340 wl->sta_rate_set = 0;
1341 ret = wl1271_acx_rate_policies(wl);
1342 if (ret < 0)
1343 goto out;
1344 ret = wl1271_acx_keep_alive_config(
1345 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1346 ACX_KEEP_ALIVE_TPL_INVALID);
1347 if (ret < 0)
1348 goto out;
1349 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1350 } else {
1351 /* increment the session counter */
1352 wl->session_counter++;
1353 if (wl->session_counter >= SESSION_COUNTER_MAX)
1354 wl->session_counter = 0;
1355 ret = wl1271_dummy_join(wl);
1356 if (ret < 0)
1357 goto out;
1358 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1359 }
1360
1361out:
1362 return ret;
1363}
1364
f5fc0f86
LC		 1365static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1366{
1367 struct wl1271 *wl = hw->priv;
1368 struct ieee80211_conf *conf = &hw->conf;
1369 int channel, ret = 0;
1370
1371 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1372
c7f43e45 1373 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
f5fc0f86
LC		 1374 channel,
1375 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45
LC		 1376 conf->power_level,
1377 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
f5fc0f86 1378
781608c4
JO		 1379 /*
1380 * mac80211 will go to idle nearly immediately after transmitting some
1381 * frames, such as the deauth. To make sure those frames reach the air,
1382 * wait here until the TX queue is fully flushed.
1383 */
1384 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1385 (conf->flags & IEEE80211_CONF_IDLE))
1386 wl1271_tx_flush(wl);
1387
f5fc0f86
LC		 1388 mutex_lock(&wl->mutex);
1389
f8d9802f
JO		 1390 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1391 ret = -EAGAIN;
2c10bb9c 1392 goto out;
f8d9802f 1393 }
8a5a37a6 1394
f5fc0f86
LC		 1395 ret = wl1271_ps_elp_wakeup(wl, false);
1396 if (ret < 0)
1397 goto out;
1398
ebba60c6 1399 /* if the channel changes while joined, join again */
69e5434c
JO		 1400 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1401 ((wl->band != conf->channel->band) ||
1402 (wl->channel != channel))) {
ebba60c6
JO		 1403 wl->band = conf->channel->band;
1404 wl->channel = channel;
1405
1406 /*
1407 * FIXME: the mac80211 should really provide a fixed rate
1408 * to use here. for now, just use the smallest possible rate
1409 * for the band as a fixed rate for association frames and
1410 * other control messages.
1411 */
1412 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1413 wl1271_set_band_rate(wl);
1414
1415 wl->basic_rate = wl1271_min_rate_get(wl);
1416 ret = wl1271_acx_rate_policies(wl);
1417 if (ret < 0)
1418 wl1271_warning("rate policy for update channel "
1419 "failed %d", ret);
1420
1421 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
69e5434c 1422 ret = wl1271_join(wl, false);
ebba60c6
JO		 1423 if (ret < 0)
1424 wl1271_warning("cmd join to update channel "
1425 "failed %d", ret);
1426 }
1427 }
1428
c7f43e45 1429 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
0d58cbff
JO		 1430 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1431 if (ret < 0)
1432 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 1433 }
1434
90494a90
JO		 1435 /*
1436 * if mac80211 changes the PSM mode, make sure the mode is not
1437 * incorrectly changed after the pspoll failure active window.
1438 */
1439 if (changed & IEEE80211_CONF_CHANGE_PS)
1440 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1441
71449f8d
JO		 1442 if (conf->flags & IEEE80211_CONF_PS &&
1443 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1444 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 1445
1446 /*
1447 * We enter PSM only if we're already associated.
1448 * If we're not, we'll enter it when joining an SSID,
1449 * through the bss_info_changed() hook.
1450 */
830fb67b 1451 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 1452 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c 1453 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
8eab7b47 1454 wl->basic_rate, true);
af5e084b 1455 }
f5fc0f86 1456 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 1457 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 1458 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 1459
71449f8d 1460 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 1461
71449f8d 1462 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c 1463 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
8eab7b47 1464 wl->basic_rate, true);
f5fc0f86
LC		 1465 }
1466
1467 if (conf->power_level != wl->power_level) {
1468 ret = wl1271_acx_tx_power(wl, conf->power_level);
1469 if (ret < 0)
c6317a54 1470 goto out_sleep;
f5fc0f86
LC		 1471
1472 wl->power_level = conf->power_level;
1473 }
1474
1475out_sleep:
1476 wl1271_ps_elp_sleep(wl);
1477
1478out:
1479 mutex_unlock(&wl->mutex);
1480
1481 return ret;
1482}
1483
b54853f1
JO		 1484struct wl1271_filter_params {
1485 bool enabled;
1486 int mc_list_length;
1487 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1488};
1489
22bedad3
JP		 1490static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1491 struct netdev_hw_addr_list *mc_list)
c87dec9f 1492{
c87dec9f 1493 struct wl1271_filter_params *fp;
22bedad3 1494 struct netdev_hw_addr *ha;
2c10bb9c 1495 struct wl1271 *wl = hw->priv;
c87dec9f 1496
2c10bb9c
SD		 1497 if (unlikely(wl->state == WL1271_STATE_OFF))
1498 return 0;
c87dec9f 1499
74441130 1500 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 1501 if (!fp) {
1502 wl1271_error("Out of memory setting filters.");
1503 return 0;
1504 }
1505
1506 /* update multicast filtering parameters */
c87dec9f 1507 fp->mc_list_length = 0;
22bedad3
JP		 1508 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1509 fp->enabled = false;
1510 } else {
1511 fp->enabled = true;
1512 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 1513 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 1514 ha->addr, ETH_ALEN);
c87dec9f 1515 fp->mc_list_length++;
22bedad3 1516 }
c87dec9f
JO		 1517 }
1518
b54853f1 1519 return (u64)(unsigned long)fp;
c87dec9f 1520}
f5fc0f86 1521
b54853f1
JO		 1522#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1523 FIF_ALLMULTI | \
1524 FIF_FCSFAIL | \
1525 FIF_BCN_PRBRESP_PROMISC | \
1526 FIF_CONTROL | \
1527 FIF_OTHER_BSS)
1528
f5fc0f86
LC		 1529static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1530 unsigned int changed,
c87dec9f 1531 unsigned int *total, u64 multicast)
f5fc0f86 1532{
b54853f1 1533 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 1534 struct wl1271 *wl = hw->priv;
b54853f1 1535 int ret;
f5fc0f86
LC		 1536
1537 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1538
b54853f1
JO		 1539 mutex_lock(&wl->mutex);
1540
2c10bb9c
SD		 1541 *total &= WL1271_SUPPORTED_FILTERS;
1542 changed &= WL1271_SUPPORTED_FILTERS;
1543
1544 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 1545 goto out;
1546
1547 ret = wl1271_ps_elp_wakeup(wl, false);
1548 if (ret < 0)
1549 goto out;
1550
f5fc0f86 1551
b54853f1
JO		 1552 if (*total & FIF_ALLMULTI)
1553 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1554 else if (fp)
1555 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1556 fp->mc_list,
1557 fp->mc_list_length);
1558 if (ret < 0)
1559 goto out_sleep;
f5fc0f86 1560
b54853f1
JO		 1561 /* determine, whether supported filter values have changed */
1562 if (changed == 0)
1563 goto out_sleep;
c87dec9f 1564
14b228a0
JO		 1565 /* configure filters */
1566 wl->filters = *total;
1567 wl1271_configure_filters(wl, 0);
1568
b54853f1
JO		 1569 /* apply configured filters */
1570 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1571 if (ret < 0)
1572 goto out_sleep;
1573
1574out_sleep:
1575 wl1271_ps_elp_sleep(wl);
1576
1577out:
1578 mutex_unlock(&wl->mutex);
14b228a0 1579 kfree(fp);
f5fc0f86
LC		 1580}
1581
1582static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1583 struct ieee80211_vif *vif,
1584 struct ieee80211_sta *sta,
1585 struct ieee80211_key_conf *key_conf)
1586{
1587 struct wl1271 *wl = hw->priv;
1588 const u8 *addr;
1589 int ret;
ac4e4ce5
JO		 1590 u32 tx_seq_32 = 0;
1591 u16 tx_seq_16 = 0;
f5fc0f86
LC		 1592 u8 key_type;
1593
1594 static const u8 bcast_addr[ETH_ALEN] =
1595 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1596
1597 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1598
1599 addr = sta ? sta->addr : bcast_addr;
1600
1601 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1602 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1603 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
97359d12 1604 key_conf->cipher, key_conf->keyidx,
f5fc0f86
LC		 1605 key_conf->keylen, key_conf->flags);
1606 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1607
1608 if (is_zero_ether_addr(addr)) {
1609 /* We dont support TX only encryption */
1610 ret = -EOPNOTSUPP;
1611 goto out;
1612 }
1613
1614 mutex_lock(&wl->mutex);
1615
f8d9802f
JO		 1616 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1617 ret = -EAGAIN;
1618 goto out_unlock;
1619 }
1620
f5fc0f86
LC		 1621 ret = wl1271_ps_elp_wakeup(wl, false);
1622 if (ret < 0)
1623 goto out_unlock;
1624
97359d12
JB		 1625 switch (key_conf->cipher) {
1626 case WLAN_CIPHER_SUITE_WEP40:
1627 case WLAN_CIPHER_SUITE_WEP104:
f5fc0f86
LC		 1628 key_type = KEY_WEP;
1629
1630 key_conf->hw_key_idx = key_conf->keyidx;
1631 break;
97359d12 1632 case WLAN_CIPHER_SUITE_TKIP:
f5fc0f86
LC		 1633 key_type = KEY_TKIP;
1634
1635 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 1636 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1637 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 1638 break;
97359d12 1639 case WLAN_CIPHER_SUITE_CCMP:
f5fc0f86
LC		 1640 key_type = KEY_AES;
1641
1642 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
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;
7a55724e
JO		 1646 case WL1271_CIPHER_SUITE_GEM:
1647 key_type = KEY_GEM;
1648 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1649 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1650 break;
f5fc0f86 1651 default:
97359d12 1652 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
f5fc0f86
LC		 1653
1654 ret = -EOPNOTSUPP;
1655 goto out_sleep;
1656 }
1657
1658 switch (cmd) {
1659 case SET_KEY:
1660 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1661 key_conf->keyidx, key_type,
1662 key_conf->keylen, key_conf->key,
ac4e4ce5 1663 addr, tx_seq_32, tx_seq_16);
f5fc0f86
LC		 1664 if (ret < 0) {
1665 wl1271_error("Could not add or replace key");
1666 goto out_sleep;
1667 }
ee444cf0
JO		 1668
1669 /* the default WEP key needs to be configured at least once */
1670 if (key_type == KEY_WEP) {
1671 ret = wl1271_cmd_set_default_wep_key(wl,
1672 wl->default_key);
1673 if (ret < 0)
1674 goto out_sleep;
1675 }
f5fc0f86
LC		 1676 break;
1677
1678 case DISABLE_KEY:
fddc7dd7
JO		 1679 /* The wl1271 does not allow to remove unicast keys - they
1680 will be cleared automatically on next CMD_JOIN. Ignore the
1681 request silently, as we dont want the mac80211 to emit
1682 an error message. */
1683 if (!is_broadcast_ether_addr(addr))
1684 break;
1685
f5fc0f86
LC		 1686 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1687 key_conf->keyidx, key_type,
1688 key_conf->keylen, key_conf->key,
ac4e4ce5 1689 addr, 0, 0);
f5fc0f86
LC		 1690 if (ret < 0) {
1691 wl1271_error("Could not remove key");
1692 goto out_sleep;
1693 }
1694 break;
1695
1696 default:
1697 wl1271_error("Unsupported key cmd 0x%x", cmd);
1698 ret = -EOPNOTSUPP;
f5fc0f86
LC		 1699 break;
1700 }
1701
1702out_sleep:
1703 wl1271_ps_elp_sleep(wl);
1704
1705out_unlock:
1706 mutex_unlock(&wl->mutex);
1707
1708out:
1709 return ret;
1710}
1711
1712static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 1713 struct ieee80211_vif *vif,
f5fc0f86
LC		 1714 struct cfg80211_scan_request *req)
1715{
1716 struct wl1271 *wl = hw->priv;
1717 int ret;
1718 u8 *ssid = NULL;
abb0b3bf 1719 size_t len = 0;
f5fc0f86
LC		 1720
1721 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1722
1723 if (req->n_ssids) {
1724 ssid = req->ssids[0].ssid;
abb0b3bf 1725 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 1726 }
1727
1728 mutex_lock(&wl->mutex);
1729
b739a42c
JO		 1730 if (wl->state == WL1271_STATE_OFF) {
1731 /*
1732 * We cannot return -EBUSY here because cfg80211 will expect
1733 * a call to ieee80211_scan_completed if we do - in this case
1734 * there won't be any call.
1735 */
1736 ret = -EAGAIN;
1737 goto out;
1738 }
1739
f5fc0f86
LC		 1740 ret = wl1271_ps_elp_wakeup(wl, false);
1741 if (ret < 0)
1742 goto out;
1743
5924f89d 1744 ret = wl1271_scan(hw->priv, ssid, len, req);
f5fc0f86
LC		 1745
1746 wl1271_ps_elp_sleep(wl);
1747
1748out:
1749 mutex_unlock(&wl->mutex);
1750
1751 return ret;
1752}
1753
68d069c4
AN		 1754static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
1755{
1756 struct wl1271 *wl = hw->priv;
1757 int ret = 0;
1758
1759 mutex_lock(&wl->mutex);
1760
1761 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1762 ret = -EAGAIN;
1763 goto out;
1764 }
1765
1766 ret = wl1271_ps_elp_wakeup(wl, false);
1767 if (ret < 0)
1768 goto out;
1769
1770 ret = wl1271_acx_frag_threshold(wl, (u16)value);
1771 if (ret < 0)
1772 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
1773
1774 wl1271_ps_elp_sleep(wl);
1775
1776out:
1777 mutex_unlock(&wl->mutex);
1778
1779 return ret;
1780}
1781
f5fc0f86
LC		 1782static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1783{
1784 struct wl1271 *wl = hw->priv;
aecb0565 1785 int ret = 0;
f5fc0f86
LC		 1786
1787 mutex_lock(&wl->mutex);
1788
f8d9802f
JO		 1789 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1790 ret = -EAGAIN;
aecb0565 1791 goto out;
f8d9802f 1792 }
aecb0565 1793
f5fc0f86
LC		 1794 ret = wl1271_ps_elp_wakeup(wl, false);
1795 if (ret < 0)
1796 goto out;
1797
1798 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1799 if (ret < 0)
1800 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1801
1802 wl1271_ps_elp_sleep(wl);
1803
1804out:
1805 mutex_unlock(&wl->mutex);
1806
1807 return ret;
1808}
1809
30240fc7
JO		 1810static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1811{
1812 u8 *ptr = beacon->data +
1813 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1814
1815 /* find the location of the ssid in the beacon */
1816 while (ptr < beacon->data + beacon->len) {
1817 if (ptr[0] == WLAN_EID_SSID) {
1818 wl->ssid_len = ptr[1];
1819 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1820 return;
1821 }
1822 ptr += ptr[1];
1823 }
1824 wl1271_error("ad-hoc beacon template has no SSID!\n");
1825}
1826
f5fc0f86
LC		 1827static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1828 struct ieee80211_vif *vif,
1829 struct ieee80211_bss_conf *bss_conf,
1830 u32 changed)
1831{
1832 enum wl1271_cmd_ps_mode mode;
1833 struct wl1271 *wl = hw->priv;
18357850 1834 struct ieee80211_sta *sta = ieee80211_find_sta(vif, bss_conf->bssid);
8bf29b0e 1835 bool do_join = false;
69e5434c 1836 bool set_assoc = false;
f5fc0f86
LC		 1837 int ret;
1838
1839 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1840
1841 mutex_lock(&wl->mutex);
1842
f8d9802f
JO		 1843 if (unlikely(wl->state == WL1271_STATE_OFF))
1844 goto out;
1845
f5fc0f86
LC		 1846 ret = wl1271_ps_elp_wakeup(wl, false);
1847 if (ret < 0)
1848 goto out;
1849
9ee82d54 1850 if ((changed & BSS_CHANGED_BEACON_INT) &&
60e84c2e
JO		 1851 (wl->bss_type == BSS_TYPE_IBSS)) {
1852 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1853 bss_conf->beacon_int);
1854
1855 wl->beacon_int = bss_conf->beacon_int;
1856 do_join = true;
1857 }
1858
9ee82d54 1859 if ((changed & BSS_CHANGED_BEACON) &&
5da11dcd 1860 (wl->bss_type == BSS_TYPE_IBSS)) {
e0d8bbf0
JO		 1861 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1862
5da11dcd
JO		 1863 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1864
e0d8bbf0
JO		 1865 if (beacon) {
1866 struct ieee80211_hdr *hdr;
30240fc7
JO		 1867
1868 wl1271_ssid_set(wl, beacon);
e0d8bbf0
JO		 1869 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1870 beacon->data,
606c1487
JO		 1871 beacon->len, 0,
1872 wl1271_min_rate_get(wl));
e0d8bbf0
JO		 1873
1874 if (ret < 0) {
1875 dev_kfree_skb(beacon);
1876 goto out_sleep;
1877 }
1878
1879 hdr = (struct ieee80211_hdr *) beacon->data;
1880 hdr->frame_control = cpu_to_le16(
1881 IEEE80211_FTYPE_MGMT |
1882 IEEE80211_STYPE_PROBE_RESP);
1883
1884 ret = wl1271_cmd_template_set(wl,
1885 CMD_TEMPL_PROBE_RESPONSE,
1886 beacon->data,
606c1487
JO		 1887 beacon->len, 0,
1888 wl1271_min_rate_get(wl));
e0d8bbf0
JO		 1889 dev_kfree_skb(beacon);
1890 if (ret < 0)
1891 goto out_sleep;
8bf29b0e
JO		 1892
1893 /* Need to update the SSID (for filtering etc) */
1894 do_join = true;
e0d8bbf0
JO		 1895 }
1896 }
1897
5da11dcd
JO		 1898 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1899 (wl->bss_type == BSS_TYPE_IBSS)) {
1900 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1901 bss_conf->enable_beacon ? "enabled" : "disabled");
1902
1903 if (bss_conf->enable_beacon)
1904 wl->set_bss_type = BSS_TYPE_IBSS;
1905 else
1906 wl->set_bss_type = BSS_TYPE_STA_BSS;
1907 do_join = true;
1908 }
1909
00236aed
JO		 1910 if (changed & BSS_CHANGED_CQM) {
1911 bool enable = false;
1912 if (bss_conf->cqm_rssi_thold)
1913 enable = true;
1914 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1915 bss_conf->cqm_rssi_thold,
1916 bss_conf->cqm_rssi_hyst);
1917 if (ret < 0)
1918 goto out;
1919 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1920 }
1921
30240fc7
JO		 1922 if ((changed & BSS_CHANGED_BSSID) &&
1923 /*
1924 * Now we know the correct bssid, so we send a new join command
1925 * and enable the BSSID filter
1926 */
1927 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
30240fc7 1928 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 1929
30240fc7 1930 ret = wl1271_cmd_build_null_data(wl);
a0cb7be4 1931 if (ret < 0)
30240fc7 1932 goto out_sleep;
30240fc7 1933
141418c7 1934 ret = wl1271_build_qos_null_data(wl);
a0cb7be4 1935 if (ret < 0)
30240fc7 1936 goto out_sleep;
30240fc7 1937
14b228a0
JO		 1938 /* filter out all packets not from this BSSID */
1939 wl1271_configure_filters(wl, 0);
1940
8bf29b0e
JO		 1941 /* Need to update the BSSID (for filtering etc) */
1942 do_join = true;
30240fc7
JO		 1943 }
1944
f5fc0f86
LC		 1945 if (changed & BSS_CHANGED_ASSOC) {
1946 if (bss_conf->assoc) {
ebba60c6 1947 u32 rates;
f5fc0f86 1948 wl->aid = bss_conf->aid;
69e5434c 1949 set_assoc = true;
f5fc0f86 1950
90494a90
JO		 1951 wl->ps_poll_failures = 0;
1952
ebba60c6
JO		 1953 /*
1954 * use basic rates from AP, and determine lowest rate
1955 * to use with control frames.
1956 */
1957 rates = bss_conf->basic_rates;
1958 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1959 rates);
1960 wl->basic_rate = wl1271_min_rate_get(wl);
1961 ret = wl1271_acx_rate_policies(wl);
1962 if (ret < 0)
1963 goto out_sleep;
1964
ae751bab
LC		 1965 /*
1966 * with wl1271, we don't need to update the
1967 * beacon_int and dtim_period, because the firmware
1968 * updates it by itself when the first beacon is
1969 * received after a join.
1970 */
f5fc0f86
LC		 1971 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1972 if (ret < 0)
1973 goto out_sleep;
1974
c2b2d99b
JO		 1975 /*
1976 * The SSID is intentionally set to NULL here - the
1977 * firmware will set the probe request with a
1978 * broadcast SSID regardless of what we set in the
1979 * template.
1980 */
1981 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1982 NULL, 0, wl->band);
1983
6ccbb92e
JO		 1984 /* enable the connection monitoring feature */
1985 ret = wl1271_acx_conn_monit_params(wl, true);
f5fc0f86
LC		 1986 if (ret < 0)
1987 goto out_sleep;
1988
1989 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 1990 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1991 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
f5fc0f86 1992 mode = STATION_POWER_SAVE_MODE;
65cddbf1 1993 ret = wl1271_ps_set_mode(wl, mode,
8eab7b47 1994 wl->basic_rate,
65cddbf1 1995 true);
f5fc0f86
LC		 1996 if (ret < 0)
1997 goto out_sleep;
1998 }
d94cd297
JO		 1999 } else {
2000 /* use defaults when not associated */
c2c192ac 2001 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
830fb67b 2002 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
d94cd297 2003 wl->aid = 0;
6ccbb92e 2004
8d2ef7bd 2005 /* re-enable dynamic ps - just in case */
f532be6d 2006 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 2007
ebba60c6
JO		 2008 /* revert back to minimum rates for the current band */
2009 wl1271_set_band_rate(wl);
2010 wl->basic_rate = wl1271_min_rate_get(wl);
2011 ret = wl1271_acx_rate_policies(wl);
2012 if (ret < 0)
2013 goto out_sleep;
2014
6ccbb92e
JO		 2015 /* disable connection monitor features */
2016 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 2017
2018 /* Disable the keep-alive feature */
2019 ret = wl1271_acx_keep_alive_mode(wl, false);
6ccbb92e
JO		 2020 if (ret < 0)
2021 goto out_sleep;
b84a7d3d
JO		 2022
2023 /* restore the bssid filter and go to dummy bssid */
2024 wl1271_unjoin(wl);
2025 wl1271_dummy_join(wl);
f5fc0f86 2026 }
d94cd297 2027
f5fc0f86 2028 }
8a5a37a6 2029
f5fc0f86
LC		 2030 if (changed & BSS_CHANGED_ERP_SLOT) {
2031 if (bss_conf->use_short_slot)
2032 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2033 else
2034 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2035 if (ret < 0) {
2036 wl1271_warning("Set slot time failed %d", ret);
2037 goto out_sleep;
2038 }
2039 }
2040
2041 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2042 if (bss_conf->use_short_preamble)
2043 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2044 else
2045 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2046 }
2047
2048 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2049 if (bss_conf->use_cts_prot)
2050 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2051 else
2052 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2053 if (ret < 0) {
2054 wl1271_warning("Set ctsprotect failed %d", ret);
2055 goto out_sleep;
2056 }
2057 }
2058
18357850
SL		 2059 /*
2060 * Takes care of: New association with HT enable,
2061 * HT information change in beacon.
2062 */
2063 if (sta &&
2064 (changed & BSS_CHANGED_HT) &&
2065 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2066 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true);
2067 if (ret < 0) {
2068 wl1271_warning("Set ht cap true failed %d", ret);
2069 goto out_sleep;
2070 }
2071 ret = wl1271_acx_set_ht_information(wl,
2072 bss_conf->ht_operation_mode);
2073 if (ret < 0) {
2074 wl1271_warning("Set ht information failed %d", ret);
2075 goto out_sleep;
2076 }
2077 }
2078 /*
2079 * Takes care of: New association without HT,
2080 * Disassociation.
2081 */
2082 else if (sta && (changed & BSS_CHANGED_ASSOC)) {
2083 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, false);
2084 if (ret < 0) {
2085 wl1271_warning("Set ht cap false failed %d", ret);
2086 goto out_sleep;
2087 }
2088 }
2089
ca52a5eb
JO		 2090 if (changed & BSS_CHANGED_ARP_FILTER) {
2091 __be32 addr = bss_conf->arp_addr_list[0];
2092 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2093
2094 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
2095 ret = wl1271_acx_arp_ip_filter(wl, true, addr);
2096 else
2097 ret = wl1271_acx_arp_ip_filter(wl, false, addr);
2098
2099 if (ret < 0)
2100 goto out_sleep;
2101 }
2102
8bf29b0e 2103 if (do_join) {
69e5434c 2104 ret = wl1271_join(wl, set_assoc);
8bf29b0e
JO		 2105 if (ret < 0) {
2106 wl1271_warning("cmd join failed %d", ret);
2107 goto out_sleep;
2108 }
c1899554
JO		 2109 }
2110
f5fc0f86
LC		 2111out_sleep:
2112 wl1271_ps_elp_sleep(wl);
2113
2114out:
2115 mutex_unlock(&wl->mutex);
2116}
2117
c6999d83
KV		 2118static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2119 const struct ieee80211_tx_queue_params *params)
2120{
2121 struct wl1271 *wl = hw->priv;
4695dc91 2122 u8 ps_scheme;
c6999d83
KV		 2123 int ret;
2124
2125 mutex_lock(&wl->mutex);
2126
2127 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2128
f8d9802f
JO		 2129 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2130 ret = -EAGAIN;
2131 goto out;
2132 }
2133
c82c1dde
KV		 2134 ret = wl1271_ps_elp_wakeup(wl, false);
2135 if (ret < 0)
2136 goto out;
2137
b43316db 2138 /* the txop is confed in units of 32us by the mac80211, we need us */
c6999d83
KV		 2139 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
2140 params->cw_min, params->cw_max,
b43316db 2141 params->aifs, params->txop << 5);
c6999d83 2142 if (ret < 0)
c82c1dde 2143 goto out_sleep;
c6999d83 2144
4695dc91
KV		 2145 if (params->uapsd)
2146 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2147 else
2148 ps_scheme = CONF_PS_SCHEME_LEGACY;
2149
c6999d83
KV		 2150 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
2151 CONF_CHANNEL_TYPE_EDCF,
2152 wl1271_tx_get_queue(queue),
4695dc91 2153 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
c6999d83 2154 if (ret < 0)
c82c1dde
KV		 2155 goto out_sleep;
2156
2157out_sleep:
2158 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 2159
2160out:
2161 mutex_unlock(&wl->mutex);
2162
2163 return ret;
2164}
2165
bbbb538e
JO		 2166static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2167{
2168
2169 struct wl1271 *wl = hw->priv;
2170 u64 mactime = ULLONG_MAX;
2171 int ret;
2172
2173 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2174
2175 mutex_lock(&wl->mutex);
2176
f8d9802f
JO		 2177 if (unlikely(wl->state == WL1271_STATE_OFF))
2178 goto out;
2179
bbbb538e
JO		 2180 ret = wl1271_ps_elp_wakeup(wl, false);
2181 if (ret < 0)
2182 goto out;
2183
2184 ret = wl1271_acx_tsf_info(wl, &mactime);
2185 if (ret < 0)
2186 goto out_sleep;
2187
2188out_sleep:
2189 wl1271_ps_elp_sleep(wl);
2190
2191out:
2192 mutex_unlock(&wl->mutex);
2193 return mactime;
2194}
f5fc0f86 2195
ece550d0
JL		 2196static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2197 struct survey_info *survey)
2198{
2199 struct wl1271 *wl = hw->priv;
2200 struct ieee80211_conf *conf = &hw->conf;
b739a42c 2201
ece550d0
JL		 2202 if (idx != 0)
2203 return -ENOENT;
b739a42c 2204
ece550d0
JL		 2205 survey->channel = conf->channel;
2206 survey->filled = SURVEY_INFO_NOISE_DBM;
2207 survey->noise = wl->noise;
b739a42c 2208
ece550d0
JL		 2209 return 0;
2210}
2211
f5fc0f86
LC		 2212/* can't be const, mac80211 writes to this */
2213static struct ieee80211_rate wl1271_rates[] = {
2214 { .bitrate = 10,
2b60100b
JO		 2215 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2216 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 2217 { .bitrate = 20,
2b60100b
JO		 2218 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2219 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 2220 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2221 { .bitrate = 55,
2b60100b
JO		 2222 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2223 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 2224 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2225 { .bitrate = 110,
2b60100b
JO		 2226 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2227 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 2228 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2229 { .bitrate = 60,
2b60100b
JO		 2230 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2231 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 2232 { .bitrate = 90,
2b60100b
JO		 2233 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2234 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 2235 { .bitrate = 120,
2b60100b
JO		 2236 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2237 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 2238 { .bitrate = 180,
2b60100b
JO		 2239 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2240 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 2241 { .bitrate = 240,
2b60100b
JO		 2242 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2243 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 2244 { .bitrate = 360,
2b60100b
JO		 2245 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2246 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 2247 { .bitrate = 480,
2b60100b
JO		 2248 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2249 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 2250 { .bitrate = 540,
2b60100b
JO		 2251 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2252 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 2253};
2254
fa97f46b 2255/* can't be const, mac80211 writes to this */
f5fc0f86 2256static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 2257 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
fa21c7a9 2258 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
fa97f46b
JO		 2259 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2260 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2261 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
fa21c7a9 2262 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
fa97f46b
JO		 2263 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2264 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2265 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
fa21c7a9 2266 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
fa97f46b
JO		 2267 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2268 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2269 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
f5fc0f86
LC		 2270};
2271
f876bb9a 2272/* mapping to indexes for wl1271_rates */
a0ea9493 2273static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a 2274 /* MCS rates are used only with 11n */
18357850
SL		 2275 7, /* CONF_HW_RXTX_RATE_MCS7 */
2276 6, /* CONF_HW_RXTX_RATE_MCS6 */
2277 5, /* CONF_HW_RXTX_RATE_MCS5 */
2278 4, /* CONF_HW_RXTX_RATE_MCS4 */
2279 3, /* CONF_HW_RXTX_RATE_MCS3 */
2280 2, /* CONF_HW_RXTX_RATE_MCS2 */
2281 1, /* CONF_HW_RXTX_RATE_MCS1 */
2282 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 2283
2284 11, /* CONF_HW_RXTX_RATE_54 */
2285 10, /* CONF_HW_RXTX_RATE_48 */
2286 9, /* CONF_HW_RXTX_RATE_36 */
2287 8, /* CONF_HW_RXTX_RATE_24 */
2288
2289 /* TI-specific rate */
2290 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2291
2292 7, /* CONF_HW_RXTX_RATE_18 */
2293 6, /* CONF_HW_RXTX_RATE_12 */
2294 3, /* CONF_HW_RXTX_RATE_11 */
2295 5, /* CONF_HW_RXTX_RATE_9 */
2296 4, /* CONF_HW_RXTX_RATE_6 */
2297 2, /* CONF_HW_RXTX_RATE_5_5 */
2298 1, /* CONF_HW_RXTX_RATE_2 */
2299 0 /* CONF_HW_RXTX_RATE_1 */
2300};
2301
e8b03a2b
SL		 2302/* 11n STA capabilities */
2303#define HW_RX_HIGHEST_RATE 72
2304
00d20100
SL		 2305#ifdef CONFIG_WL12XX_HT
2306#define WL12XX_HT_CAP { \
e8b03a2b
SL		 2307 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
2308 .ht_supported = true, \
2309 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
2310 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
2311 .mcs = { \
2312 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
2313 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
2314 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
2315 }, \
2316}
18357850 2317#else
00d20100 2318#define WL12XX_HT_CAP { \
18357850
SL		 2319 .ht_supported = false, \
2320}
2321#endif
e8b03a2b 2322
f5fc0f86
LC		 2323/* can't be const, mac80211 writes to this */
2324static struct ieee80211_supported_band wl1271_band_2ghz = {
2325 .channels = wl1271_channels,
2326 .n_channels = ARRAY_SIZE(wl1271_channels),
2327 .bitrates = wl1271_rates,
2328 .n_bitrates = ARRAY_SIZE(wl1271_rates),
00d20100 2329 .ht_cap = WL12XX_HT_CAP,
f5fc0f86
LC		 2330};
2331
1ebec3d7
TP		 2332/* 5 GHz data rates for WL1273 */
2333static struct ieee80211_rate wl1271_rates_5ghz[] = {
2334 { .bitrate = 60,
2335 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2336 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2337 { .bitrate = 90,
2338 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2339 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2340 { .bitrate = 120,
2341 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2342 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2343 { .bitrate = 180,
2344 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2345 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2346 { .bitrate = 240,
2347 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2348 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2349 { .bitrate = 360,
2350 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2351 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2352 { .bitrate = 480,
2353 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2354 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2355 { .bitrate = 540,
2356 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2357 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2358};
2359
fa97f46b 2360/* 5 GHz band channels for WL1273 */
1ebec3d7
TP		 2361static struct ieee80211_channel wl1271_channels_5ghz[] = {
2362 { .hw_value = 183, .center_freq = 4915},
fa21c7a9 2363 { .hw_value = 184, .center_freq = 4920},
fa97f46b
JO		 2364 { .hw_value = 185, .center_freq = 4925},
2365 { .hw_value = 187, .center_freq = 4935},
2366 { .hw_value = 188, .center_freq = 4940},
fa21c7a9 2367 { .hw_value = 189, .center_freq = 4945},
fa21c7a9 2368 { .hw_value = 192, .center_freq = 4960},
fa21c7a9 2369 { .hw_value = 196, .center_freq = 4980},
fa21c7a9 2370 { .hw_value = 7, .center_freq = 5035},
fa97f46b
JO		 2371 { .hw_value = 8, .center_freq = 5040},
2372 { .hw_value = 9, .center_freq = 5045},
2373 { .hw_value = 11, .center_freq = 5055},
2374 { .hw_value = 12, .center_freq = 5060},
fa21c7a9 2375 { .hw_value = 16, .center_freq = 5080},
fa97f46b
JO		 2376 { .hw_value = 34, .center_freq = 5170},
2377 { .hw_value = 36, .center_freq = 5180},
2378 { .hw_value = 38, .center_freq = 5190},
2379 { .hw_value = 40, .center_freq = 5200},
fa21c7a9 2380 { .hw_value = 42, .center_freq = 5210},
fa97f46b
JO		 2381 { .hw_value = 44, .center_freq = 5220},
2382 { .hw_value = 46, .center_freq = 5230},
2383 { .hw_value = 48, .center_freq = 5240},
2384 { .hw_value = 52, .center_freq = 5260},
fa21c7a9 2385 { .hw_value = 56, .center_freq = 5280},
fa97f46b
JO		 2386 { .hw_value = 60, .center_freq = 5300},
2387 { .hw_value = 64, .center_freq = 5320},
2388 { .hw_value = 100, .center_freq = 5500},
2389 { .hw_value = 104, .center_freq = 5520},
fa21c7a9 2390 { .hw_value = 108, .center_freq = 5540},
fa97f46b
JO		 2391 { .hw_value = 112, .center_freq = 5560},
2392 { .hw_value = 116, .center_freq = 5580},
2393 { .hw_value = 120, .center_freq = 5600},
2394 { .hw_value = 124, .center_freq = 5620},
fa21c7a9 2395 { .hw_value = 128, .center_freq = 5640},
fa97f46b
JO		 2396 { .hw_value = 132, .center_freq = 5660},
2397 { .hw_value = 136, .center_freq = 5680},
2398 { .hw_value = 140, .center_freq = 5700},
2399 { .hw_value = 149, .center_freq = 5745},
fa21c7a9 2400 { .hw_value = 153, .center_freq = 5765},
fa97f46b
JO		 2401 { .hw_value = 157, .center_freq = 5785},
2402 { .hw_value = 161, .center_freq = 5805},
1ebec3d7
TP		 2403 { .hw_value = 165, .center_freq = 5825},
2404};
2405
f876bb9a 2406/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 2407static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a 2408 /* MCS rates are used only with 11n */
18357850
SL		 2409 7, /* CONF_HW_RXTX_RATE_MCS7 */
2410 6, /* CONF_HW_RXTX_RATE_MCS6 */
2411 5, /* CONF_HW_RXTX_RATE_MCS5 */
2412 4, /* CONF_HW_RXTX_RATE_MCS4 */
2413 3, /* CONF_HW_RXTX_RATE_MCS3 */
2414 2, /* CONF_HW_RXTX_RATE_MCS2 */
2415 1, /* CONF_HW_RXTX_RATE_MCS1 */
2416 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 2417
2418 7, /* CONF_HW_RXTX_RATE_54 */
2419 6, /* CONF_HW_RXTX_RATE_48 */
2420 5, /* CONF_HW_RXTX_RATE_36 */
2421 4, /* CONF_HW_RXTX_RATE_24 */
2422
2423 /* TI-specific rate */
2424 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2425
2426 3, /* CONF_HW_RXTX_RATE_18 */
2427 2, /* CONF_HW_RXTX_RATE_12 */
2428 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2429 1, /* CONF_HW_RXTX_RATE_9 */
2430 0, /* CONF_HW_RXTX_RATE_6 */
2431 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2432 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2433 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2434};
1ebec3d7
TP		 2435
2436static struct ieee80211_supported_band wl1271_band_5ghz = {
2437 .channels = wl1271_channels_5ghz,
2438 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2439 .bitrates = wl1271_rates_5ghz,
2440 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
00d20100 2441 .ht_cap = WL12XX_HT_CAP,
1ebec3d7
TP		 2442};
2443
a0ea9493 2444static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 2445 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2446 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2447};
2448
f5fc0f86
LC		 2449static const struct ieee80211_ops wl1271_ops = {
2450 .start = wl1271_op_start,
2451 .stop = wl1271_op_stop,
2452 .add_interface = wl1271_op_add_interface,
2453 .remove_interface = wl1271_op_remove_interface,
2454 .config = wl1271_op_config,
c87dec9f 2455 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 2456 .configure_filter = wl1271_op_configure_filter,
2457 .tx = wl1271_op_tx,
2458 .set_key = wl1271_op_set_key,
2459 .hw_scan = wl1271_op_hw_scan,
2460 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 2461 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 2462 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 2463 .conf_tx = wl1271_op_conf_tx,
bbbb538e 2464 .get_tsf = wl1271_op_get_tsf,
ece550d0 2465 .get_survey = wl1271_op_get_survey,
c8c90873 2466 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 2467};
2468
f876bb9a 2469
6a2de93b 2470u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
f876bb9a
JO		 2471{
2472 u8 idx;
2473
6a2de93b 2474 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
f876bb9a
JO		 2475
2476 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2477 wl1271_error("Illegal RX rate from HW: %d", rate);
2478 return 0;
2479 }
2480
6a2de93b 2481 idx = wl1271_band_rate_to_idx[band][rate];
f876bb9a
JO		 2482 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2483 wl1271_error("Unsupported RX rate from HW: %d", rate);
2484 return 0;
2485 }
2486
2487 return idx;
2488}
2489
7fc3a864
JO		 2490static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2491 struct device_attribute *attr,
2492 char *buf)
2493{
2494 struct wl1271 *wl = dev_get_drvdata(dev);
2495 ssize_t len;
2496
2f63b011 2497 len = PAGE_SIZE;
7fc3a864
JO		 2498
2499 mutex_lock(&wl->mutex);
2500 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2501 wl->sg_enabled);
2502 mutex_unlock(&wl->mutex);
2503
2504 return len;
2505
2506}
2507
2508static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2509 struct device_attribute *attr,
2510 const char *buf, size_t count)
2511{
2512 struct wl1271 *wl = dev_get_drvdata(dev);
2513 unsigned long res;
2514 int ret;
2515
2516 ret = strict_strtoul(buf, 10, &res);
2517
2518 if (ret < 0) {
2519 wl1271_warning("incorrect value written to bt_coex_mode");
2520 return count;
2521 }
2522
2523 mutex_lock(&wl->mutex);
2524
2525 res = !!res;
2526
2527 if (res == wl->sg_enabled)
2528 goto out;
2529
2530 wl->sg_enabled = res;
2531
2532 if (wl->state == WL1271_STATE_OFF)
2533 goto out;
2534
2535 ret = wl1271_ps_elp_wakeup(wl, false);
2536 if (ret < 0)
2537 goto out;
2538
2539 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2540 wl1271_ps_elp_sleep(wl);
2541
2542 out:
2543 mutex_unlock(&wl->mutex);
2544 return count;
2545}
2546
2547static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2548 wl1271_sysfs_show_bt_coex_state,
2549 wl1271_sysfs_store_bt_coex_state);
2550
d717fd61
JO		 2551static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2552 struct device_attribute *attr,
2553 char *buf)
2554{
2555 struct wl1271 *wl = dev_get_drvdata(dev);
2556 ssize_t len;
2557
2f63b011 2558 len = PAGE_SIZE;
d717fd61
JO		 2559
2560 mutex_lock(&wl->mutex);
2561 if (wl->hw_pg_ver >= 0)
2562 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2563 else
2564 len = snprintf(buf, len, "n/a\n");
2565 mutex_unlock(&wl->mutex);
2566
2567 return len;
2568}
2569
2570static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2571 wl1271_sysfs_show_hw_pg_ver, NULL);
2572
2d5e82b8 2573int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 2574{
2575 int ret;
2576
2577 if (wl->mac80211_registered)
2578 return 0;
2579
2580 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2581
2582 ret = ieee80211_register_hw(wl->hw);
2583 if (ret < 0) {
2584 wl1271_error("unable to register mac80211 hw: %d", ret);
2585 return ret;
2586 }
2587
2588 wl->mac80211_registered = true;
2589
c2c192ac
JO		 2590 register_netdevice_notifier(&wl1271_dev_notifier);
2591
f5fc0f86
LC		 2592 wl1271_notice("loaded");
2593
2594 return 0;
2595}
50b3eb4b 2596EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 2597
3b56dd6a
TP		 2598void wl1271_unregister_hw(struct wl1271 *wl)
2599{
c2c192ac 2600 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 2601 ieee80211_unregister_hw(wl->hw);
2602 wl->mac80211_registered = false;
2603
2604}
2605EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2606
2d5e82b8 2607int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 2608{
7a55724e
JO		 2609 static const u32 cipher_suites[] = {
2610 WLAN_CIPHER_SUITE_WEP40,
2611 WLAN_CIPHER_SUITE_WEP104,
2612 WLAN_CIPHER_SUITE_TKIP,
2613 WLAN_CIPHER_SUITE_CCMP,
2614 WL1271_CIPHER_SUITE_GEM,
2615 };
2616
1e2b7976
JO		 2617 /* The tx descriptor buffer and the TKIP space. */
2618 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2619 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 2620
2621 /* unit us */
2622 /* FIXME: find a proper value */
2623 wl->hw->channel_change_time = 10000;
50c500ad 2624 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 2625
2626 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 2627 IEEE80211_HW_BEACON_FILTER |
0a34332f 2628 IEEE80211_HW_SUPPORTS_PS |
4695dc91 2629 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 2630 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed
JO		 2631 IEEE80211_HW_CONNECTION_MONITOR |
2632 IEEE80211_HW_SUPPORTS_CQM_RSSI;
f5fc0f86 2633
7a55724e
JO		 2634 wl->hw->wiphy->cipher_suites = cipher_suites;
2635 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
2636
e0d8bbf0
JO		 2637 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2638 BIT(NL80211_IFTYPE_ADHOC);
f5fc0f86
LC		 2639 wl->hw->wiphy->max_scan_ssids = 1;
2640 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
11eb5429 2641 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
1ebec3d7 2642
12bd8949 2643 wl->hw->queues = 4;
31627dc5 2644 wl->hw->max_rates = 1;
12bd8949 2645
b7417d93
JO		 2646 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
2647
8197b711 2648 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 2649
2650 return 0;
2651}
50b3eb4b 2652EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 2653
f5fc0f86 2654#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 2655
2d5e82b8 2656struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 2657{
f5fc0f86 2658 struct ieee80211_hw *hw;
3b56dd6a 2659 struct platform_device *plat_dev = NULL;
f5fc0f86 2660 struct wl1271 *wl;
a1dd8187 2661 int i, ret;
1f37cbc9 2662 unsigned int order;
f5fc0f86
LC		 2663
2664 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2665 if (!hw) {
2666 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 2667 ret = -ENOMEM;
3b56dd6a
TP		 2668 goto err_hw_alloc;
2669 }
2670
929ebd30 2671 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3b56dd6a
TP		 2672 if (!plat_dev) {
2673 wl1271_error("could not allocate platform_device");
2674 ret = -ENOMEM;
2675 goto err_plat_alloc;
f5fc0f86
LC		 2676 }
2677
2678 wl = hw->priv;
2679 memset(wl, 0, sizeof(*wl));
2680
01c09162
JO		 2681 INIT_LIST_HEAD(&wl->list);
2682
f5fc0f86 2683 wl->hw = hw;
3b56dd6a 2684 wl->plat_dev = plat_dev;
f5fc0f86
LC		 2685
2686 skb_queue_head_init(&wl->tx_queue);
2687
37b70a81 2688 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
90494a90 2689 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
117b38d0
JO		 2690 INIT_WORK(&wl->irq_work, wl1271_irq_work);
2691 INIT_WORK(&wl->tx_work, wl1271_tx_work);
2692 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
2693 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
f5fc0f86 2694 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 2695 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 2696 wl->default_key = 0;
f5fc0f86
LC		 2697 wl->rx_counter = 0;
2698 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2699 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
19ad0715 2700 wl->psm_entry_retry = 0;
f5fc0f86 2701 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 2702 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 2703 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b
JO		 2704 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2705 wl->sta_rate_set = 0;
8a5a37a6 2706 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 2707 wl->vif = NULL;
830fb67b 2708 wl->flags = 0;
7fc3a864 2709 wl->sg_enabled = true;
d717fd61 2710 wl->hw_pg_ver = -1;
f5fc0f86 2711
25eeb9e3 2712 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
be7078c2 2713 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 2714 wl->tx_frames[i] = NULL;
2715
2716 spin_lock_init(&wl->wl_lock);
2717
f5fc0f86
LC		 2718 wl->state = WL1271_STATE_OFF;
2719 mutex_init(&wl->mutex);
2720
c332a4b8
TP		 2721 /* Apply default driver configuration. */
2722 wl1271_conf_init(wl);
2723
2d5e82b8
TP		 2724 wl1271_debugfs_init(wl);
2725
1f37cbc9
IY		 2726 order = get_order(WL1271_AGGR_BUFFER_SIZE);
2727 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
2728 if (!wl->aggr_buf) {
2729 ret = -ENOMEM;
2730 goto err_hw;
2731 }
2732
a1dd8187 2733 /* Register platform device */
3b56dd6a 2734 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 2735 if (ret) {
2736 wl1271_error("couldn't register platform device");
1f37cbc9 2737 goto err_aggr;
a1dd8187 2738 }
3b56dd6a 2739 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 2740
7fc3a864 2741 /* Create sysfs file to control bt coex state */
3b56dd6a 2742 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 2743 if (ret < 0) {
2744 wl1271_error("failed to create sysfs file bt_coex_state");
2745 goto err_platform;
2746 }
a1dd8187 2747
d717fd61
JO		 2748 /* Create sysfs file to get HW PG version */
2749 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2750 if (ret < 0) {
2751 wl1271_error("failed to create sysfs file hw_pg_ver");
2752 goto err_bt_coex_state;
2753 }
2754
c332a4b8 2755 return hw;
a1dd8187 2756
d717fd61
JO		 2757err_bt_coex_state:
2758 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2759
7fc3a864 2760err_platform:
3b56dd6a 2761 platform_device_unregister(wl->plat_dev);
7fc3a864 2762
1f37cbc9
IY		 2763err_aggr:
2764 free_pages((unsigned long)wl->aggr_buf, order);
2765
a1dd8187 2766err_hw:
3b56dd6a
TP		 2767 wl1271_debugfs_exit(wl);
2768 kfree(plat_dev);
2769
2770err_plat_alloc:
2771 ieee80211_free_hw(hw);
2772
2773err_hw_alloc:
a1dd8187 2774
a1dd8187 2775 return ERR_PTR(ret);
c332a4b8 2776}
50b3eb4b 2777EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 2778
2779int wl1271_free_hw(struct wl1271 *wl)
2780{
3b56dd6a 2781 platform_device_unregister(wl->plat_dev);
1f37cbc9
IY		 2782 free_pages((unsigned long)wl->aggr_buf,
2783 get_order(WL1271_AGGR_BUFFER_SIZE));
3b56dd6a 2784 kfree(wl->plat_dev);
c332a4b8
TP		 2785
2786 wl1271_debugfs_exit(wl);
2787
c332a4b8
TP		 2788 vfree(wl->fw);
2789 wl->fw = NULL;
2790 kfree(wl->nvs);
2791 wl->nvs = NULL;
2792
2793 kfree(wl->fw_status);
2794 kfree(wl->tx_res_if);
2795
2796 ieee80211_free_hw(wl->hw);
2797
2798 return 0;
2799}
50b3eb4b
TP		 2800EXPORT_SYMBOL_GPL(wl1271_free_hw);
2801
2802MODULE_LICENSE("GPL");
2803MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2804MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
kernel source for telekom puls (alcatel/mediatek)