/************************************************************************* * DESCRIPTION: Store the name to non-volatile memory at offset * RETURN: true if name is a valid set of characters * NOTES: none **************************************************************************/ bool bacnet_name_save( uint16_t offset, uint8_t encoding, char *str, uint8_t str_len) { uint8_t buffer[NVM_NAME_SIZE] = { 0 }; uint8_t length = 0; if (bacnet_name_isvalid(encoding, str_len, str)) { length = bacnet_name_encode( buffer, sizeof(buffer), encoding, str, str_len); if (length) { nvm_write( offset, &buffer[0],length); return true; } } return false; }
retval_t pal_ps_set(uint16_t offset, uint16_t length, void *value) { nvm_write(INT_FLASH, (uint32_t)offset + INT_FLASH_END - STACK_FLASH_SIZE + 1, value, length); return MAC_SUCCESS; }
/*! \brief Test routine that writes to the non volatile memory, reads back * and compares the values */ static status_code_t test_mem(mem_type_t mem, uint32_t test_address) { static uint8_t write_buf[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}; static uint8_t read_buf[8], i = 0; /* Initialize the non volatile memory */ if (nvm_init(mem) != STATUS_OK) { return ERR_INVALID_ARG; } /* Write test pattern to the specified address */ nvm_write(mem, test_address, (void *)write_buf, sizeof(write_buf)); /* Read back data from the same address */ nvm_read(mem, test_address, (void *)read_buf, sizeof(read_buf)); /* Validate the read data */ for (i = 0; i < sizeof(write_buf); i++) { if (read_buf[i] != write_buf[i]) { return ERR_BAD_DATA; } } return STATUS_OK; }
static void update_mrc_cache(void *unused) { const struct mrc_saved_data *current_boot; const struct mrc_saved_data *current_saved; const struct mrc_saved_data *next_slot; struct mrc_data_region region; printk(BIOS_DEBUG, "Updating MRC cache data.\n"); current_boot = cbmem_find(CBMEM_ID_MRCDATA); if (!current_boot) { printk(BIOS_ERR, "No MRC cache in cbmem.\n"); return; } if (mrc_cache_get_region(®ion)) { printk(BIOS_ERR, "Could not obtain MRC cache region.\n"); return; } if (!mrc_cache_valid(®ion, current_boot)) { printk(BIOS_ERR, "MRC cache data in cbmem invalid.\n"); return; } current_saved = NULL; if (!__mrc_cache_get_current(®ion, ¤t_saved)) { if (current_saved->size == current_boot->size && !memcmp(¤t_saved->data[0], ¤t_boot->data[0], current_saved->size)) { printk(BIOS_DEBUG, "MRC cache up to date.\n"); protect_mrc_cache(®ion); return; } } next_slot = mrc_cache_next_slot(®ion, current_saved); if (!mrc_slot_valid(®ion, next_slot, current_boot)) { printk(BIOS_DEBUG, "Slot @ %p is invalid.\n", next_slot); if (!nvm_is_erased(region.base, region.size)) { if (nvm_erase(region.base, region.size) < 0) { printk(BIOS_DEBUG, "Failure erasing region.\n"); return; } } next_slot = region.base; } if (nvm_write((void *)next_slot, current_boot, current_boot->size + sizeof(*current_boot))) { printk(BIOS_DEBUG, "Failure writing MRC cache to %p.\n", next_slot); } protect_mrc_cache(®ion); }
void main(void) { nvmType_t type=0; nvmErr_t err; uint32_t buf[WRITE_NBYTES/4]; uint32_t i; uart_init(INC, MOD, SAMP); print_welcome("nvm-write"); vreg_init(); if(NVM_INTERFACE == gNvmInternalInterface_c) { printf("Detecting internal nvm\n\r"); } else { printf("Setting up gpio\r\n"); /* set SPI func */ GPIO->FUNC_SEL.GPIO_04 = 1; GPIO->FUNC_SEL.GPIO_05 = 1; GPIO->FUNC_SEL.GPIO_06 = 1; GPIO->FUNC_SEL.GPIO_07 = 1; printf("Detecting external nvm\n\r"); } err = nvm_detect(NVM_INTERFACE, &type); printf("nvm_detect returned: 0x%02x type is: 0x%08x\r\n", err, (unsigned int)type); buf[0] = WRITEVAL0; buf[1] = WRITEVAL1; err = nvm_erase(NVM_INTERFACE, type, 1 << WRITE_ADDR/4096); printf("nvm_erase returned: 0x%02x\r\n", err); err = nvm_write(NVM_INTERFACE, type, (uint8_t *)buf, WRITE_ADDR, WRITE_NBYTES); printf("gnychis nvm_write returned: 0x%02x\r\n", err); printf("writing\n\r"); for(i=0; i<WRITE_NBYTES/4; i++) { printf("0x%08x\r\n", (unsigned int)buf[i]); buf[i] = 0x00000000; /* clear buf for the read */ } err = nvm_read(NVM_INTERFACE, type, (uint8_t *)buf, WRITE_ADDR, WRITE_NBYTES); printf("nvm_read returned: 0x%02x\r\n", err); printf("reading\r\n"); for(i=0; i<WRITE_NBYTES/4; i++) { printf("0x%08x\r\n", (unsigned int)buf[i]); } while(1) {continue;}; }
void nvm_data_write(void) { nvmType_t type = 0; nvmErr_t err; LOG6LBR_INFO("Flashing 6LBR NVM\n"); mc1322x_config_save(&mc1322x_config); err = nvm_detect(gNvmInternalInterface_c, &type); err = nvm_write(gNvmInternalInterface_c, type, (uint8_t *) & nvm_data, CETIC_6LBR_NVM_ADDRESS, sizeof(nvm_data_t)); if (err) { LOG6LBR_ERROR("write error : %d\n", err); } }
/** * \brief Test the read and write buffer operations on the NVM * * This function will test the read and write functionalities of the NVM * using buffer access. It will first fill a buffer with a known pattern and * read it back by testing each value read.\n * * \param test Current test case. */ static void run_buffer_access_test(const struct test_case *test) { status_code_t status; uint8_t i, test_buf[20]; /* Fills a test buffer with a known pattern */ for (i = 0; i < 20; i++) { test_buf[i] = BYTE_PATTERN2(i); } /* Write the buffer to the non volatile memory */ status = nvm_write(INT_FLASH, (uint32_t)TEST_ADDRESS, (void *)test_buf, sizeof(test_buf)); test_assert_true(test, status == STATUS_OK, "Write buffer operation error"); /* Clear the test buffer */ for (i = 0; i < 20; i++) { test_buf[i] = 0; } /* Read back the non volatile memory */ status = nvm_read(INT_FLASH, (uint32_t)TEST_ADDRESS, (void *)test_buf, sizeof(test_buf)); test_assert_true(test, status == STATUS_OK, "Read buffer operation error"); /* Compare the values read from the NVM with the expected values */ for (i = 0; i < 20; i++) { test_assert_true(test, test_buf[i] == BYTE_PATTERN2(i), "Value not expected @ byte %d (read: 0x%02x," " expected: 0x%02x)", i, test_buf[i], BYTE_PATTERN2(i)); } }
bool Device_Write_Property_Local(BACNET_WRITE_PROPERTY_DATA * wp_data) { bool status = false; /* return value - false=error */ int len = 0; BACNET_APPLICATION_DATA_VALUE value; uint8_t max_master = 0; /* decode the some of the request */ len = bacapp_decode_application_data(wp_data->application_data, wp_data->application_data_len, &value); /* FIXME: len < application_data_len: more data? */ if (len < 0) { /* error while decoding - a value larger than we can handle */ wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_VALUE_OUT_OF_RANGE; return false; } if ((wp_data->object_property != PROP_OBJECT_LIST) && (wp_data->array_index != BACNET_ARRAY_ALL)) { /* only array properties can have array options */ wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_PROPERTY_IS_NOT_AN_ARRAY; return false; } switch ((int) wp_data->object_property) { case PROP_OBJECT_IDENTIFIER: if (value.tag == BACNET_APPLICATION_TAG_OBJECT_ID) { if ((value.type.Object_Id.type == OBJECT_DEVICE) && (Device_Set_Object_Instance_Number(value.type.Object_Id. instance))) { nvm_write(NVM_DEVICE_0, (uint8_t *) & value.type.Object_Id.instance, 4); /* we could send an I-Am broadcast to let the world know */ status = true; } else { wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_VALUE_OUT_OF_RANGE; } } else { wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_INVALID_DATA_TYPE; } break; case PROP_MAX_INFO_FRAMES: if (value.tag == BACNET_APPLICATION_TAG_UNSIGNED_INT) { if (value.type.Unsigned_Int <= 255) { dlmstp_set_max_info_frames(value.type.Unsigned_Int); status = true; } else { wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_VALUE_OUT_OF_RANGE; } } else { wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_INVALID_DATA_TYPE; } break; case PROP_MAX_MASTER: if (value.tag == BACNET_APPLICATION_TAG_UNSIGNED_INT) { if ((value.type.Unsigned_Int > 0) && (value.type.Unsigned_Int <= 127)) { max_master = value.type.Unsigned_Int; dlmstp_set_max_master(max_master); nvm_write(NVM_MAX_MASTER, &max_master, 1); status = true; } else { wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_VALUE_OUT_OF_RANGE; } } else { wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_INVALID_DATA_TYPE; } break; case PROP_OBJECT_NAME: if (value.tag == BACNET_APPLICATION_TAG_CHARACTER_STRING) { status = bacnet_name_write_unique(NVM_DEVICE_NAME, wp_data->object_type, wp_data->object_instance, &value.type.Character_String, &wp_data->error_class, &wp_data->error_code); } else { wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_INVALID_DATA_TYPE; } break; case PROP_DESCRIPTION: if (value.tag == BACNET_APPLICATION_TAG_CHARACTER_STRING) { status = bacnet_name_write(NVM_DEVICE_DESCRIPTION, &value.type.Character_String, &wp_data->error_class, &wp_data->error_code); } else { wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_INVALID_DATA_TYPE; } break; case PROP_LOCATION: if (value.tag == BACNET_APPLICATION_TAG_CHARACTER_STRING) { status = bacnet_name_write(NVM_DEVICE_LOCATION, &value.type.Character_String, &wp_data->error_class, &wp_data->error_code); } else { wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_INVALID_DATA_TYPE; } break; case PROP_OBJECT_TYPE: case PROP_VENDOR_NAME: case PROP_FIRMWARE_REVISION: case PROP_APPLICATION_SOFTWARE_VERSION: case PROP_DAYLIGHT_SAVINGS_STATUS: case PROP_PROTOCOL_VERSION: case PROP_PROTOCOL_REVISION: case PROP_PROTOCOL_SERVICES_SUPPORTED: case PROP_PROTOCOL_OBJECT_TYPES_SUPPORTED: case PROP_OBJECT_LIST: case PROP_MAX_APDU_LENGTH_ACCEPTED: case PROP_SEGMENTATION_SUPPORTED: case PROP_DEVICE_ADDRESS_BINDING: case PROP_DATABASE_REVISION: case 512: case 513: wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_WRITE_ACCESS_DENIED; break; default: wp_data->error_class = ERROR_CLASS_PROPERTY; wp_data->error_code = ERROR_CODE_UNKNOWN_PROPERTY; break; } return status; }
int main(void) { nvmType_t type=0; nvmErr_t err; volatile uint8_t c; volatile uint32_t i; volatile uint32_t buf[4]; volatile uint32_t len=0; volatile uint32_t state = SCAN_X; volatile uint32_t addr,data; uart_init(UART1, 115200); disable_irq(UART1); vreg_init(); dbg_putstr("Detecting internal nvm\n\r"); err = nvm_detect(gNvmInternalInterface_c, &type); dbg_putstr("nvm_detect returned: 0x"); dbg_put_hex(err); dbg_putstr(" type is: 0x"); dbg_put_hex32(type); dbg_putstr("\n\r"); err = nvm_read(gNvmInternalInterface_c, type, (uint8_t *)nvm_base, NVM_BASE, 0x100); dbg_putstr("nvm_read returned: 0x"); dbg_put_hex(err); dbg_putstr("\n\r"); /* erase the flash */ nvm_setsvar(0); err = nvm_erase(gNvmInternalInterface_c, type, 0x40000000); dbg_putstr("nvm_erase returned: 0x"); dbg_put_hex(err); dbg_putstr("\n\r"); dbg_putstr(" type is: 0x"); dbg_put_hex32(type); dbg_putstr("\n\r"); err = nvm_write(gNvmInternalInterface_c, type, (uint8_t *)nvm_base, NVM_BASE, 0x100); dbg_putstr("nvm_write returned: 0x"); dbg_put_hex(err); dbg_putstr("\n\r"); /* say we are ready */ len = 0; putstr("ready"); flushrx(); /* read the length */ for(i=0; i<4; i++) { c = uart1_getc(); /* bail if the first byte of the length is zero */ len += (c<<(i*8)); } dbg_putstr("len: "); dbg_put_hex32(len); dbg_putstr("\n\r"); dbg_putstr(" type is: 0x"); dbg_put_hex32(type); dbg_putstr("\n\r"); putstr("flasher done\n\r"); state = SCAN_X; addr=0; while((c=getc())) { if(state == SCAN_X) { /* read until we see an 'x' */ if(c==0) { break; } if(c!='x'){ continue; } /* go to read_chars once we have an 'x' */ state = READ_CHARS; i = 0; } if(state == READ_CHARS) { /* read all the chars up to a ',' */ ((uint8_t *)buf)[i++] = c; /* after reading a ',' */ /* goto PROCESS state */ if((c == ',') || (c == 0)) { state = PROCESS; } } if(state == PROCESS) { if(addr==0) { /*interpret the string as the starting address */ addr = to_u32(buf); } else { /* string is data to write */ data = to_u32(buf); putstr("writing addr "); put_hex32(NVM_BASE+addr); putstr(" data "); put_hex32(data); err = nvm_write(gNvmInternalInterface_c, type, (uint8_t *)&data, NVM_BASE+addr, 4); addr += 4; putstr(" err "); put_hex32(err); putstr("\n\r"); } /* look for the next 'x' */ state=SCAN_X; } } putstr("process flasher done\n\r"); while(1) {continue;}; }
/* write out config to flash */ void mc1322x_config_save(mc1322xConfig *c) { nvmErr_t err; err = nvm_erase(gNvmInternalInterface_c, c->flags.nvmtype, 1 << MC1322X_CONFIG_PAGE/4096); err = nvm_write(gNvmInternalInterface_c, c->flags.nvmtype, (uint8_t *)c, MC1322X_CONFIG_PAGE, sizeof(mc1322xConfig)); }
void _AJ_NV_Write(void* dest, const void* buf, uint16_t size) { nvm_write(INT_FLASH, (uint32_t)dest, buf, size); }
void main(void) { nvmType_t type=0; nvmErr_t err; volatile uint8_t c; volatile uint32_t i; volatile uint32_t buf[4]; volatile uint32_t len=0; volatile uint32_t state = SCAN_X; volatile uint32_t addr,data; uart_init(INC, MOD, SAMP); disable_irq(UART1); vreg_init(); dbg_putstr("Detecting internal nvm\n\r"); err = nvm_detect(gNvmInternalInterface_c, &type); dbg_putstr("nvm_detect returned: 0x"); dbg_put_hex(err); dbg_putstr(" type is: 0x"); dbg_put_hex32(type); dbg_putstr("\n\r"); /* erase the flash */ err = nvm_erase(gNvmInternalInterface_c, type, 0x7fffffff); dbg_putstr("nvm_erase returned: 0x"); dbg_put_hex(err); dbg_putstr("\n\r"); dbg_putstr(" type is: 0x"); dbg_put_hex32(type); dbg_putstr("\n\r"); /* say we are ready */ len = 0; putstr("ready"); flushrx(); /* read the length */ for(i=0; i<4; i++) { c = uart1_getc(); /* bail if the first byte of the length is zero */ len += (c<<(i*8)); } dbg_putstr("len: "); dbg_put_hex32(len); dbg_putstr("\n\r"); /* write the OKOK magic */ #if BOOT_OK ((uint8_t *)buf)[0] = 'O'; ((uint8_t *)buf)[1] = 'K'; ((uint8_t *)buf)[2] = 'O'; ((uint8_t *)buf)[3] = 'K'; #elif BOOT_SECURE ((uint8_t *)buf)[0] = 'S'; ((uint8_t *)buf)[1] = 'E'; ((uint8_t *)buf)[2] = 'C'; ((uint8_t *)buf)[3] = 'U'; #else ((uint8_t *)buf)[0] = 'N'; ((uint8_t *)buf)[1] = 'O'; ((uint8_t *)buf)[2] = 'N'; ((uint8_t *)buf)[3] = 'O'; #endif dbg_putstr(" type is: 0x"); dbg_put_hex32(type); dbg_putstr("\n\r"); /* don't make a valid boot image if the received length is zero */ if(len == 0) { ((uint8_t *)buf)[0] = 'N'; ((uint8_t *)buf)[1] = 'O'; ((uint8_t *)buf)[2] = 'N'; ((uint8_t *)buf)[3] = 'O'; } err = nvm_write(gNvmInternalInterface_c, type, (uint8_t *)buf, 0, 4); dbg_putstr("nvm_write returned: 0x"); dbg_put_hex(err); dbg_putstr("\n\r"); /* write the length */ err = nvm_write(gNvmInternalInterface_c, type, (uint8_t *)&len, 4, 4); /* read a byte, write a byte */ for(i=0; i<len; i++) { c = getc(); err = nvm_write(gNvmInternalInterface_c, type, (uint8_t *)&c, 8+i, 1); } putstr("flasher done\n\r"); state = SCAN_X; addr=0; while((c=getc())) { if(state == SCAN_X) { /* read until we see an 'x' */ if(c==0) { break; } if(c!='x'){ continue; } /* go to read_chars once we have an 'x' */ state = READ_CHARS; i = 0; } if(state == READ_CHARS) { /* read all the chars up to a ',' */ ((uint8_t *)buf)[i++] = c; /* after reading a ',' */ /* goto PROCESS state */ if((c == ',') || (c == 0)) { state = PROCESS; } } if(state == PROCESS) { if(addr==0) { /*interpret the string as the starting address */ addr = to_u32(buf); } else { /* string is data to write */ data = to_u32(buf); putstr("writing addr "); put_hex32(addr); putstr(" data "); put_hex32(data); putstr("\n\r"); err = nvm_write(gNvmInternalInterface_c, 1, (uint8_t *)&data, addr, 4); addr += 4; } /* look for the next 'x' */ state=SCAN_X; } } while(1) {continue;}; }