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