int ble_hci_sched_init(void) { int rc; ble_hci_sched_free_mem(); ble_hci_sched_entry_mem = malloc( OS_MEMPOOL_BYTES(BLE_HCI_SCHED_NUM_ENTRIES, sizeof (struct ble_hci_sched_entry))); if (ble_hci_sched_entry_mem == NULL) { rc = BLE_HS_ENOMEM; goto err; } rc = os_mempool_init(&ble_hci_sched_entry_pool, BLE_HCI_SCHED_NUM_ENTRIES, sizeof (struct ble_hci_sched_entry), ble_hci_sched_entry_mem, "ble_hci_sched_entry_pool"); if (rc != 0) { rc = BLE_HS_EOS; goto err; } STAILQ_INIT(&ble_hci_sched_list); ble_hci_sched_cur_entry = NULL; return 0; err: ble_hci_sched_free_mem(); return rc; }
/** * 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; uint32_t seed; /* 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"); rc = os_mbuf_pool_init(&g_mbuf_pool, &g_mbuf_mempool, MBUF_MEMBLOCK_SIZE, MBUF_NUM_MBUFS); assert(rc == 0); /* Dummy device address */ memcpy(g_dev_addr, prphtest_slv_addr, 6); /* * 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(NULL); assert(rc == 0); /* 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; }
static void os_mbuf_test_setup(void) { int rc; rc = os_mempool_init(&os_mbuf_mempool, MBUF_TEST_POOL_BUF_COUNT, MBUF_TEST_POOL_BUF_SIZE, &os_mbuf_membuf[0], "mbuf_pool"); TEST_ASSERT_FATAL(rc == 0, "Error creating memory pool %d", rc); rc = os_mbuf_pool_init(&os_mbuf_pool, &os_mbuf_mempool, 0, MBUF_TEST_POOL_BUF_SIZE, MBUF_TEST_POOL_BUF_COUNT); TEST_ASSERT_FATAL(rc == 0, "Error creating mbuf pool %d", rc); }
/** * 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(int argc, char **argv) { int rc; #ifdef ARCH_sim mcu_sim_parse_args(argc, argv); #endif conf_init(); log_init(); log_console_handler_init(&log_console_handler); log_register("log", &my_log, &log_console_handler); LOG_DEBUG(&my_log, LOG_MODULE_DEFAULT, "bla"); LOG_DEBUG(&my_log, LOG_MODULE_DEFAULT, "bab"); os_init(); rc = os_mempool_init(&default_mbuf_mpool, DEFAULT_MBUF_MPOOL_NBUFS, DEFAULT_MBUF_MPOOL_BUF_LEN, default_mbuf_mpool_data, "default_mbuf_data"); assert(rc == 0); rc = os_mbuf_pool_init(&default_mbuf_pool, &default_mbuf_mpool, DEFAULT_MBUF_MPOOL_BUF_LEN, DEFAULT_MBUF_MPOOL_NBUFS); assert(rc == 0); rc = os_msys_register(&default_mbuf_pool); assert(rc == 0); shell_task_init(SHELL_TASK_PRIO, shell_stack, SHELL_TASK_STACK_SIZE, SHELL_MAX_INPUT_LEN); (void) console_init(shell_console_rx_cb); stats_module_init(); rc = init_tasks(); os_start(); /* os start should never return. If it does, this should be an error */ assert(0); return rc; }
int ble_hs_misc_malloc_mempool(void **mem, struct os_mempool *pool, int num_entries, int entry_size, char *name) { int rc; *mem = malloc(OS_MEMPOOL_BYTES(num_entries, entry_size)); if (*mem == NULL) { return BLE_HS_ENOMEM; } rc = os_mempool_init(pool, num_entries, entry_size, *mem, name); if (rc != 0) { free(*mem); return BLE_HS_EOS; } return 0; }
/** * 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) { struct ble_hs_cfg cfg; uint32_t seed; int rc; int i; /* Initialize OS */ os_init(); /* Set cputime to count at 1 usec increments */ rc = cputime_init(1000000); assert(rc == 0); /* 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); /* Initialize msys mbufs. */ rc = os_mempool_init(&bleprph_mbuf_mpool, MBUF_NUM_MBUFS, MBUF_MEMBLOCK_SIZE, bleprph_mbuf_mpool_data, "bleprph_mbuf_data"); assert(rc == 0); rc = os_mbuf_pool_init(&bleprph_mbuf_pool, &bleprph_mbuf_mpool, MBUF_MEMBLOCK_SIZE, MBUF_NUM_MBUFS); assert(rc == 0); rc = os_msys_register(&bleprph_mbuf_pool); assert(rc == 0); /* Initialize the logging system. */ log_init(); log_console_handler_init(&bleprph_log_console_handler); log_register("bleprph", &bleprph_log, &bleprph_log_console_handler); os_task_init(&bleprph_task, "bleprph", bleprph_task_handler, NULL, BLEPRPH_TASK_PRIO, OS_WAIT_FOREVER, bleprph_stack, BLEPRPH_STACK_SIZE); /* Initialize the BLE LL */ rc = ble_ll_init(BLE_LL_TASK_PRI, MBUF_NUM_MBUFS, BLE_MBUF_PAYLOAD_SIZE); assert(rc == 0); /* Initialize the BLE host. */ cfg = ble_hs_cfg_dflt; cfg.max_hci_bufs = 3; cfg.max_connections = 1; cfg.max_attrs = 42; cfg.max_services = 5; cfg.max_client_configs = 6; cfg.max_gattc_procs = 2; cfg.max_l2cap_chans = 3; cfg.max_l2cap_sig_procs = 1; cfg.sm_bonding = 1; cfg.sm_our_key_dist = BLE_L2CAP_SM_PAIR_KEY_DIST_ENC; cfg.sm_their_key_dist = BLE_L2CAP_SM_PAIR_KEY_DIST_ENC; /* Initialize eventq */ os_eventq_init(&bleprph_evq); rc = ble_hs_init(&bleprph_evq, &cfg); assert(rc == 0); /* Initialize the console (for log output). */ rc = console_init(NULL); assert(rc == 0); /* Register GATT attributes (services, characteristics, and * descriptors). */ gatt_svr_init(); /* Start the OS */ os_start(); /* os start should never return. If it does, this should be an error */ assert(0); return 0; }
/** * 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; }
/** * Initializes the host portion of the BLE stack. */ int ble_hs_init(struct os_eventq *app_evq, struct ble_hs_cfg *cfg) { int rc; ble_hs_free_mem(); if (app_evq == NULL) { rc = BLE_HS_EINVAL; goto err; } ble_hs_parent_evq = app_evq; ble_hs_cfg_init(cfg); log_init(); log_console_handler_init(&ble_hs_log_console_handler); log_register("ble_hs", &ble_hs_log, &ble_hs_log_console_handler); ble_hs_hci_cmd_buf = malloc(OS_MEMPOOL_BYTES(ble_hs_cfg.max_hci_bufs, HCI_CMD_BUF_SIZE)); if (ble_hs_hci_cmd_buf == NULL) { rc = BLE_HS_ENOMEM; goto err; } /* Create memory pool of command buffers */ rc = os_mempool_init(&g_hci_cmd_pool, ble_hs_cfg.max_hci_bufs, HCI_CMD_BUF_SIZE, ble_hs_hci_cmd_buf, "HCICmdPool"); assert(rc == 0); ble_hs_hci_os_event_buf = malloc(OS_MEMPOOL_BYTES(ble_hs_cfg.max_hci_bufs, HCI_OS_EVENT_BUF_SIZE)); if (ble_hs_hci_os_event_buf == NULL) { rc = BLE_HS_ENOMEM; goto err; } /* Create memory pool of OS events */ rc = os_mempool_init(&g_hci_os_event_pool, ble_hs_cfg.max_hci_bufs, HCI_OS_EVENT_BUF_SIZE, ble_hs_hci_os_event_buf, "HCIOsEventPool"); assert(rc == 0); /* Initialize eventq */ os_eventq_init(&ble_hs_evq); /* Initialize stats. */ rc = stats_module_init(); if (rc != 0) { rc = BLE_HS_EOS; goto err; } ble_hci_cmd_init(); rc = ble_hs_conn_init(); if (rc != 0) { goto err; } rc = ble_l2cap_init(); if (rc != 0) { goto err; } rc = ble_att_init(); if (rc != 0) { goto err; } rc = ble_att_svr_init(); if (rc != 0) { goto err; } rc = ble_gap_init(); if (rc != 0) { goto err; } rc = ble_gattc_init(); if (rc != 0) { goto err; } rc = ble_gatts_init(); if (rc != 0) { goto err; } os_mqueue_init(&ble_hs_rx_q, NULL); os_mqueue_init(&ble_hs_tx_q, NULL); rc = stats_init_and_reg( STATS_HDR(ble_hs_stats), STATS_SIZE_INIT_PARMS(ble_hs_stats, STATS_SIZE_32), STATS_NAME_INIT_PARMS(ble_hs_stats), "ble_hs"); if (rc != 0) { rc = BLE_HS_EOS; goto err; } os_callout_func_init(&ble_hs_heartbeat_timer, ble_hs_parent_evq, ble_hs_heartbeat, NULL); os_callout_func_init(&ble_hs_event_co, &ble_hs_evq, ble_hs_event_handle, NULL); rc = os_mutex_init(&ble_hs_mutex); if (rc != 0) { rc = BLE_HS_EOS; goto err; } return 0; err: ble_hs_free_mem(); return rc; }
void oc_rep_init(void) { os_mempool_init(&oc_rep_objects, EST_NUM_REP_OBJECTS, sizeof(oc_rep_t), oc_rep_objects_area, "oc_rep_o"); }
/** * Fully resets the nffs RAM representation. * * @return 0 on success; nonzero on failure. */ int nffs_misc_reset(void) { int rc; nffs_cache_clear(); rc = os_mempool_init(&nffs_file_pool, nffs_config.nc_num_files, sizeof (struct nffs_file), nffs_file_mem, "nffs_file_pool"); if (rc != 0) { return FS_EOS; } rc = os_mempool_init(&nffs_inode_entry_pool, nffs_config.nc_num_inodes, sizeof (struct nffs_inode_entry), nffs_inode_mem, "nffs_inode_entry_pool"); if (rc != 0) { return FS_EOS; } rc = os_mempool_init(&nffs_block_entry_pool, nffs_config.nc_num_blocks, sizeof (struct nffs_hash_entry), nffs_block_entry_mem, "nffs_block_entry_pool"); if (rc != 0) { return FS_EOS; } rc = os_mempool_init(&nffs_cache_inode_pool, nffs_config.nc_num_cache_inodes, sizeof (struct nffs_cache_inode), nffs_cache_inode_mem, "nffs_cache_inode_pool"); if (rc != 0) { return FS_EOS; } rc = os_mempool_init(&nffs_cache_block_pool, nffs_config.nc_num_cache_blocks, sizeof (struct nffs_cache_block), nffs_cache_block_mem, "nffs_cache_block_pool"); if (rc != 0) { return FS_EOS; } rc = os_mempool_init(&nffs_dir_pool, nffs_config.nc_num_dirs, sizeof (struct nffs_dir), nffs_dir_mem, "nffs_dir_pool"); if (rc != 0) { return FS_EOS; } rc = nffs_hash_init(); if (rc != 0) { return rc; } free(nffs_areas); nffs_areas = NULL; nffs_num_areas = 0; nffs_root_dir = NULL; nffs_lost_found_dir = NULL; nffs_scratch_area_idx = NFFS_AREA_ID_NONE; nffs_hash_next_file_id = NFFS_ID_FILE_MIN; nffs_hash_next_dir_id = NFFS_ID_DIR_MIN; nffs_hash_next_block_id = NFFS_ID_BLOCK_MIN; return 0; }
/** * Initialize the Link Layer. Should be called only once * * @return int */ void ble_ll_init(void) { int rc; uint8_t features; struct ble_ll_obj *lldata; /* Get pointer to global data object */ lldata = &g_ble_ll_data; /* Set acl pkt size and number */ lldata->ll_num_acl_pkts = MYNEWT_VAL(BLE_ACL_BUF_COUNT); lldata->ll_acl_pkt_size = MYNEWT_VAL(BLE_ACL_BUF_SIZE); /* Initialize eventq */ os_eventq_init(&lldata->ll_evq); /* Initialize the transmit (from host) and receive (from phy) queues */ STAILQ_INIT(&lldata->ll_tx_pkt_q); STAILQ_INIT(&lldata->ll_rx_pkt_q); /* Initialize transmit (from host) and receive packet (from phy) event */ lldata->ll_rx_pkt_ev.ev_cb = ble_ll_event_rx_pkt; lldata->ll_tx_pkt_ev.ev_cb = ble_ll_event_tx_pkt; lldata->ll_dbuf_overflow_ev.ev_cb = ble_ll_event_dbuf_overflow; /* Initialize the HW error timer */ os_callout_init(&g_ble_ll_data.ll_hw_err_timer, &g_ble_ll_data.ll_evq, ble_ll_hw_err_timer_cb, NULL); /* Initialize wait for response timer */ os_cputime_timer_init(&g_ble_ll_data.ll_wfr_timer, ble_ll_wfr_timer_exp, NULL); ble_ll_hci_os_event_buf = malloc( OS_MEMPOOL_BYTES(16, sizeof (struct os_event))); SYSINIT_PANIC_ASSERT(ble_ll_hci_os_event_buf != NULL); /* Create memory pool of OS events */ rc = os_mempool_init(&g_ble_ll_hci_ev_pool, 16, sizeof (struct os_event), ble_ll_hci_os_event_buf, "g_ble_ll_hci_ev_pool"); SYSINIT_PANIC_ASSERT(rc == 0); /* Initialize LL HCI */ ble_ll_hci_init(); /* Init the scheduler */ ble_ll_sched_init(); /* Initialize advertiser */ ble_ll_adv_init(); /* Initialize a scanner */ ble_ll_scan_init(); /* Initialize the connection module */ ble_ll_conn_module_init(); /* Set the supported features. NOTE: we always support extended reject. */ features = BLE_LL_FEAT_EXTENDED_REJ; #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_DATA_LEN_EXT) == 1) features |= BLE_LL_FEAT_DATA_LEN_EXT; #endif #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_CONN_PARAM_REQ) == 1) features |= BLE_LL_FEAT_CONN_PARM_REQ; #endif #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_SLAVE_INIT_FEAT_XCHG) == 1) features |= BLE_LL_FEAT_SLAVE_INIT; #endif #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_ENCRYPTION) == 1) features |= BLE_LL_FEAT_LE_ENCRYPTION; #endif #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_PRIVACY) == 1) features |= (BLE_LL_FEAT_LL_PRIVACY | BLE_LL_FEAT_EXT_SCAN_FILT); ble_ll_resolv_init(); #endif #if (MYNEWT_VAL(BLE_LL_CFG_FEAT_LE_PING) == 1) features |= BLE_LL_FEAT_LE_PING; #endif /* Initialize random number generation */ ble_ll_rand_init(); /* XXX: This really doesn't belong here, as the address probably has not * been set yet. */ ble_ll_seed_prng(); lldata->ll_supp_features = features; /* Initialize the LL task */ os_task_init(&g_ble_ll_task, "ble_ll", ble_ll_task, NULL, MYNEWT_VAL(BLE_LL_PRIO), OS_WAIT_FOREVER, g_ble_ll_stack, BLE_LL_STACK_SIZE); rc = stats_init_and_reg(STATS_HDR(ble_ll_stats), STATS_SIZE_INIT_PARMS(ble_ll_stats, STATS_SIZE_32), STATS_NAME_INIT_PARMS(ble_ll_stats), "ble_ll"); SYSINIT_PANIC_ASSERT(rc == 0); ble_hci_trans_cfg_ll(ble_ll_hci_cmd_rx, NULL, ble_ll_hci_acl_rx, NULL); }