projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'clk/mxs-for-3.6' of git://git.linaro.org/people/shawnguo/linux-2.6...
[deliverable/linux.git] / net / bluetooth / mgmt.c
CommitLineData
0381101f
JH		 1/*
2 BlueZ - Bluetooth protocol stack for Linux
ea585ab5 3
0381101f 4 Copyright (C) 2010 Nokia Corporation
ea585ab5 5 Copyright (C) 2011-2012 Intel Corporation
0381101f
JH		 6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation;
10
11 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth HCI Management interface */
26
ca69b795 27#include <linux/kernel.h>
72359753 28#include <linux/uaccess.h>
3a9a231d 29#include <linux/module.h>
0381101f
JH		 30#include <asm/unaligned.h>
31
32#include <net/bluetooth/bluetooth.h>
33#include <net/bluetooth/hci_core.h>
34#include <net/bluetooth/mgmt.h>
5fe57d9e 35#include <net/bluetooth/smp.h>
0381101f 36
d7b7e796 37bool enable_hs;
d7b7e796 38
2da9c55c 39#define MGMT_VERSION 1
053262dc 40#define MGMT_REVISION 1
02d98129 41
e70bb2e8
JH		 42static const u16 mgmt_commands[] = {
43 MGMT_OP_READ_INDEX_LIST,
44 MGMT_OP_READ_INFO,
45 MGMT_OP_SET_POWERED,
46 MGMT_OP_SET_DISCOVERABLE,
47 MGMT_OP_SET_CONNECTABLE,
48 MGMT_OP_SET_FAST_CONNECTABLE,
49 MGMT_OP_SET_PAIRABLE,
50 MGMT_OP_SET_LINK_SECURITY,
51 MGMT_OP_SET_SSP,
52 MGMT_OP_SET_HS,
53 MGMT_OP_SET_LE,
54 MGMT_OP_SET_DEV_CLASS,
55 MGMT_OP_SET_LOCAL_NAME,
56 MGMT_OP_ADD_UUID,
57 MGMT_OP_REMOVE_UUID,
58 MGMT_OP_LOAD_LINK_KEYS,
59 MGMT_OP_LOAD_LONG_TERM_KEYS,
60 MGMT_OP_DISCONNECT,
61 MGMT_OP_GET_CONNECTIONS,
62 MGMT_OP_PIN_CODE_REPLY,
63 MGMT_OP_PIN_CODE_NEG_REPLY,
64 MGMT_OP_SET_IO_CAPABILITY,
65 MGMT_OP_PAIR_DEVICE,
66 MGMT_OP_CANCEL_PAIR_DEVICE,
67 MGMT_OP_UNPAIR_DEVICE,
68 MGMT_OP_USER_CONFIRM_REPLY,
69 MGMT_OP_USER_CONFIRM_NEG_REPLY,
70 MGMT_OP_USER_PASSKEY_REPLY,
71 MGMT_OP_USER_PASSKEY_NEG_REPLY,
72 MGMT_OP_READ_LOCAL_OOB_DATA,
73 MGMT_OP_ADD_REMOTE_OOB_DATA,
74 MGMT_OP_REMOVE_REMOTE_OOB_DATA,
75 MGMT_OP_START_DISCOVERY,
76 MGMT_OP_STOP_DISCOVERY,
77 MGMT_OP_CONFIRM_NAME,
78 MGMT_OP_BLOCK_DEVICE,
79 MGMT_OP_UNBLOCK_DEVICE,
cdbaccca 80 MGMT_OP_SET_DEVICE_ID,
e70bb2e8
JH		 81};
82
83static const u16 mgmt_events[] = {
84 MGMT_EV_CONTROLLER_ERROR,
85 MGMT_EV_INDEX_ADDED,
86 MGMT_EV_INDEX_REMOVED,
87 MGMT_EV_NEW_SETTINGS,
88 MGMT_EV_CLASS_OF_DEV_CHANGED,
89 MGMT_EV_LOCAL_NAME_CHANGED,
90 MGMT_EV_NEW_LINK_KEY,
91 MGMT_EV_NEW_LONG_TERM_KEY,
92 MGMT_EV_DEVICE_CONNECTED,
93 MGMT_EV_DEVICE_DISCONNECTED,
94 MGMT_EV_CONNECT_FAILED,
95 MGMT_EV_PIN_CODE_REQUEST,
96 MGMT_EV_USER_CONFIRM_REQUEST,
97 MGMT_EV_USER_PASSKEY_REQUEST,
98 MGMT_EV_AUTH_FAILED,
99 MGMT_EV_DEVICE_FOUND,
100 MGMT_EV_DISCOVERING,
101 MGMT_EV_DEVICE_BLOCKED,
102 MGMT_EV_DEVICE_UNBLOCKED,
103 MGMT_EV_DEVICE_UNPAIRED,
104};
105
3fd24153
AG		 106/*
107 * These LE scan and inquiry parameters were chosen according to LE General
108 * Discovery Procedure specification.
109 */
110#define LE_SCAN_TYPE 0x01
111#define LE_SCAN_WIN 0x12
112#define LE_SCAN_INT 0x12
113#define LE_SCAN_TIMEOUT_LE_ONLY 10240 /* TGAP(gen_disc_scan_min) */
5e0452c0 114#define LE_SCAN_TIMEOUT_BREDR_LE 5120 /* TGAP(100)/2 */
3fd24153 115
e8777525 116#define INQUIRY_LEN_BREDR 0x08 /* TGAP(100) */
5e0452c0 117#define INQUIRY_LEN_BREDR_LE 0x04 /* TGAP(100)/2 */
2519a1fc 118
17b02e62 119#define CACHE_TIMEOUT msecs_to_jiffies(2 * 1000)
7d78525d 120
4b34ee78
JH		 121#define hdev_is_powered(hdev) (test_bit(HCI_UP, &hdev->flags) && \
122 !test_bit(HCI_AUTO_OFF, &hdev->dev_flags))
123
eec8d2bc
JH		 124struct pending_cmd {
125 struct list_head list;
fc2f4b13 126 u16 opcode;
eec8d2bc 127 int index;
c68fb7ff 128 void *param;
eec8d2bc 129 struct sock *sk;
e9a416b5 130 void *user_data;
eec8d2bc
JH		 131};
132
ca69b795
JH		 133/* HCI to MGMT error code conversion table */
134static u8 mgmt_status_table[] = {
135 MGMT_STATUS_SUCCESS,
136 MGMT_STATUS_UNKNOWN_COMMAND, /* Unknown Command */
137 MGMT_STATUS_NOT_CONNECTED, /* No Connection */
138 MGMT_STATUS_FAILED, /* Hardware Failure */
139 MGMT_STATUS_CONNECT_FAILED, /* Page Timeout */
140 MGMT_STATUS_AUTH_FAILED, /* Authentication Failed */
141 MGMT_STATUS_NOT_PAIRED, /* PIN or Key Missing */
142 MGMT_STATUS_NO_RESOURCES, /* Memory Full */
143 MGMT_STATUS_TIMEOUT, /* Connection Timeout */
144 MGMT_STATUS_NO_RESOURCES, /* Max Number of Connections */
145 MGMT_STATUS_NO_RESOURCES, /* Max Number of SCO Connections */
146 MGMT_STATUS_ALREADY_CONNECTED, /* ACL Connection Exists */
147 MGMT_STATUS_BUSY, /* Command Disallowed */
148 MGMT_STATUS_NO_RESOURCES, /* Rejected Limited Resources */
149 MGMT_STATUS_REJECTED, /* Rejected Security */
150 MGMT_STATUS_REJECTED, /* Rejected Personal */
151 MGMT_STATUS_TIMEOUT, /* Host Timeout */
152 MGMT_STATUS_NOT_SUPPORTED, /* Unsupported Feature */
153 MGMT_STATUS_INVALID_PARAMS, /* Invalid Parameters */
154 MGMT_STATUS_DISCONNECTED, /* OE User Ended Connection */
155 MGMT_STATUS_NO_RESOURCES, /* OE Low Resources */
156 MGMT_STATUS_DISCONNECTED, /* OE Power Off */
157 MGMT_STATUS_DISCONNECTED, /* Connection Terminated */
158 MGMT_STATUS_BUSY, /* Repeated Attempts */
159 MGMT_STATUS_REJECTED, /* Pairing Not Allowed */
160 MGMT_STATUS_FAILED, /* Unknown LMP PDU */
161 MGMT_STATUS_NOT_SUPPORTED, /* Unsupported Remote Feature */
162 MGMT_STATUS_REJECTED, /* SCO Offset Rejected */
163 MGMT_STATUS_REJECTED, /* SCO Interval Rejected */
164 MGMT_STATUS_REJECTED, /* Air Mode Rejected */
165 MGMT_STATUS_INVALID_PARAMS, /* Invalid LMP Parameters */
166 MGMT_STATUS_FAILED, /* Unspecified Error */
167 MGMT_STATUS_NOT_SUPPORTED, /* Unsupported LMP Parameter Value */
168 MGMT_STATUS_FAILED, /* Role Change Not Allowed */
169 MGMT_STATUS_TIMEOUT, /* LMP Response Timeout */
170 MGMT_STATUS_FAILED, /* LMP Error Transaction Collision */
171 MGMT_STATUS_FAILED, /* LMP PDU Not Allowed */
172 MGMT_STATUS_REJECTED, /* Encryption Mode Not Accepted */
173 MGMT_STATUS_FAILED, /* Unit Link Key Used */
174 MGMT_STATUS_NOT_SUPPORTED, /* QoS Not Supported */
175 MGMT_STATUS_TIMEOUT, /* Instant Passed */
176 MGMT_STATUS_NOT_SUPPORTED, /* Pairing Not Supported */
177 MGMT_STATUS_FAILED, /* Transaction Collision */
178 MGMT_STATUS_INVALID_PARAMS, /* Unacceptable Parameter */
179 MGMT_STATUS_REJECTED, /* QoS Rejected */
180 MGMT_STATUS_NOT_SUPPORTED, /* Classification Not Supported */
181 MGMT_STATUS_REJECTED, /* Insufficient Security */
182 MGMT_STATUS_INVALID_PARAMS, /* Parameter Out Of Range */
183 MGMT_STATUS_BUSY, /* Role Switch Pending */
184 MGMT_STATUS_FAILED, /* Slot Violation */
185 MGMT_STATUS_FAILED, /* Role Switch Failed */
186 MGMT_STATUS_INVALID_PARAMS, /* EIR Too Large */
187 MGMT_STATUS_NOT_SUPPORTED, /* Simple Pairing Not Supported */
188 MGMT_STATUS_BUSY, /* Host Busy Pairing */
189 MGMT_STATUS_REJECTED, /* Rejected, No Suitable Channel */
190 MGMT_STATUS_BUSY, /* Controller Busy */
191 MGMT_STATUS_INVALID_PARAMS, /* Unsuitable Connection Interval */
192 MGMT_STATUS_TIMEOUT, /* Directed Advertising Timeout */
193 MGMT_STATUS_AUTH_FAILED, /* Terminated Due to MIC Failure */
194 MGMT_STATUS_CONNECT_FAILED, /* Connection Establishment Failed */
195 MGMT_STATUS_CONNECT_FAILED, /* MAC Connection Failed */
196};
197
198static u8 mgmt_status(u8 hci_status)
199{
200 if (hci_status < ARRAY_SIZE(mgmt_status_table))
201 return mgmt_status_table[hci_status];
202
203 return MGMT_STATUS_FAILED;
204}
205
4e51eae9 206static int cmd_status(struct sock *sk, u16 index, u16 cmd, u8 status)
f7b64e69
JH		 207{
208 struct sk_buff *skb;
209 struct mgmt_hdr *hdr;
210 struct mgmt_ev_cmd_status *ev;
56b7d137 211 int err;
f7b64e69 212
34eb525c 213 BT_DBG("sock %p, index %u, cmd %u, status %u", sk, index, cmd, status);
f7b64e69
JH		 214
215 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev), GFP_ATOMIC);
216 if (!skb)
217 return -ENOMEM;
218
219 hdr = (void *) skb_put(skb, sizeof(*hdr));
220
221 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_STATUS);
4e51eae9 222 hdr->index = cpu_to_le16(index);
f7b64e69
JH		 223 hdr->len = cpu_to_le16(sizeof(*ev));
224
225 ev = (void *) skb_put(skb, sizeof(*ev));
226 ev->status = status;
eb55ef07 227 ev->opcode = cpu_to_le16(cmd);
f7b64e69 228
56b7d137
GP		 229 err = sock_queue_rcv_skb(sk, skb);
230 if (err < 0)
f7b64e69
JH		 231 kfree_skb(skb);
232
56b7d137 233 return err;
f7b64e69
JH		 234}
235
aee9b218 236static int cmd_complete(struct sock *sk, u16 index, u16 cmd, u8 status,
04124681 237 void *rp, size_t rp_len)
02d98129
JH		 238{
239 struct sk_buff *skb;
240 struct mgmt_hdr *hdr;
241 struct mgmt_ev_cmd_complete *ev;
56b7d137 242 int err;
02d98129
JH		 243
244 BT_DBG("sock %p", sk);
245
a38528f1 246 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev) + rp_len, GFP_ATOMIC);
02d98129
JH		 247 if (!skb)
248 return -ENOMEM;
249
250 hdr = (void *) skb_put(skb, sizeof(*hdr));
02d98129 251
a38528f1 252 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE);
4e51eae9 253 hdr->index = cpu_to_le16(index);
a38528f1 254 hdr->len = cpu_to_le16(sizeof(*ev) + rp_len);
02d98129 255
a38528f1 256 ev = (void *) skb_put(skb, sizeof(*ev) + rp_len);
eb55ef07 257 ev->opcode = cpu_to_le16(cmd);
aee9b218 258 ev->status = status;
8020c16a
SJ		 259
260 if (rp)
261 memcpy(ev->data, rp, rp_len);
02d98129 262
56b7d137
GP		 263 err = sock_queue_rcv_skb(sk, skb);
264 if (err < 0)
02d98129
JH		 265 kfree_skb(skb);
266
e5f0e151 267 return err;
02d98129
JH		 268}
269
04124681
GP		 270static int read_version(struct sock *sk, struct hci_dev *hdev, void *data,
271 u16 data_len)
a38528f1
JH		 272{
273 struct mgmt_rp_read_version rp;
274
275 BT_DBG("sock %p", sk);
276
277 rp.version = MGMT_VERSION;
eb55ef07 278 rp.revision = __constant_cpu_to_le16(MGMT_REVISION);
a38528f1 279
aee9b218 280 return cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_VERSION, 0, &rp,
04124681 281 sizeof(rp));
a38528f1
JH		 282}
283
04124681
GP		 284static int read_commands(struct sock *sk, struct hci_dev *hdev, void *data,
285 u16 data_len)
e70bb2e8
JH		 286{
287 struct mgmt_rp_read_commands *rp;
eb55ef07
MH		 288 const u16 num_commands = ARRAY_SIZE(mgmt_commands);
289 const u16 num_events = ARRAY_SIZE(mgmt_events);
2e3c35ea 290 __le16 *opcode;
e70bb2e8
JH		 291 size_t rp_size;
292 int i, err;
293
294 BT_DBG("sock %p", sk);
295
296 rp_size = sizeof(*rp) + ((num_commands + num_events) * sizeof(u16));
297
298 rp = kmalloc(rp_size, GFP_KERNEL);
299 if (!rp)
300 return -ENOMEM;
301
eb55ef07
MH		 302 rp->num_commands = __constant_cpu_to_le16(num_commands);
303 rp->num_events = __constant_cpu_to_le16(num_events);
e70bb2e8
JH		 304
305 for (i = 0, opcode = rp->opcodes; i < num_commands; i++, opcode++)
306 put_unaligned_le16(mgmt_commands[i], opcode);
307
308 for (i = 0; i < num_events; i++, opcode++)
309 put_unaligned_le16(mgmt_events[i], opcode);
310
aee9b218 311 err = cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_COMMANDS, 0, rp,
04124681 312 rp_size);
e70bb2e8
JH		 313 kfree(rp);
314
315 return err;
316}
317
04124681
GP		 318static int read_index_list(struct sock *sk, struct hci_dev *hdev, void *data,
319 u16 data_len)
faba42eb 320{
faba42eb
JH		 321 struct mgmt_rp_read_index_list *rp;
322 struct list_head *p;
8035ded4 323 struct hci_dev *d;
a38528f1 324 size_t rp_len;
faba42eb 325 u16 count;
a38528f1 326 int i, err;
faba42eb
JH		 327
328 BT_DBG("sock %p", sk);
329
330 read_lock(&hci_dev_list_lock);
331
332 count = 0;
333 list_for_each(p, &hci_dev_list) {
334 count++;
335 }
336
a38528f1
JH		 337 rp_len = sizeof(*rp) + (2 * count);
338 rp = kmalloc(rp_len, GFP_ATOMIC);
339 if (!rp) {
b2c60d42 340 read_unlock(&hci_dev_list_lock);
faba42eb 341 return -ENOMEM;
b2c60d42 342 }
faba42eb 343
eb55ef07 344 rp->num_controllers = cpu_to_le16(count);
faba42eb
JH		 345
346 i = 0;
8035ded4 347 list_for_each_entry(d, &hci_dev_list, list) {
a8b2d5c2 348 if (test_bit(HCI_SETUP, &d->dev_flags))
ab81cbf9
JH		 349 continue;
350
eb55ef07 351 rp->index[i++] = cpu_to_le16(d->id);
faba42eb
JH		 352 BT_DBG("Added hci%u", d->id);
353 }
354
355 read_unlock(&hci_dev_list_lock);
356
aee9b218 357 err = cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_INDEX_LIST, 0, rp,
04124681 358 rp_len);
faba42eb 359
a38528f1
JH		 360 kfree(rp);
361
362 return err;
faba42eb
JH		 363}
364
69ab39ea
JH		 365static u32 get_supported_settings(struct hci_dev *hdev)
366{
367 u32 settings = 0;
368
369 settings |= MGMT_SETTING_POWERED;
370 settings |= MGMT_SETTING_CONNECTABLE;
371 settings |= MGMT_SETTING_FAST_CONNECTABLE;
372 settings |= MGMT_SETTING_DISCOVERABLE;
373 settings |= MGMT_SETTING_PAIRABLE;
374
375 if (hdev->features[6] & LMP_SIMPLE_PAIR)
376 settings |= MGMT_SETTING_SSP;
377
378 if (!(hdev->features[4] & LMP_NO_BREDR)) {
379 settings |= MGMT_SETTING_BREDR;
380 settings |= MGMT_SETTING_LINK_SECURITY;
381 }
382
d7b7e796
MH		 383 if (enable_hs)
384 settings |= MGMT_SETTING_HS;
385
9d42820f
MH		 386 if (hdev->features[4] & LMP_LE)
387 settings |= MGMT_SETTING_LE;
69ab39ea
JH		 388
389 return settings;
390}
391
392static u32 get_current_settings(struct hci_dev *hdev)
393{
394 u32 settings = 0;
395
f1f0eb02 396 if (hdev_is_powered(hdev))
f0d4b78a
MH		 397 settings |= MGMT_SETTING_POWERED;
398
5e5282bb 399 if (test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
69ab39ea
JH		 400 settings |= MGMT_SETTING_CONNECTABLE;
401
5e5282bb 402 if (test_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
69ab39ea
JH		 403 settings |= MGMT_SETTING_DISCOVERABLE;
404
a8b2d5c2 405 if (test_bit(HCI_PAIRABLE, &hdev->dev_flags))
69ab39ea
JH		 406 settings |= MGMT_SETTING_PAIRABLE;
407
408 if (!(hdev->features[4] & LMP_NO_BREDR))
409 settings |= MGMT_SETTING_BREDR;
410
06199cf8 411 if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags))
69ab39ea
JH		 412 settings |= MGMT_SETTING_LE;
413
47990ea0 414 if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags))
69ab39ea
JH		 415 settings |= MGMT_SETTING_LINK_SECURITY;
416
84bde9d6 417 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
69ab39ea
JH		 418 settings |= MGMT_SETTING_SSP;
419
6d80dfd0
JH		 420 if (test_bit(HCI_HS_ENABLED, &hdev->dev_flags))
421 settings |= MGMT_SETTING_HS;
422
69ab39ea
JH		 423 return settings;
424}
425
ef580372
JH		 426#define PNP_INFO_SVCLASS_ID 0x1200
427
428static u8 bluetooth_base_uuid[] = {
429 0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80,
430 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
431};
432
433static u16 get_uuid16(u8 *uuid128)
434{
435 u32 val;
436 int i;
437
438 for (i = 0; i < 12; i++) {
439 if (bluetooth_base_uuid[i] != uuid128[i])
440 return 0;
441 }
442
3e9fb6d8 443 val = get_unaligned_le32(&uuid128[12]);
ef580372
JH		 444 if (val > 0xffff)
445 return 0;
446
447 return (u16) val;
448}
449
450static void create_eir(struct hci_dev *hdev, u8 *data)
451{
452 u8 *ptr = data;
453 u16 eir_len = 0;
454 u16 uuid16_list[HCI_MAX_EIR_LENGTH / sizeof(u16)];
455 int i, truncated = 0;
456 struct bt_uuid *uuid;
457 size_t name_len;
458
459 name_len = strlen(hdev->dev_name);
460
461 if (name_len > 0) {
462 /* EIR Data type */
463 if (name_len > 48) {
464 name_len = 48;
465 ptr[1] = EIR_NAME_SHORT;
466 } else
467 ptr[1] = EIR_NAME_COMPLETE;
468
469 /* EIR Data length */
470 ptr[0] = name_len + 1;
471
472 memcpy(ptr + 2, hdev->dev_name, name_len);
473
474 eir_len += (name_len + 2);
475 ptr += (name_len + 2);
476 }
477
91c4e9b1
MH		 478 if (hdev->inq_tx_power) {
479 ptr[0] = 2;
480 ptr[1] = EIR_TX_POWER;
481 ptr[2] = (u8) hdev->inq_tx_power;
482
483 eir_len += 3;
484 ptr += 3;
485 }
486
2b9be137
MH		 487 if (hdev->devid_source > 0) {
488 ptr[0] = 9;
489 ptr[1] = EIR_DEVICE_ID;
490
491 put_unaligned_le16(hdev->devid_source, ptr + 2);
492 put_unaligned_le16(hdev->devid_vendor, ptr + 4);
493 put_unaligned_le16(hdev->devid_product, ptr + 6);
494 put_unaligned_le16(hdev->devid_version, ptr + 8);
495
496 eir_len += 10;
497 ptr += 10;
498 }
499
ef580372
JH		 500 memset(uuid16_list, 0, sizeof(uuid16_list));
501
502 /* Group all UUID16 types */
503 list_for_each_entry(uuid, &hdev->uuids, list) {
504 u16 uuid16;
505
506 uuid16 = get_uuid16(uuid->uuid);
507 if (uuid16 == 0)
508 return;
509
510 if (uuid16 < 0x1100)
511 continue;
512
513 if (uuid16 == PNP_INFO_SVCLASS_ID)
514 continue;
515
516 /* Stop if not enough space to put next UUID */
517 if (eir_len + 2 + sizeof(u16) > HCI_MAX_EIR_LENGTH) {
518 truncated = 1;
519 break;
520 }
521
522 /* Check for duplicates */
523 for (i = 0; uuid16_list[i] != 0; i++)
524 if (uuid16_list[i] == uuid16)
525 break;
526
527 if (uuid16_list[i] == 0) {
528 uuid16_list[i] = uuid16;
529 eir_len += sizeof(u16);
530 }
531 }
532
533 if (uuid16_list[0] != 0) {
534 u8 *length = ptr;
535
536 /* EIR Data type */
537 ptr[1] = truncated ? EIR_UUID16_SOME : EIR_UUID16_ALL;
538
539 ptr += 2;
540 eir_len += 2;
541
542 for (i = 0; uuid16_list[i] != 0; i++) {
543 *ptr++ = (uuid16_list[i] & 0x00ff);
544 *ptr++ = (uuid16_list[i] & 0xff00) >> 8;
545 }
546
547 /* EIR Data length */
548 *length = (i * sizeof(u16)) + 1;
549 }
550}
551
552static int update_eir(struct hci_dev *hdev)
553{
554 struct hci_cp_write_eir cp;
555
504c8dcd 556 if (!hdev_is_powered(hdev))
7770c4aa
JH		 557 return 0;
558
ef580372
JH		 559 if (!(hdev->features[6] & LMP_EXT_INQ))
560 return 0;
561
84bde9d6 562 if (!test_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
ef580372
JH		 563 return 0;
564
a8b2d5c2 565 if (test_bit(HCI_SERVICE_CACHE, &hdev->dev_flags))
ef580372
JH		 566 return 0;
567
568 memset(&cp, 0, sizeof(cp));
569
570 create_eir(hdev, cp.data);
571
572 if (memcmp(cp.data, hdev->eir, sizeof(cp.data)) == 0)
573 return 0;
574
575 memcpy(hdev->eir, cp.data, sizeof(cp.data));
576
577 return hci_send_cmd(hdev, HCI_OP_WRITE_EIR, sizeof(cp), &cp);
578}
579
580static u8 get_service_classes(struct hci_dev *hdev)
581{
582 struct bt_uuid *uuid;
583 u8 val = 0;
584
585 list_for_each_entry(uuid, &hdev->uuids, list)
586 val |= uuid->svc_hint;
587
588 return val;
589}
590
591static int update_class(struct hci_dev *hdev)
592{
593 u8 cod[3];
c95f0ba7 594 int err;
ef580372
JH		 595
596 BT_DBG("%s", hdev->name);
597
504c8dcd 598 if (!hdev_is_powered(hdev))
7770c4aa
JH		 599 return 0;
600
a8b2d5c2 601 if (test_bit(HCI_SERVICE_CACHE, &hdev->dev_flags))
ef580372
JH		 602 return 0;
603
604 cod[0] = hdev->minor_class;
605 cod[1] = hdev->major_class;
606 cod[2] = get_service_classes(hdev);
607
608 if (memcmp(cod, hdev->dev_class, 3) == 0)
609 return 0;
610
c95f0ba7
JH		 611 err = hci_send_cmd(hdev, HCI_OP_WRITE_CLASS_OF_DEV, sizeof(cod), cod);
612 if (err == 0)
613 set_bit(HCI_PENDING_CLASS, &hdev->dev_flags);
614
615 return err;
ef580372
JH		 616}
617
7d78525d
JH		 618static void service_cache_off(struct work_struct *work)
619{
620 struct hci_dev *hdev = container_of(work, struct hci_dev,
04124681 621 service_cache.work);
7d78525d 622
a8b2d5c2 623 if (!test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags))
7d78525d
JH		 624 return;
625
626 hci_dev_lock(hdev);
627
628 update_eir(hdev);
629 update_class(hdev);
630
631 hci_dev_unlock(hdev);
632}
633
6a919082 634static void mgmt_init_hdev(struct sock *sk, struct hci_dev *hdev)
7d78525d 635{
4f87da80 636 if (test_and_set_bit(HCI_MGMT, &hdev->dev_flags))
6a919082
JH		 637 return;
638
4f87da80 639 INIT_DELAYED_WORK(&hdev->service_cache, service_cache_off);
7d78525d 640
4f87da80
JH		 641 /* Non-mgmt controlled devices get this bit set
642 * implicitly so that pairing works for them, however
643 * for mgmt we require user-space to explicitly enable
644 * it
645 */
646 clear_bit(HCI_PAIRABLE, &hdev->dev_flags);
7d78525d
JH		 647}
648
0f4e68cf 649static int read_controller_info(struct sock *sk, struct hci_dev *hdev,
04124681 650 void *data, u16 data_len)
0381101f 651{
a38528f1 652 struct mgmt_rp_read_info rp;
f7b64e69 653
bdb6d971 654 BT_DBG("sock %p %s", sk, hdev->name);
f7b64e69 655
09fd0de5 656 hci_dev_lock(hdev);
f7b64e69 657
dc4fe30b
JH		 658 memset(&rp, 0, sizeof(rp));
659
69ab39ea 660 bacpy(&rp.bdaddr, &hdev->bdaddr);
f7b64e69 661
69ab39ea 662 rp.version = hdev->hci_ver;
eb55ef07 663 rp.manufacturer = cpu_to_le16(hdev->manufacturer);
69ab39ea
JH		 664
665 rp.supported_settings = cpu_to_le32(get_supported_settings(hdev));
666 rp.current_settings = cpu_to_le32(get_current_settings(hdev));
f7b64e69 667
a38528f1 668 memcpy(rp.dev_class, hdev->dev_class, 3);
f7b64e69 669
dc4fe30b 670 memcpy(rp.name, hdev->dev_name, sizeof(hdev->dev_name));
27fcc362 671 memcpy(rp.short_name, hdev->short_name, sizeof(hdev->short_name));
dc4fe30b 672
09fd0de5 673 hci_dev_unlock(hdev);
0381101f 674
bdb6d971 675 return cmd_complete(sk, hdev->id, MGMT_OP_READ_INFO, 0, &rp,
04124681 676 sizeof(rp));
0381101f
JH		 677}
678
eec8d2bc
JH		 679static void mgmt_pending_free(struct pending_cmd *cmd)
680{
681 sock_put(cmd->sk);
c68fb7ff 682 kfree(cmd->param);
eec8d2bc
JH		 683 kfree(cmd);
684}
685
366a0336 686static struct pending_cmd *mgmt_pending_add(struct sock *sk, u16 opcode,
04124681
GP		 687 struct hci_dev *hdev, void *data,
688 u16 len)
eec8d2bc
JH		 689{
690 struct pending_cmd *cmd;
691
692 cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC);
693 if (!cmd)
366a0336 694 return NULL;
eec8d2bc
JH		 695
696 cmd->opcode = opcode;
2e58ef3e 697 cmd->index = hdev->id;
eec8d2bc 698
c68fb7ff
SJ		 699 cmd->param = kmalloc(len, GFP_ATOMIC);
700 if (!cmd->param) {
eec8d2bc 701 kfree(cmd);
366a0336 702 return NULL;
eec8d2bc
JH		 703 }
704
8fce6357
SJ		 705 if (data)
706 memcpy(cmd->param, data, len);
eec8d2bc
JH		 707
708 cmd->sk = sk;
709 sock_hold(sk);
710
2e58ef3e 711 list_add(&cmd->list, &hdev->mgmt_pending);
eec8d2bc 712
366a0336 713 return cmd;
eec8d2bc
JH		 714}
715
744cf19e 716static void mgmt_pending_foreach(u16 opcode, struct hci_dev *hdev,
04124681
GP		 717 void (*cb)(struct pending_cmd *cmd, void *data),
718 void *data)
eec8d2bc
JH		 719{
720 struct list_head *p, *n;
721
2e58ef3e 722 list_for_each_safe(p, n, &hdev->mgmt_pending) {
eec8d2bc
JH		 723 struct pending_cmd *cmd;
724
725 cmd = list_entry(p, struct pending_cmd, list);
726
b24752fe 727 if (opcode > 0 && cmd->opcode != opcode)
eec8d2bc
JH		 728 continue;
729
eec8d2bc
JH		 730 cb(cmd, data);
731 }
732}
733
2e58ef3e 734static struct pending_cmd *mgmt_pending_find(u16 opcode, struct hci_dev *hdev)
eec8d2bc 735{
8035ded4 736 struct pending_cmd *cmd;
eec8d2bc 737
2e58ef3e 738 list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
2aeabcbe
JH		 739 if (cmd->opcode == opcode)
740 return cmd;
eec8d2bc
JH		 741 }
742
743 return NULL;
744}
745
a664b5bc 746static void mgmt_pending_remove(struct pending_cmd *cmd)
73f22f62 747{
73f22f62
JH		 748 list_del(&cmd->list);
749 mgmt_pending_free(cmd);
750}
751
69ab39ea 752static int send_settings_rsp(struct sock *sk, u16 opcode, struct hci_dev *hdev)
8680570b 753{
69ab39ea 754 __le32 settings = cpu_to_le32(get_current_settings(hdev));
8680570b 755
aee9b218 756 return cmd_complete(sk, hdev->id, opcode, 0, &settings,
04124681 757 sizeof(settings));
8680570b
JH		 758}
759
bdb6d971 760static int set_powered(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 761 u16 len)
eec8d2bc 762{
650f726d 763 struct mgmt_mode *cp = data;
366a0336 764 struct pending_cmd *cmd;
4b34ee78 765 int err;
eec8d2bc 766
bdb6d971 767 BT_DBG("request for %s", hdev->name);
eec8d2bc 768
09fd0de5 769 hci_dev_lock(hdev);
eec8d2bc 770
f0d4b78a
MH		 771 if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) {
772 cancel_delayed_work(&hdev->power_off);
773
774 if (cp->val) {
775 err = send_settings_rsp(sk, MGMT_OP_SET_POWERED, hdev);
776 mgmt_powered(hdev, 1);
777 goto failed;
778 }
779 }
780
4b34ee78 781 if (!!cp->val == hdev_is_powered(hdev)) {
69ab39ea 782 err = send_settings_rsp(sk, MGMT_OP_SET_POWERED, hdev);
eec8d2bc
JH		 783 goto failed;
784 }
785
2e58ef3e 786 if (mgmt_pending_find(MGMT_OP_SET_POWERED, hdev)) {
bdb6d971 787 err = cmd_status(sk, hdev->id, MGMT_OP_SET_POWERED,
04124681 788 MGMT_STATUS_BUSY);
eec8d2bc
JH		 789 goto failed;
790 }
791
2e58ef3e 792 cmd = mgmt_pending_add(sk, MGMT_OP_SET_POWERED, hdev, data, len);
366a0336
JH		 793 if (!cmd) {
794 err = -ENOMEM;
eec8d2bc 795 goto failed;
366a0336 796 }
eec8d2bc 797
72a734ec 798 if (cp->val)
7f971041 799 schedule_work(&hdev->power_on);
eec8d2bc 800 else
80b7ab33 801 schedule_work(&hdev->power_off.work);
eec8d2bc 802
366a0336 803 err = 0;
eec8d2bc
JH		 804
805failed:
09fd0de5 806 hci_dev_unlock(hdev);
366a0336 807 return err;
eec8d2bc
JH		 808}
809
04124681
GP		 810static int mgmt_event(u16 event, struct hci_dev *hdev, void *data, u16 data_len,
811 struct sock *skip_sk)
beadb2bd
JH		 812{
813 struct sk_buff *skb;
814 struct mgmt_hdr *hdr;
815
816 skb = alloc_skb(sizeof(*hdr) + data_len, GFP_ATOMIC);
817 if (!skb)
818 return -ENOMEM;
819
820 hdr = (void *) skb_put(skb, sizeof(*hdr));
821 hdr->opcode = cpu_to_le16(event);
822 if (hdev)
823 hdr->index = cpu_to_le16(hdev->id);
824 else
825 hdr->index = cpu_to_le16(MGMT_INDEX_NONE);
826 hdr->len = cpu_to_le16(data_len);
827
828 if (data)
829 memcpy(skb_put(skb, data_len), data, data_len);
830
97e0bdeb
MH		 831 /* Time stamp */
832 __net_timestamp(skb);
833
beadb2bd
JH		 834 hci_send_to_control(skb, skip_sk);
835 kfree_skb(skb);
836
837 return 0;
838}
839
840static int new_settings(struct hci_dev *hdev, struct sock *skip)
841{
842 __le32 ev;
843
844 ev = cpu_to_le32(get_current_settings(hdev));
845
846 return mgmt_event(MGMT_EV_NEW_SETTINGS, hdev, &ev, sizeof(ev), skip);
847}
848
bdb6d971 849static int set_discoverable(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 850 u16 len)
73f22f62 851{
650f726d 852 struct mgmt_cp_set_discoverable *cp = data;
366a0336 853 struct pending_cmd *cmd;
5e5282bb 854 u16 timeout;
73f22f62
JH		 855 u8 scan;
856 int err;
857
bdb6d971 858 BT_DBG("request for %s", hdev->name);
73f22f62 859
1f350c87 860 timeout = __le16_to_cpu(cp->timeout);
24c54a90 861 if (!cp->val && timeout > 0)
bdb6d971 862 return cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
04124681 863 MGMT_STATUS_INVALID_PARAMS);
73f22f62 864
09fd0de5 865 hci_dev_lock(hdev);
73f22f62 866
5e5282bb 867 if (!hdev_is_powered(hdev) && timeout > 0) {
bdb6d971 868 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
04124681 869 MGMT_STATUS_NOT_POWERED);
73f22f62
JH		 870 goto failed;
871 }
872
2e58ef3e
JH		 873 if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) ||
874 mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) {
bdb6d971 875 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
04124681 876 MGMT_STATUS_BUSY);
73f22f62
JH		 877 goto failed;
878 }
879
5e5282bb 880 if (!test_bit(HCI_CONNECTABLE, &hdev->dev_flags)) {
bdb6d971 881 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
04124681 882 MGMT_STATUS_REJECTED);
5e5282bb
JH		 883 goto failed;
884 }
885
886 if (!hdev_is_powered(hdev)) {
0224d2fa
JH		 887 bool changed = false;
888
889 if (!!cp->val != test_bit(HCI_DISCOVERABLE, &hdev->dev_flags)) {
890 change_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
891 changed = true;
892 }
893
5e5282bb 894 err = send_settings_rsp(sk, MGMT_OP_SET_DISCOVERABLE, hdev);
0224d2fa
JH		 895 if (err < 0)
896 goto failed;
897
898 if (changed)
899 err = new_settings(hdev, sk);
900
5e5282bb
JH		 901 goto failed;
902 }
903
904 if (!!cp->val == test_bit(HCI_DISCOVERABLE, &hdev->dev_flags)) {
955638ec
MH		 905 if (hdev->discov_timeout > 0) {
906 cancel_delayed_work(&hdev->discov_off);
907 hdev->discov_timeout = 0;
908 }
909
910 if (cp->val && timeout > 0) {
911 hdev->discov_timeout = timeout;
912 queue_delayed_work(hdev->workqueue, &hdev->discov_off,
913 msecs_to_jiffies(hdev->discov_timeout * 1000));
914 }
915
69ab39ea 916 err = send_settings_rsp(sk, MGMT_OP_SET_DISCOVERABLE, hdev);
73f22f62
JH		 917 goto failed;
918 }
919
2e58ef3e 920 cmd = mgmt_pending_add(sk, MGMT_OP_SET_DISCOVERABLE, hdev, data, len);
366a0336
JH		 921 if (!cmd) {
922 err = -ENOMEM;
73f22f62 923 goto failed;
366a0336 924 }
73f22f62
JH		 925
926 scan = SCAN_PAGE;
927
72a734ec 928 if (cp->val)
73f22f62 929 scan |= SCAN_INQUIRY;
16ab91ab 930 else
e0f9309f 931 cancel_delayed_work(&hdev->discov_off);
73f22f62
JH		 932
933 err = hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
934 if (err < 0)
a664b5bc 935 mgmt_pending_remove(cmd);
73f22f62 936
16ab91ab 937 if (cp->val)
5e5282bb 938 hdev->discov_timeout = timeout;
16ab91ab 939
73f22f62 940failed:
09fd0de5 941 hci_dev_unlock(hdev);
73f22f62
JH		 942 return err;
943}
944
bdb6d971 945static int set_connectable(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 946 u16 len)
9fbcbb45 947{
650f726d 948 struct mgmt_mode *cp = data;
366a0336 949 struct pending_cmd *cmd;
9fbcbb45
JH		 950 u8 scan;
951 int err;
952
bdb6d971 953 BT_DBG("request for %s", hdev->name);
9fbcbb45 954
09fd0de5 955 hci_dev_lock(hdev);
9fbcbb45 956
4b34ee78 957 if (!hdev_is_powered(hdev)) {
0224d2fa
JH		 958 bool changed = false;
959
960 if (!!cp->val != test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
961 changed = true;
962
6bf0e469 963 if (cp->val) {
5e5282bb 964 set_bit(HCI_CONNECTABLE, &hdev->dev_flags);
6bf0e469 965 } else {
5e5282bb
JH		 966 clear_bit(HCI_CONNECTABLE, &hdev->dev_flags);
967 clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
968 }
0224d2fa 969
5e5282bb 970 err = send_settings_rsp(sk, MGMT_OP_SET_CONNECTABLE, hdev);
0224d2fa
JH		 971 if (err < 0)
972 goto failed;
973
974 if (changed)
975 err = new_settings(hdev, sk);
976
9fbcbb45
JH		 977 goto failed;
978 }
979
2e58ef3e
JH		 980 if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) ||
981 mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) {
bdb6d971 982 err = cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE,
04124681 983 MGMT_STATUS_BUSY);
9fbcbb45
JH		 984 goto failed;
985 }
986
5e5282bb 987 if (!!cp->val == test_bit(HCI_PSCAN, &hdev->flags)) {
69ab39ea 988 err = send_settings_rsp(sk, MGMT_OP_SET_CONNECTABLE, hdev);
9fbcbb45
JH		 989 goto failed;
990 }
991
2e58ef3e 992 cmd = mgmt_pending_add(sk, MGMT_OP_SET_CONNECTABLE, hdev, data, len);
366a0336
JH		 993 if (!cmd) {
994 err = -ENOMEM;
9fbcbb45 995 goto failed;
366a0336 996 }
9fbcbb45 997
6bf0e469 998 if (cp->val) {
9fbcbb45 999 scan = SCAN_PAGE;
6bf0e469 1000 } else {
9fbcbb45
JH		 1001 scan = 0;
1002
df2c6c5e
JH		 1003 if (test_bit(HCI_ISCAN, &hdev->flags) &&
1004 hdev->discov_timeout > 0)
1005 cancel_delayed_work(&hdev->discov_off);
1006 }
1007
9fbcbb45
JH		 1008 err = hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
1009 if (err < 0)
a664b5bc 1010 mgmt_pending_remove(cmd);
9fbcbb45
JH		 1011
1012failed:
09fd0de5 1013 hci_dev_unlock(hdev);
9fbcbb45
JH		 1014 return err;
1015}
1016
bdb6d971 1017static int set_pairable(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 1018 u16 len)
c542a06c 1019{
650f726d 1020 struct mgmt_mode *cp = data;
c542a06c
JH		 1021 int err;
1022
bdb6d971 1023 BT_DBG("request for %s", hdev->name);
c542a06c 1024
09fd0de5 1025 hci_dev_lock(hdev);
c542a06c
JH		 1026
1027 if (cp->val)
a8b2d5c2 1028 set_bit(HCI_PAIRABLE, &hdev->dev_flags);
c542a06c 1029 else
a8b2d5c2 1030 clear_bit(HCI_PAIRABLE, &hdev->dev_flags);
c542a06c 1031
69ab39ea 1032 err = send_settings_rsp(sk, MGMT_OP_SET_PAIRABLE, hdev);
c542a06c
JH		 1033 if (err < 0)
1034 goto failed;
1035
beadb2bd 1036 err = new_settings(hdev, sk);
c542a06c
JH		 1037
1038failed:
09fd0de5 1039 hci_dev_unlock(hdev);
c542a06c
JH		 1040 return err;
1041}
1042
04124681
GP		 1043static int set_link_security(struct sock *sk, struct hci_dev *hdev, void *data,
1044 u16 len)
33ef95ed
JH		 1045{
1046 struct mgmt_mode *cp = data;
1047 struct pending_cmd *cmd;
816a11d5 1048 u8 val;
33ef95ed
JH		 1049 int err;
1050
bdb6d971 1051 BT_DBG("request for %s", hdev->name);
33ef95ed 1052
33ef95ed
JH		 1053 hci_dev_lock(hdev);
1054
4b34ee78 1055 if (!hdev_is_powered(hdev)) {
47990ea0
JH		 1056 bool changed = false;
1057
1058 if (!!cp->val != test_bit(HCI_LINK_SECURITY,
1059 &hdev->dev_flags)) {
1060 change_bit(HCI_LINK_SECURITY, &hdev->dev_flags);
1061 changed = true;
1062 }
1063
1064 err = send_settings_rsp(sk, MGMT_OP_SET_LINK_SECURITY, hdev);
1065 if (err < 0)
1066 goto failed;
1067
1068 if (changed)
1069 err = new_settings(hdev, sk);
1070
33ef95ed
JH		 1071 goto failed;
1072 }
1073
1074 if (mgmt_pending_find(MGMT_OP_SET_LINK_SECURITY, hdev)) {
bdb6d971 1075 err = cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY,
04124681 1076 MGMT_STATUS_BUSY);
33ef95ed
JH		 1077 goto failed;
1078 }
1079
1080 val = !!cp->val;
1081
1082 if (test_bit(HCI_AUTH, &hdev->flags) == val) {
1083 err = send_settings_rsp(sk, MGMT_OP_SET_LINK_SECURITY, hdev);
1084 goto failed;
1085 }
1086
1087 cmd = mgmt_pending_add(sk, MGMT_OP_SET_LINK_SECURITY, hdev, data, len);
1088 if (!cmd) {
1089 err = -ENOMEM;
1090 goto failed;
1091 }
1092
1093 err = hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, sizeof(val), &val);
1094 if (err < 0) {
1095 mgmt_pending_remove(cmd);
1096 goto failed;
1097 }
1098
1099failed:
1100 hci_dev_unlock(hdev);
33ef95ed
JH		 1101 return err;
1102}
1103
bdb6d971 1104static int set_ssp(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
ed2c4ee3
JH		 1105{
1106 struct mgmt_mode *cp = data;
1107 struct pending_cmd *cmd;
816a11d5 1108 u8 val;
ed2c4ee3
JH		 1109 int err;
1110
bdb6d971 1111 BT_DBG("request for %s", hdev->name);
ed2c4ee3 1112
ed2c4ee3
JH		 1113 hci_dev_lock(hdev);
1114
6c8f12c1 1115 if (!(hdev->features[6] & LMP_SIMPLE_PAIR)) {
bdb6d971 1116 err = cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
04124681 1117 MGMT_STATUS_NOT_SUPPORTED);
6c8f12c1
JH		 1118 goto failed;
1119 }
1120
c0ecddc2
JH		 1121 val = !!cp->val;
1122
4b34ee78 1123 if (!hdev_is_powered(hdev)) {
c0ecddc2
JH		 1124 bool changed = false;
1125
1126 if (val != test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) {
1127 change_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
1128 changed = true;
1129 }
1130
1131 err = send_settings_rsp(sk, MGMT_OP_SET_SSP, hdev);
1132 if (err < 0)
1133 goto failed;
1134
1135 if (changed)
1136 err = new_settings(hdev, sk);
1137
ed2c4ee3
JH		 1138 goto failed;
1139 }
1140
1141 if (mgmt_pending_find(MGMT_OP_SET_SSP, hdev)) {
d97dcb66
SJ		 1142 err = cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
1143 MGMT_STATUS_BUSY);
ed2c4ee3
JH		 1144 goto failed;
1145 }
1146
ed2c4ee3
JH		 1147 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags) == val) {
1148 err = send_settings_rsp(sk, MGMT_OP_SET_SSP, hdev);
1149 goto failed;
1150 }
1151
1152 cmd = mgmt_pending_add(sk, MGMT_OP_SET_SSP, hdev, data, len);
1153 if (!cmd) {
1154 err = -ENOMEM;
1155 goto failed;
1156 }
1157
1158 err = hci_send_cmd(hdev, HCI_OP_WRITE_SSP_MODE, sizeof(val), &val);
1159 if (err < 0) {
1160 mgmt_pending_remove(cmd);
1161 goto failed;
1162 }
1163
1164failed:
1165 hci_dev_unlock(hdev);
ed2c4ee3
JH		 1166 return err;
1167}
1168
bdb6d971 1169static int set_hs(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
6d80dfd0
JH		 1170{
1171 struct mgmt_mode *cp = data;
6d80dfd0 1172
bdb6d971 1173 BT_DBG("request for %s", hdev->name);
6d80dfd0 1174
bdb6d971
JH		 1175 if (!enable_hs)
1176 return cmd_status(sk, hdev->id, MGMT_OP_SET_HS,
04124681 1177 MGMT_STATUS_NOT_SUPPORTED);
6d80dfd0
JH		 1178
1179 if (cp->val)
1180 set_bit(HCI_HS_ENABLED, &hdev->dev_flags);
1181 else
1182 clear_bit(HCI_HS_ENABLED, &hdev->dev_flags);
1183
bdb6d971 1184 return send_settings_rsp(sk, MGMT_OP_SET_HS, hdev);
6d80dfd0
JH		 1185}
1186
bdb6d971 1187static int set_le(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
06199cf8
JH		 1188{
1189 struct mgmt_mode *cp = data;
1190 struct hci_cp_write_le_host_supported hci_cp;
1191 struct pending_cmd *cmd;
06199cf8 1192 int err;
0b60eba1 1193 u8 val, enabled;
06199cf8 1194
bdb6d971 1195 BT_DBG("request for %s", hdev->name);
06199cf8 1196
1de028ce
JH		 1197 hci_dev_lock(hdev);
1198
9d42820f 1199 if (!(hdev->features[4] & LMP_LE)) {
bdb6d971 1200 err = cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
04124681 1201 MGMT_STATUS_NOT_SUPPORTED);
1de028ce 1202 goto unlock;
06199cf8
JH		 1203 }
1204
1205 val = !!cp->val;
0b60eba1 1206 enabled = !!(hdev->host_features[0] & LMP_HOST_LE);
06199cf8 1207
0b60eba1 1208 if (!hdev_is_powered(hdev) || val == enabled) {
06199cf8
JH		 1209 bool changed = false;
1210
1211 if (val != test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) {
1212 change_bit(HCI_LE_ENABLED, &hdev->dev_flags);
1213 changed = true;
1214 }
1215
1216 err = send_settings_rsp(sk, MGMT_OP_SET_LE, hdev);
1217 if (err < 0)
1de028ce 1218 goto unlock;
06199cf8
JH		 1219
1220 if (changed)
1221 err = new_settings(hdev, sk);
1222
1de028ce 1223 goto unlock;
06199cf8
JH		 1224 }
1225
1226 if (mgmt_pending_find(MGMT_OP_SET_LE, hdev)) {
bdb6d971 1227 err = cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
04124681 1228 MGMT_STATUS_BUSY);
1de028ce 1229 goto unlock;
06199cf8
JH		 1230 }
1231
1232 cmd = mgmt_pending_add(sk, MGMT_OP_SET_LE, hdev, data, len);
1233 if (!cmd) {
1234 err = -ENOMEM;
1de028ce 1235 goto unlock;
06199cf8
JH		 1236 }
1237
1238 memset(&hci_cp, 0, sizeof(hci_cp));
1239
1240 if (val) {
1241 hci_cp.le = val;
1242 hci_cp.simul = !!(hdev->features[6] & LMP_SIMUL_LE_BR);
1243 }
1244
04124681
GP		 1245 err = hci_send_cmd(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(hci_cp),
1246 &hci_cp);
0c01bc48 1247 if (err < 0)
06199cf8 1248 mgmt_pending_remove(cmd);
06199cf8 1249
1de028ce
JH		 1250unlock:
1251 hci_dev_unlock(hdev);
06199cf8
JH		 1252 return err;
1253}
1254
bdb6d971 1255static int add_uuid(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
2aeb9a1a 1256{
650f726d 1257 struct mgmt_cp_add_uuid *cp = data;
90e70454 1258 struct pending_cmd *cmd;
2aeb9a1a 1259 struct bt_uuid *uuid;
2aeb9a1a
JH		 1260 int err;
1261
bdb6d971 1262 BT_DBG("request for %s", hdev->name);
2aeb9a1a 1263
09fd0de5 1264 hci_dev_lock(hdev);
2aeb9a1a 1265
c95f0ba7 1266 if (test_bit(HCI_PENDING_CLASS, &hdev->dev_flags)) {
bdb6d971 1267 err = cmd_status(sk, hdev->id, MGMT_OP_ADD_UUID,
04124681 1268 MGMT_STATUS_BUSY);
c95f0ba7
JH		 1269 goto failed;
1270 }
1271
2aeb9a1a
JH		 1272 uuid = kmalloc(sizeof(*uuid), GFP_ATOMIC);
1273 if (!uuid) {
1274 err = -ENOMEM;
1275 goto failed;
1276 }
1277
1278 memcpy(uuid->uuid, cp->uuid, 16);
1aff6f09 1279 uuid->svc_hint = cp->svc_hint;
2aeb9a1a
JH		 1280
1281 list_add(&uuid->list, &hdev->uuids);
1282
1aff6f09
JH		 1283 err = update_class(hdev);
1284 if (err < 0)
1285 goto failed;
1286
80a1e1db
JH		 1287 err = update_eir(hdev);
1288 if (err < 0)
1289 goto failed;
1290
90e70454 1291 if (!test_bit(HCI_PENDING_CLASS, &hdev->dev_flags)) {
bdb6d971 1292 err = cmd_complete(sk, hdev->id, MGMT_OP_ADD_UUID, 0,
04124681 1293 hdev->dev_class, 3);
90e70454
JH		 1294 goto failed;
1295 }
1296
1297 cmd = mgmt_pending_add(sk, MGMT_OP_ADD_UUID, hdev, data, len);
0c01bc48 1298 if (!cmd)
90e70454 1299 err = -ENOMEM;
2aeb9a1a
JH		 1300
1301failed:
09fd0de5 1302 hci_dev_unlock(hdev);
2aeb9a1a
JH		 1303 return err;
1304}
1305
24b78d0f
JH		 1306static bool enable_service_cache(struct hci_dev *hdev)
1307{
1308 if (!hdev_is_powered(hdev))
1309 return false;
1310
1311 if (!test_and_set_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) {
17b02e62 1312 schedule_delayed_work(&hdev->service_cache, CACHE_TIMEOUT);
24b78d0f
JH		 1313 return true;
1314 }
1315
1316 return false;
1317}
1318
bdb6d971
JH		 1319static int remove_uuid(struct sock *sk, struct hci_dev *hdev, void *data,
1320 u16 len)
2aeb9a1a 1321{
650f726d 1322 struct mgmt_cp_remove_uuid *cp = data;
90e70454 1323 struct pending_cmd *cmd;
2aeb9a1a 1324 struct list_head *p, *n;
2aeb9a1a 1325 u8 bt_uuid_any[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
2aeb9a1a
JH		 1326 int err, found;
1327
bdb6d971 1328 BT_DBG("request for %s", hdev->name);
2aeb9a1a 1329
09fd0de5 1330 hci_dev_lock(hdev);
2aeb9a1a 1331
c95f0ba7 1332 if (test_bit(HCI_PENDING_CLASS, &hdev->dev_flags)) {
bdb6d971 1333 err = cmd_status(sk, hdev->id, MGMT_OP_REMOVE_UUID,
04124681 1334 MGMT_STATUS_BUSY);
c95f0ba7
JH		 1335 goto unlock;
1336 }
1337
2aeb9a1a
JH		 1338 if (memcmp(cp->uuid, bt_uuid_any, 16) == 0) {
1339 err = hci_uuids_clear(hdev);
4004b6d9 1340
24b78d0f 1341 if (enable_service_cache(hdev)) {
bdb6d971 1342 err = cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_UUID,
04124681 1343 0, hdev->dev_class, 3);
24b78d0f
JH		 1344 goto unlock;
1345 }
4004b6d9 1346
9246a869 1347 goto update_class;
2aeb9a1a
JH		 1348 }
1349
1350 found = 0;
1351
1352 list_for_each_safe(p, n, &hdev->uuids) {
1353 struct bt_uuid *match = list_entry(p, struct bt_uuid, list);
1354
1355 if (memcmp(match->uuid, cp->uuid, 16) != 0)
1356 continue;
1357
1358 list_del(&match->list);
1359 found++;
1360 }
1361
1362 if (found == 0) {
bdb6d971 1363 err = cmd_status(sk, hdev->id, MGMT_OP_REMOVE_UUID,
04124681 1364 MGMT_STATUS_INVALID_PARAMS);
2aeb9a1a
JH		 1365 goto unlock;
1366 }
1367
9246a869 1368update_class:
1aff6f09
JH		 1369 err = update_class(hdev);
1370 if (err < 0)
1371 goto unlock;
1372
80a1e1db
JH		 1373 err = update_eir(hdev);
1374 if (err < 0)
1375 goto unlock;
1376
90e70454 1377 if (!test_bit(HCI_PENDING_CLASS, &hdev->dev_flags)) {
bdb6d971 1378 err = cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_UUID, 0,
04124681 1379 hdev->dev_class, 3);
90e70454
JH		 1380 goto unlock;
1381 }
1382
1383 cmd = mgmt_pending_add(sk, MGMT_OP_REMOVE_UUID, hdev, data, len);
0c01bc48 1384 if (!cmd)
90e70454 1385 err = -ENOMEM;
2aeb9a1a
JH		 1386
1387unlock:
09fd0de5 1388 hci_dev_unlock(hdev);
2aeb9a1a
JH		 1389 return err;
1390}
1391
bdb6d971 1392static int set_dev_class(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 1393 u16 len)
1aff6f09 1394{
650f726d 1395 struct mgmt_cp_set_dev_class *cp = data;
90e70454 1396 struct pending_cmd *cmd;
1aff6f09
JH		 1397 int err;
1398
bdb6d971 1399 BT_DBG("request for %s", hdev->name);
1aff6f09 1400
09fd0de5 1401 hci_dev_lock(hdev);
1aff6f09 1402
c95f0ba7 1403 if (test_bit(HCI_PENDING_CLASS, &hdev->dev_flags)) {
bdb6d971 1404 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS,
04124681 1405 MGMT_STATUS_BUSY);
c95f0ba7
JH		 1406 goto unlock;
1407 }
1408
932f5ff5
JH		 1409 hdev->major_class = cp->major;
1410 hdev->minor_class = cp->minor;
1411
b5235a65 1412 if (!hdev_is_powered(hdev)) {
bdb6d971 1413 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, 0,
04124681 1414 hdev->dev_class, 3);
b5235a65
JH		 1415 goto unlock;
1416 }
1417
a8b2d5c2 1418 if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) {
7d78525d
JH		 1419 hci_dev_unlock(hdev);
1420 cancel_delayed_work_sync(&hdev->service_cache);
1421 hci_dev_lock(hdev);
14c0b608 1422 update_eir(hdev);
7d78525d 1423 }
14c0b608 1424
1aff6f09 1425 err = update_class(hdev);
90e70454
JH		 1426 if (err < 0)
1427 goto unlock;
1aff6f09 1428
90e70454 1429 if (!test_bit(HCI_PENDING_CLASS, &hdev->dev_flags)) {
bdb6d971 1430 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, 0,
04124681 1431 hdev->dev_class, 3);
90e70454
JH		 1432 goto unlock;
1433 }
1434
1435 cmd = mgmt_pending_add(sk, MGMT_OP_SET_DEV_CLASS, hdev, data, len);
0c01bc48 1436 if (!cmd)
90e70454 1437 err = -ENOMEM;
1aff6f09 1438
b5235a65 1439unlock:
09fd0de5 1440 hci_dev_unlock(hdev);
1aff6f09
JH		 1441 return err;
1442}
1443
bdb6d971
JH		 1444static int load_link_keys(struct sock *sk, struct hci_dev *hdev, void *data,
1445 u16 len)
55ed8ca1 1446{
650f726d 1447 struct mgmt_cp_load_link_keys *cp = data;
4e51eae9 1448 u16 key_count, expected_len;
a492cd52 1449 int i;
55ed8ca1 1450
1f350c87 1451 key_count = __le16_to_cpu(cp->key_count);
55ed8ca1 1452
86742e1e
JH		 1453 expected_len = sizeof(*cp) + key_count *
1454 sizeof(struct mgmt_link_key_info);
a492cd52 1455 if (expected_len != len) {
86742e1e 1456 BT_ERR("load_link_keys: expected %u bytes, got %u bytes",
a492cd52 1457 len, expected_len);
bdb6d971 1458 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
04124681 1459 MGMT_STATUS_INVALID_PARAMS);
55ed8ca1
JH		 1460 }
1461
bdb6d971 1462 BT_DBG("%s debug_keys %u key_count %u", hdev->name, cp->debug_keys,
55ed8ca1
JH		 1463 key_count);
1464
09fd0de5 1465 hci_dev_lock(hdev);
55ed8ca1
JH		 1466
1467 hci_link_keys_clear(hdev);
1468
a8b2d5c2 1469 set_bit(HCI_LINK_KEYS, &hdev->dev_flags);
55ed8ca1
JH		 1470
1471 if (cp->debug_keys)
a8b2d5c2 1472 set_bit(HCI_DEBUG_KEYS, &hdev->dev_flags);
55ed8ca1 1473 else
a8b2d5c2 1474 clear_bit(HCI_DEBUG_KEYS, &hdev->dev_flags);
55ed8ca1 1475
a492cd52 1476 for (i = 0; i < key_count; i++) {
86742e1e 1477 struct mgmt_link_key_info *key = &cp->keys[i];
55ed8ca1 1478
d753fdc4 1479 hci_add_link_key(hdev, NULL, 0, &key->addr.bdaddr, key->val,
04124681 1480 key->type, key->pin_len);
55ed8ca1
JH		 1481 }
1482
bdb6d971 1483 cmd_complete(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS, 0, NULL, 0);
0e5f875a 1484
09fd0de5 1485 hci_dev_unlock(hdev);
55ed8ca1 1486
a492cd52 1487 return 0;
55ed8ca1
JH		 1488}
1489
b1078ad0 1490static int device_unpaired(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 1491 u8 addr_type, struct sock *skip_sk)
b1078ad0
JH		 1492{
1493 struct mgmt_ev_device_unpaired ev;
1494
1495 bacpy(&ev.addr.bdaddr, bdaddr);
1496 ev.addr.type = addr_type;
1497
1498 return mgmt_event(MGMT_EV_DEVICE_UNPAIRED, hdev, &ev, sizeof(ev),
04124681 1499 skip_sk);
b1078ad0
JH		 1500}
1501
bdb6d971 1502static int unpair_device(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 1503 u16 len)
55ed8ca1 1504{
124f6e35
JH		 1505 struct mgmt_cp_unpair_device *cp = data;
1506 struct mgmt_rp_unpair_device rp;
a8a1d19e
JH		 1507 struct hci_cp_disconnect dc;
1508 struct pending_cmd *cmd;
55ed8ca1 1509 struct hci_conn *conn;
55ed8ca1
JH		 1510 int err;
1511
09fd0de5 1512 hci_dev_lock(hdev);
55ed8ca1 1513
a8a1d19e 1514 memset(&rp, 0, sizeof(rp));
124f6e35
JH		 1515 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
1516 rp.addr.type = cp->addr.type;
a8a1d19e 1517
86a8cfc6 1518 if (!hdev_is_powered(hdev)) {
bdb6d971 1519 err = cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
04124681 1520 MGMT_STATUS_NOT_POWERED, &rp, sizeof(rp));
86a8cfc6
JH		 1521 goto unlock;
1522 }
1523
591f47f3 1524 if (cp->addr.type == BDADDR_BREDR)
124f6e35
JH		 1525 err = hci_remove_link_key(hdev, &cp->addr.bdaddr);
1526 else
1527 err = hci_remove_ltk(hdev, &cp->addr.bdaddr);
b0dbfb46 1528
55ed8ca1 1529 if (err < 0) {
bdb6d971 1530 err = cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
04124681 1531 MGMT_STATUS_NOT_PAIRED, &rp, sizeof(rp));
55ed8ca1
JH		 1532 goto unlock;
1533 }
1534
86a8cfc6 1535 if (cp->disconnect) {
591f47f3 1536 if (cp->addr.type == BDADDR_BREDR)
86a8cfc6 1537 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK,
124f6e35 1538 &cp->addr.bdaddr);
86a8cfc6
JH		 1539 else
1540 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK,
124f6e35 1541 &cp->addr.bdaddr);
86a8cfc6
JH		 1542 } else {
1543 conn = NULL;
1544 }
124f6e35 1545
a8a1d19e 1546 if (!conn) {
bdb6d971 1547 err = cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE, 0,
04124681 1548 &rp, sizeof(rp));
b1078ad0 1549 device_unpaired(hdev, &cp->addr.bdaddr, cp->addr.type, sk);
a8a1d19e
JH		 1550 goto unlock;
1551 }
55ed8ca1 1552
124f6e35 1553 cmd = mgmt_pending_add(sk, MGMT_OP_UNPAIR_DEVICE, hdev, cp,
04124681 1554 sizeof(*cp));
a8a1d19e
JH		 1555 if (!cmd) {
1556 err = -ENOMEM;
1557 goto unlock;
55ed8ca1
JH		 1558 }
1559
eb55ef07 1560 dc.handle = cpu_to_le16(conn->handle);
a8a1d19e
JH		 1561 dc.reason = 0x13; /* Remote User Terminated Connection */
1562 err = hci_send_cmd(hdev, HCI_OP_DISCONNECT, sizeof(dc), &dc);
1563 if (err < 0)
1564 mgmt_pending_remove(cmd);
1565
55ed8ca1 1566unlock:
09fd0de5 1567 hci_dev_unlock(hdev);
55ed8ca1
JH		 1568 return err;
1569}
1570
bdb6d971 1571static int disconnect(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 1572 u16 len)
8962ee74 1573{
650f726d 1574 struct mgmt_cp_disconnect *cp = data;
8962ee74 1575 struct hci_cp_disconnect dc;
366a0336 1576 struct pending_cmd *cmd;
8962ee74 1577 struct hci_conn *conn;
8962ee74
JH		 1578 int err;
1579
1580 BT_DBG("");
1581
09fd0de5 1582 hci_dev_lock(hdev);
8962ee74
JH		 1583
1584 if (!test_bit(HCI_UP, &hdev->flags)) {
bdb6d971 1585 err = cmd_status(sk, hdev->id, MGMT_OP_DISCONNECT,
04124681 1586 MGMT_STATUS_NOT_POWERED);
8962ee74
JH		 1587 goto failed;
1588 }
1589
2e58ef3e 1590 if (mgmt_pending_find(MGMT_OP_DISCONNECT, hdev)) {
bdb6d971 1591 err = cmd_status(sk, hdev->id, MGMT_OP_DISCONNECT,
04124681 1592 MGMT_STATUS_BUSY);
8962ee74
JH		 1593 goto failed;
1594 }
1595
591f47f3 1596 if (cp->addr.type == BDADDR_BREDR)
88c3df13
JH		 1597 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->addr.bdaddr);
1598 else
1599 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &cp->addr.bdaddr);
365227e5 1600
f960727e 1601 if (!conn || conn->state == BT_OPEN || conn->state == BT_CLOSED) {
bdb6d971 1602 err = cmd_status(sk, hdev->id, MGMT_OP_DISCONNECT,
04124681 1603 MGMT_STATUS_NOT_CONNECTED);
8962ee74
JH		 1604 goto failed;
1605 }
1606
2e58ef3e 1607 cmd = mgmt_pending_add(sk, MGMT_OP_DISCONNECT, hdev, data, len);
366a0336
JH		 1608 if (!cmd) {
1609 err = -ENOMEM;
8962ee74 1610 goto failed;
366a0336 1611 }
8962ee74 1612
eb55ef07 1613 dc.handle = cpu_to_le16(conn->handle);
8962ee74
JH		 1614 dc.reason = 0x13; /* Remote User Terminated Connection */
1615
1616 err = hci_send_cmd(hdev, HCI_OP_DISCONNECT, sizeof(dc), &dc);
1617 if (err < 0)
a664b5bc 1618 mgmt_pending_remove(cmd);
8962ee74
JH		 1619
1620failed:
09fd0de5 1621 hci_dev_unlock(hdev);
8962ee74
JH		 1622 return err;
1623}
1624
57c1477c 1625static u8 link_to_bdaddr(u8 link_type, u8 addr_type)
4c659c39
JH		 1626{
1627 switch (link_type) {
1628 case LE_LINK:
48264f06
JH		 1629 switch (addr_type) {
1630 case ADDR_LE_DEV_PUBLIC:
591f47f3 1631 return BDADDR_LE_PUBLIC;
0ed09148 1632
48264f06 1633 default:
0ed09148 1634 /* Fallback to LE Random address type */
591f47f3 1635 return BDADDR_LE_RANDOM;
48264f06 1636 }
0ed09148 1637
4c659c39 1638 default:
0ed09148 1639 /* Fallback to BR/EDR type */
591f47f3 1640 return BDADDR_BREDR;
4c659c39
JH		 1641 }
1642}
1643
04124681
GP		 1644static int get_connections(struct sock *sk, struct hci_dev *hdev, void *data,
1645 u16 data_len)
2784eb41 1646{
2784eb41 1647 struct mgmt_rp_get_connections *rp;
8035ded4 1648 struct hci_conn *c;
a38528f1 1649 size_t rp_len;
60fc5fb6
JH		 1650 int err;
1651 u16 i;
2784eb41
JH		 1652
1653 BT_DBG("");
1654
09fd0de5 1655 hci_dev_lock(hdev);
2784eb41 1656
5f97c1df 1657 if (!hdev_is_powered(hdev)) {
bdb6d971 1658 err = cmd_status(sk, hdev->id, MGMT_OP_GET_CONNECTIONS,
04124681 1659 MGMT_STATUS_NOT_POWERED);
5f97c1df
JH		 1660 goto unlock;
1661 }
1662
60fc5fb6 1663 i = 0;
b644ba33
JH		 1664 list_for_each_entry(c, &hdev->conn_hash.list, list) {
1665 if (test_bit(HCI_CONN_MGMT_CONNECTED, &c->flags))
60fc5fb6 1666 i++;
2784eb41
JH		 1667 }
1668
60fc5fb6 1669 rp_len = sizeof(*rp) + (i * sizeof(struct mgmt_addr_info));
a38528f1
JH		 1670 rp = kmalloc(rp_len, GFP_ATOMIC);
1671 if (!rp) {
2784eb41
JH		 1672 err = -ENOMEM;
1673 goto unlock;
1674 }
1675
2784eb41 1676 i = 0;
4c659c39 1677 list_for_each_entry(c, &hdev->conn_hash.list, list) {
b644ba33
JH		 1678 if (!test_bit(HCI_CONN_MGMT_CONNECTED, &c->flags))
1679 continue;
4c659c39 1680 bacpy(&rp->addr[i].bdaddr, &c->dst);
57c1477c 1681 rp->addr[i].type = link_to_bdaddr(c->type, c->dst_type);
0ed09148 1682 if (c->type == SCO_LINK || c->type == ESCO_LINK)
4c659c39
JH		 1683 continue;
1684 i++;
1685 }
1686
eb55ef07 1687 rp->conn_count = cpu_to_le16(i);
60fc5fb6 1688
4c659c39
JH		 1689 /* Recalculate length in case of filtered SCO connections, etc */
1690 rp_len = sizeof(*rp) + (i * sizeof(struct mgmt_addr_info));
2784eb41 1691
bdb6d971 1692 err = cmd_complete(sk, hdev->id, MGMT_OP_GET_CONNECTIONS, 0, rp,
04124681 1693 rp_len);
2784eb41 1694
a38528f1 1695 kfree(rp);
5f97c1df
JH		 1696
1697unlock:
09fd0de5 1698 hci_dev_unlock(hdev);
2784eb41
JH		 1699 return err;
1700}
1701
bdb6d971 1702static int send_pin_code_neg_reply(struct sock *sk, struct hci_dev *hdev,
04124681 1703 struct mgmt_cp_pin_code_neg_reply *cp)
96d97a67
WR		 1704{
1705 struct pending_cmd *cmd;
1706 int err;
1707
2e58ef3e 1708 cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_NEG_REPLY, hdev, cp,
04124681 1709 sizeof(*cp));
96d97a67
WR		 1710 if (!cmd)
1711 return -ENOMEM;
1712
d8457698 1713 err = hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
04124681 1714 sizeof(cp->addr.bdaddr), &cp->addr.bdaddr);
96d97a67
WR		 1715 if (err < 0)
1716 mgmt_pending_remove(cmd);
1717
1718 return err;
1719}
1720
bdb6d971 1721static int pin_code_reply(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 1722 u16 len)
980e1a53 1723{
96d97a67 1724 struct hci_conn *conn;
650f726d 1725 struct mgmt_cp_pin_code_reply *cp = data;
980e1a53 1726 struct hci_cp_pin_code_reply reply;
366a0336 1727 struct pending_cmd *cmd;
980e1a53
JH		 1728 int err;
1729
1730 BT_DBG("");
1731
09fd0de5 1732 hci_dev_lock(hdev);
980e1a53 1733
4b34ee78 1734 if (!hdev_is_powered(hdev)) {
bdb6d971 1735 err = cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
04124681 1736 MGMT_STATUS_NOT_POWERED);
980e1a53
JH		 1737 goto failed;
1738 }
1739
d8457698 1740 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->addr.bdaddr);
96d97a67 1741 if (!conn) {
bdb6d971 1742 err = cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
04124681 1743 MGMT_STATUS_NOT_CONNECTED);
96d97a67
WR		 1744 goto failed;
1745 }
1746
1747 if (conn->pending_sec_level == BT_SECURITY_HIGH && cp->pin_len != 16) {
d8457698
JH		 1748 struct mgmt_cp_pin_code_neg_reply ncp;
1749
1750 memcpy(&ncp.addr, &cp->addr, sizeof(ncp.addr));
96d97a67
WR		 1751
1752 BT_ERR("PIN code is not 16 bytes long");
1753
bdb6d971 1754 err = send_pin_code_neg_reply(sk, hdev, &ncp);
96d97a67 1755 if (err >= 0)
bdb6d971 1756 err = cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
04124681 1757 MGMT_STATUS_INVALID_PARAMS);
96d97a67
WR		 1758
1759 goto failed;
1760 }
1761
00abfe44 1762 cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_REPLY, hdev, data, len);
366a0336
JH		 1763 if (!cmd) {
1764 err = -ENOMEM;
980e1a53 1765 goto failed;
366a0336 1766 }
980e1a53 1767
d8457698 1768 bacpy(&reply.bdaddr, &cp->addr.bdaddr);
980e1a53 1769 reply.pin_len = cp->pin_len;
24718ca5 1770 memcpy(reply.pin_code, cp->pin_code, sizeof(reply.pin_code));
980e1a53
JH		 1771
1772 err = hci_send_cmd(hdev, HCI_OP_PIN_CODE_REPLY, sizeof(reply), &reply);
1773 if (err < 0)
a664b5bc 1774 mgmt_pending_remove(cmd);
980e1a53
JH		 1775
1776failed:
09fd0de5 1777 hci_dev_unlock(hdev);
980e1a53
JH		 1778 return err;
1779}
1780
bdb6d971 1781static int pin_code_neg_reply(struct sock *sk, struct hci_dev *hdev,
04124681 1782 void *data, u16 len)
980e1a53 1783{
650f726d 1784 struct mgmt_cp_pin_code_neg_reply *cp = data;
980e1a53
JH		 1785 int err;
1786
1787 BT_DBG("");
1788
09fd0de5 1789 hci_dev_lock(hdev);
980e1a53 1790
4b34ee78 1791 if (!hdev_is_powered(hdev)) {
bdb6d971 1792 err = cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_NEG_REPLY,
04124681 1793 MGMT_STATUS_NOT_POWERED);
980e1a53
JH		 1794 goto failed;
1795 }
1796
bdb6d971 1797 err = send_pin_code_neg_reply(sk, hdev, cp);
980e1a53
JH		 1798
1799failed:
09fd0de5 1800 hci_dev_unlock(hdev);
980e1a53
JH		 1801 return err;
1802}
1803
04124681
GP		 1804static int set_io_capability(struct sock *sk, struct hci_dev *hdev, void *data,
1805 u16 len)
17fa4b9d 1806{
650f726d 1807 struct mgmt_cp_set_io_capability *cp = data;
17fa4b9d
JH		 1808
1809 BT_DBG("");
1810
09fd0de5 1811 hci_dev_lock(hdev);
17fa4b9d
JH		 1812
1813 hdev->io_capability = cp->io_capability;
1814
1815 BT_DBG("%s IO capability set to 0x%02x", hdev->name,
b8534e0f 1816 hdev->io_capability);
17fa4b9d 1817
09fd0de5 1818 hci_dev_unlock(hdev);
17fa4b9d 1819
04124681
GP		 1820 return cmd_complete(sk, hdev->id, MGMT_OP_SET_IO_CAPABILITY, 0, NULL,
1821 0);
17fa4b9d
JH		 1822}
1823
e9a416b5
JH		 1824static inline struct pending_cmd *find_pairing(struct hci_conn *conn)
1825{
1826 struct hci_dev *hdev = conn->hdev;
8035ded4 1827 struct pending_cmd *cmd;
e9a416b5 1828
2e58ef3e 1829 list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
e9a416b5
JH		 1830 if (cmd->opcode != MGMT_OP_PAIR_DEVICE)
1831 continue;
1832
e9a416b5
JH		 1833 if (cmd->user_data != conn)
1834 continue;
1835
1836 return cmd;
1837 }
1838
1839 return NULL;
1840}
1841
1842static void pairing_complete(struct pending_cmd *cmd, u8 status)
1843{
1844 struct mgmt_rp_pair_device rp;
1845 struct hci_conn *conn = cmd->user_data;
1846
ba4e564f 1847 bacpy(&rp.addr.bdaddr, &conn->dst);
57c1477c 1848 rp.addr.type = link_to_bdaddr(conn->type, conn->dst_type);
e9a416b5 1849
aee9b218 1850 cmd_complete(cmd->sk, cmd->index, MGMT_OP_PAIR_DEVICE, status,
04124681 1851 &rp, sizeof(rp));
e9a416b5
JH		 1852
1853 /* So we don't get further callbacks for this connection */
1854 conn->connect_cfm_cb = NULL;
1855 conn->security_cfm_cb = NULL;
1856 conn->disconn_cfm_cb = NULL;
1857
1858 hci_conn_put(conn);
1859
a664b5bc 1860 mgmt_pending_remove(cmd);
e9a416b5
JH		 1861}
1862
1863static void pairing_complete_cb(struct hci_conn *conn, u8 status)
1864{
1865 struct pending_cmd *cmd;
1866
1867 BT_DBG("status %u", status);
1868
1869 cmd = find_pairing(conn);
56e5cb86 1870 if (!cmd)
e9a416b5 1871 BT_DBG("Unable to find a pending command");
56e5cb86 1872 else
e211326c 1873 pairing_complete(cmd, mgmt_status(status));
e9a416b5
JH		 1874}
1875
4c47d739
VA		 1876static void le_connect_complete_cb(struct hci_conn *conn, u8 status)
1877{
1878 struct pending_cmd *cmd;
1879
1880 BT_DBG("status %u", status);
1881
1882 if (!status)
1883 return;
1884
1885 cmd = find_pairing(conn);
1886 if (!cmd)
1887 BT_DBG("Unable to find a pending command");
1888 else
1889 pairing_complete(cmd, mgmt_status(status));
1890}
1891
bdb6d971 1892static int pair_device(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 1893 u16 len)
e9a416b5 1894{
650f726d 1895 struct mgmt_cp_pair_device *cp = data;
1425acb7 1896 struct mgmt_rp_pair_device rp;
e9a416b5
JH		 1897 struct pending_cmd *cmd;
1898 u8 sec_level, auth_type;
1899 struct hci_conn *conn;
e9a416b5
JH		 1900 int err;
1901
1902 BT_DBG("");
1903
09fd0de5 1904 hci_dev_lock(hdev);
e9a416b5 1905
5f97c1df 1906 if (!hdev_is_powered(hdev)) {
bdb6d971 1907 err = cmd_status(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
04124681 1908 MGMT_STATUS_NOT_POWERED);
5f97c1df
JH		 1909 goto unlock;
1910 }
1911
c908df36
VCG		 1912 sec_level = BT_SECURITY_MEDIUM;
1913 if (cp->io_cap == 0x03)
e9a416b5 1914 auth_type = HCI_AT_DEDICATED_BONDING;
c908df36 1915 else
e9a416b5 1916 auth_type = HCI_AT_DEDICATED_BONDING_MITM;
e9a416b5 1917
591f47f3 1918 if (cp->addr.type == BDADDR_BREDR)
b12f62cf
AG		 1919 conn = hci_connect(hdev, ACL_LINK, &cp->addr.bdaddr,
1920 cp->addr.type, sec_level, auth_type);
7a512d01 1921 else
b12f62cf
AG		 1922 conn = hci_connect(hdev, LE_LINK, &cp->addr.bdaddr,
1923 cp->addr.type, sec_level, auth_type);
7a512d01 1924
1425acb7
JH		 1925 memset(&rp, 0, sizeof(rp));
1926 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
1927 rp.addr.type = cp->addr.type;
1928
30e76272 1929 if (IS_ERR(conn)) {
bdb6d971 1930 err = cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
04124681
GP		 1931 MGMT_STATUS_CONNECT_FAILED, &rp,
1932 sizeof(rp));
e9a416b5
JH		 1933 goto unlock;
1934 }
1935
1936 if (conn->connect_cfm_cb) {
1937 hci_conn_put(conn);
bdb6d971 1938 err = cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
04124681 1939 MGMT_STATUS_BUSY, &rp, sizeof(rp));
e9a416b5
JH		 1940 goto unlock;
1941 }
1942
2e58ef3e 1943 cmd = mgmt_pending_add(sk, MGMT_OP_PAIR_DEVICE, hdev, data, len);
e9a416b5
JH		 1944 if (!cmd) {
1945 err = -ENOMEM;
1946 hci_conn_put(conn);
1947 goto unlock;
1948 }
1949
7a512d01 1950 /* For LE, just connecting isn't a proof that the pairing finished */
591f47f3 1951 if (cp->addr.type == BDADDR_BREDR)
7a512d01 1952 conn->connect_cfm_cb = pairing_complete_cb;
4c47d739
VA		 1953 else
1954 conn->connect_cfm_cb = le_connect_complete_cb;
7a512d01 1955
e9a416b5
JH		 1956 conn->security_cfm_cb = pairing_complete_cb;
1957 conn->disconn_cfm_cb = pairing_complete_cb;
1958 conn->io_capability = cp->io_cap;
1959 cmd->user_data = conn;
1960
1961 if (conn->state == BT_CONNECTED &&
1962 hci_conn_security(conn, sec_level, auth_type))
1963 pairing_complete(cmd, 0);
1964
1965 err = 0;
1966
1967unlock:
09fd0de5 1968 hci_dev_unlock(hdev);
e9a416b5
JH		 1969 return err;
1970}
1971
04124681
GP		 1972static int cancel_pair_device(struct sock *sk, struct hci_dev *hdev, void *data,
1973 u16 len)
28424707 1974{
0f4e68cf 1975 struct mgmt_addr_info *addr = data;
28424707
JH		 1976 struct pending_cmd *cmd;
1977 struct hci_conn *conn;
1978 int err;
1979
1980 BT_DBG("");
1981
28424707
JH		 1982 hci_dev_lock(hdev);
1983
5f97c1df 1984 if (!hdev_is_powered(hdev)) {
bdb6d971 1985 err = cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
04124681 1986 MGMT_STATUS_NOT_POWERED);
5f97c1df
JH		 1987 goto unlock;
1988 }
1989
28424707
JH		 1990 cmd = mgmt_pending_find(MGMT_OP_PAIR_DEVICE, hdev);
1991 if (!cmd) {
bdb6d971 1992 err = cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
04124681 1993 MGMT_STATUS_INVALID_PARAMS);
28424707
JH		 1994 goto unlock;
1995 }
1996
1997 conn = cmd->user_data;
1998
1999 if (bacmp(&addr->bdaddr, &conn->dst) != 0) {
bdb6d971 2000 err = cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
04124681 2001 MGMT_STATUS_INVALID_PARAMS);
28424707
JH		 2002 goto unlock;
2003 }
2004
2005 pairing_complete(cmd, MGMT_STATUS_CANCELLED);
2006
bdb6d971 2007 err = cmd_complete(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE, 0,
04124681 2008 addr, sizeof(*addr));
28424707
JH		 2009unlock:
2010 hci_dev_unlock(hdev);
28424707
JH		 2011 return err;
2012}
2013
bdb6d971 2014static int user_pairing_resp(struct sock *sk, struct hci_dev *hdev,
04124681
GP		 2015 bdaddr_t *bdaddr, u8 type, u16 mgmt_op,
2016 u16 hci_op, __le32 passkey)
a5c29683 2017{
a5c29683 2018 struct pending_cmd *cmd;
0df4c185 2019 struct hci_conn *conn;
a5c29683
JH		 2020 int err;
2021
09fd0de5 2022 hci_dev_lock(hdev);
08ba5382 2023
4b34ee78 2024 if (!hdev_is_powered(hdev)) {
bdb6d971 2025 err = cmd_status(sk, hdev->id, mgmt_op,
04124681 2026 MGMT_STATUS_NOT_POWERED);
0df4c185 2027 goto done;
a5c29683
JH		 2028 }
2029
591f47f3 2030 if (type == BDADDR_BREDR)
272d90df
JH		 2031 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, bdaddr);
2032 else
47c15e2b 2033 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, bdaddr);
272d90df
JH		 2034
2035 if (!conn) {
bdb6d971 2036 err = cmd_status(sk, hdev->id, mgmt_op,
04124681 2037 MGMT_STATUS_NOT_CONNECTED);
272d90df
JH		 2038 goto done;
2039 }
47c15e2b 2040
591f47f3 2041 if (type == BDADDR_LE_PUBLIC || type == BDADDR_LE_RANDOM) {
47c15e2b 2042 /* Continue with pairing via SMP */
5fe57d9e
BG		 2043 err = smp_user_confirm_reply(conn, mgmt_op, passkey);
2044
2045 if (!err)
bdb6d971 2046 err = cmd_status(sk, hdev->id, mgmt_op,
04124681 2047 MGMT_STATUS_SUCCESS);
5fe57d9e 2048 else
bdb6d971 2049 err = cmd_status(sk, hdev->id, mgmt_op,
04124681 2050 MGMT_STATUS_FAILED);
47c15e2b 2051
47c15e2b
BG		 2052 goto done;
2053 }
2054
0df4c185 2055 cmd = mgmt_pending_add(sk, mgmt_op, hdev, bdaddr, sizeof(*bdaddr));
a5c29683
JH		 2056 if (!cmd) {
2057 err = -ENOMEM;
0df4c185 2058 goto done;
a5c29683
JH		 2059 }
2060
0df4c185 2061 /* Continue with pairing via HCI */
604086b7
BG		 2062 if (hci_op == HCI_OP_USER_PASSKEY_REPLY) {
2063 struct hci_cp_user_passkey_reply cp;
2064
2065 bacpy(&cp.bdaddr, bdaddr);
2066 cp.passkey = passkey;
2067 err = hci_send_cmd(hdev, hci_op, sizeof(cp), &cp);
2068 } else
2069 err = hci_send_cmd(hdev, hci_op, sizeof(*bdaddr), bdaddr);
2070
a664b5bc
JH		 2071 if (err < 0)
2072 mgmt_pending_remove(cmd);
a5c29683 2073
0df4c185 2074done:
09fd0de5 2075 hci_dev_unlock(hdev);
a5c29683
JH		 2076 return err;
2077}
2078
04124681
GP		 2079static int user_confirm_reply(struct sock *sk, struct hci_dev *hdev, void *data,
2080 u16 len)
0df4c185 2081{
650f726d 2082 struct mgmt_cp_user_confirm_reply *cp = data;
0df4c185
BG		 2083
2084 BT_DBG("");
2085
2086 if (len != sizeof(*cp))
bdb6d971 2087 return cmd_status(sk, hdev->id, MGMT_OP_USER_CONFIRM_REPLY,
04124681 2088 MGMT_STATUS_INVALID_PARAMS);
0df4c185 2089
bdb6d971 2090 return user_pairing_resp(sk, hdev, &cp->addr.bdaddr, cp->addr.type,
04124681
GP		 2091 MGMT_OP_USER_CONFIRM_REPLY,
2092 HCI_OP_USER_CONFIRM_REPLY, 0);
0df4c185
BG		 2093}
2094
bdb6d971 2095static int user_confirm_neg_reply(struct sock *sk, struct hci_dev *hdev,
04124681 2096 void *data, u16 len)
0df4c185 2097{
c9c2659f 2098 struct mgmt_cp_user_confirm_neg_reply *cp = data;
0df4c185
BG		 2099
2100 BT_DBG("");
2101
bdb6d971 2102 return user_pairing_resp(sk, hdev, &cp->addr.bdaddr, cp->addr.type,
04124681
GP		 2103 MGMT_OP_USER_CONFIRM_NEG_REPLY,
2104 HCI_OP_USER_CONFIRM_NEG_REPLY, 0);
0df4c185
BG		 2105}
2106
04124681
GP		 2107static int user_passkey_reply(struct sock *sk, struct hci_dev *hdev, void *data,
2108 u16 len)
604086b7 2109{
650f726d 2110 struct mgmt_cp_user_passkey_reply *cp = data;
604086b7
BG		 2111
2112 BT_DBG("");
2113
bdb6d971 2114 return user_pairing_resp(sk, hdev, &cp->addr.bdaddr, cp->addr.type,
04124681
GP		 2115 MGMT_OP_USER_PASSKEY_REPLY,
2116 HCI_OP_USER_PASSKEY_REPLY, cp->passkey);
604086b7
BG		 2117}
2118
bdb6d971 2119static int user_passkey_neg_reply(struct sock *sk, struct hci_dev *hdev,
04124681 2120 void *data, u16 len)
604086b7 2121{
650f726d 2122 struct mgmt_cp_user_passkey_neg_reply *cp = data;
604086b7
BG		 2123
2124 BT_DBG("");
2125
bdb6d971 2126 return user_pairing_resp(sk, hdev, &cp->addr.bdaddr, cp->addr.type,
04124681
GP		 2127 MGMT_OP_USER_PASSKEY_NEG_REPLY,
2128 HCI_OP_USER_PASSKEY_NEG_REPLY, 0);
604086b7
BG		 2129}
2130
2b4bf397
JH		 2131static int update_name(struct hci_dev *hdev, const char *name)
2132{
2133 struct hci_cp_write_local_name cp;
2134
2135 memcpy(cp.name, name, sizeof(cp.name));
2136
2137 return hci_send_cmd(hdev, HCI_OP_WRITE_LOCAL_NAME, sizeof(cp), &cp);
2138}
2139
bdb6d971 2140static int set_local_name(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 2141 u16 len)
b312b161 2142{
2b4bf397 2143 struct mgmt_cp_set_local_name *cp = data;
b312b161
JH		 2144 struct pending_cmd *cmd;
2145 int err;
2146
2147 BT_DBG("");
2148
09fd0de5 2149 hci_dev_lock(hdev);
b312b161 2150
2b4bf397 2151 memcpy(hdev->short_name, cp->short_name, sizeof(hdev->short_name));
28cc7bde 2152
b5235a65 2153 if (!hdev_is_powered(hdev)) {
2b4bf397 2154 memcpy(hdev->dev_name, cp->name, sizeof(hdev->dev_name));
28cc7bde
JH		 2155
2156 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0,
04124681 2157 data, len);
28cc7bde
JH		 2158 if (err < 0)
2159 goto failed;
2160
2161 err = mgmt_event(MGMT_EV_LOCAL_NAME_CHANGED, hdev, data, len,
04124681 2162 sk);
28cc7bde 2163
b5235a65
JH		 2164 goto failed;
2165 }
2166
28cc7bde 2167 cmd = mgmt_pending_add(sk, MGMT_OP_SET_LOCAL_NAME, hdev, data, len);
b312b161
JH		 2168 if (!cmd) {
2169 err = -ENOMEM;
2170 goto failed;
2171 }
2172
2b4bf397 2173 err = update_name(hdev, cp->name);
b312b161
JH		 2174 if (err < 0)
2175 mgmt_pending_remove(cmd);
2176
2177failed:
09fd0de5 2178 hci_dev_unlock(hdev);
b312b161
JH		 2179 return err;
2180}
2181
0f4e68cf 2182static int read_local_oob_data(struct sock *sk, struct hci_dev *hdev,
04124681 2183 void *data, u16 data_len)
c35938b2 2184{
c35938b2
SJ		 2185 struct pending_cmd *cmd;
2186 int err;
2187
bdb6d971 2188 BT_DBG("%s", hdev->name);
c35938b2 2189
09fd0de5 2190 hci_dev_lock(hdev);
c35938b2 2191
4b34ee78 2192 if (!hdev_is_powered(hdev)) {
bdb6d971 2193 err = cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
04124681 2194 MGMT_STATUS_NOT_POWERED);
c35938b2
SJ		 2195 goto unlock;
2196 }
2197
2198 if (!(hdev->features[6] & LMP_SIMPLE_PAIR)) {
bdb6d971 2199 err = cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
04124681 2200 MGMT_STATUS_NOT_SUPPORTED);
c35938b2
SJ		 2201 goto unlock;
2202 }
2203
2e58ef3e 2204 if (mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev)) {
bdb6d971 2205 err = cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
04124681 2206 MGMT_STATUS_BUSY);
c35938b2
SJ		 2207 goto unlock;
2208 }
2209
2e58ef3e 2210 cmd = mgmt_pending_add(sk, MGMT_OP_READ_LOCAL_OOB_DATA, hdev, NULL, 0);
c35938b2
SJ		 2211 if (!cmd) {
2212 err = -ENOMEM;
2213 goto unlock;
2214 }
2215
2216 err = hci_send_cmd(hdev, HCI_OP_READ_LOCAL_OOB_DATA, 0, NULL);
2217 if (err < 0)
2218 mgmt_pending_remove(cmd);
2219
2220unlock:
09fd0de5 2221 hci_dev_unlock(hdev);
c35938b2
SJ		 2222 return err;
2223}
2224
bdb6d971 2225static int add_remote_oob_data(struct sock *sk, struct hci_dev *hdev,
04124681 2226 void *data, u16 len)
2763eda6 2227{
650f726d 2228 struct mgmt_cp_add_remote_oob_data *cp = data;
bf1e3541 2229 u8 status;
2763eda6
SJ		 2230 int err;
2231
bdb6d971 2232 BT_DBG("%s ", hdev->name);
2763eda6 2233
09fd0de5 2234 hci_dev_lock(hdev);
2763eda6 2235
5f97c1df 2236 if (!hdev_is_powered(hdev)) {
bdb6d971 2237 err = cmd_complete(sk, hdev->id, MGMT_OP_ADD_REMOTE_OOB_DATA,
04124681
GP		 2238 MGMT_STATUS_NOT_POWERED, &cp->addr,
2239 sizeof(cp->addr));
5f97c1df
JH		 2240 goto unlock;
2241 }
2242
664ce4cc 2243 err = hci_add_remote_oob_data(hdev, &cp->addr.bdaddr, cp->hash,
04124681 2244 cp->randomizer);
2763eda6 2245 if (err < 0)
bf1e3541 2246 status = MGMT_STATUS_FAILED;
2763eda6 2247 else
bf1e3541
JH		 2248 status = 0;
2249
bdb6d971 2250 err = cmd_complete(sk, hdev->id, MGMT_OP_ADD_REMOTE_OOB_DATA, status,
04124681 2251 &cp->addr, sizeof(cp->addr));
2763eda6 2252
5f97c1df 2253unlock:
09fd0de5 2254 hci_dev_unlock(hdev);
2763eda6
SJ		 2255 return err;
2256}
2257
bdb6d971 2258static int remove_remote_oob_data(struct sock *sk, struct hci_dev *hdev,
650f726d 2259 void *data, u16 len)
2763eda6 2260{
650f726d 2261 struct mgmt_cp_remove_remote_oob_data *cp = data;
bf1e3541 2262 u8 status;
2763eda6
SJ		 2263 int err;
2264
bdb6d971 2265 BT_DBG("%s", hdev->name);
2763eda6 2266
09fd0de5 2267 hci_dev_lock(hdev);
2763eda6 2268
5f97c1df 2269 if (!hdev_is_powered(hdev)) {
bdb6d971 2270 err = cmd_complete(sk, hdev->id,
04124681
GP		 2271 MGMT_OP_REMOVE_REMOTE_OOB_DATA,
2272 MGMT_STATUS_NOT_POWERED, &cp->addr,
2273 sizeof(cp->addr));
5f97c1df
JH		 2274 goto unlock;
2275 }
2276
664ce4cc 2277 err = hci_remove_remote_oob_data(hdev, &cp->addr.bdaddr);
2763eda6 2278 if (err < 0)
bf1e3541 2279 status = MGMT_STATUS_INVALID_PARAMS;
2763eda6 2280 else
bf1e3541
JH		 2281 status = 0;
2282
bdb6d971 2283 err = cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
04124681 2284 status, &cp->addr, sizeof(cp->addr));
2763eda6 2285
5f97c1df 2286unlock:
09fd0de5 2287 hci_dev_unlock(hdev);
2763eda6
SJ		 2288 return err;
2289}
2290
5e0452c0
AG		 2291int mgmt_interleaved_discovery(struct hci_dev *hdev)
2292{
2293 int err;
2294
2295 BT_DBG("%s", hdev->name);
2296
2297 hci_dev_lock(hdev);
2298
2299 err = hci_do_inquiry(hdev, INQUIRY_LEN_BREDR_LE);
2300 if (err < 0)
2301 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
2302
2303 hci_dev_unlock(hdev);
2304
2305 return err;
2306}
2307
bdb6d971 2308static int start_discovery(struct sock *sk, struct hci_dev *hdev,
04124681 2309 void *data, u16 len)
14a53664 2310{
650f726d 2311 struct mgmt_cp_start_discovery *cp = data;
14a53664 2312 struct pending_cmd *cmd;
14a53664
JH		 2313 int err;
2314
bdb6d971 2315 BT_DBG("%s", hdev->name);
14a53664 2316
09fd0de5 2317 hci_dev_lock(hdev);
14a53664 2318
4b34ee78 2319 if (!hdev_is_powered(hdev)) {
bdb6d971 2320 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
04124681 2321 MGMT_STATUS_NOT_POWERED);
bd2d1334
JH		 2322 goto failed;
2323 }
2324
642be6c7
AG		 2325 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags)) {
2326 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
2327 MGMT_STATUS_BUSY);
2328 goto failed;
2329 }
2330
ff9ef578 2331 if (hdev->discovery.state != DISCOVERY_STOPPED) {
bdb6d971 2332 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
04124681 2333 MGMT_STATUS_BUSY);
ff9ef578
JH		 2334 goto failed;
2335 }
2336
2e58ef3e 2337 cmd = mgmt_pending_add(sk, MGMT_OP_START_DISCOVERY, hdev, NULL, 0);
14a53664
JH		 2338 if (!cmd) {
2339 err = -ENOMEM;
2340 goto failed;
2341 }
2342
4aab14e5
AG		 2343 hdev->discovery.type = cp->type;
2344
2345 switch (hdev->discovery.type) {
f39799f5 2346 case DISCOV_TYPE_BREDR:
8b90129c
AG		 2347 if (lmp_bredr_capable(hdev))
2348 err = hci_do_inquiry(hdev, INQUIRY_LEN_BREDR);
2349 else
2350 err = -ENOTSUPP;
f39799f5
AG		 2351 break;
2352
2353 case DISCOV_TYPE_LE:
8b90129c
AG		 2354 if (lmp_host_le_capable(hdev))
2355 err = hci_le_scan(hdev, LE_SCAN_TYPE, LE_SCAN_INT,
04124681 2356 LE_SCAN_WIN, LE_SCAN_TIMEOUT_LE_ONLY);
8b90129c
AG		 2357 else
2358 err = -ENOTSUPP;
f39799f5
AG		 2359 break;
2360
5e0452c0 2361 case DISCOV_TYPE_INTERLEAVED:
426c189a
AG		 2362 if (lmp_host_le_capable(hdev) && lmp_bredr_capable(hdev))
2363 err = hci_le_scan(hdev, LE_SCAN_TYPE, LE_SCAN_INT,
04124681
GP		 2364 LE_SCAN_WIN,
2365 LE_SCAN_TIMEOUT_BREDR_LE);
426c189a
AG		 2366 else
2367 err = -ENOTSUPP;
5e0452c0
AG		 2368 break;
2369
f39799f5 2370 default:
3fd24153 2371 err = -EINVAL;
f39799f5 2372 }
3fd24153 2373
14a53664
JH		 2374 if (err < 0)
2375 mgmt_pending_remove(cmd);
ff9ef578
JH		 2376 else
2377 hci_discovery_set_state(hdev, DISCOVERY_STARTING);
14a53664
JH		 2378
2379failed:
09fd0de5 2380 hci_dev_unlock(hdev);
14a53664
JH		 2381 return err;
2382}
2383
bdb6d971 2384static int stop_discovery(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 2385 u16 len)
14a53664 2386{
d930650b 2387 struct mgmt_cp_stop_discovery *mgmt_cp = data;
14a53664 2388 struct pending_cmd *cmd;
30dc78e1
JH		 2389 struct hci_cp_remote_name_req_cancel cp;
2390 struct inquiry_entry *e;
14a53664
JH		 2391 int err;
2392
bdb6d971 2393 BT_DBG("%s", hdev->name);
14a53664 2394
09fd0de5 2395 hci_dev_lock(hdev);
14a53664 2396
30dc78e1 2397 if (!hci_discovery_active(hdev)) {
bdb6d971 2398 err = cmd_complete(sk, hdev->id, MGMT_OP_STOP_DISCOVERY,
04124681
GP		 2399 MGMT_STATUS_REJECTED, &mgmt_cp->type,
2400 sizeof(mgmt_cp->type));
d930650b
JH		 2401 goto unlock;
2402 }
2403
2404 if (hdev->discovery.type != mgmt_cp->type) {
bdb6d971 2405 err = cmd_complete(sk, hdev->id, MGMT_OP_STOP_DISCOVERY,
04124681
GP		 2406 MGMT_STATUS_INVALID_PARAMS, &mgmt_cp->type,
2407 sizeof(mgmt_cp->type));
30dc78e1 2408 goto unlock;
ff9ef578
JH		 2409 }
2410
2e58ef3e 2411 cmd = mgmt_pending_add(sk, MGMT_OP_STOP_DISCOVERY, hdev, NULL, 0);
14a53664
JH		 2412 if (!cmd) {
2413 err = -ENOMEM;
30dc78e1
JH		 2414 goto unlock;
2415 }
2416
e0d9727e
AG		 2417 switch (hdev->discovery.state) {
2418 case DISCOVERY_FINDING:
c9ecc48e
AG		 2419 if (test_bit(HCI_INQUIRY, &hdev->flags))
2420 err = hci_cancel_inquiry(hdev);
2421 else
2422 err = hci_cancel_le_scan(hdev);
2423
e0d9727e
AG		 2424 break;
2425
2426 case DISCOVERY_RESOLVING:
2427 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY,
2428 NAME_PENDING);
2429 if (!e) {
30dc78e1 2430 mgmt_pending_remove(cmd);
e0d9727e
AG		 2431 err = cmd_complete(sk, hdev->id,
2432 MGMT_OP_STOP_DISCOVERY, 0,
2433 &mgmt_cp->type,
2434 sizeof(mgmt_cp->type));
2435 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
2436 goto unlock;
2437 }
30dc78e1 2438
e0d9727e
AG		 2439 bacpy(&cp.bdaddr, &e->data.bdaddr);
2440 err = hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ_CANCEL,
2441 sizeof(cp), &cp);
2442
2443 break;
2444
2445 default:
2446 BT_DBG("unknown discovery state %u", hdev->discovery.state);
2447 err = -EFAULT;
14a53664
JH		 2448 }
2449
14a53664
JH		 2450 if (err < 0)
2451 mgmt_pending_remove(cmd);
ff9ef578
JH		 2452 else
2453 hci_discovery_set_state(hdev, DISCOVERY_STOPPING);
14a53664 2454
30dc78e1 2455unlock:
09fd0de5 2456 hci_dev_unlock(hdev);
14a53664
JH		 2457 return err;
2458}
2459
bdb6d971 2460static int confirm_name(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 2461 u16 len)
561aafbc 2462{
650f726d 2463 struct mgmt_cp_confirm_name *cp = data;
561aafbc 2464 struct inquiry_entry *e;
561aafbc
JH		 2465 int err;
2466
bdb6d971 2467 BT_DBG("%s", hdev->name);
561aafbc 2468
561aafbc
JH		 2469 hci_dev_lock(hdev);
2470
30dc78e1 2471 if (!hci_discovery_active(hdev)) {
bdb6d971 2472 err = cmd_status(sk, hdev->id, MGMT_OP_CONFIRM_NAME,
04124681 2473 MGMT_STATUS_FAILED);
30dc78e1
JH		 2474 goto failed;
2475 }
2476
a198e7b1 2477 e = hci_inquiry_cache_lookup_unknown(hdev, &cp->addr.bdaddr);
561aafbc 2478 if (!e) {
bdb6d971 2479 err = cmd_status(sk, hdev->id, MGMT_OP_CONFIRM_NAME,
04124681 2480 MGMT_STATUS_INVALID_PARAMS);
561aafbc
JH		 2481 goto failed;
2482 }
2483
2484 if (cp->name_known) {
2485 e->name_state = NAME_KNOWN;
2486 list_del(&e->list);
2487 } else {
2488 e->name_state = NAME_NEEDED;
a3d4e20a 2489 hci_inquiry_cache_update_resolve(hdev, e);
561aafbc
JH		 2490 }
2491
2492 err = 0;
2493
2494failed:
2495 hci_dev_unlock(hdev);
561aafbc
JH		 2496 return err;
2497}
2498
bdb6d971 2499static int block_device(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 2500 u16 len)
7fbec224 2501{
650f726d 2502 struct mgmt_cp_block_device *cp = data;
f0eeea8b 2503 u8 status;
7fbec224
AJ		 2504 int err;
2505
bdb6d971 2506 BT_DBG("%s", hdev->name);
7fbec224 2507
09fd0de5 2508 hci_dev_lock(hdev);
5e762444 2509
88c1fe4b 2510 err = hci_blacklist_add(hdev, &cp->addr.bdaddr, cp->addr.type);
7fbec224 2511 if (err < 0)
f0eeea8b 2512 status = MGMT_STATUS_FAILED;
7fbec224 2513 else
f0eeea8b
JH		 2514 status = 0;
2515
bdb6d971 2516 err = cmd_complete(sk, hdev->id, MGMT_OP_BLOCK_DEVICE, status,
04124681 2517 &cp->addr, sizeof(cp->addr));
5e762444 2518
09fd0de5 2519 hci_dev_unlock(hdev);
7fbec224
AJ		 2520
2521 return err;
2522}
2523
bdb6d971 2524static int unblock_device(struct sock *sk, struct hci_dev *hdev, void *data,
04124681 2525 u16 len)
7fbec224 2526{
650f726d 2527 struct mgmt_cp_unblock_device *cp = data;
f0eeea8b 2528 u8 status;
7fbec224
AJ		 2529 int err;
2530
bdb6d971 2531 BT_DBG("%s", hdev->name);
7fbec224 2532
09fd0de5 2533 hci_dev_lock(hdev);
5e762444 2534
88c1fe4b 2535 err = hci_blacklist_del(hdev, &cp->addr.bdaddr, cp->addr.type);
7fbec224 2536 if (err < 0)
f0eeea8b 2537 status = MGMT_STATUS_INVALID_PARAMS;
7fbec224 2538 else
f0eeea8b
JH		 2539 status = 0;
2540
bdb6d971 2541 err = cmd_complete(sk, hdev->id, MGMT_OP_UNBLOCK_DEVICE, status,
04124681 2542 &cp->addr, sizeof(cp->addr));
5e762444 2543
09fd0de5 2544 hci_dev_unlock(hdev);
7fbec224
AJ		 2545
2546 return err;
2547}
2548
cdbaccca
MH		 2549static int set_device_id(struct sock *sk, struct hci_dev *hdev, void *data,
2550 u16 len)
2551{
2552 struct mgmt_cp_set_device_id *cp = data;
2553 int err;
c72d4b8a 2554 __u16 source;
cdbaccca
MH		 2555
2556 BT_DBG("%s", hdev->name);
2557
c72d4b8a
SJ		 2558 source = __le16_to_cpu(cp->source);
2559
2560 if (source > 0x0002)
2561 return cmd_status(sk, hdev->id, MGMT_OP_SET_DEVICE_ID,
2562 MGMT_STATUS_INVALID_PARAMS);
2563
cdbaccca
MH		 2564 hci_dev_lock(hdev);
2565
c72d4b8a 2566 hdev->devid_source = source;
cdbaccca
MH		 2567 hdev->devid_vendor = __le16_to_cpu(cp->vendor);
2568 hdev->devid_product = __le16_to_cpu(cp->product);
2569 hdev->devid_version = __le16_to_cpu(cp->version);
2570
2571 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_DEVICE_ID, 0, NULL, 0);
2572
2573 update_eir(hdev);
2574
2575 hci_dev_unlock(hdev);
2576
2577 return err;
2578}
2579
bdb6d971 2580static int set_fast_connectable(struct sock *sk, struct hci_dev *hdev,
04124681 2581 void *data, u16 len)
f6422ec6 2582{
650f726d 2583 struct mgmt_mode *cp = data;
f6422ec6
AJ		 2584 struct hci_cp_write_page_scan_activity acp;
2585 u8 type;
2586 int err;
2587
bdb6d971 2588 BT_DBG("%s", hdev->name);
f6422ec6 2589
5400c044 2590 if (!hdev_is_powered(hdev))
bdb6d971 2591 return cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
04124681 2592 MGMT_STATUS_NOT_POWERED);
5400c044
JH		 2593
2594 if (!test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
bdb6d971 2595 return cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
04124681 2596 MGMT_STATUS_REJECTED);
f6422ec6
AJ		 2597
2598 hci_dev_lock(hdev);
2599
f7c6869c 2600 if (cp->val) {
f6422ec6 2601 type = PAGE_SCAN_TYPE_INTERLACED;
76ec9de8
AE		 2602
2603 /* 22.5 msec page scan interval */
2604 acp.interval = __constant_cpu_to_le16(0x0024);
f6422ec6
AJ		 2605 } else {
2606 type = PAGE_SCAN_TYPE_STANDARD; /* default */
76ec9de8
AE		 2607
2608 /* default 1.28 sec page scan */
2609 acp.interval = __constant_cpu_to_le16(0x0800);
f6422ec6
AJ		 2610 }
2611
76ec9de8
AE		 2612 /* default 11.25 msec page scan window */
2613 acp.window = __constant_cpu_to_le16(0x0012);
f6422ec6 2614
04124681
GP		 2615 err = hci_send_cmd(hdev, HCI_OP_WRITE_PAGE_SCAN_ACTIVITY, sizeof(acp),
2616 &acp);
f6422ec6 2617 if (err < 0) {
bdb6d971 2618 err = cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
04124681 2619 MGMT_STATUS_FAILED);
f6422ec6
AJ		 2620 goto done;
2621 }
2622
2623 err = hci_send_cmd(hdev, HCI_OP_WRITE_PAGE_SCAN_TYPE, 1, &type);
2624 if (err < 0) {
bdb6d971 2625 err = cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
04124681 2626 MGMT_STATUS_FAILED);
f6422ec6
AJ		 2627 goto done;
2628 }
2629
bdb6d971 2630 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE, 0,
04124681 2631 NULL, 0);
f6422ec6
AJ		 2632done:
2633 hci_dev_unlock(hdev);
f6422ec6
AJ		 2634 return err;
2635}
2636
bdb6d971 2637static int load_long_term_keys(struct sock *sk, struct hci_dev *hdev,
04124681 2638 void *cp_data, u16 len)
346af67b 2639{
346af67b
VCG		 2640 struct mgmt_cp_load_long_term_keys *cp = cp_data;
2641 u16 key_count, expected_len;
2642 int i;
2643
1f350c87 2644 key_count = __le16_to_cpu(cp->key_count);
346af67b
VCG		 2645
2646 expected_len = sizeof(*cp) + key_count *
2647 sizeof(struct mgmt_ltk_info);
2648 if (expected_len != len) {
2649 BT_ERR("load_keys: expected %u bytes, got %u bytes",
2650 len, expected_len);
bdb6d971 2651 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LONG_TERM_KEYS,
04124681 2652 EINVAL);
346af67b
VCG		 2653 }
2654
bdb6d971 2655 BT_DBG("%s key_count %u", hdev->name, key_count);
346af67b
VCG		 2656
2657 hci_dev_lock(hdev);
2658
2659 hci_smp_ltks_clear(hdev);
2660
2661 for (i = 0; i < key_count; i++) {
2662 struct mgmt_ltk_info *key = &cp->keys[i];
2663 u8 type;
2664
2665 if (key->master)
2666 type = HCI_SMP_LTK;
2667 else
2668 type = HCI_SMP_LTK_SLAVE;
2669
4596fde5 2670 hci_add_ltk(hdev, &key->addr.bdaddr,
378b5b7e 2671 bdaddr_to_le(key->addr.type),
04124681
GP		 2672 type, 0, key->authenticated, key->val,
2673 key->enc_size, key->ediv, key->rand);
346af67b
VCG		 2674 }
2675
2676 hci_dev_unlock(hdev);
346af67b
VCG		 2677
2678 return 0;
2679}
2680
2e3c35ea 2681static const struct mgmt_handler {
04124681
GP		 2682 int (*func) (struct sock *sk, struct hci_dev *hdev, void *data,
2683 u16 data_len);
be22b54e
JH		 2684 bool var_len;
2685 size_t data_len;
0f4e68cf
JH		 2686} mgmt_handlers[] = {
2687 { NULL }, /* 0x0000 (no command) */
be22b54e
JH		 2688 { read_version, false, MGMT_READ_VERSION_SIZE },
2689 { read_commands, false, MGMT_READ_COMMANDS_SIZE },
2690 { read_index_list, false, MGMT_READ_INDEX_LIST_SIZE },
2691 { read_controller_info, false, MGMT_READ_INFO_SIZE },
2692 { set_powered, false, MGMT_SETTING_SIZE },
2693 { set_discoverable, false, MGMT_SET_DISCOVERABLE_SIZE },
2694 { set_connectable, false, MGMT_SETTING_SIZE },
2695 { set_fast_connectable, false, MGMT_SETTING_SIZE },
2696 { set_pairable, false, MGMT_SETTING_SIZE },
2697 { set_link_security, false, MGMT_SETTING_SIZE },
2698 { set_ssp, false, MGMT_SETTING_SIZE },
2699 { set_hs, false, MGMT_SETTING_SIZE },
2700 { set_le, false, MGMT_SETTING_SIZE },
2701 { set_dev_class, false, MGMT_SET_DEV_CLASS_SIZE },
2702 { set_local_name, false, MGMT_SET_LOCAL_NAME_SIZE },
2703 { add_uuid, false, MGMT_ADD_UUID_SIZE },
2704 { remove_uuid, false, MGMT_REMOVE_UUID_SIZE },
2705 { load_link_keys, true, MGMT_LOAD_LINK_KEYS_SIZE },
2706 { load_long_term_keys, true, MGMT_LOAD_LONG_TERM_KEYS_SIZE },
2707 { disconnect, false, MGMT_DISCONNECT_SIZE },
2708 { get_connections, false, MGMT_GET_CONNECTIONS_SIZE },
2709 { pin_code_reply, false, MGMT_PIN_CODE_REPLY_SIZE },
2710 { pin_code_neg_reply, false, MGMT_PIN_CODE_NEG_REPLY_SIZE },
2711 { set_io_capability, false, MGMT_SET_IO_CAPABILITY_SIZE },
2712 { pair_device, false, MGMT_PAIR_DEVICE_SIZE },
2713 { cancel_pair_device, false, MGMT_CANCEL_PAIR_DEVICE_SIZE },
2714 { unpair_device, false, MGMT_UNPAIR_DEVICE_SIZE },
2715 { user_confirm_reply, false, MGMT_USER_CONFIRM_REPLY_SIZE },
2716 { user_confirm_neg_reply, false, MGMT_USER_CONFIRM_NEG_REPLY_SIZE },
2717 { user_passkey_reply, false, MGMT_USER_PASSKEY_REPLY_SIZE },
2718 { user_passkey_neg_reply, false, MGMT_USER_PASSKEY_NEG_REPLY_SIZE },
2719 { read_local_oob_data, false, MGMT_READ_LOCAL_OOB_DATA_SIZE },
2720 { add_remote_oob_data, false, MGMT_ADD_REMOTE_OOB_DATA_SIZE },
2721 { remove_remote_oob_data, false, MGMT_REMOVE_REMOTE_OOB_DATA_SIZE },
2722 { start_discovery, false, MGMT_START_DISCOVERY_SIZE },
2723 { stop_discovery, false, MGMT_STOP_DISCOVERY_SIZE },
2724 { confirm_name, false, MGMT_CONFIRM_NAME_SIZE },
2725 { block_device, false, MGMT_BLOCK_DEVICE_SIZE },
2726 { unblock_device, false, MGMT_UNBLOCK_DEVICE_SIZE },
cdbaccca 2727 { set_device_id, false, MGMT_SET_DEVICE_ID_SIZE },
0f4e68cf
JH		 2728};
2729
2730
0381101f
JH		 2731int mgmt_control(struct sock *sk, struct msghdr *msg, size_t msglen)
2732{
650f726d
VCG		 2733 void *buf;
2734 u8 *cp;
0381101f 2735 struct mgmt_hdr *hdr;
4e51eae9 2736 u16 opcode, index, len;
bdb6d971 2737 struct hci_dev *hdev = NULL;
2e3c35ea 2738 const struct mgmt_handler *handler;
0381101f
JH		 2739 int err;
2740
2741 BT_DBG("got %zu bytes", msglen);
2742
2743 if (msglen < sizeof(*hdr))
2744 return -EINVAL;
2745
e63a15ec 2746 buf = kmalloc(msglen, GFP_KERNEL);
0381101f
JH		 2747 if (!buf)
2748 return -ENOMEM;
2749
2750 if (memcpy_fromiovec(buf, msg->msg_iov, msglen)) {
2751 err = -EFAULT;
2752 goto done;
2753 }
2754
650f726d 2755 hdr = buf;
1f350c87
MH		 2756 opcode = __le16_to_cpu(hdr->opcode);
2757 index = __le16_to_cpu(hdr->index);
2758 len = __le16_to_cpu(hdr->len);
0381101f
JH		 2759
2760 if (len != msglen - sizeof(*hdr)) {
2761 err = -EINVAL;
2762 goto done;
2763 }
2764
0f4e68cf 2765 if (index != MGMT_INDEX_NONE) {
bdb6d971
JH		 2766 hdev = hci_dev_get(index);
2767 if (!hdev) {
2768 err = cmd_status(sk, index, opcode,
04124681 2769 MGMT_STATUS_INVALID_INDEX);
bdb6d971
JH		 2770 goto done;
2771 }
2772 }
2773
0f4e68cf
JH		 2774 if (opcode >= ARRAY_SIZE(mgmt_handlers) ||
2775 mgmt_handlers[opcode].func == NULL) {
0381101f 2776 BT_DBG("Unknown op %u", opcode);
ca69b795 2777 err = cmd_status(sk, index, opcode,
04124681 2778 MGMT_STATUS_UNKNOWN_COMMAND);
0f4e68cf
JH		 2779 goto done;
2780 }
2781
2782 if ((hdev && opcode < MGMT_OP_READ_INFO) ||
2783 (!hdev && opcode >= MGMT_OP_READ_INFO)) {
2784 err = cmd_status(sk, index, opcode,
04124681 2785 MGMT_STATUS_INVALID_INDEX);
0f4e68cf 2786 goto done;
0381101f
JH		 2787 }
2788
be22b54e
JH		 2789 handler = &mgmt_handlers[opcode];
2790
2791 if ((handler->var_len && len < handler->data_len) ||
2792 (!handler->var_len && len != handler->data_len)) {
2793 err = cmd_status(sk, index, opcode,
04124681 2794 MGMT_STATUS_INVALID_PARAMS);
be22b54e
JH		 2795 goto done;
2796 }
2797
0f4e68cf
JH		 2798 if (hdev)
2799 mgmt_init_hdev(sk, hdev);
2800
2801 cp = buf + sizeof(*hdr);
2802
be22b54e 2803 err = handler->func(sk, hdev, cp, len);
e41d8b4e
JH		 2804 if (err < 0)
2805 goto done;
2806
0381101f
JH		 2807 err = msglen;
2808
2809done:
bdb6d971
JH		 2810 if (hdev)
2811 hci_dev_put(hdev);
2812
0381101f
JH		 2813 kfree(buf);
2814 return err;
2815}
c71e97bf 2816
b24752fe
JH		 2817static void cmd_status_rsp(struct pending_cmd *cmd, void *data)
2818{
2819 u8 *status = data;
2820
2821 cmd_status(cmd->sk, cmd->index, cmd->opcode, *status);
2822 mgmt_pending_remove(cmd);
2823}
2824
744cf19e 2825int mgmt_index_added(struct hci_dev *hdev)
c71e97bf 2826{
744cf19e 2827 return mgmt_event(MGMT_EV_INDEX_ADDED, hdev, NULL, 0, NULL);
c71e97bf
JH		 2828}
2829
744cf19e 2830int mgmt_index_removed(struct hci_dev *hdev)
c71e97bf 2831{
5f159032 2832 u8 status = MGMT_STATUS_INVALID_INDEX;
b24752fe 2833
744cf19e 2834 mgmt_pending_foreach(0, hdev, cmd_status_rsp, &status);
b24752fe 2835
744cf19e 2836 return mgmt_event(MGMT_EV_INDEX_REMOVED, hdev, NULL, 0, NULL);
eec8d2bc
JH		 2837}
2838
73f22f62 2839struct cmd_lookup {
eec8d2bc 2840 struct sock *sk;
69ab39ea 2841 struct hci_dev *hdev;
90e70454 2842 u8 mgmt_status;
eec8d2bc
JH		 2843};
2844
69ab39ea 2845static void settings_rsp(struct pending_cmd *cmd, void *data)
eec8d2bc 2846{
73f22f62 2847 struct cmd_lookup *match = data;
eec8d2bc 2848
69ab39ea 2849 send_settings_rsp(cmd->sk, cmd->opcode, match->hdev);
eec8d2bc
JH		 2850
2851 list_del(&cmd->list);
2852
2853 if (match->sk == NULL) {
2854 match->sk = cmd->sk;
2855 sock_hold(match->sk);
2856 }
2857
2858 mgmt_pending_free(cmd);
c71e97bf 2859}
5add6af8 2860
744cf19e 2861int mgmt_powered(struct hci_dev *hdev, u8 powered)
5add6af8 2862{
76a7f3a4 2863 struct cmd_lookup match = { NULL, hdev };
7bb895d6 2864 int err;
5add6af8 2865
5e5282bb
JH		 2866 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
2867 return 0;
2868
69ab39ea 2869 mgmt_pending_foreach(MGMT_OP_SET_POWERED, hdev, settings_rsp, &match);
5add6af8 2870
5e5282bb
JH		 2871 if (powered) {
2872 u8 scan = 0;
2873
2874 if (test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
2875 scan |= SCAN_PAGE;
2876 if (test_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
2877 scan |= SCAN_INQUIRY;
2878
2879 if (scan)
2880 hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
504c8dcd
JH		 2881
2882 update_class(hdev);
2b4bf397 2883 update_name(hdev, hdev->dev_name);
504c8dcd 2884 update_eir(hdev);
5e5282bb 2885 } else {
d4f68526 2886 u8 status = MGMT_STATUS_NOT_POWERED;
744cf19e 2887 mgmt_pending_foreach(0, hdev, cmd_status_rsp, &status);
b24752fe
JH		 2888 }
2889
beadb2bd 2890 err = new_settings(hdev, match.sk);
eec8d2bc
JH		 2891
2892 if (match.sk)
2893 sock_put(match.sk);
2894
7bb895d6 2895 return err;
5add6af8 2896}
73f22f62 2897
744cf19e 2898int mgmt_discoverable(struct hci_dev *hdev, u8 discoverable)
73f22f62 2899{
76a7f3a4 2900 struct cmd_lookup match = { NULL, hdev };
5e5282bb
JH		 2901 bool changed = false;
2902 int err = 0;
73f22f62 2903
5e5282bb
JH		 2904 if (discoverable) {
2905 if (!test_and_set_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
2906 changed = true;
2907 } else {
2908 if (test_and_clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
2909 changed = true;
2910 }
73f22f62 2911
ed9b5f2f 2912 mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE, hdev, settings_rsp,
04124681 2913 &match);
ed9b5f2f 2914
beadb2bd
JH		 2915 if (changed)
2916 err = new_settings(hdev, match.sk);
5e5282bb 2917
73f22f62
JH		 2918 if (match.sk)
2919 sock_put(match.sk);
2920
7bb895d6 2921 return err;
73f22f62 2922}
9fbcbb45 2923
744cf19e 2924int mgmt_connectable(struct hci_dev *hdev, u8 connectable)
9fbcbb45 2925{
76a7f3a4 2926 struct cmd_lookup match = { NULL, hdev };
5e5282bb
JH		 2927 bool changed = false;
2928 int err = 0;
9fbcbb45 2929
5e5282bb
JH		 2930 if (connectable) {
2931 if (!test_and_set_bit(HCI_CONNECTABLE, &hdev->dev_flags))
2932 changed = true;
2933 } else {
2934 if (test_and_clear_bit(HCI_CONNECTABLE, &hdev->dev_flags))
2935 changed = true;
2936 }
9fbcbb45 2937
ed9b5f2f 2938 mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE, hdev, settings_rsp,
04124681 2939 &match);
ed9b5f2f 2940
beadb2bd
JH		 2941 if (changed)
2942 err = new_settings(hdev, match.sk);
9fbcbb45
JH		 2943
2944 if (match.sk)
2945 sock_put(match.sk);
2946
7bb895d6 2947 return err;
9fbcbb45 2948}
55ed8ca1 2949
744cf19e 2950int mgmt_write_scan_failed(struct hci_dev *hdev, u8 scan, u8 status)
2d7cee58 2951{
ca69b795
JH		 2952 u8 mgmt_err = mgmt_status(status);
2953
2d7cee58 2954 if (scan & SCAN_PAGE)
744cf19e 2955 mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE, hdev,
04124681 2956 cmd_status_rsp, &mgmt_err);
2d7cee58
JH		 2957
2958 if (scan & SCAN_INQUIRY)
744cf19e 2959 mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE, hdev,
04124681 2960 cmd_status_rsp, &mgmt_err);
2d7cee58
JH		 2961
2962 return 0;
2963}
2964
53168e5b
CC		 2965int mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
2966 bool persistent)
55ed8ca1 2967{
86742e1e 2968 struct mgmt_ev_new_link_key ev;
55ed8ca1 2969
a492cd52 2970 memset(&ev, 0, sizeof(ev));
55ed8ca1 2971
a492cd52 2972 ev.store_hint = persistent;
d753fdc4 2973 bacpy(&ev.key.addr.bdaddr, &key->bdaddr);
591f47f3 2974 ev.key.addr.type = BDADDR_BREDR;
a492cd52
VCG		 2975 ev.key.type = key->type;
2976 memcpy(ev.key.val, key->val, 16);
2977 ev.key.pin_len = key->pin_len;
55ed8ca1 2978
744cf19e 2979 return mgmt_event(MGMT_EV_NEW_LINK_KEY, hdev, &ev, sizeof(ev), NULL);
55ed8ca1 2980}
f7520543 2981
346af67b
VCG		 2982int mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, u8 persistent)
2983{
2984 struct mgmt_ev_new_long_term_key ev;
2985
2986 memset(&ev, 0, sizeof(ev));
2987
2988 ev.store_hint = persistent;
2989 bacpy(&ev.key.addr.bdaddr, &key->bdaddr);
57c1477c 2990 ev.key.addr.type = link_to_bdaddr(LE_LINK, key->bdaddr_type);
346af67b
VCG		 2991 ev.key.authenticated = key->authenticated;
2992 ev.key.enc_size = key->enc_size;
2993 ev.key.ediv = key->ediv;
2994
2995 if (key->type == HCI_SMP_LTK)
2996 ev.key.master = 1;
2997
2998 memcpy(ev.key.rand, key->rand, sizeof(key->rand));
2999 memcpy(ev.key.val, key->val, sizeof(key->val));
3000
04124681
GP		 3001 return mgmt_event(MGMT_EV_NEW_LONG_TERM_KEY, hdev, &ev, sizeof(ev),
3002 NULL);
346af67b
VCG		 3003}
3004
afc747a6 3005int mgmt_device_connected(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
04124681
GP		 3006 u8 addr_type, u32 flags, u8 *name, u8 name_len,
3007 u8 *dev_class)
f7520543 3008{
b644ba33
JH		 3009 char buf[512];
3010 struct mgmt_ev_device_connected *ev = (void *) buf;
3011 u16 eir_len = 0;
f7520543 3012
b644ba33 3013 bacpy(&ev->addr.bdaddr, bdaddr);
57c1477c 3014 ev->addr.type = link_to_bdaddr(link_type, addr_type);
f7520543 3015
c95f0ba7 3016 ev->flags = __cpu_to_le32(flags);
08c79b61 3017
b644ba33
JH		 3018 if (name_len > 0)
3019 eir_len = eir_append_data(ev->eir, 0, EIR_NAME_COMPLETE,
04124681 3020 name, name_len);
b644ba33
JH		 3021
3022 if (dev_class && memcmp(dev_class, "\0\0\0", 3) != 0)
53156385 3023 eir_len = eir_append_data(ev->eir, eir_len,
04124681 3024 EIR_CLASS_OF_DEV, dev_class, 3);
b644ba33 3025
eb55ef07 3026 ev->eir_len = cpu_to_le16(eir_len);
b644ba33
JH		 3027
3028 return mgmt_event(MGMT_EV_DEVICE_CONNECTED, hdev, buf,
04124681 3029 sizeof(*ev) + eir_len, NULL);
f7520543
JH		 3030}
3031
8962ee74
JH		 3032static void disconnect_rsp(struct pending_cmd *cmd, void *data)
3033{
c68fb7ff 3034 struct mgmt_cp_disconnect *cp = cmd->param;
8962ee74 3035 struct sock **sk = data;
a38528f1 3036 struct mgmt_rp_disconnect rp;
8962ee74 3037
88c3df13
JH		 3038 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
3039 rp.addr.type = cp->addr.type;
8962ee74 3040
aee9b218 3041 cmd_complete(cmd->sk, cmd->index, MGMT_OP_DISCONNECT, 0, &rp,
04124681 3042 sizeof(rp));
8962ee74
JH		 3043
3044 *sk = cmd->sk;
3045 sock_hold(*sk);
3046
a664b5bc 3047 mgmt_pending_remove(cmd);
8962ee74
JH		 3048}
3049
124f6e35 3050static void unpair_device_rsp(struct pending_cmd *cmd, void *data)
a8a1d19e 3051{
b1078ad0 3052 struct hci_dev *hdev = data;
124f6e35
JH		 3053 struct mgmt_cp_unpair_device *cp = cmd->param;
3054 struct mgmt_rp_unpair_device rp;
a8a1d19e
JH		 3055
3056 memset(&rp, 0, sizeof(rp));
124f6e35
JH		 3057 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
3058 rp.addr.type = cp->addr.type;
a8a1d19e 3059
b1078ad0
JH		 3060 device_unpaired(hdev, &cp->addr.bdaddr, cp->addr.type, cmd->sk);
3061
aee9b218 3062 cmd_complete(cmd->sk, cmd->index, cmd->opcode, 0, &rp, sizeof(rp));
a8a1d19e
JH		 3063
3064 mgmt_pending_remove(cmd);
3065}
3066
afc747a6 3067int mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 3068 u8 link_type, u8 addr_type)
f7520543 3069{
4c659c39 3070 struct mgmt_addr_info ev;
8962ee74
JH		 3071 struct sock *sk = NULL;
3072 int err;
3073
744cf19e 3074 mgmt_pending_foreach(MGMT_OP_DISCONNECT, hdev, disconnect_rsp, &sk);
f7520543 3075
f7520543 3076 bacpy(&ev.bdaddr, bdaddr);
57c1477c 3077 ev.type = link_to_bdaddr(link_type, addr_type);
f7520543 3078
afc747a6 3079 err = mgmt_event(MGMT_EV_DEVICE_DISCONNECTED, hdev, &ev, sizeof(ev),
04124681 3080 sk);
8962ee74
JH		 3081
3082 if (sk)
d97dcb66 3083 sock_put(sk);
8962ee74 3084
124f6e35 3085 mgmt_pending_foreach(MGMT_OP_UNPAIR_DEVICE, hdev, unpair_device_rsp,
04124681 3086 hdev);
a8a1d19e 3087
8962ee74
JH		 3088 return err;
3089}
3090
88c3df13 3091int mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 3092 u8 link_type, u8 addr_type, u8 status)
8962ee74 3093{
88c3df13 3094 struct mgmt_rp_disconnect rp;
8962ee74
JH		 3095 struct pending_cmd *cmd;
3096 int err;
3097
2e58ef3e 3098 cmd = mgmt_pending_find(MGMT_OP_DISCONNECT, hdev);
8962ee74
JH		 3099 if (!cmd)
3100 return -ENOENT;
3101
88c3df13 3102 bacpy(&rp.addr.bdaddr, bdaddr);
57c1477c 3103 rp.addr.type = link_to_bdaddr(link_type, addr_type);
37d9ef76 3104
88c3df13 3105 err = cmd_complete(cmd->sk, cmd->index, MGMT_OP_DISCONNECT,
04124681 3106 mgmt_status(status), &rp, sizeof(rp));
8962ee74 3107
a664b5bc 3108 mgmt_pending_remove(cmd);
8962ee74 3109
b1078ad0
JH		 3110 mgmt_pending_foreach(MGMT_OP_UNPAIR_DEVICE, hdev, unpair_device_rsp,
3111 hdev);
8962ee74 3112 return err;
f7520543 3113}
17d5c04c 3114
48264f06 3115int mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
04124681 3116 u8 addr_type, u8 status)
17d5c04c
JH		 3117{
3118 struct mgmt_ev_connect_failed ev;
3119
4c659c39 3120 bacpy(&ev.addr.bdaddr, bdaddr);
57c1477c 3121 ev.addr.type = link_to_bdaddr(link_type, addr_type);
ca69b795 3122 ev.status = mgmt_status(status);
17d5c04c 3123
744cf19e 3124 return mgmt_event(MGMT_EV_CONNECT_FAILED, hdev, &ev, sizeof(ev), NULL);
17d5c04c 3125}
980e1a53 3126
744cf19e 3127int mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure)
980e1a53
JH		 3128{
3129 struct mgmt_ev_pin_code_request ev;
3130
d8457698 3131 bacpy(&ev.addr.bdaddr, bdaddr);
591f47f3 3132 ev.addr.type = BDADDR_BREDR;
a770bb5a 3133 ev.secure = secure;
980e1a53 3134
744cf19e 3135 return mgmt_event(MGMT_EV_PIN_CODE_REQUEST, hdev, &ev, sizeof(ev),
04124681 3136 NULL);
980e1a53
JH		 3137}
3138
744cf19e 3139int mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 3140 u8 status)
980e1a53
JH		 3141{
3142 struct pending_cmd *cmd;
ac56fb13 3143 struct mgmt_rp_pin_code_reply rp;
980e1a53
JH		 3144 int err;
3145
2e58ef3e 3146 cmd = mgmt_pending_find(MGMT_OP_PIN_CODE_REPLY, hdev);
980e1a53
JH		 3147 if (!cmd)
3148 return -ENOENT;
3149
d8457698 3150 bacpy(&rp.addr.bdaddr, bdaddr);
591f47f3 3151 rp.addr.type = BDADDR_BREDR;
ac56fb13 3152
aee9b218 3153 err = cmd_complete(cmd->sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
04124681 3154 mgmt_status(status), &rp, sizeof(rp));
980e1a53 3155
a664b5bc 3156 mgmt_pending_remove(cmd);
980e1a53
JH		 3157
3158 return err;
3159}
3160
744cf19e 3161int mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 3162 u8 status)
980e1a53
JH		 3163{
3164 struct pending_cmd *cmd;
ac56fb13 3165 struct mgmt_rp_pin_code_reply rp;
980e1a53
JH		 3166 int err;
3167
2e58ef3e 3168 cmd = mgmt_pending_find(MGMT_OP_PIN_CODE_NEG_REPLY, hdev);
980e1a53
JH		 3169 if (!cmd)
3170 return -ENOENT;
3171
d8457698 3172 bacpy(&rp.addr.bdaddr, bdaddr);
591f47f3 3173 rp.addr.type = BDADDR_BREDR;
ac56fb13 3174
aee9b218 3175 err = cmd_complete(cmd->sk, hdev->id, MGMT_OP_PIN_CODE_NEG_REPLY,
04124681 3176 mgmt_status(status), &rp, sizeof(rp));
980e1a53 3177
a664b5bc 3178 mgmt_pending_remove(cmd);
980e1a53
JH		 3179
3180 return err;
3181}
a5c29683 3182
744cf19e 3183int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681
GP		 3184 u8 link_type, u8 addr_type, __le32 value,
3185 u8 confirm_hint)
a5c29683
JH		 3186{
3187 struct mgmt_ev_user_confirm_request ev;
3188
744cf19e 3189 BT_DBG("%s", hdev->name);
a5c29683 3190
272d90df 3191 bacpy(&ev.addr.bdaddr, bdaddr);
57c1477c 3192 ev.addr.type = link_to_bdaddr(link_type, addr_type);
55bc1a37 3193 ev.confirm_hint = confirm_hint;
78e8098e 3194 ev.value = value;
a5c29683 3195
744cf19e 3196 return mgmt_event(MGMT_EV_USER_CONFIRM_REQUEST, hdev, &ev, sizeof(ev),
04124681 3197 NULL);
a5c29683
JH		 3198}
3199
272d90df
JH		 3200int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
3201 u8 link_type, u8 addr_type)
604086b7
BG		 3202{
3203 struct mgmt_ev_user_passkey_request ev;
3204
3205 BT_DBG("%s", hdev->name);
3206
272d90df 3207 bacpy(&ev.addr.bdaddr, bdaddr);
57c1477c 3208 ev.addr.type = link_to_bdaddr(link_type, addr_type);
604086b7
BG		 3209
3210 return mgmt_event(MGMT_EV_USER_PASSKEY_REQUEST, hdev, &ev, sizeof(ev),
04124681 3211 NULL);
604086b7
BG		 3212}
3213
0df4c185 3214static int user_pairing_resp_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
272d90df
JH		 3215 u8 link_type, u8 addr_type, u8 status,
3216 u8 opcode)
a5c29683
JH		 3217{
3218 struct pending_cmd *cmd;
3219 struct mgmt_rp_user_confirm_reply rp;
3220 int err;
3221
2e58ef3e 3222 cmd = mgmt_pending_find(opcode, hdev);
a5c29683
JH		 3223 if (!cmd)
3224 return -ENOENT;
3225
272d90df 3226 bacpy(&rp.addr.bdaddr, bdaddr);
57c1477c 3227 rp.addr.type = link_to_bdaddr(link_type, addr_type);
aee9b218 3228 err = cmd_complete(cmd->sk, hdev->id, opcode, mgmt_status(status),
04124681 3229 &rp, sizeof(rp));
a5c29683 3230
a664b5bc 3231 mgmt_pending_remove(cmd);
a5c29683
JH		 3232
3233 return err;
3234}
3235
744cf19e 3236int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 3237 u8 link_type, u8 addr_type, u8 status)
a5c29683 3238{
272d90df 3239 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
04124681 3240 status, MGMT_OP_USER_CONFIRM_REPLY);
a5c29683
JH		 3241}
3242
272d90df 3243int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 3244 u8 link_type, u8 addr_type, u8 status)
a5c29683 3245{
272d90df 3246 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
04124681 3247 status, MGMT_OP_USER_CONFIRM_NEG_REPLY);
a5c29683 3248}
2a611692 3249
604086b7 3250int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 3251 u8 link_type, u8 addr_type, u8 status)
604086b7 3252{
272d90df 3253 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
04124681 3254 status, MGMT_OP_USER_PASSKEY_REPLY);
604086b7
BG		 3255}
3256
272d90df 3257int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 3258 u8 link_type, u8 addr_type, u8 status)
604086b7 3259{
272d90df 3260 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
04124681 3261 status, MGMT_OP_USER_PASSKEY_NEG_REPLY);
604086b7
BG		 3262}
3263
bab73cb6 3264int mgmt_auth_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
04124681 3265 u8 addr_type, u8 status)
2a611692
JH		 3266{
3267 struct mgmt_ev_auth_failed ev;
3268
bab73cb6 3269 bacpy(&ev.addr.bdaddr, bdaddr);
57c1477c 3270 ev.addr.type = link_to_bdaddr(link_type, addr_type);
ca69b795 3271 ev.status = mgmt_status(status);
2a611692 3272
744cf19e 3273 return mgmt_event(MGMT_EV_AUTH_FAILED, hdev, &ev, sizeof(ev), NULL);
2a611692 3274}
b312b161 3275
33ef95ed
JH		 3276int mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status)
3277{
3278 struct cmd_lookup match = { NULL, hdev };
47990ea0
JH		 3279 bool changed = false;
3280 int err = 0;
33ef95ed
JH		 3281
3282 if (status) {
3283 u8 mgmt_err = mgmt_status(status);
3284 mgmt_pending_foreach(MGMT_OP_SET_LINK_SECURITY, hdev,
04124681 3285 cmd_status_rsp, &mgmt_err);
33ef95ed
JH		 3286 return 0;
3287 }
3288
47990ea0
JH		 3289 if (test_bit(HCI_AUTH, &hdev->flags)) {
3290 if (!test_and_set_bit(HCI_LINK_SECURITY, &hdev->dev_flags))
3291 changed = true;
3292 } else {
3293 if (test_and_clear_bit(HCI_LINK_SECURITY, &hdev->dev_flags))
3294 changed = true;
3295 }
3296
33ef95ed 3297 mgmt_pending_foreach(MGMT_OP_SET_LINK_SECURITY, hdev, settings_rsp,
04124681 3298 &match);
33ef95ed 3299
47990ea0
JH		 3300 if (changed)
3301 err = new_settings(hdev, match.sk);
33ef95ed
JH		 3302
3303 if (match.sk)
3304 sock_put(match.sk);
3305
3306 return err;
3307}
3308
cacaf52f
JH		 3309static int clear_eir(struct hci_dev *hdev)
3310{
3311 struct hci_cp_write_eir cp;
3312
3313 if (!(hdev->features[6] & LMP_EXT_INQ))
3314 return 0;
3315
c80da27e
JH		 3316 memset(hdev->eir, 0, sizeof(hdev->eir));
3317
cacaf52f
JH		 3318 memset(&cp, 0, sizeof(cp));
3319
3320 return hci_send_cmd(hdev, HCI_OP_WRITE_EIR, sizeof(cp), &cp);
3321}
3322
c0ecddc2 3323int mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status)
ed2c4ee3
JH		 3324{
3325 struct cmd_lookup match = { NULL, hdev };
c0ecddc2
JH		 3326 bool changed = false;
3327 int err = 0;
ed2c4ee3
JH		 3328
3329 if (status) {
3330 u8 mgmt_err = mgmt_status(status);
c0ecddc2
JH		 3331
3332 if (enable && test_and_clear_bit(HCI_SSP_ENABLED,
04124681 3333 &hdev->dev_flags))
c0ecddc2
JH		 3334 err = new_settings(hdev, NULL);
3335
04124681
GP		 3336 mgmt_pending_foreach(MGMT_OP_SET_SSP, hdev, cmd_status_rsp,
3337 &mgmt_err);
c0ecddc2
JH		 3338
3339 return err;
3340 }
3341
3342 if (enable) {
3343 if (!test_and_set_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
3344 changed = true;
3345 } else {
3346 if (test_and_clear_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
3347 changed = true;
ed2c4ee3
JH		 3348 }
3349
3350 mgmt_pending_foreach(MGMT_OP_SET_SSP, hdev, settings_rsp, &match);
3351
c0ecddc2
JH		 3352 if (changed)
3353 err = new_settings(hdev, match.sk);
ed2c4ee3 3354
5fc6ebb1 3355 if (match.sk)
ed2c4ee3
JH		 3356 sock_put(match.sk);
3357
5fc6ebb1
JH		 3358 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
3359 update_eir(hdev);
3360 else
3361 clear_eir(hdev);
cacaf52f 3362
ed2c4ee3
JH		 3363 return err;
3364}
3365
90e70454
JH		 3366static void class_rsp(struct pending_cmd *cmd, void *data)
3367{
3368 struct cmd_lookup *match = data;
3369
3370 cmd_complete(cmd->sk, cmd->index, cmd->opcode, match->mgmt_status,
04124681 3371 match->hdev->dev_class, 3);
90e70454
JH		 3372
3373 list_del(&cmd->list);
3374
3375 if (match->sk == NULL) {
3376 match->sk = cmd->sk;
3377 sock_hold(match->sk);
3378 }
3379
3380 mgmt_pending_free(cmd);
3381}
3382
7f9a903c 3383int mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
04124681 3384 u8 status)
7f9a903c 3385{
90e70454
JH		 3386 struct cmd_lookup match = { NULL, hdev, mgmt_status(status) };
3387 int err = 0;
7f9a903c 3388
c95f0ba7
JH		 3389 clear_bit(HCI_PENDING_CLASS, &hdev->dev_flags);
3390
90e70454
JH		 3391 mgmt_pending_foreach(MGMT_OP_SET_DEV_CLASS, hdev, class_rsp, &match);
3392 mgmt_pending_foreach(MGMT_OP_ADD_UUID, hdev, class_rsp, &match);
3393 mgmt_pending_foreach(MGMT_OP_REMOVE_UUID, hdev, class_rsp, &match);
3394
3395 if (!status)
04124681
GP		 3396 err = mgmt_event(MGMT_EV_CLASS_OF_DEV_CHANGED, hdev, dev_class,
3397 3, NULL);
90e70454
JH		 3398
3399 if (match.sk)
3400 sock_put(match.sk);
7f9a903c
MH		 3401
3402 return err;
3403}
3404
744cf19e 3405int mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status)
b312b161
JH		 3406{
3407 struct pending_cmd *cmd;
3408 struct mgmt_cp_set_local_name ev;
28cc7bde
JH		 3409 bool changed = false;
3410 int err = 0;
3411
3412 if (memcmp(name, hdev->dev_name, sizeof(hdev->dev_name)) != 0) {
3413 memcpy(hdev->dev_name, name, sizeof(hdev->dev_name));
3414 changed = true;
3415 }
b312b161
JH		 3416
3417 memset(&ev, 0, sizeof(ev));
3418 memcpy(ev.name, name, HCI_MAX_NAME_LENGTH);
28cc7bde 3419 memcpy(ev.short_name, hdev->short_name, HCI_MAX_SHORT_NAME_LENGTH);
b312b161 3420
2e58ef3e 3421 cmd = mgmt_pending_find(MGMT_OP_SET_LOCAL_NAME, hdev);
b312b161
JH		 3422 if (!cmd)
3423 goto send_event;
3424
7bdaae4a
JH		 3425 /* Always assume that either the short or the complete name has
3426 * changed if there was a pending mgmt command */
3427 changed = true;
3428
b312b161 3429 if (status) {
744cf19e 3430 err = cmd_status(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME,
04124681 3431 mgmt_status(status));
b312b161
JH		 3432 goto failed;
3433 }
3434
aee9b218 3435 err = cmd_complete(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0, &ev,
04124681 3436 sizeof(ev));
b312b161
JH		 3437 if (err < 0)
3438 goto failed;
3439
3440send_event:
28cc7bde
JH		 3441 if (changed)
3442 err = mgmt_event(MGMT_EV_LOCAL_NAME_CHANGED, hdev, &ev,
04124681 3443 sizeof(ev), cmd ? cmd->sk : NULL);
28cc7bde 3444
f51d5b24 3445 update_eir(hdev);
b312b161
JH		 3446
3447failed:
3448 if (cmd)
3449 mgmt_pending_remove(cmd);
3450 return err;
3451}
c35938b2 3452
744cf19e 3453int mgmt_read_local_oob_data_reply_complete(struct hci_dev *hdev, u8 *hash,
04124681 3454 u8 *randomizer, u8 status)
c35938b2
SJ		 3455{
3456 struct pending_cmd *cmd;
3457 int err;
3458
744cf19e 3459 BT_DBG("%s status %u", hdev->name, status);
c35938b2 3460
2e58ef3e 3461 cmd = mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev);
c35938b2
SJ		 3462 if (!cmd)
3463 return -ENOENT;
3464
3465 if (status) {
04124681
GP		 3466 err = cmd_status(cmd->sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
3467 mgmt_status(status));
c35938b2
SJ		 3468 } else {
3469 struct mgmt_rp_read_local_oob_data rp;
3470
3471 memcpy(rp.hash, hash, sizeof(rp.hash));
3472 memcpy(rp.randomizer, randomizer, sizeof(rp.randomizer));
3473
744cf19e 3474 err = cmd_complete(cmd->sk, hdev->id,
04124681
GP		 3475 MGMT_OP_READ_LOCAL_OOB_DATA, 0, &rp,
3476 sizeof(rp));
c35938b2
SJ		 3477 }
3478
3479 mgmt_pending_remove(cmd);
3480
3481 return err;
3482}
e17acd40 3483
06199cf8
JH		 3484int mgmt_le_enable_complete(struct hci_dev *hdev, u8 enable, u8 status)
3485{
3486 struct cmd_lookup match = { NULL, hdev };
3487 bool changed = false;
3488 int err = 0;
3489
3490 if (status) {
3491 u8 mgmt_err = mgmt_status(status);
3492
3493 if (enable && test_and_clear_bit(HCI_LE_ENABLED,
04124681 3494 &hdev->dev_flags))
d97dcb66 3495 err = new_settings(hdev, NULL);
06199cf8 3496
d97dcb66
SJ		 3497 mgmt_pending_foreach(MGMT_OP_SET_LE, hdev, cmd_status_rsp,
3498 &mgmt_err);
06199cf8
JH		 3499
3500 return err;
3501 }
3502
3503 if (enable) {
3504 if (!test_and_set_bit(HCI_LE_ENABLED, &hdev->dev_flags))
3505 changed = true;
3506 } else {
3507 if (test_and_clear_bit(HCI_LE_ENABLED, &hdev->dev_flags))
3508 changed = true;
3509 }
3510
3511 mgmt_pending_foreach(MGMT_OP_SET_LE, hdev, settings_rsp, &match);
3512
3513 if (changed)
3514 err = new_settings(hdev, match.sk);
3515
3516 if (match.sk)
3517 sock_put(match.sk);
3518
3519 return err;
3520}
3521
48264f06 3522int mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
04124681
GP		 3523 u8 addr_type, u8 *dev_class, s8 rssi, u8 cfm_name, u8
3524 ssp, u8 *eir, u16 eir_len)
e17acd40 3525{
e319d2e7
JH		 3526 char buf[512];
3527 struct mgmt_ev_device_found *ev = (void *) buf;
1dc06093 3528 size_t ev_size;
e17acd40 3529
1dc06093
JH		 3530 /* Leave 5 bytes for a potential CoD field */
3531 if (sizeof(*ev) + eir_len + 5 > sizeof(buf))
7d262f86
AG		 3532 return -EINVAL;
3533
1dc06093
JH		 3534 memset(buf, 0, sizeof(buf));
3535
e319d2e7 3536 bacpy(&ev->addr.bdaddr, bdaddr);
57c1477c 3537 ev->addr.type = link_to_bdaddr(link_type, addr_type);
e319d2e7 3538 ev->rssi = rssi;
9a395a80
JH		 3539 if (cfm_name)
3540 ev->flags[0] |= MGMT_DEV_FOUND_CONFIRM_NAME;
388fc8fa
JH		 3541 if (!ssp)
3542 ev->flags[0] |= MGMT_DEV_FOUND_LEGACY_PAIRING;
e17acd40 3543
1dc06093 3544 if (eir_len > 0)
e319d2e7 3545 memcpy(ev->eir, eir, eir_len);
e17acd40 3546
1dc06093
JH		 3547 if (dev_class && !eir_has_data_type(ev->eir, eir_len, EIR_CLASS_OF_DEV))
3548 eir_len = eir_append_data(ev->eir, eir_len, EIR_CLASS_OF_DEV,
04124681 3549 dev_class, 3);
1dc06093 3550
eb55ef07 3551 ev->eir_len = cpu_to_le16(eir_len);
1dc06093
JH		 3552
3553 ev_size = sizeof(*ev) + eir_len;
f8523598 3554
e319d2e7 3555 return mgmt_event(MGMT_EV_DEVICE_FOUND, hdev, ev, ev_size, NULL);
e17acd40 3556}
a88a9652 3557
b644ba33 3558int mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
04124681 3559 u8 addr_type, s8 rssi, u8 *name, u8 name_len)
a88a9652 3560{
b644ba33
JH		 3561 struct mgmt_ev_device_found *ev;
3562 char buf[sizeof(*ev) + HCI_MAX_NAME_LENGTH + 2];
3563 u16 eir_len;
a88a9652 3564
b644ba33 3565 ev = (struct mgmt_ev_device_found *) buf;
a88a9652 3566
b644ba33
JH		 3567 memset(buf, 0, sizeof(buf));
3568
3569 bacpy(&ev->addr.bdaddr, bdaddr);
57c1477c 3570 ev->addr.type = link_to_bdaddr(link_type, addr_type);
b644ba33
JH		 3571 ev->rssi = rssi;
3572
3573 eir_len = eir_append_data(ev->eir, 0, EIR_NAME_COMPLETE, name,
04124681 3574 name_len);
b644ba33 3575
eb55ef07 3576 ev->eir_len = cpu_to_le16(eir_len);
a88a9652 3577
053c7e0c 3578 return mgmt_event(MGMT_EV_DEVICE_FOUND, hdev, ev,
04124681 3579 sizeof(*ev) + eir_len, NULL);
a88a9652 3580}
314b2381 3581
7a135109 3582int mgmt_start_discovery_failed(struct hci_dev *hdev, u8 status)
164a6e78
JH		 3583{
3584 struct pending_cmd *cmd;
f808e166 3585 u8 type;
164a6e78
JH		 3586 int err;
3587
203159d4
AG		 3588 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
3589
2e58ef3e 3590 cmd = mgmt_pending_find(MGMT_OP_START_DISCOVERY, hdev);
164a6e78
JH		 3591 if (!cmd)
3592 return -ENOENT;
3593
f808e166
JH		 3594 type = hdev->discovery.type;
3595
3596 err = cmd_complete(cmd->sk, hdev->id, cmd->opcode, mgmt_status(status),
04124681 3597 &type, sizeof(type));
164a6e78
JH		 3598 mgmt_pending_remove(cmd);
3599
3600 return err;
3601}
3602
e6d465cb
AG		 3603int mgmt_stop_discovery_failed(struct hci_dev *hdev, u8 status)
3604{
3605 struct pending_cmd *cmd;
3606 int err;
3607
3608 cmd = mgmt_pending_find(MGMT_OP_STOP_DISCOVERY, hdev);
3609 if (!cmd)
3610 return -ENOENT;
3611
d930650b 3612 err = cmd_complete(cmd->sk, hdev->id, cmd->opcode, mgmt_status(status),
04124681 3613 &hdev->discovery.type, sizeof(hdev->discovery.type));
164a6e78
JH		 3614 mgmt_pending_remove(cmd);
3615
3616 return err;
3617}
3618
744cf19e 3619int mgmt_discovering(struct hci_dev *hdev, u8 discovering)
314b2381 3620{
f963e8e9 3621 struct mgmt_ev_discovering ev;
164a6e78
JH		 3622 struct pending_cmd *cmd;
3623
343fb145
AG		 3624 BT_DBG("%s discovering %u", hdev->name, discovering);
3625
164a6e78 3626 if (discovering)
2e58ef3e 3627 cmd = mgmt_pending_find(MGMT_OP_START_DISCOVERY, hdev);
164a6e78 3628 else
2e58ef3e 3629 cmd = mgmt_pending_find(MGMT_OP_STOP_DISCOVERY, hdev);
164a6e78
JH		 3630
3631 if (cmd != NULL) {
f808e166
JH		 3632 u8 type = hdev->discovery.type;
3633
04124681
GP		 3634 cmd_complete(cmd->sk, hdev->id, cmd->opcode, 0, &type,
3635 sizeof(type));
164a6e78
JH		 3636 mgmt_pending_remove(cmd);
3637 }
3638
f963e8e9
JH		 3639 memset(&ev, 0, sizeof(ev));
3640 ev.type = hdev->discovery.type;
3641 ev.discovering = discovering;
3642
3643 return mgmt_event(MGMT_EV_DISCOVERING, hdev, &ev, sizeof(ev), NULL);
314b2381 3644}
5e762444 3645
88c1fe4b 3646int mgmt_device_blocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
5e762444
AJ		 3647{
3648 struct pending_cmd *cmd;
3649 struct mgmt_ev_device_blocked ev;
3650
2e58ef3e 3651 cmd = mgmt_pending_find(MGMT_OP_BLOCK_DEVICE, hdev);
5e762444 3652
88c1fe4b
JH		 3653 bacpy(&ev.addr.bdaddr, bdaddr);
3654 ev.addr.type = type;
5e762444 3655
744cf19e 3656 return mgmt_event(MGMT_EV_DEVICE_BLOCKED, hdev, &ev, sizeof(ev),
04124681 3657 cmd ? cmd->sk : NULL);
5e762444
AJ		 3658}
3659
88c1fe4b 3660int mgmt_device_unblocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
5e762444
AJ		 3661{
3662 struct pending_cmd *cmd;
3663 struct mgmt_ev_device_unblocked ev;
3664
2e58ef3e 3665 cmd = mgmt_pending_find(MGMT_OP_UNBLOCK_DEVICE, hdev);
5e762444 3666
88c1fe4b
JH		 3667 bacpy(&ev.addr.bdaddr, bdaddr);
3668 ev.addr.type = type;
5e762444 3669
744cf19e 3670 return mgmt_event(MGMT_EV_DEVICE_UNBLOCKED, hdev, &ev, sizeof(ev),
04124681 3671 cmd ? cmd->sk : NULL);
5e762444 3672}
d7b7e796
MH		 3673
3674module_param(enable_hs, bool, 0644);
3675MODULE_PARM_DESC(enable_hs, "Enable High Speed support");
Linux kernel - Deliverables
This page took 0.342179 seconds and 5 git commands to generate.