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