aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/wl12xx/main.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/wireless/wl12xx/main.c')
-rw-r--r--drivers/net/wireless/wl12xx/main.c2798
1 files changed, 2798 insertions, 0 deletions
diff --git a/drivers/net/wireless/wl12xx/main.c b/drivers/net/wireless/wl12xx/main.c
new file mode 100644
index 000000000000..708ffe304c6d
--- /dev/null
+++ b/drivers/net/wireless/wl12xx/main.c
@@ -0,0 +1,2798 @@
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/platform_device.h>
32#include <linux/slab.h>
33
34#include "wl12xx.h"
35#include "wl12xx_80211.h"
36#include "reg.h"
37#include "io.h"
38#include "event.h"
39#include "tx.h"
40#include "rx.h"
41#include "ps.h"
42#include "init.h"
43#include "debugfs.h"
44#include "cmd.h"
45#include "boot.h"
46#include "testmode.h"
47#include "scan.h"
48
49#define WL1271_BOOT_RETRIES 3
50
51static struct conf_drv_settings default_conf = {
52 .sg = {
53 .params = {
54 [CONF_SG_BT_PER_THRESHOLD] = 7500,
55 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
56 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
57 [CONF_SG_BT_LOAD_RATIO] = 50,
58 [CONF_SG_AUTO_PS_MODE] = 1,
59 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
60 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
61 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
62 [CONF_SG_BEACON_MISS_PERCENT] = 60,
63 [CONF_SG_RATE_ADAPT_THRESH] = 12,
64 [CONF_SG_RATE_ADAPT_SNR] = 0,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
67 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
70 /* Note: with UPSD, this should be 4 */
71 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
74 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
75 /* Note: with UPDS, this should be 15 */
76 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
77 /* Note: with UPDS, this should be 50 */
78 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
79 /* Note: with UPDS, this should be 10 */
80 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
81 [CONF_SG_RXT] = 1200,
82 [CONF_SG_TXT] = 1000,
83 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
84 [CONF_SG_PS_POLL_TIMEOUT] = 10,
85 [CONF_SG_UPSD_TIMEOUT] = 10,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
91 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
94 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
97 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
98 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
99 [CONF_SG_HV3_MAX_SERVED] = 6,
100 [CONF_SG_DHCP_TIME] = 5000,
101 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
102 },
103 .state = CONF_SG_PROTECTIVE,
104 },
105 .rx = {
106 .rx_msdu_life_time = 512000,
107 .packet_detection_threshold = 0,
108 .ps_poll_timeout = 15,
109 .upsd_timeout = 15,
110 .rts_threshold = 2347,
111 .rx_cca_threshold = 0,
112 .irq_blk_threshold = 0xFFFF,
113 .irq_pkt_threshold = 0,
114 .irq_timeout = 600,
115 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
116 },
117 .tx = {
118 .tx_energy_detection = 0,
119 .rc_conf = {
120 .enabled_rates = 0,
121 .short_retry_limit = 10,
122 .long_retry_limit = 10,
123 .aflags = 0
124 },
125 .ac_conf_count = 4,
126 .ac_conf = {
127 [CONF_TX_AC_BE] = {
128 .ac = CONF_TX_AC_BE,
129 .cw_min = 15,
130 .cw_max = 63,
131 .aifsn = 3,
132 .tx_op_limit = 0,
133 },
134 [CONF_TX_AC_BK] = {
135 .ac = CONF_TX_AC_BK,
136 .cw_min = 15,
137 .cw_max = 63,
138 .aifsn = 7,
139 .tx_op_limit = 0,
140 },
141 [CONF_TX_AC_VI] = {
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 [CONF_TX_AC_VO] = {
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 = 4,
157 .tid_conf = {
158 [CONF_TX_AC_BE] = {
159 .queue_id = CONF_TX_AC_BE,
160 .channel_type = CONF_CHANNEL_TYPE_EDCF,
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 [CONF_TX_AC_BK] = {
167 .queue_id = CONF_TX_AC_BK,
168 .channel_type = CONF_CHANNEL_TYPE_EDCF,
169 .tsid = CONF_TX_AC_BK,
170 .ps_scheme = CONF_PS_SCHEME_LEGACY,
171 .ack_policy = CONF_ACK_POLICY_LEGACY,
172 .apsd_conf = {0, 0},
173 },
174 [CONF_TX_AC_VI] = {
175 .queue_id = CONF_TX_AC_VI,
176 .channel_type = CONF_CHANNEL_TYPE_EDCF,
177 .tsid = CONF_TX_AC_VI,
178 .ps_scheme = CONF_PS_SCHEME_LEGACY,
179 .ack_policy = CONF_ACK_POLICY_LEGACY,
180 .apsd_conf = {0, 0},
181 },
182 [CONF_TX_AC_VO] = {
183 .queue_id = CONF_TX_AC_VO,
184 .channel_type = CONF_CHANNEL_TYPE_EDCF,
185 .tsid = CONF_TX_AC_VO,
186 .ps_scheme = CONF_PS_SCHEME_LEGACY,
187 .ack_policy = CONF_ACK_POLICY_LEGACY,
188 .apsd_conf = {0, 0},
189 },
190 },
191 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
192 .tx_compl_timeout = 700,
193 .tx_compl_threshold = 4,
194 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
195 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
196 },
197 .conn = {
198 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
199 .listen_interval = 1,
200 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
201 .bcn_filt_ie_count = 1,
202 .bcn_filt_ie = {
203 [0] = {
204 .ie = WLAN_EID_CHANNEL_SWITCH,
205 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
206 }
207 },
208 .synch_fail_thold = 10,
209 .bss_lose_timeout = 100,
210 .beacon_rx_timeout = 10000,
211 .broadcast_timeout = 20000,
212 .rx_broadcast_in_ps = 1,
213 .ps_poll_threshold = 10,
214 .ps_poll_recovery_period = 700,
215 .bet_enable = CONF_BET_MODE_ENABLE,
216 .bet_max_consecutive = 10,
217 .psm_entry_retries = 5,
218 .psm_entry_nullfunc_retries = 3,
219 .psm_entry_hangover_period = 1,
220 .keep_alive_interval = 55000,
221 .max_listen_interval = 20,
222 },
223 .itrim = {
224 .enable = false,
225 .timeout = 50000,
226 },
227 .pm_config = {
228 .host_clk_settling_time = 5000,
229 .host_fast_wakeup_support = false
230 },
231 .roam_trigger = {
232 .trigger_pacing = 1,
233 .avg_weight_rssi_beacon = 20,
234 .avg_weight_rssi_data = 10,
235 .avg_weight_snr_beacon = 20,
236 .avg_weight_snr_data = 10
237 },
238 .scan = {
239 .min_dwell_time_active = 7500,
240 .max_dwell_time_active = 30000,
241 .min_dwell_time_passive = 30000,
242 .max_dwell_time_passive = 60000,
243 .num_probe_reqs = 2,
244 },
245 .rf = {
246 .tx_per_channel_power_compensation_2 = {
247 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
248 },
249 .tx_per_channel_power_compensation_5 = {
250 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
251 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
252 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
253 },
254 },
255};
256
257static void __wl1271_op_remove_interface(struct wl1271 *wl);
258
259
260static void wl1271_device_release(struct device *dev)
261{
262
263}
264
265static struct platform_device wl1271_device = {
266 .name = "wl1271",
267 .id = -1,
268
269 /* device model insists to have a release function */
270 .dev = {
271 .release = wl1271_device_release,
272 },
273};
274
275static LIST_HEAD(wl_list);
276
277static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
278 void *arg)
279{
280 struct net_device *dev = arg;
281 struct wireless_dev *wdev;
282 struct wiphy *wiphy;
283 struct ieee80211_hw *hw;
284 struct wl1271 *wl;
285 struct wl1271 *wl_temp;
286 int ret = 0;
287
288 /* Check that this notification is for us. */
289 if (what != NETDEV_CHANGE)
290 return NOTIFY_DONE;
291
292 wdev = dev->ieee80211_ptr;
293 if (wdev == NULL)
294 return NOTIFY_DONE;
295
296 wiphy = wdev->wiphy;
297 if (wiphy == NULL)
298 return NOTIFY_DONE;
299
300 hw = wiphy_priv(wiphy);
301 if (hw == NULL)
302 return NOTIFY_DONE;
303
304 wl_temp = hw->priv;
305 list_for_each_entry(wl, &wl_list, list) {
306 if (wl == wl_temp)
307 break;
308 }
309 if (wl != wl_temp)
310 return NOTIFY_DONE;
311
312 mutex_lock(&wl->mutex);
313
314 if (wl->state == WL1271_STATE_OFF)
315 goto out;
316
317 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
318 goto out;
319
320 ret = wl1271_ps_elp_wakeup(wl, false);
321 if (ret < 0)
322 goto out;
323
324 if ((dev->operstate == IF_OPER_UP) &&
325 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
326 wl1271_cmd_set_sta_state(wl);
327 wl1271_info("Association completed.");
328 }
329
330 wl1271_ps_elp_sleep(wl);
331
332out:
333 mutex_unlock(&wl->mutex);
334
335 return NOTIFY_OK;
336}
337
338static int wl1271_reg_notify(struct wiphy *wiphy,
339 struct regulatory_request *request) {
340 struct ieee80211_supported_band *band;
341 struct ieee80211_channel *ch;
342 int i;
343
344 band = wiphy->bands[IEEE80211_BAND_5GHZ];
345 for (i = 0; i < band->n_channels; i++) {
346 ch = &band->channels[i];
347 if (ch->flags & IEEE80211_CHAN_DISABLED)
348 continue;
349
350 if (ch->flags & IEEE80211_CHAN_RADAR)
351 ch->flags |= IEEE80211_CHAN_NO_IBSS |
352 IEEE80211_CHAN_PASSIVE_SCAN;
353
354 }
355
356 return 0;
357}
358
359static void wl1271_conf_init(struct wl1271 *wl)
360{
361
362 /*
363 * This function applies the default configuration to the driver. This
364 * function is invoked upon driver load (spi probe.)
365 *
366 * The configuration is stored in a run-time structure in order to
367 * facilitate for run-time adjustment of any of the parameters. Making
368 * changes to the configuration structure will apply the new values on
369 * the next interface up (wl1271_op_start.)
370 */
371
372 /* apply driver default configuration */
373 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
374}
375
376
377static int wl1271_plt_init(struct wl1271 *wl)
378{
379 struct conf_tx_ac_category *conf_ac;
380 struct conf_tx_tid *conf_tid;
381 int ret, i;
382
383 ret = wl1271_cmd_general_parms(wl);
384 if (ret < 0)
385 return ret;
386
387 ret = wl1271_cmd_radio_parms(wl);
388 if (ret < 0)
389 return ret;
390
391 ret = wl1271_cmd_ext_radio_parms(wl);
392 if (ret < 0)
393 return ret;
394
395 ret = wl1271_init_templates_config(wl);
396 if (ret < 0)
397 return ret;
398
399 ret = wl1271_acx_init_mem_config(wl);
400 if (ret < 0)
401 return ret;
402
403 /* PHY layer config */
404 ret = wl1271_init_phy_config(wl);
405 if (ret < 0)
406 goto out_free_memmap;
407
408 ret = wl1271_acx_dco_itrim_params(wl);
409 if (ret < 0)
410 goto out_free_memmap;
411
412 /* Initialize connection monitoring thresholds */
413 ret = wl1271_acx_conn_monit_params(wl, false);
414 if (ret < 0)
415 goto out_free_memmap;
416
417 /* Bluetooth WLAN coexistence */
418 ret = wl1271_init_pta(wl);
419 if (ret < 0)
420 goto out_free_memmap;
421
422 /* Energy detection */
423 ret = wl1271_init_energy_detection(wl);
424 if (ret < 0)
425 goto out_free_memmap;
426
427 /* Default fragmentation threshold */
428 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
429 if (ret < 0)
430 goto out_free_memmap;
431
432 /* Default TID/AC configuration */
433 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
434 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
435 conf_ac = &wl->conf.tx.ac_conf[i];
436 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
437 conf_ac->cw_max, conf_ac->aifsn,
438 conf_ac->tx_op_limit);
439 if (ret < 0)
440 goto out_free_memmap;
441
442 conf_tid = &wl->conf.tx.tid_conf[i];
443 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
444 conf_tid->channel_type,
445 conf_tid->tsid,
446 conf_tid->ps_scheme,
447 conf_tid->ack_policy,
448 conf_tid->apsd_conf[0],
449 conf_tid->apsd_conf[1]);
450 if (ret < 0)
451 goto out_free_memmap;
452 }
453
454 /* Enable data path */
455 ret = wl1271_cmd_data_path(wl, 1);
456 if (ret < 0)
457 goto out_free_memmap;
458
459 /* Configure for CAM power saving (ie. always active) */
460 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
461 if (ret < 0)
462 goto out_free_memmap;
463
464 /* configure PM */
465 ret = wl1271_acx_pm_config(wl);
466 if (ret < 0)
467 goto out_free_memmap;
468
469 return 0;
470
471 out_free_memmap:
472 kfree(wl->target_mem_map);
473 wl->target_mem_map = NULL;
474
475 return ret;
476}
477
478static void wl1271_fw_status(struct wl1271 *wl,
479 struct wl1271_fw_status *status)
480{
481 struct timespec ts;
482 u32 total = 0;
483 int i;
484
485 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
486
487 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
488 "drv_rx_counter = %d, tx_results_counter = %d)",
489 status->intr,
490 status->fw_rx_counter,
491 status->drv_rx_counter,
492 status->tx_results_counter);
493
494 /* update number of available TX blocks */
495 for (i = 0; i < NUM_TX_QUEUES; i++) {
496 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
497 wl->tx_blocks_freed[i];
498
499 wl->tx_blocks_freed[i] =
500 le32_to_cpu(status->tx_released_blks[i]);
501 wl->tx_blocks_available += cnt;
502 total += cnt;
503 }
504
505 /* if more blocks are available now, tx work can be scheduled */
506 if (total)
507 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
508
509 /* update the host-chipset time offset */
510 getnstimeofday(&ts);
511 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
512 (s64)le32_to_cpu(status->fw_localtime);
513}
514
515#define WL1271_IRQ_MAX_LOOPS 10
516
517static void wl1271_irq_work(struct work_struct *work)
518{
519 int ret;
520 u32 intr;
521 int loopcount = WL1271_IRQ_MAX_LOOPS;
522 unsigned long flags;
523 struct wl1271 *wl =
524 container_of(work, struct wl1271, irq_work);
525
526 mutex_lock(&wl->mutex);
527
528 wl1271_debug(DEBUG_IRQ, "IRQ work");
529
530 if (unlikely(wl->state == WL1271_STATE_OFF))
531 goto out;
532
533 ret = wl1271_ps_elp_wakeup(wl, true);
534 if (ret < 0)
535 goto out;
536
537 spin_lock_irqsave(&wl->wl_lock, flags);
538 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
539 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
540 spin_unlock_irqrestore(&wl->wl_lock, flags);
541 loopcount--;
542
543 wl1271_fw_status(wl, wl->fw_status);
544 intr = le32_to_cpu(wl->fw_status->intr);
545 if (!intr) {
546 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
547 spin_lock_irqsave(&wl->wl_lock, flags);
548 continue;
549 }
550
551 intr &= WL1271_INTR_MASK;
552
553 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
554 wl1271_error("watchdog interrupt received! "
555 "starting recovery.");
556 ieee80211_queue_work(wl->hw, &wl->recovery_work);
557
558 /* restarting the chip. ignore any other interrupt. */
559 goto out;
560 }
561
562 if (intr & WL1271_ACX_INTR_DATA) {
563 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
564
565 /* check for tx results */
566 if (wl->fw_status->tx_results_counter !=
567 (wl->tx_results_count & 0xff))
568 wl1271_tx_complete(wl);
569
570 /* Check if any tx blocks were freed */
571 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
572 !skb_queue_empty(&wl->tx_queue)) {
573 /*
574 * In order to avoid starvation of the TX path,
575 * call the work function directly.
576 */
577 wl1271_tx_work_locked(wl);
578 }
579
580 wl1271_rx(wl, wl->fw_status);
581 }
582
583 if (intr & WL1271_ACX_INTR_EVENT_A) {
584 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
585 wl1271_event_handle(wl, 0);
586 }
587
588 if (intr & WL1271_ACX_INTR_EVENT_B) {
589 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
590 wl1271_event_handle(wl, 1);
591 }
592
593 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
594 wl1271_debug(DEBUG_IRQ,
595 "WL1271_ACX_INTR_INIT_COMPLETE");
596
597 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
598 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
599
600 spin_lock_irqsave(&wl->wl_lock, flags);
601 }
602
603 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
604 ieee80211_queue_work(wl->hw, &wl->irq_work);
605 else
606 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
607 spin_unlock_irqrestore(&wl->wl_lock, flags);
608
609 wl1271_ps_elp_sleep(wl);
610
611out:
612 mutex_unlock(&wl->mutex);
613}
614
615static int wl1271_fetch_firmware(struct wl1271 *wl)
616{
617 const struct firmware *fw;
618 int ret;
619
620 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
621
622 if (ret < 0) {
623 wl1271_error("could not get firmware: %d", ret);
624 return ret;
625 }
626
627 if (fw->size % 4) {
628 wl1271_error("firmware size is not multiple of 32 bits: %zu",
629 fw->size);
630 ret = -EILSEQ;
631 goto out;
632 }
633
634 wl->fw_len = fw->size;
635 wl->fw = vmalloc(wl->fw_len);
636
637 if (!wl->fw) {
638 wl1271_error("could not allocate memory for the firmware");
639 ret = -ENOMEM;
640 goto out;
641 }
642
643 memcpy(wl->fw, fw->data, wl->fw_len);
644
645 ret = 0;
646
647out:
648 release_firmware(fw);
649
650 return ret;
651}
652
653static int wl1271_fetch_nvs(struct wl1271 *wl)
654{
655 const struct firmware *fw;
656 int ret;
657
658 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
659
660 if (ret < 0) {
661 wl1271_error("could not get nvs file: %d", ret);
662 return ret;
663 }
664
665 wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
666
667 if (!wl->nvs) {
668 wl1271_error("could not allocate memory for the nvs file");
669 ret = -ENOMEM;
670 goto out;
671 }
672
673 wl->nvs_len = fw->size;
674
675out:
676 release_firmware(fw);
677
678 return ret;
679}
680
681static void wl1271_recovery_work(struct work_struct *work)
682{
683 struct wl1271 *wl =
684 container_of(work, struct wl1271, recovery_work);
685
686 mutex_lock(&wl->mutex);
687
688 if (wl->state != WL1271_STATE_ON)
689 goto out;
690
691 wl1271_info("Hardware recovery in progress.");
692
693 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
694 ieee80211_connection_loss(wl->vif);
695
696 /* reboot the chipset */
697 __wl1271_op_remove_interface(wl);
698 ieee80211_restart_hw(wl->hw);
699
700out:
701 mutex_unlock(&wl->mutex);
702}
703
704static void wl1271_fw_wakeup(struct wl1271 *wl)
705{
706 u32 elp_reg;
707
708 elp_reg = ELPCTRL_WAKE_UP;
709 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
710}
711
712static int wl1271_setup(struct wl1271 *wl)
713{
714 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
715 if (!wl->fw_status)
716 return -ENOMEM;
717
718 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
719 if (!wl->tx_res_if) {
720 kfree(wl->fw_status);
721 return -ENOMEM;
722 }
723
724 return 0;
725}
726
727static int wl1271_chip_wakeup(struct wl1271 *wl)
728{
729 struct wl1271_partition_set partition;
730 int ret = 0;
731
732 msleep(WL1271_PRE_POWER_ON_SLEEP);
733 ret = wl1271_power_on(wl);
734 if (ret < 0)
735 goto out;
736 msleep(WL1271_POWER_ON_SLEEP);
737 wl1271_io_reset(wl);
738 wl1271_io_init(wl);
739
740 /* We don't need a real memory partition here, because we only want
741 * to use the registers at this point. */
742 memset(&partition, 0, sizeof(partition));
743 partition.reg.start = REGISTERS_BASE;
744 partition.reg.size = REGISTERS_DOWN_SIZE;
745 wl1271_set_partition(wl, &partition);
746
747 /* ELP module wake up */
748 wl1271_fw_wakeup(wl);
749
750 /* whal_FwCtrl_BootSm() */
751
752 /* 0. read chip id from CHIP_ID */
753 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
754
755 /* 1. check if chip id is valid */
756
757 switch (wl->chip.id) {
758 case CHIP_ID_1271_PG10:
759 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
760 wl->chip.id);
761
762 ret = wl1271_setup(wl);
763 if (ret < 0)
764 goto out;
765 break;
766 case CHIP_ID_1271_PG20:
767 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
768 wl->chip.id);
769
770 ret = wl1271_setup(wl);
771 if (ret < 0)
772 goto out;
773 break;
774 default:
775 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
776 ret = -ENODEV;
777 goto out;
778 }
779
780 if (wl->fw == NULL) {
781 ret = wl1271_fetch_firmware(wl);
782 if (ret < 0)
783 goto out;
784 }
785
786 /* No NVS from netlink, try to get it from the filesystem */
787 if (wl->nvs == NULL) {
788 ret = wl1271_fetch_nvs(wl);
789 if (ret < 0)
790 goto out;
791 }
792
793out:
794 return ret;
795}
796
797int wl1271_plt_start(struct wl1271 *wl)
798{
799 int retries = WL1271_BOOT_RETRIES;
800 int ret;
801
802 mutex_lock(&wl->mutex);
803
804 wl1271_notice("power up");
805
806 if (wl->state != WL1271_STATE_OFF) {
807 wl1271_error("cannot go into PLT state because not "
808 "in off state: %d", wl->state);
809 ret = -EBUSY;
810 goto out;
811 }
812
813 while (retries) {
814 retries--;
815 ret = wl1271_chip_wakeup(wl);
816 if (ret < 0)
817 goto power_off;
818
819 ret = wl1271_boot(wl);
820 if (ret < 0)
821 goto power_off;
822
823 ret = wl1271_plt_init(wl);
824 if (ret < 0)
825 goto irq_disable;
826
827 wl->state = WL1271_STATE_PLT;
828 wl1271_notice("firmware booted in PLT mode (%s)",
829 wl->chip.fw_ver);
830 goto out;
831
832irq_disable:
833 wl1271_disable_interrupts(wl);
834 mutex_unlock(&wl->mutex);
835 /* Unlocking the mutex in the middle of handling is
836 inherently unsafe. In this case we deem it safe to do,
837 because we need to let any possibly pending IRQ out of
838 the system (and while we are WL1271_STATE_OFF the IRQ
839 work function will not do anything.) Also, any other
840 possible concurrent operations will fail due to the
841 current state, hence the wl1271 struct should be safe. */
842 cancel_work_sync(&wl->irq_work);
843 mutex_lock(&wl->mutex);
844power_off:
845 wl1271_power_off(wl);
846 }
847
848 wl1271_error("firmware boot in PLT mode failed despite %d retries",
849 WL1271_BOOT_RETRIES);
850out:
851 mutex_unlock(&wl->mutex);
852
853 return ret;
854}
855
856int wl1271_plt_stop(struct wl1271 *wl)
857{
858 int ret = 0;
859
860 mutex_lock(&wl->mutex);
861
862 wl1271_notice("power down");
863
864 if (wl->state != WL1271_STATE_PLT) {
865 wl1271_error("cannot power down because not in PLT "
866 "state: %d", wl->state);
867 ret = -EBUSY;
868 goto out;
869 }
870
871 wl1271_disable_interrupts(wl);
872 wl1271_power_off(wl);
873
874 wl->state = WL1271_STATE_OFF;
875 wl->rx_counter = 0;
876
877out:
878 mutex_unlock(&wl->mutex);
879
880 cancel_work_sync(&wl->irq_work);
881 cancel_work_sync(&wl->recovery_work);
882
883 return ret;
884}
885
886static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
887{
888 struct wl1271 *wl = hw->priv;
889 struct ieee80211_conf *conf = &hw->conf;
890 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
891 struct ieee80211_sta *sta = txinfo->control.sta;
892 unsigned long flags;
893
894 /*
895 * peek into the rates configured in the STA entry.
896 * The rates set after connection stage, The first block only BG sets:
897 * the compare is for bit 0-16 of sta_rate_set. The second block add
898 * HT rates in case of HT supported.
899 */
900 spin_lock_irqsave(&wl->wl_lock, flags);
901 if (sta &&
902 (sta->supp_rates[conf->channel->band] !=
903 (wl->sta_rate_set & HW_BG_RATES_MASK))) {
904 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
905 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
906 }
907
908#ifdef CONFIG_WL12XX_HT
909 if (sta &&
910 sta->ht_cap.ht_supported &&
911 ((wl->sta_rate_set >> HW_HT_RATES_OFFSET) !=
912 sta->ht_cap.mcs.rx_mask[0])) {
913 /* Clean MCS bits before setting them */
914 wl->sta_rate_set &= HW_BG_RATES_MASK;
915 wl->sta_rate_set |=
916 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
917 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
918 }
919#endif
920 spin_unlock_irqrestore(&wl->wl_lock, flags);
921
922 /* queue the packet */
923 skb_queue_tail(&wl->tx_queue, skb);
924
925 /*
926 * The chip specific setup must run before the first TX packet -
927 * before that, the tx_work will not be initialized!
928 */
929
930 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
931 ieee80211_queue_work(wl->hw, &wl->tx_work);
932
933 /*
934 * The workqueue is slow to process the tx_queue and we need stop
935 * the queue here, otherwise the queue will get too long.
936 */
937 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
938 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
939
940 spin_lock_irqsave(&wl->wl_lock, flags);
941 ieee80211_stop_queues(wl->hw);
942 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
943 spin_unlock_irqrestore(&wl->wl_lock, flags);
944 }
945
946 return NETDEV_TX_OK;
947}
948
949static struct notifier_block wl1271_dev_notifier = {
950 .notifier_call = wl1271_dev_notify,
951};
952
953static int wl1271_op_start(struct ieee80211_hw *hw)
954{
955 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
956
957 /*
958 * We have to delay the booting of the hardware because
959 * we need to know the local MAC address before downloading and
960 * initializing the firmware. The MAC address cannot be changed
961 * after boot, and without the proper MAC address, the firmware
962 * will not function properly.
963 *
964 * The MAC address is first known when the corresponding interface
965 * is added. That is where we will initialize the hardware.
966 */
967
968 return 0;
969}
970
971static void wl1271_op_stop(struct ieee80211_hw *hw)
972{
973 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
974}
975
976static int wl1271_op_add_interface(struct ieee80211_hw *hw,
977 struct ieee80211_vif *vif)
978{
979 struct wl1271 *wl = hw->priv;
980 struct wiphy *wiphy = hw->wiphy;
981 int retries = WL1271_BOOT_RETRIES;
982 int ret = 0;
983 bool booted = false;
984
985 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
986 vif->type, vif->addr);
987
988 mutex_lock(&wl->mutex);
989 if (wl->vif) {
990 wl1271_debug(DEBUG_MAC80211,
991 "multiple vifs are not supported yet");
992 ret = -EBUSY;
993 goto out;
994 }
995
996 switch (vif->type) {
997 case NL80211_IFTYPE_STATION:
998 wl->bss_type = BSS_TYPE_STA_BSS;
999 wl->set_bss_type = BSS_TYPE_STA_BSS;
1000 break;
1001 case NL80211_IFTYPE_ADHOC:
1002 wl->bss_type = BSS_TYPE_IBSS;
1003 wl->set_bss_type = BSS_TYPE_STA_BSS;
1004 break;
1005 default:
1006 ret = -EOPNOTSUPP;
1007 goto out;
1008 }
1009
1010 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1011
1012 if (wl->state != WL1271_STATE_OFF) {
1013 wl1271_error("cannot start because not in off state: %d",
1014 wl->state);
1015 ret = -EBUSY;
1016 goto out;
1017 }
1018
1019 while (retries) {
1020 retries--;
1021 ret = wl1271_chip_wakeup(wl);
1022 if (ret < 0)
1023 goto power_off;
1024
1025 ret = wl1271_boot(wl);
1026 if (ret < 0)
1027 goto power_off;
1028
1029 ret = wl1271_hw_init(wl);
1030 if (ret < 0)
1031 goto irq_disable;
1032
1033 booted = true;
1034 break;
1035
1036irq_disable:
1037 wl1271_disable_interrupts(wl);
1038 mutex_unlock(&wl->mutex);
1039 /* Unlocking the mutex in the middle of handling is
1040 inherently unsafe. In this case we deem it safe to do,
1041 because we need to let any possibly pending IRQ out of
1042 the system (and while we are WL1271_STATE_OFF the IRQ
1043 work function will not do anything.) Also, any other
1044 possible concurrent operations will fail due to the
1045 current state, hence the wl1271 struct should be safe. */
1046 cancel_work_sync(&wl->irq_work);
1047 mutex_lock(&wl->mutex);
1048power_off:
1049 wl1271_power_off(wl);
1050 }
1051
1052 if (!booted) {
1053 wl1271_error("firmware boot failed despite %d retries",
1054 WL1271_BOOT_RETRIES);
1055 goto out;
1056 }
1057
1058 wl->vif = vif;
1059 wl->state = WL1271_STATE_ON;
1060 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
1061
1062 /* update hw/fw version info in wiphy struct */
1063 wiphy->hw_version = wl->chip.id;
1064 strncpy(wiphy->fw_version, wl->chip.fw_ver,
1065 sizeof(wiphy->fw_version));
1066
1067out:
1068 mutex_unlock(&wl->mutex);
1069
1070 if (!ret)
1071 list_add(&wl->list, &wl_list);
1072
1073 return ret;
1074}
1075
1076static void __wl1271_op_remove_interface(struct wl1271 *wl)
1077{
1078 int i;
1079
1080 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1081
1082 wl1271_info("down");
1083
1084 list_del(&wl->list);
1085
1086 WARN_ON(wl->state != WL1271_STATE_ON);
1087
1088 /* enable dyn ps just in case (if left on due to fw crash etc) */
1089 if (wl->bss_type == BSS_TYPE_STA_BSS)
1090 ieee80211_enable_dyn_ps(wl->vif);
1091
1092 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1093 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1094 kfree(wl->scan.scanned_ch);
1095 wl->scan.scanned_ch = NULL;
1096 wl->scan.req = NULL;
1097 ieee80211_scan_completed(wl->hw, true);
1098 }
1099
1100 wl->state = WL1271_STATE_OFF;
1101
1102 wl1271_disable_interrupts(wl);
1103
1104 mutex_unlock(&wl->mutex);
1105
1106 cancel_delayed_work_sync(&wl->scan_complete_work);
1107 cancel_work_sync(&wl->irq_work);
1108 cancel_work_sync(&wl->tx_work);
1109 cancel_delayed_work_sync(&wl->pspoll_work);
1110 cancel_delayed_work_sync(&wl->elp_work);
1111
1112 mutex_lock(&wl->mutex);
1113
1114 /* let's notify MAC80211 about the remaining pending TX frames */
1115 wl1271_tx_reset(wl);
1116 wl1271_power_off(wl);
1117
1118 memset(wl->bssid, 0, ETH_ALEN);
1119 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1120 wl->ssid_len = 0;
1121 wl->bss_type = MAX_BSS_TYPE;
1122 wl->set_bss_type = MAX_BSS_TYPE;
1123 wl->band = IEEE80211_BAND_2GHZ;
1124
1125 wl->rx_counter = 0;
1126 wl->psm_entry_retry = 0;
1127 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1128 wl->tx_blocks_available = 0;
1129 wl->tx_results_count = 0;
1130 wl->tx_packets_count = 0;
1131 wl->tx_security_last_seq = 0;
1132 wl->tx_security_seq = 0;
1133 wl->time_offset = 0;
1134 wl->session_counter = 0;
1135 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1136 wl->sta_rate_set = 0;
1137 wl->flags = 0;
1138 wl->vif = NULL;
1139 wl->filters = 0;
1140
1141 for (i = 0; i < NUM_TX_QUEUES; i++)
1142 wl->tx_blocks_freed[i] = 0;
1143
1144 wl1271_debugfs_reset(wl);
1145
1146 kfree(wl->fw_status);
1147 wl->fw_status = NULL;
1148 kfree(wl->tx_res_if);
1149 wl->tx_res_if = NULL;
1150 kfree(wl->target_mem_map);
1151 wl->target_mem_map = NULL;
1152}
1153
1154static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1155 struct ieee80211_vif *vif)
1156{
1157 struct wl1271 *wl = hw->priv;
1158
1159 mutex_lock(&wl->mutex);
1160 WARN_ON(wl->vif != vif);
1161 __wl1271_op_remove_interface(wl);
1162 mutex_unlock(&wl->mutex);
1163
1164 cancel_work_sync(&wl->recovery_work);
1165}
1166
1167static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1168{
1169 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1170 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1171
1172 /* combine requested filters with current filter config */
1173 filters = wl->filters | filters;
1174
1175 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1176
1177 if (filters & FIF_PROMISC_IN_BSS) {
1178 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1179 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1180 wl->rx_config |= CFG_BSSID_FILTER_EN;
1181 }
1182 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1183 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1184 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1185 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1186 }
1187 if (filters & FIF_OTHER_BSS) {
1188 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1189 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1190 }
1191 if (filters & FIF_CONTROL) {
1192 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1193 wl->rx_filter |= CFG_RX_CTL_EN;
1194 }
1195 if (filters & FIF_FCSFAIL) {
1196 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1197 wl->rx_filter |= CFG_RX_FCS_ERROR;
1198 }
1199}
1200
1201static int wl1271_dummy_join(struct wl1271 *wl)
1202{
1203 int ret = 0;
1204 /* we need to use a dummy BSSID for now */
1205 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1206 0xad, 0xbe, 0xef };
1207
1208 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1209
1210 /* pass through frames from all BSS */
1211 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1212
1213 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1214 if (ret < 0)
1215 goto out;
1216
1217 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1218
1219out:
1220 return ret;
1221}
1222
1223static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1224{
1225 int ret;
1226
1227 /*
1228 * One of the side effects of the JOIN command is that is clears
1229 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1230 * to a WPA/WPA2 access point will therefore kill the data-path.
1231 * Currently there is no supported scenario for JOIN during
1232 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1233 * must be handled somehow.
1234 *
1235 */
1236 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1237 wl1271_info("JOIN while associated.");
1238
1239 if (set_assoc)
1240 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1241
1242 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1243 if (ret < 0)
1244 goto out;
1245
1246 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1247
1248 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1249 goto out;
1250
1251 /*
1252 * The join command disable the keep-alive mode, shut down its process,
1253 * and also clear the template config, so we need to reset it all after
1254 * the join. The acx_aid starts the keep-alive process, and the order
1255 * of the commands below is relevant.
1256 */
1257 ret = wl1271_acx_keep_alive_mode(wl, true);
1258 if (ret < 0)
1259 goto out;
1260
1261 ret = wl1271_acx_aid(wl, wl->aid);
1262 if (ret < 0)
1263 goto out;
1264
1265 ret = wl1271_cmd_build_klv_null_data(wl);
1266 if (ret < 0)
1267 goto out;
1268
1269 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1270 ACX_KEEP_ALIVE_TPL_VALID);
1271 if (ret < 0)
1272 goto out;
1273
1274out:
1275 return ret;
1276}
1277
1278static int wl1271_unjoin(struct wl1271 *wl)
1279{
1280 int ret;
1281
1282 /* to stop listening to a channel, we disconnect */
1283 ret = wl1271_cmd_disconnect(wl);
1284 if (ret < 0)
1285 goto out;
1286
1287 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1288 memset(wl->bssid, 0, ETH_ALEN);
1289
1290 /* stop filterting packets based on bssid */
1291 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1292
1293out:
1294 return ret;
1295}
1296
1297static void wl1271_set_band_rate(struct wl1271 *wl)
1298{
1299 if (wl->band == IEEE80211_BAND_2GHZ)
1300 wl->basic_rate_set = wl->conf.tx.basic_rate;
1301 else
1302 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1303}
1304
1305static u32 wl1271_min_rate_get(struct wl1271 *wl)
1306{
1307 int i;
1308 u32 rate = 0;
1309
1310 if (!wl->basic_rate_set) {
1311 WARN_ON(1);
1312 wl->basic_rate_set = wl->conf.tx.basic_rate;
1313 }
1314
1315 for (i = 0; !rate; i++) {
1316 if ((wl->basic_rate_set >> i) & 0x1)
1317 rate = 1 << i;
1318 }
1319
1320 return rate;
1321}
1322
1323static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1324{
1325 int ret;
1326
1327 if (idle) {
1328 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1329 ret = wl1271_unjoin(wl);
1330 if (ret < 0)
1331 goto out;
1332 }
1333 wl->rate_set = wl1271_min_rate_get(wl);
1334 wl->sta_rate_set = 0;
1335 ret = wl1271_acx_rate_policies(wl);
1336 if (ret < 0)
1337 goto out;
1338 ret = wl1271_acx_keep_alive_config(
1339 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1340 ACX_KEEP_ALIVE_TPL_INVALID);
1341 if (ret < 0)
1342 goto out;
1343 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1344 } else {
1345 /* increment the session counter */
1346 wl->session_counter++;
1347 if (wl->session_counter >= SESSION_COUNTER_MAX)
1348 wl->session_counter = 0;
1349 ret = wl1271_dummy_join(wl);
1350 if (ret < 0)
1351 goto out;
1352 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1353 }
1354
1355out:
1356 return ret;
1357}
1358
1359static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1360{
1361 struct wl1271 *wl = hw->priv;
1362 struct ieee80211_conf *conf = &hw->conf;
1363 int channel, ret = 0;
1364
1365 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1366
1367 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1368 channel,
1369 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1370 conf->power_level,
1371 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1372
1373 /*
1374 * mac80211 will go to idle nearly immediately after transmitting some
1375 * frames, such as the deauth. To make sure those frames reach the air,
1376 * wait here until the TX queue is fully flushed.
1377 */
1378 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1379 (conf->flags & IEEE80211_CONF_IDLE))
1380 wl1271_tx_flush(wl);
1381
1382 mutex_lock(&wl->mutex);
1383
1384 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1385 ret = -EAGAIN;
1386 goto out;
1387 }
1388
1389 ret = wl1271_ps_elp_wakeup(wl, false);
1390 if (ret < 0)
1391 goto out;
1392
1393 /* if the channel changes while joined, join again */
1394 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1395 ((wl->band != conf->channel->band) ||
1396 (wl->channel != channel))) {
1397 wl->band = conf->channel->band;
1398 wl->channel = channel;
1399
1400 /*
1401 * FIXME: the mac80211 should really provide a fixed rate
1402 * to use here. for now, just use the smallest possible rate
1403 * for the band as a fixed rate for association frames and
1404 * other control messages.
1405 */
1406 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1407 wl1271_set_band_rate(wl);
1408
1409 wl->basic_rate = wl1271_min_rate_get(wl);
1410 ret = wl1271_acx_rate_policies(wl);
1411 if (ret < 0)
1412 wl1271_warning("rate policy for update channel "
1413 "failed %d", ret);
1414
1415 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1416 ret = wl1271_join(wl, false);
1417 if (ret < 0)
1418 wl1271_warning("cmd join to update channel "
1419 "failed %d", ret);
1420 }
1421 }
1422
1423 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1424 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1425 if (ret < 0)
1426 wl1271_warning("idle mode change failed %d", ret);
1427 }
1428
1429 /*
1430 * if mac80211 changes the PSM mode, make sure the mode is not
1431 * incorrectly changed after the pspoll failure active window.
1432 */
1433 if (changed & IEEE80211_CONF_CHANGE_PS)
1434 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1435
1436 if (conf->flags & IEEE80211_CONF_PS &&
1437 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1438 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1439
1440 /*
1441 * We enter PSM only if we're already associated.
1442 * If we're not, we'll enter it when joining an SSID,
1443 * through the bss_info_changed() hook.
1444 */
1445 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1446 wl1271_debug(DEBUG_PSM, "psm enabled");
1447 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1448 wl->basic_rate, true);
1449 }
1450 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1451 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1452 wl1271_debug(DEBUG_PSM, "psm disabled");
1453
1454 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1455
1456 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1457 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1458 wl->basic_rate, true);
1459 }
1460
1461 if (conf->power_level != wl->power_level) {
1462 ret = wl1271_acx_tx_power(wl, conf->power_level);
1463 if (ret < 0)
1464 goto out_sleep;
1465
1466 wl->power_level = conf->power_level;
1467 }
1468
1469out_sleep:
1470 wl1271_ps_elp_sleep(wl);
1471
1472out:
1473 mutex_unlock(&wl->mutex);
1474
1475 return ret;
1476}
1477
1478struct wl1271_filter_params {
1479 bool enabled;
1480 int mc_list_length;
1481 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1482};
1483
1484static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1485 struct netdev_hw_addr_list *mc_list)
1486{
1487 struct wl1271_filter_params *fp;
1488 struct netdev_hw_addr *ha;
1489 struct wl1271 *wl = hw->priv;
1490
1491 if (unlikely(wl->state == WL1271_STATE_OFF))
1492 return 0;
1493
1494 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1495 if (!fp) {
1496 wl1271_error("Out of memory setting filters.");
1497 return 0;
1498 }
1499
1500 /* update multicast filtering parameters */
1501 fp->mc_list_length = 0;
1502 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1503 fp->enabled = false;
1504 } else {
1505 fp->enabled = true;
1506 netdev_hw_addr_list_for_each(ha, mc_list) {
1507 memcpy(fp->mc_list[fp->mc_list_length],
1508 ha->addr, ETH_ALEN);
1509 fp->mc_list_length++;
1510 }
1511 }
1512
1513 return (u64)(unsigned long)fp;
1514}
1515
1516#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1517 FIF_ALLMULTI | \
1518 FIF_FCSFAIL | \
1519 FIF_BCN_PRBRESP_PROMISC | \
1520 FIF_CONTROL | \
1521 FIF_OTHER_BSS)
1522
1523static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1524 unsigned int changed,
1525 unsigned int *total, u64 multicast)
1526{
1527 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1528 struct wl1271 *wl = hw->priv;
1529 int ret;
1530
1531 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1532
1533 mutex_lock(&wl->mutex);
1534
1535 *total &= WL1271_SUPPORTED_FILTERS;
1536 changed &= WL1271_SUPPORTED_FILTERS;
1537
1538 if (unlikely(wl->state == WL1271_STATE_OFF))
1539 goto out;
1540
1541 ret = wl1271_ps_elp_wakeup(wl, false);
1542 if (ret < 0)
1543 goto out;
1544
1545
1546 if (*total & FIF_ALLMULTI)
1547 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1548 else if (fp)
1549 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1550 fp->mc_list,
1551 fp->mc_list_length);
1552 if (ret < 0)
1553 goto out_sleep;
1554
1555 /* determine, whether supported filter values have changed */
1556 if (changed == 0)
1557 goto out_sleep;
1558
1559 /* configure filters */
1560 wl->filters = *total;
1561 wl1271_configure_filters(wl, 0);
1562
1563 /* apply configured filters */
1564 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1565 if (ret < 0)
1566 goto out_sleep;
1567
1568out_sleep:
1569 wl1271_ps_elp_sleep(wl);
1570
1571out:
1572 mutex_unlock(&wl->mutex);
1573 kfree(fp);
1574}
1575
1576static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1577 struct ieee80211_vif *vif,
1578 struct ieee80211_sta *sta,
1579 struct ieee80211_key_conf *key_conf)
1580{
1581 struct wl1271 *wl = hw->priv;
1582 const u8 *addr;
1583 int ret;
1584 u32 tx_seq_32 = 0;
1585 u16 tx_seq_16 = 0;
1586 u8 key_type;
1587
1588 static const u8 bcast_addr[ETH_ALEN] =
1589 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1590
1591 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1592
1593 addr = sta ? sta->addr : bcast_addr;
1594
1595 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1596 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1597 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1598 key_conf->cipher, key_conf->keyidx,
1599 key_conf->keylen, key_conf->flags);
1600 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1601
1602 if (is_zero_ether_addr(addr)) {
1603 /* We dont support TX only encryption */
1604 ret = -EOPNOTSUPP;
1605 goto out;
1606 }
1607
1608 mutex_lock(&wl->mutex);
1609
1610 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1611 ret = -EAGAIN;
1612 goto out_unlock;
1613 }
1614
1615 ret = wl1271_ps_elp_wakeup(wl, false);
1616 if (ret < 0)
1617 goto out_unlock;
1618
1619 switch (key_conf->cipher) {
1620 case WLAN_CIPHER_SUITE_WEP40:
1621 case WLAN_CIPHER_SUITE_WEP104:
1622 key_type = KEY_WEP;
1623
1624 key_conf->hw_key_idx = key_conf->keyidx;
1625 break;
1626 case WLAN_CIPHER_SUITE_TKIP:
1627 key_type = KEY_TKIP;
1628
1629 key_conf->hw_key_idx = key_conf->keyidx;
1630 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1631 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1632 break;
1633 case WLAN_CIPHER_SUITE_CCMP:
1634 key_type = KEY_AES;
1635
1636 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1637 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1638 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1639 break;
1640 case WL1271_CIPHER_SUITE_GEM:
1641 key_type = KEY_GEM;
1642 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1643 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1644 break;
1645 default:
1646 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1647
1648 ret = -EOPNOTSUPP;
1649 goto out_sleep;
1650 }
1651
1652 switch (cmd) {
1653 case SET_KEY:
1654 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1655 key_conf->keyidx, key_type,
1656 key_conf->keylen, key_conf->key,
1657 addr, tx_seq_32, tx_seq_16);
1658 if (ret < 0) {
1659 wl1271_error("Could not add or replace key");
1660 goto out_sleep;
1661 }
1662
1663 /* the default WEP key needs to be configured at least once */
1664 if (key_type == KEY_WEP) {
1665 ret = wl1271_cmd_set_default_wep_key(wl,
1666 wl->default_key);
1667 if (ret < 0)
1668 goto out_sleep;
1669 }
1670 break;
1671
1672 case DISABLE_KEY:
1673 /* The wl1271 does not allow to remove unicast keys - they
1674 will be cleared automatically on next CMD_JOIN. Ignore the
1675 request silently, as we dont want the mac80211 to emit
1676 an error message. */
1677 if (!is_broadcast_ether_addr(addr))
1678 break;
1679
1680 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1681 key_conf->keyidx, key_type,
1682 key_conf->keylen, key_conf->key,
1683 addr, 0, 0);
1684 if (ret < 0) {
1685 wl1271_error("Could not remove key");
1686 goto out_sleep;
1687 }
1688 break;
1689
1690 default:
1691 wl1271_error("Unsupported key cmd 0x%x", cmd);
1692 ret = -EOPNOTSUPP;
1693 break;
1694 }
1695
1696out_sleep:
1697 wl1271_ps_elp_sleep(wl);
1698
1699out_unlock:
1700 mutex_unlock(&wl->mutex);
1701
1702out:
1703 return ret;
1704}
1705
1706static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1707 struct ieee80211_vif *vif,
1708 struct cfg80211_scan_request *req)
1709{
1710 struct wl1271 *wl = hw->priv;
1711 int ret;
1712 u8 *ssid = NULL;
1713 size_t len = 0;
1714
1715 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1716
1717 if (req->n_ssids) {
1718 ssid = req->ssids[0].ssid;
1719 len = req->ssids[0].ssid_len;
1720 }
1721
1722 mutex_lock(&wl->mutex);
1723
1724 if (wl->state == WL1271_STATE_OFF) {
1725 /*
1726 * We cannot return -EBUSY here because cfg80211 will expect
1727 * a call to ieee80211_scan_completed if we do - in this case
1728 * there won't be any call.
1729 */
1730 ret = -EAGAIN;
1731 goto out;
1732 }
1733
1734 ret = wl1271_ps_elp_wakeup(wl, false);
1735 if (ret < 0)
1736 goto out;
1737
1738 ret = wl1271_scan(hw->priv, ssid, len, req);
1739
1740 wl1271_ps_elp_sleep(wl);
1741
1742out:
1743 mutex_unlock(&wl->mutex);
1744
1745 return ret;
1746}
1747
1748static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
1749{
1750 struct wl1271 *wl = hw->priv;
1751 int ret = 0;
1752
1753 mutex_lock(&wl->mutex);
1754
1755 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1756 ret = -EAGAIN;
1757 goto out;
1758 }
1759
1760 ret = wl1271_ps_elp_wakeup(wl, false);
1761 if (ret < 0)
1762 goto out;
1763
1764 ret = wl1271_acx_frag_threshold(wl, (u16)value);
1765 if (ret < 0)
1766 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
1767
1768 wl1271_ps_elp_sleep(wl);
1769
1770out:
1771 mutex_unlock(&wl->mutex);
1772
1773 return ret;
1774}
1775
1776static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1777{
1778 struct wl1271 *wl = hw->priv;
1779 int ret = 0;
1780
1781 mutex_lock(&wl->mutex);
1782
1783 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1784 ret = -EAGAIN;
1785 goto out;
1786 }
1787
1788 ret = wl1271_ps_elp_wakeup(wl, false);
1789 if (ret < 0)
1790 goto out;
1791
1792 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1793 if (ret < 0)
1794 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1795
1796 wl1271_ps_elp_sleep(wl);
1797
1798out:
1799 mutex_unlock(&wl->mutex);
1800
1801 return ret;
1802}
1803
1804static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1805{
1806 u8 *ptr = beacon->data +
1807 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1808
1809 /* find the location of the ssid in the beacon */
1810 while (ptr < beacon->data + beacon->len) {
1811 if (ptr[0] == WLAN_EID_SSID) {
1812 wl->ssid_len = ptr[1];
1813 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1814 return;
1815 }
1816 ptr += ptr[1];
1817 }
1818 wl1271_error("ad-hoc beacon template has no SSID!\n");
1819}
1820
1821static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1822 struct ieee80211_vif *vif,
1823 struct ieee80211_bss_conf *bss_conf,
1824 u32 changed)
1825{
1826 enum wl1271_cmd_ps_mode mode;
1827 struct wl1271 *wl = hw->priv;
1828 struct ieee80211_sta *sta = ieee80211_find_sta(vif, bss_conf->bssid);
1829 bool do_join = false;
1830 bool set_assoc = false;
1831 int ret;
1832
1833 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1834
1835 mutex_lock(&wl->mutex);
1836
1837 if (unlikely(wl->state == WL1271_STATE_OFF))
1838 goto out;
1839
1840 ret = wl1271_ps_elp_wakeup(wl, false);
1841 if (ret < 0)
1842 goto out;
1843
1844 if ((changed & BSS_CHANGED_BEACON_INT) &&
1845 (wl->bss_type == BSS_TYPE_IBSS)) {
1846 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1847 bss_conf->beacon_int);
1848
1849 wl->beacon_int = bss_conf->beacon_int;
1850 do_join = true;
1851 }
1852
1853 if ((changed & BSS_CHANGED_BEACON) &&
1854 (wl->bss_type == BSS_TYPE_IBSS)) {
1855 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1856
1857 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1858
1859 if (beacon) {
1860 struct ieee80211_hdr *hdr;
1861
1862 wl1271_ssid_set(wl, beacon);
1863 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1864 beacon->data,
1865 beacon->len, 0,
1866 wl1271_min_rate_get(wl));
1867
1868 if (ret < 0) {
1869 dev_kfree_skb(beacon);
1870 goto out_sleep;
1871 }
1872
1873 hdr = (struct ieee80211_hdr *) beacon->data;
1874 hdr->frame_control = cpu_to_le16(
1875 IEEE80211_FTYPE_MGMT |
1876 IEEE80211_STYPE_PROBE_RESP);
1877
1878 ret = wl1271_cmd_template_set(wl,
1879 CMD_TEMPL_PROBE_RESPONSE,
1880 beacon->data,
1881 beacon->len, 0,
1882 wl1271_min_rate_get(wl));
1883 dev_kfree_skb(beacon);
1884 if (ret < 0)
1885 goto out_sleep;
1886
1887 /* Need to update the SSID (for filtering etc) */
1888 do_join = true;
1889 }
1890 }
1891
1892 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1893 (wl->bss_type == BSS_TYPE_IBSS)) {
1894 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1895 bss_conf->enable_beacon ? "enabled" : "disabled");
1896
1897 if (bss_conf->enable_beacon)
1898 wl->set_bss_type = BSS_TYPE_IBSS;
1899 else
1900 wl->set_bss_type = BSS_TYPE_STA_BSS;
1901 do_join = true;
1902 }
1903
1904 if (changed & BSS_CHANGED_CQM) {
1905 bool enable = false;
1906 if (bss_conf->cqm_rssi_thold)
1907 enable = true;
1908 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1909 bss_conf->cqm_rssi_thold,
1910 bss_conf->cqm_rssi_hyst);
1911 if (ret < 0)
1912 goto out;
1913 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1914 }
1915
1916 if ((changed & BSS_CHANGED_BSSID) &&
1917 /*
1918 * Now we know the correct bssid, so we send a new join command
1919 * and enable the BSSID filter
1920 */
1921 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1922 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1923
1924 ret = wl1271_cmd_build_null_data(wl);
1925 if (ret < 0)
1926 goto out_sleep;
1927
1928 ret = wl1271_build_qos_null_data(wl);
1929 if (ret < 0)
1930 goto out_sleep;
1931
1932 /* filter out all packets not from this BSSID */
1933 wl1271_configure_filters(wl, 0);
1934
1935 /* Need to update the BSSID (for filtering etc) */
1936 do_join = true;
1937 }
1938
1939 if (changed & BSS_CHANGED_ASSOC) {
1940 if (bss_conf->assoc) {
1941 u32 rates;
1942 wl->aid = bss_conf->aid;
1943 set_assoc = true;
1944
1945 wl->ps_poll_failures = 0;
1946
1947 /*
1948 * use basic rates from AP, and determine lowest rate
1949 * to use with control frames.
1950 */
1951 rates = bss_conf->basic_rates;
1952 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1953 rates);
1954 wl->basic_rate = wl1271_min_rate_get(wl);
1955 ret = wl1271_acx_rate_policies(wl);
1956 if (ret < 0)
1957 goto out_sleep;
1958
1959 /*
1960 * with wl1271, we don't need to update the
1961 * beacon_int and dtim_period, because the firmware
1962 * updates it by itself when the first beacon is
1963 * received after a join.
1964 */
1965 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1966 if (ret < 0)
1967 goto out_sleep;
1968
1969 /*
1970 * The SSID is intentionally set to NULL here - the
1971 * firmware will set the probe request with a
1972 * broadcast SSID regardless of what we set in the
1973 * template.
1974 */
1975 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1976 NULL, 0, wl->band);
1977
1978 /* enable the connection monitoring feature */
1979 ret = wl1271_acx_conn_monit_params(wl, true);
1980 if (ret < 0)
1981 goto out_sleep;
1982
1983 /* If we want to go in PSM but we're not there yet */
1984 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1985 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1986 mode = STATION_POWER_SAVE_MODE;
1987 ret = wl1271_ps_set_mode(wl, mode,
1988 wl->basic_rate,
1989 true);
1990 if (ret < 0)
1991 goto out_sleep;
1992 }
1993 } else {
1994 /* use defaults when not associated */
1995 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
1996 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1997 wl->aid = 0;
1998
1999 /* re-enable dynamic ps - just in case */
2000 ieee80211_enable_dyn_ps(wl->vif);
2001
2002 /* revert back to minimum rates for the current band */
2003 wl1271_set_band_rate(wl);
2004 wl->basic_rate = wl1271_min_rate_get(wl);
2005 ret = wl1271_acx_rate_policies(wl);
2006 if (ret < 0)
2007 goto out_sleep;
2008
2009 /* disable connection monitor features */
2010 ret = wl1271_acx_conn_monit_params(wl, false);
2011
2012 /* Disable the keep-alive feature */
2013 ret = wl1271_acx_keep_alive_mode(wl, false);
2014 if (ret < 0)
2015 goto out_sleep;
2016
2017 /* restore the bssid filter and go to dummy bssid */
2018 wl1271_unjoin(wl);
2019 wl1271_dummy_join(wl);
2020 }
2021
2022 }
2023
2024 if (changed & BSS_CHANGED_ERP_SLOT) {
2025 if (bss_conf->use_short_slot)
2026 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2027 else
2028 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2029 if (ret < 0) {
2030 wl1271_warning("Set slot time failed %d", ret);
2031 goto out_sleep;
2032 }
2033 }
2034
2035 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2036 if (bss_conf->use_short_preamble)
2037 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2038 else
2039 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2040 }
2041
2042 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2043 if (bss_conf->use_cts_prot)
2044 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2045 else
2046 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2047 if (ret < 0) {
2048 wl1271_warning("Set ctsprotect failed %d", ret);
2049 goto out_sleep;
2050 }
2051 }
2052
2053 /*
2054 * Takes care of: New association with HT enable,
2055 * HT information change in beacon.
2056 */
2057 if (sta &&
2058 (changed & BSS_CHANGED_HT) &&
2059 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2060 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true);
2061 if (ret < 0) {
2062 wl1271_warning("Set ht cap true failed %d", ret);
2063 goto out_sleep;
2064 }
2065 ret = wl1271_acx_set_ht_information(wl,
2066 bss_conf->ht_operation_mode);
2067 if (ret < 0) {
2068 wl1271_warning("Set ht information failed %d", ret);
2069 goto out_sleep;
2070 }
2071 }
2072 /*
2073 * Takes care of: New association without HT,
2074 * Disassociation.
2075 */
2076 else if (sta && (changed & BSS_CHANGED_ASSOC)) {
2077 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, false);
2078 if (ret < 0) {
2079 wl1271_warning("Set ht cap false failed %d", ret);
2080 goto out_sleep;
2081 }
2082 }
2083
2084 if (changed & BSS_CHANGED_ARP_FILTER) {
2085 __be32 addr = bss_conf->arp_addr_list[0];
2086 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2087
2088 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
2089 ret = wl1271_acx_arp_ip_filter(wl, true, addr);
2090 else
2091 ret = wl1271_acx_arp_ip_filter(wl, false, addr);
2092
2093 if (ret < 0)
2094 goto out_sleep;
2095 }
2096
2097 if (do_join) {
2098 ret = wl1271_join(wl, set_assoc);
2099 if (ret < 0) {
2100 wl1271_warning("cmd join failed %d", ret);
2101 goto out_sleep;
2102 }
2103 }
2104
2105out_sleep:
2106 wl1271_ps_elp_sleep(wl);
2107
2108out:
2109 mutex_unlock(&wl->mutex);
2110}
2111
2112static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2113 const struct ieee80211_tx_queue_params *params)
2114{
2115 struct wl1271 *wl = hw->priv;
2116 u8 ps_scheme;
2117 int ret;
2118
2119 mutex_lock(&wl->mutex);
2120
2121 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2122
2123 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2124 ret = -EAGAIN;
2125 goto out;
2126 }
2127
2128 ret = wl1271_ps_elp_wakeup(wl, false);
2129 if (ret < 0)
2130 goto out;
2131
2132 /* the txop is confed in units of 32us by the mac80211, we need us */
2133 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
2134 params->cw_min, params->cw_max,
2135 params->aifs, params->txop << 5);
2136 if (ret < 0)
2137 goto out_sleep;
2138
2139 if (params->uapsd)
2140 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2141 else
2142 ps_scheme = CONF_PS_SCHEME_LEGACY;
2143
2144 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
2145 CONF_CHANNEL_TYPE_EDCF,
2146 wl1271_tx_get_queue(queue),
2147 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
2148 if (ret < 0)
2149 goto out_sleep;
2150
2151out_sleep:
2152 wl1271_ps_elp_sleep(wl);
2153
2154out:
2155 mutex_unlock(&wl->mutex);
2156
2157 return ret;
2158}
2159
2160static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2161{
2162
2163 struct wl1271 *wl = hw->priv;
2164 u64 mactime = ULLONG_MAX;
2165 int ret;
2166
2167 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2168
2169 mutex_lock(&wl->mutex);
2170
2171 if (unlikely(wl->state == WL1271_STATE_OFF))
2172 goto out;
2173
2174 ret = wl1271_ps_elp_wakeup(wl, false);
2175 if (ret < 0)
2176 goto out;
2177
2178 ret = wl1271_acx_tsf_info(wl, &mactime);
2179 if (ret < 0)
2180 goto out_sleep;
2181
2182out_sleep:
2183 wl1271_ps_elp_sleep(wl);
2184
2185out:
2186 mutex_unlock(&wl->mutex);
2187 return mactime;
2188}
2189
2190static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2191 struct survey_info *survey)
2192{
2193 struct wl1271 *wl = hw->priv;
2194 struct ieee80211_conf *conf = &hw->conf;
2195
2196 if (idx != 0)
2197 return -ENOENT;
2198
2199 survey->channel = conf->channel;
2200 survey->filled = SURVEY_INFO_NOISE_DBM;
2201 survey->noise = wl->noise;
2202
2203 return 0;
2204}
2205
2206/* can't be const, mac80211 writes to this */
2207static struct ieee80211_rate wl1271_rates[] = {
2208 { .bitrate = 10,
2209 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2210 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
2211 { .bitrate = 20,
2212 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2213 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
2214 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2215 { .bitrate = 55,
2216 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2217 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
2218 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2219 { .bitrate = 110,
2220 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2221 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
2222 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2223 { .bitrate = 60,
2224 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2225 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2226 { .bitrate = 90,
2227 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2228 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2229 { .bitrate = 120,
2230 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2231 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2232 { .bitrate = 180,
2233 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2234 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2235 { .bitrate = 240,
2236 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2237 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2238 { .bitrate = 360,
2239 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2240 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2241 { .bitrate = 480,
2242 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2243 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2244 { .bitrate = 540,
2245 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2246 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2247};
2248
2249/* can't be const, mac80211 writes to this */
2250static struct ieee80211_channel wl1271_channels[] = {
2251 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2252 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2253 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2254 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2255 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2256 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2257 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2258 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2259 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2260 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2261 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2262 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2263 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2264};
2265
2266/* mapping to indexes for wl1271_rates */
2267static const u8 wl1271_rate_to_idx_2ghz[] = {
2268 /* MCS rates are used only with 11n */
2269 7, /* CONF_HW_RXTX_RATE_MCS7 */
2270 6, /* CONF_HW_RXTX_RATE_MCS6 */
2271 5, /* CONF_HW_RXTX_RATE_MCS5 */
2272 4, /* CONF_HW_RXTX_RATE_MCS4 */
2273 3, /* CONF_HW_RXTX_RATE_MCS3 */
2274 2, /* CONF_HW_RXTX_RATE_MCS2 */
2275 1, /* CONF_HW_RXTX_RATE_MCS1 */
2276 0, /* CONF_HW_RXTX_RATE_MCS0 */
2277
2278 11, /* CONF_HW_RXTX_RATE_54 */
2279 10, /* CONF_HW_RXTX_RATE_48 */
2280 9, /* CONF_HW_RXTX_RATE_36 */
2281 8, /* CONF_HW_RXTX_RATE_24 */
2282
2283 /* TI-specific rate */
2284 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2285
2286 7, /* CONF_HW_RXTX_RATE_18 */
2287 6, /* CONF_HW_RXTX_RATE_12 */
2288 3, /* CONF_HW_RXTX_RATE_11 */
2289 5, /* CONF_HW_RXTX_RATE_9 */
2290 4, /* CONF_HW_RXTX_RATE_6 */
2291 2, /* CONF_HW_RXTX_RATE_5_5 */
2292 1, /* CONF_HW_RXTX_RATE_2 */
2293 0 /* CONF_HW_RXTX_RATE_1 */
2294};
2295
2296/* 11n STA capabilities */
2297#define HW_RX_HIGHEST_RATE 72
2298
2299#ifdef CONFIG_WL12XX_HT
2300#define WL12XX_HT_CAP { \
2301 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
2302 .ht_supported = true, \
2303 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
2304 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
2305 .mcs = { \
2306 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
2307 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
2308 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
2309 }, \
2310}
2311#else
2312#define WL12XX_HT_CAP { \
2313 .ht_supported = false, \
2314}
2315#endif
2316
2317/* can't be const, mac80211 writes to this */
2318static struct ieee80211_supported_band wl1271_band_2ghz = {
2319 .channels = wl1271_channels,
2320 .n_channels = ARRAY_SIZE(wl1271_channels),
2321 .bitrates = wl1271_rates,
2322 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2323 .ht_cap = WL12XX_HT_CAP,
2324};
2325
2326/* 5 GHz data rates for WL1273 */
2327static struct ieee80211_rate wl1271_rates_5ghz[] = {
2328 { .bitrate = 60,
2329 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2330 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2331 { .bitrate = 90,
2332 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2333 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2334 { .bitrate = 120,
2335 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2336 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2337 { .bitrate = 180,
2338 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2339 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2340 { .bitrate = 240,
2341 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2342 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2343 { .bitrate = 360,
2344 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2345 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2346 { .bitrate = 480,
2347 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2348 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2349 { .bitrate = 540,
2350 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2351 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2352};
2353
2354/* 5 GHz band channels for WL1273 */
2355static struct ieee80211_channel wl1271_channels_5ghz[] = {
2356 { .hw_value = 183, .center_freq = 4915},
2357 { .hw_value = 184, .center_freq = 4920},
2358 { .hw_value = 185, .center_freq = 4925},
2359 { .hw_value = 187, .center_freq = 4935},
2360 { .hw_value = 188, .center_freq = 4940},
2361 { .hw_value = 189, .center_freq = 4945},
2362 { .hw_value = 192, .center_freq = 4960},
2363 { .hw_value = 196, .center_freq = 4980},
2364 { .hw_value = 7, .center_freq = 5035},
2365 { .hw_value = 8, .center_freq = 5040},
2366 { .hw_value = 9, .center_freq = 5045},
2367 { .hw_value = 11, .center_freq = 5055},
2368 { .hw_value = 12, .center_freq = 5060},
2369 { .hw_value = 16, .center_freq = 5080},
2370 { .hw_value = 34, .center_freq = 5170},
2371 { .hw_value = 36, .center_freq = 5180},
2372 { .hw_value = 38, .center_freq = 5190},
2373 { .hw_value = 40, .center_freq = 5200},
2374 { .hw_value = 42, .center_freq = 5210},
2375 { .hw_value = 44, .center_freq = 5220},
2376 { .hw_value = 46, .center_freq = 5230},
2377 { .hw_value = 48, .center_freq = 5240},
2378 { .hw_value = 52, .center_freq = 5260},
2379 { .hw_value = 56, .center_freq = 5280},
2380 { .hw_value = 60, .center_freq = 5300},
2381 { .hw_value = 64, .center_freq = 5320},
2382 { .hw_value = 100, .center_freq = 5500},
2383 { .hw_value = 104, .center_freq = 5520},
2384 { .hw_value = 108, .center_freq = 5540},
2385 { .hw_value = 112, .center_freq = 5560},
2386 { .hw_value = 116, .center_freq = 5580},
2387 { .hw_value = 120, .center_freq = 5600},
2388 { .hw_value = 124, .center_freq = 5620},
2389 { .hw_value = 128, .center_freq = 5640},
2390 { .hw_value = 132, .center_freq = 5660},
2391 { .hw_value = 136, .center_freq = 5680},
2392 { .hw_value = 140, .center_freq = 5700},
2393 { .hw_value = 149, .center_freq = 5745},
2394 { .hw_value = 153, .center_freq = 5765},
2395 { .hw_value = 157, .center_freq = 5785},
2396 { .hw_value = 161, .center_freq = 5805},
2397 { .hw_value = 165, .center_freq = 5825},
2398};
2399
2400/* mapping to indexes for wl1271_rates_5ghz */
2401static const u8 wl1271_rate_to_idx_5ghz[] = {
2402 /* MCS rates are used only with 11n */
2403 7, /* CONF_HW_RXTX_RATE_MCS7 */
2404 6, /* CONF_HW_RXTX_RATE_MCS6 */
2405 5, /* CONF_HW_RXTX_RATE_MCS5 */
2406 4, /* CONF_HW_RXTX_RATE_MCS4 */
2407 3, /* CONF_HW_RXTX_RATE_MCS3 */
2408 2, /* CONF_HW_RXTX_RATE_MCS2 */
2409 1, /* CONF_HW_RXTX_RATE_MCS1 */
2410 0, /* CONF_HW_RXTX_RATE_MCS0 */
2411
2412 7, /* CONF_HW_RXTX_RATE_54 */
2413 6, /* CONF_HW_RXTX_RATE_48 */
2414 5, /* CONF_HW_RXTX_RATE_36 */
2415 4, /* CONF_HW_RXTX_RATE_24 */
2416
2417 /* TI-specific rate */
2418 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2419
2420 3, /* CONF_HW_RXTX_RATE_18 */
2421 2, /* CONF_HW_RXTX_RATE_12 */
2422 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2423 1, /* CONF_HW_RXTX_RATE_9 */
2424 0, /* CONF_HW_RXTX_RATE_6 */
2425 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2426 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2427 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2428};
2429
2430static struct ieee80211_supported_band wl1271_band_5ghz = {
2431 .channels = wl1271_channels_5ghz,
2432 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2433 .bitrates = wl1271_rates_5ghz,
2434 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2435 .ht_cap = WL12XX_HT_CAP,
2436};
2437
2438static const u8 *wl1271_band_rate_to_idx[] = {
2439 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2440 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2441};
2442
2443static const struct ieee80211_ops wl1271_ops = {
2444 .start = wl1271_op_start,
2445 .stop = wl1271_op_stop,
2446 .add_interface = wl1271_op_add_interface,
2447 .remove_interface = wl1271_op_remove_interface,
2448 .config = wl1271_op_config,
2449 .prepare_multicast = wl1271_op_prepare_multicast,
2450 .configure_filter = wl1271_op_configure_filter,
2451 .tx = wl1271_op_tx,
2452 .set_key = wl1271_op_set_key,
2453 .hw_scan = wl1271_op_hw_scan,
2454 .bss_info_changed = wl1271_op_bss_info_changed,
2455 .set_frag_threshold = wl1271_op_set_frag_threshold,
2456 .set_rts_threshold = wl1271_op_set_rts_threshold,
2457 .conf_tx = wl1271_op_conf_tx,
2458 .get_tsf = wl1271_op_get_tsf,
2459 .get_survey = wl1271_op_get_survey,
2460 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2461};
2462
2463
2464u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
2465{
2466 u8 idx;
2467
2468 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2469
2470 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2471 wl1271_error("Illegal RX rate from HW: %d", rate);
2472 return 0;
2473 }
2474
2475 idx = wl1271_band_rate_to_idx[band][rate];
2476 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2477 wl1271_error("Unsupported RX rate from HW: %d", rate);
2478 return 0;
2479 }
2480
2481 return idx;
2482}
2483
2484static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2485 struct device_attribute *attr,
2486 char *buf)
2487{
2488 struct wl1271 *wl = dev_get_drvdata(dev);
2489 ssize_t len;
2490
2491 len = PAGE_SIZE;
2492
2493 mutex_lock(&wl->mutex);
2494 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2495 wl->sg_enabled);
2496 mutex_unlock(&wl->mutex);
2497
2498 return len;
2499
2500}
2501
2502static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2503 struct device_attribute *attr,
2504 const char *buf, size_t count)
2505{
2506 struct wl1271 *wl = dev_get_drvdata(dev);
2507 unsigned long res;
2508 int ret;
2509
2510 ret = strict_strtoul(buf, 10, &res);
2511
2512 if (ret < 0) {
2513 wl1271_warning("incorrect value written to bt_coex_mode");
2514 return count;
2515 }
2516
2517 mutex_lock(&wl->mutex);
2518
2519 res = !!res;
2520
2521 if (res == wl->sg_enabled)
2522 goto out;
2523
2524 wl->sg_enabled = res;
2525
2526 if (wl->state == WL1271_STATE_OFF)
2527 goto out;
2528
2529 ret = wl1271_ps_elp_wakeup(wl, false);
2530 if (ret < 0)
2531 goto out;
2532
2533 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2534 wl1271_ps_elp_sleep(wl);
2535
2536 out:
2537 mutex_unlock(&wl->mutex);
2538 return count;
2539}
2540
2541static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2542 wl1271_sysfs_show_bt_coex_state,
2543 wl1271_sysfs_store_bt_coex_state);
2544
2545static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2546 struct device_attribute *attr,
2547 char *buf)
2548{
2549 struct wl1271 *wl = dev_get_drvdata(dev);
2550 ssize_t len;
2551
2552 len = PAGE_SIZE;
2553
2554 mutex_lock(&wl->mutex);
2555 if (wl->hw_pg_ver >= 0)
2556 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2557 else
2558 len = snprintf(buf, len, "n/a\n");
2559 mutex_unlock(&wl->mutex);
2560
2561 return len;
2562}
2563
2564static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2565 wl1271_sysfs_show_hw_pg_ver, NULL);
2566
2567int wl1271_register_hw(struct wl1271 *wl)
2568{
2569 int ret;
2570
2571 if (wl->mac80211_registered)
2572 return 0;
2573
2574 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2575
2576 ret = ieee80211_register_hw(wl->hw);
2577 if (ret < 0) {
2578 wl1271_error("unable to register mac80211 hw: %d", ret);
2579 return ret;
2580 }
2581
2582 wl->mac80211_registered = true;
2583
2584 register_netdevice_notifier(&wl1271_dev_notifier);
2585
2586 wl1271_notice("loaded");
2587
2588 return 0;
2589}
2590EXPORT_SYMBOL_GPL(wl1271_register_hw);
2591
2592void wl1271_unregister_hw(struct wl1271 *wl)
2593{
2594 unregister_netdevice_notifier(&wl1271_dev_notifier);
2595 ieee80211_unregister_hw(wl->hw);
2596 wl->mac80211_registered = false;
2597
2598}
2599EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2600
2601int wl1271_init_ieee80211(struct wl1271 *wl)
2602{
2603 static const u32 cipher_suites[] = {
2604 WLAN_CIPHER_SUITE_WEP40,
2605 WLAN_CIPHER_SUITE_WEP104,
2606 WLAN_CIPHER_SUITE_TKIP,
2607 WLAN_CIPHER_SUITE_CCMP,
2608 WL1271_CIPHER_SUITE_GEM,
2609 };
2610
2611 /* The tx descriptor buffer and the TKIP space. */
2612 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2613 sizeof(struct wl1271_tx_hw_descr);
2614
2615 /* unit us */
2616 /* FIXME: find a proper value */
2617 wl->hw->channel_change_time = 10000;
2618 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2619
2620 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2621 IEEE80211_HW_BEACON_FILTER |
2622 IEEE80211_HW_SUPPORTS_PS |
2623 IEEE80211_HW_SUPPORTS_UAPSD |
2624 IEEE80211_HW_HAS_RATE_CONTROL |
2625 IEEE80211_HW_CONNECTION_MONITOR |
2626 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2627
2628 wl->hw->wiphy->cipher_suites = cipher_suites;
2629 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
2630
2631 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2632 BIT(NL80211_IFTYPE_ADHOC);
2633 wl->hw->wiphy->max_scan_ssids = 1;
2634 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2635 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2636
2637 wl->hw->queues = 4;
2638 wl->hw->max_rates = 1;
2639
2640 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
2641
2642 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2643
2644 return 0;
2645}
2646EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2647
2648#define WL1271_DEFAULT_CHANNEL 0
2649
2650struct ieee80211_hw *wl1271_alloc_hw(void)
2651{
2652 struct ieee80211_hw *hw;
2653 struct platform_device *plat_dev = NULL;
2654 struct wl1271 *wl;
2655 int i, ret;
2656 unsigned int order;
2657
2658 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2659 if (!hw) {
2660 wl1271_error("could not alloc ieee80211_hw");
2661 ret = -ENOMEM;
2662 goto err_hw_alloc;
2663 }
2664
2665 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2666 if (!plat_dev) {
2667 wl1271_error("could not allocate platform_device");
2668 ret = -ENOMEM;
2669 goto err_plat_alloc;
2670 }
2671
2672 wl = hw->priv;
2673 memset(wl, 0, sizeof(*wl));
2674
2675 INIT_LIST_HEAD(&wl->list);
2676
2677 wl->hw = hw;
2678 wl->plat_dev = plat_dev;
2679
2680 skb_queue_head_init(&wl->tx_queue);
2681
2682 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2683 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2684 INIT_WORK(&wl->irq_work, wl1271_irq_work);
2685 INIT_WORK(&wl->tx_work, wl1271_tx_work);
2686 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
2687 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
2688 wl->channel = WL1271_DEFAULT_CHANNEL;
2689 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2690 wl->default_key = 0;
2691 wl->rx_counter = 0;
2692 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2693 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2694 wl->psm_entry_retry = 0;
2695 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2696 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2697 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2698 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2699 wl->sta_rate_set = 0;
2700 wl->band = IEEE80211_BAND_2GHZ;
2701 wl->vif = NULL;
2702 wl->flags = 0;
2703 wl->sg_enabled = true;
2704 wl->hw_pg_ver = -1;
2705
2706 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
2707 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2708 wl->tx_frames[i] = NULL;
2709
2710 spin_lock_init(&wl->wl_lock);
2711
2712 wl->state = WL1271_STATE_OFF;
2713 mutex_init(&wl->mutex);
2714
2715 /* Apply default driver configuration. */
2716 wl1271_conf_init(wl);
2717
2718 wl1271_debugfs_init(wl);
2719
2720 order = get_order(WL1271_AGGR_BUFFER_SIZE);
2721 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
2722 if (!wl->aggr_buf) {
2723 ret = -ENOMEM;
2724 goto err_hw;
2725 }
2726
2727 /* Register platform device */
2728 ret = platform_device_register(wl->plat_dev);
2729 if (ret) {
2730 wl1271_error("couldn't register platform device");
2731 goto err_aggr;
2732 }
2733 dev_set_drvdata(&wl->plat_dev->dev, wl);
2734
2735 /* Create sysfs file to control bt coex state */
2736 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2737 if (ret < 0) {
2738 wl1271_error("failed to create sysfs file bt_coex_state");
2739 goto err_platform;
2740 }
2741
2742 /* Create sysfs file to get HW PG version */
2743 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2744 if (ret < 0) {
2745 wl1271_error("failed to create sysfs file hw_pg_ver");
2746 goto err_bt_coex_state;
2747 }
2748
2749 return hw;
2750
2751err_bt_coex_state:
2752 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2753
2754err_platform:
2755 platform_device_unregister(wl->plat_dev);
2756
2757err_aggr:
2758 free_pages((unsigned long)wl->aggr_buf, order);
2759
2760err_hw:
2761 wl1271_debugfs_exit(wl);
2762 kfree(plat_dev);
2763
2764err_plat_alloc:
2765 ieee80211_free_hw(hw);
2766
2767err_hw_alloc:
2768
2769 return ERR_PTR(ret);
2770}
2771EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2772
2773int wl1271_free_hw(struct wl1271 *wl)
2774{
2775 platform_device_unregister(wl->plat_dev);
2776 free_pages((unsigned long)wl->aggr_buf,
2777 get_order(WL1271_AGGR_BUFFER_SIZE));
2778 kfree(wl->plat_dev);
2779
2780 wl1271_debugfs_exit(wl);
2781
2782 vfree(wl->fw);
2783 wl->fw = NULL;
2784 kfree(wl->nvs);
2785 wl->nvs = NULL;
2786
2787 kfree(wl->fw_status);
2788 kfree(wl->tx_res_if);
2789
2790 ieee80211_free_hw(wl->hw);
2791
2792 return 0;
2793}
2794EXPORT_SYMBOL_GPL(wl1271_free_hw);
2795
2796MODULE_LICENSE("GPL");
2797MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2798MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-02 15:19:14 -0500