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