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