254 lines
7.6 KiB
C
254 lines
7.6 KiB
C
/*
|
|
* Copyright (c) 2008 Sam Leffler, Errno Consulting
|
|
* Copyright (c) 2008 Atheros Communications, Inc.
|
|
*
|
|
* Permission to use, copy, modify, and/or 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.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
#include "opt_ah.h"
|
|
|
|
#include "ah.h"
|
|
#include "ah_internal.h"
|
|
#include "ah_eeprom_v1.h"
|
|
|
|
static HAL_STATUS
|
|
v1EepromGet(struct ath_hal *ah, int param, void *val)
|
|
{
|
|
HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom;
|
|
uint32_t sum;
|
|
uint16_t eeval;
|
|
uint8_t *macaddr;
|
|
int i;
|
|
|
|
switch (param) {
|
|
case AR_EEP_MACADDR: /* Get MAC Address */
|
|
sum = 0;
|
|
macaddr = val;
|
|
for (i = 0; i < 3; i++) {
|
|
if (!ath_hal_eepromRead(ah, AR_EEPROM_MAC(i), &eeval)) {
|
|
HALDEBUG(ah, HAL_DEBUG_ANY,
|
|
"%s: cannot read EEPROM location %u\n",
|
|
__func__, i);
|
|
return HAL_EEREAD;
|
|
}
|
|
sum += eeval;
|
|
macaddr[2*i + 0] = eeval >> 8;
|
|
macaddr[2*i + 1] = eeval & 0xff;
|
|
}
|
|
if (sum == 0 || sum == 0xffff*3) {
|
|
HALDEBUG(ah, HAL_DEBUG_ANY, "%s: bad mac address %s\n",
|
|
__func__, ath_hal_ether_sprintf(macaddr));
|
|
return HAL_EEBADMAC;
|
|
}
|
|
return HAL_OK;
|
|
case AR_EEP_REGDMN_0:
|
|
*(uint16_t *) val = ee->ee_regDomain[0];
|
|
return HAL_OK;
|
|
case AR_EEP_RFKILL:
|
|
HALASSERT(val == AH_NULL);
|
|
return ee->ee_rfKill ? HAL_OK : HAL_EIO;
|
|
case AR_EEP_WRITEPROTECT:
|
|
HALASSERT(val == AH_NULL);
|
|
return (ee->ee_protect & AR_EEPROM_PROTOTECT_WP_128_191) ?
|
|
HAL_OK : HAL_EIO;
|
|
default:
|
|
HALASSERT(0);
|
|
return HAL_EINVAL;
|
|
}
|
|
}
|
|
|
|
static HAL_BOOL
|
|
v1EepromSet(struct ath_hal *ah, int param, int v)
|
|
{
|
|
return HAL_EINVAL;
|
|
}
|
|
|
|
static HAL_BOOL
|
|
v1EepromDiag(struct ath_hal *ah, int request,
|
|
const void *args, uint32_t argsize, void **result, uint32_t *resultsize)
|
|
{
|
|
HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom;
|
|
|
|
switch (request) {
|
|
case HAL_DIAG_EEPROM:
|
|
*result = ee;
|
|
*resultsize = sizeof(*ee);
|
|
return AH_TRUE;
|
|
}
|
|
return AH_FALSE;
|
|
}
|
|
|
|
static uint16_t
|
|
v1EepromGetSpurChan(struct ath_hal *ah, int ix, HAL_BOOL is2GHz)
|
|
{
|
|
return AR_NO_SPUR;
|
|
}
|
|
|
|
/*
|
|
* Reclaim any EEPROM-related storage.
|
|
*/
|
|
static void
|
|
v1EepromDetach(struct ath_hal *ah)
|
|
{
|
|
HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom;
|
|
|
|
ath_hal_free(ee);
|
|
AH_PRIVATE(ah)->ah_eeprom = AH_NULL;
|
|
}
|
|
|
|
HAL_STATUS
|
|
ath_hal_v1EepromAttach(struct ath_hal *ah)
|
|
{
|
|
HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom;
|
|
uint16_t athvals[AR_EEPROM_ATHEROS_MAX]; /* XXX off stack */
|
|
uint16_t protect, eeprom_version, eeval;
|
|
uint32_t sum;
|
|
int i, loc;
|
|
|
|
HALASSERT(ee == AH_NULL);
|
|
|
|
if (!ath_hal_eepromRead(ah, AR_EEPROM_MAGIC, &eeval)) {
|
|
HALDEBUG(ah, HAL_DEBUG_ANY,
|
|
"%s: cannot read EEPROM magic number\n", __func__);
|
|
return HAL_EEREAD;
|
|
}
|
|
if (eeval != 0x5aa5) {
|
|
HALDEBUG(ah, HAL_DEBUG_ANY,
|
|
"%s: invalid EEPROM magic number 0x%x\n", __func__, eeval);
|
|
return HAL_EEMAGIC;
|
|
}
|
|
|
|
if (!ath_hal_eepromRead(ah, AR_EEPROM_PROTECT, &protect)) {
|
|
HALDEBUG(ah, HAL_DEBUG_ANY,
|
|
"%s: cannot read EEPROM protection bits; read locked?\n",
|
|
__func__);
|
|
return HAL_EEREAD;
|
|
}
|
|
HALDEBUG(ah, HAL_DEBUG_ATTACH, "EEPROM protect 0x%x\n", protect);
|
|
/* XXX check proper access before continuing */
|
|
|
|
if (!ath_hal_eepromRead(ah, AR_EEPROM_VERSION, &eeprom_version)) {
|
|
HALDEBUG(ah, HAL_DEBUG_ANY,
|
|
"%s: unable to read EEPROM version\n", __func__);
|
|
return HAL_EEREAD;
|
|
}
|
|
if (((eeprom_version>>12) & 0xf) != 1) {
|
|
/*
|
|
* This code only groks the version 1 EEPROM layout.
|
|
*/
|
|
HALDEBUG(ah, HAL_DEBUG_ANY,
|
|
"%s: unsupported EEPROM version 0x%x found\n",
|
|
__func__, eeprom_version);
|
|
return HAL_EEVERSION;
|
|
}
|
|
|
|
/*
|
|
* Read the Atheros EEPROM entries and calculate the checksum.
|
|
*/
|
|
sum = 0;
|
|
for (i = 0; i < AR_EEPROM_ATHEROS_MAX; i++) {
|
|
if (!ath_hal_eepromRead(ah, AR_EEPROM_ATHEROS(i), &athvals[i]))
|
|
return HAL_EEREAD;
|
|
sum ^= athvals[i];
|
|
}
|
|
if (sum != 0xffff) {
|
|
HALDEBUG(ah, HAL_DEBUG_ANY, "%s: bad EEPROM checksum 0x%x\n",
|
|
__func__, sum);
|
|
return HAL_EEBADSUM;
|
|
}
|
|
|
|
/*
|
|
* Valid checksum, fetch the regulatory domain and save values.
|
|
*/
|
|
if (!ath_hal_eepromRead(ah, AR_EEPROM_REG_DOMAIN, &eeval)) {
|
|
HALDEBUG(ah, HAL_DEBUG_ANY,
|
|
"%s: cannot read regdomain from EEPROM\n", __func__);
|
|
return HAL_EEREAD;
|
|
}
|
|
|
|
ee = ath_hal_malloc(sizeof(HAL_EEPROM_v1));
|
|
if (ee == AH_NULL) {
|
|
/* XXX message */
|
|
return HAL_ENOMEM;
|
|
}
|
|
|
|
ee->ee_version = eeprom_version;
|
|
ee->ee_protect = protect;
|
|
ee->ee_antenna = athvals[2];
|
|
ee->ee_biasCurrents = athvals[3];
|
|
ee->ee_thresh62 = athvals[4] & 0xff;
|
|
ee->ee_xlnaOn = (athvals[4] >> 8) & 0xff;
|
|
ee->ee_xpaOn = athvals[5] & 0xff;
|
|
ee->ee_xpaOff = (athvals[5] >> 8) & 0xff;
|
|
ee->ee_regDomain[0] = (athvals[6] >> 8) & 0xff;
|
|
ee->ee_regDomain[1] = athvals[6] & 0xff;
|
|
ee->ee_regDomain[2] = (athvals[7] >> 8) & 0xff;
|
|
ee->ee_regDomain[3] = athvals[7] & 0xff;
|
|
ee->ee_rfKill = athvals[8] & 0x1;
|
|
ee->ee_devType = (athvals[8] >> 1) & 0x7;
|
|
|
|
for (i = 0, loc = AR_EEPROM_ATHEROS_TP_SETTINGS; i < AR_CHANNELS_MAX; i++, loc += AR_TP_SETTINGS_SIZE) {
|
|
struct tpcMap *chan = &ee->ee_tpc[i];
|
|
|
|
/* Copy pcdac and gain_f values from EEPROM */
|
|
chan->pcdac[0] = (athvals[loc] >> 10) & 0x3F;
|
|
chan->gainF[0] = (athvals[loc] >> 4) & 0x3F;
|
|
chan->pcdac[1] = ((athvals[loc] << 2) & 0x3C)
|
|
| ((athvals[loc+1] >> 14) & 0x03);
|
|
chan->gainF[1] = (athvals[loc+1] >> 8) & 0x3F;
|
|
chan->pcdac[2] = (athvals[loc+1] >> 2) & 0x3F;
|
|
chan->gainF[2] = ((athvals[loc+1] << 4) & 0x30)
|
|
| ((athvals[loc+2] >> 12) & 0x0F);
|
|
chan->pcdac[3] = (athvals[loc+2] >> 6) & 0x3F;
|
|
chan->gainF[3] = athvals[loc+2] & 0x3F;
|
|
chan->pcdac[4] = (athvals[loc+3] >> 10) & 0x3F;
|
|
chan->gainF[4] = (athvals[loc+3] >> 4) & 0x3F;
|
|
chan->pcdac[5] = ((athvals[loc+3] << 2) & 0x3C)
|
|
| ((athvals[loc+4] >> 14) & 0x03);
|
|
chan->gainF[5] = (athvals[loc+4] >> 8) & 0x3F;
|
|
chan->pcdac[6] = (athvals[loc+4] >> 2) & 0x3F;
|
|
chan->gainF[6] = ((athvals[loc+4] << 4) & 0x30)
|
|
| ((athvals[loc+5] >> 12) & 0x0F);
|
|
chan->pcdac[7] = (athvals[loc+5] >> 6) & 0x3F;
|
|
chan->gainF[7] = athvals[loc+5] & 0x3F;
|
|
chan->pcdac[8] = (athvals[loc+6] >> 10) & 0x3F;
|
|
chan->gainF[8] = (athvals[loc+6] >> 4) & 0x3F;
|
|
chan->pcdac[9] = ((athvals[loc+6] << 2) & 0x3C)
|
|
| ((athvals[loc+7] >> 14) & 0x03);
|
|
chan->gainF[9] = (athvals[loc+7] >> 8) & 0x3F;
|
|
chan->pcdac[10] = (athvals[loc+7] >> 2) & 0x3F;
|
|
chan->gainF[10] = ((athvals[loc+7] << 4) & 0x30)
|
|
| ((athvals[loc+8] >> 12) & 0x0F);
|
|
|
|
/* Copy Regulatory Domain and Rate Information from EEPROM */
|
|
chan->rate36 = (athvals[loc+8] >> 6) & 0x3F;
|
|
chan->rate48 = athvals[loc+8] & 0x3F;
|
|
chan->rate54 = (athvals[loc+9] >> 10) & 0x3F;
|
|
chan->regdmn[0] = (athvals[loc+9] >> 4) & 0x3F;
|
|
chan->regdmn[1] = ((athvals[loc+9] << 2) & 0x3C)
|
|
| ((athvals[loc+10] >> 14) & 0x03);
|
|
chan->regdmn[2] = (athvals[loc+10] >> 8) & 0x3F;
|
|
chan->regdmn[3] = (athvals[loc+10] >> 2) & 0x3F;
|
|
}
|
|
|
|
AH_PRIVATE(ah)->ah_eeprom = ee;
|
|
AH_PRIVATE(ah)->ah_eeversion = eeprom_version;
|
|
AH_PRIVATE(ah)->ah_eepromDetach = v1EepromDetach;
|
|
AH_PRIVATE(ah)->ah_eepromGet = v1EepromGet;
|
|
AH_PRIVATE(ah)->ah_eepromSet = v1EepromSet;
|
|
AH_PRIVATE(ah)->ah_getSpurChan = v1EepromGetSpurChan;
|
|
AH_PRIVATE(ah)->ah_eepromDiag = v1EepromDiag;
|
|
return HAL_OK;
|
|
}
|