Enhance Intel e1000e driver with EEPROM MAC reading and link status checks

Author: T. Andrew Davis

network/asm/drivers/intel/init.s

@@ -309,11 +309,103 @@ asm_intel_read_mac:
     jmp     .exit
 
 .try_eeprom:
-    ; TODO: Read from EEPROM if RAL/RAH invalid
-    ; For now, return error
-    mov     eax, 1
+    ; Read MAC from EEPROM for I218/82579
+    ; EEPROM words 0, 1, 2 contain MAC address
+    ; Word 0 = bytes 0-1, Word 1 = bytes 2-3, Word 2 = bytes 4-5
+    
+    ; Read EEPROM word 0 (MAC bytes 0-1)
+    mov     rcx, r12
+    xor     edx, edx            ; Address 0
+    call    .read_eeprom_word
+    cmp     eax, 0xFFFFFFFF
+    je      .invalid            ; EEPROM read failed
+    mov     [r13], al           ; Byte 0
+    shr     eax, 8
+    mov     [r13+1], al         ; Byte 1
+    
+    ; Read EEPROM word 1 (MAC bytes 2-3)
+    mov     rcx, r12
+    mov     edx, 1              ; Address 1
+    call    .read_eeprom_word
+    cmp     eax, 0xFFFFFFFF
+    je      .invalid
+    mov     [r13+2], al         ; Byte 2
+    shr     eax, 8
+    mov     [r13+3], al         ; Byte 3
+    
+    ; Read EEPROM word 2 (MAC bytes 4-5)
+    mov     rcx, r12
+    mov     edx, 2              ; Address 2
+    call    .read_eeprom_word
+    cmp     eax, 0xFFFFFFFF
+    je      .invalid
+    mov     [r13+4], al         ; Byte 4
+    shr     eax, 8
+    mov     [r13+5], al         ; Byte 5
+    
+    ; Validate the MAC we read
+    mov     eax, [r13]
+    movzx   ecx, word [r13+4]
+    or      eax, ecx
+    jz      .invalid            ; All zeros
+    
+    xor     eax, eax            ; Success
     jmp     .exit
 
+; Helper: Read one EEPROM word
+; Input: RCX = mmio_base, EDX = address (0-2 for MAC)
+; Output: EAX = word value, or 0xFFFFFFFF on error
+.read_eeprom_word:
+    push    rbx
+    push    r14
+    push    r15
+    sub     rsp, 32
+    
+    mov     r14, rcx            ; mmio_base
+    mov     r15d, edx           ; address
+    
+    ; Write EERD: address in bits [15:8], start bit [0]
+    ; For 82579/I218: address is bits [15:2], start is bit 0
+    shl     r15d, 2             ; address << 2
+    or      r15d, 1             ; Set START bit
+    mov     edx, r15d
+    mov     rcx, r14
+    add     rcx, EERD
+    call    asm_mmio_write32
+    
+    ; Poll for DONE bit (bit 1) - timeout after ~10ms
+    mov     ebx, 10000          ; iteration count
+.eerd_poll:
+    mov     rcx, r14
+    add     rcx, EERD
+    call    asm_mmio_read32
+    test    eax, 2              ; DONE bit
+    jnz     .eerd_done
+    
+    ; Small delay
+    pause
+    pause
+    pause
+    
+    dec     ebx
+    jnz     .eerd_poll
+    
+    ; Timeout
+    mov     eax, 0xFFFFFFFF
+    jmp     .eerd_exit
+    
+.eerd_done:
+    ; Data is in bits [31:16]
+    shr     eax, 16
+    and     eax, 0xFFFF
+    
+.eerd_exit:
+    add     rsp, 32
+    pop     r15
+    pop     r14
+    pop     rbx
+    ret
+
 .invalid:
     mov     eax, 1
 

network/src/driver/intel/e1000e.rs

@@ -8,6 +8,7 @@
 use crate::driver::traits::{DriverInit, NetworkDriver, RxError, TxError};
 use crate::mainloop::bare_metal::serial_println;
 use crate::types::MacAddress;
+use crate::asm::drivers::intel::{asm_intel_link_status, LinkStatusResult};
 
 use super::init::{init_e1000e, E1000eConfig, E1000eInitError};
 use super::phy::PhyManager;
@@ -183,9 +184,13 @@ impl NetworkDriver for E1000eDriver {
 
     /// Get link status.
     fn link_up(&self) -> bool {
-        // Use cached status to avoid MMIO on every call
-        // The phy.link_status() call updates the cache
-        self.phy.cached_link_status().link_up
+        // Directly read hardware STATUS register via ASM
+        // We need actual hardware state, not cached values
+        let mut result = LinkStatusResult::default();
+        unsafe {
+            asm_intel_link_status(self.mmio_base, &mut result);
+        }
+        result.link_up != 0
     }
 }
 

network/src/driver/intel/init.rs

@@ -211,8 +211,26 @@ pub unsafe fn init_e1000e(
     // ═══════════════════════════════════════════════════════════════════
     let mut mac: MacAddress = [0u8; 6];
     let mac_result = asm_intel_read_mac(mmio_base, &mut mac);
+    
+    // Debug: print raw MAC bytes
+    serial_print("  [e1000e] MAC read result=");
+    serial_print_decimal(mac_result);
+    serial_print(" bytes=[");
+    serial_print_decimal(mac[0] as u32);
+    serial_print(",");
+    serial_print_decimal(mac[1] as u32);
+    serial_print(",");
+    serial_print_decimal(mac[2] as u32);
+    serial_print(",");
+    serial_print_decimal(mac[3] as u32);
+    serial_print(",");
+    serial_print_decimal(mac[4] as u32);
+    serial_print(",");
+    serial_print_decimal(mac[5] as u32);
+    serial_println("]");
+    
     if mac_result != 0 {
-        serial_println("  [e1000e] FAIL: Invalid MAC");
+        serial_println("  [e1000e] FAIL: Invalid MAC (ASM returned error)");
         return Err(E1000eInitError::InvalidMac);
     }
 
@@ -303,9 +321,28 @@ pub unsafe fn init_e1000e(
     asm_intel_enable_tx(mmio_base);
 
     // ═══════════════════════════════════════════════════════════════════
-    // STEP 14: SET LINK UP
+    // STEP 14: SET LINK UP AND RESTART AUTO-NEGOTIATION
+    //
+    // On I218, after all the init steps, we need to:
+    // 1. Set CTRL.SLU (Set Link Up)
+    // 2. Restart PHY auto-negotiation
+    // 3. Give time for link partner negotiation
     // ═══════════════════════════════════════════════════════════════════
     asm_intel_set_link_up(mmio_base);
+    
+    // Restart auto-negotiation after setting SLU
+    serial_println("  [e1000e] Restarting auto-negotiation...");
+    if let Some(bmcr) = phy_read(mmio_base, regs::PHY_BMCR, config.tsc_freq) {
+        let new_bmcr = bmcr | regs::BMCR_ANENABLE | regs::BMCR_ANRESTART;
+        let _ = phy_write(mmio_base, regs::PHY_BMCR, new_bmcr, config.tsc_freq);
+    }
+    
+    // Give PHY time to start negotiation (100ms)
+    let delay_start = crate::asm::core::tsc::read_tsc();
+    let delay_ticks = config.tsc_freq / 10; // 100ms
+    while crate::asm::core::tsc::read_tsc().wrapping_sub(delay_start) < delay_ticks {
+        core::hint::spin_loop();
+    }
 
     serial_println("  [e1000e] Init complete!");
 

network/src/mainloop/bare_metal.rs

@@ -89,6 +89,30 @@ unsafe fn serial_write_byte(byte: u8) {
 #[cfg(not(target_arch = "x86_64"))]
 unsafe fn serial_write_byte(_byte: u8) {}
 
+// Static counters for packet debugging
+static mut TX_PACKET_COUNT: u32 = 0;
+static mut RX_PACKET_COUNT: u32 = 0;
+
+/// Increment TX counter
+pub fn inc_tx_count() {
+    unsafe { TX_PACKET_COUNT += 1; }
+}
+
+/// Increment RX counter
+pub fn inc_rx_count() {
+    unsafe { RX_PACKET_COUNT += 1; }
+}
+
+/// Get TX count
+pub fn get_tx_count() -> u32 {
+    unsafe { TX_PACKET_COUNT }
+}
+
+/// Get RX count
+pub fn get_rx_count() -> u32 {
+    unsafe { RX_PACKET_COUNT }
+}
+
 /// Write string to serial port.
 pub fn serial_print(s: &str) {
     for byte in s.bytes() {
@@ -1109,6 +1133,10 @@ pub struct SmoltcpAdapter<'a, D: NetworkDriver> {
     rx_buffer: [u8; 2048],
     /// Length of data in rx_buffer (0 if no pending packet)
     rx_len: usize,
+    /// TX packet count (for debug)
+    tx_count: u32,
+    /// RX packet count (for debug)
+    rx_count: u32,
 }
 
 impl<'a, D: NetworkDriver> SmoltcpAdapter<'a, D> {
@@ -1117,6 +1145,8 @@ impl<'a, D: NetworkDriver> SmoltcpAdapter<'a, D> {
             driver,
             rx_buffer: [0u8; 2048],
             rx_len: 0,
+            tx_count: 0,
+            rx_count: 0,
         }
     }
 
@@ -1128,11 +1158,23 @@ impl<'a, D: NetworkDriver> SmoltcpAdapter<'a, D> {
             match self.driver.receive(&mut self.rx_buffer) {
                 Ok(Some(len)) => {
                     self.rx_len = len;
+                    self.rx_count += 1;
+                    inc_rx_count(); // Global counter
                 }
                 _ => {}
             }
         }
     }
+    
+    /// Get TX count for debug.
+    pub fn tx_count(&self) -> u32 {
+        self.tx_count
+    }
+    
+    /// Get RX count for debug.
+    pub fn rx_count(&self) -> u32 {
+        self.rx_count
+    }
 
     /// Refill RX queue. Called in main loop Phase 1.
     pub fn refill_rx(&mut self) {
@@ -1186,7 +1228,9 @@ impl<'a, D: NetworkDriver> smoltcp::phy::TxToken for TxToken<'a, D> {
         let result = f(&mut buffer[..actual_len]);
 
         // Fire-and-forget transmit - don't wait for completion
-        let _ = self.driver.transmit(&buffer[..actual_len]);
+        if self.driver.transmit(&buffer[..actual_len]).is_ok() {
+            inc_tx_count();
+        }
 
         result
     }
@@ -1732,16 +1776,27 @@ pub unsafe fn bare_metal_main(handoff: &'static BootHandoff, config: BareMetalCo
     serial_println("[NET] Waiting for PHY link...");
 
     let link_start = get_tsc();
-    let link_timeout_ticks = handoff.tsc_freq * 10; // 10 second timeout for link
+    let link_timeout_ticks = handoff.tsc_freq * 15; // 15 second timeout for link (auto-neg can be slow)
+    let mut last_dot_tsc = link_start;
+    let dot_interval = handoff.tsc_freq; // 1 second
 
     loop {
         if driver.link_up() {
+            serial_println("");
             serial_println("[OK] PHY link established");
             break;
         }
 
         let now_tsc = get_tsc();
+        
+        // Print a dot every second to show progress
+        if now_tsc.wrapping_sub(last_dot_tsc) > dot_interval {
+            serial_print(".");
+            last_dot_tsc = now_tsc;
+        }
+        
         if now_tsc.wrapping_sub(link_start) > link_timeout_ticks {
+            serial_println("");
             serial_println("[WARN] PHY link timeout - continuing anyway...");
             break;
         }
@@ -1817,14 +1872,33 @@ pub unsafe fn bare_metal_main(handoff: &'static BootHandoff, config: BareMetalCo
     // DHCP polling loop
     serial_println("[NET] Sending DHCP DISCOVER...");
 
+    let mut last_status_tsc = dhcp_start;
+    let status_interval = handoff.tsc_freq * 2; // Print status every 2 seconds
+
     loop {
         let now_tsc = get_tsc();
 
         // Check timeout
         if now_tsc.wrapping_sub(dhcp_start) > dhcp_timeout_ticks {
-            serial_println("[FAIL] DHCP timeout");
+            serial_println("");
+            serial_print("[FAIL] DHCP timeout - TX:");
+            serial_print_decimal(get_tx_count());
+            serial_print(" RX:");
+            serial_print_decimal(get_rx_count());
+            serial_println("");
             return RunResult::DhcpTimeout;
         }
+        
+        // Print status every 2 seconds
+        if now_tsc.wrapping_sub(last_status_tsc) > status_interval {
+            serial_print(".");
+            serial_print(" TX:");
+            serial_print_decimal(get_tx_count());
+            serial_print(" RX:");
+            serial_print_decimal(get_rx_count());
+            serial_println("");
+            last_status_tsc = now_tsc;
+        }
 
         // Convert TSC to smoltcp Instant
         let timestamp = tsc_to_instant(now_tsc, handoff.tsc_freq);