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