blob: 8a0bbb914bed3b50a3bbaed8b8e28c3759a30011 [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>
Brian Gix5fe57d92011-12-21 16:12:13 -080033#include <net/bluetooth/smp.h>
Johan Hedberg03811012010-12-08 00:21:06 +020034
Marcel Holtmannd7b7e792012-02-20 21:47:49 +010035bool enable_hs;
Marcel Holtmannd7b7e792012-02-20 21:47:49 +010036
Johan Hedberg2da9c552012-02-17 14:39:28 +020037#define MGMT_VERSION 1
Johan Hedberg38102852013-01-27 08:32:01 -060038#define MGMT_REVISION 3
Johan Hedberg02d98122010-12-13 21:07:04 +020039
Johan Hedberge70bb2e2012-02-13 16:59:33 +020040static const u16 mgmt_commands[] = {
41 MGMT_OP_READ_INDEX_LIST,
42 MGMT_OP_READ_INFO,
43 MGMT_OP_SET_POWERED,
44 MGMT_OP_SET_DISCOVERABLE,
45 MGMT_OP_SET_CONNECTABLE,
46 MGMT_OP_SET_FAST_CONNECTABLE,
47 MGMT_OP_SET_PAIRABLE,
48 MGMT_OP_SET_LINK_SECURITY,
49 MGMT_OP_SET_SSP,
50 MGMT_OP_SET_HS,
51 MGMT_OP_SET_LE,
52 MGMT_OP_SET_DEV_CLASS,
53 MGMT_OP_SET_LOCAL_NAME,
54 MGMT_OP_ADD_UUID,
55 MGMT_OP_REMOVE_UUID,
56 MGMT_OP_LOAD_LINK_KEYS,
57 MGMT_OP_LOAD_LONG_TERM_KEYS,
58 MGMT_OP_DISCONNECT,
59 MGMT_OP_GET_CONNECTIONS,
60 MGMT_OP_PIN_CODE_REPLY,
61 MGMT_OP_PIN_CODE_NEG_REPLY,
62 MGMT_OP_SET_IO_CAPABILITY,
63 MGMT_OP_PAIR_DEVICE,
64 MGMT_OP_CANCEL_PAIR_DEVICE,
65 MGMT_OP_UNPAIR_DEVICE,
66 MGMT_OP_USER_CONFIRM_REPLY,
67 MGMT_OP_USER_CONFIRM_NEG_REPLY,
68 MGMT_OP_USER_PASSKEY_REPLY,
69 MGMT_OP_USER_PASSKEY_NEG_REPLY,
70 MGMT_OP_READ_LOCAL_OOB_DATA,
71 MGMT_OP_ADD_REMOTE_OOB_DATA,
72 MGMT_OP_REMOVE_REMOTE_OOB_DATA,
73 MGMT_OP_START_DISCOVERY,
74 MGMT_OP_STOP_DISCOVERY,
75 MGMT_OP_CONFIRM_NAME,
76 MGMT_OP_BLOCK_DEVICE,
77 MGMT_OP_UNBLOCK_DEVICE,
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -070078 MGMT_OP_SET_DEVICE_ID,
Johan Hedberge70bb2e2012-02-13 16:59:33 +020079};
80
81static const u16 mgmt_events[] = {
82 MGMT_EV_CONTROLLER_ERROR,
83 MGMT_EV_INDEX_ADDED,
84 MGMT_EV_INDEX_REMOVED,
85 MGMT_EV_NEW_SETTINGS,
86 MGMT_EV_CLASS_OF_DEV_CHANGED,
87 MGMT_EV_LOCAL_NAME_CHANGED,
88 MGMT_EV_NEW_LINK_KEY,
89 MGMT_EV_NEW_LONG_TERM_KEY,
90 MGMT_EV_DEVICE_CONNECTED,
91 MGMT_EV_DEVICE_DISCONNECTED,
92 MGMT_EV_CONNECT_FAILED,
93 MGMT_EV_PIN_CODE_REQUEST,
94 MGMT_EV_USER_CONFIRM_REQUEST,
95 MGMT_EV_USER_PASSKEY_REQUEST,
96 MGMT_EV_AUTH_FAILED,
97 MGMT_EV_DEVICE_FOUND,
98 MGMT_EV_DISCOVERING,
99 MGMT_EV_DEVICE_BLOCKED,
100 MGMT_EV_DEVICE_UNBLOCKED,
101 MGMT_EV_DEVICE_UNPAIRED,
Johan Hedberg92a25252012-09-06 18:39:26 +0300102 MGMT_EV_PASSKEY_NOTIFY,
Johan Hedberge70bb2e2012-02-13 16:59:33 +0200103};
104
Andre Guedes3fd24152012-02-03 17:48:01 -0300105/*
106 * These LE scan and inquiry parameters were chosen according to LE General
107 * Discovery Procedure specification.
108 */
109#define LE_SCAN_TYPE 0x01
110#define LE_SCAN_WIN 0x12
111#define LE_SCAN_INT 0x12
112#define LE_SCAN_TIMEOUT_LE_ONLY 10240 /* TGAP(gen_disc_scan_min) */
Andre Guedes5e0452c2012-02-17 20:39:38 -0300113#define LE_SCAN_TIMEOUT_BREDR_LE 5120 /* TGAP(100)/2 */
Andre Guedes3fd24152012-02-03 17:48:01 -0300114
Andre Guedese8777522012-02-03 17:48:02 -0300115#define INQUIRY_LEN_BREDR 0x08 /* TGAP(100) */
Andre Guedes5e0452c2012-02-17 20:39:38 -0300116#define INQUIRY_LEN_BREDR_LE 0x04 /* TGAP(100)/2 */
Andre Guedes2519a1f2011-11-07 11:45:24 -0300117
Marcel Holtmann17b02e62012-03-01 14:32:37 -0800118#define CACHE_TIMEOUT msecs_to_jiffies(2 * 1000)
Johan Hedberg7d785252011-12-15 00:47:39 +0200119
Johan Hedberg4b34ee782012-02-21 14:13:02 +0200120#define hdev_is_powered(hdev) (test_bit(HCI_UP, &hdev->flags) && \
121 !test_bit(HCI_AUTO_OFF, &hdev->dev_flags))
122
Johan Hedbergeec8d2b2010-12-16 10:17:38 +0200123struct pending_cmd {
124 struct list_head list;
Johan Hedbergfc2f4b12011-11-09 13:58:56 +0200125 u16 opcode;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +0200126 int index;
Szymon Jancc68fb7f2011-03-22 13:12:19 +0100127 void *param;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +0200128 struct sock *sk;
Johan Hedberge9a416b2011-02-19 12:05:56 -0300129 void *user_data;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +0200130};
131
Johan Hedbergca69b792011-11-11 18:10:00 +0200132/* HCI to MGMT error code conversion table */
133static u8 mgmt_status_table[] = {
134 MGMT_STATUS_SUCCESS,
135 MGMT_STATUS_UNKNOWN_COMMAND, /* Unknown Command */
136 MGMT_STATUS_NOT_CONNECTED, /* No Connection */
137 MGMT_STATUS_FAILED, /* Hardware Failure */
138 MGMT_STATUS_CONNECT_FAILED, /* Page Timeout */
139 MGMT_STATUS_AUTH_FAILED, /* Authentication Failed */
140 MGMT_STATUS_NOT_PAIRED, /* PIN or Key Missing */
141 MGMT_STATUS_NO_RESOURCES, /* Memory Full */
142 MGMT_STATUS_TIMEOUT, /* Connection Timeout */
143 MGMT_STATUS_NO_RESOURCES, /* Max Number of Connections */
144 MGMT_STATUS_NO_RESOURCES, /* Max Number of SCO Connections */
145 MGMT_STATUS_ALREADY_CONNECTED, /* ACL Connection Exists */
146 MGMT_STATUS_BUSY, /* Command Disallowed */
147 MGMT_STATUS_NO_RESOURCES, /* Rejected Limited Resources */
148 MGMT_STATUS_REJECTED, /* Rejected Security */
149 MGMT_STATUS_REJECTED, /* Rejected Personal */
150 MGMT_STATUS_TIMEOUT, /* Host Timeout */
151 MGMT_STATUS_NOT_SUPPORTED, /* Unsupported Feature */
152 MGMT_STATUS_INVALID_PARAMS, /* Invalid Parameters */
153 MGMT_STATUS_DISCONNECTED, /* OE User Ended Connection */
154 MGMT_STATUS_NO_RESOURCES, /* OE Low Resources */
155 MGMT_STATUS_DISCONNECTED, /* OE Power Off */
156 MGMT_STATUS_DISCONNECTED, /* Connection Terminated */
157 MGMT_STATUS_BUSY, /* Repeated Attempts */
158 MGMT_STATUS_REJECTED, /* Pairing Not Allowed */
159 MGMT_STATUS_FAILED, /* Unknown LMP PDU */
160 MGMT_STATUS_NOT_SUPPORTED, /* Unsupported Remote Feature */
161 MGMT_STATUS_REJECTED, /* SCO Offset Rejected */
162 MGMT_STATUS_REJECTED, /* SCO Interval Rejected */
163 MGMT_STATUS_REJECTED, /* Air Mode Rejected */
164 MGMT_STATUS_INVALID_PARAMS, /* Invalid LMP Parameters */
165 MGMT_STATUS_FAILED, /* Unspecified Error */
166 MGMT_STATUS_NOT_SUPPORTED, /* Unsupported LMP Parameter Value */
167 MGMT_STATUS_FAILED, /* Role Change Not Allowed */
168 MGMT_STATUS_TIMEOUT, /* LMP Response Timeout */
169 MGMT_STATUS_FAILED, /* LMP Error Transaction Collision */
170 MGMT_STATUS_FAILED, /* LMP PDU Not Allowed */
171 MGMT_STATUS_REJECTED, /* Encryption Mode Not Accepted */
172 MGMT_STATUS_FAILED, /* Unit Link Key Used */
173 MGMT_STATUS_NOT_SUPPORTED, /* QoS Not Supported */
174 MGMT_STATUS_TIMEOUT, /* Instant Passed */
175 MGMT_STATUS_NOT_SUPPORTED, /* Pairing Not Supported */
176 MGMT_STATUS_FAILED, /* Transaction Collision */
177 MGMT_STATUS_INVALID_PARAMS, /* Unacceptable Parameter */
178 MGMT_STATUS_REJECTED, /* QoS Rejected */
179 MGMT_STATUS_NOT_SUPPORTED, /* Classification Not Supported */
180 MGMT_STATUS_REJECTED, /* Insufficient Security */
181 MGMT_STATUS_INVALID_PARAMS, /* Parameter Out Of Range */
182 MGMT_STATUS_BUSY, /* Role Switch Pending */
183 MGMT_STATUS_FAILED, /* Slot Violation */
184 MGMT_STATUS_FAILED, /* Role Switch Failed */
185 MGMT_STATUS_INVALID_PARAMS, /* EIR Too Large */
186 MGMT_STATUS_NOT_SUPPORTED, /* Simple Pairing Not Supported */
187 MGMT_STATUS_BUSY, /* Host Busy Pairing */
188 MGMT_STATUS_REJECTED, /* Rejected, No Suitable Channel */
189 MGMT_STATUS_BUSY, /* Controller Busy */
190 MGMT_STATUS_INVALID_PARAMS, /* Unsuitable Connection Interval */
191 MGMT_STATUS_TIMEOUT, /* Directed Advertising Timeout */
192 MGMT_STATUS_AUTH_FAILED, /* Terminated Due to MIC Failure */
193 MGMT_STATUS_CONNECT_FAILED, /* Connection Establishment Failed */
194 MGMT_STATUS_CONNECT_FAILED, /* MAC Connection Failed */
195};
196
Andrei Emeltchenkobb4b2a92012-07-19 17:03:40 +0300197bool mgmt_valid_hdev(struct hci_dev *hdev)
198{
199 return hdev->dev_type == HCI_BREDR;
200}
201
Johan Hedbergca69b792011-11-11 18:10:00 +0200202static u8 mgmt_status(u8 hci_status)
203{
204 if (hci_status < ARRAY_SIZE(mgmt_status_table))
205 return mgmt_status_table[hci_status];
206
207 return MGMT_STATUS_FAILED;
208}
209
Szymon Janc4e51eae2011-02-25 19:05:48 +0100210static int cmd_status(struct sock *sk, u16 index, u16 cmd, u8 status)
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200211{
212 struct sk_buff *skb;
213 struct mgmt_hdr *hdr;
214 struct mgmt_ev_cmd_status *ev;
Gustavo F. Padovan56b7d132011-10-14 19:20:01 -0300215 int err;
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200216
Szymon Janc34eb5252011-02-28 14:10:08 +0100217 BT_DBG("sock %p, index %u, cmd %u, status %u", sk, index, cmd, status);
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200218
Andre Guedes790eff42012-06-07 19:05:46 -0300219 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev), GFP_KERNEL);
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200220 if (!skb)
221 return -ENOMEM;
222
223 hdr = (void *) skb_put(skb, sizeof(*hdr));
224
Syam Sidhardhan612dfce2012-10-29 22:37:36 +0530225 hdr->opcode = __constant_cpu_to_le16(MGMT_EV_CMD_STATUS);
Szymon Janc4e51eae2011-02-25 19:05:48 +0100226 hdr->index = cpu_to_le16(index);
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200227 hdr->len = cpu_to_le16(sizeof(*ev));
228
229 ev = (void *) skb_put(skb, sizeof(*ev));
230 ev->status = status;
Marcel Holtmanneb55ef02012-03-14 18:08:46 +0200231 ev->opcode = cpu_to_le16(cmd);
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200232
Gustavo F. Padovan56b7d132011-10-14 19:20:01 -0300233 err = sock_queue_rcv_skb(sk, skb);
234 if (err < 0)
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200235 kfree_skb(skb);
236
Gustavo F. Padovan56b7d132011-10-14 19:20:01 -0300237 return err;
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200238}
239
Johan Hedbergaee9b212012-02-18 15:07:59 +0200240static int cmd_complete(struct sock *sk, u16 index, u16 cmd, u8 status,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300241 void *rp, size_t rp_len)
Johan Hedberg02d98122010-12-13 21:07:04 +0200242{
243 struct sk_buff *skb;
244 struct mgmt_hdr *hdr;
245 struct mgmt_ev_cmd_complete *ev;
Gustavo F. Padovan56b7d132011-10-14 19:20:01 -0300246 int err;
Johan Hedberg02d98122010-12-13 21:07:04 +0200247
248 BT_DBG("sock %p", sk);
249
Andre Guedes790eff42012-06-07 19:05:46 -0300250 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev) + rp_len, GFP_KERNEL);
Johan Hedberg02d98122010-12-13 21:07:04 +0200251 if (!skb)
252 return -ENOMEM;
253
254 hdr = (void *) skb_put(skb, sizeof(*hdr));
Johan Hedberga38528f2011-01-22 06:46:43 +0200255
Syam Sidhardhan612dfce2012-10-29 22:37:36 +0530256 hdr->opcode = __constant_cpu_to_le16(MGMT_EV_CMD_COMPLETE);
Szymon Janc4e51eae2011-02-25 19:05:48 +0100257 hdr->index = cpu_to_le16(index);
Johan Hedberga38528f2011-01-22 06:46:43 +0200258 hdr->len = cpu_to_le16(sizeof(*ev) + rp_len);
Johan Hedberg02d98122010-12-13 21:07:04 +0200259
Johan Hedberga38528f2011-01-22 06:46:43 +0200260 ev = (void *) skb_put(skb, sizeof(*ev) + rp_len);
Marcel Holtmanneb55ef02012-03-14 18:08:46 +0200261 ev->opcode = cpu_to_le16(cmd);
Johan Hedbergaee9b212012-02-18 15:07:59 +0200262 ev->status = status;
Szymon Janc8020c162011-02-28 14:09:50 +0100263
264 if (rp)
265 memcpy(ev->data, rp, rp_len);
Johan Hedberg02d98122010-12-13 21:07:04 +0200266
Gustavo F. Padovan56b7d132011-10-14 19:20:01 -0300267 err = sock_queue_rcv_skb(sk, skb);
268 if (err < 0)
Johan Hedberg02d98122010-12-13 21:07:04 +0200269 kfree_skb(skb);
270
Marcel Holtmanne5f0e152012-02-22 11:59:01 +0100271 return err;
Johan Hedberg02d98122010-12-13 21:07:04 +0200272}
273
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300274static int read_version(struct sock *sk, struct hci_dev *hdev, void *data,
275 u16 data_len)
Johan Hedberga38528f2011-01-22 06:46:43 +0200276{
277 struct mgmt_rp_read_version rp;
278
279 BT_DBG("sock %p", sk);
280
281 rp.version = MGMT_VERSION;
Marcel Holtmanneb55ef02012-03-14 18:08:46 +0200282 rp.revision = __constant_cpu_to_le16(MGMT_REVISION);
Johan Hedberga38528f2011-01-22 06:46:43 +0200283
Johan Hedbergaee9b212012-02-18 15:07:59 +0200284 return cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_VERSION, 0, &rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300285 sizeof(rp));
Johan Hedberga38528f2011-01-22 06:46:43 +0200286}
287
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300288static int read_commands(struct sock *sk, struct hci_dev *hdev, void *data,
289 u16 data_len)
Johan Hedberge70bb2e2012-02-13 16:59:33 +0200290{
291 struct mgmt_rp_read_commands *rp;
Marcel Holtmanneb55ef02012-03-14 18:08:46 +0200292 const u16 num_commands = ARRAY_SIZE(mgmt_commands);
293 const u16 num_events = ARRAY_SIZE(mgmt_events);
Andrei Emeltchenko2e3c35e2012-03-14 18:54:15 +0200294 __le16 *opcode;
Johan Hedberge70bb2e2012-02-13 16:59:33 +0200295 size_t rp_size;
296 int i, err;
297
298 BT_DBG("sock %p", sk);
299
300 rp_size = sizeof(*rp) + ((num_commands + num_events) * sizeof(u16));
301
302 rp = kmalloc(rp_size, GFP_KERNEL);
303 if (!rp)
304 return -ENOMEM;
305
Marcel Holtmanneb55ef02012-03-14 18:08:46 +0200306 rp->num_commands = __constant_cpu_to_le16(num_commands);
307 rp->num_events = __constant_cpu_to_le16(num_events);
Johan Hedberge70bb2e2012-02-13 16:59:33 +0200308
309 for (i = 0, opcode = rp->opcodes; i < num_commands; i++, opcode++)
310 put_unaligned_le16(mgmt_commands[i], opcode);
311
312 for (i = 0; i < num_events; i++, opcode++)
313 put_unaligned_le16(mgmt_events[i], opcode);
314
Johan Hedbergaee9b212012-02-18 15:07:59 +0200315 err = cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_COMMANDS, 0, rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300316 rp_size);
Johan Hedberge70bb2e2012-02-13 16:59:33 +0200317 kfree(rp);
318
319 return err;
320}
321
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300322static int read_index_list(struct sock *sk, struct hci_dev *hdev, void *data,
323 u16 data_len)
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200324{
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200325 struct mgmt_rp_read_index_list *rp;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200326 struct hci_dev *d;
Johan Hedberga38528f2011-01-22 06:46:43 +0200327 size_t rp_len;
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200328 u16 count;
Johan Hedberg476e44c2012-10-19 20:10:46 +0300329 int err;
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200330
331 BT_DBG("sock %p", sk);
332
333 read_lock(&hci_dev_list_lock);
334
335 count = 0;
Andrei Emeltchenkobb4b2a92012-07-19 17:03:40 +0300336 list_for_each_entry(d, &hci_dev_list, list) {
337 if (!mgmt_valid_hdev(d))
338 continue;
339
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200340 count++;
341 }
342
Johan Hedberga38528f2011-01-22 06:46:43 +0200343 rp_len = sizeof(*rp) + (2 * count);
344 rp = kmalloc(rp_len, GFP_ATOMIC);
345 if (!rp) {
Jesper Juhlb2c60d42011-01-14 00:18:49 +0100346 read_unlock(&hci_dev_list_lock);
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200347 return -ENOMEM;
Jesper Juhlb2c60d42011-01-14 00:18:49 +0100348 }
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200349
Johan Hedberg476e44c2012-10-19 20:10:46 +0300350 count = 0;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +0200351 list_for_each_entry(d, &hci_dev_list, list) {
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200352 if (test_bit(HCI_SETUP, &d->dev_flags))
Johan Hedbergab81cbf2010-12-15 13:53:18 +0200353 continue;
354
Andrei Emeltchenkobb4b2a92012-07-19 17:03:40 +0300355 if (!mgmt_valid_hdev(d))
356 continue;
357
Johan Hedberg476e44c2012-10-19 20:10:46 +0300358 rp->index[count++] = cpu_to_le16(d->id);
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200359 BT_DBG("Added hci%u", d->id);
360 }
361
Johan Hedberg476e44c2012-10-19 20:10:46 +0300362 rp->num_controllers = cpu_to_le16(count);
363 rp_len = sizeof(*rp) + (2 * count);
364
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200365 read_unlock(&hci_dev_list_lock);
366
Johan Hedbergaee9b212012-02-18 15:07:59 +0200367 err = cmd_complete(sk, MGMT_INDEX_NONE, MGMT_OP_READ_INDEX_LIST, 0, rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300368 rp_len);
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200369
Johan Hedberga38528f2011-01-22 06:46:43 +0200370 kfree(rp);
371
372 return err;
Johan Hedbergfaba42e2010-12-13 21:07:05 +0200373}
374
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200375static u32 get_supported_settings(struct hci_dev *hdev)
Johan Hedberg03811012010-12-08 00:21:06 +0200376{
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200377 u32 settings = 0;
Johan Hedberg03811012010-12-08 00:21:06 +0200378
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200379 settings |= MGMT_SETTING_POWERED;
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200380 settings |= MGMT_SETTING_PAIRABLE;
Johan Hedberg03811012010-12-08 00:21:06 +0200381
Andre Guedes9a1a1992012-07-24 15:03:48 -0300382 if (lmp_ssp_capable(hdev))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200383 settings |= MGMT_SETTING_SSP;
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200384
Andre Guedesed3fa312012-07-24 15:03:46 -0300385 if (lmp_bredr_capable(hdev)) {
Johan Hedberg33c525c2012-10-24 21:11:58 +0300386 settings |= MGMT_SETTING_CONNECTABLE;
387 settings |= MGMT_SETTING_FAST_CONNECTABLE;
388 settings |= MGMT_SETTING_DISCOVERABLE;
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200389 settings |= MGMT_SETTING_BREDR;
390 settings |= MGMT_SETTING_LINK_SECURITY;
391 }
Johan Hedbergab81cbf2010-12-15 13:53:18 +0200392
Marcel Holtmannd7b7e792012-02-20 21:47:49 +0100393 if (enable_hs)
394 settings |= MGMT_SETTING_HS;
395
Andre Guedesc383ddc2012-07-24 15:03:47 -0300396 if (lmp_le_capable(hdev))
Marcel Holtmann9d428202012-05-03 07:12:31 +0200397 settings |= MGMT_SETTING_LE;
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200398
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200399 return settings;
400}
Johan Hedbergebc99fe2011-01-04 11:54:26 +0200401
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200402static u32 get_current_settings(struct hci_dev *hdev)
403{
404 u32 settings = 0;
Johan Hedbergdc4fe302011-03-16 14:29:36 +0200405
Johan Hedbergf1f0eb02012-02-21 17:15:41 +0200406 if (hdev_is_powered(hdev))
Marcel Holtmannf0d4b782012-02-21 12:14:25 +0100407 settings |= MGMT_SETTING_POWERED;
408
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200409 if (test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200410 settings |= MGMT_SETTING_CONNECTABLE;
411
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200412 if (test_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200413 settings |= MGMT_SETTING_DISCOVERABLE;
414
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200415 if (test_bit(HCI_PAIRABLE, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200416 settings |= MGMT_SETTING_PAIRABLE;
417
Andre Guedesed3fa312012-07-24 15:03:46 -0300418 if (lmp_bredr_capable(hdev))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200419 settings |= MGMT_SETTING_BREDR;
420
Johan Hedberg06199cf2012-02-22 16:37:11 +0200421 if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200422 settings |= MGMT_SETTING_LE;
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200423
Johan Hedberg47990ea2012-02-22 11:58:37 +0200424 if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200425 settings |= MGMT_SETTING_LINK_SECURITY;
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200426
Johan Hedberg84bde9d2012-01-25 14:21:06 +0200427 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200428 settings |= MGMT_SETTING_SSP;
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200429
Johan Hedberg6d80dfd2012-02-20 23:50:38 +0200430 if (test_bit(HCI_HS_ENABLED, &hdev->dev_flags))
431 settings |= MGMT_SETTING_HS;
432
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200433 return settings;
Johan Hedbergc542a062011-01-26 13:11:03 +0200434}
435
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300436#define PNP_INFO_SVCLASS_ID 0x1200
437
Johan Hedberg213202e2013-01-27 00:31:33 +0200438static u8 *create_uuid16_list(struct hci_dev *hdev, u8 *data, ptrdiff_t len)
439{
440 u8 *ptr = data, *uuids_start = NULL;
441 struct bt_uuid *uuid;
442
443 if (len < 4)
444 return ptr;
445
446 list_for_each_entry(uuid, &hdev->uuids, list) {
447 u16 uuid16;
448
449 if (uuid->size != 16)
450 continue;
451
452 uuid16 = get_unaligned_le16(&uuid->uuid[12]);
453 if (uuid16 < 0x1100)
454 continue;
455
456 if (uuid16 == PNP_INFO_SVCLASS_ID)
457 continue;
458
459 if (!uuids_start) {
460 uuids_start = ptr;
461 uuids_start[0] = 1;
462 uuids_start[1] = EIR_UUID16_ALL;
463 ptr += 2;
464 }
465
466 /* Stop if not enough space to put next UUID */
467 if ((ptr - data) + sizeof(u16) > len) {
468 uuids_start[1] = EIR_UUID16_SOME;
469 break;
470 }
471
472 *ptr++ = (uuid16 & 0x00ff);
473 *ptr++ = (uuid16 & 0xff00) >> 8;
474 uuids_start[0] += sizeof(uuid16);
475 }
476
477 return ptr;
478}
479
Johan Hedbergcdf19632013-01-27 00:31:34 +0200480static u8 *create_uuid32_list(struct hci_dev *hdev, u8 *data, ptrdiff_t len)
481{
482 u8 *ptr = data, *uuids_start = NULL;
483 struct bt_uuid *uuid;
484
485 if (len < 6)
486 return ptr;
487
488 list_for_each_entry(uuid, &hdev->uuids, list) {
489 if (uuid->size != 32)
490 continue;
491
492 if (!uuids_start) {
493 uuids_start = ptr;
494 uuids_start[0] = 1;
495 uuids_start[1] = EIR_UUID32_ALL;
496 ptr += 2;
497 }
498
499 /* Stop if not enough space to put next UUID */
500 if ((ptr - data) + sizeof(u32) > len) {
501 uuids_start[1] = EIR_UUID32_SOME;
502 break;
503 }
504
505 memcpy(ptr, &uuid->uuid[12], sizeof(u32));
506 ptr += sizeof(u32);
507 uuids_start[0] += sizeof(u32);
508 }
509
510 return ptr;
511}
512
Johan Hedbergc00d5752013-01-27 00:31:35 +0200513static u8 *create_uuid128_list(struct hci_dev *hdev, u8 *data, ptrdiff_t len)
514{
515 u8 *ptr = data, *uuids_start = NULL;
516 struct bt_uuid *uuid;
517
518 if (len < 18)
519 return ptr;
520
521 list_for_each_entry(uuid, &hdev->uuids, list) {
522 if (uuid->size != 128)
523 continue;
524
525 if (!uuids_start) {
526 uuids_start = ptr;
527 uuids_start[0] = 1;
528 uuids_start[1] = EIR_UUID128_ALL;
529 ptr += 2;
530 }
531
532 /* Stop if not enough space to put next UUID */
533 if ((ptr - data) + 16 > len) {
534 uuids_start[1] = EIR_UUID128_SOME;
535 break;
536 }
537
538 memcpy(ptr, uuid->uuid, 16);
539 ptr += 16;
540 uuids_start[0] += 16;
541 }
542
543 return ptr;
544}
545
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300546static void create_eir(struct hci_dev *hdev, u8 *data)
547{
548 u8 *ptr = data;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300549 size_t name_len;
550
551 name_len = strlen(hdev->dev_name);
552
553 if (name_len > 0) {
554 /* EIR Data type */
555 if (name_len > 48) {
556 name_len = 48;
557 ptr[1] = EIR_NAME_SHORT;
558 } else
559 ptr[1] = EIR_NAME_COMPLETE;
560
561 /* EIR Data length */
562 ptr[0] = name_len + 1;
563
564 memcpy(ptr + 2, hdev->dev_name, name_len);
565
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300566 ptr += (name_len + 2);
567 }
568
Johan Hedbergbbaf4442012-11-08 01:22:59 +0100569 if (hdev->inq_tx_power != HCI_TX_POWER_INVALID) {
Marcel Holtmann91c4e9b2012-03-11 19:27:21 -0700570 ptr[0] = 2;
571 ptr[1] = EIR_TX_POWER;
572 ptr[2] = (u8) hdev->inq_tx_power;
573
Marcel Holtmann91c4e9b2012-03-11 19:27:21 -0700574 ptr += 3;
575 }
576
Marcel Holtmann2b9be132012-03-11 19:32:12 -0700577 if (hdev->devid_source > 0) {
578 ptr[0] = 9;
579 ptr[1] = EIR_DEVICE_ID;
580
581 put_unaligned_le16(hdev->devid_source, ptr + 2);
582 put_unaligned_le16(hdev->devid_vendor, ptr + 4);
583 put_unaligned_le16(hdev->devid_product, ptr + 6);
584 put_unaligned_le16(hdev->devid_version, ptr + 8);
585
Marcel Holtmann2b9be132012-03-11 19:32:12 -0700586 ptr += 10;
587 }
588
Johan Hedberg213202e2013-01-27 00:31:33 +0200589 ptr = create_uuid16_list(hdev, ptr, HCI_MAX_EIR_LENGTH - (ptr - data));
Johan Hedbergcdf19632013-01-27 00:31:34 +0200590 ptr = create_uuid32_list(hdev, ptr, HCI_MAX_EIR_LENGTH - (ptr - data));
Johan Hedbergc00d5752013-01-27 00:31:35 +0200591 ptr = create_uuid128_list(hdev, ptr, HCI_MAX_EIR_LENGTH - (ptr - data));
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300592}
593
Johan Hedberg890ea892013-03-15 17:06:52 -0500594static void update_eir(struct hci_request *req)
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300595{
Johan Hedberg890ea892013-03-15 17:06:52 -0500596 struct hci_dev *hdev = req->hdev;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300597 struct hci_cp_write_eir cp;
598
Johan Hedberg504c8dc2012-02-23 13:30:41 +0200599 if (!hdev_is_powered(hdev))
Johan Hedberg890ea892013-03-15 17:06:52 -0500600 return;
Johan Hedberg7770c4a2012-02-22 22:06:38 +0200601
Johan Hedberg976eb202012-10-24 21:12:01 +0300602 if (!lmp_ext_inq_capable(hdev))
Johan Hedberg890ea892013-03-15 17:06:52 -0500603 return;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300604
Johan Hedberg84bde9d2012-01-25 14:21:06 +0200605 if (!test_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
Johan Hedberg890ea892013-03-15 17:06:52 -0500606 return;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300607
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200608 if (test_bit(HCI_SERVICE_CACHE, &hdev->dev_flags))
Johan Hedberg890ea892013-03-15 17:06:52 -0500609 return;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300610
611 memset(&cp, 0, sizeof(cp));
612
613 create_eir(hdev, cp.data);
614
615 if (memcmp(cp.data, hdev->eir, sizeof(cp.data)) == 0)
Johan Hedberg890ea892013-03-15 17:06:52 -0500616 return;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300617
618 memcpy(hdev->eir, cp.data, sizeof(cp.data));
619
Johan Hedberg890ea892013-03-15 17:06:52 -0500620 hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp);
Johan Hedberg80a1e1d2011-03-28 14:07:23 +0300621}
622
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200623static u8 get_service_classes(struct hci_dev *hdev)
624{
Gustavo F. Padovan12dc0742011-10-14 19:32:56 -0300625 struct bt_uuid *uuid;
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200626 u8 val = 0;
627
Gustavo F. Padovan12dc0742011-10-14 19:32:56 -0300628 list_for_each_entry(uuid, &hdev->uuids, list)
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200629 val |= uuid->svc_hint;
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200630
631 return val;
632}
633
Johan Hedberg890ea892013-03-15 17:06:52 -0500634static void update_class(struct hci_request *req)
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200635{
Johan Hedberg890ea892013-03-15 17:06:52 -0500636 struct hci_dev *hdev = req->hdev;
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200637 u8 cod[3];
638
639 BT_DBG("%s", hdev->name);
640
Johan Hedberg504c8dc2012-02-23 13:30:41 +0200641 if (!hdev_is_powered(hdev))
Johan Hedberg890ea892013-03-15 17:06:52 -0500642 return;
Johan Hedberg7770c4a2012-02-22 22:06:38 +0200643
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200644 if (test_bit(HCI_SERVICE_CACHE, &hdev->dev_flags))
Johan Hedberg890ea892013-03-15 17:06:52 -0500645 return;
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200646
647 cod[0] = hdev->minor_class;
648 cod[1] = hdev->major_class;
649 cod[2] = get_service_classes(hdev);
650
651 if (memcmp(cod, hdev->dev_class, 3) == 0)
Johan Hedberg890ea892013-03-15 17:06:52 -0500652 return;
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200653
Johan Hedberg890ea892013-03-15 17:06:52 -0500654 hci_req_add(req, HCI_OP_WRITE_CLASS_OF_DEV, sizeof(cod), cod);
Johan Hedbergc95f0ba2012-02-23 22:54:38 +0200655
Johan Hedberg890ea892013-03-15 17:06:52 -0500656 set_bit(HCI_PENDING_CLASS, &hdev->dev_flags);
Johan Hedberg1aff6f02011-01-13 21:56:52 +0200657}
658
Johan Hedberg7d785252011-12-15 00:47:39 +0200659static void service_cache_off(struct work_struct *work)
660{
661 struct hci_dev *hdev = container_of(work, struct hci_dev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300662 service_cache.work);
Johan Hedberg890ea892013-03-15 17:06:52 -0500663 struct hci_request req;
Johan Hedberg7d785252011-12-15 00:47:39 +0200664
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200665 if (!test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags))
Johan Hedberg7d785252011-12-15 00:47:39 +0200666 return;
667
Johan Hedberg890ea892013-03-15 17:06:52 -0500668 hci_req_init(&req, hdev);
669
Johan Hedberg7d785252011-12-15 00:47:39 +0200670 hci_dev_lock(hdev);
671
Johan Hedberg890ea892013-03-15 17:06:52 -0500672 update_eir(&req);
673 update_class(&req);
Johan Hedberg7d785252011-12-15 00:47:39 +0200674
675 hci_dev_unlock(hdev);
Johan Hedberg890ea892013-03-15 17:06:52 -0500676
677 hci_req_run(&req, NULL);
Johan Hedberg7d785252011-12-15 00:47:39 +0200678}
679
Johan Hedberg6a919082012-02-28 06:17:26 +0200680static void mgmt_init_hdev(struct sock *sk, struct hci_dev *hdev)
Johan Hedberg7d785252011-12-15 00:47:39 +0200681{
Johan Hedberg4f87da82012-03-02 19:55:56 +0200682 if (test_and_set_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg6a919082012-02-28 06:17:26 +0200683 return;
684
Johan Hedberg4f87da82012-03-02 19:55:56 +0200685 INIT_DELAYED_WORK(&hdev->service_cache, service_cache_off);
Johan Hedberg7d785252011-12-15 00:47:39 +0200686
Johan Hedberg4f87da82012-03-02 19:55:56 +0200687 /* Non-mgmt controlled devices get this bit set
688 * implicitly so that pairing works for them, however
689 * for mgmt we require user-space to explicitly enable
690 * it
691 */
692 clear_bit(HCI_PAIRABLE, &hdev->dev_flags);
Johan Hedberg7d785252011-12-15 00:47:39 +0200693}
694
Johan Hedberg0f4e68c2012-02-28 17:18:30 +0200695static int read_controller_info(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300696 void *data, u16 data_len)
Johan Hedberg03811012010-12-08 00:21:06 +0200697{
698 struct mgmt_rp_read_info rp;
Johan Hedberg03811012010-12-08 00:21:06 +0200699
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200700 BT_DBG("sock %p %s", sk, hdev->name);
Johan Hedberg03811012010-12-08 00:21:06 +0200701
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300702 hci_dev_lock(hdev);
Johan Hedberg03811012010-12-08 00:21:06 +0200703
Johan Hedberg03811012010-12-08 00:21:06 +0200704 memset(&rp, 0, sizeof(rp));
705
Johan Hedberg03811012010-12-08 00:21:06 +0200706 bacpy(&rp.bdaddr, &hdev->bdaddr);
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200707
708 rp.version = hdev->hci_ver;
Marcel Holtmanneb55ef02012-03-14 18:08:46 +0200709 rp.manufacturer = cpu_to_le16(hdev->manufacturer);
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200710
711 rp.supported_settings = cpu_to_le32(get_supported_settings(hdev));
712 rp.current_settings = cpu_to_le32(get_current_settings(hdev));
713
714 memcpy(rp.dev_class, hdev->dev_class, 3);
Johan Hedberg03811012010-12-08 00:21:06 +0200715
716 memcpy(rp.name, hdev->dev_name, sizeof(hdev->dev_name));
Johan Hedberg27fcc362012-02-22 21:46:22 +0200717 memcpy(rp.short_name, hdev->short_name, sizeof(hdev->short_name));
Johan Hedberg03811012010-12-08 00:21:06 +0200718
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300719 hci_dev_unlock(hdev);
Johan Hedberg03811012010-12-08 00:21:06 +0200720
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200721 return cmd_complete(sk, hdev->id, MGMT_OP_READ_INFO, 0, &rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300722 sizeof(rp));
Johan Hedberg03811012010-12-08 00:21:06 +0200723}
724
725static void mgmt_pending_free(struct pending_cmd *cmd)
726{
727 sock_put(cmd->sk);
728 kfree(cmd->param);
729 kfree(cmd);
730}
731
732static struct pending_cmd *mgmt_pending_add(struct sock *sk, u16 opcode,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300733 struct hci_dev *hdev, void *data,
734 u16 len)
Johan Hedberg03811012010-12-08 00:21:06 +0200735{
736 struct pending_cmd *cmd;
737
Andre Guedes12b94562012-06-07 19:05:45 -0300738 cmd = kmalloc(sizeof(*cmd), GFP_KERNEL);
Johan Hedberg03811012010-12-08 00:21:06 +0200739 if (!cmd)
740 return NULL;
741
742 cmd->opcode = opcode;
743 cmd->index = hdev->id;
744
Andre Guedes12b94562012-06-07 19:05:45 -0300745 cmd->param = kmalloc(len, GFP_KERNEL);
Johan Hedberg03811012010-12-08 00:21:06 +0200746 if (!cmd->param) {
747 kfree(cmd);
748 return NULL;
749 }
750
751 if (data)
752 memcpy(cmd->param, data, len);
753
754 cmd->sk = sk;
755 sock_hold(sk);
756
757 list_add(&cmd->list, &hdev->mgmt_pending);
758
759 return cmd;
760}
761
762static void mgmt_pending_foreach(u16 opcode, struct hci_dev *hdev,
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300763 void (*cb)(struct pending_cmd *cmd,
764 void *data),
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300765 void *data)
Johan Hedberg03811012010-12-08 00:21:06 +0200766{
Andre Guedesa3d09352013-02-01 11:21:30 -0300767 struct pending_cmd *cmd, *tmp;
Johan Hedberg03811012010-12-08 00:21:06 +0200768
Andre Guedesa3d09352013-02-01 11:21:30 -0300769 list_for_each_entry_safe(cmd, tmp, &hdev->mgmt_pending, list) {
Johan Hedberg03811012010-12-08 00:21:06 +0200770 if (opcode > 0 && cmd->opcode != opcode)
771 continue;
772
773 cb(cmd, data);
774 }
775}
776
777static struct pending_cmd *mgmt_pending_find(u16 opcode, struct hci_dev *hdev)
778{
779 struct pending_cmd *cmd;
780
781 list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
782 if (cmd->opcode == opcode)
783 return cmd;
784 }
785
786 return NULL;
787}
788
789static void mgmt_pending_remove(struct pending_cmd *cmd)
790{
791 list_del(&cmd->list);
792 mgmt_pending_free(cmd);
793}
794
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200795static int send_settings_rsp(struct sock *sk, u16 opcode, struct hci_dev *hdev)
Johan Hedberg86805702011-11-11 16:18:52 +0200796{
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200797 __le32 settings = cpu_to_le32(get_current_settings(hdev));
Johan Hedberg86805702011-11-11 16:18:52 +0200798
Johan Hedbergaee9b212012-02-18 15:07:59 +0200799 return cmd_complete(sk, hdev->id, opcode, 0, &settings,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300800 sizeof(settings));
Johan Hedberg86805702011-11-11 16:18:52 +0200801}
802
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200803static int set_powered(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300804 u16 len)
Johan Hedberg03811012010-12-08 00:21:06 +0200805{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -0300806 struct mgmt_mode *cp = data;
Johan Hedberg03811012010-12-08 00:21:06 +0200807 struct pending_cmd *cmd;
Johan Hedberg4b34ee782012-02-21 14:13:02 +0200808 int err;
Johan Hedberg03811012010-12-08 00:21:06 +0200809
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200810 BT_DBG("request for %s", hdev->name);
Johan Hedberg03811012010-12-08 00:21:06 +0200811
Johan Hedberga7e80f22013-01-09 16:05:19 +0200812 if (cp->val != 0x00 && cp->val != 0x01)
813 return cmd_status(sk, hdev->id, MGMT_OP_SET_POWERED,
814 MGMT_STATUS_INVALID_PARAMS);
815
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300816 hci_dev_lock(hdev);
Johan Hedberg03811012010-12-08 00:21:06 +0200817
Marcel Holtmannf0d4b782012-02-21 12:14:25 +0100818 if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) {
819 cancel_delayed_work(&hdev->power_off);
820
821 if (cp->val) {
Johan Hedberga1d70452013-01-09 15:29:40 +0200822 mgmt_pending_add(sk, MGMT_OP_SET_POWERED, hdev,
823 data, len);
824 err = mgmt_powered(hdev, 1);
Marcel Holtmannf0d4b782012-02-21 12:14:25 +0100825 goto failed;
826 }
827 }
828
Johan Hedberg4b34ee782012-02-21 14:13:02 +0200829 if (!!cp->val == hdev_is_powered(hdev)) {
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200830 err = send_settings_rsp(sk, MGMT_OP_SET_POWERED, hdev);
Johan Hedberg03811012010-12-08 00:21:06 +0200831 goto failed;
832 }
833
834 if (mgmt_pending_find(MGMT_OP_SET_POWERED, hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200835 err = cmd_status(sk, hdev->id, MGMT_OP_SET_POWERED,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300836 MGMT_STATUS_BUSY);
Johan Hedberg03811012010-12-08 00:21:06 +0200837 goto failed;
838 }
839
840 cmd = mgmt_pending_add(sk, MGMT_OP_SET_POWERED, hdev, data, len);
841 if (!cmd) {
842 err = -ENOMEM;
843 goto failed;
844 }
845
846 if (cp->val)
Johan Hedberg19202572013-01-14 22:33:51 +0200847 queue_work(hdev->req_workqueue, &hdev->power_on);
Johan Hedberg03811012010-12-08 00:21:06 +0200848 else
Johan Hedberg19202572013-01-14 22:33:51 +0200849 queue_work(hdev->req_workqueue, &hdev->power_off.work);
Johan Hedberg03811012010-12-08 00:21:06 +0200850
851 err = 0;
852
853failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300854 hci_dev_unlock(hdev);
Johan Hedberg03811012010-12-08 00:21:06 +0200855 return err;
856}
857
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300858static int mgmt_event(u16 event, struct hci_dev *hdev, void *data, u16 data_len,
859 struct sock *skip_sk)
Johan Hedbergbeadb2b2012-02-21 16:55:31 +0200860{
861 struct sk_buff *skb;
862 struct mgmt_hdr *hdr;
863
Andre Guedes790eff42012-06-07 19:05:46 -0300864 skb = alloc_skb(sizeof(*hdr) + data_len, GFP_KERNEL);
Johan Hedbergbeadb2b2012-02-21 16:55:31 +0200865 if (!skb)
866 return -ENOMEM;
867
868 hdr = (void *) skb_put(skb, sizeof(*hdr));
869 hdr->opcode = cpu_to_le16(event);
870 if (hdev)
871 hdr->index = cpu_to_le16(hdev->id);
872 else
Syam Sidhardhan612dfce2012-10-29 22:37:36 +0530873 hdr->index = __constant_cpu_to_le16(MGMT_INDEX_NONE);
Johan Hedbergbeadb2b2012-02-21 16:55:31 +0200874 hdr->len = cpu_to_le16(data_len);
875
876 if (data)
877 memcpy(skb_put(skb, data_len), data, data_len);
878
Marcel Holtmann97e0bde2012-02-22 13:49:28 +0100879 /* Time stamp */
880 __net_timestamp(skb);
881
Johan Hedbergbeadb2b2012-02-21 16:55:31 +0200882 hci_send_to_control(skb, skip_sk);
883 kfree_skb(skb);
884
885 return 0;
886}
887
888static int new_settings(struct hci_dev *hdev, struct sock *skip)
889{
890 __le32 ev;
891
892 ev = cpu_to_le32(get_current_settings(hdev));
893
894 return mgmt_event(MGMT_EV_NEW_SETTINGS, hdev, &ev, sizeof(ev), skip);
895}
896
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200897static int set_discoverable(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300898 u16 len)
Johan Hedberg03811012010-12-08 00:21:06 +0200899{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -0300900 struct mgmt_cp_set_discoverable *cp = data;
Johan Hedberg03811012010-12-08 00:21:06 +0200901 struct pending_cmd *cmd;
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200902 u16 timeout;
Johan Hedberg03811012010-12-08 00:21:06 +0200903 u8 scan;
904 int err;
905
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200906 BT_DBG("request for %s", hdev->name);
Johan Hedberg03811012010-12-08 00:21:06 +0200907
Johan Hedberg33c525c2012-10-24 21:11:58 +0300908 if (!lmp_bredr_capable(hdev))
909 return cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
910 MGMT_STATUS_NOT_SUPPORTED);
911
Johan Hedberga7e80f22013-01-09 16:05:19 +0200912 if (cp->val != 0x00 && cp->val != 0x01)
913 return cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
914 MGMT_STATUS_INVALID_PARAMS);
915
Marcel Holtmann1f350c82012-03-12 20:31:08 -0700916 timeout = __le16_to_cpu(cp->timeout);
Marcel Holtmann24c54a92012-02-22 18:06:34 +0100917 if (!cp->val && timeout > 0)
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200918 return cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300919 MGMT_STATUS_INVALID_PARAMS);
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200920
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300921 hci_dev_lock(hdev);
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200922
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200923 if (!hdev_is_powered(hdev) && timeout > 0) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200924 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300925 MGMT_STATUS_NOT_POWERED);
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200926 goto failed;
927 }
928
929 if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) ||
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -0300930 mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200931 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300932 MGMT_STATUS_BUSY);
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200933 goto failed;
934 }
935
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200936 if (!test_bit(HCI_CONNECTABLE, &hdev->dev_flags)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +0200937 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DISCOVERABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300938 MGMT_STATUS_REJECTED);
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200939 goto failed;
940 }
941
942 if (!hdev_is_powered(hdev)) {
Johan Hedberg0224d2f2012-02-21 19:40:05 +0200943 bool changed = false;
944
945 if (!!cp->val != test_bit(HCI_DISCOVERABLE, &hdev->dev_flags)) {
946 change_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
947 changed = true;
948 }
949
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200950 err = send_settings_rsp(sk, MGMT_OP_SET_DISCOVERABLE, hdev);
Johan Hedberg0224d2f2012-02-21 19:40:05 +0200951 if (err < 0)
952 goto failed;
953
954 if (changed)
955 err = new_settings(hdev, sk);
956
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200957 goto failed;
958 }
959
960 if (!!cp->val == test_bit(HCI_DISCOVERABLE, &hdev->dev_flags)) {
Marcel Holtmann955638e2012-02-22 18:21:00 +0100961 if (hdev->discov_timeout > 0) {
962 cancel_delayed_work(&hdev->discov_off);
963 hdev->discov_timeout = 0;
964 }
965
966 if (cp->val && timeout > 0) {
967 hdev->discov_timeout = timeout;
968 queue_delayed_work(hdev->workqueue, &hdev->discov_off,
969 msecs_to_jiffies(hdev->discov_timeout * 1000));
970 }
971
Johan Hedberg69ab39e2011-12-15 00:47:35 +0200972 err = send_settings_rsp(sk, MGMT_OP_SET_DISCOVERABLE, hdev);
Johan Hedbergf7b64e692010-12-13 21:07:06 +0200973 goto failed;
974 }
975
976 cmd = mgmt_pending_add(sk, MGMT_OP_SET_DISCOVERABLE, hdev, data, len);
977 if (!cmd) {
978 err = -ENOMEM;
979 goto failed;
980 }
981
982 scan = SCAN_PAGE;
983
984 if (cp->val)
985 scan |= SCAN_INQUIRY;
986 else
987 cancel_delayed_work(&hdev->discov_off);
988
989 err = hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
990 if (err < 0)
991 mgmt_pending_remove(cmd);
992
Johan Hedberg03811012010-12-08 00:21:06 +0200993 if (cp->val)
Johan Hedberg5e5282b2012-02-21 16:01:30 +0200994 hdev->discov_timeout = timeout;
Johan Hedberg03811012010-12-08 00:21:06 +0200995
996failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -0300997 hci_dev_unlock(hdev);
Johan Hedberg03811012010-12-08 00:21:06 +0200998 return err;
999}
1000
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001001static int set_connectable(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001002 u16 len)
Johan Hedberg03811012010-12-08 00:21:06 +02001003{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001004 struct mgmt_mode *cp = data;
Johan Hedberg03811012010-12-08 00:21:06 +02001005 struct pending_cmd *cmd;
1006 u8 scan;
1007 int err;
1008
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001009 BT_DBG("request for %s", hdev->name);
Johan Hedberge41d8b42010-12-13 21:07:03 +02001010
Johan Hedberg33c525c2012-10-24 21:11:58 +03001011 if (!lmp_bredr_capable(hdev))
1012 return cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE,
1013 MGMT_STATUS_NOT_SUPPORTED);
1014
Johan Hedberga7e80f22013-01-09 16:05:19 +02001015 if (cp->val != 0x00 && cp->val != 0x01)
1016 return cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE,
1017 MGMT_STATUS_INVALID_PARAMS);
1018
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001019 hci_dev_lock(hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001020
Johan Hedberg4b34ee782012-02-21 14:13:02 +02001021 if (!hdev_is_powered(hdev)) {
Johan Hedberg0224d2f2012-02-21 19:40:05 +02001022 bool changed = false;
1023
1024 if (!!cp->val != test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
1025 changed = true;
1026
Andrei Emeltchenko6bf0e462012-02-22 13:21:16 +02001027 if (cp->val) {
Johan Hedberg5e5282b2012-02-21 16:01:30 +02001028 set_bit(HCI_CONNECTABLE, &hdev->dev_flags);
Andrei Emeltchenko6bf0e462012-02-22 13:21:16 +02001029 } else {
Johan Hedberg5e5282b2012-02-21 16:01:30 +02001030 clear_bit(HCI_CONNECTABLE, &hdev->dev_flags);
1031 clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags);
1032 }
Johan Hedberg0224d2f2012-02-21 19:40:05 +02001033
Johan Hedberg5e5282b2012-02-21 16:01:30 +02001034 err = send_settings_rsp(sk, MGMT_OP_SET_CONNECTABLE, hdev);
Johan Hedberg0224d2f2012-02-21 19:40:05 +02001035 if (err < 0)
1036 goto failed;
1037
1038 if (changed)
1039 err = new_settings(hdev, sk);
1040
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001041 goto failed;
1042 }
1043
1044 if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, hdev) ||
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001045 mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001046 err = cmd_status(sk, hdev->id, MGMT_OP_SET_CONNECTABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001047 MGMT_STATUS_BUSY);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001048 goto failed;
1049 }
1050
Johan Hedberg5e5282b2012-02-21 16:01:30 +02001051 if (!!cp->val == test_bit(HCI_PSCAN, &hdev->flags)) {
Johan Hedberg69ab39e2011-12-15 00:47:35 +02001052 err = send_settings_rsp(sk, MGMT_OP_SET_CONNECTABLE, hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001053 goto failed;
1054 }
1055
1056 cmd = mgmt_pending_add(sk, MGMT_OP_SET_CONNECTABLE, hdev, data, len);
1057 if (!cmd) {
1058 err = -ENOMEM;
1059 goto failed;
1060 }
1061
Andrei Emeltchenko6bf0e462012-02-22 13:21:16 +02001062 if (cp->val) {
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001063 scan = SCAN_PAGE;
Andrei Emeltchenko6bf0e462012-02-22 13:21:16 +02001064 } else {
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001065 scan = 0;
1066
Johan Hedbergdf2c6c52012-02-21 19:15:49 +02001067 if (test_bit(HCI_ISCAN, &hdev->flags) &&
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001068 hdev->discov_timeout > 0)
Johan Hedbergdf2c6c52012-02-21 19:15:49 +02001069 cancel_delayed_work(&hdev->discov_off);
1070 }
1071
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001072 err = hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
1073 if (err < 0)
1074 mgmt_pending_remove(cmd);
1075
1076failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001077 hci_dev_unlock(hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001078 return err;
1079}
1080
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001081static int set_pairable(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001082 u16 len)
Johan Hedberg73f22f62010-12-29 16:00:25 +02001083{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001084 struct mgmt_mode *cp = data;
Johan Hedberg73f22f62010-12-29 16:00:25 +02001085 int err;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001086
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001087 BT_DBG("request for %s", hdev->name);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001088
Johan Hedberga7e80f22013-01-09 16:05:19 +02001089 if (cp->val != 0x00 && cp->val != 0x01)
1090 return cmd_status(sk, hdev->id, MGMT_OP_SET_PAIRABLE,
1091 MGMT_STATUS_INVALID_PARAMS);
1092
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001093 hci_dev_lock(hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001094
1095 if (cp->val)
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001096 set_bit(HCI_PAIRABLE, &hdev->dev_flags);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001097 else
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001098 clear_bit(HCI_PAIRABLE, &hdev->dev_flags);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001099
Johan Hedberg69ab39e2011-12-15 00:47:35 +02001100 err = send_settings_rsp(sk, MGMT_OP_SET_PAIRABLE, hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001101 if (err < 0)
1102 goto failed;
1103
Johan Hedbergbeadb2b2012-02-21 16:55:31 +02001104 err = new_settings(hdev, sk);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001105
1106failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001107 hci_dev_unlock(hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02001108 return err;
1109}
Johan Hedberg72a734e2010-12-30 00:38:22 +02001110
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001111static int set_link_security(struct sock *sk, struct hci_dev *hdev, void *data,
1112 u16 len)
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001113{
1114 struct mgmt_mode *cp = data;
1115 struct pending_cmd *cmd;
Johan Hedberg816a11d2012-02-26 13:04:52 +02001116 u8 val;
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001117 int err;
1118
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001119 BT_DBG("request for %s", hdev->name);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001120
Johan Hedberg33c525c2012-10-24 21:11:58 +03001121 if (!lmp_bredr_capable(hdev))
1122 return cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY,
1123 MGMT_STATUS_NOT_SUPPORTED);
1124
Johan Hedberga7e80f22013-01-09 16:05:19 +02001125 if (cp->val != 0x00 && cp->val != 0x01)
1126 return cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY,
1127 MGMT_STATUS_INVALID_PARAMS);
1128
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001129 hci_dev_lock(hdev);
1130
Johan Hedberg4b34ee782012-02-21 14:13:02 +02001131 if (!hdev_is_powered(hdev)) {
Johan Hedberg47990ea2012-02-22 11:58:37 +02001132 bool changed = false;
1133
1134 if (!!cp->val != test_bit(HCI_LINK_SECURITY,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001135 &hdev->dev_flags)) {
Johan Hedberg47990ea2012-02-22 11:58:37 +02001136 change_bit(HCI_LINK_SECURITY, &hdev->dev_flags);
1137 changed = true;
1138 }
1139
1140 err = send_settings_rsp(sk, MGMT_OP_SET_LINK_SECURITY, hdev);
1141 if (err < 0)
1142 goto failed;
1143
1144 if (changed)
1145 err = new_settings(hdev, sk);
1146
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001147 goto failed;
1148 }
1149
1150 if (mgmt_pending_find(MGMT_OP_SET_LINK_SECURITY, hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001151 err = cmd_status(sk, hdev->id, MGMT_OP_SET_LINK_SECURITY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001152 MGMT_STATUS_BUSY);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001153 goto failed;
1154 }
1155
1156 val = !!cp->val;
1157
1158 if (test_bit(HCI_AUTH, &hdev->flags) == val) {
1159 err = send_settings_rsp(sk, MGMT_OP_SET_LINK_SECURITY, hdev);
1160 goto failed;
1161 }
1162
1163 cmd = mgmt_pending_add(sk, MGMT_OP_SET_LINK_SECURITY, hdev, data, len);
1164 if (!cmd) {
1165 err = -ENOMEM;
1166 goto failed;
1167 }
1168
1169 err = hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, sizeof(val), &val);
1170 if (err < 0) {
1171 mgmt_pending_remove(cmd);
1172 goto failed;
1173 }
1174
1175failed:
1176 hci_dev_unlock(hdev);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02001177 return err;
1178}
1179
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001180static int set_ssp(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001181{
1182 struct mgmt_mode *cp = data;
1183 struct pending_cmd *cmd;
Johan Hedberg816a11d2012-02-26 13:04:52 +02001184 u8 val;
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001185 int err;
1186
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001187 BT_DBG("request for %s", hdev->name);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001188
Johan Hedberg13ecd8b2013-01-09 15:29:38 +02001189 if (!lmp_ssp_capable(hdev))
1190 return cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
1191 MGMT_STATUS_NOT_SUPPORTED);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001192
Johan Hedberga7e80f22013-01-09 16:05:19 +02001193 if (cp->val != 0x00 && cp->val != 0x01)
1194 return cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
1195 MGMT_STATUS_INVALID_PARAMS);
1196
Johan Hedberg13ecd8b2013-01-09 15:29:38 +02001197 hci_dev_lock(hdev);
Johan Hedberg6c8f12c2012-02-22 16:35:26 +02001198
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02001199 val = !!cp->val;
1200
Johan Hedberg4b34ee782012-02-21 14:13:02 +02001201 if (!hdev_is_powered(hdev)) {
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02001202 bool changed = false;
1203
1204 if (val != test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) {
1205 change_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
1206 changed = true;
1207 }
1208
1209 err = send_settings_rsp(sk, MGMT_OP_SET_SSP, hdev);
1210 if (err < 0)
1211 goto failed;
1212
1213 if (changed)
1214 err = new_settings(hdev, sk);
1215
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001216 goto failed;
1217 }
1218
1219 if (mgmt_pending_find(MGMT_OP_SET_SSP, hdev)) {
Szymon Jancd97dcb62012-03-16 16:02:56 +01001220 err = cmd_status(sk, hdev->id, MGMT_OP_SET_SSP,
1221 MGMT_STATUS_BUSY);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001222 goto failed;
1223 }
1224
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001225 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags) == val) {
1226 err = send_settings_rsp(sk, MGMT_OP_SET_SSP, hdev);
1227 goto failed;
1228 }
1229
1230 cmd = mgmt_pending_add(sk, MGMT_OP_SET_SSP, hdev, data, len);
1231 if (!cmd) {
1232 err = -ENOMEM;
1233 goto failed;
1234 }
1235
1236 err = hci_send_cmd(hdev, HCI_OP_WRITE_SSP_MODE, sizeof(val), &val);
1237 if (err < 0) {
1238 mgmt_pending_remove(cmd);
1239 goto failed;
1240 }
1241
1242failed:
1243 hci_dev_unlock(hdev);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02001244 return err;
1245}
1246
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001247static int set_hs(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001248{
1249 struct mgmt_mode *cp = data;
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001250
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001251 BT_DBG("request for %s", hdev->name);
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001252
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001253 if (!enable_hs)
1254 return cmd_status(sk, hdev->id, MGMT_OP_SET_HS,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001255 MGMT_STATUS_NOT_SUPPORTED);
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001256
Johan Hedberga7e80f22013-01-09 16:05:19 +02001257 if (cp->val != 0x00 && cp->val != 0x01)
1258 return cmd_status(sk, hdev->id, MGMT_OP_SET_HS,
1259 MGMT_STATUS_INVALID_PARAMS);
1260
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001261 if (cp->val)
1262 set_bit(HCI_HS_ENABLED, &hdev->dev_flags);
1263 else
1264 clear_bit(HCI_HS_ENABLED, &hdev->dev_flags);
1265
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001266 return send_settings_rsp(sk, MGMT_OP_SET_HS, hdev);
Johan Hedberg6d80dfd2012-02-20 23:50:38 +02001267}
1268
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001269static int set_le(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
Johan Hedberg06199cf2012-02-22 16:37:11 +02001270{
1271 struct mgmt_mode *cp = data;
1272 struct hci_cp_write_le_host_supported hci_cp;
1273 struct pending_cmd *cmd;
Johan Hedberg06199cf2012-02-22 16:37:11 +02001274 int err;
Johan Hedberg0b60eba2012-02-28 00:57:24 +02001275 u8 val, enabled;
Johan Hedberg06199cf2012-02-22 16:37:11 +02001276
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001277 BT_DBG("request for %s", hdev->name);
Johan Hedberg06199cf2012-02-22 16:37:11 +02001278
Johan Hedberg13ecd8b2013-01-09 15:29:38 +02001279 if (!lmp_le_capable(hdev))
1280 return cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
1281 MGMT_STATUS_NOT_SUPPORTED);
Johan Hedberg1de028c2012-02-29 19:55:35 -08001282
Johan Hedberga7e80f22013-01-09 16:05:19 +02001283 if (cp->val != 0x00 && cp->val != 0x01)
1284 return cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
1285 MGMT_STATUS_INVALID_PARAMS);
1286
Johan Hedberg13ecd8b2013-01-09 15:29:38 +02001287 hci_dev_lock(hdev);
Johan Hedberg06199cf2012-02-22 16:37:11 +02001288
1289 val = !!cp->val;
Gustavo Padovanffa88e02012-11-23 16:50:51 -02001290 enabled = lmp_host_le_capable(hdev);
Johan Hedberg06199cf2012-02-22 16:37:11 +02001291
Johan Hedberg0b60eba2012-02-28 00:57:24 +02001292 if (!hdev_is_powered(hdev) || val == enabled) {
Johan Hedberg06199cf2012-02-22 16:37:11 +02001293 bool changed = false;
1294
1295 if (val != test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) {
1296 change_bit(HCI_LE_ENABLED, &hdev->dev_flags);
1297 changed = true;
1298 }
1299
1300 err = send_settings_rsp(sk, MGMT_OP_SET_LE, hdev);
1301 if (err < 0)
Johan Hedberg1de028c2012-02-29 19:55:35 -08001302 goto unlock;
Johan Hedberg06199cf2012-02-22 16:37:11 +02001303
1304 if (changed)
1305 err = new_settings(hdev, sk);
1306
Johan Hedberg1de028c2012-02-29 19:55:35 -08001307 goto unlock;
Johan Hedberg06199cf2012-02-22 16:37:11 +02001308 }
1309
1310 if (mgmt_pending_find(MGMT_OP_SET_LE, hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001311 err = cmd_status(sk, hdev->id, MGMT_OP_SET_LE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001312 MGMT_STATUS_BUSY);
Johan Hedberg1de028c2012-02-29 19:55:35 -08001313 goto unlock;
Johan Hedberg06199cf2012-02-22 16:37:11 +02001314 }
1315
1316 cmd = mgmt_pending_add(sk, MGMT_OP_SET_LE, hdev, data, len);
1317 if (!cmd) {
1318 err = -ENOMEM;
Johan Hedberg1de028c2012-02-29 19:55:35 -08001319 goto unlock;
Johan Hedberg06199cf2012-02-22 16:37:11 +02001320 }
1321
1322 memset(&hci_cp, 0, sizeof(hci_cp));
1323
1324 if (val) {
1325 hci_cp.le = val;
Gustavo Padovanffa88e02012-11-23 16:50:51 -02001326 hci_cp.simul = lmp_le_br_capable(hdev);
Johan Hedberg06199cf2012-02-22 16:37:11 +02001327 }
1328
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001329 err = hci_send_cmd(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(hci_cp),
1330 &hci_cp);
Syam Sidhardhan0c01bc42012-04-12 20:33:21 +05301331 if (err < 0)
Johan Hedberg06199cf2012-02-22 16:37:11 +02001332 mgmt_pending_remove(cmd);
Johan Hedberg06199cf2012-02-22 16:37:11 +02001333
Johan Hedberg1de028c2012-02-29 19:55:35 -08001334unlock:
1335 hci_dev_unlock(hdev);
Johan Hedberg06199cf2012-02-22 16:37:11 +02001336 return err;
1337}
1338
Johan Hedberg0cab9c82013-03-15 17:06:54 -05001339/* This is a helper function to test for pending mgmt commands that can
1340 * cause CoD or EIR HCI commands. We can only allow one such pending
1341 * mgmt command at a time since otherwise we cannot easily track what
1342 * the current values are, will be, and based on that calculate if a new
1343 * HCI command needs to be sent and if yes with what value.
1344 */
1345static bool pending_eir_or_class(struct hci_dev *hdev)
1346{
1347 struct pending_cmd *cmd;
1348
1349 list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
1350 switch (cmd->opcode) {
1351 case MGMT_OP_ADD_UUID:
1352 case MGMT_OP_REMOVE_UUID:
1353 case MGMT_OP_SET_DEV_CLASS:
1354 case MGMT_OP_SET_POWERED:
1355 return true;
1356 }
1357 }
1358
1359 return false;
1360}
1361
Johan Hedberg83be8ec2013-01-27 00:31:29 +02001362static const u8 bluetooth_base_uuid[] = {
1363 0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
1364 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1365};
1366
1367static u8 get_uuid_size(const u8 *uuid)
1368{
1369 u32 val;
1370
1371 if (memcmp(uuid, bluetooth_base_uuid, 12))
1372 return 128;
1373
1374 val = get_unaligned_le32(&uuid[12]);
1375 if (val > 0xffff)
1376 return 32;
1377
1378 return 16;
1379}
1380
Johan Hedberg92da6092013-03-15 17:06:55 -05001381static void mgmt_class_complete(struct hci_dev *hdev, u16 mgmt_op, u8 status)
1382{
1383 struct pending_cmd *cmd;
1384
1385 hci_dev_lock(hdev);
1386
1387 cmd = mgmt_pending_find(mgmt_op, hdev);
1388 if (!cmd)
1389 goto unlock;
1390
1391 cmd_complete(cmd->sk, cmd->index, cmd->opcode, mgmt_status(status),
1392 hdev->dev_class, 3);
1393
1394 mgmt_pending_remove(cmd);
1395
1396unlock:
1397 hci_dev_unlock(hdev);
1398}
1399
1400static void add_uuid_complete(struct hci_dev *hdev, u8 status)
1401{
1402 BT_DBG("status 0x%02x", status);
1403
1404 mgmt_class_complete(hdev, MGMT_OP_ADD_UUID, status);
1405}
1406
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001407static int add_uuid(struct sock *sk, struct hci_dev *hdev, void *data, u16 len)
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001408{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001409 struct mgmt_cp_add_uuid *cp = data;
Johan Hedberg90e70452012-02-23 23:09:40 +02001410 struct pending_cmd *cmd;
Johan Hedberg890ea892013-03-15 17:06:52 -05001411 struct hci_request req;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001412 struct bt_uuid *uuid;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001413 int err;
1414
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001415 BT_DBG("request for %s", hdev->name);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001416
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001417 hci_dev_lock(hdev);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001418
Johan Hedberg0cab9c82013-03-15 17:06:54 -05001419 if (pending_eir_or_class(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001420 err = cmd_status(sk, hdev->id, MGMT_OP_ADD_UUID,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001421 MGMT_STATUS_BUSY);
Johan Hedbergc95f0ba2012-02-23 22:54:38 +02001422 goto failed;
1423 }
1424
Andre Guedes92c4c202012-06-07 19:05:44 -03001425 uuid = kmalloc(sizeof(*uuid), GFP_KERNEL);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001426 if (!uuid) {
1427 err = -ENOMEM;
1428 goto failed;
1429 }
1430
1431 memcpy(uuid->uuid, cp->uuid, 16);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02001432 uuid->svc_hint = cp->svc_hint;
Johan Hedberg83be8ec2013-01-27 00:31:29 +02001433 uuid->size = get_uuid_size(cp->uuid);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001434
Johan Hedbergde66aa62013-01-27 00:31:27 +02001435 list_add_tail(&uuid->list, &hdev->uuids);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001436
Johan Hedberg890ea892013-03-15 17:06:52 -05001437 hci_req_init(&req, hdev);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02001438
Johan Hedberg890ea892013-03-15 17:06:52 -05001439 update_class(&req);
1440 update_eir(&req);
1441
Johan Hedberg92da6092013-03-15 17:06:55 -05001442 err = hci_req_run(&req, add_uuid_complete);
1443 if (err < 0) {
1444 if (err != -ENODATA)
1445 goto failed;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +03001446
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001447 err = cmd_complete(sk, hdev->id, MGMT_OP_ADD_UUID, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001448 hdev->dev_class, 3);
Johan Hedberg90e70452012-02-23 23:09:40 +02001449 goto failed;
1450 }
1451
1452 cmd = mgmt_pending_add(sk, MGMT_OP_ADD_UUID, hdev, data, len);
Johan Hedberg890ea892013-03-15 17:06:52 -05001453 if (!cmd) {
Johan Hedberg90e70452012-02-23 23:09:40 +02001454 err = -ENOMEM;
Johan Hedberg890ea892013-03-15 17:06:52 -05001455 goto failed;
1456 }
1457
1458 err = 0;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001459
1460failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001461 hci_dev_unlock(hdev);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001462 return err;
1463}
1464
Johan Hedberg24b78d02012-02-23 23:24:30 +02001465static bool enable_service_cache(struct hci_dev *hdev)
1466{
1467 if (!hdev_is_powered(hdev))
1468 return false;
1469
1470 if (!test_and_set_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) {
Johan Hedberg46818ed2013-01-14 22:33:52 +02001471 queue_delayed_work(hdev->workqueue, &hdev->service_cache,
1472 CACHE_TIMEOUT);
Johan Hedberg24b78d02012-02-23 23:24:30 +02001473 return true;
1474 }
1475
1476 return false;
1477}
1478
Johan Hedberg92da6092013-03-15 17:06:55 -05001479static void remove_uuid_complete(struct hci_dev *hdev, u8 status)
1480{
1481 BT_DBG("status 0x%02x", status);
1482
1483 mgmt_class_complete(hdev, MGMT_OP_REMOVE_UUID, status);
1484}
1485
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001486static int remove_uuid(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001487 u16 len)
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001488{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001489 struct mgmt_cp_remove_uuid *cp = data;
Johan Hedberg90e70452012-02-23 23:09:40 +02001490 struct pending_cmd *cmd;
Johan Hedberg056341c2013-01-27 00:31:30 +02001491 struct bt_uuid *match, *tmp;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001492 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 -05001493 struct hci_request req;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001494 int err, found;
1495
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001496 BT_DBG("request for %s", hdev->name);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001497
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001498 hci_dev_lock(hdev);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001499
Johan Hedberg0cab9c82013-03-15 17:06:54 -05001500 if (pending_eir_or_class(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001501 err = cmd_status(sk, hdev->id, MGMT_OP_REMOVE_UUID,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001502 MGMT_STATUS_BUSY);
Johan Hedbergc95f0ba2012-02-23 22:54:38 +02001503 goto unlock;
1504 }
1505
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001506 if (memcmp(cp->uuid, bt_uuid_any, 16) == 0) {
1507 err = hci_uuids_clear(hdev);
Johan Hedberg4004b6d2012-02-23 21:30:12 +02001508
Johan Hedberg24b78d02012-02-23 23:24:30 +02001509 if (enable_service_cache(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001510 err = cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_UUID,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001511 0, hdev->dev_class, 3);
Johan Hedberg24b78d02012-02-23 23:24:30 +02001512 goto unlock;
1513 }
Johan Hedberg4004b6d2012-02-23 21:30:12 +02001514
Johan Hedberg9246a862012-02-23 21:33:16 +02001515 goto update_class;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001516 }
1517
1518 found = 0;
1519
Johan Hedberg056341c2013-01-27 00:31:30 +02001520 list_for_each_entry_safe(match, tmp, &hdev->uuids, list) {
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001521 if (memcmp(match->uuid, cp->uuid, 16) != 0)
1522 continue;
1523
1524 list_del(&match->list);
Johan Hedberg482049f2012-11-08 10:25:26 +01001525 kfree(match);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001526 found++;
1527 }
1528
1529 if (found == 0) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001530 err = cmd_status(sk, hdev->id, MGMT_OP_REMOVE_UUID,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001531 MGMT_STATUS_INVALID_PARAMS);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001532 goto unlock;
1533 }
1534
Johan Hedberg9246a862012-02-23 21:33:16 +02001535update_class:
Johan Hedberg890ea892013-03-15 17:06:52 -05001536 hci_req_init(&req, hdev);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02001537
Johan Hedberg890ea892013-03-15 17:06:52 -05001538 update_class(&req);
1539 update_eir(&req);
1540
Johan Hedberg92da6092013-03-15 17:06:55 -05001541 err = hci_req_run(&req, remove_uuid_complete);
1542 if (err < 0) {
1543 if (err != -ENODATA)
1544 goto unlock;
Johan Hedberg80a1e1d2011-03-28 14:07:23 +03001545
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001546 err = cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_UUID, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001547 hdev->dev_class, 3);
Johan Hedberg90e70452012-02-23 23:09:40 +02001548 goto unlock;
1549 }
1550
1551 cmd = mgmt_pending_add(sk, MGMT_OP_REMOVE_UUID, hdev, data, len);
Johan Hedberg890ea892013-03-15 17:06:52 -05001552 if (!cmd) {
Johan Hedberg90e70452012-02-23 23:09:40 +02001553 err = -ENOMEM;
Johan Hedberg890ea892013-03-15 17:06:52 -05001554 goto unlock;
1555 }
1556
1557 err = 0;
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001558
1559unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001560 hci_dev_unlock(hdev);
Johan Hedberg2aeb9a12011-01-04 12:08:51 +02001561 return err;
1562}
1563
Johan Hedberg92da6092013-03-15 17:06:55 -05001564static void set_class_complete(struct hci_dev *hdev, u8 status)
1565{
1566 BT_DBG("status 0x%02x", status);
1567
1568 mgmt_class_complete(hdev, MGMT_OP_SET_DEV_CLASS, status);
1569}
1570
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001571static int set_dev_class(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001572 u16 len)
Johan Hedberg1aff6f02011-01-13 21:56:52 +02001573{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001574 struct mgmt_cp_set_dev_class *cp = data;
Johan Hedberg90e70452012-02-23 23:09:40 +02001575 struct pending_cmd *cmd;
Johan Hedberg890ea892013-03-15 17:06:52 -05001576 struct hci_request req;
Johan Hedberg1aff6f02011-01-13 21:56:52 +02001577 int err;
1578
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001579 BT_DBG("request for %s", hdev->name);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02001580
Johan Hedberg13ecd8b2013-01-09 15:29:38 +02001581 if (!lmp_bredr_capable(hdev))
1582 return cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS,
1583 MGMT_STATUS_NOT_SUPPORTED);
1584
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001585 hci_dev_lock(hdev);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02001586
Johan Hedberg0cab9c82013-03-15 17:06:54 -05001587 if (pending_eir_or_class(hdev)) {
1588 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS,
1589 MGMT_STATUS_BUSY);
1590 goto unlock;
1591 }
1592
1593 if ((cp->minor & 0x03) != 0 || (cp->major & 0xe0) != 0) {
1594 err = cmd_status(sk, hdev->id, MGMT_OP_SET_DEV_CLASS,
1595 MGMT_STATUS_INVALID_PARAMS);
1596 goto unlock;
1597 }
1598
Johan Hedberg1aff6f02011-01-13 21:56:52 +02001599 hdev->major_class = cp->major;
1600 hdev->minor_class = cp->minor;
1601
Johan Hedberg932f5ff2012-02-22 22:11:32 +02001602 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001603 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001604 hdev->dev_class, 3);
Johan Hedberg932f5ff2012-02-22 22:11:32 +02001605 goto unlock;
1606 }
1607
Johan Hedberg890ea892013-03-15 17:06:52 -05001608 hci_req_init(&req, hdev);
1609
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001610 if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) {
Johan Hedberg7d785252011-12-15 00:47:39 +02001611 hci_dev_unlock(hdev);
1612 cancel_delayed_work_sync(&hdev->service_cache);
1613 hci_dev_lock(hdev);
Johan Hedberg890ea892013-03-15 17:06:52 -05001614 update_eir(&req);
Johan Hedberg7d785252011-12-15 00:47:39 +02001615 }
Johan Hedberg14c0b602011-12-15 00:47:37 +02001616
Johan Hedberg890ea892013-03-15 17:06:52 -05001617 update_class(&req);
1618
Johan Hedberg92da6092013-03-15 17:06:55 -05001619 err = hci_req_run(&req, set_class_complete);
1620 if (err < 0) {
1621 if (err != -ENODATA)
1622 goto unlock;
Johan Hedberg1aff6f02011-01-13 21:56:52 +02001623
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001624 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_DEV_CLASS, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001625 hdev->dev_class, 3);
Johan Hedberg90e70452012-02-23 23:09:40 +02001626 goto unlock;
1627 }
1628
1629 cmd = mgmt_pending_add(sk, MGMT_OP_SET_DEV_CLASS, hdev, data, len);
Johan Hedberg890ea892013-03-15 17:06:52 -05001630 if (!cmd) {
Johan Hedberg90e70452012-02-23 23:09:40 +02001631 err = -ENOMEM;
Johan Hedberg890ea892013-03-15 17:06:52 -05001632 goto unlock;
1633 }
1634
1635 err = 0;
Johan Hedberg1aff6f02011-01-13 21:56:52 +02001636
Johan Hedbergb5235a62012-02-21 14:32:24 +02001637unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001638 hci_dev_unlock(hdev);
Johan Hedberg1aff6f02011-01-13 21:56:52 +02001639 return err;
1640}
1641
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001642static int load_link_keys(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001643 u16 len)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001644{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001645 struct mgmt_cp_load_link_keys *cp = data;
Szymon Janc4e51eae2011-02-25 19:05:48 +01001646 u16 key_count, expected_len;
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03001647 int i;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001648
Marcel Holtmann1f350c82012-03-12 20:31:08 -07001649 key_count = __le16_to_cpu(cp->key_count);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001650
Johan Hedberg86742e12011-11-07 23:13:38 +02001651 expected_len = sizeof(*cp) + key_count *
1652 sizeof(struct mgmt_link_key_info);
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03001653 if (expected_len != len) {
Johan Hedberg86742e12011-11-07 23:13:38 +02001654 BT_ERR("load_link_keys: expected %u bytes, got %u bytes",
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001655 len, expected_len);
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001656 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001657 MGMT_STATUS_INVALID_PARAMS);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001658 }
1659
Johan Hedberg4ae143012013-01-20 14:27:13 +02001660 if (cp->debug_keys != 0x00 && cp->debug_keys != 0x01)
1661 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
1662 MGMT_STATUS_INVALID_PARAMS);
1663
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001664 BT_DBG("%s debug_keys %u key_count %u", hdev->name, cp->debug_keys,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001665 key_count);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001666
Johan Hedberg4ee71b22013-01-20 14:27:19 +02001667 for (i = 0; i < key_count; i++) {
1668 struct mgmt_link_key_info *key = &cp->keys[i];
1669
1670 if (key->addr.type != BDADDR_BREDR)
1671 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS,
1672 MGMT_STATUS_INVALID_PARAMS);
1673 }
1674
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001675 hci_dev_lock(hdev);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001676
1677 hci_link_keys_clear(hdev);
1678
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001679 set_bit(HCI_LINK_KEYS, &hdev->dev_flags);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001680
1681 if (cp->debug_keys)
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001682 set_bit(HCI_DEBUG_KEYS, &hdev->dev_flags);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001683 else
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001684 clear_bit(HCI_DEBUG_KEYS, &hdev->dev_flags);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001685
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03001686 for (i = 0; i < key_count; i++) {
Johan Hedberg86742e12011-11-07 23:13:38 +02001687 struct mgmt_link_key_info *key = &cp->keys[i];
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001688
Johan Hedbergd753fdc2012-02-17 14:06:34 +02001689 hci_add_link_key(hdev, NULL, 0, &key->addr.bdaddr, key->val,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001690 key->type, key->pin_len);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001691 }
1692
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001693 cmd_complete(sk, hdev->id, MGMT_OP_LOAD_LINK_KEYS, 0, NULL, 0);
Johan Hedberg0e5f8752011-11-11 16:18:54 +02001694
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001695 hci_dev_unlock(hdev);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001696
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03001697 return 0;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001698}
1699
Johan Hedbergb1078ad2012-02-09 17:21:16 +02001700static int device_unpaired(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001701 u8 addr_type, struct sock *skip_sk)
Johan Hedbergb1078ad2012-02-09 17:21:16 +02001702{
1703 struct mgmt_ev_device_unpaired ev;
1704
1705 bacpy(&ev.addr.bdaddr, bdaddr);
1706 ev.addr.type = addr_type;
1707
1708 return mgmt_event(MGMT_EV_DEVICE_UNPAIRED, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001709 skip_sk);
Johan Hedbergb1078ad2012-02-09 17:21:16 +02001710}
1711
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001712static int unpair_device(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001713 u16 len)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001714{
Johan Hedberg124f6e32012-02-09 13:50:12 +02001715 struct mgmt_cp_unpair_device *cp = data;
1716 struct mgmt_rp_unpair_device rp;
Johan Hedberga8a1d192011-11-10 15:54:38 +02001717 struct hci_cp_disconnect dc;
1718 struct pending_cmd *cmd;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001719 struct hci_conn *conn;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001720 int err;
1721
Johan Hedberga8a1d192011-11-10 15:54:38 +02001722 memset(&rp, 0, sizeof(rp));
Johan Hedberg124f6e32012-02-09 13:50:12 +02001723 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
1724 rp.addr.type = cp->addr.type;
Johan Hedberga8a1d192011-11-10 15:54:38 +02001725
Johan Hedberg4ee71b22013-01-20 14:27:19 +02001726 if (!bdaddr_type_is_valid(cp->addr.type))
1727 return cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
1728 MGMT_STATUS_INVALID_PARAMS,
1729 &rp, sizeof(rp));
1730
Johan Hedberg118da702013-01-20 14:27:20 +02001731 if (cp->disconnect != 0x00 && cp->disconnect != 0x01)
1732 return cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
1733 MGMT_STATUS_INVALID_PARAMS,
1734 &rp, sizeof(rp));
1735
Johan Hedberg4ee71b22013-01-20 14:27:19 +02001736 hci_dev_lock(hdev);
1737
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02001738 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001739 err = cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001740 MGMT_STATUS_NOT_POWERED, &rp, sizeof(rp));
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02001741 goto unlock;
1742 }
1743
Andre Guedes591f47f2012-04-24 21:02:49 -03001744 if (cp->addr.type == BDADDR_BREDR)
Johan Hedberg124f6e32012-02-09 13:50:12 +02001745 err = hci_remove_link_key(hdev, &cp->addr.bdaddr);
1746 else
1747 err = hci_remove_ltk(hdev, &cp->addr.bdaddr);
Vinicius Costa Gomesb0dbfb42012-02-02 21:08:03 -03001748
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001749 if (err < 0) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001750 err = cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001751 MGMT_STATUS_NOT_PAIRED, &rp, sizeof(rp));
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001752 goto unlock;
1753 }
1754
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02001755 if (cp->disconnect) {
Andre Guedes591f47f2012-04-24 21:02:49 -03001756 if (cp->addr.type == BDADDR_BREDR)
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02001757 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001758 &cp->addr.bdaddr);
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02001759 else
1760 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03001761 &cp->addr.bdaddr);
Johan Hedberg86a8cfc2012-02-22 22:53:34 +02001762 } else {
1763 conn = NULL;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001764 }
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001765
Johan Hedberga8a1d192011-11-10 15:54:38 +02001766 if (!conn) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001767 err = cmd_complete(sk, hdev->id, MGMT_OP_UNPAIR_DEVICE, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001768 &rp, sizeof(rp));
Johan Hedbergb1078ad2012-02-09 17:21:16 +02001769 device_unpaired(hdev, &cp->addr.bdaddr, cp->addr.type, sk);
Johan Hedberga8a1d192011-11-10 15:54:38 +02001770 goto unlock;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001771 }
1772
Johan Hedberg124f6e32012-02-09 13:50:12 +02001773 cmd = mgmt_pending_add(sk, MGMT_OP_UNPAIR_DEVICE, hdev, cp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001774 sizeof(*cp));
Johan Hedberga8a1d192011-11-10 15:54:38 +02001775 if (!cmd) {
1776 err = -ENOMEM;
1777 goto unlock;
1778 }
1779
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02001780 dc.handle = cpu_to_le16(conn->handle);
Johan Hedberga8a1d192011-11-10 15:54:38 +02001781 dc.reason = 0x13; /* Remote User Terminated Connection */
1782 err = hci_send_cmd(hdev, HCI_OP_DISCONNECT, sizeof(dc), &dc);
1783 if (err < 0)
1784 mgmt_pending_remove(cmd);
1785
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001786unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001787 hci_dev_unlock(hdev);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02001788 return err;
1789}
1790
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001791static int disconnect(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001792 u16 len)
Johan Hedberg8962ee72011-01-20 12:40:27 +02001793{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001794 struct mgmt_cp_disconnect *cp = data;
Johan Hedberg06a63b12013-01-20 14:27:21 +02001795 struct mgmt_rp_disconnect rp;
Johan Hedberg8962ee72011-01-20 12:40:27 +02001796 struct hci_cp_disconnect dc;
Johan Hedberg366a0332011-02-19 12:05:55 -03001797 struct pending_cmd *cmd;
Johan Hedberg8962ee72011-01-20 12:40:27 +02001798 struct hci_conn *conn;
Johan Hedberg8962ee72011-01-20 12:40:27 +02001799 int err;
1800
1801 BT_DBG("");
1802
Johan Hedberg06a63b12013-01-20 14:27:21 +02001803 memset(&rp, 0, sizeof(rp));
1804 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
1805 rp.addr.type = cp->addr.type;
1806
Johan Hedberg4ee71b22013-01-20 14:27:19 +02001807 if (!bdaddr_type_is_valid(cp->addr.type))
Johan Hedberg06a63b12013-01-20 14:27:21 +02001808 return cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
1809 MGMT_STATUS_INVALID_PARAMS,
1810 &rp, sizeof(rp));
Johan Hedberg4ee71b22013-01-20 14:27:19 +02001811
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001812 hci_dev_lock(hdev);
Johan Hedberg8962ee72011-01-20 12:40:27 +02001813
1814 if (!test_bit(HCI_UP, &hdev->flags)) {
Johan Hedberg06a63b12013-01-20 14:27:21 +02001815 err = cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
1816 MGMT_STATUS_NOT_POWERED, &rp, sizeof(rp));
Johan Hedberg8962ee72011-01-20 12:40:27 +02001817 goto failed;
1818 }
1819
Johan Hedberg2e58ef32011-11-08 20:40:15 +02001820 if (mgmt_pending_find(MGMT_OP_DISCONNECT, hdev)) {
Johan Hedberg06a63b12013-01-20 14:27:21 +02001821 err = cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
1822 MGMT_STATUS_BUSY, &rp, sizeof(rp));
Johan Hedberg8962ee72011-01-20 12:40:27 +02001823 goto failed;
1824 }
1825
Andre Guedes591f47f2012-04-24 21:02:49 -03001826 if (cp->addr.type == BDADDR_BREDR)
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03001827 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK,
1828 &cp->addr.bdaddr);
Johan Hedberg88c3df12012-02-09 14:27:38 +02001829 else
1830 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &cp->addr.bdaddr);
Vinicius Costa Gomes365227e2011-05-06 18:41:44 -03001831
Vishal Agarwalf9607272012-06-13 05:32:43 +05301832 if (!conn || conn->state == BT_OPEN || conn->state == BT_CLOSED) {
Johan Hedberg06a63b12013-01-20 14:27:21 +02001833 err = cmd_complete(sk, hdev->id, MGMT_OP_DISCONNECT,
1834 MGMT_STATUS_NOT_CONNECTED, &rp, sizeof(rp));
Johan Hedberg8962ee72011-01-20 12:40:27 +02001835 goto failed;
1836 }
1837
Johan Hedberg2e58ef32011-11-08 20:40:15 +02001838 cmd = mgmt_pending_add(sk, MGMT_OP_DISCONNECT, hdev, data, len);
Johan Hedberg366a0332011-02-19 12:05:55 -03001839 if (!cmd) {
1840 err = -ENOMEM;
Johan Hedberg8962ee72011-01-20 12:40:27 +02001841 goto failed;
Johan Hedberg366a0332011-02-19 12:05:55 -03001842 }
Johan Hedberg8962ee72011-01-20 12:40:27 +02001843
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02001844 dc.handle = cpu_to_le16(conn->handle);
Andre Guedes3701f942012-06-11 18:41:12 -03001845 dc.reason = HCI_ERROR_REMOTE_USER_TERM;
Johan Hedberg8962ee72011-01-20 12:40:27 +02001846
1847 err = hci_send_cmd(hdev, HCI_OP_DISCONNECT, sizeof(dc), &dc);
1848 if (err < 0)
Johan Hedberga664b5b2011-02-19 12:06:02 -03001849 mgmt_pending_remove(cmd);
Johan Hedberg8962ee72011-01-20 12:40:27 +02001850
1851failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001852 hci_dev_unlock(hdev);
Johan Hedberg8962ee72011-01-20 12:40:27 +02001853 return err;
1854}
1855
Andre Guedes57c14772012-04-24 21:02:50 -03001856static u8 link_to_bdaddr(u8 link_type, u8 addr_type)
Johan Hedberg4c659c32011-11-07 23:13:39 +02001857{
1858 switch (link_type) {
1859 case LE_LINK:
Johan Hedberg48264f02011-11-09 13:58:58 +02001860 switch (addr_type) {
1861 case ADDR_LE_DEV_PUBLIC:
Andre Guedes591f47f2012-04-24 21:02:49 -03001862 return BDADDR_LE_PUBLIC;
Andre Guedes0ed09142012-04-03 08:46:54 -03001863
Johan Hedberg48264f02011-11-09 13:58:58 +02001864 default:
Andre Guedes0ed09142012-04-03 08:46:54 -03001865 /* Fallback to LE Random address type */
Andre Guedes591f47f2012-04-24 21:02:49 -03001866 return BDADDR_LE_RANDOM;
Johan Hedberg48264f02011-11-09 13:58:58 +02001867 }
Andre Guedes0ed09142012-04-03 08:46:54 -03001868
Johan Hedberg4c659c32011-11-07 23:13:39 +02001869 default:
Andre Guedes0ed09142012-04-03 08:46:54 -03001870 /* Fallback to BR/EDR type */
Andre Guedes591f47f2012-04-24 21:02:49 -03001871 return BDADDR_BREDR;
Johan Hedberg4c659c32011-11-07 23:13:39 +02001872 }
1873}
1874
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001875static int get_connections(struct sock *sk, struct hci_dev *hdev, void *data,
1876 u16 data_len)
Johan Hedberg2784eb42011-01-21 13:56:35 +02001877{
Johan Hedberg2784eb42011-01-21 13:56:35 +02001878 struct mgmt_rp_get_connections *rp;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02001879 struct hci_conn *c;
Johan Hedberga38528f2011-01-22 06:46:43 +02001880 size_t rp_len;
Johan Hedberg60fc5fb62012-02-23 09:52:28 +02001881 int err;
1882 u16 i;
Johan Hedberg2784eb42011-01-21 13:56:35 +02001883
1884 BT_DBG("");
1885
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001886 hci_dev_lock(hdev);
Johan Hedberg2784eb42011-01-21 13:56:35 +02001887
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02001888 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001889 err = cmd_status(sk, hdev->id, MGMT_OP_GET_CONNECTIONS,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001890 MGMT_STATUS_NOT_POWERED);
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02001891 goto unlock;
1892 }
1893
Johan Hedberg60fc5fb62012-02-23 09:52:28 +02001894 i = 0;
Johan Hedbergb644ba32012-01-17 21:48:47 +02001895 list_for_each_entry(c, &hdev->conn_hash.list, list) {
1896 if (test_bit(HCI_CONN_MGMT_CONNECTED, &c->flags))
Johan Hedberg60fc5fb62012-02-23 09:52:28 +02001897 i++;
Johan Hedberg2784eb42011-01-21 13:56:35 +02001898 }
1899
Johan Hedberg60fc5fb62012-02-23 09:52:28 +02001900 rp_len = sizeof(*rp) + (i * sizeof(struct mgmt_addr_info));
Andre Guedes92c4c202012-06-07 19:05:44 -03001901 rp = kmalloc(rp_len, GFP_KERNEL);
Johan Hedberga38528f2011-01-22 06:46:43 +02001902 if (!rp) {
Johan Hedberg2784eb42011-01-21 13:56:35 +02001903 err = -ENOMEM;
1904 goto unlock;
1905 }
1906
Johan Hedberg2784eb42011-01-21 13:56:35 +02001907 i = 0;
Johan Hedberg4c659c32011-11-07 23:13:39 +02001908 list_for_each_entry(c, &hdev->conn_hash.list, list) {
Johan Hedbergb644ba32012-01-17 21:48:47 +02001909 if (!test_bit(HCI_CONN_MGMT_CONNECTED, &c->flags))
1910 continue;
Johan Hedberg4c659c32011-11-07 23:13:39 +02001911 bacpy(&rp->addr[i].bdaddr, &c->dst);
Andre Guedes57c14772012-04-24 21:02:50 -03001912 rp->addr[i].type = link_to_bdaddr(c->type, c->dst_type);
Andre Guedes0ed09142012-04-03 08:46:54 -03001913 if (c->type == SCO_LINK || c->type == ESCO_LINK)
Johan Hedberg4c659c32011-11-07 23:13:39 +02001914 continue;
1915 i++;
1916 }
1917
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02001918 rp->conn_count = cpu_to_le16(i);
Johan Hedberg60fc5fb62012-02-23 09:52:28 +02001919
Johan Hedberg4c659c32011-11-07 23:13:39 +02001920 /* Recalculate length in case of filtered SCO connections, etc */
1921 rp_len = sizeof(*rp) + (i * sizeof(struct mgmt_addr_info));
Johan Hedberg2784eb42011-01-21 13:56:35 +02001922
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001923 err = cmd_complete(sk, hdev->id, MGMT_OP_GET_CONNECTIONS, 0, rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001924 rp_len);
Johan Hedberg2784eb42011-01-21 13:56:35 +02001925
Johan Hedberga38528f2011-01-22 06:46:43 +02001926 kfree(rp);
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02001927
1928unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001929 hci_dev_unlock(hdev);
Johan Hedberg2784eb42011-01-21 13:56:35 +02001930 return err;
1931}
1932
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001933static int send_pin_code_neg_reply(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001934 struct mgmt_cp_pin_code_neg_reply *cp)
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02001935{
1936 struct pending_cmd *cmd;
1937 int err;
1938
Johan Hedberg2e58ef32011-11-08 20:40:15 +02001939 cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_NEG_REPLY, hdev, cp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001940 sizeof(*cp));
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02001941 if (!cmd)
1942 return -ENOMEM;
1943
Johan Hedbergd8457692012-02-17 14:24:57 +02001944 err = hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001945 sizeof(cp->addr.bdaddr), &cp->addr.bdaddr);
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02001946 if (err < 0)
1947 mgmt_pending_remove(cmd);
1948
1949 return err;
1950}
1951
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001952static int pin_code_reply(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001953 u16 len)
Johan Hedberg980e1a52011-01-22 06:10:07 +02001954{
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02001955 struct hci_conn *conn;
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03001956 struct mgmt_cp_pin_code_reply *cp = data;
Johan Hedberg980e1a52011-01-22 06:10:07 +02001957 struct hci_cp_pin_code_reply reply;
Johan Hedberg366a0332011-02-19 12:05:55 -03001958 struct pending_cmd *cmd;
Johan Hedberg980e1a52011-01-22 06:10:07 +02001959 int err;
1960
1961 BT_DBG("");
1962
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03001963 hci_dev_lock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +02001964
Johan Hedberg4b34ee782012-02-21 14:13:02 +02001965 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001966 err = cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001967 MGMT_STATUS_NOT_POWERED);
Johan Hedberg980e1a52011-01-22 06:10:07 +02001968 goto failed;
1969 }
1970
Johan Hedbergd8457692012-02-17 14:24:57 +02001971 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->addr.bdaddr);
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02001972 if (!conn) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001973 err = cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001974 MGMT_STATUS_NOT_CONNECTED);
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02001975 goto failed;
1976 }
1977
1978 if (conn->pending_sec_level == BT_SECURITY_HIGH && cp->pin_len != 16) {
Johan Hedbergd8457692012-02-17 14:24:57 +02001979 struct mgmt_cp_pin_code_neg_reply ncp;
1980
1981 memcpy(&ncp.addr, &cp->addr, sizeof(ncp.addr));
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02001982
1983 BT_ERR("PIN code is not 16 bytes long");
1984
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001985 err = send_pin_code_neg_reply(sk, hdev, &ncp);
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02001986 if (err >= 0)
Johan Hedbergbdb6d972012-02-28 06:13:32 +02001987 err = cmd_status(sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001988 MGMT_STATUS_INVALID_PARAMS);
Waldemar Rymarkiewicz96d97a62011-06-01 17:28:48 +02001989
1990 goto failed;
1991 }
1992
Gustavo F. Padovan00abfe42012-03-01 00:37:10 -03001993 cmd = mgmt_pending_add(sk, MGMT_OP_PIN_CODE_REPLY, hdev, data, len);
Johan Hedberg366a0332011-02-19 12:05:55 -03001994 if (!cmd) {
1995 err = -ENOMEM;
Johan Hedberg980e1a52011-01-22 06:10:07 +02001996 goto failed;
Johan Hedberg366a0332011-02-19 12:05:55 -03001997 }
Johan Hedberg980e1a52011-01-22 06:10:07 +02001998
Johan Hedbergd8457692012-02-17 14:24:57 +02001999 bacpy(&reply.bdaddr, &cp->addr.bdaddr);
Johan Hedberg980e1a52011-01-22 06:10:07 +02002000 reply.pin_len = cp->pin_len;
Waldemar Rymarkiewicz24718ca2011-06-01 17:28:47 +02002001 memcpy(reply.pin_code, cp->pin_code, sizeof(reply.pin_code));
Johan Hedberg980e1a52011-01-22 06:10:07 +02002002
2003 err = hci_send_cmd(hdev, HCI_OP_PIN_CODE_REPLY, sizeof(reply), &reply);
2004 if (err < 0)
Johan Hedberga664b5b2011-02-19 12:06:02 -03002005 mgmt_pending_remove(cmd);
Johan Hedberg980e1a52011-01-22 06:10:07 +02002006
2007failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002008 hci_dev_unlock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +02002009 return err;
2010}
2011
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002012static int set_io_capability(struct sock *sk, struct hci_dev *hdev, void *data,
2013 u16 len)
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002014{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002015 struct mgmt_cp_set_io_capability *cp = data;
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002016
2017 BT_DBG("");
2018
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002019 hci_dev_lock(hdev);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002020
2021 hdev->io_capability = cp->io_capability;
2022
2023 BT_DBG("%s IO capability set to 0x%02x", hdev->name,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002024 hdev->io_capability);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002025
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002026 hci_dev_unlock(hdev);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002027
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002028 return cmd_complete(sk, hdev->id, MGMT_OP_SET_IO_CAPABILITY, 0, NULL,
2029 0);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002030}
2031
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002032static struct pending_cmd *find_pairing(struct hci_conn *conn)
Johan Hedberge9a416b2011-02-19 12:05:56 -03002033{
2034 struct hci_dev *hdev = conn->hdev;
Luiz Augusto von Dentz8035ded2011-11-01 10:58:56 +02002035 struct pending_cmd *cmd;
Johan Hedberge9a416b2011-02-19 12:05:56 -03002036
Johan Hedberg2e58ef32011-11-08 20:40:15 +02002037 list_for_each_entry(cmd, &hdev->mgmt_pending, list) {
Johan Hedberge9a416b2011-02-19 12:05:56 -03002038 if (cmd->opcode != MGMT_OP_PAIR_DEVICE)
2039 continue;
2040
Johan Hedberge9a416b2011-02-19 12:05:56 -03002041 if (cmd->user_data != conn)
2042 continue;
2043
2044 return cmd;
2045 }
2046
2047 return NULL;
2048}
2049
2050static void pairing_complete(struct pending_cmd *cmd, u8 status)
2051{
2052 struct mgmt_rp_pair_device rp;
2053 struct hci_conn *conn = cmd->user_data;
2054
Johan Hedbergba4e5642011-11-11 00:07:34 +02002055 bacpy(&rp.addr.bdaddr, &conn->dst);
Andre Guedes57c14772012-04-24 21:02:50 -03002056 rp.addr.type = link_to_bdaddr(conn->type, conn->dst_type);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002057
Johan Hedbergaee9b212012-02-18 15:07:59 +02002058 cmd_complete(cmd->sk, cmd->index, MGMT_OP_PAIR_DEVICE, status,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002059 &rp, sizeof(rp));
Johan Hedberge9a416b2011-02-19 12:05:56 -03002060
2061 /* So we don't get further callbacks for this connection */
2062 conn->connect_cfm_cb = NULL;
2063 conn->security_cfm_cb = NULL;
2064 conn->disconn_cfm_cb = NULL;
2065
2066 hci_conn_put(conn);
2067
Johan Hedberga664b5b2011-02-19 12:06:02 -03002068 mgmt_pending_remove(cmd);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002069}
2070
2071static void pairing_complete_cb(struct hci_conn *conn, u8 status)
2072{
2073 struct pending_cmd *cmd;
2074
2075 BT_DBG("status %u", status);
2076
Johan Hedberg56e5cb82011-11-08 20:40:16 +02002077 cmd = find_pairing(conn);
2078 if (!cmd)
2079 BT_DBG("Unable to find a pending command");
2080 else
Johan Hedberge2113262012-02-18 15:20:03 +02002081 pairing_complete(cmd, mgmt_status(status));
Johan Hedberge9a416b2011-02-19 12:05:56 -03002082}
2083
Vishal Agarwal4c47d732012-06-07 20:27:35 +05302084static void le_connect_complete_cb(struct hci_conn *conn, u8 status)
2085{
2086 struct pending_cmd *cmd;
2087
2088 BT_DBG("status %u", status);
2089
2090 if (!status)
2091 return;
2092
2093 cmd = find_pairing(conn);
2094 if (!cmd)
2095 BT_DBG("Unable to find a pending command");
2096 else
2097 pairing_complete(cmd, mgmt_status(status));
2098}
2099
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002100static int pair_device(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002101 u16 len)
Johan Hedberge9a416b2011-02-19 12:05:56 -03002102{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002103 struct mgmt_cp_pair_device *cp = data;
Johan Hedberg1425acb2011-11-11 00:07:35 +02002104 struct mgmt_rp_pair_device rp;
Johan Hedberge9a416b2011-02-19 12:05:56 -03002105 struct pending_cmd *cmd;
2106 u8 sec_level, auth_type;
2107 struct hci_conn *conn;
Johan Hedberge9a416b2011-02-19 12:05:56 -03002108 int err;
2109
2110 BT_DBG("");
2111
Szymon Jancf950a30e2013-01-18 12:48:07 +01002112 memset(&rp, 0, sizeof(rp));
2113 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
2114 rp.addr.type = cp->addr.type;
2115
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002116 if (!bdaddr_type_is_valid(cp->addr.type))
2117 return cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
2118 MGMT_STATUS_INVALID_PARAMS,
2119 &rp, sizeof(rp));
2120
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002121 hci_dev_lock(hdev);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002122
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02002123 if (!hdev_is_powered(hdev)) {
Szymon Jancf950a30e2013-01-18 12:48:07 +01002124 err = cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
2125 MGMT_STATUS_NOT_POWERED, &rp, sizeof(rp));
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02002126 goto unlock;
2127 }
2128
Vinicius Costa Gomesc908df32011-09-02 14:51:22 -03002129 sec_level = BT_SECURITY_MEDIUM;
2130 if (cp->io_cap == 0x03)
Johan Hedberge9a416b2011-02-19 12:05:56 -03002131 auth_type = HCI_AT_DEDICATED_BONDING;
Vinicius Costa Gomesc908df32011-09-02 14:51:22 -03002132 else
Johan Hedberge9a416b2011-02-19 12:05:56 -03002133 auth_type = HCI_AT_DEDICATED_BONDING_MITM;
Johan Hedberge9a416b2011-02-19 12:05:56 -03002134
Andre Guedes591f47f2012-04-24 21:02:49 -03002135 if (cp->addr.type == BDADDR_BREDR)
Andre Guedesb12f62c2012-04-24 21:02:54 -03002136 conn = hci_connect(hdev, ACL_LINK, &cp->addr.bdaddr,
2137 cp->addr.type, sec_level, auth_type);
Vinicius Costa Gomes7a512d02011-08-19 21:06:54 -03002138 else
Andre Guedesb12f62c2012-04-24 21:02:54 -03002139 conn = hci_connect(hdev, LE_LINK, &cp->addr.bdaddr,
2140 cp->addr.type, sec_level, auth_type);
Vinicius Costa Gomes7a512d02011-08-19 21:06:54 -03002141
Ville Tervo30e76272011-02-22 16:10:53 -03002142 if (IS_ERR(conn)) {
Andrzej Kaczmarek489dc482012-05-30 15:39:22 +02002143 int status;
2144
2145 if (PTR_ERR(conn) == -EBUSY)
2146 status = MGMT_STATUS_BUSY;
2147 else
2148 status = MGMT_STATUS_CONNECT_FAILED;
2149
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002150 err = cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
Andrzej Kaczmarek489dc482012-05-30 15:39:22 +02002151 status, &rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002152 sizeof(rp));
Johan Hedberge9a416b2011-02-19 12:05:56 -03002153 goto unlock;
2154 }
2155
2156 if (conn->connect_cfm_cb) {
2157 hci_conn_put(conn);
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002158 err = cmd_complete(sk, hdev->id, MGMT_OP_PAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002159 MGMT_STATUS_BUSY, &rp, sizeof(rp));
Johan Hedberge9a416b2011-02-19 12:05:56 -03002160 goto unlock;
2161 }
2162
Johan Hedberg2e58ef32011-11-08 20:40:15 +02002163 cmd = mgmt_pending_add(sk, MGMT_OP_PAIR_DEVICE, hdev, data, len);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002164 if (!cmd) {
2165 err = -ENOMEM;
2166 hci_conn_put(conn);
2167 goto unlock;
2168 }
2169
Vinicius Costa Gomes7a512d02011-08-19 21:06:54 -03002170 /* For LE, just connecting isn't a proof that the pairing finished */
Andre Guedes591f47f2012-04-24 21:02:49 -03002171 if (cp->addr.type == BDADDR_BREDR)
Vinicius Costa Gomes7a512d02011-08-19 21:06:54 -03002172 conn->connect_cfm_cb = pairing_complete_cb;
Vishal Agarwal4c47d732012-06-07 20:27:35 +05302173 else
2174 conn->connect_cfm_cb = le_connect_complete_cb;
Vinicius Costa Gomes7a512d02011-08-19 21:06:54 -03002175
Johan Hedberge9a416b2011-02-19 12:05:56 -03002176 conn->security_cfm_cb = pairing_complete_cb;
2177 conn->disconn_cfm_cb = pairing_complete_cb;
2178 conn->io_capability = cp->io_cap;
2179 cmd->user_data = conn;
2180
2181 if (conn->state == BT_CONNECTED &&
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002182 hci_conn_security(conn, sec_level, auth_type))
Johan Hedberge9a416b2011-02-19 12:05:56 -03002183 pairing_complete(cmd, 0);
2184
2185 err = 0;
2186
2187unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002188 hci_dev_unlock(hdev);
Johan Hedberge9a416b2011-02-19 12:05:56 -03002189 return err;
2190}
2191
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002192static int cancel_pair_device(struct sock *sk, struct hci_dev *hdev, void *data,
2193 u16 len)
Johan Hedberg28424702012-02-02 04:02:29 +02002194{
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02002195 struct mgmt_addr_info *addr = data;
Johan Hedberg28424702012-02-02 04:02:29 +02002196 struct pending_cmd *cmd;
2197 struct hci_conn *conn;
2198 int err;
2199
2200 BT_DBG("");
2201
Johan Hedberg28424702012-02-02 04:02:29 +02002202 hci_dev_lock(hdev);
2203
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02002204 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002205 err = cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002206 MGMT_STATUS_NOT_POWERED);
Johan Hedberg5f97c1d2012-02-22 22:41:18 +02002207 goto unlock;
2208 }
2209
Johan Hedberg28424702012-02-02 04:02:29 +02002210 cmd = mgmt_pending_find(MGMT_OP_PAIR_DEVICE, hdev);
2211 if (!cmd) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002212 err = cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002213 MGMT_STATUS_INVALID_PARAMS);
Johan Hedberg28424702012-02-02 04:02:29 +02002214 goto unlock;
2215 }
2216
2217 conn = cmd->user_data;
2218
2219 if (bacmp(&addr->bdaddr, &conn->dst) != 0) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002220 err = cmd_status(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002221 MGMT_STATUS_INVALID_PARAMS);
Johan Hedberg28424702012-02-02 04:02:29 +02002222 goto unlock;
2223 }
2224
2225 pairing_complete(cmd, MGMT_STATUS_CANCELLED);
2226
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002227 err = cmd_complete(sk, hdev->id, MGMT_OP_CANCEL_PAIR_DEVICE, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002228 addr, sizeof(*addr));
Johan Hedberg28424702012-02-02 04:02:29 +02002229unlock:
2230 hci_dev_unlock(hdev);
Johan Hedberg28424702012-02-02 04:02:29 +02002231 return err;
2232}
2233
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002234static int user_pairing_resp(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002235 bdaddr_t *bdaddr, u8 type, u16 mgmt_op,
2236 u16 hci_op, __le32 passkey)
Johan Hedberga5c29682011-02-19 12:05:57 -03002237{
Johan Hedberga5c29682011-02-19 12:05:57 -03002238 struct pending_cmd *cmd;
Brian Gix0df4c182011-11-16 13:53:13 -08002239 struct hci_conn *conn;
Johan Hedberga5c29682011-02-19 12:05:57 -03002240 int err;
2241
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002242 hci_dev_lock(hdev);
Johan Hedberg08ba5382011-03-16 14:29:34 +02002243
Johan Hedberg4b34ee782012-02-21 14:13:02 +02002244 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002245 err = cmd_status(sk, hdev->id, mgmt_op,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002246 MGMT_STATUS_NOT_POWERED);
Brian Gix0df4c182011-11-16 13:53:13 -08002247 goto done;
Johan Hedberga5c29682011-02-19 12:05:57 -03002248 }
2249
Andre Guedes591f47f2012-04-24 21:02:49 -03002250 if (type == BDADDR_BREDR)
Johan Hedberg272d90d2012-02-09 15:26:12 +02002251 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, bdaddr);
2252 else
Brian Gix47c15e22011-11-16 13:53:14 -08002253 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, bdaddr);
Brian Gix47c15e22011-11-16 13:53:14 -08002254
Johan Hedberg272d90d2012-02-09 15:26:12 +02002255 if (!conn) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002256 err = cmd_status(sk, hdev->id, mgmt_op,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002257 MGMT_STATUS_NOT_CONNECTED);
Johan Hedberg272d90d2012-02-09 15:26:12 +02002258 goto done;
2259 }
2260
Andre Guedes591f47f2012-04-24 21:02:49 -03002261 if (type == BDADDR_LE_PUBLIC || type == BDADDR_LE_RANDOM) {
Brian Gix47c15e22011-11-16 13:53:14 -08002262 /* Continue with pairing via SMP */
Brian Gix5fe57d92011-12-21 16:12:13 -08002263 err = smp_user_confirm_reply(conn, mgmt_op, passkey);
Brian Gix47c15e22011-11-16 13:53:14 -08002264
Brian Gix5fe57d92011-12-21 16:12:13 -08002265 if (!err)
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002266 err = cmd_status(sk, hdev->id, mgmt_op,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002267 MGMT_STATUS_SUCCESS);
Brian Gix5fe57d92011-12-21 16:12:13 -08002268 else
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002269 err = cmd_status(sk, hdev->id, mgmt_op,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002270 MGMT_STATUS_FAILED);
Brian Gix5fe57d92011-12-21 16:12:13 -08002271
Brian Gix47c15e22011-11-16 13:53:14 -08002272 goto done;
2273 }
2274
Brian Gix0df4c182011-11-16 13:53:13 -08002275 cmd = mgmt_pending_add(sk, mgmt_op, hdev, bdaddr, sizeof(*bdaddr));
Johan Hedberga5c29682011-02-19 12:05:57 -03002276 if (!cmd) {
2277 err = -ENOMEM;
Brian Gix0df4c182011-11-16 13:53:13 -08002278 goto done;
Johan Hedberga5c29682011-02-19 12:05:57 -03002279 }
2280
Brian Gix0df4c182011-11-16 13:53:13 -08002281 /* Continue with pairing via HCI */
Brian Gix604086b2011-11-23 08:28:33 -08002282 if (hci_op == HCI_OP_USER_PASSKEY_REPLY) {
2283 struct hci_cp_user_passkey_reply cp;
2284
2285 bacpy(&cp.bdaddr, bdaddr);
2286 cp.passkey = passkey;
2287 err = hci_send_cmd(hdev, hci_op, sizeof(cp), &cp);
2288 } else
2289 err = hci_send_cmd(hdev, hci_op, sizeof(*bdaddr), bdaddr);
2290
Johan Hedberga664b5b2011-02-19 12:06:02 -03002291 if (err < 0)
2292 mgmt_pending_remove(cmd);
Johan Hedberga5c29682011-02-19 12:05:57 -03002293
Brian Gix0df4c182011-11-16 13:53:13 -08002294done:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002295 hci_dev_unlock(hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -03002296 return err;
2297}
2298
Jaganath Kanakkasseryafeb0192012-07-09 16:11:51 +05302299static int pin_code_neg_reply(struct sock *sk, struct hci_dev *hdev,
2300 void *data, u16 len)
2301{
2302 struct mgmt_cp_pin_code_neg_reply *cp = data;
2303
2304 BT_DBG("");
2305
2306 return user_pairing_resp(sk, hdev, &cp->addr.bdaddr, cp->addr.type,
2307 MGMT_OP_PIN_CODE_NEG_REPLY,
2308 HCI_OP_PIN_CODE_NEG_REPLY, 0);
2309}
2310
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002311static int user_confirm_reply(struct sock *sk, struct hci_dev *hdev, void *data,
2312 u16 len)
Brian Gix0df4c182011-11-16 13:53:13 -08002313{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002314 struct mgmt_cp_user_confirm_reply *cp = data;
Brian Gix0df4c182011-11-16 13:53:13 -08002315
2316 BT_DBG("");
2317
2318 if (len != sizeof(*cp))
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002319 return cmd_status(sk, hdev->id, MGMT_OP_USER_CONFIRM_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002320 MGMT_STATUS_INVALID_PARAMS);
Brian Gix0df4c182011-11-16 13:53:13 -08002321
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002322 return user_pairing_resp(sk, hdev, &cp->addr.bdaddr, cp->addr.type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002323 MGMT_OP_USER_CONFIRM_REPLY,
2324 HCI_OP_USER_CONFIRM_REPLY, 0);
Brian Gix0df4c182011-11-16 13:53:13 -08002325}
2326
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002327static int user_confirm_neg_reply(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002328 void *data, u16 len)
Brian Gix0df4c182011-11-16 13:53:13 -08002329{
Johan Hedbergc9c26592011-12-15 00:47:41 +02002330 struct mgmt_cp_user_confirm_neg_reply *cp = data;
Brian Gix0df4c182011-11-16 13:53:13 -08002331
2332 BT_DBG("");
2333
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002334 return user_pairing_resp(sk, hdev, &cp->addr.bdaddr, cp->addr.type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002335 MGMT_OP_USER_CONFIRM_NEG_REPLY,
2336 HCI_OP_USER_CONFIRM_NEG_REPLY, 0);
Brian Gix0df4c182011-11-16 13:53:13 -08002337}
2338
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002339static int user_passkey_reply(struct sock *sk, struct hci_dev *hdev, void *data,
2340 u16 len)
Brian Gix604086b2011-11-23 08:28:33 -08002341{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002342 struct mgmt_cp_user_passkey_reply *cp = data;
Brian Gix604086b2011-11-23 08:28:33 -08002343
2344 BT_DBG("");
2345
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002346 return user_pairing_resp(sk, hdev, &cp->addr.bdaddr, cp->addr.type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002347 MGMT_OP_USER_PASSKEY_REPLY,
2348 HCI_OP_USER_PASSKEY_REPLY, cp->passkey);
Brian Gix604086b2011-11-23 08:28:33 -08002349}
2350
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002351static int user_passkey_neg_reply(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002352 void *data, u16 len)
Brian Gix604086b2011-11-23 08:28:33 -08002353{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002354 struct mgmt_cp_user_passkey_neg_reply *cp = data;
Brian Gix604086b2011-11-23 08:28:33 -08002355
2356 BT_DBG("");
2357
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002358 return user_pairing_resp(sk, hdev, &cp->addr.bdaddr, cp->addr.type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002359 MGMT_OP_USER_PASSKEY_NEG_REPLY,
2360 HCI_OP_USER_PASSKEY_NEG_REPLY, 0);
Brian Gix604086b2011-11-23 08:28:33 -08002361}
2362
Johan Hedberg890ea892013-03-15 17:06:52 -05002363static void update_name(struct hci_request *req, const char *name)
Johan Hedberg2b4bf392012-03-03 00:19:06 +02002364{
2365 struct hci_cp_write_local_name cp;
2366
2367 memcpy(cp.name, name, sizeof(cp.name));
2368
Johan Hedberg890ea892013-03-15 17:06:52 -05002369 hci_req_add(req, HCI_OP_WRITE_LOCAL_NAME, sizeof(cp), &cp);
Johan Hedberg2b4bf392012-03-03 00:19:06 +02002370}
2371
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002372static int set_local_name(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002373 u16 len)
Johan Hedbergb312b1612011-03-16 14:29:37 +02002374{
Johan Hedberg2b4bf392012-03-03 00:19:06 +02002375 struct mgmt_cp_set_local_name *cp = data;
Johan Hedbergb312b1612011-03-16 14:29:37 +02002376 struct pending_cmd *cmd;
Johan Hedberg890ea892013-03-15 17:06:52 -05002377 struct hci_request req;
Johan Hedbergb312b1612011-03-16 14:29:37 +02002378 int err;
2379
2380 BT_DBG("");
2381
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002382 hci_dev_lock(hdev);
Johan Hedbergb312b1612011-03-16 14:29:37 +02002383
Johan Hedberg2b4bf392012-03-03 00:19:06 +02002384 memcpy(hdev->short_name, cp->short_name, sizeof(hdev->short_name));
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02002385
Johan Hedbergb5235a62012-02-21 14:32:24 +02002386 if (!hdev_is_powered(hdev)) {
Johan Hedberg2b4bf392012-03-03 00:19:06 +02002387 memcpy(hdev->dev_name, cp->name, sizeof(hdev->dev_name));
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02002388
2389 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002390 data, len);
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02002391 if (err < 0)
2392 goto failed;
2393
2394 err = mgmt_event(MGMT_EV_LOCAL_NAME_CHANGED, hdev, data, len,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002395 sk);
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02002396
Johan Hedbergb5235a62012-02-21 14:32:24 +02002397 goto failed;
2398 }
2399
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02002400 cmd = mgmt_pending_add(sk, MGMT_OP_SET_LOCAL_NAME, hdev, data, len);
Johan Hedbergb312b1612011-03-16 14:29:37 +02002401 if (!cmd) {
2402 err = -ENOMEM;
2403 goto failed;
2404 }
2405
Johan Hedberg890ea892013-03-15 17:06:52 -05002406 hci_req_init(&req, hdev);
2407 update_name(&req, cp->name);
2408 err = hci_req_run(&req, NULL);
Johan Hedbergb312b1612011-03-16 14:29:37 +02002409 if (err < 0)
2410 mgmt_pending_remove(cmd);
2411
2412failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002413 hci_dev_unlock(hdev);
Johan Hedbergb312b1612011-03-16 14:29:37 +02002414 return err;
2415}
2416
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02002417static int read_local_oob_data(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002418 void *data, u16 data_len)
Szymon Jancc35938b2011-03-22 13:12:21 +01002419{
Szymon Jancc35938b2011-03-22 13:12:21 +01002420 struct pending_cmd *cmd;
2421 int err;
2422
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002423 BT_DBG("%s", hdev->name);
Szymon Jancc35938b2011-03-22 13:12:21 +01002424
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002425 hci_dev_lock(hdev);
Szymon Jancc35938b2011-03-22 13:12:21 +01002426
Johan Hedberg4b34ee782012-02-21 14:13:02 +02002427 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002428 err = cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002429 MGMT_STATUS_NOT_POWERED);
Szymon Jancc35938b2011-03-22 13:12:21 +01002430 goto unlock;
2431 }
2432
Andre Guedes9a1a1992012-07-24 15:03:48 -03002433 if (!lmp_ssp_capable(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002434 err = cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002435 MGMT_STATUS_NOT_SUPPORTED);
Szymon Jancc35938b2011-03-22 13:12:21 +01002436 goto unlock;
2437 }
2438
Johan Hedberg2e58ef32011-11-08 20:40:15 +02002439 if (mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002440 err = cmd_status(sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002441 MGMT_STATUS_BUSY);
Szymon Jancc35938b2011-03-22 13:12:21 +01002442 goto unlock;
2443 }
2444
Johan Hedberg2e58ef32011-11-08 20:40:15 +02002445 cmd = mgmt_pending_add(sk, MGMT_OP_READ_LOCAL_OOB_DATA, hdev, NULL, 0);
Szymon Jancc35938b2011-03-22 13:12:21 +01002446 if (!cmd) {
2447 err = -ENOMEM;
2448 goto unlock;
2449 }
2450
2451 err = hci_send_cmd(hdev, HCI_OP_READ_LOCAL_OOB_DATA, 0, NULL);
2452 if (err < 0)
2453 mgmt_pending_remove(cmd);
2454
2455unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002456 hci_dev_unlock(hdev);
Szymon Jancc35938b2011-03-22 13:12:21 +01002457 return err;
2458}
2459
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002460static int add_remote_oob_data(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002461 void *data, u16 len)
Szymon Janc2763eda2011-03-22 13:12:22 +01002462{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002463 struct mgmt_cp_add_remote_oob_data *cp = data;
Johan Hedbergbf1e3542012-02-19 13:16:14 +02002464 u8 status;
Szymon Janc2763eda2011-03-22 13:12:22 +01002465 int err;
2466
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002467 BT_DBG("%s ", hdev->name);
Szymon Janc2763eda2011-03-22 13:12:22 +01002468
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002469 hci_dev_lock(hdev);
Szymon Janc2763eda2011-03-22 13:12:22 +01002470
Johan Hedberg664ce4c2012-02-09 15:44:09 +02002471 err = hci_add_remote_oob_data(hdev, &cp->addr.bdaddr, cp->hash,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002472 cp->randomizer);
Szymon Janc2763eda2011-03-22 13:12:22 +01002473 if (err < 0)
Johan Hedbergbf1e3542012-02-19 13:16:14 +02002474 status = MGMT_STATUS_FAILED;
Szymon Janc2763eda2011-03-22 13:12:22 +01002475 else
Szymon Janca6785be2012-12-13 15:11:21 +01002476 status = MGMT_STATUS_SUCCESS;
Johan Hedbergbf1e3542012-02-19 13:16:14 +02002477
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002478 err = cmd_complete(sk, hdev->id, MGMT_OP_ADD_REMOTE_OOB_DATA, status,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002479 &cp->addr, sizeof(cp->addr));
Szymon Janc2763eda2011-03-22 13:12:22 +01002480
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002481 hci_dev_unlock(hdev);
Szymon Janc2763eda2011-03-22 13:12:22 +01002482 return err;
2483}
2484
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002485static int remove_remote_oob_data(struct sock *sk, struct hci_dev *hdev,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002486 void *data, u16 len)
Szymon Janc2763eda2011-03-22 13:12:22 +01002487{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002488 struct mgmt_cp_remove_remote_oob_data *cp = data;
Johan Hedbergbf1e3542012-02-19 13:16:14 +02002489 u8 status;
Szymon Janc2763eda2011-03-22 13:12:22 +01002490 int err;
2491
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002492 BT_DBG("%s", hdev->name);
Szymon Janc2763eda2011-03-22 13:12:22 +01002493
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002494 hci_dev_lock(hdev);
Szymon Janc2763eda2011-03-22 13:12:22 +01002495
Johan Hedberg664ce4c2012-02-09 15:44:09 +02002496 err = hci_remove_remote_oob_data(hdev, &cp->addr.bdaddr);
Szymon Janc2763eda2011-03-22 13:12:22 +01002497 if (err < 0)
Johan Hedbergbf1e3542012-02-19 13:16:14 +02002498 status = MGMT_STATUS_INVALID_PARAMS;
Szymon Janc2763eda2011-03-22 13:12:22 +01002499 else
Szymon Janca6785be2012-12-13 15:11:21 +01002500 status = MGMT_STATUS_SUCCESS;
Johan Hedbergbf1e3542012-02-19 13:16:14 +02002501
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002502 err = cmd_complete(sk, hdev->id, MGMT_OP_REMOVE_REMOTE_OOB_DATA,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002503 status, &cp->addr, sizeof(cp->addr));
Szymon Janc2763eda2011-03-22 13:12:22 +01002504
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002505 hci_dev_unlock(hdev);
Szymon Janc2763eda2011-03-22 13:12:22 +01002506 return err;
2507}
2508
Andre Guedes5e0452c2012-02-17 20:39:38 -03002509int mgmt_interleaved_discovery(struct hci_dev *hdev)
2510{
2511 int err;
2512
2513 BT_DBG("%s", hdev->name);
2514
2515 hci_dev_lock(hdev);
2516
2517 err = hci_do_inquiry(hdev, INQUIRY_LEN_BREDR_LE);
2518 if (err < 0)
2519 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
2520
2521 hci_dev_unlock(hdev);
2522
2523 return err;
2524}
2525
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002526static int start_discovery(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002527 void *data, u16 len)
Johan Hedberg14a53662011-04-27 10:29:56 -04002528{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002529 struct mgmt_cp_start_discovery *cp = data;
Johan Hedberg14a53662011-04-27 10:29:56 -04002530 struct pending_cmd *cmd;
Johan Hedberg14a53662011-04-27 10:29:56 -04002531 int err;
2532
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002533 BT_DBG("%s", hdev->name);
Johan Hedberg14a53662011-04-27 10:29:56 -04002534
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002535 hci_dev_lock(hdev);
Johan Hedberg14a53662011-04-27 10:29:56 -04002536
Johan Hedberg4b34ee782012-02-21 14:13:02 +02002537 if (!hdev_is_powered(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002538 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002539 MGMT_STATUS_NOT_POWERED);
Johan Hedbergbd2d1332011-11-07 23:13:37 +02002540 goto failed;
2541 }
2542
Andre Guedes642be6c2012-03-21 00:03:37 -03002543 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags)) {
2544 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
2545 MGMT_STATUS_BUSY);
2546 goto failed;
2547 }
2548
Johan Hedbergff9ef572012-01-04 14:23:45 +02002549 if (hdev->discovery.state != DISCOVERY_STOPPED) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002550 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002551 MGMT_STATUS_BUSY);
Johan Hedbergff9ef572012-01-04 14:23:45 +02002552 goto failed;
2553 }
2554
Johan Hedberg2e58ef32011-11-08 20:40:15 +02002555 cmd = mgmt_pending_add(sk, MGMT_OP_START_DISCOVERY, hdev, NULL, 0);
Johan Hedberg14a53662011-04-27 10:29:56 -04002556 if (!cmd) {
2557 err = -ENOMEM;
2558 goto failed;
2559 }
2560
Andre Guedes4aab14e2012-02-17 20:39:36 -03002561 hdev->discovery.type = cp->type;
2562
2563 switch (hdev->discovery.type) {
Andre Guedesf39799f2012-02-17 20:39:35 -03002564 case DISCOV_TYPE_BREDR:
Johan Hedberg04106752013-01-10 14:54:09 +02002565 if (!lmp_bredr_capable(hdev)) {
2566 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
2567 MGMT_STATUS_NOT_SUPPORTED);
2568 mgmt_pending_remove(cmd);
2569 goto failed;
2570 }
2571
2572 err = hci_do_inquiry(hdev, INQUIRY_LEN_BREDR);
Andre Guedesf39799f2012-02-17 20:39:35 -03002573 break;
2574
2575 case DISCOV_TYPE_LE:
Johan Hedberg04106752013-01-10 14:54:09 +02002576 if (!lmp_host_le_capable(hdev)) {
2577 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
2578 MGMT_STATUS_NOT_SUPPORTED);
2579 mgmt_pending_remove(cmd);
2580 goto failed;
2581 }
2582
2583 err = hci_le_scan(hdev, LE_SCAN_TYPE, LE_SCAN_INT,
2584 LE_SCAN_WIN, LE_SCAN_TIMEOUT_LE_ONLY);
Andre Guedesf39799f2012-02-17 20:39:35 -03002585 break;
2586
Andre Guedes5e0452c2012-02-17 20:39:38 -03002587 case DISCOV_TYPE_INTERLEAVED:
Johan Hedberg04106752013-01-10 14:54:09 +02002588 if (!lmp_host_le_capable(hdev) || !lmp_bredr_capable(hdev)) {
2589 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
2590 MGMT_STATUS_NOT_SUPPORTED);
2591 mgmt_pending_remove(cmd);
2592 goto failed;
2593 }
2594
2595 err = hci_le_scan(hdev, LE_SCAN_TYPE, LE_SCAN_INT, LE_SCAN_WIN,
2596 LE_SCAN_TIMEOUT_BREDR_LE);
Andre Guedes5e0452c2012-02-17 20:39:38 -03002597 break;
2598
Andre Guedesf39799f2012-02-17 20:39:35 -03002599 default:
Johan Hedberg04106752013-01-10 14:54:09 +02002600 err = cmd_status(sk, hdev->id, MGMT_OP_START_DISCOVERY,
2601 MGMT_STATUS_INVALID_PARAMS);
2602 mgmt_pending_remove(cmd);
2603 goto failed;
Andre Guedesf39799f2012-02-17 20:39:35 -03002604 }
Andre Guedes3fd24152012-02-03 17:48:01 -03002605
Johan Hedberg14a53662011-04-27 10:29:56 -04002606 if (err < 0)
2607 mgmt_pending_remove(cmd);
Johan Hedbergff9ef572012-01-04 14:23:45 +02002608 else
2609 hci_discovery_set_state(hdev, DISCOVERY_STARTING);
Johan Hedberg14a53662011-04-27 10:29:56 -04002610
2611failed:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002612 hci_dev_unlock(hdev);
Johan Hedberg14a53662011-04-27 10:29:56 -04002613 return err;
2614}
2615
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002616static int stop_discovery(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002617 u16 len)
Johan Hedberg14a53662011-04-27 10:29:56 -04002618{
Johan Hedbergd9306502012-02-20 23:25:18 +02002619 struct mgmt_cp_stop_discovery *mgmt_cp = data;
Johan Hedberg14a53662011-04-27 10:29:56 -04002620 struct pending_cmd *cmd;
Johan Hedberg30dc78e2012-01-04 15:44:20 +02002621 struct hci_cp_remote_name_req_cancel cp;
2622 struct inquiry_entry *e;
Johan Hedberg14a53662011-04-27 10:29:56 -04002623 int err;
2624
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002625 BT_DBG("%s", hdev->name);
Johan Hedberg14a53662011-04-27 10:29:56 -04002626
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002627 hci_dev_lock(hdev);
Johan Hedberg14a53662011-04-27 10:29:56 -04002628
Johan Hedberg30dc78e2012-01-04 15:44:20 +02002629 if (!hci_discovery_active(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002630 err = cmd_complete(sk, hdev->id, MGMT_OP_STOP_DISCOVERY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002631 MGMT_STATUS_REJECTED, &mgmt_cp->type,
2632 sizeof(mgmt_cp->type));
Johan Hedbergd9306502012-02-20 23:25:18 +02002633 goto unlock;
2634 }
2635
2636 if (hdev->discovery.type != mgmt_cp->type) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002637 err = cmd_complete(sk, hdev->id, MGMT_OP_STOP_DISCOVERY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002638 MGMT_STATUS_INVALID_PARAMS, &mgmt_cp->type,
2639 sizeof(mgmt_cp->type));
Johan Hedberg30dc78e2012-01-04 15:44:20 +02002640 goto unlock;
Johan Hedbergff9ef572012-01-04 14:23:45 +02002641 }
2642
Johan Hedberg2e58ef32011-11-08 20:40:15 +02002643 cmd = mgmt_pending_add(sk, MGMT_OP_STOP_DISCOVERY, hdev, NULL, 0);
Johan Hedberg14a53662011-04-27 10:29:56 -04002644 if (!cmd) {
2645 err = -ENOMEM;
Johan Hedberg30dc78e2012-01-04 15:44:20 +02002646 goto unlock;
Johan Hedberg14a53662011-04-27 10:29:56 -04002647 }
2648
Andre Guedese0d9727e2012-03-20 15:15:36 -03002649 switch (hdev->discovery.state) {
2650 case DISCOVERY_FINDING:
Andre Guedesc9ecc482012-03-15 16:52:08 -03002651 if (test_bit(HCI_INQUIRY, &hdev->flags))
2652 err = hci_cancel_inquiry(hdev);
2653 else
2654 err = hci_cancel_le_scan(hdev);
2655
Andre Guedese0d9727e2012-03-20 15:15:36 -03002656 break;
2657
2658 case DISCOVERY_RESOLVING:
2659 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002660 NAME_PENDING);
Andre Guedese0d9727e2012-03-20 15:15:36 -03002661 if (!e) {
Johan Hedberg30dc78e2012-01-04 15:44:20 +02002662 mgmt_pending_remove(cmd);
Andre Guedese0d9727e2012-03-20 15:15:36 -03002663 err = cmd_complete(sk, hdev->id,
2664 MGMT_OP_STOP_DISCOVERY, 0,
2665 &mgmt_cp->type,
2666 sizeof(mgmt_cp->type));
2667 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
2668 goto unlock;
2669 }
2670
2671 bacpy(&cp.bdaddr, &e->data.bdaddr);
2672 err = hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ_CANCEL,
2673 sizeof(cp), &cp);
2674
2675 break;
2676
2677 default:
2678 BT_DBG("unknown discovery state %u", hdev->discovery.state);
2679 err = -EFAULT;
Johan Hedberg30dc78e2012-01-04 15:44:20 +02002680 }
2681
Johan Hedberg14a53662011-04-27 10:29:56 -04002682 if (err < 0)
2683 mgmt_pending_remove(cmd);
Johan Hedbergff9ef572012-01-04 14:23:45 +02002684 else
2685 hci_discovery_set_state(hdev, DISCOVERY_STOPPING);
Johan Hedberg14a53662011-04-27 10:29:56 -04002686
Johan Hedberg30dc78e2012-01-04 15:44:20 +02002687unlock:
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002688 hci_dev_unlock(hdev);
Johan Hedberg14a53662011-04-27 10:29:56 -04002689 return err;
2690}
2691
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002692static int confirm_name(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002693 u16 len)
Johan Hedberg561aafb2012-01-04 13:31:59 +02002694{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002695 struct mgmt_cp_confirm_name *cp = data;
Johan Hedberg561aafb2012-01-04 13:31:59 +02002696 struct inquiry_entry *e;
Johan Hedberg561aafb2012-01-04 13:31:59 +02002697 int err;
2698
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002699 BT_DBG("%s", hdev->name);
Johan Hedberg561aafb2012-01-04 13:31:59 +02002700
Johan Hedberg561aafb2012-01-04 13:31:59 +02002701 hci_dev_lock(hdev);
2702
Johan Hedberg30dc78e2012-01-04 15:44:20 +02002703 if (!hci_discovery_active(hdev)) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002704 err = cmd_status(sk, hdev->id, MGMT_OP_CONFIRM_NAME,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002705 MGMT_STATUS_FAILED);
Johan Hedberg30dc78e2012-01-04 15:44:20 +02002706 goto failed;
2707 }
2708
Johan Hedberga198e7b2012-02-17 14:27:06 +02002709 e = hci_inquiry_cache_lookup_unknown(hdev, &cp->addr.bdaddr);
Johan Hedberg561aafb2012-01-04 13:31:59 +02002710 if (!e) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002711 err = cmd_status(sk, hdev->id, MGMT_OP_CONFIRM_NAME,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002712 MGMT_STATUS_INVALID_PARAMS);
Johan Hedberg561aafb2012-01-04 13:31:59 +02002713 goto failed;
2714 }
2715
2716 if (cp->name_known) {
2717 e->name_state = NAME_KNOWN;
2718 list_del(&e->list);
2719 } else {
2720 e->name_state = NAME_NEEDED;
Johan Hedberga3d4e20a2012-01-09 00:53:02 +02002721 hci_inquiry_cache_update_resolve(hdev, e);
Johan Hedberg561aafb2012-01-04 13:31:59 +02002722 }
2723
Johan Hedberge3846622013-01-09 15:29:33 +02002724 err = cmd_complete(sk, hdev->id, MGMT_OP_CONFIRM_NAME, 0, &cp->addr,
2725 sizeof(cp->addr));
Johan Hedberg561aafb2012-01-04 13:31:59 +02002726
2727failed:
2728 hci_dev_unlock(hdev);
Johan Hedberg561aafb2012-01-04 13:31:59 +02002729 return err;
2730}
2731
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002732static int block_device(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002733 u16 len)
Antti Julku7fbec222011-06-15 12:01:15 +03002734{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002735 struct mgmt_cp_block_device *cp = data;
Johan Hedbergf0eeea82012-02-19 12:58:54 +02002736 u8 status;
Antti Julku7fbec222011-06-15 12:01:15 +03002737 int err;
2738
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002739 BT_DBG("%s", hdev->name);
Antti Julku7fbec222011-06-15 12:01:15 +03002740
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002741 if (!bdaddr_type_is_valid(cp->addr.type))
Johan Hedberg5d0846d2013-01-20 14:27:22 +02002742 return cmd_complete(sk, hdev->id, MGMT_OP_BLOCK_DEVICE,
2743 MGMT_STATUS_INVALID_PARAMS,
2744 &cp->addr, sizeof(cp->addr));
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002745
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002746 hci_dev_lock(hdev);
Antti Julku5e762442011-08-25 16:48:02 +03002747
Johan Hedberg88c1fe42012-02-09 15:56:11 +02002748 err = hci_blacklist_add(hdev, &cp->addr.bdaddr, cp->addr.type);
Antti Julku7fbec222011-06-15 12:01:15 +03002749 if (err < 0)
Johan Hedbergf0eeea82012-02-19 12:58:54 +02002750 status = MGMT_STATUS_FAILED;
Antti Julku7fbec222011-06-15 12:01:15 +03002751 else
Szymon Janca6785be2012-12-13 15:11:21 +01002752 status = MGMT_STATUS_SUCCESS;
Johan Hedbergf0eeea82012-02-19 12:58:54 +02002753
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002754 err = cmd_complete(sk, hdev->id, MGMT_OP_BLOCK_DEVICE, status,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002755 &cp->addr, sizeof(cp->addr));
Antti Julku5e762442011-08-25 16:48:02 +03002756
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002757 hci_dev_unlock(hdev);
Antti Julku7fbec222011-06-15 12:01:15 +03002758
2759 return err;
2760}
2761
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002762static int unblock_device(struct sock *sk, struct hci_dev *hdev, void *data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002763 u16 len)
Antti Julku7fbec222011-06-15 12:01:15 +03002764{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002765 struct mgmt_cp_unblock_device *cp = data;
Johan Hedbergf0eeea82012-02-19 12:58:54 +02002766 u8 status;
Antti Julku7fbec222011-06-15 12:01:15 +03002767 int err;
2768
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002769 BT_DBG("%s", hdev->name);
Antti Julku7fbec222011-06-15 12:01:15 +03002770
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002771 if (!bdaddr_type_is_valid(cp->addr.type))
Johan Hedberg5d0846d2013-01-20 14:27:22 +02002772 return cmd_complete(sk, hdev->id, MGMT_OP_UNBLOCK_DEVICE,
2773 MGMT_STATUS_INVALID_PARAMS,
2774 &cp->addr, sizeof(cp->addr));
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002775
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002776 hci_dev_lock(hdev);
Antti Julku5e762442011-08-25 16:48:02 +03002777
Johan Hedberg88c1fe42012-02-09 15:56:11 +02002778 err = hci_blacklist_del(hdev, &cp->addr.bdaddr, cp->addr.type);
Antti Julku7fbec222011-06-15 12:01:15 +03002779 if (err < 0)
Johan Hedbergf0eeea82012-02-19 12:58:54 +02002780 status = MGMT_STATUS_INVALID_PARAMS;
Antti Julku7fbec222011-06-15 12:01:15 +03002781 else
Szymon Janca6785be2012-12-13 15:11:21 +01002782 status = MGMT_STATUS_SUCCESS;
Johan Hedbergf0eeea82012-02-19 12:58:54 +02002783
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002784 err = cmd_complete(sk, hdev->id, MGMT_OP_UNBLOCK_DEVICE, status,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002785 &cp->addr, sizeof(cp->addr));
Antti Julku5e762442011-08-25 16:48:02 +03002786
Gustavo F. Padovan09fd0de2011-06-17 13:03:21 -03002787 hci_dev_unlock(hdev);
Antti Julku7fbec222011-06-15 12:01:15 +03002788
2789 return err;
2790}
2791
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07002792static int set_device_id(struct sock *sk, struct hci_dev *hdev, void *data,
2793 u16 len)
2794{
2795 struct mgmt_cp_set_device_id *cp = data;
Johan Hedberg890ea892013-03-15 17:06:52 -05002796 struct hci_request req;
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07002797 int err;
Szymon Jancc72d4b82012-03-16 16:02:57 +01002798 __u16 source;
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07002799
2800 BT_DBG("%s", hdev->name);
2801
Szymon Jancc72d4b82012-03-16 16:02:57 +01002802 source = __le16_to_cpu(cp->source);
2803
2804 if (source > 0x0002)
2805 return cmd_status(sk, hdev->id, MGMT_OP_SET_DEVICE_ID,
2806 MGMT_STATUS_INVALID_PARAMS);
2807
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07002808 hci_dev_lock(hdev);
2809
Szymon Jancc72d4b82012-03-16 16:02:57 +01002810 hdev->devid_source = source;
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07002811 hdev->devid_vendor = __le16_to_cpu(cp->vendor);
2812 hdev->devid_product = __le16_to_cpu(cp->product);
2813 hdev->devid_version = __le16_to_cpu(cp->version);
2814
2815 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_DEVICE_ID, 0, NULL, 0);
2816
Johan Hedberg890ea892013-03-15 17:06:52 -05002817 hci_req_init(&req, hdev);
2818 update_eir(&req);
2819 hci_req_run(&req, NULL);
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07002820
2821 hci_dev_unlock(hdev);
2822
2823 return err;
2824}
2825
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002826static int set_fast_connectable(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002827 void *data, u16 len)
Antti Julkuf6422ec2011-06-22 13:11:56 +03002828{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03002829 struct mgmt_mode *cp = data;
Antti Julkuf6422ec2011-06-22 13:11:56 +03002830 struct hci_cp_write_page_scan_activity acp;
2831 u8 type;
2832 int err;
2833
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002834 BT_DBG("%s", hdev->name);
Antti Julkuf6422ec2011-06-22 13:11:56 +03002835
Johan Hedberg33c525c2012-10-24 21:11:58 +03002836 if (!lmp_bredr_capable(hdev))
2837 return cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
2838 MGMT_STATUS_NOT_SUPPORTED);
2839
Johan Hedberga7e80f22013-01-09 16:05:19 +02002840 if (cp->val != 0x00 && cp->val != 0x01)
2841 return cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
2842 MGMT_STATUS_INVALID_PARAMS);
2843
Johan Hedberg5400c042012-02-21 16:40:33 +02002844 if (!hdev_is_powered(hdev))
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002845 return cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002846 MGMT_STATUS_NOT_POWERED);
Johan Hedberg5400c042012-02-21 16:40:33 +02002847
2848 if (!test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002849 return cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002850 MGMT_STATUS_REJECTED);
Antti Julkuf6422ec2011-06-22 13:11:56 +03002851
2852 hci_dev_lock(hdev);
2853
Johan Hedbergf7c6869ce2011-12-15 00:47:36 +02002854 if (cp->val) {
Antti Julkuf6422ec2011-06-22 13:11:56 +03002855 type = PAGE_SCAN_TYPE_INTERLACED;
Andrei Emeltchenko76ec9de2012-03-12 12:13:11 +02002856
Johan Hedberg83ce9a062012-06-28 13:44:30 +03002857 /* 160 msec page scan interval */
2858 acp.interval = __constant_cpu_to_le16(0x0100);
Antti Julkuf6422ec2011-06-22 13:11:56 +03002859 } else {
2860 type = PAGE_SCAN_TYPE_STANDARD; /* default */
Andrei Emeltchenko76ec9de2012-03-12 12:13:11 +02002861
2862 /* default 1.28 sec page scan */
2863 acp.interval = __constant_cpu_to_le16(0x0800);
Antti Julkuf6422ec2011-06-22 13:11:56 +03002864 }
2865
Andrei Emeltchenko76ec9de2012-03-12 12:13:11 +02002866 /* default 11.25 msec page scan window */
2867 acp.window = __constant_cpu_to_le16(0x0012);
Antti Julkuf6422ec2011-06-22 13:11:56 +03002868
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002869 err = hci_send_cmd(hdev, HCI_OP_WRITE_PAGE_SCAN_ACTIVITY, sizeof(acp),
2870 &acp);
Antti Julkuf6422ec2011-06-22 13:11:56 +03002871 if (err < 0) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002872 err = cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002873 MGMT_STATUS_FAILED);
Antti Julkuf6422ec2011-06-22 13:11:56 +03002874 goto done;
2875 }
2876
2877 err = hci_send_cmd(hdev, HCI_OP_WRITE_PAGE_SCAN_TYPE, 1, &type);
2878 if (err < 0) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002879 err = cmd_status(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002880 MGMT_STATUS_FAILED);
Antti Julkuf6422ec2011-06-22 13:11:56 +03002881 goto done;
2882 }
2883
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002884 err = cmd_complete(sk, hdev->id, MGMT_OP_SET_FAST_CONNECTABLE, 0,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002885 NULL, 0);
Antti Julkuf6422ec2011-06-22 13:11:56 +03002886done:
2887 hci_dev_unlock(hdev);
Antti Julkuf6422ec2011-06-22 13:11:56 +03002888 return err;
2889}
2890
Johan Hedberg3f706b72013-01-20 14:27:16 +02002891static bool ltk_is_valid(struct mgmt_ltk_info *key)
2892{
Johan Hedberg44b20d32013-01-20 14:27:17 +02002893 if (key->authenticated != 0x00 && key->authenticated != 0x01)
2894 return false;
Johan Hedberg3f706b72013-01-20 14:27:16 +02002895 if (key->master != 0x00 && key->master != 0x01)
2896 return false;
Johan Hedberg4ee71b22013-01-20 14:27:19 +02002897 if (!bdaddr_type_is_le(key->addr.type))
2898 return false;
Johan Hedberg3f706b72013-01-20 14:27:16 +02002899 return true;
2900}
2901
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002902static int load_long_term_keys(struct sock *sk, struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002903 void *cp_data, u16 len)
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03002904{
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03002905 struct mgmt_cp_load_long_term_keys *cp = cp_data;
2906 u16 key_count, expected_len;
Johan Hedberg715a5bf2013-01-09 15:29:34 +02002907 int i, err;
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03002908
Marcel Holtmann1f350c82012-03-12 20:31:08 -07002909 key_count = __le16_to_cpu(cp->key_count);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03002910
2911 expected_len = sizeof(*cp) + key_count *
2912 sizeof(struct mgmt_ltk_info);
2913 if (expected_len != len) {
2914 BT_ERR("load_keys: expected %u bytes, got %u bytes",
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03002915 len, expected_len);
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002916 return cmd_status(sk, hdev->id, MGMT_OP_LOAD_LONG_TERM_KEYS,
Johan Hedberge57e6192013-01-20 14:27:14 +02002917 MGMT_STATUS_INVALID_PARAMS);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03002918 }
2919
Johan Hedbergbdb6d972012-02-28 06:13:32 +02002920 BT_DBG("%s key_count %u", hdev->name, key_count);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03002921
Johan Hedberg54ad6d82013-01-20 14:27:15 +02002922 for (i = 0; i < key_count; i++) {
2923 struct mgmt_ltk_info *key = &cp->keys[i];
2924
Johan Hedberg3f706b72013-01-20 14:27:16 +02002925 if (!ltk_is_valid(key))
Johan Hedberg54ad6d82013-01-20 14:27:15 +02002926 return cmd_status(sk, hdev->id,
2927 MGMT_OP_LOAD_LONG_TERM_KEYS,
2928 MGMT_STATUS_INVALID_PARAMS);
2929 }
2930
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03002931 hci_dev_lock(hdev);
2932
2933 hci_smp_ltks_clear(hdev);
2934
2935 for (i = 0; i < key_count; i++) {
2936 struct mgmt_ltk_info *key = &cp->keys[i];
2937 u8 type;
2938
2939 if (key->master)
2940 type = HCI_SMP_LTK;
2941 else
2942 type = HCI_SMP_LTK_SLAVE;
2943
Hemant Gupta4596fde2012-04-16 14:57:40 +05302944 hci_add_ltk(hdev, &key->addr.bdaddr,
Andre Guedes378b5b72012-04-24 21:02:51 -03002945 bdaddr_to_le(key->addr.type),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002946 type, 0, key->authenticated, key->val,
2947 key->enc_size, key->ediv, key->rand);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03002948 }
2949
Johan Hedberg715a5bf2013-01-09 15:29:34 +02002950 err = cmd_complete(sk, hdev->id, MGMT_OP_LOAD_LONG_TERM_KEYS, 0,
2951 NULL, 0);
2952
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03002953 hci_dev_unlock(hdev);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03002954
Johan Hedberg715a5bf2013-01-09 15:29:34 +02002955 return err;
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03002956}
2957
Andrei Emeltchenko2e3c35e2012-03-14 18:54:15 +02002958static const struct mgmt_handler {
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002959 int (*func) (struct sock *sk, struct hci_dev *hdev, void *data,
2960 u16 data_len);
Johan Hedbergbe22b542012-03-01 22:24:41 +02002961 bool var_len;
2962 size_t data_len;
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02002963} mgmt_handlers[] = {
2964 { NULL }, /* 0x0000 (no command) */
Johan Hedbergbe22b542012-03-01 22:24:41 +02002965 { read_version, false, MGMT_READ_VERSION_SIZE },
2966 { read_commands, false, MGMT_READ_COMMANDS_SIZE },
2967 { read_index_list, false, MGMT_READ_INDEX_LIST_SIZE },
2968 { read_controller_info, false, MGMT_READ_INFO_SIZE },
2969 { set_powered, false, MGMT_SETTING_SIZE },
2970 { set_discoverable, false, MGMT_SET_DISCOVERABLE_SIZE },
2971 { set_connectable, false, MGMT_SETTING_SIZE },
2972 { set_fast_connectable, false, MGMT_SETTING_SIZE },
2973 { set_pairable, false, MGMT_SETTING_SIZE },
2974 { set_link_security, false, MGMT_SETTING_SIZE },
2975 { set_ssp, false, MGMT_SETTING_SIZE },
2976 { set_hs, false, MGMT_SETTING_SIZE },
2977 { set_le, false, MGMT_SETTING_SIZE },
2978 { set_dev_class, false, MGMT_SET_DEV_CLASS_SIZE },
2979 { set_local_name, false, MGMT_SET_LOCAL_NAME_SIZE },
2980 { add_uuid, false, MGMT_ADD_UUID_SIZE },
2981 { remove_uuid, false, MGMT_REMOVE_UUID_SIZE },
2982 { load_link_keys, true, MGMT_LOAD_LINK_KEYS_SIZE },
2983 { load_long_term_keys, true, MGMT_LOAD_LONG_TERM_KEYS_SIZE },
2984 { disconnect, false, MGMT_DISCONNECT_SIZE },
2985 { get_connections, false, MGMT_GET_CONNECTIONS_SIZE },
2986 { pin_code_reply, false, MGMT_PIN_CODE_REPLY_SIZE },
2987 { pin_code_neg_reply, false, MGMT_PIN_CODE_NEG_REPLY_SIZE },
2988 { set_io_capability, false, MGMT_SET_IO_CAPABILITY_SIZE },
2989 { pair_device, false, MGMT_PAIR_DEVICE_SIZE },
2990 { cancel_pair_device, false, MGMT_CANCEL_PAIR_DEVICE_SIZE },
2991 { unpair_device, false, MGMT_UNPAIR_DEVICE_SIZE },
2992 { user_confirm_reply, false, MGMT_USER_CONFIRM_REPLY_SIZE },
2993 { user_confirm_neg_reply, false, MGMT_USER_CONFIRM_NEG_REPLY_SIZE },
2994 { user_passkey_reply, false, MGMT_USER_PASSKEY_REPLY_SIZE },
2995 { user_passkey_neg_reply, false, MGMT_USER_PASSKEY_NEG_REPLY_SIZE },
2996 { read_local_oob_data, false, MGMT_READ_LOCAL_OOB_DATA_SIZE },
2997 { add_remote_oob_data, false, MGMT_ADD_REMOTE_OOB_DATA_SIZE },
2998 { remove_remote_oob_data, false, MGMT_REMOVE_REMOTE_OOB_DATA_SIZE },
2999 { start_discovery, false, MGMT_START_DISCOVERY_SIZE },
3000 { stop_discovery, false, MGMT_STOP_DISCOVERY_SIZE },
3001 { confirm_name, false, MGMT_CONFIRM_NAME_SIZE },
3002 { block_device, false, MGMT_BLOCK_DEVICE_SIZE },
3003 { unblock_device, false, MGMT_UNBLOCK_DEVICE_SIZE },
Marcel Holtmanncdbaccc2012-03-11 20:00:29 -07003004 { set_device_id, false, MGMT_SET_DEVICE_ID_SIZE },
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02003005};
3006
3007
Johan Hedberg03811012010-12-08 00:21:06 +02003008int mgmt_control(struct sock *sk, struct msghdr *msg, size_t msglen)
3009{
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03003010 void *buf;
3011 u8 *cp;
Johan Hedberg03811012010-12-08 00:21:06 +02003012 struct mgmt_hdr *hdr;
Szymon Janc4e51eae2011-02-25 19:05:48 +01003013 u16 opcode, index, len;
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003014 struct hci_dev *hdev = NULL;
Andrei Emeltchenko2e3c35e2012-03-14 18:54:15 +02003015 const struct mgmt_handler *handler;
Johan Hedberg03811012010-12-08 00:21:06 +02003016 int err;
3017
3018 BT_DBG("got %zu bytes", msglen);
3019
3020 if (msglen < sizeof(*hdr))
3021 return -EINVAL;
3022
Gustavo F. Padovane63a15e2011-04-04 18:56:53 -03003023 buf = kmalloc(msglen, GFP_KERNEL);
Johan Hedberg03811012010-12-08 00:21:06 +02003024 if (!buf)
3025 return -ENOMEM;
3026
3027 if (memcpy_fromiovec(buf, msg->msg_iov, msglen)) {
3028 err = -EFAULT;
3029 goto done;
3030 }
3031
Vinicius Costa Gomes650f7262012-02-02 21:07:59 -03003032 hdr = buf;
Marcel Holtmann1f350c82012-03-12 20:31:08 -07003033 opcode = __le16_to_cpu(hdr->opcode);
3034 index = __le16_to_cpu(hdr->index);
3035 len = __le16_to_cpu(hdr->len);
Johan Hedberg03811012010-12-08 00:21:06 +02003036
3037 if (len != msglen - sizeof(*hdr)) {
3038 err = -EINVAL;
3039 goto done;
3040 }
3041
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02003042 if (index != MGMT_INDEX_NONE) {
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003043 hdev = hci_dev_get(index);
3044 if (!hdev) {
3045 err = cmd_status(sk, index, opcode,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003046 MGMT_STATUS_INVALID_INDEX);
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003047 goto done;
3048 }
3049 }
3050
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02003051 if (opcode >= ARRAY_SIZE(mgmt_handlers) ||
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03003052 mgmt_handlers[opcode].func == NULL) {
Johan Hedberg03811012010-12-08 00:21:06 +02003053 BT_DBG("Unknown op %u", opcode);
Johan Hedbergca69b792011-11-11 18:10:00 +02003054 err = cmd_status(sk, index, opcode,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003055 MGMT_STATUS_UNKNOWN_COMMAND);
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02003056 goto done;
Johan Hedberg03811012010-12-08 00:21:06 +02003057 }
3058
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02003059 if ((hdev && opcode < MGMT_OP_READ_INFO) ||
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03003060 (!hdev && opcode >= MGMT_OP_READ_INFO)) {
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02003061 err = cmd_status(sk, index, opcode,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003062 MGMT_STATUS_INVALID_INDEX);
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02003063 goto done;
3064 }
3065
Johan Hedbergbe22b542012-03-01 22:24:41 +02003066 handler = &mgmt_handlers[opcode];
3067
3068 if ((handler->var_len && len < handler->data_len) ||
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03003069 (!handler->var_len && len != handler->data_len)) {
Johan Hedbergbe22b542012-03-01 22:24:41 +02003070 err = cmd_status(sk, index, opcode,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003071 MGMT_STATUS_INVALID_PARAMS);
Johan Hedbergbe22b542012-03-01 22:24:41 +02003072 goto done;
3073 }
3074
Johan Hedberg0f4e68c2012-02-28 17:18:30 +02003075 if (hdev)
3076 mgmt_init_hdev(sk, hdev);
3077
3078 cp = buf + sizeof(*hdr);
3079
Johan Hedbergbe22b542012-03-01 22:24:41 +02003080 err = handler->func(sk, hdev, cp, len);
Johan Hedberge41d8b42010-12-13 21:07:03 +02003081 if (err < 0)
3082 goto done;
3083
Johan Hedberg03811012010-12-08 00:21:06 +02003084 err = msglen;
3085
3086done:
Johan Hedbergbdb6d972012-02-28 06:13:32 +02003087 if (hdev)
3088 hci_dev_put(hdev);
3089
Johan Hedberg03811012010-12-08 00:21:06 +02003090 kfree(buf);
3091 return err;
3092}
Johan Hedbergc71e97b2010-12-13 21:07:07 +02003093
Johan Hedbergb24752f2011-11-03 14:40:33 +02003094static void cmd_status_rsp(struct pending_cmd *cmd, void *data)
3095{
3096 u8 *status = data;
3097
3098 cmd_status(cmd->sk, cmd->index, cmd->opcode, *status);
3099 mgmt_pending_remove(cmd);
3100}
3101
Johan Hedberg744cf192011-11-08 20:40:14 +02003102int mgmt_index_added(struct hci_dev *hdev)
Johan Hedbergc71e97b2010-12-13 21:07:07 +02003103{
Andrei Emeltchenkobb4b2a92012-07-19 17:03:40 +03003104 if (!mgmt_valid_hdev(hdev))
3105 return -ENOTSUPP;
3106
Johan Hedberg744cf192011-11-08 20:40:14 +02003107 return mgmt_event(MGMT_EV_INDEX_ADDED, hdev, NULL, 0, NULL);
Johan Hedbergc71e97b2010-12-13 21:07:07 +02003108}
3109
Johan Hedberg744cf192011-11-08 20:40:14 +02003110int mgmt_index_removed(struct hci_dev *hdev)
Johan Hedbergc71e97b2010-12-13 21:07:07 +02003111{
Johan Hedberg5f159032012-03-02 03:13:19 +02003112 u8 status = MGMT_STATUS_INVALID_INDEX;
Johan Hedbergb24752f2011-11-03 14:40:33 +02003113
Andrei Emeltchenkobb4b2a92012-07-19 17:03:40 +03003114 if (!mgmt_valid_hdev(hdev))
3115 return -ENOTSUPP;
3116
Johan Hedberg744cf192011-11-08 20:40:14 +02003117 mgmt_pending_foreach(0, hdev, cmd_status_rsp, &status);
Johan Hedbergb24752f2011-11-03 14:40:33 +02003118
Johan Hedberg744cf192011-11-08 20:40:14 +02003119 return mgmt_event(MGMT_EV_INDEX_REMOVED, hdev, NULL, 0, NULL);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02003120}
3121
Johan Hedberg73f22f62010-12-29 16:00:25 +02003122struct cmd_lookup {
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02003123 struct sock *sk;
Johan Hedberg69ab39e2011-12-15 00:47:35 +02003124 struct hci_dev *hdev;
Johan Hedberg90e70452012-02-23 23:09:40 +02003125 u8 mgmt_status;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02003126};
3127
Johan Hedberg69ab39e2011-12-15 00:47:35 +02003128static void settings_rsp(struct pending_cmd *cmd, void *data)
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02003129{
Johan Hedberg73f22f62010-12-29 16:00:25 +02003130 struct cmd_lookup *match = data;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02003131
Johan Hedberg69ab39e2011-12-15 00:47:35 +02003132 send_settings_rsp(cmd->sk, cmd->opcode, match->hdev);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02003133
3134 list_del(&cmd->list);
3135
3136 if (match->sk == NULL) {
3137 match->sk = cmd->sk;
3138 sock_hold(match->sk);
3139 }
3140
3141 mgmt_pending_free(cmd);
Johan Hedbergc71e97b2010-12-13 21:07:07 +02003142}
Johan Hedberg5add6af2010-12-16 10:00:37 +02003143
Johan Hedberg890ea892013-03-15 17:06:52 -05003144static void set_bredr_scan(struct hci_request *req)
Johan Hedberg7f0ae642012-10-24 21:11:57 +03003145{
Johan Hedberg890ea892013-03-15 17:06:52 -05003146 struct hci_dev *hdev = req->hdev;
Johan Hedberg7f0ae642012-10-24 21:11:57 +03003147 u8 scan = 0;
3148
3149 if (test_bit(HCI_CONNECTABLE, &hdev->dev_flags))
3150 scan |= SCAN_PAGE;
3151 if (test_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
3152 scan |= SCAN_INQUIRY;
3153
Johan Hedberg890ea892013-03-15 17:06:52 -05003154 if (scan)
3155 hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
Johan Hedberg7f0ae642012-10-24 21:11:57 +03003156}
3157
Johan Hedberg229ab392013-03-15 17:06:53 -05003158static void powered_complete(struct hci_dev *hdev, u8 status)
3159{
3160 struct cmd_lookup match = { NULL, hdev };
3161
3162 BT_DBG("status 0x%02x", status);
3163
3164 hci_dev_lock(hdev);
3165
3166 mgmt_pending_foreach(MGMT_OP_SET_POWERED, hdev, settings_rsp, &match);
3167
3168 new_settings(hdev, match.sk);
3169
3170 hci_dev_unlock(hdev);
3171
3172 if (match.sk)
3173 sock_put(match.sk);
3174}
3175
Johan Hedberg70da6242013-03-15 17:06:51 -05003176static int powered_update_hci(struct hci_dev *hdev)
3177{
Johan Hedberg890ea892013-03-15 17:06:52 -05003178 struct hci_request req;
Johan Hedberg70da6242013-03-15 17:06:51 -05003179 u8 link_sec;
3180
Johan Hedberg890ea892013-03-15 17:06:52 -05003181 hci_req_init(&req, hdev);
3182
Johan Hedberg70da6242013-03-15 17:06:51 -05003183 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags) &&
3184 !lmp_host_ssp_capable(hdev)) {
3185 u8 ssp = 1;
3186
Johan Hedberg890ea892013-03-15 17:06:52 -05003187 hci_req_add(&req, HCI_OP_WRITE_SSP_MODE, 1, &ssp);
Johan Hedberg70da6242013-03-15 17:06:51 -05003188 }
3189
3190 if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) {
3191 struct hci_cp_write_le_host_supported cp;
3192
3193 cp.le = 1;
3194 cp.simul = lmp_le_br_capable(hdev);
3195
3196 /* Check first if we already have the right
3197 * host state (host features set)
3198 */
3199 if (cp.le != lmp_host_le_capable(hdev) ||
3200 cp.simul != lmp_host_le_br_capable(hdev))
Johan Hedberg890ea892013-03-15 17:06:52 -05003201 hci_req_add(&req, HCI_OP_WRITE_LE_HOST_SUPPORTED,
3202 sizeof(cp), &cp);
Johan Hedberg70da6242013-03-15 17:06:51 -05003203 }
3204
3205 link_sec = test_bit(HCI_LINK_SECURITY, &hdev->dev_flags);
3206 if (link_sec != test_bit(HCI_AUTH, &hdev->flags))
Johan Hedberg890ea892013-03-15 17:06:52 -05003207 hci_req_add(&req, HCI_OP_WRITE_AUTH_ENABLE,
3208 sizeof(link_sec), &link_sec);
Johan Hedberg70da6242013-03-15 17:06:51 -05003209
3210 if (lmp_bredr_capable(hdev)) {
Johan Hedberg890ea892013-03-15 17:06:52 -05003211 set_bredr_scan(&req);
3212 update_class(&req);
3213 update_name(&req, hdev->dev_name);
3214 update_eir(&req);
Johan Hedberg70da6242013-03-15 17:06:51 -05003215 }
3216
Johan Hedberg229ab392013-03-15 17:06:53 -05003217 return hci_req_run(&req, powered_complete);
Johan Hedberg70da6242013-03-15 17:06:51 -05003218}
3219
Johan Hedberg744cf192011-11-08 20:40:14 +02003220int mgmt_powered(struct hci_dev *hdev, u8 powered)
Johan Hedberg5add6af2010-12-16 10:00:37 +02003221{
Johan Hedberg76a7f3a2012-02-17 00:34:40 +02003222 struct cmd_lookup match = { NULL, hdev };
Johan Hedberg229ab392013-03-15 17:06:53 -05003223 u8 status_not_powered = MGMT_STATUS_NOT_POWERED;
3224 u8 zero_cod[] = { 0, 0, 0 };
Johan Hedberg7bb895d2012-02-17 01:20:00 +02003225 int err;
Johan Hedberg5add6af2010-12-16 10:00:37 +02003226
Johan Hedberg5e5282b2012-02-21 16:01:30 +02003227 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
3228 return 0;
3229
Johan Hedberg5e5282b2012-02-21 16:01:30 +02003230 if (powered) {
Johan Hedberg229ab392013-03-15 17:06:53 -05003231 if (powered_update_hci(hdev) == 0)
3232 return 0;
Johan Hedbergfe038882013-01-16 16:15:34 +02003233
Johan Hedberg229ab392013-03-15 17:06:53 -05003234 mgmt_pending_foreach(MGMT_OP_SET_POWERED, hdev, settings_rsp,
3235 &match);
3236 goto new_settings;
Johan Hedbergb24752f2011-11-03 14:40:33 +02003237 }
3238
Johan Hedberg229ab392013-03-15 17:06:53 -05003239 mgmt_pending_foreach(MGMT_OP_SET_POWERED, hdev, settings_rsp, &match);
3240 mgmt_pending_foreach(0, hdev, cmd_status_rsp, &status_not_powered);
3241
3242 if (memcmp(hdev->dev_class, zero_cod, sizeof(zero_cod)) != 0)
3243 mgmt_event(MGMT_EV_CLASS_OF_DEV_CHANGED, hdev,
3244 zero_cod, sizeof(zero_cod), NULL);
3245
3246new_settings:
Johan Hedbergbeadb2b2012-02-21 16:55:31 +02003247 err = new_settings(hdev, match.sk);
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02003248
3249 if (match.sk)
3250 sock_put(match.sk);
3251
Johan Hedberg7bb895d2012-02-17 01:20:00 +02003252 return err;
Johan Hedberg5add6af2010-12-16 10:00:37 +02003253}
Johan Hedberg73f22f62010-12-29 16:00:25 +02003254
Johan Hedberg744cf192011-11-08 20:40:14 +02003255int mgmt_discoverable(struct hci_dev *hdev, u8 discoverable)
Johan Hedberg73f22f62010-12-29 16:00:25 +02003256{
Johan Hedberg76a7f3a2012-02-17 00:34:40 +02003257 struct cmd_lookup match = { NULL, hdev };
Johan Hedberg5e5282b2012-02-21 16:01:30 +02003258 bool changed = false;
3259 int err = 0;
Johan Hedberg73f22f62010-12-29 16:00:25 +02003260
Johan Hedberg5e5282b2012-02-21 16:01:30 +02003261 if (discoverable) {
3262 if (!test_and_set_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
3263 changed = true;
3264 } else {
3265 if (test_and_clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags))
3266 changed = true;
3267 }
Johan Hedberg73f22f62010-12-29 16:00:25 +02003268
Johan Hedberged9b5f22012-02-21 20:47:06 +02003269 mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE, hdev, settings_rsp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003270 &match);
Johan Hedberged9b5f22012-02-21 20:47:06 +02003271
Johan Hedbergbeadb2b2012-02-21 16:55:31 +02003272 if (changed)
3273 err = new_settings(hdev, match.sk);
Johan Hedberg5e5282b2012-02-21 16:01:30 +02003274
Johan Hedberg73f22f62010-12-29 16:00:25 +02003275 if (match.sk)
3276 sock_put(match.sk);
3277
Johan Hedberg7bb895d2012-02-17 01:20:00 +02003278 return err;
Johan Hedberg73f22f62010-12-29 16:00:25 +02003279}
Johan Hedberg9fbcbb42010-12-30 00:18:33 +02003280
Johan Hedberg744cf192011-11-08 20:40:14 +02003281int mgmt_connectable(struct hci_dev *hdev, u8 connectable)
Johan Hedberg9fbcbb42010-12-30 00:18:33 +02003282{
Johan Hedberg76a7f3a2012-02-17 00:34:40 +02003283 struct cmd_lookup match = { NULL, hdev };
Johan Hedberg5e5282b2012-02-21 16:01:30 +02003284 bool changed = false;
3285 int err = 0;
Johan Hedberg9fbcbb42010-12-30 00:18:33 +02003286
Johan Hedberg5e5282b2012-02-21 16:01:30 +02003287 if (connectable) {
3288 if (!test_and_set_bit(HCI_CONNECTABLE, &hdev->dev_flags))
3289 changed = true;
3290 } else {
3291 if (test_and_clear_bit(HCI_CONNECTABLE, &hdev->dev_flags))
3292 changed = true;
3293 }
Johan Hedberg9fbcbb42010-12-30 00:18:33 +02003294
Johan Hedberged9b5f22012-02-21 20:47:06 +02003295 mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE, hdev, settings_rsp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003296 &match);
Johan Hedberged9b5f22012-02-21 20:47:06 +02003297
Johan Hedbergbeadb2b2012-02-21 16:55:31 +02003298 if (changed)
3299 err = new_settings(hdev, match.sk);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +02003300
3301 if (match.sk)
3302 sock_put(match.sk);
3303
Johan Hedberg7bb895d2012-02-17 01:20:00 +02003304 return err;
Johan Hedberg9fbcbb42010-12-30 00:18:33 +02003305}
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02003306
Johan Hedberg744cf192011-11-08 20:40:14 +02003307int mgmt_write_scan_failed(struct hci_dev *hdev, u8 scan, u8 status)
Johan Hedberg2d7cee52011-11-07 22:16:03 +02003308{
Johan Hedbergca69b792011-11-11 18:10:00 +02003309 u8 mgmt_err = mgmt_status(status);
3310
Johan Hedberg2d7cee52011-11-07 22:16:03 +02003311 if (scan & SCAN_PAGE)
Johan Hedberg744cf192011-11-08 20:40:14 +02003312 mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE, hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003313 cmd_status_rsp, &mgmt_err);
Johan Hedberg2d7cee52011-11-07 22:16:03 +02003314
3315 if (scan & SCAN_INQUIRY)
Johan Hedberg744cf192011-11-08 20:40:14 +02003316 mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE, hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003317 cmd_status_rsp, &mgmt_err);
Johan Hedberg2d7cee52011-11-07 22:16:03 +02003318
3319 return 0;
3320}
3321
Cristian Chilipirea53168e52012-05-09 08:44:52 +03003322int mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
3323 bool persistent)
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02003324{
Johan Hedberg86742e12011-11-07 23:13:38 +02003325 struct mgmt_ev_new_link_key ev;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02003326
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03003327 memset(&ev, 0, sizeof(ev));
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02003328
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03003329 ev.store_hint = persistent;
Johan Hedbergd753fdc2012-02-17 14:06:34 +02003330 bacpy(&ev.key.addr.bdaddr, &key->bdaddr);
Andre Guedes591f47f2012-04-24 21:02:49 -03003331 ev.key.addr.type = BDADDR_BREDR;
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03003332 ev.key.type = key->type;
Andrei Emeltchenko9b3b4462012-05-23 11:31:20 +03003333 memcpy(ev.key.val, key->val, HCI_LINK_KEY_SIZE);
Vinicius Costa Gomesa492cd52011-08-25 20:02:29 -03003334 ev.key.pin_len = key->pin_len;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02003335
Johan Hedberg744cf192011-11-08 20:40:14 +02003336 return mgmt_event(MGMT_EV_NEW_LINK_KEY, hdev, &ev, sizeof(ev), NULL);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02003337}
Johan Hedbergf7520542011-01-20 12:34:39 +02003338
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03003339int mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, u8 persistent)
3340{
3341 struct mgmt_ev_new_long_term_key ev;
3342
3343 memset(&ev, 0, sizeof(ev));
3344
3345 ev.store_hint = persistent;
3346 bacpy(&ev.key.addr.bdaddr, &key->bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03003347 ev.key.addr.type = link_to_bdaddr(LE_LINK, key->bdaddr_type);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03003348 ev.key.authenticated = key->authenticated;
3349 ev.key.enc_size = key->enc_size;
3350 ev.key.ediv = key->ediv;
3351
3352 if (key->type == HCI_SMP_LTK)
3353 ev.key.master = 1;
3354
3355 memcpy(ev.key.rand, key->rand, sizeof(key->rand));
3356 memcpy(ev.key.val, key->val, sizeof(key->val));
3357
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003358 return mgmt_event(MGMT_EV_NEW_LONG_TERM_KEY, hdev, &ev, sizeof(ev),
3359 NULL);
Vinicius Costa Gomes346af672012-02-02 21:08:02 -03003360}
3361
Johan Hedbergafc747a2012-01-15 18:11:07 +02003362int mgmt_device_connected(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003363 u8 addr_type, u32 flags, u8 *name, u8 name_len,
3364 u8 *dev_class)
Johan Hedbergf7520542011-01-20 12:34:39 +02003365{
Johan Hedbergb644ba32012-01-17 21:48:47 +02003366 char buf[512];
3367 struct mgmt_ev_device_connected *ev = (void *) buf;
3368 u16 eir_len = 0;
Johan Hedbergf7520542011-01-20 12:34:39 +02003369
Johan Hedbergb644ba32012-01-17 21:48:47 +02003370 bacpy(&ev->addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03003371 ev->addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedbergf7520542011-01-20 12:34:39 +02003372
Johan Hedbergc95f0ba2012-02-23 22:54:38 +02003373 ev->flags = __cpu_to_le32(flags);
Johan Hedberg08c79b62012-02-23 22:31:51 +02003374
Johan Hedbergb644ba32012-01-17 21:48:47 +02003375 if (name_len > 0)
3376 eir_len = eir_append_data(ev->eir, 0, EIR_NAME_COMPLETE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003377 name, name_len);
Johan Hedbergb644ba32012-01-17 21:48:47 +02003378
3379 if (dev_class && memcmp(dev_class, "\0\0\0", 3) != 0)
Brian Gix53156382012-03-09 14:07:03 -08003380 eir_len = eir_append_data(ev->eir, eir_len,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003381 EIR_CLASS_OF_DEV, dev_class, 3);
Johan Hedbergb644ba32012-01-17 21:48:47 +02003382
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02003383 ev->eir_len = cpu_to_le16(eir_len);
Johan Hedbergb644ba32012-01-17 21:48:47 +02003384
3385 return mgmt_event(MGMT_EV_DEVICE_CONNECTED, hdev, buf,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003386 sizeof(*ev) + eir_len, NULL);
Johan Hedbergf7520542011-01-20 12:34:39 +02003387}
3388
Johan Hedberg8962ee72011-01-20 12:40:27 +02003389static void disconnect_rsp(struct pending_cmd *cmd, void *data)
3390{
Szymon Jancc68fb7f2011-03-22 13:12:19 +01003391 struct mgmt_cp_disconnect *cp = cmd->param;
Johan Hedberg8962ee72011-01-20 12:40:27 +02003392 struct sock **sk = data;
Johan Hedberga38528f2011-01-22 06:46:43 +02003393 struct mgmt_rp_disconnect rp;
Johan Hedberg8962ee72011-01-20 12:40:27 +02003394
Johan Hedberg88c3df12012-02-09 14:27:38 +02003395 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
3396 rp.addr.type = cp->addr.type;
Johan Hedberg8962ee72011-01-20 12:40:27 +02003397
Johan Hedbergaee9b212012-02-18 15:07:59 +02003398 cmd_complete(cmd->sk, cmd->index, MGMT_OP_DISCONNECT, 0, &rp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003399 sizeof(rp));
Johan Hedberg8962ee72011-01-20 12:40:27 +02003400
3401 *sk = cmd->sk;
3402 sock_hold(*sk);
3403
Johan Hedberga664b5b2011-02-19 12:06:02 -03003404 mgmt_pending_remove(cmd);
Johan Hedberg8962ee72011-01-20 12:40:27 +02003405}
3406
Johan Hedberg124f6e32012-02-09 13:50:12 +02003407static void unpair_device_rsp(struct pending_cmd *cmd, void *data)
Johan Hedberga8a1d192011-11-10 15:54:38 +02003408{
Johan Hedbergb1078ad2012-02-09 17:21:16 +02003409 struct hci_dev *hdev = data;
Johan Hedberg124f6e32012-02-09 13:50:12 +02003410 struct mgmt_cp_unpair_device *cp = cmd->param;
3411 struct mgmt_rp_unpair_device rp;
Johan Hedberga8a1d192011-11-10 15:54:38 +02003412
3413 memset(&rp, 0, sizeof(rp));
Johan Hedberg124f6e32012-02-09 13:50:12 +02003414 bacpy(&rp.addr.bdaddr, &cp->addr.bdaddr);
3415 rp.addr.type = cp->addr.type;
Johan Hedberga8a1d192011-11-10 15:54:38 +02003416
Johan Hedbergb1078ad2012-02-09 17:21:16 +02003417 device_unpaired(hdev, &cp->addr.bdaddr, cp->addr.type, cmd->sk);
3418
Johan Hedbergaee9b212012-02-18 15:07:59 +02003419 cmd_complete(cmd->sk, cmd->index, cmd->opcode, 0, &rp, sizeof(rp));
Johan Hedberga8a1d192011-11-10 15:54:38 +02003420
3421 mgmt_pending_remove(cmd);
3422}
3423
Johan Hedbergafc747a2012-01-15 18:11:07 +02003424int mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02003425 u8 link_type, u8 addr_type, u8 reason)
Johan Hedbergf7520542011-01-20 12:34:39 +02003426{
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02003427 struct mgmt_ev_device_disconnected ev;
Johan Hedberg8962ee72011-01-20 12:40:27 +02003428 struct sock *sk = NULL;
3429 int err;
3430
Johan Hedberg744cf192011-11-08 20:40:14 +02003431 mgmt_pending_foreach(MGMT_OP_DISCONNECT, hdev, disconnect_rsp, &sk);
Johan Hedbergf7520542011-01-20 12:34:39 +02003432
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02003433 bacpy(&ev.addr.bdaddr, bdaddr);
3434 ev.addr.type = link_to_bdaddr(link_type, addr_type);
3435 ev.reason = reason;
Johan Hedbergf7520542011-01-20 12:34:39 +02003436
Johan Hedbergafc747a2012-01-15 18:11:07 +02003437 err = mgmt_event(MGMT_EV_DEVICE_DISCONNECTED, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003438 sk);
Johan Hedberg8962ee72011-01-20 12:40:27 +02003439
3440 if (sk)
Szymon Jancd97dcb62012-03-16 16:02:56 +01003441 sock_put(sk);
Johan Hedberg8962ee72011-01-20 12:40:27 +02003442
Johan Hedberg124f6e32012-02-09 13:50:12 +02003443 mgmt_pending_foreach(MGMT_OP_UNPAIR_DEVICE, hdev, unpair_device_rsp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003444 hdev);
Johan Hedberga8a1d192011-11-10 15:54:38 +02003445
Johan Hedberg8962ee72011-01-20 12:40:27 +02003446 return err;
3447}
3448
Johan Hedberg88c3df12012-02-09 14:27:38 +02003449int mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003450 u8 link_type, u8 addr_type, u8 status)
Johan Hedberg8962ee72011-01-20 12:40:27 +02003451{
Johan Hedberg88c3df12012-02-09 14:27:38 +02003452 struct mgmt_rp_disconnect rp;
Johan Hedberg8962ee72011-01-20 12:40:27 +02003453 struct pending_cmd *cmd;
3454 int err;
3455
Jefferson Delfes36a75f12012-09-18 13:36:54 -04003456 mgmt_pending_foreach(MGMT_OP_UNPAIR_DEVICE, hdev, unpair_device_rsp,
3457 hdev);
3458
Johan Hedberg2e58ef32011-11-08 20:40:15 +02003459 cmd = mgmt_pending_find(MGMT_OP_DISCONNECT, hdev);
Johan Hedberg8962ee72011-01-20 12:40:27 +02003460 if (!cmd)
3461 return -ENOENT;
3462
Johan Hedberg88c3df12012-02-09 14:27:38 +02003463 bacpy(&rp.addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03003464 rp.addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedberg37d9ef72011-11-10 15:54:39 +02003465
Johan Hedberg88c3df12012-02-09 14:27:38 +02003466 err = cmd_complete(cmd->sk, cmd->index, MGMT_OP_DISCONNECT,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003467 mgmt_status(status), &rp, sizeof(rp));
Johan Hedberg8962ee72011-01-20 12:40:27 +02003468
Johan Hedberga664b5b2011-02-19 12:06:02 -03003469 mgmt_pending_remove(cmd);
Johan Hedberg8962ee72011-01-20 12:40:27 +02003470
3471 return err;
Johan Hedbergf7520542011-01-20 12:34:39 +02003472}
Johan Hedberg17d5c042011-01-22 06:09:08 +02003473
Johan Hedberg48264f02011-11-09 13:58:58 +02003474int mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003475 u8 addr_type, u8 status)
Johan Hedberg17d5c042011-01-22 06:09:08 +02003476{
3477 struct mgmt_ev_connect_failed ev;
3478
Johan Hedberg4c659c32011-11-07 23:13:39 +02003479 bacpy(&ev.addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03003480 ev.addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedbergca69b792011-11-11 18:10:00 +02003481 ev.status = mgmt_status(status);
Johan Hedberg17d5c042011-01-22 06:09:08 +02003482
Johan Hedberg744cf192011-11-08 20:40:14 +02003483 return mgmt_event(MGMT_EV_CONNECT_FAILED, hdev, &ev, sizeof(ev), NULL);
Johan Hedberg17d5c042011-01-22 06:09:08 +02003484}
Johan Hedberg980e1a52011-01-22 06:10:07 +02003485
Johan Hedberg744cf192011-11-08 20:40:14 +02003486int mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure)
Johan Hedberg980e1a52011-01-22 06:10:07 +02003487{
3488 struct mgmt_ev_pin_code_request ev;
3489
Johan Hedbergd8457692012-02-17 14:24:57 +02003490 bacpy(&ev.addr.bdaddr, bdaddr);
Andre Guedes591f47f2012-04-24 21:02:49 -03003491 ev.addr.type = BDADDR_BREDR;
Waldemar Rymarkiewicza770bb52011-04-28 12:07:59 +02003492 ev.secure = secure;
Johan Hedberg980e1a52011-01-22 06:10:07 +02003493
Johan Hedberg744cf192011-11-08 20:40:14 +02003494 return mgmt_event(MGMT_EV_PIN_CODE_REQUEST, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003495 NULL);
Johan Hedberg980e1a52011-01-22 06:10:07 +02003496}
3497
Johan Hedberg744cf192011-11-08 20:40:14 +02003498int mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003499 u8 status)
Johan Hedberg980e1a52011-01-22 06:10:07 +02003500{
3501 struct pending_cmd *cmd;
Johan Hedbergac56fb12011-02-19 12:05:59 -03003502 struct mgmt_rp_pin_code_reply rp;
Johan Hedberg980e1a52011-01-22 06:10:07 +02003503 int err;
3504
Johan Hedberg2e58ef32011-11-08 20:40:15 +02003505 cmd = mgmt_pending_find(MGMT_OP_PIN_CODE_REPLY, hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +02003506 if (!cmd)
3507 return -ENOENT;
3508
Johan Hedbergd8457692012-02-17 14:24:57 +02003509 bacpy(&rp.addr.bdaddr, bdaddr);
Andre Guedes591f47f2012-04-24 21:02:49 -03003510 rp.addr.type = BDADDR_BREDR;
Johan Hedbergac56fb12011-02-19 12:05:59 -03003511
Johan Hedbergaee9b212012-02-18 15:07:59 +02003512 err = cmd_complete(cmd->sk, hdev->id, MGMT_OP_PIN_CODE_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003513 mgmt_status(status), &rp, sizeof(rp));
Johan Hedberg980e1a52011-01-22 06:10:07 +02003514
Johan Hedberga664b5b2011-02-19 12:06:02 -03003515 mgmt_pending_remove(cmd);
Johan Hedberg980e1a52011-01-22 06:10:07 +02003516
3517 return err;
3518}
3519
Johan Hedberg744cf192011-11-08 20:40:14 +02003520int mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003521 u8 status)
Johan Hedberg980e1a52011-01-22 06:10:07 +02003522{
3523 struct pending_cmd *cmd;
Johan Hedbergac56fb12011-02-19 12:05:59 -03003524 struct mgmt_rp_pin_code_reply rp;
Johan Hedberg980e1a52011-01-22 06:10:07 +02003525 int err;
3526
Johan Hedberg2e58ef32011-11-08 20:40:15 +02003527 cmd = mgmt_pending_find(MGMT_OP_PIN_CODE_NEG_REPLY, hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +02003528 if (!cmd)
3529 return -ENOENT;
3530
Johan Hedbergd8457692012-02-17 14:24:57 +02003531 bacpy(&rp.addr.bdaddr, bdaddr);
Andre Guedes591f47f2012-04-24 21:02:49 -03003532 rp.addr.type = BDADDR_BREDR;
Johan Hedbergac56fb12011-02-19 12:05:59 -03003533
Johan Hedbergaee9b212012-02-18 15:07:59 +02003534 err = cmd_complete(cmd->sk, hdev->id, MGMT_OP_PIN_CODE_NEG_REPLY,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003535 mgmt_status(status), &rp, sizeof(rp));
Johan Hedberg980e1a52011-01-22 06:10:07 +02003536
Johan Hedberga664b5b2011-02-19 12:06:02 -03003537 mgmt_pending_remove(cmd);
Johan Hedberg980e1a52011-01-22 06:10:07 +02003538
3539 return err;
3540}
Johan Hedberga5c29682011-02-19 12:05:57 -03003541
Johan Hedberg744cf192011-11-08 20:40:14 +02003542int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003543 u8 link_type, u8 addr_type, __le32 value,
3544 u8 confirm_hint)
Johan Hedberga5c29682011-02-19 12:05:57 -03003545{
3546 struct mgmt_ev_user_confirm_request ev;
3547
Johan Hedberg744cf192011-11-08 20:40:14 +02003548 BT_DBG("%s", hdev->name);
Johan Hedberga5c29682011-02-19 12:05:57 -03003549
Johan Hedberg272d90d2012-02-09 15:26:12 +02003550 bacpy(&ev.addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03003551 ev.addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedberg55bc1a32011-04-28 11:28:56 -07003552 ev.confirm_hint = confirm_hint;
Andrei Emeltchenko78e80982012-03-09 13:00:50 +02003553 ev.value = value;
Johan Hedberga5c29682011-02-19 12:05:57 -03003554
Johan Hedberg744cf192011-11-08 20:40:14 +02003555 return mgmt_event(MGMT_EV_USER_CONFIRM_REQUEST, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003556 NULL);
Johan Hedberga5c29682011-02-19 12:05:57 -03003557}
3558
Johan Hedberg272d90d2012-02-09 15:26:12 +02003559int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03003560 u8 link_type, u8 addr_type)
Brian Gix604086b2011-11-23 08:28:33 -08003561{
3562 struct mgmt_ev_user_passkey_request ev;
3563
3564 BT_DBG("%s", hdev->name);
3565
Johan Hedberg272d90d2012-02-09 15:26:12 +02003566 bacpy(&ev.addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03003567 ev.addr.type = link_to_bdaddr(link_type, addr_type);
Brian Gix604086b2011-11-23 08:28:33 -08003568
3569 return mgmt_event(MGMT_EV_USER_PASSKEY_REQUEST, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003570 NULL);
Brian Gix604086b2011-11-23 08:28:33 -08003571}
3572
Brian Gix0df4c182011-11-16 13:53:13 -08003573static int user_pairing_resp_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo Padovan8ce8e2b2012-05-17 00:36:20 -03003574 u8 link_type, u8 addr_type, u8 status,
3575 u8 opcode)
Johan Hedberga5c29682011-02-19 12:05:57 -03003576{
3577 struct pending_cmd *cmd;
3578 struct mgmt_rp_user_confirm_reply rp;
3579 int err;
3580
Johan Hedberg2e58ef32011-11-08 20:40:15 +02003581 cmd = mgmt_pending_find(opcode, hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -03003582 if (!cmd)
3583 return -ENOENT;
3584
Johan Hedberg272d90d2012-02-09 15:26:12 +02003585 bacpy(&rp.addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03003586 rp.addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedbergaee9b212012-02-18 15:07:59 +02003587 err = cmd_complete(cmd->sk, hdev->id, opcode, mgmt_status(status),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003588 &rp, sizeof(rp));
Johan Hedberga5c29682011-02-19 12:05:57 -03003589
Johan Hedberga664b5b2011-02-19 12:06:02 -03003590 mgmt_pending_remove(cmd);
Johan Hedberga5c29682011-02-19 12:05:57 -03003591
3592 return err;
3593}
3594
Johan Hedberg744cf192011-11-08 20:40:14 +02003595int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003596 u8 link_type, u8 addr_type, u8 status)
Johan Hedberga5c29682011-02-19 12:05:57 -03003597{
Johan Hedberg272d90d2012-02-09 15:26:12 +02003598 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003599 status, MGMT_OP_USER_CONFIRM_REPLY);
Johan Hedberga5c29682011-02-19 12:05:57 -03003600}
3601
Johan Hedberg272d90d2012-02-09 15:26:12 +02003602int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003603 u8 link_type, u8 addr_type, u8 status)
Johan Hedberga5c29682011-02-19 12:05:57 -03003604{
Johan Hedberg272d90d2012-02-09 15:26:12 +02003605 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03003606 status,
3607 MGMT_OP_USER_CONFIRM_NEG_REPLY);
Johan Hedberga5c29682011-02-19 12:05:57 -03003608}
Johan Hedberg2a611692011-02-19 12:06:00 -03003609
Brian Gix604086b2011-11-23 08:28:33 -08003610int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003611 u8 link_type, u8 addr_type, u8 status)
Brian Gix604086b2011-11-23 08:28:33 -08003612{
Johan Hedberg272d90d2012-02-09 15:26:12 +02003613 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003614 status, MGMT_OP_USER_PASSKEY_REPLY);
Brian Gix604086b2011-11-23 08:28:33 -08003615}
3616
Johan Hedberg272d90d2012-02-09 15:26:12 +02003617int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003618 u8 link_type, u8 addr_type, u8 status)
Brian Gix604086b2011-11-23 08:28:33 -08003619{
Johan Hedberg272d90d2012-02-09 15:26:12 +02003620 return user_pairing_resp_complete(hdev, bdaddr, link_type, addr_type,
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03003621 status,
3622 MGMT_OP_USER_PASSKEY_NEG_REPLY);
Brian Gix604086b2011-11-23 08:28:33 -08003623}
3624
Johan Hedberg92a25252012-09-06 18:39:26 +03003625int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
3626 u8 link_type, u8 addr_type, u32 passkey,
3627 u8 entered)
3628{
3629 struct mgmt_ev_passkey_notify ev;
3630
3631 BT_DBG("%s", hdev->name);
3632
3633 bacpy(&ev.addr.bdaddr, bdaddr);
3634 ev.addr.type = link_to_bdaddr(link_type, addr_type);
3635 ev.passkey = __cpu_to_le32(passkey);
3636 ev.entered = entered;
3637
3638 return mgmt_event(MGMT_EV_PASSKEY_NOTIFY, hdev, &ev, sizeof(ev), NULL);
3639}
3640
Johan Hedbergbab73cb2012-02-09 16:07:29 +02003641int mgmt_auth_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003642 u8 addr_type, u8 status)
Johan Hedberg2a611692011-02-19 12:06:00 -03003643{
3644 struct mgmt_ev_auth_failed ev;
3645
Johan Hedbergbab73cb2012-02-09 16:07:29 +02003646 bacpy(&ev.addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03003647 ev.addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedbergca69b792011-11-11 18:10:00 +02003648 ev.status = mgmt_status(status);
Johan Hedberg2a611692011-02-19 12:06:00 -03003649
Johan Hedberg744cf192011-11-08 20:40:14 +02003650 return mgmt_event(MGMT_EV_AUTH_FAILED, hdev, &ev, sizeof(ev), NULL);
Johan Hedberg2a611692011-02-19 12:06:00 -03003651}
Johan Hedbergb312b1612011-03-16 14:29:37 +02003652
Johan Hedberg33ef95e2012-02-16 23:56:27 +02003653int mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status)
3654{
3655 struct cmd_lookup match = { NULL, hdev };
Johan Hedberg47990ea2012-02-22 11:58:37 +02003656 bool changed = false;
3657 int err = 0;
Johan Hedberg33ef95e2012-02-16 23:56:27 +02003658
3659 if (status) {
3660 u8 mgmt_err = mgmt_status(status);
3661 mgmt_pending_foreach(MGMT_OP_SET_LINK_SECURITY, hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003662 cmd_status_rsp, &mgmt_err);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02003663 return 0;
3664 }
3665
Johan Hedberg47990ea2012-02-22 11:58:37 +02003666 if (test_bit(HCI_AUTH, &hdev->flags)) {
3667 if (!test_and_set_bit(HCI_LINK_SECURITY, &hdev->dev_flags))
3668 changed = true;
3669 } else {
3670 if (test_and_clear_bit(HCI_LINK_SECURITY, &hdev->dev_flags))
3671 changed = true;
3672 }
3673
Johan Hedberg33ef95e2012-02-16 23:56:27 +02003674 mgmt_pending_foreach(MGMT_OP_SET_LINK_SECURITY, hdev, settings_rsp,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003675 &match);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02003676
Johan Hedberg47990ea2012-02-22 11:58:37 +02003677 if (changed)
3678 err = new_settings(hdev, match.sk);
Johan Hedberg33ef95e2012-02-16 23:56:27 +02003679
3680 if (match.sk)
3681 sock_put(match.sk);
3682
3683 return err;
3684}
3685
Johan Hedberg890ea892013-03-15 17:06:52 -05003686static void clear_eir(struct hci_request *req)
Johan Hedbergcacaf522012-02-21 00:52:42 +02003687{
Johan Hedberg890ea892013-03-15 17:06:52 -05003688 struct hci_dev *hdev = req->hdev;
Johan Hedbergcacaf522012-02-21 00:52:42 +02003689 struct hci_cp_write_eir cp;
3690
Johan Hedberg976eb202012-10-24 21:12:01 +03003691 if (!lmp_ext_inq_capable(hdev))
Johan Hedberg890ea892013-03-15 17:06:52 -05003692 return;
Johan Hedbergcacaf522012-02-21 00:52:42 +02003693
Johan Hedbergc80da272012-02-22 15:38:48 +02003694 memset(hdev->eir, 0, sizeof(hdev->eir));
3695
Johan Hedbergcacaf522012-02-21 00:52:42 +02003696 memset(&cp, 0, sizeof(cp));
3697
Johan Hedberg890ea892013-03-15 17:06:52 -05003698 hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp);
Johan Hedbergcacaf522012-02-21 00:52:42 +02003699}
3700
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02003701int mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status)
Johan Hedberged2c4ee2012-02-17 00:56:28 +02003702{
3703 struct cmd_lookup match = { NULL, hdev };
Johan Hedberg890ea892013-03-15 17:06:52 -05003704 struct hci_request req;
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02003705 bool changed = false;
3706 int err = 0;
Johan Hedberged2c4ee2012-02-17 00:56:28 +02003707
3708 if (status) {
3709 u8 mgmt_err = mgmt_status(status);
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02003710
3711 if (enable && test_and_clear_bit(HCI_SSP_ENABLED,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003712 &hdev->dev_flags))
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02003713 err = new_settings(hdev, NULL);
3714
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003715 mgmt_pending_foreach(MGMT_OP_SET_SSP, hdev, cmd_status_rsp,
3716 &mgmt_err);
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02003717
3718 return err;
3719 }
3720
3721 if (enable) {
3722 if (!test_and_set_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
3723 changed = true;
3724 } else {
3725 if (test_and_clear_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
3726 changed = true;
Johan Hedberged2c4ee2012-02-17 00:56:28 +02003727 }
3728
3729 mgmt_pending_foreach(MGMT_OP_SET_SSP, hdev, settings_rsp, &match);
3730
Johan Hedbergc0ecddc2012-02-22 12:38:31 +02003731 if (changed)
3732 err = new_settings(hdev, match.sk);
Johan Hedberged2c4ee2012-02-17 00:56:28 +02003733
Johan Hedberg5fc6ebb2012-02-22 15:10:59 +02003734 if (match.sk)
Johan Hedberged2c4ee2012-02-17 00:56:28 +02003735 sock_put(match.sk);
3736
Johan Hedberg890ea892013-03-15 17:06:52 -05003737 hci_req_init(&req, hdev);
3738
Johan Hedberg5fc6ebb2012-02-22 15:10:59 +02003739 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags))
Johan Hedberg890ea892013-03-15 17:06:52 -05003740 update_eir(&req);
Johan Hedberg5fc6ebb2012-02-22 15:10:59 +02003741 else
Johan Hedberg890ea892013-03-15 17:06:52 -05003742 clear_eir(&req);
3743
3744 hci_req_run(&req, NULL);
Johan Hedbergcacaf522012-02-21 00:52:42 +02003745
Johan Hedberged2c4ee2012-02-17 00:56:28 +02003746 return err;
3747}
3748
Johan Hedberg92da6092013-03-15 17:06:55 -05003749static void sk_lookup(struct pending_cmd *cmd, void *data)
Johan Hedberg90e70452012-02-23 23:09:40 +02003750{
3751 struct cmd_lookup *match = data;
3752
Johan Hedberg90e70452012-02-23 23:09:40 +02003753 if (match->sk == NULL) {
3754 match->sk = cmd->sk;
3755 sock_hold(match->sk);
3756 }
Johan Hedberg90e70452012-02-23 23:09:40 +02003757}
3758
Marcel Holtmann7f9a9032012-02-22 18:38:01 +01003759int mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003760 u8 status)
Marcel Holtmann7f9a9032012-02-22 18:38:01 +01003761{
Johan Hedberg90e70452012-02-23 23:09:40 +02003762 struct cmd_lookup match = { NULL, hdev, mgmt_status(status) };
3763 int err = 0;
Marcel Holtmann7f9a9032012-02-22 18:38:01 +01003764
Johan Hedbergc95f0ba2012-02-23 22:54:38 +02003765 clear_bit(HCI_PENDING_CLASS, &hdev->dev_flags);
3766
Johan Hedberg92da6092013-03-15 17:06:55 -05003767 mgmt_pending_foreach(MGMT_OP_SET_DEV_CLASS, hdev, sk_lookup, &match);
3768 mgmt_pending_foreach(MGMT_OP_ADD_UUID, hdev, sk_lookup, &match);
3769 mgmt_pending_foreach(MGMT_OP_REMOVE_UUID, hdev, sk_lookup, &match);
Johan Hedberg90e70452012-02-23 23:09:40 +02003770
3771 if (!status)
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003772 err = mgmt_event(MGMT_EV_CLASS_OF_DEV_CHANGED, hdev, dev_class,
3773 3, NULL);
Johan Hedberg90e70452012-02-23 23:09:40 +02003774
3775 if (match.sk)
3776 sock_put(match.sk);
Marcel Holtmann7f9a9032012-02-22 18:38:01 +01003777
3778 return err;
3779}
3780
Johan Hedberg744cf192011-11-08 20:40:14 +02003781int mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status)
Johan Hedbergb312b1612011-03-16 14:29:37 +02003782{
3783 struct pending_cmd *cmd;
3784 struct mgmt_cp_set_local_name ev;
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02003785 bool changed = false;
3786 int err = 0;
3787
3788 if (memcmp(name, hdev->dev_name, sizeof(hdev->dev_name)) != 0) {
3789 memcpy(hdev->dev_name, name, sizeof(hdev->dev_name));
3790 changed = true;
3791 }
Johan Hedbergb312b1612011-03-16 14:29:37 +02003792
3793 memset(&ev, 0, sizeof(ev));
3794 memcpy(ev.name, name, HCI_MAX_NAME_LENGTH);
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02003795 memcpy(ev.short_name, hdev->short_name, HCI_MAX_SHORT_NAME_LENGTH);
Johan Hedbergb312b1612011-03-16 14:29:37 +02003796
Johan Hedberg2e58ef32011-11-08 20:40:15 +02003797 cmd = mgmt_pending_find(MGMT_OP_SET_LOCAL_NAME, hdev);
Johan Hedbergb312b1612011-03-16 14:29:37 +02003798 if (!cmd)
3799 goto send_event;
3800
Johan Hedberg7bdaae42012-02-22 21:39:58 +02003801 /* Always assume that either the short or the complete name has
3802 * changed if there was a pending mgmt command */
3803 changed = true;
3804
Johan Hedbergb312b1612011-03-16 14:29:37 +02003805 if (status) {
Johan Hedberg744cf192011-11-08 20:40:14 +02003806 err = cmd_status(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003807 mgmt_status(status));
Johan Hedbergb312b1612011-03-16 14:29:37 +02003808 goto failed;
3809 }
3810
Johan Hedbergaee9b212012-02-18 15:07:59 +02003811 err = cmd_complete(cmd->sk, hdev->id, MGMT_OP_SET_LOCAL_NAME, 0, &ev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003812 sizeof(ev));
Johan Hedbergb312b1612011-03-16 14:29:37 +02003813 if (err < 0)
3814 goto failed;
3815
3816send_event:
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02003817 if (changed)
3818 err = mgmt_event(MGMT_EV_LOCAL_NAME_CHANGED, hdev, &ev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003819 sizeof(ev), cmd ? cmd->sk : NULL);
Johan Hedberg28cc7bd2012-02-22 21:06:55 +02003820
Johan Hedberg1225a6b2012-10-25 00:09:54 +03003821 /* EIR is taken care of separately when powering on the
3822 * adapter so only update them here if this is a name change
3823 * unrelated to power on.
3824 */
Johan Hedberg890ea892013-03-15 17:06:52 -05003825 if (!test_bit(HCI_INIT, &hdev->flags)) {
3826 struct hci_request req;
3827 hci_req_init(&req, hdev);
3828 update_eir(&req);
3829 hci_req_run(&req, NULL);
3830 }
Johan Hedbergb312b1612011-03-16 14:29:37 +02003831
3832failed:
3833 if (cmd)
3834 mgmt_pending_remove(cmd);
3835 return err;
3836}
Szymon Jancc35938b2011-03-22 13:12:21 +01003837
Johan Hedberg744cf192011-11-08 20:40:14 +02003838int mgmt_read_local_oob_data_reply_complete(struct hci_dev *hdev, u8 *hash,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003839 u8 *randomizer, u8 status)
Szymon Jancc35938b2011-03-22 13:12:21 +01003840{
3841 struct pending_cmd *cmd;
3842 int err;
3843
Johan Hedberg744cf192011-11-08 20:40:14 +02003844 BT_DBG("%s status %u", hdev->name, status);
Szymon Jancc35938b2011-03-22 13:12:21 +01003845
Johan Hedberg2e58ef32011-11-08 20:40:15 +02003846 cmd = mgmt_pending_find(MGMT_OP_READ_LOCAL_OOB_DATA, hdev);
Szymon Jancc35938b2011-03-22 13:12:21 +01003847 if (!cmd)
3848 return -ENOENT;
3849
3850 if (status) {
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003851 err = cmd_status(cmd->sk, hdev->id, MGMT_OP_READ_LOCAL_OOB_DATA,
3852 mgmt_status(status));
Szymon Jancc35938b2011-03-22 13:12:21 +01003853 } else {
3854 struct mgmt_rp_read_local_oob_data rp;
3855
3856 memcpy(rp.hash, hash, sizeof(rp.hash));
3857 memcpy(rp.randomizer, randomizer, sizeof(rp.randomizer));
3858
Johan Hedberg744cf192011-11-08 20:40:14 +02003859 err = cmd_complete(cmd->sk, hdev->id,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003860 MGMT_OP_READ_LOCAL_OOB_DATA, 0, &rp,
3861 sizeof(rp));
Szymon Jancc35938b2011-03-22 13:12:21 +01003862 }
3863
3864 mgmt_pending_remove(cmd);
3865
3866 return err;
3867}
Johan Hedberge17acd42011-03-30 23:57:16 +03003868
Johan Hedberg06199cf2012-02-22 16:37:11 +02003869int mgmt_le_enable_complete(struct hci_dev *hdev, u8 enable, u8 status)
3870{
3871 struct cmd_lookup match = { NULL, hdev };
3872 bool changed = false;
3873 int err = 0;
3874
3875 if (status) {
3876 u8 mgmt_err = mgmt_status(status);
3877
3878 if (enable && test_and_clear_bit(HCI_LE_ENABLED,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003879 &hdev->dev_flags))
Szymon Jancd97dcb62012-03-16 16:02:56 +01003880 err = new_settings(hdev, NULL);
Johan Hedberg06199cf2012-02-22 16:37:11 +02003881
Szymon Jancd97dcb62012-03-16 16:02:56 +01003882 mgmt_pending_foreach(MGMT_OP_SET_LE, hdev, cmd_status_rsp,
3883 &mgmt_err);
Johan Hedberg06199cf2012-02-22 16:37:11 +02003884
3885 return err;
3886 }
3887
3888 if (enable) {
3889 if (!test_and_set_bit(HCI_LE_ENABLED, &hdev->dev_flags))
3890 changed = true;
3891 } else {
3892 if (test_and_clear_bit(HCI_LE_ENABLED, &hdev->dev_flags))
3893 changed = true;
3894 }
3895
3896 mgmt_pending_foreach(MGMT_OP_SET_LE, hdev, settings_rsp, &match);
3897
3898 if (changed)
3899 err = new_settings(hdev, match.sk);
3900
3901 if (match.sk)
3902 sock_put(match.sk);
3903
3904 return err;
3905}
3906
Johan Hedberg48264f02011-11-09 13:58:58 +02003907int mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003908 u8 addr_type, u8 *dev_class, s8 rssi, u8 cfm_name, u8
3909 ssp, u8 *eir, u16 eir_len)
Johan Hedberge17acd42011-03-30 23:57:16 +03003910{
Johan Hedberge319d2e2012-01-15 19:51:59 +02003911 char buf[512];
3912 struct mgmt_ev_device_found *ev = (void *) buf;
Johan Hedberg1dc06092012-01-15 21:01:23 +02003913 size_t ev_size;
Johan Hedberge17acd42011-03-30 23:57:16 +03003914
Johan Hedberg1dc06092012-01-15 21:01:23 +02003915 /* Leave 5 bytes for a potential CoD field */
3916 if (sizeof(*ev) + eir_len + 5 > sizeof(buf))
Andre Guedes7d262f82012-01-10 18:20:49 -03003917 return -EINVAL;
3918
Johan Hedberg1dc06092012-01-15 21:01:23 +02003919 memset(buf, 0, sizeof(buf));
3920
Johan Hedberge319d2e2012-01-15 19:51:59 +02003921 bacpy(&ev->addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03003922 ev->addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedberge319d2e2012-01-15 19:51:59 +02003923 ev->rssi = rssi;
Johan Hedberg9a395a82012-02-23 00:00:32 +02003924 if (cfm_name)
Syam Sidhardhan612dfce2012-10-29 22:37:36 +05303925 ev->flags |= __constant_cpu_to_le32(MGMT_DEV_FOUND_CONFIRM_NAME);
Johan Hedberg388fc8f2012-02-23 00:38:59 +02003926 if (!ssp)
Syam Sidhardhan612dfce2012-10-29 22:37:36 +05303927 ev->flags |= __constant_cpu_to_le32(MGMT_DEV_FOUND_LEGACY_PAIRING);
Johan Hedberge17acd42011-03-30 23:57:16 +03003928
Johan Hedberg1dc06092012-01-15 21:01:23 +02003929 if (eir_len > 0)
Johan Hedberge319d2e2012-01-15 19:51:59 +02003930 memcpy(ev->eir, eir, eir_len);
Johan Hedberge17acd42011-03-30 23:57:16 +03003931
Johan Hedberg1dc06092012-01-15 21:01:23 +02003932 if (dev_class && !eir_has_data_type(ev->eir, eir_len, EIR_CLASS_OF_DEV))
3933 eir_len = eir_append_data(ev->eir, eir_len, EIR_CLASS_OF_DEV,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003934 dev_class, 3);
Johan Hedberg1dc06092012-01-15 21:01:23 +02003935
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02003936 ev->eir_len = cpu_to_le16(eir_len);
Johan Hedberg1dc06092012-01-15 21:01:23 +02003937 ev_size = sizeof(*ev) + eir_len;
Andre Guedesf8523592011-09-09 18:56:26 -03003938
Johan Hedberge319d2e2012-01-15 19:51:59 +02003939 return mgmt_event(MGMT_EV_DEVICE_FOUND, hdev, ev, ev_size, NULL);
Johan Hedberge17acd42011-03-30 23:57:16 +03003940}
Johan Hedberga88a9652011-03-30 13:18:12 +03003941
Johan Hedbergb644ba32012-01-17 21:48:47 +02003942int mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003943 u8 addr_type, s8 rssi, u8 *name, u8 name_len)
Johan Hedberga88a9652011-03-30 13:18:12 +03003944{
Johan Hedbergb644ba32012-01-17 21:48:47 +02003945 struct mgmt_ev_device_found *ev;
3946 char buf[sizeof(*ev) + HCI_MAX_NAME_LENGTH + 2];
3947 u16 eir_len;
Johan Hedberga88a9652011-03-30 13:18:12 +03003948
Johan Hedbergb644ba32012-01-17 21:48:47 +02003949 ev = (struct mgmt_ev_device_found *) buf;
Johan Hedberga88a9652011-03-30 13:18:12 +03003950
Johan Hedbergb644ba32012-01-17 21:48:47 +02003951 memset(buf, 0, sizeof(buf));
Johan Hedberga88a9652011-03-30 13:18:12 +03003952
Johan Hedbergb644ba32012-01-17 21:48:47 +02003953 bacpy(&ev->addr.bdaddr, bdaddr);
Andre Guedes57c14772012-04-24 21:02:50 -03003954 ev->addr.type = link_to_bdaddr(link_type, addr_type);
Johan Hedbergb644ba32012-01-17 21:48:47 +02003955 ev->rssi = rssi;
3956
3957 eir_len = eir_append_data(ev->eir, 0, EIR_NAME_COMPLETE, name,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003958 name_len);
Johan Hedbergb644ba32012-01-17 21:48:47 +02003959
Marcel Holtmanneb55ef02012-03-14 18:08:46 +02003960 ev->eir_len = cpu_to_le16(eir_len);
Johan Hedbergb644ba32012-01-17 21:48:47 +02003961
Johan Hedberg053c7e02012-02-04 00:06:00 +02003962 return mgmt_event(MGMT_EV_DEVICE_FOUND, hdev, ev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003963 sizeof(*ev) + eir_len, NULL);
Johan Hedberga88a9652011-03-30 13:18:12 +03003964}
Johan Hedberg314b2382011-04-27 10:29:57 -04003965
Andre Guedes7a135102011-11-09 17:14:25 -03003966int mgmt_start_discovery_failed(struct hci_dev *hdev, u8 status)
Johan Hedberg164a6e72011-11-01 17:06:44 +02003967{
3968 struct pending_cmd *cmd;
Johan Hedbergf808e162012-02-19 12:52:07 +02003969 u8 type;
Johan Hedberg164a6e72011-11-01 17:06:44 +02003970 int err;
3971
Andre Guedes203159d2012-02-13 15:41:01 -03003972 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
3973
Johan Hedberg2e58ef32011-11-08 20:40:15 +02003974 cmd = mgmt_pending_find(MGMT_OP_START_DISCOVERY, hdev);
Johan Hedberg164a6e72011-11-01 17:06:44 +02003975 if (!cmd)
3976 return -ENOENT;
3977
Johan Hedbergf808e162012-02-19 12:52:07 +02003978 type = hdev->discovery.type;
3979
3980 err = cmd_complete(cmd->sk, hdev->id, cmd->opcode, mgmt_status(status),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003981 &type, sizeof(type));
Johan Hedberg164a6e72011-11-01 17:06:44 +02003982 mgmt_pending_remove(cmd);
3983
3984 return err;
3985}
3986
Andre Guedese6d465c2011-11-09 17:14:26 -03003987int mgmt_stop_discovery_failed(struct hci_dev *hdev, u8 status)
3988{
3989 struct pending_cmd *cmd;
3990 int err;
3991
3992 cmd = mgmt_pending_find(MGMT_OP_STOP_DISCOVERY, hdev);
3993 if (!cmd)
3994 return -ENOENT;
3995
Johan Hedbergd9306502012-02-20 23:25:18 +02003996 err = cmd_complete(cmd->sk, hdev->id, cmd->opcode, mgmt_status(status),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003997 &hdev->discovery.type, sizeof(hdev->discovery.type));
Johan Hedberg03811012010-12-08 00:21:06 +02003998 mgmt_pending_remove(cmd);
3999
4000 return err;
4001}
Johan Hedberg314b2382011-04-27 10:29:57 -04004002
Johan Hedberg744cf192011-11-08 20:40:14 +02004003int mgmt_discovering(struct hci_dev *hdev, u8 discovering)
Johan Hedberg314b2382011-04-27 10:29:57 -04004004{
Johan Hedbergf963e8e2012-02-20 23:30:44 +02004005 struct mgmt_ev_discovering ev;
Johan Hedberg164a6e72011-11-01 17:06:44 +02004006 struct pending_cmd *cmd;
4007
Andre Guedes343fb142011-11-22 17:14:19 -03004008 BT_DBG("%s discovering %u", hdev->name, discovering);
4009
Johan Hedberg164a6e72011-11-01 17:06:44 +02004010 if (discovering)
Johan Hedberg2e58ef32011-11-08 20:40:15 +02004011 cmd = mgmt_pending_find(MGMT_OP_START_DISCOVERY, hdev);
Johan Hedberg164a6e72011-11-01 17:06:44 +02004012 else
Johan Hedberg2e58ef32011-11-08 20:40:15 +02004013 cmd = mgmt_pending_find(MGMT_OP_STOP_DISCOVERY, hdev);
Johan Hedberg164a6e72011-11-01 17:06:44 +02004014
4015 if (cmd != NULL) {
Johan Hedbergf808e162012-02-19 12:52:07 +02004016 u8 type = hdev->discovery.type;
4017
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004018 cmd_complete(cmd->sk, hdev->id, cmd->opcode, 0, &type,
4019 sizeof(type));
Johan Hedberg164a6e72011-11-01 17:06:44 +02004020 mgmt_pending_remove(cmd);
4021 }
4022
Johan Hedbergf963e8e2012-02-20 23:30:44 +02004023 memset(&ev, 0, sizeof(ev));
4024 ev.type = hdev->discovery.type;
4025 ev.discovering = discovering;
4026
4027 return mgmt_event(MGMT_EV_DISCOVERING, hdev, &ev, sizeof(ev), NULL);
Johan Hedberg314b2382011-04-27 10:29:57 -04004028}
Antti Julku5e762442011-08-25 16:48:02 +03004029
Johan Hedberg88c1fe42012-02-09 15:56:11 +02004030int mgmt_device_blocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
Antti Julku5e762442011-08-25 16:48:02 +03004031{
4032 struct pending_cmd *cmd;
4033 struct mgmt_ev_device_blocked ev;
4034
Johan Hedberg2e58ef32011-11-08 20:40:15 +02004035 cmd = mgmt_pending_find(MGMT_OP_BLOCK_DEVICE, hdev);
Antti Julku5e762442011-08-25 16:48:02 +03004036
Johan Hedberg88c1fe42012-02-09 15:56:11 +02004037 bacpy(&ev.addr.bdaddr, bdaddr);
4038 ev.addr.type = type;
Antti Julku5e762442011-08-25 16:48:02 +03004039
Johan Hedberg744cf192011-11-08 20:40:14 +02004040 return mgmt_event(MGMT_EV_DEVICE_BLOCKED, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004041 cmd ? cmd->sk : NULL);
Antti Julku5e762442011-08-25 16:48:02 +03004042}
4043
Johan Hedberg88c1fe42012-02-09 15:56:11 +02004044int mgmt_device_unblocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
Antti Julku5e762442011-08-25 16:48:02 +03004045{
4046 struct pending_cmd *cmd;
4047 struct mgmt_ev_device_unblocked ev;
4048
Johan Hedberg2e58ef32011-11-08 20:40:15 +02004049 cmd = mgmt_pending_find(MGMT_OP_UNBLOCK_DEVICE, hdev);
Antti Julku5e762442011-08-25 16:48:02 +03004050
Johan Hedberg88c1fe42012-02-09 15:56:11 +02004051 bacpy(&ev.addr.bdaddr, bdaddr);
4052 ev.addr.type = type;
Antti Julku5e762442011-08-25 16:48:02 +03004053
Johan Hedberg744cf192011-11-08 20:40:14 +02004054 return mgmt_event(MGMT_EV_DEVICE_UNBLOCKED, hdev, &ev, sizeof(ev),
Gustavo F. Padovan04124682012-03-08 01:25:00 -03004055 cmd ? cmd->sk : NULL);
Antti Julku5e762442011-08-25 16:48:02 +03004056}
Marcel Holtmannd7b7e792012-02-20 21:47:49 +01004057
4058module_param(enable_hs, bool, 0644);
4059MODULE_PARM_DESC(enable_hs, "Enable High Speed support");