rt2x00.h revision fa69560f317d961c56e29dea788b346d2b34fb87 
1/*
2	Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
3	Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com>
4	Copyright (C) 2004 - 2009 Gertjan van Wingerde <gwingerde@gmail.com>
5	<http://rt2x00.serialmonkey.com>
6
7	This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or
10	(at your option) any later version.
11
12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.
16
17	You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the
19	Free Software Foundation, Inc.,
20	59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 */
22
23/*
24	Module: rt2x00
25	Abstract: rt2x00 global information.
26 */
27
28#ifndef RT2X00_H
29#define RT2X00_H
30
31#include <linux/bitops.h>
32#include <linux/skbuff.h>
33#include <linux/workqueue.h>
34#include <linux/firmware.h>
35#include <linux/leds.h>
36#include <linux/mutex.h>
37#include <linux/etherdevice.h>
38#include <linux/input-polldev.h>
39#include <linux/kfifo.h>
40
41#include <net/mac80211.h>
42
43#include "rt2x00debug.h"
44#include "rt2x00dump.h"
45#include "rt2x00leds.h"
46#include "rt2x00reg.h"
47#include "rt2x00queue.h"
48
49/*
50 * Module information.
51 */
52#define DRV_VERSION	"2.3.0"
53#define DRV_PROJECT	"http://rt2x00.serialmonkey.com"
54
55/*
56 * Debug definitions.
57 * Debug output has to be enabled during compile time.
58 */
59#define DEBUG_PRINTK_MSG(__dev, __kernlvl, __lvl, __msg, __args...)	\
60	printk(__kernlvl "%s -> %s: %s - " __msg,			\
61	       wiphy_name((__dev)->hw->wiphy), __func__, __lvl, ##__args)
62
63#define DEBUG_PRINTK_PROBE(__kernlvl, __lvl, __msg, __args...)	\
64	printk(__kernlvl "%s -> %s: %s - " __msg,		\
65	       KBUILD_MODNAME, __func__, __lvl, ##__args)
66
67#ifdef CONFIG_RT2X00_DEBUG
68#define DEBUG_PRINTK(__dev, __kernlvl, __lvl, __msg, __args...)	\
69	DEBUG_PRINTK_MSG(__dev, __kernlvl, __lvl, __msg, ##__args);
70#else
71#define DEBUG_PRINTK(__dev, __kernlvl, __lvl, __msg, __args...)	\
72	do { } while (0)
73#endif /* CONFIG_RT2X00_DEBUG */
74
75/*
76 * Various debug levels.
77 * The debug levels PANIC and ERROR both indicate serious problems,
78 * for this reason they should never be ignored.
79 * The special ERROR_PROBE message is for messages that are generated
80 * when the rt2x00_dev is not yet initialized.
81 */
82#define PANIC(__dev, __msg, __args...) \
83	DEBUG_PRINTK_MSG(__dev, KERN_CRIT, "Panic", __msg, ##__args)
84#define ERROR(__dev, __msg, __args...)	\
85	DEBUG_PRINTK_MSG(__dev, KERN_ERR, "Error", __msg, ##__args)
86#define ERROR_PROBE(__msg, __args...) \
87	DEBUG_PRINTK_PROBE(KERN_ERR, "Error", __msg, ##__args)
88#define WARNING(__dev, __msg, __args...) \
89	DEBUG_PRINTK(__dev, KERN_WARNING, "Warning", __msg, ##__args)
90#define NOTICE(__dev, __msg, __args...) \
91	DEBUG_PRINTK(__dev, KERN_NOTICE, "Notice", __msg, ##__args)
92#define INFO(__dev, __msg, __args...) \
93	DEBUG_PRINTK(__dev, KERN_INFO, "Info", __msg, ##__args)
94#define DEBUG(__dev, __msg, __args...) \
95	DEBUG_PRINTK(__dev, KERN_DEBUG, "Debug", __msg, ##__args)
96#define EEPROM(__dev, __msg, __args...) \
97	DEBUG_PRINTK(__dev, KERN_DEBUG, "EEPROM recovery", __msg, ##__args)
98
99/*
100 * Duration calculations
101 * The rate variable passed is: 100kbs.
102 * To convert from bytes to bits we multiply size with 8,
103 * then the size is multiplied with 10 to make the
104 * real rate -> rate argument correction.
105 */
106#define GET_DURATION(__size, __rate)	(((__size) * 8 * 10) / (__rate))
107#define GET_DURATION_RES(__size, __rate)(((__size) * 8 * 10) % (__rate))
108
109/*
110 * Determine the number of L2 padding bytes required between the header and
111 * the payload.
112 */
113#define L2PAD_SIZE(__hdrlen)	(-(__hdrlen) & 3)
114
115/*
116 * Determine the alignment requirement,
117 * to make sure the 802.11 payload is padded to a 4-byte boundrary
118 * we must determine the address of the payload and calculate the
119 * amount of bytes needed to move the data.
120 */
121#define ALIGN_SIZE(__skb, __header) \
122	(  ((unsigned long)((__skb)->data + (__header))) & 3 )
123
124/*
125 * Constants for extra TX headroom for alignment purposes.
126 */
127#define RT2X00_ALIGN_SIZE	4 /* Only whole frame needs alignment */
128#define RT2X00_L2PAD_SIZE	8 /* Both header & payload need alignment */
129
130/*
131 * Standard timing and size defines.
132 * These values should follow the ieee80211 specifications.
133 */
134#define ACK_SIZE		14
135#define IEEE80211_HEADER	24
136#define PLCP			48
137#define BEACON			100
138#define PREAMBLE		144
139#define SHORT_PREAMBLE		72
140#define SLOT_TIME		20
141#define SHORT_SLOT_TIME		9
142#define SIFS			10
143#define PIFS			( SIFS + SLOT_TIME )
144#define SHORT_PIFS		( SIFS + SHORT_SLOT_TIME )
145#define DIFS			( PIFS + SLOT_TIME )
146#define SHORT_DIFS		( SHORT_PIFS + SHORT_SLOT_TIME )
147#define EIFS			( SIFS + DIFS + \
148				  GET_DURATION(IEEE80211_HEADER + ACK_SIZE, 10) )
149#define SHORT_EIFS		( SIFS + SHORT_DIFS + \
150				  GET_DURATION(IEEE80211_HEADER + ACK_SIZE, 10) )
151
152/*
153 * Structure for average calculation
154 * The avg field contains the actual average value,
155 * but avg_weight is internally used during calculations
156 * to prevent rounding errors.
157 */
158struct avg_val {
159	int avg;
160	int avg_weight;
161};
162
163enum rt2x00_chip_intf {
164	RT2X00_CHIP_INTF_PCI,
165	RT2X00_CHIP_INTF_PCIE,
166	RT2X00_CHIP_INTF_USB,
167	RT2X00_CHIP_INTF_SOC,
168};
169
170/*
171 * Chipset identification
172 * The chipset on the device is composed of a RT and RF chip.
173 * The chipset combination is important for determining device capabilities.
174 */
175struct rt2x00_chip {
176	u16 rt;
177#define RT2460		0x2460
178#define RT2560		0x2560
179#define RT2570		0x2570
180#define RT2661		0x2661
181#define RT2573		0x2573
182#define RT2860		0x2860	/* 2.4GHz */
183#define RT2872		0x2872	/* WSOC */
184#define RT2883		0x2883	/* WSOC */
185#define RT3070		0x3070
186#define RT3071		0x3071
187#define RT3090		0x3090	/* 2.4GHz PCIe */
188#define RT3390		0x3390
189#define RT3572		0x3572
190#define RT3593		0x3593	/* PCIe */
191#define RT3883		0x3883	/* WSOC */
192
193	u16 rf;
194	u16 rev;
195
196	enum rt2x00_chip_intf intf;
197};
198
199/*
200 * RF register values that belong to a particular channel.
201 */
202struct rf_channel {
203	int channel;
204	u32 rf1;
205	u32 rf2;
206	u32 rf3;
207	u32 rf4;
208};
209
210/*
211 * Channel information structure
212 */
213struct channel_info {
214	unsigned int flags;
215#define GEOGRAPHY_ALLOWED	0x00000001
216
217	short max_power;
218	short default_power1;
219	short default_power2;
220};
221
222/*
223 * Antenna setup values.
224 */
225struct antenna_setup {
226	enum antenna rx;
227	enum antenna tx;
228};
229
230/*
231 * Quality statistics about the currently active link.
232 */
233struct link_qual {
234	/*
235	 * Statistics required for Link tuning by driver
236	 * The rssi value is provided by rt2x00lib during the
237	 * link_tuner() callback function.
238	 * The false_cca field is filled during the link_stats()
239	 * callback function and could be used during the
240	 * link_tuner() callback function.
241	 */
242	int rssi;
243	int false_cca;
244
245	/*
246	 * VGC levels
247	 * Hardware driver will tune the VGC level during each call
248	 * to the link_tuner() callback function. This vgc_level is
249	 * is determined based on the link quality statistics like
250	 * average RSSI and the false CCA count.
251	 *
252	 * In some cases the drivers need to differentiate between
253	 * the currently "desired" VGC level and the level configured
254	 * in the hardware. The latter is important to reduce the
255	 * number of BBP register reads to reduce register access
256	 * overhead. For this reason we store both values here.
257	 */
258	u8 vgc_level;
259	u8 vgc_level_reg;
260
261	/*
262	 * Statistics required for Signal quality calculation.
263	 * These fields might be changed during the link_stats()
264	 * callback function.
265	 */
266	int rx_success;
267	int rx_failed;
268	int tx_success;
269	int tx_failed;
270};
271
272/*
273 * Antenna settings about the currently active link.
274 */
275struct link_ant {
276	/*
277	 * Antenna flags
278	 */
279	unsigned int flags;
280#define ANTENNA_RX_DIVERSITY	0x00000001
281#define ANTENNA_TX_DIVERSITY	0x00000002
282#define ANTENNA_MODE_SAMPLE	0x00000004
283
284	/*
285	 * Currently active TX/RX antenna setup.
286	 * When software diversity is used, this will indicate
287	 * which antenna is actually used at this time.
288	 */
289	struct antenna_setup active;
290
291	/*
292	 * RSSI history information for the antenna.
293	 * Used to determine when to switch antenna
294	 * when using software diversity.
295	 */
296	int rssi_history;
297
298	/*
299	 * Current RSSI average of the currently active antenna.
300	 * Similar to the avg_rssi in the link_qual structure
301	 * this value is updated by using the walking average.
302	 */
303	struct avg_val rssi_ant;
304};
305
306/*
307 * To optimize the quality of the link we need to store
308 * the quality of received frames and periodically
309 * optimize the link.
310 */
311struct link {
312	/*
313	 * Link tuner counter
314	 * The number of times the link has been tuned
315	 * since the radio has been switched on.
316	 */
317	u32 count;
318
319	/*
320	 * Quality measurement values.
321	 */
322	struct link_qual qual;
323
324	/*
325	 * TX/RX antenna setup.
326	 */
327	struct link_ant ant;
328
329	/*
330	 * Currently active average RSSI value
331	 */
332	struct avg_val avg_rssi;
333
334	/*
335	 * Work structure for scheduling periodic link tuning.
336	 */
337	struct delayed_work work;
338
339	/*
340	 * Work structure for scheduling periodic watchdog monitoring.
341	 */
342	struct delayed_work watchdog_work;
343};
344
345/*
346 * Interface structure
347 * Per interface configuration details, this structure
348 * is allocated as the private data for ieee80211_vif.
349 */
350struct rt2x00_intf {
351	/*
352	 * All fields within the rt2x00_intf structure
353	 * must be protected with a spinlock.
354	 */
355	spinlock_t lock;
356
357	/*
358	 * MAC of the device.
359	 */
360	u8 mac[ETH_ALEN];
361
362	/*
363	 * BBSID of the AP to associate with.
364	 */
365	u8 bssid[ETH_ALEN];
366
367	/*
368	 * beacon->skb must be protected with the mutex.
369	 */
370	struct mutex beacon_skb_mutex;
371
372	/*
373	 * Entry in the beacon queue which belongs to
374	 * this interface. Each interface has its own
375	 * dedicated beacon entry.
376	 */
377	struct queue_entry *beacon;
378
379	/*
380	 * Actions that needed rescheduling.
381	 */
382	unsigned int delayed_flags;
383#define DELAYED_UPDATE_BEACON		0x00000001
384
385	/*
386	 * Software sequence counter, this is only required
387	 * for hardware which doesn't support hardware
388	 * sequence counting.
389	 */
390	spinlock_t seqlock;
391	u16 seqno;
392};
393
394static inline struct rt2x00_intf* vif_to_intf(struct ieee80211_vif *vif)
395{
396	return (struct rt2x00_intf *)vif->drv_priv;
397}
398
399/**
400 * struct hw_mode_spec: Hardware specifications structure
401 *
402 * Details about the supported modes, rates and channels
403 * of a particular chipset. This is used by rt2x00lib
404 * to build the ieee80211_hw_mode array for mac80211.
405 *
406 * @supported_bands: Bitmask contained the supported bands (2.4GHz, 5.2GHz).
407 * @supported_rates: Rate types which are supported (CCK, OFDM).
408 * @num_channels: Number of supported channels. This is used as array size
409 *	for @tx_power_a, @tx_power_bg and @channels.
410 * @channels: Device/chipset specific channel values (See &struct rf_channel).
411 * @channels_info: Additional information for channels (See &struct channel_info).
412 * @ht: Driver HT Capabilities (See &ieee80211_sta_ht_cap).
413 */
414struct hw_mode_spec {
415	unsigned int supported_bands;
416#define SUPPORT_BAND_2GHZ	0x00000001
417#define SUPPORT_BAND_5GHZ	0x00000002
418
419	unsigned int supported_rates;
420#define SUPPORT_RATE_CCK	0x00000001
421#define SUPPORT_RATE_OFDM	0x00000002
422
423	unsigned int num_channels;
424	const struct rf_channel *channels;
425	const struct channel_info *channels_info;
426
427	struct ieee80211_sta_ht_cap ht;
428};
429
430/*
431 * Configuration structure wrapper around the
432 * mac80211 configuration structure.
433 * When mac80211 configures the driver, rt2x00lib
434 * can precalculate values which are equal for all
435 * rt2x00 drivers. Those values can be stored in here.
436 */
437struct rt2x00lib_conf {
438	struct ieee80211_conf *conf;
439
440	struct rf_channel rf;
441	struct channel_info channel;
442};
443
444/*
445 * Configuration structure for erp settings.
446 */
447struct rt2x00lib_erp {
448	int short_preamble;
449	int cts_protection;
450
451	u32 basic_rates;
452
453	int slot_time;
454
455	short sifs;
456	short pifs;
457	short difs;
458	short eifs;
459
460	u16 beacon_int;
461	u16 ht_opmode;
462};
463
464/*
465 * Configuration structure for hardware encryption.
466 */
467struct rt2x00lib_crypto {
468	enum cipher cipher;
469
470	enum set_key_cmd cmd;
471	const u8 *address;
472
473	u32 bssidx;
474	u32 aid;
475
476	u8 key[16];
477	u8 tx_mic[8];
478	u8 rx_mic[8];
479};
480
481/*
482 * Configuration structure wrapper around the
483 * rt2x00 interface configuration handler.
484 */
485struct rt2x00intf_conf {
486	/*
487	 * Interface type
488	 */
489	enum nl80211_iftype type;
490
491	/*
492	 * TSF sync value, this is dependant on the operation type.
493	 */
494	enum tsf_sync sync;
495
496	/*
497	 * The MAC and BSSID addressess are simple array of bytes,
498	 * these arrays are little endian, so when sending the addressess
499	 * to the drivers, copy the it into a endian-signed variable.
500	 *
501	 * Note that all devices (except rt2500usb) have 32 bits
502	 * register word sizes. This means that whatever variable we
503	 * pass _must_ be a multiple of 32 bits. Otherwise the device
504	 * might not accept what we are sending to it.
505	 * This will also make it easier for the driver to write
506	 * the data to the device.
507	 */
508	__le32 mac[2];
509	__le32 bssid[2];
510};
511
512/*
513 * rt2x00lib callback functions.
514 */
515struct rt2x00lib_ops {
516	/*
517	 * Interrupt handlers.
518	 */
519	irq_handler_t irq_handler;
520
521	/*
522	 * Threaded Interrupt handlers.
523	 */
524	irq_handler_t irq_handler_thread;
525
526	/*
527	 * TX status tasklet handler.
528	 */
529	void (*txstatus_tasklet) (unsigned long data);
530
531	/*
532	 * Device init handlers.
533	 */
534	int (*probe_hw) (struct rt2x00_dev *rt2x00dev);
535	char *(*get_firmware_name) (struct rt2x00_dev *rt2x00dev);
536	int (*check_firmware) (struct rt2x00_dev *rt2x00dev,
537			       const u8 *data, const size_t len);
538	int (*load_firmware) (struct rt2x00_dev *rt2x00dev,
539			      const u8 *data, const size_t len);
540
541	/*
542	 * Device initialization/deinitialization handlers.
543	 */
544	int (*initialize) (struct rt2x00_dev *rt2x00dev);
545	void (*uninitialize) (struct rt2x00_dev *rt2x00dev);
546
547	/*
548	 * queue initialization handlers
549	 */
550	bool (*get_entry_state) (struct queue_entry *entry);
551	void (*clear_entry) (struct queue_entry *entry);
552
553	/*
554	 * Radio control handlers.
555	 */
556	int (*set_device_state) (struct rt2x00_dev *rt2x00dev,
557				 enum dev_state state);
558	int (*rfkill_poll) (struct rt2x00_dev *rt2x00dev);
559	void (*link_stats) (struct rt2x00_dev *rt2x00dev,
560			    struct link_qual *qual);
561	void (*reset_tuner) (struct rt2x00_dev *rt2x00dev,
562			     struct link_qual *qual);
563	void (*link_tuner) (struct rt2x00_dev *rt2x00dev,
564			    struct link_qual *qual, const u32 count);
565	void (*watchdog) (struct rt2x00_dev *rt2x00dev);
566
567	/*
568	 * TX control handlers
569	 */
570	void (*write_tx_desc) (struct queue_entry *entry,
571			       struct txentry_desc *txdesc);
572	void (*write_tx_data) (struct queue_entry *entry,
573			       struct txentry_desc *txdesc);
574	void (*write_beacon) (struct queue_entry *entry,
575			      struct txentry_desc *txdesc);
576	int (*get_tx_data_len) (struct queue_entry *entry);
577	void (*kick_tx_queue) (struct data_queue *queue);
578	void (*kill_tx_queue) (struct data_queue *queue);
579
580	/*
581	 * RX control handlers
582	 */
583	void (*fill_rxdone) (struct queue_entry *entry,
584			     struct rxdone_entry_desc *rxdesc);
585
586	/*
587	 * Configuration handlers.
588	 */
589	int (*config_shared_key) (struct rt2x00_dev *rt2x00dev,
590				  struct rt2x00lib_crypto *crypto,
591				  struct ieee80211_key_conf *key);
592	int (*config_pairwise_key) (struct rt2x00_dev *rt2x00dev,
593				    struct rt2x00lib_crypto *crypto,
594				    struct ieee80211_key_conf *key);
595	void (*config_filter) (struct rt2x00_dev *rt2x00dev,
596			       const unsigned int filter_flags);
597	void (*config_intf) (struct rt2x00_dev *rt2x00dev,
598			     struct rt2x00_intf *intf,
599			     struct rt2x00intf_conf *conf,
600			     const unsigned int flags);
601#define CONFIG_UPDATE_TYPE		( 1 << 1 )
602#define CONFIG_UPDATE_MAC		( 1 << 2 )
603#define CONFIG_UPDATE_BSSID		( 1 << 3 )
604
605	void (*config_erp) (struct rt2x00_dev *rt2x00dev,
606			    struct rt2x00lib_erp *erp,
607			    u32 changed);
608	void (*config_ant) (struct rt2x00_dev *rt2x00dev,
609			    struct antenna_setup *ant);
610	void (*config) (struct rt2x00_dev *rt2x00dev,
611			struct rt2x00lib_conf *libconf,
612			const unsigned int changed_flags);
613};
614
615/*
616 * rt2x00 driver callback operation structure.
617 */
618struct rt2x00_ops {
619	const char *name;
620	const unsigned int max_sta_intf;
621	const unsigned int max_ap_intf;
622	const unsigned int eeprom_size;
623	const unsigned int rf_size;
624	const unsigned int tx_queues;
625	const unsigned int extra_tx_headroom;
626	const struct data_queue_desc *rx;
627	const struct data_queue_desc *tx;
628	const struct data_queue_desc *bcn;
629	const struct data_queue_desc *atim;
630	const struct rt2x00lib_ops *lib;
631	const void *drv;
632	const struct ieee80211_ops *hw;
633#ifdef CONFIG_RT2X00_LIB_DEBUGFS
634	const struct rt2x00debug *debugfs;
635#endif /* CONFIG_RT2X00_LIB_DEBUGFS */
636};
637
638/*
639 * rt2x00 device flags
640 */
641enum rt2x00_flags {
642	/*
643	 * Device state flags
644	 */
645	DEVICE_STATE_PRESENT,
646	DEVICE_STATE_REGISTERED_HW,
647	DEVICE_STATE_INITIALIZED,
648	DEVICE_STATE_STARTED,
649	DEVICE_STATE_ENABLED_RADIO,
650	DEVICE_STATE_SCANNING,
651
652	/*
653	 * Driver requirements
654	 */
655	DRIVER_REQUIRE_FIRMWARE,
656	DRIVER_REQUIRE_BEACON_GUARD,
657	DRIVER_REQUIRE_ATIM_QUEUE,
658	DRIVER_REQUIRE_DMA,
659	DRIVER_REQUIRE_COPY_IV,
660	DRIVER_REQUIRE_L2PAD,
661	DRIVER_REQUIRE_TXSTATUS_FIFO,
662
663	/*
664	 * Driver features
665	 */
666	CONFIG_SUPPORT_HW_BUTTON,
667	CONFIG_SUPPORT_HW_CRYPTO,
668	DRIVER_SUPPORT_CONTROL_FILTERS,
669	DRIVER_SUPPORT_CONTROL_FILTER_PSPOLL,
670	DRIVER_SUPPORT_PRE_TBTT_INTERRUPT,
671	DRIVER_SUPPORT_LINK_TUNING,
672	DRIVER_SUPPORT_WATCHDOG,
673
674	/*
675	 * Driver configuration
676	 */
677	CONFIG_FRAME_TYPE,
678	CONFIG_RF_SEQUENCE,
679	CONFIG_EXTERNAL_LNA_A,
680	CONFIG_EXTERNAL_LNA_BG,
681	CONFIG_DOUBLE_ANTENNA,
682	CONFIG_CHANNEL_HT40,
683};
684
685/*
686 * rt2x00 device structure.
687 */
688struct rt2x00_dev {
689	/*
690	 * Device structure.
691	 * The structure stored in here depends on the
692	 * system bus (PCI or USB).
693	 * When accessing this variable, the rt2x00dev_{pci,usb}
694	 * macros should be used for correct typecasting.
695	 */
696	struct device *dev;
697
698	/*
699	 * Callback functions.
700	 */
701	const struct rt2x00_ops *ops;
702
703	/*
704	 * IEEE80211 control structure.
705	 */
706	struct ieee80211_hw *hw;
707	struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
708	enum ieee80211_band curr_band;
709	int curr_freq;
710
711	/*
712	 * If enabled, the debugfs interface structures
713	 * required for deregistration of debugfs.
714	 */
715#ifdef CONFIG_RT2X00_LIB_DEBUGFS
716	struct rt2x00debug_intf *debugfs_intf;
717#endif /* CONFIG_RT2X00_LIB_DEBUGFS */
718
719	/*
720	 * LED structure for changing the LED status
721	 * by mac8011 or the kernel.
722	 */
723#ifdef CONFIG_RT2X00_LIB_LEDS
724	struct rt2x00_led led_radio;
725	struct rt2x00_led led_assoc;
726	struct rt2x00_led led_qual;
727	u16 led_mcu_reg;
728#endif /* CONFIG_RT2X00_LIB_LEDS */
729
730	/*
731	 * Device flags.
732	 * In these flags the current status and some
733	 * of the device capabilities are stored.
734	 */
735	unsigned long flags;
736
737	/*
738	 * Device information, Bus IRQ and name (PCI, SoC)
739	 */
740	int irq;
741	const char *name;
742
743	/*
744	 * Chipset identification.
745	 */
746	struct rt2x00_chip chip;
747
748	/*
749	 * hw capability specifications.
750	 */
751	struct hw_mode_spec spec;
752
753	/*
754	 * This is the default TX/RX antenna setup as indicated
755	 * by the device's EEPROM.
756	 */
757	struct antenna_setup default_ant;
758
759	/*
760	 * Register pointers
761	 * csr.base: CSR base register address. (PCI)
762	 * csr.cache: CSR cache for usb_control_msg. (USB)
763	 */
764	union csr {
765		void __iomem *base;
766		void *cache;
767	} csr;
768
769	/*
770	 * Mutex to protect register accesses.
771	 * For PCI and USB devices it protects against concurrent indirect
772	 * register access (BBP, RF, MCU) since accessing those
773	 * registers require multiple calls to the CSR registers.
774	 * For USB devices it also protects the csr_cache since that
775	 * field is used for normal CSR access and it cannot support
776	 * multiple callers simultaneously.
777	 */
778	struct mutex csr_mutex;
779
780	/*
781	 * Current packet filter configuration for the device.
782	 * This contains all currently active FIF_* flags send
783	 * to us by mac80211 during configure_filter().
784	 */
785	unsigned int packet_filter;
786
787	/*
788	 * Interface details:
789	 *  - Open ap interface count.
790	 *  - Open sta interface count.
791	 *  - Association count.
792	 */
793	unsigned int intf_ap_count;
794	unsigned int intf_sta_count;
795	unsigned int intf_associated;
796
797	/*
798	 * Link quality
799	 */
800	struct link link;
801
802	/*
803	 * EEPROM data.
804	 */
805	__le16 *eeprom;
806
807	/*
808	 * Active RF register values.
809	 * These are stored here so we don't need
810	 * to read the rf registers and can directly
811	 * use this value instead.
812	 * This field should be accessed by using
813	 * rt2x00_rf_read() and rt2x00_rf_write().
814	 */
815	u32 *rf;
816
817	/*
818	 * LNA gain
819	 */
820	short lna_gain;
821
822	/*
823	 * Current TX power value.
824	 */
825	u16 tx_power;
826
827	/*
828	 * Current retry values.
829	 */
830	u8 short_retry;
831	u8 long_retry;
832
833	/*
834	 * Rssi <-> Dbm offset
835	 */
836	u8 rssi_offset;
837
838	/*
839	 * Frequency offset (for rt61pci & rt73usb).
840	 */
841	u8 freq_offset;
842
843	/*
844	 * Calibration information (for rt2800usb & rt2800pci).
845	 * [0] -> BW20
846	 * [1] -> BW40
847	 */
848	u8 calibration[2];
849
850	/*
851	 * Beacon interval.
852	 */
853	u16 beacon_int;
854
855	/*
856	 * Low level statistics which will have
857	 * to be kept up to date while device is running.
858	 */
859	struct ieee80211_low_level_stats low_level_stats;
860
861	/*
862	 * Scheduled work.
863	 * NOTE: intf_work will use ieee80211_iterate_active_interfaces()
864	 * which means it cannot be placed on the hw->workqueue
865	 * due to RTNL locking requirements.
866	 */
867	struct work_struct intf_work;
868
869	/**
870	 * Scheduled work for TX/RX done handling (USB devices)
871	 */
872	struct work_struct rxdone_work;
873	struct work_struct txdone_work;
874
875	/*
876	 * Data queue arrays for RX, TX and Beacon.
877	 * The Beacon array also contains the Atim queue
878	 * if that is supported by the device.
879	 */
880	unsigned int data_queues;
881	struct data_queue *rx;
882	struct data_queue *tx;
883	struct data_queue *bcn;
884
885	/*
886	 * Firmware image.
887	 */
888	const struct firmware *fw;
889
890	/*
891	 * Interrupt values, stored between interrupt service routine
892	 * and interrupt thread routine.
893	 */
894	u32 irqvalue[2];
895
896	/*
897	 * FIFO for storing tx status reports between isr and tasklet.
898	 */
899	struct kfifo txstatus_fifo;
900
901	/*
902	 * Tasklet for processing tx status reports (rt2800pci).
903	 */
904	struct tasklet_struct txstatus_tasklet;
905};
906
907/*
908 * Register defines.
909 * Some registers require multiple attempts before success,
910 * in those cases REGISTER_BUSY_COUNT attempts should be
911 * taken with a REGISTER_BUSY_DELAY interval.
912 */
913#define REGISTER_BUSY_COUNT	5
914#define REGISTER_BUSY_DELAY	100
915
916/*
917 * Generic RF access.
918 * The RF is being accessed by word index.
919 */
920static inline void rt2x00_rf_read(struct rt2x00_dev *rt2x00dev,
921				  const unsigned int word, u32 *data)
922{
923	BUG_ON(word < 1 || word > rt2x00dev->ops->rf_size / sizeof(u32));
924	*data = rt2x00dev->rf[word - 1];
925}
926
927static inline void rt2x00_rf_write(struct rt2x00_dev *rt2x00dev,
928				   const unsigned int word, u32 data)
929{
930	BUG_ON(word < 1 || word > rt2x00dev->ops->rf_size / sizeof(u32));
931	rt2x00dev->rf[word - 1] = data;
932}
933
934/*
935 *  Generic EEPROM access.
936 * The EEPROM is being accessed by word index.
937 */
938static inline void *rt2x00_eeprom_addr(struct rt2x00_dev *rt2x00dev,
939				       const unsigned int word)
940{
941	return (void *)&rt2x00dev->eeprom[word];
942}
943
944static inline void rt2x00_eeprom_read(struct rt2x00_dev *rt2x00dev,
945				      const unsigned int word, u16 *data)
946{
947	*data = le16_to_cpu(rt2x00dev->eeprom[word]);
948}
949
950static inline void rt2x00_eeprom_write(struct rt2x00_dev *rt2x00dev,
951				       const unsigned int word, u16 data)
952{
953	rt2x00dev->eeprom[word] = cpu_to_le16(data);
954}
955
956/*
957 * Chipset handlers
958 */
959static inline void rt2x00_set_chip(struct rt2x00_dev *rt2x00dev,
960				   const u16 rt, const u16 rf, const u16 rev)
961{
962	rt2x00dev->chip.rt = rt;
963	rt2x00dev->chip.rf = rf;
964	rt2x00dev->chip.rev = rev;
965
966	INFO(rt2x00dev,
967	     "Chipset detected - rt: %04x, rf: %04x, rev: %04x.\n",
968	     rt2x00dev->chip.rt, rt2x00dev->chip.rf, rt2x00dev->chip.rev);
969}
970
971static inline bool rt2x00_rt(struct rt2x00_dev *rt2x00dev, const u16 rt)
972{
973	return (rt2x00dev->chip.rt == rt);
974}
975
976static inline bool rt2x00_rf(struct rt2x00_dev *rt2x00dev, const u16 rf)
977{
978	return (rt2x00dev->chip.rf == rf);
979}
980
981static inline u16 rt2x00_rev(struct rt2x00_dev *rt2x00dev)
982{
983	return rt2x00dev->chip.rev;
984}
985
986static inline bool rt2x00_rt_rev(struct rt2x00_dev *rt2x00dev,
987				 const u16 rt, const u16 rev)
988{
989	return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) == rev);
990}
991
992static inline bool rt2x00_rt_rev_lt(struct rt2x00_dev *rt2x00dev,
993				    const u16 rt, const u16 rev)
994{
995	return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) < rev);
996}
997
998static inline bool rt2x00_rt_rev_gte(struct rt2x00_dev *rt2x00dev,
999				     const u16 rt, const u16 rev)
1000{
1001	return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) >= rev);
1002}
1003
1004static inline void rt2x00_set_chip_intf(struct rt2x00_dev *rt2x00dev,
1005					enum rt2x00_chip_intf intf)
1006{
1007	rt2x00dev->chip.intf = intf;
1008}
1009
1010static inline bool rt2x00_intf(struct rt2x00_dev *rt2x00dev,
1011			       enum rt2x00_chip_intf intf)
1012{
1013	return (rt2x00dev->chip.intf == intf);
1014}
1015
1016static inline bool rt2x00_is_pci(struct rt2x00_dev *rt2x00dev)
1017{
1018	return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCI) ||
1019	       rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE);
1020}
1021
1022static inline bool rt2x00_is_pcie(struct rt2x00_dev *rt2x00dev)
1023{
1024	return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE);
1025}
1026
1027static inline bool rt2x00_is_usb(struct rt2x00_dev *rt2x00dev)
1028{
1029	return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_USB);
1030}
1031
1032static inline bool rt2x00_is_soc(struct rt2x00_dev *rt2x00dev)
1033{
1034	return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_SOC);
1035}
1036
1037/**
1038 * rt2x00queue_map_txskb - Map a skb into DMA for TX purposes.
1039 * @entry: Pointer to &struct queue_entry
1040 */
1041void rt2x00queue_map_txskb(struct queue_entry *entry);
1042
1043/**
1044 * rt2x00queue_unmap_skb - Unmap a skb from DMA.
1045 * @entry: Pointer to &struct queue_entry
1046 */
1047void rt2x00queue_unmap_skb(struct queue_entry *entry);
1048
1049/**
1050 * rt2x00queue_get_queue - Convert queue index to queue pointer
1051 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1052 * @queue: rt2x00 queue index (see &enum data_queue_qid).
1053 */
1054struct data_queue *rt2x00queue_get_queue(struct rt2x00_dev *rt2x00dev,
1055					 const enum data_queue_qid queue);
1056
1057/**
1058 * rt2x00queue_get_entry - Get queue entry where the given index points to.
1059 * @queue: Pointer to &struct data_queue from where we obtain the entry.
1060 * @index: Index identifier for obtaining the correct index.
1061 */
1062struct queue_entry *rt2x00queue_get_entry(struct data_queue *queue,
1063					  enum queue_index index);
1064
1065/*
1066 * Debugfs handlers.
1067 */
1068/**
1069 * rt2x00debug_dump_frame - Dump a frame to userspace through debugfs.
1070 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1071 * @type: The type of frame that is being dumped.
1072 * @skb: The skb containing the frame to be dumped.
1073 */
1074#ifdef CONFIG_RT2X00_LIB_DEBUGFS
1075void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev,
1076			    enum rt2x00_dump_type type, struct sk_buff *skb);
1077#else
1078static inline void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev,
1079					  enum rt2x00_dump_type type,
1080					  struct sk_buff *skb)
1081{
1082}
1083#endif /* CONFIG_RT2X00_LIB_DEBUGFS */
1084
1085/*
1086 * Interrupt context handlers.
1087 */
1088void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev);
1089void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev);
1090void rt2x00lib_dmadone(struct queue_entry *entry);
1091void rt2x00lib_txdone(struct queue_entry *entry,
1092		      struct txdone_entry_desc *txdesc);
1093void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status);
1094void rt2x00lib_rxdone(struct queue_entry *entry);
1095
1096/*
1097 * mac80211 handlers.
1098 */
1099int rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb);
1100int rt2x00mac_start(struct ieee80211_hw *hw);
1101void rt2x00mac_stop(struct ieee80211_hw *hw);
1102int rt2x00mac_add_interface(struct ieee80211_hw *hw,
1103			    struct ieee80211_vif *vif);
1104void rt2x00mac_remove_interface(struct ieee80211_hw *hw,
1105				struct ieee80211_vif *vif);
1106int rt2x00mac_config(struct ieee80211_hw *hw, u32 changed);
1107void rt2x00mac_configure_filter(struct ieee80211_hw *hw,
1108				unsigned int changed_flags,
1109				unsigned int *total_flags,
1110				u64 multicast);
1111int rt2x00mac_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
1112		      bool set);
1113#ifdef CONFIG_RT2X00_LIB_CRYPTO
1114int rt2x00mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1115		      struct ieee80211_vif *vif, struct ieee80211_sta *sta,
1116		      struct ieee80211_key_conf *key);
1117#else
1118#define rt2x00mac_set_key	NULL
1119#endif /* CONFIG_RT2X00_LIB_CRYPTO */
1120void rt2x00mac_sw_scan_start(struct ieee80211_hw *hw);
1121void rt2x00mac_sw_scan_complete(struct ieee80211_hw *hw);
1122int rt2x00mac_get_stats(struct ieee80211_hw *hw,
1123			struct ieee80211_low_level_stats *stats);
1124void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw,
1125				struct ieee80211_vif *vif,
1126				struct ieee80211_bss_conf *bss_conf,
1127				u32 changes);
1128int rt2x00mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
1129		      const struct ieee80211_tx_queue_params *params);
1130void rt2x00mac_rfkill_poll(struct ieee80211_hw *hw);
1131
1132/*
1133 * Driver allocation handlers.
1134 */
1135int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev);
1136void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev);
1137#ifdef CONFIG_PM
1138int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state);
1139int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev);
1140#endif /* CONFIG_PM */
1141
1142#endif /* RT2X00_H */
1143