rt2x00.h

   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
 130enum 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 */
 142struct 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 */
 176struct 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 */
 187struct rt2x00_chan_survey {
 188	u64 time_idle;
 189	u64 time_busy;
 190	u64 time_ext_busy;
 191};
 192
 193/*
 194 * Channel information structure
 195 */
 196struct 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 */
 209struct 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 */
 219struct 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
 258DECLARE_EWMA(rssi, 10, 8)
 259
 260/*
 261 * Antenna settings about the currently active link.
 262 */
 263struct 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 */
 299struct 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	unsigned int watchdog;
 338};
 339
 340enum rt2x00_delayed_flags {
 341	DELAYED_UPDATE_BEACON,
 342};
 343
 344/*
 345 * Interface structure
 346 * Per interface configuration details, this structure
 347 * is allocated as the private data for ieee80211_vif.
 348 */
 349struct rt2x00_intf {
 350	/*
 351	 * beacon->skb must be protected with the mutex.
 352	 */
 353	struct mutex beacon_skb_mutex;
 354
 355	/*
 356	 * Entry in the beacon queue which belongs to
 357	 * this interface. Each interface has its own
 358	 * dedicated beacon entry.
 359	 */
 360	struct queue_entry *beacon;
 361	bool enable_beacon;
 362
 363	/*
 364	 * Actions that needed rescheduling.
 365	 */
 366	unsigned long delayed_flags;
 367
 368	/*
 369	 * Software sequence counter, this is only required
 370	 * for hardware which doesn't support hardware
 371	 * sequence counting.
 372	 */
 373	atomic_t seqno;
 374};
 375
 376static inline struct rt2x00_intf* vif_to_intf(struct ieee80211_vif *vif)
 377{
 378	return (struct rt2x00_intf *)vif->drv_priv;
 379}
 380
 381/**
 382 * struct hw_mode_spec: Hardware specifications structure
 383 *
 384 * Details about the supported modes, rates and channels
 385 * of a particular chipset. This is used by rt2x00lib
 386 * to build the ieee80211_hw_mode array for mac80211.
 387 *
 388 * @supported_bands: Bitmask contained the supported bands (2.4GHz, 5.2GHz).
 389 * @supported_rates: Rate types which are supported (CCK, OFDM).
 390 * @num_channels: Number of supported channels. This is used as array size
 391 *	for @tx_power_a, @tx_power_bg and @channels.
 392 * @channels: Device/chipset specific channel values (See &struct rf_channel).
 393 * @channels_info: Additional information for channels (See &struct channel_info).
 394 * @ht: Driver HT Capabilities (See &ieee80211_sta_ht_cap).
 395 */
 396struct hw_mode_spec {
 397	unsigned int supported_bands;
 398#define SUPPORT_BAND_2GHZ	0x00000001
 399#define SUPPORT_BAND_5GHZ	0x00000002
 400
 401	unsigned int supported_rates;
 402#define SUPPORT_RATE_CCK	0x00000001
 403#define SUPPORT_RATE_OFDM	0x00000002
 404
 405	unsigned int num_channels;
 406	const struct rf_channel *channels;
 407	const struct channel_info *channels_info;
 408
 409	struct ieee80211_sta_ht_cap ht;
 410};
 411
 412/*
 413 * Configuration structure wrapper around the
 414 * mac80211 configuration structure.
 415 * When mac80211 configures the driver, rt2x00lib
 416 * can precalculate values which are equal for all
 417 * rt2x00 drivers. Those values can be stored in here.
 418 */
 419struct rt2x00lib_conf {
 420	struct ieee80211_conf *conf;
 421
 422	struct rf_channel rf;
 423	struct channel_info channel;
 424};
 425
 426/*
 427 * Configuration structure for erp settings.
 428 */
 429struct rt2x00lib_erp {
 430	int short_preamble;
 431	int cts_protection;
 432
 433	u32 basic_rates;
 434
 435	int slot_time;
 436
 437	short sifs;
 438	short pifs;
 439	short difs;
 440	short eifs;
 441
 442	u16 beacon_int;
 443	u16 ht_opmode;
 444};
 445
 446/*
 447 * Configuration structure for hardware encryption.
 448 */
 449struct rt2x00lib_crypto {
 450	enum cipher cipher;
 451
 452	enum set_key_cmd cmd;
 453	const u8 *address;
 454
 455	u32 bssidx;
 456
 457	u8 key[16];
 458	u8 tx_mic[8];
 459	u8 rx_mic[8];
 460
 461	int wcid;
 462};
 463
 464/*
 465 * Configuration structure wrapper around the
 466 * rt2x00 interface configuration handler.
 467 */
 468struct rt2x00intf_conf {
 469	/*
 470	 * Interface type
 471	 */
 472	enum nl80211_iftype type;
 473
 474	/*
 475	 * TSF sync value, this is dependent on the operation type.
 476	 */
 477	enum tsf_sync sync;
 478
 479	/*
 480	 * The MAC and BSSID addresses are simple array of bytes,
 481	 * these arrays are little endian, so when sending the addresses
 482	 * to the drivers, copy the it into a endian-signed variable.
 483	 *
 484	 * Note that all devices (except rt2500usb) have 32 bits
 485	 * register word sizes. This means that whatever variable we
 486	 * pass _must_ be a multiple of 32 bits. Otherwise the device
 487	 * might not accept what we are sending to it.
 488	 * This will also make it easier for the driver to write
 489	 * the data to the device.
 490	 */
 491	__le32 mac[2];
 492	__le32 bssid[2];
 493};
 494
 495/*
 496 * Private structure for storing STA details
 497 * wcid: Wireless Client ID
 498 */
 499struct rt2x00_sta {
 500	int wcid;
 501};
 502
 503static inline struct rt2x00_sta* sta_to_rt2x00_sta(struct ieee80211_sta *sta)
 504{
 505	return (struct rt2x00_sta *)sta->drv_priv;
 506}
 507
 508/*
 509 * rt2x00lib callback functions.
 510 */
 511struct rt2x00lib_ops {
 512	/*
 513	 * Interrupt handlers.
 514	 */
 515	irq_handler_t irq_handler;
 516
 517	/*
 518	 * TX status tasklet handler.
 519	 */
 520	void (*txstatus_tasklet) (struct tasklet_struct *t);
 521	void (*pretbtt_tasklet) (struct tasklet_struct *t);
 522	void (*tbtt_tasklet) (struct tasklet_struct *t);
 523	void (*rxdone_tasklet) (struct tasklet_struct *t);
 524	void (*autowake_tasklet) (struct tasklet_struct *t);
 525
 526	/*
 527	 * Device init handlers.
 528	 */
 529	int (*probe_hw) (struct rt2x00_dev *rt2x00dev);
 530	char *(*get_firmware_name) (struct rt2x00_dev *rt2x00dev);
 531	int (*check_firmware) (struct rt2x00_dev *rt2x00dev,
 532			       const u8 *data, const size_t len);
 533	int (*load_firmware) (struct rt2x00_dev *rt2x00dev,
 534			      const u8 *data, const size_t len);
 535
 536	/*
 537	 * Device initialization/deinitialization handlers.
 538	 */
 539	int (*initialize) (struct rt2x00_dev *rt2x00dev);
 540	void (*uninitialize) (struct rt2x00_dev *rt2x00dev);
 541
 542	/*
 543	 * queue initialization handlers
 544	 */
 545	bool (*get_entry_state) (struct queue_entry *entry);
 546	void (*clear_entry) (struct queue_entry *entry);
 547
 548	/*
 549	 * Radio control handlers.
 550	 */
 551	int (*set_device_state) (struct rt2x00_dev *rt2x00dev,
 552				 enum dev_state state);
 553	int (*rfkill_poll) (struct rt2x00_dev *rt2x00dev);
 554	void (*link_stats) (struct rt2x00_dev *rt2x00dev,
 555			    struct link_qual *qual);
 556	void (*reset_tuner) (struct rt2x00_dev *rt2x00dev,
 557			     struct link_qual *qual);
 558	void (*link_tuner) (struct rt2x00_dev *rt2x00dev,
 559			    struct link_qual *qual, const u32 count);
 560	void (*gain_calibration) (struct rt2x00_dev *rt2x00dev);
 561	void (*vco_calibration) (struct rt2x00_dev *rt2x00dev);
 562
 563	/*
 564	 * Data queue handlers.
 565	 */
 566	void (*watchdog) (struct rt2x00_dev *rt2x00dev);
 567	void (*start_queue) (struct data_queue *queue);
 568	void (*kick_queue) (struct data_queue *queue);
 569	void (*stop_queue) (struct data_queue *queue);
 570	void (*flush_queue) (struct data_queue *queue, bool drop);
 571	void (*tx_dma_done) (struct queue_entry *entry);
 572
 573	/*
 574	 * TX control handlers
 575	 */
 576	void (*write_tx_desc) (struct queue_entry *entry,
 577			       struct txentry_desc *txdesc);
 578	void (*write_tx_data) (struct queue_entry *entry,
 579			       struct txentry_desc *txdesc);
 580	void (*write_beacon) (struct queue_entry *entry,
 581			      struct txentry_desc *txdesc);
 582	void (*clear_beacon) (struct queue_entry *entry);
 583	int (*get_tx_data_len) (struct queue_entry *entry);
 584
 585	/*
 586	 * RX control handlers
 587	 */
 588	void (*fill_rxdone) (struct queue_entry *entry,
 589			     struct rxdone_entry_desc *rxdesc);
 590
 591	/*
 592	 * Configuration handlers.
 593	 */
 594	int (*config_shared_key) (struct rt2x00_dev *rt2x00dev,
 595				  struct rt2x00lib_crypto *crypto,
 596				  struct ieee80211_key_conf *key);
 597	int (*config_pairwise_key) (struct rt2x00_dev *rt2x00dev,
 598				    struct rt2x00lib_crypto *crypto,
 599				    struct ieee80211_key_conf *key);
 600	void (*config_filter) (struct rt2x00_dev *rt2x00dev,
 601			       const unsigned int filter_flags);
 602	void (*config_intf) (struct rt2x00_dev *rt2x00dev,
 603			     struct rt2x00_intf *intf,
 604			     struct rt2x00intf_conf *conf,
 605			     const unsigned int flags);
 606#define CONFIG_UPDATE_TYPE		( 1 << 1 )
 607#define CONFIG_UPDATE_MAC		( 1 << 2 )
 608#define CONFIG_UPDATE_BSSID		( 1 << 3 )
 609
 610	void (*config_erp) (struct rt2x00_dev *rt2x00dev,
 611			    struct rt2x00lib_erp *erp,
 612			    u32 changed);
 613	void (*config_ant) (struct rt2x00_dev *rt2x00dev,
 614			    struct antenna_setup *ant);
 615	void (*config) (struct rt2x00_dev *rt2x00dev,
 616			struct rt2x00lib_conf *libconf,
 617			const unsigned int changed_flags);
 618	void (*pre_reset_hw) (struct rt2x00_dev *rt2x00dev);
 619	int (*sta_add) (struct rt2x00_dev *rt2x00dev,
 620			struct ieee80211_vif *vif,
 621			struct ieee80211_sta *sta);
 622	int (*sta_remove) (struct rt2x00_dev *rt2x00dev,
 623			   struct ieee80211_sta *sta);
 624};
 625
 626/*
 627 * rt2x00 driver callback operation structure.
 628 */
 629struct rt2x00_ops {
 630	const char *name;
 631	const unsigned int drv_data_size;
 632	const unsigned int max_ap_intf;
 633	const unsigned int eeprom_size;
 634	const unsigned int rf_size;
 635	const unsigned int tx_queues;
 636	void (*queue_init)(struct data_queue *queue);
 637	const struct rt2x00lib_ops *lib;
 638	const void *drv;
 639	const struct ieee80211_ops *hw;
 640#ifdef CONFIG_RT2X00_LIB_DEBUGFS
 641	const struct rt2x00debug *debugfs;
 642#endif /* CONFIG_RT2X00_LIB_DEBUGFS */
 643};
 644
 645/*
 646 * rt2x00 state flags
 647 */
 648enum rt2x00_state_flags {
 649	/*
 650	 * Device flags
 651	 */
 652	DEVICE_STATE_PRESENT,
 653	DEVICE_STATE_REGISTERED_HW,
 654	DEVICE_STATE_INITIALIZED,
 655	DEVICE_STATE_STARTED,
 656	DEVICE_STATE_ENABLED_RADIO,
 657	DEVICE_STATE_SCANNING,
 658	DEVICE_STATE_FLUSHING,
 659	DEVICE_STATE_RESET,
 660
 661	/*
 662	 * Driver configuration
 663	 */
 664	CONFIG_CHANNEL_HT40,
 665	CONFIG_POWERSAVING,
 666	CONFIG_HT_DISABLED,
 667	CONFIG_MONITORING,
 668
 669	/*
 670	 * Mark we currently are sequentially reading TX_STA_FIFO register
 671	 * FIXME: this is for only rt2800usb, should go to private data
 672	 */
 673	TX_STATUS_READING,
 674};
 675
 676/*
 677 * rt2x00 capability flags
 678 */
 679enum rt2x00_capability_flags {
 680	/*
 681	 * Requirements
 682	 */
 683	REQUIRE_FIRMWARE,
 684	REQUIRE_BEACON_GUARD,
 685	REQUIRE_ATIM_QUEUE,
 686	REQUIRE_DMA,
 687	REQUIRE_COPY_IV,
 688	REQUIRE_L2PAD,
 689	REQUIRE_TXSTATUS_FIFO,
 690	REQUIRE_TASKLET_CONTEXT,
 691	REQUIRE_SW_SEQNO,
 692	REQUIRE_HT_TX_DESC,
 693	REQUIRE_PS_AUTOWAKE,
 694	REQUIRE_DELAYED_RFKILL,
 695
 696	/*
 697	 * Capabilities
 698	 */
 699	CAPABILITY_HW_BUTTON,
 700	CAPABILITY_HW_CRYPTO,
 701	CAPABILITY_POWER_LIMIT,
 702	CAPABILITY_CONTROL_FILTERS,
 703	CAPABILITY_CONTROL_FILTER_PSPOLL,
 704	CAPABILITY_PRE_TBTT_INTERRUPT,
 705	CAPABILITY_LINK_TUNING,
 706	CAPABILITY_FRAME_TYPE,
 707	CAPABILITY_RF_SEQUENCE,
 708	CAPABILITY_EXTERNAL_LNA_A,
 709	CAPABILITY_EXTERNAL_LNA_BG,
 710	CAPABILITY_DOUBLE_ANTENNA,
 711	CAPABILITY_BT_COEXIST,
 712	CAPABILITY_VCO_RECALIBRATION,
 713	CAPABILITY_EXTERNAL_PA_TX0,
 714	CAPABILITY_EXTERNAL_PA_TX1,
 715	CAPABILITY_RESTART_HW,
 716};
 717
 718/*
 719 * Interface combinations
 720 */
 721enum {
 722	IF_COMB_AP = 0,
 723	NUM_IF_COMB,
 724};
 725
 726/*
 727 * rt2x00 device structure.
 728 */
 729struct rt2x00_dev {
 730	/*
 731	 * Device structure.
 732	 * The structure stored in here depends on the
 733	 * system bus (PCI or USB).
 734	 * When accessing this variable, the rt2x00dev_{pci,usb}
 735	 * macros should be used for correct typecasting.
 736	 */
 737	struct device *dev;
 738
 739	/*
 740	 * Callback functions.
 741	 */
 742	const struct rt2x00_ops *ops;
 743
 744	/*
 745	 * Driver data.
 746	 */
 747	void *drv_data;
 748
 749	/*
 750	 * IEEE80211 control structure.
 751	 */
 752	struct ieee80211_hw *hw;
 753	struct ieee80211_supported_band bands[NUM_NL80211_BANDS];
 754	struct rt2x00_chan_survey *chan_survey;
 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	/* Rx/Tx DMA busy watchdog counter */
 920	u16 rxdma_busy, txdma_busy;
 921
 922	/**
 923	 * Timestamp of last received beacon
 924	 */
 925	unsigned long last_beacon;
 926
 927	/*
 928	 * Low level statistics which will have
 929	 * to be kept up to date while device is running.
 930	 */
 931	struct ieee80211_low_level_stats low_level_stats;
 932
 933	/**
 934	 * Work queue for all work which should not be placed
 935	 * on the mac80211 workqueue (because of dependencies
 936	 * between various work structures).
 937	 */
 938	struct workqueue_struct *workqueue;
 939
 940	/*
 941	 * Scheduled work.
 942	 * NOTE: intf_work will use ieee80211_iterate_active_interfaces()
 943	 * which means it cannot be placed on the hw->workqueue
 944	 * due to RTNL locking requirements.
 945	 */
 946	struct work_struct intf_work;
 947
 948	/**
 949	 * Scheduled work for TX/RX done handling (USB devices)
 950	 */
 951	struct work_struct rxdone_work;
 952	struct work_struct txdone_work;
 953
 954	/*
 955	 * Powersaving work
 956	 */
 957	struct delayed_work autowakeup_work;
 958	struct work_struct sleep_work;
 959
 960	/*
 961	 * Data queue arrays for RX, TX, Beacon and ATIM.
 962	 */
 963	unsigned int data_queues;
 964	struct data_queue *rx;
 965	struct data_queue *tx;
 966	struct data_queue *bcn;
 967	struct data_queue *atim;
 968
 969	/*
 970	 * Firmware image.
 971	 */
 972	const struct firmware *fw;
 973
 974	/*
 975	 * FIFO for storing tx status reports between isr and tasklet.
 976	 */
 977	DECLARE_KFIFO_PTR(txstatus_fifo, u32);
 978
 979	/*
 980	 * Timer to ensure tx status reports are read (rt2800usb).
 981	 */
 982	struct hrtimer txstatus_timer;
 983
 984	/*
 985	 * Tasklet for processing tx status reports (rt2800pci).
 986	 */
 987	struct tasklet_struct txstatus_tasklet;
 988	struct tasklet_struct pretbtt_tasklet;
 989	struct tasklet_struct tbtt_tasklet;
 990	struct tasklet_struct rxdone_tasklet;
 991	struct tasklet_struct autowake_tasklet;
 992
 993	/*
 994	 * Used for VCO periodic calibration.
 995	 */
 996	int rf_channel;
 997
 998	/*
 999	 * Protect the interrupt mask register.
1000	 */
1001	spinlock_t irqmask_lock;
1002
1003	/*
1004	 * List of BlockAckReq TX entries that need driver BlockAck processing.
1005	 */
1006	struct list_head bar_list;
1007	spinlock_t bar_list_lock;
1008
1009	/* Extra TX headroom required for alignment purposes. */
1010	unsigned int extra_tx_headroom;
1011
1012	struct usb_anchor *anchor;
1013	unsigned int num_proto_errs;
1014
1015	/* Clock for System On Chip devices. */
1016	struct clk *clk;
1017};
1018
1019struct rt2x00_bar_list_entry {
1020	struct list_head list;
1021	struct rcu_head head;
1022
1023	struct queue_entry *entry;
1024	int block_acked;
1025
1026	/* Relevant parts of the IEEE80211 BAR header */
1027	__u8 ra[6];
1028	__u8 ta[6];
1029	__le16 control;
1030	__le16 start_seq_num;
1031};
1032
1033/*
1034 * Register defines.
1035 * Some registers require multiple attempts before success,
1036 * in those cases REGISTER_BUSY_COUNT attempts should be
1037 * taken with a REGISTER_BUSY_DELAY interval. Due to USB
1038 * bus delays, we do not have to loop so many times to wait
1039 * for valid register value on that bus.
1040 */
1041#define REGISTER_BUSY_COUNT	100
1042#define REGISTER_USB_BUSY_COUNT 20
1043#define REGISTER_BUSY_DELAY	100
1044
1045/*
1046 * Generic RF access.
1047 * The RF is being accessed by word index.
1048 */
1049static inline u32 rt2x00_rf_read(struct rt2x00_dev *rt2x00dev,
1050				 const unsigned int word)
1051{
1052	BUG_ON(word < 1 || word > rt2x00dev->ops->rf_size / sizeof(u32));
1053	return rt2x00dev->rf[word - 1];
1054}
1055
1056static inline void rt2x00_rf_write(struct rt2x00_dev *rt2x00dev,
1057				   const unsigned int word, u32 data)
1058{
1059	BUG_ON(word < 1 || word > rt2x00dev->ops->rf_size / sizeof(u32));
1060	rt2x00dev->rf[word - 1] = data;
1061}
1062
1063/*
1064 * Generic EEPROM access. The EEPROM is being accessed by word or byte index.
1065 */
1066static inline void *rt2x00_eeprom_addr(struct rt2x00_dev *rt2x00dev,
1067				       const unsigned int word)
1068{
1069	return (void *)&rt2x00dev->eeprom[word];
1070}
1071
1072static inline u16 rt2x00_eeprom_read(struct rt2x00_dev *rt2x00dev,
1073				     const unsigned int word)
1074{
1075	return le16_to_cpu(rt2x00dev->eeprom[word]);
1076}
1077
1078static inline void rt2x00_eeprom_write(struct rt2x00_dev *rt2x00dev,
1079				       const unsigned int word, u16 data)
1080{
1081	rt2x00dev->eeprom[word] = cpu_to_le16(data);
1082}
1083
1084static inline u8 rt2x00_eeprom_byte(struct rt2x00_dev *rt2x00dev,
1085				    const unsigned int byte)
1086{
1087	return *(((u8 *)rt2x00dev->eeprom) + byte);
1088}
1089
1090/*
1091 * Chipset handlers
1092 */
1093static inline void rt2x00_set_chip(struct rt2x00_dev *rt2x00dev,
1094				   const u16 rt, const u16 rf, const u16 rev)
1095{
1096	rt2x00dev->chip.rt = rt;
1097	rt2x00dev->chip.rf = rf;
1098	rt2x00dev->chip.rev = rev;
1099
1100	rt2x00_info(rt2x00dev, "Chipset detected - rt: %04x, rf: %04x, rev: %04x\n",
1101		    rt2x00dev->chip.rt, rt2x00dev->chip.rf,
1102		    rt2x00dev->chip.rev);
1103}
1104
1105static inline void rt2x00_set_rt(struct rt2x00_dev *rt2x00dev,
1106				 const u16 rt, const u16 rev)
1107{
1108	rt2x00dev->chip.rt = rt;
1109	rt2x00dev->chip.rev = rev;
1110
1111	rt2x00_info(rt2x00dev, "RT chipset %04x, rev %04x detected\n",
1112		    rt2x00dev->chip.rt, rt2x00dev->chip.rev);
1113}
1114
1115static inline void rt2x00_set_rf(struct rt2x00_dev *rt2x00dev, const u16 rf)
1116{
1117	rt2x00dev->chip.rf = rf;
1118
1119	rt2x00_info(rt2x00dev, "RF chipset %04x detected\n",
1120		    rt2x00dev->chip.rf);
1121}
1122
1123static inline bool rt2x00_rt(struct rt2x00_dev *rt2x00dev, const u16 rt)
1124{
1125	return (rt2x00dev->chip.rt == rt);
1126}
1127
1128static inline bool rt2x00_rf(struct rt2x00_dev *rt2x00dev, const u16 rf)
1129{
1130	return (rt2x00dev->chip.rf == rf);
1131}
1132
1133static inline u16 rt2x00_rev(struct rt2x00_dev *rt2x00dev)
1134{
1135	return rt2x00dev->chip.rev;
1136}
1137
1138static inline bool rt2x00_rt_rev(struct rt2x00_dev *rt2x00dev,
1139				 const u16 rt, const u16 rev)
1140{
1141	return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) == rev);
1142}
1143
1144static inline bool rt2x00_rt_rev_lt(struct rt2x00_dev *rt2x00dev,
1145				    const u16 rt, const u16 rev)
1146{
1147	return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) < rev);
1148}
1149
1150static inline bool rt2x00_rt_rev_gte(struct rt2x00_dev *rt2x00dev,
1151				     const u16 rt, const u16 rev)
1152{
1153	return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) >= rev);
1154}
1155
1156static inline void rt2x00_set_chip_intf(struct rt2x00_dev *rt2x00dev,
1157					enum rt2x00_chip_intf intf)
1158{
1159	rt2x00dev->chip.intf = intf;
1160}
1161
1162static inline bool rt2x00_intf(struct rt2x00_dev *rt2x00dev,
1163			       enum rt2x00_chip_intf intf)
1164{
1165	return (rt2x00dev->chip.intf == intf);
1166}
1167
1168static inline bool rt2x00_is_pci(struct rt2x00_dev *rt2x00dev)
1169{
1170	return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCI) ||
1171	       rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE);
1172}
1173
1174static inline bool rt2x00_is_pcie(struct rt2x00_dev *rt2x00dev)
1175{
1176	return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE);
1177}
1178
1179static inline bool rt2x00_is_usb(struct rt2x00_dev *rt2x00dev)
1180{
1181	return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_USB);
1182}
1183
1184static inline bool rt2x00_is_soc(struct rt2x00_dev *rt2x00dev)
1185{
1186	return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_SOC);
1187}
1188
1189/* Helpers for capability flags */
1190
1191static inline bool
1192rt2x00_has_cap_flag(struct rt2x00_dev *rt2x00dev,
1193		    enum rt2x00_capability_flags cap_flag)
1194{
1195	return test_bit(cap_flag, &rt2x00dev->cap_flags);
1196}
1197
1198static inline bool
1199rt2x00_has_cap_hw_crypto(struct rt2x00_dev *rt2x00dev)
1200{
1201	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_HW_CRYPTO);
1202}
1203
1204static inline bool
1205rt2x00_has_cap_power_limit(struct rt2x00_dev *rt2x00dev)
1206{
1207	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_POWER_LIMIT);
1208}
1209
1210static inline bool
1211rt2x00_has_cap_control_filters(struct rt2x00_dev *rt2x00dev)
1212{
1213	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_CONTROL_FILTERS);
1214}
1215
1216static inline bool
1217rt2x00_has_cap_control_filter_pspoll(struct rt2x00_dev *rt2x00dev)
1218{
1219	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_CONTROL_FILTER_PSPOLL);
1220}
1221
1222static inline bool
1223rt2x00_has_cap_pre_tbtt_interrupt(struct rt2x00_dev *rt2x00dev)
1224{
1225	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_PRE_TBTT_INTERRUPT);
1226}
1227
1228static inline bool
1229rt2x00_has_cap_link_tuning(struct rt2x00_dev *rt2x00dev)
1230{
1231	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_LINK_TUNING);
1232}
1233
1234static inline bool
1235rt2x00_has_cap_frame_type(struct rt2x00_dev *rt2x00dev)
1236{
1237	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_FRAME_TYPE);
1238}
1239
1240static inline bool
1241rt2x00_has_cap_rf_sequence(struct rt2x00_dev *rt2x00dev)
1242{
1243	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_RF_SEQUENCE);
1244}
1245
1246static inline bool
1247rt2x00_has_cap_external_lna_a(struct rt2x00_dev *rt2x00dev)
1248{
1249	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_EXTERNAL_LNA_A);
1250}
1251
1252static inline bool
1253rt2x00_has_cap_external_lna_bg(struct rt2x00_dev *rt2x00dev)
1254{
1255	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_EXTERNAL_LNA_BG);
1256}
1257
1258static inline bool
1259rt2x00_has_cap_external_pa(struct rt2x00_dev *rt2x00dev)
1260{
1261	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_EXTERNAL_PA_TX0);
1262}
1263
1264static inline bool
1265rt2x00_has_cap_double_antenna(struct rt2x00_dev *rt2x00dev)
1266{
1267	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_DOUBLE_ANTENNA);
1268}
1269
1270static inline bool
1271rt2x00_has_cap_bt_coexist(struct rt2x00_dev *rt2x00dev)
1272{
1273	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_BT_COEXIST);
1274}
1275
1276static inline bool
1277rt2x00_has_cap_vco_recalibration(struct rt2x00_dev *rt2x00dev)
1278{
1279	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_VCO_RECALIBRATION);
1280}
1281
1282static inline bool
1283rt2x00_has_cap_restart_hw(struct rt2x00_dev *rt2x00dev)
1284{
1285	return rt2x00_has_cap_flag(rt2x00dev, CAPABILITY_RESTART_HW);
1286}
1287
1288/**
1289 * rt2x00queue_map_txskb - Map a skb into DMA for TX purposes.
1290 * @entry: Pointer to &struct queue_entry
1291 *
1292 * Returns -ENOMEM if mapping fail, 0 otherwise.
1293 */
1294int rt2x00queue_map_txskb(struct queue_entry *entry);
1295
1296/**
1297 * rt2x00queue_unmap_skb - Unmap a skb from DMA.
1298 * @entry: Pointer to &struct queue_entry
1299 */
1300void rt2x00queue_unmap_skb(struct queue_entry *entry);
1301
1302/**
1303 * rt2x00queue_get_tx_queue - Convert tx queue index to queue pointer
1304 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1305 * @queue: rt2x00 queue index (see &enum data_queue_qid).
1306 *
1307 * Returns NULL for non tx queues.
1308 */
1309static inline struct data_queue *
1310rt2x00queue_get_tx_queue(struct rt2x00_dev *rt2x00dev,
1311			 enum data_queue_qid queue)
1312{
1313	if (queue >= rt2x00dev->ops->tx_queues && queue < IEEE80211_NUM_ACS)
1314		queue = rt2x00dev->ops->tx_queues - 1;
1315
1316	if (queue < rt2x00dev->ops->tx_queues && rt2x00dev->tx)
1317		return &rt2x00dev->tx[queue];
1318
1319	if (queue == QID_ATIM)
1320		return rt2x00dev->atim;
1321
1322	return NULL;
1323}
1324
1325/**
1326 * rt2x00queue_get_entry - Get queue entry where the given index points to.
1327 * @queue: Pointer to &struct data_queue from where we obtain the entry.
1328 * @index: Index identifier for obtaining the correct index.
1329 */
1330struct queue_entry *rt2x00queue_get_entry(struct data_queue *queue,
1331					  enum queue_index index);
1332
1333/**
1334 * rt2x00queue_pause_queue - Pause a data queue
1335 * @queue: Pointer to &struct data_queue.
1336 *
1337 * This function will pause the data queue locally, preventing
1338 * new frames to be added to the queue (while the hardware is
1339 * still allowed to run).
1340 */
1341void rt2x00queue_pause_queue(struct data_queue *queue);
1342
1343/**
1344 * rt2x00queue_unpause_queue - unpause a data queue
1345 * @queue: Pointer to &struct data_queue.
1346 *
1347 * This function will unpause the data queue locally, allowing
1348 * new frames to be added to the queue again.
1349 */
1350void rt2x00queue_unpause_queue(struct data_queue *queue);
1351
1352/**
1353 * rt2x00queue_start_queue - Start a data queue
1354 * @queue: Pointer to &struct data_queue.
1355 *
1356 * This function will start handling all pending frames in the queue.
1357 */
1358void rt2x00queue_start_queue(struct data_queue *queue);
1359
1360/**
1361 * rt2x00queue_stop_queue - Halt a data queue
1362 * @queue: Pointer to &struct data_queue.
1363 *
1364 * This function will stop all pending frames in the queue.
1365 */
1366void rt2x00queue_stop_queue(struct data_queue *queue);
1367
1368/**
1369 * rt2x00queue_flush_queue - Flush a data queue
1370 * @queue: Pointer to &struct data_queue.
1371 * @drop: True to drop all pending frames.
1372 *
1373 * This function will flush the queue. After this call
1374 * the queue is guaranteed to be empty.
1375 */
1376void rt2x00queue_flush_queue(struct data_queue *queue, bool drop);
1377
1378/**
1379 * rt2x00queue_start_queues - Start all data queues
1380 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1381 *
1382 * This function will loop through all available queues to start them
1383 */
1384void rt2x00queue_start_queues(struct rt2x00_dev *rt2x00dev);
1385
1386/**
1387 * rt2x00queue_stop_queues - Halt all data queues
1388 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1389 *
1390 * This function will loop through all available queues to stop
1391 * any pending frames.
1392 */
1393void rt2x00queue_stop_queues(struct rt2x00_dev *rt2x00dev);
1394
1395/**
1396 * rt2x00queue_flush_queues - Flush all data queues
1397 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1398 * @drop: True to drop all pending frames.
1399 *
1400 * This function will loop through all available queues to flush
1401 * any pending frames.
1402 */
1403void rt2x00queue_flush_queues(struct rt2x00_dev *rt2x00dev, bool drop);
1404
1405/*
1406 * Debugfs handlers.
1407 */
1408/**
1409 * rt2x00debug_dump_frame - Dump a frame to userspace through debugfs.
1410 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1411 * @type: The type of frame that is being dumped.
1412 * @entry: The queue entry containing the frame to be dumped.
1413 */
1414#ifdef CONFIG_RT2X00_LIB_DEBUGFS
1415void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev,
1416			    enum rt2x00_dump_type type, struct queue_entry *entry);
1417#else
1418static inline void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev,
1419					  enum rt2x00_dump_type type,
1420					  struct queue_entry *entry)
1421{
1422}
1423#endif /* CONFIG_RT2X00_LIB_DEBUGFS */
1424
1425/*
1426 * Utility functions.
1427 */
1428u32 rt2x00lib_get_bssidx(struct rt2x00_dev *rt2x00dev,
1429			 struct ieee80211_vif *vif);
1430int rt2x00lib_set_mac_address(struct rt2x00_dev *rt2x00dev, u8 *eeprom_mac_addr);
1431
1432/*
1433 * Interrupt context handlers.
1434 */
1435void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev);
1436void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev);
1437void rt2x00lib_dmastart(struct queue_entry *entry);
1438void rt2x00lib_dmadone(struct queue_entry *entry);
1439void rt2x00lib_txdone(struct queue_entry *entry,
1440		      struct txdone_entry_desc *txdesc);
1441void rt2x00lib_txdone_nomatch(struct queue_entry *entry,
1442			      struct txdone_entry_desc *txdesc);
1443void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status);
1444void rt2x00lib_rxdone(struct queue_entry *entry, gfp_t gfp);
1445
1446/*
1447 * mac80211 handlers.
1448 */
1449void rt2x00mac_tx(struct ieee80211_hw *hw,
1450		  struct ieee80211_tx_control *control,
1451		  struct sk_buff *skb);
1452int rt2x00mac_start(struct ieee80211_hw *hw);
1453void rt2x00mac_stop(struct ieee80211_hw *hw, bool suspend);
1454void rt2x00mac_reconfig_complete(struct ieee80211_hw *hw,
1455				 enum ieee80211_reconfig_type reconfig_type);
1456int rt2x00mac_add_interface(struct ieee80211_hw *hw,
1457			    struct ieee80211_vif *vif);
1458void rt2x00mac_remove_interface(struct ieee80211_hw *hw,
1459				struct ieee80211_vif *vif);
1460int rt2x00mac_config(struct ieee80211_hw *hw, int radio_idx, u32 changed);
1461void rt2x00mac_configure_filter(struct ieee80211_hw *hw,
1462				unsigned int changed_flags,
1463				unsigned int *total_flags,
1464				u64 multicast);
1465int rt2x00mac_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
1466		      bool set);
1467#ifdef CONFIG_RT2X00_LIB_CRYPTO
1468int rt2x00mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1469		      struct ieee80211_vif *vif, struct ieee80211_sta *sta,
1470		      struct ieee80211_key_conf *key);
1471#else
1472#define rt2x00mac_set_key	NULL
1473#endif /* CONFIG_RT2X00_LIB_CRYPTO */
1474void rt2x00mac_sw_scan_start(struct ieee80211_hw *hw,
1475			     struct ieee80211_vif *vif,
1476			     const u8 *mac_addr);
1477void rt2x00mac_sw_scan_complete(struct ieee80211_hw *hw,
1478				struct ieee80211_vif *vif);
1479int rt2x00mac_get_stats(struct ieee80211_hw *hw,
1480			struct ieee80211_low_level_stats *stats);
1481void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw,
1482				struct ieee80211_vif *vif,
1483				struct ieee80211_bss_conf *bss_conf,
1484				u64 changes);
1485int rt2x00mac_conf_tx(struct ieee80211_hw *hw,
1486		      struct ieee80211_vif *vif,
1487		      unsigned int link_id, u16 queue,
1488		      const struct ieee80211_tx_queue_params *params);
1489void rt2x00mac_rfkill_poll(struct ieee80211_hw *hw);
1490void rt2x00mac_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1491		     u32 queues, bool drop);
1492int rt2x00mac_set_antenna(struct ieee80211_hw *hw, int radio_idx,
1493			  u32 tx_ant, u32 rx_ant);
1494int rt2x00mac_get_antenna(struct ieee80211_hw *hw, int radio_idx,
1495			  u32 *tx_ant, u32 *rx_ant);
1496void rt2x00mac_get_ringparam(struct ieee80211_hw *hw,
1497			     u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max);
1498bool rt2x00mac_tx_frames_pending(struct ieee80211_hw *hw);
1499
1500/*
1501 * Driver allocation handlers.
1502 */
1503int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev);
1504void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev);
1505
1506int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev);
1507int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev);
1508
1509#endif /* RT2X00_H */