]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - drivers/net/ixgb/ixgb_ee.c
653e99f919cee638c23be7da3f02dc734b4ea00f
[linux-2.6.git] / drivers / net / ixgb / ixgb_ee.c
1 /*******************************************************************************
2
3   
4   Copyright(c) 1999 - 2005 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, uint16_t offset, uint16_t data)
376 {
377         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
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         /* clear the init_ctrl_reg_1 to signify that the cache is invalidated */
414         ee_map->init_ctrl_reg_1 = EEPROM_ICW1_SIGNATURE_CLEAR;
415
416         return;
417 }
418
419 /******************************************************************************
420  * Reads a 16 bit word from the EEPROM.
421  *
422  * hw - Struct containing variables accessed by shared code
423  * offset - offset of 16 bit word in the EEPROM to read
424  *
425  * Returns:
426  *  The 16-bit value read from the eeprom
427  *****************************************************************************/
428 uint16_t
429 ixgb_read_eeprom(struct ixgb_hw *hw,
430                   uint16_t offset)
431 {
432         uint16_t data;
433
434         /*  Prepare the EEPROM for reading  */
435         ixgb_setup_eeprom(hw);
436
437         /*  Send the READ command (opcode + addr)  */
438         ixgb_shift_out_bits(hw, EEPROM_READ_OPCODE, 3);
439         /*
440          * We have a 64 word EEPROM, there are 6 address bits
441          */
442         ixgb_shift_out_bits(hw, offset, 6);
443
444         /*  Read the data  */
445         data = ixgb_shift_in_bits(hw);
446
447         /*  End this read operation  */
448         ixgb_standby_eeprom(hw);
449
450         return (data);
451 }
452
453 /******************************************************************************
454  * Reads eeprom and stores data in shared structure.
455  * Validates eeprom checksum and eeprom signature.
456  *
457  * hw - Struct containing variables accessed by shared code
458  *
459  * Returns:
460  *      TRUE: if eeprom read is successful
461  *      FALSE: otherwise.
462  *****************************************************************************/
463 boolean_t
464 ixgb_get_eeprom_data(struct ixgb_hw *hw)
465 {
466         uint16_t i;
467         uint16_t checksum = 0;
468         struct ixgb_ee_map_type *ee_map;
469
470         DEBUGFUNC("ixgb_get_eeprom_data");
471
472         ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
473
474         DEBUGOUT("ixgb_ee: Reading eeprom data\n");
475         for(i = 0; i < IXGB_EEPROM_SIZE ; i++) {
476                 uint16_t ee_data;
477                 ee_data = ixgb_read_eeprom(hw, i);
478                 checksum += ee_data;
479                 hw->eeprom[i] = le16_to_cpu(ee_data);
480         }
481
482         if (checksum != (uint16_t) EEPROM_SUM) {
483                 DEBUGOUT("ixgb_ee: Checksum invalid.\n");
484                 /* clear the init_ctrl_reg_1 to signify that the cache is
485                  * invalidated */
486                 ee_map->init_ctrl_reg_1 = EEPROM_ICW1_SIGNATURE_CLEAR;
487                 return (FALSE);
488         }
489
490         if ((ee_map->init_ctrl_reg_1 & le16_to_cpu(EEPROM_ICW1_SIGNATURE_MASK))
491                  != le16_to_cpu(EEPROM_ICW1_SIGNATURE_VALID)) {
492                 DEBUGOUT("ixgb_ee: Signature invalid.\n");
493                 return(FALSE);
494         }
495
496         return(TRUE);
497 }
498
499 /******************************************************************************
500  * Local function to check if the eeprom signature is good
501  * If the eeprom signature is good, calls ixgb)get_eeprom_data.
502  *
503  * hw - Struct containing variables accessed by shared code
504  *
505  * Returns:
506  *      TRUE: eeprom signature was good and the eeprom read was successful
507  *      FALSE: otherwise.
508  ******************************************************************************/
509 static boolean_t
510 ixgb_check_and_get_eeprom_data (struct ixgb_hw* hw)
511 {
512         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
513
514         if ((ee_map->init_ctrl_reg_1 & le16_to_cpu(EEPROM_ICW1_SIGNATURE_MASK))
515             == le16_to_cpu(EEPROM_ICW1_SIGNATURE_VALID)) {
516                 return (TRUE);
517         } else {
518                 return ixgb_get_eeprom_data(hw);
519         }
520 }
521
522 /******************************************************************************
523  * return a word from the eeprom
524  *
525  * hw - Struct containing variables accessed by shared code
526  * index - Offset of eeprom word
527  *
528  * Returns:
529  *          Word at indexed offset in eeprom, if valid, 0 otherwise.
530  ******************************************************************************/
531 uint16_t
532 ixgb_get_eeprom_word(struct ixgb_hw *hw, uint16_t index)
533 {
534
535         if ((index < IXGB_EEPROM_SIZE) &&
536                 (ixgb_check_and_get_eeprom_data(hw) == TRUE)) {
537            return(hw->eeprom[index]);
538         }
539
540         return(0);
541 }
542
543 /******************************************************************************
544  * return the mac address from EEPROM
545  *
546  * hw       - Struct containing variables accessed by shared code
547  * mac_addr - Ethernet Address if EEPROM contents are valid, 0 otherwise
548  *
549  * Returns: None.
550  ******************************************************************************/
551 void
552 ixgb_get_ee_mac_addr(struct ixgb_hw *hw,
553                         uint8_t *mac_addr)
554 {
555         int i;
556         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
557
558         DEBUGFUNC("ixgb_get_ee_mac_addr");
559
560         if (ixgb_check_and_get_eeprom_data(hw) == TRUE) {
561                 for (i = 0; i < IXGB_ETH_LENGTH_OF_ADDRESS; i++) {
562                         mac_addr[i] = ee_map->mac_addr[i];
563                         DEBUGOUT2("mac(%d) = %.2X\n", i, mac_addr[i]);
564                 }
565         }
566 }
567
568 /******************************************************************************
569  * return the compatibility flags from EEPROM
570  *
571  * hw - Struct containing variables accessed by shared code
572  *
573  * Returns:
574  *          compatibility flags if EEPROM contents are valid, 0 otherwise
575  ******************************************************************************/
576 uint16_t
577 ixgb_get_ee_compatibility(struct ixgb_hw *hw)
578 {
579         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
580
581         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
582                 return(ee_map->compatibility);
583
584         return(0);
585 }
586
587 /******************************************************************************
588  * return the Printed Board Assembly number from EEPROM
589  *
590  * hw - Struct containing variables accessed by shared code
591  *
592  * Returns:
593  *          PBA number if EEPROM contents are valid, 0 otherwise
594  ******************************************************************************/
595 uint32_t
596 ixgb_get_ee_pba_number(struct ixgb_hw *hw)
597 {
598         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
599                 return (le16_to_cpu(hw->eeprom[EEPROM_PBA_1_2_REG])
600                         | (le16_to_cpu(hw->eeprom[EEPROM_PBA_3_4_REG])<<16));
601
602         return(0);
603 }
604
605 /******************************************************************************
606  * return the Initialization Control Word 1 from EEPROM
607  *
608  * hw - Struct containing variables accessed by shared code
609  *
610  * Returns:
611  *          Initialization Control Word 1 if EEPROM contents are valid, 0 otherwise
612  ******************************************************************************/
613 uint16_t
614 ixgb_get_ee_init_ctrl_reg_1(struct ixgb_hw *hw)
615 {
616         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
617
618         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
619                 return(ee_map->init_ctrl_reg_1);
620
621         return(0);
622 }
623
624 /******************************************************************************
625  * return the Initialization Control Word 2 from EEPROM
626  *
627  * hw - Struct containing variables accessed by shared code
628  *
629  * Returns:
630  *          Initialization Control Word 2 if EEPROM contents are valid, 0 otherwise
631  ******************************************************************************/
632 uint16_t
633 ixgb_get_ee_init_ctrl_reg_2(struct ixgb_hw *hw)
634 {
635         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
636
637         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
638                 return(ee_map->init_ctrl_reg_2);
639
640         return(0);
641 }
642
643 /******************************************************************************
644  * return the Subsystem Id from EEPROM
645  *
646  * hw - Struct containing variables accessed by shared code
647  *
648  * Returns:
649  *          Subsystem Id if EEPROM contents are valid, 0 otherwise
650  ******************************************************************************/
651 uint16_t
652 ixgb_get_ee_subsystem_id(struct ixgb_hw *hw)
653 {
654         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
655
656         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
657            return(ee_map->subsystem_id);
658
659         return(0);
660 }
661
662 /******************************************************************************
663  * return the Sub Vendor Id from EEPROM
664  *
665  * hw - Struct containing variables accessed by shared code
666  *
667  * Returns:
668  *          Sub Vendor Id if EEPROM contents are valid, 0 otherwise
669  ******************************************************************************/
670 uint16_t
671 ixgb_get_ee_subvendor_id(struct ixgb_hw *hw)
672 {
673         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
674
675         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
676                 return(ee_map->subvendor_id);
677
678         return(0);
679 }
680
681 /******************************************************************************
682  * return the Device Id from EEPROM
683  *
684  * hw - Struct containing variables accessed by shared code
685  *
686  * Returns:
687  *          Device Id if EEPROM contents are valid, 0 otherwise
688  ******************************************************************************/
689 uint16_t
690 ixgb_get_ee_device_id(struct ixgb_hw *hw)
691 {
692         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
693
694         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
695                 return(ee_map->device_id);
696
697         return(0);
698 }
699
700 /******************************************************************************
701  * return the Vendor Id from EEPROM
702  *
703  * hw - Struct containing variables accessed by shared code
704  *
705  * Returns:
706  *          Device Id if EEPROM contents are valid, 0 otherwise
707  ******************************************************************************/
708 uint16_t
709 ixgb_get_ee_vendor_id(struct ixgb_hw *hw)
710 {
711         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
712
713         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
714                 return(ee_map->vendor_id);
715
716         return(0);
717 }
718
719 /******************************************************************************
720  * return the Software Defined Pins Register from EEPROM
721  *
722  * hw - Struct containing variables accessed by shared code
723  *
724  * Returns:
725  *          SDP Register if EEPROM contents are valid, 0 otherwise
726  ******************************************************************************/
727 uint16_t
728 ixgb_get_ee_swdpins_reg(struct ixgb_hw *hw)
729 {
730         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
731
732         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
733                 return(ee_map->swdpins_reg);
734
735         return(0);
736 }
737
738 /******************************************************************************
739  * return the D3 Power Management Bits from EEPROM
740  *
741  * hw - Struct containing variables accessed by shared code
742  *
743  * Returns:
744  *          D3 Power Management Bits if EEPROM contents are valid, 0 otherwise
745  ******************************************************************************/
746 uint8_t
747 ixgb_get_ee_d3_power(struct ixgb_hw *hw)
748 {
749         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
750
751         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
752                 return(ee_map->d3_power);
753
754         return(0);
755 }
756
757 /******************************************************************************
758  * return the D0 Power Management Bits from EEPROM
759  *
760  * hw - Struct containing variables accessed by shared code
761  *
762  * Returns:
763  *          D0 Power Management Bits if EEPROM contents are valid, 0 otherwise
764  ******************************************************************************/
765 uint8_t
766 ixgb_get_ee_d0_power(struct ixgb_hw *hw)
767 {
768         struct ixgb_ee_map_type *ee_map = (struct ixgb_ee_map_type *)hw->eeprom;
769
770         if(ixgb_check_and_get_eeprom_data(hw) == TRUE)
771                 return(ee_map->d0_power);
772
773         return(0);
774 }