blob: d2d4e0d5aed017366668bf263538baf332255d20 [file] [log] [blame]
Johan Hedberg03811012010-12-08 00:21:06 +02001/*
2 BlueZ - Bluetooth protocol stack for Linux
Johan Hedbergea585ab2012-02-17 14:50:39 +02003
Johan Hedberg03811012010-12-08 00:21:06 +02004 Copyright (C) 2010 Nokia Corporation
Johan Hedbergea585ab2012-02-17 14:50:39 +02005 Copyright (C) 2011-2012 Intel Corporation
Johan Hedberg03811012010-12-08 00:21:06 +02006
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
Paul Gortmaker3a9a2312011-05-27 09:12:25 -040027#include <linux/module.h>
Johan Hedberg03811012010-12-08 00:21:06 +020028#include <asm/unaligned.h>
29
30#include <net/bluetooth/bluetooth.h>
31#include <net/bluetooth/hci_core.h>
32#include <net/bluetooth/mgmt.h>
Marcel Holtmannac4b7232013-10-10 14:54:16 -070033
34#include "smp.h"
Johan Hedberg03811012010-12-08 00:21:06 +020035
Johan Hedberg2da9c552012-02-17 14:39:28 +020036#define MGMT_VERSION 1
Marcel Holtmann404566442014-01-28 15:39:01 -080037#define MGMT_REVISION 5
Johan Hedberg02d98122010-12-13 21:07:04 +020038
Johan Hedberge70bb2e2012-02-13 16:59:33 +020039static const u16 mgmt_commands[] = {
40 MGMT_OP_READ_INDEX_LIST,
41 MGMT_OP_READ_INFO,
42 MGMT_OP_SET_POWERED,
43 MGMT_OP_SET_DISCOVERABLE,
44 MGMT_OP_SET_CONNECTABLE,
45 MGMT_OP_SET_FAST_CONNECTABLE,
46 MGMT_OP_SET_PAIRABLE,
47 MGMT_OP_SET_LINK_SECURITY,
48 MGMT_OP_SET_SSP,
49 MGMT_OP_SET_HS,
50 MGMT_OP_SET_LE,
51 MGMT_OP_SET_DEV_CLASS,
52 MGMT_OP_SET_LOCAL_NAME,
53 MGMT_OP_ADD_UUID,
54 MGMT_OP_REMOVE_UUID,
55 MGMT_OP_LOAD_LINK_KEYS,
56 MGMT_OP_LOAD_LONG_TERM_KEYS,
57 MGMT_OP_DISCONNECT,
58 MGMT_OP_GET_CONNECTIONS,
59 MGMT_OP_PIN_CODE_REPLY,
60 MGMT_OP_PIN_CODE_NEG_REPLY,
61 MGMT_OP_SET_IO_CAPABILITY,
62 MGMT_OP_PAIR_DEVICE,
63 MGMT_OP_CANCEL_PAIR_DEVICE,
64 MGMT_OP_UNPAIR_DEVICE,
65 MGMT_OP_USER_CONFIRM_REPLY,
66 MGMT_OP_USER_CONFIRM_NEG_REPLY,
67 MGMT_OP_USER_PASSKEY_REPLY,
68 MGMT_OP_USER_PASSKEY_NEG_REPLY,
69 MGMT_OP_READ_LOCAL_OOB_DATA,
70 MGMT_OP_ADD_REMOTE_OOB_DATA,
71 MGMT_OP_REMOVE_REMOTE_OOB_DATA,
72 MGMT_OP_START_DISCOVERY,
73 MGMT_OP_STOP_DISCOVERY,
74 MGMT_OP_CONFIRM_NAME,
75 MGMT_OP_BLOCK_DEVICE,
76 MGMT_OP_UNBLOCK_DEVICE,
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -070077 MGMT_OP_SET_DEVICE_ID,
Johan Hedberg4375f102013-09-25 13:26:10 +030078 MGMT_OP_SET_ADVERTISING,
Johan Hedberg0663ca22013-10-02 13:43:14 +030079 MGMT_OP_SET_BREDR,
Marcel Holtmannd13eafc2013-10-02 04:41:30 -070080 MGMT_OP_SET_STATIC_ADDRESS,
Marcel Holtmann7f72134e2013-10-11 14:44:58 -070081 MGMT_OP_SET_SCAN_PARAMS,
Marcel Holtmanne98d2ce2014-01-10 02:07:22 -080082 MGMT_OP_SET_SECURE_CONN,
Marcel Holtmann4e39ac82014-01-31 11:55:22 -080083 MGMT_OP_SET_DEBUG_KEYS,
Johan Hedberg62b04cd2014-02-23 19:42:27 +020084 MGMT_OP_SET_PRIVACY,
Johan Hedberg41edf162014-02-18 10:19:35 +020085 MGMT_OP_LOAD_IRKS,
Johan Hedberge70bb2e2012-02-13 16:59:33 +020086};
87
88static const u16 mgmt_events[] = {
89 MGMT_EV_CONTROLLER_ERROR,
90 MGMT_EV_INDEX_ADDED,
91 MGMT_EV_INDEX_REMOVED,
92 MGMT_EV_NEW_SETTINGS,
93 MGMT_EV_CLASS_OF_DEV_CHANGED,
94 MGMT_EV_LOCAL_NAME_CHANGED,
95 MGMT_EV_NEW_LINK_KEY,
96 MGMT_EV_NEW_LONG_TERM_KEY,
97 MGMT_EV_DEVICE_CONNECTED,
98 MGMT_EV_DEVICE_DISCONNECTED,
99 MGMT_EV_CONNECT_FAILED,
100 MGMT_EV_PIN_CODE_REQUEST,
101 MGMT_EV_USER_CONFIRM_REQUEST,
102 MGMT_EV_USER_PASSKEY_REQUEST,
103 MGMT_EV_AUTH_FAILED,
104 MGMT_EV_DEVICE_FOUND,
105 MGMT_EV_DISCOVERING,
106 MGMT_EV_DEVICE_BLOCKED,
107 MGMT_EV_DEVICE_UNBLOCKED,
108 MGMT_EV_DEVICE_UNPAIRED,
Johan Hedberg92a25252012-09-06 18:39:26 +0300109 MGMT_EV_PASSKEY_NOTIFY,
Marcel Holtmann1b60ef22014-02-21 21:35:30 -0800110 MGMT_EV_NEW_IRK,
Marcel Holtmann7ee4ea32014-03-09 12:19:17 -0700111 MGMT_EV_NEW_CSRK,
Johan Hedberge70bb2e2012-02-13 16:59:33 +0200112};
113
Marcel Holtmann17b02e62012-03-01 14:32:37 -0800114#define CACHE_TIMEOUT msecs_to_jiffies(2 * 1000)
Johan Hedberg7d785252011-12-15 00:47:39 +0200115
Johan Hedberg4b34ee782012-02-21 14:13:02 +0200116#define hdev_is_powered(hdev) (test_bit(HCI_UP, &hdev->flags) && \
117 !test_bit(HCI_AUTO_OFF, &hdev->dev_flags))
118
Johan Hedbergeec8d2b2010-12-16 10:17:38 +0200119struct pending_cmd {
120 struct list_head list;
Johan Hedbergfc2f4b12011-11-09 13:58:56 +0200121 u16 opcode;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +0200122 int index;
Szymon Jancc68fb7f2011-03-22 13:12:19 +0100123 void *param;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +0200124 struct sock *sk;
Johan Hedberge9a416b2011-02-19 12:05:56 -0300125 void *user_data;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +0200126};
127
Johan Hedbergca69b792011-11-11 18:10:00 +0200128/* HCI to MGMT error code conversion table */
129static u8 mgmt_status_table[] = {
130 MGMT_STATUS_SUCCESS,
131 MGMT_STATUS_UNKNOWN_COMMAND, /* Unknown Command */
132 MGMT_STATUS_NOT_CONNECTED, /* No Connection */
133 MGMT_STATUS_FAILED, /* Hardware Failure */
134 MGMT_STATUS_CONNECT_FAILED, /* Page Timeout */
135 MGMT_STATUS_AUTH_FAILED, /* Authentication Failed */
Johan Hedbergeadd6632014-01-13 17:15:53 +0200136 MGMT_STATUS_AUTH_FAILED, /* PIN or Key Missing */
Johan Hedbergca69b792011-11-11 18:10:00 +0200137 MGMT_STATUS_NO_RESOURCES, /* Memory Full */
138 MGMT_STATUS_TIMEOUT, /* Connection Timeout */
139 MGMT_STATUS_NO_RESOURCES, /* Max Number of Connections */
140 MGMT_STATUS_NO_RESOURCES, /* Max Number of SCO Connections */
141 MGMT_STATUS_ALREADY_CONNECTED, /* ACL Connection Exists */
142 MGMT_STATUS_BUSY, /* Command Disallowed */
143 MGMT_STATUS_NO_RESOURCES, /* Rejected Limited Resources */
144 MGMT_STATUS_REJECTED, /* Rejected Security */
145 MGMT_STATUS_REJECTED, /* Rejected Personal */
146 MGMT_STATUS_TIMEOUT, /* Host Timeout */
147 MGMT_STATUS_NOT_SUPPORTED, /* Unsupported Feature */
148 MGMT_STATUS_INVALID_PARAMS, /* Invalid Parameters */
149 MGMT_STATUS_DISCONNECTED, /* OE User Ended Connection */
150 MGMT_STATUS_NO_RESOURCES, /* OE Low Resources */
151 MGMT_STATUS_DISCONNECTED, /* OE Power Off */
152 MGMT_STATUS_DISCONNECTED, /* Connection Terminated */
153 MGMT_STATUS_BUSY, /* Repeated Attempts */
154 MGMT_STATUS_REJECTED, /* Pairing Not Allowed */
155 MGMT_STATUS_FAILED, /* Unknown LMP PDU */
156 MGMT_STATUS_NOT_SUPPORTED, /* Unsupported Remote Feature */
157 MGMT_STATUS_REJECTED, /* SCO Offset Rejected */
158 MGMT_STATUS_REJECTED, /* SCO Interval Rejected */
159 MGMT_STATUS_REJECTED, /* Air Mode Rejected */
160 MGMT_STATUS_INVALID_PARAMS, /* Invalid LMP Parameters */
161 MGMT_STATUS_FAILED, /* Unspecified Error */
162 MGMT_STATUS_NOT_SUPPORTED, /* Unsupported LMP Parameter Value */
163 MGMT_STATUS_FAILED, /* Role Change Not Allowed */
164 MGMT_STATUS_TIMEOUT, /* LMP Response Timeout */
165 MGMT_STATUS_FAILED, /* LMP Error Transaction Collision */
166 MGMT_STATUS_FAILED, /* LMP PDU Not Allowed */
167 MGMT_STATUS_REJECTED, /* Encryption Mode Not Accepted */
168 MGMT_STATUS_FAILED, /* Unit Link Key Used */
169 MGMT_STATUS_NOT_SUPPORTED, /* QoS Not Supported */
170 MGMT_STATUS_TIMEOUT, /* Instant Passed */
171 MGMT_STATUS_NOT_SUPPORTED, /* Pairing Not Supported */
172 MGMT_STATUS_FAILED, /* Transaction Collision */
173 MGMT_STATUS_INVALID_PARAMS, /* Unacceptable Parameter */
174 MGMT_STATUS_REJECTED, /* QoS Rejected */
175 MGMT_STATUS_NOT_SUPPORTED, /* Classification Not Supported */
176 MGMT_STATUS_REJECTED, /* Insufficient Security */
177 MGMT_STATUS_INVALID_PARAMS, /* Parameter Out Of Range */
178 MGMT_STATUS_BUSY, /* Role Switch Pending */
179 MGMT_STATUS_FAILED, /* Slot Violation */
180 MGMT_STATUS_FAILED, /* Role Switch Failed */
181 MGMT_STATUS_INVALID_PARAMS, /* EIR Too Large */
182 MGMT_STATUS_NOT_SUPPORTED, /* Simple Pairing Not Supported */
183 MGMT_STATUS_BUSY, /* Host Busy Pairing */
184 MGMT_STATUS_REJECTED, /* Rejected, No Suitable Channel */
185 MGMT_STATUS_BUSY, /* Controller Busy */
186 MGMT_STATUS_INVALID_PARAMS, /* Unsuitable Connection Interval */
187 MGMT_STATUS_TIMEOUT, /* Directed Advertising Timeout */
188 MGMT_STATUS_AUTH_FAILED, /* Terminated Due to MIC Failure */
189 MGMT_STATUS_CONNECT_FAILED, /* Connection Establishment Failed */
190 MGMT_STATUS_CONNECT_FAILED, /* MAC Connection Failed */
191};
192
193static u8 mgmt_status(u8 hci_status)
194{
195 if (hci_status < ARRAY_SIZE(mgmt_status_table))
196 return mgmt_status_table[hci_status];
197
198 return MGMT_STATUS_FAILED;
199}
200
Szymon Janc4e51eae2011-02-25 19:05:48 +0100201static int cmd_status(struct sock *sk, u16 index, u16 cmd, u8 status)
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200202{
203 struct sk_buff *skb;
204 struct mgmt_hdr *hdr;
205 struct mgmt_ev_cmd_status *ev;
Gustavo F. Padovan56b7d132011-10-14 19:20:01 -0300206 int err;
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200207
Szymon Janc34eb5252011-02-28 14:10:08 +0100208 BT_DBG("sock %p, index %u, cmd %u, status %u", sk, index, cmd, status);
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200209
Andre Guedes790eff42012-06-07 19:05:46 -0300210 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev), GFP_KERNEL);
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200211 if (!skb)
212 return -ENOMEM;
213
214 hdr = (void *) skb_put(skb, sizeof(*hdr));
215
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700216 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_STATUS);
Szymon Janc4e51eae2011-02-25 19:05:48 +0100217 hdr->index = cpu_to_le16(index);
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200218 hdr->len = cpu_to_le16(sizeof(*ev));
219
220 ev = (void *) skb_put(skb, sizeof(*ev));
221 ev->status = status;
Marcel Holtmanneb55ef02012-03-14 18:08:46 +0200222 ev->opcode = cpu_to_le16(cmd);
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200223
Gustavo F. Padovan56b7d132011-10-14 19:20:01 -0300224 err = sock_queue_rcv_skb(sk, skb);
225 if (err < 0)
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200226 kfree_skb(skb);
227
Gustavo F. Padovan56b7d132011-10-14 19:20:01 -0300228 return err;
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200229}
230
Johan Hedbergaee9b2182012-02-18 15:07:59 +0200231static int cmd_complete(struct sock *sk, u16 index, u16 cmd, u8 status,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300232 void *rp, size_t rp_len)
Johan Hedberg02d98122010-12-13 21:07:04 +0200233{
234 struct sk_buff *skb;
235 struct mgmt_hdr *hdr;
236 struct mgmt_ev_cmd_complete *ev;
Gustavo F. Padovan56b7d132011-10-14 19:20:01 -0300237 int err;
Johan Hedberg02d98122010-12-13 21:07:04 +0200238
239 BT_DBG("sock %p", sk);
240
Andre Guedes790eff42012-06-07 19:05:46 -0300241 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev) + rp_len, GFP_KERNEL);
Johan Hedberg02d98122010-12-13 21:07:04 +0200242 if (!skb)
243 return -ENOMEM;
244
245 hdr = (void *) skb_put(skb, sizeof(*hdr));
Johan Hedberga38528f2011-01-22 06:46:43 +0200246
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700247 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE);
Szymon Janc4e51eae2011-02-25 19:05:48 +0100248 hdr->index = cpu_to_le16(index);
Johan Hedberga38528f2011-01-22 06:46:43 +0200249 hdr->len = cpu_to_le16(sizeof(*ev) + rp_len);
Johan Hedberg02d98122010-12-13 21:07:04 +0200250
Johan Hedberga38528f2011-01-22 06:46:43 +0200251 ev = (void *) skb_put(skb, sizeof(*ev) + rp_len);
Marcel Holtmanneb55ef02012-03-14 18:08:46 +0200252 ev->opcode = cpu_to_le16(cmd);
Johan Hedbergaee9b2182012-02-18 15:07:59 +0200253 ev->status = status;
Szymon Janc8020c162011-02-28 14:09:50 +0100254
255 if (rp)
256 memcpy(ev->data, rp, rp_len);
Johan Hedberg02d98122010-12-13 21:07:04 +0200257
Gustavo F. Padovan56b7d132011-10-14 19:20:01 -0300258 err = sock_queue_rcv_skb(sk, skb);
259 if (err < 0)
Johan Hedberg02d98122010-12-13 21:07:04 +0200260 kfree_skb(skb);
261
Marcel Holtmanne5f0e152012-02-22 11:59:01 +0100262 return err;
Johan Hedberg02d98122010-12-13 21:07:04 +0200263}
264
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300265static int read_version(struct sock *sk, struct hci_dev *hdev, void *data,
266 u16 data_len)
Johan Hedberga38528f2011-01-22 06:46:43 +0200267{
268 struct mgmt_rp_read_version rp;
269
270 BT_DBG("sock %p", sk);
271
272 rp.version = MGMT_VERSION;
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700273 rp.revision = cpu_to_le16(MGMT_REVISION);
Johan Hedberga38528f2011-01-22 06:46:43 +0200274
Johan Hedbergaee9b2182012-02-18 15:07:59 +0200275 return cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_VERSION, 0, &rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300276 sizeof(rp));
Johan Hedberga38528f2011-01-22 06:46:43 +0200277}
278
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300279static int read_commands(struct sock *sk, struct hci_dev *hdev, void *data,
280 u16 data_len)
Johan Hedberge70bb2e2012-02-13 16:59:33 +0200281{
282 struct mgmt_rp_read_commands *rp;
Marcel Holtmanneb55ef02012-03-14 18:08:46 +0200283 const u16 num_commands = ARRAY_SIZE(mgmt_commands);
284 const u16 num_events = ARRAY_SIZE(mgmt_events);
Andrei Emeltchenko2e3c35e2012-03-14 18:54:15 +0200285 __le16 *opcode;
Johan Hedberge70bb2e2012-02-13 16:59:33 +0200286 size_t rp_size;
287 int i, err;
288
289 BT_DBG("sock %p", sk);
290
291 rp_size = sizeof(*rp) + ((num_commands + num_events) * sizeof(u16));
292
293 rp = kmalloc(rp_size, GFP_KERNEL);
294 if (!rp)
295 return -ENOMEM;
296
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700297 rp->num_commands = cpu_to_le16(num_commands);
298 rp->num_events = cpu_to_le16(num_events);
Johan Hedberge70bb2e2012-02-13 16:59:33 +0200299
300 for (i = 0, opcode = rp->opcodes; i < num_commands; i++, opcode++)
301 put_unaligned_le16(mgmt_commands[i], opcode);
302
303 for (i = 0; i < num_events; i++, opcode++)
304 put_unaligned_le16(mgmt_events[i], opcode);
305
Johan Hedbergaee9b2182012-02-18 15:07:59 +0200306 err = cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_COMMANDS, 0, rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300307 rp_size);
Johan Hedberge70bb2e2012-02-13 16:59:33 +0200308 kfree(rp);
309
310 return err;
311}
312
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300313static int read_index_list(struct sock *sk, struct hci_dev *hdev, void *data,
314 u16 data_len)
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200315{
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200316 struct mgmt_rp_read_index_list *rp;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200317 struct hci_dev *d;
Johan Hedberga38528f2011-01-22 06:46:43 +0200318 size_t rp_len;
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200319 u16 count;
Johan Hedberg476e44c2012-10-19 20:10:46 +0300320 int err;
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200321
322 BT_DBG("sock %p", sk);
323
324 read_lock(&hci_dev_list_lock);
325
326 count = 0;
Andrei Emeltchenkobb4b2a92012-07-19 17:03:40 +0300327 list_for_each_entry(d, &hci_dev_list, list) {
Marcel Holtmann1514b892013-10-06 08:25:01 -0700328 if (d->dev_type == HCI_BREDR)
329 count++;
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200330 }
331
Johan Hedberga38528f2011-01-22 06:46:43 +0200332 rp_len = sizeof(*rp) + (2 * count);
333 rp = kmalloc(rp_len, GFP_ATOMIC);
334 if (!rp) {
Jesper Juhlb2c60d42011-01-14 00:18:49 +0100335 read_unlock(&hci_dev_list_lock);
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200336 return -ENOMEM;
Jesper Juhlb2c60d42011-01-14 00:18:49 +0100337 }
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200338
Johan Hedberg476e44c2012-10-19 20:10:46 +0300339 count = 0;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200340 list_for_each_entry(d, &hci_dev_list, list) {
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200341 if (test_bit(HCI_SETUP, &d->dev_flags))
Johan Hedbergab81cbf2010-12-15 13:53:18 +0200342 continue;
343
Marcel Holtmann0736cfa2013-08-26 21:40:51 -0700344 if (test_bit(HCI_USER_CHANNEL, &d->dev_flags))
345 continue;
346
Marcel Holtmann1514b892013-10-06 08:25:01 -0700347 if (d->dev_type == HCI_BREDR) {
348 rp->index[count++] = cpu_to_le16(d->id);
349 BT_DBG("Added hci%u", d->id);
350 }
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200351 }
352
Johan Hedberg476e44c2012-10-19 20:10:46 +0300353 rp->num_controllers = cpu_to_le16(count);
354 rp_len = sizeof(*rp) + (2 * count);
355
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200356 read_unlock(&hci_dev_list_lock);
357
Johan Hedbergaee9b2182012-02-18 15:07:59 +0200358 err = cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_INDEX_LIST, 0, rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300359 rp_len);
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200360
Johan Hedberga38528f2011-01-22 06:46:43 +0200361 kfree(rp);
362
363 return err;
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200364}
365
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200366static u32 get_supported_settings(struct hci_dev *hdev)
Johan Hedberg03811012010-12-08 00:21:06 +0200367{
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200368 u32 settings = 0;
Johan Hedberg03811012010-12-08 00:21:06 +0200369
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200370 settings |= MGMT_SETTING_POWERED;
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200371 settings |= MGMT_SETTING_PAIRABLE;
Marcel Holtmannb1de97d2014-01-31 11:55:21 -0800372 settings |= MGMT_SETTING_DEBUG_KEYS;
Johan Hedberg03811012010-12-08 00:21:06 +0200373
Andre Guedesed3fa312012-07-24 15:03:46 -0300374 if (lmp_bredr_capable(hdev)) {
Johan Hedberg33c525c2012-10-24 21:11:58 +0300375 settings |= MGMT_SETTING_CONNECTABLE;
Johan Hedberg1a47aee2013-03-15 17:07:06 -0500376 if (hdev->hci_ver >= BLUETOOTH_VER_1_2)
377 settings |= MGMT_SETTING_FAST_CONNECTABLE;
Johan Hedberg33c525c2012-10-24 21:11:58 +0300378 settings |= MGMT_SETTING_DISCOVERABLE;
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200379 settings |= MGMT_SETTING_BREDR;
380 settings |= MGMT_SETTING_LINK_SECURITY;
Marcel Holtmanna82974c2013-10-11 09:48:47 -0700381
382 if (lmp_ssp_capable(hdev)) {
383 settings |= MGMT_SETTING_SSP;
384 settings |= MGMT_SETTING_HS;
385 }
Marcel Holtmanne98d2ce2014-01-10 02:07:22 -0800386
Marcel Holtmann5afeac142014-01-10 02:07:27 -0800387 if (lmp_sc_capable(hdev) ||
388 test_bit(HCI_FORCE_SC, &hdev->dev_flags))
Marcel Holtmanne98d2ce2014-01-10 02:07:22 -0800389 settings |= MGMT_SETTING_SECURE_CONN;
Marcel Holtmann848566b2013-10-01 22:59:22 -0700390 }
Marcel Holtmannd7b7e792012-02-20 21:47:49 +0100391
Johan Hedbergeeca6f82013-09-25 13:26:09 +0300392 if (lmp_le_capable(hdev)) {
Marcel Holtmann9d428202012-05-03 07:12:31 +0200393 settings |= MGMT_SETTING_LE;
Johan Hedbergeeca6f82013-09-25 13:26:09 +0300394 settings |= MGMT_SETTING_ADVERTISING;
Johan Hedberg0f4bd942014-02-22 19:06:35 +0200395 settings |= MGMT_SETTING_PRIVACY;
Johan Hedbergeeca6f82013-09-25 13:26:09 +0300396 }
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200397
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200398 return settings;
399}
Johan Hedbergebc99fe2011-01-04 11:54:26 +0200400
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200401static u32 get_current_settings(struct hci_dev *hdev)
402{
403 u32 settings = 0;
Johan Hedbergdc4fe302011-03-16 14:29:36 +0200404
Johan Hedbergf1f0eb02012-02-21 17:15:41 +0200405 if (hdev_is_powered(hdev))
Marcel Holtmannf0d4b782012-02-21 12:14:25 +0100406 settings |= MGMT_SETTING_POWERED;
407
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200408 if (test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200409 settings |= MGMT_SETTING_CONNECTABLE;
410
Johan Hedberg1a4d3c42013-03-15 17:07:08 -0500411 if (test_bit(HCI_FAST_CONNECTABLE, &hdev->dev_flags))
412 settings |= MGMT_SETTING_FAST_CONNECTABLE;
413
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200414 if (test_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200415 settings |= MGMT_SETTING_DISCOVERABLE;
416
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200417 if (test_bit(HCI_PAIRABLE, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200418 settings |= MGMT_SETTING_PAIRABLE;
419
Johan Hedberg56f87902013-10-02 13:43:13 +0300420 if (test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200421 settings |= MGMT_SETTING_BREDR;
422
Johan Hedberg06199cf2012-02-22 16:37:11 +0200423 if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200424 settings |= MGMT_SETTING_LE;
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200425
Johan Hedberg47990ea2012-02-22 11:58:37 +0200426 if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200427 settings |= MGMT_SETTING_LINK_SECURITY;
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200428
Johan Hedberg84bde9d2012-01-25 14:21:06 +0200429 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200430 settings |= MGMT_SETTING_SSP;
Johan Hedbergf7b64e62010-12-13 21:07:06 +0200431
Johan Hedberg6d80dfd2012-02-20 23:50:38 +0200432 if (test_bit(HCI_HS_ENABLED, &hdev->dev_flags))
433 settings |= MGMT_SETTING_HS;
434
Johan Hedbergf3d3444a2013-10-05 12:01:04 +0200435 if (test_bit(HCI_ADVERTISING, &hdev->dev_flags))
Johan Hedbergeeca6f82013-09-25 13:26:09 +0300436 settings |= MGMT_SETTING_ADVERTISING;
437
Marcel Holtmanne98d2ce2014-01-10 02:07:22 -0800438 if (test_bit(HCI_SC_ENABLED, &hdev->dev_flags))
439 settings |= MGMT_SETTING_SECURE_CONN;
440
Marcel Holtmannb1de97d2014-01-31 11:55:21 -0800441 if (test_bit(HCI_DEBUG_KEYS, &hdev->dev_flags))
442 settings |= MGMT_SETTING_DEBUG_KEYS;
443
Johan Hedberg0f4bd942014-02-22 19:06:35 +0200444 if (test_bit(HCI_PRIVACY, &hdev->dev_flags))
445 settings |= MGMT_SETTING_PRIVACY;
446
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200447 return settings;
Johan Hedbergc542a062011-01-26 13:11:03 +0200448}
449
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300450#define PNP_INFO_SVCLASS_ID 0x1200
451
Johan Hedberg213202e2013-01-27 00:31:33 +0200452static u8 *create_uuid16_list(struct hci_dev *hdev, u8 *data, ptrdiff_t len)
453{
454 u8 *ptr = data, *uuids_start = NULL;
455 struct bt_uuid *uuid;
456
457 if (len < 4)
458 return ptr;
459
460 list_for_each_entry(uuid, &hdev->uuids, list) {
461 u16 uuid16;
462
463 if (uuid->size != 16)
464 continue;
465
466 uuid16 = get_unaligned_le16(&uuid->uuid[12]);
467 if (uuid16 < 0x1100)
468 continue;
469
470 if (uuid16 == PNP_INFO_SVCLASS_ID)
471 continue;
472
473 if (!uuids_start) {
474 uuids_start = ptr;
475 uuids_start[0] = 1;
476 uuids_start[1] = EIR_UUID16_ALL;
477 ptr += 2;
478 }
479
480 /* Stop if not enough space to put next UUID */
481 if ((ptr - data) + sizeof(u16) > len) {
482 uuids_start[1] = EIR_UUID16_SOME;
483 break;
484 }
485
486 *ptr++ = (uuid16 & 0x00ff);
487 *ptr++ = (uuid16 & 0xff00) >> 8;
488 uuids_start[0] += sizeof(uuid16);
489 }
490
491 return ptr;
492}
493
Johan Hedbergcdf19632013-01-27 00:31:34 +0200494static u8 *create_uuid32_list(struct hci_dev *hdev, u8 *data, ptrdiff_t len)
495{
496 u8 *ptr = data, *uuids_start = NULL;
497 struct bt_uuid *uuid;
498
499 if (len < 6)
500 return ptr;
501
502 list_for_each_entry(uuid, &hdev->uuids, list) {
503 if (uuid->size != 32)
504 continue;
505
506 if (!uuids_start) {
507 uuids_start = ptr;
508 uuids_start[0] = 1;
509 uuids_start[1] = EIR_UUID32_ALL;
510 ptr += 2;
511 }
512
513 /* Stop if not enough space to put next UUID */
514 if ((ptr - data) + sizeof(u32) > len) {
515 uuids_start[1] = EIR_UUID32_SOME;
516 break;
517 }
518
519 memcpy(ptr, &uuid->uuid[12], sizeof(u32));
520 ptr += sizeof(u32);
521 uuids_start[0] += sizeof(u32);
522 }
523
524 return ptr;
525}
526
Johan Hedbergc00d5752013-01-27 00:31:35 +0200527static u8 *create_uuid128_list(struct hci_dev *hdev, u8 *data, ptrdiff_t len)
528{
529 u8 *ptr = data, *uuids_start = NULL;
530 struct bt_uuid *uuid;
531
532 if (len < 18)
533 return ptr;
534
535 list_for_each_entry(uuid, &hdev->uuids, list) {
536 if (uuid->size != 128)
537 continue;
538
539 if (!uuids_start) {
540 uuids_start = ptr;
541 uuids_start[0] = 1;
542 uuids_start[1] = EIR_UUID128_ALL;
543 ptr += 2;
544 }
545
546 /* Stop if not enough space to put next UUID */
547 if ((ptr - data) + 16 > len) {
548 uuids_start[1] = EIR_UUID128_SOME;
549 break;
550 }
551
552 memcpy(ptr, uuid->uuid, 16);
553 ptr += 16;
554 uuids_start[0] += 16;
555 }
556
557 return ptr;
558}
559
Johan Hedbergeb2a8d22013-10-19 23:38:20 +0300560static struct pending_cmd *mgmt_pending_find(u16 opcode, struct hci_dev *hdev)
561{
562 struct pending_cmd *cmd;
563
564 list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
565 if (cmd->opcode == opcode)
566 return cmd;
567 }
568
569 return NULL;
570}
571
Marcel Holtmannf14d8f62013-10-16 00:16:48 -0700572static u8 create_scan_rsp_data(struct hci_dev *hdev, u8 *ptr)
573{
Marcel Holtmann7a5f4992013-10-16 00:16:49 -0700574 u8 ad_len = 0;
575 size_t name_len;
576
577 name_len = strlen(hdev->dev_name);
578 if (name_len > 0) {
579 size_t max_len = HCI_MAX_AD_LENGTH - ad_len - 2;
580
581 if (name_len > max_len) {
582 name_len = max_len;
583 ptr[1] = EIR_NAME_SHORT;
584 } else
585 ptr[1] = EIR_NAME_COMPLETE;
586
587 ptr[0] = name_len + 1;
588
589 memcpy(ptr + 2, hdev->dev_name, name_len);
590
591 ad_len += (name_len + 2);
592 ptr += (name_len + 2);
593 }
594
595 return ad_len;
Marcel Holtmannf14d8f62013-10-16 00:16:48 -0700596}
597
598static void update_scan_rsp_data(struct hci_request *req)
599{
600 struct hci_dev *hdev = req->hdev;
601 struct hci_cp_le_set_scan_rsp_data cp;
602 u8 len;
603
Johan Hedberg7751ef12013-10-19 23:38:15 +0300604 if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags))
Marcel Holtmannf14d8f62013-10-16 00:16:48 -0700605 return;
606
607 memset(&cp, 0, sizeof(cp));
608
609 len = create_scan_rsp_data(hdev, cp.data);
610
Johan Hedbergeb438b52013-10-16 15:31:07 +0300611 if (hdev->scan_rsp_data_len == len &&
612 memcmp(cp.data, hdev->scan_rsp_data, len) == 0)
Marcel Holtmannf14d8f62013-10-16 00:16:48 -0700613 return;
614
Johan Hedbergeb438b52013-10-16 15:31:07 +0300615 memcpy(hdev->scan_rsp_data, cp.data, sizeof(cp.data));
616 hdev->scan_rsp_data_len = len;
Marcel Holtmannf14d8f62013-10-16 00:16:48 -0700617
618 cp.length = len;
619
620 hci_req_add(req, HCI_OP_LE_SET_SCAN_RSP_DATA, sizeof(cp), &cp);
621}
622
Johan Hedberg9a43e252013-10-20 19:00:07 +0300623static u8 get_adv_discov_flags(struct hci_dev *hdev)
624{
625 struct pending_cmd *cmd;
626
627 /* If there's a pending mgmt command the flags will not yet have
628 * their final values, so check for this first.
629 */
630 cmd = mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, hdev);
631 if (cmd) {
632 struct mgmt_mode *cp = cmd->param;
633 if (cp->val == 0x01)
634 return LE_AD_GENERAL;
635 else if (cp->val == 0x02)
636 return LE_AD_LIMITED;
637 } else {
638 if (test_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags))
639 return LE_AD_LIMITED;
640 else if (test_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
641 return LE_AD_GENERAL;
642 }
643
644 return 0;
645}
646
Marcel Holtmann46cad2e2013-10-16 00:16:46 -0700647static u8 create_adv_data(struct hci_dev *hdev, u8 *ptr)
Marcel Holtmann441ad2d2013-10-15 06:33:52 -0700648{
649 u8 ad_len = 0, flags = 0;
Marcel Holtmann441ad2d2013-10-15 06:33:52 -0700650
Johan Hedberg9a43e252013-10-20 19:00:07 +0300651 flags |= get_adv_discov_flags(hdev);
Marcel Holtmann441ad2d2013-10-15 06:33:52 -0700652
Johan Hedberge8340042014-01-30 11:16:50 -0800653 if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags))
Marcel Holtmann441ad2d2013-10-15 06:33:52 -0700654 flags |= LE_AD_NO_BREDR;
Marcel Holtmann441ad2d2013-10-15 06:33:52 -0700655
656 if (flags) {
657 BT_DBG("adv flags 0x%02x", flags);
658
659 ptr[0] = 2;
660 ptr[1] = EIR_FLAGS;
661 ptr[2] = flags;
662
663 ad_len += 3;
664 ptr += 3;
665 }
666
667 if (hdev->adv_tx_power != HCI_TX_POWER_INVALID) {
668 ptr[0] = 2;
669 ptr[1] = EIR_TX_POWER;
670 ptr[2] = (u8) hdev->adv_tx_power;
671
672 ad_len += 3;
673 ptr += 3;
674 }
675
Marcel Holtmann441ad2d2013-10-15 06:33:52 -0700676 return ad_len;
677}
678
Marcel Holtmann5947f4b2013-10-16 00:16:50 -0700679static void update_adv_data(struct hci_request *req)
Marcel Holtmann441ad2d2013-10-15 06:33:52 -0700680{
681 struct hci_dev *hdev = req->hdev;
682 struct hci_cp_le_set_adv_data cp;
683 u8 len;
684
Johan Hedberg10994ce2013-10-19 23:38:16 +0300685 if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags))
Marcel Holtmann441ad2d2013-10-15 06:33:52 -0700686 return;
687
688 memset(&cp, 0, sizeof(cp));
689
Marcel Holtmann46cad2e2013-10-16 00:16:46 -0700690 len = create_adv_data(hdev, cp.data);
Marcel Holtmann441ad2d2013-10-15 06:33:52 -0700691
692 if (hdev->adv_data_len == len &&
693 memcmp(cp.data, hdev->adv_data, len) == 0)
694 return;
695
696 memcpy(hdev->adv_data, cp.data, sizeof(cp.data));
697 hdev->adv_data_len = len;
698
699 cp.length = len;
700
701 hci_req_add(req, HCI_OP_LE_SET_ADV_DATA, sizeof(cp), &cp);
702}
703
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300704static void create_eir(struct hci_dev *hdev, u8 *data)
705{
706 u8 *ptr = data;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300707 size_t name_len;
708
709 name_len = strlen(hdev->dev_name);
710
711 if (name_len > 0) {
712 /* EIR Data type */
713 if (name_len > 48) {
714 name_len = 48;
715 ptr[1] = EIR_NAME_SHORT;
716 } else
717 ptr[1] = EIR_NAME_COMPLETE;
718
719 /* EIR Data length */
720 ptr[0] = name_len + 1;
721
722 memcpy(ptr + 2, hdev->dev_name, name_len);
723
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300724 ptr += (name_len + 2);
725 }
726
Johan Hedbergbbaf4442012-11-08 01:22:59 +0100727 if (hdev->inq_tx_power != HCI_TX_POWER_INVALID) {
Marcel Holtmann91c4e9b2012-03-11 19:27:21 -0700728 ptr[0] = 2;
729 ptr[1] = EIR_TX_POWER;
730 ptr[2] = (u8) hdev->inq_tx_power;
731
Marcel Holtmann91c4e9b2012-03-11 19:27:21 -0700732 ptr += 3;
733 }
734
Marcel Holtmann2b9be132012-03-11 19:32:12 -0700735 if (hdev->devid_source > 0) {
736 ptr[0] = 9;
737 ptr[1] = EIR_DEVICE_ID;
738
739 put_unaligned_le16(hdev->devid_source, ptr + 2);
740 put_unaligned_le16(hdev->devid_vendor, ptr + 4);
741 put_unaligned_le16(hdev->devid_product, ptr + 6);
742 put_unaligned_le16(hdev->devid_version, ptr + 8);
743
Marcel Holtmann2b9be132012-03-11 19:32:12 -0700744 ptr += 10;
745 }
746
Johan Hedberg213202e2013-01-27 00:31:33 +0200747 ptr = create_uuid16_list(hdev, ptr, HCI_MAX_EIR_LENGTH - (ptr - data));
Johan Hedbergcdf19632013-01-27 00:31:34 +0200748 ptr = create_uuid32_list(hdev, ptr, HCI_MAX_EIR_LENGTH - (ptr - data));
Johan Hedbergc00d5752013-01-27 00:31:35 +0200749 ptr = create_uuid128_list(hdev, ptr, HCI_MAX_EIR_LENGTH - (ptr - data));
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300750}
751
Johan Hedberg890ea892013-03-15 17:06:52 -0500752static void update_eir(struct hci_request *req)
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300753{
Johan Hedberg890ea892013-03-15 17:06:52 -0500754 struct hci_dev *hdev = req->hdev;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300755 struct hci_cp_write_eir cp;
756
Johan Hedberg504c8dc2012-02-23 13:30:41 +0200757 if (!hdev_is_powered(hdev))
Johan Hedberg890ea892013-03-15 17:06:52 -0500758 return;
Johan Hedberg7770c4a2012-02-22 22:06:38 +0200759
Johan Hedberg976eb202012-10-24 21:12:01 +0300760 if (!lmp_ext_inq_capable(hdev))
Johan Hedberg890ea892013-03-15 17:06:52 -0500761 return;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300762
Johan Hedberg84bde9d2012-01-25 14:21:06 +0200763 if (!test_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
Johan Hedberg890ea892013-03-15 17:06:52 -0500764 return;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300765
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200766 if (test_bit(HCI_SERVICE_CACHE, &hdev->dev_flags))
Johan Hedberg890ea892013-03-15 17:06:52 -0500767 return;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300768
769 memset(&cp, 0, sizeof(cp));
770
771 create_eir(hdev, cp.data);
772
773 if (memcmp(cp.data, hdev->eir, sizeof(cp.data)) == 0)
Johan Hedberg890ea892013-03-15 17:06:52 -0500774 return;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300775
776 memcpy(hdev->eir, cp.data, sizeof(cp.data));
777
Johan Hedberg890ea892013-03-15 17:06:52 -0500778 hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp);
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300779}
780
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200781static u8 get_service_classes(struct hci_dev *hdev)
782{
Gustavo F. Padovan12dc0742011-10-14 19:32:56 -0300783 struct bt_uuid *uuid;
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200784 u8 val = 0;
785
Gustavo F. Padovan12dc0742011-10-14 19:32:56 -0300786 list_for_each_entry(uuid, &hdev->uuids, list)
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200787 val |= uuid->svc_hint;
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200788
789 return val;
790}
791
Johan Hedberg890ea892013-03-15 17:06:52 -0500792static void update_class(struct hci_request *req)
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200793{
Johan Hedberg890ea892013-03-15 17:06:52 -0500794 struct hci_dev *hdev = req->hdev;
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200795 u8 cod[3];
796
797 BT_DBG("%s", hdev->name);
798
Johan Hedberg504c8dc2012-02-23 13:30:41 +0200799 if (!hdev_is_powered(hdev))
Johan Hedberg890ea892013-03-15 17:06:52 -0500800 return;
Johan Hedberg7770c4a2012-02-22 22:06:38 +0200801
Johan Hedbergf87ea1d2013-10-19 23:38:17 +0300802 if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags))
803 return;
804
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200805 if (test_bit(HCI_SERVICE_CACHE, &hdev->dev_flags))
Johan Hedberg890ea892013-03-15 17:06:52 -0500806 return;
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200807
808 cod[0] = hdev->minor_class;
809 cod[1] = hdev->major_class;
810 cod[2] = get_service_classes(hdev);
811
Marcel Holtmann6acd7db2013-10-15 06:33:53 -0700812 if (test_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags))
813 cod[1] |= 0x20;
814
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200815 if (memcmp(cod, hdev->dev_class, 3) == 0)
Johan Hedberg890ea892013-03-15 17:06:52 -0500816 return;
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200817
Johan Hedberg890ea892013-03-15 17:06:52 -0500818 hci_req_add(req, HCI_OP_WRITE_CLASS_OF_DEV, sizeof(cod), cod);
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200819}
820
Johan Hedberga4858cb2014-02-25 19:56:31 +0200821static bool get_connectable(struct hci_dev *hdev)
Johan Hedberg199a2fb2014-02-22 19:06:33 +0200822{
823 struct pending_cmd *cmd;
Johan Hedberg199a2fb2014-02-22 19:06:33 +0200824
825 /* If there's a pending mgmt command the flag will not yet have
826 * it's final value, so check for this first.
827 */
828 cmd = mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, hdev);
829 if (cmd) {
830 struct mgmt_mode *cp = cmd->param;
Johan Hedberga4858cb2014-02-25 19:56:31 +0200831 return cp->val;
Johan Hedberg199a2fb2014-02-22 19:06:33 +0200832 }
833
Johan Hedberga4858cb2014-02-25 19:56:31 +0200834 return test_bit(HCI_CONNECTABLE, &hdev->dev_flags);
Johan Hedberg199a2fb2014-02-22 19:06:33 +0200835}
836
837static void enable_advertising(struct hci_request *req)
838{
839 struct hci_dev *hdev = req->hdev;
840 struct hci_cp_le_set_adv_param cp;
Johan Hedberg8f2a0602014-02-23 19:42:23 +0200841 u8 own_addr_type, enable = 0x01;
Johan Hedberga4858cb2014-02-25 19:56:31 +0200842 bool connectable;
Johan Hedberg199a2fb2014-02-22 19:06:33 +0200843
Johan Hedberg8d972502014-02-28 12:54:14 +0200844 /* Clear the HCI_ADVERTISING bit temporarily so that the
845 * hci_update_random_address knows that it's safe to go ahead
846 * and write a new random address. The flag will be set back on
847 * as soon as the SET_ADV_ENABLE HCI command completes.
848 */
849 clear_bit(HCI_ADVERTISING, &hdev->dev_flags);
850
Johan Hedberga4858cb2014-02-25 19:56:31 +0200851 connectable = get_connectable(hdev);
Johan Hedberg8f2a0602014-02-23 19:42:23 +0200852
Johan Hedberga4858cb2014-02-25 19:56:31 +0200853 /* Set require_privacy to true only when non-connectable
854 * advertising is used. In that case it is fine to use a
855 * non-resolvable private address.
856 */
857 if (hci_update_random_address(req, !connectable, &own_addr_type) < 0)
Johan Hedberg8f2a0602014-02-23 19:42:23 +0200858 return;
859
Marcel Holtmann41c90c12014-02-23 20:25:55 -0800860 memset(&cp, 0, sizeof(cp));
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700861 cp.min_interval = cpu_to_le16(0x0800);
862 cp.max_interval = cpu_to_le16(0x0800);
Johan Hedberga4858cb2014-02-25 19:56:31 +0200863 cp.type = connectable ? LE_ADV_IND : LE_ADV_NONCONN_IND;
Johan Hedberg8f2a0602014-02-23 19:42:23 +0200864 cp.own_address_type = own_addr_type;
Johan Hedberg199a2fb2014-02-22 19:06:33 +0200865 cp.channel_map = hdev->le_adv_channel_map;
866
867 hci_req_add(req, HCI_OP_LE_SET_ADV_PARAM, sizeof(cp), &cp);
868
869 hci_req_add(req, HCI_OP_LE_SET_ADV_ENABLE, sizeof(enable), &enable);
870}
871
872static void disable_advertising(struct hci_request *req)
873{
874 u8 enable = 0x00;
875
876 hci_req_add(req, HCI_OP_LE_SET_ADV_ENABLE, sizeof(enable), &enable);
877}
878
Johan Hedberg7d785252011-12-15 00:47:39 +0200879static void service_cache_off(struct work_struct *work)
880{
881 struct hci_dev *hdev = container_of(work, struct hci_dev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300882 service_cache.work);
Johan Hedberg890ea892013-03-15 17:06:52 -0500883 struct hci_request req;
Johan Hedberg7d785252011-12-15 00:47:39 +0200884
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200885 if (!test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags))
Johan Hedberg7d785252011-12-15 00:47:39 +0200886 return;
887
Johan Hedberg890ea892013-03-15 17:06:52 -0500888 hci_req_init(&req, hdev);
889
Johan Hedberg7d785252011-12-15 00:47:39 +0200890 hci_dev_lock(hdev);
891
Johan Hedberg890ea892013-03-15 17:06:52 -0500892 update_eir(&req);
893 update_class(&req);
Johan Hedberg7d785252011-12-15 00:47:39 +0200894
895 hci_dev_unlock(hdev);
Johan Hedberg890ea892013-03-15 17:06:52 -0500896
897 hci_req_run(&req, NULL);
Johan Hedberg7d785252011-12-15 00:47:39 +0200898}
899
Johan Hedbergd6bfd592014-02-23 19:42:20 +0200900static void rpa_expired(struct work_struct *work)
901{
902 struct hci_dev *hdev = container_of(work, struct hci_dev,
903 rpa_expired.work);
904 struct hci_request req;
905
906 BT_DBG("");
907
908 set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags);
909
910 if (!test_bit(HCI_ADVERTISING, &hdev->dev_flags) ||
911 hci_conn_num(hdev, LE_LINK) > 0)
912 return;
913
914 /* The generation of a new RPA and programming it into the
915 * controller happens in the enable_advertising() function.
916 */
917
918 hci_req_init(&req, hdev);
919
920 disable_advertising(&req);
921 enable_advertising(&req);
922
923 hci_req_run(&req, NULL);
924}
925
Johan Hedberg6a919082012-02-28 06:17:26 +0200926static void mgmt_init_hdev(struct sock *sk, struct hci_dev *hdev)
Johan Hedberg7d785252011-12-15 00:47:39 +0200927{
Johan Hedberg4f87da82012-03-02 19:55:56 +0200928 if (test_and_set_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg6a919082012-02-28 06:17:26 +0200929 return;
930
Johan Hedberg4f87da82012-03-02 19:55:56 +0200931 INIT_DELAYED_WORK(&hdev->service_cache, service_cache_off);
Johan Hedbergd6bfd592014-02-23 19:42:20 +0200932 INIT_DELAYED_WORK(&hdev->rpa_expired, rpa_expired);
Johan Hedberg7d785252011-12-15 00:47:39 +0200933
Johan Hedberg4f87da82012-03-02 19:55:56 +0200934 /* Non-mgmt controlled devices get this bit set
935 * implicitly so that pairing works for them, however
936 * for mgmt we require user-space to explicitly enable
937 * it
938 */
939 clear_bit(HCI_PAIRABLE, &hdev->dev_flags);
Johan Hedberg7d785252011-12-15 00:47:39 +0200940}
941
Johan Hedberg0f4e68c2012-02-28 17:18:30 +0200942static int read_controller_info(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300943 void *data, u16 data_len)
Johan Hedberg03811012010-12-08 00:21:06 +0200944{
945 struct mgmt_rp_read_info rp;
Johan Hedberg03811012010-12-08 00:21:06 +0200946
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200947 BT_DBG("sock %p %s", sk, hdev->name);
Johan Hedberg03811012010-12-08 00:21:06 +0200948
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300949 hci_dev_lock(hdev);
Johan Hedberg03811012010-12-08 00:21:06 +0200950
Johan Hedberg03811012010-12-08 00:21:06 +0200951 memset(&rp, 0, sizeof(rp));
952
Johan Hedberg03811012010-12-08 00:21:06 +0200953 bacpy(&rp.bdaddr, &hdev->bdaddr);
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200954
955 rp.version = hdev->hci_ver;
Marcel Holtmanneb55ef02012-03-14 18:08:46 +0200956 rp.manufacturer = cpu_to_le16(hdev->manufacturer);
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200957
958 rp.supported_settings = cpu_to_le32(get_supported_settings(hdev));
959 rp.current_settings = cpu_to_le32(get_current_settings(hdev));
960
961 memcpy(rp.dev_class, hdev->dev_class, 3);
Johan Hedberg03811012010-12-08 00:21:06 +0200962
963 memcpy(rp.name, hdev->dev_name, sizeof(hdev->dev_name));
Johan Hedberg27fcc362012-02-22 21:46:22 +0200964 memcpy(rp.short_name, hdev->short_name, sizeof(hdev->short_name));
Johan Hedberg03811012010-12-08 00:21:06 +0200965
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300966 hci_dev_unlock(hdev);
Johan Hedberg03811012010-12-08 00:21:06 +0200967
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200968 return cmd_complete(sk, hdev->id, MGMT_OP_READ_INFO, 0, &rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300969 sizeof(rp));
Johan Hedberg03811012010-12-08 00:21:06 +0200970}
971
972static void mgmt_pending_free(struct pending_cmd *cmd)
973{
974 sock_put(cmd->sk);
975 kfree(cmd->param);
976 kfree(cmd);
977}
978
979static struct pending_cmd *mgmt_pending_add(struct sock *sk, u16 opcode,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300980 struct hci_dev *hdev, void *data,
981 u16 len)
Johan Hedberg03811012010-12-08 00:21:06 +0200982{
983 struct pending_cmd *cmd;
984
Andre Guedes12b94562012-06-07 19:05:45 -0300985 cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
Johan Hedberg03811012010-12-08 00:21:06 +0200986 if (!cmd)
987 return NULL;
988
989 cmd->opcode = opcode;
990 cmd->index = hdev->id;
991
Andre Guedes12b94562012-06-07 19:05:45 -0300992 cmd->param = kmalloc(len, GFP_KERNEL);
Johan Hedberg03811012010-12-08 00:21:06 +0200993 if (!cmd->param) {
994 kfree(cmd);
995 return NULL;
996 }
997
998 if (data)
999 memcpy(cmd->param, data, len);
1000
1001 cmd->sk = sk;
1002 sock_hold(sk);
1003
1004 list_add(&cmd->list, &hdev->mgmt_pending);
1005
1006 return cmd;
1007}
1008
1009static void mgmt_pending_foreach(u16 opcode, struct hci_dev *hdev,
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03001010 void (*cb)(struct pending_cmd *cmd,
1011 void *data),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001012 void *data)
Johan Hedberg03811012010-12-08 00:21:06 +02001013{
Andre Guedesa3d09352013-02-01 11:21:30 -03001014 struct pending_cmd *cmd, *tmp;
Johan Hedberg03811012010-12-08 00:21:06 +02001015
Andre Guedesa3d09352013-02-01 11:21:30 -03001016 list_for_each_entry_safe(cmd, tmp, &hdev->mgmt_pending, list) {
Johan Hedberg03811012010-12-08 00:21:06 +02001017 if (opcode > 0 && cmd->opcode != opcode)
1018 continue;
1019
1020 cb(cmd, data);
1021 }
1022}
1023
Johan Hedberg03811012010-12-08 00:21:06 +02001024static void mgmt_pending_remove(struct pending_cmd *cmd)
1025{
1026 list_del(&cmd->list);
1027 mgmt_pending_free(cmd);
1028}
1029
Johan Hedberg69ab39e2011-12-15 00:47:35 +02001030static int send_settings_rsp(struct sock *sk, u16 opcode, struct hci_dev *hdev)
Johan Hedberg86805702011-11-11 16:18:52 +02001031{
Johan Hedberg69ab39e2011-12-15 00:47:35 +02001032 __le32 settings = cpu_to_le32(get_current_settings(hdev));
Johan Hedberg86805702011-11-11 16:18:52 +02001033
Johan Hedbergaee9b2182012-02-18 15:07:59 +02001034 return cmd_complete(sk, hdev->id, opcode, 0, &settings,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001035 sizeof(settings));
Johan Hedberg86805702011-11-11 16:18:52 +02001036}
1037
Johan Hedberg8b064a32014-02-24 14:52:22 +02001038static void clean_up_hci_complete(struct hci_dev *hdev, u8 status)
1039{
1040 BT_DBG("%s status 0x%02x", hdev->name, status);
1041
Johan Hedberga3172b72014-02-28 09:33:44 +02001042 if (hci_conn_count(hdev) == 0) {
1043 cancel_delayed_work(&hdev->power_off);
Johan Hedberg8b064a32014-02-24 14:52:22 +02001044 queue_work(hdev->req_workqueue, &hdev->power_off.work);
Johan Hedberga3172b72014-02-28 09:33:44 +02001045 }
Johan Hedberg8b064a32014-02-24 14:52:22 +02001046}
1047
1048static int clean_up_hci_state(struct hci_dev *hdev)
1049{
1050 struct hci_request req;
1051 struct hci_conn *conn;
1052
1053 hci_req_init(&req, hdev);
1054
1055 if (test_bit(HCI_ISCAN, &hdev->flags) ||
1056 test_bit(HCI_PSCAN, &hdev->flags)) {
1057 u8 scan = 0x00;
1058 hci_req_add(&req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
1059 }
1060
1061 if (test_bit(HCI_ADVERTISING, &hdev->dev_flags))
1062 disable_advertising(&req);
1063
1064 if (test_bit(HCI_LE_SCAN, &hdev->dev_flags)) {
Andre Guedesb1efcc22014-02-26 20:21:40 -03001065 hci_req_add_le_scan_disable(&req);
Johan Hedberg8b064a32014-02-24 14:52:22 +02001066 }
1067
1068 list_for_each_entry(conn, &hdev->conn_hash.list, list) {
1069 struct hci_cp_disconnect dc;
Johan Hedbergc9910d02014-02-27 14:35:12 +02001070 struct hci_cp_reject_conn_req rej;
Johan Hedberg8b064a32014-02-24 14:52:22 +02001071
Johan Hedbergc9910d02014-02-27 14:35:12 +02001072 switch (conn->state) {
1073 case BT_CONNECTED:
1074 case BT_CONFIG:
1075 dc.handle = cpu_to_le16(conn->handle);
1076 dc.reason = 0x15; /* Terminated due to Power Off */
1077 hci_req_add(&req, HCI_OP_DISCONNECT, sizeof(dc), &dc);
1078 break;
1079 case BT_CONNECT:
1080 if (conn->type == LE_LINK)
1081 hci_req_add(&req, HCI_OP_LE_CREATE_CONN_CANCEL,
1082 0, NULL);
1083 else if (conn->type == ACL_LINK)
1084 hci_req_add(&req, HCI_OP_CREATE_CONN_CANCEL,
1085 6, &conn->dst);
1086 break;
1087 case BT_CONNECT2:
1088 bacpy(&rej.bdaddr, &conn->dst);
1089 rej.reason = 0x15; /* Terminated due to Power Off */
1090 if (conn->type == ACL_LINK)
1091 hci_req_add(&req, HCI_OP_REJECT_CONN_REQ,
1092 sizeof(rej), &rej);
1093 else if (conn->type == SCO_LINK)
1094 hci_req_add(&req, HCI_OP_REJECT_SYNC_CONN_REQ,
1095 sizeof(rej), &rej);
1096 break;
1097 }
Johan Hedberg8b064a32014-02-24 14:52:22 +02001098 }
1099
1100 return hci_req_run(&req, clean_up_hci_complete);
1101}
1102
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001103static int set_powered(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001104 u16 len)
Johan Hedberg03811012010-12-08 00:21:06 +02001105{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001106 struct mgmt_mode *cp = data;
Johan Hedberg03811012010-12-08 00:21:06 +02001107 struct pending_cmd *cmd;
Johan Hedberg4b34ee782012-02-21 14:13:02 +02001108 int err;
Johan Hedberg03811012010-12-08 00:21:06 +02001109
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001110 BT_DBG("request for %s", hdev->name);
Johan Hedberg03811012010-12-08 00:21:06 +02001111
Johan Hedberga7e80f22013-01-09 16:05:19 +02001112 if (cp->val != 0x00 && cp->val != 0x01)
1113 return cmd_status(sk, hdev->id, MGMT_OP_SET_POWERED,
1114 MGMT_STATUS_INVALID_PARAMS);
1115
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001116 hci_dev_lock(hdev);
Johan Hedberg03811012010-12-08 00:21:06 +02001117
Johan Hedberg87b95ba2013-09-25 13:26:06 +03001118 if (mgmt_pending_find(MGMT_OP_SET_POWERED, hdev)) {
1119 err = cmd_status(sk, hdev->id, MGMT_OP_SET_POWERED,
1120 MGMT_STATUS_BUSY);
1121 goto failed;
1122 }
1123
Marcel Holtmannf0d4b782012-02-21 12:14:25 +01001124 if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) {
1125 cancel_delayed_work(&hdev->power_off);
1126
1127 if (cp->val) {
Johan Hedberga1d70452013-01-09 15:29:40 +02001128 mgmt_pending_add(sk, MGMT_OP_SET_POWERED, hdev,
1129 data, len);
1130 err = mgmt_powered(hdev, 1);
Marcel Holtmannf0d4b782012-02-21 12:14:25 +01001131 goto failed;
1132 }
1133 }
1134
Johan Hedberg4b34ee782012-02-21 14:13:02 +02001135 if (!!cp->val == hdev_is_powered(hdev)) {
Johan Hedberg69ab39e2011-12-15 00:47:35 +02001136 err = send_settings_rsp(sk, MGMT_OP_SET_POWERED, hdev);
Johan Hedberg03811012010-12-08 00:21:06 +02001137 goto failed;
1138 }
1139
Johan Hedberg03811012010-12-08 00:21:06 +02001140 cmd = mgmt_pending_add(sk, MGMT_OP_SET_POWERED, hdev, data, len);
1141 if (!cmd) {
1142 err = -ENOMEM;
1143 goto failed;
1144 }
1145
Johan Hedberg8b064a32014-02-24 14:52:22 +02001146 if (cp->val) {
Johan Hedberg19202572013-01-14 22:33:51 +02001147 queue_work(hdev->req_workqueue, &hdev->power_on);
Johan Hedberg8b064a32014-02-24 14:52:22 +02001148 err = 0;
1149 } else {
1150 /* Disconnect connections, stop scans, etc */
1151 err = clean_up_hci_state(hdev);
Johan Hedberga3172b72014-02-28 09:33:44 +02001152 if (!err)
1153 queue_delayed_work(hdev->req_workqueue, &hdev->power_off,
1154 HCI_POWER_OFF_TIMEOUT);
Johan Hedberg03811012010-12-08 00:21:06 +02001155
Johan Hedberg8b064a32014-02-24 14:52:22 +02001156 /* ENODATA means there were no HCI commands queued */
1157 if (err == -ENODATA) {
Johan Hedberga3172b72014-02-28 09:33:44 +02001158 cancel_delayed_work(&hdev->power_off);
Johan Hedberg8b064a32014-02-24 14:52:22 +02001159 queue_work(hdev->req_workqueue, &hdev->power_off.work);
1160 err = 0;
1161 }
1162 }
Johan Hedberg03811012010-12-08 00:21:06 +02001163
1164failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001165 hci_dev_unlock(hdev);
Johan Hedberg03811012010-12-08 00:21:06 +02001166 return err;
1167}
1168
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001169static int mgmt_event(u16 event, struct hci_dev *hdev, void *data, u16 data_len,
1170 struct sock *skip_sk)
Johan Hedbergbeadb2b2012-02-21 16:55:31 +02001171{
1172 struct sk_buff *skb;
1173 struct mgmt_hdr *hdr;
1174
Andre Guedes790eff42012-06-07 19:05:46 -03001175 skb = alloc_skb(sizeof(*hdr) + data_len, GFP_KERNEL);
Johan Hedbergbeadb2b2012-02-21 16:55:31 +02001176 if (!skb)
1177 return -ENOMEM;
1178
1179 hdr = (void *) skb_put(skb, sizeof(*hdr));
1180 hdr->opcode = cpu_to_le16(event);
1181 if (hdev)
1182 hdr->index = cpu_to_le16(hdev->id);
1183 else
Joe Perchesdcf4adb2014-03-12 10:52:35 -07001184 hdr->index = cpu_to_le16(MGMT_INDEX_NONE);
Johan Hedbergbeadb2b2012-02-21 16:55:31 +02001185 hdr->len = cpu_to_le16(data_len);
1186
1187 if (data)
1188 memcpy(skb_put(skb, data_len), data, data_len);
1189
Marcel Holtmann97e0bde2012-02-22 13:49:28 +01001190 /* Time stamp */
1191 __net_timestamp(skb);
1192
Johan Hedbergbeadb2b2012-02-21 16:55:31 +02001193 hci_send_to_control(skb, skip_sk);
1194 kfree_skb(skb);
1195
1196 return 0;
1197}
1198
1199static int new_settings(struct hci_dev *hdev, struct sock *skip)
1200{
1201 __le32 ev;
1202
1203 ev = cpu_to_le32(get_current_settings(hdev));
1204
1205 return mgmt_event(MGMT_EV_NEW_SETTINGS, hdev, &ev, sizeof(ev), skip);
1206}
1207
Johan Hedbergbd99abd2013-09-25 13:26:07 +03001208struct cmd_lookup {
1209 struct sock *sk;
1210 struct hci_dev *hdev;
1211 u8 mgmt_status;
1212};
1213
1214static void settings_rsp(struct pending_cmd *cmd, void *data)
1215{
1216 struct cmd_lookup *match = data;
1217
1218 send_settings_rsp(cmd->sk, cmd->opcode, match->hdev);
1219
1220 list_del(&cmd->list);
1221
1222 if (match->sk == NULL) {
1223 match->sk = cmd->sk;
1224 sock_hold(match->sk);
1225 }
1226
1227 mgmt_pending_free(cmd);
1228}
1229
1230static void cmd_status_rsp(struct pending_cmd *cmd, void *data)
1231{
1232 u8 *status = data;
1233
1234 cmd_status(cmd->sk, cmd->index, cmd->opcode, *status);
1235 mgmt_pending_remove(cmd);
1236}
1237
Johan Hedberge6fe7982013-10-02 15:45:22 +03001238static u8 mgmt_bredr_support(struct hci_dev *hdev)
1239{
1240 if (!lmp_bredr_capable(hdev))
1241 return MGMT_STATUS_NOT_SUPPORTED;
1242 else if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags))
1243 return MGMT_STATUS_REJECTED;
1244 else
1245 return MGMT_STATUS_SUCCESS;
1246}
1247
1248static u8 mgmt_le_support(struct hci_dev *hdev)
1249{
1250 if (!lmp_le_capable(hdev))
1251 return MGMT_STATUS_NOT_SUPPORTED;
1252 else if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags))
1253 return MGMT_STATUS_REJECTED;
1254 else
1255 return MGMT_STATUS_SUCCESS;
1256}
1257
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03001258static void set_discoverable_complete(struct hci_dev *hdev, u8 status)
1259{
1260 struct pending_cmd *cmd;
1261 struct mgmt_mode *cp;
Marcel Holtmann970ba522013-10-15 06:33:57 -07001262 struct hci_request req;
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03001263 bool changed;
1264
1265 BT_DBG("status 0x%02x", status);
1266
1267 hci_dev_lock(hdev);
1268
1269 cmd = mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, hdev);
1270 if (!cmd)
1271 goto unlock;
1272
1273 if (status) {
1274 u8 mgmt_err = mgmt_status(status);
1275 cmd_status(cmd->sk, cmd->index, cmd->opcode, mgmt_err);
Marcel Holtmann310a3d42013-10-15 09:13:39 -07001276 clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags);
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03001277 goto remove_cmd;
1278 }
1279
1280 cp = cmd->param;
Marcel Holtmannd4462a02013-10-15 08:11:02 -07001281 if (cp->val) {
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03001282 changed = !test_and_set_bit(HCI_DISCOVERABLE,
1283 &hdev->dev_flags);
Marcel Holtmannd4462a02013-10-15 08:11:02 -07001284
1285 if (hdev->discov_timeout > 0) {
1286 int to = msecs_to_jiffies(hdev->discov_timeout * 1000);
1287 queue_delayed_work(hdev->workqueue, &hdev->discov_off,
1288 to);
1289 }
1290 } else {
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03001291 changed = test_and_clear_bit(HCI_DISCOVERABLE,
1292 &hdev->dev_flags);
Marcel Holtmannd4462a02013-10-15 08:11:02 -07001293 }
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03001294
1295 send_settings_rsp(cmd->sk, MGMT_OP_SET_DISCOVERABLE, hdev);
1296
1297 if (changed)
1298 new_settings(hdev, cmd->sk);
1299
Marcel Holtmann970ba522013-10-15 06:33:57 -07001300 /* When the discoverable mode gets changed, make sure
1301 * that class of device has the limited discoverable
1302 * bit correctly set.
1303 */
1304 hci_req_init(&req, hdev);
1305 update_class(&req);
1306 hci_req_run(&req, NULL);
1307
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03001308remove_cmd:
1309 mgmt_pending_remove(cmd);
1310
1311unlock:
1312 hci_dev_unlock(hdev);
1313}
1314
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001315static int set_discoverable(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001316 u16 len)
Johan Hedberg03811012010-12-08 00:21:06 +02001317{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001318 struct mgmt_cp_set_discoverable *cp = data;
Johan Hedberg03811012010-12-08 00:21:06 +02001319 struct pending_cmd *cmd;
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03001320 struct hci_request req;
Johan Hedberg5e5282b2012-02-21 16:01:30 +02001321 u16 timeout;
Johan Hedberg9a43e252013-10-20 19:00:07 +03001322 u8 scan;
Johan Hedberg03811012010-12-08 00:21:06 +02001323 int err;
1324
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001325 BT_DBG("request for %s", hdev->name);
Johan Hedberg03811012010-12-08 00:21:06 +02001326
Johan Hedberg9a43e252013-10-20 19:00:07 +03001327 if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags) &&
1328 !test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags))
Johan Hedberg33c525c2012-10-24 21:11:58 +03001329 return cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
Johan Hedberg9a43e252013-10-20 19:00:07 +03001330 MGMT_STATUS_REJECTED);
Johan Hedberg33c525c2012-10-24 21:11:58 +03001331
Marcel Holtmann310a3d42013-10-15 09:13:39 -07001332 if (cp->val != 0x00 && cp->val != 0x01 && cp->val != 0x02)
Johan Hedberga7e80f22013-01-09 16:05:19 +02001333 return cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
1334 MGMT_STATUS_INVALID_PARAMS);
1335
Marcel Holtmann1f350c82012-03-12 20:31:08 -07001336 timeout = __le16_to_cpu(cp->timeout);
Marcel Holtmann310a3d42013-10-15 09:13:39 -07001337
1338 /* Disabling discoverable requires that no timeout is set,
1339 * and enabling limited discoverable requires a timeout.
1340 */
1341 if ((cp->val == 0x00 && timeout > 0) ||
1342 (cp->val == 0x02 && timeout == 0))
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001343 return cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001344 MGMT_STATUS_INVALID_PARAMS);
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001345
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001346 hci_dev_lock(hdev);
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001347
Johan Hedberg5e5282b2012-02-21 16:01:30 +02001348 if (!hdev_is_powered(hdev) && timeout > 0) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001349 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001350 MGMT_STATUS_NOT_POWERED);
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001351 goto failed;
1352 }
1353
1354 if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) ||
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001355 mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001356 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001357 MGMT_STATUS_BUSY);
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001358 goto failed;
1359 }
1360
Johan Hedberg5e5282b2012-02-21 16:01:30 +02001361 if (!test_bit(HCI_CONNECTABLE, &hdev->dev_flags)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001362 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001363 MGMT_STATUS_REJECTED);
Johan Hedberg5e5282b2012-02-21 16:01:30 +02001364 goto failed;
1365 }
1366
1367 if (!hdev_is_powered(hdev)) {
Johan Hedberg0224d2f2012-02-21 19:40:05 +02001368 bool changed = false;
1369
Marcel Holtmann310a3d42013-10-15 09:13:39 -07001370 /* Setting limited discoverable when powered off is
1371 * not a valid operation since it requires a timeout
1372 * and so no need to check HCI_LIMITED_DISCOVERABLE.
1373 */
Johan Hedberg0224d2f2012-02-21 19:40:05 +02001374 if (!!cp->val != test_bit(HCI_DISCOVERABLE, &hdev->dev_flags)) {
1375 change_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
1376 changed = true;
1377 }
1378
Johan Hedberg5e5282b2012-02-21 16:01:30 +02001379 err = send_settings_rsp(sk, MGMT_OP_SET_DISCOVERABLE, hdev);
Johan Hedberg0224d2f2012-02-21 19:40:05 +02001380 if (err < 0)
1381 goto failed;
1382
1383 if (changed)
1384 err = new_settings(hdev, sk);
1385
Johan Hedberg5e5282b2012-02-21 16:01:30 +02001386 goto failed;
1387 }
1388
Marcel Holtmann310a3d42013-10-15 09:13:39 -07001389 /* If the current mode is the same, then just update the timeout
1390 * value with the new value. And if only the timeout gets updated,
1391 * then no need for any HCI transactions.
1392 */
1393 if (!!cp->val == test_bit(HCI_DISCOVERABLE, &hdev->dev_flags) &&
1394 (cp->val == 0x02) == test_bit(HCI_LIMITED_DISCOVERABLE,
1395 &hdev->dev_flags)) {
Marcel Holtmann36261542013-10-15 08:28:51 -07001396 cancel_delayed_work(&hdev->discov_off);
1397 hdev->discov_timeout = timeout;
Marcel Holtmann955638e2012-02-22 18:21:00 +01001398
Marcel Holtmann36261542013-10-15 08:28:51 -07001399 if (cp->val && hdev->discov_timeout > 0) {
1400 int to = msecs_to_jiffies(hdev->discov_timeout * 1000);
Marcel Holtmann955638e2012-02-22 18:21:00 +01001401 queue_delayed_work(hdev->workqueue, &hdev->discov_off,
Marcel Holtmann36261542013-10-15 08:28:51 -07001402 to);
Marcel Holtmann955638e2012-02-22 18:21:00 +01001403 }
1404
Johan Hedberg69ab39e2011-12-15 00:47:35 +02001405 err = send_settings_rsp(sk, MGMT_OP_SET_DISCOVERABLE, hdev);
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001406 goto failed;
1407 }
1408
1409 cmd = mgmt_pending_add(sk, MGMT_OP_SET_DISCOVERABLE, hdev, data, len);
1410 if (!cmd) {
1411 err = -ENOMEM;
1412 goto failed;
1413 }
1414
Marcel Holtmann310a3d42013-10-15 09:13:39 -07001415 /* Cancel any potential discoverable timeout that might be
1416 * still active and store new timeout value. The arming of
1417 * the timeout happens in the complete handler.
1418 */
1419 cancel_delayed_work(&hdev->discov_off);
1420 hdev->discov_timeout = timeout;
1421
Johan Hedbergb456f872013-10-19 23:38:22 +03001422 /* Limited discoverable mode */
1423 if (cp->val == 0x02)
1424 set_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags);
1425 else
1426 clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags);
1427
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03001428 hci_req_init(&req, hdev);
1429
Johan Hedberg9a43e252013-10-20 19:00:07 +03001430 /* The procedure for LE-only controllers is much simpler - just
1431 * update the advertising data.
1432 */
1433 if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags))
1434 goto update_ad;
1435
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001436 scan = SCAN_PAGE;
1437
Marcel Holtmann310a3d42013-10-15 09:13:39 -07001438 if (cp->val) {
1439 struct hci_cp_write_current_iac_lap hci_cp;
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001440
Marcel Holtmann310a3d42013-10-15 09:13:39 -07001441 if (cp->val == 0x02) {
1442 /* Limited discoverable mode */
Marcel Holtmann33337dc2013-10-23 08:28:01 -07001443 hci_cp.num_iac = min_t(u8, hdev->num_iac, 2);
Marcel Holtmann310a3d42013-10-15 09:13:39 -07001444 hci_cp.iac_lap[0] = 0x00; /* LIAC */
1445 hci_cp.iac_lap[1] = 0x8b;
1446 hci_cp.iac_lap[2] = 0x9e;
1447 hci_cp.iac_lap[3] = 0x33; /* GIAC */
1448 hci_cp.iac_lap[4] = 0x8b;
1449 hci_cp.iac_lap[5] = 0x9e;
1450 } else {
1451 /* General discoverable mode */
Marcel Holtmann310a3d42013-10-15 09:13:39 -07001452 hci_cp.num_iac = 1;
1453 hci_cp.iac_lap[0] = 0x33; /* GIAC */
1454 hci_cp.iac_lap[1] = 0x8b;
1455 hci_cp.iac_lap[2] = 0x9e;
1456 }
1457
1458 hci_req_add(&req, HCI_OP_WRITE_CURRENT_IAC_LAP,
1459 (hci_cp.num_iac * 3) + 1, &hci_cp);
1460
1461 scan |= SCAN_INQUIRY;
1462 } else {
1463 clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags);
1464 }
1465
1466 hci_req_add(&req, HCI_OP_WRITE_SCAN_ENABLE, sizeof(scan), &scan);
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03001467
Johan Hedberg9a43e252013-10-20 19:00:07 +03001468update_ad:
1469 update_adv_data(&req);
1470
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03001471 err = hci_req_run(&req, set_discoverable_complete);
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001472 if (err < 0)
1473 mgmt_pending_remove(cmd);
1474
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001475failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001476 hci_dev_unlock(hdev);
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001477 return err;
1478}
1479
Johan Hedberg406d7802013-03-15 17:07:09 -05001480static void write_fast_connectable(struct hci_request *req, bool enable)
1481{
Johan Hedbergbd98b992013-03-15 17:07:13 -05001482 struct hci_dev *hdev = req->hdev;
Johan Hedberg406d7802013-03-15 17:07:09 -05001483 struct hci_cp_write_page_scan_activity acp;
1484 u8 type;
1485
Johan Hedberg547003b2013-10-21 16:51:53 +03001486 if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags))
1487 return;
1488
Johan Hedberg4c01f8b2013-03-15 17:07:14 -05001489 if (hdev->hci_ver < BLUETOOTH_VER_1_2)
1490 return;
1491
Johan Hedberg406d7802013-03-15 17:07:09 -05001492 if (enable) {
1493 type = PAGE_SCAN_TYPE_INTERLACED;
1494
1495 /* 160 msec page scan interval */
Joe Perchesdcf4adb2014-03-12 10:52:35 -07001496 acp.interval = cpu_to_le16(0x0100);
Johan Hedberg406d7802013-03-15 17:07:09 -05001497 } else {
1498 type = PAGE_SCAN_TYPE_STANDARD; /* default */
1499
1500 /* default 1.28 sec page scan */
Joe Perchesdcf4adb2014-03-12 10:52:35 -07001501 acp.interval = cpu_to_le16(0x0800);
Johan Hedberg406d7802013-03-15 17:07:09 -05001502 }
1503
Joe Perchesdcf4adb2014-03-12 10:52:35 -07001504 acp.window = cpu_to_le16(0x0012);
Johan Hedberg406d7802013-03-15 17:07:09 -05001505
Johan Hedbergbd98b992013-03-15 17:07:13 -05001506 if (__cpu_to_le16(hdev->page_scan_interval) != acp.interval ||
1507 __cpu_to_le16(hdev->page_scan_window) != acp.window)
1508 hci_req_add(req, HCI_OP_WRITE_PAGE_SCAN_ACTIVITY,
1509 sizeof(acp), &acp);
1510
1511 if (hdev->page_scan_type != type)
1512 hci_req_add(req, HCI_OP_WRITE_PAGE_SCAN_TYPE, 1, &type);
Johan Hedberg406d7802013-03-15 17:07:09 -05001513}
1514
Johan Hedberg2b76f452013-03-15 17:07:04 -05001515static void set_connectable_complete(struct hci_dev *hdev, u8 status)
1516{
1517 struct pending_cmd *cmd;
Johan Hedbergd7b856f2013-10-14 16:20:04 +03001518 struct mgmt_mode *cp;
1519 bool changed;
Johan Hedberg2b76f452013-03-15 17:07:04 -05001520
1521 BT_DBG("status 0x%02x", status);
1522
1523 hci_dev_lock(hdev);
1524
1525 cmd = mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, hdev);
1526 if (!cmd)
1527 goto unlock;
1528
Johan Hedberg37438c12013-10-14 16:20:05 +03001529 if (status) {
1530 u8 mgmt_err = mgmt_status(status);
1531 cmd_status(cmd->sk, cmd->index, cmd->opcode, mgmt_err);
1532 goto remove_cmd;
1533 }
1534
Johan Hedbergd7b856f2013-10-14 16:20:04 +03001535 cp = cmd->param;
1536 if (cp->val)
1537 changed = !test_and_set_bit(HCI_CONNECTABLE, &hdev->dev_flags);
1538 else
1539 changed = test_and_clear_bit(HCI_CONNECTABLE, &hdev->dev_flags);
1540
Johan Hedberg2b76f452013-03-15 17:07:04 -05001541 send_settings_rsp(cmd->sk, MGMT_OP_SET_CONNECTABLE, hdev);
1542
Johan Hedbergd7b856f2013-10-14 16:20:04 +03001543 if (changed)
1544 new_settings(hdev, cmd->sk);
1545
Johan Hedberg37438c12013-10-14 16:20:05 +03001546remove_cmd:
Johan Hedberg2b76f452013-03-15 17:07:04 -05001547 mgmt_pending_remove(cmd);
1548
1549unlock:
1550 hci_dev_unlock(hdev);
1551}
1552
Johan Hedberge8ba3a12013-10-19 23:38:18 +03001553static int set_connectable_update_settings(struct hci_dev *hdev,
1554 struct sock *sk, u8 val)
1555{
1556 bool changed = false;
1557 int err;
1558
1559 if (!!val != test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
1560 changed = true;
1561
1562 if (val) {
1563 set_bit(HCI_CONNECTABLE, &hdev->dev_flags);
1564 } else {
1565 clear_bit(HCI_CONNECTABLE, &hdev->dev_flags);
1566 clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
1567 }
1568
1569 err = send_settings_rsp(sk, MGMT_OP_SET_CONNECTABLE, hdev);
1570 if (err < 0)
1571 return err;
1572
1573 if (changed)
1574 return new_settings(hdev, sk);
1575
1576 return 0;
1577}
1578
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001579static int set_connectable(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001580 u16 len)
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001581{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001582 struct mgmt_mode *cp = data;
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001583 struct pending_cmd *cmd;
Johan Hedberg2b76f452013-03-15 17:07:04 -05001584 struct hci_request req;
Johan Hedberg1987fdc2013-10-14 21:15:24 +03001585 u8 scan;
Johan Hedbergf7b64e62010-12-13 21:07:06 +02001586 int err;
Johan Hedberg03811012010-12-08 00:21:06 +02001587
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001588 BT_DBG("request for %s", hdev->name);
Johan Hedberge41d8b42010-12-13 21:07:03 +02001589
Johan Hedberg1987fdc2013-10-14 21:15:24 +03001590 if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags) &&
1591 !test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags))
Johan Hedberg33c525c2012-10-24 21:11:58 +03001592 return cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE,
Johan Hedberg1987fdc2013-10-14 21:15:24 +03001593 MGMT_STATUS_REJECTED);
Johan Hedberg33c525c2012-10-24 21:11:58 +03001594
Johan Hedberga7e80f22013-01-09 16:05:19 +02001595 if (cp->val != 0x00 && cp->val != 0x01)
1596 return cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE,
1597 MGMT_STATUS_INVALID_PARAMS);
1598
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001599 hci_dev_lock(hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001600
Johan Hedberg4b34ee782012-02-21 14:13:02 +02001601 if (!hdev_is_powered(hdev)) {
Johan Hedberge8ba3a12013-10-19 23:38:18 +03001602 err = set_connectable_update_settings(hdev, sk, cp->val);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001603 goto failed;
1604 }
1605
1606 if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) ||
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001607 mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001608 err = cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001609 MGMT_STATUS_BUSY);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001610 goto failed;
1611 }
1612
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001613 cmd = mgmt_pending_add(sk, MGMT_OP_SET_CONNECTABLE, hdev, data, len);
1614 if (!cmd) {
1615 err = -ENOMEM;
1616 goto failed;
1617 }
1618
Johan Hedberg2b76f452013-03-15 17:07:04 -05001619 hci_req_init(&req, hdev);
1620
Johan Hedberg9a43e252013-10-20 19:00:07 +03001621 /* If BR/EDR is not enabled and we disable advertising as a
1622 * by-product of disabling connectable, we need to update the
1623 * advertising flags.
1624 */
1625 if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) {
1626 if (!cp->val) {
1627 clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags);
1628 clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
1629 }
1630 update_adv_data(&req);
1631 } else if (cp->val != test_bit(HCI_PSCAN, &hdev->flags)) {
Johan Hedberg9b742462013-10-14 16:20:03 +03001632 if (cp->val) {
1633 scan = SCAN_PAGE;
1634 } else {
1635 scan = 0;
1636
1637 if (test_bit(HCI_ISCAN, &hdev->flags) &&
Marcel Holtmann8d6083f2013-10-14 16:38:45 -07001638 hdev->discov_timeout > 0)
Johan Hedberg9b742462013-10-14 16:20:03 +03001639 cancel_delayed_work(&hdev->discov_off);
1640 }
1641
1642 hci_req_add(&req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
1643 }
Johan Hedberg2b76f452013-03-15 17:07:04 -05001644
Johan Hedberg4c01f8b2013-03-15 17:07:14 -05001645 /* If we're going from non-connectable to connectable or
1646 * vice-versa when fast connectable is enabled ensure that fast
1647 * connectable gets disabled. write_fast_connectable won't do
1648 * anything if the page scan parameters are already what they
1649 * should be.
1650 */
1651 if (cp->val || test_bit(HCI_FAST_CONNECTABLE, &hdev->dev_flags))
Johan Hedberge36a3762013-03-15 17:07:10 -05001652 write_fast_connectable(&req, false);
1653
Johan Hedberg1987fdc2013-10-14 21:15:24 +03001654 if (test_bit(HCI_ADVERTISING, &hdev->dev_flags) &&
1655 hci_conn_num(hdev, LE_LINK) == 0) {
1656 disable_advertising(&req);
1657 enable_advertising(&req);
1658 }
1659
Johan Hedberg2b76f452013-03-15 17:07:04 -05001660 err = hci_req_run(&req, set_connectable_complete);
Johan Hedberg9b742462013-10-14 16:20:03 +03001661 if (err < 0) {
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001662 mgmt_pending_remove(cmd);
Johan Hedberg9b742462013-10-14 16:20:03 +03001663 if (err == -ENODATA)
Johan Hedberga81070b2013-10-19 23:38:19 +03001664 err = set_connectable_update_settings(hdev, sk,
1665 cp->val);
Johan Hedberg9b742462013-10-14 16:20:03 +03001666 goto failed;
1667 }
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001668
1669failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001670 hci_dev_unlock(hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001671 return err;
1672}
1673
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001674static int set_pairable(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001675 u16 len)
Johan Hedberg73f22f62010-12-29 16:00:25 +02001676{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001677 struct mgmt_mode *cp = data;
Marcel Holtmann55594352013-10-06 16:11:57 -07001678 bool changed;
Johan Hedberg73f22f62010-12-29 16:00:25 +02001679 int err;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001680
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001681 BT_DBG("request for %s", hdev->name);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001682
Johan Hedberga7e80f22013-01-09 16:05:19 +02001683 if (cp->val != 0x00 && cp->val != 0x01)
1684 return cmd_status(sk, hdev->id, MGMT_OP_SET_PAIRABLE,
1685 MGMT_STATUS_INVALID_PARAMS);
1686
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001687 hci_dev_lock(hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001688
1689 if (cp->val)
Marcel Holtmann55594352013-10-06 16:11:57 -07001690 changed = !test_and_set_bit(HCI_PAIRABLE, &hdev->dev_flags);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001691 else
Marcel Holtmann55594352013-10-06 16:11:57 -07001692 changed = test_and_clear_bit(HCI_PAIRABLE, &hdev->dev_flags);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001693
Johan Hedberg69ab39e2011-12-15 00:47:35 +02001694 err = send_settings_rsp(sk, MGMT_OP_SET_PAIRABLE, hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001695 if (err < 0)
Marcel Holtmann55594352013-10-06 16:11:57 -07001696 goto unlock;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001697
Marcel Holtmann55594352013-10-06 16:11:57 -07001698 if (changed)
1699 err = new_settings(hdev, sk);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001700
Marcel Holtmann55594352013-10-06 16:11:57 -07001701unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001702 hci_dev_unlock(hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001703 return err;
1704}
Johan Hedberg72a734e2010-12-30 00:38:22 +02001705
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001706static int set_link_security(struct sock *sk, struct hci_dev *hdev, void *data,
1707 u16 len)
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001708{
1709 struct mgmt_mode *cp = data;
1710 struct pending_cmd *cmd;
Johan Hedberge6fe7982013-10-02 15:45:22 +03001711 u8 val, status;
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001712 int err;
1713
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001714 BT_DBG("request for %s", hdev->name);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001715
Johan Hedberge6fe7982013-10-02 15:45:22 +03001716 status = mgmt_bredr_support(hdev);
1717 if (status)
Johan Hedberg33c525c2012-10-24 21:11:58 +03001718 return cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY,
Johan Hedberge6fe7982013-10-02 15:45:22 +03001719 status);
Johan Hedberg33c525c2012-10-24 21:11:58 +03001720
Johan Hedberga7e80f22013-01-09 16:05:19 +02001721 if (cp->val != 0x00 && cp->val != 0x01)
1722 return cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY,
1723 MGMT_STATUS_INVALID_PARAMS);
1724
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001725 hci_dev_lock(hdev);
1726
Johan Hedberg4b34ee782012-02-21 14:13:02 +02001727 if (!hdev_is_powered(hdev)) {
Johan Hedberg47990ea2012-02-22 11:58:37 +02001728 bool changed = false;
1729
1730 if (!!cp->val != test_bit(HCI_LINK_SECURITY,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001731 &hdev->dev_flags)) {
Johan Hedberg47990ea2012-02-22 11:58:37 +02001732 change_bit(HCI_LINK_SECURITY, &hdev->dev_flags);
1733 changed = true;
1734 }
1735
1736 err = send_settings_rsp(sk, MGMT_OP_SET_LINK_SECURITY, hdev);
1737 if (err < 0)
1738 goto failed;
1739
1740 if (changed)
1741 err = new_settings(hdev, sk);
1742
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001743 goto failed;
1744 }
1745
1746 if (mgmt_pending_find(MGMT_OP_SET_LINK_SECURITY, hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001747 err = cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001748 MGMT_STATUS_BUSY);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001749 goto failed;
1750 }
1751
1752 val = !!cp->val;
1753
1754 if (test_bit(HCI_AUTH, &hdev->flags) == val) {
1755 err = send_settings_rsp(sk, MGMT_OP_SET_LINK_SECURITY, hdev);
1756 goto failed;
1757 }
1758
1759 cmd = mgmt_pending_add(sk, MGMT_OP_SET_LINK_SECURITY, hdev, data, len);
1760 if (!cmd) {
1761 err = -ENOMEM;
1762 goto failed;
1763 }
1764
1765 err = hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, sizeof(val), &val);
1766 if (err < 0) {
1767 mgmt_pending_remove(cmd);
1768 goto failed;
1769 }
1770
1771failed:
1772 hci_dev_unlock(hdev);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001773 return err;
1774}
1775
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001776static int set_ssp(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001777{
1778 struct mgmt_mode *cp = data;
1779 struct pending_cmd *cmd;
Marcel Holtmann72ef0c12013-10-10 03:08:10 -07001780 u8 status;
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001781 int err;
1782
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001783 BT_DBG("request for %s", hdev->name);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001784
Marcel Holtmanncdba5282013-10-02 21:31:52 -07001785 status = mgmt_bredr_support(hdev);
1786 if (status)
1787 return cmd_status(sk, hdev->id, MGMT_OP_SET_SSP, status);
1788
Johan Hedberg13ecd8b2013-01-09 15:29:38 +02001789 if (!lmp_ssp_capable(hdev))
1790 return cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
1791 MGMT_STATUS_NOT_SUPPORTED);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001792
Johan Hedberga7e80f22013-01-09 16:05:19 +02001793 if (cp->val != 0x00 && cp->val != 0x01)
1794 return cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
1795 MGMT_STATUS_INVALID_PARAMS);
1796
Johan Hedberg13ecd8b2013-01-09 15:29:38 +02001797 hci_dev_lock(hdev);
Johan Hedberg6c8f12c2012-02-22 16:35:26 +02001798
Johan Hedberg4b34ee782012-02-21 14:13:02 +02001799 if (!hdev_is_powered(hdev)) {
Marcel Holtmann9ecb3e22013-10-10 03:08:11 -07001800 bool changed;
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02001801
Marcel Holtmann9ecb3e22013-10-10 03:08:11 -07001802 if (cp->val) {
1803 changed = !test_and_set_bit(HCI_SSP_ENABLED,
1804 &hdev->dev_flags);
1805 } else {
1806 changed = test_and_clear_bit(HCI_SSP_ENABLED,
1807 &hdev->dev_flags);
1808 if (!changed)
1809 changed = test_and_clear_bit(HCI_HS_ENABLED,
1810 &hdev->dev_flags);
1811 else
1812 clear_bit(HCI_HS_ENABLED, &hdev->dev_flags);
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02001813 }
1814
1815 err = send_settings_rsp(sk, MGMT_OP_SET_SSP, hdev);
1816 if (err < 0)
1817 goto failed;
1818
1819 if (changed)
1820 err = new_settings(hdev, sk);
1821
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001822 goto failed;
1823 }
1824
Marcel Holtmann9ecb3e22013-10-10 03:08:11 -07001825 if (mgmt_pending_find(MGMT_OP_SET_SSP, hdev) ||
1826 mgmt_pending_find(MGMT_OP_SET_HS, hdev)) {
Szymon Jancd97dcb62012-03-16 16:02:56 +01001827 err = cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
1828 MGMT_STATUS_BUSY);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001829 goto failed;
1830 }
1831
Marcel Holtmann72ef0c12013-10-10 03:08:10 -07001832 if (!!cp->val == test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) {
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001833 err = send_settings_rsp(sk, MGMT_OP_SET_SSP, hdev);
1834 goto failed;
1835 }
1836
1837 cmd = mgmt_pending_add(sk, MGMT_OP_SET_SSP, hdev, data, len);
1838 if (!cmd) {
1839 err = -ENOMEM;
1840 goto failed;
1841 }
1842
Marcel Holtmann72ef0c12013-10-10 03:08:10 -07001843 err = hci_send_cmd(hdev, HCI_OP_WRITE_SSP_MODE, 1, &cp->val);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001844 if (err < 0) {
1845 mgmt_pending_remove(cmd);
1846 goto failed;
1847 }
1848
1849failed:
1850 hci_dev_unlock(hdev);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001851 return err;
1852}
1853
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001854static int set_hs(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001855{
1856 struct mgmt_mode *cp = data;
Marcel Holtmannee392692013-10-01 22:59:23 -07001857 bool changed;
Johan Hedberge6fe7982013-10-02 15:45:22 +03001858 u8 status;
Marcel Holtmannee392692013-10-01 22:59:23 -07001859 int err;
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001860
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001861 BT_DBG("request for %s", hdev->name);
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001862
Johan Hedberge6fe7982013-10-02 15:45:22 +03001863 status = mgmt_bredr_support(hdev);
1864 if (status)
1865 return cmd_status(sk, hdev->id, MGMT_OP_SET_HS, status);
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001866
Marcel Holtmann9ecb3e22013-10-10 03:08:11 -07001867 if (!lmp_ssp_capable(hdev))
1868 return cmd_status(sk, hdev->id, MGMT_OP_SET_HS,
1869 MGMT_STATUS_NOT_SUPPORTED);
1870
1871 if (!test_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
1872 return cmd_status(sk, hdev->id, MGMT_OP_SET_HS,
1873 MGMT_STATUS_REJECTED);
1874
Johan Hedberga7e80f22013-01-09 16:05:19 +02001875 if (cp->val != 0x00 && cp->val != 0x01)
1876 return cmd_status(sk, hdev->id, MGMT_OP_SET_HS,
1877 MGMT_STATUS_INVALID_PARAMS);
1878
Marcel Holtmannee392692013-10-01 22:59:23 -07001879 hci_dev_lock(hdev);
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001880
Marcel Holtmanna0cdf9602013-10-02 00:27:02 -07001881 if (cp->val) {
Marcel Holtmannee392692013-10-01 22:59:23 -07001882 changed = !test_and_set_bit(HCI_HS_ENABLED, &hdev->dev_flags);
Marcel Holtmanna0cdf9602013-10-02 00:27:02 -07001883 } else {
1884 if (hdev_is_powered(hdev)) {
1885 err = cmd_status(sk, hdev->id, MGMT_OP_SET_HS,
1886 MGMT_STATUS_REJECTED);
1887 goto unlock;
1888 }
1889
Marcel Holtmannee392692013-10-01 22:59:23 -07001890 changed = test_and_clear_bit(HCI_HS_ENABLED, &hdev->dev_flags);
Marcel Holtmanna0cdf9602013-10-02 00:27:02 -07001891 }
Marcel Holtmannee392692013-10-01 22:59:23 -07001892
1893 err = send_settings_rsp(sk, MGMT_OP_SET_HS, hdev);
1894 if (err < 0)
1895 goto unlock;
1896
1897 if (changed)
1898 err = new_settings(hdev, sk);
1899
1900unlock:
1901 hci_dev_unlock(hdev);
1902 return err;
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001903}
1904
Johan Hedberg416a4ae2013-09-25 13:26:08 +03001905static void le_enable_complete(struct hci_dev *hdev, u8 status)
1906{
1907 struct cmd_lookup match = { NULL, hdev };
1908
1909 if (status) {
1910 u8 mgmt_err = mgmt_status(status);
1911
1912 mgmt_pending_foreach(MGMT_OP_SET_LE, hdev, cmd_status_rsp,
1913 &mgmt_err);
1914 return;
1915 }
1916
1917 mgmt_pending_foreach(MGMT_OP_SET_LE, hdev, settings_rsp, &match);
1918
1919 new_settings(hdev, match.sk);
1920
1921 if (match.sk)
1922 sock_put(match.sk);
Marcel Holtmann441ad2d2013-10-15 06:33:52 -07001923
1924 /* Make sure the controller has a good default for
1925 * advertising data. Restrict the update to when LE
1926 * has actually been enabled. During power on, the
1927 * update in powered_update_hci will take care of it.
1928 */
1929 if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) {
1930 struct hci_request req;
1931
1932 hci_dev_lock(hdev);
1933
1934 hci_req_init(&req, hdev);
Marcel Holtmann5947f4b2013-10-16 00:16:50 -07001935 update_adv_data(&req);
Marcel Holtmannf14d8f62013-10-16 00:16:48 -07001936 update_scan_rsp_data(&req);
Marcel Holtmann441ad2d2013-10-15 06:33:52 -07001937 hci_req_run(&req, NULL);
1938
1939 hci_dev_unlock(hdev);
1940 }
Johan Hedberg416a4ae2013-09-25 13:26:08 +03001941}
1942
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001943static int set_le(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
Johan Hedberg06199cf2012-02-22 16:37:11 +02001944{
1945 struct mgmt_mode *cp = data;
1946 struct hci_cp_write_le_host_supported hci_cp;
1947 struct pending_cmd *cmd;
Johan Hedberg416a4ae2013-09-25 13:26:08 +03001948 struct hci_request req;
Johan Hedberg06199cf2012-02-22 16:37:11 +02001949 int err;
Johan Hedberg0b60eba2012-02-28 00:57:24 +02001950 u8 val, enabled;
Johan Hedberg06199cf2012-02-22 16:37:11 +02001951
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001952 BT_DBG("request for %s", hdev->name);
Johan Hedberg06199cf2012-02-22 16:37:11 +02001953
Johan Hedberg13ecd8b2013-01-09 15:29:38 +02001954 if (!lmp_le_capable(hdev))
1955 return cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
1956 MGMT_STATUS_NOT_SUPPORTED);
Johan Hedberg1de028c2012-02-29 19:55:35 -08001957
Johan Hedberga7e80f22013-01-09 16:05:19 +02001958 if (cp->val != 0x00 && cp->val != 0x01)
1959 return cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
1960 MGMT_STATUS_INVALID_PARAMS);
1961
Johan Hedbergc73eee92013-04-19 18:35:21 +03001962 /* LE-only devices do not allow toggling LE on/off */
Johan Hedberg56f87902013-10-02 13:43:13 +03001963 if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags))
Johan Hedbergc73eee92013-04-19 18:35:21 +03001964 return cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
1965 MGMT_STATUS_REJECTED);
1966
Johan Hedberg13ecd8b2013-01-09 15:29:38 +02001967 hci_dev_lock(hdev);
Johan Hedberg06199cf2012-02-22 16:37:11 +02001968
1969 val = !!cp->val;
Gustavo Padovanffa88e02012-11-23 16:50:51 -02001970 enabled = lmp_host_le_capable(hdev);
Johan Hedberg06199cf2012-02-22 16:37:11 +02001971
Johan Hedberg0b60eba2012-02-28 00:57:24 +02001972 if (!hdev_is_powered(hdev) || val == enabled) {
Johan Hedberg06199cf2012-02-22 16:37:11 +02001973 bool changed = false;
1974
1975 if (val != test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) {
1976 change_bit(HCI_LE_ENABLED, &hdev->dev_flags);
1977 changed = true;
1978 }
1979
Johan Hedbergf3d3444a2013-10-05 12:01:04 +02001980 if (!val && test_bit(HCI_ADVERTISING, &hdev->dev_flags)) {
1981 clear_bit(HCI_ADVERTISING, &hdev->dev_flags);
Johan Hedbergeeca6f82013-09-25 13:26:09 +03001982 changed = true;
1983 }
1984
Johan Hedberg06199cf2012-02-22 16:37:11 +02001985 err = send_settings_rsp(sk, MGMT_OP_SET_LE, hdev);
1986 if (err < 0)
Johan Hedberg1de028c2012-02-29 19:55:35 -08001987 goto unlock;
Johan Hedberg06199cf2012-02-22 16:37:11 +02001988
1989 if (changed)
1990 err = new_settings(hdev, sk);
1991
Johan Hedberg1de028c2012-02-29 19:55:35 -08001992 goto unlock;
Johan Hedberg06199cf2012-02-22 16:37:11 +02001993 }
1994
Johan Hedberg4375f102013-09-25 13:26:10 +03001995 if (mgmt_pending_find(MGMT_OP_SET_LE, hdev) ||
1996 mgmt_pending_find(MGMT_OP_SET_ADVERTISING, hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001997 err = cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001998 MGMT_STATUS_BUSY);
Johan Hedberg1de028c2012-02-29 19:55:35 -08001999 goto unlock;
Johan Hedberg06199cf2012-02-22 16:37:11 +02002000 }
2001
2002 cmd = mgmt_pending_add(sk, MGMT_OP_SET_LE, hdev, data, len);
2003 if (!cmd) {
2004 err = -ENOMEM;
Johan Hedberg1de028c2012-02-29 19:55:35 -08002005 goto unlock;
Johan Hedberg06199cf2012-02-22 16:37:11 +02002006 }
2007
Marcel Holtmann441ad2d2013-10-15 06:33:52 -07002008 hci_req_init(&req, hdev);
2009
Johan Hedberg06199cf2012-02-22 16:37:11 +02002010 memset(&hci_cp, 0, sizeof(hci_cp));
2011
2012 if (val) {
2013 hci_cp.le = val;
Gustavo Padovanffa88e02012-11-23 16:50:51 -02002014 hci_cp.simul = lmp_le_br_capable(hdev);
Marcel Holtmann441ad2d2013-10-15 06:33:52 -07002015 } else {
2016 if (test_bit(HCI_ADVERTISING, &hdev->dev_flags))
2017 disable_advertising(&req);
Johan Hedberg06199cf2012-02-22 16:37:11 +02002018 }
2019
Johan Hedberg416a4ae2013-09-25 13:26:08 +03002020 hci_req_add(&req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(hci_cp),
2021 &hci_cp);
2022
2023 err = hci_req_run(&req, le_enable_complete);
Syam Sidhardhan0c01bc42012-04-12 20:33:21 +05302024 if (err < 0)
Johan Hedberg06199cf2012-02-22 16:37:11 +02002025 mgmt_pending_remove(cmd);
Johan Hedberg06199cf2012-02-22 16:37:11 +02002026
Johan Hedberg1de028c2012-02-29 19:55:35 -08002027unlock:
2028 hci_dev_unlock(hdev);
Johan Hedberg06199cf2012-02-22 16:37:11 +02002029 return err;
2030}
2031
Johan Hedberg0cab9c82013-03-15 17:06:54 -05002032/* This is a helper function to test for pending mgmt commands that can
2033 * cause CoD or EIR HCI commands. We can only allow one such pending
2034 * mgmt command at a time since otherwise we cannot easily track what
2035 * the current values are, will be, and based on that calculate if a new
2036 * HCI command needs to be sent and if yes with what value.
2037 */
2038static bool pending_eir_or_class(struct hci_dev *hdev)
2039{
2040 struct pending_cmd *cmd;
2041
2042 list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
2043 switch (cmd->opcode) {
2044 case MGMT_OP_ADD_UUID:
2045 case MGMT_OP_REMOVE_UUID:
2046 case MGMT_OP_SET_DEV_CLASS:
2047 case MGMT_OP_SET_POWERED:
2048 return true;
2049 }
2050 }
2051
2052 return false;
2053}
2054
Johan Hedberg83be8ec2013-01-27 00:31:29 +02002055static const u8 bluetooth_base_uuid[] = {
2056 0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2057 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2058};
2059
2060static u8 get_uuid_size(const u8 *uuid)
2061{
2062 u32 val;
2063
2064 if (memcmp(uuid, bluetooth_base_uuid, 12))
2065 return 128;
2066
2067 val = get_unaligned_le32(&uuid[12]);
2068 if (val > 0xffff)
2069 return 32;
2070
2071 return 16;
2072}
2073
Johan Hedberg92da6092013-03-15 17:06:55 -05002074static void mgmt_class_complete(struct hci_dev *hdev, u16 mgmt_op, u8 status)
2075{
2076 struct pending_cmd *cmd;
2077
2078 hci_dev_lock(hdev);
2079
2080 cmd = mgmt_pending_find(mgmt_op, hdev);
2081 if (!cmd)
2082 goto unlock;
2083
2084 cmd_complete(cmd->sk, cmd->index, cmd->opcode, mgmt_status(status),
2085 hdev->dev_class, 3);
2086
2087 mgmt_pending_remove(cmd);
2088
2089unlock:
2090 hci_dev_unlock(hdev);
2091}
2092
2093static void add_uuid_complete(struct hci_dev *hdev, u8 status)
2094{
2095 BT_DBG("status 0x%02x", status);
2096
2097 mgmt_class_complete(hdev, MGMT_OP_ADD_UUID, status);
2098}
2099
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002100static int add_uuid(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002101{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002102 struct mgmt_cp_add_uuid *cp = data;
Johan Hedberg90e70452012-02-23 23:09:40 +02002103 struct pending_cmd *cmd;
Johan Hedberg890ea892013-03-15 17:06:52 -05002104 struct hci_request req;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002105 struct bt_uuid *uuid;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002106 int err;
2107
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002108 BT_DBG("request for %s", hdev->name);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002109
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002110 hci_dev_lock(hdev);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002111
Johan Hedberg0cab9c82013-03-15 17:06:54 -05002112 if (pending_eir_or_class(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002113 err = cmd_status(sk, hdev->id, MGMT_OP_ADD_UUID,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002114 MGMT_STATUS_BUSY);
Johan Hedbergc95f0ba2012-02-23 22:54:38 +02002115 goto failed;
2116 }
2117
Andre Guedes92c4c202012-06-07 19:05:44 -03002118 uuid = kmalloc(sizeof(*uuid), GFP_KERNEL);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002119 if (!uuid) {
2120 err = -ENOMEM;
2121 goto failed;
2122 }
2123
2124 memcpy(uuid->uuid, cp->uuid, 16);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02002125 uuid->svc_hint = cp->svc_hint;
Johan Hedberg83be8ec2013-01-27 00:31:29 +02002126 uuid->size = get_uuid_size(cp->uuid);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002127
Johan Hedbergde66aa62013-01-27 00:31:27 +02002128 list_add_tail(&uuid->list, &hdev->uuids);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002129
Johan Hedberg890ea892013-03-15 17:06:52 -05002130 hci_req_init(&req, hdev);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02002131
Johan Hedberg890ea892013-03-15 17:06:52 -05002132 update_class(&req);
2133 update_eir(&req);
2134
Johan Hedberg92da6092013-03-15 17:06:55 -05002135 err = hci_req_run(&req, add_uuid_complete);
2136 if (err < 0) {
2137 if (err != -ENODATA)
2138 goto failed;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +03002139
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002140 err = cmd_complete(sk, hdev->id, MGMT_OP_ADD_UUID, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002141 hdev->dev_class, 3);
Johan Hedberg90e70452012-02-23 23:09:40 +02002142 goto failed;
2143 }
2144
2145 cmd = mgmt_pending_add(sk, MGMT_OP_ADD_UUID, hdev, data, len);
Johan Hedberg890ea892013-03-15 17:06:52 -05002146 if (!cmd) {
Johan Hedberg90e70452012-02-23 23:09:40 +02002147 err = -ENOMEM;
Johan Hedberg890ea892013-03-15 17:06:52 -05002148 goto failed;
2149 }
2150
2151 err = 0;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002152
2153failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002154 hci_dev_unlock(hdev);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002155 return err;
2156}
2157
Johan Hedberg24b78d02012-02-23 23:24:30 +02002158static bool enable_service_cache(struct hci_dev *hdev)
2159{
2160 if (!hdev_is_powered(hdev))
2161 return false;
2162
2163 if (!test_and_set_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) {
Johan Hedberg46818ed2013-01-14 22:33:52 +02002164 queue_delayed_work(hdev->workqueue, &hdev->service_cache,
2165 CACHE_TIMEOUT);
Johan Hedberg24b78d02012-02-23 23:24:30 +02002166 return true;
2167 }
2168
2169 return false;
2170}
2171
Johan Hedberg92da6092013-03-15 17:06:55 -05002172static void remove_uuid_complete(struct hci_dev *hdev, u8 status)
2173{
2174 BT_DBG("status 0x%02x", status);
2175
2176 mgmt_class_complete(hdev, MGMT_OP_REMOVE_UUID, status);
2177}
2178
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002179static int remove_uuid(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002180 u16 len)
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002181{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002182 struct mgmt_cp_remove_uuid *cp = data;
Johan Hedberg90e70452012-02-23 23:09:40 +02002183 struct pending_cmd *cmd;
Johan Hedberg056341c2013-01-27 00:31:30 +02002184 struct bt_uuid *match, *tmp;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002185 u8 bt_uuid_any[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
Johan Hedberg890ea892013-03-15 17:06:52 -05002186 struct hci_request req;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002187 int err, found;
2188
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002189 BT_DBG("request for %s", hdev->name);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002190
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002191 hci_dev_lock(hdev);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002192
Johan Hedberg0cab9c82013-03-15 17:06:54 -05002193 if (pending_eir_or_class(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002194 err = cmd_status(sk, hdev->id, MGMT_OP_REMOVE_UUID,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002195 MGMT_STATUS_BUSY);
Johan Hedbergc95f0ba2012-02-23 22:54:38 +02002196 goto unlock;
2197 }
2198
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002199 if (memcmp(cp->uuid, bt_uuid_any, 16) == 0) {
Johan Hedberg35f74982014-02-18 17:14:32 +02002200 hci_uuids_clear(hdev);
Johan Hedberg4004b6d2012-02-23 21:30:12 +02002201
Johan Hedberg24b78d02012-02-23 23:24:30 +02002202 if (enable_service_cache(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002203 err = cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_UUID,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002204 0, hdev->dev_class, 3);
Johan Hedberg24b78d02012-02-23 23:24:30 +02002205 goto unlock;
2206 }
Johan Hedberg4004b6d2012-02-23 21:30:12 +02002207
Johan Hedberg9246a862012-02-23 21:33:16 +02002208 goto update_class;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002209 }
2210
2211 found = 0;
2212
Johan Hedberg056341c2013-01-27 00:31:30 +02002213 list_for_each_entry_safe(match, tmp, &hdev->uuids, list) {
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002214 if (memcmp(match->uuid, cp->uuid, 16) != 0)
2215 continue;
2216
2217 list_del(&match->list);
Johan Hedberg482049f2012-11-08 10:25:26 +01002218 kfree(match);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002219 found++;
2220 }
2221
2222 if (found == 0) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002223 err = cmd_status(sk, hdev->id, MGMT_OP_REMOVE_UUID,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002224 MGMT_STATUS_INVALID_PARAMS);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002225 goto unlock;
2226 }
2227
Johan Hedberg9246a862012-02-23 21:33:16 +02002228update_class:
Johan Hedberg890ea892013-03-15 17:06:52 -05002229 hci_req_init(&req, hdev);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02002230
Johan Hedberg890ea892013-03-15 17:06:52 -05002231 update_class(&req);
2232 update_eir(&req);
2233
Johan Hedberg92da6092013-03-15 17:06:55 -05002234 err = hci_req_run(&req, remove_uuid_complete);
2235 if (err < 0) {
2236 if (err != -ENODATA)
2237 goto unlock;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +03002238
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002239 err = cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_UUID, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002240 hdev->dev_class, 3);
Johan Hedberg90e70452012-02-23 23:09:40 +02002241 goto unlock;
2242 }
2243
2244 cmd = mgmt_pending_add(sk, MGMT_OP_REMOVE_UUID, hdev, data, len);
Johan Hedberg890ea892013-03-15 17:06:52 -05002245 if (!cmd) {
Johan Hedberg90e70452012-02-23 23:09:40 +02002246 err = -ENOMEM;
Johan Hedberg890ea892013-03-15 17:06:52 -05002247 goto unlock;
2248 }
2249
2250 err = 0;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002251
2252unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002253 hci_dev_unlock(hdev);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02002254 return err;
2255}
2256
Johan Hedberg92da6092013-03-15 17:06:55 -05002257static void set_class_complete(struct hci_dev *hdev, u8 status)
2258{
2259 BT_DBG("status 0x%02x", status);
2260
2261 mgmt_class_complete(hdev, MGMT_OP_SET_DEV_CLASS, status);
2262}
2263
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002264static int set_dev_class(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002265 u16 len)
Johan Hedberg1aff6f02011-01-13 21:56:52 +02002266{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002267 struct mgmt_cp_set_dev_class *cp = data;
Johan Hedberg90e70452012-02-23 23:09:40 +02002268 struct pending_cmd *cmd;
Johan Hedberg890ea892013-03-15 17:06:52 -05002269 struct hci_request req;
Johan Hedberg1aff6f02011-01-13 21:56:52 +02002270 int err;
2271
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002272 BT_DBG("request for %s", hdev->name);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02002273
Marcel Holtmann6203fc92013-10-02 23:37:29 -07002274 if (!lmp_bredr_capable(hdev))
Johan Hedberg13ecd8b2013-01-09 15:29:38 +02002275 return cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS,
2276 MGMT_STATUS_NOT_SUPPORTED);
2277
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002278 hci_dev_lock(hdev);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02002279
Johan Hedberg0cab9c82013-03-15 17:06:54 -05002280 if (pending_eir_or_class(hdev)) {
2281 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS,
2282 MGMT_STATUS_BUSY);
2283 goto unlock;
2284 }
2285
2286 if ((cp->minor & 0x03) != 0 || (cp->major & 0xe0) != 0) {
2287 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS,
2288 MGMT_STATUS_INVALID_PARAMS);
2289 goto unlock;
2290 }
2291
Johan Hedberg1aff6f02011-01-13 21:56:52 +02002292 hdev->major_class = cp->major;
2293 hdev->minor_class = cp->minor;
2294
Johan Hedberg932f5ff2012-02-22 22:11:32 +02002295 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002296 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002297 hdev->dev_class, 3);
Johan Hedberg932f5ff2012-02-22 22:11:32 +02002298 goto unlock;
2299 }
2300
Johan Hedberg890ea892013-03-15 17:06:52 -05002301 hci_req_init(&req, hdev);
2302
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02002303 if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) {
Johan Hedberg7d785252011-12-15 00:47:39 +02002304 hci_dev_unlock(hdev);
2305 cancel_delayed_work_sync(&hdev->service_cache);
2306 hci_dev_lock(hdev);
Johan Hedberg890ea892013-03-15 17:06:52 -05002307 update_eir(&req);
Johan Hedberg7d785252011-12-15 00:47:39 +02002308 }
Johan Hedberg14c0b602011-12-15 00:47:37 +02002309
Johan Hedberg890ea892013-03-15 17:06:52 -05002310 update_class(&req);
2311
Johan Hedberg92da6092013-03-15 17:06:55 -05002312 err = hci_req_run(&req, set_class_complete);
2313 if (err < 0) {
2314 if (err != -ENODATA)
2315 goto unlock;
Johan Hedberg1aff6f02011-01-13 21:56:52 +02002316
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002317 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002318 hdev->dev_class, 3);
Johan Hedberg90e70452012-02-23 23:09:40 +02002319 goto unlock;
2320 }
2321
2322 cmd = mgmt_pending_add(sk, MGMT_OP_SET_DEV_CLASS, hdev, data, len);
Johan Hedberg890ea892013-03-15 17:06:52 -05002323 if (!cmd) {
Johan Hedberg90e70452012-02-23 23:09:40 +02002324 err = -ENOMEM;
Johan Hedberg890ea892013-03-15 17:06:52 -05002325 goto unlock;
2326 }
2327
2328 err = 0;
Johan Hedberg1aff6f02011-01-13 21:56:52 +02002329
Johan Hedbergb5235a62012-02-21 14:32:24 +02002330unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002331 hci_dev_unlock(hdev);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02002332 return err;
2333}
2334
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002335static int load_link_keys(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002336 u16 len)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002337{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002338 struct mgmt_cp_load_link_keys *cp = data;
Szymon Janc4e51eae2011-02-25 19:05:48 +01002339 u16 key_count, expected_len;
Marcel Holtmannb1de97d2014-01-31 11:55:21 -08002340 bool changed;
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03002341 int i;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002342
Marcel Holtmann9060d5c2013-10-02 21:16:07 -07002343 BT_DBG("request for %s", hdev->name);
2344
2345 if (!lmp_bredr_capable(hdev))
2346 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
2347 MGMT_STATUS_NOT_SUPPORTED);
2348
Marcel Holtmann1f350c82012-03-12 20:31:08 -07002349 key_count = __le16_to_cpu(cp->key_count);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002350
Johan Hedberg86742e12011-11-07 23:13:38 +02002351 expected_len = sizeof(*cp) + key_count *
2352 sizeof(struct mgmt_link_key_info);
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03002353 if (expected_len != len) {
Johan Hedberg86742e12011-11-07 23:13:38 +02002354 BT_ERR("load_link_keys: expected %u bytes, got %u bytes",
Johan Hedberg2606ecb2014-03-07 15:04:13 +02002355 expected_len, len);
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002356 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002357 MGMT_STATUS_INVALID_PARAMS);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002358 }
2359
Johan Hedberg4ae14302013-01-20 14:27:13 +02002360 if (cp->debug_keys != 0x00 && cp->debug_keys != 0x01)
2361 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
2362 MGMT_STATUS_INVALID_PARAMS);
2363
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002364 BT_DBG("%s debug_keys %u key_count %u", hdev->name, cp->debug_keys,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002365 key_count);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002366
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002367 for (i = 0; i < key_count; i++) {
2368 struct mgmt_link_key_info *key = &cp->keys[i];
2369
Marcel Holtmann8e991132014-01-10 02:07:25 -08002370 if (key->addr.type != BDADDR_BREDR || key->type > 0x08)
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002371 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
2372 MGMT_STATUS_INVALID_PARAMS);
2373 }
2374
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002375 hci_dev_lock(hdev);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002376
2377 hci_link_keys_clear(hdev);
2378
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002379 if (cp->debug_keys)
Marcel Holtmannb1de97d2014-01-31 11:55:21 -08002380 changed = !test_and_set_bit(HCI_DEBUG_KEYS, &hdev->dev_flags);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002381 else
Marcel Holtmannb1de97d2014-01-31 11:55:21 -08002382 changed = test_and_clear_bit(HCI_DEBUG_KEYS, &hdev->dev_flags);
2383
2384 if (changed)
2385 new_settings(hdev, NULL);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002386
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03002387 for (i = 0; i < key_count; i++) {
Johan Hedberg86742e12011-11-07 23:13:38 +02002388 struct mgmt_link_key_info *key = &cp->keys[i];
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002389
Johan Hedbergd753fdc2012-02-17 14:06:34 +02002390 hci_add_link_key(hdev, NULL, 0, &key->addr.bdaddr, key->val,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002391 key->type, key->pin_len);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002392 }
2393
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002394 cmd_complete(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS, 0, NULL, 0);
Johan Hedberg0e5f8752011-11-11 16:18:54 +02002395
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002396 hci_dev_unlock(hdev);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002397
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03002398 return 0;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002399}
2400
Johan Hedbergb1078ad2012-02-09 17:21:16 +02002401static int device_unpaired(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002402 u8 addr_type, struct sock *skip_sk)
Johan Hedbergb1078ad2012-02-09 17:21:16 +02002403{
2404 struct mgmt_ev_device_unpaired ev;
2405
2406 bacpy(&ev.addr.bdaddr, bdaddr);
2407 ev.addr.type = addr_type;
2408
2409 return mgmt_event(MGMT_EV_DEVICE_UNPAIRED, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002410 skip_sk);
Johan Hedbergb1078ad2012-02-09 17:21:16 +02002411}
2412
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002413static int unpair_device(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002414 u16 len)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002415{
Johan Hedberg124f6e32012-02-09 13:50:12 +02002416 struct mgmt_cp_unpair_device *cp = data;
2417 struct mgmt_rp_unpair_device rp;
Johan Hedberga8a1d192011-11-10 15:54:38 +02002418 struct hci_cp_disconnect dc;
2419 struct pending_cmd *cmd;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002420 struct hci_conn *conn;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002421 int err;
2422
Johan Hedberga8a1d192011-11-10 15:54:38 +02002423 memset(&rp, 0, sizeof(rp));
Johan Hedberg124f6e32012-02-09 13:50:12 +02002424 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
2425 rp.addr.type = cp->addr.type;
Johan Hedberga8a1d192011-11-10 15:54:38 +02002426
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002427 if (!bdaddr_type_is_valid(cp->addr.type))
2428 return cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
2429 MGMT_STATUS_INVALID_PARAMS,
2430 &rp, sizeof(rp));
2431
Johan Hedberg118da702013-01-20 14:27:20 +02002432 if (cp->disconnect != 0x00 && cp->disconnect != 0x01)
2433 return cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
2434 MGMT_STATUS_INVALID_PARAMS,
2435 &rp, sizeof(rp));
2436
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002437 hci_dev_lock(hdev);
2438
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02002439 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002440 err = cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002441 MGMT_STATUS_NOT_POWERED, &rp, sizeof(rp));
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02002442 goto unlock;
2443 }
2444
Johan Hedberge0b2b272014-02-18 17:14:31 +02002445 if (cp->addr.type == BDADDR_BREDR) {
Johan Hedberg124f6e32012-02-09 13:50:12 +02002446 err = hci_remove_link_key(hdev, &cp->addr.bdaddr);
Johan Hedberge0b2b272014-02-18 17:14:31 +02002447 } else {
2448 u8 addr_type;
2449
2450 if (cp->addr.type == BDADDR_LE_PUBLIC)
2451 addr_type = ADDR_LE_DEV_PUBLIC;
2452 else
2453 addr_type = ADDR_LE_DEV_RANDOM;
2454
Johan Hedberga7ec7332014-02-18 17:14:35 +02002455 hci_remove_irk(hdev, &cp->addr.bdaddr, addr_type);
2456
Andre Guedesa9b0a042014-02-26 20:21:52 -03002457 hci_conn_params_del(hdev, &cp->addr.bdaddr, addr_type);
2458
Johan Hedberge0b2b272014-02-18 17:14:31 +02002459 err = hci_remove_ltk(hdev, &cp->addr.bdaddr, addr_type);
2460 }
Vinicius Costa Gomesb0dbfb42012-02-02 21:08:03 -03002461
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002462 if (err < 0) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002463 err = cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002464 MGMT_STATUS_NOT_PAIRED, &rp, sizeof(rp));
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002465 goto unlock;
2466 }
2467
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02002468 if (cp->disconnect) {
Andre Guedes591f47f2012-04-24 21:02:49 -03002469 if (cp->addr.type == BDADDR_BREDR)
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02002470 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002471 &cp->addr.bdaddr);
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02002472 else
2473 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002474 &cp->addr.bdaddr);
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02002475 } else {
2476 conn = NULL;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002477 }
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002478
Johan Hedberga8a1d192011-11-10 15:54:38 +02002479 if (!conn) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002480 err = cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002481 &rp, sizeof(rp));
Johan Hedbergb1078ad2012-02-09 17:21:16 +02002482 device_unpaired(hdev, &cp->addr.bdaddr, cp->addr.type, sk);
Johan Hedberga8a1d192011-11-10 15:54:38 +02002483 goto unlock;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002484 }
2485
Johan Hedberg124f6e32012-02-09 13:50:12 +02002486 cmd = mgmt_pending_add(sk, MGMT_OP_UNPAIR_DEVICE, hdev, cp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002487 sizeof(*cp));
Johan Hedberga8a1d192011-11-10 15:54:38 +02002488 if (!cmd) {
2489 err = -ENOMEM;
2490 goto unlock;
2491 }
2492
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02002493 dc.handle = cpu_to_le16(conn->handle);
Johan Hedberga8a1d192011-11-10 15:54:38 +02002494 dc.reason = 0x13; /* Remote User Terminated Connection */
2495 err = hci_send_cmd(hdev, HCI_OP_DISCONNECT, sizeof(dc), &dc);
2496 if (err < 0)
2497 mgmt_pending_remove(cmd);
2498
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002499unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002500 hci_dev_unlock(hdev);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002501 return err;
2502}
2503
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002504static int disconnect(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002505 u16 len)
Johan Hedberg8962ee72011-01-20 12:40:27 +02002506{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002507 struct mgmt_cp_disconnect *cp = data;
Johan Hedberg06a63b12013-01-20 14:27:21 +02002508 struct mgmt_rp_disconnect rp;
Johan Hedberg8962ee72011-01-20 12:40:27 +02002509 struct hci_cp_disconnect dc;
Johan Hedberg366a0332011-02-19 12:05:55 -03002510 struct pending_cmd *cmd;
Johan Hedberg8962ee72011-01-20 12:40:27 +02002511 struct hci_conn *conn;
Johan Hedberg8962ee72011-01-20 12:40:27 +02002512 int err;
2513
2514 BT_DBG("");
2515
Johan Hedberg06a63b12013-01-20 14:27:21 +02002516 memset(&rp, 0, sizeof(rp));
2517 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
2518 rp.addr.type = cp->addr.type;
2519
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002520 if (!bdaddr_type_is_valid(cp->addr.type))
Johan Hedberg06a63b12013-01-20 14:27:21 +02002521 return cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
2522 MGMT_STATUS_INVALID_PARAMS,
2523 &rp, sizeof(rp));
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002524
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002525 hci_dev_lock(hdev);
Johan Hedberg8962ee72011-01-20 12:40:27 +02002526
2527 if (!test_bit(HCI_UP, &hdev->flags)) {
Johan Hedberg06a63b12013-01-20 14:27:21 +02002528 err = cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
2529 MGMT_STATUS_NOT_POWERED, &rp, sizeof(rp));
Johan Hedberg8962ee72011-01-20 12:40:27 +02002530 goto failed;
2531 }
2532
Johan Hedberg2e58ef32011-11-08 20:40:15 +02002533 if (mgmt_pending_find(MGMT_OP_DISCONNECT, hdev)) {
Johan Hedberg06a63b12013-01-20 14:27:21 +02002534 err = cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
2535 MGMT_STATUS_BUSY, &rp, sizeof(rp));
Johan Hedberg8962ee72011-01-20 12:40:27 +02002536 goto failed;
2537 }
2538
Andre Guedes591f47f2012-04-24 21:02:49 -03002539 if (cp->addr.type == BDADDR_BREDR)
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03002540 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK,
2541 &cp->addr.bdaddr);
Johan Hedberg88c3df12012-02-09 14:27:38 +02002542 else
2543 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &cp->addr.bdaddr);
Vinicius Costa Gomes365227e2011-05-06 18:41:44 -03002544
Vishal Agarwalf9607272012-06-13 05:32:43 +05302545 if (!conn || conn->state == BT_OPEN || conn->state == BT_CLOSED) {
Johan Hedberg06a63b12013-01-20 14:27:21 +02002546 err = cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
2547 MGMT_STATUS_NOT_CONNECTED, &rp, sizeof(rp));
Johan Hedberg8962ee72011-01-20 12:40:27 +02002548 goto failed;
2549 }
2550
Johan Hedberg2e58ef32011-11-08 20:40:15 +02002551 cmd = mgmt_pending_add(sk, MGMT_OP_DISCONNECT, hdev, data, len);
Johan Hedberg366a0332011-02-19 12:05:55 -03002552 if (!cmd) {
2553 err = -ENOMEM;
Johan Hedberg8962ee72011-01-20 12:40:27 +02002554 goto failed;
Johan Hedberg366a0332011-02-19 12:05:55 -03002555 }
Johan Hedberg8962ee72011-01-20 12:40:27 +02002556
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02002557 dc.handle = cpu_to_le16(conn->handle);
Andre Guedes3701f942012-06-11 18:41:12 -03002558 dc.reason = HCI_ERROR_REMOTE_USER_TERM;
Johan Hedberg8962ee72011-01-20 12:40:27 +02002559
2560 err = hci_send_cmd(hdev, HCI_OP_DISCONNECT, sizeof(dc), &dc);
2561 if (err < 0)
Johan Hedberga664b5b2011-02-19 12:06:02 -03002562 mgmt_pending_remove(cmd);
Johan Hedberg8962ee72011-01-20 12:40:27 +02002563
2564failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002565 hci_dev_unlock(hdev);
Johan Hedberg8962ee72011-01-20 12:40:27 +02002566 return err;
2567}
2568
Andre Guedes57c14772012-04-24 21:02:50 -03002569static u8 link_to_bdaddr(u8 link_type, u8 addr_type)
Johan Hedberg4c659c32011-11-07 23:13:39 +02002570{
2571 switch (link_type) {
2572 case LE_LINK:
Johan Hedberg48264f02011-11-09 13:58:58 +02002573 switch (addr_type) {
2574 case ADDR_LE_DEV_PUBLIC:
Andre Guedes591f47f2012-04-24 21:02:49 -03002575 return BDADDR_LE_PUBLIC;
Andre Guedes0ed09142012-04-03 08:46:54 -03002576
Johan Hedberg48264f02011-11-09 13:58:58 +02002577 default:
Andre Guedes0ed09142012-04-03 08:46:54 -03002578 /* Fallback to LE Random address type */
Andre Guedes591f47f2012-04-24 21:02:49 -03002579 return BDADDR_LE_RANDOM;
Johan Hedberg48264f02011-11-09 13:58:58 +02002580 }
Andre Guedes0ed09142012-04-03 08:46:54 -03002581
Johan Hedberg4c659c32011-11-07 23:13:39 +02002582 default:
Andre Guedes0ed09142012-04-03 08:46:54 -03002583 /* Fallback to BR/EDR type */
Andre Guedes591f47f2012-04-24 21:02:49 -03002584 return BDADDR_BREDR;
Johan Hedberg4c659c32011-11-07 23:13:39 +02002585 }
2586}
2587
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002588static int get_connections(struct sock *sk, struct hci_dev *hdev, void *data,
2589 u16 data_len)
Johan Hedberg2784eb42011-01-21 13:56:35 +02002590{
Johan Hedberg2784eb42011-01-21 13:56:35 +02002591 struct mgmt_rp_get_connections *rp;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02002592 struct hci_conn *c;
Johan Hedberga38528f2011-01-22 06:46:43 +02002593 size_t rp_len;
Johan Hedberg60fc5fb62012-02-23 09:52:28 +02002594 int err;
2595 u16 i;
Johan Hedberg2784eb42011-01-21 13:56:35 +02002596
2597 BT_DBG("");
2598
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002599 hci_dev_lock(hdev);
Johan Hedberg2784eb42011-01-21 13:56:35 +02002600
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02002601 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002602 err = cmd_status(sk, hdev->id, MGMT_OP_GET_CONNECTIONS,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002603 MGMT_STATUS_NOT_POWERED);
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02002604 goto unlock;
2605 }
2606
Johan Hedberg60fc5fb62012-02-23 09:52:28 +02002607 i = 0;
Johan Hedbergb644ba32012-01-17 21:48:47 +02002608 list_for_each_entry(c, &hdev->conn_hash.list, list) {
2609 if (test_bit(HCI_CONN_MGMT_CONNECTED, &c->flags))
Johan Hedberg60fc5fb62012-02-23 09:52:28 +02002610 i++;
Johan Hedberg2784eb42011-01-21 13:56:35 +02002611 }
2612
Johan Hedberg60fc5fb62012-02-23 09:52:28 +02002613 rp_len = sizeof(*rp) + (i * sizeof(struct mgmt_addr_info));
Andre Guedes92c4c202012-06-07 19:05:44 -03002614 rp = kmalloc(rp_len, GFP_KERNEL);
Johan Hedberga38528f2011-01-22 06:46:43 +02002615 if (!rp) {
Johan Hedberg2784eb42011-01-21 13:56:35 +02002616 err = -ENOMEM;
2617 goto unlock;
2618 }
2619
Johan Hedberg2784eb42011-01-21 13:56:35 +02002620 i = 0;
Johan Hedberg4c659c32011-11-07 23:13:39 +02002621 list_for_each_entry(c, &hdev->conn_hash.list, list) {
Johan Hedbergb644ba32012-01-17 21:48:47 +02002622 if (!test_bit(HCI_CONN_MGMT_CONNECTED, &c->flags))
2623 continue;
Johan Hedberg4c659c32011-11-07 23:13:39 +02002624 bacpy(&rp->addr[i].bdaddr, &c->dst);
Andre Guedes57c14772012-04-24 21:02:50 -03002625 rp->addr[i].type = link_to_bdaddr(c->type, c->dst_type);
Andre Guedes0ed09142012-04-03 08:46:54 -03002626 if (c->type == SCO_LINK || c->type == ESCO_LINK)
Johan Hedberg4c659c32011-11-07 23:13:39 +02002627 continue;
2628 i++;
2629 }
2630
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02002631 rp->conn_count = cpu_to_le16(i);
Johan Hedberg60fc5fb62012-02-23 09:52:28 +02002632
Johan Hedberg4c659c32011-11-07 23:13:39 +02002633 /* Recalculate length in case of filtered SCO connections, etc */
2634 rp_len = sizeof(*rp) + (i * sizeof(struct mgmt_addr_info));
Johan Hedberg2784eb42011-01-21 13:56:35 +02002635
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002636 err = cmd_complete(sk, hdev->id, MGMT_OP_GET_CONNECTIONS, 0, rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002637 rp_len);
Johan Hedberg2784eb42011-01-21 13:56:35 +02002638
Johan Hedberga38528f2011-01-22 06:46:43 +02002639 kfree(rp);
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02002640
2641unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002642 hci_dev_unlock(hdev);
Johan Hedberg2784eb42011-01-21 13:56:35 +02002643 return err;
2644}
2645
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002646static int send_pin_code_neg_reply(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002647 struct mgmt_cp_pin_code_neg_reply *cp)
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02002648{
2649 struct pending_cmd *cmd;
2650 int err;
2651
Johan Hedberg2e58ef32011-11-08 20:40:15 +02002652 cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_NEG_REPLY, hdev, cp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002653 sizeof(*cp));
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02002654 if (!cmd)
2655 return -ENOMEM;
2656
Johan Hedbergd8457692012-02-17 14:24:57 +02002657 err = hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002658 sizeof(cp->addr.bdaddr), &cp->addr.bdaddr);
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02002659 if (err < 0)
2660 mgmt_pending_remove(cmd);
2661
2662 return err;
2663}
2664
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002665static int pin_code_reply(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002666 u16 len)
Johan Hedberg980e1a52011-01-22 06:10:07 +02002667{
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02002668 struct hci_conn *conn;
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002669 struct mgmt_cp_pin_code_reply *cp = data;
Johan Hedberg980e1a52011-01-22 06:10:07 +02002670 struct hci_cp_pin_code_reply reply;
Johan Hedberg366a0332011-02-19 12:05:55 -03002671 struct pending_cmd *cmd;
Johan Hedberg980e1a52011-01-22 06:10:07 +02002672 int err;
2673
2674 BT_DBG("");
2675
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002676 hci_dev_lock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +02002677
Johan Hedberg4b34ee782012-02-21 14:13:02 +02002678 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002679 err = cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002680 MGMT_STATUS_NOT_POWERED);
Johan Hedberg980e1a52011-01-22 06:10:07 +02002681 goto failed;
2682 }
2683
Johan Hedbergd8457692012-02-17 14:24:57 +02002684 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->addr.bdaddr);
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02002685 if (!conn) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002686 err = cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002687 MGMT_STATUS_NOT_CONNECTED);
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02002688 goto failed;
2689 }
2690
2691 if (conn->pending_sec_level == BT_SECURITY_HIGH && cp->pin_len != 16) {
Johan Hedbergd8457692012-02-17 14:24:57 +02002692 struct mgmt_cp_pin_code_neg_reply ncp;
2693
2694 memcpy(&ncp.addr, &cp->addr, sizeof(ncp.addr));
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02002695
2696 BT_ERR("PIN code is not 16 bytes long");
2697
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002698 err = send_pin_code_neg_reply(sk, hdev, &ncp);
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02002699 if (err >= 0)
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002700 err = cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002701 MGMT_STATUS_INVALID_PARAMS);
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02002702
2703 goto failed;
2704 }
2705
Gustavo F. Padovan00abfe42012-03-01 00:37:10 -03002706 cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_REPLY, hdev, data, len);
Johan Hedberg366a0332011-02-19 12:05:55 -03002707 if (!cmd) {
2708 err = -ENOMEM;
Johan Hedberg980e1a52011-01-22 06:10:07 +02002709 goto failed;
Johan Hedberg366a0332011-02-19 12:05:55 -03002710 }
Johan Hedberg980e1a52011-01-22 06:10:07 +02002711
Johan Hedbergd8457692012-02-17 14:24:57 +02002712 bacpy(&reply.bdaddr, &cp->addr.bdaddr);
Johan Hedberg980e1a52011-01-22 06:10:07 +02002713 reply.pin_len = cp->pin_len;
Waldemar Rymarkiewicz24718ca2011-06-01 17:28:47 +02002714 memcpy(reply.pin_code, cp->pin_code, sizeof(reply.pin_code));
Johan Hedberg980e1a52011-01-22 06:10:07 +02002715
2716 err = hci_send_cmd(hdev, HCI_OP_PIN_CODE_REPLY, sizeof(reply), &reply);
2717 if (err < 0)
Johan Hedberga664b5b2011-02-19 12:06:02 -03002718 mgmt_pending_remove(cmd);
Johan Hedberg980e1a52011-01-22 06:10:07 +02002719
2720failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002721 hci_dev_unlock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +02002722 return err;
2723}
2724
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002725static int set_io_capability(struct sock *sk, struct hci_dev *hdev, void *data,
2726 u16 len)
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002727{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002728 struct mgmt_cp_set_io_capability *cp = data;
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002729
2730 BT_DBG("");
2731
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002732 hci_dev_lock(hdev);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002733
2734 hdev->io_capability = cp->io_capability;
2735
2736 BT_DBG("%s IO capability set to 0x%02x", hdev->name,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002737 hdev->io_capability);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002738
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002739 hci_dev_unlock(hdev);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002740
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002741 return cmd_complete(sk, hdev->id, MGMT_OP_SET_IO_CAPABILITY, 0, NULL,
2742 0);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002743}
2744
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002745static struct pending_cmd *find_pairing(struct hci_conn *conn)
Johan Hedberge9a416b2011-02-19 12:05:56 -03002746{
2747 struct hci_dev *hdev = conn->hdev;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02002748 struct pending_cmd *cmd;
Johan Hedberge9a416b2011-02-19 12:05:56 -03002749
Johan Hedberg2e58ef32011-11-08 20:40:15 +02002750 list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
Johan Hedberge9a416b2011-02-19 12:05:56 -03002751 if (cmd->opcode != MGMT_OP_PAIR_DEVICE)
2752 continue;
2753
Johan Hedberge9a416b2011-02-19 12:05:56 -03002754 if (cmd->user_data != conn)
2755 continue;
2756
2757 return cmd;
2758 }
2759
2760 return NULL;
2761}
2762
2763static void pairing_complete(struct pending_cmd *cmd, u8 status)
2764{
2765 struct mgmt_rp_pair_device rp;
2766 struct hci_conn *conn = cmd->user_data;
2767
Johan Hedberg61b1a7f2014-03-20 12:54:16 +02002768 bacpy(&rp.addr.bdaddr, &conn->dst);
2769 rp.addr.type = link_to_bdaddr(conn->type, conn->dst_type);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002770
Johan Hedbergaee9b2182012-02-18 15:07:59 +02002771 cmd_complete(cmd->sk, cmd->index, MGMT_OP_PAIR_DEVICE, status,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002772 &rp, sizeof(rp));
Johan Hedberge9a416b2011-02-19 12:05:56 -03002773
2774 /* So we don't get further callbacks for this connection */
2775 conn->connect_cfm_cb = NULL;
2776 conn->security_cfm_cb = NULL;
2777 conn->disconn_cfm_cb = NULL;
2778
David Herrmann76a68ba2013-04-06 20:28:37 +02002779 hci_conn_drop(conn);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002780
Johan Hedberga664b5b2011-02-19 12:06:02 -03002781 mgmt_pending_remove(cmd);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002782}
2783
Johan Hedbergf4a407b2014-02-18 21:41:34 +02002784void mgmt_smp_complete(struct hci_conn *conn, bool complete)
2785{
2786 u8 status = complete ? MGMT_STATUS_SUCCESS : MGMT_STATUS_FAILED;
2787 struct pending_cmd *cmd;
2788
2789 cmd = find_pairing(conn);
2790 if (cmd)
2791 pairing_complete(cmd, status);
2792}
2793
Johan Hedberge9a416b2011-02-19 12:05:56 -03002794static void pairing_complete_cb(struct hci_conn *conn, u8 status)
2795{
2796 struct pending_cmd *cmd;
2797
2798 BT_DBG("status %u", status);
2799
Johan Hedberg56e5cb82011-11-08 20:40:16 +02002800 cmd = find_pairing(conn);
2801 if (!cmd)
2802 BT_DBG("Unable to find a pending command");
2803 else
Johan Hedberge2113262012-02-18 15:20:03 +02002804 pairing_complete(cmd, mgmt_status(status));
Johan Hedberge9a416b2011-02-19 12:05:56 -03002805}
2806
Johan Hedbergf4a407b2014-02-18 21:41:34 +02002807static void le_pairing_complete_cb(struct hci_conn *conn, u8 status)
Vishal Agarwal4c47d732012-06-07 20:27:35 +05302808{
2809 struct pending_cmd *cmd;
2810
2811 BT_DBG("status %u", status);
2812
2813 if (!status)
2814 return;
2815
2816 cmd = find_pairing(conn);
2817 if (!cmd)
2818 BT_DBG("Unable to find a pending command");
2819 else
2820 pairing_complete(cmd, mgmt_status(status));
2821}
2822
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002823static int pair_device(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002824 u16 len)
Johan Hedberge9a416b2011-02-19 12:05:56 -03002825{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002826 struct mgmt_cp_pair_device *cp = data;
Johan Hedberg1425acb2011-11-11 00:07:35 +02002827 struct mgmt_rp_pair_device rp;
Johan Hedberge9a416b2011-02-19 12:05:56 -03002828 struct pending_cmd *cmd;
2829 u8 sec_level, auth_type;
2830 struct hci_conn *conn;
Johan Hedberge9a416b2011-02-19 12:05:56 -03002831 int err;
2832
2833 BT_DBG("");
2834
Szymon Jancf950a30e2013-01-18 12:48:07 +01002835 memset(&rp, 0, sizeof(rp));
2836 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
2837 rp.addr.type = cp->addr.type;
2838
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002839 if (!bdaddr_type_is_valid(cp->addr.type))
2840 return cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
2841 MGMT_STATUS_INVALID_PARAMS,
2842 &rp, sizeof(rp));
2843
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002844 hci_dev_lock(hdev);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002845
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02002846 if (!hdev_is_powered(hdev)) {
Szymon Jancf950a30e2013-01-18 12:48:07 +01002847 err = cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
2848 MGMT_STATUS_NOT_POWERED, &rp, sizeof(rp));
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02002849 goto unlock;
2850 }
2851
Vinicius Costa Gomesc908df32011-09-02 14:51:22 -03002852 sec_level = BT_SECURITY_MEDIUM;
2853 if (cp->io_cap == 0x03)
Johan Hedberge9a416b2011-02-19 12:05:56 -03002854 auth_type = HCI_AT_DEDICATED_BONDING;
Vinicius Costa Gomesc908df32011-09-02 14:51:22 -03002855 else
Johan Hedberge9a416b2011-02-19 12:05:56 -03002856 auth_type = HCI_AT_DEDICATED_BONDING_MITM;
Johan Hedberge9a416b2011-02-19 12:05:56 -03002857
Andre Guedes6f77d8c2014-02-26 20:21:45 -03002858 if (cp->addr.type == BDADDR_BREDR) {
Andre Guedes04a6c582014-02-26 20:21:44 -03002859 conn = hci_connect_acl(hdev, &cp->addr.bdaddr, sec_level,
2860 auth_type);
Andre Guedes6f77d8c2014-02-26 20:21:45 -03002861 } else {
2862 u8 addr_type;
2863
2864 /* Convert from L2CAP channel address type to HCI address type
2865 */
2866 if (cp->addr.type == BDADDR_LE_PUBLIC)
2867 addr_type = ADDR_LE_DEV_PUBLIC;
2868 else
2869 addr_type = ADDR_LE_DEV_RANDOM;
2870
2871 conn = hci_connect_le(hdev, &cp->addr.bdaddr, addr_type,
Andre Guedes04a6c582014-02-26 20:21:44 -03002872 sec_level, auth_type);
Andre Guedes6f77d8c2014-02-26 20:21:45 -03002873 }
Vinicius Costa Gomes7a512d02011-08-19 21:06:54 -03002874
Ville Tervo30e76272011-02-22 16:10:53 -03002875 if (IS_ERR(conn)) {
Andrzej Kaczmarek489dc482012-05-30 15:39:22 +02002876 int status;
2877
2878 if (PTR_ERR(conn) == -EBUSY)
2879 status = MGMT_STATUS_BUSY;
2880 else
2881 status = MGMT_STATUS_CONNECT_FAILED;
2882
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002883 err = cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
Andrzej Kaczmarek489dc482012-05-30 15:39:22 +02002884 status, &rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002885 sizeof(rp));
Johan Hedberge9a416b2011-02-19 12:05:56 -03002886 goto unlock;
2887 }
2888
2889 if (conn->connect_cfm_cb) {
David Herrmann76a68ba2013-04-06 20:28:37 +02002890 hci_conn_drop(conn);
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002891 err = cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002892 MGMT_STATUS_BUSY, &rp, sizeof(rp));
Johan Hedberge9a416b2011-02-19 12:05:56 -03002893 goto unlock;
2894 }
2895
Johan Hedberg2e58ef32011-11-08 20:40:15 +02002896 cmd = mgmt_pending_add(sk, MGMT_OP_PAIR_DEVICE, hdev, data, len);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002897 if (!cmd) {
2898 err = -ENOMEM;
David Herrmann76a68ba2013-04-06 20:28:37 +02002899 hci_conn_drop(conn);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002900 goto unlock;
2901 }
2902
Vinicius Costa Gomes7a512d02011-08-19 21:06:54 -03002903 /* For LE, just connecting isn't a proof that the pairing finished */
Johan Hedbergf4a407b2014-02-18 21:41:34 +02002904 if (cp->addr.type == BDADDR_BREDR) {
Vinicius Costa Gomes7a512d02011-08-19 21:06:54 -03002905 conn->connect_cfm_cb = pairing_complete_cb;
Johan Hedbergf4a407b2014-02-18 21:41:34 +02002906 conn->security_cfm_cb = pairing_complete_cb;
2907 conn->disconn_cfm_cb = pairing_complete_cb;
2908 } else {
2909 conn->connect_cfm_cb = le_pairing_complete_cb;
2910 conn->security_cfm_cb = le_pairing_complete_cb;
2911 conn->disconn_cfm_cb = le_pairing_complete_cb;
2912 }
Vinicius Costa Gomes7a512d02011-08-19 21:06:54 -03002913
Johan Hedberge9a416b2011-02-19 12:05:56 -03002914 conn->io_capability = cp->io_cap;
2915 cmd->user_data = conn;
2916
2917 if (conn->state == BT_CONNECTED &&
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002918 hci_conn_security(conn, sec_level, auth_type))
Johan Hedberge9a416b2011-02-19 12:05:56 -03002919 pairing_complete(cmd, 0);
2920
2921 err = 0;
2922
2923unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002924 hci_dev_unlock(hdev);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002925 return err;
2926}
2927
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002928static int cancel_pair_device(struct sock *sk, struct hci_dev *hdev, void *data,
2929 u16 len)
Johan Hedberg28424702012-02-02 04:02:29 +02002930{
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02002931 struct mgmt_addr_info *addr = data;
Johan Hedberg28424702012-02-02 04:02:29 +02002932 struct pending_cmd *cmd;
2933 struct hci_conn *conn;
2934 int err;
2935
2936 BT_DBG("");
2937
Johan Hedberg28424702012-02-02 04:02:29 +02002938 hci_dev_lock(hdev);
2939
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02002940 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002941 err = cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002942 MGMT_STATUS_NOT_POWERED);
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02002943 goto unlock;
2944 }
2945
Johan Hedberg28424702012-02-02 04:02:29 +02002946 cmd = mgmt_pending_find(MGMT_OP_PAIR_DEVICE, hdev);
2947 if (!cmd) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002948 err = cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002949 MGMT_STATUS_INVALID_PARAMS);
Johan Hedberg28424702012-02-02 04:02:29 +02002950 goto unlock;
2951 }
2952
2953 conn = cmd->user_data;
2954
2955 if (bacmp(&addr->bdaddr, &conn->dst) != 0) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002956 err = cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002957 MGMT_STATUS_INVALID_PARAMS);
Johan Hedberg28424702012-02-02 04:02:29 +02002958 goto unlock;
2959 }
2960
2961 pairing_complete(cmd, MGMT_STATUS_CANCELLED);
2962
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002963 err = cmd_complete(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002964 addr, sizeof(*addr));
Johan Hedberg28424702012-02-02 04:02:29 +02002965unlock:
2966 hci_dev_unlock(hdev);
Johan Hedberg28424702012-02-02 04:02:29 +02002967 return err;
2968}
2969
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002970static int user_pairing_resp(struct sock *sk, struct hci_dev *hdev,
Johan Hedberg1707c602013-03-15 17:07:15 -05002971 struct mgmt_addr_info *addr, u16 mgmt_op,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002972 u16 hci_op, __le32 passkey)
Johan Hedberga5c29682011-02-19 12:05:57 -03002973{
Johan Hedberga5c29682011-02-19 12:05:57 -03002974 struct pending_cmd *cmd;
Brian Gix0df4c182011-11-16 13:53:13 -08002975 struct hci_conn *conn;
Johan Hedberga5c29682011-02-19 12:05:57 -03002976 int err;
2977
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002978 hci_dev_lock(hdev);
Johan Hedberg08ba5382011-03-16 14:29:34 +02002979
Johan Hedberg4b34ee782012-02-21 14:13:02 +02002980 if (!hdev_is_powered(hdev)) {
Johan Hedbergfeb94d32013-03-15 17:07:16 -05002981 err = cmd_complete(sk, hdev->id, mgmt_op,
2982 MGMT_STATUS_NOT_POWERED, addr,
2983 sizeof(*addr));
Brian Gix0df4c182011-11-16 13:53:13 -08002984 goto done;
Johan Hedberga5c29682011-02-19 12:05:57 -03002985 }
2986
Johan Hedberg1707c602013-03-15 17:07:15 -05002987 if (addr->type == BDADDR_BREDR)
2988 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &addr->bdaddr);
Johan Hedberg272d90d2012-02-09 15:26:12 +02002989 else
Johan Hedberg1707c602013-03-15 17:07:15 -05002990 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &addr->bdaddr);
Brian Gix47c15e22011-11-16 13:53:14 -08002991
Johan Hedberg272d90d2012-02-09 15:26:12 +02002992 if (!conn) {
Johan Hedbergfeb94d32013-03-15 17:07:16 -05002993 err = cmd_complete(sk, hdev->id, mgmt_op,
2994 MGMT_STATUS_NOT_CONNECTED, addr,
2995 sizeof(*addr));
Johan Hedberg272d90d2012-02-09 15:26:12 +02002996 goto done;
2997 }
2998
Johan Hedberg1707c602013-03-15 17:07:15 -05002999 if (addr->type == BDADDR_LE_PUBLIC || addr->type == BDADDR_LE_RANDOM) {
Brian Gix47c15e22011-11-16 13:53:14 -08003000 /* Continue with pairing via SMP */
Brian Gix5fe57d92011-12-21 16:12:13 -08003001 err = smp_user_confirm_reply(conn, mgmt_op, passkey);
Brian Gix47c15e22011-11-16 13:53:14 -08003002
Brian Gix5fe57d92011-12-21 16:12:13 -08003003 if (!err)
Johan Hedbergfeb94d32013-03-15 17:07:16 -05003004 err = cmd_complete(sk, hdev->id, mgmt_op,
3005 MGMT_STATUS_SUCCESS, addr,
3006 sizeof(*addr));
Brian Gix5fe57d92011-12-21 16:12:13 -08003007 else
Johan Hedbergfeb94d32013-03-15 17:07:16 -05003008 err = cmd_complete(sk, hdev->id, mgmt_op,
3009 MGMT_STATUS_FAILED, addr,
3010 sizeof(*addr));
Brian Gix5fe57d92011-12-21 16:12:13 -08003011
Brian Gix47c15e22011-11-16 13:53:14 -08003012 goto done;
3013 }
3014
Johan Hedberg1707c602013-03-15 17:07:15 -05003015 cmd = mgmt_pending_add(sk, mgmt_op, hdev, addr, sizeof(*addr));
Johan Hedberga5c29682011-02-19 12:05:57 -03003016 if (!cmd) {
3017 err = -ENOMEM;
Brian Gix0df4c182011-11-16 13:53:13 -08003018 goto done;
Johan Hedberga5c29682011-02-19 12:05:57 -03003019 }
3020
Brian Gix0df4c182011-11-16 13:53:13 -08003021 /* Continue with pairing via HCI */
Brian Gix604086b2011-11-23 08:28:33 -08003022 if (hci_op == HCI_OP_USER_PASSKEY_REPLY) {
3023 struct hci_cp_user_passkey_reply cp;
3024
Johan Hedberg1707c602013-03-15 17:07:15 -05003025 bacpy(&cp.bdaddr, &addr->bdaddr);
Brian Gix604086b2011-11-23 08:28:33 -08003026 cp.passkey = passkey;
3027 err = hci_send_cmd(hdev, hci_op, sizeof(cp), &cp);
3028 } else
Johan Hedberg1707c602013-03-15 17:07:15 -05003029 err = hci_send_cmd(hdev, hci_op, sizeof(addr->bdaddr),
3030 &addr->bdaddr);
Brian Gix604086b2011-11-23 08:28:33 -08003031
Johan Hedberga664b5b2011-02-19 12:06:02 -03003032 if (err < 0)
3033 mgmt_pending_remove(cmd);
Johan Hedberga5c29682011-02-19 12:05:57 -03003034
Brian Gix0df4c182011-11-16 13:53:13 -08003035done:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003036 hci_dev_unlock(hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -03003037 return err;
3038}
3039
Jaganath Kanakkasseryafeb0192012-07-09 16:11:51 +05303040static int pin_code_neg_reply(struct sock *sk, struct hci_dev *hdev,
3041 void *data, u16 len)
3042{
3043 struct mgmt_cp_pin_code_neg_reply *cp = data;
3044
3045 BT_DBG("");
3046
Johan Hedberg1707c602013-03-15 17:07:15 -05003047 return user_pairing_resp(sk, hdev, &cp->addr,
Jaganath Kanakkasseryafeb0192012-07-09 16:11:51 +05303048 MGMT_OP_PIN_CODE_NEG_REPLY,
3049 HCI_OP_PIN_CODE_NEG_REPLY, 0);
3050}
3051
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003052static int user_confirm_reply(struct sock *sk, struct hci_dev *hdev, void *data,
3053 u16 len)
Brian Gix0df4c182011-11-16 13:53:13 -08003054{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03003055 struct mgmt_cp_user_confirm_reply *cp = data;
Brian Gix0df4c182011-11-16 13:53:13 -08003056
3057 BT_DBG("");
3058
3059 if (len != sizeof(*cp))
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003060 return cmd_status(sk, hdev->id, MGMT_OP_USER_CONFIRM_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003061 MGMT_STATUS_INVALID_PARAMS);
Brian Gix0df4c182011-11-16 13:53:13 -08003062
Johan Hedberg1707c602013-03-15 17:07:15 -05003063 return user_pairing_resp(sk, hdev, &cp->addr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003064 MGMT_OP_USER_CONFIRM_REPLY,
3065 HCI_OP_USER_CONFIRM_REPLY, 0);
Brian Gix0df4c182011-11-16 13:53:13 -08003066}
3067
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003068static int user_confirm_neg_reply(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003069 void *data, u16 len)
Brian Gix0df4c182011-11-16 13:53:13 -08003070{
Johan Hedbergc9c26592011-12-15 00:47:41 +02003071 struct mgmt_cp_user_confirm_neg_reply *cp = data;
Brian Gix0df4c182011-11-16 13:53:13 -08003072
3073 BT_DBG("");
3074
Johan Hedberg1707c602013-03-15 17:07:15 -05003075 return user_pairing_resp(sk, hdev, &cp->addr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003076 MGMT_OP_USER_CONFIRM_NEG_REPLY,
3077 HCI_OP_USER_CONFIRM_NEG_REPLY, 0);
Brian Gix0df4c182011-11-16 13:53:13 -08003078}
3079
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003080static int user_passkey_reply(struct sock *sk, struct hci_dev *hdev, void *data,
3081 u16 len)
Brian Gix604086b2011-11-23 08:28:33 -08003082{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03003083 struct mgmt_cp_user_passkey_reply *cp = data;
Brian Gix604086b2011-11-23 08:28:33 -08003084
3085 BT_DBG("");
3086
Johan Hedberg1707c602013-03-15 17:07:15 -05003087 return user_pairing_resp(sk, hdev, &cp->addr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003088 MGMT_OP_USER_PASSKEY_REPLY,
3089 HCI_OP_USER_PASSKEY_REPLY, cp->passkey);
Brian Gix604086b2011-11-23 08:28:33 -08003090}
3091
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003092static int user_passkey_neg_reply(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003093 void *data, u16 len)
Brian Gix604086b2011-11-23 08:28:33 -08003094{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03003095 struct mgmt_cp_user_passkey_neg_reply *cp = data;
Brian Gix604086b2011-11-23 08:28:33 -08003096
3097 BT_DBG("");
3098
Johan Hedberg1707c602013-03-15 17:07:15 -05003099 return user_pairing_resp(sk, hdev, &cp->addr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003100 MGMT_OP_USER_PASSKEY_NEG_REPLY,
3101 HCI_OP_USER_PASSKEY_NEG_REPLY, 0);
Brian Gix604086b2011-11-23 08:28:33 -08003102}
3103
Johan Hedberg13928972013-03-15 17:07:00 -05003104static void update_name(struct hci_request *req)
Johan Hedberg2b4bf392012-03-03 00:19:06 +02003105{
Johan Hedberg13928972013-03-15 17:07:00 -05003106 struct hci_dev *hdev = req->hdev;
Johan Hedberg2b4bf392012-03-03 00:19:06 +02003107 struct hci_cp_write_local_name cp;
3108
Johan Hedberg13928972013-03-15 17:07:00 -05003109 memcpy(cp.name, hdev->dev_name, sizeof(cp.name));
Johan Hedberg2b4bf392012-03-03 00:19:06 +02003110
Johan Hedberg890ea892013-03-15 17:06:52 -05003111 hci_req_add(req, HCI_OP_WRITE_LOCAL_NAME, sizeof(cp), &cp);
Johan Hedberg2b4bf392012-03-03 00:19:06 +02003112}
3113
Johan Hedberg13928972013-03-15 17:07:00 -05003114static void set_name_complete(struct hci_dev *hdev, u8 status)
3115{
3116 struct mgmt_cp_set_local_name *cp;
3117 struct pending_cmd *cmd;
3118
3119 BT_DBG("status 0x%02x", status);
3120
3121 hci_dev_lock(hdev);
3122
3123 cmd = mgmt_pending_find(MGMT_OP_SET_LOCAL_NAME, hdev);
3124 if (!cmd)
3125 goto unlock;
3126
3127 cp = cmd->param;
3128
3129 if (status)
3130 cmd_status(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME,
3131 mgmt_status(status));
3132 else
3133 cmd_complete(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0,
3134 cp, sizeof(*cp));
3135
3136 mgmt_pending_remove(cmd);
3137
3138unlock:
3139 hci_dev_unlock(hdev);
3140}
3141
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003142static int set_local_name(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003143 u16 len)
Johan Hedbergb312b1612011-03-16 14:29:37 +02003144{
Johan Hedberg2b4bf392012-03-03 00:19:06 +02003145 struct mgmt_cp_set_local_name *cp = data;
Johan Hedbergb312b1612011-03-16 14:29:37 +02003146 struct pending_cmd *cmd;
Johan Hedberg890ea892013-03-15 17:06:52 -05003147 struct hci_request req;
Johan Hedbergb312b1612011-03-16 14:29:37 +02003148 int err;
3149
3150 BT_DBG("");
3151
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003152 hci_dev_lock(hdev);
Johan Hedbergb312b1612011-03-16 14:29:37 +02003153
Johan Hedbergb3f2ca92013-03-15 17:07:03 -05003154 /* If the old values are the same as the new ones just return a
3155 * direct command complete event.
3156 */
3157 if (!memcmp(hdev->dev_name, cp->name, sizeof(hdev->dev_name)) &&
3158 !memcmp(hdev->short_name, cp->short_name,
3159 sizeof(hdev->short_name))) {
3160 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0,
3161 data, len);
3162 goto failed;
3163 }
3164
Johan Hedberg2b4bf392012-03-03 00:19:06 +02003165 memcpy(hdev->short_name, cp->short_name, sizeof(hdev->short_name));
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02003166
Johan Hedbergb5235a62012-02-21 14:32:24 +02003167 if (!hdev_is_powered(hdev)) {
Johan Hedberg2b4bf392012-03-03 00:19:06 +02003168 memcpy(hdev->dev_name, cp->name, sizeof(hdev->dev_name));
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02003169
3170 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003171 data, len);
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02003172 if (err < 0)
3173 goto failed;
3174
3175 err = mgmt_event(MGMT_EV_LOCAL_NAME_CHANGED, hdev, data, len,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003176 sk);
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02003177
Johan Hedbergb5235a62012-02-21 14:32:24 +02003178 goto failed;
3179 }
3180
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02003181 cmd = mgmt_pending_add(sk, MGMT_OP_SET_LOCAL_NAME, hdev, data, len);
Johan Hedbergb312b1612011-03-16 14:29:37 +02003182 if (!cmd) {
3183 err = -ENOMEM;
3184 goto failed;
3185 }
3186
Johan Hedberg13928972013-03-15 17:07:00 -05003187 memcpy(hdev->dev_name, cp->name, sizeof(hdev->dev_name));
3188
Johan Hedberg890ea892013-03-15 17:06:52 -05003189 hci_req_init(&req, hdev);
Johan Hedberg3f985052013-03-15 17:07:02 -05003190
3191 if (lmp_bredr_capable(hdev)) {
3192 update_name(&req);
3193 update_eir(&req);
3194 }
3195
Marcel Holtmann7a5f4992013-10-16 00:16:49 -07003196 /* The name is stored in the scan response data and so
3197 * no need to udpate the advertising data here.
3198 */
Johan Hedberg3f985052013-03-15 17:07:02 -05003199 if (lmp_le_capable(hdev))
Marcel Holtmann7a5f4992013-10-16 00:16:49 -07003200 update_scan_rsp_data(&req);
Johan Hedberg3f985052013-03-15 17:07:02 -05003201
Johan Hedberg13928972013-03-15 17:07:00 -05003202 err = hci_req_run(&req, set_name_complete);
Johan Hedbergb312b1612011-03-16 14:29:37 +02003203 if (err < 0)
3204 mgmt_pending_remove(cmd);
3205
3206failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003207 hci_dev_unlock(hdev);
Johan Hedbergb312b1612011-03-16 14:29:37 +02003208 return err;
3209}
3210
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02003211static int read_local_oob_data(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003212 void *data, u16 data_len)
Szymon Jancc35938b2011-03-22 13:12:21 +01003213{
Szymon Jancc35938b2011-03-22 13:12:21 +01003214 struct pending_cmd *cmd;
3215 int err;
3216
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003217 BT_DBG("%s", hdev->name);
Szymon Jancc35938b2011-03-22 13:12:21 +01003218
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003219 hci_dev_lock(hdev);
Szymon Jancc35938b2011-03-22 13:12:21 +01003220
Johan Hedberg4b34ee782012-02-21 14:13:02 +02003221 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003222 err = cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003223 MGMT_STATUS_NOT_POWERED);
Szymon Jancc35938b2011-03-22 13:12:21 +01003224 goto unlock;
3225 }
3226
Andre Guedes9a1a1992012-07-24 15:03:48 -03003227 if (!lmp_ssp_capable(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003228 err = cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003229 MGMT_STATUS_NOT_SUPPORTED);
Szymon Jancc35938b2011-03-22 13:12:21 +01003230 goto unlock;
3231 }
3232
Johan Hedberg2e58ef32011-11-08 20:40:15 +02003233 if (mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003234 err = cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003235 MGMT_STATUS_BUSY);
Szymon Jancc35938b2011-03-22 13:12:21 +01003236 goto unlock;
3237 }
3238
Johan Hedberg2e58ef32011-11-08 20:40:15 +02003239 cmd = mgmt_pending_add(sk, MGMT_OP_READ_LOCAL_OOB_DATA, hdev, NULL, 0);
Szymon Jancc35938b2011-03-22 13:12:21 +01003240 if (!cmd) {
3241 err = -ENOMEM;
3242 goto unlock;
3243 }
3244
Marcel Holtmann4d2d2792014-01-10 02:07:26 -08003245 if (test_bit(HCI_SC_ENABLED, &hdev->dev_flags))
3246 err = hci_send_cmd(hdev, HCI_OP_READ_LOCAL_OOB_EXT_DATA,
3247 0, NULL);
3248 else
3249 err = hci_send_cmd(hdev, HCI_OP_READ_LOCAL_OOB_DATA, 0, NULL);
3250
Szymon Jancc35938b2011-03-22 13:12:21 +01003251 if (err < 0)
3252 mgmt_pending_remove(cmd);
3253
3254unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003255 hci_dev_unlock(hdev);
Szymon Jancc35938b2011-03-22 13:12:21 +01003256 return err;
3257}
3258
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003259static int add_remote_oob_data(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003260 void *data, u16 len)
Szymon Janc2763eda2011-03-22 13:12:22 +01003261{
Szymon Janc2763eda2011-03-22 13:12:22 +01003262 int err;
3263
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003264 BT_DBG("%s ", hdev->name);
Szymon Janc2763eda2011-03-22 13:12:22 +01003265
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003266 hci_dev_lock(hdev);
Szymon Janc2763eda2011-03-22 13:12:22 +01003267
Marcel Holtmannec109112014-01-10 02:07:30 -08003268 if (len == MGMT_ADD_REMOTE_OOB_DATA_SIZE) {
3269 struct mgmt_cp_add_remote_oob_data *cp = data;
3270 u8 status;
Johan Hedbergbf1e3542012-02-19 13:16:14 +02003271
Marcel Holtmannec109112014-01-10 02:07:30 -08003272 err = hci_add_remote_oob_data(hdev, &cp->addr.bdaddr,
3273 cp->hash, cp->randomizer);
3274 if (err < 0)
3275 status = MGMT_STATUS_FAILED;
3276 else
3277 status = MGMT_STATUS_SUCCESS;
3278
3279 err = cmd_complete(sk, hdev->id, MGMT_OP_ADD_REMOTE_OOB_DATA,
3280 status, &cp->addr, sizeof(cp->addr));
3281 } else if (len == MGMT_ADD_REMOTE_OOB_EXT_DATA_SIZE) {
3282 struct mgmt_cp_add_remote_oob_ext_data *cp = data;
3283 u8 status;
3284
3285 err = hci_add_remote_oob_ext_data(hdev, &cp->addr.bdaddr,
3286 cp->hash192,
3287 cp->randomizer192,
3288 cp->hash256,
3289 cp->randomizer256);
3290 if (err < 0)
3291 status = MGMT_STATUS_FAILED;
3292 else
3293 status = MGMT_STATUS_SUCCESS;
3294
3295 err = cmd_complete(sk, hdev->id, MGMT_OP_ADD_REMOTE_OOB_DATA,
3296 status, &cp->addr, sizeof(cp->addr));
3297 } else {
3298 BT_ERR("add_remote_oob_data: invalid length of %u bytes", len);
3299 err = cmd_status(sk, hdev->id, MGMT_OP_ADD_REMOTE_OOB_DATA,
3300 MGMT_STATUS_INVALID_PARAMS);
3301 }
Szymon Janc2763eda2011-03-22 13:12:22 +01003302
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003303 hci_dev_unlock(hdev);
Szymon Janc2763eda2011-03-22 13:12:22 +01003304 return err;
3305}
3306
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003307static int remove_remote_oob_data(struct sock *sk, struct hci_dev *hdev,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03003308 void *data, u16 len)
Szymon Janc2763eda2011-03-22 13:12:22 +01003309{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03003310 struct mgmt_cp_remove_remote_oob_data *cp = data;
Johan Hedbergbf1e3542012-02-19 13:16:14 +02003311 u8 status;
Szymon Janc2763eda2011-03-22 13:12:22 +01003312 int err;
3313
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003314 BT_DBG("%s", hdev->name);
Szymon Janc2763eda2011-03-22 13:12:22 +01003315
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003316 hci_dev_lock(hdev);
Szymon Janc2763eda2011-03-22 13:12:22 +01003317
Johan Hedberg664ce4c2012-02-09 15:44:09 +02003318 err = hci_remove_remote_oob_data(hdev, &cp->addr.bdaddr);
Szymon Janc2763eda2011-03-22 13:12:22 +01003319 if (err < 0)
Johan Hedbergbf1e3542012-02-19 13:16:14 +02003320 status = MGMT_STATUS_INVALID_PARAMS;
Szymon Janc2763eda2011-03-22 13:12:22 +01003321 else
Szymon Janca6785be2012-12-13 15:11:21 +01003322 status = MGMT_STATUS_SUCCESS;
Johan Hedbergbf1e3542012-02-19 13:16:14 +02003323
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003324 err = cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003325 status, &cp->addr, sizeof(cp->addr));
Szymon Janc2763eda2011-03-22 13:12:22 +01003326
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003327 hci_dev_unlock(hdev);
Szymon Janc2763eda2011-03-22 13:12:22 +01003328 return err;
3329}
3330
Andre Guedes41dc2bd2013-04-30 15:29:30 -03003331static int mgmt_start_discovery_failed(struct hci_dev *hdev, u8 status)
3332{
3333 struct pending_cmd *cmd;
3334 u8 type;
3335 int err;
3336
3337 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
3338
3339 cmd = mgmt_pending_find(MGMT_OP_START_DISCOVERY, hdev);
3340 if (!cmd)
3341 return -ENOENT;
3342
3343 type = hdev->discovery.type;
3344
3345 err = cmd_complete(cmd->sk, hdev->id, cmd->opcode, mgmt_status(status),
3346 &type, sizeof(type));
3347 mgmt_pending_remove(cmd);
3348
3349 return err;
3350}
3351
Andre Guedes7c307722013-04-30 15:29:28 -03003352static void start_discovery_complete(struct hci_dev *hdev, u8 status)
3353{
3354 BT_DBG("status %d", status);
3355
3356 if (status) {
3357 hci_dev_lock(hdev);
3358 mgmt_start_discovery_failed(hdev, status);
3359 hci_dev_unlock(hdev);
3360 return;
3361 }
3362
3363 hci_dev_lock(hdev);
3364 hci_discovery_set_state(hdev, DISCOVERY_FINDING);
3365 hci_dev_unlock(hdev);
3366
3367 switch (hdev->discovery.type) {
3368 case DISCOV_TYPE_LE:
3369 queue_delayed_work(hdev->workqueue, &hdev->le_scan_disable,
Andre Guedes0d8cc932013-04-30 15:29:31 -03003370 DISCOV_LE_TIMEOUT);
Andre Guedes7c307722013-04-30 15:29:28 -03003371 break;
3372
3373 case DISCOV_TYPE_INTERLEAVED:
3374 queue_delayed_work(hdev->workqueue, &hdev->le_scan_disable,
Andre Guedes0d8cc932013-04-30 15:29:31 -03003375 DISCOV_INTERLEAVED_TIMEOUT);
Andre Guedes7c307722013-04-30 15:29:28 -03003376 break;
3377
3378 case DISCOV_TYPE_BREDR:
3379 break;
3380
3381 default:
3382 BT_ERR("Invalid discovery type %d", hdev->discovery.type);
3383 }
3384}
3385
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003386static int start_discovery(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003387 void *data, u16 len)
Johan Hedberg14a53662011-04-27 10:29:56 -04003388{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03003389 struct mgmt_cp_start_discovery *cp = data;
Johan Hedberg14a53662011-04-27 10:29:56 -04003390 struct pending_cmd *cmd;
Andre Guedes7c307722013-04-30 15:29:28 -03003391 struct hci_cp_le_set_scan_param param_cp;
3392 struct hci_cp_le_set_scan_enable enable_cp;
3393 struct hci_cp_inquiry inq_cp;
3394 struct hci_request req;
3395 /* General inquiry access code (GIAC) */
3396 u8 lap[3] = { 0x33, 0x8b, 0x9e };
Johan Hedbergd9483942014-02-23 19:42:24 +02003397 u8 status, own_addr_type;
Johan Hedberg14a53662011-04-27 10:29:56 -04003398 int err;
3399
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003400 BT_DBG("%s", hdev->name);
Johan Hedberg14a53662011-04-27 10:29:56 -04003401
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003402 hci_dev_lock(hdev);
Johan Hedberg14a53662011-04-27 10:29:56 -04003403
Johan Hedberg4b34ee782012-02-21 14:13:02 +02003404 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003405 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003406 MGMT_STATUS_NOT_POWERED);
Johan Hedbergbd2d1332011-11-07 23:13:37 +02003407 goto failed;
3408 }
3409
Andre Guedes642be6c2012-03-21 00:03:37 -03003410 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags)) {
3411 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
3412 MGMT_STATUS_BUSY);
3413 goto failed;
3414 }
3415
Johan Hedbergff9ef572012-01-04 14:23:45 +02003416 if (hdev->discovery.state != DISCOVERY_STOPPED) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003417 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003418 MGMT_STATUS_BUSY);
Johan Hedbergff9ef572012-01-04 14:23:45 +02003419 goto failed;
3420 }
3421
Johan Hedberg2e58ef32011-11-08 20:40:15 +02003422 cmd = mgmt_pending_add(sk, MGMT_OP_START_DISCOVERY, hdev, NULL, 0);
Johan Hedberg14a53662011-04-27 10:29:56 -04003423 if (!cmd) {
3424 err = -ENOMEM;
3425 goto failed;
3426 }
3427
Andre Guedes4aab14e2012-02-17 20:39:36 -03003428 hdev->discovery.type = cp->type;
3429
Andre Guedes7c307722013-04-30 15:29:28 -03003430 hci_req_init(&req, hdev);
3431
Andre Guedes4aab14e2012-02-17 20:39:36 -03003432 switch (hdev->discovery.type) {
Andre Guedesf39799f2012-02-17 20:39:35 -03003433 case DISCOV_TYPE_BREDR:
Johan Hedberge6fe7982013-10-02 15:45:22 +03003434 status = mgmt_bredr_support(hdev);
3435 if (status) {
Johan Hedberg04106752013-01-10 14:54:09 +02003436 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
Johan Hedberge6fe7982013-10-02 15:45:22 +03003437 status);
Johan Hedberg04106752013-01-10 14:54:09 +02003438 mgmt_pending_remove(cmd);
3439 goto failed;
3440 }
3441
Andre Guedes7c307722013-04-30 15:29:28 -03003442 if (test_bit(HCI_INQUIRY, &hdev->flags)) {
3443 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
3444 MGMT_STATUS_BUSY);
3445 mgmt_pending_remove(cmd);
3446 goto failed;
3447 }
3448
3449 hci_inquiry_cache_flush(hdev);
3450
3451 memset(&inq_cp, 0, sizeof(inq_cp));
3452 memcpy(&inq_cp.lap, lap, sizeof(inq_cp.lap));
Andre Guedes0d8cc932013-04-30 15:29:31 -03003453 inq_cp.length = DISCOV_BREDR_INQUIRY_LEN;
Andre Guedes7c307722013-04-30 15:29:28 -03003454 hci_req_add(&req, HCI_OP_INQUIRY, sizeof(inq_cp), &inq_cp);
Andre Guedesf39799f2012-02-17 20:39:35 -03003455 break;
3456
3457 case DISCOV_TYPE_LE:
Andre Guedes7c307722013-04-30 15:29:28 -03003458 case DISCOV_TYPE_INTERLEAVED:
Johan Hedberge6fe7982013-10-02 15:45:22 +03003459 status = mgmt_le_support(hdev);
3460 if (status) {
Johan Hedberg04106752013-01-10 14:54:09 +02003461 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
Johan Hedberge6fe7982013-10-02 15:45:22 +03003462 status);
Johan Hedberg04106752013-01-10 14:54:09 +02003463 mgmt_pending_remove(cmd);
3464 goto failed;
3465 }
3466
Andre Guedes7c307722013-04-30 15:29:28 -03003467 if (hdev->discovery.type == DISCOV_TYPE_INTERLEAVED &&
Johan Hedberg56f87902013-10-02 13:43:13 +03003468 !test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) {
Johan Hedberg04106752013-01-10 14:54:09 +02003469 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
3470 MGMT_STATUS_NOT_SUPPORTED);
3471 mgmt_pending_remove(cmd);
3472 goto failed;
3473 }
3474
Johan Hedbergf3d3444a2013-10-05 12:01:04 +02003475 if (test_bit(HCI_ADVERTISING, &hdev->dev_flags)) {
Andre Guedes7c307722013-04-30 15:29:28 -03003476 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
3477 MGMT_STATUS_REJECTED);
3478 mgmt_pending_remove(cmd);
3479 goto failed;
3480 }
3481
Andre Guedesc54c3862014-02-26 20:21:50 -03003482 /* If controller is scanning, it means the background scanning
3483 * is running. Thus, we should temporarily stop it in order to
3484 * set the discovery scanning parameters.
3485 */
3486 if (test_bit(HCI_LE_SCAN, &hdev->dev_flags))
3487 hci_req_add_le_scan_disable(&req);
Andre Guedes7c307722013-04-30 15:29:28 -03003488
3489 memset(&param_cp, 0, sizeof(param_cp));
Johan Hedbergd9483942014-02-23 19:42:24 +02003490
Marcel Holtmann94b1fc92014-02-23 20:25:54 -08003491 /* All active scans will be done with either a resolvable
3492 * private address (when privacy feature has been enabled)
3493 * or unresolvable private address.
3494 */
3495 err = hci_update_random_address(&req, true, &own_addr_type);
Johan Hedbergd9483942014-02-23 19:42:24 +02003496 if (err < 0) {
3497 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
3498 MGMT_STATUS_FAILED);
3499 mgmt_pending_remove(cmd);
3500 goto failed;
3501 }
3502
Andre Guedes7c307722013-04-30 15:29:28 -03003503 param_cp.type = LE_SCAN_ACTIVE;
Andre Guedes0d8cc932013-04-30 15:29:31 -03003504 param_cp.interval = cpu_to_le16(DISCOV_LE_SCAN_INT);
3505 param_cp.window = cpu_to_le16(DISCOV_LE_SCAN_WIN);
Johan Hedbergd9483942014-02-23 19:42:24 +02003506 param_cp.own_address_type = own_addr_type;
Andre Guedes7c307722013-04-30 15:29:28 -03003507 hci_req_add(&req, HCI_OP_LE_SET_SCAN_PARAM, sizeof(param_cp),
3508 &param_cp);
3509
3510 memset(&enable_cp, 0, sizeof(enable_cp));
3511 enable_cp.enable = LE_SCAN_ENABLE;
3512 enable_cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE;
3513 hci_req_add(&req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(enable_cp),
3514 &enable_cp);
Andre Guedes5e0452c2012-02-17 20:39:38 -03003515 break;
3516
Andre Guedesf39799f2012-02-17 20:39:35 -03003517 default:
Johan Hedberg04106752013-01-10 14:54:09 +02003518 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
3519 MGMT_STATUS_INVALID_PARAMS);
3520 mgmt_pending_remove(cmd);
3521 goto failed;
Andre Guedesf39799f2012-02-17 20:39:35 -03003522 }
Andre Guedes3fd24152012-02-03 17:48:01 -03003523
Andre Guedes7c307722013-04-30 15:29:28 -03003524 err = hci_req_run(&req, start_discovery_complete);
Johan Hedberg14a53662011-04-27 10:29:56 -04003525 if (err < 0)
3526 mgmt_pending_remove(cmd);
Johan Hedbergff9ef572012-01-04 14:23:45 +02003527 else
3528 hci_discovery_set_state(hdev, DISCOVERY_STARTING);
Johan Hedberg14a53662011-04-27 10:29:56 -04003529
3530failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003531 hci_dev_unlock(hdev);
Johan Hedberg14a53662011-04-27 10:29:56 -04003532 return err;
3533}
3534
Andre Guedes1183fdc2013-04-30 15:29:35 -03003535static int mgmt_stop_discovery_failed(struct hci_dev *hdev, u8 status)
3536{
3537 struct pending_cmd *cmd;
3538 int err;
3539
3540 cmd = mgmt_pending_find(MGMT_OP_STOP_DISCOVERY, hdev);
3541 if (!cmd)
3542 return -ENOENT;
3543
3544 err = cmd_complete(cmd->sk, hdev->id, cmd->opcode, mgmt_status(status),
3545 &hdev->discovery.type, sizeof(hdev->discovery.type));
3546 mgmt_pending_remove(cmd);
3547
3548 return err;
3549}
3550
Andre Guedes0e05bba2013-04-30 15:29:33 -03003551static void stop_discovery_complete(struct hci_dev *hdev, u8 status)
3552{
3553 BT_DBG("status %d", status);
3554
3555 hci_dev_lock(hdev);
3556
3557 if (status) {
3558 mgmt_stop_discovery_failed(hdev, status);
3559 goto unlock;
3560 }
3561
3562 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
3563
3564unlock:
3565 hci_dev_unlock(hdev);
3566}
3567
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003568static int stop_discovery(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003569 u16 len)
Johan Hedberg14a53662011-04-27 10:29:56 -04003570{
Johan Hedbergd9306502012-02-20 23:25:18 +02003571 struct mgmt_cp_stop_discovery *mgmt_cp = data;
Johan Hedberg14a53662011-04-27 10:29:56 -04003572 struct pending_cmd *cmd;
Johan Hedberg30dc78e2012-01-04 15:44:20 +02003573 struct hci_cp_remote_name_req_cancel cp;
3574 struct inquiry_entry *e;
Andre Guedes0e05bba2013-04-30 15:29:33 -03003575 struct hci_request req;
Johan Hedberg14a53662011-04-27 10:29:56 -04003576 int err;
3577
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003578 BT_DBG("%s", hdev->name);
Johan Hedberg14a53662011-04-27 10:29:56 -04003579
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003580 hci_dev_lock(hdev);
Johan Hedberg14a53662011-04-27 10:29:56 -04003581
Johan Hedberg30dc78e2012-01-04 15:44:20 +02003582 if (!hci_discovery_active(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003583 err = cmd_complete(sk, hdev->id, MGMT_OP_STOP_DISCOVERY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003584 MGMT_STATUS_REJECTED, &mgmt_cp->type,
3585 sizeof(mgmt_cp->type));
Johan Hedbergd9306502012-02-20 23:25:18 +02003586 goto unlock;
3587 }
3588
3589 if (hdev->discovery.type != mgmt_cp->type) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003590 err = cmd_complete(sk, hdev->id, MGMT_OP_STOP_DISCOVERY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003591 MGMT_STATUS_INVALID_PARAMS, &mgmt_cp->type,
3592 sizeof(mgmt_cp->type));
Johan Hedberg30dc78e2012-01-04 15:44:20 +02003593 goto unlock;
Johan Hedbergff9ef572012-01-04 14:23:45 +02003594 }
3595
Johan Hedberg2e58ef32011-11-08 20:40:15 +02003596 cmd = mgmt_pending_add(sk, MGMT_OP_STOP_DISCOVERY, hdev, NULL, 0);
Johan Hedberg14a53662011-04-27 10:29:56 -04003597 if (!cmd) {
3598 err = -ENOMEM;
Johan Hedberg30dc78e2012-01-04 15:44:20 +02003599 goto unlock;
Johan Hedberg14a53662011-04-27 10:29:56 -04003600 }
3601
Andre Guedes0e05bba2013-04-30 15:29:33 -03003602 hci_req_init(&req, hdev);
3603
Andre Guedese0d9727e2012-03-20 15:15:36 -03003604 switch (hdev->discovery.state) {
3605 case DISCOVERY_FINDING:
Andre Guedes0e05bba2013-04-30 15:29:33 -03003606 if (test_bit(HCI_INQUIRY, &hdev->flags)) {
3607 hci_req_add(&req, HCI_OP_INQUIRY_CANCEL, 0, NULL);
3608 } else {
3609 cancel_delayed_work(&hdev->le_scan_disable);
3610
Andre Guedesb1efcc22014-02-26 20:21:40 -03003611 hci_req_add_le_scan_disable(&req);
Andre Guedes0e05bba2013-04-30 15:29:33 -03003612 }
Andre Guedesc9ecc482012-03-15 16:52:08 -03003613
Andre Guedese0d9727e2012-03-20 15:15:36 -03003614 break;
3615
3616 case DISCOVERY_RESOLVING:
3617 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03003618 NAME_PENDING);
Andre Guedese0d9727e2012-03-20 15:15:36 -03003619 if (!e) {
Johan Hedberg30dc78e2012-01-04 15:44:20 +02003620 mgmt_pending_remove(cmd);
Andre Guedese0d9727e2012-03-20 15:15:36 -03003621 err = cmd_complete(sk, hdev->id,
3622 MGMT_OP_STOP_DISCOVERY, 0,
3623 &mgmt_cp->type,
3624 sizeof(mgmt_cp->type));
3625 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
3626 goto unlock;
3627 }
3628
3629 bacpy(&cp.bdaddr, &e->data.bdaddr);
Andre Guedes0e05bba2013-04-30 15:29:33 -03003630 hci_req_add(&req, HCI_OP_REMOTE_NAME_REQ_CANCEL, sizeof(cp),
3631 &cp);
Andre Guedese0d9727e2012-03-20 15:15:36 -03003632
3633 break;
3634
3635 default:
3636 BT_DBG("unknown discovery state %u", hdev->discovery.state);
Andre Guedes0e05bba2013-04-30 15:29:33 -03003637
3638 mgmt_pending_remove(cmd);
3639 err = cmd_complete(sk, hdev->id, MGMT_OP_STOP_DISCOVERY,
3640 MGMT_STATUS_FAILED, &mgmt_cp->type,
3641 sizeof(mgmt_cp->type));
3642 goto unlock;
Johan Hedberg30dc78e2012-01-04 15:44:20 +02003643 }
3644
Andre Guedes0e05bba2013-04-30 15:29:33 -03003645 err = hci_req_run(&req, stop_discovery_complete);
Johan Hedberg14a53662011-04-27 10:29:56 -04003646 if (err < 0)
3647 mgmt_pending_remove(cmd);
Johan Hedbergff9ef572012-01-04 14:23:45 +02003648 else
3649 hci_discovery_set_state(hdev, DISCOVERY_STOPPING);
Johan Hedberg14a53662011-04-27 10:29:56 -04003650
Johan Hedberg30dc78e2012-01-04 15:44:20 +02003651unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003652 hci_dev_unlock(hdev);
Johan Hedberg14a53662011-04-27 10:29:56 -04003653 return err;
3654}
3655
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003656static int confirm_name(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003657 u16 len)
Johan Hedberg561aafb2012-01-04 13:31:59 +02003658{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03003659 struct mgmt_cp_confirm_name *cp = data;
Johan Hedberg561aafb2012-01-04 13:31:59 +02003660 struct inquiry_entry *e;
Johan Hedberg561aafb2012-01-04 13:31:59 +02003661 int err;
3662
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003663 BT_DBG("%s", hdev->name);
Johan Hedberg561aafb2012-01-04 13:31:59 +02003664
Johan Hedberg561aafb2012-01-04 13:31:59 +02003665 hci_dev_lock(hdev);
3666
Johan Hedberg30dc78e2012-01-04 15:44:20 +02003667 if (!hci_discovery_active(hdev)) {
Lukasz Rymanowskid3a25412014-02-27 16:47:28 +01003668 err = cmd_complete(sk, hdev->id, MGMT_OP_CONFIRM_NAME,
3669 MGMT_STATUS_FAILED, &cp->addr,
3670 sizeof(cp->addr));
Johan Hedberg30dc78e2012-01-04 15:44:20 +02003671 goto failed;
3672 }
3673
Johan Hedberga198e7b2012-02-17 14:27:06 +02003674 e = hci_inquiry_cache_lookup_unknown(hdev, &cp->addr.bdaddr);
Johan Hedberg561aafb2012-01-04 13:31:59 +02003675 if (!e) {
Lukasz Rymanowskid3a25412014-02-27 16:47:28 +01003676 err = cmd_complete(sk, hdev->id, MGMT_OP_CONFIRM_NAME,
3677 MGMT_STATUS_INVALID_PARAMS, &cp->addr,
3678 sizeof(cp->addr));
Johan Hedberg561aafb2012-01-04 13:31:59 +02003679 goto failed;
3680 }
3681
3682 if (cp->name_known) {
3683 e->name_state = NAME_KNOWN;
3684 list_del(&e->list);
3685 } else {
3686 e->name_state = NAME_NEEDED;
Johan Hedberga3d4e202012-01-09 00:53:02 +02003687 hci_inquiry_cache_update_resolve(hdev, e);
Johan Hedberg561aafb2012-01-04 13:31:59 +02003688 }
3689
Johan Hedberge3846622013-01-09 15:29:33 +02003690 err = cmd_complete(sk, hdev->id, MGMT_OP_CONFIRM_NAME, 0, &cp->addr,
3691 sizeof(cp->addr));
Johan Hedberg561aafb2012-01-04 13:31:59 +02003692
3693failed:
3694 hci_dev_unlock(hdev);
Johan Hedberg561aafb2012-01-04 13:31:59 +02003695 return err;
3696}
3697
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003698static int block_device(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003699 u16 len)
Antti Julku7fbec222011-06-15 12:01:15 +03003700{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03003701 struct mgmt_cp_block_device *cp = data;
Johan Hedbergf0eeea82012-02-19 12:58:54 +02003702 u8 status;
Antti Julku7fbec222011-06-15 12:01:15 +03003703 int err;
3704
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003705 BT_DBG("%s", hdev->name);
Antti Julku7fbec222011-06-15 12:01:15 +03003706
Johan Hedberg4ee71b22013-01-20 14:27:19 +02003707 if (!bdaddr_type_is_valid(cp->addr.type))
Johan Hedberg5d0846d2013-01-20 14:27:22 +02003708 return cmd_complete(sk, hdev->id, MGMT_OP_BLOCK_DEVICE,
3709 MGMT_STATUS_INVALID_PARAMS,
3710 &cp->addr, sizeof(cp->addr));
Johan Hedberg4ee71b22013-01-20 14:27:19 +02003711
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003712 hci_dev_lock(hdev);
Antti Julku5e762442011-08-25 16:48:02 +03003713
Johan Hedberg88c1fe42012-02-09 15:56:11 +02003714 err = hci_blacklist_add(hdev, &cp->addr.bdaddr, cp->addr.type);
Antti Julku7fbec222011-06-15 12:01:15 +03003715 if (err < 0)
Johan Hedbergf0eeea82012-02-19 12:58:54 +02003716 status = MGMT_STATUS_FAILED;
Antti Julku7fbec222011-06-15 12:01:15 +03003717 else
Szymon Janca6785be2012-12-13 15:11:21 +01003718 status = MGMT_STATUS_SUCCESS;
Johan Hedbergf0eeea82012-02-19 12:58:54 +02003719
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003720 err = cmd_complete(sk, hdev->id, MGMT_OP_BLOCK_DEVICE, status,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003721 &cp->addr, sizeof(cp->addr));
Antti Julku5e762442011-08-25 16:48:02 +03003722
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003723 hci_dev_unlock(hdev);
Antti Julku7fbec222011-06-15 12:01:15 +03003724
3725 return err;
3726}
3727
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003728static int unblock_device(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003729 u16 len)
Antti Julku7fbec222011-06-15 12:01:15 +03003730{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03003731 struct mgmt_cp_unblock_device *cp = data;
Johan Hedbergf0eeea82012-02-19 12:58:54 +02003732 u8 status;
Antti Julku7fbec222011-06-15 12:01:15 +03003733 int err;
3734
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003735 BT_DBG("%s", hdev->name);
Antti Julku7fbec222011-06-15 12:01:15 +03003736
Johan Hedberg4ee71b22013-01-20 14:27:19 +02003737 if (!bdaddr_type_is_valid(cp->addr.type))
Johan Hedberg5d0846d2013-01-20 14:27:22 +02003738 return cmd_complete(sk, hdev->id, MGMT_OP_UNBLOCK_DEVICE,
3739 MGMT_STATUS_INVALID_PARAMS,
3740 &cp->addr, sizeof(cp->addr));
Johan Hedberg4ee71b22013-01-20 14:27:19 +02003741
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003742 hci_dev_lock(hdev);
Antti Julku5e762442011-08-25 16:48:02 +03003743
Johan Hedberg88c1fe42012-02-09 15:56:11 +02003744 err = hci_blacklist_del(hdev, &cp->addr.bdaddr, cp->addr.type);
Antti Julku7fbec222011-06-15 12:01:15 +03003745 if (err < 0)
Johan Hedbergf0eeea82012-02-19 12:58:54 +02003746 status = MGMT_STATUS_INVALID_PARAMS;
Antti Julku7fbec222011-06-15 12:01:15 +03003747 else
Szymon Janca6785be2012-12-13 15:11:21 +01003748 status = MGMT_STATUS_SUCCESS;
Johan Hedbergf0eeea82012-02-19 12:58:54 +02003749
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003750 err = cmd_complete(sk, hdev->id, MGMT_OP_UNBLOCK_DEVICE, status,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003751 &cp->addr, sizeof(cp->addr));
Antti Julku5e762442011-08-25 16:48:02 +03003752
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03003753 hci_dev_unlock(hdev);
Antti Julku7fbec222011-06-15 12:01:15 +03003754
3755 return err;
3756}
3757
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07003758static int set_device_id(struct sock *sk, struct hci_dev *hdev, void *data,
3759 u16 len)
3760{
3761 struct mgmt_cp_set_device_id *cp = data;
Johan Hedberg890ea892013-03-15 17:06:52 -05003762 struct hci_request req;
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07003763 int err;
Szymon Jancc72d4b82012-03-16 16:02:57 +01003764 __u16 source;
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07003765
3766 BT_DBG("%s", hdev->name);
3767
Szymon Jancc72d4b82012-03-16 16:02:57 +01003768 source = __le16_to_cpu(cp->source);
3769
3770 if (source > 0x0002)
3771 return cmd_status(sk, hdev->id, MGMT_OP_SET_DEVICE_ID,
3772 MGMT_STATUS_INVALID_PARAMS);
3773
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07003774 hci_dev_lock(hdev);
3775
Szymon Jancc72d4b82012-03-16 16:02:57 +01003776 hdev->devid_source = source;
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07003777 hdev->devid_vendor = __le16_to_cpu(cp->vendor);
3778 hdev->devid_product = __le16_to_cpu(cp->product);
3779 hdev->devid_version = __le16_to_cpu(cp->version);
3780
3781 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_DEVICE_ID, 0, NULL, 0);
3782
Johan Hedberg890ea892013-03-15 17:06:52 -05003783 hci_req_init(&req, hdev);
3784 update_eir(&req);
3785 hci_req_run(&req, NULL);
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07003786
3787 hci_dev_unlock(hdev);
3788
3789 return err;
3790}
3791
Johan Hedberg4375f102013-09-25 13:26:10 +03003792static void set_advertising_complete(struct hci_dev *hdev, u8 status)
3793{
3794 struct cmd_lookup match = { NULL, hdev };
3795
3796 if (status) {
3797 u8 mgmt_err = mgmt_status(status);
3798
3799 mgmt_pending_foreach(MGMT_OP_SET_ADVERTISING, hdev,
3800 cmd_status_rsp, &mgmt_err);
3801 return;
3802 }
3803
3804 mgmt_pending_foreach(MGMT_OP_SET_ADVERTISING, hdev, settings_rsp,
3805 &match);
3806
3807 new_settings(hdev, match.sk);
3808
3809 if (match.sk)
3810 sock_put(match.sk);
3811}
3812
Marcel Holtmann21b51872013-10-10 09:47:53 -07003813static int set_advertising(struct sock *sk, struct hci_dev *hdev, void *data,
3814 u16 len)
Johan Hedberg4375f102013-09-25 13:26:10 +03003815{
3816 struct mgmt_mode *cp = data;
3817 struct pending_cmd *cmd;
3818 struct hci_request req;
Johan Hedberge6fe7982013-10-02 15:45:22 +03003819 u8 val, enabled, status;
Johan Hedberg4375f102013-09-25 13:26:10 +03003820 int err;
3821
3822 BT_DBG("request for %s", hdev->name);
3823
Johan Hedberge6fe7982013-10-02 15:45:22 +03003824 status = mgmt_le_support(hdev);
3825 if (status)
Johan Hedberg4375f102013-09-25 13:26:10 +03003826 return cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
Johan Hedberge6fe7982013-10-02 15:45:22 +03003827 status);
Johan Hedberg4375f102013-09-25 13:26:10 +03003828
3829 if (cp->val != 0x00 && cp->val != 0x01)
3830 return cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
3831 MGMT_STATUS_INVALID_PARAMS);
3832
3833 hci_dev_lock(hdev);
3834
3835 val = !!cp->val;
Johan Hedbergf3d3444a2013-10-05 12:01:04 +02003836 enabled = test_bit(HCI_ADVERTISING, &hdev->dev_flags);
Johan Hedberg4375f102013-09-25 13:26:10 +03003837
Johan Hedbergf74ca9b2013-10-08 15:52:18 +02003838 /* The following conditions are ones which mean that we should
3839 * not do any HCI communication but directly send a mgmt
3840 * response to user space (after toggling the flag if
3841 * necessary).
3842 */
3843 if (!hdev_is_powered(hdev) || val == enabled ||
Marcel Holtmannb145edc2013-10-10 09:47:54 -07003844 hci_conn_num(hdev, LE_LINK) > 0) {
Johan Hedberg4375f102013-09-25 13:26:10 +03003845 bool changed = false;
3846
Johan Hedbergf3d3444a2013-10-05 12:01:04 +02003847 if (val != test_bit(HCI_ADVERTISING, &hdev->dev_flags)) {
3848 change_bit(HCI_ADVERTISING, &hdev->dev_flags);
Johan Hedberg4375f102013-09-25 13:26:10 +03003849 changed = true;
3850 }
3851
3852 err = send_settings_rsp(sk, MGMT_OP_SET_ADVERTISING, hdev);
3853 if (err < 0)
3854 goto unlock;
3855
3856 if (changed)
3857 err = new_settings(hdev, sk);
3858
3859 goto unlock;
3860 }
3861
3862 if (mgmt_pending_find(MGMT_OP_SET_ADVERTISING, hdev) ||
3863 mgmt_pending_find(MGMT_OP_SET_LE, hdev)) {
3864 err = cmd_status(sk, hdev->id, MGMT_OP_SET_ADVERTISING,
3865 MGMT_STATUS_BUSY);
3866 goto unlock;
3867 }
3868
3869 cmd = mgmt_pending_add(sk, MGMT_OP_SET_ADVERTISING, hdev, data, len);
3870 if (!cmd) {
3871 err = -ENOMEM;
3872 goto unlock;
3873 }
3874
3875 hci_req_init(&req, hdev);
3876
Marcel Holtmannbba3aa52013-10-06 02:55:21 -07003877 if (val)
3878 enable_advertising(&req);
3879 else
3880 disable_advertising(&req);
Johan Hedberg4375f102013-09-25 13:26:10 +03003881
3882 err = hci_req_run(&req, set_advertising_complete);
3883 if (err < 0)
3884 mgmt_pending_remove(cmd);
3885
3886unlock:
3887 hci_dev_unlock(hdev);
3888 return err;
3889}
3890
Marcel Holtmannd13eafc2013-10-02 04:41:30 -07003891static int set_static_address(struct sock *sk, struct hci_dev *hdev,
3892 void *data, u16 len)
3893{
3894 struct mgmt_cp_set_static_address *cp = data;
3895 int err;
3896
3897 BT_DBG("%s", hdev->name);
3898
Marcel Holtmann62af4442013-10-02 22:10:32 -07003899 if (!lmp_le_capable(hdev))
Marcel Holtmannd13eafc2013-10-02 04:41:30 -07003900 return cmd_status(sk, hdev->id, MGMT_OP_SET_STATIC_ADDRESS,
Marcel Holtmann62af4442013-10-02 22:10:32 -07003901 MGMT_STATUS_NOT_SUPPORTED);
Marcel Holtmannd13eafc2013-10-02 04:41:30 -07003902
3903 if (hdev_is_powered(hdev))
3904 return cmd_status(sk, hdev->id, MGMT_OP_SET_STATIC_ADDRESS,
3905 MGMT_STATUS_REJECTED);
3906
3907 if (bacmp(&cp->bdaddr, BDADDR_ANY)) {
3908 if (!bacmp(&cp->bdaddr, BDADDR_NONE))
3909 return cmd_status(sk, hdev->id,
3910 MGMT_OP_SET_STATIC_ADDRESS,
3911 MGMT_STATUS_INVALID_PARAMS);
3912
3913 /* Two most significant bits shall be set */
3914 if ((cp->bdaddr.b[5] & 0xc0) != 0xc0)
3915 return cmd_status(sk, hdev->id,
3916 MGMT_OP_SET_STATIC_ADDRESS,
3917 MGMT_STATUS_INVALID_PARAMS);
3918 }
3919
3920 hci_dev_lock(hdev);
3921
3922 bacpy(&hdev->static_addr, &cp->bdaddr);
3923
3924 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_STATIC_ADDRESS, 0, NULL, 0);
3925
3926 hci_dev_unlock(hdev);
3927
3928 return err;
3929}
3930
Marcel Holtmann14b49b92013-10-11 08:23:20 -07003931static int set_scan_params(struct sock *sk, struct hci_dev *hdev,
3932 void *data, u16 len)
3933{
3934 struct mgmt_cp_set_scan_params *cp = data;
3935 __u16 interval, window;
3936 int err;
3937
3938 BT_DBG("%s", hdev->name);
3939
3940 if (!lmp_le_capable(hdev))
3941 return cmd_status(sk, hdev->id, MGMT_OP_SET_SCAN_PARAMS,
3942 MGMT_STATUS_NOT_SUPPORTED);
3943
3944 interval = __le16_to_cpu(cp->interval);
3945
3946 if (interval < 0x0004 || interval > 0x4000)
3947 return cmd_status(sk, hdev->id, MGMT_OP_SET_SCAN_PARAMS,
3948 MGMT_STATUS_INVALID_PARAMS);
3949
3950 window = __le16_to_cpu(cp->window);
3951
3952 if (window < 0x0004 || window > 0x4000)
3953 return cmd_status(sk, hdev->id, MGMT_OP_SET_SCAN_PARAMS,
3954 MGMT_STATUS_INVALID_PARAMS);
3955
Marcel Holtmann899e1072013-10-14 09:55:32 -07003956 if (window > interval)
3957 return cmd_status(sk, hdev->id, MGMT_OP_SET_SCAN_PARAMS,
3958 MGMT_STATUS_INVALID_PARAMS);
3959
Marcel Holtmann14b49b92013-10-11 08:23:20 -07003960 hci_dev_lock(hdev);
3961
3962 hdev->le_scan_interval = interval;
3963 hdev->le_scan_window = window;
3964
3965 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_SCAN_PARAMS, 0, NULL, 0);
3966
Andre Guedesdd2ef8e2014-02-26 20:21:56 -03003967 /* If background scan is running, restart it so new parameters are
3968 * loaded.
3969 */
3970 if (test_bit(HCI_LE_SCAN, &hdev->dev_flags) &&
3971 hdev->discovery.state == DISCOVERY_STOPPED) {
3972 struct hci_request req;
3973
3974 hci_req_init(&req, hdev);
3975
3976 hci_req_add_le_scan_disable(&req);
3977 hci_req_add_le_passive_scan(&req);
3978
3979 hci_req_run(&req, NULL);
3980 }
3981
Marcel Holtmann14b49b92013-10-11 08:23:20 -07003982 hci_dev_unlock(hdev);
3983
3984 return err;
3985}
3986
Johan Hedberg33e38b32013-03-15 17:07:05 -05003987static void fast_connectable_complete(struct hci_dev *hdev, u8 status)
3988{
3989 struct pending_cmd *cmd;
3990
3991 BT_DBG("status 0x%02x", status);
3992
3993 hci_dev_lock(hdev);
3994
3995 cmd = mgmt_pending_find(MGMT_OP_SET_FAST_CONNECTABLE, hdev);
3996 if (!cmd)
3997 goto unlock;
3998
3999 if (status) {
4000 cmd_status(cmd->sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
4001 mgmt_status(status));
4002 } else {
Johan Hedberg1a4d3c42013-03-15 17:07:08 -05004003 struct mgmt_mode *cp = cmd->param;
4004
4005 if (cp->val)
4006 set_bit(HCI_FAST_CONNECTABLE, &hdev->dev_flags);
4007 else
4008 clear_bit(HCI_FAST_CONNECTABLE, &hdev->dev_flags);
4009
Johan Hedberg33e38b32013-03-15 17:07:05 -05004010 send_settings_rsp(cmd->sk, MGMT_OP_SET_FAST_CONNECTABLE, hdev);
4011 new_settings(hdev, cmd->sk);
4012 }
4013
4014 mgmt_pending_remove(cmd);
4015
4016unlock:
4017 hci_dev_unlock(hdev);
4018}
4019
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004020static int set_fast_connectable(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004021 void *data, u16 len)
Antti Julkuf6422ec2011-06-22 13:11:56 +03004022{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03004023 struct mgmt_mode *cp = data;
Johan Hedberg33e38b32013-03-15 17:07:05 -05004024 struct pending_cmd *cmd;
4025 struct hci_request req;
Antti Julkuf6422ec2011-06-22 13:11:56 +03004026 int err;
4027
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004028 BT_DBG("%s", hdev->name);
Antti Julkuf6422ec2011-06-22 13:11:56 +03004029
Johan Hedberg56f87902013-10-02 13:43:13 +03004030 if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags) ||
4031 hdev->hci_ver < BLUETOOTH_VER_1_2)
Johan Hedberg33c525c2012-10-24 21:11:58 +03004032 return cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
4033 MGMT_STATUS_NOT_SUPPORTED);
4034
Johan Hedberga7e80f22013-01-09 16:05:19 +02004035 if (cp->val != 0x00 && cp->val != 0x01)
4036 return cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
4037 MGMT_STATUS_INVALID_PARAMS);
4038
Johan Hedberg5400c042012-02-21 16:40:33 +02004039 if (!hdev_is_powered(hdev))
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004040 return cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004041 MGMT_STATUS_NOT_POWERED);
Johan Hedberg5400c042012-02-21 16:40:33 +02004042
4043 if (!test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004044 return cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004045 MGMT_STATUS_REJECTED);
Antti Julkuf6422ec2011-06-22 13:11:56 +03004046
4047 hci_dev_lock(hdev);
4048
Johan Hedberg05cbf292013-03-15 17:07:07 -05004049 if (mgmt_pending_find(MGMT_OP_SET_FAST_CONNECTABLE, hdev)) {
4050 err = cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
4051 MGMT_STATUS_BUSY);
4052 goto unlock;
4053 }
4054
Johan Hedberg1a4d3c42013-03-15 17:07:08 -05004055 if (!!cp->val == test_bit(HCI_FAST_CONNECTABLE, &hdev->dev_flags)) {
4056 err = send_settings_rsp(sk, MGMT_OP_SET_FAST_CONNECTABLE,
4057 hdev);
4058 goto unlock;
4059 }
4060
Johan Hedberg33e38b32013-03-15 17:07:05 -05004061 cmd = mgmt_pending_add(sk, MGMT_OP_SET_FAST_CONNECTABLE, hdev,
4062 data, len);
4063 if (!cmd) {
4064 err = -ENOMEM;
4065 goto unlock;
4066 }
4067
4068 hci_req_init(&req, hdev);
4069
Johan Hedberg406d7802013-03-15 17:07:09 -05004070 write_fast_connectable(&req, cp->val);
Johan Hedberg33e38b32013-03-15 17:07:05 -05004071
4072 err = hci_req_run(&req, fast_connectable_complete);
Antti Julkuf6422ec2011-06-22 13:11:56 +03004073 if (err < 0) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004074 err = cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004075 MGMT_STATUS_FAILED);
Johan Hedberg33e38b32013-03-15 17:07:05 -05004076 mgmt_pending_remove(cmd);
Antti Julkuf6422ec2011-06-22 13:11:56 +03004077 }
4078
Johan Hedberg33e38b32013-03-15 17:07:05 -05004079unlock:
Antti Julkuf6422ec2011-06-22 13:11:56 +03004080 hci_dev_unlock(hdev);
Johan Hedberg33e38b32013-03-15 17:07:05 -05004081
Antti Julkuf6422ec2011-06-22 13:11:56 +03004082 return err;
4083}
4084
Johan Hedberg67e5a7a2013-10-14 21:15:25 +03004085static void set_bredr_scan(struct hci_request *req)
4086{
4087 struct hci_dev *hdev = req->hdev;
4088 u8 scan = 0;
4089
4090 /* Ensure that fast connectable is disabled. This function will
4091 * not do anything if the page scan parameters are already what
4092 * they should be.
4093 */
4094 write_fast_connectable(req, false);
4095
4096 if (test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
4097 scan |= SCAN_PAGE;
4098 if (test_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
4099 scan |= SCAN_INQUIRY;
4100
4101 if (scan)
4102 hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
4103}
4104
Johan Hedberg0663ca22013-10-02 13:43:14 +03004105static void set_bredr_complete(struct hci_dev *hdev, u8 status)
4106{
4107 struct pending_cmd *cmd;
4108
4109 BT_DBG("status 0x%02x", status);
4110
4111 hci_dev_lock(hdev);
4112
4113 cmd = mgmt_pending_find(MGMT_OP_SET_BREDR, hdev);
4114 if (!cmd)
4115 goto unlock;
4116
4117 if (status) {
4118 u8 mgmt_err = mgmt_status(status);
4119
4120 /* We need to restore the flag if related HCI commands
4121 * failed.
4122 */
4123 clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags);
4124
4125 cmd_status(cmd->sk, cmd->index, cmd->opcode, mgmt_err);
4126 } else {
4127 send_settings_rsp(cmd->sk, MGMT_OP_SET_BREDR, hdev);
4128 new_settings(hdev, cmd->sk);
4129 }
4130
4131 mgmt_pending_remove(cmd);
4132
4133unlock:
4134 hci_dev_unlock(hdev);
4135}
4136
4137static int set_bredr(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
4138{
4139 struct mgmt_mode *cp = data;
4140 struct pending_cmd *cmd;
4141 struct hci_request req;
4142 int err;
4143
4144 BT_DBG("request for %s", hdev->name);
4145
4146 if (!lmp_bredr_capable(hdev) || !lmp_le_capable(hdev))
4147 return cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
4148 MGMT_STATUS_NOT_SUPPORTED);
4149
4150 if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags))
4151 return cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
4152 MGMT_STATUS_REJECTED);
4153
4154 if (cp->val != 0x00 && cp->val != 0x01)
4155 return cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
4156 MGMT_STATUS_INVALID_PARAMS);
4157
4158 hci_dev_lock(hdev);
4159
4160 if (cp->val == test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) {
4161 err = send_settings_rsp(sk, MGMT_OP_SET_BREDR, hdev);
4162 goto unlock;
4163 }
4164
4165 if (!hdev_is_powered(hdev)) {
4166 if (!cp->val) {
Johan Hedberg0663ca22013-10-02 13:43:14 +03004167 clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
4168 clear_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
4169 clear_bit(HCI_LINK_SECURITY, &hdev->dev_flags);
4170 clear_bit(HCI_FAST_CONNECTABLE, &hdev->dev_flags);
4171 clear_bit(HCI_HS_ENABLED, &hdev->dev_flags);
4172 }
4173
4174 change_bit(HCI_BREDR_ENABLED, &hdev->dev_flags);
4175
4176 err = send_settings_rsp(sk, MGMT_OP_SET_BREDR, hdev);
4177 if (err < 0)
4178 goto unlock;
4179
4180 err = new_settings(hdev, sk);
4181 goto unlock;
4182 }
4183
4184 /* Reject disabling when powered on */
4185 if (!cp->val) {
4186 err = cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
4187 MGMT_STATUS_REJECTED);
4188 goto unlock;
4189 }
4190
4191 if (mgmt_pending_find(MGMT_OP_SET_BREDR, hdev)) {
4192 err = cmd_status(sk, hdev->id, MGMT_OP_SET_BREDR,
4193 MGMT_STATUS_BUSY);
4194 goto unlock;
4195 }
4196
4197 cmd = mgmt_pending_add(sk, MGMT_OP_SET_BREDR, hdev, data, len);
4198 if (!cmd) {
4199 err = -ENOMEM;
4200 goto unlock;
4201 }
4202
Marcel Holtmann5947f4b2013-10-16 00:16:50 -07004203 /* We need to flip the bit already here so that update_adv_data
Johan Hedberg0663ca22013-10-02 13:43:14 +03004204 * generates the correct flags.
4205 */
4206 set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags);
4207
4208 hci_req_init(&req, hdev);
Johan Hedbergaa8af462013-10-14 21:15:26 +03004209
4210 if (test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
4211 set_bredr_scan(&req);
4212
Marcel Holtmannf14d8f62013-10-16 00:16:48 -07004213 /* Since only the advertising data flags will change, there
4214 * is no need to update the scan response data.
4215 */
Marcel Holtmann5947f4b2013-10-16 00:16:50 -07004216 update_adv_data(&req);
Johan Hedbergaa8af462013-10-14 21:15:26 +03004217
Johan Hedberg0663ca22013-10-02 13:43:14 +03004218 err = hci_req_run(&req, set_bredr_complete);
4219 if (err < 0)
4220 mgmt_pending_remove(cmd);
4221
4222unlock:
4223 hci_dev_unlock(hdev);
4224 return err;
4225}
4226
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08004227static int set_secure_conn(struct sock *sk, struct hci_dev *hdev,
4228 void *data, u16 len)
4229{
4230 struct mgmt_mode *cp = data;
4231 struct pending_cmd *cmd;
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08004232 u8 val, status;
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08004233 int err;
4234
4235 BT_DBG("request for %s", hdev->name);
4236
4237 status = mgmt_bredr_support(hdev);
4238 if (status)
4239 return cmd_status(sk, hdev->id, MGMT_OP_SET_SECURE_CONN,
4240 status);
4241
Marcel Holtmann5afeac142014-01-10 02:07:27 -08004242 if (!lmp_sc_capable(hdev) &&
4243 !test_bit(HCI_FORCE_SC, &hdev->dev_flags))
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08004244 return cmd_status(sk, hdev->id, MGMT_OP_SET_SECURE_CONN,
4245 MGMT_STATUS_NOT_SUPPORTED);
4246
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08004247 if (cp->val != 0x00 && cp->val != 0x01 && cp->val != 0x02)
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08004248 return cmd_status(sk, hdev->id, MGMT_OP_SET_SECURE_CONN,
4249 MGMT_STATUS_INVALID_PARAMS);
4250
4251 hci_dev_lock(hdev);
4252
4253 if (!hdev_is_powered(hdev)) {
4254 bool changed;
4255
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08004256 if (cp->val) {
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08004257 changed = !test_and_set_bit(HCI_SC_ENABLED,
4258 &hdev->dev_flags);
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08004259 if (cp->val == 0x02)
4260 set_bit(HCI_SC_ONLY, &hdev->dev_flags);
4261 else
4262 clear_bit(HCI_SC_ONLY, &hdev->dev_flags);
4263 } else {
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08004264 changed = test_and_clear_bit(HCI_SC_ENABLED,
4265 &hdev->dev_flags);
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08004266 clear_bit(HCI_SC_ONLY, &hdev->dev_flags);
4267 }
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08004268
4269 err = send_settings_rsp(sk, MGMT_OP_SET_SECURE_CONN, hdev);
4270 if (err < 0)
4271 goto failed;
4272
4273 if (changed)
4274 err = new_settings(hdev, sk);
4275
4276 goto failed;
4277 }
4278
4279 if (mgmt_pending_find(MGMT_OP_SET_SECURE_CONN, hdev)) {
4280 err = cmd_status(sk, hdev->id, MGMT_OP_SET_SECURE_CONN,
4281 MGMT_STATUS_BUSY);
4282 goto failed;
4283 }
4284
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08004285 val = !!cp->val;
4286
4287 if (val == test_bit(HCI_SC_ENABLED, &hdev->dev_flags) &&
4288 (cp->val == 0x02) == test_bit(HCI_SC_ONLY, &hdev->dev_flags)) {
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08004289 err = send_settings_rsp(sk, MGMT_OP_SET_SECURE_CONN, hdev);
4290 goto failed;
4291 }
4292
4293 cmd = mgmt_pending_add(sk, MGMT_OP_SET_SECURE_CONN, hdev, data, len);
4294 if (!cmd) {
4295 err = -ENOMEM;
4296 goto failed;
4297 }
4298
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08004299 err = hci_send_cmd(hdev, HCI_OP_WRITE_SC_SUPPORT, 1, &val);
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08004300 if (err < 0) {
4301 mgmt_pending_remove(cmd);
4302 goto failed;
4303 }
4304
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08004305 if (cp->val == 0x02)
4306 set_bit(HCI_SC_ONLY, &hdev->dev_flags);
4307 else
4308 clear_bit(HCI_SC_ONLY, &hdev->dev_flags);
4309
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08004310failed:
4311 hci_dev_unlock(hdev);
4312 return err;
4313}
4314
Marcel Holtmann4e39ac82014-01-31 11:55:22 -08004315static int set_debug_keys(struct sock *sk, struct hci_dev *hdev,
4316 void *data, u16 len)
4317{
4318 struct mgmt_mode *cp = data;
4319 bool changed;
4320 int err;
4321
4322 BT_DBG("request for %s", hdev->name);
4323
4324 if (cp->val != 0x00 && cp->val != 0x01)
4325 return cmd_status(sk, hdev->id, MGMT_OP_SET_DEBUG_KEYS,
4326 MGMT_STATUS_INVALID_PARAMS);
4327
4328 hci_dev_lock(hdev);
4329
4330 if (cp->val)
4331 changed = !test_and_set_bit(HCI_DEBUG_KEYS, &hdev->dev_flags);
4332 else
4333 changed = test_and_clear_bit(HCI_DEBUG_KEYS, &hdev->dev_flags);
4334
4335 err = send_settings_rsp(sk, MGMT_OP_SET_DEBUG_KEYS, hdev);
4336 if (err < 0)
4337 goto unlock;
4338
4339 if (changed)
4340 err = new_settings(hdev, sk);
4341
4342unlock:
4343 hci_dev_unlock(hdev);
4344 return err;
4345}
4346
Johan Hedberg62b04cd2014-02-23 19:42:27 +02004347static int set_privacy(struct sock *sk, struct hci_dev *hdev, void *cp_data,
4348 u16 len)
4349{
4350 struct mgmt_cp_set_privacy *cp = cp_data;
4351 bool changed;
4352 int err;
4353
4354 BT_DBG("request for %s", hdev->name);
4355
4356 if (!lmp_le_capable(hdev))
4357 return cmd_status(sk, hdev->id, MGMT_OP_SET_PRIVACY,
4358 MGMT_STATUS_NOT_SUPPORTED);
4359
4360 if (cp->privacy != 0x00 && cp->privacy != 0x01)
4361 return cmd_status(sk, hdev->id, MGMT_OP_SET_PRIVACY,
4362 MGMT_STATUS_INVALID_PARAMS);
4363
4364 if (hdev_is_powered(hdev))
4365 return cmd_status(sk, hdev->id, MGMT_OP_SET_PRIVACY,
4366 MGMT_STATUS_REJECTED);
4367
4368 hci_dev_lock(hdev);
4369
Johan Hedbergc21c0ea2014-02-24 11:10:30 +02004370 /* If user space supports this command it is also expected to
4371 * handle IRKs. Therefore, set the HCI_RPA_RESOLVING flag.
4372 */
4373 set_bit(HCI_RPA_RESOLVING, &hdev->dev_flags);
4374
Johan Hedberg62b04cd2014-02-23 19:42:27 +02004375 if (cp->privacy) {
4376 changed = !test_and_set_bit(HCI_PRIVACY, &hdev->dev_flags);
4377 memcpy(hdev->irk, cp->irk, sizeof(hdev->irk));
4378 set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags);
4379 } else {
4380 changed = test_and_clear_bit(HCI_PRIVACY, &hdev->dev_flags);
4381 memset(hdev->irk, 0, sizeof(hdev->irk));
4382 clear_bit(HCI_RPA_EXPIRED, &hdev->dev_flags);
4383 }
4384
4385 err = send_settings_rsp(sk, MGMT_OP_SET_PRIVACY, hdev);
4386 if (err < 0)
4387 goto unlock;
4388
4389 if (changed)
4390 err = new_settings(hdev, sk);
4391
4392unlock:
4393 hci_dev_unlock(hdev);
4394 return err;
4395}
4396
Johan Hedberg41edf162014-02-18 10:19:35 +02004397static bool irk_is_valid(struct mgmt_irk_info *irk)
4398{
4399 switch (irk->addr.type) {
4400 case BDADDR_LE_PUBLIC:
4401 return true;
4402
4403 case BDADDR_LE_RANDOM:
4404 /* Two most significant bits shall be set */
4405 if ((irk->addr.bdaddr.b[5] & 0xc0) != 0xc0)
4406 return false;
4407 return true;
4408 }
4409
4410 return false;
4411}
4412
4413static int load_irks(struct sock *sk, struct hci_dev *hdev, void *cp_data,
4414 u16 len)
4415{
4416 struct mgmt_cp_load_irks *cp = cp_data;
4417 u16 irk_count, expected_len;
4418 int i, err;
4419
4420 BT_DBG("request for %s", hdev->name);
4421
4422 if (!lmp_le_capable(hdev))
4423 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_IRKS,
4424 MGMT_STATUS_NOT_SUPPORTED);
4425
4426 irk_count = __le16_to_cpu(cp->irk_count);
4427
4428 expected_len = sizeof(*cp) + irk_count * sizeof(struct mgmt_irk_info);
4429 if (expected_len != len) {
4430 BT_ERR("load_irks: expected %u bytes, got %u bytes",
Johan Hedberg2606ecb2014-03-07 15:04:13 +02004431 expected_len, len);
Johan Hedberg41edf162014-02-18 10:19:35 +02004432 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_IRKS,
4433 MGMT_STATUS_INVALID_PARAMS);
4434 }
4435
4436 BT_DBG("%s irk_count %u", hdev->name, irk_count);
4437
4438 for (i = 0; i < irk_count; i++) {
4439 struct mgmt_irk_info *key = &cp->irks[i];
4440
4441 if (!irk_is_valid(key))
4442 return cmd_status(sk, hdev->id,
4443 MGMT_OP_LOAD_IRKS,
4444 MGMT_STATUS_INVALID_PARAMS);
4445 }
4446
4447 hci_dev_lock(hdev);
4448
4449 hci_smp_irks_clear(hdev);
4450
4451 for (i = 0; i < irk_count; i++) {
4452 struct mgmt_irk_info *irk = &cp->irks[i];
4453 u8 addr_type;
4454
4455 if (irk->addr.type == BDADDR_LE_PUBLIC)
4456 addr_type = ADDR_LE_DEV_PUBLIC;
4457 else
4458 addr_type = ADDR_LE_DEV_RANDOM;
4459
4460 hci_add_irk(hdev, &irk->addr.bdaddr, addr_type, irk->val,
4461 BDADDR_ANY);
4462 }
4463
4464 set_bit(HCI_RPA_RESOLVING, &hdev->dev_flags);
4465
4466 err = cmd_complete(sk, hdev->id, MGMT_OP_LOAD_IRKS, 0, NULL, 0);
4467
4468 hci_dev_unlock(hdev);
4469
4470 return err;
4471}
4472
Johan Hedberg3f706b72013-01-20 14:27:16 +02004473static bool ltk_is_valid(struct mgmt_ltk_info *key)
4474{
4475 if (key->master != 0x00 && key->master != 0x01)
4476 return false;
Marcel Holtmann490cb0b2014-02-16 12:59:05 -08004477
4478 switch (key->addr.type) {
4479 case BDADDR_LE_PUBLIC:
4480 return true;
4481
4482 case BDADDR_LE_RANDOM:
4483 /* Two most significant bits shall be set */
4484 if ((key->addr.bdaddr.b[5] & 0xc0) != 0xc0)
4485 return false;
4486 return true;
4487 }
4488
4489 return false;
Johan Hedberg3f706b72013-01-20 14:27:16 +02004490}
4491
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004492static int load_long_term_keys(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004493 void *cp_data, u16 len)
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004494{
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004495 struct mgmt_cp_load_long_term_keys *cp = cp_data;
4496 u16 key_count, expected_len;
Johan Hedberg715a5bf2013-01-09 15:29:34 +02004497 int i, err;
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004498
Marcel Holtmanncf99ba12013-10-02 21:16:08 -07004499 BT_DBG("request for %s", hdev->name);
4500
4501 if (!lmp_le_capable(hdev))
4502 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LONG_TERM_KEYS,
4503 MGMT_STATUS_NOT_SUPPORTED);
4504
Marcel Holtmann1f350c82012-03-12 20:31:08 -07004505 key_count = __le16_to_cpu(cp->key_count);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004506
4507 expected_len = sizeof(*cp) + key_count *
4508 sizeof(struct mgmt_ltk_info);
4509 if (expected_len != len) {
4510 BT_ERR("load_keys: expected %u bytes, got %u bytes",
Johan Hedberg2606ecb2014-03-07 15:04:13 +02004511 expected_len, len);
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004512 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LONG_TERM_KEYS,
Johan Hedberge57e6192013-01-20 14:27:14 +02004513 MGMT_STATUS_INVALID_PARAMS);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004514 }
4515
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004516 BT_DBG("%s key_count %u", hdev->name, key_count);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004517
Johan Hedberg54ad6d82013-01-20 14:27:15 +02004518 for (i = 0; i < key_count; i++) {
4519 struct mgmt_ltk_info *key = &cp->keys[i];
4520
Johan Hedberg3f706b72013-01-20 14:27:16 +02004521 if (!ltk_is_valid(key))
Johan Hedberg54ad6d82013-01-20 14:27:15 +02004522 return cmd_status(sk, hdev->id,
4523 MGMT_OP_LOAD_LONG_TERM_KEYS,
4524 MGMT_STATUS_INVALID_PARAMS);
4525 }
4526
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004527 hci_dev_lock(hdev);
4528
4529 hci_smp_ltks_clear(hdev);
4530
4531 for (i = 0; i < key_count; i++) {
4532 struct mgmt_ltk_info *key = &cp->keys[i];
Marcel Holtmann79d95a12013-10-13 03:57:38 -07004533 u8 type, addr_type;
4534
4535 if (key->addr.type == BDADDR_LE_PUBLIC)
4536 addr_type = ADDR_LE_DEV_PUBLIC;
4537 else
4538 addr_type = ADDR_LE_DEV_RANDOM;
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004539
4540 if (key->master)
4541 type = HCI_SMP_LTK;
4542 else
4543 type = HCI_SMP_LTK_SLAVE;
4544
Johan Hedberg35d70272014-02-19 14:57:47 +02004545 hci_add_ltk(hdev, &key->addr.bdaddr, addr_type, type,
4546 key->type, key->val, key->enc_size, key->ediv,
4547 key->rand);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004548 }
4549
Johan Hedberg715a5bf2013-01-09 15:29:34 +02004550 err = cmd_complete(sk, hdev->id, MGMT_OP_LOAD_LONG_TERM_KEYS, 0,
4551 NULL, 0);
4552
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004553 hci_dev_unlock(hdev);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004554
Johan Hedberg715a5bf2013-01-09 15:29:34 +02004555 return err;
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03004556}
4557
Andrei Emeltchenko2e3c35e2012-03-14 18:54:15 +02004558static const struct mgmt_handler {
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004559 int (*func) (struct sock *sk, struct hci_dev *hdev, void *data,
4560 u16 data_len);
Johan Hedbergbe22b542012-03-01 22:24:41 +02004561 bool var_len;
4562 size_t data_len;
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02004563} mgmt_handlers[] = {
4564 { NULL }, /* 0x0000 (no command) */
Johan Hedbergbe22b542012-03-01 22:24:41 +02004565 { read_version, false, MGMT_READ_VERSION_SIZE },
4566 { read_commands, false, MGMT_READ_COMMANDS_SIZE },
4567 { read_index_list, false, MGMT_READ_INDEX_LIST_SIZE },
4568 { read_controller_info, false, MGMT_READ_INFO_SIZE },
4569 { set_powered, false, MGMT_SETTING_SIZE },
4570 { set_discoverable, false, MGMT_SET_DISCOVERABLE_SIZE },
4571 { set_connectable, false, MGMT_SETTING_SIZE },
4572 { set_fast_connectable, false, MGMT_SETTING_SIZE },
4573 { set_pairable, false, MGMT_SETTING_SIZE },
4574 { set_link_security, false, MGMT_SETTING_SIZE },
4575 { set_ssp, false, MGMT_SETTING_SIZE },
4576 { set_hs, false, MGMT_SETTING_SIZE },
4577 { set_le, false, MGMT_SETTING_SIZE },
4578 { set_dev_class, false, MGMT_SET_DEV_CLASS_SIZE },
4579 { set_local_name, false, MGMT_SET_LOCAL_NAME_SIZE },
4580 { add_uuid, false, MGMT_ADD_UUID_SIZE },
4581 { remove_uuid, false, MGMT_REMOVE_UUID_SIZE },
4582 { load_link_keys, true, MGMT_LOAD_LINK_KEYS_SIZE },
4583 { load_long_term_keys, true, MGMT_LOAD_LONG_TERM_KEYS_SIZE },
4584 { disconnect, false, MGMT_DISCONNECT_SIZE },
4585 { get_connections, false, MGMT_GET_CONNECTIONS_SIZE },
4586 { pin_code_reply, false, MGMT_PIN_CODE_REPLY_SIZE },
4587 { pin_code_neg_reply, false, MGMT_PIN_CODE_NEG_REPLY_SIZE },
4588 { set_io_capability, false, MGMT_SET_IO_CAPABILITY_SIZE },
4589 { pair_device, false, MGMT_PAIR_DEVICE_SIZE },
4590 { cancel_pair_device, false, MGMT_CANCEL_PAIR_DEVICE_SIZE },
4591 { unpair_device, false, MGMT_UNPAIR_DEVICE_SIZE },
4592 { user_confirm_reply, false, MGMT_USER_CONFIRM_REPLY_SIZE },
4593 { user_confirm_neg_reply, false, MGMT_USER_CONFIRM_NEG_REPLY_SIZE },
4594 { user_passkey_reply, false, MGMT_USER_PASSKEY_REPLY_SIZE },
4595 { user_passkey_neg_reply, false, MGMT_USER_PASSKEY_NEG_REPLY_SIZE },
4596 { read_local_oob_data, false, MGMT_READ_LOCAL_OOB_DATA_SIZE },
Marcel Holtmannec109112014-01-10 02:07:30 -08004597 { add_remote_oob_data, true, MGMT_ADD_REMOTE_OOB_DATA_SIZE },
Johan Hedbergbe22b542012-03-01 22:24:41 +02004598 { remove_remote_oob_data, false, MGMT_REMOVE_REMOTE_OOB_DATA_SIZE },
4599 { start_discovery, false, MGMT_START_DISCOVERY_SIZE },
4600 { stop_discovery, false, MGMT_STOP_DISCOVERY_SIZE },
4601 { confirm_name, false, MGMT_CONFIRM_NAME_SIZE },
4602 { block_device, false, MGMT_BLOCK_DEVICE_SIZE },
4603 { unblock_device, false, MGMT_UNBLOCK_DEVICE_SIZE },
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07004604 { set_device_id, false, MGMT_SET_DEVICE_ID_SIZE },
Johan Hedberg4375f102013-09-25 13:26:10 +03004605 { set_advertising, false, MGMT_SETTING_SIZE },
Johan Hedberg0663ca22013-10-02 13:43:14 +03004606 { set_bredr, false, MGMT_SETTING_SIZE },
Marcel Holtmannd13eafc2013-10-02 04:41:30 -07004607 { set_static_address, false, MGMT_SET_STATIC_ADDRESS_SIZE },
Marcel Holtmann14b49b92013-10-11 08:23:20 -07004608 { set_scan_params, false, MGMT_SET_SCAN_PARAMS_SIZE },
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08004609 { set_secure_conn, false, MGMT_SETTING_SIZE },
Marcel Holtmann4e39ac82014-01-31 11:55:22 -08004610 { set_debug_keys, false, MGMT_SETTING_SIZE },
Johan Hedberg62b04cd2014-02-23 19:42:27 +02004611 { set_privacy, false, MGMT_SET_PRIVACY_SIZE },
Johan Hedberg41edf162014-02-18 10:19:35 +02004612 { load_irks, true, MGMT_LOAD_IRKS_SIZE },
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02004613};
4614
4615
Johan Hedberg03811012010-12-08 00:21:06 +02004616int mgmt_control(struct sock *sk, struct msghdr *msg, size_t msglen)
4617{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03004618 void *buf;
4619 u8 *cp;
Johan Hedberg03811012010-12-08 00:21:06 +02004620 struct mgmt_hdr *hdr;
Szymon Janc4e51eae2011-02-25 19:05:48 +01004621 u16 opcode, index, len;
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004622 struct hci_dev *hdev = NULL;
Andrei Emeltchenko2e3c35e2012-03-14 18:54:15 +02004623 const struct mgmt_handler *handler;
Johan Hedberg03811012010-12-08 00:21:06 +02004624 int err;
4625
4626 BT_DBG("got %zu bytes", msglen);
4627
4628 if (msglen < sizeof(*hdr))
4629 return -EINVAL;
4630
Gustavo F. Padovane63a15e2011-04-04 18:56:53 -03004631 buf = kmalloc(msglen, GFP_KERNEL);
Johan Hedberg03811012010-12-08 00:21:06 +02004632 if (!buf)
4633 return -ENOMEM;
4634
4635 if (memcpy_fromiovec(buf, msg->msg_iov, msglen)) {
4636 err = -EFAULT;
4637 goto done;
4638 }
4639
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03004640 hdr = buf;
Marcel Holtmann1f350c82012-03-12 20:31:08 -07004641 opcode = __le16_to_cpu(hdr->opcode);
4642 index = __le16_to_cpu(hdr->index);
4643 len = __le16_to_cpu(hdr->len);
Johan Hedberg03811012010-12-08 00:21:06 +02004644
4645 if (len != msglen - sizeof(*hdr)) {
4646 err = -EINVAL;
4647 goto done;
4648 }
4649
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02004650 if (index != MGMT_INDEX_NONE) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004651 hdev = hci_dev_get(index);
4652 if (!hdev) {
4653 err = cmd_status(sk, index, opcode,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004654 MGMT_STATUS_INVALID_INDEX);
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004655 goto done;
4656 }
Marcel Holtmann0736cfa2013-08-26 21:40:51 -07004657
Johan Hedbergcebf4cf2013-10-10 18:06:04 +02004658 if (test_bit(HCI_SETUP, &hdev->dev_flags) ||
4659 test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) {
Marcel Holtmann0736cfa2013-08-26 21:40:51 -07004660 err = cmd_status(sk, index, opcode,
4661 MGMT_STATUS_INVALID_INDEX);
4662 goto done;
4663 }
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004664 }
4665
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02004666 if (opcode >= ARRAY_SIZE(mgmt_handlers) ||
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03004667 mgmt_handlers[opcode].func == NULL) {
Johan Hedberg03811012010-12-08 00:21:06 +02004668 BT_DBG("Unknown op %u", opcode);
Johan Hedbergca69b792011-11-11 18:10:00 +02004669 err = cmd_status(sk, index, opcode,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004670 MGMT_STATUS_UNKNOWN_COMMAND);
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02004671 goto done;
Johan Hedberg03811012010-12-08 00:21:06 +02004672 }
4673
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02004674 if ((hdev && opcode < MGMT_OP_READ_INFO) ||
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03004675 (!hdev && opcode >= MGMT_OP_READ_INFO)) {
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02004676 err = cmd_status(sk, index, opcode,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004677 MGMT_STATUS_INVALID_INDEX);
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02004678 goto done;
4679 }
4680
Johan Hedbergbe22b542012-03-01 22:24:41 +02004681 handler = &mgmt_handlers[opcode];
4682
4683 if ((handler->var_len && len < handler->data_len) ||
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03004684 (!handler->var_len && len != handler->data_len)) {
Johan Hedbergbe22b542012-03-01 22:24:41 +02004685 err = cmd_status(sk, index, opcode,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004686 MGMT_STATUS_INVALID_PARAMS);
Johan Hedbergbe22b542012-03-01 22:24:41 +02004687 goto done;
4688 }
4689
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02004690 if (hdev)
4691 mgmt_init_hdev(sk, hdev);
4692
4693 cp = buf + sizeof(*hdr);
4694
Johan Hedbergbe22b542012-03-01 22:24:41 +02004695 err = handler->func(sk, hdev, cp, len);
Johan Hedberge41d8b42010-12-13 21:07:03 +02004696 if (err < 0)
4697 goto done;
4698
Johan Hedberg03811012010-12-08 00:21:06 +02004699 err = msglen;
4700
4701done:
Johan Hedbergbdb6d972012-02-28 06:13:32 +02004702 if (hdev)
4703 hci_dev_put(hdev);
4704
Johan Hedberg03811012010-12-08 00:21:06 +02004705 kfree(buf);
4706 return err;
4707}
Johan Hedbergc71e97b2010-12-13 21:07:07 +02004708
Marcel Holtmannbf6b56d2013-10-06 23:55:45 -07004709void mgmt_index_added(struct hci_dev *hdev)
Johan Hedbergc71e97b2010-12-13 21:07:07 +02004710{
Marcel Holtmann1514b892013-10-06 08:25:01 -07004711 if (hdev->dev_type != HCI_BREDR)
Marcel Holtmannbf6b56d2013-10-06 23:55:45 -07004712 return;
Andrei Emeltchenkobb4b2a92012-07-19 17:03:40 +03004713
Marcel Holtmannbf6b56d2013-10-06 23:55:45 -07004714 mgmt_event(MGMT_EV_INDEX_ADDED, hdev, NULL, 0, NULL);
Johan Hedbergc71e97b2010-12-13 21:07:07 +02004715}
4716
Marcel Holtmannbf6b56d2013-10-06 23:55:45 -07004717void mgmt_index_removed(struct hci_dev *hdev)
Johan Hedbergc71e97b2010-12-13 21:07:07 +02004718{
Johan Hedberg5f159032012-03-02 03:13:19 +02004719 u8 status = MGMT_STATUS_INVALID_INDEX;
Johan Hedbergb24752f2011-11-03 14:40:33 +02004720
Marcel Holtmann1514b892013-10-06 08:25:01 -07004721 if (hdev->dev_type != HCI_BREDR)
Marcel Holtmannbf6b56d2013-10-06 23:55:45 -07004722 return;
Andrei Emeltchenkobb4b2a92012-07-19 17:03:40 +03004723
Johan Hedberg744cf192011-11-08 20:40:14 +02004724 mgmt_pending_foreach(0, hdev, cmd_status_rsp, &status);
Johan Hedbergb24752f2011-11-03 14:40:33 +02004725
Marcel Holtmannbf6b56d2013-10-06 23:55:45 -07004726 mgmt_event(MGMT_EV_INDEX_REMOVED, hdev, NULL, 0, NULL);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02004727}
4728
Andre Guedes6046dc32014-02-26 20:21:51 -03004729/* This function requires the caller holds hdev->lock */
4730static void restart_le_auto_conns(struct hci_dev *hdev)
4731{
4732 struct hci_conn_params *p;
4733
4734 list_for_each_entry(p, &hdev->le_conn_params, list) {
4735 if (p->auto_connect == HCI_AUTO_CONN_ALWAYS)
4736 hci_pend_le_conn_add(hdev, &p->addr, p->addr_type);
4737 }
4738}
4739
Johan Hedberg229ab392013-03-15 17:06:53 -05004740static void powered_complete(struct hci_dev *hdev, u8 status)
4741{
4742 struct cmd_lookup match = { NULL, hdev };
4743
4744 BT_DBG("status 0x%02x", status);
4745
4746 hci_dev_lock(hdev);
4747
Andre Guedes6046dc32014-02-26 20:21:51 -03004748 restart_le_auto_conns(hdev);
4749
Johan Hedberg229ab392013-03-15 17:06:53 -05004750 mgmt_pending_foreach(MGMT_OP_SET_POWERED, hdev, settings_rsp, &match);
4751
4752 new_settings(hdev, match.sk);
4753
4754 hci_dev_unlock(hdev);
4755
4756 if (match.sk)
4757 sock_put(match.sk);
4758}
4759
Johan Hedberg70da6242013-03-15 17:06:51 -05004760static int powered_update_hci(struct hci_dev *hdev)
4761{
Johan Hedberg890ea892013-03-15 17:06:52 -05004762 struct hci_request req;
Johan Hedberg70da6242013-03-15 17:06:51 -05004763 u8 link_sec;
4764
Johan Hedberg890ea892013-03-15 17:06:52 -05004765 hci_req_init(&req, hdev);
4766
Johan Hedberg70da6242013-03-15 17:06:51 -05004767 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags) &&
4768 !lmp_host_ssp_capable(hdev)) {
4769 u8 ssp = 1;
4770
Johan Hedberg890ea892013-03-15 17:06:52 -05004771 hci_req_add(&req, HCI_OP_WRITE_SSP_MODE, 1, &ssp);
Johan Hedberg70da6242013-03-15 17:06:51 -05004772 }
4773
Johan Hedbergc73eee92013-04-19 18:35:21 +03004774 if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags) &&
4775 lmp_bredr_capable(hdev)) {
Johan Hedberg70da6242013-03-15 17:06:51 -05004776 struct hci_cp_write_le_host_supported cp;
4777
4778 cp.le = 1;
4779 cp.simul = lmp_le_br_capable(hdev);
4780
4781 /* Check first if we already have the right
4782 * host state (host features set)
4783 */
4784 if (cp.le != lmp_host_le_capable(hdev) ||
4785 cp.simul != lmp_host_le_br_capable(hdev))
Johan Hedberg890ea892013-03-15 17:06:52 -05004786 hci_req_add(&req, HCI_OP_WRITE_LE_HOST_SUPPORTED,
4787 sizeof(cp), &cp);
Johan Hedberg70da6242013-03-15 17:06:51 -05004788 }
4789
Marcel Holtmannd13eafc2013-10-02 04:41:30 -07004790 if (lmp_le_capable(hdev)) {
Marcel Holtmann441ad2d2013-10-15 06:33:52 -07004791 /* Make sure the controller has a good default for
4792 * advertising data. This also applies to the case
4793 * where BR/EDR was toggled during the AUTO_OFF phase.
4794 */
Marcel Holtmannf14d8f62013-10-16 00:16:48 -07004795 if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) {
Marcel Holtmann5947f4b2013-10-16 00:16:50 -07004796 update_adv_data(&req);
Marcel Holtmannf14d8f62013-10-16 00:16:48 -07004797 update_scan_rsp_data(&req);
4798 }
Marcel Holtmann441ad2d2013-10-15 06:33:52 -07004799
Marcel Holtmannbba3aa52013-10-06 02:55:21 -07004800 if (test_bit(HCI_ADVERTISING, &hdev->dev_flags))
4801 enable_advertising(&req);
Johan Hedbergeeca6f82013-09-25 13:26:09 +03004802 }
4803
Johan Hedberg70da6242013-03-15 17:06:51 -05004804 link_sec = test_bit(HCI_LINK_SECURITY, &hdev->dev_flags);
4805 if (link_sec != test_bit(HCI_AUTH, &hdev->flags))
Johan Hedberg890ea892013-03-15 17:06:52 -05004806 hci_req_add(&req, HCI_OP_WRITE_AUTH_ENABLE,
4807 sizeof(link_sec), &link_sec);
Johan Hedberg70da6242013-03-15 17:06:51 -05004808
4809 if (lmp_bredr_capable(hdev)) {
Johan Hedberg56f87902013-10-02 13:43:13 +03004810 if (test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags))
4811 set_bredr_scan(&req);
Johan Hedberg890ea892013-03-15 17:06:52 -05004812 update_class(&req);
Johan Hedberg13928972013-03-15 17:07:00 -05004813 update_name(&req);
Johan Hedberg890ea892013-03-15 17:06:52 -05004814 update_eir(&req);
Johan Hedberg70da6242013-03-15 17:06:51 -05004815 }
4816
Johan Hedberg229ab392013-03-15 17:06:53 -05004817 return hci_req_run(&req, powered_complete);
Johan Hedberg70da6242013-03-15 17:06:51 -05004818}
4819
Johan Hedberg744cf192011-11-08 20:40:14 +02004820int mgmt_powered(struct hci_dev *hdev, u8 powered)
Johan Hedberg5add6af2010-12-16 10:00:37 +02004821{
Johan Hedberg76a7f3a2012-02-17 00:34:40 +02004822 struct cmd_lookup match = { NULL, hdev };
Johan Hedberg229ab392013-03-15 17:06:53 -05004823 u8 status_not_powered = MGMT_STATUS_NOT_POWERED;
4824 u8 zero_cod[] = { 0, 0, 0 };
Johan Hedberg7bb895d2012-02-17 01:20:00 +02004825 int err;
Johan Hedberg5add6af2010-12-16 10:00:37 +02004826
Johan Hedberg5e5282b2012-02-21 16:01:30 +02004827 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
4828 return 0;
4829
Johan Hedberg5e5282b2012-02-21 16:01:30 +02004830 if (powered) {
Johan Hedberg229ab392013-03-15 17:06:53 -05004831 if (powered_update_hci(hdev) == 0)
4832 return 0;
Johan Hedbergfe038882013-01-16 16:15:34 +02004833
Johan Hedberg229ab392013-03-15 17:06:53 -05004834 mgmt_pending_foreach(MGMT_OP_SET_POWERED, hdev, settings_rsp,
4835 &match);
4836 goto new_settings;
Johan Hedbergb24752f2011-11-03 14:40:33 +02004837 }
4838
Johan Hedberg229ab392013-03-15 17:06:53 -05004839 mgmt_pending_foreach(MGMT_OP_SET_POWERED, hdev, settings_rsp, &match);
4840 mgmt_pending_foreach(0, hdev, cmd_status_rsp, &status_not_powered);
4841
4842 if (memcmp(hdev->dev_class, zero_cod, sizeof(zero_cod)) != 0)
4843 mgmt_event(MGMT_EV_CLASS_OF_DEV_CHANGED, hdev,
4844 zero_cod, sizeof(zero_cod), NULL);
4845
4846new_settings:
Johan Hedbergbeadb2b2012-02-21 16:55:31 +02004847 err = new_settings(hdev, match.sk);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02004848
4849 if (match.sk)
4850 sock_put(match.sk);
4851
Johan Hedberg7bb895d2012-02-17 01:20:00 +02004852 return err;
Johan Hedberg5add6af2010-12-16 10:00:37 +02004853}
Johan Hedberg73f22f62010-12-29 16:00:25 +02004854
Marcel Holtmann3eec7052013-10-06 23:55:46 -07004855void mgmt_set_powered_failed(struct hci_dev *hdev, int err)
Johan Hedberg96570ff2013-05-29 09:51:29 +03004856{
4857 struct pending_cmd *cmd;
4858 u8 status;
4859
4860 cmd = mgmt_pending_find(MGMT_OP_SET_POWERED, hdev);
4861 if (!cmd)
Marcel Holtmann3eec7052013-10-06 23:55:46 -07004862 return;
Johan Hedberg96570ff2013-05-29 09:51:29 +03004863
4864 if (err == -ERFKILL)
4865 status = MGMT_STATUS_RFKILLED;
4866 else
4867 status = MGMT_STATUS_FAILED;
4868
Marcel Holtmann3eec7052013-10-06 23:55:46 -07004869 cmd_status(cmd->sk, hdev->id, MGMT_OP_SET_POWERED, status);
Johan Hedberg96570ff2013-05-29 09:51:29 +03004870
4871 mgmt_pending_remove(cmd);
Johan Hedberg96570ff2013-05-29 09:51:29 +03004872}
4873
Marcel Holtmannd1967ff2013-10-15 10:57:40 -07004874void mgmt_discoverable_timeout(struct hci_dev *hdev)
4875{
4876 struct hci_request req;
Marcel Holtmannd1967ff2013-10-15 10:57:40 -07004877
4878 hci_dev_lock(hdev);
4879
4880 /* When discoverable timeout triggers, then just make sure
4881 * the limited discoverable flag is cleared. Even in the case
4882 * of a timeout triggered from general discoverable, it is
4883 * safe to unconditionally clear the flag.
4884 */
4885 clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags);
Johan Hedberg9a43e252013-10-20 19:00:07 +03004886 clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
Marcel Holtmannd1967ff2013-10-15 10:57:40 -07004887
4888 hci_req_init(&req, hdev);
Johan Hedberg4b580612013-10-19 23:38:21 +03004889 if (test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) {
4890 u8 scan = SCAN_PAGE;
4891 hci_req_add(&req, HCI_OP_WRITE_SCAN_ENABLE,
4892 sizeof(scan), &scan);
4893 }
Marcel Holtmannd1967ff2013-10-15 10:57:40 -07004894 update_class(&req);
Johan Hedberg9a43e252013-10-20 19:00:07 +03004895 update_adv_data(&req);
Marcel Holtmannd1967ff2013-10-15 10:57:40 -07004896 hci_req_run(&req, NULL);
4897
4898 hdev->discov_timeout = 0;
4899
Johan Hedberg9a43e252013-10-20 19:00:07 +03004900 new_settings(hdev, NULL);
4901
Marcel Holtmannd1967ff2013-10-15 10:57:40 -07004902 hci_dev_unlock(hdev);
4903}
4904
Marcel Holtmann86a75642013-10-15 06:33:54 -07004905void mgmt_discoverable(struct hci_dev *hdev, u8 discoverable)
Johan Hedberg73f22f62010-12-29 16:00:25 +02004906{
Marcel Holtmann86a75642013-10-15 06:33:54 -07004907 bool changed;
Johan Hedberg73f22f62010-12-29 16:00:25 +02004908
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03004909 /* Nothing needed here if there's a pending command since that
4910 * commands request completion callback takes care of everything
4911 * necessary.
4912 */
4913 if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, hdev))
Marcel Holtmann86a75642013-10-15 06:33:54 -07004914 return;
Johan Hedbergbfaf8c92013-10-14 21:15:27 +03004915
Johan Hedbergbd107992014-02-24 14:52:19 +02004916 /* Powering off may clear the scan mode - don't let that interfere */
4917 if (!discoverable && mgmt_pending_find(MGMT_OP_SET_POWERED, hdev))
4918 return;
4919
Johan Hedberg9a43e252013-10-20 19:00:07 +03004920 if (discoverable) {
Marcel Holtmann86a75642013-10-15 06:33:54 -07004921 changed = !test_and_set_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
Johan Hedberg9a43e252013-10-20 19:00:07 +03004922 } else {
4923 clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags);
Marcel Holtmann86a75642013-10-15 06:33:54 -07004924 changed = test_and_clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
Johan Hedberg9a43e252013-10-20 19:00:07 +03004925 }
Johan Hedberg73f22f62010-12-29 16:00:25 +02004926
Johan Hedberg9a43e252013-10-20 19:00:07 +03004927 if (changed) {
4928 struct hci_request req;
4929
4930 /* In case this change in discoverable was triggered by
4931 * a disabling of connectable there could be a need to
4932 * update the advertising flags.
4933 */
4934 hci_req_init(&req, hdev);
4935 update_adv_data(&req);
4936 hci_req_run(&req, NULL);
4937
Marcel Holtmann86a75642013-10-15 06:33:54 -07004938 new_settings(hdev, NULL);
Johan Hedberg9a43e252013-10-20 19:00:07 +03004939 }
Johan Hedberg73f22f62010-12-29 16:00:25 +02004940}
Johan Hedberg9fbcbb42010-12-30 00:18:33 +02004941
Marcel Holtmanna3309162013-10-15 06:33:55 -07004942void mgmt_connectable(struct hci_dev *hdev, u8 connectable)
Johan Hedberg9fbcbb42010-12-30 00:18:33 +02004943{
Marcel Holtmanna3309162013-10-15 06:33:55 -07004944 bool changed;
Johan Hedberg9fbcbb42010-12-30 00:18:33 +02004945
Johan Hedbergd7b856f2013-10-14 16:20:04 +03004946 /* Nothing needed here if there's a pending command since that
4947 * commands request completion callback takes care of everything
4948 * necessary.
4949 */
4950 if (mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, hdev))
Marcel Holtmanna3309162013-10-15 06:33:55 -07004951 return;
Johan Hedbergd7b856f2013-10-14 16:20:04 +03004952
Johan Hedbergce3f24c2014-02-24 14:52:20 +02004953 /* Powering off may clear the scan mode - don't let that interfere */
4954 if (!connectable && mgmt_pending_find(MGMT_OP_SET_POWERED, hdev))
4955 return;
4956
Marcel Holtmanna3309162013-10-15 06:33:55 -07004957 if (connectable)
4958 changed = !test_and_set_bit(HCI_CONNECTABLE, &hdev->dev_flags);
4959 else
4960 changed = test_and_clear_bit(HCI_CONNECTABLE, &hdev->dev_flags);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +02004961
Johan Hedbergbeadb2b2012-02-21 16:55:31 +02004962 if (changed)
Marcel Holtmanna3309162013-10-15 06:33:55 -07004963 new_settings(hdev, NULL);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +02004964}
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02004965
Johan Hedberg778b2352014-02-24 14:52:17 +02004966void mgmt_advertising(struct hci_dev *hdev, u8 advertising)
4967{
Johan Hedberg7c4cfab2014-02-24 14:52:21 +02004968 /* Powering off may stop advertising - don't let that interfere */
4969 if (!advertising && mgmt_pending_find(MGMT_OP_SET_POWERED, hdev))
4970 return;
4971
Johan Hedberg778b2352014-02-24 14:52:17 +02004972 if (advertising)
4973 set_bit(HCI_ADVERTISING, &hdev->dev_flags);
4974 else
4975 clear_bit(HCI_ADVERTISING, &hdev->dev_flags);
4976}
4977
Marcel Holtmann4796e8a2013-10-15 06:33:56 -07004978void mgmt_write_scan_failed(struct hci_dev *hdev, u8 scan, u8 status)
Johan Hedberg2d7cee52011-11-07 22:16:03 +02004979{
Johan Hedbergca69b792011-11-11 18:10:00 +02004980 u8 mgmt_err = mgmt_status(status);
4981
Johan Hedberg2d7cee52011-11-07 22:16:03 +02004982 if (scan & SCAN_PAGE)
Johan Hedberg744cf192011-11-08 20:40:14 +02004983 mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE, hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004984 cmd_status_rsp, &mgmt_err);
Johan Hedberg2d7cee52011-11-07 22:16:03 +02004985
4986 if (scan & SCAN_INQUIRY)
Johan Hedberg744cf192011-11-08 20:40:14 +02004987 mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE, hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004988 cmd_status_rsp, &mgmt_err);
Johan Hedberg2d7cee52011-11-07 22:16:03 +02004989}
4990
Marcel Holtmanndc4a5ee2013-10-15 10:15:57 -07004991void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
4992 bool persistent)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02004993{
Johan Hedberg86742e12011-11-07 23:13:38 +02004994 struct mgmt_ev_new_link_key ev;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02004995
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03004996 memset(&ev, 0, sizeof(ev));
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02004997
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03004998 ev.store_hint = persistent;
Johan Hedbergd753fdc2012-02-17 14:06:34 +02004999 bacpy(&ev.key.addr.bdaddr, &key->bdaddr);
Andre Guedes591f47f2012-04-24 21:02:49 -03005000 ev.key.addr.type = BDADDR_BREDR;
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03005001 ev.key.type = key->type;
Andrei Emeltchenko9b3b4462012-05-23 11:31:20 +03005002 memcpy(ev.key.val, key->val, HCI_LINK_KEY_SIZE);
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03005003 ev.key.pin_len = key->pin_len;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02005004
Marcel Holtmanndc4a5ee2013-10-15 10:15:57 -07005005 mgmt_event(MGMT_EV_NEW_LINK_KEY, hdev, &ev, sizeof(ev), NULL);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02005006}
Johan Hedbergf7520542011-01-20 12:34:39 +02005007
Marcel Holtmann53ac6ab2014-03-09 23:38:42 -07005008void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent)
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03005009{
5010 struct mgmt_ev_new_long_term_key ev;
5011
5012 memset(&ev, 0, sizeof(ev));
5013
Marcel Holtmann5192d302014-02-19 17:11:58 -08005014 /* Devices using resolvable or non-resolvable random addresses
5015 * without providing an indentity resolving key don't require
5016 * to store long term keys. Their addresses will change the
5017 * next time around.
5018 *
5019 * Only when a remote device provides an identity address
5020 * make sure the long term key is stored. If the remote
5021 * identity is known, the long term keys are internally
5022 * mapped to the identity address. So allow static random
5023 * and public addresses here.
5024 */
Johan Hedbergba74b662014-02-19 14:57:45 +02005025 if (key->bdaddr_type == ADDR_LE_DEV_RANDOM &&
5026 (key->bdaddr.b[5] & 0xc0) != 0xc0)
5027 ev.store_hint = 0x00;
5028 else
Marcel Holtmann53ac6ab2014-03-09 23:38:42 -07005029 ev.store_hint = persistent;
Johan Hedbergba74b662014-02-19 14:57:45 +02005030
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03005031 bacpy(&ev.key.addr.bdaddr, &key->bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03005032 ev.key.addr.type = link_to_bdaddr(LE_LINK, key->bdaddr_type);
Marcel Holtmannd40f3ee2014-01-31 18:42:17 -08005033 ev.key.type = key->authenticated;
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03005034 ev.key.enc_size = key->enc_size;
5035 ev.key.ediv = key->ediv;
Marcel Holtmannfe39c7b2014-02-27 16:00:28 -08005036 ev.key.rand = key->rand;
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03005037
5038 if (key->type == HCI_SMP_LTK)
5039 ev.key.master = 1;
5040
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03005041 memcpy(ev.key.val, key->val, sizeof(key->val));
5042
Marcel Holtmann083368f2013-10-15 14:26:29 -07005043 mgmt_event(MGMT_EV_NEW_LONG_TERM_KEY, hdev, &ev, sizeof(ev), NULL);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03005044}
5045
Johan Hedberg95fbac82014-02-19 15:18:31 +02005046void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk)
5047{
5048 struct mgmt_ev_new_irk ev;
5049
5050 memset(&ev, 0, sizeof(ev));
5051
Marcel Holtmannbab6d1e2014-02-19 11:51:54 -08005052 /* For identity resolving keys from devices that are already
5053 * using a public address or static random address, do not
5054 * ask for storing this key. The identity resolving key really
5055 * is only mandatory for devices using resovlable random
5056 * addresses.
5057 *
5058 * Storing all identity resolving keys has the downside that
5059 * they will be also loaded on next boot of they system. More
5060 * identity resolving keys, means more time during scanning is
5061 * needed to actually resolve these addresses.
5062 */
5063 if (bacmp(&irk->rpa, BDADDR_ANY))
5064 ev.store_hint = 0x01;
5065 else
5066 ev.store_hint = 0x00;
5067
Johan Hedberg95fbac82014-02-19 15:18:31 +02005068 bacpy(&ev.rpa, &irk->rpa);
5069 bacpy(&ev.irk.addr.bdaddr, &irk->bdaddr);
5070 ev.irk.addr.type = link_to_bdaddr(LE_LINK, irk->addr_type);
5071 memcpy(ev.irk.val, irk->val, sizeof(irk->val));
5072
5073 mgmt_event(MGMT_EV_NEW_IRK, hdev, &ev, sizeof(ev), NULL);
5074}
5075
Marcel Holtmann53ac6ab2014-03-09 23:38:42 -07005076void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
5077 bool persistent)
Marcel Holtmann7ee4ea32014-03-09 12:19:17 -07005078{
5079 struct mgmt_ev_new_csrk ev;
5080
5081 memset(&ev, 0, sizeof(ev));
5082
5083 /* Devices using resolvable or non-resolvable random addresses
5084 * without providing an indentity resolving key don't require
5085 * to store signature resolving keys. Their addresses will change
5086 * the next time around.
5087 *
5088 * Only when a remote device provides an identity address
5089 * make sure the signature resolving key is stored. So allow
5090 * static random and public addresses here.
5091 */
5092 if (csrk->bdaddr_type == ADDR_LE_DEV_RANDOM &&
5093 (csrk->bdaddr.b[5] & 0xc0) != 0xc0)
5094 ev.store_hint = 0x00;
5095 else
Marcel Holtmann53ac6ab2014-03-09 23:38:42 -07005096 ev.store_hint = persistent;
Marcel Holtmann7ee4ea32014-03-09 12:19:17 -07005097
5098 bacpy(&ev.key.addr.bdaddr, &csrk->bdaddr);
5099 ev.key.addr.type = link_to_bdaddr(LE_LINK, csrk->bdaddr_type);
5100 ev.key.master = csrk->master;
5101 memcpy(ev.key.val, csrk->val, sizeof(csrk->val));
5102
5103 mgmt_event(MGMT_EV_NEW_CSRK, hdev, &ev, sizeof(ev), NULL);
5104}
5105
Marcel Holtmann94933992013-10-15 10:26:39 -07005106static inline u16 eir_append_data(u8 *eir, u16 eir_len, u8 type, u8 *data,
5107 u8 data_len)
5108{
5109 eir[eir_len++] = sizeof(type) + data_len;
5110 eir[eir_len++] = type;
5111 memcpy(&eir[eir_len], data, data_len);
5112 eir_len += data_len;
5113
5114 return eir_len;
5115}
5116
Marcel Holtmannecd90ae2013-10-06 23:55:49 -07005117void mgmt_device_connected(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
5118 u8 addr_type, u32 flags, u8 *name, u8 name_len,
5119 u8 *dev_class)
Johan Hedbergf7520542011-01-20 12:34:39 +02005120{
Johan Hedbergb644ba32012-01-17 21:48:47 +02005121 char buf[512];
5122 struct mgmt_ev_device_connected *ev = (void *) buf;
5123 u16 eir_len = 0;
Johan Hedbergf7520542011-01-20 12:34:39 +02005124
Johan Hedbergb644ba32012-01-17 21:48:47 +02005125 bacpy(&ev->addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03005126 ev->addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedbergf7520542011-01-20 12:34:39 +02005127
Johan Hedbergc95f0ba2012-02-23 22:54:38 +02005128 ev->flags = __cpu_to_le32(flags);
Johan Hedberg08c79b62012-02-23 22:31:51 +02005129
Johan Hedbergb644ba32012-01-17 21:48:47 +02005130 if (name_len > 0)
5131 eir_len = eir_append_data(ev->eir, 0, EIR_NAME_COMPLETE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005132 name, name_len);
Johan Hedbergb644ba32012-01-17 21:48:47 +02005133
5134 if (dev_class && memcmp(dev_class, "\0\0\0", 3) != 0)
Brian Gix53156382012-03-09 14:07:03 -08005135 eir_len = eir_append_data(ev->eir, eir_len,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005136 EIR_CLASS_OF_DEV, dev_class, 3);
Johan Hedbergb644ba32012-01-17 21:48:47 +02005137
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02005138 ev->eir_len = cpu_to_le16(eir_len);
Johan Hedbergb644ba32012-01-17 21:48:47 +02005139
Marcel Holtmannecd90ae2013-10-06 23:55:49 -07005140 mgmt_event(MGMT_EV_DEVICE_CONNECTED, hdev, buf,
5141 sizeof(*ev) + eir_len, NULL);
Johan Hedbergf7520542011-01-20 12:34:39 +02005142}
5143
Johan Hedberg8962ee72011-01-20 12:40:27 +02005144static void disconnect_rsp(struct pending_cmd *cmd, void *data)
5145{
Szymon Jancc68fb7f2011-03-22 13:12:19 +01005146 struct mgmt_cp_disconnect *cp = cmd->param;
Johan Hedberg8962ee72011-01-20 12:40:27 +02005147 struct sock **sk = data;
Johan Hedberga38528f2011-01-22 06:46:43 +02005148 struct mgmt_rp_disconnect rp;
Johan Hedberg8962ee72011-01-20 12:40:27 +02005149
Johan Hedberg88c3df12012-02-09 14:27:38 +02005150 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
5151 rp.addr.type = cp->addr.type;
Johan Hedberg8962ee72011-01-20 12:40:27 +02005152
Johan Hedbergaee9b2182012-02-18 15:07:59 +02005153 cmd_complete(cmd->sk, cmd->index, MGMT_OP_DISCONNECT, 0, &rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005154 sizeof(rp));
Johan Hedberg8962ee72011-01-20 12:40:27 +02005155
5156 *sk = cmd->sk;
5157 sock_hold(*sk);
5158
Johan Hedberga664b5b2011-02-19 12:06:02 -03005159 mgmt_pending_remove(cmd);
Johan Hedberg8962ee72011-01-20 12:40:27 +02005160}
5161
Johan Hedberg124f6e32012-02-09 13:50:12 +02005162static void unpair_device_rsp(struct pending_cmd *cmd, void *data)
Johan Hedberga8a1d192011-11-10 15:54:38 +02005163{
Johan Hedbergb1078ad2012-02-09 17:21:16 +02005164 struct hci_dev *hdev = data;
Johan Hedberg124f6e32012-02-09 13:50:12 +02005165 struct mgmt_cp_unpair_device *cp = cmd->param;
5166 struct mgmt_rp_unpair_device rp;
Johan Hedberga8a1d192011-11-10 15:54:38 +02005167
5168 memset(&rp, 0, sizeof(rp));
Johan Hedberg124f6e32012-02-09 13:50:12 +02005169 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
5170 rp.addr.type = cp->addr.type;
Johan Hedberga8a1d192011-11-10 15:54:38 +02005171
Johan Hedbergb1078ad2012-02-09 17:21:16 +02005172 device_unpaired(hdev, &cp->addr.bdaddr, cp->addr.type, cmd->sk);
5173
Johan Hedbergaee9b2182012-02-18 15:07:59 +02005174 cmd_complete(cmd->sk, cmd->index, cmd->opcode, 0, &rp, sizeof(rp));
Johan Hedberga8a1d192011-11-10 15:54:38 +02005175
5176 mgmt_pending_remove(cmd);
5177}
5178
Marcel Holtmann9b80ec52013-10-06 23:55:50 -07005179void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
Johan Hedberg12d4a3b2014-02-24 14:52:18 +02005180 u8 link_type, u8 addr_type, u8 reason,
5181 bool mgmt_connected)
Johan Hedbergf7520542011-01-20 12:34:39 +02005182{
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02005183 struct mgmt_ev_device_disconnected ev;
Johan Hedberg8b064a32014-02-24 14:52:22 +02005184 struct pending_cmd *power_off;
Johan Hedberg8962ee72011-01-20 12:40:27 +02005185 struct sock *sk = NULL;
Johan Hedberg8962ee72011-01-20 12:40:27 +02005186
Johan Hedberg8b064a32014-02-24 14:52:22 +02005187 power_off = mgmt_pending_find(MGMT_OP_SET_POWERED, hdev);
5188 if (power_off) {
5189 struct mgmt_mode *cp = power_off->param;
5190
5191 /* The connection is still in hci_conn_hash so test for 1
5192 * instead of 0 to know if this is the last one.
5193 */
Johan Hedberga3172b72014-02-28 09:33:44 +02005194 if (!cp->val && hci_conn_count(hdev) == 1) {
5195 cancel_delayed_work(&hdev->power_off);
Johan Hedberg8b064a32014-02-24 14:52:22 +02005196 queue_work(hdev->req_workqueue, &hdev->power_off.work);
Johan Hedberga3172b72014-02-28 09:33:44 +02005197 }
Johan Hedberg8b064a32014-02-24 14:52:22 +02005198 }
5199
Johan Hedberg12d4a3b2014-02-24 14:52:18 +02005200 if (!mgmt_connected)
5201 return;
5202
Andre Guedes57eb7762013-10-30 19:01:41 -03005203 if (link_type != ACL_LINK && link_type != LE_LINK)
5204 return;
5205
Johan Hedberg744cf192011-11-08 20:40:14 +02005206 mgmt_pending_foreach(MGMT_OP_DISCONNECT, hdev, disconnect_rsp, &sk);
Johan Hedbergf7520542011-01-20 12:34:39 +02005207
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02005208 bacpy(&ev.addr.bdaddr, bdaddr);
5209 ev.addr.type = link_to_bdaddr(link_type, addr_type);
5210 ev.reason = reason;
Johan Hedbergf7520542011-01-20 12:34:39 +02005211
Marcel Holtmann9b80ec52013-10-06 23:55:50 -07005212 mgmt_event(MGMT_EV_DEVICE_DISCONNECTED, hdev, &ev, sizeof(ev), sk);
Johan Hedberg8962ee72011-01-20 12:40:27 +02005213
5214 if (sk)
Szymon Jancd97dcb62012-03-16 16:02:56 +01005215 sock_put(sk);
Johan Hedberg8962ee72011-01-20 12:40:27 +02005216
Johan Hedberg124f6e32012-02-09 13:50:12 +02005217 mgmt_pending_foreach(MGMT_OP_UNPAIR_DEVICE, hdev, unpair_device_rsp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005218 hdev);
Johan Hedberg8962ee72011-01-20 12:40:27 +02005219}
5220
Marcel Holtmann78929242013-10-06 23:55:47 -07005221void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
5222 u8 link_type, u8 addr_type, u8 status)
Johan Hedberg8962ee72011-01-20 12:40:27 +02005223{
Andre Guedes3655bba2013-10-30 19:01:40 -03005224 u8 bdaddr_type = link_to_bdaddr(link_type, addr_type);
5225 struct mgmt_cp_disconnect *cp;
Johan Hedberg88c3df12012-02-09 14:27:38 +02005226 struct mgmt_rp_disconnect rp;
Johan Hedberg8962ee72011-01-20 12:40:27 +02005227 struct pending_cmd *cmd;
Johan Hedberg8962ee72011-01-20 12:40:27 +02005228
Jefferson Delfes36a75f12012-09-18 13:36:54 -04005229 mgmt_pending_foreach(MGMT_OP_UNPAIR_DEVICE, hdev, unpair_device_rsp,
5230 hdev);
5231
Johan Hedberg2e58ef32011-11-08 20:40:15 +02005232 cmd = mgmt_pending_find(MGMT_OP_DISCONNECT, hdev);
Johan Hedberg8962ee72011-01-20 12:40:27 +02005233 if (!cmd)
Marcel Holtmann78929242013-10-06 23:55:47 -07005234 return;
Johan Hedberg8962ee72011-01-20 12:40:27 +02005235
Andre Guedes3655bba2013-10-30 19:01:40 -03005236 cp = cmd->param;
5237
5238 if (bacmp(bdaddr, &cp->addr.bdaddr))
5239 return;
5240
5241 if (cp->addr.type != bdaddr_type)
5242 return;
5243
Johan Hedberg88c3df12012-02-09 14:27:38 +02005244 bacpy(&rp.addr.bdaddr, bdaddr);
Andre Guedes3655bba2013-10-30 19:01:40 -03005245 rp.addr.type = bdaddr_type;
Johan Hedberg37d9ef72011-11-10 15:54:39 +02005246
Marcel Holtmann78929242013-10-06 23:55:47 -07005247 cmd_complete(cmd->sk, cmd->index, MGMT_OP_DISCONNECT,
5248 mgmt_status(status), &rp, sizeof(rp));
Johan Hedberg8962ee72011-01-20 12:40:27 +02005249
Johan Hedberga664b5b2011-02-19 12:06:02 -03005250 mgmt_pending_remove(cmd);
Johan Hedbergf7520542011-01-20 12:34:39 +02005251}
Johan Hedberg17d5c042011-01-22 06:09:08 +02005252
Marcel Holtmann445608d2013-10-06 23:55:48 -07005253void mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
5254 u8 addr_type, u8 status)
Johan Hedberg17d5c042011-01-22 06:09:08 +02005255{
5256 struct mgmt_ev_connect_failed ev;
Johan Hedbergc9910d02014-02-27 14:35:12 +02005257 struct pending_cmd *power_off;
5258
5259 power_off = mgmt_pending_find(MGMT_OP_SET_POWERED, hdev);
5260 if (power_off) {
5261 struct mgmt_mode *cp = power_off->param;
5262
5263 /* The connection is still in hci_conn_hash so test for 1
5264 * instead of 0 to know if this is the last one.
5265 */
Johan Hedberga3172b72014-02-28 09:33:44 +02005266 if (!cp->val && hci_conn_count(hdev) == 1) {
5267 cancel_delayed_work(&hdev->power_off);
Johan Hedbergc9910d02014-02-27 14:35:12 +02005268 queue_work(hdev->req_workqueue, &hdev->power_off.work);
Johan Hedberga3172b72014-02-28 09:33:44 +02005269 }
Johan Hedbergc9910d02014-02-27 14:35:12 +02005270 }
Johan Hedberg17d5c042011-01-22 06:09:08 +02005271
Johan Hedberg4c659c32011-11-07 23:13:39 +02005272 bacpy(&ev.addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03005273 ev.addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedbergca69b792011-11-11 18:10:00 +02005274 ev.status = mgmt_status(status);
Johan Hedberg17d5c042011-01-22 06:09:08 +02005275
Marcel Holtmann445608d2013-10-06 23:55:48 -07005276 mgmt_event(MGMT_EV_CONNECT_FAILED, hdev, &ev, sizeof(ev), NULL);
Johan Hedberg17d5c042011-01-22 06:09:08 +02005277}
Johan Hedberg980e1a52011-01-22 06:10:07 +02005278
Marcel Holtmannce0e4a02013-10-15 14:26:20 -07005279void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure)
Johan Hedberg980e1a52011-01-22 06:10:07 +02005280{
5281 struct mgmt_ev_pin_code_request ev;
5282
Johan Hedbergd8457692012-02-17 14:24:57 +02005283 bacpy(&ev.addr.bdaddr, bdaddr);
Andre Guedes591f47f2012-04-24 21:02:49 -03005284 ev.addr.type = BDADDR_BREDR;
Waldemar Rymarkiewicza770bb52011-04-28 12:07:59 +02005285 ev.secure = secure;
Johan Hedberg980e1a52011-01-22 06:10:07 +02005286
Marcel Holtmannce0e4a02013-10-15 14:26:20 -07005287 mgmt_event(MGMT_EV_PIN_CODE_REQUEST, hdev, &ev, sizeof(ev), NULL);
Johan Hedberg980e1a52011-01-22 06:10:07 +02005288}
5289
Marcel Holtmanne669cf82013-10-15 14:26:21 -07005290void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
5291 u8 status)
Johan Hedberg980e1a52011-01-22 06:10:07 +02005292{
5293 struct pending_cmd *cmd;
Johan Hedbergac56fb12011-02-19 12:05:59 -03005294 struct mgmt_rp_pin_code_reply rp;
Johan Hedberg980e1a52011-01-22 06:10:07 +02005295
Johan Hedberg2e58ef32011-11-08 20:40:15 +02005296 cmd = mgmt_pending_find(MGMT_OP_PIN_CODE_REPLY, hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +02005297 if (!cmd)
Marcel Holtmanne669cf82013-10-15 14:26:21 -07005298 return;
Johan Hedberg980e1a52011-01-22 06:10:07 +02005299
Johan Hedbergd8457692012-02-17 14:24:57 +02005300 bacpy(&rp.addr.bdaddr, bdaddr);
Andre Guedes591f47f2012-04-24 21:02:49 -03005301 rp.addr.type = BDADDR_BREDR;
Johan Hedbergac56fb12011-02-19 12:05:59 -03005302
Marcel Holtmanne669cf82013-10-15 14:26:21 -07005303 cmd_complete(cmd->sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
5304 mgmt_status(status), &rp, sizeof(rp));
Johan Hedberg980e1a52011-01-22 06:10:07 +02005305
Johan Hedberga664b5b2011-02-19 12:06:02 -03005306 mgmt_pending_remove(cmd);
Johan Hedberg980e1a52011-01-22 06:10:07 +02005307}
5308
Marcel Holtmann3eb38522013-10-15 14:26:22 -07005309void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
5310 u8 status)
Johan Hedberg980e1a52011-01-22 06:10:07 +02005311{
5312 struct pending_cmd *cmd;
Johan Hedbergac56fb12011-02-19 12:05:59 -03005313 struct mgmt_rp_pin_code_reply rp;
Johan Hedberg980e1a52011-01-22 06:10:07 +02005314
Johan Hedberg2e58ef32011-11-08 20:40:15 +02005315 cmd = mgmt_pending_find(MGMT_OP_PIN_CODE_NEG_REPLY, hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +02005316 if (!cmd)
Marcel Holtmann3eb38522013-10-15 14:26:22 -07005317 return;
Johan Hedberg980e1a52011-01-22 06:10:07 +02005318
Johan Hedbergd8457692012-02-17 14:24:57 +02005319 bacpy(&rp.addr.bdaddr, bdaddr);
Andre Guedes591f47f2012-04-24 21:02:49 -03005320 rp.addr.type = BDADDR_BREDR;
Johan Hedbergac56fb12011-02-19 12:05:59 -03005321
Marcel Holtmann3eb38522013-10-15 14:26:22 -07005322 cmd_complete(cmd->sk, hdev->id, MGMT_OP_PIN_CODE_NEG_REPLY,
5323 mgmt_status(status), &rp, sizeof(rp));
Johan Hedberg980e1a52011-01-22 06:10:07 +02005324
Johan Hedberga664b5b2011-02-19 12:06:02 -03005325 mgmt_pending_remove(cmd);
Johan Hedberg980e1a52011-01-22 06:10:07 +02005326}
Johan Hedberga5c29682011-02-19 12:05:57 -03005327
Johan Hedberg744cf192011-11-08 20:40:14 +02005328int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
Johan Hedberg39adbff2014-03-20 08:18:14 +02005329 u8 link_type, u8 addr_type, u32 value,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005330 u8 confirm_hint)
Johan Hedberga5c29682011-02-19 12:05:57 -03005331{
5332 struct mgmt_ev_user_confirm_request ev;
5333
Johan Hedberg744cf192011-11-08 20:40:14 +02005334 BT_DBG("%s", hdev->name);
Johan Hedberga5c29682011-02-19 12:05:57 -03005335
Johan Hedberg272d90d2012-02-09 15:26:12 +02005336 bacpy(&ev.addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03005337 ev.addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedberg55bc1a32011-04-28 11:28:56 -07005338 ev.confirm_hint = confirm_hint;
Johan Hedberg39adbff2014-03-20 08:18:14 +02005339 ev.value = cpu_to_le32(value);
Johan Hedberga5c29682011-02-19 12:05:57 -03005340
Johan Hedberg744cf192011-11-08 20:40:14 +02005341 return mgmt_event(MGMT_EV_USER_CONFIRM_REQUEST, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005342 NULL);
Johan Hedberga5c29682011-02-19 12:05:57 -03005343}
5344
Johan Hedberg272d90d2012-02-09 15:26:12 +02005345int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03005346 u8 link_type, u8 addr_type)
Brian Gix604086b2011-11-23 08:28:33 -08005347{
5348 struct mgmt_ev_user_passkey_request ev;
5349
5350 BT_DBG("%s", hdev->name);
5351
Johan Hedberg272d90d2012-02-09 15:26:12 +02005352 bacpy(&ev.addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03005353 ev.addr.type = link_to_bdaddr(link_type, addr_type);
Brian Gix604086b2011-11-23 08:28:33 -08005354
5355 return mgmt_event(MGMT_EV_USER_PASSKEY_REQUEST, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005356 NULL);
Brian Gix604086b2011-11-23 08:28:33 -08005357}
5358
Brian Gix0df4c182011-11-16 13:53:13 -08005359static int user_pairing_resp_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03005360 u8 link_type, u8 addr_type, u8 status,
5361 u8 opcode)
Johan Hedberga5c29682011-02-19 12:05:57 -03005362{
5363 struct pending_cmd *cmd;
5364 struct mgmt_rp_user_confirm_reply rp;
5365 int err;
5366
Johan Hedberg2e58ef32011-11-08 20:40:15 +02005367 cmd = mgmt_pending_find(opcode, hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -03005368 if (!cmd)
5369 return -ENOENT;
5370
Johan Hedberg272d90d2012-02-09 15:26:12 +02005371 bacpy(&rp.addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03005372 rp.addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedbergaee9b2182012-02-18 15:07:59 +02005373 err = cmd_complete(cmd->sk, hdev->id, opcode, mgmt_status(status),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005374 &rp, sizeof(rp));
Johan Hedberga5c29682011-02-19 12:05:57 -03005375
Johan Hedberga664b5b2011-02-19 12:06:02 -03005376 mgmt_pending_remove(cmd);
Johan Hedberga5c29682011-02-19 12:05:57 -03005377
5378 return err;
5379}
5380
Johan Hedberg744cf192011-11-08 20:40:14 +02005381int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005382 u8 link_type, u8 addr_type, u8 status)
Johan Hedberga5c29682011-02-19 12:05:57 -03005383{
Johan Hedberg272d90d2012-02-09 15:26:12 +02005384 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005385 status, MGMT_OP_USER_CONFIRM_REPLY);
Johan Hedberga5c29682011-02-19 12:05:57 -03005386}
5387
Johan Hedberg272d90d2012-02-09 15:26:12 +02005388int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005389 u8 link_type, u8 addr_type, u8 status)
Johan Hedberga5c29682011-02-19 12:05:57 -03005390{
Johan Hedberg272d90d2012-02-09 15:26:12 +02005391 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03005392 status,
5393 MGMT_OP_USER_CONFIRM_NEG_REPLY);
Johan Hedberga5c29682011-02-19 12:05:57 -03005394}
Johan Hedberg2a611692011-02-19 12:06:00 -03005395
Brian Gix604086b2011-11-23 08:28:33 -08005396int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005397 u8 link_type, u8 addr_type, u8 status)
Brian Gix604086b2011-11-23 08:28:33 -08005398{
Johan Hedberg272d90d2012-02-09 15:26:12 +02005399 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005400 status, MGMT_OP_USER_PASSKEY_REPLY);
Brian Gix604086b2011-11-23 08:28:33 -08005401}
5402
Johan Hedberg272d90d2012-02-09 15:26:12 +02005403int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005404 u8 link_type, u8 addr_type, u8 status)
Brian Gix604086b2011-11-23 08:28:33 -08005405{
Johan Hedberg272d90d2012-02-09 15:26:12 +02005406 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03005407 status,
5408 MGMT_OP_USER_PASSKEY_NEG_REPLY);
Brian Gix604086b2011-11-23 08:28:33 -08005409}
5410
Johan Hedberg92a25252012-09-06 18:39:26 +03005411int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
5412 u8 link_type, u8 addr_type, u32 passkey,
5413 u8 entered)
5414{
5415 struct mgmt_ev_passkey_notify ev;
5416
5417 BT_DBG("%s", hdev->name);
5418
5419 bacpy(&ev.addr.bdaddr, bdaddr);
5420 ev.addr.type = link_to_bdaddr(link_type, addr_type);
5421 ev.passkey = __cpu_to_le32(passkey);
5422 ev.entered = entered;
5423
5424 return mgmt_event(MGMT_EV_PASSKEY_NOTIFY, hdev, &ev, sizeof(ev), NULL);
5425}
5426
Marcel Holtmanne5460992013-10-15 14:26:23 -07005427void mgmt_auth_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
5428 u8 addr_type, u8 status)
Johan Hedberg2a611692011-02-19 12:06:00 -03005429{
5430 struct mgmt_ev_auth_failed ev;
5431
Johan Hedbergbab73cb2012-02-09 16:07:29 +02005432 bacpy(&ev.addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03005433 ev.addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedbergca69b792011-11-11 18:10:00 +02005434 ev.status = mgmt_status(status);
Johan Hedberg2a611692011-02-19 12:06:00 -03005435
Marcel Holtmanne5460992013-10-15 14:26:23 -07005436 mgmt_event(MGMT_EV_AUTH_FAILED, hdev, &ev, sizeof(ev), NULL);
Johan Hedberg2a611692011-02-19 12:06:00 -03005437}
Johan Hedbergb312b1612011-03-16 14:29:37 +02005438
Marcel Holtmann464996a2013-10-15 14:26:24 -07005439void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status)
Johan Hedberg33ef95e2012-02-16 23:56:27 +02005440{
5441 struct cmd_lookup match = { NULL, hdev };
Marcel Holtmann464996a2013-10-15 14:26:24 -07005442 bool changed;
Johan Hedberg33ef95e2012-02-16 23:56:27 +02005443
5444 if (status) {
5445 u8 mgmt_err = mgmt_status(status);
5446 mgmt_pending_foreach(MGMT_OP_SET_LINK_SECURITY, hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005447 cmd_status_rsp, &mgmt_err);
Marcel Holtmann464996a2013-10-15 14:26:24 -07005448 return;
Johan Hedberg33ef95e2012-02-16 23:56:27 +02005449 }
5450
Marcel Holtmann464996a2013-10-15 14:26:24 -07005451 if (test_bit(HCI_AUTH, &hdev->flags))
5452 changed = !test_and_set_bit(HCI_LINK_SECURITY,
5453 &hdev->dev_flags);
5454 else
5455 changed = test_and_clear_bit(HCI_LINK_SECURITY,
5456 &hdev->dev_flags);
Johan Hedberg47990ea2012-02-22 11:58:37 +02005457
Johan Hedberg33ef95e2012-02-16 23:56:27 +02005458 mgmt_pending_foreach(MGMT_OP_SET_LINK_SECURITY, hdev, settings_rsp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005459 &match);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02005460
Johan Hedberg47990ea2012-02-22 11:58:37 +02005461 if (changed)
Marcel Holtmann464996a2013-10-15 14:26:24 -07005462 new_settings(hdev, match.sk);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02005463
5464 if (match.sk)
5465 sock_put(match.sk);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02005466}
5467
Johan Hedberg890ea892013-03-15 17:06:52 -05005468static void clear_eir(struct hci_request *req)
Johan Hedbergcacaf522012-02-21 00:52:42 +02005469{
Johan Hedberg890ea892013-03-15 17:06:52 -05005470 struct hci_dev *hdev = req->hdev;
Johan Hedbergcacaf522012-02-21 00:52:42 +02005471 struct hci_cp_write_eir cp;
5472
Johan Hedberg976eb202012-10-24 21:12:01 +03005473 if (!lmp_ext_inq_capable(hdev))
Johan Hedberg890ea892013-03-15 17:06:52 -05005474 return;
Johan Hedbergcacaf522012-02-21 00:52:42 +02005475
Johan Hedbergc80da272012-02-22 15:38:48 +02005476 memset(hdev->eir, 0, sizeof(hdev->eir));
5477
Johan Hedbergcacaf522012-02-21 00:52:42 +02005478 memset(&cp, 0, sizeof(cp));
5479
Johan Hedberg890ea892013-03-15 17:06:52 -05005480 hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp);
Johan Hedbergcacaf522012-02-21 00:52:42 +02005481}
5482
Marcel Holtmann3e248562013-10-15 14:26:25 -07005483void mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status)
Johan Hedberged2c4ee2012-02-17 00:56:28 +02005484{
5485 struct cmd_lookup match = { NULL, hdev };
Johan Hedberg890ea892013-03-15 17:06:52 -05005486 struct hci_request req;
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02005487 bool changed = false;
Johan Hedberged2c4ee2012-02-17 00:56:28 +02005488
5489 if (status) {
5490 u8 mgmt_err = mgmt_status(status);
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02005491
5492 if (enable && test_and_clear_bit(HCI_SSP_ENABLED,
Marcel Holtmann9ecb3e22013-10-10 03:08:11 -07005493 &hdev->dev_flags)) {
5494 clear_bit(HCI_HS_ENABLED, &hdev->dev_flags);
Marcel Holtmann3e248562013-10-15 14:26:25 -07005495 new_settings(hdev, NULL);
Marcel Holtmann9ecb3e22013-10-10 03:08:11 -07005496 }
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02005497
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005498 mgmt_pending_foreach(MGMT_OP_SET_SSP, hdev, cmd_status_rsp,
5499 &mgmt_err);
Marcel Holtmann3e248562013-10-15 14:26:25 -07005500 return;
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02005501 }
5502
5503 if (enable) {
Marcel Holtmann9ecb3e22013-10-10 03:08:11 -07005504 changed = !test_and_set_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02005505 } else {
Marcel Holtmann9ecb3e22013-10-10 03:08:11 -07005506 changed = test_and_clear_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
5507 if (!changed)
5508 changed = test_and_clear_bit(HCI_HS_ENABLED,
5509 &hdev->dev_flags);
5510 else
5511 clear_bit(HCI_HS_ENABLED, &hdev->dev_flags);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02005512 }
5513
5514 mgmt_pending_foreach(MGMT_OP_SET_SSP, hdev, settings_rsp, &match);
5515
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02005516 if (changed)
Marcel Holtmann3e248562013-10-15 14:26:25 -07005517 new_settings(hdev, match.sk);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02005518
Johan Hedberg5fc6ebb2012-02-22 15:10:59 +02005519 if (match.sk)
Johan Hedberged2c4ee2012-02-17 00:56:28 +02005520 sock_put(match.sk);
5521
Johan Hedberg890ea892013-03-15 17:06:52 -05005522 hci_req_init(&req, hdev);
5523
Johan Hedberg5fc6ebb2012-02-22 15:10:59 +02005524 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
Johan Hedberg890ea892013-03-15 17:06:52 -05005525 update_eir(&req);
Johan Hedberg5fc6ebb2012-02-22 15:10:59 +02005526 else
Johan Hedberg890ea892013-03-15 17:06:52 -05005527 clear_eir(&req);
5528
5529 hci_req_run(&req, NULL);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02005530}
5531
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08005532void mgmt_sc_enable_complete(struct hci_dev *hdev, u8 enable, u8 status)
5533{
5534 struct cmd_lookup match = { NULL, hdev };
5535 bool changed = false;
5536
5537 if (status) {
5538 u8 mgmt_err = mgmt_status(status);
5539
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08005540 if (enable) {
5541 if (test_and_clear_bit(HCI_SC_ENABLED,
5542 &hdev->dev_flags))
5543 new_settings(hdev, NULL);
5544 clear_bit(HCI_SC_ONLY, &hdev->dev_flags);
5545 }
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08005546
5547 mgmt_pending_foreach(MGMT_OP_SET_SECURE_CONN, hdev,
5548 cmd_status_rsp, &mgmt_err);
5549 return;
5550 }
5551
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08005552 if (enable) {
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08005553 changed = !test_and_set_bit(HCI_SC_ENABLED, &hdev->dev_flags);
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08005554 } else {
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08005555 changed = test_and_clear_bit(HCI_SC_ENABLED, &hdev->dev_flags);
Marcel Holtmann0ab04a92014-02-01 09:19:57 -08005556 clear_bit(HCI_SC_ONLY, &hdev->dev_flags);
5557 }
Marcel Holtmanneac83dc2014-01-10 02:07:23 -08005558
5559 mgmt_pending_foreach(MGMT_OP_SET_SECURE_CONN, hdev,
5560 settings_rsp, &match);
5561
5562 if (changed)
5563 new_settings(hdev, match.sk);
5564
5565 if (match.sk)
5566 sock_put(match.sk);
5567}
5568
Johan Hedberg92da6092013-03-15 17:06:55 -05005569static void sk_lookup(struct pending_cmd *cmd, void *data)
Johan Hedberg90e70452012-02-23 23:09:40 +02005570{
5571 struct cmd_lookup *match = data;
5572
Johan Hedberg90e70452012-02-23 23:09:40 +02005573 if (match->sk == NULL) {
5574 match->sk = cmd->sk;
5575 sock_hold(match->sk);
5576 }
Johan Hedberg90e70452012-02-23 23:09:40 +02005577}
5578
Marcel Holtmann4e1b0242013-10-15 14:26:26 -07005579void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
5580 u8 status)
Marcel Holtmann7f9a9032012-02-22 18:38:01 +01005581{
Johan Hedberg90e70452012-02-23 23:09:40 +02005582 struct cmd_lookup match = { NULL, hdev, mgmt_status(status) };
Marcel Holtmann7f9a9032012-02-22 18:38:01 +01005583
Johan Hedberg92da6092013-03-15 17:06:55 -05005584 mgmt_pending_foreach(MGMT_OP_SET_DEV_CLASS, hdev, sk_lookup, &match);
5585 mgmt_pending_foreach(MGMT_OP_ADD_UUID, hdev, sk_lookup, &match);
5586 mgmt_pending_foreach(MGMT_OP_REMOVE_UUID, hdev, sk_lookup, &match);
Johan Hedberg90e70452012-02-23 23:09:40 +02005587
5588 if (!status)
Marcel Holtmann4e1b0242013-10-15 14:26:26 -07005589 mgmt_event(MGMT_EV_CLASS_OF_DEV_CHANGED, hdev, dev_class, 3,
5590 NULL);
Johan Hedberg90e70452012-02-23 23:09:40 +02005591
5592 if (match.sk)
5593 sock_put(match.sk);
Marcel Holtmann7f9a9032012-02-22 18:38:01 +01005594}
5595
Marcel Holtmann7667da32013-10-15 14:26:27 -07005596void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status)
Johan Hedbergb312b1612011-03-16 14:29:37 +02005597{
Johan Hedbergb312b1612011-03-16 14:29:37 +02005598 struct mgmt_cp_set_local_name ev;
Johan Hedberg13928972013-03-15 17:07:00 -05005599 struct pending_cmd *cmd;
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02005600
Johan Hedberg13928972013-03-15 17:07:00 -05005601 if (status)
Marcel Holtmann7667da32013-10-15 14:26:27 -07005602 return;
Johan Hedbergb312b1612011-03-16 14:29:37 +02005603
5604 memset(&ev, 0, sizeof(ev));
5605 memcpy(ev.name, name, HCI_MAX_NAME_LENGTH);
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02005606 memcpy(ev.short_name, hdev->short_name, HCI_MAX_SHORT_NAME_LENGTH);
Johan Hedbergb312b1612011-03-16 14:29:37 +02005607
Johan Hedberg2e58ef32011-11-08 20:40:15 +02005608 cmd = mgmt_pending_find(MGMT_OP_SET_LOCAL_NAME, hdev);
Johan Hedberg13928972013-03-15 17:07:00 -05005609 if (!cmd) {
5610 memcpy(hdev->dev_name, name, sizeof(hdev->dev_name));
Johan Hedbergb312b1612011-03-16 14:29:37 +02005611
Johan Hedberg13928972013-03-15 17:07:00 -05005612 /* If this is a HCI command related to powering on the
5613 * HCI dev don't send any mgmt signals.
5614 */
5615 if (mgmt_pending_find(MGMT_OP_SET_POWERED, hdev))
Marcel Holtmann7667da32013-10-15 14:26:27 -07005616 return;
Johan Hedbergb312b1612011-03-16 14:29:37 +02005617 }
5618
Marcel Holtmann7667da32013-10-15 14:26:27 -07005619 mgmt_event(MGMT_EV_LOCAL_NAME_CHANGED, hdev, &ev, sizeof(ev),
5620 cmd ? cmd->sk : NULL);
Johan Hedbergb312b1612011-03-16 14:29:37 +02005621}
Szymon Jancc35938b2011-03-22 13:12:21 +01005622
Marcel Holtmann4d2d2792014-01-10 02:07:26 -08005623void mgmt_read_local_oob_data_complete(struct hci_dev *hdev, u8 *hash192,
5624 u8 *randomizer192, u8 *hash256,
5625 u8 *randomizer256, u8 status)
Szymon Jancc35938b2011-03-22 13:12:21 +01005626{
5627 struct pending_cmd *cmd;
Szymon Jancc35938b2011-03-22 13:12:21 +01005628
Johan Hedberg744cf192011-11-08 20:40:14 +02005629 BT_DBG("%s status %u", hdev->name, status);
Szymon Jancc35938b2011-03-22 13:12:21 +01005630
Johan Hedberg2e58ef32011-11-08 20:40:15 +02005631 cmd = mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev);
Szymon Jancc35938b2011-03-22 13:12:21 +01005632 if (!cmd)
Marcel Holtmann3edaf092013-10-15 14:26:28 -07005633 return;
Szymon Jancc35938b2011-03-22 13:12:21 +01005634
5635 if (status) {
Marcel Holtmann3edaf092013-10-15 14:26:28 -07005636 cmd_status(cmd->sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
5637 mgmt_status(status));
Szymon Jancc35938b2011-03-22 13:12:21 +01005638 } else {
Marcel Holtmann4d2d2792014-01-10 02:07:26 -08005639 if (test_bit(HCI_SC_ENABLED, &hdev->dev_flags) &&
5640 hash256 && randomizer256) {
5641 struct mgmt_rp_read_local_oob_ext_data rp;
Szymon Jancc35938b2011-03-22 13:12:21 +01005642
Marcel Holtmann4d2d2792014-01-10 02:07:26 -08005643 memcpy(rp.hash192, hash192, sizeof(rp.hash192));
5644 memcpy(rp.randomizer192, randomizer192,
5645 sizeof(rp.randomizer192));
Szymon Jancc35938b2011-03-22 13:12:21 +01005646
Marcel Holtmann4d2d2792014-01-10 02:07:26 -08005647 memcpy(rp.hash256, hash256, sizeof(rp.hash256));
5648 memcpy(rp.randomizer256, randomizer256,
5649 sizeof(rp.randomizer256));
5650
5651 cmd_complete(cmd->sk, hdev->id,
5652 MGMT_OP_READ_LOCAL_OOB_DATA, 0,
5653 &rp, sizeof(rp));
5654 } else {
5655 struct mgmt_rp_read_local_oob_data rp;
5656
5657 memcpy(rp.hash, hash192, sizeof(rp.hash));
5658 memcpy(rp.randomizer, randomizer192,
5659 sizeof(rp.randomizer));
5660
5661 cmd_complete(cmd->sk, hdev->id,
5662 MGMT_OP_READ_LOCAL_OOB_DATA, 0,
5663 &rp, sizeof(rp));
5664 }
Szymon Jancc35938b2011-03-22 13:12:21 +01005665 }
5666
5667 mgmt_pending_remove(cmd);
Szymon Jancc35938b2011-03-22 13:12:21 +01005668}
Johan Hedberge17acd42011-03-30 23:57:16 +03005669
Marcel Holtmann901801b2013-10-06 23:55:51 -07005670void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
5671 u8 addr_type, u8 *dev_class, s8 rssi, u8 cfm_name, u8
5672 ssp, u8 *eir, u16 eir_len)
Johan Hedberge17acd42011-03-30 23:57:16 +03005673{
Johan Hedberge319d2e2012-01-15 19:51:59 +02005674 char buf[512];
5675 struct mgmt_ev_device_found *ev = (void *) buf;
Johan Hedberg5cedbb82014-02-18 21:41:37 +02005676 struct smp_irk *irk;
Johan Hedberg1dc06092012-01-15 21:01:23 +02005677 size_t ev_size;
Johan Hedberge17acd42011-03-30 23:57:16 +03005678
Andre Guedes12602d02013-04-30 15:29:40 -03005679 if (!hci_discovery_active(hdev))
Marcel Holtmann901801b2013-10-06 23:55:51 -07005680 return;
Andre Guedes12602d02013-04-30 15:29:40 -03005681
Johan Hedberg1dc06092012-01-15 21:01:23 +02005682 /* Leave 5 bytes for a potential CoD field */
5683 if (sizeof(*ev) + eir_len + 5 > sizeof(buf))
Marcel Holtmann901801b2013-10-06 23:55:51 -07005684 return;
Andre Guedes7d262f82012-01-10 18:20:49 -03005685
Johan Hedberg1dc06092012-01-15 21:01:23 +02005686 memset(buf, 0, sizeof(buf));
5687
Johan Hedberg5cedbb82014-02-18 21:41:37 +02005688 irk = hci_get_irk(hdev, bdaddr, addr_type);
5689 if (irk) {
5690 bacpy(&ev->addr.bdaddr, &irk->bdaddr);
5691 ev->addr.type = link_to_bdaddr(link_type, irk->addr_type);
5692 } else {
5693 bacpy(&ev->addr.bdaddr, bdaddr);
5694 ev->addr.type = link_to_bdaddr(link_type, addr_type);
5695 }
5696
Johan Hedberge319d2e2012-01-15 19:51:59 +02005697 ev->rssi = rssi;
Johan Hedberg9a395a82012-02-23 00:00:32 +02005698 if (cfm_name)
Joe Perchesdcf4adb2014-03-12 10:52:35 -07005699 ev->flags |= cpu_to_le32(MGMT_DEV_FOUND_CONFIRM_NAME);
Johan Hedberg388fc8f2012-02-23 00:38:59 +02005700 if (!ssp)
Joe Perchesdcf4adb2014-03-12 10:52:35 -07005701 ev->flags |= cpu_to_le32(MGMT_DEV_FOUND_LEGACY_PAIRING);
Johan Hedberge17acd42011-03-30 23:57:16 +03005702
Johan Hedberg1dc06092012-01-15 21:01:23 +02005703 if (eir_len > 0)
Johan Hedberge319d2e2012-01-15 19:51:59 +02005704 memcpy(ev->eir, eir, eir_len);
Johan Hedberge17acd42011-03-30 23:57:16 +03005705
Johan Hedberg1dc06092012-01-15 21:01:23 +02005706 if (dev_class && !eir_has_data_type(ev->eir, eir_len, EIR_CLASS_OF_DEV))
5707 eir_len = eir_append_data(ev->eir, eir_len, EIR_CLASS_OF_DEV,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005708 dev_class, 3);
Johan Hedberg1dc06092012-01-15 21:01:23 +02005709
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02005710 ev->eir_len = cpu_to_le16(eir_len);
Johan Hedberg1dc06092012-01-15 21:01:23 +02005711 ev_size = sizeof(*ev) + eir_len;
Andre Guedesf8523592011-09-09 18:56:26 -03005712
Marcel Holtmann901801b2013-10-06 23:55:51 -07005713 mgmt_event(MGMT_EV_DEVICE_FOUND, hdev, ev, ev_size, NULL);
Johan Hedberge17acd42011-03-30 23:57:16 +03005714}
Johan Hedberga88a9652011-03-30 13:18:12 +03005715
Marcel Holtmann9cf12ae2013-10-06 23:55:52 -07005716void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
5717 u8 addr_type, s8 rssi, u8 *name, u8 name_len)
Johan Hedberga88a9652011-03-30 13:18:12 +03005718{
Johan Hedbergb644ba32012-01-17 21:48:47 +02005719 struct mgmt_ev_device_found *ev;
5720 char buf[sizeof(*ev) + HCI_MAX_NAME_LENGTH + 2];
5721 u16 eir_len;
Johan Hedberga88a9652011-03-30 13:18:12 +03005722
Johan Hedbergb644ba32012-01-17 21:48:47 +02005723 ev = (struct mgmt_ev_device_found *) buf;
Johan Hedberga88a9652011-03-30 13:18:12 +03005724
Johan Hedbergb644ba32012-01-17 21:48:47 +02005725 memset(buf, 0, sizeof(buf));
Johan Hedberga88a9652011-03-30 13:18:12 +03005726
Johan Hedbergb644ba32012-01-17 21:48:47 +02005727 bacpy(&ev->addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03005728 ev->addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedbergb644ba32012-01-17 21:48:47 +02005729 ev->rssi = rssi;
5730
5731 eir_len = eir_append_data(ev->eir, 0, EIR_NAME_COMPLETE, name,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005732 name_len);
Johan Hedbergb644ba32012-01-17 21:48:47 +02005733
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02005734 ev->eir_len = cpu_to_le16(eir_len);
Johan Hedbergb644ba32012-01-17 21:48:47 +02005735
Marcel Holtmann9cf12ae2013-10-06 23:55:52 -07005736 mgmt_event(MGMT_EV_DEVICE_FOUND, hdev, ev, sizeof(*ev) + eir_len, NULL);
Johan Hedberga88a9652011-03-30 13:18:12 +03005737}
Johan Hedberg314b2382011-04-27 10:29:57 -04005738
Marcel Holtmann2f1e0632013-10-06 23:55:53 -07005739void mgmt_discovering(struct hci_dev *hdev, u8 discovering)
Johan Hedberg314b2382011-04-27 10:29:57 -04005740{
Johan Hedbergf963e8e2012-02-20 23:30:44 +02005741 struct mgmt_ev_discovering ev;
Johan Hedberg164a6e72011-11-01 17:06:44 +02005742 struct pending_cmd *cmd;
5743
Andre Guedes343fb142011-11-22 17:14:19 -03005744 BT_DBG("%s discovering %u", hdev->name, discovering);
5745
Johan Hedberg164a6e72011-11-01 17:06:44 +02005746 if (discovering)
Johan Hedberg2e58ef32011-11-08 20:40:15 +02005747 cmd = mgmt_pending_find(MGMT_OP_START_DISCOVERY, hdev);
Johan Hedberg164a6e72011-11-01 17:06:44 +02005748 else
Johan Hedberg2e58ef32011-11-08 20:40:15 +02005749 cmd = mgmt_pending_find(MGMT_OP_STOP_DISCOVERY, hdev);
Johan Hedberg164a6e72011-11-01 17:06:44 +02005750
5751 if (cmd != NULL) {
Johan Hedbergf808e162012-02-19 12:52:07 +02005752 u8 type = hdev->discovery.type;
5753
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005754 cmd_complete(cmd->sk, hdev->id, cmd->opcode, 0, &type,
5755 sizeof(type));
Johan Hedberg164a6e72011-11-01 17:06:44 +02005756 mgmt_pending_remove(cmd);
5757 }
5758
Johan Hedbergf963e8e2012-02-20 23:30:44 +02005759 memset(&ev, 0, sizeof(ev));
5760 ev.type = hdev->discovery.type;
5761 ev.discovering = discovering;
5762
Marcel Holtmann2f1e0632013-10-06 23:55:53 -07005763 mgmt_event(MGMT_EV_DISCOVERING, hdev, &ev, sizeof(ev), NULL);
Johan Hedberg314b2382011-04-27 10:29:57 -04005764}
Antti Julku5e762442011-08-25 16:48:02 +03005765
Johan Hedberg88c1fe42012-02-09 15:56:11 +02005766int mgmt_device_blocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
Antti Julku5e762442011-08-25 16:48:02 +03005767{
5768 struct pending_cmd *cmd;
5769 struct mgmt_ev_device_blocked ev;
5770
Johan Hedberg2e58ef32011-11-08 20:40:15 +02005771 cmd = mgmt_pending_find(MGMT_OP_BLOCK_DEVICE, hdev);
Antti Julku5e762442011-08-25 16:48:02 +03005772
Johan Hedberg88c1fe42012-02-09 15:56:11 +02005773 bacpy(&ev.addr.bdaddr, bdaddr);
5774 ev.addr.type = type;
Antti Julku5e762442011-08-25 16:48:02 +03005775
Johan Hedberg744cf192011-11-08 20:40:14 +02005776 return mgmt_event(MGMT_EV_DEVICE_BLOCKED, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005777 cmd ? cmd->sk : NULL);
Antti Julku5e762442011-08-25 16:48:02 +03005778}
5779
Johan Hedberg88c1fe42012-02-09 15:56:11 +02005780int mgmt_device_unblocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
Antti Julku5e762442011-08-25 16:48:02 +03005781{
5782 struct pending_cmd *cmd;
5783 struct mgmt_ev_device_unblocked ev;
5784
Johan Hedberg2e58ef32011-11-08 20:40:15 +02005785 cmd = mgmt_pending_find(MGMT_OP_UNBLOCK_DEVICE, hdev);
Antti Julku5e762442011-08-25 16:48:02 +03005786
Johan Hedberg88c1fe42012-02-09 15:56:11 +02005787 bacpy(&ev.addr.bdaddr, bdaddr);
5788 ev.addr.type = type;
Antti Julku5e762442011-08-25 16:48:02 +03005789
Johan Hedberg744cf192011-11-08 20:40:14 +02005790 return mgmt_event(MGMT_EV_DEVICE_UNBLOCKED, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03005791 cmd ? cmd->sk : NULL);
Antti Julku5e762442011-08-25 16:48:02 +03005792}
Marcel Holtmann5976e602013-10-06 04:08:14 -07005793
5794static void adv_enable_complete(struct hci_dev *hdev, u8 status)
5795{
5796 BT_DBG("%s status %u", hdev->name, status);
5797
5798 /* Clear the advertising mgmt setting if we failed to re-enable it */
5799 if (status) {
5800 clear_bit(HCI_ADVERTISING, &hdev->dev_flags);
Marcel Holtmanna6d811e2013-10-06 04:11:12 -07005801 new_settings(hdev, NULL);
Marcel Holtmann5976e602013-10-06 04:08:14 -07005802 }
5803}
5804
5805void mgmt_reenable_advertising(struct hci_dev *hdev)
5806{
5807 struct hci_request req;
5808
Marcel Holtmannb145edc2013-10-10 09:47:54 -07005809 if (hci_conn_num(hdev, LE_LINK) > 0)
Marcel Holtmann5976e602013-10-06 04:08:14 -07005810 return;
5811
5812 if (!test_bit(HCI_ADVERTISING, &hdev->dev_flags))
5813 return;
5814
5815 hci_req_init(&req, hdev);
5816 enable_advertising(&req);
5817
5818 /* If this fails we have no option but to let user space know
5819 * that we've disabled advertising.
5820 */
5821 if (hci_req_run(&req, adv_enable_complete) < 0) {
5822 clear_bit(HCI_ADVERTISING, &hdev->dev_flags);
Marcel Holtmanna6d811e2013-10-06 04:11:12 -07005823 new_settings(hdev, NULL);
Marcel Holtmann5976e602013-10-06 04:08:14 -07005824 }
5825}