projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl1271: Removed duplicate code from module remove function.
[deliverable/linux.git] / drivers / net / wireless / wl12xx / wl1271_main.c
CommitLineData
f5fc0f86
LC		 1/*
2 * This file is part of wl1271
3 *
8bf29b0e 4 * Copyright (C) 2008-2010 Nokia Corporation
f5fc0f86
LC		 5 *
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 *
22 */
23
24#include <linux/module.h>
f5fc0f86
LC		 25#include <linux/firmware.h>
26#include <linux/delay.h>
f5fc0f86
LC		 27#include <linux/spi/spi.h>
28#include <linux/crc32.h>
29#include <linux/etherdevice.h>
1fba4974 30#include <linux/vmalloc.h>
01c09162 31#include <linux/inetdevice.h>
a1dd8187 32#include <linux/platform_device.h>
f5fc0f86
LC		 33
34#include "wl1271.h"
35#include "wl12xx_80211.h"
36#include "wl1271_reg.h"
7b048c52 37#include "wl1271_io.h"
f5fc0f86
LC		 38#include "wl1271_event.h"
39#include "wl1271_tx.h"
40#include "wl1271_rx.h"
41#include "wl1271_ps.h"
42#include "wl1271_init.h"
43#include "wl1271_debugfs.h"
44#include "wl1271_cmd.h"
45#include "wl1271_boot.h"
c8c90873 46#include "wl1271_testmode.h"
f5fc0f86 47
9ccd9217
JO		 48#define WL1271_BOOT_RETRIES 3
49
8a08048a
JO		 50static struct conf_drv_settings default_conf = {
51 .sg = {
1b00f546
JO		 52 .params = {
53 [CONF_SG_BT_PER_THRESHOLD] = 7500,
54 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
55 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
56 [CONF_SG_BT_LOAD_RATIO] = 50,
57 [CONF_SG_AUTO_PS_MODE] = 0,
58 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
59 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
60 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
61 [CONF_SG_BEACON_MISS_PERCENT] = 60,
62 [CONF_SG_RATE_ADAPT_THRESH] = 12,
63 [CONF_SG_RATE_ADAPT_SNR] = 0,
64 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
66 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
67 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
69 /* Note: with UPSD, this should be 4 */
70 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
71 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
73 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
74 /* Note: with UPDS, this should be 15 */
75 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
76 /* Note: with UPDS, this should be 50 */
77 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
78 /* Note: with UPDS, this should be 10 */
79 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
80 [CONF_SG_RXT] = 1200,
81 [CONF_SG_TXT] = 1000,
82 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
83 [CONF_SG_PS_POLL_TIMEOUT] = 10,
84 [CONF_SG_UPSD_TIMEOUT] = 10,
85 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
87 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
90 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
91 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
93 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
94 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
96 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
97 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
98 [CONF_SG_HV3_MAX_SERVED] = 6,
99 [CONF_SG_DHCP_TIME] = 5000,
100 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
101 },
102 .state = CONF_SG_PROTECTIVE,
8a08048a
JO		 103 },
104 .rx = {
105 .rx_msdu_life_time = 512000,
106 .packet_detection_threshold = 0,
107 .ps_poll_timeout = 15,
108 .upsd_timeout = 15,
109 .rts_threshold = 2347,
3ed8f2c6
LC		 110 .rx_cca_threshold = 0,
111 .irq_blk_threshold = 0xFFFF,
112 .irq_pkt_threshold = 0,
113 .irq_timeout = 600,
8a08048a
JO		 114 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
115 },
116 .tx = {
117 .tx_energy_detection = 0,
118 .rc_conf = {
ec078d94
JO		 119 .enabled_rates = CONF_HW_BIT_RATE_1MBPS |
120 CONF_HW_BIT_RATE_2MBPS,
8a08048a
JO		 121 .short_retry_limit = 10,
122 .long_retry_limit = 10,
123 .aflags = 0
45b531a8 124 },
8a08048a
JO		 125 .ac_conf_count = 4,
126 .ac_conf = {
127 [0] = {
128 .ac = CONF_TX_AC_BE,
129 .cw_min = 15,
130 .cw_max = 63,
131 .aifsn = 3,
132 .tx_op_limit = 0,
45b531a8 133 },
8a08048a
JO		 134 [1] = {
135 .ac = CONF_TX_AC_BK,
136 .cw_min = 15,
137 .cw_max = 63,
138 .aifsn = 7,
139 .tx_op_limit = 0,
45b531a8 140 },
8a08048a
JO		 141 [2] = {
142 .ac = CONF_TX_AC_VI,
143 .cw_min = 15,
144 .cw_max = 63,
145 .aifsn = CONF_TX_AIFS_PIFS,
146 .tx_op_limit = 3008,
147 },
148 [3] = {
149 .ac = CONF_TX_AC_VO,
150 .cw_min = 15,
151 .cw_max = 63,
152 .aifsn = CONF_TX_AIFS_PIFS,
153 .tx_op_limit = 1504,
45b531a8 154 },
51f2be24 155 },
8a08048a
JO		 156 .tid_conf_count = 7,
157 .tid_conf = {
158 [0] = {
159 .queue_id = 0,
160 .channel_type = CONF_CHANNEL_TYPE_DCF,
161 .tsid = CONF_TX_AC_BE,
162 .ps_scheme = CONF_PS_SCHEME_LEGACY,
163 .ack_policy = CONF_ACK_POLICY_LEGACY,
164 .apsd_conf = {0, 0},
165 },
166 [1] = {
167 .queue_id = 1,
168 .channel_type = CONF_CHANNEL_TYPE_DCF,
169 .tsid = CONF_TX_AC_BE,
170 .ps_scheme = CONF_PS_SCHEME_LEGACY,
171 .ack_policy = CONF_ACK_POLICY_LEGACY,
172 .apsd_conf = {0, 0},
51f2be24 173 },
8a08048a
JO		 174 [2] = {
175 .queue_id = 2,
176 .channel_type = CONF_CHANNEL_TYPE_DCF,
177 .tsid = CONF_TX_AC_BE,
178 .ps_scheme = CONF_PS_SCHEME_LEGACY,
179 .ack_policy = CONF_ACK_POLICY_LEGACY,
180 .apsd_conf = {0, 0},
51f2be24 181 },
8a08048a
JO		 182 [3] = {
183 .queue_id = 3,
184 .channel_type = CONF_CHANNEL_TYPE_DCF,
185 .tsid = CONF_TX_AC_BE,
186 .ps_scheme = CONF_PS_SCHEME_LEGACY,
187 .ack_policy = CONF_ACK_POLICY_LEGACY,
188 .apsd_conf = {0, 0},
189 },
190 [4] = {
191 .queue_id = 4,
192 .channel_type = CONF_CHANNEL_TYPE_DCF,
193 .tsid = CONF_TX_AC_BE,
194 .ps_scheme = CONF_PS_SCHEME_LEGACY,
195 .ack_policy = CONF_ACK_POLICY_LEGACY,
196 .apsd_conf = {0, 0},
197 },
198 [5] = {
199 .queue_id = 5,
200 .channel_type = CONF_CHANNEL_TYPE_DCF,
201 .tsid = CONF_TX_AC_BE,
202 .ps_scheme = CONF_PS_SCHEME_LEGACY,
203 .ack_policy = CONF_ACK_POLICY_LEGACY,
204 .apsd_conf = {0, 0},
205 },
206 [6] = {
207 .queue_id = 6,
208 .channel_type = CONF_CHANNEL_TYPE_DCF,
209 .tsid = CONF_TX_AC_BE,
210 .ps_scheme = CONF_PS_SCHEME_LEGACY,
211 .ack_policy = CONF_ACK_POLICY_LEGACY,
212 .apsd_conf = {0, 0},
213 }
214 },
215 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
3ed8f2c6
LC		 216 .tx_compl_timeout = 700,
217 .tx_compl_threshold = 4
8a08048a
JO		 218 },
219 .conn = {
220 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
221 .listen_interval = 0,
222 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
223 .bcn_filt_ie_count = 1,
224 .bcn_filt_ie = {
225 [0] = {
226 .ie = WLAN_EID_CHANNEL_SWITCH,
227 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
51f2be24 228 }
47fab7d5 229 },
3ed8f2c6 230 .synch_fail_thold = 10,
8a08048a
JO		 231 .bss_lose_timeout = 100,
232 .beacon_rx_timeout = 10000,
233 .broadcast_timeout = 20000,
234 .rx_broadcast_in_ps = 1,
3ed8f2c6 235 .ps_poll_threshold = 20,
8a08048a
JO		 236 .sig_trigger_count = 2,
237 .sig_trigger = {
238 [0] = {
239 .threshold = -75,
240 .pacing = 500,
241 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
242 .type = CONF_TRIG_EVENT_TYPE_EDGE,
243 .direction = CONF_TRIG_EVENT_DIR_LOW,
244 .hysteresis = 2,
245 .index = 0,
246 .enable = 1
47fab7d5 247 },
8a08048a
JO		 248 [1] = {
249 .threshold = -75,
250 .pacing = 500,
251 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
252 .type = CONF_TRIG_EVENT_TYPE_EDGE,
253 .direction = CONF_TRIG_EVENT_DIR_HIGH,
254 .hysteresis = 2,
255 .index = 1,
256 .enable = 1
257 }
258 },
259 .sig_weights = {
260 .rssi_bcn_avg_weight = 10,
261 .rssi_pkt_avg_weight = 10,
262 .snr_bcn_avg_weight = 10,
263 .snr_pkt_avg_weight = 10
11f70f97
JO		 264 },
265 .bet_enable = CONF_BET_MODE_ENABLE,
84502563 266 .bet_max_consecutive = 10,
19ad0715 267 .psm_entry_retries = 3
8a08048a
JO		 268 },
269 .init = {
8a08048a 270 .radioparam = {
152ee6e0 271 .fem = 1,
2b60100b 272 }
6e92b416
LC		 273 },
274 .itrim = {
275 .enable = false,
276 .timeout = 50000,
38ad2d87
JO		 277 },
278 .pm_config = {
279 .host_clk_settling_time = 5000,
280 .host_fast_wakeup_support = false
8a08048a
JO		 281 }
282};
283
a1dd8187
JO		 284static void wl1271_device_release(struct device *dev)
285{
286
287}
288
289static struct platform_device wl1271_device = {
290 .name = "wl1271",
291 .id = -1,
292
293 /* device model insists to have a release function */
294 .dev = {
295 .release = wl1271_device_release,
296 },
297};
298
01c09162
JO		 299static LIST_HEAD(wl_list);
300
8a08048a
JO		 301static void wl1271_conf_init(struct wl1271 *wl)
302{
2b60100b
JO		 303
304 /*
305 * This function applies the default configuration to the driver. This
306 * function is invoked upon driver load (spi probe.)
307 *
308 * The configuration is stored in a run-time structure in order to
309 * facilitate for run-time adjustment of any of the parameters. Making
310 * changes to the configuration structure will apply the new values on
311 * the next interface up (wl1271_op_start.)
312 */
313
314 /* apply driver default configuration */
8a08048a 315 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
2b60100b
JO		 316}
317
318
f5fc0f86
LC		 319static int wl1271_plt_init(struct wl1271 *wl)
320{
12419cce
LC		 321 struct conf_tx_ac_category *conf_ac;
322 struct conf_tx_tid *conf_tid;
323 int ret, i;
f5fc0f86 324
98b5dd5d 325 ret = wl1271_cmd_general_parms(wl);
4a90406b 326 if (ret < 0)
cc7defa3
LC		 327 return ret;
328
98b5dd5d 329 ret = wl1271_cmd_radio_parms(wl);
4a90406b 330 if (ret < 0)
cc7defa3
LC		 331 return ret;
332
12419cce
LC		 333 ret = wl1271_init_templates_config(wl);
334 if (ret < 0)
335 return ret;
336
f5fc0f86
LC		 337 ret = wl1271_acx_init_mem_config(wl);
338 if (ret < 0)
339 return ret;
340
12419cce
LC		 341 /* PHY layer config */
342 ret = wl1271_init_phy_config(wl);
343 if (ret < 0)
344 goto out_free_memmap;
345
346 ret = wl1271_acx_dco_itrim_params(wl);
347 if (ret < 0)
348 goto out_free_memmap;
349
350 /* Initialize connection monitoring thresholds */
351 ret = wl1271_acx_conn_monit_params(wl);
352 if (ret < 0)
353 goto out_free_memmap;
354
355 /* Bluetooth WLAN coexistence */
356 ret = wl1271_init_pta(wl);
357 if (ret < 0)
358 goto out_free_memmap;
359
360 /* Energy detection */
361 ret = wl1271_init_energy_detection(wl);
362 if (ret < 0)
363 goto out_free_memmap;
364
365 /* Default fragmentation threshold */
366 ret = wl1271_acx_frag_threshold(wl);
367 if (ret < 0)
368 goto out_free_memmap;
369
370 /* Default TID configuration */
371 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
372 conf_tid = &wl->conf.tx.tid_conf[i];
373 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
374 conf_tid->channel_type,
375 conf_tid->tsid,
376 conf_tid->ps_scheme,
377 conf_tid->ack_policy,
378 conf_tid->apsd_conf[0],
379 conf_tid->apsd_conf[1]);
380 if (ret < 0)
381 goto out_free_memmap;
382 }
383
384 /* Default AC configuration */
385 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
386 conf_ac = &wl->conf.tx.ac_conf[i];
387 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
388 conf_ac->cw_max, conf_ac->aifsn,
389 conf_ac->tx_op_limit);
390 if (ret < 0)
391 goto out_free_memmap;
392 }
393
394 /* Enable data path */
94210897 395 ret = wl1271_cmd_data_path(wl, 1);
f5fc0f86 396 if (ret < 0)
12419cce
LC		 397 goto out_free_memmap;
398
399 /* Configure for CAM power saving (ie. always active) */
400 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
401 if (ret < 0)
402 goto out_free_memmap;
403
404 /* configure PM */
405 ret = wl1271_acx_pm_config(wl);
406 if (ret < 0)
407 goto out_free_memmap;
f5fc0f86
LC		 408
409 return 0;
12419cce
LC		 410
411 out_free_memmap:
412 kfree(wl->target_mem_map);
413 wl->target_mem_map = NULL;
414
415 return ret;
f5fc0f86
LC		 416}
417
c15f63bf
JO		 418static void wl1271_fw_status(struct wl1271 *wl,
419 struct wl1271_fw_status *status)
f5fc0f86 420{
ac5e1e39 421 struct timespec ts;
f5fc0f86
LC		 422 u32 total = 0;
423 int i;
424
09a9c2b3 425 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
f5fc0f86
LC		 426
427 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
428 "drv_rx_counter = %d, tx_results_counter = %d)",
429 status->intr,
430 status->fw_rx_counter,
431 status->drv_rx_counter,
432 status->tx_results_counter);
433
434 /* update number of available TX blocks */
435 for (i = 0; i < NUM_TX_QUEUES; i++) {
d0f63b20
LC		 436 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
437 wl->tx_blocks_freed[i];
438
439 wl->tx_blocks_freed[i] =
440 le32_to_cpu(status->tx_released_blks[i]);
f5fc0f86
LC		 441 wl->tx_blocks_available += cnt;
442 total += cnt;
443 }
444
445 /* if more blocks are available now, schedule some tx work */
446 if (total && !skb_queue_empty(&wl->tx_queue))
a64b07e8 447 ieee80211_queue_work(wl->hw, &wl->tx_work);
f5fc0f86
LC		 448
449 /* update the host-chipset time offset */
ac5e1e39
JO		 450 getnstimeofday(&ts);
451 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
452 (s64)le32_to_cpu(status->fw_localtime);
f5fc0f86
LC		 453}
454
1e73eb62
JO		 455#define WL1271_IRQ_MAX_LOOPS 10
456
f5fc0f86
LC		 457static void wl1271_irq_work(struct work_struct *work)
458{
f5fc0f86 459 int ret;
c15f63bf 460 u32 intr;
1e73eb62
JO		 461 int loopcount = WL1271_IRQ_MAX_LOOPS;
462 unsigned long flags;
f5fc0f86
LC		 463 struct wl1271 *wl =
464 container_of(work, struct wl1271, irq_work);
465
466 mutex_lock(&wl->mutex);
467
468 wl1271_debug(DEBUG_IRQ, "IRQ work");
469
1e73eb62 470 if (unlikely(wl->state == WL1271_STATE_OFF))
f5fc0f86
LC		 471 goto out;
472
473 ret = wl1271_ps_elp_wakeup(wl, true);
474 if (ret < 0)
475 goto out;
476
1e73eb62
JO		 477 spin_lock_irqsave(&wl->wl_lock, flags);
478 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
479 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
480 spin_unlock_irqrestore(&wl->wl_lock, flags);
481 loopcount--;
482
483 wl1271_fw_status(wl, wl->fw_status);
484 intr = le32_to_cpu(wl->fw_status->intr);
485 if (!intr) {
486 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
487 continue;
488 }
f5fc0f86 489
1e73eb62 490 intr &= WL1271_INTR_MASK;
f5fc0f86 491
1e73eb62
JO		 492 if (intr & WL1271_ACX_INTR_DATA) {
493 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
1fd2794f 494
1e73eb62
JO		 495 /* check for tx results */
496 if (wl->fw_status->tx_results_counter !=
497 (wl->tx_results_count & 0xff))
498 wl1271_tx_complete(wl);
f5fc0f86 499
1e73eb62
JO		 500 wl1271_rx(wl, wl->fw_status);
501 }
f5fc0f86 502
1e73eb62
JO		 503 if (intr & WL1271_ACX_INTR_EVENT_A) {
504 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
505 wl1271_event_handle(wl, 0);
506 }
f5fc0f86 507
1e73eb62
JO		 508 if (intr & WL1271_ACX_INTR_EVENT_B) {
509 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
510 wl1271_event_handle(wl, 1);
511 }
f5fc0f86 512
1e73eb62
JO		 513 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
514 wl1271_debug(DEBUG_IRQ,
515 "WL1271_ACX_INTR_INIT_COMPLETE");
f5fc0f86 516
1e73eb62
JO		 517 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
518 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
519
520 spin_lock_irqsave(&wl->wl_lock, flags);
c15f63bf 521 }
f5fc0f86 522
1e73eb62
JO		 523 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
524 ieee80211_queue_work(wl->hw, &wl->irq_work);
525 else
526 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
527 spin_unlock_irqrestore(&wl->wl_lock, flags);
528
f5fc0f86
LC		 529 wl1271_ps_elp_sleep(wl);
530
531out:
532 mutex_unlock(&wl->mutex);
533}
534
f5fc0f86
LC		 535static int wl1271_fetch_firmware(struct wl1271 *wl)
536{
537 const struct firmware *fw;
538 int ret;
539
8197b711 540 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 541
542 if (ret < 0) {
543 wl1271_error("could not get firmware: %d", ret);
544 return ret;
545 }
546
547 if (fw->size % 4) {
548 wl1271_error("firmware size is not multiple of 32 bits: %zu",
549 fw->size);
550 ret = -EILSEQ;
551 goto out;
552 }
553
554 wl->fw_len = fw->size;
1fba4974 555 wl->fw = vmalloc(wl->fw_len);
f5fc0f86
LC		 556
557 if (!wl->fw) {
558 wl1271_error("could not allocate memory for the firmware");
559 ret = -ENOMEM;
560 goto out;
561 }
562
563 memcpy(wl->fw, fw->data, wl->fw_len);
564
565 ret = 0;
566
567out:
568 release_firmware(fw);
569
570 return ret;
571}
572
573static int wl1271_fetch_nvs(struct wl1271 *wl)
574{
575 const struct firmware *fw;
576 int ret;
577
8197b711 578 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 579
580 if (ret < 0) {
581 wl1271_error("could not get nvs file: %d", ret);
582 return ret;
583 }
584
152ee6e0
JO		 585 if (fw->size != sizeof(struct wl1271_nvs_file)) {
586 wl1271_error("nvs size is not as expected: %zu != %zu",
587 fw->size, sizeof(struct wl1271_nvs_file));
f5fc0f86
LC		 588 ret = -EILSEQ;
589 goto out;
590 }
591
152ee6e0 592 wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
f5fc0f86
LC		 593
594 if (!wl->nvs) {
595 wl1271_error("could not allocate memory for the nvs file");
596 ret = -ENOMEM;
597 goto out;
598 }
599
152ee6e0 600 memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
f5fc0f86 601
f5fc0f86
LC		 602out:
603 release_firmware(fw);
604
605 return ret;
606}
607
608static void wl1271_fw_wakeup(struct wl1271 *wl)
609{
610 u32 elp_reg;
611
612 elp_reg = ELPCTRL_WAKE_UP;
74621417 613 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
f5fc0f86
LC		 614}
615
616static int wl1271_setup(struct wl1271 *wl)
617{
618 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
619 if (!wl->fw_status)
620 return -ENOMEM;
621
622 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
623 if (!wl->tx_res_if) {
624 kfree(wl->fw_status);
625 return -ENOMEM;
626 }
627
628 INIT_WORK(&wl->irq_work, wl1271_irq_work);
629 INIT_WORK(&wl->tx_work, wl1271_tx_work);
630 return 0;
631}
632
633static int wl1271_chip_wakeup(struct wl1271 *wl)
634{
451de97a 635 struct wl1271_partition_set partition;
f5fc0f86
LC		 636 int ret = 0;
637
01ac17ec 638 msleep(WL1271_PRE_POWER_ON_SLEEP);
f5fc0f86
LC		 639 wl1271_power_on(wl);
640 msleep(WL1271_POWER_ON_SLEEP);
9b280722
TP		 641 wl1271_io_reset(wl);
642 wl1271_io_init(wl);
f5fc0f86
LC		 643
644 /* We don't need a real memory partition here, because we only want
645 * to use the registers at this point. */
451de97a
JO		 646 memset(&partition, 0, sizeof(partition));
647 partition.reg.start = REGISTERS_BASE;
648 partition.reg.size = REGISTERS_DOWN_SIZE;
649 wl1271_set_partition(wl, &partition);
f5fc0f86
LC		 650
651 /* ELP module wake up */
652 wl1271_fw_wakeup(wl);
653
654 /* whal_FwCtrl_BootSm() */
655
656 /* 0. read chip id from CHIP_ID */
7b048c52 657 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
f5fc0f86
LC		 658
659 /* 1. check if chip id is valid */
660
661 switch (wl->chip.id) {
662 case CHIP_ID_1271_PG10:
663 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
664 wl->chip.id);
665
666 ret = wl1271_setup(wl);
667 if (ret < 0)
9ccd9217 668 goto out;
f5fc0f86
LC		 669 break;
670 case CHIP_ID_1271_PG20:
671 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
672 wl->chip.id);
673
674 ret = wl1271_setup(wl);
675 if (ret < 0)
9ccd9217 676 goto out;
f5fc0f86
LC		 677 break;
678 default:
9ccd9217 679 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
f5fc0f86 680 ret = -ENODEV;
9ccd9217 681 goto out;
f5fc0f86
LC		 682 }
683
684 if (wl->fw == NULL) {
685 ret = wl1271_fetch_firmware(wl);
686 if (ret < 0)
9ccd9217 687 goto out;
f5fc0f86
LC		 688 }
689
690 /* No NVS from netlink, try to get it from the filesystem */
691 if (wl->nvs == NULL) {
692 ret = wl1271_fetch_nvs(wl);
693 if (ret < 0)
9ccd9217 694 goto out;
f5fc0f86
LC		 695 }
696
697out:
698 return ret;
699}
700
f5fc0f86
LC		 701int wl1271_plt_start(struct wl1271 *wl)
702{
9ccd9217 703 int retries = WL1271_BOOT_RETRIES;
f5fc0f86
LC		 704 int ret;
705
706 mutex_lock(&wl->mutex);
707
708 wl1271_notice("power up");
709
710 if (wl->state != WL1271_STATE_OFF) {
711 wl1271_error("cannot go into PLT state because not "
712 "in off state: %d", wl->state);
713 ret = -EBUSY;
714 goto out;
715 }
716
9ccd9217
JO		 717 while (retries) {
718 retries--;
719 ret = wl1271_chip_wakeup(wl);
720 if (ret < 0)
721 goto power_off;
f5fc0f86 722
9ccd9217
JO		 723 ret = wl1271_boot(wl);
724 if (ret < 0)
725 goto power_off;
eb5b28d0 726
9ccd9217
JO		 727 ret = wl1271_plt_init(wl);
728 if (ret < 0)
729 goto irq_disable;
bd5ea18f 730
9ccd9217
JO		 731 wl->state = WL1271_STATE_PLT;
732 wl1271_notice("firmware booted in PLT mode (%s)",
733 wl->chip.fw_ver);
734 goto out;
eb5b28d0 735
9ccd9217
JO		 736irq_disable:
737 wl1271_disable_interrupts(wl);
738 mutex_unlock(&wl->mutex);
739 /* Unlocking the mutex in the middle of handling is
740 inherently unsafe. In this case we deem it safe to do,
741 because we need to let any possibly pending IRQ out of
742 the system (and while we are WL1271_STATE_OFF the IRQ
743 work function will not do anything.) Also, any other
744 possible concurrent operations will fail due to the
745 current state, hence the wl1271 struct should be safe. */
746 cancel_work_sync(&wl->irq_work);
747 mutex_lock(&wl->mutex);
748power_off:
749 wl1271_power_off(wl);
750 }
f5fc0f86 751
9ccd9217
JO		 752 wl1271_error("firmware boot in PLT mode failed despite %d retries",
753 WL1271_BOOT_RETRIES);
f5fc0f86
LC		 754out:
755 mutex_unlock(&wl->mutex);
756
757 return ret;
758}
759
760int wl1271_plt_stop(struct wl1271 *wl)
761{
762 int ret = 0;
763
764 mutex_lock(&wl->mutex);
765
766 wl1271_notice("power down");
767
768 if (wl->state != WL1271_STATE_PLT) {
769 wl1271_error("cannot power down because not in PLT "
770 "state: %d", wl->state);
771 ret = -EBUSY;
772 goto out;
773 }
774
775 wl1271_disable_interrupts(wl);
776 wl1271_power_off(wl);
777
778 wl->state = WL1271_STATE_OFF;
bd5ea18f 779 wl->rx_counter = 0;
f5fc0f86
LC		 780
781out:
782 mutex_unlock(&wl->mutex);
783
784 return ret;
785}
786
787
788static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
789{
790 struct wl1271 *wl = hw->priv;
830fb67b
JO		 791 struct ieee80211_conf *conf = &hw->conf;
792 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
793 struct ieee80211_sta *sta = txinfo->control.sta;
794 unsigned long flags;
f5fc0f86 795
830fb67b
JO		 796 /* peek into the rates configured in the STA entry */
797 spin_lock_irqsave(&wl->wl_lock, flags);
798 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
799 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
800 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
801 }
802 spin_unlock_irqrestore(&wl->wl_lock, flags);
803
804 /* queue the packet */
f5fc0f86
LC		 805 skb_queue_tail(&wl->tx_queue, skb);
806
807 /*
808 * The chip specific setup must run before the first TX packet -
809 * before that, the tx_work will not be initialized!
810 */
811
a64b07e8 812 ieee80211_queue_work(wl->hw, &wl->tx_work);
f5fc0f86
LC		 813
814 /*
815 * The workqueue is slow to process the tx_queue and we need stop
816 * the queue here, otherwise the queue will get too long.
817 */
06f7bc7d
JO		 818 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
819 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
f5fc0f86 820
06f7bc7d
JO		 821 spin_lock_irqsave(&wl->wl_lock, flags);
822 ieee80211_stop_queues(wl->hw);
71449f8d 823 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
06f7bc7d 824 spin_unlock_irqrestore(&wl->wl_lock, flags);
f5fc0f86
LC		 825 }
826
827 return NETDEV_TX_OK;
828}
829
01c09162
JO		 830static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
831 void *arg)
832{
833 struct net_device *dev;
834 struct wireless_dev *wdev;
835 struct wiphy *wiphy;
836 struct ieee80211_hw *hw;
837 struct wl1271 *wl;
838 struct wl1271 *wl_temp;
839 struct in_device *idev;
840 struct in_ifaddr *ifa = arg;
841 int ret = 0;
842
843 /* FIXME: this ugly function should probably be implemented in the
844 * mac80211, and here should only be a simple callback handling actual
845 * setting of the filters. Now we need to dig up references to
846 * various structures to gain access to what we need.
847 * Also, because of this, there is no "initial" setting of the filter
848 * in "op_start", because we don't want to dig up struct net_device
849 * there - the filter will be set upon first change of the interface
850 * IP address. */
851
852 dev = ifa->ifa_dev->dev;
853
854 wdev = dev->ieee80211_ptr;
855 if (wdev == NULL)
17d7265c 856 return NOTIFY_DONE;
01c09162
JO		 857
858 wiphy = wdev->wiphy;
859 if (wiphy == NULL)
17d7265c 860 return NOTIFY_DONE;
01c09162
JO		 861
862 hw = wiphy_priv(wiphy);
863 if (hw == NULL)
17d7265c 864 return NOTIFY_DONE;
01c09162
JO		 865
866 /* Check that the interface is one supported by this driver. */
867 wl_temp = hw->priv;
868 list_for_each_entry(wl, &wl_list, list) {
869 if (wl == wl_temp)
870 break;
871 }
872 if (wl == NULL)
17d7265c 873 return NOTIFY_DONE;
01c09162
JO		 874
875 /* Get the interface IP address for the device. "ifa" will become
876 NULL if:
877 - there is no IPV4 protocol address configured
878 - there are multiple (virtual) IPV4 addresses configured
879 When "ifa" is NULL, filtering will be disabled.
880 */
881 ifa = NULL;
882 idev = dev->ip_ptr;
883 if (idev)
884 ifa = idev->ifa_list;
885
886 if (ifa && ifa->ifa_next)
887 ifa = NULL;
888
889 mutex_lock(&wl->mutex);
890
891 if (wl->state == WL1271_STATE_OFF)
892 goto out;
893
894 ret = wl1271_ps_elp_wakeup(wl, false);
895 if (ret < 0)
896 goto out;
897 if (ifa)
898 ret = wl1271_acx_arp_ip_filter(wl, true,
899 (u8 *)&ifa->ifa_address,
900 ACX_IPV4_VERSION);
901 else
902 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
903 ACX_IPV4_VERSION);
904 wl1271_ps_elp_sleep(wl);
905
906out:
907 mutex_unlock(&wl->mutex);
908
17d7265c 909 return NOTIFY_OK;
01c09162
JO		 910}
911
912static struct notifier_block wl1271_dev_notifier = {
913 .notifier_call = wl1271_dev_notify,
914};
915
916
f5fc0f86 917static int wl1271_op_start(struct ieee80211_hw *hw)
1b72aecd
JO		 918{
919 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
920
921 /*
922 * We have to delay the booting of the hardware because
923 * we need to know the local MAC address before downloading and
924 * initializing the firmware. The MAC address cannot be changed
925 * after boot, and without the proper MAC address, the firmware
926 * will not function properly.
927 *
928 * The MAC address is first known when the corresponding interface
929 * is added. That is where we will initialize the hardware.
930 */
931
932 return 0;
933}
934
935static void wl1271_op_stop(struct ieee80211_hw *hw)
936{
937 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
938}
939
940static int wl1271_op_add_interface(struct ieee80211_hw *hw,
941 struct ieee80211_vif *vif)
f5fc0f86
LC		 942{
943 struct wl1271 *wl = hw->priv;
9ccd9217 944 int retries = WL1271_BOOT_RETRIES;
f5fc0f86
LC		 945 int ret = 0;
946
1b72aecd
JO		 947 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
948 vif->type, vif->addr);
f5fc0f86
LC		 949
950 mutex_lock(&wl->mutex);
1b72aecd
JO		 951 if (wl->vif) {
952 ret = -EBUSY;
953 goto out;
954 }
955
956 wl->vif = vif;
957
958 switch (vif->type) {
959 case NL80211_IFTYPE_STATION:
960 wl->bss_type = BSS_TYPE_STA_BSS;
961 break;
962 case NL80211_IFTYPE_ADHOC:
963 wl->bss_type = BSS_TYPE_IBSS;
964 break;
965 default:
966 ret = -EOPNOTSUPP;
967 goto out;
968 }
969
970 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
f5fc0f86
LC		 971
972 if (wl->state != WL1271_STATE_OFF) {
973 wl1271_error("cannot start because not in off state: %d",
974 wl->state);
975 ret = -EBUSY;
976 goto out;
977 }
978
9ccd9217
JO		 979 while (retries) {
980 retries--;
981 ret = wl1271_chip_wakeup(wl);
982 if (ret < 0)
983 goto power_off;
f5fc0f86 984
9ccd9217
JO		 985 ret = wl1271_boot(wl);
986 if (ret < 0)
987 goto power_off;
f5fc0f86 988
9ccd9217
JO		 989 ret = wl1271_hw_init(wl);
990 if (ret < 0)
991 goto irq_disable;
f5fc0f86 992
9ccd9217
JO		 993 wl->state = WL1271_STATE_ON;
994 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
995 goto out;
eb5b28d0 996
9ccd9217
JO		 997irq_disable:
998 wl1271_disable_interrupts(wl);
999 mutex_unlock(&wl->mutex);
1000 /* Unlocking the mutex in the middle of handling is
1001 inherently unsafe. In this case we deem it safe to do,
1002 because we need to let any possibly pending IRQ out of
1003 the system (and while we are WL1271_STATE_OFF the IRQ
1004 work function will not do anything.) Also, any other
1005 possible concurrent operations will fail due to the
1006 current state, hence the wl1271 struct should be safe. */
1007 cancel_work_sync(&wl->irq_work);
1008 mutex_lock(&wl->mutex);
1009power_off:
1010 wl1271_power_off(wl);
1011 }
eb5b28d0 1012
9ccd9217
JO		 1013 wl1271_error("firmware boot failed despite %d retries",
1014 WL1271_BOOT_RETRIES);
eb5b28d0 1015out:
f5fc0f86
LC		 1016 mutex_unlock(&wl->mutex);
1017
01c09162
JO		 1018 if (!ret) {
1019 list_add(&wl->list, &wl_list);
1020 register_inetaddr_notifier(&wl1271_dev_notifier);
1021 }
1022
f5fc0f86
LC		 1023 return ret;
1024}
1025
1b72aecd
JO		 1026static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1027 struct ieee80211_vif *vif)
f5fc0f86
LC		 1028{
1029 struct wl1271 *wl = hw->priv;
1030 int i;
1031
1b72aecd
JO		 1032 mutex_lock(&wl->mutex);
1033 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
f5fc0f86 1034
1b72aecd 1035 wl1271_info("down");
f5fc0f86 1036
01c09162
JO		 1037 unregister_inetaddr_notifier(&wl1271_dev_notifier);
1038 list_del(&wl->list);
1039
f5fc0f86
LC		 1040 WARN_ON(wl->state != WL1271_STATE_ON);
1041
71449f8d 1042 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
f5fc0f86
LC		 1043 mutex_unlock(&wl->mutex);
1044 ieee80211_scan_completed(wl->hw, true);
1045 mutex_lock(&wl->mutex);
f5fc0f86
LC		 1046 }
1047
1048 wl->state = WL1271_STATE_OFF;
1049
1050 wl1271_disable_interrupts(wl);
1051
1052 mutex_unlock(&wl->mutex);
1053
1054 cancel_work_sync(&wl->irq_work);
1055 cancel_work_sync(&wl->tx_work);
f5fc0f86
LC		 1056
1057 mutex_lock(&wl->mutex);
1058
1059 /* let's notify MAC80211 about the remaining pending TX frames */
1060 wl1271_tx_flush(wl);
1061 wl1271_power_off(wl);
1062
1063 memset(wl->bssid, 0, ETH_ALEN);
1064 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1065 wl->ssid_len = 0;
f5fc0f86 1066 wl->bss_type = MAX_BSS_TYPE;
8a5a37a6 1067 wl->band = IEEE80211_BAND_2GHZ;
f5fc0f86
LC		 1068
1069 wl->rx_counter = 0;
19ad0715 1070 wl->psm_entry_retry = 0;
f5fc0f86
LC		 1071 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1072 wl->tx_blocks_available = 0;
1073 wl->tx_results_count = 0;
1074 wl->tx_packets_count = 0;
ac4e4ce5 1075 wl->tx_security_last_seq = 0;
04e36fc5 1076 wl->tx_security_seq = 0;
f5fc0f86
LC		 1077 wl->time_offset = 0;
1078 wl->session_counter = 0;
830fb67b
JO		 1079 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1080 wl->sta_rate_set = 0;
1081 wl->flags = 0;
1b72aecd 1082 wl->vif = NULL;
d6e19d13 1083
f5fc0f86
LC		 1084 for (i = 0; i < NUM_TX_QUEUES; i++)
1085 wl->tx_blocks_freed[i] = 0;
1086
1087 wl1271_debugfs_reset(wl);
1088 mutex_unlock(&wl->mutex);
1089}
1090
c7f43e45
LC		 1091static int wl1271_join_channel(struct wl1271 *wl, int channel)
1092{
e0d8bbf0 1093 int ret = 0;
c7f43e45
LC		 1094 /* we need to use a dummy BSSID for now */
1095 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1096 0xad, 0xbe, 0xef };
1097
1098 /* disable mac filter, so we hear everything */
1099 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1100
1101 wl->channel = channel;
1102 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1103
15305498
JO		 1104 /* the dummy join is performed always with STATION BSS type to allow
1105 also ad-hoc mode to listen to the surroundings without sending any
1106 beacons yet. */
1107 ret = wl1271_cmd_join(wl, BSS_TYPE_STA_BSS);
c7f43e45
LC		 1108 if (ret < 0)
1109 goto out;
1110
71449f8d 1111 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1112
1113out:
1114 return ret;
1115}
1116
1117static int wl1271_unjoin_channel(struct wl1271 *wl)
1118{
1119 int ret;
1120
1121 /* to stop listening to a channel, we disconnect */
1122 ret = wl1271_cmd_disconnect(wl);
1123 if (ret < 0)
1124 goto out;
1125
71449f8d 1126 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1127 wl->channel = 0;
1128 memset(wl->bssid, 0, ETH_ALEN);
1129 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1130
1131out:
1132 return ret;
1133}
1134
f5fc0f86
LC		 1135static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1136{
1137 struct wl1271 *wl = hw->priv;
1138 struct ieee80211_conf *conf = &hw->conf;
1139 int channel, ret = 0;
1140
1141 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1142
c7f43e45 1143 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
f5fc0f86
LC		 1144 channel,
1145 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45
LC		 1146 conf->power_level,
1147 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
f5fc0f86
LC		 1148
1149 mutex_lock(&wl->mutex);
1150
8a5a37a6
JO		 1151 wl->band = conf->channel->band;
1152
f5fc0f86
LC		 1153 ret = wl1271_ps_elp_wakeup(wl, false);
1154 if (ret < 0)
1155 goto out;
1156
c7f43e45 1157 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
71449f8d
JO		 1158 if (conf->flags & IEEE80211_CONF_IDLE &&
1159 test_bit(WL1271_FLAG_JOINED, &wl->flags))
c7f43e45 1160 wl1271_unjoin_channel(wl);
8f648c00 1161 else if (!(conf->flags & IEEE80211_CONF_IDLE))
c7f43e45 1162 wl1271_join_channel(wl, channel);
a6fe2313
JO		 1163
1164 if (conf->flags & IEEE80211_CONF_IDLE) {
830fb67b
JO		 1165 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1166 wl->sta_rate_set = 0;
1167 wl1271_acx_rate_policies(wl);
a6fe2313 1168 }
f5fc0f86
LC		 1169 }
1170
c7f43e45 1171 /* if the channel changes while joined, join again */
ddb01a5b
JO		 1172 if (channel != wl->channel &&
1173 test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1174 wl->channel = channel;
1175 /* FIXME: maybe use CMD_CHANNEL_SWITCH for this? */
15305498 1176 ret = wl1271_cmd_join(wl, wl->bss_type);
ddb01a5b
JO		 1177 if (ret < 0)
1178 wl1271_warning("cmd join to update channel failed %d",
1179 ret);
1180 } else
1181 wl->channel = channel;
c7f43e45 1182
71449f8d
JO		 1183 if (conf->flags & IEEE80211_CONF_PS &&
1184 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1185 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 1186
1187 /*
1188 * We enter PSM only if we're already associated.
1189 * If we're not, we'll enter it when joining an SSID,
1190 * through the bss_info_changed() hook.
1191 */
830fb67b 1192 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 1193 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c
JO		 1194 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1195 true);
af5e084b 1196 }
f5fc0f86 1197 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 1198 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 1199 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 1200
71449f8d 1201 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 1202
71449f8d 1203 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c
JO		 1204 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1205 true);
f5fc0f86
LC		 1206 }
1207
1208 if (conf->power_level != wl->power_level) {
1209 ret = wl1271_acx_tx_power(wl, conf->power_level);
1210 if (ret < 0)
c6317a54 1211 goto out_sleep;
f5fc0f86
LC		 1212
1213 wl->power_level = conf->power_level;
1214 }
1215
1216out_sleep:
1217 wl1271_ps_elp_sleep(wl);
1218
1219out:
1220 mutex_unlock(&wl->mutex);
1221
1222 return ret;
1223}
1224
b54853f1
JO		 1225struct wl1271_filter_params {
1226 bool enabled;
1227 int mc_list_length;
1228 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1229};
1230
c87dec9f
JO		 1231static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1232 struct dev_addr_list *mc_list)
1233{
c87dec9f 1234 struct wl1271_filter_params *fp;
c87dec9f
JO		 1235 int i;
1236
74441130 1237 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 1238 if (!fp) {
1239 wl1271_error("Out of memory setting filters.");
1240 return 0;
1241 }
1242
1243 /* update multicast filtering parameters */
b54853f1 1244 fp->enabled = true;
c87dec9f
JO		 1245 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1246 mc_count = 0;
b54853f1 1247 fp->enabled = false;
c87dec9f
JO		 1248 }
1249
1250 fp->mc_list_length = 0;
1251 for (i = 0; i < mc_count; i++) {
1252 if (mc_list->da_addrlen == ETH_ALEN) {
1253 memcpy(fp->mc_list[fp->mc_list_length],
1254 mc_list->da_addr, ETH_ALEN);
1255 fp->mc_list_length++;
1256 } else
1257 wl1271_warning("Unknown mc address length.");
74441130 1258 mc_list = mc_list->next;
c87dec9f
JO		 1259 }
1260
b54853f1 1261 return (u64)(unsigned long)fp;
c87dec9f 1262}
f5fc0f86 1263
b54853f1
JO		 1264#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1265 FIF_ALLMULTI | \
1266 FIF_FCSFAIL | \
1267 FIF_BCN_PRBRESP_PROMISC | \
1268 FIF_CONTROL | \
1269 FIF_OTHER_BSS)
1270
f5fc0f86
LC		 1271static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1272 unsigned int changed,
c87dec9f 1273 unsigned int *total, u64 multicast)
f5fc0f86 1274{
b54853f1 1275 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 1276 struct wl1271 *wl = hw->priv;
b54853f1 1277 int ret;
f5fc0f86
LC		 1278
1279 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1280
b54853f1
JO		 1281 mutex_lock(&wl->mutex);
1282
1283 if (wl->state == WL1271_STATE_OFF)
1284 goto out;
1285
1286 ret = wl1271_ps_elp_wakeup(wl, false);
1287 if (ret < 0)
1288 goto out;
1289
f5fc0f86
LC		 1290 *total &= WL1271_SUPPORTED_FILTERS;
1291 changed &= WL1271_SUPPORTED_FILTERS;
1292
b54853f1
JO		 1293 if (*total & FIF_ALLMULTI)
1294 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1295 else if (fp)
1296 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1297 fp->mc_list,
1298 fp->mc_list_length);
1299 if (ret < 0)
1300 goto out_sleep;
f5fc0f86 1301
b54853f1
JO		 1302 kfree(fp);
1303
1304 /* FIXME: We still need to set our filters properly */
c87dec9f 1305
b54853f1
JO		 1306 /* determine, whether supported filter values have changed */
1307 if (changed == 0)
1308 goto out_sleep;
c87dec9f 1309
b54853f1
JO		 1310 /* apply configured filters */
1311 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1312 if (ret < 0)
1313 goto out_sleep;
1314
1315out_sleep:
1316 wl1271_ps_elp_sleep(wl);
1317
1318out:
1319 mutex_unlock(&wl->mutex);
f5fc0f86
LC		 1320}
1321
1322static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1323 struct ieee80211_vif *vif,
1324 struct ieee80211_sta *sta,
1325 struct ieee80211_key_conf *key_conf)
1326{
1327 struct wl1271 *wl = hw->priv;
1328 const u8 *addr;
1329 int ret;
ac4e4ce5
JO		 1330 u32 tx_seq_32 = 0;
1331 u16 tx_seq_16 = 0;
f5fc0f86
LC		 1332 u8 key_type;
1333
1334 static const u8 bcast_addr[ETH_ALEN] =
1335 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1336
1337 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1338
1339 addr = sta ? sta->addr : bcast_addr;
1340
1341 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1342 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1343 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1344 key_conf->alg, key_conf->keyidx,
1345 key_conf->keylen, key_conf->flags);
1346 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1347
1348 if (is_zero_ether_addr(addr)) {
1349 /* We dont support TX only encryption */
1350 ret = -EOPNOTSUPP;
1351 goto out;
1352 }
1353
1354 mutex_lock(&wl->mutex);
1355
1356 ret = wl1271_ps_elp_wakeup(wl, false);
1357 if (ret < 0)
1358 goto out_unlock;
1359
1360 switch (key_conf->alg) {
1361 case ALG_WEP:
1362 key_type = KEY_WEP;
1363
1364 key_conf->hw_key_idx = key_conf->keyidx;
1365 break;
1366 case ALG_TKIP:
1367 key_type = KEY_TKIP;
1368
1369 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 1370 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1371 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86
LC		 1372 break;
1373 case ALG_CCMP:
1374 key_type = KEY_AES;
1375
1376 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
04e36fc5
JO		 1377 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1378 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86
LC		 1379 break;
1380 default:
1381 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1382
1383 ret = -EOPNOTSUPP;
1384 goto out_sleep;
1385 }
1386
1387 switch (cmd) {
1388 case SET_KEY:
1389 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1390 key_conf->keyidx, key_type,
1391 key_conf->keylen, key_conf->key,
ac4e4ce5 1392 addr, tx_seq_32, tx_seq_16);
f5fc0f86
LC		 1393 if (ret < 0) {
1394 wl1271_error("Could not add or replace key");
1395 goto out_sleep;
1396 }
ee444cf0
JO		 1397
1398 /* the default WEP key needs to be configured at least once */
1399 if (key_type == KEY_WEP) {
1400 ret = wl1271_cmd_set_default_wep_key(wl,
1401 wl->default_key);
1402 if (ret < 0)
1403 goto out_sleep;
1404 }
f5fc0f86
LC		 1405 break;
1406
1407 case DISABLE_KEY:
fddc7dd7
JO		 1408 /* The wl1271 does not allow to remove unicast keys - they
1409 will be cleared automatically on next CMD_JOIN. Ignore the
1410 request silently, as we dont want the mac80211 to emit
1411 an error message. */
1412 if (!is_broadcast_ether_addr(addr))
1413 break;
1414
f5fc0f86
LC		 1415 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1416 key_conf->keyidx, key_type,
1417 key_conf->keylen, key_conf->key,
ac4e4ce5 1418 addr, 0, 0);
f5fc0f86
LC		 1419 if (ret < 0) {
1420 wl1271_error("Could not remove key");
1421 goto out_sleep;
1422 }
1423 break;
1424
1425 default:
1426 wl1271_error("Unsupported key cmd 0x%x", cmd);
1427 ret = -EOPNOTSUPP;
1428 goto out_sleep;
1429
1430 break;
1431 }
1432
1433out_sleep:
1434 wl1271_ps_elp_sleep(wl);
1435
1436out_unlock:
1437 mutex_unlock(&wl->mutex);
1438
1439out:
1440 return ret;
1441}
1442
1443static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1444 struct cfg80211_scan_request *req)
1445{
1446 struct wl1271 *wl = hw->priv;
1447 int ret;
1448 u8 *ssid = NULL;
abb0b3bf 1449 size_t len = 0;
f5fc0f86
LC		 1450
1451 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1452
1453 if (req->n_ssids) {
1454 ssid = req->ssids[0].ssid;
abb0b3bf 1455 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 1456 }
1457
1458 mutex_lock(&wl->mutex);
1459
1460 ret = wl1271_ps_elp_wakeup(wl, false);
1461 if (ret < 0)
1462 goto out;
1463
abb0b3bf 1464 if (wl1271_11a_enabled())
818e3063
KV		 1465 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1466 req->ie, req->ie_len, 1, 0,
abb0b3bf
TP		 1467 WL1271_SCAN_BAND_DUAL, 3);
1468 else
818e3063
KV		 1469 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1470 req->ie, req->ie_len, 1, 0,
abb0b3bf 1471 WL1271_SCAN_BAND_2_4_GHZ, 3);
f5fc0f86
LC		 1472
1473 wl1271_ps_elp_sleep(wl);
1474
1475out:
1476 mutex_unlock(&wl->mutex);
1477
1478 return ret;
1479}
1480
1481static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1482{
1483 struct wl1271 *wl = hw->priv;
1484 int ret;
1485
1486 mutex_lock(&wl->mutex);
1487
1488 ret = wl1271_ps_elp_wakeup(wl, false);
1489 if (ret < 0)
1490 goto out;
1491
1492 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1493 if (ret < 0)
1494 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1495
1496 wl1271_ps_elp_sleep(wl);
1497
1498out:
1499 mutex_unlock(&wl->mutex);
1500
1501 return ret;
1502}
1503
30240fc7
JO		 1504static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1505{
1506 u8 *ptr = beacon->data +
1507 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1508
1509 /* find the location of the ssid in the beacon */
1510 while (ptr < beacon->data + beacon->len) {
1511 if (ptr[0] == WLAN_EID_SSID) {
1512 wl->ssid_len = ptr[1];
1513 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1514 return;
1515 }
1516 ptr += ptr[1];
1517 }
1518 wl1271_error("ad-hoc beacon template has no SSID!\n");
1519}
1520
f5fc0f86
LC		 1521static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1522 struct ieee80211_vif *vif,
1523 struct ieee80211_bss_conf *bss_conf,
1524 u32 changed)
1525{
1526 enum wl1271_cmd_ps_mode mode;
1527 struct wl1271 *wl = hw->priv;
8bf29b0e 1528 bool do_join = false;
f5fc0f86
LC		 1529 int ret;
1530
1531 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1532
1533 mutex_lock(&wl->mutex);
1534
1535 ret = wl1271_ps_elp_wakeup(wl, false);
1536 if (ret < 0)
1537 goto out;
1538
e0d8bbf0
JO		 1539 if (wl->bss_type == BSS_TYPE_IBSS) {
1540 /* FIXME: This implements rudimentary ad-hoc support -
1541 proper templates are on the wish list and notification
1542 on when they change. This patch will update the templates
30240fc7 1543 on every call to this function. */
e0d8bbf0
JO		 1544 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1545
1546 if (beacon) {
1547 struct ieee80211_hdr *hdr;
30240fc7
JO		 1548
1549 wl1271_ssid_set(wl, beacon);
e0d8bbf0
JO		 1550 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1551 beacon->data,
1552 beacon->len);
1553
1554 if (ret < 0) {
1555 dev_kfree_skb(beacon);
1556 goto out_sleep;
1557 }
1558
1559 hdr = (struct ieee80211_hdr *) beacon->data;
1560 hdr->frame_control = cpu_to_le16(
1561 IEEE80211_FTYPE_MGMT |
1562 IEEE80211_STYPE_PROBE_RESP);
1563
1564 ret = wl1271_cmd_template_set(wl,
1565 CMD_TEMPL_PROBE_RESPONSE,
1566 beacon->data,
1567 beacon->len);
1568 dev_kfree_skb(beacon);
1569 if (ret < 0)
1570 goto out_sleep;
8bf29b0e
JO		 1571
1572 /* Need to update the SSID (for filtering etc) */
1573 do_join = true;
e0d8bbf0
JO		 1574 }
1575 }
1576
30240fc7
JO		 1577 if ((changed & BSS_CHANGED_BSSID) &&
1578 /*
1579 * Now we know the correct bssid, so we send a new join command
1580 * and enable the BSSID filter
1581 */
1582 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1583 wl->rx_config |= CFG_BSSID_FILTER_EN;
1584 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1585 ret = wl1271_cmd_build_null_data(wl);
1586 if (ret < 0) {
1587 wl1271_warning("cmd buld null data failed %d",
1588 ret);
1589 goto out_sleep;
1590 }
1591
8bf29b0e
JO		 1592 /* Need to update the BSSID (for filtering etc) */
1593 do_join = true;
30240fc7
JO		 1594 }
1595
f5fc0f86
LC		 1596 if (changed & BSS_CHANGED_ASSOC) {
1597 if (bss_conf->assoc) {
1598 wl->aid = bss_conf->aid;
830fb67b 1599 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
f5fc0f86 1600
ae751bab
LC		 1601 /*
1602 * with wl1271, we don't need to update the
1603 * beacon_int and dtim_period, because the firmware
1604 * updates it by itself when the first beacon is
1605 * received after a join.
1606 */
f5fc0f86
LC		 1607 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1608 if (ret < 0)
1609 goto out_sleep;
1610
1611 ret = wl1271_acx_aid(wl, wl->aid);
1612 if (ret < 0)
1613 goto out_sleep;
1614
1615 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 1616 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1617 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
f5fc0f86 1618 mode = STATION_POWER_SAVE_MODE;
d8c42c0c 1619 ret = wl1271_ps_set_mode(wl, mode, true);
f5fc0f86
LC		 1620 if (ret < 0)
1621 goto out_sleep;
1622 }
d94cd297
JO		 1623 } else {
1624 /* use defaults when not associated */
830fb67b 1625 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
d94cd297 1626 wl->aid = 0;
f5fc0f86 1627 }
d94cd297 1628
f5fc0f86 1629 }
8a5a37a6 1630
f5fc0f86
LC		 1631 if (changed & BSS_CHANGED_ERP_SLOT) {
1632 if (bss_conf->use_short_slot)
1633 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1634 else
1635 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1636 if (ret < 0) {
1637 wl1271_warning("Set slot time failed %d", ret);
1638 goto out_sleep;
1639 }
1640 }
1641
1642 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1643 if (bss_conf->use_short_preamble)
1644 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1645 else
1646 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1647 }
1648
1649 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1650 if (bss_conf->use_cts_prot)
1651 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1652 else
1653 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1654 if (ret < 0) {
1655 wl1271_warning("Set ctsprotect failed %d", ret);
1656 goto out_sleep;
1657 }
1658 }
1659
8bf29b0e 1660 if (do_join) {
15305498 1661 ret = wl1271_cmd_join(wl, wl->bss_type);
8bf29b0e
JO		 1662 if (ret < 0) {
1663 wl1271_warning("cmd join failed %d", ret);
1664 goto out_sleep;
1665 }
1666 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1667 }
1668
f5fc0f86
LC		 1669out_sleep:
1670 wl1271_ps_elp_sleep(wl);
1671
1672out:
1673 mutex_unlock(&wl->mutex);
1674}
1675
c6999d83
KV		 1676static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1677 const struct ieee80211_tx_queue_params *params)
1678{
1679 struct wl1271 *wl = hw->priv;
4695dc91 1680 u8 ps_scheme;
c6999d83
KV		 1681 int ret;
1682
1683 mutex_lock(&wl->mutex);
1684
1685 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1686
c82c1dde
KV		 1687 ret = wl1271_ps_elp_wakeup(wl, false);
1688 if (ret < 0)
1689 goto out;
1690
b43316db 1691 /* the txop is confed in units of 32us by the mac80211, we need us */
c6999d83
KV		 1692 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1693 params->cw_min, params->cw_max,
b43316db 1694 params->aifs, params->txop << 5);
c6999d83 1695 if (ret < 0)
c82c1dde 1696 goto out_sleep;
c6999d83 1697
4695dc91
KV		 1698 if (params->uapsd)
1699 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1700 else
1701 ps_scheme = CONF_PS_SCHEME_LEGACY;
1702
c6999d83
KV		 1703 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1704 CONF_CHANNEL_TYPE_EDCF,
1705 wl1271_tx_get_queue(queue),
4695dc91 1706 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
c6999d83 1707 if (ret < 0)
c82c1dde
KV		 1708 goto out_sleep;
1709
1710out_sleep:
1711 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 1712
1713out:
1714 mutex_unlock(&wl->mutex);
1715
1716 return ret;
1717}
1718
f5fc0f86
LC		 1719
1720/* can't be const, mac80211 writes to this */
1721static struct ieee80211_rate wl1271_rates[] = {
1722 { .bitrate = 10,
2b60100b
JO		 1723 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1724 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 1725 { .bitrate = 20,
2b60100b
JO		 1726 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1727 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 1728 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1729 { .bitrate = 55,
2b60100b
JO		 1730 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1731 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 1732 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1733 { .bitrate = 110,
2b60100b
JO		 1734 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1735 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 1736 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1737 { .bitrate = 60,
2b60100b
JO		 1738 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1739 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 1740 { .bitrate = 90,
2b60100b
JO		 1741 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1742 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 1743 { .bitrate = 120,
2b60100b
JO		 1744 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1745 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 1746 { .bitrate = 180,
2b60100b
JO		 1747 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1748 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 1749 { .bitrate = 240,
2b60100b
JO		 1750 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1751 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 1752 { .bitrate = 360,
2b60100b
JO		 1753 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1754 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 1755 { .bitrate = 480,
2b60100b
JO		 1756 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1757 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 1758 { .bitrate = 540,
2b60100b
JO		 1759 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1760 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 1761};
1762
1763/* can't be const, mac80211 writes to this */
1764static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1
LC		 1765 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1766 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1767 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1768 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1769 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1770 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1771 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1772 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1773 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1774 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1775 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1776 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1777 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
f5fc0f86
LC		 1778};
1779
1780/* can't be const, mac80211 writes to this */
1781static struct ieee80211_supported_band wl1271_band_2ghz = {
1782 .channels = wl1271_channels,
1783 .n_channels = ARRAY_SIZE(wl1271_channels),
1784 .bitrates = wl1271_rates,
1785 .n_bitrates = ARRAY_SIZE(wl1271_rates),
1786};
1787
1ebec3d7
TP		 1788/* 5 GHz data rates for WL1273 */
1789static struct ieee80211_rate wl1271_rates_5ghz[] = {
1790 { .bitrate = 60,
1791 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1792 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1793 { .bitrate = 90,
1794 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1795 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1796 { .bitrate = 120,
1797 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1798 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1799 { .bitrate = 180,
1800 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1801 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1802 { .bitrate = 240,
1803 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1804 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1805 { .bitrate = 360,
1806 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1807 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1808 { .bitrate = 480,
1809 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1810 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1811 { .bitrate = 540,
1812 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1813 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1814};
1815
1816/* 5 GHz band channels for WL1273 */
1817static struct ieee80211_channel wl1271_channels_5ghz[] = {
1818 { .hw_value = 183, .center_freq = 4915},
1819 { .hw_value = 184, .center_freq = 4920},
1820 { .hw_value = 185, .center_freq = 4925},
1821 { .hw_value = 187, .center_freq = 4935},
1822 { .hw_value = 188, .center_freq = 4940},
1823 { .hw_value = 189, .center_freq = 4945},
1824 { .hw_value = 192, .center_freq = 4960},
1825 { .hw_value = 196, .center_freq = 4980},
1826 { .hw_value = 7, .center_freq = 5035},
1827 { .hw_value = 8, .center_freq = 5040},
1828 { .hw_value = 9, .center_freq = 5045},
1829 { .hw_value = 11, .center_freq = 5055},
1830 { .hw_value = 12, .center_freq = 5060},
1831 { .hw_value = 16, .center_freq = 5080},
1832 { .hw_value = 34, .center_freq = 5170},
1833 { .hw_value = 36, .center_freq = 5180},
1834 { .hw_value = 38, .center_freq = 5190},
1835 { .hw_value = 40, .center_freq = 5200},
1836 { .hw_value = 42, .center_freq = 5210},
1837 { .hw_value = 44, .center_freq = 5220},
1838 { .hw_value = 46, .center_freq = 5230},
1839 { .hw_value = 48, .center_freq = 5240},
1840 { .hw_value = 52, .center_freq = 5260},
1841 { .hw_value = 56, .center_freq = 5280},
1842 { .hw_value = 60, .center_freq = 5300},
1843 { .hw_value = 64, .center_freq = 5320},
1844 { .hw_value = 100, .center_freq = 5500},
1845 { .hw_value = 104, .center_freq = 5520},
1846 { .hw_value = 108, .center_freq = 5540},
1847 { .hw_value = 112, .center_freq = 5560},
1848 { .hw_value = 116, .center_freq = 5580},
1849 { .hw_value = 120, .center_freq = 5600},
1850 { .hw_value = 124, .center_freq = 5620},
1851 { .hw_value = 128, .center_freq = 5640},
1852 { .hw_value = 132, .center_freq = 5660},
1853 { .hw_value = 136, .center_freq = 5680},
1854 { .hw_value = 140, .center_freq = 5700},
1855 { .hw_value = 149, .center_freq = 5745},
1856 { .hw_value = 153, .center_freq = 5765},
1857 { .hw_value = 157, .center_freq = 5785},
1858 { .hw_value = 161, .center_freq = 5805},
1859 { .hw_value = 165, .center_freq = 5825},
1860};
1861
1862
1863static struct ieee80211_supported_band wl1271_band_5ghz = {
1864 .channels = wl1271_channels_5ghz,
1865 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
1866 .bitrates = wl1271_rates_5ghz,
1867 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
1868};
1869
f5fc0f86
LC		 1870static const struct ieee80211_ops wl1271_ops = {
1871 .start = wl1271_op_start,
1872 .stop = wl1271_op_stop,
1873 .add_interface = wl1271_op_add_interface,
1874 .remove_interface = wl1271_op_remove_interface,
1875 .config = wl1271_op_config,
c87dec9f 1876 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 1877 .configure_filter = wl1271_op_configure_filter,
1878 .tx = wl1271_op_tx,
1879 .set_key = wl1271_op_set_key,
1880 .hw_scan = wl1271_op_hw_scan,
1881 .bss_info_changed = wl1271_op_bss_info_changed,
1882 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 1883 .conf_tx = wl1271_op_conf_tx,
c8c90873 1884 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 1885};
1886
7fc3a864
JO		 1887static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
1888 struct device_attribute *attr,
1889 char *buf)
1890{
1891 struct wl1271 *wl = dev_get_drvdata(dev);
1892 ssize_t len;
1893
1894 /* FIXME: what's the maximum length of buf? page size?*/
1895 len = 500;
1896
1897 mutex_lock(&wl->mutex);
1898 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
1899 wl->sg_enabled);
1900 mutex_unlock(&wl->mutex);
1901
1902 return len;
1903
1904}
1905
1906static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
1907 struct device_attribute *attr,
1908 const char *buf, size_t count)
1909{
1910 struct wl1271 *wl = dev_get_drvdata(dev);
1911 unsigned long res;
1912 int ret;
1913
1914 ret = strict_strtoul(buf, 10, &res);
1915
1916 if (ret < 0) {
1917 wl1271_warning("incorrect value written to bt_coex_mode");
1918 return count;
1919 }
1920
1921 mutex_lock(&wl->mutex);
1922
1923 res = !!res;
1924
1925 if (res == wl->sg_enabled)
1926 goto out;
1927
1928 wl->sg_enabled = res;
1929
1930 if (wl->state == WL1271_STATE_OFF)
1931 goto out;
1932
1933 ret = wl1271_ps_elp_wakeup(wl, false);
1934 if (ret < 0)
1935 goto out;
1936
1937 wl1271_acx_sg_enable(wl, wl->sg_enabled);
1938 wl1271_ps_elp_sleep(wl);
1939
1940 out:
1941 mutex_unlock(&wl->mutex);
1942 return count;
1943}
1944
1945static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
1946 wl1271_sysfs_show_bt_coex_state,
1947 wl1271_sysfs_store_bt_coex_state);
1948
2d5e82b8 1949int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 1950{
1951 int ret;
1952
1953 if (wl->mac80211_registered)
1954 return 0;
1955
1956 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
1957
1958 ret = ieee80211_register_hw(wl->hw);
1959 if (ret < 0) {
1960 wl1271_error("unable to register mac80211 hw: %d", ret);
1961 return ret;
1962 }
1963
1964 wl->mac80211_registered = true;
1965
1966 wl1271_notice("loaded");
1967
1968 return 0;
1969}
50b3eb4b 1970EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 1971
2d5e82b8 1972int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 1973{
1e2b7976
JO		 1974 /* The tx descriptor buffer and the TKIP space. */
1975 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
1976 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 1977
1978 /* unit us */
1979 /* FIXME: find a proper value */
1980 wl->hw->channel_change_time = 10000;
1981
1982 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1922167b 1983 IEEE80211_HW_NOISE_DBM |
03442a33 1984 IEEE80211_HW_BEACON_FILTER |
0a34332f 1985 IEEE80211_HW_SUPPORTS_PS |
4695dc91 1986 IEEE80211_HW_SUPPORTS_UAPSD |
0a34332f 1987 IEEE80211_HW_HAS_RATE_CONTROL;
f5fc0f86 1988
e0d8bbf0
JO		 1989 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1990 BIT(NL80211_IFTYPE_ADHOC);
f5fc0f86
LC		 1991 wl->hw->wiphy->max_scan_ssids = 1;
1992 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
1993
1ebec3d7
TP		 1994 if (wl1271_11a_enabled())
1995 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
1996
12bd8949
KV		 1997 wl->hw->queues = 4;
1998
8197b711 1999 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 2000
2001 return 0;
2002}
50b3eb4b 2003EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 2004
f5fc0f86 2005#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 2006
2d5e82b8 2007struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 2008{
f5fc0f86
LC		 2009 struct ieee80211_hw *hw;
2010 struct wl1271 *wl;
a1dd8187 2011 int i, ret;
1b72aecd 2012 static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
f5fc0f86
LC		 2013
2014 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2015 if (!hw) {
2016 wl1271_error("could not alloc ieee80211_hw");
a1dd8187
JO		 2017 ret = -ENOMEM;
2018 goto err;
f5fc0f86
LC		 2019 }
2020
2021 wl = hw->priv;
2022 memset(wl, 0, sizeof(*wl));
2023
01c09162
JO		 2024 INIT_LIST_HEAD(&wl->list);
2025
f5fc0f86 2026 wl->hw = hw;
f5fc0f86
LC		 2027
2028 skb_queue_head_init(&wl->tx_queue);
2029
37b70a81 2030 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
f5fc0f86 2031 wl->channel = WL1271_DEFAULT_CHANNEL;
f5fc0f86 2032 wl->default_key = 0;
f5fc0f86
LC		 2033 wl->rx_counter = 0;
2034 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2035 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
19ad0715 2036 wl->psm_entry_retry = 0;
f5fc0f86 2037 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 2038 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
830fb67b
JO		 2039 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2040 wl->sta_rate_set = 0;
8a5a37a6 2041 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 2042 wl->vif = NULL;
830fb67b 2043 wl->flags = 0;
7fc3a864 2044 wl->sg_enabled = true;
f5fc0f86 2045
be7078c2 2046 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 2047 wl->tx_frames[i] = NULL;
2048
2049 spin_lock_init(&wl->wl_lock);
2050
f5fc0f86
LC		 2051 wl->state = WL1271_STATE_OFF;
2052 mutex_init(&wl->mutex);
2053
1b72aecd
JO		 2054 /*
2055 * FIXME: we should use a zero MAC address here, but for now we
2056 * generate a random Nokia address.
2057 */
2058 memcpy(wl->mac_addr, nokia_oui, 3);
2059 get_random_bytes(wl->mac_addr + 3, 3);
2060
c332a4b8
TP		 2061 /* Apply default driver configuration. */
2062 wl1271_conf_init(wl);
2063
2d5e82b8
TP		 2064 wl1271_debugfs_init(wl);
2065
a1dd8187
JO		 2066 /* Register platform device */
2067 ret = platform_device_register(&wl1271_device);
2068 if (ret) {
2069 wl1271_error("couldn't register platform device");
2070 goto err_hw;
2071 }
2072 dev_set_drvdata(&wl1271_device.dev, wl);
2073
7fc3a864
JO		 2074 /* Create sysfs file to control bt coex state */
2075 ret = device_create_file(&wl1271_device.dev, &dev_attr_bt_coex_state);
2076 if (ret < 0) {
2077 wl1271_error("failed to create sysfs file bt_coex_state");
2078 goto err_platform;
2079 }
a1dd8187 2080
c332a4b8 2081 return hw;
a1dd8187 2082
7fc3a864
JO		 2083err_platform:
2084 platform_device_unregister(&wl1271_device);
2085
a1dd8187
JO		 2086err_hw:
2087 ieee80211_unregister_hw(wl->hw);
2088
2089err:
2090 return ERR_PTR(ret);
c332a4b8 2091}
50b3eb4b 2092EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 2093
2094int wl1271_free_hw(struct wl1271 *wl)
2095{
a1dd8187 2096 platform_device_unregister(&wl1271_device);
c332a4b8
TP		 2097 ieee80211_unregister_hw(wl->hw);
2098
2099 wl1271_debugfs_exit(wl);
2100
2101 kfree(wl->target_mem_map);
2102 vfree(wl->fw);
2103 wl->fw = NULL;
2104 kfree(wl->nvs);
2105 wl->nvs = NULL;
2106
2107 kfree(wl->fw_status);
2108 kfree(wl->tx_res_if);
2109
2110 ieee80211_free_hw(wl->hw);
2111
2112 return 0;
2113}
50b3eb4b
TP		 2114EXPORT_SYMBOL_GPL(wl1271_free_hw);
2115
2116MODULE_LICENSE("GPL");
2117MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2118MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux kernel - Deliverables
This page took 0.226499 seconds and 5 git commands to generate.