// write default blackfin
void flash_write_ldr(void) {
#if 1
#else
// flashc_memset32((void*)&(flash_nvram_data.ldrSize), bfinLdrSize, 4, true);
// flashc_memcpy((void*)&(flash_nvram_data.ldrData), (const void*)bfinLdrData, bfinLdrSize, true);
// seeing some missing pages, so try writing one page at a time
u32 i;
u32 nPages = bfinLdrSize / 0x200;
u32 rem;
const u8* pSrc;
u8* pDst;
// write size
flashc_memset32((void*)&(flash_nvram_data.ldrSize), bfinLdrSize, 4, true);
// write data
pSrc = (const void*)bfinLdrData;
pDst = (void*)&(flash_nvram_data.ldrData);
for(i=0; i<nPages; i++) {
flashc_memcpy((void*)pDst, (const void*)pSrc, 0x200, true);
pDst += 0x200;
pSrc += 0x200;
delay_ms(1);
}
// remaining bytes
rem = bfinLdrSize - (nPages * 0x200);
flashc_memcpy((void*)pDst, (const void*)pSrc, rem, true);
#endif
}
void flash_write(void) {
// print_dbg("\r write preset ");
// print_dbg_ulong(preset_select);
flashc_memcpy((void *)&flashy.m[preset_select], &m, sizeof(m), true);
flashc_memcpy((void *)&flashy.glyph[preset_select], &glyph, sizeof(glyph), true);
flashc_memset8((void*)&(flashy.preset_select), preset_select, 1, true);
}
u8 HV_InitAllSlotData (void)
{
// u8 RandomCharArray_au8[16];
u32 i;
// Create salt
for (i = 0; i < 2; i++)
{
// Get a random number from smart card
if (FALSE == GetRandomNumber_u32 (16, &DecryptedHiddenVolumeSlotsData_au8[i * 16]))
{
CI_LocalPrintf ("GetRandomNumber fails\n\r");
return (FALSE);
}
}
// Fill hidden volume flash page with random chars
for (i = 0; i < 16; i++)
{
// Get a random number from smart card
if (FALSE == GetRandomNumber_u32 (16, &DecryptedHiddenVolumeSlotsData_au8[HV_SALT_SIZE + i * 16]))
{
CI_LocalPrintf ("GetRandomNumber fails\n\r");
return (FALSE);
}
}
// Write magic number to flash
DecryptedHiddenVolumeMagicNumber_u32 = HV_MAGIC_NUMBER_INIT;
flashc_memcpy ((u8 *) HV_MAGIC_NUMBER_ADDRESS, &DecryptedHiddenVolumeMagicNumber_u32, HV_MAGIC_NUMBER_SIZE, TRUE);
// Write ram data to flash
flashc_memcpy ((u8 *) HV_SALT_START_ADDRESS, DecryptedHiddenVolumeSlotsData_au8, HV_SALT_SIZE + HV_SLOT_SIZE * HV_SLOT_COUNT, TRUE);
CI_LocalPrintf ("Init hidden volume slot data\r\n");
CI_LocalPrintf ("Salt\r\n");
CI_LocalPrintf ("Encrypted data :\r\n");
HexPrint (HV_SALT_SIZE, DecryptedHiddenVolumeSlotsData_au8);
CI_LocalPrintf ("\r\n\r\n");
for (i = 0; i < HV_SLOT_COUNT; i++)
{
CI_LocalPrintf ("Slot %d\r\n", i);
CI_LocalPrintf ("Encrypted data :\r\n");
HexPrint (HV_SLOT_SIZE, DecryptedHiddenVolumeSlotsData_au8 + HV_SALT_SIZE + i * HV_SLOT_SIZE);
CI_LocalPrintf ("\r\n\r\n");
}
return (TRUE);
}
u8 WriteScId (u32 *ScId_u32)
{
flashc_memcpy(AVR32_FLASHC_USER_PAGE + 142,ScId_u32,4,TRUE);
StickConfiguration_st.ActiveSmartCardID_u32 = *ScId_u32;
return (TRUE);
}
void DFU_FirmwareResetUserpage (void)
{
u8 DFU_String_au8[4];
/*
flashc_erase_all_gp_fuses (TRUE);
flashc_write_gp_fuse_bit
FC07FFFF
flashc_set_all_gp_fuses ();
*/
flashc_write_gp_fuse_bit (30,0); // Set SP_IO_COND_EN = 0 for DUF 1.0.3
flashc_write_gp_fuse_bit (31,0); // Set to 0 to start application for DUF 1.0.3
flashc_erase_user_page (TRUE);
DFU_String_au8[0] = TOOL_DFU_ISP_CONFIG_WORD_DEFAULT_0_0;
DFU_String_au8[1] = TOOL_DFU_ISP_CONFIG_WORD_DEFAULT_0_1;
DFU_String_au8[2] = TOOL_DFU_ISP_CONFIG_WORD_DEFAULT_0_2;
DFU_String_au8[3] = TOOL_DFU_ISP_CONFIG_WORD_DEFAULT_0_3;
/*
DFU_String_au8[0] = TOOL_DFU_ISP_CONFIG_WORD_START_APPL_0_0;
DFU_String_au8[1] = TOOL_DFU_ISP_CONFIG_WORD_START_APPL_0_1;
DFU_String_au8[2] = TOOL_DFU_ISP_CONFIG_WORD_START_APPL_0_2;
DFU_String_au8[3] = TOOL_DFU_ISP_CONFIG_WORD_START_APPL_0_3;
*/
flashc_memcpy(TOOL_DFU_ISP_CONFIG_ADDR_1,DFU_String_au8,4,TRUE);
}
u8 HV_WriteSlot_u8 (u8 SlotNr_u8, HiddenVolumeKeySlot_tst * SlotData_st, u8 * SlotKey_pu8)
{
u32 i;
u8 Buffer_au8[HV_SLOT_SIZE];
// u8 HiddenVolumeSlotsKey_au8[AES_KEYSIZE_256_BIT];
if (FALSE == DecryptedHiddenVolumeSlotsActive_u8)
{
return (FALSE); // Slot data is not in ram
}
// Fill buffer with random numbers
for (i = 0; i < HV_SLOT_SIZE; i++)
{
Buffer_au8[i] = rand () % 256;
}
// Set magic number
// SlotData_st->MagicNumber_u32 = HV_MAGIC_NUMBER_SLOT_ENTRY;
// Set CRC32
SlotData_st->Crc_u32 = generateCRC_len ((u8 *) SlotData_st, (sizeof (HiddenVolumeKeySlot_tst) / 4) - 1); // -1 for CRC variable
#ifdef DEBUG_KEYS
CI_LocalPrintf ("HV_WriteSlot_u8 %d - CRC 0x%08x\r\n", SlotNr_u8, SlotData_st->Crc_u32);
CI_LocalPrintf ("Decrypted data :\r\n");
HexPrint (sizeof (HiddenVolumeKeySlot_tst), SlotData_st);
CI_LocalPrintf ("\r\n");
#endif
memcpy (Buffer_au8, (u8 *) SlotData_st, sizeof (HiddenVolumeKeySlot_tst));
// Encrypt slot data
AES_KeyEncryption (HV_SLOT_SIZE, Buffer_au8, SlotKey_pu8, AES_PMODE_CIPHER, SlotNr_u8);
// Write encrypted slot data into ram
memcpy ((u8 *) (DecryptedHiddenVolumeSlotsData_au8 + HV_SALT_SIZE + SlotNr_u8 * HV_SLOT_SIZE), Buffer_au8, HV_SLOT_SIZE);
#ifdef DEBUG_KEYS
CI_LocalPrintf ("Encrypted data :\r\n");
HexPrint (HV_SLOT_SIZE, &DecryptedHiddenVolumeSlotsData_au8[HV_SALT_SIZE + SlotNr_u8 * HV_SLOT_SIZE]);
CI_LocalPrintf ("\r\n");
#endif
// Encrypt all slots data (max 256 byte per encryption)
AES_KeyEncryption (HV_SLOT_COUNT * HV_SLOT_SIZE, &DecryptedHiddenVolumeSlotsData_au8[HV_SALT_SIZE], DecryptedHiddenVolumeSlotsKey_au8,
AES_PMODE_CIPHER, SlotNr_u8);
// Write ram data to flash
flashc_memcpy ((u8 *) (HV_SALT_START_ADDRESS + HV_SALT_SIZE), &DecryptedHiddenVolumeSlotsData_au8[HV_SALT_SIZE], HV_SLOT_SIZE * HV_SLOT_COUNT,
TRUE);
return (TRUE);
}
u8 WriteStickConfigurationToUserPage (void)
{
// Set actual firmware version
StickConfiguration_st.VersionInfo_au8[0] = VERSION_MAJOR;
StickConfiguration_st.VersionInfo_au8[1] = VERSION_MINOR;
StickConfiguration_st.VersionInfo_au8[2] = 0; // Build number not used
StickConfiguration_st.VersionInfo_au8[3] = 0; // Build number not used
flashc_memcpy(AVR32_FLASHC_USER_PAGE + 72,&StickConfiguration_st,30,TRUE);
return (TRUE);
}
void settings_write(void)
{
uint32_t chk = get_crc();
if (chk != settings.settings_words[USER_PAGE_CHECKSUM])
{
settings.settings_words[USER_PAGE_CHECKSUM] = chk;
settings.settings_words[BOOT_LOADER_CONFIGURATION] = 0x929E1424; // boot loader config word
flashc_memcpy(AVR32_FLASHC_USER_PAGE, & settings, 512, TRUE);
}
}
/*! \brief This is an example demonstrating flash read / write data accesses
* using the FLASHC driver.
*
* \param caption Caption to print before running the example.
* \param nvram_data Pointer to the NVRAM data structure to use in the example.
*/
static void flash_rw_example(const char *caption, nvram_data_t *nvram_data)
{
static const uint8_t write_data[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
print_dbg(caption);
print_dbg("Initial values of NVRAM variables:\r\n");
print_nvram_variables(nvram_data);
print_dbg("\r\nClearing NVRAM variables...");
flashc_memset((void *)nvram_data, 0x00, 8, sizeof(*nvram_data), true);
print_dbg("\r\nNVRAM variables cleared:\r\n");
print_nvram_variables(nvram_data);
print_dbg("\r\nWriting new values to NVRAM variables...");
flashc_memcpy((void *)&nvram_data->var8, &write_data, sizeof(nvram_data->var8), true);
flashc_memcpy((void *)&nvram_data->var16, &write_data, sizeof(nvram_data->var16), true);
flashc_memcpy((void *)&nvram_data->var8_3, &write_data, sizeof(nvram_data->var8_3), true);
flashc_memcpy((void *)&nvram_data->var32, &write_data, sizeof(nvram_data->var32), true);
print_dbg("\r\nNVRAM variables written:\r\n");
print_nvram_variables(nvram_data);
}
void DFU_DisableFirmwareUpdate (void)
{
u8 DFU_String_au8[4];
DFU_String_au8[0] = TOOL_DFU_ISP_CONFIG_WORD_START_APPL_0;
DFU_String_au8[1] = TOOL_DFU_ISP_CONFIG_WORD_START_APPL_1;
DFU_String_au8[2] = TOOL_DFU_ISP_CONFIG_WORD_START_APPL_2;
DFU_String_au8[3] = TOOL_DFU_ISP_CONFIG_WORD_START_APPL_3;
flashc_memcpy(TOOL_DFU_ISP_CONFIG_ADDR_1,DFU_String_au8,4,TRUE);
flashc_write_gp_fuse_bit (30,0); // Set SP_IO_COND_EN = 0 for DUF 1.0.3
flashc_write_gp_fuse_bit (31,0); // Set to 0 to start application for DUF 1.0.3
}
// parse a hex record and write the contents to flash if appropriate
// return 1 if EOF, 0 otherwise
extern u8 flash_write_hex_record(u8* data) {
static hexRecord_t rec;
static u32 addrOff = 0;
static u32 dst;
static char hexBuf[9] = {0,0,0,0,0,0,0,0,0};
int err;
err = parse_raw_hex_record(data, &rec);
if(err) {
// print_dbg("\r\n failure parsing hex record: \r\n");
// print_dbg((const char*)data);
screen_line(0, 6, "WARNING:", 0xf);
screen_line(0, 7, "error parsing hex record!", 0xf);
screen_refresh();
} else {
switch(rec.type) {
case HEX_EXT_LINEAR_ADDRESS:
addrOff = rec.address;
break;
case HEX_DATA:
/* // print_dbg("\r\n writing firmware to flash at address: "); */
/* // print_dbg_hex(addrOff + rec.address); */
dst = addrOff + rec.address;
/// TEST!!
if(dst < FIRMWARE_FLASH_ADDRESS) {
// if(0) {
// don't allow writes to anything below the runtime location!
// this is where the bootloader lives!
// app data goes at the end of flash.
screen_line(0, 6, "WARNING:", 0xf);
screen_line(0, 7, "scary address! ", 0xf);
uint_to_hex_ascii( hexBuf, dst);
screen_line(64, 7, hexBuf, 0xf);
} else {
flashc_memcpy( (void*)(dst), rec.data, rec.count, 1);
}
break;
default:
;;
}
}
return 0;
}
void DFU_EnableFirmwareUpdate (void)
{
u8 DFU_String_au8[4];
DFU_String_au8[0] = TOOL_DFU_ISP_CONFIG_WORD_START_DFU_0;
DFU_String_au8[1] = TOOL_DFU_ISP_CONFIG_WORD_START_DFU_1;
DFU_String_au8[2] = TOOL_DFU_ISP_CONFIG_WORD_START_DFU_2;
DFU_String_au8[3] = TOOL_DFU_ISP_CONFIG_WORD_START_DFU_3;
flashc_memcpy(TOOL_DFU_ISP_CONFIG_ADDR_1,DFU_String_au8,4,TRUE);
flashc_erase_gp_fuse_bit (30,0); // Set SP_IO_COND_EN = 1 for DUF 1.0.3
flashc_erase_gp_fuse_bit (31,0); // Set to 1 to start bootloader for DUF 1.0.3
flashc_write_gp_fuse_bit (30,1); // Set SP_IO_COND_EN = 1 for DUF 1.0.3
flashc_write_gp_fuse_bit (31,1); // Set to 1 to start application for DUF 1.0.3
}
int snmp_set_flashstatus (int32_t arg, const uint8_t * req, int req_len)
{
if (req[ req_len - 1] == 2) // least significant byte == 2
{
uint32_t chk = get_crc();
if (chk != settings.settings_words[USER_PAGE_CHECKSUM])
{
settings.settings_words[USER_PAGE_CHECKSUM] = chk;
settings.settings_words[BOOT_LOADER_CONFIGURATION] = 0x929E1424; // boot loader config word
flashc_memcpy(AVR32_FLASHC_USER_PAGE, & settings, 512, TRUE);
settings_set_home_ref();
}
}
return 0;
}
void onboard_parameters_write_parameters_to_flashc(onboard_parameters_t* onboard_parameters)
{
onboard_parameters_set_t* param_set = onboard_parameters->param_set;
float cksum1, cksum2;
cksum1 = 0;
cksum2 = 0;
uint8_t i;
size_t bytes_to_write = 0;
nvram_data_t* nvram_array = (nvram_data_t*) MAVERIC_FLASHC_USER_PAGE_START_ADDRESS;
nvram_data_t local_array;
local_array.values[0] = param_set->param_count;
cksum1 += local_array.values[0];
cksum2 += cksum1;
print_util_dbg_print("Begin write to flashc...\r\n");
for (i = 1; i <= param_set->param_count; i++)
{
// local_array.values[i] = onboard_parameters_read_parameter(onboard_parameters, i-1);
local_array.values[i] = *(param_set->parameters[i-1].param);
cksum1 += local_array.values[i];
cksum2 += cksum1;
}
local_array.values[param_set->param_count + 1] = cksum1;
local_array.values[param_set->param_count + 2] = cksum2;
bytes_to_write = 4 * (param_set->param_count + 3); // (1 param_count + parameters + 2 checksums) floats
if(bytes_to_write < MAVERIC_FLASHC_USER_PAGE_FREE_SPACE)
{
flashc_memcpy((void *)nvram_array, &local_array, bytes_to_write, true);
print_util_dbg_print("Write to flashc completed.\r\n");
}
else
{
print_util_dbg_print("Attempted to write too many parameters on flash user page, aborted.\r\n");
}
}
u8 WriteMatrixColumsUserPWToUserPage (u8 *data)
{
flashc_memcpy(AVR32_FLASHC_USER_PAGE + 32,data,20,TRUE);
return (TRUE);
}
u32 EraseLocalFlashKeyValues_u32 (void)
{
u32 i;
u32 i1;
// Clear user page
for (i1=0;i1<5;i1++)
{
for (i=0;i<256;i++)
{
EraseStoreData_au8[i] = (u8)(rand () % 256);
}
flashc_memcpy((void*)AVR32_FLASHC_USER_PAGE,EraseStoreData_au8,256,TRUE);
}
flashc_erase_user_page (TRUE);
// Set default values
InitStickConfigurationToUserPage_u8 ();
DFU_DisableFirmwareUpdate (); // Stick always starts in application mode
CheckForNewSdCard (); // Get SD ID
// Clear password safe
for (i1=0;i1<5;i1++)
{
for (i=0;i<256;i++)
{
EraseStoreData_au8[i] = (u8)(rand () % 256);
}
flashc_memcpy((void*)(PWS_FLASH_START_ADDRESS ),EraseStoreData_au8,256,TRUE);
flashc_memcpy((void*)(PWS_FLASH_START_ADDRESS+256),EraseStoreData_au8,256,TRUE);
}
flashc_erase_page(PWS_FLASH_START_PAGE,TRUE);
// Clear OTP
for (i1=0;i1<5;i1++)
{
for (i=0;i<256;i++)
{
EraseStoreData_au8[i] = (u8)(rand () % 256);
}
for (i=0;i<10;i++)
{
flashc_memcpy((void*)(SLOTS_ADDRESS+i*512 ),EraseStoreData_au8,256,TRUE);
flashc_memcpy((void*)(SLOTS_ADDRESS+i*512+256),EraseStoreData_au8,256,TRUE);
}
}
for (i=0;i<10;i++)
{
flashc_erase_page(OTP_FLASH_START_PAGE+i,TRUE);
}
// Clear hidden volumes
for (i1=0;i1<5;i1++)
{
for (i=0;i<256;i++)
{
EraseStoreData_au8[i] = (u8)(rand () % 256);
}
for (i=0;i<2;i++)
{
flashc_memcpy((void*)(HV_MAGIC_NUMBER_ADDRESS+i*512 ),EraseStoreData_au8,256,TRUE);
flashc_memcpy((void*)(HV_MAGIC_NUMBER_ADDRESS+i*512+256),EraseStoreData_au8,256,TRUE);
}
}
for (i=0;i<10;i++)
{
flashc_erase_page(HV_FLASH_START_PAGE+i,TRUE);
}
return (TRUE);
}
u8 WritePasswordSafeKey (u8 *data)
{
flashc_memcpy((void*)(AVR32_FLASHC_USER_PAGE + 178),data,32,TRUE);
return (TRUE);
}
u8 WriteXorPatternToFlash (u8 *XorPattern_pu8)
{
flashc_memcpy(AVR32_FLASHC_USER_PAGE + 146,XorPattern_pu8,32,TRUE);
return (TRUE);
}
u8 WriteDatetime (u32 Datetime_u32)
{
flashc_memcpy(AVR32_FLASHC_USER_PAGE + 138,&Datetime_u32,4,TRUE);
return (TRUE);
}
u8 WriteHiddenVolumeSlotKey (u8 *data)
{
flashc_memcpy((void*)(AVR32_FLASHC_USER_PAGE + 102),data,32,TRUE);
return (TRUE);
}
int main(void) {
u8 i1;
sysclk_init();
init_dbg_rs232(FMCK_HZ);
init_gpio();
assign_main_event_handlers();
init_events();
init_tc();
init_spi();
init_adc();
irq_initialize_vectors();
register_interrupts();
cpu_irq_enable();
init_usb_host();
init_monome();
init_i2c_slave(0x30);
print_dbg("\r\n\n// meadowphysics //////////////////////////////// ");
print_dbg_ulong(sizeof(flashy));
print_dbg(" ");
print_dbg_ulong(sizeof(m));
if(flash_is_fresh()) {
print_dbg("\r\nfirst run.");
flash_unfresh();
flashc_memset32((void*)&(flashy.preset_select), 0, 4, true);
// clear out some reasonable defaults
for(i1=0;i1<8;i1++) {
m.positions[i1] = i1;
m.points[i1] = i1;
m.points_save[i1] = i1;
m.triggers[i1] = 0;
m.trig_dests[i1] = 0;
m.rules[i1] = 0;
m.rule_dests[i1] = i1;
}
m.positions[0] = m.points[0] = 3;
m.trig_dests[0] = 254;
// save all presets, clear glyphs
for(i1=0;i1<8;i1++) {
flashc_memcpy((void *)&flashy.m[i1], &m, sizeof(m), true);
glyph[i1] = (1<<i1);
flashc_memcpy((void *)&flashy.glyph[i1], &glyph, sizeof(glyph), true);
}
}
else {
// load from flash at startup
preset_select = flashy.preset_select;
flash_read();
for(i1=0;i1<8;i1++)
glyph[i1] = flashy.glyph[preset_select][i1];
}
LENGTH = 15;
SIZE = 16;
re = &refresh;
process_ii = &mp_process_ii;
clock_pulse = &clock;
clock_external = !gpio_get_pin_value(B09);
timer_add(&clockTimer,120,&clockTimer_callback, NULL);
timer_add(&keyTimer,50,&keyTimer_callback, NULL);
timer_add(&adcTimer,100,&adcTimer_callback, NULL);
clock_temp = 10000; // out of ADC range to force tempo
while (true) {
check_events();
}
}
u8 WriteAESStorageKeyToUserPage (u8 *data)
{
flashc_memcpy(AVR32_FLASHC_USER_PAGE,data,32,TRUE);
return (TRUE);
}
void Update_stored_values(void)
{
flashc_memcpy((void *)&Stored_values_flash, (void *)&Stored_values_ram, sizeof(Stored_values_ram), true);
}
u8 WriteMatrixColumsAdminPWFromUserPage (u8 *data)
{
flashc_memcpy(AVR32_FLASHC_USER_PAGE + 52,data,20,TRUE);
return (TRUE);
}
