projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl1271: moved scan operations to a separate file
[GitHub/mt8127/android_kernel_alcatel_ttab.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
71449f8d 945 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
f5fc0f86
LC		 946 mutex_unlock(&wl->mutex);
947 ieee80211_scan_completed(wl->hw, true);
948 mutex_lock(&wl->mutex);
f5fc0f86
LC		 949 }
950
951 wl->state = WL1271_STATE_OFF;
952
953 wl1271_disable_interrupts(wl);
954
955 mutex_unlock(&wl->mutex);
956
957 cancel_work_sync(&wl->irq_work);
958 cancel_work_sync(&wl->tx_work);
90494a90 959 cancel_delayed_work_sync(&wl->pspoll_work);
f5fc0f86
LC		 960
961 mutex_lock(&wl->mutex);
962
963 /* let's notify MAC80211 about the remaining pending TX frames */
781608c4 964 wl1271_tx_reset(wl);
f5fc0f86
LC		 965 wl1271_power_off(wl);
966
967 memset(wl->bssid, 0, ETH_ALEN);
968 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
969 wl->ssid_len = 0;
f5fc0f86 970 wl->bss_type = MAX_BSS_TYPE;
5da11dcd 971 wl->set_bss_type = MAX_BSS_TYPE;
8a5a37a6 972 wl->band = IEEE80211_BAND_2GHZ;
f5fc0f86
LC		 973
974 wl->rx_counter = 0;
19ad0715 975 wl->psm_entry_retry = 0;
f5fc0f86
LC		 976 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
977 wl->tx_blocks_available = 0;
978 wl->tx_results_count = 0;
979 wl->tx_packets_count = 0;
ac4e4ce5 980 wl->tx_security_last_seq = 0;
04e36fc5 981 wl->tx_security_seq = 0;
f5fc0f86
LC		 982 wl->time_offset = 0;
983 wl->session_counter = 0;
830fb67b
JO		 984 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
985 wl->sta_rate_set = 0;
986 wl->flags = 0;
1b72aecd 987 wl->vif = NULL;
14b228a0 988 wl->filters = 0;
d6e19d13 989
f5fc0f86
LC		 990 for (i = 0; i < NUM_TX_QUEUES; i++)
991 wl->tx_blocks_freed[i] = 0;
992
993 wl1271_debugfs_reset(wl);
bd9dc49c
JO		 994
995 kfree(wl->fw_status);
996 wl->fw_status = NULL;
997 kfree(wl->tx_res_if);
998 wl->tx_res_if = NULL;
999 kfree(wl->target_mem_map);
1000 wl->target_mem_map = NULL;
1001
f5fc0f86
LC		 1002 mutex_unlock(&wl->mutex);
1003}
1004
14b228a0
JO		 1005static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1006{
1007 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1008 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1009
1010 /* combine requested filters with current filter config */
1011 filters = wl->filters | filters;
1012
1013 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1014
1015 if (filters & FIF_PROMISC_IN_BSS) {
1016 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1017 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1018 wl->rx_config |= CFG_BSSID_FILTER_EN;
1019 }
1020 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1021 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1022 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1023 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1024 }
1025 if (filters & FIF_OTHER_BSS) {
1026 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1027 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1028 }
1029 if (filters & FIF_CONTROL) {
1030 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1031 wl->rx_filter |= CFG_RX_CTL_EN;
1032 }
1033 if (filters & FIF_FCSFAIL) {
1034 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1035 wl->rx_filter |= CFG_RX_FCS_ERROR;
1036 }
1037}
1038
82429d32 1039static int wl1271_dummy_join(struct wl1271 *wl)
c7f43e45 1040{
e0d8bbf0 1041 int ret = 0;
c7f43e45
LC		 1042 /* we need to use a dummy BSSID for now */
1043 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1044 0xad, 0xbe, 0xef };
1045
c7f43e45
LC		 1046 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1047
14b228a0
JO		 1048 /* pass through frames from all BSS */
1049 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1050
5da11dcd 1051 ret = wl1271_cmd_join(wl, wl->set_bss_type);
c7f43e45
LC		 1052 if (ret < 0)
1053 goto out;
1054
71449f8d 1055 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1056
1057out:
1058 return ret;
1059}
1060
69e5434c 1061static int wl1271_join(struct wl1271 *wl, bool set_assoc)
82429d32
JO		 1062{
1063 int ret;
1064
69e5434c
JO		 1065 /*
1066 * One of the side effects of the JOIN command is that is clears
1067 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1068 * to a WPA/WPA2 access point will therefore kill the data-path.
1069 * Currently there is no supported scenario for JOIN during
1070 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1071 * must be handled somehow.
1072 *
1073 */
1074 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1075 wl1271_info("JOIN while associated.");
1076
1077 if (set_assoc)
1078 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1079
82429d32
JO		 1080 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1081 if (ret < 0)
1082 goto out;
1083
1084 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1085
1086 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1087 goto out;
1088
1089 /*
1090 * The join command disable the keep-alive mode, shut down its process,
1091 * and also clear the template config, so we need to reset it all after
1092 * the join. The acx_aid starts the keep-alive process, and the order
1093 * of the commands below is relevant.
1094 */
1095 ret = wl1271_acx_keep_alive_mode(wl, true);
1096 if (ret < 0)
1097 goto out;
1098
1099 ret = wl1271_acx_aid(wl, wl->aid);
1100 if (ret < 0)
1101 goto out;
1102
1103 ret = wl1271_cmd_build_klv_null_data(wl);
1104 if (ret < 0)
1105 goto out;
1106
1107 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1108 ACX_KEEP_ALIVE_TPL_VALID);
1109 if (ret < 0)
1110 goto out;
1111
1112out:
1113 return ret;
1114}
1115
1116static int wl1271_unjoin(struct wl1271 *wl)
c7f43e45
LC		 1117{
1118 int ret;
1119
1120 /* to stop listening to a channel, we disconnect */
1121 ret = wl1271_cmd_disconnect(wl);
1122 if (ret < 0)
1123 goto out;
1124
71449f8d 1125 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45 1126 memset(wl->bssid, 0, ETH_ALEN);
14b228a0
JO		 1127
1128 /* stop filterting packets based on bssid */
1129 wl1271_configure_filters(wl, FIF_OTHER_BSS);
c7f43e45
LC		 1130
1131out:
1132 return ret;
1133}
1134
ebba60c6
JO		 1135static void wl1271_set_band_rate(struct wl1271 *wl)
1136{
1137 if (wl->band == IEEE80211_BAND_2GHZ)
1138 wl->basic_rate_set = wl->conf.tx.basic_rate;
1139 else
1140 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1141}
1142
1143static u32 wl1271_min_rate_get(struct wl1271 *wl)
1144{
1145 int i;
1146 u32 rate = 0;
1147
1148 if (!wl->basic_rate_set) {
1149 WARN_ON(1);
1150 wl->basic_rate_set = wl->conf.tx.basic_rate;
1151 }
1152
1153 for (i = 0; !rate; i++) {
1154 if ((wl->basic_rate_set >> i) & 0x1)
1155 rate = 1 << i;
1156 }
1157
1158 return rate;
1159}
1160
0d58cbff
JO		 1161static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1162{
1163 int ret;
1164
1165 if (idle) {
1166 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1167 ret = wl1271_unjoin(wl);
1168 if (ret < 0)
1169 goto out;
1170 }
1171 wl->rate_set = wl1271_min_rate_get(wl);
1172 wl->sta_rate_set = 0;
1173 ret = wl1271_acx_rate_policies(wl);
1174 if (ret < 0)
1175 goto out;
1176 ret = wl1271_acx_keep_alive_config(
1177 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1178 ACX_KEEP_ALIVE_TPL_INVALID);
1179 if (ret < 0)
1180 goto out;
1181 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1182 } else {
1183 /* increment the session counter */
1184 wl->session_counter++;
1185 if (wl->session_counter >= SESSION_COUNTER_MAX)
1186 wl->session_counter = 0;
1187 ret = wl1271_dummy_join(wl);
1188 if (ret < 0)
1189 goto out;
1190 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1191 }
1192
1193out:
1194 return ret;
1195}
1196
f5fc0f86
LC		 1197static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1198{
1199 struct wl1271 *wl = hw->priv;
1200 struct ieee80211_conf *conf = &hw->conf;
1201 int channel, ret = 0;
1202
1203 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1204
c7f43e45 1205 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
f5fc0f86
LC		 1206 channel,
1207 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45
LC		 1208 conf->power_level,
1209 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
f5fc0f86 1210
781608c4
JO		 1211 /*
1212 * mac80211 will go to idle nearly immediately after transmitting some
1213 * frames, such as the deauth. To make sure those frames reach the air,
1214 * wait here until the TX queue is fully flushed.
1215 */
1216 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1217 (conf->flags & IEEE80211_CONF_IDLE))
1218 wl1271_tx_flush(wl);
1219
f5fc0f86
LC		 1220 mutex_lock(&wl->mutex);
1221
2c10bb9c
SD		 1222 if (unlikely(wl->state == WL1271_STATE_OFF))
1223 goto out;
8a5a37a6 1224
f5fc0f86
LC		 1225 ret = wl1271_ps_elp_wakeup(wl, false);
1226 if (ret < 0)
1227 goto out;
1228
ebba60c6 1229 /* if the channel changes while joined, join again */
69e5434c
JO		 1230 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1231 ((wl->band != conf->channel->band) ||
1232 (wl->channel != channel))) {
ebba60c6
JO		 1233 wl->band = conf->channel->band;
1234 wl->channel = channel;
1235
1236 /*
1237 * FIXME: the mac80211 should really provide a fixed rate
1238 * to use here. for now, just use the smallest possible rate
1239 * for the band as a fixed rate for association frames and
1240 * other control messages.
1241 */
1242 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1243 wl1271_set_band_rate(wl);
1244
1245 wl->basic_rate = wl1271_min_rate_get(wl);
1246 ret = wl1271_acx_rate_policies(wl);
1247 if (ret < 0)
1248 wl1271_warning("rate policy for update channel "
1249 "failed %d", ret);
1250
1251 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
69e5434c 1252 ret = wl1271_join(wl, false);
ebba60c6
JO		 1253 if (ret < 0)
1254 wl1271_warning("cmd join to update channel "
1255 "failed %d", ret);
1256 }
1257 }
1258
c7f43e45 1259 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
0d58cbff
JO		 1260 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1261 if (ret < 0)
1262 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 1263 }
1264
90494a90
JO		 1265 /*
1266 * if mac80211 changes the PSM mode, make sure the mode is not
1267 * incorrectly changed after the pspoll failure active window.
1268 */
1269 if (changed & IEEE80211_CONF_CHANGE_PS)
1270 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1271
71449f8d
JO		 1272 if (conf->flags & IEEE80211_CONF_PS &&
1273 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1274 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 1275
1276 /*
1277 * We enter PSM only if we're already associated.
1278 * If we're not, we'll enter it when joining an SSID,
1279 * through the bss_info_changed() hook.
1280 */
830fb67b 1281 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 1282 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c
JO		 1283 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1284 true);
af5e084b 1285 }
f5fc0f86 1286 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 1287 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 1288 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 1289
71449f8d 1290 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 1291
71449f8d 1292 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c
JO		 1293 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1294 true);
f5fc0f86
LC		 1295 }
1296
1297 if (conf->power_level != wl->power_level) {
1298 ret = wl1271_acx_tx_power(wl, conf->power_level);
1299 if (ret < 0)
c6317a54 1300 goto out_sleep;
f5fc0f86
LC		 1301
1302 wl->power_level = conf->power_level;
1303 }
1304
1305out_sleep:
1306 wl1271_ps_elp_sleep(wl);
1307
1308out:
1309 mutex_unlock(&wl->mutex);
1310
1311 return ret;
1312}
1313
b54853f1
JO		 1314struct wl1271_filter_params {
1315 bool enabled;
1316 int mc_list_length;
1317 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1318};
1319
22bedad3
JP		 1320static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1321 struct netdev_hw_addr_list *mc_list)
c87dec9f 1322{
c87dec9f 1323 struct wl1271_filter_params *fp;
22bedad3 1324 struct netdev_hw_addr *ha;
2c10bb9c 1325 struct wl1271 *wl = hw->priv;
c87dec9f 1326
2c10bb9c
SD		 1327 if (unlikely(wl->state == WL1271_STATE_OFF))
1328 return 0;
c87dec9f 1329
74441130 1330 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 1331 if (!fp) {
1332 wl1271_error("Out of memory setting filters.");
1333 return 0;
1334 }
1335
1336 /* update multicast filtering parameters */
c87dec9f 1337 fp->mc_list_length = 0;
22bedad3
JP		 1338 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1339 fp->enabled = false;
1340 } else {
1341 fp->enabled = true;
1342 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 1343 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 1344 ha->addr, ETH_ALEN);
c87dec9f 1345 fp->mc_list_length++;
22bedad3 1346 }
c87dec9f
JO		 1347 }
1348
b54853f1 1349 return (u64)(unsigned long)fp;
c87dec9f 1350}
f5fc0f86 1351
b54853f1
JO		 1352#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1353 FIF_ALLMULTI | \
1354 FIF_FCSFAIL | \
1355 FIF_BCN_PRBRESP_PROMISC | \
1356 FIF_CONTROL | \
1357 FIF_OTHER_BSS)
1358
f5fc0f86
LC		 1359static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1360 unsigned int changed,
c87dec9f 1361 unsigned int *total, u64 multicast)
f5fc0f86 1362{
b54853f1 1363 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 1364 struct wl1271 *wl = hw->priv;
b54853f1 1365 int ret;
f5fc0f86
LC		 1366
1367 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1368
b54853f1
JO		 1369 mutex_lock(&wl->mutex);
1370
2c10bb9c
SD		 1371 *total &= WL1271_SUPPORTED_FILTERS;
1372 changed &= WL1271_SUPPORTED_FILTERS;
1373
1374 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 1375 goto out;
1376
1377 ret = wl1271_ps_elp_wakeup(wl, false);
1378 if (ret < 0)
1379 goto out;
1380
f5fc0f86 1381
b54853f1
JO		 1382 if (*total & FIF_ALLMULTI)
1383 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1384 else if (fp)
1385 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1386 fp->mc_list,
1387 fp->mc_list_length);
1388 if (ret < 0)
1389 goto out_sleep;
f5fc0f86 1390
b54853f1
JO		 1391 /* determine, whether supported filter values have changed */
1392 if (changed == 0)
1393 goto out_sleep;
c87dec9f 1394
14b228a0
JO		 1395 /* configure filters */
1396 wl->filters = *total;
1397 wl1271_configure_filters(wl, 0);
1398
b54853f1
JO		 1399 /* apply configured filters */
1400 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1401 if (ret < 0)
1402 goto out_sleep;
1403
1404out_sleep:
1405 wl1271_ps_elp_sleep(wl);
1406
1407out:
1408 mutex_unlock(&wl->mutex);
14b228a0 1409 kfree(fp);
f5fc0f86
LC		 1410}
1411
1412static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1413 struct ieee80211_vif *vif,
1414 struct ieee80211_sta *sta,
1415 struct ieee80211_key_conf *key_conf)
1416{
1417 struct wl1271 *wl = hw->priv;
1418 const u8 *addr;
1419 int ret;
ac4e4ce5
JO		 1420 u32 tx_seq_32 = 0;
1421 u16 tx_seq_16 = 0;
f5fc0f86
LC		 1422 u8 key_type;
1423
1424 static const u8 bcast_addr[ETH_ALEN] =
1425 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1426
1427 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1428
1429 addr = sta ? sta->addr : bcast_addr;
1430
1431 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1432 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1433 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1434 key_conf->alg, key_conf->keyidx,
1435 key_conf->keylen, key_conf->flags);
1436 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1437
1438 if (is_zero_ether_addr(addr)) {
1439 /* We dont support TX only encryption */
1440 ret = -EOPNOTSUPP;
1441 goto out;
1442 }
1443
1444 mutex_lock(&wl->mutex);
1445
1446 ret = wl1271_ps_elp_wakeup(wl, false);
1447 if (ret < 0)
1448 goto out_unlock;
1449
1450 switch (key_conf->alg) {
1451 case ALG_WEP:
1452 key_type = KEY_WEP;
1453
1454 key_conf->hw_key_idx = key_conf->keyidx;
1455 break;
1456 case ALG_TKIP:
1457 key_type = KEY_TKIP;
1458
1459 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 1460 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1461 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86
LC		 1462 break;
1463 case ALG_CCMP:
1464 key_type = KEY_AES;
1465
1466 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
04e36fc5
JO		 1467 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1468 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86
LC		 1469 break;
1470 default:
1471 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1472
1473 ret = -EOPNOTSUPP;
1474 goto out_sleep;
1475 }
1476
1477 switch (cmd) {
1478 case SET_KEY:
1479 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1480 key_conf->keyidx, key_type,
1481 key_conf->keylen, key_conf->key,
ac4e4ce5 1482 addr, tx_seq_32, tx_seq_16);
f5fc0f86
LC		 1483 if (ret < 0) {
1484 wl1271_error("Could not add or replace key");
1485 goto out_sleep;
1486 }
ee444cf0
JO		 1487
1488 /* the default WEP key needs to be configured at least once */
1489 if (key_type == KEY_WEP) {
1490 ret = wl1271_cmd_set_default_wep_key(wl,
1491 wl->default_key);
1492 if (ret < 0)
1493 goto out_sleep;
1494 }
f5fc0f86
LC		 1495 break;
1496
1497 case DISABLE_KEY:
fddc7dd7
JO		 1498 /* The wl1271 does not allow to remove unicast keys - they
1499 will be cleared automatically on next CMD_JOIN. Ignore the
1500 request silently, as we dont want the mac80211 to emit
1501 an error message. */
1502 if (!is_broadcast_ether_addr(addr))
1503 break;
1504
f5fc0f86
LC		 1505 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1506 key_conf->keyidx, key_type,
1507 key_conf->keylen, key_conf->key,
ac4e4ce5 1508 addr, 0, 0);
f5fc0f86
LC		 1509 if (ret < 0) {
1510 wl1271_error("Could not remove key");
1511 goto out_sleep;
1512 }
1513 break;
1514
1515 default:
1516 wl1271_error("Unsupported key cmd 0x%x", cmd);
1517 ret = -EOPNOTSUPP;
f5fc0f86
LC		 1518 break;
1519 }
1520
1521out_sleep:
1522 wl1271_ps_elp_sleep(wl);
1523
1524out_unlock:
1525 mutex_unlock(&wl->mutex);
1526
1527out:
1528 return ret;
1529}
1530
1531static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 1532 struct ieee80211_vif *vif,
f5fc0f86
LC		 1533 struct cfg80211_scan_request *req)
1534{
1535 struct wl1271 *wl = hw->priv;
1536 int ret;
1537 u8 *ssid = NULL;
abb0b3bf 1538 size_t len = 0;
f5fc0f86
LC		 1539
1540 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1541
1542 if (req->n_ssids) {
1543 ssid = req->ssids[0].ssid;
abb0b3bf 1544 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 1545 }
1546
1547 mutex_lock(&wl->mutex);
1548
1549 ret = wl1271_ps_elp_wakeup(wl, false);
1550 if (ret < 0)
1551 goto out;
1552
abb0b3bf 1553 if (wl1271_11a_enabled())
34dd2aaa
LC		 1554 ret = wl1271_scan(hw->priv, ssid, len, req,
1555 1, 0, WL1271_SCAN_BAND_DUAL, 3);
abb0b3bf 1556 else
34dd2aaa
LC		 1557 ret = wl1271_scan(hw->priv, ssid, len, req,
1558 1, 0, WL1271_SCAN_BAND_2_4_GHZ, 3);
f5fc0f86
LC		 1559
1560 wl1271_ps_elp_sleep(wl);
1561
1562out:
1563 mutex_unlock(&wl->mutex);
1564
1565 return ret;
1566}
1567
1568static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1569{
1570 struct wl1271 *wl = hw->priv;
aecb0565 1571 int ret = 0;
f5fc0f86
LC		 1572
1573 mutex_lock(&wl->mutex);
1574
aecb0565
SD		 1575 if (unlikely(wl->state == WL1271_STATE_OFF))
1576 goto out;
1577
f5fc0f86
LC		 1578 ret = wl1271_ps_elp_wakeup(wl, false);
1579 if (ret < 0)
1580 goto out;
1581
1582 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1583 if (ret < 0)
1584 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1585
1586 wl1271_ps_elp_sleep(wl);
1587
1588out:
1589 mutex_unlock(&wl->mutex);
1590
1591 return ret;
1592}
1593
30240fc7
JO		 1594static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1595{
1596 u8 *ptr = beacon->data +
1597 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1598
1599 /* find the location of the ssid in the beacon */
1600 while (ptr < beacon->data + beacon->len) {
1601 if (ptr[0] == WLAN_EID_SSID) {
1602 wl->ssid_len = ptr[1];
1603 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1604 return;
1605 }
1606 ptr += ptr[1];
1607 }
1608 wl1271_error("ad-hoc beacon template has no SSID!\n");
1609}
1610
f5fc0f86
LC		 1611static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1612 struct ieee80211_vif *vif,
1613 struct ieee80211_bss_conf *bss_conf,
1614 u32 changed)
1615{
1616 enum wl1271_cmd_ps_mode mode;
1617 struct wl1271 *wl = hw->priv;
8bf29b0e 1618 bool do_join = false;
69e5434c 1619 bool set_assoc = false;
f5fc0f86
LC		 1620 int ret;
1621
1622 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1623
1624 mutex_lock(&wl->mutex);
1625
1626 ret = wl1271_ps_elp_wakeup(wl, false);
1627 if (ret < 0)
1628 goto out;
1629
60e84c2e
JO		 1630 if ((changed && BSS_CHANGED_BEACON_INT) &&
1631 (wl->bss_type == BSS_TYPE_IBSS)) {
1632 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1633 bss_conf->beacon_int);
1634
1635 wl->beacon_int = bss_conf->beacon_int;
1636 do_join = true;
1637 }
1638
5da11dcd
JO		 1639 if ((changed && BSS_CHANGED_BEACON) &&
1640 (wl->bss_type == BSS_TYPE_IBSS)) {
e0d8bbf0
JO		 1641 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1642
5da11dcd
JO		 1643 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1644
e0d8bbf0
JO		 1645 if (beacon) {
1646 struct ieee80211_hdr *hdr;
30240fc7
JO		 1647
1648 wl1271_ssid_set(wl, beacon);
e0d8bbf0
JO		 1649 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1650 beacon->data,
606c1487
JO		 1651 beacon->len, 0,
1652 wl1271_min_rate_get(wl));
e0d8bbf0
JO		 1653
1654 if (ret < 0) {
1655 dev_kfree_skb(beacon);
1656 goto out_sleep;
1657 }
1658
1659 hdr = (struct ieee80211_hdr *) beacon->data;
1660 hdr->frame_control = cpu_to_le16(
1661 IEEE80211_FTYPE_MGMT |
1662 IEEE80211_STYPE_PROBE_RESP);
1663
1664 ret = wl1271_cmd_template_set(wl,
1665 CMD_TEMPL_PROBE_RESPONSE,
1666 beacon->data,
606c1487
JO		 1667 beacon->len, 0,
1668 wl1271_min_rate_get(wl));
e0d8bbf0
JO		 1669 dev_kfree_skb(beacon);
1670 if (ret < 0)
1671 goto out_sleep;
8bf29b0e
JO		 1672
1673 /* Need to update the SSID (for filtering etc) */
1674 do_join = true;
e0d8bbf0
JO		 1675 }
1676 }
1677
5da11dcd
JO		 1678 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1679 (wl->bss_type == BSS_TYPE_IBSS)) {
1680 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1681 bss_conf->enable_beacon ? "enabled" : "disabled");
1682
1683 if (bss_conf->enable_beacon)
1684 wl->set_bss_type = BSS_TYPE_IBSS;
1685 else
1686 wl->set_bss_type = BSS_TYPE_STA_BSS;
1687 do_join = true;
1688 }
1689
00236aed
JO		 1690 if (changed & BSS_CHANGED_CQM) {
1691 bool enable = false;
1692 if (bss_conf->cqm_rssi_thold)
1693 enable = true;
1694 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1695 bss_conf->cqm_rssi_thold,
1696 bss_conf->cqm_rssi_hyst);
1697 if (ret < 0)
1698 goto out;
1699 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1700 }
1701
30240fc7
JO		 1702 if ((changed & BSS_CHANGED_BSSID) &&
1703 /*
1704 * Now we know the correct bssid, so we send a new join command
1705 * and enable the BSSID filter
1706 */
1707 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
30240fc7 1708 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 1709
30240fc7 1710 ret = wl1271_cmd_build_null_data(wl);
a0cb7be4 1711 if (ret < 0)
30240fc7 1712 goto out_sleep;
30240fc7 1713
141418c7 1714 ret = wl1271_build_qos_null_data(wl);
a0cb7be4 1715 if (ret < 0)
30240fc7 1716 goto out_sleep;
30240fc7 1717
14b228a0
JO		 1718 /* filter out all packets not from this BSSID */
1719 wl1271_configure_filters(wl, 0);
1720
8bf29b0e
JO		 1721 /* Need to update the BSSID (for filtering etc) */
1722 do_join = true;
30240fc7
JO		 1723 }
1724
f5fc0f86
LC		 1725 if (changed & BSS_CHANGED_ASSOC) {
1726 if (bss_conf->assoc) {
ebba60c6 1727 u32 rates;
f5fc0f86 1728 wl->aid = bss_conf->aid;
69e5434c 1729 set_assoc = true;
f5fc0f86 1730
90494a90
JO		 1731 wl->ps_poll_failures = 0;
1732
ebba60c6
JO		 1733 /*
1734 * use basic rates from AP, and determine lowest rate
1735 * to use with control frames.
1736 */
1737 rates = bss_conf->basic_rates;
1738 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1739 rates);
1740 wl->basic_rate = wl1271_min_rate_get(wl);
1741 ret = wl1271_acx_rate_policies(wl);
1742 if (ret < 0)
1743 goto out_sleep;
1744
ae751bab
LC		 1745 /*
1746 * with wl1271, we don't need to update the
1747 * beacon_int and dtim_period, because the firmware
1748 * updates it by itself when the first beacon is
1749 * received after a join.
1750 */
f5fc0f86
LC		 1751 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1752 if (ret < 0)
1753 goto out_sleep;
1754
c2b2d99b
JO		 1755 /*
1756 * The SSID is intentionally set to NULL here - the
1757 * firmware will set the probe request with a
1758 * broadcast SSID regardless of what we set in the
1759 * template.
1760 */
1761 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1762 NULL, 0, wl->band);
1763
6ccbb92e
JO		 1764 /* enable the connection monitoring feature */
1765 ret = wl1271_acx_conn_monit_params(wl, true);
f5fc0f86
LC		 1766 if (ret < 0)
1767 goto out_sleep;
1768
1769 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 1770 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1771 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
f5fc0f86 1772 mode = STATION_POWER_SAVE_MODE;
d8c42c0c 1773 ret = wl1271_ps_set_mode(wl, mode, true);
f5fc0f86
LC		 1774 if (ret < 0)
1775 goto out_sleep;
1776 }
d94cd297
JO		 1777 } else {
1778 /* use defaults when not associated */
830fb67b 1779 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
d94cd297 1780 wl->aid = 0;
6ccbb92e 1781
8d2ef7bd 1782 /* re-enable dynamic ps - just in case */
f532be6d 1783 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 1784
ebba60c6
JO		 1785 /* revert back to minimum rates for the current band */
1786 wl1271_set_band_rate(wl);
1787 wl->basic_rate = wl1271_min_rate_get(wl);
1788 ret = wl1271_acx_rate_policies(wl);
1789 if (ret < 0)
1790 goto out_sleep;
1791
6ccbb92e
JO		 1792 /* disable connection monitor features */
1793 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 1794
1795 /* Disable the keep-alive feature */
1796 ret = wl1271_acx_keep_alive_mode(wl, false);
1797
6ccbb92e
JO		 1798 if (ret < 0)
1799 goto out_sleep;
f5fc0f86 1800 }
d94cd297 1801
f5fc0f86 1802 }
8a5a37a6 1803
f5fc0f86
LC		 1804 if (changed & BSS_CHANGED_ERP_SLOT) {
1805 if (bss_conf->use_short_slot)
1806 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1807 else
1808 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1809 if (ret < 0) {
1810 wl1271_warning("Set slot time failed %d", ret);
1811 goto out_sleep;
1812 }
1813 }
1814
1815 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1816 if (bss_conf->use_short_preamble)
1817 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1818 else
1819 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1820 }
1821
1822 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1823 if (bss_conf->use_cts_prot)
1824 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1825 else
1826 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1827 if (ret < 0) {
1828 wl1271_warning("Set ctsprotect failed %d", ret);
1829 goto out_sleep;
1830 }
1831 }
1832
ca52a5eb
JO		 1833 if (changed & BSS_CHANGED_ARP_FILTER) {
1834 __be32 addr = bss_conf->arp_addr_list[0];
1835 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1836
1837 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1838 ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1839 else
1840 ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1841
1842 if (ret < 0)
1843 goto out_sleep;
1844 }
1845
8bf29b0e 1846 if (do_join) {
69e5434c 1847 ret = wl1271_join(wl, set_assoc);
8bf29b0e
JO		 1848 if (ret < 0) {
1849 wl1271_warning("cmd join failed %d", ret);
1850 goto out_sleep;
1851 }
c1899554
JO		 1852 }
1853
f5fc0f86
LC		 1854out_sleep:
1855 wl1271_ps_elp_sleep(wl);
1856
1857out:
1858 mutex_unlock(&wl->mutex);
1859}
1860
c6999d83
KV		 1861static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1862 const struct ieee80211_tx_queue_params *params)
1863{
1864 struct wl1271 *wl = hw->priv;
4695dc91 1865 u8 ps_scheme;
c6999d83
KV		 1866 int ret;
1867
1868 mutex_lock(&wl->mutex);
1869
1870 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1871
c82c1dde
KV		 1872 ret = wl1271_ps_elp_wakeup(wl, false);
1873 if (ret < 0)
1874 goto out;
1875
b43316db 1876 /* the txop is confed in units of 32us by the mac80211, we need us */
c6999d83
KV		 1877 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1878 params->cw_min, params->cw_max,
b43316db 1879 params->aifs, params->txop << 5);
c6999d83 1880 if (ret < 0)
c82c1dde 1881 goto out_sleep;
c6999d83 1882
4695dc91
KV		 1883 if (params->uapsd)
1884 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1885 else
1886 ps_scheme = CONF_PS_SCHEME_LEGACY;
1887
c6999d83
KV		 1888 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1889 CONF_CHANNEL_TYPE_EDCF,
1890 wl1271_tx_get_queue(queue),
4695dc91 1891 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
c6999d83 1892 if (ret < 0)
c82c1dde
KV		 1893 goto out_sleep;
1894
1895out_sleep:
1896 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 1897
1898out:
1899 mutex_unlock(&wl->mutex);
1900
1901 return ret;
1902}
1903
bbbb538e
JO		 1904static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1905{
1906
1907 struct wl1271 *wl = hw->priv;
1908 u64 mactime = ULLONG_MAX;
1909 int ret;
1910
1911 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1912
1913 mutex_lock(&wl->mutex);
1914
1915 ret = wl1271_ps_elp_wakeup(wl, false);
1916 if (ret < 0)
1917 goto out;
1918
1919 ret = wl1271_acx_tsf_info(wl, &mactime);
1920 if (ret < 0)
1921 goto out_sleep;
1922
1923out_sleep:
1924 wl1271_ps_elp_sleep(wl);
1925
1926out:
1927 mutex_unlock(&wl->mutex);
1928 return mactime;
1929}
f5fc0f86
LC		 1930
1931/* can't be const, mac80211 writes to this */
1932static struct ieee80211_rate wl1271_rates[] = {
1933 { .bitrate = 10,
2b60100b
JO		 1934 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1935 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 1936 { .bitrate = 20,
2b60100b
JO		 1937 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1938 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 1939 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1940 { .bitrate = 55,
2b60100b
JO		 1941 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1942 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 1943 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1944 { .bitrate = 110,
2b60100b
JO		 1945 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1946 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 1947 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1948 { .bitrate = 60,
2b60100b
JO		 1949 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1950 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 1951 { .bitrate = 90,
2b60100b
JO		 1952 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1953 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 1954 { .bitrate = 120,
2b60100b
JO		 1955 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1956 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 1957 { .bitrate = 180,
2b60100b
JO		 1958 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1959 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 1960 { .bitrate = 240,
2b60100b
JO		 1961 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1962 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 1963 { .bitrate = 360,
2b60100b
JO		 1964 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1965 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 1966 { .bitrate = 480,
2b60100b
JO		 1967 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1968 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 1969 { .bitrate = 540,
2b60100b
JO		 1970 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1971 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 1972};
1973
1974/* can't be const, mac80211 writes to this */
1975static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1
LC		 1976 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1977 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1978 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1979 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1980 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1981 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1982 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1983 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1984 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1985 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1986 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1987 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1988 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
f5fc0f86
LC		 1989};
1990
f876bb9a 1991/* mapping to indexes for wl1271_rates */
a0ea9493 1992static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a
JO		 1993 /* MCS rates are used only with 11n */
1994 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
1995 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
1996 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
1997 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
1998 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
1999 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2000 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2001 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2002
2003 11, /* CONF_HW_RXTX_RATE_54 */
2004 10, /* CONF_HW_RXTX_RATE_48 */
2005 9, /* CONF_HW_RXTX_RATE_36 */
2006 8, /* CONF_HW_RXTX_RATE_24 */
2007
2008 /* TI-specific rate */
2009 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2010
2011 7, /* CONF_HW_RXTX_RATE_18 */
2012 6, /* CONF_HW_RXTX_RATE_12 */
2013 3, /* CONF_HW_RXTX_RATE_11 */
2014 5, /* CONF_HW_RXTX_RATE_9 */
2015 4, /* CONF_HW_RXTX_RATE_6 */
2016 2, /* CONF_HW_RXTX_RATE_5_5 */
2017 1, /* CONF_HW_RXTX_RATE_2 */
2018 0 /* CONF_HW_RXTX_RATE_1 */
2019};
2020
f5fc0f86
LC		 2021/* can't be const, mac80211 writes to this */
2022static struct ieee80211_supported_band wl1271_band_2ghz = {
2023 .channels = wl1271_channels,
2024 .n_channels = ARRAY_SIZE(wl1271_channels),
2025 .bitrates = wl1271_rates,
2026 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2027};
2028
1ebec3d7
TP		 2029/* 5 GHz data rates for WL1273 */
2030static struct ieee80211_rate wl1271_rates_5ghz[] = {
2031 { .bitrate = 60,
2032 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2033 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2034 { .bitrate = 90,
2035 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2036 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2037 { .bitrate = 120,
2038 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2039 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2040 { .bitrate = 180,
2041 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2042 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2043 { .bitrate = 240,
2044 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2045 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2046 { .bitrate = 360,
2047 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2048 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2049 { .bitrate = 480,
2050 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2051 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2052 { .bitrate = 540,
2053 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2054 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2055};
2056
2057/* 5 GHz band channels for WL1273 */
2058static struct ieee80211_channel wl1271_channels_5ghz[] = {
2059 { .hw_value = 183, .center_freq = 4915},
2060 { .hw_value = 184, .center_freq = 4920},
2061 { .hw_value = 185, .center_freq = 4925},
2062 { .hw_value = 187, .center_freq = 4935},
2063 { .hw_value = 188, .center_freq = 4940},
2064 { .hw_value = 189, .center_freq = 4945},
2065 { .hw_value = 192, .center_freq = 4960},
2066 { .hw_value = 196, .center_freq = 4980},
2067 { .hw_value = 7, .center_freq = 5035},
2068 { .hw_value = 8, .center_freq = 5040},
2069 { .hw_value = 9, .center_freq = 5045},
2070 { .hw_value = 11, .center_freq = 5055},
2071 { .hw_value = 12, .center_freq = 5060},
2072 { .hw_value = 16, .center_freq = 5080},
2073 { .hw_value = 34, .center_freq = 5170},
2074 { .hw_value = 36, .center_freq = 5180},
2075 { .hw_value = 38, .center_freq = 5190},
2076 { .hw_value = 40, .center_freq = 5200},
2077 { .hw_value = 42, .center_freq = 5210},
2078 { .hw_value = 44, .center_freq = 5220},
2079 { .hw_value = 46, .center_freq = 5230},
2080 { .hw_value = 48, .center_freq = 5240},
2081 { .hw_value = 52, .center_freq = 5260},
2082 { .hw_value = 56, .center_freq = 5280},
2083 { .hw_value = 60, .center_freq = 5300},
2084 { .hw_value = 64, .center_freq = 5320},
2085 { .hw_value = 100, .center_freq = 5500},
2086 { .hw_value = 104, .center_freq = 5520},
2087 { .hw_value = 108, .center_freq = 5540},
2088 { .hw_value = 112, .center_freq = 5560},
2089 { .hw_value = 116, .center_freq = 5580},
2090 { .hw_value = 120, .center_freq = 5600},
2091 { .hw_value = 124, .center_freq = 5620},
2092 { .hw_value = 128, .center_freq = 5640},
2093 { .hw_value = 132, .center_freq = 5660},
2094 { .hw_value = 136, .center_freq = 5680},
2095 { .hw_value = 140, .center_freq = 5700},
2096 { .hw_value = 149, .center_freq = 5745},
2097 { .hw_value = 153, .center_freq = 5765},
2098 { .hw_value = 157, .center_freq = 5785},
2099 { .hw_value = 161, .center_freq = 5805},
2100 { .hw_value = 165, .center_freq = 5825},
2101};
2102
f876bb9a 2103/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 2104static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a
JO		 2105 /* MCS rates are used only with 11n */
2106 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2107 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2108 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2109 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2110 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2111 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2112 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2113 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2114
2115 7, /* CONF_HW_RXTX_RATE_54 */
2116 6, /* CONF_HW_RXTX_RATE_48 */
2117 5, /* CONF_HW_RXTX_RATE_36 */
2118 4, /* CONF_HW_RXTX_RATE_24 */
2119
2120 /* TI-specific rate */
2121 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2122
2123 3, /* CONF_HW_RXTX_RATE_18 */
2124 2, /* CONF_HW_RXTX_RATE_12 */
2125 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2126 1, /* CONF_HW_RXTX_RATE_9 */
2127 0, /* CONF_HW_RXTX_RATE_6 */
2128 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2129 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2130 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2131};
1ebec3d7
TP		 2132
2133static struct ieee80211_supported_band wl1271_band_5ghz = {
2134 .channels = wl1271_channels_5ghz,
2135 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2136 .bitrates = wl1271_rates_5ghz,
2137 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2138};
2139
a0ea9493 2140static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 2141 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2142 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2143};
2144
f5fc0f86
LC		 2145static const struct ieee80211_ops wl1271_ops = {
2146 .start = wl1271_op_start,
2147 .stop = wl1271_op_stop,
2148 .add_interface = wl1271_op_add_interface,
2149 .remove_interface = wl1271_op_remove_interface,
2150 .config = wl1271_op_config,
c87dec9f 2151 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 2152 .configure_filter = wl1271_op_configure_filter,
2153 .tx = wl1271_op_tx,
2154 .set_key = wl1271_op_set_key,
2155 .hw_scan = wl1271_op_hw_scan,
2156 .bss_info_changed = wl1271_op_bss_info_changed,
2157 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 2158 .conf_tx = wl1271_op_conf_tx,
bbbb538e 2159 .get_tsf = wl1271_op_get_tsf,
c8c90873 2160 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 2161};
2162
f876bb9a
JO		 2163
2164u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2165{
2166 u8 idx;
2167
2168 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2169
2170 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2171 wl1271_error("Illegal RX rate from HW: %d", rate);
2172 return 0;
2173 }
2174
2175 idx = wl1271_band_rate_to_idx[wl->band][rate];
2176 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2177 wl1271_error("Unsupported RX rate from HW: %d", rate);
2178 return 0;
2179 }
2180
2181 return idx;
2182}
2183
7fc3a864
JO		 2184static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2185 struct device_attribute *attr,
2186 char *buf)
2187{
2188 struct wl1271 *wl = dev_get_drvdata(dev);
2189 ssize_t len;
2190
2191 /* FIXME: what's the maximum length of buf? page size?*/
2192 len = 500;
2193
2194 mutex_lock(&wl->mutex);
2195 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2196 wl->sg_enabled);
2197 mutex_unlock(&wl->mutex);
2198
2199 return len;
2200
2201}
2202
2203static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2204 struct device_attribute *attr,
2205 const char *buf, size_t count)
2206{
2207 struct wl1271 *wl = dev_get_drvdata(dev);
2208 unsigned long res;
2209 int ret;
2210
2211 ret = strict_strtoul(buf, 10, &res);
2212
2213 if (ret < 0) {
2214 wl1271_warning("incorrect value written to bt_coex_mode");
2215 return count;
2216 }
2217
2218 mutex_lock(&wl->mutex);
2219
2220 res = !!res;
2221
2222 if (res == wl->sg_enabled)
2223 goto out;
2224
2225 wl->sg_enabled = res;
2226
2227 if (wl->state == WL1271_STATE_OFF)
2228 goto out;
2229
2230 ret = wl1271_ps_elp_wakeup(wl, false);
2231 if (ret < 0)
2232 goto out;
2233
2234 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2235 wl1271_ps_elp_sleep(wl);
2236
2237 out:
2238 mutex_unlock(&wl->mutex);
2239 return count;
2240}
2241
2242static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2243 wl1271_sysfs_show_bt_coex_state,
2244 wl1271_sysfs_store_bt_coex_state);
2245
d717fd61
JO		 2246static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2247 struct device_attribute *attr,
2248 char *buf)
2249{
2250 struct wl1271 *wl = dev_get_drvdata(dev);
2251 ssize_t len;
2252
2253 /* FIXME: what's the maximum length of buf? page size?*/
2254 len = 500;
2255
2256 mutex_lock(&wl->mutex);
2257 if (wl->hw_pg_ver >= 0)
2258 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2259 else
2260 len = snprintf(buf, len, "n/a\n");
2261 mutex_unlock(&wl->mutex);
2262
2263 return len;
2264}
2265
2266static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2267 wl1271_sysfs_show_hw_pg_ver, NULL);
2268
2d5e82b8 2269int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 2270{
2271 int ret;
2272
2273 if (wl->mac80211_registered)
2274 return 0;
2275
2276 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2277
2278 ret = ieee80211_register_hw(wl->hw);
2279 if (ret < 0) {
2280 wl1271_error("unable to register mac80211 hw: %d", ret);
2281 return ret;
2282 }
2283
2284 wl->mac80211_registered = true;
2285
2286 wl1271_notice("loaded");
2287
2288 return 0;
2289}
50b3eb4b 2290EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 2291
3b56dd6a
TP		 2292void wl1271_unregister_hw(struct wl1271 *wl)
2293{
2294 ieee80211_unregister_hw(wl->hw);
2295 wl->mac80211_registered = false;
2296
2297}
2298EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2299
2d5e82b8 2300int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 2301{
1e2b7976
JO		 2302 /* The tx descriptor buffer and the TKIP space. */
2303 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2304 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 2305
2306 /* unit us */
2307 /* FIXME: find a proper value */
2308 wl->hw->channel_change_time = 10000;
50c500ad 2309 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 2310
2311 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 2312 IEEE80211_HW_BEACON_FILTER |
0a34332f 2313 IEEE80211_HW_SUPPORTS_PS |
4695dc91 2314 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 2315 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed
JO		 2316 IEEE80211_HW_CONNECTION_MONITOR |
2317 IEEE80211_HW_SUPPORTS_CQM_RSSI;
f5fc0f86 2318
e0d8bbf0
JO		 2319 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2320 BIT(NL80211_IFTYPE_ADHOC);
f5fc0f86
LC		 2321 wl->hw->wiphy->max_scan_ssids = 1;
2322 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2323
1ebec3d7
TP		 2324 if (wl1271_11a_enabled())
2325 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2326
12bd8949 2327 wl->hw->queues = 4;
31627dc5 2328 wl->hw->max_rates = 1;
12bd8949 2329
8197b711 2330 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 2331
2332 return 0;
2333}
50b3eb4b 2334EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 2335
f5fc0f86 2336#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 2337
2d5e82b8 2338struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 2339{
f5fc0f86 2340 struct ieee80211_hw *hw;
3b56dd6a 2341 struct platform_device *plat_dev = NULL;
f5fc0f86 2342 struct wl1271 *wl;
a1dd8187 2343 int i, ret;
f5fc0f86
LC		 2344
2345 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2346 if (!hw) {
2347 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 2348 ret = -ENOMEM;
3b56dd6a
TP		 2349 goto err_hw_alloc;
2350 }
2351
2352 plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2353 if (!plat_dev) {
2354 wl1271_error("could not allocate platform_device");
2355 ret = -ENOMEM;
2356 goto err_plat_alloc;
f5fc0f86
LC		 2357 }
2358
3b56dd6a
TP		 2359 memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2360
f5fc0f86
LC		 2361 wl = hw->priv;
2362 memset(wl, 0, sizeof(*wl));
2363
01c09162
JO		 2364 INIT_LIST_HEAD(&wl->list);
2365
f5fc0f86 2366 wl->hw = hw;
3b56dd6a 2367 wl->plat_dev = plat_dev;
f5fc0f86
LC		 2368
2369 skb_queue_head_init(&wl->tx_queue);
2370
37b70a81 2371 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
90494a90 2372 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
f5fc0f86 2373 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 2374 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 2375 wl->default_key = 0;
f5fc0f86
LC		 2376 wl->rx_counter = 0;
2377 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2378 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
19ad0715 2379 wl->psm_entry_retry = 0;
f5fc0f86 2380 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 2381 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 2382 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b
JO		 2383 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2384 wl->sta_rate_set = 0;
8a5a37a6 2385 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 2386 wl->vif = NULL;
830fb67b 2387 wl->flags = 0;
7fc3a864 2388 wl->sg_enabled = true;
d717fd61 2389 wl->hw_pg_ver = -1;
f5fc0f86 2390
be7078c2 2391 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 2392 wl->tx_frames[i] = NULL;
2393
2394 spin_lock_init(&wl->wl_lock);
2395
f5fc0f86
LC		 2396 wl->state = WL1271_STATE_OFF;
2397 mutex_init(&wl->mutex);
2398
c332a4b8
TP		 2399 /* Apply default driver configuration. */
2400 wl1271_conf_init(wl);
2401
2d5e82b8
TP		 2402 wl1271_debugfs_init(wl);
2403
a1dd8187 2404 /* Register platform device */
3b56dd6a 2405 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 2406 if (ret) {
2407 wl1271_error("couldn't register platform device");
2408 goto err_hw;
2409 }
3b56dd6a 2410 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 2411
7fc3a864 2412 /* Create sysfs file to control bt coex state */
3b56dd6a 2413 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 2414 if (ret < 0) {
2415 wl1271_error("failed to create sysfs file bt_coex_state");
2416 goto err_platform;
2417 }
a1dd8187 2418
d717fd61
JO		 2419 /* Create sysfs file to get HW PG version */
2420 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2421 if (ret < 0) {
2422 wl1271_error("failed to create sysfs file hw_pg_ver");
2423 goto err_bt_coex_state;
2424 }
2425
c332a4b8 2426 return hw;
a1dd8187 2427
d717fd61
JO		 2428err_bt_coex_state:
2429 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2430
7fc3a864 2431err_platform:
3b56dd6a 2432 platform_device_unregister(wl->plat_dev);
7fc3a864 2433
a1dd8187 2434err_hw:
3b56dd6a
TP		 2435 wl1271_debugfs_exit(wl);
2436 kfree(plat_dev);
2437
2438err_plat_alloc:
2439 ieee80211_free_hw(hw);
2440
2441err_hw_alloc:
a1dd8187 2442
a1dd8187 2443 return ERR_PTR(ret);
c332a4b8 2444}
50b3eb4b 2445EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 2446
2447int wl1271_free_hw(struct wl1271 *wl)
2448{
3b56dd6a
TP		 2449 platform_device_unregister(wl->plat_dev);
2450 kfree(wl->plat_dev);
c332a4b8
TP		 2451
2452 wl1271_debugfs_exit(wl);
2453
c332a4b8
TP		 2454 vfree(wl->fw);
2455 wl->fw = NULL;
2456 kfree(wl->nvs);
2457 wl->nvs = NULL;
2458
2459 kfree(wl->fw_status);
2460 kfree(wl->tx_res_if);
2461
2462 ieee80211_free_hw(wl->hw);
2463
2464 return 0;
2465}
50b3eb4b
TP		 2466EXPORT_SYMBOL_GPL(wl1271_free_hw);
2467
2468MODULE_LICENSE("GPL");
2469MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2470MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
kernel source for telekom puls (alcatel/mediatek)