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