TM4C129 and EMAC IEEE-1588 TimeStamp Read Precision

#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include "inc/hw_gpio.h"
#include "inc/hw_memmap.h"
#include "inc/hw_sysctl.h"
#include "inc/hw_types.h"
#include "inc/hw_emac.h"
#include "driverlib/gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/pin_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/emac.h"
#include "driverlib/flash.h"
#include "inc/tm4c129encpdt.h"

//Interrupts Configuration
#define GPIO_EPINS 0x0F
#define BUFSIZ 10000
static volatile uint8_t value;
static volatile uint32_t seconds;
static volatile uint32_t subseconds;
static volatile uint32_t addptr = 0;
static volatile uint32_t remptr = 0;
static volatile uint32_t tmpptr = 0;
uint8_t valuebuf[BUFSIZ];
uint32_t secondsbuf[BUFSIZ];
uint32_t subsecondsbuf[BUFSIZ];

void
IntGPIOE(void)
{
	//Capture Timestamp
	subseconds = HWREG(EMAC0_BASE + EMAC_O_TIMNANO);
	seconds = HWREG(EMAC0_BASE + EMAC_O_TIMSEC);

	//Capture Value
	value = 0xF0;
	value |= GPIO_PORTE_AHB_DATA_R & GPIO_EPINS;

	//Clear Edge Triggered Interrupt
	GPIOIntClear(GPIO_PORTE_AHB_BASE, GPIO_EPINS);

	//Store Data in Buffers
	valuebuf[addptr] = ~value;
	secondsbuf[addptr] = seconds;
	subsecondsbuf[addptr] = subseconds;

	if (addptr < BUFSIZ - 1)
		addptr++;
	else
		addptr = 0;
};

//Ethernet Configuration
#define PKTSIZ 9
#define PKTHDR 42
uint8_t databuf[PKTHDR + PKTSIZ];
uint32_t sendbytes;
uint32_t ui32User0, ui32User1, ui32SysClock;
uint8_t ui8PHYAddr;
uint8_t pui8MACAddr[6];

#define NUM_TX_DESCRIPTORS 3
tEMACDMADescriptor g_psTxDescriptor[NUM_TX_DESCRIPTORS];
uint32_t g_ui32TxDescIndex;

void
InitDescriptors(uint32_t ui32Base)
{
	uint32_t ui32Loop;

	//Initialize each of the transmit descriptors
	for(ui32Loop = 0; ui32Loop < NUM_TX_DESCRIPTORS; ui32Loop++)
	{
		g_psTxDescriptor[ui32Loop].ui32Count = DES1_TX_CTRL_SADDR_INSERT;
		g_psTxDescriptor[ui32Loop].DES3.pLink = (ui32Loop == (NUM_TX_DESCRIPTORS - 1)) ? g_psTxDescriptor : &g_psTxDescriptor[ui32Loop + 1];
		g_psTxDescriptor[ui32Loop].ui32CtrlStatus = (DES0_TX_CTRL_LAST_SEG | DES0_TX_CTRL_FIRST_SEG | DES0_TX_CTRL_CHAINED | DES0_TX_CTRL_IP_ALL_CKHSUMS);
	}

	//Set the descriptor pointers in the hardware.
	EMACTxDMADescriptorListSet(ui32Base, g_psTxDescriptor);

	//Start from the beginning of descriptor chains
	g_ui32TxDescIndex = NUM_TX_DESCRIPTORS - 1;
}

//Transmit a packet from the supplied buffer
static int32_t
SendPacket(uint8_t *pui8Buf, int32_t i32BufLen)
{

	//Wait for the transmit descriptor to free up.
	while(g_psTxDescriptor[g_ui32TxDescIndex].ui32CtrlStatus & DES0_TX_CTRL_OWN)
	{
		//Spin and waste time.
	}

	//Move to the next descriptor.
	g_ui32TxDescIndex++;
	if(g_ui32TxDescIndex == NUM_TX_DESCRIPTORS)
	{
		g_ui32TxDescIndex = 0;
	}

	//Fill in the packet size and pointer, and tell the transmitter to start
	g_psTxDescriptor[g_ui32TxDescIndex].ui32Count = (uint32_t)i32BufLen;
	g_psTxDescriptor[g_ui32TxDescIndex].pvBuffer1 = pui8Buf;
	g_psTxDescriptor[g_ui32TxDescIndex].ui32CtrlStatus = (DES0_TX_CTRL_LAST_SEG | DES0_TX_CTRL_FIRST_SEG | DES0_TX_CTRL_IP_ALL_CKHSUMS | DES0_TX_CTRL_CHAINED | DES0_TX_CTRL_OWN);

	//Tell the DMA to reacquire the descriptor
	EMACTxDMAPollDemand(EMAC0_BASE);

	//Return the number of bytes sent.
	return(i32BufLen);
}

void
InitPacket(void)
{
	uint32_t count;

	//Clear Data Packet
	memset(&databuf[0], 0, sizeof(databuf));

	//Ethernet Destination
	for (count = 0; count < 6; count++)
	{
		databuf[count] = 0;
	}

	//Ethernet Source
	for (count = 0; count < 6; count++)
	{
		databuf[count + 6] = pui8MACAddr[count];
	}

	//Ethernet Type
	databuf[12] = 0x08;

	//IP Protocol Version, Header Length
	databuf[14] = 0x45;

	//IP Protocol Total Length (PKTHDR + PKTSIZ) - 14
	databuf[16] = 0x00;
	databuf[17] = (PKTHDR + PKTSIZ) - 14;

	//IP Flags = Do Not Fragment
	databuf[20] = 0x40;

	//IP Protocol TTL = 64
	databuf[22] = 0x40;

	//IP Protocol UDP = 17
	databuf[23] = 0x11;

	//IP Protocol Header Checksum
	databuf[24] = 0xCE;
	databuf[25] = 0x7C;

	//IP Protocol Source
	databuf[26] = 0;
	databuf[27] = 0;
	databuf[28] = 0;
	databuf[29] = 0;

	//IP Protocol Destination
	databuf[30] = 0;
	databuf[31] = 0;
	databuf[32] = 0;
	databuf[33] = 0;

	//UDP Protocol Source = Port 49999
	databuf[34] = 0xC3;
	databuf[35] = 0x4F;

	//UDP Protocol Destination = Port 49999
	databuf[36] = 0xC3;
	databuf[37] = 0x4F;

	//UDP Length = PKTSIZ + 8
	databuf[38] = 0x00;
	databuf[39] = PKTSIZ + 8;
}

int
main(void)
{
	uint32_t count, index;

	//Initialize Buffers
	memset(&valuebuf[0], 0, sizeof(valuebuf));
	memset(&secondsbuf[0], 0, sizeof(secondsbuf));
	memset(&subsecondsbuf[0], 0, sizeof(subsecondsbuf));

	//System Clock Setting
	ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000);

	//Read the MAC address from the user registers.
	FlashUserGet(&ui32User0, &ui32User1);
	if((ui32User0 == 0xffffffff) || (ui32User1 == 0xffffffff))
	{
		while(1)
		{
		}
	}

	//MAC Address into the Ethernet Controller registers.
	pui8MACAddr[0] = ((ui32User0 >> 0) & 0xff);
	pui8MACAddr[1] = ((ui32User0 >> 8) & 0xff);
	pui8MACAddr[2] = ((ui32User0 >> 16) & 0xff);
	pui8MACAddr[3] = ((ui32User1 >> 0) & 0xff);
	pui8MACAddr[4] = ((ui32User1 >> 8) & 0xff);
	pui8MACAddr[5] = ((ui32User1 >> 16) & 0xff);

	//Enable Ethernet
	SysCtlPeripheralEnable(SYSCTL_PERIPH_EMAC0);
	SysCtlPeripheralEnable(SYSCTL_PERIPH_EPHY0);
	while(!SysCtlPeripheralReady(SYSCTL_PERIPH_EMAC0));

	ui8PHYAddr = 0;
	EMACPHYConfigSet(EMAC0_BASE, (EMAC_PHY_TYPE_INTERNAL | EMAC_PHY_AN_100B_T_HALF_DUPLEX));
	EMACReset(EMAC0_BASE);
	EMACInit(EMAC0_BASE, ui32SysClock, EMAC_BCONFIG_PRIORITY_FIXED, 4, 4, 0);

	//Set MAC configuration options
	EMACConfigSet(EMAC0_BASE,
	(EMAC_CONFIG_HALF_DUPLEX |
	EMAC_CONFIG_IF_GAP_96BITS |
	EMAC_CONFIG_BO_LIMIT_1024),
	(EMAC_MODE_TX_STORE_FORWARD |
	EMAC_MODE_TX_THRESHOLD_64_BYTES), 146);

	//Initialize the Ethernet DMA descriptors.
	InitDescriptors(EMAC0_BASE);

	//Initialize UDP Packet
	InitPacket();

	//EMACFrameFilterSet(EMAC0_BASE, (EMAC_FRMFILTER_HASH_AND_PERFECT | EMAC_FRMFILTER_PASS_MULTICAST));
	EMACAddrSet(EMAC0_BASE, 0, pui8MACAddr);

	//Wait for the link to become active.
	while((EMACPHYRead(EMAC0_BASE, ui8PHYAddr, EPHY_BMSR) & EPHY_BMSR_LINKSTAT) == 0)
	{
	}

	EMACTxEnable(EMAC0_BASE);

	EMACPHYWrite(EMAC0_BASE, 0, EPHY_BMCR, (EPHY_BMCR_ANEN | EPHY_BMCR_RESTARTAN));

	//Enable IEEE-1588 Timestamps
	EMACTimestampConfigSet(EMAC0_BASE, (EMAC_TS_PTP_VERSION_2 | EMAC_TS_DIGITAL_ROLLOVER | EMAC_TS_UPDATE_FINE), 40);
	EMACTimestampAddendSet(EMAC0_BASE, 0x40000000);
	EMACTimestampEnable(EMAC0_BASE);

	//Configure Port E Inputs
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
	while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOE));
	SysCtlGPIOAHBEnable(SYSCTL_PERIPH_GPIOE);
	GPIOPinTypeGPIOInput(GPIO_PORTE_AHB_BASE, GPIO_EPINS);
	GPIOPadConfigSet(GPIO_PORTE_AHB_BASE, GPIO_EPINS, GPIO_STRENGTH_8MA, GPIO_PIN_TYPE_STD_WPU);
	GPIOIntRegister(GPIO_PORTE_AHB_BASE, IntGPIOE);
	GPIOIntTypeSet(GPIO_PORTE_AHB_BASE, GPIO_EPINS, GPIO_BOTH_EDGES);

	//Configure Port F MAC LEDS
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
	while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOF));
	GPIOPinConfigure(GPIO_PF0_EN0LED0);
	GPIOPinConfigure(GPIO_PF4_EN0LED1);
	GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4);

	//Configure Port N User LEDS
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
    while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPION));
    GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1);

    //Turn On User LED 1
    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, GPIO_PIN_1);

    //Turn Off User LED 2
    GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0);

    //Enable Interrupt on Port E
    IntPrioritySet(INT_GPIOE, 0);
    GPIOIntEnable(GPIO_PORTE_AHB_BASE, GPIO_EPINS);

    //Control Loop
    while(1)
    {
    	//Freeze Add Pointer
    	tmpptr = addptr;

    	//Check for New Data
    	if (tmpptr != remptr)
    	{
    		//Turn On LED 2
    		GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, GPIO_PIN_0);

    		//Clear Packet Data
    		for (count = PKTHDR; count < PKTHDR + PKTSIZ; count++)
    		{
    			databuf[count] = 0;
    		}

    		//Process Packet Data
    		index = PKTHDR;
    		//Copy Value
    		memcpy(&databuf[index], &valuebuf[remptr], 1);
    		index += 1;
    		//Copy Seconds
    		memcpy(&databuf[index], &secondsbuf[remptr], 4);
    		index += 4;
    		//Copy Subseconds
    		memcpy(&databuf[index], &subsecondsbuf[remptr], 4);
    		index += 4;

    		if (remptr < BUFSIZ - 1)
    			remptr++;
    		else
    			remptr = 0;

			//Send Data Packet
			sendbytes = 0;
    		sendbytes = SendPacket(&databuf[0], sizeof(databuf));

    		//Turn Off LED 2
    		GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0);
    	}
    }
}