Microchip%20TCP_IP%20stack/TCPIP%20Stack/SLIP.c

/*********************************************************************
 *
 *      Medium Access Control (MAC) Layer for Serial Line Internet 
 *  Protocol (SLIP)
 *  Module for Microchip TCP/IP Stack
 *       -Provides access to the Internet over a RS232 serial link
 *       -Reference: RFC 1055
 *
 *********************************************************************
 * FileName:        SLIP.c
 * Dependencies:    stacktsk.h
 *                  mac.h
 * Processor:       PIC18
 * Complier:        MCC18 v1.00.50 or higher
 *                  HITECH PICC-18 V8.10PL1 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * This software is owned by Microchip Technology Inc. ("Microchip") 
 * and is supplied to you for use exclusively as described in the 
 * associated software agreement.  This software is protected by 
 * software and other intellectual property laws.  Any use in 
 * violation of the software license may subject the user to criminal 
 * sanctions as well as civil liability.  Copyright 2007 Microchip
 * Technology Inc.  All rights reserved.
 *
 * This software is provided "AS IS."  MICROCHIP DISCLAIMS ALL 
 * WARRANTIES, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, NOT LIMITED 
 * TO MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND 
 * INFRINGEMENT.  Microchip shall in no event be liable for special, 
 * incidental, or consequential damages.
 *
 *
 * Author               Date    Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Nilesh Rajbharti     11/27/01 Original        (Rev 1.0)
 * Nilesh Rajbharti     2/9/02  Cleanup
 ********************************************************************/
#define THIS_IS_MAC_LAYER

#include "TCPIP Stack/TCPIP.h"

#if defined(STACK_USE_SLIP)

#define MAX_SLIP_BUFFER_SIZE    MAC_TX_BUFFER_SIZE

#if (MAX_SLIP_BUFFER_SIZE > 250)
#error Invalid MAX_SLIP_BUFFER_SIZE detected
#endif

#define BAUD_RATE               (38400)     // bps

#define USART_USE_BRGH_LOW
#if defined(USART_USE_BRGH_LOW)
    #define SPBRG_VAL           ( ((CLOCK_FREQ/BAUD_RATE)/64) - 1)
#else
    #define SPBRG_VAL           ( ((CLOCK_FREQ/BAUD_RATE)/16) - 1)
#endif

#if SPBRG_VAL > 255
    #error "Calculated SPBRG value is out of range for currnet CLOCK_FREQ."
#endif

typedef struct _SLIP_TX_BUFFER
{
    BYTE Length;
    BYTE IOAccess;
    BYTE CallerAccess;
    union
    {
        struct
        {
            unsigned int bIsModemString : 1;
        } bits;
        BYTE byte;
    } Flags;
    BYTE Data[MAX_SLIP_BUFFER_SIZE];
} SLIP_TX_BUFFER;

typedef struct _SLIP_RX_BUFFER
{
    BYTE CurrentPacket;
    BYTE PacketCount;
    BYTE IOAccess;
    BYTE CallerAccess;
    BYTE Data[MAX_SLIP_BUFFER_SIZE];        // Format: <Next>[<Data>...]
} SLIP_RX_BUFFER;

#pragma udata SLIP_TX_BUFFER_SEG = 0x400
SLIP_TX_BUFFER TxBuffer;

#pragma udata SLIP_RX_BUFFER_SEG = 0x300
SLIP_RX_BUFFER RxBuffer;

#pragma udata

static BOOL bIsRxActive;


/*
 * SLIP escape character as per RFC 1055
 */
#define END                     (0xc0)
#define ESC                     (0xdb)
#define ESC_END                 (0xdc)
#define ESC_ESC                 (0xdd)

typedef enum _SM_SLIP
{
    SM_SLIP_SOF = 0,
    SM_MODEM_CMD,
    SM_MODEM_CMD_AT,
    SM_SLIP_DATA,
    SM_SLIP_ESC,
    SM_SLIP_OVERFLOW
} SM_SLIP;

static struct
{
    BYTE    tempData;
    BYTE    currentPacket;
    SM_SLIP smSLIP;
    BYTE    currentLength;
    union
    {
        struct
        {
            unsigned int bIsDataReady   : 1;
            unsigned int bIsPacketDone  : 1;
        } bits;
        BYTE byte;
    } Flags;
} ISRLocals;


void MACISR(void)
{
    /*
     * If we have received an character, handle it.
     */
    if ( PIR1bits.RCIF && PIE1bits.RCIE )
    {
        /*
         * Check for any error, and clear it if there is any.
         */
        if ( RCSTA & 0x06 )
        {
            RCSTAbits.CREN = 0;
            RCSTAbits.CREN = 1;
            ISRLocals.smSLIP = SM_SLIP_OVERFLOW;
        }

        ISRLocals.tempData = RCREG;

        ISRLocals.Flags.bits.bIsDataReady = FALSE;

        switch(ISRLocals.smSLIP)
        {
        default:    // case SM_SLIP_SOF:
            /*
             * Remember current packet start location in a RxBuffer.
             * This will be useful when buffer overflows and we need to
             * discard packet that was overflown, keeping previously
             * loaded packets intact.
             */
            ISRLocals.currentPacket             = RxBuffer.IOAccess;
            ISRLocals.currentLength             = 0;

            if ( ISRLocals.tempData == END )
                ISRLocals.smSLIP = SM_SLIP_DATA;

            /*
             * Handle modem commands differently.
             */
            else if ( ISRLocals.tempData == 'A' )
            {
                ISRLocals.Flags.bits.bIsDataReady = TRUE;
                ISRLocals.smSLIP = SM_MODEM_CMD_AT;
            }
            break;

        case SM_MODEM_CMD:
            ISRLocals.Flags.bits.bIsDataReady = TRUE;
            if ( ISRLocals.tempData == '\r' )
            {
                ISRLocals.Flags.bits.bIsPacketDone = TRUE;
            }
            break;

        case SM_MODEM_CMD_AT:
            ISRLocals.Flags.bits.bIsDataReady = TRUE;
            if ( ISRLocals.tempData == 'T' )
                ISRLocals.smSLIP = SM_MODEM_CMD;
            else
                ISRLocals.smSLIP = SM_SLIP_OVERFLOW;
            break;

        case SM_SLIP_DATA:
            ISRLocals.Flags.bits.bIsDataReady   = TRUE;
            /*
             * If this is a escape character, wait for next
             * character to determine its value.
             */
            if ( ISRLocals.tempData == ESC )
            {
                ISRLocals.Flags.bits.bIsDataReady = FALSE;
                ISRLocals.smSLIP = SM_SLIP_ESC;
            }

            else if ( ISRLocals.tempData == END )
            {
                /*
                 * End of packet is received.
                 * Make sure that we have at least one data byte
                 * before declaring that new packet is received.
                 */
                if ( ISRLocals.currentLength )
                {
                    ISRLocals.Flags.bits.bIsPacketDone = TRUE;

                    /*
                     * Even though we are saving END character,
                     * it will be overwritten by next packet as per
                     * bIsPacketDone logic.
                     * This saves some code space as we do not have to
                     * wrap IOAccess index twice.
                     */
                }
                else
                    ISRLocals.Flags.bits.bIsDataReady = FALSE;
            }

            break;

        case SM_SLIP_ESC:
            // Save the data.
            ISRLocals.Flags.bits.bIsDataReady   = TRUE;
            ISRLocals.smSLIP                    = SM_SLIP_DATA;

            if ( ISRLocals.tempData == ESC_END )
                ISRLocals.tempData = END;

            else if ( ISRLocals.tempData == ESC_ESC )
                ISRLocals.tempData = ESC;

            else
                /*
                 * This is an invalid character sequence.
                 * Do not save it.
                 */
            {
                ISRLocals.Flags.bits.bIsDataReady = FALSE;
                ISRLocals.smSLIP = SM_SLIP_SOF;
            }
            break;

        case SM_SLIP_OVERFLOW:
            RxBuffer.IOAccess                   = ISRLocals.currentPacket;
            ISRLocals.smSLIP                    = SM_SLIP_SOF;
            break;
        }

        if ( ISRLocals.Flags.bits.bIsDataReady )
        {
            RxBuffer.IOAccess++;
            if ( RxBuffer.IOAccess >= MAX_SLIP_BUFFER_SIZE )
                RxBuffer.IOAccess = 0;

            /*
             * Make sure that we have not reached end of buffer.
             */
            if ( RxBuffer.IOAccess != RxBuffer.CurrentPacket )
            {
                ISRLocals.currentLength++;
                RxBuffer.Data[RxBuffer.IOAccess] = ISRLocals.tempData;
            }
            else
            {
                /*
                 * We have reached end of buffer.
                 * Discard this packet by restoring IOAccess to begining
                 * of current packet.
                 */
                RxBuffer.IOAccess                   = ISRLocals.currentPacket;
                ISRLocals.smSLIP                    = SM_SLIP_SOF;
                ISRLocals.Flags.bits.bIsPacketDone  = FALSE;
            }

        }

        if ( ISRLocals.Flags.bits.bIsPacketDone )
        {
            ISRLocals.Flags.bits.bIsPacketDone      = FALSE;

            /*
             * Create link to next packet.
             */
            RxBuffer.Data[ISRLocals.currentPacket]  = RxBuffer.IOAccess;
            RxBuffer.PacketCount++;

            /*
             * Start waiting for another packet.
             */
            ISRLocals.smSLIP                        = SM_SLIP_SOF;
        }
    }

    if ( PIR1bits.TXIF && PIE1bits.TXIE )
    {
        /*
         * If there is any data, transmit it.
         */
        if ( TxBuffer.Length )
        {
            ISRLocals.tempData = TxBuffer.Data[TxBuffer.IOAccess];
            if ( ISRLocals.tempData == END )
            {
                ISRLocals.tempData = ESC;
                TxBuffer.Data[TxBuffer.IOAccess] = ESC_END;
            }
            else if ( ISRLocals.tempData == ESC )
            {
                ISRLocals.tempData = ESC;
                TxBuffer.Data[TxBuffer.IOAccess] = ESC_ESC;
            }
            else
            {
                TxBuffer.Length--;
                TxBuffer.IOAccess++;
            }
            TXREG = ISRLocals.tempData;
        }
        else
        {
            /*
             * Else, disable transmit interrupt.
             */
            PIE1bits.TXIE = 0;

            if ( TxBuffer.Flags.bits.bIsModemString )
                TxBuffer.Flags.bits.bIsModemString = FALSE;
            else
                TXREG = END;

        }
    }
}

void MACInit(void)
{
    MACDiscardTx(0);

    /*
     * Initialize ISR variables.
     */
    ISRLocals.smSLIP        = SM_SLIP_SOF;
    ISRLocals.Flags.byte    = 0;

    RxBuffer.CurrentPacket  = 0;
    RxBuffer.PacketCount    = 0;
    RxBuffer.CallerAccess   = 0;
    RxBuffer.IOAccess       = 0;

    bIsRxActive = FALSE;

    /*
     * Clear receive interrupt flag.
     */
    PIR1bits.RCIF = 0;

    /*
     * Enable receive interrupt.
     * Do not enable transmit interrupt yet.  Enable it only when
     * there is something to transmit
     */
    PIE1bits.RCIE = 1;
    PIE1bits.TXIE = 0;

    /*
     * Configure USART for Asynch, 8-bit mode.
     */
#if defined(USART_USE_BRGH_LOW)
    TXSTA = 0b00100000;
#else
    TXSTA = 0b00100100;
#endif

    RCSTA = 0b10010000;
    SPBRG = SPBRG_VAL;

    /*
     * Enable global and peripheral interrupts.
     */
    INTCONbits.GIEH = 1;
    INTCONbits.GIEL = 1;

}

BOOL    MACIsTxReady(BOOL HighPriority)
{
    return ( (TxBuffer.Length < MAX_SLIP_BUFFER_SIZE) && !PIE1bits.TXIE);
}

BOOL    MACGetHeader(MAC_ADDR *remote, BYTE* type)
{
    /*
     * This marks that all future accesses to MACGet and MACPut
     * be applied to Receive buffer.
     */
    bIsRxActive = TRUE;

    if ( RxBuffer.PacketCount )
    {

        /*
         * Set up packet access index.
         */
        RxBuffer.CallerAccess = RxBuffer.CurrentPacket;

        RxBuffer.CallerAccess++;
        if ( RxBuffer.CallerAccess >= MAX_SLIP_BUFFER_SIZE )
            RxBuffer.CallerAccess = 0;


        /*
         * Handle modem commands differently.
         */
        if ( RxBuffer.Data[RxBuffer.CallerAccess] == 'A' )
        {
            /*
             * Once a modem command is detected, we are not interested
             * in detail.
             */
            MACDiscardRx();

            /*
             * Mark TxBuffer for Modem String.
             * This will make sure that Transmit ISR does nottransmit END
             * at the end.
             */
            TxBuffer.Flags.bits.bIsModemString = TRUE;

            /*
             * Since this special handling does not follow standard
             * SLIP buffer logic, we will setup all required variables
             * manually.
             */
            TxBuffer.Length = 4;
            TxBuffer.CallerAccess = 0;

            /*
             * Remember to use transmit buffer for MACPut
             */
            bIsRxActive = FALSE;

            /*
             * Now load modem response.
             */
            MACPut('O');
            MACPut('K');
            MACPut('\r');
            MACPut('\n');

            /*
             * Transmit it.
             */
            MACFlush();
        }
        else
        {
            /*
             * This was not a modem command.
             * It must be IP packet.  Mark it accordingly and return.
             */
            *type = MAC_IP;

            return TRUE;
        }
    }
    return FALSE;
}

BYTE    MACGet(void)
{
    BYTE c;

    /*
     * Depending on what buffer is active, act accordingly.
     */
    if ( bIsRxActive )
    {
        c = RxBuffer.Data[RxBuffer.CallerAccess++];
        if ( RxBuffer.CallerAccess >= MAX_SLIP_BUFFER_SIZE )
            RxBuffer.CallerAccess = 0;
    }
    else
    {
        /*
         * TxBuffer.Data contains data bytes only. There is no link byte.
         */
        c = TxBuffer.Data[TxBuffer.CallerAccess++];
    }

    return c;
}

WORD    MACGetArray(BYTE *val, WORD len)
{
    /*
     * This function does not verify requested bytes against available
     * bytes in current packet.  Higher level logic must always validate
     * packet and fetch data according to packet header.
     */

    while( len-- )
        *val++ = MACGet();
    return len;
}

void    MACDiscardRx(void)
{
    PIE1bits.RCIE = 0;

    if ( RxBuffer.PacketCount )
    {
        /*
         * Once a packet is discarded, current packet becomes next one.
         */
        RxBuffer.CurrentPacket    = RxBuffer.Data[RxBuffer.CurrentPacket];

        RxBuffer.PacketCount--;
    }

    PIE1bits.RCIE = 1;
}

void    MACPutHeader(MAC_ADDR *remote,
                     BYTE type,
                     WORD dataLen)
{
    TxBuffer.Length         = dataLen;
    TxBuffer.CallerAccess   = 0;
    bIsRxActive             = FALSE;
}

void    MACPut(BYTE val)
{
    if ( bIsRxActive )
    {
        RxBuffer.Data[RxBuffer.CallerAccess++] = val;
        if ( RxBuffer.CallerAccess >= MAX_SLIP_BUFFER_SIZE )
            RxBuffer.CallerAccess = 0;
    }
    else
    {
        TxBuffer.Data[TxBuffer.CallerAccess++] = val;
    }
}

void    MACPutArray(BYTE *val, WORD len)
{
    while( len-- )
        MACPut(*val++);
}


void    MACFlush(void)
{
    TxBuffer.CallerAccess   = 0;
    TxBuffer.IOAccess       = 0;

    if ( !TxBuffer.Flags.bits.bIsModemString )
        TXREG = END;

    PIE1bits.TXIE = 1;
}

void    MACDiscardTx(BUFFER buffer)
{
    /*
     * If there is no transmission in progress,
     * discard current buffer.
     * This is different than ethernet controller where
     * discarding transmit buffer does not affect
     * transmission that is already in progress.
     */
    if ( !PIE1bits.TXIE )
    {
        TxBuffer.Length         = 0;
        TxBuffer.CallerAccess   = 0;
        TxBuffer.IOAccess       = 0;
        TxBuffer.Flags.byte     = 0;
    }
}

void    MACSetRxBuffer(WORD offset)
{
    /*
     * Set absolute offset.
     */
    offset += RxBuffer.CurrentPacket;

    /*
     * Skip "next packet" byte.
     */
    offset++;

    /*
     * Wrap the offset if necessary.
     */
    if ( offset >= (BYTE)(MAX_SLIP_BUFFER_SIZE-1) )
        RxBuffer.CallerAccess = (BYTE)(offset - (BYTE)MAX_SLIP_BUFFER_SIZE);
    else
        RxBuffer.CallerAccess = (BYTE)offset;

    bIsRxActive = TRUE;
}

void    MACSetTxBuffer(BUFFER buffer, WORD offset)
{
    TxBuffer.CallerAccess = offset;
    bIsRxActive = FALSE;
}

void    MACReserveTxBuffer(BUFFER buffer)
{
}

WORD    MACGetFreeRxSize(void)
{
    BYTE temp;

    PIE1bits.RCIE = 0;
    temp = RxBuffer.IOAccess;
    PIE1bits.RCIE = 1;

    if ( RxBuffer.PacketCount )
    {
        if( temp > RxBuffer.CurrentPacket )
            return ((MAX_SLIP_BUFFER_SIZE -temp) + RxBuffer.CurrentPacket);
        else
            return (RxBuffer.CurrentPacket - temp);
    }
    else
        return (MAX_SLIP_BUFFER_SIZE-2);
}

BUFFER  MACGetTxBuffer(BOOL HighPriority)
{
        return 0;
}


#endif //#if defined(STACK_USE_SLIP)
1	hedin	15	/*********************************************************************
2			*
3			* Medium Access Control (MAC) Layer for Serial Line Internet
4			* Protocol (SLIP)
5			* Module for Microchip TCP/IP Stack
6			* -Provides access to the Internet over a RS232 serial link
7			* -Reference: RFC 1055
8			*
9			*********************************************************************
10			* FileName: SLIP.c
11			* Dependencies: stacktsk.h
12			* mac.h
13			* Processor: PIC18
14			* Complier: MCC18 v1.00.50 or higher
15			* HITECH PICC-18 V8.10PL1 or higher
16			* Company: Microchip Technology, Inc.
17			*
18			* Software License Agreement
19			*
20			* This software is owned by Microchip Technology Inc. ("Microchip")
21			* and is supplied to you for use exclusively as described in the
22			* associated software agreement. This software is protected by
23			* software and other intellectual property laws. Any use in
24			* violation of the software license may subject the user to criminal
25			* sanctions as well as civil liability. Copyright 2007 Microchip
26			* Technology Inc. All rights reserved.
27			*
28			* This software is provided "AS IS." MICROCHIP DISCLAIMS ALL
29			* WARRANTIES, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, NOT LIMITED
30			* TO MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
31			* INFRINGEMENT. Microchip shall in no event be liable for special,
32			* incidental, or consequential damages.
33			*
34			*
35			* Author Date Comment
36			*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
37			* Nilesh Rajbharti 11/27/01 Original (Rev 1.0)
38			* Nilesh Rajbharti 2/9/02 Cleanup
39			********************************************************************/
40			#define THIS_IS_MAC_LAYER
41
42			#include "TCPIP Stack/TCPIP.h"
43
44			#if defined(STACK_USE_SLIP)
45
46			#define MAX_SLIP_BUFFER_SIZE MAC_TX_BUFFER_SIZE
47
48			#if (MAX_SLIP_BUFFER_SIZE > 250)
49			#error Invalid MAX_SLIP_BUFFER_SIZE detected
50			#endif
51
52			#define BAUD_RATE (38400) // bps
53
54			#define USART_USE_BRGH_LOW
55			#if defined(USART_USE_BRGH_LOW)
56			#define SPBRG_VAL ( ((CLOCK_FREQ/BAUD_RATE)/64) - 1)
57			#else
58			#define SPBRG_VAL ( ((CLOCK_FREQ/BAUD_RATE)/16) - 1)
59			#endif
60
61			#if SPBRG_VAL > 255
62			#error "Calculated SPBRG value is out of range for currnet CLOCK_FREQ."
63			#endif
64
65			typedef struct _SLIP_TX_BUFFER
66			{
67			BYTE Length;
68			BYTE IOAccess;
69			BYTE CallerAccess;
70			union
71			{
72			struct
73			{
74			unsigned int bIsModemString : 1;
75			} bits;
76			BYTE byte;
77			} Flags;
78			BYTE Data[MAX_SLIP_BUFFER_SIZE];
79			} SLIP_TX_BUFFER;
80
81			typedef struct _SLIP_RX_BUFFER
82			{
83			BYTE CurrentPacket;
84			BYTE PacketCount;
85			BYTE IOAccess;
86			BYTE CallerAccess;
87			BYTE Data[MAX_SLIP_BUFFER_SIZE]; // Format: <Next>[<Data>...]
88			} SLIP_RX_BUFFER;
89
90			#pragma udata SLIP_TX_BUFFER_SEG = 0x400
91			SLIP_TX_BUFFER TxBuffer;
92
93			#pragma udata SLIP_RX_BUFFER_SEG = 0x300
94			SLIP_RX_BUFFER RxBuffer;
95
96			#pragma udata
97
98			static BOOL bIsRxActive;
99
100
101			/*
102			* SLIP escape character as per RFC 1055
103			*/
104			#define END (0xc0)
105			#define ESC (0xdb)
106			#define ESC_END (0xdc)
107			#define ESC_ESC (0xdd)
108
109			typedef enum _SM_SLIP
110			{
111			SM_SLIP_SOF = 0,
112			SM_MODEM_CMD,
113			SM_MODEM_CMD_AT,
114			SM_SLIP_DATA,
115			SM_SLIP_ESC,
116			SM_SLIP_OVERFLOW
117			} SM_SLIP;
118
119			static struct
120			{
121			BYTE tempData;
122			BYTE currentPacket;
123			SM_SLIP smSLIP;
124			BYTE currentLength;
125			union
126			{
127			struct
128			{
129			unsigned int bIsDataReady : 1;
130			unsigned int bIsPacketDone : 1;
131			} bits;
132			BYTE byte;
133			} Flags;
134			} ISRLocals;
135
136
137			void MACISR(void)
138			{
139			/*
140			* If we have received an character, handle it.
141			*/
142			if ( PIR1bits.RCIF && PIE1bits.RCIE )
143			{
144			/*
145			* Check for any error, and clear it if there is any.
146			*/
147			if ( RCSTA & 0x06 )
148			{
149			RCSTAbits.CREN = 0;
150			RCSTAbits.CREN = 1;
151			ISRLocals.smSLIP = SM_SLIP_OVERFLOW;
152			}
153
154			ISRLocals.tempData = RCREG;
155
156			ISRLocals.Flags.bits.bIsDataReady = FALSE;
157
158			switch(ISRLocals.smSLIP)
159			{
160			default: // case SM_SLIP_SOF:
161			/*
162			* Remember current packet start location in a RxBuffer.
163			* This will be useful when buffer overflows and we need to
164			* discard packet that was overflown, keeping previously
165			* loaded packets intact.
166			*/
167			ISRLocals.currentPacket = RxBuffer.IOAccess;
168			ISRLocals.currentLength = 0;
169
170			if ( ISRLocals.tempData == END )
171			ISRLocals.smSLIP = SM_SLIP_DATA;
172
173			/*
174			* Handle modem commands differently.
175			*/
176			else if ( ISRLocals.tempData == 'A' )
177			{
178			ISRLocals.Flags.bits.bIsDataReady = TRUE;
179			ISRLocals.smSLIP = SM_MODEM_CMD_AT;
180			}
181			break;
182
183			case SM_MODEM_CMD:
184			ISRLocals.Flags.bits.bIsDataReady = TRUE;
185			if ( ISRLocals.tempData == '\r' )
186			{
187			ISRLocals.Flags.bits.bIsPacketDone = TRUE;
188			}
189			break;
190
191			case SM_MODEM_CMD_AT:
192			ISRLocals.Flags.bits.bIsDataReady = TRUE;
193			if ( ISRLocals.tempData == 'T' )
194			ISRLocals.smSLIP = SM_MODEM_CMD;
195			else
196			ISRLocals.smSLIP = SM_SLIP_OVERFLOW;
197			break;
198
199			case SM_SLIP_DATA:
200			ISRLocals.Flags.bits.bIsDataReady = TRUE;
201			/*
202			* If this is a escape character, wait for next
203			* character to determine its value.
204			*/
205			if ( ISRLocals.tempData == ESC )
206			{
207			ISRLocals.Flags.bits.bIsDataReady = FALSE;
208			ISRLocals.smSLIP = SM_SLIP_ESC;
209			}
210
211			else if ( ISRLocals.tempData == END )
212			{
213			/*
214			* End of packet is received.
215			* Make sure that we have at least one data byte
216			* before declaring that new packet is received.
217			*/
218			if ( ISRLocals.currentLength )
219			{
220			ISRLocals.Flags.bits.bIsPacketDone = TRUE;
221
222			/*
223			* Even though we are saving END character,
224			* it will be overwritten by next packet as per
225			* bIsPacketDone logic.
226			* This saves some code space as we do not have to
227			* wrap IOAccess index twice.
228			*/
229			}
230			else
231			ISRLocals.Flags.bits.bIsDataReady = FALSE;
232			}
233
234			break;
235
236			case SM_SLIP_ESC:
237			// Save the data.
238			ISRLocals.Flags.bits.bIsDataReady = TRUE;
239			ISRLocals.smSLIP = SM_SLIP_DATA;
240
241			if ( ISRLocals.tempData == ESC_END )
242			ISRLocals.tempData = END;
243
244			else if ( ISRLocals.tempData == ESC_ESC )
245			ISRLocals.tempData = ESC;
246
247			else
248			/*
249			* This is an invalid character sequence.
250			* Do not save it.
251			*/
252			{
253			ISRLocals.Flags.bits.bIsDataReady = FALSE;
254			ISRLocals.smSLIP = SM_SLIP_SOF;
255			}
256			break;
257
258			case SM_SLIP_OVERFLOW:
259			RxBuffer.IOAccess = ISRLocals.currentPacket;
260			ISRLocals.smSLIP = SM_SLIP_SOF;
261			break;
262			}
263
264			if ( ISRLocals.Flags.bits.bIsDataReady )
265			{
266			RxBuffer.IOAccess++;
267			if ( RxBuffer.IOAccess >= MAX_SLIP_BUFFER_SIZE )
268			RxBuffer.IOAccess = 0;
269
270			/*
271			* Make sure that we have not reached end of buffer.
272			*/
273			if ( RxBuffer.IOAccess != RxBuffer.CurrentPacket )
274			{
275			ISRLocals.currentLength++;
276			RxBuffer.Data[RxBuffer.IOAccess] = ISRLocals.tempData;
277			}
278			else
279			{
280			/*
281			* We have reached end of buffer.
282			* Discard this packet by restoring IOAccess to begining
283			* of current packet.
284			*/
285			RxBuffer.IOAccess = ISRLocals.currentPacket;
286			ISRLocals.smSLIP = SM_SLIP_SOF;
287			ISRLocals.Flags.bits.bIsPacketDone = FALSE;
288			}
289
290			}
291
292			if ( ISRLocals.Flags.bits.bIsPacketDone )
293			{
294			ISRLocals.Flags.bits.bIsPacketDone = FALSE;
295
296			/*
297			* Create link to next packet.
298			*/
299			RxBuffer.Data[ISRLocals.currentPacket] = RxBuffer.IOAccess;
300			RxBuffer.PacketCount++;
301
302			/*
303			* Start waiting for another packet.
304			*/
305			ISRLocals.smSLIP = SM_SLIP_SOF;
306			}
307			}
308
309			if ( PIR1bits.TXIF && PIE1bits.TXIE )
310			{
311			/*
312			* If there is any data, transmit it.
313			*/
314			if ( TxBuffer.Length )
315			{
316			ISRLocals.tempData = TxBuffer.Data[TxBuffer.IOAccess];
317			if ( ISRLocals.tempData == END )
318			{
319			ISRLocals.tempData = ESC;
320			TxBuffer.Data[TxBuffer.IOAccess] = ESC_END;
321			}
322			else if ( ISRLocals.tempData == ESC )
323			{
324			ISRLocals.tempData = ESC;
325			TxBuffer.Data[TxBuffer.IOAccess] = ESC_ESC;
326			}
327			else
328			{
329			TxBuffer.Length--;
330			TxBuffer.IOAccess++;
331			}
332			TXREG = ISRLocals.tempData;
333			}
334			else
335			{
336			/*
337			* Else, disable transmit interrupt.
338			*/
339			PIE1bits.TXIE = 0;
340
341			if ( TxBuffer.Flags.bits.bIsModemString )
342			TxBuffer.Flags.bits.bIsModemString = FALSE;
343			else
344			TXREG = END;
345
346			}
347			}
348			}
349
350			void MACInit(void)
351			{
352			MACDiscardTx(0);
353
354			/*
355			* Initialize ISR variables.
356			*/
357			ISRLocals.smSLIP = SM_SLIP_SOF;
358			ISRLocals.Flags.byte = 0;
359
360			RxBuffer.CurrentPacket = 0;
361			RxBuffer.PacketCount = 0;
362			RxBuffer.CallerAccess = 0;
363			RxBuffer.IOAccess = 0;
364
365			bIsRxActive = FALSE;
366
367			/*
368			* Clear receive interrupt flag.
369			*/
370			PIR1bits.RCIF = 0;
371
372			/*
373			* Enable receive interrupt.
374			* Do not enable transmit interrupt yet. Enable it only when
375			* there is something to transmit
376			*/
377			PIE1bits.RCIE = 1;
378			PIE1bits.TXIE = 0;
379
380			/*
381			* Configure USART for Asynch, 8-bit mode.
382			*/
383			#if defined(USART_USE_BRGH_LOW)
384			TXSTA = 0b00100000;
385			#else
386			TXSTA = 0b00100100;
387			#endif
388
389			RCSTA = 0b10010000;
390			SPBRG = SPBRG_VAL;
391
392			/*
393			* Enable global and peripheral interrupts.
394			*/
395			INTCONbits.GIEH = 1;
396			INTCONbits.GIEL = 1;
397
398			}
399
400			BOOL MACIsTxReady(BOOL HighPriority)
401			{
402			return ( (TxBuffer.Length < MAX_SLIP_BUFFER_SIZE) && !PIE1bits.TXIE);
403			}
404
405			BOOL MACGetHeader(MAC_ADDR remote, BYTE type)
406			{
407			/*
408			* This marks that all future accesses to MACGet and MACPut
409			* be applied to Receive buffer.
410			*/
411			bIsRxActive = TRUE;
412
413			if ( RxBuffer.PacketCount )
414			{
415
416			/*
417			* Set up packet access index.
418			*/
419			RxBuffer.CallerAccess = RxBuffer.CurrentPacket;
420
421			RxBuffer.CallerAccess++;
422			if ( RxBuffer.CallerAccess >= MAX_SLIP_BUFFER_SIZE )
423			RxBuffer.CallerAccess = 0;
424
425
426			/*
427			* Handle modem commands differently.
428			*/
429			if ( RxBuffer.Data[RxBuffer.CallerAccess] == 'A' )
430			{
431			/*
432			* Once a modem command is detected, we are not interested
433			* in detail.
434			*/
435			MACDiscardRx();
436
437			/*
438			* Mark TxBuffer for Modem String.
439			* This will make sure that Transmit ISR does nottransmit END
440			* at the end.
441			*/
442			TxBuffer.Flags.bits.bIsModemString = TRUE;
443
444			/*
445			* Since this special handling does not follow standard
446			* SLIP buffer logic, we will setup all required variables
447			* manually.
448			*/
449			TxBuffer.Length = 4;
450			TxBuffer.CallerAccess = 0;
451
452			/*
453			* Remember to use transmit buffer for MACPut
454			*/
455			bIsRxActive = FALSE;
456
457			/*
458			* Now load modem response.
459			*/
460			MACPut('O');
461			MACPut('K');
462			MACPut('\r');
463			MACPut('\n');
464
465			/*
466			* Transmit it.
467			*/
468			MACFlush();
469			}
470			else
471			{
472			/*
473			* This was not a modem command.
474			* It must be IP packet. Mark it accordingly and return.
475			*/
476			*type = MAC_IP;
477
478			return TRUE;
479			}
480			}
481			return FALSE;
482			}
483
484			BYTE MACGet(void)
485			{
486			BYTE c;
487
488			/*
489			* Depending on what buffer is active, act accordingly.
490			*/
491			if ( bIsRxActive )
492			{
493			c = RxBuffer.Data[RxBuffer.CallerAccess++];
494			if ( RxBuffer.CallerAccess >= MAX_SLIP_BUFFER_SIZE )
495			RxBuffer.CallerAccess = 0;
496			}
497			else
498			{
499			/*
500			* TxBuffer.Data contains data bytes only. There is no link byte.
501			*/
502			c = TxBuffer.Data[TxBuffer.CallerAccess++];
503			}
504
505			return c;
506			}
507
508			WORD MACGetArray(BYTE *val, WORD len)
509			{
510			/*
511			* This function does not verify requested bytes against available
512			* bytes in current packet. Higher level logic must always validate
513			* packet and fetch data according to packet header.
514			*/
515
516			while( len-- )
517			*val++ = MACGet();
518			return len;
519			}
520
521			void MACDiscardRx(void)
522			{
523			PIE1bits.RCIE = 0;
524
525			if ( RxBuffer.PacketCount )
526			{
527			/*
528			* Once a packet is discarded, current packet becomes next one.
529			*/
530			RxBuffer.CurrentPacket = RxBuffer.Data[RxBuffer.CurrentPacket];
531
532			RxBuffer.PacketCount--;
533			}
534
535			PIE1bits.RCIE = 1;
536			}
537
538			void MACPutHeader(MAC_ADDR *remote,
539			BYTE type,
540			WORD dataLen)
541			{
542			TxBuffer.Length = dataLen;
543			TxBuffer.CallerAccess = 0;
544			bIsRxActive = FALSE;
545			}
546
547			void MACPut(BYTE val)
548			{
549			if ( bIsRxActive )
550			{
551			RxBuffer.Data[RxBuffer.CallerAccess++] = val;
552			if ( RxBuffer.CallerAccess >= MAX_SLIP_BUFFER_SIZE )
553			RxBuffer.CallerAccess = 0;
554			}
555			else
556			{
557			TxBuffer.Data[TxBuffer.CallerAccess++] = val;
558			}
559			}
560
561			void MACPutArray(BYTE *val, WORD len)
562			{
563			while( len-- )
564			MACPut(*val++);
565			}
566
567
568			void MACFlush(void)
569			{
570			TxBuffer.CallerAccess = 0;
571			TxBuffer.IOAccess = 0;
572
573			if ( !TxBuffer.Flags.bits.bIsModemString )
574			TXREG = END;
575
576			PIE1bits.TXIE = 1;
577			}
578
579			void MACDiscardTx(BUFFER buffer)
580			{
581			/*
582			* If there is no transmission in progress,
583			* discard current buffer.
584			* This is different than ethernet controller where
585			* discarding transmit buffer does not affect
586			* transmission that is already in progress.
587			*/
588			if ( !PIE1bits.TXIE )
589			{
590			TxBuffer.Length = 0;
591			TxBuffer.CallerAccess = 0;
592			TxBuffer.IOAccess = 0;
593			TxBuffer.Flags.byte = 0;
594			}
595			}
596
597			void MACSetRxBuffer(WORD offset)
598			{
599			/*
600			* Set absolute offset.
601			*/
602			offset += RxBuffer.CurrentPacket;
603
604			/*
605			* Skip "next packet" byte.
606			*/
607			offset++;
608
609			/*
610			* Wrap the offset if necessary.
611			*/
612			if ( offset >= (BYTE)(MAX_SLIP_BUFFER_SIZE-1) )
613			RxBuffer.CallerAccess = (BYTE)(offset - (BYTE)MAX_SLIP_BUFFER_SIZE);
614			else
615			RxBuffer.CallerAccess = (BYTE)offset;
616
617			bIsRxActive = TRUE;
618			}
619
620			void MACSetTxBuffer(BUFFER buffer, WORD offset)
621			{
622			TxBuffer.CallerAccess = offset;
623			bIsRxActive = FALSE;
624			}
625
626			void MACReserveTxBuffer(BUFFER buffer)
627			{
628			}
629
630			WORD MACGetFreeRxSize(void)
631			{
632			BYTE temp;
633
634			PIE1bits.RCIE = 0;
635			temp = RxBuffer.IOAccess;
636			PIE1bits.RCIE = 1;
637
638			if ( RxBuffer.PacketCount )
639			{
640			if( temp > RxBuffer.CurrentPacket )
641			return ((MAX_SLIP_BUFFER_SIZE -temp) + RxBuffer.CurrentPacket);
642			else
643			return (RxBuffer.CurrentPacket - temp);
644			}
645			else
646			return (MAX_SLIP_BUFFER_SIZE-2);
647			}
648
649			BUFFER MACGetTxBuffer(BOOL HighPriority)
650			{
651			return 0;
652			}
653
654
655			#endif //#if defined(STACK_USE_SLIP)