void ath9k_init_leds(struct ath9k_htc_priv *priv) { int ret; if (AR_SREV_9287(priv->ah)) priv->ah->led_pin = ATH_LED_PIN_9287; else if (AR_SREV_9271(priv->ah)) priv->ah->led_pin = ATH_LED_PIN_9271; else if (AR_DEVID_7010(priv->ah)) priv->ah->led_pin = ATH_LED_PIN_7010; else priv->ah->led_pin = ATH_LED_PIN_DEF; /* Configure gpio 1 for output */ ath9k_hw_cfg_output(priv->ah, priv->ah->led_pin, AR_GPIO_OUTPUT_MUX_AS_OUTPUT); /* LED off, active low */ ath9k_hw_set_gpio(priv->ah, priv->ah->led_pin, 1); snprintf(priv->led_name, sizeof(priv->led_name), "ath9k_htc-%s", wiphy_name(priv->hw->wiphy)); priv->led_cdev.name = priv->led_name; priv->led_cdev.brightness_set = ath9k_led_brightness; ret = led_classdev_register(wiphy_dev(priv->hw->wiphy), &priv->led_cdev); if (ret < 0) return; INIT_WORK(&priv->led_work, ath9k_led_work); priv->led_registered = true; return; }
void ar9285_setup(struct athn_softc *sc) { const struct ar9285_eeprom *eep = sc->eep; uint8_t type; /* Select initialization values based on ROM. */ type = eep->baseEepHeader.txGainType; DPRINTF(("Tx gain type=0x%x\n", type)); #if NATHN_USB > 0 if (AR_SREV_9271(sc)) { if (type == AR_EEP_TXGAIN_HIGH_POWER) sc->tx_gain = &ar9271_tx_gain_high_power; else sc->tx_gain = &ar9271_tx_gain; } else #endif /* NATHN_USB */ if ((AR_READ(sc, AR_AN_SYNTH9) & 0x7) == 0x1) { /* XE rev. */ if (type == AR_EEP_TXGAIN_HIGH_POWER) sc->tx_gain = &ar9285_2_0_tx_gain_high_power; else sc->tx_gain = &ar9285_2_0_tx_gain; } else { if (type == AR_EEP_TXGAIN_HIGH_POWER) sc->tx_gain = &ar9285_1_2_tx_gain_high_power; else sc->tx_gain = &ar9285_1_2_tx_gain; } }
static void ar9002_hw_set11n_txdesc(struct ath_hw *ah, void *ds, u32 pktLen, enum ath9k_pkt_type type, u32 txPower, u8 keyIx, enum ath9k_key_type keyType, u32 flags) { struct ar5416_desc *ads = AR5416DESC(ds); if (txPower > 63) txPower = 63; ads->ds_ctl0 = (pktLen & AR_FrameLen) | (flags & ATH9K_TXDESC_VMF ? AR_VirtMoreFrag : 0) | SM(txPower, AR_XmitPower) | (flags & ATH9K_TXDESC_VEOL ? AR_VEOL : 0) | (flags & ATH9K_TXDESC_INTREQ ? AR_TxIntrReq : 0) | (keyIx != ATH9K_TXKEYIX_INVALID ? AR_DestIdxValid : 0); ads->ds_ctl1 = (keyIx != ATH9K_TXKEYIX_INVALID ? SM(keyIx, AR_DestIdx) : 0) | SM(type, AR_FrameType) | (flags & ATH9K_TXDESC_NOACK ? AR_NoAck : 0) | (flags & ATH9K_TXDESC_EXT_ONLY ? AR_ExtOnly : 0) | (flags & ATH9K_TXDESC_EXT_AND_CTL ? AR_ExtAndCtl : 0); ads->ds_ctl6 = SM(keyType, AR_EncrType); if (AR_SREV_9285(ah) || AR_SREV_9271(ah)) { ads->ds_ctl8 = 0; ads->ds_ctl9 = 0; ads->ds_ctl10 = 0; ads->ds_ctl11 = 0; } }
int ar9285_attach(struct athn_softc *sc) { sc->eep_base = AR9285_EEP_START_LOC; sc->eep_size = sizeof(struct ar9285_eeprom); sc->def_nf = AR9285_PHY_CCA_MAX_GOOD_VALUE; sc->ngpiopins = (sc->flags & ATHN_FLAG_USB) ? 16 : 12; sc->led_pin = (sc->flags & ATHN_FLAG_USB) ? 15 : 1; sc->workaround = AR9285_WA_DEFAULT; sc->ops.setup = ar9285_setup; sc->ops.swap_rom = ar9285_swap_rom; sc->ops.init_from_rom = ar9285_init_from_rom; sc->ops.set_txpower = ar9285_set_txpower; sc->ops.set_synth = ar9280_set_synth; sc->ops.spur_mitigate = ar9280_spur_mitigate; sc->ops.get_spur_chans = ar9285_get_spur_chans; #if NATHN_USB > 0 if (AR_SREV_9271(sc)) sc->ini = &ar9271_ini; else #endif sc->ini = &ar9285_1_2_ini; sc->serdes = ar9280_2_0_serdes; return (ar5008_attach(sc)); }
void ath9k_cmn_setup_ht_cap(struct ath_hw *ah, struct ieee80211_sta_ht_cap *ht_info) { struct ath_common *common = ath9k_hw_common(ah); u8 tx_streams, rx_streams; int i, max_streams; ht_info->ht_supported = true; ht_info->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 | IEEE80211_HT_CAP_SM_PS | IEEE80211_HT_CAP_SGI_40 | IEEE80211_HT_CAP_DSSSCCK40; if (ah->caps.hw_caps & ATH9K_HW_CAP_LDPC) ht_info->cap |= IEEE80211_HT_CAP_LDPC_CODING; if (ah->caps.hw_caps & ATH9K_HW_CAP_SGI_20) ht_info->cap |= IEEE80211_HT_CAP_SGI_20; ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_8; if (AR_SREV_9271(ah) || AR_SREV_9330(ah) || AR_SREV_9485(ah) || AR_SREV_9565(ah)) max_streams = 1; else if (AR_SREV_9462(ah)) max_streams = 2; else if (AR_SREV_9300_20_OR_LATER(ah)) max_streams = 3; else max_streams = 2; if (AR_SREV_9280_20_OR_LATER(ah)) { if (max_streams >= 2) ht_info->cap |= IEEE80211_HT_CAP_TX_STBC; ht_info->cap |= (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT); } /* set up supported mcs set */ memset(&ht_info->mcs, 0, sizeof(ht_info->mcs)); tx_streams = ath9k_cmn_count_streams(ah->txchainmask, max_streams); rx_streams = ath9k_cmn_count_streams(ah->rxchainmask, max_streams); ath_dbg(common, CONFIG, "TX streams %d, RX streams: %d\n", tx_streams, rx_streams); if (tx_streams != rx_streams) { ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF; ht_info->mcs.tx_params |= ((tx_streams - 1) << IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT); } for (i = 0; i < rx_streams; i++) ht_info->mcs.rx_mask[i] = 0xff; ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; }
static ssize_t read_file_modal_eeprom(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct ath9k_htc_priv *priv = file->private_data; if (AR_SREV_9271(priv->ah)) return read_4k_modal_eeprom(file, user_buf, count, ppos); else if (priv->ah->hw_version.usbdev == AR9280_USB) return read_def_modal_eeprom(file, user_buf, count, ppos); else if (priv->ah->hw_version.usbdev == AR9287_USB) return read_9287_modal_eeprom(file, user_buf, count, ppos); return 0; }
bool ath9k_hw_calibrate(struct ath_hw *ah, struct ath9k_channel *chan, u8 rxchainmask, bool longcal) { bool iscaldone = true; struct ath9k_cal_list *currCal = ah->cal_list_curr; if (currCal && (currCal->calState == CAL_RUNNING || currCal->calState == CAL_WAITING)) { iscaldone = ath9k_hw_per_calibration(ah, chan, rxchainmask, currCal); if (iscaldone) { ah->cal_list_curr = currCal = currCal->calNext; if (currCal->calState == CAL_WAITING) { iscaldone = false; ath9k_hw_reset_calibration(ah, currCal); } } } /* Do NF cal only at longer intervals */ if (longcal) { /* Do periodic PAOffset Cal */ if (AR_SREV_9271(ah)) ath9k_hw_9271_pa_cal(ah); else if (AR_SREV_9285_11_OR_LATER(ah)) { if (!ah->pacal_info.skipcount) ath9k_hw_9285_pa_cal(ah, false); else ah->pacal_info.skipcount--; } if (OLC_FOR_AR9280_20_LATER || OLC_FOR_AR9287_10_LATER) ath9k_olc_temp_compensation(ah); /* Get the value from the previous NF cal and update history buffer */ ath9k_hw_getnf(ah, chan); /* * Load the NF from history buffer of the current channel. * NF is slow time-variant, so it is OK to use a historical value. */ ath9k_hw_loadnf(ah, ah->curchan); ath9k_hw_start_nfcal(ah); } return iscaldone; }
struct base_eep_header *ath9k_htc_get_eeprom_base(struct ath9k_htc_priv *priv) { struct base_eep_header *pBase = NULL; /* * This can be done since all the 3 EEPROM families have the * same base header upto a certain point, and we are interested in * the data only upto that point. */ if (AR_SREV_9271(priv->ah)) pBase = (struct base_eep_header *) &priv->ah->eeprom.map4k.baseEepHeader; else if (priv->ah->hw_version.usbdev == AR9280_USB) pBase = (struct base_eep_header *) &priv->ah->eeprom.def.baseEepHeader; else if (priv->ah->hw_version.usbdev == AR9287_USB) pBase = (struct base_eep_header *) &priv->ah->eeprom.map9287.baseEepHeader; return pBase; }
int ath9k_hw_eeprom_init(struct ath_hw *ah) { int status; if (AR_SREV_9300_20_OR_LATER(ah)) ah->eep_ops = &eep_ar9300_ops; else if (AR_SREV_9287(ah)) { ah->eep_ops = &eep_ar9287_ops; } else if (AR_SREV_9285(ah) || AR_SREV_9271(ah)) { ah->eep_ops = &eep_4k_ops; } else { ah->eep_ops = &eep_def_ops; } if (!ah->eep_ops->fill_eeprom(ah)) return -EIO; status = ah->eep_ops->check_eeprom(ah); return status; }
int ath9k_hw_eeprom_init(struct ath_hw *ah) { int status; if (AR_SREV_9287(ah)) { ah->eep_map = EEP_MAP_AR9287; ah->eep_ops = &eep_AR9287_ops; } else if (AR_SREV_9285(ah) || AR_SREV_9271(ah)) { ah->eep_map = EEP_MAP_4KBITS; ah->eep_ops = &eep_4k_ops; } else { ah->eep_map = EEP_MAP_DEFAULT; ah->eep_ops = &eep_def_ops; } if (!ah->eep_ops->fill_eeprom(ah)) return -EIO; status = ah->eep_ops->check_eeprom(ah); return status; }
void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah) { int i, j; s16 noise_floor; if (AR_SREV_9280(ah)) noise_floor = AR_PHY_CCA_MAX_AR9280_GOOD_VALUE; else if (AR_SREV_9285(ah) || AR_SREV_9271(ah)) noise_floor = AR_PHY_CCA_MAX_AR9285_GOOD_VALUE; else if (AR_SREV_9287(ah)) noise_floor = AR_PHY_CCA_MAX_AR9287_GOOD_VALUE; else noise_floor = AR_PHY_CCA_MAX_AR5416_GOOD_VALUE; for (i = 0; i < NUM_NF_READINGS; i++) { ah->nfCalHist[i].currIndex = 0; ah->nfCalHist[i].privNF = noise_floor; ah->nfCalHist[i].invalidNFcount = AR_PHY_CCA_FILTERWINDOW_LENGTH; for (j = 0; j < ATH9K_NF_CAL_HIST_MAX; j++) { ah->nfCalHist[i].nfCalBuffer[j] = noise_floor; } } }
static ssize_t read_file_base_eeprom(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { struct ath9k_htc_priv *priv = file->private_data; struct ath_common *common = ath9k_hw_common(priv->ah); struct base_eep_header *pBase = NULL; unsigned int len = 0, size = 1500; ssize_t retval = 0; char *buf; /* * This can be done since all the 3 EEPROM families have the * same base header upto a certain point, and we are interested in * the data only upto that point. */ if (AR_SREV_9271(priv->ah)) pBase = (struct base_eep_header *) &priv->ah->eeprom.map4k.baseEepHeader; else if (priv->ah->hw_version.usbdev == AR9280_USB) pBase = (struct base_eep_header *) &priv->ah->eeprom.def.baseEepHeader; else if (priv->ah->hw_version.usbdev == AR9287_USB) pBase = (struct base_eep_header *) &priv->ah->eeprom.map9287.baseEepHeader; if (pBase == NULL) { ath_err(common, "Unknown EEPROM type\n"); return 0; } buf = kzalloc(size, GFP_KERNEL); if (buf == NULL) return -ENOMEM; len += snprintf(buf + len, size - len, "%20s : %10d\n", "Major Version", pBase->version >> 12); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Minor Version", pBase->version & 0xFFF); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Checksum", pBase->checksum); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Length", pBase->length); len += snprintf(buf + len, size - len, "%20s : %10d\n", "RegDomain1", pBase->regDmn[0]); len += snprintf(buf + len, size - len, "%20s : %10d\n", "RegDomain2", pBase->regDmn[1]); len += snprintf(buf + len, size - len, "%20s : %10d\n", "TX Mask", pBase->txMask); len += snprintf(buf + len, size - len, "%20s : %10d\n", "RX Mask", pBase->rxMask); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Allow 5GHz", !!(pBase->opCapFlags & AR5416_OPFLAGS_11A)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Allow 2GHz", !!(pBase->opCapFlags & AR5416_OPFLAGS_11G)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Disable 2GHz HT20", !!(pBase->opCapFlags & AR5416_OPFLAGS_N_2G_HT20)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Disable 2GHz HT40", !!(pBase->opCapFlags & AR5416_OPFLAGS_N_2G_HT40)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Disable 5Ghz HT20", !!(pBase->opCapFlags & AR5416_OPFLAGS_N_5G_HT20)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Disable 5Ghz HT40", !!(pBase->opCapFlags & AR5416_OPFLAGS_N_5G_HT40)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Big Endian", !!(pBase->eepMisc & 0x01)); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Cal Bin Major Ver", (pBase->binBuildNumber >> 24) & 0xFF); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Cal Bin Minor Ver", (pBase->binBuildNumber >> 16) & 0xFF); len += snprintf(buf + len, size - len, "%20s : %10d\n", "Cal Bin Build", (pBase->binBuildNumber >> 8) & 0xFF); /* * UB91 specific data. */ if (AR_SREV_9271(priv->ah)) { struct base_eep_header_4k *pBase4k = &priv->ah->eeprom.map4k.baseEepHeader; len += snprintf(buf + len, size - len, "%20s : %10d\n", "TX Gain type", pBase4k->txGainType); } /* * UB95 specific data. */ if (priv->ah->hw_version.usbdev == AR9287_USB) { struct base_eep_ar9287_header *pBase9287 = &priv->ah->eeprom.map9287.baseEepHeader; len += snprintf(buf + len, size - len, "%20s : %10ddB\n", "Power Table Offset", pBase9287->pwrTableOffset); len += snprintf(buf + len, size - len, "%20s : %10d\n", "OpenLoop Power Ctrl", pBase9287->openLoopPwrCntl); } len += snprintf(buf + len, size - len, "%20s : %pM\n", "MacAddress", pBase->macAddr); if (len > size) len = size; retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); kfree(buf); return retval; }
void ath9k_hw_get_gain_boundaries_pdadcs(struct ath_hw *ah, struct ath9k_channel *chan, void *pRawDataSet, u8 *bChans, u16 availPiers, u16 tPdGainOverlap, u16 *pPdGainBoundaries, u8 *pPDADCValues, u16 numXpdGains) { int i, j, k; int16_t ss; u16 idxL = 0, idxR = 0, numPiers; static u8 vpdTableL[AR5416_NUM_PD_GAINS] [AR5416_MAX_PWR_RANGE_IN_HALF_DB]; static u8 vpdTableR[AR5416_NUM_PD_GAINS] [AR5416_MAX_PWR_RANGE_IN_HALF_DB]; static u8 vpdTableI[AR5416_NUM_PD_GAINS] [AR5416_MAX_PWR_RANGE_IN_HALF_DB]; u8 *pVpdL, *pVpdR, *pPwrL, *pPwrR; u8 minPwrT4[AR5416_NUM_PD_GAINS]; u8 maxPwrT4[AR5416_NUM_PD_GAINS]; int16_t vpdStep; int16_t tmpVal; u16 sizeCurrVpdTable, maxIndex, tgtIndex; bool match; int16_t minDelta = 0; struct chan_centers centers; int pdgain_boundary_default; struct cal_data_per_freq *data_def = pRawDataSet; struct cal_data_per_freq_4k *data_4k = pRawDataSet; struct cal_data_per_freq_ar9287 *data_9287 = pRawDataSet; bool eeprom_4k = AR_SREV_9285(ah) || AR_SREV_9271(ah); int intercepts; if (AR_SREV_9287(ah)) intercepts = AR9287_PD_GAIN_ICEPTS; else intercepts = AR5416_PD_GAIN_ICEPTS; memset(&minPwrT4, 0, AR5416_NUM_PD_GAINS); ath9k_hw_get_channel_centers(ah, chan, ¢ers); for (numPiers = 0; numPiers < availPiers; numPiers++) { if (bChans[numPiers] == AR5416_BCHAN_UNUSED) break; } match = ath9k_hw_get_lower_upper_index((u8)FREQ2FBIN(centers.synth_center, IS_CHAN_2GHZ(chan)), bChans, numPiers, &idxL, &idxR); if (match) { if (AR_SREV_9287(ah)) { /* FIXME: array overrun? */ for (i = 0; i < numXpdGains; i++) { minPwrT4[i] = data_9287[idxL].pwrPdg[i][0]; maxPwrT4[i] = data_9287[idxL].pwrPdg[i][4]; ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i], data_9287[idxL].pwrPdg[i], data_9287[idxL].vpdPdg[i], intercepts, vpdTableI[i]); } } else if (eeprom_4k) { for (i = 0; i < numXpdGains; i++) { minPwrT4[i] = data_4k[idxL].pwrPdg[i][0]; maxPwrT4[i] = data_4k[idxL].pwrPdg[i][4]; ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i], data_4k[idxL].pwrPdg[i], data_4k[idxL].vpdPdg[i], intercepts, vpdTableI[i]); } } else { for (i = 0; i < numXpdGains; i++) { minPwrT4[i] = data_def[idxL].pwrPdg[i][0]; maxPwrT4[i] = data_def[idxL].pwrPdg[i][4]; ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i], data_def[idxL].pwrPdg[i], data_def[idxL].vpdPdg[i], intercepts, vpdTableI[i]); } } } else { for (i = 0; i < numXpdGains; i++) { if (AR_SREV_9287(ah)) { pVpdL = data_9287[idxL].vpdPdg[i]; pPwrL = data_9287[idxL].pwrPdg[i]; pVpdR = data_9287[idxR].vpdPdg[i]; pPwrR = data_9287[idxR].pwrPdg[i]; } else if (eeprom_4k) { pVpdL = data_4k[idxL].vpdPdg[i]; pPwrL = data_4k[idxL].pwrPdg[i]; pVpdR = data_4k[idxR].vpdPdg[i]; pPwrR = data_4k[idxR].pwrPdg[i]; } else { pVpdL = data_def[idxL].vpdPdg[i]; pPwrL = data_def[idxL].pwrPdg[i]; pVpdR = data_def[idxR].vpdPdg[i]; pPwrR = data_def[idxR].pwrPdg[i]; } minPwrT4[i] = max(pPwrL[0], pPwrR[0]); maxPwrT4[i] = min(pPwrL[intercepts - 1], pPwrR[intercepts - 1]); ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i], pPwrL, pVpdL, intercepts, vpdTableL[i]); ath9k_hw_fill_vpd_table(minPwrT4[i], maxPwrT4[i], pPwrR, pVpdR, intercepts, vpdTableR[i]); for (j = 0; j <= (maxPwrT4[i] - minPwrT4[i]) / 2; j++) { vpdTableI[i][j] = (u8)(ath9k_hw_interpolate((u16) FREQ2FBIN(centers. synth_center, IS_CHAN_2GHZ (chan)), bChans[idxL], bChans[idxR], vpdTableL[i][j], vpdTableR[i][j])); } } } k = 0; for (i = 0; i < numXpdGains; i++) { if (i == (numXpdGains - 1)) pPdGainBoundaries[i] = (u16)(maxPwrT4[i] / 2); else pPdGainBoundaries[i] = (u16)((maxPwrT4[i] + minPwrT4[i + 1]) / 4); pPdGainBoundaries[i] = min((u16)MAX_RATE_POWER, pPdGainBoundaries[i]); minDelta = 0; if (i == 0) { if (AR_SREV_9280_20_OR_LATER(ah)) ss = (int16_t)(0 - (minPwrT4[i] / 2)); else ss = 0; } else { ss = (int16_t)((pPdGainBoundaries[i - 1] - (minPwrT4[i] / 2)) - tPdGainOverlap + 1 + minDelta); } vpdStep = (int16_t)(vpdTableI[i][1] - vpdTableI[i][0]); vpdStep = (int16_t)((vpdStep < 1) ? 1 : vpdStep); while ((ss < 0) && (k < (AR5416_NUM_PDADC_VALUES - 1))) { tmpVal = (int16_t)(vpdTableI[i][0] + ss * vpdStep); pPDADCValues[k++] = (u8)((tmpVal < 0) ? 0 : tmpVal); ss++; } sizeCurrVpdTable = (u8) ((maxPwrT4[i] - minPwrT4[i]) / 2 + 1); tgtIndex = (u8)(pPdGainBoundaries[i] + tPdGainOverlap - (minPwrT4[i] / 2)); maxIndex = (tgtIndex < sizeCurrVpdTable) ? tgtIndex : sizeCurrVpdTable; while ((ss < maxIndex) && (k < (AR5416_NUM_PDADC_VALUES - 1))) { pPDADCValues[k++] = vpdTableI[i][ss++]; } vpdStep = (int16_t)(vpdTableI[i][sizeCurrVpdTable - 1] - vpdTableI[i][sizeCurrVpdTable - 2]); vpdStep = (int16_t)((vpdStep < 1) ? 1 : vpdStep); if (tgtIndex >= maxIndex) { while ((ss <= tgtIndex) && (k < (AR5416_NUM_PDADC_VALUES - 1))) { tmpVal = (int16_t)((vpdTableI[i][sizeCurrVpdTable - 1] + (ss - maxIndex + 1) * vpdStep)); pPDADCValues[k++] = (u8)((tmpVal > 255) ? 255 : tmpVal); ss++; } } } if (eeprom_4k) pdgain_boundary_default = 58; else pdgain_boundary_default = pPdGainBoundaries[i - 1]; while (i < AR5416_PD_GAINS_IN_MASK) { pPdGainBoundaries[i] = pdgain_boundary_default; i++; } while (k < AR5416_NUM_PDADC_VALUES) { pPDADCValues[k] = pPDADCValues[k - 1]; k++; } }