drivers/net/ixgb/ixgb_ee.c

   1 /*******************************************************************************
   2
   3
   4   Copyright(c) 1999 - 2004 Intel Corporation. All rights reserved.
   5
   6   This program is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU General Public License as published by the Free
   8   Software Foundation; either version 2 of the License, or (at your option)
   9   any later version.
  10
  11   This program is distributed in the hope that it will be useful, but WITHOUT
  12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14   more details.
  15
  16   You should have received a copy of the GNU General Public License along with
  17   this program; if not, write to the Free Software Foundation, Inc., 59
  18   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19
  20   The full GNU General Public License is included in this distribution in the
  21   file called LICENSE.
  22
  23   Contact Information:
  24   Linux NICS <linux.nics@intel.com>
  25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  26
  27 *******************************************************************************/
  28
  29 #include "ixgb_hw.h"
  30 #include "ixgb_ee.h"
  31 /* Local prototypes */
  32 static uint16_t ixgb_shift_in_bits(struct ixgb_hw *hw);
  33
  34 static void ixgb_shift_out_bits(struct ixgb_hw *hw,
  35                                 uint16_t data,
  36                                 uint16_t count);
  37 static void ixgb_standby_eeprom(struct ixgb_hw *hw);
  38
  39 static boolean_t ixgb_wait_eeprom_command(struct ixgb_hw *hw);
  40
  41 static void ixgb_cleanup_eeprom(struct ixgb_hw *hw);
  42
  43 /******************************************************************************
  44  * Raises the EEPROM's clock input.
  45  *
  46  * hw - Struct containing variables accessed by shared code
  47  * eecd_reg - EECD's current value
  48  *****************************************************************************/
  49 static void
  50 ixgb_raise_clock(struct ixgb_hw *hw,
  51                   uint32_t *eecd_reg)
  52 {
  53         /* Raise the clock input to the EEPROM (by setting the SK bit), and then
  54          *  wait 50 microseconds.
  55          */
  56         *eecd_reg = *eecd_reg | IXGB_EECD_SK;
  57         IXGB_WRITE_REG(hw, EECD, *eecd_reg);
  58         udelay(50);
  59         return;
  60 }
  61
  62 /******************************************************************************
  63  * Lowers the EEPROM's clock input.
  64  *
  65  * hw - Struct containing variables accessed by shared code
  66  * eecd_reg - EECD's current value
  67  *****************************************************************************/
  68 static void
  69 ixgb_lower_clock(struct ixgb_hw *hw,
  70                   uint32_t *eecd_reg)
  71 {
  72         /* Lower the clock input to the EEPROM (by clearing the SK bit), and then
  73          * wait 50 microseconds.
  74          */
  75         *eecd_reg = *eecd_reg & ~IXGB_EECD_SK;
  76         IXGB_WRITE_REG(hw, EECD, *eecd_reg);
  77         udelay(50);
  78         return;
  79 }
  80
  81 /******************************************************************************
  82  * Shift data bits out to the EEPROM.
  83  *
  84  * hw - Struct containing variables accessed by shared code
  85  * data - data to send to the EEPROM
  86  * count - number of bits to shift out
  87  *****************************************************************************/
  88 static void
  89 ixgb_shift_out_bits(struct ixgb_hw *hw,
  90                                          uint16_t data,
  91                                          uint16_t count)
  92 {
  93         uint32_t eecd_reg;
  94         uint32_t mask;
  95
  96         /* We need to shift "count" bits out to the EEPROM. So, value in the
  97          * "data" parameter will be shifted out to the EEPROM one bit at a time.
  98          * In order to do this, "data" must be broken down into bits.
  99          */
 100         mask = 0x01 << (count - 1);
 101         eecd_reg = IXGB_READ_REG(hw, EECD);
 102         eecd_reg &= ~(IXGB_EECD_DO | IXGB_EECD_DI);
 103         do {
 104                 /* A "1" is shifted out to the EEPROM by setting bit "DI" to a "1",
 105                  * and then raising and then lowering the clock (the SK bit controls
 106                  * the clock input to the EEPROM).  A "0" is shifted out to the EEPROM
 107                  * by setting "DI" to "0" and then raising and then lowering the clock.
 108                  */
 109                 eecd_reg &= ~IXGB_EECD_DI;
 110
 111                 if(data & mask)
 112                         eecd_reg |= IXGB_EECD_DI;
 113
 114                 IXGB_WRITE_REG(hw, EECD, eecd_reg);
 115
 116                 udelay(50);
 117
 118                 ixgb_raise_clock(hw, &eecd_reg);
 119                 ixgb_lower_clock(hw, &eecd_reg);
 120
 121                 mask = mask >> 1;
 122
 123         } while(mask);
 124
 125         /* We leave the "DI" bit set to "0" when we leave this routine. */
 126         eecd_reg &= ~IXGB_EECD_DI;
 127         IXGB_WRITE_REG(hw, EECD, eecd_reg);
 128         return;
 129 }
 130
 131 /******************************************************************************
 132  * Shift data bits in from the EEPROM
 133  *
 134  * hw - Struct containing variables accessed by shared code
 135  *****************************************************************************/
 136 static uint16_t
 137 ixgb_shift_in_bits(struct ixgb_hw *hw)
 138 {
 139         uint32_t eecd_reg;
 140         uint32_t i;
 141         uint16_t data;
 142
 143         /* In order to read a register from the EEPROM, we need to shift 16 bits
 144          * in from the EEPROM. Bits are "shifted in" by raising the clock input to
 145          * the EEPROM (setting the SK bit), and then reading the value of the "DO"
 146          * bit.  During this "shifting in" process the "DI" bit should always be
 147          * clear..
 148          */
 149
 150         eecd_reg = IXGB_READ_REG(hw, EECD);
 151
 152         eecd_reg &= ~(IXGB_EECD_DO | IXGB_EECD_DI);
 153         data = 0;
 154
 155         for(i = 0; i < 16; i++) {
 156                 data = data << 1;
 157                 ixgb_raise_clock(hw, &eecd_reg);
 158
 159                 eecd_reg = IXGB_READ_REG(hw, EECD);
 160
 161                 eecd_reg &= ~(IXGB_EECD_DI);
 162                 if(eecd_reg & IXGB_EECD_DO)
 163                         data |= 1;
 164
 165                 ixgb_lower_clock(hw, &eecd_reg);
 166         }
 167
 168         return data;
 169 }
 170
 171 /******************************************************************************
 172  * Prepares EEPROM for access
 173  *
 174  * hw - Struct containing variables accessed by shared code
 175  *
 176  * Lowers EEPROM clock. Clears input pin. Sets the chip select pin. This
 177  * function should be called before issuing a command to the EEPROM.
 178  *****************************************************************************/
 179 static void
 180 ixgb_setup_eeprom(struct ixgb_hw *hw)
 181 {
 182         uint32_t eecd_reg;
 183
 184         eecd_reg = IXGB_READ_REG(hw, EECD);
 185
 186         /*  Clear SK and DI  */
 187         eecd_reg &= ~(IXGB_EECD_SK | IXGB_EECD_DI);
 188         IXGB_WRITE_REG(hw, EECD, eecd_reg);
 189
 190         /*  Set CS  */
 191         eecd_reg |= IXGB_EECD_CS;
 192         IXGB_WRITE_REG(hw, EECD, eecd_reg);
 193         return;
 194 }
 195
 196 /******************************************************************************
 197  * Returns EEPROM to a "standby" state
 198  *
 199  * hw - Struct containing variables accessed by shared code
 200  *****************************************************************************/
 201 static void
 202 ixgb_standby_eeprom(struct ixgb_hw *hw)
 203 {
 204         uint32_t eecd_reg;
 205
 206         eecd_reg = IXGB_READ_REG(hw, EECD);
 207
 208         /*  Deselct EEPROM  */
 209         eecd_reg &= ~(IXGB_EECD_CS | IXGB_EECD_SK);
 210         IXGB_WRITE_REG(hw, EECD, eecd_reg);
 211         udelay(50);
 212
 213         /*  Clock high  */
 214         eecd_reg |= IXGB_EECD_SK;
 215         IXGB_WRITE_REG(hw, EECD, eecd_reg);
 216         udelay(50);
 217
 218         /*  Select EEPROM  */
 219         eecd_reg |= IXGB_EECD_CS;
 220         IXGB_WRITE_REG(hw, EECD, eecd_reg);
 221         udelay(50);
 222
 223         /*  Clock low  */
 224         eecd_reg &= ~IXGB_EECD_SK;
 225         IXGB_WRITE_REG(hw, EECD, eecd_reg);
 226         udelay(50);
 227         return;
 228 }
 229
 230 /******************************************************************************
 231  * Raises then lowers the EEPROM's clock pin
 232  *
 233  * hw - Struct containing variables accessed by shared code
 234  *****************************************************************************/
 235 static void
 236 ixgb_clock_eeprom(struct ixgb_hw *hw)
 237 {
 238         uint32_t eecd_reg;
 239
 240         eecd_reg = IXGB_READ_REG(hw, EECD);
 241
 242         /*  Rising edge of clock  */
 243         eecd_reg |= IXGB_EECD_SK;
 244         IXGB_WRITE_REG(hw, EECD, eecd_reg);
 245         udelay(50);
 246
 247         /*  Falling edge of clock  */
 248         eecd_reg &= ~IXGB_EECD_SK;
 249         IXGB_WRITE_REG(hw, EECD, eecd_reg);
 250         udelay(50);
 251         return;
 252 }
 253
 254 /******************************************************************************
 255  * Terminates a command by lowering the EEPROM's chip select pin
 256  *
 257  * hw - Struct containing variables accessed by shared code
 258  *****************************************************************************/
 259 static void
 260 ixgb_cleanup_eeprom(struct ixgb_hw *hw)
 261 {
 262         uint32_t eecd_reg;
 263
 264         eecd_reg = IXGB_READ_REG(hw, EECD);
 265
 266         eecd_reg &= ~(IXGB_EECD_CS | IXGB_EECD_DI);
 267
 268         IXGB_WRITE_REG(hw, EECD, eecd_reg);
 269
 270         ixgb_clock_eeprom(hw);
 271         return;
 272 }
 273
 274 /******************************************************************************
 275  * Waits for the EEPROM to finish the current command.
 276  *
 277  * hw - Struct containing variables accessed by shared code
 278  *
 279  * The command is done when the EEPROM's data out pin goes high.
 280  *
 281  * Returns:
 282  *      TRUE: EEPROM data pin is high before timeout.
 283  *      FALSE:  Time expired.
 284  *****************************************************************************/
 285 static boolean_t
 286 ixgb_wait_eeprom_command(struct ixgb_hw *hw)
 287 {
 288         uint32_t eecd_reg;
 289         uint32_t i;
 290
 291         /* Toggle the CS line.  This in effect tells to EEPROM to actually execute
 292          * the command in question.
 293          */
 294         ixgb_standby_eeprom(hw);
 295
 296         /* Now read DO repeatedly until is high (equal to '1').  The EEEPROM will
 297          * signal that the command has been completed by raising the DO signal.
 298          * If DO does not go high in 10 milliseconds, then error out.
 299          */
 300         for(i = 0; i < 200; i++) {
 301                 eecd_reg = IXGB_READ_REG(hw, EECD);
 302
 303                 if(eecd_reg & IXGB_EECD_DO)
 304                         return (TRUE);
 305
 306                 udelay(50);
 307         }
 308         ASSERT(0);
 309         return (FALSE);
 310 }
 311
 312 /******************************************************************************
 313  * Verifies that the EEPROM has a valid checksum
 314  *
 315  * hw - Struct containing variables accessed by shared code
 316  *
 317  * Reads the first 64 16 bit words of the EEPROM and sums the values read.
 318  * If the the sum of the 64 16 bit words is 0xBABA, the EEPROM's checksum is
 319  * valid.
 320  *
 321  * Returns:
 322  *  TRUE: Checksum is valid
 323  *  FALSE: Checksum is not valid.
 324  *****************************************************************************/
 325 boolean_t
 326 ixgb_validate_eeprom_checksum(struct ixgb_hw *hw)
 327 {
 328         uint16_t checksum = 0;
 329         uint16_t i;
 330
 331         for(i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++)
 332                 checksum += ixgb_read_eeprom(hw, i);
 333
 334         if(checksum == (uint16_t) EEPROM_SUM)
 335                 return (TRUE);
 336         else
 337                 return (FALSE);
 338 }
 339
 340 /******************************************************************************
 341  * Calculates the EEPROM checksum and writes it to the EEPROM
 342  *
 343  * hw - Struct containing variables accessed by shared code
 344  *
 345  * Sums the first 63 16 bit words of the EEPROM. Subtracts the sum from 0xBABA.
 346  * Writes the difference to word offset 63 of the EEPROM.
 347  *****************************************************************************/
 348 void
 349 ixgb_update_eeprom_checksum(struct ixgb_hw *hw)
 350 {
 351         uint16_t checksum = 0;
 352         uint16_t i;
 353
 354         for(i = 0; i < EEPROM_CHECKSUM_REG; i++)
 355                 checksum += ixgb_read_eeprom(hw, i);
 356
 357         checksum = (uint16_t) EEPROM_SUM - checksum;
 358
 359         ixgb_write_eeprom(hw, EEPROM_CHECKSUM_REG, checksum);
 360         return;
 361 }
 362
 363 /******************************************************************************
 364  * Writes a 16 bit word to a given offset in the EEPROM.
 365  *
 366  * hw - Struct containing variables accessed by shared code
 367  * reg - offset within the EEPROM to be written to
 368  * data - 16 bit word to be writen to the EEPROM
 369  *
 370  * If ixgb_update_eeprom_checksum is not called after this function, the
 371  * EEPROM will most likely contain an invalid checksum.
 372  *
 373  *****************************************************************************/
 374 void
 375 ixgb_write_eeprom(struct ixgb_hw *hw,
 376                    uint16_t offset,
 377                    uint16_t data)
 378 {
 379         /*  Prepare the EEPROM for writing  */
 380         ixgb_setup_eeprom(hw);
 381
 382         /*  Send the 9-bit EWEN (write enable) command to the EEPROM (5-bit opcode
 383          *  plus 4-bit dummy).  This puts the EEPROM into write/erase mode.
 384          */
 385         ixgb_shift_out_bits(hw, EEPROM_EWEN_OPCODE, 5);
 386         ixgb_shift_out_bits(hw, 0, 4);
 387
 388         /*  Prepare the EEPROM  */
 389         ixgb_standby_eeprom(hw);
 390
 391         /*  Send the Write command (3-bit opcode + 6-bit addr)  */
 392         ixgb_shift_out_bits(hw, EEPROM_WRITE_OPCODE, 3);
 393         ixgb_shift_out_bits(hw, offset, 6);
 394
 395         /*  Send the data  */
 396         ixgb_shift_out_bits(hw, data, 16);
 397
 398         ixgb_wait_eeprom_command(hw);
 399
 400         /*  Recover from write  */
 401         ixgb_standby_eeprom(hw);
 402
 403         /* Send the 9-bit EWDS (write disable) command to the EEPROM (5-bit
 404          * opcode plus 4-bit dummy).  This takes the EEPROM out of write/erase
 405          * mode.
 406          */
 407         ixgb_shift_out_bits(hw, EEPROM_EWDS_OPCODE, 5);
 408         ixgb_shift_out_bits(hw, 0, 4);
 409
 410         /*  Done with writing  */
 411         ixgb_cleanup_eeprom(hw);
 412
 413         return;
 414 }
 415
 416 /******************************************************************************
 417  * Reads a 16 bit word from the EEPROM.
 418  *
 419  * hw - Struct containing variables accessed by shared code
 420  * offset - offset of 16 bit word in the EEPROM to read
 421  *
 422  * Returns:
 423  *  The 16-bit value read from the eeprom
 424  *****************************************************************************/
 425 uint16_t
 426 ixgb_read_eeprom(struct ixgb_hw *hw,
 427                   uint16_t offset)
 428 {
 429         uint16_t data;
 430
 431         /*  Prepare the EEPROM for reading  */
 432         ixgb_setup_eeprom(hw);
 433
 434         /*  Send the READ command (opcode + addr)  */
 435         ixgb_shift_out_bits(hw, EEPROM_READ_OPCODE, 3);
 436         /*
 437          * We have a 64 word EEPROM, there are 6 address bits
 438          */
 439         ixgb_shift_out_bits(hw, offset, 6);
 440
 441         /*  Read the data  */
 442         data = ixgb_shift_in_bits(hw);
 443
 444         /*  End this read operation  */
 445         ixgb_standby_eeprom(hw);
 446
 447         return (data);
 448 }
 449
 450 /******************************************************************************
 451  * Reads eeprom and stores data in shared structure.
 452  * Validates eeprom checksum and eeprom signature.
 453  *
 454  * hw - Struct containing variables accessed by shared code
 455  *
 456  * Returns:
 457  *      TRUE: if eeprom read is successful
 458  *      FALSE: otherwise.
 459  *****************************************************************************/
 460 boolean_t
 461 ixgb_get_eeprom_data(struct ixgb_hw *hw)
 462 {
 463         uint16_t i;
 464         uint16_t checksum = 0;
 465         struct ixgb_ee_map_type *ee_map;
 466
 467         DEBUGFUNC("ixgb_get_eeprom_data");
 468
 469         ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 470
 471         DEBUGOUT("ixgb_ee: Reading eeprom data\n");
 472         for(i = 0; i < IXGB_EEPROM_SIZE ; i++) {
 473                 uint16_t ee_data;
 474                 ee_data = ixgb_read_eeprom(hw, i);
 475                 checksum += ee_data;
 476                 hw->eeprom[i] = le16_to_cpu(ee_data);
 477         }
 478
 479         if (checksum != (uint16_t) EEPROM_SUM) {
 480                 DEBUGOUT("ixgb_ee: Checksum invalid.\n");
 481                 return (FALSE);
 482         }
 483
 484         if ((ee_map->init_ctrl_reg_1 & le16_to_cpu(EEPROM_ICW1_SIGNATURE_MASK))
 485                  != le16_to_cpu(EEPROM_ICW1_SIGNATURE_VALID)) {
 486                 DEBUGOUT("ixgb_ee: Signature invalid.\n");
 487                 return(FALSE);
 488         }
 489
 490         return(TRUE);
 491 }
 492
 493 /******************************************************************************
 494  * Local function to check if the eeprom signature is good
 495  * If the eeprom signature is good, calls ixgb)get_eeprom_data.
 496  *
 497  * hw - Struct containing variables accessed by shared code
 498  *
 499  * Returns:
 500  *      TRUE: eeprom signature was good and the eeprom read was successful
 501  *      FALSE: otherwise.
 502  ******************************************************************************/
 503 static boolean_t
 504 ixgb_check_and_get_eeprom_data (struct ixgb_hw* hw)
 505 {
 506         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 507
 508         if ((ee_map->init_ctrl_reg_1 & le16_to_cpu(EEPROM_ICW1_SIGNATURE_MASK))
 509             == le16_to_cpu(EEPROM_ICW1_SIGNATURE_VALID)) {
 510                 return (TRUE);
 511         } else {
 512                 return ixgb_get_eeprom_data(hw);
 513         }
 514 }
 515
 516 /******************************************************************************
 517  * return a word from the eeprom
 518  *
 519  * hw - Struct containing variables accessed by shared code
 520  * index - Offset of eeprom word
 521  *
 522  * Returns:
 523  *          Word at indexed offset in eeprom, if valid, 0 otherwise.
 524  ******************************************************************************/
 525 uint16_t
 526 ixgb_get_eeprom_word(struct ixgb_hw *hw, uint16_t index)
 527 {
 528
 529         if ((index < IXGB_EEPROM_SIZE) &&
 530                 (ixgb_check_and_get_eeprom_data(hw) == TRUE)) {
 531            return(hw->eeprom[index]);
 532         }
 533
 534         return(0);
 535 }
 536
 537 /******************************************************************************
 538  * return the mac address from EEPROM
 539  *
 540  * hw       - Struct containing variables accessed by shared code
 541  * mac_addr - Ethernet Address if EEPROM contents are valid, 0 otherwise
 542  *
 543  * Returns: None.
 544  ******************************************************************************/
 545 void
 546 ixgb_get_ee_mac_addr(struct ixgb_hw *hw,
 547                         uint8_t *mac_addr)
 548 {
 549         int i;
 550         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 551
 552         DEBUGFUNC("ixgb_get_ee_mac_addr");
 553
 554         if (ixgb_check_and_get_eeprom_data(hw) == TRUE) {
 555                 for (i = 0; i < IXGB_ETH_LENGTH_OF_ADDRESS; i++) {
 556                         mac_addr[i] = ee_map->mac_addr[i];
 557                         DEBUGOUT2("mac(%d) = %.2X\n", i, mac_addr[i]);
 558                 }
 559         }
 560 }
 561
 562 /******************************************************************************
 563  * return the compatibility flags from EEPROM
 564  *
 565  * hw - Struct containing variables accessed by shared code
 566  *
 567  * Returns:
 568  *          compatibility flags if EEPROM contents are valid, 0 otherwise
 569  ******************************************************************************/
 570 uint16_t
 571 ixgb_get_ee_compatibility(struct ixgb_hw *hw)
 572 {
 573         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 574
 575         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
 576                 return(ee_map->compatibility);
 577
 578         return(0);
 579 }
 580
 581 /******************************************************************************
 582  * return the Printed Board Assembly number from EEPROM
 583  *
 584  * hw - Struct containing variables accessed by shared code
 585  *
 586  * Returns:
 587  *          PBA number if EEPROM contents are valid, 0 otherwise
 588  ******************************************************************************/
 589 uint32_t
 590 ixgb_get_ee_pba_number(struct ixgb_hw *hw)
 591 {
 592         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
 593                 return (le16_to_cpu(hw->eeprom[EEPROM_PBA_1_2_REG])
 594                         | (le16_to_cpu(hw->eeprom[EEPROM_PBA_3_4_REG])<<16));
 595
 596         return(0);
 597 }
 598
 599 /******************************************************************************
 600  * return the Initialization Control Word 1 from EEPROM
 601  *
 602  * hw - Struct containing variables accessed by shared code
 603  *
 604  * Returns:
 605  *          Initialization Control Word 1 if EEPROM contents are valid, 0 otherwise
 606  ******************************************************************************/
 607 uint16_t
 608 ixgb_get_ee_init_ctrl_reg_1(struct ixgb_hw *hw)
 609 {
 610         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 611
 612         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
 613                 return(ee_map->init_ctrl_reg_1);
 614
 615         return(0);
 616 }
 617
 618 /******************************************************************************
 619  * return the Initialization Control Word 2 from EEPROM
 620  *
 621  * hw - Struct containing variables accessed by shared code
 622  *
 623  * Returns:
 624  *          Initialization Control Word 2 if EEPROM contents are valid, 0 otherwise
 625  ******************************************************************************/
 626 uint16_t
 627 ixgb_get_ee_init_ctrl_reg_2(struct ixgb_hw *hw)
 628 {
 629         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 630
 631         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
 632                 return(ee_map->init_ctrl_reg_2);
 633
 634         return(0);
 635 }
 636
 637 /******************************************************************************
 638  * return the Subsystem Id from EEPROM
 639  *
 640  * hw - Struct containing variables accessed by shared code
 641  *
 642  * Returns:
 643  *          Subsystem Id if EEPROM contents are valid, 0 otherwise
 644  ******************************************************************************/
 645 uint16_t
 646 ixgb_get_ee_subsystem_id(struct ixgb_hw *hw)
 647 {
 648         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 649
 650         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
 651            return(ee_map->subsystem_id);
 652
 653         return(0);
 654 }
 655
 656 /******************************************************************************
 657  * return the Sub Vendor Id from EEPROM
 658  *
 659  * hw - Struct containing variables accessed by shared code
 660  *
 661  * Returns:
 662  *          Sub Vendor Id if EEPROM contents are valid, 0 otherwise
 663  ******************************************************************************/
 664 uint16_t
 665 ixgb_get_ee_subvendor_id(struct ixgb_hw *hw)
 666 {
 667         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 668
 669         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
 670                 return(ee_map->subvendor_id);
 671
 672         return(0);
 673 }
 674
 675 /******************************************************************************
 676  * return the Device Id from EEPROM
 677  *
 678  * hw - Struct containing variables accessed by shared code
 679  *
 680  * Returns:
 681  *          Device Id if EEPROM contents are valid, 0 otherwise
 682  ******************************************************************************/
 683 uint16_t
 684 ixgb_get_ee_device_id(struct ixgb_hw *hw)
 685 {
 686         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 687
 688         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
 689                 return(ee_map->device_id);
 690
 691         return(0);
 692 }
 693
 694 /******************************************************************************
 695  * return the Vendor Id from EEPROM
 696  *
 697  * hw - Struct containing variables accessed by shared code
 698  *
 699  * Returns:
 700  *          Device Id if EEPROM contents are valid, 0 otherwise
 701  ******************************************************************************/
 702 uint16_t
 703 ixgb_get_ee_vendor_id(struct ixgb_hw *hw)
 704 {
 705         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 706
 707         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
 708                 return(ee_map->vendor_id);
 709
 710         return(0);
 711 }
 712
 713 /******************************************************************************
 714  * return the Software Defined Pins Register from EEPROM
 715  *
 716  * hw - Struct containing variables accessed by shared code
 717  *
 718  * Returns:
 719  *          SDP Register if EEPROM contents are valid, 0 otherwise
 720  ******************************************************************************/
 721 uint16_t
 722 ixgb_get_ee_swdpins_reg(struct ixgb_hw *hw)
 723 {
 724         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 725
 726         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
 727                 return(ee_map->swdpins_reg);
 728
 729         return(0);
 730 }
 731
 732 /******************************************************************************
 733  * return the D3 Power Management Bits from EEPROM
 734  *
 735  * hw - Struct containing variables accessed by shared code
 736  *
 737  * Returns:
 738  *          D3 Power Management Bits if EEPROM contents are valid, 0 otherwise
 739  ******************************************************************************/
 740 uint8_t
 741 ixgb_get_ee_d3_power(struct ixgb_hw *hw)
 742 {
 743         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 744
 745         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
 746                 return(ee_map->d3_power);
 747
 748         return(0);
 749 }
 750
 751 /******************************************************************************
 752  * return the D0 Power Management Bits from EEPROM
 753  *
 754  * hw - Struct containing variables accessed by shared code
 755  *
 756  * Returns:
 757  *          D0 Power Management Bits if EEPROM contents are valid, 0 otherwise
 758  ******************************************************************************/
 759 uint8_t
 760 ixgb_get_ee_d0_power(struct ixgb_hw *hw)
 761 {
 762         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
 763
 764         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
 765                 return(ee_map->d0_power);
 766
 767         return(0);
 768 }