Subversion Repositories Code-Repo

#include "defines.h"
#include "ETHERNET.h"

static ETH_DATA *eth_data;

/* Function to convert from virtual address to physical address
    See 3.4.1 in reference manual for explanation */
uint32_t VA_TO_PA(uint32_t ptr) {
    uint32_t ret = ptr & 0x1FFFFFFF;
    return ret;
}

void ETH_Init(ETH_DATA *data, void(*tx_callback)(void), void(*rx_callback)(void)) {
    // Save a pointer to the descriptor tables
    eth_data = data;
    eth_data->tx_callback = tx_callback;
    eth_data->rx_callback = rx_callback;

    // Bring the PHY reset line high to initialize the PHY
    PHY_RESET_TRIS = 0;
    PHY_RESET_LAT = 0;
    Delay_US(100);
    PHY_RESET_LAT = 1;

    INTDisableInterrupts();

    // Initialize the I/O lines (dont actually need this)
    ETH_MDC_TRIS = 0;
    ETH_MDIO_TRIS = 1;
    ETH_TXEN_TRIS = 0;
    ETH_TXD0_TRIS = 0;
    ETH_TXD1_TRIS = 0;
    ETH_RXCLK_TRIS = 1;
    ETH_RXDV_TRIS = 1;
    ETH_RXD0_TRIS = 1;
    ETH_RXD1_TRIS = 1;
    ETH_RXERR_TRIS = 1;

    eth_data->TX_descriptor_index = 0;
    eth_data->RX_descriptor_index = 0;

    // Initialize values in the descriptor tables
    uint8_t i;
    for (i = 0; i < ETH_TX_DESCRIPTOR_COUNT; i++) {
        // Set the NPV values for each descriptor (linear list)
        eth_data->TX_ED_table.descriptor[i].NPV = 0;
        
        // Set the EOWN values for each descriptor
        eth_data->TX_ED_table.descriptor[i].EOWN = 0;

        // Assign a data buffer to each descriptor
        eth_data->TX_ED_table.descriptor[i].BUFFER_ADDR = VA_TO_PA((uint32_t)eth_data->TX_ED_buffer[i]);
    }
    for (i = 0; i < ETH_RX_DESCRIPTOR_COUNT; i++) {
        // Set the NPV values for each descriptor (linear list)
        eth_data->RX_ED_table.descriptor[i].NPV = 0;

        // Set the EOWN values for each descriptor
        eth_data->RX_ED_table.descriptor[i].EOWN = 1;

        // Assign a data buffer to each descriptor
        eth_data->RX_ED_table.descriptor[i].BUFFER_ADDR = VA_TO_PA((uint32_t)eth_data->RX_ED_buffer[i]);
    }

    // On the last descriptor, save the address to the beginning of the list
    eth_data->TX_ED_table.descriptor[ETH_TX_DESCRIPTOR_COUNT-1].NPV = 1;
    eth_data->RX_ED_table.descriptor[ETH_RX_DESCRIPTOR_COUNT-1].NPV = 1;

    // Set the last RX descriptor EOWN to software, thus using list configuration
//    eth_data->TX_ED_table.descriptor[ETH_TX_DESCRIPTOR_COUNT-1].EOWN = 0;
//    eth_data->RX_ED_table.descriptor[ETH_RX_DESCRIPTOR_COUNT-1].EOWN = 0;

    // Loop the end of the descriptor table to the beginning (ring configuration)
    eth_data->TX_ED_table.next_ED = VA_TO_PA((uint32_t)eth_data->TX_ED_table.descriptor);
    eth_data->RX_ED_table.next_ED = VA_TO_PA((uint32_t)eth_data->RX_ED_table.descriptor);

    // Save the head of the table to the corresponding ETH register
    ETHTXST = VA_TO_PA((uint32_t)eth_data->TX_ED_table.descriptor);
    ETHRXST = VA_TO_PA((uint32_t)eth_data->RX_ED_table.descriptor);
    

    // Ethernet Initialization Sequence: see section 35.4.10 in the PIC32 Family Reference Manual
    
    // Part 1. Ethernet Controller Initialization
    IEC1bits.ETHIE = 0;     // Disable ethernet interrupts
    ETHCON1bits.ON = 0;     // Disable the ethernet module
    ETHCON1bits.TXRTS = 0;  // Stop transmit logic
    ETHCON1bits.RXEN = 0;   // Stop receive logic
    ETHCON1bits.AUTOFC = 0;
    ETHCON1bits.MANFC = 0;
    while (ETHSTATbits.ETHBUSY);
    IFS1bits.ETHIF = 0;     // Clear interrupt flags
    ETHIENCLR = 0xFFFF;     // Clear the ETHIEN register (interrupt enable)

    // Part 2. MAC Init
    EMAC1CFG1bits.SOFTRESET = 1;    // Put the MACMII in reset
    EMAC1CFG1bits.SOFTRESET = 0;
        // Default I/O configuration, RMII operating mode
    EMAC1SUPPbits.RESETRMII = 1;    // Reset the MAC RMII module
    EMAC1MCFGbits.RESETMGMT = 1;    // Reset the MII management module
    EMAC1MCFGbits.RESETMGMT = 0;    
    EMAC1MCFGbits.CLKSEL = 0x8;     // Set the MIIM PHY clock to SYSCLK/40
    while(EMAC1MINDbits.MIIMBUSY);

    // Part 3. PHY Init
        // Contrary to the ref manual, the ETH module needs to be enabled for the MIIM to work

    ETHCON1bits.ON = 1;     // Enable the ethernet module
    
    uint16_t value;
    // Reset the PHY chip
    ETH_PHY_Write(PHY_ADDRESS, 0x0, 0x8000);
    do {
        value = ETH_PHY_Read(PHY_ADDRESS, 0x0);
    } while (value & 0x8000 != 0);

    // Delay to wait for the link to be established
    Delay_MS(5000);
    
    // Wait for auto-negotiation to finish
    do {
        value = ETH_PHY_Read(PHY_ADDRESS, 0x1F); // Acquire link status
    } while (value & 0x1000 == 0);

    ETHCON1bits.ON = 0;     // Disable the ethernet module before changing other settings
    
    // Part 4. MAC Configuration
    EMAC1CFG1bits.RXENABLE = 1;     // Enable the MAC receiving of frames
    EMAC1CFG1bits.TXPAUSE = 1;      // Enable PAUSE flow control frames
    EMAC1CFG1bits.RXPAUSE = 1;      // Enable processing of PAUSE control frames
    EMAC1CFG2bits.AUTOPAD = 0;      // No auto-detection for VLAN padding
    EMAC1CFG2bits.VLANPAD = 0;      // MAC does not perform padding of short frames
    EMAC1CFG2bits.PADENABLE = 1;    // Pad all short frames
    EMAC1CFG2bits.CRCENABLE = 1;    // Append a CRC to every frame
    EMAC1CFG2bits.HUGEFRM = 1;      // Allow frames of any length
    EMAC1CFG2bits.LENGTHCK = 0;     // Check the frame lengths to the length/type field
    if ((value & 0x14) || (value & 0x18)) {
        EMAC1CFG2bits.FULLDPLX = 1; // Operate in full-duplex mode
        EMAC1IPGT = 0x15;           // Back-to-back interpacket gap @ 0.96us/9.6us
//        LED1_LAT = 1;
    } else {
        EMAC1CFG2bits.FULLDPLX = 0; // Operate in half-duplex mode
        EMAC1IPGT = 0x12;           // Back-to-back interpacket gap @ 0.96us/9.6us
//        LED2_LAT = 1;
    }
    if ((value & 0x08) || (value & 0x18)) {
        EMAC1SUPPbits.SPEEDRMII = 1;    // 100Mbps mode
//        LED3_LAT = 1;
    } else {
        EMAC1SUPPbits.SPEEDRMII = 0;    // 10Mbps mode
//        LED4_LAT = 1;
    }
    EMAC1IPGRbits.NB2BIPKTGP1 = 0xC;    // Set some other delay gap values
    EMAC1IPGRbits.NB2BIPKTGP2 = 0x12;
    EMAC1CLRTbits.CWINDOW = 0x37;       // Set collision window to count of frame bytes
    EMAC1CLRTbits.RETX = 0xF;           // Set number of retransmission attempts
    EMAC1MAXF = 0x7F4;                  // Set the maximum frame length to 2046 bits
    // Default MAC address is 00-04-A3-1A-4C-FC
    // Set MAC address to 00-18-3E-00-D7-EB
    EMAC1SA0 = 0xEBD7;
    EMAC1SA1 = 0x003E;
    EMAC1SA2 = 0x1800;

    // Part 5. Ethernet Controller Initialization cont.
        // Flow control is off by default!
    ETHRXFCbits.HTEN = 0;       // Disable hash table filtering
    ETHRXFCbits.MPEN = 0;       // Disable magic packet filtering
    ETHRXFCbits.PMMODE = 0;     // Disable pattern matching
    ETHRXFCbits.CRCERREN = 0;   // Disable CRC error collection filtering
    ETHRXFCbits.CRCOKEN = 0;    // Disable CRC filtering
    ETHRXFCbits.RUNTERREN = 0;  // Disable runt error collection filtering
    ETHRXFCbits.RUNTEN = 0;     // Disable runt filtering
    ETHRXFCbits.UCEN = 1;       // Enable unicast filtering
    ETHRXFCbits.NOTMEEN = 0;    // Disable acceptance of packets to other destinations
    ETHRXFCbits.MCEN = 0;       // Disable multicast filtering
    ETHRXFCbits.BCEN = 0;       // Disable broadcast filtering

    ETHCON2bits.RXBUF_SZ = 0x7F;    // Set RX data buffer size to 2032 bytes

    EMAC1SUPPbits.RESETRMII = 0;    // Bring the RMII module out of reset
    ETHCON1bits.ON = 1;             // Enable the ethernet module

    ETHCON1bits.RXEN = 1;       // Start receive logic

    ETHIENbits.TXBUSEIE = 1;    // Enable interrupt on transmit BVCI bus error
    ETHIENbits.RXBUSEIE = 1;    // Enable interrupt on receive BVCI bus error
//    ETHIENbits.RXDONEIE = 1;    // Enable interrupt on packet received
    ETHIENbits.PKTPENDIE = 1;   // Enable interrupt on packet pending
//    ETHIENbits.RXACTIE = 1;
    ETHIENbits.TXDONEIE = 1;    // Enable interrupt on packet sent
    ETHIENbits.TXABORTIE = 1;   // Enable interrupt on packet send aborted

    IPC12bits.ETHIP = 1;        // Set interrupt priority to 1
    IPC12bits.ETHIS = 1;        // Set intererupt sub-priority to 1
    IEC1bits.ETHIE = 1;         // Enable ethernet interrupts

    INTEnableInterrupts();
}

/* Reads from the specified register on the PHY chip */
uint16_t ETH_PHY_Read(uint8_t address, uint8_t reg) {
    EMAC1MADR = reg | (address << 8);
    EMAC1MCMDbits.READ = 1;
    Nop();Nop();Nop();
    while (EMAC1MINDbits.MIIMBUSY);
    EMAC1MCMDbits.READ = 0;
    return EMAC1MRDD;
}

/* Write to the specified register on the PHY chip */
void ETH_PHY_Write(uint8_t address, uint8_t reg, uint16_t value) {
    EMAC1MADR = reg | (address << 8);
    EMAC1MWTD = value;
    Nop();Nop();Nop();
    while (EMAC1MINDbits.MIIMBUSY);
}

/* Queries the number of pending packets */
uint8_t ETH_Recv_Queue(void) {
    return ETHSTATbits.BUFCNT;
}

/* Function to read a single packet (<2014 bytes) */
uint8_t ETH_Read_Packet(uint8_t *buffer, uint16_t *length) {
    uint16_t i, j;
    uint16_t size;
    uint8_t descriptor_index = eth_data->RX_descriptor_index;

    // Look for the first descriptor where EOWN is cleared and SOP/EOP is set
    for (i = 0; i < ETH_RX_DESCRIPTOR_COUNT; i++) {
        if ((eth_data->RX_ED_table.descriptor[descriptor_index].EOWN == 0) &&
                (eth_data->RX_ED_table.descriptor[descriptor_index].SOP == 1) &&
                (eth_data->RX_ED_table.descriptor[descriptor_index].EOP == 1)) {

            // Read the packet data values into the buffer
            size = eth_data->RX_ED_table.descriptor[descriptor_index].BYTE_COUNT - 18;
            *length = size;
            for (j = 0; j < size - 18; j++) {
                buffer[j] = eth_data->RX_ED_buffer[descriptor_index][j+14];
            }

            // Reset the descriptors
            eth_data->RX_ED_table.descriptor[descriptor_index].SOP = 0;
            eth_data->RX_ED_table.descriptor[descriptor_index].EOP = 0;
            eth_data->RX_ED_table.descriptor[descriptor_index].EOWN = 1;

            eth_data->RX_descriptor_index = (descriptor_index == ETH_RX_DESCRIPTOR_COUNT - 1) ? 0 : descriptor_index + 1;

            ETHCON1bits.BUFCDEC = 1;
            
            return 0;

        } else {
            descriptor_index = (descriptor_index == ETH_RX_DESCRIPTOR_COUNT - 1) ? 0 : descriptor_index + 1;
        }
    }

    return 1;
}

/* Function to send a single packet (<2018 bytes) */
uint8_t ETH_Write_Packet(ETH_MAC_ADDRESS dest, ETH_MAC_ADDRESS src, uint16_t length, uint8_t *buffer) {
    uint16_t i;
    uint16_t write_index = 0;
    uint16_t read_index = 0;
    uint16_t descriptor_index = eth_data->TX_descriptor_index;

    // Do a quick sanity check to ensure that we have enough memory to send the message
    if (length > ETH_TX_ED_BUFFER_SIZE - 14)
        return 1;

    // Fill the descriptor
    eth_data->TX_ED_table.descriptor[descriptor_index].TSV.registers[0] = 0;
    eth_data->TX_ED_table.descriptor[descriptor_index].TSV.registers[1] = 0;
    eth_data->TX_ED_table.descriptor[descriptor_index].EOWN = 1;
    eth_data->TX_ED_table.descriptor[descriptor_index].SOP = 1;
    eth_data->TX_ED_table.descriptor[descriptor_index].EOP = 1;

    for (i = 0; i < 6; i++) {
        eth_data->TX_ED_buffer[descriptor_index][write_index] = dest.bytes[i];
        write_index++;
    }
    for (i = 0; i < 6; i++) {
        eth_data->TX_ED_buffer[descriptor_index][write_index] = src.bytes[i];
        write_index++;
    }
    eth_data->TX_ED_buffer[descriptor_index][write_index] = length >> 8;
    eth_data->TX_ED_buffer[descriptor_index][write_index+1] = length;
    write_index += 2;


    eth_data->TX_ED_table.descriptor[descriptor_index].BYTE_COUNT = length + 14;

    for (i = 0; i < length; i++) {
        eth_data->TX_ED_buffer[descriptor_index][write_index] = buffer[read_index];
        write_index++;
        read_index++;
    }

    // Wait for any previous transmits to finish before sending
    while (ETHSTATbits.TXBUSY);
    ETHCON1bits.TXRTS = 1;
    while (ETHSTATbits.TXBUSY);

    eth_data->TX_descriptor_index = (descriptor_index == ETH_TX_DESCRIPTOR_COUNT - 1) ? 0 : descriptor_index + 1;
    
    return 0;
}

void __ISR(_ETH_VECTOR, ipl1) __ETH_Interrupt_Handler(void) {
    uint32_t value = ETHIRQ;
    if (ETHIRQbits.TXBUSE) {

        ETHIRQbits.TXBUSE = 0;
    }
    if (ETHIRQbits.RXBUSE) {

        ETHIRQbits.RXBUSE = 0;
    }
//    if (ETHIRQbits.RXDONE) {
//        ETHIRQbits.RXDONE = 0;
//    }
    if (ETHIRQbits.PKTPEND) {
        if (eth_data->rx_callback != NULL)
            (*eth_data->rx_callback)();
        ETHIRQbits.PKTPEND = 0;
    }
    if (ETHIRQbits.TXDONE) {
        if (eth_data->tx_callback != NULL)
            (*eth_data->tx_callback)();
        ETHIRQbits.TXDONE = 0;
    }
    if (ETHIRQbits.TXABORT) {

        ETHIRQbits.TXABORT = 0;
    }
    if (ETHIRQbits.RXBUFNA) {
        // This is a serious error!

        ETHIRQbits.RXBUFNA = 0;
    }
    if (ETHIRQbits.RXOVFLW) {
        // This is a serious error!

        ETHIRQbits.RXOVFLW = 0;
    }

    IFS1bits.ETHIF = 0;
}