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