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