1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3 Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
4 Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com>
5 Copyright (C) 2004 - 2009 Gertjan van Wingerde <gwingerde@gmail.com>
6 <http://rt2x00.serialmonkey.com>
7
8 */
9
10 /*
11 Module: rt2x00
12 Abstract: rt2x00 global information.
13 */
14
15 #ifndef RT2X00_H
16 #define RT2X00_H
17
18 #include <linux/bitops.h>
19 #include <linux/interrupt.h>
20 #include <linux/skbuff.h>
21 #include <linux/workqueue.h>
22 #include <linux/firmware.h>
23 #include <linux/leds.h>
24 #include <linux/mutex.h>
25 #include <linux/etherdevice.h>
26 #include <linux/kfifo.h>
27 #include <linux/hrtimer.h>
28 #include <linux/average.h>
29 #include <linux/usb.h>
30 #include <linux/clk.h>
31
32 #include <net/mac80211.h>
33
34 #include "rt2x00debug.h"
35 #include "rt2x00dump.h"
36 #include "rt2x00leds.h"
37 #include "rt2x00reg.h"
38 #include "rt2x00queue.h"
39
40 /*
41 * Module information.
42 */
43 #define DRV_VERSION "2.3.0"
44 #define DRV_PROJECT "http://rt2x00.serialmonkey.com"
45
46 /* Debug definitions.
47 * Debug output has to be enabled during compile time.
48 */
49 #ifdef CONFIG_RT2X00_DEBUG
50 #define DEBUG
51 #endif /* CONFIG_RT2X00_DEBUG */
52
53 /* Utility printing macros
54 * rt2x00_probe_err is for messages when rt2x00_dev is uninitialized
55 */
56 #define rt2x00_probe_err(fmt, ...) \
57 printk(KERN_ERR KBUILD_MODNAME ": %s: Error - " fmt, \
58 __func__, ##__VA_ARGS__)
59 #define rt2x00_err(dev, fmt, ...) \
60 wiphy_err_ratelimited((dev)->hw->wiphy, "%s: Error - " fmt, \
61 __func__, ##__VA_ARGS__)
62 #define rt2x00_warn(dev, fmt, ...) \
63 wiphy_warn_ratelimited((dev)->hw->wiphy, "%s: Warning - " fmt, \
64 __func__, ##__VA_ARGS__)
65 #define rt2x00_info(dev, fmt, ...) \
66 wiphy_info((dev)->hw->wiphy, "%s: Info - " fmt, \
67 __func__, ##__VA_ARGS__)
68
69 /* Various debug levels */
70 #define rt2x00_dbg(dev, fmt, ...) \
71 wiphy_dbg((dev)->hw->wiphy, "%s: Debug - " fmt, \
72 __func__, ##__VA_ARGS__)
73 #define rt2x00_eeprom_dbg(dev, fmt, ...) \
74 wiphy_dbg((dev)->hw->wiphy, "%s: EEPROM recovery - " fmt, \
75 __func__, ##__VA_ARGS__)
76
77 /*
78 * Duration calculations
79 * The rate variable passed is: 100kbs.
80 * To convert from bytes to bits we multiply size with 8,
81 * then the size is multiplied with 10 to make the
82 * real rate -> rate argument correction.
83 */
84 #define GET_DURATION(__size, __rate) (((__size) * 8 * 10) / (__rate))
85 #define GET_DURATION_RES(__size, __rate)(((__size) * 8 * 10) % (__rate))
86
87 /*
88 * Determine the number of L2 padding bytes required between the header and
89 * the payload.
90 */
91 #define L2PAD_SIZE(__hdrlen) (-(__hdrlen) & 3)
92
93 /*
94 * Determine the alignment requirement,
95 * to make sure the 802.11 payload is padded to a 4-byte boundrary
96 * we must determine the address of the payload and calculate the
97 * amount of bytes needed to move the data.
98 */
99 #define ALIGN_SIZE(__skb, __header) \
100 (((unsigned long)((__skb)->data + (__header))) & 3)
101
102 /*
103 * Constants for extra TX headroom for alignment purposes.
104 */
105 #define RT2X00_ALIGN_SIZE 4 /* Only whole frame needs alignment */
106 #define RT2X00_L2PAD_SIZE 8 /* Both header & payload need alignment */
107
108 /*
109 * Standard timing and size defines.
110 * These values should follow the ieee80211 specifications.
111 */
112 #define ACK_SIZE 14
113 #define IEEE80211_HEADER 24
114 #define PLCP 48
115 #define BEACON 100
116 #define PREAMBLE 144
117 #define SHORT_PREAMBLE 72
118 #define SLOT_TIME 20
119 #define SHORT_SLOT_TIME 9
120 #define SIFS 10
121 #define PIFS (SIFS + SLOT_TIME)
122 #define SHORT_PIFS (SIFS + SHORT_SLOT_TIME)
123 #define DIFS (PIFS + SLOT_TIME)
124 #define SHORT_DIFS (SHORT_PIFS + SHORT_SLOT_TIME)
125 #define EIFS (SIFS + DIFS + \
126 GET_DURATION(IEEE80211_HEADER + ACK_SIZE, 10))
127 #define SHORT_EIFS (SIFS + SHORT_DIFS + \
128 GET_DURATION(IEEE80211_HEADER + ACK_SIZE, 10))
129
130 enum rt2x00_chip_intf {
131 RT2X00_CHIP_INTF_PCI,
132 RT2X00_CHIP_INTF_PCIE,
133 RT2X00_CHIP_INTF_USB,
134 RT2X00_CHIP_INTF_SOC,
135 };
136
137 /*
138 * Chipset identification
139 * The chipset on the device is composed of a RT and RF chip.
140 * The chipset combination is important for determining device capabilities.
141 */
142 struct rt2x00_chip {
143 u16 rt;
144 #define RT2460 0x2460
145 #define RT2560 0x2560
146 #define RT2570 0x2570
147 #define RT2661 0x2661
148 #define RT2573 0x2573
149 #define RT2860 0x2860 /* 2.4GHz */
150 #define RT2872 0x2872 /* WSOC */
151 #define RT2883 0x2883 /* WSOC */
152 #define RT3070 0x3070
153 #define RT3071 0x3071
154 #define RT3090 0x3090 /* 2.4GHz PCIe */
155 #define RT3290 0x3290
156 #define RT3352 0x3352 /* WSOC */
157 #define RT3390 0x3390
158 #define RT3572 0x3572
159 #define RT3593 0x3593
160 #define RT3883 0x3883 /* WSOC */
161 #define RT5350 0x5350 /* WSOC 2.4GHz */
162 #define RT5390 0x5390 /* 2.4GHz */
163 #define RT5392 0x5392 /* 2.4GHz */
164 #define RT5592 0x5592
165 #define RT6352 0x6352 /* WSOC 2.4GHz */
166
167 u16 rf;
168 u16 rev;
169
170 enum rt2x00_chip_intf intf;
171 };
172
173 /*
174 * RF register values that belong to a particular channel.
175 */
176 struct rf_channel {
177 int channel;
178 u32 rf1;
179 u32 rf2;
180 u32 rf3;
181 u32 rf4;
182 };
183
184 /*
185 * Channel information structure
186 */
187 struct channel_info {
188 unsigned int flags;
189 #define GEOGRAPHY_ALLOWED 0x00000001
190
191 short max_power;
192 short default_power1;
193 short default_power2;
194 short default_power3;
195 };
196
197 /*
198 * Antenna setup values.
199 */
200 struct antenna_setup {
201 enum antenna rx;
202 enum antenna tx;
203 u8 rx_chain_num;
204 u8 tx_chain_num;
205 };
206
207 /*
208 * Quality statistics about the currently active link.
209 */
210 struct link_qual {
211 /*
212 * Statistics required for Link tuning by driver
213 * The rssi value is provided by rt2x00lib during the
214 * link_tuner() callback function.
215 * The false_cca field is filled during the link_stats()
216 * callback function and could be used during the
217 * link_tuner() callback function.
218 */
219 int rssi;
220 int false_cca;
221
222 /*
223 * VGC levels
224 * Hardware driver will tune the VGC level during each call
225 * to the link_tuner() callback function. This vgc_level is
226 * is determined based on the link quality statistics like
227 * average RSSI and the false CCA count.
228 *
229 * In some cases the drivers need to differentiate between
230 * the currently "desired" VGC level and the level configured
231 * in the hardware. The latter is important to reduce the
232 * number of BBP register reads to reduce register access
233 * overhead. For this reason we store both values here.
234 */
235 u8 vgc_level;
236 u8 vgc_level_reg;
237
238 /*
239 * Statistics required for Signal quality calculation.
240 * These fields might be changed during the link_stats()
241 * callback function.
242 */
243 int rx_success;
244 int rx_failed;
245 int tx_success;
246 int tx_failed;
247 };
248
249 DECLARE_EWMA(rssi, 10, 8)
250
251 /*
252 * Antenna settings about the currently active link.
253 */
254 struct link_ant {
255 /*
256 * Antenna flags
257 */
258 unsigned int flags;
259 #define ANTENNA_RX_DIVERSITY 0x00000001
260 #define ANTENNA_TX_DIVERSITY 0x00000002
261 #define ANTENNA_MODE_SAMPLE 0x00000004
262
263 /*
264 * Currently active TX/RX antenna setup.
265 * When software diversity is used, this will indicate
266 * which antenna is actually used at this time.
267 */
268 struct antenna_setup active;
269
270 /*
271 * RSSI history information for the antenna.
272 * Used to determine when to switch antenna
273 * when using software diversity.
274 */
275 int rssi_history;
276
277 /*
278 * Current RSSI average of the currently active antenna.
279 * Similar to the avg_rssi in the link_qual structure
280 * this value is updated by using the walking average.
281 */
282 struct ewma_rssi rssi_ant;
283 };
284
285 /*
286 * To optimize the quality of the link we need to store
287 * the quality of received frames and periodically
288 * optimize the link.
289 */
290 struct link {
291 /*
292 * Link tuner counter
293 * The number of times the link has been tuned
294 * since the radio has been switched on.
295 */
296 u32 count;
297
298 /*
299 * Quality measurement values.
300 */
301 struct link_qual qual;
302
303 /*
304 * TX/RX antenna setup.
305 */
306 struct link_ant ant;
307
308 /*
309 * Currently active average RSSI value
310 */
311 struct ewma_rssi avg_rssi;
312
313 /*
314 * Work structure for scheduling periodic link tuning.
315 */
316 struct delayed_work work;
317
318 /*
319 * Work structure for scheduling periodic watchdog monitoring.
320 * This work must be scheduled on the kernel workqueue, while
321 * all other work structures must be queued on the mac80211
322 * workqueue. This guarantees that the watchdog can schedule
323 * other work structures and wait for their completion in order
324 * to bring the device/driver back into the desired state.
325 */
326 struct delayed_work watchdog_work;
327 unsigned int watchdog_interval;
328 bool watchdog_disabled;
329
330 /*
331 * Work structure for scheduling periodic AGC adjustments.
332 */
333 struct delayed_work agc_work;
334
335 /*
336 * Work structure for scheduling periodic VCO calibration.
337 */
338 struct delayed_work vco_work;
339 };
340
341 enum rt2x00_delayed_flags {
342 DELAYED_UPDATE_BEACON,
343 };
344
345 /*
346 * Interface structure
347 * Per interface configuration details, this structure
348 * is allocated as the private data for ieee80211_vif.
349 */
350 struct rt2x00_intf {
351 /*
352 * beacon->skb must be protected with the mutex.
353 */
354 struct mutex beacon_skb_mutex;
355
356 /*
357 * Entry in the beacon queue which belongs to
358 * this interface. Each interface has its own
359 * dedicated beacon entry.
360 */
361 struct queue_entry *beacon;
362 bool enable_beacon;
363
364 /*
365 * Actions that needed rescheduling.
366 */
367 unsigned long delayed_flags;
368
369 /*
370 * Software sequence counter, this is only required
371 * for hardware which doesn't support hardware
372 * sequence counting.
373 */
374 atomic_t seqno;
375 };
376
vif_to_intf(struct ieee80211_vif * vif)377 static inline struct rt2x00_intf* vif_to_intf(struct ieee80211_vif *vif)
378 {
379 return (struct rt2x00_intf *)vif->drv_priv;
380 }
381
382 /**
383 * struct hw_mode_spec: Hardware specifications structure
384 *
385 * Details about the supported modes, rates and channels
386 * of a particular chipset. This is used by rt2x00lib
387 * to build the ieee80211_hw_mode array for mac80211.
388 *
389 * @supported_bands: Bitmask contained the supported bands (2.4GHz, 5.2GHz).
390 * @supported_rates: Rate types which are supported (CCK, OFDM).
391 * @num_channels: Number of supported channels. This is used as array size
392 * for @tx_power_a, @tx_power_bg and @channels.
393 * @channels: Device/chipset specific channel values (See &struct rf_channel).
394 * @channels_info: Additional information for channels (See &struct channel_info).
395 * @ht: Driver HT Capabilities (See &ieee80211_sta_ht_cap).
396 */
397 struct hw_mode_spec {
398 unsigned int supported_bands;
399 #define SUPPORT_BAND_2GHZ 0x00000001
400 #define SUPPORT_BAND_5GHZ 0x00000002
401
402 unsigned int supported_rates;
403 #define SUPPORT_RATE_CCK 0x00000001
404 #define SUPPORT_RATE_OFDM 0x00000002
405
406 unsigned int num_channels;
407 const struct rf_channel *channels;
408 const struct channel_info *channels_info;
409
410 struct ieee80211_sta_ht_cap ht;
411 };
412
413 /*
414 * Configuration structure wrapper around the
415 * mac80211 configuration structure.
416 * When mac80211 configures the driver, rt2x00lib
417 * can precalculate values which are equal for all
418 * rt2x00 drivers. Those values can be stored in here.
419 */
420 struct rt2x00lib_conf {
421 struct ieee80211_conf *conf;
422
423 struct rf_channel rf;
424 struct channel_info channel;
425 };
426
427 /*
428 * Configuration structure for erp settings.
429 */
430 struct rt2x00lib_erp {
431 int short_preamble;
432 int cts_protection;
433
434 u32 basic_rates;
435
436 int slot_time;
437
438 short sifs;
439 short pifs;
440 short difs;
441 short eifs;
442
443 u16 beacon_int;
444 u16 ht_opmode;
445 };
446
447 /*
448 * Configuration structure for hardware encryption.
449 */
450 struct rt2x00lib_crypto {
451 enum cipher cipher;
452
453 enum set_key_cmd cmd;
454 const u8 *address;
455
456 u32 bssidx;
457
458 u8 key[16];
459 u8 tx_mic[8];
460 u8 rx_mic[8];
461
462 int wcid;
463 };
464
465 /*
466 * Configuration structure wrapper around the
467 * rt2x00 interface configuration handler.
468 */
469 struct rt2x00intf_conf {
470 /*
471 * Interface type
472 */
473 enum nl80211_iftype type;
474
475 /*
476 * TSF sync value, this is dependent on the operation type.
477 */
478 enum tsf_sync sync;
479
480 /*
481 * The MAC and BSSID addresses are simple array of bytes,
482 * these arrays are little endian, so when sending the addresses
483 * to the drivers, copy the it into a endian-signed variable.
484 *
485 * Note that all devices (except rt2500usb) have 32 bits
486 * register word sizes. This means that whatever variable we
487 * pass _must_ be a multiple of 32 bits. Otherwise the device
488 * might not accept what we are sending to it.
489 * This will also make it easier for the driver to write
490 * the data to the device.
491 */
492 __le32 mac[2];
493 __le32 bssid[2];
494 };
495
496 /*
497 * Private structure for storing STA details
498 * wcid: Wireless Client ID
499 */
500 struct rt2x00_sta {
501 int wcid;
502 };
503
sta_to_rt2x00_sta(struct ieee80211_sta * sta)504 static inline struct rt2x00_sta* sta_to_rt2x00_sta(struct ieee80211_sta *sta)
505 {
506 return (struct rt2x00_sta *)sta->drv_priv;
507 }
508
509 /*
510 * rt2x00lib callback functions.
511 */
512 struct rt2x00lib_ops {
513 /*
514 * Interrupt handlers.
515 */
516 irq_handler_t irq_handler;
517
518 /*
519 * TX status tasklet handler.
520 */
521 void (*txstatus_tasklet) (unsigned long data);
522 void (*pretbtt_tasklet) (unsigned long data);
523 void (*tbtt_tasklet) (unsigned long data);
524 void (*rxdone_tasklet) (unsigned long data);
525 void (*autowake_tasklet) (unsigned long data);
526
527 /*
528 * Device init handlers.
529 */
530 int (*probe_hw) (struct rt2x00_dev *rt2x00dev);
531 char *(*get_firmware_name) (struct rt2x00_dev *rt2x00dev);
532 int (*check_firmware) (struct rt2x00_dev *rt2x00dev,
533 const u8 *data, const size_t len);
534 int (*load_firmware) (struct rt2x00_dev *rt2x00dev,
535 const u8 *data, const size_t len);
536
537 /*
538 * Device initialization/deinitialization handlers.
539 */
540 int (*initialize) (struct rt2x00_dev *rt2x00dev);
541 void (*uninitialize) (struct rt2x00_dev *rt2x00dev);
542
543 /*
544 * queue initialization handlers
545 */
546 bool (*get_entry_state) (struct queue_entry *entry);
547 void (*clear_entry) (struct queue_entry *entry);
548
549 /*
550 * Radio control handlers.
551 */
552 int (*set_device_state) (struct rt2x00_dev *rt2x00dev,
553 enum dev_state state);
554 int (*rfkill_poll) (struct rt2x00_dev *rt2x00dev);
555 void (*link_stats) (struct rt2x00_dev *rt2x00dev,
556 struct link_qual *qual);
557 void (*reset_tuner) (struct rt2x00_dev *rt2x00dev,
558 struct link_qual *qual);
559 void (*link_tuner) (struct rt2x00_dev *rt2x00dev,
560 struct link_qual *qual, const u32 count);
561 void (*gain_calibration) (struct rt2x00_dev *rt2x00dev);
562 void (*vco_calibration) (struct rt2x00_dev *rt2x00dev);
563
564 /*
565 * Data queue handlers.
566 */
567 void (*watchdog) (struct rt2x00_dev *rt2x00dev);
568 void (*start_queue) (struct data_queue *queue);
569 void (*kick_queue) (struct data_queue *queue);
570 void (*stop_queue) (struct data_queue *queue);
571 void (*flush_queue) (struct data_queue *queue, bool drop);
572 void (*tx_dma_done) (struct queue_entry *entry);
573
574 /*
575 * TX control handlers
576 */
577 void (*write_tx_desc) (struct queue_entry *entry,
578 struct txentry_desc *txdesc);
579 void (*write_tx_data) (struct queue_entry *entry,
580 struct txentry_desc *txdesc);
581 void (*write_beacon) (struct queue_entry *entry,
582 struct txentry_desc *txdesc);
583 void (*clear_beacon) (struct queue_entry *entry);
584 int (*get_tx_data_len) (struct queue_entry *entry);
585
586 /*
587 * RX control handlers
588 */
589 void (*fill_rxdone) (struct queue_entry *entry,
590 struct rxdone_entry_desc *rxdesc);
591
592 /*
593 * Configuration handlers.
594 */
595 int (*config_shared_key) (struct rt2x00_dev *rt2x00dev,
596 struct rt2x00lib_crypto *crypto,
597 struct ieee80211_key_conf *key);
598 int (*config_pairwise_key) (struct rt2x00_dev *rt2x00dev,
599 struct rt2x00lib_crypto *crypto,
600 struct ieee80211_key_conf *key);
601 void (*config_filter) (struct rt2x00_dev *rt2x00dev,
602 const unsigned int filter_flags);
603 void (*config_intf) (struct rt2x00_dev *rt2x00dev,
604 struct rt2x00_intf *intf,
605 struct rt2x00intf_conf *conf,
606 const unsigned int flags);
607 #define CONFIG_UPDATE_TYPE ( 1 << 1 )
608 #define CONFIG_UPDATE_MAC ( 1 << 2 )
609 #define CONFIG_UPDATE_BSSID ( 1 << 3 )
610
611 void (*config_erp) (struct rt2x00_dev *rt2x00dev,
612 struct rt2x00lib_erp *erp,
613 u32 changed);
614 void (*config_ant) (struct rt2x00_dev *rt2x00dev,
615 struct antenna_setup *ant);
616 void (*config) (struct rt2x00_dev *rt2x00dev,
617 struct rt2x00lib_conf *libconf,
618 const unsigned int changed_flags);
619 void (*pre_reset_hw) (struct rt2x00_dev *rt2x00dev);
620 int (*sta_add) (struct rt2x00_dev *rt2x00dev,
621 struct ieee80211_vif *vif,
622 struct ieee80211_sta *sta);
623 int (*sta_remove) (struct rt2x00_dev *rt2x00dev,
624 struct ieee80211_sta *sta);
625 };
626
627 /*
628 * rt2x00 driver callback operation structure.
629 */
630 struct rt2x00_ops {
631 const char *name;
632 const unsigned int drv_data_size;
633 const unsigned int max_ap_intf;
634 const unsigned int eeprom_size;
635 const unsigned int rf_size;
636 const unsigned int tx_queues;
637 void (*queue_init)(struct data_queue *queue);
638 const struct rt2x00lib_ops *lib;
639 const void *drv;
640 const struct ieee80211_ops *hw;
641 #ifdef CONFIG_RT2X00_LIB_DEBUGFS
642 const struct rt2x00debug *debugfs;
643 #endif /* CONFIG_RT2X00_LIB_DEBUGFS */
644 };
645
646 /*
647 * rt2x00 state flags
648 */
649 enum rt2x00_state_flags {
650 /*
651 * Device flags
652 */
653 DEVICE_STATE_PRESENT,
654 DEVICE_STATE_REGISTERED_HW,
655 DEVICE_STATE_INITIALIZED,
656 DEVICE_STATE_STARTED,
657 DEVICE_STATE_ENABLED_RADIO,
658 DEVICE_STATE_SCANNING,
659 DEVICE_STATE_FLUSHING,
660 DEVICE_STATE_RESET,
661
662 /*
663 * Driver configuration
664 */
665 CONFIG_CHANNEL_HT40,
666 CONFIG_POWERSAVING,
667 CONFIG_HT_DISABLED,
668 CONFIG_MONITORING,
669
670 /*
671 * Mark we currently are sequentially reading TX_STA_FIFO register
672 * FIXME: this is for only rt2800usb, should go to private data
673 */
674 TX_STATUS_READING,
675 };
676
677 /*
678 * rt2x00 capability flags
679 */
680 enum rt2x00_capability_flags {
681 /*
682 * Requirements
683 */
684 REQUIRE_FIRMWARE,
685 REQUIRE_BEACON_GUARD,
686 REQUIRE_ATIM_QUEUE,
687 REQUIRE_DMA,
688 REQUIRE_COPY_IV,
689 REQUIRE_L2PAD,
690 REQUIRE_TXSTATUS_FIFO,
691 REQUIRE_TASKLET_CONTEXT,
692 REQUIRE_SW_SEQNO,
693 REQUIRE_HT_TX_DESC,
694 REQUIRE_PS_AUTOWAKE,
695 REQUIRE_DELAYED_RFKILL,
696
697 /*
698 * Capabilities
699 */
700 CAPABILITY_HW_BUTTON,
701 CAPABILITY_HW_CRYPTO,
702 CAPABILITY_POWER_LIMIT,
703 CAPABILITY_CONTROL_FILTERS,
704 CAPABILITY_CONTROL_FILTER_PSPOLL,
705 CAPABILITY_PRE_TBTT_INTERRUPT,
706 CAPABILITY_LINK_TUNING,
707 CAPABILITY_FRAME_TYPE,
708 CAPABILITY_RF_SEQUENCE,
709 CAPABILITY_EXTERNAL_LNA_A,
710 CAPABILITY_EXTERNAL_LNA_BG,
711 CAPABILITY_DOUBLE_ANTENNA,
712 CAPABILITY_BT_COEXIST,
713 CAPABILITY_VCO_RECALIBRATION,
714 CAPABILITY_EXTERNAL_PA_TX0,
715 CAPABILITY_EXTERNAL_PA_TX1,
716 CAPABILITY_RESTART_HW,
717 };
718
719 /*
720 * Interface combinations
721 */
722 enum {
723 IF_COMB_AP = 0,
724 NUM_IF_COMB,
725 };
726
727 /*
728 * rt2x00 device structure.
729 */
730 struct rt2x00_dev {
731 /*
732 * Device structure.
733 * The structure stored in here depends on the
734 * system bus (PCI or USB).
735 * When accessing this variable, the rt2x00dev_{pci,usb}
736 * macros should be used for correct typecasting.
737 */
738 struct device *dev;
739
740 /*
741 * Callback functions.
742 */
743 const struct rt2x00_ops *ops;
744
745 /*
746 * Driver data.
747 */
748 void *drv_data;
749
750 /*
751 * IEEE80211 control structure.
752 */
753 struct ieee80211_hw *hw;
754 struct ieee80211_supported_band bands[NUM_NL80211_BANDS];
755 enum nl80211_band curr_band;
756 int curr_freq;
757
758 /*
759 * If enabled, the debugfs interface structures
760 * required for deregistration of debugfs.
761 */
762 #ifdef CONFIG_RT2X00_LIB_DEBUGFS
763 struct rt2x00debug_intf *debugfs_intf;
764 #endif /* CONFIG_RT2X00_LIB_DEBUGFS */
765
766 /*
767 * LED structure for changing the LED status
768 * by mac8011 or the kernel.
769 */
770 #ifdef CONFIG_RT2X00_LIB_LEDS
771 struct rt2x00_led led_radio;
772 struct rt2x00_led led_assoc;
773 struct rt2x00_led led_qual;
774 u16 led_mcu_reg;
775 #endif /* CONFIG_RT2X00_LIB_LEDS */
776
777 /*
778 * Device state flags.
779 * In these flags the current status is stored.
780 * Access to these flags should occur atomically.
781 */
782 unsigned long flags;
783
784 /*
785 * Device capabiltiy flags.
786 * In these flags the device/driver capabilities are stored.
787 * Access to these flags should occur non-atomically.
788 */
789 unsigned long cap_flags;
790
791 /*
792 * Device information, Bus IRQ and name (PCI, SoC)
793 */
794 int irq;
795 const char *name;
796
797 /*
798 * Chipset identification.
799 */
800 struct rt2x00_chip chip;
801
802 /*
803 * hw capability specifications.
804 */
805 struct hw_mode_spec spec;
806
807 /*
808 * This is the default TX/RX antenna setup as indicated
809 * by the device's EEPROM.
810 */
811 struct antenna_setup default_ant;
812
813 /*
814 * Register pointers
815 * csr.base: CSR base register address. (PCI)
816 * csr.cache: CSR cache for usb_control_msg. (USB)
817 */
818 union csr {
819 void __iomem *base;
820 void *cache;
821 } csr;
822
823 /*
824 * Mutex to protect register accesses.
825 * For PCI and USB devices it protects against concurrent indirect
826 * register access (BBP, RF, MCU) since accessing those
827 * registers require multiple calls to the CSR registers.
828 * For USB devices it also protects the csr_cache since that
829 * field is used for normal CSR access and it cannot support
830 * multiple callers simultaneously.
831 */
832 struct mutex csr_mutex;
833
834 /*
835 * Mutex to synchronize config and link tuner.
836 */
837 struct mutex conf_mutex;
838 /*
839 * Current packet filter configuration for the device.
840 * This contains all currently active FIF_* flags send
841 * to us by mac80211 during configure_filter().
842 */
843 unsigned int packet_filter;
844
845 /*
846 * Interface details:
847 * - Open ap interface count.
848 * - Open sta interface count.
849 * - Association count.
850 * - Beaconing enabled count.
851 */
852 unsigned int intf_ap_count;
853 unsigned int intf_sta_count;
854 unsigned int intf_associated;
855 unsigned int intf_beaconing;
856
857 /*
858 * Interface combinations
859 */
860 struct ieee80211_iface_limit if_limits_ap;
861 struct ieee80211_iface_combination if_combinations[NUM_IF_COMB];
862
863 /*
864 * Link quality
865 */
866 struct link link;
867
868 /*
869 * EEPROM data.
870 */
871 __le16 *eeprom;
872
873 /*
874 * Active RF register values.
875 * These are stored here so we don't need
876 * to read the rf registers and can directly
877 * use this value instead.
878 * This field should be accessed by using
879 * rt2x00_rf_read() and rt2x00_rf_write().
880 */
881 u32 *rf;
882
883 /*
884 * LNA gain
885 */
886 short lna_gain;
887
888 /*
889 * Current TX power value.
890 */
891 u16 tx_power;
892
893 /*
894 * Current retry values.
895 */
896 u8 short_retry;
897 u8 long_retry;
898
899 /*
900 * Rssi <-> Dbm offset
901 */
902 u8 rssi_offset;
903
904 /*
905 * Frequency offset.
906 */
907 u8 freq_offset;
908
909 /*
910 * Association id.
911 */
912 u16 aid;
913
914 /*
915 * Beacon interval.
916 */
917 u16 beacon_int;
918
919 /**
920 * Timestamp of last received beacon
921 */
922 unsigned long last_beacon;
923
924 /*
925 * Low level statistics which will have
926 * to be kept up to date while device is running.
927 */
928 struct ieee80211_low_level_stats low_level_stats;
929
930 /**
931 * Work queue for all work which should not be placed
932 * on the mac80211 workqueue (because of dependencies
933 * between various work structures).
934 */
935 struct workqueue_struct *workqueue;
936
937 /*
938 * Scheduled work.
939 * NOTE: intf_work will use ieee80211_iterate_active_interfaces()
940 * which means it cannot be placed on the hw->workqueue
941 * due to RTNL locking requirements.
942 */
943 struct work_struct intf_work;
944
945 /**
946 * Scheduled work for TX/RX done handling (USB devices)
947 */
948 struct work_struct rxdone_work;
949 struct work_struct txdone_work;
950
951 /*
952 * Powersaving work
953 */
954 struct delayed_work autowakeup_work;
955 struct work_struct sleep_work;
956
957 /*
958 * Data queue arrays for RX, TX, Beacon and ATIM.
959 */
960 unsigned int data_queues;
961 struct data_queue *rx;
962 struct data_queue *tx;
963 struct data_queue *bcn;
964 struct data_queue *atim;
965
966 /*
967 * Firmware image.
968 */
969 const struct firmware *fw;
970
971 /*
972 * FIFO for storing tx status reports between isr and tasklet.
973 */
974 DECLARE_KFIFO_PTR(txstatus_fifo, u32);
975
976 /*
977 * Timer to ensure tx status reports are read (rt2800usb).
978 */
979 struct hrtimer txstatus_timer;
980
981 /*
982 * Tasklet for processing tx status reports (rt2800pci).
983 */
984 struct tasklet_struct txstatus_tasklet;
985 struct tasklet_struct pretbtt_tasklet;
986 struct tasklet_struct tbtt_tasklet;
987 struct tasklet_struct rxdone_tasklet;
988 struct tasklet_struct autowake_tasklet;
989
990 /*
991 * Used for VCO periodic calibration.
992 */
993 int rf_channel;
994
995 /*
996 * Protect the interrupt mask register.
997 */
998 spinlock_t irqmask_lock;
999
1000 /*
1001 * List of BlockAckReq TX entries that need driver BlockAck processing.
1002 */
1003 struct list_head bar_list;
1004 spinlock_t bar_list_lock;
1005
1006 /* Extra TX headroom required for alignment purposes. */
1007 unsigned int extra_tx_headroom;
1008
1009 struct usb_anchor *anchor;
1010 unsigned int num_proto_errs;
1011
1012 /* Clock for System On Chip devices. */
1013 struct clk *clk;
1014 };
1015
1016 struct rt2x00_bar_list_entry {
1017 struct list_head list;
1018 struct rcu_head head;
1019
1020 struct queue_entry *entry;
1021 int block_acked;
1022
1023 /* Relevant parts of the IEEE80211 BAR header */
1024 __u8 ra[6];
1025 __u8 ta[6];
1026 __le16 control;
1027 __le16 start_seq_num;
1028 };
1029
1030 /*
1031 * Register defines.
1032 * Some registers require multiple attempts before success,
1033 * in those cases REGISTER_BUSY_COUNT attempts should be
1034 * taken with a REGISTER_BUSY_DELAY interval. Due to USB
1035 * bus delays, we do not have to loop so many times to wait
1036 * for valid register value on that bus.
1037 */
1038 #define REGISTER_BUSY_COUNT 100
1039 #define REGISTER_USB_BUSY_COUNT 20
1040 #define REGISTER_BUSY_DELAY 100
1041
1042 /*
1043 * Generic RF access.
1044 * The RF is being accessed by word index.
1045 */
rt2x00_rf_read(struct rt2x00_dev * rt2x00dev,const unsigned int word)1046 static inline u32 rt2x00_rf_read(struct rt2x00_dev *rt2x00dev,
1047 const unsigned int word)
1048 {
1049 BUG_ON(word < 1 || word > rt2x00dev->ops->rf_size / sizeof(u32));
1050 return rt2x00dev->rf[word - 1];
1051 }
1052
rt2x00_rf_write(struct rt2x00_dev * rt2x00dev,const unsigned int word,u32 data)1053 static inline void rt2x00_rf_write(struct rt2x00_dev *rt2x00dev,
1054 const unsigned int word, u32 data)
1055 {
1056 BUG_ON(word < 1 || word > rt2x00dev->ops->rf_size / sizeof(u32));
1057 rt2x00dev->rf[word - 1] = data;
1058 }
1059
1060 /*
1061 * Generic EEPROM access. The EEPROM is being accessed by word or byte index.
1062 */
rt2x00_eeprom_addr(struct rt2x00_dev * rt2x00dev,const unsigned int word)1063 static inline void *rt2x00_eeprom_addr(struct rt2x00_dev *rt2x00dev,
1064 const unsigned int word)
1065 {
1066 return (void *)&rt2x00dev->eeprom[word];
1067 }
1068
rt2x00_eeprom_read(struct rt2x00_dev * rt2x00dev,const unsigned int word)1069 static inline u16 rt2x00_eeprom_read(struct rt2x00_dev *rt2x00dev,
1070 const unsigned int word)
1071 {
1072 return le16_to_cpu(rt2x00dev->eeprom[word]);
1073 }
1074
rt2x00_eeprom_write(struct rt2x00_dev * rt2x00dev,const unsigned int word,u16 data)1075 static inline void rt2x00_eeprom_write(struct rt2x00_dev *rt2x00dev,
1076 const unsigned int word, u16 data)
1077 {
1078 rt2x00dev->eeprom[word] = cpu_to_le16(data);
1079 }
1080
rt2x00_eeprom_byte(struct rt2x00_dev * rt2x00dev,const unsigned int byte)1081 static inline u8 rt2x00_eeprom_byte(struct rt2x00_dev *rt2x00dev,
1082 const unsigned int byte)
1083 {
1084 return *(((u8 *)rt2x00dev->eeprom) + byte);
1085 }
1086
1087 /*
1088 * Chipset handlers
1089 */
rt2x00_set_chip(struct rt2x00_dev * rt2x00dev,const u16 rt,const u16 rf,const u16 rev)1090 static inline void rt2x00_set_chip(struct rt2x00_dev *rt2x00dev,
1091 const u16 rt, const u16 rf, const u16 rev)
1092 {
1093 rt2x00dev->chip.rt = rt;
1094 rt2x00dev->chip.rf = rf;
1095 rt2x00dev->chip.rev = rev;
1096
1097 rt2x00_info(rt2x00dev, "Chipset detected - rt: %04x, rf: %04x, rev: %04x\n",
1098 rt2x00dev->chip.rt, rt2x00dev->chip.rf,
1099 rt2x00dev->chip.rev);
1100 }
1101
rt2x00_set_rt(struct rt2x00_dev * rt2x00dev,const u16 rt,const u16 rev)1102 static inline void rt2x00_set_rt(struct rt2x00_dev *rt2x00dev,
1103 const u16 rt, const u16 rev)
1104 {
1105 rt2x00dev->chip.rt = rt;
1106 rt2x00dev->chip.rev = rev;
1107
1108 rt2x00_info(rt2x00dev, "RT chipset %04x, rev %04x detected\n",
1109 rt2x00dev->chip.rt, rt2x00dev->chip.rev);
1110 }
1111
rt2x00_set_rf(struct rt2x00_dev * rt2x00dev,const u16 rf)1112 static inline void rt2x00_set_rf(struct rt2x00_dev *rt2x00dev, const u16 rf)
1113 {
1114 rt2x00dev->chip.rf = rf;
1115
1116 rt2x00_info(rt2x00dev, "RF chipset %04x detected\n",
1117 rt2x00dev->chip.rf);
1118 }
1119
rt2x00_rt(struct rt2x00_dev * rt2x00dev,const u16 rt)1120 static inline bool rt2x00_rt(struct rt2x00_dev *rt2x00dev, const u16 rt)
1121 {
1122 return (rt2x00dev->chip.rt == rt);
1123 }
1124
rt2x00_rf(struct rt2x00_dev * rt2x00dev,const u16 rf)1125 static inline bool rt2x00_rf(struct rt2x00_dev *rt2x00dev, const u16 rf)
1126 {
1127 return (rt2x00dev->chip.rf == rf);
1128 }
1129
rt2x00_rev(struct rt2x00_dev * rt2x00dev)1130 static inline u16 rt2x00_rev(struct rt2x00_dev *rt2x00dev)
1131 {
1132 return rt2x00dev->chip.rev;
1133 }
1134
rt2x00_rt_rev(struct rt2x00_dev * rt2x00dev,const u16 rt,const u16 rev)1135 static inline bool rt2x00_rt_rev(struct rt2x00_dev *rt2x00dev,
1136 const u16 rt, const u16 rev)
1137 {
1138 return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) == rev);
1139 }
1140
rt2x00_rt_rev_lt(struct rt2x00_dev * rt2x00dev,const u16 rt,const u16 rev)1141 static inline bool rt2x00_rt_rev_lt(struct rt2x00_dev *rt2x00dev,
1142 const u16 rt, const u16 rev)
1143 {
1144 return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) < rev);
1145 }
1146
rt2x00_rt_rev_gte(struct rt2x00_dev * rt2x00dev,const u16 rt,const u16 rev)1147 static inline bool rt2x00_rt_rev_gte(struct rt2x00_dev *rt2x00dev,
1148 const u16 rt, const u16 rev)
1149 {
1150 return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) >= rev);
1151 }
1152
rt2x00_set_chip_intf(struct rt2x00_dev * rt2x00dev,enum rt2x00_chip_intf intf)1153 static inline void rt2x00_set_chip_intf(struct rt2x00_dev *rt2x00dev,
1154 enum rt2x00_chip_intf intf)
1155 {
1156 rt2x00dev->chip.intf = intf;
1157 }
1158
rt2x00_intf(struct rt2x00_dev * rt2x00dev,enum rt2x00_chip_intf intf)1159 static inline bool rt2x00_intf(struct rt2x00_dev *rt2x00dev,
1160 enum rt2x00_chip_intf intf)
1161 {
1162 return (rt2x00dev->chip.intf == intf);
1163 }
1164
rt2x00_is_pci(struct rt2x00_dev * rt2x00dev)1165 static inline bool rt2x00_is_pci(struct rt2x00_dev *rt2x00dev)
1166 {
1167 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCI) ||
1168 rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE);
1169 }
1170
rt2x00_is_pcie(struct rt2x00_dev * rt2x00dev)1171 static inline bool rt2x00_is_pcie(struct rt2x00_dev *rt2x00dev)
1172 {
1173 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE);
1174 }
1175
rt2x00_is_usb(struct rt2x00_dev * rt2x00dev)1176 static inline bool rt2x00_is_usb(struct rt2x00_dev *rt2x00dev)
1177 {
1178 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_USB);
1179 }
1180
rt2x00_is_soc(struct rt2x00_dev * rt2x00dev)1181 static inline bool rt2x00_is_soc(struct rt2x00_dev *rt2x00dev)
1182 {
1183 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_SOC);
1184 }
1185
1186 /* Helpers for capability flags */
1187
1188 static inline bool
rt2x00_has_cap_flag(struct rt2x00_dev * rt2x00dev,enum rt2x00_capability_flags cap_flag)1189 rt2x00_has_cap_flag(struct rt2x00_dev *rt2x00dev,
1190 enum rt2x00_capability_flags cap_flag)
1191 {
1192 return test_bit(cap_flag, &rt2x00dev->cap_flags);
1193 }
1194
1195 static inline bool
rt2x00_has_cap_hw_crypto(struct rt2x00_dev * rt2x00dev)1196 rt2x00_has_cap_hw_crypto(struct rt2x00_dev *rt2x00dev)
1197 {
1198 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_HW_CRYPTO);
1199 }
1200
1201 static inline bool
rt2x00_has_cap_power_limit(struct rt2x00_dev * rt2x00dev)1202 rt2x00_has_cap_power_limit(struct rt2x00_dev *rt2x00dev)
1203 {
1204 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_POWER_LIMIT);
1205 }
1206
1207 static inline bool
rt2x00_has_cap_control_filters(struct rt2x00_dev * rt2x00dev)1208 rt2x00_has_cap_control_filters(struct rt2x00_dev *rt2x00dev)
1209 {
1210 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_CONTROL_FILTERS);
1211 }
1212
1213 static inline bool
rt2x00_has_cap_control_filter_pspoll(struct rt2x00_dev * rt2x00dev)1214 rt2x00_has_cap_control_filter_pspoll(struct rt2x00_dev *rt2x00dev)
1215 {
1216 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_CONTROL_FILTER_PSPOLL);
1217 }
1218
1219 static inline bool
rt2x00_has_cap_pre_tbtt_interrupt(struct rt2x00_dev * rt2x00dev)1220 rt2x00_has_cap_pre_tbtt_interrupt(struct rt2x00_dev *rt2x00dev)
1221 {
1222 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_PRE_TBTT_INTERRUPT);
1223 }
1224
1225 static inline bool
rt2x00_has_cap_link_tuning(struct rt2x00_dev * rt2x00dev)1226 rt2x00_has_cap_link_tuning(struct rt2x00_dev *rt2x00dev)
1227 {
1228 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_LINK_TUNING);
1229 }
1230
1231 static inline bool
rt2x00_has_cap_frame_type(struct rt2x00_dev * rt2x00dev)1232 rt2x00_has_cap_frame_type(struct rt2x00_dev *rt2x00dev)
1233 {
1234 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_FRAME_TYPE);
1235 }
1236
1237 static inline bool
rt2x00_has_cap_rf_sequence(struct rt2x00_dev * rt2x00dev)1238 rt2x00_has_cap_rf_sequence(struct rt2x00_dev *rt2x00dev)
1239 {
1240 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_RF_SEQUENCE);
1241 }
1242
1243 static inline bool
rt2x00_has_cap_external_lna_a(struct rt2x00_dev * rt2x00dev)1244 rt2x00_has_cap_external_lna_a(struct rt2x00_dev *rt2x00dev)
1245 {
1246 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_EXTERNAL_LNA_A);
1247 }
1248
1249 static inline bool
rt2x00_has_cap_external_lna_bg(struct rt2x00_dev * rt2x00dev)1250 rt2x00_has_cap_external_lna_bg(struct rt2x00_dev *rt2x00dev)
1251 {
1252 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_EXTERNAL_LNA_BG);
1253 }
1254
1255 static inline bool
rt2x00_has_cap_double_antenna(struct rt2x00_dev * rt2x00dev)1256 rt2x00_has_cap_double_antenna(struct rt2x00_dev *rt2x00dev)
1257 {
1258 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_DOUBLE_ANTENNA);
1259 }
1260
1261 static inline bool
rt2x00_has_cap_bt_coexist(struct rt2x00_dev * rt2x00dev)1262 rt2x00_has_cap_bt_coexist(struct rt2x00_dev *rt2x00dev)
1263 {
1264 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_BT_COEXIST);
1265 }
1266
1267 static inline bool
rt2x00_has_cap_vco_recalibration(struct rt2x00_dev * rt2x00dev)1268 rt2x00_has_cap_vco_recalibration(struct rt2x00_dev *rt2x00dev)
1269 {
1270 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_VCO_RECALIBRATION);
1271 }
1272
1273 static inline bool
rt2x00_has_cap_restart_hw(struct rt2x00_dev * rt2x00dev)1274 rt2x00_has_cap_restart_hw(struct rt2x00_dev *rt2x00dev)
1275 {
1276 return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_RESTART_HW);
1277 }
1278
1279 /**
1280 * rt2x00queue_map_txskb - Map a skb into DMA for TX purposes.
1281 * @entry: Pointer to &struct queue_entry
1282 *
1283 * Returns -ENOMEM if mapping fail, 0 otherwise.
1284 */
1285 int rt2x00queue_map_txskb(struct queue_entry *entry);
1286
1287 /**
1288 * rt2x00queue_unmap_skb - Unmap a skb from DMA.
1289 * @entry: Pointer to &struct queue_entry
1290 */
1291 void rt2x00queue_unmap_skb(struct queue_entry *entry);
1292
1293 /**
1294 * rt2x00queue_get_tx_queue - Convert tx queue index to queue pointer
1295 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1296 * @queue: rt2x00 queue index (see &enum data_queue_qid).
1297 *
1298 * Returns NULL for non tx queues.
1299 */
1300 static inline struct data_queue *
rt2x00queue_get_tx_queue(struct rt2x00_dev * rt2x00dev,const enum data_queue_qid queue)1301 rt2x00queue_get_tx_queue(struct rt2x00_dev *rt2x00dev,
1302 const enum data_queue_qid queue)
1303 {
1304 if (queue < rt2x00dev->ops->tx_queues && rt2x00dev->tx)
1305 return &rt2x00dev->tx[queue];
1306
1307 if (queue == QID_ATIM)
1308 return rt2x00dev->atim;
1309
1310 return NULL;
1311 }
1312
1313 /**
1314 * rt2x00queue_get_entry - Get queue entry where the given index points to.
1315 * @queue: Pointer to &struct data_queue from where we obtain the entry.
1316 * @index: Index identifier for obtaining the correct index.
1317 */
1318 struct queue_entry *rt2x00queue_get_entry(struct data_queue *queue,
1319 enum queue_index index);
1320
1321 /**
1322 * rt2x00queue_pause_queue - Pause a data queue
1323 * @queue: Pointer to &struct data_queue.
1324 *
1325 * This function will pause the data queue locally, preventing
1326 * new frames to be added to the queue (while the hardware is
1327 * still allowed to run).
1328 */
1329 void rt2x00queue_pause_queue(struct data_queue *queue);
1330
1331 /**
1332 * rt2x00queue_unpause_queue - unpause a data queue
1333 * @queue: Pointer to &struct data_queue.
1334 *
1335 * This function will unpause the data queue locally, allowing
1336 * new frames to be added to the queue again.
1337 */
1338 void rt2x00queue_unpause_queue(struct data_queue *queue);
1339
1340 /**
1341 * rt2x00queue_start_queue - Start a data queue
1342 * @queue: Pointer to &struct data_queue.
1343 *
1344 * This function will start handling all pending frames in the queue.
1345 */
1346 void rt2x00queue_start_queue(struct data_queue *queue);
1347
1348 /**
1349 * rt2x00queue_stop_queue - Halt a data queue
1350 * @queue: Pointer to &struct data_queue.
1351 *
1352 * This function will stop all pending frames in the queue.
1353 */
1354 void rt2x00queue_stop_queue(struct data_queue *queue);
1355
1356 /**
1357 * rt2x00queue_flush_queue - Flush a data queue
1358 * @queue: Pointer to &struct data_queue.
1359 * @drop: True to drop all pending frames.
1360 *
1361 * This function will flush the queue. After this call
1362 * the queue is guaranteed to be empty.
1363 */
1364 void rt2x00queue_flush_queue(struct data_queue *queue, bool drop);
1365
1366 /**
1367 * rt2x00queue_start_queues - Start all data queues
1368 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1369 *
1370 * This function will loop through all available queues to start them
1371 */
1372 void rt2x00queue_start_queues(struct rt2x00_dev *rt2x00dev);
1373
1374 /**
1375 * rt2x00queue_stop_queues - Halt all data queues
1376 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1377 *
1378 * This function will loop through all available queues to stop
1379 * any pending frames.
1380 */
1381 void rt2x00queue_stop_queues(struct rt2x00_dev *rt2x00dev);
1382
1383 /**
1384 * rt2x00queue_flush_queues - Flush all data queues
1385 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1386 * @drop: True to drop all pending frames.
1387 *
1388 * This function will loop through all available queues to flush
1389 * any pending frames.
1390 */
1391 void rt2x00queue_flush_queues(struct rt2x00_dev *rt2x00dev, bool drop);
1392
1393 /*
1394 * Debugfs handlers.
1395 */
1396 /**
1397 * rt2x00debug_dump_frame - Dump a frame to userspace through debugfs.
1398 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1399 * @type: The type of frame that is being dumped.
1400 * @entry: The queue entry containing the frame to be dumped.
1401 */
1402 #ifdef CONFIG_RT2X00_LIB_DEBUGFS
1403 void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev,
1404 enum rt2x00_dump_type type, struct queue_entry *entry);
1405 #else
rt2x00debug_dump_frame(struct rt2x00_dev * rt2x00dev,enum rt2x00_dump_type type,struct queue_entry * entry)1406 static inline void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev,
1407 enum rt2x00_dump_type type,
1408 struct queue_entry *entry)
1409 {
1410 }
1411 #endif /* CONFIG_RT2X00_LIB_DEBUGFS */
1412
1413 /*
1414 * Utility functions.
1415 */
1416 u32 rt2x00lib_get_bssidx(struct rt2x00_dev *rt2x00dev,
1417 struct ieee80211_vif *vif);
1418 void rt2x00lib_set_mac_address(struct rt2x00_dev *rt2x00dev, u8 *eeprom_mac_addr);
1419
1420 /*
1421 * Interrupt context handlers.
1422 */
1423 void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev);
1424 void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev);
1425 void rt2x00lib_dmastart(struct queue_entry *entry);
1426 void rt2x00lib_dmadone(struct queue_entry *entry);
1427 void rt2x00lib_txdone(struct queue_entry *entry,
1428 struct txdone_entry_desc *txdesc);
1429 void rt2x00lib_txdone_nomatch(struct queue_entry *entry,
1430 struct txdone_entry_desc *txdesc);
1431 void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status);
1432 void rt2x00lib_rxdone(struct queue_entry *entry, gfp_t gfp);
1433
1434 /*
1435 * mac80211 handlers.
1436 */
1437 void rt2x00mac_tx(struct ieee80211_hw *hw,
1438 struct ieee80211_tx_control *control,
1439 struct sk_buff *skb);
1440 int rt2x00mac_start(struct ieee80211_hw *hw);
1441 void rt2x00mac_stop(struct ieee80211_hw *hw);
1442 int rt2x00mac_add_interface(struct ieee80211_hw *hw,
1443 struct ieee80211_vif *vif);
1444 void rt2x00mac_remove_interface(struct ieee80211_hw *hw,
1445 struct ieee80211_vif *vif);
1446 int rt2x00mac_config(struct ieee80211_hw *hw, u32 changed);
1447 void rt2x00mac_configure_filter(struct ieee80211_hw *hw,
1448 unsigned int changed_flags,
1449 unsigned int *total_flags,
1450 u64 multicast);
1451 int rt2x00mac_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
1452 bool set);
1453 #ifdef CONFIG_RT2X00_LIB_CRYPTO
1454 int rt2x00mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1455 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
1456 struct ieee80211_key_conf *key);
1457 #else
1458 #define rt2x00mac_set_key NULL
1459 #endif /* CONFIG_RT2X00_LIB_CRYPTO */
1460 void rt2x00mac_sw_scan_start(struct ieee80211_hw *hw,
1461 struct ieee80211_vif *vif,
1462 const u8 *mac_addr);
1463 void rt2x00mac_sw_scan_complete(struct ieee80211_hw *hw,
1464 struct ieee80211_vif *vif);
1465 int rt2x00mac_get_stats(struct ieee80211_hw *hw,
1466 struct ieee80211_low_level_stats *stats);
1467 void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw,
1468 struct ieee80211_vif *vif,
1469 struct ieee80211_bss_conf *bss_conf,
1470 u32 changes);
1471 int rt2x00mac_conf_tx(struct ieee80211_hw *hw,
1472 struct ieee80211_vif *vif, u16 queue,
1473 const struct ieee80211_tx_queue_params *params);
1474 void rt2x00mac_rfkill_poll(struct ieee80211_hw *hw);
1475 void rt2x00mac_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1476 u32 queues, bool drop);
1477 int rt2x00mac_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant);
1478 int rt2x00mac_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant);
1479 void rt2x00mac_get_ringparam(struct ieee80211_hw *hw,
1480 u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max);
1481 bool rt2x00mac_tx_frames_pending(struct ieee80211_hw *hw);
1482
1483 /*
1484 * Driver allocation handlers.
1485 */
1486 int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev);
1487 void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev);
1488 #ifdef CONFIG_PM
1489 int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state);
1490 int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev);
1491 #endif /* CONFIG_PM */
1492
1493 #endif /* RT2X00_H */
1494
