?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wl18xx: read FW pc on recovery
[linux-2.6/libata-dev.git] / drivers / net / wireless / ti / wlcore / main.c
blobdfa87b4d3bb2f26c6c5263db2e25495849f0c3a3
1
2 /*
3 * This file is part of wl1271
4 *
5 * Copyright (C) 2008-2010 Nokia Corporation
6 *
7 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * version 2 as published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21 * 02110-1301 USA
22 *
23 */
24
25 #include <linux/module.h>
26 #include <linux/firmware.h>
27 #include <linux/delay.h>
28 #include <linux/spi/spi.h>
29 #include <linux/crc32.h>
30 #include <linux/etherdevice.h>
31 #include <linux/vmalloc.h>
32 #include <linux/platform_device.h>
33 #include <linux/slab.h>
34 #include <linux/wl12xx.h>
35 #include <linux/sched.h>
36 #include <linux/interrupt.h>
37
38 #include "wlcore.h"
39 #include "debug.h"
40 #include "wl12xx_80211.h"
41 #include "io.h"
42 #include "event.h"
43 #include "tx.h"
44 #include "rx.h"
45 #include "ps.h"
46 #include "init.h"
47 #include "debugfs.h"
48 #include "cmd.h"
49 #include "boot.h"
50 #include "testmode.h"
51 #include "scan.h"
52 #include "hw_ops.h"
53
54 #define WL1271_BOOT_RETRIES 3
55
56 #define WL1271_BOOT_RETRIES 3
57
58 static char *fwlog_param;
59 static bool bug_on_recovery;
60 static bool no_recovery;
61
62 static void __wl1271_op_remove_interface(struct wl1271 *wl,
63 struct ieee80211_vif *vif,
64 bool reset_tx_queues);
65 static void wl1271_op_stop(struct ieee80211_hw *hw);
66 static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif);
67
68 static int wl12xx_set_authorized(struct wl1271 *wl,
69 struct wl12xx_vif *wlvif)
70 {
71 int ret;
72
73 if (WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS))
74 return -EINVAL;
75
76 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
77 return 0;
78
79 if (test_and_set_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags))
80 return 0;
81
82 ret = wl12xx_cmd_set_peer_state(wl, wlvif->sta.hlid);
83 if (ret < 0)
84 return ret;
85
86 wl12xx_croc(wl, wlvif->role_id);
87
88 wl1271_info("Association completed.");
89 return 0;
90 }
91
92 static int wl1271_reg_notify(struct wiphy *wiphy,
93 struct regulatory_request *request)
94 {
95 struct ieee80211_supported_band *band;
96 struct ieee80211_channel *ch;
97 int i;
98
99 band = wiphy->bands[IEEE80211_BAND_5GHZ];
100 for (i = 0; i < band->n_channels; i++) {
101 ch = &band->channels[i];
102 if (ch->flags & IEEE80211_CHAN_DISABLED)
103 continue;
104
105 if (ch->flags & IEEE80211_CHAN_RADAR)
106 ch->flags |= IEEE80211_CHAN_NO_IBSS |
107 IEEE80211_CHAN_PASSIVE_SCAN;
108
109 }
110
111 return 0;
112 }
113
114 static int wl1271_set_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif,
115 bool enable)
116 {
117 int ret = 0;
118
119 /* we should hold wl->mutex */
120 ret = wl1271_acx_ps_rx_streaming(wl, wlvif, enable);
121 if (ret < 0)
122 goto out;
123
124 if (enable)
125 set_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
126 else
127 clear_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
128 out:
129 return ret;
130 }
131
132 /*
133 * this function is being called when the rx_streaming interval
134 * has beed changed or rx_streaming should be disabled
135 */
136 int wl1271_recalc_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif)
137 {
138 int ret = 0;
139 int period = wl->conf.rx_streaming.interval;
140
141 /* don't reconfigure if rx_streaming is disabled */
142 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
143 goto out;
144
145 /* reconfigure/disable according to new streaming_period */
146 if (period &&
147 test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
148 (wl->conf.rx_streaming.always ||
149 test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
150 ret = wl1271_set_rx_streaming(wl, wlvif, true);
151 else {
152 ret = wl1271_set_rx_streaming(wl, wlvif, false);
153 /* don't cancel_work_sync since we might deadlock */
154 del_timer_sync(&wlvif->rx_streaming_timer);
155 }
156 out:
157 return ret;
158 }
159
160 static void wl1271_rx_streaming_enable_work(struct work_struct *work)
161 {
162 int ret;
163 struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
164 rx_streaming_enable_work);
165 struct wl1271 *wl = wlvif->wl;
166
167 mutex_lock(&wl->mutex);
168
169 if (test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags) ||
170 !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
171 (!wl->conf.rx_streaming.always &&
172 !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
173 goto out;
174
175 if (!wl->conf.rx_streaming.interval)
176 goto out;
177
178 ret = wl1271_ps_elp_wakeup(wl);
179 if (ret < 0)
180 goto out;
181
182 ret = wl1271_set_rx_streaming(wl, wlvif, true);
183 if (ret < 0)
184 goto out_sleep;
185
186 /* stop it after some time of inactivity */
187 mod_timer(&wlvif->rx_streaming_timer,
188 jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));
189
190 out_sleep:
191 wl1271_ps_elp_sleep(wl);
192 out:
193 mutex_unlock(&wl->mutex);
194 }
195
196 static void wl1271_rx_streaming_disable_work(struct work_struct *work)
197 {
198 int ret;
199 struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
200 rx_streaming_disable_work);
201 struct wl1271 *wl = wlvif->wl;
202
203 mutex_lock(&wl->mutex);
204
205 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
206 goto out;
207
208 ret = wl1271_ps_elp_wakeup(wl);
209 if (ret < 0)
210 goto out;
211
212 ret = wl1271_set_rx_streaming(wl, wlvif, false);
213 if (ret)
214 goto out_sleep;
215
216 out_sleep:
217 wl1271_ps_elp_sleep(wl);
218 out:
219 mutex_unlock(&wl->mutex);
220 }
221
222 static void wl1271_rx_streaming_timer(unsigned long data)
223 {
224 struct wl12xx_vif *wlvif = (struct wl12xx_vif *)data;
225 struct wl1271 *wl = wlvif->wl;
226 ieee80211_queue_work(wl->hw, &wlvif->rx_streaming_disable_work);
227 }
228
229 /* wl->mutex must be taken */
230 void wl12xx_rearm_tx_watchdog_locked(struct wl1271 *wl)
231 {
232 /* if the watchdog is not armed, don't do anything */
233 if (wl->tx_allocated_blocks == 0)
234 return;
235
236 cancel_delayed_work(&wl->tx_watchdog_work);
237 ieee80211_queue_delayed_work(wl->hw, &wl->tx_watchdog_work,
238 msecs_to_jiffies(wl->conf.tx.tx_watchdog_timeout));
239 }
240
241 static void wl12xx_tx_watchdog_work(struct work_struct *work)
242 {
243 struct delayed_work *dwork;
244 struct wl1271 *wl;
245
246 dwork = container_of(work, struct delayed_work, work);
247 wl = container_of(dwork, struct wl1271, tx_watchdog_work);
248
249 mutex_lock(&wl->mutex);
250
251 if (unlikely(wl->state == WL1271_STATE_OFF))
252 goto out;
253
254 /* Tx went out in the meantime - everything is ok */
255 if (unlikely(wl->tx_allocated_blocks == 0))
256 goto out;
257
258 /*
259 * if a ROC is in progress, we might not have any Tx for a long
260 * time (e.g. pending Tx on the non-ROC channels)
261 */
262 if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
263 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to ROC",
264 wl->conf.tx.tx_watchdog_timeout);
265 wl12xx_rearm_tx_watchdog_locked(wl);
266 goto out;
267 }
268
269 /*
270 * if a scan is in progress, we might not have any Tx for a long
271 * time
272 */
273 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
274 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to scan",
275 wl->conf.tx.tx_watchdog_timeout);
276 wl12xx_rearm_tx_watchdog_locked(wl);
277 goto out;
278 }
279
280 /*
281 * AP might cache a frame for a long time for a sleeping station,
282 * so rearm the timer if there's an AP interface with stations. If
283 * Tx is genuinely stuck we will most hopefully discover it when all
284 * stations are removed due to inactivity.
285 */
286 if (wl->active_sta_count) {
287 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms. AP has "
288 " %d stations",
289 wl->conf.tx.tx_watchdog_timeout,
290 wl->active_sta_count);
291 wl12xx_rearm_tx_watchdog_locked(wl);
292 goto out;
293 }
294
295 wl1271_error("Tx stuck (in FW) for %d ms. Starting recovery",
296 wl->conf.tx.tx_watchdog_timeout);
297 wl12xx_queue_recovery_work(wl);
298
299 out:
300 mutex_unlock(&wl->mutex);
301 }
302
303 static void wlcore_adjust_conf(struct wl1271 *wl)
304 {
305 /* Adjust settings according to optional module parameters */
306 if (fwlog_param) {
307 if (!strcmp(fwlog_param, "continuous")) {
308 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
309 } else if (!strcmp(fwlog_param, "ondemand")) {
310 wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND;
311 } else if (!strcmp(fwlog_param, "dbgpins")) {
312 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
313 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS;
314 } else if (!strcmp(fwlog_param, "disable")) {
315 wl->conf.fwlog.mem_blocks = 0;
316 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
317 } else {
318 wl1271_error("Unknown fwlog parameter %s", fwlog_param);
319 }
320 }
321 }
322
323 static int wl1271_plt_init(struct wl1271 *wl)
324 {
325 int ret;
326
327 ret = wl->ops->hw_init(wl);
328 if (ret < 0)
329 return ret;
330
331 ret = wl1271_acx_init_mem_config(wl);
332 if (ret < 0)
333 return ret;
334
335 ret = wl12xx_acx_mem_cfg(wl);
336 if (ret < 0)
337 goto out_free_memmap;
338
339 /* Enable data path */
340 ret = wl1271_cmd_data_path(wl, 1);
341 if (ret < 0)
342 goto out_free_memmap;
343
344 /* Configure for CAM power saving (ie. always active) */
345 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
346 if (ret < 0)
347 goto out_free_memmap;
348
349 /* configure PM */
350 ret = wl1271_acx_pm_config(wl);
351 if (ret < 0)
352 goto out_free_memmap;
353
354 return 0;
355
356 out_free_memmap:
357 kfree(wl->target_mem_map);
358 wl->target_mem_map = NULL;
359
360 return ret;
361 }
362
363 static void wl12xx_irq_ps_regulate_link(struct wl1271 *wl,
364 struct wl12xx_vif *wlvif,
365 u8 hlid, u8 tx_pkts)
366 {
367 bool fw_ps, single_sta;
368
369 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
370 single_sta = (wl->active_sta_count == 1);
371
372 /*
373 * Wake up from high level PS if the STA is asleep with too little
374 * packets in FW or if the STA is awake.
375 */
376 if (!fw_ps || tx_pkts < WL1271_PS_STA_MAX_PACKETS)
377 wl12xx_ps_link_end(wl, wlvif, hlid);
378
379 /*
380 * Start high-level PS if the STA is asleep with enough blocks in FW.
381 * Make an exception if this is the only connected station. In this
382 * case FW-memory congestion is not a problem.
383 */
384 else if (!single_sta && fw_ps && tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
385 wl12xx_ps_link_start(wl, wlvif, hlid, true);
386 }
387
388 static void wl12xx_irq_update_links_status(struct wl1271 *wl,
389 struct wl12xx_vif *wlvif,
390 struct wl_fw_status *status)
391 {
392 struct wl1271_link *lnk;
393 u32 cur_fw_ps_map;
394 u8 hlid, cnt;
395
396 /* TODO: also use link_fast_bitmap here */
397
398 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
399 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
400 wl1271_debug(DEBUG_PSM,
401 "link ps prev 0x%x cur 0x%x changed 0x%x",
402 wl->ap_fw_ps_map, cur_fw_ps_map,
403 wl->ap_fw_ps_map ^ cur_fw_ps_map);
404
405 wl->ap_fw_ps_map = cur_fw_ps_map;
406 }
407
408 for_each_set_bit(hlid, wlvif->ap.sta_hlid_map, WL12XX_MAX_LINKS) {
409 lnk = &wl->links[hlid];
410 cnt = status->counters.tx_lnk_free_pkts[hlid] -
411 lnk->prev_freed_pkts;
412
413 lnk->prev_freed_pkts = status->counters.tx_lnk_free_pkts[hlid];
414 lnk->allocated_pkts -= cnt;
415
416 wl12xx_irq_ps_regulate_link(wl, wlvif, hlid,
417 lnk->allocated_pkts);
418 }
419 }
420
421 static void wl12xx_fw_status(struct wl1271 *wl,
422 struct wl_fw_status *status)
423 {
424 struct wl12xx_vif *wlvif;
425 struct timespec ts;
426 u32 old_tx_blk_count = wl->tx_blocks_available;
427 int avail, freed_blocks;
428 int i;
429 size_t status_len;
430
431 status_len = sizeof(*status) + wl->fw_status_priv_len;
432
433 wlcore_raw_read_data(wl, REG_RAW_FW_STATUS_ADDR, status,
434 status_len, false);
435
436 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
437 "drv_rx_counter = %d, tx_results_counter = %d)",
438 status->intr,
439 status->fw_rx_counter,
440 status->drv_rx_counter,
441 status->tx_results_counter);
442
443 for (i = 0; i < NUM_TX_QUEUES; i++) {
444 /* prevent wrap-around in freed-packets counter */
445 wl->tx_allocated_pkts[i] -=
446 (status->counters.tx_released_pkts[i] -
447 wl->tx_pkts_freed[i]) & 0xff;
448
449 wl->tx_pkts_freed[i] = status->counters.tx_released_pkts[i];
450 }
451
452 /* prevent wrap-around in total blocks counter */
453 if (likely(wl->tx_blocks_freed <=
454 le32_to_cpu(status->total_released_blks)))
455 freed_blocks = le32_to_cpu(status->total_released_blks) -
456 wl->tx_blocks_freed;
457 else
458 freed_blocks = 0x100000000LL - wl->tx_blocks_freed +
459 le32_to_cpu(status->total_released_blks);
460
461 wl->tx_blocks_freed = le32_to_cpu(status->total_released_blks);
462
463 wl->tx_allocated_blocks -= freed_blocks;
464
465 /*
466 * If the FW freed some blocks:
467 * If we still have allocated blocks - re-arm the timer, Tx is
468 * not stuck. Otherwise, cancel the timer (no Tx currently).
469 */
470 if (freed_blocks) {
471 if (wl->tx_allocated_blocks)
472 wl12xx_rearm_tx_watchdog_locked(wl);
473 else
474 cancel_delayed_work(&wl->tx_watchdog_work);
475 }
476
477 avail = le32_to_cpu(status->tx_total) - wl->tx_allocated_blocks;
478
479 /*
480 * The FW might change the total number of TX memblocks before
481 * we get a notification about blocks being released. Thus, the
482 * available blocks calculation might yield a temporary result
483 * which is lower than the actual available blocks. Keeping in
484 * mind that only blocks that were allocated can be moved from
485 * TX to RX, tx_blocks_available should never decrease here.
486 */
487 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
488 avail);
489
490 /* if more blocks are available now, tx work can be scheduled */
491 if (wl->tx_blocks_available > old_tx_blk_count)
492 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
493
494 /* for AP update num of allocated TX blocks per link and ps status */
495 wl12xx_for_each_wlvif_ap(wl, wlvif) {
496 wl12xx_irq_update_links_status(wl, wlvif, status);
497 }
498
499 /* update the host-chipset time offset */
500 getnstimeofday(&ts);
501 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
502 (s64)le32_to_cpu(status->fw_localtime);
503 }
504
505 static void wl1271_flush_deferred_work(struct wl1271 *wl)
506 {
507 struct sk_buff *skb;
508
509 /* Pass all received frames to the network stack */
510 while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
511 ieee80211_rx_ni(wl->hw, skb);
512
513 /* Return sent skbs to the network stack */
514 while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
515 ieee80211_tx_status_ni(wl->hw, skb);
516 }
517
518 static void wl1271_netstack_work(struct work_struct *work)
519 {
520 struct wl1271 *wl =
521 container_of(work, struct wl1271, netstack_work);
522
523 do {
524 wl1271_flush_deferred_work(wl);
525 } while (skb_queue_len(&wl->deferred_rx_queue));
526 }
527
528 #define WL1271_IRQ_MAX_LOOPS 256
529
530 static irqreturn_t wl1271_irq(int irq, void *cookie)
531 {
532 int ret;
533 u32 intr;
534 int loopcount = WL1271_IRQ_MAX_LOOPS;
535 struct wl1271 *wl = (struct wl1271 *)cookie;
536 bool done = false;
537 unsigned int defer_count;
538 unsigned long flags;
539
540 /* TX might be handled here, avoid redundant work */
541 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
542 cancel_work_sync(&wl->tx_work);
543
544 /*
545 * In case edge triggered interrupt must be used, we cannot iterate
546 * more than once without introducing race conditions with the hardirq.
547 */
548 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
549 loopcount = 1;
550
551 mutex_lock(&wl->mutex);
552
553 wl1271_debug(DEBUG_IRQ, "IRQ work");
554
555 if (unlikely(wl->state == WL1271_STATE_OFF))
556 goto out;
557
558 ret = wl1271_ps_elp_wakeup(wl);
559 if (ret < 0)
560 goto out;
561
562 while (!done && loopcount--) {
563 /*
564 * In order to avoid a race with the hardirq, clear the flag
565 * before acknowledging the chip. Since the mutex is held,
566 * wl1271_ps_elp_wakeup cannot be called concurrently.
567 */
568 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
569 smp_mb__after_clear_bit();
570
571 wl12xx_fw_status(wl, wl->fw_status);
572
573 wlcore_hw_tx_immediate_compl(wl);
574
575 intr = le32_to_cpu(wl->fw_status->intr);
576 intr &= WL1271_INTR_MASK;
577 if (!intr) {
578 done = true;
579 continue;
580 }
581
582 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
583 wl1271_error("watchdog interrupt received! "
584 "starting recovery.");
585 wl12xx_queue_recovery_work(wl);
586
587 /* restarting the chip. ignore any other interrupt. */
588 goto out;
589 }
590
591 if (likely(intr & WL1271_ACX_INTR_DATA)) {
592 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
593
594 wl12xx_rx(wl, wl->fw_status);
595
596 /* Check if any tx blocks were freed */
597 spin_lock_irqsave(&wl->wl_lock, flags);
598 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
599 wl1271_tx_total_queue_count(wl) > 0) {
600 spin_unlock_irqrestore(&wl->wl_lock, flags);
601 /*
602 * In order to avoid starvation of the TX path,
603 * call the work function directly.
604 */
605 wl1271_tx_work_locked(wl);
606 } else {
607 spin_unlock_irqrestore(&wl->wl_lock, flags);
608 }
609
610 /* check for tx results */
611 wlcore_hw_tx_delayed_compl(wl);
612
613 /* Make sure the deferred queues don't get too long */
614 defer_count = skb_queue_len(&wl->deferred_tx_queue) +
615 skb_queue_len(&wl->deferred_rx_queue);
616 if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
617 wl1271_flush_deferred_work(wl);
618 }
619
620 if (intr & WL1271_ACX_INTR_EVENT_A) {
621 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
622 wl1271_event_handle(wl, 0);
623 }
624
625 if (intr & WL1271_ACX_INTR_EVENT_B) {
626 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
627 wl1271_event_handle(wl, 1);
628 }
629
630 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
631 wl1271_debug(DEBUG_IRQ,
632 "WL1271_ACX_INTR_INIT_COMPLETE");
633
634 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
635 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
636 }
637
638 wl1271_ps_elp_sleep(wl);
639
640 out:
641 spin_lock_irqsave(&wl->wl_lock, flags);
642 /* In case TX was not handled here, queue TX work */
643 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
644 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
645 wl1271_tx_total_queue_count(wl) > 0)
646 ieee80211_queue_work(wl->hw, &wl->tx_work);
647 spin_unlock_irqrestore(&wl->wl_lock, flags);
648
649 mutex_unlock(&wl->mutex);
650
651 return IRQ_HANDLED;
652 }
653
654 struct vif_counter_data {
655 u8 counter;
656
657 struct ieee80211_vif *cur_vif;
658 bool cur_vif_running;
659 };
660
661 static void wl12xx_vif_count_iter(void *data, u8 *mac,
662 struct ieee80211_vif *vif)
663 {
664 struct vif_counter_data *counter = data;
665
666 counter->counter++;
667 if (counter->cur_vif == vif)
668 counter->cur_vif_running = true;
669 }
670
671 /* caller must not hold wl->mutex, as it might deadlock */
672 static void wl12xx_get_vif_count(struct ieee80211_hw *hw,
673 struct ieee80211_vif *cur_vif,
674 struct vif_counter_data *data)
675 {
676 memset(data, 0, sizeof(*data));
677 data->cur_vif = cur_vif;
678
679 ieee80211_iterate_active_interfaces(hw,
680 wl12xx_vif_count_iter, data);
681 }
682
683 static int wl12xx_fetch_firmware(struct wl1271 *wl, bool plt)
684 {
685 const struct firmware *fw;
686 const char *fw_name;
687 enum wl12xx_fw_type fw_type;
688 int ret;
689
690 if (plt) {
691 fw_type = WL12XX_FW_TYPE_PLT;
692 fw_name = wl->plt_fw_name;
693 } else {
694 /*
695 * we can't call wl12xx_get_vif_count() here because
696 * wl->mutex is taken, so use the cached last_vif_count value
697 */
698 if (wl->last_vif_count > 1) {
699 fw_type = WL12XX_FW_TYPE_MULTI;
700 fw_name = wl->mr_fw_name;
701 } else {
702 fw_type = WL12XX_FW_TYPE_NORMAL;
703 fw_name = wl->sr_fw_name;
704 }
705 }
706
707 if (wl->fw_type == fw_type)
708 return 0;
709
710 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
711
712 ret = request_firmware(&fw, fw_name, wl->dev);
713
714 if (ret < 0) {
715 wl1271_error("could not get firmware %s: %d", fw_name, ret);
716 return ret;
717 }
718
719 if (fw->size % 4) {
720 wl1271_error("firmware size is not multiple of 32 bits: %zu",
721 fw->size);
722 ret = -EILSEQ;
723 goto out;
724 }
725
726 vfree(wl->fw);
727 wl->fw_type = WL12XX_FW_TYPE_NONE;
728 wl->fw_len = fw->size;
729 wl->fw = vmalloc(wl->fw_len);
730
731 if (!wl->fw) {
732 wl1271_error("could not allocate memory for the firmware");
733 ret = -ENOMEM;
734 goto out;
735 }
736
737 memcpy(wl->fw, fw->data, wl->fw_len);
738 ret = 0;
739 wl->fw_type = fw_type;
740 out:
741 release_firmware(fw);
742
743 return ret;
744 }
745
746 static int wl1271_fetch_nvs(struct wl1271 *wl)
747 {
748 const struct firmware *fw;
749 int ret;
750
751 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl->dev);
752
753 if (ret < 0) {
754 wl1271_error("could not get nvs file %s: %d", WL12XX_NVS_NAME,
755 ret);
756 return ret;
757 }
758
759 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
760
761 if (!wl->nvs) {
762 wl1271_error("could not allocate memory for the nvs file");
763 ret = -ENOMEM;
764 goto out;
765 }
766
767 wl->nvs_len = fw->size;
768
769 out:
770 release_firmware(fw);
771
772 return ret;
773 }
774
775 void wl12xx_queue_recovery_work(struct wl1271 *wl)
776 {
777 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
778 ieee80211_queue_work(wl->hw, &wl->recovery_work);
779 }
780
781 size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
782 {
783 size_t len = 0;
784
785 /* The FW log is a length-value list, find where the log end */
786 while (len < maxlen) {
787 if (memblock[len] == 0)
788 break;
789 if (len + memblock[len] + 1 > maxlen)
790 break;
791 len += memblock[len] + 1;
792 }
793
794 /* Make sure we have enough room */
795 len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size));
796
797 /* Fill the FW log file, consumed by the sysfs fwlog entry */
798 memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
799 wl->fwlog_size += len;
800
801 return len;
802 }
803
804 static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
805 {
806 u32 addr;
807 u32 first_addr;
808 u8 *block;
809
810 if ((wl->quirks & WLCORE_QUIRK_FWLOG_NOT_IMPLEMENTED) ||
811 (wl->conf.fwlog.mode != WL12XX_FWLOG_ON_DEMAND) ||
812 (wl->conf.fwlog.mem_blocks == 0))
813 return;
814
815 wl1271_info("Reading FW panic log");
816
817 block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL);
818 if (!block)
819 return;
820
821 /*
822 * Make sure the chip is awake and the logger isn't active.
823 * This might fail if the firmware hanged.
824 */
825 if (!wl1271_ps_elp_wakeup(wl))
826 wl12xx_cmd_stop_fwlog(wl);
827
828 /* Read the first memory block address */
829 wl12xx_fw_status(wl, wl->fw_status);
830 first_addr = le32_to_cpu(wl->fw_status->log_start_addr);
831 if (!first_addr)
832 goto out;
833
834 /* Traverse the memory blocks linked list */
835 addr = first_addr;
836 do {
837 memset(block, 0, WL12XX_HW_BLOCK_SIZE);
838 wl1271_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE,
839 false);
840
841 /*
842 * Memory blocks are linked to one another. The first 4 bytes
843 * of each memory block hold the hardware address of the next
844 * one. The last memory block points to the first one.
845 */
846 addr = le32_to_cpup((__le32 *)block);
847 if (!wl12xx_copy_fwlog(wl, block + sizeof(addr),
848 WL12XX_HW_BLOCK_SIZE - sizeof(addr)))
849 break;
850 } while (addr && (addr != first_addr));
851
852 wake_up_interruptible(&wl->fwlog_waitq);
853
854 out:
855 kfree(block);
856 }
857
858 static void wl1271_recovery_work(struct work_struct *work)
859 {
860 struct wl1271 *wl =
861 container_of(work, struct wl1271, recovery_work);
862 struct wl12xx_vif *wlvif;
863 struct ieee80211_vif *vif;
864
865 mutex_lock(&wl->mutex);
866
867 if (wl->state != WL1271_STATE_ON || wl->plt)
868 goto out_unlock;
869
870 /* Avoid a recursive recovery */
871 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
872
873 wl12xx_read_fwlog_panic(wl);
874
875 /* change partitions momentarily so we can read the FW pc */
876 wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
877 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
878 wl->chip.fw_ver_str,
879 wlcore_read_reg(wl, REG_PC_ON_RECOVERY));
880 wlcore_set_partition(wl, &wl->ptable[PART_WORK]);
881
882 BUG_ON(bug_on_recovery &&
883 !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags));
884
885 if (no_recovery) {
886 wl1271_info("No recovery (chosen on module load). Fw will remain stuck.");
887 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
888 goto out_unlock;
889 }
890
891 BUG_ON(bug_on_recovery);
892
893 /*
894 * Advance security sequence number to overcome potential progress
895 * in the firmware during recovery. This doens't hurt if the network is
896 * not encrypted.
897 */
898 wl12xx_for_each_wlvif(wl, wlvif) {
899 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
900 test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
901 wlvif->tx_security_seq +=
902 WL1271_TX_SQN_POST_RECOVERY_PADDING;
903 }
904
905 /* Prevent spurious TX during FW restart */
906 ieee80211_stop_queues(wl->hw);
907
908 if (wl->sched_scanning) {
909 ieee80211_sched_scan_stopped(wl->hw);
910 wl->sched_scanning = false;
911 }
912
913 /* reboot the chipset */
914 while (!list_empty(&wl->wlvif_list)) {
915 wlvif = list_first_entry(&wl->wlvif_list,
916 struct wl12xx_vif, list);
917 vif = wl12xx_wlvif_to_vif(wlvif);
918 __wl1271_op_remove_interface(wl, vif, false);
919 }
920 mutex_unlock(&wl->mutex);
921 wl1271_op_stop(wl->hw);
922
923 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
924
925 ieee80211_restart_hw(wl->hw);
926
927 /*
928 * Its safe to enable TX now - the queues are stopped after a request
929 * to restart the HW.
930 */
931 ieee80211_wake_queues(wl->hw);
932 return;
933 out_unlock:
934 mutex_unlock(&wl->mutex);
935 }
936
937 static void wl1271_fw_wakeup(struct wl1271 *wl)
938 {
939 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_WAKE_UP);
940 }
941
942 static int wl1271_setup(struct wl1271 *wl)
943 {
944 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
945 if (!wl->fw_status)
946 return -ENOMEM;
947
948 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
949 if (!wl->tx_res_if) {
950 kfree(wl->fw_status);
951 return -ENOMEM;
952 }
953
954 return 0;
955 }
956
957 static int wl12xx_set_power_on(struct wl1271 *wl)
958 {
959 int ret;
960
961 msleep(WL1271_PRE_POWER_ON_SLEEP);
962 ret = wl1271_power_on(wl);
963 if (ret < 0)
964 goto out;
965 msleep(WL1271_POWER_ON_SLEEP);
966 wl1271_io_reset(wl);
967 wl1271_io_init(wl);
968
969 wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
970
971 /* ELP module wake up */
972 wl1271_fw_wakeup(wl);
973
974 out:
975 return ret;
976 }
977
978 static int wl12xx_chip_wakeup(struct wl1271 *wl, bool plt)
979 {
980 int ret = 0;
981
982 ret = wl12xx_set_power_on(wl);
983 if (ret < 0)
984 goto out;
985
986 /*
987 * For wl127x based devices we could use the default block
988 * size (512 bytes), but due to a bug in the sdio driver, we
989 * need to set it explicitly after the chip is powered on. To
990 * simplify the code and since the performance impact is
991 * negligible, we use the same block size for all different
992 * chip types.
993 */
994 if (wl1271_set_block_size(wl))
995 wl->quirks |= WLCORE_QUIRK_TX_BLOCKSIZE_ALIGN;
996
997 ret = wl->ops->identify_chip(wl);
998 if (ret < 0)
999 goto out;
1000
1001 /* TODO: make sure the lower driver has set things up correctly */
1002
1003 ret = wl1271_setup(wl);
1004 if (ret < 0)
1005 goto out;
1006
1007 ret = wl12xx_fetch_firmware(wl, plt);
1008 if (ret < 0)
1009 goto out;
1010
1011 /* No NVS from netlink, try to get it from the filesystem */
1012 if (wl->nvs == NULL) {
1013 ret = wl1271_fetch_nvs(wl);
1014 if (ret < 0)
1015 goto out;
1016 }
1017
1018 out:
1019 return ret;
1020 }
1021
1022 int wl1271_plt_start(struct wl1271 *wl)
1023 {
1024 int retries = WL1271_BOOT_RETRIES;
1025 struct wiphy *wiphy = wl->hw->wiphy;
1026 int ret;
1027
1028 mutex_lock(&wl->mutex);
1029
1030 wl1271_notice("power up");
1031
1032 if (wl->state != WL1271_STATE_OFF) {
1033 wl1271_error("cannot go into PLT state because not "
1034 "in off state: %d", wl->state);
1035 ret = -EBUSY;
1036 goto out;
1037 }
1038
1039 while (retries) {
1040 retries--;
1041 ret = wl12xx_chip_wakeup(wl, true);
1042 if (ret < 0)
1043 goto power_off;
1044
1045 ret = wl->ops->boot(wl);
1046 if (ret < 0)
1047 goto power_off;
1048
1049 ret = wl1271_plt_init(wl);
1050 if (ret < 0)
1051 goto irq_disable;
1052
1053 wl->plt = true;
1054 wl->state = WL1271_STATE_ON;
1055 wl1271_notice("firmware booted in PLT mode (%s)",
1056 wl->chip.fw_ver_str);
1057
1058 /* update hw/fw version info in wiphy struct */
1059 wiphy->hw_version = wl->chip.id;
1060 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1061 sizeof(wiphy->fw_version));
1062
1063 goto out;
1064
1065 irq_disable:
1066 mutex_unlock(&wl->mutex);
1067 /* Unlocking the mutex in the middle of handling is
1068 inherently unsafe. In this case we deem it safe to do,
1069 because we need to let any possibly pending IRQ out of
1070 the system (and while we are WL1271_STATE_OFF the IRQ
1071 work function will not do anything.) Also, any other
1072 possible concurrent operations will fail due to the
1073 current state, hence the wl1271 struct should be safe. */
1074 wlcore_disable_interrupts(wl);
1075 wl1271_flush_deferred_work(wl);
1076 cancel_work_sync(&wl->netstack_work);
1077 mutex_lock(&wl->mutex);
1078 power_off:
1079 wl1271_power_off(wl);
1080 }
1081
1082 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1083 WL1271_BOOT_RETRIES);
1084 out:
1085 mutex_unlock(&wl->mutex);
1086
1087 return ret;
1088 }
1089
1090 int wl1271_plt_stop(struct wl1271 *wl)
1091 {
1092 int ret = 0;
1093
1094 wl1271_notice("power down");
1095
1096 /*
1097 * Interrupts must be disabled before setting the state to OFF.
1098 * Otherwise, the interrupt handler might be called and exit without
1099 * reading the interrupt status.
1100 */
1101 wlcore_disable_interrupts(wl);
1102 mutex_lock(&wl->mutex);
1103 if (!wl->plt) {
1104 mutex_unlock(&wl->mutex);
1105
1106 /*
1107 * This will not necessarily enable interrupts as interrupts
1108 * may have been disabled when op_stop was called. It will,
1109 * however, balance the above call to disable_interrupts().
1110 */
1111 wlcore_enable_interrupts(wl);
1112
1113 wl1271_error("cannot power down because not in PLT "
1114 "state: %d", wl->state);
1115 ret = -EBUSY;
1116 goto out;
1117 }
1118
1119 mutex_unlock(&wl->mutex);
1120
1121 wl1271_flush_deferred_work(wl);
1122 cancel_work_sync(&wl->netstack_work);
1123 cancel_work_sync(&wl->recovery_work);
1124 cancel_delayed_work_sync(&wl->elp_work);
1125 cancel_delayed_work_sync(&wl->tx_watchdog_work);
1126 cancel_delayed_work_sync(&wl->connection_loss_work);
1127
1128 mutex_lock(&wl->mutex);
1129 wl1271_power_off(wl);
1130 wl->flags = 0;
1131 wl->state = WL1271_STATE_OFF;
1132 wl->plt = false;
1133 wl->rx_counter = 0;
1134 mutex_unlock(&wl->mutex);
1135
1136 out:
1137 return ret;
1138 }
1139
1140 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1141 {
1142 struct wl1271 *wl = hw->priv;
1143 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1144 struct ieee80211_vif *vif = info->control.vif;
1145 struct wl12xx_vif *wlvif = NULL;
1146 unsigned long flags;
1147 int q, mapping;
1148 u8 hlid;
1149
1150 if (vif)
1151 wlvif = wl12xx_vif_to_data(vif);
1152
1153 mapping = skb_get_queue_mapping(skb);
1154 q = wl1271_tx_get_queue(mapping);
1155
1156 hlid = wl12xx_tx_get_hlid(wl, wlvif, skb);
1157
1158 spin_lock_irqsave(&wl->wl_lock, flags);
1159
1160 /* queue the packet */
1161 if (hlid == WL12XX_INVALID_LINK_ID ||
1162 (wlvif && !test_bit(hlid, wlvif->links_map))) {
1163 wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d", hlid, q);
1164 ieee80211_free_txskb(hw, skb);
1165 goto out;
1166 }
1167
1168 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d len %d",
1169 hlid, q, skb->len);
1170 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1171
1172 wl->tx_queue_count[q]++;
1173
1174 /*
1175 * The workqueue is slow to process the tx_queue and we need stop
1176 * the queue here, otherwise the queue will get too long.
1177 */
1178 if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1179 wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
1180 ieee80211_stop_queue(wl->hw, mapping);
1181 set_bit(q, &wl->stopped_queues_map);
1182 }
1183
1184 /*
1185 * The chip specific setup must run before the first TX packet -
1186 * before that, the tx_work will not be initialized!
1187 */
1188
1189 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1190 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1191 ieee80211_queue_work(wl->hw, &wl->tx_work);
1192
1193 out:
1194 spin_unlock_irqrestore(&wl->wl_lock, flags);
1195 }
1196
1197 int wl1271_tx_dummy_packet(struct wl1271 *wl)
1198 {
1199 unsigned long flags;
1200 int q;
1201
1202 /* no need to queue a new dummy packet if one is already pending */
1203 if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags))
1204 return 0;
1205
1206 q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
1207
1208 spin_lock_irqsave(&wl->wl_lock, flags);
1209 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1210 wl->tx_queue_count[q]++;
1211 spin_unlock_irqrestore(&wl->wl_lock, flags);
1212
1213 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1214 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1215 wl1271_tx_work_locked(wl);
1216
1217 /*
1218 * If the FW TX is busy, TX work will be scheduled by the threaded
1219 * interrupt handler function
1220 */
1221 return 0;
1222 }
1223
1224 /*
1225 * The size of the dummy packet should be at least 1400 bytes. However, in
1226 * order to minimize the number of bus transactions, aligning it to 512 bytes
1227 * boundaries could be beneficial, performance wise
1228 */
1229 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1230
1231 static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1232 {
1233 struct sk_buff *skb;
1234 struct ieee80211_hdr_3addr *hdr;
1235 unsigned int dummy_packet_size;
1236
1237 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1238 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1239
1240 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1241 if (!skb) {
1242 wl1271_warning("Failed to allocate a dummy packet skb");
1243 return NULL;
1244 }
1245
1246 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1247
1248 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1249 memset(hdr, 0, sizeof(*hdr));
1250 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1251 IEEE80211_STYPE_NULLFUNC |
1252 IEEE80211_FCTL_TODS);
1253
1254 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1255
1256 /* Dummy packets require the TID to be management */
1257 skb->priority = WL1271_TID_MGMT;
1258
1259 /* Initialize all fields that might be used */
1260 skb_set_queue_mapping(skb, 0);
1261 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1262
1263 return skb;
1264 }
1265
1266
1267 #ifdef CONFIG_PM
1268 static int
1269 wl1271_validate_wowlan_pattern(struct cfg80211_wowlan_trig_pkt_pattern *p)
1270 {
1271 int num_fields = 0, in_field = 0, fields_size = 0;
1272 int i, pattern_len = 0;
1273
1274 if (!p->mask) {
1275 wl1271_warning("No mask in WoWLAN pattern");
1276 return -EINVAL;
1277 }
1278
1279 /*
1280 * The pattern is broken up into segments of bytes at different offsets
1281 * that need to be checked by the FW filter. Each segment is called
1282 * a field in the FW API. We verify that the total number of fields
1283 * required for this pattern won't exceed FW limits (8)
1284 * as well as the total fields buffer won't exceed the FW limit.
1285 * Note that if there's a pattern which crosses Ethernet/IP header
1286 * boundary a new field is required.
1287 */
1288 for (i = 0; i < p->pattern_len; i++) {
1289 if (test_bit(i, (unsigned long *)p->mask)) {
1290 if (!in_field) {
1291 in_field = 1;
1292 pattern_len = 1;
1293 } else {
1294 if (i == WL1271_RX_FILTER_ETH_HEADER_SIZE) {
1295 num_fields++;
1296 fields_size += pattern_len +
1297 RX_FILTER_FIELD_OVERHEAD;
1298 pattern_len = 1;
1299 } else
1300 pattern_len++;
1301 }
1302 } else {
1303 if (in_field) {
1304 in_field = 0;
1305 fields_size += pattern_len +
1306 RX_FILTER_FIELD_OVERHEAD;
1307 num_fields++;
1308 }
1309 }
1310 }
1311
1312 if (in_field) {
1313 fields_size += pattern_len + RX_FILTER_FIELD_OVERHEAD;
1314 num_fields++;
1315 }
1316
1317 if (num_fields > WL1271_RX_FILTER_MAX_FIELDS) {
1318 wl1271_warning("RX Filter too complex. Too many segments");
1319 return -EINVAL;
1320 }
1321
1322 if (fields_size > WL1271_RX_FILTER_MAX_FIELDS_SIZE) {
1323 wl1271_warning("RX filter pattern is too big");
1324 return -E2BIG;
1325 }
1326
1327 return 0;
1328 }
1329
1330 struct wl12xx_rx_filter *wl1271_rx_filter_alloc(void)
1331 {
1332 return kzalloc(sizeof(struct wl12xx_rx_filter), GFP_KERNEL);
1333 }
1334
1335 void wl1271_rx_filter_free(struct wl12xx_rx_filter *filter)
1336 {
1337 int i;
1338
1339 if (filter == NULL)
1340 return;
1341
1342 for (i = 0; i < filter->num_fields; i++)
1343 kfree(filter->fields[i].pattern);
1344
1345 kfree(filter);
1346 }
1347
1348 int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter,
1349 u16 offset, u8 flags,
1350 u8 *pattern, u8 len)
1351 {
1352 struct wl12xx_rx_filter_field *field;
1353
1354 if (filter->num_fields == WL1271_RX_FILTER_MAX_FIELDS) {
1355 wl1271_warning("Max fields per RX filter. can't alloc another");
1356 return -EINVAL;
1357 }
1358
1359 field = &filter->fields[filter->num_fields];
1360
1361 field->pattern = kzalloc(len, GFP_KERNEL);
1362 if (!field->pattern) {
1363 wl1271_warning("Failed to allocate RX filter pattern");
1364 return -ENOMEM;
1365 }
1366
1367 filter->num_fields++;
1368
1369 field->offset = cpu_to_le16(offset);
1370 field->flags = flags;
1371 field->len = len;
1372 memcpy(field->pattern, pattern, len);
1373
1374 return 0;
1375 }
1376
1377 int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter *filter)
1378 {
1379 int i, fields_size = 0;
1380
1381 for (i = 0; i < filter->num_fields; i++)
1382 fields_size += filter->fields[i].len +
1383 sizeof(struct wl12xx_rx_filter_field) -
1384 sizeof(u8 *);
1385
1386 return fields_size;
1387 }
1388
1389 void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter *filter,
1390 u8 *buf)
1391 {
1392 int i;
1393 struct wl12xx_rx_filter_field *field;
1394
1395 for (i = 0; i < filter->num_fields; i++) {
1396 field = (struct wl12xx_rx_filter_field *)buf;
1397
1398 field->offset = filter->fields[i].offset;
1399 field->flags = filter->fields[i].flags;
1400 field->len = filter->fields[i].len;
1401
1402 memcpy(&field->pattern, filter->fields[i].pattern, field->len);
1403 buf += sizeof(struct wl12xx_rx_filter_field) -
1404 sizeof(u8 *) + field->len;
1405 }
1406 }
1407
1408 /*
1409 * Allocates an RX filter returned through f
1410 * which needs to be freed using rx_filter_free()
1411 */
1412 static int wl1271_convert_wowlan_pattern_to_rx_filter(
1413 struct cfg80211_wowlan_trig_pkt_pattern *p,
1414 struct wl12xx_rx_filter **f)
1415 {
1416 int i, j, ret = 0;
1417 struct wl12xx_rx_filter *filter;
1418 u16 offset;
1419 u8 flags, len;
1420
1421 filter = wl1271_rx_filter_alloc();
1422 if (!filter) {
1423 wl1271_warning("Failed to alloc rx filter");
1424 ret = -ENOMEM;
1425 goto err;
1426 }
1427
1428 i = 0;
1429 while (i < p->pattern_len) {
1430 if (!test_bit(i, (unsigned long *)p->mask)) {
1431 i++;
1432 continue;
1433 }
1434
1435 for (j = i; j < p->pattern_len; j++) {
1436 if (!test_bit(j, (unsigned long *)p->mask))
1437 break;
1438
1439 if (i < WL1271_RX_FILTER_ETH_HEADER_SIZE &&
1440 j >= WL1271_RX_FILTER_ETH_HEADER_SIZE)
1441 break;
1442 }
1443
1444 if (i < WL1271_RX_FILTER_ETH_HEADER_SIZE) {
1445 offset = i;
1446 flags = WL1271_RX_FILTER_FLAG_ETHERNET_HEADER;
1447 } else {
1448 offset = i - WL1271_RX_FILTER_ETH_HEADER_SIZE;
1449 flags = WL1271_RX_FILTER_FLAG_IP_HEADER;
1450 }
1451
1452 len = j - i;
1453
1454 ret = wl1271_rx_filter_alloc_field(filter,
1455 offset,
1456 flags,
1457 &p->pattern[i], len);
1458 if (ret)
1459 goto err;
1460
1461 i = j;
1462 }
1463
1464 filter->action = FILTER_SIGNAL;
1465
1466 *f = filter;
1467 return 0;
1468
1469 err:
1470 wl1271_rx_filter_free(filter);
1471 *f = NULL;
1472
1473 return ret;
1474 }
1475
1476 static int wl1271_configure_wowlan(struct wl1271 *wl,
1477 struct cfg80211_wowlan *wow)
1478 {
1479 int i, ret;
1480
1481 if (!wow || wow->any || !wow->n_patterns) {
1482 wl1271_acx_default_rx_filter_enable(wl, 0, FILTER_SIGNAL);
1483 wl1271_rx_filter_clear_all(wl);
1484 return 0;
1485 }
1486
1487 if (WARN_ON(wow->n_patterns > WL1271_MAX_RX_FILTERS))
1488 return -EINVAL;
1489
1490 /* Validate all incoming patterns before clearing current FW state */
1491 for (i = 0; i < wow->n_patterns; i++) {
1492 ret = wl1271_validate_wowlan_pattern(&wow->patterns[i]);
1493 if (ret) {
1494 wl1271_warning("Bad wowlan pattern %d", i);
1495 return ret;
1496 }
1497 }
1498
1499 wl1271_acx_default_rx_filter_enable(wl, 0, FILTER_SIGNAL);
1500 wl1271_rx_filter_clear_all(wl);
1501
1502 /* Translate WoWLAN patterns into filters */
1503 for (i = 0; i < wow->n_patterns; i++) {
1504 struct cfg80211_wowlan_trig_pkt_pattern *p;
1505 struct wl12xx_rx_filter *filter = NULL;
1506
1507 p = &wow->patterns[i];
1508
1509 ret = wl1271_convert_wowlan_pattern_to_rx_filter(p, &filter);
1510 if (ret) {
1511 wl1271_warning("Failed to create an RX filter from "
1512 "wowlan pattern %d", i);
1513 goto out;
1514 }
1515
1516 ret = wl1271_rx_filter_enable(wl, i, 1, filter);
1517
1518 wl1271_rx_filter_free(filter);
1519 if (ret)
1520 goto out;
1521 }
1522
1523 ret = wl1271_acx_default_rx_filter_enable(wl, 1, FILTER_DROP);
1524
1525 out:
1526 return ret;
1527 }
1528
1529 static int wl1271_configure_suspend_sta(struct wl1271 *wl,
1530 struct wl12xx_vif *wlvif,
1531 struct cfg80211_wowlan *wow)
1532 {
1533 int ret = 0;
1534
1535 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
1536 goto out;
1537
1538 ret = wl1271_ps_elp_wakeup(wl);
1539 if (ret < 0)
1540 goto out;
1541
1542 wl1271_configure_wowlan(wl, wow);
1543 ret = wl1271_acx_wake_up_conditions(wl, wlvif,
1544 wl->conf.conn.suspend_wake_up_event,
1545 wl->conf.conn.suspend_listen_interval);
1546
1547 if (ret < 0)
1548 wl1271_error("suspend: set wake up conditions failed: %d", ret);
1549
1550 wl1271_ps_elp_sleep(wl);
1551
1552 out:
1553 return ret;
1554
1555 }
1556
1557 static int wl1271_configure_suspend_ap(struct wl1271 *wl,
1558 struct wl12xx_vif *wlvif)
1559 {
1560 int ret = 0;
1561
1562 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
1563 goto out;
1564
1565 ret = wl1271_ps_elp_wakeup(wl);
1566 if (ret < 0)
1567 goto out;
1568
1569 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
1570
1571 wl1271_ps_elp_sleep(wl);
1572 out:
1573 return ret;
1574
1575 }
1576
1577 static int wl1271_configure_suspend(struct wl1271 *wl,
1578 struct wl12xx_vif *wlvif,
1579 struct cfg80211_wowlan *wow)
1580 {
1581 if (wlvif->bss_type == BSS_TYPE_STA_BSS)
1582 return wl1271_configure_suspend_sta(wl, wlvif, wow);
1583 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
1584 return wl1271_configure_suspend_ap(wl, wlvif);
1585 return 0;
1586 }
1587
1588 static void wl1271_configure_resume(struct wl1271 *wl,
1589 struct wl12xx_vif *wlvif)
1590 {
1591 int ret = 0;
1592 bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
1593 bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
1594
1595 if ((!is_ap) && (!is_sta))
1596 return;
1597
1598 ret = wl1271_ps_elp_wakeup(wl);
1599 if (ret < 0)
1600 return;
1601
1602 if (is_sta) {
1603 wl1271_configure_wowlan(wl, NULL);
1604
1605 ret = wl1271_acx_wake_up_conditions(wl, wlvif,
1606 wl->conf.conn.wake_up_event,
1607 wl->conf.conn.listen_interval);
1608
1609 if (ret < 0)
1610 wl1271_error("resume: wake up conditions failed: %d",
1611 ret);
1612
1613 } else if (is_ap) {
1614 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, false);
1615 }
1616
1617 wl1271_ps_elp_sleep(wl);
1618 }
1619
1620 static int wl1271_op_suspend(struct ieee80211_hw *hw,
1621 struct cfg80211_wowlan *wow)
1622 {
1623 struct wl1271 *wl = hw->priv;
1624 struct wl12xx_vif *wlvif;
1625 int ret;
1626
1627 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1628 WARN_ON(!wow);
1629
1630 wl1271_tx_flush(wl);
1631
1632 mutex_lock(&wl->mutex);
1633 wl->wow_enabled = true;
1634 wl12xx_for_each_wlvif(wl, wlvif) {
1635 ret = wl1271_configure_suspend(wl, wlvif, wow);
1636 if (ret < 0) {
1637 mutex_unlock(&wl->mutex);
1638 wl1271_warning("couldn't prepare device to suspend");
1639 return ret;
1640 }
1641 }
1642 mutex_unlock(&wl->mutex);
1643 /* flush any remaining work */
1644 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1645
1646 /*
1647 * disable and re-enable interrupts in order to flush
1648 * the threaded_irq
1649 */
1650 wlcore_disable_interrupts(wl);
1651
1652 /*
1653 * set suspended flag to avoid triggering a new threaded_irq
1654 * work. no need for spinlock as interrupts are disabled.
1655 */
1656 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1657
1658 wlcore_enable_interrupts(wl);
1659 flush_work(&wl->tx_work);
1660 flush_delayed_work(&wl->elp_work);
1661
1662 return 0;
1663 }
1664
1665 static int wl1271_op_resume(struct ieee80211_hw *hw)
1666 {
1667 struct wl1271 *wl = hw->priv;
1668 struct wl12xx_vif *wlvif;
1669 unsigned long flags;
1670 bool run_irq_work = false;
1671
1672 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1673 wl->wow_enabled);
1674 WARN_ON(!wl->wow_enabled);
1675
1676 /*
1677 * re-enable irq_work enqueuing, and call irq_work directly if
1678 * there is a pending work.
1679 */
1680 spin_lock_irqsave(&wl->wl_lock, flags);
1681 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1682 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1683 run_irq_work = true;
1684 spin_unlock_irqrestore(&wl->wl_lock, flags);
1685
1686 if (run_irq_work) {
1687 wl1271_debug(DEBUG_MAC80211,
1688 "run postponed irq_work directly");
1689 wl1271_irq(0, wl);
1690 wlcore_enable_interrupts(wl);
1691 }
1692
1693 mutex_lock(&wl->mutex);
1694 wl12xx_for_each_wlvif(wl, wlvif) {
1695 wl1271_configure_resume(wl, wlvif);
1696 }
1697 wl->wow_enabled = false;
1698 mutex_unlock(&wl->mutex);
1699
1700 return 0;
1701 }
1702 #endif
1703
1704 static int wl1271_op_start(struct ieee80211_hw *hw)
1705 {
1706 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1707
1708 /*
1709 * We have to delay the booting of the hardware because
1710 * we need to know the local MAC address before downloading and
1711 * initializing the firmware. The MAC address cannot be changed
1712 * after boot, and without the proper MAC address, the firmware
1713 * will not function properly.
1714 *
1715 * The MAC address is first known when the corresponding interface
1716 * is added. That is where we will initialize the hardware.
1717 */
1718
1719 return 0;
1720 }
1721
1722 static void wl1271_op_stop(struct ieee80211_hw *hw)
1723 {
1724 struct wl1271 *wl = hw->priv;
1725 int i;
1726
1727 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1728
1729 /*
1730 * Interrupts must be disabled before setting the state to OFF.
1731 * Otherwise, the interrupt handler might be called and exit without
1732 * reading the interrupt status.
1733 */
1734 wlcore_disable_interrupts(wl);
1735 mutex_lock(&wl->mutex);
1736 if (wl->state == WL1271_STATE_OFF) {
1737 mutex_unlock(&wl->mutex);
1738
1739 /*
1740 * This will not necessarily enable interrupts as interrupts
1741 * may have been disabled when op_stop was called. It will,
1742 * however, balance the above call to disable_interrupts().
1743 */
1744 wlcore_enable_interrupts(wl);
1745 return;
1746 }
1747
1748 /*
1749 * this must be before the cancel_work calls below, so that the work
1750 * functions don't perform further work.
1751 */
1752 wl->state = WL1271_STATE_OFF;
1753 mutex_unlock(&wl->mutex);
1754
1755 wl1271_flush_deferred_work(wl);
1756 cancel_delayed_work_sync(&wl->scan_complete_work);
1757 cancel_work_sync(&wl->netstack_work);
1758 cancel_work_sync(&wl->tx_work);
1759 cancel_delayed_work_sync(&wl->elp_work);
1760 cancel_delayed_work_sync(&wl->tx_watchdog_work);
1761 cancel_delayed_work_sync(&wl->connection_loss_work);
1762
1763 /* let's notify MAC80211 about the remaining pending TX frames */
1764 wl12xx_tx_reset(wl, true);
1765 mutex_lock(&wl->mutex);
1766
1767 wl1271_power_off(wl);
1768
1769 wl->band = IEEE80211_BAND_2GHZ;
1770
1771 wl->rx_counter = 0;
1772 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1773 wl->channel_type = NL80211_CHAN_NO_HT;
1774 wl->tx_blocks_available = 0;
1775 wl->tx_allocated_blocks = 0;
1776 wl->tx_results_count = 0;
1777 wl->tx_packets_count = 0;
1778 wl->time_offset = 0;
1779 wl->ap_fw_ps_map = 0;
1780 wl->ap_ps_map = 0;
1781 wl->sched_scanning = false;
1782 memset(wl->roles_map, 0, sizeof(wl->roles_map));
1783 memset(wl->links_map, 0, sizeof(wl->links_map));
1784 memset(wl->roc_map, 0, sizeof(wl->roc_map));
1785 wl->active_sta_count = 0;
1786
1787 /* The system link is always allocated */
1788 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
1789
1790 /*
1791 * this is performed after the cancel_work calls and the associated
1792 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1793 * get executed before all these vars have been reset.
1794 */
1795 wl->flags = 0;
1796
1797 wl->tx_blocks_freed = 0;
1798
1799 for (i = 0; i < NUM_TX_QUEUES; i++) {
1800 wl->tx_pkts_freed[i] = 0;
1801 wl->tx_allocated_pkts[i] = 0;
1802 }
1803
1804 wl1271_debugfs_reset(wl);
1805
1806 kfree(wl->fw_status);
1807 wl->fw_status = NULL;
1808 kfree(wl->tx_res_if);
1809 wl->tx_res_if = NULL;
1810 kfree(wl->target_mem_map);
1811 wl->target_mem_map = NULL;
1812
1813 mutex_unlock(&wl->mutex);
1814 }
1815
1816 static int wl12xx_allocate_rate_policy(struct wl1271 *wl, u8 *idx)
1817 {
1818 u8 policy = find_first_zero_bit(wl->rate_policies_map,
1819 WL12XX_MAX_RATE_POLICIES);
1820 if (policy >= WL12XX_MAX_RATE_POLICIES)
1821 return -EBUSY;
1822
1823 __set_bit(policy, wl->rate_policies_map);
1824 *idx = policy;
1825 return 0;
1826 }
1827
1828 static void wl12xx_free_rate_policy(struct wl1271 *wl, u8 *idx)
1829 {
1830 if (WARN_ON(*idx >= WL12XX_MAX_RATE_POLICIES))
1831 return;
1832
1833 __clear_bit(*idx, wl->rate_policies_map);
1834 *idx = WL12XX_MAX_RATE_POLICIES;
1835 }
1836
1837 static u8 wl12xx_get_role_type(struct wl1271 *wl, struct wl12xx_vif *wlvif)
1838 {
1839 switch (wlvif->bss_type) {
1840 case BSS_TYPE_AP_BSS:
1841 if (wlvif->p2p)
1842 return WL1271_ROLE_P2P_GO;
1843 else
1844 return WL1271_ROLE_AP;
1845
1846 case BSS_TYPE_STA_BSS:
1847 if (wlvif->p2p)
1848 return WL1271_ROLE_P2P_CL;
1849 else
1850 return WL1271_ROLE_STA;
1851
1852 case BSS_TYPE_IBSS:
1853 return WL1271_ROLE_IBSS;
1854
1855 default:
1856 wl1271_error("invalid bss_type: %d", wlvif->bss_type);
1857 }
1858 return WL12XX_INVALID_ROLE_TYPE;
1859 }
1860
1861 static int wl12xx_init_vif_data(struct wl1271 *wl, struct ieee80211_vif *vif)
1862 {
1863 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
1864 int i;
1865
1866 /* clear everything but the persistent data */
1867 memset(wlvif, 0, offsetof(struct wl12xx_vif, persistent));
1868
1869 switch (ieee80211_vif_type_p2p(vif)) {
1870 case NL80211_IFTYPE_P2P_CLIENT:
1871 wlvif->p2p = 1;
1872 /* fall-through */
1873 case NL80211_IFTYPE_STATION:
1874 wlvif->bss_type = BSS_TYPE_STA_BSS;
1875 break;
1876 case NL80211_IFTYPE_ADHOC:
1877 wlvif->bss_type = BSS_TYPE_IBSS;
1878 break;
1879 case NL80211_IFTYPE_P2P_GO:
1880 wlvif->p2p = 1;
1881 /* fall-through */
1882 case NL80211_IFTYPE_AP:
1883 wlvif->bss_type = BSS_TYPE_AP_BSS;
1884 break;
1885 default:
1886 wlvif->bss_type = MAX_BSS_TYPE;
1887 return -EOPNOTSUPP;
1888 }
1889
1890 wlvif->role_id = WL12XX_INVALID_ROLE_ID;
1891 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
1892 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
1893
1894 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
1895 wlvif->bss_type == BSS_TYPE_IBSS) {
1896 /* init sta/ibss data */
1897 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
1898 wl12xx_allocate_rate_policy(wl, &wlvif->sta.basic_rate_idx);
1899 wl12xx_allocate_rate_policy(wl, &wlvif->sta.ap_rate_idx);
1900 wl12xx_allocate_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
1901 } else {
1902 /* init ap data */
1903 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
1904 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
1905 wl12xx_allocate_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
1906 wl12xx_allocate_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
1907 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
1908 wl12xx_allocate_rate_policy(wl,
1909 &wlvif->ap.ucast_rate_idx[i]);
1910 }
1911
1912 wlvif->bitrate_masks[IEEE80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
1913 wlvif->bitrate_masks[IEEE80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
1914 wlvif->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
1915 wlvif->basic_rate = CONF_TX_RATE_MASK_BASIC;
1916 wlvif->rate_set = CONF_TX_RATE_MASK_BASIC;
1917 wlvif->beacon_int = WL1271_DEFAULT_BEACON_INT;
1918
1919 /*
1920 * mac80211 configures some values globally, while we treat them
1921 * per-interface. thus, on init, we have to copy them from wl
1922 */
1923 wlvif->band = wl->band;
1924 wlvif->channel = wl->channel;
1925 wlvif->power_level = wl->power_level;
1926 wlvif->channel_type = wl->channel_type;
1927
1928 INIT_WORK(&wlvif->rx_streaming_enable_work,
1929 wl1271_rx_streaming_enable_work);
1930 INIT_WORK(&wlvif->rx_streaming_disable_work,
1931 wl1271_rx_streaming_disable_work);
1932 INIT_LIST_HEAD(&wlvif->list);
1933
1934 setup_timer(&wlvif->rx_streaming_timer, wl1271_rx_streaming_timer,
1935 (unsigned long) wlvif);
1936 return 0;
1937 }
1938
1939 static bool wl12xx_init_fw(struct wl1271 *wl)
1940 {
1941 int retries = WL1271_BOOT_RETRIES;
1942 bool booted = false;
1943 struct wiphy *wiphy = wl->hw->wiphy;
1944 int ret;
1945
1946 while (retries) {
1947 retries--;
1948 ret = wl12xx_chip_wakeup(wl, false);
1949 if (ret < 0)
1950 goto power_off;
1951
1952 ret = wl->ops->boot(wl);
1953 if (ret < 0)
1954 goto power_off;
1955
1956 ret = wl1271_hw_init(wl);
1957 if (ret < 0)
1958 goto irq_disable;
1959
1960 booted = true;
1961 break;
1962
1963 irq_disable:
1964 mutex_unlock(&wl->mutex);
1965 /* Unlocking the mutex in the middle of handling is
1966 inherently unsafe. In this case we deem it safe to do,
1967 because we need to let any possibly pending IRQ out of
1968 the system (and while we are WL1271_STATE_OFF the IRQ
1969 work function will not do anything.) Also, any other
1970 possible concurrent operations will fail due to the
1971 current state, hence the wl1271 struct should be safe. */
1972 wlcore_disable_interrupts(wl);
1973 wl1271_flush_deferred_work(wl);
1974 cancel_work_sync(&wl->netstack_work);
1975 mutex_lock(&wl->mutex);
1976 power_off:
1977 wl1271_power_off(wl);
1978 }
1979
1980 if (!booted) {
1981 wl1271_error("firmware boot failed despite %d retries",
1982 WL1271_BOOT_RETRIES);
1983 goto out;
1984 }
1985
1986 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1987
1988 /* update hw/fw version info in wiphy struct */
1989 wiphy->hw_version = wl->chip.id;
1990 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1991 sizeof(wiphy->fw_version));
1992
1993 /*
1994 * Now we know if 11a is supported (info from the NVS), so disable
1995 * 11a channels if not supported
1996 */
1997 if (!wl->enable_11a)
1998 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1999
2000 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
2001 wl->enable_11a ? "" : "not ");
2002
2003 wl->state = WL1271_STATE_ON;
2004 out:
2005 return booted;
2006 }
2007
2008 static bool wl12xx_dev_role_started(struct wl12xx_vif *wlvif)
2009 {
2010 return wlvif->dev_hlid != WL12XX_INVALID_LINK_ID;
2011 }
2012
2013 /*
2014 * Check whether a fw switch (i.e. moving from one loaded
2015 * fw to another) is needed. This function is also responsible
2016 * for updating wl->last_vif_count, so it must be called before
2017 * loading a non-plt fw (so the correct fw (single-role/multi-role)
2018 * will be used).
2019 */
2020 static bool wl12xx_need_fw_change(struct wl1271 *wl,
2021 struct vif_counter_data vif_counter_data,
2022 bool add)
2023 {
2024 enum wl12xx_fw_type current_fw = wl->fw_type;
2025 u8 vif_count = vif_counter_data.counter;
2026
2027 if (test_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags))
2028 return false;
2029
2030 /* increase the vif count if this is a new vif */
2031 if (add && !vif_counter_data.cur_vif_running)
2032 vif_count++;
2033
2034 wl->last_vif_count = vif_count;
2035
2036 /* no need for fw change if the device is OFF */
2037 if (wl->state == WL1271_STATE_OFF)
2038 return false;
2039
2040 if (vif_count > 1 && current_fw == WL12XX_FW_TYPE_NORMAL)
2041 return true;
2042 if (vif_count <= 1 && current_fw == WL12XX_FW_TYPE_MULTI)
2043 return true;
2044
2045 return false;
2046 }
2047
2048 /*
2049 * Enter "forced psm". Make sure the sta is in psm against the ap,
2050 * to make the fw switch a bit more disconnection-persistent.
2051 */
2052 static void wl12xx_force_active_psm(struct wl1271 *wl)
2053 {
2054 struct wl12xx_vif *wlvif;
2055
2056 wl12xx_for_each_wlvif_sta(wl, wlvif) {
2057 wl1271_ps_set_mode(wl, wlvif, STATION_POWER_SAVE_MODE);
2058 }
2059 }
2060
2061 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
2062 struct ieee80211_vif *vif)
2063 {
2064 struct wl1271 *wl = hw->priv;
2065 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2066 struct vif_counter_data vif_count;
2067 int ret = 0;
2068 u8 role_type;
2069 bool booted = false;
2070
2071 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
2072 IEEE80211_VIF_SUPPORTS_CQM_RSSI;
2073
2074 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
2075 ieee80211_vif_type_p2p(vif), vif->addr);
2076
2077 wl12xx_get_vif_count(hw, vif, &vif_count);
2078
2079 mutex_lock(&wl->mutex);
2080 ret = wl1271_ps_elp_wakeup(wl);
2081 if (ret < 0)
2082 goto out_unlock;
2083
2084 /*
2085 * in some very corner case HW recovery scenarios its possible to
2086 * get here before __wl1271_op_remove_interface is complete, so
2087 * opt out if that is the case.
2088 */
2089 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) ||
2090 test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) {
2091 ret = -EBUSY;
2092 goto out;
2093 }
2094
2095
2096 ret = wl12xx_init_vif_data(wl, vif);
2097 if (ret < 0)
2098 goto out;
2099
2100 wlvif->wl = wl;
2101 role_type = wl12xx_get_role_type(wl, wlvif);
2102 if (role_type == WL12XX_INVALID_ROLE_TYPE) {
2103 ret = -EINVAL;
2104 goto out;
2105 }
2106
2107 if (wl12xx_need_fw_change(wl, vif_count, true)) {
2108 wl12xx_force_active_psm(wl);
2109 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2110 mutex_unlock(&wl->mutex);
2111 wl1271_recovery_work(&wl->recovery_work);
2112 return 0;
2113 }
2114
2115 /*
2116 * TODO: after the nvs issue will be solved, move this block
2117 * to start(), and make sure here the driver is ON.
2118 */
2119 if (wl->state == WL1271_STATE_OFF) {
2120 /*
2121 * we still need this in order to configure the fw
2122 * while uploading the nvs
2123 */
2124 memcpy(wl->addresses[0].addr, vif->addr, ETH_ALEN);
2125
2126 booted = wl12xx_init_fw(wl);
2127 if (!booted) {
2128 ret = -EINVAL;
2129 goto out;
2130 }
2131 }
2132
2133 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2134 wlvif->bss_type == BSS_TYPE_IBSS) {
2135 /*
2136 * The device role is a special role used for
2137 * rx and tx frames prior to association (as
2138 * the STA role can get packets only from
2139 * its associated bssid)
2140 */
2141 ret = wl12xx_cmd_role_enable(wl, vif->addr,
2142 WL1271_ROLE_DEVICE,
2143 &wlvif->dev_role_id);
2144 if (ret < 0)
2145 goto out;
2146 }
2147
2148 ret = wl12xx_cmd_role_enable(wl, vif->addr,
2149 role_type, &wlvif->role_id);
2150 if (ret < 0)
2151 goto out;
2152
2153 ret = wl1271_init_vif_specific(wl, vif);
2154 if (ret < 0)
2155 goto out;
2156
2157 list_add(&wlvif->list, &wl->wlvif_list);
2158 set_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags);
2159
2160 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2161 wl->ap_count++;
2162 else
2163 wl->sta_count++;
2164 out:
2165 wl1271_ps_elp_sleep(wl);
2166 out_unlock:
2167 mutex_unlock(&wl->mutex);
2168
2169 return ret;
2170 }
2171
2172 static void __wl1271_op_remove_interface(struct wl1271 *wl,
2173 struct ieee80211_vif *vif,
2174 bool reset_tx_queues)
2175 {
2176 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2177 int i, ret;
2178
2179 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
2180
2181 if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2182 return;
2183
2184 /* because of hardware recovery, we may get here twice */
2185 if (wl->state != WL1271_STATE_ON)
2186 return;
2187
2188 wl1271_info("down");
2189
2190 if (wl->scan.state != WL1271_SCAN_STATE_IDLE &&
2191 wl->scan_vif == vif) {
2192 /*
2193 * Rearm the tx watchdog just before idling scan. This
2194 * prevents just-finished scans from triggering the watchdog
2195 */
2196 wl12xx_rearm_tx_watchdog_locked(wl);
2197
2198 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2199 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2200 wl->scan_vif = NULL;
2201 wl->scan.req = NULL;
2202 ieee80211_scan_completed(wl->hw, true);
2203 }
2204
2205 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2206 /* disable active roles */
2207 ret = wl1271_ps_elp_wakeup(wl);
2208 if (ret < 0)
2209 goto deinit;
2210
2211 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2212 wlvif->bss_type == BSS_TYPE_IBSS) {
2213 if (wl12xx_dev_role_started(wlvif))
2214 wl12xx_stop_dev(wl, wlvif);
2215
2216 ret = wl12xx_cmd_role_disable(wl, &wlvif->dev_role_id);
2217 if (ret < 0)
2218 goto deinit;
2219 }
2220
2221 ret = wl12xx_cmd_role_disable(wl, &wlvif->role_id);
2222 if (ret < 0)
2223 goto deinit;
2224
2225 wl1271_ps_elp_sleep(wl);
2226 }
2227 deinit:
2228 /* clear all hlids (except system_hlid) */
2229 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
2230
2231 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2232 wlvif->bss_type == BSS_TYPE_IBSS) {
2233 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
2234 wl12xx_free_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2235 wl12xx_free_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2236 wl12xx_free_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
2237 } else {
2238 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2239 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
2240 wl12xx_free_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2241 wl12xx_free_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2242 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2243 wl12xx_free_rate_policy(wl,
2244 &wlvif->ap.ucast_rate_idx[i]);
2245 wl1271_free_ap_keys(wl, wlvif);
2246 }
2247
2248 dev_kfree_skb(wlvif->probereq);
2249 wlvif->probereq = NULL;
2250 wl12xx_tx_reset_wlvif(wl, wlvif);
2251 if (wl->last_wlvif == wlvif)
2252 wl->last_wlvif = NULL;
2253 list_del(&wlvif->list);
2254 memset(wlvif->ap.sta_hlid_map, 0, sizeof(wlvif->ap.sta_hlid_map));
2255 wlvif->role_id = WL12XX_INVALID_ROLE_ID;
2256 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
2257
2258 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2259 wl->ap_count--;
2260 else
2261 wl->sta_count--;
2262
2263 mutex_unlock(&wl->mutex);
2264
2265 del_timer_sync(&wlvif->rx_streaming_timer);
2266 cancel_work_sync(&wlvif->rx_streaming_enable_work);
2267 cancel_work_sync(&wlvif->rx_streaming_disable_work);
2268
2269 mutex_lock(&wl->mutex);
2270 }
2271
2272 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2273 struct ieee80211_vif *vif)
2274 {
2275 struct wl1271 *wl = hw->priv;
2276 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2277 struct wl12xx_vif *iter;
2278 struct vif_counter_data vif_count;
2279 bool cancel_recovery = true;
2280
2281 wl12xx_get_vif_count(hw, vif, &vif_count);
2282 mutex_lock(&wl->mutex);
2283
2284 if (wl->state == WL1271_STATE_OFF ||
2285 !test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2286 goto out;
2287
2288 /*
2289 * wl->vif can be null here if someone shuts down the interface
2290 * just when hardware recovery has been started.
2291 */
2292 wl12xx_for_each_wlvif(wl, iter) {
2293 if (iter != wlvif)
2294 continue;
2295
2296 __wl1271_op_remove_interface(wl, vif, true);
2297 break;
2298 }
2299 WARN_ON(iter != wlvif);
2300 if (wl12xx_need_fw_change(wl, vif_count, false)) {
2301 wl12xx_force_active_psm(wl);
2302 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2303 wl12xx_queue_recovery_work(wl);
2304 cancel_recovery = false;
2305 }
2306 out:
2307 mutex_unlock(&wl->mutex);
2308 if (cancel_recovery)
2309 cancel_work_sync(&wl->recovery_work);
2310 }
2311
2312 static int wl12xx_op_change_interface(struct ieee80211_hw *hw,
2313 struct ieee80211_vif *vif,
2314 enum nl80211_iftype new_type, bool p2p)
2315 {
2316 struct wl1271 *wl = hw->priv;
2317 int ret;
2318
2319 set_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
2320 wl1271_op_remove_interface(hw, vif);
2321
2322 vif->type = new_type;
2323 vif->p2p = p2p;
2324 ret = wl1271_op_add_interface(hw, vif);
2325
2326 clear_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
2327 return ret;
2328 }
2329
2330 static int wl1271_join(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2331 bool set_assoc)
2332 {
2333 int ret;
2334 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
2335
2336 /*
2337 * One of the side effects of the JOIN command is that is clears
2338 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2339 * to a WPA/WPA2 access point will therefore kill the data-path.
2340 * Currently the only valid scenario for JOIN during association
2341 * is on roaming, in which case we will also be given new keys.
2342 * Keep the below message for now, unless it starts bothering
2343 * users who really like to roam a lot :)
2344 */
2345 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2346 wl1271_info("JOIN while associated.");
2347
2348 /* clear encryption type */
2349 wlvif->encryption_type = KEY_NONE;
2350
2351 if (set_assoc)
2352 set_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags);
2353
2354 if (is_ibss)
2355 ret = wl12xx_cmd_role_start_ibss(wl, wlvif);
2356 else
2357 ret = wl12xx_cmd_role_start_sta(wl, wlvif);
2358 if (ret < 0)
2359 goto out;
2360
2361 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2362 goto out;
2363
2364 /*
2365 * The join command disable the keep-alive mode, shut down its process,
2366 * and also clear the template config, so we need to reset it all after
2367 * the join. The acx_aid starts the keep-alive process, and the order
2368 * of the commands below is relevant.
2369 */
2370 ret = wl1271_acx_keep_alive_mode(wl, wlvif, true);
2371 if (ret < 0)
2372 goto out;
2373
2374 ret = wl1271_acx_aid(wl, wlvif, wlvif->aid);
2375 if (ret < 0)
2376 goto out;
2377
2378 ret = wl12xx_cmd_build_klv_null_data(wl, wlvif);
2379 if (ret < 0)
2380 goto out;
2381
2382 ret = wl1271_acx_keep_alive_config(wl, wlvif,
2383 CMD_TEMPL_KLV_IDX_NULL_DATA,
2384 ACX_KEEP_ALIVE_TPL_VALID);
2385 if (ret < 0)
2386 goto out;
2387
2388 out:
2389 return ret;
2390 }
2391
2392 static int wl1271_unjoin(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2393 {
2394 int ret;
2395
2396 if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags)) {
2397 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2398
2399 wl12xx_cmd_stop_channel_switch(wl);
2400 ieee80211_chswitch_done(vif, false);
2401 }
2402
2403 /* to stop listening to a channel, we disconnect */
2404 ret = wl12xx_cmd_role_stop_sta(wl, wlvif);
2405 if (ret < 0)
2406 goto out;
2407
2408 /* reset TX security counters on a clean disconnect */
2409 wlvif->tx_security_last_seq_lsb = 0;
2410 wlvif->tx_security_seq = 0;
2411
2412 out:
2413 return ret;
2414 }
2415
2416 static void wl1271_set_band_rate(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2417 {
2418 wlvif->basic_rate_set = wlvif->bitrate_masks[wlvif->band];
2419 wlvif->rate_set = wlvif->basic_rate_set;
2420 }
2421
2422 static int wl1271_sta_handle_idle(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2423 bool idle)
2424 {
2425 int ret;
2426 bool cur_idle = !test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
2427
2428 if (idle == cur_idle)
2429 return 0;
2430
2431 if (idle) {
2432 /* no need to croc if we weren't busy (e.g. during boot) */
2433 if (wl12xx_dev_role_started(wlvif)) {
2434 ret = wl12xx_stop_dev(wl, wlvif);
2435 if (ret < 0)
2436 goto out;
2437 }
2438 wlvif->rate_set =
2439 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
2440 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
2441 if (ret < 0)
2442 goto out;
2443 ret = wl1271_acx_keep_alive_config(
2444 wl, wlvif, CMD_TEMPL_KLV_IDX_NULL_DATA,
2445 ACX_KEEP_ALIVE_TPL_INVALID);
2446 if (ret < 0)
2447 goto out;
2448 clear_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
2449 } else {
2450 /* The current firmware only supports sched_scan in idle */
2451 if (wl->sched_scanning) {
2452 wl1271_scan_sched_scan_stop(wl);
2453 ieee80211_sched_scan_stopped(wl->hw);
2454 }
2455
2456 ret = wl12xx_start_dev(wl, wlvif);
2457 if (ret < 0)
2458 goto out;
2459 set_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
2460 }
2461
2462 out:
2463 return ret;
2464 }
2465
2466 static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2467 struct ieee80211_conf *conf, u32 changed)
2468 {
2469 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
2470 int channel, ret;
2471
2472 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2473
2474 /* if the channel changes while joined, join again */
2475 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2476 ((wlvif->band != conf->channel->band) ||
2477 (wlvif->channel != channel) ||
2478 (wlvif->channel_type != conf->channel_type))) {
2479 /* send all pending packets */
2480 wl1271_tx_work_locked(wl);
2481 wlvif->band = conf->channel->band;
2482 wlvif->channel = channel;
2483 wlvif->channel_type = conf->channel_type;
2484
2485 if (is_ap) {
2486 ret = wl1271_init_ap_rates(wl, wlvif);
2487 if (ret < 0)
2488 wl1271_error("AP rate policy change failed %d",
2489 ret);
2490 } else {
2491 /*
2492 * FIXME: the mac80211 should really provide a fixed
2493 * rate to use here. for now, just use the smallest
2494 * possible rate for the band as a fixed rate for
2495 * association frames and other control messages.
2496 */
2497 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2498 wl1271_set_band_rate(wl, wlvif);
2499
2500 wlvif->basic_rate =
2501 wl1271_tx_min_rate_get(wl,
2502 wlvif->basic_rate_set);
2503 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
2504 if (ret < 0)
2505 wl1271_warning("rate policy for channel "
2506 "failed %d", ret);
2507
2508 /*
2509 * change the ROC channel. do it only if we are
2510 * not idle. otherwise, CROC will be called
2511 * anyway.
2512 */
2513 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED,
2514 &wlvif->flags) &&
2515 wl12xx_dev_role_started(wlvif) &&
2516 !(conf->flags & IEEE80211_CONF_IDLE)) {
2517 ret = wl12xx_stop_dev(wl, wlvif);
2518 if (ret < 0)
2519 return ret;
2520
2521 ret = wl12xx_start_dev(wl, wlvif);
2522 if (ret < 0)
2523 return ret;
2524 }
2525 }
2526 }
2527
2528 if ((changed & IEEE80211_CONF_CHANGE_PS) && !is_ap) {
2529
2530 if ((conf->flags & IEEE80211_CONF_PS) &&
2531 test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
2532 !test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
2533
2534 int ps_mode;
2535 char *ps_mode_str;
2536
2537 if (wl->conf.conn.forced_ps) {
2538 ps_mode = STATION_POWER_SAVE_MODE;
2539 ps_mode_str = "forced";
2540 } else {
2541 ps_mode = STATION_AUTO_PS_MODE;
2542 ps_mode_str = "auto";
2543 }
2544
2545 wl1271_debug(DEBUG_PSM, "%s ps enabled", ps_mode_str);
2546
2547 ret = wl1271_ps_set_mode(wl, wlvif, ps_mode);
2548
2549 if (ret < 0)
2550 wl1271_warning("enter %s ps failed %d",
2551 ps_mode_str, ret);
2552
2553 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
2554 test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
2555
2556 wl1271_debug(DEBUG_PSM, "auto ps disabled");
2557
2558 ret = wl1271_ps_set_mode(wl, wlvif,
2559 STATION_ACTIVE_MODE);
2560 if (ret < 0)
2561 wl1271_warning("exit auto ps failed %d", ret);
2562 }
2563 }
2564
2565 if (conf->power_level != wlvif->power_level) {
2566 ret = wl1271_acx_tx_power(wl, wlvif, conf->power_level);
2567 if (ret < 0)
2568 return ret;
2569
2570 wlvif->power_level = conf->power_level;
2571 }
2572
2573 return 0;
2574 }
2575
2576 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2577 {
2578 struct wl1271 *wl = hw->priv;
2579 struct wl12xx_vif *wlvif;
2580 struct ieee80211_conf *conf = &hw->conf;
2581 int channel, ret = 0;
2582
2583 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2584
2585 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2586 " changed 0x%x",
2587 channel,
2588 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
2589 conf->power_level,
2590 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2591 changed);
2592
2593 /*
2594 * mac80211 will go to idle nearly immediately after transmitting some
2595 * frames, such as the deauth. To make sure those frames reach the air,
2596 * wait here until the TX queue is fully flushed.
2597 */
2598 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2599 (conf->flags & IEEE80211_CONF_IDLE))
2600 wl1271_tx_flush(wl);
2601
2602 mutex_lock(&wl->mutex);
2603
2604 /* we support configuring the channel and band even while off */
2605 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2606 wl->band = conf->channel->band;
2607 wl->channel = channel;
2608 wl->channel_type = conf->channel_type;
2609 }
2610
2611 if (changed & IEEE80211_CONF_CHANGE_POWER)
2612 wl->power_level = conf->power_level;
2613
2614 if (unlikely(wl->state == WL1271_STATE_OFF))
2615 goto out;
2616
2617 ret = wl1271_ps_elp_wakeup(wl);
2618 if (ret < 0)
2619 goto out;
2620
2621 /* configure each interface */
2622 wl12xx_for_each_wlvif(wl, wlvif) {
2623 ret = wl12xx_config_vif(wl, wlvif, conf, changed);
2624 if (ret < 0)
2625 goto out_sleep;
2626 }
2627
2628 out_sleep:
2629 wl1271_ps_elp_sleep(wl);
2630
2631 out:
2632 mutex_unlock(&wl->mutex);
2633
2634 return ret;
2635 }
2636
2637 struct wl1271_filter_params {
2638 bool enabled;
2639 int mc_list_length;
2640 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2641 };
2642
2643 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2644 struct netdev_hw_addr_list *mc_list)
2645 {
2646 struct wl1271_filter_params *fp;
2647 struct netdev_hw_addr *ha;
2648 struct wl1271 *wl = hw->priv;
2649
2650 if (unlikely(wl->state == WL1271_STATE_OFF))
2651 return 0;
2652
2653 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2654 if (!fp) {
2655 wl1271_error("Out of memory setting filters.");
2656 return 0;
2657 }
2658
2659 /* update multicast filtering parameters */
2660 fp->mc_list_length = 0;
2661 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2662 fp->enabled = false;
2663 } else {
2664 fp->enabled = true;
2665 netdev_hw_addr_list_for_each(ha, mc_list) {
2666 memcpy(fp->mc_list[fp->mc_list_length],
2667 ha->addr, ETH_ALEN);
2668 fp->mc_list_length++;
2669 }
2670 }
2671
2672 return (u64)(unsigned long)fp;
2673 }
2674
2675 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2676 FIF_ALLMULTI | \
2677 FIF_FCSFAIL | \
2678 FIF_BCN_PRBRESP_PROMISC | \
2679 FIF_CONTROL | \
2680 FIF_OTHER_BSS)
2681
2682 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2683 unsigned int changed,
2684 unsigned int *total, u64 multicast)
2685 {
2686 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2687 struct wl1271 *wl = hw->priv;
2688 struct wl12xx_vif *wlvif;
2689
2690 int ret;
2691
2692 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2693 " total %x", changed, *total);
2694
2695 mutex_lock(&wl->mutex);
2696
2697 *total &= WL1271_SUPPORTED_FILTERS;
2698 changed &= WL1271_SUPPORTED_FILTERS;
2699
2700 if (unlikely(wl->state == WL1271_STATE_OFF))
2701 goto out;
2702
2703 ret = wl1271_ps_elp_wakeup(wl);
2704 if (ret < 0)
2705 goto out;
2706
2707 wl12xx_for_each_wlvif(wl, wlvif) {
2708 if (wlvif->bss_type != BSS_TYPE_AP_BSS) {
2709 if (*total & FIF_ALLMULTI)
2710 ret = wl1271_acx_group_address_tbl(wl, wlvif,
2711 false,
2712 NULL, 0);
2713 else if (fp)
2714 ret = wl1271_acx_group_address_tbl(wl, wlvif,
2715 fp->enabled,
2716 fp->mc_list,
2717 fp->mc_list_length);
2718 if (ret < 0)
2719 goto out_sleep;
2720 }
2721 }
2722
2723 /*
2724 * the fw doesn't provide an api to configure the filters. instead,
2725 * the filters configuration is based on the active roles / ROC
2726 * state.
2727 */
2728
2729 out_sleep:
2730 wl1271_ps_elp_sleep(wl);
2731
2732 out:
2733 mutex_unlock(&wl->mutex);
2734 kfree(fp);
2735 }
2736
2737 static int wl1271_record_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2738 u8 id, u8 key_type, u8 key_size,
2739 const u8 *key, u8 hlid, u32 tx_seq_32,
2740 u16 tx_seq_16)
2741 {
2742 struct wl1271_ap_key *ap_key;
2743 int i;
2744
2745 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2746
2747 if (key_size > MAX_KEY_SIZE)
2748 return -EINVAL;
2749
2750 /*
2751 * Find next free entry in ap_keys. Also check we are not replacing
2752 * an existing key.
2753 */
2754 for (i = 0; i < MAX_NUM_KEYS; i++) {
2755 if (wlvif->ap.recorded_keys[i] == NULL)
2756 break;
2757
2758 if (wlvif->ap.recorded_keys[i]->id == id) {
2759 wl1271_warning("trying to record key replacement");
2760 return -EINVAL;
2761 }
2762 }
2763
2764 if (i == MAX_NUM_KEYS)
2765 return -EBUSY;
2766
2767 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2768 if (!ap_key)
2769 return -ENOMEM;
2770
2771 ap_key->id = id;
2772 ap_key->key_type = key_type;
2773 ap_key->key_size = key_size;
2774 memcpy(ap_key->key, key, key_size);
2775 ap_key->hlid = hlid;
2776 ap_key->tx_seq_32 = tx_seq_32;
2777 ap_key->tx_seq_16 = tx_seq_16;
2778
2779 wlvif->ap.recorded_keys[i] = ap_key;
2780 return 0;
2781 }
2782
2783 static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2784 {
2785 int i;
2786
2787 for (i = 0; i < MAX_NUM_KEYS; i++) {
2788 kfree(wlvif->ap.recorded_keys[i]);
2789 wlvif->ap.recorded_keys[i] = NULL;
2790 }
2791 }
2792
2793 static int wl1271_ap_init_hwenc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2794 {
2795 int i, ret = 0;
2796 struct wl1271_ap_key *key;
2797 bool wep_key_added = false;
2798
2799 for (i = 0; i < MAX_NUM_KEYS; i++) {
2800 u8 hlid;
2801 if (wlvif->ap.recorded_keys[i] == NULL)
2802 break;
2803
2804 key = wlvif->ap.recorded_keys[i];
2805 hlid = key->hlid;
2806 if (hlid == WL12XX_INVALID_LINK_ID)
2807 hlid = wlvif->ap.bcast_hlid;
2808
2809 ret = wl1271_cmd_set_ap_key(wl, wlvif, KEY_ADD_OR_REPLACE,
2810 key->id, key->key_type,
2811 key->key_size, key->key,
2812 hlid, key->tx_seq_32,
2813 key->tx_seq_16);
2814 if (ret < 0)
2815 goto out;
2816
2817 if (key->key_type == KEY_WEP)
2818 wep_key_added = true;
2819 }
2820
2821 if (wep_key_added) {
2822 ret = wl12xx_cmd_set_default_wep_key(wl, wlvif->default_key,
2823 wlvif->ap.bcast_hlid);
2824 if (ret < 0)
2825 goto out;
2826 }
2827
2828 out:
2829 wl1271_free_ap_keys(wl, wlvif);
2830 return ret;
2831 }
2832
2833 static int wl1271_set_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2834 u16 action, u8 id, u8 key_type,
2835 u8 key_size, const u8 *key, u32 tx_seq_32,
2836 u16 tx_seq_16, struct ieee80211_sta *sta)
2837 {
2838 int ret;
2839 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
2840
2841 /*
2842 * A role set to GEM cipher requires different Tx settings (namely
2843 * spare blocks). Note when we are in this mode so the HW can adjust.
2844 */
2845 if (key_type == KEY_GEM) {
2846 if (action == KEY_ADD_OR_REPLACE)
2847 wlvif->is_gem = true;
2848 else if (action == KEY_REMOVE)
2849 wlvif->is_gem = false;
2850 }
2851
2852 if (is_ap) {
2853 struct wl1271_station *wl_sta;
2854 u8 hlid;
2855
2856 if (sta) {
2857 wl_sta = (struct wl1271_station *)sta->drv_priv;
2858 hlid = wl_sta->hlid;
2859 } else {
2860 hlid = wlvif->ap.bcast_hlid;
2861 }
2862
2863 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
2864 /*
2865 * We do not support removing keys after AP shutdown.
2866 * Pretend we do to make mac80211 happy.
2867 */
2868 if (action != KEY_ADD_OR_REPLACE)
2869 return 0;
2870
2871 ret = wl1271_record_ap_key(wl, wlvif, id,
2872 key_type, key_size,
2873 key, hlid, tx_seq_32,
2874 tx_seq_16);
2875 } else {
2876 ret = wl1271_cmd_set_ap_key(wl, wlvif, action,
2877 id, key_type, key_size,
2878 key, hlid, tx_seq_32,
2879 tx_seq_16);
2880 }
2881
2882 if (ret < 0)
2883 return ret;
2884 } else {
2885 const u8 *addr;
2886 static const u8 bcast_addr[ETH_ALEN] = {
2887 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2888 };
2889
2890 addr = sta ? sta->addr : bcast_addr;
2891
2892 if (is_zero_ether_addr(addr)) {
2893 /* We dont support TX only encryption */
2894 return -EOPNOTSUPP;
2895 }
2896
2897 /* The wl1271 does not allow to remove unicast keys - they
2898 will be cleared automatically on next CMD_JOIN. Ignore the
2899 request silently, as we dont want the mac80211 to emit
2900 an error message. */
2901 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2902 return 0;
2903
2904 /* don't remove key if hlid was already deleted */
2905 if (action == KEY_REMOVE &&
2906 wlvif->sta.hlid == WL12XX_INVALID_LINK_ID)
2907 return 0;
2908
2909 ret = wl1271_cmd_set_sta_key(wl, wlvif, action,
2910 id, key_type, key_size,
2911 key, addr, tx_seq_32,
2912 tx_seq_16);
2913 if (ret < 0)
2914 return ret;
2915
2916 /* the default WEP key needs to be configured at least once */
2917 if (key_type == KEY_WEP) {
2918 ret = wl12xx_cmd_set_default_wep_key(wl,
2919 wlvif->default_key,
2920 wlvif->sta.hlid);
2921 if (ret < 0)
2922 return ret;
2923 }
2924 }
2925
2926 return 0;
2927 }
2928
2929 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2930 struct ieee80211_vif *vif,
2931 struct ieee80211_sta *sta,
2932 struct ieee80211_key_conf *key_conf)
2933 {
2934 struct wl1271 *wl = hw->priv;
2935 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2936 int ret;
2937 u32 tx_seq_32 = 0;
2938 u16 tx_seq_16 = 0;
2939 u8 key_type;
2940
2941 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2942
2943 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2944 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2945 key_conf->cipher, key_conf->keyidx,
2946 key_conf->keylen, key_conf->flags);
2947 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2948
2949 mutex_lock(&wl->mutex);
2950
2951 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2952 ret = -EAGAIN;
2953 goto out_unlock;
2954 }
2955
2956 ret = wl1271_ps_elp_wakeup(wl);
2957 if (ret < 0)
2958 goto out_unlock;
2959
2960 switch (key_conf->cipher) {
2961 case WLAN_CIPHER_SUITE_WEP40:
2962 case WLAN_CIPHER_SUITE_WEP104:
2963 key_type = KEY_WEP;
2964
2965 key_conf->hw_key_idx = key_conf->keyidx;
2966 break;
2967 case WLAN_CIPHER_SUITE_TKIP:
2968 key_type = KEY_TKIP;
2969
2970 key_conf->hw_key_idx = key_conf->keyidx;
2971 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
2972 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
2973 break;
2974 case WLAN_CIPHER_SUITE_CCMP:
2975 key_type = KEY_AES;
2976
2977 key_conf->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
2978 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
2979 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
2980 break;
2981 case WL1271_CIPHER_SUITE_GEM:
2982 key_type = KEY_GEM;
2983 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
2984 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
2985 break;
2986 default:
2987 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2988
2989 ret = -EOPNOTSUPP;
2990 goto out_sleep;
2991 }
2992
2993 switch (cmd) {
2994 case SET_KEY:
2995 ret = wl1271_set_key(wl, wlvif, KEY_ADD_OR_REPLACE,
2996 key_conf->keyidx, key_type,
2997 key_conf->keylen, key_conf->key,
2998 tx_seq_32, tx_seq_16, sta);
2999 if (ret < 0) {
3000 wl1271_error("Could not add or replace key");
3001 goto out_sleep;
3002 }
3003
3004 /*
3005 * reconfiguring arp response if the unicast (or common)
3006 * encryption key type was changed
3007 */
3008 if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
3009 (sta || key_type == KEY_WEP) &&
3010 wlvif->encryption_type != key_type) {
3011 wlvif->encryption_type = key_type;
3012 ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
3013 if (ret < 0) {
3014 wl1271_warning("build arp rsp failed: %d", ret);
3015 goto out_sleep;
3016 }
3017 }
3018 break;
3019
3020 case DISABLE_KEY:
3021 ret = wl1271_set_key(wl, wlvif, KEY_REMOVE,
3022 key_conf->keyidx, key_type,
3023 key_conf->keylen, key_conf->key,
3024 0, 0, sta);
3025 if (ret < 0) {
3026 wl1271_error("Could not remove key");
3027 goto out_sleep;
3028 }
3029 break;
3030
3031 default:
3032 wl1271_error("Unsupported key cmd 0x%x", cmd);
3033 ret = -EOPNOTSUPP;
3034 break;
3035 }
3036
3037 out_sleep:
3038 wl1271_ps_elp_sleep(wl);
3039
3040 out_unlock:
3041 mutex_unlock(&wl->mutex);
3042
3043 return ret;
3044 }
3045
3046 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
3047 struct ieee80211_vif *vif,
3048 struct cfg80211_scan_request *req)
3049 {
3050 struct wl1271 *wl = hw->priv;
3051 int ret;
3052 u8 *ssid = NULL;
3053 size_t len = 0;
3054
3055 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
3056
3057 if (req->n_ssids) {
3058 ssid = req->ssids[0].ssid;
3059 len = req->ssids[0].ssid_len;
3060 }
3061
3062 mutex_lock(&wl->mutex);
3063
3064 if (wl->state == WL1271_STATE_OFF) {
3065 /*
3066 * We cannot return -EBUSY here because cfg80211 will expect
3067 * a call to ieee80211_scan_completed if we do - in this case
3068 * there won't be any call.
3069 */
3070 ret = -EAGAIN;
3071 goto out;
3072 }
3073
3074 ret = wl1271_ps_elp_wakeup(wl);
3075 if (ret < 0)
3076 goto out;
3077
3078 /* fail if there is any role in ROC */
3079 if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
3080 /* don't allow scanning right now */
3081 ret = -EBUSY;
3082 goto out_sleep;
3083 }
3084
3085 ret = wl1271_scan(hw->priv, vif, ssid, len, req);
3086 out_sleep:
3087 wl1271_ps_elp_sleep(wl);
3088 out:
3089 mutex_unlock(&wl->mutex);
3090
3091 return ret;
3092 }
3093
3094 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
3095 struct ieee80211_vif *vif)
3096 {
3097 struct wl1271 *wl = hw->priv;
3098 int ret;
3099
3100 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
3101
3102 mutex_lock(&wl->mutex);
3103
3104 if (wl->state == WL1271_STATE_OFF)
3105 goto out;
3106
3107 if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
3108 goto out;
3109
3110 ret = wl1271_ps_elp_wakeup(wl);
3111 if (ret < 0)
3112 goto out;
3113
3114 if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
3115 ret = wl1271_scan_stop(wl);
3116 if (ret < 0)
3117 goto out_sleep;
3118 }
3119
3120 /*
3121 * Rearm the tx watchdog just before idling scan. This
3122 * prevents just-finished scans from triggering the watchdog
3123 */
3124 wl12xx_rearm_tx_watchdog_locked(wl);
3125
3126 wl->scan.state = WL1271_SCAN_STATE_IDLE;
3127 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
3128 wl->scan_vif = NULL;
3129 wl->scan.req = NULL;
3130 ieee80211_scan_completed(wl->hw, true);
3131
3132 out_sleep:
3133 wl1271_ps_elp_sleep(wl);
3134 out:
3135 mutex_unlock(&wl->mutex);
3136
3137 cancel_delayed_work_sync(&wl->scan_complete_work);
3138 }
3139
3140 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
3141 struct ieee80211_vif *vif,
3142 struct cfg80211_sched_scan_request *req,
3143 struct ieee80211_sched_scan_ies *ies)
3144 {
3145 struct wl1271 *wl = hw->priv;
3146 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3147 int ret;
3148
3149 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
3150
3151 mutex_lock(&wl->mutex);
3152
3153 if (wl->state == WL1271_STATE_OFF) {
3154 ret = -EAGAIN;
3155 goto out;
3156 }
3157
3158 ret = wl1271_ps_elp_wakeup(wl);
3159 if (ret < 0)
3160 goto out;
3161
3162 ret = wl1271_scan_sched_scan_config(wl, wlvif, req, ies);
3163 if (ret < 0)
3164 goto out_sleep;
3165
3166 ret = wl1271_scan_sched_scan_start(wl, wlvif);
3167 if (ret < 0)
3168 goto out_sleep;
3169
3170 wl->sched_scanning = true;
3171
3172 out_sleep:
3173 wl1271_ps_elp_sleep(wl);
3174 out:
3175 mutex_unlock(&wl->mutex);
3176 return ret;
3177 }
3178
3179 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
3180 struct ieee80211_vif *vif)
3181 {
3182 struct wl1271 *wl = hw->priv;
3183 int ret;
3184
3185 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
3186
3187 mutex_lock(&wl->mutex);
3188
3189 if (wl->state == WL1271_STATE_OFF)
3190 goto out;
3191
3192 ret = wl1271_ps_elp_wakeup(wl);
3193 if (ret < 0)
3194 goto out;
3195
3196 wl1271_scan_sched_scan_stop(wl);
3197
3198 wl1271_ps_elp_sleep(wl);
3199 out:
3200 mutex_unlock(&wl->mutex);
3201 }
3202
3203 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3204 {
3205 struct wl1271 *wl = hw->priv;
3206 int ret = 0;
3207
3208 mutex_lock(&wl->mutex);
3209
3210 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3211 ret = -EAGAIN;
3212 goto out;
3213 }
3214
3215 ret = wl1271_ps_elp_wakeup(wl);
3216 if (ret < 0)
3217 goto out;
3218
3219 ret = wl1271_acx_frag_threshold(wl, value);
3220 if (ret < 0)
3221 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
3222
3223 wl1271_ps_elp_sleep(wl);
3224
3225 out:
3226 mutex_unlock(&wl->mutex);
3227
3228 return ret;
3229 }
3230
3231 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3232 {
3233 struct wl1271 *wl = hw->priv;
3234 struct wl12xx_vif *wlvif;
3235 int ret = 0;
3236
3237 mutex_lock(&wl->mutex);
3238
3239 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3240 ret = -EAGAIN;
3241 goto out;
3242 }
3243
3244 ret = wl1271_ps_elp_wakeup(wl);
3245 if (ret < 0)
3246 goto out;
3247
3248 wl12xx_for_each_wlvif(wl, wlvif) {
3249 ret = wl1271_acx_rts_threshold(wl, wlvif, value);
3250 if (ret < 0)
3251 wl1271_warning("set rts threshold failed: %d", ret);
3252 }
3253 wl1271_ps_elp_sleep(wl);
3254
3255 out:
3256 mutex_unlock(&wl->mutex);
3257
3258 return ret;
3259 }
3260
3261 static int wl1271_ssid_set(struct ieee80211_vif *vif, struct sk_buff *skb,
3262 int offset)
3263 {
3264 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3265 u8 ssid_len;
3266 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
3267 skb->len - offset);
3268
3269 if (!ptr) {
3270 wl1271_error("No SSID in IEs!");
3271 return -ENOENT;
3272 }
3273
3274 ssid_len = ptr[1];
3275 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
3276 wl1271_error("SSID is too long!");
3277 return -EINVAL;
3278 }
3279
3280 wlvif->ssid_len = ssid_len;
3281 memcpy(wlvif->ssid, ptr+2, ssid_len);
3282 return 0;
3283 }
3284
3285 static void wl12xx_remove_ie(struct sk_buff *skb, u8 eid, int ieoffset)
3286 {
3287 int len;
3288 const u8 *next, *end = skb->data + skb->len;
3289 u8 *ie = (u8 *)cfg80211_find_ie(eid, skb->data + ieoffset,
3290 skb->len - ieoffset);
3291 if (!ie)
3292 return;
3293 len = ie[1] + 2;
3294 next = ie + len;
3295 memmove(ie, next, end - next);
3296 skb_trim(skb, skb->len - len);
3297 }
3298
3299 static void wl12xx_remove_vendor_ie(struct sk_buff *skb,
3300 unsigned int oui, u8 oui_type,
3301 int ieoffset)
3302 {
3303 int len;
3304 const u8 *next, *end = skb->data + skb->len;
3305 u8 *ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
3306 skb->data + ieoffset,
3307 skb->len - ieoffset);
3308 if (!ie)
3309 return;
3310 len = ie[1] + 2;
3311 next = ie + len;
3312 memmove(ie, next, end - next);
3313 skb_trim(skb, skb->len - len);
3314 }
3315
3316 static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl, u32 rates,
3317 struct ieee80211_vif *vif)
3318 {
3319 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3320 struct sk_buff *skb;
3321 int ret;
3322
3323 skb = ieee80211_proberesp_get(wl->hw, vif);
3324 if (!skb)
3325 return -EOPNOTSUPP;
3326
3327 ret = wl1271_cmd_template_set(wl, wlvif->role_id,
3328 CMD_TEMPL_AP_PROBE_RESPONSE,
3329 skb->data,
3330 skb->len, 0,
3331 rates);
3332
3333 dev_kfree_skb(skb);
3334 return ret;
3335 }
3336
3337 static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271 *wl,
3338 struct ieee80211_vif *vif,
3339 u8 *probe_rsp_data,
3340 size_t probe_rsp_len,
3341 u32 rates)
3342 {
3343 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3344 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
3345 u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE];
3346 int ssid_ie_offset, ie_offset, templ_len;
3347 const u8 *ptr;
3348
3349 /* no need to change probe response if the SSID is set correctly */
3350 if (wlvif->ssid_len > 0)
3351 return wl1271_cmd_template_set(wl, wlvif->role_id,
3352 CMD_TEMPL_AP_PROBE_RESPONSE,
3353 probe_rsp_data,
3354 probe_rsp_len, 0,
3355 rates);
3356
3357 if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) {
3358 wl1271_error("probe_rsp template too big");
3359 return -EINVAL;
3360 }
3361
3362 /* start searching from IE offset */
3363 ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
3364
3365 ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset,
3366 probe_rsp_len - ie_offset);
3367 if (!ptr) {
3368 wl1271_error("No SSID in beacon!");
3369 return -EINVAL;
3370 }
3371
3372 ssid_ie_offset = ptr - probe_rsp_data;
3373 ptr += (ptr[1] + 2);
3374
3375 memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset);
3376
3377 /* insert SSID from bss_conf */
3378 probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID;
3379 probe_rsp_templ[ssid_ie_offset + 1] = bss_conf->ssid_len;
3380 memcpy(probe_rsp_templ + ssid_ie_offset + 2,
3381 bss_conf->ssid, bss_conf->ssid_len);
3382 templ_len = ssid_ie_offset + 2 + bss_conf->ssid_len;
3383
3384 memcpy(probe_rsp_templ + ssid_ie_offset + 2 + bss_conf->ssid_len,
3385 ptr, probe_rsp_len - (ptr - probe_rsp_data));
3386 templ_len += probe_rsp_len - (ptr - probe_rsp_data);
3387
3388 return wl1271_cmd_template_set(wl, wlvif->role_id,
3389 CMD_TEMPL_AP_PROBE_RESPONSE,
3390 probe_rsp_templ,
3391 templ_len, 0,
3392 rates);
3393 }
3394
3395 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
3396 struct ieee80211_vif *vif,
3397 struct ieee80211_bss_conf *bss_conf,
3398 u32 changed)
3399 {
3400 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3401 int ret = 0;
3402
3403 if (changed & BSS_CHANGED_ERP_SLOT) {
3404 if (bss_conf->use_short_slot)
3405 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT);
3406 else
3407 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG);
3408 if (ret < 0) {
3409 wl1271_warning("Set slot time failed %d", ret);
3410 goto out;
3411 }
3412 }
3413
3414 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3415 if (bss_conf->use_short_preamble)
3416 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT);
3417 else
3418 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG);
3419 }
3420
3421 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3422 if (bss_conf->use_cts_prot)
3423 ret = wl1271_acx_cts_protect(wl, wlvif,
3424 CTSPROTECT_ENABLE);
3425 else
3426 ret = wl1271_acx_cts_protect(wl, wlvif,
3427 CTSPROTECT_DISABLE);
3428 if (ret < 0) {
3429 wl1271_warning("Set ctsprotect failed %d", ret);
3430 goto out;
3431 }
3432 }
3433
3434 out:
3435 return ret;
3436 }
3437
3438 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3439 struct ieee80211_vif *vif,
3440 struct ieee80211_bss_conf *bss_conf,
3441 u32 changed)
3442 {
3443 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3444 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
3445 int ret = 0;
3446
3447 if ((changed & BSS_CHANGED_BEACON_INT)) {
3448 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
3449 bss_conf->beacon_int);
3450
3451 wlvif->beacon_int = bss_conf->beacon_int;
3452 }
3453
3454 if ((changed & BSS_CHANGED_AP_PROBE_RESP) && is_ap) {
3455 u32 rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
3456 if (!wl1271_ap_set_probe_resp_tmpl(wl, rate, vif)) {
3457 wl1271_debug(DEBUG_AP, "probe response updated");
3458 set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags);
3459 }
3460 }
3461
3462 if ((changed & BSS_CHANGED_BEACON)) {
3463 struct ieee80211_hdr *hdr;
3464 u32 min_rate;
3465 int ieoffset = offsetof(struct ieee80211_mgmt,
3466 u.beacon.variable);
3467 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3468 u16 tmpl_id;
3469
3470 if (!beacon) {
3471 ret = -EINVAL;
3472 goto out;
3473 }
3474
3475 wl1271_debug(DEBUG_MASTER, "beacon updated");
3476
3477 ret = wl1271_ssid_set(vif, beacon, ieoffset);
3478 if (ret < 0) {
3479 dev_kfree_skb(beacon);
3480 goto out;
3481 }
3482 min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
3483 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3484 CMD_TEMPL_BEACON;
3485 ret = wl1271_cmd_template_set(wl, wlvif->role_id, tmpl_id,
3486 beacon->data,
3487 beacon->len, 0,
3488 min_rate);
3489 if (ret < 0) {
3490 dev_kfree_skb(beacon);
3491 goto out;
3492 }
3493
3494 /*
3495 * In case we already have a probe-resp beacon set explicitly
3496 * by usermode, don't use the beacon data.
3497 */
3498 if (test_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags))
3499 goto end_bcn;
3500
3501 /* remove TIM ie from probe response */
3502 wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset);
3503
3504 /*
3505 * remove p2p ie from probe response.
3506 * the fw reponds to probe requests that don't include
3507 * the p2p ie. probe requests with p2p ie will be passed,
3508 * and will be responded by the supplicant (the spec
3509 * forbids including the p2p ie when responding to probe
3510 * requests that didn't include it).
3511 */
3512 wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA,
3513 WLAN_OUI_TYPE_WFA_P2P, ieoffset);
3514
3515 hdr = (struct ieee80211_hdr *) beacon->data;
3516 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3517 IEEE80211_STYPE_PROBE_RESP);
3518 if (is_ap)
3519 ret = wl1271_ap_set_probe_resp_tmpl_legacy(wl, vif,
3520 beacon->data,
3521 beacon->len,
3522 min_rate);
3523 else
3524 ret = wl1271_cmd_template_set(wl, wlvif->role_id,
3525 CMD_TEMPL_PROBE_RESPONSE,
3526 beacon->data,
3527 beacon->len, 0,
3528 min_rate);
3529 end_bcn:
3530 dev_kfree_skb(beacon);
3531 if (ret < 0)
3532 goto out;
3533 }
3534
3535 out:
3536 if (ret != 0)
3537 wl1271_error("beacon info change failed: %d", ret);
3538 return ret;
3539 }
3540
3541 /* AP mode changes */
3542 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3543 struct ieee80211_vif *vif,
3544 struct ieee80211_bss_conf *bss_conf,
3545 u32 changed)
3546 {
3547 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3548 int ret = 0;
3549
3550 if ((changed & BSS_CHANGED_BASIC_RATES)) {
3551 u32 rates = bss_conf->basic_rates;
3552
3553 wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates,
3554 wlvif->band);
3555 wlvif->basic_rate = wl1271_tx_min_rate_get(wl,
3556 wlvif->basic_rate_set);
3557
3558 ret = wl1271_init_ap_rates(wl, wlvif);
3559 if (ret < 0) {
3560 wl1271_error("AP rate policy change failed %d", ret);
3561 goto out;
3562 }
3563
3564 ret = wl1271_ap_init_templates(wl, vif);
3565 if (ret < 0)
3566 goto out;
3567 }
3568
3569 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3570 if (ret < 0)
3571 goto out;
3572
3573 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3574 if (bss_conf->enable_beacon) {
3575 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
3576 ret = wl12xx_cmd_role_start_ap(wl, wlvif);
3577 if (ret < 0)
3578 goto out;
3579
3580 ret = wl1271_ap_init_hwenc(wl, wlvif);
3581 if (ret < 0)
3582 goto out;
3583
3584 set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
3585 wl1271_debug(DEBUG_AP, "started AP");
3586 }
3587 } else {
3588 if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
3589 ret = wl12xx_cmd_role_stop_ap(wl, wlvif);
3590 if (ret < 0)
3591 goto out;
3592
3593 clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
3594 clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET,
3595 &wlvif->flags);
3596 wl1271_debug(DEBUG_AP, "stopped AP");
3597 }
3598 }
3599 }
3600
3601 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
3602 if (ret < 0)
3603 goto out;
3604
3605 /* Handle HT information change */
3606 if ((changed & BSS_CHANGED_HT) &&
3607 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3608 ret = wl1271_acx_set_ht_information(wl, wlvif,
3609 bss_conf->ht_operation_mode);
3610 if (ret < 0) {
3611 wl1271_warning("Set ht information failed %d", ret);
3612 goto out;
3613 }
3614 }
3615
3616 out:
3617 return;
3618 }
3619
3620 /* STA/IBSS mode changes */
3621 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3622 struct ieee80211_vif *vif,
3623 struct ieee80211_bss_conf *bss_conf,
3624 u32 changed)
3625 {
3626 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3627 bool do_join = false, set_assoc = false;
3628 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
3629 bool ibss_joined = false;
3630 u32 sta_rate_set = 0;
3631 int ret;
3632 struct ieee80211_sta *sta;
3633 bool sta_exists = false;
3634 struct ieee80211_sta_ht_cap sta_ht_cap;
3635
3636 if (is_ibss) {
3637 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3638 changed);
3639 if (ret < 0)
3640 goto out;
3641 }
3642
3643 if (changed & BSS_CHANGED_IBSS) {
3644 if (bss_conf->ibss_joined) {
3645 set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags);
3646 ibss_joined = true;
3647 } else {
3648 if (test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED,
3649 &wlvif->flags))
3650 wl1271_unjoin(wl, wlvif);
3651 }
3652 }
3653
3654 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
3655 do_join = true;
3656
3657 /* Need to update the SSID (for filtering etc) */
3658 if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
3659 do_join = true;
3660
3661 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
3662 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3663 bss_conf->enable_beacon ? "enabled" : "disabled");
3664
3665 do_join = true;
3666 }
3667
3668 if (changed & BSS_CHANGED_IDLE && !is_ibss) {
3669 ret = wl1271_sta_handle_idle(wl, wlvif, bss_conf->idle);
3670 if (ret < 0)
3671 wl1271_warning("idle mode change failed %d", ret);
3672 }
3673
3674 if ((changed & BSS_CHANGED_CQM)) {
3675 bool enable = false;
3676 if (bss_conf->cqm_rssi_thold)
3677 enable = true;
3678 ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable,
3679 bss_conf->cqm_rssi_thold,
3680 bss_conf->cqm_rssi_hyst);
3681 if (ret < 0)
3682 goto out;
3683 wlvif->rssi_thold = bss_conf->cqm_rssi_thold;
3684 }
3685
3686 if (changed & BSS_CHANGED_BSSID)
3687 if (!is_zero_ether_addr(bss_conf->bssid)) {
3688 ret = wl12xx_cmd_build_null_data(wl, wlvif);
3689 if (ret < 0)
3690 goto out;
3691
3692 ret = wl1271_build_qos_null_data(wl, vif);
3693 if (ret < 0)
3694 goto out;
3695 }
3696
3697 if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
3698 rcu_read_lock();
3699 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3700 if (!sta)
3701 goto sta_not_found;
3702
3703 /* save the supp_rates of the ap */
3704 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3705 if (sta->ht_cap.ht_supported)
3706 sta_rate_set |=
3707 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET) |
3708 (sta->ht_cap.mcs.rx_mask[1] << HW_MIMO_RATES_OFFSET);
3709 sta_ht_cap = sta->ht_cap;
3710 sta_exists = true;
3711
3712 sta_not_found:
3713 rcu_read_unlock();
3714 }
3715
3716 if ((changed & BSS_CHANGED_ASSOC)) {
3717 if (bss_conf->assoc) {
3718 u32 rates;
3719 int ieoffset;
3720 wlvif->aid = bss_conf->aid;
3721 wlvif->channel_type = bss_conf->channel_type;
3722 wlvif->beacon_int = bss_conf->beacon_int;
3723 do_join = true;
3724 set_assoc = true;
3725
3726 /* Cancel connection_loss_work */
3727 cancel_delayed_work_sync(&wl->connection_loss_work);
3728
3729 /*
3730 * use basic rates from AP, and determine lowest rate
3731 * to use with control frames.
3732 */
3733 rates = bss_conf->basic_rates;
3734 wlvif->basic_rate_set =
3735 wl1271_tx_enabled_rates_get(wl, rates,
3736 wlvif->band);
3737 wlvif->basic_rate =
3738 wl1271_tx_min_rate_get(wl,
3739 wlvif->basic_rate_set);
3740 if (sta_rate_set)
3741 wlvif->rate_set =
3742 wl1271_tx_enabled_rates_get(wl,
3743 sta_rate_set,
3744 wlvif->band);
3745 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3746 if (ret < 0)
3747 goto out;
3748
3749 /*
3750 * with wl1271, we don't need to update the
3751 * beacon_int and dtim_period, because the firmware
3752 * updates it by itself when the first beacon is
3753 * received after a join.
3754 */
3755 ret = wl1271_cmd_build_ps_poll(wl, wlvif, wlvif->aid);
3756 if (ret < 0)
3757 goto out;
3758
3759 /*
3760 * Get a template for hardware connection maintenance
3761 */
3762 dev_kfree_skb(wlvif->probereq);
3763 wlvif->probereq = wl1271_cmd_build_ap_probe_req(wl,
3764 wlvif,
3765 NULL);
3766 ieoffset = offsetof(struct ieee80211_mgmt,
3767 u.probe_req.variable);
3768 wl1271_ssid_set(vif, wlvif->probereq, ieoffset);
3769
3770 /* enable the connection monitoring feature */
3771 ret = wl1271_acx_conn_monit_params(wl, wlvif, true);
3772 if (ret < 0)
3773 goto out;
3774 } else {
3775 /* use defaults when not associated */
3776 bool was_assoc =
3777 !!test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED,
3778 &wlvif->flags);
3779 bool was_ifup =
3780 !!test_and_clear_bit(WLVIF_FLAG_STA_STATE_SENT,
3781 &wlvif->flags);
3782 wlvif->aid = 0;
3783
3784 /* free probe-request template */
3785 dev_kfree_skb(wlvif->probereq);
3786 wlvif->probereq = NULL;
3787
3788 /* revert back to minimum rates for the current band */
3789 wl1271_set_band_rate(wl, wlvif);
3790 wlvif->basic_rate =
3791 wl1271_tx_min_rate_get(wl,
3792 wlvif->basic_rate_set);
3793 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3794 if (ret < 0)
3795 goto out;
3796
3797 /* disable connection monitor features */
3798 ret = wl1271_acx_conn_monit_params(wl, wlvif, false);
3799
3800 /* Disable the keep-alive feature */
3801 ret = wl1271_acx_keep_alive_mode(wl, wlvif, false);
3802 if (ret < 0)
3803 goto out;
3804
3805 /* restore the bssid filter and go to dummy bssid */
3806 if (was_assoc) {
3807 /*
3808 * we might have to disable roc, if there was
3809 * no IF_OPER_UP notification.
3810 */
3811 if (!was_ifup) {
3812 ret = wl12xx_croc(wl, wlvif->role_id);
3813 if (ret < 0)
3814 goto out;
3815 }
3816 /*
3817 * (we also need to disable roc in case of
3818 * roaming on the same channel. until we will
3819 * have a better flow...)
3820 */
3821 if (test_bit(wlvif->dev_role_id, wl->roc_map)) {
3822 ret = wl12xx_croc(wl,
3823 wlvif->dev_role_id);
3824 if (ret < 0)
3825 goto out;
3826 }
3827
3828 wl1271_unjoin(wl, wlvif);
3829 if (!bss_conf->idle)
3830 wl12xx_start_dev(wl, wlvif);
3831 }
3832 }
3833 }
3834
3835 if (changed & BSS_CHANGED_IBSS) {
3836 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3837 bss_conf->ibss_joined);
3838
3839 if (bss_conf->ibss_joined) {
3840 u32 rates = bss_conf->basic_rates;
3841 wlvif->basic_rate_set =
3842 wl1271_tx_enabled_rates_get(wl, rates,
3843 wlvif->band);
3844 wlvif->basic_rate =
3845 wl1271_tx_min_rate_get(wl,
3846 wlvif->basic_rate_set);
3847
3848 /* by default, use 11b + OFDM rates */
3849 wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3850 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3851 if (ret < 0)
3852 goto out;
3853 }
3854 }
3855
3856 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
3857 if (ret < 0)
3858 goto out;
3859
3860 if (do_join) {
3861 ret = wl1271_join(wl, wlvif, set_assoc);
3862 if (ret < 0) {
3863 wl1271_warning("cmd join failed %d", ret);
3864 goto out;
3865 }
3866
3867 /* ROC until connected (after EAPOL exchange) */
3868 if (!is_ibss) {
3869 ret = wl12xx_roc(wl, wlvif, wlvif->role_id);
3870 if (ret < 0)
3871 goto out;
3872
3873 if (test_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags))
3874 wl12xx_set_authorized(wl, wlvif);
3875 }
3876 /*
3877 * stop device role if started (we might already be in
3878 * STA/IBSS role).
3879 */
3880 if (wl12xx_dev_role_started(wlvif)) {
3881 ret = wl12xx_stop_dev(wl, wlvif);
3882 if (ret < 0)
3883 goto out;
3884 }
3885 }
3886
3887 /* Handle new association with HT. Do this after join. */
3888 if (sta_exists) {
3889 if ((changed & BSS_CHANGED_HT) &&
3890 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3891 ret = wl1271_acx_set_ht_capabilities(wl,
3892 &sta_ht_cap,
3893 true,
3894 wlvif->sta.hlid);
3895 if (ret < 0) {
3896 wl1271_warning("Set ht cap true failed %d",
3897 ret);
3898 goto out;
3899 }
3900 }
3901 /* handle new association without HT and disassociation */
3902 else if (changed & BSS_CHANGED_ASSOC) {
3903 ret = wl1271_acx_set_ht_capabilities(wl,
3904 &sta_ht_cap,
3905 false,
3906 wlvif->sta.hlid);
3907 if (ret < 0) {
3908 wl1271_warning("Set ht cap false failed %d",
3909 ret);
3910 goto out;
3911 }
3912 }
3913 }
3914
3915 /* Handle HT information change. Done after join. */
3916 if ((changed & BSS_CHANGED_HT) &&
3917 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3918 ret = wl1271_acx_set_ht_information(wl, wlvif,
3919 bss_conf->ht_operation_mode);
3920 if (ret < 0) {
3921 wl1271_warning("Set ht information failed %d", ret);
3922 goto out;
3923 }
3924 }
3925
3926 /* Handle arp filtering. Done after join. */
3927 if ((changed & BSS_CHANGED_ARP_FILTER) ||
3928 (!is_ibss && (changed & BSS_CHANGED_QOS))) {
3929 __be32 addr = bss_conf->arp_addr_list[0];
3930 wlvif->sta.qos = bss_conf->qos;
3931 WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS);
3932
3933 if (bss_conf->arp_addr_cnt == 1 &&
3934 bss_conf->arp_filter_enabled) {
3935 wlvif->ip_addr = addr;
3936 /*
3937 * The template should have been configured only upon
3938 * association. however, it seems that the correct ip
3939 * isn't being set (when sending), so we have to
3940 * reconfigure the template upon every ip change.
3941 */
3942 ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
3943 if (ret < 0) {
3944 wl1271_warning("build arp rsp failed: %d", ret);
3945 goto out;
3946 }
3947
3948 ret = wl1271_acx_arp_ip_filter(wl, wlvif,
3949 (ACX_ARP_FILTER_ARP_FILTERING |
3950 ACX_ARP_FILTER_AUTO_ARP),
3951 addr);
3952 } else {
3953 wlvif->ip_addr = 0;
3954 ret = wl1271_acx_arp_ip_filter(wl, wlvif, 0, addr);
3955 }
3956
3957 if (ret < 0)
3958 goto out;
3959 }
3960
3961 out:
3962 return;
3963 }
3964
3965 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3966 struct ieee80211_vif *vif,
3967 struct ieee80211_bss_conf *bss_conf,
3968 u32 changed)
3969 {
3970 struct wl1271 *wl = hw->priv;
3971 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3972 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
3973 int ret;
3974
3975 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3976 (int)changed);
3977
3978 mutex_lock(&wl->mutex);
3979
3980 if (unlikely(wl->state == WL1271_STATE_OFF))
3981 goto out;
3982
3983 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
3984 goto out;
3985
3986 ret = wl1271_ps_elp_wakeup(wl);
3987 if (ret < 0)
3988 goto out;
3989
3990 if (is_ap)
3991 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3992 else
3993 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3994
3995 wl1271_ps_elp_sleep(wl);
3996
3997 out:
3998 mutex_unlock(&wl->mutex);
3999 }
4000
4001 static int wl1271_op_conf_tx(struct ieee80211_hw *hw,
4002 struct ieee80211_vif *vif, u16 queue,
4003 const struct ieee80211_tx_queue_params *params)
4004 {
4005 struct wl1271 *wl = hw->priv;
4006 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4007 u8 ps_scheme;
4008 int ret = 0;
4009
4010 mutex_lock(&wl->mutex);
4011
4012 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
4013
4014 if (params->uapsd)
4015 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
4016 else
4017 ps_scheme = CONF_PS_SCHEME_LEGACY;
4018
4019 if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
4020 goto out;
4021
4022 ret = wl1271_ps_elp_wakeup(wl);
4023 if (ret < 0)
4024 goto out;
4025
4026 /*
4027 * the txop is confed in units of 32us by the mac80211,
4028 * we need us
4029 */
4030 ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4031 params->cw_min, params->cw_max,
4032 params->aifs, params->txop << 5);
4033 if (ret < 0)
4034 goto out_sleep;
4035
4036 ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4037 CONF_CHANNEL_TYPE_EDCF,
4038 wl1271_tx_get_queue(queue),
4039 ps_scheme, CONF_ACK_POLICY_LEGACY,
4040 0, 0);
4041
4042 out_sleep:
4043 wl1271_ps_elp_sleep(wl);
4044
4045 out:
4046 mutex_unlock(&wl->mutex);
4047
4048 return ret;
4049 }
4050
4051 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw,
4052 struct ieee80211_vif *vif)
4053 {
4054
4055 struct wl1271 *wl = hw->priv;
4056 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4057 u64 mactime = ULLONG_MAX;
4058 int ret;
4059
4060 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
4061
4062 mutex_lock(&wl->mutex);
4063
4064 if (unlikely(wl->state == WL1271_STATE_OFF))
4065 goto out;
4066
4067 ret = wl1271_ps_elp_wakeup(wl);
4068 if (ret < 0)
4069 goto out;
4070
4071 ret = wl12xx_acx_tsf_info(wl, wlvif, &mactime);
4072 if (ret < 0)
4073 goto out_sleep;
4074
4075 out_sleep:
4076 wl1271_ps_elp_sleep(wl);
4077
4078 out:
4079 mutex_unlock(&wl->mutex);
4080 return mactime;
4081 }
4082
4083 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
4084 struct survey_info *survey)
4085 {
4086 struct wl1271 *wl = hw->priv;
4087 struct ieee80211_conf *conf = &hw->conf;
4088
4089 if (idx != 0)
4090 return -ENOENT;
4091
4092 survey->channel = conf->channel;
4093 survey->filled = SURVEY_INFO_NOISE_DBM;
4094 survey->noise = wl->noise;
4095
4096 return 0;
4097 }
4098
4099 static int wl1271_allocate_sta(struct wl1271 *wl,
4100 struct wl12xx_vif *wlvif,
4101 struct ieee80211_sta *sta)
4102 {
4103 struct wl1271_station *wl_sta;
4104 int ret;
4105
4106
4107 if (wl->active_sta_count >= AP_MAX_STATIONS) {
4108 wl1271_warning("could not allocate HLID - too much stations");
4109 return -EBUSY;
4110 }
4111
4112 wl_sta = (struct wl1271_station *)sta->drv_priv;
4113 ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid);
4114 if (ret < 0) {
4115 wl1271_warning("could not allocate HLID - too many links");
4116 return -EBUSY;
4117 }
4118
4119 set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map);
4120 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
4121 wl->active_sta_count++;
4122 return 0;
4123 }
4124
4125 void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid)
4126 {
4127 if (!test_bit(hlid, wlvif->ap.sta_hlid_map))
4128 return;
4129
4130 clear_bit(hlid, wlvif->ap.sta_hlid_map);
4131 memset(wl->links[hlid].addr, 0, ETH_ALEN);
4132 wl->links[hlid].ba_bitmap = 0;
4133 __clear_bit(hlid, &wl->ap_ps_map);
4134 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
4135 wl12xx_free_link(wl, wlvif, &hlid);
4136 wl->active_sta_count--;
4137
4138 /*
4139 * rearm the tx watchdog when the last STA is freed - give the FW a
4140 * chance to return STA-buffered packets before complaining.
4141 */
4142 if (wl->active_sta_count == 0)
4143 wl12xx_rearm_tx_watchdog_locked(wl);
4144 }
4145
4146 static int wl12xx_sta_add(struct wl1271 *wl,
4147 struct wl12xx_vif *wlvif,
4148 struct ieee80211_sta *sta)
4149 {
4150 struct wl1271_station *wl_sta;
4151 int ret = 0;
4152 u8 hlid;
4153
4154 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
4155
4156 ret = wl1271_allocate_sta(wl, wlvif, sta);
4157 if (ret < 0)
4158 return ret;
4159
4160 wl_sta = (struct wl1271_station *)sta->drv_priv;
4161 hlid = wl_sta->hlid;
4162
4163 ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid);
4164 if (ret < 0)
4165 wl1271_free_sta(wl, wlvif, hlid);
4166
4167 return ret;
4168 }
4169
4170 static int wl12xx_sta_remove(struct wl1271 *wl,
4171 struct wl12xx_vif *wlvif,
4172 struct ieee80211_sta *sta)
4173 {
4174 struct wl1271_station *wl_sta;
4175 int ret = 0, id;
4176
4177 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
4178
4179 wl_sta = (struct wl1271_station *)sta->drv_priv;
4180 id = wl_sta->hlid;
4181 if (WARN_ON(!test_bit(id, wlvif->ap.sta_hlid_map)))
4182 return -EINVAL;
4183
4184 ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
4185 if (ret < 0)
4186 return ret;
4187
4188 wl1271_free_sta(wl, wlvif, wl_sta->hlid);
4189 return ret;
4190 }
4191
4192 static int wl12xx_update_sta_state(struct wl1271 *wl,
4193 struct wl12xx_vif *wlvif,
4194 struct ieee80211_sta *sta,
4195 enum ieee80211_sta_state old_state,
4196 enum ieee80211_sta_state new_state)
4197 {
4198 struct wl1271_station *wl_sta;
4199 u8 hlid;
4200 bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
4201 bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
4202 int ret;
4203
4204 wl_sta = (struct wl1271_station *)sta->drv_priv;
4205 hlid = wl_sta->hlid;
4206
4207 /* Add station (AP mode) */
4208 if (is_ap &&
4209 old_state == IEEE80211_STA_NOTEXIST &&
4210 new_state == IEEE80211_STA_NONE)
4211 return wl12xx_sta_add(wl, wlvif, sta);
4212
4213 /* Remove station (AP mode) */
4214 if (is_ap &&
4215 old_state == IEEE80211_STA_NONE &&
4216 new_state == IEEE80211_STA_NOTEXIST) {
4217 /* must not fail */
4218 wl12xx_sta_remove(wl, wlvif, sta);
4219 return 0;
4220 }
4221
4222 /* Authorize station (AP mode) */
4223 if (is_ap &&
4224 new_state == IEEE80211_STA_AUTHORIZED) {
4225 ret = wl12xx_cmd_set_peer_state(wl, hlid);
4226 if (ret < 0)
4227 return ret;
4228
4229 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true,
4230 hlid);
4231 return ret;
4232 }
4233
4234 /* Authorize station */
4235 if (is_sta &&
4236 new_state == IEEE80211_STA_AUTHORIZED) {
4237 set_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
4238 return wl12xx_set_authorized(wl, wlvif);
4239 }
4240
4241 if (is_sta &&
4242 old_state == IEEE80211_STA_AUTHORIZED &&
4243 new_state == IEEE80211_STA_ASSOC) {
4244 clear_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
4245 return 0;
4246 }
4247
4248 return 0;
4249 }
4250
4251 static int wl12xx_op_sta_state(struct ieee80211_hw *hw,
4252 struct ieee80211_vif *vif,
4253 struct ieee80211_sta *sta,
4254 enum ieee80211_sta_state old_state,
4255 enum ieee80211_sta_state new_state)
4256 {
4257 struct wl1271 *wl = hw->priv;
4258 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4259 int ret;
4260
4261 wl1271_debug(DEBUG_MAC80211, "mac80211 sta %d state=%d->%d",
4262 sta->aid, old_state, new_state);
4263
4264 mutex_lock(&wl->mutex);
4265
4266 if (unlikely(wl->state == WL1271_STATE_OFF)) {
4267 ret = -EBUSY;
4268 goto out;
4269 }
4270
4271 ret = wl1271_ps_elp_wakeup(wl);
4272 if (ret < 0)
4273 goto out;
4274
4275 ret = wl12xx_update_sta_state(wl, wlvif, sta, old_state, new_state);
4276
4277 wl1271_ps_elp_sleep(wl);
4278 out:
4279 mutex_unlock(&wl->mutex);
4280 if (new_state < old_state)
4281 return 0;
4282 return ret;
4283 }
4284
4285 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
4286 struct ieee80211_vif *vif,
4287 enum ieee80211_ampdu_mlme_action action,
4288 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4289 u8 buf_size)
4290 {
4291 struct wl1271 *wl = hw->priv;
4292 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4293 int ret;
4294 u8 hlid, *ba_bitmap;
4295
4296 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
4297 tid);
4298
4299 /* sanity check - the fields in FW are only 8bits wide */
4300 if (WARN_ON(tid > 0xFF))
4301 return -ENOTSUPP;
4302
4303 mutex_lock(&wl->mutex);
4304
4305 if (unlikely(wl->state == WL1271_STATE_OFF)) {
4306 ret = -EAGAIN;
4307 goto out;
4308 }
4309
4310 if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
4311 hlid = wlvif->sta.hlid;
4312 ba_bitmap = &wlvif->sta.ba_rx_bitmap;
4313 } else if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
4314 struct wl1271_station *wl_sta;
4315
4316 wl_sta = (struct wl1271_station *)sta->drv_priv;
4317 hlid = wl_sta->hlid;
4318 ba_bitmap = &wl->links[hlid].ba_bitmap;
4319 } else {
4320 ret = -EINVAL;
4321 goto out;
4322 }
4323
4324 ret = wl1271_ps_elp_wakeup(wl);
4325 if (ret < 0)
4326 goto out;
4327
4328 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
4329 tid, action);
4330
4331 switch (action) {
4332 case IEEE80211_AMPDU_RX_START:
4333 if (!wlvif->ba_support || !wlvif->ba_allowed) {
4334 ret = -ENOTSUPP;
4335 break;
4336 }
4337
4338 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
4339 ret = -EBUSY;
4340 wl1271_error("exceeded max RX BA sessions");
4341 break;
4342 }
4343
4344 if (*ba_bitmap & BIT(tid)) {
4345 ret = -EINVAL;
4346 wl1271_error("cannot enable RX BA session on active "
4347 "tid: %d", tid);
4348 break;
4349 }
4350
4351 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
4352 hlid);
4353 if (!ret) {
4354 *ba_bitmap |= BIT(tid);
4355 wl->ba_rx_session_count++;
4356 }
4357 break;
4358
4359 case IEEE80211_AMPDU_RX_STOP:
4360 if (!(*ba_bitmap & BIT(tid))) {
4361 ret = -EINVAL;
4362 wl1271_error("no active RX BA session on tid: %d",
4363 tid);
4364 break;
4365 }
4366
4367 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
4368 hlid);
4369 if (!ret) {
4370 *ba_bitmap &= ~BIT(tid);
4371 wl->ba_rx_session_count--;
4372 }
4373 break;
4374
4375 /*
4376 * The BA initiator session management in FW independently.
4377 * Falling break here on purpose for all TX APDU commands.
4378 */
4379 case IEEE80211_AMPDU_TX_START:
4380 case IEEE80211_AMPDU_TX_STOP:
4381 case IEEE80211_AMPDU_TX_OPERATIONAL:
4382 ret = -EINVAL;
4383 break;
4384
4385 default:
4386 wl1271_error("Incorrect ampdu action id=%x\n", action);
4387 ret = -EINVAL;
4388 }
4389
4390 wl1271_ps_elp_sleep(wl);
4391
4392 out:
4393 mutex_unlock(&wl->mutex);
4394
4395 return ret;
4396 }
4397
4398 static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
4399 struct ieee80211_vif *vif,
4400 const struct cfg80211_bitrate_mask *mask)
4401 {
4402 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4403 struct wl1271 *wl = hw->priv;
4404 int i, ret = 0;
4405
4406 wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x",
4407 mask->control[NL80211_BAND_2GHZ].legacy,
4408 mask->control[NL80211_BAND_5GHZ].legacy);
4409
4410 mutex_lock(&wl->mutex);
4411
4412 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
4413 wlvif->bitrate_masks[i] =
4414 wl1271_tx_enabled_rates_get(wl,
4415 mask->control[i].legacy,
4416 i);
4417
4418 if (unlikely(wl->state == WL1271_STATE_OFF))
4419 goto out;
4420
4421 if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
4422 !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
4423
4424 ret = wl1271_ps_elp_wakeup(wl);
4425 if (ret < 0)
4426 goto out;
4427
4428 wl1271_set_band_rate(wl, wlvif);
4429 wlvif->basic_rate =
4430 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
4431 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4432
4433 wl1271_ps_elp_sleep(wl);
4434 }
4435 out:
4436 mutex_unlock(&wl->mutex);
4437
4438 return ret;
4439 }
4440
4441 static void wl12xx_op_channel_switch(struct ieee80211_hw *hw,
4442 struct ieee80211_channel_switch *ch_switch)
4443 {
4444 struct wl1271 *wl = hw->priv;
4445 struct wl12xx_vif *wlvif;
4446 int ret;
4447
4448 wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch");
4449
4450 wl1271_tx_flush(wl);
4451
4452 mutex_lock(&wl->mutex);
4453
4454 if (unlikely(wl->state == WL1271_STATE_OFF)) {
4455 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4456 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
4457 ieee80211_chswitch_done(vif, false);
4458 }
4459 goto out;
4460 }
4461
4462 ret = wl1271_ps_elp_wakeup(wl);
4463 if (ret < 0)
4464 goto out;
4465
4466 /* TODO: change mac80211 to pass vif as param */
4467 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4468 ret = wl12xx_cmd_channel_switch(wl, wlvif, ch_switch);
4469
4470 if (!ret)
4471 set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);
4472 }
4473
4474 wl1271_ps_elp_sleep(wl);
4475
4476 out:
4477 mutex_unlock(&wl->mutex);
4478 }
4479
4480 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
4481 {
4482 struct wl1271 *wl = hw->priv;
4483 bool ret = false;
4484
4485 mutex_lock(&wl->mutex);
4486
4487 if (unlikely(wl->state == WL1271_STATE_OFF))
4488 goto out;
4489
4490 /* packets are considered pending if in the TX queue or the FW */
4491 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
4492 out:
4493 mutex_unlock(&wl->mutex);
4494
4495 return ret;
4496 }
4497
4498 /* can't be const, mac80211 writes to this */
4499 static struct ieee80211_rate wl1271_rates[] = {
4500 { .bitrate = 10,
4501 .hw_value = CONF_HW_BIT_RATE_1MBPS,
4502 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
4503 { .bitrate = 20,
4504 .hw_value = CONF_HW_BIT_RATE_2MBPS,
4505 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
4506 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4507 { .bitrate = 55,
4508 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
4509 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
4510 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4511 { .bitrate = 110,
4512 .hw_value = CONF_HW_BIT_RATE_11MBPS,
4513 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
4514 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4515 { .bitrate = 60,
4516 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4517 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4518 { .bitrate = 90,
4519 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4520 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4521 { .bitrate = 120,
4522 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4523 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4524 { .bitrate = 180,
4525 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4526 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4527 { .bitrate = 240,
4528 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4529 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4530 { .bitrate = 360,
4531 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4532 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4533 { .bitrate = 480,
4534 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4535 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4536 { .bitrate = 540,
4537 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4538 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4539 };
4540
4541 /* can't be const, mac80211 writes to this */
4542 static struct ieee80211_channel wl1271_channels[] = {
4543 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
4544 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
4545 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
4546 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
4547 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
4548 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
4549 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
4550 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
4551 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
4552 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
4553 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
4554 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
4555 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
4556 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
4557 };
4558
4559 /* can't be const, mac80211 writes to this */
4560 static struct ieee80211_supported_band wl1271_band_2ghz = {
4561 .channels = wl1271_channels,
4562 .n_channels = ARRAY_SIZE(wl1271_channels),
4563 .bitrates = wl1271_rates,
4564 .n_bitrates = ARRAY_SIZE(wl1271_rates),
4565 };
4566
4567 /* 5 GHz data rates for WL1273 */
4568 static struct ieee80211_rate wl1271_rates_5ghz[] = {
4569 { .bitrate = 60,
4570 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4571 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4572 { .bitrate = 90,
4573 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4574 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4575 { .bitrate = 120,
4576 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4577 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4578 { .bitrate = 180,
4579 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4580 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4581 { .bitrate = 240,
4582 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4583 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4584 { .bitrate = 360,
4585 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4586 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4587 { .bitrate = 480,
4588 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4589 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4590 { .bitrate = 540,
4591 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4592 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4593 };
4594
4595 /* 5 GHz band channels for WL1273 */
4596 static struct ieee80211_channel wl1271_channels_5ghz[] = {
4597 { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
4598 { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
4599 { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
4600 { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
4601 { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
4602 { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
4603 { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
4604 { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
4605 { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
4606 { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
4607 { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
4608 { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
4609 { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
4610 { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
4611 { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
4612 { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
4613 { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
4614 { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
4615 { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
4616 { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
4617 { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
4618 { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
4619 { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
4620 { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
4621 { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
4622 { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
4623 { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
4624 { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
4625 { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
4626 { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
4627 { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
4628 { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
4629 { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
4630 { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
4631 };
4632
4633 static struct ieee80211_supported_band wl1271_band_5ghz = {
4634 .channels = wl1271_channels_5ghz,
4635 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4636 .bitrates = wl1271_rates_5ghz,
4637 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
4638 };
4639
4640 static const struct ieee80211_ops wl1271_ops = {
4641 .start = wl1271_op_start,
4642 .stop = wl1271_op_stop,
4643 .add_interface = wl1271_op_add_interface,
4644 .remove_interface = wl1271_op_remove_interface,
4645 .change_interface = wl12xx_op_change_interface,
4646 #ifdef CONFIG_PM
4647 .suspend = wl1271_op_suspend,
4648 .resume = wl1271_op_resume,
4649 #endif
4650 .config = wl1271_op_config,
4651 .prepare_multicast = wl1271_op_prepare_multicast,
4652 .configure_filter = wl1271_op_configure_filter,
4653 .tx = wl1271_op_tx,
4654 .set_key = wl1271_op_set_key,
4655 .hw_scan = wl1271_op_hw_scan,
4656 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
4657 .sched_scan_start = wl1271_op_sched_scan_start,
4658 .sched_scan_stop = wl1271_op_sched_scan_stop,
4659 .bss_info_changed = wl1271_op_bss_info_changed,
4660 .set_frag_threshold = wl1271_op_set_frag_threshold,
4661 .set_rts_threshold = wl1271_op_set_rts_threshold,
4662 .conf_tx = wl1271_op_conf_tx,
4663 .get_tsf = wl1271_op_get_tsf,
4664 .get_survey = wl1271_op_get_survey,
4665 .sta_state = wl12xx_op_sta_state,
4666 .ampdu_action = wl1271_op_ampdu_action,
4667 .tx_frames_pending = wl1271_tx_frames_pending,
4668 .set_bitrate_mask = wl12xx_set_bitrate_mask,
4669 .channel_switch = wl12xx_op_channel_switch,
4670 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
4671 };
4672
4673
4674 u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum ieee80211_band band)
4675 {
4676 u8 idx;
4677
4678 BUG_ON(band >= 2);
4679
4680 if (unlikely(rate >= wl->hw_tx_rate_tbl_size)) {
4681 wl1271_error("Illegal RX rate from HW: %d", rate);
4682 return 0;
4683 }
4684
4685 idx = wl->band_rate_to_idx[band][rate];
4686 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4687 wl1271_error("Unsupported RX rate from HW: %d", rate);
4688 return 0;
4689 }
4690
4691 return idx;
4692 }
4693
4694 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4695 struct device_attribute *attr,
4696 char *buf)
4697 {
4698 struct wl1271 *wl = dev_get_drvdata(dev);
4699 ssize_t len;
4700
4701 len = PAGE_SIZE;
4702
4703 mutex_lock(&wl->mutex);
4704 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4705 wl->sg_enabled);
4706 mutex_unlock(&wl->mutex);
4707
4708 return len;
4709
4710 }
4711
4712 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4713 struct device_attribute *attr,
4714 const char *buf, size_t count)
4715 {
4716 struct wl1271 *wl = dev_get_drvdata(dev);
4717 unsigned long res;
4718 int ret;
4719
4720 ret = kstrtoul(buf, 10, &res);
4721 if (ret < 0) {
4722 wl1271_warning("incorrect value written to bt_coex_mode");
4723 return count;
4724 }
4725
4726 mutex_lock(&wl->mutex);
4727
4728 res = !!res;
4729
4730 if (res == wl->sg_enabled)
4731 goto out;
4732
4733 wl->sg_enabled = res;
4734
4735 if (wl->state == WL1271_STATE_OFF)
4736 goto out;
4737
4738 ret = wl1271_ps_elp_wakeup(wl);
4739 if (ret < 0)
4740 goto out;
4741
4742 wl1271_acx_sg_enable(wl, wl->sg_enabled);
4743 wl1271_ps_elp_sleep(wl);
4744
4745 out:
4746 mutex_unlock(&wl->mutex);
4747 return count;
4748 }
4749
4750 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4751 wl1271_sysfs_show_bt_coex_state,
4752 wl1271_sysfs_store_bt_coex_state);
4753
4754 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4755 struct device_attribute *attr,
4756 char *buf)
4757 {
4758 struct wl1271 *wl = dev_get_drvdata(dev);
4759 ssize_t len;
4760
4761 len = PAGE_SIZE;
4762
4763 mutex_lock(&wl->mutex);
4764 if (wl->hw_pg_ver >= 0)
4765 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4766 else
4767 len = snprintf(buf, len, "n/a\n");
4768 mutex_unlock(&wl->mutex);
4769
4770 return len;
4771 }
4772
4773 static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
4774 wl1271_sysfs_show_hw_pg_ver, NULL);
4775
4776 static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4777 struct bin_attribute *bin_attr,
4778 char *buffer, loff_t pos, size_t count)
4779 {
4780 struct device *dev = container_of(kobj, struct device, kobj);
4781 struct wl1271 *wl = dev_get_drvdata(dev);
4782 ssize_t len;
4783 int ret;
4784
4785 ret = mutex_lock_interruptible(&wl->mutex);
4786 if (ret < 0)
4787 return -ERESTARTSYS;
4788
4789 /* Let only one thread read the log at a time, blocking others */
4790 while (wl->fwlog_size == 0) {
4791 DEFINE_WAIT(wait);
4792
4793 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4794 &wait,
4795 TASK_INTERRUPTIBLE);
4796
4797 if (wl->fwlog_size != 0) {
4798 finish_wait(&wl->fwlog_waitq, &wait);
4799 break;
4800 }
4801
4802 mutex_unlock(&wl->mutex);
4803
4804 schedule();
4805 finish_wait(&wl->fwlog_waitq, &wait);
4806
4807 if (signal_pending(current))
4808 return -ERESTARTSYS;
4809
4810 ret = mutex_lock_interruptible(&wl->mutex);
4811 if (ret < 0)
4812 return -ERESTARTSYS;
4813 }
4814
4815 /* Check if the fwlog is still valid */
4816 if (wl->fwlog_size < 0) {
4817 mutex_unlock(&wl->mutex);
4818 return 0;
4819 }
4820
4821 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4822 len = min(count, (size_t)wl->fwlog_size);
4823 wl->fwlog_size -= len;
4824 memcpy(buffer, wl->fwlog, len);
4825
4826 /* Make room for new messages */
4827 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4828
4829 mutex_unlock(&wl->mutex);
4830
4831 return len;
4832 }
4833
4834 static struct bin_attribute fwlog_attr = {
4835 .attr = {.name = "fwlog", .mode = S_IRUSR},
4836 .read = wl1271_sysfs_read_fwlog,
4837 };
4838
4839 static void wl1271_connection_loss_work(struct work_struct *work)
4840 {
4841 struct delayed_work *dwork;
4842 struct wl1271 *wl;
4843 struct ieee80211_vif *vif;
4844 struct wl12xx_vif *wlvif;
4845
4846 dwork = container_of(work, struct delayed_work, work);
4847 wl = container_of(dwork, struct wl1271, connection_loss_work);
4848
4849 wl1271_info("Connection loss work.");
4850
4851 mutex_lock(&wl->mutex);
4852
4853 if (unlikely(wl->state == WL1271_STATE_OFF))
4854 goto out;
4855
4856 /* Call mac80211 connection loss */
4857 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4858 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
4859 goto out;
4860 vif = wl12xx_wlvif_to_vif(wlvif);
4861 ieee80211_connection_loss(vif);
4862 }
4863 out:
4864 mutex_unlock(&wl->mutex);
4865 }
4866
4867 static void wl12xx_derive_mac_addresses(struct wl1271 *wl,
4868 u32 oui, u32 nic, int n)
4869 {
4870 int i;
4871
4872 wl1271_debug(DEBUG_PROBE, "base address: oui %06x nic %06x, n %d",
4873 oui, nic, n);
4874
4875 if (nic + n - 1 > 0xffffff)
4876 wl1271_warning("NIC part of the MAC address wraps around!");
4877
4878 for (i = 0; i < n; i++) {
4879 wl->addresses[i].addr[0] = (u8)(oui >> 16);
4880 wl->addresses[i].addr[1] = (u8)(oui >> 8);
4881 wl->addresses[i].addr[2] = (u8) oui;
4882 wl->addresses[i].addr[3] = (u8)(nic >> 16);
4883 wl->addresses[i].addr[4] = (u8)(nic >> 8);
4884 wl->addresses[i].addr[5] = (u8) nic;
4885 nic++;
4886 }
4887
4888 wl->hw->wiphy->n_addresses = n;
4889 wl->hw->wiphy->addresses = wl->addresses;
4890 }
4891
4892 static int wl12xx_get_hw_info(struct wl1271 *wl)
4893 {
4894 int ret;
4895
4896 ret = wl12xx_set_power_on(wl);
4897 if (ret < 0)
4898 goto out;
4899
4900 wl->chip.id = wlcore_read_reg(wl, REG_CHIP_ID_B);
4901
4902 wl->fuse_oui_addr = 0;
4903 wl->fuse_nic_addr = 0;
4904
4905 wl->hw_pg_ver = wl->ops->get_pg_ver(wl);
4906
4907 if (wl->ops->get_mac)
4908 wl->ops->get_mac(wl);
4909
4910 wl1271_power_off(wl);
4911 out:
4912 return ret;
4913 }
4914
4915 static int wl1271_register_hw(struct wl1271 *wl)
4916 {
4917 int ret;
4918 u32 oui_addr = 0, nic_addr = 0;
4919
4920 if (wl->mac80211_registered)
4921 return 0;
4922
4923 ret = wl12xx_get_hw_info(wl);
4924 if (ret < 0) {
4925 wl1271_error("couldn't get hw info");
4926 goto out;
4927 }
4928
4929 ret = wl1271_fetch_nvs(wl);
4930 if (ret == 0) {
4931 /* NOTE: The wl->nvs->nvs element must be first, in
4932 * order to simplify the casting, we assume it is at
4933 * the beginning of the wl->nvs structure.
4934 */
4935 u8 *nvs_ptr = (u8 *)wl->nvs;
4936
4937 oui_addr =
4938 (nvs_ptr[11] << 16) + (nvs_ptr[10] << 8) + nvs_ptr[6];
4939 nic_addr =
4940 (nvs_ptr[5] << 16) + (nvs_ptr[4] << 8) + nvs_ptr[3];
4941 }
4942
4943 /* if the MAC address is zeroed in the NVS derive from fuse */
4944 if (oui_addr == 0 && nic_addr == 0) {
4945 oui_addr = wl->fuse_oui_addr;
4946 /* fuse has the BD_ADDR, the WLAN addresses are the next two */
4947 nic_addr = wl->fuse_nic_addr + 1;
4948 }
4949
4950 wl12xx_derive_mac_addresses(wl, oui_addr, nic_addr, 2);
4951
4952 ret = ieee80211_register_hw(wl->hw);
4953 if (ret < 0) {
4954 wl1271_error("unable to register mac80211 hw: %d", ret);
4955 goto out;
4956 }
4957
4958 wl->mac80211_registered = true;
4959
4960 wl1271_debugfs_init(wl);
4961
4962 wl1271_notice("loaded");
4963
4964 out:
4965 return ret;
4966 }
4967
4968 static void wl1271_unregister_hw(struct wl1271 *wl)
4969 {
4970 if (wl->plt)
4971 wl1271_plt_stop(wl);
4972
4973 ieee80211_unregister_hw(wl->hw);
4974 wl->mac80211_registered = false;
4975
4976 }
4977
4978 static int wl1271_init_ieee80211(struct wl1271 *wl)
4979 {
4980 static const u32 cipher_suites[] = {
4981 WLAN_CIPHER_SUITE_WEP40,
4982 WLAN_CIPHER_SUITE_WEP104,
4983 WLAN_CIPHER_SUITE_TKIP,
4984 WLAN_CIPHER_SUITE_CCMP,
4985 WL1271_CIPHER_SUITE_GEM,
4986 };
4987
4988 /* The tx descriptor buffer and the TKIP space. */
4989 wl->hw->extra_tx_headroom = WL1271_EXTRA_SPACE_TKIP +
4990 sizeof(struct wl1271_tx_hw_descr);
4991
4992 /* unit us */
4993 /* FIXME: find a proper value */
4994 wl->hw->channel_change_time = 10000;
4995 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
4996
4997 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4998 IEEE80211_HW_SUPPORTS_PS |
4999 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
5000 IEEE80211_HW_SUPPORTS_UAPSD |
5001 IEEE80211_HW_HAS_RATE_CONTROL |
5002 IEEE80211_HW_CONNECTION_MONITOR |
5003 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
5004 IEEE80211_HW_SPECTRUM_MGMT |
5005 IEEE80211_HW_AP_LINK_PS |
5006 IEEE80211_HW_AMPDU_AGGREGATION |
5007 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW |
5008 IEEE80211_HW_SCAN_WHILE_IDLE;
5009
5010 wl->hw->wiphy->cipher_suites = cipher_suites;
5011 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
5012
5013 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
5014 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP) |
5015 BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO);
5016 wl->hw->wiphy->max_scan_ssids = 1;
5017 wl->hw->wiphy->max_sched_scan_ssids = 16;
5018 wl->hw->wiphy->max_match_sets = 16;
5019 /*
5020 * Maximum length of elements in scanning probe request templates
5021 * should be the maximum length possible for a template, without
5022 * the IEEE80211 header of the template
5023 */
5024 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
5025 sizeof(struct ieee80211_header);
5026
5027 wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
5028 sizeof(struct ieee80211_header);
5029
5030 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD |
5031 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
5032
5033 /* make sure all our channels fit in the scanned_ch bitmask */
5034 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
5035 ARRAY_SIZE(wl1271_channels_5ghz) >
5036 WL1271_MAX_CHANNELS);
5037 /*
5038 * We keep local copies of the band structs because we need to
5039 * modify them on a per-device basis.
5040 */
5041 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
5042 sizeof(wl1271_band_2ghz));
5043 memcpy(&wl->bands[IEEE80211_BAND_2GHZ].ht_cap, &wl->ht_cap,
5044 sizeof(wl->ht_cap));
5045 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
5046 sizeof(wl1271_band_5ghz));
5047 memcpy(&wl->bands[IEEE80211_BAND_5GHZ].ht_cap, &wl->ht_cap,
5048 sizeof(wl->ht_cap));
5049
5050 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
5051 &wl->bands[IEEE80211_BAND_2GHZ];
5052 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
5053 &wl->bands[IEEE80211_BAND_5GHZ];
5054
5055 wl->hw->queues = 4;
5056 wl->hw->max_rates = 1;
5057
5058 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
5059
5060 /* the FW answers probe-requests in AP-mode */
5061 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
5062 wl->hw->wiphy->probe_resp_offload =
5063 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
5064 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
5065 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
5066
5067 SET_IEEE80211_DEV(wl->hw, wl->dev);
5068
5069 wl->hw->sta_data_size = sizeof(struct wl1271_station);
5070 wl->hw->vif_data_size = sizeof(struct wl12xx_vif);
5071
5072 wl->hw->max_rx_aggregation_subframes = wl->conf.ht.rx_ba_win_size;
5073
5074 return 0;
5075 }
5076
5077 #define WL1271_DEFAULT_CHANNEL 0
5078
5079 struct ieee80211_hw *wlcore_alloc_hw(size_t priv_size)
5080 {
5081 struct ieee80211_hw *hw;
5082 struct wl1271 *wl;
5083 int i, j, ret;
5084 unsigned int order;
5085
5086 BUILD_BUG_ON(AP_MAX_STATIONS > WL12XX_MAX_LINKS);
5087
5088 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
5089 if (!hw) {
5090 wl1271_error("could not alloc ieee80211_hw");
5091 ret = -ENOMEM;
5092 goto err_hw_alloc;
5093 }
5094
5095 wl = hw->priv;
5096 memset(wl, 0, sizeof(*wl));
5097
5098 wl->priv = kzalloc(priv_size, GFP_KERNEL);
5099 if (!wl->priv) {
5100 wl1271_error("could not alloc wl priv");
5101 ret = -ENOMEM;
5102 goto err_priv_alloc;
5103 }
5104
5105 INIT_LIST_HEAD(&wl->wlvif_list);
5106
5107 wl->hw = hw;
5108
5109 for (i = 0; i < NUM_TX_QUEUES; i++)
5110 for (j = 0; j < WL12XX_MAX_LINKS; j++)
5111 skb_queue_head_init(&wl->links[j].tx_queue[i]);
5112
5113 skb_queue_head_init(&wl->deferred_rx_queue);
5114 skb_queue_head_init(&wl->deferred_tx_queue);
5115
5116 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
5117 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
5118 INIT_WORK(&wl->tx_work, wl1271_tx_work);
5119 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
5120 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
5121 INIT_DELAYED_WORK(&wl->tx_watchdog_work, wl12xx_tx_watchdog_work);
5122 INIT_DELAYED_WORK(&wl->connection_loss_work,
5123 wl1271_connection_loss_work);
5124
5125 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
5126 if (!wl->freezable_wq) {
5127 ret = -ENOMEM;
5128 goto err_hw;
5129 }
5130
5131 wl->channel = WL1271_DEFAULT_CHANNEL;
5132 wl->rx_counter = 0;
5133 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
5134 wl->band = IEEE80211_BAND_2GHZ;
5135 wl->channel_type = NL80211_CHAN_NO_HT;
5136 wl->flags = 0;
5137 wl->sg_enabled = true;
5138 wl->hw_pg_ver = -1;
5139 wl->ap_ps_map = 0;
5140 wl->ap_fw_ps_map = 0;
5141 wl->quirks = 0;
5142 wl->platform_quirks = 0;
5143 wl->sched_scanning = false;
5144 wl->system_hlid = WL12XX_SYSTEM_HLID;
5145 wl->active_sta_count = 0;
5146 wl->fwlog_size = 0;
5147 init_waitqueue_head(&wl->fwlog_waitq);
5148
5149 /* The system link is always allocated */
5150 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
5151
5152 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
5153 for (i = 0; i < wl->num_tx_desc; i++)
5154 wl->tx_frames[i] = NULL;
5155
5156 spin_lock_init(&wl->wl_lock);
5157
5158 wl->state = WL1271_STATE_OFF;
5159 wl->fw_type = WL12XX_FW_TYPE_NONE;
5160 mutex_init(&wl->mutex);
5161
5162 order = get_order(WL1271_AGGR_BUFFER_SIZE);
5163 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
5164 if (!wl->aggr_buf) {
5165 ret = -ENOMEM;
5166 goto err_wq;
5167 }
5168
5169 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
5170 if (!wl->dummy_packet) {
5171 ret = -ENOMEM;
5172 goto err_aggr;
5173 }
5174
5175 /* Allocate one page for the FW log */
5176 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
5177 if (!wl->fwlog) {
5178 ret = -ENOMEM;
5179 goto err_dummy_packet;
5180 }
5181
5182 wl->mbox = kmalloc(sizeof(*wl->mbox), GFP_KERNEL | GFP_DMA);
5183 if (!wl->mbox) {
5184 ret = -ENOMEM;
5185 goto err_fwlog;
5186 }
5187
5188 return hw;
5189
5190 err_fwlog:
5191 free_page((unsigned long)wl->fwlog);
5192
5193 err_dummy_packet:
5194 dev_kfree_skb(wl->dummy_packet);
5195
5196 err_aggr:
5197 free_pages((unsigned long)wl->aggr_buf, order);
5198
5199 err_wq:
5200 destroy_workqueue(wl->freezable_wq);
5201
5202 err_hw:
5203 wl1271_debugfs_exit(wl);
5204 kfree(wl->priv);
5205
5206 err_priv_alloc:
5207 ieee80211_free_hw(hw);
5208
5209 err_hw_alloc:
5210
5211 return ERR_PTR(ret);
5212 }
5213 EXPORT_SYMBOL_GPL(wlcore_alloc_hw);
5214
5215 int wlcore_free_hw(struct wl1271 *wl)
5216 {
5217 /* Unblock any fwlog readers */
5218 mutex_lock(&wl->mutex);
5219 wl->fwlog_size = -1;
5220 wake_up_interruptible_all(&wl->fwlog_waitq);
5221 mutex_unlock(&wl->mutex);
5222
5223 device_remove_bin_file(wl->dev, &fwlog_attr);
5224
5225 device_remove_file(wl->dev, &dev_attr_hw_pg_ver);
5226
5227 device_remove_file(wl->dev, &dev_attr_bt_coex_state);
5228 free_page((unsigned long)wl->fwlog);
5229 dev_kfree_skb(wl->dummy_packet);
5230 free_pages((unsigned long)wl->aggr_buf,
5231 get_order(WL1271_AGGR_BUFFER_SIZE));
5232
5233 wl1271_debugfs_exit(wl);
5234
5235 vfree(wl->fw);
5236 wl->fw = NULL;
5237 wl->fw_type = WL12XX_FW_TYPE_NONE;
5238 kfree(wl->nvs);
5239 wl->nvs = NULL;
5240
5241 kfree(wl->fw_status);
5242 kfree(wl->tx_res_if);
5243 destroy_workqueue(wl->freezable_wq);
5244
5245 kfree(wl->priv);
5246 ieee80211_free_hw(wl->hw);
5247
5248 return 0;
5249 }
5250 EXPORT_SYMBOL_GPL(wlcore_free_hw);
5251
5252 static irqreturn_t wl12xx_hardirq(int irq, void *cookie)
5253 {
5254 struct wl1271 *wl = cookie;
5255 unsigned long flags;
5256
5257 wl1271_debug(DEBUG_IRQ, "IRQ");
5258
5259 /* complete the ELP completion */
5260 spin_lock_irqsave(&wl->wl_lock, flags);
5261 set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
5262 if (wl->elp_compl) {
5263 complete(wl->elp_compl);
5264 wl->elp_compl = NULL;
5265 }
5266
5267 if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {
5268 /* don't enqueue a work right now. mark it as pending */
5269 set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);
5270 wl1271_debug(DEBUG_IRQ, "should not enqueue work");
5271 disable_irq_nosync(wl->irq);
5272 pm_wakeup_event(wl->dev, 0);
5273 spin_unlock_irqrestore(&wl->wl_lock, flags);
5274 return IRQ_HANDLED;
5275 }
5276 spin_unlock_irqrestore(&wl->wl_lock, flags);
5277
5278 return IRQ_WAKE_THREAD;
5279 }
5280
5281 int __devinit wlcore_probe(struct wl1271 *wl, struct platform_device *pdev)
5282 {
5283 struct wl12xx_platform_data *pdata = pdev->dev.platform_data;
5284 unsigned long irqflags;
5285 int ret;
5286
5287 if (!wl->ops || !wl->ptable) {
5288 ret = -EINVAL;
5289 goto out_free_hw;
5290 }
5291
5292 BUG_ON(wl->num_tx_desc > WLCORE_MAX_TX_DESCRIPTORS);
5293
5294 /* adjust some runtime configuration parameters */
5295 wlcore_adjust_conf(wl);
5296
5297 wl->irq = platform_get_irq(pdev, 0);
5298 wl->ref_clock = pdata->board_ref_clock;
5299 wl->tcxo_clock = pdata->board_tcxo_clock;
5300 wl->platform_quirks = pdata->platform_quirks;
5301 wl->set_power = pdata->set_power;
5302 wl->dev = &pdev->dev;
5303 wl->if_ops = pdata->ops;
5304
5305 platform_set_drvdata(pdev, wl);
5306
5307 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
5308 irqflags = IRQF_TRIGGER_RISING;
5309 else
5310 irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;
5311
5312 ret = request_threaded_irq(wl->irq, wl12xx_hardirq, wl1271_irq,
5313 irqflags,
5314 pdev->name, wl);
5315 if (ret < 0) {
5316 wl1271_error("request_irq() failed: %d", ret);
5317 goto out_free_hw;
5318 }
5319
5320 ret = enable_irq_wake(wl->irq);
5321 if (!ret) {
5322 wl->irq_wake_enabled = true;
5323 device_init_wakeup(wl->dev, 1);
5324 if (pdata->pwr_in_suspend) {
5325 wl->hw->wiphy->wowlan.flags = WIPHY_WOWLAN_ANY;
5326 wl->hw->wiphy->wowlan.n_patterns =
5327 WL1271_MAX_RX_FILTERS;
5328 wl->hw->wiphy->wowlan.pattern_min_len = 1;
5329 wl->hw->wiphy->wowlan.pattern_max_len =
5330 WL1271_RX_FILTER_MAX_PATTERN_SIZE;
5331 }
5332 }
5333 disable_irq(wl->irq);
5334
5335 ret = wl1271_init_ieee80211(wl);
5336 if (ret)
5337 goto out_irq;
5338
5339 ret = wl1271_register_hw(wl);
5340 if (ret)
5341 goto out_irq;
5342
5343 /* Create sysfs file to control bt coex state */
5344 ret = device_create_file(wl->dev, &dev_attr_bt_coex_state);
5345 if (ret < 0) {
5346 wl1271_error("failed to create sysfs file bt_coex_state");
5347 goto out_irq;
5348 }
5349
5350 /* Create sysfs file to get HW PG version */
5351 ret = device_create_file(wl->dev, &dev_attr_hw_pg_ver);
5352 if (ret < 0) {
5353 wl1271_error("failed to create sysfs file hw_pg_ver");
5354 goto out_bt_coex_state;
5355 }
5356
5357 /* Create sysfs file for the FW log */
5358 ret = device_create_bin_file(wl->dev, &fwlog_attr);
5359 if (ret < 0) {
5360 wl1271_error("failed to create sysfs file fwlog");
5361 goto out_hw_pg_ver;
5362 }
5363
5364 goto out;
5365
5366 out_hw_pg_ver:
5367 device_remove_file(wl->dev, &dev_attr_hw_pg_ver);
5368
5369 out_bt_coex_state:
5370 device_remove_file(wl->dev, &dev_attr_bt_coex_state);
5371
5372 out_irq:
5373 free_irq(wl->irq, wl);
5374
5375 out_free_hw:
5376 wlcore_free_hw(wl);
5377
5378 out:
5379 return ret;
5380 }
5381 EXPORT_SYMBOL_GPL(wlcore_probe);
5382
5383 int __devexit wlcore_remove(struct platform_device *pdev)
5384 {
5385 struct wl1271 *wl = platform_get_drvdata(pdev);
5386
5387 if (wl->irq_wake_enabled) {
5388 device_init_wakeup(wl->dev, 0);
5389 disable_irq_wake(wl->irq);
5390 }
5391 wl1271_unregister_hw(wl);
5392 free_irq(wl->irq, wl);
5393 wlcore_free_hw(wl);
5394
5395 return 0;
5396 }
5397 EXPORT_SYMBOL_GPL(wlcore_remove);
5398
5399 u32 wl12xx_debug_level = DEBUG_NONE;
5400 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
5401 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
5402 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
5403
5404 module_param_named(fwlog, fwlog_param, charp, 0);
5405 MODULE_PARM_DESC(fwlog,
5406 "FW logger options: continuous, ondemand, dbgpins or disable");
5407
5408 module_param(bug_on_recovery, bool, S_IRUSR | S_IWUSR);
5409 MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
5410
5411 module_param(no_recovery, bool, S_IRUSR | S_IWUSR);
5412 MODULE_PARM_DESC(no_recovery, "Prevent HW recovery. FW will remain stuck.");
5413
5414 MODULE_LICENSE("GPL");
5415 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
5416 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux 2.6 libata-dev (mirror)