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
 
//void dump(const unsigned char *data, int length);
 
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 gCheckedBefore;
static int gEmptyBefore;
 
 
//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;
   int byte, byteNext;
   unsigned long crc;
   int byteCrc;
   volatile unsigned char *buf = (unsigned char*)ETHERNET_RECEIVE;
   int countEmpty, countEmptyGoal, countOk, needWait;
   int packetExpected;
 
   //Find the start of a frame
   countEmpty = 0;
   countOk = 0;
   needWait = 0;
   countEmptyGoal = COUNT_EMPTY;
   packetExpected = MemoryRead(IRQ_STATUS) & IRQ_ETHERNET_RECEIVE;
   if(packetExpected && buf[gIndex] == BYTE_EMPTY && gEmptyBefore)
   {
      //printf("Check ");
      countEmptyGoal = 1500;
   }
   MemoryRead(ETHERNET_REG);        //clear receive interrupt
   for(i = 0; i < INDEX_MASK; ++i)
   {
      //Check if partial packet possibly received
      if(needWait && gCheckedBefore == 0 && countOk != i && countEmpty != i)
      {
         gCheckedBefore = 1;
         //printf("W(%d,%d,%d)", i, countOk, countEmpty);
         return 0;                  //Wait for more data
      }
 
      //Detect start of frame
      byte = buf[(gIndex + i) & INDEX_MASK];
      if(byte == gDestMac[countOk] || (countOk && byte == 0xff))
      {
         if(++countOk == sizeof(gDestMac))
         {
            //Set bytes before 0x5d to BYTE_EMPTY
            offset = i - (int)sizeof(gDestMac);
            //if(offset > 3)
            //   printf("es%d ", offset);
            for(j = 0; j <= offset; ++j)
            {
               buf[gIndex] = BYTE_EMPTY;
               gIndex = (gIndex + 1) & INDEX_MASK;
            }
            break;
         }
      }
      else
      {
         //if(countOk)
         //   printf("N%d ", countOk);
         if(countOk == 3 && byte == BYTE_EMPTY)
            needWait = 1;
         if(byte == 0x5d)
            countOk = 1;
         else
            countOk = 0;
      }
 
      //Check if remainder of buffer is empty
      if(byte == BYTE_EMPTY)
      {
         if(++countEmpty >= countEmptyGoal)
         {
            //Set skiped bytes to BYTE_EMPTY
            //if(i - countEmpty > 3)
            //{
            //   printf("eb%d \n", i - countEmpty);
            //   //dump((char*)buf+gIndex, 0x200);
            //}
            for(j = 0; j <= i - countEmpty; ++j)
            {
               buf[gIndex] = BYTE_EMPTY;
               gIndex = (gIndex + 1) & INDEX_MASK;
            }
            gCheckedBefore = 0;
            if(countEmpty >= i && packetExpected)
               gEmptyBefore = 1;
            return 0;
         }
      }
      else
      {
         if(countEmpty > 2 || (countEmpty > 0 && countEmpty == i))
            needWait = 1;
         countEmpty = 0;
         gEmptyBefore = 0;
      }
   }
 
   //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;
               }
               gCheckedBefore = 0;
               return count;
            }
         }
      }
   }
   gIndex = start;
   if(gCheckedBefore)
   {
      //printf("CRC failure\n");
      buf[gIndex] = BYTE_EMPTY;
   }
   gCheckedBefore = 1;
   return 0;        //wait for more data
}
 
 
//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);
 
   //Wait for previous transfer to complete
   for(i = 0; i < 10000; ++i)
   {
      if(MemoryRead(IRQ_STATUS) & IRQ_ETHERNET_TRANSMIT)
         break;
   }
   //if(i > 100)
   //   printf("wait=%d ", i);
 
   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);
 
   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);
      OS_SemaphorePend(SemEthernet, 50);  //wait for interrupt
 
      //Process all received packets
      for(;;)
      {
         if(ethFrame == NULL)
            ethFrame = IPFrameGet(FRAME_COUNT_RCV);
         if(ethFrame == NULL)
         {
            OS_ThreadSleep(50);
            break;
         }
         length = EthernetReceive(ethFrame->packet, PACKET_SIZE);
         if(length == 0)
            break;
         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_TRANSMIT | IRQ_ETHERNET_RECEIVE);
   OS_SemaphorePost(SemEthernet);
}
 
 
/******************* CRC32 calculations **********************
 * The CRC32 code is modified from Michale 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)
      ;
}
 
 
void EthernetInit(unsigned char MacAddress[6])
{
   //Format of SMI data: 0101 A4:A0 R4:R0 00 D15:D0
   unsigned long data=0x5f800100; //SMI R0 = 10Mbps full duplex
   //unsigned long data=0x5f800000; //SMI R0 = 10Mbps half duplex
   int i, value;
   volatile unsigned char *buf = (unsigned char*)ETHERNET_RECEIVE;
 
   CrcInit();
   for(i = 0; i < 6; ++i)
   {
      value = MacAddress[i];
      gDestMac[i+1] = (unsigned char)((value >> 4) | (value << 4));
   }
 
   //Configure Ethernet PHY for 10Mbps full duplex via SMI interface
   MemoryWrite(GPIO0_OUT, ETHERNET_MDIO | ETHERNET_MDIO_WE | ETHERENT_MDC);
   for(i = 0; i < 34; ++i)
   {
      MemoryWrite(GPIO0_OUT, ETHERENT_MDC);    //clock high
      SpinWait(10);
      MemoryWrite(GPIO0_CLEAR, ETHERENT_MDC);  //clock low
      SpinWait(10);
   }
   for(i = 31; i >= 0; --i)
   {
      value = (data >> i) & 1;
      if(value)
         MemoryWrite(GPIO0_OUT, ETHERNET_MDIO);
      else
         MemoryWrite(GPIO0_CLEAR, ETHERNET_MDIO);
      MemoryWrite(GPIO0_OUT, ETHERENT_MDC);    //clock high
      SpinWait(10);
      MemoryWrite(GPIO0_CLEAR, ETHERENT_MDC);  //clock low
      SpinWait(10);
   }
   MemoryWrite(GPIO0_CLEAR, ETHERNET_MDIO_WE | ETHERNET_ENABLE);
 
   //Clear receive buffer
   for(i = 0; i <= INDEX_MASK; ++i)
      buf[i] = BYTE_EMPTY;
 
   //Start receive DMA
   MemoryWrite(GPIO0_OUT, ETHERNET_ENABLE);
 
   //Setup interrupts for receiving data
   SemEthernet = OS_SemaphoreCreate("eth", 0);
   SemEthTransmit = OS_SemaphoreCreate("ethT", 1);
   OS_ThreadCreate("eth", EthernetThread, NULL, 240, 0);
   OS_InterruptRegister(IRQ_ETHERNET_RECEIVE, EthernetIsr);
}