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