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