/*****************************************************************************
NOR FLASH Chip SPI Bus Driver for CC1010 SoC
M25P80 / M25PE80
Page Alterability would be added later on
/*Author(s)/* Abhishek Mitra and Anirban Banerjee, UC Riverside
Portions from the SPI Bus example program from CC1010 Example 
 ****************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <chipcon/reg1010.h>
#include <chipcon/cc1010eb.h>
#include <chipcon/hal.h>
#include <chipcon/cul.h>
#include <chipcon/vt100.h>

// Define M25P80 instructions
#define INST_WREN 0x06
#define INST_WRDI 0x04
#define INST_RDSR 0x05
#define INST_WRSR 0x01
#define INST_READ 0x03
#define INST_WRIT 0x02
#define INST_ERSE 0xD8
#define INST_ERBK 0xC7
#define INST_PWDN 0xB9
#define INST_RLSE 0xAB

/*char AD0=0;//LSB
char AD1=0;
char AD2=0;//MSB
*/
// Define the addresses
#define RAMBUF1_ADDRESS     0x0000
#define RAMBUF2_ADDRESS     0x0100
#define BUF_SIZE            256

// EEPROM access function prototypes
void M25PWriteEnable(void);
void M25PWriteDisable(void);
void M25PWriteWait(void);
void M25PReadByte(byte AD0, byte AD1, byte AD2); // one byte only
void M25PReadBytes(byte AD0, byte AD1, byte AD2, byte xdata *buffer, word length);
void M25PWriteByte(byte AD0, byte AD1, byte AD2, byte databyte); // one byte only
bool M25PWriteBytes(byte AD0, byte AD1, byte AD2, byte xdata *buffer, word length); // 1-256 bytes
void M25PReadStatus(void);
void M25PWriteStatus(byte databyte);
void M25PEraseSector(byte AD0, byte AD1, byte AD2);
void M25PEraseChip();
void M25PWait();
void M25PBulkErase();
void M25PFill();//Fill the chip with rand data

// Set up properly aligned RAM buffers
byte xdata ramBuf1[BUF_SIZE] _at_ RAMBUF1_ADDRESS;
byte xdata ramBuf2[BUF_SIZE] _at_ RAMBUF2_ADDRESS;

// Array which will be initialized with random bytes
byte xdata rndData[BUF_SIZE];



int main() {

    int i;

    // Turn off watchdog timer
    WDT_ENABLE(FALSE);

    // Set optimum settings for speed and low power consumption
    MEM_NO_WAIT_STATES();
    FLASH_SET_POWER_MODE(FLASH_STANDBY_BETWEEN_READS);
    
    // All I/Os are inputs after reset. Make I/Os connected to LEDs outputs
    RLED=YLED=GLED=BLED=LED_OFF;
    RLED_OE(TRUE); YLED_OE(TRUE); GLED_OE(TRUE); BLED_OE(TRUE);

    // Set up P0.3 as output to CS_N
	// Set P1.0 for nor
    PORTDIRBIT(1,0,POUT);

    // Fill rndData with random contents.
    srand(0xF012);
    for (i=0; i<BUF_SIZE; i++)
        rndData[i]=rand()%0xFF;
    memcpy(ramBuf1, rndData, BUF_SIZE);

    // Set up SPI for transfer. MSB first, sample on posedge, 
    // output on negedge, SCK = CLK/16, three-wire protocol
    SPI_CONTROL(SPI_SPM_DISABLED | SPI_ENABLE | SPI_MSB_FIRST | 
        SPI_POSEDGE_IDLE0 | SPI_CLK_DIV_8);
    MOSI_OE(TRUE);
	UART0_SETUP(57600, CC1010EB_CLKFREQ, UART_NO_PARITY | UART_RX_TX | UART_POLLED);

      // Read status register
    PORTBIT(1,0) = 0; // Set CS_N low
    SPI_DATA = INST_RDSR;
    while (SPI_IS_ACTIVE);
    SPI_DATA = 0x00; // clock in answer
    while (SPI_IS_ACTIVE);
    PORTBIT(1,0) = 1; // Set CS_N high
    for (i=0;i<8;i++);
	printf("Status %d", SPI_DATA);

    // Set write enable latch
    PORTBIT(1,0) = 0; // Set CS_N low
    SPI_DATA = INST_WREN;
    while (SPI_IS_ACTIVE);
    PORTBIT(1,0) = 1; // Set CS_N high
    for (i=0;i<8;i++);
	
//	M25PWriteStatus(0x00); //Disable any write protection
	
	M25PFill();
	BLED=LED_ON;

	while(1);

    // Write and read a buffer in EEPROM, wraparound address
   // eepromWriteBytes(0xFB, ramBuf1, BUF_SIZE);
  //  eepromReadBytes(0xFB, ramBuf2, BUF_SIZE);
  //  if (memcmp(ramBuf1, ramBuf2, BUF_SIZE))
  //      RLED = LED_ON;
  //  else
  //      GLED = LED_ON;


 // Write and read another buffer, different address size
//    eepromWriteBytes(0x49, ramBuf1, 27);
 //   eepromReadBytes(0x49, ramBuf2, 27);
 //   if (memcmp(ramBuf1, ramBuf2, 27))
 //       RLED = LED_ON;
 //   else
 //       GLED = LED_ON;

    // Write protect 1/4 and read back status register
//    eepromWriteStatus(0x04);
//    eepromReadStatus();

    // Attempt to write protected part
//    eepromWriteByte(0xC0, 0xAA);
//    eepromReadByte(0xC0);
//    if (SPI_DATA != 0xAA)
//        RLED = LED_ON;
//    else
//        YLED = LED_ON;

    // Attempt to write unprotected part
//    eepromWriteByte(0xBF, 0xCC);
//    eepromReadByte(0xBF);
//    if (SPI_DATA != 0xCC)
//        RLED = LED_ON;
//    else
//        YLED = LED_ON;

    // Switch off LEDs
//    RLED = LED_OFF;
//    YLED = LED_OFF;
//    GLED = LED_OFF;

    // Disable protection, write contiguous buffer and check
  //  M25PWriteStatus(0x00);
//    M25PWriteBytes(0xBE, ramBuf1, 4);
//    eepromReadBytes(0xBE, ramBuf2, 4);
//    if (memcmp(ramBuf1, ramBuf2, BUF_SIZE))
//        RLED = LED_ON;
//    else
//        GLED = LED_ON;

    // Check disabling of write
    M25PWriteEnable();
    M25PReadStatus();
//    if (SPI_DATA != 0x02)
 //     RLED = LED_ON;
//    else
//      YLED = LED_ON;
    M25PWriteDisable();
    M25PReadStatus();

    if (SPI_DATA)
      RLED = LED_ON;
    else
      BLED = LED_ON;

    // Disable SPI
    SPI_CONTROL(SPI_DISABLE);
	
    // Infinite loop
    while(1);
}

// EEPROM access functions

// Function reads a byte at the specified address location
// SPDR will contain the read byte
void M25PReadByte(byte AD0, byte AD1, byte AD2) {

    PORTBIT(1,0) = 0; // Set CS_N low
    SPI_DATA = INST_READ; // write instruction
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD2; // write address
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD1; // write address
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD0; // write address
    while (SPI_IS_ACTIVE);
    SPI_DATA = 0x00; // clock in answer
    while (SPI_IS_ACTIVE);
    PORTBIT(1,0) = 1; // Set CS_N high
    M25PWait();
}

// Function reads _length_ bytes from the specified address 
// location and puts them in _buffer_
void M25PReadBytes(byte AD0, byte AD1, byte AD2, byte xdata *buffer, word length) {

    word i;
	GLED=LED_ON;
    PORTBIT(1,0) = 0; // Set CS_N low
    SPI_DATA = INST_READ; // write instruction
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD2; // write address
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD1; // write address
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD0; // write address
    while (SPI_IS_ACTIVE);
    for (i=0; i<length; i++) {
        SPI_DATA = 0x00; // clock in answer
        while (SPI_IS_ACTIVE);
        *buffer = SPI_DATA;
        buffer++;
    }
    PORTBIT(1,0) = 1; // Set CS_N high
    M25PWait();
	GLED=LED_OFF;
}

// Function writes specified byte to the specified address location
void M25PWriteByte(byte AD0, byte AD1, byte AD2, byte databyte) {

    M25PWriteEnable(); // Must enable write latch first
    PORTBIT(1,0) = 0; // Set CS_N low
    SPI_DATA = INST_WRIT; // write instruction
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD2; // write address
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD1; // write address
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD0; // write address
	while (SPI_IS_ACTIVE);
    SPI_DATA = databyte; // write data
    while (SPI_IS_ACTIVE);
    PORTBIT(1,0) = 1; // Set CS_N high
    M25PWait();
    M25PWriteWait();
}

// Function writes _length_ bytes to the specified address location
bool M25PWriteBytes(byte AD0, byte AD1, byte AD2, byte xdata *buffer, word length) {

    word bytes_to_write;
    if (!length)
      return FALSE;
  	YLED=LED_ON;
	bytes_to_write = length;
    M25PWriteEnable(); // Must enable write latch first
    PORTBIT(1,0) = 0; // Set CS_N low
    SPI_DATA = INST_WRIT; // write instruction
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD2; // write address
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD1; // write address
    while (SPI_IS_ACTIVE);
    SPI_DATA = AD0; // write address
	while (SPI_IS_ACTIVE);

    while (bytes_to_write) {
		SPI_DATA = *buffer; // clock in answer
        while (SPI_IS_ACTIVE);
        buffer++;
		bytes_to_write--;
		
	}
      // Post-processing
     PORTBIT(1,0) = 1; // Set CS_N high
     M25PWait();
     M25PWriteWait();
    YLED=LED_OFF;
    return TRUE;
}

// Function reads the EEPROM status register
// SPDR will contain the status byte
void M25PReadStatus(void) {

    PORTBIT(1,0) = 0; // Set CS_N low
    SPI_DATA = INST_RDSR; // write instruction
    while (SPI_IS_ACTIVE);
    SPI_DATA = 0x00; // clock in answer
    while (SPI_IS_ACTIVE);
    PORTBIT(1,0) = 1; // Set CS_N high
    M25PWait();
}

// Function writes the FlashROM status register
void M25PWriteStatus(byte databyte) {

    M25PWriteEnable(); // Must enable write latch first
    PORTBIT(1,0) = 0; // Set CS_N low
    SPI_DATA = INST_WRSR; // write instruction
    while (SPI_IS_ACTIVE);
    SPI_DATA = databyte; // write status byte
    while (SPI_IS_ACTIVE);
    PORTBIT(1,0) = 1; // Set CS_N high
    M25PWait();
    M25PWriteWait();
}

// Function sets the write enable latch
void M25PWriteEnable(void) {

    PORTBIT(1,0) = 0; // Set CS_N low
    SPI_DATA = INST_WREN; // write instruction
    while (SPI_IS_ACTIVE);
    PORTBIT(1,0) = 1; // Set CS_N high
    M25PWait();
}

void M25PBulkErase(void) {
	PORTBIT(1,0)=0;
	SPI_DATA=INST_ERBK; //Bulk Erase Instruction
	while (SPI_IS_ACTIVE);
	PORTBIT(1,0)=1;
	M25PWait();
	M25PWriteWait();

}
// Function resets the write enable latch
void M25PWriteDisable(void) {

    PORTBIT(1,0) = 0; // Set CS_N low
    SPI_DATA = INST_WRDI; // write instruction
    while (SPI_IS_ACTIVE);
    PORTBIT(1,0) = 1; // Set CS_N high
    M25PWait();
}

// Function counts 8 clock cycles and waits for write to finish
void M25PWait(void) {

    int i;

    for (i=0; i<8; i++);
}

// Function waits for write to finish
void M25PWriteWait(void) {

    // Wait until finished with write
    while (1) {
        M25PReadStatus();
        if (!(SPI_DATA&0x01))   // Write in progress ?
            break;
		else (printf("."));
    }
}

void M25PFill()
{
	long int address=0;
	unsigned char WAD0, WAD1, WAD2;
	const int num_pages=4096;
	int i=0;
	
	RLED=LED_ON;
    M25PBulkErase(); //Erase the Chip
	RLED=LED_OFF;

	for (i=0; i<num_pages; i++)
	{
		WAD0 = address;//0..7
		WAD1 = address >> 8;//8..15
		WAD2 = address >> 16;//16..23 
		M25PWriteBytes(WAD0,WAD1,WAD2, rndData, BUF_SIZE );
		
//		M25PReadBytes(WAD0,WAD1,WAD2, ramBuf1, BUF_SIZE );
		//if (memcmp(rndData, ramBuf1, BUF_SIZE))
    	    {
		//		RLED = LED_ON;
		//		printf("\n Fatal Error on page %d", i);
			 }

	    address+=256;
	}
}