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