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