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

/*********************************************************************
 *
 *               Data SPI EEPROM Access Routines
 *
 *********************************************************************
 * FileName:        SPIEEPROM.c
 * Dependencies:    Compiler.h
 *                  XEEPROM.h
 * Processor:       PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
 * Complier:        Microchip C18 v3.02 or higher
 *                                      Microchip C30 v2.01 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             9/01/04         Rewritten for SPI EEPROMs
 * Howard Schlunder             8/10/06         Modified to control SPI module 
 *                                                                      frequency whenever EEPROM accessed 
 *                                                                      to allow bus sharing with different 
 *                                                                      frequencies.
********************************************************************/
#define __SPIEEPROM_C

#include "TCPIP Stack/TCPIP.h"

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

// IMPORTANT SPI NOTE: The code in this file expects that the SPI interrupt 
//              flag (EEPROM_SPI_IF) be clear at all times.  If the SPI is shared with 
//              other hardware, the other code should clear the EEPROM_SPI_IF when it is 
//              done using the SPI.

// SPI Serial EEPROM buffer size.  To enhance performance while
// cooperatively sharing the SPI bus with other peripherals, bytes 
// read and written to the memory are locally buffered. Legal 
// sizes are 1 to the EEPROM page size.
#define EEPROM_BUFFER_SIZE                      (32)

// EEPROM SPI opcodes
#define READ    0x03    // Read data from memory array beginning at selected address
#define WRITE   0x02    // Write data to memory array beginning at selected address
#define WRDI    0x04    // Reset the write enable latch (disable write operations)
#define WREN    0x06    // Set the write enable latch (enable write operations)
#define RDSR    0x05    // Read Status register
#define WRSR    0x01    // Write Status register

static void DoWrite(void);

static WORD EEPROMAddress;
static BYTE EEPROMBuffer[EEPROM_BUFFER_SIZE];
static BYTE *EEPROMBufferPtr;

/*********************************************************************
 * Function:        void XEEInit(unsigned char speed)
 *
 * PreCondition:    None
 *
 * Input:           speed - not used (included for compatibility only)
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Initialize SPI module to communicate to serial
 *                  EEPROM.
 *
 * Note:            Code sets SPI clock to Fosc/16.  
 ********************************************************************/
#if defined(HPC_EXPLORER) && !defined(__18F87J10)
        #define PROPER_SPICON1  (0x20)          /* SSPEN bit is set, SPI in master mode, FOSC/4, IDLE state is low level */
#elif defined(__PIC24F__)
    #define PROPER_SPICON1      (0x0013 | 0x0120)       /* 1:1 primary prescale, 4:1 secondary prescale, CKE=1, MASTER mode */
#elif defined(__dsPIC30F__)
    #define PROPER_SPICON1      (0x0017 | 0x0120)       /* 1:1 primary prescale, 3:1 secondary prescale, CKE=1, MASTER mode */
#elif defined(__dsPIC33F__) || defined(__PIC24H__)
    #define PROPER_SPICON1      (0x0003 | 0x0120)       /* 1:1 primary prescale, 8:1 secondary prescale, CKE=1, MASTER mode */
#else
        #define PROPER_SPICON1  (0x21)          /* SSPEN bit is set, SPI in master mode, FOSC/16, IDLE state is low level */
#endif

void XEEInit(void)
{
        EEPROM_CS_IO = 1;
        EEPROM_CS_TRIS = 0;             // Drive SPI EEPROM chip select pin

        EEPROM_SCK_TRIS = 0;    // Set SCK pin as an output
        EEPROM_SDI_TRIS = 1;    // Make sure SDI pin is an input
        EEPROM_SDO_TRIS = 0;    // Set SDO pin as an output

        EEPROM_SPICON1 = PROPER_SPICON1; // See PROPER_SPICON1 definition above
        #if defined(__C30__)
            EEPROM_SPICON2 = 0;
            EEPROM_SPISTAT = 0;    // clear SPI
            EEPROM_SPISTATbits.SPIEN = 1;
        #elif defined(__18CXX)
                EEPROM_SPI_IF = 0;
                EEPROM_SPISTATbits.CKE = 1;     // Transmit data on rising edge of clock
                EEPROM_SPISTATbits.SMP = 0;             // Input sampled at middle of data output time
        #endif
}


/*********************************************************************
 * Function:        XEE_RESULT XEEBeginRead(unsigned char control,
 *                                          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(XEE_ADDR address)
{
        // Save the address and emptry the contents of our local buffer
        EEPROMAddress = address;
        EEPROMBufferPtr = EEPROMBuffer + EEPROM_BUFFER_SIZE;
        return XEE_SUCCESS;
}


/*********************************************************************
 * 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)
{
        // Check if no more bytes are left in our local buffer
        if( EEPROMBufferPtr == EEPROMBuffer + EEPROM_BUFFER_SIZE )
        { 
                // Get a new set of bytes
                XEEReadArray(EEPROMAddress, EEPROMBuffer, EEPROM_BUFFER_SIZE);
                EEPROMAddress += EEPROM_BUFFER_SIZE;
                EEPROMBufferPtr = EEPROMBuffer;
        }

        // Return a byte from our local buffer
        return *EEPROMBufferPtr++;
}

/*********************************************************************
 * 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 sequential cycle that was in
 *                  progress.  It releases I2C bus.
 ********************************************************************/
XEE_RESULT XEEEndRead(void)
{
    return XEE_SUCCESS;
}


/*********************************************************************
 * Function:        XEE_RESULT XEEReadArray(unsigned char control,
 *                                          XEE_ADDR address,
 *                                          unsigned char *buffer,
 *                                          unsigned char length)
 *
 * PreCondition:    XEEInit() is already called.
 *
 * Input:           control     - Unused
 *                  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(XEE_ADDR address,
                        unsigned char *buffer,
                        unsigned char length)
{
        BYTE Dummy;
        #if defined(__18CXX)
        BYTE SPICON1Save;
        #else
        WORD SPICON1Save;
        #endif  

        // Save SPI state (clock speed)
        SPICON1Save = EEPROM_SPICON1;
        EEPROM_SPICON1 = PROPER_SPICON1;

        EEPROM_CS_IO = 0;

        // Send READ opcode
        EEPROM_SSPBUF = READ;
        while(!EEPROM_SPI_IF);
        Dummy = EEPROM_SSPBUF;
        EEPROM_SPI_IF = 0;
        
        // Send address
        EEPROM_SSPBUF = ((WORD_VAL*)&address)->v[1];
        while(!EEPROM_SPI_IF);
        Dummy = EEPROM_SSPBUF;
        EEPROM_SPI_IF = 0;
        EEPROM_SSPBUF = ((WORD_VAL*)&address)->v[0];
        while(!EEPROM_SPI_IF);
        Dummy = EEPROM_SSPBUF;
        EEPROM_SPI_IF = 0;
        
        while(length--)
        {
                EEPROM_SSPBUF = 0;
                while(!EEPROM_SPI_IF);
                *buffer++ = EEPROM_SSPBUF;
                EEPROM_SPI_IF = 0;
        };
        
        EEPROM_CS_IO = 1;

        // Restore SPI state
        EEPROM_SPICON1 = SPICON1Save;

        return XEE_SUCCESS;
}


/*********************************************************************
 * Function:        XEE_RESULT XEESetAddr(unsigned char control,
 *                                        XEE_ADDR address)
 *
 * PreCondition:    XEEInit() is already called.
 *
 * Input:           control     - data EEPROM control code
 *                  address     - address to be set for writing
 *
 * Output:          XEE_SUCCESS if successful
 *                  other value if failed.
 *
 * Side Effects:    None
 *
 * Overview:        Modifies internal address counter of EEPROM.
 *
 * Note:            Unlike XEESetAddr() in xeeprom.c for I2C EEPROM 
 *                                       memories, this function is used only for writing
 *                                       to the EEPROM.  Reads must use XEEBeginRead(), 
 *                                       XEERead(), and XEEEndRead().
 *                                      This function does not release the SPI bus.
 ********************************************************************/
XEE_RESULT XEEBeginWrite(XEE_ADDR address)
{
        EEPROMAddress = address;
        EEPROMBufferPtr = EEPROMBuffer;
        return XEE_SUCCESS;
}


/*********************************************************************
 * Function:        XEE_RESULT XEEWrite(unsigned char val)
 *
 * PreCondition:    XEEInit() && XEEBeginWrite() are already called.
 *
 * Input:           val - Byte to be written
 *
 * Output:          XEE_SUCCESS
 *
 * Side Effects:    None
 *
 * Overview:        Adds a byte to the current page to be writen when
 *                                      XEEEndWrite() is called.
 *
 * Note:            Page boundary cannot be exceeded or the byte 
 *                                      to be written will be looped back to the 
 *                                      beginning of the page.
 ********************************************************************/
XEE_RESULT XEEWrite(unsigned char val)
{
        *EEPROMBufferPtr++ = val;
        if( EEPROMBufferPtr == EEPROMBuffer + EEPROM_BUFFER_SIZE )
    {
                DoWrite();
    }

    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 XEEIsBusy() to ensure that write
 *                  cycle is finished before calling any other
 *                  routine.
 ********************************************************************/
XEE_RESULT XEEEndWrite(void)
{
        if( EEPROMBufferPtr != EEPROMBuffer )
    {
                DoWrite();
    }

    return XEE_SUCCESS;
}

static void DoWrite(void)
{
        BYTE Dummy;
        BYTE BytesToWrite;
        #if defined(__18CXX)
        BYTE SPICON1Save;
        #else
        WORD SPICON1Save;
        #endif  

        // Save SPI state (clock speed)
        SPICON1Save = EEPROM_SPICON1;
        EEPROM_SPICON1 = PROPER_SPICON1;
        
        // Set the Write Enable latch
        EEPROM_CS_IO = 0;
        EEPROM_SSPBUF = WREN;
        while(!EEPROM_SPI_IF);
        Dummy = EEPROM_SSPBUF;
        EEPROM_SPI_IF = 0;
        EEPROM_CS_IO = 1;
        
        // Send WRITE opcode
        EEPROM_CS_IO = 0;
        EEPROM_SSPBUF = WRITE;
        while(!EEPROM_SPI_IF);
        Dummy = EEPROM_SSPBUF;
        EEPROM_SPI_IF = 0;
        
        // Send address
        EEPROM_SSPBUF = ((WORD_VAL*)&EEPROMAddress)->v[1];
        while(!EEPROM_SPI_IF);
        Dummy = EEPROM_SSPBUF;
        EEPROM_SPI_IF = 0;
        EEPROM_SSPBUF = ((WORD_VAL*)&EEPROMAddress)->v[0];
        while(!EEPROM_SPI_IF);
        Dummy = EEPROM_SSPBUF;
        EEPROM_SPI_IF = 0;
        
        BytesToWrite = (BYTE)(EEPROMBufferPtr - EEPROMBuffer);
        
        EEPROMAddress += BytesToWrite;
        EEPROMBufferPtr = EEPROMBuffer;

        while(BytesToWrite--)
        {
                // Send the byte to write
                EEPROM_SSPBUF = *EEPROMBufferPtr++;
                while(!EEPROM_SPI_IF);
                Dummy = EEPROM_SSPBUF;
                EEPROM_SPI_IF = 0;
        }

        // Begin the write
        EEPROM_CS_IO = 1;

        EEPROMBufferPtr = EEPROMBuffer;

        // Restore SPI State
        EEPROM_SPICON1 = SPICON1Save;

        // Wait for write to complete
        while( XEEIsBusy() );
}


/*********************************************************************
 * Function:        BOOL XEEIsBusy(void)
 *
 * PreCondition:    XEEInit() is already called.
 *
 * Input:           None
 *
 * Output:          FALSE if EEPROM is not busy
 *                  TRUE if EEPROM is busy
 *
 * Side Effects:    None
 *
 * Overview:        Reads the status register
 *
 * Note:            None
 ********************************************************************/
BOOL XEEIsBusy(void)
{
        BYTE_VAL result;
        #if defined(__18CXX)
        BYTE SPICON1Save;
        #else
        WORD SPICON1Save;
        #endif  

        // Save SPI state (clock speed)
        SPICON1Save = EEPROM_SPICON1;
        EEPROM_SPICON1 = PROPER_SPICON1;

        EEPROM_CS_IO = 0;
        // Send RDSR - Read Status Register opcode
        EEPROM_SSPBUF = RDSR;
        while(!EEPROM_SPI_IF);
        result.Val = EEPROM_SSPBUF;
        EEPROM_SPI_IF = 0;
        
        // Get register contents
        EEPROM_SSPBUF = 0;
        while(!EEPROM_SPI_IF);
        result.Val = EEPROM_SSPBUF;
        EEPROM_SPI_IF = 0;
        EEPROM_CS_IO = 1;

        // Restore SPI State
        EEPROM_SPICON1 = SPICON1Save;

        return result.bits.b0;
}


#endif //#if defined(MPFS_USE_EEPROM) && defined(EEPROM_CS_TRIS) && defined(STACK_USE_MPFS)
1	/*********************************************************************
2	*
3	* Data SPI EEPROM Access Routines
4	*
5	*********************************************************************
6	* FileName: SPIEEPROM.c
7	* Dependencies: Compiler.h
8	* XEEPROM.h
9	* Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
10	* Complier: Microchip C18 v3.02 or higher
11	* Microchip C30 v2.01 or higher
12	* Company: Microchip Technology, Inc.
13	*
14	* Software License Agreement
15	*
16	* Copyright © 2002-2007 Microchip Technology Inc. All rights
17	* reserved.
18	*
19	* Microchip licenses to you the right to use, modify, copy, and
20	* distribute:
21	* (i) the Software when embedded on a Microchip microcontroller or
22	* digital signal controller product (“Device”) which is
23	* integrated into Licensee’s product; or
24	* (ii) ONLY the Software driver source files ENC28J60.c and
25	* ENC28J60.h ported to a non-Microchip device used in
26	* conjunction with a Microchip ethernet controller for the
27	* sole purpose of interfacing with the ethernet controller.
28	*
29	* You should refer to the license agreement accompanying this
30	* Software for additional information regarding your rights and
31	* obligations.
32	*
33	* THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT
34	* WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
35	* LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
36	* PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
37	* MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
38	* CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
39	* PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
40	* BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
41	* THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
42	* SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
43	* (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
44	*
45	*
46	* Author Date Comment
47	*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
48	* Nilesh Rajbharti 5/20/02 Original (Rev. 1.0)
49	* Howard Schlunder 9/01/04 Rewritten for SPI EEPROMs
50	* Howard Schlunder 8/10/06 Modified to control SPI module
51	* frequency whenever EEPROM accessed
52	* to allow bus sharing with different
53	* frequencies.
54	********************************************************************/
55	#define __SPIEEPROM_C
56
57	#include "TCPIP Stack/TCPIP.h"
58
59	#if defined(MPFS_USE_EEPROM) && defined(EEPROM_CS_TRIS) && defined(STACK_USE_MPFS)
60
61	// IMPORTANT SPI NOTE: The code in this file expects that the SPI interrupt
62	// flag (EEPROM_SPI_IF) be clear at all times. If the SPI is shared with
63	// other hardware, the other code should clear the EEPROM_SPI_IF when it is
64	// done using the SPI.
65
66	// SPI Serial EEPROM buffer size. To enhance performance while
67	// cooperatively sharing the SPI bus with other peripherals, bytes
68	// read and written to the memory are locally buffered. Legal
69	// sizes are 1 to the EEPROM page size.
70	#define EEPROM_BUFFER_SIZE (32)
71
72	// EEPROM SPI opcodes
73	#define READ 0x03 // Read data from memory array beginning at selected address
74	#define WRITE 0x02 // Write data to memory array beginning at selected address
75	#define WRDI 0x04 // Reset the write enable latch (disable write operations)
76	#define WREN 0x06 // Set the write enable latch (enable write operations)
77	#define RDSR 0x05 // Read Status register
78	#define WRSR 0x01 // Write Status register
79
80	static void DoWrite(void);
81
82	static WORD EEPROMAddress;
83	static BYTE EEPROMBuffer[EEPROM_BUFFER_SIZE];
84	static BYTE *EEPROMBufferPtr;
85
86	/*********************************************************************
87	* Function: void XEEInit(unsigned char speed)
88	*
89	* PreCondition: None
90	*
91	* Input: speed - not used (included for compatibility only)
92	*
93	* Output: None
94	*
95	* Side Effects: None
96	*
97	* Overview: Initialize SPI module to communicate to serial
98	* EEPROM.
99	*
100	* Note: Code sets SPI clock to Fosc/16.
101	********************************************************************/
102	#if defined(HPC_EXPLORER) && !defined(__18F87J10)
103	#define PROPER_SPICON1 (0x20) /* SSPEN bit is set, SPI in master mode, FOSC/4, IDLE state is low level */
104	#elif defined(__PIC24F__)
105	#define PROPER_SPICON1 (0x0013 \| 0x0120) /* 1:1 primary prescale, 4:1 secondary prescale, CKE=1, MASTER mode */
106	#elif defined(__dsPIC30F__)
107	#define PROPER_SPICON1 (0x0017 \| 0x0120) /* 1:1 primary prescale, 3:1 secondary prescale, CKE=1, MASTER mode */
108	#elif defined(__dsPIC33F__) \|\| defined(__PIC24H__)
109	#define PROPER_SPICON1 (0x0003 \| 0x0120) /* 1:1 primary prescale, 8:1 secondary prescale, CKE=1, MASTER mode */
110	#else
111	#define PROPER_SPICON1 (0x21) /* SSPEN bit is set, SPI in master mode, FOSC/16, IDLE state is low level */
112	#endif
113
114	void XEEInit(void)
115	{
116	EEPROM_CS_IO = 1;
117	EEPROM_CS_TRIS = 0; // Drive SPI EEPROM chip select pin
118
119	EEPROM_SCK_TRIS = 0; // Set SCK pin as an output
120	EEPROM_SDI_TRIS = 1; // Make sure SDI pin is an input
121	EEPROM_SDO_TRIS = 0; // Set SDO pin as an output
122
123	EEPROM_SPICON1 = PROPER_SPICON1; // See PROPER_SPICON1 definition above
124	#if defined(__C30__)
125	EEPROM_SPICON2 = 0;
126	EEPROM_SPISTAT = 0; // clear SPI
127	EEPROM_SPISTATbits.SPIEN = 1;
128	#elif defined(__18CXX)
129	EEPROM_SPI_IF = 0;
130	EEPROM_SPISTATbits.CKE = 1; // Transmit data on rising edge of clock
131	EEPROM_SPISTATbits.SMP = 0; // Input sampled at middle of data output time
132	#endif
133	}
134
135
136	/*********************************************************************
137	* Function: XEE_RESULT XEEBeginRead(unsigned char control,
138	* XEE_ADDR address)
139	*
140	* PreCondition: XEEInit() is already called.
141	*
142	* Input: control - EEPROM control and address code.
143	* address - Address at which read is to be performed.
144	*
145	* Output: XEE_SUCCESS if successful
146	* other value if failed.
147	*
148	* Side Effects: None
149	*
150	* Overview: Sets internal address counter to given address.
151	* Puts EEPROM in sequential read mode.
152	*
153	* Note: This function does not release I2C bus.
154	* User must call XEEEndRead() when read is not longer
155	* needed; I2C bus will released after XEEEndRead()
156	* is called.
157	********************************************************************/
158	XEE_RESULT XEEBeginRead(XEE_ADDR address)
159	{
160	// Save the address and emptry the contents of our local buffer
161	EEPROMAddress = address;
162	EEPROMBufferPtr = EEPROMBuffer + EEPROM_BUFFER_SIZE;
163	return XEE_SUCCESS;
164	}
165
166
167	/*********************************************************************
168	* Function: XEE_RESULT XEERead(void)
169	*
170	* PreCondition: XEEInit() && XEEBeginRead() are already called.
171	*
172	* Input: None
173	*
174	* Output: XEE_SUCCESS if successful
175	* other value if failed.
176	*
177	* Side Effects: None
178	*
179	* Overview: Reads next byte from EEPROM; internal address
180	* is incremented by one.
181	*
182	* Note: This function does not release I2C bus.
183	* User must call XEEEndRead() when read is not longer
184	* needed; I2C bus will released after XEEEndRead()
185	* is called.
186	********************************************************************/
187	unsigned char XEERead(void)
188	{
189	// Check if no more bytes are left in our local buffer
190	if( EEPROMBufferPtr == EEPROMBuffer + EEPROM_BUFFER_SIZE )
191	{
192	// Get a new set of bytes
193	XEEReadArray(EEPROMAddress, EEPROMBuffer, EEPROM_BUFFER_SIZE);
194	EEPROMAddress += EEPROM_BUFFER_SIZE;
195	EEPROMBufferPtr = EEPROMBuffer;
196	}
197
198	// Return a byte from our local buffer
199	return *EEPROMBufferPtr++;
200	}
201
202	/*********************************************************************
203	* Function: XEE_RESULT XEEEndRead(void)
204	*
205	* PreCondition: XEEInit() && XEEBeginRead() are already called.
206	*
207	* Input: None
208	*
209	* Output: XEE_SUCCESS if successful
210	* other value if failed.
211	*
212	* Side Effects: None
213	*
214	* Overview: Ends sequential read cycle.
215	*
216	* Note: This function ends sequential cycle that was in
217	* progress. It releases I2C bus.
218	********************************************************************/
219	XEE_RESULT XEEEndRead(void)
220	{
221	return XEE_SUCCESS;
222	}
223
224
225	/*********************************************************************
226	* Function: XEE_RESULT XEEReadArray(unsigned char control,
227	* XEE_ADDR address,
228	* unsigned char *buffer,
229	* unsigned char length)
230	*
231	* PreCondition: XEEInit() is already called.
232	*
233	* Input: control - Unused
234	* address - Address from where array is to be read
235	* buffer - Caller supplied buffer to hold the data
236	* length - Number of bytes to read.
237	*
238	* Output: XEE_SUCCESS if successful
239	* other value if failed.
240	*
241	* Side Effects: None
242	*
243	* Overview: Reads desired number of bytes in sequential mode.
244	* This function performs all necessary steps
245	* and releases the bus when finished.
246	*
247	* Note: None
248	********************************************************************/
249	XEE_RESULT XEEReadArray(XEE_ADDR address,
250	unsigned char *buffer,
251	unsigned char length)
252	{
253	BYTE Dummy;
254	#if defined(__18CXX)
255	BYTE SPICON1Save;
256	#else
257	WORD SPICON1Save;
258	#endif
259
260	// Save SPI state (clock speed)
261	SPICON1Save = EEPROM_SPICON1;
262	EEPROM_SPICON1 = PROPER_SPICON1;
263
264	EEPROM_CS_IO = 0;
265
266	// Send READ opcode
267	EEPROM_SSPBUF = READ;
268	while(!EEPROM_SPI_IF);
269	Dummy = EEPROM_SSPBUF;
270	EEPROM_SPI_IF = 0;
271
272	// Send address
273	EEPROM_SSPBUF = ((WORD_VAL*)&address)->v[1];
274	while(!EEPROM_SPI_IF);
275	Dummy = EEPROM_SSPBUF;
276	EEPROM_SPI_IF = 0;
277	EEPROM_SSPBUF = ((WORD_VAL*)&address)->v[0];
278	while(!EEPROM_SPI_IF);
279	Dummy = EEPROM_SSPBUF;
280	EEPROM_SPI_IF = 0;
281
282	while(length--)
283	{
284	EEPROM_SSPBUF = 0;
285	while(!EEPROM_SPI_IF);
286	*buffer++ = EEPROM_SSPBUF;
287	EEPROM_SPI_IF = 0;
288	};
289
290	EEPROM_CS_IO = 1;
291
292	// Restore SPI state
293	EEPROM_SPICON1 = SPICON1Save;
294
295	return XEE_SUCCESS;
296	}
297
298
299	/*********************************************************************
300	* Function: XEE_RESULT XEESetAddr(unsigned char control,
301	* XEE_ADDR address)
302	*
303	* PreCondition: XEEInit() is already called.
304	*
305	* Input: control - data EEPROM control code
306	* address - address to be set for writing
307	*
308	* Output: XEE_SUCCESS if successful
309	* other value if failed.
310	*
311	* Side Effects: None
312	*
313	* Overview: Modifies internal address counter of EEPROM.
314	*
315	* Note: Unlike XEESetAddr() in xeeprom.c for I2C EEPROM
316	* memories, this function is used only for writing
317	* to the EEPROM. Reads must use XEEBeginRead(),
318	* XEERead(), and XEEEndRead().
319	* This function does not release the SPI bus.
320	********************************************************************/
321	XEE_RESULT XEEBeginWrite(XEE_ADDR address)
322	{
323	EEPROMAddress = address;
324	EEPROMBufferPtr = EEPROMBuffer;
325	return XEE_SUCCESS;
326	}
327
328
329	/*********************************************************************
330	* Function: XEE_RESULT XEEWrite(unsigned char val)
331	*
332	* PreCondition: XEEInit() && XEEBeginWrite() are already called.
333	*
334	* Input: val - Byte to be written
335	*
336	* Output: XEE_SUCCESS
337	*
338	* Side Effects: None
339	*
340	* Overview: Adds a byte to the current page to be writen when
341	* XEEEndWrite() is called.
342	*
343	* Note: Page boundary cannot be exceeded or the byte
344	* to be written will be looped back to the
345	* beginning of the page.
346	********************************************************************/
347	XEE_RESULT XEEWrite(unsigned char val)
348	{
349	*EEPROMBufferPtr++ = val;
350	if( EEPROMBufferPtr == EEPROMBuffer + EEPROM_BUFFER_SIZE )
351	{
352	DoWrite();
353	}
354
355	return XEE_SUCCESS;
356	}
357
358
359	/*********************************************************************
360	* Function: XEE_RESULT XEEEndWrite(void)
361	*
362	* PreCondition: XEEInit() && XEEBeginWrite() are already called.
363	*
364	* Input: None
365	*
366	* Output: XEE_SUCCESS if successful
367	* other value if failed.
368	*
369	* Side Effects: None
370	*
371	* Overview: Instructs EEPROM to begin write cycle.
372	*
373	* Note: Call this function after either page full of bytes
374	* written or no more bytes are left to load.
375	* This function initiates the write cycle.
376	* User must call for XEEIsBusy() to ensure that write
377	* cycle is finished before calling any other
378	* routine.
379	********************************************************************/
380	XEE_RESULT XEEEndWrite(void)
381	{
382	if( EEPROMBufferPtr != EEPROMBuffer )
383	{
384	DoWrite();
385	}
386
387	return XEE_SUCCESS;
388	}
389
390	static void DoWrite(void)
391	{
392	BYTE Dummy;
393	BYTE BytesToWrite;
394	#if defined(__18CXX)
395	BYTE SPICON1Save;
396	#else
397	WORD SPICON1Save;
398	#endif
399
400	// Save SPI state (clock speed)
401	SPICON1Save = EEPROM_SPICON1;
402	EEPROM_SPICON1 = PROPER_SPICON1;
403
404	// Set the Write Enable latch
405	EEPROM_CS_IO = 0;
406	EEPROM_SSPBUF = WREN;
407	while(!EEPROM_SPI_IF);
408	Dummy = EEPROM_SSPBUF;
409	EEPROM_SPI_IF = 0;
410	EEPROM_CS_IO = 1;
411
412	// Send WRITE opcode
413	EEPROM_CS_IO = 0;
414	EEPROM_SSPBUF = WRITE;
415	while(!EEPROM_SPI_IF);
416	Dummy = EEPROM_SSPBUF;
417	EEPROM_SPI_IF = 0;
418
419	// Send address
420	EEPROM_SSPBUF = ((WORD_VAL*)&EEPROMAddress)->v[1];
421	while(!EEPROM_SPI_IF);
422	Dummy = EEPROM_SSPBUF;
423	EEPROM_SPI_IF = 0;
424	EEPROM_SSPBUF = ((WORD_VAL*)&EEPROMAddress)->v[0];
425	while(!EEPROM_SPI_IF);
426	Dummy = EEPROM_SSPBUF;
427	EEPROM_SPI_IF = 0;
428
429	BytesToWrite = (BYTE)(EEPROMBufferPtr - EEPROMBuffer);
430
431	EEPROMAddress += BytesToWrite;
432	EEPROMBufferPtr = EEPROMBuffer;
433
434	while(BytesToWrite--)
435	{
436	// Send the byte to write
437	EEPROM_SSPBUF = *EEPROMBufferPtr++;
438	while(!EEPROM_SPI_IF);
439	Dummy = EEPROM_SSPBUF;
440	EEPROM_SPI_IF = 0;
441	}
442
443	// Begin the write
444	EEPROM_CS_IO = 1;
445
446	EEPROMBufferPtr = EEPROMBuffer;
447
448	// Restore SPI State
449	EEPROM_SPICON1 = SPICON1Save;
450
451	// Wait for write to complete
452	while( XEEIsBusy() );
453	}
454
455
456	/*********************************************************************
457	* Function: BOOL XEEIsBusy(void)
458	*
459	* PreCondition: XEEInit() is already called.
460	*
461	* Input: None
462	*
463	* Output: FALSE if EEPROM is not busy
464	* TRUE if EEPROM is busy
465	*
466	* Side Effects: None
467	*
468	* Overview: Reads the status register
469	*
470	* Note: None
471	********************************************************************/
472	BOOL XEEIsBusy(void)
473	{
474	BYTE_VAL result;
475	#if defined(__18CXX)
476	BYTE SPICON1Save;
477	#else
478	WORD SPICON1Save;
479	#endif
480
481	// Save SPI state (clock speed)
482	SPICON1Save = EEPROM_SPICON1;
483	EEPROM_SPICON1 = PROPER_SPICON1;
484
485	EEPROM_CS_IO = 0;
486	// Send RDSR - Read Status Register opcode
487	EEPROM_SSPBUF = RDSR;
488	while(!EEPROM_SPI_IF);
489	result.Val = EEPROM_SSPBUF;
490	EEPROM_SPI_IF = 0;
491
492	// Get register contents
493	EEPROM_SSPBUF = 0;
494	while(!EEPROM_SPI_IF);
495	result.Val = EEPROM_SSPBUF;
496	EEPROM_SPI_IF = 0;
497	EEPROM_CS_IO = 1;
498
499	// Restore SPI State
500	EEPROM_SPICON1 = SPICON1Save;
501
502	return result.bits.b0;
503	}
504
505
506	#endif //#if defined(MPFS_USE_EEPROM) && defined(EEPROM_CS_TRIS) && defined(STACK_USE_MPFS)