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