Lines Matching defs:conn
48 struct hci_conn *conn;
71 void hci_connect_le_scan_cleanup(struct hci_conn *conn, u8 status)
74 struct hci_dev *hdev = conn->hdev;
79 bdaddr = &conn->dst;
80 bdaddr_type = conn->dst_type;
94 if (params->conn) {
95 hci_conn_drop(params->conn);
96 hci_conn_put(params->conn);
97 params->conn = NULL;
110 mgmt_connect_failed(hdev, &conn->dst, conn->type,
111 conn->dst_type, status);
141 static void hci_conn_cleanup(struct hci_conn *conn)
143 struct hci_dev *hdev = conn->hdev;
145 if (test_bit(HCI_CONN_PARAM_REMOVAL_PEND, &conn->flags))
146 hci_conn_params_del(conn->hdev, &conn->dst, conn->dst_type);
148 if (test_and_clear_bit(HCI_CONN_FLUSH_KEY, &conn->flags))
149 hci_remove_link_key(hdev, &conn->dst);
151 hci_chan_list_flush(conn);
153 hci_conn_hash_del(hdev, conn);
155 if (HCI_CONN_HANDLE_UNSET(conn->handle))
156 ida_free(&hdev->unset_handle_ida, conn->handle);
158 if (conn->cleanup)
159 conn->cleanup(conn);
161 if (conn->type == SCO_LINK || conn->type == ESCO_LINK) {
162 switch (conn->setting & SCO_AIRMODE_MASK) {
174 debugfs_remove_recursive(conn->debugfs);
176 hci_conn_del_sysfs(conn);
181 int hci_disconnect(struct hci_conn *conn, __u8 reason)
183 BT_DBG("hcon %p", conn);
190 if (conn->type == ACL_LINK && conn->role == HCI_ROLE_MASTER &&
191 (conn->state == BT_CONNECTED || conn->state == BT_CONFIG)) {
192 struct hci_dev *hdev = conn->hdev;
195 clkoff_cp.handle = cpu_to_le16(conn->handle);
200 return hci_abort_conn(conn, reason);
203 static void hci_add_sco(struct hci_conn *conn, __u16 handle)
205 struct hci_dev *hdev = conn->hdev;
208 BT_DBG("hcon %p", conn);
210 conn->state = BT_CONNECT;
211 conn->out = true;
213 conn->attempt++;
216 cp.pkt_type = cpu_to_le16(conn->pkt_type);
221 static bool find_next_esco_param(struct hci_conn *conn,
224 if (!conn->parent)
227 for (; conn->attempt <= size; conn->attempt++) {
228 if (lmp_esco_2m_capable(conn->parent) ||
229 (esco_param[conn->attempt - 1].pkt_type & ESCO_2EV3))
232 conn, conn->attempt);
235 return conn->attempt <= size;
287 struct hci_conn *conn = conn_handle->conn;
294 bt_dev_dbg(hdev, "hcon %p", conn);
296 configure_datapath_sync(hdev, &conn->codec);
298 conn->state = BT_CONNECT;
299 conn->out = true;
301 conn->attempt++;
310 switch (conn->codec.id) {
312 if (!find_next_esco_param(conn, esco_param_msbc,
316 param = &esco_param_msbc[conn->attempt - 1];
331 cp.in_data_path = conn->codec.data_path;
332 cp.out_data_path = conn->codec.data_path;
338 if (!find_next_esco_param(conn, esco_param_msbc,
341 param = &esco_param_msbc[conn->attempt - 1];
356 cp.in_data_path = conn->codec.data_path;
357 cp.out_data_path = conn->codec.data_path;
363 if (conn->parent && lmp_esco_capable(conn->parent)) {
364 if (!find_next_esco_param(conn, esco_param_cvsd,
367 param = &esco_param_cvsd[conn->attempt - 1];
369 if (conn->attempt > ARRAY_SIZE(sco_param_cvsd))
371 param = &sco_param_cvsd[conn->attempt - 1];
387 cp.in_data_path = conn->codec.data_path;
388 cp.out_data_path = conn->codec.data_path;
406 static bool hci_setup_sync_conn(struct hci_conn *conn, __u16 handle)
408 struct hci_dev *hdev = conn->hdev;
412 bt_dev_dbg(hdev, "hcon %p", conn);
414 conn->state = BT_CONNECT;
415 conn->out = true;
417 conn->attempt++;
423 cp.voice_setting = cpu_to_le16(conn->setting);
425 switch (conn->setting & SCO_AIRMODE_MASK) {
427 if (!find_next_esco_param(conn, esco_param_msbc,
430 param = &esco_param_msbc[conn->attempt - 1];
433 if (conn->parent && lmp_esco_capable(conn->parent)) {
434 if (!find_next_esco_param(conn, esco_param_cvsd,
437 param = &esco_param_cvsd[conn->attempt - 1];
439 if (conn->attempt > ARRAY_SIZE(sco_param_cvsd))
441 param = &sco_param_cvsd[conn->attempt - 1];
458 bool hci_setup_sync(struct hci_conn *conn, __u16 handle)
463 if (enhanced_sync_conn_capable(conn->hdev)) {
469 conn_handle->conn = conn;
471 result = hci_cmd_sync_queue(conn->hdev, hci_enhanced_setup_sync,
479 return hci_setup_sync_conn(conn, handle);
482 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
485 struct hci_dev *hdev = conn->hdev;
491 params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
502 cp.handle = cpu_to_le16(conn->handle);
518 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
521 struct hci_dev *hdev = conn->hdev;
524 BT_DBG("hcon %p", conn);
528 cp.handle = cpu_to_le16(conn->handle);
537 void hci_sco_setup(struct hci_conn *conn, __u8 status)
541 link = list_first_entry_or_null(&conn->link_list, struct hci_link, list);
542 if (!link || !link->conn)
545 BT_DBG("hcon %p", conn);
548 if (lmp_esco_capable(conn->hdev))
549 hci_setup_sync(link->conn, conn->handle);
551 hci_add_sco(link->conn, conn->handle);
553 hci_connect_cfm(link->conn, status);
554 hci_conn_del(link->conn);
560 struct hci_conn *conn = container_of(work, struct hci_conn,
562 int refcnt = atomic_read(&conn->refcnt);
564 BT_DBG("hcon %p state %s", conn, state_to_string(conn->state));
570 * l2cap_chan_del for each channel, and inside l2cap_chan_del conn is
572 * conn. For now make sure that ACL is alive if refcnt is higher then 0,
578 hci_abort_conn(conn, hci_proto_disconn_ind(conn));
584 struct hci_conn *conn = container_of(work, struct hci_conn,
586 struct hci_dev *hdev = conn->hdev;
588 BT_DBG("hcon %p mode %d", conn, conn->mode);
590 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
593 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
596 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
598 cp.handle = cpu_to_le16(conn->handle);
605 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
607 cp.handle = cpu_to_le16(conn->handle);
618 struct hci_conn *conn = container_of(work, struct hci_conn,
621 hci_send_cmd(conn->hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
622 &conn->dst);
644 struct hci_conn *conn = container_of(work, struct hci_conn,
646 struct hci_dev *hdev = conn->hdev;
655 if (conn->role == HCI_ROLE_SLAVE) {
659 hci_conn_failed(conn, HCI_ERROR_ADVERTISING_TIMEOUT);
664 hci_abort_conn(conn, HCI_ERROR_REMOTE_USER_TERM);
683 static void bis_list(struct hci_conn *conn, void *data)
688 if (bacmp(&conn->dst, BDADDR_ANY))
691 if (d->big != conn->iso_qos.bcast.big || d->bis == BT_ISO_QOS_BIS_UNSET ||
692 d->bis != conn->iso_qos.bcast.bis)
720 static int hci_le_terminate_big(struct hci_dev *hdev, struct hci_conn *conn)
725 bt_dev_dbg(hdev, "big 0x%2.2x bis 0x%2.2x", conn->iso_qos.bcast.big,
726 conn->iso_qos.bcast.bis);
732 d->big = conn->iso_qos.bcast.big;
733 d->bis = conn->iso_qos.bcast.bis;
734 d->big_term = test_and_clear_bit(HCI_CONN_BIG_CREATED, &conn->flags);
760 static void find_bis(struct hci_conn *conn, void *data)
765 if (d->big != conn->iso_qos.bcast.big)
771 static int hci_le_big_terminate(struct hci_dev *hdev, u8 big, struct hci_conn *conn)
776 bt_dev_dbg(hdev, "big 0x%2.2x sync_handle 0x%4.4x", big, conn->sync_handle);
784 d->sync_handle = conn->sync_handle;
786 if (test_and_clear_bit(HCI_CONN_PA_SYNC, &conn->flags)) {
796 if (test_and_clear_bit(HCI_CONN_BIG_SYNC, &conn->flags)) {
818 static void bis_cleanup(struct hci_conn *conn)
820 struct hci_dev *hdev = conn->hdev;
823 bt_dev_dbg(hdev, "conn %p", conn);
825 if (conn->role == HCI_ROLE_MASTER) {
826 if (!test_and_clear_bit(HCI_CONN_PER_ADV, &conn->flags))
832 bis = hci_conn_hash_lookup_big(hdev, conn->iso_qos.bcast.big);
836 hci_le_terminate_big(hdev, conn);
838 hci_le_big_terminate(hdev, conn->iso_qos.bcast.big,
839 conn);
858 static void find_cis(struct hci_conn *conn, void *data)
863 if (!bacmp(&conn->dst, BDADDR_ANY) || d->cig != conn->iso_qos.ucast.cig)
873 static void cis_cleanup(struct hci_conn *conn)
875 struct hci_dev *hdev = conn->hdev;
878 if (conn->iso_qos.ucast.cig == BT_ISO_QOS_CIG_UNSET)
882 d.cig = conn->iso_qos.ucast.cig;
893 hci_le_remove_cig(hdev, conn->iso_qos.ucast.cig);
905 struct hci_conn *conn;
935 conn = kzalloc(sizeof(*conn), GFP_KERNEL);
936 if (!conn)
939 bacpy(&conn->dst, dst);
940 bacpy(&conn->src, &hdev->bdaddr);
941 conn->handle = handle;
942 conn->hdev = hdev;
943 conn->type = type;
944 conn->role = role;
945 conn->mode = HCI_CM_ACTIVE;
946 conn->state = BT_OPEN;
947 conn->auth_type = HCI_AT_GENERAL_BONDING;
948 conn->io_capability = hdev->io_capability;
949 conn->remote_auth = 0xff;
950 conn->key_type = 0xff;
951 conn->rssi = HCI_RSSI_INVALID;
952 conn->tx_power = HCI_TX_POWER_INVALID;
953 conn->max_tx_power = HCI_TX_POWER_INVALID;
954 conn->sync_handle = HCI_SYNC_HANDLE_INVALID;
956 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
957 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
960 conn->auth_payload_timeout = DEFAULT_AUTH_PAYLOAD_TIMEOUT;
962 if (conn->role == HCI_ROLE_MASTER)
963 conn->out = true;
967 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
968 conn->mtu = hdev->acl_mtu;
971 /* conn->src should reflect the local identity address */
972 hci_copy_identity_address(hdev, &conn->src, &conn->src_type);
973 conn->mtu = hdev->le_mtu ? hdev->le_mtu : hdev->acl_mtu;
976 /* conn->src should reflect the local identity address */
977 hci_copy_identity_address(hdev, &conn->src, &conn->src_type);
981 conn->cleanup = bis_cleanup;
982 else if (conn->role == HCI_ROLE_MASTER)
983 conn->cleanup = cis_cleanup;
985 conn->mtu = hdev->iso_mtu ? hdev->iso_mtu :
990 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
993 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
995 conn->mtu = hdev->sco_mtu;
998 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
999 conn->mtu = hdev->sco_mtu;
1003 skb_queue_head_init(&conn->data_q);
1005 INIT_LIST_HEAD(&conn->chan_list);
1006 INIT_LIST_HEAD(&conn->link_list);
1008 INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
1009 INIT_DELAYED_WORK(&conn->auto_accept_work, hci_conn_auto_accept);
1010 INIT_DELAYED_WORK(&conn->idle_work, hci_conn_idle);
1011 INIT_DELAYED_WORK(&conn->le_conn_timeout, le_conn_timeout);
1013 atomic_set(&conn->refcnt, 0);
1017 hci_conn_hash_add(hdev, conn);
1023 if (conn->type != SCO_LINK && conn->type != ESCO_LINK) {
1028 hci_conn_init_sysfs(conn);
1030 return conn;
1047 static void hci_conn_cleanup_child(struct hci_conn *conn, u8 reason)
1052 /* Due to race, SCO/ISO conn might be not established yet at this point,
1056 switch (conn->type) {
1059 if (HCI_CONN_HANDLE_UNSET(conn->handle))
1060 hci_conn_failed(conn, reason);
1063 if ((conn->state != BT_CONNECTED &&
1064 !test_bit(HCI_CONN_CREATE_CIS, &conn->flags)) ||
1065 test_bit(HCI_CONN_BIG_CREATED, &conn->flags))
1066 hci_conn_failed(conn, reason);
1071 static void hci_conn_unlink(struct hci_conn *conn)
1073 struct hci_dev *hdev = conn->hdev;
1075 bt_dev_dbg(hdev, "hcon %p", conn);
1077 if (!conn->parent) {
1080 list_for_each_entry_safe(link, t, &conn->link_list, list) {
1081 struct hci_conn *child = link->conn;
1093 hci_conn_cleanup_child(child, conn->abort_reason);
1099 if (!conn->link)
1102 list_del_rcu(&conn->link->list);
1105 hci_conn_drop(conn->parent);
1106 hci_conn_put(conn->parent);
1107 conn->parent = NULL;
1109 kfree(conn->link);
1110 conn->link = NULL;
1113 void hci_conn_del(struct hci_conn *conn)
1115 struct hci_dev *hdev = conn->hdev;
1117 BT_DBG("%s hcon %p handle %d", hdev->name, conn, conn->handle);
1119 hci_conn_unlink(conn);
1121 cancel_delayed_work_sync(&conn->disc_work);
1122 cancel_delayed_work_sync(&conn->auto_accept_work);
1123 cancel_delayed_work_sync(&conn->idle_work);
1125 if (conn->type == ACL_LINK) {
1127 hdev->acl_cnt += conn->sent;
1128 } else if (conn->type == LE_LINK) {
1129 cancel_delayed_work(&conn->le_conn_timeout);
1132 hdev->le_cnt += conn->sent;
1134 hdev->acl_cnt += conn->sent;
1137 if (conn->type == ISO_LINK) {
1139 hdev->iso_cnt += conn->sent;
1141 hdev->le_cnt += conn->sent;
1143 hdev->acl_cnt += conn->sent;
1147 skb_queue_purge(&conn->data_q);
1154 hci_conn_cleanup(conn);
1157 hci_cmd_sync_dequeue(hdev, NULL, conn, NULL);
1221 static void hci_le_conn_failed(struct hci_conn *conn, u8 status)
1223 struct hci_dev *hdev = conn->hdev;
1225 hci_connect_le_scan_cleanup(conn, status);
1234 void hci_conn_failed(struct hci_conn *conn, u8 status)
1236 struct hci_dev *hdev = conn->hdev;
1240 switch (conn->type) {
1242 hci_le_conn_failed(conn, status);
1245 mgmt_connect_failed(hdev, &conn->dst, conn->type,
1246 conn->dst_type, status);
1250 /* In case of BIG/PA sync failed, clear conn flags so that
1253 test_and_clear_bit(HCI_CONN_BIG_SYNC_FAILED, &conn->flags);
1254 test_and_clear_bit(HCI_CONN_PA_SYNC_FAILED, &conn->flags);
1256 conn->state = BT_CLOSED;
1257 hci_connect_cfm(conn, status);
1258 hci_conn_del(conn);
1262 u8 hci_conn_set_handle(struct hci_conn *conn, u16 handle)
1264 struct hci_dev *hdev = conn->hdev;
1266 bt_dev_dbg(hdev, "hcon %p handle 0x%4.4x", conn, handle);
1268 if (conn->handle == handle)
1280 if (conn->abort_reason)
1281 return conn->abort_reason;
1283 if (HCI_CONN_HANDLE_UNSET(conn->handle))
1284 ida_free(&hdev->unset_handle_ida, conn->handle);
1286 conn->handle = handle;
1295 struct hci_conn *conn;
1318 conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);
1319 if (conn && !test_bit(HCI_CONN_SCANNING, &conn->flags)) {
1343 if (conn) {
1344 bacpy(&conn->dst, dst);
1346 conn = hci_conn_add_unset(hdev, LE_LINK, dst, role);
1347 if (IS_ERR(conn))
1348 return conn;
1349 hci_conn_hold(conn);
1350 conn->pending_sec_level = sec_level;
1353 conn->dst_type = dst_type;
1354 conn->sec_level = BT_SECURITY_LOW;
1355 conn->conn_timeout = conn_timeout;
1356 conn->le_adv_phy = phy;
1357 conn->le_adv_sec_phy = sec_phy;
1359 err = hci_connect_le_sync(hdev, conn);
1361 hci_conn_del(conn);
1365 return conn;
1370 struct hci_conn *conn;
1372 conn = hci_conn_hash_lookup_le(hdev, addr, type);
1373 if (!conn)
1376 if (conn->state != BT_CONNECTED)
1422 struct hci_conn *conn;
1429 conn = hci_conn_hash_lookup_big(hdev, big);
1430 if (!conn)
1446 struct hci_conn *conn;
1452 conn = hci_conn_hash_lookup_big(hdev, qos->bcast.big);
1454 if (conn) {
1458 qos->bcast.bis = conn->iso_qos.bcast.bis;
1469 conn = hci_conn_hash_lookup_bis(hdev, BDADDR_ANY, bis);
1470 if (!conn)
1489 struct hci_conn *conn;
1508 conn = hci_conn_hash_lookup_per_adv_bis(hdev, dst, qos->bcast.big,
1510 if (conn)
1516 conn = hci_conn_hash_lookup_big(hdev, qos->bcast.big);
1518 if (conn && (memcmp(qos, &conn->iso_qos, sizeof(*qos)) ||
1519 base_len != conn->le_per_adv_data_len ||
1520 memcmp(conn->le_per_adv_data, base, base_len)))
1523 conn = hci_conn_add_unset(hdev, ISO_LINK, dst, HCI_ROLE_MASTER);
1524 if (IS_ERR(conn))
1525 return conn;
1527 conn->state = BT_CONNECT;
1529 hci_conn_hold(conn);
1530 return conn;
1539 struct hci_conn *conn;
1558 conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);
1559 if (conn) {
1560 if (conn->pending_sec_level < sec_level)
1561 conn->pending_sec_level = sec_level;
1567 conn = hci_conn_add_unset(hdev, LE_LINK, dst, HCI_ROLE_MASTER);
1568 if (IS_ERR(conn))
1569 return conn;
1572 hci_conn_del(conn);
1576 conn->state = BT_CONNECT;
1577 set_bit(HCI_CONN_SCANNING, &conn->flags);
1578 conn->dst_type = dst_type;
1579 conn->sec_level = BT_SECURITY_LOW;
1580 conn->pending_sec_level = sec_level;
1581 conn->conn_timeout = conn_timeout;
1582 conn->conn_reason = conn_reason;
1587 hci_conn_hold(conn);
1588 return conn;
1642 struct hci_conn *conn)
1647 bt_dev_dbg(hdev, "parent %p hcon %p", parent, conn);
1649 if (conn->link)
1650 return conn->link;
1652 if (conn->parent)
1659 link->conn = hci_conn_hold(conn);
1660 conn->link = link;
1661 conn->parent = hci_conn_get(parent);
1718 static int hci_le_create_big(struct hci_conn *conn, struct bt_iso_qos *qos)
1720 struct hci_dev *hdev = conn->hdev;
1754 struct hci_conn *conn;
1759 conn = hci_conn_hash_lookup_cig(hdev, cig_id);
1760 if (!conn)
1763 qos = &conn->iso_qos;
1781 conn = hci_conn_hash_lookup_cis(hdev, NULL, 0, cig_id, cis_id);
1782 if (!conn)
1785 qos = &conn->iso_qos;
1789 cis->c_sdu = cpu_to_le16(conn->iso_qos.ucast.out.sdu);
1790 cis->p_sdu = cpu_to_le16(conn->iso_qos.ucast.in.sdu);
1808 static bool hci_le_set_cig_params(struct hci_conn *conn, struct bt_iso_qos *qos)
1810 struct hci_dev *hdev = conn->hdev;
1933 bool hci_iso_setup_path(struct hci_conn *conn)
1935 struct hci_dev *hdev = conn->hdev;
1940 if (conn->iso_qos.ucast.out.sdu) {
1941 cmd.handle = cpu_to_le16(conn->handle);
1951 if (conn->iso_qos.ucast.in.sdu) {
1952 cmd.handle = cpu_to_le16(conn->handle);
1965 int hci_conn_check_create_cis(struct hci_conn *conn)
1967 if (conn->type != ISO_LINK || !bacmp(&conn->dst, BDADDR_ANY))
1970 if (!conn->parent || conn->parent->state != BT_CONNECTED ||
1971 conn->state != BT_CONNECT || HCI_CONN_HANDLE_UNSET(conn->handle))
1984 struct hci_conn *conn;
1989 list_for_each_entry_rcu(conn, &hdev->conn_hash.list, list) {
1990 if (test_bit(HCI_CONN_CREATE_CIS, &conn->flags)) {
1995 if (!hci_conn_check_create_cis(conn))
2008 static void hci_iso_qos_setup(struct hci_dev *hdev, struct hci_conn *conn,
2013 qos->sdu = conn->mtu;
2022 qos->interval = conn->le_conn_interval * 1250;
2026 qos->latency = conn->le_conn_latency;
2031 struct hci_conn *conn = data;
2032 struct bt_iso_qos *qos = &conn->iso_qos;
2046 err = hci_start_per_adv_sync(hdev, qos->bcast.bis, conn->le_per_adv_data_len,
2047 conn->le_per_adv_data, flags, interval,
2052 return hci_le_create_big(conn, &conn->iso_qos);
2087 struct hci_conn *conn;
2093 conn = hci_conn_add_unset(hdev, ISO_LINK, dst, HCI_ROLE_SLAVE);
2094 if (IS_ERR(conn))
2095 return conn;
2097 conn->iso_qos = *qos;
2098 conn->state = BT_LISTEN;
2100 hci_conn_hold(conn);
2105 hci_conn_drop(conn);
2120 hci_conn_drop(conn);
2125 return conn;
2160 struct hci_conn *conn = data;
2162 bt_dev_dbg(hdev, "conn %p", conn);
2166 hci_connect_cfm(conn, err);
2167 hci_conn_del(conn);
2175 struct hci_conn *conn;
2181 conn = hci_conn_hash_lookup_big_state(hdev, qos->bcast.big, BT_OPEN);
2182 if (conn) {
2183 memcpy(qos, &conn->iso_qos, sizeof(*qos));
2184 conn->state = BT_CONNECTED;
2185 return conn;
2193 conn = hci_add_bis(hdev, dst, qos, base_len, eir);
2194 if (IS_ERR(conn))
2195 return conn;
2198 conn->le_tx_phy = qos->bcast.out.phy;
2199 conn->le_tx_phy = qos->bcast.out.phy;
2203 memcpy(conn->le_per_adv_data, eir, sizeof(eir));
2204 conn->le_per_adv_data_len = base_len;
2207 hci_iso_qos_setup(hdev, conn, &qos->bcast.out,
2208 conn->le_tx_phy ? conn->le_tx_phy :
2211 conn->iso_qos = *qos;
2212 conn->state = BT_BOUND;
2216 conn->iso_qos.bcast.big);
2217 if (parent && parent != conn) {
2218 link = hci_conn_link(parent, conn);
2220 hci_conn_drop(conn);
2225 hci_conn_drop(conn);
2228 return conn;
2231 static void bis_mark_per_adv(struct hci_conn *conn, void *data)
2236 if (bacmp(&conn->dst, BDADDR_ANY))
2239 if (d->big != conn->iso_qos.bcast.big ||
2241 d->bis != conn->iso_qos.bcast.bis)
2244 set_bit(HCI_CONN_PER_ADV, &conn->flags);
2251 struct hci_conn *conn;
2255 conn = hci_bind_bis(hdev, dst, qos, base_len, base);
2256 if (IS_ERR(conn))
2257 return conn;
2259 if (conn->state == BT_CONNECTED)
2260 return conn;
2273 err = hci_cmd_sync_queue(hdev, create_big_sync, conn,
2276 hci_conn_drop(conn);
2280 return conn;
2332 int hci_conn_check_link_mode(struct hci_conn *conn)
2334 BT_DBG("hcon %p", conn);
2340 if (hci_dev_test_flag(conn->hdev, HCI_SC_ONLY)) {
2341 if (!hci_conn_sc_enabled(conn) ||
2342 !test_bit(HCI_CONN_AES_CCM, &conn->flags) ||
2343 conn->key_type != HCI_LK_AUTH_COMBINATION_P256)
2357 if (conn->sec_level == BT_SECURITY_FIPS &&
2358 !test_bit(HCI_CONN_AES_CCM, &conn->flags)) {
2359 bt_dev_err(conn->hdev,
2364 if (hci_conn_ssp_enabled(conn) &&
2365 !test_bit(HCI_CONN_ENCRYPT, &conn->flags))
2372 static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
2374 BT_DBG("hcon %p", conn);
2376 if (conn->pending_sec_level > sec_level)
2377 sec_level = conn->pending_sec_level;
2379 if (sec_level > conn->sec_level)
2380 conn->pending_sec_level = sec_level;
2381 else if (test_bit(HCI_CONN_AUTH, &conn->flags))
2385 auth_type |= (conn->auth_type & 0x01);
2387 conn->auth_type = auth_type;
2389 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
2392 cp.handle = cpu_to_le16(conn->handle);
2393 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
2399 if (!test_bit(HCI_CONN_ENCRYPT, &conn->flags))
2400 set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
2407 static void hci_conn_encrypt(struct hci_conn *conn)
2409 BT_DBG("hcon %p", conn);
2411 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
2413 cp.handle = cpu_to_le16(conn->handle);
2415 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
2421 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
2424 BT_DBG("hcon %p", conn);
2426 if (conn->type == LE_LINK)
2427 return smp_conn_security(conn, sec_level);
2435 if (sec_level == BT_SECURITY_LOW && !hci_conn_ssp_enabled(conn))
2439 if (!test_bit(HCI_CONN_AUTH, &conn->flags))
2442 switch (conn->key_type) {
2471 if (sec_level <= BT_SECURITY_MEDIUM || conn->pin_length == 16)
2479 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
2483 set_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags);
2485 if (!hci_conn_auth(conn, sec_level, auth_type))
2489 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags)) {
2493 if (!conn->enc_key_size)
2500 hci_conn_encrypt(conn);
2506 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
2508 BT_DBG("hcon %p", conn);
2515 if (conn->sec_level == BT_SECURITY_HIGH ||
2516 conn->sec_level == BT_SECURITY_FIPS)
2525 int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
2527 BT_DBG("hcon %p", conn);
2529 if (role == conn->role)
2532 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->flags)) {
2534 bacpy(&cp.bdaddr, &conn->dst);
2536 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
2544 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
2546 struct hci_dev *hdev = conn->hdev;
2548 BT_DBG("hcon %p mode %d", conn, conn->mode);
2550 if (conn->mode != HCI_CM_SNIFF)
2553 if (!test_bit(HCI_CONN_POWER_SAVE, &conn->flags) && !force_active)
2556 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
2558 cp.handle = cpu_to_le16(conn->handle);
2564 queue_delayed_work(hdev->workqueue, &conn->idle_work,
2572 struct hci_conn *conn;
2580 while ((conn = list_first_entry_or_null(head,
2583 conn->state = BT_CLOSED;
2584 hci_disconn_cfm(conn, HCI_ERROR_LOCAL_HOST_TERM);
2585 hci_conn_del(conn);
2589 static u32 get_link_mode(struct hci_conn *conn)
2593 if (conn->role == HCI_ROLE_MASTER)
2596 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
2599 if (test_bit(HCI_CONN_AUTH, &conn->flags))
2602 if (test_bit(HCI_CONN_SECURE, &conn->flags))
2605 if (test_bit(HCI_CONN_FIPS, &conn->flags))
2668 struct hci_conn *conn;
2675 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
2676 if (conn) {
2677 bacpy(&ci.bdaddr, &conn->dst);
2678 ci.handle = conn->handle;
2679 ci.type = conn->type;
2680 ci.out = conn->out;
2681 ci.state = conn->state;
2682 ci.link_mode = get_link_mode(conn);
2686 if (!conn)
2695 struct hci_conn *conn;
2701 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
2702 if (conn)
2703 req.type = conn->auth_type;
2706 if (!conn)
2712 struct hci_chan *hci_chan_create(struct hci_conn *conn)
2714 struct hci_dev *hdev = conn->hdev;
2717 BT_DBG("%s hcon %p", hdev->name, conn);
2719 if (test_bit(HCI_CONN_DROP, &conn->flags)) {
2728 chan->conn = hci_conn_get(conn);
2732 list_add_rcu(&chan->list, &conn->chan_list);
2739 struct hci_conn *conn = chan->conn;
2740 struct hci_dev *hdev = conn->hdev;
2742 BT_DBG("%s hcon %p chan %p", hdev->name, conn, chan);
2749 set_bit(HCI_CONN_DROP, &conn->flags);
2751 hci_conn_put(conn);
2757 void hci_chan_list_flush(struct hci_conn *conn)
2761 BT_DBG("hcon %p", conn);
2763 list_for_each_entry_safe(chan, n, &conn->chan_list, list)
2799 u32 hci_conn_get_phy(struct hci_conn *conn)
2807 switch (conn->type) {
2822 if (conn->pkt_type & (HCI_DM3 | HCI_DH3))
2825 if (conn->pkt_type & (HCI_DM5 | HCI_DH5))
2831 if (!(conn->pkt_type & HCI_2DH1))
2834 if (!(conn->pkt_type & HCI_2DH3))
2837 if (!(conn->pkt_type & HCI_2DH5))
2843 if (!(conn->pkt_type & HCI_3DH1))
2846 if (!(conn->pkt_type & HCI_3DH3))
2849 if (!(conn->pkt_type & HCI_3DH5))
2858 if (!(conn->pkt_type & (ESCO_EV4 | ESCO_EV5)))
2862 if (!(conn->pkt_type & ESCO_2EV3))
2865 if (!(conn->pkt_type & ESCO_2EV5))
2869 if (!(conn->pkt_type & ESCO_3EV3))
2872 if (!(conn->pkt_type & ESCO_3EV5))
2878 if (conn->le_tx_phy & HCI_LE_SET_PHY_1M)
2881 if (conn->le_rx_phy & HCI_LE_SET_PHY_1M)
2884 if (conn->le_tx_phy & HCI_LE_SET_PHY_2M)
2887 if (conn->le_rx_phy & HCI_LE_SET_PHY_2M)
2890 if (conn->le_tx_phy & HCI_LE_SET_PHY_CODED)
2893 if (conn->le_rx_phy & HCI_LE_SET_PHY_CODED)
2904 struct hci_conn *conn = data;
2906 if (!hci_conn_valid(hdev, conn))
2909 return hci_abort_conn_sync(hdev, conn, conn->abort_reason);
2912 int hci_abort_conn(struct hci_conn *conn, u8 reason)
2914 struct hci_dev *hdev = conn->hdev;
2919 if (conn->abort_reason)
2922 bt_dev_dbg(hdev, "handle 0x%2.2x reason 0x%2.2x", conn->handle, reason);
2924 conn->abort_reason = reason;
2933 if (conn->state == BT_CONNECT && hdev->req_status == HCI_REQ_PEND) {
2943 } else if (!hci_cancel_connect_sync(hdev, conn)) {
2947 return hci_cmd_sync_queue_once(hdev, abort_conn_sync, conn, NULL);