rt2860_read_eeprom.c

   1
   2 /*-
   3  * Copyright (c) 2009-2010 Alexander Egorenkov <egorenar@gmail.com>
   4  * Copyright (c) 2009 Damien Bergamini <damien.bergamini@free.fr>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include "rt2860_read_eeprom.h"
  20 #include "rt2860_reg.h"
  21 #include "rt2860_eeprom.h"
  22 #include "rt2860_io.h"
  23 #include "rt2860_debug.h"
  24
  25 /*
  26  * rt2860_read_eeprom
  27  */
  28 void rt2860_read_eeprom(struct rt2860_softc *sc)
  29 {
  30         uint32_t tmp;
  31         uint16_t val;
  32         int i;
  33
  34         /* read EEPROM address number */
  35
  36         tmp = rt2860_io_mac_read(sc, RT2860_REG_EEPROM_CSR);
  37
  38         if((tmp & 0x30) == 0)
  39                 sc->eeprom_addr_num = 6;
  40         else if((tmp & 0x30) == 0x10)
  41                 sc->eeprom_addr_num = 8;
  42         else
  43                 sc->eeprom_addr_num = 8;
  44
  45         /* read EEPROM version */
  46
  47         sc->eeprom_rev = rt2860_io_eeprom_read(sc, RT2860_EEPROM_VERSION);
  48
  49         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
  50                 "%s: EEPROM rev=0x%04x\n",
  51                 device_get_nameunit(sc->dev), sc->eeprom_rev);
  52
  53         /* read MAC address */
  54
  55         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_ADDRESS01);
  56
  57         sc->mac_addr[0] = (val & 0xff);
  58         sc->mac_addr[1] = (val >> 8);
  59
  60         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_ADDRESS23);
  61
  62         sc->mac_addr[2] = (val & 0xff);
  63         sc->mac_addr[3] = (val >> 8);
  64
  65         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_ADDRESS45);
  66
  67         sc->mac_addr[4] = (val & 0xff);
  68         sc->mac_addr[5] = (val >> 8);
  69
  70         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
  71                 "%s: EEPROM mac address=%s\n",
  72                 device_get_nameunit(sc->dev), ether_sprintf(sc->mac_addr));
  73
  74         /* read RF information */
  75
  76         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_ANTENNA);
  77         if (val == 0xffff)
  78         {
  79                 printf("%s: invalid EEPROM antenna info\n",
  80                         device_get_nameunit(sc->dev));
  81
  82                 sc->rf_rev = RT2860_EEPROM_RF_2820;
  83                 sc->ntxpath = 1;
  84                 sc->nrxpath = 2;
  85         }
  86         else
  87         {
  88                 sc->rf_rev = (val >> 8) & 0xf;
  89                 sc->ntxpath = (val >> 4) & 0xf;
  90                 sc->nrxpath = (val & 0xf);
  91         }
  92
  93         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
  94                 "%s: EEPROM RF rev=0x%04x, paths=%dT%dR\n",
  95                 device_get_nameunit(sc->dev), sc->rf_rev, sc->ntxpath, sc->nrxpath);
  96
  97         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_NIC_CONFIG);
  98
  99         sc->hw_radio_cntl = ((val & RT2860_EEPROM_HW_RADIO_CNTL) ? 1 : 0);
 100         sc->tx_agc_cntl = ((val & RT2860_EEPROM_TX_AGC_CNTL) ? 1 : 0);
 101         sc->ext_lna_2ghz = ((val & RT2860_EEPROM_EXT_LNA_2GHZ) ? 1 : 0);
 102         sc->ext_lna_5ghz = ((val & RT2860_EEPROM_EXT_LNA_5GHZ) ? 1 : 0);
 103
 104         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 105                 "%s: EEPROM NIC config: HW radio cntl=%d, Tx AGC cntl=%d, ext LNA gains=%d/%d\n",
 106                 device_get_nameunit(sc->dev),
 107                 sc->hw_radio_cntl, sc->tx_agc_cntl, sc->ext_lna_2ghz, sc->ext_lna_5ghz);
 108
 109         /* read country code */
 110
 111         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_COUNTRY);
 112
 113         sc->country_2ghz = (val >> 8) & 0xff;
 114         sc->country_5ghz = (val & 0xff);
 115
 116         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 117                 "%s: EEPROM country code=%d/%d\n",
 118                 device_get_nameunit(sc->dev), sc->country_2ghz, sc->country_5ghz);
 119
 120         /* read RF frequency offset */
 121
 122         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_RF_FREQ_OFF);
 123
 124         if ((val & 0xff) != 0xff)
 125         {
 126                 sc->rf_freq_off = (val & 0xff);
 127         }
 128         else
 129         {
 130                 printf("%s: invalid EEPROM RF freq offset\n",
 131                         device_get_nameunit(sc->dev));
 132
 133                 sc->rf_freq_off = 0;
 134         }
 135
 136         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 137                 "%s: EEPROM freq offset=0x%02x\n",
 138                 device_get_nameunit(sc->dev), sc->rf_freq_off);
 139
 140         /* read LEDs operating mode */
 141
 142         if (((val >> 8) & 0xff) != 0xff)
 143         {
 144                 sc->led_cntl = ((val >> 8) & 0xff);
 145                 sc->led_off[0] = rt2860_io_eeprom_read(sc, RT2860_EEPROM_LED1_OFF);
 146                 sc->led_off[1] = rt2860_io_eeprom_read(sc, RT2860_EEPROM_LED2_OFF);
 147                 sc->led_off[2] = rt2860_io_eeprom_read(sc, RT2860_EEPROM_LED3_OFF);
 148         }
 149         else
 150         {
 151                 printf("%s: invalid EEPROM LED settings\n",
 152                         device_get_nameunit(sc->dev));
 153
 154                 sc->led_cntl = RT2860_EEPROM_LED_CNTL_DEFAULT;
 155                 sc->led_off[0] = RT2860_EEPROM_LED1_OFF_DEFAULT;
 156                 sc->led_off[1] = RT2860_EEPROM_LED2_OFF_DEFAULT;
 157                 sc->led_off[2] = RT2860_EEPROM_LED3_OFF_DEFAULT;
 158         }
 159
 160         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 161                 "%s: EEPROM LED cntl=0x%02x, LEDs=0x%04x/0x%04x/0x%04x\n",
 162                 device_get_nameunit(sc->dev), sc->led_cntl,
 163                 sc->led_off[0], sc->led_off[1], sc->led_off[2]);
 164
 165         /* read RSSI offsets and LNA gains */
 166
 167         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_LNA_GAIN);
 168
 169         sc->lna_gain[0] = (val & 0xff);
 170         sc->lna_gain[1] = (val >> 8) & 0xff;
 171
 172         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_RSSI_OFF_2GHZ_BASE);
 173
 174         sc->rssi_off_2ghz[0] = (val & 0xff);
 175         sc->rssi_off_2ghz[1] = (val >> 8) & 0xff;
 176
 177         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_RSSI_OFF_2GHZ_BASE + sizeof(uint16_t));
 178
 179         sc->rssi_off_2ghz[2] = (val & 0xff);
 180         sc->lna_gain[2] = (val >> 8) & 0xff;
 181
 182         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_RSSI_OFF_5GHZ_BASE);
 183
 184         sc->rssi_off_5ghz[0] = (val & 0xff);
 185         sc->rssi_off_5ghz[1] = (val >> 8) & 0xff;
 186
 187         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_RSSI_OFF_5GHZ_BASE + sizeof(uint16_t));
 188
 189         sc->rssi_off_5ghz[2] = (val & 0xff);
 190         sc->lna_gain[3] = (val >> 8) & 0xff;
 191
 192         for (i = 2; i < RT2860_SOFTC_LNA_GAIN_COUNT; i++)
 193         {
 194                 if (sc->lna_gain[i] == 0x00 || sc->lna_gain[i] == (int8_t) 0xff)
 195                 {
 196                         printf("%s: invalid EEPROM LNA gain #%d: 0x%02x\n",
 197                                 device_get_nameunit(sc->dev), i, sc->lna_gain[i]);
 198
 199                         sc->lna_gain[i] = sc->lna_gain[1];
 200                 }
 201         }
 202
 203         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 204                 "%s: EEPROM LNA gains=0x%02x/0x%02x/0x%02x/0x%02x\n",
 205                 device_get_nameunit(sc->dev),
 206                 sc->lna_gain[0], sc->lna_gain[1], sc->lna_gain[2], sc->lna_gain[3]);
 207
 208         for (i = 0; i < RT2860_SOFTC_RSSI_OFF_COUNT; i++)
 209         {
 210                 if (sc->rssi_off_2ghz[i] < RT2860_EEPROM_RSSI_OFF_MIN ||
 211                         sc->rssi_off_2ghz[i] > RT2860_EEPROM_RSSI_OFF_MAX)
 212                 {
 213                         printf("%s: invalid EEPROM RSSI offset #%d (2GHz): 0x%02x\n",
 214                                 device_get_nameunit(sc->dev), i, sc->rssi_off_2ghz[i]);
 215
 216                         sc->rssi_off_2ghz[i] = 0;
 217                 }
 218
 219                 if (sc->rssi_off_5ghz[i] < RT2860_EEPROM_RSSI_OFF_MIN ||
 220                         sc->rssi_off_5ghz[i] > RT2860_EEPROM_RSSI_OFF_MAX)
 221                 {
 222                         printf("%s: invalid EEPROM RSSI offset #%d (5GHz): 0x%02x\n",
 223                                 device_get_nameunit(sc->dev), i, sc->rssi_off_5ghz[i]);
 224
 225                         sc->rssi_off_5ghz[i] = 0;
 226                 }
 227         }
 228
 229         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 230                 "%s: EEPROM RSSI offsets 2GHz=%d/%d/%d\n",
 231                 device_get_nameunit(sc->dev),
 232                 sc->rssi_off_2ghz[0], sc->rssi_off_2ghz[1], sc->rssi_off_2ghz[2]);
 233
 234         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 235                 "%s: EEPROM RSSI offsets 5GHz=%d/%d/%d\n",
 236                 device_get_nameunit(sc->dev),
 237                 sc->rssi_off_5ghz[0], sc->rssi_off_5ghz[1], sc->rssi_off_5ghz[2]);
 238
 239         /* read Tx power settings for 2GHz channels */
 240
 241         for (i = 0; i < 14; i += 2)
 242         {
 243                 val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TXPOW1_2GHZ_BASE + i / 2);
 244
 245                 sc->txpow1[i + 0] = (int8_t) (val & 0xff);
 246                 sc->txpow1[i + 1] = (int8_t) (val >> 8);
 247
 248                 val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TXPOW2_2GHZ_BASE + i / 2);
 249
 250                 sc->txpow2[i + 0] = (int8_t) (val & 0xff);
 251                 sc->txpow2[i + 1] = (int8_t) (val >> 8);
 252         }
 253
 254         /* read Tx power settings for 5GHz channels */
 255
 256         for (; i < RT2860_SOFTC_TXPOW_COUNT; i += 2)
 257         {
 258                 val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TXPOW1_5GHZ_BASE + i / 2);
 259
 260                 sc->txpow1[i + 0] = (int8_t) (val & 0xff);
 261                 sc->txpow1[i + 1] = (int8_t) (val >> 8);
 262
 263                 val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TXPOW2_5GHZ_BASE + i / 2);
 264
 265                 sc->txpow2[i + 0] = (int8_t) (val & 0xff);
 266                 sc->txpow2[i + 1] = (int8_t) (val >> 8);
 267         }
 268
 269         /* fix broken Tx power settings */
 270
 271     for (i = 0; i < 14; i++)
 272         {
 273                 if (sc->txpow1[i] < RT2860_EEPROM_TXPOW_2GHZ_MIN ||
 274                         sc->txpow1[i] > RT2860_EEPROM_TXPOW_2GHZ_MAX)
 275                 {
 276                         printf("%s: invalid EEPROM Tx power1 #%d (2GHz): 0x%02x\n",
 277                                 device_get_nameunit(sc->dev), i, sc->txpow1[i]);
 278
 279                         sc->txpow1[i] = RT2860_EEPROM_TXPOW_2GHZ_DEFAULT;
 280                 }
 281
 282                 if (sc->txpow2[i] < RT2860_EEPROM_TXPOW_2GHZ_MIN ||
 283                         sc->txpow2[i] > RT2860_EEPROM_TXPOW_2GHZ_MAX)
 284                 {
 285                         printf("%s: invalid EEPROM Tx power2 #%d (2GHz): 0x%02x\n",
 286                                 device_get_nameunit(sc->dev), i, sc->txpow2[i]);
 287
 288                         sc->txpow2[i] = RT2860_EEPROM_TXPOW_2GHZ_DEFAULT;
 289                 }
 290         }
 291
 292         for (; i < RT2860_SOFTC_TXPOW_COUNT; i++)
 293         {
 294                 if (sc->txpow1[i] < RT2860_EEPROM_TXPOW_5GHZ_MIN ||
 295                         sc->txpow1[i] > RT2860_EEPROM_TXPOW_5GHZ_MAX)
 296                 {
 297                         printf("%s: invalid EEPROM Tx power1 #%d (5GHz): 0x%02x\n",
 298                                 device_get_nameunit(sc->dev), i, sc->txpow1[i]);
 299
 300                         sc->txpow1[i] = RT2860_EEPROM_TXPOW_5GHZ_DEFAULT;
 301                 }
 302
 303                 if (sc->txpow2[i] < RT2860_EEPROM_TXPOW_5GHZ_MIN ||
 304                         sc->txpow2[i] > RT2860_EEPROM_TXPOW_5GHZ_MAX)
 305                 {
 306                         printf("%s: invalid EEPROM Tx power2 #%d (5GHz): 0x%02x\n",
 307                                 device_get_nameunit(sc->dev), i, sc->txpow2[i]);
 308
 309                         sc->txpow2[i] = RT2860_EEPROM_TXPOW_5GHZ_DEFAULT;
 310                 }
 311         }
 312
 313         /* read Tx power per rate deltas */
 314
 315         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TXPOW_RATE_DELTA);
 316
 317         sc->txpow_rate_delta_2ghz = 0;
 318         sc->txpow_rate_delta_5ghz = 0;
 319
 320         if ((val & 0xff) != 0xff)
 321         {
 322                 if (val & 0x80)
 323                         sc->txpow_rate_delta_2ghz = (val & 0xf);
 324
 325                 if (!(val & 0x40))
 326                         sc->txpow_rate_delta_2ghz = -sc->txpow_rate_delta_2ghz;
 327         }
 328
 329         val >>= 8;
 330
 331         if ((val & 0xff) != 0xff)
 332         {
 333                 if (val & 0x80)
 334                         sc->txpow_rate_delta_5ghz = (val & 0xf);
 335
 336                 if (!(val & 0x40))
 337                         sc->txpow_rate_delta_5ghz = -sc->txpow_rate_delta_5ghz;
 338         }
 339
 340         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 341                 "%s: EEPROM Tx power per rate deltas=%d(2MHz), %d(5MHz)\n",
 342                 device_get_nameunit(sc->dev),
 343                 sc->txpow_rate_delta_2ghz, sc->txpow_rate_delta_5ghz);
 344
 345         /* read Tx power per rate */
 346
 347         for (i = 0; i < RT2860_SOFTC_TXPOW_RATE_COUNT; i++)
 348         {
 349                 rt2860_io_eeprom_read_multi(sc, RT2860_EEPROM_TXPOW_RATE_BASE + i * sizeof(uint32_t),
 350                         &tmp, sizeof(uint32_t));
 351
 352                 sc->txpow_rate_20mhz[i] = tmp;
 353                 sc->txpow_rate_40mhz_2ghz[i] =
 354                         rt2860_read_eeprom_txpow_rate_add_delta(tmp, sc->txpow_rate_delta_2ghz);
 355                 sc->txpow_rate_40mhz_5ghz[i] =
 356                         rt2860_read_eeprom_txpow_rate_add_delta(tmp, sc->txpow_rate_delta_5ghz);
 357
 358                 RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 359                         "%s: EEPROM Tx power per rate #%d=0x%08x(20MHz), 0x%08x(40MHz/2GHz), 0x%08x(40MHz/5GHz)\n",
 360                         device_get_nameunit(sc->dev), i,
 361                         sc->txpow_rate_20mhz[i], sc->txpow_rate_40mhz_2ghz[i], sc->txpow_rate_40mhz_5ghz[i]);
 362         }
 363
 364         if (sc->tx_agc_cntl)
 365                 sc->tx_agc_cntl_2ghz = sc->tx_agc_cntl_5ghz = 1;
 366
 367         /* read factory-calibrated samples for temperature compensation */
 368
 369         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TSSI_2GHZ_BASE);
 370
 371         sc->tssi_2ghz[0] = (val & 0xff);        /* [-4] */
 372         sc->tssi_2ghz[1] = (val >> 8);          /* [-3] */
 373
 374         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TSSI_2GHZ_BASE + sizeof(uint16_t));
 375
 376         sc->tssi_2ghz[2] = (val & 0xff);        /* [-2] */
 377         sc->tssi_2ghz[3] = (val >> 8);          /* [-1] */
 378
 379         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TSSI_2GHZ_BASE + 2 * sizeof(uint16_t));
 380
 381         sc->tssi_2ghz[4] = (val & 0xff);        /* [0] */
 382         sc->tssi_2ghz[5] = (val >> 8);          /* [+1] */
 383
 384         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TSSI_2GHZ_BASE + 3 * sizeof(uint16_t));
 385
 386         sc->tssi_2ghz[6] = (val & 0xff);        /* [+2] */
 387         sc->tssi_2ghz[7] = (val >> 8);          /* [+3] */
 388
 389         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TSSI_2GHZ_BASE + 4 * sizeof(uint16_t));
 390
 391         sc->tssi_2ghz[8] = (val & 0xff);        /* [+4] */
 392         sc->tssi_step_2ghz = (val >> 8);
 393
 394         if (sc->tssi_2ghz[4] == 0xff)
 395                 sc->tx_agc_cntl_2ghz = 0;
 396
 397         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 398                 "%s: EEPROM TSSI 2GHz: 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, "
 399                 "0x%02x, 0x%02x, step=%d\n",
 400                 device_get_nameunit(sc->dev),
 401                 sc->tssi_2ghz[0], sc->tssi_2ghz[1], sc->tssi_2ghz[2],
 402                 sc->tssi_2ghz[3], sc->tssi_2ghz[4], sc->tssi_2ghz[5],
 403                 sc->tssi_2ghz[6], sc->tssi_2ghz[7], sc->tssi_2ghz[8],
 404                 sc->tssi_step_2ghz);
 405
 406         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TSSI_5GHZ_BASE);
 407
 408         sc->tssi_5ghz[0] = (val & 0xff);        /* [-4] */
 409         sc->tssi_5ghz[1] = (val >> 8);          /* [-3] */
 410
 411         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TSSI_5GHZ_BASE + sizeof(uint16_t));
 412
 413         sc->tssi_5ghz[2] = (val & 0xff);        /* [-2] */
 414         sc->tssi_5ghz[3] = (val >> 8);          /* [-1] */
 415
 416         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TSSI_5GHZ_BASE + 2 * sizeof(uint16_t));
 417
 418         sc->tssi_5ghz[4] = (val & 0xff);        /* [0] */
 419         sc->tssi_5ghz[5] = (val >> 8);          /* [+1] */
 420
 421         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TSSI_5GHZ_BASE + 3 * sizeof(uint16_t));
 422
 423         sc->tssi_5ghz[6] = (val & 0xff);        /* [+2] */
 424         sc->tssi_5ghz[7] = (val >> 8);          /* [+3] */
 425
 426         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_TSSI_5GHZ_BASE + 4 * sizeof(uint16_t));
 427
 428         sc->tssi_5ghz[8] = (val & 0xff);        /* [+4] */
 429         sc->tssi_step_5ghz = (val >> 8);
 430
 431         if (sc->tssi_5ghz[4] == 0xff)
 432                 sc->tx_agc_cntl_5ghz = 0;
 433
 434         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 435                 "%s: EEPROM TSSI 5GHz: 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, "
 436                 "0x%02x, 0x%02x, step=%d\n",
 437                 device_get_nameunit(sc->dev),
 438                 sc->tssi_5ghz[0], sc->tssi_5ghz[1], sc->tssi_5ghz[2],
 439                 sc->tssi_5ghz[3], sc->tssi_5ghz[4], sc->tssi_5ghz[5],
 440                 sc->tssi_5ghz[6], sc->tssi_5ghz[7], sc->tssi_5ghz[8],
 441                 sc->tssi_step_5ghz);
 442
 443         /* read default BBP settings */
 444
 445         rt2860_io_eeprom_read_multi(sc, RT2860_EEPROM_BBP_BASE,
 446                 sc->bbp_eeprom, RT2860_SOFTC_BBP_EEPROM_COUNT * sizeof(uint16_t));
 447
 448         /* read powersave level */
 449
 450         val = rt2860_io_eeprom_read(sc, RT2860_EEPROM_POWERSAVE_LEVEL);
 451
 452         sc->powersave_level = val & 0xff;
 453
 454         if ((sc->powersave_level & 0xff) == 0xff)
 455                 printf("%s: invalid EEPROM powersave level\n",
 456                         device_get_nameunit(sc->dev));
 457
 458         RT2860_DPRINTF(sc, RT2860_DEBUG_EEPROM,
 459                 "%s: EEPROM powersave level=0x%02x\n",
 460                 device_get_nameunit(sc->dev), sc->powersave_level);
 461 }
 462
 463 /*
 464  * rt2860_read_eeprom_txpow_rate_add_delta
 465  */
 466 uint32_t rt2860_read_eeprom_txpow_rate_add_delta(uint32_t txpow_rate,
 467         int8_t delta)
 468 {
 469         int8_t b4;
 470         int i;
 471
 472         for (i = 0; i < 8; i++)
 473         {
 474                 b4 = txpow_rate & 0xf;
 475                 b4 += delta;
 476
 477                 if (b4 < 0)
 478                         b4 = 0;
 479                 else if (b4 > 0xf)
 480                         b4 = 0xf;
 481
 482                 txpow_rate = (txpow_rate >> 4) | (b4 << 28);
 483         }
 484
 485         return txpow_rate;
 486 }