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