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