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