1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/slab.h>
30#include <linux/log2.h>
31
32#include "rt2x00.h"
33#include "rt2x00lib.h"
34
35
36
37
38u32 rt2x00lib_get_bssidx(struct rt2x00_dev *rt2x00dev,
39 struct ieee80211_vif *vif)
40{
41
42
43
44
45 if (rt2x00dev->intf_sta_count)
46 return 0;
47 return vif->addr[5] & (rt2x00dev->ops->max_ap_intf - 1);
48}
49EXPORT_SYMBOL_GPL(rt2x00lib_get_bssidx);
50
51
52
53
54int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev)
55{
56 int status;
57
58
59
60
61
62 if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
63 return 0;
64
65
66
67
68 rt2x00queue_init_queues(rt2x00dev);
69
70
71
72
73 status =
74 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_ON);
75 if (status)
76 return status;
77
78 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_ON);
79
80 rt2x00leds_led_radio(rt2x00dev, true);
81 rt2x00led_led_activity(rt2x00dev, true);
82
83 set_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags);
84
85
86
87
88 rt2x00queue_start_queues(rt2x00dev);
89 rt2x00link_start_tuner(rt2x00dev);
90 rt2x00link_start_agc(rt2x00dev);
91 if (test_bit(CAPABILITY_VCO_RECALIBRATION, &rt2x00dev->cap_flags))
92 rt2x00link_start_vcocal(rt2x00dev);
93
94
95
96
97 rt2x00link_start_watchdog(rt2x00dev);
98
99 return 0;
100}
101
102void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
103{
104 if (!test_and_clear_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
105 return;
106
107
108
109
110 rt2x00link_stop_watchdog(rt2x00dev);
111
112
113
114
115 rt2x00link_stop_agc(rt2x00dev);
116 if (test_bit(CAPABILITY_VCO_RECALIBRATION, &rt2x00dev->cap_flags))
117 rt2x00link_stop_vcocal(rt2x00dev);
118 rt2x00link_stop_tuner(rt2x00dev);
119 rt2x00queue_stop_queues(rt2x00dev);
120 rt2x00queue_flush_queues(rt2x00dev, true);
121
122
123
124
125 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
126 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_OFF);
127 rt2x00led_led_activity(rt2x00dev, false);
128 rt2x00leds_led_radio(rt2x00dev, false);
129}
130
131static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
132 struct ieee80211_vif *vif)
133{
134 struct rt2x00_dev *rt2x00dev = data;
135 struct rt2x00_intf *intf = vif_to_intf(vif);
136
137
138
139
140
141
142
143 if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
144 return;
145
146 if (test_and_clear_bit(DELAYED_UPDATE_BEACON, &intf->delayed_flags))
147 rt2x00queue_update_beacon(rt2x00dev, vif);
148}
149
150static void rt2x00lib_intf_scheduled(struct work_struct *work)
151{
152 struct rt2x00_dev *rt2x00dev =
153 container_of(work, struct rt2x00_dev, intf_work);
154
155
156
157
158
159 ieee80211_iterate_active_interfaces(rt2x00dev->hw,
160 IEEE80211_IFACE_ITER_RESUME_ALL,
161 rt2x00lib_intf_scheduled_iter,
162 rt2x00dev);
163}
164
165static void rt2x00lib_autowakeup(struct work_struct *work)
166{
167 struct rt2x00_dev *rt2x00dev =
168 container_of(work, struct rt2x00_dev, autowakeup_work.work);
169
170 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
171 return;
172
173 if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_AWAKE))
174 rt2x00_err(rt2x00dev, "Device failed to wakeup\n");
175 clear_bit(CONFIG_POWERSAVING, &rt2x00dev->flags);
176}
177
178
179
180
181static void rt2x00lib_bc_buffer_iter(void *data, u8 *mac,
182 struct ieee80211_vif *vif)
183{
184 struct rt2x00_dev *rt2x00dev = data;
185 struct sk_buff *skb;
186
187
188
189
190 if (vif->type != NL80211_IFTYPE_AP)
191 return;
192
193
194
195
196 skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
197 while (skb) {
198 rt2x00mac_tx(rt2x00dev->hw, NULL, skb);
199 skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
200 }
201}
202
203static void rt2x00lib_beaconupdate_iter(void *data, u8 *mac,
204 struct ieee80211_vif *vif)
205{
206 struct rt2x00_dev *rt2x00dev = data;
207
208 if (vif->type != NL80211_IFTYPE_AP &&
209 vif->type != NL80211_IFTYPE_ADHOC &&
210 vif->type != NL80211_IFTYPE_MESH_POINT &&
211 vif->type != NL80211_IFTYPE_WDS)
212 return;
213
214
215
216
217
218
219 WARN_ON(rt2x00_is_usb(rt2x00dev));
220 rt2x00queue_update_beacon_locked(rt2x00dev, vif);
221}
222
223void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
224{
225 if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
226 return;
227
228
229 ieee80211_iterate_active_interfaces_atomic(
230 rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
231 rt2x00lib_bc_buffer_iter, rt2x00dev);
232
233
234
235
236
237 if (test_bit(CAPABILITY_PRE_TBTT_INTERRUPT, &rt2x00dev->cap_flags))
238 return;
239
240
241 ieee80211_iterate_active_interfaces_atomic(
242 rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
243 rt2x00lib_beaconupdate_iter, rt2x00dev);
244}
245EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);
246
247void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev)
248{
249 if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
250 return;
251
252
253 ieee80211_iterate_active_interfaces_atomic(
254 rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
255 rt2x00lib_beaconupdate_iter, rt2x00dev);
256}
257EXPORT_SYMBOL_GPL(rt2x00lib_pretbtt);
258
259void rt2x00lib_dmastart(struct queue_entry *entry)
260{
261 set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
262 rt2x00queue_index_inc(entry, Q_INDEX);
263}
264EXPORT_SYMBOL_GPL(rt2x00lib_dmastart);
265
266void rt2x00lib_dmadone(struct queue_entry *entry)
267{
268 set_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags);
269 clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
270 rt2x00queue_index_inc(entry, Q_INDEX_DMA_DONE);
271}
272EXPORT_SYMBOL_GPL(rt2x00lib_dmadone);
273
274static inline int rt2x00lib_txdone_bar_status(struct queue_entry *entry)
275{
276 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
277 struct ieee80211_bar *bar = (void *) entry->skb->data;
278 struct rt2x00_bar_list_entry *bar_entry;
279 int ret;
280
281 if (likely(!ieee80211_is_back_req(bar->frame_control)))
282 return 0;
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297 ret = 0;
298 rcu_read_lock();
299 list_for_each_entry_rcu(bar_entry, &rt2x00dev->bar_list, list) {
300 if (bar_entry->entry != entry)
301 continue;
302
303 spin_lock_bh(&rt2x00dev->bar_list_lock);
304
305 ret = bar_entry->block_acked;
306
307 list_del_rcu(&bar_entry->list);
308 spin_unlock_bh(&rt2x00dev->bar_list_lock);
309 kfree_rcu(bar_entry, head);
310
311 break;
312 }
313 rcu_read_unlock();
314
315 return ret;
316}
317
318void rt2x00lib_txdone(struct queue_entry *entry,
319 struct txdone_entry_desc *txdesc)
320{
321 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
322 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
323 struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
324 unsigned int header_length, i;
325 u8 rate_idx, rate_flags, retry_rates;
326 u8 skbdesc_flags = skbdesc->flags;
327 bool success;
328
329
330
331
332 rt2x00queue_unmap_skb(entry);
333
334
335
336
337 skb_pull(entry->skb, rt2x00dev->ops->extra_tx_headroom);
338
339
340
341
342 skbdesc->flags &= ~SKBDESC_DESC_IN_SKB;
343
344
345
346
347 header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
348
349
350
351
352 if (test_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags))
353 rt2x00queue_remove_l2pad(entry->skb, header_length);
354
355
356
357
358
359
360
361 if (test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags))
362 rt2x00crypto_tx_insert_iv(entry->skb, header_length);
363
364
365
366
367
368 rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_TXDONE, entry->skb);
369
370
371
372
373
374
375 success =
376 rt2x00lib_txdone_bar_status(entry) ||
377 test_bit(TXDONE_SUCCESS, &txdesc->flags) ||
378 test_bit(TXDONE_UNKNOWN, &txdesc->flags);
379
380
381
382
383 rt2x00dev->link.qual.tx_success += success;
384 rt2x00dev->link.qual.tx_failed += !success;
385
386 rate_idx = skbdesc->tx_rate_idx;
387 rate_flags = skbdesc->tx_rate_flags;
388 retry_rates = test_bit(TXDONE_FALLBACK, &txdesc->flags) ?
389 (txdesc->retry + 1) : 1;
390
391
392
393
394 memset(&tx_info->status, 0, sizeof(tx_info->status));
395 tx_info->status.ack_signal = 0;
396
397
398
399
400
401
402
403 for (i = 0; i < retry_rates && i < IEEE80211_TX_MAX_RATES; i++) {
404 tx_info->status.rates[i].idx = rate_idx - i;
405 tx_info->status.rates[i].flags = rate_flags;
406
407 if (rate_idx - i == 0) {
408
409
410
411
412 tx_info->status.rates[i].count = retry_rates - i;
413 i++;
414 break;
415 }
416 tx_info->status.rates[i].count = 1;
417 }
418 if (i < (IEEE80211_TX_MAX_RATES - 1))
419 tx_info->status.rates[i].idx = -1;
420
421 if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
422 if (success)
423 tx_info->flags |= IEEE80211_TX_STAT_ACK;
424 else
425 rt2x00dev->low_level_stats.dot11ACKFailureCount++;
426 }
427
428
429
430
431
432
433
434
435
436
437 if (test_bit(TXDONE_AMPDU, &txdesc->flags) ||
438 tx_info->flags & IEEE80211_TX_CTL_AMPDU) {
439 tx_info->flags |= IEEE80211_TX_STAT_AMPDU;
440 tx_info->status.ampdu_len = 1;
441 tx_info->status.ampdu_ack_len = success ? 1 : 0;
442
443 if (!success)
444 tx_info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;
445 }
446
447 if (rate_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
448 if (success)
449 rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
450 else
451 rt2x00dev->low_level_stats.dot11RTSFailureCount++;
452 }
453
454
455
456
457
458
459
460 if (!(skbdesc_flags & SKBDESC_NOT_MAC80211)) {
461 if (test_bit(REQUIRE_TASKLET_CONTEXT, &rt2x00dev->cap_flags))
462 ieee80211_tx_status(rt2x00dev->hw, entry->skb);
463 else
464 ieee80211_tx_status_ni(rt2x00dev->hw, entry->skb);
465 } else
466 dev_kfree_skb_any(entry->skb);
467
468
469
470
471 entry->skb = NULL;
472 entry->flags = 0;
473
474 rt2x00dev->ops->lib->clear_entry(entry);
475
476 rt2x00queue_index_inc(entry, Q_INDEX_DONE);
477
478
479
480
481
482
483
484
485 spin_lock_bh(&entry->queue->tx_lock);
486 if (!rt2x00queue_threshold(entry->queue))
487 rt2x00queue_unpause_queue(entry->queue);
488 spin_unlock_bh(&entry->queue->tx_lock);
489}
490EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
491
492void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status)
493{
494 struct txdone_entry_desc txdesc;
495
496 txdesc.flags = 0;
497 __set_bit(status, &txdesc.flags);
498 txdesc.retry = 0;
499
500 rt2x00lib_txdone(entry, &txdesc);
501}
502EXPORT_SYMBOL_GPL(rt2x00lib_txdone_noinfo);
503
504static u8 *rt2x00lib_find_ie(u8 *data, unsigned int len, u8 ie)
505{
506 struct ieee80211_mgmt *mgmt = (void *)data;
507 u8 *pos, *end;
508
509 pos = (u8 *)mgmt->u.beacon.variable;
510 end = data + len;
511 while (pos < end) {
512 if (pos + 2 + pos[1] > end)
513 return NULL;
514
515 if (pos[0] == ie)
516 return pos;
517
518 pos += 2 + pos[1];
519 }
520
521 return NULL;
522}
523
524static void rt2x00lib_sleep(struct work_struct *work)
525{
526 struct rt2x00_dev *rt2x00dev =
527 container_of(work, struct rt2x00_dev, sleep_work);
528
529 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
530 return;
531
532
533
534
535
536 if (!test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags))
537 rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf,
538 IEEE80211_CONF_CHANGE_PS);
539}
540
541static void rt2x00lib_rxdone_check_ba(struct rt2x00_dev *rt2x00dev,
542 struct sk_buff *skb,
543 struct rxdone_entry_desc *rxdesc)
544{
545 struct rt2x00_bar_list_entry *entry;
546 struct ieee80211_bar *ba = (void *)skb->data;
547
548 if (likely(!ieee80211_is_back(ba->frame_control)))
549 return;
550
551 if (rxdesc->size < sizeof(*ba) + FCS_LEN)
552 return;
553
554 rcu_read_lock();
555 list_for_each_entry_rcu(entry, &rt2x00dev->bar_list, list) {
556
557 if (ba->start_seq_num != entry->start_seq_num)
558 continue;
559
560#define TID_CHECK(a, b) ( \
561 ((a) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK)) == \
562 ((b) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK))) \
563
564 if (!TID_CHECK(ba->control, entry->control))
565 continue;
566
567#undef TID_CHECK
568
569 if (compare_ether_addr(ba->ra, entry->ta))
570 continue;
571
572 if (compare_ether_addr(ba->ta, entry->ra))
573 continue;
574
575
576 spin_lock_bh(&rt2x00dev->bar_list_lock);
577 entry->block_acked = 1;
578 spin_unlock_bh(&rt2x00dev->bar_list_lock);
579 break;
580 }
581 rcu_read_unlock();
582
583}
584
585static void rt2x00lib_rxdone_check_ps(struct rt2x00_dev *rt2x00dev,
586 struct sk_buff *skb,
587 struct rxdone_entry_desc *rxdesc)
588{
589 struct ieee80211_hdr *hdr = (void *) skb->data;
590 struct ieee80211_tim_ie *tim_ie;
591 u8 *tim;
592 u8 tim_len;
593 bool cam;
594
595
596
597
598 if (likely(!ieee80211_is_beacon(hdr->frame_control) ||
599 !(rt2x00dev->hw->conf.flags & IEEE80211_CONF_PS)))
600 return;
601
602
603 if (skb->len <= 40 + FCS_LEN)
604 return;
605
606
607 if (!(rxdesc->dev_flags & RXDONE_MY_BSS) ||
608 !rt2x00dev->aid)
609 return;
610
611 rt2x00dev->last_beacon = jiffies;
612
613 tim = rt2x00lib_find_ie(skb->data, skb->len - FCS_LEN, WLAN_EID_TIM);
614 if (!tim)
615 return;
616
617 if (tim[1] < sizeof(*tim_ie))
618 return;
619
620 tim_len = tim[1];
621 tim_ie = (struct ieee80211_tim_ie *) &tim[2];
622
623
624
625
626 cam = ieee80211_check_tim(tim_ie, tim_len, rt2x00dev->aid);
627
628
629 cam |= (tim_ie->bitmap_ctrl & 0x01);
630
631 if (!cam && !test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags))
632 queue_work(rt2x00dev->workqueue, &rt2x00dev->sleep_work);
633}
634
635static int rt2x00lib_rxdone_read_signal(struct rt2x00_dev *rt2x00dev,
636 struct rxdone_entry_desc *rxdesc)
637{
638 struct ieee80211_supported_band *sband;
639 const struct rt2x00_rate *rate;
640 unsigned int i;
641 int signal = rxdesc->signal;
642 int type = (rxdesc->dev_flags & RXDONE_SIGNAL_MASK);
643
644 switch (rxdesc->rate_mode) {
645 case RATE_MODE_CCK:
646 case RATE_MODE_OFDM:
647
648
649
650
651 if (rxdesc->dev_flags & RXDONE_SIGNAL_MCS)
652 signal = RATE_MCS(rxdesc->rate_mode, signal);
653
654 sband = &rt2x00dev->bands[rt2x00dev->curr_band];
655 for (i = 0; i < sband->n_bitrates; i++) {
656 rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
657 if (((type == RXDONE_SIGNAL_PLCP) &&
658 (rate->plcp == signal)) ||
659 ((type == RXDONE_SIGNAL_BITRATE) &&
660 (rate->bitrate == signal)) ||
661 ((type == RXDONE_SIGNAL_MCS) &&
662 (rate->mcs == signal))) {
663 return i;
664 }
665 }
666 break;
667 case RATE_MODE_HT_MIX:
668 case RATE_MODE_HT_GREENFIELD:
669 if (signal >= 0 && signal <= 76)
670 return signal;
671 break;
672 default:
673 break;
674 }
675
676 rt2x00_warn(rt2x00dev, "Frame received with unrecognized signal, mode=0x%.4x, signal=0x%.4x, type=%d\n",
677 rxdesc->rate_mode, signal, type);
678 return 0;
679}
680
681void rt2x00lib_rxdone(struct queue_entry *entry, gfp_t gfp)
682{
683 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
684 struct rxdone_entry_desc rxdesc;
685 struct sk_buff *skb;
686 struct ieee80211_rx_status *rx_status;
687 unsigned int header_length;
688 int rate_idx;
689
690 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) ||
691 !test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
692 goto submit_entry;
693
694 if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags))
695 goto submit_entry;
696
697
698
699
700
701 skb = rt2x00queue_alloc_rxskb(entry, gfp);
702 if (!skb)
703 goto submit_entry;
704
705
706
707
708 rt2x00queue_unmap_skb(entry);
709
710
711
712
713 memset(&rxdesc, 0, sizeof(rxdesc));
714 rt2x00dev->ops->lib->fill_rxdone(entry, &rxdesc);
715
716
717
718
719
720 if (unlikely(rxdesc.size == 0 ||
721 rxdesc.size > entry->queue->data_size)) {
722 rt2x00_err(rt2x00dev, "Wrong frame size %d max %d\n",
723 rxdesc.size, entry->queue->data_size);
724 dev_kfree_skb(entry->skb);
725 goto renew_skb;
726 }
727
728
729
730
731
732 header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
733
734
735
736
737
738
739
740 if ((rxdesc.dev_flags & RXDONE_CRYPTO_IV) &&
741 (rxdesc.flags & RX_FLAG_IV_STRIPPED))
742 rt2x00crypto_rx_insert_iv(entry->skb, header_length,
743 &rxdesc);
744 else if (header_length &&
745 (rxdesc.size > header_length) &&
746 (rxdesc.dev_flags & RXDONE_L2PAD))
747 rt2x00queue_remove_l2pad(entry->skb, header_length);
748
749
750 skb_trim(entry->skb, rxdesc.size);
751
752
753
754
755 rate_idx = rt2x00lib_rxdone_read_signal(rt2x00dev, &rxdesc);
756 if (rxdesc.rate_mode == RATE_MODE_HT_MIX ||
757 rxdesc.rate_mode == RATE_MODE_HT_GREENFIELD)
758 rxdesc.flags |= RX_FLAG_HT;
759
760
761
762
763
764 rt2x00lib_rxdone_check_ps(rt2x00dev, entry->skb, &rxdesc);
765
766
767
768
769
770 rt2x00lib_rxdone_check_ba(rt2x00dev, entry->skb, &rxdesc);
771
772
773
774
775 rt2x00link_update_stats(rt2x00dev, entry->skb, &rxdesc);
776 rt2x00debug_update_crypto(rt2x00dev, &rxdesc);
777 rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_RXDONE, entry->skb);
778
779
780
781
782
783 rx_status = IEEE80211_SKB_RXCB(entry->skb);
784
785
786
787
788
789
790 memset(rx_status, 0, sizeof(*rx_status));
791
792 rx_status->mactime = rxdesc.timestamp;
793 rx_status->band = rt2x00dev->curr_band;
794 rx_status->freq = rt2x00dev->curr_freq;
795 rx_status->rate_idx = rate_idx;
796 rx_status->signal = rxdesc.rssi;
797 rx_status->flag = rxdesc.flags;
798 rx_status->antenna = rt2x00dev->link.ant.active.rx;
799
800 ieee80211_rx_ni(rt2x00dev->hw, entry->skb);
801
802renew_skb:
803
804
805
806 entry->skb = skb;
807
808submit_entry:
809 entry->flags = 0;
810 rt2x00queue_index_inc(entry, Q_INDEX_DONE);
811 if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) &&
812 test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
813 rt2x00dev->ops->lib->clear_entry(entry);
814}
815EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);
816
817
818
819
820const struct rt2x00_rate rt2x00_supported_rates[12] = {
821 {
822 .flags = DEV_RATE_CCK,
823 .bitrate = 10,
824 .ratemask = BIT(0),
825 .plcp = 0x00,
826 .mcs = RATE_MCS(RATE_MODE_CCK, 0),
827 },
828 {
829 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
830 .bitrate = 20,
831 .ratemask = BIT(1),
832 .plcp = 0x01,
833 .mcs = RATE_MCS(RATE_MODE_CCK, 1),
834 },
835 {
836 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
837 .bitrate = 55,
838 .ratemask = BIT(2),
839 .plcp = 0x02,
840 .mcs = RATE_MCS(RATE_MODE_CCK, 2),
841 },
842 {
843 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
844 .bitrate = 110,
845 .ratemask = BIT(3),
846 .plcp = 0x03,
847 .mcs = RATE_MCS(RATE_MODE_CCK, 3),
848 },
849 {
850 .flags = DEV_RATE_OFDM,
851 .bitrate = 60,
852 .ratemask = BIT(4),
853 .plcp = 0x0b,
854 .mcs = RATE_MCS(RATE_MODE_OFDM, 0),
855 },
856 {
857 .flags = DEV_RATE_OFDM,
858 .bitrate = 90,
859 .ratemask = BIT(5),
860 .plcp = 0x0f,
861 .mcs = RATE_MCS(RATE_MODE_OFDM, 1),
862 },
863 {
864 .flags = DEV_RATE_OFDM,
865 .bitrate = 120,
866 .ratemask = BIT(6),
867 .plcp = 0x0a,
868 .mcs = RATE_MCS(RATE_MODE_OFDM, 2),
869 },
870 {
871 .flags = DEV_RATE_OFDM,
872 .bitrate = 180,
873 .ratemask = BIT(7),
874 .plcp = 0x0e,
875 .mcs = RATE_MCS(RATE_MODE_OFDM, 3),
876 },
877 {
878 .flags = DEV_RATE_OFDM,
879 .bitrate = 240,
880 .ratemask = BIT(8),
881 .plcp = 0x09,
882 .mcs = RATE_MCS(RATE_MODE_OFDM, 4),
883 },
884 {
885 .flags = DEV_RATE_OFDM,
886 .bitrate = 360,
887 .ratemask = BIT(9),
888 .plcp = 0x0d,
889 .mcs = RATE_MCS(RATE_MODE_OFDM, 5),
890 },
891 {
892 .flags = DEV_RATE_OFDM,
893 .bitrate = 480,
894 .ratemask = BIT(10),
895 .plcp = 0x08,
896 .mcs = RATE_MCS(RATE_MODE_OFDM, 6),
897 },
898 {
899 .flags = DEV_RATE_OFDM,
900 .bitrate = 540,
901 .ratemask = BIT(11),
902 .plcp = 0x0c,
903 .mcs = RATE_MCS(RATE_MODE_OFDM, 7),
904 },
905};
906
907static void rt2x00lib_channel(struct ieee80211_channel *entry,
908 const int channel, const int tx_power,
909 const int value)
910{
911
912 entry->band = channel <= 14 ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
913 entry->center_freq = ieee80211_channel_to_frequency(channel,
914 entry->band);
915 entry->hw_value = value;
916 entry->max_power = tx_power;
917 entry->max_antenna_gain = 0xff;
918}
919
920static void rt2x00lib_rate(struct ieee80211_rate *entry,
921 const u16 index, const struct rt2x00_rate *rate)
922{
923 entry->flags = 0;
924 entry->bitrate = rate->bitrate;
925 entry->hw_value = index;
926 entry->hw_value_short = index;
927
928 if (rate->flags & DEV_RATE_SHORT_PREAMBLE)
929 entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
930}
931
932static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
933 struct hw_mode_spec *spec)
934{
935 struct ieee80211_hw *hw = rt2x00dev->hw;
936 struct ieee80211_channel *channels;
937 struct ieee80211_rate *rates;
938 unsigned int num_rates;
939 unsigned int i;
940
941 num_rates = 0;
942 if (spec->supported_rates & SUPPORT_RATE_CCK)
943 num_rates += 4;
944 if (spec->supported_rates & SUPPORT_RATE_OFDM)
945 num_rates += 8;
946
947 channels = kcalloc(spec->num_channels, sizeof(*channels), GFP_KERNEL);
948 if (!channels)
949 return -ENOMEM;
950
951 rates = kcalloc(num_rates, sizeof(*rates), GFP_KERNEL);
952 if (!rates)
953 goto exit_free_channels;
954
955
956
957
958 for (i = 0; i < num_rates; i++)
959 rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
960
961
962
963
964 for (i = 0; i < spec->num_channels; i++) {
965 rt2x00lib_channel(&channels[i],
966 spec->channels[i].channel,
967 spec->channels_info[i].max_power, i);
968 }
969
970
971
972
973
974
975 if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
976 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_channels = 14;
977 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_bitrates = num_rates;
978 rt2x00dev->bands[IEEE80211_BAND_2GHZ].channels = channels;
979 rt2x00dev->bands[IEEE80211_BAND_2GHZ].bitrates = rates;
980 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
981 &rt2x00dev->bands[IEEE80211_BAND_2GHZ];
982 memcpy(&rt2x00dev->bands[IEEE80211_BAND_2GHZ].ht_cap,
983 &spec->ht, sizeof(spec->ht));
984 }
985
986
987
988
989
990
991 if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
992 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_channels =
993 spec->num_channels - 14;
994 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_bitrates =
995 num_rates - 4;
996 rt2x00dev->bands[IEEE80211_BAND_5GHZ].channels = &channels[14];
997 rt2x00dev->bands[IEEE80211_BAND_5GHZ].bitrates = &rates[4];
998 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
999 &rt2x00dev->bands[IEEE80211_BAND_5GHZ];
1000 memcpy(&rt2x00dev->bands[IEEE80211_BAND_5GHZ].ht_cap,
1001 &spec->ht, sizeof(spec->ht));
1002 }
1003
1004 return 0;
1005
1006 exit_free_channels:
1007 kfree(channels);
1008 rt2x00_err(rt2x00dev, "Allocation ieee80211 modes failed\n");
1009 return -ENOMEM;
1010}
1011
1012static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
1013{
1014 if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
1015 ieee80211_unregister_hw(rt2x00dev->hw);
1016
1017 if (likely(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ])) {
1018 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
1019 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->bitrates);
1020 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
1021 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
1022 }
1023
1024 kfree(rt2x00dev->spec.channels_info);
1025}
1026
1027static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
1028{
1029 struct hw_mode_spec *spec = &rt2x00dev->spec;
1030 int status;
1031
1032 if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
1033 return 0;
1034
1035
1036
1037
1038 status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
1039 if (status)
1040 return status;
1041
1042
1043
1044
1045 rt2x00dev->hw->queues = rt2x00dev->ops->tx_queues;
1046
1047
1048
1049
1050 rt2x00dev->hw->extra_tx_headroom =
1051 max_t(unsigned int, IEEE80211_TX_STATUS_HEADROOM,
1052 rt2x00dev->ops->extra_tx_headroom);
1053
1054
1055
1056
1057 if (test_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags))
1058 rt2x00dev->hw->extra_tx_headroom += RT2X00_L2PAD_SIZE;
1059 else if (test_bit(REQUIRE_DMA, &rt2x00dev->cap_flags))
1060 rt2x00dev->hw->extra_tx_headroom += RT2X00_ALIGN_SIZE;
1061
1062
1063
1064
1065 rt2x00dev->hw->sta_data_size = sizeof(struct rt2x00_sta);
1066
1067
1068
1069
1070 if (test_bit(REQUIRE_TXSTATUS_FIFO, &rt2x00dev->cap_flags)) {
1071
1072
1073
1074
1075
1076
1077
1078 int kfifo_size =
1079 roundup_pow_of_two(rt2x00dev->ops->tx_queues *
1080 rt2x00dev->ops->tx->entry_num *
1081 sizeof(u32));
1082
1083 status = kfifo_alloc(&rt2x00dev->txstatus_fifo, kfifo_size,
1084 GFP_KERNEL);
1085 if (status)
1086 return status;
1087 }
1088
1089
1090
1091
1092
1093
1094#define RT2X00_TASKLET_INIT(taskletname) \
1095 if (rt2x00dev->ops->lib->taskletname) { \
1096 tasklet_init(&rt2x00dev->taskletname, \
1097 rt2x00dev->ops->lib->taskletname, \
1098 (unsigned long)rt2x00dev); \
1099 }
1100
1101 RT2X00_TASKLET_INIT(txstatus_tasklet);
1102 RT2X00_TASKLET_INIT(pretbtt_tasklet);
1103 RT2X00_TASKLET_INIT(tbtt_tasklet);
1104 RT2X00_TASKLET_INIT(rxdone_tasklet);
1105 RT2X00_TASKLET_INIT(autowake_tasklet);
1106
1107#undef RT2X00_TASKLET_INIT
1108
1109
1110
1111
1112 status = ieee80211_register_hw(rt2x00dev->hw);
1113 if (status)
1114 return status;
1115
1116 set_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags);
1117
1118 return 0;
1119}
1120
1121
1122
1123
1124static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
1125{
1126 if (!test_and_clear_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
1127 return;
1128
1129
1130
1131
1132 rt2x00rfkill_unregister(rt2x00dev);
1133
1134
1135
1136
1137 rt2x00dev->ops->lib->uninitialize(rt2x00dev);
1138
1139
1140
1141
1142 rt2x00queue_uninitialize(rt2x00dev);
1143}
1144
1145static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
1146{
1147 int status;
1148
1149 if (test_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
1150 return 0;
1151
1152
1153
1154
1155 status = rt2x00queue_initialize(rt2x00dev);
1156 if (status)
1157 return status;
1158
1159
1160
1161
1162 status = rt2x00dev->ops->lib->initialize(rt2x00dev);
1163 if (status) {
1164 rt2x00queue_uninitialize(rt2x00dev);
1165 return status;
1166 }
1167
1168 set_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags);
1169
1170 return 0;
1171}
1172
1173int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
1174{
1175 int retval;
1176
1177 if (test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
1178 return 0;
1179
1180
1181
1182
1183
1184 retval = rt2x00lib_load_firmware(rt2x00dev);
1185 if (retval)
1186 return retval;
1187
1188
1189
1190
1191 retval = rt2x00lib_initialize(rt2x00dev);
1192 if (retval)
1193 return retval;
1194
1195 rt2x00dev->intf_ap_count = 0;
1196 rt2x00dev->intf_sta_count = 0;
1197 rt2x00dev->intf_associated = 0;
1198
1199
1200 retval = rt2x00lib_enable_radio(rt2x00dev);
1201 if (retval)
1202 return retval;
1203
1204 set_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags);
1205
1206 return 0;
1207}
1208
1209void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
1210{
1211 if (!test_and_clear_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
1212 return;
1213
1214
1215
1216
1217
1218 rt2x00lib_disable_radio(rt2x00dev);
1219
1220 rt2x00dev->intf_ap_count = 0;
1221 rt2x00dev->intf_sta_count = 0;
1222 rt2x00dev->intf_associated = 0;
1223}
1224
1225static inline void rt2x00lib_set_if_combinations(struct rt2x00_dev *rt2x00dev)
1226{
1227 struct ieee80211_iface_limit *if_limit;
1228 struct ieee80211_iface_combination *if_combination;
1229
1230 if (rt2x00dev->ops->max_ap_intf < 2)
1231 return;
1232
1233
1234
1235
1236 if_limit = &rt2x00dev->if_limits_ap;
1237 if_limit->max = rt2x00dev->ops->max_ap_intf;
1238 if_limit->types = BIT(NL80211_IFTYPE_AP);
1239#ifdef CONFIG_MAC80211_MESH
1240 if_limit->types |= BIT(NL80211_IFTYPE_MESH_POINT);
1241#endif
1242
1243
1244
1245
1246 if_combination = &rt2x00dev->if_combinations[IF_COMB_AP];
1247 if_combination->limits = if_limit;
1248 if_combination->n_limits = 1;
1249 if_combination->max_interfaces = if_limit->max;
1250 if_combination->num_different_channels = 1;
1251
1252
1253
1254
1255 rt2x00dev->hw->wiphy->iface_combinations = rt2x00dev->if_combinations;
1256 rt2x00dev->hw->wiphy->n_iface_combinations = 1;
1257}
1258
1259
1260
1261
1262int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
1263{
1264 int retval = -ENOMEM;
1265
1266
1267
1268
1269 rt2x00lib_set_if_combinations(rt2x00dev);
1270
1271
1272
1273
1274 if (rt2x00dev->ops->drv_data_size > 0) {
1275 rt2x00dev->drv_data = kzalloc(rt2x00dev->ops->drv_data_size,
1276 GFP_KERNEL);
1277 if (!rt2x00dev->drv_data) {
1278 retval = -ENOMEM;
1279 goto exit;
1280 }
1281 }
1282
1283 spin_lock_init(&rt2x00dev->irqmask_lock);
1284 mutex_init(&rt2x00dev->csr_mutex);
1285 INIT_LIST_HEAD(&rt2x00dev->bar_list);
1286 spin_lock_init(&rt2x00dev->bar_list_lock);
1287
1288 set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1289
1290
1291
1292
1293
1294 rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);
1295
1296
1297
1298
1299
1300 rt2x00dev->hw->wiphy->addr_mask[ETH_ALEN - 1] =
1301 (rt2x00dev->ops->max_ap_intf - 1);
1302
1303
1304
1305
1306
1307
1308 rt2x00dev->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
1309 if (rt2x00dev->ops->bcn->entry_num > 0)
1310 rt2x00dev->hw->wiphy->interface_modes |=
1311 BIT(NL80211_IFTYPE_ADHOC) |
1312 BIT(NL80211_IFTYPE_AP) |
1313#ifdef CONFIG_MAC80211_MESH
1314 BIT(NL80211_IFTYPE_MESH_POINT) |
1315#endif
1316 BIT(NL80211_IFTYPE_WDS);
1317
1318 rt2x00dev->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
1319
1320
1321
1322
1323 rt2x00dev->workqueue =
1324 alloc_ordered_workqueue(wiphy_name(rt2x00dev->hw->wiphy), 0);
1325 if (!rt2x00dev->workqueue) {
1326 retval = -ENOMEM;
1327 goto exit;
1328 }
1329
1330 INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
1331 INIT_DELAYED_WORK(&rt2x00dev->autowakeup_work, rt2x00lib_autowakeup);
1332 INIT_WORK(&rt2x00dev->sleep_work, rt2x00lib_sleep);
1333
1334
1335
1336
1337 retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
1338 if (retval) {
1339 rt2x00_err(rt2x00dev, "Failed to allocate device\n");
1340 goto exit;
1341 }
1342
1343
1344
1345
1346 retval = rt2x00queue_allocate(rt2x00dev);
1347 if (retval)
1348 goto exit;
1349
1350
1351
1352
1353 retval = rt2x00lib_probe_hw(rt2x00dev);
1354 if (retval) {
1355 rt2x00_err(rt2x00dev, "Failed to initialize hw\n");
1356 goto exit;
1357 }
1358
1359
1360
1361
1362 rt2x00link_register(rt2x00dev);
1363 rt2x00leds_register(rt2x00dev);
1364 rt2x00debug_register(rt2x00dev);
1365 rt2x00rfkill_register(rt2x00dev);
1366
1367 return 0;
1368
1369exit:
1370 rt2x00lib_remove_dev(rt2x00dev);
1371
1372 return retval;
1373}
1374EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);
1375
1376void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
1377{
1378 clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1379
1380
1381
1382
1383 rt2x00lib_disable_radio(rt2x00dev);
1384
1385
1386
1387
1388 cancel_work_sync(&rt2x00dev->intf_work);
1389 cancel_delayed_work_sync(&rt2x00dev->autowakeup_work);
1390 cancel_work_sync(&rt2x00dev->sleep_work);
1391 if (rt2x00_is_usb(rt2x00dev)) {
1392 hrtimer_cancel(&rt2x00dev->txstatus_timer);
1393 cancel_work_sync(&rt2x00dev->rxdone_work);
1394 cancel_work_sync(&rt2x00dev->txdone_work);
1395 }
1396 if (rt2x00dev->workqueue)
1397 destroy_workqueue(rt2x00dev->workqueue);
1398
1399
1400
1401
1402 kfifo_free(&rt2x00dev->txstatus_fifo);
1403
1404
1405
1406
1407 tasklet_kill(&rt2x00dev->txstatus_tasklet);
1408 tasklet_kill(&rt2x00dev->pretbtt_tasklet);
1409 tasklet_kill(&rt2x00dev->tbtt_tasklet);
1410 tasklet_kill(&rt2x00dev->rxdone_tasklet);
1411 tasklet_kill(&rt2x00dev->autowake_tasklet);
1412
1413
1414
1415
1416 rt2x00lib_uninitialize(rt2x00dev);
1417
1418
1419
1420
1421 rt2x00debug_deregister(rt2x00dev);
1422 rt2x00leds_unregister(rt2x00dev);
1423
1424
1425
1426
1427 rt2x00lib_remove_hw(rt2x00dev);
1428
1429
1430
1431
1432 rt2x00lib_free_firmware(rt2x00dev);
1433
1434
1435
1436
1437 rt2x00queue_free(rt2x00dev);
1438
1439
1440
1441
1442 if (rt2x00dev->drv_data)
1443 kfree(rt2x00dev->drv_data);
1444}
1445EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);
1446
1447
1448
1449
1450#ifdef CONFIG_PM
1451int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
1452{
1453 rt2x00_dbg(rt2x00dev, "Going to sleep\n");
1454
1455
1456
1457
1458 if (!test_and_clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
1459 return 0;
1460
1461
1462
1463
1464 rt2x00lib_uninitialize(rt2x00dev);
1465
1466
1467
1468
1469 rt2x00leds_suspend(rt2x00dev);
1470 rt2x00debug_deregister(rt2x00dev);
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483 if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP))
1484 rt2x00_warn(rt2x00dev, "Device failed to enter sleep state, continue suspending\n");
1485
1486 return 0;
1487}
1488EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
1489
1490int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1491{
1492 rt2x00_dbg(rt2x00dev, "Waking up\n");
1493
1494
1495
1496
1497 rt2x00debug_register(rt2x00dev);
1498 rt2x00leds_resume(rt2x00dev);
1499
1500
1501
1502
1503 set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1504
1505 return 0;
1506}
1507EXPORT_SYMBOL_GPL(rt2x00lib_resume);
1508#endif
1509
1510
1511
1512
1513MODULE_AUTHOR(DRV_PROJECT);
1514MODULE_VERSION(DRV_VERSION);
1515MODULE_DESCRIPTION("rt2x00 library");
1516MODULE_LICENSE("GPL");
1517