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