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