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