projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl1271: Add handling for failing hardware scan command
[linux-block.git] / drivers / net / wireless / wl12xx / wl1271_main.c
CommitLineData
f5fc0f86
LC		 1/*
2 * This file is part of wl1271
3 *
8bf29b0e 4 * Copyright (C) 2008-2010 Nokia Corporation
f5fc0f86
LC		 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>
f5fc0f86
LC		 25#include <linux/firmware.h>
26#include <linux/delay.h>
f5fc0f86
LC		 27#include <linux/spi/spi.h>
28#include <linux/crc32.h>
29#include <linux/etherdevice.h>
1fba4974 30#include <linux/vmalloc.h>
a1dd8187 31#include <linux/platform_device.h>
5a0e3ad6 32#include <linux/slab.h>
f5fc0f86
LC		 33
34#include "wl1271.h"
35#include "wl12xx_80211.h"
36#include "wl1271_reg.h"
7b048c52 37#include "wl1271_io.h"
f5fc0f86
LC		 38#include "wl1271_event.h"
39#include "wl1271_tx.h"
40#include "wl1271_rx.h"
41#include "wl1271_ps.h"
42#include "wl1271_init.h"
43#include "wl1271_debugfs.h"
44#include "wl1271_cmd.h"
45#include "wl1271_boot.h"
c8c90873 46#include "wl1271_testmode.h"
34dd2aaa 47#include "wl1271_scan.h"
f5fc0f86 48
9ccd9217
JO		 49#define WL1271_BOOT_RETRIES 3
50
8a08048a
JO		 51static struct conf_drv_settings default_conf = {
52 .sg = {
1b00f546
JO		 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,
8d2ef7bd 58 [CONF_SG_AUTO_PS_MODE] = 1,
1b00f546
JO		 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,
8a08048a
JO		 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,
3ed8f2c6
LC		 111 .rx_cca_threshold = 0,
112 .irq_blk_threshold = 0xFFFF,
113 .irq_pkt_threshold = 0,
114 .irq_timeout = 600,
8a08048a
JO		 115 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
116 },
117 .tx = {
118 .tx_energy_detection = 0,
119 .rc_conf = {
ebba60c6 120 .enabled_rates = 0,
8a08048a
JO		 121 .short_retry_limit = 10,
122 .long_retry_limit = 10,
123 .aflags = 0
45b531a8 124 },
8a08048a
JO		 125 .ac_conf_count = 4,
126 .ac_conf = {
9987a9da 127 [CONF_TX_AC_BE] = {
8a08048a
JO		 128 .ac = CONF_TX_AC_BE,
129 .cw_min = 15,
130 .cw_max = 63,
131 .aifsn = 3,
132 .tx_op_limit = 0,
45b531a8 133 },
9987a9da 134 [CONF_TX_AC_BK] = {
8a08048a
JO		 135 .ac = CONF_TX_AC_BK,
136 .cw_min = 15,
137 .cw_max = 63,
138 .aifsn = 7,
139 .tx_op_limit = 0,
45b531a8 140 },
9987a9da 141 [CONF_TX_AC_VI] = {
8a08048a
JO		 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 },
9987a9da 148 [CONF_TX_AC_VO] = {
8a08048a
JO		 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,
45b531a8 154 },
51f2be24 155 },
9987a9da 156 .tid_conf_count = 4,
8a08048a 157 .tid_conf = {
9987a9da
JO		 158 [CONF_TX_AC_BE] = {
159 .queue_id = CONF_TX_AC_BE,
160 .channel_type = CONF_CHANNEL_TYPE_EDCF,
8a08048a
JO		 161 .tsid = CONF_TX_AC_BE,
162 .ps_scheme = CONF_PS_SCHEME_LEGACY,
163 .ack_policy = CONF_ACK_POLICY_LEGACY,
164 .apsd_conf = {0, 0},
51f2be24 165 },
9987a9da
JO		 166 [CONF_TX_AC_BK] = {
167 .queue_id = CONF_TX_AC_BK,
168 .channel_type = CONF_CHANNEL_TYPE_EDCF,
169 .tsid = CONF_TX_AC_BK,
8a08048a
JO		 170 .ps_scheme = CONF_PS_SCHEME_LEGACY,
171 .ack_policy = CONF_ACK_POLICY_LEGACY,
172 .apsd_conf = {0, 0},
173 },
9987a9da
JO		 174 [CONF_TX_AC_VI] = {
175 .queue_id = CONF_TX_AC_VI,
176 .channel_type = CONF_CHANNEL_TYPE_EDCF,
177 .tsid = CONF_TX_AC_VI,
8a08048a
JO		 178 .ps_scheme = CONF_PS_SCHEME_LEGACY,
179 .ack_policy = CONF_ACK_POLICY_LEGACY,
180 .apsd_conf = {0, 0},
181 },
9987a9da
JO		 182 [CONF_TX_AC_VO] = {
183 .queue_id = CONF_TX_AC_VO,
184 .channel_type = CONF_CHANNEL_TYPE_EDCF,
185 .tsid = CONF_TX_AC_VO,
8a08048a
JO		 186 .ps_scheme = CONF_PS_SCHEME_LEGACY,
187 .ack_policy = CONF_ACK_POLICY_LEGACY,
188 .apsd_conf = {0, 0},
189 },
8a08048a
JO		 190 },
191 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
3ed8f2c6 192 .tx_compl_timeout = 700,
ebba60c6
JO		 193 .tx_compl_threshold = 4,
194 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
195 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
8a08048a
JO		 196 },
197 .conn = {
198 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
50c500ad 199 .listen_interval = 1,
8a08048a
JO		 200 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
201 .bcn_filt_ie_count = 1,
202 .bcn_filt_ie = {
203 [0] = {
204 .ie = WLAN_EID_CHANNEL_SWITCH,
205 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
51f2be24 206 }
47fab7d5 207 },
3ed8f2c6 208 .synch_fail_thold = 10,
8a08048a
JO		 209 .bss_lose_timeout = 100,
210 .beacon_rx_timeout = 10000,
211 .broadcast_timeout = 20000,
212 .rx_broadcast_in_ps = 1,
90494a90
JO		 213 .ps_poll_threshold = 10,
214 .ps_poll_recovery_period = 700,
11f70f97 215 .bet_enable = CONF_BET_MODE_ENABLE,
84502563 216 .bet_max_consecutive = 10,
c1899554 217 .psm_entry_retries = 3,
50c500ad
JO		 218 .keep_alive_interval = 55000,
219 .max_listen_interval = 20,
8a08048a 220 },
6e92b416
LC		 221 .itrim = {
222 .enable = false,
223 .timeout = 50000,
38ad2d87
JO		 224 },
225 .pm_config = {
226 .host_clk_settling_time = 5000,
227 .host_fast_wakeup_support = false
00236aed
JO		 228 },
229 .roam_trigger = {
00236aed
JO		 230 .trigger_pacing = 1,
231 .avg_weight_rssi_beacon = 20,
232 .avg_weight_rssi_data = 10,
233 .avg_weight_snr_beacon = 20,
234 .avg_weight_snr_data = 10
8a08048a
JO		 235 }
236};
237
52b0e7a6
JO		 238static void __wl1271_op_remove_interface(struct wl1271 *wl);
239
240
a1dd8187
JO		 241static void wl1271_device_release(struct device *dev)
242{
243
244}
245
246static struct platform_device wl1271_device = {
247 .name = "wl1271",
248 .id = -1,
249
250 /* device model insists to have a release function */
251 .dev = {
252 .release = wl1271_device_release,
253 },
254};
255
01c09162
JO		 256static LIST_HEAD(wl_list);
257
c2c192ac
JO		 258static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
259 void *arg)
260{
261 struct net_device *dev = arg;
262 struct wireless_dev *wdev;
263 struct wiphy *wiphy;
264 struct ieee80211_hw *hw;
265 struct wl1271 *wl;
266 struct wl1271 *wl_temp;
267 int ret = 0;
268
269 /* Check that this notification is for us. */
270 if (what != NETDEV_CHANGE)
271 return NOTIFY_DONE;
272
273 wdev = dev->ieee80211_ptr;
274 if (wdev == NULL)
275 return NOTIFY_DONE;
276
277 wiphy = wdev->wiphy;
278 if (wiphy == NULL)
279 return NOTIFY_DONE;
280
281 hw = wiphy_priv(wiphy);
282 if (hw == NULL)
283 return NOTIFY_DONE;
284
285 wl_temp = hw->priv;
286 list_for_each_entry(wl, &wl_list, list) {
287 if (wl == wl_temp)
288 break;
289 }
290 if (wl != wl_temp)
291 return NOTIFY_DONE;
292
293 mutex_lock(&wl->mutex);
294
295 if (wl->state == WL1271_STATE_OFF)
296 goto out;
297
298 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
299 goto out;
300
301 ret = wl1271_ps_elp_wakeup(wl, false);
302 if (ret < 0)
303 goto out;
304
305 if ((dev->operstate == IF_OPER_UP) &&
306 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
307 wl1271_cmd_set_sta_state(wl);
308 wl1271_info("Association completed.");
309 }
310
311 wl1271_ps_elp_sleep(wl);
312
313out:
314 mutex_unlock(&wl->mutex);
315
316 return NOTIFY_OK;
317}
318
8a08048a
JO		 319static void wl1271_conf_init(struct wl1271 *wl)
320{
2b60100b
JO		 321
322 /*
323 * This function applies the default configuration to the driver. This
324 * function is invoked upon driver load (spi probe.)
325 *
326 * The configuration is stored in a run-time structure in order to
327 * facilitate for run-time adjustment of any of the parameters. Making
328 * changes to the configuration structure will apply the new values on
329 * the next interface up (wl1271_op_start.)
330 */
331
332 /* apply driver default configuration */
8a08048a 333 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
2b60100b
JO		 334}
335
336
f5fc0f86
LC		 337static int wl1271_plt_init(struct wl1271 *wl)
338{
12419cce
LC		 339 struct conf_tx_ac_category *conf_ac;
340 struct conf_tx_tid *conf_tid;
341 int ret, i;
f5fc0f86 342
98b5dd5d 343 ret = wl1271_cmd_general_parms(wl);
4a90406b 344 if (ret < 0)
cc7defa3
LC		 345 return ret;
346
98b5dd5d 347 ret = wl1271_cmd_radio_parms(wl);
4a90406b 348 if (ret < 0)
cc7defa3
LC		 349 return ret;
350
12419cce
LC		 351 ret = wl1271_init_templates_config(wl);
352 if (ret < 0)
353 return ret;
354
f5fc0f86
LC		 355 ret = wl1271_acx_init_mem_config(wl);
356 if (ret < 0)
357 return ret;
358
12419cce
LC		 359 /* PHY layer config */
360 ret = wl1271_init_phy_config(wl);
361 if (ret < 0)
362 goto out_free_memmap;
363
364 ret = wl1271_acx_dco_itrim_params(wl);
365 if (ret < 0)
366 goto out_free_memmap;
367
368 /* Initialize connection monitoring thresholds */
6ccbb92e 369 ret = wl1271_acx_conn_monit_params(wl, false);
12419cce
LC		 370 if (ret < 0)
371 goto out_free_memmap;
372
373 /* Bluetooth WLAN coexistence */
374 ret = wl1271_init_pta(wl);
375 if (ret < 0)
376 goto out_free_memmap;
377
378 /* Energy detection */
379 ret = wl1271_init_energy_detection(wl);
380 if (ret < 0)
381 goto out_free_memmap;
382
383 /* Default fragmentation threshold */
384 ret = wl1271_acx_frag_threshold(wl);
385 if (ret < 0)
386 goto out_free_memmap;
387
9987a9da
JO		 388 /* Default TID/AC configuration */
389 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
12419cce 390 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
9987a9da
JO		 391 conf_ac = &wl->conf.tx.ac_conf[i];
392 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
393 conf_ac->cw_max, conf_ac->aifsn,
394 conf_ac->tx_op_limit);
395 if (ret < 0)
396 goto out_free_memmap;
397
12419cce
LC		 398 conf_tid = &wl->conf.tx.tid_conf[i];
399 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
400 conf_tid->channel_type,
401 conf_tid->tsid,
402 conf_tid->ps_scheme,
403 conf_tid->ack_policy,
404 conf_tid->apsd_conf[0],
405 conf_tid->apsd_conf[1]);
406 if (ret < 0)
407 goto out_free_memmap;
408 }
409
12419cce 410 /* Enable data path */
94210897 411 ret = wl1271_cmd_data_path(wl, 1);
f5fc0f86 412 if (ret < 0)
12419cce
LC		 413 goto out_free_memmap;
414
415 /* Configure for CAM power saving (ie. always active) */
416 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
417 if (ret < 0)
418 goto out_free_memmap;
419
420 /* configure PM */
421 ret = wl1271_acx_pm_config(wl);
422 if (ret < 0)
423 goto out_free_memmap;
f5fc0f86
LC		 424
425 return 0;
12419cce
LC		 426
427 out_free_memmap:
428 kfree(wl->target_mem_map);
429 wl->target_mem_map = NULL;
430
431 return ret;
f5fc0f86
LC		 432}
433
c15f63bf
JO		 434static void wl1271_fw_status(struct wl1271 *wl,
435 struct wl1271_fw_status *status)
f5fc0f86 436{
ac5e1e39 437 struct timespec ts;
f5fc0f86
LC		 438 u32 total = 0;
439 int i;
440
09a9c2b3 441 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
f5fc0f86
LC		 442
443 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
444 "drv_rx_counter = %d, tx_results_counter = %d)",
445 status->intr,
446 status->fw_rx_counter,
447 status->drv_rx_counter,
448 status->tx_results_counter);
449
450 /* update number of available TX blocks */
451 for (i = 0; i < NUM_TX_QUEUES; i++) {
d0f63b20
LC		 452 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
453 wl->tx_blocks_freed[i];
454
455 wl->tx_blocks_freed[i] =
456 le32_to_cpu(status->tx_released_blks[i]);
f5fc0f86
LC		 457 wl->tx_blocks_available += cnt;
458 total += cnt;
459 }
460
461 /* if more blocks are available now, schedule some tx work */
462 if (total && !skb_queue_empty(&wl->tx_queue))
a64b07e8 463 ieee80211_queue_work(wl->hw, &wl->tx_work);
f5fc0f86
LC		 464
465 /* update the host-chipset time offset */
ac5e1e39
JO		 466 getnstimeofday(&ts);
467 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
468 (s64)le32_to_cpu(status->fw_localtime);
f5fc0f86
LC		 469}
470
1e73eb62
JO		 471#define WL1271_IRQ_MAX_LOOPS 10
472
f5fc0f86
LC		 473static void wl1271_irq_work(struct work_struct *work)
474{
f5fc0f86 475 int ret;
c15f63bf 476 u32 intr;
1e73eb62
JO		 477 int loopcount = WL1271_IRQ_MAX_LOOPS;
478 unsigned long flags;
f5fc0f86
LC		 479 struct wl1271 *wl =
480 container_of(work, struct wl1271, irq_work);
481
482 mutex_lock(&wl->mutex);
483
484 wl1271_debug(DEBUG_IRQ, "IRQ work");
485
1e73eb62 486 if (unlikely(wl->state == WL1271_STATE_OFF))
f5fc0f86
LC		 487 goto out;
488
489 ret = wl1271_ps_elp_wakeup(wl, true);
490 if (ret < 0)
491 goto out;
492
1e73eb62
JO		 493 spin_lock_irqsave(&wl->wl_lock, flags);
494 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
495 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
496 spin_unlock_irqrestore(&wl->wl_lock, flags);
497 loopcount--;
498
499 wl1271_fw_status(wl, wl->fw_status);
500 intr = le32_to_cpu(wl->fw_status->intr);
501 if (!intr) {
502 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
cdd0864a 503 spin_lock_irqsave(&wl->wl_lock, flags);
1e73eb62
JO		 504 continue;
505 }
f5fc0f86 506
1e73eb62 507 intr &= WL1271_INTR_MASK;
f5fc0f86 508
1e73eb62
JO		 509 if (intr & WL1271_ACX_INTR_DATA) {
510 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
1fd2794f 511
1e73eb62
JO		 512 /* check for tx results */
513 if (wl->fw_status->tx_results_counter !=
514 (wl->tx_results_count & 0xff))
515 wl1271_tx_complete(wl);
f5fc0f86 516
1e73eb62
JO		 517 wl1271_rx(wl, wl->fw_status);
518 }
f5fc0f86 519
1e73eb62
JO		 520 if (intr & WL1271_ACX_INTR_EVENT_A) {
521 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
522 wl1271_event_handle(wl, 0);
523 }
f5fc0f86 524
1e73eb62
JO		 525 if (intr & WL1271_ACX_INTR_EVENT_B) {
526 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
527 wl1271_event_handle(wl, 1);
528 }
f5fc0f86 529
1e73eb62
JO		 530 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
531 wl1271_debug(DEBUG_IRQ,
532 "WL1271_ACX_INTR_INIT_COMPLETE");
f5fc0f86 533
1e73eb62
JO		 534 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
535 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
536
537 spin_lock_irqsave(&wl->wl_lock, flags);
c15f63bf 538 }
f5fc0f86 539
1e73eb62
JO		 540 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
541 ieee80211_queue_work(wl->hw, &wl->irq_work);
542 else
543 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
544 spin_unlock_irqrestore(&wl->wl_lock, flags);
545
f5fc0f86
LC		 546 wl1271_ps_elp_sleep(wl);
547
548out:
549 mutex_unlock(&wl->mutex);
550}
551
f5fc0f86
LC		 552static int wl1271_fetch_firmware(struct wl1271 *wl)
553{
554 const struct firmware *fw;
555 int ret;
556
8197b711 557 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 558
559 if (ret < 0) {
560 wl1271_error("could not get firmware: %d", ret);
561 return ret;
562 }
563
564 if (fw->size % 4) {
565 wl1271_error("firmware size is not multiple of 32 bits: %zu",
566 fw->size);
567 ret = -EILSEQ;
568 goto out;
569 }
570
571 wl->fw_len = fw->size;
1fba4974 572 wl->fw = vmalloc(wl->fw_len);
f5fc0f86
LC		 573
574 if (!wl->fw) {
575 wl1271_error("could not allocate memory for the firmware");
576 ret = -ENOMEM;
577 goto out;
578 }
579
580 memcpy(wl->fw, fw->data, wl->fw_len);
581
582 ret = 0;
583
584out:
585 release_firmware(fw);
586
587 return ret;
588}
589
590static int wl1271_fetch_nvs(struct wl1271 *wl)
591{
592 const struct firmware *fw;
593 int ret;
594
8197b711 595 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 596
597 if (ret < 0) {
598 wl1271_error("could not get nvs file: %d", ret);
599 return ret;
600 }
601
929ebd30 602 wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
f5fc0f86
LC		 603
604 if (!wl->nvs) {
605 wl1271_error("could not allocate memory for the nvs file");
606 ret = -ENOMEM;
607 goto out;
608 }
609
02fabb0e
JO		 610 wl->nvs_len = fw->size;
611
f5fc0f86
LC		 612out:
613 release_firmware(fw);
614
615 return ret;
616}
617
52b0e7a6
JO		 618static void wl1271_recovery_work(struct work_struct *work)
619{
620 struct wl1271 *wl =
621 container_of(work, struct wl1271, recovery_work);
622
623 mutex_lock(&wl->mutex);
624
625 if (wl->state != WL1271_STATE_ON)
626 goto out;
627
628 wl1271_info("Hardware recovery in progress.");
629
630 /* reboot the chipset */
631 __wl1271_op_remove_interface(wl);
632 ieee80211_restart_hw(wl->hw);
633
634out:
635 mutex_unlock(&wl->mutex);
636}
637
f5fc0f86
LC		 638static void wl1271_fw_wakeup(struct wl1271 *wl)
639{
640 u32 elp_reg;
641
642 elp_reg = ELPCTRL_WAKE_UP;
74621417 643 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
f5fc0f86
LC		 644}
645
646static int wl1271_setup(struct wl1271 *wl)
647{
648 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
649 if (!wl->fw_status)
650 return -ENOMEM;
651
652 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
653 if (!wl->tx_res_if) {
654 kfree(wl->fw_status);
655 return -ENOMEM;
656 }
657
658 INIT_WORK(&wl->irq_work, wl1271_irq_work);
659 INIT_WORK(&wl->tx_work, wl1271_tx_work);
52b0e7a6 660 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
78abd320 661 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
c454f1d9 662
f5fc0f86
LC		 663 return 0;
664}
665
666static int wl1271_chip_wakeup(struct wl1271 *wl)
667{
451de97a 668 struct wl1271_partition_set partition;
f5fc0f86
LC		 669 int ret = 0;
670
01ac17ec 671 msleep(WL1271_PRE_POWER_ON_SLEEP);
2cc78ff7
OBC		 672 ret = wl1271_power_on(wl);
673 if (ret < 0)
674 goto out;
f5fc0f86 675 msleep(WL1271_POWER_ON_SLEEP);
9b280722
TP		 676 wl1271_io_reset(wl);
677 wl1271_io_init(wl);
f5fc0f86
LC		 678
679 /* We don't need a real memory partition here, because we only want
680 * to use the registers at this point. */
451de97a
JO		 681 memset(&partition, 0, sizeof(partition));
682 partition.reg.start = REGISTERS_BASE;
683 partition.reg.size = REGISTERS_DOWN_SIZE;
684 wl1271_set_partition(wl, &partition);
f5fc0f86
LC		 685
686 /* ELP module wake up */
687 wl1271_fw_wakeup(wl);
688
689 /* whal_FwCtrl_BootSm() */
690
691 /* 0. read chip id from CHIP_ID */
7b048c52 692 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
f5fc0f86
LC		 693
694 /* 1. check if chip id is valid */
695
696 switch (wl->chip.id) {
697 case CHIP_ID_1271_PG10:
698 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
699 wl->chip.id);
700
701 ret = wl1271_setup(wl);
702 if (ret < 0)
9ccd9217 703 goto out;
f5fc0f86
LC		 704 break;
705 case CHIP_ID_1271_PG20:
706 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
707 wl->chip.id);
708
709 ret = wl1271_setup(wl);
710 if (ret < 0)
9ccd9217 711 goto out;
f5fc0f86
LC		 712 break;
713 default:
9ccd9217 714 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
f5fc0f86 715 ret = -ENODEV;
9ccd9217 716 goto out;
f5fc0f86
LC		 717 }
718
719 if (wl->fw == NULL) {
720 ret = wl1271_fetch_firmware(wl);
721 if (ret < 0)
9ccd9217 722 goto out;
f5fc0f86
LC		 723 }
724
725 /* No NVS from netlink, try to get it from the filesystem */
726 if (wl->nvs == NULL) {
727 ret = wl1271_fetch_nvs(wl);
728 if (ret < 0)
9ccd9217 729 goto out;
f5fc0f86
LC		 730 }
731
732out:
733 return ret;
734}
735
f5fc0f86
LC		 736int wl1271_plt_start(struct wl1271 *wl)
737{
9ccd9217 738 int retries = WL1271_BOOT_RETRIES;
f5fc0f86
LC		 739 int ret;
740
741 mutex_lock(&wl->mutex);
742
743 wl1271_notice("power up");
744
745 if (wl->state != WL1271_STATE_OFF) {
746 wl1271_error("cannot go into PLT state because not "
747 "in off state: %d", wl->state);
748 ret = -EBUSY;
749 goto out;
750 }
751
9ccd9217
JO		 752 while (retries) {
753 retries--;
754 ret = wl1271_chip_wakeup(wl);
755 if (ret < 0)
756 goto power_off;
f5fc0f86 757
9ccd9217
JO		 758 ret = wl1271_boot(wl);
759 if (ret < 0)
760 goto power_off;
eb5b28d0 761
9ccd9217
JO		 762 ret = wl1271_plt_init(wl);
763 if (ret < 0)
764 goto irq_disable;
bd5ea18f 765
9ccd9217
JO		 766 wl->state = WL1271_STATE_PLT;
767 wl1271_notice("firmware booted in PLT mode (%s)",
768 wl->chip.fw_ver);
769 goto out;
eb5b28d0 770
9ccd9217
JO		 771irq_disable:
772 wl1271_disable_interrupts(wl);
773 mutex_unlock(&wl->mutex);
774 /* Unlocking the mutex in the middle of handling is
775 inherently unsafe. In this case we deem it safe to do,
776 because we need to let any possibly pending IRQ out of
777 the system (and while we are WL1271_STATE_OFF the IRQ
778 work function will not do anything.) Also, any other
779 possible concurrent operations will fail due to the
780 current state, hence the wl1271 struct should be safe. */
781 cancel_work_sync(&wl->irq_work);
782 mutex_lock(&wl->mutex);
783power_off:
784 wl1271_power_off(wl);
785 }
f5fc0f86 786
9ccd9217
JO		 787 wl1271_error("firmware boot in PLT mode failed despite %d retries",
788 WL1271_BOOT_RETRIES);
f5fc0f86
LC		 789out:
790 mutex_unlock(&wl->mutex);
791
792 return ret;
793}
794
795int wl1271_plt_stop(struct wl1271 *wl)
796{
797 int ret = 0;
798
799 mutex_lock(&wl->mutex);
800
801 wl1271_notice("power down");
802
803 if (wl->state != WL1271_STATE_PLT) {
804 wl1271_error("cannot power down because not in PLT "
805 "state: %d", wl->state);
806 ret = -EBUSY;
807 goto out;
808 }
809
810 wl1271_disable_interrupts(wl);
811 wl1271_power_off(wl);
812
813 wl->state = WL1271_STATE_OFF;
bd5ea18f 814 wl->rx_counter = 0;
f5fc0f86
LC		 815
816out:
817 mutex_unlock(&wl->mutex);
818
8c7f4f31 819 cancel_work_sync(&wl->irq_work);
52b0e7a6 820 cancel_work_sync(&wl->recovery_work);
8c7f4f31 821
f5fc0f86
LC		 822 return ret;
823}
824
f5fc0f86
LC		 825static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
826{
827 struct wl1271 *wl = hw->priv;
830fb67b
JO		 828 struct ieee80211_conf *conf = &hw->conf;
829 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
830 struct ieee80211_sta *sta = txinfo->control.sta;
831 unsigned long flags;
f5fc0f86 832
830fb67b
JO		 833 /* peek into the rates configured in the STA entry */
834 spin_lock_irqsave(&wl->wl_lock, flags);
835 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
836 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
837 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
838 }
839 spin_unlock_irqrestore(&wl->wl_lock, flags);
840
841 /* queue the packet */
f5fc0f86
LC		 842 skb_queue_tail(&wl->tx_queue, skb);
843
844 /*
845 * The chip specific setup must run before the first TX packet -
846 * before that, the tx_work will not be initialized!
847 */
848
a64b07e8 849 ieee80211_queue_work(wl->hw, &wl->tx_work);
f5fc0f86
LC		 850
851 /*
852 * The workqueue is slow to process the tx_queue and we need stop
853 * the queue here, otherwise the queue will get too long.
854 */
06f7bc7d
JO		 855 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
856 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
f5fc0f86 857
06f7bc7d
JO		 858 spin_lock_irqsave(&wl->wl_lock, flags);
859 ieee80211_stop_queues(wl->hw);
71449f8d 860 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
06f7bc7d 861 spin_unlock_irqrestore(&wl->wl_lock, flags);
f5fc0f86
LC		 862 }
863
864 return NETDEV_TX_OK;
865}
866
c2c192ac
JO		 867static struct notifier_block wl1271_dev_notifier = {
868 .notifier_call = wl1271_dev_notify,
869};
870
f5fc0f86 871static int wl1271_op_start(struct ieee80211_hw *hw)
1b72aecd
JO		 872{
873 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
874
875 /*
876 * We have to delay the booting of the hardware because
877 * we need to know the local MAC address before downloading and
878 * initializing the firmware. The MAC address cannot be changed
879 * after boot, and without the proper MAC address, the firmware
880 * will not function properly.
881 *
882 * The MAC address is first known when the corresponding interface
883 * is added. That is where we will initialize the hardware.
884 */
885
886 return 0;
887}
888
889static void wl1271_op_stop(struct ieee80211_hw *hw)
890{
891 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
892}
893
894static int wl1271_op_add_interface(struct ieee80211_hw *hw,
895 struct ieee80211_vif *vif)
f5fc0f86
LC		 896{
897 struct wl1271 *wl = hw->priv;
ac01e948 898 struct wiphy *wiphy = hw->wiphy;
9ccd9217 899 int retries = WL1271_BOOT_RETRIES;
f5fc0f86
LC		 900 int ret = 0;
901
1b72aecd
JO		 902 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
903 vif->type, vif->addr);
f5fc0f86
LC		 904
905 mutex_lock(&wl->mutex);
1b72aecd
JO		 906 if (wl->vif) {
907 ret = -EBUSY;
908 goto out;
909 }
910
911 wl->vif = vif;
912
913 switch (vif->type) {
914 case NL80211_IFTYPE_STATION:
915 wl->bss_type = BSS_TYPE_STA_BSS;
5da11dcd 916 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd
JO		 917 break;
918 case NL80211_IFTYPE_ADHOC:
919 wl->bss_type = BSS_TYPE_IBSS;
5da11dcd 920 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd
JO		 921 break;
922 default:
923 ret = -EOPNOTSUPP;
924 goto out;
925 }
926
927 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
f5fc0f86
LC		 928
929 if (wl->state != WL1271_STATE_OFF) {
930 wl1271_error("cannot start because not in off state: %d",
931 wl->state);
932 ret = -EBUSY;
933 goto out;
934 }
935
9ccd9217
JO		 936 while (retries) {
937 retries--;
938 ret = wl1271_chip_wakeup(wl);
939 if (ret < 0)
940 goto power_off;
f5fc0f86 941
9ccd9217
JO		 942 ret = wl1271_boot(wl);
943 if (ret < 0)
944 goto power_off;
f5fc0f86 945
9ccd9217
JO		 946 ret = wl1271_hw_init(wl);
947 if (ret < 0)
948 goto irq_disable;
f5fc0f86 949
9ccd9217
JO		 950 wl->state = WL1271_STATE_ON;
951 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
ac01e948
JL		 952
953 /* update hw/fw version info in wiphy struct */
954 wiphy->hw_version = wl->chip.id;
955 strncpy(wiphy->fw_version, wl->chip.fw_ver,
956 sizeof(wiphy->fw_version));
957
9ccd9217 958 goto out;
eb5b28d0 959
9ccd9217
JO		 960irq_disable:
961 wl1271_disable_interrupts(wl);
962 mutex_unlock(&wl->mutex);
963 /* Unlocking the mutex in the middle of handling is
964 inherently unsafe. In this case we deem it safe to do,
965 because we need to let any possibly pending IRQ out of
966 the system (and while we are WL1271_STATE_OFF the IRQ
967 work function will not do anything.) Also, any other
968 possible concurrent operations will fail due to the
969 current state, hence the wl1271 struct should be safe. */
970 cancel_work_sync(&wl->irq_work);
971 mutex_lock(&wl->mutex);
972power_off:
973 wl1271_power_off(wl);
974 }
eb5b28d0 975
9ccd9217
JO		 976 wl1271_error("firmware boot failed despite %d retries",
977 WL1271_BOOT_RETRIES);
eb5b28d0 978out:
f5fc0f86
LC		 979 mutex_unlock(&wl->mutex);
980
eb887dfd 981 if (!ret)
01c09162 982 list_add(&wl->list, &wl_list);
01c09162 983
f5fc0f86
LC		 984 return ret;
985}
986
52a2a375 987static void __wl1271_op_remove_interface(struct wl1271 *wl)
f5fc0f86 988{
f5fc0f86
LC		 989 int i;
990
1b72aecd 991 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
f5fc0f86 992
1b72aecd 993 wl1271_info("down");
f5fc0f86 994
01c09162
JO		 995 list_del(&wl->list);
996
f5fc0f86
LC		 997 WARN_ON(wl->state != WL1271_STATE_ON);
998
8d2ef7bd 999 /* enable dyn ps just in case (if left on due to fw crash etc) */
9a547bf9 1000 if (wl->bss_type == BSS_TYPE_STA_BSS)
f532be6d 1001 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 1002
08688d6b 1003 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
08688d6b
LC		 1004 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1005 kfree(wl->scan.scanned_ch);
1006 wl->scan.scanned_ch = NULL;
76a029fb 1007 ieee80211_scan_completed(wl->hw, true);
f5fc0f86
LC		 1008 }
1009
1010 wl->state = WL1271_STATE_OFF;
1011
1012 wl1271_disable_interrupts(wl);
1013
1014 mutex_unlock(&wl->mutex);
1015
78abd320 1016 cancel_delayed_work_sync(&wl->scan_complete_work);
f5fc0f86
LC		 1017 cancel_work_sync(&wl->irq_work);
1018 cancel_work_sync(&wl->tx_work);
90494a90 1019 cancel_delayed_work_sync(&wl->pspoll_work);
8c7f4f31 1020 cancel_delayed_work_sync(&wl->elp_work);
f5fc0f86
LC		 1021
1022 mutex_lock(&wl->mutex);
1023
1024 /* let's notify MAC80211 about the remaining pending TX frames */
781608c4 1025 wl1271_tx_reset(wl);
f5fc0f86
LC		 1026 wl1271_power_off(wl);
1027
1028 memset(wl->bssid, 0, ETH_ALEN);
1029 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1030 wl->ssid_len = 0;
f5fc0f86 1031 wl->bss_type = MAX_BSS_TYPE;
5da11dcd 1032 wl->set_bss_type = MAX_BSS_TYPE;
8a5a37a6 1033 wl->band = IEEE80211_BAND_2GHZ;
f5fc0f86
LC		 1034
1035 wl->rx_counter = 0;
19ad0715 1036 wl->psm_entry_retry = 0;
f5fc0f86
LC		 1037 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1038 wl->tx_blocks_available = 0;
1039 wl->tx_results_count = 0;
1040 wl->tx_packets_count = 0;
ac4e4ce5 1041 wl->tx_security_last_seq = 0;
04e36fc5 1042 wl->tx_security_seq = 0;
f5fc0f86
LC		 1043 wl->time_offset = 0;
1044 wl->session_counter = 0;
830fb67b
JO		 1045 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1046 wl->sta_rate_set = 0;
1047 wl->flags = 0;
1b72aecd 1048 wl->vif = NULL;
14b228a0 1049 wl->filters = 0;
d6e19d13 1050
f5fc0f86
LC		 1051 for (i = 0; i < NUM_TX_QUEUES; i++)
1052 wl->tx_blocks_freed[i] = 0;
1053
1054 wl1271_debugfs_reset(wl);
bd9dc49c
JO		 1055
1056 kfree(wl->fw_status);
1057 wl->fw_status = NULL;
1058 kfree(wl->tx_res_if);
1059 wl->tx_res_if = NULL;
1060 kfree(wl->target_mem_map);
1061 wl->target_mem_map = NULL;
52a2a375 1062}
bd9dc49c 1063
52a2a375
JO		 1064static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1065 struct ieee80211_vif *vif)
1066{
1067 struct wl1271 *wl = hw->priv;
1068
1069 mutex_lock(&wl->mutex);
1070 WARN_ON(wl->vif != vif);
1071 __wl1271_op_remove_interface(wl);
f5fc0f86 1072 mutex_unlock(&wl->mutex);
52b0e7a6
JO		 1073
1074 cancel_work_sync(&wl->recovery_work);
f5fc0f86
LC		 1075}
1076
14b228a0
JO		 1077static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1078{
1079 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1080 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1081
1082 /* combine requested filters with current filter config */
1083 filters = wl->filters | filters;
1084
1085 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1086
1087 if (filters & FIF_PROMISC_IN_BSS) {
1088 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1089 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1090 wl->rx_config |= CFG_BSSID_FILTER_EN;
1091 }
1092 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1093 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1094 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1095 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1096 }
1097 if (filters & FIF_OTHER_BSS) {
1098 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1099 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1100 }
1101 if (filters & FIF_CONTROL) {
1102 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1103 wl->rx_filter |= CFG_RX_CTL_EN;
1104 }
1105 if (filters & FIF_FCSFAIL) {
1106 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1107 wl->rx_filter |= CFG_RX_FCS_ERROR;
1108 }
1109}
1110
82429d32 1111static int wl1271_dummy_join(struct wl1271 *wl)
c7f43e45 1112{
e0d8bbf0 1113 int ret = 0;
c7f43e45
LC		 1114 /* we need to use a dummy BSSID for now */
1115 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1116 0xad, 0xbe, 0xef };
1117
c7f43e45
LC		 1118 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1119
14b228a0
JO		 1120 /* pass through frames from all BSS */
1121 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1122
5da11dcd 1123 ret = wl1271_cmd_join(wl, wl->set_bss_type);
c7f43e45
LC		 1124 if (ret < 0)
1125 goto out;
1126
71449f8d 1127 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1128
1129out:
1130 return ret;
1131}
1132
69e5434c 1133static int wl1271_join(struct wl1271 *wl, bool set_assoc)
82429d32
JO		 1134{
1135 int ret;
1136
69e5434c
JO		 1137 /*
1138 * One of the side effects of the JOIN command is that is clears
1139 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1140 * to a WPA/WPA2 access point will therefore kill the data-path.
1141 * Currently there is no supported scenario for JOIN during
1142 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1143 * must be handled somehow.
1144 *
1145 */
1146 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1147 wl1271_info("JOIN while associated.");
1148
1149 if (set_assoc)
1150 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1151
82429d32
JO		 1152 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1153 if (ret < 0)
1154 goto out;
1155
1156 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1157
1158 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1159 goto out;
1160
1161 /*
1162 * The join command disable the keep-alive mode, shut down its process,
1163 * and also clear the template config, so we need to reset it all after
1164 * the join. The acx_aid starts the keep-alive process, and the order
1165 * of the commands below is relevant.
1166 */
1167 ret = wl1271_acx_keep_alive_mode(wl, true);
1168 if (ret < 0)
1169 goto out;
1170
1171 ret = wl1271_acx_aid(wl, wl->aid);
1172 if (ret < 0)
1173 goto out;
1174
1175 ret = wl1271_cmd_build_klv_null_data(wl);
1176 if (ret < 0)
1177 goto out;
1178
1179 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1180 ACX_KEEP_ALIVE_TPL_VALID);
1181 if (ret < 0)
1182 goto out;
1183
1184out:
1185 return ret;
1186}
1187
1188static int wl1271_unjoin(struct wl1271 *wl)
c7f43e45
LC		 1189{
1190 int ret;
1191
1192 /* to stop listening to a channel, we disconnect */
1193 ret = wl1271_cmd_disconnect(wl);
1194 if (ret < 0)
1195 goto out;
1196
71449f8d 1197 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45 1198 memset(wl->bssid, 0, ETH_ALEN);
14b228a0
JO		 1199
1200 /* stop filterting packets based on bssid */
1201 wl1271_configure_filters(wl, FIF_OTHER_BSS);
c7f43e45
LC		 1202
1203out:
1204 return ret;
1205}
1206
ebba60c6
JO		 1207static void wl1271_set_band_rate(struct wl1271 *wl)
1208{
1209 if (wl->band == IEEE80211_BAND_2GHZ)
1210 wl->basic_rate_set = wl->conf.tx.basic_rate;
1211 else
1212 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1213}
1214
1215static u32 wl1271_min_rate_get(struct wl1271 *wl)
1216{
1217 int i;
1218 u32 rate = 0;
1219
1220 if (!wl->basic_rate_set) {
1221 WARN_ON(1);
1222 wl->basic_rate_set = wl->conf.tx.basic_rate;
1223 }
1224
1225 for (i = 0; !rate; i++) {
1226 if ((wl->basic_rate_set >> i) & 0x1)
1227 rate = 1 << i;
1228 }
1229
1230 return rate;
1231}
1232
0d58cbff
JO		 1233static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1234{
1235 int ret;
1236
1237 if (idle) {
1238 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1239 ret = wl1271_unjoin(wl);
1240 if (ret < 0)
1241 goto out;
1242 }
1243 wl->rate_set = wl1271_min_rate_get(wl);
1244 wl->sta_rate_set = 0;
1245 ret = wl1271_acx_rate_policies(wl);
1246 if (ret < 0)
1247 goto out;
1248 ret = wl1271_acx_keep_alive_config(
1249 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1250 ACX_KEEP_ALIVE_TPL_INVALID);
1251 if (ret < 0)
1252 goto out;
1253 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1254 } else {
1255 /* increment the session counter */
1256 wl->session_counter++;
1257 if (wl->session_counter >= SESSION_COUNTER_MAX)
1258 wl->session_counter = 0;
1259 ret = wl1271_dummy_join(wl);
1260 if (ret < 0)
1261 goto out;
1262 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1263 }
1264
1265out:
1266 return ret;
1267}
1268
f5fc0f86
LC		 1269static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1270{
1271 struct wl1271 *wl = hw->priv;
1272 struct ieee80211_conf *conf = &hw->conf;
1273 int channel, ret = 0;
1274
1275 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1276
c7f43e45 1277 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
f5fc0f86
LC		 1278 channel,
1279 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45
LC		 1280 conf->power_level,
1281 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
f5fc0f86 1282
781608c4
JO		 1283 /*
1284 * mac80211 will go to idle nearly immediately after transmitting some
1285 * frames, such as the deauth. To make sure those frames reach the air,
1286 * wait here until the TX queue is fully flushed.
1287 */
1288 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1289 (conf->flags & IEEE80211_CONF_IDLE))
1290 wl1271_tx_flush(wl);
1291
f5fc0f86
LC		 1292 mutex_lock(&wl->mutex);
1293
2c10bb9c
SD		 1294 if (unlikely(wl->state == WL1271_STATE_OFF))
1295 goto out;
8a5a37a6 1296
f5fc0f86
LC		 1297 ret = wl1271_ps_elp_wakeup(wl, false);
1298 if (ret < 0)
1299 goto out;
1300
ebba60c6 1301 /* if the channel changes while joined, join again */
69e5434c
JO		 1302 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1303 ((wl->band != conf->channel->band) ||
1304 (wl->channel != channel))) {
ebba60c6
JO		 1305 wl->band = conf->channel->band;
1306 wl->channel = channel;
1307
1308 /*
1309 * FIXME: the mac80211 should really provide a fixed rate
1310 * to use here. for now, just use the smallest possible rate
1311 * for the band as a fixed rate for association frames and
1312 * other control messages.
1313 */
1314 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1315 wl1271_set_band_rate(wl);
1316
1317 wl->basic_rate = wl1271_min_rate_get(wl);
1318 ret = wl1271_acx_rate_policies(wl);
1319 if (ret < 0)
1320 wl1271_warning("rate policy for update channel "
1321 "failed %d", ret);
1322
1323 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
69e5434c 1324 ret = wl1271_join(wl, false);
ebba60c6
JO		 1325 if (ret < 0)
1326 wl1271_warning("cmd join to update channel "
1327 "failed %d", ret);
1328 }
1329 }
1330
c7f43e45 1331 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
0d58cbff
JO		 1332 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1333 if (ret < 0)
1334 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 1335 }
1336
90494a90
JO		 1337 /*
1338 * if mac80211 changes the PSM mode, make sure the mode is not
1339 * incorrectly changed after the pspoll failure active window.
1340 */
1341 if (changed & IEEE80211_CONF_CHANGE_PS)
1342 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1343
71449f8d
JO		 1344 if (conf->flags & IEEE80211_CONF_PS &&
1345 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1346 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 1347
1348 /*
1349 * We enter PSM only if we're already associated.
1350 * If we're not, we'll enter it when joining an SSID,
1351 * through the bss_info_changed() hook.
1352 */
830fb67b 1353 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 1354 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c 1355 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
65cddbf1 1356 wl->basic_rate_set, true);
af5e084b 1357 }
f5fc0f86 1358 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 1359 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 1360 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 1361
71449f8d 1362 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 1363
71449f8d 1364 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c 1365 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
65cddbf1 1366 wl->basic_rate_set, true);
f5fc0f86
LC		 1367 }
1368
1369 if (conf->power_level != wl->power_level) {
1370 ret = wl1271_acx_tx_power(wl, conf->power_level);
1371 if (ret < 0)
c6317a54 1372 goto out_sleep;
f5fc0f86
LC		 1373
1374 wl->power_level = conf->power_level;
1375 }
1376
1377out_sleep:
1378 wl1271_ps_elp_sleep(wl);
1379
1380out:
1381 mutex_unlock(&wl->mutex);
1382
1383 return ret;
1384}
1385
b54853f1
JO		 1386struct wl1271_filter_params {
1387 bool enabled;
1388 int mc_list_length;
1389 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1390};
1391
22bedad3
JP		 1392static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1393 struct netdev_hw_addr_list *mc_list)
c87dec9f 1394{
c87dec9f 1395 struct wl1271_filter_params *fp;
22bedad3 1396 struct netdev_hw_addr *ha;
2c10bb9c 1397 struct wl1271 *wl = hw->priv;
c87dec9f 1398
2c10bb9c
SD		 1399 if (unlikely(wl->state == WL1271_STATE_OFF))
1400 return 0;
c87dec9f 1401
74441130 1402 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 1403 if (!fp) {
1404 wl1271_error("Out of memory setting filters.");
1405 return 0;
1406 }
1407
1408 /* update multicast filtering parameters */
c87dec9f 1409 fp->mc_list_length = 0;
22bedad3
JP		 1410 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1411 fp->enabled = false;
1412 } else {
1413 fp->enabled = true;
1414 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 1415 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 1416 ha->addr, ETH_ALEN);
c87dec9f 1417 fp->mc_list_length++;
22bedad3 1418 }
c87dec9f
JO		 1419 }
1420
b54853f1 1421 return (u64)(unsigned long)fp;
c87dec9f 1422}
f5fc0f86 1423
b54853f1
JO		 1424#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1425 FIF_ALLMULTI | \
1426 FIF_FCSFAIL | \
1427 FIF_BCN_PRBRESP_PROMISC | \
1428 FIF_CONTROL | \
1429 FIF_OTHER_BSS)
1430
f5fc0f86
LC		 1431static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1432 unsigned int changed,
c87dec9f 1433 unsigned int *total, u64 multicast)
f5fc0f86 1434{
b54853f1 1435 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 1436 struct wl1271 *wl = hw->priv;
b54853f1 1437 int ret;
f5fc0f86
LC		 1438
1439 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1440
b54853f1
JO		 1441 mutex_lock(&wl->mutex);
1442
2c10bb9c
SD		 1443 *total &= WL1271_SUPPORTED_FILTERS;
1444 changed &= WL1271_SUPPORTED_FILTERS;
1445
1446 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 1447 goto out;
1448
1449 ret = wl1271_ps_elp_wakeup(wl, false);
1450 if (ret < 0)
1451 goto out;
1452
f5fc0f86 1453
b54853f1
JO		 1454 if (*total & FIF_ALLMULTI)
1455 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1456 else if (fp)
1457 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1458 fp->mc_list,
1459 fp->mc_list_length);
1460 if (ret < 0)
1461 goto out_sleep;
f5fc0f86 1462
b54853f1
JO		 1463 /* determine, whether supported filter values have changed */
1464 if (changed == 0)
1465 goto out_sleep;
c87dec9f 1466
14b228a0
JO		 1467 /* configure filters */
1468 wl->filters = *total;
1469 wl1271_configure_filters(wl, 0);
1470
b54853f1
JO		 1471 /* apply configured filters */
1472 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1473 if (ret < 0)
1474 goto out_sleep;
1475
1476out_sleep:
1477 wl1271_ps_elp_sleep(wl);
1478
1479out:
1480 mutex_unlock(&wl->mutex);
14b228a0 1481 kfree(fp);
f5fc0f86
LC		 1482}
1483
1484static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1485 struct ieee80211_vif *vif,
1486 struct ieee80211_sta *sta,
1487 struct ieee80211_key_conf *key_conf)
1488{
1489 struct wl1271 *wl = hw->priv;
1490 const u8 *addr;
1491 int ret;
ac4e4ce5
JO		 1492 u32 tx_seq_32 = 0;
1493 u16 tx_seq_16 = 0;
f5fc0f86
LC		 1494 u8 key_type;
1495
1496 static const u8 bcast_addr[ETH_ALEN] =
1497 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1498
1499 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1500
1501 addr = sta ? sta->addr : bcast_addr;
1502
1503 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1504 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1505 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
97359d12 1506 key_conf->cipher, key_conf->keyidx,
f5fc0f86
LC		 1507 key_conf->keylen, key_conf->flags);
1508 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1509
1510 if (is_zero_ether_addr(addr)) {
1511 /* We dont support TX only encryption */
1512 ret = -EOPNOTSUPP;
1513 goto out;
1514 }
1515
1516 mutex_lock(&wl->mutex);
1517
1518 ret = wl1271_ps_elp_wakeup(wl, false);
1519 if (ret < 0)
1520 goto out_unlock;
1521
97359d12
JB		 1522 switch (key_conf->cipher) {
1523 case WLAN_CIPHER_SUITE_WEP40:
1524 case WLAN_CIPHER_SUITE_WEP104:
f5fc0f86
LC		 1525 key_type = KEY_WEP;
1526
1527 key_conf->hw_key_idx = key_conf->keyidx;
1528 break;
97359d12 1529 case WLAN_CIPHER_SUITE_TKIP:
f5fc0f86
LC		 1530 key_type = KEY_TKIP;
1531
1532 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 1533 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1534 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 1535 break;
97359d12 1536 case WLAN_CIPHER_SUITE_CCMP:
f5fc0f86
LC		 1537 key_type = KEY_AES;
1538
1539 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
04e36fc5
JO		 1540 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1541 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86
LC		 1542 break;
1543 default:
97359d12 1544 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
f5fc0f86
LC		 1545
1546 ret = -EOPNOTSUPP;
1547 goto out_sleep;
1548 }
1549
1550 switch (cmd) {
1551 case SET_KEY:
1552 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1553 key_conf->keyidx, key_type,
1554 key_conf->keylen, key_conf->key,
ac4e4ce5 1555 addr, tx_seq_32, tx_seq_16);
f5fc0f86
LC		 1556 if (ret < 0) {
1557 wl1271_error("Could not add or replace key");
1558 goto out_sleep;
1559 }
ee444cf0
JO		 1560
1561 /* the default WEP key needs to be configured at least once */
1562 if (key_type == KEY_WEP) {
1563 ret = wl1271_cmd_set_default_wep_key(wl,
1564 wl->default_key);
1565 if (ret < 0)
1566 goto out_sleep;
1567 }
f5fc0f86
LC		 1568 break;
1569
1570 case DISABLE_KEY:
fddc7dd7
JO		 1571 /* The wl1271 does not allow to remove unicast keys - they
1572 will be cleared automatically on next CMD_JOIN. Ignore the
1573 request silently, as we dont want the mac80211 to emit
1574 an error message. */
1575 if (!is_broadcast_ether_addr(addr))
1576 break;
1577
f5fc0f86
LC		 1578 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1579 key_conf->keyidx, key_type,
1580 key_conf->keylen, key_conf->key,
ac4e4ce5 1581 addr, 0, 0);
f5fc0f86
LC		 1582 if (ret < 0) {
1583 wl1271_error("Could not remove key");
1584 goto out_sleep;
1585 }
1586 break;
1587
1588 default:
1589 wl1271_error("Unsupported key cmd 0x%x", cmd);
1590 ret = -EOPNOTSUPP;
f5fc0f86
LC		 1591 break;
1592 }
1593
1594out_sleep:
1595 wl1271_ps_elp_sleep(wl);
1596
1597out_unlock:
1598 mutex_unlock(&wl->mutex);
1599
1600out:
1601 return ret;
1602}
1603
1604static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 1605 struct ieee80211_vif *vif,
f5fc0f86
LC		 1606 struct cfg80211_scan_request *req)
1607{
1608 struct wl1271 *wl = hw->priv;
1609 int ret;
1610 u8 *ssid = NULL;
abb0b3bf 1611 size_t len = 0;
f5fc0f86
LC		 1612
1613 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1614
1615 if (req->n_ssids) {
1616 ssid = req->ssids[0].ssid;
abb0b3bf 1617 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 1618 }
1619
1620 mutex_lock(&wl->mutex);
1621
1622 ret = wl1271_ps_elp_wakeup(wl, false);
1623 if (ret < 0)
1624 goto out;
1625
5924f89d 1626 ret = wl1271_scan(hw->priv, ssid, len, req);
f5fc0f86
LC		 1627
1628 wl1271_ps_elp_sleep(wl);
1629
1630out:
1631 mutex_unlock(&wl->mutex);
1632
1633 return ret;
1634}
1635
1636static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1637{
1638 struct wl1271 *wl = hw->priv;
aecb0565 1639 int ret = 0;
f5fc0f86
LC		 1640
1641 mutex_lock(&wl->mutex);
1642
aecb0565
SD		 1643 if (unlikely(wl->state == WL1271_STATE_OFF))
1644 goto out;
1645
f5fc0f86
LC		 1646 ret = wl1271_ps_elp_wakeup(wl, false);
1647 if (ret < 0)
1648 goto out;
1649
1650 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1651 if (ret < 0)
1652 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1653
1654 wl1271_ps_elp_sleep(wl);
1655
1656out:
1657 mutex_unlock(&wl->mutex);
1658
1659 return ret;
1660}
1661
30240fc7
JO		 1662static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1663{
1664 u8 *ptr = beacon->data +
1665 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1666
1667 /* find the location of the ssid in the beacon */
1668 while (ptr < beacon->data + beacon->len) {
1669 if (ptr[0] == WLAN_EID_SSID) {
1670 wl->ssid_len = ptr[1];
1671 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1672 return;
1673 }
1674 ptr += ptr[1];
1675 }
1676 wl1271_error("ad-hoc beacon template has no SSID!\n");
1677}
1678
f5fc0f86
LC		 1679static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1680 struct ieee80211_vif *vif,
1681 struct ieee80211_bss_conf *bss_conf,
1682 u32 changed)
1683{
1684 enum wl1271_cmd_ps_mode mode;
1685 struct wl1271 *wl = hw->priv;
8bf29b0e 1686 bool do_join = false;
69e5434c 1687 bool set_assoc = false;
f5fc0f86
LC		 1688 int ret;
1689
1690 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1691
1692 mutex_lock(&wl->mutex);
1693
1694 ret = wl1271_ps_elp_wakeup(wl, false);
1695 if (ret < 0)
1696 goto out;
1697
9ee82d54 1698 if ((changed & BSS_CHANGED_BEACON_INT) &&
60e84c2e
JO		 1699 (wl->bss_type == BSS_TYPE_IBSS)) {
1700 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1701 bss_conf->beacon_int);
1702
1703 wl->beacon_int = bss_conf->beacon_int;
1704 do_join = true;
1705 }
1706
9ee82d54 1707 if ((changed & BSS_CHANGED_BEACON) &&
5da11dcd 1708 (wl->bss_type == BSS_TYPE_IBSS)) {
e0d8bbf0
JO		 1709 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1710
5da11dcd
JO		 1711 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1712
e0d8bbf0
JO		 1713 if (beacon) {
1714 struct ieee80211_hdr *hdr;
30240fc7
JO		 1715
1716 wl1271_ssid_set(wl, beacon);
e0d8bbf0
JO		 1717 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1718 beacon->data,
606c1487
JO		 1719 beacon->len, 0,
1720 wl1271_min_rate_get(wl));
e0d8bbf0
JO		 1721
1722 if (ret < 0) {
1723 dev_kfree_skb(beacon);
1724 goto out_sleep;
1725 }
1726
1727 hdr = (struct ieee80211_hdr *) beacon->data;
1728 hdr->frame_control = cpu_to_le16(
1729 IEEE80211_FTYPE_MGMT |
1730 IEEE80211_STYPE_PROBE_RESP);
1731
1732 ret = wl1271_cmd_template_set(wl,
1733 CMD_TEMPL_PROBE_RESPONSE,
1734 beacon->data,
606c1487
JO		 1735 beacon->len, 0,
1736 wl1271_min_rate_get(wl));
e0d8bbf0
JO		 1737 dev_kfree_skb(beacon);
1738 if (ret < 0)
1739 goto out_sleep;
8bf29b0e
JO		 1740
1741 /* Need to update the SSID (for filtering etc) */
1742 do_join = true;
e0d8bbf0
JO		 1743 }
1744 }
1745
5da11dcd
JO		 1746 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1747 (wl->bss_type == BSS_TYPE_IBSS)) {
1748 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1749 bss_conf->enable_beacon ? "enabled" : "disabled");
1750
1751 if (bss_conf->enable_beacon)
1752 wl->set_bss_type = BSS_TYPE_IBSS;
1753 else
1754 wl->set_bss_type = BSS_TYPE_STA_BSS;
1755 do_join = true;
1756 }
1757
00236aed
JO		 1758 if (changed & BSS_CHANGED_CQM) {
1759 bool enable = false;
1760 if (bss_conf->cqm_rssi_thold)
1761 enable = true;
1762 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1763 bss_conf->cqm_rssi_thold,
1764 bss_conf->cqm_rssi_hyst);
1765 if (ret < 0)
1766 goto out;
1767 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1768 }
1769
30240fc7
JO		 1770 if ((changed & BSS_CHANGED_BSSID) &&
1771 /*
1772 * Now we know the correct bssid, so we send a new join command
1773 * and enable the BSSID filter
1774 */
1775 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
30240fc7 1776 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 1777
30240fc7 1778 ret = wl1271_cmd_build_null_data(wl);
a0cb7be4 1779 if (ret < 0)
30240fc7 1780 goto out_sleep;
30240fc7 1781
141418c7 1782 ret = wl1271_build_qos_null_data(wl);
a0cb7be4 1783 if (ret < 0)
30240fc7 1784 goto out_sleep;
30240fc7 1785
14b228a0
JO		 1786 /* filter out all packets not from this BSSID */
1787 wl1271_configure_filters(wl, 0);
1788
8bf29b0e
JO		 1789 /* Need to update the BSSID (for filtering etc) */
1790 do_join = true;
30240fc7
JO		 1791 }
1792
f5fc0f86
LC		 1793 if (changed & BSS_CHANGED_ASSOC) {
1794 if (bss_conf->assoc) {
ebba60c6 1795 u32 rates;
f5fc0f86 1796 wl->aid = bss_conf->aid;
69e5434c 1797 set_assoc = true;
f5fc0f86 1798
90494a90
JO		 1799 wl->ps_poll_failures = 0;
1800
ebba60c6
JO		 1801 /*
1802 * use basic rates from AP, and determine lowest rate
1803 * to use with control frames.
1804 */
1805 rates = bss_conf->basic_rates;
1806 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1807 rates);
1808 wl->basic_rate = wl1271_min_rate_get(wl);
1809 ret = wl1271_acx_rate_policies(wl);
1810 if (ret < 0)
1811 goto out_sleep;
1812
ae751bab
LC		 1813 /*
1814 * with wl1271, we don't need to update the
1815 * beacon_int and dtim_period, because the firmware
1816 * updates it by itself when the first beacon is
1817 * received after a join.
1818 */
f5fc0f86
LC		 1819 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1820 if (ret < 0)
1821 goto out_sleep;
1822
c2b2d99b
JO		 1823 /*
1824 * The SSID is intentionally set to NULL here - the
1825 * firmware will set the probe request with a
1826 * broadcast SSID regardless of what we set in the
1827 * template.
1828 */
1829 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1830 NULL, 0, wl->band);
1831
6ccbb92e
JO		 1832 /* enable the connection monitoring feature */
1833 ret = wl1271_acx_conn_monit_params(wl, true);
f5fc0f86
LC		 1834 if (ret < 0)
1835 goto out_sleep;
1836
1837 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 1838 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1839 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
f5fc0f86 1840 mode = STATION_POWER_SAVE_MODE;
65cddbf1
JO		 1841 ret = wl1271_ps_set_mode(wl, mode,
1842 wl->basic_rate_set,
1843 true);
f5fc0f86
LC		 1844 if (ret < 0)
1845 goto out_sleep;
1846 }
d94cd297
JO		 1847 } else {
1848 /* use defaults when not associated */
c2c192ac 1849 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
830fb67b 1850 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
d94cd297 1851 wl->aid = 0;
6ccbb92e 1852
8d2ef7bd 1853 /* re-enable dynamic ps - just in case */
f532be6d 1854 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 1855
ebba60c6
JO		 1856 /* revert back to minimum rates for the current band */
1857 wl1271_set_band_rate(wl);
1858 wl->basic_rate = wl1271_min_rate_get(wl);
1859 ret = wl1271_acx_rate_policies(wl);
1860 if (ret < 0)
1861 goto out_sleep;
1862
6ccbb92e
JO		 1863 /* disable connection monitor features */
1864 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 1865
1866 /* Disable the keep-alive feature */
1867 ret = wl1271_acx_keep_alive_mode(wl, false);
1868
6ccbb92e
JO		 1869 if (ret < 0)
1870 goto out_sleep;
f5fc0f86 1871 }
d94cd297 1872
f5fc0f86 1873 }
8a5a37a6 1874
f5fc0f86
LC		 1875 if (changed & BSS_CHANGED_ERP_SLOT) {
1876 if (bss_conf->use_short_slot)
1877 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1878 else
1879 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1880 if (ret < 0) {
1881 wl1271_warning("Set slot time failed %d", ret);
1882 goto out_sleep;
1883 }
1884 }
1885
1886 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1887 if (bss_conf->use_short_preamble)
1888 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1889 else
1890 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1891 }
1892
1893 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1894 if (bss_conf->use_cts_prot)
1895 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1896 else
1897 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1898 if (ret < 0) {
1899 wl1271_warning("Set ctsprotect failed %d", ret);
1900 goto out_sleep;
1901 }
1902 }
1903
ca52a5eb
JO		 1904 if (changed & BSS_CHANGED_ARP_FILTER) {
1905 __be32 addr = bss_conf->arp_addr_list[0];
1906 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1907
1908 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1909 ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1910 else
1911 ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1912
1913 if (ret < 0)
1914 goto out_sleep;
1915 }
1916
8bf29b0e 1917 if (do_join) {
69e5434c 1918 ret = wl1271_join(wl, set_assoc);
8bf29b0e
JO		 1919 if (ret < 0) {
1920 wl1271_warning("cmd join failed %d", ret);
1921 goto out_sleep;
1922 }
c1899554
JO		 1923 }
1924
f5fc0f86
LC		 1925out_sleep:
1926 wl1271_ps_elp_sleep(wl);
1927
1928out:
1929 mutex_unlock(&wl->mutex);
1930}
1931
c6999d83
KV		 1932static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1933 const struct ieee80211_tx_queue_params *params)
1934{
1935 struct wl1271 *wl = hw->priv;
4695dc91 1936 u8 ps_scheme;
c6999d83
KV		 1937 int ret;
1938
1939 mutex_lock(&wl->mutex);
1940
1941 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1942
c82c1dde
KV		 1943 ret = wl1271_ps_elp_wakeup(wl, false);
1944 if (ret < 0)
1945 goto out;
1946
b43316db 1947 /* the txop is confed in units of 32us by the mac80211, we need us */
c6999d83
KV		 1948 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1949 params->cw_min, params->cw_max,
b43316db 1950 params->aifs, params->txop << 5);
c6999d83 1951 if (ret < 0)
c82c1dde 1952 goto out_sleep;
c6999d83 1953
4695dc91
KV		 1954 if (params->uapsd)
1955 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1956 else
1957 ps_scheme = CONF_PS_SCHEME_LEGACY;
1958
c6999d83
KV		 1959 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1960 CONF_CHANNEL_TYPE_EDCF,
1961 wl1271_tx_get_queue(queue),
4695dc91 1962 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
c6999d83 1963 if (ret < 0)
c82c1dde
KV		 1964 goto out_sleep;
1965
1966out_sleep:
1967 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 1968
1969out:
1970 mutex_unlock(&wl->mutex);
1971
1972 return ret;
1973}
1974
bbbb538e
JO		 1975static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1976{
1977
1978 struct wl1271 *wl = hw->priv;
1979 u64 mactime = ULLONG_MAX;
1980 int ret;
1981
1982 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1983
1984 mutex_lock(&wl->mutex);
1985
1986 ret = wl1271_ps_elp_wakeup(wl, false);
1987 if (ret < 0)
1988 goto out;
1989
1990 ret = wl1271_acx_tsf_info(wl, &mactime);
1991 if (ret < 0)
1992 goto out_sleep;
1993
1994out_sleep:
1995 wl1271_ps_elp_sleep(wl);
1996
1997out:
1998 mutex_unlock(&wl->mutex);
1999 return mactime;
2000}
f5fc0f86 2001
ece550d0
JL		 2002static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2003 struct survey_info *survey)
2004{
2005 struct wl1271 *wl = hw->priv;
2006 struct ieee80211_conf *conf = &hw->conf;
2007
2008 if (idx != 0)
2009 return -ENOENT;
2010
2011 survey->channel = conf->channel;
2012 survey->filled = SURVEY_INFO_NOISE_DBM;
2013 survey->noise = wl->noise;
2014
2015 return 0;
2016}
2017
f5fc0f86
LC		 2018/* can't be const, mac80211 writes to this */
2019static struct ieee80211_rate wl1271_rates[] = {
2020 { .bitrate = 10,
2b60100b
JO		 2021 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2022 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 2023 { .bitrate = 20,
2b60100b
JO		 2024 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2025 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 2026 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2027 { .bitrate = 55,
2b60100b
JO		 2028 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2029 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 2030 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2031 { .bitrate = 110,
2b60100b
JO		 2032 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2033 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 2034 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2035 { .bitrate = 60,
2b60100b
JO		 2036 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2037 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 2038 { .bitrate = 90,
2b60100b
JO		 2039 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2040 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 2041 { .bitrate = 120,
2b60100b
JO		 2042 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2043 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 2044 { .bitrate = 180,
2b60100b
JO		 2045 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2046 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 2047 { .bitrate = 240,
2b60100b
JO		 2048 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2049 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 2050 { .bitrate = 360,
2b60100b
JO		 2051 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2052 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 2053 { .bitrate = 480,
2b60100b
JO		 2054 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2055 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 2056 { .bitrate = 540,
2b60100b
JO		 2057 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2058 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 2059};
2060
fa21c7a9
JO		 2061/*
2062 * Can't be const, mac80211 writes to this. The order of the channels here
2063 * is designed to improve scanning.
2064 */
f5fc0f86 2065static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 2066 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
a2d0e3f1 2067 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
a2d0e3f1 2068 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
a2d0e3f1 2069 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
fa21c7a9
JO		 2070 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2071 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2072 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2073 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2074 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2075 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2076 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2077 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2078 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
f5fc0f86
LC		 2079};
2080
f876bb9a 2081/* mapping to indexes for wl1271_rates */
a0ea9493 2082static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a
JO		 2083 /* MCS rates are used only with 11n */
2084 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2085 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2086 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2087 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2088 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2089 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2090 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2091 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2092
2093 11, /* CONF_HW_RXTX_RATE_54 */
2094 10, /* CONF_HW_RXTX_RATE_48 */
2095 9, /* CONF_HW_RXTX_RATE_36 */
2096 8, /* CONF_HW_RXTX_RATE_24 */
2097
2098 /* TI-specific rate */
2099 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2100
2101 7, /* CONF_HW_RXTX_RATE_18 */
2102 6, /* CONF_HW_RXTX_RATE_12 */
2103 3, /* CONF_HW_RXTX_RATE_11 */
2104 5, /* CONF_HW_RXTX_RATE_9 */
2105 4, /* CONF_HW_RXTX_RATE_6 */
2106 2, /* CONF_HW_RXTX_RATE_5_5 */
2107 1, /* CONF_HW_RXTX_RATE_2 */
2108 0 /* CONF_HW_RXTX_RATE_1 */
2109};
2110
f5fc0f86
LC		 2111/* can't be const, mac80211 writes to this */
2112static struct ieee80211_supported_band wl1271_band_2ghz = {
2113 .channels = wl1271_channels,
2114 .n_channels = ARRAY_SIZE(wl1271_channels),
2115 .bitrates = wl1271_rates,
2116 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2117};
2118
1ebec3d7
TP		 2119/* 5 GHz data rates for WL1273 */
2120static struct ieee80211_rate wl1271_rates_5ghz[] = {
2121 { .bitrate = 60,
2122 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2123 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2124 { .bitrate = 90,
2125 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2126 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2127 { .bitrate = 120,
2128 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2129 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2130 { .bitrate = 180,
2131 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2132 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2133 { .bitrate = 240,
2134 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2135 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2136 { .bitrate = 360,
2137 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2138 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2139 { .bitrate = 480,
2140 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2141 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2142 { .bitrate = 540,
2143 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2144 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2145};
2146
fa21c7a9
JO		 2147/*
2148 * 5 GHz band channels for WL1273 - can't be const, mac80211 writes to this.
2149 * The order of the channels here is designed to improve scanning.
2150 */
1ebec3d7
TP		 2151static struct ieee80211_channel wl1271_channels_5ghz[] = {
2152 { .hw_value = 183, .center_freq = 4915},
1ebec3d7 2153 { .hw_value = 188, .center_freq = 4940},
1ebec3d7 2154 { .hw_value = 8, .center_freq = 5040},
1ebec3d7 2155 { .hw_value = 34, .center_freq = 5170},
1ebec3d7 2156 { .hw_value = 44, .center_freq = 5220},
1ebec3d7 2157 { .hw_value = 60, .center_freq = 5300},
1ebec3d7 2158 { .hw_value = 112, .center_freq = 5560},
1ebec3d7 2159 { .hw_value = 132, .center_freq = 5660},
fa21c7a9
JO		 2160 { .hw_value = 157, .center_freq = 5785},
2161 { .hw_value = 184, .center_freq = 4920},
2162 { .hw_value = 189, .center_freq = 4945},
2163 { .hw_value = 9, .center_freq = 5045},
2164 { .hw_value = 36, .center_freq = 5180},
2165 { .hw_value = 46, .center_freq = 5230},
2166 { .hw_value = 64, .center_freq = 5320},
2167 { .hw_value = 116, .center_freq = 5580},
1ebec3d7 2168 { .hw_value = 136, .center_freq = 5680},
fa21c7a9
JO		 2169 { .hw_value = 192, .center_freq = 4960},
2170 { .hw_value = 11, .center_freq = 5055},
2171 { .hw_value = 38, .center_freq = 5190},
2172 { .hw_value = 48, .center_freq = 5240},
2173 { .hw_value = 100, .center_freq = 5500},
2174 { .hw_value = 120, .center_freq = 5600},
1ebec3d7 2175 { .hw_value = 140, .center_freq = 5700},
fa21c7a9
JO		 2176 { .hw_value = 185, .center_freq = 4925},
2177 { .hw_value = 196, .center_freq = 4980},
2178 { .hw_value = 12, .center_freq = 5060},
2179 { .hw_value = 40, .center_freq = 5200},
2180 { .hw_value = 52, .center_freq = 5260},
2181 { .hw_value = 104, .center_freq = 5520},
2182 { .hw_value = 124, .center_freq = 5620},
1ebec3d7 2183 { .hw_value = 149, .center_freq = 5745},
1ebec3d7 2184 { .hw_value = 161, .center_freq = 5805},
fa21c7a9
JO		 2185 { .hw_value = 187, .center_freq = 4935},
2186 { .hw_value = 7, .center_freq = 5035},
2187 { .hw_value = 16, .center_freq = 5080},
2188 { .hw_value = 42, .center_freq = 5210},
2189 { .hw_value = 56, .center_freq = 5280},
2190 { .hw_value = 108, .center_freq = 5540},
2191 { .hw_value = 128, .center_freq = 5640},
2192 { .hw_value = 153, .center_freq = 5765},
1ebec3d7
TP		 2193 { .hw_value = 165, .center_freq = 5825},
2194};
2195
f876bb9a 2196/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 2197static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a
JO		 2198 /* MCS rates are used only with 11n */
2199 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2200 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2201 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2202 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2203 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2204 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2205 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2206 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2207
2208 7, /* CONF_HW_RXTX_RATE_54 */
2209 6, /* CONF_HW_RXTX_RATE_48 */
2210 5, /* CONF_HW_RXTX_RATE_36 */
2211 4, /* CONF_HW_RXTX_RATE_24 */
2212
2213 /* TI-specific rate */
2214 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2215
2216 3, /* CONF_HW_RXTX_RATE_18 */
2217 2, /* CONF_HW_RXTX_RATE_12 */
2218 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2219 1, /* CONF_HW_RXTX_RATE_9 */
2220 0, /* CONF_HW_RXTX_RATE_6 */
2221 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2222 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2223 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2224};
1ebec3d7
TP		 2225
2226static struct ieee80211_supported_band wl1271_band_5ghz = {
2227 .channels = wl1271_channels_5ghz,
2228 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2229 .bitrates = wl1271_rates_5ghz,
2230 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2231};
2232
a0ea9493 2233static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 2234 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2235 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2236};
2237
f5fc0f86
LC		 2238static const struct ieee80211_ops wl1271_ops = {
2239 .start = wl1271_op_start,
2240 .stop = wl1271_op_stop,
2241 .add_interface = wl1271_op_add_interface,
2242 .remove_interface = wl1271_op_remove_interface,
2243 .config = wl1271_op_config,
c87dec9f 2244 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 2245 .configure_filter = wl1271_op_configure_filter,
2246 .tx = wl1271_op_tx,
2247 .set_key = wl1271_op_set_key,
2248 .hw_scan = wl1271_op_hw_scan,
2249 .bss_info_changed = wl1271_op_bss_info_changed,
2250 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 2251 .conf_tx = wl1271_op_conf_tx,
bbbb538e 2252 .get_tsf = wl1271_op_get_tsf,
ece550d0 2253 .get_survey = wl1271_op_get_survey,
c8c90873 2254 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 2255};
2256
f876bb9a
JO		 2257
2258u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2259{
2260 u8 idx;
2261
2262 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2263
2264 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2265 wl1271_error("Illegal RX rate from HW: %d", rate);
2266 return 0;
2267 }
2268
2269 idx = wl1271_band_rate_to_idx[wl->band][rate];
2270 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2271 wl1271_error("Unsupported RX rate from HW: %d", rate);
2272 return 0;
2273 }
2274
2275 return idx;
2276}
2277
7fc3a864
JO		 2278static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2279 struct device_attribute *attr,
2280 char *buf)
2281{
2282 struct wl1271 *wl = dev_get_drvdata(dev);
2283 ssize_t len;
2284
2f63b011 2285 len = PAGE_SIZE;
7fc3a864
JO		 2286
2287 mutex_lock(&wl->mutex);
2288 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2289 wl->sg_enabled);
2290 mutex_unlock(&wl->mutex);
2291
2292 return len;
2293
2294}
2295
2296static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2297 struct device_attribute *attr,
2298 const char *buf, size_t count)
2299{
2300 struct wl1271 *wl = dev_get_drvdata(dev);
2301 unsigned long res;
2302 int ret;
2303
2304 ret = strict_strtoul(buf, 10, &res);
2305
2306 if (ret < 0) {
2307 wl1271_warning("incorrect value written to bt_coex_mode");
2308 return count;
2309 }
2310
2311 mutex_lock(&wl->mutex);
2312
2313 res = !!res;
2314
2315 if (res == wl->sg_enabled)
2316 goto out;
2317
2318 wl->sg_enabled = res;
2319
2320 if (wl->state == WL1271_STATE_OFF)
2321 goto out;
2322
2323 ret = wl1271_ps_elp_wakeup(wl, false);
2324 if (ret < 0)
2325 goto out;
2326
2327 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2328 wl1271_ps_elp_sleep(wl);
2329
2330 out:
2331 mutex_unlock(&wl->mutex);
2332 return count;
2333}
2334
2335static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2336 wl1271_sysfs_show_bt_coex_state,
2337 wl1271_sysfs_store_bt_coex_state);
2338
d717fd61
JO		 2339static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2340 struct device_attribute *attr,
2341 char *buf)
2342{
2343 struct wl1271 *wl = dev_get_drvdata(dev);
2344 ssize_t len;
2345
2f63b011 2346 len = PAGE_SIZE;
d717fd61
JO		 2347
2348 mutex_lock(&wl->mutex);
2349 if (wl->hw_pg_ver >= 0)
2350 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2351 else
2352 len = snprintf(buf, len, "n/a\n");
2353 mutex_unlock(&wl->mutex);
2354
2355 return len;
2356}
2357
2358static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2359 wl1271_sysfs_show_hw_pg_ver, NULL);
2360
2d5e82b8 2361int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 2362{
2363 int ret;
2364
2365 if (wl->mac80211_registered)
2366 return 0;
2367
2368 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2369
2370 ret = ieee80211_register_hw(wl->hw);
2371 if (ret < 0) {
2372 wl1271_error("unable to register mac80211 hw: %d", ret);
2373 return ret;
2374 }
2375
2376 wl->mac80211_registered = true;
2377
c2c192ac
JO		 2378 register_netdevice_notifier(&wl1271_dev_notifier);
2379
f5fc0f86
LC		 2380 wl1271_notice("loaded");
2381
2382 return 0;
2383}
50b3eb4b 2384EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 2385
3b56dd6a
TP		 2386void wl1271_unregister_hw(struct wl1271 *wl)
2387{
c2c192ac 2388 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 2389 ieee80211_unregister_hw(wl->hw);
2390 wl->mac80211_registered = false;
2391
2392}
2393EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2394
2d5e82b8 2395int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 2396{
1e2b7976
JO		 2397 /* The tx descriptor buffer and the TKIP space. */
2398 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2399 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 2400
2401 /* unit us */
2402 /* FIXME: find a proper value */
2403 wl->hw->channel_change_time = 10000;
50c500ad 2404 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 2405
2406 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 2407 IEEE80211_HW_BEACON_FILTER |
0a34332f 2408 IEEE80211_HW_SUPPORTS_PS |
4695dc91 2409 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 2410 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed
JO		 2411 IEEE80211_HW_CONNECTION_MONITOR |
2412 IEEE80211_HW_SUPPORTS_CQM_RSSI;
f5fc0f86 2413
e0d8bbf0
JO		 2414 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2415 BIT(NL80211_IFTYPE_ADHOC);
f5fc0f86
LC		 2416 wl->hw->wiphy->max_scan_ssids = 1;
2417 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
11eb5429 2418 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
1ebec3d7 2419
12bd8949 2420 wl->hw->queues = 4;
31627dc5 2421 wl->hw->max_rates = 1;
12bd8949 2422
8197b711 2423 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 2424
2425 return 0;
2426}
50b3eb4b 2427EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 2428
f5fc0f86 2429#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 2430
2d5e82b8 2431struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 2432{
f5fc0f86 2433 struct ieee80211_hw *hw;
3b56dd6a 2434 struct platform_device *plat_dev = NULL;
f5fc0f86 2435 struct wl1271 *wl;
a1dd8187 2436 int i, ret;
f5fc0f86
LC		 2437
2438 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2439 if (!hw) {
2440 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 2441 ret = -ENOMEM;
3b56dd6a
TP		 2442 goto err_hw_alloc;
2443 }
2444
929ebd30 2445 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3b56dd6a
TP		 2446 if (!plat_dev) {
2447 wl1271_error("could not allocate platform_device");
2448 ret = -ENOMEM;
2449 goto err_plat_alloc;
f5fc0f86
LC		 2450 }
2451
2452 wl = hw->priv;
2453 memset(wl, 0, sizeof(*wl));
2454
01c09162
JO		 2455 INIT_LIST_HEAD(&wl->list);
2456
f5fc0f86 2457 wl->hw = hw;
3b56dd6a 2458 wl->plat_dev = plat_dev;
f5fc0f86
LC		 2459
2460 skb_queue_head_init(&wl->tx_queue);
2461
37b70a81 2462 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
90494a90 2463 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
f5fc0f86 2464 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 2465 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 2466 wl->default_key = 0;
f5fc0f86
LC		 2467 wl->rx_counter = 0;
2468 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2469 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
19ad0715 2470 wl->psm_entry_retry = 0;
f5fc0f86 2471 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 2472 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 2473 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b
JO		 2474 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2475 wl->sta_rate_set = 0;
8a5a37a6 2476 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 2477 wl->vif = NULL;
830fb67b 2478 wl->flags = 0;
7fc3a864 2479 wl->sg_enabled = true;
d717fd61 2480 wl->hw_pg_ver = -1;
f5fc0f86 2481
be7078c2 2482 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 2483 wl->tx_frames[i] = NULL;
2484
2485 spin_lock_init(&wl->wl_lock);
2486
f5fc0f86
LC		 2487 wl->state = WL1271_STATE_OFF;
2488 mutex_init(&wl->mutex);
2489
c332a4b8
TP		 2490 /* Apply default driver configuration. */
2491 wl1271_conf_init(wl);
2492
2d5e82b8
TP		 2493 wl1271_debugfs_init(wl);
2494
a1dd8187 2495 /* Register platform device */
3b56dd6a 2496 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 2497 if (ret) {
2498 wl1271_error("couldn't register platform device");
2499 goto err_hw;
2500 }
3b56dd6a 2501 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 2502
7fc3a864 2503 /* Create sysfs file to control bt coex state */
3b56dd6a 2504 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 2505 if (ret < 0) {
2506 wl1271_error("failed to create sysfs file bt_coex_state");
2507 goto err_platform;
2508 }
a1dd8187 2509
d717fd61
JO		 2510 /* Create sysfs file to get HW PG version */
2511 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2512 if (ret < 0) {
2513 wl1271_error("failed to create sysfs file hw_pg_ver");
2514 goto err_bt_coex_state;
2515 }
2516
c332a4b8 2517 return hw;
a1dd8187 2518
d717fd61
JO		 2519err_bt_coex_state:
2520 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2521
7fc3a864 2522err_platform:
3b56dd6a 2523 platform_device_unregister(wl->plat_dev);
7fc3a864 2524
a1dd8187 2525err_hw:
3b56dd6a
TP		 2526 wl1271_debugfs_exit(wl);
2527 kfree(plat_dev);
2528
2529err_plat_alloc:
2530 ieee80211_free_hw(hw);
2531
2532err_hw_alloc:
a1dd8187 2533
a1dd8187 2534 return ERR_PTR(ret);
c332a4b8 2535}
50b3eb4b 2536EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 2537
2538int wl1271_free_hw(struct wl1271 *wl)
2539{
3b56dd6a
TP		 2540 platform_device_unregister(wl->plat_dev);
2541 kfree(wl->plat_dev);
c332a4b8
TP		 2542
2543 wl1271_debugfs_exit(wl);
2544
c332a4b8
TP		 2545 vfree(wl->fw);
2546 wl->fw = NULL;
2547 kfree(wl->nvs);
2548 wl->nvs = NULL;
2549
2550 kfree(wl->fw_status);
2551 kfree(wl->tx_res_if);
2552
2553 ieee80211_free_hw(wl->hw);
2554
2555 return 0;
2556}
50b3eb4b
TP		 2557EXPORT_SYMBOL_GPL(wl1271_free_hw);
2558
2559MODULE_LICENSE("GPL");
2560MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2561MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux 6.x block layer and io_uring tree(s)