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