/* * Copyright (c) 2004-2007 Reyk Floeter <[email protected]> * Copyright (c) 2006-2009 Nick Kossifidis <[email protected]> * Copyright (c) 2007-2008 Jiri Slaby <[email protected]> * Copyright (c) 2008-2009 Felix Fietkau <[email protected]> * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ /***********************\ * PHY related functions * \***********************/ #define pr_fmt(fmt) … #include <linux/delay.h> #include <linux/slab.h> #include <linux/sort.h> #include <asm/unaligned.h> #include "ath5k.h" #include "reg.h" #include "rfbuffer.h" #include "rfgain.h" #include "../regd.h" /** * DOC: PHY related functions * * Here we handle the low-level functions related to baseband * and analog frontend (RF) parts. This is by far the most complex * part of the hw code so make sure you know what you are doing. * * Here is a list of what this is all about: * * - Channel setting/switching * * - Automatic Gain Control (AGC) calibration * * - Noise Floor calibration * * - I/Q imbalance calibration (QAM correction) * * - Calibration due to thermal changes (gain_F) * * - Spur noise mitigation * * - RF/PHY initialization for the various operating modes and bwmodes * * - Antenna control * * - TX power control per channel/rate/packet type * * Also have in mind we never got documentation for most of these * functions, what we have comes mostly from Atheros's code, reverse * engineering and patent docs/presentations etc. */ /******************\ * Helper functions * \******************/ /** * ath5k_hw_radio_revision() - Get the PHY Chip revision * @ah: The &struct ath5k_hw * @band: One of enum nl80211_band * * Returns the revision number of a 2GHz, 5GHz or single chip * radio. */ u16 ath5k_hw_radio_revision(struct ath5k_hw *ah, enum nl80211_band band) { … } /** * ath5k_channel_ok() - Check if a channel is supported by the hw * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel * * Note: We don't do any regulatory domain checks here, it's just * a sanity check. */ bool ath5k_channel_ok(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /** * ath5k_hw_chan_has_spur_noise() - Check if channel is sensitive to spur noise * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel */ bool ath5k_hw_chan_has_spur_noise(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /** * ath5k_hw_rfb_op() - Perform an operation on the given RF Buffer * @ah: The &struct ath5k_hw * @rf_regs: The struct ath5k_rf_reg * @val: New value * @reg_id: RF register ID * @set: Indicate we need to swap data * * This is an internal function used to modify RF Banks before * writing them to AR5K_RF_BUFFER. Check out rfbuffer.h for more * infos. */ static unsigned int ath5k_hw_rfb_op(struct ath5k_hw *ah, const struct ath5k_rf_reg *rf_regs, u32 val, u8 reg_id, bool set) { … } /** * ath5k_hw_write_ofdm_timings() - set OFDM timings on AR5212 * @ah: the &struct ath5k_hw * @channel: the currently set channel upon reset * * Write the delta slope coefficient (used on pilot tracking ?) for OFDM * operation on the AR5212 upon reset. This is a helper for ath5k_hw_phy_init. * * Since delta slope is floating point we split it on its exponent and * mantissa and provide these values on hw. * * For more infos i think this patent is related * "http://www.freepatentsonline.com/7184495.html" */ static inline int ath5k_hw_write_ofdm_timings(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /** * ath5k_hw_phy_disable() - Disable PHY * @ah: The &struct ath5k_hw */ int ath5k_hw_phy_disable(struct ath5k_hw *ah) { … } /** * ath5k_hw_wait_for_synth() - Wait for synth to settle * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel */ static void ath5k_hw_wait_for_synth(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /**********************\ * RF Gain optimization * \**********************/ /** * DOC: RF Gain optimization * * This code is used to optimize RF gain on different environments * (temperature mostly) based on feedback from a power detector. * * It's only used on RF5111 and RF5112, later RF chips seem to have * auto adjustment on hw -notice they have a much smaller BANK 7 and * no gain optimization ladder-. * * For more infos check out this patent doc * "http://www.freepatentsonline.com/7400691.html" * * This paper describes power drops as seen on the receiver due to * probe packets * "http://www.cnri.dit.ie/publications/ICT08%20-%20Practical%20Issues * %20of%20Power%20Control.pdf" * * And this is the MadWiFi bug entry related to the above * "http://madwifi-project.org/ticket/1659" * with various measurements and diagrams */ /** * ath5k_hw_rfgain_opt_init() - Initialize ah_gain during attach * @ah: The &struct ath5k_hw */ int ath5k_hw_rfgain_opt_init(struct ath5k_hw *ah) { … } /** * ath5k_hw_request_rfgain_probe() - Request a PAPD probe packet * @ah: The &struct ath5k_hw * * Schedules a gain probe check on the next transmitted packet. * That means our next packet is going to be sent with lower * tx power and a Peak to Average Power Detector (PAPD) will try * to measure the gain. * * TODO: Force a tx packet (bypassing PCU arbitrator etc) * just after we enable the probe so that we don't mess with * standard traffic. */ static void ath5k_hw_request_rfgain_probe(struct ath5k_hw *ah) { … } /** * ath5k_hw_rf_gainf_corr() - Calculate Gain_F measurement correction * @ah: The &struct ath5k_hw * * Calculate Gain_F measurement correction * based on the current step for RF5112 rev. 2 */ static u32 ath5k_hw_rf_gainf_corr(struct ath5k_hw *ah) { … } /** * ath5k_hw_rf_check_gainf_readback() - Validate Gain_F feedback from detector * @ah: The &struct ath5k_hw * * Check if current gain_F measurement is in the range of our * power detector windows. If we get a measurement outside range * we know it's not accurate (detectors can't measure anything outside * their detection window) so we must ignore it. * * Returns true if readback was O.K. or false on failure */ static bool ath5k_hw_rf_check_gainf_readback(struct ath5k_hw *ah) { … } /** * ath5k_hw_rf_gainf_adjust() - Perform Gain_F adjustment * @ah: The &struct ath5k_hw * * Choose the right target gain based on current gain * and RF gain optimization ladder */ static s8 ath5k_hw_rf_gainf_adjust(struct ath5k_hw *ah) { … } /** * ath5k_hw_gainf_calibrate() - Do a gain_F calibration * @ah: The &struct ath5k_hw * * Main callback for thermal RF gain calibration engine * Check for a new gain reading and schedule an adjustment * if needed. * * Returns one of enum ath5k_rfgain codes */ enum ath5k_rfgain ath5k_hw_gainf_calibrate(struct ath5k_hw *ah) { … } /** * ath5k_hw_rfgain_init() - Write initial RF gain settings to hw * @ah: The &struct ath5k_hw * @band: One of enum nl80211_band * * Write initial RF gain table to set the RF sensitivity. * * NOTE: This one works on all RF chips and has nothing to do * with Gain_F calibration */ static int ath5k_hw_rfgain_init(struct ath5k_hw *ah, enum nl80211_band band) { … } /********************\ * RF Registers setup * \********************/ /** * ath5k_hw_rfregs_init() - Initialize RF register settings * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel * @mode: One of enum ath5k_driver_mode * * Setup RF registers by writing RF buffer on hw. For * more infos on this, check out rfbuffer.h */ static int ath5k_hw_rfregs_init(struct ath5k_hw *ah, struct ieee80211_channel *channel, unsigned int mode) { … } /**************************\ PHY/RF channel functions \**************************/ /** * ath5k_hw_rf5110_chan2athchan() - Convert channel freq on RF5110 * @channel: The &struct ieee80211_channel * * Map channel frequency to IEEE channel number and convert it * to an internal channel value used by the RF5110 chipset. */ static u32 ath5k_hw_rf5110_chan2athchan(struct ieee80211_channel *channel) { … } /** * ath5k_hw_rf5110_channel() - Set channel frequency on RF5110 * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel */ static int ath5k_hw_rf5110_channel(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /** * ath5k_hw_rf5111_chan2athchan() - Handle 2GHz channels on RF5111/2111 * @ieee: IEEE channel number * @athchan: The &struct ath5k_athchan_2ghz * * In order to enable the RF2111 frequency converter on RF5111/2111 setups * we need to add some offsets and extra flags to the data values we pass * on to the PHY. So for every 2GHz channel this function gets called * to do the conversion. */ static int ath5k_hw_rf5111_chan2athchan(unsigned int ieee, struct ath5k_athchan_2ghz *athchan) { … } /** * ath5k_hw_rf5111_channel() - Set channel frequency on RF5111/2111 * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel */ static int ath5k_hw_rf5111_channel(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /** * ath5k_hw_rf5112_channel() - Set channel frequency on 5112 and newer * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel * * On RF5112/2112 and newer we don't need to do any conversion. * We pass the frequency value after a few modifications to the * chip directly. * * NOTE: Make sure channel frequency given is within our range or else * we might damage the chip ! Use ath5k_channel_ok before calling this one. */ static int ath5k_hw_rf5112_channel(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /** * ath5k_hw_rf2425_channel() - Set channel frequency on RF2425 * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel * * AR2425/2417 have a different 2GHz RF so code changes * a little bit from RF5112. */ static int ath5k_hw_rf2425_channel(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /** * ath5k_hw_channel() - Set a channel on the radio chip * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel * * This is the main function called to set a channel on the * radio chip based on the radio chip version. */ static int ath5k_hw_channel(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /*****************\ PHY calibration \*****************/ /** * DOC: PHY Calibration routines * * Noise floor calibration: When we tell the hardware to * perform a noise floor calibration by setting the * AR5K_PHY_AGCCTL_NF bit on AR5K_PHY_AGCCTL, it will periodically * sample-and-hold the minimum noise level seen at the antennas. * This value is then stored in a ring buffer of recently measured * noise floor values so we have a moving window of the last few * samples. The median of the values in the history is then loaded * into the hardware for its own use for RSSI and CCA measurements. * This type of calibration doesn't interfere with traffic. * * AGC calibration: When we tell the hardware to perform * an AGC (Automatic Gain Control) calibration by setting the * AR5K_PHY_AGCCTL_CAL, hw disconnects the antennas and does * a calibration on the DC offsets of ADCs. During this period * rx/tx gets disabled so we have to deal with it on the driver * part. * * I/Q calibration: When we tell the hardware to perform * an I/Q calibration, it tries to correct I/Q imbalance and * fix QAM constellation by sampling data from rxed frames. * It doesn't interfere with traffic. * * For more infos on AGC and I/Q calibration check out patent doc * #03/094463. */ /** * ath5k_hw_read_measured_noise_floor() - Read measured NF from hw * @ah: The &struct ath5k_hw */ static s32 ath5k_hw_read_measured_noise_floor(struct ath5k_hw *ah) { … } /** * ath5k_hw_init_nfcal_hist() - Initialize NF calibration history buffer * @ah: The &struct ath5k_hw */ void ath5k_hw_init_nfcal_hist(struct ath5k_hw *ah) { … } /** * ath5k_hw_update_nfcal_hist() - Update NF calibration history buffer * @ah: The &struct ath5k_hw * @noise_floor: The NF we got from hw */ static void ath5k_hw_update_nfcal_hist(struct ath5k_hw *ah, s16 noise_floor) { … } static int cmps16(const void *a, const void *b) { … } /** * ath5k_hw_get_median_noise_floor() - Get median NF from history buffer * @ah: The &struct ath5k_hw */ static s16 ath5k_hw_get_median_noise_floor(struct ath5k_hw *ah) { … } /** * ath5k_hw_update_noise_floor() - Update NF on hardware * @ah: The &struct ath5k_hw * * This is the main function we call to perform a NF calibration, * it reads NF from hardware, calculates the median and updates * NF on hw. */ void ath5k_hw_update_noise_floor(struct ath5k_hw *ah) { … } /** * ath5k_hw_rf5110_calibrate() - Perform a PHY calibration on RF5110 * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel * * Do a complete PHY calibration (AGC + NF + I/Q) on RF5110 */ static int ath5k_hw_rf5110_calibrate(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /** * ath5k_hw_rf511x_iq_calibrate() - Perform I/Q calibration on RF5111 and newer * @ah: The &struct ath5k_hw */ static int ath5k_hw_rf511x_iq_calibrate(struct ath5k_hw *ah) { … } /** * ath5k_hw_phy_calibrate() - Perform a PHY calibration * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel * * The main function we call from above to perform * a short or full PHY calibration based on RF chip * and current channel */ int ath5k_hw_phy_calibrate(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /***************************\ * Spur mitigation functions * \***************************/ /** * ath5k_hw_set_spur_mitigation_filter() - Configure SPUR filter * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel * * This function gets called during PHY initialization to * configure the spur filter for the given channel. Spur is noise * generated due to "reflection" effects, for more information on this * method check out patent US7643810 */ static void ath5k_hw_set_spur_mitigation_filter(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /*****************\ * Antenna control * \*****************/ /** * DOC: Antenna control * * Hw supports up to 14 antennas ! I haven't found any card that implements * that. The maximum number of antennas I've seen is up to 4 (2 for 2GHz and 2 * for 5GHz). Antenna 1 (MAIN) should be omnidirectional, 2 (AUX) * omnidirectional or sectorial and antennas 3-14 sectorial (or directional). * * We can have a single antenna for RX and multiple antennas for TX. * RX antenna is our "default" antenna (usually antenna 1) set on * DEFAULT_ANTENNA register and TX antenna is set on each TX control descriptor * (0 for automatic selection, 1 - 14 antenna number). * * We can let hw do all the work doing fast antenna diversity for both * tx and rx or we can do things manually. Here are the options we have * (all are bits of STA_ID1 register): * * AR5K_STA_ID1_DEFAULT_ANTENNA -> When 0 is set as the TX antenna on TX * control descriptor, use the default antenna to transmit or else use the last * antenna on which we received an ACK. * * AR5K_STA_ID1_DESC_ANTENNA -> Update default antenna after each TX frame to * the antenna on which we got the ACK for that frame. * * AR5K_STA_ID1_RTS_DEF_ANTENNA -> Use default antenna for RTS or else use the * one on the TX descriptor. * * AR5K_STA_ID1_SELFGEN_DEF_ANT -> Use default antenna for self generated frames * (ACKs etc), or else use current antenna (the one we just used for TX). * * Using the above we support the following scenarios: * * AR5K_ANTMODE_DEFAULT -> Hw handles antenna diversity etc automatically * * AR5K_ANTMODE_FIXED_A -> Only antenna A (MAIN) is present * * AR5K_ANTMODE_FIXED_B -> Only antenna B (AUX) is present * * AR5K_ANTMODE_SINGLE_AP -> Sta locked on a single ap * * AR5K_ANTMODE_SECTOR_AP -> AP with tx antenna set on tx desc * * AR5K_ANTMODE_SECTOR_STA -> STA with tx antenna set on tx desc * * AR5K_ANTMODE_DEBUG Debug mode -A -> Rx, B-> Tx- * * Also note that when setting antenna to F on tx descriptor card inverts * current tx antenna. */ /** * ath5k_hw_set_def_antenna() - Set default rx antenna on AR5211/5212 and newer * @ah: The &struct ath5k_hw * @ant: Antenna number */ static void ath5k_hw_set_def_antenna(struct ath5k_hw *ah, u8 ant) { … } /** * ath5k_hw_set_fast_div() - Enable/disable fast rx antenna diversity * @ah: The &struct ath5k_hw * @ee_mode: One of enum ath5k_driver_mode * @enable: True to enable, false to disable */ static void ath5k_hw_set_fast_div(struct ath5k_hw *ah, u8 ee_mode, bool enable) { … } /** * ath5k_hw_set_antenna_switch() - Set up antenna switch table * @ah: The &struct ath5k_hw * @ee_mode: One of enum ath5k_driver_mode * * Switch table comes from EEPROM and includes information on controlling * the 2 antenna RX attenuators */ void ath5k_hw_set_antenna_switch(struct ath5k_hw *ah, u8 ee_mode) { … } /** * ath5k_hw_set_antenna_mode() - Set antenna operating mode * @ah: The &struct ath5k_hw * @ant_mode: One of enum ath5k_ant_mode */ void ath5k_hw_set_antenna_mode(struct ath5k_hw *ah, u8 ant_mode) { … } /****************\ * TX power setup * \****************/ /* * Helper functions */ /** * ath5k_get_interpolated_value() - Get interpolated Y val between two points * @target: X value of the middle point * @x_left: X value of the left point * @x_right: X value of the right point * @y_left: Y value of the left point * @y_right: Y value of the right point */ static s16 ath5k_get_interpolated_value(s16 target, s16 x_left, s16 x_right, s16 y_left, s16 y_right) { … } /** * ath5k_get_linear_pcdac_min() - Find vertical boundary (min pwr) for the * linear PCDAC curve * @stepL: Left array with y values (pcdac steps) * @stepR: Right array with y values (pcdac steps) * @pwrL: Left array with x values (power steps) * @pwrR: Right array with x values (power steps) * * Since we have the top of the curve and we draw the line below * until we reach 1 (1 pcdac step) we need to know which point * (x value) that is so that we don't go below x axis and have negative * pcdac values when creating the curve, or fill the table with zeros. */ static s16 ath5k_get_linear_pcdac_min(const u8 *stepL, const u8 *stepR, const s16 *pwrL, const s16 *pwrR) { … } /** * ath5k_create_power_curve() - Create a Power to PDADC or PCDAC curve * @pmin: Minimum power value (xmin) * @pmax: Maximum power value (xmax) * @pwr: Array of power steps (x values) * @vpd: Array of matching PCDAC/PDADC steps (y values) * @num_points: Number of provided points * @vpd_table: Array to fill with the full PCDAC/PDADC values (y values) * @type: One of enum ath5k_powertable_type (eeprom.h) * * Interpolate (pwr,vpd) points to create a Power to PDADC or a * Power to PCDAC curve. * * Each curve has power on x axis (in 0.5dB units) and PCDAC/PDADC * steps (offsets) on y axis. Power can go up to 31.5dB and max * PCDAC/PDADC step for each curve is 64 but we can write more than * one curves on hw so we can go up to 128 (which is the max step we * can write on the final table). * * We write y values (PCDAC/PDADC steps) on hw. */ static void ath5k_create_power_curve(s16 pmin, s16 pmax, const s16 *pwr, const u8 *vpd, u8 num_points, u8 *vpd_table, u8 type) { … } /** * ath5k_get_chan_pcal_surrounding_piers() - Get surrounding calibration piers * for a given channel. * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel * @pcinfo_l: The &struct ath5k_chan_pcal_info to put the left cal. pier * @pcinfo_r: The &struct ath5k_chan_pcal_info to put the right cal. pier * * Get the surrounding per-channel power calibration piers * for a given frequency so that we can interpolate between * them and come up with an appropriate dataset for our current * channel. */ static void ath5k_get_chan_pcal_surrounding_piers(struct ath5k_hw *ah, struct ieee80211_channel *channel, struct ath5k_chan_pcal_info **pcinfo_l, struct ath5k_chan_pcal_info **pcinfo_r) { … } /** * ath5k_get_rate_pcal_data() - Get the interpolated per-rate power * calibration data * @ah: The &struct ath5k_hw *ah, * @channel: The &struct ieee80211_channel * @rates: The &struct ath5k_rate_pcal_info to fill * * Get the surrounding per-rate power calibration data * for a given frequency and interpolate between power * values to set max target power supported by hw for * each rate on this frequency. */ static void ath5k_get_rate_pcal_data(struct ath5k_hw *ah, struct ieee80211_channel *channel, struct ath5k_rate_pcal_info *rates) { … } /** * ath5k_get_max_ctl_power() - Get max edge power for a given frequency * @ah: the &struct ath5k_hw * @channel: The &struct ieee80211_channel * * Get the max edge power for this channel if * we have such data from EEPROM's Conformance Test * Limits (CTL), and limit max power if needed. */ static void ath5k_get_max_ctl_power(struct ath5k_hw *ah, struct ieee80211_channel *channel) { … } /* * Power to PCDAC table functions */ /** * DOC: Power to PCDAC table functions * * For RF5111 we have an XPD -eXternal Power Detector- curve * for each calibrated channel. Each curve has 0,5dB Power steps * on x axis and PCDAC steps (offsets) on y axis and looks like an * exponential function. To recreate the curve we read 11 points * from eeprom (eeprom.c) and interpolate here. * * For RF5112 we have 4 XPD -eXternal Power Detector- curves * for each calibrated channel on 0, -6, -12 and -18dBm but we only * use the higher (3) and the lower (0) curves. Each curve again has 0.5dB * power steps on x axis and PCDAC steps on y axis and looks like a * linear function. To recreate the curve and pass the power values * on hw, we get 4 points for xpd 0 (lower gain -> max power) * and 3 points for xpd 3 (higher gain -> lower power) from eeprom (eeprom.c) * and interpolate here. * * For a given channel we get the calibrated points (piers) for it or * -if we don't have calibration data for this specific channel- from the * available surrounding channels we have calibration data for, after we do a * linear interpolation between them. Then since we have our calibrated points * for this channel, we do again a linear interpolation between them to get the * whole curve. * * We finally write the Y values of the curve(s) (the PCDAC values) on hw */ /** * ath5k_fill_pwr_to_pcdac_table() - Fill Power to PCDAC table on RF5111 * @ah: The &struct ath5k_hw * @table_min: Minimum power (x min) * @table_max: Maximum power (x max) * * No further processing is needed for RF5111, the only thing we have to * do is fill the values below and above calibration range since eeprom data * may not cover the entire PCDAC table. */ static void ath5k_fill_pwr_to_pcdac_table(struct ath5k_hw *ah, s16* table_min, s16 *table_max) { … } /** * ath5k_combine_linear_pcdac_curves() - Combine available PCDAC Curves * @ah: The &struct ath5k_hw * @table_min: Minimum power (x min) * @table_max: Maximum power (x max) * @pdcurves: Number of pd curves * * Combine available XPD Curves and fill Linear Power to PCDAC table on RF5112 * RFX112 can have up to 2 curves (one for low txpower range and one for * higher txpower range). We need to put them both on pcdac_out and place * them in the correct location. In case we only have one curve available * just fit it on pcdac_out (it's supposed to cover the entire range of * available pwr levels since it's always the higher power curve). Extrapolate * below and above final table if needed. */ static void ath5k_combine_linear_pcdac_curves(struct ath5k_hw *ah, s16* table_min, s16 *table_max, u8 pdcurves) { … } /** * ath5k_write_pcdac_table() - Write the PCDAC values on hw * @ah: The &struct ath5k_hw */ static void ath5k_write_pcdac_table(struct ath5k_hw *ah) { … } /* * Power to PDADC table functions */ /** * DOC: Power to PDADC table functions * * For RF2413 and later we have a Power to PDADC table (Power Detector) * instead of a PCDAC (Power Control) and 4 pd gain curves for each * calibrated channel. Each curve has power on x axis in 0.5 db steps and * PDADC steps on y axis and looks like an exponential function like the * RF5111 curve. * * To recreate the curves we read the points from eeprom (eeprom.c) * and interpolate here. Note that in most cases only 2 (higher and lower) * curves are used (like RF5112) but vendors have the opportunity to include * all 4 curves on eeprom. The final curve (higher power) has an extra * point for better accuracy like RF5112. * * The process is similar to what we do above for RF5111/5112 */ /** * ath5k_combine_pwr_to_pdadc_curves() - Combine the various PDADC curves * @ah: The &struct ath5k_hw * @pwr_min: Minimum power (x min) * @pwr_max: Maximum power (x max) * @pdcurves: Number of available curves * * Combine the various pd curves and create the final Power to PDADC table * We can have up to 4 pd curves, we need to do a similar process * as we do for RF5112. This time we don't have an edge_flag but we * set the gain boundaries on a separate register. */ static void ath5k_combine_pwr_to_pdadc_curves(struct ath5k_hw *ah, s16 *pwr_min, s16 *pwr_max, u8 pdcurves) { … } /** * ath5k_write_pwr_to_pdadc_table() - Write the PDADC values on hw * @ah: The &struct ath5k_hw * @ee_mode: One of enum ath5k_driver_mode */ static void ath5k_write_pwr_to_pdadc_table(struct ath5k_hw *ah, u8 ee_mode) { … } /* * Common code for PCDAC/PDADC tables */ /** * ath5k_setup_channel_powertable() - Set up power table for this channel * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel * @ee_mode: One of enum ath5k_driver_mode * @type: One of enum ath5k_powertable_type (eeprom.h) * * This is the main function that uses all of the above * to set PCDAC/PDADC table on hw for the current channel. * This table is used for tx power calibration on the baseband, * without it we get weird tx power levels and in some cases * distorted spectral mask */ static int ath5k_setup_channel_powertable(struct ath5k_hw *ah, struct ieee80211_channel *channel, u8 ee_mode, u8 type) { … } /** * ath5k_write_channel_powertable() - Set power table for current channel on hw * @ah: The &struct ath5k_hw * @ee_mode: One of enum ath5k_driver_mode * @type: One of enum ath5k_powertable_type (eeprom.h) */ static void ath5k_write_channel_powertable(struct ath5k_hw *ah, u8 ee_mode, u8 type) { … } /** * DOC: Per-rate tx power setting * * This is the code that sets the desired tx power limit (below * maximum) on hw for each rate (we also have TPC that sets * power per packet type). We do that by providing an index on the * PCDAC/PDADC table we set up above, for each rate. * * For now we only limit txpower based on maximum tx power * supported by hw (what's inside rate_info) + conformance test * limits. We need to limit this even more, based on regulatory domain * etc to be safe. Normally this is done from above so we don't care * here, all we care is that the tx power we set will be O.K. * for the hw (e.g. won't create noise on PA etc). * * Rate power table contains indices to PCDAC/PDADC table (0.5dB steps - * x values) and is indexed as follows: * rates[0] - rates[7] -> OFDM rates * rates[8] - rates[14] -> CCK rates * rates[15] -> XR rates (they all have the same power) */ /** * ath5k_setup_rate_powertable() - Set up rate power table for a given tx power * @ah: The &struct ath5k_hw * @max_pwr: The maximum tx power requested in 0.5dB steps * @rate_info: The &struct ath5k_rate_pcal_info to fill * @ee_mode: One of enum ath5k_driver_mode */ static void ath5k_setup_rate_powertable(struct ath5k_hw *ah, u16 max_pwr, struct ath5k_rate_pcal_info *rate_info, u8 ee_mode) { … } /** * ath5k_hw_txpower() - Set transmission power limit for a given channel * @ah: The &struct ath5k_hw * @channel: The &struct ieee80211_channel * @txpower: Requested tx power in 0.5dB steps * * Combines all of the above to set the requested tx power limit * on hw. */ static int ath5k_hw_txpower(struct ath5k_hw *ah, struct ieee80211_channel *channel, u8 txpower) { … } /** * ath5k_hw_set_txpower_limit() - Set txpower limit for the current channel * @ah: The &struct ath5k_hw * @txpower: The requested tx power limit in 0.5dB steps * * This function provides access to ath5k_hw_txpower to the driver in * case user or an application changes it while PHY is running. */ int ath5k_hw_set_txpower_limit(struct ath5k_hw *ah, u8 txpower) { … } /*************\ Init function \*************/ /** * ath5k_hw_phy_init() - Initialize PHY * @ah: The &struct ath5k_hw * @channel: The @struct ieee80211_channel * @mode: One of enum ath5k_driver_mode * @fast: Try a fast channel switch instead * * This is the main function used during reset to initialize PHY * or do a fast channel change if possible. * * NOTE: Do not call this one from the driver, it assumes PHY is in a * warm reset state ! */ int ath5k_hw_phy_init(struct ath5k_hw *ah, struct ieee80211_channel *channel, u8 mode, bool fast) { … }
Codebase Browser
linux