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