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

/*********************************************************************
 *
 *               Data I2C EEPROM Access Routines
 *
 *********************************************************************
 * FileName:        I2CEEPROM.c
 * Dependencies:    Compiler.h
 *                  XEEPROM.h
 * Processor:       PIC18
 * Complier:        Microchip C18 v3.03 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * Copyright © 2002-2007 Microchip Technology Inc.  All rights 
 * reserved.
 *
 * Microchip licenses to you the right to use, modify, copy, and 
 * distribute: 
 * (i)  the Software when embedded on a Microchip microcontroller or 
 *      digital signal controller product (“Device”) which is 
 *      integrated into Licensee’s product; or
 * (ii) ONLY the Software driver source files ENC28J60.c and 
 *      ENC28J60.h ported to a non-Microchip device used in 
 *      conjunction with a Microchip ethernet controller for the 
 *      sole purpose of interfacing with the ethernet controller. 
 *
 * You should refer to the license agreement accompanying this 
 * Software for additional information regarding your rights and 
 * obligations.
 *
 * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT 
 * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT 
 * LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
 * PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL 
 * MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR 
 * CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF 
 * PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS 
 * BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE 
 * THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER 
 * SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT 
 * (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
 *
 *
 * Author               Date        Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Nilesh Rajbharti     5/20/02     Original (Rev. 1.0)
 * Howard Schlunder             8/10/06         Renamed registers/bits to use 
 *                                                                      C18/C30 style standard names
********************************************************************/
#include "TCPIP Stack/TCPIP.h"

#if defined(MPFS_USE_EEPROM) && defined(EEPROM_SCL_TRIS) && defined(STACK_USE_MPFS)

        // 24LC256 I/O pins
        #define EEPROM_SCL_TRIS         (TRISCbits.TRISC3)
        #define EEPROM_SDA_TRIS         (TRISCbits.TRISC4)
        #define EEPROM_SCL_IO           (PORTCbits.RC3)
        #define EEPROM_SDA_IO           (PORTCbits.RC4)
        #define EEPROM_SSPBUF           (SSPBUF)
        #define EEPROM_SSPCON1          (SSPCON1)
        #define EEPROM_SSPCON1bits      (SSPCON1bits)
        #define EEPROM_SSPCON2          (SSPCON2)
        #define EEPROM_SSPCON2bits      (SSPCON2bits)
        #define EEPROM_SSPSTATbits      (SSPSTATbits)


// I2C bits are in different registers for 8-bit and 16-bit 
// microcontrollers
#if defined(__18CXX)
        #define I2CBIT_ACKDT            (EEPROM_SSPCON2bits.ACKDT)
        #define I2CBIT_ACKEN            (EEPROM_SSPCON2bits.ACKEN)
        #define I2CBIT_RCEN                     (EEPROM_SSPCON2bits.RCEN)
        #define I2CBIT_PEN                      (EEPROM_SSPCON2bits.PEN)
        #define I2CBIT_SEN                      (EEPROM_SSPCON2bits.SEN)
        #define I2CBIT_ACKSTAT          (EEPROM_SSPCON2bits.ACKSTAT)
        #define I2CBIT_TRSTAT           (EEPROM_SSPSTATbits.R_W)
//      #define I2CBIT_TRSTAT           (EEPROM_SSPSTATbits.BF)
        #define I2CBIT_IWCOL            (EEPROM_SSPCON1bits.WCOL)
        #define I2C_DATA_IN                     (EEPROM_SSPBUF)
        #define I2C_DATA_OUT            (EEPROM_SSPBUF)
#elif defined(__C30__)
        #define I2CBIT_ACKDT            (EEPROM_I2CCONbits.ACKDT)
        #define I2CBIT_ACKEN            (EEPROM_I2CCONbits.ACKEN)
        #define I2CBIT_RCEN                     (EEPROM_I2CCONbits.RCEN)
        #define I2CBIT_PEN                      (EEPROM_I2CCONbits.PEN)
        #define I2CBIT_SEN                      (EEPROM_I2CCONbits.SEN)
        #define I2CBIT_ACKSTAT          (EEPROM_I2CSTATbits.ACKSTAT)
        #define I2CBIT_TRSTAT           (EEPROM_I2CSTATbits.TRSTAT)
        #define I2CBIT_IWCOL            (EEPROM_I2CSTATbits.IWCOL)
        #define I2C_DATA_IN                     (EEPROM_I2CRCV)
        #define I2C_DATA_OUT            (EEPROM_I2CTRN)
#endif


#define READ    (0x01)
#define WRITE   (0x00)

static BOOL NeedACK = FALSE;
static BOOL NeedEndRead = FALSE;
static BOOL NeedEndWrite = FALSE;


static void Delayus(BYTE v);
static void I2CStart(void);
static void I2CStop(void);
static void I2CAck(BOOL Not);
static BOOL I2CPut(BYTE c);
static BYTE I2CGet(void);

static void Delayus(BYTE v)
{
        while(v--)
        {
                Nop();
        }
}


static void I2CStart(void)
{
        EEPROM_SCL_TRIS = 1;    // Clock line must be high
        while(EEPROM_SCL_IO == 0);      
        Delayus(3);

        // Generate a start condition
        EEPROM_SDA_TRIS = 0;
        Delayus(3);     
}

static void I2CStop(void)
{
        // Pull data low
        EEPROM_SDA_TRIS = 0;
        Delayus(1);


        EEPROM_SCL_TRIS = 1;    // Clock line must be high
        while(EEPROM_SCL_IO == 0);      
        Delayus(3);

        // Generate a stop condition
        EEPROM_SDA_TRIS = 1;
        Delayus(3);     
}

static void I2CAck(BOOL Not)
{
        // Generate the (N)Ack
        EEPROM_SDA_TRIS = Not;
        Delayus(3);     

        EEPROM_SCL_TRIS = 1;    // Release the clock
        while(EEPROM_SCL_IO == 0);      
        Delayus(3);     

        EEPROM_SCL_TRIS = 0;    // Pull clock low
        Delayus(1);     
        EEPROM_SDA_TRIS = 1;
        Delayus(3);     
}

static BOOL I2CPut(BYTE c)
{
        BYTE i;

        EEPROM_SCL_TRIS = 0;    // Clock line must be low
        Delayus(1);

        for(i = 0; i < 8; i++)
        {       
                // Generate the data bit
                EEPROM_SDA_TRIS = ((BYTE_VAL*)&c)->bits.b7;
                Delayus(3);
                EEPROM_SCL_TRIS = 1;    // Release the clock    
                while(EEPROM_SCL_IO == 0);      
                Delayus(3);
                EEPROM_SCL_TRIS = 0;    // Pull clock low
                Delayus(1);
                c <<= 1;
        }
        
        // Read the ACK response
        EEPROM_SDA_TRIS = 1;
        Delayus(3);
        
        EEPROM_SCL_TRIS = 1;    // Release the clock    
        while(EEPROM_SCL_IO == 0);      
        Delayus(1);
        i = EEPROM_SDA_IO;
        Delayus(1);
        i += EEPROM_SDA_IO;
        Delayus(1);
        i += EEPROM_SDA_IO;
        
        EEPROM_SCL_TRIS = 0;    // Pull clock low
        Delayus(3);

        return i >= 2;
}


static BYTE I2CGet(void)
{
        BYTE i;
        BYTE c;

        EEPROM_SCL_TRIS = 0;    // Clock line must be low
        Delayus(1);
        EEPROM_SDA_TRIS = 1;
        Delayus(3);

        for(i = 0; i < 8; i++)
        {
                EEPROM_SCL_TRIS = 1;    // Release the clock
                while(EEPROM_SCL_IO == 0);      
                Delayus(3);
        
                // Get the data bit
                c <<= 1;
                ((BYTE_VAL*)&c)->bits.b0 = EEPROM_SDA_IO;
                EEPROM_SCL_TRIS = 0;    // Pull clock low
                Delayus(3);
        }

        return c;
}

void XEEInit(void)
{
        LATCbits.LATC3 = 0;
        LATCbits.LATC4 = 0;
//      EEPROM_SCL_IO = 0;
//      EEPROM_SDA_IO = 0;
        EEPROM_SCL_TRIS = 1;            // Set SCL pin to output
        EEPROM_SDA_TRIS = 1;            // Set SDA pin to input
}

XEE_RESULT XEEBeginWrite(XEE_ADDR address)
{
        if(NeedEndRead)
                while(1);
        if(NeedEndWrite)
                while(1);

        while(XEEIsBusy());

        NeedEndWrite = TRUE;

        // Generate a start condition
        I2CStart();

        // Send "control" byte with device address to slave
        if(I2CPut(EEPROM_CONTROL | WRITE))
                while(1);
        // Send address bytes
        if(I2CPut(((WORD_VAL*)&address)->v[1]))
                while(1);
        if(I2CPut(((WORD_VAL*)&address)->v[0]))
                while(1);
        
        return XEE_SUCCESS;
}

XEE_RESULT XEEBeginRead(XEE_ADDR address)
{
        // Set the address to read from.  This procedure is identical 
        // for reading and writing.
        XEEBeginWrite(address);

        NeedEndRead = TRUE;
        NeedEndWrite = FALSE;

        // Generate a start condition
        I2CStart();

        // Send "control" byte with device address to slave
        if(I2CPut(EEPROM_CONTROL | READ))
                while(1);
        
        return XEE_SUCCESS;
}

XEE_RESULT XEEEndWrite(void)
{
        if(!NeedEndWrite)
                while(1);
        if(NeedEndRead)
                while(1);

        NeedEndWrite = FALSE;

        // Generate a STOP condition
        I2CStop();
}

XEE_RESULT XEEWrite(unsigned char val)
{
        if(!NeedEndWrite)
                while(1);
        if(NeedEndRead)
                while(1);

        // Send data byte
        if(I2CPut(val))
                while(1);

        return XEE_SUCCESS;
}

unsigned char XEERead(void)
{
        if(NeedEndWrite)
                while(1);
        if(!NeedEndRead)
                while(1);

        if(NeedACK)
        {
                NeedACK = FALSE;
                I2CAck(FALSE);
        }

        NeedACK = TRUE;

        // Receive a byte       
        return I2CGet();
}

XEE_RESULT XEEEndRead(void)
{
        if(NeedEndWrite)
                while(1);
        if(!NeedEndRead)
                while(1);

        NeedEndRead = FALSE;

        // Send a NACK to complete the read
        I2CAck(TRUE);
        NeedACK = FALSE;

        // Generate a STOP condition
        I2CStop();

        DelayMs(1);//TODO: debug

    return XEE_SUCCESS;
}

XEE_RESULT XEEReadArray(XEE_ADDR address, unsigned char *buffer, unsigned char length)
{
    XEEBeginRead(address);
    while(length--)
        *buffer++ = XEERead();
    XEEEndRead();

    return XEE_SUCCESS;
}

BOOL XEEIsBusy(void)
{
        BOOL i;

        if(NeedEndWrite)
                while(1);
        if(NeedEndRead)
                while(1);

        // Generate a start condition
        I2CStart();

        // Send "control" byte with device address to slave
        i = I2CPut(EEPROM_CONTROL | WRITE);

        // Generate a STOP condition
        I2CStop();

        return i;
}


//
///*********************************************************************
// * Function:        void XEEInit(unsigned char baud)
// *
// * PreCondition:    None
// *
// * Input:           baud    - SSPADD value for bit rate.
// *
// * Output:          None
// *
// * Side Effects:    None
// *
// * Overview:        Initialize I2C module to communicate to serial
// *                  EEPROM.
// *
// * Note:            None
// ********************************************************************/
//void XEEInit(BYTE baud)
//{
//
//#if defined(__18CXX)
//      EEPROM_SCL_TRIS = 1;            // Set SCL pin to output
//      EEPROM_SDA_TRIS = 1;            // Set SDA pin to input
//      SSPCON1 = 0x28;                         // Set SSPEN and set I2C Master mode
//      SSPADD = (INSTR_FREQ+I2CBAUD/2)/I2CBAUD - 1;
//#elif defined(__C30__)
//      EEPROM_I2CCONbits.I2CEN = 1;
//      #if defined(__dsPIC30F__)       
//              I2CBRG = ((INSTR_FREQ+I2CBAUD/2)/I2CBAUD - (INSTR_FREQ+1111111/2)/1111111)-1; //dsPIC30F only
//      #else                                           
//              I2CBRG = (INSTR_FREQ+I2CBAUD)/(2*I2CBAUD)-1     // PIC24, dsPIC33
//      #endif
//#endif
//}
//
//
///*********************************************************************
// * Macro:           XEE_RESULT XEEBeginWrite(XEE_ADDR address)
// *
// * PreCondition:    XEEInit() is already called.
// *
// * Input:           control     - data EEPROM control code
// *                  address     - address to where to write
// *
// * Output:          XEE_SUCCESS if successful
// *                  other value if failed.
// *
// * Side Effects:    None
// *
// * Overview:        Sets up internal address counter of EEPROM.
// *
// * Note:            This function does not release the I2C bus.
// *                  User must close XEEEndWrite() after this function
// *                  is called to relase the I2C bus.
// ********************************************************************/
//XEE_RESULT XEEBeginWrite(BYTE control, XEE_ADDR address)
//{
//      if(NeedEndRead)
//              while(1);
//      if(NeedEndWrite)
//              while(1);
//
//      NeedEndWrite = TRUE;
//
//      // Generate a start condition
//      I2CBIT_SEN = 1;
//    while(I2CBIT_SEN);
//
//      // Send "control" byte with device address to slave
//      do
//      {
//              I2CBIT_IWCOL = 0;
//              I2C_DATA_OUT = EEPROM_CONTROL | WRITE;
//      } while(I2CBIT_IWCOL);
//      while(I2CBIT_TRSTAT);
//      if(I2CBIT_ACKSTAT)
//              while(1);
//
//      // Send address bytes
//      do
//      {
//              I2CBIT_IWCOL = 0;
//              I2C_DATA_OUT = ((WORD_VAL*)&address)->v[1];
//      } while(I2CBIT_IWCOL);
//      while(I2CBIT_TRSTAT);
//      if(I2CBIT_ACKSTAT)
//              while(1);
//      do
//      {
//              I2CBIT_IWCOL = 0;
//              I2C_DATA_OUT = ((WORD_VAL*)&address)->v[0];
//      } while(I2CBIT_IWCOL);
//      while(I2CBIT_TRSTAT);
//      if(I2CBIT_ACKSTAT)
//              while(1);
//      
//      return XEE_SUCCESS;
//}
//
///*********************************************************************
// * Function:        XEE_RESULT XEEBeginRead(XEE_ADDR address)
// *
// * PreCondition:    XEEInit() is already called.
// *
// * Input:           control - EEPROM control and address code.
// *                  address - Address at which read is to be performed.
// *
// * Output:          XEE_SUCCESS if successful
// *                  other value if failed.
// *
// * Side Effects:    None
// *
// * Overview:        Sets internal address counter to given address.
// *                  Puts EEPROM in sequential read mode.
// *
// * Note:            This function does not release I2C bus.
// *                  User must call XEEEndRead() when read is not longer
// *                  needed; I2C bus will released after XEEEndRead()
// *                  is called.
// ********************************************************************/
//XEE_RESULT XEEBeginRead(BYTE control, XEE_ADDR address)
//{
//      if(NeedEndWrite)
//              while(1);
//      if(NeedEndRead)
//              while(1);
//
//
//      // Set the address to read from.  This procedure is identical 
//      // for reading and writing.
//      XEEBeginWrite(0, address);
//
//      NeedEndRead = TRUE;
//      NeedEndWrite = FALSE;
//
////    // Generate a STOP condition
////    I2CBIT_PEN = 1;
////    while(I2CBIT_PEN);
//
//
//      EEPROM_SCL_TRIS = 1;
//
//      // Generate a start condition
//      I2CBIT_SEN = 1;
//    while(I2CBIT_SEN);
//
//      // Send "control" byte with device address to slave
//      do
//      {
//              I2CBIT_IWCOL = 0;
//              I2C_DATA_OUT = EEPROM_CONTROL | READ;
//      } while(I2CBIT_IWCOL);
//      while(I2CBIT_TRSTAT);
//      if(I2CBIT_ACKSTAT)
//              while(1);
//      
//      return XEE_SUCCESS;
//}
//
//
//XEE_RESULT XEEWrite(unsigned char val)
//{
//      if(!NeedEndWrite)
//              while(1);
//      if(NeedEndRead)
//              while(1);
//
//      // Send data byte
//      do
//      {
//              I2CBIT_IWCOL = 0;
//              I2C_DATA_OUT = val;
//      } while(I2CBIT_IWCOL);
//      while(I2CBIT_TRSTAT);
//      if(I2CBIT_ACKSTAT)
//              while(1);
//
//      return XEE_SUCCESS;
//}
//
///*********************************************************************
// * Function:        XEE_RESULT XEEEndWrite(void)
// *
// * PreCondition:    XEEInit() && XEEBeginWrite() are already called.
// *
// * Input:           None
// *
// * Output:          XEE_SUCCESS if successful
// *                  other value if failed.
// *
// * Side Effects:    None
// *
// * Overview:        Instructs EEPROM to begin write cycle.
// *
// * Note:            Call this function after either page full of bytes
// *                  written or no more bytes are left to load.
// *                  This function initiates the write cycle.
// *                  User must call for XEEWait() to ensure that write
// *                  cycle is finished before calling any other
// *                  routine.
// ********************************************************************/
//XEE_RESULT XEEEndWrite(void)
//{
//      if(!NeedEndWrite)
//              while(1);
//      if(NeedEndRead)
//              while(1);
//
//      NeedEndWrite = FALSE;
//
//      // Generate a STOP condition
//      I2CBIT_PEN = 1;
//      while(I2CBIT_PEN);
//
//      DelayMs(5);
//
//}
//
//
//
///*********************************************************************
// * Function:        XEE_RESULT XEERead(void)
// *
// * PreCondition:    XEEInit() && XEEBeginRead() are already called.
// *
// * Input:           None
// *
// * Output:          XEE_SUCCESS if successful
// *                  other value if failed.
// *
// * Side Effects:    None
// *
// * Overview:        Reads next byte from EEPROM; internal address
// *                  is incremented by one.
// *
// * Note:            This function does not release I2C bus.
// *                  User must call XEEEndRead() when read is not longer
// *                  needed; I2C bus will released after XEEEndRead()
// *                  is called.
// ********************************************************************/
//unsigned char XEERead(void)
//{
//      volatile BYTE i;
//      
//      if(NeedEndWrite)
//              while(1);
//      if(!NeedEndRead)
//              while(1);
//
//      if(NeedACK)
//      {
//              NeedACK = FALSE;
//              I2CBIT_ACKDT = 0;
//              I2CBIT_ACKEN = 1;
//              while(I2CBIT_ACKEN);
//      }
//
//      // Receive a byte
//      I2CBIT_RCEN = 1;
//      while(I2CBIT_RCEN);
//      NeedACK = TRUE;
//
//      i = I2C_DATA_IN;
//    return i;
//}
//
///*********************************************************************
// * Function:        XEE_RESULT XEEEndRead(void)
// *
// * PreCondition:    XEEInit() && XEEBeginRead() are already called.
// *
// * Input:           None
// *
// * Output:          XEE_SUCCESS if successful
// *                  other value if failed.
// *
// * Side Effects:    None
// *
// * Overview:        Ends sequential read cycle.
// *
// * Note:            This function ends seuential cycle that was in
// *                  progress.  It releases I2C bus.
// ********************************************************************/
//XEE_RESULT XEEEndRead(void)
//{
//      if(NeedEndWrite)
//              while(1);
//      if(!NeedEndRead)
//              while(1);
//
//      NeedEndRead = FALSE;
//
//      // Send a NACK to complete the read
//      I2CBIT_ACKDT = 1;
//      I2CBIT_ACKEN = 1;
//      while(I2CBIT_ACKEN);
//      NeedACK = FALSE;
//
//      // Generate a STOP condition
//      I2CBIT_PEN = 1;
//      while(I2CBIT_PEN);
//
//    return XEE_SUCCESS;
//}
//
//
///*********************************************************************
// * Function:        XEE_RESULT XEEReadArray(XEE_ADDR address,
// *                                          unsigned char *buffer,
// *                                          unsigned char length)
// *
// * PreCondition:    XEEInit() is already called.
// *
// * Input:           control     - EEPROM control and address code.
// *                  address     - Address from where array is to be read
// *                  buffer      - Caller supplied buffer to hold the data
// *                  length      - Number of bytes to read.
// *
// * Output:          XEE_SUCCESS if successful
// *                  other value if failed.
// *
// * Side Effects:    None
// *
// * Overview:        Reads desired number of bytes in sequential mode.
// *                  This function performs all necessary steps
// *                  and releases the bus when finished.
// *
// * Note:            None
// ********************************************************************/
//XEE_RESULT XEEReadArray(BYTE control, XEE_ADDR address,
//                        unsigned char *buffer,
//                        unsigned char length)
//{
//    XEEBeginRead(0, address);
//    while(length--)
//        *buffer++ = XEERead();
//    XEEEndRead();
//
//    return XEE_SUCCESS;
//}
//
//
///*********************************************************************
// * Function:        BOOL XEEIsBusy(void)
// *
// * PreCondition:    XEEInit() is already called.
// *
// * Input:           None
// *
// * Output:          FALSE if EEPROM is not busy
// *                  TRUE if EEPROM is busy or operation failed
// *
// * Side Effects:    None
// *
// * Overview:        Requests ACK from EEPROM.
// *
// * Note:            None
// ********************************************************************/
//BOOL XEEIsBusy(BYTE control)
//{
//      if(NeedEndWrite)
//              while(1);
//      if(NeedEndRead)
//              while(1);
//
//      // Generate a start condition
//      I2CBIT_SEN = 1;
//    while(I2CBIT_SEN);
//
//      // Send "control" byte with device address to slave
//      do
//      {
//              I2CBIT_IWCOL = 0;
//              I2C_DATA_OUT = EEPROM_CONTROL | WRITE;
//      } while(I2CBIT_IWCOL);
//      while(I2CBIT_TRSTAT);
//
//      // Generate a STOP condition
//      I2CBIT_PEN = 1;
//      while(I2CBIT_PEN);
//
//      return I2CBIT_ACKSTAT;
//}
//

#endif //#if defined(MPFS_USE_EEPROM) && defined(EEPROM_SCL_TRIS) && defined(STACK_USE_MPFS)
1	/*********************************************************************
2	*
3	* Data I2C EEPROM Access Routines
4	*
5	*********************************************************************
6	* FileName: I2CEEPROM.c
7	* Dependencies: Compiler.h
8	* XEEPROM.h
9	* Processor: PIC18
10	* Complier: Microchip C18 v3.03 or higher
11	* Company: Microchip Technology, Inc.
12	*
13	* Software License Agreement
14	*
15	* Copyright © 2002-2007 Microchip Technology Inc. All rights
16	* reserved.
17	*
18	* Microchip licenses to you the right to use, modify, copy, and
19	* distribute:
20	* (i) the Software when embedded on a Microchip microcontroller or
21	* digital signal controller product (“Device”) which is
22	* integrated into Licensee’s product; or
23	* (ii) ONLY the Software driver source files ENC28J60.c and
24	* ENC28J60.h ported to a non-Microchip device used in
25	* conjunction with a Microchip ethernet controller for the
26	* sole purpose of interfacing with the ethernet controller.
27	*
28	* You should refer to the license agreement accompanying this
29	* Software for additional information regarding your rights and
30	* obligations.
31	*
32	* THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT
33	* WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
34	* LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
35	* PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
36	* MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
37	* CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
38	* PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
39	* BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
40	* THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
41	* SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
42	* (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
43	*
44	*
45	* Author Date Comment
46	*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
47	* Nilesh Rajbharti 5/20/02 Original (Rev. 1.0)
48	* Howard Schlunder 8/10/06 Renamed registers/bits to use
49	* C18/C30 style standard names
50	********************************************************************/
51	#include "TCPIP Stack/TCPIP.h"
52
53	#if defined(MPFS_USE_EEPROM) && defined(EEPROM_SCL_TRIS) && defined(STACK_USE_MPFS)
54
55	// 24LC256 I/O pins
56	#define EEPROM_SCL_TRIS (TRISCbits.TRISC3)
57	#define EEPROM_SDA_TRIS (TRISCbits.TRISC4)
58	#define EEPROM_SCL_IO (PORTCbits.RC3)
59	#define EEPROM_SDA_IO (PORTCbits.RC4)
60	#define EEPROM_SSPBUF (SSPBUF)
61	#define EEPROM_SSPCON1 (SSPCON1)
62	#define EEPROM_SSPCON1bits (SSPCON1bits)
63	#define EEPROM_SSPCON2 (SSPCON2)
64	#define EEPROM_SSPCON2bits (SSPCON2bits)
65	#define EEPROM_SSPSTATbits (SSPSTATbits)
66
67
68	// I2C bits are in different registers for 8-bit and 16-bit
69	// microcontrollers
70	#if defined(__18CXX)
71	#define I2CBIT_ACKDT (EEPROM_SSPCON2bits.ACKDT)
72	#define I2CBIT_ACKEN (EEPROM_SSPCON2bits.ACKEN)
73	#define I2CBIT_RCEN (EEPROM_SSPCON2bits.RCEN)
74	#define I2CBIT_PEN (EEPROM_SSPCON2bits.PEN)
75	#define I2CBIT_SEN (EEPROM_SSPCON2bits.SEN)
76	#define I2CBIT_ACKSTAT (EEPROM_SSPCON2bits.ACKSTAT)
77	#define I2CBIT_TRSTAT (EEPROM_SSPSTATbits.R_W)
78	// #define I2CBIT_TRSTAT (EEPROM_SSPSTATbits.BF)
79	#define I2CBIT_IWCOL (EEPROM_SSPCON1bits.WCOL)
80	#define I2C_DATA_IN (EEPROM_SSPBUF)
81	#define I2C_DATA_OUT (EEPROM_SSPBUF)
82	#elif defined(__C30__)
83	#define I2CBIT_ACKDT (EEPROM_I2CCONbits.ACKDT)
84	#define I2CBIT_ACKEN (EEPROM_I2CCONbits.ACKEN)
85	#define I2CBIT_RCEN (EEPROM_I2CCONbits.RCEN)
86	#define I2CBIT_PEN (EEPROM_I2CCONbits.PEN)
87	#define I2CBIT_SEN (EEPROM_I2CCONbits.SEN)
88	#define I2CBIT_ACKSTAT (EEPROM_I2CSTATbits.ACKSTAT)
89	#define I2CBIT_TRSTAT (EEPROM_I2CSTATbits.TRSTAT)
90	#define I2CBIT_IWCOL (EEPROM_I2CSTATbits.IWCOL)
91	#define I2C_DATA_IN (EEPROM_I2CRCV)
92	#define I2C_DATA_OUT (EEPROM_I2CTRN)
93	#endif
94
95
96	#define READ (0x01)
97	#define WRITE (0x00)
98
99	static BOOL NeedACK = FALSE;
100	static BOOL NeedEndRead = FALSE;
101	static BOOL NeedEndWrite = FALSE;
102
103
104	static void Delayus(BYTE v);
105	static void I2CStart(void);
106	static void I2CStop(void);
107	static void I2CAck(BOOL Not);
108	static BOOL I2CPut(BYTE c);
109	static BYTE I2CGet(void);
110
111	static void Delayus(BYTE v)
112	{
113	while(v--)
114	{
115	Nop();
116	}
117	}
118
119
120	static void I2CStart(void)
121	{
122	EEPROM_SCL_TRIS = 1; // Clock line must be high
123	while(EEPROM_SCL_IO == 0);
124	Delayus(3);
125
126	// Generate a start condition
127	EEPROM_SDA_TRIS = 0;
128	Delayus(3);
129	}
130
131	static void I2CStop(void)
132	{
133	// Pull data low
134	EEPROM_SDA_TRIS = 0;
135	Delayus(1);
136
137
138	EEPROM_SCL_TRIS = 1; // Clock line must be high
139	while(EEPROM_SCL_IO == 0);
140	Delayus(3);
141
142	// Generate a stop condition
143	EEPROM_SDA_TRIS = 1;
144	Delayus(3);
145	}
146
147	static void I2CAck(BOOL Not)
148	{
149	// Generate the (N)Ack
150	EEPROM_SDA_TRIS = Not;
151	Delayus(3);
152
153	EEPROM_SCL_TRIS = 1; // Release the clock
154	while(EEPROM_SCL_IO == 0);
155	Delayus(3);
156
157	EEPROM_SCL_TRIS = 0; // Pull clock low
158	Delayus(1);
159	EEPROM_SDA_TRIS = 1;
160	Delayus(3);
161	}
162
163	static BOOL I2CPut(BYTE c)
164	{
165	BYTE i;
166
167	EEPROM_SCL_TRIS = 0; // Clock line must be low
168	Delayus(1);
169
170	for(i = 0; i < 8; i++)
171	{
172	// Generate the data bit
173	EEPROM_SDA_TRIS = ((BYTE_VAL*)&c)->bits.b7;
174	Delayus(3);
175	EEPROM_SCL_TRIS = 1; // Release the clock
176	while(EEPROM_SCL_IO == 0);
177	Delayus(3);
178	EEPROM_SCL_TRIS = 0; // Pull clock low
179	Delayus(1);
180	c <<= 1;
181	}
182
183	// Read the ACK response
184	EEPROM_SDA_TRIS = 1;
185	Delayus(3);
186
187	EEPROM_SCL_TRIS = 1; // Release the clock
188	while(EEPROM_SCL_IO == 0);
189	Delayus(1);
190	i = EEPROM_SDA_IO;
191	Delayus(1);
192	i += EEPROM_SDA_IO;
193	Delayus(1);
194	i += EEPROM_SDA_IO;
195
196	EEPROM_SCL_TRIS = 0; // Pull clock low
197	Delayus(3);
198
199	return i >= 2;
200	}
201
202
203	static BYTE I2CGet(void)
204	{
205	BYTE i;
206	BYTE c;
207
208	EEPROM_SCL_TRIS = 0; // Clock line must be low
209	Delayus(1);
210	EEPROM_SDA_TRIS = 1;
211	Delayus(3);
212
213	for(i = 0; i < 8; i++)
214	{
215	EEPROM_SCL_TRIS = 1; // Release the clock
216	while(EEPROM_SCL_IO == 0);
217	Delayus(3);
218
219	// Get the data bit
220	c <<= 1;
221	((BYTE_VAL*)&c)->bits.b0 = EEPROM_SDA_IO;
222	EEPROM_SCL_TRIS = 0; // Pull clock low
223	Delayus(3);
224	}
225
226	return c;
227	}
228
229	void XEEInit(void)
230	{
231	LATCbits.LATC3 = 0;
232	LATCbits.LATC4 = 0;
233	// EEPROM_SCL_IO = 0;
234	// EEPROM_SDA_IO = 0;
235	EEPROM_SCL_TRIS = 1; // Set SCL pin to output
236	EEPROM_SDA_TRIS = 1; // Set SDA pin to input
237	}
238
239	XEE_RESULT XEEBeginWrite(XEE_ADDR address)
240	{
241	if(NeedEndRead)
242	while(1);
243	if(NeedEndWrite)
244	while(1);
245
246	while(XEEIsBusy());
247
248	NeedEndWrite = TRUE;
249
250	// Generate a start condition
251	I2CStart();
252
253	// Send "control" byte with device address to slave
254	if(I2CPut(EEPROM_CONTROL \| WRITE))
255	while(1);
256	// Send address bytes
257	if(I2CPut(((WORD_VAL*)&address)->v[1]))
258	while(1);
259	if(I2CPut(((WORD_VAL*)&address)->v[0]))
260	while(1);
261
262	return XEE_SUCCESS;
263	}
264
265	XEE_RESULT XEEBeginRead(XEE_ADDR address)
266	{
267	// Set the address to read from. This procedure is identical
268	// for reading and writing.
269	XEEBeginWrite(address);
270
271	NeedEndRead = TRUE;
272	NeedEndWrite = FALSE;
273
274	// Generate a start condition
275	I2CStart();
276
277	// Send "control" byte with device address to slave
278	if(I2CPut(EEPROM_CONTROL \| READ))
279	while(1);
280
281	return XEE_SUCCESS;
282	}
283
284	XEE_RESULT XEEEndWrite(void)
285	{
286	if(!NeedEndWrite)
287	while(1);
288	if(NeedEndRead)
289	while(1);
290
291	NeedEndWrite = FALSE;
292
293	// Generate a STOP condition
294	I2CStop();
295	}
296
297	XEE_RESULT XEEWrite(unsigned char val)
298	{
299	if(!NeedEndWrite)
300	while(1);
301	if(NeedEndRead)
302	while(1);
303
304	// Send data byte
305	if(I2CPut(val))
306	while(1);
307
308	return XEE_SUCCESS;
309	}
310
311	unsigned char XEERead(void)
312	{
313	if(NeedEndWrite)
314	while(1);
315	if(!NeedEndRead)
316	while(1);
317
318	if(NeedACK)
319	{
320	NeedACK = FALSE;
321	I2CAck(FALSE);
322	}
323
324	NeedACK = TRUE;
325
326	// Receive a byte
327	return I2CGet();
328	}
329
330	XEE_RESULT XEEEndRead(void)
331	{
332	if(NeedEndWrite)
333	while(1);
334	if(!NeedEndRead)
335	while(1);
336
337	NeedEndRead = FALSE;
338
339	// Send a NACK to complete the read
340	I2CAck(TRUE);
341	NeedACK = FALSE;
342
343	// Generate a STOP condition
344	I2CStop();
345
346	DelayMs(1);//TODO: debug
347
348	return XEE_SUCCESS;
349	}
350
351	XEE_RESULT XEEReadArray(XEE_ADDR address, unsigned char *buffer, unsigned char length)
352	{
353	XEEBeginRead(address);
354	while(length--)
355	*buffer++ = XEERead();
356	XEEEndRead();
357
358	return XEE_SUCCESS;
359	}
360
361	BOOL XEEIsBusy(void)
362	{
363	BOOL i;
364
365	if(NeedEndWrite)
366	while(1);
367	if(NeedEndRead)
368	while(1);
369
370	// Generate a start condition
371	I2CStart();
372
373	// Send "control" byte with device address to slave
374	i = I2CPut(EEPROM_CONTROL \| WRITE);
375
376	// Generate a STOP condition
377	I2CStop();
378
379	return i;
380	}
381
382
383	//
384	///*********************************************************************
385	// * Function: void XEEInit(unsigned char baud)
386	// *
387	// * PreCondition: None
388	// *
389	// * Input: baud - SSPADD value for bit rate.
390	// *
391	// * Output: None
392	// *
393	// * Side Effects: None
394	// *
395	// * Overview: Initialize I2C module to communicate to serial
396	// * EEPROM.
397	// *
398	// * Note: None
399	// ********************************************************************/
400	//void XEEInit(BYTE baud)
401	//{
402	//
403	//#if defined(__18CXX)
404	// EEPROM_SCL_TRIS = 1; // Set SCL pin to output
405	// EEPROM_SDA_TRIS = 1; // Set SDA pin to input
406	// SSPCON1 = 0x28; // Set SSPEN and set I2C Master mode
407	// SSPADD = (INSTR_FREQ+I2CBAUD/2)/I2CBAUD - 1;
408	//#elif defined(__C30__)
409	// EEPROM_I2CCONbits.I2CEN = 1;
410	// #if defined(__dsPIC30F__)
411	// I2CBRG = ((INSTR_FREQ+I2CBAUD/2)/I2CBAUD - (INSTR_FREQ+1111111/2)/1111111)-1; //dsPIC30F only
412	// #else
413	// I2CBRG = (INSTR_FREQ+I2CBAUD)/(2*I2CBAUD)-1 // PIC24, dsPIC33
414	// #endif
415	//#endif
416	//}
417	//
418	//
419	///*********************************************************************
420	// * Macro: XEE_RESULT XEEBeginWrite(XEE_ADDR address)
421	// *
422	// * PreCondition: XEEInit() is already called.
423	// *
424	// * Input: control - data EEPROM control code
425	// * address - address to where to write
426	// *
427	// * Output: XEE_SUCCESS if successful
428	// * other value if failed.
429	// *
430	// * Side Effects: None
431	// *
432	// * Overview: Sets up internal address counter of EEPROM.
433	// *
434	// * Note: This function does not release the I2C bus.
435	// * User must close XEEEndWrite() after this function
436	// * is called to relase the I2C bus.
437	// ********************************************************************/
438	//XEE_RESULT XEEBeginWrite(BYTE control, XEE_ADDR address)
439	//{
440	// if(NeedEndRead)
441	// while(1);
442	// if(NeedEndWrite)
443	// while(1);
444	//
445	// NeedEndWrite = TRUE;
446	//
447	// // Generate a start condition
448	// I2CBIT_SEN = 1;
449	// while(I2CBIT_SEN);
450	//
451	// // Send "control" byte with device address to slave
452	// do
453	// {
454	// I2CBIT_IWCOL = 0;
455	// I2C_DATA_OUT = EEPROM_CONTROL \| WRITE;
456	// } while(I2CBIT_IWCOL);
457	// while(I2CBIT_TRSTAT);
458	// if(I2CBIT_ACKSTAT)
459	// while(1);
460	//
461	// // Send address bytes
462	// do
463	// {
464	// I2CBIT_IWCOL = 0;
465	// I2C_DATA_OUT = ((WORD_VAL*)&address)->v[1];
466	// } while(I2CBIT_IWCOL);
467	// while(I2CBIT_TRSTAT);
468	// if(I2CBIT_ACKSTAT)
469	// while(1);
470	// do
471	// {
472	// I2CBIT_IWCOL = 0;
473	// I2C_DATA_OUT = ((WORD_VAL*)&address)->v[0];
474	// } while(I2CBIT_IWCOL);
475	// while(I2CBIT_TRSTAT);
476	// if(I2CBIT_ACKSTAT)
477	// while(1);
478	//
479	// return XEE_SUCCESS;
480	//}
481	//
482	///*********************************************************************
483	// * Function: XEE_RESULT XEEBeginRead(XEE_ADDR address)
484	// *
485	// * PreCondition: XEEInit() is already called.
486	// *
487	// * Input: control - EEPROM control and address code.
488	// * address - Address at which read is to be performed.
489	// *
490	// * Output: XEE_SUCCESS if successful
491	// * other value if failed.
492	// *
493	// * Side Effects: None
494	// *
495	// * Overview: Sets internal address counter to given address.
496	// * Puts EEPROM in sequential read mode.
497	// *
498	// * Note: This function does not release I2C bus.
499	// * User must call XEEEndRead() when read is not longer
500	// * needed; I2C bus will released after XEEEndRead()
501	// * is called.
502	// ********************************************************************/
503	//XEE_RESULT XEEBeginRead(BYTE control, XEE_ADDR address)
504	//{
505	// if(NeedEndWrite)
506	// while(1);
507	// if(NeedEndRead)
508	// while(1);
509	//
510	//
511	// // Set the address to read from. This procedure is identical
512	// // for reading and writing.
513	// XEEBeginWrite(0, address);
514	//
515	// NeedEndRead = TRUE;
516	// NeedEndWrite = FALSE;
517	//
518	//// // Generate a STOP condition
519	//// I2CBIT_PEN = 1;
520	//// while(I2CBIT_PEN);
521	//
522	//
523	// EEPROM_SCL_TRIS = 1;
524	//
525	// // Generate a start condition
526	// I2CBIT_SEN = 1;
527	// while(I2CBIT_SEN);
528	//
529	// // Send "control" byte with device address to slave
530	// do
531	// {
532	// I2CBIT_IWCOL = 0;
533	// I2C_DATA_OUT = EEPROM_CONTROL \| READ;
534	// } while(I2CBIT_IWCOL);
535	// while(I2CBIT_TRSTAT);
536	// if(I2CBIT_ACKSTAT)
537	// while(1);
538	//
539	// return XEE_SUCCESS;
540	//}
541	//
542	//
543	//XEE_RESULT XEEWrite(unsigned char val)
544	//{
545	// if(!NeedEndWrite)
546	// while(1);
547	// if(NeedEndRead)
548	// while(1);
549	//
550	// // Send data byte
551	// do
552	// {
553	// I2CBIT_IWCOL = 0;
554	// I2C_DATA_OUT = val;
555	// } while(I2CBIT_IWCOL);
556	// while(I2CBIT_TRSTAT);
557	// if(I2CBIT_ACKSTAT)
558	// while(1);
559	//
560	// return XEE_SUCCESS;
561	//}
562	//
563	///*********************************************************************
564	// * Function: XEE_RESULT XEEEndWrite(void)
565	// *
566	// * PreCondition: XEEInit() && XEEBeginWrite() are already called.
567	// *
568	// * Input: None
569	// *
570	// * Output: XEE_SUCCESS if successful
571	// * other value if failed.
572	// *
573	// * Side Effects: None
574	// *
575	// * Overview: Instructs EEPROM to begin write cycle.
576	// *
577	// * Note: Call this function after either page full of bytes
578	// * written or no more bytes are left to load.
579	// * This function initiates the write cycle.
580	// * User must call for XEEWait() to ensure that write
581	// * cycle is finished before calling any other
582	// * routine.
583	// ********************************************************************/
584	//XEE_RESULT XEEEndWrite(void)
585	//{
586	// if(!NeedEndWrite)
587	// while(1);
588	// if(NeedEndRead)
589	// while(1);
590	//
591	// NeedEndWrite = FALSE;
592	//
593	// // Generate a STOP condition
594	// I2CBIT_PEN = 1;
595	// while(I2CBIT_PEN);
596	//
597	// DelayMs(5);
598	//
599	//}
600	//
601	//
602	//
603	///*********************************************************************
604	// * Function: XEE_RESULT XEERead(void)
605	// *
606	// * PreCondition: XEEInit() && XEEBeginRead() are already called.
607	// *
608	// * Input: None
609	// *
610	// * Output: XEE_SUCCESS if successful
611	// * other value if failed.
612	// *
613	// * Side Effects: None
614	// *
615	// * Overview: Reads next byte from EEPROM; internal address
616	// * is incremented by one.
617	// *
618	// * Note: This function does not release I2C bus.
619	// * User must call XEEEndRead() when read is not longer
620	// * needed; I2C bus will released after XEEEndRead()
621	// * is called.
622	// ********************************************************************/
623	//unsigned char XEERead(void)
624	//{
625	// volatile BYTE i;
626	//
627	// if(NeedEndWrite)
628	// while(1);
629	// if(!NeedEndRead)
630	// while(1);
631	//
632	// if(NeedACK)
633	// {
634	// NeedACK = FALSE;
635	// I2CBIT_ACKDT = 0;
636	// I2CBIT_ACKEN = 1;
637	// while(I2CBIT_ACKEN);
638	// }
639	//
640	// // Receive a byte
641	// I2CBIT_RCEN = 1;
642	// while(I2CBIT_RCEN);
643	// NeedACK = TRUE;
644	//
645	// i = I2C_DATA_IN;
646	// return i;
647	//}
648	//
649	///*********************************************************************
650	// * Function: XEE_RESULT XEEEndRead(void)
651	// *
652	// * PreCondition: XEEInit() && XEEBeginRead() are already called.
653	// *
654	// * Input: None
655	// *
656	// * Output: XEE_SUCCESS if successful
657	// * other value if failed.
658	// *
659	// * Side Effects: None
660	// *
661	// * Overview: Ends sequential read cycle.
662	// *
663	// * Note: This function ends seuential cycle that was in
664	// * progress. It releases I2C bus.
665	// ********************************************************************/
666	//XEE_RESULT XEEEndRead(void)
667	//{
668	// if(NeedEndWrite)
669	// while(1);
670	// if(!NeedEndRead)
671	// while(1);
672	//
673	// NeedEndRead = FALSE;
674	//
675	// // Send a NACK to complete the read
676	// I2CBIT_ACKDT = 1;
677	// I2CBIT_ACKEN = 1;
678	// while(I2CBIT_ACKEN);
679	// NeedACK = FALSE;
680	//
681	// // Generate a STOP condition
682	// I2CBIT_PEN = 1;
683	// while(I2CBIT_PEN);
684	//
685	// return XEE_SUCCESS;
686	//}
687	//
688	//
689	///*********************************************************************
690	// * Function: XEE_RESULT XEEReadArray(XEE_ADDR address,
691	// * unsigned char *buffer,
692	// * unsigned char length)
693	// *
694	// * PreCondition: XEEInit() is already called.
695	// *
696	// * Input: control - EEPROM control and address code.
697	// * address - Address from where array is to be read
698	// * buffer - Caller supplied buffer to hold the data
699	// * length - Number of bytes to read.
700	// *
701	// * Output: XEE_SUCCESS if successful
702	// * other value if failed.
703	// *
704	// * Side Effects: None
705	// *
706	// * Overview: Reads desired number of bytes in sequential mode.
707	// * This function performs all necessary steps
708	// * and releases the bus when finished.
709	// *
710	// * Note: None
711	// ********************************************************************/
712	//XEE_RESULT XEEReadArray(BYTE control, XEE_ADDR address,
713	// unsigned char *buffer,
714	// unsigned char length)
715	//{
716	// XEEBeginRead(0, address);
717	// while(length--)
718	// *buffer++ = XEERead();
719	// XEEEndRead();
720	//
721	// return XEE_SUCCESS;
722	//}
723	//
724	//
725	///*********************************************************************
726	// * Function: BOOL XEEIsBusy(void)
727	// *
728	// * PreCondition: XEEInit() is already called.
729	// *
730	// * Input: None
731	// *
732	// * Output: FALSE if EEPROM is not busy
733	// * TRUE if EEPROM is busy or operation failed
734	// *
735	// * Side Effects: None
736	// *
737	// * Overview: Requests ACK from EEPROM.
738	// *
739	// * Note: None
740	// ********************************************************************/
741	//BOOL XEEIsBusy(BYTE control)
742	//{
743	// if(NeedEndWrite)
744	// while(1);
745	// if(NeedEndRead)
746	// while(1);
747	//
748	// // Generate a start condition
749	// I2CBIT_SEN = 1;
750	// while(I2CBIT_SEN);
751	//
752	// // Send "control" byte with device address to slave
753	// do
754	// {
755	// I2CBIT_IWCOL = 0;
756	// I2C_DATA_OUT = EEPROM_CONTROL \| WRITE;
757	// } while(I2CBIT_IWCOL);
758	// while(I2CBIT_TRSTAT);
759	//
760	// // Generate a STOP condition
761	// I2CBIT_PEN = 1;
762	// while(I2CBIT_PEN);
763	//
764	// return I2CBIT_ACKSTAT;
765	//}
766	//
767
768	#endif //#if defined(MPFS_USE_EEPROM) && defined(EEPROM_SCL_TRIS) && defined(STACK_USE_MPFS)