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