Intel Ethernet i217: Difference between revisions

== Network Driver for Intel Ethernet Cards I217 and 82577LM ==

 

It is very important to highlight that this wiki does not utilize all the features in the above NICs, but it show how to configure the NICs for basic functionality such as initialization, read packets, and write packets.

 

 

To start with, lets state some macro definitions that we are going to use in the code.

 

#define INTEL_VEND 0x8086 // Vendor ID for Intel

 

#define REG_RDTR 0x2820 // RX Delay Timer Register

#define REG_RADV 0x282C // RX Int. Absolute Delay Timer

#define REG_RSRPD 0x2C00 // RX Small Packet Detect Interrupt

#define TSTA_LC (1 << 2) // Late Collision

#define LSTA_TU (1 << 3) // Transmit Underrun

 

Now lets define the data structures for the transmit and receive buffers

 

 

#define E1000_NUM_RX_DESC 32

} __attribute__((packed));

 

 

 

 

 

== The Driver Class Header (Class Definition)==

 

 

class E1000 : public NetworkDriver

{

private:

uint16_t io_base; // IO Base Address

uint64_t mem_base; // MMIO Base Address

~E1000(); // Default Destructor

};

 

== How the Gears Move (Class methods implementation) ==

First of all we need to be able to send commands and read results from the NIC. It is important to detect the type of BAR0 and based on that the correct communication mechanism should be adopted. The following two methods encapsulate the read/write commands and uses MMIO or IO ports based on the value in BAR0 which is reflected in bar_type data member flag.

 

void E1000::writeCommand( uint16_t p_address, uint32_t p_value)

{

}

}

 

 

Now we need to detect if the card has an EEPROM or not. The Qemu and Bochs emulate EEPROM, but the I217 and 82577LM do not. The following first method tries to read the status field of the EEPROM, the status field should contain the value 0x10, and based on the result the internal data member eerprom_exists. The second method performs a 2-bytes read operation from the EEPROM

 

bool E1000::detectEEProm()

{

}

 

 

 

The first thing you will need to do after detecting the BAR0 type and the existence of the EEPROM is to read the hardware MAC address of the NIC. The following method reads the hardware mac address based. If an EEPROM exists it will read it from the EEPROM else it will read it from address 0x5400 where it should be located in that case. It is very important to detect if an EEPROM exists or not prior to reading the MAC address.

 

 

bool E1000::readMACAddress()

return true;

}

 

 

Now, we need to configure the transmit and receive descriptor buffers, here are the implementation of the corresponding methods. The rxinit method is identical to the one I use for my e1000 driver. The difference is in txinit

 

 

void E1000::rxinit()

writeCommand(REG_RXDESCTAIL, E1000_NUM_RX_DESC-1);

rx_cur = 0;

}

 

 

 

 

To enable interrupts

void E1000::enableInterrupt()

{

 

}

 

As we have defined most of the building blocks and the helper methods lets define the main methods of the class.

 

The constructor is responsible for fetching PCI related data and initialize the object internal state

 

E1000::E1000(PCIConfigHeader * p_pciConfigHeader) : NetworkDriver(p_pciConfigHeader)

{

eerprom_exists = false;

}

 

The start method basically detects the EEPROM, reads the MAC addresses, setup rx and tx buffers, register the interrupt handler, and enable NIC interrupts

 

 

 

bool E1000::start ()

 

 

 

 

Your interrupt handler should eventually call the fire method which handles the NIC's events

 

void E1000::fire (InterruptContext * p_interruptContext)

if ( p_interruptContext->getInteruptNumber() == pciConfigHeader->getIntLine()+IRQ0)

{

uint32_t status = readCommand(0xc0);

if(status & 0x04)

}

 

 

Finally we define the sendPacket method as follows

 

 

int E1000::sendPacket(const void * p_data, uint16_t p_len)

tx_descs[tx_cur]->addr = (uint64_t)p_data;

tx_descs[tx_cur]->length = p_len;

tx_descs[tx_cur]->status = 0;

uint8_t old_cur = tx_cur;

}

 

 

 

This is an example of how to instantiate an object of this class and startup you driver. I assume that you have scanned your PCI buses and loaded the found devices parameters into some data structures; in our example this is done by the PCIConfigManager class, which is outside the scope of this tutorial

 

 

pciConfigHeaderManager.initialize(); // Initialize the PCIConfigHeaderManager Object and scan PCI devices

}

 

 

== Summary and Wrap Up ==

 

I have presented in this Wiki the steps I followed to make an e1000 driver work with the two e1000e NICs Intel I217 and 82577LM. The wiki does not show how to utilize all the features of the NICs, but basically primitive setup and send/receive packets. Three important issues that I faced:

 

* You need to detect the BAR0 type as some cards uses IO ports and others uses MMIO and you need to communincate with the NIC with the method appropriate to each.

* You need to make sure to setup the card TCTRL register (Transmission Control Register) with the value 0b0110000000000111111000011111010. For more details reference the Intel manual for the meaning of the different bits of the register