---

/opentcp/ethernet.c

Go to the documentation of this file.

/*
 *Copyright (c) 2000-2002 Viola Systems Ltd.
 *All rights reserved.
 *
 *Redistribution and use in source and binary forms, with or without 
 *modification, are permitted provided that the following conditions 
 *are met:
 *
 *1. Redistributions of source code must retain the above copyright 
 *notice, this list of conditions and the following disclaimer.
 *
 *2. Redistributions in binary form must reproduce the above copyright 
 *notice, this list of conditions and the following disclaimer in the 
 *documentation and/or other materials provided with the distribution.
 *
 *3. The end-user documentation included with the redistribution, if 
 *any, must include the following acknowledgment:
 *      "This product includes software developed by Viola 
 *      Systems (http://www.violasystems.com/)."
 *
 *Alternately, this acknowledgment may appear in the software itself, 
 *if and wherever such third-party acknowledgments normally appear.
 *
 *4. The names "OpenTCP" and "Viola Systems" must not be used to 
 *endorse or promote products derived from this software without prior 
 *written permission. For written permission, please contact 
 *opentcp@opentcp.org.
 *
 *5. Products derived from this software may not be called "OpenTCP", 
 *nor may "OpenTCP" appear in their name, without prior written 
 *permission of the Viola Systems Ltd.
 *
 *THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED 
 *WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
 *MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
 *IN NO EVENT SHALL VIOLA SYSTEMS LTD. OR ITS CONTRIBUTORS BE LIABLE 
 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 *CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
 *SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 
 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 *WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
 *OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 
 *EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *====================================================================
 *
 *OpenTCP is the unified open source TCP/IP stack available on a series 
 *of 8/16-bit microcontrollers, please see <http://www.opentcp.org>.
 *
 *For more information on how to network-enable your devices, or how to 
 *obtain commercial technical support for OpenTCP, please see 
 *<http://www.violasystems.com/>.
 */

#include <inet/debug.h>
#include <inet/datatypes.h>
#include <inet/system.h>
#include <inet/ethernet.h>


#include <inet/arch/config.h>

UINT8   NE2000NextPktPtr;                       
UINT8   NE2000CurrPktPtr;                       
UINT8   EtherSleep = 0; 
struct ethernet_frame received_frame;

struct ethernet_frame send_frame;


void outNE2000 (UINT8 reg , UINT8 dat)
{

        UINT8 temp = reg;
        
        DATADIR = DDR_OUT;                              /* datapins = output */
        DATABUS = dat;                          /* data to bus */
        ADRBUS =  (temp | 0x60);        /* dont change R,W,Reset pins */
        
        /* Wait until bus free */
        
        while(IOCHRDY == 0);
        
        IOW = 0;                                        /* do writestrobe */
        IOW = 1;

}       

void outNE2000again (UINT8 dat)
{
        /* Write data to same reg as outNE2000 before */
        
        DATABUS = dat;
        
        /* Wait until bus free */
        
        while(IOCHRDY == 0);
        
        IOW = 0;                                /* do writestrobe */
        IOW = 1;
 
}

UINT8 inNE2000 (UINT8 reg)
{
        UINT8 temp = reg;
        DATADIR = DDR_IN;                               /* port input */
        ADRBUS = (temp | 0x60);
        
        /* Wait until bus free */
        
        while(IOCHRDY == 0);
        
        IOR = 0;                                        /* do readstrobe */
        temp = DATABUS;
        IOR = 1;
        
        return temp;
}

UINT8 inNE2000again (void)
{
        UINT8 temp;
        
        /* Wait until bus free */
        
        while(IOCHRDY == 0);
        
        IOR = 0;
        temp = DATABUS;
        IOR = 1;
        
        return(temp);
 
}

UINT8 NE2000CheckRxFrame (void)
{
        /* Checks to see if ethernet frame has been received */
        
        UINT8 temp;
        
        outNE2000( CR ,0x62);                   /* page 1, abort DMA */
        temp = inNE2000( CURR );
        outNE2000( CR, 0x02 );                  /* page 0 */
        
        if( temp != inNE2000( BOUNDARY ) ) {
                /* Boundary != Current => packet exists */
 
                return(TRUE);
        }       
        
        return(FALSE);
 
}

void NE2000DumpRxFrame (void)
{
 
        outNE2000( CR, 0x22 );                  /* page0, abort DMA */
        
        /* Set boundary to start of next packet */
        
        outNE2000( BOUNDARY, NE2000NextPktPtr );        

 
}
 
 
void NE2000Init (UINT8* mac)
{

        /* Give HW Reset        */
        
        RESETPIN_NE2000 = 1;
        wait(10000);
        RESETPIN_NE2000 = 0;
        wait(10000);
        
        outNE2000( RESETPORT, 0 );              /* reset NE2000*/
        /* Wait for a while */
        
        wait(30000);

        
        /* Goto page 3 and set registers */
        outNE2000( CR, 0xC1 );                  /* page3, stop */
        outNE2000( 0x01, 0xC0 );                /* config reg. write enble */
        outNE2000( 0x05, 0 );                   /* link test enable */
        /* outNE2000( 0x06, 0x70 );             //Full duplex, leds */
        
        /* Goto page 1 and set registers */
        
        outNE2000( CR, 0x41 );                                                          /* page1, stop */
        outNE2000( PAR5, *mac++);                       /* Set MAC Address  */
        outNE2000( PAR4, *mac++);
        outNE2000( PAR3, *mac++);
        outNE2000( PAR2, *mac++);
        outNE2000( PAR1, *mac++);
        outNE2000( PAR0, *mac); 
        
        outNE2000( CURR, RXBUF_START ); /* Current address */
        
        /* Goto page 0 and set registers */
        
        outNE2000( CR, 0 );                                             /* page0, Stop */
        outNE2000( PSTART, RXBUF_START);                /* Rx buffer start address */
        outNE2000( PSTOP, RXBUF_END );                  /* Rx buffer end address */
        outNE2000( BOUNDARY, RXBUF_START );             /* Boundary */
        outNE2000( ISR, 0xFF );                                 /* Interrupt services */
        outNE2000( RCR, 0xD6);                                  /* Rx config (Accept all), was C4 */
        outNE2000( TCR, 0xE0);                                  /* Tx config */
        outNE2000( DCR, 0xB8);                                  /* Dataconfig */
        
        /* Start action ! */
        
        outNE2000( CR, 0x22 );                   /* Page0, start */
        
}


void NE2000CheckOverFlow (void)
{
        /* Checks if Receive Buffer overflow has happened */
        /* and re-initializes the NIC if needed                   */
        
        UINT8 temp;

        outNE2000( CR, 0x22 );                  /* page0, abort DMA */

        if( inNE2000( ISR ) & 0x10 ) {
        
                /* OverFlow occured!! */
        
                outNE2000( CR, 0x21 );          /* Issue Stop-command           */
 
                outNE2000( RBCR0, 0x00 );       /* Clear remote Byte Count      */
                outNE2000( RBCR1, 0x00 );
        
                /* Poll the interrupt status register for RST bit */
        
                kick_WD();
                while( ( inNE2000( ISR ) & 0x80 ) == 0 );

                /* RST was set, NIC is in Stop mode     */
                /* Enter to LOOPBACK mode now           */
        
                outNE2000( TCR, 0x02 );
        
                /* Issue Start Command                                                  */
                /* NIC is still inactive because LOOPBACK on    */
        
                outNE2000(CR,0x22);
        
                /* Remove Packet from buffer */
        
                NE2000DumpRxFrame();
                
                outNE2000( ISR, 0xFF );                  /* Interrupt services */
        
                /* Exit from loopback to normal mode */
        
                outNE2000( TCR, 0xE0);                   /* Tx config */
        
        }
 
}

UINT8 NE2000ReceiveFrame (void)
{

        
        if( NE2000CheckRxFrame() == FALSE ) 
                return(FALSE);

        
        /* There is data, receive Ethernet info */
        
        NE2000CurrPktPtr = inNE2000(BOUNDARY);  /* Store pointer */
        outNE2000( CR, 0x22 );                                  /* page0, abort DMA */
        
        /* Initialize DMA  to Start of the packet       */
        
        
        outNE2000( RSAR0, 0 );
        outNE2000( RSAR1, NE2000CurrPktPtr );
        outNE2000( RBCR0, 0xFF );                               /* Set DMA length for */
        outNE2000( RBCR1, 0x0F );                               /* definitely sufficient */

        outNE2000( CR, 0x0A );                                  /* page 0, remote read */
        
        inNE2000( IOPORT );                                             /* ignore receive status */
        
        NE2000NextPktPtr = inNE2000again();             /* Store pointer */
        
        /* Record Frame Size                                    */
        
        received_frame.frame_size = inNE2000again();                                    
        received_frame.frame_size |= ((UINT16)inNE2000again()) << 8;
        
        if(received_frame.frame_size > 4)
                received_frame.frame_size -= 4;                 /* Remove chip specific bytes   */
        else
                return(FALSE);
        
        /* Record destination Ethernet Address  */
        
        received_frame.destination[5] = inNE2000again();                                                
        received_frame.destination[4] = inNE2000again();
        received_frame.destination[3] = inNE2000again();
        received_frame.destination[2] = inNE2000again();
        received_frame.destination[1] = inNE2000again();
        received_frame.destination[0] = inNE2000again();
        
        /* Record senders Ethernet address              */
        
        received_frame.source[5] = inNE2000again();
        received_frame.source[4] = inNE2000again();
        received_frame.source[3] = inNE2000again();
        received_frame.source[2] = inNE2000again();
        received_frame.source[1] = inNE2000again();
        received_frame.source[0] = inNE2000again(); 
        
        /* Record Protocol      */
        
        received_frame.protocol = inNE2000again();
        received_frame.protocol <<= 8;
        received_frame.protocol |= inNE2000again();
        
        /* Give the next layer data start buffer index from the start   */
        
        received_frame.buf_index = ETH_HEADER_LEN;
        
        /* Stop DMA */
        
        outNE2000( CR, 0x22 );  
        
        ETH_DEBUGOUT("Ethernet Frame Received\n\r");
        
        return(TRUE);                                           /* Indicate we got packet */
        
}

void InitTransmission (UINT8 page)
{
        /* Initializes NE2000 for remote write                                          */
        
        while( (inNE2000(CR) & 0x04) ) ;                /* wait Tx to complete */
        
        outNE2000( CR, 0x22 );                          /* page0, abort DMA */
        
        outNE2000( TPSR, page );                        /* Tx buffer Start */
        
        outNE2000( RSAR0, 0x00 );                       /* Remote DMA start */
        outNE2000( RSAR1, page );
        
        outNE2000( RBCR0, 0xEA );                       /* Max.Ethernet frame */
        outNE2000( RBCR1, 0x05 );                       /* size */
        
        outNE2000( CR, 0x12 );                          /* page0, remote write */
        
        /* Set Address lines to be ready        */
        
        DATADIR = 0xFF;                         /* datapins = output */
        ADRBUS =  (IOPORT | 0x60);      /* dont change R,W,Reset pins */
                
        
}

void NE2000WriteEthernetHeader (struct ethernet_frame* frame)
{
        INT8 i;
        
        /* Write destination Ethernet Address   */
        
        for(i=ETH_ADDRESS_LEN-1; i >= 0; i--) {
                outNE2000again(frame->destination[i]);
        }

        /* Write sender (our) Ethernet address  */
        
        for(i=ETH_ADDRESS_LEN-1; i >= 0; i--) {
                outNE2000again(frame->source[i]);
        }
        
        /* Write protocol                                               */
        
        outNE2000again( (UINT8)(frame->protocol >> 8) );
        outNE2000again( (UINT8)frame->protocol );

}

void NE2000DMAInit (UINT8 page)
{
        
        outNE2000( CR, 0x22 );                  /* page0, abort DMA  */
        
        /* Initialize DMA  to address field in Ethernet Frame   */
        /* That is, isolate chip specific fields from                   */
        /* actual Ethernet Frame                                                                */
        
        outNE2000( RSAR0, 4 );
        outNE2000( RSAR1, page );
        outNE2000( RBCR0, 0xFF );               /* Set DMA length for */
        outNE2000( RBCR1, 0x0F );               /* definitely sufficient */
        
}

void NE2000DMAInit_position (UINT16 pos)
{
        
        UINT16 abspos;
        UINT16 page;
        UINT8 offset;
        
        /* Calculate start page */
        
        abspos = pos + 4;
        
        page = (UINT8)(abspos >> 8);
        page += NE2000CurrPktPtr;
        
        /* Check we are not exceeding the Rx buffer space       */
        
        if( page >= RXBUF_END ) {
                page = RXBUF_START + (page - RXBUF_END);
        } 
        
        offset = (UINT8)(abspos & 0xFF);
        
        /* Make settings                */
         
        outNE2000( CR, 0x22 );                  /* page0, abort DMA */
        
        /* Initialize DMA  to address field in Ethernet Frame   */
        /* That is, isolate chip specific fields from                   */
        /* actual Ethernet Frame                                                                */
        
        outNE2000( RSAR0, offset );
        outNE2000( RSAR1, (UINT8)page );
        outNE2000( RBCR0, 0xFF );               /* Set DMA length for */
        outNE2000( RBCR1, 0x0F );               /* definitely sufficient */
        
        outNE2000( CR, 0x0A );                  /* page 0, remote read */
        
        /* Init Address bus     */

        DATADIR = 0x00;                         /* port input */
        ADRBUS = (IOPORT | 0x60);
        
        /* Now just read by inNE2000again()             */
}



void NE2000SendFrame ( UINT16 len )
{
        /* After filling Tx buffer, call this function to send it */
        /* Input:       Len: packet length                                                        */

        
        /* Check if we need to insert Pad bytes */
        
        while(len < 50) {
                outNE2000again((BYTE)0x00);
                len++;
        }
        
        len += 6 + 6 + 2;
        
        outNE2000( CR, (BYTE)0x22 );                            /* Page0, abort DMA */
        
        outNE2000( TBCR0, (BYTE)(len) );
        outNE2000( TBCR1, (BYTE)(len >> 8 ) );
        
        /* Transmit packet to Ether */
        
        outNE2000( CR, (BYTE)0x06 );            /* Page0, transmit */
        
        
}

void NE2000EnterSleep (void) 
{
        if (EtherSleep)
                return;

        EtherSleep = 1;
        
        outNE2000( CR, 0xE2 );                  /* page3, abort DMA      */
        outNE2000( 0x06, 0x04);                 /* Sleep */
}

void NE2000ExitSleep (void) 
{
        if (EtherSleep) {
                outNE2000( CR, 0xE2 );                  /* age3, abort DMA       */
                outNE2000( 0x06, 0x00);                 /* Wake up */
                EtherSleep = 0;
        }
                
}

---