diff options
Diffstat (limited to 'src/libs/mynewt-nimble/porting/npl/dummy')
3 files changed, 510 insertions, 0 deletions
diff --git a/src/libs/mynewt-nimble/porting/npl/dummy/include/nimble/nimble_npl_os.h b/src/libs/mynewt-nimble/porting/npl/dummy/include/nimble/nimble_npl_os.h new file mode 100644 index 00000000..996aed23 --- /dev/null +++ b/src/libs/mynewt-nimble/porting/npl/dummy/include/nimble/nimble_npl_os.h @@ -0,0 +1,60 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +#ifndef _NIMBLE_NPL_OS_H_ +#define _NIMBLE_NPL_OS_H_ + +#include <stdint.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#define BLE_NPL_OS_ALIGNMENT 4 + +#define BLE_NPL_TIME_FOREVER UINT32_MAX + +typedef uint32_t ble_npl_time_t; +typedef int32_t ble_npl_stime_t; + +struct ble_npl_event { + int dummy; +}; + +struct ble_npl_eventq { + int dummy; +}; + +struct ble_npl_callout { + int dummy; +}; + +struct ble_npl_mutex { + int dummy; +}; + +struct ble_npl_sem { + int dummy; +}; + +#ifdef __cplusplus +} +#endif + +#endif /* _NPL_H_ */ diff --git a/src/libs/mynewt-nimble/porting/npl/dummy/src/hci_dummy.c b/src/libs/mynewt-nimble/porting/npl/dummy/src/hci_dummy.c new file mode 100644 index 00000000..78fffe95 --- /dev/null +++ b/src/libs/mynewt-nimble/porting/npl/dummy/src/hci_dummy.c @@ -0,0 +1,250 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +#include <assert.h> +#include <stdio.h> +#include <stdint.h> +#include "syscfg/syscfg.h" +#include "sysinit/sysinit.h" +#include "os/os_mempool.h" +#include "nimble/ble.h" +#include "nimble/ble_hci_trans.h" +#include "nimble/hci_common.h" + +/* HCI packet types */ +#define HCI_PKT_CMD 0x01 +#define HCI_PKT_ACL 0x02 +#define HCI_PKT_EVT 0x04 +#define HCI_PKT_GTL 0x05 + +/* Buffers for HCI commands data */ +static uint8_t trans_buf_cmd[BLE_HCI_TRANS_CMD_SZ]; +static uint8_t trans_buf_cmd_allocd; + +/* Buffers for HCI events data */ +static uint8_t trans_buf_evt_hi_pool_buf[ OS_MEMPOOL_BYTES( + MYNEWT_VAL(BLE_HCI_EVT_HI_BUF_COUNT), + MYNEWT_VAL(BLE_HCI_EVT_BUF_SIZE)) ]; +static struct os_mempool trans_buf_evt_hi_pool; +static uint8_t trans_buf_evt_lo_pool_buf[ OS_MEMPOOL_BYTES( + MYNEWT_VAL(BLE_HCI_EVT_LO_BUF_COUNT), + MYNEWT_VAL(BLE_HCI_EVT_BUF_SIZE)) ]; +static struct os_mempool trans_buf_evt_lo_pool; + +/* Buffers for HCI ACL data */ +#define ACL_POOL_BLOCK_SIZE OS_ALIGN(MYNEWT_VAL(BLE_ACL_BUF_SIZE) + \ + BLE_MBUF_MEMBLOCK_OVERHEAD + \ + BLE_HCI_DATA_HDR_SZ, OS_ALIGNMENT) +static uint8_t trans_buf_acl_pool_buf[ OS_MEMPOOL_BYTES( + MYNEWT_VAL(BLE_ACL_BUF_COUNT), + ACL_POOL_BLOCK_SIZE) ]; +static struct os_mempool trans_buf_acl_pool; +static struct os_mbuf_pool trans_buf_acl_mbuf_pool; + +/* Host interface */ +static ble_hci_trans_rx_cmd_fn *trans_rx_cmd_cb; +static void *trans_rx_cmd_arg; +static ble_hci_trans_rx_acl_fn *trans_rx_acl_cb; +static void *trans_rx_acl_arg; + +/* Called by NimBLE host to reset HCI transport state (i.e. on host reset) */ +int +ble_hci_trans_reset(void) +{ + return 0; +} + +/* Called by NimBLE host to setup callbacks from HCI transport */ +void +ble_hci_trans_cfg_hs(ble_hci_trans_rx_cmd_fn *cmd_cb, void *cmd_arg, + ble_hci_trans_rx_acl_fn *acl_cb, void *acl_arg) +{ + trans_rx_cmd_cb = cmd_cb; + trans_rx_cmd_arg = cmd_arg; + trans_rx_acl_cb = acl_cb; + trans_rx_acl_arg = acl_arg; +} + +/* + * Called by NimBLE host to allocate buffer for HCI Command packet. + * Called by HCI transport to allocate buffer for HCI Event packet. + */ +uint8_t * +ble_hci_trans_buf_alloc(int type) +{ + uint8_t *buf; + + switch (type) { + case BLE_HCI_TRANS_BUF_CMD: + assert(!trans_buf_cmd_allocd); + trans_buf_cmd_allocd = 1; + buf = trans_buf_cmd; + break; + case BLE_HCI_TRANS_BUF_EVT_HI: + buf = os_memblock_get(&trans_buf_evt_hi_pool); + if (buf) { + break; + } + /* no break */ + case BLE_HCI_TRANS_BUF_EVT_LO: + buf = os_memblock_get(&trans_buf_evt_lo_pool); + break; + default: + assert(0); + buf = NULL; + } + + return buf; +} + +/* + * Called by NimBLE host to free buffer allocated for HCI Event packet. + * Called by HCI transport to free buffer allocated for HCI Command packet. + */ +void +ble_hci_trans_buf_free(uint8_t *buf) +{ + int rc; + + if (buf == trans_buf_cmd) { + assert(trans_buf_cmd_allocd); + trans_buf_cmd_allocd = 0; + } else if (os_memblock_from(&trans_buf_evt_hi_pool, buf)) { + rc = os_memblock_put(&trans_buf_evt_hi_pool, buf); + assert(rc == 0); + } else { + assert(os_memblock_from(&trans_buf_evt_lo_pool, buf)); + rc = os_memblock_put(&trans_buf_evt_lo_pool, buf); + assert(rc == 0); + } +} + +/* Called by NimBLE host to send HCI Command packet over HCI transport */ +int +ble_hci_trans_hs_cmd_tx(uint8_t *cmd) +{ + uint8_t *buf = cmd; + + /* + * TODO Send HCI Command packet somewhere. + * Buffer pointed by 'cmd' contains complete HCI Command packet as defined + * by Core spec. + */ + + ble_hci_trans_buf_free(buf); + + return 0; +} + +/* Called by NimBLE host to send HCI ACL Data packet over HCI transport */ +int +ble_hci_trans_hs_acl_tx(struct os_mbuf *om) +{ + uint8_t *buf = om->om_data; + + /* + * TODO Send HCI ACL Data packet somewhere. + * mbuf pointed by 'om' contains complete HCI ACL Data packet as defined + * by Core spec. + */ + (void)buf; + + os_mbuf_free_chain(om); + + return 0; +} + +/* Called by application to send HCI ACL Data packet to host */ +int +hci_transport_send_acl_to_host(uint8_t *buf, uint16_t size) +{ + struct os_mbuf *trans_mbuf; + int rc; + + trans_mbuf = os_mbuf_get_pkthdr(&trans_buf_acl_mbuf_pool, + sizeof(struct ble_mbuf_hdr)); + os_mbuf_append(trans_mbuf, buf, size); + rc = trans_rx_acl_cb(trans_mbuf, trans_rx_acl_arg); + + return rc; +} + +/* Called by application to send HCI Event packet to host */ +int +hci_transport_send_evt_to_host(uint8_t *buf, uint8_t size) +{ + uint8_t *trans_buf; + int rc; + + /* Allocate LE Advertising Report Event from lo pool only */ + if ((buf[0] == BLE_HCI_EVCODE_LE_META) && + (buf[2] == BLE_HCI_LE_SUBEV_ADV_RPT)) { + trans_buf = ble_hci_trans_buf_alloc(BLE_HCI_TRANS_BUF_EVT_LO); + if (!trans_buf) { + /* Skip advertising report if we're out of memory */ + return 0; + } + } else { + trans_buf = ble_hci_trans_buf_alloc(BLE_HCI_TRANS_BUF_EVT_HI); + } + + memcpy(trans_buf, buf, size); + + rc = trans_rx_cmd_cb(trans_buf, trans_rx_cmd_arg); + if (rc != 0) { + ble_hci_trans_buf_free(trans_buf); + } + + return rc; +} + +/* Called by application to initialize transport structures */ +int +hci_transport_init(void) +{ + int rc; + + trans_buf_cmd_allocd = 0; + + rc = os_mempool_init(&trans_buf_acl_pool, MYNEWT_VAL(BLE_ACL_BUF_COUNT), + ACL_POOL_BLOCK_SIZE, trans_buf_acl_pool_buf, + "dummy_hci_acl_pool"); + SYSINIT_PANIC_ASSERT(rc == 0); + + rc = os_mbuf_pool_init(&trans_buf_acl_mbuf_pool, &trans_buf_acl_pool, + ACL_POOL_BLOCK_SIZE, + MYNEWT_VAL(BLE_ACL_BUF_COUNT)); + SYSINIT_PANIC_ASSERT(rc == 0); + + rc = os_mempool_init(&trans_buf_evt_hi_pool, + MYNEWT_VAL(BLE_HCI_EVT_HI_BUF_COUNT), + MYNEWT_VAL(BLE_HCI_EVT_BUF_SIZE), + trans_buf_evt_hi_pool_buf, + "dummy_hci_hci_evt_hi_pool"); + SYSINIT_PANIC_ASSERT(rc == 0); + + rc = os_mempool_init(&trans_buf_evt_lo_pool, + MYNEWT_VAL(BLE_HCI_EVT_LO_BUF_COUNT), + MYNEWT_VAL(BLE_HCI_EVT_BUF_SIZE), + trans_buf_evt_lo_pool_buf, + "dummy_hci_hci_evt_lo_pool"); + SYSINIT_PANIC_ASSERT(rc == 0); + + return 0; +} diff --git a/src/libs/mynewt-nimble/porting/npl/dummy/src/npl_os_dummy.c b/src/libs/mynewt-nimble/porting/npl/dummy/src/npl_os_dummy.c new file mode 100644 index 00000000..a522531f --- /dev/null +++ b/src/libs/mynewt-nimble/porting/npl/dummy/src/npl_os_dummy.c @@ -0,0 +1,200 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +#include <stddef.h> +#include "nimble/nimble_npl.h" + +bool +ble_npl_os_started(void) +{ + return 0; +} + +void * +ble_npl_get_current_task_id(void) +{ + return NULL; +} + +void +ble_npl_eventq_init(struct ble_npl_eventq *evq) +{ + +} + +struct ble_npl_event * +ble_npl_eventq_get(struct ble_npl_eventq *evq, ble_npl_time_t tmo) +{ +} + +void +ble_npl_eventq_put(struct ble_npl_eventq *evq, struct ble_npl_event *ev) +{ +} + +void +ble_npl_eventq_remove(struct ble_npl_eventq *evq, + struct ble_npl_event *ev) +{ + +} + +void +ble_npl_event_run(struct ble_npl_event *ev) +{ + +} + +void +ble_npl_event_init(struct ble_npl_event *ev, ble_npl_event_fn *fn, + void *arg) +{ + +} + +bool ble_npl_event_is_queued(struct ble_npl_event *ev) +{ + return false; +} + +void * +ble_npl_event_get_arg(struct ble_npl_event *ev) +{ + return NULL; +} + +void +ble_npl_event_set_arg(struct ble_npl_event *ev, void *arg) +{ + +} + +ble_npl_error_t +ble_npl_mutex_init(struct ble_npl_mutex *mu) +{ + return BLE_NPL_ENOENT; +} + +ble_npl_error_t +ble_npl_mutex_pend(struct ble_npl_mutex *mu, ble_npl_time_t timeout) +{ + return BLE_NPL_ENOENT; +} + +ble_npl_error_t +ble_npl_mutex_release(struct ble_npl_mutex *mu) +{ + return BLE_NPL_ENOENT; +} + +ble_npl_error_t +ble_npl_sem_init(struct ble_npl_sem *sem, uint16_t tokens) +{ + return BLE_NPL_ENOENT; +} + +ble_npl_error_t +ble_npl_sem_pend(struct ble_npl_sem *sem, ble_npl_time_t timeout) +{ + return BLE_NPL_ENOENT; +} + +ble_npl_error_t +ble_npl_sem_release(struct ble_npl_sem *sem) +{ + return BLE_NPL_ENOENT; +} + +uint16_t +ble_npl_sem_get_count(struct ble_npl_sem *sem) +{ + return 0; +} + +void +ble_npl_callout_init(struct ble_npl_callout *c, struct ble_npl_eventq *evq, + ble_npl_event_fn *ev_cb, void *ev_arg) +{ +} + +ble_npl_error_t +ble_npl_callout_reset(struct ble_npl_callout *c, ble_npl_time_t ticks) +{ + return BLE_NPL_ENOENT; +} + +void +ble_npl_callout_stop(struct ble_npl_callout *co) +{ + +} + +bool +ble_npl_callout_is_active(struct ble_npl_callout *c) +{ + return false; +} + +ble_npl_time_t +ble_npl_callout_get_ticks(struct ble_npl_callout *co) +{ + return 0; +} + +uint32_t +ble_npl_time_get(void) +{ + return 0; +} + +ble_npl_error_t +ble_npl_time_ms_to_ticks(uint32_t ms, ble_npl_time_t *out_ticks) +{ + return BLE_NPL_ENOENT; +} + +ble_npl_error_t +ble_npl_time_ticks_to_ms(ble_npl_time_t ticks, uint32_t *out_ms) +{ + return BLE_NPL_ENOENT; +} + +ble_npl_time_t +ble_npl_time_ms_to_ticks32(uint32_t ms) +{ + return 0; +} + +uint32_t +ble_npl_time_ticks_to_ms32(ble_npl_time_t ticks) +{ + return 0; +} + +uint32_t +ble_npl_hw_enter_critical(void) +{ + return 0; +} + +void +ble_npl_hw_exit_critical(uint32_t ctx) +{ + +} |