You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by ja...@apache.org on 2019/12/03 22:37:23 UTC
[mynewt-nimble] 05/08: nimble/host: Add support for sync transfer
This is an automated email from the ASF dual-hosted git repository.
janc pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-nimble.git
commit 465b5c808f316587cdc968e9544d35b1215ab0f5
Author: Szymon Janc <sz...@codecoup.pl>
AuthorDate: Mon Nov 4 12:57:46 2019 +0100
nimble/host: Add support for sync transfer
This allows to transmit and receive periodic sync transfer.
New BLE_GAP_EVENT_PERIODIC_TRANSFER is generated when periodic
sync transfer reception was attempted regardless of status.
Since HCI spec is not requiring controller to disable transfer reception
on first attemp, such behaviour is implemented in host. This is to
mimic other GAP procedures as well as give application more control
on controlling receptions.
---
nimble/host/include/host/ble_gap.h | 107 +++++++++++++
nimble/host/src/ble_gap.c | 303 +++++++++++++++++++++++++++++++++++++
nimble/host/src/ble_gap_priv.h | 1 +
nimble/host/src/ble_hs_conn_priv.h | 4 +
nimble/host/src/ble_hs_hci_evt.c | 19 +++
nimble/host/src/ble_hs_startup.c | 10 ++
6 files changed, 444 insertions(+)
diff --git a/nimble/host/include/host/ble_gap.h b/nimble/host/include/host/ble_gap.h
index 7523e23..6af7e9d 100644
--- a/nimble/host/include/host/ble_gap.h
+++ b/nimble/host/include/host/ble_gap.h
@@ -128,6 +128,7 @@ struct hci_conn_update;
#define BLE_GAP_EVENT_PERIODIC_REPORT 21
#define BLE_GAP_EVENT_PERIODIC_SYNC_LOST 22
#define BLE_GAP_EVENT_SCAN_REQ_RCVD 23
+#define BLE_GAP_EVENT_PERIODIC_TRANSFER 24
/*** Reason codes for the subscribe GAP event. */
@@ -925,6 +926,47 @@ struct ble_gap_event {
ble_addr_t scan_addr;
} scan_req_rcvd;
#endif
+#if MYNEWT_VAL(BLE_PERIODIC_ADV_SYNC_TRANSFER)
+ /**
+ * Represents a periodic advertising sync transfer received. Valid for
+ * the following event types:
+ * o BLE_GAP_EVENT_PERIODIC_TRANSFER
+ */
+ struct {
+ /** BLE_ERR_SUCCESS on success or error code on failure. Sync handle
+ * is valid only for success.
+ */
+ uint8_t status;
+
+ /** Periodic sync handle */
+ uint16_t sync_handle;
+
+ /** Connection handle */
+ uint16_t conn_handle;
+
+ /** Service Data */
+ uint16_t service_data;
+
+ /** Advertising Set ID */
+ uint8_t sid;
+
+ /** Advertiser address */
+ ble_addr_t adv_addr;
+
+ /** Advertising PHY, can be one of following constants:
+ * - BLE_HCI_LE_PHY_1M
+ * - LE_HCI_LE_PHY_2M
+ * - BLE_HCI_LE_PHY_CODED
+ */
+ uint8_t adv_phy;
+
+ /** Periodic advertising interval */
+ uint16_t per_adv_itvl;
+
+ /** Advertiser clock accuracy */
+ uint8_t adv_clk_accuracy;
+ } periodic_transfer;
+#endif
};
};
@@ -1297,6 +1339,9 @@ struct ble_gap_periodic_sync_params {
/** Synchronization timeout for the periodic advertising train in 10ms units
*/
uint16_t sync_timeout;
+
+ /** If reports should be initially disabled when sync is created */
+ unsigned int reports_disabled:1;
};
/**
@@ -1379,6 +1424,68 @@ int ble_gap_periodic_adv_sync_create_cancel(void);
*/
int ble_gap_periodic_adv_sync_terminate(uint16_t sync_handle);
+#if MYNEWT_VAL(BLE_PERIODIC_ADV_SYNC_TRANSFER)
+/**
+ * Disable or enable periodic reports for specified sync.
+ *
+ * @param sync_handle Handle identifying synchronization.
+ * @param enable If reports should be enabled.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int ble_gap_periodic_adv_sync_reporting(uint16_t sync_handle, bool enable);
+
+/**
+ * Initialize sync transfer procedure for specified handles.
+ *
+ * This allows to transfer periodic sync to which host is synchronized.
+ *
+ * @param sync_handle Handle identifying synchronization.
+ * @param conn_handle Handle identifying connection.
+ * @param service_data Sync transfer service data
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int ble_gap_periodic_adv_sync_transfer(uint16_t sync_handle,
+ uint16_t conn_handle,
+ uint16_t service_data);
+
+/**
+ * Initialize set info transfer procedure for specified handles.
+ *
+ * This allows to transfer periodic sync which is being advertised by host.
+ *
+ * @param instance Advertising instance with periodic adv enabled.
+ * @param conn_handle Handle identifying connection.
+ * @param service_data Sync transfer service data
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int ble_gap_periodic_adv_sync_set_info(uint8_t instance,
+ uint16_t conn_handle,
+ uint16_t service_data);
+
+/**
+ * Enables or disables sync transfer reception on specified connection.
+ * When BLE_GAP_EVENT_PERIODIC_TRANSFER is sent transfer reception is terminated
+ * on that connection.
+ *
+ * @param conn_handle Handle identifying connection.
+ * @param params Parameters for enabled sync transfer reception.
+ * Specify NULL to disable reception.
+ * @param cb The callback to associate with this synchronization
+ * procedure. BLE_GAP_EVENT_PERIODIC_REPORT events
+ * are reported only by this callback.
+ * @param cb_arg The optional argument to pass to the callback
+ * function.
+ *
+ * @return 0 on success; nonzero on failure.
+ */
+int ble_gap_periodic_adv_sync_receive(uint16_t conn_handle,
+ const struct ble_gap_periodic_sync_params *params,
+ ble_gap_event_fn *cb, void *cb_arg);
+#endif
+
/**
* Add peer device to periodic synchronization list.
*
diff --git a/nimble/host/src/ble_gap.c b/nimble/host/src/ble_gap.c
index 779b89c..d77d414 100644
--- a/nimble/host/src/ble_gap.c
+++ b/nimble/host/src/ble_gap.c
@@ -1499,6 +1499,110 @@ ble_gap_rx_periodic_adv_sync_lost(const struct ble_hci_ev_le_subev_periodic_adv_
}
#endif
+#if MYNEWT_VAL(BLE_PERIODIC_ADV_SYNC_TRANSFER)
+static int
+periodic_adv_transfer_disable(uint16_t conn_handle)
+{
+ struct ble_hci_le_periodic_adv_sync_transfer_params_cp cmd;
+ struct ble_hci_le_periodic_adv_sync_transfer_params_rp rsp;
+ uint16_t opcode;
+ int rc;
+
+ opcode = BLE_HCI_OP(BLE_HCI_OGF_LE, BLE_HCI_OCF_LE_PERIODIC_ADV_SYNC_TRANSFER_PARAMS);
+
+ cmd.conn_handle = htole16(conn_handle);
+ cmd.sync_cte_type = 0x00;
+ cmd.mode = 0x00;
+ cmd.skip = 0x0000;
+ cmd.sync_timeout = 0x000a;
+
+ rc = ble_hs_hci_cmd_tx(opcode, &cmd, sizeof(cmd), &rsp, sizeof(rsp));
+ if (!rc) {
+ BLE_HS_DBG_ASSERT(le16toh(rsp.conn_handle) == conn_handle);
+ }
+
+ return rc;
+}
+
+void
+ble_gap_rx_periodic_adv_sync_transfer(const struct ble_hci_ev_le_subev_periodic_adv_sync_transfer *ev)
+{
+ struct ble_hci_le_periodic_adv_term_sync_cp cmd_term;
+ struct ble_gap_event event;
+ struct ble_hs_conn *conn;
+ ble_gap_event_fn *cb;
+ uint16_t sync_handle;
+ uint16_t conn_handle;
+ uint16_t opcode;
+ void *cb_arg;
+
+ conn_handle = le16toh(ev->conn_handle);
+
+ ble_hs_lock();
+
+ /* Unfortunately spec sucks here as it doesn't explicitly stop
+ * transfer reception on first transfer... for now just disable it on
+ * every transfer event we get.
+ */
+ periodic_adv_transfer_disable(conn_handle);
+
+ conn = ble_hs_conn_find(le16toh(ev->conn_handle));
+ if (!conn || !conn->psync) {
+ /* terminate sync if we didn't expect it */
+ if (!ev->status) {
+ opcode = BLE_HCI_OP(BLE_HCI_OGF_LE, BLE_HCI_OCF_LE_PERIODIC_ADV_TERM_SYNC);
+ cmd_term.sync_handle = ev->sync_handle;
+ ble_hs_hci_cmd_tx(opcode, &cmd_term, sizeof(cmd_term), NULL, 0);
+ }
+
+ ble_hs_unlock();
+ return;
+ }
+
+ cb = conn->psync->cb;
+ cb_arg = conn->psync->cb_arg;
+
+ memset(&event, 0, sizeof event);
+
+ event.type = BLE_GAP_EVENT_PERIODIC_TRANSFER;
+ event.periodic_transfer.status = ev->status;
+
+ /* only sync handle is not valid on error */
+ if (ev->status) {
+ sync_handle = 0;
+ ble_hs_periodic_sync_free(conn->psync);
+ } else {
+ sync_handle = le16toh(ev->sync_handle);
+
+ conn->psync->sync_handle = sync_handle;
+ conn->psync->adv_sid = ev->sid;
+ memcpy(conn->psync->advertiser_addr.val, ev->peer_addr, 6);
+ conn->psync->advertiser_addr.type = ev->peer_addr_type;
+ ble_hs_periodic_sync_insert(conn->psync);
+ }
+
+ conn->psync = NULL;
+
+ event.periodic_transfer.sync_handle = sync_handle;
+ event.periodic_transfer.conn_handle = conn_handle;
+ event.periodic_transfer.service_data = le16toh(ev->service_data);
+ event.periodic_transfer.sid = ev->sid;
+ memcpy(event.periodic_transfer.adv_addr.val, ev->peer_addr, 6);
+ event.periodic_transfer.adv_addr.type = ev->peer_addr_type;
+
+ event.periodic_transfer.adv_phy = ev->phy;
+ event.periodic_transfer.per_adv_itvl = le16toh(ev->interval);
+ event.periodic_transfer.adv_clk_accuracy = ev->aca;
+
+ ble_hs_unlock();
+
+ ble_gap_event_listener_call(&event);
+ if (cb) {
+ cb(&event, cb_arg);
+ }
+}
+#endif
+
static int
ble_gap_rd_rem_sup_feat_tx(uint16_t handle)
{
@@ -3561,6 +3665,205 @@ ble_gap_periodic_adv_sync_terminate(uint16_t sync_handle)
return rc;
}
+#if MYNEWT_VAL(BLE_PERIODIC_ADV_SYNC_TRANSFER)
+int
+ble_gap_periodic_adv_sync_reporting(uint16_t sync_handle, bool enable)
+{
+ struct ble_hci_le_periodic_adv_receive_enable_cp cmd;
+ struct ble_hs_periodic_sync *psync;
+ uint16_t opcode;
+ int rc;
+
+ ble_hs_lock();
+
+ if (ble_gap_sync.op == BLE_GAP_OP_SYNC) {
+ ble_hs_unlock();
+ return BLE_HS_EBUSY;
+ }
+
+ psync = ble_hs_periodic_sync_find_by_handle(sync_handle);
+ if (!psync) {
+ ble_hs_unlock();
+ return BLE_HS_ENOTCONN;
+ }
+
+ opcode = BLE_HCI_OP(BLE_HCI_OGF_LE, BLE_HCI_OCF_LE_PERIODIC_ADV_RECEIVE_ENABLE);
+
+ cmd.sync_handle = htole16(sync_handle);
+ cmd.enable = enable ? 0x01 : 0x00;
+
+ rc = ble_hs_hci_cmd_tx(opcode, &cmd, sizeof(cmd), NULL, 0);
+
+ ble_hs_unlock();
+
+ return rc;
+}
+
+int
+ble_gap_periodic_adv_sync_transfer(uint16_t sync_handle, uint16_t conn_handle,
+ uint16_t service_data)
+{
+ struct ble_hci_le_periodic_adv_sync_transfer_cp cmd;
+ struct ble_hci_le_periodic_adv_sync_transfer_rp rsp;
+ struct ble_hs_periodic_sync *psync;
+ struct ble_hs_conn *conn;
+ uint16_t opcode;
+ int rc;
+
+ ble_hs_lock();
+
+ conn = ble_hs_conn_find(conn_handle);
+ if (!conn) {
+ ble_hs_unlock();
+ return BLE_HS_ENOTCONN;
+ }
+
+ psync = ble_hs_periodic_sync_find_by_handle(sync_handle);
+ if (!psync) {
+ ble_hs_unlock();
+ return BLE_HS_ENOTCONN;
+ }
+
+ opcode = BLE_HCI_OP(BLE_HCI_OGF_LE, BLE_HCI_OCF_LE_PERIODIC_ADV_SYNC_TRANSFER);
+
+ cmd.conn_handle = htole16(conn_handle);
+ cmd.sync_handle = htole16(sync_handle);
+ cmd.service_data = htole16(service_data);
+
+ rc = ble_hs_hci_cmd_tx(opcode, &cmd, sizeof(cmd), &rsp, sizeof(rsp));
+ if (!rc) {
+ BLE_HS_DBG_ASSERT(le16toh(rsp.conn_handle) == conn_handle);
+ }
+
+ ble_hs_unlock();
+
+ return rc;
+}
+
+int
+ble_gap_periodic_adv_sync_set_info(uint8_t instance, uint16_t conn_handle,
+ uint16_t service_data)
+{
+ struct ble_hci_le_periodic_adv_set_info_transfer_cp cmd;
+ struct ble_hci_le_periodic_adv_set_info_transfer_rp rsp;
+ struct ble_hs_conn *conn;
+ uint16_t opcode;
+ int rc;
+
+ if (instance >= BLE_ADV_INSTANCES) {
+ return BLE_HS_EINVAL;
+ }
+
+ ble_hs_lock();
+ if (ble_gap_slave[instance].periodic_op != BLE_GAP_OP_S_PERIODIC_ADV) {
+ /* periodic adv not enabled */
+ ble_hs_unlock();
+ return BLE_HS_EINVAL;
+ }
+
+ conn = ble_hs_conn_find(conn_handle);
+ if (!conn) {
+ ble_hs_unlock();
+ return BLE_HS_ENOTCONN;
+ }
+
+ opcode = BLE_HCI_OP(BLE_HCI_OGF_LE, BLE_HCI_OCF_LE_PERIODIC_ADV_SET_INFO_TRANSFER);
+
+ cmd.conn_handle = htole16(conn_handle);
+ cmd.adv_handle = instance;
+ cmd.service_data = htole16(service_data);
+
+ rc = ble_hs_hci_cmd_tx(opcode, &cmd, sizeof(cmd), &rsp, sizeof(rsp));
+ if (!rc) {
+ BLE_HS_DBG_ASSERT(le16toh(rsp.conn_handle) == conn_handle);
+ }
+
+ ble_hs_unlock();
+
+ return rc;
+}
+
+static int
+periodic_adv_transfer_enable(uint16_t conn_handle,
+ const struct ble_gap_periodic_sync_params *params)
+{
+ struct ble_hci_le_periodic_adv_sync_transfer_params_cp cmd;
+ struct ble_hci_le_periodic_adv_sync_transfer_params_rp rsp;
+ uint16_t opcode;
+ int rc;
+
+ opcode = BLE_HCI_OP(BLE_HCI_OGF_LE, BLE_HCI_OCF_LE_PERIODIC_ADV_SYNC_TRANSFER_PARAMS);
+
+ cmd.conn_handle = htole16(conn_handle);
+ cmd.sync_cte_type = 0x00;
+ cmd.mode = params->reports_disabled ? 0x01 : 0x02;
+ cmd.skip = htole16(params->skip);
+ cmd.sync_timeout = htole16(params->sync_timeout);
+
+ rc = ble_hs_hci_cmd_tx(opcode, &cmd, sizeof(cmd), &rsp, sizeof(rsp));
+ if (!rc) {
+ BLE_HS_DBG_ASSERT(le16toh(rsp.conn_handle) == conn_handle);
+ }
+
+ return rc;
+}
+
+int
+ble_gap_periodic_adv_sync_receive(uint16_t conn_handle,
+ const struct ble_gap_periodic_sync_params *params,
+ ble_gap_event_fn *cb, void *cb_arg)
+{
+ struct ble_hs_conn *conn;
+ int rc;
+
+ ble_hs_lock();
+
+ conn = ble_hs_conn_find(conn_handle);
+ if (!conn) {
+ ble_hs_unlock();
+ return BLE_HS_ENOTCONN;
+ }
+
+ if (params) {
+ if (conn->psync) {
+ ble_hs_unlock();
+ return BLE_HS_EALREADY;
+ }
+
+ conn->psync = ble_hs_periodic_sync_alloc();
+ if (!conn->psync) {
+ ble_hs_unlock();
+ return BLE_HS_ENOMEM;
+ }
+
+ rc = periodic_adv_transfer_enable(conn_handle, params);
+ if (rc) {
+ ble_hs_periodic_sync_free(conn->psync);
+ conn->psync = NULL;
+ } else {
+ conn->psync->cb = cb;
+ conn->psync->cb_arg = cb_arg;
+ ble_npl_event_init(&conn->psync->lost_ev, ble_gap_npl_sync_lost,
+ conn->psync);
+ }
+ } else {
+ if (!conn->psync) {
+ ble_hs_unlock();
+ return BLE_HS_EALREADY;
+ }
+
+ rc = periodic_adv_transfer_disable(conn_handle);
+ if (!rc) {
+ ble_hs_periodic_sync_free(conn->psync);
+ conn->psync = NULL;
+ }
+ }
+
+ ble_hs_unlock();
+
+ return rc;
+}
+#endif
int
ble_gap_add_dev_to_periodic_adv_list(const ble_addr_t *peer_addr,
diff --git a/nimble/host/src/ble_gap_priv.h b/nimble/host/src/ble_gap_priv.h
index 06ab765..ce44319 100644
--- a/nimble/host/src/ble_gap_priv.h
+++ b/nimble/host/src/ble_gap_priv.h
@@ -86,6 +86,7 @@ void ble_gap_rx_adv_set_terminated(const struct ble_hci_ev_le_subev_adv_set_term
void ble_gap_rx_peroidic_adv_sync_estab(const struct ble_hci_ev_le_subev_periodic_adv_sync_estab *ev);
void ble_gap_rx_periodic_adv_rpt(const struct ble_hci_ev_le_subev_periodic_adv_rpt *ev);
void ble_gap_rx_periodic_adv_sync_lost(const struct ble_hci_ev_le_subev_periodic_adv_sync_lost *ev);
+void ble_gap_rx_periodic_adv_sync_transfer(const struct ble_hci_ev_le_subev_periodic_adv_sync_transfer *ev);
#endif
void ble_gap_rx_scan_req_rcvd(const struct ble_hci_ev_le_subev_scan_req_rcvd *ev);
#endif
diff --git a/nimble/host/src/ble_hs_conn_priv.h b/nimble/host/src/ble_hs_conn_priv.h
index fa9f7a8..7578145 100644
--- a/nimble/host/src/ble_hs_conn_priv.h
+++ b/nimble/host/src/ble_hs_conn_priv.h
@@ -98,6 +98,10 @@ struct ble_hs_conn {
ble_gap_event_fn *bhc_cb;
void *bhc_cb_arg;
+
+#if MYNEWT_VAL(BLE_PERIODIC_ADV)
+ struct ble_hs_periodic_sync *psync;
+#endif
};
struct ble_hs_conn_addrs {
diff --git a/nimble/host/src/ble_hs_hci_evt.c b/nimble/host/src/ble_hs_hci_evt.c
index 1ebd5a6..32ed401 100644
--- a/nimble/host/src/ble_hs_hci_evt.c
+++ b/nimble/host/src/ble_hs_hci_evt.c
@@ -57,6 +57,8 @@ static ble_hs_hci_evt_le_fn ble_hs_hci_evt_le_periodic_adv_rpt;
static ble_hs_hci_evt_le_fn ble_hs_hci_evt_le_periodic_adv_sync_lost;
static ble_hs_hci_evt_le_fn ble_hs_hci_evt_le_scan_req_rcvd;
static ble_hs_hci_evt_le_fn ble_hs_hci_evt_le_enh_conn_complete;
+static ble_hs_hci_evt_le_fn ble_hs_hci_evt_le_periodic_adv_sync_transfer;
+
/* Statistics */
struct host_hci_stats
{
@@ -103,6 +105,7 @@ static ble_hs_hci_evt_le_fn * const ble_hs_hci_evt_le_dispatch[] = {
[BLE_HCI_LE_SUBEV_SCAN_TIMEOUT] = ble_hs_hci_evt_le_scan_timeout,
[BLE_HCI_LE_SUBEV_ADV_SET_TERMINATED] = ble_hs_hci_evt_le_adv_set_terminated,
[BLE_HCI_LE_SUBEV_SCAN_REQ_RCVD] = ble_hs_hci_evt_le_scan_req_rcvd,
+ [BLE_HCI_LE_SUBEV_PERIODIC_ADV_SYNC_TRANSFER] = ble_hs_hci_evt_le_periodic_adv_sync_transfer,
};
#define BLE_HS_HCI_EVT_LE_DISPATCH_SZ \
@@ -623,6 +626,22 @@ ble_hs_hci_evt_le_periodic_adv_sync_lost(uint8_t subevent, const void *data,
return 0;
}
+static int
+ble_hs_hci_evt_le_periodic_adv_sync_transfer(uint8_t subevent, const void *data,
+ unsigned int len)
+{
+#if MYNEWT_VAL(BLE_PERIODIC_ADV_SYNC_TRANSFER)
+ const struct ble_hci_ev_le_subev_periodic_adv_sync_transfer *ev = data;
+
+ if (len != sizeof(*ev)) {
+ return BLE_HS_EBADDATA;
+ }
+
+ ble_gap_rx_periodic_adv_sync_transfer(ev);
+
+#endif
+ return 0;
+}
static int
ble_hs_hci_evt_le_scan_timeout(uint8_t subevent, const void *data,
diff --git a/nimble/host/src/ble_hs_startup.c b/nimble/host/src/ble_hs_startup.c
index 2ef8900..83026ac 100644
--- a/nimble/host/src/ble_hs_startup.c
+++ b/nimble/host/src/ble_hs_startup.c
@@ -228,6 +228,16 @@ ble_hs_startup_le_set_evmask_tx(void)
mask |= 0x00000000000ff800;
}
+#if MYNEWT_VAL(BLE_PERIODIC_ADV_SYNC_TRANSFER)
+ if (version >= BLE_HCI_VER_BCS_5_1) {
+ /**
+ * Enable the following LE events:
+ * 0x0000000000800000 LE Periodic Advertising Sync Transfer Received event
+ */
+ mask |= 0x0000000000800000;
+ }
+#endif
+
cmd.event_mask = htole64(mask);
rc = ble_hs_hci_cmd_tx(BLE_HCI_OP(BLE_HCI_OGF_LE,