projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wl12xx: AP mode config in ieee80211_ops.config
[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 wl1271_set_default_filters(wl);
1231
1232 /* combine requested filters with current filter config */
1233 filters = wl->filters | filters;
1234
1235 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1236
1237 if (filters & FIF_PROMISC_IN_BSS) {
1238 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1239 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1240 wl->rx_config |= CFG_BSSID_FILTER_EN;
1241 }
1242 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1243 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1244 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1245 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1246 }
1247 if (filters & FIF_OTHER_BSS) {
1248 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1249 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1250 }
1251 if (filters & FIF_CONTROL) {
1252 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1253 wl->rx_filter |= CFG_RX_CTL_EN;
1254 }
1255 if (filters & FIF_FCSFAIL) {
1256 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1257 wl->rx_filter |= CFG_RX_FCS_ERROR;
1258 }
1259 }
1260
1261 static int wl1271_dummy_join(struct wl1271 *wl)
1262 {
1263 int ret = 0;
1264 /* we need to use a dummy BSSID for now */
1265 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1266 0xad, 0xbe, 0xef };
1267
1268 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1269
1270 /* pass through frames from all BSS */
1271 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1272
1273 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1274 if (ret < 0)
1275 goto out;
1276
1277 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1278
1279 out:
1280 return ret;
1281 }
1282
1283 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1284 {
1285 int ret;
1286
1287 /*
1288 * One of the side effects of the JOIN command is that is clears
1289 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1290 * to a WPA/WPA2 access point will therefore kill the data-path.
1291 * Currently there is no supported scenario for JOIN during
1292 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1293 * must be handled somehow.
1294 *
1295 */
1296 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1297 wl1271_info("JOIN while associated.");
1298
1299 if (set_assoc)
1300 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1301
1302 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1303 if (ret < 0)
1304 goto out;
1305
1306 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1307
1308 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1309 goto out;
1310
1311 /*
1312 * The join command disable the keep-alive mode, shut down its process,
1313 * and also clear the template config, so we need to reset it all after
1314 * the join. The acx_aid starts the keep-alive process, and the order
1315 * of the commands below is relevant.
1316 */
1317 ret = wl1271_acx_keep_alive_mode(wl, true);
1318 if (ret < 0)
1319 goto out;
1320
1321 ret = wl1271_acx_aid(wl, wl->aid);
1322 if (ret < 0)
1323 goto out;
1324
1325 ret = wl1271_cmd_build_klv_null_data(wl);
1326 if (ret < 0)
1327 goto out;
1328
1329 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1330 ACX_KEEP_ALIVE_TPL_VALID);
1331 if (ret < 0)
1332 goto out;
1333
1334 out:
1335 return ret;
1336 }
1337
1338 static int wl1271_unjoin(struct wl1271 *wl)
1339 {
1340 int ret;
1341
1342 /* to stop listening to a channel, we disconnect */
1343 ret = wl1271_cmd_disconnect(wl);
1344 if (ret < 0)
1345 goto out;
1346
1347 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1348 memset(wl->bssid, 0, ETH_ALEN);
1349
1350 /* stop filterting packets based on bssid */
1351 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1352
1353 out:
1354 return ret;
1355 }
1356
1357 static void wl1271_set_band_rate(struct wl1271 *wl)
1358 {
1359 if (wl->band == IEEE80211_BAND_2GHZ)
1360 wl->basic_rate_set = wl->conf.tx.basic_rate;
1361 else
1362 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1363 }
1364
1365 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
1366 {
1367 int ret;
1368
1369 if (idle) {
1370 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1371 ret = wl1271_unjoin(wl);
1372 if (ret < 0)
1373 goto out;
1374 }
1375 wl->rate_set = wl1271_tx_min_rate_get(wl);
1376 wl->sta_rate_set = 0;
1377 ret = wl1271_acx_sta_rate_policies(wl);
1378 if (ret < 0)
1379 goto out;
1380 ret = wl1271_acx_keep_alive_config(
1381 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1382 ACX_KEEP_ALIVE_TPL_INVALID);
1383 if (ret < 0)
1384 goto out;
1385 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1386 } else {
1387 /* increment the session counter */
1388 wl->session_counter++;
1389 if (wl->session_counter >= SESSION_COUNTER_MAX)
1390 wl->session_counter = 0;
1391 ret = wl1271_dummy_join(wl);
1392 if (ret < 0)
1393 goto out;
1394 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1395 }
1396
1397 out:
1398 return ret;
1399 }
1400
1401 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1402 {
1403 struct wl1271 *wl = hw->priv;
1404 struct ieee80211_conf *conf = &hw->conf;
1405 int channel, ret = 0;
1406 bool is_ap;
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 " changed 0x%x",
1412 channel,
1413 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1414 conf->power_level,
1415 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1416 changed);
1417
1418 /*
1419 * mac80211 will go to idle nearly immediately after transmitting some
1420 * frames, such as the deauth. To make sure those frames reach the air,
1421 * wait here until the TX queue is fully flushed.
1422 */
1423 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1424 (conf->flags & IEEE80211_CONF_IDLE))
1425 wl1271_tx_flush(wl);
1426
1427 mutex_lock(&wl->mutex);
1428
1429 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1430 ret = -EAGAIN;
1431 goto out;
1432 }
1433
1434 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1435
1436 ret = wl1271_ps_elp_wakeup(wl, false);
1437 if (ret < 0)
1438 goto out;
1439
1440 /* if the channel changes while joined, join again */
1441 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1442 ((wl->band != conf->channel->band) ||
1443 (wl->channel != channel))) {
1444 wl->band = conf->channel->band;
1445 wl->channel = channel;
1446
1447 if (!is_ap) {
1448 /*
1449 * FIXME: the mac80211 should really provide a fixed
1450 * rate to use here. for now, just use the smallest
1451 * possible rate for the band as a fixed rate for
1452 * association frames and other control messages.
1453 */
1454 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1455 wl1271_set_band_rate(wl);
1456
1457 wl->basic_rate = wl1271_tx_min_rate_get(wl);
1458 ret = wl1271_acx_sta_rate_policies(wl);
1459 if (ret < 0)
1460 wl1271_warning("rate policy for channel "
1461 "failed %d", ret);
1462
1463 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1464 ret = wl1271_join(wl, false);
1465 if (ret < 0)
1466 wl1271_warning("cmd join on channel "
1467 "failed %d", ret);
1468 }
1469 }
1470 }
1471
1472 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
1473 ret = wl1271_sta_handle_idle(wl,
1474 conf->flags & IEEE80211_CONF_IDLE);
1475 if (ret < 0)
1476 wl1271_warning("idle mode change failed %d", ret);
1477 }
1478
1479 /*
1480 * if mac80211 changes the PSM mode, make sure the mode is not
1481 * incorrectly changed after the pspoll failure active window.
1482 */
1483 if (changed & IEEE80211_CONF_CHANGE_PS)
1484 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1485
1486 if (conf->flags & IEEE80211_CONF_PS &&
1487 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1488 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1489
1490 /*
1491 * We enter PSM only if we're already associated.
1492 * If we're not, we'll enter it when joining an SSID,
1493 * through the bss_info_changed() hook.
1494 */
1495 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1496 wl1271_debug(DEBUG_PSM, "psm enabled");
1497 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1498 wl->basic_rate, true);
1499 }
1500 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1501 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1502 wl1271_debug(DEBUG_PSM, "psm disabled");
1503
1504 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1505
1506 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1507 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1508 wl->basic_rate, true);
1509 }
1510
1511 if (conf->power_level != wl->power_level) {
1512 ret = wl1271_acx_tx_power(wl, conf->power_level);
1513 if (ret < 0)
1514 goto out_sleep;
1515
1516 wl->power_level = conf->power_level;
1517 }
1518
1519 out_sleep:
1520 wl1271_ps_elp_sleep(wl);
1521
1522 out:
1523 mutex_unlock(&wl->mutex);
1524
1525 return ret;
1526 }
1527
1528 struct wl1271_filter_params {
1529 bool enabled;
1530 int mc_list_length;
1531 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1532 };
1533
1534 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1535 struct netdev_hw_addr_list *mc_list)
1536 {
1537 struct wl1271_filter_params *fp;
1538 struct netdev_hw_addr *ha;
1539 struct wl1271 *wl = hw->priv;
1540
1541 if (unlikely(wl->state == WL1271_STATE_OFF))
1542 return 0;
1543
1544 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1545 if (!fp) {
1546 wl1271_error("Out of memory setting filters.");
1547 return 0;
1548 }
1549
1550 /* update multicast filtering parameters */
1551 fp->mc_list_length = 0;
1552 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1553 fp->enabled = false;
1554 } else {
1555 fp->enabled = true;
1556 netdev_hw_addr_list_for_each(ha, mc_list) {
1557 memcpy(fp->mc_list[fp->mc_list_length],
1558 ha->addr, ETH_ALEN);
1559 fp->mc_list_length++;
1560 }
1561 }
1562
1563 return (u64)(unsigned long)fp;
1564 }
1565
1566 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1567 FIF_ALLMULTI | \
1568 FIF_FCSFAIL | \
1569 FIF_BCN_PRBRESP_PROMISC | \
1570 FIF_CONTROL | \
1571 FIF_OTHER_BSS)
1572
1573 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1574 unsigned int changed,
1575 unsigned int *total, u64 multicast)
1576 {
1577 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1578 struct wl1271 *wl = hw->priv;
1579 int ret;
1580
1581 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1582
1583 mutex_lock(&wl->mutex);
1584
1585 *total &= WL1271_SUPPORTED_FILTERS;
1586 changed &= WL1271_SUPPORTED_FILTERS;
1587
1588 if (unlikely(wl->state == WL1271_STATE_OFF))
1589 goto out;
1590
1591 ret = wl1271_ps_elp_wakeup(wl, false);
1592 if (ret < 0)
1593 goto out;
1594
1595
1596 if (*total & FIF_ALLMULTI)
1597 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1598 else if (fp)
1599 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1600 fp->mc_list,
1601 fp->mc_list_length);
1602 if (ret < 0)
1603 goto out_sleep;
1604
1605 /* determine, whether supported filter values have changed */
1606 if (changed == 0)
1607 goto out_sleep;
1608
1609 /* configure filters */
1610 wl->filters = *total;
1611 wl1271_configure_filters(wl, 0);
1612
1613 /* apply configured filters */
1614 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1615 if (ret < 0)
1616 goto out_sleep;
1617
1618 out_sleep:
1619 wl1271_ps_elp_sleep(wl);
1620
1621 out:
1622 mutex_unlock(&wl->mutex);
1623 kfree(fp);
1624 }
1625
1626 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1627 struct ieee80211_vif *vif,
1628 struct ieee80211_sta *sta,
1629 struct ieee80211_key_conf *key_conf)
1630 {
1631 struct wl1271 *wl = hw->priv;
1632 const u8 *addr;
1633 int ret;
1634 u32 tx_seq_32 = 0;
1635 u16 tx_seq_16 = 0;
1636 u8 key_type;
1637
1638 static const u8 bcast_addr[ETH_ALEN] =
1639 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1640
1641 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1642
1643 addr = sta ? sta->addr : bcast_addr;
1644
1645 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1646 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1647 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1648 key_conf->cipher, key_conf->keyidx,
1649 key_conf->keylen, key_conf->flags);
1650 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1651
1652 if (is_zero_ether_addr(addr)) {
1653 /* We dont support TX only encryption */
1654 ret = -EOPNOTSUPP;
1655 goto out;
1656 }
1657
1658 mutex_lock(&wl->mutex);
1659
1660 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1661 ret = -EAGAIN;
1662 goto out_unlock;
1663 }
1664
1665 ret = wl1271_ps_elp_wakeup(wl, false);
1666 if (ret < 0)
1667 goto out_unlock;
1668
1669 switch (key_conf->cipher) {
1670 case WLAN_CIPHER_SUITE_WEP40:
1671 case WLAN_CIPHER_SUITE_WEP104:
1672 key_type = KEY_WEP;
1673
1674 key_conf->hw_key_idx = key_conf->keyidx;
1675 break;
1676 case WLAN_CIPHER_SUITE_TKIP:
1677 key_type = KEY_TKIP;
1678
1679 key_conf->hw_key_idx = key_conf->keyidx;
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 WLAN_CIPHER_SUITE_CCMP:
1684 key_type = KEY_AES;
1685
1686 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1687 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1688 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1689 break;
1690 case WL1271_CIPHER_SUITE_GEM:
1691 key_type = KEY_GEM;
1692 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1693 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1694 break;
1695 default:
1696 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1697
1698 ret = -EOPNOTSUPP;
1699 goto out_sleep;
1700 }
1701
1702 switch (cmd) {
1703 case SET_KEY:
1704 ret = wl1271_cmd_set_sta_key(wl, KEY_ADD_OR_REPLACE,
1705 key_conf->keyidx, key_type,
1706 key_conf->keylen, key_conf->key,
1707 addr, tx_seq_32, tx_seq_16);
1708 if (ret < 0) {
1709 wl1271_error("Could not add or replace key");
1710 goto out_sleep;
1711 }
1712
1713 /* the default WEP key needs to be configured at least once */
1714 if (key_type == KEY_WEP) {
1715 ret = wl1271_cmd_set_sta_default_wep_key(wl,
1716 wl->default_key);
1717 if (ret < 0)
1718 goto out_sleep;
1719 }
1720 break;
1721
1722 case DISABLE_KEY:
1723 /* The wl1271 does not allow to remove unicast keys - they
1724 will be cleared automatically on next CMD_JOIN. Ignore the
1725 request silently, as we dont want the mac80211 to emit
1726 an error message. */
1727 if (!is_broadcast_ether_addr(addr))
1728 break;
1729
1730 ret = wl1271_cmd_set_sta_key(wl, KEY_REMOVE,
1731 key_conf->keyidx, key_type,
1732 key_conf->keylen, key_conf->key,
1733 addr, 0, 0);
1734 if (ret < 0) {
1735 wl1271_error("Could not remove key");
1736 goto out_sleep;
1737 }
1738 break;
1739
1740 default:
1741 wl1271_error("Unsupported key cmd 0x%x", cmd);
1742 ret = -EOPNOTSUPP;
1743 break;
1744 }
1745
1746 out_sleep:
1747 wl1271_ps_elp_sleep(wl);
1748
1749 out_unlock:
1750 mutex_unlock(&wl->mutex);
1751
1752 out:
1753 return ret;
1754 }
1755
1756 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1757 struct ieee80211_vif *vif,
1758 struct cfg80211_scan_request *req)
1759 {
1760 struct wl1271 *wl = hw->priv;
1761 int ret;
1762 u8 *ssid = NULL;
1763 size_t len = 0;
1764
1765 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1766
1767 if (req->n_ssids) {
1768 ssid = req->ssids[0].ssid;
1769 len = req->ssids[0].ssid_len;
1770 }
1771
1772 mutex_lock(&wl->mutex);
1773
1774 if (wl->state == WL1271_STATE_OFF) {
1775 /*
1776 * We cannot return -EBUSY here because cfg80211 will expect
1777 * a call to ieee80211_scan_completed if we do - in this case
1778 * there won't be any call.
1779 */
1780 ret = -EAGAIN;
1781 goto out;
1782 }
1783
1784 ret = wl1271_ps_elp_wakeup(wl, false);
1785 if (ret < 0)
1786 goto out;
1787
1788 ret = wl1271_scan(hw->priv, ssid, len, req);
1789
1790 wl1271_ps_elp_sleep(wl);
1791
1792 out:
1793 mutex_unlock(&wl->mutex);
1794
1795 return ret;
1796 }
1797
1798 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
1799 {
1800 struct wl1271 *wl = hw->priv;
1801 int ret = 0;
1802
1803 mutex_lock(&wl->mutex);
1804
1805 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1806 ret = -EAGAIN;
1807 goto out;
1808 }
1809
1810 ret = wl1271_ps_elp_wakeup(wl, false);
1811 if (ret < 0)
1812 goto out;
1813
1814 ret = wl1271_acx_frag_threshold(wl, (u16)value);
1815 if (ret < 0)
1816 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
1817
1818 wl1271_ps_elp_sleep(wl);
1819
1820 out:
1821 mutex_unlock(&wl->mutex);
1822
1823 return ret;
1824 }
1825
1826 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1827 {
1828 struct wl1271 *wl = hw->priv;
1829 int ret = 0;
1830
1831 mutex_lock(&wl->mutex);
1832
1833 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1834 ret = -EAGAIN;
1835 goto out;
1836 }
1837
1838 ret = wl1271_ps_elp_wakeup(wl, false);
1839 if (ret < 0)
1840 goto out;
1841
1842 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1843 if (ret < 0)
1844 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1845
1846 wl1271_ps_elp_sleep(wl);
1847
1848 out:
1849 mutex_unlock(&wl->mutex);
1850
1851 return ret;
1852 }
1853
1854 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
1855 int offset)
1856 {
1857 u8 *ptr = skb->data + offset;
1858
1859 /* find the location of the ssid in the beacon */
1860 while (ptr < skb->data + skb->len) {
1861 if (ptr[0] == WLAN_EID_SSID) {
1862 wl->ssid_len = ptr[1];
1863 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1864 return 0;
1865 }
1866 ptr += (ptr[1] + 2);
1867 }
1868
1869 wl1271_error("No SSID in IEs!\n");
1870 return -ENOENT;
1871 }
1872
1873 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
1874 struct ieee80211_bss_conf *bss_conf,
1875 u32 changed)
1876 {
1877 int ret = 0;
1878
1879 if (changed & BSS_CHANGED_ERP_SLOT) {
1880 if (bss_conf->use_short_slot)
1881 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1882 else
1883 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1884 if (ret < 0) {
1885 wl1271_warning("Set slot time failed %d", ret);
1886 goto out;
1887 }
1888 }
1889
1890 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1891 if (bss_conf->use_short_preamble)
1892 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1893 else
1894 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1895 }
1896
1897 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1898 if (bss_conf->use_cts_prot)
1899 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1900 else
1901 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1902 if (ret < 0) {
1903 wl1271_warning("Set ctsprotect failed %d", ret);
1904 goto out;
1905 }
1906 }
1907
1908 out:
1909 return ret;
1910 }
1911
1912 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
1913 struct ieee80211_vif *vif,
1914 struct ieee80211_bss_conf *bss_conf,
1915 u32 changed)
1916 {
1917 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1918 int ret = 0;
1919
1920 if ((changed & BSS_CHANGED_BEACON_INT)) {
1921 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
1922 bss_conf->beacon_int);
1923
1924 wl->beacon_int = bss_conf->beacon_int;
1925 }
1926
1927 if ((changed & BSS_CHANGED_BEACON)) {
1928 struct ieee80211_hdr *hdr;
1929 int ieoffset = offsetof(struct ieee80211_mgmt,
1930 u.beacon.variable);
1931 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
1932 u16 tmpl_id;
1933
1934 if (!beacon)
1935 goto out;
1936
1937 wl1271_debug(DEBUG_MASTER, "beacon updated");
1938
1939 ret = wl1271_ssid_set(wl, beacon, ieoffset);
1940 if (ret < 0) {
1941 dev_kfree_skb(beacon);
1942 goto out;
1943 }
1944 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
1945 CMD_TEMPL_BEACON;
1946 ret = wl1271_cmd_template_set(wl, tmpl_id,
1947 beacon->data,
1948 beacon->len, 0,
1949 wl1271_tx_min_rate_get(wl));
1950 if (ret < 0) {
1951 dev_kfree_skb(beacon);
1952 goto out;
1953 }
1954
1955 hdr = (struct ieee80211_hdr *) beacon->data;
1956 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1957 IEEE80211_STYPE_PROBE_RESP);
1958
1959 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
1960 CMD_TEMPL_PROBE_RESPONSE;
1961 ret = wl1271_cmd_template_set(wl,
1962 tmpl_id,
1963 beacon->data,
1964 beacon->len, 0,
1965 wl1271_tx_min_rate_get(wl));
1966 dev_kfree_skb(beacon);
1967 if (ret < 0)
1968 goto out;
1969 }
1970
1971 out:
1972 return ret;
1973 }
1974
1975 /* AP mode changes */
1976 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
1977 struct ieee80211_vif *vif,
1978 struct ieee80211_bss_conf *bss_conf,
1979 u32 changed)
1980 {
1981 int ret = 0;
1982
1983 if ((changed & BSS_CHANGED_BASIC_RATES)) {
1984 u32 rates = bss_conf->basic_rates;
1985 struct conf_tx_rate_class mgmt_rc;
1986
1987 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
1988 wl->basic_rate = wl1271_tx_min_rate_get(wl);
1989 wl1271_debug(DEBUG_AP, "basic rates: 0x%x",
1990 wl->basic_rate_set);
1991
1992 /* update the AP management rate policy with the new rates */
1993 mgmt_rc.enabled_rates = wl->basic_rate_set;
1994 mgmt_rc.long_retry_limit = 10;
1995 mgmt_rc.short_retry_limit = 10;
1996 mgmt_rc.aflags = 0;
1997 ret = wl1271_acx_ap_rate_policy(wl, &mgmt_rc,
1998 ACX_TX_AP_MODE_MGMT_RATE);
1999 if (ret < 0) {
2000 wl1271_error("AP mgmt policy change failed %d", ret);
2001 goto out;
2002 }
2003 }
2004
2005 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2006 if (ret < 0)
2007 goto out;
2008
2009 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2010 if (bss_conf->enable_beacon) {
2011 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2012 ret = wl1271_cmd_start_bss(wl);
2013 if (ret < 0)
2014 goto out;
2015
2016 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2017 wl1271_debug(DEBUG_AP, "started AP");
2018 }
2019 } else {
2020 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2021 ret = wl1271_cmd_stop_bss(wl);
2022 if (ret < 0)
2023 goto out;
2024
2025 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2026 wl1271_debug(DEBUG_AP, "stopped AP");
2027 }
2028 }
2029 }
2030
2031 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2032 if (ret < 0)
2033 goto out;
2034 out:
2035 return;
2036 }
2037
2038 /* STA/IBSS mode changes */
2039 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2040 struct ieee80211_vif *vif,
2041 struct ieee80211_bss_conf *bss_conf,
2042 u32 changed)
2043 {
2044 bool do_join = false, set_assoc = false;
2045 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2046 int ret;
2047 struct ieee80211_sta *sta = ieee80211_find_sta(vif, bss_conf->bssid);
2048
2049 if (is_ibss) {
2050 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2051 changed);
2052 if (ret < 0)
2053 goto out;
2054 }
2055
2056 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
2057 do_join = true;
2058
2059 /* Need to update the SSID (for filtering etc) */
2060 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2061 do_join = true;
2062
2063 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
2064 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2065 bss_conf->enable_beacon ? "enabled" : "disabled");
2066
2067 if (bss_conf->enable_beacon)
2068 wl->set_bss_type = BSS_TYPE_IBSS;
2069 else
2070 wl->set_bss_type = BSS_TYPE_STA_BSS;
2071 do_join = true;
2072 }
2073
2074 if ((changed & BSS_CHANGED_CQM)) {
2075 bool enable = false;
2076 if (bss_conf->cqm_rssi_thold)
2077 enable = true;
2078 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2079 bss_conf->cqm_rssi_thold,
2080 bss_conf->cqm_rssi_hyst);
2081 if (ret < 0)
2082 goto out;
2083 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2084 }
2085
2086 if ((changed & BSS_CHANGED_BSSID) &&
2087 /*
2088 * Now we know the correct bssid, so we send a new join command
2089 * and enable the BSSID filter
2090 */
2091 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
2092 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
2093
2094 ret = wl1271_cmd_build_null_data(wl);
2095 if (ret < 0)
2096 goto out;
2097
2098 ret = wl1271_build_qos_null_data(wl);
2099 if (ret < 0)
2100 goto out;
2101
2102 /* filter out all packets not from this BSSID */
2103 wl1271_configure_filters(wl, 0);
2104
2105 /* Need to update the BSSID (for filtering etc) */
2106 do_join = true;
2107 }
2108
2109 if ((changed & BSS_CHANGED_ASSOC)) {
2110 if (bss_conf->assoc) {
2111 u32 rates;
2112 int ieoffset;
2113 wl->aid = bss_conf->aid;
2114 set_assoc = true;
2115
2116 wl->ps_poll_failures = 0;
2117
2118 /*
2119 * use basic rates from AP, and determine lowest rate
2120 * to use with control frames.
2121 */
2122 rates = bss_conf->basic_rates;
2123 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2124 rates);
2125 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2126 ret = wl1271_acx_sta_rate_policies(wl);
2127 if (ret < 0)
2128 goto out;
2129
2130 /*
2131 * with wl1271, we don't need to update the
2132 * beacon_int and dtim_period, because the firmware
2133 * updates it by itself when the first beacon is
2134 * received after a join.
2135 */
2136 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2137 if (ret < 0)
2138 goto out;
2139
2140 /*
2141 * Get a template for hardware connection maintenance
2142 */
2143 dev_kfree_skb(wl->probereq);
2144 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2145 ieoffset = offsetof(struct ieee80211_mgmt,
2146 u.probe_req.variable);
2147 wl1271_ssid_set(wl, wl->probereq, ieoffset);
2148
2149 /* enable the connection monitoring feature */
2150 ret = wl1271_acx_conn_monit_params(wl, true);
2151 if (ret < 0)
2152 goto out;
2153
2154 /* If we want to go in PSM but we're not there yet */
2155 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2156 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
2157 enum wl1271_cmd_ps_mode mode;
2158
2159 mode = STATION_POWER_SAVE_MODE;
2160 ret = wl1271_ps_set_mode(wl, mode,
2161 wl->basic_rate,
2162 true);
2163 if (ret < 0)
2164 goto out;
2165 }
2166 } else {
2167 /* use defaults when not associated */
2168 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
2169 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2170 wl->aid = 0;
2171
2172 /* free probe-request template */
2173 dev_kfree_skb(wl->probereq);
2174 wl->probereq = NULL;
2175
2176 /* re-enable dynamic ps - just in case */
2177 ieee80211_enable_dyn_ps(wl->vif);
2178
2179 /* revert back to minimum rates for the current band */
2180 wl1271_set_band_rate(wl);
2181 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2182 ret = wl1271_acx_sta_rate_policies(wl);
2183 if (ret < 0)
2184 goto out;
2185
2186 /* disable connection monitor features */
2187 ret = wl1271_acx_conn_monit_params(wl, false);
2188
2189 /* Disable the keep-alive feature */
2190 ret = wl1271_acx_keep_alive_mode(wl, false);
2191 if (ret < 0)
2192 goto out;
2193
2194 /* restore the bssid filter and go to dummy bssid */
2195 wl1271_unjoin(wl);
2196 wl1271_dummy_join(wl);
2197 }
2198 }
2199
2200 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2201 if (ret < 0)
2202 goto out;
2203
2204 /*
2205 * Takes care of: New association with HT enable,
2206 * HT information change in beacon.
2207 */
2208 if (sta &&
2209 (changed & BSS_CHANGED_HT) &&
2210 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2211 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true);
2212 if (ret < 0) {
2213 wl1271_warning("Set ht cap true failed %d", ret);
2214 goto out;
2215 }
2216 ret = wl1271_acx_set_ht_information(wl,
2217 bss_conf->ht_operation_mode);
2218 if (ret < 0) {
2219 wl1271_warning("Set ht information failed %d", ret);
2220 goto out;
2221 }
2222 }
2223 /*
2224 * Takes care of: New association without HT,
2225 * Disassociation.
2226 */
2227 else if (sta && (changed & BSS_CHANGED_ASSOC)) {
2228 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, false);
2229 if (ret < 0) {
2230 wl1271_warning("Set ht cap false failed %d", ret);
2231 goto out;
2232 }
2233 }
2234
2235 if (changed & BSS_CHANGED_ARP_FILTER) {
2236 __be32 addr = bss_conf->arp_addr_list[0];
2237 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2238
2239 if (bss_conf->arp_addr_cnt == 1 &&
2240 bss_conf->arp_filter_enabled) {
2241 /*
2242 * The template should have been configured only upon
2243 * association. however, it seems that the correct ip
2244 * isn't being set (when sending), so we have to
2245 * reconfigure the template upon every ip change.
2246 */
2247 ret = wl1271_cmd_build_arp_rsp(wl, addr);
2248 if (ret < 0) {
2249 wl1271_warning("build arp rsp failed: %d", ret);
2250 goto out;
2251 }
2252
2253 ret = wl1271_acx_arp_ip_filter(wl,
2254 (ACX_ARP_FILTER_ARP_FILTERING |
2255 ACX_ARP_FILTER_AUTO_ARP),
2256 addr);
2257 } else
2258 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
2259
2260 if (ret < 0)
2261 goto out;
2262 }
2263
2264 if (do_join) {
2265 ret = wl1271_join(wl, set_assoc);
2266 if (ret < 0) {
2267 wl1271_warning("cmd join failed %d", ret);
2268 goto out;
2269 }
2270 }
2271
2272 out:
2273 return;
2274 }
2275
2276 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
2277 struct ieee80211_vif *vif,
2278 struct ieee80211_bss_conf *bss_conf,
2279 u32 changed)
2280 {
2281 struct wl1271 *wl = hw->priv;
2282 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2283 int ret;
2284
2285 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
2286 (int)changed);
2287
2288 mutex_lock(&wl->mutex);
2289
2290 if (unlikely(wl->state == WL1271_STATE_OFF))
2291 goto out;
2292
2293 ret = wl1271_ps_elp_wakeup(wl, false);
2294 if (ret < 0)
2295 goto out;
2296
2297 if (is_ap)
2298 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
2299 else
2300 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
2301
2302 wl1271_ps_elp_sleep(wl);
2303
2304 out:
2305 mutex_unlock(&wl->mutex);
2306 }
2307
2308 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2309 const struct ieee80211_tx_queue_params *params)
2310 {
2311 struct wl1271 *wl = hw->priv;
2312 u8 ps_scheme;
2313 int ret;
2314
2315 mutex_lock(&wl->mutex);
2316
2317 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2318
2319 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2320 ret = -EAGAIN;
2321 goto out;
2322 }
2323
2324 ret = wl1271_ps_elp_wakeup(wl, false);
2325 if (ret < 0)
2326 goto out;
2327
2328 /* the txop is confed in units of 32us by the mac80211, we need us */
2329 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
2330 params->cw_min, params->cw_max,
2331 params->aifs, params->txop << 5);
2332 if (ret < 0)
2333 goto out_sleep;
2334
2335 if (params->uapsd)
2336 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2337 else
2338 ps_scheme = CONF_PS_SCHEME_LEGACY;
2339
2340 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
2341 CONF_CHANNEL_TYPE_EDCF,
2342 wl1271_tx_get_queue(queue),
2343 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
2344 if (ret < 0)
2345 goto out_sleep;
2346
2347 out_sleep:
2348 wl1271_ps_elp_sleep(wl);
2349
2350 out:
2351 mutex_unlock(&wl->mutex);
2352
2353 return ret;
2354 }
2355
2356 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2357 {
2358
2359 struct wl1271 *wl = hw->priv;
2360 u64 mactime = ULLONG_MAX;
2361 int ret;
2362
2363 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2364
2365 mutex_lock(&wl->mutex);
2366
2367 if (unlikely(wl->state == WL1271_STATE_OFF))
2368 goto out;
2369
2370 ret = wl1271_ps_elp_wakeup(wl, false);
2371 if (ret < 0)
2372 goto out;
2373
2374 ret = wl1271_acx_tsf_info(wl, &mactime);
2375 if (ret < 0)
2376 goto out_sleep;
2377
2378 out_sleep:
2379 wl1271_ps_elp_sleep(wl);
2380
2381 out:
2382 mutex_unlock(&wl->mutex);
2383 return mactime;
2384 }
2385
2386 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2387 struct survey_info *survey)
2388 {
2389 struct wl1271 *wl = hw->priv;
2390 struct ieee80211_conf *conf = &hw->conf;
2391
2392 if (idx != 0)
2393 return -ENOENT;
2394
2395 survey->channel = conf->channel;
2396 survey->filled = SURVEY_INFO_NOISE_DBM;
2397 survey->noise = wl->noise;
2398
2399 return 0;
2400 }
2401
2402 /* can't be const, mac80211 writes to this */
2403 static struct ieee80211_rate wl1271_rates[] = {
2404 { .bitrate = 10,
2405 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2406 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
2407 { .bitrate = 20,
2408 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2409 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
2410 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2411 { .bitrate = 55,
2412 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2413 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
2414 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2415 { .bitrate = 110,
2416 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2417 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
2418 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2419 { .bitrate = 60,
2420 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2421 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2422 { .bitrate = 90,
2423 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2424 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2425 { .bitrate = 120,
2426 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2427 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2428 { .bitrate = 180,
2429 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2430 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2431 { .bitrate = 240,
2432 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2433 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2434 { .bitrate = 360,
2435 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2436 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2437 { .bitrate = 480,
2438 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2439 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2440 { .bitrate = 540,
2441 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2442 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2443 };
2444
2445 /* can't be const, mac80211 writes to this */
2446 static struct ieee80211_channel wl1271_channels[] = {
2447 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2448 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2449 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2450 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2451 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2452 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2453 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2454 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2455 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2456 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2457 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2458 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2459 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2460 };
2461
2462 /* mapping to indexes for wl1271_rates */
2463 static const u8 wl1271_rate_to_idx_2ghz[] = {
2464 /* MCS rates are used only with 11n */
2465 7, /* CONF_HW_RXTX_RATE_MCS7 */
2466 6, /* CONF_HW_RXTX_RATE_MCS6 */
2467 5, /* CONF_HW_RXTX_RATE_MCS5 */
2468 4, /* CONF_HW_RXTX_RATE_MCS4 */
2469 3, /* CONF_HW_RXTX_RATE_MCS3 */
2470 2, /* CONF_HW_RXTX_RATE_MCS2 */
2471 1, /* CONF_HW_RXTX_RATE_MCS1 */
2472 0, /* CONF_HW_RXTX_RATE_MCS0 */
2473
2474 11, /* CONF_HW_RXTX_RATE_54 */
2475 10, /* CONF_HW_RXTX_RATE_48 */
2476 9, /* CONF_HW_RXTX_RATE_36 */
2477 8, /* CONF_HW_RXTX_RATE_24 */
2478
2479 /* TI-specific rate */
2480 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2481
2482 7, /* CONF_HW_RXTX_RATE_18 */
2483 6, /* CONF_HW_RXTX_RATE_12 */
2484 3, /* CONF_HW_RXTX_RATE_11 */
2485 5, /* CONF_HW_RXTX_RATE_9 */
2486 4, /* CONF_HW_RXTX_RATE_6 */
2487 2, /* CONF_HW_RXTX_RATE_5_5 */
2488 1, /* CONF_HW_RXTX_RATE_2 */
2489 0 /* CONF_HW_RXTX_RATE_1 */
2490 };
2491
2492 /* 11n STA capabilities */
2493 #define HW_RX_HIGHEST_RATE 72
2494
2495 #ifdef CONFIG_WL12XX_HT
2496 #define WL12XX_HT_CAP { \
2497 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
2498 .ht_supported = true, \
2499 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
2500 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
2501 .mcs = { \
2502 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
2503 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
2504 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
2505 }, \
2506 }
2507 #else
2508 #define WL12XX_HT_CAP { \
2509 .ht_supported = false, \
2510 }
2511 #endif
2512
2513 /* can't be const, mac80211 writes to this */
2514 static struct ieee80211_supported_band wl1271_band_2ghz = {
2515 .channels = wl1271_channels,
2516 .n_channels = ARRAY_SIZE(wl1271_channels),
2517 .bitrates = wl1271_rates,
2518 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2519 .ht_cap = WL12XX_HT_CAP,
2520 };
2521
2522 /* 5 GHz data rates for WL1273 */
2523 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2524 { .bitrate = 60,
2525 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2526 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2527 { .bitrate = 90,
2528 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2529 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2530 { .bitrate = 120,
2531 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2532 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2533 { .bitrate = 180,
2534 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2535 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2536 { .bitrate = 240,
2537 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2538 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2539 { .bitrate = 360,
2540 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2541 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2542 { .bitrate = 480,
2543 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2544 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2545 { .bitrate = 540,
2546 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2547 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2548 };
2549
2550 /* 5 GHz band channels for WL1273 */
2551 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2552 { .hw_value = 7, .center_freq = 5035},
2553 { .hw_value = 8, .center_freq = 5040},
2554 { .hw_value = 9, .center_freq = 5045},
2555 { .hw_value = 11, .center_freq = 5055},
2556 { .hw_value = 12, .center_freq = 5060},
2557 { .hw_value = 16, .center_freq = 5080},
2558 { .hw_value = 34, .center_freq = 5170},
2559 { .hw_value = 36, .center_freq = 5180},
2560 { .hw_value = 38, .center_freq = 5190},
2561 { .hw_value = 40, .center_freq = 5200},
2562 { .hw_value = 42, .center_freq = 5210},
2563 { .hw_value = 44, .center_freq = 5220},
2564 { .hw_value = 46, .center_freq = 5230},
2565 { .hw_value = 48, .center_freq = 5240},
2566 { .hw_value = 52, .center_freq = 5260},
2567 { .hw_value = 56, .center_freq = 5280},
2568 { .hw_value = 60, .center_freq = 5300},
2569 { .hw_value = 64, .center_freq = 5320},
2570 { .hw_value = 100, .center_freq = 5500},
2571 { .hw_value = 104, .center_freq = 5520},
2572 { .hw_value = 108, .center_freq = 5540},
2573 { .hw_value = 112, .center_freq = 5560},
2574 { .hw_value = 116, .center_freq = 5580},
2575 { .hw_value = 120, .center_freq = 5600},
2576 { .hw_value = 124, .center_freq = 5620},
2577 { .hw_value = 128, .center_freq = 5640},
2578 { .hw_value = 132, .center_freq = 5660},
2579 { .hw_value = 136, .center_freq = 5680},
2580 { .hw_value = 140, .center_freq = 5700},
2581 { .hw_value = 149, .center_freq = 5745},
2582 { .hw_value = 153, .center_freq = 5765},
2583 { .hw_value = 157, .center_freq = 5785},
2584 { .hw_value = 161, .center_freq = 5805},
2585 { .hw_value = 165, .center_freq = 5825},
2586 };
2587
2588 /* mapping to indexes for wl1271_rates_5ghz */
2589 static const u8 wl1271_rate_to_idx_5ghz[] = {
2590 /* MCS rates are used only with 11n */
2591 7, /* CONF_HW_RXTX_RATE_MCS7 */
2592 6, /* CONF_HW_RXTX_RATE_MCS6 */
2593 5, /* CONF_HW_RXTX_RATE_MCS5 */
2594 4, /* CONF_HW_RXTX_RATE_MCS4 */
2595 3, /* CONF_HW_RXTX_RATE_MCS3 */
2596 2, /* CONF_HW_RXTX_RATE_MCS2 */
2597 1, /* CONF_HW_RXTX_RATE_MCS1 */
2598 0, /* CONF_HW_RXTX_RATE_MCS0 */
2599
2600 7, /* CONF_HW_RXTX_RATE_54 */
2601 6, /* CONF_HW_RXTX_RATE_48 */
2602 5, /* CONF_HW_RXTX_RATE_36 */
2603 4, /* CONF_HW_RXTX_RATE_24 */
2604
2605 /* TI-specific rate */
2606 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2607
2608 3, /* CONF_HW_RXTX_RATE_18 */
2609 2, /* CONF_HW_RXTX_RATE_12 */
2610 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2611 1, /* CONF_HW_RXTX_RATE_9 */
2612 0, /* CONF_HW_RXTX_RATE_6 */
2613 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2614 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2615 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2616 };
2617
2618 static struct ieee80211_supported_band wl1271_band_5ghz = {
2619 .channels = wl1271_channels_5ghz,
2620 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2621 .bitrates = wl1271_rates_5ghz,
2622 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2623 .ht_cap = WL12XX_HT_CAP,
2624 };
2625
2626 static const u8 *wl1271_band_rate_to_idx[] = {
2627 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2628 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2629 };
2630
2631 static const struct ieee80211_ops wl1271_ops = {
2632 .start = wl1271_op_start,
2633 .stop = wl1271_op_stop,
2634 .add_interface = wl1271_op_add_interface,
2635 .remove_interface = wl1271_op_remove_interface,
2636 .config = wl1271_op_config,
2637 .prepare_multicast = wl1271_op_prepare_multicast,
2638 .configure_filter = wl1271_op_configure_filter,
2639 .tx = wl1271_op_tx,
2640 .set_key = wl1271_op_set_key,
2641 .hw_scan = wl1271_op_hw_scan,
2642 .bss_info_changed = wl1271_op_bss_info_changed,
2643 .set_frag_threshold = wl1271_op_set_frag_threshold,
2644 .set_rts_threshold = wl1271_op_set_rts_threshold,
2645 .conf_tx = wl1271_op_conf_tx,
2646 .get_tsf = wl1271_op_get_tsf,
2647 .get_survey = wl1271_op_get_survey,
2648 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2649 };
2650
2651
2652 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
2653 {
2654 u8 idx;
2655
2656 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2657
2658 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2659 wl1271_error("Illegal RX rate from HW: %d", rate);
2660 return 0;
2661 }
2662
2663 idx = wl1271_band_rate_to_idx[band][rate];
2664 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2665 wl1271_error("Unsupported RX rate from HW: %d", rate);
2666 return 0;
2667 }
2668
2669 return idx;
2670 }
2671
2672 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2673 struct device_attribute *attr,
2674 char *buf)
2675 {
2676 struct wl1271 *wl = dev_get_drvdata(dev);
2677 ssize_t len;
2678
2679 len = PAGE_SIZE;
2680
2681 mutex_lock(&wl->mutex);
2682 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2683 wl->sg_enabled);
2684 mutex_unlock(&wl->mutex);
2685
2686 return len;
2687
2688 }
2689
2690 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2691 struct device_attribute *attr,
2692 const char *buf, size_t count)
2693 {
2694 struct wl1271 *wl = dev_get_drvdata(dev);
2695 unsigned long res;
2696 int ret;
2697
2698 ret = strict_strtoul(buf, 10, &res);
2699
2700 if (ret < 0) {
2701 wl1271_warning("incorrect value written to bt_coex_mode");
2702 return count;
2703 }
2704
2705 mutex_lock(&wl->mutex);
2706
2707 res = !!res;
2708
2709 if (res == wl->sg_enabled)
2710 goto out;
2711
2712 wl->sg_enabled = res;
2713
2714 if (wl->state == WL1271_STATE_OFF)
2715 goto out;
2716
2717 ret = wl1271_ps_elp_wakeup(wl, false);
2718 if (ret < 0)
2719 goto out;
2720
2721 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2722 wl1271_ps_elp_sleep(wl);
2723
2724 out:
2725 mutex_unlock(&wl->mutex);
2726 return count;
2727 }
2728
2729 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2730 wl1271_sysfs_show_bt_coex_state,
2731 wl1271_sysfs_store_bt_coex_state);
2732
2733 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2734 struct device_attribute *attr,
2735 char *buf)
2736 {
2737 struct wl1271 *wl = dev_get_drvdata(dev);
2738 ssize_t len;
2739
2740 len = PAGE_SIZE;
2741
2742 mutex_lock(&wl->mutex);
2743 if (wl->hw_pg_ver >= 0)
2744 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2745 else
2746 len = snprintf(buf, len, "n/a\n");
2747 mutex_unlock(&wl->mutex);
2748
2749 return len;
2750 }
2751
2752 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2753 wl1271_sysfs_show_hw_pg_ver, NULL);
2754
2755 int wl1271_register_hw(struct wl1271 *wl)
2756 {
2757 int ret;
2758
2759 if (wl->mac80211_registered)
2760 return 0;
2761
2762 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2763
2764 ret = ieee80211_register_hw(wl->hw);
2765 if (ret < 0) {
2766 wl1271_error("unable to register mac80211 hw: %d", ret);
2767 return ret;
2768 }
2769
2770 wl->mac80211_registered = true;
2771
2772 wl1271_debugfs_init(wl);
2773
2774 register_netdevice_notifier(&wl1271_dev_notifier);
2775
2776 wl1271_notice("loaded");
2777
2778 return 0;
2779 }
2780 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2781
2782 void wl1271_unregister_hw(struct wl1271 *wl)
2783 {
2784 unregister_netdevice_notifier(&wl1271_dev_notifier);
2785 ieee80211_unregister_hw(wl->hw);
2786 wl->mac80211_registered = false;
2787
2788 }
2789 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2790
2791 int wl1271_init_ieee80211(struct wl1271 *wl)
2792 {
2793 static const u32 cipher_suites[] = {
2794 WLAN_CIPHER_SUITE_WEP40,
2795 WLAN_CIPHER_SUITE_WEP104,
2796 WLAN_CIPHER_SUITE_TKIP,
2797 WLAN_CIPHER_SUITE_CCMP,
2798 WL1271_CIPHER_SUITE_GEM,
2799 };
2800
2801 /* The tx descriptor buffer and the TKIP space. */
2802 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2803 sizeof(struct wl1271_tx_hw_descr);
2804
2805 /* unit us */
2806 /* FIXME: find a proper value */
2807 wl->hw->channel_change_time = 10000;
2808 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2809
2810 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2811 IEEE80211_HW_BEACON_FILTER |
2812 IEEE80211_HW_SUPPORTS_PS |
2813 IEEE80211_HW_SUPPORTS_UAPSD |
2814 IEEE80211_HW_HAS_RATE_CONTROL |
2815 IEEE80211_HW_CONNECTION_MONITOR |
2816 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2817
2818 wl->hw->wiphy->cipher_suites = cipher_suites;
2819 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
2820
2821 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2822 BIT(NL80211_IFTYPE_ADHOC);
2823 wl->hw->wiphy->max_scan_ssids = 1;
2824 /*
2825 * Maximum length of elements in scanning probe request templates
2826 * should be the maximum length possible for a template, without
2827 * the IEEE80211 header of the template
2828 */
2829 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
2830 sizeof(struct ieee80211_header);
2831 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2832 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2833
2834 wl->hw->queues = 4;
2835 wl->hw->max_rates = 1;
2836
2837 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
2838
2839 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2840
2841 return 0;
2842 }
2843 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2844
2845 #define WL1271_DEFAULT_CHANNEL 0
2846
2847 struct ieee80211_hw *wl1271_alloc_hw(void)
2848 {
2849 struct ieee80211_hw *hw;
2850 struct platform_device *plat_dev = NULL;
2851 struct wl1271 *wl;
2852 int i, ret;
2853 unsigned int order;
2854
2855 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2856 if (!hw) {
2857 wl1271_error("could not alloc ieee80211_hw");
2858 ret = -ENOMEM;
2859 goto err_hw_alloc;
2860 }
2861
2862 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2863 if (!plat_dev) {
2864 wl1271_error("could not allocate platform_device");
2865 ret = -ENOMEM;
2866 goto err_plat_alloc;
2867 }
2868
2869 wl = hw->priv;
2870 memset(wl, 0, sizeof(*wl));
2871
2872 INIT_LIST_HEAD(&wl->list);
2873
2874 wl->hw = hw;
2875 wl->plat_dev = plat_dev;
2876
2877 for (i = 0; i < NUM_TX_QUEUES; i++)
2878 skb_queue_head_init(&wl->tx_queue[i]);
2879
2880 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2881 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2882 INIT_WORK(&wl->irq_work, wl1271_irq_work);
2883 INIT_WORK(&wl->tx_work, wl1271_tx_work);
2884 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
2885 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
2886 wl->channel = WL1271_DEFAULT_CHANNEL;
2887 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2888 wl->default_key = 0;
2889 wl->rx_counter = 0;
2890 wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
2891 wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
2892 wl->psm_entry_retry = 0;
2893 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2894 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2895 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2896 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2897 wl->sta_rate_set = 0;
2898 wl->band = IEEE80211_BAND_2GHZ;
2899 wl->vif = NULL;
2900 wl->flags = 0;
2901 wl->sg_enabled = true;
2902 wl->hw_pg_ver = -1;
2903
2904 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
2905 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2906 wl->tx_frames[i] = NULL;
2907
2908 spin_lock_init(&wl->wl_lock);
2909
2910 wl->state = WL1271_STATE_OFF;
2911 mutex_init(&wl->mutex);
2912
2913 /* Apply default driver configuration. */
2914 wl1271_conf_init(wl);
2915
2916 order = get_order(WL1271_AGGR_BUFFER_SIZE);
2917 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
2918 if (!wl->aggr_buf) {
2919 ret = -ENOMEM;
2920 goto err_hw;
2921 }
2922
2923 /* Register platform device */
2924 ret = platform_device_register(wl->plat_dev);
2925 if (ret) {
2926 wl1271_error("couldn't register platform device");
2927 goto err_aggr;
2928 }
2929 dev_set_drvdata(&wl->plat_dev->dev, wl);
2930
2931 /* Create sysfs file to control bt coex state */
2932 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2933 if (ret < 0) {
2934 wl1271_error("failed to create sysfs file bt_coex_state");
2935 goto err_platform;
2936 }
2937
2938 /* Create sysfs file to get HW PG version */
2939 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2940 if (ret < 0) {
2941 wl1271_error("failed to create sysfs file hw_pg_ver");
2942 goto err_bt_coex_state;
2943 }
2944
2945 return hw;
2946
2947 err_bt_coex_state:
2948 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2949
2950 err_platform:
2951 platform_device_unregister(wl->plat_dev);
2952
2953 err_aggr:
2954 free_pages((unsigned long)wl->aggr_buf, order);
2955
2956 err_hw:
2957 wl1271_debugfs_exit(wl);
2958 kfree(plat_dev);
2959
2960 err_plat_alloc:
2961 ieee80211_free_hw(hw);
2962
2963 err_hw_alloc:
2964
2965 return ERR_PTR(ret);
2966 }
2967 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2968
2969 int wl1271_free_hw(struct wl1271 *wl)
2970 {
2971 platform_device_unregister(wl->plat_dev);
2972 free_pages((unsigned long)wl->aggr_buf,
2973 get_order(WL1271_AGGR_BUFFER_SIZE));
2974 kfree(wl->plat_dev);
2975
2976 wl1271_debugfs_exit(wl);
2977
2978 vfree(wl->fw);
2979 wl->fw = NULL;
2980 kfree(wl->nvs);
2981 wl->nvs = NULL;
2982
2983 kfree(wl->fw_status);
2984 kfree(wl->tx_res_if);
2985
2986 ieee80211_free_hw(wl->hw);
2987
2988 return 0;
2989 }
2990 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2991
2992 u32 wl12xx_debug_level;
2993 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
2994 module_param_named(debug_level, wl12xx_debug_level, uint, DEBUG_NONE);
2995 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
2996
2997 MODULE_LICENSE("GPL");
2998 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2999 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux kernel - Deliverables
This page took 0.090837 seconds and 6 git commands to generate.