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