1 /**************************************************************************
2 Intel Pro 1000 for ppcboot/das-u-boot
3 Drivers are port from Intel's Linux driver e1000-4.3.15
4 and from Etherboot pro 1000 driver by mrakes at vivato dot net
5 tested on both gig copper and gig fiber boards
6 ***************************************************************************/
7 /*******************************************************************************
10 Copyright(c) 1999 - 2002 Intel Corporation. All rights reserved.
12 This program is free software; you can redistribute it and/or modify it
13 under the terms of the GNU General Public License as published by the Free
14 Software Foundation; either version 2 of the License, or (at your option)
17 This program is distributed in the hope that it will be useful, but WITHOUT
18 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
22 You should have received a copy of the GNU General Public License along with
23 this program; if not, write to the Free Software Foundation, Inc., 59
24 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26 The full GNU General Public License is included in this distribution in the
30 Linux NICS <linux.nics@intel.com>
31 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
33 *******************************************************************************/
35 * Copyright (C) Archway Digital Solutions.
37 * written by Chrsitopher Li <cli at arcyway dot com> or <chrisl at gnuchina dot org>
40 * Copyright (C) Linux Networx.
41 * Massive upgrade to work with the new intel gigabit NICs.
42 * <ebiederman at lnxi dot com>
47 #if defined(CONFIG_CMD_NET) \
48 && defined(CONFIG_NET_MULTI) && defined(CONFIG_E1000)
50 #define TOUT_LOOP 100000
53 #define virt_to_bus(x) ((unsigned long)x)
54 #define bus_to_phys(devno, a) pci_mem_to_phys(devno, a)
55 #define mdelay(n) udelay((n)*1000)
57 #define E1000_DEFAULT_PBA 0x00000030
59 /* NIC specific static variables go here */
61 static char tx_pool
[128 + 16];
62 static char rx_pool
[128 + 16];
63 static char packet
[2096];
65 static struct e1000_tx_desc
*tx_base
;
66 static struct e1000_rx_desc
*rx_base
;
69 static int rx_tail
, rx_last
;
71 static struct pci_device_id supported
[] = {
72 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82542
},
73 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82543GC_FIBER
},
74 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82543GC_COPPER
},
75 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82544EI_COPPER
},
76 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82544EI_FIBER
},
77 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82544GC_COPPER
},
78 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82544GC_LOM
},
79 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82540EM
},
80 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82545EM_COPPER
},
81 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82546EB_COPPER
},
82 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82545EM_FIBER
},
83 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82546EB_FIBER
},
84 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82540EM_LOM
},
85 {PCI_VENDOR_ID_INTEL
, PCI_DEVICE_ID_INTEL_82541ER
},
88 /* Function forward declarations */
89 static int e1000_setup_link(struct eth_device
*nic
);
90 static int e1000_setup_fiber_link(struct eth_device
*nic
);
91 static int e1000_setup_copper_link(struct eth_device
*nic
);
92 static int e1000_phy_setup_autoneg(struct e1000_hw
*hw
);
93 static void e1000_config_collision_dist(struct e1000_hw
*hw
);
94 static int e1000_config_mac_to_phy(struct e1000_hw
*hw
);
95 static int e1000_config_fc_after_link_up(struct e1000_hw
*hw
);
96 static int e1000_check_for_link(struct eth_device
*nic
);
97 static int e1000_wait_autoneg(struct e1000_hw
*hw
);
98 static void e1000_get_speed_and_duplex(struct e1000_hw
*hw
, uint16_t * speed
,
100 static int e1000_read_phy_reg(struct e1000_hw
*hw
, uint32_t reg_addr
,
101 uint16_t * phy_data
);
102 static int e1000_write_phy_reg(struct e1000_hw
*hw
, uint32_t reg_addr
,
104 static void e1000_phy_hw_reset(struct e1000_hw
*hw
);
105 static int e1000_phy_reset(struct e1000_hw
*hw
);
106 static int e1000_detect_gig_phy(struct e1000_hw
*hw
);
108 #define E1000_WRITE_REG(a, reg, value) (writel((value), ((a)->hw_addr + E1000_##reg)))
109 #define E1000_READ_REG(a, reg) (readl((a)->hw_addr + E1000_##reg))
110 #define E1000_WRITE_REG_ARRAY(a, reg, offset, value) (\
111 writel((value), ((a)->hw_addr + E1000_##reg + ((offset) << 2))))
112 #define E1000_READ_REG_ARRAY(a, reg, offset) ( \
113 readl((a)->hw_addr + E1000_##reg + ((offset) << 2)))
114 #define E1000_WRITE_FLUSH(a) {uint32_t x; x = E1000_READ_REG(a, STATUS);}
116 #ifndef CONFIG_AP1000 /* remove for warnings */
117 /******************************************************************************
118 * Raises the EEPROM's clock input.
120 * hw - Struct containing variables accessed by shared code
121 * eecd - EECD's current value
122 *****************************************************************************/
124 e1000_raise_ee_clk(struct e1000_hw
*hw
, uint32_t * eecd
)
126 /* Raise the clock input to the EEPROM (by setting the SK bit), and then
127 * wait 50 microseconds.
129 *eecd
= *eecd
| E1000_EECD_SK
;
130 E1000_WRITE_REG(hw
, EECD
, *eecd
);
131 E1000_WRITE_FLUSH(hw
);
135 /******************************************************************************
136 * Lowers the EEPROM's clock input.
138 * hw - Struct containing variables accessed by shared code
139 * eecd - EECD's current value
140 *****************************************************************************/
142 e1000_lower_ee_clk(struct e1000_hw
*hw
, uint32_t * eecd
)
144 /* Lower the clock input to the EEPROM (by clearing the SK bit), and then
145 * wait 50 microseconds.
147 *eecd
= *eecd
& ~E1000_EECD_SK
;
148 E1000_WRITE_REG(hw
, EECD
, *eecd
);
149 E1000_WRITE_FLUSH(hw
);
153 /******************************************************************************
154 * Shift data bits out to the EEPROM.
156 * hw - Struct containing variables accessed by shared code
157 * data - data to send to the EEPROM
158 * count - number of bits to shift out
159 *****************************************************************************/
161 e1000_shift_out_ee_bits(struct e1000_hw
*hw
, uint16_t data
, uint16_t count
)
166 /* We need to shift "count" bits out to the EEPROM. So, value in the
167 * "data" parameter will be shifted out to the EEPROM one bit at a time.
168 * In order to do this, "data" must be broken down into bits.
170 mask
= 0x01 << (count
- 1);
171 eecd
= E1000_READ_REG(hw
, EECD
);
172 eecd
&= ~(E1000_EECD_DO
| E1000_EECD_DI
);
174 /* A "1" is shifted out to the EEPROM by setting bit "DI" to a "1",
175 * and then raising and then lowering the clock (the SK bit controls
176 * the clock input to the EEPROM). A "0" is shifted out to the EEPROM
177 * by setting "DI" to "0" and then raising and then lowering the clock.
179 eecd
&= ~E1000_EECD_DI
;
182 eecd
|= E1000_EECD_DI
;
184 E1000_WRITE_REG(hw
, EECD
, eecd
);
185 E1000_WRITE_FLUSH(hw
);
189 e1000_raise_ee_clk(hw
, &eecd
);
190 e1000_lower_ee_clk(hw
, &eecd
);
196 /* We leave the "DI" bit set to "0" when we leave this routine. */
197 eecd
&= ~E1000_EECD_DI
;
198 E1000_WRITE_REG(hw
, EECD
, eecd
);
201 /******************************************************************************
202 * Shift data bits in from the EEPROM
204 * hw - Struct containing variables accessed by shared code
205 *****************************************************************************/
207 e1000_shift_in_ee_bits(struct e1000_hw
*hw
)
213 /* In order to read a register from the EEPROM, we need to shift 16 bits
214 * in from the EEPROM. Bits are "shifted in" by raising the clock input to
215 * the EEPROM (setting the SK bit), and then reading the value of the "DO"
216 * bit. During this "shifting in" process the "DI" bit should always be
220 eecd
= E1000_READ_REG(hw
, EECD
);
222 eecd
&= ~(E1000_EECD_DO
| E1000_EECD_DI
);
225 for (i
= 0; i
< 16; i
++) {
227 e1000_raise_ee_clk(hw
, &eecd
);
229 eecd
= E1000_READ_REG(hw
, EECD
);
231 eecd
&= ~(E1000_EECD_DI
);
232 if (eecd
& E1000_EECD_DO
)
235 e1000_lower_ee_clk(hw
, &eecd
);
241 /******************************************************************************
242 * Prepares EEPROM for access
244 * hw - Struct containing variables accessed by shared code
246 * Lowers EEPROM clock. Clears input pin. Sets the chip select pin. This
247 * function should be called before issuing a command to the EEPROM.
248 *****************************************************************************/
250 e1000_setup_eeprom(struct e1000_hw
*hw
)
254 eecd
= E1000_READ_REG(hw
, EECD
);
256 /* Clear SK and DI */
257 eecd
&= ~(E1000_EECD_SK
| E1000_EECD_DI
);
258 E1000_WRITE_REG(hw
, EECD
, eecd
);
261 eecd
|= E1000_EECD_CS
;
262 E1000_WRITE_REG(hw
, EECD
, eecd
);
265 /******************************************************************************
266 * Returns EEPROM to a "standby" state
268 * hw - Struct containing variables accessed by shared code
269 *****************************************************************************/
271 e1000_standby_eeprom(struct e1000_hw
*hw
)
275 eecd
= E1000_READ_REG(hw
, EECD
);
278 eecd
&= ~(E1000_EECD_CS
| E1000_EECD_SK
);
279 E1000_WRITE_REG(hw
, EECD
, eecd
);
280 E1000_WRITE_FLUSH(hw
);
284 eecd
|= E1000_EECD_SK
;
285 E1000_WRITE_REG(hw
, EECD
, eecd
);
286 E1000_WRITE_FLUSH(hw
);
290 eecd
|= E1000_EECD_CS
;
291 E1000_WRITE_REG(hw
, EECD
, eecd
);
292 E1000_WRITE_FLUSH(hw
);
296 eecd
&= ~E1000_EECD_SK
;
297 E1000_WRITE_REG(hw
, EECD
, eecd
);
298 E1000_WRITE_FLUSH(hw
);
302 /******************************************************************************
303 * Reads a 16 bit word from the EEPROM.
305 * hw - Struct containing variables accessed by shared code
306 * offset - offset of word in the EEPROM to read
307 * data - word read from the EEPROM
308 *****************************************************************************/
310 e1000_read_eeprom(struct e1000_hw
*hw
, uint16_t offset
, uint16_t * data
)
314 int large_eeprom
= FALSE
;
316 /* Request EEPROM Access */
317 if (hw
->mac_type
> e1000_82544
) {
318 eecd
= E1000_READ_REG(hw
, EECD
);
319 if (eecd
& E1000_EECD_SIZE
)
321 eecd
|= E1000_EECD_REQ
;
322 E1000_WRITE_REG(hw
, EECD
, eecd
);
323 eecd
= E1000_READ_REG(hw
, EECD
);
324 while ((!(eecd
& E1000_EECD_GNT
)) && (i
< 100)) {
327 eecd
= E1000_READ_REG(hw
, EECD
);
329 if (!(eecd
& E1000_EECD_GNT
)) {
330 eecd
&= ~E1000_EECD_REQ
;
331 E1000_WRITE_REG(hw
, EECD
, eecd
);
332 DEBUGOUT("Could not acquire EEPROM grant\n");
333 return -E1000_ERR_EEPROM
;
337 /* Prepare the EEPROM for reading */
338 e1000_setup_eeprom(hw
);
340 /* Send the READ command (opcode + addr) */
341 e1000_shift_out_ee_bits(hw
, EEPROM_READ_OPCODE
, 3);
342 e1000_shift_out_ee_bits(hw
, offset
, (large_eeprom
) ? 8 : 6);
345 *data
= e1000_shift_in_ee_bits(hw
);
347 /* End this read operation */
348 e1000_standby_eeprom(hw
);
350 /* Stop requesting EEPROM access */
351 if (hw
->mac_type
> e1000_82544
) {
352 eecd
= E1000_READ_REG(hw
, EECD
);
353 eecd
&= ~E1000_EECD_REQ
;
354 E1000_WRITE_REG(hw
, EECD
, eecd
);
362 e1000_eeprom_cleanup(struct e1000_hw
*hw
)
366 eecd
= E1000_READ_REG(hw
, EECD
);
367 eecd
&= ~(E1000_EECD_CS
| E1000_EECD_DI
);
368 E1000_WRITE_REG(hw
, EECD
, eecd
);
369 e1000_raise_ee_clk(hw
, &eecd
);
370 e1000_lower_ee_clk(hw
, &eecd
);
374 e1000_wait_eeprom_done(struct e1000_hw
*hw
)
379 e1000_standby_eeprom(hw
);
380 for (i
= 0; i
< 200; i
++) {
381 eecd
= E1000_READ_REG(hw
, EECD
);
382 if (eecd
& E1000_EECD_DO
)
390 e1000_write_eeprom(struct e1000_hw
*hw
, uint16_t Reg
, uint16_t Data
)
393 int large_eeprom
= FALSE
;
396 /* Request EEPROM Access */
397 if (hw
->mac_type
> e1000_82544
) {
398 eecd
= E1000_READ_REG(hw
, EECD
);
399 if (eecd
& E1000_EECD_SIZE
)
401 eecd
|= E1000_EECD_REQ
;
402 E1000_WRITE_REG(hw
, EECD
, eecd
);
403 eecd
= E1000_READ_REG(hw
, EECD
);
404 while ((!(eecd
& E1000_EECD_GNT
)) && (i
< 100)) {
407 eecd
= E1000_READ_REG(hw
, EECD
);
409 if (!(eecd
& E1000_EECD_GNT
)) {
410 eecd
&= ~E1000_EECD_REQ
;
411 E1000_WRITE_REG(hw
, EECD
, eecd
);
412 DEBUGOUT("Could not acquire EEPROM grant\n");
416 e1000_setup_eeprom(hw
);
417 e1000_shift_out_ee_bits(hw
, EEPROM_EWEN_OPCODE
, 5);
418 e1000_shift_out_ee_bits(hw
, Reg
, (large_eeprom
) ? 6 : 4);
419 e1000_standby_eeprom(hw
);
420 e1000_shift_out_ee_bits(hw
, EEPROM_WRITE_OPCODE
, 3);
421 e1000_shift_out_ee_bits(hw
, Reg
, (large_eeprom
) ? 8 : 6);
422 e1000_shift_out_ee_bits(hw
, Data
, 16);
423 if (!e1000_wait_eeprom_done(hw
)) {
426 e1000_shift_out_ee_bits(hw
, EEPROM_EWDS_OPCODE
, 5);
427 e1000_shift_out_ee_bits(hw
, Reg
, (large_eeprom
) ? 6 : 4);
428 e1000_eeprom_cleanup(hw
);
430 /* Stop requesting EEPROM access */
431 if (hw
->mac_type
> e1000_82544
) {
432 eecd
= E1000_READ_REG(hw
, EECD
);
433 eecd
&= ~E1000_EECD_REQ
;
434 E1000_WRITE_REG(hw
, EECD
, eecd
);
437 eecd
= E1000_READ_REG(hw
, EECD
);
438 while (((eecd
& E1000_EECD_GNT
)) && (i
< 500)) {
441 eecd
= E1000_READ_REG(hw
, EECD
);
443 if ((eecd
& E1000_EECD_GNT
)) {
444 DEBUGOUT("Could not release EEPROM grant\n");
450 /******************************************************************************
451 * Verifies that the EEPROM has a valid checksum
453 * hw - Struct containing variables accessed by shared code
455 * Reads the first 64 16 bit words of the EEPROM and sums the values read.
456 * If the the sum of the 64 16 bit words is 0xBABA, the EEPROM's checksum is
458 *****************************************************************************/
460 e1000_validate_eeprom_checksum(struct eth_device
*nic
)
462 struct e1000_hw
*hw
= nic
->priv
;
463 uint16_t checksum
= 0;
464 uint16_t i
, eeprom_data
;
468 for (i
= 0; i
< (EEPROM_CHECKSUM_REG
+ 1); i
++) {
469 if (e1000_read_eeprom(hw
, i
, &eeprom_data
) < 0) {
470 DEBUGOUT("EEPROM Read Error\n");
471 return -E1000_ERR_EEPROM
;
473 checksum
+= eeprom_data
;
476 if (checksum
== (uint16_t) EEPROM_SUM
) {
479 DEBUGOUT("EEPROM Checksum Invalid\n");
480 return -E1000_ERR_EEPROM
;
483 #endif /* #ifndef CONFIG_AP1000 */
485 /******************************************************************************
486 * Reads the adapter's MAC address from the EEPROM and inverts the LSB for the
487 * second function of dual function devices
489 * nic - Struct containing variables accessed by shared code
490 *****************************************************************************/
492 e1000_read_mac_addr(struct eth_device
*nic
)
494 #ifndef CONFIG_AP1000
495 struct e1000_hw
*hw
= nic
->priv
;
497 uint16_t eeprom_data
;
502 for (i
= 0; i
< NODE_ADDRESS_SIZE
; i
+= 2) {
504 if (e1000_read_eeprom(hw
, offset
, &eeprom_data
) < 0) {
505 DEBUGOUT("EEPROM Read Error\n");
506 return -E1000_ERR_EEPROM
;
508 nic
->enetaddr
[i
] = eeprom_data
& 0xff;
509 nic
->enetaddr
[i
+ 1] = (eeprom_data
>> 8) & 0xff;
511 if ((hw
->mac_type
== e1000_82546
) &&
512 (E1000_READ_REG(hw
, STATUS
) & E1000_STATUS_FUNC_1
)) {
513 /* Invert the last bit if this is the second device */
514 nic
->enetaddr
[5] += 1;
516 #ifdef CONFIG_E1000_FALLBACK_MAC
517 if ( *(u32
*)(nic
->enetaddr
) == 0 || *(u32
*)(nic
->enetaddr
) == ~0 )
518 for ( i
=0; i
< NODE_ADDRESS_SIZE
; i
++ )
519 nic
->enetaddr
[i
] = (CONFIG_E1000_FALLBACK_MAC
>> (8*(5-i
))) & 0xff;
523 * The AP1000's e1000 has no eeprom; the MAC address is stored in the
524 * environment variables. Currently this does not support the addition
525 * of a PMC e1000 card, which is certainly a possibility, so this should
526 * be updated to properly use the env variable only for the onboard e1000
534 s
= getenv ("ethaddr");
536 return -E1000_ERR_EEPROM
;
539 for(ii
= 0; ii
< 6; ii
++) {
540 nic
->enetaddr
[ii
] = s
? simple_strtoul (s
, &e
, 16) : 0;
542 s
= (*e
) ? e
+ 1 : e
;
550 /******************************************************************************
551 * Initializes receive address filters.
553 * hw - Struct containing variables accessed by shared code
555 * Places the MAC address in receive address register 0 and clears the rest
556 * of the receive addresss registers. Clears the multicast table. Assumes
557 * the receiver is in reset when the routine is called.
558 *****************************************************************************/
560 e1000_init_rx_addrs(struct eth_device
*nic
)
562 struct e1000_hw
*hw
= nic
->priv
;
569 /* Setup the receive address. */
570 DEBUGOUT("Programming MAC Address into RAR[0]\n");
571 addr_low
= (nic
->enetaddr
[0] |
572 (nic
->enetaddr
[1] << 8) |
573 (nic
->enetaddr
[2] << 16) | (nic
->enetaddr
[3] << 24));
575 addr_high
= (nic
->enetaddr
[4] | (nic
->enetaddr
[5] << 8) | E1000_RAH_AV
);
577 E1000_WRITE_REG_ARRAY(hw
, RA
, 0, addr_low
);
578 E1000_WRITE_REG_ARRAY(hw
, RA
, 1, addr_high
);
580 /* Zero out the other 15 receive addresses. */
581 DEBUGOUT("Clearing RAR[1-15]\n");
582 for (i
= 1; i
< E1000_RAR_ENTRIES
; i
++) {
583 E1000_WRITE_REG_ARRAY(hw
, RA
, (i
<< 1), 0);
584 E1000_WRITE_REG_ARRAY(hw
, RA
, ((i
<< 1) + 1), 0);
588 /******************************************************************************
589 * Clears the VLAN filer table
591 * hw - Struct containing variables accessed by shared code
592 *****************************************************************************/
594 e1000_clear_vfta(struct e1000_hw
*hw
)
598 for (offset
= 0; offset
< E1000_VLAN_FILTER_TBL_SIZE
; offset
++)
599 E1000_WRITE_REG_ARRAY(hw
, VFTA
, offset
, 0);
602 /******************************************************************************
603 * Set the mac type member in the hw struct.
605 * hw - Struct containing variables accessed by shared code
606 *****************************************************************************/
608 e1000_set_mac_type(struct e1000_hw
*hw
)
612 switch (hw
->device_id
) {
613 case E1000_DEV_ID_82542
:
614 switch (hw
->revision_id
) {
615 case E1000_82542_2_0_REV_ID
:
616 hw
->mac_type
= e1000_82542_rev2_0
;
618 case E1000_82542_2_1_REV_ID
:
619 hw
->mac_type
= e1000_82542_rev2_1
;
622 /* Invalid 82542 revision ID */
623 return -E1000_ERR_MAC_TYPE
;
626 case E1000_DEV_ID_82543GC_FIBER
:
627 case E1000_DEV_ID_82543GC_COPPER
:
628 hw
->mac_type
= e1000_82543
;
630 case E1000_DEV_ID_82544EI_COPPER
:
631 case E1000_DEV_ID_82544EI_FIBER
:
632 case E1000_DEV_ID_82544GC_COPPER
:
633 case E1000_DEV_ID_82544GC_LOM
:
634 hw
->mac_type
= e1000_82544
;
636 case E1000_DEV_ID_82540EM
:
637 case E1000_DEV_ID_82540EM_LOM
:
638 hw
->mac_type
= e1000_82540
;
640 case E1000_DEV_ID_82545EM_COPPER
:
641 case E1000_DEV_ID_82545EM_FIBER
:
642 hw
->mac_type
= e1000_82545
;
644 case E1000_DEV_ID_82546EB_COPPER
:
645 case E1000_DEV_ID_82546EB_FIBER
:
646 hw
->mac_type
= e1000_82546
;
648 case E1000_DEV_ID_82541ER
:
649 hw
->mac_type
= e1000_82541_rev_2
;
652 /* Should never have loaded on this device */
653 return -E1000_ERR_MAC_TYPE
;
655 return E1000_SUCCESS
;
658 /******************************************************************************
659 * Reset the transmit and receive units; mask and clear all interrupts.
661 * hw - Struct containing variables accessed by shared code
662 *****************************************************************************/
664 e1000_reset_hw(struct e1000_hw
*hw
)
673 /* For 82542 (rev 2.0), disable MWI before issuing a device reset */
674 if (hw
->mac_type
== e1000_82542_rev2_0
) {
675 DEBUGOUT("Disabling MWI on 82542 rev 2.0\n");
676 pci_write_config_word(hw
->pdev
, PCI_COMMAND
,
678 pci_cmd_word
& ~PCI_COMMAND_INVALIDATE
);
681 /* Clear interrupt mask to stop board from generating interrupts */
682 DEBUGOUT("Masking off all interrupts\n");
683 E1000_WRITE_REG(hw
, IMC
, 0xffffffff);
685 /* Disable the Transmit and Receive units. Then delay to allow
686 * any pending transactions to complete before we hit the MAC with
689 E1000_WRITE_REG(hw
, RCTL
, 0);
690 E1000_WRITE_REG(hw
, TCTL
, E1000_TCTL_PSP
);
691 E1000_WRITE_FLUSH(hw
);
693 /* The tbi_compatibility_on Flag must be cleared when Rctl is cleared. */
694 hw
->tbi_compatibility_on
= FALSE
;
696 /* Delay to allow any outstanding PCI transactions to complete before
697 * resetting the device
701 /* Issue a global reset to the MAC. This will reset the chip's
702 * transmit, receive, DMA, and link units. It will not effect
703 * the current PCI configuration. The global reset bit is self-
704 * clearing, and should clear within a microsecond.
706 DEBUGOUT("Issuing a global reset to MAC\n");
707 ctrl
= E1000_READ_REG(hw
, CTRL
);
710 if (hw
->mac_type
> e1000_82543
)
711 E1000_WRITE_REG_IO(hw
, CTRL
, (ctrl
| E1000_CTRL_RST
));
714 E1000_WRITE_REG(hw
, CTRL
, (ctrl
| E1000_CTRL_RST
));
716 /* Force a reload from the EEPROM if necessary */
717 if (hw
->mac_type
< e1000_82540
) {
718 /* Wait for reset to complete */
720 ctrl_ext
= E1000_READ_REG(hw
, CTRL_EXT
);
721 ctrl_ext
|= E1000_CTRL_EXT_EE_RST
;
722 E1000_WRITE_REG(hw
, CTRL_EXT
, ctrl_ext
);
723 E1000_WRITE_FLUSH(hw
);
724 /* Wait for EEPROM reload */
727 /* Wait for EEPROM reload (it happens automatically) */
729 /* Dissable HW ARPs on ASF enabled adapters */
730 manc
= E1000_READ_REG(hw
, MANC
);
731 manc
&= ~(E1000_MANC_ARP_EN
);
732 E1000_WRITE_REG(hw
, MANC
, manc
);
735 /* Clear interrupt mask to stop board from generating interrupts */
736 DEBUGOUT("Masking off all interrupts\n");
737 E1000_WRITE_REG(hw
, IMC
, 0xffffffff);
739 /* Clear any pending interrupt events. */
740 icr
= E1000_READ_REG(hw
, ICR
);
742 /* If MWI was previously enabled, reenable it. */
743 if (hw
->mac_type
== e1000_82542_rev2_0
) {
744 pci_write_config_word(hw
->pdev
, PCI_COMMAND
, hw
->pci_cmd_word
);
748 /******************************************************************************
749 * Performs basic configuration of the adapter.
751 * hw - Struct containing variables accessed by shared code
753 * Assumes that the controller has previously been reset and is in a
754 * post-reset uninitialized state. Initializes the receive address registers,
755 * multicast table, and VLAN filter table. Calls routines to setup link
756 * configuration and flow control settings. Clears all on-chip counters. Leaves
757 * the transmit and receive units disabled and uninitialized.
758 *****************************************************************************/
760 e1000_init_hw(struct eth_device
*nic
)
762 struct e1000_hw
*hw
= nic
->priv
;
763 uint32_t ctrl
, status
;
766 uint16_t pcix_cmd_word
;
767 uint16_t pcix_stat_hi_word
;
770 e1000_bus_type bus_type
= e1000_bus_type_unknown
;
774 /* Initialize Identification LED */
775 ret_val
= e1000_id_led_init(hw
);
777 DEBUGOUT("Error Initializing Identification LED\n");
781 /* Set the Media Type and exit with error if it is not valid. */
782 if (hw
->mac_type
!= e1000_82543
) {
783 /* tbi_compatibility is only valid on 82543 */
784 hw
->tbi_compatibility_en
= FALSE
;
787 if (hw
->mac_type
>= e1000_82543
) {
788 status
= E1000_READ_REG(hw
, STATUS
);
789 if (status
& E1000_STATUS_TBIMODE
) {
790 hw
->media_type
= e1000_media_type_fiber
;
791 /* tbi_compatibility not valid on fiber */
792 hw
->tbi_compatibility_en
= FALSE
;
794 hw
->media_type
= e1000_media_type_copper
;
797 /* This is an 82542 (fiber only) */
798 hw
->media_type
= e1000_media_type_fiber
;
801 /* Disabling VLAN filtering. */
802 DEBUGOUT("Initializing the IEEE VLAN\n");
803 E1000_WRITE_REG(hw
, VET
, 0);
805 e1000_clear_vfta(hw
);
807 /* For 82542 (rev 2.0), disable MWI and put the receiver into reset */
808 if (hw
->mac_type
== e1000_82542_rev2_0
) {
809 DEBUGOUT("Disabling MWI on 82542 rev 2.0\n");
810 pci_write_config_word(hw
->pdev
, PCI_COMMAND
,
812 pci_cmd_word
& ~PCI_COMMAND_INVALIDATE
);
813 E1000_WRITE_REG(hw
, RCTL
, E1000_RCTL_RST
);
814 E1000_WRITE_FLUSH(hw
);
818 /* Setup the receive address. This involves initializing all of the Receive
819 * Address Registers (RARs 0 - 15).
821 e1000_init_rx_addrs(nic
);
823 /* For 82542 (rev 2.0), take the receiver out of reset and enable MWI */
824 if (hw
->mac_type
== e1000_82542_rev2_0
) {
825 E1000_WRITE_REG(hw
, RCTL
, 0);
826 E1000_WRITE_FLUSH(hw
);
828 pci_write_config_word(hw
->pdev
, PCI_COMMAND
, hw
->pci_cmd_word
);
831 /* Zero out the Multicast HASH table */
832 DEBUGOUT("Zeroing the MTA\n");
833 for (i
= 0; i
< E1000_MC_TBL_SIZE
; i
++)
834 E1000_WRITE_REG_ARRAY(hw
, MTA
, i
, 0);
837 /* Set the PCI priority bit correctly in the CTRL register. This
838 * determines if the adapter gives priority to receives, or if it
839 * gives equal priority to transmits and receives.
841 if (hw
->dma_fairness
) {
842 ctrl
= E1000_READ_REG(hw
, CTRL
);
843 E1000_WRITE_REG(hw
, CTRL
, ctrl
| E1000_CTRL_PRIOR
);
846 if (hw
->mac_type
>= e1000_82543
) {
847 status
= E1000_READ_REG(hw
, STATUS
);
848 bus_type
= (status
& E1000_STATUS_PCIX_MODE
) ?
849 e1000_bus_type_pcix
: e1000_bus_type_pci
;
851 /* Workaround for PCI-X problem when BIOS sets MMRBC incorrectly. */
852 if (bus_type
== e1000_bus_type_pcix
) {
853 pci_read_config_word(hw
->pdev
, PCIX_COMMAND_REGISTER
,
855 pci_read_config_word(hw
->pdev
, PCIX_STATUS_REGISTER_HI
,
858 (pcix_cmd_word
& PCIX_COMMAND_MMRBC_MASK
) >>
859 PCIX_COMMAND_MMRBC_SHIFT
;
861 (pcix_stat_hi_word
& PCIX_STATUS_HI_MMRBC_MASK
) >>
862 PCIX_STATUS_HI_MMRBC_SHIFT
;
863 if (stat_mmrbc
== PCIX_STATUS_HI_MMRBC_4K
)
864 stat_mmrbc
= PCIX_STATUS_HI_MMRBC_2K
;
865 if (cmd_mmrbc
> stat_mmrbc
) {
866 pcix_cmd_word
&= ~PCIX_COMMAND_MMRBC_MASK
;
867 pcix_cmd_word
|= stat_mmrbc
<< PCIX_COMMAND_MMRBC_SHIFT
;
868 pci_write_config_word(hw
->pdev
, PCIX_COMMAND_REGISTER
,
873 /* Call a subroutine to configure the link and setup flow control. */
874 ret_val
= e1000_setup_link(nic
);
876 /* Set the transmit descriptor write-back policy */
877 if (hw
->mac_type
> e1000_82544
) {
878 ctrl
= E1000_READ_REG(hw
, TXDCTL
);
880 (ctrl
& ~E1000_TXDCTL_WTHRESH
) |
881 E1000_TXDCTL_FULL_TX_DESC_WB
;
882 E1000_WRITE_REG(hw
, TXDCTL
, ctrl
);
885 /* Clear all of the statistics registers (clear on read). It is
886 * important that we do this after we have tried to establish link
887 * because the symbol error count will increment wildly if there
890 e1000_clear_hw_cntrs(hw
);
896 /******************************************************************************
897 * Configures flow control and link settings.
899 * hw - Struct containing variables accessed by shared code
901 * Determines which flow control settings to use. Calls the apropriate media-
902 * specific link configuration function. Configures the flow control settings.
903 * Assuming the adapter has a valid link partner, a valid link should be
904 * established. Assumes the hardware has previously been reset and the
905 * transmitter and receiver are not enabled.
906 *****************************************************************************/
908 e1000_setup_link(struct eth_device
*nic
)
910 struct e1000_hw
*hw
= nic
->priv
;
913 uint16_t eeprom_data
;
917 #ifndef CONFIG_AP1000
918 /* Read and store word 0x0F of the EEPROM. This word contains bits
919 * that determine the hardware's default PAUSE (flow control) mode,
920 * a bit that determines whether the HW defaults to enabling or
921 * disabling auto-negotiation, and the direction of the
922 * SW defined pins. If there is no SW over-ride of the flow
923 * control setting, then the variable hw->fc will
924 * be initialized based on a value in the EEPROM.
926 if (e1000_read_eeprom(hw
, EEPROM_INIT_CONTROL2_REG
, &eeprom_data
) < 0) {
927 DEBUGOUT("EEPROM Read Error\n");
928 return -E1000_ERR_EEPROM
;
931 /* we have to hardcode the proper value for our hardware. */
932 /* this value is for the 82540EM pci card used for prototyping, and it works. */
933 eeprom_data
= 0xb220;
936 if (hw
->fc
== e1000_fc_default
) {
937 if ((eeprom_data
& EEPROM_WORD0F_PAUSE_MASK
) == 0)
938 hw
->fc
= e1000_fc_none
;
939 else if ((eeprom_data
& EEPROM_WORD0F_PAUSE_MASK
) ==
940 EEPROM_WORD0F_ASM_DIR
)
941 hw
->fc
= e1000_fc_tx_pause
;
943 hw
->fc
= e1000_fc_full
;
946 /* We want to save off the original Flow Control configuration just
947 * in case we get disconnected and then reconnected into a different
948 * hub or switch with different Flow Control capabilities.
950 if (hw
->mac_type
== e1000_82542_rev2_0
)
951 hw
->fc
&= (~e1000_fc_tx_pause
);
953 if ((hw
->mac_type
< e1000_82543
) && (hw
->report_tx_early
== 1))
954 hw
->fc
&= (~e1000_fc_rx_pause
);
956 hw
->original_fc
= hw
->fc
;
958 DEBUGOUT("After fix-ups FlowControl is now = %x\n", hw
->fc
);
960 /* Take the 4 bits from EEPROM word 0x0F that determine the initial
961 * polarity value for the SW controlled pins, and setup the
962 * Extended Device Control reg with that info.
963 * This is needed because one of the SW controlled pins is used for
964 * signal detection. So this should be done before e1000_setup_pcs_link()
965 * or e1000_phy_setup() is called.
967 if (hw
->mac_type
== e1000_82543
) {
968 ctrl_ext
= ((eeprom_data
& EEPROM_WORD0F_SWPDIO_EXT
) <<
970 E1000_WRITE_REG(hw
, CTRL_EXT
, ctrl_ext
);
973 /* Call the necessary subroutine to configure the link. */
974 ret_val
= (hw
->media_type
== e1000_media_type_fiber
) ?
975 e1000_setup_fiber_link(nic
) : e1000_setup_copper_link(nic
);
980 /* Initialize the flow control address, type, and PAUSE timer
981 * registers to their default values. This is done even if flow
982 * control is disabled, because it does not hurt anything to
983 * initialize these registers.
986 ("Initializing the Flow Control address, type and timer regs\n");
988 E1000_WRITE_REG(hw
, FCAL
, FLOW_CONTROL_ADDRESS_LOW
);
989 E1000_WRITE_REG(hw
, FCAH
, FLOW_CONTROL_ADDRESS_HIGH
);
990 E1000_WRITE_REG(hw
, FCT
, FLOW_CONTROL_TYPE
);
991 E1000_WRITE_REG(hw
, FCTTV
, hw
->fc_pause_time
);
993 /* Set the flow control receive threshold registers. Normally,
994 * these registers will be set to a default threshold that may be
995 * adjusted later by the driver's runtime code. However, if the
996 * ability to transmit pause frames in not enabled, then these
997 * registers will be set to 0.
999 if (!(hw
->fc
& e1000_fc_tx_pause
)) {
1000 E1000_WRITE_REG(hw
, FCRTL
, 0);
1001 E1000_WRITE_REG(hw
, FCRTH
, 0);
1003 /* We need to set up the Receive Threshold high and low water marks
1004 * as well as (optionally) enabling the transmission of XON frames.
1006 if (hw
->fc_send_xon
) {
1007 E1000_WRITE_REG(hw
, FCRTL
,
1008 (hw
->fc_low_water
| E1000_FCRTL_XONE
));
1009 E1000_WRITE_REG(hw
, FCRTH
, hw
->fc_high_water
);
1011 E1000_WRITE_REG(hw
, FCRTL
, hw
->fc_low_water
);
1012 E1000_WRITE_REG(hw
, FCRTH
, hw
->fc_high_water
);
1018 /******************************************************************************
1019 * Sets up link for a fiber based adapter
1021 * hw - Struct containing variables accessed by shared code
1023 * Manipulates Physical Coding Sublayer functions in order to configure
1024 * link. Assumes the hardware has been previously reset and the transmitter
1025 * and receiver are not enabled.
1026 *****************************************************************************/
1028 e1000_setup_fiber_link(struct eth_device
*nic
)
1030 struct e1000_hw
*hw
= nic
->priv
;
1039 /* On adapters with a MAC newer that 82544, SW Defineable pin 1 will be
1040 * set when the optics detect a signal. On older adapters, it will be
1041 * cleared when there is a signal
1043 ctrl
= E1000_READ_REG(hw
, CTRL
);
1044 if ((hw
->mac_type
> e1000_82544
) && !(ctrl
& E1000_CTRL_ILOS
))
1045 signal
= E1000_CTRL_SWDPIN1
;
1049 printf("signal for %s is %x (ctrl %08x)!!!!\n", nic
->name
, signal
,
1051 /* Take the link out of reset */
1052 ctrl
&= ~(E1000_CTRL_LRST
);
1054 e1000_config_collision_dist(hw
);
1056 /* Check for a software override of the flow control settings, and setup
1057 * the device accordingly. If auto-negotiation is enabled, then software
1058 * will have to set the "PAUSE" bits to the correct value in the Tranmsit
1059 * Config Word Register (TXCW) and re-start auto-negotiation. However, if
1060 * auto-negotiation is disabled, then software will have to manually
1061 * configure the two flow control enable bits in the CTRL register.
1063 * The possible values of the "fc" parameter are:
1064 * 0: Flow control is completely disabled
1065 * 1: Rx flow control is enabled (we can receive pause frames, but
1066 * not send pause frames).
1067 * 2: Tx flow control is enabled (we can send pause frames but we do
1068 * not support receiving pause frames).
1069 * 3: Both Rx and TX flow control (symmetric) are enabled.
1073 /* Flow control is completely disabled by a software over-ride. */
1074 txcw
= (E1000_TXCW_ANE
| E1000_TXCW_FD
);
1076 case e1000_fc_rx_pause
:
1077 /* RX Flow control is enabled and TX Flow control is disabled by a
1078 * software over-ride. Since there really isn't a way to advertise
1079 * that we are capable of RX Pause ONLY, we will advertise that we
1080 * support both symmetric and asymmetric RX PAUSE. Later, we will
1081 * disable the adapter's ability to send PAUSE frames.
1083 txcw
= (E1000_TXCW_ANE
| E1000_TXCW_FD
| E1000_TXCW_PAUSE_MASK
);
1085 case e1000_fc_tx_pause
:
1086 /* TX Flow control is enabled, and RX Flow control is disabled, by a
1087 * software over-ride.
1089 txcw
= (E1000_TXCW_ANE
| E1000_TXCW_FD
| E1000_TXCW_ASM_DIR
);
1092 /* Flow control (both RX and TX) is enabled by a software over-ride. */
1093 txcw
= (E1000_TXCW_ANE
| E1000_TXCW_FD
| E1000_TXCW_PAUSE_MASK
);
1096 DEBUGOUT("Flow control param set incorrectly\n");
1097 return -E1000_ERR_CONFIG
;
1101 /* Since auto-negotiation is enabled, take the link out of reset (the link
1102 * will be in reset, because we previously reset the chip). This will
1103 * restart auto-negotiation. If auto-neogtiation is successful then the
1104 * link-up status bit will be set and the flow control enable bits (RFCE
1105 * and TFCE) will be set according to their negotiated value.
1107 DEBUGOUT("Auto-negotiation enabled (%#x)\n", txcw
);
1109 E1000_WRITE_REG(hw
, TXCW
, txcw
);
1110 E1000_WRITE_REG(hw
, CTRL
, ctrl
);
1111 E1000_WRITE_FLUSH(hw
);
1116 /* If we have a signal (the cable is plugged in) then poll for a "Link-Up"
1117 * indication in the Device Status Register. Time-out if a link isn't
1118 * seen in 500 milliseconds seconds (Auto-negotiation should complete in
1119 * less than 500 milliseconds even if the other end is doing it in SW).
1121 if ((E1000_READ_REG(hw
, CTRL
) & E1000_CTRL_SWDPIN1
) == signal
) {
1122 DEBUGOUT("Looking for Link\n");
1123 for (i
= 0; i
< (LINK_UP_TIMEOUT
/ 10); i
++) {
1125 status
= E1000_READ_REG(hw
, STATUS
);
1126 if (status
& E1000_STATUS_LU
)
1129 if (i
== (LINK_UP_TIMEOUT
/ 10)) {
1130 /* AutoNeg failed to achieve a link, so we'll call
1131 * e1000_check_for_link. This routine will force the link up if we
1132 * detect a signal. This will allow us to communicate with
1133 * non-autonegotiating link partners.
1135 DEBUGOUT("Never got a valid link from auto-neg!!!\n");
1136 hw
->autoneg_failed
= 1;
1137 ret_val
= e1000_check_for_link(nic
);
1139 DEBUGOUT("Error while checking for link\n");
1142 hw
->autoneg_failed
= 0;
1144 hw
->autoneg_failed
= 0;
1145 DEBUGOUT("Valid Link Found\n");
1148 DEBUGOUT("No Signal Detected\n");
1149 return -E1000_ERR_NOLINK
;
1154 /******************************************************************************
1155 * Detects which PHY is present and the speed and duplex
1157 * hw - Struct containing variables accessed by shared code
1158 ******************************************************************************/
1160 e1000_setup_copper_link(struct eth_device
*nic
)
1162 struct e1000_hw
*hw
= nic
->priv
;
1170 ctrl
= E1000_READ_REG(hw
, CTRL
);
1171 /* With 82543, we need to force speed and duplex on the MAC equal to what
1172 * the PHY speed and duplex configuration is. In addition, we need to
1173 * perform a hardware reset on the PHY to take it out of reset.
1175 if (hw
->mac_type
> e1000_82543
) {
1176 ctrl
|= E1000_CTRL_SLU
;
1177 ctrl
&= ~(E1000_CTRL_FRCSPD
| E1000_CTRL_FRCDPX
);
1178 E1000_WRITE_REG(hw
, CTRL
, ctrl
);
1181 (E1000_CTRL_FRCSPD
| E1000_CTRL_FRCDPX
| E1000_CTRL_SLU
);
1182 E1000_WRITE_REG(hw
, CTRL
, ctrl
);
1183 e1000_phy_hw_reset(hw
);
1186 /* Make sure we have a valid PHY */
1187 ret_val
= e1000_detect_gig_phy(hw
);
1189 DEBUGOUT("Error, did not detect valid phy.\n");
1192 DEBUGOUT("Phy ID = %x \n", hw
->phy_id
);
1194 /* Enable CRS on TX. This must be set for half-duplex operation. */
1195 if (e1000_read_phy_reg(hw
, M88E1000_PHY_SPEC_CTRL
, &phy_data
) < 0) {
1196 DEBUGOUT("PHY Read Error\n");
1197 return -E1000_ERR_PHY
;
1199 phy_data
|= M88E1000_PSCR_ASSERT_CRS_ON_TX
;
1203 * MDI/MDI-X = 0 (default)
1204 * 0 - Auto for all speeds
1207 * 3 - Auto for 1000Base-T only (MDI-X for 10/100Base-T modes)
1209 phy_data
&= ~M88E1000_PSCR_AUTO_X_MODE
;
1212 phy_data
|= M88E1000_PSCR_MDI_MANUAL_MODE
;
1215 phy_data
|= M88E1000_PSCR_MDIX_MANUAL_MODE
;
1218 phy_data
|= M88E1000_PSCR_AUTO_X_1000T
;
1222 phy_data
|= M88E1000_PSCR_AUTO_X_MODE
;
1226 phy_data
|= M88E1000_PSCR_AUTO_X_MODE
;
1231 * disable_polarity_correction = 0 (default)
1232 * Automatic Correction for Reversed Cable Polarity
1236 phy_data
&= ~M88E1000_PSCR_POLARITY_REVERSAL
;
1237 if (hw
->disable_polarity_correction
== 1)
1238 phy_data
|= M88E1000_PSCR_POLARITY_REVERSAL
;
1240 phy_data
&= ~M88E1000_PSCR_POLARITY_REVERSAL
;
1242 if (e1000_write_phy_reg(hw
, M88E1000_PHY_SPEC_CTRL
, phy_data
) < 0) {
1243 DEBUGOUT("PHY Write Error\n");
1244 return -E1000_ERR_PHY
;
1247 /* Force TX_CLK in the Extended PHY Specific Control Register
1250 if (e1000_read_phy_reg(hw
, M88E1000_EXT_PHY_SPEC_CTRL
, &phy_data
) < 0) {
1251 DEBUGOUT("PHY Read Error\n");
1252 return -E1000_ERR_PHY
;
1254 phy_data
|= M88E1000_EPSCR_TX_CLK_25
;
1255 /* Configure Master and Slave downshift values */
1256 phy_data
&= ~(M88E1000_EPSCR_MASTER_DOWNSHIFT_MASK
|
1257 M88E1000_EPSCR_SLAVE_DOWNSHIFT_MASK
);
1258 phy_data
|= (M88E1000_EPSCR_MASTER_DOWNSHIFT_1X
|
1259 M88E1000_EPSCR_SLAVE_DOWNSHIFT_1X
);
1260 if (e1000_write_phy_reg(hw
, M88E1000_EXT_PHY_SPEC_CTRL
, phy_data
) < 0) {
1261 DEBUGOUT("PHY Write Error\n");
1262 return -E1000_ERR_PHY
;
1265 /* SW Reset the PHY so all changes take effect */
1266 ret_val
= e1000_phy_reset(hw
);
1268 DEBUGOUT("Error Resetting the PHY\n");
1273 * autoneg = 1 (default)
1274 * PHY will advertise value(s) parsed from
1275 * autoneg_advertised and fc
1277 * PHY will be set to 10H, 10F, 100H, or 100F
1278 * depending on value parsed from forced_speed_duplex.
1281 /* Is autoneg enabled? This is enabled by default or by software override.
1282 * If so, call e1000_phy_setup_autoneg routine to parse the
1283 * autoneg_advertised and fc options. If autoneg is NOT enabled, then the
1284 * user should have provided a speed/duplex override. If so, then call
1285 * e1000_phy_force_speed_duplex to parse and set this up.
1287 /* Perform some bounds checking on the hw->autoneg_advertised
1288 * parameter. If this variable is zero, then set it to the default.
1290 hw
->autoneg_advertised
&= AUTONEG_ADVERTISE_SPEED_DEFAULT
;
1292 /* If autoneg_advertised is zero, we assume it was not defaulted
1293 * by the calling code so we set to advertise full capability.
1295 if (hw
->autoneg_advertised
== 0)
1296 hw
->autoneg_advertised
= AUTONEG_ADVERTISE_SPEED_DEFAULT
;
1298 DEBUGOUT("Reconfiguring auto-neg advertisement params\n");
1299 ret_val
= e1000_phy_setup_autoneg(hw
);
1301 DEBUGOUT("Error Setting up Auto-Negotiation\n");
1304 DEBUGOUT("Restarting Auto-Neg\n");
1306 /* Restart auto-negotiation by setting the Auto Neg Enable bit and
1307 * the Auto Neg Restart bit in the PHY control register.
1309 if (e1000_read_phy_reg(hw
, PHY_CTRL
, &phy_data
) < 0) {
1310 DEBUGOUT("PHY Read Error\n");
1311 return -E1000_ERR_PHY
;
1313 phy_data
|= (MII_CR_AUTO_NEG_EN
| MII_CR_RESTART_AUTO_NEG
);
1314 if (e1000_write_phy_reg(hw
, PHY_CTRL
, phy_data
) < 0) {
1315 DEBUGOUT("PHY Write Error\n");
1316 return -E1000_ERR_PHY
;
1319 /* Does the user want to wait for Auto-Neg to complete here, or
1320 * check at a later time (for example, callback routine).
1322 if (hw
->wait_autoneg_complete
) {
1323 ret_val
= e1000_wait_autoneg(hw
);
1326 ("Error while waiting for autoneg to complete\n");
1331 /* If we do not wait for autonegtation to complete I
1332 * do not see a valid link status.
1334 ret_val
= e1000_wait_autoneg(hw
);
1336 DEBUGOUT("Error while waiting for autoneg to complete\n");
1341 /* Check link status. Wait up to 100 microseconds for link to become
1344 for (i
= 0; i
< 10; i
++) {
1345 if (e1000_read_phy_reg(hw
, PHY_STATUS
, &phy_data
) < 0) {
1346 DEBUGOUT("PHY Read Error\n");
1347 return -E1000_ERR_PHY
;
1349 if (e1000_read_phy_reg(hw
, PHY_STATUS
, &phy_data
) < 0) {
1350 DEBUGOUT("PHY Read Error\n");
1351 return -E1000_ERR_PHY
;
1353 if (phy_data
& MII_SR_LINK_STATUS
) {
1354 /* We have link, so we need to finish the config process:
1355 * 1) Set up the MAC to the current PHY speed/duplex
1356 * if we are on 82543. If we
1357 * are on newer silicon, we only need to configure
1358 * collision distance in the Transmit Control Register.
1359 * 2) Set up flow control on the MAC to that established with
1362 if (hw
->mac_type
>= e1000_82544
) {
1363 e1000_config_collision_dist(hw
);
1365 ret_val
= e1000_config_mac_to_phy(hw
);
1368 ("Error configuring MAC to PHY settings\n");
1372 ret_val
= e1000_config_fc_after_link_up(hw
);
1374 DEBUGOUT("Error Configuring Flow Control\n");
1377 DEBUGOUT("Valid link established!!!\n");
1383 DEBUGOUT("Unable to establish link!!!\n");
1384 return -E1000_ERR_NOLINK
;
1387 /******************************************************************************
1388 * Configures PHY autoneg and flow control advertisement settings
1390 * hw - Struct containing variables accessed by shared code
1391 ******************************************************************************/
1393 e1000_phy_setup_autoneg(struct e1000_hw
*hw
)
1395 uint16_t mii_autoneg_adv_reg
;
1396 uint16_t mii_1000t_ctrl_reg
;
1400 /* Read the MII Auto-Neg Advertisement Register (Address 4). */
1401 if (e1000_read_phy_reg(hw
, PHY_AUTONEG_ADV
, &mii_autoneg_adv_reg
) < 0) {
1402 DEBUGOUT("PHY Read Error\n");
1403 return -E1000_ERR_PHY
;
1406 /* Read the MII 1000Base-T Control Register (Address 9). */
1407 if (e1000_read_phy_reg(hw
, PHY_1000T_CTRL
, &mii_1000t_ctrl_reg
) < 0) {
1408 DEBUGOUT("PHY Read Error\n");
1409 return -E1000_ERR_PHY
;
1412 /* Need to parse both autoneg_advertised and fc and set up
1413 * the appropriate PHY registers. First we will parse for
1414 * autoneg_advertised software override. Since we can advertise
1415 * a plethora of combinations, we need to check each bit
1419 /* First we clear all the 10/100 mb speed bits in the Auto-Neg
1420 * Advertisement Register (Address 4) and the 1000 mb speed bits in
1421 * the 1000Base-T Control Register (Address 9).
1423 mii_autoneg_adv_reg
&= ~REG4_SPEED_MASK
;
1424 mii_1000t_ctrl_reg
&= ~REG9_SPEED_MASK
;
1426 DEBUGOUT("autoneg_advertised %x\n", hw
->autoneg_advertised
);
1428 /* Do we want to advertise 10 Mb Half Duplex? */
1429 if (hw
->autoneg_advertised
& ADVERTISE_10_HALF
) {
1430 DEBUGOUT("Advertise 10mb Half duplex\n");
1431 mii_autoneg_adv_reg
|= NWAY_AR_10T_HD_CAPS
;
1434 /* Do we want to advertise 10 Mb Full Duplex? */
1435 if (hw
->autoneg_advertised
& ADVERTISE_10_FULL
) {
1436 DEBUGOUT("Advertise 10mb Full duplex\n");
1437 mii_autoneg_adv_reg
|= NWAY_AR_10T_FD_CAPS
;
1440 /* Do we want to advertise 100 Mb Half Duplex? */
1441 if (hw
->autoneg_advertised
& ADVERTISE_100_HALF
) {
1442 DEBUGOUT("Advertise 100mb Half duplex\n");
1443 mii_autoneg_adv_reg
|= NWAY_AR_100TX_HD_CAPS
;
1446 /* Do we want to advertise 100 Mb Full Duplex? */
1447 if (hw
->autoneg_advertised
& ADVERTISE_100_FULL
) {
1448 DEBUGOUT("Advertise 100mb Full duplex\n");
1449 mii_autoneg_adv_reg
|= NWAY_AR_100TX_FD_CAPS
;
1452 /* We do not allow the Phy to advertise 1000 Mb Half Duplex */
1453 if (hw
->autoneg_advertised
& ADVERTISE_1000_HALF
) {
1455 ("Advertise 1000mb Half duplex requested, request denied!\n");
1458 /* Do we want to advertise 1000 Mb Full Duplex? */
1459 if (hw
->autoneg_advertised
& ADVERTISE_1000_FULL
) {
1460 DEBUGOUT("Advertise 1000mb Full duplex\n");
1461 mii_1000t_ctrl_reg
|= CR_1000T_FD_CAPS
;
1464 /* Check for a software override of the flow control settings, and
1465 * setup the PHY advertisement registers accordingly. If
1466 * auto-negotiation is enabled, then software will have to set the
1467 * "PAUSE" bits to the correct value in the Auto-Negotiation
1468 * Advertisement Register (PHY_AUTONEG_ADV) and re-start auto-negotiation.
1470 * The possible values of the "fc" parameter are:
1471 * 0: Flow control is completely disabled
1472 * 1: Rx flow control is enabled (we can receive pause frames
1473 * but not send pause frames).
1474 * 2: Tx flow control is enabled (we can send pause frames
1475 * but we do not support receiving pause frames).
1476 * 3: Both Rx and TX flow control (symmetric) are enabled.
1477 * other: No software override. The flow control configuration
1478 * in the EEPROM is used.
1481 case e1000_fc_none
: /* 0 */
1482 /* Flow control (RX & TX) is completely disabled by a
1483 * software over-ride.
1485 mii_autoneg_adv_reg
&= ~(NWAY_AR_ASM_DIR
| NWAY_AR_PAUSE
);
1487 case e1000_fc_rx_pause
: /* 1 */
1488 /* RX Flow control is enabled, and TX Flow control is
1489 * disabled, by a software over-ride.
1491 /* Since there really isn't a way to advertise that we are
1492 * capable of RX Pause ONLY, we will advertise that we
1493 * support both symmetric and asymmetric RX PAUSE. Later
1494 * (in e1000_config_fc_after_link_up) we will disable the
1495 *hw's ability to send PAUSE frames.
1497 mii_autoneg_adv_reg
|= (NWAY_AR_ASM_DIR
| NWAY_AR_PAUSE
);
1499 case e1000_fc_tx_pause
: /* 2 */
1500 /* TX Flow control is enabled, and RX Flow control is
1501 * disabled, by a software over-ride.
1503 mii_autoneg_adv_reg
|= NWAY_AR_ASM_DIR
;
1504 mii_autoneg_adv_reg
&= ~NWAY_AR_PAUSE
;
1506 case e1000_fc_full
: /* 3 */
1507 /* Flow control (both RX and TX) is enabled by a software
1510 mii_autoneg_adv_reg
|= (NWAY_AR_ASM_DIR
| NWAY_AR_PAUSE
);
1513 DEBUGOUT("Flow control param set incorrectly\n");
1514 return -E1000_ERR_CONFIG
;
1517 if (e1000_write_phy_reg(hw
, PHY_AUTONEG_ADV
, mii_autoneg_adv_reg
) < 0) {
1518 DEBUGOUT("PHY Write Error\n");
1519 return -E1000_ERR_PHY
;
1522 DEBUGOUT("Auto-Neg Advertising %x\n", mii_autoneg_adv_reg
);
1524 if (e1000_write_phy_reg(hw
, PHY_1000T_CTRL
, mii_1000t_ctrl_reg
) < 0) {
1525 DEBUGOUT("PHY Write Error\n");
1526 return -E1000_ERR_PHY
;
1531 /******************************************************************************
1532 * Sets the collision distance in the Transmit Control register
1534 * hw - Struct containing variables accessed by shared code
1536 * Link should have been established previously. Reads the speed and duplex
1537 * information from the Device Status register.
1538 ******************************************************************************/
1540 e1000_config_collision_dist(struct e1000_hw
*hw
)
1544 tctl
= E1000_READ_REG(hw
, TCTL
);
1546 tctl
&= ~E1000_TCTL_COLD
;
1547 tctl
|= E1000_COLLISION_DISTANCE
<< E1000_COLD_SHIFT
;
1549 E1000_WRITE_REG(hw
, TCTL
, tctl
);
1550 E1000_WRITE_FLUSH(hw
);
1553 /******************************************************************************
1554 * Sets MAC speed and duplex settings to reflect the those in the PHY
1556 * hw - Struct containing variables accessed by shared code
1557 * mii_reg - data to write to the MII control register
1559 * The contents of the PHY register containing the needed information need to
1561 ******************************************************************************/
1563 e1000_config_mac_to_phy(struct e1000_hw
*hw
)
1570 /* Read the Device Control Register and set the bits to Force Speed
1573 ctrl
= E1000_READ_REG(hw
, CTRL
);
1574 ctrl
|= (E1000_CTRL_FRCSPD
| E1000_CTRL_FRCDPX
);
1575 ctrl
&= ~(E1000_CTRL_SPD_SEL
| E1000_CTRL_ILOS
);
1577 /* Set up duplex in the Device Control and Transmit Control
1578 * registers depending on negotiated values.
1580 if (e1000_read_phy_reg(hw
, M88E1000_PHY_SPEC_STATUS
, &phy_data
) < 0) {
1581 DEBUGOUT("PHY Read Error\n");
1582 return -E1000_ERR_PHY
;
1584 if (phy_data
& M88E1000_PSSR_DPLX
)
1585 ctrl
|= E1000_CTRL_FD
;
1587 ctrl
&= ~E1000_CTRL_FD
;
1589 e1000_config_collision_dist(hw
);
1591 /* Set up speed in the Device Control register depending on
1592 * negotiated values.
1594 if ((phy_data
& M88E1000_PSSR_SPEED
) == M88E1000_PSSR_1000MBS
)
1595 ctrl
|= E1000_CTRL_SPD_1000
;
1596 else if ((phy_data
& M88E1000_PSSR_SPEED
) == M88E1000_PSSR_100MBS
)
1597 ctrl
|= E1000_CTRL_SPD_100
;
1598 /* Write the configured values back to the Device Control Reg. */
1599 E1000_WRITE_REG(hw
, CTRL
, ctrl
);
1603 /******************************************************************************
1604 * Forces the MAC's flow control settings.
1606 * hw - Struct containing variables accessed by shared code
1608 * Sets the TFCE and RFCE bits in the device control register to reflect
1609 * the adapter settings. TFCE and RFCE need to be explicitly set by
1610 * software when a Copper PHY is used because autonegotiation is managed
1611 * by the PHY rather than the MAC. Software must also configure these
1612 * bits when link is forced on a fiber connection.
1613 *****************************************************************************/
1615 e1000_force_mac_fc(struct e1000_hw
*hw
)
1621 /* Get the current configuration of the Device Control Register */
1622 ctrl
= E1000_READ_REG(hw
, CTRL
);
1624 /* Because we didn't get link via the internal auto-negotiation
1625 * mechanism (we either forced link or we got link via PHY
1626 * auto-neg), we have to manually enable/disable transmit an
1627 * receive flow control.
1629 * The "Case" statement below enables/disable flow control
1630 * according to the "hw->fc" parameter.
1632 * The possible values of the "fc" parameter are:
1633 * 0: Flow control is completely disabled
1634 * 1: Rx flow control is enabled (we can receive pause
1635 * frames but not send pause frames).
1636 * 2: Tx flow control is enabled (we can send pause frames
1637 * frames but we do not receive pause frames).
1638 * 3: Both Rx and TX flow control (symmetric) is enabled.
1639 * other: No other values should be possible at this point.
1644 ctrl
&= (~(E1000_CTRL_TFCE
| E1000_CTRL_RFCE
));
1646 case e1000_fc_rx_pause
:
1647 ctrl
&= (~E1000_CTRL_TFCE
);
1648 ctrl
|= E1000_CTRL_RFCE
;
1650 case e1000_fc_tx_pause
:
1651 ctrl
&= (~E1000_CTRL_RFCE
);
1652 ctrl
|= E1000_CTRL_TFCE
;
1655 ctrl
|= (E1000_CTRL_TFCE
| E1000_CTRL_RFCE
);
1658 DEBUGOUT("Flow control param set incorrectly\n");
1659 return -E1000_ERR_CONFIG
;
1662 /* Disable TX Flow Control for 82542 (rev 2.0) */
1663 if (hw
->mac_type
== e1000_82542_rev2_0
)
1664 ctrl
&= (~E1000_CTRL_TFCE
);
1666 E1000_WRITE_REG(hw
, CTRL
, ctrl
);
1670 /******************************************************************************
1671 * Configures flow control settings after link is established
1673 * hw - Struct containing variables accessed by shared code
1675 * Should be called immediately after a valid link has been established.
1676 * Forces MAC flow control settings if link was forced. When in MII/GMII mode
1677 * and autonegotiation is enabled, the MAC flow control settings will be set
1678 * based on the flow control negotiated by the PHY. In TBI mode, the TFCE
1679 * and RFCE bits will be automaticaly set to the negotiated flow control mode.
1680 *****************************************************************************/
1682 e1000_config_fc_after_link_up(struct e1000_hw
*hw
)
1685 uint16_t mii_status_reg
;
1686 uint16_t mii_nway_adv_reg
;
1687 uint16_t mii_nway_lp_ability_reg
;
1693 /* Check for the case where we have fiber media and auto-neg failed
1694 * so we had to force link. In this case, we need to force the
1695 * configuration of the MAC to match the "fc" parameter.
1697 if ((hw
->media_type
== e1000_media_type_fiber
) && (hw
->autoneg_failed
)) {
1698 ret_val
= e1000_force_mac_fc(hw
);
1700 DEBUGOUT("Error forcing flow control settings\n");
1705 /* Check for the case where we have copper media and auto-neg is
1706 * enabled. In this case, we need to check and see if Auto-Neg
1707 * has completed, and if so, how the PHY and link partner has
1708 * flow control configured.
1710 if (hw
->media_type
== e1000_media_type_copper
) {
1711 /* Read the MII Status Register and check to see if AutoNeg
1712 * has completed. We read this twice because this reg has
1713 * some "sticky" (latched) bits.
1715 if (e1000_read_phy_reg(hw
, PHY_STATUS
, &mii_status_reg
) < 0) {
1716 DEBUGOUT("PHY Read Error \n");
1717 return -E1000_ERR_PHY
;
1719 if (e1000_read_phy_reg(hw
, PHY_STATUS
, &mii_status_reg
) < 0) {
1720 DEBUGOUT("PHY Read Error \n");
1721 return -E1000_ERR_PHY
;
1724 if (mii_status_reg
& MII_SR_AUTONEG_COMPLETE
) {
1725 /* The AutoNeg process has completed, so we now need to
1726 * read both the Auto Negotiation Advertisement Register
1727 * (Address 4) and the Auto_Negotiation Base Page Ability
1728 * Register (Address 5) to determine how flow control was
1731 if (e1000_read_phy_reg
1732 (hw
, PHY_AUTONEG_ADV
, &mii_nway_adv_reg
) < 0) {
1733 DEBUGOUT("PHY Read Error\n");
1734 return -E1000_ERR_PHY
;
1736 if (e1000_read_phy_reg
1737 (hw
, PHY_LP_ABILITY
,
1738 &mii_nway_lp_ability_reg
) < 0) {
1739 DEBUGOUT("PHY Read Error\n");
1740 return -E1000_ERR_PHY
;
1743 /* Two bits in the Auto Negotiation Advertisement Register
1744 * (Address 4) and two bits in the Auto Negotiation Base
1745 * Page Ability Register (Address 5) determine flow control
1746 * for both the PHY and the link partner. The following
1747 * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,
1748 * 1999, describes these PAUSE resolution bits and how flow
1749 * control is determined based upon these settings.
1750 * NOTE: DC = Don't Care
1752 * LOCAL DEVICE | LINK PARTNER
1753 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution
1754 *-------|---------|-------|---------|--------------------
1755 * 0 | 0 | DC | DC | e1000_fc_none
1756 * 0 | 1 | 0 | DC | e1000_fc_none
1757 * 0 | 1 | 1 | 0 | e1000_fc_none
1758 * 0 | 1 | 1 | 1 | e1000_fc_tx_pause
1759 * 1 | 0 | 0 | DC | e1000_fc_none
1760 * 1 | DC | 1 | DC | e1000_fc_full
1761 * 1 | 1 | 0 | 0 | e1000_fc_none
1762 * 1 | 1 | 0 | 1 | e1000_fc_rx_pause
1765 /* Are both PAUSE bits set to 1? If so, this implies
1766 * Symmetric Flow Control is enabled at both ends. The
1767 * ASM_DIR bits are irrelevant per the spec.
1769 * For Symmetric Flow Control:
1771 * LOCAL DEVICE | LINK PARTNER
1772 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1773 *-------|---------|-------|---------|--------------------
1774 * 1 | DC | 1 | DC | e1000_fc_full
1777 if ((mii_nway_adv_reg
& NWAY_AR_PAUSE
) &&
1778 (mii_nway_lp_ability_reg
& NWAY_LPAR_PAUSE
)) {
1779 /* Now we need to check if the user selected RX ONLY
1780 * of pause frames. In this case, we had to advertise
1781 * FULL flow control because we could not advertise RX
1782 * ONLY. Hence, we must now check to see if we need to
1783 * turn OFF the TRANSMISSION of PAUSE frames.
1785 if (hw
->original_fc
== e1000_fc_full
) {
1786 hw
->fc
= e1000_fc_full
;
1787 DEBUGOUT("Flow Control = FULL.\r\n");
1789 hw
->fc
= e1000_fc_rx_pause
;
1791 ("Flow Control = RX PAUSE frames only.\r\n");
1794 /* For receiving PAUSE frames ONLY.
1796 * LOCAL DEVICE | LINK PARTNER
1797 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1798 *-------|---------|-------|---------|--------------------
1799 * 0 | 1 | 1 | 1 | e1000_fc_tx_pause
1802 else if (!(mii_nway_adv_reg
& NWAY_AR_PAUSE
) &&
1803 (mii_nway_adv_reg
& NWAY_AR_ASM_DIR
) &&
1804 (mii_nway_lp_ability_reg
& NWAY_LPAR_PAUSE
) &&
1805 (mii_nway_lp_ability_reg
& NWAY_LPAR_ASM_DIR
))
1807 hw
->fc
= e1000_fc_tx_pause
;
1809 ("Flow Control = TX PAUSE frames only.\r\n");
1811 /* For transmitting PAUSE frames ONLY.
1813 * LOCAL DEVICE | LINK PARTNER
1814 * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result
1815 *-------|---------|-------|---------|--------------------
1816 * 1 | 1 | 0 | 1 | e1000_fc_rx_pause
1819 else if ((mii_nway_adv_reg
& NWAY_AR_PAUSE
) &&
1820 (mii_nway_adv_reg
& NWAY_AR_ASM_DIR
) &&
1821 !(mii_nway_lp_ability_reg
& NWAY_LPAR_PAUSE
) &&
1822 (mii_nway_lp_ability_reg
& NWAY_LPAR_ASM_DIR
))
1824 hw
->fc
= e1000_fc_rx_pause
;
1826 ("Flow Control = RX PAUSE frames only.\r\n");
1828 /* Per the IEEE spec, at this point flow control should be
1829 * disabled. However, we want to consider that we could
1830 * be connected to a legacy switch that doesn't advertise
1831 * desired flow control, but can be forced on the link
1832 * partner. So if we advertised no flow control, that is
1833 * what we will resolve to. If we advertised some kind of
1834 * receive capability (Rx Pause Only or Full Flow Control)
1835 * and the link partner advertised none, we will configure
1836 * ourselves to enable Rx Flow Control only. We can do
1837 * this safely for two reasons: If the link partner really
1838 * didn't want flow control enabled, and we enable Rx, no
1839 * harm done since we won't be receiving any PAUSE frames
1840 * anyway. If the intent on the link partner was to have
1841 * flow control enabled, then by us enabling RX only, we
1842 * can at least receive pause frames and process them.
1843 * This is a good idea because in most cases, since we are
1844 * predominantly a server NIC, more times than not we will
1845 * be asked to delay transmission of packets than asking
1846 * our link partner to pause transmission of frames.
1848 else if (hw
->original_fc
== e1000_fc_none
||
1849 hw
->original_fc
== e1000_fc_tx_pause
) {
1850 hw
->fc
= e1000_fc_none
;
1851 DEBUGOUT("Flow Control = NONE.\r\n");
1853 hw
->fc
= e1000_fc_rx_pause
;
1855 ("Flow Control = RX PAUSE frames only.\r\n");
1858 /* Now we need to do one last check... If we auto-
1859 * negotiated to HALF DUPLEX, flow control should not be
1860 * enabled per IEEE 802.3 spec.
1862 e1000_get_speed_and_duplex(hw
, &speed
, &duplex
);
1864 if (duplex
== HALF_DUPLEX
)
1865 hw
->fc
= e1000_fc_none
;
1867 /* Now we call a subroutine to actually force the MAC
1868 * controller to use the correct flow control settings.
1870 ret_val
= e1000_force_mac_fc(hw
);
1873 ("Error forcing flow control settings\n");
1878 ("Copper PHY and Auto Neg has not completed.\r\n");
1884 /******************************************************************************
1885 * Checks to see if the link status of the hardware has changed.
1887 * hw - Struct containing variables accessed by shared code
1889 * Called by any function that needs to check the link status of the adapter.
1890 *****************************************************************************/
1892 e1000_check_for_link(struct eth_device
*nic
)
1894 struct e1000_hw
*hw
= nic
->priv
;
1902 uint16_t lp_capability
;
1906 /* On adapters with a MAC newer that 82544, SW Defineable pin 1 will be
1907 * set when the optics detect a signal. On older adapters, it will be
1908 * cleared when there is a signal
1910 ctrl
= E1000_READ_REG(hw
, CTRL
);
1911 if ((hw
->mac_type
> e1000_82544
) && !(ctrl
& E1000_CTRL_ILOS
))
1912 signal
= E1000_CTRL_SWDPIN1
;
1916 status
= E1000_READ_REG(hw
, STATUS
);
1917 rxcw
= E1000_READ_REG(hw
, RXCW
);
1918 DEBUGOUT("ctrl: %#08x status %#08x rxcw %#08x\n", ctrl
, status
, rxcw
);
1920 /* If we have a copper PHY then we only want to go out to the PHY
1921 * registers to see if Auto-Neg has completed and/or if our link
1922 * status has changed. The get_link_status flag will be set if we
1923 * receive a Link Status Change interrupt or we have Rx Sequence
1926 if ((hw
->media_type
== e1000_media_type_copper
) && hw
->get_link_status
) {
1927 /* First we want to see if the MII Status Register reports
1928 * link. If so, then we want to get the current speed/duplex
1930 * Read the register twice since the link bit is sticky.
1932 if (e1000_read_phy_reg(hw
, PHY_STATUS
, &phy_data
) < 0) {
1933 DEBUGOUT("PHY Read Error\n");
1934 return -E1000_ERR_PHY
;
1936 if (e1000_read_phy_reg(hw
, PHY_STATUS
, &phy_data
) < 0) {
1937 DEBUGOUT("PHY Read Error\n");
1938 return -E1000_ERR_PHY
;
1941 if (phy_data
& MII_SR_LINK_STATUS
) {
1942 hw
->get_link_status
= FALSE
;
1944 /* No link detected */
1945 return -E1000_ERR_NOLINK
;
1948 /* We have a M88E1000 PHY and Auto-Neg is enabled. If we
1949 * have Si on board that is 82544 or newer, Auto
1950 * Speed Detection takes care of MAC speed/duplex
1951 * configuration. So we only need to configure Collision
1952 * Distance in the MAC. Otherwise, we need to force
1953 * speed/duplex on the MAC to the current PHY speed/duplex
1956 if (hw
->mac_type
>= e1000_82544
)
1957 e1000_config_collision_dist(hw
);
1959 ret_val
= e1000_config_mac_to_phy(hw
);
1962 ("Error configuring MAC to PHY settings\n");
1967 /* Configure Flow Control now that Auto-Neg has completed. First, we
1968 * need to restore the desired flow control settings because we may
1969 * have had to re-autoneg with a different link partner.
1971 ret_val
= e1000_config_fc_after_link_up(hw
);
1973 DEBUGOUT("Error configuring flow control\n");
1977 /* At this point we know that we are on copper and we have
1978 * auto-negotiated link. These are conditions for checking the link
1979 * parter capability register. We use the link partner capability to
1980 * determine if TBI Compatibility needs to be turned on or off. If
1981 * the link partner advertises any speed in addition to Gigabit, then
1982 * we assume that they are GMII-based, and TBI compatibility is not
1983 * needed. If no other speeds are advertised, we assume the link
1984 * partner is TBI-based, and we turn on TBI Compatibility.
1986 if (hw
->tbi_compatibility_en
) {
1987 if (e1000_read_phy_reg
1988 (hw
, PHY_LP_ABILITY
, &lp_capability
) < 0) {
1989 DEBUGOUT("PHY Read Error\n");
1990 return -E1000_ERR_PHY
;
1992 if (lp_capability
& (NWAY_LPAR_10T_HD_CAPS
|
1993 NWAY_LPAR_10T_FD_CAPS
|
1994 NWAY_LPAR_100TX_HD_CAPS
|
1995 NWAY_LPAR_100TX_FD_CAPS
|
1996 NWAY_LPAR_100T4_CAPS
)) {
1997 /* If our link partner advertises anything in addition to
1998 * gigabit, we do not need to enable TBI compatibility.
2000 if (hw
->tbi_compatibility_on
) {
2001 /* If we previously were in the mode, turn it off. */
2002 rctl
= E1000_READ_REG(hw
, RCTL
);
2003 rctl
&= ~E1000_RCTL_SBP
;
2004 E1000_WRITE_REG(hw
, RCTL
, rctl
);
2005 hw
->tbi_compatibility_on
= FALSE
;
2008 /* If TBI compatibility is was previously off, turn it on. For
2009 * compatibility with a TBI link partner, we will store bad
2010 * packets. Some frames have an additional byte on the end and
2011 * will look like CRC errors to to the hardware.
2013 if (!hw
->tbi_compatibility_on
) {
2014 hw
->tbi_compatibility_on
= TRUE
;
2015 rctl
= E1000_READ_REG(hw
, RCTL
);
2016 rctl
|= E1000_RCTL_SBP
;
2017 E1000_WRITE_REG(hw
, RCTL
, rctl
);
2022 /* If we don't have link (auto-negotiation failed or link partner cannot
2023 * auto-negotiate), the cable is plugged in (we have signal), and our
2024 * link partner is not trying to auto-negotiate with us (we are receiving
2025 * idles or data), we need to force link up. We also need to give
2026 * auto-negotiation time to complete, in case the cable was just plugged
2027 * in. The autoneg_failed flag does this.
2029 else if ((hw
->media_type
== e1000_media_type_fiber
) &&
2030 (!(status
& E1000_STATUS_LU
)) &&
2031 ((ctrl
& E1000_CTRL_SWDPIN1
) == signal
) &&
2032 (!(rxcw
& E1000_RXCW_C
))) {
2033 if (hw
->autoneg_failed
== 0) {
2034 hw
->autoneg_failed
= 1;
2037 DEBUGOUT("NOT RXing /C/, disable AutoNeg and force link.\r\n");
2039 /* Disable auto-negotiation in the TXCW register */
2040 E1000_WRITE_REG(hw
, TXCW
, (hw
->txcw
& ~E1000_TXCW_ANE
));
2042 /* Force link-up and also force full-duplex. */
2043 ctrl
= E1000_READ_REG(hw
, CTRL
);
2044 ctrl
|= (E1000_CTRL_SLU
| E1000_CTRL_FD
);
2045 E1000_WRITE_REG(hw
, CTRL
, ctrl
);
2047 /* Configure Flow Control after forcing link up. */
2048 ret_val
= e1000_config_fc_after_link_up(hw
);
2050 DEBUGOUT("Error configuring flow control\n");
2054 /* If we are forcing link and we are receiving /C/ ordered sets, re-enable
2055 * auto-negotiation in the TXCW register and disable forced link in the
2056 * Device Control register in an attempt to auto-negotiate with our link
2059 else if ((hw
->media_type
== e1000_media_type_fiber
) &&
2060 (ctrl
& E1000_CTRL_SLU
) && (rxcw
& E1000_RXCW_C
)) {
2062 ("RXing /C/, enable AutoNeg and stop forcing link.\r\n");
2063 E1000_WRITE_REG(hw
, TXCW
, hw
->txcw
);
2064 E1000_WRITE_REG(hw
, CTRL
, (ctrl
& ~E1000_CTRL_SLU
));
2069 /******************************************************************************
2070 * Detects the current speed and duplex settings of the hardware.
2072 * hw - Struct containing variables accessed by shared code
2073 * speed - Speed of the connection
2074 * duplex - Duplex setting of the connection
2075 *****************************************************************************/
2077 e1000_get_speed_and_duplex(struct e1000_hw
*hw
,
2078 uint16_t * speed
, uint16_t * duplex
)
2084 if (hw
->mac_type
>= e1000_82543
) {
2085 status
= E1000_READ_REG(hw
, STATUS
);
2086 if (status
& E1000_STATUS_SPEED_1000
) {
2087 *speed
= SPEED_1000
;
2088 DEBUGOUT("1000 Mbs, ");
2089 } else if (status
& E1000_STATUS_SPEED_100
) {
2091 DEBUGOUT("100 Mbs, ");
2094 DEBUGOUT("10 Mbs, ");
2097 if (status
& E1000_STATUS_FD
) {
2098 *duplex
= FULL_DUPLEX
;
2099 DEBUGOUT("Full Duplex\r\n");
2101 *duplex
= HALF_DUPLEX
;
2102 DEBUGOUT(" Half Duplex\r\n");
2105 DEBUGOUT("1000 Mbs, Full Duplex\r\n");
2106 *speed
= SPEED_1000
;
2107 *duplex
= FULL_DUPLEX
;
2111 /******************************************************************************
2112 * Blocks until autoneg completes or times out (~4.5 seconds)
2114 * hw - Struct containing variables accessed by shared code
2115 ******************************************************************************/
2117 e1000_wait_autoneg(struct e1000_hw
*hw
)
2123 DEBUGOUT("Waiting for Auto-Neg to complete.\n");
2125 /* We will wait for autoneg to complete or 4.5 seconds to expire. */
2126 for (i
= PHY_AUTO_NEG_TIME
; i
> 0; i
--) {
2127 /* Read the MII Status Register and wait for Auto-Neg
2128 * Complete bit to be set.
2130 if (e1000_read_phy_reg(hw
, PHY_STATUS
, &phy_data
) < 0) {
2131 DEBUGOUT("PHY Read Error\n");
2132 return -E1000_ERR_PHY
;
2134 if (e1000_read_phy_reg(hw
, PHY_STATUS
, &phy_data
) < 0) {
2135 DEBUGOUT("PHY Read Error\n");
2136 return -E1000_ERR_PHY
;
2138 if (phy_data
& MII_SR_AUTONEG_COMPLETE
) {
2139 DEBUGOUT("Auto-Neg complete.\n");
2144 DEBUGOUT("Auto-Neg timedout.\n");
2145 return -E1000_ERR_TIMEOUT
;
2148 /******************************************************************************
2149 * Raises the Management Data Clock
2151 * hw - Struct containing variables accessed by shared code
2152 * ctrl - Device control register's current value
2153 ******************************************************************************/
2155 e1000_raise_mdi_clk(struct e1000_hw
*hw
, uint32_t * ctrl
)
2157 /* Raise the clock input to the Management Data Clock (by setting the MDC
2158 * bit), and then delay 2 microseconds.
2160 E1000_WRITE_REG(hw
, CTRL
, (*ctrl
| E1000_CTRL_MDC
));
2161 E1000_WRITE_FLUSH(hw
);
2165 /******************************************************************************
2166 * Lowers the Management Data Clock
2168 * hw - Struct containing variables accessed by shared code
2169 * ctrl - Device control register's current value
2170 ******************************************************************************/
2172 e1000_lower_mdi_clk(struct e1000_hw
*hw
, uint32_t * ctrl
)
2174 /* Lower the clock input to the Management Data Clock (by clearing the MDC
2175 * bit), and then delay 2 microseconds.
2177 E1000_WRITE_REG(hw
, CTRL
, (*ctrl
& ~E1000_CTRL_MDC
));
2178 E1000_WRITE_FLUSH(hw
);
2182 /******************************************************************************
2183 * Shifts data bits out to the PHY
2185 * hw - Struct containing variables accessed by shared code
2186 * data - Data to send out to the PHY
2187 * count - Number of bits to shift out
2189 * Bits are shifted out in MSB to LSB order.
2190 ******************************************************************************/
2192 e1000_shift_out_mdi_bits(struct e1000_hw
*hw
, uint32_t data
, uint16_t count
)
2197 /* We need to shift "count" number of bits out to the PHY. So, the value
2198 * in the "data" parameter will be shifted out to the PHY one bit at a
2199 * time. In order to do this, "data" must be broken down into bits.
2202 mask
<<= (count
- 1);
2204 ctrl
= E1000_READ_REG(hw
, CTRL
);
2206 /* Set MDIO_DIR and MDC_DIR direction bits to be used as output pins. */
2207 ctrl
|= (E1000_CTRL_MDIO_DIR
| E1000_CTRL_MDC_DIR
);
2210 /* A "1" is shifted out to the PHY by setting the MDIO bit to "1" and
2211 * then raising and lowering the Management Data Clock. A "0" is
2212 * shifted out to the PHY by setting the MDIO bit to "0" and then
2213 * raising and lowering the clock.
2216 ctrl
|= E1000_CTRL_MDIO
;
2218 ctrl
&= ~E1000_CTRL_MDIO
;
2220 E1000_WRITE_REG(hw
, CTRL
, ctrl
);
2221 E1000_WRITE_FLUSH(hw
);
2225 e1000_raise_mdi_clk(hw
, &ctrl
);
2226 e1000_lower_mdi_clk(hw
, &ctrl
);
2232 /******************************************************************************
2233 * Shifts data bits in from the PHY
2235 * hw - Struct containing variables accessed by shared code
2237 * Bits are shifted in in MSB to LSB order.
2238 ******************************************************************************/
2240 e1000_shift_in_mdi_bits(struct e1000_hw
*hw
)
2246 /* In order to read a register from the PHY, we need to shift in a total
2247 * of 18 bits from the PHY. The first two bit (turnaround) times are used
2248 * to avoid contention on the MDIO pin when a read operation is performed.
2249 * These two bits are ignored by us and thrown away. Bits are "shifted in"
2250 * by raising the input to the Management Data Clock (setting the MDC bit),
2251 * and then reading the value of the MDIO bit.
2253 ctrl
= E1000_READ_REG(hw
, CTRL
);
2255 /* Clear MDIO_DIR (SWDPIO1) to indicate this bit is to be used as input. */
2256 ctrl
&= ~E1000_CTRL_MDIO_DIR
;
2257 ctrl
&= ~E1000_CTRL_MDIO
;
2259 E1000_WRITE_REG(hw
, CTRL
, ctrl
);
2260 E1000_WRITE_FLUSH(hw
);
2262 /* Raise and Lower the clock before reading in the data. This accounts for
2263 * the turnaround bits. The first clock occurred when we clocked out the
2264 * last bit of the Register Address.
2266 e1000_raise_mdi_clk(hw
, &ctrl
);
2267 e1000_lower_mdi_clk(hw
, &ctrl
);
2269 for (data
= 0, i
= 0; i
< 16; i
++) {
2271 e1000_raise_mdi_clk(hw
, &ctrl
);
2272 ctrl
= E1000_READ_REG(hw
, CTRL
);
2273 /* Check to see if we shifted in a "1". */
2274 if (ctrl
& E1000_CTRL_MDIO
)
2276 e1000_lower_mdi_clk(hw
, &ctrl
);
2279 e1000_raise_mdi_clk(hw
, &ctrl
);
2280 e1000_lower_mdi_clk(hw
, &ctrl
);
2285 /*****************************************************************************
2286 * Reads the value from a PHY register
2288 * hw - Struct containing variables accessed by shared code
2289 * reg_addr - address of the PHY register to read
2290 ******************************************************************************/
2292 e1000_read_phy_reg(struct e1000_hw
*hw
, uint32_t reg_addr
, uint16_t * phy_data
)
2296 const uint32_t phy_addr
= 1;
2298 if (reg_addr
> MAX_PHY_REG_ADDRESS
) {
2299 DEBUGOUT("PHY Address %d is out of range\n", reg_addr
);
2300 return -E1000_ERR_PARAM
;
2303 if (hw
->mac_type
> e1000_82543
) {
2304 /* Set up Op-code, Phy Address, and register address in the MDI
2305 * Control register. The MAC will take care of interfacing with the
2306 * PHY to retrieve the desired data.
2308 mdic
= ((reg_addr
<< E1000_MDIC_REG_SHIFT
) |
2309 (phy_addr
<< E1000_MDIC_PHY_SHIFT
) |
2310 (E1000_MDIC_OP_READ
));
2312 E1000_WRITE_REG(hw
, MDIC
, mdic
);
2314 /* Poll the ready bit to see if the MDI read completed */
2315 for (i
= 0; i
< 64; i
++) {
2317 mdic
= E1000_READ_REG(hw
, MDIC
);
2318 if (mdic
& E1000_MDIC_READY
)
2321 if (!(mdic
& E1000_MDIC_READY
)) {
2322 DEBUGOUT("MDI Read did not complete\n");
2323 return -E1000_ERR_PHY
;
2325 if (mdic
& E1000_MDIC_ERROR
) {
2326 DEBUGOUT("MDI Error\n");
2327 return -E1000_ERR_PHY
;
2329 *phy_data
= (uint16_t) mdic
;
2331 /* We must first send a preamble through the MDIO pin to signal the
2332 * beginning of an MII instruction. This is done by sending 32
2333 * consecutive "1" bits.
2335 e1000_shift_out_mdi_bits(hw
, PHY_PREAMBLE
, PHY_PREAMBLE_SIZE
);
2337 /* Now combine the next few fields that are required for a read
2338 * operation. We use this method instead of calling the
2339 * e1000_shift_out_mdi_bits routine five different times. The format of
2340 * a MII read instruction consists of a shift out of 14 bits and is
2341 * defined as follows:
2342 * <Preamble><SOF><Op Code><Phy Addr><Reg Addr>
2343 * followed by a shift in of 18 bits. This first two bits shifted in
2344 * are TurnAround bits used to avoid contention on the MDIO pin when a
2345 * READ operation is performed. These two bits are thrown away
2346 * followed by a shift in of 16 bits which contains the desired data.
2348 mdic
= ((reg_addr
) | (phy_addr
<< 5) |
2349 (PHY_OP_READ
<< 10) | (PHY_SOF
<< 12));
2351 e1000_shift_out_mdi_bits(hw
, mdic
, 14);
2353 /* Now that we've shifted out the read command to the MII, we need to
2354 * "shift in" the 16-bit value (18 total bits) of the requested PHY
2357 *phy_data
= e1000_shift_in_mdi_bits(hw
);
2362 /******************************************************************************
2363 * Writes a value to a PHY register
2365 * hw - Struct containing variables accessed by shared code
2366 * reg_addr - address of the PHY register to write
2367 * data - data to write to the PHY
2368 ******************************************************************************/
2370 e1000_write_phy_reg(struct e1000_hw
*hw
, uint32_t reg_addr
, uint16_t phy_data
)
2374 const uint32_t phy_addr
= 1;
2376 if (reg_addr
> MAX_PHY_REG_ADDRESS
) {
2377 DEBUGOUT("PHY Address %d is out of range\n", reg_addr
);
2378 return -E1000_ERR_PARAM
;
2381 if (hw
->mac_type
> e1000_82543
) {
2382 /* Set up Op-code, Phy Address, register address, and data intended
2383 * for the PHY register in the MDI Control register. The MAC will take
2384 * care of interfacing with the PHY to send the desired data.
2386 mdic
= (((uint32_t) phy_data
) |
2387 (reg_addr
<< E1000_MDIC_REG_SHIFT
) |
2388 (phy_addr
<< E1000_MDIC_PHY_SHIFT
) |
2389 (E1000_MDIC_OP_WRITE
));
2391 E1000_WRITE_REG(hw
, MDIC
, mdic
);
2393 /* Poll the ready bit to see if the MDI read completed */
2394 for (i
= 0; i
< 64; i
++) {
2396 mdic
= E1000_READ_REG(hw
, MDIC
);
2397 if (mdic
& E1000_MDIC_READY
)
2400 if (!(mdic
& E1000_MDIC_READY
)) {
2401 DEBUGOUT("MDI Write did not complete\n");
2402 return -E1000_ERR_PHY
;
2405 /* We'll need to use the SW defined pins to shift the write command
2406 * out to the PHY. We first send a preamble to the PHY to signal the
2407 * beginning of the MII instruction. This is done by sending 32
2408 * consecutive "1" bits.
2410 e1000_shift_out_mdi_bits(hw
, PHY_PREAMBLE
, PHY_PREAMBLE_SIZE
);
2412 /* Now combine the remaining required fields that will indicate a
2413 * write operation. We use this method instead of calling the
2414 * e1000_shift_out_mdi_bits routine for each field in the command. The
2415 * format of a MII write instruction is as follows:
2416 * <Preamble><SOF><Op Code><Phy Addr><Reg Addr><Turnaround><Data>.
2418 mdic
= ((PHY_TURNAROUND
) | (reg_addr
<< 2) | (phy_addr
<< 7) |
2419 (PHY_OP_WRITE
<< 12) | (PHY_SOF
<< 14));
2421 mdic
|= (uint32_t) phy_data
;
2423 e1000_shift_out_mdi_bits(hw
, mdic
, 32);
2428 /******************************************************************************
2429 * Returns the PHY to the power-on reset state
2431 * hw - Struct containing variables accessed by shared code
2432 ******************************************************************************/
2434 e1000_phy_hw_reset(struct e1000_hw
*hw
)
2441 DEBUGOUT("Resetting Phy...\n");
2443 if (hw
->mac_type
> e1000_82543
) {
2444 /* Read the device control register and assert the E1000_CTRL_PHY_RST
2445 * bit. Then, take it out of reset.
2447 ctrl
= E1000_READ_REG(hw
, CTRL
);
2448 E1000_WRITE_REG(hw
, CTRL
, ctrl
| E1000_CTRL_PHY_RST
);
2449 E1000_WRITE_FLUSH(hw
);
2451 E1000_WRITE_REG(hw
, CTRL
, ctrl
);
2452 E1000_WRITE_FLUSH(hw
);
2454 /* Read the Extended Device Control Register, assert the PHY_RESET_DIR
2455 * bit to put the PHY into reset. Then, take it out of reset.
2457 ctrl_ext
= E1000_READ_REG(hw
, CTRL_EXT
);
2458 ctrl_ext
|= E1000_CTRL_EXT_SDP4_DIR
;
2459 ctrl_ext
&= ~E1000_CTRL_EXT_SDP4_DATA
;
2460 E1000_WRITE_REG(hw
, CTRL_EXT
, ctrl_ext
);
2461 E1000_WRITE_FLUSH(hw
);
2463 ctrl_ext
|= E1000_CTRL_EXT_SDP4_DATA
;
2464 E1000_WRITE_REG(hw
, CTRL_EXT
, ctrl_ext
);
2465 E1000_WRITE_FLUSH(hw
);
2470 /******************************************************************************
2473 * hw - Struct containing variables accessed by shared code
2475 * Sets bit 15 of the MII Control regiser
2476 ******************************************************************************/
2478 e1000_phy_reset(struct e1000_hw
*hw
)
2484 if (e1000_read_phy_reg(hw
, PHY_CTRL
, &phy_data
) < 0) {
2485 DEBUGOUT("PHY Read Error\n");
2486 return -E1000_ERR_PHY
;
2488 phy_data
|= MII_CR_RESET
;
2489 if (e1000_write_phy_reg(hw
, PHY_CTRL
, phy_data
) < 0) {
2490 DEBUGOUT("PHY Write Error\n");
2491 return -E1000_ERR_PHY
;
2498 e1000_set_phy_type(struct e1000_hw
*hw
)
2502 if(hw
->mac_type
== e1000_undefined
)
2503 return -E1000_ERR_PHY_TYPE
;
2505 switch(hw
->phy_id
) {
2506 case M88E1000_E_PHY_ID
:
2507 case M88E1000_I_PHY_ID
:
2508 case M88E1011_I_PHY_ID
:
2509 hw
->phy_type
= e1000_phy_m88
;
2511 case IGP01E1000_I_PHY_ID
:
2512 if(hw
->mac_type
== e1000_82541
||
2513 hw
->mac_type
== e1000_82541_rev_2
) {
2514 hw
->phy_type
= e1000_phy_igp
;
2519 /* Should never have loaded on this device */
2520 hw
->phy_type
= e1000_phy_undefined
;
2521 return -E1000_ERR_PHY_TYPE
;
2524 return E1000_SUCCESS
;
2527 /******************************************************************************
2528 * Probes the expected PHY address for known PHY IDs
2530 * hw - Struct containing variables accessed by shared code
2531 ******************************************************************************/
2533 e1000_detect_gig_phy(struct e1000_hw
*hw
)
2535 int32_t phy_init_status
;
2536 uint16_t phy_id_high
, phy_id_low
;
2541 /* Read the PHY ID Registers to identify which PHY is onboard. */
2542 if (e1000_read_phy_reg(hw
, PHY_ID1
, &phy_id_high
) < 0) {
2543 DEBUGOUT("PHY Read Error\n");
2544 return -E1000_ERR_PHY
;
2546 hw
->phy_id
= (uint32_t) (phy_id_high
<< 16);
2548 if (e1000_read_phy_reg(hw
, PHY_ID2
, &phy_id_low
) < 0) {
2549 DEBUGOUT("PHY Read Error\n");
2550 return -E1000_ERR_PHY
;
2552 hw
->phy_id
|= (uint32_t) (phy_id_low
& PHY_REVISION_MASK
);
2554 switch (hw
->mac_type
) {
2556 if (hw
->phy_id
== M88E1000_E_PHY_ID
)
2560 if (hw
->phy_id
== M88E1000_I_PHY_ID
)
2566 if (hw
->phy_id
== M88E1011_I_PHY_ID
)
2569 case e1000_82541_rev_2
:
2570 if(hw
->phy_id
== IGP01E1000_I_PHY_ID
)
2575 DEBUGOUT("Invalid MAC type %d\n", hw
->mac_type
);
2576 return -E1000_ERR_CONFIG
;
2579 phy_init_status
= e1000_set_phy_type(hw
);
2581 if ((match
) && (phy_init_status
== E1000_SUCCESS
)) {
2582 DEBUGOUT("PHY ID 0x%X detected\n", hw
->phy_id
);
2585 DEBUGOUT("Invalid PHY ID 0x%X\n", hw
->phy_id
);
2586 return -E1000_ERR_PHY
;
2590 * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
2592 * e1000_sw_init initializes the Adapter private data structure.
2593 * Fields are initialized based on PCI device information and
2594 * OS network device settings (MTU size).
2598 e1000_sw_init(struct eth_device
*nic
, int cardnum
)
2600 struct e1000_hw
*hw
= (typeof(hw
)) nic
->priv
;
2603 /* PCI config space info */
2604 pci_read_config_word(hw
->pdev
, PCI_VENDOR_ID
, &hw
->vendor_id
);
2605 pci_read_config_word(hw
->pdev
, PCI_DEVICE_ID
, &hw
->device_id
);
2606 pci_read_config_word(hw
->pdev
, PCI_SUBSYSTEM_VENDOR_ID
,
2607 &hw
->subsystem_vendor_id
);
2608 pci_read_config_word(hw
->pdev
, PCI_SUBSYSTEM_ID
, &hw
->subsystem_id
);
2610 pci_read_config_byte(hw
->pdev
, PCI_REVISION_ID
, &hw
->revision_id
);
2611 pci_read_config_word(hw
->pdev
, PCI_COMMAND
, &hw
->pci_cmd_word
);
2613 /* identify the MAC */
2614 result
= e1000_set_mac_type(hw
);
2616 E1000_ERR("Unknown MAC Type\n");
2620 /* lan a vs. lan b settings */
2621 if (hw
->mac_type
== e1000_82546
)
2622 /*this also works w/ multiple 82546 cards */
2623 /*but not if they're intermingled /w other e1000s */
2624 hw
->lan_loc
= (cardnum
% 2) ? e1000_lan_b
: e1000_lan_a
;
2626 hw
->lan_loc
= e1000_lan_a
;
2628 /* flow control settings */
2629 hw
->fc_high_water
= E1000_FC_HIGH_THRESH
;
2630 hw
->fc_low_water
= E1000_FC_LOW_THRESH
;
2631 hw
->fc_pause_time
= E1000_FC_PAUSE_TIME
;
2632 hw
->fc_send_xon
= 1;
2634 /* Media type - copper or fiber */
2636 if (hw
->mac_type
>= e1000_82543
) {
2637 uint32_t status
= E1000_READ_REG(hw
, STATUS
);
2639 if (status
& E1000_STATUS_TBIMODE
) {
2640 DEBUGOUT("fiber interface\n");
2641 hw
->media_type
= e1000_media_type_fiber
;
2643 DEBUGOUT("copper interface\n");
2644 hw
->media_type
= e1000_media_type_copper
;
2647 hw
->media_type
= e1000_media_type_fiber
;
2650 if (hw
->mac_type
< e1000_82543
)
2651 hw
->report_tx_early
= 0;
2653 hw
->report_tx_early
= 1;
2655 hw
->tbi_compatibility_en
= TRUE
;
2657 hw
->wait_autoneg_complete
= FALSE
;
2658 hw
->adaptive_ifs
= TRUE
;
2660 /* Copper options */
2661 if (hw
->media_type
== e1000_media_type_copper
) {
2662 hw
->mdix
= AUTO_ALL_MODES
;
2663 hw
->disable_polarity_correction
= FALSE
;
2666 return E1000_SUCCESS
;
2670 fill_rx(struct e1000_hw
*hw
)
2672 struct e1000_rx_desc
*rd
;
2675 rd
= rx_base
+ rx_tail
;
2676 rx_tail
= (rx_tail
+ 1) % 8;
2678 rd
->buffer_addr
= cpu_to_le64((u32
) & packet
);
2679 E1000_WRITE_REG(hw
, RDT
, rx_tail
);
2683 * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
2684 * @adapter: board private structure
2686 * Configure the Tx unit of the MAC after a reset.
2690 e1000_configure_tx(struct e1000_hw
*hw
)
2696 ptr
= (u32
) tx_pool
;
2698 ptr
= (ptr
+ 0x10) & (~0xf);
2700 tx_base
= (typeof(tx_base
)) ptr
;
2702 E1000_WRITE_REG(hw
, TDBAL
, (u32
) tx_base
);
2703 E1000_WRITE_REG(hw
, TDBAH
, 0);
2705 E1000_WRITE_REG(hw
, TDLEN
, 128);
2707 /* Setup the HW Tx Head and Tail descriptor pointers */
2708 E1000_WRITE_REG(hw
, TDH
, 0);
2709 E1000_WRITE_REG(hw
, TDT
, 0);
2712 /* Set the default values for the Tx Inter Packet Gap timer */
2713 switch (hw
->mac_type
) {
2714 case e1000_82542_rev2_0
:
2715 case e1000_82542_rev2_1
:
2716 tipg
= DEFAULT_82542_TIPG_IPGT
;
2717 tipg
|= DEFAULT_82542_TIPG_IPGR1
<< E1000_TIPG_IPGR1_SHIFT
;
2718 tipg
|= DEFAULT_82542_TIPG_IPGR2
<< E1000_TIPG_IPGR2_SHIFT
;
2721 if (hw
->media_type
== e1000_media_type_fiber
)
2722 tipg
= DEFAULT_82543_TIPG_IPGT_FIBER
;
2724 tipg
= DEFAULT_82543_TIPG_IPGT_COPPER
;
2725 tipg
|= DEFAULT_82543_TIPG_IPGR1
<< E1000_TIPG_IPGR1_SHIFT
;
2726 tipg
|= DEFAULT_82543_TIPG_IPGR2
<< E1000_TIPG_IPGR2_SHIFT
;
2728 E1000_WRITE_REG(hw
, TIPG
, tipg
);
2730 /* Set the Tx Interrupt Delay register */
2731 E1000_WRITE_REG(hw
, TIDV
, adapter
->tx_int_delay
);
2732 if (hw
->mac_type
>= e1000_82540
)
2733 E1000_WRITE_REG(hw
, TADV
, adapter
->tx_abs_int_delay
);
2735 /* Program the Transmit Control Register */
2736 tctl
= E1000_READ_REG(hw
, TCTL
);
2737 tctl
&= ~E1000_TCTL_CT
;
2738 tctl
|= E1000_TCTL_EN
| E1000_TCTL_PSP
|
2739 (E1000_COLLISION_THRESHOLD
<< E1000_CT_SHIFT
);
2740 E1000_WRITE_REG(hw
, TCTL
, tctl
);
2742 e1000_config_collision_dist(hw
);
2744 /* Setup Transmit Descriptor Settings for this adapter */
2745 adapter
->txd_cmd
= E1000_TXD_CMD_IFCS
| E1000_TXD_CMD_IDE
;
2747 if (adapter
->hw
.report_tx_early
== 1)
2748 adapter
->txd_cmd
|= E1000_TXD_CMD_RS
;
2750 adapter
->txd_cmd
|= E1000_TXD_CMD_RPS
;
2755 * e1000_setup_rctl - configure the receive control register
2756 * @adapter: Board private structure
2759 e1000_setup_rctl(struct e1000_hw
*hw
)
2763 rctl
= E1000_READ_REG(hw
, RCTL
);
2765 rctl
&= ~(3 << E1000_RCTL_MO_SHIFT
);
2767 rctl
|= E1000_RCTL_EN
| E1000_RCTL_BAM
| E1000_RCTL_LBM_NO
| E1000_RCTL_RDMTS_HALF
; /* |
2768 (hw.mc_filter_type << E1000_RCTL_MO_SHIFT); */
2770 if (hw
->tbi_compatibility_on
== 1)
2771 rctl
|= E1000_RCTL_SBP
;
2773 rctl
&= ~E1000_RCTL_SBP
;
2775 rctl
&= ~(E1000_RCTL_SZ_4096
);
2777 switch (adapter
->rx_buffer_len
) {
2778 case E1000_RXBUFFER_2048
:
2781 rctl
|= E1000_RCTL_SZ_2048
;
2782 rctl
&= ~(E1000_RCTL_BSEX
| E1000_RCTL_LPE
);
2785 case E1000_RXBUFFER_4096
:
2786 rctl
|= E1000_RCTL_SZ_4096
| E1000_RCTL_BSEX
| E1000_RCTL_LPE
;
2788 case E1000_RXBUFFER_8192
:
2789 rctl
|= E1000_RCTL_SZ_8192
| E1000_RCTL_BSEX
| E1000_RCTL_LPE
;
2791 case E1000_RXBUFFER_16384
:
2792 rctl
|= E1000_RCTL_SZ_16384
| E1000_RCTL_BSEX
| E1000_RCTL_LPE
;
2796 E1000_WRITE_REG(hw
, RCTL
, rctl
);
2800 * e1000_configure_rx - Configure 8254x Receive Unit after Reset
2801 * @adapter: board private structure
2803 * Configure the Rx unit of the MAC after a reset.
2806 e1000_configure_rx(struct e1000_hw
*hw
)
2811 unsigned long rxcsum
;
2814 /* make sure receives are disabled while setting up the descriptors */
2815 rctl
= E1000_READ_REG(hw
, RCTL
);
2816 E1000_WRITE_REG(hw
, RCTL
, rctl
& ~E1000_RCTL_EN
);
2818 /* set the Receive Delay Timer Register */
2820 E1000_WRITE_REG(hw
, RDTR
, adapter
->rx_int_delay
);
2822 if (hw
->mac_type
>= e1000_82540
) {
2824 E1000_WRITE_REG(hw
, RADV
, adapter
->rx_abs_int_delay
);
2826 /* Set the interrupt throttling rate. Value is calculated
2827 * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */
2828 #define MAX_INTS_PER_SEC 8000
2829 #define DEFAULT_ITR 1000000000/(MAX_INTS_PER_SEC * 256)
2830 E1000_WRITE_REG(hw
, ITR
, DEFAULT_ITR
);
2833 /* Setup the Base and Length of the Rx Descriptor Ring */
2834 ptr
= (u32
) rx_pool
;
2836 ptr
= (ptr
+ 0x10) & (~0xf);
2837 rx_base
= (typeof(rx_base
)) ptr
;
2838 E1000_WRITE_REG(hw
, RDBAL
, (u32
) rx_base
);
2839 E1000_WRITE_REG(hw
, RDBAH
, 0);
2841 E1000_WRITE_REG(hw
, RDLEN
, 128);
2843 /* Setup the HW Rx Head and Tail Descriptor Pointers */
2844 E1000_WRITE_REG(hw
, RDH
, 0);
2845 E1000_WRITE_REG(hw
, RDT
, 0);
2847 /* Enable 82543 Receive Checksum Offload for TCP and UDP */
2848 if ((adapter
->hw
.mac_type
>= e1000_82543
) && (adapter
->rx_csum
== TRUE
)) {
2849 rxcsum
= E1000_READ_REG(hw
, RXCSUM
);
2850 rxcsum
|= E1000_RXCSUM_TUOFL
;
2851 E1000_WRITE_REG(hw
, RXCSUM
, rxcsum
);
2854 /* Enable Receives */
2856 E1000_WRITE_REG(hw
, RCTL
, rctl
);
2860 /**************************************************************************
2861 POLL - Wait for a frame
2862 ***************************************************************************/
2864 e1000_poll(struct eth_device
*nic
)
2866 struct e1000_hw
*hw
= nic
->priv
;
2867 struct e1000_rx_desc
*rd
;
2868 /* return true if there's an ethernet packet ready to read */
2869 rd
= rx_base
+ rx_last
;
2870 if (!(le32_to_cpu(rd
->status
)) & E1000_RXD_STAT_DD
)
2872 /*DEBUGOUT("recv: packet len=%d \n", rd->length); */
2873 NetReceive((uchar
*)packet
, le32_to_cpu(rd
->length
));
2878 /**************************************************************************
2879 TRANSMIT - Transmit a frame
2880 ***************************************************************************/
2882 e1000_transmit(struct eth_device
*nic
, volatile void *packet
, int length
)
2884 struct e1000_hw
*hw
= nic
->priv
;
2885 struct e1000_tx_desc
*txp
;
2888 txp
= tx_base
+ tx_tail
;
2889 tx_tail
= (tx_tail
+ 1) % 8;
2891 txp
->buffer_addr
= cpu_to_le64(virt_to_bus(packet
));
2892 txp
->lower
.data
= cpu_to_le32(E1000_TXD_CMD_RPS
| E1000_TXD_CMD_EOP
|
2893 E1000_TXD_CMD_IFCS
| length
);
2894 txp
->upper
.data
= 0;
2895 E1000_WRITE_REG(hw
, TDT
, tx_tail
);
2897 while (!(le32_to_cpu(txp
->upper
.data
) & E1000_TXD_STAT_DD
)) {
2898 if (i
++ > TOUT_LOOP
) {
2899 DEBUGOUT("e1000: tx timeout\n");
2902 udelay(10); /* give the nic a chance to write to the register */
2909 e1000_reset(struct eth_device
*nic
)
2911 struct e1000_hw
*hw
= nic
->priv
;
2914 if (hw
->mac_type
>= e1000_82544
) {
2915 E1000_WRITE_REG(hw
, WUC
, 0);
2917 return e1000_init_hw(nic
);
2920 /**************************************************************************
2921 DISABLE - Turn off ethernet interface
2922 ***************************************************************************/
2924 e1000_disable(struct eth_device
*nic
)
2926 struct e1000_hw
*hw
= nic
->priv
;
2928 /* Turn off the ethernet interface */
2929 E1000_WRITE_REG(hw
, RCTL
, 0);
2930 E1000_WRITE_REG(hw
, TCTL
, 0);
2932 /* Clear the transmit ring */
2933 E1000_WRITE_REG(hw
, TDH
, 0);
2934 E1000_WRITE_REG(hw
, TDT
, 0);
2936 /* Clear the receive ring */
2937 E1000_WRITE_REG(hw
, RDH
, 0);
2938 E1000_WRITE_REG(hw
, RDT
, 0);
2940 /* put the card in its initial state */
2942 E1000_WRITE_REG(hw
, CTRL
, E1000_CTRL_RST
);
2948 /**************************************************************************
2949 INIT - set up ethernet interface(s)
2950 ***************************************************************************/
2952 e1000_init(struct eth_device
*nic
, bd_t
* bis
)
2954 struct e1000_hw
*hw
= nic
->priv
;
2957 ret_val
= e1000_reset(nic
);
2959 if ((ret_val
== -E1000_ERR_NOLINK
) ||
2960 (ret_val
== -E1000_ERR_TIMEOUT
)) {
2961 E1000_ERR("Valid Link not detected\n");
2963 E1000_ERR("Hardware Initialization Failed\n");
2967 e1000_configure_tx(hw
);
2968 e1000_setup_rctl(hw
);
2969 e1000_configure_rx(hw
);
2973 /**************************************************************************
2974 PROBE - Look for an adapter, this routine's visible to the outside
2975 You should omit the last argument struct pci_device * for a non-PCI NIC
2976 ***************************************************************************/
2978 e1000_initialize(bd_t
* bis
)
2981 int card_number
= 0;
2982 struct eth_device
*nic
= NULL
;
2983 struct e1000_hw
*hw
= NULL
;
2988 while (1) { /* Find PCI device(s) */
2989 if ((devno
= pci_find_devices(supported
, idx
++)) < 0) {
2993 pci_read_config_dword(devno
, PCI_BASE_ADDRESS_0
, &iobase
);
2994 iobase
&= ~0xf; /* Mask the bits that say "this is an io addr" */
2995 DEBUGOUT("e1000#%d: iobase 0x%08x\n", card_number
, iobase
);
2997 pci_write_config_dword(devno
, PCI_COMMAND
,
2998 PCI_COMMAND_MEMORY
| PCI_COMMAND_MASTER
);
2999 /* Check if I/O accesses and Bus Mastering are enabled. */
3000 pci_read_config_dword(devno
, PCI_COMMAND
, &PciCommandWord
);
3001 if (!(PciCommandWord
& PCI_COMMAND_MEMORY
)) {
3002 printf("Error: Can not enable MEM access.\n");
3004 } else if (!(PciCommandWord
& PCI_COMMAND_MASTER
)) {
3005 printf("Error: Can not enable Bus Mastering.\n");
3009 nic
= (struct eth_device
*) malloc(sizeof (*nic
));
3010 hw
= (struct e1000_hw
*) malloc(sizeof (*hw
));
3013 nic
->iobase
= bus_to_phys(devno
, iobase
);
3015 sprintf(nic
->name
, "e1000#%d", card_number
);
3017 /* Are these variables needed? */
3019 hw
->fc
= e1000_fc_none
;
3020 hw
->original_fc
= e1000_fc_none
;
3022 hw
->fc
= e1000_fc_default
;
3023 hw
->original_fc
= e1000_fc_default
;
3025 hw
->autoneg_failed
= 0;
3026 hw
->get_link_status
= TRUE
;
3027 hw
->hw_addr
= (typeof(hw
->hw_addr
)) iobase
;
3028 hw
->mac_type
= e1000_undefined
;
3030 /* MAC and Phy settings */
3031 if (e1000_sw_init(nic
, card_number
) < 0) {
3036 #if !(defined(CONFIG_AP1000) || defined(CONFIG_MVBC_1G))
3037 if (e1000_validate_eeprom_checksum(nic
) < 0) {
3038 printf("The EEPROM Checksum Is Not Valid\n");
3044 e1000_read_mac_addr(nic
);
3046 E1000_WRITE_REG(hw
, PBA
, E1000_DEFAULT_PBA
);
3048 printf("e1000: %02x:%02x:%02x:%02x:%02x:%02x\n",
3049 nic
->enetaddr
[0], nic
->enetaddr
[1], nic
->enetaddr
[2],
3050 nic
->enetaddr
[3], nic
->enetaddr
[4], nic
->enetaddr
[5]);
3052 nic
->init
= e1000_init
;
3053 nic
->recv
= e1000_poll
;
3054 nic
->send
= e1000_transmit
;
3055 nic
->halt
= e1000_disable
;