eeprom.c

/**
 * @file i2c_lib.C
 * @brief CPU EEPROM support library
 *
 * @copyright (C) 2014 Lodz University of Technology, Lodz, Poland  (TUL)
 * @copyright (C) 2014 Deutsches Elektronen-Synchrotron, Hamburg, Germany (DESY)
 * @author Pawel Plewinski (TUL)
 * @author Dariusz Makowski (TUL)
 * @par License
 *
 * Redistribution and use in source and binary forms, with or without
 * modification is not allowed. Exceptions are regulated by separate License document. In all cases it is requested to provide the above header.
 *
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "eeprom.h"
#include "power_monitor.h"


#include <avr/eeprom.h>
#include <util/delay.h>

/**
 * \brief Initialize EEPROM, if empty or corrupted
 */
void initEEPROM( void )
{
	if (eeprom_read_byte(EEPROM_ADDR_INIT) != EEPROM_INIT_VALUE)
	{
        printf("!Initializing EEPROM with default values\r\n");
		eeprom_write_byte(EEPROM_ADDR_LIMIT_MASK, 0xFF);
		eeprom_write_dword(EEPROM_ADDR_LIMIT_CHANNEL0, MAX_CURRENT_LIMIT);
		eeprom_write_dword(EEPROM_ADDR_LIMIT_CHANNEL1, MAX_CURRENT_LIMIT);
		eeprom_write_dword(EEPROM_ADDR_LIMIT_CHANNEL2, MAX_CURRENT_LIMIT);
		eeprom_write_dword(EEPROM_ADDR_LIMIT_CHANNEL3, MAX_CURRENT_LIMIT);
		eeprom_write_dword(EEPROM_ADDR_LIMIT_CHANNEL4, MAX_CURRENT_LIMIT);
		eeprom_write_dword(EEPROM_ADDR_LIMIT_CHANNEL5, MAX_CURRENT_LIMIT);
		eeprom_write_dword(EEPROM_ADDR_LIMIT_CHANNEL6, MAX_CURRENT_LIMIT);
		eeprom_write_dword(EEPROM_ADDR_LIMIT_CHANNEL7, MAX_CURRENT_LIMIT);
		
		eeprom_write_byte(EEPROM_ADDR_FWUPGRADE, EEPROM_FWREADY_VALUE);
		
		eeprom_write_byte(EEPROM_ADDR_INIT, EEPROM_INIT_VALUE);
		
		eeprom_write_name("FRED standard");
		eeprom_write_inv_no("0000");
		
		//init voltage masks
		eeprom_write_byte(EEPROM_ADDR_UNCONDITIONAL_MASK, EEPROM_UNCONDITIONAL_MASK_DEFAUALT);
		eeprom_write_byte(EEPROM_ADDR_HOTPLUG_MASK, EEPROM_HOTPLUG_MASK_DEFAULT);
	}
	if(eeprom_read_byte(EEPROM_ADDR_FWUPGRADE) != EEPROM_FWREADY_VALUE)
	{
		eeprom_write_byte(EEPROM_ADDR_FWUPGRADE, EEPROM_FWREADY_VALUE);
	}
}

/**
 * \brief Write upgrade byte to EEPROM - bootloader will wait for new FW after reset
 */
void eeprom_write_upgrade(void)
{
	eeprom_write_byte(EEPROM_ADDR_FWUPGRADE, EEPROM_FWUPGRADE_VALUE);	
	_delay_ms(100);
}

/**
 * \brief Write board name to EEPROM
 * 
 * \param name Name
 */
void eeprom_write_name( char * name )
{
	int i = 0;
	for (i = 0; i < EEPROM_STR_LEN; i++)
	{
		if (name[i] != '\0')
			eeprom_write_byte(EEPROM_ADDR_BOARD_NAME + i, name[i]);
		else 
			break;
	}
	eeprom_write_byte(EEPROM_ADDR_BOARD_NAME + i, name[i]);
}

/**
 * \brief Write box inventory number to EEPROM
 * 
 * \param number Number
 */
void eeprom_write_inv_no( char * number )
{
	int i = 0;
	for (i = 0; i < EEPROM_STR_LEN; i++)
	{
		if (number[i] != '\0')
			eeprom_write_byte(EEPROM_ADDR_INV_NO + i, number[i]);
		else 
			break;
	}
	eeprom_write_byte(EEPROM_ADDR_INV_NO + i, number[i]);	
}

/**
 * \brief Read board name from EEPROM
 * 
 * \param name Name
 */
void eeprom_read_name(char * name)
{
	int i = 0;
	char c;
	while ((c = eeprom_read_byte(EEPROM_ADDR_BOARD_NAME + i)) != '\0')
	{
		name[i] = c;
		i++;
	}
	name[i] = '\0';
}

/**
 * \brief Read box inventory number from EEPROM
 * 
 * \param nr Number
 */
void eeprom_read_inv_no(char * nr)
{
	int i = 0;
	char c;
	while ((c = eeprom_read_byte(EEPROM_ADDR_INV_NO + i)) != '\0')
	{
		nr[i] = c;
		i++;
	}
	nr[i] = '\0';	
}

void eeprom_update_cur_limit( unsigned channel)
{
	eeprom_write_dword(channels[channel].eeprom_addr, channels[channel].current_limit);
}

void eeprom_write_unconditional_mask( uint8_t mask )
{
	eeprom_write_byte(EEPROM_ADDR_UNCONDITIONAL_MASK, mask);
}

void eeprom_write_hotplug_mask( uint8_t mask )
{
	eeprom_write_byte(EEPROM_ADDR_HOTPLUG_MASK, mask);	
}

uint8_t eeprom_read_unconditional_mask( )
{
	return eeprom_read_byte(EEPROM_ADDR_UNCONDITIONAL_MASK);
}

uint8_t eeprom_read_hotplug_mask( )
{
	return eeprom_read_byte(EEPROM_ADDR_HOTPLUG_MASK);
}