]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - drivers/net/wireless/wl12xx/wl1271_main.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wl1271: Fix channel changing code
[mirror_ubuntu-jammy-kernel.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 &&
1238 test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1239 wl->channel = channel;
1240 /* FIXME: maybe use CMD_CHANNEL_SWITCH for this? */
1241 ret = wl1271_cmd_join(wl);
1242 if (ret < 0)
1243 wl1271_warning("cmd join to update channel failed %d",
1244 ret);
1245 } else
1246 wl->channel = channel;
1247
1248 if (conf->flags & IEEE80211_CONF_PS &&
1249 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1250 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1251
1252 /*
1253 * We enter PSM only if we're already associated.
1254 * If we're not, we'll enter it when joining an SSID,
1255 * through the bss_info_changed() hook.
1256 */
1257 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1258 wl1271_info("psm enabled");
1259 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1260 true);
1261 }
1262 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1263 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1264 wl1271_info("psm disabled");
1265
1266 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1267
1268 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1269 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1270 true);
1271 }
1272
1273 if (conf->power_level != wl->power_level) {
1274 ret = wl1271_acx_tx_power(wl, conf->power_level);
1275 if (ret < 0)
1276 goto out_sleep;
1277
1278 wl->power_level = conf->power_level;
1279 }
1280
1281 out_sleep:
1282 wl1271_ps_elp_sleep(wl);
1283
1284 out:
1285 mutex_unlock(&wl->mutex);
1286
1287 return ret;
1288 }
1289
1290 struct wl1271_filter_params {
1291 bool enabled;
1292 int mc_list_length;
1293 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1294 };
1295
1296 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1297 struct dev_addr_list *mc_list)
1298 {
1299 struct wl1271_filter_params *fp;
1300 int i;
1301
1302 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1303 if (!fp) {
1304 wl1271_error("Out of memory setting filters.");
1305 return 0;
1306 }
1307
1308 /* update multicast filtering parameters */
1309 fp->enabled = true;
1310 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1311 mc_count = 0;
1312 fp->enabled = false;
1313 }
1314
1315 fp->mc_list_length = 0;
1316 for (i = 0; i < mc_count; i++) {
1317 if (mc_list->da_addrlen == ETH_ALEN) {
1318 memcpy(fp->mc_list[fp->mc_list_length],
1319 mc_list->da_addr, ETH_ALEN);
1320 fp->mc_list_length++;
1321 } else
1322 wl1271_warning("Unknown mc address length.");
1323 mc_list = mc_list->next;
1324 }
1325
1326 return (u64)(unsigned long)fp;
1327 }
1328
1329 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1330 FIF_ALLMULTI | \
1331 FIF_FCSFAIL | \
1332 FIF_BCN_PRBRESP_PROMISC | \
1333 FIF_CONTROL | \
1334 FIF_OTHER_BSS)
1335
1336 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1337 unsigned int changed,
1338 unsigned int *total, u64 multicast)
1339 {
1340 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1341 struct wl1271 *wl = hw->priv;
1342 int ret;
1343
1344 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1345
1346 mutex_lock(&wl->mutex);
1347
1348 if (wl->state == WL1271_STATE_OFF)
1349 goto out;
1350
1351 ret = wl1271_ps_elp_wakeup(wl, false);
1352 if (ret < 0)
1353 goto out;
1354
1355 *total &= WL1271_SUPPORTED_FILTERS;
1356 changed &= WL1271_SUPPORTED_FILTERS;
1357
1358 if (*total & FIF_ALLMULTI)
1359 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1360 else if (fp)
1361 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1362 fp->mc_list,
1363 fp->mc_list_length);
1364 if (ret < 0)
1365 goto out_sleep;
1366
1367 kfree(fp);
1368
1369 /* FIXME: We still need to set our filters properly */
1370
1371 /* determine, whether supported filter values have changed */
1372 if (changed == 0)
1373 goto out_sleep;
1374
1375 /* apply configured filters */
1376 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1377 if (ret < 0)
1378 goto out_sleep;
1379
1380 out_sleep:
1381 wl1271_ps_elp_sleep(wl);
1382
1383 out:
1384 mutex_unlock(&wl->mutex);
1385 }
1386
1387 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1388 struct ieee80211_vif *vif,
1389 struct ieee80211_sta *sta,
1390 struct ieee80211_key_conf *key_conf)
1391 {
1392 struct wl1271 *wl = hw->priv;
1393 const u8 *addr;
1394 int ret;
1395 u32 tx_seq_32 = 0;
1396 u16 tx_seq_16 = 0;
1397 u8 key_type;
1398
1399 static const u8 bcast_addr[ETH_ALEN] =
1400 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1401
1402 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1403
1404 addr = sta ? sta->addr : bcast_addr;
1405
1406 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1407 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1408 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1409 key_conf->alg, key_conf->keyidx,
1410 key_conf->keylen, key_conf->flags);
1411 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1412
1413 if (is_zero_ether_addr(addr)) {
1414 /* We dont support TX only encryption */
1415 ret = -EOPNOTSUPP;
1416 goto out;
1417 }
1418
1419 mutex_lock(&wl->mutex);
1420
1421 ret = wl1271_ps_elp_wakeup(wl, false);
1422 if (ret < 0)
1423 goto out_unlock;
1424
1425 switch (key_conf->alg) {
1426 case ALG_WEP:
1427 key_type = KEY_WEP;
1428
1429 key_conf->hw_key_idx = key_conf->keyidx;
1430 break;
1431 case ALG_TKIP:
1432 key_type = KEY_TKIP;
1433
1434 key_conf->hw_key_idx = key_conf->keyidx;
1435 tx_seq_32 = wl->tx_security_seq_32;
1436 tx_seq_16 = wl->tx_security_seq_16;
1437 break;
1438 case ALG_CCMP:
1439 key_type = KEY_AES;
1440
1441 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1442 tx_seq_32 = wl->tx_security_seq_32;
1443 tx_seq_16 = wl->tx_security_seq_16;
1444 break;
1445 default:
1446 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1447
1448 ret = -EOPNOTSUPP;
1449 goto out_sleep;
1450 }
1451
1452 switch (cmd) {
1453 case SET_KEY:
1454 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1455 key_conf->keyidx, key_type,
1456 key_conf->keylen, key_conf->key,
1457 addr, tx_seq_32, tx_seq_16);
1458 if (ret < 0) {
1459 wl1271_error("Could not add or replace key");
1460 goto out_sleep;
1461 }
1462 break;
1463
1464 case DISABLE_KEY:
1465 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1466 key_conf->keyidx, key_type,
1467 key_conf->keylen, key_conf->key,
1468 addr, 0, 0);
1469 if (ret < 0) {
1470 wl1271_error("Could not remove key");
1471 goto out_sleep;
1472 }
1473 break;
1474
1475 default:
1476 wl1271_error("Unsupported key cmd 0x%x", cmd);
1477 ret = -EOPNOTSUPP;
1478 goto out_sleep;
1479
1480 break;
1481 }
1482
1483 out_sleep:
1484 wl1271_ps_elp_sleep(wl);
1485
1486 out_unlock:
1487 mutex_unlock(&wl->mutex);
1488
1489 out:
1490 return ret;
1491 }
1492
1493 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1494 struct cfg80211_scan_request *req)
1495 {
1496 struct wl1271 *wl = hw->priv;
1497 int ret;
1498 u8 *ssid = NULL;
1499 size_t len = 0;
1500
1501 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1502
1503 if (req->n_ssids) {
1504 ssid = req->ssids[0].ssid;
1505 len = req->ssids[0].ssid_len;
1506 }
1507
1508 mutex_lock(&wl->mutex);
1509
1510 ret = wl1271_ps_elp_wakeup(wl, false);
1511 if (ret < 0)
1512 goto out;
1513
1514 if (wl1271_11a_enabled())
1515 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1516 WL1271_SCAN_BAND_DUAL, 3);
1517 else
1518 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1519 WL1271_SCAN_BAND_2_4_GHZ, 3);
1520
1521 wl1271_ps_elp_sleep(wl);
1522
1523 out:
1524 mutex_unlock(&wl->mutex);
1525
1526 return ret;
1527 }
1528
1529 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1530 {
1531 struct wl1271 *wl = hw->priv;
1532 int ret;
1533
1534 mutex_lock(&wl->mutex);
1535
1536 ret = wl1271_ps_elp_wakeup(wl, false);
1537 if (ret < 0)
1538 goto out;
1539
1540 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1541 if (ret < 0)
1542 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1543
1544 wl1271_ps_elp_sleep(wl);
1545
1546 out:
1547 mutex_unlock(&wl->mutex);
1548
1549 return ret;
1550 }
1551
1552 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1553 struct ieee80211_vif *vif,
1554 struct ieee80211_bss_conf *bss_conf,
1555 u32 changed)
1556 {
1557 enum wl1271_cmd_ps_mode mode;
1558 struct wl1271 *wl = hw->priv;
1559 int ret;
1560
1561 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1562
1563 mutex_lock(&wl->mutex);
1564
1565 ret = wl1271_ps_elp_wakeup(wl, false);
1566 if (ret < 0)
1567 goto out;
1568
1569 if ((changed & BSS_CHANGED_BSSID) &&
1570 /*
1571 * Now we know the correct bssid, so we send a new join command
1572 * and enable the BSSID filter
1573 */
1574 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1575 wl->rx_config |= CFG_BSSID_FILTER_EN;
1576 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1577 ret = wl1271_cmd_build_null_data(wl);
1578 if (ret < 0) {
1579 wl1271_warning("cmd buld null data failed %d",
1580 ret);
1581 goto out_sleep;
1582 }
1583 ret = wl1271_cmd_join(wl);
1584 if (ret < 0) {
1585 wl1271_warning("cmd join failed %d", ret);
1586 goto out_sleep;
1587 }
1588 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1589 }
1590
1591 if (wl->bss_type == BSS_TYPE_IBSS) {
1592 /* FIXME: This implements rudimentary ad-hoc support -
1593 proper templates are on the wish list and notification
1594 on when they change. This patch will update the templates
1595 on every call to this function. Also, the firmware will not
1596 answer to probe-requests as it does not have the proper
1597 SSID set in the JOIN command. The probe-response template
1598 is set nevertheless, as the FW will ASSERT without it */
1599 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1600
1601 if (beacon) {
1602 struct ieee80211_hdr *hdr;
1603 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1604 beacon->data,
1605 beacon->len);
1606
1607 if (ret < 0) {
1608 dev_kfree_skb(beacon);
1609 goto out_sleep;
1610 }
1611
1612 hdr = (struct ieee80211_hdr *) beacon->data;
1613 hdr->frame_control = cpu_to_le16(
1614 IEEE80211_FTYPE_MGMT |
1615 IEEE80211_STYPE_PROBE_RESP);
1616
1617 ret = wl1271_cmd_template_set(wl,
1618 CMD_TEMPL_PROBE_RESPONSE,
1619 beacon->data,
1620 beacon->len);
1621 dev_kfree_skb(beacon);
1622 if (ret < 0)
1623 goto out_sleep;
1624 }
1625 }
1626
1627 if (changed & BSS_CHANGED_ASSOC) {
1628 if (bss_conf->assoc) {
1629 wl->aid = bss_conf->aid;
1630 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1631
1632 /*
1633 * with wl1271, we don't need to update the
1634 * beacon_int and dtim_period, because the firmware
1635 * updates it by itself when the first beacon is
1636 * received after a join.
1637 */
1638 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1639 if (ret < 0)
1640 goto out_sleep;
1641
1642 ret = wl1271_acx_aid(wl, wl->aid);
1643 if (ret < 0)
1644 goto out_sleep;
1645
1646 /* If we want to go in PSM but we're not there yet */
1647 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1648 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1649 mode = STATION_POWER_SAVE_MODE;
1650 ret = wl1271_ps_set_mode(wl, mode, true);
1651 if (ret < 0)
1652 goto out_sleep;
1653 }
1654 } else {
1655 /* use defaults when not associated */
1656 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1657 wl->aid = 0;
1658 }
1659
1660 }
1661
1662 if (changed & BSS_CHANGED_ERP_SLOT) {
1663 if (bss_conf->use_short_slot)
1664 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1665 else
1666 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1667 if (ret < 0) {
1668 wl1271_warning("Set slot time failed %d", ret);
1669 goto out_sleep;
1670 }
1671 }
1672
1673 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1674 if (bss_conf->use_short_preamble)
1675 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1676 else
1677 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1678 }
1679
1680 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1681 if (bss_conf->use_cts_prot)
1682 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1683 else
1684 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1685 if (ret < 0) {
1686 wl1271_warning("Set ctsprotect failed %d", ret);
1687 goto out_sleep;
1688 }
1689 }
1690
1691 out_sleep:
1692 wl1271_ps_elp_sleep(wl);
1693
1694 out:
1695 mutex_unlock(&wl->mutex);
1696 }
1697
1698
1699 /* can't be const, mac80211 writes to this */
1700 static struct ieee80211_rate wl1271_rates[] = {
1701 { .bitrate = 10,
1702 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1703 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1704 { .bitrate = 20,
1705 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1706 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1707 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1708 { .bitrate = 55,
1709 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1710 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1711 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1712 { .bitrate = 110,
1713 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1714 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1715 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1716 { .bitrate = 60,
1717 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1718 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1719 { .bitrate = 90,
1720 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1721 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1722 { .bitrate = 120,
1723 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1724 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1725 { .bitrate = 180,
1726 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1727 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1728 { .bitrate = 240,
1729 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1730 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1731 { .bitrate = 360,
1732 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1733 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1734 { .bitrate = 480,
1735 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1736 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1737 { .bitrate = 540,
1738 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1739 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1740 };
1741
1742 /* can't be const, mac80211 writes to this */
1743 static struct ieee80211_channel wl1271_channels[] = {
1744 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1745 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1746 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1747 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1748 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1749 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1750 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1751 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1752 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1753 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1754 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1755 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1756 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1757 };
1758
1759 /* can't be const, mac80211 writes to this */
1760 static struct ieee80211_supported_band wl1271_band_2ghz = {
1761 .channels = wl1271_channels,
1762 .n_channels = ARRAY_SIZE(wl1271_channels),
1763 .bitrates = wl1271_rates,
1764 .n_bitrates = ARRAY_SIZE(wl1271_rates),
1765 };
1766
1767 /* 5 GHz data rates for WL1273 */
1768 static struct ieee80211_rate wl1271_rates_5ghz[] = {
1769 { .bitrate = 60,
1770 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1771 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1772 { .bitrate = 90,
1773 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1774 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1775 { .bitrate = 120,
1776 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1777 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1778 { .bitrate = 180,
1779 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1780 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1781 { .bitrate = 240,
1782 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1783 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1784 { .bitrate = 360,
1785 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1786 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1787 { .bitrate = 480,
1788 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1789 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1790 { .bitrate = 540,
1791 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1792 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1793 };
1794
1795 /* 5 GHz band channels for WL1273 */
1796 static struct ieee80211_channel wl1271_channels_5ghz[] = {
1797 { .hw_value = 183, .center_freq = 4915},
1798 { .hw_value = 184, .center_freq = 4920},
1799 { .hw_value = 185, .center_freq = 4925},
1800 { .hw_value = 187, .center_freq = 4935},
1801 { .hw_value = 188, .center_freq = 4940},
1802 { .hw_value = 189, .center_freq = 4945},
1803 { .hw_value = 192, .center_freq = 4960},
1804 { .hw_value = 196, .center_freq = 4980},
1805 { .hw_value = 7, .center_freq = 5035},
1806 { .hw_value = 8, .center_freq = 5040},
1807 { .hw_value = 9, .center_freq = 5045},
1808 { .hw_value = 11, .center_freq = 5055},
1809 { .hw_value = 12, .center_freq = 5060},
1810 { .hw_value = 16, .center_freq = 5080},
1811 { .hw_value = 34, .center_freq = 5170},
1812 { .hw_value = 36, .center_freq = 5180},
1813 { .hw_value = 38, .center_freq = 5190},
1814 { .hw_value = 40, .center_freq = 5200},
1815 { .hw_value = 42, .center_freq = 5210},
1816 { .hw_value = 44, .center_freq = 5220},
1817 { .hw_value = 46, .center_freq = 5230},
1818 { .hw_value = 48, .center_freq = 5240},
1819 { .hw_value = 52, .center_freq = 5260},
1820 { .hw_value = 56, .center_freq = 5280},
1821 { .hw_value = 60, .center_freq = 5300},
1822 { .hw_value = 64, .center_freq = 5320},
1823 { .hw_value = 100, .center_freq = 5500},
1824 { .hw_value = 104, .center_freq = 5520},
1825 { .hw_value = 108, .center_freq = 5540},
1826 { .hw_value = 112, .center_freq = 5560},
1827 { .hw_value = 116, .center_freq = 5580},
1828 { .hw_value = 120, .center_freq = 5600},
1829 { .hw_value = 124, .center_freq = 5620},
1830 { .hw_value = 128, .center_freq = 5640},
1831 { .hw_value = 132, .center_freq = 5660},
1832 { .hw_value = 136, .center_freq = 5680},
1833 { .hw_value = 140, .center_freq = 5700},
1834 { .hw_value = 149, .center_freq = 5745},
1835 { .hw_value = 153, .center_freq = 5765},
1836 { .hw_value = 157, .center_freq = 5785},
1837 { .hw_value = 161, .center_freq = 5805},
1838 { .hw_value = 165, .center_freq = 5825},
1839 };
1840
1841
1842 static struct ieee80211_supported_band wl1271_band_5ghz = {
1843 .channels = wl1271_channels_5ghz,
1844 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
1845 .bitrates = wl1271_rates_5ghz,
1846 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
1847 };
1848
1849 static const struct ieee80211_ops wl1271_ops = {
1850 .start = wl1271_op_start,
1851 .stop = wl1271_op_stop,
1852 .add_interface = wl1271_op_add_interface,
1853 .remove_interface = wl1271_op_remove_interface,
1854 .config = wl1271_op_config,
1855 /* .config_interface = wl1271_op_config_interface, */
1856 .prepare_multicast = wl1271_op_prepare_multicast,
1857 .configure_filter = wl1271_op_configure_filter,
1858 .tx = wl1271_op_tx,
1859 .set_key = wl1271_op_set_key,
1860 .hw_scan = wl1271_op_hw_scan,
1861 .bss_info_changed = wl1271_op_bss_info_changed,
1862 .set_rts_threshold = wl1271_op_set_rts_threshold,
1863 };
1864
1865 static int wl1271_register_hw(struct wl1271 *wl)
1866 {
1867 int ret;
1868
1869 if (wl->mac80211_registered)
1870 return 0;
1871
1872 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
1873
1874 ret = ieee80211_register_hw(wl->hw);
1875 if (ret < 0) {
1876 wl1271_error("unable to register mac80211 hw: %d", ret);
1877 return ret;
1878 }
1879
1880 wl->mac80211_registered = true;
1881
1882 wl1271_notice("loaded");
1883
1884 return 0;
1885 }
1886
1887 static int wl1271_init_ieee80211(struct wl1271 *wl)
1888 {
1889 /* The tx descriptor buffer and the TKIP space. */
1890 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
1891 sizeof(struct wl1271_tx_hw_descr);
1892
1893 /* unit us */
1894 /* FIXME: find a proper value */
1895 wl->hw->channel_change_time = 10000;
1896
1897 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1898 IEEE80211_HW_NOISE_DBM |
1899 IEEE80211_HW_BEACON_FILTER |
1900 IEEE80211_HW_SUPPORTS_PS;
1901
1902 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1903 BIT(NL80211_IFTYPE_ADHOC);
1904 wl->hw->wiphy->max_scan_ssids = 1;
1905 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
1906
1907 if (wl1271_11a_enabled())
1908 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
1909
1910 SET_IEEE80211_DEV(wl->hw, &wl->spi->dev);
1911
1912 return 0;
1913 }
1914
1915 static void wl1271_device_release(struct device *dev)
1916 {
1917
1918 }
1919
1920 static struct platform_device wl1271_device = {
1921 .name = "wl1271",
1922 .id = -1,
1923
1924 /* device model insists to have a release function */
1925 .dev = {
1926 .release = wl1271_device_release,
1927 },
1928 };
1929
1930 #define WL1271_DEFAULT_CHANNEL 0
1931 static int __devinit wl1271_probe(struct spi_device *spi)
1932 {
1933 struct wl12xx_platform_data *pdata;
1934 struct ieee80211_hw *hw;
1935 struct wl1271 *wl;
1936 int ret, i;
1937 static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
1938
1939 pdata = spi->dev.platform_data;
1940 if (!pdata) {
1941 wl1271_error("no platform data");
1942 return -ENODEV;
1943 }
1944
1945 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
1946 if (!hw) {
1947 wl1271_error("could not alloc ieee80211_hw");
1948 return -ENOMEM;
1949 }
1950
1951 wl = hw->priv;
1952 memset(wl, 0, sizeof(*wl));
1953
1954 INIT_LIST_HEAD(&wl->list);
1955
1956 wl->hw = hw;
1957 dev_set_drvdata(&spi->dev, wl);
1958 wl->spi = spi;
1959
1960 skb_queue_head_init(&wl->tx_queue);
1961
1962 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
1963 wl->channel = WL1271_DEFAULT_CHANNEL;
1964 wl->default_key = 0;
1965 wl->rx_counter = 0;
1966 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1967 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1968 wl->psm_entry_retry = 0;
1969 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1970 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
1971 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1972 wl->sta_rate_set = 0;
1973 wl->band = IEEE80211_BAND_2GHZ;
1974 wl->vif = NULL;
1975 wl->flags = 0;
1976
1977 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
1978 wl->tx_frames[i] = NULL;
1979
1980 spin_lock_init(&wl->wl_lock);
1981
1982 /*
1983 * In case our MAC address is not correctly set,
1984 * we use a random but Nokia MAC.
1985 */
1986 memcpy(wl->mac_addr, nokia_oui, 3);
1987 get_random_bytes(wl->mac_addr + 3, 3);
1988
1989 wl->state = WL1271_STATE_OFF;
1990 mutex_init(&wl->mutex);
1991
1992 /* This is the only SPI value that we need to set here, the rest
1993 * comes from the board-peripherals file */
1994 spi->bits_per_word = 32;
1995
1996 ret = spi_setup(spi);
1997 if (ret < 0) {
1998 wl1271_error("spi_setup failed");
1999 goto out_free;
2000 }
2001
2002 wl->set_power = pdata->set_power;
2003 if (!wl->set_power) {
2004 wl1271_error("set power function missing in platform data");
2005 ret = -ENODEV;
2006 goto out_free;
2007 }
2008
2009 wl->irq = spi->irq;
2010 if (wl->irq < 0) {
2011 wl1271_error("irq missing in platform data");
2012 ret = -ENODEV;
2013 goto out_free;
2014 }
2015
2016 ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl);
2017 if (ret < 0) {
2018 wl1271_error("request_irq() failed: %d", ret);
2019 goto out_free;
2020 }
2021
2022 set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
2023
2024 disable_irq(wl->irq);
2025
2026 ret = platform_device_register(&wl1271_device);
2027 if (ret) {
2028 wl1271_error("couldn't register platform device");
2029 goto out_irq;
2030 }
2031 dev_set_drvdata(&wl1271_device.dev, wl);
2032
2033 /* Apply default driver configuration. */
2034 wl1271_conf_init(wl);
2035
2036 ret = wl1271_init_ieee80211(wl);
2037 if (ret)
2038 goto out_platform;
2039
2040 ret = wl1271_register_hw(wl);
2041 if (ret)
2042 goto out_platform;
2043
2044 wl1271_debugfs_init(wl);
2045
2046 wl1271_notice("initialized");
2047
2048 return 0;
2049
2050 out_platform:
2051 platform_device_unregister(&wl1271_device);
2052
2053 out_irq:
2054 free_irq(wl->irq, wl);
2055
2056 out_free:
2057 ieee80211_free_hw(hw);
2058
2059 return ret;
2060 }
2061
2062 static int __devexit wl1271_remove(struct spi_device *spi)
2063 {
2064 struct wl1271 *wl = dev_get_drvdata(&spi->dev);
2065
2066 ieee80211_unregister_hw(wl->hw);
2067
2068 wl1271_debugfs_exit(wl);
2069 platform_device_unregister(&wl1271_device);
2070 free_irq(wl->irq, wl);
2071 kfree(wl->target_mem_map);
2072 vfree(wl->fw);
2073 wl->fw = NULL;
2074 kfree(wl->nvs);
2075 wl->nvs = NULL;
2076
2077 kfree(wl->fw_status);
2078 kfree(wl->tx_res_if);
2079
2080 ieee80211_free_hw(wl->hw);
2081
2082 return 0;
2083 }
2084
2085
2086 static struct spi_driver wl1271_spi_driver = {
2087 .driver = {
2088 .name = "wl1271",
2089 .bus = &spi_bus_type,
2090 .owner = THIS_MODULE,
2091 },
2092
2093 .probe = wl1271_probe,
2094 .remove = __devexit_p(wl1271_remove),
2095 };
2096
2097 static int __init wl1271_init(void)
2098 {
2099 int ret;
2100
2101 ret = spi_register_driver(&wl1271_spi_driver);
2102 if (ret < 0) {
2103 wl1271_error("failed to register spi driver: %d", ret);
2104 goto out;
2105 }
2106
2107 out:
2108 return ret;
2109 }
2110
2111 static void __exit wl1271_exit(void)
2112 {
2113 spi_unregister_driver(&wl1271_spi_driver);
2114
2115 wl1271_notice("unloaded");
2116 }
2117
2118 module_init(wl1271_init);
2119 module_exit(wl1271_exit);
2120
2121 MODULE_LICENSE("GPL");
2122 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2123 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
2124 MODULE_FIRMWARE(WL1271_FW_NAME);
Ubuntu Jammy Linux kernel mirror