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