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