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