/** * Initializes the nffs memory and data structures. This must be called before * any nffs operations are attempted. * * @return 0 on success; nonzero on error. */ int nffs_init(void) { int rc; nffs_config_init(); nffs_cache_clear(); rc = os_mutex_init(&nffs_mutex); if (rc != 0) { return NFFS_EOS; } free(nffs_file_mem); nffs_file_mem = malloc( OS_MEMPOOL_BYTES(nffs_config.nc_num_files, sizeof (struct nffs_file))); if (nffs_file_mem == NULL) { return NFFS_ENOMEM; } free(nffs_inode_mem); nffs_inode_mem = malloc( OS_MEMPOOL_BYTES(nffs_config.nc_num_inodes, sizeof (struct nffs_inode_entry))); if (nffs_inode_mem == NULL) { return NFFS_ENOMEM; } free(nffs_block_entry_mem); nffs_block_entry_mem = malloc( OS_MEMPOOL_BYTES(nffs_config.nc_num_blocks, sizeof (struct nffs_hash_entry))); if (nffs_block_entry_mem == NULL) { return NFFS_ENOMEM; } free(nffs_cache_inode_mem); nffs_cache_inode_mem = malloc( OS_MEMPOOL_BYTES(nffs_config.nc_num_cache_inodes, sizeof (struct nffs_cache_inode))); if (nffs_cache_inode_mem == NULL) { return NFFS_ENOMEM; } free(nffs_cache_block_mem); nffs_cache_block_mem = malloc( OS_MEMPOOL_BYTES(nffs_config.nc_num_cache_blocks, sizeof (struct nffs_cache_block))); if (nffs_cache_block_mem == NULL) { return NFFS_ENOMEM; } rc = nffs_misc_reset(); if (rc != 0) { return rc; } return 0; }
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; }
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; }
/** * 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; }
// limitations under the License. */ #include <stddef.h> #include <os/os_mempool.h> #include "oc_rep.h" #include "config.h" #include "port/oc_assert.h" #include "port/oc_log.h" #include "api/oc_priv.h" #include <tinycbor/cbor_buf_writer.h> #include <tinycbor/cbor_buf_reader.h> static struct os_mempool oc_rep_objects; static uint8_t oc_rep_objects_area[OS_MEMPOOL_BYTES(EST_NUM_REP_OBJECTS, sizeof(oc_rep_t))]; static const CborEncoder g_empty; static uint8_t *g_buf; CborEncoder g_encoder, root_map, links_array; CborError g_err; struct CborBufWriter g_buf_writer; void oc_rep_new(uint8_t *out_payload, int size) { g_err = CborNoError; g_buf = out_payload; cbor_buf_writer_init(&g_buf_writer, out_payload, size); cbor_encoder_init(&g_encoder, &g_buf_writer.enc, 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); }
/** * Initializes internal nffs memory and data structures. This must be called * before any nffs operations are attempted. * * @return 0 on success; nonzero on error. */ int nffs_init(void) { int rc; nffs_config_init(); nffs_cache_clear(); rc = os_mutex_init(&nffs_mutex); if (rc != 0) { return FS_EOS; } free(nffs_file_mem); nffs_file_mem = malloc( OS_MEMPOOL_BYTES(nffs_config.nc_num_files, sizeof (struct nffs_file))); if (nffs_file_mem == NULL) { return FS_ENOMEM; } free(nffs_inode_mem); nffs_inode_mem = malloc( OS_MEMPOOL_BYTES(nffs_config.nc_num_inodes, sizeof (struct nffs_inode_entry))); if (nffs_inode_mem == NULL) { return FS_ENOMEM; } free(nffs_block_entry_mem); nffs_block_entry_mem = malloc( OS_MEMPOOL_BYTES(nffs_config.nc_num_blocks, sizeof (struct nffs_hash_entry))); if (nffs_block_entry_mem == NULL) { return FS_ENOMEM; } free(nffs_cache_inode_mem); nffs_cache_inode_mem = malloc( OS_MEMPOOL_BYTES(nffs_config.nc_num_cache_inodes, sizeof (struct nffs_cache_inode))); if (nffs_cache_inode_mem == NULL) { return FS_ENOMEM; } free(nffs_cache_block_mem); nffs_cache_block_mem = malloc( OS_MEMPOOL_BYTES(nffs_config.nc_num_cache_blocks, sizeof (struct nffs_cache_block))); if (nffs_cache_block_mem == NULL) { return FS_ENOMEM; } free(nffs_dir_mem); nffs_dir_mem = malloc( OS_MEMPOOL_BYTES(nffs_config.nc_num_dirs, sizeof (struct nffs_dir))); if (nffs_dir_mem == NULL) { return FS_ENOMEM; } log_init(); log_console_handler_init(&nffs_log_console_handler); log_register("nffs", &nffs_log, &nffs_log_console_handler); rc = nffs_misc_reset(); if (rc != 0) { return rc; } fs_register(&nffs_ops); return 0; }