Subversion Repositories plasma

/*--------------------------------------------------------------------
 * TITLE: Plasma Ethernet MAC
 * AUTHOR: Steve Rhoads (rhoadss@yahoo.com)
 * DATE CREATED: 1/12/08
 * FILENAME: ethernet.c
 * PROJECT: Plasma CPU core
 * COPYRIGHT: Software placed into the public domain by the author.
 *    Software 'as is' without warranty.  Author liable for nothing.
 * DESCRIPTION:
 *    Ethernet MAC implementation.
 *    Data is received from the Ethernet PHY four bits at a time. 
 *    After 32-bits are received they are written to 0x13ff0000 + N.  
 *    The data is received LSB first for each byte which requires the
 *    nibbles to be swapped.
 *    Transmit data is read from 0x13fe0000.  Write length/4+1 to
 *    ETHERNET_REG to start transfer.
 *--------------------------------------------------------------------*/
#include "plasma.h"
#include "rtos.h"
#include "tcpip.h"
 
#define POLYNOMIAL  0x04C11DB7   //CRC bit 33 is truncated
#define TOPBIT      (1<<31)
#define BYTE_EMPTY  0xde         //Data copied into receive buffer
#define COUNT_EMPTY 16           //Count to decide there isn't data
#define INDEX_MASK  0xffff       //Size of receive buffer
 
static unsigned char gDestMac[]={0x5d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
static unsigned int CrcTable[256];
static unsigned char reflect[256];
static unsigned char reflectNibble[256];
static OS_Semaphore_t *SemEthernet, *SemEthTransmit;
static int gIndex;          //byte index into 0x13ff0000 receive buffer
static int gCrcChecked;
static volatile int ethTxBusy;
 
 
//Read received data from 0x13ff0000.  Data starts with 0x5d+MACaddress.
//Data is being received while processing the data.  Therefore,
//all errors require waiting and then re-processing the data
//to see if the error is fixed by receiving the rest of the packet.
int EthernetReceive(unsigned char *buffer, int length)
{
   int count;
   int start, i, j, shift, offset, index, emptyCount;
   int byte, byteNext;
   unsigned long crc;
   int byteCrc;
   volatile unsigned char *buf = (unsigned char*)ETHERNET_RECEIVE;
   int packetExpected;
 
   while(ethTxBusy)
      OS_ThreadSleep(1);
 
   //Find the start of a frame
   packetExpected = MemoryRead(IRQ_STATUS) & IRQ_ETHERNET_RECEIVE;
   MemoryRead(ETHERNET_REG);        //clear receive interrupt
   emptyCount = 0;
 
   //Find dest MAC address
   for(offset = 0; offset <= INDEX_MASK; ++offset)
   {
      index = (gIndex + offset) & INDEX_MASK;
      byte = buf[index];
      if(byte == 0x5d)  //bit pattern 01011101
      {
         for(i = 1; i < sizeof(gDestMac); ++i)
         {
            j = (index + i) & INDEX_MASK;
            byte = buf[j];
            if(byte != 0xff && byte != gDestMac[i])
               break;
         }
         if(i == sizeof(gDestMac))
            break;    //found dest MAC
         emptyCount = 0;
      }
      else if(byte == BYTE_EMPTY)
      {
         if(packetExpected == 0 && ++emptyCount >= 4)
            return 0;
      }
      else
         emptyCount = 0;
   }
   if(offset > INDEX_MASK)
      return 0;
   while(gIndex != index)
   {
      buf[gIndex] = BYTE_EMPTY;
      gIndex = (gIndex + 1) & INDEX_MASK;
   }
 
   //Found start of frame.  Now find end of frame and check CRC.
   start = gIndex;
   gIndex = (gIndex + 1) & INDEX_MASK;           //skip 0x5d byte
   crc = 0xffffffff;
   for(count = 0; count < length; )
   {
      byte = buf[gIndex];
      gIndex = (gIndex + 1) & INDEX_MASK;
 
      byte = ((byte << 4) & 0xf0) | (byte >> 4); //swap nibbles
      buffer[count++] = (unsigned char)byte;
      byte = reflect[byte] ^ (crc >> 24);        //calculate CRC32
      crc = CrcTable[byte] ^ (crc << 8);
      if(count >= 40)
      {
         //Check if CRC matches to detect end of frame
         byteCrc = reflectNibble[crc >> 24];
         byteNext = buf[gIndex];
         if(byteCrc == byteNext)
         {
            for(i = 1; i < 4; ++i)
            {
               shift = 24 - (i << 3);
               byteCrc = reflectNibble[(crc >> shift) & 0xff];
               byteNext = buf[(gIndex + i) & 0xffff];
               if(byteCrc != byteNext)
               {
                  //printf("nope %d %d 0x%x 0x%x\n", count, i, byteCrc, byteNext);
                  i = 99;
               }
            }
            if(i == 4)
            {
               //Found end of frame -- set used bytes to BYTE_EMPTY
               //printf("Found it! %d\n", count);
               gIndex = (gIndex + 4) & INDEX_MASK;
               for(i = 0; i < count+5; ++i)
                  buf[(start + i) & INDEX_MASK] = BYTE_EMPTY;
               while(gIndex & 3)
               {
                  buf[gIndex] = BYTE_EMPTY;
                  gIndex = (gIndex + 1) & INDEX_MASK;
               }
               gCrcChecked = 0;
               return count;
            }
         }
      }
   }
   gIndex = start;
   if(++gCrcChecked > 0)     //if the CPU speed is > 25MHz, change to 1
   {
      buf[gIndex] = BYTE_EMPTY;
      gIndex = (gIndex + 1) & INDEX_MASK;
   }
   return -1;
}
 
 
//Copy transmit data to 0x13fe0000 with preamble and CRC32
void EthernetTransmit(unsigned char *buffer, int length)
{
   int i, byte, shift;
   unsigned long crc;
   volatile unsigned char *buf = (unsigned char*)ETHERNET_TRANSMIT;
 
   OS_SemaphorePend(SemEthTransmit, OS_WAIT_FOREVER);
   ethTxBusy = 1;
 
   //Wait for previous transfer to complete
   for(i = 0; i < 10000; ++i)
   {
      if(MemoryRead(IRQ_STATUS) & IRQ_ETHERNET_TRANSMIT)
         break;
   }
 
   Led(2, 2);
   while(length < 60 || (length & 3) != 0)
      buffer[length++] = 0;
 
   //Start of Ethernet frame
   for(i = 0; i < 7; ++i)
      buf[i] = 0x55;
   buf[7] = 0x5d;
 
   //Calculate CRC32
   crc = 0xffffffff;
   for(i = 0; i < length; ++i)
   {
      byte = buffer[i];
      buf[i + 8] = (unsigned char)((byte << 4) | (byte >> 4)); //swap nibbles
      byte = reflect[byte] ^ (crc >> 24);        //calculate CRC32
      crc = CrcTable[byte] ^ (crc << 8);
   }
 
   //Output CRC32
   for(i = 0; i < 4; ++i)
   {
      shift = 24 - (i << 3);
      byte = reflectNibble[(crc >> shift) & 0xff];
      buf[length + 8 + i] = (unsigned char)byte;
   }
 
   //Start transfer
   length = (length + 12 + 4) >> 2;
   MemoryWrite(ETHERNET_REG, length);
   Led(2, 0);
 
   //Wait for previous transfer to complete
   for(i = 0; i < 10000; ++i)
   {
      if(MemoryRead(IRQ_STATUS) & IRQ_ETHERNET_TRANSMIT)
         break;
   }
   ethTxBusy = 0;
 
   OS_SemaphorePost(SemEthTransmit);
}
 
 
void EthernetThread(void *arg)
{
   int length;
   int rc;
   unsigned int ticks, ticksLast=0;
   IPFrame *ethFrame=NULL;
   (void)arg;
 
   for(;;)
   {
      OS_InterruptMaskSet(IRQ_ETHERNET_RECEIVE);    //enable interrupt
      OS_SemaphorePend(SemEthernet, 50);            //wait for interrupt
 
      //Process all received packets
      for(;;)
      {
         if(ethFrame == NULL)
            ethFrame = IPFrameGet(FRAME_COUNT_RCV);
         if(ethFrame == NULL)
            break;
         length = EthernetReceive(ethFrame->packet, PACKET_SIZE);
         if(length == 0)
            break;         //no packet found
         if(length < 0)
            continue;      //CRC didn't match; process next packet
         Led(1, 1);
         rc = IPProcessEthernetPacket(ethFrame, length);
         Led(1, 0);
         if(rc)
            ethFrame = NULL;
      }
 
      ticks = OS_ThreadTime();
      if(ticks - ticksLast >= 50)
      {
         IPTick();
         ticksLast = ticks;
      }
   }
}
 
 
void EthernetIsr(void *arg)
{
   (void)arg;
   OS_InterruptMaskClear(IRQ_ETHERNET_RECEIVE);
   OS_SemaphorePost(SemEthernet);
}
 
 
/******************* CRC32 calculations **********************
 * The CRC32 code is modified from Michael Barr's article in 
 * Embedded Systems Programming January 2000.
 * A CRC is really modulo-2 binary division.  Substraction means XOR. */
static unsigned int Reflect(unsigned int value, int bits)
{
   unsigned int num=0;
   int i;
   for(i = 0; i < bits; ++i)
   {
      num = (num << 1) | (value & 1);
      value >>= 1;
   }
   return num;
}
 
 
static void CrcInit(void)
{
   unsigned int remainder;
   int dividend, bit, i;
 
   //Compute the remainder of each possible dividend
   for(dividend = 0; dividend < 256; ++dividend)
   {
      //Start with the dividend followed by zeros
      remainder = dividend << 24;
      //Perform modulo-2 division, a bit at a time
      for(bit = 8; bit > 0; --bit)
      {
         //Try to divide the current data bit
         if(remainder & TOPBIT)
            remainder = (remainder << 1) ^ POLYNOMIAL;
         else
            remainder = remainder << 1;
      }
      CrcTable[dividend] = remainder;
   }
   for(i = 0; i < 256; ++i)
   {
      reflect[i] = (unsigned char)Reflect(i, 8);
      reflectNibble[i] = (unsigned char)((Reflect((i >> 4) ^ 0xf, 4) << 4) | 
         Reflect(i ^ 0xf, 4));
   }
}
 
 
static void SpinWait(int clocks)
{
   int value = *(volatile int*)COUNTER_REG + clocks;
   while(*(volatile int*)COUNTER_REG - value < 0)
      ;
}
 
 
//Use the Ethernet MDIO bus to configure the Ethernet PHY
static int EthernetConfigure(int index, int value)
{
   unsigned int data;
   int i, bit, rc=0;
 
   //Format of SMI data: 0101 A4:A0 R4:R0 00 D15:D0
   if(value <= 0xffff)
      data = 0x5f800000;  //write
   else
      data = 0x6f800000;  //read
   data |= index << 18 | value;
 
   MemoryWrite(GPIO0_SET, ETHERNET_MDIO | ETHERNET_MDIO_WE | ETHERNET_MDC);
   for(i = 0; i < 34; ++i)
   {
      MemoryWrite(GPIO0_SET, ETHERNET_MDC);    //clock high
      SpinWait(10);
      MemoryWrite(GPIO0_CLEAR, ETHERNET_MDC);  //clock low
      SpinWait(10);
   }
   for(i = 31; i >= 0; --i)
   {
      bit = (data >> i) & 1;
      if(bit)
         MemoryWrite(GPIO0_SET, ETHERNET_MDIO);
      else
         MemoryWrite(GPIO0_CLEAR, ETHERNET_MDIO);
      SpinWait(10);         
      MemoryWrite(GPIO0_SET, ETHERNET_MDC);    //clock high
      SpinWait(10);
      rc = rc << 1 | ((MemoryRead(GPIOA_IN) >> 13) & 1);
      MemoryWrite(GPIO0_CLEAR, ETHERNET_MDC);  //clock low
      SpinWait(10);
      if(value > 0xffff && i == 17)
         MemoryWrite(GPIO0_CLEAR, ETHERNET_MDIO_WE);
   }
   MemoryWrite(GPIO0_CLEAR, ETHERNET_MDIO | ETHERNET_MDIO_WE | ETHERNET_MDC);
   return (rc >> 1) & 0xffff;
}
 
 
void EthernetInit(unsigned char MacAddress[6])
{
   int i, value;
   volatile unsigned char *buf = (unsigned char*)ETHERNET_RECEIVE;
 
   CrcInit();
   if(MacAddress)
   {
      for(i = 0; i < 6; ++i)
      {
         value = MacAddress[i];
         gDestMac[i+1] = (unsigned char)((value >> 4) | (value << 4));
      }
   }
 
   EthernetConfigure(4, 0x0061);        //advertise 10Base-T full duplex
   EthernetConfigure(0, 0x1300);        //start auto negotiation
#if 0
   OS_ThreadSleep(100);
   printf("reg4=0x%x (0x61)\n", EthernetConfigure(4, 0x10000));
   printf("reg0=0x%x (0x1100)\n", EthernetConfigure(0, 0x10000));
   printf("reg1=status=0x%x (0x7809)\n", EthernetConfigure(1, 0x10000));
   printf("reg5=partner=0x%x (0x01e1)\n", EthernetConfigure(5, 0x10000));
#endif
 
   MemoryWrite(GPIO0_CLEAR, ETHERNET_ENABLE);
 
   //Clear receive buffer
   for(i = 0; i <= INDEX_MASK; ++i)
      buf[i] = BYTE_EMPTY;
 
   if(SemEthernet == NULL)
   {
      SemEthernet = OS_SemaphoreCreate("eth", 0);
      SemEthTransmit = OS_SemaphoreCreate("ethT", 1);
      OS_ThreadCreate("eth", EthernetThread, NULL, 240, 0);
   }
 
   //Setup interrupts for receiving data
   OS_InterruptRegister(IRQ_ETHERNET_RECEIVE, EthernetIsr);
 
   //Start receive DMA
   MemoryWrite(GPIO0_SET, ETHERNET_ENABLE);
}