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