?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sfc: Don't use enums as a bitmask.
[zen-stable.git] / drivers / net / wireless / ath / carl9170 / main.c
blob7d5c65ea94e6213723ecb7a98f8222d6fa727daf
1 /*
2 * Atheros CARL9170 driver
3 *
4 * mac80211 interaction code
5 *
6 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
7 * Copyright 2009, 2010, Christian Lamparter <chunkeey@googlemail.com>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; see the file COPYING. If not, see
21 * http://www.gnu.org/licenses/.
22 *
23 * This file incorporates work covered by the following copyright and
24 * permission notice:
25 * Copyright (c) 2007-2008 Atheros Communications, Inc.
26 *
27 * Permission to use, copy, modify, and/or distribute this software for any
28 * purpose with or without fee is hereby granted, provided that the above
29 * copyright notice and this permission notice appear in all copies.
30 *
31 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
32 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
33 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
34 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
35 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
36 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
37 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
38 */
39
40 #include <linux/init.h>
41 #include <linux/slab.h>
42 #include <linux/module.h>
43 #include <linux/etherdevice.h>
44 #include <linux/random.h>
45 #include <net/mac80211.h>
46 #include <net/cfg80211.h>
47 #include "hw.h"
48 #include "carl9170.h"
49 #include "cmd.h"
50
51 static int modparam_nohwcrypt;
52 module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO);
53 MODULE_PARM_DESC(nohwcrypt, "Disable hardware crypto offload.");
54
55 int modparam_noht;
56 module_param_named(noht, modparam_noht, int, S_IRUGO);
57 MODULE_PARM_DESC(noht, "Disable MPDU aggregation.");
58
59 #define RATE(_bitrate, _hw_rate, _txpidx, _flags) { \
60 .bitrate = (_bitrate), \
61 .flags = (_flags), \
62 .hw_value = (_hw_rate) | (_txpidx) << 4, \
63 }
64
65 struct ieee80211_rate __carl9170_ratetable[] = {
66 RATE(10, 0, 0, 0),
67 RATE(20, 1, 1, IEEE80211_RATE_SHORT_PREAMBLE),
68 RATE(55, 2, 2, IEEE80211_RATE_SHORT_PREAMBLE),
69 RATE(110, 3, 3, IEEE80211_RATE_SHORT_PREAMBLE),
70 RATE(60, 0xb, 0, 0),
71 RATE(90, 0xf, 0, 0),
72 RATE(120, 0xa, 0, 0),
73 RATE(180, 0xe, 0, 0),
74 RATE(240, 0x9, 0, 0),
75 RATE(360, 0xd, 1, 0),
76 RATE(480, 0x8, 2, 0),
77 RATE(540, 0xc, 3, 0),
78 };
79 #undef RATE
80
81 #define carl9170_g_ratetable (__carl9170_ratetable + 0)
82 #define carl9170_g_ratetable_size 12
83 #define carl9170_a_ratetable (__carl9170_ratetable + 4)
84 #define carl9170_a_ratetable_size 8
85
86 /*
87 * NB: The hw_value is used as an index into the carl9170_phy_freq_params
88 * array in phy.c so that we don't have to do frequency lookups!
89 */
90 #define CHAN(_freq, _idx) { \
91 .center_freq = (_freq), \
92 .hw_value = (_idx), \
93 .max_power = 18, /* XXX */ \
94 }
95
96 static struct ieee80211_channel carl9170_2ghz_chantable[] = {
97 CHAN(2412, 0),
98 CHAN(2417, 1),
99 CHAN(2422, 2),
100 CHAN(2427, 3),
101 CHAN(2432, 4),
102 CHAN(2437, 5),
103 CHAN(2442, 6),
104 CHAN(2447, 7),
105 CHAN(2452, 8),
106 CHAN(2457, 9),
107 CHAN(2462, 10),
108 CHAN(2467, 11),
109 CHAN(2472, 12),
110 CHAN(2484, 13),
111 };
112
113 static struct ieee80211_channel carl9170_5ghz_chantable[] = {
114 CHAN(4920, 14),
115 CHAN(4940, 15),
116 CHAN(4960, 16),
117 CHAN(4980, 17),
118 CHAN(5040, 18),
119 CHAN(5060, 19),
120 CHAN(5080, 20),
121 CHAN(5180, 21),
122 CHAN(5200, 22),
123 CHAN(5220, 23),
124 CHAN(5240, 24),
125 CHAN(5260, 25),
126 CHAN(5280, 26),
127 CHAN(5300, 27),
128 CHAN(5320, 28),
129 CHAN(5500, 29),
130 CHAN(5520, 30),
131 CHAN(5540, 31),
132 CHAN(5560, 32),
133 CHAN(5580, 33),
134 CHAN(5600, 34),
135 CHAN(5620, 35),
136 CHAN(5640, 36),
137 CHAN(5660, 37),
138 CHAN(5680, 38),
139 CHAN(5700, 39),
140 CHAN(5745, 40),
141 CHAN(5765, 41),
142 CHAN(5785, 42),
143 CHAN(5805, 43),
144 CHAN(5825, 44),
145 CHAN(5170, 45),
146 CHAN(5190, 46),
147 CHAN(5210, 47),
148 CHAN(5230, 48),
149 };
150 #undef CHAN
151
152 #define CARL9170_HT_CAP \
153 { \
154 .ht_supported = true, \
155 .cap = IEEE80211_HT_CAP_MAX_AMSDU | \
156 IEEE80211_HT_CAP_SUP_WIDTH_20_40 | \
157 IEEE80211_HT_CAP_SGI_40 | \
158 IEEE80211_HT_CAP_DSSSCCK40 | \
159 IEEE80211_HT_CAP_SM_PS, \
160 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, \
161 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
162 .mcs = { \
163 .rx_mask = { 0xff, 0xff, 0, 0, 0x1, 0, 0, 0, 0, 0, }, \
164 .rx_highest = cpu_to_le16(300), \
165 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
166 }, \
167 }
168
169 static struct ieee80211_supported_band carl9170_band_2GHz = {
170 .channels = carl9170_2ghz_chantable,
171 .n_channels = ARRAY_SIZE(carl9170_2ghz_chantable),
172 .bitrates = carl9170_g_ratetable,
173 .n_bitrates = carl9170_g_ratetable_size,
174 .ht_cap = CARL9170_HT_CAP,
175 };
176
177 static struct ieee80211_supported_band carl9170_band_5GHz = {
178 .channels = carl9170_5ghz_chantable,
179 .n_channels = ARRAY_SIZE(carl9170_5ghz_chantable),
180 .bitrates = carl9170_a_ratetable,
181 .n_bitrates = carl9170_a_ratetable_size,
182 .ht_cap = CARL9170_HT_CAP,
183 };
184
185 static void carl9170_ampdu_gc(struct ar9170 *ar)
186 {
187 struct carl9170_sta_tid *tid_info;
188 LIST_HEAD(tid_gc);
189
190 rcu_read_lock();
191 list_for_each_entry_rcu(tid_info, &ar->tx_ampdu_list, list) {
192 spin_lock_bh(&ar->tx_ampdu_list_lock);
193 if (tid_info->state == CARL9170_TID_STATE_SHUTDOWN) {
194 tid_info->state = CARL9170_TID_STATE_KILLED;
195 list_del_rcu(&tid_info->list);
196 ar->tx_ampdu_list_len--;
197 list_add_tail(&tid_info->tmp_list, &tid_gc);
198 }
199 spin_unlock_bh(&ar->tx_ampdu_list_lock);
200
201 }
202 rcu_assign_pointer(ar->tx_ampdu_iter, tid_info);
203 rcu_read_unlock();
204
205 synchronize_rcu();
206
207 while (!list_empty(&tid_gc)) {
208 struct sk_buff *skb;
209 tid_info = list_first_entry(&tid_gc, struct carl9170_sta_tid,
210 tmp_list);
211
212 while ((skb = __skb_dequeue(&tid_info->queue)))
213 carl9170_tx_status(ar, skb, false);
214
215 list_del_init(&tid_info->tmp_list);
216 kfree(tid_info);
217 }
218 }
219
220 static void carl9170_flush(struct ar9170 *ar, bool drop_queued)
221 {
222 if (drop_queued) {
223 int i;
224
225 /*
226 * We can only drop frames which have not been uploaded
227 * to the device yet.
228 */
229
230 for (i = 0; i < ar->hw->queues; i++) {
231 struct sk_buff *skb;
232
233 while ((skb = skb_dequeue(&ar->tx_pending[i]))) {
234 struct ieee80211_tx_info *info;
235
236 info = IEEE80211_SKB_CB(skb);
237 if (info->flags & IEEE80211_TX_CTL_AMPDU)
238 atomic_dec(&ar->tx_ampdu_upload);
239
240 carl9170_tx_status(ar, skb, false);
241 }
242 }
243 }
244
245 /* Wait for all other outstanding frames to timeout. */
246 if (atomic_read(&ar->tx_total_queued))
247 WARN_ON(wait_for_completion_timeout(&ar->tx_flush, HZ) == 0);
248 }
249
250 static void carl9170_flush_ba(struct ar9170 *ar)
251 {
252 struct sk_buff_head free;
253 struct carl9170_sta_tid *tid_info;
254 struct sk_buff *skb;
255
256 __skb_queue_head_init(&free);
257
258 rcu_read_lock();
259 spin_lock_bh(&ar->tx_ampdu_list_lock);
260 list_for_each_entry_rcu(tid_info, &ar->tx_ampdu_list, list) {
261 if (tid_info->state > CARL9170_TID_STATE_SUSPEND) {
262 tid_info->state = CARL9170_TID_STATE_SUSPEND;
263
264 spin_lock(&tid_info->lock);
265 while ((skb = __skb_dequeue(&tid_info->queue)))
266 __skb_queue_tail(&free, skb);
267 spin_unlock(&tid_info->lock);
268 }
269 }
270 spin_unlock_bh(&ar->tx_ampdu_list_lock);
271 rcu_read_unlock();
272
273 while ((skb = __skb_dequeue(&free)))
274 carl9170_tx_status(ar, skb, false);
275 }
276
277 static void carl9170_zap_queues(struct ar9170 *ar)
278 {
279 struct carl9170_vif_info *cvif;
280 unsigned int i;
281
282 carl9170_ampdu_gc(ar);
283
284 carl9170_flush_ba(ar);
285 carl9170_flush(ar, true);
286
287 for (i = 0; i < ar->hw->queues; i++) {
288 spin_lock_bh(&ar->tx_status[i].lock);
289 while (!skb_queue_empty(&ar->tx_status[i])) {
290 struct sk_buff *skb;
291
292 skb = skb_peek(&ar->tx_status[i]);
293 carl9170_tx_get_skb(skb);
294 spin_unlock_bh(&ar->tx_status[i].lock);
295 carl9170_tx_drop(ar, skb);
296 spin_lock_bh(&ar->tx_status[i].lock);
297 carl9170_tx_put_skb(skb);
298 }
299 spin_unlock_bh(&ar->tx_status[i].lock);
300 }
301
302 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_SOFT < 1);
303 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_HARD < CARL9170_NUM_TX_LIMIT_SOFT);
304 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_HARD >= CARL9170_BAW_BITS);
305
306 /* reinitialize queues statistics */
307 memset(&ar->tx_stats, 0, sizeof(ar->tx_stats));
308 for (i = 0; i < ar->hw->queues; i++)
309 ar->tx_stats[i].limit = CARL9170_NUM_TX_LIMIT_HARD;
310
311 for (i = 0; i < DIV_ROUND_UP(ar->fw.mem_blocks, BITS_PER_LONG); i++)
312 ar->mem_bitmap[i] = 0;
313
314 rcu_read_lock();
315 list_for_each_entry_rcu(cvif, &ar->vif_list, list) {
316 spin_lock_bh(&ar->beacon_lock);
317 dev_kfree_skb_any(cvif->beacon);
318 cvif->beacon = NULL;
319 spin_unlock_bh(&ar->beacon_lock);
320 }
321 rcu_read_unlock();
322
323 atomic_set(&ar->tx_ampdu_upload, 0);
324 atomic_set(&ar->tx_ampdu_scheduler, 0);
325 atomic_set(&ar->tx_total_pending, 0);
326 atomic_set(&ar->tx_total_queued, 0);
327 atomic_set(&ar->mem_free_blocks, ar->fw.mem_blocks);
328 }
329
330 #define CARL9170_FILL_QUEUE(queue, ai_fs, cwmin, cwmax, _txop) \
331 do { \
332 queue.aifs = ai_fs; \
333 queue.cw_min = cwmin; \
334 queue.cw_max = cwmax; \
335 queue.txop = _txop; \
336 } while (0)
337
338 static int carl9170_op_start(struct ieee80211_hw *hw)
339 {
340 struct ar9170 *ar = hw->priv;
341 int err, i;
342
343 mutex_lock(&ar->mutex);
344
345 carl9170_zap_queues(ar);
346
347 /* reset QoS defaults */
348 CARL9170_FILL_QUEUE(ar->edcf[0], 3, 15, 1023, 0); /* BEST EFFORT */
349 CARL9170_FILL_QUEUE(ar->edcf[1], 2, 7, 15, 94); /* VIDEO */
350 CARL9170_FILL_QUEUE(ar->edcf[2], 2, 3, 7, 47); /* VOICE */
351 CARL9170_FILL_QUEUE(ar->edcf[3], 7, 15, 1023, 0); /* BACKGROUND */
352 CARL9170_FILL_QUEUE(ar->edcf[4], 2, 3, 7, 0); /* SPECIAL */
353
354 ar->current_factor = ar->current_density = -1;
355 /* "The first key is unique." */
356 ar->usedkeys = 1;
357 ar->filter_state = 0;
358 ar->ps.last_action = jiffies;
359 ar->ps.last_slept = jiffies;
360 ar->erp_mode = CARL9170_ERP_AUTO;
361 ar->rx_software_decryption = false;
362 ar->disable_offload = false;
363
364 for (i = 0; i < ar->hw->queues; i++) {
365 ar->queue_stop_timeout[i] = jiffies;
366 ar->max_queue_stop_timeout[i] = 0;
367 }
368
369 atomic_set(&ar->mem_allocs, 0);
370
371 err = carl9170_usb_open(ar);
372 if (err)
373 goto out;
374
375 err = carl9170_init_mac(ar);
376 if (err)
377 goto out;
378
379 err = carl9170_set_qos(ar);
380 if (err)
381 goto out;
382
383 if (ar->fw.rx_filter) {
384 err = carl9170_rx_filter(ar, CARL9170_RX_FILTER_OTHER_RA |
385 CARL9170_RX_FILTER_CTL_OTHER | CARL9170_RX_FILTER_BAD);
386 if (err)
387 goto out;
388 }
389
390 err = carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER,
391 AR9170_DMA_TRIGGER_RXQ);
392 if (err)
393 goto out;
394
395 /* Clear key-cache */
396 for (i = 0; i < AR9170_CAM_MAX_USER + 4; i++) {
397 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE,
398 0, NULL, 0);
399 if (err)
400 goto out;
401
402 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE,
403 1, NULL, 0);
404 if (err)
405 goto out;
406
407 if (i < AR9170_CAM_MAX_USER) {
408 err = carl9170_disable_key(ar, i);
409 if (err)
410 goto out;
411 }
412 }
413
414 carl9170_set_state_when(ar, CARL9170_IDLE, CARL9170_STARTED);
415
416 ieee80211_wake_queues(ar->hw);
417 err = 0;
418
419 out:
420 mutex_unlock(&ar->mutex);
421 return err;
422 }
423
424 static void carl9170_cancel_worker(struct ar9170 *ar)
425 {
426 cancel_delayed_work_sync(&ar->tx_janitor);
427 #ifdef CONFIG_CARL9170_LEDS
428 cancel_delayed_work_sync(&ar->led_work);
429 #endif /* CONFIG_CARL9170_LEDS */
430 cancel_work_sync(&ar->ps_work);
431 cancel_work_sync(&ar->ping_work);
432 cancel_work_sync(&ar->ampdu_work);
433 }
434
435 static void carl9170_op_stop(struct ieee80211_hw *hw)
436 {
437 struct ar9170 *ar = hw->priv;
438
439 carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
440
441 ieee80211_stop_queues(ar->hw);
442
443 mutex_lock(&ar->mutex);
444 if (IS_ACCEPTING_CMD(ar)) {
445 rcu_assign_pointer(ar->beacon_iter, NULL);
446
447 carl9170_led_set_state(ar, 0);
448
449 /* stop DMA */
450 carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER, 0);
451 carl9170_usb_stop(ar);
452 }
453
454 carl9170_zap_queues(ar);
455 mutex_unlock(&ar->mutex);
456
457 carl9170_cancel_worker(ar);
458 }
459
460 static void carl9170_restart_work(struct work_struct *work)
461 {
462 struct ar9170 *ar = container_of(work, struct ar9170,
463 restart_work);
464 int err;
465
466 ar->usedkeys = 0;
467 ar->filter_state = 0;
468 carl9170_cancel_worker(ar);
469
470 mutex_lock(&ar->mutex);
471 err = carl9170_usb_restart(ar);
472 if (net_ratelimit()) {
473 if (err) {
474 dev_err(&ar->udev->dev, "Failed to restart device "
475 " (%d).\n", err);
476 } else {
477 dev_info(&ar->udev->dev, "device restarted "
478 "successfully.\n");
479 }
480 }
481
482 carl9170_zap_queues(ar);
483 mutex_unlock(&ar->mutex);
484 if (!err) {
485 ar->restart_counter++;
486 atomic_set(&ar->pending_restarts, 0);
487
488 ieee80211_restart_hw(ar->hw);
489 } else {
490 /*
491 * The reset was unsuccessful and the device seems to
492 * be dead. But there's still one option: a low-level
493 * usb subsystem reset...
494 */
495
496 carl9170_usb_reset(ar);
497 }
498 }
499
500 void carl9170_restart(struct ar9170 *ar, const enum carl9170_restart_reasons r)
501 {
502 carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
503
504 /*
505 * Sometimes, an error can trigger several different reset events.
506 * By ignoring these *surplus* reset events, the device won't be
507 * killed again, right after it has recovered.
508 */
509 if (atomic_inc_return(&ar->pending_restarts) > 1) {
510 dev_dbg(&ar->udev->dev, "ignoring restart (%d)\n", r);
511 return;
512 }
513
514 ieee80211_stop_queues(ar->hw);
515
516 dev_err(&ar->udev->dev, "restart device (%d)\n", r);
517
518 if (!WARN_ON(r == CARL9170_RR_NO_REASON) ||
519 !WARN_ON(r >= __CARL9170_RR_LAST))
520 ar->last_reason = r;
521
522 if (!ar->registered)
523 return;
524
525 if (IS_ACCEPTING_CMD(ar) && !ar->needs_full_reset)
526 ieee80211_queue_work(ar->hw, &ar->restart_work);
527 else
528 carl9170_usb_reset(ar);
529
530 /*
531 * At this point, the device instance might have vanished/disabled.
532 * So, don't put any code which access the ar9170 struct
533 * without proper protection.
534 */
535 }
536
537 static void carl9170_ping_work(struct work_struct *work)
538 {
539 struct ar9170 *ar = container_of(work, struct ar9170, ping_work);
540 int err;
541
542 if (!IS_STARTED(ar))
543 return;
544
545 mutex_lock(&ar->mutex);
546 err = carl9170_echo_test(ar, 0xdeadbeef);
547 if (err)
548 carl9170_restart(ar, CARL9170_RR_UNRESPONSIVE_DEVICE);
549 mutex_unlock(&ar->mutex);
550 }
551
552 static int carl9170_init_interface(struct ar9170 *ar,
553 struct ieee80211_vif *vif)
554 {
555 struct ath_common *common = &ar->common;
556 int err;
557
558 if (!vif) {
559 WARN_ON_ONCE(IS_STARTED(ar));
560 return 0;
561 }
562
563 memcpy(common->macaddr, vif->addr, ETH_ALEN);
564
565 if (modparam_nohwcrypt ||
566 ((vif->type != NL80211_IFTYPE_STATION) &&
567 (vif->type != NL80211_IFTYPE_AP))) {
568 ar->rx_software_decryption = true;
569 ar->disable_offload = true;
570 }
571
572 err = carl9170_set_operating_mode(ar);
573 return err;
574 }
575
576 static int carl9170_op_add_interface(struct ieee80211_hw *hw,
577 struct ieee80211_vif *vif)
578 {
579 struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
580 struct ieee80211_vif *main_vif;
581 struct ar9170 *ar = hw->priv;
582 int vif_id = -1, err = 0;
583
584 mutex_lock(&ar->mutex);
585 rcu_read_lock();
586 if (vif_priv->active) {
587 /*
588 * Skip the interface structure initialization,
589 * if the vif survived the _restart call.
590 */
591 vif_id = vif_priv->id;
592 vif_priv->enable_beacon = false;
593
594 spin_lock_bh(&ar->beacon_lock);
595 dev_kfree_skb_any(vif_priv->beacon);
596 vif_priv->beacon = NULL;
597 spin_unlock_bh(&ar->beacon_lock);
598
599 goto init;
600 }
601
602 main_vif = carl9170_get_main_vif(ar);
603
604 if (main_vif) {
605 switch (main_vif->type) {
606 case NL80211_IFTYPE_STATION:
607 if (vif->type == NL80211_IFTYPE_STATION)
608 break;
609
610 err = -EBUSY;
611 rcu_read_unlock();
612
613 goto unlock;
614
615 case NL80211_IFTYPE_AP:
616 if ((vif->type == NL80211_IFTYPE_STATION) ||
617 (vif->type == NL80211_IFTYPE_WDS) ||
618 (vif->type == NL80211_IFTYPE_AP))
619 break;
620
621 err = -EBUSY;
622 rcu_read_unlock();
623 goto unlock;
624
625 default:
626 rcu_read_unlock();
627 goto unlock;
628 }
629 }
630
631 vif_id = bitmap_find_free_region(&ar->vif_bitmap, ar->fw.vif_num, 0);
632
633 if (vif_id < 0) {
634 rcu_read_unlock();
635
636 err = -ENOSPC;
637 goto unlock;
638 }
639
640 BUG_ON(ar->vif_priv[vif_id].id != vif_id);
641
642 vif_priv->active = true;
643 vif_priv->id = vif_id;
644 vif_priv->enable_beacon = false;
645 ar->vifs++;
646 list_add_tail_rcu(&vif_priv->list, &ar->vif_list);
647 rcu_assign_pointer(ar->vif_priv[vif_id].vif, vif);
648
649 init:
650 if (carl9170_get_main_vif(ar) == vif) {
651 rcu_assign_pointer(ar->beacon_iter, vif_priv);
652 rcu_read_unlock();
653
654 err = carl9170_init_interface(ar, vif);
655 if (err)
656 goto unlock;
657 } else {
658 rcu_read_unlock();
659 err = carl9170_mod_virtual_mac(ar, vif_id, vif->addr);
660
661 if (err)
662 goto unlock;
663 }
664
665 if (ar->fw.tx_seq_table) {
666 err = carl9170_write_reg(ar, ar->fw.tx_seq_table + vif_id * 4,
667 0);
668 if (err)
669 goto unlock;
670 }
671
672 unlock:
673 if (err && (vif_id >= 0)) {
674 vif_priv->active = false;
675 bitmap_release_region(&ar->vif_bitmap, vif_id, 0);
676 ar->vifs--;
677 rcu_assign_pointer(ar->vif_priv[vif_id].vif, NULL);
678 list_del_rcu(&vif_priv->list);
679 mutex_unlock(&ar->mutex);
680 synchronize_rcu();
681 } else {
682 if (ar->vifs > 1)
683 ar->ps.off_override |= PS_OFF_VIF;
684
685 mutex_unlock(&ar->mutex);
686 }
687
688 return err;
689 }
690
691 static void carl9170_op_remove_interface(struct ieee80211_hw *hw,
692 struct ieee80211_vif *vif)
693 {
694 struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
695 struct ieee80211_vif *main_vif;
696 struct ar9170 *ar = hw->priv;
697 unsigned int id;
698
699 mutex_lock(&ar->mutex);
700
701 if (WARN_ON_ONCE(!vif_priv->active))
702 goto unlock;
703
704 ar->vifs--;
705
706 rcu_read_lock();
707 main_vif = carl9170_get_main_vif(ar);
708
709 id = vif_priv->id;
710
711 vif_priv->active = false;
712 WARN_ON(vif_priv->enable_beacon);
713 vif_priv->enable_beacon = false;
714 list_del_rcu(&vif_priv->list);
715 rcu_assign_pointer(ar->vif_priv[id].vif, NULL);
716
717 if (vif == main_vif) {
718 rcu_read_unlock();
719
720 if (ar->vifs) {
721 WARN_ON(carl9170_init_interface(ar,
722 carl9170_get_main_vif(ar)));
723 } else {
724 carl9170_set_operating_mode(ar);
725 }
726 } else {
727 rcu_read_unlock();
728
729 WARN_ON(carl9170_mod_virtual_mac(ar, id, NULL));
730 }
731
732 carl9170_update_beacon(ar, false);
733 carl9170_flush_cab(ar, id);
734
735 spin_lock_bh(&ar->beacon_lock);
736 dev_kfree_skb_any(vif_priv->beacon);
737 vif_priv->beacon = NULL;
738 spin_unlock_bh(&ar->beacon_lock);
739
740 bitmap_release_region(&ar->vif_bitmap, id, 0);
741
742 carl9170_set_beacon_timers(ar);
743
744 if (ar->vifs == 1)
745 ar->ps.off_override &= ~PS_OFF_VIF;
746
747 unlock:
748 mutex_unlock(&ar->mutex);
749
750 synchronize_rcu();
751 }
752
753 void carl9170_ps_check(struct ar9170 *ar)
754 {
755 ieee80211_queue_work(ar->hw, &ar->ps_work);
756 }
757
758 /* caller must hold ar->mutex */
759 static int carl9170_ps_update(struct ar9170 *ar)
760 {
761 bool ps = false;
762 int err = 0;
763
764 if (!ar->ps.off_override)
765 ps = (ar->hw->conf.flags & IEEE80211_CONF_PS);
766
767 if (ps != ar->ps.state) {
768 err = carl9170_powersave(ar, ps);
769 if (err)
770 return err;
771
772 if (ar->ps.state && !ps) {
773 ar->ps.sleep_ms = jiffies_to_msecs(jiffies -
774 ar->ps.last_action);
775 }
776
777 if (ps)
778 ar->ps.last_slept = jiffies;
779
780 ar->ps.last_action = jiffies;
781 ar->ps.state = ps;
782 }
783
784 return 0;
785 }
786
787 static void carl9170_ps_work(struct work_struct *work)
788 {
789 struct ar9170 *ar = container_of(work, struct ar9170,
790 ps_work);
791 mutex_lock(&ar->mutex);
792 if (IS_STARTED(ar))
793 WARN_ON_ONCE(carl9170_ps_update(ar) != 0);
794 mutex_unlock(&ar->mutex);
795 }
796
797
798 static int carl9170_op_config(struct ieee80211_hw *hw, u32 changed)
799 {
800 struct ar9170 *ar = hw->priv;
801 int err = 0;
802
803 mutex_lock(&ar->mutex);
804 if (changed & IEEE80211_CONF_CHANGE_LISTEN_INTERVAL) {
805 /* TODO */
806 err = 0;
807 }
808
809 if (changed & IEEE80211_CONF_CHANGE_PS) {
810 err = carl9170_ps_update(ar);
811 if (err)
812 goto out;
813 }
814
815 if (changed & IEEE80211_CONF_CHANGE_POWER) {
816 /* TODO */
817 err = 0;
818 }
819
820 if (changed & IEEE80211_CONF_CHANGE_SMPS) {
821 /* TODO */
822 err = 0;
823 }
824
825 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
826 /* adjust slot time for 5 GHz */
827 err = carl9170_set_slot_time(ar);
828 if (err)
829 goto out;
830
831 err = carl9170_set_channel(ar, hw->conf.channel,
832 hw->conf.channel_type, CARL9170_RFI_NONE);
833 if (err)
834 goto out;
835
836 err = carl9170_set_dyn_sifs_ack(ar);
837 if (err)
838 goto out;
839
840 err = carl9170_set_rts_cts_rate(ar);
841 if (err)
842 goto out;
843 }
844
845 out:
846 mutex_unlock(&ar->mutex);
847 return err;
848 }
849
850 static u64 carl9170_op_prepare_multicast(struct ieee80211_hw *hw,
851 struct netdev_hw_addr_list *mc_list)
852 {
853 struct netdev_hw_addr *ha;
854 u64 mchash;
855
856 /* always get broadcast frames */
857 mchash = 1ULL << (0xff >> 2);
858
859 netdev_hw_addr_list_for_each(ha, mc_list)
860 mchash |= 1ULL << (ha->addr[5] >> 2);
861
862 return mchash;
863 }
864
865 static void carl9170_op_configure_filter(struct ieee80211_hw *hw,
866 unsigned int changed_flags,
867 unsigned int *new_flags,
868 u64 multicast)
869 {
870 struct ar9170 *ar = hw->priv;
871
872 /* mask supported flags */
873 *new_flags &= FIF_ALLMULTI | ar->rx_filter_caps;
874
875 if (!IS_ACCEPTING_CMD(ar))
876 return;
877
878 mutex_lock(&ar->mutex);
879
880 ar->filter_state = *new_flags;
881 /*
882 * We can support more by setting the sniffer bit and
883 * then checking the error flags, later.
884 */
885
886 if (*new_flags & FIF_ALLMULTI)
887 multicast = ~0ULL;
888
889 if (multicast != ar->cur_mc_hash)
890 WARN_ON(carl9170_update_multicast(ar, multicast));
891
892 if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) {
893 ar->sniffer_enabled = !!(*new_flags &
894 (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS));
895
896 WARN_ON(carl9170_set_operating_mode(ar));
897 }
898
899 if (ar->fw.rx_filter && changed_flags & ar->rx_filter_caps) {
900 u32 rx_filter = 0;
901
902 if (!(*new_flags & (FIF_FCSFAIL | FIF_PLCPFAIL)))
903 rx_filter |= CARL9170_RX_FILTER_BAD;
904
905 if (!(*new_flags & FIF_CONTROL))
906 rx_filter |= CARL9170_RX_FILTER_CTL_OTHER;
907
908 if (!(*new_flags & FIF_PSPOLL))
909 rx_filter |= CARL9170_RX_FILTER_CTL_PSPOLL;
910
911 if (!(*new_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))) {
912 rx_filter |= CARL9170_RX_FILTER_OTHER_RA;
913 rx_filter |= CARL9170_RX_FILTER_DECRY_FAIL;
914 }
915
916 WARN_ON(carl9170_rx_filter(ar, rx_filter));
917 }
918
919 mutex_unlock(&ar->mutex);
920 }
921
922
923 static void carl9170_op_bss_info_changed(struct ieee80211_hw *hw,
924 struct ieee80211_vif *vif,
925 struct ieee80211_bss_conf *bss_conf,
926 u32 changed)
927 {
928 struct ar9170 *ar = hw->priv;
929 struct ath_common *common = &ar->common;
930 int err = 0;
931 struct carl9170_vif_info *vif_priv;
932 struct ieee80211_vif *main_vif;
933
934 mutex_lock(&ar->mutex);
935 vif_priv = (void *) vif->drv_priv;
936 main_vif = carl9170_get_main_vif(ar);
937 if (WARN_ON(!main_vif))
938 goto out;
939
940 if (changed & BSS_CHANGED_BEACON_ENABLED) {
941 struct carl9170_vif_info *iter;
942 int i = 0;
943
944 vif_priv->enable_beacon = bss_conf->enable_beacon;
945 rcu_read_lock();
946 list_for_each_entry_rcu(iter, &ar->vif_list, list) {
947 if (iter->active && iter->enable_beacon)
948 i++;
949
950 }
951 rcu_read_unlock();
952
953 ar->beacon_enabled = i;
954 }
955
956 if (changed & BSS_CHANGED_BEACON) {
957 err = carl9170_update_beacon(ar, false);
958 if (err)
959 goto out;
960 }
961
962 if (changed & (BSS_CHANGED_BEACON_ENABLED | BSS_CHANGED_BEACON |
963 BSS_CHANGED_BEACON_INT)) {
964
965 if (main_vif != vif) {
966 bss_conf->beacon_int = main_vif->bss_conf.beacon_int;
967 bss_conf->dtim_period = main_vif->bss_conf.dtim_period;
968 }
969
970 /*
971 * Therefore a hard limit for the broadcast traffic should
972 * prevent false alarms.
973 */
974 if (vif->type != NL80211_IFTYPE_STATION &&
975 (bss_conf->beacon_int * bss_conf->dtim_period >=
976 (CARL9170_QUEUE_STUCK_TIMEOUT / 2))) {
977 err = -EINVAL;
978 goto out;
979 }
980
981 err = carl9170_set_beacon_timers(ar);
982 if (err)
983 goto out;
984 }
985
986 if (changed & BSS_CHANGED_HT) {
987 /* TODO */
988 err = 0;
989 if (err)
990 goto out;
991 }
992
993 if (main_vif != vif)
994 goto out;
995
996 /*
997 * The following settings can only be changed by the
998 * master interface.
999 */
1000
1001 if (changed & BSS_CHANGED_BSSID) {
1002 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1003 err = carl9170_set_operating_mode(ar);
1004 if (err)
1005 goto out;
1006 }
1007
1008 if (changed & BSS_CHANGED_ASSOC) {
1009 ar->common.curaid = bss_conf->aid;
1010 err = carl9170_set_beacon_timers(ar);
1011 if (err)
1012 goto out;
1013 }
1014
1015 if (changed & BSS_CHANGED_ERP_SLOT) {
1016 err = carl9170_set_slot_time(ar);
1017 if (err)
1018 goto out;
1019 }
1020
1021 if (changed & BSS_CHANGED_BASIC_RATES) {
1022 err = carl9170_set_mac_rates(ar);
1023 if (err)
1024 goto out;
1025 }
1026
1027 out:
1028 WARN_ON_ONCE(err && IS_STARTED(ar));
1029 mutex_unlock(&ar->mutex);
1030 }
1031
1032 static u64 carl9170_op_get_tsf(struct ieee80211_hw *hw)
1033 {
1034 struct ar9170 *ar = hw->priv;
1035 struct carl9170_tsf_rsp tsf;
1036 int err;
1037
1038 mutex_lock(&ar->mutex);
1039 err = carl9170_exec_cmd(ar, CARL9170_CMD_READ_TSF,
1040 0, NULL, sizeof(tsf), &tsf);
1041 mutex_unlock(&ar->mutex);
1042 if (WARN_ON(err))
1043 return 0;
1044
1045 return le64_to_cpu(tsf.tsf_64);
1046 }
1047
1048 static int carl9170_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1049 struct ieee80211_vif *vif,
1050 struct ieee80211_sta *sta,
1051 struct ieee80211_key_conf *key)
1052 {
1053 struct ar9170 *ar = hw->priv;
1054 int err = 0, i;
1055 u8 ktype;
1056
1057 if (ar->disable_offload || !vif)
1058 return -EOPNOTSUPP;
1059
1060 /*
1061 * We have to fall back to software encryption, whenever
1062 * the user choose to participates in an IBSS or is connected
1063 * to more than one network.
1064 *
1065 * This is very unfortunate, because some machines cannot handle
1066 * the high througput speed in 802.11n networks.
1067 */
1068
1069 if (!is_main_vif(ar, vif))
1070 goto err_softw;
1071
1072 /*
1073 * While the hardware supports *catch-all* key, for offloading
1074 * group-key en-/de-cryption. The way of how the hardware
1075 * decides which keyId maps to which key, remains a mystery...
1076 */
1077 if ((vif->type != NL80211_IFTYPE_STATION &&
1078 vif->type != NL80211_IFTYPE_ADHOC) &&
1079 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
1080 return -EOPNOTSUPP;
1081
1082 switch (key->cipher) {
1083 case WLAN_CIPHER_SUITE_WEP40:
1084 ktype = AR9170_ENC_ALG_WEP64;
1085 break;
1086 case WLAN_CIPHER_SUITE_WEP104:
1087 ktype = AR9170_ENC_ALG_WEP128;
1088 break;
1089 case WLAN_CIPHER_SUITE_TKIP:
1090 ktype = AR9170_ENC_ALG_TKIP;
1091 break;
1092 case WLAN_CIPHER_SUITE_CCMP:
1093 ktype = AR9170_ENC_ALG_AESCCMP;
1094 break;
1095 default:
1096 return -EOPNOTSUPP;
1097 }
1098
1099 mutex_lock(&ar->mutex);
1100 if (cmd == SET_KEY) {
1101 if (!IS_STARTED(ar)) {
1102 err = -EOPNOTSUPP;
1103 goto out;
1104 }
1105
1106 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1107 sta = NULL;
1108
1109 i = 64 + key->keyidx;
1110 } else {
1111 for (i = 0; i < 64; i++)
1112 if (!(ar->usedkeys & BIT(i)))
1113 break;
1114 if (i == 64)
1115 goto err_softw;
1116 }
1117
1118 key->hw_key_idx = i;
1119
1120 err = carl9170_upload_key(ar, i, sta ? sta->addr : NULL,
1121 ktype, 0, key->key,
1122 min_t(u8, 16, key->keylen));
1123 if (err)
1124 goto out;
1125
1126 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1127 err = carl9170_upload_key(ar, i, sta ? sta->addr :
1128 NULL, ktype, 1,
1129 key->key + 16, 16);
1130 if (err)
1131 goto out;
1132
1133 /*
1134 * hardware is not capable generating MMIC
1135 * of fragmented frames!
1136 */
1137 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1138 }
1139
1140 if (i < 64)
1141 ar->usedkeys |= BIT(i);
1142
1143 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1144 } else {
1145 if (!IS_STARTED(ar)) {
1146 /* The device is gone... together with the key ;-) */
1147 err = 0;
1148 goto out;
1149 }
1150
1151 if (key->hw_key_idx < 64) {
1152 ar->usedkeys &= ~BIT(key->hw_key_idx);
1153 } else {
1154 err = carl9170_upload_key(ar, key->hw_key_idx, NULL,
1155 AR9170_ENC_ALG_NONE, 0,
1156 NULL, 0);
1157 if (err)
1158 goto out;
1159
1160 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1161 err = carl9170_upload_key(ar, key->hw_key_idx,
1162 NULL,
1163 AR9170_ENC_ALG_NONE,
1164 1, NULL, 0);
1165 if (err)
1166 goto out;
1167 }
1168
1169 }
1170
1171 err = carl9170_disable_key(ar, key->hw_key_idx);
1172 if (err)
1173 goto out;
1174 }
1175
1176 out:
1177 mutex_unlock(&ar->mutex);
1178 return err;
1179
1180 err_softw:
1181 if (!ar->rx_software_decryption) {
1182 ar->rx_software_decryption = true;
1183 carl9170_set_operating_mode(ar);
1184 }
1185 mutex_unlock(&ar->mutex);
1186 return -ENOSPC;
1187 }
1188
1189 static int carl9170_op_sta_add(struct ieee80211_hw *hw,
1190 struct ieee80211_vif *vif,
1191 struct ieee80211_sta *sta)
1192 {
1193 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1194 unsigned int i;
1195
1196 atomic_set(&sta_info->pending_frames, 0);
1197
1198 if (sta->ht_cap.ht_supported) {
1199 if (sta->ht_cap.ampdu_density > 6) {
1200 /*
1201 * HW does support 16us AMPDU density.
1202 * No HT-Xmit for station.
1203 */
1204
1205 return 0;
1206 }
1207
1208 for (i = 0; i < CARL9170_NUM_TID; i++)
1209 rcu_assign_pointer(sta_info->agg[i], NULL);
1210
1211 sta_info->ampdu_max_len = 1 << (3 + sta->ht_cap.ampdu_factor);
1212 sta_info->ht_sta = true;
1213 }
1214
1215 return 0;
1216 }
1217
1218 static int carl9170_op_sta_remove(struct ieee80211_hw *hw,
1219 struct ieee80211_vif *vif,
1220 struct ieee80211_sta *sta)
1221 {
1222 struct ar9170 *ar = hw->priv;
1223 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1224 unsigned int i;
1225 bool cleanup = false;
1226
1227 if (sta->ht_cap.ht_supported) {
1228
1229 sta_info->ht_sta = false;
1230
1231 rcu_read_lock();
1232 for (i = 0; i < CARL9170_NUM_TID; i++) {
1233 struct carl9170_sta_tid *tid_info;
1234
1235 tid_info = rcu_dereference(sta_info->agg[i]);
1236 rcu_assign_pointer(sta_info->agg[i], NULL);
1237
1238 if (!tid_info)
1239 continue;
1240
1241 spin_lock_bh(&ar->tx_ampdu_list_lock);
1242 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1243 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1244 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1245 cleanup = true;
1246 }
1247 rcu_read_unlock();
1248
1249 if (cleanup)
1250 carl9170_ampdu_gc(ar);
1251 }
1252
1253 return 0;
1254 }
1255
1256 static int carl9170_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1257 const struct ieee80211_tx_queue_params *param)
1258 {
1259 struct ar9170 *ar = hw->priv;
1260 int ret;
1261
1262 mutex_lock(&ar->mutex);
1263 if (queue < ar->hw->queues) {
1264 memcpy(&ar->edcf[ar9170_qmap[queue]], param, sizeof(*param));
1265 ret = carl9170_set_qos(ar);
1266 } else {
1267 ret = -EINVAL;
1268 }
1269
1270 mutex_unlock(&ar->mutex);
1271 return ret;
1272 }
1273
1274 static void carl9170_ampdu_work(struct work_struct *work)
1275 {
1276 struct ar9170 *ar = container_of(work, struct ar9170,
1277 ampdu_work);
1278
1279 if (!IS_STARTED(ar))
1280 return;
1281
1282 mutex_lock(&ar->mutex);
1283 carl9170_ampdu_gc(ar);
1284 mutex_unlock(&ar->mutex);
1285 }
1286
1287 static int carl9170_op_ampdu_action(struct ieee80211_hw *hw,
1288 struct ieee80211_vif *vif,
1289 enum ieee80211_ampdu_mlme_action action,
1290 struct ieee80211_sta *sta,
1291 u16 tid, u16 *ssn, u8 buf_size)
1292 {
1293 struct ar9170 *ar = hw->priv;
1294 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1295 struct carl9170_sta_tid *tid_info;
1296
1297 if (modparam_noht)
1298 return -EOPNOTSUPP;
1299
1300 switch (action) {
1301 case IEEE80211_AMPDU_TX_START:
1302 if (!sta_info->ht_sta)
1303 return -EOPNOTSUPP;
1304
1305 rcu_read_lock();
1306 if (rcu_dereference(sta_info->agg[tid])) {
1307 rcu_read_unlock();
1308 return -EBUSY;
1309 }
1310
1311 tid_info = kzalloc(sizeof(struct carl9170_sta_tid),
1312 GFP_ATOMIC);
1313 if (!tid_info) {
1314 rcu_read_unlock();
1315 return -ENOMEM;
1316 }
1317
1318 tid_info->hsn = tid_info->bsn = tid_info->snx = (*ssn);
1319 tid_info->state = CARL9170_TID_STATE_PROGRESS;
1320 tid_info->tid = tid;
1321 tid_info->max = sta_info->ampdu_max_len;
1322
1323 INIT_LIST_HEAD(&tid_info->list);
1324 INIT_LIST_HEAD(&tid_info->tmp_list);
1325 skb_queue_head_init(&tid_info->queue);
1326 spin_lock_init(&tid_info->lock);
1327
1328 spin_lock_bh(&ar->tx_ampdu_list_lock);
1329 ar->tx_ampdu_list_len++;
1330 list_add_tail_rcu(&tid_info->list, &ar->tx_ampdu_list);
1331 rcu_assign_pointer(sta_info->agg[tid], tid_info);
1332 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1333 rcu_read_unlock();
1334
1335 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1336 break;
1337
1338 case IEEE80211_AMPDU_TX_STOP:
1339 rcu_read_lock();
1340 tid_info = rcu_dereference(sta_info->agg[tid]);
1341 if (tid_info) {
1342 spin_lock_bh(&ar->tx_ampdu_list_lock);
1343 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1344 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1345 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1346 }
1347
1348 rcu_assign_pointer(sta_info->agg[tid], NULL);
1349 rcu_read_unlock();
1350
1351 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1352 ieee80211_queue_work(ar->hw, &ar->ampdu_work);
1353 break;
1354
1355 case IEEE80211_AMPDU_TX_OPERATIONAL:
1356 rcu_read_lock();
1357 tid_info = rcu_dereference(sta_info->agg[tid]);
1358
1359 sta_info->stats[tid].clear = true;
1360 sta_info->stats[tid].req = false;
1361
1362 if (tid_info) {
1363 bitmap_zero(tid_info->bitmap, CARL9170_BAW_SIZE);
1364 tid_info->state = CARL9170_TID_STATE_IDLE;
1365 }
1366 rcu_read_unlock();
1367
1368 if (WARN_ON_ONCE(!tid_info))
1369 return -EFAULT;
1370
1371 break;
1372
1373 case IEEE80211_AMPDU_RX_START:
1374 case IEEE80211_AMPDU_RX_STOP:
1375 /* Handled by hardware */
1376 break;
1377
1378 default:
1379 return -EOPNOTSUPP;
1380 }
1381
1382 return 0;
1383 }
1384
1385 #ifdef CONFIG_CARL9170_WPC
1386 static int carl9170_register_wps_button(struct ar9170 *ar)
1387 {
1388 struct input_dev *input;
1389 int err;
1390
1391 if (!(ar->features & CARL9170_WPS_BUTTON))
1392 return 0;
1393
1394 input = input_allocate_device();
1395 if (!input)
1396 return -ENOMEM;
1397
1398 snprintf(ar->wps.name, sizeof(ar->wps.name), "%s WPS Button",
1399 wiphy_name(ar->hw->wiphy));
1400
1401 snprintf(ar->wps.phys, sizeof(ar->wps.phys),
1402 "ieee80211/%s/input0", wiphy_name(ar->hw->wiphy));
1403
1404 input->name = ar->wps.name;
1405 input->phys = ar->wps.phys;
1406 input->id.bustype = BUS_USB;
1407 input->dev.parent = &ar->hw->wiphy->dev;
1408
1409 input_set_capability(input, EV_KEY, KEY_WPS_BUTTON);
1410
1411 err = input_register_device(input);
1412 if (err) {
1413 input_free_device(input);
1414 return err;
1415 }
1416
1417 ar->wps.pbc = input;
1418 return 0;
1419 }
1420 #endif /* CONFIG_CARL9170_WPC */
1421
1422 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx,
1423 struct survey_info *survey)
1424 {
1425 struct ar9170 *ar = hw->priv;
1426 int err;
1427
1428 if (idx != 0)
1429 return -ENOENT;
1430
1431 mutex_lock(&ar->mutex);
1432 err = carl9170_get_noisefloor(ar);
1433 mutex_unlock(&ar->mutex);
1434 if (err)
1435 return err;
1436
1437 survey->channel = ar->channel;
1438 survey->filled = SURVEY_INFO_NOISE_DBM;
1439 survey->noise = ar->noise[0];
1440 return 0;
1441 }
1442
1443 static void carl9170_op_flush(struct ieee80211_hw *hw, bool drop)
1444 {
1445 struct ar9170 *ar = hw->priv;
1446 unsigned int vid;
1447
1448 mutex_lock(&ar->mutex);
1449 for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num)
1450 carl9170_flush_cab(ar, vid);
1451
1452 carl9170_flush(ar, drop);
1453 mutex_unlock(&ar->mutex);
1454 }
1455
1456 static int carl9170_op_get_stats(struct ieee80211_hw *hw,
1457 struct ieee80211_low_level_stats *stats)
1458 {
1459 struct ar9170 *ar = hw->priv;
1460
1461 memset(stats, 0, sizeof(*stats));
1462 stats->dot11ACKFailureCount = ar->tx_ack_failures;
1463 stats->dot11FCSErrorCount = ar->tx_fcs_errors;
1464 return 0;
1465 }
1466
1467 static void carl9170_op_sta_notify(struct ieee80211_hw *hw,
1468 struct ieee80211_vif *vif,
1469 enum sta_notify_cmd cmd,
1470 struct ieee80211_sta *sta)
1471 {
1472 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1473
1474 switch (cmd) {
1475 case STA_NOTIFY_SLEEP:
1476 sta_info->sleeping = true;
1477 if (atomic_read(&sta_info->pending_frames))
1478 ieee80211_sta_block_awake(hw, sta, true);
1479 break;
1480
1481 case STA_NOTIFY_AWAKE:
1482 sta_info->sleeping = false;
1483 break;
1484 }
1485 }
1486
1487 static const struct ieee80211_ops carl9170_ops = {
1488 .start = carl9170_op_start,
1489 .stop = carl9170_op_stop,
1490 .tx = carl9170_op_tx,
1491 .flush = carl9170_op_flush,
1492 .add_interface = carl9170_op_add_interface,
1493 .remove_interface = carl9170_op_remove_interface,
1494 .config = carl9170_op_config,
1495 .prepare_multicast = carl9170_op_prepare_multicast,
1496 .configure_filter = carl9170_op_configure_filter,
1497 .conf_tx = carl9170_op_conf_tx,
1498 .bss_info_changed = carl9170_op_bss_info_changed,
1499 .get_tsf = carl9170_op_get_tsf,
1500 .set_key = carl9170_op_set_key,
1501 .sta_add = carl9170_op_sta_add,
1502 .sta_remove = carl9170_op_sta_remove,
1503 .sta_notify = carl9170_op_sta_notify,
1504 .get_survey = carl9170_op_get_survey,
1505 .get_stats = carl9170_op_get_stats,
1506 .ampdu_action = carl9170_op_ampdu_action,
1507 };
1508
1509 void *carl9170_alloc(size_t priv_size)
1510 {
1511 struct ieee80211_hw *hw;
1512 struct ar9170 *ar;
1513 struct sk_buff *skb;
1514 int i;
1515
1516 /*
1517 * this buffer is used for rx stream reconstruction.
1518 * Under heavy load this device (or the transport layer?)
1519 * tends to split the streams into separate rx descriptors.
1520 */
1521
1522 skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL);
1523 if (!skb)
1524 goto err_nomem;
1525
1526 hw = ieee80211_alloc_hw(priv_size, &carl9170_ops);
1527 if (!hw)
1528 goto err_nomem;
1529
1530 ar = hw->priv;
1531 ar->hw = hw;
1532 ar->rx_failover = skb;
1533
1534 memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head));
1535 ar->rx_has_plcp = false;
1536
1537 /*
1538 * Here's a hidden pitfall!
1539 *
1540 * All 4 AC queues work perfectly well under _legacy_ operation.
1541 * However as soon as aggregation is enabled, the traffic flow
1542 * gets very bumpy. Therefore we have to _switch_ to a
1543 * software AC with a single HW queue.
1544 */
1545 hw->queues = __AR9170_NUM_TXQ;
1546
1547 mutex_init(&ar->mutex);
1548 spin_lock_init(&ar->beacon_lock);
1549 spin_lock_init(&ar->cmd_lock);
1550 spin_lock_init(&ar->tx_stats_lock);
1551 spin_lock_init(&ar->tx_ampdu_list_lock);
1552 spin_lock_init(&ar->mem_lock);
1553 spin_lock_init(&ar->state_lock);
1554 atomic_set(&ar->pending_restarts, 0);
1555 ar->vifs = 0;
1556 for (i = 0; i < ar->hw->queues; i++) {
1557 skb_queue_head_init(&ar->tx_status[i]);
1558 skb_queue_head_init(&ar->tx_pending[i]);
1559 }
1560 INIT_WORK(&ar->ps_work, carl9170_ps_work);
1561 INIT_WORK(&ar->ping_work, carl9170_ping_work);
1562 INIT_WORK(&ar->restart_work, carl9170_restart_work);
1563 INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work);
1564 INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor);
1565 INIT_LIST_HEAD(&ar->tx_ampdu_list);
1566 rcu_assign_pointer(ar->tx_ampdu_iter,
1567 (struct carl9170_sta_tid *) &ar->tx_ampdu_list);
1568
1569 bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num);
1570 INIT_LIST_HEAD(&ar->vif_list);
1571 init_completion(&ar->tx_flush);
1572
1573 /*
1574 * Note:
1575 * IBSS/ADHOC and AP mode are only enabled, if the firmware
1576 * supports these modes. The code which will add the
1577 * additional interface_modes is in fw.c.
1578 */
1579 hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1580 BIT(NL80211_IFTYPE_P2P_CLIENT);
1581
1582 hw->flags |= IEEE80211_HW_RX_INCLUDES_FCS |
1583 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
1584 IEEE80211_HW_SUPPORTS_PS |
1585 IEEE80211_HW_PS_NULLFUNC_STACK |
1586 IEEE80211_HW_SIGNAL_DBM;
1587
1588 if (!modparam_noht) {
1589 /*
1590 * see the comment above, why we allow the user
1591 * to disable HT by a module parameter.
1592 */
1593 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
1594 }
1595
1596 hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe);
1597 hw->sta_data_size = sizeof(struct carl9170_sta_info);
1598 hw->vif_data_size = sizeof(struct carl9170_vif_info);
1599
1600 hw->max_rates = CARL9170_TX_MAX_RATES;
1601 hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES;
1602
1603 for (i = 0; i < ARRAY_SIZE(ar->noise); i++)
1604 ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */
1605
1606 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
1607 return ar;
1608
1609 err_nomem:
1610 kfree_skb(skb);
1611 return ERR_PTR(-ENOMEM);
1612 }
1613
1614 static int carl9170_read_eeprom(struct ar9170 *ar)
1615 {
1616 #define RW 8 /* number of words to read at once */
1617 #define RB (sizeof(u32) * RW)
1618 u8 *eeprom = (void *)&ar->eeprom;
1619 __le32 offsets[RW];
1620 int i, j, err;
1621
1622 BUILD_BUG_ON(sizeof(ar->eeprom) & 3);
1623
1624 BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4);
1625 #ifndef __CHECKER__
1626 /* don't want to handle trailing remains */
1627 BUILD_BUG_ON(sizeof(ar->eeprom) % RB);
1628 #endif
1629
1630 for (i = 0; i < sizeof(ar->eeprom)/RB; i++) {
1631 for (j = 0; j < RW; j++)
1632 offsets[j] = cpu_to_le32(AR9170_EEPROM_START +
1633 RB * i + 4 * j);
1634
1635 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1636 RB, (u8 *) &offsets,
1637 RB, eeprom + RB * i);
1638 if (err)
1639 return err;
1640 }
1641
1642 #undef RW
1643 #undef RB
1644 return 0;
1645 }
1646
1647 static int carl9170_parse_eeprom(struct ar9170 *ar)
1648 {
1649 struct ath_regulatory *regulatory = &ar->common.regulatory;
1650 unsigned int rx_streams, tx_streams, tx_params = 0;
1651 int bands = 0;
1652
1653 if (ar->eeprom.length == cpu_to_le16(0xffff))
1654 return -ENODATA;
1655
1656 rx_streams = hweight8(ar->eeprom.rx_mask);
1657 tx_streams = hweight8(ar->eeprom.tx_mask);
1658
1659 if (rx_streams != tx_streams) {
1660 tx_params = IEEE80211_HT_MCS_TX_RX_DIFF;
1661
1662 WARN_ON(!(tx_streams >= 1 && tx_streams <=
1663 IEEE80211_HT_MCS_TX_MAX_STREAMS));
1664
1665 tx_params = (tx_streams - 1) <<
1666 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
1667
1668 carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params;
1669 carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params;
1670 }
1671
1672 if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) {
1673 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
1674 &carl9170_band_2GHz;
1675 bands++;
1676 }
1677 if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) {
1678 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
1679 &carl9170_band_5GHz;
1680 bands++;
1681 }
1682
1683 /*
1684 * I measured this, a bandswitch takes roughly
1685 * 135 ms and a frequency switch about 80.
1686 *
1687 * FIXME: measure these values again once EEPROM settings
1688 * are used, that will influence them!
1689 */
1690 if (bands == 2)
1691 ar->hw->channel_change_time = 135 * 1000;
1692 else
1693 ar->hw->channel_change_time = 80 * 1000;
1694
1695 regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]);
1696 regulatory->current_rd_ext = le16_to_cpu(ar->eeprom.reg_domain[1]);
1697
1698 /* second part of wiphy init */
1699 SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address);
1700
1701 return bands ? 0 : -EINVAL;
1702 }
1703
1704 static int carl9170_reg_notifier(struct wiphy *wiphy,
1705 struct regulatory_request *request)
1706 {
1707 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1708 struct ar9170 *ar = hw->priv;
1709
1710 return ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory);
1711 }
1712
1713 int carl9170_register(struct ar9170 *ar)
1714 {
1715 struct ath_regulatory *regulatory = &ar->common.regulatory;
1716 int err = 0, i;
1717
1718 if (WARN_ON(ar->mem_bitmap))
1719 return -EINVAL;
1720
1721 ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) *
1722 sizeof(unsigned long), GFP_KERNEL);
1723
1724 if (!ar->mem_bitmap)
1725 return -ENOMEM;
1726
1727 /* try to read EEPROM, init MAC addr */
1728 err = carl9170_read_eeprom(ar);
1729 if (err)
1730 return err;
1731
1732 err = carl9170_fw_fix_eeprom(ar);
1733 if (err)
1734 return err;
1735
1736 err = carl9170_parse_eeprom(ar);
1737 if (err)
1738 return err;
1739
1740 err = ath_regd_init(regulatory, ar->hw->wiphy,
1741 carl9170_reg_notifier);
1742 if (err)
1743 return err;
1744
1745 if (modparam_noht) {
1746 carl9170_band_2GHz.ht_cap.ht_supported = false;
1747 carl9170_band_5GHz.ht_cap.ht_supported = false;
1748 }
1749
1750 for (i = 0; i < ar->fw.vif_num; i++) {
1751 ar->vif_priv[i].id = i;
1752 ar->vif_priv[i].vif = NULL;
1753 }
1754
1755 err = ieee80211_register_hw(ar->hw);
1756 if (err)
1757 return err;
1758
1759 /* mac80211 interface is now registered */
1760 ar->registered = true;
1761
1762 if (!ath_is_world_regd(regulatory))
1763 regulatory_hint(ar->hw->wiphy, regulatory->alpha2);
1764
1765 #ifdef CONFIG_CARL9170_DEBUGFS
1766 carl9170_debugfs_register(ar);
1767 #endif /* CONFIG_CARL9170_DEBUGFS */
1768
1769 err = carl9170_led_init(ar);
1770 if (err)
1771 goto err_unreg;
1772
1773 #ifdef CONFIG_CARL9170_LEDS
1774 err = carl9170_led_register(ar);
1775 if (err)
1776 goto err_unreg;
1777 #endif /* CONFIG_CARL9170_LEDS */
1778
1779 #ifdef CONFIG_CARL9170_WPC
1780 err = carl9170_register_wps_button(ar);
1781 if (err)
1782 goto err_unreg;
1783 #endif /* CONFIG_CARL9170_WPC */
1784
1785 dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n",
1786 wiphy_name(ar->hw->wiphy));
1787
1788 return 0;
1789
1790 err_unreg:
1791 carl9170_unregister(ar);
1792 return err;
1793 }
1794
1795 void carl9170_unregister(struct ar9170 *ar)
1796 {
1797 if (!ar->registered)
1798 return;
1799
1800 ar->registered = false;
1801
1802 #ifdef CONFIG_CARL9170_LEDS
1803 carl9170_led_unregister(ar);
1804 #endif /* CONFIG_CARL9170_LEDS */
1805
1806 #ifdef CONFIG_CARL9170_DEBUGFS
1807 carl9170_debugfs_unregister(ar);
1808 #endif /* CONFIG_CARL9170_DEBUGFS */
1809
1810 #ifdef CONFIG_CARL9170_WPC
1811 if (ar->wps.pbc) {
1812 input_unregister_device(ar->wps.pbc);
1813 ar->wps.pbc = NULL;
1814 }
1815 #endif /* CONFIG_CARL9170_WPC */
1816
1817 carl9170_cancel_worker(ar);
1818 cancel_work_sync(&ar->restart_work);
1819
1820 ieee80211_unregister_hw(ar->hw);
1821 }
1822
1823 void carl9170_free(struct ar9170 *ar)
1824 {
1825 WARN_ON(ar->registered);
1826 WARN_ON(IS_INITIALIZED(ar));
1827
1828 kfree_skb(ar->rx_failover);
1829 ar->rx_failover = NULL;
1830
1831 kfree(ar->mem_bitmap);
1832 ar->mem_bitmap = NULL;
1833
1834 mutex_destroy(&ar->mutex);
1835
1836 ieee80211_free_hw(ar->hw);
1837 }