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