1185380Ssam/* 2185380Ssam * Copyright (c) 2008 Sam Leffler, Errno Consulting 3185380Ssam * Copyright (c) 2008 Atheros Communications, Inc. 4185380Ssam * 5185380Ssam * Permission to use, copy, modify, and/or distribute this software for any 6185380Ssam * purpose with or without fee is hereby granted, provided that the above 7185380Ssam * copyright notice and this permission notice appear in all copies. 8185380Ssam * 9185380Ssam * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10185380Ssam * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11185380Ssam * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12185380Ssam * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13185380Ssam * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14185380Ssam * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15185380Ssam * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16185380Ssam * 17204644Srpaulo * $FreeBSD$ 18185380Ssam */ 19185380Ssam#include "opt_ah.h" 20185380Ssam 21185380Ssam#include "ah.h" 22185380Ssam#include "ah_internal.h" 23185380Ssam#include "ah_eeprom_v1.h" 24185380Ssam 25185380Ssamstatic HAL_STATUS 26185380Ssamv1EepromGet(struct ath_hal *ah, int param, void *val) 27185380Ssam{ 28185380Ssam HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom; 29185380Ssam uint32_t sum; 30185380Ssam uint16_t eeval; 31185380Ssam uint8_t *macaddr; 32185380Ssam int i; 33185380Ssam 34185380Ssam switch (param) { 35185380Ssam case AR_EEP_MACADDR: /* Get MAC Address */ 36185380Ssam sum = 0; 37185380Ssam macaddr = val; 38185380Ssam for (i = 0; i < 3; i++) { 39185380Ssam if (!ath_hal_eepromRead(ah, AR_EEPROM_MAC(i), &eeval)) { 40185380Ssam HALDEBUG(ah, HAL_DEBUG_ANY, 41185380Ssam "%s: cannot read EEPROM location %u\n", 42185380Ssam __func__, i); 43185380Ssam return HAL_EEREAD; 44185380Ssam } 45185380Ssam sum += eeval; 46185380Ssam macaddr[2*i + 0] = eeval >> 8; 47185380Ssam macaddr[2*i + 1] = eeval & 0xff; 48185380Ssam } 49185380Ssam if (sum == 0 || sum == 0xffff*3) { 50185380Ssam HALDEBUG(ah, HAL_DEBUG_ANY, "%s: bad mac address %s\n", 51185380Ssam __func__, ath_hal_ether_sprintf(macaddr)); 52185380Ssam return HAL_EEBADMAC; 53185380Ssam } 54185380Ssam return HAL_OK; 55185380Ssam case AR_EEP_REGDMN_0: 56185380Ssam *(uint16_t *) val = ee->ee_regDomain[0]; 57185380Ssam return HAL_OK; 58185380Ssam case AR_EEP_RFKILL: 59185380Ssam HALASSERT(val == AH_NULL); 60185380Ssam return ee->ee_rfKill ? HAL_OK : HAL_EIO; 61185380Ssam case AR_EEP_WRITEPROTECT: 62185380Ssam HALASSERT(val == AH_NULL); 63185380Ssam return (ee->ee_protect & AR_EEPROM_PROTOTECT_WP_128_191) ? 64185380Ssam HAL_OK : HAL_EIO; 65185380Ssam default: 66185380Ssam HALASSERT(0); 67185380Ssam return HAL_EINVAL; 68185380Ssam } 69185380Ssam} 70185380Ssam 71221896Sadrianstatic HAL_STATUS 72185380Ssamv1EepromSet(struct ath_hal *ah, int param, int v) 73185380Ssam{ 74185380Ssam return HAL_EINVAL; 75185380Ssam} 76185380Ssam 77185380Ssamstatic HAL_BOOL 78185380Ssamv1EepromDiag(struct ath_hal *ah, int request, 79185380Ssam const void *args, uint32_t argsize, void **result, uint32_t *resultsize) 80185380Ssam{ 81185380Ssam HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom; 82185380Ssam 83185380Ssam switch (request) { 84185380Ssam case HAL_DIAG_EEPROM: 85185380Ssam *result = ee; 86185380Ssam *resultsize = sizeof(*ee); 87185380Ssam return AH_TRUE; 88185380Ssam } 89185380Ssam return AH_FALSE; 90185380Ssam} 91185380Ssam 92185380Ssamstatic uint16_t 93185380Ssamv1EepromGetSpurChan(struct ath_hal *ah, int ix, HAL_BOOL is2GHz) 94185380Ssam{ 95185380Ssam return AR_NO_SPUR; 96185380Ssam} 97185380Ssam 98185380Ssam/* 99185380Ssam * Reclaim any EEPROM-related storage. 100185380Ssam */ 101185380Ssamstatic void 102185380Ssamv1EepromDetach(struct ath_hal *ah) 103185380Ssam{ 104185380Ssam HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom; 105185380Ssam 106185380Ssam ath_hal_free(ee); 107185380Ssam AH_PRIVATE(ah)->ah_eeprom = AH_NULL; 108185380Ssam} 109185380Ssam 110185380SsamHAL_STATUS 111185380Ssamath_hal_v1EepromAttach(struct ath_hal *ah) 112185380Ssam{ 113185380Ssam HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom; 114185380Ssam uint16_t athvals[AR_EEPROM_ATHEROS_MAX]; /* XXX off stack */ 115208642Srpaulo uint16_t protect, eeprom_version, eeval; 116185380Ssam uint32_t sum; 117185380Ssam int i, loc; 118185380Ssam 119185380Ssam HALASSERT(ee == AH_NULL); 120185380Ssam 121185380Ssam if (!ath_hal_eepromRead(ah, AR_EEPROM_MAGIC, &eeval)) { 122185380Ssam HALDEBUG(ah, HAL_DEBUG_ANY, 123185380Ssam "%s: cannot read EEPROM magic number\n", __func__); 124185380Ssam return HAL_EEREAD; 125185380Ssam } 126185380Ssam if (eeval != 0x5aa5) { 127185380Ssam HALDEBUG(ah, HAL_DEBUG_ANY, 128185380Ssam "%s: invalid EEPROM magic number 0x%x\n", __func__, eeval); 129185380Ssam return HAL_EEMAGIC; 130185380Ssam } 131185380Ssam 132185380Ssam if (!ath_hal_eepromRead(ah, AR_EEPROM_PROTECT, &protect)) { 133185380Ssam HALDEBUG(ah, HAL_DEBUG_ANY, 134185380Ssam "%s: cannot read EEPROM protection bits; read locked?\n", 135185380Ssam __func__); 136185380Ssam return HAL_EEREAD; 137185380Ssam } 138185380Ssam HALDEBUG(ah, HAL_DEBUG_ATTACH, "EEPROM protect 0x%x\n", protect); 139185380Ssam /* XXX check proper access before continuing */ 140185380Ssam 141208642Srpaulo if (!ath_hal_eepromRead(ah, AR_EEPROM_VERSION, &eeprom_version)) { 142185380Ssam HALDEBUG(ah, HAL_DEBUG_ANY, 143185380Ssam "%s: unable to read EEPROM version\n", __func__); 144185380Ssam return HAL_EEREAD; 145185380Ssam } 146208642Srpaulo if (((eeprom_version>>12) & 0xf) != 1) { 147185380Ssam /* 148185380Ssam * This code only groks the version 1 EEPROM layout. 149185380Ssam */ 150185380Ssam HALDEBUG(ah, HAL_DEBUG_ANY, 151185380Ssam "%s: unsupported EEPROM version 0x%x found\n", 152208642Srpaulo __func__, eeprom_version); 153185380Ssam return HAL_EEVERSION; 154185380Ssam } 155185380Ssam 156185380Ssam /* 157185380Ssam * Read the Atheros EEPROM entries and calculate the checksum. 158185380Ssam */ 159185380Ssam sum = 0; 160185380Ssam for (i = 0; i < AR_EEPROM_ATHEROS_MAX; i++) { 161185380Ssam if (!ath_hal_eepromRead(ah, AR_EEPROM_ATHEROS(i), &athvals[i])) 162185380Ssam return HAL_EEREAD; 163185380Ssam sum ^= athvals[i]; 164185380Ssam } 165185380Ssam if (sum != 0xffff) { 166185380Ssam HALDEBUG(ah, HAL_DEBUG_ANY, "%s: bad EEPROM checksum 0x%x\n", 167185380Ssam __func__, sum); 168185380Ssam return HAL_EEBADSUM; 169185380Ssam } 170185380Ssam 171185380Ssam /* 172185380Ssam * Valid checksum, fetch the regulatory domain and save values. 173185380Ssam */ 174185380Ssam if (!ath_hal_eepromRead(ah, AR_EEPROM_REG_DOMAIN, &eeval)) { 175185380Ssam HALDEBUG(ah, HAL_DEBUG_ANY, 176185380Ssam "%s: cannot read regdomain from EEPROM\n", __func__); 177185380Ssam return HAL_EEREAD; 178185380Ssam } 179185380Ssam 180185380Ssam ee = ath_hal_malloc(sizeof(HAL_EEPROM_v1)); 181185380Ssam if (ee == AH_NULL) { 182185380Ssam /* XXX message */ 183185380Ssam return HAL_ENOMEM; 184185380Ssam } 185185380Ssam 186208642Srpaulo ee->ee_version = eeprom_version; 187185380Ssam ee->ee_protect = protect; 188185380Ssam ee->ee_antenna = athvals[2]; 189185380Ssam ee->ee_biasCurrents = athvals[3]; 190185380Ssam ee->ee_thresh62 = athvals[4] & 0xff; 191185380Ssam ee->ee_xlnaOn = (athvals[4] >> 8) & 0xff; 192185380Ssam ee->ee_xpaOn = athvals[5] & 0xff; 193185380Ssam ee->ee_xpaOff = (athvals[5] >> 8) & 0xff; 194185380Ssam ee->ee_regDomain[0] = (athvals[6] >> 8) & 0xff; 195185380Ssam ee->ee_regDomain[1] = athvals[6] & 0xff; 196185380Ssam ee->ee_regDomain[2] = (athvals[7] >> 8) & 0xff; 197185380Ssam ee->ee_regDomain[3] = athvals[7] & 0xff; 198185380Ssam ee->ee_rfKill = athvals[8] & 0x1; 199185380Ssam ee->ee_devType = (athvals[8] >> 1) & 0x7; 200185380Ssam 201185380Ssam for (i = 0, loc = AR_EEPROM_ATHEROS_TP_SETTINGS; i < AR_CHANNELS_MAX; i++, loc += AR_TP_SETTINGS_SIZE) { 202185380Ssam struct tpcMap *chan = &ee->ee_tpc[i]; 203185380Ssam 204185380Ssam /* Copy pcdac and gain_f values from EEPROM */ 205185380Ssam chan->pcdac[0] = (athvals[loc] >> 10) & 0x3F; 206185380Ssam chan->gainF[0] = (athvals[loc] >> 4) & 0x3F; 207185380Ssam chan->pcdac[1] = ((athvals[loc] << 2) & 0x3C) 208185380Ssam | ((athvals[loc+1] >> 14) & 0x03); 209185380Ssam chan->gainF[1] = (athvals[loc+1] >> 8) & 0x3F; 210185380Ssam chan->pcdac[2] = (athvals[loc+1] >> 2) & 0x3F; 211185380Ssam chan->gainF[2] = ((athvals[loc+1] << 4) & 0x30) 212185380Ssam | ((athvals[loc+2] >> 12) & 0x0F); 213185380Ssam chan->pcdac[3] = (athvals[loc+2] >> 6) & 0x3F; 214185380Ssam chan->gainF[3] = athvals[loc+2] & 0x3F; 215185380Ssam chan->pcdac[4] = (athvals[loc+3] >> 10) & 0x3F; 216185380Ssam chan->gainF[4] = (athvals[loc+3] >> 4) & 0x3F; 217185380Ssam chan->pcdac[5] = ((athvals[loc+3] << 2) & 0x3C) 218185380Ssam | ((athvals[loc+4] >> 14) & 0x03); 219185380Ssam chan->gainF[5] = (athvals[loc+4] >> 8) & 0x3F; 220185380Ssam chan->pcdac[6] = (athvals[loc+4] >> 2) & 0x3F; 221185380Ssam chan->gainF[6] = ((athvals[loc+4] << 4) & 0x30) 222185380Ssam | ((athvals[loc+5] >> 12) & 0x0F); 223185380Ssam chan->pcdac[7] = (athvals[loc+5] >> 6) & 0x3F; 224185380Ssam chan->gainF[7] = athvals[loc+5] & 0x3F; 225185380Ssam chan->pcdac[8] = (athvals[loc+6] >> 10) & 0x3F; 226185380Ssam chan->gainF[8] = (athvals[loc+6] >> 4) & 0x3F; 227185380Ssam chan->pcdac[9] = ((athvals[loc+6] << 2) & 0x3C) 228185380Ssam | ((athvals[loc+7] >> 14) & 0x03); 229185380Ssam chan->gainF[9] = (athvals[loc+7] >> 8) & 0x3F; 230185380Ssam chan->pcdac[10] = (athvals[loc+7] >> 2) & 0x3F; 231185380Ssam chan->gainF[10] = ((athvals[loc+7] << 4) & 0x30) 232185380Ssam | ((athvals[loc+8] >> 12) & 0x0F); 233185380Ssam 234185380Ssam /* Copy Regulatory Domain and Rate Information from EEPROM */ 235185380Ssam chan->rate36 = (athvals[loc+8] >> 6) & 0x3F; 236185380Ssam chan->rate48 = athvals[loc+8] & 0x3F; 237185380Ssam chan->rate54 = (athvals[loc+9] >> 10) & 0x3F; 238185380Ssam chan->regdmn[0] = (athvals[loc+9] >> 4) & 0x3F; 239185380Ssam chan->regdmn[1] = ((athvals[loc+9] << 2) & 0x3C) 240185380Ssam | ((athvals[loc+10] >> 14) & 0x03); 241185380Ssam chan->regdmn[2] = (athvals[loc+10] >> 8) & 0x3F; 242185380Ssam chan->regdmn[3] = (athvals[loc+10] >> 2) & 0x3F; 243185380Ssam } 244185380Ssam 245185380Ssam AH_PRIVATE(ah)->ah_eeprom = ee; 246208642Srpaulo AH_PRIVATE(ah)->ah_eeversion = eeprom_version; 247185380Ssam AH_PRIVATE(ah)->ah_eepromDetach = v1EepromDetach; 248185380Ssam AH_PRIVATE(ah)->ah_eepromGet = v1EepromGet; 249185380Ssam AH_PRIVATE(ah)->ah_eepromSet = v1EepromSet; 250185380Ssam AH_PRIVATE(ah)->ah_getSpurChan = v1EepromGetSpurChan; 251185380Ssam AH_PRIVATE(ah)->ah_eepromDiag = v1EepromDiag; 252185380Ssam return HAL_OK; 253185380Ssam} 254