2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
6 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License version 2 as
10 published by the Free Software Foundation;
12 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
13 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
15 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
16 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
17 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
22 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
23 SOFTWARE IS DISCLAIMED.
26 /* Bluetooth HCI event handling. */
28 #include <asm/unaligned.h>
30 #include <net/bluetooth/bluetooth.h>
31 #include <net/bluetooth/hci_core.h>
32 #include <net/bluetooth/mgmt.h>
34 #include "hci_request.h"
35 #include "hci_debugfs.h"
42 #define ZERO_KEY "\x00\x00\x00\x00\x00\x00\x00\x00" \
43 "\x00\x00\x00\x00\x00\x00\x00\x00"
45 #define secs_to_jiffies(_secs) msecs_to_jiffies((_secs) * 1000)
47 /* Handle HCI Event packets */
49 static void *hci_ev_skb_pull(struct hci_dev *hdev, struct sk_buff *skb,
54 data = skb_pull_data(skb, len);
56 bt_dev_err(hdev, "Malformed Event: 0x%2.2x", ev);
61 static void *hci_cc_skb_pull(struct hci_dev *hdev, struct sk_buff *skb,
66 data = skb_pull_data(skb, len);
68 bt_dev_err(hdev, "Malformed Command Complete: 0x%4.4x", op);
73 static void *hci_le_ev_skb_pull(struct hci_dev *hdev, struct sk_buff *skb,
78 data = skb_pull_data(skb, len);
80 bt_dev_err(hdev, "Malformed LE Event: 0x%2.2x", ev);
85 static u8 hci_cc_inquiry_cancel(struct hci_dev *hdev, void *data,
88 struct hci_ev_status *rp = data;
90 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
92 /* It is possible that we receive Inquiry Complete event right
93 * before we receive Inquiry Cancel Command Complete event, in
94 * which case the latter event should have status of Command
95 * Disallowed (0x0c). This should not be treated as error, since
96 * we actually achieve what Inquiry Cancel wants to achieve,
97 * which is to end the last Inquiry session.
99 if (rp->status == 0x0c && !test_bit(HCI_INQUIRY, &hdev->flags)) {
100 bt_dev_warn(hdev, "Ignoring error of Inquiry Cancel command");
107 clear_bit(HCI_INQUIRY, &hdev->flags);
108 smp_mb__after_atomic(); /* wake_up_bit advises about this barrier */
109 wake_up_bit(&hdev->flags, HCI_INQUIRY);
112 /* Set discovery state to stopped if we're not doing LE active
115 if (!hci_dev_test_flag(hdev, HCI_LE_SCAN) ||
116 hdev->le_scan_type != LE_SCAN_ACTIVE)
117 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
118 hci_dev_unlock(hdev);
120 hci_conn_check_pending(hdev);
125 static u8 hci_cc_periodic_inq(struct hci_dev *hdev, void *data,
128 struct hci_ev_status *rp = data;
130 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
135 hci_dev_set_flag(hdev, HCI_PERIODIC_INQ);
140 static u8 hci_cc_exit_periodic_inq(struct hci_dev *hdev, void *data,
143 struct hci_ev_status *rp = data;
145 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
150 hci_dev_clear_flag(hdev, HCI_PERIODIC_INQ);
152 hci_conn_check_pending(hdev);
157 static u8 hci_cc_remote_name_req_cancel(struct hci_dev *hdev, void *data,
160 struct hci_ev_status *rp = data;
162 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
167 static u8 hci_cc_role_discovery(struct hci_dev *hdev, void *data,
170 struct hci_rp_role_discovery *rp = data;
171 struct hci_conn *conn;
173 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
180 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
182 conn->role = rp->role;
184 hci_dev_unlock(hdev);
189 static u8 hci_cc_read_link_policy(struct hci_dev *hdev, void *data,
192 struct hci_rp_read_link_policy *rp = data;
193 struct hci_conn *conn;
195 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
202 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
204 conn->link_policy = __le16_to_cpu(rp->policy);
206 hci_dev_unlock(hdev);
211 static u8 hci_cc_write_link_policy(struct hci_dev *hdev, void *data,
214 struct hci_rp_write_link_policy *rp = data;
215 struct hci_conn *conn;
218 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
223 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
229 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
231 conn->link_policy = get_unaligned_le16(sent + 2);
233 hci_dev_unlock(hdev);
238 static u8 hci_cc_read_def_link_policy(struct hci_dev *hdev, void *data,
241 struct hci_rp_read_def_link_policy *rp = data;
243 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
248 hdev->link_policy = __le16_to_cpu(rp->policy);
253 static u8 hci_cc_write_def_link_policy(struct hci_dev *hdev, void *data,
256 struct hci_ev_status *rp = data;
259 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
264 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
268 hdev->link_policy = get_unaligned_le16(sent);
273 static u8 hci_cc_reset(struct hci_dev *hdev, void *data, struct sk_buff *skb)
275 struct hci_ev_status *rp = data;
277 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
279 clear_bit(HCI_RESET, &hdev->flags);
284 /* Reset all non-persistent flags */
285 hci_dev_clear_volatile_flags(hdev);
287 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
289 hdev->inq_tx_power = HCI_TX_POWER_INVALID;
290 hdev->adv_tx_power = HCI_TX_POWER_INVALID;
292 memset(hdev->adv_data, 0, sizeof(hdev->adv_data));
293 hdev->adv_data_len = 0;
295 memset(hdev->scan_rsp_data, 0, sizeof(hdev->scan_rsp_data));
296 hdev->scan_rsp_data_len = 0;
298 hdev->le_scan_type = LE_SCAN_PASSIVE;
300 hdev->ssp_debug_mode = 0;
302 hci_bdaddr_list_clear(&hdev->le_accept_list);
303 hci_bdaddr_list_clear(&hdev->le_resolv_list);
308 static u8 hci_cc_read_stored_link_key(struct hci_dev *hdev, void *data,
311 struct hci_rp_read_stored_link_key *rp = data;
312 struct hci_cp_read_stored_link_key *sent;
314 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
316 sent = hci_sent_cmd_data(hdev, HCI_OP_READ_STORED_LINK_KEY);
320 if (!rp->status && sent->read_all == 0x01) {
321 hdev->stored_max_keys = le16_to_cpu(rp->max_keys);
322 hdev->stored_num_keys = le16_to_cpu(rp->num_keys);
328 static u8 hci_cc_delete_stored_link_key(struct hci_dev *hdev, void *data,
331 struct hci_rp_delete_stored_link_key *rp = data;
334 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
339 num_keys = le16_to_cpu(rp->num_keys);
341 if (num_keys <= hdev->stored_num_keys)
342 hdev->stored_num_keys -= num_keys;
344 hdev->stored_num_keys = 0;
349 static u8 hci_cc_write_local_name(struct hci_dev *hdev, void *data,
352 struct hci_ev_status *rp = data;
355 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
357 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
363 if (hci_dev_test_flag(hdev, HCI_MGMT))
364 mgmt_set_local_name_complete(hdev, sent, rp->status);
365 else if (!rp->status)
366 memcpy(hdev->dev_name, sent, HCI_MAX_NAME_LENGTH);
368 hci_dev_unlock(hdev);
373 static u8 hci_cc_read_local_name(struct hci_dev *hdev, void *data,
376 struct hci_rp_read_local_name *rp = data;
378 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
383 if (hci_dev_test_flag(hdev, HCI_SETUP) ||
384 hci_dev_test_flag(hdev, HCI_CONFIG))
385 memcpy(hdev->dev_name, rp->name, HCI_MAX_NAME_LENGTH);
390 static u8 hci_cc_write_auth_enable(struct hci_dev *hdev, void *data,
393 struct hci_ev_status *rp = data;
396 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
398 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
405 __u8 param = *((__u8 *) sent);
407 if (param == AUTH_ENABLED)
408 set_bit(HCI_AUTH, &hdev->flags);
410 clear_bit(HCI_AUTH, &hdev->flags);
413 if (hci_dev_test_flag(hdev, HCI_MGMT))
414 mgmt_auth_enable_complete(hdev, rp->status);
416 hci_dev_unlock(hdev);
421 static u8 hci_cc_write_encrypt_mode(struct hci_dev *hdev, void *data,
424 struct hci_ev_status *rp = data;
428 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
433 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
437 param = *((__u8 *) sent);
440 set_bit(HCI_ENCRYPT, &hdev->flags);
442 clear_bit(HCI_ENCRYPT, &hdev->flags);
447 static u8 hci_cc_write_scan_enable(struct hci_dev *hdev, void *data,
450 struct hci_ev_status *rp = data;
454 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
456 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
460 param = *((__u8 *) sent);
465 hdev->discov_timeout = 0;
469 if (param & SCAN_INQUIRY)
470 set_bit(HCI_ISCAN, &hdev->flags);
472 clear_bit(HCI_ISCAN, &hdev->flags);
474 if (param & SCAN_PAGE)
475 set_bit(HCI_PSCAN, &hdev->flags);
477 clear_bit(HCI_PSCAN, &hdev->flags);
480 hci_dev_unlock(hdev);
485 static u8 hci_cc_set_event_filter(struct hci_dev *hdev, void *data,
488 struct hci_ev_status *rp = data;
489 struct hci_cp_set_event_filter *cp;
492 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
497 sent = hci_sent_cmd_data(hdev, HCI_OP_SET_EVENT_FLT);
501 cp = (struct hci_cp_set_event_filter *)sent;
503 if (cp->flt_type == HCI_FLT_CLEAR_ALL)
504 hci_dev_clear_flag(hdev, HCI_EVENT_FILTER_CONFIGURED);
506 hci_dev_set_flag(hdev, HCI_EVENT_FILTER_CONFIGURED);
511 static u8 hci_cc_read_class_of_dev(struct hci_dev *hdev, void *data,
514 struct hci_rp_read_class_of_dev *rp = data;
516 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
521 memcpy(hdev->dev_class, rp->dev_class, 3);
523 bt_dev_dbg(hdev, "class 0x%.2x%.2x%.2x", hdev->dev_class[2],
524 hdev->dev_class[1], hdev->dev_class[0]);
529 static u8 hci_cc_write_class_of_dev(struct hci_dev *hdev, void *data,
532 struct hci_ev_status *rp = data;
535 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
537 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
544 memcpy(hdev->dev_class, sent, 3);
546 if (hci_dev_test_flag(hdev, HCI_MGMT))
547 mgmt_set_class_of_dev_complete(hdev, sent, rp->status);
549 hci_dev_unlock(hdev);
554 static u8 hci_cc_read_voice_setting(struct hci_dev *hdev, void *data,
557 struct hci_rp_read_voice_setting *rp = data;
560 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
565 setting = __le16_to_cpu(rp->voice_setting);
567 if (hdev->voice_setting == setting)
570 hdev->voice_setting = setting;
572 bt_dev_dbg(hdev, "voice setting 0x%4.4x", setting);
575 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
580 static u8 hci_cc_write_voice_setting(struct hci_dev *hdev, void *data,
583 struct hci_ev_status *rp = data;
587 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
592 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
596 setting = get_unaligned_le16(sent);
598 if (hdev->voice_setting == setting)
601 hdev->voice_setting = setting;
603 bt_dev_dbg(hdev, "voice setting 0x%4.4x", setting);
606 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
611 static u8 hci_cc_read_num_supported_iac(struct hci_dev *hdev, void *data,
614 struct hci_rp_read_num_supported_iac *rp = data;
616 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
621 hdev->num_iac = rp->num_iac;
623 bt_dev_dbg(hdev, "num iac %d", hdev->num_iac);
628 static u8 hci_cc_write_ssp_mode(struct hci_dev *hdev, void *data,
631 struct hci_ev_status *rp = data;
632 struct hci_cp_write_ssp_mode *sent;
634 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
636 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
644 hdev->features[1][0] |= LMP_HOST_SSP;
646 hdev->features[1][0] &= ~LMP_HOST_SSP;
651 hci_dev_set_flag(hdev, HCI_SSP_ENABLED);
653 hci_dev_clear_flag(hdev, HCI_SSP_ENABLED);
656 hci_dev_unlock(hdev);
661 static u8 hci_cc_write_sc_support(struct hci_dev *hdev, void *data,
664 struct hci_ev_status *rp = data;
665 struct hci_cp_write_sc_support *sent;
667 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
669 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SC_SUPPORT);
677 hdev->features[1][0] |= LMP_HOST_SC;
679 hdev->features[1][0] &= ~LMP_HOST_SC;
682 if (!hci_dev_test_flag(hdev, HCI_MGMT) && !rp->status) {
684 hci_dev_set_flag(hdev, HCI_SC_ENABLED);
686 hci_dev_clear_flag(hdev, HCI_SC_ENABLED);
689 hci_dev_unlock(hdev);
694 static u8 hci_cc_read_local_version(struct hci_dev *hdev, void *data,
697 struct hci_rp_read_local_version *rp = data;
699 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
704 if (hci_dev_test_flag(hdev, HCI_SETUP) ||
705 hci_dev_test_flag(hdev, HCI_CONFIG)) {
706 hdev->hci_ver = rp->hci_ver;
707 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
708 hdev->lmp_ver = rp->lmp_ver;
709 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
710 hdev->lmp_subver = __le16_to_cpu(rp->lmp_subver);
716 static u8 hci_cc_read_enc_key_size(struct hci_dev *hdev, void *data,
719 struct hci_rp_read_enc_key_size *rp = data;
720 struct hci_conn *conn;
722 u8 status = rp->status;
724 bt_dev_dbg(hdev, "status 0x%2.2x", status);
726 handle = le16_to_cpu(rp->handle);
730 conn = hci_conn_hash_lookup_handle(hdev, handle);
736 /* While unexpected, the read_enc_key_size command may fail. The most
737 * secure approach is to then assume the key size is 0 to force a
741 bt_dev_err(hdev, "failed to read key size for handle %u",
743 conn->enc_key_size = 0;
745 conn->enc_key_size = rp->key_size;
749 hci_encrypt_cfm(conn, 0);
752 hci_dev_unlock(hdev);
757 static u8 hci_cc_read_local_commands(struct hci_dev *hdev, void *data,
760 struct hci_rp_read_local_commands *rp = data;
762 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
767 if (hci_dev_test_flag(hdev, HCI_SETUP) ||
768 hci_dev_test_flag(hdev, HCI_CONFIG))
769 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
774 static u8 hci_cc_read_auth_payload_timeout(struct hci_dev *hdev, void *data,
777 struct hci_rp_read_auth_payload_to *rp = data;
778 struct hci_conn *conn;
780 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
787 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
789 conn->auth_payload_timeout = __le16_to_cpu(rp->timeout);
791 hci_dev_unlock(hdev);
796 static u8 hci_cc_write_auth_payload_timeout(struct hci_dev *hdev, void *data,
799 struct hci_rp_write_auth_payload_to *rp = data;
800 struct hci_conn *conn;
803 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
805 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_PAYLOAD_TO);
811 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
818 conn->auth_payload_timeout = get_unaligned_le16(sent + 2);
820 hci_encrypt_cfm(conn, 0);
823 hci_dev_unlock(hdev);
828 static u8 hci_cc_read_local_features(struct hci_dev *hdev, void *data,
831 struct hci_rp_read_local_features *rp = data;
833 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
838 memcpy(hdev->features, rp->features, 8);
840 /* Adjust default settings according to features
841 * supported by device. */
843 if (hdev->features[0][0] & LMP_3SLOT)
844 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
846 if (hdev->features[0][0] & LMP_5SLOT)
847 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
849 if (hdev->features[0][1] & LMP_HV2) {
850 hdev->pkt_type |= (HCI_HV2);
851 hdev->esco_type |= (ESCO_HV2);
854 if (hdev->features[0][1] & LMP_HV3) {
855 hdev->pkt_type |= (HCI_HV3);
856 hdev->esco_type |= (ESCO_HV3);
859 if (lmp_esco_capable(hdev))
860 hdev->esco_type |= (ESCO_EV3);
862 if (hdev->features[0][4] & LMP_EV4)
863 hdev->esco_type |= (ESCO_EV4);
865 if (hdev->features[0][4] & LMP_EV5)
866 hdev->esco_type |= (ESCO_EV5);
868 if (hdev->features[0][5] & LMP_EDR_ESCO_2M)
869 hdev->esco_type |= (ESCO_2EV3);
871 if (hdev->features[0][5] & LMP_EDR_ESCO_3M)
872 hdev->esco_type |= (ESCO_3EV3);
874 if (hdev->features[0][5] & LMP_EDR_3S_ESCO)
875 hdev->esco_type |= (ESCO_2EV5 | ESCO_3EV5);
880 static u8 hci_cc_read_local_ext_features(struct hci_dev *hdev, void *data,
883 struct hci_rp_read_local_ext_features *rp = data;
885 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
890 if (hdev->max_page < rp->max_page) {
891 if (test_bit(HCI_QUIRK_BROKEN_LOCAL_EXT_FEATURES_PAGE_2,
893 bt_dev_warn(hdev, "broken local ext features page 2");
895 hdev->max_page = rp->max_page;
898 if (rp->page < HCI_MAX_PAGES)
899 memcpy(hdev->features[rp->page], rp->features, 8);
904 static u8 hci_cc_read_flow_control_mode(struct hci_dev *hdev, void *data,
907 struct hci_rp_read_flow_control_mode *rp = data;
909 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
914 hdev->flow_ctl_mode = rp->mode;
919 static u8 hci_cc_read_buffer_size(struct hci_dev *hdev, void *data,
922 struct hci_rp_read_buffer_size *rp = data;
924 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
929 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
930 hdev->sco_mtu = rp->sco_mtu;
931 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
932 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
934 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
939 hdev->acl_cnt = hdev->acl_pkts;
940 hdev->sco_cnt = hdev->sco_pkts;
942 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name, hdev->acl_mtu,
943 hdev->acl_pkts, hdev->sco_mtu, hdev->sco_pkts);
948 static u8 hci_cc_read_bd_addr(struct hci_dev *hdev, void *data,
951 struct hci_rp_read_bd_addr *rp = data;
953 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
958 if (test_bit(HCI_INIT, &hdev->flags))
959 bacpy(&hdev->bdaddr, &rp->bdaddr);
961 if (hci_dev_test_flag(hdev, HCI_SETUP))
962 bacpy(&hdev->setup_addr, &rp->bdaddr);
967 static u8 hci_cc_read_local_pairing_opts(struct hci_dev *hdev, void *data,
970 struct hci_rp_read_local_pairing_opts *rp = data;
972 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
977 if (hci_dev_test_flag(hdev, HCI_SETUP) ||
978 hci_dev_test_flag(hdev, HCI_CONFIG)) {
979 hdev->pairing_opts = rp->pairing_opts;
980 hdev->max_enc_key_size = rp->max_key_size;
986 static u8 hci_cc_read_page_scan_activity(struct hci_dev *hdev, void *data,
989 struct hci_rp_read_page_scan_activity *rp = data;
991 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
996 if (test_bit(HCI_INIT, &hdev->flags)) {
997 hdev->page_scan_interval = __le16_to_cpu(rp->interval);
998 hdev->page_scan_window = __le16_to_cpu(rp->window);
1004 static u8 hci_cc_write_page_scan_activity(struct hci_dev *hdev, void *data,
1005 struct sk_buff *skb)
1007 struct hci_ev_status *rp = data;
1008 struct hci_cp_write_page_scan_activity *sent;
1010 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1015 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_PAGE_SCAN_ACTIVITY);
1019 hdev->page_scan_interval = __le16_to_cpu(sent->interval);
1020 hdev->page_scan_window = __le16_to_cpu(sent->window);
1025 static u8 hci_cc_read_page_scan_type(struct hci_dev *hdev, void *data,
1026 struct sk_buff *skb)
1028 struct hci_rp_read_page_scan_type *rp = data;
1030 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1035 if (test_bit(HCI_INIT, &hdev->flags))
1036 hdev->page_scan_type = rp->type;
1041 static u8 hci_cc_write_page_scan_type(struct hci_dev *hdev, void *data,
1042 struct sk_buff *skb)
1044 struct hci_ev_status *rp = data;
1047 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1052 type = hci_sent_cmd_data(hdev, HCI_OP_WRITE_PAGE_SCAN_TYPE);
1054 hdev->page_scan_type = *type;
1059 static u8 hci_cc_read_data_block_size(struct hci_dev *hdev, void *data,
1060 struct sk_buff *skb)
1062 struct hci_rp_read_data_block_size *rp = data;
1064 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1069 hdev->block_mtu = __le16_to_cpu(rp->max_acl_len);
1070 hdev->block_len = __le16_to_cpu(rp->block_len);
1071 hdev->num_blocks = __le16_to_cpu(rp->num_blocks);
1073 hdev->block_cnt = hdev->num_blocks;
1075 BT_DBG("%s blk mtu %d cnt %d len %d", hdev->name, hdev->block_mtu,
1076 hdev->block_cnt, hdev->block_len);
1081 static u8 hci_cc_read_clock(struct hci_dev *hdev, void *data,
1082 struct sk_buff *skb)
1084 struct hci_rp_read_clock *rp = data;
1085 struct hci_cp_read_clock *cp;
1086 struct hci_conn *conn;
1088 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1095 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_CLOCK);
1099 if (cp->which == 0x00) {
1100 hdev->clock = le32_to_cpu(rp->clock);
1104 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
1106 conn->clock = le32_to_cpu(rp->clock);
1107 conn->clock_accuracy = le16_to_cpu(rp->accuracy);
1111 hci_dev_unlock(hdev);
1115 static u8 hci_cc_read_local_amp_info(struct hci_dev *hdev, void *data,
1116 struct sk_buff *skb)
1118 struct hci_rp_read_local_amp_info *rp = data;
1120 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1125 hdev->amp_status = rp->amp_status;
1126 hdev->amp_total_bw = __le32_to_cpu(rp->total_bw);
1127 hdev->amp_max_bw = __le32_to_cpu(rp->max_bw);
1128 hdev->amp_min_latency = __le32_to_cpu(rp->min_latency);
1129 hdev->amp_max_pdu = __le32_to_cpu(rp->max_pdu);
1130 hdev->amp_type = rp->amp_type;
1131 hdev->amp_pal_cap = __le16_to_cpu(rp->pal_cap);
1132 hdev->amp_assoc_size = __le16_to_cpu(rp->max_assoc_size);
1133 hdev->amp_be_flush_to = __le32_to_cpu(rp->be_flush_to);
1134 hdev->amp_max_flush_to = __le32_to_cpu(rp->max_flush_to);
1139 static u8 hci_cc_read_inq_rsp_tx_power(struct hci_dev *hdev, void *data,
1140 struct sk_buff *skb)
1142 struct hci_rp_read_inq_rsp_tx_power *rp = data;
1144 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1149 hdev->inq_tx_power = rp->tx_power;
1154 static u8 hci_cc_read_def_err_data_reporting(struct hci_dev *hdev, void *data,
1155 struct sk_buff *skb)
1157 struct hci_rp_read_def_err_data_reporting *rp = data;
1159 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1164 hdev->err_data_reporting = rp->err_data_reporting;
1169 static u8 hci_cc_write_def_err_data_reporting(struct hci_dev *hdev, void *data,
1170 struct sk_buff *skb)
1172 struct hci_ev_status *rp = data;
1173 struct hci_cp_write_def_err_data_reporting *cp;
1175 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1180 cp = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_ERR_DATA_REPORTING);
1184 hdev->err_data_reporting = cp->err_data_reporting;
1189 static u8 hci_cc_pin_code_reply(struct hci_dev *hdev, void *data,
1190 struct sk_buff *skb)
1192 struct hci_rp_pin_code_reply *rp = data;
1193 struct hci_cp_pin_code_reply *cp;
1194 struct hci_conn *conn;
1196 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1200 if (hci_dev_test_flag(hdev, HCI_MGMT))
1201 mgmt_pin_code_reply_complete(hdev, &rp->bdaddr, rp->status);
1206 cp = hci_sent_cmd_data(hdev, HCI_OP_PIN_CODE_REPLY);
1210 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
1212 conn->pin_length = cp->pin_len;
1215 hci_dev_unlock(hdev);
1219 static u8 hci_cc_pin_code_neg_reply(struct hci_dev *hdev, void *data,
1220 struct sk_buff *skb)
1222 struct hci_rp_pin_code_neg_reply *rp = data;
1224 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1228 if (hci_dev_test_flag(hdev, HCI_MGMT))
1229 mgmt_pin_code_neg_reply_complete(hdev, &rp->bdaddr,
1232 hci_dev_unlock(hdev);
1237 static u8 hci_cc_le_read_buffer_size(struct hci_dev *hdev, void *data,
1238 struct sk_buff *skb)
1240 struct hci_rp_le_read_buffer_size *rp = data;
1242 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1247 hdev->le_mtu = __le16_to_cpu(rp->le_mtu);
1248 hdev->le_pkts = rp->le_max_pkt;
1250 hdev->le_cnt = hdev->le_pkts;
1252 BT_DBG("%s le mtu %d:%d", hdev->name, hdev->le_mtu, hdev->le_pkts);
1257 static u8 hci_cc_le_read_local_features(struct hci_dev *hdev, void *data,
1258 struct sk_buff *skb)
1260 struct hci_rp_le_read_local_features *rp = data;
1262 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1267 memcpy(hdev->le_features, rp->features, 8);
1272 static u8 hci_cc_le_read_adv_tx_power(struct hci_dev *hdev, void *data,
1273 struct sk_buff *skb)
1275 struct hci_rp_le_read_adv_tx_power *rp = data;
1277 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1282 hdev->adv_tx_power = rp->tx_power;
1287 static u8 hci_cc_user_confirm_reply(struct hci_dev *hdev, void *data,
1288 struct sk_buff *skb)
1290 struct hci_rp_user_confirm_reply *rp = data;
1292 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1296 if (hci_dev_test_flag(hdev, HCI_MGMT))
1297 mgmt_user_confirm_reply_complete(hdev, &rp->bdaddr, ACL_LINK, 0,
1300 hci_dev_unlock(hdev);
1305 static u8 hci_cc_user_confirm_neg_reply(struct hci_dev *hdev, void *data,
1306 struct sk_buff *skb)
1308 struct hci_rp_user_confirm_reply *rp = data;
1310 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1314 if (hci_dev_test_flag(hdev, HCI_MGMT))
1315 mgmt_user_confirm_neg_reply_complete(hdev, &rp->bdaddr,
1316 ACL_LINK, 0, rp->status);
1318 hci_dev_unlock(hdev);
1323 static u8 hci_cc_user_passkey_reply(struct hci_dev *hdev, void *data,
1324 struct sk_buff *skb)
1326 struct hci_rp_user_confirm_reply *rp = data;
1328 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1332 if (hci_dev_test_flag(hdev, HCI_MGMT))
1333 mgmt_user_passkey_reply_complete(hdev, &rp->bdaddr, ACL_LINK,
1336 hci_dev_unlock(hdev);
1341 static u8 hci_cc_user_passkey_neg_reply(struct hci_dev *hdev, void *data,
1342 struct sk_buff *skb)
1344 struct hci_rp_user_confirm_reply *rp = data;
1346 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1350 if (hci_dev_test_flag(hdev, HCI_MGMT))
1351 mgmt_user_passkey_neg_reply_complete(hdev, &rp->bdaddr,
1352 ACL_LINK, 0, rp->status);
1354 hci_dev_unlock(hdev);
1359 static u8 hci_cc_read_local_oob_data(struct hci_dev *hdev, void *data,
1360 struct sk_buff *skb)
1362 struct hci_rp_read_local_oob_data *rp = data;
1364 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1369 static u8 hci_cc_read_local_oob_ext_data(struct hci_dev *hdev, void *data,
1370 struct sk_buff *skb)
1372 struct hci_rp_read_local_oob_ext_data *rp = data;
1374 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1379 static u8 hci_cc_le_set_random_addr(struct hci_dev *hdev, void *data,
1380 struct sk_buff *skb)
1382 struct hci_ev_status *rp = data;
1385 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1390 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_RANDOM_ADDR);
1396 bacpy(&hdev->random_addr, sent);
1398 if (!bacmp(&hdev->rpa, sent)) {
1399 hci_dev_clear_flag(hdev, HCI_RPA_EXPIRED);
1400 queue_delayed_work(hdev->workqueue, &hdev->rpa_expired,
1401 secs_to_jiffies(hdev->rpa_timeout));
1404 hci_dev_unlock(hdev);
1409 static u8 hci_cc_le_set_default_phy(struct hci_dev *hdev, void *data,
1410 struct sk_buff *skb)
1412 struct hci_ev_status *rp = data;
1413 struct hci_cp_le_set_default_phy *cp;
1415 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1420 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_DEFAULT_PHY);
1426 hdev->le_tx_def_phys = cp->tx_phys;
1427 hdev->le_rx_def_phys = cp->rx_phys;
1429 hci_dev_unlock(hdev);
1434 static u8 hci_cc_le_set_adv_set_random_addr(struct hci_dev *hdev, void *data,
1435 struct sk_buff *skb)
1437 struct hci_ev_status *rp = data;
1438 struct hci_cp_le_set_adv_set_rand_addr *cp;
1439 struct adv_info *adv;
1441 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1446 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_ADV_SET_RAND_ADDR);
1447 /* Update only in case the adv instance since handle 0x00 shall be using
1448 * HCI_OP_LE_SET_RANDOM_ADDR since that allows both extended and
1449 * non-extended adverting.
1451 if (!cp || !cp->handle)
1456 adv = hci_find_adv_instance(hdev, cp->handle);
1458 bacpy(&adv->random_addr, &cp->bdaddr);
1459 if (!bacmp(&hdev->rpa, &cp->bdaddr)) {
1460 adv->rpa_expired = false;
1461 queue_delayed_work(hdev->workqueue,
1462 &adv->rpa_expired_cb,
1463 secs_to_jiffies(hdev->rpa_timeout));
1467 hci_dev_unlock(hdev);
1472 static u8 hci_cc_le_remove_adv_set(struct hci_dev *hdev, void *data,
1473 struct sk_buff *skb)
1475 struct hci_ev_status *rp = data;
1479 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1484 instance = hci_sent_cmd_data(hdev, HCI_OP_LE_REMOVE_ADV_SET);
1490 err = hci_remove_adv_instance(hdev, *instance);
1492 mgmt_advertising_removed(hci_skb_sk(hdev->sent_cmd), hdev,
1495 hci_dev_unlock(hdev);
1500 static u8 hci_cc_le_clear_adv_sets(struct hci_dev *hdev, void *data,
1501 struct sk_buff *skb)
1503 struct hci_ev_status *rp = data;
1504 struct adv_info *adv, *n;
1507 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1512 if (!hci_sent_cmd_data(hdev, HCI_OP_LE_CLEAR_ADV_SETS))
1517 list_for_each_entry_safe(adv, n, &hdev->adv_instances, list) {
1518 u8 instance = adv->instance;
1520 err = hci_remove_adv_instance(hdev, instance);
1522 mgmt_advertising_removed(hci_skb_sk(hdev->sent_cmd),
1526 hci_dev_unlock(hdev);
1531 static u8 hci_cc_le_read_transmit_power(struct hci_dev *hdev, void *data,
1532 struct sk_buff *skb)
1534 struct hci_rp_le_read_transmit_power *rp = data;
1536 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1541 hdev->min_le_tx_power = rp->min_le_tx_power;
1542 hdev->max_le_tx_power = rp->max_le_tx_power;
1547 static u8 hci_cc_le_set_privacy_mode(struct hci_dev *hdev, void *data,
1548 struct sk_buff *skb)
1550 struct hci_ev_status *rp = data;
1551 struct hci_cp_le_set_privacy_mode *cp;
1552 struct hci_conn_params *params;
1554 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1559 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_PRIVACY_MODE);
1565 params = hci_conn_params_lookup(hdev, &cp->bdaddr, cp->bdaddr_type);
1567 WRITE_ONCE(params->privacy_mode, cp->mode);
1569 hci_dev_unlock(hdev);
1574 static u8 hci_cc_le_set_adv_enable(struct hci_dev *hdev, void *data,
1575 struct sk_buff *skb)
1577 struct hci_ev_status *rp = data;
1580 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1585 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_ADV_ENABLE);
1591 /* If we're doing connection initiation as peripheral. Set a
1592 * timeout in case something goes wrong.
1595 struct hci_conn *conn;
1597 hci_dev_set_flag(hdev, HCI_LE_ADV);
1599 conn = hci_lookup_le_connect(hdev);
1601 queue_delayed_work(hdev->workqueue,
1602 &conn->le_conn_timeout,
1603 conn->conn_timeout);
1605 hci_dev_clear_flag(hdev, HCI_LE_ADV);
1608 hci_dev_unlock(hdev);
1613 static u8 hci_cc_le_set_ext_adv_enable(struct hci_dev *hdev, void *data,
1614 struct sk_buff *skb)
1616 struct hci_cp_le_set_ext_adv_enable *cp;
1617 struct hci_cp_ext_adv_set *set;
1618 struct adv_info *adv = NULL, *n;
1619 struct hci_ev_status *rp = data;
1621 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1626 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_EXT_ADV_ENABLE);
1630 set = (void *)cp->data;
1634 if (cp->num_of_sets)
1635 adv = hci_find_adv_instance(hdev, set->handle);
1638 struct hci_conn *conn;
1640 hci_dev_set_flag(hdev, HCI_LE_ADV);
1642 if (adv && !adv->periodic)
1643 adv->enabled = true;
1645 conn = hci_lookup_le_connect(hdev);
1647 queue_delayed_work(hdev->workqueue,
1648 &conn->le_conn_timeout,
1649 conn->conn_timeout);
1651 if (cp->num_of_sets) {
1653 adv->enabled = false;
1655 /* If just one instance was disabled check if there are
1656 * any other instance enabled before clearing HCI_LE_ADV
1658 list_for_each_entry_safe(adv, n, &hdev->adv_instances,
1664 /* All instances shall be considered disabled */
1665 list_for_each_entry_safe(adv, n, &hdev->adv_instances,
1667 adv->enabled = false;
1670 hci_dev_clear_flag(hdev, HCI_LE_ADV);
1674 hci_dev_unlock(hdev);
1678 static u8 hci_cc_le_set_scan_param(struct hci_dev *hdev, void *data,
1679 struct sk_buff *skb)
1681 struct hci_cp_le_set_scan_param *cp;
1682 struct hci_ev_status *rp = data;
1684 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1689 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_SCAN_PARAM);
1695 hdev->le_scan_type = cp->type;
1697 hci_dev_unlock(hdev);
1702 static u8 hci_cc_le_set_ext_scan_param(struct hci_dev *hdev, void *data,
1703 struct sk_buff *skb)
1705 struct hci_cp_le_set_ext_scan_params *cp;
1706 struct hci_ev_status *rp = data;
1707 struct hci_cp_le_scan_phy_params *phy_param;
1709 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1714 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_EXT_SCAN_PARAMS);
1718 phy_param = (void *)cp->data;
1722 hdev->le_scan_type = phy_param->type;
1724 hci_dev_unlock(hdev);
1729 static bool has_pending_adv_report(struct hci_dev *hdev)
1731 struct discovery_state *d = &hdev->discovery;
1733 return bacmp(&d->last_adv_addr, BDADDR_ANY);
1736 static void clear_pending_adv_report(struct hci_dev *hdev)
1738 struct discovery_state *d = &hdev->discovery;
1740 bacpy(&d->last_adv_addr, BDADDR_ANY);
1741 d->last_adv_data_len = 0;
1744 static void store_pending_adv_report(struct hci_dev *hdev, bdaddr_t *bdaddr,
1745 u8 bdaddr_type, s8 rssi, u32 flags,
1748 struct discovery_state *d = &hdev->discovery;
1750 if (len > max_adv_len(hdev))
1753 bacpy(&d->last_adv_addr, bdaddr);
1754 d->last_adv_addr_type = bdaddr_type;
1755 d->last_adv_rssi = rssi;
1756 d->last_adv_flags = flags;
1757 memcpy(d->last_adv_data, data, len);
1758 d->last_adv_data_len = len;
1761 static void le_set_scan_enable_complete(struct hci_dev *hdev, u8 enable)
1766 case LE_SCAN_ENABLE:
1767 hci_dev_set_flag(hdev, HCI_LE_SCAN);
1768 if (hdev->le_scan_type == LE_SCAN_ACTIVE)
1769 clear_pending_adv_report(hdev);
1770 if (hci_dev_test_flag(hdev, HCI_MESH))
1771 hci_discovery_set_state(hdev, DISCOVERY_FINDING);
1774 case LE_SCAN_DISABLE:
1775 /* We do this here instead of when setting DISCOVERY_STOPPED
1776 * since the latter would potentially require waiting for
1777 * inquiry to stop too.
1779 if (has_pending_adv_report(hdev)) {
1780 struct discovery_state *d = &hdev->discovery;
1782 mgmt_device_found(hdev, &d->last_adv_addr, LE_LINK,
1783 d->last_adv_addr_type, NULL,
1784 d->last_adv_rssi, d->last_adv_flags,
1786 d->last_adv_data_len, NULL, 0, 0);
1789 /* Cancel this timer so that we don't try to disable scanning
1790 * when it's already disabled.
1792 cancel_delayed_work(&hdev->le_scan_disable);
1794 hci_dev_clear_flag(hdev, HCI_LE_SCAN);
1796 /* The HCI_LE_SCAN_INTERRUPTED flag indicates that we
1797 * interrupted scanning due to a connect request. Mark
1798 * therefore discovery as stopped.
1800 if (hci_dev_test_and_clear_flag(hdev, HCI_LE_SCAN_INTERRUPTED))
1801 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1802 else if (!hci_dev_test_flag(hdev, HCI_LE_ADV) &&
1803 hdev->discovery.state == DISCOVERY_FINDING)
1804 queue_work(hdev->workqueue, &hdev->reenable_adv_work);
1809 bt_dev_err(hdev, "use of reserved LE_Scan_Enable param %d",
1814 hci_dev_unlock(hdev);
1817 static u8 hci_cc_le_set_scan_enable(struct hci_dev *hdev, void *data,
1818 struct sk_buff *skb)
1820 struct hci_cp_le_set_scan_enable *cp;
1821 struct hci_ev_status *rp = data;
1823 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1828 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_SCAN_ENABLE);
1832 le_set_scan_enable_complete(hdev, cp->enable);
1837 static u8 hci_cc_le_set_ext_scan_enable(struct hci_dev *hdev, void *data,
1838 struct sk_buff *skb)
1840 struct hci_cp_le_set_ext_scan_enable *cp;
1841 struct hci_ev_status *rp = data;
1843 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1848 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_EXT_SCAN_ENABLE);
1852 le_set_scan_enable_complete(hdev, cp->enable);
1857 static u8 hci_cc_le_read_num_adv_sets(struct hci_dev *hdev, void *data,
1858 struct sk_buff *skb)
1860 struct hci_rp_le_read_num_supported_adv_sets *rp = data;
1862 bt_dev_dbg(hdev, "status 0x%2.2x No of Adv sets %u", rp->status,
1868 hdev->le_num_of_adv_sets = rp->num_of_sets;
1873 static u8 hci_cc_le_read_accept_list_size(struct hci_dev *hdev, void *data,
1874 struct sk_buff *skb)
1876 struct hci_rp_le_read_accept_list_size *rp = data;
1878 bt_dev_dbg(hdev, "status 0x%2.2x size %u", rp->status, rp->size);
1883 hdev->le_accept_list_size = rp->size;
1888 static u8 hci_cc_le_clear_accept_list(struct hci_dev *hdev, void *data,
1889 struct sk_buff *skb)
1891 struct hci_ev_status *rp = data;
1893 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1899 hci_bdaddr_list_clear(&hdev->le_accept_list);
1900 hci_dev_unlock(hdev);
1905 static u8 hci_cc_le_add_to_accept_list(struct hci_dev *hdev, void *data,
1906 struct sk_buff *skb)
1908 struct hci_cp_le_add_to_accept_list *sent;
1909 struct hci_ev_status *rp = data;
1911 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1916 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_ADD_TO_ACCEPT_LIST);
1921 hci_bdaddr_list_add(&hdev->le_accept_list, &sent->bdaddr,
1923 hci_dev_unlock(hdev);
1928 static u8 hci_cc_le_del_from_accept_list(struct hci_dev *hdev, void *data,
1929 struct sk_buff *skb)
1931 struct hci_cp_le_del_from_accept_list *sent;
1932 struct hci_ev_status *rp = data;
1934 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1939 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_DEL_FROM_ACCEPT_LIST);
1944 hci_bdaddr_list_del(&hdev->le_accept_list, &sent->bdaddr,
1946 hci_dev_unlock(hdev);
1951 static u8 hci_cc_le_read_supported_states(struct hci_dev *hdev, void *data,
1952 struct sk_buff *skb)
1954 struct hci_rp_le_read_supported_states *rp = data;
1956 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1961 memcpy(hdev->le_states, rp->le_states, 8);
1966 static u8 hci_cc_le_read_def_data_len(struct hci_dev *hdev, void *data,
1967 struct sk_buff *skb)
1969 struct hci_rp_le_read_def_data_len *rp = data;
1971 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1976 hdev->le_def_tx_len = le16_to_cpu(rp->tx_len);
1977 hdev->le_def_tx_time = le16_to_cpu(rp->tx_time);
1982 static u8 hci_cc_le_write_def_data_len(struct hci_dev *hdev, void *data,
1983 struct sk_buff *skb)
1985 struct hci_cp_le_write_def_data_len *sent;
1986 struct hci_ev_status *rp = data;
1988 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
1993 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_WRITE_DEF_DATA_LEN);
1997 hdev->le_def_tx_len = le16_to_cpu(sent->tx_len);
1998 hdev->le_def_tx_time = le16_to_cpu(sent->tx_time);
2003 static u8 hci_cc_le_add_to_resolv_list(struct hci_dev *hdev, void *data,
2004 struct sk_buff *skb)
2006 struct hci_cp_le_add_to_resolv_list *sent;
2007 struct hci_ev_status *rp = data;
2009 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
2014 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_ADD_TO_RESOLV_LIST);
2019 hci_bdaddr_list_add_with_irk(&hdev->le_resolv_list, &sent->bdaddr,
2020 sent->bdaddr_type, sent->peer_irk,
2022 hci_dev_unlock(hdev);
2027 static u8 hci_cc_le_del_from_resolv_list(struct hci_dev *hdev, void *data,
2028 struct sk_buff *skb)
2030 struct hci_cp_le_del_from_resolv_list *sent;
2031 struct hci_ev_status *rp = data;
2033 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
2038 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_DEL_FROM_RESOLV_LIST);
2043 hci_bdaddr_list_del_with_irk(&hdev->le_resolv_list, &sent->bdaddr,
2045 hci_dev_unlock(hdev);
2050 static u8 hci_cc_le_clear_resolv_list(struct hci_dev *hdev, void *data,
2051 struct sk_buff *skb)
2053 struct hci_ev_status *rp = data;
2055 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
2061 hci_bdaddr_list_clear(&hdev->le_resolv_list);
2062 hci_dev_unlock(hdev);
2067 static u8 hci_cc_le_read_resolv_list_size(struct hci_dev *hdev, void *data,
2068 struct sk_buff *skb)
2070 struct hci_rp_le_read_resolv_list_size *rp = data;
2072 bt_dev_dbg(hdev, "status 0x%2.2x size %u", rp->status, rp->size);
2077 hdev->le_resolv_list_size = rp->size;
2082 static u8 hci_cc_le_set_addr_resolution_enable(struct hci_dev *hdev, void *data,
2083 struct sk_buff *skb)
2085 struct hci_ev_status *rp = data;
2088 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
2093 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_ADDR_RESOLV_ENABLE);
2100 hci_dev_set_flag(hdev, HCI_LL_RPA_RESOLUTION);
2102 hci_dev_clear_flag(hdev, HCI_LL_RPA_RESOLUTION);
2104 hci_dev_unlock(hdev);
2109 static u8 hci_cc_le_read_max_data_len(struct hci_dev *hdev, void *data,
2110 struct sk_buff *skb)
2112 struct hci_rp_le_read_max_data_len *rp = data;
2114 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
2119 hdev->le_max_tx_len = le16_to_cpu(rp->tx_len);
2120 hdev->le_max_tx_time = le16_to_cpu(rp->tx_time);
2121 hdev->le_max_rx_len = le16_to_cpu(rp->rx_len);
2122 hdev->le_max_rx_time = le16_to_cpu(rp->rx_time);
2127 static u8 hci_cc_write_le_host_supported(struct hci_dev *hdev, void *data,
2128 struct sk_buff *skb)
2130 struct hci_cp_write_le_host_supported *sent;
2131 struct hci_ev_status *rp = data;
2133 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
2138 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED);
2145 hdev->features[1][0] |= LMP_HOST_LE;
2146 hci_dev_set_flag(hdev, HCI_LE_ENABLED);
2148 hdev->features[1][0] &= ~LMP_HOST_LE;
2149 hci_dev_clear_flag(hdev, HCI_LE_ENABLED);
2150 hci_dev_clear_flag(hdev, HCI_ADVERTISING);
2154 hdev->features[1][0] |= LMP_HOST_LE_BREDR;
2156 hdev->features[1][0] &= ~LMP_HOST_LE_BREDR;
2158 hci_dev_unlock(hdev);
2163 static u8 hci_cc_set_adv_param(struct hci_dev *hdev, void *data,
2164 struct sk_buff *skb)
2166 struct hci_cp_le_set_adv_param *cp;
2167 struct hci_ev_status *rp = data;
2169 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
2174 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_ADV_PARAM);
2179 hdev->adv_addr_type = cp->own_address_type;
2180 hci_dev_unlock(hdev);
2185 static u8 hci_cc_set_ext_adv_param(struct hci_dev *hdev, void *data,
2186 struct sk_buff *skb)
2188 struct hci_rp_le_set_ext_adv_params *rp = data;
2189 struct hci_cp_le_set_ext_adv_params *cp;
2190 struct adv_info *adv_instance;
2192 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
2197 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_EXT_ADV_PARAMS);
2202 hdev->adv_addr_type = cp->own_addr_type;
2204 /* Store in hdev for instance 0 */
2205 hdev->adv_tx_power = rp->tx_power;
2207 adv_instance = hci_find_adv_instance(hdev, cp->handle);
2209 adv_instance->tx_power = rp->tx_power;
2211 /* Update adv data as tx power is known now */
2212 hci_update_adv_data(hdev, cp->handle);
2214 hci_dev_unlock(hdev);
2219 static u8 hci_cc_read_rssi(struct hci_dev *hdev, void *data,
2220 struct sk_buff *skb)
2222 struct hci_rp_read_rssi *rp = data;
2223 struct hci_conn *conn;
2225 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
2232 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
2234 conn->rssi = rp->rssi;
2236 hci_dev_unlock(hdev);
2241 static u8 hci_cc_read_tx_power(struct hci_dev *hdev, void *data,
2242 struct sk_buff *skb)
2244 struct hci_cp_read_tx_power *sent;
2245 struct hci_rp_read_tx_power *rp = data;
2246 struct hci_conn *conn;
2248 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
2253 sent = hci_sent_cmd_data(hdev, HCI_OP_READ_TX_POWER);
2259 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
2263 switch (sent->type) {
2265 conn->tx_power = rp->tx_power;
2268 conn->max_tx_power = rp->tx_power;
2273 hci_dev_unlock(hdev);
2277 static u8 hci_cc_write_ssp_debug_mode(struct hci_dev *hdev, void *data,
2278 struct sk_buff *skb)
2280 struct hci_ev_status *rp = data;
2283 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
2288 mode = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_DEBUG_MODE);
2290 hdev->ssp_debug_mode = *mode;
2295 static void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
2297 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2300 hci_conn_check_pending(hdev);
2304 set_bit(HCI_INQUIRY, &hdev->flags);
2307 static void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
2309 struct hci_cp_create_conn *cp;
2310 struct hci_conn *conn;
2312 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2314 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
2320 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
2322 bt_dev_dbg(hdev, "bdaddr %pMR hcon %p", &cp->bdaddr, conn);
2325 if (conn && conn->state == BT_CONNECT) {
2326 if (status != 0x0c || conn->attempt > 2) {
2327 conn->state = BT_CLOSED;
2328 hci_connect_cfm(conn, status);
2331 conn->state = BT_CONNECT2;
2335 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr,
2338 bt_dev_err(hdev, "no memory for new connection");
2342 hci_dev_unlock(hdev);
2345 static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
2347 struct hci_cp_add_sco *cp;
2348 struct hci_conn *acl;
2349 struct hci_link *link;
2352 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2357 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
2361 handle = __le16_to_cpu(cp->handle);
2363 bt_dev_dbg(hdev, "handle 0x%4.4x", handle);
2367 acl = hci_conn_hash_lookup_handle(hdev, handle);
2369 link = list_first_entry_or_null(&acl->link_list,
2370 struct hci_link, list);
2371 if (link && link->conn) {
2372 link->conn->state = BT_CLOSED;
2374 hci_connect_cfm(link->conn, status);
2375 hci_conn_del(link->conn);
2379 hci_dev_unlock(hdev);
2382 static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
2384 struct hci_cp_auth_requested *cp;
2385 struct hci_conn *conn;
2387 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2392 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
2398 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2400 if (conn->state == BT_CONFIG) {
2401 hci_connect_cfm(conn, status);
2402 hci_conn_drop(conn);
2406 hci_dev_unlock(hdev);
2409 static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
2411 struct hci_cp_set_conn_encrypt *cp;
2412 struct hci_conn *conn;
2414 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2419 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
2425 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2427 if (conn->state == BT_CONFIG) {
2428 hci_connect_cfm(conn, status);
2429 hci_conn_drop(conn);
2433 hci_dev_unlock(hdev);
2436 static int hci_outgoing_auth_needed(struct hci_dev *hdev,
2437 struct hci_conn *conn)
2439 if (conn->state != BT_CONFIG || !conn->out)
2442 if (conn->pending_sec_level == BT_SECURITY_SDP)
2445 /* Only request authentication for SSP connections or non-SSP
2446 * devices with sec_level MEDIUM or HIGH or if MITM protection
2449 if (!hci_conn_ssp_enabled(conn) && !(conn->auth_type & 0x01) &&
2450 conn->pending_sec_level != BT_SECURITY_FIPS &&
2451 conn->pending_sec_level != BT_SECURITY_HIGH &&
2452 conn->pending_sec_level != BT_SECURITY_MEDIUM)
2458 static int hci_resolve_name(struct hci_dev *hdev,
2459 struct inquiry_entry *e)
2461 struct hci_cp_remote_name_req cp;
2463 memset(&cp, 0, sizeof(cp));
2465 bacpy(&cp.bdaddr, &e->data.bdaddr);
2466 cp.pscan_rep_mode = e->data.pscan_rep_mode;
2467 cp.pscan_mode = e->data.pscan_mode;
2468 cp.clock_offset = e->data.clock_offset;
2470 return hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
2473 static bool hci_resolve_next_name(struct hci_dev *hdev)
2475 struct discovery_state *discov = &hdev->discovery;
2476 struct inquiry_entry *e;
2478 if (list_empty(&discov->resolve))
2481 /* We should stop if we already spent too much time resolving names. */
2482 if (time_after(jiffies, discov->name_resolve_timeout)) {
2483 bt_dev_warn_ratelimited(hdev, "Name resolve takes too long.");
2487 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY, NAME_NEEDED);
2491 if (hci_resolve_name(hdev, e) == 0) {
2492 e->name_state = NAME_PENDING;
2499 static void hci_check_pending_name(struct hci_dev *hdev, struct hci_conn *conn,
2500 bdaddr_t *bdaddr, u8 *name, u8 name_len)
2502 struct discovery_state *discov = &hdev->discovery;
2503 struct inquiry_entry *e;
2505 /* Update the mgmt connected state if necessary. Be careful with
2506 * conn objects that exist but are not (yet) connected however.
2507 * Only those in BT_CONFIG or BT_CONNECTED states can be
2508 * considered connected.
2511 (conn->state == BT_CONFIG || conn->state == BT_CONNECTED) &&
2512 !test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
2513 mgmt_device_connected(hdev, conn, name, name_len);
2515 if (discov->state == DISCOVERY_STOPPED)
2518 if (discov->state == DISCOVERY_STOPPING)
2519 goto discov_complete;
2521 if (discov->state != DISCOVERY_RESOLVING)
2524 e = hci_inquiry_cache_lookup_resolve(hdev, bdaddr, NAME_PENDING);
2525 /* If the device was not found in a list of found devices names of which
2526 * are pending. there is no need to continue resolving a next name as it
2527 * will be done upon receiving another Remote Name Request Complete
2534 e->name_state = name ? NAME_KNOWN : NAME_NOT_KNOWN;
2535 mgmt_remote_name(hdev, bdaddr, ACL_LINK, 0x00, e->data.rssi,
2538 if (hci_resolve_next_name(hdev))
2542 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
2545 static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
2547 struct hci_cp_remote_name_req *cp;
2548 struct hci_conn *conn;
2550 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2552 /* If successful wait for the name req complete event before
2553 * checking for the need to do authentication */
2557 cp = hci_sent_cmd_data(hdev, HCI_OP_REMOTE_NAME_REQ);
2563 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
2565 if (hci_dev_test_flag(hdev, HCI_MGMT))
2566 hci_check_pending_name(hdev, conn, &cp->bdaddr, NULL, 0);
2571 if (!hci_outgoing_auth_needed(hdev, conn))
2574 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
2575 struct hci_cp_auth_requested auth_cp;
2577 set_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags);
2579 auth_cp.handle = __cpu_to_le16(conn->handle);
2580 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED,
2581 sizeof(auth_cp), &auth_cp);
2585 hci_dev_unlock(hdev);
2588 static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
2590 struct hci_cp_read_remote_features *cp;
2591 struct hci_conn *conn;
2593 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2598 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
2604 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2606 if (conn->state == BT_CONFIG) {
2607 hci_connect_cfm(conn, status);
2608 hci_conn_drop(conn);
2612 hci_dev_unlock(hdev);
2615 static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
2617 struct hci_cp_read_remote_ext_features *cp;
2618 struct hci_conn *conn;
2620 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2625 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
2631 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2633 if (conn->state == BT_CONFIG) {
2634 hci_connect_cfm(conn, status);
2635 hci_conn_drop(conn);
2639 hci_dev_unlock(hdev);
2642 static void hci_setup_sync_conn_status(struct hci_dev *hdev, __u16 handle,
2645 struct hci_conn *acl;
2646 struct hci_link *link;
2648 bt_dev_dbg(hdev, "handle 0x%4.4x status 0x%2.2x", handle, status);
2652 acl = hci_conn_hash_lookup_handle(hdev, handle);
2654 link = list_first_entry_or_null(&acl->link_list,
2655 struct hci_link, list);
2656 if (link && link->conn) {
2657 link->conn->state = BT_CLOSED;
2659 hci_connect_cfm(link->conn, status);
2660 hci_conn_del(link->conn);
2664 hci_dev_unlock(hdev);
2667 static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
2669 struct hci_cp_setup_sync_conn *cp;
2671 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2676 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
2680 hci_setup_sync_conn_status(hdev, __le16_to_cpu(cp->handle), status);
2683 static void hci_cs_enhanced_setup_sync_conn(struct hci_dev *hdev, __u8 status)
2685 struct hci_cp_enhanced_setup_sync_conn *cp;
2687 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2692 cp = hci_sent_cmd_data(hdev, HCI_OP_ENHANCED_SETUP_SYNC_CONN);
2696 hci_setup_sync_conn_status(hdev, __le16_to_cpu(cp->handle), status);
2699 static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
2701 struct hci_cp_sniff_mode *cp;
2702 struct hci_conn *conn;
2704 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2709 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
2715 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2717 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
2719 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
2720 hci_sco_setup(conn, status);
2723 hci_dev_unlock(hdev);
2726 static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
2728 struct hci_cp_exit_sniff_mode *cp;
2729 struct hci_conn *conn;
2731 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2736 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
2742 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2744 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
2746 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
2747 hci_sco_setup(conn, status);
2750 hci_dev_unlock(hdev);
2753 static void hci_cs_disconnect(struct hci_dev *hdev, u8 status)
2755 struct hci_cp_disconnect *cp;
2756 struct hci_conn_params *params;
2757 struct hci_conn *conn;
2760 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2762 /* Wait for HCI_EV_DISCONN_COMPLETE if status 0x00 and not suspended
2763 * otherwise cleanup the connection immediately.
2765 if (!status && !hdev->suspended)
2768 cp = hci_sent_cmd_data(hdev, HCI_OP_DISCONNECT);
2774 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2779 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
2780 conn->dst_type, status);
2782 if (conn->type == LE_LINK && conn->role == HCI_ROLE_SLAVE) {
2783 hdev->cur_adv_instance = conn->adv_instance;
2784 hci_enable_advertising(hdev);
2787 /* Inform sockets conn is gone before we delete it */
2788 hci_disconn_cfm(conn, HCI_ERROR_UNSPECIFIED);
2793 mgmt_conn = test_and_clear_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags);
2795 if (conn->type == ACL_LINK) {
2796 if (test_and_clear_bit(HCI_CONN_FLUSH_KEY, &conn->flags))
2797 hci_remove_link_key(hdev, &conn->dst);
2800 params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
2802 switch (params->auto_connect) {
2803 case HCI_AUTO_CONN_LINK_LOSS:
2804 if (cp->reason != HCI_ERROR_CONNECTION_TIMEOUT)
2808 case HCI_AUTO_CONN_DIRECT:
2809 case HCI_AUTO_CONN_ALWAYS:
2810 hci_pend_le_list_del_init(params);
2811 hci_pend_le_list_add(params, &hdev->pend_le_conns);
2819 mgmt_device_disconnected(hdev, &conn->dst, conn->type, conn->dst_type,
2820 cp->reason, mgmt_conn);
2822 hci_disconn_cfm(conn, cp->reason);
2825 /* If the disconnection failed for any reason, the upper layer
2826 * does not retry to disconnect in current implementation.
2827 * Hence, we need to do some basic cleanup here and re-enable
2828 * advertising if necessary.
2832 hci_dev_unlock(hdev);
2835 static u8 ev_bdaddr_type(struct hci_dev *hdev, u8 type, bool *resolved)
2837 /* When using controller based address resolution, then the new
2838 * address types 0x02 and 0x03 are used. These types need to be
2839 * converted back into either public address or random address type
2842 case ADDR_LE_DEV_PUBLIC_RESOLVED:
2845 return ADDR_LE_DEV_PUBLIC;
2846 case ADDR_LE_DEV_RANDOM_RESOLVED:
2849 return ADDR_LE_DEV_RANDOM;
2857 static void cs_le_create_conn(struct hci_dev *hdev, bdaddr_t *peer_addr,
2858 u8 peer_addr_type, u8 own_address_type,
2861 struct hci_conn *conn;
2863 conn = hci_conn_hash_lookup_le(hdev, peer_addr,
2868 own_address_type = ev_bdaddr_type(hdev, own_address_type, NULL);
2870 /* Store the initiator and responder address information which
2871 * is needed for SMP. These values will not change during the
2872 * lifetime of the connection.
2874 conn->init_addr_type = own_address_type;
2875 if (own_address_type == ADDR_LE_DEV_RANDOM)
2876 bacpy(&conn->init_addr, &hdev->random_addr);
2878 bacpy(&conn->init_addr, &hdev->bdaddr);
2880 conn->resp_addr_type = peer_addr_type;
2881 bacpy(&conn->resp_addr, peer_addr);
2884 static void hci_cs_le_create_conn(struct hci_dev *hdev, u8 status)
2886 struct hci_cp_le_create_conn *cp;
2888 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2890 /* All connection failure handling is taken care of by the
2891 * hci_conn_failed function which is triggered by the HCI
2892 * request completion callbacks used for connecting.
2897 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_CREATE_CONN);
2903 cs_le_create_conn(hdev, &cp->peer_addr, cp->peer_addr_type,
2904 cp->own_address_type, cp->filter_policy);
2906 hci_dev_unlock(hdev);
2909 static void hci_cs_le_ext_create_conn(struct hci_dev *hdev, u8 status)
2911 struct hci_cp_le_ext_create_conn *cp;
2913 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2915 /* All connection failure handling is taken care of by the
2916 * hci_conn_failed function which is triggered by the HCI
2917 * request completion callbacks used for connecting.
2922 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_EXT_CREATE_CONN);
2928 cs_le_create_conn(hdev, &cp->peer_addr, cp->peer_addr_type,
2929 cp->own_addr_type, cp->filter_policy);
2931 hci_dev_unlock(hdev);
2934 static void hci_cs_le_read_remote_features(struct hci_dev *hdev, u8 status)
2936 struct hci_cp_le_read_remote_features *cp;
2937 struct hci_conn *conn;
2939 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2944 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_READ_REMOTE_FEATURES);
2950 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2952 if (conn->state == BT_CONFIG) {
2953 hci_connect_cfm(conn, status);
2954 hci_conn_drop(conn);
2958 hci_dev_unlock(hdev);
2961 static void hci_cs_le_start_enc(struct hci_dev *hdev, u8 status)
2963 struct hci_cp_le_start_enc *cp;
2964 struct hci_conn *conn;
2966 bt_dev_dbg(hdev, "status 0x%2.2x", status);
2973 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_START_ENC);
2977 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
2981 if (conn->state != BT_CONNECTED)
2984 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
2985 hci_conn_drop(conn);
2988 hci_dev_unlock(hdev);
2991 static void hci_cs_switch_role(struct hci_dev *hdev, u8 status)
2993 struct hci_cp_switch_role *cp;
2994 struct hci_conn *conn;
2996 BT_DBG("%s status 0x%2.2x", hdev->name, status);
3001 cp = hci_sent_cmd_data(hdev, HCI_OP_SWITCH_ROLE);
3007 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
3009 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->flags);
3011 hci_dev_unlock(hdev);
3014 static void hci_inquiry_complete_evt(struct hci_dev *hdev, void *data,
3015 struct sk_buff *skb)
3017 struct hci_ev_status *ev = data;
3018 struct discovery_state *discov = &hdev->discovery;
3019 struct inquiry_entry *e;
3021 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
3023 hci_conn_check_pending(hdev);
3025 if (!test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
3028 smp_mb__after_atomic(); /* wake_up_bit advises about this barrier */
3029 wake_up_bit(&hdev->flags, HCI_INQUIRY);
3031 if (!hci_dev_test_flag(hdev, HCI_MGMT))
3036 if (discov->state != DISCOVERY_FINDING)
3039 if (list_empty(&discov->resolve)) {
3040 /* When BR/EDR inquiry is active and no LE scanning is in
3041 * progress, then change discovery state to indicate completion.
3043 * When running LE scanning and BR/EDR inquiry simultaneously
3044 * and the LE scan already finished, then change the discovery
3045 * state to indicate completion.
3047 if (!hci_dev_test_flag(hdev, HCI_LE_SCAN) ||
3048 !test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks))
3049 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
3053 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY, NAME_NEEDED);
3054 if (e && hci_resolve_name(hdev, e) == 0) {
3055 e->name_state = NAME_PENDING;
3056 hci_discovery_set_state(hdev, DISCOVERY_RESOLVING);
3057 discov->name_resolve_timeout = jiffies + NAME_RESOLVE_DURATION;
3059 /* When BR/EDR inquiry is active and no LE scanning is in
3060 * progress, then change discovery state to indicate completion.
3062 * When running LE scanning and BR/EDR inquiry simultaneously
3063 * and the LE scan already finished, then change the discovery
3064 * state to indicate completion.
3066 if (!hci_dev_test_flag(hdev, HCI_LE_SCAN) ||
3067 !test_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks))
3068 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
3072 hci_dev_unlock(hdev);
3075 static void hci_inquiry_result_evt(struct hci_dev *hdev, void *edata,
3076 struct sk_buff *skb)
3078 struct hci_ev_inquiry_result *ev = edata;
3079 struct inquiry_data data;
3082 if (!hci_ev_skb_pull(hdev, skb, HCI_EV_INQUIRY_RESULT,
3083 flex_array_size(ev, info, ev->num)))
3086 bt_dev_dbg(hdev, "num %d", ev->num);
3091 if (hci_dev_test_flag(hdev, HCI_PERIODIC_INQ))
3096 for (i = 0; i < ev->num; i++) {
3097 struct inquiry_info *info = &ev->info[i];
3100 bacpy(&data.bdaddr, &info->bdaddr);
3101 data.pscan_rep_mode = info->pscan_rep_mode;
3102 data.pscan_period_mode = info->pscan_period_mode;
3103 data.pscan_mode = info->pscan_mode;
3104 memcpy(data.dev_class, info->dev_class, 3);
3105 data.clock_offset = info->clock_offset;
3106 data.rssi = HCI_RSSI_INVALID;
3107 data.ssp_mode = 0x00;
3109 flags = hci_inquiry_cache_update(hdev, &data, false);
3111 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
3112 info->dev_class, HCI_RSSI_INVALID,
3113 flags, NULL, 0, NULL, 0, 0);
3116 hci_dev_unlock(hdev);
3119 static void hci_conn_complete_evt(struct hci_dev *hdev, void *data,
3120 struct sk_buff *skb)
3122 struct hci_ev_conn_complete *ev = data;
3123 struct hci_conn *conn;
3124 u8 status = ev->status;
3126 bt_dev_dbg(hdev, "status 0x%2.2x", status);
3130 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
3132 /* In case of error status and there is no connection pending
3133 * just unlock as there is nothing to cleanup.
3138 /* Connection may not exist if auto-connected. Check the bredr
3139 * allowlist to see if this device is allowed to auto connect.
3140 * If link is an ACL type, create a connection class
3143 * Auto-connect will only occur if the event filter is
3144 * programmed with a given address. Right now, event filter is
3145 * only used during suspend.
3147 if (ev->link_type == ACL_LINK &&
3148 hci_bdaddr_list_lookup_with_flags(&hdev->accept_list,
3151 conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr,
3154 bt_dev_err(hdev, "no memory for new conn");
3158 if (ev->link_type != SCO_LINK)
3161 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK,
3166 conn->type = SCO_LINK;
3170 /* The HCI_Connection_Complete event is only sent once per connection.
3171 * Processing it more than once per connection can corrupt kernel memory.
3173 * As the connection handle is set here for the first time, it indicates
3174 * whether the connection is already set up.
3176 if (!HCI_CONN_HANDLE_UNSET(conn->handle)) {
3177 bt_dev_err(hdev, "Ignoring HCI_Connection_Complete for existing connection");
3182 status = hci_conn_set_handle(conn, __le16_to_cpu(ev->handle));
3186 if (conn->type == ACL_LINK) {
3187 conn->state = BT_CONFIG;
3188 hci_conn_hold(conn);
3190 if (!conn->out && !hci_conn_ssp_enabled(conn) &&
3191 !hci_find_link_key(hdev, &ev->bdaddr))
3192 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
3194 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
3196 conn->state = BT_CONNECTED;
3198 hci_debugfs_create_conn(conn);
3199 hci_conn_add_sysfs(conn);
3201 if (test_bit(HCI_AUTH, &hdev->flags))
3202 set_bit(HCI_CONN_AUTH, &conn->flags);
3204 if (test_bit(HCI_ENCRYPT, &hdev->flags))
3205 set_bit(HCI_CONN_ENCRYPT, &conn->flags);
3207 /* Get remote features */
3208 if (conn->type == ACL_LINK) {
3209 struct hci_cp_read_remote_features cp;
3210 cp.handle = ev->handle;
3211 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
3214 hci_update_scan(hdev);
3217 /* Set packet type for incoming connection */
3218 if (!conn->out && hdev->hci_ver < BLUETOOTH_VER_2_0) {
3219 struct hci_cp_change_conn_ptype cp;
3220 cp.handle = ev->handle;
3221 cp.pkt_type = cpu_to_le16(conn->pkt_type);
3222 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE, sizeof(cp),
3227 if (conn->type == ACL_LINK)
3228 hci_sco_setup(conn, ev->status);
3232 hci_conn_failed(conn, status);
3233 } else if (ev->link_type == SCO_LINK) {
3234 switch (conn->setting & SCO_AIRMODE_MASK) {
3235 case SCO_AIRMODE_CVSD:
3237 hdev->notify(hdev, HCI_NOTIFY_ENABLE_SCO_CVSD);
3241 hci_connect_cfm(conn, status);
3245 hci_dev_unlock(hdev);
3247 hci_conn_check_pending(hdev);
3250 static void hci_reject_conn(struct hci_dev *hdev, bdaddr_t *bdaddr)
3252 struct hci_cp_reject_conn_req cp;
3254 bacpy(&cp.bdaddr, bdaddr);
3255 cp.reason = HCI_ERROR_REJ_BAD_ADDR;
3256 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
3259 static void hci_conn_request_evt(struct hci_dev *hdev, void *data,
3260 struct sk_buff *skb)
3262 struct hci_ev_conn_request *ev = data;
3263 int mask = hdev->link_mode;
3264 struct inquiry_entry *ie;
3265 struct hci_conn *conn;
3268 bt_dev_dbg(hdev, "bdaddr %pMR type 0x%x", &ev->bdaddr, ev->link_type);
3270 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type,
3273 if (!(mask & HCI_LM_ACCEPT)) {
3274 hci_reject_conn(hdev, &ev->bdaddr);
3280 if (hci_bdaddr_list_lookup(&hdev->reject_list, &ev->bdaddr,
3282 hci_reject_conn(hdev, &ev->bdaddr);
3286 /* Require HCI_CONNECTABLE or an accept list entry to accept the
3287 * connection. These features are only touched through mgmt so
3288 * only do the checks if HCI_MGMT is set.
3290 if (hci_dev_test_flag(hdev, HCI_MGMT) &&
3291 !hci_dev_test_flag(hdev, HCI_CONNECTABLE) &&
3292 !hci_bdaddr_list_lookup_with_flags(&hdev->accept_list, &ev->bdaddr,
3294 hci_reject_conn(hdev, &ev->bdaddr);
3298 /* Connection accepted */
3300 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
3302 memcpy(ie->data.dev_class, ev->dev_class, 3);
3304 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type,
3307 conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr,
3310 bt_dev_err(hdev, "no memory for new connection");
3315 memcpy(conn->dev_class, ev->dev_class, 3);
3317 hci_dev_unlock(hdev);
3319 if (ev->link_type == ACL_LINK ||
3320 (!(flags & HCI_PROTO_DEFER) && !lmp_esco_capable(hdev))) {
3321 struct hci_cp_accept_conn_req cp;
3322 conn->state = BT_CONNECT;
3324 bacpy(&cp.bdaddr, &ev->bdaddr);
3326 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
3327 cp.role = 0x00; /* Become central */
3329 cp.role = 0x01; /* Remain peripheral */
3331 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
3332 } else if (!(flags & HCI_PROTO_DEFER)) {
3333 struct hci_cp_accept_sync_conn_req cp;
3334 conn->state = BT_CONNECT;
3336 bacpy(&cp.bdaddr, &ev->bdaddr);
3337 cp.pkt_type = cpu_to_le16(conn->pkt_type);
3339 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
3340 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
3341 cp.max_latency = cpu_to_le16(0xffff);
3342 cp.content_format = cpu_to_le16(hdev->voice_setting);
3343 cp.retrans_effort = 0xff;
3345 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ, sizeof(cp),
3348 conn->state = BT_CONNECT2;
3349 hci_connect_cfm(conn, 0);
3354 hci_dev_unlock(hdev);
3357 static u8 hci_to_mgmt_reason(u8 err)
3360 case HCI_ERROR_CONNECTION_TIMEOUT:
3361 return MGMT_DEV_DISCONN_TIMEOUT;
3362 case HCI_ERROR_REMOTE_USER_TERM:
3363 case HCI_ERROR_REMOTE_LOW_RESOURCES:
3364 case HCI_ERROR_REMOTE_POWER_OFF:
3365 return MGMT_DEV_DISCONN_REMOTE;
3366 case HCI_ERROR_LOCAL_HOST_TERM:
3367 return MGMT_DEV_DISCONN_LOCAL_HOST;
3369 return MGMT_DEV_DISCONN_UNKNOWN;
3373 static void hci_disconn_complete_evt(struct hci_dev *hdev, void *data,
3374 struct sk_buff *skb)
3376 struct hci_ev_disconn_complete *ev = data;
3378 struct hci_conn_params *params;
3379 struct hci_conn *conn;
3380 bool mgmt_connected;
3382 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
3386 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3391 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
3392 conn->dst_type, ev->status);
3396 conn->state = BT_CLOSED;
3398 mgmt_connected = test_and_clear_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags);
3400 if (test_bit(HCI_CONN_AUTH_FAILURE, &conn->flags))
3401 reason = MGMT_DEV_DISCONN_AUTH_FAILURE;
3403 reason = hci_to_mgmt_reason(ev->reason);
3405 mgmt_device_disconnected(hdev, &conn->dst, conn->type, conn->dst_type,
3406 reason, mgmt_connected);
3408 if (conn->type == ACL_LINK) {
3409 if (test_and_clear_bit(HCI_CONN_FLUSH_KEY, &conn->flags))
3410 hci_remove_link_key(hdev, &conn->dst);
3412 hci_update_scan(hdev);
3415 params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
3417 switch (params->auto_connect) {
3418 case HCI_AUTO_CONN_LINK_LOSS:
3419 if (ev->reason != HCI_ERROR_CONNECTION_TIMEOUT)
3423 case HCI_AUTO_CONN_DIRECT:
3424 case HCI_AUTO_CONN_ALWAYS:
3425 hci_pend_le_list_del_init(params);
3426 hci_pend_le_list_add(params, &hdev->pend_le_conns);
3427 hci_update_passive_scan(hdev);
3435 hci_disconn_cfm(conn, ev->reason);
3437 /* Re-enable advertising if necessary, since it might
3438 * have been disabled by the connection. From the
3439 * HCI_LE_Set_Advertise_Enable command description in
3440 * the core specification (v4.0):
3441 * "The Controller shall continue advertising until the Host
3442 * issues an LE_Set_Advertise_Enable command with
3443 * Advertising_Enable set to 0x00 (Advertising is disabled)
3444 * or until a connection is created or until the Advertising
3445 * is timed out due to Directed Advertising."
3447 if (conn->type == LE_LINK && conn->role == HCI_ROLE_SLAVE) {
3448 hdev->cur_adv_instance = conn->adv_instance;
3449 hci_enable_advertising(hdev);
3455 hci_dev_unlock(hdev);
3458 static void hci_auth_complete_evt(struct hci_dev *hdev, void *data,
3459 struct sk_buff *skb)
3461 struct hci_ev_auth_complete *ev = data;
3462 struct hci_conn *conn;
3464 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
3468 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3473 clear_bit(HCI_CONN_AUTH_FAILURE, &conn->flags);
3475 if (!hci_conn_ssp_enabled(conn) &&
3476 test_bit(HCI_CONN_REAUTH_PEND, &conn->flags)) {
3477 bt_dev_info(hdev, "re-auth of legacy device is not possible.");
3479 set_bit(HCI_CONN_AUTH, &conn->flags);
3480 conn->sec_level = conn->pending_sec_level;
3483 if (ev->status == HCI_ERROR_PIN_OR_KEY_MISSING)
3484 set_bit(HCI_CONN_AUTH_FAILURE, &conn->flags);
3486 mgmt_auth_failed(conn, ev->status);
3489 clear_bit(HCI_CONN_AUTH_PEND, &conn->flags);
3490 clear_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
3492 if (conn->state == BT_CONFIG) {
3493 if (!ev->status && hci_conn_ssp_enabled(conn)) {
3494 struct hci_cp_set_conn_encrypt cp;
3495 cp.handle = ev->handle;
3497 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
3500 conn->state = BT_CONNECTED;
3501 hci_connect_cfm(conn, ev->status);
3502 hci_conn_drop(conn);
3505 hci_auth_cfm(conn, ev->status);
3507 hci_conn_hold(conn);
3508 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
3509 hci_conn_drop(conn);
3512 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
3514 struct hci_cp_set_conn_encrypt cp;
3515 cp.handle = ev->handle;
3517 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
3520 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
3521 hci_encrypt_cfm(conn, ev->status);
3526 hci_dev_unlock(hdev);
3529 static void hci_remote_name_evt(struct hci_dev *hdev, void *data,
3530 struct sk_buff *skb)
3532 struct hci_ev_remote_name *ev = data;
3533 struct hci_conn *conn;
3535 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
3537 hci_conn_check_pending(hdev);
3541 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3543 if (!hci_dev_test_flag(hdev, HCI_MGMT))
3546 if (ev->status == 0)
3547 hci_check_pending_name(hdev, conn, &ev->bdaddr, ev->name,
3548 strnlen(ev->name, HCI_MAX_NAME_LENGTH));
3550 hci_check_pending_name(hdev, conn, &ev->bdaddr, NULL, 0);
3556 if (!hci_outgoing_auth_needed(hdev, conn))
3559 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
3560 struct hci_cp_auth_requested cp;
3562 set_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags);
3564 cp.handle = __cpu_to_le16(conn->handle);
3565 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
3569 hci_dev_unlock(hdev);
3572 static void hci_encrypt_change_evt(struct hci_dev *hdev, void *data,
3573 struct sk_buff *skb)
3575 struct hci_ev_encrypt_change *ev = data;
3576 struct hci_conn *conn;
3578 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
3582 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3588 /* Encryption implies authentication */
3589 set_bit(HCI_CONN_AUTH, &conn->flags);
3590 set_bit(HCI_CONN_ENCRYPT, &conn->flags);
3591 conn->sec_level = conn->pending_sec_level;
3593 /* P-256 authentication key implies FIPS */
3594 if (conn->key_type == HCI_LK_AUTH_COMBINATION_P256)
3595 set_bit(HCI_CONN_FIPS, &conn->flags);
3597 if ((conn->type == ACL_LINK && ev->encrypt == 0x02) ||
3598 conn->type == LE_LINK)
3599 set_bit(HCI_CONN_AES_CCM, &conn->flags);
3601 clear_bit(HCI_CONN_ENCRYPT, &conn->flags);
3602 clear_bit(HCI_CONN_AES_CCM, &conn->flags);
3606 /* We should disregard the current RPA and generate a new one
3607 * whenever the encryption procedure fails.
3609 if (ev->status && conn->type == LE_LINK) {
3610 hci_dev_set_flag(hdev, HCI_RPA_EXPIRED);
3611 hci_adv_instances_set_rpa_expired(hdev, true);
3614 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
3616 /* Check link security requirements are met */
3617 if (!hci_conn_check_link_mode(conn))
3618 ev->status = HCI_ERROR_AUTH_FAILURE;
3620 if (ev->status && conn->state == BT_CONNECTED) {
3621 if (ev->status == HCI_ERROR_PIN_OR_KEY_MISSING)
3622 set_bit(HCI_CONN_AUTH_FAILURE, &conn->flags);
3624 /* Notify upper layers so they can cleanup before
3627 hci_encrypt_cfm(conn, ev->status);
3628 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
3629 hci_conn_drop(conn);
3633 /* Try reading the encryption key size for encrypted ACL links */
3634 if (!ev->status && ev->encrypt && conn->type == ACL_LINK) {
3635 struct hci_cp_read_enc_key_size cp;
3637 /* Only send HCI_Read_Encryption_Key_Size if the
3638 * controller really supports it. If it doesn't, assume
3639 * the default size (16).
3641 if (!(hdev->commands[20] & 0x10)) {
3642 conn->enc_key_size = HCI_LINK_KEY_SIZE;
3646 cp.handle = cpu_to_le16(conn->handle);
3647 if (hci_send_cmd(hdev, HCI_OP_READ_ENC_KEY_SIZE,
3649 bt_dev_err(hdev, "sending read key size failed");
3650 conn->enc_key_size = HCI_LINK_KEY_SIZE;
3657 /* Set the default Authenticated Payload Timeout after
3658 * an LE Link is established. As per Core Spec v5.0, Vol 2, Part B
3659 * Section 3.3, the HCI command WRITE_AUTH_PAYLOAD_TIMEOUT should be
3660 * sent when the link is active and Encryption is enabled, the conn
3661 * type can be either LE or ACL and controller must support LMP Ping.
3662 * Ensure for AES-CCM encryption as well.
3664 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags) &&
3665 test_bit(HCI_CONN_AES_CCM, &conn->flags) &&
3666 ((conn->type == ACL_LINK && lmp_ping_capable(hdev)) ||
3667 (conn->type == LE_LINK && (hdev->le_features[0] & HCI_LE_PING)))) {
3668 struct hci_cp_write_auth_payload_to cp;
3670 cp.handle = cpu_to_le16(conn->handle);
3671 cp.timeout = cpu_to_le16(hdev->auth_payload_timeout);
3672 if (hci_send_cmd(conn->hdev, HCI_OP_WRITE_AUTH_PAYLOAD_TO,
3674 bt_dev_err(hdev, "write auth payload timeout failed");
3682 hci_encrypt_cfm(conn, ev->status);
3685 hci_dev_unlock(hdev);
3688 static void hci_change_link_key_complete_evt(struct hci_dev *hdev, void *data,
3689 struct sk_buff *skb)
3691 struct hci_ev_change_link_key_complete *ev = data;
3692 struct hci_conn *conn;
3694 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
3698 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3701 set_bit(HCI_CONN_SECURE, &conn->flags);
3703 clear_bit(HCI_CONN_AUTH_PEND, &conn->flags);
3705 hci_key_change_cfm(conn, ev->status);
3708 hci_dev_unlock(hdev);
3711 static void hci_remote_features_evt(struct hci_dev *hdev, void *data,
3712 struct sk_buff *skb)
3714 struct hci_ev_remote_features *ev = data;
3715 struct hci_conn *conn;
3717 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
3721 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3726 memcpy(conn->features[0], ev->features, 8);
3728 if (conn->state != BT_CONFIG)
3731 if (!ev->status && lmp_ext_feat_capable(hdev) &&
3732 lmp_ext_feat_capable(conn)) {
3733 struct hci_cp_read_remote_ext_features cp;
3734 cp.handle = ev->handle;
3736 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES,
3741 if (!ev->status && !test_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags)) {
3742 struct hci_cp_remote_name_req cp;
3743 memset(&cp, 0, sizeof(cp));
3744 bacpy(&cp.bdaddr, &conn->dst);
3745 cp.pscan_rep_mode = 0x02;
3746 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
3747 } else if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
3748 mgmt_device_connected(hdev, conn, NULL, 0);
3750 if (!hci_outgoing_auth_needed(hdev, conn)) {
3751 conn->state = BT_CONNECTED;
3752 hci_connect_cfm(conn, ev->status);
3753 hci_conn_drop(conn);
3757 hci_dev_unlock(hdev);
3760 static inline void handle_cmd_cnt_and_timer(struct hci_dev *hdev, u8 ncmd)
3762 cancel_delayed_work(&hdev->cmd_timer);
3765 if (!test_bit(HCI_RESET, &hdev->flags)) {
3767 cancel_delayed_work(&hdev->ncmd_timer);
3768 atomic_set(&hdev->cmd_cnt, 1);
3770 if (!hci_dev_test_flag(hdev, HCI_CMD_DRAIN_WORKQUEUE))
3771 queue_delayed_work(hdev->workqueue, &hdev->ncmd_timer,
3778 static u8 hci_cc_le_read_buffer_size_v2(struct hci_dev *hdev, void *data,
3779 struct sk_buff *skb)
3781 struct hci_rp_le_read_buffer_size_v2 *rp = data;
3783 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
3788 hdev->le_mtu = __le16_to_cpu(rp->acl_mtu);
3789 hdev->le_pkts = rp->acl_max_pkt;
3790 hdev->iso_mtu = __le16_to_cpu(rp->iso_mtu);
3791 hdev->iso_pkts = rp->iso_max_pkt;
3793 hdev->le_cnt = hdev->le_pkts;
3794 hdev->iso_cnt = hdev->iso_pkts;
3796 BT_DBG("%s acl mtu %d:%d iso mtu %d:%d", hdev->name, hdev->acl_mtu,
3797 hdev->acl_pkts, hdev->iso_mtu, hdev->iso_pkts);
3802 static void hci_unbound_cis_failed(struct hci_dev *hdev, u8 cig, u8 status)
3804 struct hci_conn *conn, *tmp;
3806 lockdep_assert_held(&hdev->lock);
3808 list_for_each_entry_safe(conn, tmp, &hdev->conn_hash.list, list) {
3809 if (conn->type != ISO_LINK || !bacmp(&conn->dst, BDADDR_ANY) ||
3810 conn->state == BT_OPEN || conn->iso_qos.ucast.cig != cig)
3813 if (HCI_CONN_HANDLE_UNSET(conn->handle))
3814 hci_conn_failed(conn, status);
3818 static u8 hci_cc_le_set_cig_params(struct hci_dev *hdev, void *data,
3819 struct sk_buff *skb)
3821 struct hci_rp_le_set_cig_params *rp = data;
3822 struct hci_cp_le_set_cig_params *cp;
3823 struct hci_conn *conn;
3824 u8 status = rp->status;
3825 bool pending = false;
3828 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
3830 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_CIG_PARAMS);
3831 if (!rp->status && (!cp || rp->num_handles != cp->num_cis ||
3832 rp->cig_id != cp->cig_id)) {
3833 bt_dev_err(hdev, "unexpected Set CIG Parameters response data");
3834 status = HCI_ERROR_UNSPECIFIED;
3839 /* BLUETOOTH CORE SPECIFICATION Version 5.4 | Vol 4, Part E page 2554
3841 * If the Status return parameter is non-zero, then the state of the CIG
3842 * and its CIS configurations shall not be changed by the command. If
3843 * the CIG did not already exist, it shall not be created.
3846 /* Keep current configuration, fail only the unbound CIS */
3847 hci_unbound_cis_failed(hdev, rp->cig_id, status);
3851 /* BLUETOOTH CORE SPECIFICATION Version 5.3 | Vol 4, Part E page 2553
3853 * If the Status return parameter is zero, then the Controller shall
3854 * set the Connection_Handle arrayed return parameter to the connection
3855 * handle(s) corresponding to the CIS configurations specified in
3856 * the CIS_IDs command parameter, in the same order.
3858 for (i = 0; i < rp->num_handles; ++i) {
3859 conn = hci_conn_hash_lookup_cis(hdev, NULL, 0, rp->cig_id,
3861 if (!conn || !bacmp(&conn->dst, BDADDR_ANY))
3864 if (conn->state != BT_BOUND && conn->state != BT_CONNECT)
3867 if (hci_conn_set_handle(conn, __le16_to_cpu(rp->handle[i])))
3870 if (conn->state == BT_CONNECT)
3876 hci_le_create_cis_pending(hdev);
3878 hci_dev_unlock(hdev);
3883 static u8 hci_cc_le_setup_iso_path(struct hci_dev *hdev, void *data,
3884 struct sk_buff *skb)
3886 struct hci_rp_le_setup_iso_path *rp = data;
3887 struct hci_cp_le_setup_iso_path *cp;
3888 struct hci_conn *conn;
3890 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
3892 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SETUP_ISO_PATH);
3898 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
3903 hci_connect_cfm(conn, rp->status);
3908 switch (cp->direction) {
3909 /* Input (Host to Controller) */
3911 /* Only confirm connection if output only */
3912 if (conn->iso_qos.ucast.out.sdu && !conn->iso_qos.ucast.in.sdu)
3913 hci_connect_cfm(conn, rp->status);
3915 /* Output (Controller to Host) */
3917 /* Confirm connection since conn->iso_qos is always configured
3920 hci_connect_cfm(conn, rp->status);
3925 hci_dev_unlock(hdev);
3929 static void hci_cs_le_create_big(struct hci_dev *hdev, u8 status)
3931 bt_dev_dbg(hdev, "status 0x%2.2x", status);
3934 static u8 hci_cc_set_per_adv_param(struct hci_dev *hdev, void *data,
3935 struct sk_buff *skb)
3937 struct hci_ev_status *rp = data;
3938 struct hci_cp_le_set_per_adv_params *cp;
3940 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
3945 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_PER_ADV_PARAMS);
3949 /* TODO: set the conn state */
3953 static u8 hci_cc_le_set_per_adv_enable(struct hci_dev *hdev, void *data,
3954 struct sk_buff *skb)
3956 struct hci_ev_status *rp = data;
3957 struct hci_cp_le_set_per_adv_enable *cp;
3958 struct adv_info *adv = NULL, *n;
3961 bt_dev_dbg(hdev, "status 0x%2.2x", rp->status);
3966 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_PER_ADV_ENABLE);
3972 adv = hci_find_adv_instance(hdev, cp->handle);
3975 hci_dev_set_flag(hdev, HCI_LE_PER_ADV);
3978 adv->enabled = true;
3980 /* If just one instance was disabled check if there are
3981 * any other instance enabled before clearing HCI_LE_PER_ADV.
3982 * The current periodic adv instance will be marked as
3983 * disabled once extended advertising is also disabled.
3985 list_for_each_entry_safe(adv, n, &hdev->adv_instances,
3987 if (adv->periodic && adv->enabled)
3991 if (per_adv_cnt > 1)
3994 hci_dev_clear_flag(hdev, HCI_LE_PER_ADV);
3998 hci_dev_unlock(hdev);
4003 #define HCI_CC_VL(_op, _func, _min, _max) \
4011 #define HCI_CC(_op, _func, _len) \
4012 HCI_CC_VL(_op, _func, _len, _len)
4014 #define HCI_CC_STATUS(_op, _func) \
4015 HCI_CC(_op, _func, sizeof(struct hci_ev_status))
4017 static const struct hci_cc {
4019 u8 (*func)(struct hci_dev *hdev, void *data, struct sk_buff *skb);
4022 } hci_cc_table[] = {
4023 HCI_CC_STATUS(HCI_OP_INQUIRY_CANCEL, hci_cc_inquiry_cancel),
4024 HCI_CC_STATUS(HCI_OP_PERIODIC_INQ, hci_cc_periodic_inq),
4025 HCI_CC_STATUS(HCI_OP_EXIT_PERIODIC_INQ, hci_cc_exit_periodic_inq),
4026 HCI_CC_STATUS(HCI_OP_REMOTE_NAME_REQ_CANCEL,
4027 hci_cc_remote_name_req_cancel),
4028 HCI_CC(HCI_OP_ROLE_DISCOVERY, hci_cc_role_discovery,
4029 sizeof(struct hci_rp_role_discovery)),
4030 HCI_CC(HCI_OP_READ_LINK_POLICY, hci_cc_read_link_policy,
4031 sizeof(struct hci_rp_read_link_policy)),
4032 HCI_CC(HCI_OP_WRITE_LINK_POLICY, hci_cc_write_link_policy,
4033 sizeof(struct hci_rp_write_link_policy)),
4034 HCI_CC(HCI_OP_READ_DEF_LINK_POLICY, hci_cc_read_def_link_policy,
4035 sizeof(struct hci_rp_read_def_link_policy)),
4036 HCI_CC_STATUS(HCI_OP_WRITE_DEF_LINK_POLICY,
4037 hci_cc_write_def_link_policy),
4038 HCI_CC_STATUS(HCI_OP_RESET, hci_cc_reset),
4039 HCI_CC(HCI_OP_READ_STORED_LINK_KEY, hci_cc_read_stored_link_key,
4040 sizeof(struct hci_rp_read_stored_link_key)),
4041 HCI_CC(HCI_OP_DELETE_STORED_LINK_KEY, hci_cc_delete_stored_link_key,
4042 sizeof(struct hci_rp_delete_stored_link_key)),
4043 HCI_CC_STATUS(HCI_OP_WRITE_LOCAL_NAME, hci_cc_write_local_name),
4044 HCI_CC(HCI_OP_READ_LOCAL_NAME, hci_cc_read_local_name,
4045 sizeof(struct hci_rp_read_local_name)),
4046 HCI_CC_STATUS(HCI_OP_WRITE_AUTH_ENABLE, hci_cc_write_auth_enable),
4047 HCI_CC_STATUS(HCI_OP_WRITE_ENCRYPT_MODE, hci_cc_write_encrypt_mode),
4048 HCI_CC_STATUS(HCI_OP_WRITE_SCAN_ENABLE, hci_cc_write_scan_enable),
4049 HCI_CC_STATUS(HCI_OP_SET_EVENT_FLT, hci_cc_set_event_filter),
4050 HCI_CC(HCI_OP_READ_CLASS_OF_DEV, hci_cc_read_class_of_dev,
4051 sizeof(struct hci_rp_read_class_of_dev)),
4052 HCI_CC_STATUS(HCI_OP_WRITE_CLASS_OF_DEV, hci_cc_write_class_of_dev),
4053 HCI_CC(HCI_OP_READ_VOICE_SETTING, hci_cc_read_voice_setting,
4054 sizeof(struct hci_rp_read_voice_setting)),
4055 HCI_CC_STATUS(HCI_OP_WRITE_VOICE_SETTING, hci_cc_write_voice_setting),
4056 HCI_CC(HCI_OP_READ_NUM_SUPPORTED_IAC, hci_cc_read_num_supported_iac,
4057 sizeof(struct hci_rp_read_num_supported_iac)),
4058 HCI_CC_STATUS(HCI_OP_WRITE_SSP_MODE, hci_cc_write_ssp_mode),
4059 HCI_CC_STATUS(HCI_OP_WRITE_SC_SUPPORT, hci_cc_write_sc_support),
4060 HCI_CC(HCI_OP_READ_AUTH_PAYLOAD_TO, hci_cc_read_auth_payload_timeout,
4061 sizeof(struct hci_rp_read_auth_payload_to)),
4062 HCI_CC(HCI_OP_WRITE_AUTH_PAYLOAD_TO, hci_cc_write_auth_payload_timeout,
4063 sizeof(struct hci_rp_write_auth_payload_to)),
4064 HCI_CC(HCI_OP_READ_LOCAL_VERSION, hci_cc_read_local_version,
4065 sizeof(struct hci_rp_read_local_version)),
4066 HCI_CC(HCI_OP_READ_LOCAL_COMMANDS, hci_cc_read_local_commands,
4067 sizeof(struct hci_rp_read_local_commands)),
4068 HCI_CC(HCI_OP_READ_LOCAL_FEATURES, hci_cc_read_local_features,
4069 sizeof(struct hci_rp_read_local_features)),
4070 HCI_CC(HCI_OP_READ_LOCAL_EXT_FEATURES, hci_cc_read_local_ext_features,
4071 sizeof(struct hci_rp_read_local_ext_features)),
4072 HCI_CC(HCI_OP_READ_BUFFER_SIZE, hci_cc_read_buffer_size,
4073 sizeof(struct hci_rp_read_buffer_size)),
4074 HCI_CC(HCI_OP_READ_BD_ADDR, hci_cc_read_bd_addr,
4075 sizeof(struct hci_rp_read_bd_addr)),
4076 HCI_CC(HCI_OP_READ_LOCAL_PAIRING_OPTS, hci_cc_read_local_pairing_opts,
4077 sizeof(struct hci_rp_read_local_pairing_opts)),
4078 HCI_CC(HCI_OP_READ_PAGE_SCAN_ACTIVITY, hci_cc_read_page_scan_activity,
4079 sizeof(struct hci_rp_read_page_scan_activity)),
4080 HCI_CC_STATUS(HCI_OP_WRITE_PAGE_SCAN_ACTIVITY,
4081 hci_cc_write_page_scan_activity),
4082 HCI_CC(HCI_OP_READ_PAGE_SCAN_TYPE, hci_cc_read_page_scan_type,
4083 sizeof(struct hci_rp_read_page_scan_type)),
4084 HCI_CC_STATUS(HCI_OP_WRITE_PAGE_SCAN_TYPE, hci_cc_write_page_scan_type),
4085 HCI_CC(HCI_OP_READ_DATA_BLOCK_SIZE, hci_cc_read_data_block_size,
4086 sizeof(struct hci_rp_read_data_block_size)),
4087 HCI_CC(HCI_OP_READ_FLOW_CONTROL_MODE, hci_cc_read_flow_control_mode,
4088 sizeof(struct hci_rp_read_flow_control_mode)),
4089 HCI_CC(HCI_OP_READ_LOCAL_AMP_INFO, hci_cc_read_local_amp_info,
4090 sizeof(struct hci_rp_read_local_amp_info)),
4091 HCI_CC(HCI_OP_READ_CLOCK, hci_cc_read_clock,
4092 sizeof(struct hci_rp_read_clock)),
4093 HCI_CC(HCI_OP_READ_ENC_KEY_SIZE, hci_cc_read_enc_key_size,
4094 sizeof(struct hci_rp_read_enc_key_size)),
4095 HCI_CC(HCI_OP_READ_INQ_RSP_TX_POWER, hci_cc_read_inq_rsp_tx_power,
4096 sizeof(struct hci_rp_read_inq_rsp_tx_power)),
4097 HCI_CC(HCI_OP_READ_DEF_ERR_DATA_REPORTING,
4098 hci_cc_read_def_err_data_reporting,
4099 sizeof(struct hci_rp_read_def_err_data_reporting)),
4100 HCI_CC_STATUS(HCI_OP_WRITE_DEF_ERR_DATA_REPORTING,
4101 hci_cc_write_def_err_data_reporting),
4102 HCI_CC(HCI_OP_PIN_CODE_REPLY, hci_cc_pin_code_reply,
4103 sizeof(struct hci_rp_pin_code_reply)),
4104 HCI_CC(HCI_OP_PIN_CODE_NEG_REPLY, hci_cc_pin_code_neg_reply,
4105 sizeof(struct hci_rp_pin_code_neg_reply)),
4106 HCI_CC(HCI_OP_READ_LOCAL_OOB_DATA, hci_cc_read_local_oob_data,
4107 sizeof(struct hci_rp_read_local_oob_data)),
4108 HCI_CC(HCI_OP_READ_LOCAL_OOB_EXT_DATA, hci_cc_read_local_oob_ext_data,
4109 sizeof(struct hci_rp_read_local_oob_ext_data)),
4110 HCI_CC(HCI_OP_LE_READ_BUFFER_SIZE, hci_cc_le_read_buffer_size,
4111 sizeof(struct hci_rp_le_read_buffer_size)),
4112 HCI_CC(HCI_OP_LE_READ_LOCAL_FEATURES, hci_cc_le_read_local_features,
4113 sizeof(struct hci_rp_le_read_local_features)),
4114 HCI_CC(HCI_OP_LE_READ_ADV_TX_POWER, hci_cc_le_read_adv_tx_power,
4115 sizeof(struct hci_rp_le_read_adv_tx_power)),
4116 HCI_CC(HCI_OP_USER_CONFIRM_REPLY, hci_cc_user_confirm_reply,
4117 sizeof(struct hci_rp_user_confirm_reply)),
4118 HCI_CC(HCI_OP_USER_CONFIRM_NEG_REPLY, hci_cc_user_confirm_neg_reply,
4119 sizeof(struct hci_rp_user_confirm_reply)),
4120 HCI_CC(HCI_OP_USER_PASSKEY_REPLY, hci_cc_user_passkey_reply,
4121 sizeof(struct hci_rp_user_confirm_reply)),
4122 HCI_CC(HCI_OP_USER_PASSKEY_NEG_REPLY, hci_cc_user_passkey_neg_reply,
4123 sizeof(struct hci_rp_user_confirm_reply)),
4124 HCI_CC_STATUS(HCI_OP_LE_SET_RANDOM_ADDR, hci_cc_le_set_random_addr),
4125 HCI_CC_STATUS(HCI_OP_LE_SET_ADV_ENABLE, hci_cc_le_set_adv_enable),
4126 HCI_CC_STATUS(HCI_OP_LE_SET_SCAN_PARAM, hci_cc_le_set_scan_param),
4127 HCI_CC_STATUS(HCI_OP_LE_SET_SCAN_ENABLE, hci_cc_le_set_scan_enable),
4128 HCI_CC(HCI_OP_LE_READ_ACCEPT_LIST_SIZE,
4129 hci_cc_le_read_accept_list_size,
4130 sizeof(struct hci_rp_le_read_accept_list_size)),
4131 HCI_CC_STATUS(HCI_OP_LE_CLEAR_ACCEPT_LIST, hci_cc_le_clear_accept_list),
4132 HCI_CC_STATUS(HCI_OP_LE_ADD_TO_ACCEPT_LIST,
4133 hci_cc_le_add_to_accept_list),
4134 HCI_CC_STATUS(HCI_OP_LE_DEL_FROM_ACCEPT_LIST,
4135 hci_cc_le_del_from_accept_list),
4136 HCI_CC(HCI_OP_LE_READ_SUPPORTED_STATES, hci_cc_le_read_supported_states,
4137 sizeof(struct hci_rp_le_read_supported_states)),
4138 HCI_CC(HCI_OP_LE_READ_DEF_DATA_LEN, hci_cc_le_read_def_data_len,
4139 sizeof(struct hci_rp_le_read_def_data_len)),
4140 HCI_CC_STATUS(HCI_OP_LE_WRITE_DEF_DATA_LEN,
4141 hci_cc_le_write_def_data_len),
4142 HCI_CC_STATUS(HCI_OP_LE_ADD_TO_RESOLV_LIST,
4143 hci_cc_le_add_to_resolv_list),
4144 HCI_CC_STATUS(HCI_OP_LE_DEL_FROM_RESOLV_LIST,
4145 hci_cc_le_del_from_resolv_list),
4146 HCI_CC_STATUS(HCI_OP_LE_CLEAR_RESOLV_LIST,
4147 hci_cc_le_clear_resolv_list),
4148 HCI_CC(HCI_OP_LE_READ_RESOLV_LIST_SIZE, hci_cc_le_read_resolv_list_size,
4149 sizeof(struct hci_rp_le_read_resolv_list_size)),
4150 HCI_CC_STATUS(HCI_OP_LE_SET_ADDR_RESOLV_ENABLE,
4151 hci_cc_le_set_addr_resolution_enable),
4152 HCI_CC(HCI_OP_LE_READ_MAX_DATA_LEN, hci_cc_le_read_max_data_len,
4153 sizeof(struct hci_rp_le_read_max_data_len)),
4154 HCI_CC_STATUS(HCI_OP_WRITE_LE_HOST_SUPPORTED,
4155 hci_cc_write_le_host_supported),
4156 HCI_CC_STATUS(HCI_OP_LE_SET_ADV_PARAM, hci_cc_set_adv_param),
4157 HCI_CC(HCI_OP_READ_RSSI, hci_cc_read_rssi,
4158 sizeof(struct hci_rp_read_rssi)),
4159 HCI_CC(HCI_OP_READ_TX_POWER, hci_cc_read_tx_power,
4160 sizeof(struct hci_rp_read_tx_power)),
4161 HCI_CC_STATUS(HCI_OP_WRITE_SSP_DEBUG_MODE, hci_cc_write_ssp_debug_mode),
4162 HCI_CC_STATUS(HCI_OP_LE_SET_EXT_SCAN_PARAMS,
4163 hci_cc_le_set_ext_scan_param),
4164 HCI_CC_STATUS(HCI_OP_LE_SET_EXT_SCAN_ENABLE,
4165 hci_cc_le_set_ext_scan_enable),
4166 HCI_CC_STATUS(HCI_OP_LE_SET_DEFAULT_PHY, hci_cc_le_set_default_phy),
4167 HCI_CC(HCI_OP_LE_READ_NUM_SUPPORTED_ADV_SETS,
4168 hci_cc_le_read_num_adv_sets,
4169 sizeof(struct hci_rp_le_read_num_supported_adv_sets)),
4170 HCI_CC(HCI_OP_LE_SET_EXT_ADV_PARAMS, hci_cc_set_ext_adv_param,
4171 sizeof(struct hci_rp_le_set_ext_adv_params)),
4172 HCI_CC_STATUS(HCI_OP_LE_SET_EXT_ADV_ENABLE,
4173 hci_cc_le_set_ext_adv_enable),
4174 HCI_CC_STATUS(HCI_OP_LE_SET_ADV_SET_RAND_ADDR,
4175 hci_cc_le_set_adv_set_random_addr),
4176 HCI_CC_STATUS(HCI_OP_LE_REMOVE_ADV_SET, hci_cc_le_remove_adv_set),
4177 HCI_CC_STATUS(HCI_OP_LE_CLEAR_ADV_SETS, hci_cc_le_clear_adv_sets),
4178 HCI_CC_STATUS(HCI_OP_LE_SET_PER_ADV_PARAMS, hci_cc_set_per_adv_param),
4179 HCI_CC_STATUS(HCI_OP_LE_SET_PER_ADV_ENABLE,
4180 hci_cc_le_set_per_adv_enable),
4181 HCI_CC(HCI_OP_LE_READ_TRANSMIT_POWER, hci_cc_le_read_transmit_power,
4182 sizeof(struct hci_rp_le_read_transmit_power)),
4183 HCI_CC_STATUS(HCI_OP_LE_SET_PRIVACY_MODE, hci_cc_le_set_privacy_mode),
4184 HCI_CC(HCI_OP_LE_READ_BUFFER_SIZE_V2, hci_cc_le_read_buffer_size_v2,
4185 sizeof(struct hci_rp_le_read_buffer_size_v2)),
4186 HCI_CC_VL(HCI_OP_LE_SET_CIG_PARAMS, hci_cc_le_set_cig_params,
4187 sizeof(struct hci_rp_le_set_cig_params), HCI_MAX_EVENT_SIZE),
4188 HCI_CC(HCI_OP_LE_SETUP_ISO_PATH, hci_cc_le_setup_iso_path,
4189 sizeof(struct hci_rp_le_setup_iso_path)),
4192 static u8 hci_cc_func(struct hci_dev *hdev, const struct hci_cc *cc,
4193 struct sk_buff *skb)
4197 if (skb->len < cc->min_len) {
4198 bt_dev_err(hdev, "unexpected cc 0x%4.4x length: %u < %u",
4199 cc->op, skb->len, cc->min_len);
4200 return HCI_ERROR_UNSPECIFIED;
4203 /* Just warn if the length is over max_len size it still be possible to
4204 * partially parse the cc so leave to callback to decide if that is
4207 if (skb->len > cc->max_len)
4208 bt_dev_warn(hdev, "unexpected cc 0x%4.4x length: %u > %u",
4209 cc->op, skb->len, cc->max_len);
4211 data = hci_cc_skb_pull(hdev, skb, cc->op, cc->min_len);
4213 return HCI_ERROR_UNSPECIFIED;
4215 return cc->func(hdev, data, skb);
4218 static void hci_cmd_complete_evt(struct hci_dev *hdev, void *data,
4219 struct sk_buff *skb, u16 *opcode, u8 *status,
4220 hci_req_complete_t *req_complete,
4221 hci_req_complete_skb_t *req_complete_skb)
4223 struct hci_ev_cmd_complete *ev = data;
4226 *opcode = __le16_to_cpu(ev->opcode);
4228 bt_dev_dbg(hdev, "opcode 0x%4.4x", *opcode);
4230 for (i = 0; i < ARRAY_SIZE(hci_cc_table); i++) {
4231 if (hci_cc_table[i].op == *opcode) {
4232 *status = hci_cc_func(hdev, &hci_cc_table[i], skb);
4237 if (i == ARRAY_SIZE(hci_cc_table)) {
4238 /* Unknown opcode, assume byte 0 contains the status, so
4239 * that e.g. __hci_cmd_sync() properly returns errors
4240 * for vendor specific commands send by HCI drivers.
4241 * If a vendor doesn't actually follow this convention we may
4242 * need to introduce a vendor CC table in order to properly set
4245 *status = skb->data[0];
4248 handle_cmd_cnt_and_timer(hdev, ev->ncmd);
4250 hci_req_cmd_complete(hdev, *opcode, *status, req_complete,
4253 if (hci_dev_test_flag(hdev, HCI_CMD_PENDING)) {
4255 "unexpected event for opcode 0x%4.4x", *opcode);
4259 if (atomic_read(&hdev->cmd_cnt) && !skb_queue_empty(&hdev->cmd_q))
4260 queue_work(hdev->workqueue, &hdev->cmd_work);
4263 static void hci_cs_le_create_cis(struct hci_dev *hdev, u8 status)
4265 struct hci_cp_le_create_cis *cp;
4266 bool pending = false;
4269 bt_dev_dbg(hdev, "status 0x%2.2x", status);
4274 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_CREATE_CIS);
4280 /* Remove connection if command failed */
4281 for (i = 0; cp->num_cis; cp->num_cis--, i++) {
4282 struct hci_conn *conn;
4285 handle = __le16_to_cpu(cp->cis[i].cis_handle);
4287 conn = hci_conn_hash_lookup_handle(hdev, handle);
4289 if (test_and_clear_bit(HCI_CONN_CREATE_CIS,
4292 conn->state = BT_CLOSED;
4293 hci_connect_cfm(conn, status);
4299 hci_le_create_cis_pending(hdev);
4301 hci_dev_unlock(hdev);
4304 #define HCI_CS(_op, _func) \
4310 static const struct hci_cs {
4312 void (*func)(struct hci_dev *hdev, __u8 status);
4313 } hci_cs_table[] = {
4314 HCI_CS(HCI_OP_INQUIRY, hci_cs_inquiry),
4315 HCI_CS(HCI_OP_CREATE_CONN, hci_cs_create_conn),
4316 HCI_CS(HCI_OP_DISCONNECT, hci_cs_disconnect),
4317 HCI_CS(HCI_OP_ADD_SCO, hci_cs_add_sco),
4318 HCI_CS(HCI_OP_AUTH_REQUESTED, hci_cs_auth_requested),
4319 HCI_CS(HCI_OP_SET_CONN_ENCRYPT, hci_cs_set_conn_encrypt),
4320 HCI_CS(HCI_OP_REMOTE_NAME_REQ, hci_cs_remote_name_req),
4321 HCI_CS(HCI_OP_READ_REMOTE_FEATURES, hci_cs_read_remote_features),
4322 HCI_CS(HCI_OP_READ_REMOTE_EXT_FEATURES,
4323 hci_cs_read_remote_ext_features),
4324 HCI_CS(HCI_OP_SETUP_SYNC_CONN, hci_cs_setup_sync_conn),
4325 HCI_CS(HCI_OP_ENHANCED_SETUP_SYNC_CONN,
4326 hci_cs_enhanced_setup_sync_conn),
4327 HCI_CS(HCI_OP_SNIFF_MODE, hci_cs_sniff_mode),
4328 HCI_CS(HCI_OP_EXIT_SNIFF_MODE, hci_cs_exit_sniff_mode),
4329 HCI_CS(HCI_OP_SWITCH_ROLE, hci_cs_switch_role),
4330 HCI_CS(HCI_OP_LE_CREATE_CONN, hci_cs_le_create_conn),
4331 HCI_CS(HCI_OP_LE_READ_REMOTE_FEATURES, hci_cs_le_read_remote_features),
4332 HCI_CS(HCI_OP_LE_START_ENC, hci_cs_le_start_enc),
4333 HCI_CS(HCI_OP_LE_EXT_CREATE_CONN, hci_cs_le_ext_create_conn),
4334 HCI_CS(HCI_OP_LE_CREATE_CIS, hci_cs_le_create_cis),
4335 HCI_CS(HCI_OP_LE_CREATE_BIG, hci_cs_le_create_big),
4338 static void hci_cmd_status_evt(struct hci_dev *hdev, void *data,
4339 struct sk_buff *skb, u16 *opcode, u8 *status,
4340 hci_req_complete_t *req_complete,
4341 hci_req_complete_skb_t *req_complete_skb)
4343 struct hci_ev_cmd_status *ev = data;
4346 *opcode = __le16_to_cpu(ev->opcode);
4347 *status = ev->status;
4349 bt_dev_dbg(hdev, "opcode 0x%4.4x", *opcode);
4351 for (i = 0; i < ARRAY_SIZE(hci_cs_table); i++) {
4352 if (hci_cs_table[i].op == *opcode) {
4353 hci_cs_table[i].func(hdev, ev->status);
4358 handle_cmd_cnt_and_timer(hdev, ev->ncmd);
4360 /* Indicate request completion if the command failed. Also, if
4361 * we're not waiting for a special event and we get a success
4362 * command status we should try to flag the request as completed
4363 * (since for this kind of commands there will not be a command
4366 if (ev->status || (hdev->sent_cmd && !hci_skb_event(hdev->sent_cmd))) {
4367 hci_req_cmd_complete(hdev, *opcode, ev->status, req_complete,
4369 if (hci_dev_test_flag(hdev, HCI_CMD_PENDING)) {
4370 bt_dev_err(hdev, "unexpected event for opcode 0x%4.4x",
4376 if (atomic_read(&hdev->cmd_cnt) && !skb_queue_empty(&hdev->cmd_q))
4377 queue_work(hdev->workqueue, &hdev->cmd_work);
4380 static void hci_hardware_error_evt(struct hci_dev *hdev, void *data,
4381 struct sk_buff *skb)
4383 struct hci_ev_hardware_error *ev = data;
4385 bt_dev_dbg(hdev, "code 0x%2.2x", ev->code);
4387 hdev->hw_error_code = ev->code;
4389 queue_work(hdev->req_workqueue, &hdev->error_reset);
4392 static void hci_role_change_evt(struct hci_dev *hdev, void *data,
4393 struct sk_buff *skb)
4395 struct hci_ev_role_change *ev = data;
4396 struct hci_conn *conn;
4398 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
4402 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
4405 conn->role = ev->role;
4407 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->flags);
4409 hci_role_switch_cfm(conn, ev->status, ev->role);
4412 hci_dev_unlock(hdev);
4415 static void hci_num_comp_pkts_evt(struct hci_dev *hdev, void *data,
4416 struct sk_buff *skb)
4418 struct hci_ev_num_comp_pkts *ev = data;
4421 if (!hci_ev_skb_pull(hdev, skb, HCI_EV_NUM_COMP_PKTS,
4422 flex_array_size(ev, handles, ev->num)))
4425 if (hdev->flow_ctl_mode != HCI_FLOW_CTL_MODE_PACKET_BASED) {
4426 bt_dev_err(hdev, "wrong event for mode %d", hdev->flow_ctl_mode);
4430 bt_dev_dbg(hdev, "num %d", ev->num);
4432 for (i = 0; i < ev->num; i++) {
4433 struct hci_comp_pkts_info *info = &ev->handles[i];
4434 struct hci_conn *conn;
4435 __u16 handle, count;
4437 handle = __le16_to_cpu(info->handle);
4438 count = __le16_to_cpu(info->count);
4440 conn = hci_conn_hash_lookup_handle(hdev, handle);
4444 conn->sent -= count;
4446 switch (conn->type) {
4448 hdev->acl_cnt += count;
4449 if (hdev->acl_cnt > hdev->acl_pkts)
4450 hdev->acl_cnt = hdev->acl_pkts;
4454 if (hdev->le_pkts) {
4455 hdev->le_cnt += count;
4456 if (hdev->le_cnt > hdev->le_pkts)
4457 hdev->le_cnt = hdev->le_pkts;
4459 hdev->acl_cnt += count;
4460 if (hdev->acl_cnt > hdev->acl_pkts)
4461 hdev->acl_cnt = hdev->acl_pkts;
4466 hdev->sco_cnt += count;
4467 if (hdev->sco_cnt > hdev->sco_pkts)
4468 hdev->sco_cnt = hdev->sco_pkts;
4472 if (hdev->iso_pkts) {
4473 hdev->iso_cnt += count;
4474 if (hdev->iso_cnt > hdev->iso_pkts)
4475 hdev->iso_cnt = hdev->iso_pkts;
4476 } else if (hdev->le_pkts) {
4477 hdev->le_cnt += count;
4478 if (hdev->le_cnt > hdev->le_pkts)
4479 hdev->le_cnt = hdev->le_pkts;
4481 hdev->acl_cnt += count;
4482 if (hdev->acl_cnt > hdev->acl_pkts)
4483 hdev->acl_cnt = hdev->acl_pkts;
4488 bt_dev_err(hdev, "unknown type %d conn %p",
4494 queue_work(hdev->workqueue, &hdev->tx_work);
4497 static struct hci_conn *__hci_conn_lookup_handle(struct hci_dev *hdev,
4500 struct hci_chan *chan;
4502 switch (hdev->dev_type) {
4504 return hci_conn_hash_lookup_handle(hdev, handle);
4506 chan = hci_chan_lookup_handle(hdev, handle);
4511 bt_dev_err(hdev, "unknown dev_type %d", hdev->dev_type);
4518 static void hci_num_comp_blocks_evt(struct hci_dev *hdev, void *data,
4519 struct sk_buff *skb)
4521 struct hci_ev_num_comp_blocks *ev = data;
4524 if (!hci_ev_skb_pull(hdev, skb, HCI_EV_NUM_COMP_BLOCKS,
4525 flex_array_size(ev, handles, ev->num_hndl)))
4528 if (hdev->flow_ctl_mode != HCI_FLOW_CTL_MODE_BLOCK_BASED) {
4529 bt_dev_err(hdev, "wrong event for mode %d",
4530 hdev->flow_ctl_mode);
4534 bt_dev_dbg(hdev, "num_blocks %d num_hndl %d", ev->num_blocks,
4537 for (i = 0; i < ev->num_hndl; i++) {
4538 struct hci_comp_blocks_info *info = &ev->handles[i];
4539 struct hci_conn *conn = NULL;
4540 __u16 handle, block_count;
4542 handle = __le16_to_cpu(info->handle);
4543 block_count = __le16_to_cpu(info->blocks);
4545 conn = __hci_conn_lookup_handle(hdev, handle);
4549 conn->sent -= block_count;
4551 switch (conn->type) {
4554 hdev->block_cnt += block_count;
4555 if (hdev->block_cnt > hdev->num_blocks)
4556 hdev->block_cnt = hdev->num_blocks;
4560 bt_dev_err(hdev, "unknown type %d conn %p",
4566 queue_work(hdev->workqueue, &hdev->tx_work);
4569 static void hci_mode_change_evt(struct hci_dev *hdev, void *data,
4570 struct sk_buff *skb)
4572 struct hci_ev_mode_change *ev = data;
4573 struct hci_conn *conn;
4575 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
4579 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
4581 conn->mode = ev->mode;
4583 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND,
4585 if (conn->mode == HCI_CM_ACTIVE)
4586 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
4588 clear_bit(HCI_CONN_POWER_SAVE, &conn->flags);
4591 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
4592 hci_sco_setup(conn, ev->status);
4595 hci_dev_unlock(hdev);
4598 static void hci_pin_code_request_evt(struct hci_dev *hdev, void *data,
4599 struct sk_buff *skb)
4601 struct hci_ev_pin_code_req *ev = data;
4602 struct hci_conn *conn;
4604 bt_dev_dbg(hdev, "");
4608 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
4612 if (conn->state == BT_CONNECTED) {
4613 hci_conn_hold(conn);
4614 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
4615 hci_conn_drop(conn);
4618 if (!hci_dev_test_flag(hdev, HCI_BONDABLE) &&
4619 !test_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags)) {
4620 hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
4621 sizeof(ev->bdaddr), &ev->bdaddr);
4622 } else if (hci_dev_test_flag(hdev, HCI_MGMT)) {
4625 if (conn->pending_sec_level == BT_SECURITY_HIGH)
4630 mgmt_pin_code_request(hdev, &ev->bdaddr, secure);
4634 hci_dev_unlock(hdev);
4637 static void conn_set_key(struct hci_conn *conn, u8 key_type, u8 pin_len)
4639 if (key_type == HCI_LK_CHANGED_COMBINATION)
4642 conn->pin_length = pin_len;
4643 conn->key_type = key_type;
4646 case HCI_LK_LOCAL_UNIT:
4647 case HCI_LK_REMOTE_UNIT:
4648 case HCI_LK_DEBUG_COMBINATION:
4650 case HCI_LK_COMBINATION:
4652 conn->pending_sec_level = BT_SECURITY_HIGH;
4654 conn->pending_sec_level = BT_SECURITY_MEDIUM;
4656 case HCI_LK_UNAUTH_COMBINATION_P192:
4657 case HCI_LK_UNAUTH_COMBINATION_P256:
4658 conn->pending_sec_level = BT_SECURITY_MEDIUM;
4660 case HCI_LK_AUTH_COMBINATION_P192:
4661 conn->pending_sec_level = BT_SECURITY_HIGH;
4663 case HCI_LK_AUTH_COMBINATION_P256:
4664 conn->pending_sec_level = BT_SECURITY_FIPS;
4669 static void hci_link_key_request_evt(struct hci_dev *hdev, void *data,
4670 struct sk_buff *skb)
4672 struct hci_ev_link_key_req *ev = data;
4673 struct hci_cp_link_key_reply cp;
4674 struct hci_conn *conn;
4675 struct link_key *key;
4677 bt_dev_dbg(hdev, "");
4679 if (!hci_dev_test_flag(hdev, HCI_MGMT))
4684 key = hci_find_link_key(hdev, &ev->bdaddr);
4686 bt_dev_dbg(hdev, "link key not found for %pMR", &ev->bdaddr);
4690 bt_dev_dbg(hdev, "found key type %u for %pMR", key->type, &ev->bdaddr);
4692 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
4694 clear_bit(HCI_CONN_NEW_LINK_KEY, &conn->flags);
4696 if ((key->type == HCI_LK_UNAUTH_COMBINATION_P192 ||
4697 key->type == HCI_LK_UNAUTH_COMBINATION_P256) &&
4698 conn->auth_type != 0xff && (conn->auth_type & 0x01)) {
4699 bt_dev_dbg(hdev, "ignoring unauthenticated key");
4703 if (key->type == HCI_LK_COMBINATION && key->pin_len < 16 &&
4704 (conn->pending_sec_level == BT_SECURITY_HIGH ||
4705 conn->pending_sec_level == BT_SECURITY_FIPS)) {
4706 bt_dev_dbg(hdev, "ignoring key unauthenticated for high security");
4710 conn_set_key(conn, key->type, key->pin_len);
4713 bacpy(&cp.bdaddr, &ev->bdaddr);
4714 memcpy(cp.link_key, key->val, HCI_LINK_KEY_SIZE);
4716 hci_send_cmd(hdev, HCI_OP_LINK_KEY_REPLY, sizeof(cp), &cp);
4718 hci_dev_unlock(hdev);
4723 hci_send_cmd(hdev, HCI_OP_LINK_KEY_NEG_REPLY, 6, &ev->bdaddr);
4724 hci_dev_unlock(hdev);
4727 static void hci_link_key_notify_evt(struct hci_dev *hdev, void *data,
4728 struct sk_buff *skb)
4730 struct hci_ev_link_key_notify *ev = data;
4731 struct hci_conn *conn;
4732 struct link_key *key;
4736 bt_dev_dbg(hdev, "");
4740 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
4744 hci_conn_hold(conn);
4745 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
4746 hci_conn_drop(conn);
4748 set_bit(HCI_CONN_NEW_LINK_KEY, &conn->flags);
4749 conn_set_key(conn, ev->key_type, conn->pin_length);
4751 if (!hci_dev_test_flag(hdev, HCI_MGMT))
4754 key = hci_add_link_key(hdev, conn, &ev->bdaddr, ev->link_key,
4755 ev->key_type, pin_len, &persistent);
4759 /* Update connection information since adding the key will have
4760 * fixed up the type in the case of changed combination keys.
4762 if (ev->key_type == HCI_LK_CHANGED_COMBINATION)
4763 conn_set_key(conn, key->type, key->pin_len);
4765 mgmt_new_link_key(hdev, key, persistent);
4767 /* Keep debug keys around only if the HCI_KEEP_DEBUG_KEYS flag
4768 * is set. If it's not set simply remove the key from the kernel
4769 * list (we've still notified user space about it but with
4770 * store_hint being 0).
4772 if (key->type == HCI_LK_DEBUG_COMBINATION &&
4773 !hci_dev_test_flag(hdev, HCI_KEEP_DEBUG_KEYS)) {
4774 list_del_rcu(&key->list);
4775 kfree_rcu(key, rcu);
4780 clear_bit(HCI_CONN_FLUSH_KEY, &conn->flags);
4782 set_bit(HCI_CONN_FLUSH_KEY, &conn->flags);
4785 hci_dev_unlock(hdev);
4788 static void hci_clock_offset_evt(struct hci_dev *hdev, void *data,
4789 struct sk_buff *skb)
4791 struct hci_ev_clock_offset *ev = data;
4792 struct hci_conn *conn;
4794 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
4798 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
4799 if (conn && !ev->status) {
4800 struct inquiry_entry *ie;
4802 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
4804 ie->data.clock_offset = ev->clock_offset;
4805 ie->timestamp = jiffies;
4809 hci_dev_unlock(hdev);
4812 static void hci_pkt_type_change_evt(struct hci_dev *hdev, void *data,
4813 struct sk_buff *skb)
4815 struct hci_ev_pkt_type_change *ev = data;
4816 struct hci_conn *conn;
4818 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
4822 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
4823 if (conn && !ev->status)
4824 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
4826 hci_dev_unlock(hdev);
4829 static void hci_pscan_rep_mode_evt(struct hci_dev *hdev, void *data,
4830 struct sk_buff *skb)
4832 struct hci_ev_pscan_rep_mode *ev = data;
4833 struct inquiry_entry *ie;
4835 bt_dev_dbg(hdev, "");
4839 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
4841 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
4842 ie->timestamp = jiffies;
4845 hci_dev_unlock(hdev);
4848 static void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, void *edata,
4849 struct sk_buff *skb)
4851 struct hci_ev_inquiry_result_rssi *ev = edata;
4852 struct inquiry_data data;
4855 bt_dev_dbg(hdev, "num_rsp %d", ev->num);
4860 if (hci_dev_test_flag(hdev, HCI_PERIODIC_INQ))
4865 if (skb->len == array_size(ev->num,
4866 sizeof(struct inquiry_info_rssi_pscan))) {
4867 struct inquiry_info_rssi_pscan *info;
4869 for (i = 0; i < ev->num; i++) {
4872 info = hci_ev_skb_pull(hdev, skb,
4873 HCI_EV_INQUIRY_RESULT_WITH_RSSI,
4876 bt_dev_err(hdev, "Malformed HCI Event: 0x%2.2x",
4877 HCI_EV_INQUIRY_RESULT_WITH_RSSI);
4881 bacpy(&data.bdaddr, &info->bdaddr);
4882 data.pscan_rep_mode = info->pscan_rep_mode;
4883 data.pscan_period_mode = info->pscan_period_mode;
4884 data.pscan_mode = info->pscan_mode;
4885 memcpy(data.dev_class, info->dev_class, 3);
4886 data.clock_offset = info->clock_offset;
4887 data.rssi = info->rssi;
4888 data.ssp_mode = 0x00;
4890 flags = hci_inquiry_cache_update(hdev, &data, false);
4892 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
4893 info->dev_class, info->rssi,
4894 flags, NULL, 0, NULL, 0, 0);
4896 } else if (skb->len == array_size(ev->num,
4897 sizeof(struct inquiry_info_rssi))) {
4898 struct inquiry_info_rssi *info;
4900 for (i = 0; i < ev->num; i++) {
4903 info = hci_ev_skb_pull(hdev, skb,
4904 HCI_EV_INQUIRY_RESULT_WITH_RSSI,
4907 bt_dev_err(hdev, "Malformed HCI Event: 0x%2.2x",
4908 HCI_EV_INQUIRY_RESULT_WITH_RSSI);
4912 bacpy(&data.bdaddr, &info->bdaddr);
4913 data.pscan_rep_mode = info->pscan_rep_mode;
4914 data.pscan_period_mode = info->pscan_period_mode;
4915 data.pscan_mode = 0x00;
4916 memcpy(data.dev_class, info->dev_class, 3);
4917 data.clock_offset = info->clock_offset;
4918 data.rssi = info->rssi;
4919 data.ssp_mode = 0x00;
4921 flags = hci_inquiry_cache_update(hdev, &data, false);
4923 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
4924 info->dev_class, info->rssi,
4925 flags, NULL, 0, NULL, 0, 0);
4928 bt_dev_err(hdev, "Malformed HCI Event: 0x%2.2x",
4929 HCI_EV_INQUIRY_RESULT_WITH_RSSI);
4932 hci_dev_unlock(hdev);
4935 static void hci_remote_ext_features_evt(struct hci_dev *hdev, void *data,
4936 struct sk_buff *skb)
4938 struct hci_ev_remote_ext_features *ev = data;
4939 struct hci_conn *conn;
4941 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
4945 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
4949 if (ev->page < HCI_MAX_PAGES)
4950 memcpy(conn->features[ev->page], ev->features, 8);
4952 if (!ev->status && ev->page == 0x01) {
4953 struct inquiry_entry *ie;
4955 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
4957 ie->data.ssp_mode = (ev->features[0] & LMP_HOST_SSP);
4959 if (ev->features[0] & LMP_HOST_SSP) {
4960 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
4962 /* It is mandatory by the Bluetooth specification that
4963 * Extended Inquiry Results are only used when Secure
4964 * Simple Pairing is enabled, but some devices violate
4967 * To make these devices work, the internal SSP
4968 * enabled flag needs to be cleared if the remote host
4969 * features do not indicate SSP support */
4970 clear_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
4973 if (ev->features[0] & LMP_HOST_SC)
4974 set_bit(HCI_CONN_SC_ENABLED, &conn->flags);
4977 if (conn->state != BT_CONFIG)
4980 if (!ev->status && !test_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags)) {
4981 struct hci_cp_remote_name_req cp;
4982 memset(&cp, 0, sizeof(cp));
4983 bacpy(&cp.bdaddr, &conn->dst);
4984 cp.pscan_rep_mode = 0x02;
4985 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
4986 } else if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
4987 mgmt_device_connected(hdev, conn, NULL, 0);
4989 if (!hci_outgoing_auth_needed(hdev, conn)) {
4990 conn->state = BT_CONNECTED;
4991 hci_connect_cfm(conn, ev->status);
4992 hci_conn_drop(conn);
4996 hci_dev_unlock(hdev);
4999 static void hci_sync_conn_complete_evt(struct hci_dev *hdev, void *data,
5000 struct sk_buff *skb)
5002 struct hci_ev_sync_conn_complete *ev = data;
5003 struct hci_conn *conn;
5004 u8 status = ev->status;
5006 switch (ev->link_type) {
5011 /* As per Core 5.3 Vol 4 Part E 7.7.35 (p.2219), Link_Type
5012 * for HCI_Synchronous_Connection_Complete is limited to
5013 * either SCO or eSCO
5015 bt_dev_err(hdev, "Ignoring connect complete event for invalid link type");
5019 bt_dev_dbg(hdev, "status 0x%2.2x", status);
5023 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
5025 if (ev->link_type == ESCO_LINK)
5028 /* When the link type in the event indicates SCO connection
5029 * and lookup of the connection object fails, then check
5030 * if an eSCO connection object exists.
5032 * The core limits the synchronous connections to either
5033 * SCO or eSCO. The eSCO connection is preferred and tried
5034 * to be setup first and until successfully established,
5035 * the link type will be hinted as eSCO.
5037 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
5042 /* The HCI_Synchronous_Connection_Complete event is only sent once per connection.
5043 * Processing it more than once per connection can corrupt kernel memory.
5045 * As the connection handle is set here for the first time, it indicates
5046 * whether the connection is already set up.
5048 if (!HCI_CONN_HANDLE_UNSET(conn->handle)) {
5049 bt_dev_err(hdev, "Ignoring HCI_Sync_Conn_Complete event for existing connection");
5055 status = hci_conn_set_handle(conn, __le16_to_cpu(ev->handle));
5057 conn->state = BT_CLOSED;
5061 conn->state = BT_CONNECTED;
5062 conn->type = ev->link_type;
5064 hci_debugfs_create_conn(conn);
5065 hci_conn_add_sysfs(conn);
5068 case 0x10: /* Connection Accept Timeout */
5069 case 0x0d: /* Connection Rejected due to Limited Resources */
5070 case 0x11: /* Unsupported Feature or Parameter Value */
5071 case 0x1c: /* SCO interval rejected */
5072 case 0x1a: /* Unsupported Remote Feature */
5073 case 0x1e: /* Invalid LMP Parameters */
5074 case 0x1f: /* Unspecified error */
5075 case 0x20: /* Unsupported LMP Parameter value */
5077 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
5078 (hdev->esco_type & EDR_ESCO_MASK);
5079 if (hci_setup_sync(conn, conn->parent->handle))
5085 conn->state = BT_CLOSED;
5089 bt_dev_dbg(hdev, "SCO connected with air mode: %02x", ev->air_mode);
5090 /* Notify only in case of SCO over HCI transport data path which
5091 * is zero and non-zero value shall be non-HCI transport data path
5093 if (conn->codec.data_path == 0 && hdev->notify) {
5094 switch (ev->air_mode) {
5096 hdev->notify(hdev, HCI_NOTIFY_ENABLE_SCO_CVSD);
5099 hdev->notify(hdev, HCI_NOTIFY_ENABLE_SCO_TRANSP);
5104 hci_connect_cfm(conn, status);
5109 hci_dev_unlock(hdev);
5112 static inline size_t eir_get_length(u8 *eir, size_t eir_len)
5116 while (parsed < eir_len) {
5117 u8 field_len = eir[0];
5122 parsed += field_len + 1;
5123 eir += field_len + 1;
5129 static void hci_extended_inquiry_result_evt(struct hci_dev *hdev, void *edata,
5130 struct sk_buff *skb)
5132 struct hci_ev_ext_inquiry_result *ev = edata;
5133 struct inquiry_data data;
5137 if (!hci_ev_skb_pull(hdev, skb, HCI_EV_EXTENDED_INQUIRY_RESULT,
5138 flex_array_size(ev, info, ev->num)))
5141 bt_dev_dbg(hdev, "num %d", ev->num);
5146 if (hci_dev_test_flag(hdev, HCI_PERIODIC_INQ))
5151 for (i = 0; i < ev->num; i++) {
5152 struct extended_inquiry_info *info = &ev->info[i];
5156 bacpy(&data.bdaddr, &info->bdaddr);
5157 data.pscan_rep_mode = info->pscan_rep_mode;
5158 data.pscan_period_mode = info->pscan_period_mode;
5159 data.pscan_mode = 0x00;
5160 memcpy(data.dev_class, info->dev_class, 3);
5161 data.clock_offset = info->clock_offset;
5162 data.rssi = info->rssi;
5163 data.ssp_mode = 0x01;
5165 if (hci_dev_test_flag(hdev, HCI_MGMT))
5166 name_known = eir_get_data(info->data,
5168 EIR_NAME_COMPLETE, NULL);
5172 flags = hci_inquiry_cache_update(hdev, &data, name_known);
5174 eir_len = eir_get_length(info->data, sizeof(info->data));
5176 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
5177 info->dev_class, info->rssi,
5178 flags, info->data, eir_len, NULL, 0, 0);
5181 hci_dev_unlock(hdev);
5184 static void hci_key_refresh_complete_evt(struct hci_dev *hdev, void *data,
5185 struct sk_buff *skb)
5187 struct hci_ev_key_refresh_complete *ev = data;
5188 struct hci_conn *conn;
5190 bt_dev_dbg(hdev, "status 0x%2.2x handle 0x%4.4x", ev->status,
5191 __le16_to_cpu(ev->handle));
5195 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
5199 /* For BR/EDR the necessary steps are taken through the
5200 * auth_complete event.
5202 if (conn->type != LE_LINK)
5206 conn->sec_level = conn->pending_sec_level;
5208 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
5210 if (ev->status && conn->state == BT_CONNECTED) {
5211 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
5212 hci_conn_drop(conn);
5216 if (conn->state == BT_CONFIG) {
5218 conn->state = BT_CONNECTED;
5220 hci_connect_cfm(conn, ev->status);
5221 hci_conn_drop(conn);
5223 hci_auth_cfm(conn, ev->status);
5225 hci_conn_hold(conn);
5226 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
5227 hci_conn_drop(conn);
5231 hci_dev_unlock(hdev);
5234 static u8 hci_get_auth_req(struct hci_conn *conn)
5236 /* If remote requests no-bonding follow that lead */
5237 if (conn->remote_auth == HCI_AT_NO_BONDING ||
5238 conn->remote_auth == HCI_AT_NO_BONDING_MITM)
5239 return conn->remote_auth | (conn->auth_type & 0x01);
5241 /* If both remote and local have enough IO capabilities, require
5244 if (conn->remote_cap != HCI_IO_NO_INPUT_OUTPUT &&
5245 conn->io_capability != HCI_IO_NO_INPUT_OUTPUT)
5246 return conn->remote_auth | 0x01;
5248 /* No MITM protection possible so ignore remote requirement */
5249 return (conn->remote_auth & ~0x01) | (conn->auth_type & 0x01);
5252 static u8 bredr_oob_data_present(struct hci_conn *conn)
5254 struct hci_dev *hdev = conn->hdev;
5255 struct oob_data *data;
5257 data = hci_find_remote_oob_data(hdev, &conn->dst, BDADDR_BREDR);
5261 if (bredr_sc_enabled(hdev)) {
5262 /* When Secure Connections is enabled, then just
5263 * return the present value stored with the OOB
5264 * data. The stored value contains the right present
5265 * information. However it can only be trusted when
5266 * not in Secure Connection Only mode.
5268 if (!hci_dev_test_flag(hdev, HCI_SC_ONLY))
5269 return data->present;
5271 /* When Secure Connections Only mode is enabled, then
5272 * the P-256 values are required. If they are not
5273 * available, then do not declare that OOB data is
5276 if (!memcmp(data->rand256, ZERO_KEY, 16) ||
5277 !memcmp(data->hash256, ZERO_KEY, 16))
5283 /* When Secure Connections is not enabled or actually
5284 * not supported by the hardware, then check that if
5285 * P-192 data values are present.
5287 if (!memcmp(data->rand192, ZERO_KEY, 16) ||
5288 !memcmp(data->hash192, ZERO_KEY, 16))
5294 static void hci_io_capa_request_evt(struct hci_dev *hdev, void *data,
5295 struct sk_buff *skb)
5297 struct hci_ev_io_capa_request *ev = data;
5298 struct hci_conn *conn;
5300 bt_dev_dbg(hdev, "");
5304 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5308 hci_conn_hold(conn);
5310 if (!hci_dev_test_flag(hdev, HCI_MGMT))
5313 /* Allow pairing if we're pairable, the initiators of the
5314 * pairing or if the remote is not requesting bonding.
5316 if (hci_dev_test_flag(hdev, HCI_BONDABLE) ||
5317 test_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags) ||
5318 (conn->remote_auth & ~0x01) == HCI_AT_NO_BONDING) {
5319 struct hci_cp_io_capability_reply cp;
5321 bacpy(&cp.bdaddr, &ev->bdaddr);
5322 /* Change the IO capability from KeyboardDisplay
5323 * to DisplayYesNo as it is not supported by BT spec. */
5324 cp.capability = (conn->io_capability == 0x04) ?
5325 HCI_IO_DISPLAY_YESNO : conn->io_capability;
5327 /* If we are initiators, there is no remote information yet */
5328 if (conn->remote_auth == 0xff) {
5329 /* Request MITM protection if our IO caps allow it
5330 * except for the no-bonding case.
5332 if (conn->io_capability != HCI_IO_NO_INPUT_OUTPUT &&
5333 conn->auth_type != HCI_AT_NO_BONDING)
5334 conn->auth_type |= 0x01;
5336 conn->auth_type = hci_get_auth_req(conn);
5339 /* If we're not bondable, force one of the non-bondable
5340 * authentication requirement values.
5342 if (!hci_dev_test_flag(hdev, HCI_BONDABLE))
5343 conn->auth_type &= HCI_AT_NO_BONDING_MITM;
5345 cp.authentication = conn->auth_type;
5346 cp.oob_data = bredr_oob_data_present(conn);
5348 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_REPLY,
5351 struct hci_cp_io_capability_neg_reply cp;
5353 bacpy(&cp.bdaddr, &ev->bdaddr);
5354 cp.reason = HCI_ERROR_PAIRING_NOT_ALLOWED;
5356 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_NEG_REPLY,
5361 hci_dev_unlock(hdev);
5364 static void hci_io_capa_reply_evt(struct hci_dev *hdev, void *data,
5365 struct sk_buff *skb)
5367 struct hci_ev_io_capa_reply *ev = data;
5368 struct hci_conn *conn;
5370 bt_dev_dbg(hdev, "");
5374 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5378 conn->remote_cap = ev->capability;
5379 conn->remote_auth = ev->authentication;
5382 hci_dev_unlock(hdev);
5385 static void hci_user_confirm_request_evt(struct hci_dev *hdev, void *data,
5386 struct sk_buff *skb)
5388 struct hci_ev_user_confirm_req *ev = data;
5389 int loc_mitm, rem_mitm, confirm_hint = 0;
5390 struct hci_conn *conn;
5392 bt_dev_dbg(hdev, "");
5396 if (!hci_dev_test_flag(hdev, HCI_MGMT))
5399 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5403 loc_mitm = (conn->auth_type & 0x01);
5404 rem_mitm = (conn->remote_auth & 0x01);
5406 /* If we require MITM but the remote device can't provide that
5407 * (it has NoInputNoOutput) then reject the confirmation
5408 * request. We check the security level here since it doesn't
5409 * necessarily match conn->auth_type.
5411 if (conn->pending_sec_level > BT_SECURITY_MEDIUM &&
5412 conn->remote_cap == HCI_IO_NO_INPUT_OUTPUT) {
5413 bt_dev_dbg(hdev, "Rejecting request: remote device can't provide MITM");
5414 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_NEG_REPLY,
5415 sizeof(ev->bdaddr), &ev->bdaddr);
5419 /* If no side requires MITM protection; auto-accept */
5420 if ((!loc_mitm || conn->remote_cap == HCI_IO_NO_INPUT_OUTPUT) &&
5421 (!rem_mitm || conn->io_capability == HCI_IO_NO_INPUT_OUTPUT)) {
5423 /* If we're not the initiators request authorization to
5424 * proceed from user space (mgmt_user_confirm with
5425 * confirm_hint set to 1). The exception is if neither
5426 * side had MITM or if the local IO capability is
5427 * NoInputNoOutput, in which case we do auto-accept
5429 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags) &&
5430 conn->io_capability != HCI_IO_NO_INPUT_OUTPUT &&
5431 (loc_mitm || rem_mitm)) {
5432 bt_dev_dbg(hdev, "Confirming auto-accept as acceptor");
5437 /* If there already exists link key in local host, leave the
5438 * decision to user space since the remote device could be
5439 * legitimate or malicious.
5441 if (hci_find_link_key(hdev, &ev->bdaddr)) {
5442 bt_dev_dbg(hdev, "Local host already has link key");
5447 BT_DBG("Auto-accept of user confirmation with %ums delay",
5448 hdev->auto_accept_delay);
5450 if (hdev->auto_accept_delay > 0) {
5451 int delay = msecs_to_jiffies(hdev->auto_accept_delay);
5452 queue_delayed_work(conn->hdev->workqueue,
5453 &conn->auto_accept_work, delay);
5457 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY,
5458 sizeof(ev->bdaddr), &ev->bdaddr);
5463 mgmt_user_confirm_request(hdev, &ev->bdaddr, ACL_LINK, 0,
5464 le32_to_cpu(ev->passkey), confirm_hint);
5467 hci_dev_unlock(hdev);
5470 static void hci_user_passkey_request_evt(struct hci_dev *hdev, void *data,
5471 struct sk_buff *skb)
5473 struct hci_ev_user_passkey_req *ev = data;
5475 bt_dev_dbg(hdev, "");
5477 if (hci_dev_test_flag(hdev, HCI_MGMT))
5478 mgmt_user_passkey_request(hdev, &ev->bdaddr, ACL_LINK, 0);
5481 static void hci_user_passkey_notify_evt(struct hci_dev *hdev, void *data,
5482 struct sk_buff *skb)
5484 struct hci_ev_user_passkey_notify *ev = data;
5485 struct hci_conn *conn;
5487 bt_dev_dbg(hdev, "");
5489 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5493 conn->passkey_notify = __le32_to_cpu(ev->passkey);
5494 conn->passkey_entered = 0;
5496 if (hci_dev_test_flag(hdev, HCI_MGMT))
5497 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
5498 conn->dst_type, conn->passkey_notify,
5499 conn->passkey_entered);
5502 static void hci_keypress_notify_evt(struct hci_dev *hdev, void *data,
5503 struct sk_buff *skb)
5505 struct hci_ev_keypress_notify *ev = data;
5506 struct hci_conn *conn;
5508 bt_dev_dbg(hdev, "");
5510 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5515 case HCI_KEYPRESS_STARTED:
5516 conn->passkey_entered = 0;
5519 case HCI_KEYPRESS_ENTERED:
5520 conn->passkey_entered++;
5523 case HCI_KEYPRESS_ERASED:
5524 conn->passkey_entered--;
5527 case HCI_KEYPRESS_CLEARED:
5528 conn->passkey_entered = 0;
5531 case HCI_KEYPRESS_COMPLETED:
5535 if (hci_dev_test_flag(hdev, HCI_MGMT))
5536 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
5537 conn->dst_type, conn->passkey_notify,
5538 conn->passkey_entered);
5541 static void hci_simple_pair_complete_evt(struct hci_dev *hdev, void *data,
5542 struct sk_buff *skb)
5544 struct hci_ev_simple_pair_complete *ev = data;
5545 struct hci_conn *conn;
5547 bt_dev_dbg(hdev, "");
5551 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5555 /* Reset the authentication requirement to unknown */
5556 conn->remote_auth = 0xff;
5558 /* To avoid duplicate auth_failed events to user space we check
5559 * the HCI_CONN_AUTH_PEND flag which will be set if we
5560 * initiated the authentication. A traditional auth_complete
5561 * event gets always produced as initiator and is also mapped to
5562 * the mgmt_auth_failed event */
5563 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags) && ev->status)
5564 mgmt_auth_failed(conn, ev->status);
5566 hci_conn_drop(conn);
5569 hci_dev_unlock(hdev);
5572 static void hci_remote_host_features_evt(struct hci_dev *hdev, void *data,
5573 struct sk_buff *skb)
5575 struct hci_ev_remote_host_features *ev = data;
5576 struct inquiry_entry *ie;
5577 struct hci_conn *conn;
5579 bt_dev_dbg(hdev, "");
5583 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
5585 memcpy(conn->features[1], ev->features, 8);
5587 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
5589 ie->data.ssp_mode = (ev->features[0] & LMP_HOST_SSP);
5591 hci_dev_unlock(hdev);
5594 static void hci_remote_oob_data_request_evt(struct hci_dev *hdev, void *edata,
5595 struct sk_buff *skb)
5597 struct hci_ev_remote_oob_data_request *ev = edata;
5598 struct oob_data *data;
5600 bt_dev_dbg(hdev, "");
5604 if (!hci_dev_test_flag(hdev, HCI_MGMT))
5607 data = hci_find_remote_oob_data(hdev, &ev->bdaddr, BDADDR_BREDR);
5609 struct hci_cp_remote_oob_data_neg_reply cp;
5611 bacpy(&cp.bdaddr, &ev->bdaddr);
5612 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_NEG_REPLY,
5617 if (bredr_sc_enabled(hdev)) {
5618 struct hci_cp_remote_oob_ext_data_reply cp;
5620 bacpy(&cp.bdaddr, &ev->bdaddr);
5621 if (hci_dev_test_flag(hdev, HCI_SC_ONLY)) {
5622 memset(cp.hash192, 0, sizeof(cp.hash192));
5623 memset(cp.rand192, 0, sizeof(cp.rand192));
5625 memcpy(cp.hash192, data->hash192, sizeof(cp.hash192));
5626 memcpy(cp.rand192, data->rand192, sizeof(cp.rand192));
5628 memcpy(cp.hash256, data->hash256, sizeof(cp.hash256));
5629 memcpy(cp.rand256, data->rand256, sizeof(cp.rand256));
5631 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_EXT_DATA_REPLY,
5634 struct hci_cp_remote_oob_data_reply cp;
5636 bacpy(&cp.bdaddr, &ev->bdaddr);
5637 memcpy(cp.hash, data->hash192, sizeof(cp.hash));
5638 memcpy(cp.rand, data->rand192, sizeof(cp.rand));
5640 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_REPLY,
5645 hci_dev_unlock(hdev);
5648 #if IS_ENABLED(CONFIG_BT_HS)
5649 static void hci_chan_selected_evt(struct hci_dev *hdev, void *data,
5650 struct sk_buff *skb)
5652 struct hci_ev_channel_selected *ev = data;
5653 struct hci_conn *hcon;
5655 bt_dev_dbg(hdev, "handle 0x%2.2x", ev->phy_handle);
5657 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
5661 amp_read_loc_assoc_final_data(hdev, hcon);
5664 static void hci_phy_link_complete_evt(struct hci_dev *hdev, void *data,
5665 struct sk_buff *skb)
5667 struct hci_ev_phy_link_complete *ev = data;
5668 struct hci_conn *hcon, *bredr_hcon;
5670 bt_dev_dbg(hdev, "handle 0x%2.2x status 0x%2.2x", ev->phy_handle,
5675 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
5687 bredr_hcon = hcon->amp_mgr->l2cap_conn->hcon;
5689 hcon->state = BT_CONNECTED;
5690 bacpy(&hcon->dst, &bredr_hcon->dst);
5692 hci_conn_hold(hcon);
5693 hcon->disc_timeout = HCI_DISCONN_TIMEOUT;
5694 hci_conn_drop(hcon);
5696 hci_debugfs_create_conn(hcon);
5697 hci_conn_add_sysfs(hcon);
5699 amp_physical_cfm(bredr_hcon, hcon);
5702 hci_dev_unlock(hdev);
5705 static void hci_loglink_complete_evt(struct hci_dev *hdev, void *data,
5706 struct sk_buff *skb)
5708 struct hci_ev_logical_link_complete *ev = data;
5709 struct hci_conn *hcon;
5710 struct hci_chan *hchan;
5711 struct amp_mgr *mgr;
5713 bt_dev_dbg(hdev, "log_handle 0x%4.4x phy_handle 0x%2.2x status 0x%2.2x",
5714 le16_to_cpu(ev->handle), ev->phy_handle, ev->status);
5716 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
5720 /* Create AMP hchan */
5721 hchan = hci_chan_create(hcon);
5725 hchan->handle = le16_to_cpu(ev->handle);
5728 BT_DBG("hcon %p mgr %p hchan %p", hcon, hcon->amp_mgr, hchan);
5730 mgr = hcon->amp_mgr;
5731 if (mgr && mgr->bredr_chan) {
5732 struct l2cap_chan *bredr_chan = mgr->bredr_chan;
5734 l2cap_chan_lock(bredr_chan);
5736 bredr_chan->conn->mtu = hdev->block_mtu;
5737 l2cap_logical_cfm(bredr_chan, hchan, 0);
5738 hci_conn_hold(hcon);
5740 l2cap_chan_unlock(bredr_chan);
5744 static void hci_disconn_loglink_complete_evt(struct hci_dev *hdev, void *data,
5745 struct sk_buff *skb)
5747 struct hci_ev_disconn_logical_link_complete *ev = data;
5748 struct hci_chan *hchan;
5750 bt_dev_dbg(hdev, "handle 0x%4.4x status 0x%2.2x",
5751 le16_to_cpu(ev->handle), ev->status);
5758 hchan = hci_chan_lookup_handle(hdev, le16_to_cpu(ev->handle));
5759 if (!hchan || !hchan->amp)
5762 amp_destroy_logical_link(hchan, ev->reason);
5765 hci_dev_unlock(hdev);
5768 static void hci_disconn_phylink_complete_evt(struct hci_dev *hdev, void *data,
5769 struct sk_buff *skb)
5771 struct hci_ev_disconn_phy_link_complete *ev = data;
5772 struct hci_conn *hcon;
5774 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
5781 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
5782 if (hcon && hcon->type == AMP_LINK) {
5783 hcon->state = BT_CLOSED;
5784 hci_disconn_cfm(hcon, ev->reason);
5788 hci_dev_unlock(hdev);
5792 static void le_conn_update_addr(struct hci_conn *conn, bdaddr_t *bdaddr,
5793 u8 bdaddr_type, bdaddr_t *local_rpa)
5796 conn->dst_type = bdaddr_type;
5797 conn->resp_addr_type = bdaddr_type;
5798 bacpy(&conn->resp_addr, bdaddr);
5800 /* Check if the controller has set a Local RPA then it must be
5801 * used instead or hdev->rpa.
5803 if (local_rpa && bacmp(local_rpa, BDADDR_ANY)) {
5804 conn->init_addr_type = ADDR_LE_DEV_RANDOM;
5805 bacpy(&conn->init_addr, local_rpa);
5806 } else if (hci_dev_test_flag(conn->hdev, HCI_PRIVACY)) {
5807 conn->init_addr_type = ADDR_LE_DEV_RANDOM;
5808 bacpy(&conn->init_addr, &conn->hdev->rpa);
5810 hci_copy_identity_address(conn->hdev, &conn->init_addr,
5811 &conn->init_addr_type);
5814 conn->resp_addr_type = conn->hdev->adv_addr_type;
5815 /* Check if the controller has set a Local RPA then it must be
5816 * used instead or hdev->rpa.
5818 if (local_rpa && bacmp(local_rpa, BDADDR_ANY)) {
5819 conn->resp_addr_type = ADDR_LE_DEV_RANDOM;
5820 bacpy(&conn->resp_addr, local_rpa);
5821 } else if (conn->hdev->adv_addr_type == ADDR_LE_DEV_RANDOM) {
5822 /* In case of ext adv, resp_addr will be updated in
5823 * Adv Terminated event.
5825 if (!ext_adv_capable(conn->hdev))
5826 bacpy(&conn->resp_addr,
5827 &conn->hdev->random_addr);
5829 bacpy(&conn->resp_addr, &conn->hdev->bdaddr);
5832 conn->init_addr_type = bdaddr_type;
5833 bacpy(&conn->init_addr, bdaddr);
5835 /* For incoming connections, set the default minimum
5836 * and maximum connection interval. They will be used
5837 * to check if the parameters are in range and if not
5838 * trigger the connection update procedure.
5840 conn->le_conn_min_interval = conn->hdev->le_conn_min_interval;
5841 conn->le_conn_max_interval = conn->hdev->le_conn_max_interval;
5845 static void le_conn_complete_evt(struct hci_dev *hdev, u8 status,
5846 bdaddr_t *bdaddr, u8 bdaddr_type,
5847 bdaddr_t *local_rpa, u8 role, u16 handle,
5848 u16 interval, u16 latency,
5849 u16 supervision_timeout)
5851 struct hci_conn_params *params;
5852 struct hci_conn *conn;
5853 struct smp_irk *irk;
5858 /* All controllers implicitly stop advertising in the event of a
5859 * connection, so ensure that the state bit is cleared.
5861 hci_dev_clear_flag(hdev, HCI_LE_ADV);
5863 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, bdaddr);
5865 /* In case of error status and there is no connection pending
5866 * just unlock as there is nothing to cleanup.
5871 conn = hci_conn_add(hdev, LE_LINK, bdaddr, role);
5873 bt_dev_err(hdev, "no memory for new connection");
5877 conn->dst_type = bdaddr_type;
5879 /* If we didn't have a hci_conn object previously
5880 * but we're in central role this must be something
5881 * initiated using an accept list. Since accept list based
5882 * connections are not "first class citizens" we don't
5883 * have full tracking of them. Therefore, we go ahead
5884 * with a "best effort" approach of determining the
5885 * initiator address based on the HCI_PRIVACY flag.
5888 conn->resp_addr_type = bdaddr_type;
5889 bacpy(&conn->resp_addr, bdaddr);
5890 if (hci_dev_test_flag(hdev, HCI_PRIVACY)) {
5891 conn->init_addr_type = ADDR_LE_DEV_RANDOM;
5892 bacpy(&conn->init_addr, &hdev->rpa);
5894 hci_copy_identity_address(hdev,
5896 &conn->init_addr_type);
5900 cancel_delayed_work(&conn->le_conn_timeout);
5903 /* The HCI_LE_Connection_Complete event is only sent once per connection.
5904 * Processing it more than once per connection can corrupt kernel memory.
5906 * As the connection handle is set here for the first time, it indicates
5907 * whether the connection is already set up.
5909 if (!HCI_CONN_HANDLE_UNSET(conn->handle)) {
5910 bt_dev_err(hdev, "Ignoring HCI_Connection_Complete for existing connection");
5914 le_conn_update_addr(conn, bdaddr, bdaddr_type, local_rpa);
5916 /* Lookup the identity address from the stored connection
5917 * address and address type.
5919 * When establishing connections to an identity address, the
5920 * connection procedure will store the resolvable random
5921 * address first. Now if it can be converted back into the
5922 * identity address, start using the identity address from
5925 irk = hci_get_irk(hdev, &conn->dst, conn->dst_type);
5927 bacpy(&conn->dst, &irk->bdaddr);
5928 conn->dst_type = irk->addr_type;
5931 conn->dst_type = ev_bdaddr_type(hdev, conn->dst_type, NULL);
5933 if (handle > HCI_CONN_HANDLE_MAX) {
5934 bt_dev_err(hdev, "Invalid handle: 0x%4.4x > 0x%4.4x", handle,
5935 HCI_CONN_HANDLE_MAX);
5936 status = HCI_ERROR_INVALID_PARAMETERS;
5939 /* All connection failure handling is taken care of by the
5940 * hci_conn_failed function which is triggered by the HCI
5941 * request completion callbacks used for connecting.
5946 /* Drop the connection if it has been aborted */
5947 if (test_bit(HCI_CONN_CANCEL, &conn->flags)) {
5948 hci_conn_drop(conn);
5952 if (conn->dst_type == ADDR_LE_DEV_PUBLIC)
5953 addr_type = BDADDR_LE_PUBLIC;
5955 addr_type = BDADDR_LE_RANDOM;
5957 /* Drop the connection if the device is blocked */
5958 if (hci_bdaddr_list_lookup(&hdev->reject_list, &conn->dst, addr_type)) {
5959 hci_conn_drop(conn);
5963 if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
5964 mgmt_device_connected(hdev, conn, NULL, 0);
5966 conn->sec_level = BT_SECURITY_LOW;
5967 conn->handle = handle;
5968 conn->state = BT_CONFIG;
5970 /* Store current advertising instance as connection advertising instance
5971 * when sotfware rotation is in use so it can be re-enabled when
5974 if (!ext_adv_capable(hdev))
5975 conn->adv_instance = hdev->cur_adv_instance;
5977 conn->le_conn_interval = interval;
5978 conn->le_conn_latency = latency;
5979 conn->le_supv_timeout = supervision_timeout;
5981 hci_debugfs_create_conn(conn);
5982 hci_conn_add_sysfs(conn);
5984 /* The remote features procedure is defined for central
5985 * role only. So only in case of an initiated connection
5986 * request the remote features.
5988 * If the local controller supports peripheral-initiated features
5989 * exchange, then requesting the remote features in peripheral
5990 * role is possible. Otherwise just transition into the
5991 * connected state without requesting the remote features.
5994 (hdev->le_features[0] & HCI_LE_PERIPHERAL_FEATURES)) {
5995 struct hci_cp_le_read_remote_features cp;
5997 cp.handle = __cpu_to_le16(conn->handle);
5999 hci_send_cmd(hdev, HCI_OP_LE_READ_REMOTE_FEATURES,
6002 hci_conn_hold(conn);
6004 conn->state = BT_CONNECTED;
6005 hci_connect_cfm(conn, status);
6008 params = hci_pend_le_action_lookup(&hdev->pend_le_conns, &conn->dst,
6011 hci_pend_le_list_del_init(params);
6013 hci_conn_drop(params->conn);
6014 hci_conn_put(params->conn);
6015 params->conn = NULL;
6020 hci_update_passive_scan(hdev);
6021 hci_dev_unlock(hdev);
6024 static void hci_le_conn_complete_evt(struct hci_dev *hdev, void *data,
6025 struct sk_buff *skb)
6027 struct hci_ev_le_conn_complete *ev = data;
6029 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
6031 le_conn_complete_evt(hdev, ev->status, &ev->bdaddr, ev->bdaddr_type,
6032 NULL, ev->role, le16_to_cpu(ev->handle),
6033 le16_to_cpu(ev->interval),
6034 le16_to_cpu(ev->latency),
6035 le16_to_cpu(ev->supervision_timeout));
6038 static void hci_le_enh_conn_complete_evt(struct hci_dev *hdev, void *data,
6039 struct sk_buff *skb)
6041 struct hci_ev_le_enh_conn_complete *ev = data;
6043 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
6045 le_conn_complete_evt(hdev, ev->status, &ev->bdaddr, ev->bdaddr_type,
6046 &ev->local_rpa, ev->role, le16_to_cpu(ev->handle),
6047 le16_to_cpu(ev->interval),
6048 le16_to_cpu(ev->latency),
6049 le16_to_cpu(ev->supervision_timeout));
6052 static void hci_le_ext_adv_term_evt(struct hci_dev *hdev, void *data,
6053 struct sk_buff *skb)
6055 struct hci_evt_le_ext_adv_set_term *ev = data;
6056 struct hci_conn *conn;
6057 struct adv_info *adv, *n;
6059 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
6061 /* The Bluetooth Core 5.3 specification clearly states that this event
6062 * shall not be sent when the Host disables the advertising set. So in
6063 * case of HCI_ERROR_CANCELLED_BY_HOST, just ignore the event.
6065 * When the Host disables an advertising set, all cleanup is done via
6066 * its command callback and not needed to be duplicated here.
6068 if (ev->status == HCI_ERROR_CANCELLED_BY_HOST) {
6069 bt_dev_warn_ratelimited(hdev, "Unexpected advertising set terminated event");
6075 adv = hci_find_adv_instance(hdev, ev->handle);
6081 /* Remove advertising as it has been terminated */
6082 hci_remove_adv_instance(hdev, ev->handle);
6083 mgmt_advertising_removed(NULL, hdev, ev->handle);
6085 list_for_each_entry_safe(adv, n, &hdev->adv_instances, list) {
6090 /* We are no longer advertising, clear HCI_LE_ADV */
6091 hci_dev_clear_flag(hdev, HCI_LE_ADV);
6096 adv->enabled = false;
6098 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->conn_handle));
6100 /* Store handle in the connection so the correct advertising
6101 * instance can be re-enabled when disconnected.
6103 conn->adv_instance = ev->handle;
6105 if (hdev->adv_addr_type != ADDR_LE_DEV_RANDOM ||
6106 bacmp(&conn->resp_addr, BDADDR_ANY))
6110 bacpy(&conn->resp_addr, &hdev->random_addr);
6115 bacpy(&conn->resp_addr, &adv->random_addr);
6119 hci_dev_unlock(hdev);
6122 static void hci_le_conn_update_complete_evt(struct hci_dev *hdev, void *data,
6123 struct sk_buff *skb)
6125 struct hci_ev_le_conn_update_complete *ev = data;
6126 struct hci_conn *conn;
6128 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
6135 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
6137 conn->le_conn_interval = le16_to_cpu(ev->interval);
6138 conn->le_conn_latency = le16_to_cpu(ev->latency);
6139 conn->le_supv_timeout = le16_to_cpu(ev->supervision_timeout);
6142 hci_dev_unlock(hdev);
6145 /* This function requires the caller holds hdev->lock */
6146 static struct hci_conn *check_pending_le_conn(struct hci_dev *hdev,
6148 u8 addr_type, bool addr_resolved,
6151 struct hci_conn *conn;
6152 struct hci_conn_params *params;
6154 /* If the event is not connectable don't proceed further */
6155 if (adv_type != LE_ADV_IND && adv_type != LE_ADV_DIRECT_IND)
6158 /* Ignore if the device is blocked or hdev is suspended */
6159 if (hci_bdaddr_list_lookup(&hdev->reject_list, addr, addr_type) ||
6163 /* Most controller will fail if we try to create new connections
6164 * while we have an existing one in peripheral role.
6166 if (hdev->conn_hash.le_num_peripheral > 0 &&
6167 (!test_bit(HCI_QUIRK_VALID_LE_STATES, &hdev->quirks) ||
6168 !(hdev->le_states[3] & 0x10)))
6171 /* If we're not connectable only connect devices that we have in
6172 * our pend_le_conns list.
6174 params = hci_pend_le_action_lookup(&hdev->pend_le_conns, addr,
6179 if (!params->explicit_connect) {
6180 switch (params->auto_connect) {
6181 case HCI_AUTO_CONN_DIRECT:
6182 /* Only devices advertising with ADV_DIRECT_IND are
6183 * triggering a connection attempt. This is allowing
6184 * incoming connections from peripheral devices.
6186 if (adv_type != LE_ADV_DIRECT_IND)
6189 case HCI_AUTO_CONN_ALWAYS:
6190 /* Devices advertising with ADV_IND or ADV_DIRECT_IND
6191 * are triggering a connection attempt. This means
6192 * that incoming connections from peripheral device are
6193 * accepted and also outgoing connections to peripheral
6194 * devices are established when found.
6202 conn = hci_connect_le(hdev, addr, addr_type, addr_resolved,
6203 BT_SECURITY_LOW, hdev->def_le_autoconnect_timeout,
6205 if (!IS_ERR(conn)) {
6206 /* If HCI_AUTO_CONN_EXPLICIT is set, conn is already owned
6207 * by higher layer that tried to connect, if no then
6208 * store the pointer since we don't really have any
6209 * other owner of the object besides the params that
6210 * triggered it. This way we can abort the connection if
6211 * the parameters get removed and keep the reference
6212 * count consistent once the connection is established.
6215 if (!params->explicit_connect)
6216 params->conn = hci_conn_get(conn);
6221 switch (PTR_ERR(conn)) {
6223 /* If hci_connect() returns -EBUSY it means there is already
6224 * an LE connection attempt going on. Since controllers don't
6225 * support more than one connection attempt at the time, we
6226 * don't consider this an error case.
6230 BT_DBG("Failed to connect: err %ld", PTR_ERR(conn));
6237 static void process_adv_report(struct hci_dev *hdev, u8 type, bdaddr_t *bdaddr,
6238 u8 bdaddr_type, bdaddr_t *direct_addr,
6239 u8 direct_addr_type, s8 rssi, u8 *data, u8 len,
6240 bool ext_adv, bool ctl_time, u64 instant)
6242 struct discovery_state *d = &hdev->discovery;
6243 struct smp_irk *irk;
6244 struct hci_conn *conn;
6245 bool match, bdaddr_resolved;
6251 case LE_ADV_DIRECT_IND:
6252 case LE_ADV_SCAN_IND:
6253 case LE_ADV_NONCONN_IND:
6254 case LE_ADV_SCAN_RSP:
6257 bt_dev_err_ratelimited(hdev, "unknown advertising packet "
6258 "type: 0x%02x", type);
6262 if (len > max_adv_len(hdev)) {
6263 bt_dev_err_ratelimited(hdev,
6264 "adv larger than maximum supported");
6268 /* Find the end of the data in case the report contains padded zero
6269 * bytes at the end causing an invalid length value.
6271 * When data is NULL, len is 0 so there is no need for extra ptr
6272 * check as 'ptr < data + 0' is already false in such case.
6274 for (ptr = data; ptr < data + len && *ptr; ptr += *ptr + 1) {
6275 if (ptr + 1 + *ptr > data + len)
6279 /* Adjust for actual length. This handles the case when remote
6280 * device is advertising with incorrect data length.
6284 /* If the direct address is present, then this report is from
6285 * a LE Direct Advertising Report event. In that case it is
6286 * important to see if the address is matching the local
6287 * controller address.
6289 if (!hci_dev_test_flag(hdev, HCI_MESH) && direct_addr) {
6290 direct_addr_type = ev_bdaddr_type(hdev, direct_addr_type,
6293 /* Only resolvable random addresses are valid for these
6294 * kind of reports and others can be ignored.
6296 if (!hci_bdaddr_is_rpa(direct_addr, direct_addr_type))
6299 /* If the controller is not using resolvable random
6300 * addresses, then this report can be ignored.
6302 if (!hci_dev_test_flag(hdev, HCI_PRIVACY))
6305 /* If the local IRK of the controller does not match
6306 * with the resolvable random address provided, then
6307 * this report can be ignored.
6309 if (!smp_irk_matches(hdev, hdev->irk, direct_addr))
6313 /* Check if we need to convert to identity address */
6314 irk = hci_get_irk(hdev, bdaddr, bdaddr_type);
6316 bdaddr = &irk->bdaddr;
6317 bdaddr_type = irk->addr_type;
6320 bdaddr_type = ev_bdaddr_type(hdev, bdaddr_type, &bdaddr_resolved);
6322 /* Check if we have been requested to connect to this device.
6324 * direct_addr is set only for directed advertising reports (it is NULL
6325 * for advertising reports) and is already verified to be RPA above.
6327 conn = check_pending_le_conn(hdev, bdaddr, bdaddr_type, bdaddr_resolved,
6329 if (!ext_adv && conn && type == LE_ADV_IND &&
6330 len <= max_adv_len(hdev)) {
6331 /* Store report for later inclusion by
6332 * mgmt_device_connected
6334 memcpy(conn->le_adv_data, data, len);
6335 conn->le_adv_data_len = len;
6338 if (type == LE_ADV_NONCONN_IND || type == LE_ADV_SCAN_IND)
6339 flags = MGMT_DEV_FOUND_NOT_CONNECTABLE;
6343 /* All scan results should be sent up for Mesh systems */
6344 if (hci_dev_test_flag(hdev, HCI_MESH)) {
6345 mgmt_device_found(hdev, bdaddr, LE_LINK, bdaddr_type, NULL,
6346 rssi, flags, data, len, NULL, 0, instant);
6350 /* Passive scanning shouldn't trigger any device found events,
6351 * except for devices marked as CONN_REPORT for which we do send
6352 * device found events, or advertisement monitoring requested.
6354 if (hdev->le_scan_type == LE_SCAN_PASSIVE) {
6355 if (type == LE_ADV_DIRECT_IND)
6358 if (!hci_pend_le_action_lookup(&hdev->pend_le_reports,
6359 bdaddr, bdaddr_type) &&
6360 idr_is_empty(&hdev->adv_monitors_idr))
6363 mgmt_device_found(hdev, bdaddr, LE_LINK, bdaddr_type, NULL,
6364 rssi, flags, data, len, NULL, 0, 0);
6368 /* When receiving a scan response, then there is no way to
6369 * know if the remote device is connectable or not. However
6370 * since scan responses are merged with a previously seen
6371 * advertising report, the flags field from that report
6374 * In the unlikely case that a controller just sends a scan
6375 * response event that doesn't match the pending report, then
6376 * it is marked as a standalone SCAN_RSP.
6378 if (type == LE_ADV_SCAN_RSP)
6379 flags = MGMT_DEV_FOUND_SCAN_RSP;
6381 /* If there's nothing pending either store the data from this
6382 * event or send an immediate device found event if the data
6383 * should not be stored for later.
6385 if (!ext_adv && !has_pending_adv_report(hdev)) {
6386 /* If the report will trigger a SCAN_REQ store it for
6389 if (type == LE_ADV_IND || type == LE_ADV_SCAN_IND) {
6390 store_pending_adv_report(hdev, bdaddr, bdaddr_type,
6391 rssi, flags, data, len);
6395 mgmt_device_found(hdev, bdaddr, LE_LINK, bdaddr_type, NULL,
6396 rssi, flags, data, len, NULL, 0, 0);
6400 /* Check if the pending report is for the same device as the new one */
6401 match = (!bacmp(bdaddr, &d->last_adv_addr) &&
6402 bdaddr_type == d->last_adv_addr_type);
6404 /* If the pending data doesn't match this report or this isn't a
6405 * scan response (e.g. we got a duplicate ADV_IND) then force
6406 * sending of the pending data.
6408 if (type != LE_ADV_SCAN_RSP || !match) {
6409 /* Send out whatever is in the cache, but skip duplicates */
6411 mgmt_device_found(hdev, &d->last_adv_addr, LE_LINK,
6412 d->last_adv_addr_type, NULL,
6413 d->last_adv_rssi, d->last_adv_flags,
6415 d->last_adv_data_len, NULL, 0, 0);
6417 /* If the new report will trigger a SCAN_REQ store it for
6420 if (!ext_adv && (type == LE_ADV_IND ||
6421 type == LE_ADV_SCAN_IND)) {
6422 store_pending_adv_report(hdev, bdaddr, bdaddr_type,
6423 rssi, flags, data, len);
6427 /* The advertising reports cannot be merged, so clear
6428 * the pending report and send out a device found event.
6430 clear_pending_adv_report(hdev);
6431 mgmt_device_found(hdev, bdaddr, LE_LINK, bdaddr_type, NULL,
6432 rssi, flags, data, len, NULL, 0, 0);
6436 /* If we get here we've got a pending ADV_IND or ADV_SCAN_IND and
6437 * the new event is a SCAN_RSP. We can therefore proceed with
6438 * sending a merged device found event.
6440 mgmt_device_found(hdev, &d->last_adv_addr, LE_LINK,
6441 d->last_adv_addr_type, NULL, rssi, d->last_adv_flags,
6442 d->last_adv_data, d->last_adv_data_len, data, len, 0);
6443 clear_pending_adv_report(hdev);
6446 static void hci_le_adv_report_evt(struct hci_dev *hdev, void *data,
6447 struct sk_buff *skb)
6449 struct hci_ev_le_advertising_report *ev = data;
6450 u64 instant = jiffies;
6458 struct hci_ev_le_advertising_info *info;
6461 info = hci_le_ev_skb_pull(hdev, skb,
6462 HCI_EV_LE_ADVERTISING_REPORT,
6467 if (!hci_le_ev_skb_pull(hdev, skb, HCI_EV_LE_ADVERTISING_REPORT,
6471 if (info->length <= max_adv_len(hdev)) {
6472 rssi = info->data[info->length];
6473 process_adv_report(hdev, info->type, &info->bdaddr,
6474 info->bdaddr_type, NULL, 0, rssi,
6475 info->data, info->length, false,
6478 bt_dev_err(hdev, "Dropping invalid advertising data");
6482 hci_dev_unlock(hdev);
6485 static u8 ext_evt_type_to_legacy(struct hci_dev *hdev, u16 evt_type)
6487 if (evt_type & LE_EXT_ADV_LEGACY_PDU) {
6489 case LE_LEGACY_ADV_IND:
6491 case LE_LEGACY_ADV_DIRECT_IND:
6492 return LE_ADV_DIRECT_IND;
6493 case LE_LEGACY_ADV_SCAN_IND:
6494 return LE_ADV_SCAN_IND;
6495 case LE_LEGACY_NONCONN_IND:
6496 return LE_ADV_NONCONN_IND;
6497 case LE_LEGACY_SCAN_RSP_ADV:
6498 case LE_LEGACY_SCAN_RSP_ADV_SCAN:
6499 return LE_ADV_SCAN_RSP;
6505 if (evt_type & LE_EXT_ADV_CONN_IND) {
6506 if (evt_type & LE_EXT_ADV_DIRECT_IND)
6507 return LE_ADV_DIRECT_IND;
6512 if (evt_type & LE_EXT_ADV_SCAN_RSP)
6513 return LE_ADV_SCAN_RSP;
6515 if (evt_type & LE_EXT_ADV_SCAN_IND)
6516 return LE_ADV_SCAN_IND;
6518 if (evt_type == LE_EXT_ADV_NON_CONN_IND ||
6519 evt_type & LE_EXT_ADV_DIRECT_IND)
6520 return LE_ADV_NONCONN_IND;
6523 bt_dev_err_ratelimited(hdev, "Unknown advertising packet type: 0x%02x",
6526 return LE_ADV_INVALID;
6529 static void hci_le_ext_adv_report_evt(struct hci_dev *hdev, void *data,
6530 struct sk_buff *skb)
6532 struct hci_ev_le_ext_adv_report *ev = data;
6533 u64 instant = jiffies;
6541 struct hci_ev_le_ext_adv_info *info;
6545 info = hci_le_ev_skb_pull(hdev, skb, HCI_EV_LE_EXT_ADV_REPORT,
6550 if (!hci_le_ev_skb_pull(hdev, skb, HCI_EV_LE_EXT_ADV_REPORT,
6554 evt_type = __le16_to_cpu(info->type) & LE_EXT_ADV_EVT_TYPE_MASK;
6555 legacy_evt_type = ext_evt_type_to_legacy(hdev, evt_type);
6556 if (legacy_evt_type != LE_ADV_INVALID) {
6557 process_adv_report(hdev, legacy_evt_type, &info->bdaddr,
6558 info->bdaddr_type, NULL, 0,
6559 info->rssi, info->data, info->length,
6560 !(evt_type & LE_EXT_ADV_LEGACY_PDU),
6565 hci_dev_unlock(hdev);
6568 static int hci_le_pa_term_sync(struct hci_dev *hdev, __le16 handle)
6570 struct hci_cp_le_pa_term_sync cp;
6572 memset(&cp, 0, sizeof(cp));
6575 return hci_send_cmd(hdev, HCI_OP_LE_PA_TERM_SYNC, sizeof(cp), &cp);
6578 static void hci_le_pa_sync_estabilished_evt(struct hci_dev *hdev, void *data,
6579 struct sk_buff *skb)
6581 struct hci_ev_le_pa_sync_established *ev = data;
6582 int mask = hdev->link_mode;
6584 struct hci_conn *bis;
6586 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
6590 hci_dev_clear_flag(hdev, HCI_PA_SYNC);
6592 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ISO_LINK, &flags);
6593 if (!(mask & HCI_LM_ACCEPT)) {
6594 hci_le_pa_term_sync(hdev, ev->handle);
6598 if (!(flags & HCI_PROTO_DEFER))
6601 /* Add connection to indicate the PA sync event */
6602 bis = hci_conn_add(hdev, ISO_LINK, BDADDR_ANY,
6609 set_bit(HCI_CONN_PA_SYNC_FAILED, &bis->flags);
6611 set_bit(HCI_CONN_PA_SYNC, &bis->flags);
6613 /* Notify connection to iso layer */
6614 hci_connect_cfm(bis, ev->status);
6617 hci_dev_unlock(hdev);
6620 static void hci_le_per_adv_report_evt(struct hci_dev *hdev, void *data,
6621 struct sk_buff *skb)
6623 struct hci_ev_le_per_adv_report *ev = data;
6624 int mask = hdev->link_mode;
6627 bt_dev_dbg(hdev, "sync_handle 0x%4.4x", le16_to_cpu(ev->sync_handle));
6631 mask |= hci_proto_connect_ind(hdev, BDADDR_ANY, ISO_LINK, &flags);
6632 if (!(mask & HCI_LM_ACCEPT))
6633 hci_le_pa_term_sync(hdev, ev->sync_handle);
6635 hci_dev_unlock(hdev);
6638 static void hci_le_remote_feat_complete_evt(struct hci_dev *hdev, void *data,
6639 struct sk_buff *skb)
6641 struct hci_ev_le_remote_feat_complete *ev = data;
6642 struct hci_conn *conn;
6644 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
6648 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
6651 memcpy(conn->features[0], ev->features, 8);
6653 if (conn->state == BT_CONFIG) {
6656 /* If the local controller supports peripheral-initiated
6657 * features exchange, but the remote controller does
6658 * not, then it is possible that the error code 0x1a
6659 * for unsupported remote feature gets returned.
6661 * In this specific case, allow the connection to
6662 * transition into connected state and mark it as
6665 if (!conn->out && ev->status == 0x1a &&
6666 (hdev->le_features[0] & HCI_LE_PERIPHERAL_FEATURES))
6669 status = ev->status;
6671 conn->state = BT_CONNECTED;
6672 hci_connect_cfm(conn, status);
6673 hci_conn_drop(conn);
6677 hci_dev_unlock(hdev);
6680 static void hci_le_ltk_request_evt(struct hci_dev *hdev, void *data,
6681 struct sk_buff *skb)
6683 struct hci_ev_le_ltk_req *ev = data;
6684 struct hci_cp_le_ltk_reply cp;
6685 struct hci_cp_le_ltk_neg_reply neg;
6686 struct hci_conn *conn;
6687 struct smp_ltk *ltk;
6689 bt_dev_dbg(hdev, "handle 0x%4.4x", __le16_to_cpu(ev->handle));
6693 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
6697 ltk = hci_find_ltk(hdev, &conn->dst, conn->dst_type, conn->role);
6701 if (smp_ltk_is_sc(ltk)) {
6702 /* With SC both EDiv and Rand are set to zero */
6703 if (ev->ediv || ev->rand)
6706 /* For non-SC keys check that EDiv and Rand match */
6707 if (ev->ediv != ltk->ediv || ev->rand != ltk->rand)
6711 memcpy(cp.ltk, ltk->val, ltk->enc_size);
6712 memset(cp.ltk + ltk->enc_size, 0, sizeof(cp.ltk) - ltk->enc_size);
6713 cp.handle = cpu_to_le16(conn->handle);
6715 conn->pending_sec_level = smp_ltk_sec_level(ltk);
6717 conn->enc_key_size = ltk->enc_size;
6719 hci_send_cmd(hdev, HCI_OP_LE_LTK_REPLY, sizeof(cp), &cp);
6721 /* Ref. Bluetooth Core SPEC pages 1975 and 2004. STK is a
6722 * temporary key used to encrypt a connection following
6723 * pairing. It is used during the Encrypted Session Setup to
6724 * distribute the keys. Later, security can be re-established
6725 * using a distributed LTK.
6727 if (ltk->type == SMP_STK) {
6728 set_bit(HCI_CONN_STK_ENCRYPT, &conn->flags);
6729 list_del_rcu(<k->list);
6730 kfree_rcu(ltk, rcu);
6732 clear_bit(HCI_CONN_STK_ENCRYPT, &conn->flags);
6735 hci_dev_unlock(hdev);
6740 neg.handle = ev->handle;
6741 hci_send_cmd(hdev, HCI_OP_LE_LTK_NEG_REPLY, sizeof(neg), &neg);
6742 hci_dev_unlock(hdev);
6745 static void send_conn_param_neg_reply(struct hci_dev *hdev, u16 handle,
6748 struct hci_cp_le_conn_param_req_neg_reply cp;
6750 cp.handle = cpu_to_le16(handle);
6753 hci_send_cmd(hdev, HCI_OP_LE_CONN_PARAM_REQ_NEG_REPLY, sizeof(cp),
6757 static void hci_le_remote_conn_param_req_evt(struct hci_dev *hdev, void *data,
6758 struct sk_buff *skb)
6760 struct hci_ev_le_remote_conn_param_req *ev = data;
6761 struct hci_cp_le_conn_param_req_reply cp;
6762 struct hci_conn *hcon;
6763 u16 handle, min, max, latency, timeout;
6765 bt_dev_dbg(hdev, "handle 0x%4.4x", __le16_to_cpu(ev->handle));
6767 handle = le16_to_cpu(ev->handle);
6768 min = le16_to_cpu(ev->interval_min);
6769 max = le16_to_cpu(ev->interval_max);
6770 latency = le16_to_cpu(ev->latency);
6771 timeout = le16_to_cpu(ev->timeout);
6773 hcon = hci_conn_hash_lookup_handle(hdev, handle);
6774 if (!hcon || hcon->state != BT_CONNECTED)
6775 return send_conn_param_neg_reply(hdev, handle,
6776 HCI_ERROR_UNKNOWN_CONN_ID);
6778 if (hci_check_conn_params(min, max, latency, timeout))
6779 return send_conn_param_neg_reply(hdev, handle,
6780 HCI_ERROR_INVALID_LL_PARAMS);
6782 if (hcon->role == HCI_ROLE_MASTER) {
6783 struct hci_conn_params *params;
6788 params = hci_conn_params_lookup(hdev, &hcon->dst,
6791 params->conn_min_interval = min;
6792 params->conn_max_interval = max;
6793 params->conn_latency = latency;
6794 params->supervision_timeout = timeout;
6800 hci_dev_unlock(hdev);
6802 mgmt_new_conn_param(hdev, &hcon->dst, hcon->dst_type,
6803 store_hint, min, max, latency, timeout);
6806 cp.handle = ev->handle;
6807 cp.interval_min = ev->interval_min;
6808 cp.interval_max = ev->interval_max;
6809 cp.latency = ev->latency;
6810 cp.timeout = ev->timeout;
6814 hci_send_cmd(hdev, HCI_OP_LE_CONN_PARAM_REQ_REPLY, sizeof(cp), &cp);
6817 static void hci_le_direct_adv_report_evt(struct hci_dev *hdev, void *data,
6818 struct sk_buff *skb)
6820 struct hci_ev_le_direct_adv_report *ev = data;
6821 u64 instant = jiffies;
6824 if (!hci_le_ev_skb_pull(hdev, skb, HCI_EV_LE_DIRECT_ADV_REPORT,
6825 flex_array_size(ev, info, ev->num)))
6833 for (i = 0; i < ev->num; i++) {
6834 struct hci_ev_le_direct_adv_info *info = &ev->info[i];
6836 process_adv_report(hdev, info->type, &info->bdaddr,
6837 info->bdaddr_type, &info->direct_addr,
6838 info->direct_addr_type, info->rssi, NULL, 0,
6839 false, false, instant);
6842 hci_dev_unlock(hdev);
6845 static void hci_le_phy_update_evt(struct hci_dev *hdev, void *data,
6846 struct sk_buff *skb)
6848 struct hci_ev_le_phy_update_complete *ev = data;
6849 struct hci_conn *conn;
6851 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
6858 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
6862 conn->le_tx_phy = ev->tx_phy;
6863 conn->le_rx_phy = ev->rx_phy;
6866 hci_dev_unlock(hdev);
6869 static void hci_le_cis_estabilished_evt(struct hci_dev *hdev, void *data,
6870 struct sk_buff *skb)
6872 struct hci_evt_le_cis_established *ev = data;
6873 struct hci_conn *conn;
6874 struct bt_iso_qos *qos;
6875 bool pending = false;
6876 u16 handle = __le16_to_cpu(ev->handle);
6878 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
6882 conn = hci_conn_hash_lookup_handle(hdev, handle);
6885 "Unable to find connection with handle 0x%4.4x",
6890 if (conn->type != ISO_LINK) {
6892 "Invalid connection link type handle 0x%4.4x",
6897 qos = &conn->iso_qos;
6899 pending = test_and_clear_bit(HCI_CONN_CREATE_CIS, &conn->flags);
6901 /* Convert ISO Interval (1.25 ms slots) to SDU Interval (us) */
6902 qos->ucast.in.interval = le16_to_cpu(ev->interval) * 1250;
6903 qos->ucast.out.interval = qos->ucast.in.interval;
6905 switch (conn->role) {
6906 case HCI_ROLE_SLAVE:
6907 /* Convert Transport Latency (us) to Latency (msec) */
6908 qos->ucast.in.latency =
6909 DIV_ROUND_CLOSEST(get_unaligned_le24(ev->c_latency),
6911 qos->ucast.out.latency =
6912 DIV_ROUND_CLOSEST(get_unaligned_le24(ev->p_latency),
6914 qos->ucast.in.sdu = le16_to_cpu(ev->c_mtu);
6915 qos->ucast.out.sdu = le16_to_cpu(ev->p_mtu);
6916 qos->ucast.in.phy = ev->c_phy;
6917 qos->ucast.out.phy = ev->p_phy;
6919 case HCI_ROLE_MASTER:
6920 /* Convert Transport Latency (us) to Latency (msec) */
6921 qos->ucast.out.latency =
6922 DIV_ROUND_CLOSEST(get_unaligned_le24(ev->c_latency),
6924 qos->ucast.in.latency =
6925 DIV_ROUND_CLOSEST(get_unaligned_le24(ev->p_latency),
6927 qos->ucast.out.sdu = le16_to_cpu(ev->c_mtu);
6928 qos->ucast.in.sdu = le16_to_cpu(ev->p_mtu);
6929 qos->ucast.out.phy = ev->c_phy;
6930 qos->ucast.in.phy = ev->p_phy;
6935 conn->state = BT_CONNECTED;
6936 hci_debugfs_create_conn(conn);
6937 hci_conn_add_sysfs(conn);
6938 hci_iso_setup_path(conn);
6942 conn->state = BT_CLOSED;
6943 hci_connect_cfm(conn, ev->status);
6948 hci_le_create_cis_pending(hdev);
6950 hci_dev_unlock(hdev);
6953 static void hci_le_reject_cis(struct hci_dev *hdev, __le16 handle)
6955 struct hci_cp_le_reject_cis cp;
6957 memset(&cp, 0, sizeof(cp));
6959 cp.reason = HCI_ERROR_REJ_BAD_ADDR;
6960 hci_send_cmd(hdev, HCI_OP_LE_REJECT_CIS, sizeof(cp), &cp);
6963 static void hci_le_accept_cis(struct hci_dev *hdev, __le16 handle)
6965 struct hci_cp_le_accept_cis cp;
6967 memset(&cp, 0, sizeof(cp));
6969 hci_send_cmd(hdev, HCI_OP_LE_ACCEPT_CIS, sizeof(cp), &cp);
6972 static void hci_le_cis_req_evt(struct hci_dev *hdev, void *data,
6973 struct sk_buff *skb)
6975 struct hci_evt_le_cis_req *ev = data;
6976 u16 acl_handle, cis_handle;
6977 struct hci_conn *acl, *cis;
6981 acl_handle = __le16_to_cpu(ev->acl_handle);
6982 cis_handle = __le16_to_cpu(ev->cis_handle);
6984 bt_dev_dbg(hdev, "acl 0x%4.4x handle 0x%4.4x cig 0x%2.2x cis 0x%2.2x",
6985 acl_handle, cis_handle, ev->cig_id, ev->cis_id);
6989 acl = hci_conn_hash_lookup_handle(hdev, acl_handle);
6993 mask = hci_proto_connect_ind(hdev, &acl->dst, ISO_LINK, &flags);
6994 if (!(mask & HCI_LM_ACCEPT)) {
6995 hci_le_reject_cis(hdev, ev->cis_handle);
6999 cis = hci_conn_hash_lookup_handle(hdev, cis_handle);
7001 cis = hci_conn_add(hdev, ISO_LINK, &acl->dst, HCI_ROLE_SLAVE);
7003 hci_le_reject_cis(hdev, ev->cis_handle);
7006 cis->handle = cis_handle;
7009 cis->iso_qos.ucast.cig = ev->cig_id;
7010 cis->iso_qos.ucast.cis = ev->cis_id;
7012 if (!(flags & HCI_PROTO_DEFER)) {
7013 hci_le_accept_cis(hdev, ev->cis_handle);
7015 cis->state = BT_CONNECT2;
7016 hci_connect_cfm(cis, 0);
7020 hci_dev_unlock(hdev);
7023 static void hci_le_create_big_complete_evt(struct hci_dev *hdev, void *data,
7024 struct sk_buff *skb)
7026 struct hci_evt_le_create_big_complete *ev = data;
7027 struct hci_conn *conn;
7030 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
7032 if (!hci_le_ev_skb_pull(hdev, skb, HCI_EVT_LE_CREATE_BIG_COMPLETE,
7033 flex_array_size(ev, bis_handle, ev->num_bis)))
7039 /* Connect all BISes that are bound to the BIG */
7040 list_for_each_entry_rcu(conn, &hdev->conn_hash.list, list) {
7041 if (bacmp(&conn->dst, BDADDR_ANY) ||
7042 conn->type != ISO_LINK ||
7043 conn->iso_qos.bcast.big != ev->handle)
7046 if (hci_conn_set_handle(conn,
7047 __le16_to_cpu(ev->bis_handle[i++])))
7051 conn->state = BT_CONNECTED;
7052 set_bit(HCI_CONN_BIG_CREATED, &conn->flags);
7054 hci_debugfs_create_conn(conn);
7055 hci_conn_add_sysfs(conn);
7056 hci_iso_setup_path(conn);
7061 hci_connect_cfm(conn, ev->status);
7067 if (!ev->status && !i)
7068 /* If no BISes have been connected for the BIG,
7069 * terminate. This is in case all bound connections
7070 * have been closed before the BIG creation
7073 hci_le_terminate_big_sync(hdev, ev->handle,
7074 HCI_ERROR_LOCAL_HOST_TERM);
7077 hci_dev_unlock(hdev);
7080 static void hci_le_big_sync_established_evt(struct hci_dev *hdev, void *data,
7081 struct sk_buff *skb)
7083 struct hci_evt_le_big_sync_estabilished *ev = data;
7084 struct hci_conn *bis;
7085 struct hci_conn *pa_sync;
7088 bt_dev_dbg(hdev, "status 0x%2.2x", ev->status);
7090 if (!hci_le_ev_skb_pull(hdev, skb, HCI_EVT_LE_BIG_SYNC_ESTABILISHED,
7091 flex_array_size(ev, bis, ev->num_bis)))
7097 pa_sync = hci_conn_hash_lookup_pa_sync(hdev, ev->handle);
7099 /* Also mark the BIG sync established event on the
7100 * associated PA sync hcon
7102 set_bit(HCI_CONN_BIG_SYNC, &pa_sync->flags);
7105 for (i = 0; i < ev->num_bis; i++) {
7106 u16 handle = le16_to_cpu(ev->bis[i]);
7109 bis = hci_conn_hash_lookup_handle(hdev, handle);
7111 bis = hci_conn_add(hdev, ISO_LINK, BDADDR_ANY,
7115 bis->handle = handle;
7118 if (ev->status != 0x42)
7119 /* Mark PA sync as established */
7120 set_bit(HCI_CONN_PA_SYNC, &bis->flags);
7122 bis->iso_qos.bcast.big = ev->handle;
7123 memset(&interval, 0, sizeof(interval));
7124 memcpy(&interval, ev->latency, sizeof(ev->latency));
7125 bis->iso_qos.bcast.in.interval = le32_to_cpu(interval);
7126 /* Convert ISO Interval (1.25 ms slots) to latency (ms) */
7127 bis->iso_qos.bcast.in.latency = le16_to_cpu(ev->interval) * 125 / 100;
7128 bis->iso_qos.bcast.in.sdu = le16_to_cpu(ev->max_pdu);
7131 set_bit(HCI_CONN_BIG_SYNC, &bis->flags);
7132 hci_iso_setup_path(bis);
7136 /* In case BIG sync failed, notify each failed connection to
7137 * the user after all hci connections have been added
7140 for (i = 0; i < ev->num_bis; i++) {
7141 u16 handle = le16_to_cpu(ev->bis[i]);
7143 bis = hci_conn_hash_lookup_handle(hdev, handle);
7145 set_bit(HCI_CONN_BIG_SYNC_FAILED, &bis->flags);
7146 hci_connect_cfm(bis, ev->status);
7149 hci_dev_unlock(hdev);
7152 static void hci_le_big_info_adv_report_evt(struct hci_dev *hdev, void *data,
7153 struct sk_buff *skb)
7155 struct hci_evt_le_big_info_adv_report *ev = data;
7156 int mask = hdev->link_mode;
7159 bt_dev_dbg(hdev, "sync_handle 0x%4.4x", le16_to_cpu(ev->sync_handle));
7163 mask |= hci_proto_connect_ind(hdev, BDADDR_ANY, ISO_LINK, &flags);
7164 if (!(mask & HCI_LM_ACCEPT))
7165 hci_le_pa_term_sync(hdev, ev->sync_handle);
7167 hci_dev_unlock(hdev);
7170 #define HCI_LE_EV_VL(_op, _func, _min_len, _max_len) \
7173 .min_len = _min_len, \
7174 .max_len = _max_len, \
7177 #define HCI_LE_EV(_op, _func, _len) \
7178 HCI_LE_EV_VL(_op, _func, _len, _len)
7180 #define HCI_LE_EV_STATUS(_op, _func) \
7181 HCI_LE_EV(_op, _func, sizeof(struct hci_ev_status))
7183 /* Entries in this table shall have their position according to the subevent
7184 * opcode they handle so the use of the macros above is recommend since it does
7185 * attempt to initialize at its proper index using Designated Initializers that
7186 * way events without a callback function can be ommited.
7188 static const struct hci_le_ev {
7189 void (*func)(struct hci_dev *hdev, void *data, struct sk_buff *skb);
7192 } hci_le_ev_table[U8_MAX + 1] = {
7193 /* [0x01 = HCI_EV_LE_CONN_COMPLETE] */
7194 HCI_LE_EV(HCI_EV_LE_CONN_COMPLETE, hci_le_conn_complete_evt,
7195 sizeof(struct hci_ev_le_conn_complete)),
7196 /* [0x02 = HCI_EV_LE_ADVERTISING_REPORT] */
7197 HCI_LE_EV_VL(HCI_EV_LE_ADVERTISING_REPORT, hci_le_adv_report_evt,
7198 sizeof(struct hci_ev_le_advertising_report),
7199 HCI_MAX_EVENT_SIZE),
7200 /* [0x03 = HCI_EV_LE_CONN_UPDATE_COMPLETE] */
7201 HCI_LE_EV(HCI_EV_LE_CONN_UPDATE_COMPLETE,
7202 hci_le_conn_update_complete_evt,
7203 sizeof(struct hci_ev_le_conn_update_complete)),
7204 /* [0x04 = HCI_EV_LE_REMOTE_FEAT_COMPLETE] */
7205 HCI_LE_EV(HCI_EV_LE_REMOTE_FEAT_COMPLETE,
7206 hci_le_remote_feat_complete_evt,
7207 sizeof(struct hci_ev_le_remote_feat_complete)),
7208 /* [0x05 = HCI_EV_LE_LTK_REQ] */
7209 HCI_LE_EV(HCI_EV_LE_LTK_REQ, hci_le_ltk_request_evt,
7210 sizeof(struct hci_ev_le_ltk_req)),
7211 /* [0x06 = HCI_EV_LE_REMOTE_CONN_PARAM_REQ] */
7212 HCI_LE_EV(HCI_EV_LE_REMOTE_CONN_PARAM_REQ,
7213 hci_le_remote_conn_param_req_evt,
7214 sizeof(struct hci_ev_le_remote_conn_param_req)),
7215 /* [0x0a = HCI_EV_LE_ENHANCED_CONN_COMPLETE] */
7216 HCI_LE_EV(HCI_EV_LE_ENHANCED_CONN_COMPLETE,
7217 hci_le_enh_conn_complete_evt,
7218 sizeof(struct hci_ev_le_enh_conn_complete)),
7219 /* [0x0b = HCI_EV_LE_DIRECT_ADV_REPORT] */
7220 HCI_LE_EV_VL(HCI_EV_LE_DIRECT_ADV_REPORT, hci_le_direct_adv_report_evt,
7221 sizeof(struct hci_ev_le_direct_adv_report),
7222 HCI_MAX_EVENT_SIZE),
7223 /* [0x0c = HCI_EV_LE_PHY_UPDATE_COMPLETE] */
7224 HCI_LE_EV(HCI_EV_LE_PHY_UPDATE_COMPLETE, hci_le_phy_update_evt,
7225 sizeof(struct hci_ev_le_phy_update_complete)),
7226 /* [0x0d = HCI_EV_LE_EXT_ADV_REPORT] */
7227 HCI_LE_EV_VL(HCI_EV_LE_EXT_ADV_REPORT, hci_le_ext_adv_report_evt,
7228 sizeof(struct hci_ev_le_ext_adv_report),
7229 HCI_MAX_EVENT_SIZE),
7230 /* [0x0e = HCI_EV_LE_PA_SYNC_ESTABLISHED] */
7231 HCI_LE_EV(HCI_EV_LE_PA_SYNC_ESTABLISHED,
7232 hci_le_pa_sync_estabilished_evt,
7233 sizeof(struct hci_ev_le_pa_sync_established)),
7234 /* [0x0f = HCI_EV_LE_PER_ADV_REPORT] */
7235 HCI_LE_EV_VL(HCI_EV_LE_PER_ADV_REPORT,
7236 hci_le_per_adv_report_evt,
7237 sizeof(struct hci_ev_le_per_adv_report),
7238 HCI_MAX_EVENT_SIZE),
7239 /* [0x12 = HCI_EV_LE_EXT_ADV_SET_TERM] */
7240 HCI_LE_EV(HCI_EV_LE_EXT_ADV_SET_TERM, hci_le_ext_adv_term_evt,
7241 sizeof(struct hci_evt_le_ext_adv_set_term)),
7242 /* [0x19 = HCI_EVT_LE_CIS_ESTABLISHED] */
7243 HCI_LE_EV(HCI_EVT_LE_CIS_ESTABLISHED, hci_le_cis_estabilished_evt,
7244 sizeof(struct hci_evt_le_cis_established)),
7245 /* [0x1a = HCI_EVT_LE_CIS_REQ] */
7246 HCI_LE_EV(HCI_EVT_LE_CIS_REQ, hci_le_cis_req_evt,
7247 sizeof(struct hci_evt_le_cis_req)),
7248 /* [0x1b = HCI_EVT_LE_CREATE_BIG_COMPLETE] */
7249 HCI_LE_EV_VL(HCI_EVT_LE_CREATE_BIG_COMPLETE,
7250 hci_le_create_big_complete_evt,
7251 sizeof(struct hci_evt_le_create_big_complete),
7252 HCI_MAX_EVENT_SIZE),
7253 /* [0x1d = HCI_EV_LE_BIG_SYNC_ESTABILISHED] */
7254 HCI_LE_EV_VL(HCI_EVT_LE_BIG_SYNC_ESTABILISHED,
7255 hci_le_big_sync_established_evt,
7256 sizeof(struct hci_evt_le_big_sync_estabilished),
7257 HCI_MAX_EVENT_SIZE),
7258 /* [0x22 = HCI_EVT_LE_BIG_INFO_ADV_REPORT] */
7259 HCI_LE_EV_VL(HCI_EVT_LE_BIG_INFO_ADV_REPORT,
7260 hci_le_big_info_adv_report_evt,
7261 sizeof(struct hci_evt_le_big_info_adv_report),
7262 HCI_MAX_EVENT_SIZE),
7265 static void hci_le_meta_evt(struct hci_dev *hdev, void *data,
7266 struct sk_buff *skb, u16 *opcode, u8 *status,
7267 hci_req_complete_t *req_complete,
7268 hci_req_complete_skb_t *req_complete_skb)
7270 struct hci_ev_le_meta *ev = data;
7271 const struct hci_le_ev *subev;
7273 bt_dev_dbg(hdev, "subevent 0x%2.2x", ev->subevent);
7275 /* Only match event if command OGF is for LE */
7276 if (hdev->sent_cmd &&
7277 hci_opcode_ogf(hci_skb_opcode(hdev->sent_cmd)) == 0x08 &&
7278 hci_skb_event(hdev->sent_cmd) == ev->subevent) {
7279 *opcode = hci_skb_opcode(hdev->sent_cmd);
7280 hci_req_cmd_complete(hdev, *opcode, 0x00, req_complete,
7284 subev = &hci_le_ev_table[ev->subevent];
7288 if (skb->len < subev->min_len) {
7289 bt_dev_err(hdev, "unexpected subevent 0x%2.2x length: %u < %u",
7290 ev->subevent, skb->len, subev->min_len);
7294 /* Just warn if the length is over max_len size it still be
7295 * possible to partially parse the event so leave to callback to
7296 * decide if that is acceptable.
7298 if (skb->len > subev->max_len)
7299 bt_dev_warn(hdev, "unexpected subevent 0x%2.2x length: %u > %u",
7300 ev->subevent, skb->len, subev->max_len);
7301 data = hci_le_ev_skb_pull(hdev, skb, ev->subevent, subev->min_len);
7305 subev->func(hdev, data, skb);
7308 static bool hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode,
7309 u8 event, struct sk_buff *skb)
7311 struct hci_ev_cmd_complete *ev;
7312 struct hci_event_hdr *hdr;
7317 hdr = hci_ev_skb_pull(hdev, skb, event, sizeof(*hdr));
7322 if (hdr->evt != event)
7327 /* Check if request ended in Command Status - no way to retrieve
7328 * any extra parameters in this case.
7330 if (hdr->evt == HCI_EV_CMD_STATUS)
7333 if (hdr->evt != HCI_EV_CMD_COMPLETE) {
7334 bt_dev_err(hdev, "last event is not cmd complete (0x%2.2x)",
7339 ev = hci_cc_skb_pull(hdev, skb, opcode, sizeof(*ev));
7343 if (opcode != __le16_to_cpu(ev->opcode)) {
7344 BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode,
7345 __le16_to_cpu(ev->opcode));
7352 static void hci_store_wake_reason(struct hci_dev *hdev, u8 event,
7353 struct sk_buff *skb)
7355 struct hci_ev_le_advertising_info *adv;
7356 struct hci_ev_le_direct_adv_info *direct_adv;
7357 struct hci_ev_le_ext_adv_info *ext_adv;
7358 const struct hci_ev_conn_complete *conn_complete = (void *)skb->data;
7359 const struct hci_ev_conn_request *conn_request = (void *)skb->data;
7363 /* If we are currently suspended and this is the first BT event seen,
7364 * save the wake reason associated with the event.
7366 if (!hdev->suspended || hdev->wake_reason)
7369 /* Default to remote wake. Values for wake_reason are documented in the
7370 * Bluez mgmt api docs.
7372 hdev->wake_reason = MGMT_WAKE_REASON_REMOTE_WAKE;
7374 /* Once configured for remote wakeup, we should only wake up for
7375 * reconnections. It's useful to see which device is waking us up so
7376 * keep track of the bdaddr of the connection event that woke us up.
7378 if (event == HCI_EV_CONN_REQUEST) {
7379 bacpy(&hdev->wake_addr, &conn_complete->bdaddr);
7380 hdev->wake_addr_type = BDADDR_BREDR;
7381 } else if (event == HCI_EV_CONN_COMPLETE) {
7382 bacpy(&hdev->wake_addr, &conn_request->bdaddr);
7383 hdev->wake_addr_type = BDADDR_BREDR;
7384 } else if (event == HCI_EV_LE_META) {
7385 struct hci_ev_le_meta *le_ev = (void *)skb->data;
7386 u8 subevent = le_ev->subevent;
7387 u8 *ptr = &skb->data[sizeof(*le_ev)];
7388 u8 num_reports = *ptr;
7390 if ((subevent == HCI_EV_LE_ADVERTISING_REPORT ||
7391 subevent == HCI_EV_LE_DIRECT_ADV_REPORT ||
7392 subevent == HCI_EV_LE_EXT_ADV_REPORT) &&
7394 adv = (void *)(ptr + 1);
7395 direct_adv = (void *)(ptr + 1);
7396 ext_adv = (void *)(ptr + 1);
7399 case HCI_EV_LE_ADVERTISING_REPORT:
7400 bacpy(&hdev->wake_addr, &adv->bdaddr);
7401 hdev->wake_addr_type = adv->bdaddr_type;
7403 case HCI_EV_LE_DIRECT_ADV_REPORT:
7404 bacpy(&hdev->wake_addr, &direct_adv->bdaddr);
7405 hdev->wake_addr_type = direct_adv->bdaddr_type;
7407 case HCI_EV_LE_EXT_ADV_REPORT:
7408 bacpy(&hdev->wake_addr, &ext_adv->bdaddr);
7409 hdev->wake_addr_type = ext_adv->bdaddr_type;
7414 hdev->wake_reason = MGMT_WAKE_REASON_UNEXPECTED;
7418 hci_dev_unlock(hdev);
7421 #define HCI_EV_VL(_op, _func, _min_len, _max_len) \
7425 .min_len = _min_len, \
7426 .max_len = _max_len, \
7429 #define HCI_EV(_op, _func, _len) \
7430 HCI_EV_VL(_op, _func, _len, _len)
7432 #define HCI_EV_STATUS(_op, _func) \
7433 HCI_EV(_op, _func, sizeof(struct hci_ev_status))
7435 #define HCI_EV_REQ_VL(_op, _func, _min_len, _max_len) \
7438 .func_req = _func, \
7439 .min_len = _min_len, \
7440 .max_len = _max_len, \
7443 #define HCI_EV_REQ(_op, _func, _len) \
7444 HCI_EV_REQ_VL(_op, _func, _len, _len)
7446 /* Entries in this table shall have their position according to the event opcode
7447 * they handle so the use of the macros above is recommend since it does attempt
7448 * to initialize at its proper index using Designated Initializers that way
7449 * events without a callback function don't have entered.
7451 static const struct hci_ev {
7454 void (*func)(struct hci_dev *hdev, void *data,
7455 struct sk_buff *skb);
7456 void (*func_req)(struct hci_dev *hdev, void *data,
7457 struct sk_buff *skb, u16 *opcode, u8 *status,
7458 hci_req_complete_t *req_complete,
7459 hci_req_complete_skb_t *req_complete_skb);
7463 } hci_ev_table[U8_MAX + 1] = {
7464 /* [0x01 = HCI_EV_INQUIRY_COMPLETE] */
7465 HCI_EV_STATUS(HCI_EV_INQUIRY_COMPLETE, hci_inquiry_complete_evt),
7466 /* [0x02 = HCI_EV_INQUIRY_RESULT] */
7467 HCI_EV_VL(HCI_EV_INQUIRY_RESULT, hci_inquiry_result_evt,
7468 sizeof(struct hci_ev_inquiry_result), HCI_MAX_EVENT_SIZE),
7469 /* [0x03 = HCI_EV_CONN_COMPLETE] */
7470 HCI_EV(HCI_EV_CONN_COMPLETE, hci_conn_complete_evt,
7471 sizeof(struct hci_ev_conn_complete)),
7472 /* [0x04 = HCI_EV_CONN_REQUEST] */
7473 HCI_EV(HCI_EV_CONN_REQUEST, hci_conn_request_evt,
7474 sizeof(struct hci_ev_conn_request)),
7475 /* [0x05 = HCI_EV_DISCONN_COMPLETE] */
7476 HCI_EV(HCI_EV_DISCONN_COMPLETE, hci_disconn_complete_evt,
7477 sizeof(struct hci_ev_disconn_complete)),
7478 /* [0x06 = HCI_EV_AUTH_COMPLETE] */
7479 HCI_EV(HCI_EV_AUTH_COMPLETE, hci_auth_complete_evt,
7480 sizeof(struct hci_ev_auth_complete)),
7481 /* [0x07 = HCI_EV_REMOTE_NAME] */
7482 HCI_EV(HCI_EV_REMOTE_NAME, hci_remote_name_evt,
7483 sizeof(struct hci_ev_remote_name)),
7484 /* [0x08 = HCI_EV_ENCRYPT_CHANGE] */
7485 HCI_EV(HCI_EV_ENCRYPT_CHANGE, hci_encrypt_change_evt,
7486 sizeof(struct hci_ev_encrypt_change)),
7487 /* [0x09 = HCI_EV_CHANGE_LINK_KEY_COMPLETE] */
7488 HCI_EV(HCI_EV_CHANGE_LINK_KEY_COMPLETE,
7489 hci_change_link_key_complete_evt,
7490 sizeof(struct hci_ev_change_link_key_complete)),
7491 /* [0x0b = HCI_EV_REMOTE_FEATURES] */
7492 HCI_EV(HCI_EV_REMOTE_FEATURES, hci_remote_features_evt,
7493 sizeof(struct hci_ev_remote_features)),
7494 /* [0x0e = HCI_EV_CMD_COMPLETE] */
7495 HCI_EV_REQ_VL(HCI_EV_CMD_COMPLETE, hci_cmd_complete_evt,
7496 sizeof(struct hci_ev_cmd_complete), HCI_MAX_EVENT_SIZE),
7497 /* [0x0f = HCI_EV_CMD_STATUS] */
7498 HCI_EV_REQ(HCI_EV_CMD_STATUS, hci_cmd_status_evt,
7499 sizeof(struct hci_ev_cmd_status)),
7500 /* [0x10 = HCI_EV_CMD_STATUS] */
7501 HCI_EV(HCI_EV_HARDWARE_ERROR, hci_hardware_error_evt,
7502 sizeof(struct hci_ev_hardware_error)),
7503 /* [0x12 = HCI_EV_ROLE_CHANGE] */
7504 HCI_EV(HCI_EV_ROLE_CHANGE, hci_role_change_evt,
7505 sizeof(struct hci_ev_role_change)),
7506 /* [0x13 = HCI_EV_NUM_COMP_PKTS] */
7507 HCI_EV_VL(HCI_EV_NUM_COMP_PKTS, hci_num_comp_pkts_evt,
7508 sizeof(struct hci_ev_num_comp_pkts), HCI_MAX_EVENT_SIZE),
7509 /* [0x14 = HCI_EV_MODE_CHANGE] */
7510 HCI_EV(HCI_EV_MODE_CHANGE, hci_mode_change_evt,
7511 sizeof(struct hci_ev_mode_change)),
7512 /* [0x16 = HCI_EV_PIN_CODE_REQ] */
7513 HCI_EV(HCI_EV_PIN_CODE_REQ, hci_pin_code_request_evt,
7514 sizeof(struct hci_ev_pin_code_req)),
7515 /* [0x17 = HCI_EV_LINK_KEY_REQ] */
7516 HCI_EV(HCI_EV_LINK_KEY_REQ, hci_link_key_request_evt,
7517 sizeof(struct hci_ev_link_key_req)),
7518 /* [0x18 = HCI_EV_LINK_KEY_NOTIFY] */
7519 HCI_EV(HCI_EV_LINK_KEY_NOTIFY, hci_link_key_notify_evt,
7520 sizeof(struct hci_ev_link_key_notify)),
7521 /* [0x1c = HCI_EV_CLOCK_OFFSET] */
7522 HCI_EV(HCI_EV_CLOCK_OFFSET, hci_clock_offset_evt,
7523 sizeof(struct hci_ev_clock_offset)),
7524 /* [0x1d = HCI_EV_PKT_TYPE_CHANGE] */
7525 HCI_EV(HCI_EV_PKT_TYPE_CHANGE, hci_pkt_type_change_evt,
7526 sizeof(struct hci_ev_pkt_type_change)),
7527 /* [0x20 = HCI_EV_PSCAN_REP_MODE] */
7528 HCI_EV(HCI_EV_PSCAN_REP_MODE, hci_pscan_rep_mode_evt,
7529 sizeof(struct hci_ev_pscan_rep_mode)),
7530 /* [0x22 = HCI_EV_INQUIRY_RESULT_WITH_RSSI] */
7531 HCI_EV_VL(HCI_EV_INQUIRY_RESULT_WITH_RSSI,
7532 hci_inquiry_result_with_rssi_evt,
7533 sizeof(struct hci_ev_inquiry_result_rssi),
7534 HCI_MAX_EVENT_SIZE),
7535 /* [0x23 = HCI_EV_REMOTE_EXT_FEATURES] */
7536 HCI_EV(HCI_EV_REMOTE_EXT_FEATURES, hci_remote_ext_features_evt,
7537 sizeof(struct hci_ev_remote_ext_features)),
7538 /* [0x2c = HCI_EV_SYNC_CONN_COMPLETE] */
7539 HCI_EV(HCI_EV_SYNC_CONN_COMPLETE, hci_sync_conn_complete_evt,
7540 sizeof(struct hci_ev_sync_conn_complete)),
7541 /* [0x2d = HCI_EV_EXTENDED_INQUIRY_RESULT] */
7542 HCI_EV_VL(HCI_EV_EXTENDED_INQUIRY_RESULT,
7543 hci_extended_inquiry_result_evt,
7544 sizeof(struct hci_ev_ext_inquiry_result), HCI_MAX_EVENT_SIZE),
7545 /* [0x30 = HCI_EV_KEY_REFRESH_COMPLETE] */
7546 HCI_EV(HCI_EV_KEY_REFRESH_COMPLETE, hci_key_refresh_complete_evt,
7547 sizeof(struct hci_ev_key_refresh_complete)),
7548 /* [0x31 = HCI_EV_IO_CAPA_REQUEST] */
7549 HCI_EV(HCI_EV_IO_CAPA_REQUEST, hci_io_capa_request_evt,
7550 sizeof(struct hci_ev_io_capa_request)),
7551 /* [0x32 = HCI_EV_IO_CAPA_REPLY] */
7552 HCI_EV(HCI_EV_IO_CAPA_REPLY, hci_io_capa_reply_evt,
7553 sizeof(struct hci_ev_io_capa_reply)),
7554 /* [0x33 = HCI_EV_USER_CONFIRM_REQUEST] */
7555 HCI_EV(HCI_EV_USER_CONFIRM_REQUEST, hci_user_confirm_request_evt,
7556 sizeof(struct hci_ev_user_confirm_req)),
7557 /* [0x34 = HCI_EV_USER_PASSKEY_REQUEST] */
7558 HCI_EV(HCI_EV_USER_PASSKEY_REQUEST, hci_user_passkey_request_evt,
7559 sizeof(struct hci_ev_user_passkey_req)),
7560 /* [0x35 = HCI_EV_REMOTE_OOB_DATA_REQUEST] */
7561 HCI_EV(HCI_EV_REMOTE_OOB_DATA_REQUEST, hci_remote_oob_data_request_evt,
7562 sizeof(struct hci_ev_remote_oob_data_request)),
7563 /* [0x36 = HCI_EV_SIMPLE_PAIR_COMPLETE] */
7564 HCI_EV(HCI_EV_SIMPLE_PAIR_COMPLETE, hci_simple_pair_complete_evt,
7565 sizeof(struct hci_ev_simple_pair_complete)),
7566 /* [0x3b = HCI_EV_USER_PASSKEY_NOTIFY] */
7567 HCI_EV(HCI_EV_USER_PASSKEY_NOTIFY, hci_user_passkey_notify_evt,
7568 sizeof(struct hci_ev_user_passkey_notify)),
7569 /* [0x3c = HCI_EV_KEYPRESS_NOTIFY] */
7570 HCI_EV(HCI_EV_KEYPRESS_NOTIFY, hci_keypress_notify_evt,
7571 sizeof(struct hci_ev_keypress_notify)),
7572 /* [0x3d = HCI_EV_REMOTE_HOST_FEATURES] */
7573 HCI_EV(HCI_EV_REMOTE_HOST_FEATURES, hci_remote_host_features_evt,
7574 sizeof(struct hci_ev_remote_host_features)),
7575 /* [0x3e = HCI_EV_LE_META] */
7576 HCI_EV_REQ_VL(HCI_EV_LE_META, hci_le_meta_evt,
7577 sizeof(struct hci_ev_le_meta), HCI_MAX_EVENT_SIZE),
7578 #if IS_ENABLED(CONFIG_BT_HS)
7579 /* [0x40 = HCI_EV_PHY_LINK_COMPLETE] */
7580 HCI_EV(HCI_EV_PHY_LINK_COMPLETE, hci_phy_link_complete_evt,
7581 sizeof(struct hci_ev_phy_link_complete)),
7582 /* [0x41 = HCI_EV_CHANNEL_SELECTED] */
7583 HCI_EV(HCI_EV_CHANNEL_SELECTED, hci_chan_selected_evt,
7584 sizeof(struct hci_ev_channel_selected)),
7585 /* [0x42 = HCI_EV_DISCONN_PHY_LINK_COMPLETE] */
7586 HCI_EV(HCI_EV_DISCONN_LOGICAL_LINK_COMPLETE,
7587 hci_disconn_loglink_complete_evt,
7588 sizeof(struct hci_ev_disconn_logical_link_complete)),
7589 /* [0x45 = HCI_EV_LOGICAL_LINK_COMPLETE] */
7590 HCI_EV(HCI_EV_LOGICAL_LINK_COMPLETE, hci_loglink_complete_evt,
7591 sizeof(struct hci_ev_logical_link_complete)),
7592 /* [0x46 = HCI_EV_DISCONN_LOGICAL_LINK_COMPLETE] */
7593 HCI_EV(HCI_EV_DISCONN_PHY_LINK_COMPLETE,
7594 hci_disconn_phylink_complete_evt,
7595 sizeof(struct hci_ev_disconn_phy_link_complete)),
7597 /* [0x48 = HCI_EV_NUM_COMP_BLOCKS] */
7598 HCI_EV(HCI_EV_NUM_COMP_BLOCKS, hci_num_comp_blocks_evt,
7599 sizeof(struct hci_ev_num_comp_blocks)),
7600 /* [0xff = HCI_EV_VENDOR] */
7601 HCI_EV_VL(HCI_EV_VENDOR, msft_vendor_evt, 0, HCI_MAX_EVENT_SIZE),
7604 static void hci_event_func(struct hci_dev *hdev, u8 event, struct sk_buff *skb,
7605 u16 *opcode, u8 *status,
7606 hci_req_complete_t *req_complete,
7607 hci_req_complete_skb_t *req_complete_skb)
7609 const struct hci_ev *ev = &hci_ev_table[event];
7615 if (skb->len < ev->min_len) {
7616 bt_dev_err(hdev, "unexpected event 0x%2.2x length: %u < %u",
7617 event, skb->len, ev->min_len);
7621 /* Just warn if the length is over max_len size it still be
7622 * possible to partially parse the event so leave to callback to
7623 * decide if that is acceptable.
7625 if (skb->len > ev->max_len)
7626 bt_dev_warn_ratelimited(hdev,
7627 "unexpected event 0x%2.2x length: %u > %u",
7628 event, skb->len, ev->max_len);
7630 data = hci_ev_skb_pull(hdev, skb, event, ev->min_len);
7635 ev->func_req(hdev, data, skb, opcode, status, req_complete,
7638 ev->func(hdev, data, skb);
7641 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
7643 struct hci_event_hdr *hdr = (void *) skb->data;
7644 hci_req_complete_t req_complete = NULL;
7645 hci_req_complete_skb_t req_complete_skb = NULL;
7646 struct sk_buff *orig_skb = NULL;
7647 u8 status = 0, event, req_evt = 0;
7648 u16 opcode = HCI_OP_NOP;
7650 if (skb->len < sizeof(*hdr)) {
7651 bt_dev_err(hdev, "Malformed HCI Event");
7655 kfree_skb(hdev->recv_event);
7656 hdev->recv_event = skb_clone(skb, GFP_KERNEL);
7660 bt_dev_warn(hdev, "Received unexpected HCI Event 0x%2.2x",
7665 /* Only match event if command OGF is not for LE */
7666 if (hdev->sent_cmd &&
7667 hci_opcode_ogf(hci_skb_opcode(hdev->sent_cmd)) != 0x08 &&
7668 hci_skb_event(hdev->sent_cmd) == event) {
7669 hci_req_cmd_complete(hdev, hci_skb_opcode(hdev->sent_cmd),
7670 status, &req_complete, &req_complete_skb);
7674 /* If it looks like we might end up having to call
7675 * req_complete_skb, store a pristine copy of the skb since the
7676 * various handlers may modify the original one through
7677 * skb_pull() calls, etc.
7679 if (req_complete_skb || event == HCI_EV_CMD_STATUS ||
7680 event == HCI_EV_CMD_COMPLETE)
7681 orig_skb = skb_clone(skb, GFP_KERNEL);
7683 skb_pull(skb, HCI_EVENT_HDR_SIZE);
7685 /* Store wake reason if we're suspended */
7686 hci_store_wake_reason(hdev, event, skb);
7688 bt_dev_dbg(hdev, "event 0x%2.2x", event);
7690 hci_event_func(hdev, event, skb, &opcode, &status, &req_complete,
7694 req_complete(hdev, status, opcode);
7695 } else if (req_complete_skb) {
7696 if (!hci_get_cmd_complete(hdev, opcode, req_evt, orig_skb)) {
7697 kfree_skb(orig_skb);
7700 req_complete_skb(hdev, status, opcode, orig_skb);
7704 kfree_skb(orig_skb);
7706 hdev->stat.evt_rx++;