Lines Matching refs:conn
48 struct hci_conn *conn;
71 static 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 static void hci_acl_create_connection(struct hci_conn *conn)
183 struct hci_dev *hdev = conn->hdev;
187 BT_DBG("hcon %p", conn);
201 conn->state = BT_CONNECT2;
206 conn->state = BT_CONNECT;
207 conn->out = true;
208 conn->role = HCI_ROLE_MASTER;
210 conn->attempt++;
212 conn->link_policy = hdev->link_policy;
215 bacpy(&cp.bdaddr, &conn->dst);
218 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
227 memcpy(conn->dev_class, ie->data.dev_class, 3);
230 cp.pkt_type = cpu_to_le16(conn->pkt_type);
239 int hci_disconnect(struct hci_conn *conn, __u8 reason)
241 BT_DBG("hcon %p", conn);
248 if (conn->type == ACL_LINK && conn->role == HCI_ROLE_MASTER &&
249 (conn->state == BT_CONNECTED || conn->state == BT_CONFIG)) {
250 struct hci_dev *hdev = conn->hdev;
253 clkoff_cp.handle = cpu_to_le16(conn->handle);
258 return hci_abort_conn(conn, reason);
261 static void hci_add_sco(struct hci_conn *conn, __u16 handle)
263 struct hci_dev *hdev = conn->hdev;
266 BT_DBG("hcon %p", conn);
268 conn->state = BT_CONNECT;
269 conn->out = true;
271 conn->attempt++;
274 cp.pkt_type = cpu_to_le16(conn->pkt_type);
279 static bool find_next_esco_param(struct hci_conn *conn,
282 if (!conn->parent)
285 for (; conn->attempt <= size; conn->attempt++) {
286 if (lmp_esco_2m_capable(conn->parent) ||
287 (esco_param[conn->attempt - 1].pkt_type & ESCO_2EV3))
290 conn, conn->attempt);
293 return conn->attempt <= size;
338 struct hci_conn *conn = conn_handle->conn;
345 bt_dev_dbg(hdev, "hcon %p", conn);
348 if (conn->codec.data_path)
349 configure_datapath_sync(hdev, &conn->codec);
351 conn->state = BT_CONNECT;
352 conn->out = true;
354 conn->attempt++;
363 switch (conn->codec.id) {
365 if (!find_next_esco_param(conn, esco_param_msbc,
369 param = &esco_param_msbc[conn->attempt - 1];
384 cp.in_data_path = conn->codec.data_path;
385 cp.out_data_path = conn->codec.data_path;
391 if (!find_next_esco_param(conn, esco_param_msbc,
394 param = &esco_param_msbc[conn->attempt - 1];
409 cp.in_data_path = conn->codec.data_path;
410 cp.out_data_path = conn->codec.data_path;
416 if (conn->parent && lmp_esco_capable(conn->parent)) {
417 if (!find_next_esco_param(conn, esco_param_cvsd,
420 param = &esco_param_cvsd[conn->attempt - 1];
422 if (conn->attempt > ARRAY_SIZE(sco_param_cvsd))
424 param = &sco_param_cvsd[conn->attempt - 1];
440 cp.in_data_path = conn->codec.data_path;
441 cp.out_data_path = conn->codec.data_path;
459 static bool hci_setup_sync_conn(struct hci_conn *conn, __u16 handle)
461 struct hci_dev *hdev = conn->hdev;
465 bt_dev_dbg(hdev, "hcon %p", conn);
467 conn->state = BT_CONNECT;
468 conn->out = true;
470 conn->attempt++;
476 cp.voice_setting = cpu_to_le16(conn->setting);
478 switch (conn->setting & SCO_AIRMODE_MASK) {
480 if (!find_next_esco_param(conn, esco_param_msbc,
483 param = &esco_param_msbc[conn->attempt - 1];
486 if (conn->parent && lmp_esco_capable(conn->parent)) {
487 if (!find_next_esco_param(conn, esco_param_cvsd,
490 param = &esco_param_cvsd[conn->attempt - 1];
492 if (conn->attempt > ARRAY_SIZE(sco_param_cvsd))
494 param = &sco_param_cvsd[conn->attempt - 1];
511 bool hci_setup_sync(struct hci_conn *conn, __u16 handle)
516 if (enhanced_sync_conn_capable(conn->hdev)) {
522 conn_handle->conn = conn;
524 result = hci_cmd_sync_queue(conn->hdev, hci_enhanced_setup_sync,
532 return hci_setup_sync_conn(conn, handle);
535 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
538 struct hci_dev *hdev = conn->hdev;
544 params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
555 cp.handle = cpu_to_le16(conn->handle);
571 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
574 struct hci_dev *hdev = conn->hdev;
577 BT_DBG("hcon %p", conn);
581 cp.handle = cpu_to_le16(conn->handle);
590 void hci_sco_setup(struct hci_conn *conn, __u8 status)
594 link = list_first_entry_or_null(&conn->link_list, struct hci_link, list);
595 if (!link || !link->conn)
598 BT_DBG("hcon %p", conn);
601 if (lmp_esco_capable(conn->hdev))
602 hci_setup_sync(link->conn, conn->handle);
604 hci_add_sco(link->conn, conn->handle);
606 hci_connect_cfm(link->conn, status);
607 hci_conn_del(link->conn);
613 struct hci_conn *conn = container_of(work, struct hci_conn,
615 int refcnt = atomic_read(&conn->refcnt);
617 BT_DBG("hcon %p state %s", conn, state_to_string(conn->state));
623 * l2cap_chan_del for each channel, and inside l2cap_chan_del conn is
625 * conn. For now make sure that ACL is alive if refcnt is higher then 0,
631 hci_abort_conn(conn, hci_proto_disconn_ind(conn));
637 struct hci_conn *conn = container_of(work, struct hci_conn,
639 struct hci_dev *hdev = conn->hdev;
641 BT_DBG("hcon %p mode %d", conn, conn->mode);
643 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
646 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
649 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
651 cp.handle = cpu_to_le16(conn->handle);
658 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
660 cp.handle = cpu_to_le16(conn->handle);
671 struct hci_conn *conn = container_of(work, struct hci_conn,
674 hci_send_cmd(conn->hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
675 &conn->dst);
697 struct hci_conn *conn = container_of(work, struct hci_conn,
699 struct hci_dev *hdev = conn->hdev;
708 if (conn->role == HCI_ROLE_SLAVE) {
712 hci_conn_failed(conn, HCI_ERROR_ADVERTISING_TIMEOUT);
717 hci_abort_conn(conn, HCI_ERROR_REMOTE_USER_TERM);
741 static void bis_list(struct hci_conn *conn, void *data)
746 if (bacmp(&conn->dst, BDADDR_ANY))
749 if (d->big != conn->iso_qos.bcast.big || d->bis == BT_ISO_QOS_BIS_UNSET ||
750 d->bis != conn->iso_qos.bcast.bis)
777 static int hci_le_terminate_big(struct hci_dev *hdev, struct hci_conn *conn)
782 bt_dev_dbg(hdev, "big 0x%2.2x bis 0x%2.2x", conn->iso_qos.bcast.big,
783 conn->iso_qos.bcast.bis);
789 d->big = conn->iso_qos.bcast.big;
790 d->bis = conn->iso_qos.bcast.bis;
791 d->big_term = test_and_clear_bit(HCI_CONN_BIG_CREATED, &conn->flags);
817 static int hci_le_big_terminate(struct hci_dev *hdev, u8 big, struct hci_conn *conn)
822 bt_dev_dbg(hdev, "big 0x%2.2x sync_handle 0x%4.4x", big, conn->sync_handle);
829 d->sync_handle = conn->sync_handle;
830 d->pa_sync_term = test_and_clear_bit(HCI_CONN_PA_SYNC, &conn->flags);
831 d->big_sync_term = test_and_clear_bit(HCI_CONN_BIG_SYNC, &conn->flags);
847 static void bis_cleanup(struct hci_conn *conn)
849 struct hci_dev *hdev = conn->hdev;
852 bt_dev_dbg(hdev, "conn %p", conn);
854 if (conn->role == HCI_ROLE_MASTER) {
855 if (!test_and_clear_bit(HCI_CONN_PER_ADV, &conn->flags))
861 bis = hci_conn_hash_lookup_big(hdev, conn->iso_qos.bcast.big);
865 hci_le_terminate_big(hdev, conn);
868 conn->iso_qos.bcast.big);
873 hci_le_big_terminate(hdev, conn->iso_qos.bcast.big,
874 conn);
893 static void find_cis(struct hci_conn *conn, void *data)
898 if (!bacmp(&conn->dst, BDADDR_ANY) || d->cig != conn->iso_qos.ucast.cig)
908 static void cis_cleanup(struct hci_conn *conn)
910 struct hci_dev *hdev = conn->hdev;
913 if (conn->iso_qos.ucast.cig == BT_ISO_QOS_CIG_UNSET)
917 d.cig = conn->iso_qos.ucast.cig;
928 hci_le_remove_cig(hdev, conn->iso_qos.ucast.cig);
940 struct hci_conn *conn;
944 conn = kzalloc(sizeof(*conn), GFP_KERNEL);
945 if (!conn)
948 bacpy(&conn->dst, dst);
949 bacpy(&conn->src, &hdev->bdaddr);
950 conn->handle = handle;
951 conn->hdev = hdev;
952 conn->type = type;
953 conn->role = role;
954 conn->mode = HCI_CM_ACTIVE;
955 conn->state = BT_OPEN;
956 conn->auth_type = HCI_AT_GENERAL_BONDING;
957 conn->io_capability = hdev->io_capability;
958 conn->remote_auth = 0xff;
959 conn->key_type = 0xff;
960 conn->rssi = HCI_RSSI_INVALID;
961 conn->tx_power = HCI_TX_POWER_INVALID;
962 conn->max_tx_power = HCI_TX_POWER_INVALID;
963 conn->sync_handle = HCI_SYNC_HANDLE_INVALID;
965 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
966 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
969 conn->auth_payload_timeout = DEFAULT_AUTH_PAYLOAD_TIMEOUT;
971 if (conn->role == HCI_ROLE_MASTER)
972 conn->out = true;
976 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
979 /* conn->src should reflect the local identity address */
980 hci_copy_identity_address(hdev, &conn->src, &conn->src_type);
983 /* conn->src should reflect the local identity address */
984 hci_copy_identity_address(hdev, &conn->src, &conn->src_type);
988 conn->cleanup = bis_cleanup;
989 else if (conn->role == HCI_ROLE_MASTER)
990 conn->cleanup = cis_cleanup;
995 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
998 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
1001 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
1005 skb_queue_head_init(&conn->data_q);
1007 INIT_LIST_HEAD(&conn->chan_list);
1008 INIT_LIST_HEAD(&conn->link_list);
1010 INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
1011 INIT_DELAYED_WORK(&conn->auto_accept_work, hci_conn_auto_accept);
1012 INIT_DELAYED_WORK(&conn->idle_work, hci_conn_idle);
1013 INIT_DELAYED_WORK(&conn->le_conn_timeout, le_conn_timeout);
1015 atomic_set(&conn->refcnt, 0);
1019 hci_conn_hash_add(hdev, conn);
1025 if (conn->type != SCO_LINK && conn->type != ESCO_LINK) {
1030 hci_conn_init_sysfs(conn);
1032 return conn;
1049 static void hci_conn_cleanup_child(struct hci_conn *conn, u8 reason)
1054 /* Due to race, SCO/ISO conn might be not established yet at this point,
1058 switch (conn->type) {
1061 if (HCI_CONN_HANDLE_UNSET(conn->handle))
1062 hci_conn_failed(conn, reason);
1065 if (conn->state != BT_CONNECTED &&
1066 !test_bit(HCI_CONN_CREATE_CIS, &conn->flags))
1067 hci_conn_failed(conn, reason);
1072 static void hci_conn_unlink(struct hci_conn *conn)
1074 struct hci_dev *hdev = conn->hdev;
1076 bt_dev_dbg(hdev, "hcon %p", conn);
1078 if (!conn->parent) {
1081 list_for_each_entry_safe(link, t, &conn->link_list, list) {
1082 struct hci_conn *child = link->conn;
1094 hci_conn_cleanup_child(child, conn->abort_reason);
1100 if (!conn->link)
1103 list_del_rcu(&conn->link->list);
1106 hci_conn_drop(conn->parent);
1107 hci_conn_put(conn->parent);
1108 conn->parent = NULL;
1110 kfree(conn->link);
1111 conn->link = NULL;
1114 void hci_conn_del(struct hci_conn *conn)
1116 struct hci_dev *hdev = conn->hdev;
1118 BT_DBG("%s hcon %p handle %d", hdev->name, conn, conn->handle);
1120 hci_conn_unlink(conn);
1122 cancel_delayed_work_sync(&conn->disc_work);
1123 cancel_delayed_work_sync(&conn->auto_accept_work);
1124 cancel_delayed_work_sync(&conn->idle_work);
1126 if (conn->type == ACL_LINK) {
1128 hdev->acl_cnt += conn->sent;
1129 } else if (conn->type == LE_LINK) {
1130 cancel_delayed_work(&conn->le_conn_timeout);
1133 hdev->le_cnt += conn->sent;
1135 hdev->acl_cnt += conn->sent;
1138 if (conn->type == ISO_LINK) {
1140 hdev->iso_cnt += conn->sent;
1142 hdev->le_cnt += conn->sent;
1144 hdev->acl_cnt += conn->sent;
1148 skb_queue_purge(&conn->data_q);
1155 hci_conn_cleanup(conn);
1220 static void hci_le_conn_failed(struct hci_conn *conn, u8 status)
1222 struct hci_dev *hdev = conn->hdev;
1224 hci_connect_le_scan_cleanup(conn, status);
1233 void hci_conn_failed(struct hci_conn *conn, u8 status)
1235 struct hci_dev *hdev = conn->hdev;
1239 switch (conn->type) {
1241 hci_le_conn_failed(conn, status);
1244 mgmt_connect_failed(hdev, &conn->dst, conn->type,
1245 conn->dst_type, status);
1249 conn->state = BT_CLOSED;
1250 hci_connect_cfm(conn, status);
1251 hci_conn_del(conn);
1255 u8 hci_conn_set_handle(struct hci_conn *conn, u16 handle)
1257 struct hci_dev *hdev = conn->hdev;
1259 bt_dev_dbg(hdev, "hcon %p handle 0x%4.4x", conn, handle);
1261 if (conn->handle == handle)
1273 if (conn->abort_reason)
1274 return conn->abort_reason;
1276 if (HCI_CONN_HANDLE_UNSET(conn->handle))
1277 ida_free(&hdev->unset_handle_ida, conn->handle);
1279 conn->handle = handle;
1286 struct hci_conn *conn;
1289 conn = hci_conn_hash_lookup_handle(hdev, handle);
1290 if (!conn)
1298 hci_connect_le_scan_cleanup(conn, 0x00);
1303 if (conn != hci_lookup_le_connect(hdev))
1306 /* Flush to make sure we send create conn cancel command if needed */
1307 flush_delayed_work(&conn->le_conn_timeout);
1308 hci_conn_failed(conn, bt_status(err));
1316 struct hci_conn *conn;
1319 conn = hci_conn_hash_lookup_handle(hdev, handle);
1320 if (!conn)
1323 bt_dev_dbg(hdev, "conn %p", conn);
1325 clear_bit(HCI_CONN_SCANNING, &conn->flags);
1326 conn->state = BT_CONNECT;
1328 return hci_le_create_conn_sync(hdev, conn);
1335 struct hci_conn *conn;
1358 conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);
1359 if (conn && !test_bit(HCI_CONN_SCANNING, &conn->flags)) {
1383 if (conn) {
1384 bacpy(&conn->dst, dst);
1386 conn = hci_conn_add_unset(hdev, LE_LINK, dst, role);
1387 if (!conn)
1389 hci_conn_hold(conn);
1390 conn->pending_sec_level = sec_level;
1393 conn->dst_type = dst_type;
1394 conn->sec_level = BT_SECURITY_LOW;
1395 conn->conn_timeout = conn_timeout;
1398 UINT_PTR(conn->handle),
1401 hci_conn_del(conn);
1405 return conn;
1410 struct hci_conn *conn;
1412 conn = hci_conn_hash_lookup_le(hdev, addr, type);
1413 if (!conn)
1416 if (conn->state != BT_CONNECTED)
1462 struct hci_conn *conn;
1469 conn = hci_conn_hash_lookup_big(hdev, big);
1470 if (!conn)
1486 struct hci_conn *conn;
1497 conn = hci_conn_hash_lookup_bis(hdev, BDADDR_ANY, bis);
1498 if (!conn)
1517 struct hci_conn *conn;
1536 conn = hci_conn_hash_lookup_per_adv_bis(hdev, dst, qos->bcast.big,
1538 if (conn)
1544 conn = hci_conn_hash_lookup_big(hdev, qos->bcast.big);
1546 if (conn && (memcmp(qos, &conn->iso_qos, sizeof(*qos)) ||
1547 base_len != conn->le_per_adv_data_len ||
1548 memcmp(conn->le_per_adv_data, base, base_len)))
1551 conn = hci_conn_add_unset(hdev, ISO_LINK, dst, HCI_ROLE_MASTER);
1552 if (!conn)
1555 conn->state = BT_CONNECT;
1557 hci_conn_hold(conn);
1558 return conn;
1567 struct hci_conn *conn;
1586 conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);
1587 if (conn) {
1588 if (conn->pending_sec_level < sec_level)
1589 conn->pending_sec_level = sec_level;
1595 conn = hci_conn_add_unset(hdev, LE_LINK, dst, HCI_ROLE_MASTER);
1596 if (!conn)
1600 hci_conn_del(conn);
1604 conn->state = BT_CONNECT;
1605 set_bit(HCI_CONN_SCANNING, &conn->flags);
1606 conn->dst_type = dst_type;
1607 conn->sec_level = BT_SECURITY_LOW;
1608 conn->pending_sec_level = sec_level;
1609 conn->conn_timeout = conn_timeout;
1610 conn->conn_reason = conn_reason;
1615 hci_conn_hold(conn);
1616 return conn;
1662 struct hci_conn *conn)
1667 bt_dev_dbg(hdev, "parent %p hcon %p", parent, conn);
1669 if (conn->link)
1670 return conn->link;
1672 if (conn->parent)
1679 link->conn = hci_conn_hold(conn);
1680 conn->link = link;
1681 conn->parent = hci_conn_get(parent);
1737 static int hci_le_create_big(struct hci_conn *conn, struct bt_iso_qos *qos)
1739 struct hci_dev *hdev = conn->hdev;
1772 struct hci_conn *conn;
1777 conn = hci_conn_hash_lookup_cig(hdev, cig_id);
1778 if (!conn)
1783 qos = &conn->iso_qos;
1801 conn = hci_conn_hash_lookup_cis(hdev, NULL, 0, cig_id, cis_id);
1802 if (!conn)
1805 qos = &conn->iso_qos;
1809 cis->c_sdu = cpu_to_le16(conn->iso_qos.ucast.out.sdu);
1810 cis->p_sdu = cpu_to_le16(conn->iso_qos.ucast.in.sdu);
1828 static bool hci_le_set_cig_params(struct hci_conn *conn, struct bt_iso_qos *qos)
1830 struct hci_dev *hdev = conn->hdev;
1953 bool hci_iso_setup_path(struct hci_conn *conn)
1955 struct hci_dev *hdev = conn->hdev;
1960 if (conn->iso_qos.ucast.out.sdu) {
1961 cmd.handle = cpu_to_le16(conn->handle);
1971 if (conn->iso_qos.ucast.in.sdu) {
1972 cmd.handle = cpu_to_le16(conn->handle);
1985 int hci_conn_check_create_cis(struct hci_conn *conn)
1987 if (conn->type != ISO_LINK || !bacmp(&conn->dst, BDADDR_ANY))
1990 if (!conn->parent || conn->parent->state != BT_CONNECTED ||
1991 conn->state != BT_CONNECT || HCI_CONN_HANDLE_UNSET(conn->handle))
2004 struct hci_conn *conn;
2009 list_for_each_entry_rcu(conn, &hdev->conn_hash.list, list) {
2010 if (test_bit(HCI_CONN_CREATE_CIS, &conn->flags)) {
2015 if (!hci_conn_check_create_cis(conn))
2028 static void hci_iso_qos_setup(struct hci_dev *hdev, struct hci_conn *conn,
2048 qos->interval = conn->le_conn_interval * 1250;
2052 qos->latency = conn->le_conn_latency;
2057 struct hci_conn *conn = data;
2058 struct bt_iso_qos *qos = &conn->iso_qos;
2072 err = hci_start_per_adv_sync(hdev, qos->bcast.bis, conn->le_per_adv_data_len,
2073 conn->le_per_adv_data, flags, interval,
2078 return hci_le_create_big(conn, &conn->iso_qos);
2170 struct hci_conn *conn = data;
2172 bt_dev_dbg(hdev, "conn %p", conn);
2176 hci_connect_cfm(conn, err);
2177 hci_conn_del(conn);
2185 struct hci_conn *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;
2214 return conn;
2217 static void bis_mark_per_adv(struct hci_conn *conn, void *data)
2222 if (bacmp(&conn->dst, BDADDR_ANY))
2225 if (d->big != conn->iso_qos.bcast.big ||
2227 d->bis != conn->iso_qos.bcast.bis)
2230 set_bit(HCI_CONN_PER_ADV, &conn->flags);
2237 struct hci_conn *conn;
2241 conn = hci_bind_bis(hdev, dst, qos, base_len, base);
2242 if (IS_ERR(conn))
2243 return conn;
2256 err = hci_cmd_sync_queue(hdev, create_big_sync, conn,
2259 hci_conn_drop(conn);
2263 return conn;
2315 int hci_conn_check_link_mode(struct hci_conn *conn)
2317 BT_DBG("hcon %p", conn);
2323 if (hci_dev_test_flag(conn->hdev, HCI_SC_ONLY)) {
2324 if (!hci_conn_sc_enabled(conn) ||
2325 !test_bit(HCI_CONN_AES_CCM, &conn->flags) ||
2326 conn->key_type != HCI_LK_AUTH_COMBINATION_P256)
2340 if (conn->sec_level == BT_SECURITY_FIPS &&
2341 !test_bit(HCI_CONN_AES_CCM, &conn->flags)) {
2342 bt_dev_err(conn->hdev,
2347 if (hci_conn_ssp_enabled(conn) &&
2348 !test_bit(HCI_CONN_ENCRYPT, &conn->flags))
2355 static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
2357 BT_DBG("hcon %p", conn);
2359 if (conn->pending_sec_level > sec_level)
2360 sec_level = conn->pending_sec_level;
2362 if (sec_level > conn->sec_level)
2363 conn->pending_sec_level = sec_level;
2364 else if (test_bit(HCI_CONN_AUTH, &conn->flags))
2368 auth_type |= (conn->auth_type & 0x01);
2370 conn->auth_type = auth_type;
2372 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
2375 cp.handle = cpu_to_le16(conn->handle);
2376 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
2382 if (!test_bit(HCI_CONN_ENCRYPT, &conn->flags))
2383 set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
2390 static void hci_conn_encrypt(struct hci_conn *conn)
2392 BT_DBG("hcon %p", conn);
2394 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
2396 cp.handle = cpu_to_le16(conn->handle);
2398 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
2404 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
2407 BT_DBG("hcon %p", conn);
2409 if (conn->type == LE_LINK)
2410 return smp_conn_security(conn, sec_level);
2418 if (sec_level == BT_SECURITY_LOW && !hci_conn_ssp_enabled(conn))
2422 if (!test_bit(HCI_CONN_AUTH, &conn->flags))
2425 switch (conn->key_type) {
2454 if (sec_level <= BT_SECURITY_MEDIUM || conn->pin_length == 16)
2462 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
2466 set_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags);
2468 if (!hci_conn_auth(conn, sec_level, auth_type))
2472 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags)) {
2476 if (!conn->enc_key_size)
2483 hci_conn_encrypt(conn);
2489 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
2491 BT_DBG("hcon %p", conn);
2498 if (conn->sec_level == BT_SECURITY_HIGH ||
2499 conn->sec_level == BT_SECURITY_FIPS)
2508 int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
2510 BT_DBG("hcon %p", conn);
2512 if (role == conn->role)
2515 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->flags)) {
2517 bacpy(&cp.bdaddr, &conn->dst);
2519 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
2527 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
2529 struct hci_dev *hdev = conn->hdev;
2531 BT_DBG("hcon %p mode %d", conn, conn->mode);
2533 if (conn->mode != HCI_CM_SNIFF)
2536 if (!test_bit(HCI_CONN_POWER_SAVE, &conn->flags) && !force_active)
2539 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
2541 cp.handle = cpu_to_le16(conn->handle);
2547 queue_delayed_work(hdev->workqueue, &conn->idle_work,
2555 struct hci_conn *conn;
2563 while ((conn = list_first_entry_or_null(head,
2566 conn->state = BT_CLOSED;
2567 hci_disconn_cfm(conn, HCI_ERROR_LOCAL_HOST_TERM);
2568 hci_conn_del(conn);
2575 struct hci_conn *conn;
2581 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
2582 if (conn)
2583 hci_acl_create_connection(conn);
2588 static u32 get_link_mode(struct hci_conn *conn)
2592 if (conn->role == HCI_ROLE_MASTER)
2595 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
2598 if (test_bit(HCI_CONN_AUTH, &conn->flags))
2601 if (test_bit(HCI_CONN_SECURE, &conn->flags))
2604 if (test_bit(HCI_CONN_FIPS, &conn->flags))
2667 struct hci_conn *conn;
2674 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
2675 if (conn) {
2676 bacpy(&ci.bdaddr, &conn->dst);
2677 ci.handle = conn->handle;
2678 ci.type = conn->type;
2679 ci.out = conn->out;
2680 ci.state = conn->state;
2681 ci.link_mode = get_link_mode(conn);
2685 if (!conn)
2694 struct hci_conn *conn;
2700 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
2701 if (conn)
2702 req.type = conn->auth_type;
2705 if (!conn)
2711 struct hci_chan *hci_chan_create(struct hci_conn *conn)
2713 struct hci_dev *hdev = conn->hdev;
2716 BT_DBG("%s hcon %p", hdev->name, conn);
2718 if (test_bit(HCI_CONN_DROP, &conn->flags)) {
2727 chan->conn = hci_conn_get(conn);
2731 list_add_rcu(&chan->list, &conn->chan_list);
2738 struct hci_conn *conn = chan->conn;
2739 struct hci_dev *hdev = conn->hdev;
2741 BT_DBG("%s hcon %p chan %p", hdev->name, conn, chan);
2748 set_bit(HCI_CONN_DROP, &conn->flags);
2750 hci_conn_put(conn);
2756 void hci_chan_list_flush(struct hci_conn *conn)
2760 BT_DBG("hcon %p", conn);
2762 list_for_each_entry_safe(chan, n, &conn->chan_list, list)
2798 u32 hci_conn_get_phy(struct hci_conn *conn)
2806 switch (conn->type) {
2821 if (conn->pkt_type & (HCI_DM3 | HCI_DH3))
2824 if (conn->pkt_type & (HCI_DM5 | HCI_DH5))
2830 if (!(conn->pkt_type & HCI_2DH1))
2833 if (!(conn->pkt_type & HCI_2DH3))
2836 if (!(conn->pkt_type & HCI_2DH5))
2842 if (!(conn->pkt_type & HCI_3DH1))
2845 if (!(conn->pkt_type & HCI_3DH3))
2848 if (!(conn->pkt_type & HCI_3DH5))
2857 if (!(conn->pkt_type & (ESCO_EV4 | ESCO_EV5)))
2861 if (!(conn->pkt_type & ESCO_2EV3))
2864 if (!(conn->pkt_type & ESCO_2EV5))
2868 if (!(conn->pkt_type & ESCO_3EV3))
2871 if (!(conn->pkt_type & ESCO_3EV5))
2877 if (conn->le_tx_phy & HCI_LE_SET_PHY_1M)
2880 if (conn->le_rx_phy & HCI_LE_SET_PHY_1M)
2883 if (conn->le_tx_phy & HCI_LE_SET_PHY_2M)
2886 if (conn->le_rx_phy & HCI_LE_SET_PHY_2M)
2889 if (conn->le_tx_phy & HCI_LE_SET_PHY_CODED)
2892 if (conn->le_rx_phy & HCI_LE_SET_PHY_CODED)
2903 struct hci_conn *conn;
2906 conn = hci_conn_hash_lookup_handle(hdev, handle);
2907 if (!conn)
2910 return hci_abort_conn_sync(hdev, conn, conn->abort_reason);
2913 int hci_abort_conn(struct hci_conn *conn, u8 reason)
2915 struct hci_dev *hdev = conn->hdev;
2920 if (conn->abort_reason)
2923 bt_dev_dbg(hdev, "handle 0x%2.2x reason 0x%2.2x", conn->handle, reason);
2925 conn->abort_reason = reason;
2934 if (conn->state == BT_CONNECT && hdev->req_status == HCI_REQ_PEND) {
2944 return hci_cmd_sync_queue(hdev, abort_conn_sync, UINT_PTR(conn->handle),