2 BlueZ - Bluetooth protocol stack for Linux
4 Copyright (C) 2010 Nokia Corporation
5 Copyright (C) 2011-2012 Intel Corporation
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;
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.
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.
25 /* Bluetooth HCI Management interface */
27 #include <linux/kernel.h>
28 #include <linux/uaccess.h>
29 #include <linux/module.h>
30 #include <asm/unaligned.h>
32 #include <net/bluetooth/bluetooth.h>
33 #include <net/bluetooth/hci_core.h>
34 #include <net/bluetooth/mgmt.h>
35 #include <net/bluetooth/smp.h>
40 #define MGMT_VERSION 1
41 #define MGMT_REVISION 0
43 static const u16 mgmt_commands
[] = {
44 MGMT_OP_READ_INDEX_LIST
,
47 MGMT_OP_SET_DISCOVERABLE
,
48 MGMT_OP_SET_CONNECTABLE
,
49 MGMT_OP_SET_FAST_CONNECTABLE
,
51 MGMT_OP_SET_LINK_SECURITY
,
55 MGMT_OP_SET_DEV_CLASS
,
56 MGMT_OP_SET_LOCAL_NAME
,
59 MGMT_OP_LOAD_LINK_KEYS
,
60 MGMT_OP_LOAD_LONG_TERM_KEYS
,
62 MGMT_OP_GET_CONNECTIONS
,
63 MGMT_OP_PIN_CODE_REPLY
,
64 MGMT_OP_PIN_CODE_NEG_REPLY
,
65 MGMT_OP_SET_IO_CAPABILITY
,
67 MGMT_OP_CANCEL_PAIR_DEVICE
,
68 MGMT_OP_UNPAIR_DEVICE
,
69 MGMT_OP_USER_CONFIRM_REPLY
,
70 MGMT_OP_USER_CONFIRM_NEG_REPLY
,
71 MGMT_OP_USER_PASSKEY_REPLY
,
72 MGMT_OP_USER_PASSKEY_NEG_REPLY
,
73 MGMT_OP_READ_LOCAL_OOB_DATA
,
74 MGMT_OP_ADD_REMOTE_OOB_DATA
,
75 MGMT_OP_REMOVE_REMOTE_OOB_DATA
,
76 MGMT_OP_START_DISCOVERY
,
77 MGMT_OP_STOP_DISCOVERY
,
80 MGMT_OP_UNBLOCK_DEVICE
,
83 static const u16 mgmt_events
[] = {
84 MGMT_EV_CONTROLLER_ERROR
,
86 MGMT_EV_INDEX_REMOVED
,
88 MGMT_EV_CLASS_OF_DEV_CHANGED
,
89 MGMT_EV_LOCAL_NAME_CHANGED
,
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
,
101 MGMT_EV_DEVICE_BLOCKED
,
102 MGMT_EV_DEVICE_UNBLOCKED
,
103 MGMT_EV_DEVICE_UNPAIRED
,
107 * These LE scan and inquiry parameters were chosen according to LE General
108 * Discovery Procedure specification.
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) */
114 #define LE_SCAN_TIMEOUT_BREDR_LE 5120 /* TGAP(100)/2 */
116 #define INQUIRY_LEN_BREDR 0x08 /* TGAP(100) */
117 #define INQUIRY_LEN_BREDR_LE 0x04 /* TGAP(100)/2 */
119 #define SERVICE_CACHE_TIMEOUT (5 * 1000)
121 #define hdev_is_powered(hdev) (test_bit(HCI_UP, &hdev->flags) && \
122 !test_bit(HCI_AUTO_OFF, &hdev->dev_flags))
125 struct list_head list
;
133 /* HCI to MGMT error code conversion table */
134 static u8 mgmt_status_table
[] = {
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 */
198 static u8
mgmt_status(u8 hci_status
)
200 if (hci_status
< ARRAY_SIZE(mgmt_status_table
))
201 return mgmt_status_table
[hci_status
];
203 return MGMT_STATUS_FAILED
;
206 static int cmd_status(struct sock
*sk
, u16 index
, u16 cmd
, u8 status
)
209 struct mgmt_hdr
*hdr
;
210 struct mgmt_ev_cmd_status
*ev
;
213 BT_DBG("sock %p, index %u, cmd %u, status %u", sk
, index
, cmd
, status
);
215 skb
= alloc_skb(sizeof(*hdr
) + sizeof(*ev
), GFP_ATOMIC
);
219 hdr
= (void *) skb_put(skb
, sizeof(*hdr
));
221 hdr
->opcode
= cpu_to_le16(MGMT_EV_CMD_STATUS
);
222 hdr
->index
= cpu_to_le16(index
);
223 hdr
->len
= cpu_to_le16(sizeof(*ev
));
225 ev
= (void *) skb_put(skb
, sizeof(*ev
));
227 put_unaligned_le16(cmd
, &ev
->opcode
);
229 err
= sock_queue_rcv_skb(sk
, skb
);
236 static int cmd_complete(struct sock
*sk
, u16 index
, u16 cmd
, u8 status
,
237 void *rp
, size_t rp_len
)
240 struct mgmt_hdr
*hdr
;
241 struct mgmt_ev_cmd_complete
*ev
;
244 BT_DBG("sock %p", sk
);
246 skb
= alloc_skb(sizeof(*hdr
) + sizeof(*ev
) + rp_len
, GFP_ATOMIC
);
250 hdr
= (void *) skb_put(skb
, sizeof(*hdr
));
252 hdr
->opcode
= cpu_to_le16(MGMT_EV_CMD_COMPLETE
);
253 hdr
->index
= cpu_to_le16(index
);
254 hdr
->len
= cpu_to_le16(sizeof(*ev
) + rp_len
);
256 ev
= (void *) skb_put(skb
, sizeof(*ev
) + rp_len
);
257 put_unaligned_le16(cmd
, &ev
->opcode
);
261 memcpy(ev
->data
, rp
, rp_len
);
263 err
= sock_queue_rcv_skb(sk
, skb
);
270 static int read_version(struct sock
*sk
)
272 struct mgmt_rp_read_version rp
;
274 BT_DBG("sock %p", sk
);
276 rp
.version
= MGMT_VERSION
;
277 put_unaligned_le16(MGMT_REVISION
, &rp
.revision
);
279 return cmd_complete(sk
, MGMT_INDEX_NONE
, MGMT_OP_READ_VERSION
, 0, &rp
,
283 static int read_commands(struct sock
*sk
)
285 struct mgmt_rp_read_commands
*rp
;
286 u16 num_commands
= ARRAY_SIZE(mgmt_commands
);
287 u16 num_events
= ARRAY_SIZE(mgmt_events
);
292 BT_DBG("sock %p", sk
);
294 rp_size
= sizeof(*rp
) + ((num_commands
+ num_events
) * sizeof(u16
));
296 rp
= kmalloc(rp_size
, GFP_KERNEL
);
300 put_unaligned_le16(num_commands
, &rp
->num_commands
);
301 put_unaligned_le16(num_events
, &rp
->num_events
);
303 for (i
= 0, opcode
= rp
->opcodes
; i
< num_commands
; i
++, opcode
++)
304 put_unaligned_le16(mgmt_commands
[i
], opcode
);
306 for (i
= 0; i
< num_events
; i
++, opcode
++)
307 put_unaligned_le16(mgmt_events
[i
], opcode
);
309 err
= cmd_complete(sk
, MGMT_INDEX_NONE
, MGMT_OP_READ_COMMANDS
, 0, rp
,
316 static int read_index_list(struct sock
*sk
)
318 struct mgmt_rp_read_index_list
*rp
;
325 BT_DBG("sock %p", sk
);
327 read_lock(&hci_dev_list_lock
);
330 list_for_each(p
, &hci_dev_list
) {
334 rp_len
= sizeof(*rp
) + (2 * count
);
335 rp
= kmalloc(rp_len
, GFP_ATOMIC
);
337 read_unlock(&hci_dev_list_lock
);
341 put_unaligned_le16(count
, &rp
->num_controllers
);
344 list_for_each_entry(d
, &hci_dev_list
, list
) {
345 if (test_bit(HCI_SETUP
, &d
->dev_flags
))
348 put_unaligned_le16(d
->id
, &rp
->index
[i
++]);
349 BT_DBG("Added hci%u", d
->id
);
352 read_unlock(&hci_dev_list_lock
);
354 err
= cmd_complete(sk
, MGMT_INDEX_NONE
, MGMT_OP_READ_INDEX_LIST
, 0, rp
,
362 static u32
get_supported_settings(struct hci_dev
*hdev
)
366 settings
|= MGMT_SETTING_POWERED
;
367 settings
|= MGMT_SETTING_CONNECTABLE
;
368 settings
|= MGMT_SETTING_FAST_CONNECTABLE
;
369 settings
|= MGMT_SETTING_DISCOVERABLE
;
370 settings
|= MGMT_SETTING_PAIRABLE
;
372 if (hdev
->features
[6] & LMP_SIMPLE_PAIR
)
373 settings
|= MGMT_SETTING_SSP
;
375 if (!(hdev
->features
[4] & LMP_NO_BREDR
)) {
376 settings
|= MGMT_SETTING_BREDR
;
377 settings
|= MGMT_SETTING_LINK_SECURITY
;
381 settings
|= MGMT_SETTING_HS
;
384 if (hdev
->features
[4] & LMP_LE
)
385 settings
|= MGMT_SETTING_LE
;
391 static u32
get_current_settings(struct hci_dev
*hdev
)
395 if (hdev_is_powered(hdev
))
396 settings
|= MGMT_SETTING_POWERED
;
398 if (test_bit(HCI_CONNECTABLE
, &hdev
->dev_flags
))
399 settings
|= MGMT_SETTING_CONNECTABLE
;
401 if (test_bit(HCI_DISCOVERABLE
, &hdev
->dev_flags
))
402 settings
|= MGMT_SETTING_DISCOVERABLE
;
404 if (test_bit(HCI_PAIRABLE
, &hdev
->dev_flags
))
405 settings
|= MGMT_SETTING_PAIRABLE
;
407 if (!(hdev
->features
[4] & LMP_NO_BREDR
))
408 settings
|= MGMT_SETTING_BREDR
;
410 if (test_bit(HCI_LE_ENABLED
, &hdev
->dev_flags
))
411 settings
|= MGMT_SETTING_LE
;
413 if (test_bit(HCI_LINK_SECURITY
, &hdev
->dev_flags
))
414 settings
|= MGMT_SETTING_LINK_SECURITY
;
416 if (test_bit(HCI_SSP_ENABLED
, &hdev
->dev_flags
))
417 settings
|= MGMT_SETTING_SSP
;
419 if (test_bit(HCI_HS_ENABLED
, &hdev
->dev_flags
))
420 settings
|= MGMT_SETTING_HS
;
425 #define PNP_INFO_SVCLASS_ID 0x1200
427 static u8 bluetooth_base_uuid
[] = {
428 0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80,
429 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
432 static u16
get_uuid16(u8
*uuid128
)
437 for (i
= 0; i
< 12; i
++) {
438 if (bluetooth_base_uuid
[i
] != uuid128
[i
])
442 memcpy(&val
, &uuid128
[12], 4);
444 val
= le32_to_cpu(val
);
451 static void create_eir(struct hci_dev
*hdev
, u8
*data
)
455 u16 uuid16_list
[HCI_MAX_EIR_LENGTH
/ sizeof(u16
)];
456 int i
, truncated
= 0;
457 struct bt_uuid
*uuid
;
460 name_len
= strlen(hdev
->dev_name
);
466 ptr
[1] = EIR_NAME_SHORT
;
468 ptr
[1] = EIR_NAME_COMPLETE
;
470 /* EIR Data length */
471 ptr
[0] = name_len
+ 1;
473 memcpy(ptr
+ 2, hdev
->dev_name
, name_len
);
475 eir_len
+= (name_len
+ 2);
476 ptr
+= (name_len
+ 2);
479 memset(uuid16_list
, 0, sizeof(uuid16_list
));
481 /* Group all UUID16 types */
482 list_for_each_entry(uuid
, &hdev
->uuids
, list
) {
485 uuid16
= get_uuid16(uuid
->uuid
);
492 if (uuid16
== PNP_INFO_SVCLASS_ID
)
495 /* Stop if not enough space to put next UUID */
496 if (eir_len
+ 2 + sizeof(u16
) > HCI_MAX_EIR_LENGTH
) {
501 /* Check for duplicates */
502 for (i
= 0; uuid16_list
[i
] != 0; i
++)
503 if (uuid16_list
[i
] == uuid16
)
506 if (uuid16_list
[i
] == 0) {
507 uuid16_list
[i
] = uuid16
;
508 eir_len
+= sizeof(u16
);
512 if (uuid16_list
[0] != 0) {
516 ptr
[1] = truncated
? EIR_UUID16_SOME
: EIR_UUID16_ALL
;
521 for (i
= 0; uuid16_list
[i
] != 0; i
++) {
522 *ptr
++ = (uuid16_list
[i
] & 0x00ff);
523 *ptr
++ = (uuid16_list
[i
] & 0xff00) >> 8;
526 /* EIR Data length */
527 *length
= (i
* sizeof(u16
)) + 1;
531 static int update_eir(struct hci_dev
*hdev
)
533 struct hci_cp_write_eir cp
;
535 if (!test_bit(HCI_UP
, &hdev
->flags
))
538 if (!(hdev
->features
[6] & LMP_EXT_INQ
))
541 if (!test_bit(HCI_SSP_ENABLED
, &hdev
->dev_flags
))
544 if (test_bit(HCI_SERVICE_CACHE
, &hdev
->dev_flags
))
547 memset(&cp
, 0, sizeof(cp
));
549 create_eir(hdev
, cp
.data
);
551 if (memcmp(cp
.data
, hdev
->eir
, sizeof(cp
.data
)) == 0)
554 memcpy(hdev
->eir
, cp
.data
, sizeof(cp
.data
));
556 return hci_send_cmd(hdev
, HCI_OP_WRITE_EIR
, sizeof(cp
), &cp
);
559 static u8
get_service_classes(struct hci_dev
*hdev
)
561 struct bt_uuid
*uuid
;
564 list_for_each_entry(uuid
, &hdev
->uuids
, list
)
565 val
|= uuid
->svc_hint
;
570 static int update_class(struct hci_dev
*hdev
)
574 BT_DBG("%s", hdev
->name
);
576 if (!test_bit(HCI_UP
, &hdev
->flags
))
579 if (test_bit(HCI_SERVICE_CACHE
, &hdev
->dev_flags
))
582 cod
[0] = hdev
->minor_class
;
583 cod
[1] = hdev
->major_class
;
584 cod
[2] = get_service_classes(hdev
);
586 if (memcmp(cod
, hdev
->dev_class
, 3) == 0)
589 return hci_send_cmd(hdev
, HCI_OP_WRITE_CLASS_OF_DEV
, sizeof(cod
), cod
);
592 static void service_cache_off(struct work_struct
*work
)
594 struct hci_dev
*hdev
= container_of(work
, struct hci_dev
,
597 if (!test_and_clear_bit(HCI_SERVICE_CACHE
, &hdev
->dev_flags
))
605 hci_dev_unlock(hdev
);
608 static void mgmt_init_hdev(struct hci_dev
*hdev
)
610 if (!test_and_set_bit(HCI_MGMT
, &hdev
->dev_flags
)) {
611 INIT_DELAYED_WORK(&hdev
->service_cache
, service_cache_off
);
613 /* Non-mgmt controlled devices get this bit set
614 * implicitly so that pairing works for them, however
615 * for mgmt we require user-space to explicitly enable
618 clear_bit(HCI_PAIRABLE
, &hdev
->dev_flags
);
621 if (!test_and_set_bit(HCI_SERVICE_CACHE
, &hdev
->dev_flags
))
622 schedule_delayed_work(&hdev
->service_cache
,
623 msecs_to_jiffies(SERVICE_CACHE_TIMEOUT
));
626 static int read_controller_info(struct sock
*sk
, u16 index
)
628 struct mgmt_rp_read_info rp
;
629 struct hci_dev
*hdev
;
631 BT_DBG("sock %p hci%u", sk
, index
);
633 hdev
= hci_dev_get(index
);
635 return cmd_status(sk
, index
, MGMT_OP_READ_INFO
,
636 MGMT_STATUS_INVALID_PARAMS
);
640 if (test_and_clear_bit(HCI_PI_MGMT_INIT
, &hci_pi(sk
)->flags
))
641 mgmt_init_hdev(hdev
);
643 memset(&rp
, 0, sizeof(rp
));
645 bacpy(&rp
.bdaddr
, &hdev
->bdaddr
);
647 rp
.version
= hdev
->hci_ver
;
649 put_unaligned_le16(hdev
->manufacturer
, &rp
.manufacturer
);
651 rp
.supported_settings
= cpu_to_le32(get_supported_settings(hdev
));
652 rp
.current_settings
= cpu_to_le32(get_current_settings(hdev
));
654 memcpy(rp
.dev_class
, hdev
->dev_class
, 3);
656 memcpy(rp
.name
, hdev
->dev_name
, sizeof(hdev
->dev_name
));
657 memcpy(rp
.short_name
, hdev
->short_name
, sizeof(hdev
->short_name
));
659 hci_dev_unlock(hdev
);
662 return cmd_complete(sk
, index
, MGMT_OP_READ_INFO
, 0, &rp
, sizeof(rp
));
665 static void mgmt_pending_free(struct pending_cmd
*cmd
)
672 static struct pending_cmd
*mgmt_pending_add(struct sock
*sk
, u16 opcode
,
673 struct hci_dev
*hdev
,
676 struct pending_cmd
*cmd
;
678 cmd
= kmalloc(sizeof(*cmd
), GFP_ATOMIC
);
682 cmd
->opcode
= opcode
;
683 cmd
->index
= hdev
->id
;
685 cmd
->param
= kmalloc(len
, GFP_ATOMIC
);
692 memcpy(cmd
->param
, data
, len
);
697 list_add(&cmd
->list
, &hdev
->mgmt_pending
);
702 static void mgmt_pending_foreach(u16 opcode
, struct hci_dev
*hdev
,
703 void (*cb
)(struct pending_cmd
*cmd
, void *data
),
706 struct list_head
*p
, *n
;
708 list_for_each_safe(p
, n
, &hdev
->mgmt_pending
) {
709 struct pending_cmd
*cmd
;
711 cmd
= list_entry(p
, struct pending_cmd
, list
);
713 if (opcode
> 0 && cmd
->opcode
!= opcode
)
720 static struct pending_cmd
*mgmt_pending_find(u16 opcode
, struct hci_dev
*hdev
)
722 struct pending_cmd
*cmd
;
724 list_for_each_entry(cmd
, &hdev
->mgmt_pending
, list
) {
725 if (cmd
->opcode
== opcode
)
732 static void mgmt_pending_remove(struct pending_cmd
*cmd
)
734 list_del(&cmd
->list
);
735 mgmt_pending_free(cmd
);
738 static int send_settings_rsp(struct sock
*sk
, u16 opcode
, struct hci_dev
*hdev
)
740 __le32 settings
= cpu_to_le32(get_current_settings(hdev
));
742 return cmd_complete(sk
, hdev
->id
, opcode
, 0, &settings
,
746 static int set_powered(struct sock
*sk
, u16 index
, void *data
, u16 len
)
748 struct mgmt_mode
*cp
= data
;
749 struct hci_dev
*hdev
;
750 struct pending_cmd
*cmd
;
753 BT_DBG("request for hci%u", index
);
755 if (len
!= sizeof(*cp
))
756 return cmd_status(sk
, index
, MGMT_OP_SET_POWERED
,
757 MGMT_STATUS_INVALID_PARAMS
);
759 hdev
= hci_dev_get(index
);
761 return cmd_status(sk
, index
, MGMT_OP_SET_POWERED
,
762 MGMT_STATUS_INVALID_PARAMS
);
766 if (test_and_clear_bit(HCI_AUTO_OFF
, &hdev
->dev_flags
)) {
767 cancel_delayed_work(&hdev
->power_off
);
770 err
= send_settings_rsp(sk
, MGMT_OP_SET_POWERED
, hdev
);
771 mgmt_powered(hdev
, 1);
776 if (!!cp
->val
== hdev_is_powered(hdev
)) {
777 err
= send_settings_rsp(sk
, MGMT_OP_SET_POWERED
, hdev
);
781 if (mgmt_pending_find(MGMT_OP_SET_POWERED
, hdev
)) {
782 err
= cmd_status(sk
, index
, MGMT_OP_SET_POWERED
,
787 cmd
= mgmt_pending_add(sk
, MGMT_OP_SET_POWERED
, hdev
, data
, len
);
794 schedule_work(&hdev
->power_on
);
796 schedule_work(&hdev
->power_off
.work
);
801 hci_dev_unlock(hdev
);
806 static int mgmt_event(u16 event
, struct hci_dev
*hdev
, void *data
,
807 u16 data_len
, struct sock
*skip_sk
)
810 struct mgmt_hdr
*hdr
;
812 skb
= alloc_skb(sizeof(*hdr
) + data_len
, GFP_ATOMIC
);
816 hdr
= (void *) skb_put(skb
, sizeof(*hdr
));
817 hdr
->opcode
= cpu_to_le16(event
);
819 hdr
->index
= cpu_to_le16(hdev
->id
);
821 hdr
->index
= cpu_to_le16(MGMT_INDEX_NONE
);
822 hdr
->len
= cpu_to_le16(data_len
);
825 memcpy(skb_put(skb
, data_len
), data
, data_len
);
828 __net_timestamp(skb
);
830 hci_send_to_control(skb
, skip_sk
);
836 static int new_settings(struct hci_dev
*hdev
, struct sock
*skip
)
840 ev
= cpu_to_le32(get_current_settings(hdev
));
842 return mgmt_event(MGMT_EV_NEW_SETTINGS
, hdev
, &ev
, sizeof(ev
), skip
);
845 static int set_discoverable(struct sock
*sk
, u16 index
, void *data
, u16 len
)
847 struct mgmt_cp_set_discoverable
*cp
= data
;
848 struct hci_dev
*hdev
;
849 struct pending_cmd
*cmd
;
854 BT_DBG("request for hci%u", index
);
856 if (len
!= sizeof(*cp
))
857 return cmd_status(sk
, index
, MGMT_OP_SET_DISCOVERABLE
,
858 MGMT_STATUS_INVALID_PARAMS
);
860 timeout
= get_unaligned_le16(&cp
->timeout
);
861 if (!cp
->val
&& timeout
> 0)
862 return cmd_status(sk
, index
, MGMT_OP_SET_DISCOVERABLE
,
863 MGMT_STATUS_INVALID_PARAMS
);
865 hdev
= hci_dev_get(index
);
867 return cmd_status(sk
, index
, MGMT_OP_SET_DISCOVERABLE
,
868 MGMT_STATUS_INVALID_PARAMS
);
872 if (!hdev_is_powered(hdev
) && timeout
> 0) {
873 err
= cmd_status(sk
, index
, MGMT_OP_SET_DISCOVERABLE
,
874 MGMT_STATUS_NOT_POWERED
);
878 if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE
, hdev
) ||
879 mgmt_pending_find(MGMT_OP_SET_CONNECTABLE
, hdev
)) {
880 err
= cmd_status(sk
, index
, MGMT_OP_SET_DISCOVERABLE
,
885 if (!test_bit(HCI_CONNECTABLE
, &hdev
->dev_flags
)) {
886 err
= cmd_status(sk
, index
, MGMT_OP_SET_DISCOVERABLE
,
887 MGMT_STATUS_REJECTED
);
891 if (!hdev_is_powered(hdev
)) {
892 bool changed
= false;
894 if (!!cp
->val
!= test_bit(HCI_DISCOVERABLE
, &hdev
->dev_flags
)) {
895 change_bit(HCI_DISCOVERABLE
, &hdev
->dev_flags
);
899 err
= send_settings_rsp(sk
, MGMT_OP_SET_DISCOVERABLE
, hdev
);
904 err
= new_settings(hdev
, sk
);
909 if (!!cp
->val
== test_bit(HCI_DISCOVERABLE
, &hdev
->dev_flags
)) {
910 if (hdev
->discov_timeout
> 0) {
911 cancel_delayed_work(&hdev
->discov_off
);
912 hdev
->discov_timeout
= 0;
915 if (cp
->val
&& timeout
> 0) {
916 hdev
->discov_timeout
= timeout
;
917 queue_delayed_work(hdev
->workqueue
, &hdev
->discov_off
,
918 msecs_to_jiffies(hdev
->discov_timeout
* 1000));
921 err
= send_settings_rsp(sk
, MGMT_OP_SET_DISCOVERABLE
, hdev
);
925 cmd
= mgmt_pending_add(sk
, MGMT_OP_SET_DISCOVERABLE
, hdev
, data
, len
);
934 scan
|= SCAN_INQUIRY
;
936 cancel_delayed_work(&hdev
->discov_off
);
938 err
= hci_send_cmd(hdev
, HCI_OP_WRITE_SCAN_ENABLE
, 1, &scan
);
940 mgmt_pending_remove(cmd
);
943 hdev
->discov_timeout
= timeout
;
946 hci_dev_unlock(hdev
);
952 static int set_connectable(struct sock
*sk
, u16 index
, void *data
, u16 len
)
954 struct mgmt_mode
*cp
= data
;
955 struct hci_dev
*hdev
;
956 struct pending_cmd
*cmd
;
960 BT_DBG("request for hci%u", index
);
962 if (len
!= sizeof(*cp
))
963 return cmd_status(sk
, index
, MGMT_OP_SET_CONNECTABLE
,
964 MGMT_STATUS_INVALID_PARAMS
);
966 hdev
= hci_dev_get(index
);
968 return cmd_status(sk
, index
, MGMT_OP_SET_CONNECTABLE
,
969 MGMT_STATUS_INVALID_PARAMS
);
973 if (!hdev_is_powered(hdev
)) {
974 bool changed
= false;
976 if (!!cp
->val
!= test_bit(HCI_CONNECTABLE
, &hdev
->dev_flags
))
980 set_bit(HCI_CONNECTABLE
, &hdev
->dev_flags
);
982 clear_bit(HCI_CONNECTABLE
, &hdev
->dev_flags
);
983 clear_bit(HCI_DISCOVERABLE
, &hdev
->dev_flags
);
986 err
= send_settings_rsp(sk
, MGMT_OP_SET_CONNECTABLE
, hdev
);
991 err
= new_settings(hdev
, sk
);
996 if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE
, hdev
) ||
997 mgmt_pending_find(MGMT_OP_SET_CONNECTABLE
, hdev
)) {
998 err
= cmd_status(sk
, index
, MGMT_OP_SET_CONNECTABLE
,
1003 if (!!cp
->val
== test_bit(HCI_PSCAN
, &hdev
->flags
)) {
1004 err
= send_settings_rsp(sk
, MGMT_OP_SET_CONNECTABLE
, hdev
);
1008 cmd
= mgmt_pending_add(sk
, MGMT_OP_SET_CONNECTABLE
, hdev
, data
, len
);
1019 if (test_bit(HCI_ISCAN
, &hdev
->flags
) &&
1020 hdev
->discov_timeout
> 0)
1021 cancel_delayed_work(&hdev
->discov_off
);
1024 err
= hci_send_cmd(hdev
, HCI_OP_WRITE_SCAN_ENABLE
, 1, &scan
);
1026 mgmt_pending_remove(cmd
);
1029 hci_dev_unlock(hdev
);
1035 static int set_pairable(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1037 struct mgmt_mode
*cp
= data
;
1038 struct hci_dev
*hdev
;
1041 BT_DBG("request for hci%u", index
);
1043 if (len
!= sizeof(*cp
))
1044 return cmd_status(sk
, index
, MGMT_OP_SET_PAIRABLE
,
1045 MGMT_STATUS_INVALID_PARAMS
);
1047 hdev
= hci_dev_get(index
);
1049 return cmd_status(sk
, index
, MGMT_OP_SET_PAIRABLE
,
1050 MGMT_STATUS_INVALID_PARAMS
);
1055 set_bit(HCI_PAIRABLE
, &hdev
->dev_flags
);
1057 clear_bit(HCI_PAIRABLE
, &hdev
->dev_flags
);
1059 err
= send_settings_rsp(sk
, MGMT_OP_SET_PAIRABLE
, hdev
);
1063 err
= new_settings(hdev
, sk
);
1066 hci_dev_unlock(hdev
);
1072 static int set_link_security(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1074 struct mgmt_mode
*cp
= data
;
1075 struct pending_cmd
*cmd
;
1076 struct hci_dev
*hdev
;
1080 BT_DBG("request for hci%u", index
);
1082 if (len
!= sizeof(*cp
))
1083 return cmd_status(sk
, index
, MGMT_OP_SET_LINK_SECURITY
,
1084 MGMT_STATUS_INVALID_PARAMS
);
1086 hdev
= hci_dev_get(index
);
1088 return cmd_status(sk
, index
, MGMT_OP_SET_LINK_SECURITY
,
1089 MGMT_STATUS_INVALID_PARAMS
);
1093 if (!hdev_is_powered(hdev
)) {
1094 bool changed
= false;
1096 if (!!cp
->val
!= test_bit(HCI_LINK_SECURITY
,
1097 &hdev
->dev_flags
)) {
1098 change_bit(HCI_LINK_SECURITY
, &hdev
->dev_flags
);
1102 err
= send_settings_rsp(sk
, MGMT_OP_SET_LINK_SECURITY
, hdev
);
1107 err
= new_settings(hdev
, sk
);
1112 if (mgmt_pending_find(MGMT_OP_SET_LINK_SECURITY
, hdev
)) {
1113 err
= cmd_status(sk
, index
, MGMT_OP_SET_LINK_SECURITY
,
1120 if (test_bit(HCI_AUTH
, &hdev
->flags
) == val
) {
1121 err
= send_settings_rsp(sk
, MGMT_OP_SET_LINK_SECURITY
, hdev
);
1125 cmd
= mgmt_pending_add(sk
, MGMT_OP_SET_LINK_SECURITY
, hdev
, data
, len
);
1131 err
= hci_send_cmd(hdev
, HCI_OP_WRITE_AUTH_ENABLE
, sizeof(val
), &val
);
1133 mgmt_pending_remove(cmd
);
1138 hci_dev_unlock(hdev
);
1144 static int set_ssp(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1146 struct mgmt_mode
*cp
= data
;
1147 struct pending_cmd
*cmd
;
1148 struct hci_dev
*hdev
;
1152 BT_DBG("request for hci%u", index
);
1154 if (len
!= sizeof(*cp
))
1155 return cmd_status(sk
, index
, MGMT_OP_SET_SSP
,
1156 MGMT_STATUS_INVALID_PARAMS
);
1158 hdev
= hci_dev_get(index
);
1160 return cmd_status(sk
, index
, MGMT_OP_SET_SSP
,
1161 MGMT_STATUS_INVALID_PARAMS
);
1165 if (!(hdev
->features
[6] & LMP_SIMPLE_PAIR
)) {
1166 err
= cmd_status(sk
, index
, MGMT_OP_SET_SSP
,
1167 MGMT_STATUS_NOT_SUPPORTED
);
1173 if (!hdev_is_powered(hdev
)) {
1174 bool changed
= false;
1176 if (val
!= test_bit(HCI_SSP_ENABLED
, &hdev
->dev_flags
)) {
1177 change_bit(HCI_SSP_ENABLED
, &hdev
->dev_flags
);
1181 err
= send_settings_rsp(sk
, MGMT_OP_SET_SSP
, hdev
);
1186 err
= new_settings(hdev
, sk
);
1191 if (mgmt_pending_find(MGMT_OP_SET_SSP
, hdev
)) {
1192 err
= cmd_status(sk
, index
, MGMT_OP_SET_SSP
, MGMT_STATUS_BUSY
);
1196 if (test_bit(HCI_SSP_ENABLED
, &hdev
->dev_flags
) == val
) {
1197 err
= send_settings_rsp(sk
, MGMT_OP_SET_SSP
, hdev
);
1201 cmd
= mgmt_pending_add(sk
, MGMT_OP_SET_SSP
, hdev
, data
, len
);
1207 err
= hci_send_cmd(hdev
, HCI_OP_WRITE_SSP_MODE
, sizeof(val
), &val
);
1209 mgmt_pending_remove(cmd
);
1214 hci_dev_unlock(hdev
);
1220 static int set_hs(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1222 struct mgmt_mode
*cp
= data
;
1223 struct hci_dev
*hdev
;
1226 BT_DBG("request for hci%u", index
);
1228 if (len
!= sizeof(*cp
))
1229 return cmd_status(sk
, index
, MGMT_OP_SET_HS
,
1230 MGMT_STATUS_INVALID_PARAMS
);
1232 hdev
= hci_dev_get(index
);
1234 return cmd_status(sk
, index
, MGMT_OP_SET_HS
,
1235 MGMT_STATUS_INVALID_PARAMS
);
1238 err
= cmd_status(sk
, index
, MGMT_OP_SET_HS
,
1239 MGMT_STATUS_NOT_SUPPORTED
);
1244 set_bit(HCI_HS_ENABLED
, &hdev
->dev_flags
);
1246 clear_bit(HCI_HS_ENABLED
, &hdev
->dev_flags
);
1248 err
= send_settings_rsp(sk
, MGMT_OP_SET_HS
, hdev
);
1255 static int set_le(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1257 struct mgmt_mode
*cp
= data
;
1258 struct hci_cp_write_le_host_supported hci_cp
;
1259 struct pending_cmd
*cmd
;
1260 struct hci_dev
*hdev
;
1264 BT_DBG("request for hci%u", index
);
1266 if (len
!= sizeof(*cp
))
1267 return cmd_status(sk
, index
, MGMT_OP_SET_LE
,
1268 MGMT_STATUS_INVALID_PARAMS
);
1270 hdev
= hci_dev_get(index
);
1272 return cmd_status(sk
, index
, MGMT_OP_SET_LE
,
1273 MGMT_STATUS_INVALID_PARAMS
);
1275 if (!enable_le
|| !(hdev
->features
[4] & LMP_LE
)) {
1276 err
= cmd_status(sk
, index
, MGMT_OP_SET_LE
,
1277 MGMT_STATUS_NOT_SUPPORTED
);
1283 if (!hdev_is_powered(hdev
)) {
1284 bool changed
= false;
1286 if (val
!= test_bit(HCI_LE_ENABLED
, &hdev
->dev_flags
)) {
1287 change_bit(HCI_LE_ENABLED
, &hdev
->dev_flags
);
1291 err
= send_settings_rsp(sk
, MGMT_OP_SET_LE
, hdev
);
1296 err
= new_settings(hdev
, sk
);
1301 if (mgmt_pending_find(MGMT_OP_SET_LE
, hdev
)) {
1302 err
= cmd_status(sk
, index
, MGMT_OP_SET_LE
, MGMT_STATUS_BUSY
);
1306 cmd
= mgmt_pending_add(sk
, MGMT_OP_SET_LE
, hdev
, data
, len
);
1312 memset(&hci_cp
, 0, sizeof(hci_cp
));
1316 hci_cp
.simul
= !!(hdev
->features
[6] & LMP_SIMUL_LE_BR
);
1319 err
= hci_send_cmd(hdev
, HCI_OP_WRITE_LE_HOST_SUPPORTED
,
1320 sizeof(hci_cp
), &hci_cp
);
1322 mgmt_pending_remove(cmd
);
1331 static int add_uuid(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1333 struct mgmt_cp_add_uuid
*cp
= data
;
1334 struct hci_dev
*hdev
;
1335 struct bt_uuid
*uuid
;
1338 BT_DBG("request for hci%u", index
);
1340 if (len
!= sizeof(*cp
))
1341 return cmd_status(sk
, index
, MGMT_OP_ADD_UUID
,
1342 MGMT_STATUS_INVALID_PARAMS
);
1344 hdev
= hci_dev_get(index
);
1346 return cmd_status(sk
, index
, MGMT_OP_ADD_UUID
,
1347 MGMT_STATUS_INVALID_PARAMS
);
1351 uuid
= kmalloc(sizeof(*uuid
), GFP_ATOMIC
);
1357 memcpy(uuid
->uuid
, cp
->uuid
, 16);
1358 uuid
->svc_hint
= cp
->svc_hint
;
1360 list_add(&uuid
->list
, &hdev
->uuids
);
1362 err
= update_class(hdev
);
1366 err
= update_eir(hdev
);
1370 err
= cmd_complete(sk
, index
, MGMT_OP_ADD_UUID
, 0, NULL
, 0);
1373 hci_dev_unlock(hdev
);
1379 static int remove_uuid(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1381 struct mgmt_cp_remove_uuid
*cp
= data
;
1382 struct list_head
*p
, *n
;
1383 struct hci_dev
*hdev
;
1384 u8 bt_uuid_any
[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1387 BT_DBG("request for hci%u", index
);
1389 if (len
!= sizeof(*cp
))
1390 return cmd_status(sk
, index
, MGMT_OP_REMOVE_UUID
,
1391 MGMT_STATUS_INVALID_PARAMS
);
1393 hdev
= hci_dev_get(index
);
1395 return cmd_status(sk
, index
, MGMT_OP_REMOVE_UUID
,
1396 MGMT_STATUS_INVALID_PARAMS
);
1400 if (memcmp(cp
->uuid
, bt_uuid_any
, 16) == 0) {
1401 err
= hci_uuids_clear(hdev
);
1407 list_for_each_safe(p
, n
, &hdev
->uuids
) {
1408 struct bt_uuid
*match
= list_entry(p
, struct bt_uuid
, list
);
1410 if (memcmp(match
->uuid
, cp
->uuid
, 16) != 0)
1413 list_del(&match
->list
);
1418 err
= cmd_status(sk
, index
, MGMT_OP_REMOVE_UUID
,
1419 MGMT_STATUS_INVALID_PARAMS
);
1423 err
= update_class(hdev
);
1427 err
= update_eir(hdev
);
1431 err
= cmd_complete(sk
, index
, MGMT_OP_REMOVE_UUID
, 0, NULL
, 0);
1434 hci_dev_unlock(hdev
);
1440 static int set_dev_class(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1442 struct hci_dev
*hdev
;
1443 struct mgmt_cp_set_dev_class
*cp
= data
;
1446 BT_DBG("request for hci%u", index
);
1448 if (len
!= sizeof(*cp
))
1449 return cmd_status(sk
, index
, MGMT_OP_SET_DEV_CLASS
,
1450 MGMT_STATUS_INVALID_PARAMS
);
1452 hdev
= hci_dev_get(index
);
1454 return cmd_status(sk
, index
, MGMT_OP_SET_DEV_CLASS
,
1455 MGMT_STATUS_INVALID_PARAMS
);
1459 hdev
->major_class
= cp
->major
;
1460 hdev
->minor_class
= cp
->minor
;
1462 if (!hdev_is_powered(hdev
)) {
1463 err
= cmd_complete(sk
, index
, MGMT_OP_SET_DEV_CLASS
, 0,
1464 hdev
->dev_class
, 3);
1468 if (test_and_clear_bit(HCI_SERVICE_CACHE
, &hdev
->dev_flags
)) {
1469 hci_dev_unlock(hdev
);
1470 cancel_delayed_work_sync(&hdev
->service_cache
);
1475 err
= update_class(hdev
);
1478 err
= cmd_complete(sk
, index
, MGMT_OP_SET_DEV_CLASS
, 0,
1479 hdev
->dev_class
, 3);
1482 hci_dev_unlock(hdev
);
1488 static int load_link_keys(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1490 struct hci_dev
*hdev
;
1491 struct mgmt_cp_load_link_keys
*cp
= data
;
1492 u16 key_count
, expected_len
;
1495 if (len
< sizeof(*cp
))
1496 return cmd_status(sk
, index
, MGMT_OP_LOAD_LINK_KEYS
,
1497 MGMT_STATUS_INVALID_PARAMS
);
1499 key_count
= get_unaligned_le16(&cp
->key_count
);
1501 expected_len
= sizeof(*cp
) + key_count
*
1502 sizeof(struct mgmt_link_key_info
);
1503 if (expected_len
!= len
) {
1504 BT_ERR("load_link_keys: expected %u bytes, got %u bytes",
1506 return cmd_status(sk
, index
, MGMT_OP_LOAD_LINK_KEYS
,
1507 MGMT_STATUS_INVALID_PARAMS
);
1510 hdev
= hci_dev_get(index
);
1512 return cmd_status(sk
, index
, MGMT_OP_LOAD_LINK_KEYS
,
1513 MGMT_STATUS_INVALID_PARAMS
);
1515 BT_DBG("hci%u debug_keys %u key_count %u", index
, cp
->debug_keys
,
1520 hci_link_keys_clear(hdev
);
1522 set_bit(HCI_LINK_KEYS
, &hdev
->dev_flags
);
1525 set_bit(HCI_DEBUG_KEYS
, &hdev
->dev_flags
);
1527 clear_bit(HCI_DEBUG_KEYS
, &hdev
->dev_flags
);
1529 for (i
= 0; i
< key_count
; i
++) {
1530 struct mgmt_link_key_info
*key
= &cp
->keys
[i
];
1532 hci_add_link_key(hdev
, NULL
, 0, &key
->addr
.bdaddr
, key
->val
,
1533 key
->type
, key
->pin_len
);
1536 cmd_complete(sk
, index
, MGMT_OP_LOAD_LINK_KEYS
, 0, NULL
, 0);
1538 hci_dev_unlock(hdev
);
1544 static int device_unpaired(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
1545 u8 addr_type
, struct sock
*skip_sk
)
1547 struct mgmt_ev_device_unpaired ev
;
1549 bacpy(&ev
.addr
.bdaddr
, bdaddr
);
1550 ev
.addr
.type
= addr_type
;
1552 return mgmt_event(MGMT_EV_DEVICE_UNPAIRED
, hdev
, &ev
, sizeof(ev
),
1556 static int unpair_device(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1558 struct hci_dev
*hdev
;
1559 struct mgmt_cp_unpair_device
*cp
= data
;
1560 struct mgmt_rp_unpair_device rp
;
1561 struct hci_cp_disconnect dc
;
1562 struct pending_cmd
*cmd
;
1563 struct hci_conn
*conn
;
1566 if (len
!= sizeof(*cp
))
1567 return cmd_status(sk
, index
, MGMT_OP_UNPAIR_DEVICE
,
1568 MGMT_STATUS_INVALID_PARAMS
);
1570 hdev
= hci_dev_get(index
);
1572 return cmd_status(sk
, index
, MGMT_OP_UNPAIR_DEVICE
,
1573 MGMT_STATUS_INVALID_PARAMS
);
1577 memset(&rp
, 0, sizeof(rp
));
1578 bacpy(&rp
.addr
.bdaddr
, &cp
->addr
.bdaddr
);
1579 rp
.addr
.type
= cp
->addr
.type
;
1581 if (!hdev_is_powered(hdev
)) {
1582 err
= cmd_complete(sk
, index
, MGMT_OP_UNPAIR_DEVICE
,
1583 MGMT_STATUS_NOT_POWERED
,
1588 if (cp
->addr
.type
== MGMT_ADDR_BREDR
)
1589 err
= hci_remove_link_key(hdev
, &cp
->addr
.bdaddr
);
1591 err
= hci_remove_ltk(hdev
, &cp
->addr
.bdaddr
);
1594 err
= cmd_complete(sk
, index
, MGMT_OP_UNPAIR_DEVICE
,
1595 MGMT_STATUS_NOT_PAIRED
,
1600 if (cp
->disconnect
) {
1601 if (cp
->addr
.type
== MGMT_ADDR_BREDR
)
1602 conn
= hci_conn_hash_lookup_ba(hdev
, ACL_LINK
,
1605 conn
= hci_conn_hash_lookup_ba(hdev
, LE_LINK
,
1612 err
= cmd_complete(sk
, index
, MGMT_OP_UNPAIR_DEVICE
, 0,
1614 device_unpaired(hdev
, &cp
->addr
.bdaddr
, cp
->addr
.type
, sk
);
1618 cmd
= mgmt_pending_add(sk
, MGMT_OP_UNPAIR_DEVICE
, hdev
, cp
,
1625 put_unaligned_le16(conn
->handle
, &dc
.handle
);
1626 dc
.reason
= 0x13; /* Remote User Terminated Connection */
1627 err
= hci_send_cmd(hdev
, HCI_OP_DISCONNECT
, sizeof(dc
), &dc
);
1629 mgmt_pending_remove(cmd
);
1632 hci_dev_unlock(hdev
);
1638 static int disconnect(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1640 struct hci_dev
*hdev
;
1641 struct mgmt_cp_disconnect
*cp
= data
;
1642 struct hci_cp_disconnect dc
;
1643 struct pending_cmd
*cmd
;
1644 struct hci_conn
*conn
;
1649 if (len
!= sizeof(*cp
))
1650 return cmd_status(sk
, index
, MGMT_OP_DISCONNECT
,
1651 MGMT_STATUS_INVALID_PARAMS
);
1653 hdev
= hci_dev_get(index
);
1655 return cmd_status(sk
, index
, MGMT_OP_DISCONNECT
,
1656 MGMT_STATUS_INVALID_PARAMS
);
1660 if (!test_bit(HCI_UP
, &hdev
->flags
)) {
1661 err
= cmd_status(sk
, index
, MGMT_OP_DISCONNECT
,
1662 MGMT_STATUS_NOT_POWERED
);
1666 if (mgmt_pending_find(MGMT_OP_DISCONNECT
, hdev
)) {
1667 err
= cmd_status(sk
, index
, MGMT_OP_DISCONNECT
,
1672 if (cp
->addr
.type
== MGMT_ADDR_BREDR
)
1673 conn
= hci_conn_hash_lookup_ba(hdev
, ACL_LINK
, &cp
->addr
.bdaddr
);
1675 conn
= hci_conn_hash_lookup_ba(hdev
, LE_LINK
, &cp
->addr
.bdaddr
);
1678 err
= cmd_status(sk
, index
, MGMT_OP_DISCONNECT
,
1679 MGMT_STATUS_NOT_CONNECTED
);
1683 cmd
= mgmt_pending_add(sk
, MGMT_OP_DISCONNECT
, hdev
, data
, len
);
1689 put_unaligned_le16(conn
->handle
, &dc
.handle
);
1690 dc
.reason
= 0x13; /* Remote User Terminated Connection */
1692 err
= hci_send_cmd(hdev
, HCI_OP_DISCONNECT
, sizeof(dc
), &dc
);
1694 mgmt_pending_remove(cmd
);
1697 hci_dev_unlock(hdev
);
1703 static u8
link_to_mgmt(u8 link_type
, u8 addr_type
)
1705 switch (link_type
) {
1707 switch (addr_type
) {
1708 case ADDR_LE_DEV_PUBLIC
:
1709 return MGMT_ADDR_LE_PUBLIC
;
1710 case ADDR_LE_DEV_RANDOM
:
1711 return MGMT_ADDR_LE_RANDOM
;
1713 return MGMT_ADDR_INVALID
;
1716 return MGMT_ADDR_BREDR
;
1718 return MGMT_ADDR_INVALID
;
1722 static int get_connections(struct sock
*sk
, u16 index
)
1724 struct mgmt_rp_get_connections
*rp
;
1725 struct hci_dev
*hdev
;
1733 hdev
= hci_dev_get(index
);
1735 return cmd_status(sk
, index
, MGMT_OP_GET_CONNECTIONS
,
1736 MGMT_STATUS_INVALID_PARAMS
);
1740 if (!hdev_is_powered(hdev
)) {
1741 err
= cmd_status(sk
, index
, MGMT_OP_GET_CONNECTIONS
,
1742 MGMT_STATUS_NOT_POWERED
);
1747 list_for_each_entry(c
, &hdev
->conn_hash
.list
, list
) {
1748 if (test_bit(HCI_CONN_MGMT_CONNECTED
, &c
->flags
))
1752 rp_len
= sizeof(*rp
) + (count
* sizeof(struct mgmt_addr_info
));
1753 rp
= kmalloc(rp_len
, GFP_ATOMIC
);
1759 put_unaligned_le16(count
, &rp
->conn_count
);
1762 list_for_each_entry(c
, &hdev
->conn_hash
.list
, list
) {
1763 if (!test_bit(HCI_CONN_MGMT_CONNECTED
, &c
->flags
))
1765 bacpy(&rp
->addr
[i
].bdaddr
, &c
->dst
);
1766 rp
->addr
[i
].type
= link_to_mgmt(c
->type
, c
->dst_type
);
1767 if (rp
->addr
[i
].type
== MGMT_ADDR_INVALID
)
1772 /* Recalculate length in case of filtered SCO connections, etc */
1773 rp_len
= sizeof(*rp
) + (i
* sizeof(struct mgmt_addr_info
));
1775 err
= cmd_complete(sk
, index
, MGMT_OP_GET_CONNECTIONS
, 0, rp
, rp_len
);
1780 hci_dev_unlock(hdev
);
1785 static int send_pin_code_neg_reply(struct sock
*sk
, u16 index
,
1786 struct hci_dev
*hdev
, struct mgmt_cp_pin_code_neg_reply
*cp
)
1788 struct pending_cmd
*cmd
;
1791 cmd
= mgmt_pending_add(sk
, MGMT_OP_PIN_CODE_NEG_REPLY
, hdev
, cp
,
1796 err
= hci_send_cmd(hdev
, HCI_OP_PIN_CODE_NEG_REPLY
,
1797 sizeof(cp
->addr
.bdaddr
), &cp
->addr
.bdaddr
);
1799 mgmt_pending_remove(cmd
);
1804 static int pin_code_reply(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1806 struct hci_dev
*hdev
;
1807 struct hci_conn
*conn
;
1808 struct mgmt_cp_pin_code_reply
*cp
= data
;
1809 struct hci_cp_pin_code_reply reply
;
1810 struct pending_cmd
*cmd
;
1815 if (len
!= sizeof(*cp
))
1816 return cmd_status(sk
, index
, MGMT_OP_PIN_CODE_REPLY
,
1817 MGMT_STATUS_INVALID_PARAMS
);
1819 hdev
= hci_dev_get(index
);
1821 return cmd_status(sk
, index
, MGMT_OP_PIN_CODE_REPLY
,
1822 MGMT_STATUS_INVALID_PARAMS
);
1826 if (!hdev_is_powered(hdev
)) {
1827 err
= cmd_status(sk
, index
, MGMT_OP_PIN_CODE_REPLY
,
1828 MGMT_STATUS_NOT_POWERED
);
1832 conn
= hci_conn_hash_lookup_ba(hdev
, ACL_LINK
, &cp
->addr
.bdaddr
);
1834 err
= cmd_status(sk
, index
, MGMT_OP_PIN_CODE_REPLY
,
1835 MGMT_STATUS_NOT_CONNECTED
);
1839 if (conn
->pending_sec_level
== BT_SECURITY_HIGH
&& cp
->pin_len
!= 16) {
1840 struct mgmt_cp_pin_code_neg_reply ncp
;
1842 memcpy(&ncp
.addr
, &cp
->addr
, sizeof(ncp
.addr
));
1844 BT_ERR("PIN code is not 16 bytes long");
1846 err
= send_pin_code_neg_reply(sk
, index
, hdev
, &ncp
);
1848 err
= cmd_status(sk
, index
, MGMT_OP_PIN_CODE_REPLY
,
1849 MGMT_STATUS_INVALID_PARAMS
);
1854 cmd
= mgmt_pending_add(sk
, MGMT_OP_PIN_CODE_REPLY
, hdev
, data
,
1861 bacpy(&reply
.bdaddr
, &cp
->addr
.bdaddr
);
1862 reply
.pin_len
= cp
->pin_len
;
1863 memcpy(reply
.pin_code
, cp
->pin_code
, sizeof(reply
.pin_code
));
1865 err
= hci_send_cmd(hdev
, HCI_OP_PIN_CODE_REPLY
, sizeof(reply
), &reply
);
1867 mgmt_pending_remove(cmd
);
1870 hci_dev_unlock(hdev
);
1876 static int pin_code_neg_reply(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1878 struct hci_dev
*hdev
;
1879 struct mgmt_cp_pin_code_neg_reply
*cp
= data
;
1884 if (len
!= sizeof(*cp
))
1885 return cmd_status(sk
, index
, MGMT_OP_PIN_CODE_NEG_REPLY
,
1886 MGMT_STATUS_INVALID_PARAMS
);
1888 hdev
= hci_dev_get(index
);
1890 return cmd_status(sk
, index
, MGMT_OP_PIN_CODE_NEG_REPLY
,
1891 MGMT_STATUS_INVALID_PARAMS
);
1895 if (!hdev_is_powered(hdev
)) {
1896 err
= cmd_status(sk
, index
, MGMT_OP_PIN_CODE_NEG_REPLY
,
1897 MGMT_STATUS_NOT_POWERED
);
1901 err
= send_pin_code_neg_reply(sk
, index
, hdev
, cp
);
1904 hci_dev_unlock(hdev
);
1910 static int set_io_capability(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1912 struct hci_dev
*hdev
;
1913 struct mgmt_cp_set_io_capability
*cp
= data
;
1917 if (len
!= sizeof(*cp
))
1918 return cmd_status(sk
, index
, MGMT_OP_SET_IO_CAPABILITY
,
1919 MGMT_STATUS_INVALID_PARAMS
);
1921 hdev
= hci_dev_get(index
);
1923 return cmd_status(sk
, index
, MGMT_OP_SET_IO_CAPABILITY
,
1924 MGMT_STATUS_INVALID_PARAMS
);
1928 hdev
->io_capability
= cp
->io_capability
;
1930 BT_DBG("%s IO capability set to 0x%02x", hdev
->name
,
1931 hdev
->io_capability
);
1933 hci_dev_unlock(hdev
);
1936 return cmd_complete(sk
, index
, MGMT_OP_SET_IO_CAPABILITY
, 0, NULL
, 0);
1939 static inline struct pending_cmd
*find_pairing(struct hci_conn
*conn
)
1941 struct hci_dev
*hdev
= conn
->hdev
;
1942 struct pending_cmd
*cmd
;
1944 list_for_each_entry(cmd
, &hdev
->mgmt_pending
, list
) {
1945 if (cmd
->opcode
!= MGMT_OP_PAIR_DEVICE
)
1948 if (cmd
->user_data
!= conn
)
1957 static void pairing_complete(struct pending_cmd
*cmd
, u8 status
)
1959 struct mgmt_rp_pair_device rp
;
1960 struct hci_conn
*conn
= cmd
->user_data
;
1962 bacpy(&rp
.addr
.bdaddr
, &conn
->dst
);
1963 rp
.addr
.type
= link_to_mgmt(conn
->type
, conn
->dst_type
);
1965 cmd_complete(cmd
->sk
, cmd
->index
, MGMT_OP_PAIR_DEVICE
, status
,
1968 /* So we don't get further callbacks for this connection */
1969 conn
->connect_cfm_cb
= NULL
;
1970 conn
->security_cfm_cb
= NULL
;
1971 conn
->disconn_cfm_cb
= NULL
;
1975 mgmt_pending_remove(cmd
);
1978 static void pairing_complete_cb(struct hci_conn
*conn
, u8 status
)
1980 struct pending_cmd
*cmd
;
1982 BT_DBG("status %u", status
);
1984 cmd
= find_pairing(conn
);
1986 BT_DBG("Unable to find a pending command");
1988 pairing_complete(cmd
, mgmt_status(status
));
1991 static int pair_device(struct sock
*sk
, u16 index
, void *data
, u16 len
)
1993 struct hci_dev
*hdev
;
1994 struct mgmt_cp_pair_device
*cp
= data
;
1995 struct mgmt_rp_pair_device rp
;
1996 struct pending_cmd
*cmd
;
1997 u8 sec_level
, auth_type
;
1998 struct hci_conn
*conn
;
2003 if (len
!= sizeof(*cp
))
2004 return cmd_status(sk
, index
, MGMT_OP_PAIR_DEVICE
,
2005 MGMT_STATUS_INVALID_PARAMS
);
2007 hdev
= hci_dev_get(index
);
2009 return cmd_status(sk
, index
, MGMT_OP_PAIR_DEVICE
,
2010 MGMT_STATUS_INVALID_PARAMS
);
2014 if (!hdev_is_powered(hdev
)) {
2015 err
= cmd_status(sk
, index
, MGMT_OP_PAIR_DEVICE
,
2016 MGMT_STATUS_NOT_POWERED
);
2020 sec_level
= BT_SECURITY_MEDIUM
;
2021 if (cp
->io_cap
== 0x03)
2022 auth_type
= HCI_AT_DEDICATED_BONDING
;
2024 auth_type
= HCI_AT_DEDICATED_BONDING_MITM
;
2026 if (cp
->addr
.type
== MGMT_ADDR_BREDR
)
2027 conn
= hci_connect(hdev
, ACL_LINK
, &cp
->addr
.bdaddr
, sec_level
,
2030 conn
= hci_connect(hdev
, LE_LINK
, &cp
->addr
.bdaddr
, sec_level
,
2033 memset(&rp
, 0, sizeof(rp
));
2034 bacpy(&rp
.addr
.bdaddr
, &cp
->addr
.bdaddr
);
2035 rp
.addr
.type
= cp
->addr
.type
;
2038 err
= cmd_complete(sk
, index
, MGMT_OP_PAIR_DEVICE
,
2039 MGMT_STATUS_CONNECT_FAILED
,
2044 if (conn
->connect_cfm_cb
) {
2046 err
= cmd_complete(sk
, index
, MGMT_OP_PAIR_DEVICE
,
2047 MGMT_STATUS_BUSY
, &rp
, sizeof(rp
));
2051 cmd
= mgmt_pending_add(sk
, MGMT_OP_PAIR_DEVICE
, hdev
, data
, len
);
2058 /* For LE, just connecting isn't a proof that the pairing finished */
2059 if (cp
->addr
.type
== MGMT_ADDR_BREDR
)
2060 conn
->connect_cfm_cb
= pairing_complete_cb
;
2062 conn
->security_cfm_cb
= pairing_complete_cb
;
2063 conn
->disconn_cfm_cb
= pairing_complete_cb
;
2064 conn
->io_capability
= cp
->io_cap
;
2065 cmd
->user_data
= conn
;
2067 if (conn
->state
== BT_CONNECTED
&&
2068 hci_conn_security(conn
, sec_level
, auth_type
))
2069 pairing_complete(cmd
, 0);
2074 hci_dev_unlock(hdev
);
2080 static int cancel_pair_device(struct sock
*sk
, u16 index
,
2081 unsigned char *data
, u16 len
)
2083 struct mgmt_addr_info
*addr
= (void *) data
;
2084 struct hci_dev
*hdev
;
2085 struct pending_cmd
*cmd
;
2086 struct hci_conn
*conn
;
2091 if (len
!= sizeof(*addr
))
2092 return cmd_status(sk
, index
, MGMT_OP_CANCEL_PAIR_DEVICE
,
2093 MGMT_STATUS_INVALID_PARAMS
);
2095 hdev
= hci_dev_get(index
);
2097 return cmd_status(sk
, index
, MGMT_OP_CANCEL_PAIR_DEVICE
,
2098 MGMT_STATUS_INVALID_PARAMS
);
2102 if (!hdev_is_powered(hdev
)) {
2103 err
= cmd_status(sk
, index
, MGMT_OP_CANCEL_PAIR_DEVICE
,
2104 MGMT_STATUS_NOT_POWERED
);
2108 cmd
= mgmt_pending_find(MGMT_OP_PAIR_DEVICE
, hdev
);
2110 err
= cmd_status(sk
, index
, MGMT_OP_CANCEL_PAIR_DEVICE
,
2111 MGMT_STATUS_INVALID_PARAMS
);
2115 conn
= cmd
->user_data
;
2117 if (bacmp(&addr
->bdaddr
, &conn
->dst
) != 0) {
2118 err
= cmd_status(sk
, index
, MGMT_OP_CANCEL_PAIR_DEVICE
,
2119 MGMT_STATUS_INVALID_PARAMS
);
2123 pairing_complete(cmd
, MGMT_STATUS_CANCELLED
);
2125 err
= cmd_complete(sk
, index
, MGMT_OP_CANCEL_PAIR_DEVICE
, 0, addr
,
2128 hci_dev_unlock(hdev
);
2134 static int user_pairing_resp(struct sock
*sk
, u16 index
, bdaddr_t
*bdaddr
,
2135 u8 type
, u16 mgmt_op
, u16 hci_op
,
2138 struct pending_cmd
*cmd
;
2139 struct hci_dev
*hdev
;
2140 struct hci_conn
*conn
;
2143 hdev
= hci_dev_get(index
);
2145 return cmd_status(sk
, index
, mgmt_op
,
2146 MGMT_STATUS_INVALID_PARAMS
);
2150 if (!hdev_is_powered(hdev
)) {
2151 err
= cmd_status(sk
, index
, mgmt_op
, MGMT_STATUS_NOT_POWERED
);
2155 if (type
== MGMT_ADDR_BREDR
)
2156 conn
= hci_conn_hash_lookup_ba(hdev
, ACL_LINK
, bdaddr
);
2158 conn
= hci_conn_hash_lookup_ba(hdev
, LE_LINK
, bdaddr
);
2161 err
= cmd_status(sk
, index
, mgmt_op
,
2162 MGMT_STATUS_NOT_CONNECTED
);
2166 if (type
== MGMT_ADDR_LE_PUBLIC
|| type
== MGMT_ADDR_LE_RANDOM
) {
2167 /* Continue with pairing via SMP */
2168 err
= smp_user_confirm_reply(conn
, mgmt_op
, passkey
);
2171 err
= cmd_status(sk
, index
, mgmt_op
,
2172 MGMT_STATUS_SUCCESS
);
2174 err
= cmd_status(sk
, index
, mgmt_op
,
2175 MGMT_STATUS_FAILED
);
2180 cmd
= mgmt_pending_add(sk
, mgmt_op
, hdev
, bdaddr
, sizeof(*bdaddr
));
2186 /* Continue with pairing via HCI */
2187 if (hci_op
== HCI_OP_USER_PASSKEY_REPLY
) {
2188 struct hci_cp_user_passkey_reply cp
;
2190 bacpy(&cp
.bdaddr
, bdaddr
);
2191 cp
.passkey
= passkey
;
2192 err
= hci_send_cmd(hdev
, hci_op
, sizeof(cp
), &cp
);
2194 err
= hci_send_cmd(hdev
, hci_op
, sizeof(*bdaddr
), bdaddr
);
2197 mgmt_pending_remove(cmd
);
2200 hci_dev_unlock(hdev
);
2206 static int user_confirm_reply(struct sock
*sk
, u16 index
, void *data
, u16 len
)
2208 struct mgmt_cp_user_confirm_reply
*cp
= data
;
2212 if (len
!= sizeof(*cp
))
2213 return cmd_status(sk
, index
, MGMT_OP_USER_CONFIRM_REPLY
,
2214 MGMT_STATUS_INVALID_PARAMS
);
2216 return user_pairing_resp(sk
, index
, &cp
->addr
.bdaddr
, cp
->addr
.type
,
2217 MGMT_OP_USER_CONFIRM_REPLY
,
2218 HCI_OP_USER_CONFIRM_REPLY
, 0);
2221 static int user_confirm_neg_reply(struct sock
*sk
, u16 index
, void *data
,
2224 struct mgmt_cp_user_confirm_neg_reply
*cp
= data
;
2228 if (len
!= sizeof(*cp
))
2229 return cmd_status(sk
, index
, MGMT_OP_USER_CONFIRM_NEG_REPLY
,
2230 MGMT_STATUS_INVALID_PARAMS
);
2232 return user_pairing_resp(sk
, index
, &cp
->addr
.bdaddr
, cp
->addr
.type
,
2233 MGMT_OP_USER_CONFIRM_NEG_REPLY
,
2234 HCI_OP_USER_CONFIRM_NEG_REPLY
, 0);
2237 static int user_passkey_reply(struct sock
*sk
, u16 index
, void *data
, u16 len
)
2239 struct mgmt_cp_user_passkey_reply
*cp
= data
;
2243 if (len
!= sizeof(*cp
))
2244 return cmd_status(sk
, index
, MGMT_OP_USER_PASSKEY_REPLY
,
2247 return user_pairing_resp(sk
, index
, &cp
->addr
.bdaddr
, cp
->addr
.type
,
2248 MGMT_OP_USER_PASSKEY_REPLY
,
2249 HCI_OP_USER_PASSKEY_REPLY
,
2253 static int user_passkey_neg_reply(struct sock
*sk
, u16 index
, void *data
,
2256 struct mgmt_cp_user_passkey_neg_reply
*cp
= data
;
2260 if (len
!= sizeof(*cp
))
2261 return cmd_status(sk
, index
, MGMT_OP_USER_PASSKEY_NEG_REPLY
,
2264 return user_pairing_resp(sk
, index
, &cp
->addr
.bdaddr
, cp
->addr
.type
,
2265 MGMT_OP_USER_PASSKEY_NEG_REPLY
,
2266 HCI_OP_USER_PASSKEY_NEG_REPLY
, 0);
2269 static int set_local_name(struct sock
*sk
, u16 index
, void *data
,
2272 struct mgmt_cp_set_local_name
*mgmt_cp
= data
;
2273 struct hci_cp_write_local_name hci_cp
;
2274 struct hci_dev
*hdev
;
2275 struct pending_cmd
*cmd
;
2280 if (len
!= sizeof(*mgmt_cp
))
2281 return cmd_status(sk
, index
, MGMT_OP_SET_LOCAL_NAME
,
2282 MGMT_STATUS_INVALID_PARAMS
);
2284 hdev
= hci_dev_get(index
);
2286 return cmd_status(sk
, index
, MGMT_OP_SET_LOCAL_NAME
,
2287 MGMT_STATUS_INVALID_PARAMS
);
2291 memcpy(hdev
->short_name
, mgmt_cp
->short_name
,
2292 sizeof(hdev
->short_name
));
2294 if (!hdev_is_powered(hdev
)) {
2295 memcpy(hdev
->dev_name
, mgmt_cp
->name
, sizeof(hdev
->dev_name
));
2297 err
= cmd_complete(sk
, hdev
->id
, MGMT_OP_SET_LOCAL_NAME
, 0,
2302 err
= mgmt_event(MGMT_EV_LOCAL_NAME_CHANGED
, hdev
, data
, len
,
2308 cmd
= mgmt_pending_add(sk
, MGMT_OP_SET_LOCAL_NAME
, hdev
, data
, len
);
2314 memcpy(hci_cp
.name
, mgmt_cp
->name
, sizeof(hci_cp
.name
));
2315 err
= hci_send_cmd(hdev
, HCI_OP_WRITE_LOCAL_NAME
, sizeof(hci_cp
),
2318 mgmt_pending_remove(cmd
);
2321 hci_dev_unlock(hdev
);
2327 static int read_local_oob_data(struct sock
*sk
, u16 index
)
2329 struct hci_dev
*hdev
;
2330 struct pending_cmd
*cmd
;
2333 BT_DBG("hci%u", index
);
2335 hdev
= hci_dev_get(index
);
2337 return cmd_status(sk
, index
, MGMT_OP_READ_LOCAL_OOB_DATA
,
2338 MGMT_STATUS_INVALID_PARAMS
);
2342 if (!hdev_is_powered(hdev
)) {
2343 err
= cmd_status(sk
, index
, MGMT_OP_READ_LOCAL_OOB_DATA
,
2344 MGMT_STATUS_NOT_POWERED
);
2348 if (!(hdev
->features
[6] & LMP_SIMPLE_PAIR
)) {
2349 err
= cmd_status(sk
, index
, MGMT_OP_READ_LOCAL_OOB_DATA
,
2350 MGMT_STATUS_NOT_SUPPORTED
);
2354 if (mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA
, hdev
)) {
2355 err
= cmd_status(sk
, index
, MGMT_OP_READ_LOCAL_OOB_DATA
,
2360 cmd
= mgmt_pending_add(sk
, MGMT_OP_READ_LOCAL_OOB_DATA
, hdev
, NULL
, 0);
2366 err
= hci_send_cmd(hdev
, HCI_OP_READ_LOCAL_OOB_DATA
, 0, NULL
);
2368 mgmt_pending_remove(cmd
);
2371 hci_dev_unlock(hdev
);
2377 static int add_remote_oob_data(struct sock
*sk
, u16 index
, void *data
,
2380 struct hci_dev
*hdev
;
2381 struct mgmt_cp_add_remote_oob_data
*cp
= data
;
2385 BT_DBG("hci%u ", index
);
2387 if (len
!= sizeof(*cp
))
2388 return cmd_status(sk
, index
, MGMT_OP_ADD_REMOTE_OOB_DATA
,
2389 MGMT_STATUS_INVALID_PARAMS
);
2391 hdev
= hci_dev_get(index
);
2393 return cmd_complete(sk
, index
, MGMT_OP_ADD_REMOTE_OOB_DATA
,
2394 MGMT_STATUS_INVALID_PARAMS
,
2395 &cp
->addr
, sizeof(cp
->addr
));
2399 if (!hdev_is_powered(hdev
)) {
2400 err
= cmd_complete(sk
, index
, MGMT_OP_ADD_REMOTE_OOB_DATA
,
2401 MGMT_STATUS_NOT_POWERED
,
2402 &cp
->addr
, sizeof(cp
->addr
));
2406 err
= hci_add_remote_oob_data(hdev
, &cp
->addr
.bdaddr
, cp
->hash
,
2409 status
= MGMT_STATUS_FAILED
;
2413 err
= cmd_complete(sk
, index
, MGMT_OP_ADD_REMOTE_OOB_DATA
, status
,
2414 &cp
->addr
, sizeof(cp
->addr
));
2417 hci_dev_unlock(hdev
);
2423 static int remove_remote_oob_data(struct sock
*sk
, u16 index
,
2424 void *data
, u16 len
)
2426 struct hci_dev
*hdev
;
2427 struct mgmt_cp_remove_remote_oob_data
*cp
= data
;
2431 BT_DBG("hci%u ", index
);
2433 if (len
!= sizeof(*cp
))
2434 return cmd_status(sk
, index
, MGMT_OP_REMOVE_REMOTE_OOB_DATA
,
2435 MGMT_STATUS_INVALID_PARAMS
);
2437 hdev
= hci_dev_get(index
);
2439 return cmd_complete(sk
, index
, MGMT_OP_REMOVE_REMOTE_OOB_DATA
,
2440 MGMT_STATUS_INVALID_PARAMS
,
2441 &cp
->addr
, sizeof(cp
->addr
));
2445 if (!hdev_is_powered(hdev
)) {
2446 err
= cmd_complete(sk
, index
, MGMT_OP_REMOVE_REMOTE_OOB_DATA
,
2447 MGMT_STATUS_NOT_POWERED
,
2448 &cp
->addr
, sizeof(cp
->addr
));
2452 err
= hci_remove_remote_oob_data(hdev
, &cp
->addr
.bdaddr
);
2454 status
= MGMT_STATUS_INVALID_PARAMS
;
2458 err
= cmd_complete(sk
, index
, MGMT_OP_REMOVE_REMOTE_OOB_DATA
, status
,
2459 &cp
->addr
, sizeof(cp
->addr
));
2462 hci_dev_unlock(hdev
);
2468 static int discovery(struct hci_dev
*hdev
)
2472 if (lmp_host_le_capable(hdev
)) {
2473 if (lmp_bredr_capable(hdev
)) {
2474 err
= hci_le_scan(hdev
, LE_SCAN_TYPE
,
2475 LE_SCAN_INT
, LE_SCAN_WIN
,
2476 LE_SCAN_TIMEOUT_BREDR_LE
);
2478 hdev
->discovery
.type
= DISCOV_TYPE_LE
;
2479 err
= hci_le_scan(hdev
, LE_SCAN_TYPE
,
2480 LE_SCAN_INT
, LE_SCAN_WIN
,
2481 LE_SCAN_TIMEOUT_LE_ONLY
);
2484 hdev
->discovery
.type
= DISCOV_TYPE_BREDR
;
2485 err
= hci_do_inquiry(hdev
, INQUIRY_LEN_BREDR
);
2491 int mgmt_interleaved_discovery(struct hci_dev
*hdev
)
2495 BT_DBG("%s", hdev
->name
);
2499 err
= hci_do_inquiry(hdev
, INQUIRY_LEN_BREDR_LE
);
2501 hci_discovery_set_state(hdev
, DISCOVERY_STOPPED
);
2503 hci_dev_unlock(hdev
);
2508 static int start_discovery(struct sock
*sk
, u16 index
,
2509 void *data
, u16 len
)
2511 struct mgmt_cp_start_discovery
*cp
= data
;
2512 struct pending_cmd
*cmd
;
2513 struct hci_dev
*hdev
;
2516 BT_DBG("hci%u", index
);
2518 if (len
!= sizeof(*cp
))
2519 return cmd_status(sk
, index
, MGMT_OP_START_DISCOVERY
,
2520 MGMT_STATUS_INVALID_PARAMS
);
2522 hdev
= hci_dev_get(index
);
2524 return cmd_status(sk
, index
, MGMT_OP_START_DISCOVERY
,
2525 MGMT_STATUS_INVALID_PARAMS
);
2529 if (!hdev_is_powered(hdev
)) {
2530 err
= cmd_status(sk
, index
, MGMT_OP_START_DISCOVERY
,
2531 MGMT_STATUS_NOT_POWERED
);
2535 if (hdev
->discovery
.state
!= DISCOVERY_STOPPED
) {
2536 err
= cmd_status(sk
, index
, MGMT_OP_START_DISCOVERY
,
2541 cmd
= mgmt_pending_add(sk
, MGMT_OP_START_DISCOVERY
, hdev
, NULL
, 0);
2547 hdev
->discovery
.type
= cp
->type
;
2549 switch (hdev
->discovery
.type
) {
2550 case DISCOV_TYPE_BREDR
:
2551 err
= hci_do_inquiry(hdev
, INQUIRY_LEN_BREDR
);
2554 case DISCOV_TYPE_LE
:
2555 err
= hci_le_scan(hdev
, LE_SCAN_TYPE
, LE_SCAN_INT
,
2556 LE_SCAN_WIN
, LE_SCAN_TIMEOUT_LE_ONLY
);
2559 case DISCOV_TYPE_INTERLEAVED
:
2560 err
= discovery(hdev
);
2568 mgmt_pending_remove(cmd
);
2570 hci_discovery_set_state(hdev
, DISCOVERY_STARTING
);
2573 hci_dev_unlock(hdev
);
2579 static int stop_discovery(struct sock
*sk
, u16 index
, void *data
, u16 len
)
2581 struct mgmt_cp_stop_discovery
*mgmt_cp
= data
;
2582 struct hci_dev
*hdev
;
2583 struct pending_cmd
*cmd
;
2584 struct hci_cp_remote_name_req_cancel cp
;
2585 struct inquiry_entry
*e
;
2588 BT_DBG("hci%u", index
);
2590 if (len
!= sizeof(*mgmt_cp
))
2591 return cmd_status(sk
, index
, MGMT_OP_STOP_DISCOVERY
,
2592 MGMT_STATUS_INVALID_PARAMS
);
2594 hdev
= hci_dev_get(index
);
2596 return cmd_status(sk
, index
, MGMT_OP_STOP_DISCOVERY
,
2597 MGMT_STATUS_INVALID_PARAMS
);
2601 if (!hci_discovery_active(hdev
)) {
2602 err
= cmd_complete(sk
, index
, MGMT_OP_STOP_DISCOVERY
,
2603 MGMT_STATUS_REJECTED
,
2604 &mgmt_cp
->type
, sizeof(mgmt_cp
->type
));
2608 if (hdev
->discovery
.type
!= mgmt_cp
->type
) {
2609 err
= cmd_complete(sk
, index
, MGMT_OP_STOP_DISCOVERY
,
2610 MGMT_STATUS_INVALID_PARAMS
,
2611 &mgmt_cp
->type
, sizeof(mgmt_cp
->type
));
2615 cmd
= mgmt_pending_add(sk
, MGMT_OP_STOP_DISCOVERY
, hdev
, NULL
, 0);
2621 if (hdev
->discovery
.state
== DISCOVERY_FINDING
) {
2622 err
= hci_cancel_inquiry(hdev
);
2624 mgmt_pending_remove(cmd
);
2626 hci_discovery_set_state(hdev
, DISCOVERY_STOPPING
);
2630 e
= hci_inquiry_cache_lookup_resolve(hdev
, BDADDR_ANY
, NAME_PENDING
);
2632 mgmt_pending_remove(cmd
);
2633 err
= cmd_complete(sk
, index
, MGMT_OP_STOP_DISCOVERY
, 0,
2634 &mgmt_cp
->type
, sizeof(mgmt_cp
->type
));
2635 hci_discovery_set_state(hdev
, DISCOVERY_STOPPED
);
2639 bacpy(&cp
.bdaddr
, &e
->data
.bdaddr
);
2640 err
= hci_send_cmd(hdev
, HCI_OP_REMOTE_NAME_REQ_CANCEL
,
2643 mgmt_pending_remove(cmd
);
2645 hci_discovery_set_state(hdev
, DISCOVERY_STOPPING
);
2648 hci_dev_unlock(hdev
);
2654 static int confirm_name(struct sock
*sk
, u16 index
, void *data
, u16 len
)
2656 struct mgmt_cp_confirm_name
*cp
= data
;
2657 struct inquiry_entry
*e
;
2658 struct hci_dev
*hdev
;
2661 BT_DBG("hci%u", index
);
2663 if (len
!= sizeof(*cp
))
2664 return cmd_status(sk
, index
, MGMT_OP_CONFIRM_NAME
,
2665 MGMT_STATUS_INVALID_PARAMS
);
2667 hdev
= hci_dev_get(index
);
2669 return cmd_status(sk
, index
, MGMT_OP_CONFIRM_NAME
,
2670 MGMT_STATUS_INVALID_PARAMS
);
2674 if (!hci_discovery_active(hdev
)) {
2675 err
= cmd_status(sk
, index
, MGMT_OP_CONFIRM_NAME
,
2676 MGMT_STATUS_FAILED
);
2680 e
= hci_inquiry_cache_lookup_unknown(hdev
, &cp
->addr
.bdaddr
);
2682 err
= cmd_status(sk
, index
, MGMT_OP_CONFIRM_NAME
,
2683 MGMT_STATUS_INVALID_PARAMS
);
2687 if (cp
->name_known
) {
2688 e
->name_state
= NAME_KNOWN
;
2691 e
->name_state
= NAME_NEEDED
;
2692 hci_inquiry_cache_update_resolve(hdev
, e
);
2698 hci_dev_unlock(hdev
);
2703 static int block_device(struct sock
*sk
, u16 index
, void *data
, u16 len
)
2705 struct hci_dev
*hdev
;
2706 struct mgmt_cp_block_device
*cp
= data
;
2710 BT_DBG("hci%u", index
);
2712 if (len
!= sizeof(*cp
))
2713 return cmd_status(sk
, index
, MGMT_OP_BLOCK_DEVICE
,
2714 MGMT_STATUS_INVALID_PARAMS
);
2716 hdev
= hci_dev_get(index
);
2718 return cmd_complete(sk
, index
, MGMT_OP_BLOCK_DEVICE
,
2719 MGMT_STATUS_INVALID_PARAMS
,
2720 &cp
->addr
, sizeof(cp
->addr
));
2724 err
= hci_blacklist_add(hdev
, &cp
->addr
.bdaddr
, cp
->addr
.type
);
2726 status
= MGMT_STATUS_FAILED
;
2730 err
= cmd_complete(sk
, index
, MGMT_OP_BLOCK_DEVICE
, status
,
2731 &cp
->addr
, sizeof(cp
->addr
));
2733 hci_dev_unlock(hdev
);
2739 static int unblock_device(struct sock
*sk
, u16 index
, void *data
, u16 len
)
2741 struct hci_dev
*hdev
;
2742 struct mgmt_cp_unblock_device
*cp
= data
;
2746 BT_DBG("hci%u", index
);
2748 if (len
!= sizeof(*cp
))
2749 return cmd_status(sk
, index
, MGMT_OP_UNBLOCK_DEVICE
,
2750 MGMT_STATUS_INVALID_PARAMS
);
2752 hdev
= hci_dev_get(index
);
2754 return cmd_complete(sk
, index
, MGMT_OP_UNBLOCK_DEVICE
,
2755 MGMT_STATUS_INVALID_PARAMS
,
2756 &cp
->addr
, sizeof(cp
->addr
));
2760 err
= hci_blacklist_del(hdev
, &cp
->addr
.bdaddr
, cp
->addr
.type
);
2762 status
= MGMT_STATUS_INVALID_PARAMS
;
2766 err
= cmd_complete(sk
, index
, MGMT_OP_UNBLOCK_DEVICE
, status
,
2767 &cp
->addr
, sizeof(cp
->addr
));
2769 hci_dev_unlock(hdev
);
2775 static int set_fast_connectable(struct sock
*sk
, u16 index
,
2776 void *data
, u16 len
)
2778 struct hci_dev
*hdev
;
2779 struct mgmt_mode
*cp
= data
;
2780 struct hci_cp_write_page_scan_activity acp
;
2784 BT_DBG("hci%u", index
);
2786 if (len
!= sizeof(*cp
))
2787 return cmd_status(sk
, index
, MGMT_OP_SET_FAST_CONNECTABLE
,
2788 MGMT_STATUS_INVALID_PARAMS
);
2790 hdev
= hci_dev_get(index
);
2792 return cmd_status(sk
, index
, MGMT_OP_SET_FAST_CONNECTABLE
,
2793 MGMT_STATUS_INVALID_PARAMS
);
2794 if (!hdev_is_powered(hdev
))
2795 return cmd_status(sk
, index
, MGMT_OP_SET_FAST_CONNECTABLE
,
2796 MGMT_STATUS_NOT_POWERED
);
2798 if (!test_bit(HCI_CONNECTABLE
, &hdev
->dev_flags
))
2799 return cmd_status(sk
, index
, MGMT_OP_SET_FAST_CONNECTABLE
,
2800 MGMT_STATUS_REJECTED
);
2805 type
= PAGE_SCAN_TYPE_INTERLACED
;
2806 acp
.interval
= 0x0024; /* 22.5 msec page scan interval */
2808 type
= PAGE_SCAN_TYPE_STANDARD
; /* default */
2809 acp
.interval
= 0x0800; /* default 1.28 sec page scan */
2812 acp
.window
= 0x0012; /* default 11.25 msec page scan window */
2814 err
= hci_send_cmd(hdev
, HCI_OP_WRITE_PAGE_SCAN_ACTIVITY
,
2817 err
= cmd_status(sk
, index
, MGMT_OP_SET_FAST_CONNECTABLE
,
2818 MGMT_STATUS_FAILED
);
2822 err
= hci_send_cmd(hdev
, HCI_OP_WRITE_PAGE_SCAN_TYPE
, 1, &type
);
2824 err
= cmd_status(sk
, index
, MGMT_OP_SET_FAST_CONNECTABLE
,
2825 MGMT_STATUS_FAILED
);
2829 err
= cmd_complete(sk
, index
, MGMT_OP_SET_FAST_CONNECTABLE
, 0,
2832 hci_dev_unlock(hdev
);
2838 static int load_long_term_keys(struct sock
*sk
, u16 index
,
2839 void *cp_data
, u16 len
)
2841 struct hci_dev
*hdev
;
2842 struct mgmt_cp_load_long_term_keys
*cp
= cp_data
;
2843 u16 key_count
, expected_len
;
2846 if (len
< sizeof(*cp
))
2847 return cmd_status(sk
, index
, MGMT_OP_LOAD_LONG_TERM_KEYS
,
2850 key_count
= get_unaligned_le16(&cp
->key_count
);
2852 expected_len
= sizeof(*cp
) + key_count
*
2853 sizeof(struct mgmt_ltk_info
);
2854 if (expected_len
!= len
) {
2855 BT_ERR("load_keys: expected %u bytes, got %u bytes",
2857 return cmd_status(sk
, index
, MGMT_OP_LOAD_LONG_TERM_KEYS
,
2861 hdev
= hci_dev_get(index
);
2863 return cmd_status(sk
, index
, MGMT_OP_LOAD_LONG_TERM_KEYS
,
2866 BT_DBG("hci%u key_count %u", index
, key_count
);
2870 hci_smp_ltks_clear(hdev
);
2872 for (i
= 0; i
< key_count
; i
++) {
2873 struct mgmt_ltk_info
*key
= &cp
->keys
[i
];
2879 type
= HCI_SMP_LTK_SLAVE
;
2881 hci_add_ltk(hdev
, &key
->addr
.bdaddr
, key
->addr
.type
,
2882 type
, 0, key
->authenticated
, key
->val
,
2883 key
->enc_size
, key
->ediv
, key
->rand
);
2886 hci_dev_unlock(hdev
);
2892 int mgmt_control(struct sock
*sk
, struct msghdr
*msg
, size_t msglen
)
2896 struct mgmt_hdr
*hdr
;
2897 u16 opcode
, index
, len
;
2900 BT_DBG("got %zu bytes", msglen
);
2902 if (msglen
< sizeof(*hdr
))
2905 buf
= kmalloc(msglen
, GFP_KERNEL
);
2909 if (memcpy_fromiovec(buf
, msg
->msg_iov
, msglen
)) {
2915 opcode
= get_unaligned_le16(&hdr
->opcode
);
2916 index
= get_unaligned_le16(&hdr
->index
);
2917 len
= get_unaligned_le16(&hdr
->len
);
2919 if (len
!= msglen
- sizeof(*hdr
)) {
2924 cp
= buf
+ sizeof(*hdr
);
2927 case MGMT_OP_READ_VERSION
:
2928 err
= read_version(sk
);
2930 case MGMT_OP_READ_COMMANDS
:
2931 err
= read_commands(sk
);
2933 case MGMT_OP_READ_INDEX_LIST
:
2934 err
= read_index_list(sk
);
2936 case MGMT_OP_READ_INFO
:
2937 err
= read_controller_info(sk
, index
);
2939 case MGMT_OP_SET_POWERED
:
2940 err
= set_powered(sk
, index
, cp
, len
);
2942 case MGMT_OP_SET_DISCOVERABLE
:
2943 err
= set_discoverable(sk
, index
, cp
, len
);
2945 case MGMT_OP_SET_CONNECTABLE
:
2946 err
= set_connectable(sk
, index
, cp
, len
);
2948 case MGMT_OP_SET_FAST_CONNECTABLE
:
2949 err
= set_fast_connectable(sk
, index
, cp
, len
);
2951 case MGMT_OP_SET_PAIRABLE
:
2952 err
= set_pairable(sk
, index
, cp
, len
);
2954 case MGMT_OP_SET_LINK_SECURITY
:
2955 err
= set_link_security(sk
, index
, cp
, len
);
2957 case MGMT_OP_SET_SSP
:
2958 err
= set_ssp(sk
, index
, cp
, len
);
2960 case MGMT_OP_SET_HS
:
2961 err
= set_hs(sk
, index
, cp
, len
);
2963 case MGMT_OP_SET_LE
:
2964 err
= set_le(sk
, index
, cp
, len
);
2966 case MGMT_OP_ADD_UUID
:
2967 err
= add_uuid(sk
, index
, cp
, len
);
2969 case MGMT_OP_REMOVE_UUID
:
2970 err
= remove_uuid(sk
, index
, cp
, len
);
2972 case MGMT_OP_SET_DEV_CLASS
:
2973 err
= set_dev_class(sk
, index
, cp
, len
);
2975 case MGMT_OP_LOAD_LINK_KEYS
:
2976 err
= load_link_keys(sk
, index
, cp
, len
);
2978 case MGMT_OP_DISCONNECT
:
2979 err
= disconnect(sk
, index
, cp
, len
);
2981 case MGMT_OP_GET_CONNECTIONS
:
2982 err
= get_connections(sk
, index
);
2984 case MGMT_OP_PIN_CODE_REPLY
:
2985 err
= pin_code_reply(sk
, index
, cp
, len
);
2987 case MGMT_OP_PIN_CODE_NEG_REPLY
:
2988 err
= pin_code_neg_reply(sk
, index
, cp
, len
);
2990 case MGMT_OP_SET_IO_CAPABILITY
:
2991 err
= set_io_capability(sk
, index
, cp
, len
);
2993 case MGMT_OP_PAIR_DEVICE
:
2994 err
= pair_device(sk
, index
, cp
, len
);
2996 case MGMT_OP_CANCEL_PAIR_DEVICE
:
2997 err
= cancel_pair_device(sk
, index
, buf
+ sizeof(*hdr
), len
);
2999 case MGMT_OP_UNPAIR_DEVICE
:
3000 err
= unpair_device(sk
, index
, cp
, len
);
3002 case MGMT_OP_USER_CONFIRM_REPLY
:
3003 err
= user_confirm_reply(sk
, index
, cp
, len
);
3005 case MGMT_OP_USER_CONFIRM_NEG_REPLY
:
3006 err
= user_confirm_neg_reply(sk
, index
, cp
, len
);
3008 case MGMT_OP_USER_PASSKEY_REPLY
:
3009 err
= user_passkey_reply(sk
, index
, cp
, len
);
3011 case MGMT_OP_USER_PASSKEY_NEG_REPLY
:
3012 err
= user_passkey_neg_reply(sk
, index
, cp
, len
);
3014 case MGMT_OP_SET_LOCAL_NAME
:
3015 err
= set_local_name(sk
, index
, cp
, len
);
3017 case MGMT_OP_READ_LOCAL_OOB_DATA
:
3018 err
= read_local_oob_data(sk
, index
);
3020 case MGMT_OP_ADD_REMOTE_OOB_DATA
:
3021 err
= add_remote_oob_data(sk
, index
, cp
, len
);
3023 case MGMT_OP_REMOVE_REMOTE_OOB_DATA
:
3024 err
= remove_remote_oob_data(sk
, index
, cp
, len
);
3026 case MGMT_OP_START_DISCOVERY
:
3027 err
= start_discovery(sk
, index
, cp
, len
);
3029 case MGMT_OP_STOP_DISCOVERY
:
3030 err
= stop_discovery(sk
, index
, cp
, len
);
3032 case MGMT_OP_CONFIRM_NAME
:
3033 err
= confirm_name(sk
, index
, cp
, len
);
3035 case MGMT_OP_BLOCK_DEVICE
:
3036 err
= block_device(sk
, index
, cp
, len
);
3038 case MGMT_OP_UNBLOCK_DEVICE
:
3039 err
= unblock_device(sk
, index
, cp
, len
);
3041 case MGMT_OP_LOAD_LONG_TERM_KEYS
:
3042 err
= load_long_term_keys(sk
, index
, cp
, len
);
3045 BT_DBG("Unknown op %u", opcode
);
3046 err
= cmd_status(sk
, index
, opcode
,
3047 MGMT_STATUS_UNKNOWN_COMMAND
);
3061 static void cmd_status_rsp(struct pending_cmd
*cmd
, void *data
)
3065 cmd_status(cmd
->sk
, cmd
->index
, cmd
->opcode
, *status
);
3066 mgmt_pending_remove(cmd
);
3069 int mgmt_index_added(struct hci_dev
*hdev
)
3071 return mgmt_event(MGMT_EV_INDEX_ADDED
, hdev
, NULL
, 0, NULL
);
3074 int mgmt_index_removed(struct hci_dev
*hdev
)
3078 mgmt_pending_foreach(0, hdev
, cmd_status_rsp
, &status
);
3080 return mgmt_event(MGMT_EV_INDEX_REMOVED
, hdev
, NULL
, 0, NULL
);
3085 struct hci_dev
*hdev
;
3088 static void settings_rsp(struct pending_cmd
*cmd
, void *data
)
3090 struct cmd_lookup
*match
= data
;
3092 send_settings_rsp(cmd
->sk
, cmd
->opcode
, match
->hdev
);
3094 list_del(&cmd
->list
);
3096 if (match
->sk
== NULL
) {
3097 match
->sk
= cmd
->sk
;
3098 sock_hold(match
->sk
);
3101 mgmt_pending_free(cmd
);
3104 int mgmt_powered(struct hci_dev
*hdev
, u8 powered
)
3106 struct cmd_lookup match
= { NULL
, hdev
};
3109 if (!test_bit(HCI_MGMT
, &hdev
->dev_flags
))
3112 mgmt_pending_foreach(MGMT_OP_SET_POWERED
, hdev
, settings_rsp
, &match
);
3117 if (test_bit(HCI_CONNECTABLE
, &hdev
->dev_flags
))
3119 if (test_bit(HCI_DISCOVERABLE
, &hdev
->dev_flags
))
3120 scan
|= SCAN_INQUIRY
;
3123 hci_send_cmd(hdev
, HCI_OP_WRITE_SCAN_ENABLE
, 1, &scan
);
3125 u8 status
= ENETDOWN
;
3126 mgmt_pending_foreach(0, hdev
, cmd_status_rsp
, &status
);
3129 err
= new_settings(hdev
, match
.sk
);
3137 int mgmt_discoverable(struct hci_dev
*hdev
, u8 discoverable
)
3139 struct cmd_lookup match
= { NULL
, hdev
};
3140 bool changed
= false;
3144 if (!test_and_set_bit(HCI_DISCOVERABLE
, &hdev
->dev_flags
))
3147 if (test_and_clear_bit(HCI_DISCOVERABLE
, &hdev
->dev_flags
))
3151 mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE
, hdev
, settings_rsp
,
3155 err
= new_settings(hdev
, match
.sk
);
3163 int mgmt_connectable(struct hci_dev
*hdev
, u8 connectable
)
3165 struct cmd_lookup match
= { NULL
, hdev
};
3166 bool changed
= false;
3170 if (!test_and_set_bit(HCI_CONNECTABLE
, &hdev
->dev_flags
))
3173 if (test_and_clear_bit(HCI_CONNECTABLE
, &hdev
->dev_flags
))
3177 mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE
, hdev
, settings_rsp
,
3181 err
= new_settings(hdev
, match
.sk
);
3189 int mgmt_write_scan_failed(struct hci_dev
*hdev
, u8 scan
, u8 status
)
3191 u8 mgmt_err
= mgmt_status(status
);
3193 if (scan
& SCAN_PAGE
)
3194 mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE
, hdev
,
3195 cmd_status_rsp
, &mgmt_err
);
3197 if (scan
& SCAN_INQUIRY
)
3198 mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE
, hdev
,
3199 cmd_status_rsp
, &mgmt_err
);
3204 int mgmt_new_link_key(struct hci_dev
*hdev
, struct link_key
*key
,
3207 struct mgmt_ev_new_link_key ev
;
3209 memset(&ev
, 0, sizeof(ev
));
3211 ev
.store_hint
= persistent
;
3212 bacpy(&ev
.key
.addr
.bdaddr
, &key
->bdaddr
);
3213 ev
.key
.addr
.type
= MGMT_ADDR_BREDR
;
3214 ev
.key
.type
= key
->type
;
3215 memcpy(ev
.key
.val
, key
->val
, 16);
3216 ev
.key
.pin_len
= key
->pin_len
;
3218 return mgmt_event(MGMT_EV_NEW_LINK_KEY
, hdev
, &ev
, sizeof(ev
), NULL
);
3221 int mgmt_new_ltk(struct hci_dev
*hdev
, struct smp_ltk
*key
, u8 persistent
)
3223 struct mgmt_ev_new_long_term_key ev
;
3225 memset(&ev
, 0, sizeof(ev
));
3227 ev
.store_hint
= persistent
;
3228 bacpy(&ev
.key
.addr
.bdaddr
, &key
->bdaddr
);
3229 ev
.key
.addr
.type
= key
->bdaddr_type
;
3230 ev
.key
.authenticated
= key
->authenticated
;
3231 ev
.key
.enc_size
= key
->enc_size
;
3232 ev
.key
.ediv
= key
->ediv
;
3234 if (key
->type
== HCI_SMP_LTK
)
3237 memcpy(ev
.key
.rand
, key
->rand
, sizeof(key
->rand
));
3238 memcpy(ev
.key
.val
, key
->val
, sizeof(key
->val
));
3240 return mgmt_event(MGMT_EV_NEW_LONG_TERM_KEY
, hdev
,
3241 &ev
, sizeof(ev
), NULL
);
3244 int mgmt_device_connected(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
, u8 link_type
,
3245 u8 addr_type
, u8
*name
, u8 name_len
,
3249 struct mgmt_ev_device_connected
*ev
= (void *) buf
;
3252 bacpy(&ev
->addr
.bdaddr
, bdaddr
);
3253 ev
->addr
.type
= link_to_mgmt(link_type
, addr_type
);
3256 eir_len
= eir_append_data(ev
->eir
, 0, EIR_NAME_COMPLETE
,
3259 if (dev_class
&& memcmp(dev_class
, "\0\0\0", 3) != 0)
3260 eir_len
= eir_append_data(&ev
->eir
[eir_len
], eir_len
,
3261 EIR_CLASS_OF_DEV
, dev_class
, 3);
3263 put_unaligned_le16(eir_len
, &ev
->eir_len
);
3265 return mgmt_event(MGMT_EV_DEVICE_CONNECTED
, hdev
, buf
,
3266 sizeof(*ev
) + eir_len
, NULL
);
3269 static void disconnect_rsp(struct pending_cmd
*cmd
, void *data
)
3271 struct mgmt_cp_disconnect
*cp
= cmd
->param
;
3272 struct sock
**sk
= data
;
3273 struct mgmt_rp_disconnect rp
;
3275 bacpy(&rp
.addr
.bdaddr
, &cp
->addr
.bdaddr
);
3276 rp
.addr
.type
= cp
->addr
.type
;
3278 cmd_complete(cmd
->sk
, cmd
->index
, MGMT_OP_DISCONNECT
, 0, &rp
,
3284 mgmt_pending_remove(cmd
);
3287 static void unpair_device_rsp(struct pending_cmd
*cmd
, void *data
)
3289 struct hci_dev
*hdev
= data
;
3290 struct mgmt_cp_unpair_device
*cp
= cmd
->param
;
3291 struct mgmt_rp_unpair_device rp
;
3293 memset(&rp
, 0, sizeof(rp
));
3294 bacpy(&rp
.addr
.bdaddr
, &cp
->addr
.bdaddr
);
3295 rp
.addr
.type
= cp
->addr
.type
;
3297 device_unpaired(hdev
, &cp
->addr
.bdaddr
, cp
->addr
.type
, cmd
->sk
);
3299 cmd_complete(cmd
->sk
, cmd
->index
, cmd
->opcode
, 0, &rp
, sizeof(rp
));
3301 mgmt_pending_remove(cmd
);
3304 int mgmt_device_disconnected(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
3305 u8 link_type
, u8 addr_type
)
3307 struct mgmt_addr_info ev
;
3308 struct sock
*sk
= NULL
;
3311 mgmt_pending_foreach(MGMT_OP_DISCONNECT
, hdev
, disconnect_rsp
, &sk
);
3313 bacpy(&ev
.bdaddr
, bdaddr
);
3314 ev
.type
= link_to_mgmt(link_type
, addr_type
);
3316 err
= mgmt_event(MGMT_EV_DEVICE_DISCONNECTED
, hdev
, &ev
, sizeof(ev
),
3322 mgmt_pending_foreach(MGMT_OP_UNPAIR_DEVICE
, hdev
, unpair_device_rsp
,
3328 int mgmt_disconnect_failed(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
3329 u8 link_type
, u8 addr_type
, u8 status
)
3331 struct mgmt_rp_disconnect rp
;
3332 struct pending_cmd
*cmd
;
3335 cmd
= mgmt_pending_find(MGMT_OP_DISCONNECT
, hdev
);
3339 bacpy(&rp
.addr
.bdaddr
, bdaddr
);
3340 rp
.addr
.type
= link_to_mgmt(link_type
, addr_type
);
3342 err
= cmd_complete(cmd
->sk
, cmd
->index
, MGMT_OP_DISCONNECT
,
3343 mgmt_status(status
), &rp
, sizeof(rp
));
3345 mgmt_pending_remove(cmd
);
3347 mgmt_pending_foreach(MGMT_OP_UNPAIR_DEVICE
, hdev
, unpair_device_rsp
,
3352 int mgmt_connect_failed(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
, u8 link_type
,
3353 u8 addr_type
, u8 status
)
3355 struct mgmt_ev_connect_failed ev
;
3357 bacpy(&ev
.addr
.bdaddr
, bdaddr
);
3358 ev
.addr
.type
= link_to_mgmt(link_type
, addr_type
);
3359 ev
.status
= mgmt_status(status
);
3361 return mgmt_event(MGMT_EV_CONNECT_FAILED
, hdev
, &ev
, sizeof(ev
), NULL
);
3364 int mgmt_pin_code_request(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
, u8 secure
)
3366 struct mgmt_ev_pin_code_request ev
;
3368 bacpy(&ev
.addr
.bdaddr
, bdaddr
);
3369 ev
.addr
.type
= MGMT_ADDR_BREDR
;
3372 return mgmt_event(MGMT_EV_PIN_CODE_REQUEST
, hdev
, &ev
, sizeof(ev
),
3376 int mgmt_pin_code_reply_complete(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
3379 struct pending_cmd
*cmd
;
3380 struct mgmt_rp_pin_code_reply rp
;
3383 cmd
= mgmt_pending_find(MGMT_OP_PIN_CODE_REPLY
, hdev
);
3387 bacpy(&rp
.addr
.bdaddr
, bdaddr
);
3388 rp
.addr
.type
= MGMT_ADDR_BREDR
;
3390 err
= cmd_complete(cmd
->sk
, hdev
->id
, MGMT_OP_PIN_CODE_REPLY
,
3391 mgmt_status(status
), &rp
, sizeof(rp
));
3393 mgmt_pending_remove(cmd
);
3398 int mgmt_pin_code_neg_reply_complete(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
3401 struct pending_cmd
*cmd
;
3402 struct mgmt_rp_pin_code_reply rp
;
3405 cmd
= mgmt_pending_find(MGMT_OP_PIN_CODE_NEG_REPLY
, hdev
);
3409 bacpy(&rp
.addr
.bdaddr
, bdaddr
);
3410 rp
.addr
.type
= MGMT_ADDR_BREDR
;
3412 err
= cmd_complete(cmd
->sk
, hdev
->id
, MGMT_OP_PIN_CODE_NEG_REPLY
,
3413 mgmt_status(status
), &rp
, sizeof(rp
));
3415 mgmt_pending_remove(cmd
);
3420 int mgmt_user_confirm_request(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
3421 u8 link_type
, u8 addr_type
, __le32 value
,
3424 struct mgmt_ev_user_confirm_request ev
;
3426 BT_DBG("%s", hdev
->name
);
3428 bacpy(&ev
.addr
.bdaddr
, bdaddr
);
3429 ev
.addr
.type
= link_to_mgmt(link_type
, addr_type
);
3430 ev
.confirm_hint
= confirm_hint
;
3431 put_unaligned_le32(value
, &ev
.value
);
3433 return mgmt_event(MGMT_EV_USER_CONFIRM_REQUEST
, hdev
, &ev
, sizeof(ev
),
3437 int mgmt_user_passkey_request(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
3438 u8 link_type
, u8 addr_type
)
3440 struct mgmt_ev_user_passkey_request ev
;
3442 BT_DBG("%s", hdev
->name
);
3444 bacpy(&ev
.addr
.bdaddr
, bdaddr
);
3445 ev
.addr
.type
= link_to_mgmt(link_type
, addr_type
);
3447 return mgmt_event(MGMT_EV_USER_PASSKEY_REQUEST
, hdev
, &ev
, sizeof(ev
),
3451 static int user_pairing_resp_complete(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
3452 u8 link_type
, u8 addr_type
, u8 status
,
3455 struct pending_cmd
*cmd
;
3456 struct mgmt_rp_user_confirm_reply rp
;
3459 cmd
= mgmt_pending_find(opcode
, hdev
);
3463 bacpy(&rp
.addr
.bdaddr
, bdaddr
);
3464 rp
.addr
.type
= link_to_mgmt(link_type
, addr_type
);
3465 err
= cmd_complete(cmd
->sk
, hdev
->id
, opcode
, mgmt_status(status
),
3468 mgmt_pending_remove(cmd
);
3473 int mgmt_user_confirm_reply_complete(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
3474 u8 link_type
, u8 addr_type
, u8 status
)
3476 return user_pairing_resp_complete(hdev
, bdaddr
, link_type
, addr_type
,
3477 status
, MGMT_OP_USER_CONFIRM_REPLY
);
3480 int mgmt_user_confirm_neg_reply_complete(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
3481 u8 link_type
, u8 addr_type
, u8 status
)
3483 return user_pairing_resp_complete(hdev
, bdaddr
, link_type
, addr_type
,
3484 status
, MGMT_OP_USER_CONFIRM_NEG_REPLY
);
3487 int mgmt_user_passkey_reply_complete(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
3488 u8 link_type
, u8 addr_type
, u8 status
)
3490 return user_pairing_resp_complete(hdev
, bdaddr
, link_type
, addr_type
,
3491 status
, MGMT_OP_USER_PASSKEY_REPLY
);
3494 int mgmt_user_passkey_neg_reply_complete(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
,
3495 u8 link_type
, u8 addr_type
, u8 status
)
3497 return user_pairing_resp_complete(hdev
, bdaddr
, link_type
, addr_type
,
3498 status
, MGMT_OP_USER_PASSKEY_NEG_REPLY
);
3501 int mgmt_auth_failed(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
, u8 link_type
,
3502 u8 addr_type
, u8 status
)
3504 struct mgmt_ev_auth_failed ev
;
3506 bacpy(&ev
.addr
.bdaddr
, bdaddr
);
3507 ev
.addr
.type
= link_to_mgmt(link_type
, addr_type
);
3508 ev
.status
= mgmt_status(status
);
3510 return mgmt_event(MGMT_EV_AUTH_FAILED
, hdev
, &ev
, sizeof(ev
), NULL
);
3513 int mgmt_auth_enable_complete(struct hci_dev
*hdev
, u8 status
)
3515 struct cmd_lookup match
= { NULL
, hdev
};
3516 bool changed
= false;
3520 u8 mgmt_err
= mgmt_status(status
);
3521 mgmt_pending_foreach(MGMT_OP_SET_LINK_SECURITY
, hdev
,
3522 cmd_status_rsp
, &mgmt_err
);
3526 if (test_bit(HCI_AUTH
, &hdev
->flags
)) {
3527 if (!test_and_set_bit(HCI_LINK_SECURITY
, &hdev
->dev_flags
))
3530 if (test_and_clear_bit(HCI_LINK_SECURITY
, &hdev
->dev_flags
))
3534 mgmt_pending_foreach(MGMT_OP_SET_LINK_SECURITY
, hdev
, settings_rsp
,
3538 err
= new_settings(hdev
, match
.sk
);
3546 static int clear_eir(struct hci_dev
*hdev
)
3548 struct hci_cp_write_eir cp
;
3550 if (!(hdev
->features
[6] & LMP_EXT_INQ
))
3553 memset(hdev
->eir
, 0, sizeof(hdev
->eir
));
3555 memset(&cp
, 0, sizeof(cp
));
3557 return hci_send_cmd(hdev
, HCI_OP_WRITE_EIR
, sizeof(cp
), &cp
);
3560 int mgmt_ssp_enable_complete(struct hci_dev
*hdev
, u8 enable
, u8 status
)
3562 struct cmd_lookup match
= { NULL
, hdev
};
3563 bool changed
= false;
3567 u8 mgmt_err
= mgmt_status(status
);
3569 if (enable
&& test_and_clear_bit(HCI_SSP_ENABLED
,
3571 err
= new_settings(hdev
, NULL
);
3573 mgmt_pending_foreach(MGMT_OP_SET_SSP
, hdev
,
3574 cmd_status_rsp
, &mgmt_err
);
3580 if (!test_and_set_bit(HCI_SSP_ENABLED
, &hdev
->dev_flags
))
3583 if (test_and_clear_bit(HCI_SSP_ENABLED
, &hdev
->dev_flags
))
3587 mgmt_pending_foreach(MGMT_OP_SET_SSP
, hdev
, settings_rsp
, &match
);
3590 err
= new_settings(hdev
, match
.sk
);
3595 if (test_bit(HCI_SSP_ENABLED
, &hdev
->dev_flags
))
3603 int mgmt_set_class_of_dev_complete(struct hci_dev
*hdev
, u8
*dev_class
,
3608 err
= mgmt_event(MGMT_EV_CLASS_OF_DEV_CHANGED
, hdev
, dev_class
, 3, NULL
);
3613 int mgmt_set_local_name_complete(struct hci_dev
*hdev
, u8
*name
, u8 status
)
3615 struct pending_cmd
*cmd
;
3616 struct mgmt_cp_set_local_name ev
;
3617 bool changed
= false;
3620 if (memcmp(name
, hdev
->dev_name
, sizeof(hdev
->dev_name
)) != 0) {
3621 memcpy(hdev
->dev_name
, name
, sizeof(hdev
->dev_name
));
3625 memset(&ev
, 0, sizeof(ev
));
3626 memcpy(ev
.name
, name
, HCI_MAX_NAME_LENGTH
);
3627 memcpy(ev
.short_name
, hdev
->short_name
, HCI_MAX_SHORT_NAME_LENGTH
);
3629 cmd
= mgmt_pending_find(MGMT_OP_SET_LOCAL_NAME
, hdev
);
3633 /* Always assume that either the short or the complete name has
3634 * changed if there was a pending mgmt command */
3638 err
= cmd_status(cmd
->sk
, hdev
->id
, MGMT_OP_SET_LOCAL_NAME
,
3639 mgmt_status(status
));
3643 err
= cmd_complete(cmd
->sk
, hdev
->id
, MGMT_OP_SET_LOCAL_NAME
, 0, &ev
,
3650 err
= mgmt_event(MGMT_EV_LOCAL_NAME_CHANGED
, hdev
, &ev
,
3651 sizeof(ev
), cmd
? cmd
->sk
: NULL
);
3657 mgmt_pending_remove(cmd
);
3661 int mgmt_read_local_oob_data_reply_complete(struct hci_dev
*hdev
, u8
*hash
,
3662 u8
*randomizer
, u8 status
)
3664 struct pending_cmd
*cmd
;
3667 BT_DBG("%s status %u", hdev
->name
, status
);
3669 cmd
= mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA
, hdev
);
3674 err
= cmd_status(cmd
->sk
, hdev
->id
,
3675 MGMT_OP_READ_LOCAL_OOB_DATA
,
3676 mgmt_status(status
));
3678 struct mgmt_rp_read_local_oob_data rp
;
3680 memcpy(rp
.hash
, hash
, sizeof(rp
.hash
));
3681 memcpy(rp
.randomizer
, randomizer
, sizeof(rp
.randomizer
));
3683 err
= cmd_complete(cmd
->sk
, hdev
->id
,
3684 MGMT_OP_READ_LOCAL_OOB_DATA
,
3685 0, &rp
, sizeof(rp
));
3688 mgmt_pending_remove(cmd
);
3693 int mgmt_le_enable_complete(struct hci_dev
*hdev
, u8 enable
, u8 status
)
3695 struct cmd_lookup match
= { NULL
, hdev
};
3696 bool changed
= false;
3700 u8 mgmt_err
= mgmt_status(status
);
3702 if (enable
&& test_and_clear_bit(HCI_LE_ENABLED
,
3704 err
= new_settings(hdev
, NULL
);
3706 mgmt_pending_foreach(MGMT_OP_SET_LE
, hdev
,
3707 cmd_status_rsp
, &mgmt_err
);
3713 if (!test_and_set_bit(HCI_LE_ENABLED
, &hdev
->dev_flags
))
3716 if (test_and_clear_bit(HCI_LE_ENABLED
, &hdev
->dev_flags
))
3720 mgmt_pending_foreach(MGMT_OP_SET_LE
, hdev
, settings_rsp
, &match
);
3723 err
= new_settings(hdev
, match
.sk
);
3731 int mgmt_device_found(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
, u8 link_type
,
3732 u8 addr_type
, u8
*dev_class
, s8 rssi
,
3733 u8 cfm_name
, u8 ssp
, u8
*eir
, u16 eir_len
)
3736 struct mgmt_ev_device_found
*ev
= (void *) buf
;
3739 /* Leave 5 bytes for a potential CoD field */
3740 if (sizeof(*ev
) + eir_len
+ 5 > sizeof(buf
))
3743 memset(buf
, 0, sizeof(buf
));
3745 bacpy(&ev
->addr
.bdaddr
, bdaddr
);
3746 ev
->addr
.type
= link_to_mgmt(link_type
, addr_type
);
3749 ev
->flags
[0] |= MGMT_DEV_FOUND_CONFIRM_NAME
;
3751 ev
->flags
[0] |= MGMT_DEV_FOUND_LEGACY_PAIRING
;
3754 memcpy(ev
->eir
, eir
, eir_len
);
3756 if (dev_class
&& !eir_has_data_type(ev
->eir
, eir_len
, EIR_CLASS_OF_DEV
))
3757 eir_len
= eir_append_data(ev
->eir
, eir_len
, EIR_CLASS_OF_DEV
,
3760 put_unaligned_le16(eir_len
, &ev
->eir_len
);
3762 ev_size
= sizeof(*ev
) + eir_len
;
3764 return mgmt_event(MGMT_EV_DEVICE_FOUND
, hdev
, ev
, ev_size
, NULL
);
3767 int mgmt_remote_name(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
, u8 link_type
,
3768 u8 addr_type
, s8 rssi
, u8
*name
, u8 name_len
)
3770 struct mgmt_ev_device_found
*ev
;
3771 char buf
[sizeof(*ev
) + HCI_MAX_NAME_LENGTH
+ 2];
3774 ev
= (struct mgmt_ev_device_found
*) buf
;
3776 memset(buf
, 0, sizeof(buf
));
3778 bacpy(&ev
->addr
.bdaddr
, bdaddr
);
3779 ev
->addr
.type
= link_to_mgmt(link_type
, addr_type
);
3782 eir_len
= eir_append_data(ev
->eir
, 0, EIR_NAME_COMPLETE
, name
,
3785 put_unaligned_le16(eir_len
, &ev
->eir_len
);
3787 return mgmt_event(MGMT_EV_DEVICE_FOUND
, hdev
, ev
,
3788 sizeof(*ev
) + eir_len
, NULL
);
3791 int mgmt_start_discovery_failed(struct hci_dev
*hdev
, u8 status
)
3793 struct pending_cmd
*cmd
;
3797 hci_discovery_set_state(hdev
, DISCOVERY_STOPPED
);
3799 cmd
= mgmt_pending_find(MGMT_OP_START_DISCOVERY
, hdev
);
3803 type
= hdev
->discovery
.type
;
3805 err
= cmd_complete(cmd
->sk
, hdev
->id
, cmd
->opcode
, mgmt_status(status
),
3806 &type
, sizeof(type
));
3807 mgmt_pending_remove(cmd
);
3812 int mgmt_stop_discovery_failed(struct hci_dev
*hdev
, u8 status
)
3814 struct pending_cmd
*cmd
;
3817 cmd
= mgmt_pending_find(MGMT_OP_STOP_DISCOVERY
, hdev
);
3821 err
= cmd_complete(cmd
->sk
, hdev
->id
, cmd
->opcode
, mgmt_status(status
),
3822 &hdev
->discovery
.type
,
3823 sizeof(hdev
->discovery
.type
));
3824 mgmt_pending_remove(cmd
);
3829 int mgmt_discovering(struct hci_dev
*hdev
, u8 discovering
)
3831 struct mgmt_ev_discovering ev
;
3832 struct pending_cmd
*cmd
;
3834 BT_DBG("%s discovering %u", hdev
->name
, discovering
);
3837 cmd
= mgmt_pending_find(MGMT_OP_START_DISCOVERY
, hdev
);
3839 cmd
= mgmt_pending_find(MGMT_OP_STOP_DISCOVERY
, hdev
);
3842 u8 type
= hdev
->discovery
.type
;
3844 cmd_complete(cmd
->sk
, hdev
->id
, cmd
->opcode
, 0,
3845 &type
, sizeof(type
));
3846 mgmt_pending_remove(cmd
);
3849 memset(&ev
, 0, sizeof(ev
));
3850 ev
.type
= hdev
->discovery
.type
;
3851 ev
.discovering
= discovering
;
3853 return mgmt_event(MGMT_EV_DISCOVERING
, hdev
, &ev
, sizeof(ev
), NULL
);
3856 int mgmt_device_blocked(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
, u8 type
)
3858 struct pending_cmd
*cmd
;
3859 struct mgmt_ev_device_blocked ev
;
3861 cmd
= mgmt_pending_find(MGMT_OP_BLOCK_DEVICE
, hdev
);
3863 bacpy(&ev
.addr
.bdaddr
, bdaddr
);
3864 ev
.addr
.type
= type
;
3866 return mgmt_event(MGMT_EV_DEVICE_BLOCKED
, hdev
, &ev
, sizeof(ev
),
3867 cmd
? cmd
->sk
: NULL
);
3870 int mgmt_device_unblocked(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
, u8 type
)
3872 struct pending_cmd
*cmd
;
3873 struct mgmt_ev_device_unblocked ev
;
3875 cmd
= mgmt_pending_find(MGMT_OP_UNBLOCK_DEVICE
, hdev
);
3877 bacpy(&ev
.addr
.bdaddr
, bdaddr
);
3878 ev
.addr
.type
= type
;
3880 return mgmt_event(MGMT_EV_DEVICE_UNBLOCKED
, hdev
, &ev
, sizeof(ev
),
3881 cmd
? cmd
->sk
: NULL
);
3884 module_param(enable_hs
, bool, 0644);
3885 MODULE_PARM_DESC(enable_hs
, "Enable High Speed support");
3887 module_param(enable_le
, bool, 0644);
3888 MODULE_PARM_DESC(enable_le
, "Enable Low Energy support");