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