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