Lines Matching defs:hdev

323 static int mgmt_index_event(u16 event, struct hci_dev *hdev, void *data,
326 	return mgmt_send_event(event, hdev, HCI_CHANNEL_CONTROL, data, len,
330 static int mgmt_limited_event(u16 event, struct hci_dev *hdev, void *data,
333 	return mgmt_send_event(event, hdev, HCI_CHANNEL_CONTROL, data, len,
337 static int mgmt_event(u16 event, struct hci_dev *hdev, void *data, u16 len,
340 	return mgmt_send_event(event, hdev, HCI_CHANNEL_CONTROL, data, len,
366 static int read_version(struct sock *sk, struct hci_dev *hdev, void *data,
371 	bt_dev_dbg(hdev, "sock %p", sk);
379 static int read_commands(struct sock *sk, struct hci_dev *hdev, void *data,
387 	bt_dev_dbg(hdev, "sock %p", sk);
431 static int read_index_list(struct sock *sk, struct hci_dev *hdev, void *data,
440 	bt_dev_dbg(hdev, "sock %p", sk);
474 			bt_dev_dbg(hdev, "Added hci%u", d->id);
491 static int read_unconf_index_list(struct sock *sk, struct hci_dev *hdev,
500 	bt_dev_dbg(hdev, "sock %p", sk);
534 			bt_dev_dbg(hdev, "Added hci%u", d->id);
551 static int read_ext_index_list(struct sock *sk, struct hci_dev *hdev,
559 	bt_dev_dbg(hdev, "sock %p", sk);
601 		bt_dev_dbg(hdev, "Added hci%u", d->id);
625 static bool is_configured(struct hci_dev *hdev)
627 	if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) &&
628 	    !hci_dev_test_flag(hdev, HCI_EXT_CONFIGURED))
631 	if ((test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks) ||
632 	     test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks)) &&
633 	    !bacmp(&hdev->public_addr, BDADDR_ANY))
639 static __le32 get_missing_options(struct hci_dev *hdev)
643 	if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) &&
644 	    !hci_dev_test_flag(hdev, HCI_EXT_CONFIGURED))
647 	if ((test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks) ||
648 	     test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks)) &&
649 	    !bacmp(&hdev->public_addr, BDADDR_ANY))
655 static int new_options(struct hci_dev *hdev, struct sock *skip)
657 	__le32 options = get_missing_options(hdev);
659 	return mgmt_limited_event(MGMT_EV_NEW_CONFIG_OPTIONS, hdev, &options,
663 static int send_options_rsp(struct sock *sk, u16 opcode, struct hci_dev *hdev)
665 	__le32 options = get_missing_options(hdev);
667 	return mgmt_cmd_complete(sk, hdev->id, opcode, 0, &options,
671 static int read_config_info(struct sock *sk, struct hci_dev *hdev,
677 	bt_dev_dbg(hdev, "sock %p", sk);
679 	hci_dev_lock(hdev);
682 	rp.manufacturer = cpu_to_le16(hdev->manufacturer);
684 	if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks))
687 	if (hdev->set_bdaddr)
691 	rp.missing_options = get_missing_options(hdev);
693 	hci_dev_unlock(hdev);
695 	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_CONFIG_INFO, 0,
699 static u32 get_supported_phys(struct hci_dev *hdev)
703 	if (lmp_bredr_capable(hdev)) {
706 		if (hdev->features[0][0] & LMP_3SLOT)
709 		if (hdev->features[0][0] & LMP_5SLOT)
712 		if (lmp_edr_2m_capable(hdev)) {
715 			if (lmp_edr_3slot_capable(hdev))
718 			if (lmp_edr_5slot_capable(hdev))
721 			if (lmp_edr_3m_capable(hdev)) {
724 				if (lmp_edr_3slot_capable(hdev))
727 				if (lmp_edr_5slot_capable(hdev))
733 	if (lmp_le_capable(hdev)) {
737 		if (hdev->le_features[1] & HCI_LE_PHY_2M) {
742 		if (hdev->le_features[1] & HCI_LE_PHY_CODED) {
751 static u32 get_selected_phys(struct hci_dev *hdev)
755 	if (lmp_bredr_capable(hdev)) {
758 		if (hdev->pkt_type & (HCI_DM3 | HCI_DH3))
761 		if (hdev->pkt_type & (HCI_DM5 | HCI_DH5))
764 		if (lmp_edr_2m_capable(hdev)) {
765 			if (!(hdev->pkt_type & HCI_2DH1))
768 			if (lmp_edr_3slot_capable(hdev) &&
769 			    !(hdev->pkt_type & HCI_2DH3))
772 			if (lmp_edr_5slot_capable(hdev) &&
773 			    !(hdev->pkt_type & HCI_2DH5))
776 			if (lmp_edr_3m_capable(hdev)) {
777 				if (!(hdev->pkt_type & HCI_3DH1))
780 				if (lmp_edr_3slot_capable(hdev) &&
781 				    !(hdev->pkt_type & HCI_3DH3))
784 				if (lmp_edr_5slot_capable(hdev) &&
785 				    !(hdev->pkt_type & HCI_3DH5))
791 	if (lmp_le_capable(hdev)) {
792 		if (hdev->le_tx_def_phys & HCI_LE_SET_PHY_1M)
795 		if (hdev->le_rx_def_phys & HCI_LE_SET_PHY_1M)
798 		if (hdev->le_tx_def_phys & HCI_LE_SET_PHY_2M)
801 		if (hdev->le_rx_def_phys & HCI_LE_SET_PHY_2M)
804 		if (hdev->le_tx_def_phys & HCI_LE_SET_PHY_CODED)
807 		if (hdev->le_rx_def_phys & HCI_LE_SET_PHY_CODED)
814 static u32 get_configurable_phys(struct hci_dev *hdev)
816 	return (get_supported_phys(hdev) & ~MGMT_PHY_BR_1M_1SLOT &
820 static u32 get_supported_settings(struct hci_dev *hdev)
830 	if (lmp_bredr_capable(hdev)) {
831 		if (hdev->hci_ver >= BLUETOOTH_VER_1_2)
836 		if (lmp_ssp_capable(hdev)) {
840 		if (lmp_sc_capable(hdev))
844 			     &hdev->quirks))
848 	if (lmp_le_capable(hdev)) {
856 	if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) ||
857 	    hdev->set_bdaddr)
860 	if (cis_central_capable(hdev))
863 	if (cis_peripheral_capable(hdev))
871 static u32 get_current_settings(struct hci_dev *hdev)
875 	if (hdev_is_powered(hdev))
878 	if (hci_dev_test_flag(hdev, HCI_CONNECTABLE))
881 	if (hci_dev_test_flag(hdev, HCI_FAST_CONNECTABLE))
884 	if (hci_dev_test_flag(hdev, HCI_DISCOVERABLE))
887 	if (hci_dev_test_flag(hdev, HCI_BONDABLE))
890 	if (hci_dev_test_flag(hdev, HCI_BREDR_ENABLED))
893 	if (hci_dev_test_flag(hdev, HCI_LE_ENABLED))
896 	if (hci_dev_test_flag(hdev, HCI_LINK_SECURITY))
899 	if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED))
902 	if (hci_dev_test_flag(hdev, HCI_ADVERTISING))
905 	if (hci_dev_test_flag(hdev, HCI_SC_ENABLED))
908 	if (hci_dev_test_flag(hdev, HCI_KEEP_DEBUG_KEYS))
911 	if (hci_dev_test_flag(hdev, HCI_PRIVACY))
926 	if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ||
927 	    !hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) ||
928 	    !bacmp(&hdev->bdaddr, BDADDR_ANY)) {
929 		if (bacmp(&hdev->static_addr, BDADDR_ANY))
933 	if (hci_dev_test_flag(hdev, HCI_WIDEBAND_SPEECH_ENABLED))
936 	if (cis_central_capable(hdev))
939 	if (cis_peripheral_capable(hdev))
942 	if (bis_capable(hdev))
945 	if (sync_recv_capable(hdev))
951 static struct mgmt_pending_cmd *pending_find(u16 opcode, struct hci_dev *hdev)
953 	return mgmt_pending_find(HCI_CHANNEL_CONTROL, opcode, hdev);
956 u8 mgmt_get_adv_discov_flags(struct hci_dev *hdev)
963 	cmd = pending_find(MGMT_OP_SET_DISCOVERABLE, hdev);
971 		if (hci_dev_test_flag(hdev, HCI_LIMITED_DISCOVERABLE))
973 		else if (hci_dev_test_flag(hdev, HCI_DISCOVERABLE))
980 bool mgmt_get_connectable(struct hci_dev *hdev)
987 	cmd = pending_find(MGMT_OP_SET_CONNECTABLE, hdev);
994 	return hci_dev_test_flag(hdev, HCI_CONNECTABLE);
997 static int service_cache_sync(struct hci_dev *hdev, void *data)
999 	hci_update_eir_sync(hdev);
1000 	hci_update_class_sync(hdev);
1007 	struct hci_dev *hdev = container_of(work, struct hci_dev,
1010 	if (!hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE))
1013 	hci_cmd_sync_queue(hdev, service_cache_sync, NULL, NULL);
1016 static int rpa_expired_sync(struct hci_dev *hdev, void *data)
1022 	if (ext_adv_capable(hdev))
1023 		return hci_start_ext_adv_sync(hdev, hdev->cur_adv_instance);
1025 		return hci_enable_advertising_sync(hdev);
1030 	struct hci_dev *hdev = container_of(work, struct hci_dev,
1033 	bt_dev_dbg(hdev, "");
1035 	hci_dev_set_flag(hdev, HCI_RPA_EXPIRED);
1037 	if (!hci_dev_test_flag(hdev, HCI_ADVERTISING))
1040 	hci_cmd_sync_queue(hdev, rpa_expired_sync, NULL, NULL);
1043 static int set_discoverable_sync(struct hci_dev *hdev, void *data);
1047 	struct hci_dev *hdev = container_of(work, struct hci_dev,
1050 	bt_dev_dbg(hdev, "");
1052 	hci_dev_lock(hdev);
1059 	hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE);
1060 	hci_dev_clear_flag(hdev, HCI_DISCOVERABLE);
1061 	hdev->discov_timeout = 0;
1063 	hci_cmd_sync_queue(hdev, set_discoverable_sync, NULL, NULL);
1065 	mgmt_new_settings(hdev);
1067 	hci_dev_unlock(hdev);
1070 static int send_settings_rsp(struct sock *sk, u16 opcode, struct hci_dev *hdev);
1072 static void mesh_send_complete(struct hci_dev *hdev,
1078 		mgmt_event(MGMT_EV_MESH_PACKET_CMPLT, hdev, &handle,
1084 static int mesh_send_done_sync(struct hci_dev *hdev, void *data)
1088 	hci_dev_clear_flag(hdev, HCI_MESH_SENDING);
1089 	hci_disable_advertising_sync(hdev);
1090 	mesh_tx = mgmt_mesh_next(hdev, NULL);
1093 		mesh_send_complete(hdev, mesh_tx, false);
1098 static int mesh_send_sync(struct hci_dev *hdev, void *data);
1099 static void mesh_send_start_complete(struct hci_dev *hdev, void *data, int err);
1100 static void mesh_next(struct hci_dev *hdev, void *data, int err)
1102 	struct mgmt_mesh_tx *mesh_tx = mgmt_mesh_next(hdev, NULL);
1107 	err = hci_cmd_sync_queue(hdev, mesh_send_sync, mesh_tx,
1111 		mesh_send_complete(hdev, mesh_tx, false);
1113 		hci_dev_set_flag(hdev, HCI_MESH_SENDING);
1118 	struct hci_dev *hdev = container_of(work, struct hci_dev,
1121 	if (!hci_dev_test_flag(hdev, HCI_MESH_SENDING))
1124 	hci_cmd_sync_queue(hdev, mesh_send_done_sync, NULL, mesh_next);
1127 static void mgmt_init_hdev(struct sock *sk, struct hci_dev *hdev)
1129 	if (hci_dev_test_flag(hdev, HCI_MGMT))
1134 	INIT_DELAYED_WORK(&hdev->discov_off, discov_off);
1135 	INIT_DELAYED_WORK(&hdev->service_cache, service_cache_off);
1136 	INIT_DELAYED_WORK(&hdev->rpa_expired, rpa_expired);
1137 	INIT_DELAYED_WORK(&hdev->mesh_send_done, mesh_send_done);
1144 	hci_dev_clear_flag(hdev, HCI_BONDABLE);
1146 	hci_dev_set_flag(hdev, HCI_MGMT);
1149 static int read_controller_info(struct sock *sk, struct hci_dev *hdev,
1154 	bt_dev_dbg(hdev, "sock %p", sk);
1156 	hci_dev_lock(hdev);
1160 	bacpy(&rp.bdaddr, &hdev->bdaddr);
1162 	rp.version = hdev->hci_ver;
1163 	rp.manufacturer = cpu_to_le16(hdev->manufacturer);
1165 	rp.supported_settings = cpu_to_le32(get_supported_settings(hdev));
1166 	rp.current_settings = cpu_to_le32(get_current_settings(hdev));
1168 	memcpy(rp.dev_class, hdev->dev_class, 3);
1170 	memcpy(rp.name, hdev->dev_name, sizeof(hdev->dev_name));
1171 	memcpy(rp.short_name, hdev->short_name, sizeof(hdev->short_name));
1173 	hci_dev_unlock(hdev);
1175 	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_INFO, 0, &rp,
1179 static u16 append_eir_data_to_buf(struct hci_dev *hdev, u8 *eir)
1184 	if (hci_dev_test_flag(hdev, HCI_BREDR_ENABLED))
1186 					  hdev->dev_class, 3);
1188 	if (hci_dev_test_flag(hdev, HCI_LE_ENABLED))
1190 					  hdev->appearance);
1192 	name_len = strnlen(hdev->dev_name, sizeof(hdev->dev_name));
1194 				  hdev->dev_name, name_len);
1196 	name_len = strnlen(hdev->short_name, sizeof(hdev->short_name));
1198 				  hdev->short_name, name_len);
1203 static int read_ext_controller_info(struct sock *sk, struct hci_dev *hdev,
1210 	bt_dev_dbg(hdev, "sock %p", sk);
1214 	hci_dev_lock(hdev);
1216 	bacpy(&rp->bdaddr, &hdev->bdaddr);
1218 	rp->version = hdev->hci_ver;
1219 	rp->manufacturer = cpu_to_le16(hdev->manufacturer);
1221 	rp->supported_settings = cpu_to_le32(get_supported_settings(hdev));
1222 	rp->current_settings = cpu_to_le32(get_current_settings(hdev));
1225 	eir_len = append_eir_data_to_buf(hdev, rp->eir);
1228 	hci_dev_unlock(hdev);
1239 	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_EXT_INFO, 0, rp,
1243 static int ext_info_changed(struct hci_dev *hdev, struct sock *skip)
1251 	eir_len = append_eir_data_to_buf(hdev, ev->eir);
1254 	return mgmt_limited_event(MGMT_EV_EXT_INFO_CHANGED, hdev, ev,
1259 static int send_settings_rsp(struct sock *sk, u16 opcode, struct hci_dev *hdev)
1261 	__le32 settings = cpu_to_le32(get_current_settings(hdev));
1263 	return mgmt_cmd_complete(sk, hdev->id, opcode, 0, &settings,
1267 void mgmt_advertising_added(struct sock *sk, struct hci_dev *hdev, u8 instance)
1273 	mgmt_event(MGMT_EV_ADVERTISING_ADDED, hdev, &ev, sizeof(ev), sk);
1276 void mgmt_advertising_removed(struct sock *sk, struct hci_dev *hdev,
1283 	mgmt_event(MGMT_EV_ADVERTISING_REMOVED, hdev, &ev, sizeof(ev), sk);
1286 static void cancel_adv_timeout(struct hci_dev *hdev)
1288 	if (hdev->adv_instance_timeout) {
1289 		hdev->adv_instance_timeout = 0;
1290 		cancel_delayed_work(&hdev->adv_instance_expire);
1294 /* This function requires the caller holds hdev->lock */
1295 static void restart_le_actions(struct hci_dev *hdev)
1299 	list_for_each_entry(p, &hdev->le_conn_params, list) {
1308 			hci_pend_le_list_add(p, &hdev->pend_le_conns);
1311 			hci_pend_le_list_add(p, &hdev->pend_le_reports);
1319 static int new_settings(struct hci_dev *hdev, struct sock *skip)
1321 	__le32 ev = cpu_to_le32(get_current_settings(hdev));
1323 	return mgmt_limited_event(MGMT_EV_NEW_SETTINGS, hdev, &ev,
1327 static void mgmt_set_powered_complete(struct hci_dev *hdev, void *data, int err)
1333 	if (cmd != pending_find(MGMT_OP_SET_POWERED, hdev))
1338 	bt_dev_dbg(hdev, "err %d", err);
1342 			hci_dev_lock(hdev);
1343 			restart_le_actions(hdev);
1344 			hci_update_passive_scan(hdev);
1345 			hci_dev_unlock(hdev);
1348 		send_settings_rsp(cmd->sk, cmd->opcode, hdev);
1351 		 * to hdev->power_off work which does call hci_dev_do_close.
1354 			new_settings(hdev, cmd->sk);
1356 		mgmt_cmd_status(cmd->sk, hdev->id, MGMT_OP_SET_POWERED,
1363 static int set_powered_sync(struct hci_dev *hdev, void *data)
1368 	BT_DBG("%s", hdev->name);
1370 	return hci_set_powered_sync(hdev, cp->val);
1373 static int set_powered(struct sock *sk, struct hci_dev *hdev, void *data,
1380 	bt_dev_dbg(hdev, "sock %p", sk);
1383 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_POWERED,
1386 	hci_dev_lock(hdev);
1388 	if (pending_find(MGMT_OP_SET_POWERED, hdev)) {
1389 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_POWERED,
1394 	if (!!cp->val == hdev_is_powered(hdev)) {
1395 		err = send_settings_rsp(sk, MGMT_OP_SET_POWERED, hdev);
1399 	cmd = mgmt_pending_add(sk, MGMT_OP_SET_POWERED, hdev, data, len);
1407 		hci_cmd_sync_cancel_sync(hdev, -EHOSTDOWN);
1408 		err = hci_cmd_sync_queue(hdev, set_powered_sync, cmd,
1411 		/* Use hci_cmd_sync_submit since hdev might not be running */
1412 		err = hci_cmd_sync_submit(hdev, set_powered_sync, cmd,
1420 	hci_dev_unlock(hdev);
1424 int mgmt_new_settings(struct hci_dev *hdev)
1426 	return new_settings(hdev, NULL);
1431 	struct hci_dev *hdev;
1439 	send_settings_rsp(cmd->sk, cmd->opcode, match->hdev);
1485 static u8 mgmt_bredr_support(struct hci_dev *hdev)
1487 	if (!lmp_bredr_capable(hdev))
1489 	else if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED))
1495 static u8 mgmt_le_support(struct hci_dev *hdev)
1497 	if (!lmp_le_capable(hdev))
1499 	else if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED))
1505 static void mgmt_set_discoverable_complete(struct hci_dev *hdev, void *data,
1510 	bt_dev_dbg(hdev, "err %d", err);
1513 	if (cmd != pending_find(MGMT_OP_SET_DISCOVERABLE, hdev))
1516 	hci_dev_lock(hdev);
1521 		hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE);
1525 	if (hci_dev_test_flag(hdev, HCI_DISCOVERABLE) &&
1526 	    hdev->discov_timeout > 0) {
1527 		int to = msecs_to_jiffies(hdev->discov_timeout * 1000);
1528 		queue_delayed_work(hdev->req_workqueue, &hdev->discov_off, to);
1531 	send_settings_rsp(cmd->sk, MGMT_OP_SET_DISCOVERABLE, hdev);
1532 	new_settings(hdev, cmd->sk);
1536 	hci_dev_unlock(hdev);
1539 static int set_discoverable_sync(struct hci_dev *hdev, void *data)
1541 	BT_DBG("%s", hdev->name);
1543 	return hci_update_discoverable_sync(hdev);
1546 static int set_discoverable(struct sock *sk, struct hci_dev *hdev, void *data,
1554 	bt_dev_dbg(hdev, "sock %p", sk);
1556 	if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED) &&
1557 	    !hci_dev_test_flag(hdev, HCI_BREDR_ENABLED))
1558 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
1562 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
1572 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
1575 	hci_dev_lock(hdev);
1577 	if (!hdev_is_powered(hdev) && timeout > 0) {
1578 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
1583 	if (pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) ||
1584 	    pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) {
1585 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
1590 	if (!hci_dev_test_flag(hdev, HCI_CONNECTABLE)) {
1591 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
1596 	if (hdev->advertising_paused) {
1597 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
1602 	if (!hdev_is_powered(hdev)) {
1609 		if (!!cp->val != hci_dev_test_flag(hdev, HCI_DISCOVERABLE)) {
1610 			hci_dev_change_flag(hdev, HCI_DISCOVERABLE);
1614 		err = send_settings_rsp(sk, MGMT_OP_SET_DISCOVERABLE, hdev);
1619 			err = new_settings(hdev, sk);
1628 	if (!!cp->val == hci_dev_test_flag(hdev, HCI_DISCOVERABLE) &&
1629 	    (cp->val == 0x02) == hci_dev_test_flag(hdev,
1631 		cancel_delayed_work(&hdev->discov_off);
1632 		hdev->discov_timeout = timeout;
1634 		if (cp->val && hdev->discov_timeout > 0) {
1635 			int to = msecs_to_jiffies(hdev->discov_timeout * 1000);
1636 			queue_delayed_work(hdev->req_workqueue,
1637 					   &hdev->discov_off, to);
1640 		err = send_settings_rsp(sk, MGMT_OP_SET_DISCOVERABLE, hdev);
1644 	cmd = mgmt_pending_add(sk, MGMT_OP_SET_DISCOVERABLE, hdev, data, len);
1654 	cancel_delayed_work(&hdev->discov_off);
1655 	hdev->discov_timeout = timeout;
1658 		hci_dev_set_flag(hdev, HCI_DISCOVERABLE);
1660 		hci_dev_clear_flag(hdev, HCI_DISCOVERABLE);
1664 		hci_dev_set_flag(hdev, HCI_LIMITED_DISCOVERABLE);
1666 		hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE);
1668 	err = hci_cmd_sync_queue(hdev, set_discoverable_sync, cmd,
1675 	hci_dev_unlock(hdev);
1679 static void mgmt_set_connectable_complete(struct hci_dev *hdev, void *data,
1684 	bt_dev_dbg(hdev, "err %d", err);
1687 	if (cmd != pending_find(MGMT_OP_SET_CONNECTABLE, hdev))
1690 	hci_dev_lock(hdev);
1698 	send_settings_rsp(cmd->sk, MGMT_OP_SET_CONNECTABLE, hdev);
1699 	new_settings(hdev, cmd->sk);
1705 	hci_dev_unlock(hdev);
1708 static int set_connectable_update_settings(struct hci_dev *hdev,
1714 	if (!!val != hci_dev_test_flag(hdev, HCI_CONNECTABLE))
1718 		hci_dev_set_flag(hdev, HCI_CONNECTABLE);
1720 		hci_dev_clear_flag(hdev, HCI_CONNECTABLE);
1721 		hci_dev_clear_flag(hdev, HCI_DISCOVERABLE);
1724 	err = send_settings_rsp(sk, MGMT_OP_SET_CONNECTABLE, hdev);
1729 		hci_update_scan(hdev);
1730 		hci_update_passive_scan(hdev);
1731 		return new_settings(hdev, sk);
1737 static int set_connectable_sync(struct hci_dev *hdev, void *data)
1739 	BT_DBG("%s", hdev->name);
1741 	return hci_update_connectable_sync(hdev);
1744 static int set_connectable(struct sock *sk, struct hci_dev *hdev, void *data,
1751 	bt_dev_dbg(hdev, "sock %p", sk);
1753 	if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED) &&
1754 	    !hci_dev_test_flag(hdev, HCI_BREDR_ENABLED))
1755 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE,
1759 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE,
1762 	hci_dev_lock(hdev);
1764 	if (!hdev_is_powered(hdev)) {
1765 		err = set_connectable_update_settings(hdev, sk, cp->val);
1769 	if (pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) ||
1770 	    pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) {
1771 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE,
1776 	cmd = mgmt_pending_add(sk, MGMT_OP_SET_CONNECTABLE, hdev, data, len);
1783 		hci_dev_set_flag(hdev, HCI_CONNECTABLE);
1785 		if (hdev->discov_timeout > 0)
1786 			cancel_delayed_work(&hdev->discov_off);
1788 		hci_dev_clear_flag(hdev, HCI_LIMITED_DISCOVERABLE);
1789 		hci_dev_clear_flag(hdev, HCI_DISCOVERABLE);
1790 		hci_dev_clear_flag(hdev, HCI_CONNECTABLE);
1793 	err = hci_cmd_sync_queue(hdev, set_connectable_sync, cmd,
1800 	hci_dev_unlock(hdev);
1804 static int set_bondable(struct sock *sk, struct hci_dev *hdev, void *data,
1811 	bt_dev_dbg(hdev, "sock %p", sk);
1814 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BONDABLE,
1817 	hci_dev_lock(hdev);
1820 		changed = !hci_dev_test_and_set_flag(hdev, HCI_BONDABLE);
1822 		changed = hci_dev_test_and_clear_flag(hdev, HCI_BONDABLE);
1824 	err = send_settings_rsp(sk, MGMT_OP_SET_BONDABLE, hdev);
1832 		hci_update_discoverable(hdev);
1834 		err = new_settings(hdev, sk);
1838 	hci_dev_unlock(hdev);
1842 static int set_link_security(struct sock *sk, struct hci_dev *hdev, void *data,
1850 	bt_dev_dbg(hdev, "sock %p", sk);
1852 	status = mgmt_bredr_support(hdev);
1854 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY,
1858 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY,
1861 	hci_dev_lock(hdev);
1863 	if (!hdev_is_powered(hdev)) {
1866 		if (!!cp->val != hci_dev_test_flag(hdev, HCI_LINK_SECURITY)) {
1867 			hci_dev_change_flag(hdev, HCI_LINK_SECURITY);
1871 		err = send_settings_rsp(sk, MGMT_OP_SET_LINK_SECURITY, hdev);
1876 			err = new_settings(hdev, sk);
1881 	if (pending_find(MGMT_OP_SET_LINK_SECURITY, hdev)) {
1882 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY,
1889 	if (test_bit(HCI_AUTH, &hdev->flags) == val) {
1890 		err = send_settings_rsp(sk, MGMT_OP_SET_LINK_SECURITY, hdev);
1894 	cmd = mgmt_pending_add(sk, MGMT_OP_SET_LINK_SECURITY, hdev, data, len);
1900 	err = hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, sizeof(val), &val);
1907 	hci_dev_unlock(hdev);
1911 static void set_ssp_complete(struct hci_dev *hdev, void *data, int err)
1913 	struct cmd_lookup match = { NULL, hdev };
1920 	if (cmd != pending_find(MGMT_OP_SET_SSP, hdev))
1926 		if (enable && hci_dev_test_and_clear_flag(hdev,
1928 			new_settings(hdev, NULL);
1931 		mgmt_pending_foreach(MGMT_OP_SET_SSP, hdev, cmd_status_rsp,
1937 		changed = !hci_dev_test_and_set_flag(hdev, HCI_SSP_ENABLED);
1939 		changed = hci_dev_test_and_clear_flag(hdev, HCI_SSP_ENABLED);
1942 	mgmt_pending_foreach(MGMT_OP_SET_SSP, hdev, settings_rsp, &match);
1945 		new_settings(hdev, match.sk);
1950 	hci_update_eir_sync(hdev);
1953 static int set_ssp_sync(struct hci_dev *hdev, void *data)
1961 		changed = !hci_dev_test_and_set_flag(hdev, HCI_SSP_ENABLED);
1963 	err = hci_write_ssp_mode_sync(hdev, cp->val);
1966 		hci_dev_clear_flag(hdev, HCI_SSP_ENABLED);
1971 static int set_ssp(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
1978 	bt_dev_dbg(hdev, "sock %p", sk);
1980 	status = mgmt_bredr_support(hdev);
1982 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SSP, status);
1984 	if (!lmp_ssp_capable(hdev))
1985 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
1989 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
1992 	hci_dev_lock(hdev);
1994 	if (!hdev_is_powered(hdev)) {
1998 			changed = !hci_dev_test_and_set_flag(hdev,
2001 			changed = hci_dev_test_and_clear_flag(hdev,
2005 		err = send_settings_rsp(sk, MGMT_OP_SET_SSP, hdev);
2010 			err = new_settings(hdev, sk);
2015 	if (pending_find(MGMT_OP_SET_SSP, hdev)) {
2016 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
2021 	if (!!cp->val == hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) {
2022 		err = send_settings_rsp(sk, MGMT_OP_SET_SSP, hdev);
2026 	cmd = mgmt_pending_add(sk, MGMT_OP_SET_SSP, hdev, data, len);
2030 		err = hci_cmd_sync_queue(hdev, set_ssp_sync, cmd,
2034 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
2042 	hci_dev_unlock(hdev);
2046 static int set_hs(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
2048 	bt_dev_dbg(hdev, "sock %p", sk);
2050 	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_HS,
2054 static void set_le_complete(struct hci_dev *hdev, void *data, int err)
2056 	struct cmd_lookup match = { NULL, hdev };
2059 	bt_dev_dbg(hdev, "err %d", err);
2062 		mgmt_pending_foreach(MGMT_OP_SET_LE, hdev, cmd_status_rsp,
2067 	mgmt_pending_foreach(MGMT_OP_SET_LE, hdev, settings_rsp, &match);
2069 	new_settings(hdev, match.sk);
2075 static int set_le_sync(struct hci_dev *hdev, void *data)
2083 		hci_clear_adv_instance_sync(hdev, NULL, 0x00, true);
2085 		if (hci_dev_test_flag(hdev, HCI_LE_ADV))
2086 			hci_disable_advertising_sync(hdev);
2088 		if (ext_adv_capable(hdev))
2089 			hci_remove_ext_adv_instance_sync(hdev, 0, cmd->sk);
2091 		hci_dev_set_flag(hdev, HCI_LE_ENABLED);
2094 	err = hci_write_le_host_supported_sync(hdev, val, 0);
2101 	if (!err && hci_dev_test_flag(hdev, HCI_LE_ENABLED)) {
2102 		if (ext_adv_capable(hdev)) {
2105 			status = hci_setup_ext_adv_instance_sync(hdev, 0x00);
2107 				hci_update_scan_rsp_data_sync(hdev, 0x00);
2109 			hci_update_adv_data_sync(hdev, 0x00);
2110 			hci_update_scan_rsp_data_sync(hdev, 0x00);
2113 		hci_update_passive_scan(hdev);
2119 static void set_mesh_complete(struct hci_dev *hdev, void *data, int err)
2126 		mgmt_pending_foreach(MGMT_OP_SET_MESH_RECEIVER, hdev,
2132 	mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_MESH_RECEIVER, 0, NULL, 0);
2135 static int set_mesh_sync(struct hci_dev *hdev, void *data)
2141 	memset(hdev->mesh_ad_types, 0, sizeof(hdev->mesh_ad_types));
2144 		hci_dev_set_flag(hdev, HCI_MESH);
2146 		hci_dev_clear_flag(hdev, HCI_MESH);
2151 	if (len <= sizeof(hdev->mesh_ad_types))
2152 		memcpy(hdev->mesh_ad_types, cp->ad_types, len);
2154 	hci_update_passive_scan_sync(hdev);
2158 static int set_mesh(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
2164 	bt_dev_dbg(hdev, "sock %p", sk);
2166 	if (!lmp_le_capable(hdev) ||
2167 	    !hci_dev_test_flag(hdev, HCI_MESH_EXPERIMENTAL))
2168 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_MESH_RECEIVER,
2172 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_MESH_RECEIVER,
2175 	hci_dev_lock(hdev);
2177 	cmd = mgmt_pending_add(sk, MGMT_OP_SET_MESH_RECEIVER, hdev, data, len);
2181 		err = hci_cmd_sync_queue(hdev, set_mesh_sync, cmd,
2185 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_MESH_RECEIVER,
2192 	hci_dev_unlock(hdev);
2196 static void mesh_send_start_complete(struct hci_dev *hdev, void *data, int err)
2206 		hci_dev_clear_flag(hdev, HCI_MESH_SENDING);
2208 		mesh_send_complete(hdev, mesh_tx, false);
2213 	queue_delayed_work(hdev->req_workqueue, &hdev->mesh_send_done,
2217 static int mesh_send_sync(struct hci_dev *hdev, void *data)
2222 	u8 instance = hdev->le_num_of_adv_sets + 1;
2226 	if (hdev->le_num_of_adv_sets <= hdev->adv_instance_cnt)
2230 	duration = send->cnt * INTERVAL_TO_MS(hdev->le_adv_max_interval);
2231 	adv = hci_add_adv_instance(hdev, instance, 0,
2236 				   hdev->le_adv_min_interval,
2237 				   hdev->le_adv_max_interval,
2245 	if (hdev->cur_adv_instance == instance) {
2251 		cancel_adv_timeout(hdev);
2253 		next_instance = hci_get_next_instance(hdev, instance);
2258 	} else if (hdev->adv_instance_timeout) {
2266 		return hci_schedule_adv_instance_sync(hdev, instance, true);
2281 static int mesh_features(struct sock *sk, struct hci_dev *hdev,
2286 	if (!lmp_le_capable(hdev) ||
2287 	    !hci_dev_test_flag(hdev, HCI_MESH_EXPERIMENTAL))
2288 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_MESH_READ_FEATURES,
2292 	rp.index = cpu_to_le16(hdev->id);
2293 	if (hci_dev_test_flag(hdev, HCI_LE_ENABLED))
2296 	hci_dev_lock(hdev);
2299 		mgmt_mesh_foreach(hdev, send_count, &rp, sk);
2301 	mgmt_cmd_complete(sk, hdev->id, MGMT_OP_MESH_READ_FEATURES, 0, &rp,
2304 	hci_dev_unlock(hdev);
2308 static int send_cancel(struct hci_dev *hdev, void *data)
2316 			mesh_tx = mgmt_mesh_next(hdev, cmd->sk);
2319 				mesh_send_complete(hdev, mesh_tx, false);
2322 		mesh_tx = mgmt_mesh_find(hdev, cancel->handle);
2325 			mesh_send_complete(hdev, mesh_tx, false);
2328 	mgmt_cmd_complete(cmd->sk, hdev->id, MGMT_OP_MESH_SEND_CANCEL,
2335 static int mesh_send_cancel(struct sock *sk, struct hci_dev *hdev,
2341 	if (!lmp_le_capable(hdev) ||
2342 	    !hci_dev_test_flag(hdev, HCI_MESH_EXPERIMENTAL))
2343 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_MESH_SEND_CANCEL,
2346 	if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED))
2347 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_MESH_SEND_CANCEL,
2350 	hci_dev_lock(hdev);
2351 	cmd = mgmt_pending_new(sk, MGMT_OP_MESH_SEND_CANCEL, hdev, data, len);
2355 		err = hci_cmd_sync_queue(hdev, send_cancel, cmd, NULL);
2358 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_MESH_SEND_CANCEL,
2365 	hci_dev_unlock(hdev);
2369 static int mesh_send(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
2377 	if (!lmp_le_capable(hdev) ||
2378 	    !hci_dev_test_flag(hdev, HCI_MESH_EXPERIMENTAL))
2379 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_MESH_SEND,
2381 	if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED) ||
2384 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_MESH_SEND,
2387 	hci_dev_lock(hdev);
2392 	mgmt_mesh_foreach(hdev, send_count, &rp, sk);
2395 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_MESH_SEND,
2400 	sending = hci_dev_test_flag(hdev, HCI_MESH_SENDING);
2401 	mesh_tx = mgmt_mesh_add(sk, hdev, send, len);
2406 		err = hci_cmd_sync_queue(hdev, mesh_send_sync, mesh_tx,
2410 		bt_dev_err(hdev, "Send Mesh Failed %d", err);
2411 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_MESH_SEND,
2419 		hci_dev_set_flag(hdev, HCI_MESH_SENDING);
2421 		mgmt_cmd_complete(sk, hdev->id, MGMT_OP_MESH_SEND, 0,
2426 	hci_dev_unlock(hdev);
2430 static int set_le(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
2437 	bt_dev_dbg(hdev, "sock %p", sk);
2439 	if (!lmp_le_capable(hdev))
2440 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
2444 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
2456 	if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) {
2458 			return send_settings_rsp(sk, MGMT_OP_SET_LE, hdev);
2460 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
2464 	hci_dev_lock(hdev);
2467 	enabled = lmp_host_le_capable(hdev);
2469 	if (!hdev_is_powered(hdev) || val == enabled) {
2472 		if (val != hci_dev_test_flag(hdev, HCI_LE_ENABLED)) {
2473 			hci_dev_change_flag(hdev, HCI_LE_ENABLED);
2477 		if (!val && hci_dev_test_flag(hdev, HCI_ADVERTISING)) {
2478 			hci_dev_clear_flag(hdev, HCI_ADVERTISING);
2482 		err = send_settings_rsp(sk, MGMT_OP_SET_LE, hdev);
2487 			err = new_settings(hdev, sk);
2492 	if (pending_find(MGMT_OP_SET_LE, hdev) ||
2493 	    pending_find(MGMT_OP_SET_ADVERTISING, hdev)) {
2494 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
2499 	cmd = mgmt_pending_add(sk, MGMT_OP_SET_LE, hdev, data, len);
2503 		err = hci_cmd_sync_queue(hdev, set_le_sync, cmd,
2507 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
2515 	hci_dev_unlock(hdev);
2525 static bool pending_eir_or_class(struct hci_dev *hdev)
2529 	list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
2561 static void mgmt_class_complete(struct hci_dev *hdev, void *data, int err)
2565 	bt_dev_dbg(hdev, "err %d", err);
2568 			  mgmt_status(err), hdev->dev_class, 3);
2573 static int add_uuid_sync(struct hci_dev *hdev, void *data)
2577 	err = hci_update_class_sync(hdev);
2581 	return hci_update_eir_sync(hdev);
2584 static int add_uuid(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
2591 	bt_dev_dbg(hdev, "sock %p", sk);
2593 	hci_dev_lock(hdev);
2595 	if (pending_eir_or_class(hdev)) {
2596 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_UUID,
2611 	list_add_tail(&uuid->list, &hdev->uuids);
2613 	cmd = mgmt_pending_new(sk, MGMT_OP_ADD_UUID, hdev, data, len);
2619 	err = hci_cmd_sync_queue(hdev, add_uuid_sync, cmd, mgmt_class_complete);
2626 	hci_dev_unlock(hdev);
2630 static bool enable_service_cache(struct hci_dev *hdev)
2632 	if (!hdev_is_powered(hdev))
2635 	if (!hci_dev_test_and_set_flag(hdev, HCI_SERVICE_CACHE)) {
2636 		queue_delayed_work(hdev->workqueue, &hdev->service_cache,
2644 static int remove_uuid_sync(struct hci_dev *hdev, void *data)
2648 	err = hci_update_class_sync(hdev);
2652 	return hci_update_eir_sync(hdev);
2655 static int remove_uuid(struct sock *sk, struct hci_dev *hdev, void *data,
2666 	bt_dev_dbg(hdev, "sock %p", sk);
2668 	hci_dev_lock(hdev);
2670 	if (pending_eir_or_class(hdev)) {
2671 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_REMOVE_UUID,
2677 		hci_uuids_clear(hdev);
2679 		if (enable_service_cache(hdev)) {
2680 			err = mgmt_cmd_complete(sk, hdev->id,
2682 						0, hdev->dev_class, 3);
2691 	list_for_each_entry_safe(match, tmp, &hdev->uuids, list) {
2701 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_REMOVE_UUID,
2707 	cmd = mgmt_pending_new(sk, MGMT_OP_REMOVE_UUID, hdev, data, len);
2713 	err = hci_cmd_sync_queue(hdev, remove_uuid_sync, cmd,
2719 	hci_dev_unlock(hdev);
2723 static int set_class_sync(struct hci_dev *hdev, void *data)
2727 	if (hci_dev_test_and_clear_flag(hdev, HCI_SERVICE_CACHE)) {
2728 		cancel_delayed_work_sync(&hdev->service_cache);
2729 		err = hci_update_eir_sync(hdev);
2735 	return hci_update_class_sync(hdev);
2738 static int set_dev_class(struct sock *sk, struct hci_dev *hdev, void *data,
2745 	bt_dev_dbg(hdev, "sock %p", sk);
2747 	if (!lmp_bredr_capable(hdev))
2748 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS,
2751 	hci_dev_lock(hdev);
2753 	if (pending_eir_or_class(hdev)) {
2754 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS,
2760 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS,
2765 	hdev->major_class = cp->major;
2766 	hdev->minor_class = cp->minor;
2768 	if (!hdev_is_powered(hdev)) {
2769 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, 0,
2770 					hdev->dev_class, 3);
2774 	cmd = mgmt_pending_new(sk, MGMT_OP_SET_DEV_CLASS, hdev, data, len);
2780 	err = hci_cmd_sync_queue(hdev, set_class_sync, cmd,
2786 	hci_dev_unlock(hdev);
2790 static int load_link_keys(struct sock *sk, struct hci_dev *hdev, void *data,
2800 	bt_dev_dbg(hdev, "sock %p", sk);
2802 	if (!lmp_bredr_capable(hdev))
2803 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
2808 		bt_dev_err(hdev, "load_link_keys: too big key_count value %u",
2810 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
2816 		bt_dev_err(hdev, "load_link_keys: expected %u bytes, got %u bytes",
2818 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
2823 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
2826 	bt_dev_dbg(hdev, "debug_keys %u key_count %u", cp->debug_keys,
2834 			return mgmt_cmd_status(sk, hdev->id,
2839 	hci_dev_lock(hdev);
2841 	hci_link_keys_clear(hdev);
2844 		changed = !hci_dev_test_and_set_flag(hdev, HCI_KEEP_DEBUG_KEYS);
2846 		changed = hci_dev_test_and_clear_flag(hdev,
2850 		new_settings(hdev, NULL);
2855 		if (hci_is_blocked_key(hdev,
2858 			bt_dev_warn(hdev, "Skipping blocked link key for %pMR",
2869 		hci_add_link_key(hdev, NULL, &key->addr.bdaddr, key->val,
2873 	mgmt_cmd_complete(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS, 0, NULL, 0);
2875 	hci_dev_unlock(hdev);
2880 static int device_unpaired(struct hci_dev *hdev, bdaddr_t *bdaddr,
2888 	return mgmt_event(MGMT_EV_DEVICE_UNPAIRED, hdev, &ev, sizeof(ev),
2892 static void unpair_device_complete(struct hci_dev *hdev, void *data, int err)
2898 		device_unpaired(hdev, &cp->addr.bdaddr, cp->addr.type, cmd->sk);
2904 static int unpair_device_sync(struct hci_dev *hdev, void *data)
2911 		conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK,
2914 		conn = hci_conn_hash_lookup_le(hdev, &cp->addr.bdaddr,
2920 	return hci_abort_conn_sync(hdev, conn, HCI_ERROR_REMOTE_USER_TERM);
2923 static int unpair_device(struct sock *sk, struct hci_dev *hdev, void *data,
2939 		return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
2944 		return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
2948 	hci_dev_lock(hdev);
2950 	if (!hdev_is_powered(hdev)) {
2951 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
2966 			conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK,
2971 		err = hci_remove_link_key(hdev, &cp->addr.bdaddr);
2973 			err = mgmt_cmd_complete(sk, hdev->id,
2987 	err = smp_cancel_and_remove_pairing(hdev, &cp->addr.bdaddr, addr_type);
2989 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
2995 	conn = hci_conn_hash_lookup_le(hdev, &cp->addr.bdaddr, addr_type);
2997 		hci_conn_params_del(hdev, &cp->addr.bdaddr, addr_type);
3008 	params = hci_conn_params_lookup(hdev, &cp->addr.bdaddr, addr_type);
3027 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE, 0,
3029 		device_unpaired(hdev, &cp->addr.bdaddr, cp->addr.type, sk);
3033 	cmd = mgmt_pending_new(sk, MGMT_OP_UNPAIR_DEVICE, hdev, cp,
3042 	err = hci_cmd_sync_queue(hdev, unpair_device_sync, cmd,
3048 	hci_dev_unlock(hdev);
3052 static int disconnect(struct sock *sk, struct hci_dev *hdev, void *data,
3061 	bt_dev_dbg(hdev, "sock %p", sk);
3068 		return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
3072 	hci_dev_lock(hdev);
3074 	if (!test_bit(HCI_UP, &hdev->flags)) {
3075 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
3081 	if (pending_find(MGMT_OP_DISCONNECT, hdev)) {
3082 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
3088 		conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK,
3091 		conn = hci_conn_hash_lookup_le(hdev, &cp->addr.bdaddr,
3095 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
3101 	cmd = mgmt_pending_add(sk, MGMT_OP_DISCONNECT, hdev, data, len);
3114 	hci_dev_unlock(hdev);
3138 static int get_connections(struct sock *sk, struct hci_dev *hdev, void *data,
3146 	bt_dev_dbg(hdev, "sock %p", sk);
3148 	hci_dev_lock(hdev);
3150 	if (!hdev_is_powered(hdev)) {
3151 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_GET_CONNECTIONS,
3157 	list_for_each_entry(c, &hdev->conn_hash.list, list) {
3169 	list_for_each_entry(c, &hdev->conn_hash.list, list) {
3182 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CONNECTIONS, 0, rp,
3188 	hci_dev_unlock(hdev);
3192 static int send_pin_code_neg_reply(struct sock *sk, struct hci_dev *hdev,
3198 	cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_NEG_REPLY, hdev, cp,
3205 	err = hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
3213 static int pin_code_reply(struct sock *sk, struct hci_dev *hdev, void *data,
3222 	bt_dev_dbg(hdev, "sock %p", sk);
3224 	hci_dev_lock(hdev);
3226 	if (!hdev_is_powered(hdev)) {
3227 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
3232 	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->addr.bdaddr);
3234 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
3244 		bt_dev_err(hdev, "PIN code is not 16 bytes long");
3246 		err = send_pin_code_neg_reply(sk, hdev, &ncp);
3248 			err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
3254 	cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_REPLY, hdev, data, len);
3266 	err = hci_send_cmd(hdev, HCI_OP_PIN_CODE_REPLY, sizeof(reply), &reply);
3271 	hci_dev_unlock(hdev);
3275 static int set_io_capability(struct sock *sk, struct hci_dev *hdev, void *data,
3280 	bt_dev_dbg(hdev, "sock %p", sk);
3283 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_IO_CAPABILITY,
3286 	hci_dev_lock(hdev);
3288 	hdev->io_capability = cp->io_capability;
3290 	bt_dev_dbg(hdev, "IO capability set to 0x%02x", hdev->io_capability);
3292 	hci_dev_unlock(hdev);
3294 	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_IO_CAPABILITY, 0,
3300 	struct hci_dev *hdev = conn->hdev;
3303 	list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
3392 static int pair_device(struct sock *sk, struct hci_dev *hdev, void *data,
3402 	bt_dev_dbg(hdev, "sock %p", sk);
3409 		return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
3414 		return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
3418 	hci_dev_lock(hdev);
3420 	if (!hdev_is_powered(hdev)) {
3421 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
3427 	if (hci_bdaddr_is_paired(hdev, &cp->addr.bdaddr, cp->addr.type)) {
3428 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
3438 		conn = hci_connect_acl(hdev, &cp->addr.bdaddr, sec_level,
3453 		p = hci_conn_params_add(hdev, &cp->addr.bdaddr, addr_type);
3458 		conn = hci_connect_le_scan(hdev, &cp->addr.bdaddr, addr_type,
3475 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
3482 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
3487 	cmd = mgmt_pending_add(sk, MGMT_OP_PAIR_DEVICE, hdev, data, len);
3519 	hci_dev_unlock(hdev);
3523 static int cancel_pair_device(struct sock *sk, struct hci_dev *hdev, void *data,
3531 	bt_dev_dbg(hdev, "sock %p", sk);
3533 	hci_dev_lock(hdev);
3535 	if (!hdev_is_powered(hdev)) {
3536 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
3541 	cmd = pending_find(MGMT_OP_PAIR_DEVICE, hdev);
3543 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
3551 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
3559 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE, 0,
3567 		hci_remove_link_key(hdev, &addr->bdaddr);
3569 		smp_cancel_and_remove_pairing(hdev, &addr->bdaddr,
3576 	hci_dev_unlock(hdev);
3580 static int user_pairing_resp(struct sock *sk, struct hci_dev *hdev,
3588 	hci_dev_lock(hdev);
3590 	if (!hdev_is_powered(hdev)) {
3591 		err = mgmt_cmd_complete(sk, hdev->id, mgmt_op,
3598 		conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &addr->bdaddr);
3600 		conn = hci_conn_hash_lookup_le(hdev, &addr->bdaddr,
3604 		err = mgmt_cmd_complete(sk, hdev->id, mgmt_op,
3613 			err = mgmt_cmd_complete(sk, hdev->id, mgmt_op,
3617 			err = mgmt_cmd_complete(sk, hdev->id, mgmt_op,
3624 	cmd = mgmt_pending_add(sk, mgmt_op, hdev, addr, sizeof(*addr));
3638 		err = hci_send_cmd(hdev, hci_op, sizeof(cp), &cp);
3640 		err = hci_send_cmd(hdev, hci_op, sizeof(addr->bdaddr),
3647 	hci_dev_unlock(hdev);
3651 static int pin_code_neg_reply(struct sock *sk, struct hci_dev *hdev,
3656 	bt_dev_dbg(hdev, "sock %p", sk);
3658 	return user_pairing_resp(sk, hdev, &cp->addr,
3663 static int user_confirm_reply(struct sock *sk, struct hci_dev *hdev, void *data,
3668 	bt_dev_dbg(hdev, "sock %p", sk);
3671 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_USER_CONFIRM_REPLY,
3674 	return user_pairing_resp(sk, hdev, &cp->addr,
3679 static int user_confirm_neg_reply(struct sock *sk, struct hci_dev *hdev,
3684 	bt_dev_dbg(hdev, "sock %p", sk);
3686 	return user_pairing_resp(sk, hdev, &cp->addr,
3691 static int user_passkey_reply(struct sock *sk, struct hci_dev *hdev, void *data,
3696 	bt_dev_dbg(hdev, "sock %p", sk);
3698 	return user_pairing_resp(sk, hdev, &cp->addr,
3703 static int user_passkey_neg_reply(struct sock *sk, struct hci_dev *hdev,
3708 	bt_dev_dbg(hdev, "sock %p", sk);
3710 	return user_pairing_resp(sk, hdev, &cp->addr,
3715 static int adv_expire_sync(struct hci_dev *hdev, u32 flags)
3719 	adv_instance = hci_find_adv_instance(hdev, hdev->cur_adv_instance);
3727 	cancel_adv_timeout(hdev);
3729 	adv_instance = hci_get_next_instance(hdev, adv_instance->instance);
3733 	hci_schedule_adv_instance_sync(hdev, adv_instance->instance, true);
3738 static int name_changed_sync(struct hci_dev *hdev, void *data)
3740 	return adv_expire_sync(hdev, MGMT_ADV_FLAG_LOCAL_NAME);
3743 static void set_name_complete(struct hci_dev *hdev, void *data, int err)
3749 	bt_dev_dbg(hdev, "err %d", err);
3751 	if (cmd != pending_find(MGMT_OP_SET_LOCAL_NAME, hdev))
3755 		mgmt_cmd_status(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME,
3758 		mgmt_cmd_complete(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0,
3761 		if (hci_dev_test_flag(hdev, HCI_LE_ADV))
3762 			hci_cmd_sync_queue(hdev, name_changed_sync, NULL, NULL);
3768 static int set_name_sync(struct hci_dev *hdev, void *data)
3770 	if (lmp_bredr_capable(hdev)) {
3771 		hci_update_name_sync(hdev);
3772 		hci_update_eir_sync(hdev);
3778 	if (lmp_le_capable(hdev) && hci_dev_test_flag(hdev, HCI_ADVERTISING))
3779 		hci_update_scan_rsp_data_sync(hdev, hdev->cur_adv_instance);
3784 static int set_local_name(struct sock *sk, struct hci_dev *hdev, void *data,
3791 	bt_dev_dbg(hdev, "sock %p", sk);
3793 	hci_dev_lock(hdev);
3798 	if (!memcmp(hdev->dev_name, cp->name, sizeof(hdev->dev_name)) &&
3799 	    !memcmp(hdev->short_name, cp->short_name,
3800 		    sizeof(hdev->short_name))) {
3801 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0,
3806 	memcpy(hdev->short_name, cp->short_name, sizeof(hdev->short_name));
3808 	if (!hdev_is_powered(hdev)) {
3809 		memcpy(hdev->dev_name, cp->name, sizeof(hdev->dev_name));
3811 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0,
3816 		err = mgmt_limited_event(MGMT_EV_LOCAL_NAME_CHANGED, hdev, data,
3818 		ext_info_changed(hdev, sk);
3823 	cmd = mgmt_pending_add(sk, MGMT_OP_SET_LOCAL_NAME, hdev, data, len);
3827 		err = hci_cmd_sync_queue(hdev, set_name_sync, cmd,
3831 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LOCAL_NAME,
3840 	memcpy(hdev->dev_name, cp->name, sizeof(hdev->dev_name));
3843 	hci_dev_unlock(hdev);
3847 static int appearance_changed_sync(struct hci_dev *hdev, void *data)
3849 	return adv_expire_sync(hdev, MGMT_ADV_FLAG_APPEARANCE);
3852 static int set_appearance(struct sock *sk, struct hci_dev *hdev, void *data,
3859 	bt_dev_dbg(hdev, "sock %p", sk);
3861 	if (!lmp_le_capable(hdev))
3862 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_APPEARANCE,
3867 	hci_dev_lock(hdev);
3869 	if (hdev->appearance != appearance) {
3870 		hdev->appearance = appearance;
3872 		if (hci_dev_test_flag(hdev, HCI_LE_ADV))
3873 			hci_cmd_sync_queue(hdev, appearance_changed_sync, NULL,
3876 		ext_info_changed(hdev, sk);
3879 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_APPEARANCE, 0, NULL,
3882 	hci_dev_unlock(hdev);
3887 static int get_phy_configuration(struct sock *sk, struct hci_dev *hdev,
3892 	bt_dev_dbg(hdev, "sock %p", sk);
3894 	hci_dev_lock(hdev);
3898 	rp.supported_phys = cpu_to_le32(get_supported_phys(hdev));
3899 	rp.selected_phys = cpu_to_le32(get_selected_phys(hdev));
3900 	rp.configurable_phys = cpu_to_le32(get_configurable_phys(hdev));
3902 	hci_dev_unlock(hdev);
3904 	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_PHY_CONFIGURATION, 0,
3908 int mgmt_phy_configuration_changed(struct hci_dev *hdev, struct sock *skip)
3914 	ev.selected_phys = cpu_to_le32(get_selected_phys(hdev));
3916 	return mgmt_event(MGMT_EV_PHY_CONFIGURATION_CHANGED, hdev, &ev,
3920 static void set_default_phy_complete(struct hci_dev *hdev, void *data, int err)
3926 	if (cmd != pending_find(MGMT_OP_SET_PHY_CONFIGURATION, hdev))
3938 	bt_dev_dbg(hdev, "status %d", status);
3941 		mgmt_cmd_status(cmd->sk, hdev->id,
3944 		mgmt_cmd_complete(cmd->sk, hdev->id,
3948 		mgmt_phy_configuration_changed(hdev, cmd->sk);
3957 static int set_default_phy_sync(struct hci_dev *hdev, void *data)
3990 	cmd->skb =  __hci_cmd_sync(hdev, HCI_OP_LE_SET_DEFAULT_PHY,
3996 static int set_phy_configuration(struct sock *sk, struct hci_dev *hdev,
4006 	bt_dev_dbg(hdev, "sock %p", sk);
4008 	configurable_phys = get_configurable_phys(hdev);
4009 	supported_phys = get_supported_phys(hdev);
4013 		return mgmt_cmd_status(sk, hdev->id,
4020 		return mgmt_cmd_status(sk, hdev->id,
4024 	if (selected_phys == get_selected_phys(hdev))
4025 		return mgmt_cmd_complete(sk, hdev->id,
4029 	hci_dev_lock(hdev);
4031 	if (!hdev_is_powered(hdev)) {
4032 		err = mgmt_cmd_status(sk, hdev->id,
4038 	if (pending_find(MGMT_OP_SET_PHY_CONFIGURATION, hdev)) {
4039 		err = mgmt_cmd_status(sk, hdev->id,
4085 	if (pkt_type != hdev->pkt_type) {
4086 		hdev->pkt_type = pkt_type;
4091 	    (get_selected_phys(hdev) & MGMT_PHY_LE_MASK)) {
4093 			mgmt_phy_configuration_changed(hdev, sk);
4095 		err = mgmt_cmd_complete(sk, hdev->id,
4102 	cmd = mgmt_pending_add(sk, MGMT_OP_SET_PHY_CONFIGURATION, hdev, data,
4107 		err = hci_cmd_sync_queue(hdev, set_default_phy_sync, cmd,
4111 		err = mgmt_cmd_status(sk, hdev->id,
4120 	hci_dev_unlock(hdev);
4125 static int set_blocked_keys(struct sock *sk, struct hci_dev *hdev, void *data,
4135 	bt_dev_dbg(hdev, "sock %p", sk);
4139 		bt_dev_err(hdev, "too big key_count value %u", key_count);
4140 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BLOCKED_KEYS,
4146 		bt_dev_err(hdev, "expected %u bytes, got %u bytes",
4148 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BLOCKED_KEYS,
4152 	hci_dev_lock(hdev);
4154 	hci_blocked_keys_clear(hdev);
4166 		list_add_rcu(&b->list, &hdev->blocked_keys);
4168 	hci_dev_unlock(hdev);
4170 	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_BLOCKED_KEYS,
4174 static int set_wideband_speech(struct sock *sk, struct hci_dev *hdev,
4181 	bt_dev_dbg(hdev, "sock %p", sk);
4183 	if (!test_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks))
4184 		return mgmt_cmd_status(sk, hdev->id,
4189 		return mgmt_cmd_status(sk, hdev->id,
4193 	hci_dev_lock(hdev);
4195 	if (hdev_is_powered(hdev) &&
4196 	    !!cp->val != hci_dev_test_flag(hdev,
4198 		err = mgmt_cmd_status(sk, hdev->id,
4205 		changed = !hci_dev_test_and_set_flag(hdev,
4208 		changed = hci_dev_test_and_clear_flag(hdev,
4211 	err = send_settings_rsp(sk, MGMT_OP_SET_WIDEBAND_SPEECH, hdev);
4216 		err = new_settings(hdev, sk);
4219 	hci_dev_unlock(hdev);
4223 static int read_controller_cap(struct sock *sk, struct hci_dev *hdev,
4232 	bt_dev_dbg(hdev, "sock %p", sk);
4236 	hci_dev_lock(hdev);
4244 	if ((hdev->commands[41] & 0x08) || msft_curve_validity(hdev))
4252 	if (hdev->commands[20] & 0x10)
4263 	if (hdev->commands[41] & 0x08)
4266 					  hdev->max_enc_key_size);
4275 	if (hdev->commands[38] & 0x80) {
4276 		memcpy(&tx_power_range[0], &hdev->min_le_tx_power, 1);
4277 		memcpy(&tx_power_range[1], &hdev->max_le_tx_power, 1);
4284 	hci_dev_unlock(hdev);
4286 	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_CONTROLLER_CAP, 0,
4334 static int read_exp_features_info(struct sock *sk, struct hci_dev *hdev,
4343 	bt_dev_dbg(hdev, "sock %p", sk);
4352 	if (!hdev) {
4361 	if (hdev && hci_dev_le_state_simultaneous(hdev)) {
4362 		if (hci_dev_test_flag(hdev, HCI_LE_SIMULTANEOUS_ROLES))
4372 	if (hdev && ll_privacy_capable(hdev)) {
4373 		if (hci_dev_test_flag(hdev, HCI_ENABLE_LL_PRIVACY))
4383 	if (hdev && (aosp_has_quality_report(hdev) ||
4384 		     hdev->set_quality_report)) {
4385 		if (hci_dev_test_flag(hdev, HCI_QUALITY_REPORT))
4395 	if (hdev && hdev->get_data_path_id) {
4396 		if (hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED))
4413 	if (hdev && lmp_le_capable(hdev)) {
4414 		if (hci_dev_test_flag(hdev, HCI_MESH_EXPERIMENTAL))
4431 	status = mgmt_cmd_complete(sk, hdev ? hdev->id : MGMT_INDEX_NONE,
4439 static int exp_ll_privacy_feature_changed(bool enabled, struct hci_dev *hdev,
4449 	if (enabled && privacy_mode_capable(hdev))
4450 		hdev->conn_flags |= HCI_CONN_FLAG_DEVICE_PRIVACY;
4452 		hdev->conn_flags &= ~HCI_CONN_FLAG_DEVICE_PRIVACY;
4454 	return mgmt_limited_event(MGMT_EV_EXP_FEATURE_CHANGED, hdev,
4460 static int exp_feature_changed(struct hci_dev *hdev, const u8 *uuid,
4469 	return mgmt_limited_event(MGMT_EV_EXP_FEATURE_CHANGED, hdev,
4481 static int set_zero_key_func(struct sock *sk, struct hci_dev *hdev,
4490 	if (!hdev) {
4500 	if (hdev && use_ll_privacy(hdev) && !hdev_is_powered(hdev)) {
4503 		changed = hci_dev_test_and_clear_flag(hdev,
4506 			exp_feature_changed(hdev, rpa_resolution_uuid, false,
4512 	return mgmt_cmd_complete(sk, hdev ? hdev->id : MGMT_INDEX_NONE,
4518 static int set_debug_func(struct sock *sk, struct hci_dev *hdev,
4527 	if (hdev)
4528 		return mgmt_cmd_status(sk, hdev->id,
4558 		exp_feature_changed(hdev, debug_uuid, val, sk);
4564 static int set_mgmt_mesh_func(struct sock *sk, struct hci_dev *hdev,
4572 	if (!hdev)
4579 		return mgmt_cmd_status(sk, hdev->id,
4585 		return mgmt_cmd_status(sk, hdev->id,
4592 		changed = !hci_dev_test_and_set_flag(hdev,
4595 		hci_dev_clear_flag(hdev, HCI_MESH);
4596 		changed = hci_dev_test_and_clear_flag(hdev,
4605 	err = mgmt_cmd_complete(sk, hdev->id,
4610 		exp_feature_changed(hdev, mgmt_mesh_uuid, val, sk);
4615 static int set_rpa_resolution_func(struct sock *sk, struct hci_dev *hdev,
4625 	if (!hdev)
4631 	if (hdev_is_powered(hdev))
4632 		return mgmt_cmd_status(sk, hdev->id,
4638 		return mgmt_cmd_status(sk, hdev->id,
4644 		return mgmt_cmd_status(sk, hdev->id,
4651 		changed = !hci_dev_test_and_set_flag(hdev,
4653 		hci_dev_clear_flag(hdev, HCI_ADVERTISING);
4658 		changed = hci_dev_test_and_clear_flag(hdev,
4670 	err = mgmt_cmd_complete(sk, hdev->id,
4675 		exp_ll_privacy_feature_changed(val, hdev, sk);
4680 static int set_quality_report_func(struct sock *sk, struct hci_dev *hdev,
4689 	if (!hdev)
4696 		return mgmt_cmd_status(sk, hdev->id,
4702 		return mgmt_cmd_status(sk, hdev->id,
4706 	hci_req_sync_lock(hdev);
4709 	changed = (val != hci_dev_test_flag(hdev, HCI_QUALITY_REPORT));
4711 	if (!aosp_has_quality_report(hdev) && !hdev->set_quality_report) {
4712 		err = mgmt_cmd_status(sk, hdev->id,
4719 		if (hdev->set_quality_report)
4720 			err = hdev->set_quality_report(hdev, val);
4722 			err = aosp_set_quality_report(hdev, val);
4725 			err = mgmt_cmd_status(sk, hdev->id,
4732 			hci_dev_set_flag(hdev, HCI_QUALITY_REPORT);
4734 			hci_dev_clear_flag(hdev, HCI_QUALITY_REPORT);
4737 	bt_dev_dbg(hdev, "quality report enable %d changed %d", val, changed);
4743 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_EXP_FEATURE, 0,
4747 		exp_feature_changed(hdev, quality_report_uuid, val, sk);
4750 	hci_req_sync_unlock(hdev);
4754 static int set_offload_codec_func(struct sock *sk, struct hci_dev *hdev,
4763 	if (!hdev)
4770 		return mgmt_cmd_status(sk, hdev->id,
4776 		return mgmt_cmd_status(sk, hdev->id,
4781 	changed = (val != hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED));
4783 	if (!hdev->get_data_path_id) {
4784 		return mgmt_cmd_status(sk, hdev->id,
4791 			hci_dev_set_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED);
4793 			hci_dev_clear_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED);
4796 	bt_dev_info(hdev, "offload codecs enable %d changed %d",
4802 	err = mgmt_cmd_complete(sk, hdev->id,
4807 		exp_feature_changed(hdev, offload_codecs_uuid, val, sk);
4812 static int set_le_simultaneous_roles_func(struct sock *sk, struct hci_dev *hdev,
4821 	if (!hdev)
4828 		return mgmt_cmd_status(sk, hdev->id,
4834 		return mgmt_cmd_status(sk, hdev->id,
4839 	changed = (val != hci_dev_test_flag(hdev, HCI_LE_SIMULTANEOUS_ROLES));
4841 	if (!hci_dev_le_state_simultaneous(hdev)) {
4842 		return mgmt_cmd_status(sk, hdev->id,
4849 			hci_dev_set_flag(hdev, HCI_LE_SIMULTANEOUS_ROLES);
4851 			hci_dev_clear_flag(hdev, HCI_LE_SIMULTANEOUS_ROLES);
4854 	bt_dev_info(hdev, "LE simultaneous roles enable %d changed %d",
4860 	err = mgmt_cmd_complete(sk, hdev->id,
4865 		exp_feature_changed(hdev, le_simultaneous_roles_uuid, val, sk);
4871 static int set_iso_socket_func(struct sock *sk, struct hci_dev *hdev,
4879 	if (hdev)
4880 		return mgmt_cmd_status(sk, hdev->id,
4915 		exp_feature_changed(hdev, iso_socket_uuid, val, sk);
4923 	int (*set_func)(struct sock *sk, struct hci_dev *hdev,
4943 static int set_exp_feature(struct sock *sk, struct hci_dev *hdev,
4949 	bt_dev_dbg(hdev, "sock %p", sk);
4953 			return exp_features[i].set_func(sk, hdev, cp, data_len);
4956 	return mgmt_cmd_status(sk, hdev ? hdev->id : MGMT_INDEX_NONE,
4961 static u32 get_params_flags(struct hci_dev *hdev,
4964 	u32 flags = hdev->conn_flags;
4970 	if ((flags & HCI_CONN_FLAG_REMOTE_WAKEUP) && !use_ll_privacy(hdev) &&
4971 	    hci_find_irk_by_addr(hdev, &params->addr, params->addr_type))
4977 static int get_device_flags(struct sock *sk, struct hci_dev *hdev, void *data,
4988 	bt_dev_dbg(hdev, "Get device flags %pMR (type 0x%x)\n",
4991 	hci_dev_lock(hdev);
4993 	supported_flags = hdev->conn_flags;
4998 		br_params = hci_bdaddr_list_lookup_with_flags(&hdev->accept_list,
5006 		params = hci_conn_params_lookup(hdev, &cp->addr.bdaddr,
5011 		supported_flags = get_params_flags(hdev, params);
5023 	hci_dev_unlock(hdev);
5025 	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_DEVICE_FLAGS, status,
5029 static void device_flags_changed(struct sock *sk, struct hci_dev *hdev,
5040 	mgmt_event(MGMT_EV_DEVICE_FLAGS_CHANGED, hdev, &ev, sizeof(ev), sk);
5043 static int set_device_flags(struct sock *sk, struct hci_dev *hdev, void *data,
5053 	bt_dev_dbg(hdev, "Set device flags %pMR (type 0x%x) = 0x%x",
5057 	supported_flags = hdev->conn_flags;
5060 		bt_dev_warn(hdev, "Bad flag given (0x%x) vs supported (0x%0x)",
5065 	hci_dev_lock(hdev);
5068 		br_params = hci_bdaddr_list_lookup_with_flags(&hdev->accept_list,
5076 			bt_dev_warn(hdev, "No such BR/EDR device %pMR (0x%x)",
5083 	params = hci_conn_params_lookup(hdev, &cp->addr.bdaddr,
5086 		bt_dev_warn(hdev, "No such LE device %pMR (0x%x)",
5091 	supported_flags = get_params_flags(hdev, params);
5094 		bt_dev_warn(hdev, "Bad flag given (0x%x) vs supported (0x%0x)",
5106 		hci_update_passive_scan(hdev);
5109 	hci_dev_unlock(hdev);
5113 		device_flags_changed(sk, hdev, &cp->addr.bdaddr, cp->addr.type,
5116 	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_DEVICE_FLAGS, status,
5120 static void mgmt_adv_monitor_added(struct sock *sk, struct hci_dev *hdev,
5127 	mgmt_event(MGMT_EV_ADV_MONITOR_ADDED, hdev, &ev, sizeof(ev), sk);
5130 void mgmt_adv_monitor_removed(struct hci_dev *hdev, u16 handle)
5137 	cmd = pending_find(MGMT_OP_REMOVE_ADV_MONITOR, hdev);
5147 	mgmt_event(MGMT_EV_ADV_MONITOR_REMOVED, hdev, &ev, sizeof(ev), sk_skip);
5150 static int read_adv_mon_features(struct sock *sk, struct hci_dev *hdev,
5162 	BT_DBG("request for %s", hdev->name);
5164 	hci_dev_lock(hdev);
5166 	if (msft_monitor_supported(hdev))
5169 	idr_for_each_entry(&hdev->adv_monitors_idr, monitor, handle)
5172 	hci_dev_unlock(hdev);
5190 	err = mgmt_cmd_complete(sk, hdev->id,
5199 static void mgmt_add_adv_patterns_monitor_complete(struct hci_dev *hdev,
5206 	hci_dev_lock(hdev);
5211 		mgmt_adv_monitor_added(cmd->sk, hdev, monitor->handle);
5212 		hdev->adv_monitors_cnt++;
5215 		hci_update_passive_scan(hdev);
5222 	hci_dev_unlock(hdev);
5223 	bt_dev_dbg(hdev, "add monitor %d complete, status %d",
5227 static int mgmt_add_adv_patterns_monitor_sync(struct hci_dev *hdev, void *data)
5232 	return hci_add_adv_monitor(hdev, monitor);
5235 static int __add_adv_patterns_monitor(struct sock *sk, struct hci_dev *hdev,
5242 	hci_dev_lock(hdev);
5247 	if (pending_find(MGMT_OP_SET_LE, hdev) ||
5248 	    pending_find(MGMT_OP_ADD_ADV_PATTERNS_MONITOR, hdev) ||
5249 	    pending_find(MGMT_OP_ADD_ADV_PATTERNS_MONITOR_RSSI, hdev) ||
5250 	    pending_find(MGMT_OP_REMOVE_ADV_MONITOR, hdev)) {
5255 	cmd = mgmt_pending_add(sk, op, hdev, data, len);
5262 	err = hci_cmd_sync_queue(hdev, mgmt_add_adv_patterns_monitor_sync, cmd,
5273 	hci_dev_unlock(hdev);
5278 	hci_free_adv_monitor(hdev, m);
5279 	hci_dev_unlock(hdev);
5280 	return mgmt_cmd_status(sk, hdev->id, op, status);
5339 static int add_adv_patterns_monitor(struct sock *sk, struct hci_dev *hdev,
5347 	BT_DBG("request for %s", hdev->name);
5372 	return __add_adv_patterns_monitor(sk, hdev, m, status, data, len,
5376 static int add_adv_patterns_monitor_rssi(struct sock *sk, struct hci_dev *hdev,
5384 	BT_DBG("request for %s", hdev->name);
5409 	return __add_adv_patterns_monitor(sk, hdev, m, status, data, len,
5413 static void mgmt_remove_adv_monitor_complete(struct hci_dev *hdev,
5420 	hci_dev_lock(hdev);
5425 		hci_update_passive_scan(hdev);
5431 	hci_dev_unlock(hdev);
5432 	bt_dev_dbg(hdev, "remove monitor %d complete, status %d",
5436 static int mgmt_remove_adv_monitor_sync(struct hci_dev *hdev, void *data)
5443 		return hci_remove_all_adv_monitor(hdev);
5445 	return hci_remove_single_adv_monitor(hdev, handle);
5448 static int remove_adv_monitor(struct sock *sk, struct hci_dev *hdev,
5454 	hci_dev_lock(hdev);
5456 	if (pending_find(MGMT_OP_SET_LE, hdev) ||
5457 	    pending_find(MGMT_OP_REMOVE_ADV_MONITOR, hdev) ||
5458 	    pending_find(MGMT_OP_ADD_ADV_PATTERNS_MONITOR, hdev) ||
5459 	    pending_find(MGMT_OP_ADD_ADV_PATTERNS_MONITOR_RSSI, hdev)) {
5464 	cmd = mgmt_pending_add(sk, MGMT_OP_REMOVE_ADV_MONITOR, hdev, data, len);
5470 	err = hci_cmd_sync_queue(hdev, mgmt_remove_adv_monitor_sync, cmd,
5484 	hci_dev_unlock(hdev);
5489 	hci_dev_unlock(hdev);
5490 	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_REMOVE_ADV_MONITOR,
5494 static void read_local_oob_data_complete(struct hci_dev *hdev, void *data, int err)
5511 	bt_dev_dbg(hdev, "status %d", status);
5514 		mgmt_cmd_status(cmd->sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA, status);
5520 	if (!bredr_sc_enabled(hdev)) {
5524 			mgmt_cmd_status(cmd->sk, hdev->id,
5538 			mgmt_cmd_status(cmd->sk, hdev->id,
5551 	mgmt_cmd_complete(cmd->sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
5561 static int read_local_oob_data_sync(struct hci_dev *hdev, void *data)
5565 	if (bredr_sc_enabled(hdev))
5566 		cmd->skb = hci_read_local_oob_data_sync(hdev, true, cmd->sk);
5568 		cmd->skb = hci_read_local_oob_data_sync(hdev, false, cmd->sk);
5576 static int read_local_oob_data(struct sock *sk, struct hci_dev *hdev,
5582 	bt_dev_dbg(hdev, "sock %p", sk);
5584 	hci_dev_lock(hdev);
5586 	if (!hdev_is_powered(hdev)) {
5587 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
5592 	if (!lmp_ssp_capable(hdev)) {
5593 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
5598 	cmd = mgmt_pending_new(sk, MGMT_OP_READ_LOCAL_OOB_DATA, hdev, NULL, 0);
5602 		err = hci_cmd_sync_queue(hdev, read_local_oob_data_sync, cmd,
5606 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
5614 	hci_dev_unlock(hdev);
5618 static int add_remote_oob_data(struct sock *sk, struct hci_dev *hdev,
5624 	bt_dev_dbg(hdev, "sock %p", sk);
5627 		return mgmt_cmd_complete(sk, hdev->id,
5632 	hci_dev_lock(hdev);
5639 			err = mgmt_cmd_complete(sk, hdev->id,
5646 		err = hci_add_remote_oob_data(hdev, &cp->addr.bdaddr,
5654 		err = mgmt_cmd_complete(sk, hdev->id,
5668 				err = mgmt_cmd_complete(sk, hdev->id,
5703 		err = hci_add_remote_oob_data(hdev, &cp->addr.bdaddr,
5711 		err = mgmt_cmd_complete(sk, hdev->id,
5715 		bt_dev_err(hdev, "add_remote_oob_data: invalid len of %u bytes",
5717 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_REMOTE_OOB_DATA,
5722 	hci_dev_unlock(hdev);
5726 static int remove_remote_oob_data(struct sock *sk, struct hci_dev *hdev,
5733 	bt_dev_dbg(hdev, "sock %p", sk);
5736 		return mgmt_cmd_complete(sk, hdev->id,
5741 	hci_dev_lock(hdev);
5744 		hci_remote_oob_data_clear(hdev);
5749 	err = hci_remove_remote_oob_data(hdev, &cp->addr.bdaddr, cp->addr.type);
5756 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
5759 	hci_dev_unlock(hdev);
5763 void mgmt_start_discovery_complete(struct hci_dev *hdev, u8 status)
5767 	bt_dev_dbg(hdev, "status %u", status);
5769 	hci_dev_lock(hdev);
5771 	cmd = pending_find(MGMT_OP_START_DISCOVERY, hdev);
5773 		cmd = pending_find(MGMT_OP_START_SERVICE_DISCOVERY, hdev);
5776 		cmd = pending_find(MGMT_OP_START_LIMITED_DISCOVERY, hdev);
5783 	hci_dev_unlock(hdev);
5786 static bool discovery_type_is_valid(struct hci_dev *hdev, uint8_t type,
5791 		*mgmt_status = mgmt_le_support(hdev);
5796 		*mgmt_status = mgmt_le_support(hdev);
5801 		*mgmt_status = mgmt_bredr_support(hdev);
5813 static void start_discovery_complete(struct hci_dev *hdev, void *data, int err)
5817 	if (cmd != pending_find(MGMT_OP_START_DISCOVERY, hdev) &&
5818 	    cmd != pending_find(MGMT_OP_START_LIMITED_DISCOVERY, hdev) &&
5819 	    cmd != pending_find(MGMT_OP_START_SERVICE_DISCOVERY, hdev))
5822 	bt_dev_dbg(hdev, "err %d", err);
5828 	hci_discovery_set_state(hdev, err ? DISCOVERY_STOPPED:
5832 static int start_discovery_sync(struct hci_dev *hdev, void *data)
5834 	return hci_start_discovery_sync(hdev);
5837 static int start_discovery_internal(struct sock *sk, struct hci_dev *hdev,
5845 	bt_dev_dbg(hdev, "sock %p", sk);
5847 	hci_dev_lock(hdev);
5849 	if (!hdev_is_powered(hdev)) {
5850 		err = mgmt_cmd_complete(sk, hdev->id, op,
5856 	if (hdev->discovery.state != DISCOVERY_STOPPED ||
5857 	    hci_dev_test_flag(hdev, HCI_PERIODIC_INQ)) {
5858 		err = mgmt_cmd_complete(sk, hdev->id, op, MGMT_STATUS_BUSY,
5863 	if (!discovery_type_is_valid(hdev, cp->type, &status)) {
5864 		err = mgmt_cmd_complete(sk, hdev->id, op, status,
5870 	if (hdev->discovery_paused) {
5871 		err = mgmt_cmd_complete(sk, hdev->id, op, MGMT_STATUS_BUSY,
5879 	hci_discovery_filter_clear(hdev);
5881 	hdev->discovery.type = cp->type;
5882 	hdev->discovery.report_invalid_rssi = false;
5884 		hdev->discovery.limited = true;
5886 		hdev->discovery.limited = false;
5888 	cmd = mgmt_pending_add(sk, op, hdev, data, len);
5894 	err = hci_cmd_sync_queue(hdev, start_discovery_sync, cmd,
5901 	hci_discovery_set_state(hdev, DISCOVERY_STARTING);
5904 	hci_dev_unlock(hdev);
5908 static int start_discovery(struct sock *sk, struct hci_dev *hdev,
5911 	return start_discovery_internal(sk, hdev, MGMT_OP_START_DISCOVERY,
5915 static int start_limited_discovery(struct sock *sk, struct hci_dev *hdev,
5918 	return start_discovery_internal(sk, hdev,
5923 static int start_service_discovery(struct sock *sk, struct hci_dev *hdev,
5933 	bt_dev_dbg(hdev, "sock %p", sk);
5935 	hci_dev_lock(hdev);
5937 	if (!hdev_is_powered(hdev)) {
5938 		err = mgmt_cmd_complete(sk, hdev->id,
5945 	if (hdev->discovery.state != DISCOVERY_STOPPED ||
5946 	    hci_dev_test_flag(hdev, HCI_PERIODIC_INQ)) {
5947 		err = mgmt_cmd_complete(sk, hdev->id,
5954 	if (hdev->discovery_paused) {
5955 		err = mgmt_cmd_complete(sk, hdev->id,
5964 		bt_dev_err(hdev, "service_discovery: too big uuid_count value %u",
5966 		err = mgmt_cmd_complete(sk, hdev->id,
5975 		bt_dev_err(hdev, "service_discovery: expected %u bytes, got %u bytes",
5977 		err = mgmt_cmd_complete(sk, hdev->id,
5984 	if (!discovery_type_is_valid(hdev, cp->type, &status)) {
5985 		err = mgmt_cmd_complete(sk, hdev->id,
5992 			       hdev, data, len);
6001 	hci_discovery_filter_clear(hdev);
6003 	hdev->discovery.result_filtering = true;
6004 	hdev->discovery.type = cp->type;
6005 	hdev->discovery.rssi = cp->rssi;
6006 	hdev->discovery.uuid_count = uuid_count;
6009 		hdev->discovery.uuids = kmemdup(cp->uuids, uuid_count * 16,
6011 		if (!hdev->discovery.uuids) {
6012 			err = mgmt_cmd_complete(sk, hdev->id,
6021 	err = hci_cmd_sync_queue(hdev, start_discovery_sync, cmd,
6028 	hci_discovery_set_state(hdev, DISCOVERY_STARTING);
6031 	hci_dev_unlock(hdev);
6035 void mgmt_stop_discovery_complete(struct hci_dev *hdev, u8 status)
6039 	bt_dev_dbg(hdev, "status %u", status);
6041 	hci_dev_lock(hdev);
6043 	cmd = pending_find(MGMT_OP_STOP_DISCOVERY, hdev);
6049 	hci_dev_unlock(hdev);
6052 static void stop_discovery_complete(struct hci_dev *hdev, void *data, int err)
6056 	if (cmd != pending_find(MGMT_OP_STOP_DISCOVERY, hdev))
6059 	bt_dev_dbg(hdev, "err %d", err);
6066 		hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
6069 static int stop_discovery_sync(struct hci_dev *hdev, void *data)
6071 	return hci_stop_discovery_sync(hdev);
6074 static int stop_discovery(struct sock *sk, struct hci_dev *hdev, void *data,
6081 	bt_dev_dbg(hdev, "sock %p", sk);
6083 	hci_dev_lock(hdev);
6085 	if (!hci_discovery_active(hdev)) {
6086 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_STOP_DISCOVERY,
6092 	if (hdev->discovery.type != mgmt_cp->type) {
6093 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_STOP_DISCOVERY,
6099 	cmd = mgmt_pending_add(sk, MGMT_OP_STOP_DISCOVERY, hdev, data, len);
6105 	err = hci_cmd_sync_queue(hdev, stop_discovery_sync, cmd,
6112 	hci_discovery_set_state(hdev, DISCOVERY_STOPPING);
6115 	hci_dev_unlock(hdev);
6119 static int confirm_name(struct sock *sk, struct hci_dev *hdev, void *data,
6126 	bt_dev_dbg(hdev, "sock %p", sk);
6128 	hci_dev_lock(hdev);
6130 	if (!hci_discovery_active(hdev)) {
6131 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_CONFIRM_NAME,
6137 	e = hci_inquiry_cache_lookup_unknown(hdev, &cp->addr.bdaddr);
6139 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_CONFIRM_NAME,
6150 		hci_inquiry_cache_update_resolve(hdev, e);
6153 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_CONFIRM_NAME, 0,
6157 	hci_dev_unlock(hdev);
6161 static int block_device(struct sock *sk, struct hci_dev *hdev, void *data,
6168 	bt_dev_dbg(hdev, "sock %p", sk);
6171 		return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_BLOCK_DEVICE,
6175 	hci_dev_lock(hdev);
6177 	err = hci_bdaddr_list_add(&hdev->reject_list, &cp->addr.bdaddr,
6184 	mgmt_event(MGMT_EV_DEVICE_BLOCKED, hdev, &cp->addr, sizeof(cp->addr),
6189 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_BLOCK_DEVICE, status,
6192 	hci_dev_unlock(hdev);
6197 static int unblock_device(struct sock *sk, struct hci_dev *hdev, void *data,
6204 	bt_dev_dbg(hdev, "sock %p", sk);
6207 		return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNBLOCK_DEVICE,
6211 	hci_dev_lock(hdev);
6213 	err = hci_bdaddr_list_del(&hdev->reject_list, &cp->addr.bdaddr,
6220 	mgmt_event(MGMT_EV_DEVICE_UNBLOCKED, hdev, &cp->addr, sizeof(cp->addr),
6225 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNBLOCK_DEVICE, status,
6228 	hci_dev_unlock(hdev);
6233 static int set_device_id_sync(struct hci_dev *hdev, void *data)
6235 	return hci_update_eir_sync(hdev);
6238 static int set_device_id(struct sock *sk, struct hci_dev *hdev, void *data,
6245 	bt_dev_dbg(hdev, "sock %p", sk);
6250 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DEVICE_ID,
6253 	hci_dev_lock(hdev);
6255 	hdev->devid_source = source;
6256 	hdev->devid_vendor = __le16_to_cpu(cp->vendor);
6257 	hdev->devid_product = __le16_to_cpu(cp->product);
6258 	hdev->devid_version = __le16_to_cpu(cp->version);
6260 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_DEVICE_ID, 0,
6263 	hci_cmd_sync_queue(hdev, set_device_id_sync, NULL, NULL);
6265 	hci_dev_unlock(hdev);
6270 static void enable_advertising_instance(struct hci_dev *hdev, int err)
6273 		bt_dev_err(hdev, "failed to re-configure advertising %d", err);
6275 		bt_dev_dbg(hdev, "status %d", err);
6278 static void set_advertising_complete(struct hci_dev *hdev, void *data, int err)
6280 	struct cmd_lookup match = { NULL, hdev };
6286 		mgmt_pending_foreach(MGMT_OP_SET_ADVERTISING, hdev,
6291 	if (hci_dev_test_flag(hdev, HCI_LE_ADV))
6292 		hci_dev_set_flag(hdev, HCI_ADVERTISING);
6294 		hci_dev_clear_flag(hdev, HCI_ADVERTISING);
6296 	mgmt_pending_foreach(MGMT_OP_SET_ADVERTISING, hdev, settings_rsp,
6299 	new_settings(hdev, match.sk);
6307 	if (hci_dev_test_flag(hdev, HCI_ADVERTISING) ||
6308 	    list_empty(&hdev->adv_instances))
6311 	instance = hdev->cur_adv_instance;
6313 		adv_instance = list_first_entry_or_null(&hdev->adv_instances,
6321 	err = hci_schedule_adv_instance_sync(hdev, instance, true);
6323 	enable_advertising_instance(hdev, err);
6326 static int set_adv_sync(struct hci_dev *hdev, void *data)
6333 		hci_dev_set_flag(hdev, HCI_ADVERTISING_CONNECTABLE);
6335 		hci_dev_clear_flag(hdev, HCI_ADVERTISING_CONNECTABLE);
6337 	cancel_adv_timeout(hdev);
6344 		hdev->cur_adv_instance = 0x00;
6346 		if (ext_adv_capable(hdev)) {
6347 			hci_start_ext_adv_sync(hdev, 0x00);
6349 			hci_update_adv_data_sync(hdev, 0x00);
6350 			hci_update_scan_rsp_data_sync(hdev, 0x00);
6351 			hci_enable_advertising_sync(hdev);
6354 		hci_disable_advertising_sync(hdev);
6360 static int set_advertising(struct sock *sk, struct hci_dev *hdev, void *data,
6368 	bt_dev_dbg(hdev, "sock %p", sk);
6370 	status = mgmt_le_support(hdev);
6372 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
6376 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
6379 	if (hdev->advertising_paused)
6380 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
6383 	hci_dev_lock(hdev);
6392 	if (!hdev_is_powered(hdev) ||
6393 	    (val == hci_dev_test_flag(hdev, HCI_ADVERTISING) &&
6394 	     (cp->val == 0x02) == hci_dev_test_flag(hdev, HCI_ADVERTISING_CONNECTABLE)) ||
6395 	    hci_dev_test_flag(hdev, HCI_MESH) ||
6396 	    hci_conn_num(hdev, LE_LINK) > 0 ||
6397 	    (hci_dev_test_flag(hdev, HCI_LE_SCAN) &&
6398 	     hdev->le_scan_type == LE_SCAN_ACTIVE)) {
6402 			hdev->cur_adv_instance = 0x00;
6403 			changed = !hci_dev_test_and_set_flag(hdev, HCI_ADVERTISING);
6405 				hci_dev_set_flag(hdev, HCI_ADVERTISING_CONNECTABLE);
6407 				hci_dev_clear_flag(hdev, HCI_ADVERTISING_CONNECTABLE);
6409 			changed = hci_dev_test_and_clear_flag(hdev, HCI_ADVERTISING);
6410 			hci_dev_clear_flag(hdev, HCI_ADVERTISING_CONNECTABLE);
6413 		err = send_settings_rsp(sk, MGMT_OP_SET_ADVERTISING, hdev);
6418 			err = new_settings(hdev, sk);
6423 	if (pending_find(MGMT_OP_SET_ADVERTISING, hdev) ||
6424 	    pending_find(MGMT_OP_SET_LE, hdev)) {
6425 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
6430 	cmd = mgmt_pending_add(sk, MGMT_OP_SET_ADVERTISING, hdev, data, len);
6434 		err = hci_cmd_sync_queue(hdev, set_adv_sync, cmd,
6441 	hci_dev_unlock(hdev);
6445 static int set_static_address(struct sock *sk, struct hci_dev *hdev,
6451 	bt_dev_dbg(hdev, "sock %p", sk);
6453 	if (!lmp_le_capable(hdev))
6454 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_STATIC_ADDRESS,
6457 	if (hdev_is_powered(hdev))
6458 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_STATIC_ADDRESS,
6463 			return mgmt_cmd_status(sk, hdev->id,
6469 			return mgmt_cmd_status(sk, hdev->id,
6474 	hci_dev_lock(hdev);
6476 	bacpy(&hdev->static_addr, &cp->bdaddr);
6478 	err = send_settings_rsp(sk, MGMT_OP_SET_STATIC_ADDRESS, hdev);
6482 	err = new_settings(hdev, sk);
6485 	hci_dev_unlock(hdev);
6489 static int set_scan_params(struct sock *sk, struct hci_dev *hdev,
6496 	bt_dev_dbg(hdev, "sock %p", sk);
6498 	if (!lmp_le_capable(hdev))
6499 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SCAN_PARAMS,
6505 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SCAN_PARAMS,
6511 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SCAN_PARAMS,
6515 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SCAN_PARAMS,
6518 	hci_dev_lock(hdev);
6520 	hdev->le_scan_interval = interval;
6521 	hdev->le_scan_window = window;
6523 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_SCAN_PARAMS, 0,
6529 	if (hci_dev_test_flag(hdev, HCI_LE_SCAN) &&
6530 	    hdev->discovery.state == DISCOVERY_STOPPED)
6531 		hci_update_passive_scan(hdev);
6533 	hci_dev_unlock(hdev);
6538 static void fast_connectable_complete(struct hci_dev *hdev, void *data, int err)
6542 	bt_dev_dbg(hdev, "err %d", err);
6545 		mgmt_cmd_status(cmd->sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
6551 			hci_dev_set_flag(hdev, HCI_FAST_CONNECTABLE);
6553 			hci_dev_clear_flag(hdev, HCI_FAST_CONNECTABLE);
6555 		send_settings_rsp(cmd->sk, MGMT_OP_SET_FAST_CONNECTABLE, hdev);
6556 		new_settings(hdev, cmd->sk);
6562 static int write_fast_connectable_sync(struct hci_dev *hdev, void *data)
6567 	return hci_write_fast_connectable_sync(hdev, cp->val);
6570 static int set_fast_connectable(struct sock *sk, struct hci_dev *hdev,
6577 	bt_dev_dbg(hdev, "sock %p", sk);
6579 	if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) ||
6580 	    hdev->hci_ver < BLUETOOTH_VER_1_2)
6581 		return mgmt_cmd_status(sk, hdev->id,
6586 		return mgmt_cmd_status(sk, hdev->id,
6590 	hci_dev_lock(hdev);
6592 	if (!!cp->val == hci_dev_test_flag(hdev, HCI_FAST_CONNECTABLE)) {
6593 		err = send_settings_rsp(sk, MGMT_OP_SET_FAST_CONNECTABLE, hdev);
6597 	if (!hdev_is_powered(hdev)) {
6598 		hci_dev_change_flag(hdev, HCI_FAST_CONNECTABLE);
6599 		err = send_settings_rsp(sk, MGMT_OP_SET_FAST_CONNECTABLE, hdev);
6600 		new_settings(hdev, sk);
6604 	cmd = mgmt_pending_new(sk, MGMT_OP_SET_FAST_CONNECTABLE, hdev, data,
6609 		err = hci_cmd_sync_queue(hdev, write_fast_connectable_sync, cmd,
6613 		mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
6621 	hci_dev_unlock(hdev);
6626 static void set_bredr_complete(struct hci_dev *hdev, void *data, int err)
6630 	bt_dev_dbg(hdev, "err %d", err);
6638 		hci_dev_clear_flag(hdev, HCI_BREDR_ENABLED);
6642 		send_settings_rsp(cmd->sk, MGMT_OP_SET_BREDR, hdev);
6643 		new_settings(hdev, cmd->sk);
6649 static int set_bredr_sync(struct hci_dev *hdev, void *data)
6653 	status = hci_write_fast_connectable_sync(hdev, false);
6656 		status = hci_update_scan_sync(hdev);
6662 		status = hci_update_adv_data_sync(hdev, hdev->cur_adv_instance);
6667 static int set_bredr(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
6673 	bt_dev_dbg(hdev, "sock %p", sk);
6675 	if (!lmp_bredr_capable(hdev) || !lmp_le_capable(hdev))
6676 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
6679 	if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED))
6680 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
6684 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
6687 	hci_dev_lock(hdev);
6689 	if (cp->val == hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) {
6690 		err = send_settings_rsp(sk, MGMT_OP_SET_BREDR, hdev);
6694 	if (!hdev_is_powered(hdev)) {
6696 			hci_dev_clear_flag(hdev, HCI_DISCOVERABLE);
6697 			hci_dev_clear_flag(hdev, HCI_SSP_ENABLED);
6698 			hci_dev_clear_flag(hdev, HCI_LINK_SECURITY);
6699 			hci_dev_clear_flag(hdev, HCI_FAST_CONNECTABLE);
6702 		hci_dev_change_flag(hdev, HCI_BREDR_ENABLED);
6704 		err = send_settings_rsp(sk, MGMT_OP_SET_BREDR, hdev);
6708 		err = new_settings(hdev, sk);
6714 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
6732 		if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) &&
6733 		    (bacmp(&hdev->static_addr, BDADDR_ANY) ||
6734 		     hci_dev_test_flag(hdev, HCI_SC_ENABLED))) {
6735 			err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
6741 	cmd = mgmt_pending_new(sk, MGMT_OP_SET_BREDR, hdev, data, len);
6745 		err = hci_cmd_sync_queue(hdev, set_bredr_sync, cmd,
6749 		mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
6760 	hci_dev_set_flag(hdev, HCI_BREDR_ENABLED);
6763 	hci_dev_unlock(hdev);
6767 static void set_secure_conn_complete(struct hci_dev *hdev, void *data, int err)
6772 	bt_dev_dbg(hdev, "err %d", err);
6785 		hci_dev_clear_flag(hdev, HCI_SC_ENABLED);
6786 		hci_dev_clear_flag(hdev, HCI_SC_ONLY);
6789 		hci_dev_set_flag(hdev, HCI_SC_ENABLED);
6790 		hci_dev_clear_flag(hdev, HCI_SC_ONLY);
6793 		hci_dev_set_flag(hdev, HCI_SC_ENABLED);
6794 		hci_dev_set_flag(hdev, HCI_SC_ONLY);
6798 	send_settings_rsp(cmd->sk, cmd->opcode, hdev);
6799 	new_settings(hdev, cmd->sk);
6805 static int set_secure_conn_sync(struct hci_dev *hdev, void *data)
6812 	hci_dev_set_flag(hdev, HCI_SC_ENABLED);
6814 	return hci_write_sc_support_sync(hdev, val);
6817 static int set_secure_conn(struct sock *sk, struct hci_dev *hdev,
6825 	bt_dev_dbg(hdev, "sock %p", sk);
6827 	if (!lmp_sc_capable(hdev) &&
6828 	    !hci_dev_test_flag(hdev, HCI_LE_ENABLED))
6829 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SECURE_CONN,
6832 	if (hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) &&
6833 	    lmp_sc_capable(hdev) &&
6834 	    !hci_dev_test_flag(hdev, HCI_SSP_ENABLED))
6835 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SECURE_CONN,
6839 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SECURE_CONN,
6842 	hci_dev_lock(hdev);
6844 	if (!hdev_is_powered(hdev) || !lmp_sc_capable(hdev) ||
6845 	    !hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) {
6849 			changed = !hci_dev_test_and_set_flag(hdev,
6852 				hci_dev_set_flag(hdev, HCI_SC_ONLY);
6854 				hci_dev_clear_flag(hdev, HCI_SC_ONLY);
6856 			changed = hci_dev_test_and_clear_flag(hdev,
6858 			hci_dev_clear_flag(hdev, HCI_SC_ONLY);
6861 		err = send_settings_rsp(sk, MGMT_OP_SET_SECURE_CONN, hdev);
6866 			err = new_settings(hdev, sk);
6873 	if (val == hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
6874 	    (cp->val == 0x02) == hci_dev_test_flag(hdev, HCI_SC_ONLY)) {
6875 		err = send_settings_rsp(sk, MGMT_OP_SET_SECURE_CONN, hdev);
6879 	cmd = mgmt_pending_new(sk, MGMT_OP_SET_SECURE_CONN, hdev, data, len);
6883 		err = hci_cmd_sync_queue(hdev, set_secure_conn_sync, cmd,
6887 		mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SECURE_CONN,
6894 	hci_dev_unlock(hdev);
6898 static int set_debug_keys(struct sock *sk, struct hci_dev *hdev,
6905 	bt_dev_dbg(hdev, "sock %p", sk);
6908 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DEBUG_KEYS,
6911 	hci_dev_lock(hdev);
6914 		changed = !hci_dev_test_and_set_flag(hdev, HCI_KEEP_DEBUG_KEYS);
6916 		changed = hci_dev_test_and_clear_flag(hdev,
6920 		use_changed = !hci_dev_test_and_set_flag(hdev,
6923 		use_changed = hci_dev_test_and_clear_flag(hdev,
6926 	if (hdev_is_powered(hdev) && use_changed &&
6927 	    hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) {
6929 		hci_send_cmd(hdev, HCI_OP_WRITE_SSP_DEBUG_MODE,
6933 	err = send_settings_rsp(sk, MGMT_OP_SET_DEBUG_KEYS, hdev);
6938 		err = new_settings(hdev, sk);
6941 	hci_dev_unlock(hdev);
6945 static int set_privacy(struct sock *sk, struct hci_dev *hdev, void *cp_data,
6952 	bt_dev_dbg(hdev, "sock %p", sk);
6954 	if (!lmp_le_capable(hdev))
6955 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_PRIVACY,
6959 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_PRIVACY,
6962 	if (hdev_is_powered(hdev))
6963 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_PRIVACY,
6966 	hci_dev_lock(hdev);
6971 	hci_dev_set_flag(hdev, HCI_RPA_RESOLVING);
6974 		changed = !hci_dev_test_and_set_flag(hdev, HCI_PRIVACY);
6975 		memcpy(hdev->irk, cp->irk, sizeof(hdev->irk));
6976 		hci_dev_set_flag(hdev, HCI_RPA_EXPIRED);
6977 		hci_adv_instances_set_rpa_expired(hdev, true);
6979 			hci_dev_set_flag(hdev, HCI_LIMITED_PRIVACY);
6981 			hci_dev_clear_flag(hdev, HCI_LIMITED_PRIVACY);
6983 		changed = hci_dev_test_and_clear_flag(hdev, HCI_PRIVACY);
6984 		memset(hdev->irk, 0, sizeof(hdev->irk));
6985 		hci_dev_clear_flag(hdev, HCI_RPA_EXPIRED);
6986 		hci_adv_instances_set_rpa_expired(hdev, false);
6987 		hci_dev_clear_flag(hdev, HCI_LIMITED_PRIVACY);
6990 	err = send_settings_rsp(sk, MGMT_OP_SET_PRIVACY, hdev);
6995 		err = new_settings(hdev, sk);
6998 	hci_dev_unlock(hdev);
7018 static int load_irks(struct sock *sk, struct hci_dev *hdev, void *cp_data,
7027 	bt_dev_dbg(hdev, "sock %p", sk);
7029 	if (!lmp_le_capable(hdev))
7030 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_IRKS,
7035 		bt_dev_err(hdev, "load_irks: too big irk_count value %u",
7037 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_IRKS,
7043 		bt_dev_err(hdev, "load_irks: expected %u bytes, got %u bytes",
7045 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_IRKS,
7049 	bt_dev_dbg(hdev, "irk_count %u", irk_count);
7055 			return mgmt_cmd_status(sk, hdev->id,
7060 	hci_dev_lock(hdev);
7062 	hci_smp_irks_clear(hdev);
7068 		if (hci_is_blocked_key(hdev,
7071 			bt_dev_warn(hdev, "Skipping blocked IRK for %pMR",
7080 		hci_add_irk(hdev, &irk->addr.bdaddr,
7085 	hci_dev_set_flag(hdev, HCI_RPA_RESOLVING);
7087 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_LOAD_IRKS, 0, NULL, 0);
7089 	hci_dev_unlock(hdev);
7113 static int load_long_term_keys(struct sock *sk, struct hci_dev *hdev,
7122 	bt_dev_dbg(hdev, "sock %p", sk);
7124 	if (!lmp_le_capable(hdev))
7125 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LONG_TERM_KEYS,
7130 		bt_dev_err(hdev, "load_ltks: too big key_count value %u",
7132 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LONG_TERM_KEYS,
7138 		bt_dev_err(hdev, "load_keys: expected %u bytes, got %u bytes",
7140 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LONG_TERM_KEYS,
7144 	bt_dev_dbg(hdev, "key_count %u", key_count);
7150 			return mgmt_cmd_status(sk, hdev->id,
7155 	hci_dev_lock(hdev);
7157 	hci_smp_ltks_clear(hdev);
7164 		if (hci_is_blocked_key(hdev,
7167 			bt_dev_warn(hdev, "Skipping blocked LTK for %pMR",
7201 		hci_add_ltk(hdev, &key->addr.bdaddr,
7206 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_LOAD_LONG_TERM_KEYS, 0,
7209 	hci_dev_unlock(hdev);
7214 static void get_conn_info_complete(struct hci_dev *hdev, void *data, int err)
7222 	bt_dev_dbg(hdev, "err %d", err);
7243 static int get_conn_info_sync(struct hci_dev *hdev, void *data)
7253 		conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK,
7256 		conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &cp->addr.bdaddr);
7265 	err = hci_read_rssi_sync(hdev, handle);
7272 		err = hci_read_tx_power_sync(hdev, handle, 0x00);
7276 		err = hci_read_tx_power_sync(hdev, handle, 0x01);
7281 static int get_conn_info(struct sock *sk, struct hci_dev *hdev, void *data,
7290 	bt_dev_dbg(hdev, "sock %p", sk);
7297 		return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CONN_INFO,
7301 	hci_dev_lock(hdev);
7303 	if (!hdev_is_powered(hdev)) {
7304 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CONN_INFO,
7311 		conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK,
7314 		conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &cp->addr.bdaddr);
7317 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CONN_INFO,
7324 	 * calculate conn info age as random value between min/max set in hdev.
7326 	conn_info_age = get_random_u32_inclusive(hdev->conn_info_min_age,
7327 						 hdev->conn_info_max_age - 1);
7337 		cmd = mgmt_pending_new(sk, MGMT_OP_GET_CONN_INFO, hdev, data,
7342 			err = hci_cmd_sync_queue(hdev, get_conn_info_sync,
7347 			mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CONN_INFO,
7363 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CONN_INFO,
7368 	hci_dev_unlock(hdev);
7372 static void get_clock_info_complete(struct hci_dev *hdev, void *data, int err)
7380 	bt_dev_dbg(hdev, "err %d", err);
7389 	rp.local_clock = cpu_to_le32(hdev->clock);
7403 static int get_clock_info_sync(struct hci_dev *hdev, void *data)
7411 	hci_read_clock_sync(hdev, &hci_cp);
7414 	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->addr.bdaddr);
7422 	return hci_read_clock_sync(hdev, &hci_cp);
7425 static int get_clock_info(struct sock *sk, struct hci_dev *hdev, void *data,
7434 	bt_dev_dbg(hdev, "sock %p", sk);
7441 		return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CLOCK_INFO,
7445 	hci_dev_lock(hdev);
7447 	if (!hdev_is_powered(hdev)) {
7448 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CLOCK_INFO,
7455 		conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK,
7458 			err = mgmt_cmd_complete(sk, hdev->id,
7468 	cmd = mgmt_pending_new(sk, MGMT_OP_GET_CLOCK_INFO, hdev, data, len);
7472 		err = hci_cmd_sync_queue(hdev, get_clock_info_sync, cmd,
7476 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CLOCK_INFO,
7485 	hci_dev_unlock(hdev);
7489 static bool is_connected(struct hci_dev *hdev, bdaddr_t *addr, u8 type)
7493 	conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, addr);
7506 /* This function requires the caller holds hdev->lock */
7507 static int hci_conn_params_set(struct hci_dev *hdev, bdaddr_t *addr,
7512 	params = hci_conn_params_add(hdev, addr, addr_type);
7528 			hci_pend_le_list_add(params, &hdev->pend_le_conns);
7532 			hci_pend_le_list_add(params, &hdev->pend_le_conns);
7534 			hci_pend_le_list_add(params, &hdev->pend_le_reports);
7538 		if (!is_connected(hdev, addr, addr_type))
7539 			hci_pend_le_list_add(params, &hdev->pend_le_conns);
7545 	bt_dev_dbg(hdev, "addr %pMR (type %u) auto_connect %u",
7551 static void device_added(struct sock *sk, struct hci_dev *hdev,
7560 	mgmt_event(MGMT_EV_DEVICE_ADDED, hdev, &ev, sizeof(ev), sk);
7563 static int add_device_sync(struct hci_dev *hdev, void *data)
7565 	return hci_update_passive_scan_sync(hdev);
7568 static int add_device(struct sock *sk, struct hci_dev *hdev,
7578 	bt_dev_dbg(hdev, "sock %p", sk);
7582 		return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_DEVICE,
7587 		return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_DEVICE,
7591 	hci_dev_lock(hdev);
7596 			err = mgmt_cmd_complete(sk, hdev->id,
7603 		err = hci_bdaddr_list_add_with_flags(&hdev->accept_list,
7609 		hci_update_scan(hdev);
7629 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_DEVICE,
7638 	if (hci_conn_params_set(hdev, &cp->addr.bdaddr, addr_type,
7640 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_DEVICE,
7645 		params = hci_conn_params_lookup(hdev, &cp->addr.bdaddr,
7651 	err = hci_cmd_sync_queue(hdev, add_device_sync, NULL, NULL);
7656 	device_added(sk, hdev, &cp->addr.bdaddr, cp->addr.type, cp->action);
7657 	supported_flags = hdev->conn_flags;
7658 	device_flags_changed(NULL, hdev, &cp->addr.bdaddr, cp->addr.type,
7661 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_DEVICE,
7666 	hci_dev_unlock(hdev);
7670 static void device_removed(struct sock *sk, struct hci_dev *hdev,
7678 	mgmt_event(MGMT_EV_DEVICE_REMOVED, hdev, &ev, sizeof(ev), sk);
7681 static int remove_device_sync(struct hci_dev *hdev, void *data)
7683 	return hci_update_passive_scan_sync(hdev);
7686 static int remove_device(struct sock *sk, struct hci_dev *hdev,
7692 	bt_dev_dbg(hdev, "sock %p", sk);
7694 	hci_dev_lock(hdev);
7701 			err = mgmt_cmd_complete(sk, hdev->id,
7709 			err = hci_bdaddr_list_del(&hdev->accept_list,
7713 				err = mgmt_cmd_complete(sk, hdev->id,
7721 			hci_update_scan(hdev);
7723 			device_removed(sk, hdev, &cp->addr.bdaddr,
7736 			err = mgmt_cmd_complete(sk, hdev->id,
7743 		params = hci_conn_params_lookup(hdev, &cp->addr.bdaddr,
7746 			err = mgmt_cmd_complete(sk, hdev->id,
7755 			err = mgmt_cmd_complete(sk, hdev->id,
7764 		device_removed(sk, hdev, &cp->addr.bdaddr, cp->addr.type);
7770 			err = mgmt_cmd_complete(sk, hdev->id,
7777 		list_for_each_entry_safe(b, btmp, &hdev->accept_list, list) {
7778 			device_removed(sk, hdev, &b->bdaddr, b->bdaddr_type);
7783 		hci_update_scan(hdev);
7785 		list_for_each_entry_safe(p, tmp, &hdev->le_conn_params, list) {
7788 			device_removed(sk, hdev, &p->addr, p->addr_type);
7796 		bt_dev_dbg(hdev, "All LE connection parameters were removed");
7799 	hci_cmd_sync_queue(hdev, remove_device_sync, NULL, NULL);
7802 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_DEVICE,
7806 	hci_dev_unlock(hdev);
7810 static int load_conn_param(struct sock *sk, struct hci_dev *hdev, void *data,
7819 	if (!lmp_le_capable(hdev))
7820 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_CONN_PARAM,
7825 		bt_dev_err(hdev, "load_conn_param: too big param_count value %u",
7827 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_CONN_PARAM,
7833 		bt_dev_err(hdev, "load_conn_param: expected %u bytes, got %u bytes",
7835 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_CONN_PARAM,
7839 	bt_dev_dbg(hdev, "param_count %u", param_count);
7841 	hci_dev_lock(hdev);
7843 	hci_conn_params_clear_disabled(hdev);
7851 		bt_dev_dbg(hdev, "Adding %pMR (type %u)", &param->addr.bdaddr,
7859 			bt_dev_err(hdev, "ignoring invalid connection parameters");
7868 		bt_dev_dbg(hdev, "min 0x%04x max 0x%04x latency 0x%04x timeout 0x%04x",
7872 			bt_dev_err(hdev, "ignoring invalid connection parameters");
7876 		hci_param = hci_conn_params_add(hdev, &param->addr.bdaddr,
7879 			bt_dev_err(hdev, "failed to add connection parameters");
7889 	hci_dev_unlock(hdev);
7891 	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_LOAD_CONN_PARAM, 0,
7895 static int set_external_config(struct sock *sk, struct hci_dev *hdev,
7902 	bt_dev_dbg(hdev, "sock %p", sk);
7904 	if (hdev_is_powered(hdev))
7905 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_EXTERNAL_CONFIG,
7909 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_EXTERNAL_CONFIG,
7912 	if (!test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks))
7913 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_EXTERNAL_CONFIG,
7916 	hci_dev_lock(hdev);
7919 		changed = !hci_dev_test_and_set_flag(hdev, HCI_EXT_CONFIGURED);
7921 		changed = hci_dev_test_and_clear_flag(hdev, HCI_EXT_CONFIGURED);
7923 	err = send_options_rsp(sk, MGMT_OP_SET_EXTERNAL_CONFIG, hdev);
7930 	err = new_options(hdev, sk);
7932 	if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) == is_configured(hdev)) {
7933 		mgmt_index_removed(hdev);
7935 		if (hci_dev_test_and_change_flag(hdev, HCI_UNCONFIGURED)) {
7936 			hci_dev_set_flag(hdev, HCI_CONFIG);
7937 			hci_dev_set_flag(hdev, HCI_AUTO_OFF);
7939 			queue_work(hdev->req_workqueue, &hdev->power_on);
7941 			set_bit(HCI_RAW, &hdev->flags);
7942 			mgmt_index_added(hdev);
7947 	hci_dev_unlock(hdev);
7951 static int set_public_address(struct sock *sk, struct hci_dev *hdev,
7958 	bt_dev_dbg(hdev, "sock %p", sk);
7960 	if (hdev_is_powered(hdev))
7961 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_PUBLIC_ADDRESS,
7965 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_PUBLIC_ADDRESS,
7968 	if (!hdev->set_bdaddr)
7969 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_PUBLIC_ADDRESS,
7972 	hci_dev_lock(hdev);
7974 	changed = !!bacmp(&hdev->public_addr, &cp->bdaddr);
7975 	bacpy(&hdev->public_addr, &cp->bdaddr);
7977 	err = send_options_rsp(sk, MGMT_OP_SET_PUBLIC_ADDRESS, hdev);
7984 	if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED))
7985 		err = new_options(hdev, sk);
7987 	if (is_configured(hdev)) {
7988 		mgmt_index_removed(hdev);
7990 		hci_dev_clear_flag(hdev, HCI_UNCONFIGURED);
7992 		hci_dev_set_flag(hdev, HCI_CONFIG);
7993 		hci_dev_set_flag(hdev, HCI_AUTO_OFF);
7995 		queue_work(hdev->req_workqueue, &hdev->power_on);
7999 	hci_dev_unlock(hdev);
8003 static void read_local_oob_ext_data_complete(struct hci_dev *hdev, void *data,
8014 	if (cmd != pending_find(MGMT_OP_READ_LOCAL_OOB_EXT_DATA, hdev))
8026 	bt_dev_dbg(hdev, "status %u", status);
8038 	} else if (!bredr_sc_enabled(hdev)) {
8064 			if (hci_dev_test_flag(hdev, HCI_SC_ONLY)) {
8087 				  hdev->dev_class, 3);
8107 	err = mgmt_cmd_complete(cmd->sk, hdev->id,
8115 	err = mgmt_limited_event(MGMT_EV_LOCAL_OOB_DATA_UPDATED, hdev,
8126 static int read_local_ssp_oob_req(struct hci_dev *hdev, struct sock *sk,
8132 	cmd = mgmt_pending_add(sk, MGMT_OP_READ_LOCAL_OOB_EXT_DATA, hdev,
8137 	err = hci_cmd_sync_queue(hdev, read_local_oob_data_sync, cmd,
8148 static int read_local_oob_ext_data(struct sock *sk, struct hci_dev *hdev,
8158 	bt_dev_dbg(hdev, "sock %p", sk);
8160 	if (hdev_is_powered(hdev)) {
8163 			status = mgmt_bredr_support(hdev);
8170 			status = mgmt_le_support(hdev);
8191 	if (!status && !lmp_ssp_capable(hdev)) {
8199 	hci_dev_lock(hdev);
8204 		if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) {
8205 			err = read_local_ssp_oob_req(hdev, sk, cp);
8206 			hci_dev_unlock(hdev);
8215 						  hdev->dev_class, 3);
8219 		if (hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
8220 		    smp_generate_oob(hdev, hash, rand) < 0) {
8221 			hci_dev_unlock(hdev);
8236 		if (hci_dev_test_flag(hdev, HCI_PRIVACY)) {
8237 			hci_dev_unlock(hdev);
8242 		if (hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ||
8243 		   !bacmp(&hdev->bdaddr, BDADDR_ANY) ||
8244 		   (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) &&
8245 		    bacmp(&hdev->static_addr, BDADDR_ANY))) {
8246 			memcpy(addr, &hdev->static_addr, 6);
8249 			memcpy(addr, &hdev->bdaddr, 6);
8256 		if (hci_dev_test_flag(hdev, HCI_ADVERTISING))
8264 		if (hci_dev_test_flag(hdev, HCI_SC_ENABLED)) {
8274 		flags = mgmt_get_adv_discov_flags(hdev);
8276 		if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED))
8284 	hci_dev_unlock(hdev);
8294 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_EXT_DATA,
8299 	err = mgmt_limited_event(MGMT_EV_LOCAL_OOB_DATA_UPDATED, hdev,
8309 static u32 get_supported_adv_flags(struct hci_dev *hdev)
8328 	if (hdev->adv_tx_power != HCI_TX_POWER_INVALID || ext_adv_capable(hdev))
8331 	if (ext_adv_capable(hdev)) {
8336 		if (le_2m_capable(hdev))
8339 		if (le_coded_capable(hdev))
8346 static int read_adv_features(struct sock *sk, struct hci_dev *hdev,
8356 	bt_dev_dbg(hdev, "sock %p", sk);
8358 	if (!lmp_le_capable(hdev))
8359 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_READ_ADV_FEATURES,
8362 	hci_dev_lock(hdev);
8364 	rp_len = sizeof(*rp) + hdev->adv_instance_cnt;
8367 		hci_dev_unlock(hdev);
8371 	supported_flags = get_supported_adv_flags(hdev);
8374 	rp->max_adv_data_len = max_adv_len(hdev);
8375 	rp->max_scan_rsp_len = max_adv_len(hdev);
8376 	rp->max_instances = hdev->le_num_of_adv_sets;
8377 	rp->num_instances = hdev->adv_instance_cnt;
8380 	list_for_each_entry(adv_instance, &hdev->adv_instances, list) {
8382 		if (adv_instance->instance <= hdev->adv_instance_cnt) {
8391 	hci_dev_unlock(hdev);
8393 	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_ADV_FEATURES,
8401 static u8 calculate_name_len(struct hci_dev *hdev)
8405 	return eir_append_local_name(hdev, buf, 0);
8408 static u8 tlv_data_max_len(struct hci_dev *hdev, u32 adv_flags,
8411 	u8 max_len = max_adv_len(hdev);
8423 			max_len -= calculate_name_len(hdev);
8454 static bool tlv_data_is_valid(struct hci_dev *hdev, u32 adv_flags, u8 *data,
8460 	max_len = tlv_data_max_len(hdev, adv_flags, is_adv_data);
8499 static bool requested_adv_flags_are_valid(struct hci_dev *hdev, u32 adv_flags)
8506 	supported_flags = get_supported_adv_flags(hdev);
8515 static bool adv_busy(struct hci_dev *hdev)
8517 	return pending_find(MGMT_OP_SET_LE, hdev);
8520 static void add_adv_complete(struct hci_dev *hdev, struct sock *sk, u8 instance,
8525 	bt_dev_dbg(hdev, "err %d", err);
8527 	hci_dev_lock(hdev);
8529 	list_for_each_entry_safe(adv, n, &hdev->adv_instances, list) {
8542 		if (hdev->cur_adv_instance == instance)
8543 			cancel_adv_timeout(hdev);
8545 		hci_remove_adv_instance(hdev, instance);
8546 		mgmt_advertising_removed(sk, hdev, instance);
8549 	hci_dev_unlock(hdev);
8552 static void add_advertising_complete(struct hci_dev *hdev, void *data, int err)
8569 	add_adv_complete(hdev, cmd->sk, cp->instance, err);
8574 static int add_advertising_sync(struct hci_dev *hdev, void *data)
8579 	return hci_schedule_adv_instance_sync(hdev, cp->instance, true);
8582 static int add_advertising(struct sock *sk, struct hci_dev *hdev,
8596 	bt_dev_dbg(hdev, "sock %p", sk);
8598 	status = mgmt_le_support(hdev);
8600 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
8603 	if (cp->instance < 1 || cp->instance > hdev->le_num_of_adv_sets)
8604 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
8608 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
8615 	if (!requested_adv_flags_are_valid(hdev, flags))
8616 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
8619 	hci_dev_lock(hdev);
8621 	if (timeout && !hdev_is_powered(hdev)) {
8622 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
8627 	if (adv_busy(hdev)) {
8628 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
8633 	if (!tlv_data_is_valid(hdev, flags, cp->data, cp->adv_data_len, true) ||
8634 	    !tlv_data_is_valid(hdev, flags, cp->data + cp->adv_data_len,
8636 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
8641 	prev_instance_cnt = hdev->adv_instance_cnt;
8643 	adv = hci_add_adv_instance(hdev, cp->instance, flags,
8649 				   hdev->le_adv_min_interval,
8650 				   hdev->le_adv_max_interval, 0);
8652 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
8660 	if (hdev->adv_instance_cnt > prev_instance_cnt)
8661 		mgmt_advertising_added(sk, hdev, cp->instance);
8663 	if (hdev->cur_adv_instance == cp->instance) {
8669 		cancel_adv_timeout(hdev);
8671 		next_instance = hci_get_next_instance(hdev, cp->instance);
8674 	} else if (!hdev->adv_instance_timeout) {
8685 	if (!hdev_is_powered(hdev) ||
8686 	    hci_dev_test_flag(hdev, HCI_ADVERTISING) ||
8689 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
8697 	cmd = mgmt_pending_new(sk, MGMT_OP_ADD_ADVERTISING, hdev, data,
8706 	err = hci_cmd_sync_queue(hdev, add_advertising_sync, cmd,
8712 	hci_dev_unlock(hdev);
8717 static void add_ext_adv_params_complete(struct hci_dev *hdev, void *data,
8726 	BT_DBG("%s", hdev->name);
8728 	hci_dev_lock(hdev);
8730 	adv = hci_find_adv_instance(hdev, cp->instance);
8741 	rp.max_adv_data_len = tlv_data_max_len(hdev, flags, true);
8742 	rp.max_scan_rsp_len = tlv_data_max_len(hdev, flags, false);
8750 			mgmt_advertising_removed(cmd->sk, hdev, cp->instance);
8752 		hci_remove_adv_instance(hdev, cp->instance);
8765 	hci_dev_unlock(hdev);
8768 static int add_ext_adv_params_sync(struct hci_dev *hdev, void *data)
8773 	return hci_setup_ext_adv_instance_sync(hdev, cp->instance);
8776 static int add_ext_adv_params(struct sock *sk, struct hci_dev *hdev,
8789 	BT_DBG("%s", hdev->name);
8791 	status = mgmt_le_support(hdev);
8793 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
8796 	if (cp->instance < 1 || cp->instance > hdev->le_num_of_adv_sets)
8797 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
8807 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
8812 	if (!requested_adv_flags_are_valid(hdev, flags))
8813 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
8816 	hci_dev_lock(hdev);
8819 	if (!hdev_is_powered(hdev)) {
8820 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
8825 	if (adv_busy(hdev)) {
8826 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
8837 		   hdev->def_multi_adv_rotation_duration;
8841 		       hdev->le_adv_min_interval;
8845 		       hdev->le_adv_max_interval;
8852 	adv = hci_add_adv_instance(hdev, cp->instance, flags, 0, NULL, 0, NULL,
8857 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
8863 	if (ext_adv_capable(hdev)) {
8864 		cmd = mgmt_pending_new(sk, MGMT_OP_ADD_EXT_ADV_PARAMS, hdev,
8868 			hci_remove_adv_instance(hdev, cp->instance);
8872 		err = hci_cmd_sync_queue(hdev, add_ext_adv_params_sync, cmd,
8879 		rp.max_adv_data_len = tlv_data_max_len(hdev, flags, true);
8880 		rp.max_scan_rsp_len = tlv_data_max_len(hdev, flags, false);
8881 		err = mgmt_cmd_complete(sk, hdev->id,
8887 	hci_dev_unlock(hdev);
8892 static void add_ext_adv_data_complete(struct hci_dev *hdev, void *data, int err)
8898 	add_adv_complete(hdev, cmd->sk, cp->instance, err);
8914 static int add_ext_adv_data_sync(struct hci_dev *hdev, void *data)
8920 	if (ext_adv_capable(hdev)) {
8921 		err = hci_update_adv_data_sync(hdev, cp->instance);
8925 		err = hci_update_scan_rsp_data_sync(hdev, cp->instance);
8929 		return hci_enable_ext_advertising_sync(hdev, cp->instance);
8932 	return hci_schedule_adv_instance_sync(hdev, cp->instance, true);
8935 static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data,
8946 	BT_DBG("%s", hdev->name);
8948 	hci_dev_lock(hdev);
8950 	adv_instance = hci_find_adv_instance(hdev, cp->instance);
8953 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
8959 	if (!hdev_is_powered(hdev)) {
8960 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
8965 	if (adv_busy(hdev)) {
8966 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
8972 	if (!tlv_data_is_valid(hdev, adv_instance->flags, cp->data,
8974 	    !tlv_data_is_valid(hdev, adv_instance->flags, cp->data +
8976 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
8982 	hci_set_adv_instance_data(hdev, cp->instance, cp->adv_data_len,
8987 	if (hdev->cur_adv_instance == cp->instance) {
8994 		cancel_adv_timeout(hdev);
8996 		next_instance = hci_get_next_instance(hdev, cp->instance);
8999 	} else if (!hdev->adv_instance_timeout) {
9010 	if (hci_dev_test_flag(hdev, HCI_ADVERTISING) || !schedule_instance) {
9012 			mgmt_advertising_added(sk, hdev, cp->instance);
9016 		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
9021 	cmd = mgmt_pending_new(sk, MGMT_OP_ADD_EXT_ADV_DATA, hdev, data,
9028 	err = hci_cmd_sync_queue(hdev, add_ext_adv_data_sync, cmd,
9041 		mgmt_advertising_added(sk, hdev, cp->instance);
9046 	hci_remove_adv_instance(hdev, cp->instance);
9049 	hci_dev_unlock(hdev);
9054 static void remove_advertising_complete(struct hci_dev *hdev, void *data,
9061 	bt_dev_dbg(hdev, "err %d", err);
9076 static int remove_advertising_sync(struct hci_dev *hdev, void *data)
9082 	err = hci_remove_advertising_sync(hdev, cmd->sk, cp->instance, true);
9086 	if (list_empty(&hdev->adv_instances))
9087 		err = hci_disable_advertising_sync(hdev);
9092 static int remove_advertising(struct sock *sk, struct hci_dev *hdev,
9099 	bt_dev_dbg(hdev, "sock %p", sk);
9101 	hci_dev_lock(hdev);
9103 	if (cp->instance && !hci_find_adv_instance(hdev, cp->instance)) {
9104 		err = mgmt_cmd_status(sk, hdev->id,
9110 	if (pending_find(MGMT_OP_SET_LE, hdev)) {
9111 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_REMOVE_ADVERTISING,
9116 	if (list_empty(&hdev->adv_instances)) {
9117 		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_REMOVE_ADVERTISING,
9122 	cmd = mgmt_pending_new(sk, MGMT_OP_REMOVE_ADVERTISING, hdev, data,
9129 	err = hci_cmd_sync_queue(hdev, remove_advertising_sync, cmd,
9135 	hci_dev_unlock(hdev);
9140 static int get_adv_size_info(struct sock *sk, struct hci_dev *hdev,
9147 	bt_dev_dbg(hdev, "sock %p", sk);
9149 	if (!lmp_le_capable(hdev))
9150 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_GET_ADV_SIZE_INFO,
9153 	if (cp->instance < 1 || cp->instance > hdev->le_num_of_adv_sets)
9154 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_GET_ADV_SIZE_INFO,
9162 	supported_flags = get_supported_adv_flags(hdev);
9164 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_GET_ADV_SIZE_INFO,
9169 	rp.max_adv_data_len = tlv_data_max_len(hdev, flags, true);
9170 	rp.max_scan_rsp_len = tlv_data_max_len(hdev, flags, false);
9172 	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_ADV_SIZE_INFO,
9310 void mgmt_index_added(struct hci_dev *hdev)
9314 	if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
9317 	switch (hdev->dev_type) {
9319 		if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) {
9320 			mgmt_index_event(MGMT_EV_UNCONF_INDEX_ADDED, hdev,
9324 			mgmt_index_event(MGMT_EV_INDEX_ADDED, hdev, NULL, 0,
9336 	ev.bus = hdev->bus;
9338 	mgmt_index_event(MGMT_EV_EXT_INDEX_ADDED, hdev, &ev, sizeof(ev),
9342 void mgmt_index_removed(struct hci_dev *hdev)
9347 	if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
9350 	switch (hdev->dev_type) {
9352 		mgmt_pending_foreach(0, hdev, cmd_complete_rsp, &status);
9354 		if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED)) {
9355 			mgmt_index_event(MGMT_EV_UNCONF_INDEX_REMOVED, hdev,
9359 			mgmt_index_event(MGMT_EV_INDEX_REMOVED, hdev, NULL, 0,
9371 	ev.bus = hdev->bus;
9373 	mgmt_index_event(MGMT_EV_EXT_INDEX_REMOVED, hdev, &ev, sizeof(ev),
9377 	if (!hci_dev_test_flag(hdev, HCI_MGMT))
9379 	cancel_delayed_work_sync(&hdev->discov_off);
9380 	cancel_delayed_work_sync(&hdev->service_cache);
9381 	cancel_delayed_work_sync(&hdev->rpa_expired);
9384 void mgmt_power_on(struct hci_dev *hdev, int err)
9386 	struct cmd_lookup match = { NULL, hdev };
9388 	bt_dev_dbg(hdev, "err %d", err);
9390 	hci_dev_lock(hdev);
9393 		restart_le_actions(hdev);
9394 		hci_update_passive_scan(hdev);
9397 	mgmt_pending_foreach(MGMT_OP_SET_POWERED, hdev, settings_rsp, &match);
9399 	new_settings(hdev, match.sk);
9404 	hci_dev_unlock(hdev);
9407 void __mgmt_power_off(struct hci_dev *hdev)
9409 	struct cmd_lookup match = { NULL, hdev };
9412 	mgmt_pending_foreach(MGMT_OP_SET_POWERED, hdev, settings_rsp, &match);
9414 	/* If the power off is because of hdev unregistration let
9421 	if (hci_dev_test_flag(hdev, HCI_UNREGISTER))
9426 	mgmt_pending_foreach(0, hdev, cmd_complete_rsp, &status);
9428 	if (memcmp(hdev->dev_class, zero_cod, sizeof(zero_cod)) != 0) {
9429 		mgmt_limited_event(MGMT_EV_CLASS_OF_DEV_CHANGED, hdev,
9432 		ext_info_changed(hdev, NULL);
9435 	new_settings(hdev, match.sk);
9441 void mgmt_set_powered_failed(struct hci_dev *hdev, int err)
9446 	cmd = pending_find(MGMT_OP_SET_POWERED, hdev);
9455 	mgmt_cmd_status(cmd->sk, hdev->id, MGMT_OP_SET_POWERED, status);
9460 void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
9474 	mgmt_event(MGMT_EV_NEW_LINK_KEY, hdev, &ev, sizeof(ev), NULL);
9496 void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent)
9536 	mgmt_event(MGMT_EV_NEW_LONG_TERM_KEY, hdev, &ev, sizeof(ev), NULL);
9539 void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk, bool persistent)
9552 	mgmt_event(MGMT_EV_NEW_IRK, hdev, &ev, sizeof(ev), NULL);
9555 void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
9582 	mgmt_event(MGMT_EV_NEW_CSRK, hdev, &ev, sizeof(ev), NULL);
9585 void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr,
9603 	mgmt_event(MGMT_EV_NEW_CONN_PARAM, hdev, &ev, sizeof(ev), NULL);
9606 void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
9619 		skb = mgmt_alloc_skb(hdev, MGMT_EV_DEVICE_CONNECTED,
9622 		skb = mgmt_alloc_skb(hdev, MGMT_EV_DEVICE_CONNECTED,
9670 	struct hci_dev *hdev = data;
9673 	device_unpaired(hdev, &cp->addr.bdaddr, cp->addr.type, cmd->sk);
9679 bool mgmt_powering_down(struct hci_dev *hdev)
9684 	cmd = pending_find(MGMT_OP_SET_POWERED, hdev);
9695 void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
9708 	mgmt_pending_foreach(MGMT_OP_DISCONNECT, hdev, disconnect_rsp, &sk);
9715 	if (hdev->suspended)
9718 	mgmt_event(MGMT_EV_DEVICE_DISCONNECTED, hdev, &ev, sizeof(ev), sk);
9723 	mgmt_pending_foreach(MGMT_OP_UNPAIR_DEVICE, hdev, unpair_device_rsp,
9724 			     hdev);
9727 void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
9734 	mgmt_pending_foreach(MGMT_OP_UNPAIR_DEVICE, hdev, unpair_device_rsp,
9735 			     hdev);
9737 	cmd = pending_find(MGMT_OP_DISCONNECT, hdev);
9753 void mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
9762 	mgmt_event(MGMT_EV_CONNECT_FAILED, hdev, &ev, sizeof(ev), NULL);
9765 void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure)
9773 	mgmt_event(MGMT_EV_PIN_CODE_REQUEST, hdev, &ev, sizeof(ev), NULL);
9776 void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
9781 	cmd = pending_find(MGMT_OP_PIN_CODE_REPLY, hdev);
9789 void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
9794 	cmd = pending_find(MGMT_OP_PIN_CODE_NEG_REPLY, hdev);
9802 int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
9808 	bt_dev_dbg(hdev, "bdaddr %pMR", bdaddr);
9815 	return mgmt_event(MGMT_EV_USER_CONFIRM_REQUEST, hdev, &ev, sizeof(ev),
9819 int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
9824 	bt_dev_dbg(hdev, "bdaddr %pMR", bdaddr);
9829 	return mgmt_event(MGMT_EV_USER_PASSKEY_REQUEST, hdev, &ev, sizeof(ev),
9833 static int user_pairing_resp_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
9839 	cmd = pending_find(opcode, hdev);
9849 int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
9852 	return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
9856 int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
9859 	return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
9864 int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
9867 	return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
9871 int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
9874 	return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
9879 int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
9885 	bt_dev_dbg(hdev, "bdaddr %pMR", bdaddr);
9892 	return mgmt_event(MGMT_EV_PASSKEY_NOTIFY, hdev, &ev, sizeof(ev), NULL);
9907 	mgmt_event(MGMT_EV_AUTH_FAILED, conn->hdev, &ev, sizeof(ev),
9916 void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status)
9918 	struct cmd_lookup match = { NULL, hdev };
9923 		mgmt_pending_foreach(MGMT_OP_SET_LINK_SECURITY, hdev,
9928 	if (test_bit(HCI_AUTH, &hdev->flags))
9929 		changed = !hci_dev_test_and_set_flag(hdev, HCI_LINK_SECURITY);
9931 		changed = hci_dev_test_and_clear_flag(hdev, HCI_LINK_SECURITY);
9933 	mgmt_pending_foreach(MGMT_OP_SET_LINK_SECURITY, hdev, settings_rsp,
9937 		new_settings(hdev, match.sk);
9953 void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
9956 	struct cmd_lookup match = { NULL, hdev, mgmt_status(status) };
9958 	mgmt_pending_foreach(MGMT_OP_SET_DEV_CLASS, hdev, sk_lookup, &match);
9959 	mgmt_pending_foreach(MGMT_OP_ADD_UUID, hdev, sk_lookup, &match);
9960 	mgmt_pending_foreach(MGMT_OP_REMOVE_UUID, hdev, sk_lookup, &match);
9963 		mgmt_limited_event(MGMT_EV_CLASS_OF_DEV_CHANGED, hdev, dev_class,
9965 		ext_info_changed(hdev, NULL);
9972 void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status)
9982 	memcpy(ev.short_name, hdev->short_name, HCI_MAX_SHORT_NAME_LENGTH);
9984 	cmd = pending_find(MGMT_OP_SET_LOCAL_NAME, hdev);
9986 		memcpy(hdev->dev_name, name, sizeof(hdev->dev_name));
9991 		if (pending_find(MGMT_OP_SET_POWERED, hdev))
9995 	mgmt_limited_event(MGMT_EV_LOCAL_NAME_CHANGED, hdev, &ev, sizeof(ev),
9997 	ext_info_changed(hdev, cmd ? cmd->sk : NULL);
10067 static void restart_le_scan(struct hci_dev *hdev)
10070 	if (!hci_dev_test_flag(hdev, HCI_LE_SCAN))
10074 		       hdev->discovery.scan_start +
10075 		       hdev->discovery.scan_duration))
10078 	queue_delayed_work(hdev->req_workqueue, &hdev->le_scan_restart,
10082 static bool is_filter_match(struct hci_dev *hdev, s8 rssi, u8 *eir,
10094 	if (hdev->discovery.rssi != HCI_RSSI_INVALID &&
10096 	    (rssi < hdev->discovery.rssi &&
10097 	     !test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks))))
10100 	if (hdev->discovery.uuid_count != 0) {
10104 		if (!eir_has_uuids(eir, eir_len, hdev->discovery.uuid_count,
10105 				   hdev->discovery.uuids) &&
10107 				   hdev->discovery.uuid_count,
10108 				   hdev->discovery.uuids))
10115 	if (test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks)) {
10116 		restart_le_scan(hdev);
10119 		if (hdev->discovery.rssi != HCI_RSSI_INVALID &&
10120 		    rssi < hdev->discovery.rssi)
10127 void mgmt_adv_monitor_device_lost(struct hci_dev *hdev, u16 handle,
10136 	mgmt_event(MGMT_EV_ADV_MONITOR_DEVICE_LOST, hdev, &ev, sizeof(ev),
10140 static void mgmt_send_adv_monitor_device_found(struct hci_dev *hdev,
10154 	advmon_skb = mgmt_alloc_skb(hdev, MGMT_EV_ADV_MONITOR_DEVICE_FOUND,
10170 static void mgmt_adv_monitor_device_found(struct hci_dev *hdev,
10194 	if (report_device && !hdev->advmon_pend_notify) {
10199 	hdev->advmon_pend_notify = false;
10201 	list_for_each_entry_safe(dev, tmp, &hdev->monitored_devices, list) {
10206 				mgmt_send_adv_monitor_device_found(hdev, skb,
10215 			hdev->advmon_pend_notify = true;
10219 	    ((matched && !notified) || !msft_monitor_supported(hdev))) {
10225 		mgmt_send_adv_monitor_device_found(hdev, skb, skip_sk, 0);
10234 static void mesh_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr,
10243 	if (!hdev->mesh_ad_types[0])
10249 			for (j = 0; j < sizeof(hdev->mesh_ad_types); j++) {
10250 				if (!hdev->mesh_ad_types[j])
10253 				if (hdev->mesh_ad_types[j] == eir[i + 1])
10261 			for (j = 0; j < sizeof(hdev->mesh_ad_types); j++) {
10262 				if (!hdev->mesh_ad_types[j])
10265 				if (hdev->mesh_ad_types[j] == scan_rsp[i + 1])
10274 	skb = mgmt_alloc_skb(hdev, MGMT_EV_MESH_DEVICE_FOUND,
10300 void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
10307 	bool report_device = hci_discovery_active(hdev);
10309 	if (hci_dev_test_flag(hdev, HCI_MESH) && link_type == LE_LINK)
10310 		mesh_device_found(hdev, bdaddr, addr_type, rssi, flags,
10318 	if (!hci_discovery_active(hdev)) {
10321 		if (link_type == LE_LINK && !list_empty(&hdev->pend_le_reports))
10323 		else if (!hci_is_adv_monitoring(hdev))
10327 	if (hdev->discovery.result_filtering) {
10329 		if (!is_filter_match(hdev, rssi, eir, eir_len, scan_rsp,
10334 	if (hdev->discovery.limited) {
10347 	skb = mgmt_alloc_skb(hdev, MGMT_EV_DEVICE_FOUND,
10362 	if (rssi == HCI_RSSI_INVALID && !hdev->discovery.report_invalid_rssi &&
10389 	mgmt_adv_monitor_device_found(hdev, bdaddr, report_device, skb, NULL);
10392 void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
10400 	skb = mgmt_alloc_skb(hdev, MGMT_EV_DEVICE_FOUND,
10419 void mgmt_discovering(struct hci_dev *hdev, u8 discovering)
10423 	bt_dev_dbg(hdev, "discovering %u", discovering);
10426 	ev.type = hdev->discovery.type;
10429 	mgmt_event(MGMT_EV_DISCOVERING, hdev, &ev, sizeof(ev), NULL);
10432 void mgmt_suspending(struct hci_dev *hdev, u8 state)
10437 	mgmt_event(MGMT_EV_CONTROLLER_SUSPEND, hdev, &ev, sizeof(ev), NULL);
10440 void mgmt_resuming(struct hci_dev *hdev, u8 reason, bdaddr_t *bdaddr,
10453 	mgmt_event(MGMT_EV_CONTROLLER_RESUME, hdev, &ev, sizeof(ev), NULL);
10476 	struct hci_dev *hdev;
10480 	list_for_each_entry(hdev, &hci_dev_list, list) {
10482 			mesh_tx = mgmt_mesh_next(hdev, sk);
10485 				mesh_send_complete(hdev, mesh_tx, true);