diff options
author | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
---|---|---|
committer | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
commit | fcc9d2e5a6c89d22b8b773a64fb4ad21ac318446 (patch) | |
tree | a57612d1888735a2ec7972891b68c1ac5ec8faea /drivers/net/wireless/wl1251/main.c | |
parent | 8dea78da5cee153b8af9c07a2745f6c55057fe12 (diff) |
Diffstat (limited to 'drivers/net/wireless/wl1251/main.c')
-rw-r--r-- | drivers/net/wireless/wl1251/main.c | 1469 |
1 files changed, 1469 insertions, 0 deletions
diff --git a/drivers/net/wireless/wl1251/main.c b/drivers/net/wireless/wl1251/main.c new file mode 100644 index 00000000000..a14a48c99cd --- /dev/null +++ b/drivers/net/wireless/wl1251/main.c | |||
@@ -0,0 +1,1469 @@ | |||
1 | /* | ||
2 | * This file is part of wl1251 | ||
3 | * | ||
4 | * Copyright (C) 2008-2009 Nokia Corporation | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or | ||
7 | * modify it under the terms of the GNU General Public License | ||
8 | * version 2 as published by the Free Software Foundation. | ||
9 | * | ||
10 | * This program is distributed in the hope that it will be useful, but | ||
11 | * WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | * General Public License for more details. | ||
14 | * | ||
15 | * You should have received a copy of the GNU General Public License | ||
16 | * along with this program; if not, write to the Free Software | ||
17 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA | ||
18 | * 02110-1301 USA | ||
19 | * | ||
20 | */ | ||
21 | |||
22 | #include <linux/module.h> | ||
23 | #include <linux/interrupt.h> | ||
24 | #include <linux/firmware.h> | ||
25 | #include <linux/delay.h> | ||
26 | #include <linux/irq.h> | ||
27 | #include <linux/crc32.h> | ||
28 | #include <linux/etherdevice.h> | ||
29 | #include <linux/vmalloc.h> | ||
30 | #include <linux/slab.h> | ||
31 | |||
32 | #include "wl1251.h" | ||
33 | #include "wl12xx_80211.h" | ||
34 | #include "reg.h" | ||
35 | #include "io.h" | ||
36 | #include "cmd.h" | ||
37 | #include "event.h" | ||
38 | #include "tx.h" | ||
39 | #include "rx.h" | ||
40 | #include "ps.h" | ||
41 | #include "init.h" | ||
42 | #include "debugfs.h" | ||
43 | #include "boot.h" | ||
44 | |||
45 | void wl1251_enable_interrupts(struct wl1251 *wl) | ||
46 | { | ||
47 | wl->if_ops->enable_irq(wl); | ||
48 | } | ||
49 | |||
50 | void wl1251_disable_interrupts(struct wl1251 *wl) | ||
51 | { | ||
52 | wl->if_ops->disable_irq(wl); | ||
53 | } | ||
54 | |||
55 | static int wl1251_power_off(struct wl1251 *wl) | ||
56 | { | ||
57 | return wl->if_ops->power(wl, false); | ||
58 | } | ||
59 | |||
60 | static int wl1251_power_on(struct wl1251 *wl) | ||
61 | { | ||
62 | return wl->if_ops->power(wl, true); | ||
63 | } | ||
64 | |||
65 | static int wl1251_fetch_firmware(struct wl1251 *wl) | ||
66 | { | ||
67 | const struct firmware *fw; | ||
68 | struct device *dev = wiphy_dev(wl->hw->wiphy); | ||
69 | int ret; | ||
70 | |||
71 | ret = request_firmware(&fw, WL1251_FW_NAME, dev); | ||
72 | |||
73 | if (ret < 0) { | ||
74 | wl1251_error("could not get firmware: %d", ret); | ||
75 | return ret; | ||
76 | } | ||
77 | |||
78 | if (fw->size % 4) { | ||
79 | wl1251_error("firmware size is not multiple of 32 bits: %zu", | ||
80 | fw->size); | ||
81 | ret = -EILSEQ; | ||
82 | goto out; | ||
83 | } | ||
84 | |||
85 | wl->fw_len = fw->size; | ||
86 | wl->fw = vmalloc(wl->fw_len); | ||
87 | |||
88 | if (!wl->fw) { | ||
89 | wl1251_error("could not allocate memory for the firmware"); | ||
90 | ret = -ENOMEM; | ||
91 | goto out; | ||
92 | } | ||
93 | |||
94 | memcpy(wl->fw, fw->data, wl->fw_len); | ||
95 | |||
96 | ret = 0; | ||
97 | |||
98 | out: | ||
99 | release_firmware(fw); | ||
100 | |||
101 | return ret; | ||
102 | } | ||
103 | |||
104 | static int wl1251_fetch_nvs(struct wl1251 *wl) | ||
105 | { | ||
106 | const struct firmware *fw; | ||
107 | struct device *dev = wiphy_dev(wl->hw->wiphy); | ||
108 | int ret; | ||
109 | |||
110 | ret = request_firmware(&fw, WL1251_NVS_NAME, dev); | ||
111 | |||
112 | if (ret < 0) { | ||
113 | wl1251_error("could not get nvs file: %d", ret); | ||
114 | return ret; | ||
115 | } | ||
116 | |||
117 | if (fw->size % 4) { | ||
118 | wl1251_error("nvs size is not multiple of 32 bits: %zu", | ||
119 | fw->size); | ||
120 | ret = -EILSEQ; | ||
121 | goto out; | ||
122 | } | ||
123 | |||
124 | wl->nvs_len = fw->size; | ||
125 | wl->nvs = kmemdup(fw->data, wl->nvs_len, GFP_KERNEL); | ||
126 | |||
127 | if (!wl->nvs) { | ||
128 | wl1251_error("could not allocate memory for the nvs file"); | ||
129 | ret = -ENOMEM; | ||
130 | goto out; | ||
131 | } | ||
132 | |||
133 | ret = 0; | ||
134 | |||
135 | out: | ||
136 | release_firmware(fw); | ||
137 | |||
138 | return ret; | ||
139 | } | ||
140 | |||
141 | static void wl1251_fw_wakeup(struct wl1251 *wl) | ||
142 | { | ||
143 | u32 elp_reg; | ||
144 | |||
145 | elp_reg = ELPCTRL_WAKE_UP; | ||
146 | wl1251_write_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg); | ||
147 | elp_reg = wl1251_read_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR); | ||
148 | |||
149 | if (!(elp_reg & ELPCTRL_WLAN_READY)) | ||
150 | wl1251_warning("WLAN not ready"); | ||
151 | } | ||
152 | |||
153 | static int wl1251_chip_wakeup(struct wl1251 *wl) | ||
154 | { | ||
155 | int ret; | ||
156 | |||
157 | ret = wl1251_power_on(wl); | ||
158 | if (ret < 0) | ||
159 | return ret; | ||
160 | |||
161 | msleep(WL1251_POWER_ON_SLEEP); | ||
162 | wl->if_ops->reset(wl); | ||
163 | |||
164 | /* We don't need a real memory partition here, because we only want | ||
165 | * to use the registers at this point. */ | ||
166 | wl1251_set_partition(wl, | ||
167 | 0x00000000, | ||
168 | 0x00000000, | ||
169 | REGISTERS_BASE, | ||
170 | REGISTERS_DOWN_SIZE); | ||
171 | |||
172 | /* ELP module wake up */ | ||
173 | wl1251_fw_wakeup(wl); | ||
174 | |||
175 | /* whal_FwCtrl_BootSm() */ | ||
176 | |||
177 | /* 0. read chip id from CHIP_ID */ | ||
178 | wl->chip_id = wl1251_reg_read32(wl, CHIP_ID_B); | ||
179 | |||
180 | /* 1. check if chip id is valid */ | ||
181 | |||
182 | switch (wl->chip_id) { | ||
183 | case CHIP_ID_1251_PG12: | ||
184 | wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG12)", | ||
185 | wl->chip_id); | ||
186 | break; | ||
187 | case CHIP_ID_1251_PG11: | ||
188 | wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG11)", | ||
189 | wl->chip_id); | ||
190 | break; | ||
191 | case CHIP_ID_1251_PG10: | ||
192 | default: | ||
193 | wl1251_error("unsupported chip id: 0x%x", wl->chip_id); | ||
194 | ret = -ENODEV; | ||
195 | goto out; | ||
196 | } | ||
197 | |||
198 | if (wl->fw == NULL) { | ||
199 | ret = wl1251_fetch_firmware(wl); | ||
200 | if (ret < 0) | ||
201 | goto out; | ||
202 | } | ||
203 | |||
204 | if (wl->nvs == NULL && !wl->use_eeprom) { | ||
205 | /* No NVS from netlink, try to get it from the filesystem */ | ||
206 | ret = wl1251_fetch_nvs(wl); | ||
207 | if (ret < 0) | ||
208 | goto out; | ||
209 | } | ||
210 | |||
211 | out: | ||
212 | return ret; | ||
213 | } | ||
214 | |||
215 | #define WL1251_IRQ_LOOP_COUNT 10 | ||
216 | static void wl1251_irq_work(struct work_struct *work) | ||
217 | { | ||
218 | u32 intr, ctr = WL1251_IRQ_LOOP_COUNT; | ||
219 | struct wl1251 *wl = | ||
220 | container_of(work, struct wl1251, irq_work); | ||
221 | int ret; | ||
222 | |||
223 | mutex_lock(&wl->mutex); | ||
224 | |||
225 | wl1251_debug(DEBUG_IRQ, "IRQ work"); | ||
226 | |||
227 | if (wl->state == WL1251_STATE_OFF) | ||
228 | goto out; | ||
229 | |||
230 | ret = wl1251_ps_elp_wakeup(wl); | ||
231 | if (ret < 0) | ||
232 | goto out; | ||
233 | |||
234 | wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, WL1251_ACX_INTR_ALL); | ||
235 | |||
236 | intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR); | ||
237 | wl1251_debug(DEBUG_IRQ, "intr: 0x%x", intr); | ||
238 | |||
239 | do { | ||
240 | if (wl->data_path) { | ||
241 | wl->rx_counter = wl1251_mem_read32( | ||
242 | wl, wl->data_path->rx_control_addr); | ||
243 | |||
244 | /* We handle a frmware bug here */ | ||
245 | switch ((wl->rx_counter - wl->rx_handled) & 0xf) { | ||
246 | case 0: | ||
247 | wl1251_debug(DEBUG_IRQ, | ||
248 | "RX: FW and host in sync"); | ||
249 | intr &= ~WL1251_ACX_INTR_RX0_DATA; | ||
250 | intr &= ~WL1251_ACX_INTR_RX1_DATA; | ||
251 | break; | ||
252 | case 1: | ||
253 | wl1251_debug(DEBUG_IRQ, "RX: FW +1"); | ||
254 | intr |= WL1251_ACX_INTR_RX0_DATA; | ||
255 | intr &= ~WL1251_ACX_INTR_RX1_DATA; | ||
256 | break; | ||
257 | case 2: | ||
258 | wl1251_debug(DEBUG_IRQ, "RX: FW +2"); | ||
259 | intr |= WL1251_ACX_INTR_RX0_DATA; | ||
260 | intr |= WL1251_ACX_INTR_RX1_DATA; | ||
261 | break; | ||
262 | default: | ||
263 | wl1251_warning( | ||
264 | "RX: FW and host out of sync: %d", | ||
265 | wl->rx_counter - wl->rx_handled); | ||
266 | break; | ||
267 | } | ||
268 | |||
269 | wl->rx_handled = wl->rx_counter; | ||
270 | |||
271 | wl1251_debug(DEBUG_IRQ, "RX counter: %d", | ||
272 | wl->rx_counter); | ||
273 | } | ||
274 | |||
275 | intr &= wl->intr_mask; | ||
276 | |||
277 | if (intr == 0) { | ||
278 | wl1251_debug(DEBUG_IRQ, "INTR is 0"); | ||
279 | goto out_sleep; | ||
280 | } | ||
281 | |||
282 | if (intr & WL1251_ACX_INTR_RX0_DATA) { | ||
283 | wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX0_DATA"); | ||
284 | wl1251_rx(wl); | ||
285 | } | ||
286 | |||
287 | if (intr & WL1251_ACX_INTR_RX1_DATA) { | ||
288 | wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX1_DATA"); | ||
289 | wl1251_rx(wl); | ||
290 | } | ||
291 | |||
292 | if (intr & WL1251_ACX_INTR_TX_RESULT) { | ||
293 | wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_TX_RESULT"); | ||
294 | wl1251_tx_complete(wl); | ||
295 | } | ||
296 | |||
297 | if (intr & WL1251_ACX_INTR_EVENT_A) { | ||
298 | wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT_A"); | ||
299 | wl1251_event_handle(wl, 0); | ||
300 | } | ||
301 | |||
302 | if (intr & WL1251_ACX_INTR_EVENT_B) { | ||
303 | wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT_B"); | ||
304 | wl1251_event_handle(wl, 1); | ||
305 | } | ||
306 | |||
307 | if (intr & WL1251_ACX_INTR_INIT_COMPLETE) | ||
308 | wl1251_debug(DEBUG_IRQ, | ||
309 | "WL1251_ACX_INTR_INIT_COMPLETE"); | ||
310 | |||
311 | if (--ctr == 0) | ||
312 | break; | ||
313 | |||
314 | intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR); | ||
315 | } while (intr); | ||
316 | |||
317 | out_sleep: | ||
318 | wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, ~(wl->intr_mask)); | ||
319 | wl1251_ps_elp_sleep(wl); | ||
320 | |||
321 | out: | ||
322 | mutex_unlock(&wl->mutex); | ||
323 | } | ||
324 | |||
325 | static int wl1251_join(struct wl1251 *wl, u8 bss_type, u8 channel, | ||
326 | u16 beacon_interval, u8 dtim_period) | ||
327 | { | ||
328 | int ret; | ||
329 | |||
330 | ret = wl1251_acx_frame_rates(wl, DEFAULT_HW_GEN_TX_RATE, | ||
331 | DEFAULT_HW_GEN_MODULATION_TYPE, | ||
332 | wl->tx_mgmt_frm_rate, | ||
333 | wl->tx_mgmt_frm_mod); | ||
334 | if (ret < 0) | ||
335 | goto out; | ||
336 | |||
337 | |||
338 | ret = wl1251_cmd_join(wl, bss_type, channel, beacon_interval, | ||
339 | dtim_period); | ||
340 | if (ret < 0) | ||
341 | goto out; | ||
342 | |||
343 | ret = wl1251_event_wait(wl, JOIN_EVENT_COMPLETE_ID, 100); | ||
344 | if (ret < 0) | ||
345 | wl1251_warning("join timeout"); | ||
346 | |||
347 | out: | ||
348 | return ret; | ||
349 | } | ||
350 | |||
351 | static void wl1251_filter_work(struct work_struct *work) | ||
352 | { | ||
353 | struct wl1251 *wl = | ||
354 | container_of(work, struct wl1251, filter_work); | ||
355 | int ret; | ||
356 | |||
357 | mutex_lock(&wl->mutex); | ||
358 | |||
359 | if (wl->state == WL1251_STATE_OFF) | ||
360 | goto out; | ||
361 | |||
362 | ret = wl1251_ps_elp_wakeup(wl); | ||
363 | if (ret < 0) | ||
364 | goto out; | ||
365 | |||
366 | ret = wl1251_join(wl, wl->bss_type, wl->channel, wl->beacon_int, | ||
367 | wl->dtim_period); | ||
368 | if (ret < 0) | ||
369 | goto out_sleep; | ||
370 | |||
371 | out_sleep: | ||
372 | wl1251_ps_elp_sleep(wl); | ||
373 | |||
374 | out: | ||
375 | mutex_unlock(&wl->mutex); | ||
376 | } | ||
377 | |||
378 | static void wl1251_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb) | ||
379 | { | ||
380 | struct wl1251 *wl = hw->priv; | ||
381 | unsigned long flags; | ||
382 | |||
383 | skb_queue_tail(&wl->tx_queue, skb); | ||
384 | |||
385 | /* | ||
386 | * The chip specific setup must run before the first TX packet - | ||
387 | * before that, the tx_work will not be initialized! | ||
388 | */ | ||
389 | |||
390 | ieee80211_queue_work(wl->hw, &wl->tx_work); | ||
391 | |||
392 | /* | ||
393 | * The workqueue is slow to process the tx_queue and we need stop | ||
394 | * the queue here, otherwise the queue will get too long. | ||
395 | */ | ||
396 | if (skb_queue_len(&wl->tx_queue) >= WL1251_TX_QUEUE_HIGH_WATERMARK) { | ||
397 | wl1251_debug(DEBUG_TX, "op_tx: tx_queue full, stop queues"); | ||
398 | |||
399 | spin_lock_irqsave(&wl->wl_lock, flags); | ||
400 | ieee80211_stop_queues(wl->hw); | ||
401 | wl->tx_queue_stopped = true; | ||
402 | spin_unlock_irqrestore(&wl->wl_lock, flags); | ||
403 | } | ||
404 | } | ||
405 | |||
406 | static int wl1251_op_start(struct ieee80211_hw *hw) | ||
407 | { | ||
408 | struct wl1251 *wl = hw->priv; | ||
409 | struct wiphy *wiphy = hw->wiphy; | ||
410 | int ret = 0; | ||
411 | |||
412 | wl1251_debug(DEBUG_MAC80211, "mac80211 start"); | ||
413 | |||
414 | mutex_lock(&wl->mutex); | ||
415 | |||
416 | if (wl->state != WL1251_STATE_OFF) { | ||
417 | wl1251_error("cannot start because not in off state: %d", | ||
418 | wl->state); | ||
419 | ret = -EBUSY; | ||
420 | goto out; | ||
421 | } | ||
422 | |||
423 | ret = wl1251_chip_wakeup(wl); | ||
424 | if (ret < 0) | ||
425 | goto out; | ||
426 | |||
427 | ret = wl1251_boot(wl); | ||
428 | if (ret < 0) | ||
429 | goto out; | ||
430 | |||
431 | ret = wl1251_hw_init(wl); | ||
432 | if (ret < 0) | ||
433 | goto out; | ||
434 | |||
435 | ret = wl1251_acx_station_id(wl); | ||
436 | if (ret < 0) | ||
437 | goto out; | ||
438 | |||
439 | wl->state = WL1251_STATE_ON; | ||
440 | |||
441 | wl1251_info("firmware booted (%s)", wl->fw_ver); | ||
442 | |||
443 | /* update hw/fw version info in wiphy struct */ | ||
444 | wiphy->hw_version = wl->chip_id; | ||
445 | strncpy(wiphy->fw_version, wl->fw_ver, sizeof(wiphy->fw_version)); | ||
446 | |||
447 | out: | ||
448 | if (ret < 0) | ||
449 | wl1251_power_off(wl); | ||
450 | |||
451 | mutex_unlock(&wl->mutex); | ||
452 | |||
453 | return ret; | ||
454 | } | ||
455 | |||
456 | static void wl1251_op_stop(struct ieee80211_hw *hw) | ||
457 | { | ||
458 | struct wl1251 *wl = hw->priv; | ||
459 | |||
460 | wl1251_info("down"); | ||
461 | |||
462 | wl1251_debug(DEBUG_MAC80211, "mac80211 stop"); | ||
463 | |||
464 | mutex_lock(&wl->mutex); | ||
465 | |||
466 | WARN_ON(wl->state != WL1251_STATE_ON); | ||
467 | |||
468 | if (wl->scanning) { | ||
469 | ieee80211_scan_completed(wl->hw, true); | ||
470 | wl->scanning = false; | ||
471 | } | ||
472 | |||
473 | wl->state = WL1251_STATE_OFF; | ||
474 | |||
475 | wl1251_disable_interrupts(wl); | ||
476 | |||
477 | mutex_unlock(&wl->mutex); | ||
478 | |||
479 | cancel_work_sync(&wl->irq_work); | ||
480 | cancel_work_sync(&wl->tx_work); | ||
481 | cancel_work_sync(&wl->filter_work); | ||
482 | |||
483 | mutex_lock(&wl->mutex); | ||
484 | |||
485 | /* let's notify MAC80211 about the remaining pending TX frames */ | ||
486 | wl1251_tx_flush(wl); | ||
487 | wl1251_power_off(wl); | ||
488 | |||
489 | memset(wl->bssid, 0, ETH_ALEN); | ||
490 | wl->listen_int = 1; | ||
491 | wl->bss_type = MAX_BSS_TYPE; | ||
492 | |||
493 | wl->data_in_count = 0; | ||
494 | wl->rx_counter = 0; | ||
495 | wl->rx_handled = 0; | ||
496 | wl->rx_current_buffer = 0; | ||
497 | wl->rx_last_id = 0; | ||
498 | wl->next_tx_complete = 0; | ||
499 | wl->elp = false; | ||
500 | wl->station_mode = STATION_ACTIVE_MODE; | ||
501 | wl->tx_queue_stopped = false; | ||
502 | wl->power_level = WL1251_DEFAULT_POWER_LEVEL; | ||
503 | wl->rssi_thold = 0; | ||
504 | wl->channel = WL1251_DEFAULT_CHANNEL; | ||
505 | |||
506 | wl1251_debugfs_reset(wl); | ||
507 | |||
508 | mutex_unlock(&wl->mutex); | ||
509 | } | ||
510 | |||
511 | static int wl1251_op_add_interface(struct ieee80211_hw *hw, | ||
512 | struct ieee80211_vif *vif) | ||
513 | { | ||
514 | struct wl1251 *wl = hw->priv; | ||
515 | int ret = 0; | ||
516 | |||
517 | wl1251_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM", | ||
518 | vif->type, vif->addr); | ||
519 | |||
520 | mutex_lock(&wl->mutex); | ||
521 | if (wl->vif) { | ||
522 | ret = -EBUSY; | ||
523 | goto out; | ||
524 | } | ||
525 | |||
526 | wl->vif = vif; | ||
527 | |||
528 | switch (vif->type) { | ||
529 | case NL80211_IFTYPE_STATION: | ||
530 | wl->bss_type = BSS_TYPE_STA_BSS; | ||
531 | break; | ||
532 | case NL80211_IFTYPE_ADHOC: | ||
533 | wl->bss_type = BSS_TYPE_IBSS; | ||
534 | break; | ||
535 | default: | ||
536 | ret = -EOPNOTSUPP; | ||
537 | goto out; | ||
538 | } | ||
539 | |||
540 | if (memcmp(wl->mac_addr, vif->addr, ETH_ALEN)) { | ||
541 | memcpy(wl->mac_addr, vif->addr, ETH_ALEN); | ||
542 | SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr); | ||
543 | ret = wl1251_acx_station_id(wl); | ||
544 | if (ret < 0) | ||
545 | goto out; | ||
546 | } | ||
547 | |||
548 | out: | ||
549 | mutex_unlock(&wl->mutex); | ||
550 | return ret; | ||
551 | } | ||
552 | |||
553 | static void wl1251_op_remove_interface(struct ieee80211_hw *hw, | ||
554 | struct ieee80211_vif *vif) | ||
555 | { | ||
556 | struct wl1251 *wl = hw->priv; | ||
557 | |||
558 | mutex_lock(&wl->mutex); | ||
559 | wl1251_debug(DEBUG_MAC80211, "mac80211 remove interface"); | ||
560 | wl->vif = NULL; | ||
561 | mutex_unlock(&wl->mutex); | ||
562 | } | ||
563 | |||
564 | static int wl1251_build_qos_null_data(struct wl1251 *wl) | ||
565 | { | ||
566 | struct ieee80211_qos_hdr template; | ||
567 | |||
568 | memset(&template, 0, sizeof(template)); | ||
569 | |||
570 | memcpy(template.addr1, wl->bssid, ETH_ALEN); | ||
571 | memcpy(template.addr2, wl->mac_addr, ETH_ALEN); | ||
572 | memcpy(template.addr3, wl->bssid, ETH_ALEN); | ||
573 | |||
574 | template.frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | | ||
575 | IEEE80211_STYPE_QOS_NULLFUNC | | ||
576 | IEEE80211_FCTL_TODS); | ||
577 | |||
578 | /* FIXME: not sure what priority to use here */ | ||
579 | template.qos_ctrl = cpu_to_le16(0); | ||
580 | |||
581 | return wl1251_cmd_template_set(wl, CMD_QOS_NULL_DATA, &template, | ||
582 | sizeof(template)); | ||
583 | } | ||
584 | |||
585 | static int wl1251_op_config(struct ieee80211_hw *hw, u32 changed) | ||
586 | { | ||
587 | struct wl1251 *wl = hw->priv; | ||
588 | struct ieee80211_conf *conf = &hw->conf; | ||
589 | int channel, ret = 0; | ||
590 | |||
591 | channel = ieee80211_frequency_to_channel(conf->channel->center_freq); | ||
592 | |||
593 | wl1251_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d", | ||
594 | channel, | ||
595 | conf->flags & IEEE80211_CONF_PS ? "on" : "off", | ||
596 | conf->power_level); | ||
597 | |||
598 | mutex_lock(&wl->mutex); | ||
599 | |||
600 | ret = wl1251_ps_elp_wakeup(wl); | ||
601 | if (ret < 0) | ||
602 | goto out; | ||
603 | |||
604 | if (channel != wl->channel) { | ||
605 | wl->channel = channel; | ||
606 | |||
607 | ret = wl1251_join(wl, wl->bss_type, wl->channel, | ||
608 | wl->beacon_int, wl->dtim_period); | ||
609 | if (ret < 0) | ||
610 | goto out_sleep; | ||
611 | } | ||
612 | |||
613 | if (conf->flags & IEEE80211_CONF_PS && !wl->psm_requested) { | ||
614 | wl1251_debug(DEBUG_PSM, "psm enabled"); | ||
615 | |||
616 | wl->psm_requested = true; | ||
617 | |||
618 | wl->dtim_period = conf->ps_dtim_period; | ||
619 | |||
620 | ret = wl1251_acx_wr_tbtt_and_dtim(wl, wl->beacon_int, | ||
621 | wl->dtim_period); | ||
622 | |||
623 | /* | ||
624 | * mac80211 enables PSM only if we're already associated. | ||
625 | */ | ||
626 | ret = wl1251_ps_set_mode(wl, STATION_POWER_SAVE_MODE); | ||
627 | if (ret < 0) | ||
628 | goto out_sleep; | ||
629 | } else if (!(conf->flags & IEEE80211_CONF_PS) && | ||
630 | wl->psm_requested) { | ||
631 | wl1251_debug(DEBUG_PSM, "psm disabled"); | ||
632 | |||
633 | wl->psm_requested = false; | ||
634 | |||
635 | if (wl->station_mode != STATION_ACTIVE_MODE) { | ||
636 | ret = wl1251_ps_set_mode(wl, STATION_ACTIVE_MODE); | ||
637 | if (ret < 0) | ||
638 | goto out_sleep; | ||
639 | } | ||
640 | } | ||
641 | |||
642 | if (changed & IEEE80211_CONF_CHANGE_IDLE) { | ||
643 | if (conf->flags & IEEE80211_CONF_IDLE) { | ||
644 | ret = wl1251_ps_set_mode(wl, STATION_IDLE); | ||
645 | if (ret < 0) | ||
646 | goto out_sleep; | ||
647 | } else { | ||
648 | ret = wl1251_ps_set_mode(wl, STATION_ACTIVE_MODE); | ||
649 | if (ret < 0) | ||
650 | goto out_sleep; | ||
651 | ret = wl1251_join(wl, wl->bss_type, wl->channel, | ||
652 | wl->beacon_int, wl->dtim_period); | ||
653 | if (ret < 0) | ||
654 | goto out_sleep; | ||
655 | } | ||
656 | } | ||
657 | |||
658 | if (conf->power_level != wl->power_level) { | ||
659 | ret = wl1251_acx_tx_power(wl, conf->power_level); | ||
660 | if (ret < 0) | ||
661 | goto out_sleep; | ||
662 | |||
663 | wl->power_level = conf->power_level; | ||
664 | } | ||
665 | |||
666 | out_sleep: | ||
667 | wl1251_ps_elp_sleep(wl); | ||
668 | |||
669 | out: | ||
670 | mutex_unlock(&wl->mutex); | ||
671 | |||
672 | return ret; | ||
673 | } | ||
674 | |||
675 | #define WL1251_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \ | ||
676 | FIF_ALLMULTI | \ | ||
677 | FIF_FCSFAIL | \ | ||
678 | FIF_BCN_PRBRESP_PROMISC | \ | ||
679 | FIF_CONTROL | \ | ||
680 | FIF_OTHER_BSS) | ||
681 | |||
682 | static void wl1251_op_configure_filter(struct ieee80211_hw *hw, | ||
683 | unsigned int changed, | ||
684 | unsigned int *total,u64 multicast) | ||
685 | { | ||
686 | struct wl1251 *wl = hw->priv; | ||
687 | |||
688 | wl1251_debug(DEBUG_MAC80211, "mac80211 configure filter"); | ||
689 | |||
690 | *total &= WL1251_SUPPORTED_FILTERS; | ||
691 | changed &= WL1251_SUPPORTED_FILTERS; | ||
692 | |||
693 | if (changed == 0) | ||
694 | /* no filters which we support changed */ | ||
695 | return; | ||
696 | |||
697 | /* FIXME: wl->rx_config and wl->rx_filter are not protected */ | ||
698 | |||
699 | wl->rx_config = WL1251_DEFAULT_RX_CONFIG; | ||
700 | wl->rx_filter = WL1251_DEFAULT_RX_FILTER; | ||
701 | |||
702 | if (*total & FIF_PROMISC_IN_BSS) { | ||
703 | wl->rx_config |= CFG_BSSID_FILTER_EN; | ||
704 | wl->rx_config |= CFG_RX_ALL_GOOD; | ||
705 | } | ||
706 | if (*total & FIF_ALLMULTI) | ||
707 | /* | ||
708 | * CFG_MC_FILTER_EN in rx_config needs to be 0 to receive | ||
709 | * all multicast frames | ||
710 | */ | ||
711 | wl->rx_config &= ~CFG_MC_FILTER_EN; | ||
712 | if (*total & FIF_FCSFAIL) | ||
713 | wl->rx_filter |= CFG_RX_FCS_ERROR; | ||
714 | if (*total & FIF_BCN_PRBRESP_PROMISC) { | ||
715 | wl->rx_config &= ~CFG_BSSID_FILTER_EN; | ||
716 | wl->rx_config &= ~CFG_SSID_FILTER_EN; | ||
717 | } | ||
718 | if (*total & FIF_CONTROL) | ||
719 | wl->rx_filter |= CFG_RX_CTL_EN; | ||
720 | if (*total & FIF_OTHER_BSS) | ||
721 | wl->rx_filter &= ~CFG_BSSID_FILTER_EN; | ||
722 | |||
723 | /* | ||
724 | * FIXME: workqueues need to be properly cancelled on stop(), for | ||
725 | * now let's just disable changing the filter settings. They will | ||
726 | * be updated any on config(). | ||
727 | */ | ||
728 | /* schedule_work(&wl->filter_work); */ | ||
729 | } | ||
730 | |||
731 | /* HW encryption */ | ||
732 | static int wl1251_set_key_type(struct wl1251 *wl, | ||
733 | struct wl1251_cmd_set_keys *key, | ||
734 | enum set_key_cmd cmd, | ||
735 | struct ieee80211_key_conf *mac80211_key, | ||
736 | const u8 *addr) | ||
737 | { | ||
738 | switch (mac80211_key->cipher) { | ||
739 | case WLAN_CIPHER_SUITE_WEP40: | ||
740 | case WLAN_CIPHER_SUITE_WEP104: | ||
741 | if (is_broadcast_ether_addr(addr)) | ||
742 | key->key_type = KEY_WEP_DEFAULT; | ||
743 | else | ||
744 | key->key_type = KEY_WEP_ADDR; | ||
745 | |||
746 | mac80211_key->hw_key_idx = mac80211_key->keyidx; | ||
747 | break; | ||
748 | case WLAN_CIPHER_SUITE_TKIP: | ||
749 | if (is_broadcast_ether_addr(addr)) | ||
750 | key->key_type = KEY_TKIP_MIC_GROUP; | ||
751 | else | ||
752 | key->key_type = KEY_TKIP_MIC_PAIRWISE; | ||
753 | |||
754 | mac80211_key->hw_key_idx = mac80211_key->keyidx; | ||
755 | break; | ||
756 | case WLAN_CIPHER_SUITE_CCMP: | ||
757 | if (is_broadcast_ether_addr(addr)) | ||
758 | key->key_type = KEY_AES_GROUP; | ||
759 | else | ||
760 | key->key_type = KEY_AES_PAIRWISE; | ||
761 | mac80211_key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; | ||
762 | break; | ||
763 | default: | ||
764 | wl1251_error("Unknown key cipher 0x%x", mac80211_key->cipher); | ||
765 | return -EOPNOTSUPP; | ||
766 | } | ||
767 | |||
768 | return 0; | ||
769 | } | ||
770 | |||
771 | static int wl1251_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, | ||
772 | struct ieee80211_vif *vif, | ||
773 | struct ieee80211_sta *sta, | ||
774 | struct ieee80211_key_conf *key) | ||
775 | { | ||
776 | struct wl1251 *wl = hw->priv; | ||
777 | struct wl1251_cmd_set_keys *wl_cmd; | ||
778 | const u8 *addr; | ||
779 | int ret; | ||
780 | |||
781 | static const u8 bcast_addr[ETH_ALEN] = | ||
782 | { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; | ||
783 | |||
784 | wl1251_debug(DEBUG_MAC80211, "mac80211 set key"); | ||
785 | |||
786 | wl_cmd = kzalloc(sizeof(*wl_cmd), GFP_KERNEL); | ||
787 | if (!wl_cmd) { | ||
788 | ret = -ENOMEM; | ||
789 | goto out; | ||
790 | } | ||
791 | |||
792 | addr = sta ? sta->addr : bcast_addr; | ||
793 | |||
794 | wl1251_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd); | ||
795 | wl1251_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN); | ||
796 | wl1251_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x", | ||
797 | key->cipher, key->keyidx, key->keylen, key->flags); | ||
798 | wl1251_dump(DEBUG_CRYPT, "KEY: ", key->key, key->keylen); | ||
799 | |||
800 | if (is_zero_ether_addr(addr)) { | ||
801 | /* We dont support TX only encryption */ | ||
802 | ret = -EOPNOTSUPP; | ||
803 | goto out; | ||
804 | } | ||
805 | |||
806 | mutex_lock(&wl->mutex); | ||
807 | |||
808 | ret = wl1251_ps_elp_wakeup(wl); | ||
809 | if (ret < 0) | ||
810 | goto out_unlock; | ||
811 | |||
812 | switch (cmd) { | ||
813 | case SET_KEY: | ||
814 | wl_cmd->key_action = KEY_ADD_OR_REPLACE; | ||
815 | break; | ||
816 | case DISABLE_KEY: | ||
817 | wl_cmd->key_action = KEY_REMOVE; | ||
818 | break; | ||
819 | default: | ||
820 | wl1251_error("Unsupported key cmd 0x%x", cmd); | ||
821 | break; | ||
822 | } | ||
823 | |||
824 | ret = wl1251_set_key_type(wl, wl_cmd, cmd, key, addr); | ||
825 | if (ret < 0) { | ||
826 | wl1251_error("Set KEY type failed"); | ||
827 | goto out_sleep; | ||
828 | } | ||
829 | |||
830 | if (wl_cmd->key_type != KEY_WEP_DEFAULT) | ||
831 | memcpy(wl_cmd->addr, addr, ETH_ALEN); | ||
832 | |||
833 | if ((wl_cmd->key_type == KEY_TKIP_MIC_GROUP) || | ||
834 | (wl_cmd->key_type == KEY_TKIP_MIC_PAIRWISE)) { | ||
835 | /* | ||
836 | * We get the key in the following form: | ||
837 | * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes) | ||
838 | * but the target is expecting: | ||
839 | * TKIP - RX MIC - TX MIC | ||
840 | */ | ||
841 | memcpy(wl_cmd->key, key->key, 16); | ||
842 | memcpy(wl_cmd->key + 16, key->key + 24, 8); | ||
843 | memcpy(wl_cmd->key + 24, key->key + 16, 8); | ||
844 | |||
845 | } else { | ||
846 | memcpy(wl_cmd->key, key->key, key->keylen); | ||
847 | } | ||
848 | wl_cmd->key_size = key->keylen; | ||
849 | |||
850 | wl_cmd->id = key->keyidx; | ||
851 | wl_cmd->ssid_profile = 0; | ||
852 | |||
853 | wl1251_dump(DEBUG_CRYPT, "TARGET KEY: ", wl_cmd, sizeof(*wl_cmd)); | ||
854 | |||
855 | ret = wl1251_cmd_send(wl, CMD_SET_KEYS, wl_cmd, sizeof(*wl_cmd)); | ||
856 | if (ret < 0) { | ||
857 | wl1251_warning("could not set keys"); | ||
858 | goto out_sleep; | ||
859 | } | ||
860 | |||
861 | out_sleep: | ||
862 | wl1251_ps_elp_sleep(wl); | ||
863 | |||
864 | out_unlock: | ||
865 | mutex_unlock(&wl->mutex); | ||
866 | |||
867 | out: | ||
868 | kfree(wl_cmd); | ||
869 | |||
870 | return ret; | ||
871 | } | ||
872 | |||
873 | static int wl1251_op_hw_scan(struct ieee80211_hw *hw, | ||
874 | struct ieee80211_vif *vif, | ||
875 | struct cfg80211_scan_request *req) | ||
876 | { | ||
877 | struct wl1251 *wl = hw->priv; | ||
878 | struct sk_buff *skb; | ||
879 | size_t ssid_len = 0; | ||
880 | u8 *ssid = NULL; | ||
881 | int ret; | ||
882 | |||
883 | wl1251_debug(DEBUG_MAC80211, "mac80211 hw scan"); | ||
884 | |||
885 | if (req->n_ssids) { | ||
886 | ssid = req->ssids[0].ssid; | ||
887 | ssid_len = req->ssids[0].ssid_len; | ||
888 | } | ||
889 | |||
890 | mutex_lock(&wl->mutex); | ||
891 | |||
892 | if (wl->scanning) { | ||
893 | wl1251_debug(DEBUG_SCAN, "scan already in progress"); | ||
894 | ret = -EINVAL; | ||
895 | goto out; | ||
896 | } | ||
897 | |||
898 | ret = wl1251_ps_elp_wakeup(wl); | ||
899 | if (ret < 0) | ||
900 | goto out; | ||
901 | |||
902 | skb = ieee80211_probereq_get(wl->hw, wl->vif, ssid, ssid_len, | ||
903 | req->ie, req->ie_len); | ||
904 | if (!skb) { | ||
905 | ret = -ENOMEM; | ||
906 | goto out; | ||
907 | } | ||
908 | |||
909 | ret = wl1251_cmd_template_set(wl, CMD_PROBE_REQ, skb->data, | ||
910 | skb->len); | ||
911 | dev_kfree_skb(skb); | ||
912 | if (ret < 0) | ||
913 | goto out_sleep; | ||
914 | |||
915 | ret = wl1251_cmd_trigger_scan_to(wl, 0); | ||
916 | if (ret < 0) | ||
917 | goto out_sleep; | ||
918 | |||
919 | wl->scanning = true; | ||
920 | |||
921 | ret = wl1251_cmd_scan(wl, ssid, ssid_len, req->channels, | ||
922 | req->n_channels, WL1251_SCAN_NUM_PROBES); | ||
923 | if (ret < 0) { | ||
924 | wl->scanning = false; | ||
925 | goto out_sleep; | ||
926 | } | ||
927 | |||
928 | out_sleep: | ||
929 | wl1251_ps_elp_sleep(wl); | ||
930 | |||
931 | out: | ||
932 | mutex_unlock(&wl->mutex); | ||
933 | |||
934 | return ret; | ||
935 | } | ||
936 | |||
937 | static int wl1251_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) | ||
938 | { | ||
939 | struct wl1251 *wl = hw->priv; | ||
940 | int ret; | ||
941 | |||
942 | mutex_lock(&wl->mutex); | ||
943 | |||
944 | ret = wl1251_ps_elp_wakeup(wl); | ||
945 | if (ret < 0) | ||
946 | goto out; | ||
947 | |||
948 | ret = wl1251_acx_rts_threshold(wl, (u16) value); | ||
949 | if (ret < 0) | ||
950 | wl1251_warning("wl1251_op_set_rts_threshold failed: %d", ret); | ||
951 | |||
952 | wl1251_ps_elp_sleep(wl); | ||
953 | |||
954 | out: | ||
955 | mutex_unlock(&wl->mutex); | ||
956 | |||
957 | return ret; | ||
958 | } | ||
959 | |||
960 | static void wl1251_op_bss_info_changed(struct ieee80211_hw *hw, | ||
961 | struct ieee80211_vif *vif, | ||
962 | struct ieee80211_bss_conf *bss_conf, | ||
963 | u32 changed) | ||
964 | { | ||
965 | struct wl1251 *wl = hw->priv; | ||
966 | struct sk_buff *beacon, *skb; | ||
967 | int ret; | ||
968 | |||
969 | wl1251_debug(DEBUG_MAC80211, "mac80211 bss info changed"); | ||
970 | |||
971 | mutex_lock(&wl->mutex); | ||
972 | |||
973 | ret = wl1251_ps_elp_wakeup(wl); | ||
974 | if (ret < 0) | ||
975 | goto out; | ||
976 | |||
977 | if (changed & BSS_CHANGED_CQM) { | ||
978 | ret = wl1251_acx_low_rssi(wl, bss_conf->cqm_rssi_thold, | ||
979 | WL1251_DEFAULT_LOW_RSSI_WEIGHT, | ||
980 | WL1251_DEFAULT_LOW_RSSI_DEPTH, | ||
981 | WL1251_ACX_LOW_RSSI_TYPE_EDGE); | ||
982 | if (ret < 0) | ||
983 | goto out; | ||
984 | wl->rssi_thold = bss_conf->cqm_rssi_thold; | ||
985 | } | ||
986 | |||
987 | if (changed & BSS_CHANGED_BSSID) { | ||
988 | memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN); | ||
989 | |||
990 | skb = ieee80211_nullfunc_get(wl->hw, wl->vif); | ||
991 | if (!skb) | ||
992 | goto out_sleep; | ||
993 | |||
994 | ret = wl1251_cmd_template_set(wl, CMD_NULL_DATA, | ||
995 | skb->data, skb->len); | ||
996 | dev_kfree_skb(skb); | ||
997 | if (ret < 0) | ||
998 | goto out_sleep; | ||
999 | |||
1000 | ret = wl1251_build_qos_null_data(wl); | ||
1001 | if (ret < 0) | ||
1002 | goto out; | ||
1003 | |||
1004 | if (wl->bss_type != BSS_TYPE_IBSS) { | ||
1005 | ret = wl1251_join(wl, wl->bss_type, wl->channel, | ||
1006 | wl->beacon_int, wl->dtim_period); | ||
1007 | if (ret < 0) | ||
1008 | goto out_sleep; | ||
1009 | } | ||
1010 | } | ||
1011 | |||
1012 | if (changed & BSS_CHANGED_ASSOC) { | ||
1013 | if (bss_conf->assoc) { | ||
1014 | wl->beacon_int = bss_conf->beacon_int; | ||
1015 | |||
1016 | skb = ieee80211_pspoll_get(wl->hw, wl->vif); | ||
1017 | if (!skb) | ||
1018 | goto out_sleep; | ||
1019 | |||
1020 | ret = wl1251_cmd_template_set(wl, CMD_PS_POLL, | ||
1021 | skb->data, | ||
1022 | skb->len); | ||
1023 | dev_kfree_skb(skb); | ||
1024 | if (ret < 0) | ||
1025 | goto out_sleep; | ||
1026 | |||
1027 | ret = wl1251_acx_aid(wl, bss_conf->aid); | ||
1028 | if (ret < 0) | ||
1029 | goto out_sleep; | ||
1030 | } else { | ||
1031 | /* use defaults when not associated */ | ||
1032 | wl->beacon_int = WL1251_DEFAULT_BEACON_INT; | ||
1033 | wl->dtim_period = WL1251_DEFAULT_DTIM_PERIOD; | ||
1034 | } | ||
1035 | } | ||
1036 | if (changed & BSS_CHANGED_ERP_SLOT) { | ||
1037 | if (bss_conf->use_short_slot) | ||
1038 | ret = wl1251_acx_slot(wl, SLOT_TIME_SHORT); | ||
1039 | else | ||
1040 | ret = wl1251_acx_slot(wl, SLOT_TIME_LONG); | ||
1041 | if (ret < 0) { | ||
1042 | wl1251_warning("Set slot time failed %d", ret); | ||
1043 | goto out_sleep; | ||
1044 | } | ||
1045 | } | ||
1046 | |||
1047 | if (changed & BSS_CHANGED_ERP_PREAMBLE) { | ||
1048 | if (bss_conf->use_short_preamble) | ||
1049 | wl1251_acx_set_preamble(wl, ACX_PREAMBLE_SHORT); | ||
1050 | else | ||
1051 | wl1251_acx_set_preamble(wl, ACX_PREAMBLE_LONG); | ||
1052 | } | ||
1053 | |||
1054 | if (changed & BSS_CHANGED_ERP_CTS_PROT) { | ||
1055 | if (bss_conf->use_cts_prot) | ||
1056 | ret = wl1251_acx_cts_protect(wl, CTSPROTECT_ENABLE); | ||
1057 | else | ||
1058 | ret = wl1251_acx_cts_protect(wl, CTSPROTECT_DISABLE); | ||
1059 | if (ret < 0) { | ||
1060 | wl1251_warning("Set ctsprotect failed %d", ret); | ||
1061 | goto out_sleep; | ||
1062 | } | ||
1063 | } | ||
1064 | |||
1065 | if (changed & BSS_CHANGED_BEACON) { | ||
1066 | beacon = ieee80211_beacon_get(hw, vif); | ||
1067 | if (!beacon) | ||
1068 | goto out_sleep; | ||
1069 | |||
1070 | ret = wl1251_cmd_template_set(wl, CMD_BEACON, beacon->data, | ||
1071 | beacon->len); | ||
1072 | |||
1073 | if (ret < 0) { | ||
1074 | dev_kfree_skb(beacon); | ||
1075 | goto out_sleep; | ||
1076 | } | ||
1077 | |||
1078 | ret = wl1251_cmd_template_set(wl, CMD_PROBE_RESP, beacon->data, | ||
1079 | beacon->len); | ||
1080 | |||
1081 | dev_kfree_skb(beacon); | ||
1082 | |||
1083 | if (ret < 0) | ||
1084 | goto out_sleep; | ||
1085 | |||
1086 | ret = wl1251_join(wl, wl->bss_type, wl->beacon_int, | ||
1087 | wl->channel, wl->dtim_period); | ||
1088 | |||
1089 | if (ret < 0) | ||
1090 | goto out_sleep; | ||
1091 | } | ||
1092 | |||
1093 | out_sleep: | ||
1094 | wl1251_ps_elp_sleep(wl); | ||
1095 | |||
1096 | out: | ||
1097 | mutex_unlock(&wl->mutex); | ||
1098 | } | ||
1099 | |||
1100 | |||
1101 | /* can't be const, mac80211 writes to this */ | ||
1102 | static struct ieee80211_rate wl1251_rates[] = { | ||
1103 | { .bitrate = 10, | ||
1104 | .hw_value = 0x1, | ||
1105 | .hw_value_short = 0x1, }, | ||
1106 | { .bitrate = 20, | ||
1107 | .hw_value = 0x2, | ||
1108 | .hw_value_short = 0x2, | ||
1109 | .flags = IEEE80211_RATE_SHORT_PREAMBLE }, | ||
1110 | { .bitrate = 55, | ||
1111 | .hw_value = 0x4, | ||
1112 | .hw_value_short = 0x4, | ||
1113 | .flags = IEEE80211_RATE_SHORT_PREAMBLE }, | ||
1114 | { .bitrate = 110, | ||
1115 | .hw_value = 0x20, | ||
1116 | .hw_value_short = 0x20, | ||
1117 | .flags = IEEE80211_RATE_SHORT_PREAMBLE }, | ||
1118 | { .bitrate = 60, | ||
1119 | .hw_value = 0x8, | ||
1120 | .hw_value_short = 0x8, }, | ||
1121 | { .bitrate = 90, | ||
1122 | .hw_value = 0x10, | ||
1123 | .hw_value_short = 0x10, }, | ||
1124 | { .bitrate = 120, | ||
1125 | .hw_value = 0x40, | ||
1126 | .hw_value_short = 0x40, }, | ||
1127 | { .bitrate = 180, | ||
1128 | .hw_value = 0x80, | ||
1129 | .hw_value_short = 0x80, }, | ||
1130 | { .bitrate = 240, | ||
1131 | .hw_value = 0x200, | ||
1132 | .hw_value_short = 0x200, }, | ||
1133 | { .bitrate = 360, | ||
1134 | .hw_value = 0x400, | ||
1135 | .hw_value_short = 0x400, }, | ||
1136 | { .bitrate = 480, | ||
1137 | .hw_value = 0x800, | ||
1138 | .hw_value_short = 0x800, }, | ||
1139 | { .bitrate = 540, | ||
1140 | .hw_value = 0x1000, | ||
1141 | .hw_value_short = 0x1000, }, | ||
1142 | }; | ||
1143 | |||
1144 | /* can't be const, mac80211 writes to this */ | ||
1145 | static struct ieee80211_channel wl1251_channels[] = { | ||
1146 | { .hw_value = 1, .center_freq = 2412}, | ||
1147 | { .hw_value = 2, .center_freq = 2417}, | ||
1148 | { .hw_value = 3, .center_freq = 2422}, | ||
1149 | { .hw_value = 4, .center_freq = 2427}, | ||
1150 | { .hw_value = 5, .center_freq = 2432}, | ||
1151 | { .hw_value = 6, .center_freq = 2437}, | ||
1152 | { .hw_value = 7, .center_freq = 2442}, | ||
1153 | { .hw_value = 8, .center_freq = 2447}, | ||
1154 | { .hw_value = 9, .center_freq = 2452}, | ||
1155 | { .hw_value = 10, .center_freq = 2457}, | ||
1156 | { .hw_value = 11, .center_freq = 2462}, | ||
1157 | { .hw_value = 12, .center_freq = 2467}, | ||
1158 | { .hw_value = 13, .center_freq = 2472}, | ||
1159 | }; | ||
1160 | |||
1161 | static int wl1251_op_conf_tx(struct ieee80211_hw *hw, u16 queue, | ||
1162 | const struct ieee80211_tx_queue_params *params) | ||
1163 | { | ||
1164 | enum wl1251_acx_ps_scheme ps_scheme; | ||
1165 | struct wl1251 *wl = hw->priv; | ||
1166 | int ret; | ||
1167 | |||
1168 | mutex_lock(&wl->mutex); | ||
1169 | |||
1170 | wl1251_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue); | ||
1171 | |||
1172 | ret = wl1251_ps_elp_wakeup(wl); | ||
1173 | if (ret < 0) | ||
1174 | goto out; | ||
1175 | |||
1176 | /* mac80211 uses units of 32 usec */ | ||
1177 | ret = wl1251_acx_ac_cfg(wl, wl1251_tx_get_queue(queue), | ||
1178 | params->cw_min, params->cw_max, | ||
1179 | params->aifs, params->txop * 32); | ||
1180 | if (ret < 0) | ||
1181 | goto out_sleep; | ||
1182 | |||
1183 | if (params->uapsd) | ||
1184 | ps_scheme = WL1251_ACX_PS_SCHEME_UPSD_TRIGGER; | ||
1185 | else | ||
1186 | ps_scheme = WL1251_ACX_PS_SCHEME_LEGACY; | ||
1187 | |||
1188 | ret = wl1251_acx_tid_cfg(wl, wl1251_tx_get_queue(queue), | ||
1189 | CHANNEL_TYPE_EDCF, | ||
1190 | wl1251_tx_get_queue(queue), ps_scheme, | ||
1191 | WL1251_ACX_ACK_POLICY_LEGACY); | ||
1192 | if (ret < 0) | ||
1193 | goto out_sleep; | ||
1194 | |||
1195 | out_sleep: | ||
1196 | wl1251_ps_elp_sleep(wl); | ||
1197 | |||
1198 | out: | ||
1199 | mutex_unlock(&wl->mutex); | ||
1200 | |||
1201 | return ret; | ||
1202 | } | ||
1203 | |||
1204 | static int wl1251_op_get_survey(struct ieee80211_hw *hw, int idx, | ||
1205 | struct survey_info *survey) | ||
1206 | { | ||
1207 | struct wl1251 *wl = hw->priv; | ||
1208 | struct ieee80211_conf *conf = &hw->conf; | ||
1209 | |||
1210 | if (idx != 0) | ||
1211 | return -ENOENT; | ||
1212 | |||
1213 | survey->channel = conf->channel; | ||
1214 | survey->filled = SURVEY_INFO_NOISE_DBM; | ||
1215 | survey->noise = wl->noise; | ||
1216 | |||
1217 | return 0; | ||
1218 | } | ||
1219 | |||
1220 | /* can't be const, mac80211 writes to this */ | ||
1221 | static struct ieee80211_supported_band wl1251_band_2ghz = { | ||
1222 | .channels = wl1251_channels, | ||
1223 | .n_channels = ARRAY_SIZE(wl1251_channels), | ||
1224 | .bitrates = wl1251_rates, | ||
1225 | .n_bitrates = ARRAY_SIZE(wl1251_rates), | ||
1226 | }; | ||
1227 | |||
1228 | static const struct ieee80211_ops wl1251_ops = { | ||
1229 | .start = wl1251_op_start, | ||
1230 | .stop = wl1251_op_stop, | ||
1231 | .add_interface = wl1251_op_add_interface, | ||
1232 | .remove_interface = wl1251_op_remove_interface, | ||
1233 | .config = wl1251_op_config, | ||
1234 | .configure_filter = wl1251_op_configure_filter, | ||
1235 | .tx = wl1251_op_tx, | ||
1236 | .set_key = wl1251_op_set_key, | ||
1237 | .hw_scan = wl1251_op_hw_scan, | ||
1238 | .bss_info_changed = wl1251_op_bss_info_changed, | ||
1239 | .set_rts_threshold = wl1251_op_set_rts_threshold, | ||
1240 | .conf_tx = wl1251_op_conf_tx, | ||
1241 | .get_survey = wl1251_op_get_survey, | ||
1242 | }; | ||
1243 | |||
1244 | static int wl1251_read_eeprom_byte(struct wl1251 *wl, off_t offset, u8 *data) | ||
1245 | { | ||
1246 | unsigned long timeout; | ||
1247 | |||
1248 | wl1251_reg_write32(wl, EE_ADDR, offset); | ||
1249 | wl1251_reg_write32(wl, EE_CTL, EE_CTL_READ); | ||
1250 | |||
1251 | /* EE_CTL_READ clears when data is ready */ | ||
1252 | timeout = jiffies + msecs_to_jiffies(100); | ||
1253 | while (1) { | ||
1254 | if (!(wl1251_reg_read32(wl, EE_CTL) & EE_CTL_READ)) | ||
1255 | break; | ||
1256 | |||
1257 | if (time_after(jiffies, timeout)) | ||
1258 | return -ETIMEDOUT; | ||
1259 | |||
1260 | msleep(1); | ||
1261 | } | ||
1262 | |||
1263 | *data = wl1251_reg_read32(wl, EE_DATA); | ||
1264 | return 0; | ||
1265 | } | ||
1266 | |||
1267 | static int wl1251_read_eeprom(struct wl1251 *wl, off_t offset, | ||
1268 | u8 *data, size_t len) | ||
1269 | { | ||
1270 | size_t i; | ||
1271 | int ret; | ||
1272 | |||
1273 | wl1251_reg_write32(wl, EE_START, 0); | ||
1274 | |||
1275 | for (i = 0; i < len; i++) { | ||
1276 | ret = wl1251_read_eeprom_byte(wl, offset + i, &data[i]); | ||
1277 | if (ret < 0) | ||
1278 | return ret; | ||
1279 | } | ||
1280 | |||
1281 | return 0; | ||
1282 | } | ||
1283 | |||
1284 | static int wl1251_read_eeprom_mac(struct wl1251 *wl) | ||
1285 | { | ||
1286 | u8 mac[ETH_ALEN]; | ||
1287 | int i, ret; | ||
1288 | |||
1289 | wl1251_set_partition(wl, 0, 0, REGISTERS_BASE, REGISTERS_DOWN_SIZE); | ||
1290 | |||
1291 | ret = wl1251_read_eeprom(wl, 0x1c, mac, sizeof(mac)); | ||
1292 | if (ret < 0) { | ||
1293 | wl1251_warning("failed to read MAC address from EEPROM"); | ||
1294 | return ret; | ||
1295 | } | ||
1296 | |||
1297 | /* MAC is stored in reverse order */ | ||
1298 | for (i = 0; i < ETH_ALEN; i++) | ||
1299 | wl->mac_addr[i] = mac[ETH_ALEN - i - 1]; | ||
1300 | |||
1301 | return 0; | ||
1302 | } | ||
1303 | |||
1304 | static int wl1251_register_hw(struct wl1251 *wl) | ||
1305 | { | ||
1306 | int ret; | ||
1307 | |||
1308 | if (wl->mac80211_registered) | ||
1309 | return 0; | ||
1310 | |||
1311 | SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr); | ||
1312 | |||
1313 | ret = ieee80211_register_hw(wl->hw); | ||
1314 | if (ret < 0) { | ||
1315 | wl1251_error("unable to register mac80211 hw: %d", ret); | ||
1316 | return ret; | ||
1317 | } | ||
1318 | |||
1319 | wl->mac80211_registered = true; | ||
1320 | |||
1321 | wl1251_notice("loaded"); | ||
1322 | |||
1323 | return 0; | ||
1324 | } | ||
1325 | |||
1326 | int wl1251_init_ieee80211(struct wl1251 *wl) | ||
1327 | { | ||
1328 | int ret; | ||
1329 | |||
1330 | /* The tx descriptor buffer and the TKIP space */ | ||
1331 | wl->hw->extra_tx_headroom = sizeof(struct tx_double_buffer_desc) | ||
1332 | + WL1251_TKIP_IV_SPACE; | ||
1333 | |||
1334 | /* unit us */ | ||
1335 | /* FIXME: find a proper value */ | ||
1336 | wl->hw->channel_change_time = 10000; | ||
1337 | |||
1338 | wl->hw->flags = IEEE80211_HW_SIGNAL_DBM | | ||
1339 | IEEE80211_HW_SUPPORTS_PS | | ||
1340 | IEEE80211_HW_BEACON_FILTER | | ||
1341 | IEEE80211_HW_SUPPORTS_UAPSD | | ||
1342 | IEEE80211_HW_SUPPORTS_CQM_RSSI; | ||
1343 | |||
1344 | wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | | ||
1345 | BIT(NL80211_IFTYPE_ADHOC); | ||
1346 | wl->hw->wiphy->max_scan_ssids = 1; | ||
1347 | wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1251_band_2ghz; | ||
1348 | |||
1349 | wl->hw->queues = 4; | ||
1350 | |||
1351 | if (wl->use_eeprom) | ||
1352 | wl1251_read_eeprom_mac(wl); | ||
1353 | |||
1354 | ret = wl1251_register_hw(wl); | ||
1355 | if (ret) | ||
1356 | goto out; | ||
1357 | |||
1358 | wl1251_debugfs_init(wl); | ||
1359 | wl1251_notice("initialized"); | ||
1360 | |||
1361 | ret = 0; | ||
1362 | |||
1363 | out: | ||
1364 | return ret; | ||
1365 | } | ||
1366 | EXPORT_SYMBOL_GPL(wl1251_init_ieee80211); | ||
1367 | |||
1368 | struct ieee80211_hw *wl1251_alloc_hw(void) | ||
1369 | { | ||
1370 | struct ieee80211_hw *hw; | ||
1371 | struct wl1251 *wl; | ||
1372 | int i; | ||
1373 | static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf}; | ||
1374 | |||
1375 | hw = ieee80211_alloc_hw(sizeof(*wl), &wl1251_ops); | ||
1376 | if (!hw) { | ||
1377 | wl1251_error("could not alloc ieee80211_hw"); | ||
1378 | return ERR_PTR(-ENOMEM); | ||
1379 | } | ||
1380 | |||
1381 | wl = hw->priv; | ||
1382 | memset(wl, 0, sizeof(*wl)); | ||
1383 | |||
1384 | wl->hw = hw; | ||
1385 | |||
1386 | wl->data_in_count = 0; | ||
1387 | |||
1388 | skb_queue_head_init(&wl->tx_queue); | ||
1389 | |||
1390 | INIT_WORK(&wl->filter_work, wl1251_filter_work); | ||
1391 | INIT_DELAYED_WORK(&wl->elp_work, wl1251_elp_work); | ||
1392 | wl->channel = WL1251_DEFAULT_CHANNEL; | ||
1393 | wl->scanning = false; | ||
1394 | wl->default_key = 0; | ||
1395 | wl->listen_int = 1; | ||
1396 | wl->rx_counter = 0; | ||
1397 | wl->rx_handled = 0; | ||
1398 | wl->rx_current_buffer = 0; | ||
1399 | wl->rx_last_id = 0; | ||
1400 | wl->rx_config = WL1251_DEFAULT_RX_CONFIG; | ||
1401 | wl->rx_filter = WL1251_DEFAULT_RX_FILTER; | ||
1402 | wl->elp = false; | ||
1403 | wl->station_mode = STATION_ACTIVE_MODE; | ||
1404 | wl->psm_requested = false; | ||
1405 | wl->tx_queue_stopped = false; | ||
1406 | wl->power_level = WL1251_DEFAULT_POWER_LEVEL; | ||
1407 | wl->rssi_thold = 0; | ||
1408 | wl->beacon_int = WL1251_DEFAULT_BEACON_INT; | ||
1409 | wl->dtim_period = WL1251_DEFAULT_DTIM_PERIOD; | ||
1410 | wl->vif = NULL; | ||
1411 | |||
1412 | for (i = 0; i < FW_TX_CMPLT_BLOCK_SIZE; i++) | ||
1413 | wl->tx_frames[i] = NULL; | ||
1414 | |||
1415 | wl->next_tx_complete = 0; | ||
1416 | |||
1417 | INIT_WORK(&wl->irq_work, wl1251_irq_work); | ||
1418 | INIT_WORK(&wl->tx_work, wl1251_tx_work); | ||
1419 | |||
1420 | /* | ||
1421 | * In case our MAC address is not correctly set, | ||
1422 | * we use a random but Nokia MAC. | ||
1423 | */ | ||
1424 | memcpy(wl->mac_addr, nokia_oui, 3); | ||
1425 | get_random_bytes(wl->mac_addr + 3, 3); | ||
1426 | |||
1427 | wl->state = WL1251_STATE_OFF; | ||
1428 | mutex_init(&wl->mutex); | ||
1429 | |||
1430 | wl->tx_mgmt_frm_rate = DEFAULT_HW_GEN_TX_RATE; | ||
1431 | wl->tx_mgmt_frm_mod = DEFAULT_HW_GEN_MODULATION_TYPE; | ||
1432 | |||
1433 | wl->rx_descriptor = kmalloc(sizeof(*wl->rx_descriptor), GFP_KERNEL); | ||
1434 | if (!wl->rx_descriptor) { | ||
1435 | wl1251_error("could not allocate memory for rx descriptor"); | ||
1436 | ieee80211_free_hw(hw); | ||
1437 | return ERR_PTR(-ENOMEM); | ||
1438 | } | ||
1439 | |||
1440 | return hw; | ||
1441 | } | ||
1442 | EXPORT_SYMBOL_GPL(wl1251_alloc_hw); | ||
1443 | |||
1444 | int wl1251_free_hw(struct wl1251 *wl) | ||
1445 | { | ||
1446 | ieee80211_unregister_hw(wl->hw); | ||
1447 | |||
1448 | wl1251_debugfs_exit(wl); | ||
1449 | |||
1450 | kfree(wl->target_mem_map); | ||
1451 | kfree(wl->data_path); | ||
1452 | vfree(wl->fw); | ||
1453 | wl->fw = NULL; | ||
1454 | kfree(wl->nvs); | ||
1455 | wl->nvs = NULL; | ||
1456 | |||
1457 | kfree(wl->rx_descriptor); | ||
1458 | wl->rx_descriptor = NULL; | ||
1459 | |||
1460 | ieee80211_free_hw(wl->hw); | ||
1461 | |||
1462 | return 0; | ||
1463 | } | ||
1464 | EXPORT_SYMBOL_GPL(wl1251_free_hw); | ||
1465 | |||
1466 | MODULE_DESCRIPTION("TI wl1251 Wireles LAN Driver Core"); | ||
1467 | MODULE_LICENSE("GPL"); | ||
1468 | MODULE_AUTHOR("Kalle Valo <kvalo@adurom.com>"); | ||
1469 | MODULE_FIRMWARE(WL1251_FW_NAME); | ||