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