SPIEEPROM.c

Go to the documentation of this file.

/*********************************************************************
 * Software License Agreement
 *
 * Copyright (C) 2002-2008 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.h"

// Local Defines

// 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

#define EEPROM_CS_IO    (LATFbits.LATF5)


// Local function prototypes

static void DoWrite(void);
// MODIFIX: Moved the following prototypes from the header file to this 
// location and made them static.
static XEE_RESULT XEEBeginWrite(XEE_ADDR address);
static XEE_RESULT XEEWrite(unsigned char val);
static XEE_RESULT XEEEndWrite(void);
static BOOL XEEIsBusy(void);


// Local Variables

static XEE_ADDR EEPROMAddress;
static BYTE EEPROMBuffer[EEPROM_BUFFER_SIZE];
static BYTE EEPROMBytesToWrite;
static BYTE EEPROMPageSpace;


// MODIFIX: Removed the functions XEEInit, XEEBeginRead, XEERead and 
// XEEEndRead.

/*********************************************************************
 * Function:        XEE_RESULT XEEReadArray(XEE_ADDR address,
 *                                          BYTE *buffer,
 *                                          BYTE length)
 *
 * PreCondition:    None.
 *
 * Input:           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
 *
 * 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
 ********************************************************************/

void _startReading(XEE_ADDR Address)
{
    BYTE tmp;

    // SPI-Configuration for EEPROM:
    // SPI Master / Clock = Fosc/16 / Enable / Clock idle state is low  
    SSP1CON1 = 0x21;
    SSP1STAT = 0x40;    // CKE = 1

    // Send READ opcode
    PIR1bits.SSP1IF = 0;
    EEPROM_CS_IO = 0;
    SSPBUF = READ;
    while(PIR1bits.SSP1IF == 0);
    tmp = SSPBUF;
    
    // Send address (WORD)
    PIR1bits.SSP1IF = 0;
    SSPBUF = ((WORD_VAL*)&Address)->v[1];
    while( PIR1bits.SSP1IF == 0 );
    tmp = SSPBUF;
    PIR1bits.SSP1IF = 0;
    SSPBUF = ((WORD_VAL*)&Address)->v[0];
    while( PIR1bits.SSP1IF == 0 );
    tmp = SSPBUF;
}



XEE_RESULT XEEReadArray(XEE_ADDR address, BYTE *buffer, BYTE length)
{
    BYTE Dummy;
    BYTE len = length;
    BYTE * pBuf = buffer;

    _startReading(address);
    
    while(len--)
    {
        PIR1bits.SSP1IF = 0;
        SSPBUF = 0;
        while(PIR1bits.SSP1IF == 0);
        *pBuf++ = SSPBUF;
    }
    
    EEPROM_CS_IO = 1;

    return XEE_SUCCESS;
}


/*********************************************************************
 * Function:        XEE_RESULT XEEBeginWrite(XEE_ADDR address)
 *
 * PreCondition:    None (MODIFIX)
 *
 * Input:           address     - address to be set for writing
 *
 * Output:          XEE_SUCCESS
 *
 * Side Effects:    None
 *
 * Overview:        Starts the writing of content to EEPROM to the 
 *                  given address.
 *
 ********************************************************************/
XEE_RESULT XEEBeginWrite(XEE_ADDR address)
{
    EEPROMAddress = address;
    EEPROMBytesToWrite = 0;
    EEPROMPageSpace = EEPROM_BUFFER_SIZE-(address % EEPROM_BUFFER_SIZE);
    return XEE_SUCCESS;
}


/*********************************************************************
 * Function:        XEE_RESULT XEEWrite(BYTE val)
 *
 * PreCondition:    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(BYTE val)
{
    EEPROMBuffer[EEPROMBytesToWrite++] = val;
    EEPROMPageSpace--;

    if(EEPROMPageSpace==0)
        DoWrite();

    return XEE_SUCCESS;
}


/*********************************************************************
 * Function:        XEE_RESULT XEEEndWrite(void)
 *
 * PreCondition:    XEEBeginWrite() is 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(EEPROMBytesToWrite)
        DoWrite();

    return XEE_SUCCESS;
}

static void DoWrite(void)
{
    BYTE Dummy;
    BYTE i;

    // SPI-Configuration for EEPROM:
    // SPI Master / Clock = Fosc/16 / Enable / Clock idle state is low (CKP=0)  
    SSP1CON1 = 0x21;
    SSP1STAT = 0x40;    // CKE = 1
    
    // Set the Write Enable latch
    PIR1bits.SSP1IF = 0;
    EEPROM_CS_IO = 0;
    SSPBUF = WREN;
    while( PIR1bits.SSP1IF == 0 );
    Dummy = SSPBUF;
    EEPROM_CS_IO = 1;
    
    // Send WRITE opcode
    EEPROM_CS_IO = 0;
    PIR1bits.SSP1IF = 0;
    SSPBUF = WRITE;
    while(PIR1bits.SSP1IF == 0);
    Dummy = SSPBUF;
    
    // Send address (WORD)
    PIR1bits.SSP1IF = 0;
    SSPBUF = ((WORD_VAL*)&EEPROMAddress)->v[1];
    while(PIR1bits.SSP1IF == 0);
    Dummy = SSPBUF;
    PIR1bits.SSP1IF = 0;
    SSPBUF = ((WORD_VAL*)&EEPROMAddress)->v[0];
    while(PIR1bits.SSP1IF == 0);
    Dummy = SSPBUF;
    
    EEPROMAddress += EEPROMBytesToWrite;

    for (i=0; i<EEPROMBytesToWrite;i++)
    {
        // Send the byte to write
        PIR1bits.SSP1IF = 0;
        SSPBUF = EEPROMBuffer[i];
        while(PIR1bits.SSP1IF == 0);
        Dummy = SSPBUF;
    }

    // Begin the write
    EEPROM_CS_IO = 1;

    EEPROMBytesToWrite = 0;
    EEPROMPageSpace = EEPROM_BUFFER_SIZE;
    

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


/*********************************************************************
 * Function:        BOOL XEEIsBusy(void)
 *
 * PreCondition:    None.
 *
 * Input:           None
 *
 * Output:          FALSE if EEPROM is not busy
 *                  TRUE if EEPROM is busy
 *
 * Side Effects:    None
 *
 * Overview:        Reads the status register
 *
 * Note:            None
 ********************************************************************/
static BOOL XEEIsBusy(void)
{
    BYTE_VAL result;

    // SPI-Configuration for EEPROM:
    // SPI Master / Clock = Fosc/16 / Enable / Clock idle state is low  
    SSP1CON1 = 0x21;
    SSP1STAT = 0x40;    // CKE = 1

    PIR1bits.SSP1IF = 0;
    EEPROM_CS_IO = 0;
    // Send RDSR - Read Status Register opcode
    SSPBUF = RDSR;
    while(PIR1bits.SSP1IF == 0);
    result.Val = SSPBUF;

    // Get register contents
    PIR1bits.SSP1IF = 0;
    SSPBUF = 0;
    while(PIR1bits.SSP1IF == 0);
    result.Val = SSPBUF;
    EEPROM_CS_IO = 1;

    return result.bits.b0;
}


void XEEEraseEEPROM(void)
{
    int i = 0;
    XEEBeginWrite(0);

    for (; i < EEPROM_SIZE; i++)
    {
        XEEWrite(0xFF);
    }

    XEEEndWrite();
}


void XEEWriteArray(WORD address, BYTE * pData, BYTE len)
{
    BYTE i;

    XEEBeginWrite(address);

    for (i = 0; i < len; i++)
        XEEWrite(pData[i]); 

    XEEEndWrite();
}

---