2 * Copyright (c) 2008-2011 Atheros Communications Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 void ath9k_hw_analog_shift_regwrite(struct ath_hw
*ah
, u32 reg
, u32 val
)
21 REG_WRITE(ah
, reg
, val
);
23 if (ah
->config
.analog_shiftreg
)
27 void ath9k_hw_analog_shift_rmw(struct ath_hw
*ah
, u32 reg
, u32 mask
,
32 regVal
= REG_READ(ah
, reg
) & ~mask
;
33 regVal
|= (val
<< shift
) & mask
;
35 REG_WRITE(ah
, reg
, regVal
);
37 if (ah
->config
.analog_shiftreg
)
41 int16_t ath9k_hw_interpolate(u16 target
, u16 srcLeft
, u16 srcRight
,
42 int16_t targetLeft
, int16_t targetRight
)
46 if (srcRight
== srcLeft
) {
49 rv
= (int16_t) (((target
- srcLeft
) * targetRight
+
50 (srcRight
- target
) * targetLeft
) /
51 (srcRight
- srcLeft
));
56 bool ath9k_hw_get_lower_upper_index(u8 target
, u8
*pList
, u16 listSize
,
57 u16
*indexL
, u16
*indexR
)
61 if (target
<= pList
[0]) {
62 *indexL
= *indexR
= 0;
65 if (target
>= pList
[listSize
- 1]) {
66 *indexL
= *indexR
= (u16
) (listSize
- 1);
70 for (i
= 0; i
< listSize
- 1; i
++) {
71 if (pList
[i
] == target
) {
72 *indexL
= *indexR
= i
;
75 if (target
< pList
[i
+ 1]) {
77 *indexR
= (u16
) (i
+ 1);
84 void ath9k_hw_usb_gen_fill_eeprom(struct ath_hw
*ah
, u16
*eep_data
,
85 int eep_start_loc
, int size
)
91 for (addr
= 0; addr
< size
; addr
++) {
92 addrdata
[i
] = AR5416_EEPROM_OFFSET
+
93 ((addr
+ eep_start_loc
) << AR5416_EEPROM_S
);
96 REG_READ_MULTI(ah
, addrdata
, data
, i
);
98 for (j
= 0; j
< i
; j
++) {
107 REG_READ_MULTI(ah
, addrdata
, data
, i
);
109 for (j
= 0; j
< i
; j
++) {
116 bool ath9k_hw_nvram_read(struct ath_hw
*ah
, u32 off
, u16
*data
)
118 struct ath_common
*common
= ath9k_hw_common(ah
);
121 ret
= common
->bus_ops
->eeprom_read(common
, off
, data
);
123 ath_dbg(common
, EEPROM
,
124 "unable to read eeprom region at offset %u\n", off
);
129 void ath9k_hw_fill_vpd_table(u8 pwrMin
, u8 pwrMax
, u8
*pPwrList
,
130 u8
*pVpdList
, u16 numIntercepts
,
135 u16 idxL
= 0, idxR
= 0;
137 for (i
= 0; i
<= (pwrMax
- pwrMin
) / 2; i
++) {
138 ath9k_hw_get_lower_upper_index(currPwr
, pPwrList
,
139 numIntercepts
, &(idxL
),
143 if (idxL
== numIntercepts
- 1)
144 idxL
= (u16
) (numIntercepts
- 2);
145 if (pPwrList
[idxL
] == pPwrList
[idxR
])
148 k
= (u16
)(((currPwr
- pPwrList
[idxL
]) * pVpdList
[idxR
] +
149 (pPwrList
[idxR
] - currPwr
) * pVpdList
[idxL
]) /
150 (pPwrList
[idxR
] - pPwrList
[idxL
]));
151 pRetVpdList
[i
] = (u8
) k
;
156 void ath9k_hw_get_legacy_target_powers(struct ath_hw
*ah
,
157 struct ath9k_channel
*chan
,
158 struct cal_target_power_leg
*powInfo
,
160 struct cal_target_power_leg
*pNewPower
,
161 u16 numRates
, bool isExtTarget
)
163 struct chan_centers centers
;
166 int matchIndex
= -1, lowIndex
= -1;
169 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
170 freq
= (isExtTarget
) ? centers
.ext_center
: centers
.ctl_center
;
172 if (freq
<= ath9k_hw_fbin2freq(powInfo
[0].bChannel
,
173 IS_CHAN_2GHZ(chan
))) {
176 for (i
= 0; (i
< numChannels
) &&
177 (powInfo
[i
].bChannel
!= AR5416_BCHAN_UNUSED
); i
++) {
178 if (freq
== ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
179 IS_CHAN_2GHZ(chan
))) {
182 } else if (freq
< ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
183 IS_CHAN_2GHZ(chan
)) && i
> 0 &&
184 freq
> ath9k_hw_fbin2freq(powInfo
[i
- 1].bChannel
,
185 IS_CHAN_2GHZ(chan
))) {
190 if ((matchIndex
== -1) && (lowIndex
== -1))
194 if (matchIndex
!= -1) {
195 *pNewPower
= powInfo
[matchIndex
];
197 clo
= ath9k_hw_fbin2freq(powInfo
[lowIndex
].bChannel
,
199 chi
= ath9k_hw_fbin2freq(powInfo
[lowIndex
+ 1].bChannel
,
202 for (i
= 0; i
< numRates
; i
++) {
203 pNewPower
->tPow2x
[i
] =
204 (u8
)ath9k_hw_interpolate(freq
, clo
, chi
,
205 powInfo
[lowIndex
].tPow2x
[i
],
206 powInfo
[lowIndex
+ 1].tPow2x
[i
]);
211 void ath9k_hw_get_target_powers(struct ath_hw
*ah
,
212 struct ath9k_channel
*chan
,
213 struct cal_target_power_ht
*powInfo
,
215 struct cal_target_power_ht
*pNewPower
,
216 u16 numRates
, bool isHt40Target
)
218 struct chan_centers centers
;
221 int matchIndex
= -1, lowIndex
= -1;
224 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
225 freq
= isHt40Target
? centers
.synth_center
: centers
.ctl_center
;
227 if (freq
<= ath9k_hw_fbin2freq(powInfo
[0].bChannel
, IS_CHAN_2GHZ(chan
))) {
230 for (i
= 0; (i
< numChannels
) &&
231 (powInfo
[i
].bChannel
!= AR5416_BCHAN_UNUSED
); i
++) {
232 if (freq
== ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
233 IS_CHAN_2GHZ(chan
))) {
237 if (freq
< ath9k_hw_fbin2freq(powInfo
[i
].bChannel
,
238 IS_CHAN_2GHZ(chan
)) && i
> 0 &&
239 freq
> ath9k_hw_fbin2freq(powInfo
[i
- 1].bChannel
,
240 IS_CHAN_2GHZ(chan
))) {
245 if ((matchIndex
== -1) && (lowIndex
== -1))
249 if (matchIndex
!= -1) {
250 *pNewPower
= powInfo
[matchIndex
];
252 clo
= ath9k_hw_fbin2freq(powInfo
[lowIndex
].bChannel
,
254 chi
= ath9k_hw_fbin2freq(powInfo
[lowIndex
+ 1].bChannel
,
257 for (i
= 0; i
< numRates
; i
++) {
258 pNewPower
->tPow2x
[i
] = (u8
)ath9k_hw_interpolate(freq
,
260 powInfo
[lowIndex
].tPow2x
[i
],
261 powInfo
[lowIndex
+ 1].tPow2x
[i
]);
266 u16
ath9k_hw_get_max_edge_power(u16 freq
, struct cal_ctl_edges
*pRdEdgesPower
,
267 bool is2GHz
, int num_band_edges
)
269 u16 twiceMaxEdgePower
= MAX_RATE_POWER
;
272 for (i
= 0; (i
< num_band_edges
) &&
273 (pRdEdgesPower
[i
].bChannel
!= AR5416_BCHAN_UNUSED
); i
++) {
274 if (freq
== ath9k_hw_fbin2freq(pRdEdgesPower
[i
].bChannel
, is2GHz
)) {
275 twiceMaxEdgePower
= CTL_EDGE_TPOWER(pRdEdgesPower
[i
].ctl
);
277 } else if ((i
> 0) &&
278 (freq
< ath9k_hw_fbin2freq(pRdEdgesPower
[i
].bChannel
,
280 if (ath9k_hw_fbin2freq(pRdEdgesPower
[i
- 1].bChannel
,
282 CTL_EDGE_FLAGS(pRdEdgesPower
[i
- 1].ctl
)) {
284 CTL_EDGE_TPOWER(pRdEdgesPower
[i
- 1].ctl
);
290 return twiceMaxEdgePower
;
293 u16
ath9k_hw_get_scaled_power(struct ath_hw
*ah
, u16 power_limit
,
294 u8 antenna_reduction
)
296 u16 reduction
= antenna_reduction
;
299 * Reduce scaled Power by number of chains active
300 * to get the per chain tx power level.
302 switch (ar5416_get_ntxchains(ah
->txchainmask
)) {
306 reduction
+= POWER_CORRECTION_FOR_TWO_CHAIN
;
309 reduction
+= POWER_CORRECTION_FOR_THREE_CHAIN
;
313 if (power_limit
> reduction
)
314 power_limit
-= reduction
;
321 void ath9k_hw_update_regulatory_maxpower(struct ath_hw
*ah
)
323 struct ath_common
*common
= ath9k_hw_common(ah
);
324 struct ath_regulatory
*regulatory
= ath9k_hw_regulatory(ah
);
326 switch (ar5416_get_ntxchains(ah
->txchainmask
)) {
330 regulatory
->max_power_level
+= POWER_CORRECTION_FOR_TWO_CHAIN
;
333 regulatory
->max_power_level
+= POWER_CORRECTION_FOR_THREE_CHAIN
;
336 ath_dbg(common
, EEPROM
, "Invalid chainmask configuration\n");
341 void ath9k_hw_get_gain_boundaries_pdadcs(struct ath_hw
*ah
,
342 struct ath9k_channel
*chan
,
344 u8
*bChans
, u16 availPiers
,
346 u16
*pPdGainBoundaries
, u8
*pPDADCValues
,
351 u16 idxL
= 0, idxR
= 0, numPiers
;
352 static u8 vpdTableL
[AR5416_NUM_PD_GAINS
]
353 [AR5416_MAX_PWR_RANGE_IN_HALF_DB
];
354 static u8 vpdTableR
[AR5416_NUM_PD_GAINS
]
355 [AR5416_MAX_PWR_RANGE_IN_HALF_DB
];
356 static u8 vpdTableI
[AR5416_NUM_PD_GAINS
]
357 [AR5416_MAX_PWR_RANGE_IN_HALF_DB
];
359 u8
*pVpdL
, *pVpdR
, *pPwrL
, *pPwrR
;
360 u8 minPwrT4
[AR5416_NUM_PD_GAINS
];
361 u8 maxPwrT4
[AR5416_NUM_PD_GAINS
];
364 u16 sizeCurrVpdTable
, maxIndex
, tgtIndex
;
366 int16_t minDelta
= 0;
367 struct chan_centers centers
;
368 int pdgain_boundary_default
;
369 struct cal_data_per_freq
*data_def
= pRawDataSet
;
370 struct cal_data_per_freq_4k
*data_4k
= pRawDataSet
;
371 struct cal_data_per_freq_ar9287
*data_9287
= pRawDataSet
;
372 bool eeprom_4k
= AR_SREV_9285(ah
) || AR_SREV_9271(ah
);
375 if (AR_SREV_9287(ah
))
376 intercepts
= AR9287_PD_GAIN_ICEPTS
;
378 intercepts
= AR5416_PD_GAIN_ICEPTS
;
380 memset(&minPwrT4
, 0, AR5416_NUM_PD_GAINS
);
381 ath9k_hw_get_channel_centers(ah
, chan
, ¢ers
);
383 for (numPiers
= 0; numPiers
< availPiers
; numPiers
++) {
384 if (bChans
[numPiers
] == AR5416_BCHAN_UNUSED
)
388 match
= ath9k_hw_get_lower_upper_index((u8
)FREQ2FBIN(centers
.synth_center
,
390 bChans
, numPiers
, &idxL
, &idxR
);
393 if (AR_SREV_9287(ah
)) {
394 /* FIXME: array overrun? */
395 for (i
= 0; i
< numXpdGains
; i
++) {
396 minPwrT4
[i
] = data_9287
[idxL
].pwrPdg
[i
][0];
397 maxPwrT4
[i
] = data_9287
[idxL
].pwrPdg
[i
][4];
398 ath9k_hw_fill_vpd_table(minPwrT4
[i
], maxPwrT4
[i
],
399 data_9287
[idxL
].pwrPdg
[i
],
400 data_9287
[idxL
].vpdPdg
[i
],
404 } else if (eeprom_4k
) {
405 for (i
= 0; i
< numXpdGains
; i
++) {
406 minPwrT4
[i
] = data_4k
[idxL
].pwrPdg
[i
][0];
407 maxPwrT4
[i
] = data_4k
[idxL
].pwrPdg
[i
][4];
408 ath9k_hw_fill_vpd_table(minPwrT4
[i
], maxPwrT4
[i
],
409 data_4k
[idxL
].pwrPdg
[i
],
410 data_4k
[idxL
].vpdPdg
[i
],
415 for (i
= 0; i
< numXpdGains
; i
++) {
416 minPwrT4
[i
] = data_def
[idxL
].pwrPdg
[i
][0];
417 maxPwrT4
[i
] = data_def
[idxL
].pwrPdg
[i
][4];
418 ath9k_hw_fill_vpd_table(minPwrT4
[i
], maxPwrT4
[i
],
419 data_def
[idxL
].pwrPdg
[i
],
420 data_def
[idxL
].vpdPdg
[i
],
426 for (i
= 0; i
< numXpdGains
; i
++) {
427 if (AR_SREV_9287(ah
)) {
428 pVpdL
= data_9287
[idxL
].vpdPdg
[i
];
429 pPwrL
= data_9287
[idxL
].pwrPdg
[i
];
430 pVpdR
= data_9287
[idxR
].vpdPdg
[i
];
431 pPwrR
= data_9287
[idxR
].pwrPdg
[i
];
432 } else if (eeprom_4k
) {
433 pVpdL
= data_4k
[idxL
].vpdPdg
[i
];
434 pPwrL
= data_4k
[idxL
].pwrPdg
[i
];
435 pVpdR
= data_4k
[idxR
].vpdPdg
[i
];
436 pPwrR
= data_4k
[idxR
].pwrPdg
[i
];
438 pVpdL
= data_def
[idxL
].vpdPdg
[i
];
439 pPwrL
= data_def
[idxL
].pwrPdg
[i
];
440 pVpdR
= data_def
[idxR
].vpdPdg
[i
];
441 pPwrR
= data_def
[idxR
].pwrPdg
[i
];
444 minPwrT4
[i
] = max(pPwrL
[0], pPwrR
[0]);
447 min(pPwrL
[intercepts
- 1],
448 pPwrR
[intercepts
- 1]);
451 ath9k_hw_fill_vpd_table(minPwrT4
[i
], maxPwrT4
[i
],
455 ath9k_hw_fill_vpd_table(minPwrT4
[i
], maxPwrT4
[i
],
460 for (j
= 0; j
<= (maxPwrT4
[i
] - minPwrT4
[i
]) / 2; j
++) {
462 (u8
)(ath9k_hw_interpolate((u16
)
467 bChans
[idxL
], bChans
[idxR
],
468 vpdTableL
[i
][j
], vpdTableR
[i
][j
]));
475 for (i
= 0; i
< numXpdGains
; i
++) {
476 if (i
== (numXpdGains
- 1))
477 pPdGainBoundaries
[i
] =
478 (u16
)(maxPwrT4
[i
] / 2);
480 pPdGainBoundaries
[i
] =
481 (u16
)((maxPwrT4
[i
] + minPwrT4
[i
+ 1]) / 4);
483 pPdGainBoundaries
[i
] =
484 min((u16
)MAX_RATE_POWER
, pPdGainBoundaries
[i
]);
489 if (AR_SREV_9280_20_OR_LATER(ah
))
490 ss
= (int16_t)(0 - (minPwrT4
[i
] / 2));
494 ss
= (int16_t)((pPdGainBoundaries
[i
- 1] -
496 tPdGainOverlap
+ 1 + minDelta
);
498 vpdStep
= (int16_t)(vpdTableI
[i
][1] - vpdTableI
[i
][0]);
499 vpdStep
= (int16_t)((vpdStep
< 1) ? 1 : vpdStep
);
501 while ((ss
< 0) && (k
< (AR5416_NUM_PDADC_VALUES
- 1))) {
502 tmpVal
= (int16_t)(vpdTableI
[i
][0] + ss
* vpdStep
);
503 pPDADCValues
[k
++] = (u8
)((tmpVal
< 0) ? 0 : tmpVal
);
507 sizeCurrVpdTable
= (u8
) ((maxPwrT4
[i
] - minPwrT4
[i
]) / 2 + 1);
508 tgtIndex
= (u8
)(pPdGainBoundaries
[i
] + tPdGainOverlap
-
510 maxIndex
= (tgtIndex
< sizeCurrVpdTable
) ?
511 tgtIndex
: sizeCurrVpdTable
;
513 while ((ss
< maxIndex
) && (k
< (AR5416_NUM_PDADC_VALUES
- 1))) {
514 pPDADCValues
[k
++] = vpdTableI
[i
][ss
++];
517 vpdStep
= (int16_t)(vpdTableI
[i
][sizeCurrVpdTable
- 1] -
518 vpdTableI
[i
][sizeCurrVpdTable
- 2]);
519 vpdStep
= (int16_t)((vpdStep
< 1) ? 1 : vpdStep
);
521 if (tgtIndex
>= maxIndex
) {
522 while ((ss
<= tgtIndex
) &&
523 (k
< (AR5416_NUM_PDADC_VALUES
- 1))) {
524 tmpVal
= (int16_t)((vpdTableI
[i
][sizeCurrVpdTable
- 1] +
525 (ss
- maxIndex
+ 1) * vpdStep
));
526 pPDADCValues
[k
++] = (u8
)((tmpVal
> 255) ?
534 pdgain_boundary_default
= 58;
536 pdgain_boundary_default
= pPdGainBoundaries
[i
- 1];
538 while (i
< AR5416_PD_GAINS_IN_MASK
) {
539 pPdGainBoundaries
[i
] = pdgain_boundary_default
;
543 while (k
< AR5416_NUM_PDADC_VALUES
) {
544 pPDADCValues
[k
] = pPDADCValues
[k
- 1];
549 int ath9k_hw_eeprom_init(struct ath_hw
*ah
)
553 if (AR_SREV_9300_20_OR_LATER(ah
))
554 ah
->eep_ops
= &eep_ar9300_ops
;
555 else if (AR_SREV_9287(ah
)) {
556 ah
->eep_ops
= &eep_ar9287_ops
;
557 } else if (AR_SREV_9285(ah
) || AR_SREV_9271(ah
)) {
558 ah
->eep_ops
= &eep_4k_ops
;
560 ah
->eep_ops
= &eep_def_ops
;
563 if (!ah
->eep_ops
->fill_eeprom(ah
))
566 status
= ah
->eep_ops
->check_eeprom(ah
);