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