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