/**
* 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;
}
