sys/dev/netif/ath/hal/ath_hal/ah_eeprom_v1.c

   1 /*
   2  * Copyright (c) 2008 Sam Leffler, Errno Consulting
   3  * Copyright (c) 2008 Atheros Communications, Inc.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  *
  17  * $Id: ah_eeprom_v1.c,v 1.1 2008/11/11 02:40:11 sam Exp $
  18  * $DragonFly$
  19  */
  20 #include "opt_ah.h"
  21
  22 #include "ah.h"
  23 #include "ah_internal.h"
  24 #include "ah_eeprom_v1.h"
  25
  26 static HAL_STATUS
  27 v1EepromGet(struct ath_hal *ah, int param, void *val)
  28 {
  29         HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom;
  30         uint32_t sum;
  31         uint16_t eeval;
  32         uint8_t *macaddr;
  33         int i;
  34
  35         switch (param) {
  36         case AR_EEP_MACADDR:            /* Get MAC Address */
  37                 sum = 0;
  38                 macaddr = val;
  39                 for (i = 0; i < 3; i++) {
  40                         if (!ath_hal_eepromRead(ah, AR_EEPROM_MAC(i), &eeval)) {
  41                                 HALDEBUG(ah, HAL_DEBUG_ANY,
  42                                     "%s: cannot read EEPROM location %u\n",
  43                                     __func__, i);
  44                                 return HAL_EEREAD;
  45                         }
  46                         sum += eeval;
  47                         macaddr[2*i + 0] = eeval >> 8;
  48                         macaddr[2*i + 1] = eeval & 0xff;
  49                 }
  50                 if (sum == 0 || sum == 0xffff*3) {
  51                         HALDEBUG(ah, HAL_DEBUG_ANY, "%s: bad mac address %s\n",
  52                             __func__, ath_hal_ether_sprintf(macaddr));
  53                         return HAL_EEBADMAC;
  54                 }
  55                 return HAL_OK;
  56         case AR_EEP_REGDMN_0:
  57                 *(uint16_t *) val = ee->ee_regDomain[0];
  58                 return HAL_OK;
  59         case AR_EEP_RFKILL:
  60                 HALASSERT(val == AH_NULL);
  61                 return ee->ee_rfKill ? HAL_OK : HAL_EIO;
  62         case AR_EEP_WRITEPROTECT:
  63                 HALASSERT(val == AH_NULL);
  64                 return (ee->ee_protect & AR_EEPROM_PROTOTECT_WP_128_191) ?
  65                     HAL_OK : HAL_EIO;
  66         default:
  67                 HALASSERT(0);
  68                 return HAL_EINVAL;
  69         }
  70 }
  71
  72 static HAL_BOOL
  73 v1EepromSet(struct ath_hal *ah, int param, int v)
  74 {
  75         return HAL_EINVAL;
  76 }
  77
  78 static HAL_BOOL
  79 v1EepromDiag(struct ath_hal *ah, int request,
  80      const void *args, uint32_t argsize, void **result, uint32_t *resultsize)
  81 {
  82         HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom;
  83
  84         switch (request) {
  85         case HAL_DIAG_EEPROM:
  86                 *result = ee;
  87                 *resultsize = sizeof(*ee);
  88                 return AH_TRUE;
  89         }
  90         return AH_FALSE;
  91 }
  92
  93 static uint16_t
  94 v1EepromGetSpurChan(struct ath_hal *ah, int ix, HAL_BOOL is2GHz)
  95 {
  96         return AR_NO_SPUR;
  97 }
  98
  99 /*
 100  * Reclaim any EEPROM-related storage.
 101  */
 102 static void
 103 v1EepromDetach(struct ath_hal *ah)
 104 {
 105         HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom;
 106
 107         ath_hal_free(ee);
 108         AH_PRIVATE(ah)->ah_eeprom = AH_NULL;
 109 }
 110
 111 HAL_STATUS
 112 ath_hal_v1EepromAttach(struct ath_hal *ah)
 113 {
 114         HAL_EEPROM_v1 *ee = AH_PRIVATE(ah)->ah_eeprom;
 115         uint16_t athvals[AR_EEPROM_ATHEROS_MAX];        /* XXX off stack */
 116         uint16_t protect, eeprom_version, eeval;
 117         uint32_t sum;
 118         int i, loc;
 119
 120         HALASSERT(ee == AH_NULL);
 121
 122         if (!ath_hal_eepromRead(ah, AR_EEPROM_MAGIC, &eeval)) {
 123                 HALDEBUG(ah, HAL_DEBUG_ANY,
 124                     "%s: cannot read EEPROM magic number\n", __func__);
 125                 return HAL_EEREAD;
 126         }
 127         if (eeval != 0x5aa5) {
 128                 HALDEBUG(ah, HAL_DEBUG_ANY,
 129                     "%s: invalid EEPROM magic number 0x%x\n", __func__, eeval);
 130                 return HAL_EEMAGIC;
 131         }
 132
 133         if (!ath_hal_eepromRead(ah, AR_EEPROM_PROTECT, &protect)) {
 134                 HALDEBUG(ah, HAL_DEBUG_ANY,
 135                     "%s: cannot read EEPROM protection bits; read locked?\n",
 136                     __func__);
 137                 return HAL_EEREAD;
 138         }
 139         HALDEBUG(ah, HAL_DEBUG_ATTACH, "EEPROM protect 0x%x\n", protect);
 140         /* XXX check proper access before continuing */
 141
 142         if (!ath_hal_eepromRead(ah, AR_EEPROM_VERSION, &eeprom_version)) {
 143                 HALDEBUG(ah, HAL_DEBUG_ANY,
 144                     "%s: unable to read EEPROM version\n", __func__);
 145                 return HAL_EEREAD;
 146         }
 147         if (((eeprom_version>>12) & 0xf) != 1) {
 148                 /*
 149                  * This code only groks the version 1 EEPROM layout.
 150                  */
 151                 HALDEBUG(ah, HAL_DEBUG_ANY,
 152                     "%s: unsupported EEPROM version 0x%x found\n",
 153                     __func__, eeprom_version);
 154                 return HAL_EEVERSION;
 155         }
 156
 157         /*
 158          * Read the Atheros EEPROM entries and calculate the checksum.
 159          */
 160         sum = 0;
 161         for (i = 0; i < AR_EEPROM_ATHEROS_MAX; i++) {
 162                 if (!ath_hal_eepromRead(ah, AR_EEPROM_ATHEROS(i), &athvals[i]))
 163                         return HAL_EEREAD;
 164                 sum ^= athvals[i];
 165         }
 166         if (sum != 0xffff) {
 167                 HALDEBUG(ah, HAL_DEBUG_ANY, "%s: bad EEPROM checksum 0x%x\n",
 168                     __func__, sum);
 169                 return HAL_EEBADSUM;
 170         }
 171
 172         /*
 173          * Valid checksum, fetch the regulatory domain and save values.
 174          */
 175         if (!ath_hal_eepromRead(ah, AR_EEPROM_REG_DOMAIN, &eeval)) {
 176                 HALDEBUG(ah, HAL_DEBUG_ANY,
 177                     "%s: cannot read regdomain from EEPROM\n", __func__);
 178                 return HAL_EEREAD;
 179         }
 180
 181         ee = ath_hal_malloc(sizeof(HAL_EEPROM_v1));
 182         if (ee == AH_NULL) {
 183                 /* XXX message */
 184                 return HAL_ENOMEM;
 185         }
 186
 187         ee->ee_version          = eeprom_version;
 188         ee->ee_protect          = protect;
 189         ee->ee_antenna          = athvals[2];
 190         ee->ee_biasCurrents     = athvals[3];
 191         ee->ee_thresh62 = athvals[4] & 0xff;
 192         ee->ee_xlnaOn           = (athvals[4] >> 8) & 0xff;
 193         ee->ee_xpaOn            = athvals[5] & 0xff;
 194         ee->ee_xpaOff           = (athvals[5] >> 8) & 0xff;
 195         ee->ee_regDomain[0]     = (athvals[6] >> 8) & 0xff;
 196         ee->ee_regDomain[1]     = athvals[6] & 0xff;
 197         ee->ee_regDomain[2]     = (athvals[7] >> 8) & 0xff;
 198         ee->ee_regDomain[3]     = athvals[7] & 0xff;
 199         ee->ee_rfKill           = athvals[8] & 0x1;
 200         ee->ee_devType          = (athvals[8] >> 1) & 0x7;
 201
 202         for (i = 0, loc = AR_EEPROM_ATHEROS_TP_SETTINGS; i < AR_CHANNELS_MAX; i++, loc += AR_TP_SETTINGS_SIZE) {
 203                 struct tpcMap *chan = &ee->ee_tpc[i];
 204
 205                 /* Copy pcdac and gain_f values from EEPROM */
 206                 chan->pcdac[0]  = (athvals[loc] >> 10) & 0x3F;
 207                 chan->gainF[0]  = (athvals[loc] >> 4) & 0x3F;
 208                 chan->pcdac[1]  = ((athvals[loc] << 2) & 0x3C)
 209                                 | ((athvals[loc+1] >> 14) & 0x03);
 210                 chan->gainF[1]  = (athvals[loc+1] >> 8) & 0x3F;
 211                 chan->pcdac[2]  = (athvals[loc+1] >> 2) & 0x3F;
 212                 chan->gainF[2]  = ((athvals[loc+1] << 4) & 0x30)
 213                                 | ((athvals[loc+2] >> 12) & 0x0F);
 214                 chan->pcdac[3]  = (athvals[loc+2] >> 6) & 0x3F;
 215                 chan->gainF[3]  = athvals[loc+2] & 0x3F;
 216                 chan->pcdac[4]  = (athvals[loc+3] >> 10) & 0x3F;
 217                 chan->gainF[4]  = (athvals[loc+3] >> 4) & 0x3F;
 218                 chan->pcdac[5]  = ((athvals[loc+3] << 2) & 0x3C)
 219                                 | ((athvals[loc+4] >> 14) & 0x03);
 220                 chan->gainF[5]  = (athvals[loc+4] >> 8) & 0x3F;
 221                 chan->pcdac[6]  = (athvals[loc+4] >> 2) & 0x3F;
 222                 chan->gainF[6]  = ((athvals[loc+4] << 4) & 0x30)
 223                                 | ((athvals[loc+5] >> 12) & 0x0F);
 224                 chan->pcdac[7]  = (athvals[loc+5] >> 6) & 0x3F;
 225                 chan->gainF[7]  = athvals[loc+5] & 0x3F;
 226                 chan->pcdac[8]  = (athvals[loc+6] >> 10) & 0x3F;
 227                 chan->gainF[8]  = (athvals[loc+6] >> 4) & 0x3F;
 228                 chan->pcdac[9]  = ((athvals[loc+6] << 2) & 0x3C)
 229                                 | ((athvals[loc+7] >> 14) & 0x03);
 230                 chan->gainF[9]  = (athvals[loc+7] >> 8) & 0x3F;
 231                 chan->pcdac[10] = (athvals[loc+7] >> 2) & 0x3F;
 232                 chan->gainF[10] = ((athvals[loc+7] << 4) & 0x30)
 233                                 | ((athvals[loc+8] >> 12) & 0x0F);
 234
 235                 /* Copy Regulatory Domain and Rate Information from EEPROM */
 236                 chan->rate36    = (athvals[loc+8] >> 6) & 0x3F;
 237                 chan->rate48    = athvals[loc+8] & 0x3F;
 238                 chan->rate54    = (athvals[loc+9] >> 10) & 0x3F;
 239                 chan->regdmn[0] = (athvals[loc+9] >> 4) & 0x3F;
 240                 chan->regdmn[1] = ((athvals[loc+9] << 2) & 0x3C)
 241                                 | ((athvals[loc+10] >> 14) & 0x03);
 242                 chan->regdmn[2] = (athvals[loc+10] >> 8) & 0x3F;
 243                 chan->regdmn[3] = (athvals[loc+10] >> 2) & 0x3F;
 244         }
 245
 246         AH_PRIVATE(ah)->ah_eeprom = ee;
 247         AH_PRIVATE(ah)->ah_eeversion = eeprom_version;
 248         AH_PRIVATE(ah)->ah_eepromDetach = v1EepromDetach;
 249         AH_PRIVATE(ah)->ah_eepromGet = v1EepromGet;
 250         AH_PRIVATE(ah)->ah_eepromSet = v1EepromSet;
 251         AH_PRIVATE(ah)->ah_getSpurChan = v1EepromGetSpurChan;
 252         AH_PRIVATE(ah)->ah_eepromDiag = v1EepromDiag;
 253         return HAL_OK;
 254 }