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