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