projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wl1271: Use slow rates for association messages
[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 bool do_ack = (intr & WL1271_ACX_INTR_EVENT_B) ? false : true;
454 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
455 wl1271_event_handle(wl, 0, do_ack);
456 }
457
458 if (intr & WL1271_ACX_INTR_EVENT_B) {
459 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
460 wl1271_event_handle(wl, 1, true);
461 }
462
463 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
464 wl1271_debug(DEBUG_IRQ,
465 "WL1271_ACX_INTR_INIT_COMPLETE");
466
467 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
468 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
469
470 if (intr & WL1271_ACX_INTR_DATA) {
471 u8 tx_res_cnt = wl->fw_status->tx_results_counter -
472 wl->tx_results_count;
473
474 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
475
476 /* check for tx results */
477 if (tx_res_cnt)
478 wl1271_tx_complete(wl, tx_res_cnt);
479
480 wl1271_rx(wl, wl->fw_status);
481 }
482
483 out_sleep:
484 wl1271_spi_write32(wl, ACX_REG_INTERRUPT_MASK,
485 WL1271_ACX_INTR_ALL & ~(WL1271_INTR_MASK));
486 wl1271_ps_elp_sleep(wl);
487
488 out:
489 mutex_unlock(&wl->mutex);
490 }
491
492 static irqreturn_t wl1271_irq(int irq, void *cookie)
493 {
494 struct wl1271 *wl;
495 unsigned long flags;
496
497 wl1271_debug(DEBUG_IRQ, "IRQ");
498
499 wl = cookie;
500
501 /* complete the ELP completion */
502 spin_lock_irqsave(&wl->wl_lock, flags);
503 if (wl->elp_compl) {
504 complete(wl->elp_compl);
505 wl->elp_compl = NULL;
506 }
507
508 ieee80211_queue_work(wl->hw, &wl->irq_work);
509 spin_unlock_irqrestore(&wl->wl_lock, flags);
510
511 return IRQ_HANDLED;
512 }
513
514 static int wl1271_fetch_firmware(struct wl1271 *wl)
515 {
516 const struct firmware *fw;
517 int ret;
518
519 ret = request_firmware(&fw, WL1271_FW_NAME, &wl->spi->dev);
520
521 if (ret < 0) {
522 wl1271_error("could not get firmware: %d", ret);
523 return ret;
524 }
525
526 if (fw->size % 4) {
527 wl1271_error("firmware size is not multiple of 32 bits: %zu",
528 fw->size);
529 ret = -EILSEQ;
530 goto out;
531 }
532
533 wl->fw_len = fw->size;
534 wl->fw = vmalloc(wl->fw_len);
535
536 if (!wl->fw) {
537 wl1271_error("could not allocate memory for the firmware");
538 ret = -ENOMEM;
539 goto out;
540 }
541
542 memcpy(wl->fw, fw->data, wl->fw_len);
543
544 ret = 0;
545
546 out:
547 release_firmware(fw);
548
549 return ret;
550 }
551
552 static int wl1271_fetch_nvs(struct wl1271 *wl)
553 {
554 const struct firmware *fw;
555 int ret;
556
557 ret = request_firmware(&fw, WL1271_NVS_NAME, &wl->spi->dev);
558
559 if (ret < 0) {
560 wl1271_error("could not get nvs file: %d", ret);
561 return ret;
562 }
563
564 if (fw->size % 4) {
565 wl1271_error("nvs size is not multiple of 32 bits: %zu",
566 fw->size);
567 ret = -EILSEQ;
568 goto out;
569 }
570
571 wl->nvs_len = fw->size;
572 wl->nvs = kmalloc(wl->nvs_len, GFP_KERNEL);
573
574 if (!wl->nvs) {
575 wl1271_error("could not allocate memory for the nvs file");
576 ret = -ENOMEM;
577 goto out;
578 }
579
580 memcpy(wl->nvs, fw->data, wl->nvs_len);
581
582 ret = 0;
583
584 out:
585 release_firmware(fw);
586
587 return ret;
588 }
589
590 static void wl1271_fw_wakeup(struct wl1271 *wl)
591 {
592 u32 elp_reg;
593
594 elp_reg = ELPCTRL_WAKE_UP;
595 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
596 }
597
598 static int wl1271_setup(struct wl1271 *wl)
599 {
600 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
601 if (!wl->fw_status)
602 return -ENOMEM;
603
604 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
605 if (!wl->tx_res_if) {
606 kfree(wl->fw_status);
607 return -ENOMEM;
608 }
609
610 INIT_WORK(&wl->irq_work, wl1271_irq_work);
611 INIT_WORK(&wl->tx_work, wl1271_tx_work);
612 return 0;
613 }
614
615 static int wl1271_chip_wakeup(struct wl1271 *wl)
616 {
617 struct wl1271_partition_set partition;
618 int ret = 0;
619
620 wl1271_power_on(wl);
621 msleep(WL1271_POWER_ON_SLEEP);
622 wl1271_spi_reset(wl);
623 wl1271_spi_init(wl);
624
625 /* We don't need a real memory partition here, because we only want
626 * to use the registers at this point. */
627 memset(&partition, 0, sizeof(partition));
628 partition.reg.start = REGISTERS_BASE;
629 partition.reg.size = REGISTERS_DOWN_SIZE;
630 wl1271_set_partition(wl, &partition);
631
632 /* ELP module wake up */
633 wl1271_fw_wakeup(wl);
634
635 /* whal_FwCtrl_BootSm() */
636
637 /* 0. read chip id from CHIP_ID */
638 wl->chip.id = wl1271_spi_read32(wl, CHIP_ID_B);
639
640 /* 1. check if chip id is valid */
641
642 switch (wl->chip.id) {
643 case CHIP_ID_1271_PG10:
644 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
645 wl->chip.id);
646
647 ret = wl1271_setup(wl);
648 if (ret < 0)
649 goto out_power_off;
650 break;
651 case CHIP_ID_1271_PG20:
652 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
653 wl->chip.id);
654
655 ret = wl1271_setup(wl);
656 if (ret < 0)
657 goto out_power_off;
658 break;
659 default:
660 wl1271_error("unsupported chip id: 0x%x", wl->chip.id);
661 ret = -ENODEV;
662 goto out_power_off;
663 }
664
665 if (wl->fw == NULL) {
666 ret = wl1271_fetch_firmware(wl);
667 if (ret < 0)
668 goto out_power_off;
669 }
670
671 /* No NVS from netlink, try to get it from the filesystem */
672 if (wl->nvs == NULL) {
673 ret = wl1271_fetch_nvs(wl);
674 if (ret < 0)
675 goto out_power_off;
676 }
677
678 goto out;
679
680 out_power_off:
681 wl1271_power_off(wl);
682
683 out:
684 return ret;
685 }
686
687 int wl1271_plt_start(struct wl1271 *wl)
688 {
689 int ret;
690
691 mutex_lock(&wl->mutex);
692
693 wl1271_notice("power up");
694
695 if (wl->state != WL1271_STATE_OFF) {
696 wl1271_error("cannot go into PLT state because not "
697 "in off state: %d", wl->state);
698 ret = -EBUSY;
699 goto out;
700 }
701
702 wl->state = WL1271_STATE_PLT;
703
704 ret = wl1271_chip_wakeup(wl);
705 if (ret < 0)
706 goto out;
707
708 ret = wl1271_boot(wl);
709 if (ret < 0)
710 goto out_power_off;
711
712 wl1271_notice("firmware booted in PLT mode (%s)", wl->chip.fw_ver);
713
714 ret = wl1271_plt_init(wl);
715 if (ret < 0)
716 goto out_irq_disable;
717
718 /* Make sure power saving is disabled */
719 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
720 if (ret < 0)
721 goto out_irq_disable;
722
723 goto out;
724
725 out_irq_disable:
726 wl1271_disable_interrupts(wl);
727
728 out_power_off:
729 wl1271_power_off(wl);
730
731 out:
732 mutex_unlock(&wl->mutex);
733
734 return ret;
735 }
736
737 int wl1271_plt_stop(struct wl1271 *wl)
738 {
739 int ret = 0;
740
741 mutex_lock(&wl->mutex);
742
743 wl1271_notice("power down");
744
745 if (wl->state != WL1271_STATE_PLT) {
746 wl1271_error("cannot power down because not in PLT "
747 "state: %d", wl->state);
748 ret = -EBUSY;
749 goto out;
750 }
751
752 wl1271_disable_interrupts(wl);
753 wl1271_power_off(wl);
754
755 wl->state = WL1271_STATE_OFF;
756 wl->rx_counter = 0;
757
758 out:
759 mutex_unlock(&wl->mutex);
760
761 return ret;
762 }
763
764
765 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
766 {
767 struct wl1271 *wl = hw->priv;
768
769 skb_queue_tail(&wl->tx_queue, skb);
770
771 /*
772 * The chip specific setup must run before the first TX packet -
773 * before that, the tx_work will not be initialized!
774 */
775
776 ieee80211_queue_work(wl->hw, &wl->tx_work);
777
778 /*
779 * The workqueue is slow to process the tx_queue and we need stop
780 * the queue here, otherwise the queue will get too long.
781 */
782 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_MAX_LENGTH) {
783 ieee80211_stop_queues(wl->hw);
784
785 /*
786 * FIXME: this is racy, the variable is not properly
787 * protected. Maybe fix this by removing the stupid
788 * variable altogether and checking the real queue state?
789 */
790 wl->tx_queue_stopped = true;
791 }
792
793 return NETDEV_TX_OK;
794 }
795
796 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
797 void *arg)
798 {
799 struct net_device *dev;
800 struct wireless_dev *wdev;
801 struct wiphy *wiphy;
802 struct ieee80211_hw *hw;
803 struct wl1271 *wl;
804 struct wl1271 *wl_temp;
805 struct in_device *idev;
806 struct in_ifaddr *ifa = arg;
807 int ret = 0;
808
809 /* FIXME: this ugly function should probably be implemented in the
810 * mac80211, and here should only be a simple callback handling actual
811 * setting of the filters. Now we need to dig up references to
812 * various structures to gain access to what we need.
813 * Also, because of this, there is no "initial" setting of the filter
814 * in "op_start", because we don't want to dig up struct net_device
815 * there - the filter will be set upon first change of the interface
816 * IP address. */
817
818 dev = ifa->ifa_dev->dev;
819
820 wdev = dev->ieee80211_ptr;
821 if (wdev == NULL)
822 return NOTIFY_DONE;
823
824 wiphy = wdev->wiphy;
825 if (wiphy == NULL)
826 return NOTIFY_DONE;
827
828 hw = wiphy_priv(wiphy);
829 if (hw == NULL)
830 return NOTIFY_DONE;
831
832 /* Check that the interface is one supported by this driver. */
833 wl_temp = hw->priv;
834 list_for_each_entry(wl, &wl_list, list) {
835 if (wl == wl_temp)
836 break;
837 }
838 if (wl == NULL)
839 return NOTIFY_DONE;
840
841 /* Get the interface IP address for the device. "ifa" will become
842 NULL if:
843 - there is no IPV4 protocol address configured
844 - there are multiple (virtual) IPV4 addresses configured
845 When "ifa" is NULL, filtering will be disabled.
846 */
847 ifa = NULL;
848 idev = dev->ip_ptr;
849 if (idev)
850 ifa = idev->ifa_list;
851
852 if (ifa && ifa->ifa_next)
853 ifa = NULL;
854
855 mutex_lock(&wl->mutex);
856
857 if (wl->state == WL1271_STATE_OFF)
858 goto out;
859
860 ret = wl1271_ps_elp_wakeup(wl, false);
861 if (ret < 0)
862 goto out;
863 if (ifa)
864 ret = wl1271_acx_arp_ip_filter(wl, true,
865 (u8 *)&ifa->ifa_address,
866 ACX_IPV4_VERSION);
867 else
868 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
869 ACX_IPV4_VERSION);
870 wl1271_ps_elp_sleep(wl);
871
872 out:
873 mutex_unlock(&wl->mutex);
874
875 return NOTIFY_OK;
876 }
877
878 static struct notifier_block wl1271_dev_notifier = {
879 .notifier_call = wl1271_dev_notify,
880 };
881
882
883 static int wl1271_op_start(struct ieee80211_hw *hw)
884 {
885 struct wl1271 *wl = hw->priv;
886 int ret = 0;
887
888 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
889
890 mutex_lock(&wl->mutex);
891
892 if (wl->state != WL1271_STATE_OFF) {
893 wl1271_error("cannot start because not in off state: %d",
894 wl->state);
895 ret = -EBUSY;
896 goto out;
897 }
898
899 ret = wl1271_chip_wakeup(wl);
900 if (ret < 0)
901 goto out;
902
903 ret = wl1271_boot(wl);
904 if (ret < 0)
905 goto out_power_off;
906
907 ret = wl1271_hw_init(wl);
908 if (ret < 0)
909 goto out_irq_disable;
910
911 wl->state = WL1271_STATE_ON;
912
913 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
914
915 goto out;
916
917 out_irq_disable:
918 wl1271_disable_interrupts(wl);
919
920 out_power_off:
921 wl1271_power_off(wl);
922
923 out:
924 mutex_unlock(&wl->mutex);
925
926 if (!ret) {
927 list_add(&wl->list, &wl_list);
928 register_inetaddr_notifier(&wl1271_dev_notifier);
929 }
930
931 return ret;
932 }
933
934 static void wl1271_op_stop(struct ieee80211_hw *hw)
935 {
936 struct wl1271 *wl = hw->priv;
937 int i;
938
939 wl1271_info("down");
940
941 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
942
943 unregister_inetaddr_notifier(&wl1271_dev_notifier);
944 list_del(&wl->list);
945
946 mutex_lock(&wl->mutex);
947
948 WARN_ON(wl->state != WL1271_STATE_ON);
949
950 if (wl->scanning) {
951 mutex_unlock(&wl->mutex);
952 ieee80211_scan_completed(wl->hw, true);
953 mutex_lock(&wl->mutex);
954 wl->scanning = false;
955 }
956
957 wl->state = WL1271_STATE_OFF;
958
959 wl1271_disable_interrupts(wl);
960
961 mutex_unlock(&wl->mutex);
962
963 cancel_work_sync(&wl->irq_work);
964 cancel_work_sync(&wl->tx_work);
965
966 mutex_lock(&wl->mutex);
967
968 /* let's notify MAC80211 about the remaining pending TX frames */
969 wl1271_tx_flush(wl);
970 wl1271_power_off(wl);
971
972 memset(wl->bssid, 0, ETH_ALEN);
973 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
974 wl->ssid_len = 0;
975 wl->bss_type = MAX_BSS_TYPE;
976 wl->band = IEEE80211_BAND_2GHZ;
977
978 wl->rx_counter = 0;
979 wl->elp = false;
980 wl->psm = 0;
981 wl->psm_entry_retry = 0;
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 wl1271_info("psm enabled");
1196
1197 wl->psm_requested = true;
1198
1199 /*
1200 * We enter PSM only if we're already associated.
1201 * If we're not, we'll enter it when joining an SSID,
1202 * through the bss_info_changed() hook.
1203 */
1204 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE);
1205 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1206 wl->psm_requested) {
1207 wl1271_info("psm disabled");
1208
1209 wl->psm_requested = false;
1210
1211 if (wl->psm)
1212 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE);
1213 }
1214
1215 if (conf->power_level != wl->power_level) {
1216 ret = wl1271_acx_tx_power(wl, conf->power_level);
1217 if (ret < 0)
1218 goto out_sleep;
1219
1220 wl->power_level = conf->power_level;
1221 }
1222
1223 out_sleep:
1224 wl1271_ps_elp_sleep(wl);
1225
1226 out:
1227 mutex_unlock(&wl->mutex);
1228
1229 return ret;
1230 }
1231
1232 struct wl1271_filter_params {
1233 bool enabled;
1234 int mc_list_length;
1235 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1236 };
1237
1238 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1239 struct dev_addr_list *mc_list)
1240 {
1241 struct wl1271_filter_params *fp;
1242 int i;
1243
1244 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1245 if (!fp) {
1246 wl1271_error("Out of memory setting filters.");
1247 return 0;
1248 }
1249
1250 /* update multicast filtering parameters */
1251 fp->enabled = true;
1252 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1253 mc_count = 0;
1254 fp->enabled = false;
1255 }
1256
1257 fp->mc_list_length = 0;
1258 for (i = 0; i < mc_count; i++) {
1259 if (mc_list->da_addrlen == ETH_ALEN) {
1260 memcpy(fp->mc_list[fp->mc_list_length],
1261 mc_list->da_addr, ETH_ALEN);
1262 fp->mc_list_length++;
1263 } else
1264 wl1271_warning("Unknown mc address length.");
1265 mc_list = mc_list->next;
1266 }
1267
1268 return (u64)(unsigned long)fp;
1269 }
1270
1271 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1272 FIF_ALLMULTI | \
1273 FIF_FCSFAIL | \
1274 FIF_BCN_PRBRESP_PROMISC | \
1275 FIF_CONTROL | \
1276 FIF_OTHER_BSS)
1277
1278 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1279 unsigned int changed,
1280 unsigned int *total, u64 multicast)
1281 {
1282 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1283 struct wl1271 *wl = hw->priv;
1284 int ret;
1285
1286 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1287
1288 mutex_lock(&wl->mutex);
1289
1290 if (wl->state == WL1271_STATE_OFF)
1291 goto out;
1292
1293 ret = wl1271_ps_elp_wakeup(wl, false);
1294 if (ret < 0)
1295 goto out;
1296
1297 *total &= WL1271_SUPPORTED_FILTERS;
1298 changed &= WL1271_SUPPORTED_FILTERS;
1299
1300 if (*total & FIF_ALLMULTI)
1301 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1302 else if (fp)
1303 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1304 fp->mc_list,
1305 fp->mc_list_length);
1306 if (ret < 0)
1307 goto out_sleep;
1308
1309 kfree(fp);
1310
1311 /* FIXME: We still need to set our filters properly */
1312
1313 /* determine, whether supported filter values have changed */
1314 if (changed == 0)
1315 goto out_sleep;
1316
1317 /* apply configured filters */
1318 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1319 if (ret < 0)
1320 goto out_sleep;
1321
1322 out_sleep:
1323 wl1271_ps_elp_sleep(wl);
1324
1325 out:
1326 mutex_unlock(&wl->mutex);
1327 }
1328
1329 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1330 struct ieee80211_vif *vif,
1331 struct ieee80211_sta *sta,
1332 struct ieee80211_key_conf *key_conf)
1333 {
1334 struct wl1271 *wl = hw->priv;
1335 const u8 *addr;
1336 int ret;
1337 u32 tx_seq_32 = 0;
1338 u16 tx_seq_16 = 0;
1339 u8 key_type;
1340
1341 static const u8 bcast_addr[ETH_ALEN] =
1342 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1343
1344 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1345
1346 addr = sta ? sta->addr : bcast_addr;
1347
1348 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1349 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1350 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1351 key_conf->alg, key_conf->keyidx,
1352 key_conf->keylen, key_conf->flags);
1353 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1354
1355 if (is_zero_ether_addr(addr)) {
1356 /* We dont support TX only encryption */
1357 ret = -EOPNOTSUPP;
1358 goto out;
1359 }
1360
1361 mutex_lock(&wl->mutex);
1362
1363 ret = wl1271_ps_elp_wakeup(wl, false);
1364 if (ret < 0)
1365 goto out_unlock;
1366
1367 switch (key_conf->alg) {
1368 case ALG_WEP:
1369 key_type = KEY_WEP;
1370
1371 key_conf->hw_key_idx = key_conf->keyidx;
1372 break;
1373 case ALG_TKIP:
1374 key_type = KEY_TKIP;
1375
1376 key_conf->hw_key_idx = key_conf->keyidx;
1377 tx_seq_32 = wl->tx_security_seq_32;
1378 tx_seq_16 = wl->tx_security_seq_16;
1379 break;
1380 case ALG_CCMP:
1381 key_type = KEY_AES;
1382
1383 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1384 tx_seq_32 = wl->tx_security_seq_32;
1385 tx_seq_16 = wl->tx_security_seq_16;
1386 break;
1387 default:
1388 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1389
1390 ret = -EOPNOTSUPP;
1391 goto out_sleep;
1392 }
1393
1394 switch (cmd) {
1395 case SET_KEY:
1396 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1397 key_conf->keyidx, key_type,
1398 key_conf->keylen, key_conf->key,
1399 addr, tx_seq_32, tx_seq_16);
1400 if (ret < 0) {
1401 wl1271_error("Could not add or replace key");
1402 goto out_sleep;
1403 }
1404 break;
1405
1406 case DISABLE_KEY:
1407 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1408 key_conf->keyidx, key_type,
1409 key_conf->keylen, key_conf->key,
1410 addr, 0, 0);
1411 if (ret < 0) {
1412 wl1271_error("Could not remove key");
1413 goto out_sleep;
1414 }
1415 break;
1416
1417 default:
1418 wl1271_error("Unsupported key cmd 0x%x", cmd);
1419 ret = -EOPNOTSUPP;
1420 goto out_sleep;
1421
1422 break;
1423 }
1424
1425 out_sleep:
1426 wl1271_ps_elp_sleep(wl);
1427
1428 out_unlock:
1429 mutex_unlock(&wl->mutex);
1430
1431 out:
1432 return ret;
1433 }
1434
1435 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1436 struct cfg80211_scan_request *req)
1437 {
1438 struct wl1271 *wl = hw->priv;
1439 int ret;
1440 u8 *ssid = NULL;
1441 size_t len = 0;
1442
1443 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1444
1445 if (req->n_ssids) {
1446 ssid = req->ssids[0].ssid;
1447 len = req->ssids[0].ssid_len;
1448 }
1449
1450 mutex_lock(&wl->mutex);
1451
1452 ret = wl1271_ps_elp_wakeup(wl, false);
1453 if (ret < 0)
1454 goto out;
1455
1456 if (wl1271_11a_enabled())
1457 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1458 WL1271_SCAN_BAND_DUAL, 3);
1459 else
1460 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1461 WL1271_SCAN_BAND_2_4_GHZ, 3);
1462
1463 wl1271_ps_elp_sleep(wl);
1464
1465 out:
1466 mutex_unlock(&wl->mutex);
1467
1468 return ret;
1469 }
1470
1471 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1472 {
1473 struct wl1271 *wl = hw->priv;
1474 int ret;
1475
1476 mutex_lock(&wl->mutex);
1477
1478 ret = wl1271_ps_elp_wakeup(wl, false);
1479 if (ret < 0)
1480 goto out;
1481
1482 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1483 if (ret < 0)
1484 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1485
1486 wl1271_ps_elp_sleep(wl);
1487
1488 out:
1489 mutex_unlock(&wl->mutex);
1490
1491 return ret;
1492 }
1493
1494 static u32 wl1271_enabled_rates_get(struct wl1271 *wl, u64 basic_rate_set)
1495 {
1496 struct ieee80211_supported_band *band;
1497 u32 enabled_rates = 0;
1498 int bit;
1499
1500 band = wl->hw->wiphy->bands[wl->band];
1501 for (bit = 0; bit < band->n_bitrates; bit++) {
1502 if (basic_rate_set & 0x1)
1503 enabled_rates |= band->bitrates[bit].hw_value;
1504 basic_rate_set >>= 1;
1505 }
1506
1507 return enabled_rates;
1508 }
1509
1510 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1511 struct ieee80211_vif *vif,
1512 struct ieee80211_bss_conf *bss_conf,
1513 u32 changed)
1514 {
1515 enum wl1271_cmd_ps_mode mode;
1516 struct wl1271 *wl = hw->priv;
1517 int ret;
1518
1519 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1520
1521 mutex_lock(&wl->mutex);
1522
1523 ret = wl1271_ps_elp_wakeup(wl, false);
1524 if (ret < 0)
1525 goto out;
1526
1527 if ((changed & BSS_CHANGED_BSSID) &&
1528 /*
1529 * Now we know the correct bssid, so we send a new join command
1530 * and enable the BSSID filter
1531 */
1532 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1533 wl->rx_config |= CFG_BSSID_FILTER_EN;
1534 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1535 ret = wl1271_cmd_build_null_data(wl);
1536 if (ret < 0) {
1537 wl1271_warning("cmd buld null data failed %d",
1538 ret);
1539 goto out_sleep;
1540 }
1541 ret = wl1271_cmd_join(wl);
1542 if (ret < 0) {
1543 wl1271_warning("cmd join failed %d", ret);
1544 goto out_sleep;
1545 }
1546 wl->joined = true;
1547 }
1548
1549 if (changed & BSS_CHANGED_ASSOC) {
1550 if (bss_conf->assoc) {
1551 wl->aid = bss_conf->aid;
1552
1553 /*
1554 * with wl1271, we don't need to update the
1555 * beacon_int and dtim_period, because the firmware
1556 * updates it by itself when the first beacon is
1557 * received after a join.
1558 */
1559 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1560 if (ret < 0)
1561 goto out_sleep;
1562
1563 ret = wl1271_acx_aid(wl, wl->aid);
1564 if (ret < 0)
1565 goto out_sleep;
1566
1567 /* If we want to go in PSM but we're not there yet */
1568 if (wl->psm_requested && !wl->psm) {
1569 mode = STATION_POWER_SAVE_MODE;
1570 ret = wl1271_ps_set_mode(wl, mode);
1571 if (ret < 0)
1572 goto out_sleep;
1573 }
1574 } else {
1575 /* use defaults when not associated */
1576 wl->aid = 0;
1577 }
1578
1579 }
1580
1581 if (changed & BSS_CHANGED_ERP_SLOT) {
1582 if (bss_conf->use_short_slot)
1583 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1584 else
1585 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1586 if (ret < 0) {
1587 wl1271_warning("Set slot time failed %d", ret);
1588 goto out_sleep;
1589 }
1590 }
1591
1592 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1593 if (bss_conf->use_short_preamble)
1594 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1595 else
1596 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1597 }
1598
1599 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1600 if (bss_conf->use_cts_prot)
1601 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1602 else
1603 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1604 if (ret < 0) {
1605 wl1271_warning("Set ctsprotect failed %d", ret);
1606 goto out_sleep;
1607 }
1608 }
1609
1610 if (changed & BSS_CHANGED_BASIC_RATES) {
1611 wl->basic_rate_set = wl1271_enabled_rates_get(
1612 wl, bss_conf->basic_rates);
1613
1614 ret = wl1271_acx_rate_policies(wl, wl->basic_rate_set);
1615 if (ret < 0) {
1616 wl1271_warning("Set rate policies failed %d", ret);
1617 goto out_sleep;
1618 }
1619 }
1620
1621 out_sleep:
1622 wl1271_ps_elp_sleep(wl);
1623
1624 out:
1625 mutex_unlock(&wl->mutex);
1626 }
1627
1628
1629 /* can't be const, mac80211 writes to this */
1630 static struct ieee80211_rate wl1271_rates[] = {
1631 { .bitrate = 10,
1632 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1633 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1634 { .bitrate = 20,
1635 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1636 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1637 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1638 { .bitrate = 55,
1639 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1640 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1641 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1642 { .bitrate = 110,
1643 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1644 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1645 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1646 { .bitrate = 60,
1647 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1648 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1649 { .bitrate = 90,
1650 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1651 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1652 { .bitrate = 120,
1653 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1654 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1655 { .bitrate = 180,
1656 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1657 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1658 { .bitrate = 240,
1659 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1660 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1661 { .bitrate = 360,
1662 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1663 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1664 { .bitrate = 480,
1665 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1666 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1667 { .bitrate = 540,
1668 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1669 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1670 };
1671
1672 /* can't be const, mac80211 writes to this */
1673 static struct ieee80211_channel wl1271_channels[] = {
1674 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1675 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1676 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1677 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1678 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1679 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1680 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1681 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1682 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1683 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1684 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1685 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1686 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1687 };
1688
1689 /* can't be const, mac80211 writes to this */
1690 static struct ieee80211_supported_band wl1271_band_2ghz = {
1691 .channels = wl1271_channels,
1692 .n_channels = ARRAY_SIZE(wl1271_channels),
1693 .bitrates = wl1271_rates,
1694 .n_bitrates = ARRAY_SIZE(wl1271_rates),
1695 };
1696
1697 /* 5 GHz data rates for WL1273 */
1698 static struct ieee80211_rate wl1271_rates_5ghz[] = {
1699 { .bitrate = 60,
1700 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1701 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1702 { .bitrate = 90,
1703 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1704 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1705 { .bitrate = 120,
1706 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1707 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1708 { .bitrate = 180,
1709 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1710 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1711 { .bitrate = 240,
1712 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1713 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1714 { .bitrate = 360,
1715 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1716 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1717 { .bitrate = 480,
1718 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1719 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1720 { .bitrate = 540,
1721 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1722 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1723 };
1724
1725 /* 5 GHz band channels for WL1273 */
1726 static struct ieee80211_channel wl1271_channels_5ghz[] = {
1727 { .hw_value = 183, .center_freq = 4915},
1728 { .hw_value = 184, .center_freq = 4920},
1729 { .hw_value = 185, .center_freq = 4925},
1730 { .hw_value = 187, .center_freq = 4935},
1731 { .hw_value = 188, .center_freq = 4940},
1732 { .hw_value = 189, .center_freq = 4945},
1733 { .hw_value = 192, .center_freq = 4960},
1734 { .hw_value = 196, .center_freq = 4980},
1735 { .hw_value = 7, .center_freq = 5035},
1736 { .hw_value = 8, .center_freq = 5040},
1737 { .hw_value = 9, .center_freq = 5045},
1738 { .hw_value = 11, .center_freq = 5055},
1739 { .hw_value = 12, .center_freq = 5060},
1740 { .hw_value = 16, .center_freq = 5080},
1741 { .hw_value = 34, .center_freq = 5170},
1742 { .hw_value = 36, .center_freq = 5180},
1743 { .hw_value = 38, .center_freq = 5190},
1744 { .hw_value = 40, .center_freq = 5200},
1745 { .hw_value = 42, .center_freq = 5210},
1746 { .hw_value = 44, .center_freq = 5220},
1747 { .hw_value = 46, .center_freq = 5230},
1748 { .hw_value = 48, .center_freq = 5240},
1749 { .hw_value = 52, .center_freq = 5260},
1750 { .hw_value = 56, .center_freq = 5280},
1751 { .hw_value = 60, .center_freq = 5300},
1752 { .hw_value = 64, .center_freq = 5320},
1753 { .hw_value = 100, .center_freq = 5500},
1754 { .hw_value = 104, .center_freq = 5520},
1755 { .hw_value = 108, .center_freq = 5540},
1756 { .hw_value = 112, .center_freq = 5560},
1757 { .hw_value = 116, .center_freq = 5580},
1758 { .hw_value = 120, .center_freq = 5600},
1759 { .hw_value = 124, .center_freq = 5620},
1760 { .hw_value = 128, .center_freq = 5640},
1761 { .hw_value = 132, .center_freq = 5660},
1762 { .hw_value = 136, .center_freq = 5680},
1763 { .hw_value = 140, .center_freq = 5700},
1764 { .hw_value = 149, .center_freq = 5745},
1765 { .hw_value = 153, .center_freq = 5765},
1766 { .hw_value = 157, .center_freq = 5785},
1767 { .hw_value = 161, .center_freq = 5805},
1768 { .hw_value = 165, .center_freq = 5825},
1769 };
1770
1771
1772 static struct ieee80211_supported_band wl1271_band_5ghz = {
1773 .channels = wl1271_channels_5ghz,
1774 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
1775 .bitrates = wl1271_rates_5ghz,
1776 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
1777 };
1778
1779 static const struct ieee80211_ops wl1271_ops = {
1780 .start = wl1271_op_start,
1781 .stop = wl1271_op_stop,
1782 .add_interface = wl1271_op_add_interface,
1783 .remove_interface = wl1271_op_remove_interface,
1784 .config = wl1271_op_config,
1785 /* .config_interface = wl1271_op_config_interface, */
1786 .prepare_multicast = wl1271_op_prepare_multicast,
1787 .configure_filter = wl1271_op_configure_filter,
1788 .tx = wl1271_op_tx,
1789 .set_key = wl1271_op_set_key,
1790 .hw_scan = wl1271_op_hw_scan,
1791 .bss_info_changed = wl1271_op_bss_info_changed,
1792 .set_rts_threshold = wl1271_op_set_rts_threshold,
1793 };
1794
1795 static int wl1271_register_hw(struct wl1271 *wl)
1796 {
1797 int ret;
1798
1799 if (wl->mac80211_registered)
1800 return 0;
1801
1802 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
1803
1804 ret = ieee80211_register_hw(wl->hw);
1805 if (ret < 0) {
1806 wl1271_error("unable to register mac80211 hw: %d", ret);
1807 return ret;
1808 }
1809
1810 wl->mac80211_registered = true;
1811
1812 wl1271_notice("loaded");
1813
1814 return 0;
1815 }
1816
1817 static int wl1271_init_ieee80211(struct wl1271 *wl)
1818 {
1819 /* The tx descriptor buffer and the TKIP space. */
1820 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
1821 sizeof(struct wl1271_tx_hw_descr);
1822
1823 /* unit us */
1824 /* FIXME: find a proper value */
1825 wl->hw->channel_change_time = 10000;
1826
1827 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1828 IEEE80211_HW_NOISE_DBM |
1829 IEEE80211_HW_BEACON_FILTER |
1830 IEEE80211_HW_SUPPORTS_PS;
1831
1832 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
1833 wl->hw->wiphy->max_scan_ssids = 1;
1834 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
1835
1836 if (wl1271_11a_enabled())
1837 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
1838
1839 SET_IEEE80211_DEV(wl->hw, &wl->spi->dev);
1840
1841 return 0;
1842 }
1843
1844 static void wl1271_device_release(struct device *dev)
1845 {
1846
1847 }
1848
1849 static struct platform_device wl1271_device = {
1850 .name = "wl1271",
1851 .id = -1,
1852
1853 /* device model insists to have a release function */
1854 .dev = {
1855 .release = wl1271_device_release,
1856 },
1857 };
1858
1859 #define WL1271_DEFAULT_CHANNEL 0
1860 static int __devinit wl1271_probe(struct spi_device *spi)
1861 {
1862 struct wl12xx_platform_data *pdata;
1863 struct ieee80211_hw *hw;
1864 struct wl1271 *wl;
1865 int ret, i;
1866 static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
1867
1868 pdata = spi->dev.platform_data;
1869 if (!pdata) {
1870 wl1271_error("no platform data");
1871 return -ENODEV;
1872 }
1873
1874 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
1875 if (!hw) {
1876 wl1271_error("could not alloc ieee80211_hw");
1877 return -ENOMEM;
1878 }
1879
1880 wl = hw->priv;
1881 memset(wl, 0, sizeof(*wl));
1882
1883 INIT_LIST_HEAD(&wl->list);
1884
1885 wl->hw = hw;
1886 dev_set_drvdata(&spi->dev, wl);
1887 wl->spi = spi;
1888
1889 skb_queue_head_init(&wl->tx_queue);
1890
1891 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
1892 wl->channel = WL1271_DEFAULT_CHANNEL;
1893 wl->scanning = false;
1894 wl->default_key = 0;
1895 wl->rx_counter = 0;
1896 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1897 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1898 wl->elp = false;
1899 wl->psm = 0;
1900 wl->psm_requested = false;
1901 wl->psm_entry_retry = 0;
1902 wl->tx_queue_stopped = false;
1903 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1904 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
1905 wl->band = IEEE80211_BAND_2GHZ;
1906 wl->vif = NULL;
1907 wl->joined = false;
1908 wl->gpio_power = false;
1909
1910 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
1911 wl->tx_frames[i] = NULL;
1912
1913 spin_lock_init(&wl->wl_lock);
1914
1915 /*
1916 * In case our MAC address is not correctly set,
1917 * we use a random but Nokia MAC.
1918 */
1919 memcpy(wl->mac_addr, nokia_oui, 3);
1920 get_random_bytes(wl->mac_addr + 3, 3);
1921
1922 wl->state = WL1271_STATE_OFF;
1923 mutex_init(&wl->mutex);
1924
1925 /* This is the only SPI value that we need to set here, the rest
1926 * comes from the board-peripherals file */
1927 spi->bits_per_word = 32;
1928
1929 ret = spi_setup(spi);
1930 if (ret < 0) {
1931 wl1271_error("spi_setup failed");
1932 goto out_free;
1933 }
1934
1935 wl->set_power = pdata->set_power;
1936 if (!wl->set_power) {
1937 wl1271_error("set power function missing in platform data");
1938 ret = -ENODEV;
1939 goto out_free;
1940 }
1941
1942 wl->irq = spi->irq;
1943 if (wl->irq < 0) {
1944 wl1271_error("irq missing in platform data");
1945 ret = -ENODEV;
1946 goto out_free;
1947 }
1948
1949 ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl);
1950 if (ret < 0) {
1951 wl1271_error("request_irq() failed: %d", ret);
1952 goto out_free;
1953 }
1954
1955 set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
1956
1957 disable_irq(wl->irq);
1958
1959 ret = platform_device_register(&wl1271_device);
1960 if (ret) {
1961 wl1271_error("couldn't register platform device");
1962 goto out_irq;
1963 }
1964 dev_set_drvdata(&wl1271_device.dev, wl);
1965
1966 /* Apply default driver configuration. */
1967 wl1271_conf_init(wl);
1968
1969 ret = wl1271_init_ieee80211(wl);
1970 if (ret)
1971 goto out_platform;
1972
1973 ret = wl1271_register_hw(wl);
1974 if (ret)
1975 goto out_platform;
1976
1977 wl1271_debugfs_init(wl);
1978
1979 wl1271_notice("initialized");
1980
1981 return 0;
1982
1983 out_platform:
1984 platform_device_unregister(&wl1271_device);
1985
1986 out_irq:
1987 free_irq(wl->irq, wl);
1988
1989 out_free:
1990 ieee80211_free_hw(hw);
1991
1992 return ret;
1993 }
1994
1995 static int __devexit wl1271_remove(struct spi_device *spi)
1996 {
1997 struct wl1271 *wl = dev_get_drvdata(&spi->dev);
1998
1999 ieee80211_unregister_hw(wl->hw);
2000
2001 wl1271_debugfs_exit(wl);
2002 platform_device_unregister(&wl1271_device);
2003 free_irq(wl->irq, wl);
2004 kfree(wl->target_mem_map);
2005 vfree(wl->fw);
2006 wl->fw = NULL;
2007 kfree(wl->nvs);
2008 wl->nvs = NULL;
2009
2010 kfree(wl->fw_status);
2011 kfree(wl->tx_res_if);
2012
2013 ieee80211_free_hw(wl->hw);
2014
2015 return 0;
2016 }
2017
2018
2019 static struct spi_driver wl1271_spi_driver = {
2020 .driver = {
2021 .name = "wl1271",
2022 .bus = &spi_bus_type,
2023 .owner = THIS_MODULE,
2024 },
2025
2026 .probe = wl1271_probe,
2027 .remove = __devexit_p(wl1271_remove),
2028 };
2029
2030 static int __init wl1271_init(void)
2031 {
2032 int ret;
2033
2034 ret = spi_register_driver(&wl1271_spi_driver);
2035 if (ret < 0) {
2036 wl1271_error("failed to register spi driver: %d", ret);
2037 goto out;
2038 }
2039
2040 out:
2041 return ret;
2042 }
2043
2044 static void __exit wl1271_exit(void)
2045 {
2046 spi_unregister_driver(&wl1271_spi_driver);
2047
2048 wl1271_notice("unloaded");
2049 }
2050
2051 module_init(wl1271_init);
2052 module_exit(wl1271_exit);
2053
2054 MODULE_LICENSE("GPL");
2055 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2056 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
2057 MODULE_FIRMWARE(WL1271_FW_NAME);
Linux kernel - Deliverables
This page took 0.080342 seconds and 6 git commands to generate.