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