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