korg/bluez
0
0
Fork 0
mirror of https://git.kernel.org/pub/scm/bluetooth/bluez.git synced 2024-11-15 00:04:29 +08:00
Code Issues Packages Projects Releases Wiki Activity

monitor: Inclusive language changes

Browse Source 
BT core spec 5.3 promotes the usage of inclusive languages.
This CL replaces some terms with the more appropriate counterparts,
such as "central", "peripheral", "link key", and "accept list"

Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
This commit is contained in:
Archie Pusaka 2021-09-15 16:31:57 +08:00 committed by Marcel Holtmann
parent a777d7d535
commit 7582f36071
13 changed files with 400 additions and 390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
emulator/btdev.c
View File

@ -3568,11 +3568,11 @@ static int cmd_le_create_conn_complete(struct btdev *dev, const void *data,
static int cmd_read_wl_size(struct btdev *dev, const void *data, uint8_t len)
{
struct bt_hci_rsp_le_read_white_list_size rsp;
struct bt_hci_rsp_le_read_accept_list_size rsp;
rsp.status = BT_HCI_ERR_SUCCESS;
rsp.size = WL_SIZE;
cmd_complete(dev, BT_HCI_CMD_LE_READ_WHITE_LIST_SIZE, &rsp,
cmd_complete(dev, BT_HCI_CMD_LE_READ_ACCEPT_LIST_SIZE, &rsp,
sizeof(rsp));
return 0;
@ -3620,7 +3620,7 @@ static int cmd_wl_clear(struct btdev *dev, const void *data, uint8_t len)
wl_clear(dev);
status = BT_HCI_ERR_SUCCESS;
cmd_complete(dev, BT_HCI_CMD_LE_CLEAR_WHITE_LIST, &status,
cmd_complete(dev, BT_HCI_CMD_LE_CLEAR_ACCEPT_LIST, &status,
sizeof(status));
return 0;
@ -3637,7 +3637,7 @@ static void wl_add(struct btdev_wl *wl, uint8_t type, bdaddr_t *addr)
static int cmd_add_wl(struct btdev *dev, const void *data, uint8_t len)
{
const struct bt_hci_cmd_le_add_to_white_list *cmd = data;
const struct bt_hci_cmd_le_add_to_accept_list *cmd = data;
uint8_t status;
bool exists = false;
int i, pos = -1;
@ -3673,14 +3673,14 @@ static int cmd_add_wl(struct btdev *dev, const void *data, uint8_t len)
if (pos < 0) {
cmd_status(dev, BT_HCI_ERR_MEM_CAPACITY_EXCEEDED,
BT_HCI_CMD_LE_ADD_TO_WHITE_LIST);
BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST);
return 0;
}
wl_add(&dev->le_wl[pos], cmd->addr_type, (bdaddr_t *)&cmd->addr);
status = BT_HCI_ERR_SUCCESS;
cmd_complete(dev, BT_HCI_CMD_LE_ADD_TO_WHITE_LIST,
cmd_complete(dev, BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST,
&status, sizeof(status));
return 0;
@ -3688,7 +3688,7 @@ static int cmd_add_wl(struct btdev *dev, const void *data, uint8_t len)
static int cmd_remove_wl(struct btdev *dev, const void *data, uint8_t len)
{
const struct bt_hci_cmd_le_remove_from_white_list *cmd = data;
const struct bt_hci_cmd_le_remove_from_accept_list *cmd = data;
uint8_t status;
int i;
char addr[18];
@ -3728,7 +3728,7 @@ static int cmd_remove_wl(struct btdev *dev, const void *data, uint8_t len)
return -EINVAL;
status = BT_HCI_ERR_SUCCESS;
cmd_complete(dev, BT_HCI_CMD_LE_REMOVE_FROM_WHITE_LIST,
cmd_complete(dev, BT_HCI_CMD_LE_REMOVE_FROM_ACCEPT_LIST,
&status, sizeof(status));
return 0;
@ -4313,10 +4313,10 @@ static int cmd_gen_dhkey(struct btdev *dev, const void *data, uint8_t len)
cmd_set_scan_enable_complete), \
CMD(BT_HCI_CMD_LE_CREATE_CONN, cmd_le_create_conn, \
cmd_le_create_conn_complete), \
CMD(BT_HCI_CMD_LE_READ_WHITE_LIST_SIZE, cmd_read_wl_size, NULL), \
CMD(BT_HCI_CMD_LE_CLEAR_WHITE_LIST, cmd_wl_clear, NULL), \
CMD(BT_HCI_CMD_LE_ADD_TO_WHITE_LIST, cmd_add_wl, NULL), \
CMD(BT_HCI_CMD_LE_REMOVE_FROM_WHITE_LIST, cmd_remove_wl, NULL), \
CMD(BT_HCI_CMD_LE_READ_ACCEPT_LIST_SIZE, cmd_read_wl_size, NULL), \
CMD(BT_HCI_CMD_LE_CLEAR_ACCEPT_LIST, cmd_wl_clear, NULL), \
CMD(BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST, cmd_add_wl, NULL), \
CMD(BT_HCI_CMD_LE_REMOVE_FROM_ACCEPT_LIST, cmd_remove_wl, NULL), \
CMD(BT_HCI_CMD_LE_CONN_UPDATE, cmd_conn_update, \
cmd_conn_update_complete), \
CMD(BT_HCI_CMD_LE_READ_REMOTE_FEATURES, cmd_le_read_remote_features, \
@ -5408,24 +5408,24 @@ static void le_cis_estabilished(struct btdev *dev, struct btdev_conn *conn,
struct btdev *remote = conn->link->dev;
/* TODO: Figure out if these values makes sense */
memcpy(evt.cig_sync_delay, remote->le_cig.params.m_interval,
sizeof(remote->le_cig.params.m_interval));
memcpy(evt.cis_sync_delay, remote->le_cig.params.s_interval,
sizeof(remote->le_cig.params.s_interval));
memcpy(evt.m_latency, &remote->le_cig.params.m_latency,
sizeof(remote->le_cig.params.m_latency));
memcpy(evt.s_latency, &remote->le_cig.params.s_latency,
sizeof(remote->le_cig.params.s_latency));
evt.m_phy = remote->le_cig.cis[0].m_phy;
evt.s_phy = remote->le_cig.cis[0].s_phy;
memcpy(evt.cig_sync_delay, remote->le_cig.params.c_interval,
sizeof(remote->le_cig.params.c_interval));
memcpy(evt.cis_sync_delay, remote->le_cig.params.p_interval,
sizeof(remote->le_cig.params.p_interval));
memcpy(evt.c_latency, &remote->le_cig.params.c_latency,
sizeof(remote->le_cig.params.c_latency));
memcpy(evt.p_latency, &remote->le_cig.params.p_latency,
sizeof(remote->le_cig.params.p_latency));
evt.c_phy = remote->le_cig.cis[0].c_phy;
evt.p_phy = remote->le_cig.cis[0].p_phy;
evt.nse = 0x01;
evt.m_bn = 0x01;
evt.s_bn = 0x01;
evt.m_ft = 0x01;
evt.s_ft = 0x01;
evt.m_mtu = remote->le_cig.cis[0].m_sdu;
evt.s_mtu = remote->le_cig.cis[0].s_sdu;
evt.interval = remote->le_cig.params.m_latency;
evt.c_bn = 0x01;
evt.p_bn = 0x01;
evt.c_ft = 0x01;
evt.p_ft = 0x01;
evt.c_mtu = remote->le_cig.cis[0].c_sdu;
evt.p_mtu = remote->le_cig.cis[0].p_sdu;
evt.interval = remote->le_cig.params.c_latency;
}
le_meta_event(dev, BT_HCI_EVT_LE_CIS_ESTABLISHED, &evt, sizeof(evt));

32
emulator/le.c
View File

@ -1211,12 +1211,12 @@ static void cmd_le_create_conn_cancel(struct bt_le *hci,
static void cmd_le_read_white_list_size(struct bt_le *hci,
const void *data, uint8_t size)
{
struct bt_hci_rsp_le_read_white_list_size rsp;
struct bt_hci_rsp_le_read_accept_list_size rsp;
rsp.status = BT_HCI_ERR_SUCCESS;
rsp.size = hci->le_white_list_size;
cmd_complete(hci, BT_HCI_CMD_LE_READ_WHITE_LIST_SIZE,
cmd_complete(hci, BT_HCI_CMD_LE_READ_ACCEPT_LIST_SIZE,
&rsp, sizeof(rsp));
}
@ -1228,14 +1228,14 @@ static void cmd_le_clear_white_list(struct bt_le *hci,
clear_white_list(hci);
status = BT_HCI_ERR_SUCCESS;
cmd_complete(hci, BT_HCI_CMD_LE_CLEAR_WHITE_LIST,
cmd_complete(hci, BT_HCI_CMD_LE_CLEAR_ACCEPT_LIST,
&status, sizeof(status));
}
static void cmd_le_add_to_white_list(struct bt_le *hci,
const void *data, uint8_t size)
{
const struct bt_hci_cmd_le_add_to_white_list *cmd = data;
const struct bt_hci_cmd_le_add_to_accept_list *cmd = data;
uint8_t status;
bool exists = false;
int i, pos = -1;
@ -1243,7 +1243,7 @@ static void cmd_le_add_to_white_list(struct bt_le *hci,
/* Valid range for address type is 0x00 to 0x01 */
if (cmd->addr_type > 0x01) {
cmd_status(hci, BT_HCI_ERR_INVALID_PARAMETERS,
BT_HCI_CMD_LE_ADD_TO_WHITE_LIST);
BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST);
return;
}
@ -1259,13 +1259,13 @@ static void cmd_le_add_to_white_list(struct bt_le *hci,
if (exists) {
cmd_status(hci, BT_HCI_ERR_UNSPECIFIED_ERROR,
BT_HCI_CMD_LE_ADD_TO_WHITE_LIST);
BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST);
return;
}
if (pos < 0) {
cmd_status(hci, BT_HCI_ERR_MEM_CAPACITY_EXCEEDED,
BT_HCI_CMD_LE_ADD_TO_WHITE_LIST);
BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST);
return;
}
@ -1273,21 +1273,21 @@ static void cmd_le_add_to_white_list(struct bt_le *hci,
memcpy(&hci->le_white_list[pos][1], cmd->addr, 6);
status = BT_HCI_ERR_SUCCESS;
cmd_complete(hci, BT_HCI_CMD_LE_ADD_TO_WHITE_LIST,
cmd_complete(hci, BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST,
&status, sizeof(status));
}
static void cmd_le_remove_from_white_list(struct bt_le *hci,
const void *data, uint8_t size)
{
const struct bt_hci_cmd_le_remove_from_white_list *cmd = data;
const struct bt_hci_cmd_le_remove_from_accept_list *cmd = data;
uint8_t status;
int i, pos = -1;
/* Valid range for address type is 0x00 to 0x01 */
if (cmd->addr_type > 0x01) {
cmd_status(hci, BT_HCI_ERR_INVALID_PARAMETERS,
BT_HCI_CMD_LE_REMOVE_FROM_WHITE_LIST);
BT_HCI_CMD_LE_REMOVE_FROM_ACCEPT_LIST);
return;
}
@ -1302,7 +1302,7 @@ static void cmd_le_remove_from_white_list(struct bt_le *hci,
if (pos < 0) {
cmd_status(hci, BT_HCI_ERR_INVALID_PARAMETERS,
BT_HCI_CMD_LE_REMOVE_FROM_WHITE_LIST);
BT_HCI_CMD_LE_REMOVE_FROM_ACCEPT_LIST);
return;
}
@ -1310,7 +1310,7 @@ static void cmd_le_remove_from_white_list(struct bt_le *hci,
memset(&hci->le_white_list[pos][1], 0, 6);
status = BT_HCI_ERR_SUCCESS;
cmd_complete(hci, BT_HCI_CMD_LE_REMOVE_FROM_WHITE_LIST,
cmd_complete(hci, BT_HCI_CMD_LE_REMOVE_FROM_ACCEPT_LIST,
&status, sizeof(status));
}
@ -1830,13 +1830,13 @@ static const struct {
cmd_le_create_conn, 25, true },
{ BT_HCI_CMD_LE_CREATE_CONN_CANCEL,
cmd_le_create_conn_cancel, 0, true },
{ BT_HCI_CMD_LE_READ_WHITE_LIST_SIZE,
{ BT_HCI_CMD_LE_READ_ACCEPT_LIST_SIZE,
cmd_le_read_white_list_size, 0, true },
{ BT_HCI_CMD_LE_CLEAR_WHITE_LIST,
{ BT_HCI_CMD_LE_CLEAR_ACCEPT_LIST,
cmd_le_clear_white_list, 0, true },
{ BT_HCI_CMD_LE_ADD_TO_WHITE_LIST,
{ BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST,
cmd_le_add_to_white_list, 7, true },
{ BT_HCI_CMD_LE_REMOVE_FROM_WHITE_LIST,
{ BT_HCI_CMD_LE_REMOVE_FROM_ACCEPT_LIST,
cmd_le_remove_from_white_list, 7, true },
{ BT_HCI_CMD_LE_ENCRYPT, cmd_le_encrypt, 32, true },

8
emulator/smp.c
View File

@ -383,7 +383,7 @@ static void distribute_keys(struct smp_conn *conn)
if (conn->local_key_dist & DIST_ENC_KEY) {
memset(buf, 0, sizeof(buf));
smp_send(conn, BT_L2CAP_SMP_ENCRYPT_INFO, buf, sizeof(buf));
smp_send(conn, BT_L2CAP_SMP_MASTER_IDENT, buf, 10);
smp_send(conn, BT_L2CAP_SMP_CENTRAL_IDENT, buf, 10);
}
if (conn->local_key_dist & DIST_ID_KEY) {
@ -571,7 +571,7 @@ static void encrypt_info(struct smp_conn *conn, const void *data, uint16_t len)
{
}
static void master_ident(struct smp_conn *conn, const void *data, uint16_t len)
static void central_ident(struct smp_conn *conn, const void *data, uint16_t len)
{
conn->remote_key_dist &= ~DIST_ENC_KEY;
@ -727,8 +727,8 @@ void smp_data(void *conn_data, const void *data, uint16_t len)
case BT_L2CAP_SMP_ENCRYPT_INFO:
encrypt_info(conn, data, len);
break;
case BT_L2CAP_SMP_MASTER_IDENT:
master_ident(conn, data, len);
case BT_L2CAP_SMP_CENTRAL_IDENT:
central_ident(conn, data, len);
break;
case BT_L2CAP_SMP_IDENT_ADDR_INFO:
ident_addr_info(conn, data, len);

8
monitor/broadcom.c
View File

@ -120,10 +120,10 @@ static void print_sync_mode(uint8_t mode)
switch (mode) {
case 0x00:
str = "Slave";
str = "Peripheral";
break;
case 0x01:
str = "Master";
str = "Central";
break;
default:
str = "Reserved";
@ -139,10 +139,10 @@ static void print_clock_mode(uint8_t mode)
switch (mode) {
case 0x00:
str = "Slave";
str = "Peripheral";
break;
case 0x01:
str = "Master";
str = "Central";
break;
default:
str = "Reserved";

150
monitor/bt.h
View File

@ -88,8 +88,8 @@ struct bt_ll_reject_ind {
uint8_t error;
} __attribute__ ((packed));
#define BT_LL_SLAVE_FEATURE_REQ 0x0e
struct bt_ll_slave_feature_req {
#define BT_LL_PERIPHERAL_FEATURE_REQ 0x0e
struct bt_ll_peripheral_feature_req {
uint8_t features[8];
} __attribute__ ((packed));
@ -127,8 +127,8 @@ struct bt_ll_phy {
#define BT_LL_PHY_UPDATE_IND 0x18
struct bt_ll_phy_update_ind {
uint8_t m_phy;
uint8_t s_phy;
uint8_t c_phy;
uint8_t p_phy;
uint16_t instant;
} __attribute__ ((packed));
@ -168,19 +168,19 @@ struct bt_ll_clock_acc {
struct bt_ll_cis_req {
uint8_t cig;
uint8_t cis;
uint8_t m_phy;
uint8_t s_phy;
uint16_t m_sdu;
uint16_t s_sdu;
uint8_t m_interval[3];
uint8_t s_interval[3];
uint8_t m_pdu;
uint8_t s_pdu;
uint8_t c_phy;
uint8_t p_phy;
uint16_t c_sdu;
uint16_t p_sdu;
uint8_t c_interval[3];
uint8_t p_interval[3];
uint8_t c_pdu;
uint8_t p_pdu;
uint8_t nse;
uint8_t sub_interval[3];
uint8_t bn;
uint8_t m_ft;
uint8_t s_ft;
uint8_t c_ft;
uint8_t p_ft;
uint16_t iso_interval;
uint8_t offset_min[3];
uint8_t offset_max[3];
@ -628,8 +628,8 @@ struct bt_hci_cmd_change_conn_link_key {
uint16_t handle;
} __attribute__ ((packed));
#define BT_HCI_CMD_MASTER_LINK_KEY 0x0417
struct bt_hci_cmd_master_link_key {
#define BT_HCI_CMD_LINK_KEY_SELECTION 0x0417
struct bt_hci_cmd_link_key_selection {
uint8_t key_flag;
} __attribute__ ((packed));
@ -898,8 +898,8 @@ struct bt_hci_cmd_truncated_page_cancel {
uint8_t bdaddr[6];
} __attribute__ ((packed));
#define BT_HCI_CMD_SET_SLAVE_BROADCAST 0x0441
struct bt_hci_cmd_set_slave_broadcast {
#define BT_HCI_CMD_SET_PERIPHERAL_BROADCAST 0x0441
struct bt_hci_cmd_set_peripheral_broadcast {
uint8_t enable;
uint8_t lt_addr;
uint8_t lpo_allowed;
@ -908,14 +908,14 @@ struct bt_hci_cmd_set_slave_broadcast {
uint16_t max_interval;
uint16_t timeout;
} __attribute__ ((packed));
struct bt_hci_rsp_set_slave_broadcast {
struct bt_hci_rsp_set_peripheral_broadcast {
uint8_t status;
uint8_t lt_addr;
uint16_t interval;
} __attribute__ ((packed));
#define BT_HCI_CMD_SET_SLAVE_BROADCAST_RECEIVE 0x0442
struct bt_hci_cmd_set_slave_broadcast_receive {
#define BT_HCI_CMD_SET_PERIPHERAL_BROADCAST_RECEIVE 0x0442
struct bt_hci_cmd_set_peripheral_broadcast_receive {
uint8_t enable;
uint8_t bdaddr[6];
uint8_t lt_addr;
@ -928,7 +928,7 @@ struct bt_hci_cmd_set_slave_broadcast_receive {
uint16_t pkt_type;
uint8_t map[10];
} __attribute__ ((packed));
struct bt_hci_rsp_set_slave_broadcast_receive {
struct bt_hci_rsp_set_peripheral_broadcast_receive {
uint8_t status;
uint8_t bdaddr[6];
uint8_t lt_addr;
@ -1599,13 +1599,13 @@ struct bt_hci_rsp_delete_reserved_lt_addr {
uint8_t lt_addr;
} __attribute__ ((packed));
#define BT_HCI_CMD_SET_SLAVE_BROADCAST_DATA 0x0c76
struct bt_hci_cmd_set_slave_broadcast_data {
#define BT_HCI_CMD_SET_PERIPHERAL_BROADCAST_DATA 0x0c76
struct bt_hci_cmd_set_peripheral_broadcast_data {
uint8_t lt_addr;
uint8_t fragment;
uint8_t length;
} __attribute__ ((packed));
struct bt_hci_rsp_set_slave_broadcast_data {
struct bt_hci_rsp_set_peripheral_broadcast_data {
uint8_t status;
uint8_t lt_addr;
} __attribute__ ((packed));
@ -2072,22 +2072,22 @@ struct bt_hci_cmd_le_create_conn {
#define BT_HCI_CMD_LE_CREATE_CONN_CANCEL 0x200e
#define BT_HCI_CMD_LE_READ_WHITE_LIST_SIZE 0x200f
struct bt_hci_rsp_le_read_white_list_size {
#define BT_HCI_CMD_LE_READ_ACCEPT_LIST_SIZE 0x200f
struct bt_hci_rsp_le_read_accept_list_size {
uint8_t status;
uint8_t size;
} __attribute__ ((packed));
#define BT_HCI_CMD_LE_CLEAR_WHITE_LIST 0x2010
#define BT_HCI_CMD_LE_CLEAR_ACCEPT_LIST 0x2010
#define BT_HCI_CMD_LE_ADD_TO_WHITE_LIST 0x2011
struct bt_hci_cmd_le_add_to_white_list {
#define BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST 0x2011
struct bt_hci_cmd_le_add_to_accept_list {
uint8_t addr_type;
uint8_t addr[6];
} __attribute__ ((packed));
#define BT_HCI_CMD_LE_REMOVE_FROM_WHITE_LIST 0x2012
struct bt_hci_cmd_le_remove_from_white_list {
#define BT_HCI_CMD_LE_REMOVE_FROM_ACCEPT_LIST 0x2012
struct bt_hci_cmd_le_remove_from_accept_list {
uint8_t addr_type;
uint8_t addr[6];
} __attribute__ ((packed));
@ -2646,23 +2646,23 @@ struct bt_hci_rsp_le_read_iso_tx_sync {
#define BT_HCI_BIT_LE_SET_CIG_PARAMS BT_HCI_CMD_BIT(41, 7)
struct bt_hci_cis_params {
uint8_t cis_id;
uint16_t m_sdu;
uint16_t s_sdu;
uint8_t m_phy;
uint8_t s_phy;
uint8_t m_rtn;
uint8_t s_rtn;
uint16_t c_sdu;
uint16_t p_sdu;
uint8_t c_phy;
uint8_t p_phy;
uint8_t c_rtn;
uint8_t p_rtn;
} __attribute__ ((packed));
struct bt_hci_cmd_le_set_cig_params {
uint8_t cig_id;
uint8_t m_interval[3];
uint8_t s_interval[3];
uint8_t c_interval[3];
uint8_t p_interval[3];
uint8_t sca;
uint8_t packing;
uint8_t framing;
uint16_t m_latency;
uint16_t s_latency;
uint16_t c_latency;
uint16_t p_latency;
uint8_t num_cis;
struct bt_hci_cis_params cis[0];
} __attribute__ ((packed));
@ -2679,22 +2679,22 @@ struct bt_hci_rsp_le_set_cig_params {
struct bt_hci_cis_params_test {
uint8_t cis_id;
uint8_t nse;
uint16_t m_sdu;
uint16_t s_sdu;
uint16_t m_pdu;
uint16_t s_pdu;
uint8_t m_phy;
uint8_t s_phy;
uint8_t m_bn;
uint8_t s_bn;
uint16_t c_sdu;
uint16_t p_sdu;
uint16_t c_pdu;
uint16_t p_pdu;
uint8_t c_phy;
uint8_t p_phy;
uint8_t c_bn;
uint8_t p_bn;
} __attribute__ ((packed));
struct bt_hci_cmd_le_set_cig_params_test {
uint8_t cig_id;
uint8_t m_interval[3];
uint8_t s_interval[3];
uint8_t m_ft;
uint8_t s_ft;
uint8_t c_interval[3];
uint8_t p_interval[3];
uint8_t c_ft;
uint8_t p_ft;
uint16_t iso_interval;
uint8_t sca;
uint8_t packing;
@ -2931,8 +2931,8 @@ struct bt_hci_evt_change_conn_link_key_complete {
uint16_t handle;
} __attribute__ ((packed));
#define BT_HCI_EVT_MASTER_LINK_KEY_COMPLETE 0x0a
struct bt_hci_evt_master_link_key_complete {
#define BT_HCI_EVT_LINK_KEY_TYPE_CHANGED 0x0a
struct bt_hci_evt_link_key_type_changed {
uint8_t status;
uint16_t handle;
uint8_t key_flag;
@ -3325,8 +3325,8 @@ struct bt_hci_evt_sync_train_received {
uint8_t service_data;
} __attribute__ ((packed));
#define BT_HCI_EVT_SLAVE_BROADCAST_RECEIVE 0x51
struct bt_hci_evt_slave_broadcast_receive {
#define BT_HCI_EVT_PERIPHERAL_BROADCAST_RECEIVE 0x51
struct bt_hci_evt_peripheral_broadcast_receive {
uint8_t bdaddr[6];
uint8_t lt_addr;
uint32_t clock;
@ -3336,8 +3336,8 @@ struct bt_hci_evt_slave_broadcast_receive {
uint8_t length;
} __attribute__ ((packed));
#define BT_HCI_EVT_SLAVE_BROADCAST_TIMEOUT 0x52
struct bt_hci_evt_slave_broadcast_timeout {
#define BT_HCI_EVT_PERIPHERAL_BROADCAST_TIMEOUT 0x52
struct bt_hci_evt_peripheral_broadcast_timeout {
uint8_t bdaddr[6];
uint8_t lt_addr;
} __attribute__ ((packed));
@ -3348,10 +3348,10 @@ struct bt_hci_evt_truncated_page_complete {
uint8_t bdaddr[6];
} __attribute__ ((packed));
#define BT_HCI_EVT_SLAVE_PAGE_RESPONSE_TIMEOUT 0x54
#define BT_HCI_EVT_PERIPHERAL_PAGE_RESPONSE_TIMEOUT 0x54
#define BT_HCI_EVT_SLAVE_BROADCAST_CHANNEL_MAP_CHANGE 0x55
struct bt_hci_evt_slave_broadcast_channel_map_change {
#define BT_HCI_EVT_PERIPHERAL_BROADCAST_CHANNEL_MAP_CHANGE 0x55
struct bt_hci_evt_channel_map_change {
uint8_t map[10];
} __attribute__ ((packed));
@ -3571,17 +3571,17 @@ struct bt_hci_evt_le_cis_established {
uint16_t conn_handle;
uint8_t cig_sync_delay[3];
uint8_t cis_sync_delay[3];
uint8_t m_latency[3];
uint8_t s_latency[3];
uint8_t m_phy;
uint8_t s_phy;
uint8_t c_latency[3];
uint8_t p_latency[3];
uint8_t c_phy;
uint8_t p_phy;
uint8_t nse;
uint8_t m_bn;
uint8_t s_bn;
uint8_t m_ft;
uint8_t s_ft;
uint16_t m_mtu;
uint16_t s_mtu;
uint8_t c_bn;
uint8_t p_bn;
uint8_t c_ft;
uint8_t p_ft;
uint16_t c_mtu;
uint16_t p_mtu;
uint16_t interval;
} __attribute__ ((packed));
@ -4026,8 +4026,8 @@ struct bt_l2cap_smp_encrypt_info {
uint8_t ltk[16];
} __attribute__ ((packed));
#define BT_L2CAP_SMP_MASTER_IDENT 0x07
struct bt_l2cap_smp_master_ident {
#define BT_L2CAP_SMP_CENTRAL_IDENT 0x07
struct bt_l2cap_smp_central_ident {
uint16_t ediv;
uint64_t rand;
} __attribute__ ((packed));

10
monitor/control.c
View File

@ -305,19 +305,19 @@ static void mgmt_new_long_term_key(uint16_t len, const void *buf)
return;
}
/* LE SC keys are both for master and slave */
/* LE SC keys are both for central and peripheral */
switch (ev->key.type) {
case 0x00:
if (ev->key.central)
type = "Master (Unauthenticated)";
type = "Central (Unauthenticated)";
else
type = "Slave (Unauthenticated)";
type = "Peripheral (Unauthenticated)";
break;
case 0x01:
if (ev->key.central)
type = "Master (Authenticated)";
type = "Central (Authenticated)";
else
type = "Slave (Authenticated)";
type = "Peripheral (Authenticated)";
break;
case 0x02:
type = "SC (Unauthenticated)";

10
monitor/l2cap.c
View File

@ -1280,7 +1280,7 @@ static void sig_conn_param_req(const struct l2cap_frame *frame)
print_field("Min interval: %d", le16_to_cpu(pdu->min_interval));
print_field("Max interval: %d", le16_to_cpu(pdu->max_interval));
print_field("Slave latency: %d", le16_to_cpu(pdu->latency));
print_field("Peripheral latency: %d", le16_to_cpu(pdu->latency));
print_field("Timeout multiplier: %d", le16_to_cpu(pdu->timeout));
}
@ -2960,9 +2960,9 @@ static void smp_encrypt_info(const struct l2cap_frame *frame)
print_hex_field("Long term key", pdu->ltk, 16);
}
static void smp_master_ident(const struct l2cap_frame *frame)
static void smp_central_ident(const struct l2cap_frame *frame)
{
const struct bt_l2cap_smp_master_ident *pdu = frame->data;
const struct bt_l2cap_smp_central_ident *pdu = frame->data;
print_field("EDIV: 0x%4.4x", le16_to_cpu(pdu->ediv));
print_field("Rand: 0x%16.16" PRIx64, le64_to_cpu(pdu->rand));
@ -3065,8 +3065,8 @@ static const struct smp_opcode_data smp_opcode_table[] = {
smp_pairing_failed, 1, true },
{ 0x06, "Encryption Information",
smp_encrypt_info, 16, true },
{ 0x07, "Master Identification",
smp_master_ident, 10, true },
{ 0x07, "Central Identification",
smp_central_ident, 10, true },
{ 0x08, "Identity Information",
smp_ident_info, 16, true },
{ 0x09, "Identity Address Information",

60
monitor/ll.c
View File

@ -186,7 +186,7 @@ static void advertising_packet(const void *data, uint8_t size)
print_field("Transmit window size: %u", win_size);
print_field("Transmit window offset: %u", win_offset);
print_field("Connection interval: %u", interval);
print_field("Connection slave latency: %u", latency);
print_field("Connection peripheral latency: %u", latency);
print_field("Connection supervision timeout: %u", timeout);
packet_print_channel_map_ll(ptr + 30);
@ -371,8 +371,10 @@ static void conn_update_req(const void *data, uint8_t size)
print_field("Transmit window size: %u", pdu->win_size);
print_field("Transmit window offset: %u", le16_to_cpu(pdu->win_offset));
print_field("Connection interval: %u", le16_to_cpu(pdu->interval));
print_field("Connection slave latency: %u", le16_to_cpu(pdu->latency));
print_field("Connection supervision timeout: %u", le16_to_cpu(pdu->timeout));
print_field("Connection peripheral latency: %u",
le16_to_cpu(pdu->latency));
print_field("Connection supervision timeout: %u",
le16_to_cpu(pdu->timeout));
print_field("Connection instant: %u", le16_to_cpu(pdu->instant));
}
@ -397,16 +399,16 @@ static void enc_req(const void *data, uint8_t size)
print_field("Rand: 0x%16.16" PRIx64, le64_to_cpu(pdu->rand));
print_field("EDIV: 0x%4.4x", le16_to_cpu(pdu->ediv));
print_field("SKD (master): 0x%16.16" PRIx64, le64_to_cpu(pdu->skd));
print_field("IV (master): 0x%8.8x", le32_to_cpu(pdu->iv));
print_field("SKD (central): 0x%16.16" PRIx64, le64_to_cpu(pdu->skd));
print_field("IV (central): 0x%8.8x", le32_to_cpu(pdu->iv));
}
static void enc_rsp(const void *data, uint8_t size)
{
const struct bt_ll_enc_rsp *pdu = data;
print_field("SKD (slave): 0x%16.16" PRIx64, le64_to_cpu(pdu->skd));
print_field("IV (slave): 0x%8.8x", le32_to_cpu(pdu->iv));
print_field("SKD (peripheral): 0x%16.16" PRIx64, le64_to_cpu(pdu->skd));
print_field("IV (peripheral): 0x%8.8x", le32_to_cpu(pdu->iv));
}
static const char *opcode_to_string(uint8_t opcode);
@ -449,9 +451,9 @@ static void reject_ind(const void *data, uint8_t size)
packet_print_error("Error code", pdu->error);
}
static void slave_feature_req(const void *data, uint8_t size)
static void peripheral_feature_req(const void *data, uint8_t size)
{
const struct bt_ll_slave_feature_req *pdu = data;
const struct bt_ll_peripheral_feature_req *pdu = data;
packet_print_features_ll(pdu->features);
}
@ -505,16 +507,16 @@ static void phy_update_ind(const void *data, uint8_t size)
const struct bt_ll_phy_update_ind *pdu = data;
uint8_t mask;
print_field("M_TO_S_PHY: 0x%2.2x", pdu->m_phy);
print_field("C_TO_P_PHY: 0x%2.2x", pdu->c_phy);
mask = print_bitfield(2, pdu->m_phy, le_phys);
mask = print_bitfield(2, pdu->c_phy, le_phys);
if (mask)
print_text(COLOR_UNKNOWN_OPTIONS_BIT, " Reserved"
" (0x%2.2x)", mask);
print_field("S_TO_M_PHY: 0x%2.2x", pdu->s_phy);
print_field("P_TO_C_PHY: 0x%2.2x", pdu->p_phy);
mask = print_bitfield(2, pdu->s_phy, le_phys);
mask = print_bitfield(2, pdu->p_phy, le_phys);
if (mask)
print_text(COLOR_UNKNOWN_OPTIONS_BIT, " Reserved"
" (0x%2.2x)", mask);
@ -596,38 +598,40 @@ static void cis_req(const void *data, uint8_t size)
print_field("CIG ID: 0x%2.2x", cmd->cig);
print_field("CIS ID: 0x%2.2x", cmd->cis);
print_field("Master to Slave PHY: 0x%2.2x", cmd->m_phy);
print_field("Central to Peripheral PHY: 0x%2.2x", cmd->c_phy);
mask = print_bitfield(2, cmd->m_phy, le_phys);
mask = print_bitfield(2, cmd->c_phy, le_phys);
if (mask)
print_text(COLOR_UNKNOWN_OPTIONS_BIT, " Reserved"
" (0x%2.2x)", mask);
print_field("Slave To Master PHY: 0x%2.2x", cmd->s_phy);
print_field("Peripheral To Central PHY: 0x%2.2x", cmd->p_phy);
mask = print_bitfield(2, cmd->s_phy, le_phys);
mask = print_bitfield(2, cmd->p_phy, le_phys);
if (mask)
print_text(COLOR_UNKNOWN_OPTIONS_BIT, " Reserved"
" (0x%2.2x)", mask);
print_field("Master to Slave Maximum SDU: %u", cmd->m_sdu);
print_field("Slave to Master Maximum SDU: %u", cmd->s_sdu);
print_field("Central to Peripheral Maximum SDU: %u", cmd->c_sdu);
print_field("Peripheral to Central Maximum SDU: %u", cmd->p_sdu);
memcpy(&interval, cmd->m_interval, sizeof(cmd->m_interval));
print_field("Master to Slave Interval: 0x%6.6x", le32_to_cpu(interval));
memcpy(&interval, cmd->s_interval, sizeof(cmd->s_interval));
print_field("Slave to Master Interval: 0x%6.6x", le32_to_cpu(interval));
memcpy(&interval, cmd->c_interval, sizeof(cmd->c_interval));
print_field("Central to Peripheral Interval: 0x%6.6x",
le32_to_cpu(interval));
memcpy(&interval, cmd->p_interval, sizeof(cmd->p_interval));
print_field("Peripheral to Central Interval: 0x%6.6x",
le32_to_cpu(interval));
print_field("Master to Slave Maximum PDU: %u", cmd->m_pdu);
print_field("Slave to Master Maximum PDU: %u", cmd->s_pdu);
print_field("Central to Peripheral Maximum PDU: %u", cmd->c_pdu);
print_field("Peripheral to Central Maximum PDU: %u", cmd->p_pdu);
print_field("Burst Number: %u us", cmd->bn);
memcpy(&interval, cmd->sub_interval, sizeof(cmd->sub_interval));
print_field("Sub-Interval: 0x%6.6x", le32_to_cpu(interval));
print_field("Master to Slave Flush Timeout: %u", cmd->m_ft);
print_field("Slave to Master Flush Timeout: %u", cmd->s_ft);
print_field("Central to Peripheral Flush Timeout: %u", cmd->c_ft);
print_field("Peripheral to Central Flush Timeout: %u", cmd->p_ft);
print_field("ISO Interval: 0x%4.4x", le16_to_cpu(cmd->iso_interval));
@ -702,7 +706,7 @@ static const struct llcp_data llcp_table[] = {
{ 0x0b, "LL_PAUSE_ENC_RSP", null_pdu, 0, true },
{ 0x0c, "LL_VERSION_IND", version_ind, 5, true },
{ 0x0d, "LL_REJECT_IND", reject_ind, 1, true },
{ 0x0e, "LL_SLAVE_FEATURE_REQ", slave_feature_req, 8, true },
{ 0x0e, "LL_PERIPHERAL_FEATURE_REQ", peripheral_feature_req, 8, true },
{ 0x0f, "LL_CONNECTION_PARAM_REQ", NULL, 23, true },
{ 0x10, "LL_CONNECTION_PARAM_RSP", NULL, 23, true },
{ 0x11, "LL_REJECT_IND_EXT", reject_ind_ext, 2, true },

2
monitor/lmp.c
View File

@ -839,7 +839,7 @@ void lmp_packet(const void *data, uint8_t size, bool padded)
tid = ((const uint8_t *) data)[0] & 0x01;
opcode = (((const uint8_t *) data)[0] & 0xfe) >> 1;
tid_str = tid == 0x00 ? "Master" : "Slave";
tid_str = tid == 0x00 ? "Central" : "Peripheral";
switch (opcode) {
case 127:

411
monitor/packet.c
View File

@ -2171,16 +2171,16 @@ static void print_adv_filter_policy(const char *label, uint8_t value)
"Allow Connect Request from Any";
break;
case 0x01:
str = "Allow Scan Request from White List Only, "
str = "Allow Scan Request from Accept List Only, "
"Allow Connect Request from Any";
break;
case 0x02:
str = "Allow Scan Request from Any, "
"Allow Connect Request from White List Only";
"Allow Connect Request from Accept List Only";
break;
case 0x03:
str = "Allow Scan Request from White List Only, "
"Allow Connect Request from White List Only";
str = "Allow Scan Request from Accept List Only, "
"Allow Connect Request from Accept List Only";
break;
default:
str = "Reserved";
@ -2234,10 +2234,10 @@ static void print_role(uint8_t role)
switch (role) {
case 0x00:
str = "Master";
str = "Central";
break;
case 0x01:
str = "Slave";
str = "Peripheral";
break;
default:
str = "Reserved";
@ -2556,16 +2556,16 @@ static const struct bitfield_data features_page0[] = {
{ 31, "Extended SCO link (EV3 packets)" },
{ 32, "EV4 packets" },
{ 33, "EV5 packets" },
{ 35, "AFH capable slave" },
{ 36, "AFH classification slave" },
{ 35, "AFH capable peripheral" },
{ 36, "AFH classification peripheral" },
{ 37, "BR/EDR Not Supported" },
{ 38, "LE Supported (Controller)" },
{ 39, "3-slot Enhanced Data Rate ACL packets" },
{ 40, "5-slot Enhanced Data Rate ACL packets" },
{ 41, "Sniff subrating" },
{ 42, "Pause encryption" },
{ 43, "AFH capable master" },
{ 44, "AFH classification master" },
{ 43, "AFH capable central" },
{ 44, "AFH classification central" },
{ 45, "Enhanced Data Rate eSCO 2 Mbps mode" },
{ 46, "Enhanced Data Rate eSCO 3 Mbps mode" },
{ 47, "3-slot Enhanced Data Rate eSCO packets" },
@ -2591,17 +2591,17 @@ static const struct bitfield_data features_page1[] = {
};
static const struct bitfield_data features_page2[] = {
{ 0, "Connectionless Slave Broadcast - Master" },
{ 1, "Connectionless Slave Broadcast - Slave" },
{ 2, "Synchronization Train" },
{ 3, "Synchronization Scan" },
{ 4, "Inquiry Response Notification Event" },
{ 5, "Generalized interlaced scan" },
{ 6, "Coarse Clock Adjustment" },
{ 8, "Secure Connections (Controller Support)" },
{ 9, "Ping" },
{ 10, "Slot Availability Mask" },
{ 11, "Train nudging" },
{ 0, "Connectionless Peripheral Broadcast - Central" },
{ 1, "Connectionless Peripheral Broadcast - Peripheral"},
{ 2, "Synchronization Train" },
{ 3, "Synchronization Scan" },
{ 4, "Inquiry Response Notification Event" },
{ 5, "Generalized interlaced scan" },
{ 6, "Coarse Clock Adjustment" },
{ 8, "Secure Connections (Controller Support)" },
{ 9, "Ping" },
{ 10, "Slot Availability Mask" },
{ 11, "Train nudging" },
{ }
};
@ -2609,7 +2609,7 @@ static const struct bitfield_data features_le[] = {
{ 0, "LE Encryption" },
{ 1, "Connection Parameter Request Procedure" },
{ 2, "Extended Reject Indication" },
{ 3, "Slave-initiated Features Exchange" },
{ 3, "Peripheral-initiated Features Exchange" },
{ 4, "LE Ping" },
{ 5, "LE Data Packet Length Extension" },
{ 6, "LL Privacy" },
@ -2634,8 +2634,8 @@ static const struct bitfield_data features_le[] = {
{ 25, "Periodic Advertising Sync Transfer - Recipient" },
{ 26, "Sleep Clock Accuracy Updates" },
{ 27, "Remote Public Key Validation" },
{ 28, "Connected Isochronous Stream - Master" },
{ 29, "Connected Isochronous Stream - Slave" },
{ 28, "Connected Isochronous Stream - Central" },
{ 29, "Connected Isochronous Stream - Peripheral" },
{ 30, "Isochronous Broadcaster" },
{ 31, "Synchronized Receiver" },
{ 32, "Isochronous Channels (Host Support)" },
@ -2729,11 +2729,11 @@ void packet_print_features_msft(const uint8_t *features)
#define LE_STATE_ACTIVE_SCAN 0x0020
#define LE_STATE_PASSIVE_SCAN 0x0040
#define LE_STATE_INITIATING 0x0080
#define LE_STATE_CONN_MASTER 0x0100
#define LE_STATE_CONN_SLAVE 0x0200
#define LE_STATE_MASTER_MASTER 0x0400
#define LE_STATE_SLAVE_SLAVE 0x0800
#define LE_STATE_MASTER_SLAVE 0x1000
#define LE_STATE_CONN_CENTRAL 0x0100
#define LE_STATE_CONN_PERIPHERAL 0x0200
#define LE_STATE_CENTRAL_CENTRAL 0x0400
#define LE_STATE_PERIPHERAL_PERIPHERAL 0x0800
#define LE_STATE_CENTRAL_PERIPHERAL 0x1000
static const struct bitfield_data le_states_desc_table[] = {
{ 0, "Scannable Advertising State" },
@ -2744,11 +2744,11 @@ static const struct bitfield_data le_states_desc_table[] = {
{ 5, "Active Scanning State" },
{ 6, "Passive Scanning State" },
{ 7, "Initiating State" },
{ 8, "Connection State (Master Role)" },
{ 9, "Connection State (Slave Role)" },
{ 10, "Master Role & Master Role" },
{ 11, "Slave Role & Slave Role" },
{ 12, "Master Role & Slave Role" },
{ 8, "Connection State (Central Role)" },
{ 9, "Connection State (Peripheral Role)" },
{ 10, "Central Role & Central Role" },
{ 11, "Peripheral Role & Peripheral Role" },
{ 12, "Central Role & Peripheral Role" },
{ }
};
@ -2756,59 +2756,59 @@ static const struct {
uint8_t bit;
uint16_t states;
} le_states_comb_table[] = {
{ 0, LE_STATE_NONCONN_ADV },
{ 1, LE_STATE_SCAN_ADV },
{ 2, LE_STATE_CONN_ADV },
{ 3, LE_STATE_HIGH_DIRECT_ADV },
{ 4, LE_STATE_PASSIVE_SCAN },
{ 5, LE_STATE_ACTIVE_SCAN },
{ 6, LE_STATE_INITIATING | LE_STATE_CONN_MASTER },
{ 7, LE_STATE_CONN_SLAVE },
{ 8, LE_STATE_PASSIVE_SCAN | LE_STATE_NONCONN_ADV },
{ 9, LE_STATE_PASSIVE_SCAN | LE_STATE_SCAN_ADV },
{ 10, LE_STATE_PASSIVE_SCAN | LE_STATE_CONN_ADV },
{ 11, LE_STATE_PASSIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV },
{ 12, LE_STATE_ACTIVE_SCAN | LE_STATE_NONCONN_ADV },
{ 13, LE_STATE_ACTIVE_SCAN | LE_STATE_SCAN_ADV },
{ 14, LE_STATE_ACTIVE_SCAN | LE_STATE_CONN_ADV },
{ 15, LE_STATE_ACTIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV },
{ 16, LE_STATE_INITIATING | LE_STATE_NONCONN_ADV },
{ 17, LE_STATE_INITIATING | LE_STATE_SCAN_ADV },
{ 18, LE_STATE_CONN_MASTER | LE_STATE_NONCONN_ADV },
{ 19, LE_STATE_CONN_MASTER | LE_STATE_SCAN_ADV },
{ 20, LE_STATE_CONN_SLAVE | LE_STATE_NONCONN_ADV },
{ 21, LE_STATE_CONN_SLAVE | LE_STATE_SCAN_ADV },
{ 22, LE_STATE_INITIATING | LE_STATE_PASSIVE_SCAN },
{ 23, LE_STATE_INITIATING | LE_STATE_ACTIVE_SCAN },
{ 24, LE_STATE_CONN_MASTER | LE_STATE_PASSIVE_SCAN },
{ 25, LE_STATE_CONN_MASTER | LE_STATE_ACTIVE_SCAN },
{ 26, LE_STATE_CONN_SLAVE | LE_STATE_PASSIVE_SCAN },
{ 27, LE_STATE_CONN_SLAVE | LE_STATE_ACTIVE_SCAN },
{ 28, LE_STATE_INITIATING | LE_STATE_CONN_MASTER |
LE_STATE_MASTER_MASTER },
{ 29, LE_STATE_LOW_DIRECT_ADV },
{ 30, LE_STATE_LOW_DIRECT_ADV | LE_STATE_PASSIVE_SCAN },
{ 31, LE_STATE_LOW_DIRECT_ADV | LE_STATE_ACTIVE_SCAN },
{ 0, LE_STATE_NONCONN_ADV },
{ 1, LE_STATE_SCAN_ADV },
{ 2, LE_STATE_CONN_ADV },
{ 3, LE_STATE_HIGH_DIRECT_ADV },
{ 4, LE_STATE_PASSIVE_SCAN },
{ 5, LE_STATE_ACTIVE_SCAN },
{ 6, LE_STATE_INITIATING | LE_STATE_CONN_CENTRAL },
{ 7, LE_STATE_CONN_PERIPHERAL },
{ 8, LE_STATE_PASSIVE_SCAN | LE_STATE_NONCONN_ADV },
{ 9, LE_STATE_PASSIVE_SCAN | LE_STATE_SCAN_ADV },
{ 10, LE_STATE_PASSIVE_SCAN | LE_STATE_CONN_ADV },
{ 11, LE_STATE_PASSIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV },
{ 12, LE_STATE_ACTIVE_SCAN | LE_STATE_NONCONN_ADV },
{ 13, LE_STATE_ACTIVE_SCAN | LE_STATE_SCAN_ADV },
{ 14, LE_STATE_ACTIVE_SCAN | LE_STATE_CONN_ADV },
{ 15, LE_STATE_ACTIVE_SCAN | LE_STATE_HIGH_DIRECT_ADV },
{ 16, LE_STATE_INITIATING | LE_STATE_NONCONN_ADV },
{ 17, LE_STATE_INITIATING | LE_STATE_SCAN_ADV },
{ 18, LE_STATE_CONN_CENTRAL | LE_STATE_NONCONN_ADV },
{ 19, LE_STATE_CONN_CENTRAL | LE_STATE_SCAN_ADV },
{ 20, LE_STATE_CONN_PERIPHERAL | LE_STATE_NONCONN_ADV },
{ 21, LE_STATE_CONN_PERIPHERAL | LE_STATE_SCAN_ADV },
{ 22, LE_STATE_INITIATING | LE_STATE_PASSIVE_SCAN },
{ 23, LE_STATE_INITIATING | LE_STATE_ACTIVE_SCAN },
{ 24, LE_STATE_CONN_CENTRAL | LE_STATE_PASSIVE_SCAN },
{ 25, LE_STATE_CONN_CENTRAL | LE_STATE_ACTIVE_SCAN },
{ 26, LE_STATE_CONN_PERIPHERAL | LE_STATE_PASSIVE_SCAN },
{ 27, LE_STATE_CONN_PERIPHERAL | LE_STATE_ACTIVE_SCAN },
{ 28, LE_STATE_INITIATING | LE_STATE_CONN_CENTRAL |
LE_STATE_CENTRAL_CENTRAL },
{ 29, LE_STATE_LOW_DIRECT_ADV },
{ 30, LE_STATE_LOW_DIRECT_ADV | LE_STATE_PASSIVE_SCAN },
{ 31, LE_STATE_LOW_DIRECT_ADV | LE_STATE_ACTIVE_SCAN },
{ 32, LE_STATE_INITIATING | LE_STATE_CONN_ADV |
LE_STATE_MASTER_SLAVE },
LE_STATE_CENTRAL_PERIPHERAL },
{ 33, LE_STATE_INITIATING | LE_STATE_HIGH_DIRECT_ADV |
LE_STATE_MASTER_SLAVE },
LE_STATE_CENTRAL_PERIPHERAL },
{ 34, LE_STATE_INITIATING | LE_STATE_LOW_DIRECT_ADV |
LE_STATE_MASTER_SLAVE },
{ 35, LE_STATE_CONN_MASTER | LE_STATE_CONN_ADV |
LE_STATE_MASTER_SLAVE },
{ 36, LE_STATE_CONN_MASTER | LE_STATE_HIGH_DIRECT_ADV |
LE_STATE_MASTER_SLAVE },
{ 37, LE_STATE_CONN_MASTER | LE_STATE_LOW_DIRECT_ADV |
LE_STATE_MASTER_SLAVE },
{ 38, LE_STATE_CONN_SLAVE | LE_STATE_CONN_ADV |
LE_STATE_MASTER_SLAVE },
{ 39, LE_STATE_CONN_SLAVE | LE_STATE_HIGH_DIRECT_ADV |
LE_STATE_SLAVE_SLAVE },
{ 40, LE_STATE_CONN_SLAVE | LE_STATE_LOW_DIRECT_ADV |
LE_STATE_SLAVE_SLAVE },
{ 41, LE_STATE_INITIATING | LE_STATE_CONN_SLAVE |
LE_STATE_MASTER_SLAVE },
LE_STATE_CENTRAL_PERIPHERAL },
{ 35, LE_STATE_CONN_CENTRAL | LE_STATE_CONN_ADV |
LE_STATE_CENTRAL_PERIPHERAL },
{ 36, LE_STATE_CONN_CENTRAL | LE_STATE_HIGH_DIRECT_ADV |
LE_STATE_CENTRAL_PERIPHERAL },
{ 37, LE_STATE_CONN_CENTRAL | LE_STATE_LOW_DIRECT_ADV |
LE_STATE_CENTRAL_PERIPHERAL },
{ 38, LE_STATE_CONN_PERIPHERAL | LE_STATE_CONN_ADV |
LE_STATE_CENTRAL_PERIPHERAL },
{ 39, LE_STATE_CONN_PERIPHERAL | LE_STATE_HIGH_DIRECT_ADV |
LE_STATE_PERIPHERAL_PERIPHERAL },
{ 40, LE_STATE_CONN_PERIPHERAL | LE_STATE_LOW_DIRECT_ADV |
LE_STATE_PERIPHERAL_PERIPHERAL },
{ 41, LE_STATE_INITIATING | LE_STATE_CONN_PERIPHERAL |
LE_STATE_CENTRAL_PERIPHERAL },
{ }
};
@ -2908,7 +2908,7 @@ static const struct bitfield_data events_table[] = {
{ 6, "Remote Name Request Complete" },
{ 7, "Encryption Change" },
{ 8, "Change Connection Link Key Complete" },
{ 9, "Master Link Key Complete" },
{ 9, "Link Key Type Changed" },
{ 10, "Read Remote Supported Features Complete" },
{ 11, "Read Remote Version Information Complete" },
{ 12, "QoS Setup Complete" },
@ -2989,11 +2989,11 @@ static const struct bitfield_data events_page2_table[] = {
{ 14, "Triggered Clock Capture" },
{ 15, "Synchronization Train Complete" },
{ 16, "Synchronization Train Received" },
{ 17, "Connectionless Slave Broadcast Receive" },
{ 18, "Connectionless Slave Broadcast Timeout" },
{ 17, "Connectionless Peripheral Broadcast Receive" },
{ 18, "Connectionless Peripheral Broadcast Timeout" },
{ 19, "Truncated Page Complete" },
{ 20, "Slave Page Response Timeout" },
{ 21, "Connectionless Slave Broadcast Channel Map Change" },
{ 20, "Peripheral Page Response Timeout" },
{ 21, "Connectionless Peripheral Broadcast Channel Map Change" },
{ 22, "Inquiry Response Notification" },
{ 23, "Authenticated Payload Timeout Expired" },
{ 24, "SAM Status Change" },
@ -3065,7 +3065,7 @@ static void print_fec(uint8_t fec)
#define BT_EIR_DEVICE_ID 0x10
#define BT_EIR_SMP_TK 0x10
#define BT_EIR_SMP_OOB_FLAGS 0x11
#define BT_EIR_SLAVE_CONN_INTERVAL 0x12
#define BT_EIR_PERIPHERAL_CONN_INTERVAL 0x12
#define BT_EIR_SERVICE_UUID16 0x14
#define BT_EIR_SERVICE_UUID128 0x15
#define BT_EIR_SERVICE_DATA 0x16
@ -3675,10 +3675,11 @@ static void print_eir(const uint8_t *eir, uint8_t eir_len, bool le)
print_field("SMP OOB Flags: 0x%2.2x", *data);
break;
case BT_EIR_SLAVE_CONN_INTERVAL:
case BT_EIR_PERIPHERAL_CONN_INTERVAL:
if (data_len < 4)
break;
print_field("Slave Conn. Interval: 0x%4.4x - 0x%4.4x",
print_field("Peripheral Conn. Interval: "
"0x%4.4x - 0x%4.4x",
get_le16(&data[0]),
get_le16(&data[2]));
break;
@ -4147,10 +4148,10 @@ static void create_conn_cmd(const void *data, uint8_t size)
switch (cmd->role_switch) {
case 0x00:
str = "Stay master";
str = "Stay central";
break;
case 0x01:
str = "Allow slave";
str = "Allow peripheral";
break;
default:
str = "Reserved";
@ -4260,9 +4261,9 @@ static void change_conn_link_key_cmd(const void *data, uint8_t size)
print_handle(cmd->handle);
}
static void master_link_key_cmd(const void *data, uint8_t size)
static void link_key_selection_cmd(const void *data, uint8_t size)
{
const struct bt_hci_cmd_master_link_key *cmd = data;
const struct bt_hci_cmd_link_key_selection *cmd = data;
print_key_flag(cmd->key_flag);
}
@ -4554,9 +4555,9 @@ static void truncated_page_cancel_cmd(const void *data, uint8_t size)
print_bdaddr(cmd->bdaddr);
}
static void set_slave_broadcast_cmd(const void *data, uint8_t size)
static void set_peripheral_broadcast_cmd(const void *data, uint8_t size)
{
const struct bt_hci_cmd_set_slave_broadcast *cmd = data;
const struct bt_hci_cmd_set_peripheral_broadcast *cmd = data;
print_field("Enable: 0x%2.2x", cmd->enable);
print_lt_addr(cmd->lt_addr);
@ -4567,18 +4568,18 @@ static void set_slave_broadcast_cmd(const void *data, uint8_t size)
print_slot_625("Supervision timeout", cmd->timeout);
}
static void set_slave_broadcast_rsp(const void *data, uint8_t size)
static void set_peripheral_broadcast_rsp(const void *data, uint8_t size)
{
const struct bt_hci_rsp_set_slave_broadcast *rsp = data;
const struct bt_hci_rsp_set_peripheral_broadcast *rsp = data;
print_status(rsp->status);
print_lt_addr(rsp->lt_addr);
print_interval(rsp->interval);
}
static void set_slave_broadcast_receive_cmd(const void *data, uint8_t size)
static void set_peripheral_broadcast_receive_cmd(const void *data, uint8_t size)
{
const struct bt_hci_cmd_set_slave_broadcast_receive *cmd = data;
const struct bt_hci_cmd_set_peripheral_broadcast_receive *cmd = data;
print_field("Enable: 0x%2.2x", cmd->enable);
print_bdaddr(cmd->bdaddr);
@ -4594,9 +4595,9 @@ static void set_slave_broadcast_receive_cmd(const void *data, uint8_t size)
print_channel_map(cmd->map);
}
static void set_slave_broadcast_receive_rsp(const void *data, uint8_t size)
static void set_peripheral_broadcast_receive_rsp(const void *data, uint8_t size)
{
const struct bt_hci_rsp_set_slave_broadcast_receive *rsp = data;
const struct bt_hci_rsp_set_peripheral_broadcast_receive *rsp = data;
print_status(rsp->status);
print_bdaddr(rsp->bdaddr);
@ -5665,9 +5666,9 @@ static void delete_reserved_lt_addr_rsp(const void *data, uint8_t size)
print_lt_addr(rsp->lt_addr);
}
static void set_slave_broadcast_data_cmd(const void *data, uint8_t size)
static void set_peripheral_broadcast_data_cmd(const void *data, uint8_t size)
{
const struct bt_hci_cmd_set_slave_broadcast_data *cmd = data;
const struct bt_hci_cmd_set_peripheral_broadcast_data *cmd = data;
print_lt_addr(cmd->lt_addr);
print_broadcast_fragment(cmd->fragment);
@ -5680,9 +5681,9 @@ static void set_slave_broadcast_data_cmd(const void *data, uint8_t size)
packet_hexdump(data + 3, size - 3);
}
static void set_slave_broadcast_data_rsp(const void *data, uint8_t size)
static void set_peripheral_broadcast_data_rsp(const void *data, uint8_t size)
{
const struct bt_hci_rsp_set_slave_broadcast_data *rsp = data;
const struct bt_hci_rsp_set_peripheral_broadcast_data *rsp = data;
print_status(rsp->status);
print_lt_addr(rsp->lt_addr);
@ -6541,13 +6542,13 @@ static void print_scan_filter_policy(uint8_t policy)
str = "Accept all advertisement";
break;
case 0x01:
str = "Ignore not in white list";
str = "Ignore not in accept list";
break;
case 0x02:
str = "Accept all advertisement, inc. directed unresolved RPA";
break;
case 0x03:
str = "Ignore not in white list, exc. directed unresolved RPA";
str = "Ignore not in accept list, exc. directed unresolved RPA";
break;
default:
str = "Reserved";
@ -6586,10 +6587,10 @@ static void le_create_conn_cmd(const void *data, uint8_t size)
switch (cmd->filter_policy) {
case 0x00:
str = "White list is not used";
str = "Accept list is not used";
break;
case 0x01:
str = "White list is used";
str = "Accept list is used";
break;
default:
str = "Reserved";
@ -6612,25 +6613,25 @@ static void le_create_conn_cmd(const void *data, uint8_t size)
print_slot_625("Max connection length", cmd->max_length);
}
static void le_read_white_list_size_rsp(const void *data, uint8_t size)
static void le_read_accept_list_size_rsp(const void *data, uint8_t size)
{
const struct bt_hci_rsp_le_read_white_list_size *rsp = data;
const struct bt_hci_rsp_le_read_accept_list_size *rsp = data;
print_status(rsp->status);
print_field("Size: %u", rsp->size);
}
static void le_add_to_white_list_cmd(const void *data, uint8_t size)
static void le_add_to_accept_list_cmd(const void *data, uint8_t size)
{
const struct bt_hci_cmd_le_add_to_white_list *cmd = data;
const struct bt_hci_cmd_le_add_to_accept_list *cmd = data;
print_addr_type("Address type", cmd->addr_type);
print_addr("Address", cmd->addr, cmd->addr_type);
}
static void le_remove_from_white_list_cmd(const void *data, uint8_t size)
static void le_remove_from_accept_list_cmd(const void *data, uint8_t size)
{
const struct bt_hci_cmd_le_remove_from_white_list *cmd = data;
const struct bt_hci_cmd_le_remove_from_accept_list *cmd = data;
print_addr_type("Address type", cmd->addr_type);
print_addr("Address", cmd->addr, cmd->addr_type);
@ -7569,10 +7570,10 @@ static void le_ext_create_conn_cmd(const void *data, uint8_t size)
switch (cmd->filter_policy) {
case 0x00:
str = "White list is not used";
str = "Accept list is not used";
break;
case 0x01:
str = "White list is used";
str = "Accept list is used";
break;
default:
str = "Reserved";
@ -8030,16 +8031,16 @@ static void print_cis_params(const void *data, int i)
const struct bt_hci_cis_params *cis = data;
print_field("CIS ID: 0x%2.2x", cis->cis_id);
print_field("Master to Slave Maximum SDU Size: %u",
le16_to_cpu(cis->m_sdu));
print_field("Slave to Master Maximum SDU Size: %u",
le16_to_cpu(cis->s_sdu));
print_le_phy("Master to Slave PHY", cis->m_phy);
print_le_phy("Slave to Master PHY", cis->s_phy);
print_field("Master to Slave Retransmission attempts: 0x%2.2x",
cis->m_rtn);
print_field("Slave to Master Retransmission attempts: 0x%2.2x",
cis->s_rtn);
print_field("Central to Peripheral Maximum SDU Size: %u",
le16_to_cpu(cis->c_sdu));
print_field("Peripheral to Central Maximum SDU Size: %u",
le16_to_cpu(cis->p_sdu));
print_le_phy("Central to Peripheral PHY", cis->c_phy);
print_le_phy("Peripheral to Central PHY", cis->p_phy);
print_field("Central to Peripheral Retransmission attempts: 0x%2.2x",
cis->c_rtn);
print_field("Peripheral to Central Retransmission attempts: 0x%2.2x",
cis->p_rtn);
}
static void le_set_cig_params_cmd(const void *data, uint8_t size)
@ -8047,15 +8048,17 @@ static void le_set_cig_params_cmd(const void *data, uint8_t size)
const struct bt_hci_cmd_le_set_cig_params *cmd = data;
print_field("CIG ID: 0x%2.2x", cmd->cig_id);
print_usec_interval("Master to Slave SDU Interval", cmd->m_interval);
print_usec_interval("Slave to Master SDU Interval", cmd->s_interval);
print_usec_interval("Central to Peripheral SDU Interval",
cmd->c_interval);
print_usec_interval("Peripheral to Central SDU Interval",
cmd->p_interval);
print_sca(cmd->sca);
print_packing(cmd->packing);
print_framing(cmd->framing);
print_field("Master to Slave Maximum Latency: %d ms (0x%4.4x)",
le16_to_cpu(cmd->m_latency), le16_to_cpu(cmd->m_latency));
print_field("Slave to Master Maximum Latency: %d ms (0x%4.4x)",
le16_to_cpu(cmd->s_latency), le16_to_cpu(cmd->s_latency));
print_field("Central to Peripheral Maximum Latency: %d ms (0x%4.4x)",
le16_to_cpu(cmd->c_latency), le16_to_cpu(cmd->c_latency));
print_field("Peripheral to Central Maximum Latency: %d ms (0x%4.4x)",
le16_to_cpu(cmd->p_latency), le16_to_cpu(cmd->p_latency));
print_field("Number of CIS: %u", cmd->num_cis);
size -= sizeof(*cmd);
@ -8070,18 +8073,18 @@ static void print_cis_params_test(const void *data, int i)
print_field("CIS ID: 0x%2.2x", cis->cis_id);
print_field("NSE: 0x%2.2x", cis->nse);
print_field("Master to Slave Maximum SDU: 0x%4.4x",
le16_to_cpu(cis->m_sdu));
print_field("Slave to Master Maximum SDU: 0x%4.4x",
le16_to_cpu(cis->s_sdu));
print_field("Master to Slave Maximum PDU: 0x%4.4x",
le16_to_cpu(cis->m_pdu));
print_field("Slave to Master Maximum PDU: 0x%4.4x",
le16_to_cpu(cis->s_pdu));
print_le_phy("Master to Slave PHY", cis->m_phy);
print_le_phy("Slave to Master PHY", cis->s_phy);
print_field("Master to Slave Burst Number: 0x%2.2x", cis->m_bn);
print_field("Slave to Master Burst Number: 0x%2.2x", cis->s_bn);
print_field("Central to Peripheral Maximum SDU: 0x%4.4x",
le16_to_cpu(cis->c_sdu));
print_field("Peripheral to Central Maximum SDU: 0x%4.4x",
le16_to_cpu(cis->p_sdu));
print_field("Central to Peripheral Maximum PDU: 0x%4.4x",
le16_to_cpu(cis->c_pdu));
print_field("Peripheral to Central Maximum PDU: 0x%4.4x",
le16_to_cpu(cis->p_pdu));
print_le_phy("Central to Peripheral PHY", cis->c_phy);
print_le_phy("Peripheral to Central PHY", cis->p_phy);
print_field("Central to Peripheral Burst Number: 0x%2.2x", cis->c_bn);
print_field("Peripheral to Central Burst Number: 0x%2.2x", cis->p_bn);
}
static void le_set_cig_params_test_cmd(const void *data, uint8_t size)
@ -8089,10 +8092,12 @@ static void le_set_cig_params_test_cmd(const void *data, uint8_t size)
const struct bt_hci_cmd_le_set_cig_params_test *cmd = data;
print_field("CIG ID: 0x%2.2x", cmd->cig_id);
print_usec_interval("Master to Slave SDU Interval", cmd->m_interval);
print_usec_interval("Slave to Master SDU Interval", cmd->s_interval);
print_field("Master to Slave Flush Timeout: 0x%2.2x", cmd->m_ft);
print_field("Slave to Master Flush Timeout: 0x%2.2x", cmd->s_ft);
print_usec_interval("Central to Peripheral SDU Interval",
cmd->c_interval);
print_usec_interval("Peripheral to Central SDU Interval",
cmd->p_interval);
print_field("Central to Peripheral Flush Timeout: 0x%2.2x", cmd->c_ft);
print_field("Peripheral to Central Flush Timeout: 0x%2.2x", cmd->p_ft);
print_field("ISO Interval: %.2f ms (0x%4.4x)",
le16_to_cpu(cmd->iso_interval) * 1.25,
le16_to_cpu(cmd->iso_interval));
@ -8425,8 +8430,8 @@ static const struct opcode_data opcode_table[] = {
set_conn_encrypt_cmd, 3, true },
{ 0x0415, 17, "Change Connection Link Key",
change_conn_link_key_cmd, 2, true },
{ 0x0417, 18, "Master Link Key",
master_link_key_cmd, 1, true },
{ 0x0417, 18, "Temporary Link Key",
link_key_selection_cmd, 1, true },
{ 0x0419, 19, "Remote Name Request",
remote_name_request_cmd, 10, true },
{ 0x041a, 20, "Remote Name Request Cancel",
@ -8499,12 +8504,12 @@ static const struct opcode_data opcode_table[] = {
{ 0x0440, 247, "Truncated Page Cancel",
truncated_page_cancel_cmd, 6, true,
status_bdaddr_rsp, 7, true },
{ 0x0441, 248, "Set Connectionless Slave Broadcast",
set_slave_broadcast_cmd, 11, true,
set_slave_broadcast_rsp, 4, true },
{ 0x0442, 249, "Set Connectionless Slave Broadcast Receive",
set_slave_broadcast_receive_cmd, 34, true,
set_slave_broadcast_receive_rsp, 8, true },
{ 0x0441, 248, "Set Connectionless Peripheral Broadcast",
set_peripheral_broadcast_cmd, 11, true,
set_peripheral_broadcast_rsp, 4, true },
{ 0x0442, 249, "Set Connectionless Peripheral Broadcast Receive",
set_peripheral_broadcast_receive_cmd, 34, true,
set_peripheral_broadcast_receive_rsp, 8, true },
{ 0x0443, 250, "Start Synchronization Train",
null_cmd, 0, true },
{ 0x0444, 251, "Receive Synchronization Train",
@ -8805,9 +8810,9 @@ static const struct opcode_data opcode_table[] = {
{ 0x0c75, 253, "Delete Reserved LT_ADDR",
delete_reserved_lt_addr_cmd, 1, true,
delete_reserved_lt_addr_rsp, 2, true },
{ 0x0c76, 254, "Set Connectionless Slave Broadcast Data",
set_slave_broadcast_data_cmd, 3, false,
set_slave_broadcast_data_rsp, 2, true },
{ 0x0c76, 254, "Set Connectionless Peripheral Broadcast Data",
set_peripheral_broadcast_data_cmd, 3, false,
set_peripheral_broadcast_data_rsp, 2, true },
{ 0x0c77, 255, "Read Synchronization Train Parameters",
null_cmd, 0, true,
read_sync_train_params_rsp, 8, true },
@ -8995,17 +9000,17 @@ static const struct opcode_data opcode_table[] = {
{ 0x200e, 213, "LE Create Connection Cancel",
null_cmd, 0, true,
status_rsp, 1, true },
{ 0x200f, 214, "LE Read White List Size",
{ 0x200f, 214, "LE Read Accept List Size",
null_cmd, 0, true,
le_read_white_list_size_rsp, 2, true },
{ 0x2010, 215, "LE Clear White List",
le_read_accept_list_size_rsp, 2, true },
{ 0x2010, 215, "LE Clear Accept List",
null_cmd, 0, true,
status_rsp, 1, true },
{ 0x2011, 216, "LE Add Device To White List",
le_add_to_white_list_cmd, 7, true,
{ 0x2011, 216, "LE Add Device To Accept List",
le_add_to_accept_list_cmd, 7, true,
status_rsp, 1, true },
{ 0x2012, 217, "LE Remove Device From White List",
le_remove_from_white_list_cmd, 7, true,
{ 0x2012, 217, "LE Remove Device From Accept List",
le_remove_from_accept_list_cmd, 7, true,
status_rsp, 1, true },
{ 0x2013, 218, "LE Connection Update",
le_conn_update_cmd, 14, true },
@ -9502,9 +9507,9 @@ static void change_conn_link_key_complete_evt(const void *data, uint8_t size)
print_handle(evt->handle);
}
static void master_link_key_complete_evt(const void *data, uint8_t size)
static void link_key_type_changed_evt(const void *data, uint8_t size)
{
const struct bt_hci_evt_master_link_key_complete *evt = data;
const struct bt_hci_evt_link_key_type_changed *evt = data;
print_status(evt->status);
print_handle(evt->handle);
@ -10209,9 +10214,9 @@ static void sync_train_received_evt(const void *data, uint8_t size)
print_field("Service Data: 0x%2.2x", evt->service_data);
}
static void slave_broadcast_receive_evt(const void *data, uint8_t size)
static void peripheral_broadcast_receive_evt(const void *data, uint8_t size)
{
const struct bt_hci_evt_slave_broadcast_receive *evt = data;
const struct bt_hci_evt_peripheral_broadcast_receive *evt = data;
print_bdaddr(evt->bdaddr);
print_lt_addr(evt->lt_addr);
@ -10231,9 +10236,9 @@ static void slave_broadcast_receive_evt(const void *data, uint8_t size)
packet_hexdump(data + 18, size - 18);
}
static void slave_broadcast_timeout_evt(const void *data, uint8_t size)
static void peripheral_broadcast_timeout_evt(const void *data, uint8_t size)
{
const struct bt_hci_evt_slave_broadcast_timeout *evt = data;
const struct bt_hci_evt_peripheral_broadcast_timeout *evt = data;
print_bdaddr(evt->bdaddr);
print_lt_addr(evt->lt_addr);
@ -10247,13 +10252,13 @@ static void truncated_page_complete_evt(const void *data, uint8_t size)
print_bdaddr(evt->bdaddr);
}
static void slave_page_response_timeout_evt(const void *data, uint8_t size)
static void peripheral_page_response_timeout_evt(const void *data, uint8_t size)
{
}
static void slave_broadcast_channel_map_change_evt(const void *data, uint8_t size)
static void channel_map_change_evt(const void *data, uint8_t size)
{
const struct bt_hci_evt_slave_broadcast_channel_map_change *evt = data;
const struct bt_hci_evt_channel_map_change *evt = data;
print_channel_map(evt->map);
}
@ -10287,7 +10292,7 @@ static void le_conn_complete_evt(const void *data, uint8_t size)
print_field("Supervision timeout: %d msec (0x%4.4x)",
le16_to_cpu(evt->supv_timeout) * 10,
le16_to_cpu(evt->supv_timeout));
print_field("Master clock accuracy: 0x%2.2x", evt->clock_accuracy);
print_field("Central clock accuracy: 0x%2.2x", evt->clock_accuracy);
if (evt->status == 0x00)
assign_handle(le16_to_cpu(evt->handle), 0x01);
@ -10408,7 +10413,7 @@ static void le_enhanced_conn_complete_evt(const void *data, uint8_t size)
print_field("Supervision timeout: %d msec (0x%4.4x)",
le16_to_cpu(evt->supv_timeout) * 10,
le16_to_cpu(evt->supv_timeout));
print_field("Master clock accuracy: 0x%2.2x", evt->clock_accuracy);
print_field("Central clock accuracy: 0x%2.2x", evt->clock_accuracy);
if (evt->status == 0x00)
assign_handle(le16_to_cpu(evt->handle), 0x01);
@ -10784,17 +10789,17 @@ static void le_cis_established_evt(const void *data, uint8_t size)
print_field("Connection Handle: %d", le16_to_cpu(evt->conn_handle));
print_usec_interval("CIG Synchronization Delay", evt->cig_sync_delay);
print_usec_interval("CIS Synchronization Delay", evt->cis_sync_delay);
print_usec_interval("Master to Slave Latency", evt->m_latency);
print_usec_interval("Slave to Master Latency", evt->s_latency);
print_le_phy("Master to Slave PHY", evt->m_phy);
print_le_phy("Slave to Master PHY", evt->s_phy);
print_usec_interval("Central to Peripheral Latency", evt->c_latency);
print_usec_interval("Peripheral to Central Latency", evt->p_latency);
print_le_phy("Central to Peripheral PHY", evt->c_phy);
print_le_phy("Peripheral to Central PHY", evt->p_phy);
print_field("Number of Subevents: %u", evt->nse);
print_field("Master to Slave Burst Number: %u", evt->m_bn);
print_field("Slave to Master Burst Number: %u", evt->s_bn);
print_field("Master to Slave Flush Timeout: %u", evt->m_ft);
print_field("Slave to Master Flush Timeout: %u", evt->s_ft);
print_field("Master to Slave MTU: %u", le16_to_cpu(evt->m_mtu));
print_field("Slave to Master MTU: %u", le16_to_cpu(evt->s_mtu));
print_field("Central to Peripheral Burst Number: %u", evt->c_bn);
print_field("Peripheral to Central Burst Number: %u", evt->p_bn);
print_field("Central to Peripheral Flush Timeout: %u", evt->c_ft);
print_field("Peripheral to Central Flush Timeout: %u", evt->p_ft);
print_field("Central to Peripheral MTU: %u", le16_to_cpu(evt->c_mtu));
print_field("Peripheral to Central MTU: %u", le16_to_cpu(evt->p_mtu));
print_field("ISO Interval: %u", le16_to_cpu(evt->interval));
}
@ -11082,8 +11087,8 @@ static const struct event_data event_table[] = {
encrypt_change_evt, 4, true },
{ 0x09, "Change Connection Link Key Complete",
change_conn_link_key_complete_evt, 3, true },
{ 0x0a, "Master Link Key Complete",
master_link_key_complete_evt, 4, true },
{ 0x0a, "Link Key Type Changed",
link_key_type_changed_evt, 4, true },
{ 0x0b, "Read Remote Supported Features",
remote_features_complete_evt, 11, true },
{ 0x0c, "Read Remote Version Complete",
@ -11199,16 +11204,16 @@ static const struct event_data event_table[] = {
sync_train_complete_evt, 1, true },
{ 0x50, "Synchronization Train Received",
sync_train_received_evt, 29, true },
{ 0x51, "Connectionless Slave Broadcast Receive",
slave_broadcast_receive_evt, 18, false },
{ 0x52, "Connectionless Slave Broadcast Timeout",
slave_broadcast_timeout_evt, 7, true },
{ 0x51, "Connectionless Peripheral Broadcast Receive",
peripheral_broadcast_receive_evt, 18, false },
{ 0x52, "Connectionless Peripheral Broadcast Timeout",
peripheral_broadcast_timeout_evt, 7, true },
{ 0x53, "Truncated Page Complete",
truncated_page_complete_evt, 7, true },
{ 0x54, "Slave Page Response Timeout",
slave_page_response_timeout_evt, 0, true },
{ 0x55, "Connectionless Slave Broadcast Channel Map Change",
slave_broadcast_channel_map_change_evt, 10, true },
{ 0x54, "Peripheral Page Response Timeout",
peripheral_page_response_timeout_evt, 0, true },
{ 0x55, "Connectionless Peripheral Broadcast Channel Map Change",
channel_map_change_evt, 10, true },
{ 0x56, "Inquiry Response Notification",
inquiry_response_notify_evt, 4, true },
{ 0x57, "Authenticated Payload Timeout Expired",
@ -12171,7 +12176,7 @@ static void mgmt_print_long_term_key(const void *data)
{
uint8_t address_type = get_u8(data + 6);
uint8_t key_type = get_u8(data + 7);
uint8_t master = get_u8(data + 8);
uint8_t central = get_u8(data + 8);
uint8_t enc_size = get_u8(data + 9);
const char *str;
@ -12199,7 +12204,7 @@ static void mgmt_print_long_term_key(const void *data)
}
print_field("Key type: %s (0x%2.2x)", str, key_type);
print_field("Master: 0x%2.2x", master);
print_field("Central: 0x%2.2x", central);
print_field("Encryption size: %u", enc_size);
print_hex_field("Diversifier", data + 10, 2);
print_hex_field("Randomizer", data + 12, 8);

33
tools/3dsp.c
View File

@ -122,7 +122,7 @@ static void sync_train_received(const void *data, uint8_t size,
void *user_data)
{
const struct bt_hci_evt_sync_train_received *evt = data;
struct bt_hci_cmd_set_slave_broadcast_receive cmd;
struct bt_hci_cmd_set_peripheral_broadcast_receive cmd;
if (evt->status) {
printf("Failed to synchronize with 3D display\n");
@ -147,7 +147,7 @@ static void sync_train_received(const void *data, uint8_t size,
cmd.pkt_type = cpu_to_le16(PKT_TYPE);
memcpy(cmd.map, evt->map, 10);
bt_hci_send(hci_dev, BT_HCI_CMD_SET_SLAVE_BROADCAST_RECEIVE,
bt_hci_send(hci_dev, BT_HCI_CMD_SET_PERIPHERAL_BROADCAST_RECEIVE,
&cmd, sizeof(cmd),
set_slave_broadcast_receive, NULL, NULL);
}
@ -156,7 +156,7 @@ static void brcm_sync_train_received(const void *data, uint8_t size,
void *user_data)
{
const struct brcm_evt_sync_train_received *evt = data;
struct bt_hci_cmd_set_slave_broadcast_receive cmd;
struct bt_hci_cmd_set_peripheral_broadcast_receive cmd;
if (evt->status) {
printf("Failed to synchronize with 3D display\n");
@ -181,7 +181,7 @@ static void brcm_sync_train_received(const void *data, uint8_t size,
cmd.pkt_type = cpu_to_le16(PKT_TYPE);
memcpy(cmd.map, evt->map, 10);
bt_hci_send(hci_dev, BT_HCI_CMD_SET_SLAVE_BROADCAST_RECEIVE,
bt_hci_send(hci_dev, BT_HCI_CMD_SET_PERIPHERAL_BROADCAST_RECEIVE,
&cmd, sizeof(cmd),
set_slave_broadcast_receive, NULL, NULL);
}
@ -212,7 +212,7 @@ static void truncated_page_complete(const void *data, uint8_t size,
static void slave_broadcast_timeout(const void *data, uint8_t size,
void *user_data)
{
const struct bt_hci_evt_slave_broadcast_timeout *evt = data;
const struct bt_hci_evt_peripheral_broadcast_timeout *evt = data;
struct bt_hci_cmd_receive_sync_train cmd;
printf("Re-synchronizing with 3D display\n");
@ -229,7 +229,7 @@ static void slave_broadcast_timeout(const void *data, uint8_t size,
static void slave_broadcast_receive(const void *data, uint8_t size,
void *user_data)
{
const struct bt_hci_evt_slave_broadcast_receive *evt = data;
const struct bt_hci_evt_peripheral_broadcast_receive *evt = data;
struct bt_hci_cmd_read_clock cmd;
if (evt->status != 0x00)
@ -326,9 +326,9 @@ static void start_glasses(void)
bt_hci_register(hci_dev, BT_HCI_EVT_TRUNCATED_PAGE_COMPLETE,
truncated_page_complete, NULL, NULL);
bt_hci_register(hci_dev, BT_HCI_EVT_SLAVE_BROADCAST_TIMEOUT,
bt_hci_register(hci_dev, BT_HCI_EVT_PERIPHERAL_BROADCAST_TIMEOUT,
slave_broadcast_timeout, NULL, NULL);
bt_hci_register(hci_dev, BT_HCI_EVT_SLAVE_BROADCAST_RECEIVE,
bt_hci_register(hci_dev, BT_HCI_EVT_PERIPHERAL_BROADCAST_RECEIVE,
slave_broadcast_receive, NULL, NULL);
start_inquiry();
@ -443,13 +443,13 @@ static void read_clock(const void *data, uint8_t size, void *user_data)
msg.frame_sync_period_fraction = 0;
memcpy(bcastdata + 3, &msg, sizeof(msg));
bt_hci_send(hci_dev, BT_HCI_CMD_SET_SLAVE_BROADCAST_DATA,
bt_hci_send(hci_dev, BT_HCI_CMD_SET_PERIPHERAL_BROADCAST_DATA,
bcastdata, sizeof(bcastdata), NULL, NULL, NULL);
}
static void set_slave_broadcast(const void *data, uint8_t size, void *user_data)
{
const struct bt_hci_rsp_set_slave_broadcast *rsp = data;
const struct bt_hci_rsp_set_peripheral_broadcast *rsp = data;
struct bt_hci_cmd_read_clock cmd;
if (rsp->status) {
@ -467,7 +467,7 @@ static void set_slave_broadcast(const void *data, uint8_t size, void *user_data)
static void start_display(void)
{
struct bt_hci_cmd_set_slave_broadcast cmd;
struct bt_hci_cmd_set_peripheral_broadcast cmd;
uint8_t evtmask1[] = { 0x1c, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t evtmask2[] = { 0x00, 0xc0, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t sspmode = 0x01;
@ -492,10 +492,11 @@ static void start_display(void)
bt_hci_register(hci_dev, BT_HCI_EVT_CONN_REQUEST,
conn_request, NULL, NULL);
bt_hci_register(hci_dev, BT_HCI_EVT_SLAVE_PAGE_RESPONSE_TIMEOUT,
bt_hci_register(hci_dev, BT_HCI_EVT_PERIPHERAL_PAGE_RESPONSE_TIMEOUT,
slave_page_response_timeout, NULL, NULL);
bt_hci_register(hci_dev, BT_HCI_EVT_SLAVE_BROADCAST_CHANNEL_MAP_CHANGE,
slave_broadcast_channel_map_change, NULL, NULL);
bt_hci_register(hci_dev,
BT_HCI_EVT_PERIPHERAL_BROADCAST_CHANNEL_MAP_CHANGE,
slave_broadcast_channel_map_change, NULL, NULL);
bt_hci_register(hci_dev, BT_HCI_EVT_SYNC_TRAIN_COMPLETE,
sync_train_complete, NULL, NULL);
@ -510,8 +511,8 @@ static void start_display(void)
cmd.max_interval = cpu_to_le16(0x00a0); /* 100 ms */
cmd.timeout = cpu_to_le16(0xfffe);
bt_hci_send(hci_dev, BT_HCI_CMD_SET_SLAVE_BROADCAST, &cmd, sizeof(cmd),
set_slave_broadcast, NULL, NULL);
bt_hci_send(hci_dev, BT_HCI_CMD_SET_PERIPHERAL_BROADCAST, &cmd,
sizeof(cmd), set_slave_broadcast, NULL, NULL);
}
static void signal_callback(int signum, void *user_data)

4
tools/hci-tester.c
View File

@ -337,12 +337,12 @@ static void test_read_local_supported_codecs(const void *test_data)
static void test_le_read_white_list_size(const void *test_data)
{
test_command(BT_HCI_CMD_LE_READ_WHITE_LIST_SIZE);
test_command(BT_HCI_CMD_LE_READ_ACCEPT_LIST_SIZE);
}
static void test_le_clear_white_list(const void *test_data)
{
test_command(BT_HCI_CMD_LE_CLEAR_WHITE_LIST);
test_command(BT_HCI_CMD_LE_CLEAR_ACCEPT_LIST);
}
static void test_le_encrypt_complete(const void *data, uint8_t size,

4
tools/mgmt-tester.c
View File

@ -4248,7 +4248,7 @@ static const struct generic_data add_device_success_6 = {
.expect_alt_ev = MGMT_EV_DEVICE_ADDED,
.expect_alt_ev_param = add_device_success_param_6,
.expect_alt_ev_len = sizeof(add_device_success_param_6),
.expect_hci_command = BT_HCI_CMD_LE_ADD_TO_WHITE_LIST,
.expect_hci_command = BT_HCI_CMD_LE_ADD_TO_ACCEPT_LIST,
.expect_hci_param = le_add_to_white_list_param,
.expect_hci_len = sizeof(le_add_to_white_list_param),
};
@ -4418,7 +4418,7 @@ static const struct generic_data remove_device_success_7 = {
.expect_param = remove_device_param_2,
.expect_len = sizeof(remove_device_param_2),
.expect_status = MGMT_STATUS_SUCCESS,
.expect_hci_command = BT_HCI_CMD_LE_REMOVE_FROM_WHITE_LIST,
.expect_hci_command = BT_HCI_CMD_LE_REMOVE_FROM_ACCEPT_LIST,
.expect_hci_param = le_add_to_white_list_param,
.expect_hci_len = sizeof(le_add_to_white_list_param),
.expect_alt_ev = MGMT_EV_DEVICE_REMOVED,