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