MaxOS::drivers::ethernet::AMD_AM79C973 Class Reference

Driver for the AMD AM79C973 Ethernet Controller. More...

#include <amd_am79c973.h>

Inheritance diagram for MaxOS::drivers::ethernet::AMD_AM79C973:

Public Member Functions
	AMD_AM79C973 (hardwarecommunication::PCIDeviceDescriptor *dev)
	Constructs a new AMD_AM79C973 Ethernet driver, reads the MAC address and sets up the initialisation block and buffer descriptors.
uint32_t	reset () final
	This function resets the device.
void	activate () final
	This function activates the device and starts it (Runs when the driver-manger calls activateAll())
void	deactivate () final
	Deactivate the driver.
string	vendor_name () final
	Get who created the device.
string	device_name () final
	Get the device name of the driver.
void	handle_interrupt () final
	This function handles the interrupt for the device.
void	do_send (uint8_t *buffer, uint32_t size) final
	This function sends a package.
uint64_t	get_media_access_control_address () final
	This function gets the MAC address.
Public Member Functions inherited from MaxOS::drivers::ethernet::EthernetDriver
void	send (uint8_t *buffer, uint32_t size)
	send data to the network via the driver backend
Public Member Functions inherited from MaxOS::drivers::Driver
virtual void	initialise ()
	Initialise the driver.
Public Member Functions inherited from MaxOS::common::EventManager< EthernetDriverEvents >
void	connect_event_handler (EventHandler< EthernetDriverEvents > *handler)
	connect an event handler to the event manager if it is not already connected
void	disconnect_event_handler (EventHandler< EthernetDriverEvents > *handler)
	disconnect an event handler from the event manager if it is connected
Vector< Event< EthernetDriverEvents > * >	raise_event (Event< EthernetDriverEvents > *event)
	Calls the on_event function of all the event m_handlers connected to the event manager and returns a list of the results.
Public Member Functions inherited from MaxOS::hardwarecommunication::InterruptHandler
virtual system::cpu_status_t *	handle_interrupt (system::cpu_status_t *status)
	Handles an interrupt and returns the status.

Additional Inherited Members
Static Public Member Functions inherited from MaxOS::drivers::ethernet::EthernetDriver
static MediaAccessControlAddress	create_media_access_control_address (uint8_t digit1, uint8_t digit2, uint8_t digit3, uint8_t digit4, uint8_t digit5, uint8_t digit6)
	Create a Media Access Control Address.
Protected Member Functions inherited from MaxOS::drivers::ethernet::EthernetDriver
void	fire_data_received (uint8_t *buffer, uint32_t size)
	Handle the recieved data.
void	fire_data_sent (uint8_t *buffer, uint32_t size)
	send data
Protected Member Functions inherited from MaxOS::hardwarecommunication::InterruptHandler
	InterruptHandler (uint8_t interrupt_number, int64_t redirect=-1, uint64_t redirect_index=0)
	Creates a new interrupt handler and registers it with the interrupt manager.
	~InterruptHandler ()
	Destroys the interrupt handler and unregisters it from the interrupt manager.
Protected Attributes inherited from MaxOS::common::EventManager< EthernetDriverEvents >
Vector< EventHandler< EthernetDriverEvents > * >	m_handlers
Protected Attributes inherited from MaxOS::hardwarecommunication::InterruptHandler
uint8_t	m_interrupt_number
	The interrupt number this handler handles.

Detailed Description

Driver for the AMD AM79C973 Ethernet Controller.

Definition at line 65 of file amd_am79c973.h.

Constructor & Destructor Documentation

AMD_AM79C973()

AMD_AM79C973::AMD_AM79C973 ( hardwarecommunication::PCIDeviceDescriptor *  dev )

explicit

Constructs a new AMD_AM79C973 Ethernet driver, reads the MAC address and sets up the initialisation block and buffer descriptors.

MAX OS NET CODE: All the old (this) networking code poorly written and not used, this will be moved to userspace in the future but is kept here as a reference for now.

Parameters

dev	The PCI device descriptor for this device

Todo:

move all this to initilise()

Definition at line 26 of file amd_am79c973.cpp.

: InterruptHandler(0x20 + dev->interrupt),
mac_address_0_port(dev->port_base),
mac_address_2_port(dev->port_base + 0x02),
mac_address_4_port(dev->port_base + 0x04),
register_data_port(dev->port_base + 0x10),
register_address_port(dev->port_base + 0x12),
bus_control_register_data_port(dev->port_base + 0x16),
reset_port(dev->port_base + 0x14),
init_block(),
send_buffers(),
recv_buffers() {
    // No active buffer at the start
    current_send_buffer = 0;
    current_recv_buffer = 0;
 
    //Not active or initialised
    active = false;
    init_done = false;
 
 
    // Get the MAC addresses (split up in little endian order)
    uint64_t mac_0 = mac_address_0_port.read() % 256;
    uint64_t mac_1 = mac_address_0_port.read() / 256;
    uint64_t mac_2 = mac_address_2_port.read() % 256;
    uint64_t mac_3 = mac_address_2_port.read() / 256;
    uint64_t mac_4 = mac_address_4_port.read() % 256;
    uint64_t mac_5 = mac_address_4_port.read() / 256;
 
    // Combine MAC addresses into one 48 bit number
    own_mac = mac_5 << 40
              | mac_4 << 32
              | mac_3 << 24
              | mac_2 << 16
              | mac_1 << 8
              | mac_0;
 
    // Set the device to 32 bit mode
    register_address_port.write(20);              // Tell device to write to register 20
    bus_control_register_data_port.write(0x102);    // write desired data
 
    // Reset the stop bit (tell device it's not supposed to be reset now)
    register_address_port.write(0);               // Tell device to write to register 0
    register_data_port.write(0x04);               // write desired data
 
    // Set the initialization block
    init_block.mode = 0x0000;                         // Promiscuous mode = false   ( promiscuous mode tells it to receive all packets, not just broadcasts and those for its own MAC address)
    init_block.reserved1 = 0;                         // Reserved
    init_block.num_send_buffers = 3;                    // Means 8 because 2^8 (number of bits used)
    init_block.reserved2 = 0;                         // Reserved
    init_block.num_recv_buffers = 3;                    // Means 8 because 2^8 (number of bits used)
    init_block.physical_address = own_mac;              // Set the physical address to the MAC address
    init_block.reserved3 = 0;                         // Reserved
    init_block.logical_address = 0;                    // None for now
 
    // Set Buffer descriptors memory
    send_buffer_descr = (BufferDescriptor*) (MemoryManager::kmalloc((sizeof(BufferDescriptor) * 8) + 15));  // Allocate memory for 8 buffer descriptors
    init_block.send_buffer_descr_address = (uint64_t) send_buffer_descr;
 
    recv_buffer_descr = (BufferDescriptor*) (MemoryManager::kmalloc((sizeof(BufferDescriptor) * 8) + 15));  // Allocate memory for 8 buffer descriptors
    init_block.recv_buffer_descr_address = (uint64_t) recv_buffer_descr;
 
    for(uint8_t i = 0; i < 8; i++) {
 
        // Send buffer descriptors
        send_buffer_descr[i].address = (((uint64_t) &send_buffers[i]) + 15) & ~(uint32_t) 0xF;       // Same as above
        send_buffer_descr[i].flags =
        0x7FF                                                         // Length of descriptor
        | 0xF000;                                                     // Set it to send buffer
        send_buffer_descr[i].flags2 = 0;                                                           // "Flags2" shows whether an error occurred while sending and should therefore be set to 0 by the drive
        send_buffer_descr[i].avail = 0;                                                            // IF it is in use
 
        // Receive
        recv_buffer_descr[i].address = (((uint64_t) &recv_buffers[i]) + 15) & ~(uint32_t) 0xF;   // Same as above
        recv_buffer_descr[i].flags =
        0xF7FF                                                        // Length of descriptor        (This 0xF7FF is what was causing the problem, it used to be 0x7FF)
        | 0x80000000;                                                 // Set it to receive buffer
        recv_buffer_descr[i].flags2 = 0;                                                           // "Flags2" shows whether an error occurred while sending and should therefore be set to 0 by the drive
        recv_buffer_descr[i].avail = 0;                                                            // IF it is in use
    }
 
    // Move initialization block into device
    register_address_port.write(1);                                     // Tell device to write to register 1
    register_data_port.write((uint64_t) (&init_block) &
                             0xFFFF);             // write address data
    register_address_port.write(2);                                     // Tell device to write to register 2
    register_data_port.write(((uint64_t) (&init_block) >> 16) &
                             0xFFFF);     // write shifted address data
 
 
}

References MaxOS::memory::MemoryManager::kmalloc(), MaxOS::hardwarecommunication::Port16Bit::read(), and MaxOS::hardwarecommunication::Port16Bit::write().

Member Function Documentation

activate()

void AMD_AM79C973::activate ( )

finalvirtual

This function activates the device and starts it (Runs when the driver-manger calls activateAll())

Todo:

Re-implement this class

Reimplemented from MaxOS::drivers::Driver.

Definition at line 127 of file amd_am79c973.cpp.

                            {
 
    return;
 
    init_done = false;                                            // Set initDone to false
    register_address_port.write(0);                           // Tell device to write to register 0
    register_data_port.write(0x41);                           // Enable Interrupts and start the device
    while(!init_done);                                            // Wait for initDone to be set to true
 
    register_address_port.write(4);                           // Tell device to read from register 4
    uint32_t temp = register_data_port.read();                     // Get current data
 
    register_address_port.write(4);                           // Tell device to write to register 4
    register_data_port.write(temp |
                             0xC00);                   // Bitwise OR function on data (This automatically enlarges packets smaller than 64 bytes to that size and removes some relatively superfluous information from received packets.)
 
    register_address_port.write(0);                           // Tell device to write to register 0
    register_data_port.write(
    0x42);                           // Tell device that it is initialised and can begin operating
 
    active = true;                                               // Set active to true
}

References MaxOS::hardwarecommunication::Port16Bit::read(), and MaxOS::hardwarecommunication::Port16Bit::write().

deactivate()

void AMD_AM79C973::deactivate ( )

finalvirtual

Deactivate the driver.

Reimplemented from MaxOS::drivers::Driver.

Definition at line 305 of file amd_am79c973.cpp.

                              {
 
}

device_name()

string AMD_AM79C973::device_name ( )

finalvirtual

Get the device name of the driver.

Returns

The device name of the driver

Reimplemented from MaxOS::drivers::Driver.

Definition at line 313 of file amd_am79c973.cpp.

                                 {
    return "PCnet-Fast III (Am79C973)";
}

do_send()

void AMD_AM79C973::do_send ( uint8_t *  buffer, uint32_t  size  )

finalvirtual

This function sends a package.

Parameters

buffer	The buffer to send
size	The size of the buffer

Reimplemented from MaxOS::drivers::ethernet::EthernetDriver.

Definition at line 210 of file amd_am79c973.cpp.

                                                         {
 
    while(!active);
 
    int send_descriptor = current_send_buffer;              // Get where data has been written to
    current_send_buffer = (current_send_buffer + 1) %
                          8;    // Move send buffer to next send buffer (div by 8 so that it is cycled) (this allows for data to be sent from different m_tasks in parallel)
 
    if(size >
       1518) {                                    // If attempt to send more than 1518 bytes at once it will be too large
        size = 1518;                                    // Discard all data after that  (Generally if data is bigger than that at driver level then a higher up network layer must have made a mistake)
 
    }
 
    // What this loop does is copy the information passed as the parameter buffer (src) to the send buffer in the ram (dst) which the card will then use to send the data
    for(uint8_t* src = buffer + size -
                       1,                                                   // Set src pointer to the end of the data that is being sent
        * dst = (uint8_t*) (send_buffer_descr[send_descriptor].address + size -
                            1);       // Take the buffer that has been selected
        src >=
        buffer;                                                             // While there is still information in the buffer that hasn't been written to src
        src--, dst--                                                                // Move 2 pointers to the end of the buffers
    ) {
        *dst = *src;                                                                        // Copy data from source buffer to destination buffer
    }
 
 
    send_buffer_descr[send_descriptor].avail = 0;                               // Set that this buffer is in use
    send_buffer_descr[send_descriptor].flags2 = 0;                              // Clear any previous error messages
    send_buffer_descr[send_descriptor].flags = 0x8300F000                       // Encode the size of what is being sent
                                               | ((uint16_t) ((-size) & 0xFFF));
 
    register_address_port.write(0);                           // Tell device to write to register 0
    register_data_port.write(
    0x48);                           // Tell device to send the data currently in the buffer
}

References MaxOS::hardwarecommunication::Port16Bit::write().

get_media_access_control_address()

uint64_t AMD_AM79C973::get_media_access_control_address ( )

finalvirtual

This function gets the MAC address.

Returns

The MAC address

Reimplemented from MaxOS::drivers::ethernet::EthernetDriver.

Definition at line 300 of file amd_am79c973.cpp.

                                                        {
    while(own_mac == 0);
    return own_mac;
}

handle_interrupt()

void AMD_AM79C973::handle_interrupt ( )

finalvirtual

This function handles the interrupt for the device.

Reimplemented from MaxOS::hardwarecommunication::InterruptHandler.

Definition at line 168 of file amd_am79c973.cpp.

                                    {
 
    // Similar to PIC, data needs to be read when an interrupt is sent, or it hangs
    register_address_port.write(0);                           // Tell device to read from register 0
    uint32_t temp = register_data_port.read();                     // Get current data
 
    // Note: Cant be switch case as multiple errors can occur at the same time
 
    // Errors
    if((temp & 0x8000) == 0x8000)
        Logger::WARNING() << "AMD am79c973 ERROR: ";
    if((temp & 0x2000) == 0x2000)
        Logger::WARNING() << "COLLISION ERROR\n";
    if((temp & 0x1000) == 0x1000)
        Logger::WARNING() << "MISSED FRAME\n";
    if((temp & 0x0800) == 0x0800)
        Logger::WARNING() << "MEMORY ERROR\n";
 
 
    // Responses
    if((temp & 0x0400) == 0x0400) fetch_data_received();
    if((temp & 0x0200) == 0x0200) fetch_data_sent();
    if((temp & 0x0100) == 0x0100) init_done = true;//
 
    // Reply that it was received
    register_address_port.write(0);                           // Tell device to write to register 0
    register_data_port.write(temp);                           // Tell device that the interrupt was received
}

References MaxOS::hardwarecommunication::Port16Bit::read(), MaxOS::Logger::WARNING(), and MaxOS::hardwarecommunication::Port16Bit::write().

reset()

uint32_t AMD_AM79C973::reset ( )

finalvirtual

This function resets the device.

Returns

The amount of ms to wait

Reimplemented from MaxOS::drivers::Driver.

Definition at line 155 of file amd_am79c973.cpp.

                             {
 
    reset_port.read();
    reset_port.write(0);
    return 10;                      // 10 means wait for 10ms
 
}

References MaxOS::hardwarecommunication::Port16Bit::read(), and MaxOS::hardwarecommunication::Port16Bit::write().

vendor_name()

string AMD_AM79C973::vendor_name ( )

finalvirtual

Get who created the device.

Returns

The vendor name of the driver

Reimplemented from MaxOS::drivers::Driver.

Definition at line 309 of file amd_am79c973.cpp.

                                 {
    return "AMD";
}

---

The documentation for this class was generated from the following files:

• /home/runner/work/MaxOS/MaxOS/kernel/include/drivers/ethernet/amd_am79c973.h
• /home/runner/work/MaxOS/MaxOS/kernel/src/drivers/ethernet/amd_am79c973.cpp