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