static void
boot_test_util_init_flash(void)
{
const struct nffs_area_desc *area_desc;
int rc;
rc = hal_flash_init();
TEST_ASSERT(rc == 0);
for (area_desc = boot_test_area_descs;
area_desc->nad_length != 0;
area_desc++) {
rc = hal_flash_erase(area_desc->nad_flash_id, area_desc->nad_offset,
area_desc->nad_length);
TEST_ASSERT(rc == 0);
}
rc = nffs_init();
TEST_ASSERT(rc == 0);
rc = nffs_format(boot_test_format_descs);
TEST_ASSERT(rc == 0);
rc = fs_mkdir("/boot");
TEST_ASSERT(rc == 0);
}
/**
* Initializes the flash driver and file system for use by the boot loader.
*
* @return 0 on success; nonzero on failure.
*/
static int
boot_init_flash(void)
{
int rc;
rc = hal_flash_init();
if (rc != 0) {
return BOOT_EFLASH;
}
rc = nffs_init();
if (rc != 0) {
return BOOT_EFILE;
}
/* Look for an nffs file system in internal flash. If no file system gets
* detected, all subsequent file operations will fail, but the boot loader
* should proceed anyway.
*/
nffs_detect(boot_req->br_area_descs);
/* Create the boot directory if it doesn't already exist. */
fs_mkdir("/boot");
return 0;
}
int
tr_init(void)
{
int rc;
if (tr_config.tc_base_path != NULL) {
if (tr_config.tc_area_descs != NULL) {
rc = hal_flash_init();
if (rc != 0) {
return -1;
}
rc = nffs_init();
if (rc != 0) {
return -1;
}
rc = nffs_detect(tr_config.tc_area_descs);
if (rc == FS_ECORRUPT) {
rc = nffs_format(tr_config.tc_area_descs);
}
if (rc != 0) {
return -1;
}
}
rc = tr_results_read_status();
if (rc != 0) {
tr_results_rmdir_results();
}
rc = tr_results_mkdir_results();
if (rc != 0) {
return -1;
}
rc = tr_results_mkdir_meta();
if (rc != 0) {
return -1;
}
}
tu_config.tc_case_init_cb = tr_case_init;
tu_config.tc_case_fail_cb = tr_case_fail;
tu_config.tc_case_pass_cb = tr_case_pass;
tu_config.tc_suite_init_cb = tr_suite_init;
tu_config.tc_restart_cb = tr_restart;
return 0;
}
void
boot_test_util_init_flash(void)
{
const struct flash_area *area_desc;
int rc;
rc = hal_flash_init();
TEST_ASSERT(rc == 0);
for (area_desc = boot_test_area_descs;
area_desc->fa_size != 0;
area_desc++) {
rc = flash_area_erase(area_desc, 0, area_desc->fa_size);
TEST_ASSERT(rc == 0);
}
}
extern hal_result_t hal_core_init(const hal_core_cfg_t *cfg)
{
if(NULL == cfg)
{
hal_base_on_fatalerror(hal_fatalerror_missingconfiguration, "hal_core_init() needs cfg");
return(hal_res_NOK_generic);
}
if(hal_core_status_zero != s_hal_core_theinternals.status)
{
hal_base_on_fatalerror(hal_fatalerror_generic, "hal_core_init() already called");
return(hal_res_NOK_generic);
}
// sets used config. it may be used to retrieve params for hal_cpu_init() and hal_sys_init()
memcpy(&s_hal_core_theinternals.config, cfg, sizeof(hal_core_cfg_t));
// call something which prepares memory in core modules
s_hal_core_modules_in_core_static_memory_init();
// call something which prepares memory of other modules specified in brdcfg
s_hal_core_modules_in_brdcfg_static_memory_init();
// -- call initialisation of base
hal_base_init(&cfg->basecfg);
// -- call initialisation of cpu
hal_cpu_init(&cfg->cpucfg);
// -- call initialisation of flash
hal_flash_init(&cfg->flashcfg);
// -- call initialisation of sys
hal_sys_init(&cfg->syscfg);
// sets initialisation done
s_hal_core_theinternals.status = hal_core_status_initialised;
return(hal_res_OK);
}
/**
* main
*
* The main function for the project. This function initializes the os, calls
* init_tasks to initialize tasks (and possibly other objects), then starts the
* OS. We should not return from os start.
*
* @return int NOTE: this function should never return!
*/
int
main(void)
{
int i;
int rc;
int cnt;
uint32_t seed;
struct nffs_area_desc descs[NFFS_AREA_MAX];
/* Initialize OS */
os_init();
/* Set cputime to count at 1 usec increments */
rc = cputime_init(1000000);
assert(rc == 0);
rc = os_mempool_init(&g_mbuf_mempool, MBUF_NUM_MBUFS,
MBUF_MEMBLOCK_SIZE, &g_mbuf_buffer[0], "mbuf_pool");
assert(rc == 0);
rc = os_mbuf_pool_init(&g_mbuf_pool, &g_mbuf_mempool, MBUF_MEMBLOCK_SIZE,
MBUF_NUM_MBUFS);
assert(rc == 0);
rc = os_msys_register(&g_mbuf_pool);
assert(rc == 0);
/* Dummy device address */
#if BLETEST_CFG_ROLE == BLETEST_ROLE_ADVERTISER
g_dev_addr[0] = 0x00;
g_dev_addr[1] = 0x00;
g_dev_addr[2] = 0x00;
g_dev_addr[3] = 0x88;
g_dev_addr[4] = 0x88;
g_dev_addr[5] = 0x08;
g_bletest_cur_peer_addr[0] = 0x00;
g_bletest_cur_peer_addr[1] = 0x00;
g_bletest_cur_peer_addr[2] = 0x00;
g_bletest_cur_peer_addr[3] = 0x99;
g_bletest_cur_peer_addr[4] = 0x99;
g_bletest_cur_peer_addr[5] = 0x09;
#else
g_dev_addr[0] = 0x00;
g_dev_addr[1] = 0x00;
g_dev_addr[2] = 0x00;
g_dev_addr[3] = 0x99;
g_dev_addr[4] = 0x99;
g_dev_addr[5] = 0x09;
g_bletest_cur_peer_addr[0] = 0x00;
g_bletest_cur_peer_addr[1] = 0x00;
g_bletest_cur_peer_addr[2] = 0x00;
g_bletest_cur_peer_addr[3] = 0x88;
g_bletest_cur_peer_addr[4] = 0x88;
g_bletest_cur_peer_addr[5] = 0x08;
#endif
/*
* Seed random number generator with least significant bytes of device
* address.
*/
seed = 0;
for (i = 0; i < 4; ++i) {
seed |= g_dev_addr[i];
seed <<= 8;
}
srand(seed);
/* Set the led pin as an output */
g_led_pin = LED_BLINK_PIN;
gpio_init_out(g_led_pin, 1);
/* Init the console */
rc = console_init(shell_console_rx_cb);
assert(rc == 0);
rc = hal_flash_init();
assert(rc == 0);
nffs_config.nc_num_inodes = 32;
nffs_config.nc_num_blocks = 64;
nffs_config.nc_num_files = 2;
nffs_config.nc_num_dirs = 2;
rc = nffs_init();
assert(rc == 0);
cnt = NFFS_AREA_MAX;
rc = flash_area_to_nffs_desc(FLASH_AREA_NFFS, &cnt, descs);
assert(rc == 0);
if (nffs_detect(descs) == FS_ECORRUPT) {
rc = nffs_format(descs);
assert(rc == 0);
}
shell_task_init(SHELL_TASK_PRIO, shell_stack, SHELL_TASK_STACK_SIZE,
SHELL_MAX_INPUT_LEN);
nmgr_task_init(NEWTMGR_TASK_PRIO, newtmgr_stack, NEWTMGR_TASK_STACK_SIZE);
imgmgr_module_init();
/* Init statistics module */
stats_module_init();
/* Init tasks */
init_tasks();
/* Start the OS */
os_start();
/* os start should never return. If it does, this should be an error */
assert(0);
return rc;
}
