]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/net/wireless/wl12xx/wl1271_main.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl1271: Use minimum rate for each band for control messages
[net-next-2.6.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,
bfb24c9e 1645 beacon->len, 0);
e0d8bbf0
JO		 1646
1647 if (ret < 0) {
1648 dev_kfree_skb(beacon);
1649 goto out_sleep;
1650 }
1651
1652 hdr = (struct ieee80211_hdr *) beacon->data;
1653 hdr->frame_control = cpu_to_le16(
1654 IEEE80211_FTYPE_MGMT |
1655 IEEE80211_STYPE_PROBE_RESP);
1656
1657 ret = wl1271_cmd_template_set(wl,
1658 CMD_TEMPL_PROBE_RESPONSE,
1659 beacon->data,
bfb24c9e 1660 beacon->len, 0);
e0d8bbf0
JO		 1661 dev_kfree_skb(beacon);
1662 if (ret < 0)
1663 goto out_sleep;
8bf29b0e
JO		 1664
1665 /* Need to update the SSID (for filtering etc) */
1666 do_join = true;
e0d8bbf0
JO		 1667 }
1668 }
1669
5da11dcd
JO		 1670 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1671 (wl->bss_type == BSS_TYPE_IBSS)) {
1672 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1673 bss_conf->enable_beacon ? "enabled" : "disabled");
1674
1675 if (bss_conf->enable_beacon)
1676 wl->set_bss_type = BSS_TYPE_IBSS;
1677 else
1678 wl->set_bss_type = BSS_TYPE_STA_BSS;
1679 do_join = true;
1680 }
1681
30240fc7
JO		 1682 if ((changed & BSS_CHANGED_BSSID) &&
1683 /*
1684 * Now we know the correct bssid, so we send a new join command
1685 * and enable the BSSID filter
1686 */
1687 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
30240fc7 1688 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 1689
30240fc7 1690 ret = wl1271_cmd_build_null_data(wl);
a0cb7be4 1691 if (ret < 0)
30240fc7 1692 goto out_sleep;
30240fc7 1693
14b228a0
JO		 1694 /* filter out all packets not from this BSSID */
1695 wl1271_configure_filters(wl, 0);
1696
8bf29b0e
JO		 1697 /* Need to update the BSSID (for filtering etc) */
1698 do_join = true;
30240fc7
JO		 1699 }
1700
f5fc0f86
LC		 1701 if (changed & BSS_CHANGED_ASSOC) {
1702 if (bss_conf->assoc) {
ebba60c6 1703 u32 rates;
f5fc0f86 1704 wl->aid = bss_conf->aid;
830fb67b 1705 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
f5fc0f86 1706
ebba60c6
JO		 1707 /*
1708 * use basic rates from AP, and determine lowest rate
1709 * to use with control frames.
1710 */
1711 rates = bss_conf->basic_rates;
1712 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1713 rates);
1714 wl->basic_rate = wl1271_min_rate_get(wl);
1715 ret = wl1271_acx_rate_policies(wl);
1716 if (ret < 0)
1717 goto out_sleep;
1718
ae751bab
LC		 1719 /*
1720 * with wl1271, we don't need to update the
1721 * beacon_int and dtim_period, because the firmware
1722 * updates it by itself when the first beacon is
1723 * received after a join.
1724 */
f5fc0f86
LC		 1725 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1726 if (ret < 0)
1727 goto out_sleep;
1728
c2b2d99b
JO		 1729 /*
1730 * The SSID is intentionally set to NULL here - the
1731 * firmware will set the probe request with a
1732 * broadcast SSID regardless of what we set in the
1733 * template.
1734 */
1735 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1736 NULL, 0, wl->band);
1737
c1899554
JO		 1738 /* Enable the keep-alive feature */
1739 ret = wl1271_acx_keep_alive_mode(wl, true);
f5fc0f86
LC		 1740 if (ret < 0)
1741 goto out_sleep;
1742
40b359c6
JO		 1743 /*
1744 * This is awkward. The keep-alive configs must be done
1745 * *after* the join command, because otherwise it will
1746 * not work, but it must only be done *once* because
1747 * otherwise the firmware will start complaining.
1748 */
1749 do_keepalive = true;
1750
6ccbb92e
JO		 1751 /* enable the connection monitoring feature */
1752 ret = wl1271_acx_conn_monit_params(wl, true);
1753 if (ret < 0)
1754 goto out_sleep;
1755
f5fc0f86 1756 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 1757 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1758 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
f5fc0f86 1759 mode = STATION_POWER_SAVE_MODE;
d8c42c0c 1760 ret = wl1271_ps_set_mode(wl, mode, true);
f5fc0f86
LC		 1761 if (ret < 0)
1762 goto out_sleep;
1763 }
d94cd297
JO		 1764 } else {
1765 /* use defaults when not associated */
830fb67b 1766 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
d94cd297 1767 wl->aid = 0;
6ccbb92e 1768
ebba60c6
JO		 1769 /* revert back to minimum rates for the current band */
1770 wl1271_set_band_rate(wl);
1771 wl->basic_rate = wl1271_min_rate_get(wl);
1772 ret = wl1271_acx_rate_policies(wl);
1773 if (ret < 0)
1774 goto out_sleep;
1775
6ccbb92e
JO		 1776 /* disable connection monitor features */
1777 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 1778
1779 /* Disable the keep-alive feature */
1780 ret = wl1271_acx_keep_alive_mode(wl, false);
1781
6ccbb92e
JO		 1782 if (ret < 0)
1783 goto out_sleep;
f5fc0f86 1784 }
d94cd297 1785
f5fc0f86 1786 }
8a5a37a6 1787
f5fc0f86
LC		 1788 if (changed & BSS_CHANGED_ERP_SLOT) {
1789 if (bss_conf->use_short_slot)
1790 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1791 else
1792 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1793 if (ret < 0) {
1794 wl1271_warning("Set slot time failed %d", ret);
1795 goto out_sleep;
1796 }
1797 }
1798
1799 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1800 if (bss_conf->use_short_preamble)
1801 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1802 else
1803 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1804 }
1805
1806 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1807 if (bss_conf->use_cts_prot)
1808 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1809 else
1810 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1811 if (ret < 0) {
1812 wl1271_warning("Set ctsprotect failed %d", ret);
1813 goto out_sleep;
1814 }
1815 }
1816
8bf29b0e 1817 if (do_join) {
5da11dcd 1818 ret = wl1271_cmd_join(wl, wl->set_bss_type);
8bf29b0e
JO		 1819 if (ret < 0) {
1820 wl1271_warning("cmd join failed %d", ret);
1821 goto out_sleep;
1822 }
1823 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1824 }
1825
c1899554
JO		 1826 /*
1827 * The JOIN operation shuts down the firmware keep-alive as a side
1828 * effect, and the ACX_AID will start the keep-alive as a side effect.
1829 * Hence, for non-IBSS, the ACX_AID must always happen *after* the
1830 * JOIN operation, and the template config after the ACX_AID.
1831 */
1832 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1833 ret = wl1271_acx_aid(wl, wl->aid);
1834 if (ret < 0)
1835 goto out_sleep;
40b359c6
JO		 1836 }
1837
1838 if (do_keepalive) {
c1899554
JO		 1839 ret = wl1271_cmd_build_klv_null_data(wl);
1840 if (ret < 0)
1841 goto out_sleep;
1842 ret = wl1271_acx_keep_alive_config(
1843 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1844 ACX_KEEP_ALIVE_TPL_VALID);
1845 if (ret < 0)
1846 goto out_sleep;
1847 }
1848
f5fc0f86
LC		 1849out_sleep:
1850 wl1271_ps_elp_sleep(wl);
1851
1852out:
1853 mutex_unlock(&wl->mutex);
1854}
1855
c6999d83
KV		 1856static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1857 const struct ieee80211_tx_queue_params *params)
1858{
1859 struct wl1271 *wl = hw->priv;
4695dc91 1860 u8 ps_scheme;
c6999d83
KV		 1861 int ret;
1862
1863 mutex_lock(&wl->mutex);
1864
1865 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1866
c82c1dde
KV		 1867 ret = wl1271_ps_elp_wakeup(wl, false);
1868 if (ret < 0)
1869 goto out;
1870
b43316db 1871 /* the txop is confed in units of 32us by the mac80211, we need us */
c6999d83
KV		 1872 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1873 params->cw_min, params->cw_max,
b43316db 1874 params->aifs, params->txop << 5);
c6999d83 1875 if (ret < 0)
c82c1dde 1876 goto out_sleep;
c6999d83 1877
4695dc91
KV		 1878 if (params->uapsd)
1879 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1880 else
1881 ps_scheme = CONF_PS_SCHEME_LEGACY;
1882
c6999d83
KV		 1883 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1884 CONF_CHANNEL_TYPE_EDCF,
1885 wl1271_tx_get_queue(queue),
4695dc91 1886 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
c6999d83 1887 if (ret < 0)
c82c1dde
KV		 1888 goto out_sleep;
1889
1890out_sleep:
1891 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 1892
1893out:
1894 mutex_unlock(&wl->mutex);
1895
1896 return ret;
1897}
1898
f5fc0f86
LC		 1899
1900/* can't be const, mac80211 writes to this */
1901static struct ieee80211_rate wl1271_rates[] = {
1902 { .bitrate = 10,
2b60100b
JO		 1903 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1904 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 1905 { .bitrate = 20,
2b60100b
JO		 1906 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1907 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 1908 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1909 { .bitrate = 55,
2b60100b
JO		 1910 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1911 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 1912 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1913 { .bitrate = 110,
2b60100b
JO		 1914 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1915 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 1916 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1917 { .bitrate = 60,
2b60100b
JO		 1918 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1919 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 1920 { .bitrate = 90,
2b60100b
JO		 1921 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1922 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 1923 { .bitrate = 120,
2b60100b
JO		 1924 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1925 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 1926 { .bitrate = 180,
2b60100b
JO		 1927 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1928 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 1929 { .bitrate = 240,
2b60100b
JO		 1930 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1931 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 1932 { .bitrate = 360,
2b60100b
JO		 1933 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1934 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 1935 { .bitrate = 480,
2b60100b
JO		 1936 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1937 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 1938 { .bitrate = 540,
2b60100b
JO		 1939 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1940 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 1941};
1942
1943/* can't be const, mac80211 writes to this */
1944static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1
LC		 1945 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1946 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1947 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1948 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1949 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1950 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1951 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1952 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1953 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1954 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1955 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1956 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1957 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
f5fc0f86
LC		 1958};
1959
f876bb9a
JO		 1960/* mapping to indexes for wl1271_rates */
1961const static u8 wl1271_rate_to_idx_2ghz[] = {
1962 /* MCS rates are used only with 11n */
1963 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
1964 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
1965 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
1966 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
1967 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
1968 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
1969 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
1970 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
1971
1972 11, /* CONF_HW_RXTX_RATE_54 */
1973 10, /* CONF_HW_RXTX_RATE_48 */
1974 9, /* CONF_HW_RXTX_RATE_36 */
1975 8, /* CONF_HW_RXTX_RATE_24 */
1976
1977 /* TI-specific rate */
1978 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
1979
1980 7, /* CONF_HW_RXTX_RATE_18 */
1981 6, /* CONF_HW_RXTX_RATE_12 */
1982 3, /* CONF_HW_RXTX_RATE_11 */
1983 5, /* CONF_HW_RXTX_RATE_9 */
1984 4, /* CONF_HW_RXTX_RATE_6 */
1985 2, /* CONF_HW_RXTX_RATE_5_5 */
1986 1, /* CONF_HW_RXTX_RATE_2 */
1987 0 /* CONF_HW_RXTX_RATE_1 */
1988};
1989
f5fc0f86
LC		 1990/* can't be const, mac80211 writes to this */
1991static struct ieee80211_supported_band wl1271_band_2ghz = {
1992 .channels = wl1271_channels,
1993 .n_channels = ARRAY_SIZE(wl1271_channels),
1994 .bitrates = wl1271_rates,
1995 .n_bitrates = ARRAY_SIZE(wl1271_rates),
1996};
1997
1ebec3d7
TP		 1998/* 5 GHz data rates for WL1273 */
1999static struct ieee80211_rate wl1271_rates_5ghz[] = {
2000 { .bitrate = 60,
2001 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2002 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2003 { .bitrate = 90,
2004 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2005 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2006 { .bitrate = 120,
2007 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2008 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2009 { .bitrate = 180,
2010 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2011 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2012 { .bitrate = 240,
2013 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2014 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2015 { .bitrate = 360,
2016 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2017 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2018 { .bitrate = 480,
2019 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2020 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2021 { .bitrate = 540,
2022 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2023 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2024};
2025
2026/* 5 GHz band channels for WL1273 */
2027static struct ieee80211_channel wl1271_channels_5ghz[] = {
2028 { .hw_value = 183, .center_freq = 4915},
2029 { .hw_value = 184, .center_freq = 4920},
2030 { .hw_value = 185, .center_freq = 4925},
2031 { .hw_value = 187, .center_freq = 4935},
2032 { .hw_value = 188, .center_freq = 4940},
2033 { .hw_value = 189, .center_freq = 4945},
2034 { .hw_value = 192, .center_freq = 4960},
2035 { .hw_value = 196, .center_freq = 4980},
2036 { .hw_value = 7, .center_freq = 5035},
2037 { .hw_value = 8, .center_freq = 5040},
2038 { .hw_value = 9, .center_freq = 5045},
2039 { .hw_value = 11, .center_freq = 5055},
2040 { .hw_value = 12, .center_freq = 5060},
2041 { .hw_value = 16, .center_freq = 5080},
2042 { .hw_value = 34, .center_freq = 5170},
2043 { .hw_value = 36, .center_freq = 5180},
2044 { .hw_value = 38, .center_freq = 5190},
2045 { .hw_value = 40, .center_freq = 5200},
2046 { .hw_value = 42, .center_freq = 5210},
2047 { .hw_value = 44, .center_freq = 5220},
2048 { .hw_value = 46, .center_freq = 5230},
2049 { .hw_value = 48, .center_freq = 5240},
2050 { .hw_value = 52, .center_freq = 5260},
2051 { .hw_value = 56, .center_freq = 5280},
2052 { .hw_value = 60, .center_freq = 5300},
2053 { .hw_value = 64, .center_freq = 5320},
2054 { .hw_value = 100, .center_freq = 5500},
2055 { .hw_value = 104, .center_freq = 5520},
2056 { .hw_value = 108, .center_freq = 5540},
2057 { .hw_value = 112, .center_freq = 5560},
2058 { .hw_value = 116, .center_freq = 5580},
2059 { .hw_value = 120, .center_freq = 5600},
2060 { .hw_value = 124, .center_freq = 5620},
2061 { .hw_value = 128, .center_freq = 5640},
2062 { .hw_value = 132, .center_freq = 5660},
2063 { .hw_value = 136, .center_freq = 5680},
2064 { .hw_value = 140, .center_freq = 5700},
2065 { .hw_value = 149, .center_freq = 5745},
2066 { .hw_value = 153, .center_freq = 5765},
2067 { .hw_value = 157, .center_freq = 5785},
2068 { .hw_value = 161, .center_freq = 5805},
2069 { .hw_value = 165, .center_freq = 5825},
2070};
2071
f876bb9a
JO		 2072/* mapping to indexes for wl1271_rates_5ghz */
2073const static u8 wl1271_rate_to_idx_5ghz[] = {
2074 /* MCS rates are used only with 11n */
2075 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2076 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2077 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2078 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2079 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2080 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2081 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2082 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2083
2084 7, /* CONF_HW_RXTX_RATE_54 */
2085 6, /* CONF_HW_RXTX_RATE_48 */
2086 5, /* CONF_HW_RXTX_RATE_36 */
2087 4, /* CONF_HW_RXTX_RATE_24 */
2088
2089 /* TI-specific rate */
2090 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2091
2092 3, /* CONF_HW_RXTX_RATE_18 */
2093 2, /* CONF_HW_RXTX_RATE_12 */
2094 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2095 1, /* CONF_HW_RXTX_RATE_9 */
2096 0, /* CONF_HW_RXTX_RATE_6 */
2097 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2098 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2099 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2100};
1ebec3d7
TP		 2101
2102static struct ieee80211_supported_band wl1271_band_5ghz = {
2103 .channels = wl1271_channels_5ghz,
2104 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2105 .bitrates = wl1271_rates_5ghz,
2106 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2107};
2108
f876bb9a
JO		 2109const static u8 *wl1271_band_rate_to_idx[] = {
2110 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2111 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2112};
2113
f5fc0f86
LC		 2114static const struct ieee80211_ops wl1271_ops = {
2115 .start = wl1271_op_start,
2116 .stop = wl1271_op_stop,
2117 .add_interface = wl1271_op_add_interface,
2118 .remove_interface = wl1271_op_remove_interface,
2119 .config = wl1271_op_config,
c87dec9f 2120 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 2121 .configure_filter = wl1271_op_configure_filter,
2122 .tx = wl1271_op_tx,
2123 .set_key = wl1271_op_set_key,
2124 .hw_scan = wl1271_op_hw_scan,
2125 .bss_info_changed = wl1271_op_bss_info_changed,
2126 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 2127 .conf_tx = wl1271_op_conf_tx,
c8c90873 2128 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 2129};
2130
f876bb9a
JO		 2131
2132u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2133{
2134 u8 idx;
2135
2136 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2137
2138 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2139 wl1271_error("Illegal RX rate from HW: %d", rate);
2140 return 0;
2141 }
2142
2143 idx = wl1271_band_rate_to_idx[wl->band][rate];
2144 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2145 wl1271_error("Unsupported RX rate from HW: %d", rate);
2146 return 0;
2147 }
2148
2149 return idx;
2150}
2151
7fc3a864
JO		 2152static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2153 struct device_attribute *attr,
2154 char *buf)
2155{
2156 struct wl1271 *wl = dev_get_drvdata(dev);
2157 ssize_t len;
2158
2159 /* FIXME: what's the maximum length of buf? page size?*/
2160 len = 500;
2161
2162 mutex_lock(&wl->mutex);
2163 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2164 wl->sg_enabled);
2165 mutex_unlock(&wl->mutex);
2166
2167 return len;
2168
2169}
2170
2171static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2172 struct device_attribute *attr,
2173 const char *buf, size_t count)
2174{
2175 struct wl1271 *wl = dev_get_drvdata(dev);
2176 unsigned long res;
2177 int ret;
2178
2179 ret = strict_strtoul(buf, 10, &res);
2180
2181 if (ret < 0) {
2182 wl1271_warning("incorrect value written to bt_coex_mode");
2183 return count;
2184 }
2185
2186 mutex_lock(&wl->mutex);
2187
2188 res = !!res;
2189
2190 if (res == wl->sg_enabled)
2191 goto out;
2192
2193 wl->sg_enabled = res;
2194
2195 if (wl->state == WL1271_STATE_OFF)
2196 goto out;
2197
2198 ret = wl1271_ps_elp_wakeup(wl, false);
2199 if (ret < 0)
2200 goto out;
2201
2202 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2203 wl1271_ps_elp_sleep(wl);
2204
2205 out:
2206 mutex_unlock(&wl->mutex);
2207 return count;
2208}
2209
2210static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2211 wl1271_sysfs_show_bt_coex_state,
2212 wl1271_sysfs_store_bt_coex_state);
2213
2d5e82b8 2214int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 2215{
2216 int ret;
2217
2218 if (wl->mac80211_registered)
2219 return 0;
2220
2221 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2222
2223 ret = ieee80211_register_hw(wl->hw);
2224 if (ret < 0) {
2225 wl1271_error("unable to register mac80211 hw: %d", ret);
2226 return ret;
2227 }
2228
2229 wl->mac80211_registered = true;
2230
2231 wl1271_notice("loaded");
2232
2233 return 0;
2234}
50b3eb4b 2235EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 2236
3b56dd6a
TP		 2237void wl1271_unregister_hw(struct wl1271 *wl)
2238{
2239 ieee80211_unregister_hw(wl->hw);
2240 wl->mac80211_registered = false;
2241
2242}
2243EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2244
2d5e82b8 2245int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 2246{
1e2b7976
JO		 2247 /* The tx descriptor buffer and the TKIP space. */
2248 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2249 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 2250
2251 /* unit us */
2252 /* FIXME: find a proper value */
2253 wl->hw->channel_change_time = 10000;
2254
2255 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1922167b 2256 IEEE80211_HW_NOISE_DBM |
03442a33 2257 IEEE80211_HW_BEACON_FILTER |
0a34332f 2258 IEEE80211_HW_SUPPORTS_PS |
4695dc91 2259 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b
JO		 2260 IEEE80211_HW_HAS_RATE_CONTROL |
2261 IEEE80211_HW_CONNECTION_MONITOR;
f5fc0f86 2262
e0d8bbf0
JO		 2263 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2264 BIT(NL80211_IFTYPE_ADHOC);
f5fc0f86
LC		 2265 wl->hw->wiphy->max_scan_ssids = 1;
2266 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2267
1ebec3d7
TP		 2268 if (wl1271_11a_enabled())
2269 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2270
12bd8949 2271 wl->hw->queues = 4;
31627dc5 2272 wl->hw->max_rates = 1;
12bd8949 2273
8197b711 2274 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 2275
2276 return 0;
2277}
50b3eb4b 2278EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 2279
f5fc0f86 2280#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 2281
2d5e82b8 2282struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 2283{
f5fc0f86 2284 struct ieee80211_hw *hw;
3b56dd6a 2285 struct platform_device *plat_dev = NULL;
f5fc0f86 2286 struct wl1271 *wl;
a1dd8187 2287 int i, ret;
f5fc0f86
LC		 2288
2289 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2290 if (!hw) {
2291 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 2292 ret = -ENOMEM;
3b56dd6a
TP		 2293 goto err_hw_alloc;
2294 }
2295
2296 plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2297 if (!plat_dev) {
2298 wl1271_error("could not allocate platform_device");
2299 ret = -ENOMEM;
2300 goto err_plat_alloc;
f5fc0f86
LC		 2301 }
2302
3b56dd6a
TP		 2303 memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2304
f5fc0f86
LC		 2305 wl = hw->priv;
2306 memset(wl, 0, sizeof(*wl));
2307
01c09162
JO		 2308 INIT_LIST_HEAD(&wl->list);
2309
f5fc0f86 2310 wl->hw = hw;
3b56dd6a 2311 wl->plat_dev = plat_dev;
f5fc0f86
LC		 2312
2313 skb_queue_head_init(&wl->tx_queue);
2314
37b70a81 2315 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
f5fc0f86 2316 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 2317 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 2318 wl->default_key = 0;
f5fc0f86
LC		 2319 wl->rx_counter = 0;
2320 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2321 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
19ad0715 2322 wl->psm_entry_retry = 0;
f5fc0f86 2323 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 2324 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 2325 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b
JO		 2326 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2327 wl->sta_rate_set = 0;
8a5a37a6 2328 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 2329 wl->vif = NULL;
830fb67b 2330 wl->flags = 0;
7fc3a864 2331 wl->sg_enabled = true;
f5fc0f86 2332
be7078c2 2333 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 2334 wl->tx_frames[i] = NULL;
2335
2336 spin_lock_init(&wl->wl_lock);
2337
f5fc0f86
LC		 2338 wl->state = WL1271_STATE_OFF;
2339 mutex_init(&wl->mutex);
2340
c332a4b8
TP		 2341 /* Apply default driver configuration. */
2342 wl1271_conf_init(wl);
2343
2d5e82b8
TP		 2344 wl1271_debugfs_init(wl);
2345
a1dd8187 2346 /* Register platform device */
3b56dd6a 2347 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 2348 if (ret) {
2349 wl1271_error("couldn't register platform device");
2350 goto err_hw;
2351 }
3b56dd6a 2352 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 2353
7fc3a864 2354 /* Create sysfs file to control bt coex state */
3b56dd6a 2355 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 2356 if (ret < 0) {
2357 wl1271_error("failed to create sysfs file bt_coex_state");
2358 goto err_platform;
2359 }
a1dd8187 2360
c332a4b8 2361 return hw;
a1dd8187 2362
7fc3a864 2363err_platform:
3b56dd6a 2364 platform_device_unregister(wl->plat_dev);
7fc3a864 2365
a1dd8187 2366err_hw:
3b56dd6a
TP		 2367 wl1271_debugfs_exit(wl);
2368 kfree(plat_dev);
2369
2370err_plat_alloc:
2371 ieee80211_free_hw(hw);
2372
2373err_hw_alloc:
a1dd8187 2374
a1dd8187 2375 return ERR_PTR(ret);
c332a4b8 2376}
50b3eb4b 2377EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 2378
2379int wl1271_free_hw(struct wl1271 *wl)
2380{
3b56dd6a
TP		 2381 platform_device_unregister(wl->plat_dev);
2382 kfree(wl->plat_dev);
c332a4b8
TP		 2383
2384 wl1271_debugfs_exit(wl);
2385
2386 kfree(wl->target_mem_map);
2387 vfree(wl->fw);
2388 wl->fw = NULL;
2389 kfree(wl->nvs);
2390 wl->nvs = NULL;
2391
2392 kfree(wl->fw_status);
2393 kfree(wl->tx_res_if);
2394
2395 ieee80211_free_hw(wl->hw);
2396
2397 return 0;
2398}
50b3eb4b
TP		 2399EXPORT_SYMBOL_GPL(wl1271_free_hw);
2400
2401MODULE_LICENSE("GPL");
2402MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2403MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Clone of davem's net-next-2.6 tree