char BSL430_writeByte(unsigned long addr, char data)
{
char exceptions;
if (LockedStatus == UNLOCKED)
{
exceptions = SUCCESSFUL_OPERATION;
#ifdef RAM_BASED_BSL
while (FCTL3 & BUSY) ;
#endif
__data20_write_char(addr, data);
#ifdef RAM_BASED_BSL
while (FCTL3 & BUSY) ;
#endif
if (data != __data20_read_char(addr))
{
exceptions = MEMORY_WRITE_CHECK_FAILED;
}
#ifndef RAM_WRITE_ONLY_BSL
# ifndef DO_NOT_CHECK_VPE
if (FCTL4 & VPE)
{
exceptions = VOLTAGE_CHANGE_DURING_PROGRAM;
}
# endif
#endif
}
else
{
exceptions = BSL_LOCKED;
}
return exceptions;
}
void BSL430_writeByte(uint32_t addr, char data)
{
while (FCTL3 & BUSY) ;
__data20_write_char(addr, data);
while (FCTL3 & BUSY) ;
if (data != __data20_read_char(addr))
{
putchar_('E');
}
}
mp_ret_t mp_flash_read(mp_flash_t *flash, mp_flash_addr_t offset, int size, void *in_mem) {
mp_flash_addr_t addr = flash->base+offset;
unsigned char *ptr;
int a;
ptr = (unsigned char *)in_mem;
for(a=0; a<size; a++, ptr++)
*ptr = __data20_read_char(addr+a);
return(TRUE);
}
/******************************************************************************
* @fn HalOTARead
*
* @brief Read from the storage medium according to image type.
*
* @param oset - Offset into the monolithic image.
* @param pBuf - Pointer to the buffer in which to copy the bytes read.
* @param len - Number of bytes to read.
* @param type - Which image: HAL_OTA_RC or HAL_OTA_DL.
*
* @return None.
*/
void HalOTARead(uint32 oset, uint8 *pBuf, uint16 len, image_t type)
{
if (HAL_OTA_DL == type)
{
HalXNVRead(oset, pBuf, len);
}
else
{
istate_t ss = __get_interrupt_state();
__disable_interrupt();
if ((oset + LO_ROM_BEG) > LO_ROM_END) // Read from active image in high flash.
{
oset = HI_ROM_BEG + oset - (LO_ROM_END - LO_ROM_BEG + 1);
}
else // Read from active image in low flash.
{
uint8 *ptr = (uint8 *)((uint16)oset + LO_ROM_BEG);
while (len)
{
// If a read crosses from low to high flash, break and fall into high flash read loop.
if (ptr > (uint8 *)LO_ROM_END)
{
oset = HI_ROM_BEG;
break;
}
*pBuf++ = *ptr++;
len--;
}
}
while (len--)
{
*pBuf++ = __data20_read_char(oset++);
}
__set_interrupt_state(ss);
}
}
char BSL430_readMemory(unsigned long addr, unsigned int length, char* data)
{
unsigned long i;
#ifdef RAM_BASED_BSL
flushBuffer();
#endif
char exceptions = SUCCESSFUL_OPERATION;
for (i = addr + length - 1; i >= addr; i--)
{
if (LockedStatus == UNLOCKED)
{
data[i - addr] = __data20_read_char(i);
}
else
{
return BSL_LOCKED;
}
}
return exceptions;
}
/******************************************************************************
* @fn crcCalc
*
* @brief Run the CRC16 Polynomial calculation over the RC image.
*
* @param None.
*
* @return The CRC16 calculated.
*/
static uint16 crcCalc(void)
{
preamble_t preamble;
uint32 oset;
uint8 *ptr;
uint16 crc = 0;
HalOTARead(PREAMBLE_OFFSET, (uint8 *)&preamble, sizeof(preamble_t), HAL_OTA_RC);
preamble.programLength = HI_ROM_BEG + preamble.programLength - (LO_ROM_END - LO_ROM_BEG + 1);
// Skipping 2-byte CRC and CRC shadow at the beginning of image.
for (ptr = (uint8 *)LO_ROM_BEG+4; ptr <= (uint8 *)LO_ROM_END; ptr++)
{
crc = runPoly(crc, *ptr);
}
for (oset = HI_ROM_BEG; oset < preamble.programLength; oset++)
{
crc = runPoly(crc, __data20_read_char(oset));
}
return crc;
}
int BSL430_crcCheck(unsigned long addr, unsigned int length, int* result)
{
unsigned long i;
#ifdef RAM_BASED_BSL
flushBuffer();
#endif
CRCINIRES = 0xFFFF;
for (i = addr; i < addr + length; i++)
{
if (LockedStatus == UNLOCKED)
{
CRCDIRB_L = __data20_read_char(i);
}
else
{
return BSL_LOCKED;
}
}
*result = CRCINIRES;
return SUCCESSFUL_OPERATION;
}
