// This file has been prepared for Doxygen automatic documentation generation.
/*! \file ********************************************************************
*
* Atmel Corporation
*
* \li File:               eeprom.c
* \li Compiler:           IAR EWAAVR 3.10c
* \li Support mail:       avr@atmel.com
*
* \li Supported devices:  All devices with split EEPROM erase/write
*                         capabilities can be used.
*                         The example is written for ATmega48.
*
* \li AppNote:            AVR103 - Using the EEPROM Programming Modes.
*
* \li Description:        Example on how to use the split EEPROM erase/write
*                         capabilities in e.g. ATmega48. All EEPROM
*                         programming modes are tested, i.e. Erase+Write,
*                         Erase-only and Write-only.
*
*                         $Revision: 1.6 $
*                         $Date: Friday, February 11, 2005 07:16:44 UTC $
****************************************************************************/
//#include <avr/io.h>
//#include <avr/interrupt.h>


// ecmc added
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#define EEPROM_DUMMY_FILE "./ecmc_grbl_eeprom.txt"
#define EEPROM_MEM_SIZE 1024
char buffer[EEPROM_MEM_SIZE];


/* These EEPROM bits have different names on different devices. */
//#ifndef EEPE
//		#define EEPE  EEWE  //!< EEPROM program/write enable.
//		#define EEMPE EEMWE //!< EEPROM master program/write enable.
//#endif

/* These two are unfortunately not defined in the device include files. */
//#define EEPM1 5 //!< EEPROM Programming Mode Bit 1.
//#define EEPM0 4 //!< EEPROM Programming Mode Bit 0.

/* Define to reduce code size. */
//#define EEPROM_IGNORE_SELFPROG //!< Remove SPM flag polling.

//unsigned char ecmc_mem_to_file();
// Init file
void ecmc_init_file() {
  printf("%s:%s:%d\n",__FILE__,__FUNCTION__,__LINE__);
  memset(&buffer[0],0,EEPROM_MEM_SIZE);
  //ecmc_mem_to_file();
}

// Read file to buffer[]
//unsigned char  ecmc_file_to_mem()
//{
//  //printf("%s:%s:%d EEPROM simulated by file..\n",__FILE__,__FUNCTION__,__LINE__);
//
//  FILE* fh = fopen(EEPROM_DUMMY_FILE, "rd");
//
//  if (fh == NULL)
//    {
//        printf("something went wrong and file could not be opened");
//        return 1;
//    }
//    unsigned char c = 0;    
//    for (int i = 0; i < EEPROM_MEM_SIZE ; i++) { 
//         // Get the characters
//        buffer[i] = fgetc(fh);
//    }
//   
//    fclose(fh);
//    return 0;
//}

// Write buffer[] to file
//unsigned char ecmc_mem_to_file()
//{
////  printf("%s:%s:%d EEPROM simulated by file..\n",__FILE__,__FUNCTION__,__LINE__);
//
//  FILE* fh = fopen(EEPROM_DUMMY_FILE, "w");
//
//  if (fh == NULL)
//    {
//        printf("something went wrong and file could not be opened");
//        return 1;
//    }    
//    for (int i = 0; i < EEPROM_MEM_SIZE ; i++) { 
//         // Get the characters
//		fputc (buffer[i], fh);     
//    }
//   
//    fclose(fh);
//    return 0;
//}


/*! \brief  Read byte from EEPROM.
 *
 *  This function reads one byte from a given EEPROM address.
 *
 *  \note  The CPU is halted for 4 clock cycles during EEPROM read.
 *
 *  \param  addr  EEPROM address to read from.
 *  \return  The byte read from the EEPROM address.
 */
unsigned char eeprom_get_char( unsigned int addr )
{
  //ecmc_file_to_mem();
  //printf("%s:%s:%d addr: %ud, value %d..\n",__FILE__,__FUNCTION__,__LINE__,addr,buffer[addr]);

  return buffer[addr];

  //do {} while( EECR & (1<<EEPE) ); // Wait for completion of previous write.
  //EEAR = addr; // Set EEPROM address register.
  //EECR = (1<<EERE); // Start EEPROM read operation.
  //return EEDR; // Return the byte read from EEPROM.
}

/*! \brief  Write byte to EEPROM.
 *
 *  This function writes one byte to a given EEPROM address.
 *  The differences between the existing byte and the new value is used
 *  to select the most efficient EEPROM programming mode.
 *
 *  \note  The CPU is halted for 2 clock cycles during EEPROM programming.
 *
 *  \note  When this function returns, the new EEPROM value is not available
 *         until the EEPROM programming time has passed. The EEPE bit in EECR
 *         should be polled to check whether the programming is finished.
 *
 *  \note  The EEPROM_GetChar() function checks the EEPE bit automatically.
 *
 *  \param  addr  EEPROM address to write to.
 *  \param  new_value  New EEPROM value.
 */
void eeprom_put_char( unsigned int addr, unsigned char new_value )
{
  //printf("%s:%s:%d addr: %ud, value %d..\n",__FILE__,__FUNCTION__,__LINE__,addr,new_value);

  //ecmc_file_to_mem();
  buffer[addr] = new_value;
	//ecmc_mem_to_file();

	//char old_value; // Old EEPROM value.
	//char diff_mask; // Difference mask, i.e. old value XOR new value.
//
	//cli(); // Ensure atomic operation for the write operation.
	//
	//do {} while( EECR & (1<<EEPE) ); // Wait for completion of previous write.
	//#ifndef EEPROM_IGNORE_SELFPROG
	//do {} while( SPMCSR & (1<<SELFPRGEN) ); // Wait for completion of SPM.
	//#endif
	//
	//EEAR = addr; // Set EEPROM address register.
	//EECR = (1<<EERE); // Start EEPROM read operation.
	//old_value = EEDR; // Get old EEPROM value.
	//diff_mask = old_value ^ new_value; // Get bit differences.
	//
	//// Check if any bits are changed to '1' in the new value.
	//if( diff_mask & new_value ) {
	//	// Now we know that _some_ bits need to be erased to '1'.
	//	
	//	// Check if any bits in the new value are '0'.
	//	if( new_value != 0xff ) {
	//		// Now we know that some bits need to be programmed to '0' also.
	//		
	//		EEDR = new_value; // Set EEPROM data register.
	//		EECR = (1<<EEMPE) | // Set Master Write Enable bit...
	//		       (0<<EEPM1) | (0<<EEPM0); // ...and Erase+Write mode.
	//		EECR |= (1<<EEPE);  // Start Erase+Write operation.
	//	} else {
	//		// Now we know that all bits should be erased.
//
	//		EECR = (1<<EEMPE) | // Set Master Write Enable bit...
	//		       (1<<EEPM0);  // ...and Erase-only mode.
	//		EECR |= (1<<EEPE);  // Start Erase-only operation.
	//	}
	//} else {
	//	// Now we know that _no_ bits need to be erased to '1'.
	//	
	//	// Check if any bits are changed from '1' in the old value.
	//	if( diff_mask ) {
	//		// Now we know that _some_ bits need to the programmed to '0'.
	//		
	//		EEDR = new_value;   // Set EEPROM data register.
	//		EECR = (1<<EEMPE) | // Set Master Write Enable bit...
	//		       (1<<EEPM1);  // ...and Write-only mode.
	//		EECR |= (1<<EEPE);  // Start Write-only operation.
	//	}
	//}
	//
	//sei(); // Restore interrupt flag state.
}

// Extensions added as part of Grbl 


void memcpy_to_eeprom_with_checksum(unsigned int destination, char *source, unsigned int size) {
  //printf("%s:%s:%d EEPROM simulated by file..\n",__FILE__,__FUNCTION__,__LINE__);
  unsigned char checksum = 0;
  for(; size > 0; size--) { 
    checksum = (checksum << 1) || (checksum >> 7);
    checksum += *source;
    eeprom_put_char(destination++, *(source++)); 
  }
  eeprom_put_char(destination, checksum);
}

int memcpy_from_eeprom_with_checksum(char *destination, unsigned int source, unsigned int size) {
  printf("%s:%s:%d EEPROM simulated by file..\n",__FILE__,__FUNCTION__,__LINE__);
  unsigned char data, checksum = 0;
  for(; size > 0; size--) { 
    data = eeprom_get_char(source++);
    checksum = (checksum << 1) || (checksum >> 7);
    checksum += data;    
    *(destination++) = data; 
  }
  return(checksum == eeprom_get_char(source));
}

// end of file