monitor: Inclusive language changes

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>
Signed-off-by: Anuj Jain <anuj01.jain@samsung.com>
Signed-off-by: Ayush Garg <ayush.garg@samsung.com>

diff --git a/emulator/btdev.c b/emulator/btdev.c
index 52c2b57..343c065 100755 (executable)
--- a/emulator/btdev.c
+++ b/emulator/btdev.c
@@ -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));

diff --git a/emulator/le.c b/emulator/le.c
index 4ffe3b1..23f2579 100755 (executable)
--- a/emulator/le.c
+++ b/emulator/le.c
@@ -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 },

diff --git a/emulator/smp.c b/emulator/smp.c
index 21a34dd..2a36437 100755 (executable)
--- a/emulator/smp.c
+++ b/emulator/smp.c
@@ -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);

diff --git a/monitor/broadcom.c b/monitor/broadcom.c
index ca56233..ed27fa1 100644 (file)
--- a/monitor/broadcom.c
+++ b/monitor/broadcom.c
@@ -123,10 +123,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";
@@ -142,10 +142,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";

diff --git a/monitor/bt.h b/monitor/bt.h
index c2df919..3e6b4df 100755 (executable)
--- a/monitor/bt.h
+++ b/monitor/bt.h
@@ -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;
@@ -2930,8 +2930,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;
@@ -3324,8 +3324,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;
@@ -3335,8 +3335,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));
@@ -3347,10 +3347,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));
 
@@ -3570,17 +3570,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));
 
@@ -4025,8 +4025,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));

diff --git a/monitor/control.c b/monitor/control.c
index c22d1c3..52c26fd 100755 (executable)
--- a/monitor/control.c
+++ b/monitor/control.c
@@ -304,19 +304,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)";

diff --git a/monitor/l2cap.c b/monitor/l2cap.c
index 5beb9da..97afef7 100755 (executable)
--- a/monitor/l2cap.c
+++ b/monitor/l2cap.c
@@ -1279,7 +1279,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));
 }
 
@@ -2959,9 +2959,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));
@@ -3064,8 +3064,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",

diff --git a/monitor/ll.c b/monitor/ll.c
index b2d9757..8ee253c 100755 (executable)
--- a/monitor/ll.c
+++ b/monitor/ll.c
@@ -185,7 +185,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);
@@ -370,8 +370,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));
 }
 
@@ -396,16 +398,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);
@@ -448,9 +450,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);
 }
@@ -504,16 +506,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);
@@ -595,38 +597,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));
 
@@ -701,7 +705,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 },

diff --git a/monitor/lmp.c b/monitor/lmp.c
index f128828..a3ad4e1 100755 (executable)
--- a/monitor/lmp.c
+++ b/monitor/lmp.c
@@ -838,7 +838,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:

diff --git a/monitor/packet.c b/monitor/packet.c
index e15669f..51fc09a 100755 (executable)
--- a/monitor/packet.c
+++ b/monitor/packet.c
@@ -2170,16 +2170,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";
@@ -2233,10 +2233,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";
@@ -2555,16 +2555,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"  },
@@ -2590,17 +2590,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"                                   },
        { }
 };
 
@@ -2608,7 +2608,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"                                      },
@@ -2633,8 +2633,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)"             },
@@ -2728,11 +2728,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"                     },
@@ -2743,11 +2743,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"                  },
        { }
 };
 
@@ -2755,59 +2755,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     },
        { }
 };
 
@@ -2907,7 +2907,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"                                      },
@@ -2988,11 +2988,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"                                       },
@@ -3064,7 +3064,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
@@ -3674,10 +3674,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;
@@ -4141,10 +4142,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";
@@ -4254,9 +4255,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);
 }
@@ -4548,9 +4549,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);
@@ -4561,18 +4562,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);
@@ -4588,9 +4589,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);
@@ -5659,9 +5660,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);
@@ -5674,9 +5675,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);
@@ -6535,13 +6536,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";
@@ -6580,10 +6581,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";
@@ -6606,25 +6607,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);
@@ -7563,10 +7564,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";
@@ -8024,16 +8025,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)
@@ -8041,15 +8042,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);
@@ -8064,18 +8067,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)
@@ -8083,10 +8086,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));
@@ -8419,8 +8424,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",
@@ -8493,12 +8498,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",
@@ -8799,9 +8804,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 },
@@ -8989,17 +8994,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 },
@@ -9508,9 +9513,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);
@@ -10215,9 +10220,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);
@@ -10237,9 +10242,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);
@@ -10253,13 +10258,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);
 }
@@ -10293,7 +10298,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);
@@ -10414,7 +10419,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);
@@ -10790,17 +10795,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));
 }
 
@@ -11088,8 +11093,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",
@@ -11205,16 +11210,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",
@@ -12167,7 +12172,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;
 
@@ -12195,7 +12200,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);

diff --git a/tools/3dsp.c b/tools/3dsp.c
index 99c1ac8..5227c30 100755 (executable)
--- a/tools/3dsp.c
+++ b/tools/3dsp.c
@@ -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)

diff --git a/tools/hci-tester.c b/tools/hci-tester.c
index 0fb74e6..645d89e 100755 (executable)
--- a/tools/hci-tester.c
+++ b/tools/hci-tester.c
@@ -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,

diff --git a/tools/mgmt-tester.c b/tools/mgmt-tester.c
index f027f03..03e56ac 100755 (executable)
--- a/tools/mgmt-tester.c
+++ b/tools/mgmt-tester.c
@@ -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,