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