projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cfg80211: Remove default dynamic PS timeout value
[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
c7f43e45
LC		 1120static int wl1271_join_channel(struct wl1271 *wl, int channel)
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 wl->channel = channel;
1128 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1129
14b228a0
JO		 1130 /* pass through frames from all BSS */
1131 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1132
5da11dcd 1133 ret = wl1271_cmd_join(wl, wl->set_bss_type);
c7f43e45
LC		 1134 if (ret < 0)
1135 goto out;
1136
71449f8d 1137 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1138
1139out:
1140 return ret;
1141}
1142
1143static int wl1271_unjoin_channel(struct wl1271 *wl)
1144{
1145 int ret;
1146
1147 /* to stop listening to a channel, we disconnect */
1148 ret = wl1271_cmd_disconnect(wl);
1149 if (ret < 0)
1150 goto out;
1151
71449f8d 1152 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1153 wl->channel = 0;
1154 memset(wl->bssid, 0, ETH_ALEN);
14b228a0
JO		 1155
1156 /* stop filterting packets based on bssid */
1157 wl1271_configure_filters(wl, FIF_OTHER_BSS);
c7f43e45
LC		 1158
1159out:
1160 return ret;
1161}
1162
ebba60c6
JO		 1163static void wl1271_set_band_rate(struct wl1271 *wl)
1164{
1165 if (wl->band == IEEE80211_BAND_2GHZ)
1166 wl->basic_rate_set = wl->conf.tx.basic_rate;
1167 else
1168 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1169}
1170
1171static u32 wl1271_min_rate_get(struct wl1271 *wl)
1172{
1173 int i;
1174 u32 rate = 0;
1175
1176 if (!wl->basic_rate_set) {
1177 WARN_ON(1);
1178 wl->basic_rate_set = wl->conf.tx.basic_rate;
1179 }
1180
1181 for (i = 0; !rate; i++) {
1182 if ((wl->basic_rate_set >> i) & 0x1)
1183 rate = 1 << i;
1184 }
1185
1186 return rate;
1187}
1188
f5fc0f86
LC		 1189static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1190{
1191 struct wl1271 *wl = hw->priv;
1192 struct ieee80211_conf *conf = &hw->conf;
1193 int channel, ret = 0;
1194
1195 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1196
c7f43e45 1197 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
f5fc0f86
LC		 1198 channel,
1199 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45
LC		 1200 conf->power_level,
1201 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
f5fc0f86
LC		 1202
1203 mutex_lock(&wl->mutex);
1204
2c10bb9c
SD		 1205 if (unlikely(wl->state == WL1271_STATE_OFF))
1206 goto out;
1207
f5fc0f86
LC		 1208 ret = wl1271_ps_elp_wakeup(wl, false);
1209 if (ret < 0)
1210 goto out;
1211
ebba60c6
JO		 1212 /* if the channel changes while joined, join again */
1213 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1214 wl->band = conf->channel->band;
1215 wl->channel = channel;
1216
1217 /*
1218 * FIXME: the mac80211 should really provide a fixed rate
1219 * to use here. for now, just use the smallest possible rate
1220 * for the band as a fixed rate for association frames and
1221 * other control messages.
1222 */
1223 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1224 wl1271_set_band_rate(wl);
1225
1226 wl->basic_rate = wl1271_min_rate_get(wl);
1227 ret = wl1271_acx_rate_policies(wl);
1228 if (ret < 0)
1229 wl1271_warning("rate policy for update channel "
1230 "failed %d", ret);
1231
1232 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1233 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1234 if (ret < 0)
1235 wl1271_warning("cmd join to update channel "
1236 "failed %d", ret);
1237 }
1238 }
1239
c7f43e45 1240 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
71449f8d
JO		 1241 if (conf->flags & IEEE80211_CONF_IDLE &&
1242 test_bit(WL1271_FLAG_JOINED, &wl->flags))
c7f43e45 1243 wl1271_unjoin_channel(wl);
8f648c00 1244 else if (!(conf->flags & IEEE80211_CONF_IDLE))
c7f43e45 1245 wl1271_join_channel(wl, channel);
a6fe2313
JO		 1246
1247 if (conf->flags & IEEE80211_CONF_IDLE) {
ebba60c6 1248 wl->rate_set = wl1271_min_rate_get(wl);
830fb67b
JO		 1249 wl->sta_rate_set = 0;
1250 wl1271_acx_rate_policies(wl);
c1899554
JO		 1251 wl1271_acx_keep_alive_config(
1252 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1253 ACX_KEEP_ALIVE_TPL_INVALID);
e1972818
JO		 1254 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1255 } else
1256 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
f5fc0f86
LC		 1257 }
1258
71449f8d
JO		 1259 if (conf->flags & IEEE80211_CONF_PS &&
1260 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1261 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 1262
1263 /*
1264 * We enter PSM only if we're already associated.
1265 * If we're not, we'll enter it when joining an SSID,
1266 * through the bss_info_changed() hook.
1267 */
830fb67b 1268 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 1269 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c
JO		 1270 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1271 true);
af5e084b 1272 }
f5fc0f86 1273 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 1274 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 1275 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 1276
71449f8d 1277 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 1278
71449f8d 1279 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c
JO		 1280 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1281 true);
f5fc0f86
LC		 1282 }
1283
1284 if (conf->power_level != wl->power_level) {
1285 ret = wl1271_acx_tx_power(wl, conf->power_level);
1286 if (ret < 0)
c6317a54 1287 goto out_sleep;
f5fc0f86
LC		 1288
1289 wl->power_level = conf->power_level;
1290 }
1291
1292out_sleep:
1293 wl1271_ps_elp_sleep(wl);
1294
1295out:
1296 mutex_unlock(&wl->mutex);
1297
1298 return ret;
1299}
1300
b54853f1
JO		 1301struct wl1271_filter_params {
1302 bool enabled;
1303 int mc_list_length;
1304 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1305};
1306
c87dec9f
JO		 1307static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1308 struct dev_addr_list *mc_list)
1309{
c87dec9f 1310 struct wl1271_filter_params *fp;
2c10bb9c 1311 struct wl1271 *wl = hw->priv;
c87dec9f
JO		 1312 int i;
1313
2c10bb9c
SD		 1314 if (unlikely(wl->state == WL1271_STATE_OFF))
1315 return 0;
1316
74441130 1317 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 1318 if (!fp) {
1319 wl1271_error("Out of memory setting filters.");
1320 return 0;
1321 }
1322
1323 /* update multicast filtering parameters */
b54853f1 1324 fp->enabled = true;
c87dec9f
JO		 1325 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1326 mc_count = 0;
b54853f1 1327 fp->enabled = false;
c87dec9f
JO		 1328 }
1329
1330 fp->mc_list_length = 0;
1331 for (i = 0; i < mc_count; i++) {
1332 if (mc_list->da_addrlen == ETH_ALEN) {
1333 memcpy(fp->mc_list[fp->mc_list_length],
1334 mc_list->da_addr, ETH_ALEN);
1335 fp->mc_list_length++;
1336 } else
1337 wl1271_warning("Unknown mc address length.");
74441130 1338 mc_list = mc_list->next;
c87dec9f
JO		 1339 }
1340
b54853f1 1341 return (u64)(unsigned long)fp;
c87dec9f 1342}
f5fc0f86 1343
b54853f1
JO		 1344#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1345 FIF_ALLMULTI | \
1346 FIF_FCSFAIL | \
1347 FIF_BCN_PRBRESP_PROMISC | \
1348 FIF_CONTROL | \
1349 FIF_OTHER_BSS)
1350
f5fc0f86
LC		 1351static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1352 unsigned int changed,
c87dec9f 1353 unsigned int *total, u64 multicast)
f5fc0f86 1354{
b54853f1 1355 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 1356 struct wl1271 *wl = hw->priv;
b54853f1 1357 int ret;
f5fc0f86
LC		 1358
1359 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1360
b54853f1
JO		 1361 mutex_lock(&wl->mutex);
1362
2c10bb9c
SD		 1363 *total &= WL1271_SUPPORTED_FILTERS;
1364 changed &= WL1271_SUPPORTED_FILTERS;
1365
1366 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 1367 goto out;
1368
1369 ret = wl1271_ps_elp_wakeup(wl, false);
1370 if (ret < 0)
1371 goto out;
1372
f5fc0f86 1373
b54853f1
JO		 1374 if (*total & FIF_ALLMULTI)
1375 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1376 else if (fp)
1377 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1378 fp->mc_list,
1379 fp->mc_list_length);
1380 if (ret < 0)
1381 goto out_sleep;
f5fc0f86 1382
b54853f1
JO		 1383 /* determine, whether supported filter values have changed */
1384 if (changed == 0)
1385 goto out_sleep;
c87dec9f 1386
14b228a0
JO		 1387 /* configure filters */
1388 wl->filters = *total;
1389 wl1271_configure_filters(wl, 0);
1390
b54853f1
JO		 1391 /* apply configured filters */
1392 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1393 if (ret < 0)
1394 goto out_sleep;
1395
1396out_sleep:
1397 wl1271_ps_elp_sleep(wl);
1398
1399out:
1400 mutex_unlock(&wl->mutex);
14b228a0 1401 kfree(fp);
f5fc0f86
LC		 1402}
1403
1404static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1405 struct ieee80211_vif *vif,
1406 struct ieee80211_sta *sta,
1407 struct ieee80211_key_conf *key_conf)
1408{
1409 struct wl1271 *wl = hw->priv;
1410 const u8 *addr;
1411 int ret;
ac4e4ce5
JO		 1412 u32 tx_seq_32 = 0;
1413 u16 tx_seq_16 = 0;
f5fc0f86
LC		 1414 u8 key_type;
1415
1416 static const u8 bcast_addr[ETH_ALEN] =
1417 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1418
1419 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1420
1421 addr = sta ? sta->addr : bcast_addr;
1422
1423 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1424 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1425 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1426 key_conf->alg, key_conf->keyidx,
1427 key_conf->keylen, key_conf->flags);
1428 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1429
1430 if (is_zero_ether_addr(addr)) {
1431 /* We dont support TX only encryption */
1432 ret = -EOPNOTSUPP;
1433 goto out;
1434 }
1435
1436 mutex_lock(&wl->mutex);
1437
1438 ret = wl1271_ps_elp_wakeup(wl, false);
1439 if (ret < 0)
1440 goto out_unlock;
1441
1442 switch (key_conf->alg) {
1443 case ALG_WEP:
1444 key_type = KEY_WEP;
1445
1446 key_conf->hw_key_idx = key_conf->keyidx;
1447 break;
1448 case ALG_TKIP:
1449 key_type = KEY_TKIP;
1450
1451 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 1452 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1453 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86
LC		 1454 break;
1455 case ALG_CCMP:
1456 key_type = KEY_AES;
1457
1458 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
04e36fc5
JO		 1459 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1460 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86
LC		 1461 break;
1462 default:
1463 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1464
1465 ret = -EOPNOTSUPP;
1466 goto out_sleep;
1467 }
1468
1469 switch (cmd) {
1470 case SET_KEY:
1471 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1472 key_conf->keyidx, key_type,
1473 key_conf->keylen, key_conf->key,
ac4e4ce5 1474 addr, tx_seq_32, tx_seq_16);
f5fc0f86
LC		 1475 if (ret < 0) {
1476 wl1271_error("Could not add or replace key");
1477 goto out_sleep;
1478 }
ee444cf0
JO		 1479
1480 /* the default WEP key needs to be configured at least once */
1481 if (key_type == KEY_WEP) {
1482 ret = wl1271_cmd_set_default_wep_key(wl,
1483 wl->default_key);
1484 if (ret < 0)
1485 goto out_sleep;
1486 }
f5fc0f86
LC		 1487 break;
1488
1489 case DISABLE_KEY:
fddc7dd7
JO		 1490 /* The wl1271 does not allow to remove unicast keys - they
1491 will be cleared automatically on next CMD_JOIN. Ignore the
1492 request silently, as we dont want the mac80211 to emit
1493 an error message. */
1494 if (!is_broadcast_ether_addr(addr))
1495 break;
1496
f5fc0f86
LC		 1497 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1498 key_conf->keyidx, key_type,
1499 key_conf->keylen, key_conf->key,
ac4e4ce5 1500 addr, 0, 0);
f5fc0f86
LC		 1501 if (ret < 0) {
1502 wl1271_error("Could not remove key");
1503 goto out_sleep;
1504 }
1505 break;
1506
1507 default:
1508 wl1271_error("Unsupported key cmd 0x%x", cmd);
1509 ret = -EOPNOTSUPP;
1510 goto out_sleep;
1511
1512 break;
1513 }
1514
1515out_sleep:
1516 wl1271_ps_elp_sleep(wl);
1517
1518out_unlock:
1519 mutex_unlock(&wl->mutex);
1520
1521out:
1522 return ret;
1523}
1524
1525static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1526 struct cfg80211_scan_request *req)
1527{
1528 struct wl1271 *wl = hw->priv;
1529 int ret;
1530 u8 *ssid = NULL;
abb0b3bf 1531 size_t len = 0;
f5fc0f86
LC		 1532
1533 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1534
1535 if (req->n_ssids) {
1536 ssid = req->ssids[0].ssid;
abb0b3bf 1537 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 1538 }
1539
1540 mutex_lock(&wl->mutex);
1541
1542 ret = wl1271_ps_elp_wakeup(wl, false);
1543 if (ret < 0)
1544 goto out;
1545
abb0b3bf 1546 if (wl1271_11a_enabled())
818e3063
KV		 1547 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1548 req->ie, req->ie_len, 1, 0,
abb0b3bf
TP		 1549 WL1271_SCAN_BAND_DUAL, 3);
1550 else
818e3063
KV		 1551 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1552 req->ie, req->ie_len, 1, 0,
abb0b3bf 1553 WL1271_SCAN_BAND_2_4_GHZ, 3);
f5fc0f86
LC		 1554
1555 wl1271_ps_elp_sleep(wl);
1556
1557out:
1558 mutex_unlock(&wl->mutex);
1559
1560 return ret;
1561}
1562
1563static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1564{
1565 struct wl1271 *wl = hw->priv;
aecb0565 1566 int ret = 0;
f5fc0f86
LC		 1567
1568 mutex_lock(&wl->mutex);
1569
aecb0565
SD		 1570 if (unlikely(wl->state == WL1271_STATE_OFF))
1571 goto out;
1572
f5fc0f86
LC		 1573 ret = wl1271_ps_elp_wakeup(wl, false);
1574 if (ret < 0)
1575 goto out;
1576
1577 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1578 if (ret < 0)
1579 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1580
1581 wl1271_ps_elp_sleep(wl);
1582
1583out:
1584 mutex_unlock(&wl->mutex);
1585
1586 return ret;
1587}
1588
30240fc7
JO		 1589static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1590{
1591 u8 *ptr = beacon->data +
1592 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1593
1594 /* find the location of the ssid in the beacon */
1595 while (ptr < beacon->data + beacon->len) {
1596 if (ptr[0] == WLAN_EID_SSID) {
1597 wl->ssid_len = ptr[1];
1598 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1599 return;
1600 }
1601 ptr += ptr[1];
1602 }
1603 wl1271_error("ad-hoc beacon template has no SSID!\n");
1604}
1605
f5fc0f86
LC		 1606static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1607 struct ieee80211_vif *vif,
1608 struct ieee80211_bss_conf *bss_conf,
1609 u32 changed)
1610{
1611 enum wl1271_cmd_ps_mode mode;
1612 struct wl1271 *wl = hw->priv;
8bf29b0e 1613 bool do_join = false;
40b359c6 1614 bool do_keepalive = false;
f5fc0f86
LC		 1615 int ret;
1616
1617 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1618
1619 mutex_lock(&wl->mutex);
1620
1621 ret = wl1271_ps_elp_wakeup(wl, false);
1622 if (ret < 0)
1623 goto out;
1624
60e84c2e
JO		 1625 if ((changed && BSS_CHANGED_BEACON_INT) &&
1626 (wl->bss_type == BSS_TYPE_IBSS)) {
1627 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1628 bss_conf->beacon_int);
1629
1630 wl->beacon_int = bss_conf->beacon_int;
1631 do_join = true;
1632 }
1633
5da11dcd
JO		 1634 if ((changed && BSS_CHANGED_BEACON) &&
1635 (wl->bss_type == BSS_TYPE_IBSS)) {
e0d8bbf0
JO		 1636 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1637
5da11dcd
JO		 1638 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1639
e0d8bbf0
JO		 1640 if (beacon) {
1641 struct ieee80211_hdr *hdr;
30240fc7
JO		 1642
1643 wl1271_ssid_set(wl, beacon);
e0d8bbf0
JO		 1644 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1645 beacon->data,
606c1487
JO		 1646 beacon->len, 0,
1647 wl1271_min_rate_get(wl));
e0d8bbf0
JO		 1648
1649 if (ret < 0) {
1650 dev_kfree_skb(beacon);
1651 goto out_sleep;
1652 }
1653
1654 hdr = (struct ieee80211_hdr *) beacon->data;
1655 hdr->frame_control = cpu_to_le16(
1656 IEEE80211_FTYPE_MGMT |
1657 IEEE80211_STYPE_PROBE_RESP);
1658
1659 ret = wl1271_cmd_template_set(wl,
1660 CMD_TEMPL_PROBE_RESPONSE,
1661 beacon->data,
606c1487
JO		 1662 beacon->len, 0,
1663 wl1271_min_rate_get(wl));
e0d8bbf0
JO		 1664 dev_kfree_skb(beacon);
1665 if (ret < 0)
1666 goto out_sleep;
8bf29b0e
JO		 1667
1668 /* Need to update the SSID (for filtering etc) */
1669 do_join = true;
e0d8bbf0
JO		 1670 }
1671 }
1672
5da11dcd
JO		 1673 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1674 (wl->bss_type == BSS_TYPE_IBSS)) {
1675 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1676 bss_conf->enable_beacon ? "enabled" : "disabled");
1677
1678 if (bss_conf->enable_beacon)
1679 wl->set_bss_type = BSS_TYPE_IBSS;
1680 else
1681 wl->set_bss_type = BSS_TYPE_STA_BSS;
1682 do_join = true;
1683 }
1684
00236aed
JO		 1685 if (changed & BSS_CHANGED_CQM) {
1686 bool enable = false;
1687 if (bss_conf->cqm_rssi_thold)
1688 enable = true;
1689 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1690 bss_conf->cqm_rssi_thold,
1691 bss_conf->cqm_rssi_hyst);
1692 if (ret < 0)
1693 goto out;
1694 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1695 }
1696
30240fc7
JO		 1697 if ((changed & BSS_CHANGED_BSSID) &&
1698 /*
1699 * Now we know the correct bssid, so we send a new join command
1700 * and enable the BSSID filter
1701 */
1702 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
30240fc7 1703 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 1704
30240fc7 1705 ret = wl1271_cmd_build_null_data(wl);
a0cb7be4 1706 if (ret < 0)
30240fc7 1707 goto out_sleep;
30240fc7 1708
14b228a0
JO		 1709 /* filter out all packets not from this BSSID */
1710 wl1271_configure_filters(wl, 0);
1711
8bf29b0e
JO		 1712 /* Need to update the BSSID (for filtering etc) */
1713 do_join = true;
30240fc7
JO		 1714 }
1715
f5fc0f86
LC		 1716 if (changed & BSS_CHANGED_ASSOC) {
1717 if (bss_conf->assoc) {
ebba60c6 1718 u32 rates;
f5fc0f86 1719 wl->aid = bss_conf->aid;
830fb67b 1720 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
f5fc0f86 1721
ebba60c6
JO		 1722 /*
1723 * use basic rates from AP, and determine lowest rate
1724 * to use with control frames.
1725 */
1726 rates = bss_conf->basic_rates;
1727 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1728 rates);
1729 wl->basic_rate = wl1271_min_rate_get(wl);
1730 ret = wl1271_acx_rate_policies(wl);
1731 if (ret < 0)
1732 goto out_sleep;
1733
ae751bab
LC		 1734 /*
1735 * with wl1271, we don't need to update the
1736 * beacon_int and dtim_period, because the firmware
1737 * updates it by itself when the first beacon is
1738 * received after a join.
1739 */
f5fc0f86
LC		 1740 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1741 if (ret < 0)
1742 goto out_sleep;
1743
c2b2d99b
JO		 1744 /*
1745 * The SSID is intentionally set to NULL here - the
1746 * firmware will set the probe request with a
1747 * broadcast SSID regardless of what we set in the
1748 * template.
1749 */
1750 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1751 NULL, 0, wl->band);
1752
c1899554
JO		 1753 /* Enable the keep-alive feature */
1754 ret = wl1271_acx_keep_alive_mode(wl, true);
f5fc0f86
LC		 1755 if (ret < 0)
1756 goto out_sleep;
1757
40b359c6
JO		 1758 /*
1759 * This is awkward. The keep-alive configs must be done
1760 * *after* the join command, because otherwise it will
1761 * not work, but it must only be done *once* because
1762 * otherwise the firmware will start complaining.
1763 */
1764 do_keepalive = true;
1765
6ccbb92e
JO		 1766 /* enable the connection monitoring feature */
1767 ret = wl1271_acx_conn_monit_params(wl, true);
1768 if (ret < 0)
1769 goto out_sleep;
1770
f5fc0f86 1771 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 1772 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1773 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
f5fc0f86 1774 mode = STATION_POWER_SAVE_MODE;
d8c42c0c 1775 ret = wl1271_ps_set_mode(wl, mode, true);
f5fc0f86
LC		 1776 if (ret < 0)
1777 goto out_sleep;
1778 }
d94cd297
JO		 1779 } else {
1780 /* use defaults when not associated */
830fb67b 1781 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
d94cd297 1782 wl->aid = 0;
6ccbb92e 1783
ebba60c6
JO		 1784 /* revert back to minimum rates for the current band */
1785 wl1271_set_band_rate(wl);
1786 wl->basic_rate = wl1271_min_rate_get(wl);
1787 ret = wl1271_acx_rate_policies(wl);
1788 if (ret < 0)
1789 goto out_sleep;
1790
6ccbb92e
JO		 1791 /* disable connection monitor features */
1792 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 1793
1794 /* Disable the keep-alive feature */
1795 ret = wl1271_acx_keep_alive_mode(wl, false);
1796
6ccbb92e
JO		 1797 if (ret < 0)
1798 goto out_sleep;
f5fc0f86 1799 }
d94cd297 1800
f5fc0f86 1801 }
8a5a37a6 1802
f5fc0f86
LC		 1803 if (changed & BSS_CHANGED_ERP_SLOT) {
1804 if (bss_conf->use_short_slot)
1805 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1806 else
1807 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1808 if (ret < 0) {
1809 wl1271_warning("Set slot time failed %d", ret);
1810 goto out_sleep;
1811 }
1812 }
1813
1814 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1815 if (bss_conf->use_short_preamble)
1816 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1817 else
1818 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1819 }
1820
1821 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1822 if (bss_conf->use_cts_prot)
1823 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1824 else
1825 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1826 if (ret < 0) {
1827 wl1271_warning("Set ctsprotect failed %d", ret);
1828 goto out_sleep;
1829 }
1830 }
1831
8bf29b0e 1832 if (do_join) {
5da11dcd 1833 ret = wl1271_cmd_join(wl, wl->set_bss_type);
8bf29b0e
JO		 1834 if (ret < 0) {
1835 wl1271_warning("cmd join failed %d", ret);
1836 goto out_sleep;
1837 }
1838 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1839 }
1840
c1899554
JO		 1841 /*
1842 * The JOIN operation shuts down the firmware keep-alive as a side
1843 * effect, and the ACX_AID will start the keep-alive as a side effect.
1844 * Hence, for non-IBSS, the ACX_AID must always happen *after* the
1845 * JOIN operation, and the template config after the ACX_AID.
1846 */
1847 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1848 ret = wl1271_acx_aid(wl, wl->aid);
1849 if (ret < 0)
1850 goto out_sleep;
40b359c6
JO		 1851 }
1852
1853 if (do_keepalive) {
c1899554
JO		 1854 ret = wl1271_cmd_build_klv_null_data(wl);
1855 if (ret < 0)
1856 goto out_sleep;
1857 ret = wl1271_acx_keep_alive_config(
1858 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1859 ACX_KEEP_ALIVE_TPL_VALID);
1860 if (ret < 0)
1861 goto out_sleep;
1862 }
1863
f5fc0f86
LC		 1864out_sleep:
1865 wl1271_ps_elp_sleep(wl);
1866
1867out:
1868 mutex_unlock(&wl->mutex);
1869}
1870
c6999d83
KV		 1871static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1872 const struct ieee80211_tx_queue_params *params)
1873{
1874 struct wl1271 *wl = hw->priv;
4695dc91 1875 u8 ps_scheme;
c6999d83
KV		 1876 int ret;
1877
1878 mutex_lock(&wl->mutex);
1879
1880 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1881
c82c1dde
KV		 1882 ret = wl1271_ps_elp_wakeup(wl, false);
1883 if (ret < 0)
1884 goto out;
1885
b43316db 1886 /* the txop is confed in units of 32us by the mac80211, we need us */
c6999d83
KV		 1887 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1888 params->cw_min, params->cw_max,
b43316db 1889 params->aifs, params->txop << 5);
c6999d83 1890 if (ret < 0)
c82c1dde 1891 goto out_sleep;
c6999d83 1892
4695dc91
KV		 1893 if (params->uapsd)
1894 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1895 else
1896 ps_scheme = CONF_PS_SCHEME_LEGACY;
1897
c6999d83
KV		 1898 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1899 CONF_CHANNEL_TYPE_EDCF,
1900 wl1271_tx_get_queue(queue),
4695dc91 1901 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
c6999d83 1902 if (ret < 0)
c82c1dde
KV		 1903 goto out_sleep;
1904
1905out_sleep:
1906 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 1907
1908out:
1909 mutex_unlock(&wl->mutex);
1910
1911 return ret;
1912}
1913
f5fc0f86
LC		 1914
1915/* can't be const, mac80211 writes to this */
1916static struct ieee80211_rate wl1271_rates[] = {
1917 { .bitrate = 10,
2b60100b
JO		 1918 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1919 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 1920 { .bitrate = 20,
2b60100b
JO		 1921 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1922 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 1923 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1924 { .bitrate = 55,
2b60100b
JO		 1925 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1926 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 1927 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1928 { .bitrate = 110,
2b60100b
JO		 1929 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1930 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 1931 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1932 { .bitrate = 60,
2b60100b
JO		 1933 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1934 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 1935 { .bitrate = 90,
2b60100b
JO		 1936 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1937 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 1938 { .bitrate = 120,
2b60100b
JO		 1939 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1940 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 1941 { .bitrate = 180,
2b60100b
JO		 1942 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1943 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 1944 { .bitrate = 240,
2b60100b
JO		 1945 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1946 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 1947 { .bitrate = 360,
2b60100b
JO		 1948 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1949 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 1950 { .bitrate = 480,
2b60100b
JO		 1951 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1952 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 1953 { .bitrate = 540,
2b60100b
JO		 1954 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1955 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 1956};
1957
1958/* can't be const, mac80211 writes to this */
1959static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1
LC		 1960 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1961 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1962 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1963 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1964 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1965 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1966 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1967 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1968 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1969 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1970 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1971 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1972 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
f5fc0f86
LC		 1973};
1974
f876bb9a
JO		 1975/* mapping to indexes for wl1271_rates */
1976const static u8 wl1271_rate_to_idx_2ghz[] = {
1977 /* MCS rates are used only with 11n */
1978 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
1979 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
1980 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
1981 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
1982 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
1983 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
1984 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
1985 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
1986
1987 11, /* CONF_HW_RXTX_RATE_54 */
1988 10, /* CONF_HW_RXTX_RATE_48 */
1989 9, /* CONF_HW_RXTX_RATE_36 */
1990 8, /* CONF_HW_RXTX_RATE_24 */
1991
1992 /* TI-specific rate */
1993 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
1994
1995 7, /* CONF_HW_RXTX_RATE_18 */
1996 6, /* CONF_HW_RXTX_RATE_12 */
1997 3, /* CONF_HW_RXTX_RATE_11 */
1998 5, /* CONF_HW_RXTX_RATE_9 */
1999 4, /* CONF_HW_RXTX_RATE_6 */
2000 2, /* CONF_HW_RXTX_RATE_5_5 */
2001 1, /* CONF_HW_RXTX_RATE_2 */
2002 0 /* CONF_HW_RXTX_RATE_1 */
2003};
2004
f5fc0f86
LC		 2005/* can't be const, mac80211 writes to this */
2006static struct ieee80211_supported_band wl1271_band_2ghz = {
2007 .channels = wl1271_channels,
2008 .n_channels = ARRAY_SIZE(wl1271_channels),
2009 .bitrates = wl1271_rates,
2010 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2011};
2012
1ebec3d7
TP		 2013/* 5 GHz data rates for WL1273 */
2014static struct ieee80211_rate wl1271_rates_5ghz[] = {
2015 { .bitrate = 60,
2016 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2017 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2018 { .bitrate = 90,
2019 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2020 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2021 { .bitrate = 120,
2022 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2023 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2024 { .bitrate = 180,
2025 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2026 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2027 { .bitrate = 240,
2028 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2029 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2030 { .bitrate = 360,
2031 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2032 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2033 { .bitrate = 480,
2034 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2035 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2036 { .bitrate = 540,
2037 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2038 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2039};
2040
2041/* 5 GHz band channels for WL1273 */
2042static struct ieee80211_channel wl1271_channels_5ghz[] = {
2043 { .hw_value = 183, .center_freq = 4915},
2044 { .hw_value = 184, .center_freq = 4920},
2045 { .hw_value = 185, .center_freq = 4925},
2046 { .hw_value = 187, .center_freq = 4935},
2047 { .hw_value = 188, .center_freq = 4940},
2048 { .hw_value = 189, .center_freq = 4945},
2049 { .hw_value = 192, .center_freq = 4960},
2050 { .hw_value = 196, .center_freq = 4980},
2051 { .hw_value = 7, .center_freq = 5035},
2052 { .hw_value = 8, .center_freq = 5040},
2053 { .hw_value = 9, .center_freq = 5045},
2054 { .hw_value = 11, .center_freq = 5055},
2055 { .hw_value = 12, .center_freq = 5060},
2056 { .hw_value = 16, .center_freq = 5080},
2057 { .hw_value = 34, .center_freq = 5170},
2058 { .hw_value = 36, .center_freq = 5180},
2059 { .hw_value = 38, .center_freq = 5190},
2060 { .hw_value = 40, .center_freq = 5200},
2061 { .hw_value = 42, .center_freq = 5210},
2062 { .hw_value = 44, .center_freq = 5220},
2063 { .hw_value = 46, .center_freq = 5230},
2064 { .hw_value = 48, .center_freq = 5240},
2065 { .hw_value = 52, .center_freq = 5260},
2066 { .hw_value = 56, .center_freq = 5280},
2067 { .hw_value = 60, .center_freq = 5300},
2068 { .hw_value = 64, .center_freq = 5320},
2069 { .hw_value = 100, .center_freq = 5500},
2070 { .hw_value = 104, .center_freq = 5520},
2071 { .hw_value = 108, .center_freq = 5540},
2072 { .hw_value = 112, .center_freq = 5560},
2073 { .hw_value = 116, .center_freq = 5580},
2074 { .hw_value = 120, .center_freq = 5600},
2075 { .hw_value = 124, .center_freq = 5620},
2076 { .hw_value = 128, .center_freq = 5640},
2077 { .hw_value = 132, .center_freq = 5660},
2078 { .hw_value = 136, .center_freq = 5680},
2079 { .hw_value = 140, .center_freq = 5700},
2080 { .hw_value = 149, .center_freq = 5745},
2081 { .hw_value = 153, .center_freq = 5765},
2082 { .hw_value = 157, .center_freq = 5785},
2083 { .hw_value = 161, .center_freq = 5805},
2084 { .hw_value = 165, .center_freq = 5825},
2085};
2086
f876bb9a
JO		 2087/* mapping to indexes for wl1271_rates_5ghz */
2088const static u8 wl1271_rate_to_idx_5ghz[] = {
2089 /* MCS rates are used only with 11n */
2090 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2091 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2092 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2093 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2094 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2095 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2096 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2097 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2098
2099 7, /* CONF_HW_RXTX_RATE_54 */
2100 6, /* CONF_HW_RXTX_RATE_48 */
2101 5, /* CONF_HW_RXTX_RATE_36 */
2102 4, /* CONF_HW_RXTX_RATE_24 */
2103
2104 /* TI-specific rate */
2105 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2106
2107 3, /* CONF_HW_RXTX_RATE_18 */
2108 2, /* CONF_HW_RXTX_RATE_12 */
2109 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2110 1, /* CONF_HW_RXTX_RATE_9 */
2111 0, /* CONF_HW_RXTX_RATE_6 */
2112 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2113 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2114 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2115};
1ebec3d7
TP		 2116
2117static struct ieee80211_supported_band wl1271_band_5ghz = {
2118 .channels = wl1271_channels_5ghz,
2119 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2120 .bitrates = wl1271_rates_5ghz,
2121 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2122};
2123
f876bb9a
JO		 2124const static u8 *wl1271_band_rate_to_idx[] = {
2125 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2126 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2127};
2128
f5fc0f86
LC		 2129static const struct ieee80211_ops wl1271_ops = {
2130 .start = wl1271_op_start,
2131 .stop = wl1271_op_stop,
2132 .add_interface = wl1271_op_add_interface,
2133 .remove_interface = wl1271_op_remove_interface,
2134 .config = wl1271_op_config,
c87dec9f 2135 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 2136 .configure_filter = wl1271_op_configure_filter,
2137 .tx = wl1271_op_tx,
2138 .set_key = wl1271_op_set_key,
2139 .hw_scan = wl1271_op_hw_scan,
2140 .bss_info_changed = wl1271_op_bss_info_changed,
2141 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 2142 .conf_tx = wl1271_op_conf_tx,
c8c90873 2143 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 2144};
2145
f876bb9a
JO		 2146
2147u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2148{
2149 u8 idx;
2150
2151 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2152
2153 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2154 wl1271_error("Illegal RX rate from HW: %d", rate);
2155 return 0;
2156 }
2157
2158 idx = wl1271_band_rate_to_idx[wl->band][rate];
2159 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2160 wl1271_error("Unsupported RX rate from HW: %d", rate);
2161 return 0;
2162 }
2163
2164 return idx;
2165}
2166
7fc3a864
JO		 2167static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2168 struct device_attribute *attr,
2169 char *buf)
2170{
2171 struct wl1271 *wl = dev_get_drvdata(dev);
2172 ssize_t len;
2173
2174 /* FIXME: what's the maximum length of buf? page size?*/
2175 len = 500;
2176
2177 mutex_lock(&wl->mutex);
2178 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2179 wl->sg_enabled);
2180 mutex_unlock(&wl->mutex);
2181
2182 return len;
2183
2184}
2185
2186static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2187 struct device_attribute *attr,
2188 const char *buf, size_t count)
2189{
2190 struct wl1271 *wl = dev_get_drvdata(dev);
2191 unsigned long res;
2192 int ret;
2193
2194 ret = strict_strtoul(buf, 10, &res);
2195
2196 if (ret < 0) {
2197 wl1271_warning("incorrect value written to bt_coex_mode");
2198 return count;
2199 }
2200
2201 mutex_lock(&wl->mutex);
2202
2203 res = !!res;
2204
2205 if (res == wl->sg_enabled)
2206 goto out;
2207
2208 wl->sg_enabled = res;
2209
2210 if (wl->state == WL1271_STATE_OFF)
2211 goto out;
2212
2213 ret = wl1271_ps_elp_wakeup(wl, false);
2214 if (ret < 0)
2215 goto out;
2216
2217 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2218 wl1271_ps_elp_sleep(wl);
2219
2220 out:
2221 mutex_unlock(&wl->mutex);
2222 return count;
2223}
2224
2225static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2226 wl1271_sysfs_show_bt_coex_state,
2227 wl1271_sysfs_store_bt_coex_state);
2228
2d5e82b8 2229int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 2230{
2231 int ret;
2232
2233 if (wl->mac80211_registered)
2234 return 0;
2235
2236 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2237
2238 ret = ieee80211_register_hw(wl->hw);
2239 if (ret < 0) {
2240 wl1271_error("unable to register mac80211 hw: %d", ret);
2241 return ret;
2242 }
2243
2244 wl->mac80211_registered = true;
2245
2246 wl1271_notice("loaded");
2247
2248 return 0;
2249}
50b3eb4b 2250EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 2251
3b56dd6a
TP		 2252void wl1271_unregister_hw(struct wl1271 *wl)
2253{
2254 ieee80211_unregister_hw(wl->hw);
2255 wl->mac80211_registered = false;
2256
2257}
2258EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2259
2d5e82b8 2260int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 2261{
1e2b7976
JO		 2262 /* The tx descriptor buffer and the TKIP space. */
2263 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2264 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 2265
2266 /* unit us */
2267 /* FIXME: find a proper value */
2268 wl->hw->channel_change_time = 10000;
50c500ad 2269 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 2270
2271 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1922167b 2272 IEEE80211_HW_NOISE_DBM |
03442a33 2273 IEEE80211_HW_BEACON_FILTER |
0a34332f 2274 IEEE80211_HW_SUPPORTS_PS |
4695dc91 2275 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 2276 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed
JO		 2277 IEEE80211_HW_CONNECTION_MONITOR |
2278 IEEE80211_HW_SUPPORTS_CQM_RSSI;
f5fc0f86 2279
e0d8bbf0
JO		 2280 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2281 BIT(NL80211_IFTYPE_ADHOC);
f5fc0f86
LC		 2282 wl->hw->wiphy->max_scan_ssids = 1;
2283 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2284
1ebec3d7
TP		 2285 if (wl1271_11a_enabled())
2286 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2287
12bd8949 2288 wl->hw->queues = 4;
31627dc5 2289 wl->hw->max_rates = 1;
12bd8949 2290
8197b711 2291 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 2292
2293 return 0;
2294}
50b3eb4b 2295EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 2296
f5fc0f86 2297#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 2298
2d5e82b8 2299struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 2300{
f5fc0f86 2301 struct ieee80211_hw *hw;
3b56dd6a 2302 struct platform_device *plat_dev = NULL;
f5fc0f86 2303 struct wl1271 *wl;
a1dd8187 2304 int i, ret;
f5fc0f86
LC		 2305
2306 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2307 if (!hw) {
2308 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 2309 ret = -ENOMEM;
3b56dd6a
TP		 2310 goto err_hw_alloc;
2311 }
2312
2313 plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2314 if (!plat_dev) {
2315 wl1271_error("could not allocate platform_device");
2316 ret = -ENOMEM;
2317 goto err_plat_alloc;
f5fc0f86
LC		 2318 }
2319
3b56dd6a
TP		 2320 memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2321
f5fc0f86
LC		 2322 wl = hw->priv;
2323 memset(wl, 0, sizeof(*wl));
2324
01c09162
JO		 2325 INIT_LIST_HEAD(&wl->list);
2326
f5fc0f86 2327 wl->hw = hw;
3b56dd6a 2328 wl->plat_dev = plat_dev;
f5fc0f86
LC		 2329
2330 skb_queue_head_init(&wl->tx_queue);
2331
37b70a81 2332 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
f5fc0f86 2333 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 2334 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 2335 wl->default_key = 0;
f5fc0f86
LC		 2336 wl->rx_counter = 0;
2337 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2338 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
19ad0715 2339 wl->psm_entry_retry = 0;
f5fc0f86 2340 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 2341 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 2342 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b
JO		 2343 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2344 wl->sta_rate_set = 0;
8a5a37a6 2345 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 2346 wl->vif = NULL;
830fb67b 2347 wl->flags = 0;
7fc3a864 2348 wl->sg_enabled = true;
f5fc0f86 2349
be7078c2 2350 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 2351 wl->tx_frames[i] = NULL;
2352
2353 spin_lock_init(&wl->wl_lock);
2354
f5fc0f86
LC		 2355 wl->state = WL1271_STATE_OFF;
2356 mutex_init(&wl->mutex);
2357
c332a4b8
TP		 2358 /* Apply default driver configuration. */
2359 wl1271_conf_init(wl);
2360
2d5e82b8
TP		 2361 wl1271_debugfs_init(wl);
2362
a1dd8187 2363 /* Register platform device */
3b56dd6a 2364 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 2365 if (ret) {
2366 wl1271_error("couldn't register platform device");
2367 goto err_hw;
2368 }
3b56dd6a 2369 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 2370
7fc3a864 2371 /* Create sysfs file to control bt coex state */
3b56dd6a 2372 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 2373 if (ret < 0) {
2374 wl1271_error("failed to create sysfs file bt_coex_state");
2375 goto err_platform;
2376 }
a1dd8187 2377
c332a4b8 2378 return hw;
a1dd8187 2379
7fc3a864 2380err_platform:
3b56dd6a 2381 platform_device_unregister(wl->plat_dev);
7fc3a864 2382
a1dd8187 2383err_hw:
3b56dd6a
TP		 2384 wl1271_debugfs_exit(wl);
2385 kfree(plat_dev);
2386
2387err_plat_alloc:
2388 ieee80211_free_hw(hw);
2389
2390err_hw_alloc:
a1dd8187 2391
a1dd8187 2392 return ERR_PTR(ret);
c332a4b8 2393}
50b3eb4b 2394EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 2395
2396int wl1271_free_hw(struct wl1271 *wl)
2397{
3b56dd6a
TP		 2398 platform_device_unregister(wl->plat_dev);
2399 kfree(wl->plat_dev);
c332a4b8
TP		 2400
2401 wl1271_debugfs_exit(wl);
2402
c332a4b8
TP		 2403 vfree(wl->fw);
2404 wl->fw = NULL;
2405 kfree(wl->nvs);
2406 wl->nvs = NULL;
2407
2408 kfree(wl->fw_status);
2409 kfree(wl->tx_res_if);
2410
2411 ieee80211_free_hw(wl->hw);
2412
2413 return 0;
2414}
50b3eb4b
TP		 2415EXPORT_SYMBOL_GPL(wl1271_free_hw);
2416
2417MODULE_LICENSE("GPL");
2418MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2419MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
kernel source for telekom puls (alcatel/mediatek)