espressif/esp-nimble
1
0
Fork 0
mirror of https://github.com/espressif/esp-nimble.git synced 2026-08-11 20:47:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

apps: bttester: make bttester code compliant with Mynewt code style

Browse Source 
bttester was initially ported from Zephyr. This app is independent now
and should follow Mynewt Coding Standards.
This commit is contained in:
Krzysztof Kopyściński
2023-06-05 16:22:16 +02:00
committed by Szymon Janc
parent a366af0d4b
commit 7f17076cc2
13 changed files with 6490 additions and 6147 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/bttester/src/atomic.h
+144 -132
View File
@@ -55,12 +55,13 @@ typedef atomic_t atomic_val_t;
* @param new_value New value to store.
* @return 1 if @a new_value is written, 0 otherwise.
*/
static inline int atomic_cas(atomic_t *target, atomic_val_t old_value,
atomic_val_t new_value)
static inline int
atomic_cas(atomic_t *target, atomic_val_t old_value,
atomic_val_t new_value)
{
return __atomic_compare_exchange_n(target, &old_value, new_value,
0, __ATOMIC_SEQ_CST,
__ATOMIC_SEQ_CST);
0, __ATOMIC_SEQ_CST,
__ATOMIC_SEQ_CST);
}
/**
@@ -74,7 +75,8 @@ static inline int atomic_cas(atomic_t *target, atomic_val_t old_value,
*
* @return Previous value of @a target.
*/
static inline atomic_val_t atomic_add(atomic_t *target, atomic_val_t value)
static inline atomic_val_t
atomic_add(atomic_t *target, atomic_val_t value)
{
return __atomic_fetch_add(target, value, __ATOMIC_SEQ_CST);
}
@@ -91,7 +93,8 @@ static inline atomic_val_t atomic_add(atomic_t *target, atomic_val_t value)
* @return Previous value of @a target.
*/
static inline atomic_val_t atomic_sub(atomic_t *target, atomic_val_t value)
static inline atomic_val_t
atomic_sub(atomic_t *target, atomic_val_t value)
{
return __atomic_fetch_sub(target, value, __ATOMIC_SEQ_CST);
}
@@ -107,7 +110,8 @@ static inline atomic_val_t atomic_sub(atomic_t *target, atomic_val_t value)
* @return Previous value of @a target.
*/
static inline atomic_val_t atomic_inc(atomic_t *target)
static inline atomic_val_t
atomic_inc(atomic_t *target)
{
return atomic_add(target, 1);
}
@@ -123,7 +127,8 @@ static inline atomic_val_t atomic_inc(atomic_t *target)
* @return Previous value of @a target.
*/
static inline atomic_val_t atomic_dec(atomic_t *target)
static inline atomic_val_t
atomic_dec(atomic_t *target)
{
return atomic_sub(target, 1);
}
@@ -139,7 +144,8 @@ static inline atomic_val_t atomic_dec(atomic_t *target)
* @return Value of @a target.
*/
static inline atomic_val_t atomic_get(const atomic_t *target)
static inline atomic_val_t
atomic_get(const atomic_t *target)
{
return __atomic_load_n(target, __ATOMIC_SEQ_CST);
}
@@ -157,7 +163,8 @@ static inline atomic_val_t atomic_get(const atomic_t *target)
* @return Previous value of @a target.
*/
static inline atomic_val_t atomic_set(atomic_t *target, atomic_val_t value)
static inline atomic_val_t
atomic_set(atomic_t *target, atomic_val_t value)
{
/* This builtin, as described by Intel, is not a traditional
* test-and-set operation, but rather an atomic exchange operation. It
@@ -178,7 +185,8 @@ static inline atomic_val_t atomic_set(atomic_t *target, atomic_val_t value)
* @return Previous value of @a target.
*/
static inline atomic_val_t atomic_clear(atomic_t *target)
static inline atomic_val_t
atomic_clear(atomic_t *target)
{
return atomic_set(target, 0);
}
@@ -196,7 +204,8 @@ static inline atomic_val_t atomic_clear(atomic_t *target)
* @return Previous value of @a target.
*/
static inline atomic_val_t atomic_or(atomic_t *target, atomic_val_t value)
static inline atomic_val_t
atomic_or(atomic_t *target, atomic_val_t value)
{
return __atomic_fetch_or(target, value, __ATOMIC_SEQ_CST);
}
@@ -214,7 +223,8 @@ static inline atomic_val_t atomic_or(atomic_t *target, atomic_val_t value)
* @return Previous value of @a target.
*/
static inline atomic_val_t atomic_xor(atomic_t *target, atomic_val_t value)
static inline atomic_val_t
atomic_xor(atomic_t *target, atomic_val_t value)
{
return __atomic_fetch_xor(target, value, __ATOMIC_SEQ_CST);
}
@@ -232,7 +242,8 @@ static inline atomic_val_t atomic_xor(atomic_t *target, atomic_val_t value)
* @return Previous value of @a target.
*/
static inline atomic_val_t atomic_and(atomic_t *target, atomic_val_t value)
static inline atomic_val_t
atomic_and(atomic_t *target, atomic_val_t value)
{
return __atomic_fetch_and(target, value, __ATOMIC_SEQ_CST);
}
@@ -250,149 +261,150 @@ static inline atomic_val_t atomic_and(atomic_t *target, atomic_val_t value)
* @return Previous value of @a target.
*/
static inline atomic_val_t atomic_nand(atomic_t *target, atomic_val_t value)
static inline atomic_val_t
atomic_nand(atomic_t *target, atomic_val_t value)
{
return __atomic_fetch_nand(target, value, __ATOMIC_SEQ_CST);
}
/**
* @brief Initialize an atomic variable.
*
* This macro can be used to initialize an atomic variable. For example,
* @code atomic_t my_var = ATOMIC_INIT(75); @endcode
*
* @param i Value to assign to atomic variable.
*/
/**
* @brief Initialize an atomic variable.
*
* This macro can be used to initialize an atomic variable. For example,
* @code atomic_t my_var = ATOMIC_INIT(75); @endcode
*
* @param i Value to assign to atomic variable.
*/
#define ATOMIC_INIT(i) (i)
/**
* @cond INTERNAL_HIDDEN
*/
/**
* @cond INTERNAL_HIDDEN
*/
#define ATOMIC_BITS (sizeof(atomic_val_t) * 8)
#define ATOMIC_MASK(bit) (1 << ((bit) & (ATOMIC_BITS - 1)))
#define ATOMIC_ELEM(addr, bit) ((addr) + ((bit) / ATOMIC_BITS))
/**
* INTERNAL_HIDDEN @endcond
*/
/**
* INTERNAL_HIDDEN @endcond
*/
/**
* @brief Define an array of atomic variables.
*
* This macro defines an array of atomic variables containing at least
* @a num_bits bits.
*
* @note
* If used from file scope, the bits of the array are initialized to zero;
* if used from within a function, the bits are left uninitialized.
*
* @param name Name of array of atomic variables.
* @param num_bits Number of bits needed.
*/
/**
* @brief Define an array of atomic variables.
*
* This macro defines an array of atomic variables containing at least
* @a num_bits bits.
*
* @note
* If used from file scope, the bits of the array are initialized to zero;
* if used from within a function, the bits are left uninitialized.
*
* @param name Name of array of atomic variables.
* @param num_bits Number of bits needed.
*/
#define ATOMIC_DEFINE(name, num_bits) \
atomic_t name[1 + ((num_bits) - 1) / ATOMIC_BITS]
atomic_t name[1 + ((num_bits) - 1) / ATOMIC_BITS]
/**
* @brief Atomically test a bit.
*
* This routine tests whether bit number @a bit of @a target is set or not.
* The target may be a single atomic variable or an array of them.
*
* @param target Address of atomic variable or array.
* @param bit Bit number (starting from 0).
*
* @return 1 if the bit was set, 0 if it wasn't.
*/
static inline int
atomic_test_bit(const atomic_t *target, int bit)
{
atomic_val_t val = atomic_get(ATOMIC_ELEM(target, bit));
/**
* @brief Atomically test a bit.
*
* This routine tests whether bit number @a bit of @a target is set or not.
* The target may be a single atomic variable or an array of them.
*
* @param target Address of atomic variable or array.
* @param bit Bit number (starting from 0).
*
* @return 1 if the bit was set, 0 if it wasn't.
*/
static inline int
atomic_test_bit(const atomic_t *target, int bit)
{
atomic_val_t val = atomic_get(ATOMIC_ELEM(target, bit));
return (1 & (val >> (bit & (ATOMIC_BITS - 1))));
}
return (1 & (val >> (bit & (ATOMIC_BITS - 1))));
}
/**
* @brief Atomically test and clear a bit.
*
* Atomically clear bit number @a bit of @a target and return its old value.
* The target may be a single atomic variable or an array of them.
*
* @param target Address of atomic variable or array.
* @param bit Bit number (starting from 0).
*
* @return 1 if the bit was set, 0 if it wasn't.
*/
static inline int
atomic_test_and_clear_bit(atomic_t *target, int bit)
{
atomic_val_t mask = ATOMIC_MASK(bit);
atomic_val_t old;
/**
* @brief Atomically test and clear a bit.
*
* Atomically clear bit number @a bit of @a target and return its old value.
* The target may be a single atomic variable or an array of them.
*
* @param target Address of atomic variable or array.
* @param bit Bit number (starting from 0).
*
* @return 1 if the bit was set, 0 if it wasn't.
*/
static inline int
atomic_test_and_clear_bit(atomic_t *target, int bit)
{
atomic_val_t mask = ATOMIC_MASK(bit);
atomic_val_t old;
old = atomic_and(ATOMIC_ELEM(target, bit), ~mask);
old = atomic_and(ATOMIC_ELEM(target, bit), ~mask);
return (old & mask) != 0;
}
return (old & mask) != 0;
}
/**
* @brief Atomically set a bit.
*
* Atomically set bit number @a bit of @a target and return its old value.
* The target may be a single atomic variable or an array of them.
*
* @param target Address of atomic variable or array.
* @param bit Bit number (starting from 0).
*
* @return 1 if the bit was set, 0 if it wasn't.
*/
static inline int
atomic_test_and_set_bit(atomic_t *target, int bit)
{
atomic_val_t mask = ATOMIC_MASK(bit);
atomic_val_t old;
/**
* @brief Atomically set a bit.
*
* Atomically set bit number @a bit of @a target and return its old value.
* The target may be a single atomic variable or an array of them.
*
* @param target Address of atomic variable or array.
* @param bit Bit number (starting from 0).
*
* @return 1 if the bit was set, 0 if it wasn't.
*/
static inline int
atomic_test_and_set_bit(atomic_t *target, int bit)
{
atomic_val_t mask = ATOMIC_MASK(bit);
atomic_val_t old;
old = atomic_or(ATOMIC_ELEM(target, bit), mask);
old = atomic_or(ATOMIC_ELEM(target, bit), mask);
return (old & mask) != 0;
}
return (old & mask) != 0;
}
/**
* @brief Atomically clear a bit.
*
* Atomically clear bit number @a bit of @a target.
* The target may be a single atomic variable or an array of them.
*
* @param target Address of atomic variable or array.
* @param bit Bit number (starting from 0).
*
* @return N/A
*/
static inline void
atomic_clear_bit(atomic_t *target, int bit)
{
atomic_val_t mask = ATOMIC_MASK(bit);
/**
* @brief Atomically clear a bit.
*
* Atomically clear bit number @a bit of @a target.
* The target may be a single atomic variable or an array of them.
*
* @param target Address of atomic variable or array.
* @param bit Bit number (starting from 0).
*
* @return N/A
*/
static inline void
atomic_clear_bit(atomic_t *target, int bit)
{
atomic_val_t mask = ATOMIC_MASK(bit);
atomic_and(ATOMIC_ELEM(target, bit), ~mask);
}
atomic_and(ATOMIC_ELEM(target, bit), ~mask);
}
/**
* @brief Atomically set a bit.
*
* Atomically set bit number @a bit of @a target.
* The target may be a single atomic variable or an array of them.
*
* @param target Address of atomic variable or array.
* @param bit Bit number (starting from 0).
*
* @return N/A
*/
static inline void
atomic_set_bit(atomic_t *target, int bit)
{
atomic_val_t mask = ATOMIC_MASK(bit);
/**
* @brief Atomically set a bit.
*
* Atomically set bit number @a bit of @a target.
* The target may be a single atomic variable or an array of them.
*
* @param target Address of atomic variable or array.
* @param bit Bit number (starting from 0).
*
* @return N/A
*/
static inline void
atomic_set_bit(atomic_t *target, int bit)
{
atomic_val_t mask = ATOMIC_MASK(bit);
atomic_or(ATOMIC_ELEM(target, bit), mask);
}
atomic_or(ATOMIC_ELEM(target, bit), mask);
}
/**
* @}
apps/bttester/src/bttester.c
+251 -238
View File
@@ -42,338 +42,351 @@ static struct os_eventq *cmds_queue;
static struct os_event bttester_ev[CMD_QUEUED];
struct btp_buf {
struct os_event *ev;
union {
uint8_t data[BTP_MTU];
struct btp_hdr hdr;
};
struct os_event *ev;
union {
uint8_t data[BTP_MTU];
struct btp_hdr hdr;
};
};
static struct btp_buf cmd_buf[CMD_QUEUED];
static void supported_commands(uint8_t *data, uint16_t len)
static void
supported_commands(uint8_t *data, uint16_t len)
{
uint8_t buf[1];
struct core_read_supported_commands_rp *rp = (void *) buf;
uint8_t buf[1];
struct core_read_supported_commands_rp *rp = (void *) buf;
memset(buf, 0, sizeof(buf));
memset(buf, 0, sizeof(buf));
tester_set_bit(buf, CORE_READ_SUPPORTED_COMMANDS);
tester_set_bit(buf, CORE_READ_SUPPORTED_SERVICES);
tester_set_bit(buf, CORE_REGISTER_SERVICE);
tester_set_bit(buf, CORE_UNREGISTER_SERVICE);
tester_set_bit(buf, CORE_READ_SUPPORTED_COMMANDS);
tester_set_bit(buf, CORE_READ_SUPPORTED_SERVICES);
tester_set_bit(buf, CORE_REGISTER_SERVICE);
tester_set_bit(buf, CORE_UNREGISTER_SERVICE);
tester_send(BTP_SERVICE_ID_CORE, CORE_READ_SUPPORTED_COMMANDS,
BTP_INDEX_NONE, (uint8_t *) rp, sizeof(buf));
tester_send(BTP_SERVICE_ID_CORE, CORE_READ_SUPPORTED_COMMANDS,
BTP_INDEX_NONE, (uint8_t *) rp, sizeof(buf));
}
static void supported_services(uint8_t *data, uint16_t len)
static void
supported_services(uint8_t *data, uint16_t len)
{
uint8_t buf[1];
struct core_read_supported_services_rp *rp = (void *) buf;
uint8_t buf[1];
struct core_read_supported_services_rp *rp = (void *) buf;
memset(buf, 0, sizeof(buf));
memset(buf, 0, sizeof(buf));
tester_set_bit(buf, BTP_SERVICE_ID_CORE);
tester_set_bit(buf, BTP_SERVICE_ID_GAP);
tester_set_bit(buf, BTP_SERVICE_ID_GATT);
tester_set_bit(buf, BTP_SERVICE_ID_CORE);
tester_set_bit(buf, BTP_SERVICE_ID_GAP);
tester_set_bit(buf, BTP_SERVICE_ID_GATT);
#if MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM)
tester_set_bit(buf, BTP_SERVICE_ID_L2CAP);
tester_set_bit(buf, BTP_SERVICE_ID_L2CAP);
#endif /* MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) */
#if MYNEWT_VAL(BLE_MESH)
tester_set_bit(buf, BTP_SERVICE_ID_MESH);
tester_set_bit(buf, BTP_SERVICE_ID_MESH);
#endif /* MYNEWT_VAL(BLE_MESH) */
tester_set_bit(buf, BTP_SERVICE_ID_GATTC);
tester_set_bit(buf, BTP_SERVICE_ID_GATTC);
tester_send(BTP_SERVICE_ID_CORE, CORE_READ_SUPPORTED_SERVICES,
BTP_INDEX_NONE, (uint8_t *) rp, sizeof(buf));
tester_send(BTP_SERVICE_ID_CORE, CORE_READ_SUPPORTED_SERVICES,
BTP_INDEX_NONE, (uint8_t *) rp, sizeof(buf));
}
static void register_service(uint8_t *data, uint16_t len)
static void
register_service(uint8_t *data, uint16_t len)
{
struct core_register_service_cmd *cmd = (void *) data;
uint8_t status;
struct core_register_service_cmd *cmd = (void *) data;
uint8_t status;
switch (cmd->id) {
case BTP_SERVICE_ID_GAP:
status = tester_init_gap();
/* Rsp with success status will be handled by bt enable cb */
if (status == BTP_STATUS_FAILED) {
goto rsp;
}
return;
case BTP_SERVICE_ID_GATT:
status = tester_init_gatt();
break;
switch (cmd->id) {
case BTP_SERVICE_ID_GAP:
status = tester_init_gap();
/* Rsp with success status will be handled by bt enable cb */
if (status == BTP_STATUS_FAILED) {
goto rsp;
}
return;
case BTP_SERVICE_ID_GATT:
status = tester_init_gatt();
break;
#if MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM)
case BTP_SERVICE_ID_L2CAP:
status = tester_init_l2cap();
break;
case BTP_SERVICE_ID_L2CAP:
status = tester_init_l2cap();
break;
#endif /* MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) */
#if MYNEWT_VAL(BLE_MESH)
case BTP_SERVICE_ID_MESH:
status = tester_init_mesh();
break;
case BTP_SERVICE_ID_MESH:
status = tester_init_mesh();
break;
#endif /* MYNEWT_VAL(BLE_MESH) */
default:
status = BTP_STATUS_FAILED;
break;
}
default:
status = BTP_STATUS_FAILED;
break;
}
rsp:
tester_rsp(BTP_SERVICE_ID_CORE, CORE_REGISTER_SERVICE, BTP_INDEX_NONE,
status);
tester_rsp(BTP_SERVICE_ID_CORE, CORE_REGISTER_SERVICE, BTP_INDEX_NONE,
status);
}
static void unregister_service(uint8_t *data, uint16_t len)
static void
unregister_service(uint8_t *data, uint16_t len)
{
struct core_unregister_service_cmd *cmd = (void *) data;
uint8_t status;
struct core_unregister_service_cmd *cmd = (void *) data;
uint8_t status;
switch (cmd->id) {
case BTP_SERVICE_ID_GAP:
status = tester_unregister_gap();
break;
case BTP_SERVICE_ID_GATT:
status = tester_unregister_gatt();
break;
switch (cmd->id) {
case BTP_SERVICE_ID_GAP:
status = tester_unregister_gap();
break;
case BTP_SERVICE_ID_GATT:
status = tester_unregister_gatt();
break;
#if MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM)
case BTP_SERVICE_ID_L2CAP:
status = tester_unregister_l2cap();
break;
case BTP_SERVICE_ID_L2CAP:
status = tester_unregister_l2cap();
break;
#endif /* MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) */
#if MYNEWT_VAL(BLE_MESH)
case BTP_SERVICE_ID_MESH:
status = tester_unregister_mesh();
break;
case BTP_SERVICE_ID_MESH:
status = tester_unregister_mesh();
break;
#endif /* MYNEWT_VAL(BLE_MESH) */
default:
status = BTP_STATUS_FAILED;
break;
}
default:
status = BTP_STATUS_FAILED;
break;
}
tester_rsp(BTP_SERVICE_ID_CORE, CORE_UNREGISTER_SERVICE, BTP_INDEX_NONE,
status);
tester_rsp(BTP_SERVICE_ID_CORE, CORE_UNREGISTER_SERVICE, BTP_INDEX_NONE,
status);
}
static void handle_core(uint8_t opcode, uint8_t index, uint8_t *data,
uint16_t len)
static void
handle_core(uint8_t opcode, uint8_t index, uint8_t *data,
uint16_t len)
{
if (index != BTP_INDEX_NONE) {
tester_rsp(BTP_SERVICE_ID_CORE, opcode, index,
BTP_STATUS_FAILED);
return;
}
if (index != BTP_INDEX_NONE) {
tester_rsp(BTP_SERVICE_ID_CORE, opcode, index,
BTP_STATUS_FAILED);
return;
}
switch (opcode) {
case CORE_READ_SUPPORTED_COMMANDS:
supported_commands(data, len);
return;
case CORE_READ_SUPPORTED_SERVICES:
supported_services(data, len);
return;
case CORE_REGISTER_SERVICE:
register_service(data, len);
return;
case CORE_UNREGISTER_SERVICE:
unregister_service(data, len);
return;
default:
tester_rsp(BTP_SERVICE_ID_CORE, opcode, BTP_INDEX_NONE,
BTP_STATUS_UNKNOWN_CMD);
return;
}
switch (opcode) {
case CORE_READ_SUPPORTED_COMMANDS:
supported_commands(data, len);
return;
case CORE_READ_SUPPORTED_SERVICES:
supported_services(data, len);
return;
case CORE_REGISTER_SERVICE:
register_service(data, len);
return;
case CORE_UNREGISTER_SERVICE:
unregister_service(data, len);
return;
default:
tester_rsp(BTP_SERVICE_ID_CORE, opcode, BTP_INDEX_NONE,
BTP_STATUS_UNKNOWN_CMD);
return;
}
}
static void cmd_handler(struct os_event *ev)
static void
cmd_handler(struct os_event *ev)
{
uint16_t len;
struct btp_buf *cmd;
uint16_t len;
struct btp_buf *cmd;
if (!ev || !ev->ev_arg) {
return;
}
if (!ev || !ev->ev_arg) {
return;
}
cmd = ev->ev_arg;
cmd = ev->ev_arg;
len = sys_le16_to_cpu(cmd->hdr.len);
if (MYNEWT_VAL(BTTESTER_BTP_LOG)) {
console_printf("[DBG] received %d bytes: %s\n",
sizeof(cmd->hdr) + len,
bt_hex(cmd->data,
sizeof(cmd->hdr) + len));
}
len = sys_le16_to_cpu(cmd->hdr.len);
if (MYNEWT_VAL(BTTESTER_BTP_LOG)) {
console_printf("[DBG] received %d bytes: %s\n",
sizeof(cmd->hdr) + len,
bt_hex(cmd->data,
sizeof(cmd->hdr) + len));
}
/* TODO
* verify if service is registered before calling handler
*/
/* TODO
* verify if service is registered before calling handler
*/
switch (cmd->hdr.service) {
case BTP_SERVICE_ID_CORE:
handle_core(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
case BTP_SERVICE_ID_GAP:
tester_handle_gap(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
case BTP_SERVICE_ID_GATT:
tester_handle_gatt(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
switch (cmd->hdr.service) {
case BTP_SERVICE_ID_CORE:
handle_core(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
case BTP_SERVICE_ID_GAP:
tester_handle_gap(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
case BTP_SERVICE_ID_GATT:
tester_handle_gatt(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
#if MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM)
case BTP_SERVICE_ID_L2CAP:
tester_handle_l2cap(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
case BTP_SERVICE_ID_L2CAP:
tester_handle_l2cap(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
#endif /* MYNEWT_VAL(BLE_L2CAP_COC_MAX_NUM) */
#if MYNEWT_VAL(BLE_MESH)
case BTP_SERVICE_ID_MESH:
tester_handle_mesh(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
case BTP_SERVICE_ID_MESH:
tester_handle_mesh(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
#endif /* MYNEWT_VAL(BLE_MESH) */
case BTP_SERVICE_ID_GATTC:
tester_handle_gattc(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
default:
tester_rsp(cmd->hdr.service, cmd->hdr.opcode,
cmd->hdr.index, BTP_STATUS_FAILED);
break;
}
case BTP_SERVICE_ID_GATTC:
tester_handle_gattc(cmd->hdr.opcode, cmd->hdr.index,
cmd->hdr.data, len);
break;
default:
tester_rsp(cmd->hdr.service, cmd->hdr.opcode,
cmd->hdr.index, BTP_STATUS_FAILED);
break;
}
os_eventq_put(&avail_queue, ev);
os_eventq_put(&avail_queue, ev);
}
static uint8_t *recv_cb(uint8_t *buf, size_t *off)
static uint8_t *
recv_cb(uint8_t *buf, size_t *off)
{
struct btp_hdr *cmd = (void *) buf;
struct os_event *new_ev;
struct btp_buf *new_buf, *old_buf;
uint16_t len;
struct btp_hdr *cmd = (void *) buf;
struct os_event *new_ev;
struct btp_buf *new_buf, *old_buf;
uint16_t len;
if (*off < sizeof(*cmd)) {
return buf;
}
if (*off < sizeof(*cmd)) {
return buf;
}
len = sys_le16_to_cpu(cmd->len);
if (len > BTP_MTU - sizeof(*cmd)) {
*off = 0;
return buf;
}
len = sys_le16_to_cpu(cmd->len);
if (len > BTP_MTU - sizeof(*cmd)) {
*off = 0;
return buf;
}
if (*off < sizeof(*cmd) + len) {
return buf;
}
if (*off < sizeof(*cmd) + len) {
return buf;
}
new_ev = os_eventq_get_no_wait(&avail_queue);
if (!new_ev) {
SYS_LOG_ERR("BT tester: RX overflow");
*off = 0;
return buf;
}
new_ev = os_eventq_get_no_wait(&avail_queue);
if (!new_ev) {
SYS_LOG_ERR("BT tester: RX overflow");
*off = 0;
return buf;
}
old_buf = CONTAINER_OF(buf, struct btp_buf, data);
os_eventq_put(cmds_queue, old_buf->ev);
old_buf = CONTAINER_OF(buf, struct btp_buf, data);
os_eventq_put(cmds_queue, old_buf->ev);
new_buf = new_ev->ev_arg;
*off = 0;
return new_buf->data;
new_buf = new_ev->ev_arg;
*off = 0;
return new_buf->data;
}
static void avail_queue_init(void)
static void
avail_queue_init(void)
{
int i;
int i;
os_eventq_init(&avail_queue);
os_eventq_init(&avail_queue);
for (i = 0; i < CMD_QUEUED; i++) {
cmd_buf[i].ev = &bttester_ev[i];
bttester_ev[i].ev_cb = cmd_handler;
bttester_ev[i].ev_arg = &cmd_buf[i];
for (i = 0; i < CMD_QUEUED; i++) {
cmd_buf[i].ev = &bttester_ev[i];
bttester_ev[i].ev_cb = cmd_handler;
bttester_ev[i].ev_arg = &cmd_buf[i];
os_eventq_put(&avail_queue, &bttester_ev[i]);
}
os_eventq_put(&avail_queue, &bttester_ev[i]);
}
}
void bttester_evq_set(struct os_eventq *evq)
void
bttester_evq_set(struct os_eventq *evq)
{
cmds_queue = evq;
cmds_queue = evq;
}
void tester_init(void)
void
tester_init(void)
{
struct os_event *ev;
struct btp_buf *buf;
struct os_event *ev;
struct btp_buf *buf;
avail_queue_init();
bttester_evq_set(os_eventq_dflt_get());
avail_queue_init();
bttester_evq_set(os_eventq_dflt_get());
ev = os_eventq_get(&avail_queue);
buf = ev->ev_arg;
ev = os_eventq_get(&avail_queue);
buf = ev->ev_arg;
if (bttester_pipe_init()) {
SYS_LOG_ERR("Failed to initialize pipe");
return;
}
if (bttester_pipe_init()) {
SYS_LOG_ERR("Failed to initialize pipe");
return;
}
bttester_pipe_register(buf->data, BTP_MTU, recv_cb);
bttester_pipe_register(buf->data, BTP_MTU, recv_cb);
tester_send(BTP_SERVICE_ID_CORE, CORE_EV_IUT_READY, BTP_INDEX_NONE,
NULL, 0);
tester_send(BTP_SERVICE_ID_CORE, CORE_EV_IUT_READY, BTP_INDEX_NONE,
NULL, 0);
}
void tester_send(uint8_t service, uint8_t opcode, uint8_t index, uint8_t *data,
size_t len)
void
tester_send(uint8_t service, uint8_t opcode, uint8_t index, uint8_t *data,
size_t len)
{
struct btp_hdr msg;
struct btp_hdr msg;
msg.service = service;
msg.opcode = opcode;
msg.index = index;
msg.len = len;
msg.service = service;
msg.opcode = opcode;
msg.index = index;
msg.len = len;
bttester_pipe_send((uint8_t *)&msg, sizeof(msg));
if (data && len) {
bttester_pipe_send(data, len);
}
bttester_pipe_send((uint8_t *) &msg, sizeof(msg));
if (data && len) {
bttester_pipe_send(data, len);
}
if (MYNEWT_VAL(BTTESTER_BTP_LOG)) {
console_printf("[DBG] send %d bytes hdr: %s\n", sizeof(msg),
bt_hex((char *) &msg, sizeof(msg)));
if (data && len) {
console_printf("[DBG] send %d bytes data: %s\n", len,
bt_hex((char *) data, len));
}
}
if (MYNEWT_VAL(BTTESTER_BTP_LOG)) {
console_printf("[DBG] send %d bytes hdr: %s\n", sizeof(msg),
bt_hex((char *) &msg, sizeof(msg)));
if (data && len) {
console_printf("[DBG] send %d bytes data: %s\n", len,
bt_hex((char *) data, len));
}
}
}
void tester_send_buf(uint8_t service, uint8_t opcode, uint8_t index,
struct os_mbuf *data)
void
tester_send_buf(uint8_t service, uint8_t opcode, uint8_t index,
struct os_mbuf *data)
{
struct btp_hdr msg;
struct btp_hdr msg;
msg.service = service;
msg.opcode = opcode;
msg.index = index;
msg.len = os_mbuf_len(data);
msg.service = service;
msg.opcode = opcode;
msg.index = index;
msg.len = os_mbuf_len(data);
bttester_pipe_send((uint8_t *)&msg, sizeof(msg));
if (data && msg.len) {
bttester_pipe_send_buf(data);
}
bttester_pipe_send((uint8_t *) &msg, sizeof(msg));
if (data && msg.len) {
bttester_pipe_send_buf(data);
}
}
void tester_rsp(uint8_t service, uint8_t opcode, uint8_t index, uint8_t status)
void
tester_rsp(uint8_t service, uint8_t opcode, uint8_t index, uint8_t status)
{
struct btp_status s;
struct btp_status s;
if (status == BTP_STATUS_SUCCESS) {
tester_send(service, opcode, index, NULL, 0);
return;
}
if (status == BTP_STATUS_SUCCESS) {
tester_send(service, opcode, index, NULL, 0);
return;
}
s.code = status;
tester_send(service, BTP_STATUS, index, (uint8_t *) &s, sizeof(s));
s.code = status;
tester_send(service, BTP_STATUS, index, (uint8_t *) &s, sizeof(s));
}
apps/bttester/src/bttester.h
+687 -660
View File
File diff suppressed because it is too large Load Diff
apps/bttester/src/bttester_pipe.h
+8 -4
View File
@@ -28,10 +28,14 @@ extern "C" {
#endif
typedef uint8_t *(*bttester_pipe_recv_cb)(uint8_t *buf, size_t *off);
void bttester_pipe_register(uint8_t *buf, size_t len, bttester_pipe_recv_cb cb);
int bttester_pipe_send(const uint8_t *data, int len);
int bttester_pipe_send_buf(struct os_mbuf *buf);
int bttester_pipe_init(void);
void
bttester_pipe_register(uint8_t *buf, size_t len, bttester_pipe_recv_cb cb);
int
bttester_pipe_send(const uint8_t *data, int len);
int
bttester_pipe_send_buf(struct os_mbuf *buf);
int
bttester_pipe_init(void);
#ifdef __cplusplus
}
apps/bttester/src/gap.c
+1303 -1229
View File
File diff suppressed because it is too large Load Diff
apps/bttester/src/gatt.c
+1507 -1445
View File
File diff suppressed because it is too large Load Diff
apps/bttester/src/gatt_cl.c
+1296 -1234
View File
File diff suppressed because it is too large Load Diff
apps/bttester/src/glue.c
+44 -44
View File
@@ -31,99 +31,99 @@
const char *bt_hex(const void *buf, size_t len)
{
static const char hex[] = "0123456789abcdef";
static char hexbufs[4][137];
static uint8_t curbuf;
const uint8_t *b = buf;
char *str;
int i;
static const char hex[] = "0123456789abcdef";
static char hexbufs[4][137];
static uint8_t curbuf;
const uint8_t *b = buf;
char *str;
int i;
str = hexbufs[curbuf++];
curbuf %= ARRAY_SIZE(hexbufs);
str = hexbufs[curbuf++];
curbuf %= ARRAY_SIZE(hexbufs);
len = min(len, (sizeof(hexbufs[0]) - 1) / 2);
len = min(len, (sizeof(hexbufs[0]) - 1) / 2);
for (i = 0; i < len; i++) {
str[i * 2] = hex[b[i] >> 4];
str[i * 2 + 1] = hex[b[i] & 0xf];
}
for (i = 0; i < len; i++) {
str[i * 2] = hex[b[i] >> 4];
str[i * 2 + 1] = hex[b[i] & 0xf];
}
str[i * 2] = '\0';
str[i * 2] = '\0';
return str;
return str;
}
struct os_mbuf * NET_BUF_SIMPLE(uint16_t size)
{
struct os_mbuf *buf;
struct os_mbuf *buf;
buf = os_msys_get(size, 0);
assert(buf);
buf = os_msys_get(size, 0);
assert(buf);
return buf;
return buf;
}
/* This is by purpose */
void net_buf_simple_init(struct os_mbuf *buf,
size_t reserve_head)
size_t reserve_head)
{
/* This is called in Zephyr after init.
* Note in Mynewt case we don't care abour reserved head*/
buf->om_data = &buf->om_databuf[buf->om_pkthdr_len] + reserve_head;
buf->om_len = 0;
/* This is called in Zephyr after init.
* Note in Mynewt case we don't care abour reserved head*/
buf->om_data = &buf->om_databuf[buf->om_pkthdr_len] + reserve_head;
buf->om_len = 0;
}
void
net_buf_simple_add_le16(struct os_mbuf *om, uint16_t val)
{
val = htole16(val);
os_mbuf_append(om, &val, sizeof(val));
ASSERT_NOT_CHAIN(om);
val = htole16(val);
os_mbuf_append(om, &val, sizeof(val));
ASSERT_NOT_CHAIN(om);
}
void
net_buf_simple_add_be16(struct os_mbuf *om, uint16_t val)
{
val = htobe16(val);
os_mbuf_append(om, &val, sizeof(val));
ASSERT_NOT_CHAIN(om);
val = htobe16(val);
os_mbuf_append(om, &val, sizeof(val));
ASSERT_NOT_CHAIN(om);
}
void
net_buf_simple_add_be32(struct os_mbuf *om, uint32_t val)
{
val = htobe32(val);
os_mbuf_append(om, &val, sizeof(val));
ASSERT_NOT_CHAIN(om);
val = htobe32(val);
os_mbuf_append(om, &val, sizeof(val));
ASSERT_NOT_CHAIN(om);
}
void
net_buf_simple_add_u8(struct os_mbuf *om, uint8_t val)
{
os_mbuf_append(om, &val, 1);
ASSERT_NOT_CHAIN(om);
os_mbuf_append(om, &val, 1);
ASSERT_NOT_CHAIN(om);
}
void*
net_buf_simple_add(struct os_mbuf *om, uint8_t len)
{
void * tmp;
void * tmp;
tmp = os_mbuf_extend(om, len);
ASSERT_NOT_CHAIN(om);
tmp = os_mbuf_extend(om, len);
ASSERT_NOT_CHAIN(om);
return tmp;
return tmp;
}
uint8_t *
net_buf_simple_push(struct os_mbuf *om, uint8_t len)
{
uint8_t headroom = om->om_data - &om->om_databuf[om->om_pkthdr_len];
uint8_t headroom = om->om_data - &om->om_databuf[om->om_pkthdr_len];
assert(headroom >= len);
om->om_data -= len;
om->om_len += len;
assert(headroom >= len);
om->om_data -= len;
om->om_len += len;
return om->om_data;
return om->om_data;
}
#endif
apps/bttester/src/glue.h
+15 -8
View File
@@ -49,15 +49,22 @@ struct bt_data {
.data = (const uint8_t *)(_data), \
}
struct os_mbuf * NET_BUF_SIMPLE(uint16_t size);
void net_buf_simple_init(struct os_mbuf *buf, size_t reserve_head);
void net_buf_simple_add_le16(struct os_mbuf *om, uint16_t val);
void net_buf_simple_add_u8(struct os_mbuf *om, uint8_t val);
void *net_buf_simple_add(struct os_mbuf *om, uint8_t len);
uint8_t *net_buf_simple_push(struct os_mbuf *om, uint8_t len);
struct os_mbuf *
NET_BUF_SIMPLE(uint16_t size);
void
net_buf_simple_init(struct os_mbuf *buf, size_t reserve_head);
void
net_buf_simple_add_le16(struct os_mbuf *om, uint16_t val);
void
net_buf_simple_add_u8(struct os_mbuf *om, uint8_t val);
void *
net_buf_simple_add(struct os_mbuf *om, uint8_t len);
uint8_t *
net_buf_simple_push(struct os_mbuf *om, uint8_t len);
#define net_buf_simple_add_mem(a,b,c) os_mbuf_append(a,b,c)
#define net_buf_simple_add_mem(a, b, c) os_mbuf_append(a,b,c)
const char *bt_hex(const void *buf, size_t len);
const char *
bt_hex(const void *buf, size_t len);
#endif /* __GLUE_H__ */
apps/bttester/src/l2cap.c
+535 -509
View File
File diff suppressed because it is too large Load Diff
apps/bttester/src/main.c
+24 -21
View File
@@ -33,40 +33,43 @@
#include "bttester.h"
static void on_reset(int reason)
static void
on_reset(int reason)
{
MODLOG_DFLT(ERROR, "Resetting state; reason=%d\n", reason);
MODLOG_DFLT(ERROR, "Resetting state; reason=%d\n", reason);
}
static void on_sync(void)
static void
on_sync(void)
{
MODLOG_DFLT(INFO, "Bluetooth initialized\n");
MODLOG_DFLT(INFO, "Bluetooth initialized\n");
tester_init();
tester_init();
}
int main(int argc, char **argv)
int
main(int argc, char **argv)
{
int rc;
int rc;
#ifdef ARCH_sim
mcu_sim_parse_args(argc, argv);
mcu_sim_parse_args(argc, argv);
#endif
/* Initialize OS */
sysinit();
/* Initialize OS */
sysinit();
/* Initialize the NimBLE host configuration. */
ble_hs_cfg.reset_cb = on_reset;
ble_hs_cfg.sync_cb = on_sync;
ble_hs_cfg.gatts_register_cb = gatt_svr_register_cb,
ble_hs_cfg.store_status_cb = ble_store_util_status_rr;
/* Initialize the NimBLE host configuration. */
ble_hs_cfg.reset_cb = on_reset;
ble_hs_cfg.sync_cb = on_sync;
ble_hs_cfg.gatts_register_cb = gatt_svr_register_cb,
ble_hs_cfg.store_status_cb = ble_store_util_status_rr;
rc = gatt_svr_init();
assert(rc == 0);
rc = gatt_svr_init();
assert(rc == 0);
while (1) {
os_eventq_run(os_eventq_dflt_get());
}
return 0;
while (1) {
os_eventq_run(os_eventq_dflt_get());
}
return 0;
}
apps/bttester/src/mesh.c
+645 -594
View File
File diff suppressed because it is too large Load Diff
apps/bttester/src/uart_pipe.c
+31 -29
View File
@@ -41,7 +41,7 @@ struct uart_pipe_ring {
static struct uart_dev *uart_dev;
static struct uart_pipe_ring cr_tx;
static uint8_t cr_tx_buf[MYNEWT_VAL(BTTESTER_BTP_DATA_SIZE_MAX)];
typedef void (*console_write_char)(struct uart_dev*, uint8_t);
typedef void (*console_write_char)(struct uart_dev *, uint8_t);
static console_write_char write_char_cb;
static struct uart_pipe_ring cr_rx;
@@ -217,39 +217,39 @@ bttester_pipe_send(const uint8_t *data, int len)
int
bttester_pipe_send_buf(struct os_mbuf *buf)
{
int i, len;
struct os_mbuf *om;
int i, len;
struct os_mbuf *om;
/* Assure that there is a write cb installed; this enables to debug
* code that is faulting before the console was initialized.
*/
if (!write_char_cb) {
return -1;
}
/* Assure that there is a write cb installed; this enables to debug
* code that is faulting before the console was initialized.
*/
if (!write_char_cb) {
return -1;
}
for (om = buf; om; om = SLIST_NEXT(om, om_next)) {
len = om->om_len;
for (i = 0; i < len; ++i) {
write_char_cb(uart_dev, om->om_data[i]);
}
}
for (om = buf; om; om = SLIST_NEXT(om, om_next)) {
len = om->om_len;
for (i = 0; i < len; ++i) {
write_char_cb(uart_dev, om->om_data[i]);
}
}
uart_start_tx(uart_dev);
uart_start_tx(uart_dev);
return 0;
return 0;
}
int
bttester_pipe_init(void)
{
struct uart_conf uc = {
.uc_speed = MYNEWT_VAL(CONSOLE_UART_BAUD),
.uc_databits = 8,
.uc_stopbits = 1,
.uc_parity = UART_PARITY_NONE,
.uc_flow_ctl = MYNEWT_VAL(CONSOLE_UART_FLOW_CONTROL),
.uc_tx_char = uart_console_tx_char,
.uc_rx_char = uart_console_rx_char,
.uc_speed = MYNEWT_VAL(CONSOLE_UART_BAUD),
.uc_databits = 8,
.uc_stopbits = 1,
.uc_parity = UART_PARITY_NONE,
.uc_flow_ctl = MYNEWT_VAL(CONSOLE_UART_FLOW_CONTROL),
.uc_tx_char = uart_console_tx_char,
.uc_rx_char = uart_console_rx_char,
};
cr_tx.size = sizeof(cr_tx_buf);
@@ -262,8 +262,9 @@ bttester_pipe_init(void)
rx_ev.ev_cb = uart_console_rx_char_event;
if (!uart_dev) {
uart_dev = (struct uart_dev *)os_dev_open(MYNEWT_VAL(CONSOLE_UART_DEV),
OS_TIMEOUT_NEVER, &uc);
uart_dev =
(struct uart_dev *) os_dev_open(MYNEWT_VAL(CONSOLE_UART_DEV),
OS_TIMEOUT_NEVER, &uc);
if (!uart_dev) {
return -1;
}
@@ -274,8 +275,9 @@ bttester_pipe_init(void)
void
bttester_pipe_register(uint8_t *buf, size_t len, bttester_pipe_recv_cb cb)
{
recv_buf = buf;
recv_buf_len = len;
app_cb = cb;
recv_buf = buf;
recv_buf_len = len;
app_cb = cb;
}
#endif /* MYNEWT_VAL(BTTESTER_PIPE_UART) */