~hc/RK356X_SDK_RELEASE.git

..	..	@@ -36,9 +36,11 @@
36	36	#include "hci_request.h"
37	37	#include "smp.h"
38	38	#include "mgmt_util.h"
	39	+#include "mgmt_config.h"
	40	+#include "msft.h"
39	41
40	42	#define MGMT_VERSION 1
41		-#define MGMT_REVISION 14
	43	+#define MGMT_REVISION 18
42	44
43	45	static const u16 mgmt_commands[] = {
44	46	MGMT_OP_READ_INDEX_LIST,
..	..	@@ -106,6 +108,20 @@
106	108	MGMT_OP_START_LIMITED_DISCOVERY,
107	109	MGMT_OP_READ_EXT_INFO,
108	110	MGMT_OP_SET_APPEARANCE,
	111	+ MGMT_OP_SET_BLOCKED_KEYS,
	112	+ MGMT_OP_SET_WIDEBAND_SPEECH,
	113	+ MGMT_OP_READ_SECURITY_INFO,
	114	+ MGMT_OP_READ_EXP_FEATURES_INFO,
	115	+ MGMT_OP_SET_EXP_FEATURE,
	116	+ MGMT_OP_READ_DEF_SYSTEM_CONFIG,
	117	+ MGMT_OP_SET_DEF_SYSTEM_CONFIG,
	118	+ MGMT_OP_READ_DEF_RUNTIME_CONFIG,
	119	+ MGMT_OP_SET_DEF_RUNTIME_CONFIG,
	120	+ MGMT_OP_GET_DEVICE_FLAGS,
	121	+ MGMT_OP_SET_DEVICE_FLAGS,
	122	+ MGMT_OP_READ_ADV_MONITOR_FEATURES,
	123	+ MGMT_OP_ADD_ADV_PATTERNS_MONITOR,
	124	+ MGMT_OP_REMOVE_ADV_MONITOR,
109	125	};
110	126
111	127	static const u16 mgmt_events[] = {
..	..	@@ -144,6 +160,11 @@
144	160	MGMT_EV_ADVERTISING_ADDED,
145	161	MGMT_EV_ADVERTISING_REMOVED,
146	162	MGMT_EV_EXT_INFO_CHANGED,
	163	+ MGMT_EV_PHY_CONFIGURATION_CHANGED,
	164	+ MGMT_EV_EXP_FEATURE_CHANGED,
	165	+ MGMT_EV_DEVICE_FLAGS_CHANGED,
	166	+ MGMT_EV_CONTROLLER_SUSPEND,
	167	+ MGMT_EV_CONTROLLER_RESUME,
147	168	};
148	169
149	170	static const u16 mgmt_untrusted_commands[] = {
..	..	@@ -153,6 +174,10 @@
153	174	MGMT_OP_READ_CONFIG_INFO,
154	175	MGMT_OP_READ_EXT_INDEX_LIST,
155	176	MGMT_OP_READ_EXT_INFO,
	177	+ MGMT_OP_READ_SECURITY_INFO,
	178	+ MGMT_OP_READ_EXP_FEATURES_INFO,
	179	+ MGMT_OP_READ_DEF_SYSTEM_CONFIG,
	180	+ MGMT_OP_READ_DEF_RUNTIME_CONFIG,
156	181	};
157	182
158	183	static const u16 mgmt_untrusted_events[] = {
..	..	@@ -167,6 +192,9 @@
167	192	MGMT_EV_EXT_INDEX_ADDED,
168	193	MGMT_EV_EXT_INDEX_REMOVED,
169	194	MGMT_EV_EXT_INFO_CHANGED,
	195	+ MGMT_EV_EXP_FEATURE_CHANGED,
	196	+ MGMT_EV_ADV_MONITOR_ADDED,
	197	+ MGMT_EV_ADV_MONITOR_REMOVED,
170	198	};
171	199
172	200	#define CACHE_TIMEOUT msecs_to_jiffies(2 * 1000)
..	..	@@ -175,7 +203,7 @@
175	203	"\x00\x00\x00\x00\x00\x00\x00\x00"
176	204
177	205	/* HCI to MGMT error code conversion table */
178		-static u8 mgmt_status_table[] = {
	206	+static const u8 mgmt_status_table[] = {
179	207	MGMT_STATUS_SUCCESS,
180	208	MGMT_STATUS_UNKNOWN_COMMAND, /* Unknown Command */
181	209	MGMT_STATUS_NOT_CONNECTED, /* No Connection */
..	..	@@ -292,7 +320,7 @@
292	320	{
293	321	struct mgmt_rp_read_version rp;
294	322
295		- BT_DBG("sock %p", sk);
	323	+ bt_dev_dbg(hdev, "sock %p", sk);
296	324
297	325	mgmt_fill_version_info(&rp);
298	326
..	..	@@ -308,7 +336,7 @@
308	336	size_t rp_size;
309	337	int i, err;
310	338
311		- BT_DBG("sock %p", sk);
	339	+ bt_dev_dbg(hdev, "sock %p", sk);
312	340
313	341	if (hci_sock_test_flag(sk, HCI_SOCK_TRUSTED)) {
314	342	num_commands = ARRAY_SIZE(mgmt_commands);
..	..	@@ -361,7 +389,7 @@
361	389	u16 count;
362	390	int err;
363	391
364		- BT_DBG("sock %p", sk);
	392	+ bt_dev_dbg(hdev, "sock %p", sk);
365	393
366	394	read_lock(&hci_dev_list_lock);
367	395
..	..	@@ -395,7 +423,7 @@
395	423	if (d->dev_type == HCI_PRIMARY &&
396	424	!hci_dev_test_flag(d, HCI_UNCONFIGURED)) {
397	425	rp->index[count++] = cpu_to_le16(d->id);
398		- BT_DBG("Added hci%u", d->id);
	426	+ bt_dev_dbg(hdev, "Added hci%u", d->id);
399	427	}
400	428	}
401	429
..	..	@@ -421,7 +449,7 @@
421	449	u16 count;
422	450	int err;
423	451
424		- BT_DBG("sock %p", sk);
	452	+ bt_dev_dbg(hdev, "sock %p", sk);
425	453
426	454	read_lock(&hci_dev_list_lock);
427	455
..	..	@@ -455,7 +483,7 @@
455	483	if (d->dev_type == HCI_PRIMARY &&
456	484	hci_dev_test_flag(d, HCI_UNCONFIGURED)) {
457	485	rp->index[count++] = cpu_to_le16(d->id);
458		- BT_DBG("Added hci%u", d->id);
	486	+ bt_dev_dbg(hdev, "Added hci%u", d->id);
459	487	}
460	488	}
461	489
..	..	@@ -477,11 +505,10 @@
477	505	{
478	506	struct mgmt_rp_read_ext_index_list *rp;
479	507	struct hci_dev *d;
480		- size_t rp_len;
481	508	u16 count;
482	509	int err;
483	510
484		- BT_DBG("sock %p", sk);
	511	+ bt_dev_dbg(hdev, "sock %p", sk);
485	512
486	513	read_lock(&hci_dev_list_lock);
487	514
..	..	@@ -491,8 +518,7 @@
491	518	count++;
492	519	}
493	520
494		- rp_len = sizeof(rp) + (sizeof(rp->entry[0]) count);
495		- rp = kmalloc(rp_len, GFP_ATOMIC);
	521	+ rp = kmalloc(struct_size(rp, entry, count), GFP_ATOMIC);
496	522	if (!rp) {
497	523	read_unlock(&hci_dev_list_lock);
498	524	return -ENOMEM;
..	..	@@ -524,11 +550,10 @@
524	550
525	551	rp->entry[count].bus = d->bus;
526	552	rp->entry[count++].index = cpu_to_le16(d->id);
527		- BT_DBG("Added hci%u", d->id);
	553	+ bt_dev_dbg(hdev, "Added hci%u", d->id);
528	554	}
529	555
530	556	rp->num_controllers = cpu_to_le16(count);
531		- rp_len = sizeof(rp) + (sizeof(rp->entry[0]) count);
532	557
533	558	read_unlock(&hci_dev_list_lock);
534	559
..	..	@@ -541,7 +566,8 @@
541	566	hci_sock_clear_flag(sk, HCI_MGMT_UNCONF_INDEX_EVENTS);
542	567
543	568	err = mgmt_cmd_complete(sk, MGMT_INDEX_NONE,
544		- MGMT_OP_READ_EXT_INDEX_LIST, 0, rp, rp_len);
	569	+ MGMT_OP_READ_EXT_INDEX_LIST, 0, rp,
	570	+ struct_size(rp, entry, count));
545	571
546	572	kfree(rp);
547	573
..	..	@@ -554,7 +580,8 @@
554	580	!hci_dev_test_flag(hdev, HCI_EXT_CONFIGURED))
555	581	return false;
556	582
557		- if (test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks) &&
	583	+ if ((test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks) \|\|
	584	+ test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks)) &&
558	585	!bacmp(&hdev->public_addr, BDADDR_ANY))
559	586	return false;
560	587
..	..	@@ -569,7 +596,8 @@
569	596	!hci_dev_test_flag(hdev, HCI_EXT_CONFIGURED))
570	597	options \|= MGMT_OPTION_EXTERNAL_CONFIG;
571	598
572		- if (test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks) &&
	599	+ if ((test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks) \|\|
	600	+ test_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hdev->quirks)) &&
573	601	!bacmp(&hdev->public_addr, BDADDR_ANY))
574	602	options \|= MGMT_OPTION_PUBLIC_ADDRESS;
575	603
..	..	@@ -598,7 +626,7 @@
598	626	struct mgmt_rp_read_config_info rp;
599	627	u32 options = 0;
600	628
601		- BT_DBG("sock %p %s", sk, hdev->name);
	629	+ bt_dev_dbg(hdev, "sock %p", sk);
602	630
603	631	hci_dev_lock(hdev);
604	632
..	..	@@ -765,14 +793,23 @@
765	793
766	794	if (lmp_sc_capable(hdev))
767	795	settings \|= MGMT_SETTING_SECURE_CONN;
	796	+
	797	+ if (test_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED,
	798	+ &hdev->quirks))
	799	+ settings \|= MGMT_SETTING_WIDEBAND_SPEECH;
768	800	}
769	801
770	802	if (lmp_le_capable(hdev)) {
771	803	settings \|= MGMT_SETTING_LE;
772		- settings \|= MGMT_SETTING_ADVERTISING;
773	804	settings \|= MGMT_SETTING_SECURE_CONN;
774	805	settings \|= MGMT_SETTING_PRIVACY;
775	806	settings \|= MGMT_SETTING_STATIC_ADDRESS;
	807	+
	808	+ /* When the experimental feature for LL Privacy support is
	809	+ * enabled, then advertising is no longer supported.
	810	+ */
	811	+ if (!hci_dev_test_flag(hdev, HCI_ENABLE_LL_PRIVACY))
	812	+ settings \|= MGMT_SETTING_ADVERTISING;
776	813	}
777	814
778	815	if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) \|\|
..	..	@@ -848,6 +885,9 @@
848	885	if (bacmp(&hdev->static_addr, BDADDR_ANY))
849	886	settings \|= MGMT_SETTING_STATIC_ADDRESS;
850	887	}
	888	+
	889	+ if (hci_dev_test_flag(hdev, HCI_WIDEBAND_SPEECH_ENABLED))
	890	+ settings \|= MGMT_SETTING_WIDEBAND_SPEECH;
851	891
852	892	return settings;
853	893	}
..	..	@@ -932,7 +972,7 @@
932	972	rpa_expired.work);
933	973	struct hci_request req;
934	974
935		- BT_DBG("");
	975	+ bt_dev_dbg(hdev, "");
936	976
937	977	hci_dev_set_flag(hdev, HCI_RPA_EXPIRED);
938	978
..	..	@@ -972,7 +1012,7 @@
972	1012	{
973	1013	struct mgmt_rp_read_info rp;
974	1014
975		- BT_DBG("sock %p %s", sk, hdev->name);
	1015	+ bt_dev_dbg(hdev, "sock %p", sk);
976	1016
977	1017	hci_dev_lock(hdev);
978	1018
..	..	@@ -1028,7 +1068,7 @@
1028	1068	struct mgmt_rp_read_ext_info rp = (void )buf;
1029	1069	u16 eir_len;
1030	1070
1031		- BT_DBG("sock %p %s", sk, hdev->name);
	1071	+ bt_dev_dbg(hdev, "sock %p", sk);
1032	1072
1033	1073	memset(&buf, 0, sizeof(buf));
1034	1074
..	..	@@ -1087,7 +1127,7 @@
1087	1127
1088	1128	static void clean_up_hci_complete(struct hci_dev *hdev, u8 status, u16 opcode)
1089	1129	{
1090		- BT_DBG("%s status 0x%02x", hdev->name, status);
	1130	+ bt_dev_dbg(hdev, "status 0x%02x", status);
1091	1131
1092	1132	if (hci_conn_count(hdev) == 0) {
1093	1133	cancel_delayed_work(&hdev->power_off);
..	..	@@ -1163,7 +1203,7 @@
1163	1203	struct mgmt_pending_cmd *cmd;
1164	1204	int err;
1165	1205
1166		- BT_DBG("request for %s", hdev->name);
	1206	+ bt_dev_dbg(hdev, "sock %p", sk);
1167	1207
1168	1208	if (cp->val != 0x00 && cp->val != 0x01)
1169	1209	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_POWERED,
..	..	@@ -1304,7 +1344,7 @@
1304	1344	{
1305	1345	struct mgmt_pending_cmd *cmd;
1306	1346
1307		- BT_DBG("status 0x%02x", status);
	1347	+ bt_dev_dbg(hdev, "status 0x%02x", status);
1308	1348
1309	1349	hci_dev_lock(hdev);
1310	1350
..	..	@@ -1343,7 +1383,7 @@
1343	1383	u16 timeout;
1344	1384	int err;
1345	1385
1346		- BT_DBG("request for %s", hdev->name);
	1386	+ bt_dev_dbg(hdev, "sock %p", sk);
1347	1387
1348	1388	if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED) &&
1349	1389	!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED))
..	..	@@ -1382,6 +1422,12 @@
1382	1422	if (!hci_dev_test_flag(hdev, HCI_CONNECTABLE)) {
1383	1423	err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
1384	1424	MGMT_STATUS_REJECTED);
	1425	+ goto failed;
	1426	+ }
	1427	+
	1428	+ if (hdev->advertising_paused) {
	1429	+ err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
	1430	+ MGMT_STATUS_BUSY);
1385	1431	goto failed;
1386	1432	}
1387	1433
..	..	@@ -1463,7 +1509,7 @@
1463	1509	{
1464	1510	struct mgmt_pending_cmd *cmd;
1465	1511
1466		- BT_DBG("status 0x%02x", status);
	1512	+ bt_dev_dbg(hdev, "status 0x%02x", status);
1467	1513
1468	1514	hci_dev_lock(hdev);
1469	1515
..	..	@@ -1523,7 +1569,7 @@
1523	1569	struct mgmt_pending_cmd *cmd;
1524	1570	int err;
1525	1571
1526		- BT_DBG("request for %s", hdev->name);
	1572	+ bt_dev_dbg(hdev, "sock %p", sk);
1527	1573
1528	1574	if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED) &&
1529	1575	!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED))
..	..	@@ -1580,7 +1626,7 @@
1580	1626	bool changed;
1581	1627	int err;
1582	1628
1583		- BT_DBG("request for %s", hdev->name);
	1629	+ bt_dev_dbg(hdev, "sock %p", sk);
1584	1630
1585	1631	if (cp->val != 0x00 && cp->val != 0x01)
1586	1632	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BONDABLE,
..	..	@@ -1624,7 +1670,7 @@
1624	1670	u8 val, status;
1625	1671	int err;
1626	1672
1627		- BT_DBG("request for %s", hdev->name);
	1673	+ bt_dev_dbg(hdev, "sock %p", sk);
1628	1674
1629	1675	status = mgmt_bredr_support(hdev);
1630	1676	if (status)
..	..	@@ -1692,7 +1738,7 @@
1692	1738	u8 status;
1693	1739	int err;
1694	1740
1695		- BT_DBG("request for %s", hdev->name);
	1741	+ bt_dev_dbg(hdev, "sock %p", sk);
1696	1742
1697	1743	status = mgmt_bredr_support(hdev);
1698	1744	if (status)
..	..	@@ -1773,7 +1819,7 @@
1773	1819	u8 status;
1774	1820	int err;
1775	1821
1776		- BT_DBG("request for %s", hdev->name);
	1822	+ bt_dev_dbg(hdev, "sock %p", sk);
1777	1823
1778	1824	if (!IS_ENABLED(CONFIG_BT_HS))
1779	1825	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_HS,
..	..	@@ -1883,7 +1929,7 @@
1883	1929	int err;
1884	1930	u8 val, enabled;
1885	1931
1886		- BT_DBG("request for %s", hdev->name);
	1932	+ bt_dev_dbg(hdev, "sock %p", sk);
1887	1933
1888	1934	if (!lmp_le_capable(hdev))
1889	1935	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
..	..	@@ -2044,7 +2090,7 @@
2044	2090
2045	2091	static void add_uuid_complete(struct hci_dev *hdev, u8 status, u16 opcode)
2046	2092	{
2047		- BT_DBG("status 0x%02x", status);
	2093	+ bt_dev_dbg(hdev, "status 0x%02x", status);
2048	2094
2049	2095	mgmt_class_complete(hdev, MGMT_OP_ADD_UUID, status);
2050	2096	}
..	..	@@ -2057,7 +2103,7 @@
2057	2103	struct bt_uuid *uuid;
2058	2104	int err;
2059	2105
2060		- BT_DBG("request for %s", hdev->name);
	2106	+ bt_dev_dbg(hdev, "sock %p", sk);
2061	2107
2062	2108	hci_dev_lock(hdev);
2063	2109
..	..	@@ -2123,7 +2169,7 @@
2123	2169
2124	2170	static void remove_uuid_complete(struct hci_dev *hdev, u8 status, u16 opcode)
2125	2171	{
2126		- BT_DBG("status 0x%02x", status);
	2172	+ bt_dev_dbg(hdev, "status 0x%02x", status);
2127	2173
2128	2174	mgmt_class_complete(hdev, MGMT_OP_REMOVE_UUID, status);
2129	2175	}
..	..	@@ -2138,7 +2184,7 @@
2138	2184	struct hci_request req;
2139	2185	int err, found;
2140	2186
2141		- BT_DBG("request for %s", hdev->name);
	2187	+ bt_dev_dbg(hdev, "sock %p", sk);
2142	2188
2143	2189	hci_dev_lock(hdev);
2144	2190
..	..	@@ -2209,7 +2255,7 @@
2209	2255
2210	2256	static void set_class_complete(struct hci_dev *hdev, u8 status, u16 opcode)
2211	2257	{
2212		- BT_DBG("status 0x%02x", status);
	2258	+ bt_dev_dbg(hdev, "status 0x%02x", status);
2213	2259
2214	2260	mgmt_class_complete(hdev, MGMT_OP_SET_DEV_CLASS, status);
2215	2261	}
..	..	@@ -2222,7 +2268,7 @@
2222	2268	struct hci_request req;
2223	2269	int err;
2224	2270
2225		- BT_DBG("request for %s", hdev->name);
	2271	+ bt_dev_dbg(hdev, "sock %p", sk);
2226	2272
2227	2273	if (!lmp_bredr_capable(hdev))
2228	2274	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS,
..	..	@@ -2295,7 +2341,7 @@
2295	2341	bool changed;
2296	2342	int i;
2297	2343
2298		- BT_DBG("request for %s", hdev->name);
	2344	+ bt_dev_dbg(hdev, "sock %p", sk);
2299	2345
2300	2346	if (!lmp_bredr_capable(hdev))
2301	2347	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
..	..	@@ -2309,8 +2355,7 @@
2309	2355	MGMT_STATUS_INVALID_PARAMS);
2310	2356	}
2311	2357
2312		- expected_len = sizeof(cp) + key_count
2313		- sizeof(struct mgmt_link_key_info);
	2358	+ expected_len = struct_size(cp, keys, key_count);
2314	2359	if (expected_len != len) {
2315	2360	bt_dev_err(hdev, "load_link_keys: expected %u bytes, got %u bytes",
2316	2361	expected_len, len);
..	..	@@ -2322,8 +2367,8 @@
2322	2367	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
2323	2368	MGMT_STATUS_INVALID_PARAMS);
2324	2369
2325		- BT_DBG("%s debug_keys %u key_count %u", hdev->name, cp->debug_keys,
2326		- key_count);
	2370	+ bt_dev_dbg(hdev, "debug_keys %u key_count %u", cp->debug_keys,
	2371	+ key_count);
2327	2372
2328	2373	for (i = 0; i < key_count; i++) {
2329	2374	struct mgmt_link_key_info *key = &cp->keys[i];
..	..	@@ -2349,6 +2394,14 @@
2349	2394
2350	2395	for (i = 0; i < key_count; i++) {
2351	2396	struct mgmt_link_key_info *key = &cp->keys[i];
	2397	+
	2398	+ if (hci_is_blocked_key(hdev,
	2399	+ HCI_BLOCKED_KEY_TYPE_LINKKEY,
	2400	+ key->val)) {
	2401	+ bt_dev_warn(hdev, "Skipping blocked link key for %pMR",
	2402	+ &key->addr.bdaddr);
	2403	+ continue;
	2404	+ }
2352	2405
2353	2406	/* Always ignore debug keys and require a new pairing if
2354	2407	* the user wants to use them.
..	..	@@ -2516,7 +2569,7 @@
2516	2569	struct hci_conn *conn;
2517	2570	int err;
2518	2571
2519		- BT_DBG("");
	2572	+ bt_dev_dbg(hdev, "sock %p", sk);
2520	2573
2521	2574	memset(&rp, 0, sizeof(rp));
2522	2575	bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
..	..	@@ -2597,11 +2650,10 @@
2597	2650	{
2598	2651	struct mgmt_rp_get_connections *rp;
2599	2652	struct hci_conn *c;
2600		- size_t rp_len;
2601	2653	int err;
2602	2654	u16 i;
2603	2655
2604		- BT_DBG("");
	2656	+ bt_dev_dbg(hdev, "sock %p", sk);
2605	2657
2606	2658	hci_dev_lock(hdev);
2607	2659
..	..	@@ -2617,8 +2669,7 @@
2617	2669	i++;
2618	2670	}
2619	2671
2620		- rp_len = sizeof(rp) + (i sizeof(struct mgmt_addr_info));
2621		- rp = kmalloc(rp_len, GFP_KERNEL);
	2672	+ rp = kmalloc(struct_size(rp, addr, i), GFP_KERNEL);
2622	2673	if (!rp) {
2623	2674	err = -ENOMEM;
2624	2675	goto unlock;
..	..	@@ -2638,10 +2689,8 @@
2638	2689	rp->conn_count = cpu_to_le16(i);
2639	2690
2640	2691	/* Recalculate length in case of filtered SCO connections, etc */
2641		- rp_len = sizeof(rp) + (i sizeof(struct mgmt_addr_info));
2642		-
2643	2692	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_CONNECTIONS, 0, rp,
2644		- rp_len);
	2693	+ struct_size(rp, addr, i));
2645	2694
2646	2695	kfree(rp);
2647	2696
..	..	@@ -2680,7 +2729,7 @@
2680	2729	struct mgmt_pending_cmd *cmd;
2681	2730	int err;
2682	2731
2683		- BT_DBG("");
	2732	+ bt_dev_dbg(hdev, "sock %p", sk);
2684	2733
2685	2734	hci_dev_lock(hdev);
2686	2735
..	..	@@ -2738,7 +2787,7 @@
2738	2787	{
2739	2788	struct mgmt_cp_set_io_capability *cp = data;
2740	2789
2741		- BT_DBG("");
	2790	+ bt_dev_dbg(hdev, "sock %p", sk);
2742	2791
2743	2792	if (cp->io_capability > SMP_IO_KEYBOARD_DISPLAY)
2744	2793	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_IO_CAPABILITY,
..	..	@@ -2748,8 +2797,7 @@
2748	2797
2749	2798	hdev->io_capability = cp->io_capability;
2750	2799
2751		- BT_DBG("%s IO capability set to 0x%02x", hdev->name,
2752		- hdev->io_capability);
	2800	+ bt_dev_dbg(hdev, "IO capability set to 0x%02x", hdev->io_capability);
2753	2801
2754	2802	hci_dev_unlock(hdev);
2755	2803
..	..	@@ -2861,7 +2909,7 @@
2861	2909	struct hci_conn *conn;
2862	2910	int err;
2863	2911
2864		- BT_DBG("");
	2912	+ bt_dev_dbg(hdev, "sock %p", sk);
2865	2913
2866	2914	memset(&rp, 0, sizeof(rp));
2867	2915	bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
..	..	@@ -2898,7 +2946,7 @@
2898	2946
2899	2947	if (cp->addr.type == BDADDR_BREDR) {
2900	2948	conn = hci_connect_acl(hdev, &cp->addr.bdaddr, sec_level,
2901		- auth_type);
	2949	+ auth_type, CONN_REASON_PAIR_DEVICE);
2902	2950	} else {
2903	2951	u8 addr_type = le_addr_type(cp->addr.type);
2904	2952	struct hci_conn_params *p;
..	..	@@ -2917,9 +2965,9 @@
2917	2965	if (p->auto_connect == HCI_AUTO_CONN_EXPLICIT)
2918	2966	p->auto_connect = HCI_AUTO_CONN_DISABLED;
2919	2967
2920		- conn = hci_connect_le_scan(hdev, &cp->addr.bdaddr,
2921		- addr_type, sec_level,
2922		- HCI_LE_CONN_TIMEOUT);
	2968	+ conn = hci_connect_le_scan(hdev, &cp->addr.bdaddr, addr_type,
	2969	+ sec_level, HCI_LE_CONN_TIMEOUT,
	2970	+ CONN_REASON_PAIR_DEVICE);
2923	2971	}
2924	2972
2925	2973	if (IS_ERR(conn)) {
..	..	@@ -2990,7 +3038,7 @@
2990	3038	struct hci_conn *conn;
2991	3039	int err;
2992	3040
2993		- BT_DBG("");
	3041	+ bt_dev_dbg(hdev, "sock %p", sk);
2994	3042
2995	3043	hci_dev_lock(hdev);
2996	3044
..	..	@@ -3020,6 +3068,20 @@
3020	3068
3021	3069	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE, 0,
3022	3070	addr, sizeof(*addr));
	3071	+
	3072	+ /* Since user doesn't want to proceed with the connection, abort any
	3073	+ * ongoing pairing and then terminate the link if it was created
	3074	+ * because of the pair device action.
	3075	+ */
	3076	+ if (addr->type == BDADDR_BREDR)
	3077	+ hci_remove_link_key(hdev, &addr->bdaddr);
	3078	+ else
	3079	+ smp_cancel_and_remove_pairing(hdev, &addr->bdaddr,
	3080	+ le_addr_type(addr->type));
	3081	+
	3082	+ if (conn->conn_reason == CONN_REASON_PAIR_DEVICE)
	3083	+ hci_abort_conn(conn, HCI_ERROR_REMOTE_USER_TERM);
	3084	+
3023	3085	unlock:
3024	3086	hci_dev_unlock(hdev);
3025	3087	return err;
..	..	@@ -3101,7 +3163,7 @@
3101	3163	{
3102	3164	struct mgmt_cp_pin_code_neg_reply *cp = data;
3103	3165
3104		- BT_DBG("");
	3166	+ bt_dev_dbg(hdev, "sock %p", sk);
3105	3167
3106	3168	return user_pairing_resp(sk, hdev, &cp->addr,
3107	3169	MGMT_OP_PIN_CODE_NEG_REPLY,
..	..	@@ -3113,7 +3175,7 @@
3113	3175	{
3114	3176	struct mgmt_cp_user_confirm_reply *cp = data;
3115	3177
3116		- BT_DBG("");
	3178	+ bt_dev_dbg(hdev, "sock %p", sk);
3117	3179
3118	3180	if (len != sizeof(*cp))
3119	3181	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_USER_CONFIRM_REPLY,
..	..	@@ -3129,7 +3191,7 @@
3129	3191	{
3130	3192	struct mgmt_cp_user_confirm_neg_reply *cp = data;
3131	3193
3132		- BT_DBG("");
	3194	+ bt_dev_dbg(hdev, "sock %p", sk);
3133	3195
3134	3196	return user_pairing_resp(sk, hdev, &cp->addr,
3135	3197	MGMT_OP_USER_CONFIRM_NEG_REPLY,
..	..	@@ -3141,7 +3203,7 @@
3141	3203	{
3142	3204	struct mgmt_cp_user_passkey_reply *cp = data;
3143	3205
3144		- BT_DBG("");
	3206	+ bt_dev_dbg(hdev, "sock %p", sk);
3145	3207
3146	3208	return user_pairing_resp(sk, hdev, &cp->addr,
3147	3209	MGMT_OP_USER_PASSKEY_REPLY,
..	..	@@ -3153,7 +3215,7 @@
3153	3215	{
3154	3216	struct mgmt_cp_user_passkey_neg_reply *cp = data;
3155	3217
3156		- BT_DBG("");
	3218	+ bt_dev_dbg(hdev, "sock %p", sk);
3157	3219
3158	3220	return user_pairing_resp(sk, hdev, &cp->addr,
3159	3221	MGMT_OP_USER_PASSKEY_NEG_REPLY,
..	..	@@ -3194,7 +3256,7 @@
3194	3256	struct mgmt_cp_set_local_name *cp;
3195	3257	struct mgmt_pending_cmd *cmd;
3196	3258
3197		- BT_DBG("status 0x%02x", status);
	3259	+ bt_dev_dbg(hdev, "status 0x%02x", status);
3198	3260
3199	3261	hci_dev_lock(hdev);
3200	3262
..	..	@@ -3229,7 +3291,7 @@
3229	3291	struct hci_request req;
3230	3292	int err;
3231	3293
3232		- BT_DBG("");
	3294	+ bt_dev_dbg(hdev, "sock %p", sk);
3233	3295
3234	3296	hci_dev_lock(hdev);
3235	3297
..	..	@@ -3295,21 +3357,21 @@
3295	3357	u16 len)
3296	3358	{
3297	3359	struct mgmt_cp_set_appearance *cp = data;
3298		- u16 apperance;
	3360	+ u16 appearance;
3299	3361	int err;
3300	3362
3301		- BT_DBG("");
	3363	+ bt_dev_dbg(hdev, "sock %p", sk);
3302	3364
3303	3365	if (!lmp_le_capable(hdev))
3304	3366	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_APPEARANCE,
3305	3367	MGMT_STATUS_NOT_SUPPORTED);
3306	3368
3307		- apperance = le16_to_cpu(cp->appearance);
	3369	+ appearance = le16_to_cpu(cp->appearance);
3308	3370
3309	3371	hci_dev_lock(hdev);
3310	3372
3311		- if (hdev->appearance != apperance) {
3312		- hdev->appearance = apperance;
	3373	+ if (hdev->appearance != appearance) {
	3374	+ hdev->appearance = appearance;
3313	3375
3314	3376	if (hci_dev_test_flag(hdev, HCI_LE_ADV))
3315	3377	adv_expire(hdev, MGMT_ADV_FLAG_APPEARANCE);
..	..	@@ -3330,7 +3392,7 @@
3330	3392	{
3331	3393	struct mgmt_rp_get_phy_confguration rp;
3332	3394
3333		- BT_DBG("sock %p %s", sk, hdev->name);
	3395	+ bt_dev_dbg(hdev, "sock %p", sk);
3334	3396
3335	3397	hci_dev_lock(hdev);
3336	3398
..	..	@@ -3363,7 +3425,7 @@
3363	3425	{
3364	3426	struct mgmt_pending_cmd *cmd;
3365	3427
3366		- BT_DBG("status 0x%02x", status);
	3428	+ bt_dev_dbg(hdev, "status 0x%02x", status);
3367	3429
3368	3430	hci_dev_lock(hdev);
3369	3431
..	..	@@ -3401,7 +3463,7 @@
3401	3463	bool changed = false;
3402	3464	int err;
3403	3465
3404		- BT_DBG("sock %p %s", sk, hdev->name);
	3466	+ bt_dev_dbg(hdev, "sock %p", sk);
3405	3467
3406	3468	configurable_phys = get_configurable_phys(hdev);
3407	3469	supported_phys = get_supported_phys(hdev);
..	..	@@ -3544,6 +3606,753 @@
3544	3606	return err;
3545	3607	}
3546	3608
	3609	+static int set_blocked_keys(struct sock sk, struct hci_dev hdev, void *data,
	3610	+ u16 len)
	3611	+{
	3612	+ int err = MGMT_STATUS_SUCCESS;
	3613	+ struct mgmt_cp_set_blocked_keys *keys = data;
	3614	+ const u16 max_key_count = ((U16_MAX - sizeof(*keys)) /
	3615	+ sizeof(struct mgmt_blocked_key_info));
	3616	+ u16 key_count, expected_len;
	3617	+ int i;
	3618	+
	3619	+ bt_dev_dbg(hdev, "sock %p", sk);
	3620	+
	3621	+ key_count = __le16_to_cpu(keys->key_count);
	3622	+ if (key_count > max_key_count) {
	3623	+ bt_dev_err(hdev, "too big key_count value %u", key_count);
	3624	+ return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BLOCKED_KEYS,
	3625	+ MGMT_STATUS_INVALID_PARAMS);
	3626	+ }
	3627	+
	3628	+ expected_len = struct_size(keys, keys, key_count);
	3629	+ if (expected_len != len) {
	3630	+ bt_dev_err(hdev, "expected %u bytes, got %u bytes",
	3631	+ expected_len, len);
	3632	+ return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BLOCKED_KEYS,
	3633	+ MGMT_STATUS_INVALID_PARAMS);
	3634	+ }
	3635	+
	3636	+ hci_dev_lock(hdev);
	3637	+
	3638	+ hci_blocked_keys_clear(hdev);
	3639	+
	3640	+ for (i = 0; i < keys->key_count; ++i) {
	3641	+ struct blocked_key b = kzalloc(sizeof(b), GFP_KERNEL);
	3642	+
	3643	+ if (!b) {
	3644	+ err = MGMT_STATUS_NO_RESOURCES;
	3645	+ break;
	3646	+ }
	3647	+
	3648	+ b->type = keys->keys[i].type;
	3649	+ memcpy(b->val, keys->keys[i].val, sizeof(b->val));
	3650	+ list_add_rcu(&b->list, &hdev->blocked_keys);
	3651	+ }
	3652	+ hci_dev_unlock(hdev);
	3653	+
	3654	+ return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_BLOCKED_KEYS,
	3655	+ err, NULL, 0);
	3656	+}
	3657	+
	3658	+static int set_wideband_speech(struct sock sk, struct hci_dev hdev,
	3659	+ void *data, u16 len)
	3660	+{
	3661	+ struct mgmt_mode *cp = data;
	3662	+ int err;
	3663	+ bool changed = false;
	3664	+
	3665	+ bt_dev_dbg(hdev, "sock %p", sk);
	3666	+
	3667	+ if (!test_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks))
	3668	+ return mgmt_cmd_status(sk, hdev->id,
	3669	+ MGMT_OP_SET_WIDEBAND_SPEECH,
	3670	+ MGMT_STATUS_NOT_SUPPORTED);
	3671	+
	3672	+ if (cp->val != 0x00 && cp->val != 0x01)
	3673	+ return mgmt_cmd_status(sk, hdev->id,
	3674	+ MGMT_OP_SET_WIDEBAND_SPEECH,
	3675	+ MGMT_STATUS_INVALID_PARAMS);
	3676	+
	3677	+ hci_dev_lock(hdev);
	3678	+
	3679	+ if (pending_find(MGMT_OP_SET_WIDEBAND_SPEECH, hdev)) {
	3680	+ err = mgmt_cmd_status(sk, hdev->id,
	3681	+ MGMT_OP_SET_WIDEBAND_SPEECH,
	3682	+ MGMT_STATUS_BUSY);
	3683	+ goto unlock;
	3684	+ }
	3685	+
	3686	+ if (hdev_is_powered(hdev) &&
	3687	+ !!cp->val != hci_dev_test_flag(hdev,
	3688	+ HCI_WIDEBAND_SPEECH_ENABLED)) {
	3689	+ err = mgmt_cmd_status(sk, hdev->id,
	3690	+ MGMT_OP_SET_WIDEBAND_SPEECH,
	3691	+ MGMT_STATUS_REJECTED);
	3692	+ goto unlock;
	3693	+ }
	3694	+
	3695	+ if (cp->val)
	3696	+ changed = !hci_dev_test_and_set_flag(hdev,
	3697	+ HCI_WIDEBAND_SPEECH_ENABLED);
	3698	+ else
	3699	+ changed = hci_dev_test_and_clear_flag(hdev,
	3700	+ HCI_WIDEBAND_SPEECH_ENABLED);
	3701	+
	3702	+ err = send_settings_rsp(sk, MGMT_OP_SET_WIDEBAND_SPEECH, hdev);
	3703	+ if (err < 0)
	3704	+ goto unlock;
	3705	+
	3706	+ if (changed)
	3707	+ err = new_settings(hdev, sk);
	3708	+
	3709	+unlock:
	3710	+ hci_dev_unlock(hdev);
	3711	+ return err;
	3712	+}
	3713	+
	3714	+static int read_security_info(struct sock sk, struct hci_dev hdev,
	3715	+ void *data, u16 data_len)
	3716	+{
	3717	+ char buf[16];
	3718	+ struct mgmt_rp_read_security_info rp = (void )buf;
	3719	+ u16 sec_len = 0;
	3720	+ u8 flags = 0;
	3721	+
	3722	+ bt_dev_dbg(hdev, "sock %p", sk);
	3723	+
	3724	+ memset(&buf, 0, sizeof(buf));
	3725	+
	3726	+ hci_dev_lock(hdev);
	3727	+
	3728	+ /* When the Read Simple Pairing Options command is supported, then
	3729	+ * the remote public key validation is supported.
	3730	+ */
	3731	+ if (hdev->commands[41] & 0x08)
	3732	+ flags \|= 0x01; /* Remote public key validation (BR/EDR) */
	3733	+
	3734	+ flags \|= 0x02; /* Remote public key validation (LE) */
	3735	+
	3736	+ /* When the Read Encryption Key Size command is supported, then the
	3737	+ * encryption key size is enforced.
	3738	+ */
	3739	+ if (hdev->commands[20] & 0x10)
	3740	+ flags \|= 0x04; /* Encryption key size enforcement (BR/EDR) */
	3741	+
	3742	+ flags \|= 0x08; /* Encryption key size enforcement (LE) */
	3743	+
	3744	+ sec_len = eir_append_data(rp->sec, sec_len, 0x01, &flags, 1);
	3745	+
	3746	+ /* When the Read Simple Pairing Options command is supported, then
	3747	+ * also max encryption key size information is provided.
	3748	+ */
	3749	+ if (hdev->commands[41] & 0x08)
	3750	+ sec_len = eir_append_le16(rp->sec, sec_len, 0x02,
	3751	+ hdev->max_enc_key_size);
	3752	+
	3753	+ sec_len = eir_append_le16(rp->sec, sec_len, 0x03, SMP_MAX_ENC_KEY_SIZE);
	3754	+
	3755	+ rp->sec_len = cpu_to_le16(sec_len);
	3756	+
	3757	+ hci_dev_unlock(hdev);
	3758	+
	3759	+ return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_READ_SECURITY_INFO, 0,
	3760	+ rp, sizeof(*rp) + sec_len);
	3761	+}
	3762	+
	3763	+#ifdef CONFIG_BT_FEATURE_DEBUG
	3764	+/* d4992530-b9ec-469f-ab01-6c481c47da1c */
	3765	+static const u8 debug_uuid[16] = {
	3766	+ 0x1c, 0xda, 0x47, 0x1c, 0x48, 0x6c, 0x01, 0xab,
	3767	+ 0x9f, 0x46, 0xec, 0xb9, 0x30, 0x25, 0x99, 0xd4,
	3768	+};
	3769	+#endif
	3770	+
	3771	+/* 671b10b5-42c0-4696-9227-eb28d1b049d6 */
	3772	+static const u8 simult_central_periph_uuid[16] = {
	3773	+ 0xd6, 0x49, 0xb0, 0xd1, 0x28, 0xeb, 0x27, 0x92,
	3774	+ 0x96, 0x46, 0xc0, 0x42, 0xb5, 0x10, 0x1b, 0x67,
	3775	+};
	3776	+
	3777	+/* 15c0a148-c273-11ea-b3de-0242ac130004 */
	3778	+static const u8 rpa_resolution_uuid[16] = {
	3779	+ 0x04, 0x00, 0x13, 0xac, 0x42, 0x02, 0xde, 0xb3,
	3780	+ 0xea, 0x11, 0x73, 0xc2, 0x48, 0xa1, 0xc0, 0x15,
	3781	+};
	3782	+
	3783	+static int read_exp_features_info(struct sock sk, struct hci_dev hdev,
	3784	+ void *data, u16 data_len)
	3785	+{
	3786	+ char buf[62]; /* Enough space for 3 features */
	3787	+ struct mgmt_rp_read_exp_features_info rp = (void )buf;
	3788	+ u16 idx = 0;
	3789	+ u32 flags;
	3790	+
	3791	+ bt_dev_dbg(hdev, "sock %p", sk);
	3792	+
	3793	+ memset(&buf, 0, sizeof(buf));
	3794	+
	3795	+#ifdef CONFIG_BT_FEATURE_DEBUG
	3796	+ if (!hdev) {
	3797	+ flags = bt_dbg_get() ? BIT(0) : 0;
	3798	+
	3799	+ memcpy(rp->features[idx].uuid, debug_uuid, 16);
	3800	+ rp->features[idx].flags = cpu_to_le32(flags);
	3801	+ idx++;
	3802	+ }
	3803	+#endif
	3804	+
	3805	+ if (hdev) {
	3806	+ if (test_bit(HCI_QUIRK_VALID_LE_STATES, &hdev->quirks) &&
	3807	+ (hdev->le_states[4] & 0x08) && /* Central */
	3808	+ (hdev->le_states[4] & 0x40) && /* Peripheral */
	3809	+ (hdev->le_states[3] & 0x10)) /* Simultaneous */
	3810	+ flags = BIT(0);
	3811	+ else
	3812	+ flags = 0;
	3813	+
	3814	+ memcpy(rp->features[idx].uuid, simult_central_periph_uuid, 16);
	3815	+ rp->features[idx].flags = cpu_to_le32(flags);
	3816	+ idx++;
	3817	+ }
	3818	+
	3819	+ if (hdev && use_ll_privacy(hdev)) {
	3820	+ if (hci_dev_test_flag(hdev, HCI_ENABLE_LL_PRIVACY))
	3821	+ flags = BIT(0) \| BIT(1);
	3822	+ else
	3823	+ flags = BIT(1);
	3824	+
	3825	+ memcpy(rp->features[idx].uuid, rpa_resolution_uuid, 16);
	3826	+ rp->features[idx].flags = cpu_to_le32(flags);
	3827	+ idx++;
	3828	+ }
	3829	+
	3830	+ rp->feature_count = cpu_to_le16(idx);
	3831	+
	3832	+ /* After reading the experimental features information, enable
	3833	+ * the events to update client on any future change.
	3834	+ */
	3835	+ hci_sock_set_flag(sk, HCI_MGMT_EXP_FEATURE_EVENTS);
	3836	+
	3837	+ return mgmt_cmd_complete(sk, hdev ? hdev->id : MGMT_INDEX_NONE,
	3838	+ MGMT_OP_READ_EXP_FEATURES_INFO,
	3839	+ 0, rp, sizeof(rp) + (20 idx));
	3840	+}
	3841	+
	3842	+static int exp_ll_privacy_feature_changed(bool enabled, struct hci_dev *hdev,
	3843	+ struct sock *skip)
	3844	+{
	3845	+ struct mgmt_ev_exp_feature_changed ev;
	3846	+
	3847	+ memset(&ev, 0, sizeof(ev));
	3848	+ memcpy(ev.uuid, rpa_resolution_uuid, 16);
	3849	+ ev.flags = cpu_to_le32((enabled ? BIT(0) : 0) \| BIT(1));
	3850	+
	3851	+ return mgmt_limited_event(MGMT_EV_EXP_FEATURE_CHANGED, hdev,
	3852	+ &ev, sizeof(ev),
	3853	+ HCI_MGMT_EXP_FEATURE_EVENTS, skip);
	3854	+
	3855	+}
	3856	+
	3857	+#ifdef CONFIG_BT_FEATURE_DEBUG
	3858	+static int exp_debug_feature_changed(bool enabled, struct sock *skip)
	3859	+{
	3860	+ struct mgmt_ev_exp_feature_changed ev;
	3861	+
	3862	+ memset(&ev, 0, sizeof(ev));
	3863	+ memcpy(ev.uuid, debug_uuid, 16);
	3864	+ ev.flags = cpu_to_le32(enabled ? BIT(0) : 0);
	3865	+
	3866	+ return mgmt_limited_event(MGMT_EV_EXP_FEATURE_CHANGED, NULL,
	3867	+ &ev, sizeof(ev),
	3868	+ HCI_MGMT_EXP_FEATURE_EVENTS, skip);
	3869	+}
	3870	+#endif
	3871	+
	3872	+static int set_exp_feature(struct sock sk, struct hci_dev hdev,
	3873	+ void *data, u16 data_len)
	3874	+{
	3875	+ struct mgmt_cp_set_exp_feature *cp = data;
	3876	+ struct mgmt_rp_set_exp_feature rp;
	3877	+
	3878	+ bt_dev_dbg(hdev, "sock %p", sk);
	3879	+
	3880	+ if (!memcmp(cp->uuid, ZERO_KEY, 16)) {
	3881	+ memset(rp.uuid, 0, 16);
	3882	+ rp.flags = cpu_to_le32(0);
	3883	+
	3884	+#ifdef CONFIG_BT_FEATURE_DEBUG
	3885	+ if (!hdev) {
	3886	+ bool changed = bt_dbg_get();
	3887	+
	3888	+ bt_dbg_set(false);
	3889	+
	3890	+ if (changed)
	3891	+ exp_debug_feature_changed(false, sk);
	3892	+ }
	3893	+#endif
	3894	+
	3895	+ if (hdev && use_ll_privacy(hdev) && !hdev_is_powered(hdev)) {
	3896	+ bool changed = hci_dev_test_flag(hdev,
	3897	+ HCI_ENABLE_LL_PRIVACY);
	3898	+
	3899	+ hci_dev_clear_flag(hdev, HCI_ENABLE_LL_PRIVACY);
	3900	+
	3901	+ if (changed)
	3902	+ exp_ll_privacy_feature_changed(false, hdev, sk);
	3903	+ }
	3904	+
	3905	+ hci_sock_set_flag(sk, HCI_MGMT_EXP_FEATURE_EVENTS);
	3906	+
	3907	+ return mgmt_cmd_complete(sk, hdev ? hdev->id : MGMT_INDEX_NONE,
	3908	+ MGMT_OP_SET_EXP_FEATURE, 0,
	3909	+ &rp, sizeof(rp));
	3910	+ }
	3911	+
	3912	+#ifdef CONFIG_BT_FEATURE_DEBUG
	3913	+ if (!memcmp(cp->uuid, debug_uuid, 16)) {
	3914	+ bool val, changed;
	3915	+ int err;
	3916	+
	3917	+ /* Command requires to use the non-controller index */
	3918	+ if (hdev)
	3919	+ return mgmt_cmd_status(sk, hdev->id,
	3920	+ MGMT_OP_SET_EXP_FEATURE,
	3921	+ MGMT_STATUS_INVALID_INDEX);
	3922	+
	3923	+ /* Parameters are limited to a single octet */
	3924	+ if (data_len != MGMT_SET_EXP_FEATURE_SIZE + 1)
	3925	+ return mgmt_cmd_status(sk, MGMT_INDEX_NONE,
	3926	+ MGMT_OP_SET_EXP_FEATURE,
	3927	+ MGMT_STATUS_INVALID_PARAMS);
	3928	+
	3929	+ /* Only boolean on/off is supported */
	3930	+ if (cp->param[0] != 0x00 && cp->param[0] != 0x01)
	3931	+ return mgmt_cmd_status(sk, MGMT_INDEX_NONE,
	3932	+ MGMT_OP_SET_EXP_FEATURE,
	3933	+ MGMT_STATUS_INVALID_PARAMS);
	3934	+
	3935	+ val = !!cp->param[0];
	3936	+ changed = val ? !bt_dbg_get() : bt_dbg_get();
	3937	+ bt_dbg_set(val);
	3938	+
	3939	+ memcpy(rp.uuid, debug_uuid, 16);
	3940	+ rp.flags = cpu_to_le32(val ? BIT(0) : 0);
	3941	+
	3942	+ hci_sock_set_flag(sk, HCI_MGMT_EXP_FEATURE_EVENTS);
	3943	+
	3944	+ err = mgmt_cmd_complete(sk, MGMT_INDEX_NONE,
	3945	+ MGMT_OP_SET_EXP_FEATURE, 0,
	3946	+ &rp, sizeof(rp));
	3947	+
	3948	+ if (changed)
	3949	+ exp_debug_feature_changed(val, sk);
	3950	+
	3951	+ return err;
	3952	+ }
	3953	+#endif
	3954	+
	3955	+ if (!memcmp(cp->uuid, rpa_resolution_uuid, 16)) {
	3956	+ bool val, changed;
	3957	+ int err;
	3958	+ u32 flags;
	3959	+
	3960	+ /* Command requires to use the controller index */
	3961	+ if (!hdev)
	3962	+ return mgmt_cmd_status(sk, MGMT_INDEX_NONE,
	3963	+ MGMT_OP_SET_EXP_FEATURE,
	3964	+ MGMT_STATUS_INVALID_INDEX);
	3965	+
	3966	+ /* Changes can only be made when controller is powered down */
	3967	+ if (hdev_is_powered(hdev))
	3968	+ return mgmt_cmd_status(sk, hdev->id,
	3969	+ MGMT_OP_SET_EXP_FEATURE,
	3970	+ MGMT_STATUS_NOT_POWERED);
	3971	+
	3972	+ /* Parameters are limited to a single octet */
	3973	+ if (data_len != MGMT_SET_EXP_FEATURE_SIZE + 1)
	3974	+ return mgmt_cmd_status(sk, hdev->id,
	3975	+ MGMT_OP_SET_EXP_FEATURE,
	3976	+ MGMT_STATUS_INVALID_PARAMS);
	3977	+
	3978	+ /* Only boolean on/off is supported */
	3979	+ if (cp->param[0] != 0x00 && cp->param[0] != 0x01)
	3980	+ return mgmt_cmd_status(sk, hdev->id,
	3981	+ MGMT_OP_SET_EXP_FEATURE,
	3982	+ MGMT_STATUS_INVALID_PARAMS);
	3983	+
	3984	+ val = !!cp->param[0];
	3985	+
	3986	+ if (val) {
	3987	+ changed = !hci_dev_test_flag(hdev,
	3988	+ HCI_ENABLE_LL_PRIVACY);
	3989	+ hci_dev_set_flag(hdev, HCI_ENABLE_LL_PRIVACY);
	3990	+ hci_dev_clear_flag(hdev, HCI_ADVERTISING);
	3991	+
	3992	+ /* Enable LL privacy + supported settings changed */
	3993	+ flags = BIT(0) \| BIT(1);
	3994	+ } else {
	3995	+ changed = hci_dev_test_flag(hdev,
	3996	+ HCI_ENABLE_LL_PRIVACY);
	3997	+ hci_dev_clear_flag(hdev, HCI_ENABLE_LL_PRIVACY);
	3998	+
	3999	+ /* Disable LL privacy + supported settings changed */
	4000	+ flags = BIT(1);
	4001	+ }
	4002	+
	4003	+ memcpy(rp.uuid, rpa_resolution_uuid, 16);
	4004	+ rp.flags = cpu_to_le32(flags);
	4005	+
	4006	+ hci_sock_set_flag(sk, HCI_MGMT_EXP_FEATURE_EVENTS);
	4007	+
	4008	+ err = mgmt_cmd_complete(sk, hdev->id,
	4009	+ MGMT_OP_SET_EXP_FEATURE, 0,
	4010	+ &rp, sizeof(rp));
	4011	+
	4012	+ if (changed)
	4013	+ exp_ll_privacy_feature_changed(val, hdev, sk);
	4014	+
	4015	+ return err;
	4016	+ }
	4017	+
	4018	+ return mgmt_cmd_status(sk, hdev ? hdev->id : MGMT_INDEX_NONE,
	4019	+ MGMT_OP_SET_EXP_FEATURE,
	4020	+ MGMT_STATUS_NOT_SUPPORTED);
	4021	+}
	4022	+
	4023	+#define SUPPORTED_DEVICE_FLAGS() ((1U << HCI_CONN_FLAG_MAX) - 1)
	4024	+
	4025	+static int get_device_flags(struct sock sk, struct hci_dev hdev, void *data,
	4026	+ u16 data_len)
	4027	+{
	4028	+ struct mgmt_cp_get_device_flags *cp = data;
	4029	+ struct mgmt_rp_get_device_flags rp;
	4030	+ struct bdaddr_list_with_flags *br_params;
	4031	+ struct hci_conn_params *params;
	4032	+ u32 supported_flags = SUPPORTED_DEVICE_FLAGS();
	4033	+ u32 current_flags = 0;
	4034	+ u8 status = MGMT_STATUS_INVALID_PARAMS;
	4035	+
	4036	+ bt_dev_dbg(hdev, "Get device flags %pMR (type 0x%x)\n",
	4037	+ &cp->addr.bdaddr, cp->addr.type);
	4038	+
	4039	+ hci_dev_lock(hdev);
	4040	+
	4041	+ memset(&rp, 0, sizeof(rp));
	4042	+
	4043	+ if (cp->addr.type == BDADDR_BREDR) {
	4044	+ br_params = hci_bdaddr_list_lookup_with_flags(&hdev->whitelist,
	4045	+ &cp->addr.bdaddr,
	4046	+ cp->addr.type);
	4047	+ if (!br_params)
	4048	+ goto done;
	4049	+
	4050	+ current_flags = br_params->current_flags;
	4051	+ } else {
	4052	+ params = hci_conn_params_lookup(hdev, &cp->addr.bdaddr,
	4053	+ le_addr_type(cp->addr.type));
	4054	+
	4055	+ if (!params)
	4056	+ goto done;
	4057	+
	4058	+ current_flags = params->current_flags;
	4059	+ }
	4060	+
	4061	+ bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
	4062	+ rp.addr.type = cp->addr.type;
	4063	+ rp.supported_flags = cpu_to_le32(supported_flags);
	4064	+ rp.current_flags = cpu_to_le32(current_flags);
	4065	+
	4066	+ status = MGMT_STATUS_SUCCESS;
	4067	+
	4068	+done:
	4069	+ hci_dev_unlock(hdev);
	4070	+
	4071	+ return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_GET_DEVICE_FLAGS, status,
	4072	+ &rp, sizeof(rp));
	4073	+}
	4074	+
	4075	+static void device_flags_changed(struct sock sk, struct hci_dev hdev,
	4076	+ bdaddr_t *bdaddr, u8 bdaddr_type,
	4077	+ u32 supported_flags, u32 current_flags)
	4078	+{
	4079	+ struct mgmt_ev_device_flags_changed ev;
	4080	+
	4081	+ bacpy(&ev.addr.bdaddr, bdaddr);
	4082	+ ev.addr.type = bdaddr_type;
	4083	+ ev.supported_flags = cpu_to_le32(supported_flags);
	4084	+ ev.current_flags = cpu_to_le32(current_flags);
	4085	+
	4086	+ mgmt_event(MGMT_EV_DEVICE_FLAGS_CHANGED, hdev, &ev, sizeof(ev), sk);
	4087	+}
	4088	+
	4089	+static int set_device_flags(struct sock sk, struct hci_dev hdev, void *data,
	4090	+ u16 len)
	4091	+{
	4092	+ struct mgmt_cp_set_device_flags *cp = data;
	4093	+ struct bdaddr_list_with_flags *br_params;
	4094	+ struct hci_conn_params *params;
	4095	+ u8 status = MGMT_STATUS_INVALID_PARAMS;
	4096	+ u32 supported_flags = SUPPORTED_DEVICE_FLAGS();
	4097	+ u32 current_flags = __le32_to_cpu(cp->current_flags);
	4098	+
	4099	+ bt_dev_dbg(hdev, "Set device flags %pMR (type 0x%x) = 0x%x",
	4100	+ &cp->addr.bdaddr, cp->addr.type,
	4101	+ __le32_to_cpu(current_flags));
	4102	+
	4103	+ if ((supported_flags \| current_flags) != supported_flags) {
	4104	+ bt_dev_warn(hdev, "Bad flag given (0x%x) vs supported (0x%0x)",
	4105	+ current_flags, supported_flags);
	4106	+ goto done;
	4107	+ }
	4108	+
	4109	+ hci_dev_lock(hdev);
	4110	+
	4111	+ if (cp->addr.type == BDADDR_BREDR) {
	4112	+ br_params = hci_bdaddr_list_lookup_with_flags(&hdev->whitelist,
	4113	+ &cp->addr.bdaddr,
	4114	+ cp->addr.type);
	4115	+
	4116	+ if (br_params) {
	4117	+ br_params->current_flags = current_flags;
	4118	+ status = MGMT_STATUS_SUCCESS;
	4119	+ } else {
	4120	+ bt_dev_warn(hdev, "No such BR/EDR device %pMR (0x%x)",
	4121	+ &cp->addr.bdaddr, cp->addr.type);
	4122	+ }
	4123	+ } else {
	4124	+ params = hci_conn_params_lookup(hdev, &cp->addr.bdaddr,
	4125	+ le_addr_type(cp->addr.type));
	4126	+ if (params) {
	4127	+ params->current_flags = current_flags;
	4128	+ status = MGMT_STATUS_SUCCESS;
	4129	+ } else {
	4130	+ bt_dev_warn(hdev, "No such LE device %pMR (0x%x)",
	4131	+ &cp->addr.bdaddr,
	4132	+ le_addr_type(cp->addr.type));
	4133	+ }
	4134	+ }
	4135	+
	4136	+done:
	4137	+ hci_dev_unlock(hdev);
	4138	+
	4139	+ if (status == MGMT_STATUS_SUCCESS)
	4140	+ device_flags_changed(sk, hdev, &cp->addr.bdaddr, cp->addr.type,
	4141	+ supported_flags, current_flags);
	4142	+
	4143	+ return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_SET_DEVICE_FLAGS, status,
	4144	+ &cp->addr, sizeof(cp->addr));
	4145	+}
	4146	+
	4147	+static void mgmt_adv_monitor_added(struct sock sk, struct hci_dev hdev,
	4148	+ u16 handle)
	4149	+{
	4150	+ struct mgmt_ev_adv_monitor_added ev;
	4151	+
	4152	+ ev.monitor_handle = cpu_to_le16(handle);
	4153	+
	4154	+ mgmt_event(MGMT_EV_ADV_MONITOR_ADDED, hdev, &ev, sizeof(ev), sk);
	4155	+}
	4156	+
	4157	+static void mgmt_adv_monitor_removed(struct sock sk, struct hci_dev hdev,
	4158	+ u16 handle)
	4159	+{
	4160	+ struct mgmt_ev_adv_monitor_added ev;
	4161	+
	4162	+ ev.monitor_handle = cpu_to_le16(handle);
	4163	+
	4164	+ mgmt_event(MGMT_EV_ADV_MONITOR_REMOVED, hdev, &ev, sizeof(ev), sk);
	4165	+}
	4166	+
	4167	+static int read_adv_mon_features(struct sock sk, struct hci_dev hdev,
	4168	+ void *data, u16 len)
	4169	+{
	4170	+ struct adv_monitor *monitor = NULL;
	4171	+ struct mgmt_rp_read_adv_monitor_features *rp = NULL;
	4172	+ int handle, err;
	4173	+ size_t rp_size = 0;
	4174	+ __u32 supported = 0;
	4175	+ __u16 num_handles = 0;
	4176	+ __u16 handles[HCI_MAX_ADV_MONITOR_NUM_HANDLES];
	4177	+
	4178	+ BT_DBG("request for %s", hdev->name);
	4179	+
	4180	+ hci_dev_lock(hdev);
	4181	+
	4182	+ if (msft_get_features(hdev) & MSFT_FEATURE_MASK_LE_ADV_MONITOR)
	4183	+ supported \|= MGMT_ADV_MONITOR_FEATURE_MASK_OR_PATTERNS;
	4184	+
	4185	+ idr_for_each_entry(&hdev->adv_monitors_idr, monitor, handle) {
	4186	+ handles[num_handles++] = monitor->handle;
	4187	+ }
	4188	+
	4189	+ hci_dev_unlock(hdev);
	4190	+
	4191	+ rp_size = sizeof(rp) + (num_handles sizeof(u16));
	4192	+ rp = kmalloc(rp_size, GFP_KERNEL);
	4193	+ if (!rp)
	4194	+ return -ENOMEM;
	4195	+
	4196	+ /* Once controller-based monitoring is in place, the enabled_features
	4197	+ * should reflect the use.
	4198	+ */
	4199	+ rp->supported_features = cpu_to_le32(supported);
	4200	+ rp->enabled_features = 0;
	4201	+ rp->max_num_handles = cpu_to_le16(HCI_MAX_ADV_MONITOR_NUM_HANDLES);
	4202	+ rp->max_num_patterns = HCI_MAX_ADV_MONITOR_NUM_PATTERNS;
	4203	+ rp->num_handles = cpu_to_le16(num_handles);
	4204	+ if (num_handles)
	4205	+ memcpy(&rp->handles, &handles, (num_handles * sizeof(u16)));
	4206	+
	4207	+ err = mgmt_cmd_complete(sk, hdev->id,
	4208	+ MGMT_OP_READ_ADV_MONITOR_FEATURES,
	4209	+ MGMT_STATUS_SUCCESS, rp, rp_size);
	4210	+
	4211	+ kfree(rp);
	4212	+
	4213	+ return err;
	4214	+}
	4215	+
	4216	+static int add_adv_patterns_monitor(struct sock sk, struct hci_dev hdev,
	4217	+ void *data, u16 len)
	4218	+{
	4219	+ struct mgmt_cp_add_adv_patterns_monitor *cp = data;
	4220	+ struct mgmt_rp_add_adv_patterns_monitor rp;
	4221	+ struct adv_monitor *m = NULL;
	4222	+ struct adv_pattern *p = NULL;
	4223	+ unsigned int mp_cnt = 0, prev_adv_monitors_cnt;
	4224	+ __u8 cp_ofst = 0, cp_len = 0;
	4225	+ int err, i;
	4226	+
	4227	+ BT_DBG("request for %s", hdev->name);
	4228	+
	4229	+ if (len <= sizeof(*cp) \|\| cp->pattern_count == 0) {
	4230	+ err = mgmt_cmd_status(sk, hdev->id,
	4231	+ MGMT_OP_ADD_ADV_PATTERNS_MONITOR,
	4232	+ MGMT_STATUS_INVALID_PARAMS);
	4233	+ goto failed;
	4234	+ }
	4235	+
	4236	+ m = kmalloc(sizeof(*m), GFP_KERNEL);
	4237	+ if (!m) {
	4238	+ err = -ENOMEM;
	4239	+ goto failed;
	4240	+ }
	4241	+
	4242	+ INIT_LIST_HEAD(&m->patterns);
	4243	+ m->active = false;
	4244	+
	4245	+ for (i = 0; i < cp->pattern_count; i++) {
	4246	+ if (++mp_cnt > HCI_MAX_ADV_MONITOR_NUM_PATTERNS) {
	4247	+ err = mgmt_cmd_status(sk, hdev->id,
	4248	+ MGMT_OP_ADD_ADV_PATTERNS_MONITOR,
	4249	+ MGMT_STATUS_INVALID_PARAMS);
	4250	+ goto failed;
	4251	+ }
	4252	+
	4253	+ cp_ofst = cp->patterns[i].offset;
	4254	+ cp_len = cp->patterns[i].length;
	4255	+ if (cp_ofst >= HCI_MAX_AD_LENGTH \|\|
	4256	+ cp_len > HCI_MAX_AD_LENGTH \|\|
	4257	+ (cp_ofst + cp_len) > HCI_MAX_AD_LENGTH) {
	4258	+ err = mgmt_cmd_status(sk, hdev->id,
	4259	+ MGMT_OP_ADD_ADV_PATTERNS_MONITOR,
	4260	+ MGMT_STATUS_INVALID_PARAMS);
	4261	+ goto failed;
	4262	+ }
	4263	+
	4264	+ p = kmalloc(sizeof(*p), GFP_KERNEL);
	4265	+ if (!p) {
	4266	+ err = -ENOMEM;
	4267	+ goto failed;
	4268	+ }
	4269	+
	4270	+ p->ad_type = cp->patterns[i].ad_type;
	4271	+ p->offset = cp->patterns[i].offset;
	4272	+ p->length = cp->patterns[i].length;
	4273	+ memcpy(p->value, cp->patterns[i].value, p->length);
	4274	+
	4275	+ INIT_LIST_HEAD(&p->list);
	4276	+ list_add(&p->list, &m->patterns);
	4277	+ }
	4278	+
	4279	+ if (mp_cnt != cp->pattern_count) {
	4280	+ err = mgmt_cmd_status(sk, hdev->id,
	4281	+ MGMT_OP_ADD_ADV_PATTERNS_MONITOR,
	4282	+ MGMT_STATUS_INVALID_PARAMS);
	4283	+ goto failed;
	4284	+ }
	4285	+
	4286	+ hci_dev_lock(hdev);
	4287	+
	4288	+ prev_adv_monitors_cnt = hdev->adv_monitors_cnt;
	4289	+
	4290	+ err = hci_add_adv_monitor(hdev, m);
	4291	+ if (err) {
	4292	+ if (err == -ENOSPC) {
	4293	+ mgmt_cmd_status(sk, hdev->id,
	4294	+ MGMT_OP_ADD_ADV_PATTERNS_MONITOR,
	4295	+ MGMT_STATUS_NO_RESOURCES);
	4296	+ }
	4297	+ goto unlock;
	4298	+ }
	4299	+
	4300	+ if (hdev->adv_monitors_cnt > prev_adv_monitors_cnt)
	4301	+ mgmt_adv_monitor_added(sk, hdev, m->handle);
	4302	+
	4303	+ hci_dev_unlock(hdev);
	4304	+
	4305	+ rp.monitor_handle = cpu_to_le16(m->handle);
	4306	+
	4307	+ return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_ADV_PATTERNS_MONITOR,
	4308	+ MGMT_STATUS_SUCCESS, &rp, sizeof(rp));
	4309	+
	4310	+unlock:
	4311	+ hci_dev_unlock(hdev);
	4312	+
	4313	+failed:
	4314	+ hci_free_adv_monitor(m);
	4315	+ return err;
	4316	+}
	4317	+
	4318	+static int remove_adv_monitor(struct sock sk, struct hci_dev hdev,
	4319	+ void *data, u16 len)
	4320	+{
	4321	+ struct mgmt_cp_remove_adv_monitor *cp = data;
	4322	+ struct mgmt_rp_remove_adv_monitor rp;
	4323	+ unsigned int prev_adv_monitors_cnt;
	4324	+ u16 handle;
	4325	+ int err;
	4326	+
	4327	+ BT_DBG("request for %s", hdev->name);
	4328	+
	4329	+ hci_dev_lock(hdev);
	4330	+
	4331	+ handle = __le16_to_cpu(cp->monitor_handle);
	4332	+ prev_adv_monitors_cnt = hdev->adv_monitors_cnt;
	4333	+
	4334	+ err = hci_remove_adv_monitor(hdev, handle);
	4335	+ if (err == -ENOENT) {
	4336	+ err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_REMOVE_ADV_MONITOR,
	4337	+ MGMT_STATUS_INVALID_INDEX);
	4338	+ goto unlock;
	4339	+ }
	4340	+
	4341	+ if (hdev->adv_monitors_cnt < prev_adv_monitors_cnt)
	4342	+ mgmt_adv_monitor_removed(sk, hdev, handle);
	4343	+
	4344	+ hci_dev_unlock(hdev);
	4345	+
	4346	+ rp.monitor_handle = cp->monitor_handle;
	4347	+
	4348	+ return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_ADV_MONITOR,
	4349	+ MGMT_STATUS_SUCCESS, &rp, sizeof(rp));
	4350	+
	4351	+unlock:
	4352	+ hci_dev_unlock(hdev);
	4353	+ return err;
	4354	+}
	4355	+
3547	4356	static void read_local_oob_data_complete(struct hci_dev *hdev, u8 status,
3548	4357	u16 opcode, struct sk_buff *skb)
3549	4358	{
..	..	@@ -3551,7 +4360,7 @@
3551	4360	size_t rp_size = sizeof(mgmt_rp);
3552	4361	struct mgmt_pending_cmd *cmd;
3553	4362
3554		- BT_DBG("%s status %u", hdev->name, status);
	4363	+ bt_dev_dbg(hdev, "status %u", status);
3555	4364
3556	4365	cmd = pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev);
3557	4366	if (!cmd)
..	..	@@ -3610,7 +4419,7 @@
3610	4419	struct hci_request req;
3611	4420	int err;
3612	4421
3613		- BT_DBG("%s", hdev->name);
	4422	+ bt_dev_dbg(hdev, "sock %p", sk);
3614	4423
3615	4424	hci_dev_lock(hdev);
3616	4425
..	..	@@ -3660,7 +4469,7 @@
3660	4469	struct mgmt_addr_info *addr = data;
3661	4470	int err;
3662	4471
3663		- BT_DBG("%s ", hdev->name);
	4472	+ bt_dev_dbg(hdev, "sock %p", sk);
3664	4473
3665	4474	if (!bdaddr_type_is_valid(addr->type))
3666	4475	return mgmt_cmd_complete(sk, hdev->id,
..	..	@@ -3769,7 +4578,7 @@
3769	4578	u8 status;
3770	4579	int err;
3771	4580
3772		- BT_DBG("%s", hdev->name);
	4581	+ bt_dev_dbg(hdev, "sock %p", sk);
3773	4582
3774	4583	if (cp->addr.type != BDADDR_BREDR)
3775	4584	return mgmt_cmd_complete(sk, hdev->id,
..	..	@@ -3803,7 +4612,7 @@
3803	4612	{
3804	4613	struct mgmt_pending_cmd *cmd;
3805	4614
3806		- BT_DBG("status %d", status);
	4615	+ bt_dev_dbg(hdev, "status %d", status);
3807	4616
3808	4617	hci_dev_lock(hdev);
3809	4618
..	..	@@ -3820,6 +4629,13 @@
3820	4629	}
3821	4630
3822	4631	hci_dev_unlock(hdev);
	4632	+
	4633	+ /* Handle suspend notifier */
	4634	+ if (test_and_clear_bit(SUSPEND_UNPAUSE_DISCOVERY,
	4635	+ hdev->suspend_tasks)) {
	4636	+ bt_dev_dbg(hdev, "Unpaused discovery");
	4637	+ wake_up(&hdev->suspend_wait_q);
	4638	+ }
3823	4639	}
3824	4640
3825	4641	static bool discovery_type_is_valid(struct hci_dev *hdev, uint8_t type,
..	..	@@ -3835,7 +4651,7 @@
3835	4651	*mgmt_status = mgmt_le_support(hdev);
3836	4652	if (*mgmt_status)
3837	4653	return false;
3838		- /* Intentional fall-through */
	4654	+ fallthrough;
3839	4655	case DISCOV_TYPE_BREDR:
3840	4656	*mgmt_status = mgmt_bredr_support(hdev);
3841	4657	if (*mgmt_status)
..	..	@@ -3857,7 +4673,7 @@
3857	4673	u8 status;
3858	4674	int err;
3859	4675
3860		- BT_DBG("%s", hdev->name);
	4676	+ bt_dev_dbg(hdev, "sock %p", sk);
3861	4677
3862	4678	hci_dev_lock(hdev);
3863	4679
..	..	@@ -3877,6 +4693,13 @@
3877	4693
3878	4694	if (!discovery_type_is_valid(hdev, cp->type, &status)) {
3879	4695	err = mgmt_cmd_complete(sk, hdev->id, op, status,
	4696	+ &cp->type, sizeof(cp->type));
	4697	+ goto failed;
	4698	+ }
	4699	+
	4700	+ /* Can't start discovery when it is paused */
	4701	+ if (hdev->discovery_paused) {
	4702	+ err = mgmt_cmd_complete(sk, hdev->id, op, MGMT_STATUS_BUSY,
3880	4703	&cp->type, sizeof(cp->type));
3881	4704	goto failed;
3882	4705	}
..	..	@@ -3942,7 +4765,7 @@
3942	4765	u8 status;
3943	4766	int err;
3944	4767
3945		- BT_DBG("%s", hdev->name);
	4768	+ bt_dev_dbg(hdev, "sock %p", sk);
3946	4769
3947	4770	hci_dev_lock(hdev);
3948	4771
..	..	@@ -4037,7 +4860,7 @@
4037	4860	{
4038	4861	struct mgmt_pending_cmd *cmd;
4039	4862
4040		- BT_DBG("status %d", status);
	4863	+ bt_dev_dbg(hdev, "status %d", status);
4041	4864
4042	4865	hci_dev_lock(hdev);
4043	4866
..	..	@@ -4048,6 +4871,12 @@
4048	4871	}
4049	4872
4050	4873	hci_dev_unlock(hdev);
	4874	+
	4875	+ /* Handle suspend notifier */
	4876	+ if (test_and_clear_bit(SUSPEND_PAUSE_DISCOVERY, hdev->suspend_tasks)) {
	4877	+ bt_dev_dbg(hdev, "Paused discovery");
	4878	+ wake_up(&hdev->suspend_wait_q);
	4879	+ }
4051	4880	}
4052	4881
4053	4882	static int stop_discovery(struct sock sk, struct hci_dev hdev, void *data,
..	..	@@ -4057,7 +4886,7 @@
4057	4886	struct mgmt_pending_cmd *cmd;
4058	4887	int err;
4059	4888
4060		- BT_DBG("%s", hdev->name);
	4889	+ bt_dev_dbg(hdev, "sock %p", sk);
4061	4890
4062	4891	hci_dev_lock(hdev);
4063	4892
..	..	@@ -4099,7 +4928,7 @@
4099	4928	struct inquiry_entry *e;
4100	4929	int err;
4101	4930
4102		- BT_DBG("%s", hdev->name);
	4931	+ bt_dev_dbg(hdev, "sock %p", sk);
4103	4932
4104	4933	hci_dev_lock(hdev);
4105	4934
..	..	@@ -4141,7 +4970,7 @@
4141	4970	u8 status;
4142	4971	int err;
4143	4972
4144		- BT_DBG("%s", hdev->name);
	4973	+ bt_dev_dbg(hdev, "sock %p", sk);
4145	4974
4146	4975	if (!bdaddr_type_is_valid(cp->addr.type))
4147	4976	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_BLOCK_DEVICE,
..	..	@@ -4177,7 +5006,7 @@
4177	5006	u8 status;
4178	5007	int err;
4179	5008
4180		- BT_DBG("%s", hdev->name);
	5009	+ bt_dev_dbg(hdev, "sock %p", sk);
4181	5010
4182	5011	if (!bdaddr_type_is_valid(cp->addr.type))
4183	5012	return mgmt_cmd_complete(sk, hdev->id, MGMT_OP_UNBLOCK_DEVICE,
..	..	@@ -4214,7 +5043,7 @@
4214	5043	int err;
4215	5044	__u16 source;
4216	5045
4217		- BT_DBG("%s", hdev->name);
	5046	+ bt_dev_dbg(hdev, "sock %p", sk);
4218	5047
4219	5048	source = __le16_to_cpu(cp->source);
4220	5049
..	..	@@ -4244,7 +5073,7 @@
4244	5073	static void enable_advertising_instance(struct hci_dev *hdev, u8 status,
4245	5074	u16 opcode)
4246	5075	{
4247		- BT_DBG("status %d", status);
	5076	+ bt_dev_dbg(hdev, "status %d", status);
4248	5077	}
4249	5078
4250	5079	static void set_advertising_complete(struct hci_dev *hdev, u8 status,
..	..	@@ -4278,6 +5107,17 @@
4278	5107
4279	5108	if (match.sk)
4280	5109	sock_put(match.sk);
	5110	+
	5111	+ /* Handle suspend notifier */
	5112	+ if (test_and_clear_bit(SUSPEND_PAUSE_ADVERTISING,
	5113	+ hdev->suspend_tasks)) {
	5114	+ bt_dev_dbg(hdev, "Paused advertising");
	5115	+ wake_up(&hdev->suspend_wait_q);
	5116	+ } else if (test_and_clear_bit(SUSPEND_UNPAUSE_ADVERTISING,
	5117	+ hdev->suspend_tasks)) {
	5118	+ bt_dev_dbg(hdev, "Unpaused advertising");
	5119	+ wake_up(&hdev->suspend_wait_q);
	5120	+ }
4281	5121
4282	5122	/* If "Set Advertising" was just disabled and instance advertising was
4283	5123	* set up earlier, then re-enable multi-instance advertising.
..	..	@@ -4319,16 +5159,27 @@
4319	5159	u8 val, status;
4320	5160	int err;
4321	5161
4322		- BT_DBG("request for %s", hdev->name);
	5162	+ bt_dev_dbg(hdev, "sock %p", sk);
4323	5163
4324	5164	status = mgmt_le_support(hdev);
4325	5165	if (status)
4326	5166	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
4327	5167	status);
4328	5168
	5169	+ /* Enabling the experimental LL Privay support disables support for
	5170	+ * advertising.
	5171	+ */
	5172	+ if (hci_dev_test_flag(hdev, HCI_ENABLE_LL_PRIVACY))
	5173	+ return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
	5174	+ MGMT_STATUS_NOT_SUPPORTED);
	5175	+
4329	5176	if (cp->val != 0x00 && cp->val != 0x01 && cp->val != 0x02)
4330	5177	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
4331	5178	MGMT_STATUS_INVALID_PARAMS);
	5179	+
	5180	+ if (hdev->advertising_paused)
	5181	+ return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
	5182	+ MGMT_STATUS_BUSY);
4332	5183
4333	5184	hci_dev_lock(hdev);
4334	5185
..	..	@@ -4424,7 +5275,7 @@
4424	5275	struct mgmt_cp_set_static_address *cp = data;
4425	5276	int err;
4426	5277
4427		- BT_DBG("%s", hdev->name);
	5278	+ bt_dev_dbg(hdev, "sock %p", sk);
4428	5279
4429	5280	if (!lmp_le_capable(hdev))
4430	5281	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_STATIC_ADDRESS,
..	..	@@ -4469,7 +5320,7 @@
4469	5320	__u16 interval, window;
4470	5321	int err;
4471	5322
4472		- BT_DBG("%s", hdev->name);
	5323	+ bt_dev_dbg(hdev, "sock %p", sk);
4473	5324
4474	5325	if (!lmp_le_capable(hdev))
4475	5326	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_SCAN_PARAMS,
..	..	@@ -4508,7 +5359,7 @@
4508	5359
4509	5360	hci_req_init(&req, hdev);
4510	5361
4511		- hci_req_add_le_scan_disable(&req);
	5362	+ hci_req_add_le_scan_disable(&req, false);
4512	5363	hci_req_add_le_passive_scan(&req);
4513	5364
4514	5365	hci_req_run(&req, NULL);
..	..	@@ -4524,7 +5375,7 @@
4524	5375	{
4525	5376	struct mgmt_pending_cmd *cmd;
4526	5377
4527		- BT_DBG("status 0x%02x", status);
	5378	+ bt_dev_dbg(hdev, "status 0x%02x", status);
4528	5379
4529	5380	hci_dev_lock(hdev);
4530	5381
..	..	@@ -4561,7 +5412,7 @@
4561	5412	struct hci_request req;
4562	5413	int err;
4563	5414
4564		- BT_DBG("%s", hdev->name);
	5415	+ bt_dev_dbg(hdev, "sock %p", sk);
4565	5416
4566	5417	if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED) \|\|
4567	5418	hdev->hci_ver < BLUETOOTH_VER_1_2)
..	..	@@ -4622,7 +5473,7 @@
4622	5473	{
4623	5474	struct mgmt_pending_cmd *cmd;
4624	5475
4625		- BT_DBG("status 0x%02x", status);
	5476	+ bt_dev_dbg(hdev, "status 0x%02x", status);
4626	5477
4627	5478	hci_dev_lock(hdev);
4628	5479
..	..	@@ -4657,7 +5508,7 @@
4657	5508	struct hci_request req;
4658	5509	int err;
4659	5510
4660		- BT_DBG("request for %s", hdev->name);
	5511	+ bt_dev_dbg(hdev, "sock %p", sk);
4661	5512
4662	5513	if (!lmp_bredr_capable(hdev) \|\| !lmp_le_capable(hdev))
4663	5514	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
..	..	@@ -4767,7 +5618,7 @@
4767	5618	struct mgmt_pending_cmd *cmd;
4768	5619	struct mgmt_mode *cp;
4769	5620
4770		- BT_DBG("%s status %u", hdev->name, status);
	5621	+ bt_dev_dbg(hdev, "status %u", status);
4771	5622
4772	5623	hci_dev_lock(hdev);
4773	5624
..	..	@@ -4816,7 +5667,7 @@
4816	5667	u8 val;
4817	5668	int err;
4818	5669
4819		- BT_DBG("request for %s", hdev->name);
	5670	+ bt_dev_dbg(hdev, "sock %p", sk);
4820	5671
4821	5672	if (!lmp_sc_capable(hdev) &&
4822	5673	!hci_dev_test_flag(hdev, HCI_LE_ENABLED))
..	..	@@ -4902,7 +5753,7 @@
4902	5753	bool changed, use_changed;
4903	5754	int err;
4904	5755
4905		- BT_DBG("request for %s", hdev->name);
	5756	+ bt_dev_dbg(hdev, "sock %p", sk);
4906	5757
4907	5758	if (cp->val != 0x00 && cp->val != 0x01 && cp->val != 0x02)
4908	5759	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_DEBUG_KEYS,
..	..	@@ -4949,7 +5800,7 @@
4949	5800	bool changed;
4950	5801	int err;
4951	5802
4952		- BT_DBG("request for %s", hdev->name);
	5803	+ bt_dev_dbg(hdev, "sock %p", sk);
4953	5804
4954	5805	if (!lmp_le_capable(hdev))
4955	5806	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_PRIVACY,
..	..	@@ -5024,7 +5875,7 @@
5024	5875	u16 irk_count, expected_len;
5025	5876	int i, err;
5026	5877
5027		- BT_DBG("request for %s", hdev->name);
	5878	+ bt_dev_dbg(hdev, "sock %p", sk);
5028	5879
5029	5880	if (!lmp_le_capable(hdev))
5030	5881	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_IRKS,
..	..	@@ -5038,7 +5889,7 @@
5038	5889	MGMT_STATUS_INVALID_PARAMS);
5039	5890	}
5040	5891
5041		- expected_len = sizeof(cp) + irk_count sizeof(struct mgmt_irk_info);
	5892	+ expected_len = struct_size(cp, irks, irk_count);
5042	5893	if (expected_len != len) {
5043	5894	bt_dev_err(hdev, "load_irks: expected %u bytes, got %u bytes",
5044	5895	expected_len, len);
..	..	@@ -5046,7 +5897,7 @@
5046	5897	MGMT_STATUS_INVALID_PARAMS);
5047	5898	}
5048	5899
5049		- BT_DBG("%s irk_count %u", hdev->name, irk_count);
	5900	+ bt_dev_dbg(hdev, "irk_count %u", irk_count);
5050	5901
5051	5902	for (i = 0; i < irk_count; i++) {
5052	5903	struct mgmt_irk_info *key = &cp->irks[i];
..	..	@@ -5063,6 +5914,14 @@
5063	5914
5064	5915	for (i = 0; i < irk_count; i++) {
5065	5916	struct mgmt_irk_info *irk = &cp->irks[i];
	5917	+
	5918	+ if (hci_is_blocked_key(hdev,
	5919	+ HCI_BLOCKED_KEY_TYPE_IRK,
	5920	+ irk->val)) {
	5921	+ bt_dev_warn(hdev, "Skipping blocked IRK for %pMR",
	5922	+ &irk->addr.bdaddr);
	5923	+ continue;
	5924	+ }
5066	5925
5067	5926	hci_add_irk(hdev, &irk->addr.bdaddr,
5068	5927	le_addr_type(irk->addr.type), irk->val,
..	..	@@ -5106,7 +5965,7 @@
5106	5965	u16 key_count, expected_len;
5107	5966	int i, err;
5108	5967
5109		- BT_DBG("request for %s", hdev->name);
	5968	+ bt_dev_dbg(hdev, "sock %p", sk);
5110	5969
5111	5970	if (!lmp_le_capable(hdev))
5112	5971	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_LOAD_LONG_TERM_KEYS,
..	..	@@ -5120,8 +5979,7 @@
5120	5979	MGMT_STATUS_INVALID_PARAMS);
5121	5980	}
5122	5981
5123		- expected_len = sizeof(cp) + key_count
5124		- sizeof(struct mgmt_ltk_info);
	5982	+ expected_len = struct_size(cp, keys, key_count);
5125	5983	if (expected_len != len) {
5126	5984	bt_dev_err(hdev, "load_keys: expected %u bytes, got %u bytes",
5127	5985	expected_len, len);
..	..	@@ -5129,7 +5987,7 @@
5129	5987	MGMT_STATUS_INVALID_PARAMS);
5130	5988	}
5131	5989
5132		- BT_DBG("%s key_count %u", hdev->name, key_count);
	5990	+ bt_dev_dbg(hdev, "key_count %u", key_count);
5133	5991
5134	5992	for (i = 0; i < key_count; i++) {
5135	5993	struct mgmt_ltk_info *key = &cp->keys[i];
..	..	@@ -5147,6 +6005,14 @@
5147	6005	for (i = 0; i < key_count; i++) {
5148	6006	struct mgmt_ltk_info *key = &cp->keys[i];
5149	6007	u8 type, authenticated;
	6008	+
	6009	+ if (hci_is_blocked_key(hdev,
	6010	+ HCI_BLOCKED_KEY_TYPE_LTK,
	6011	+ key->val)) {
	6012	+ bt_dev_warn(hdev, "Skipping blocked LTK for %pMR",
	6013	+ &key->addr.bdaddr);
	6014	+ continue;
	6015	+ }
5150	6016
5151	6017	switch (key->type) {
5152	6018	case MGMT_LTK_UNAUTHENTICATED:
..	..	@@ -5168,7 +6034,7 @@
5168	6034	case MGMT_LTK_P256_DEBUG:
5169	6035	authenticated = 0x00;
5170	6036	type = SMP_LTK_P256_DEBUG;
5171		- /* fall through */
	6037	+ fallthrough;
5172	6038	default:
5173	6039	continue;
5174	6040	}
..	..	@@ -5222,7 +6088,7 @@
5222	6088	u16 handle;
5223	6089	u8 status;
5224	6090
5225		- BT_DBG("status 0x%02x", hci_status);
	6091	+ bt_dev_dbg(hdev, "status 0x%02x", hci_status);
5226	6092
5227	6093	hci_dev_lock(hdev);
5228	6094
..	..	@@ -5276,7 +6142,7 @@
5276	6142	unsigned long conn_info_age;
5277	6143	int err = 0;
5278	6144
5279		- BT_DBG("%s", hdev->name);
	6145	+ bt_dev_dbg(hdev, "sock %p", sk);
5280	6146
5281	6147	memset(&rp, 0, sizeof(rp));
5282	6148	bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
..	..	@@ -5430,7 +6296,7 @@
5430	6296	struct mgmt_pending_cmd *cmd;
5431	6297	struct hci_conn *conn;
5432	6298
5433		- BT_DBG("%s status %u", hdev->name, status);
	6299	+ bt_dev_dbg(hdev, "status %u", status);
5434	6300
5435	6301	hci_dev_lock(hdev);
5436	6302
..	..	@@ -5467,7 +6333,7 @@
5467	6333	struct hci_conn *conn;
5468	6334	int err;
5469	6335
5470		- BT_DBG("%s", hdev->name);
	6336	+ bt_dev_dbg(hdev, "sock %p", sk);
5471	6337
5472	6338	memset(&rp, 0, sizeof(rp));
5473	6339	bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
..	..	@@ -5588,8 +6454,8 @@
5588	6454
5589	6455	params->auto_connect = auto_connect;
5590	6456
5591		- BT_DBG("addr %pMR (type %u) auto_connect %u", addr, addr_type,
5592		- auto_connect);
	6457	+ bt_dev_dbg(hdev, "addr %pMR (type %u) auto_connect %u",
	6458	+ addr, addr_type, auto_connect);
5593	6459
5594	6460	return 0;
5595	6461	}
..	..	@@ -5611,9 +6477,11 @@
5611	6477	{
5612	6478	struct mgmt_cp_add_device *cp = data;
5613	6479	u8 auto_conn, addr_type;
	6480	+ struct hci_conn_params *params;
5614	6481	int err;
	6482	+ u32 current_flags = 0;
5615	6483
5616		- BT_DBG("%s", hdev->name);
	6484	+ bt_dev_dbg(hdev, "sock %p", sk);
5617	6485
5618	6486	if (!bdaddr_type_is_valid(cp->addr.type) \|\|
5619	6487	!bacmp(&cp->addr.bdaddr, BDADDR_ANY))
..	..	@@ -5638,8 +6506,9 @@
5638	6506	goto unlock;
5639	6507	}
5640	6508
5641		- err = hci_bdaddr_list_add(&hdev->whitelist, &cp->addr.bdaddr,
5642		- cp->addr.type);
	6509	+ err = hci_bdaddr_list_add_with_flags(&hdev->whitelist,
	6510	+ &cp->addr.bdaddr,
	6511	+ cp->addr.type, 0);
5643	6512	if (err)
5644	6513	goto unlock;
5645	6514
..	..	@@ -5678,12 +6547,19 @@
5678	6547	MGMT_STATUS_FAILED, &cp->addr,
5679	6548	sizeof(cp->addr));
5680	6549	goto unlock;
	6550	+ } else {
	6551	+ params = hci_conn_params_lookup(hdev, &cp->addr.bdaddr,
	6552	+ addr_type);
	6553	+ if (params)
	6554	+ current_flags = params->current_flags;
5681	6555	}
5682	6556
5683	6557	hci_update_background_scan(hdev);
5684	6558
5685	6559	added:
5686	6560	device_added(sk, hdev, &cp->addr.bdaddr, cp->addr.type, cp->action);
	6561	+ device_flags_changed(NULL, hdev, &cp->addr.bdaddr, cp->addr.type,
	6562	+ SUPPORTED_DEVICE_FLAGS(), current_flags);
5687	6563
5688	6564	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_DEVICE,
5689	6565	MGMT_STATUS_SUCCESS, &cp->addr,
..	..	@@ -5711,7 +6587,7 @@
5711	6587	struct mgmt_cp_remove_device *cp = data;
5712	6588	int err;
5713	6589
5714		- BT_DBG("%s", hdev->name);
	6590	+ bt_dev_dbg(hdev, "sock %p", sk);
5715	6591
5716	6592	hci_dev_lock(hdev);
5717	6593
..	..	@@ -5820,7 +6696,7 @@
5820	6696	kfree(p);
5821	6697	}
5822	6698
5823		- BT_DBG("All LE connection parameters were removed");
	6699	+ bt_dev_dbg(hdev, "All LE connection parameters were removed");
5824	6700
5825	6701	hci_update_background_scan(hdev);
5826	6702	}
..	..	@@ -5855,8 +6731,7 @@
5855	6731	MGMT_STATUS_INVALID_PARAMS);
5856	6732	}
5857	6733
5858		- expected_len = sizeof(cp) + param_count
5859		- sizeof(struct mgmt_conn_param);
	6734	+ expected_len = struct_size(cp, params, param_count);
5860	6735	if (expected_len != len) {
5861	6736	bt_dev_err(hdev, "load_conn_param: expected %u bytes, got %u bytes",
5862	6737	expected_len, len);
..	..	@@ -5864,7 +6739,7 @@
5864	6739	MGMT_STATUS_INVALID_PARAMS);
5865	6740	}
5866	6741
5867		- BT_DBG("%s param_count %u", hdev->name, param_count);
	6742	+ bt_dev_dbg(hdev, "param_count %u", param_count);
5868	6743
5869	6744	hci_dev_lock(hdev);
5870	6745
..	..	@@ -5876,8 +6751,8 @@
5876	6751	u16 min, max, latency, timeout;
5877	6752	u8 addr_type;
5878	6753
5879		- BT_DBG("Adding %pMR (type %u)", &param->addr.bdaddr,
5880		- param->addr.type);
	6754	+ bt_dev_dbg(hdev, "Adding %pMR (type %u)", &param->addr.bdaddr,
	6755	+ param->addr.type);
5881	6756
5882	6757	if (param->addr.type == BDADDR_LE_PUBLIC) {
5883	6758	addr_type = ADDR_LE_DEV_PUBLIC;
..	..	@@ -5893,8 +6768,8 @@
5893	6768	latency = le16_to_cpu(param->latency);
5894	6769	timeout = le16_to_cpu(param->timeout);
5895	6770
5896		- BT_DBG("min 0x%04x max 0x%04x latency 0x%04x timeout 0x%04x",
5897		- min, max, latency, timeout);
	6771	+ bt_dev_dbg(hdev, "min 0x%04x max 0x%04x latency 0x%04x timeout 0x%04x",
	6772	+ min, max, latency, timeout);
5898	6773
5899	6774	if (hci_check_conn_params(min, max, latency, timeout) < 0) {
5900	6775	bt_dev_err(hdev, "ignoring invalid connection parameters");
..	..	@@ -5927,7 +6802,7 @@
5927	6802	bool changed;
5928	6803	int err;
5929	6804
5930		- BT_DBG("%s", hdev->name);
	6805	+ bt_dev_dbg(hdev, "sock %p", sk);
5931	6806
5932	6807	if (hdev_is_powered(hdev))
5933	6808	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_EXTERNAL_CONFIG,
..	..	@@ -5983,7 +6858,7 @@
5983	6858	bool changed;
5984	6859	int err;
5985	6860
5986		- BT_DBG("%s", hdev->name);
	6861	+ bt_dev_dbg(hdev, "sock %p", sk);
5987	6862
5988	6863	if (hdev_is_powered(hdev))
5989	6864	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_PUBLIC_ADDRESS,
..	..	@@ -6038,7 +6913,7 @@
6038	6913	u16 eir_len;
6039	6914	int err;
6040	6915
6041		- BT_DBG("%s status %u", hdev->name, status);
	6916	+ bt_dev_dbg(hdev, "status %u", status);
6042	6917
6043	6918	cmd = pending_find(MGMT_OP_READ_LOCAL_OOB_EXT_DATA, hdev);
6044	6919	if (!cmd)
..	..	@@ -6177,7 +7052,7 @@
6177	7052	u8 status, flags, role, addr[7], hash[16], rand[16];
6178	7053	int err;
6179	7054
6180		- BT_DBG("%s", hdev->name);
	7055	+ bt_dev_dbg(hdev, "sock %p", sk);
6181	7056
6182	7057	if (hdev_is_powered(hdev)) {
6183	7058	switch (cp->type) {
..	..	@@ -6343,6 +7218,8 @@
6343	7218
6344	7219	if (ext_adv_capable(hdev)) {
6345	7220	flags \|= MGMT_ADV_FLAG_SEC_1M;
	7221	+ flags \|= MGMT_ADV_FLAG_HW_OFFLOAD;
	7222	+ flags \|= MGMT_ADV_FLAG_CAN_SET_TX_POWER;
6346	7223
6347	7224	if (hdev->le_features[1] & HCI_LE_PHY_2M)
6348	7225	flags \|= MGMT_ADV_FLAG_SEC_2M;
..	..	@@ -6364,11 +7241,18 @@
6364	7241	u32 supported_flags;
6365	7242	u8 *instance;
6366	7243
6367		- BT_DBG("%s", hdev->name);
	7244	+ bt_dev_dbg(hdev, "sock %p", sk);
6368	7245
6369	7246	if (!lmp_le_capable(hdev))
6370	7247	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_READ_ADV_FEATURES,
6371	7248	MGMT_STATUS_REJECTED);
	7249	+
	7250	+ /* Enabling the experimental LL Privay support disables support for
	7251	+ * advertising.
	7252	+ */
	7253	+ if (hci_dev_test_flag(hdev, HCI_ENABLE_LL_PRIVACY))
	7254	+ return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
	7255	+ MGMT_STATUS_NOT_SUPPORTED);
6372	7256
6373	7257	hci_dev_lock(hdev);
6374	7258
..	..	@@ -6384,7 +7268,7 @@
6384	7268	rp->supported_flags = cpu_to_le32(supported_flags);
6385	7269	rp->max_adv_data_len = HCI_MAX_AD_LENGTH;
6386	7270	rp->max_scan_rsp_len = HCI_MAX_AD_LENGTH;
6387		- rp->max_instances = HCI_MAX_ADV_INSTANCES;
	7271	+ rp->max_instances = hdev->le_num_of_adv_sets;
6388	7272	rp->num_instances = hdev->adv_instance_cnt;
6389	7273
6390	7274	instance = rp->instance;
..	..	@@ -6510,7 +7394,7 @@
6510	7394	struct adv_info adv_instance, n;
6511	7395	u8 instance;
6512	7396
6513		- BT_DBG("status %d", status);
	7397	+ bt_dev_dbg(hdev, "status %d", status);
6514	7398
6515	7399	hci_dev_lock(hdev);
6516	7400
..	..	@@ -6569,14 +7453,21 @@
6569	7453	struct mgmt_pending_cmd *cmd;
6570	7454	struct hci_request req;
6571	7455
6572		- BT_DBG("%s", hdev->name);
	7456	+ bt_dev_dbg(hdev, "sock %p", sk);
6573	7457
6574	7458	status = mgmt_le_support(hdev);
6575	7459	if (status)
6576	7460	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
6577	7461	status);
6578	7462
6579		- if (cp->instance < 1 \|\| cp->instance > HCI_MAX_ADV_INSTANCES)
	7463	+ /* Enabling the experimental LL Privay support disables support for
	7464	+ * advertising.
	7465	+ */
	7466	+ if (hci_dev_test_flag(hdev, HCI_ENABLE_LL_PRIVACY))
	7467	+ return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
	7468	+ MGMT_STATUS_NOT_SUPPORTED);
	7469	+
	7470	+ if (cp->instance < 1 \|\| cp->instance > hdev->le_num_of_adv_sets)
6580	7471	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
6581	7472	MGMT_STATUS_INVALID_PARAMS);
6582	7473
..	..	@@ -6687,8 +7578,11 @@
6687	7578	if (!err)
6688	7579	err = hci_req_run(&req, add_advertising_complete);
6689	7580
6690		- if (err < 0)
	7581	+ if (err < 0) {
	7582	+ err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
	7583	+ MGMT_STATUS_FAILED);
6691	7584	mgmt_pending_remove(cmd);
	7585	+ }
6692	7586
6693	7587	unlock:
6694	7588	hci_dev_unlock(hdev);
..	..	@@ -6703,7 +7597,7 @@
6703	7597	struct mgmt_cp_remove_advertising *cp;
6704	7598	struct mgmt_rp_remove_advertising rp;
6705	7599
6706		- BT_DBG("status %d", status);
	7600	+ bt_dev_dbg(hdev, "status %d", status);
6707	7601
6708	7602	hci_dev_lock(hdev);
6709	7603
..	..	@@ -6735,7 +7629,14 @@
6735	7629	struct hci_request req;
6736	7630	int err;
6737	7631
6738		- BT_DBG("%s", hdev->name);
	7632	+ bt_dev_dbg(hdev, "sock %p", sk);
	7633	+
	7634	+ /* Enabling the experimental LL Privay support disables support for
	7635	+ * advertising.
	7636	+ */
	7637	+ if (hci_dev_test_flag(hdev, HCI_ENABLE_LL_PRIVACY))
	7638	+ return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
	7639	+ MGMT_STATUS_NOT_SUPPORTED);
6739	7640
6740	7641	hci_dev_lock(hdev);
6741	7642
..	..	@@ -6761,6 +7662,12 @@
6761	7662	}
6762	7663
6763	7664	hci_req_init(&req, hdev);
	7665	+
	7666	+ /* If we use extended advertising, instance is disabled and removed */
	7667	+ if (ext_adv_capable(hdev)) {
	7668	+ __hci_req_disable_ext_adv_instance(&req, cp->instance);
	7669	+ __hci_req_remove_ext_adv_instance(&req, cp->instance);
	7670	+ }
6764	7671
6765	7672	hci_req_clear_adv_instance(hdev, sk, &req, cp->instance, true);
6766	7673
..	..	@@ -6807,13 +7714,13 @@
6807	7714	u32 flags, supported_flags;
6808	7715	int err;
6809	7716
6810		- BT_DBG("%s", hdev->name);
	7717	+ bt_dev_dbg(hdev, "sock %p", sk);
6811	7718
6812	7719	if (!lmp_le_capable(hdev))
6813	7720	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_GET_ADV_SIZE_INFO,
6814	7721	MGMT_STATUS_REJECTED);
6815	7722
6816		- if (cp->instance < 1 \|\| cp->instance > HCI_MAX_ADV_INSTANCES)
	7723	+ if (cp->instance < 1 \|\| cp->instance > hdev->le_num_of_adv_sets)
6817	7724	return mgmt_cmd_status(sk, hdev->id, MGMT_OP_GET_ADV_SIZE_INFO,
6818	7725	MGMT_STATUS_INVALID_PARAMS);
6819	7726
..	..	@@ -6932,6 +7839,31 @@
6932	7839	{ set_appearance, MGMT_SET_APPEARANCE_SIZE },
6933	7840	{ get_phy_configuration, MGMT_GET_PHY_CONFIGURATION_SIZE },
6934	7841	{ set_phy_configuration, MGMT_SET_PHY_CONFIGURATION_SIZE },
	7842	+ { set_blocked_keys, MGMT_OP_SET_BLOCKED_KEYS_SIZE,
	7843	+ HCI_MGMT_VAR_LEN },
	7844	+ { set_wideband_speech, MGMT_SETTING_SIZE },
	7845	+ { read_security_info, MGMT_READ_SECURITY_INFO_SIZE,
	7846	+ HCI_MGMT_UNTRUSTED },
	7847	+ { read_exp_features_info, MGMT_READ_EXP_FEATURES_INFO_SIZE,
	7848	+ HCI_MGMT_UNTRUSTED \|
	7849	+ HCI_MGMT_HDEV_OPTIONAL },
	7850	+ { set_exp_feature, MGMT_SET_EXP_FEATURE_SIZE,
	7851	+ HCI_MGMT_VAR_LEN \|
	7852	+ HCI_MGMT_HDEV_OPTIONAL },
	7853	+ { read_def_system_config, MGMT_READ_DEF_SYSTEM_CONFIG_SIZE,
	7854	+ HCI_MGMT_UNTRUSTED },
	7855	+ { set_def_system_config, MGMT_SET_DEF_SYSTEM_CONFIG_SIZE,
	7856	+ HCI_MGMT_VAR_LEN },
	7857	+ { read_def_runtime_config, MGMT_READ_DEF_RUNTIME_CONFIG_SIZE,
	7858	+ HCI_MGMT_UNTRUSTED },
	7859	+ { set_def_runtime_config, MGMT_SET_DEF_RUNTIME_CONFIG_SIZE,
	7860	+ HCI_MGMT_VAR_LEN },
	7861	+ { get_device_flags, MGMT_GET_DEVICE_FLAGS_SIZE },
	7862	+ { set_device_flags, MGMT_SET_DEVICE_FLAGS_SIZE },
	7863	+ { read_adv_mon_features, MGMT_READ_ADV_MONITOR_FEATURES_SIZE },
	7864	+ { add_adv_patterns_monitor,MGMT_ADD_ADV_PATTERNS_MONITOR_SIZE,
	7865	+ HCI_MGMT_VAR_LEN },
	7866	+ { remove_adv_monitor, MGMT_REMOVE_ADV_MONITOR_SIZE },
6935	7867	};
6936	7868
6937	7869	void mgmt_index_added(struct hci_dev *hdev)
..	..	@@ -7030,7 +7962,7 @@
7030	7962	{
7031	7963	struct cmd_lookup match = { NULL, hdev };
7032	7964
7033		- BT_DBG("err %d", err);
	7965	+ bt_dev_dbg(hdev, "err %d", err);
7034	7966
7035	7967	hci_dev_lock(hdev);
7036	7968
..	..	@@ -7351,6 +8283,10 @@
7351	8283	ev.addr.type = link_to_bdaddr(link_type, addr_type);
7352	8284	ev.reason = reason;
7353	8285
	8286	+ /* Report disconnects due to suspend */
	8287	+ if (hdev->suspended)
	8288	+ ev.reason = MGMT_DEV_DISCONN_LOCAL_HOST_SUSPEND;
	8289	+
7354	8290	mgmt_event(MGMT_EV_DEVICE_DISCONNECTED, hdev, &ev, sizeof(ev), sk);
7355	8291
7356	8292	if (sk)
..	..	@@ -7449,7 +8385,7 @@
7449	8385	{
7450	8386	struct mgmt_ev_user_confirm_request ev;
7451	8387
7452		- BT_DBG("%s", hdev->name);
	8388	+ bt_dev_dbg(hdev, "bdaddr %pMR", bdaddr);
7453	8389
7454	8390	bacpy(&ev.addr.bdaddr, bdaddr);
7455	8391	ev.addr.type = link_to_bdaddr(link_type, addr_type);
..	..	@@ -7465,7 +8401,7 @@
7465	8401	{
7466	8402	struct mgmt_ev_user_passkey_request ev;
7467	8403
7468		- BT_DBG("%s", hdev->name);
	8404	+ bt_dev_dbg(hdev, "bdaddr %pMR", bdaddr);
7469	8405
7470	8406	bacpy(&ev.addr.bdaddr, bdaddr);
7471	8407	ev.addr.type = link_to_bdaddr(link_type, addr_type);
..	..	@@ -7526,7 +8462,7 @@
7526	8462	{
7527	8463	struct mgmt_ev_passkey_notify ev;
7528	8464
7529		- BT_DBG("%s", hdev->name);
	8465	+ bt_dev_dbg(hdev, "bdaddr %pMR", bdaddr);
7530	8466
7531	8467	bacpy(&ev.addr.bdaddr, bdaddr);
7532	8468	ev.addr.type = link_to_bdaddr(link_type, addr_type);
..	..	@@ -7851,8 +8787,11 @@
7851	8787	if (!hci_discovery_active(hdev)) {
7852	8788	if (link_type == ACL_LINK)
7853	8789	return;
7854		- if (link_type == LE_LINK && list_empty(&hdev->pend_le_reports))
	8790	+ if (link_type == LE_LINK &&
	8791	+ list_empty(&hdev->pend_le_reports) &&
	8792	+ !hci_is_adv_monitoring(hdev)) {
7855	8793	return;
	8794	+ }
7856	8795	}
7857	8796
7858	8797	if (hdev->discovery.result_filtering) {
..	..	@@ -7945,7 +8884,7 @@
7945	8884	{
7946	8885	struct mgmt_ev_discovering ev;
7947	8886
7948		- BT_DBG("%s discovering %u", hdev->name, discovering);
	8887	+ bt_dev_dbg(hdev, "discovering %u", discovering);
7949	8888
7950	8889	memset(&ev, 0, sizeof(ev));
7951	8890	ev.type = hdev->discovery.type;
..	..	@@ -7954,6 +8893,30 @@
7954	8893	mgmt_event(MGMT_EV_DISCOVERING, hdev, &ev, sizeof(ev), NULL);
7955	8894	}
7956	8895
	8896	+void mgmt_suspending(struct hci_dev *hdev, u8 state)
	8897	+{
	8898	+ struct mgmt_ev_controller_suspend ev;
	8899	+
	8900	+ ev.suspend_state = state;
	8901	+ mgmt_event(MGMT_EV_CONTROLLER_SUSPEND, hdev, &ev, sizeof(ev), NULL);
	8902	+}
	8903	+
	8904	+void mgmt_resuming(struct hci_dev hdev, u8 reason, bdaddr_t bdaddr,
	8905	+ u8 addr_type)
	8906	+{
	8907	+ struct mgmt_ev_controller_resume ev;
	8908	+
	8909	+ ev.wake_reason = reason;
	8910	+ if (bdaddr) {
	8911	+ bacpy(&ev.addr.bdaddr, bdaddr);
	8912	+ ev.addr.type = addr_type;
	8913	+ } else {
	8914	+ memset(&ev.addr, 0, sizeof(ev.addr));
	8915	+ }
	8916	+
	8917	+ mgmt_event(MGMT_EV_CONTROLLER_RESUME, hdev, &ev, sizeof(ev), NULL);
	8918	+}
	8919	+
7957	8920	static struct hci_mgmt_chan chan = {
7958	8921	.channel = HCI_CHANNEL_CONTROL,
7959	8922	.handler_count = ARRAY_SIZE(mgmt_handlers),