projects / deliverable / linux.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
wl1271: Update TX packet life time handling with higher resolution time
[deliverable/linux.git] / drivers / net / wireless / wl12xx / wl1271_main.c
... / ...
CommitLineData
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/inetdevice.h>
32
33#include "wl1271.h"
34#include "wl12xx_80211.h"
35#include "wl1271_reg.h"
36#include "wl1271_io.h"
37#include "wl1271_event.h"
38#include "wl1271_tx.h"
39#include "wl1271_rx.h"
40#include "wl1271_ps.h"
41#include "wl1271_init.h"
42#include "wl1271_debugfs.h"
43#include "wl1271_cmd.h"
44#include "wl1271_boot.h"
45#include "wl1271_testmode.h"
46
47#define WL1271_BOOT_RETRIES 3
48
49static struct conf_drv_settings default_conf = {
50 .sg = {
51 .per_threshold = 7500,
52 .max_scan_compensation_time = 120000,
53 .nfs_sample_interval = 400,
54 .load_ratio = 50,
55 .auto_ps_mode = 0,
56 .probe_req_compensation = 170,
57 .scan_window_compensation = 50,
58 .antenna_config = 0,
59 .beacon_miss_threshold = 60,
60 .rate_adaptation_threshold = CONF_HW_BIT_RATE_12MBPS,
61 .rate_adaptation_snr = 0
62 },
63 .rx = {
64 .rx_msdu_life_time = 512000,
65 .packet_detection_threshold = 0,
66 .ps_poll_timeout = 15,
67 .upsd_timeout = 15,
68 .rts_threshold = 2347,
69 .rx_cca_threshold = 0,
70 .irq_blk_threshold = 0xFFFF,
71 .irq_pkt_threshold = 0,
72 .irq_timeout = 600,
73 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
74 },
75 .tx = {
76 .tx_energy_detection = 0,
77 .rc_conf = {
78 .enabled_rates = CONF_HW_BIT_RATE_1MBPS |
79 CONF_HW_BIT_RATE_2MBPS,
80 .short_retry_limit = 10,
81 .long_retry_limit = 10,
82 .aflags = 0
83 },
84 .ac_conf_count = 4,
85 .ac_conf = {
86 [0] = {
87 .ac = CONF_TX_AC_BE,
88 .cw_min = 15,
89 .cw_max = 63,
90 .aifsn = 3,
91 .tx_op_limit = 0,
92 },
93 [1] = {
94 .ac = CONF_TX_AC_BK,
95 .cw_min = 15,
96 .cw_max = 63,
97 .aifsn = 7,
98 .tx_op_limit = 0,
99 },
100 [2] = {
101 .ac = CONF_TX_AC_VI,
102 .cw_min = 15,
103 .cw_max = 63,
104 .aifsn = CONF_TX_AIFS_PIFS,
105 .tx_op_limit = 3008,
106 },
107 [3] = {
108 .ac = CONF_TX_AC_VO,
109 .cw_min = 15,
110 .cw_max = 63,
111 .aifsn = CONF_TX_AIFS_PIFS,
112 .tx_op_limit = 1504,
113 },
114 },
115 .tid_conf_count = 7,
116 .tid_conf = {
117 [0] = {
118 .queue_id = 0,
119 .channel_type = CONF_CHANNEL_TYPE_DCF,
120 .tsid = CONF_TX_AC_BE,
121 .ps_scheme = CONF_PS_SCHEME_LEGACY,
122 .ack_policy = CONF_ACK_POLICY_LEGACY,
123 .apsd_conf = {0, 0},
124 },
125 [1] = {
126 .queue_id = 1,
127 .channel_type = CONF_CHANNEL_TYPE_DCF,
128 .tsid = CONF_TX_AC_BE,
129 .ps_scheme = CONF_PS_SCHEME_LEGACY,
130 .ack_policy = CONF_ACK_POLICY_LEGACY,
131 .apsd_conf = {0, 0},
132 },
133 [2] = {
134 .queue_id = 2,
135 .channel_type = CONF_CHANNEL_TYPE_DCF,
136 .tsid = CONF_TX_AC_BE,
137 .ps_scheme = CONF_PS_SCHEME_LEGACY,
138 .ack_policy = CONF_ACK_POLICY_LEGACY,
139 .apsd_conf = {0, 0},
140 },
141 [3] = {
142 .queue_id = 3,
143 .channel_type = CONF_CHANNEL_TYPE_DCF,
144 .tsid = CONF_TX_AC_BE,
145 .ps_scheme = CONF_PS_SCHEME_LEGACY,
146 .ack_policy = CONF_ACK_POLICY_LEGACY,
147 .apsd_conf = {0, 0},
148 },
149 [4] = {
150 .queue_id = 4,
151 .channel_type = CONF_CHANNEL_TYPE_DCF,
152 .tsid = CONF_TX_AC_BE,
153 .ps_scheme = CONF_PS_SCHEME_LEGACY,
154 .ack_policy = CONF_ACK_POLICY_LEGACY,
155 .apsd_conf = {0, 0},
156 },
157 [5] = {
158 .queue_id = 5,
159 .channel_type = CONF_CHANNEL_TYPE_DCF,
160 .tsid = CONF_TX_AC_BE,
161 .ps_scheme = CONF_PS_SCHEME_LEGACY,
162 .ack_policy = CONF_ACK_POLICY_LEGACY,
163 .apsd_conf = {0, 0},
164 },
165 [6] = {
166 .queue_id = 6,
167 .channel_type = CONF_CHANNEL_TYPE_DCF,
168 .tsid = CONF_TX_AC_BE,
169 .ps_scheme = CONF_PS_SCHEME_LEGACY,
170 .ack_policy = CONF_ACK_POLICY_LEGACY,
171 .apsd_conf = {0, 0},
172 }
173 },
174 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
175 .tx_compl_timeout = 700,
176 .tx_compl_threshold = 4
177 },
178 .conn = {
179 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
180 .listen_interval = 0,
181 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
182 .bcn_filt_ie_count = 1,
183 .bcn_filt_ie = {
184 [0] = {
185 .ie = WLAN_EID_CHANNEL_SWITCH,
186 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
187 }
188 },
189 .synch_fail_thold = 10,
190 .bss_lose_timeout = 100,
191 .beacon_rx_timeout = 10000,
192 .broadcast_timeout = 20000,
193 .rx_broadcast_in_ps = 1,
194 .ps_poll_threshold = 20,
195 .sig_trigger_count = 2,
196 .sig_trigger = {
197 [0] = {
198 .threshold = -75,
199 .pacing = 500,
200 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
201 .type = CONF_TRIG_EVENT_TYPE_EDGE,
202 .direction = CONF_TRIG_EVENT_DIR_LOW,
203 .hysteresis = 2,
204 .index = 0,
205 .enable = 1
206 },
207 [1] = {
208 .threshold = -75,
209 .pacing = 500,
210 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
211 .type = CONF_TRIG_EVENT_TYPE_EDGE,
212 .direction = CONF_TRIG_EVENT_DIR_HIGH,
213 .hysteresis = 2,
214 .index = 1,
215 .enable = 1
216 }
217 },
218 .sig_weights = {
219 .rssi_bcn_avg_weight = 10,
220 .rssi_pkt_avg_weight = 10,
221 .snr_bcn_avg_weight = 10,
222 .snr_pkt_avg_weight = 10
223 },
224 .bet_enable = CONF_BET_MODE_ENABLE,
225 .bet_max_consecutive = 10,
226 .psm_entry_retries = 3
227 },
228 .init = {
229 .radioparam = {
230 .fem = 1,
231 }
232 },
233 .itrim = {
234 .enable = false,
235 .timeout = 50000,
236 },
237 .pm_config = {
238 .host_clk_settling_time = 5000,
239 .host_fast_wakeup_support = false
240 }
241};
242
243static LIST_HEAD(wl_list);
244
245static void wl1271_conf_init(struct wl1271 *wl)
246{
247
248 /*
249 * This function applies the default configuration to the driver. This
250 * function is invoked upon driver load (spi probe.)
251 *
252 * The configuration is stored in a run-time structure in order to
253 * facilitate for run-time adjustment of any of the parameters. Making
254 * changes to the configuration structure will apply the new values on
255 * the next interface up (wl1271_op_start.)
256 */
257
258 /* apply driver default configuration */
259 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
260}
261
262
263static int wl1271_plt_init(struct wl1271 *wl)
264{
265 struct conf_tx_ac_category *conf_ac;
266 struct conf_tx_tid *conf_tid;
267 int ret, i;
268
269 ret = wl1271_cmd_general_parms(wl);
270 if (ret < 0)
271 return ret;
272
273 ret = wl1271_cmd_radio_parms(wl);
274 if (ret < 0)
275 return ret;
276
277 ret = wl1271_init_templates_config(wl);
278 if (ret < 0)
279 return ret;
280
281 ret = wl1271_acx_init_mem_config(wl);
282 if (ret < 0)
283 return ret;
284
285 /* PHY layer config */
286 ret = wl1271_init_phy_config(wl);
287 if (ret < 0)
288 goto out_free_memmap;
289
290 ret = wl1271_acx_dco_itrim_params(wl);
291 if (ret < 0)
292 goto out_free_memmap;
293
294 /* Initialize connection monitoring thresholds */
295 ret = wl1271_acx_conn_monit_params(wl);
296 if (ret < 0)
297 goto out_free_memmap;
298
299 /* Bluetooth WLAN coexistence */
300 ret = wl1271_init_pta(wl);
301 if (ret < 0)
302 goto out_free_memmap;
303
304 /* Energy detection */
305 ret = wl1271_init_energy_detection(wl);
306 if (ret < 0)
307 goto out_free_memmap;
308
309 /* Default fragmentation threshold */
310 ret = wl1271_acx_frag_threshold(wl);
311 if (ret < 0)
312 goto out_free_memmap;
313
314 /* Default TID configuration */
315 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
316 conf_tid = &wl->conf.tx.tid_conf[i];
317 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
318 conf_tid->channel_type,
319 conf_tid->tsid,
320 conf_tid->ps_scheme,
321 conf_tid->ack_policy,
322 conf_tid->apsd_conf[0],
323 conf_tid->apsd_conf[1]);
324 if (ret < 0)
325 goto out_free_memmap;
326 }
327
328 /* Default AC configuration */
329 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
330 conf_ac = &wl->conf.tx.ac_conf[i];
331 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
332 conf_ac->cw_max, conf_ac->aifsn,
333 conf_ac->tx_op_limit);
334 if (ret < 0)
335 goto out_free_memmap;
336 }
337
338 /* Enable data path */
339 ret = wl1271_cmd_data_path(wl, 1);
340 if (ret < 0)
341 goto out_free_memmap;
342
343 /* Configure for CAM power saving (ie. always active) */
344 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
345 if (ret < 0)
346 goto out_free_memmap;
347
348 /* configure PM */
349 ret = wl1271_acx_pm_config(wl);
350 if (ret < 0)
351 goto out_free_memmap;
352
353 return 0;
354
355 out_free_memmap:
356 kfree(wl->target_mem_map);
357 wl->target_mem_map = NULL;
358
359 return ret;
360}
361
362static void wl1271_power_off(struct wl1271 *wl)
363{
364 wl->set_power(false);
365 clear_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
366}
367
368static void wl1271_power_on(struct wl1271 *wl)
369{
370 wl->set_power(true);
371 set_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
372}
373
374static void wl1271_fw_status(struct wl1271 *wl,
375 struct wl1271_fw_status *status)
376{
377 struct timespec ts;
378 u32 total = 0;
379 int i;
380
381 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
382
383 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
384 "drv_rx_counter = %d, tx_results_counter = %d)",
385 status->intr,
386 status->fw_rx_counter,
387 status->drv_rx_counter,
388 status->tx_results_counter);
389
390 /* update number of available TX blocks */
391 for (i = 0; i < NUM_TX_QUEUES; i++) {
392 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
393 wl->tx_blocks_freed[i];
394
395 wl->tx_blocks_freed[i] =
396 le32_to_cpu(status->tx_released_blks[i]);
397 wl->tx_blocks_available += cnt;
398 total += cnt;
399 }
400
401 /* if more blocks are available now, schedule some tx work */
402 if (total && !skb_queue_empty(&wl->tx_queue))
403 ieee80211_queue_work(wl->hw, &wl->tx_work);
404
405 /* update the host-chipset time offset */
406 getnstimeofday(&ts);
407 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
408 (s64)le32_to_cpu(status->fw_localtime);
409}
410
411#define WL1271_IRQ_MAX_LOOPS 10
412
413static void wl1271_irq_work(struct work_struct *work)
414{
415 int ret;
416 u32 intr;
417 int loopcount = WL1271_IRQ_MAX_LOOPS;
418 unsigned long flags;
419 struct wl1271 *wl =
420 container_of(work, struct wl1271, irq_work);
421
422 mutex_lock(&wl->mutex);
423
424 wl1271_debug(DEBUG_IRQ, "IRQ work");
425
426 if (unlikely(wl->state == WL1271_STATE_OFF))
427 goto out;
428
429 ret = wl1271_ps_elp_wakeup(wl, true);
430 if (ret < 0)
431 goto out;
432
433 spin_lock_irqsave(&wl->wl_lock, flags);
434 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
435 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
436 spin_unlock_irqrestore(&wl->wl_lock, flags);
437 loopcount--;
438
439 wl1271_fw_status(wl, wl->fw_status);
440 intr = le32_to_cpu(wl->fw_status->intr);
441 if (!intr) {
442 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
443 continue;
444 }
445
446 intr &= WL1271_INTR_MASK;
447
448 if (intr & WL1271_ACX_INTR_DATA) {
449 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
450
451 /* check for tx results */
452 if (wl->fw_status->tx_results_counter !=
453 (wl->tx_results_count & 0xff))
454 wl1271_tx_complete(wl);
455
456 wl1271_rx(wl, wl->fw_status);
457 }
458
459 if (intr & WL1271_ACX_INTR_EVENT_A) {
460 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
461 wl1271_event_handle(wl, 0);
462 }
463
464 if (intr & WL1271_ACX_INTR_EVENT_B) {
465 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
466 wl1271_event_handle(wl, 1);
467 }
468
469 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
470 wl1271_debug(DEBUG_IRQ,
471 "WL1271_ACX_INTR_INIT_COMPLETE");
472
473 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
474 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
475
476 spin_lock_irqsave(&wl->wl_lock, flags);
477 }
478
479 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
480 ieee80211_queue_work(wl->hw, &wl->irq_work);
481 else
482 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
483 spin_unlock_irqrestore(&wl->wl_lock, flags);
484
485 wl1271_ps_elp_sleep(wl);
486
487out:
488 mutex_unlock(&wl->mutex);
489}
490
491static int wl1271_fetch_firmware(struct wl1271 *wl)
492{
493 const struct firmware *fw;
494 int ret;
495
496 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
497
498 if (ret < 0) {
499 wl1271_error("could not get firmware: %d", ret);
500 return ret;
501 }
502
503 if (fw->size % 4) {
504 wl1271_error("firmware size is not multiple of 32 bits: %zu",
505 fw->size);
506 ret = -EILSEQ;
507 goto out;
508 }
509
510 wl->fw_len = fw->size;
511 wl->fw = vmalloc(wl->fw_len);
512
513 if (!wl->fw) {
514 wl1271_error("could not allocate memory for the firmware");
515 ret = -ENOMEM;
516 goto out;
517 }
518
519 memcpy(wl->fw, fw->data, wl->fw_len);
520
521 ret = 0;
522
523out:
524 release_firmware(fw);
525
526 return ret;
527}
528
529static int wl1271_update_mac_addr(struct wl1271 *wl)
530{
531 int ret = 0;
532 u8 *nvs_ptr = (u8 *)wl->nvs->nvs;
533
534 /* get mac address from the NVS */
535 wl->mac_addr[0] = nvs_ptr[11];
536 wl->mac_addr[1] = nvs_ptr[10];
537 wl->mac_addr[2] = nvs_ptr[6];
538 wl->mac_addr[3] = nvs_ptr[5];
539 wl->mac_addr[4] = nvs_ptr[4];
540 wl->mac_addr[5] = nvs_ptr[3];
541
542 /* FIXME: if it is a zero-address, we should bail out. Now, instead,
543 we randomize an address */
544 if (is_zero_ether_addr(wl->mac_addr)) {
545 static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
546 memcpy(wl->mac_addr, nokia_oui, 3);
547 get_random_bytes(wl->mac_addr + 3, 3);
548
549 /* update this address to the NVS */
550 nvs_ptr[11] = wl->mac_addr[0];
551 nvs_ptr[10] = wl->mac_addr[1];
552 nvs_ptr[6] = wl->mac_addr[2];
553 nvs_ptr[5] = wl->mac_addr[3];
554 nvs_ptr[4] = wl->mac_addr[4];
555 nvs_ptr[3] = wl->mac_addr[5];
556 }
557
558 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
559
560 return ret;
561}
562
563static int wl1271_fetch_nvs(struct wl1271 *wl)
564{
565 const struct firmware *fw;
566 int ret;
567
568 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
569
570 if (ret < 0) {
571 wl1271_error("could not get nvs file: %d", ret);
572 return ret;
573 }
574
575 if (fw->size != sizeof(struct wl1271_nvs_file)) {
576 wl1271_error("nvs size is not as expected: %zu != %zu",
577 fw->size, sizeof(struct wl1271_nvs_file));
578 ret = -EILSEQ;
579 goto out;
580 }
581
582 wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
583
584 if (!wl->nvs) {
585 wl1271_error("could not allocate memory for the nvs file");
586 ret = -ENOMEM;
587 goto out;
588 }
589
590 memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
591
592 ret = wl1271_update_mac_addr(wl);
593
594out:
595 release_firmware(fw);
596
597 return ret;
598}
599
600static void wl1271_fw_wakeup(struct wl1271 *wl)
601{
602 u32 elp_reg;
603
604 elp_reg = ELPCTRL_WAKE_UP;
605 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
606}
607
608static int wl1271_setup(struct wl1271 *wl)
609{
610 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
611 if (!wl->fw_status)
612 return -ENOMEM;
613
614 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
615 if (!wl->tx_res_if) {
616 kfree(wl->fw_status);
617 return -ENOMEM;
618 }
619
620 INIT_WORK(&wl->irq_work, wl1271_irq_work);
621 INIT_WORK(&wl->tx_work, wl1271_tx_work);
622 return 0;
623}
624
625static int wl1271_chip_wakeup(struct wl1271 *wl)
626{
627 struct wl1271_partition_set partition;
628 int ret = 0;
629
630 msleep(WL1271_PRE_POWER_ON_SLEEP);
631 wl1271_power_on(wl);
632 msleep(WL1271_POWER_ON_SLEEP);
633 wl1271_io_reset(wl);
634 wl1271_io_init(wl);
635
636 /* We don't need a real memory partition here, because we only want
637 * to use the registers at this point. */
638 memset(&partition, 0, sizeof(partition));
639 partition.reg.start = REGISTERS_BASE;
640 partition.reg.size = REGISTERS_DOWN_SIZE;
641 wl1271_set_partition(wl, &partition);
642
643 /* ELP module wake up */
644 wl1271_fw_wakeup(wl);
645
646 /* whal_FwCtrl_BootSm() */
647
648 /* 0. read chip id from CHIP_ID */
649 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
650
651 /* 1. check if chip id is valid */
652
653 switch (wl->chip.id) {
654 case CHIP_ID_1271_PG10:
655 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
656 wl->chip.id);
657
658 ret = wl1271_setup(wl);
659 if (ret < 0)
660 goto out;
661 break;
662 case CHIP_ID_1271_PG20:
663 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
664 wl->chip.id);
665
666 ret = wl1271_setup(wl);
667 if (ret < 0)
668 goto out;
669 break;
670 default:
671 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
672 ret = -ENODEV;
673 goto out;
674 }
675
676 if (wl->fw == NULL) {
677 ret = wl1271_fetch_firmware(wl);
678 if (ret < 0)
679 goto out;
680 }
681
682 /* No NVS from netlink, try to get it from the filesystem */
683 if (wl->nvs == NULL) {
684 ret = wl1271_fetch_nvs(wl);
685 if (ret < 0)
686 goto out;
687 }
688
689out:
690 return ret;
691}
692
693int wl1271_plt_start(struct wl1271 *wl)
694{
695 int retries = WL1271_BOOT_RETRIES;
696 int ret;
697
698 mutex_lock(&wl->mutex);
699
700 wl1271_notice("power up");
701
702 if (wl->state != WL1271_STATE_OFF) {
703 wl1271_error("cannot go into PLT state because not "
704 "in off state: %d", wl->state);
705 ret = -EBUSY;
706 goto out;
707 }
708
709 while (retries) {
710 retries--;
711 ret = wl1271_chip_wakeup(wl);
712 if (ret < 0)
713 goto power_off;
714
715 ret = wl1271_boot(wl);
716 if (ret < 0)
717 goto power_off;
718
719 ret = wl1271_plt_init(wl);
720 if (ret < 0)
721 goto irq_disable;
722
723 wl->state = WL1271_STATE_PLT;
724 wl1271_notice("firmware booted in PLT mode (%s)",
725 wl->chip.fw_ver);
726 goto out;
727
728irq_disable:
729 wl1271_disable_interrupts(wl);
730 mutex_unlock(&wl->mutex);
731 /* Unlocking the mutex in the middle of handling is
732 inherently unsafe. In this case we deem it safe to do,
733 because we need to let any possibly pending IRQ out of
734 the system (and while we are WL1271_STATE_OFF the IRQ
735 work function will not do anything.) Also, any other
736 possible concurrent operations will fail due to the
737 current state, hence the wl1271 struct should be safe. */
738 cancel_work_sync(&wl->irq_work);
739 mutex_lock(&wl->mutex);
740power_off:
741 wl1271_power_off(wl);
742 }
743
744 wl1271_error("firmware boot in PLT mode failed despite %d retries",
745 WL1271_BOOT_RETRIES);
746out:
747 mutex_unlock(&wl->mutex);
748
749 return ret;
750}
751
752int wl1271_plt_stop(struct wl1271 *wl)
753{
754 int ret = 0;
755
756 mutex_lock(&wl->mutex);
757
758 wl1271_notice("power down");
759
760 if (wl->state != WL1271_STATE_PLT) {
761 wl1271_error("cannot power down because not in PLT "
762 "state: %d", wl->state);
763 ret = -EBUSY;
764 goto out;
765 }
766
767 wl1271_disable_interrupts(wl);
768 wl1271_power_off(wl);
769
770 wl->state = WL1271_STATE_OFF;
771 wl->rx_counter = 0;
772
773out:
774 mutex_unlock(&wl->mutex);
775
776 return ret;
777}
778
779
780static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
781{
782 struct wl1271 *wl = hw->priv;
783 struct ieee80211_conf *conf = &hw->conf;
784 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
785 struct ieee80211_sta *sta = txinfo->control.sta;
786 unsigned long flags;
787
788 /* peek into the rates configured in the STA entry */
789 spin_lock_irqsave(&wl->wl_lock, flags);
790 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
791 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
792 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
793 }
794 spin_unlock_irqrestore(&wl->wl_lock, flags);
795
796 /* queue the packet */
797 skb_queue_tail(&wl->tx_queue, skb);
798
799 /*
800 * The chip specific setup must run before the first TX packet -
801 * before that, the tx_work will not be initialized!
802 */
803
804 ieee80211_queue_work(wl->hw, &wl->tx_work);
805
806 /*
807 * The workqueue is slow to process the tx_queue and we need stop
808 * the queue here, otherwise the queue will get too long.
809 */
810 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
811 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
812
813 spin_lock_irqsave(&wl->wl_lock, flags);
814 ieee80211_stop_queues(wl->hw);
815 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
816 spin_unlock_irqrestore(&wl->wl_lock, flags);
817 }
818
819 return NETDEV_TX_OK;
820}
821
822static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
823 void *arg)
824{
825 struct net_device *dev;
826 struct wireless_dev *wdev;
827 struct wiphy *wiphy;
828 struct ieee80211_hw *hw;
829 struct wl1271 *wl;
830 struct wl1271 *wl_temp;
831 struct in_device *idev;
832 struct in_ifaddr *ifa = arg;
833 int ret = 0;
834
835 /* FIXME: this ugly function should probably be implemented in the
836 * mac80211, and here should only be a simple callback handling actual
837 * setting of the filters. Now we need to dig up references to
838 * various structures to gain access to what we need.
839 * Also, because of this, there is no "initial" setting of the filter
840 * in "op_start", because we don't want to dig up struct net_device
841 * there - the filter will be set upon first change of the interface
842 * IP address. */
843
844 dev = ifa->ifa_dev->dev;
845
846 wdev = dev->ieee80211_ptr;
847 if (wdev == NULL)
848 return NOTIFY_DONE;
849
850 wiphy = wdev->wiphy;
851 if (wiphy == NULL)
852 return NOTIFY_DONE;
853
854 hw = wiphy_priv(wiphy);
855 if (hw == NULL)
856 return NOTIFY_DONE;
857
858 /* Check that the interface is one supported by this driver. */
859 wl_temp = hw->priv;
860 list_for_each_entry(wl, &wl_list, list) {
861 if (wl == wl_temp)
862 break;
863 }
864 if (wl == NULL)
865 return NOTIFY_DONE;
866
867 /* Get the interface IP address for the device. "ifa" will become
868 NULL if:
869 - there is no IPV4 protocol address configured
870 - there are multiple (virtual) IPV4 addresses configured
871 When "ifa" is NULL, filtering will be disabled.
872 */
873 ifa = NULL;
874 idev = dev->ip_ptr;
875 if (idev)
876 ifa = idev->ifa_list;
877
878 if (ifa && ifa->ifa_next)
879 ifa = NULL;
880
881 mutex_lock(&wl->mutex);
882
883 if (wl->state == WL1271_STATE_OFF)
884 goto out;
885
886 ret = wl1271_ps_elp_wakeup(wl, false);
887 if (ret < 0)
888 goto out;
889 if (ifa)
890 ret = wl1271_acx_arp_ip_filter(wl, true,
891 (u8 *)&ifa->ifa_address,
892 ACX_IPV4_VERSION);
893 else
894 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
895 ACX_IPV4_VERSION);
896 wl1271_ps_elp_sleep(wl);
897
898out:
899 mutex_unlock(&wl->mutex);
900
901 return NOTIFY_OK;
902}
903
904static struct notifier_block wl1271_dev_notifier = {
905 .notifier_call = wl1271_dev_notify,
906};
907
908
909static int wl1271_op_start(struct ieee80211_hw *hw)
910{
911 struct wl1271 *wl = hw->priv;
912 int retries = WL1271_BOOT_RETRIES;
913 int ret = 0;
914
915 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
916
917 mutex_lock(&wl->mutex);
918
919 if (wl->state != WL1271_STATE_OFF) {
920 wl1271_error("cannot start because not in off state: %d",
921 wl->state);
922 ret = -EBUSY;
923 goto out;
924 }
925
926 while (retries) {
927 retries--;
928 ret = wl1271_chip_wakeup(wl);
929 if (ret < 0)
930 goto power_off;
931
932 ret = wl1271_boot(wl);
933 if (ret < 0)
934 goto power_off;
935
936 ret = wl1271_hw_init(wl);
937 if (ret < 0)
938 goto irq_disable;
939
940 wl->state = WL1271_STATE_ON;
941 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
942 goto out;
943
944irq_disable:
945 wl1271_disable_interrupts(wl);
946 mutex_unlock(&wl->mutex);
947 /* Unlocking the mutex in the middle of handling is
948 inherently unsafe. In this case we deem it safe to do,
949 because we need to let any possibly pending IRQ out of
950 the system (and while we are WL1271_STATE_OFF the IRQ
951 work function will not do anything.) Also, any other
952 possible concurrent operations will fail due to the
953 current state, hence the wl1271 struct should be safe. */
954 cancel_work_sync(&wl->irq_work);
955 mutex_lock(&wl->mutex);
956power_off:
957 wl1271_power_off(wl);
958 }
959
960 wl1271_error("firmware boot failed despite %d retries",
961 WL1271_BOOT_RETRIES);
962out:
963 mutex_unlock(&wl->mutex);
964
965 if (!ret) {
966 list_add(&wl->list, &wl_list);
967 register_inetaddr_notifier(&wl1271_dev_notifier);
968 }
969
970 return ret;
971}
972
973static void wl1271_op_stop(struct ieee80211_hw *hw)
974{
975 struct wl1271 *wl = hw->priv;
976 int i;
977
978 wl1271_info("down");
979
980 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
981
982 unregister_inetaddr_notifier(&wl1271_dev_notifier);
983 list_del(&wl->list);
984
985 mutex_lock(&wl->mutex);
986
987 WARN_ON(wl->state != WL1271_STATE_ON);
988
989 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
990 mutex_unlock(&wl->mutex);
991 ieee80211_scan_completed(wl->hw, true);
992 mutex_lock(&wl->mutex);
993 }
994
995 wl->state = WL1271_STATE_OFF;
996
997 wl1271_disable_interrupts(wl);
998
999 mutex_unlock(&wl->mutex);
1000
1001 cancel_work_sync(&wl->irq_work);
1002 cancel_work_sync(&wl->tx_work);
1003
1004 mutex_lock(&wl->mutex);
1005
1006 /* let's notify MAC80211 about the remaining pending TX frames */
1007 wl1271_tx_flush(wl);
1008 wl1271_power_off(wl);
1009
1010 memset(wl->bssid, 0, ETH_ALEN);
1011 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1012 wl->ssid_len = 0;
1013 wl->bss_type = MAX_BSS_TYPE;
1014 wl->band = IEEE80211_BAND_2GHZ;
1015
1016 wl->rx_counter = 0;
1017 wl->psm_entry_retry = 0;
1018 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1019 wl->tx_blocks_available = 0;
1020 wl->tx_results_count = 0;
1021 wl->tx_packets_count = 0;
1022 wl->tx_security_last_seq = 0;
1023 wl->tx_security_seq_16 = 0;
1024 wl->tx_security_seq_32 = 0;
1025 wl->time_offset = 0;
1026 wl->session_counter = 0;
1027 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1028 wl->sta_rate_set = 0;
1029 wl->flags = 0;
1030
1031 for (i = 0; i < NUM_TX_QUEUES; i++)
1032 wl->tx_blocks_freed[i] = 0;
1033
1034 wl1271_debugfs_reset(wl);
1035 mutex_unlock(&wl->mutex);
1036}
1037
1038static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1039 struct ieee80211_vif *vif)
1040{
1041 struct wl1271 *wl = hw->priv;
1042 int ret = 0;
1043
1044 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1045 vif->type, vif->addr);
1046
1047 mutex_lock(&wl->mutex);
1048 if (wl->vif) {
1049 ret = -EBUSY;
1050 goto out;
1051 }
1052
1053 wl->vif = vif;
1054
1055 switch (vif->type) {
1056 case NL80211_IFTYPE_STATION:
1057 wl->bss_type = BSS_TYPE_STA_BSS;
1058 break;
1059 case NL80211_IFTYPE_ADHOC:
1060 wl->bss_type = BSS_TYPE_IBSS;
1061 break;
1062 default:
1063 ret = -EOPNOTSUPP;
1064 goto out;
1065 }
1066
1067 /* FIXME: what if conf->mac_addr changes? */
1068
1069out:
1070 mutex_unlock(&wl->mutex);
1071 return ret;
1072}
1073
1074static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1075 struct ieee80211_vif *vif)
1076{
1077 struct wl1271 *wl = hw->priv;
1078
1079 mutex_lock(&wl->mutex);
1080 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1081 wl->vif = NULL;
1082 mutex_unlock(&wl->mutex);
1083}
1084
1085#if 0
1086static int wl1271_op_config_interface(struct ieee80211_hw *hw,
1087 struct ieee80211_vif *vif,
1088 struct ieee80211_if_conf *conf)
1089{
1090 struct wl1271 *wl = hw->priv;
1091 struct sk_buff *beacon;
1092 int ret;
1093
1094 wl1271_debug(DEBUG_MAC80211, "mac80211 config_interface bssid %pM",
1095 conf->bssid);
1096 wl1271_dump_ascii(DEBUG_MAC80211, "ssid: ", conf->ssid,
1097 conf->ssid_len);
1098
1099 mutex_lock(&wl->mutex);
1100
1101 ret = wl1271_ps_elp_wakeup(wl, false);
1102 if (ret < 0)
1103 goto out;
1104
1105 if (memcmp(wl->bssid, conf->bssid, ETH_ALEN)) {
1106 wl1271_debug(DEBUG_MAC80211, "bssid changed");
1107
1108 memcpy(wl->bssid, conf->bssid, ETH_ALEN);
1109
1110 ret = wl1271_cmd_join(wl, wl->bss_type);
1111 if (ret < 0)
1112 goto out_sleep;
1113
1114 ret = wl1271_cmd_build_null_data(wl);
1115 if (ret < 0)
1116 goto out_sleep;
1117 }
1118
1119 wl->ssid_len = conf->ssid_len;
1120 if (wl->ssid_len)
1121 memcpy(wl->ssid, conf->ssid, wl->ssid_len);
1122
1123 if (conf->changed & IEEE80211_IFCC_BEACON) {
1124 beacon = ieee80211_beacon_get(hw, vif);
1125 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1126 beacon->data, beacon->len);
1127
1128 if (ret < 0) {
1129 dev_kfree_skb(beacon);
1130 goto out_sleep;
1131 }
1132
1133 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PROBE_RESPONSE,
1134 beacon->data, beacon->len);
1135
1136 dev_kfree_skb(beacon);
1137
1138 if (ret < 0)
1139 goto out_sleep;
1140 }
1141
1142out_sleep:
1143 wl1271_ps_elp_sleep(wl);
1144
1145out:
1146 mutex_unlock(&wl->mutex);
1147
1148 return ret;
1149}
1150#endif
1151
1152static int wl1271_join_channel(struct wl1271 *wl, int channel)
1153{
1154 int ret = 0;
1155 /* we need to use a dummy BSSID for now */
1156 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1157 0xad, 0xbe, 0xef };
1158
1159 /* disable mac filter, so we hear everything */
1160 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1161
1162 wl->channel = channel;
1163 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1164
1165 /* the dummy join is performed always with STATION BSS type to allow
1166 also ad-hoc mode to listen to the surroundings without sending any
1167 beacons yet. */
1168 ret = wl1271_cmd_join(wl, BSS_TYPE_STA_BSS);
1169 if (ret < 0)
1170 goto out;
1171
1172 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1173
1174out:
1175 return ret;
1176}
1177
1178static int wl1271_unjoin_channel(struct wl1271 *wl)
1179{
1180 int ret;
1181
1182 /* to stop listening to a channel, we disconnect */
1183 ret = wl1271_cmd_disconnect(wl);
1184 if (ret < 0)
1185 goto out;
1186
1187 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1188 wl->channel = 0;
1189 memset(wl->bssid, 0, ETH_ALEN);
1190 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1191
1192out:
1193 return ret;
1194}
1195
1196static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1197{
1198 struct wl1271 *wl = hw->priv;
1199 struct ieee80211_conf *conf = &hw->conf;
1200 int channel, ret = 0;
1201
1202 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1203
1204 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1205 channel,
1206 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1207 conf->power_level,
1208 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1209
1210 mutex_lock(&wl->mutex);
1211
1212 wl->band = conf->channel->band;
1213
1214 ret = wl1271_ps_elp_wakeup(wl, false);
1215 if (ret < 0)
1216 goto out;
1217
1218 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1219 if (conf->flags & IEEE80211_CONF_IDLE &&
1220 test_bit(WL1271_FLAG_JOINED, &wl->flags))
1221 wl1271_unjoin_channel(wl);
1222 else if (!(conf->flags & IEEE80211_CONF_IDLE))
1223 wl1271_join_channel(wl, channel);
1224
1225 if (conf->flags & IEEE80211_CONF_IDLE) {
1226 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1227 wl->sta_rate_set = 0;
1228 wl1271_acx_rate_policies(wl);
1229 }
1230 }
1231
1232 /* if the channel changes while joined, join again */
1233 if (channel != wl->channel &&
1234 test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1235 wl->channel = channel;
1236 /* FIXME: maybe use CMD_CHANNEL_SWITCH for this? */
1237 ret = wl1271_cmd_join(wl, wl->bss_type);
1238 if (ret < 0)
1239 wl1271_warning("cmd join to update channel failed %d",
1240 ret);
1241 } else
1242 wl->channel = channel;
1243
1244 if (conf->flags & IEEE80211_CONF_PS &&
1245 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1246 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1247
1248 /*
1249 * We enter PSM only if we're already associated.
1250 * If we're not, we'll enter it when joining an SSID,
1251 * through the bss_info_changed() hook.
1252 */
1253 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1254 wl1271_debug(DEBUG_PSM, "psm enabled");
1255 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1256 true);
1257 }
1258 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1259 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1260 wl1271_debug(DEBUG_PSM, "psm disabled");
1261
1262 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1263
1264 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1265 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1266 true);
1267 }
1268
1269 if (conf->power_level != wl->power_level) {
1270 ret = wl1271_acx_tx_power(wl, conf->power_level);
1271 if (ret < 0)
1272 goto out_sleep;
1273
1274 wl->power_level = conf->power_level;
1275 }
1276
1277out_sleep:
1278 wl1271_ps_elp_sleep(wl);
1279
1280out:
1281 mutex_unlock(&wl->mutex);
1282
1283 return ret;
1284}
1285
1286struct wl1271_filter_params {
1287 bool enabled;
1288 int mc_list_length;
1289 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1290};
1291
1292static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1293 struct dev_addr_list *mc_list)
1294{
1295 struct wl1271_filter_params *fp;
1296 int i;
1297
1298 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1299 if (!fp) {
1300 wl1271_error("Out of memory setting filters.");
1301 return 0;
1302 }
1303
1304 /* update multicast filtering parameters */
1305 fp->enabled = true;
1306 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1307 mc_count = 0;
1308 fp->enabled = false;
1309 }
1310
1311 fp->mc_list_length = 0;
1312 for (i = 0; i < mc_count; i++) {
1313 if (mc_list->da_addrlen == ETH_ALEN) {
1314 memcpy(fp->mc_list[fp->mc_list_length],
1315 mc_list->da_addr, ETH_ALEN);
1316 fp->mc_list_length++;
1317 } else
1318 wl1271_warning("Unknown mc address length.");
1319 mc_list = mc_list->next;
1320 }
1321
1322 return (u64)(unsigned long)fp;
1323}
1324
1325#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1326 FIF_ALLMULTI | \
1327 FIF_FCSFAIL | \
1328 FIF_BCN_PRBRESP_PROMISC | \
1329 FIF_CONTROL | \
1330 FIF_OTHER_BSS)
1331
1332static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1333 unsigned int changed,
1334 unsigned int *total, u64 multicast)
1335{
1336 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1337 struct wl1271 *wl = hw->priv;
1338 int ret;
1339
1340 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1341
1342 mutex_lock(&wl->mutex);
1343
1344 if (wl->state == WL1271_STATE_OFF)
1345 goto out;
1346
1347 ret = wl1271_ps_elp_wakeup(wl, false);
1348 if (ret < 0)
1349 goto out;
1350
1351 *total &= WL1271_SUPPORTED_FILTERS;
1352 changed &= WL1271_SUPPORTED_FILTERS;
1353
1354 if (*total & FIF_ALLMULTI)
1355 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1356 else if (fp)
1357 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1358 fp->mc_list,
1359 fp->mc_list_length);
1360 if (ret < 0)
1361 goto out_sleep;
1362
1363 kfree(fp);
1364
1365 /* FIXME: We still need to set our filters properly */
1366
1367 /* determine, whether supported filter values have changed */
1368 if (changed == 0)
1369 goto out_sleep;
1370
1371 /* apply configured filters */
1372 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1373 if (ret < 0)
1374 goto out_sleep;
1375
1376out_sleep:
1377 wl1271_ps_elp_sleep(wl);
1378
1379out:
1380 mutex_unlock(&wl->mutex);
1381}
1382
1383static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1384 struct ieee80211_vif *vif,
1385 struct ieee80211_sta *sta,
1386 struct ieee80211_key_conf *key_conf)
1387{
1388 struct wl1271 *wl = hw->priv;
1389 const u8 *addr;
1390 int ret;
1391 u32 tx_seq_32 = 0;
1392 u16 tx_seq_16 = 0;
1393 u8 key_type;
1394
1395 static const u8 bcast_addr[ETH_ALEN] =
1396 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1397
1398 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1399
1400 addr = sta ? sta->addr : bcast_addr;
1401
1402 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1403 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1404 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1405 key_conf->alg, key_conf->keyidx,
1406 key_conf->keylen, key_conf->flags);
1407 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1408
1409 if (is_zero_ether_addr(addr)) {
1410 /* We dont support TX only encryption */
1411 ret = -EOPNOTSUPP;
1412 goto out;
1413 }
1414
1415 mutex_lock(&wl->mutex);
1416
1417 ret = wl1271_ps_elp_wakeup(wl, false);
1418 if (ret < 0)
1419 goto out_unlock;
1420
1421 switch (key_conf->alg) {
1422 case ALG_WEP:
1423 key_type = KEY_WEP;
1424
1425 key_conf->hw_key_idx = key_conf->keyidx;
1426 break;
1427 case ALG_TKIP:
1428 key_type = KEY_TKIP;
1429
1430 key_conf->hw_key_idx = key_conf->keyidx;
1431 tx_seq_32 = wl->tx_security_seq_32;
1432 tx_seq_16 = wl->tx_security_seq_16;
1433 break;
1434 case ALG_CCMP:
1435 key_type = KEY_AES;
1436
1437 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1438 tx_seq_32 = wl->tx_security_seq_32;
1439 tx_seq_16 = wl->tx_security_seq_16;
1440 break;
1441 default:
1442 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1443
1444 ret = -EOPNOTSUPP;
1445 goto out_sleep;
1446 }
1447
1448 switch (cmd) {
1449 case SET_KEY:
1450 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1451 key_conf->keyidx, key_type,
1452 key_conf->keylen, key_conf->key,
1453 addr, tx_seq_32, tx_seq_16);
1454 if (ret < 0) {
1455 wl1271_error("Could not add or replace key");
1456 goto out_sleep;
1457 }
1458
1459 /* the default WEP key needs to be configured at least once */
1460 if (key_type == KEY_WEP) {
1461 ret = wl1271_cmd_set_default_wep_key(wl,
1462 wl->default_key);
1463 if (ret < 0)
1464 goto out_sleep;
1465 }
1466 break;
1467
1468 case DISABLE_KEY:
1469 /* The wl1271 does not allow to remove unicast keys - they
1470 will be cleared automatically on next CMD_JOIN. Ignore the
1471 request silently, as we dont want the mac80211 to emit
1472 an error message. */
1473 if (!is_broadcast_ether_addr(addr))
1474 break;
1475
1476 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1477 key_conf->keyidx, key_type,
1478 key_conf->keylen, key_conf->key,
1479 addr, 0, 0);
1480 if (ret < 0) {
1481 wl1271_error("Could not remove key");
1482 goto out_sleep;
1483 }
1484 break;
1485
1486 default:
1487 wl1271_error("Unsupported key cmd 0x%x", cmd);
1488 ret = -EOPNOTSUPP;
1489 goto out_sleep;
1490
1491 break;
1492 }
1493
1494out_sleep:
1495 wl1271_ps_elp_sleep(wl);
1496
1497out_unlock:
1498 mutex_unlock(&wl->mutex);
1499
1500out:
1501 return ret;
1502}
1503
1504static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1505 struct cfg80211_scan_request *req)
1506{
1507 struct wl1271 *wl = hw->priv;
1508 int ret;
1509 u8 *ssid = NULL;
1510 size_t len = 0;
1511
1512 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1513
1514 if (req->n_ssids) {
1515 ssid = req->ssids[0].ssid;
1516 len = req->ssids[0].ssid_len;
1517 }
1518
1519 mutex_lock(&wl->mutex);
1520
1521 ret = wl1271_ps_elp_wakeup(wl, false);
1522 if (ret < 0)
1523 goto out;
1524
1525 if (wl1271_11a_enabled())
1526 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1527 WL1271_SCAN_BAND_DUAL, 3);
1528 else
1529 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1530 WL1271_SCAN_BAND_2_4_GHZ, 3);
1531
1532 wl1271_ps_elp_sleep(wl);
1533
1534out:
1535 mutex_unlock(&wl->mutex);
1536
1537 return ret;
1538}
1539
1540static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1541{
1542 struct wl1271 *wl = hw->priv;
1543 int ret;
1544
1545 mutex_lock(&wl->mutex);
1546
1547 ret = wl1271_ps_elp_wakeup(wl, false);
1548 if (ret < 0)
1549 goto out;
1550
1551 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1552 if (ret < 0)
1553 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1554
1555 wl1271_ps_elp_sleep(wl);
1556
1557out:
1558 mutex_unlock(&wl->mutex);
1559
1560 return ret;
1561}
1562
1563static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1564{
1565 u8 *ptr = beacon->data +
1566 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1567
1568 /* find the location of the ssid in the beacon */
1569 while (ptr < beacon->data + beacon->len) {
1570 if (ptr[0] == WLAN_EID_SSID) {
1571 wl->ssid_len = ptr[1];
1572 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1573 return;
1574 }
1575 ptr += ptr[1];
1576 }
1577 wl1271_error("ad-hoc beacon template has no SSID!\n");
1578}
1579
1580static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1581 struct ieee80211_vif *vif,
1582 struct ieee80211_bss_conf *bss_conf,
1583 u32 changed)
1584{
1585 enum wl1271_cmd_ps_mode mode;
1586 struct wl1271 *wl = hw->priv;
1587 bool do_join = false;
1588 int ret;
1589
1590 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1591
1592 mutex_lock(&wl->mutex);
1593
1594 ret = wl1271_ps_elp_wakeup(wl, false);
1595 if (ret < 0)
1596 goto out;
1597
1598 if (wl->bss_type == BSS_TYPE_IBSS) {
1599 /* FIXME: This implements rudimentary ad-hoc support -
1600 proper templates are on the wish list and notification
1601 on when they change. This patch will update the templates
1602 on every call to this function. */
1603 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1604
1605 if (beacon) {
1606 struct ieee80211_hdr *hdr;
1607
1608 wl1271_ssid_set(wl, beacon);
1609 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1610 beacon->data,
1611 beacon->len);
1612
1613 if (ret < 0) {
1614 dev_kfree_skb(beacon);
1615 goto out_sleep;
1616 }
1617
1618 hdr = (struct ieee80211_hdr *) beacon->data;
1619 hdr->frame_control = cpu_to_le16(
1620 IEEE80211_FTYPE_MGMT |
1621 IEEE80211_STYPE_PROBE_RESP);
1622
1623 ret = wl1271_cmd_template_set(wl,
1624 CMD_TEMPL_PROBE_RESPONSE,
1625 beacon->data,
1626 beacon->len);
1627 dev_kfree_skb(beacon);
1628 if (ret < 0)
1629 goto out_sleep;
1630
1631 /* Need to update the SSID (for filtering etc) */
1632 do_join = true;
1633 }
1634 }
1635
1636 if ((changed & BSS_CHANGED_BSSID) &&
1637 /*
1638 * Now we know the correct bssid, so we send a new join command
1639 * and enable the BSSID filter
1640 */
1641 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1642 wl->rx_config |= CFG_BSSID_FILTER_EN;
1643 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1644 ret = wl1271_cmd_build_null_data(wl);
1645 if (ret < 0) {
1646 wl1271_warning("cmd buld null data failed %d",
1647 ret);
1648 goto out_sleep;
1649 }
1650
1651 /* Need to update the BSSID (for filtering etc) */
1652 do_join = true;
1653 }
1654
1655 if (changed & BSS_CHANGED_ASSOC) {
1656 if (bss_conf->assoc) {
1657 wl->aid = bss_conf->aid;
1658 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1659
1660 /*
1661 * with wl1271, we don't need to update the
1662 * beacon_int and dtim_period, because the firmware
1663 * updates it by itself when the first beacon is
1664 * received after a join.
1665 */
1666 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1667 if (ret < 0)
1668 goto out_sleep;
1669
1670 ret = wl1271_acx_aid(wl, wl->aid);
1671 if (ret < 0)
1672 goto out_sleep;
1673
1674 /* If we want to go in PSM but we're not there yet */
1675 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1676 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1677 mode = STATION_POWER_SAVE_MODE;
1678 ret = wl1271_ps_set_mode(wl, mode, true);
1679 if (ret < 0)
1680 goto out_sleep;
1681 }
1682 } else {
1683 /* use defaults when not associated */
1684 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1685 wl->aid = 0;
1686 }
1687
1688 }
1689
1690 if (changed & BSS_CHANGED_ERP_SLOT) {
1691 if (bss_conf->use_short_slot)
1692 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1693 else
1694 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1695 if (ret < 0) {
1696 wl1271_warning("Set slot time failed %d", ret);
1697 goto out_sleep;
1698 }
1699 }
1700
1701 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1702 if (bss_conf->use_short_preamble)
1703 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1704 else
1705 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1706 }
1707
1708 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1709 if (bss_conf->use_cts_prot)
1710 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1711 else
1712 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1713 if (ret < 0) {
1714 wl1271_warning("Set ctsprotect failed %d", ret);
1715 goto out_sleep;
1716 }
1717 }
1718
1719 if (do_join) {
1720 ret = wl1271_cmd_join(wl, wl->bss_type);
1721 if (ret < 0) {
1722 wl1271_warning("cmd join failed %d", ret);
1723 goto out_sleep;
1724 }
1725 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1726 }
1727
1728out_sleep:
1729 wl1271_ps_elp_sleep(wl);
1730
1731out:
1732 mutex_unlock(&wl->mutex);
1733}
1734
1735static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1736 const struct ieee80211_tx_queue_params *params)
1737{
1738 struct wl1271 *wl = hw->priv;
1739 int ret;
1740
1741 mutex_lock(&wl->mutex);
1742
1743 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1744
1745 ret = wl1271_ps_elp_wakeup(wl, false);
1746 if (ret < 0)
1747 goto out;
1748
1749 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1750 params->cw_min, params->cw_max,
1751 params->aifs, params->txop);
1752 if (ret < 0)
1753 goto out_sleep;
1754
1755 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1756 CONF_CHANNEL_TYPE_EDCF,
1757 wl1271_tx_get_queue(queue),
1758 CONF_PS_SCHEME_LEGACY_PSPOLL,
1759 CONF_ACK_POLICY_LEGACY, 0, 0);
1760 if (ret < 0)
1761 goto out_sleep;
1762
1763out_sleep:
1764 wl1271_ps_elp_sleep(wl);
1765
1766out:
1767 mutex_unlock(&wl->mutex);
1768
1769 return ret;
1770}
1771
1772
1773/* can't be const, mac80211 writes to this */
1774static struct ieee80211_rate wl1271_rates[] = {
1775 { .bitrate = 10,
1776 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1777 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1778 { .bitrate = 20,
1779 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1780 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1781 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1782 { .bitrate = 55,
1783 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1784 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1785 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1786 { .bitrate = 110,
1787 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1788 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1789 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1790 { .bitrate = 60,
1791 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1792 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1793 { .bitrate = 90,
1794 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1795 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1796 { .bitrate = 120,
1797 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1798 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1799 { .bitrate = 180,
1800 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1801 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1802 { .bitrate = 240,
1803 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1804 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1805 { .bitrate = 360,
1806 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1807 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1808 { .bitrate = 480,
1809 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1810 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1811 { .bitrate = 540,
1812 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1813 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1814};
1815
1816/* can't be const, mac80211 writes to this */
1817static struct ieee80211_channel wl1271_channels[] = {
1818 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1819 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1820 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1821 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1822 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1823 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1824 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1825 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1826 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1827 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1828 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1829 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1830 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1831};
1832
1833/* can't be const, mac80211 writes to this */
1834static struct ieee80211_supported_band wl1271_band_2ghz = {
1835 .channels = wl1271_channels,
1836 .n_channels = ARRAY_SIZE(wl1271_channels),
1837 .bitrates = wl1271_rates,
1838 .n_bitrates = ARRAY_SIZE(wl1271_rates),
1839};
1840
1841/* 5 GHz data rates for WL1273 */
1842static struct ieee80211_rate wl1271_rates_5ghz[] = {
1843 { .bitrate = 60,
1844 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1845 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1846 { .bitrate = 90,
1847 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1848 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1849 { .bitrate = 120,
1850 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1851 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1852 { .bitrate = 180,
1853 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1854 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1855 { .bitrate = 240,
1856 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1857 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1858 { .bitrate = 360,
1859 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1860 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1861 { .bitrate = 480,
1862 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1863 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1864 { .bitrate = 540,
1865 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1866 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1867};
1868
1869/* 5 GHz band channels for WL1273 */
1870static struct ieee80211_channel wl1271_channels_5ghz[] = {
1871 { .hw_value = 183, .center_freq = 4915},
1872 { .hw_value = 184, .center_freq = 4920},
1873 { .hw_value = 185, .center_freq = 4925},
1874 { .hw_value = 187, .center_freq = 4935},
1875 { .hw_value = 188, .center_freq = 4940},
1876 { .hw_value = 189, .center_freq = 4945},
1877 { .hw_value = 192, .center_freq = 4960},
1878 { .hw_value = 196, .center_freq = 4980},
1879 { .hw_value = 7, .center_freq = 5035},
1880 { .hw_value = 8, .center_freq = 5040},
1881 { .hw_value = 9, .center_freq = 5045},
1882 { .hw_value = 11, .center_freq = 5055},
1883 { .hw_value = 12, .center_freq = 5060},
1884 { .hw_value = 16, .center_freq = 5080},
1885 { .hw_value = 34, .center_freq = 5170},
1886 { .hw_value = 36, .center_freq = 5180},
1887 { .hw_value = 38, .center_freq = 5190},
1888 { .hw_value = 40, .center_freq = 5200},
1889 { .hw_value = 42, .center_freq = 5210},
1890 { .hw_value = 44, .center_freq = 5220},
1891 { .hw_value = 46, .center_freq = 5230},
1892 { .hw_value = 48, .center_freq = 5240},
1893 { .hw_value = 52, .center_freq = 5260},
1894 { .hw_value = 56, .center_freq = 5280},
1895 { .hw_value = 60, .center_freq = 5300},
1896 { .hw_value = 64, .center_freq = 5320},
1897 { .hw_value = 100, .center_freq = 5500},
1898 { .hw_value = 104, .center_freq = 5520},
1899 { .hw_value = 108, .center_freq = 5540},
1900 { .hw_value = 112, .center_freq = 5560},
1901 { .hw_value = 116, .center_freq = 5580},
1902 { .hw_value = 120, .center_freq = 5600},
1903 { .hw_value = 124, .center_freq = 5620},
1904 { .hw_value = 128, .center_freq = 5640},
1905 { .hw_value = 132, .center_freq = 5660},
1906 { .hw_value = 136, .center_freq = 5680},
1907 { .hw_value = 140, .center_freq = 5700},
1908 { .hw_value = 149, .center_freq = 5745},
1909 { .hw_value = 153, .center_freq = 5765},
1910 { .hw_value = 157, .center_freq = 5785},
1911 { .hw_value = 161, .center_freq = 5805},
1912 { .hw_value = 165, .center_freq = 5825},
1913};
1914
1915
1916static struct ieee80211_supported_band wl1271_band_5ghz = {
1917 .channels = wl1271_channels_5ghz,
1918 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
1919 .bitrates = wl1271_rates_5ghz,
1920 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
1921};
1922
1923static const struct ieee80211_ops wl1271_ops = {
1924 .start = wl1271_op_start,
1925 .stop = wl1271_op_stop,
1926 .add_interface = wl1271_op_add_interface,
1927 .remove_interface = wl1271_op_remove_interface,
1928 .config = wl1271_op_config,
1929/* .config_interface = wl1271_op_config_interface, */
1930 .prepare_multicast = wl1271_op_prepare_multicast,
1931 .configure_filter = wl1271_op_configure_filter,
1932 .tx = wl1271_op_tx,
1933 .set_key = wl1271_op_set_key,
1934 .hw_scan = wl1271_op_hw_scan,
1935 .bss_info_changed = wl1271_op_bss_info_changed,
1936 .set_rts_threshold = wl1271_op_set_rts_threshold,
1937 .conf_tx = wl1271_op_conf_tx,
1938 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
1939};
1940
1941int wl1271_register_hw(struct wl1271 *wl)
1942{
1943 int ret;
1944
1945 if (wl->mac80211_registered)
1946 return 0;
1947
1948 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
1949
1950 ret = ieee80211_register_hw(wl->hw);
1951 if (ret < 0) {
1952 wl1271_error("unable to register mac80211 hw: %d", ret);
1953 return ret;
1954 }
1955
1956 wl->mac80211_registered = true;
1957
1958 wl1271_notice("loaded");
1959
1960 return 0;
1961}
1962EXPORT_SYMBOL_GPL(wl1271_register_hw);
1963
1964int wl1271_init_ieee80211(struct wl1271 *wl)
1965{
1966 /* The tx descriptor buffer and the TKIP space. */
1967 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
1968 sizeof(struct wl1271_tx_hw_descr);
1969
1970 /* unit us */
1971 /* FIXME: find a proper value */
1972 wl->hw->channel_change_time = 10000;
1973
1974 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1975 IEEE80211_HW_NOISE_DBM |
1976 IEEE80211_HW_BEACON_FILTER |
1977 IEEE80211_HW_SUPPORTS_PS;
1978
1979 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1980 BIT(NL80211_IFTYPE_ADHOC);
1981 wl->hw->wiphy->max_scan_ssids = 1;
1982 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
1983
1984 if (wl1271_11a_enabled())
1985 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
1986
1987 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
1988
1989 return 0;
1990}
1991EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
1992
1993#define WL1271_DEFAULT_CHANNEL 0
1994
1995struct ieee80211_hw *wl1271_alloc_hw(void)
1996{
1997 struct ieee80211_hw *hw;
1998 struct wl1271 *wl;
1999 int i;
2000
2001 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2002 if (!hw) {
2003 wl1271_error("could not alloc ieee80211_hw");
2004 return ERR_PTR(-ENOMEM);
2005 }
2006
2007 wl = hw->priv;
2008 memset(wl, 0, sizeof(*wl));
2009
2010 INIT_LIST_HEAD(&wl->list);
2011
2012 wl->hw = hw;
2013
2014 skb_queue_head_init(&wl->tx_queue);
2015
2016 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2017 wl->channel = WL1271_DEFAULT_CHANNEL;
2018 wl->default_key = 0;
2019 wl->rx_counter = 0;
2020 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2021 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2022 wl->psm_entry_retry = 0;
2023 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2024 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2025 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2026 wl->sta_rate_set = 0;
2027 wl->band = IEEE80211_BAND_2GHZ;
2028 wl->vif = NULL;
2029 wl->flags = 0;
2030
2031 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2032 wl->tx_frames[i] = NULL;
2033
2034 spin_lock_init(&wl->wl_lock);
2035
2036 wl->state = WL1271_STATE_OFF;
2037 mutex_init(&wl->mutex);
2038
2039 /* Apply default driver configuration. */
2040 wl1271_conf_init(wl);
2041
2042 wl1271_debugfs_init(wl);
2043
2044 return hw;
2045}
2046EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2047
2048int wl1271_free_hw(struct wl1271 *wl)
2049{
2050 ieee80211_unregister_hw(wl->hw);
2051
2052 wl1271_debugfs_exit(wl);
2053
2054 kfree(wl->target_mem_map);
2055 vfree(wl->fw);
2056 wl->fw = NULL;
2057 kfree(wl->nvs);
2058 wl->nvs = NULL;
2059
2060 kfree(wl->fw_status);
2061 kfree(wl->tx_res_if);
2062
2063 ieee80211_free_hw(wl->hw);
2064
2065 return 0;
2066}
2067EXPORT_SYMBOL_GPL(wl1271_free_hw);
2068
2069MODULE_LICENSE("GPL");
2070MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2071MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux kernel - Deliverables
This page took 0.040697 seconds and 5 git commands to generate.