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