linux/drivers/net/wireless/ralink/rt2x00/rt2800lib.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
	Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
	Copyright (C) 2010 Ivo van Doorn <[email protected]>
	Copyright (C) 2009 Bartlomiej Zolnierkiewicz <[email protected]>
	Copyright (C) 2009 Gertjan van Wingerde <[email protected]>

	Based on the original rt2800pci.c and rt2800usb.c.
	  Copyright (C) 2009 Alban Browaeys <[email protected]>
	  Copyright (C) 2009 Felix Fietkau <[email protected]>
	  Copyright (C) 2009 Luis Correia <[email protected]>
	  Copyright (C) 2009 Mattias Nissler <[email protected]>
	  Copyright (C) 2009 Mark Asselstine <[email protected]>
	  Copyright (C) 2009 Xose Vazquez Perez <[email protected]>
	  <http://rt2x00.serialmonkey.com>

 */

/*
	Module: rt2800lib
	Abstract: rt2800 generic device routines.
 */

#include <linux/crc-ccitt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>

#include "rt2x00.h"
#include "rt2800lib.h"
#include "rt2800.h"

static unsigned int modparam_watchdog =;
module_param_named(watchdog, modparam_watchdog, uint, 0444);
MODULE_PARM_DESC();

/*
 * Register access.
 * All access to the CSR registers will go through the methods
 * rt2800_register_read and rt2800_register_write.
 * BBP and RF register require indirect register access,
 * and use the CSR registers BBPCSR and RFCSR to achieve this.
 * These indirect registers work with busy bits,
 * and we will try maximal REGISTER_BUSY_COUNT times to access
 * the register while taking a REGISTER_BUSY_DELAY us delay
 * between each attampt. When the busy bit is still set at that time,
 * the access attempt is considered to have failed,
 * and we will print an error.
 * The _lock versions must be used if you already hold the csr_mutex
 */
#define WAIT_FOR_BBP(__dev, __reg)
#define WAIT_FOR_RFCSR(__dev, __reg)
#define WAIT_FOR_RFCSR_MT7620(__dev, __reg)
#define WAIT_FOR_RF(__dev, __reg)
#define WAIT_FOR_MCU(__dev, __reg)

static inline bool rt2800_is_305x_soc(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_bbp_write(struct rt2x00_dev *rt2x00dev,
			     const unsigned int word, const u8 value)
{}

static u8 rt2800_bbp_read(struct rt2x00_dev *rt2x00dev, const unsigned int word)
{}

static void rt2800_rfcsr_write(struct rt2x00_dev *rt2x00dev,
			       const unsigned int word, const u8 value)
{}

static void rt2800_rfcsr_write_bank(struct rt2x00_dev *rt2x00dev, const u8 bank,
				    const unsigned int reg, const u8 value)
{}

static void rt2800_rfcsr_write_chanreg(struct rt2x00_dev *rt2x00dev,
				       const unsigned int reg, const u8 value)
{}

static void rt2800_rfcsr_write_dccal(struct rt2x00_dev *rt2x00dev,
				     const unsigned int reg, const u8 value)
{}

static void rt2800_bbp_dcoc_write(struct rt2x00_dev *rt2x00dev,
				  const u8 reg, const u8 value)
{}

static u8 rt2800_bbp_dcoc_read(struct rt2x00_dev *rt2x00dev, const u8 reg)
{}

static void rt2800_bbp_glrt_write(struct rt2x00_dev *rt2x00dev,
				  const u8 reg, const u8 value)
{}

static u8 rt2800_rfcsr_read(struct rt2x00_dev *rt2x00dev,
			    const unsigned int word)
{}

static u8 rt2800_rfcsr_read_bank(struct rt2x00_dev *rt2x00dev, const u8 bank,
				 const unsigned int reg)
{}

static void rt2800_rf_write(struct rt2x00_dev *rt2x00dev,
			    const unsigned int word, const u32 value)
{}

static const unsigned int rt2800_eeprom_map[EEPROM_WORD_COUNT] =;

static const unsigned int rt2800_eeprom_map_ext[EEPROM_WORD_COUNT] =;

static unsigned int rt2800_eeprom_word_index(struct rt2x00_dev *rt2x00dev,
					     const enum rt2800_eeprom_word word)
{}

static void *rt2800_eeprom_addr(struct rt2x00_dev *rt2x00dev,
				const enum rt2800_eeprom_word word)
{}

static u16 rt2800_eeprom_read(struct rt2x00_dev *rt2x00dev,
			      const enum rt2800_eeprom_word word)
{}

static void rt2800_eeprom_write(struct rt2x00_dev *rt2x00dev,
				const enum rt2800_eeprom_word word, u16 data)
{}

static u16 rt2800_eeprom_read_from_array(struct rt2x00_dev *rt2x00dev,
					 const enum rt2800_eeprom_word array,
					 unsigned int offset)
{}

static int rt2800_enable_wlan_rt3290(struct rt2x00_dev *rt2x00dev)
{}

void rt2800_mcu_request(struct rt2x00_dev *rt2x00dev,
			const u8 command, const u8 token,
			const u8 arg0, const u8 arg1)
{}
EXPORT_SYMBOL_GPL();

int rt2800_wait_csr_ready(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

int rt2800_wait_wpdma_ready(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

void rt2800_disable_wpdma(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

void rt2800_get_txwi_rxwi_size(struct rt2x00_dev *rt2x00dev,
			       unsigned short *txwi_size,
			       unsigned short *rxwi_size)
{}
EXPORT_SYMBOL_GPL();

static bool rt2800_check_firmware_crc(const u8 *data, const size_t len)
{}

int rt2800_check_firmware(struct rt2x00_dev *rt2x00dev,
			  const u8 *data, const size_t len)
{}
EXPORT_SYMBOL_GPL();

int rt2800_load_firmware(struct rt2x00_dev *rt2x00dev,
			 const u8 *data, const size_t len)
{}
EXPORT_SYMBOL_GPL();

void rt2800_write_tx_data(struct queue_entry *entry,
			  struct txentry_desc *txdesc)
{}
EXPORT_SYMBOL_GPL();

static int rt2800_agc_to_rssi(struct rt2x00_dev *rt2x00dev, u32 rxwi_w2)
{}

void rt2800_process_rxwi(struct queue_entry *entry,
			 struct rxdone_entry_desc *rxdesc)
{}
EXPORT_SYMBOL_GPL();

static void rt2800_rate_from_status(struct skb_frame_desc *skbdesc,
				    u32 status, enum nl80211_band band)
{}

static bool rt2800_txdone_entry_check(struct queue_entry *entry, u32 reg)
{}

void rt2800_txdone_entry(struct queue_entry *entry, u32 status, __le32 *txwi,
			 bool match)
{}
EXPORT_SYMBOL_GPL();

void rt2800_txdone(struct rt2x00_dev *rt2x00dev, unsigned int quota)
{}
EXPORT_SYMBOL_GPL();

static inline bool rt2800_entry_txstatus_timeout(struct rt2x00_dev *rt2x00dev,
						 struct queue_entry *entry)
{}

bool rt2800_txstatus_timeout(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

/*
 * test if there is an entry in any TX queue for which DMA is done
 * but the TX status has not been returned yet
 */
bool rt2800_txstatus_pending(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

void rt2800_txdone_nostatus(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

static bool rt2800_check_hung(struct data_queue *queue)
{}

static void rt2800_update_survey(struct rt2x00_dev *rt2x00dev)
{}

static bool rt2800_watchdog_hung(struct rt2x00_dev *rt2x00dev)
{}

static bool rt2800_watchdog_dma_busy(struct rt2x00_dev *rt2x00dev)
{}

void rt2800_watchdog(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

static unsigned int rt2800_hw_beacon_base(struct rt2x00_dev *rt2x00dev,
					  unsigned int index)
{}

static inline u8 rt2800_get_beacon_offset(struct rt2x00_dev *rt2x00dev,
					  unsigned int index)
{}

static void rt2800_update_beacons_setup(struct rt2x00_dev *rt2x00dev)
{}

void rt2800_write_beacon(struct queue_entry *entry, struct txentry_desc *txdesc)
{}
EXPORT_SYMBOL_GPL();

static inline void rt2800_clear_beacon_register(struct rt2x00_dev *rt2x00dev,
						unsigned int index)
{}

void rt2800_clear_beacon(struct queue_entry *entry)
{}
EXPORT_SYMBOL_GPL();

#ifdef CONFIG_RT2X00_LIB_DEBUGFS
const struct rt2x00debug rt2800_rt2x00debug =;
EXPORT_SYMBOL_GPL();
#endif /* CONFIG_RT2X00_LIB_DEBUGFS */

int rt2800_rfkill_poll(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

#ifdef CONFIG_RT2X00_LIB_LEDS
static void rt2800_brightness_set(struct led_classdev *led_cdev,
				  enum led_brightness brightness)
{}

static void rt2800_init_led(struct rt2x00_dev *rt2x00dev,
		     struct rt2x00_led *led, enum led_type type)
{}
#endif /* CONFIG_RT2X00_LIB_LEDS */

/*
 * Configuration handlers.
 */
static void rt2800_config_wcid(struct rt2x00_dev *rt2x00dev,
			       const u8 *address,
			       int wcid)
{}

static void rt2800_delete_wcid_attr(struct rt2x00_dev *rt2x00dev, int wcid)
{}

static void rt2800_config_wcid_attr_bssidx(struct rt2x00_dev *rt2x00dev,
					   int wcid, u32 bssidx)
{}

static void rt2800_config_wcid_attr_cipher(struct rt2x00_dev *rt2x00dev,
					   struct rt2x00lib_crypto *crypto,
					   struct ieee80211_key_conf *key)
{}

int rt2800_config_shared_key(struct rt2x00_dev *rt2x00dev,
			     struct rt2x00lib_crypto *crypto,
			     struct ieee80211_key_conf *key)
{}
EXPORT_SYMBOL_GPL();

int rt2800_config_pairwise_key(struct rt2x00_dev *rt2x00dev,
			       struct rt2x00lib_crypto *crypto,
			       struct ieee80211_key_conf *key)
{}
EXPORT_SYMBOL_GPL();

static void rt2800_set_max_psdu_len(struct rt2x00_dev *rt2x00dev)
{}

int rt2800_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		   struct ieee80211_sta *sta)
{}
EXPORT_SYMBOL_GPL();

int rt2800_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		      struct ieee80211_sta *sta)
{}
EXPORT_SYMBOL_GPL();

void rt2800_pre_reset_hw(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

void rt2800_config_filter(struct rt2x00_dev *rt2x00dev,
			  const unsigned int filter_flags)
{}
EXPORT_SYMBOL_GPL();

void rt2800_config_intf(struct rt2x00_dev *rt2x00dev, struct rt2x00_intf *intf,
			struct rt2x00intf_conf *conf, const unsigned int flags)
{}
EXPORT_SYMBOL_GPL();

static void rt2800_config_ht_opmode(struct rt2x00_dev *rt2x00dev,
				    struct rt2x00lib_erp *erp)
{}

void rt2800_config_erp(struct rt2x00_dev *rt2x00dev, struct rt2x00lib_erp *erp,
		       u32 changed)
{}
EXPORT_SYMBOL_GPL();

static int rt2800_wait_bbp_rf_ready(struct rt2x00_dev *rt2x00dev,
				    const struct rt2x00_field32 mask)
{}

static int rt2800_wait_bbp_ready(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_config_3572bt_ant(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_set_ant_diversity(struct rt2x00_dev *rt2x00dev,
				     enum antenna ant)
{}

void rt2800_config_ant(struct rt2x00_dev *rt2x00dev, struct antenna_setup *ant)
{}
EXPORT_SYMBOL_GPL();

static void rt2800_config_lna_gain(struct rt2x00_dev *rt2x00dev,
				   struct rt2x00lib_conf *libconf)
{}

static inline bool rt2800_clk_is_20mhz(struct rt2x00_dev *rt2x00dev)
{}

#define FREQ_OFFSET_BOUND

static void rt2800_freq_cal_mode1(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_config_channel_rf2xxx(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_conf *conf,
					 struct rf_channel *rf,
					 struct channel_info *info)
{}

static void rt2800_config_channel_rf3xxx(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_conf *conf,
					 struct rf_channel *rf,
					 struct channel_info *info)
{}

static void rt2800_config_channel_rf3052(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_conf *conf,
					 struct rf_channel *rf,
					 struct channel_info *info)
{}

static void rt2800_config_channel_rf3053(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_conf *conf,
					 struct rf_channel *rf,
					 struct channel_info *info)
{}

static void rt2800_config_channel_rf3853(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_conf *conf,
					 struct rf_channel *rf,
					 struct channel_info *info)
{}

#define POWER_BOUND
#define POWER_BOUND_5G

static void rt2800_config_channel_rf3290(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_conf *conf,
					 struct rf_channel *rf,
					 struct channel_info *info)
{}

static void rt2800_config_channel_rf3322(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_conf *conf,
					 struct rf_channel *rf,
					 struct channel_info *info)
{}

static void rt2800_config_channel_rf53xx(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_conf *conf,
					 struct rf_channel *rf,
					 struct channel_info *info)
{}

static void rt2800_config_channel_rf55xx(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_conf *conf,
					 struct rf_channel *rf,
					 struct channel_info *info)
{}

static void rt2800_config_channel_rf7620(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_conf *conf,
					 struct rf_channel *rf,
					 struct channel_info *info)
{}

static void rt2800_config_alc_rt6352(struct rt2x00_dev *rt2x00dev,
				     struct ieee80211_channel *chan,
				     int power_level)
{}

static void rt2800_bbp_write_with_rx_chain(struct rt2x00_dev *rt2x00dev,
					   const unsigned int word,
					   const u8 value)
{}

static void rt2800_iq_calibrate(struct rt2x00_dev *rt2x00dev, int channel)
{}

static s8 rt2800_txpower_to_dev(struct rt2x00_dev *rt2x00dev,
				  unsigned int channel,
				  s8 txpower)
{}

static void rt3883_bbp_adjust(struct rt2x00_dev *rt2x00dev,
			      struct rf_channel *rf)
{}

static void rt2800_config_channel(struct rt2x00_dev *rt2x00dev,
				  struct ieee80211_conf *conf,
				  struct rf_channel *rf,
				  struct channel_info *info)
{}

static int rt2800_get_gain_calibration_delta(struct rt2x00_dev *rt2x00dev)
{}

static int rt2800_get_txpower_bw_comp(struct rt2x00_dev *rt2x00dev,
				      enum nl80211_band band)
{}

static int rt2800_get_txpower_reg_delta(struct rt2x00_dev *rt2x00dev,
					int power_level, int max_power)
{}

static u8 rt2800_compensate_txpower(struct rt2x00_dev *rt2x00dev, int is_rate_b,
				   enum nl80211_band band, int power_level,
				   u8 txpower, int delta)
{}


enum {};

static void rt2800_config_txpower_rt3593(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_channel *chan,
					 int power_level)
{}

static void rt2800_config_txpower_rt6352(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_channel *chan,
					 int power_level)
{}

/*
 * We configure transmit power using MAC TX_PWR_CFG_{0,...,N} registers and
 * BBP R1 register. TX_PWR_CFG_X allow to configure per rate TX power values,
 * 4 bits for each rate (tune from 0 to 15 dBm). BBP_R1 controls transmit power
 * for all rates, but allow to set only 4 discrete values: -12, -6, 0 and 6 dBm.
 * Reference per rate transmit power values are located in the EEPROM at
 * EEPROM_TXPOWER_BYRATE offset. We adjust them and BBP R1 settings according to
 * current conditions (i.e. band, bandwidth, temperature, user settings).
 */
static void rt2800_config_txpower_rt28xx(struct rt2x00_dev *rt2x00dev,
					 struct ieee80211_channel *chan,
					 int power_level)
{}

static void rt2800_config_txpower(struct rt2x00_dev *rt2x00dev,
				  struct ieee80211_channel *chan,
				  int power_level)
{}

void rt2800_gain_calibration(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

void rt2800_vco_calibration(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

static void rt2800_config_retry_limit(struct rt2x00_dev *rt2x00dev,
				      struct rt2x00lib_conf *libconf)
{}

static void rt2800_config_ps(struct rt2x00_dev *rt2x00dev,
			     struct rt2x00lib_conf *libconf)
{}

void rt2800_config(struct rt2x00_dev *rt2x00dev,
		   struct rt2x00lib_conf *libconf,
		   const unsigned int flags)
{}
EXPORT_SYMBOL_GPL();

/*
 * Link tuning
 */
void rt2800_link_stats(struct rt2x00_dev *rt2x00dev, struct link_qual *qual)
{}
EXPORT_SYMBOL_GPL();

static u8 rt2800_get_default_vgc(struct rt2x00_dev *rt2x00dev)
{}

static inline void rt2800_set_vgc(struct rt2x00_dev *rt2x00dev,
				  struct link_qual *qual, u8 vgc_level)
{}

void rt2800_reset_tuner(struct rt2x00_dev *rt2x00dev, struct link_qual *qual)
{}
EXPORT_SYMBOL_GPL();

void rt2800_link_tuner(struct rt2x00_dev *rt2x00dev, struct link_qual *qual,
		       const u32 count)
{}
EXPORT_SYMBOL_GPL();

/*
 * Initialization functions.
 */
static int rt2800_init_registers(struct rt2x00_dev *rt2x00dev)
{}


static void rt2800_bbp4_mac_if_ctrl(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_freq_calibration(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_5592_glrt(struct rt2x00_dev *rt2x00dev)
{
	static const u8 glrt_table[] = {
		0xE0, 0x1F, 0X38, 0x32, 0x08, 0x28, 0x19, 0x0A, 0xFF, 0x00, /* 128 ~ 137 */
		0x16, 0x10, 0x10, 0x0B, 0x36, 0x2C, 0x26, 0x24, 0x42, 0x36, /* 138 ~ 147 */
		0x30, 0x2D, 0x4C, 0x46, 0x3D, 0x40, 0x3E, 0x42, 0x3D, 0x40, /* 148 ~ 157 */
		0X3C, 0x34, 0x2C, 0x2F, 0x3C, 0x35, 0x2E, 0x2A, 0x49, 0x41, /* 158 ~ 167 */
		0x36, 0x31, 0x30, 0x30, 0x0E, 0x0D, 0x28, 0x21, 0x1C, 0x16, /* 168 ~ 177 */
		0x50, 0x4A, 0x43, 0x40, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, /* 178 ~ 187 */
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 188 ~ 197 */
		0x00, 0x00, 0x7D, 0x14, 0x32, 0x2C, 0x36, 0x4C, 0x43, 0x2C, /* 198 ~ 207 */
		0x2E, 0x36, 0x30, 0x6E,					    /* 208 ~ 211 */
	};
	int i;

	for (i = 0; i < ARRAY_SIZE(glrt_table); i++) {
		rt2800_bbp_write(rt2x00dev, 195, 128 + i);
		rt2800_bbp_write(rt2x00dev, 196, glrt_table[i]);
	}
};

static void rt2800_init_bbp_early(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_disable_unused_dac_adc(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_305x_soc(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_28xx(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_30xx(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_3290(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_3352(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_3390(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_3572(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_3593(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_3883(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_53xx(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_5592(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp_6352(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_bbp(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_led_open_drain_enable(struct rt2x00_dev *rt2x00dev)
{}

static u8 rt2800_init_rx_filter(struct rt2x00_dev *rt2x00dev, bool bw40,
				u8 filter_target)
{}

static void rt2800_rf_init_calibration(struct rt2x00_dev *rt2x00dev,
				       const unsigned int rf_reg)
{}

static void rt2800_rx_filter_calibration(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_normal_mode_setup_3xxx(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_normal_mode_setup_3593(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_normal_mode_setup_5xxx(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_305x_soc(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_30xx(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_3290(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_3352(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_3390(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_3572(struct rt2x00_dev *rt2x00dev)
{}

static void rt3593_post_bbp_init(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_3593(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_5350(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_3883(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_5390(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_5392(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_5592(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_rf_self_txdc_cal(struct rt2x00_dev *rt2x00dev)
{}

static int rt2800_calcrcalibrationcode(struct rt2x00_dev *rt2x00dev, int d1, int d2)
{}

static void rt2800_r_calibration(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_rxdcoc_calibration(struct rt2x00_dev *rt2x00dev)
{}

static u32 rt2800_do_sqrt_accumulation(u32 si)
{}

static void rt2800_rxiq_calibration(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_rf_configstore(struct rt2x00_dev *rt2x00dev,
				  struct rf_reg_pair rf_reg_record[][13], u8 chain)
{}

static void rt2800_rf_configrecover(struct rt2x00_dev *rt2x00dev,
				    struct rf_reg_pair rf_record[][13])
{}

static void rt2800_setbbptonegenerator(struct rt2x00_dev *rt2x00dev)
{}

static u32 rt2800_do_fft_accumulation(struct rt2x00_dev *rt2x00dev, u8 tidx, u8 read_neg)
{}

static u32 rt2800_read_fft_accumulation(struct rt2x00_dev *rt2x00dev, u8 tidx)
{}

static void rt2800_write_dc(struct rt2x00_dev *rt2x00dev, u8 ch_idx, u8 alc, u8 iorq, u8 dc)
{}

static void rt2800_loft_search(struct rt2x00_dev *rt2x00dev, u8 ch_idx,
			       u8 alc_idx, u8 dc_result[][RF_ALC_NUM][2])
{}

static void rt2800_iq_search(struct rt2x00_dev *rt2x00dev, u8 ch_idx, u8 *ges, u8 *pes)
{}

static void rt2800_rf_aux_tx0_loopback(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_rf_aux_tx1_loopback(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_loft_iq_calibration(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_bbp_core_soft_reset(struct rt2x00_dev *rt2x00dev,
				       bool set_bw, bool is_ht40)
{}

static int rt2800_rf_lp_config(struct rt2x00_dev *rt2x00dev, bool btxcal)
{}

static s8 rt2800_lp_tx_filter_bw_cal(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_bw_filter_calibration(struct rt2x00_dev *rt2x00dev,
					 bool btxcal)
{}

static void rt2800_restore_rf_bbp_rt6352(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_calibration_rt6352(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr_6352(struct rt2x00_dev *rt2x00dev)
{}

static void rt2800_init_rfcsr(struct rt2x00_dev *rt2x00dev)
{}

int rt2800_enable_radio(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

void rt2800_disable_radio(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

int rt2800_efuse_detect(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

static void rt2800_efuse_read(struct rt2x00_dev *rt2x00dev, unsigned int i)
{}

int rt2800_read_eeprom_efuse(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

static u8 rt2800_get_txmixer_gain_24g(struct rt2x00_dev *rt2x00dev)
{}

static u8 rt2800_get_txmixer_gain_5g(struct rt2x00_dev *rt2x00dev)
{}

static int rt2800_validate_eeprom(struct rt2x00_dev *rt2x00dev)
{}

static int rt2800_init_eeprom(struct rt2x00_dev *rt2x00dev)
{}

/*
 * RF value list for rt28xx
 * Supports: 2.4 GHz (all) & 5.2 GHz (RF2850 & RF2750)
 */
static const struct rf_channel rf_vals[] =;

/*
 * RF value list for rt3xxx
 * Supports: 2.4 GHz (all) & 5.2 GHz (RF3052 & RF3053)
 */
static const struct rf_channel rf_vals_3x[] =;

/*
 * RF value list for rt3xxx with Xtal20MHz
 * Supports: 2.4 GHz (all) (RF3322)
 */
static const struct rf_channel rf_vals_3x_xtal20[] =;

static const struct rf_channel rf_vals_3853[] =;

static const struct rf_channel rf_vals_5592_xtal20[] =;

static const struct rf_channel rf_vals_5592_xtal40[] =;

static const struct rf_channel rf_vals_7620[] =;

static int rt2800_probe_hw_mode(struct rt2x00_dev *rt2x00dev)
{}

static int rt2800_probe_rt(struct rt2x00_dev *rt2x00dev)
{}

int rt2800_probe_hw(struct rt2x00_dev *rt2x00dev)
{}
EXPORT_SYMBOL_GPL();

/*
 * IEEE80211 stack callback functions.
 */
void rt2800_get_key_seq(struct ieee80211_hw *hw,
			struct ieee80211_key_conf *key,
			struct ieee80211_key_seq *seq)
{}
EXPORT_SYMBOL_GPL();

int rt2800_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{}
EXPORT_SYMBOL_GPL();

int rt2800_conf_tx(struct ieee80211_hw *hw,
		   struct ieee80211_vif *vif,
		   unsigned int link_id, u16 queue_idx,
		   const struct ieee80211_tx_queue_params *params)
{}
EXPORT_SYMBOL_GPL();

u64 rt2800_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
{}
EXPORT_SYMBOL_GPL();

int rt2800_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			struct ieee80211_ampdu_params *params)
{}
EXPORT_SYMBOL_GPL();

int rt2800_get_survey(struct ieee80211_hw *hw, int idx,
		      struct survey_info *survey)
{}
EXPORT_SYMBOL_GPL();

MODULE_AUTHOR();
MODULE_VERSION();
MODULE_DESCRIPTION();
MODULE_LICENSE();