blob: 0383635f91fbc18991abe090c6a637d5d12d96e7 [file] [log] [blame]
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 BlueZ - Bluetooth protocol stack for Linux
Ron Shaffer2d0a0342010-05-28 11:53:46 -04003 Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation;
10
11 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090015 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090020 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth HCI event handling. */
26
Gustavo Padovan8c520a52012-05-23 04:04:22 -030027#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <asm/unaligned.h>
29
30#include <net/bluetooth/bluetooth.h>
31#include <net/bluetooth/hci_core.h>
Mikel Astizf0d6a0e2012-08-09 09:52:30 +020032#include <net/bluetooth/mgmt.h>
Andrei Emeltchenko8e2a0d92012-09-27 17:26:08 +030033#include <net/bluetooth/a2mp.h>
Andrei Emeltchenko903e4542012-09-27 17:26:09 +030034#include <net/bluetooth/amp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Linus Torvalds1da177e2005-04-16 15:20:36 -070036/* Handle HCI Event packets */
37
Marcel Holtmanna9de9242007-10-20 13:33:56 +020038static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070039{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020040 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +030042 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Andre Guedese6d465c2011-11-09 17:14:26 -030044 if (status) {
45 hci_dev_lock(hdev);
46 mgmt_stop_discovery_failed(hdev, status);
47 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +020048 return;
Andre Guedese6d465c2011-11-09 17:14:26 -030049 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Andre Guedes89352e72011-11-04 14:16:53 -030051 clear_bit(HCI_INQUIRY, &hdev->flags);
52
Johan Hedberg56e5cb82011-11-08 20:40:16 +020053 hci_dev_lock(hdev);
Johan Hedbergff9ef572012-01-04 14:23:45 +020054 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
Johan Hedberg56e5cb82011-11-08 20:40:16 +020055 hci_dev_unlock(hdev);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010056
Johan Hedberg23bb5762010-12-21 23:01:27 +020057 hci_req_complete(hdev, HCI_OP_INQUIRY_CANCEL, status);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010058
Marcel Holtmanna9de9242007-10-20 13:33:56 +020059 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060}
61
Andre Guedes4d934832012-03-21 00:03:35 -030062static void hci_cc_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
63{
64 __u8 status = *((__u8 *) skb->data);
65
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +030066 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Andre Guedesae854a72012-03-21 00:03:36 -030067
68 if (status)
69 return;
70
71 set_bit(HCI_PERIODIC_INQ, &hdev->dev_flags);
Andre Guedes4d934832012-03-21 00:03:35 -030072}
73
Marcel Holtmanna9de9242007-10-20 13:33:56 +020074static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070075{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020076 __u8 status = *((__u8 *) skb->data);
77
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +030078 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +020079
80 if (status)
81 return;
82
Andre Guedesae854a72012-03-21 00:03:36 -030083 clear_bit(HCI_PERIODIC_INQ, &hdev->dev_flags);
84
Marcel Holtmanna9de9242007-10-20 13:33:56 +020085 hci_conn_check_pending(hdev);
86}
87
Gustavo Padovan807deac2012-05-17 00:36:24 -030088static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev,
89 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +020090{
91 BT_DBG("%s", hdev->name);
92}
93
94static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb)
95{
96 struct hci_rp_role_discovery *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +030099 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200101 if (rp->status)
102 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200104 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200106 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
107 if (conn) {
108 if (rp->role)
109 conn->link_mode &= ~HCI_LM_MASTER;
110 else
111 conn->link_mode |= HCI_LM_MASTER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200113
114 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115}
116
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200117static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
118{
119 struct hci_rp_read_link_policy *rp = (void *) skb->data;
120 struct hci_conn *conn;
121
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300122 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200123
124 if (rp->status)
125 return;
126
127 hci_dev_lock(hdev);
128
129 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
130 if (conn)
131 conn->link_policy = __le16_to_cpu(rp->policy);
132
133 hci_dev_unlock(hdev);
134}
135
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200136static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200138 struct hci_rp_write_link_policy *rp = (void *) skb->data;
139 struct hci_conn *conn;
140 void *sent;
141
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300142 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200143
144 if (rp->status)
145 return;
146
147 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
148 if (!sent)
149 return;
150
151 hci_dev_lock(hdev);
152
153 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200154 if (conn)
Harvey Harrison83985312008-05-02 16:25:46 -0700155 conn->link_policy = get_unaligned_le16(sent + 2);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200156
157 hci_dev_unlock(hdev);
158}
159
Gustavo Padovan807deac2012-05-17 00:36:24 -0300160static void hci_cc_read_def_link_policy(struct hci_dev *hdev,
161 struct sk_buff *skb)
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200162{
163 struct hci_rp_read_def_link_policy *rp = (void *) skb->data;
164
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300165 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200166
167 if (rp->status)
168 return;
169
170 hdev->link_policy = __le16_to_cpu(rp->policy);
171}
172
Gustavo Padovan807deac2012-05-17 00:36:24 -0300173static void hci_cc_write_def_link_policy(struct hci_dev *hdev,
174 struct sk_buff *skb)
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200175{
176 __u8 status = *((__u8 *) skb->data);
177 void *sent;
178
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300179 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200180
181 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
182 if (!sent)
183 return;
184
185 if (!status)
186 hdev->link_policy = get_unaligned_le16(sent);
187
Johan Hedberg23bb5762010-12-21 23:01:27 +0200188 hci_req_complete(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, status);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200189}
190
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200191static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
192{
193 __u8 status = *((__u8 *) skb->data);
194
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300195 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200196
Gustavo F. Padovan10572132011-03-16 15:36:29 -0300197 clear_bit(HCI_RESET, &hdev->flags);
198
Johan Hedberg23bb5762010-12-21 23:01:27 +0200199 hci_req_complete(hdev, HCI_OP_RESET, status);
Andre Guedesd23264a2011-11-25 20:53:38 -0300200
Johan Hedberga297e972012-02-21 17:55:47 +0200201 /* Reset all non-persistent flags */
Andre Guedesae854a72012-03-21 00:03:36 -0300202 hdev->dev_flags &= ~(BIT(HCI_LE_SCAN) | BIT(HCI_PENDING_CLASS) |
203 BIT(HCI_PERIODIC_INQ));
Andre Guedes69775ff2012-02-23 16:50:05 +0200204
205 hdev->discovery.state = DISCOVERY_STOPPED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200206}
207
208static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
209{
210 __u8 status = *((__u8 *) skb->data);
211 void *sent;
212
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300213 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200214
215 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
216 if (!sent)
217 return;
218
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200219 hci_dev_lock(hdev);
220
Johan Hedbergf51d5b22012-02-22 18:17:32 +0200221 if (test_bit(HCI_MGMT, &hdev->dev_flags))
222 mgmt_set_local_name_complete(hdev, sent, status);
Johan Hedberg28cc7bd2012-02-22 21:06:55 +0200223 else if (!status)
224 memcpy(hdev->dev_name, sent, HCI_MAX_NAME_LENGTH);
Johan Hedbergf51d5b22012-02-22 18:17:32 +0200225
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200226 hci_dev_unlock(hdev);
Johan Hedberg3159d382012-02-24 13:47:56 +0200227
228 hci_req_complete(hdev, HCI_OP_WRITE_LOCAL_NAME, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200229}
230
231static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
232{
233 struct hci_rp_read_local_name *rp = (void *) skb->data;
234
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300235 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200236
237 if (rp->status)
238 return;
239
Johan Hedbergdb99b5f2012-02-22 20:14:22 +0200240 if (test_bit(HCI_SETUP, &hdev->dev_flags))
241 memcpy(hdev->dev_name, rp->name, HCI_MAX_NAME_LENGTH);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200242}
243
244static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
245{
246 __u8 status = *((__u8 *) skb->data);
247 void *sent;
248
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300249 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200250
251 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
252 if (!sent)
253 return;
254
255 if (!status) {
256 __u8 param = *((__u8 *) sent);
257
258 if (param == AUTH_ENABLED)
259 set_bit(HCI_AUTH, &hdev->flags);
260 else
261 clear_bit(HCI_AUTH, &hdev->flags);
262 }
263
Johan Hedberg33ef95e2012-02-16 23:56:27 +0200264 if (test_bit(HCI_MGMT, &hdev->dev_flags))
265 mgmt_auth_enable_complete(hdev, status);
266
Johan Hedberg23bb5762010-12-21 23:01:27 +0200267 hci_req_complete(hdev, HCI_OP_WRITE_AUTH_ENABLE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200268}
269
270static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
271{
272 __u8 status = *((__u8 *) skb->data);
273 void *sent;
274
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300275 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200276
277 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
278 if (!sent)
279 return;
280
281 if (!status) {
282 __u8 param = *((__u8 *) sent);
283
284 if (param)
285 set_bit(HCI_ENCRYPT, &hdev->flags);
286 else
287 clear_bit(HCI_ENCRYPT, &hdev->flags);
288 }
289
Johan Hedberg23bb5762010-12-21 23:01:27 +0200290 hci_req_complete(hdev, HCI_OP_WRITE_ENCRYPT_MODE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200291}
292
293static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
294{
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200295 __u8 param, status = *((__u8 *) skb->data);
296 int old_pscan, old_iscan;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200297 void *sent;
298
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300299 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200300
301 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
302 if (!sent)
303 return;
304
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200305 param = *((__u8 *) sent);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200306
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200307 hci_dev_lock(hdev);
308
Mikel Astizfa1bd912012-08-09 09:52:29 +0200309 if (status) {
Johan Hedberg744cf192011-11-08 20:40:14 +0200310 mgmt_write_scan_failed(hdev, param, status);
Johan Hedberg2d7cee52011-11-07 22:16:03 +0200311 hdev->discov_timeout = 0;
312 goto done;
313 }
314
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200315 old_pscan = test_and_clear_bit(HCI_PSCAN, &hdev->flags);
316 old_iscan = test_and_clear_bit(HCI_ISCAN, &hdev->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200317
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200318 if (param & SCAN_INQUIRY) {
319 set_bit(HCI_ISCAN, &hdev->flags);
320 if (!old_iscan)
Johan Hedberg744cf192011-11-08 20:40:14 +0200321 mgmt_discoverable(hdev, 1);
Johan Hedberg16ab91a2011-11-07 22:16:02 +0200322 if (hdev->discov_timeout > 0) {
323 int to = msecs_to_jiffies(hdev->discov_timeout * 1000);
324 queue_delayed_work(hdev->workqueue, &hdev->discov_off,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300325 to);
Johan Hedberg16ab91a2011-11-07 22:16:02 +0200326 }
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200327 } else if (old_iscan)
Johan Hedberg744cf192011-11-08 20:40:14 +0200328 mgmt_discoverable(hdev, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200329
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200330 if (param & SCAN_PAGE) {
331 set_bit(HCI_PSCAN, &hdev->flags);
332 if (!old_pscan)
Johan Hedberg744cf192011-11-08 20:40:14 +0200333 mgmt_connectable(hdev, 1);
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200334 } else if (old_pscan)
Johan Hedberg744cf192011-11-08 20:40:14 +0200335 mgmt_connectable(hdev, 0);
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200336
337done:
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200338 hci_dev_unlock(hdev);
Johan Hedberg23bb5762010-12-21 23:01:27 +0200339 hci_req_complete(hdev, HCI_OP_WRITE_SCAN_ENABLE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200340}
341
342static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
343{
344 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
345
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300346 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200347
348 if (rp->status)
349 return;
350
351 memcpy(hdev->dev_class, rp->dev_class, 3);
352
353 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300354 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200355}
356
357static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
358{
359 __u8 status = *((__u8 *) skb->data);
360 void *sent;
361
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300362 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200363
364 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
365 if (!sent)
366 return;
367
Marcel Holtmann7f9a9032012-02-22 18:38:01 +0100368 hci_dev_lock(hdev);
369
370 if (status == 0)
371 memcpy(hdev->dev_class, sent, 3);
372
373 if (test_bit(HCI_MGMT, &hdev->dev_flags))
374 mgmt_set_class_of_dev_complete(hdev, sent, status);
375
376 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200377}
378
379static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
380{
381 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 __u16 setting;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200383
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300384 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200385
386 if (rp->status)
387 return;
388
389 setting = __le16_to_cpu(rp->voice_setting);
390
Marcel Holtmannf383f272008-07-14 20:13:47 +0200391 if (hdev->voice_setting == setting)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200392 return;
393
394 hdev->voice_setting = setting;
395
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300396 BT_DBG("%s voice setting 0x%4.4x", hdev->name, setting);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200397
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200398 if (hdev->notify)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200399 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200400}
401
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300402static void hci_cc_write_voice_setting(struct hci_dev *hdev,
403 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200404{
405 __u8 status = *((__u8 *) skb->data);
Marcel Holtmannf383f272008-07-14 20:13:47 +0200406 __u16 setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 void *sent;
408
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300409 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Marcel Holtmannf383f272008-07-14 20:13:47 +0200411 if (status)
412 return;
413
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200414 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
415 if (!sent)
416 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Marcel Holtmannf383f272008-07-14 20:13:47 +0200418 setting = get_unaligned_le16(sent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
Marcel Holtmannf383f272008-07-14 20:13:47 +0200420 if (hdev->voice_setting == setting)
421 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Marcel Holtmannf383f272008-07-14 20:13:47 +0200423 hdev->voice_setting = setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300425 BT_DBG("%s voice setting 0x%4.4x", hdev->name, setting);
Marcel Holtmannf383f272008-07-14 20:13:47 +0200426
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200427 if (hdev->notify)
Marcel Holtmannf383f272008-07-14 20:13:47 +0200428 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429}
430
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200431static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200433 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300435 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
Johan Hedberg23bb5762010-12-21 23:01:27 +0200437 hci_req_complete(hdev, HCI_OP_HOST_BUFFER_SIZE, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438}
439
Marcel Holtmann333140b2008-07-14 20:13:48 +0200440static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
441{
442 __u8 status = *((__u8 *) skb->data);
443 void *sent;
444
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300445 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmann333140b2008-07-14 20:13:48 +0200446
Marcel Holtmann333140b2008-07-14 20:13:48 +0200447 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
448 if (!sent)
449 return;
450
Johan Hedberged2c4ee2012-02-17 00:56:28 +0200451 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedbergc0ecddc2012-02-22 12:38:31 +0200452 mgmt_ssp_enable_complete(hdev, *((u8 *) sent), status);
453 else if (!status) {
454 if (*((u8 *) sent))
455 set_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
456 else
457 clear_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
458 }
Marcel Holtmann333140b2008-07-14 20:13:48 +0200459}
460
Johan Hedbergd5859e22011-01-25 01:19:58 +0200461static u8 hci_get_inquiry_mode(struct hci_dev *hdev)
462{
463 if (hdev->features[6] & LMP_EXT_INQ)
464 return 2;
465
466 if (hdev->features[3] & LMP_RSSI_INQ)
467 return 1;
468
469 if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 &&
Gustavo Padovan807deac2012-05-17 00:36:24 -0300470 hdev->lmp_subver == 0x0757)
Johan Hedbergd5859e22011-01-25 01:19:58 +0200471 return 1;
472
473 if (hdev->manufacturer == 15) {
474 if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963)
475 return 1;
476 if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963)
477 return 1;
478 if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965)
479 return 1;
480 }
481
482 if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 &&
Gustavo Padovan807deac2012-05-17 00:36:24 -0300483 hdev->lmp_subver == 0x1805)
Johan Hedbergd5859e22011-01-25 01:19:58 +0200484 return 1;
485
486 return 0;
487}
488
489static void hci_setup_inquiry_mode(struct hci_dev *hdev)
490{
491 u8 mode;
492
493 mode = hci_get_inquiry_mode(hdev);
494
495 hci_send_cmd(hdev, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode);
496}
497
498static void hci_setup_event_mask(struct hci_dev *hdev)
499{
500 /* The second byte is 0xff instead of 0x9f (two reserved bits
501 * disabled) since a Broadcom 1.2 dongle doesn't respond to the
502 * command otherwise */
503 u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 };
504
Ville Tervo6de6c182011-05-27 11:16:21 +0300505 /* CSR 1.1 dongles does not accept any bitfield so don't try to set
506 * any event mask for pre 1.2 devices */
Andrei Emeltchenko5a13b092011-12-01 14:33:28 +0200507 if (hdev->hci_ver < BLUETOOTH_VER_1_2)
Ville Tervo6de6c182011-05-27 11:16:21 +0300508 return;
509
510 events[4] |= 0x01; /* Flow Specification Complete */
511 events[4] |= 0x02; /* Inquiry Result with RSSI */
512 events[4] |= 0x04; /* Read Remote Extended Features Complete */
513 events[5] |= 0x08; /* Synchronous Connection Complete */
514 events[5] |= 0x10; /* Synchronous Connection Changed */
Johan Hedbergd5859e22011-01-25 01:19:58 +0200515
516 if (hdev->features[3] & LMP_RSSI_INQ)
Johan Hedberga24299e2012-04-26 09:47:46 +0300517 events[4] |= 0x02; /* Inquiry Result with RSSI */
Johan Hedbergd5859e22011-01-25 01:19:58 +0200518
Andre Guedes999dcd12012-07-24 15:03:52 -0300519 if (lmp_sniffsubr_capable(hdev))
Johan Hedbergd5859e22011-01-25 01:19:58 +0200520 events[5] |= 0x20; /* Sniff Subrating */
521
522 if (hdev->features[5] & LMP_PAUSE_ENC)
523 events[5] |= 0x80; /* Encryption Key Refresh Complete */
524
525 if (hdev->features[6] & LMP_EXT_INQ)
526 events[5] |= 0x40; /* Extended Inquiry Result */
527
Andre Guedesc58e8102012-07-24 15:03:53 -0300528 if (lmp_no_flush_capable(hdev))
Johan Hedbergd5859e22011-01-25 01:19:58 +0200529 events[7] |= 0x01; /* Enhanced Flush Complete */
530
531 if (hdev->features[7] & LMP_LSTO)
532 events[6] |= 0x80; /* Link Supervision Timeout Changed */
533
Andre Guedes9a1a1992012-07-24 15:03:48 -0300534 if (lmp_ssp_capable(hdev)) {
Johan Hedbergd5859e22011-01-25 01:19:58 +0200535 events[6] |= 0x01; /* IO Capability Request */
536 events[6] |= 0x02; /* IO Capability Response */
537 events[6] |= 0x04; /* User Confirmation Request */
538 events[6] |= 0x08; /* User Passkey Request */
539 events[6] |= 0x10; /* Remote OOB Data Request */
540 events[6] |= 0x20; /* Simple Pairing Complete */
541 events[7] |= 0x04; /* User Passkey Notification */
542 events[7] |= 0x08; /* Keypress Notification */
543 events[7] |= 0x10; /* Remote Host Supported
544 * Features Notification */
545 }
546
Andre Guedesc383ddc2012-07-24 15:03:47 -0300547 if (lmp_le_capable(hdev))
Johan Hedbergd5859e22011-01-25 01:19:58 +0200548 events[7] |= 0x20; /* LE Meta-Event */
549
550 hci_send_cmd(hdev, HCI_OP_SET_EVENT_MASK, sizeof(events), events);
551}
552
553static void hci_setup(struct hci_dev *hdev)
554{
Andrei Emeltchenkoe61ef4992011-12-19 16:31:27 +0200555 if (hdev->dev_type != HCI_BREDR)
556 return;
557
Johan Hedbergd5859e22011-01-25 01:19:58 +0200558 hci_setup_event_mask(hdev);
559
Andrei Emeltchenkod095c1e2011-12-01 14:33:27 +0200560 if (hdev->hci_ver > BLUETOOTH_VER_1_1)
Johan Hedbergd5859e22011-01-25 01:19:58 +0200561 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL);
562
Gustavo Padovan6d3c7302012-05-24 03:36:37 -0300563 if (lmp_ssp_capable(hdev)) {
Johan Hedberg54d04db2012-02-22 15:47:48 +0200564 if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) {
565 u8 mode = 0x01;
566 hci_send_cmd(hdev, HCI_OP_WRITE_SSP_MODE,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300567 sizeof(mode), &mode);
Johan Hedberg54d04db2012-02-22 15:47:48 +0200568 } else {
569 struct hci_cp_write_eir cp;
570
571 memset(hdev->eir, 0, sizeof(hdev->eir));
572 memset(&cp, 0, sizeof(cp));
573
574 hci_send_cmd(hdev, HCI_OP_WRITE_EIR, sizeof(cp), &cp);
575 }
Johan Hedbergd5859e22011-01-25 01:19:58 +0200576 }
577
578 if (hdev->features[3] & LMP_RSSI_INQ)
579 hci_setup_inquiry_mode(hdev);
580
581 if (hdev->features[7] & LMP_INQ_TX_PWR)
582 hci_send_cmd(hdev, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL);
Andre Guedes971e3a42011-06-30 19:20:52 -0300583
584 if (hdev->features[7] & LMP_EXTFEATURES) {
585 struct hci_cp_read_local_ext_features cp;
586
587 cp.page = 0x01;
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300588 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_EXT_FEATURES, sizeof(cp),
589 &cp);
Andre Guedes971e3a42011-06-30 19:20:52 -0300590 }
Andre Guedese6100a22011-06-30 19:20:54 -0300591
Johan Hedberg47990ea2012-02-22 11:58:37 +0200592 if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) {
593 u8 enable = 1;
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300594 hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable),
595 &enable);
Johan Hedberg47990ea2012-02-22 11:58:37 +0200596 }
Johan Hedbergd5859e22011-01-25 01:19:58 +0200597}
598
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200599static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
600{
601 struct hci_rp_read_local_version *rp = (void *) skb->data;
602
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300603 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200604
605 if (rp->status)
Andrei Emeltchenko28b8df72012-02-24 12:45:44 +0200606 goto done;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200607
608 hdev->hci_ver = rp->hci_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200609 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200610 hdev->lmp_ver = rp->lmp_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200611 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200612 hdev->lmp_subver = __le16_to_cpu(rp->lmp_subver);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200613
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300614 BT_DBG("%s manufacturer 0x%4.4x hci ver %d:%d", hdev->name,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300615 hdev->manufacturer, hdev->hci_ver, hdev->hci_rev);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200616
617 if (test_bit(HCI_INIT, &hdev->flags))
618 hci_setup(hdev);
Andrei Emeltchenko28b8df72012-02-24 12:45:44 +0200619
620done:
621 hci_req_complete(hdev, HCI_OP_READ_LOCAL_VERSION, rp->status);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200622}
623
624static void hci_setup_link_policy(struct hci_dev *hdev)
625{
Andrei Emeltchenko035100c2012-03-12 15:59:32 +0200626 struct hci_cp_write_def_link_policy cp;
Johan Hedbergd5859e22011-01-25 01:19:58 +0200627 u16 link_policy = 0;
628
Andre Guedes9f92ebf2012-07-24 15:03:50 -0300629 if (lmp_rswitch_capable(hdev))
Johan Hedbergd5859e22011-01-25 01:19:58 +0200630 link_policy |= HCI_LP_RSWITCH;
631 if (hdev->features[0] & LMP_HOLD)
632 link_policy |= HCI_LP_HOLD;
Andre Guedes6eded102012-07-24 15:03:51 -0300633 if (lmp_sniff_capable(hdev))
Johan Hedbergd5859e22011-01-25 01:19:58 +0200634 link_policy |= HCI_LP_SNIFF;
635 if (hdev->features[1] & LMP_PARK)
636 link_policy |= HCI_LP_PARK;
637
Andrei Emeltchenko035100c2012-03-12 15:59:32 +0200638 cp.policy = cpu_to_le16(link_policy);
639 hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200640}
641
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300642static void hci_cc_read_local_commands(struct hci_dev *hdev,
643 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200644{
645 struct hci_rp_read_local_commands *rp = (void *) skb->data;
646
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300647 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200648
649 if (rp->status)
Johan Hedbergd5859e22011-01-25 01:19:58 +0200650 goto done;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200651
652 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
Johan Hedbergd5859e22011-01-25 01:19:58 +0200653
654 if (test_bit(HCI_INIT, &hdev->flags) && (hdev->commands[5] & 0x10))
655 hci_setup_link_policy(hdev);
656
657done:
658 hci_req_complete(hdev, HCI_OP_READ_LOCAL_COMMANDS, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200659}
660
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300661static void hci_cc_read_local_features(struct hci_dev *hdev,
662 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200663{
664 struct hci_rp_read_local_features *rp = (void *) skb->data;
665
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300666 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200667
668 if (rp->status)
669 return;
670
671 memcpy(hdev->features, rp->features, 8);
672
673 /* Adjust default settings according to features
674 * supported by device. */
675
676 if (hdev->features[0] & LMP_3SLOT)
677 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
678
679 if (hdev->features[0] & LMP_5SLOT)
680 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
681
682 if (hdev->features[1] & LMP_HV2) {
683 hdev->pkt_type |= (HCI_HV2);
684 hdev->esco_type |= (ESCO_HV2);
685 }
686
687 if (hdev->features[1] & LMP_HV3) {
688 hdev->pkt_type |= (HCI_HV3);
689 hdev->esco_type |= (ESCO_HV3);
690 }
691
Andre Guedes45db810f2012-07-24 15:03:49 -0300692 if (lmp_esco_capable(hdev))
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200693 hdev->esco_type |= (ESCO_EV3);
694
695 if (hdev->features[4] & LMP_EV4)
696 hdev->esco_type |= (ESCO_EV4);
697
698 if (hdev->features[4] & LMP_EV5)
699 hdev->esco_type |= (ESCO_EV5);
700
Marcel Holtmannefc76882009-02-06 09:13:37 +0100701 if (hdev->features[5] & LMP_EDR_ESCO_2M)
702 hdev->esco_type |= (ESCO_2EV3);
703
704 if (hdev->features[5] & LMP_EDR_ESCO_3M)
705 hdev->esco_type |= (ESCO_3EV3);
706
707 if (hdev->features[5] & LMP_EDR_3S_ESCO)
708 hdev->esco_type |= (ESCO_2EV5 | ESCO_3EV5);
709
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200710 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300711 hdev->features[0], hdev->features[1],
712 hdev->features[2], hdev->features[3],
713 hdev->features[4], hdev->features[5],
714 hdev->features[6], hdev->features[7]);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200715}
716
Johan Hedberg8f984df2012-02-28 01:07:22 +0200717static void hci_set_le_support(struct hci_dev *hdev)
718{
719 struct hci_cp_write_le_host_supported cp;
720
721 memset(&cp, 0, sizeof(cp));
722
Marcel Holtmann9d428202012-05-03 07:12:31 +0200723 if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) {
Johan Hedberg8f984df2012-02-28 01:07:22 +0200724 cp.le = 1;
725 cp.simul = !!(hdev->features[6] & LMP_SIMUL_LE_BR);
726 }
727
728 if (cp.le != !!(hdev->host_features[0] & LMP_HOST_LE))
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300729 hci_send_cmd(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp),
730 &cp);
Johan Hedberg8f984df2012-02-28 01:07:22 +0200731}
732
Andre Guedes971e3a42011-06-30 19:20:52 -0300733static void hci_cc_read_local_ext_features(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300734 struct sk_buff *skb)
Andre Guedes971e3a42011-06-30 19:20:52 -0300735{
736 struct hci_rp_read_local_ext_features *rp = (void *) skb->data;
737
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300738 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Andre Guedes971e3a42011-06-30 19:20:52 -0300739
740 if (rp->status)
Johan Hedberg8f984df2012-02-28 01:07:22 +0200741 goto done;
Andre Guedes971e3a42011-06-30 19:20:52 -0300742
Andre Guedesb5b32b62011-12-30 10:34:04 -0300743 switch (rp->page) {
744 case 0:
745 memcpy(hdev->features, rp->features, 8);
746 break;
747 case 1:
748 memcpy(hdev->host_features, rp->features, 8);
749 break;
750 }
Andre Guedes971e3a42011-06-30 19:20:52 -0300751
Andre Guedesc383ddc2012-07-24 15:03:47 -0300752 if (test_bit(HCI_INIT, &hdev->flags) && lmp_le_capable(hdev))
Johan Hedberg8f984df2012-02-28 01:07:22 +0200753 hci_set_le_support(hdev);
754
755done:
Andre Guedes971e3a42011-06-30 19:20:52 -0300756 hci_req_complete(hdev, HCI_OP_READ_LOCAL_EXT_FEATURES, rp->status);
757}
758
Andrei Emeltchenko1e89cff2011-11-24 14:52:02 +0200759static void hci_cc_read_flow_control_mode(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300760 struct sk_buff *skb)
Andrei Emeltchenko1e89cff2011-11-24 14:52:02 +0200761{
762 struct hci_rp_read_flow_control_mode *rp = (void *) skb->data;
763
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300764 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Andrei Emeltchenko1e89cff2011-11-24 14:52:02 +0200765
766 if (rp->status)
767 return;
768
769 hdev->flow_ctl_mode = rp->mode;
770
771 hci_req_complete(hdev, HCI_OP_READ_FLOW_CONTROL_MODE, rp->status);
772}
773
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200774static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
775{
776 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
777
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300778 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200779
780 if (rp->status)
781 return;
782
783 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
784 hdev->sco_mtu = rp->sco_mtu;
785 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
786 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
787
788 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
789 hdev->sco_mtu = 64;
790 hdev->sco_pkts = 8;
791 }
792
793 hdev->acl_cnt = hdev->acl_pkts;
794 hdev->sco_cnt = hdev->sco_pkts;
795
Gustavo Padovan807deac2012-05-17 00:36:24 -0300796 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name, hdev->acl_mtu,
797 hdev->acl_pkts, hdev->sco_mtu, hdev->sco_pkts);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200798}
799
800static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
801{
802 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
803
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300804 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200805
806 if (!rp->status)
807 bacpy(&hdev->bdaddr, &rp->bdaddr);
808
Johan Hedberg23bb5762010-12-21 23:01:27 +0200809 hci_req_complete(hdev, HCI_OP_READ_BD_ADDR, rp->status);
810}
811
Andrei Emeltchenko350ee4c2011-12-07 15:56:51 +0200812static void hci_cc_read_data_block_size(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300813 struct sk_buff *skb)
Andrei Emeltchenko350ee4c2011-12-07 15:56:51 +0200814{
815 struct hci_rp_read_data_block_size *rp = (void *) skb->data;
816
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300817 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Andrei Emeltchenko350ee4c2011-12-07 15:56:51 +0200818
819 if (rp->status)
820 return;
821
822 hdev->block_mtu = __le16_to_cpu(rp->max_acl_len);
823 hdev->block_len = __le16_to_cpu(rp->block_len);
824 hdev->num_blocks = __le16_to_cpu(rp->num_blocks);
825
826 hdev->block_cnt = hdev->num_blocks;
827
828 BT_DBG("%s blk mtu %d cnt %d len %d", hdev->name, hdev->block_mtu,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300829 hdev->block_cnt, hdev->block_len);
Andrei Emeltchenko350ee4c2011-12-07 15:56:51 +0200830
831 hci_req_complete(hdev, HCI_OP_READ_DATA_BLOCK_SIZE, rp->status);
832}
833
Johan Hedberg23bb5762010-12-21 23:01:27 +0200834static void hci_cc_write_ca_timeout(struct hci_dev *hdev, struct sk_buff *skb)
835{
836 __u8 status = *((__u8 *) skb->data);
837
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300838 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Johan Hedberg23bb5762010-12-21 23:01:27 +0200839
840 hci_req_complete(hdev, HCI_OP_WRITE_CA_TIMEOUT, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200841}
842
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +0300843static void hci_cc_read_local_amp_info(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300844 struct sk_buff *skb)
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +0300845{
846 struct hci_rp_read_local_amp_info *rp = (void *) skb->data;
847
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300848 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +0300849
850 if (rp->status)
Andrei Emeltchenko8e2a0d92012-09-27 17:26:08 +0300851 goto a2mp_rsp;
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +0300852
853 hdev->amp_status = rp->amp_status;
854 hdev->amp_total_bw = __le32_to_cpu(rp->total_bw);
855 hdev->amp_max_bw = __le32_to_cpu(rp->max_bw);
856 hdev->amp_min_latency = __le32_to_cpu(rp->min_latency);
857 hdev->amp_max_pdu = __le32_to_cpu(rp->max_pdu);
858 hdev->amp_type = rp->amp_type;
859 hdev->amp_pal_cap = __le16_to_cpu(rp->pal_cap);
860 hdev->amp_assoc_size = __le16_to_cpu(rp->max_assoc_size);
861 hdev->amp_be_flush_to = __le32_to_cpu(rp->be_flush_to);
862 hdev->amp_max_flush_to = __le32_to_cpu(rp->max_flush_to);
863
864 hci_req_complete(hdev, HCI_OP_READ_LOCAL_AMP_INFO, rp->status);
Andrei Emeltchenko8e2a0d92012-09-27 17:26:08 +0300865
866a2mp_rsp:
867 a2mp_send_getinfo_rsp(hdev);
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +0300868}
869
Andrei Emeltchenko903e4542012-09-27 17:26:09 +0300870static void hci_cc_read_local_amp_assoc(struct hci_dev *hdev,
871 struct sk_buff *skb)
872{
873 struct hci_rp_read_local_amp_assoc *rp = (void *) skb->data;
874 struct amp_assoc *assoc = &hdev->loc_assoc;
875 size_t rem_len, frag_len;
876
877 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
878
879 if (rp->status)
880 goto a2mp_rsp;
881
882 frag_len = skb->len - sizeof(*rp);
883 rem_len = __le16_to_cpu(rp->rem_len);
884
885 if (rem_len > frag_len) {
Andrei Emeltchenko2e430be32012-09-28 14:44:23 +0300886 BT_DBG("frag_len %zu rem_len %zu", frag_len, rem_len);
Andrei Emeltchenko903e4542012-09-27 17:26:09 +0300887
888 memcpy(assoc->data + assoc->offset, rp->frag, frag_len);
889 assoc->offset += frag_len;
890
891 /* Read other fragments */
892 amp_read_loc_assoc_frag(hdev, rp->phy_handle);
893
894 return;
895 }
896
897 memcpy(assoc->data + assoc->offset, rp->frag, rem_len);
898 assoc->len = assoc->offset + rem_len;
899 assoc->offset = 0;
900
901a2mp_rsp:
902 /* Send A2MP Rsp when all fragments are received */
903 a2mp_send_getampassoc_rsp(hdev, rp->status);
Andrei Emeltchenko9495b2e2012-09-27 17:26:22 +0300904 a2mp_send_create_phy_link_req(hdev, rp->status);
Andrei Emeltchenko903e4542012-09-27 17:26:09 +0300905}
906
Johan Hedbergb0916ea2011-01-10 13:44:55 +0200907static void hci_cc_delete_stored_link_key(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300908 struct sk_buff *skb)
Johan Hedbergb0916ea2011-01-10 13:44:55 +0200909{
910 __u8 status = *((__u8 *) skb->data);
911
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300912 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Johan Hedbergb0916ea2011-01-10 13:44:55 +0200913
914 hci_req_complete(hdev, HCI_OP_DELETE_STORED_LINK_KEY, status);
915}
916
Johan Hedbergd5859e22011-01-25 01:19:58 +0200917static void hci_cc_set_event_mask(struct hci_dev *hdev, struct sk_buff *skb)
918{
919 __u8 status = *((__u8 *) skb->data);
920
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300921 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200922
923 hci_req_complete(hdev, HCI_OP_SET_EVENT_MASK, status);
924}
925
926static void hci_cc_write_inquiry_mode(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300927 struct sk_buff *skb)
Johan Hedbergd5859e22011-01-25 01:19:58 +0200928{
929 __u8 status = *((__u8 *) skb->data);
930
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300931 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200932
933 hci_req_complete(hdev, HCI_OP_WRITE_INQUIRY_MODE, status);
934}
935
936static void hci_cc_read_inq_rsp_tx_power(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300937 struct sk_buff *skb)
Johan Hedbergd5859e22011-01-25 01:19:58 +0200938{
Marcel Holtmann91c4e9b2012-03-11 19:27:21 -0700939 struct hci_rp_read_inq_rsp_tx_power *rp = (void *) skb->data;
Johan Hedbergd5859e22011-01-25 01:19:58 +0200940
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300941 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200942
Marcel Holtmann91c4e9b2012-03-11 19:27:21 -0700943 if (!rp->status)
944 hdev->inq_tx_power = rp->tx_power;
945
946 hci_req_complete(hdev, HCI_OP_READ_INQ_RSP_TX_POWER, rp->status);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200947}
948
949static void hci_cc_set_event_flt(struct hci_dev *hdev, struct sk_buff *skb)
950{
951 __u8 status = *((__u8 *) skb->data);
952
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300953 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200954
955 hci_req_complete(hdev, HCI_OP_SET_EVENT_FLT, status);
956}
957
Johan Hedberg980e1a52011-01-22 06:10:07 +0200958static void hci_cc_pin_code_reply(struct hci_dev *hdev, struct sk_buff *skb)
959{
960 struct hci_rp_pin_code_reply *rp = (void *) skb->data;
961 struct hci_cp_pin_code_reply *cp;
962 struct hci_conn *conn;
963
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300964 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200965
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200966 hci_dev_lock(hdev);
967
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200968 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg744cf192011-11-08 20:40:14 +0200969 mgmt_pin_code_reply_complete(hdev, &rp->bdaddr, rp->status);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200970
Mikel Astizfa1bd912012-08-09 09:52:29 +0200971 if (rp->status)
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200972 goto unlock;
Johan Hedberg980e1a52011-01-22 06:10:07 +0200973
974 cp = hci_sent_cmd_data(hdev, HCI_OP_PIN_CODE_REPLY);
975 if (!cp)
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200976 goto unlock;
Johan Hedberg980e1a52011-01-22 06:10:07 +0200977
978 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
979 if (conn)
980 conn->pin_length = cp->pin_len;
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200981
982unlock:
983 hci_dev_unlock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200984}
985
986static void hci_cc_pin_code_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
987{
988 struct hci_rp_pin_code_neg_reply *rp = (void *) skb->data;
989
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300990 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200991
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200992 hci_dev_lock(hdev);
993
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200994 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg744cf192011-11-08 20:40:14 +0200995 mgmt_pin_code_neg_reply_complete(hdev, &rp->bdaddr,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300996 rp->status);
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200997
998 hci_dev_unlock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200999}
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001000
Ville Tervo6ed58ec2011-02-10 22:38:48 -03001001static void hci_cc_le_read_buffer_size(struct hci_dev *hdev,
1002 struct sk_buff *skb)
1003{
1004 struct hci_rp_le_read_buffer_size *rp = (void *) skb->data;
1005
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001006 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Ville Tervo6ed58ec2011-02-10 22:38:48 -03001007
1008 if (rp->status)
1009 return;
1010
1011 hdev->le_mtu = __le16_to_cpu(rp->le_mtu);
1012 hdev->le_pkts = rp->le_max_pkt;
1013
1014 hdev->le_cnt = hdev->le_pkts;
1015
1016 BT_DBG("%s le mtu %d:%d", hdev->name, hdev->le_mtu, hdev->le_pkts);
1017
1018 hci_req_complete(hdev, HCI_OP_LE_READ_BUFFER_SIZE, rp->status);
1019}
Johan Hedberg980e1a52011-01-22 06:10:07 +02001020
Johan Hedberga5c29682011-02-19 12:05:57 -03001021static void hci_cc_user_confirm_reply(struct hci_dev *hdev, struct sk_buff *skb)
1022{
1023 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
1024
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001025 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Johan Hedberga5c29682011-02-19 12:05:57 -03001026
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001027 hci_dev_lock(hdev);
1028
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001029 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001030 mgmt_user_confirm_reply_complete(hdev, &rp->bdaddr, ACL_LINK, 0,
1031 rp->status);
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001032
1033 hci_dev_unlock(hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -03001034}
1035
1036static void hci_cc_user_confirm_neg_reply(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -03001037 struct sk_buff *skb)
Johan Hedberga5c29682011-02-19 12:05:57 -03001038{
1039 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
1040
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001041 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Johan Hedberga5c29682011-02-19 12:05:57 -03001042
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001043 hci_dev_lock(hdev);
1044
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001045 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg744cf192011-11-08 20:40:14 +02001046 mgmt_user_confirm_neg_reply_complete(hdev, &rp->bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001047 ACL_LINK, 0, rp->status);
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001048
1049 hci_dev_unlock(hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -03001050}
1051
Brian Gix1143d452011-11-23 08:28:34 -08001052static void hci_cc_user_passkey_reply(struct hci_dev *hdev, struct sk_buff *skb)
1053{
1054 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
1055
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001056 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Brian Gix1143d452011-11-23 08:28:34 -08001057
1058 hci_dev_lock(hdev);
1059
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001060 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg272d90d2012-02-09 15:26:12 +02001061 mgmt_user_passkey_reply_complete(hdev, &rp->bdaddr, ACL_LINK,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001062 0, rp->status);
Brian Gix1143d452011-11-23 08:28:34 -08001063
1064 hci_dev_unlock(hdev);
1065}
1066
1067static void hci_cc_user_passkey_neg_reply(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -03001068 struct sk_buff *skb)
Brian Gix1143d452011-11-23 08:28:34 -08001069{
1070 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
1071
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001072 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Brian Gix1143d452011-11-23 08:28:34 -08001073
1074 hci_dev_lock(hdev);
1075
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001076 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Brian Gix1143d452011-11-23 08:28:34 -08001077 mgmt_user_passkey_neg_reply_complete(hdev, &rp->bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001078 ACL_LINK, 0, rp->status);
Brian Gix1143d452011-11-23 08:28:34 -08001079
1080 hci_dev_unlock(hdev);
1081}
1082
Szymon Jancc35938b2011-03-22 13:12:21 +01001083static void hci_cc_read_local_oob_data_reply(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -03001084 struct sk_buff *skb)
Szymon Jancc35938b2011-03-22 13:12:21 +01001085{
1086 struct hci_rp_read_local_oob_data *rp = (void *) skb->data;
1087
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001088 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Szymon Jancc35938b2011-03-22 13:12:21 +01001089
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001090 hci_dev_lock(hdev);
Johan Hedberg744cf192011-11-08 20:40:14 +02001091 mgmt_read_local_oob_data_reply_complete(hdev, rp->hash,
Szymon Jancc35938b2011-03-22 13:12:21 +01001092 rp->randomizer, rp->status);
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001093 hci_dev_unlock(hdev);
Szymon Jancc35938b2011-03-22 13:12:21 +01001094}
1095
Andre Guedes07f7fa52011-12-02 21:13:31 +09001096static void hci_cc_le_set_scan_param(struct hci_dev *hdev, struct sk_buff *skb)
1097{
1098 __u8 status = *((__u8 *) skb->data);
1099
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001100 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001101
1102 hci_req_complete(hdev, HCI_OP_LE_SET_SCAN_PARAM, status);
Andre Guedes3fd24152012-02-03 17:48:01 -03001103
1104 if (status) {
1105 hci_dev_lock(hdev);
1106 mgmt_start_discovery_failed(hdev, status);
1107 hci_dev_unlock(hdev);
1108 return;
1109 }
Andre Guedes07f7fa52011-12-02 21:13:31 +09001110}
1111
Andre Guedeseb9d91f2011-05-26 16:23:52 -03001112static void hci_cc_le_set_scan_enable(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -03001113 struct sk_buff *skb)
Andre Guedeseb9d91f2011-05-26 16:23:52 -03001114{
1115 struct hci_cp_le_set_scan_enable *cp;
1116 __u8 status = *((__u8 *) skb->data);
1117
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001118 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Andre Guedeseb9d91f2011-05-26 16:23:52 -03001119
Andre Guedeseb9d91f2011-05-26 16:23:52 -03001120 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_SCAN_ENABLE);
1121 if (!cp)
1122 return;
1123
Andrei Emeltchenko68a8aea2011-12-19 16:14:18 +02001124 switch (cp->enable) {
1125 case LE_SCANNING_ENABLED:
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001126 hci_req_complete(hdev, HCI_OP_LE_SET_SCAN_ENABLE, status);
1127
Andre Guedes3fd24152012-02-03 17:48:01 -03001128 if (status) {
1129 hci_dev_lock(hdev);
1130 mgmt_start_discovery_failed(hdev, status);
1131 hci_dev_unlock(hdev);
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001132 return;
Andre Guedes3fd24152012-02-03 17:48:01 -03001133 }
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001134
Andre Guedesd23264a2011-11-25 20:53:38 -03001135 set_bit(HCI_LE_SCAN, &hdev->dev_flags);
1136
Andre Guedesa8f13c82011-09-09 18:56:24 -03001137 hci_dev_lock(hdev);
Andre Guedes343f9352012-02-17 20:39:37 -03001138 hci_discovery_set_state(hdev, DISCOVERY_FINDING);
Andre Guedesa8f13c82011-09-09 18:56:24 -03001139 hci_dev_unlock(hdev);
Andrei Emeltchenko68a8aea2011-12-19 16:14:18 +02001140 break;
1141
1142 case LE_SCANNING_DISABLED:
Andre Guedesc9ecc482012-03-15 16:52:08 -03001143 if (status) {
1144 hci_dev_lock(hdev);
1145 mgmt_stop_discovery_failed(hdev, status);
1146 hci_dev_unlock(hdev);
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001147 return;
Andre Guedesc9ecc482012-03-15 16:52:08 -03001148 }
Andre Guedes7ba8b4b2012-02-03 17:47:59 -03001149
Andre Guedesd23264a2011-11-25 20:53:38 -03001150 clear_bit(HCI_LE_SCAN, &hdev->dev_flags);
1151
Andre Guedesbc3dd332012-03-06 19:37:06 -03001152 if (hdev->discovery.type == DISCOV_TYPE_INTERLEAVED &&
1153 hdev->discovery.state == DISCOVERY_FINDING) {
Andre Guedes5e0452c2012-02-17 20:39:38 -03001154 mgmt_interleaved_discovery(hdev);
1155 } else {
1156 hci_dev_lock(hdev);
1157 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1158 hci_dev_unlock(hdev);
1159 }
1160
Andrei Emeltchenko68a8aea2011-12-19 16:14:18 +02001161 break;
1162
1163 default:
1164 BT_ERR("Used reserved LE_Scan_Enable param %d", cp->enable);
1165 break;
Andre Guedes35815082011-05-26 16:23:53 -03001166 }
Andre Guedeseb9d91f2011-05-26 16:23:52 -03001167}
1168
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03001169static void hci_cc_le_ltk_reply(struct hci_dev *hdev, struct sk_buff *skb)
1170{
1171 struct hci_rp_le_ltk_reply *rp = (void *) skb->data;
1172
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001173 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03001174
1175 if (rp->status)
1176 return;
1177
1178 hci_req_complete(hdev, HCI_OP_LE_LTK_REPLY, rp->status);
1179}
1180
1181static void hci_cc_le_ltk_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
1182{
1183 struct hci_rp_le_ltk_neg_reply *rp = (void *) skb->data;
1184
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001185 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03001186
1187 if (rp->status)
1188 return;
1189
1190 hci_req_complete(hdev, HCI_OP_LE_LTK_NEG_REPLY, rp->status);
1191}
1192
Gustavo Padovan6039aa732012-05-23 04:04:18 -03001193static void hci_cc_write_le_host_supported(struct hci_dev *hdev,
1194 struct sk_buff *skb)
Andre Guedesf9b49302011-06-30 19:20:53 -03001195{
Johan Hedberg06199cf2012-02-22 16:37:11 +02001196 struct hci_cp_write_le_host_supported *sent;
Andre Guedesf9b49302011-06-30 19:20:53 -03001197 __u8 status = *((__u8 *) skb->data);
1198
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001199 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Andre Guedesf9b49302011-06-30 19:20:53 -03001200
Johan Hedberg06199cf2012-02-22 16:37:11 +02001201 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED);
Johan Hedberg8f984df2012-02-28 01:07:22 +02001202 if (!sent)
Andre Guedesf9b49302011-06-30 19:20:53 -03001203 return;
1204
Johan Hedberg8f984df2012-02-28 01:07:22 +02001205 if (!status) {
1206 if (sent->le)
1207 hdev->host_features[0] |= LMP_HOST_LE;
1208 else
1209 hdev->host_features[0] &= ~LMP_HOST_LE;
1210 }
1211
1212 if (test_bit(HCI_MGMT, &hdev->dev_flags) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03001213 !test_bit(HCI_INIT, &hdev->flags))
Johan Hedberg8f984df2012-02-28 01:07:22 +02001214 mgmt_le_enable_complete(hdev, sent->le, status);
1215
1216 hci_req_complete(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED, status);
Andre Guedesf9b49302011-06-30 19:20:53 -03001217}
1218
Andrei Emeltchenko93c284e2012-09-27 17:26:20 +03001219static void hci_cc_write_remote_amp_assoc(struct hci_dev *hdev,
1220 struct sk_buff *skb)
1221{
1222 struct hci_rp_write_remote_amp_assoc *rp = (void *) skb->data;
1223
1224 BT_DBG("%s status 0x%2.2x phy_handle 0x%2.2x",
1225 hdev->name, rp->status, rp->phy_handle);
1226
1227 if (rp->status)
1228 return;
1229
1230 amp_write_rem_assoc_continue(hdev, rp->phy_handle);
1231}
1232
Gustavo Padovan6039aa732012-05-23 04:04:18 -03001233static void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001234{
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001235 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001236
1237 if (status) {
Johan Hedberg23bb5762010-12-21 23:01:27 +02001238 hci_req_complete(hdev, HCI_OP_INQUIRY, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001239 hci_conn_check_pending(hdev);
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001240 hci_dev_lock(hdev);
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001241 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Andre Guedes7a135102011-11-09 17:14:25 -03001242 mgmt_start_discovery_failed(hdev, status);
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001243 hci_dev_unlock(hdev);
Johan Hedberg314b2382011-04-27 10:29:57 -04001244 return;
1245 }
1246
Andre Guedes89352e72011-11-04 14:16:53 -03001247 set_bit(HCI_INQUIRY, &hdev->flags);
1248
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001249 hci_dev_lock(hdev);
Andre Guedes343f9352012-02-17 20:39:37 -03001250 hci_discovery_set_state(hdev, DISCOVERY_FINDING);
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001251 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001252}
1253
Gustavo Padovan6039aa732012-05-23 04:04:18 -03001254static void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001256 struct hci_cp_create_conn *cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001259 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001260
1261 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 if (!cp)
1263 return;
1264
1265 hci_dev_lock(hdev);
1266
1267 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
1268
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001269 BT_DBG("%s bdaddr %pMR hcon %p", hdev->name, &cp->bdaddr, conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
1271 if (status) {
1272 if (conn && conn->state == BT_CONNECT) {
Marcel Holtmann4c67bc72006-10-15 17:30:56 +02001273 if (status != 0x0c || conn->attempt > 2) {
1274 conn->state = BT_CLOSED;
1275 hci_proto_connect_cfm(conn, status);
1276 hci_conn_del(conn);
1277 } else
1278 conn->state = BT_CONNECT2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 }
1280 } else {
1281 if (!conn) {
1282 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
1283 if (conn) {
Johan Hedberga0c808b2012-01-16 09:49:58 +02001284 conn->out = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 conn->link_mode |= HCI_LM_MASTER;
1286 } else
Gustavo F. Padovan893ef972010-07-18 15:13:37 -03001287 BT_ERR("No memory for new connection");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 }
1289 }
1290
1291 hci_dev_unlock(hdev);
1292}
1293
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001294static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001296 struct hci_cp_add_sco *cp;
1297 struct hci_conn *acl, *sco;
1298 __u16 handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001300 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001301
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001302 if (!status)
1303 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001305 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
1306 if (!cp)
1307 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001309 handle = __le16_to_cpu(cp->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001311 BT_DBG("%s handle 0x%4.4x", hdev->name, handle);
Marcel Holtmann6bd57412006-11-18 22:14:22 +01001312
1313 hci_dev_lock(hdev);
1314
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001315 acl = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001316 if (acl) {
1317 sco = acl->link;
1318 if (sco) {
1319 sco->state = BT_CLOSED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001320
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001321 hci_proto_connect_cfm(sco, status);
1322 hci_conn_del(sco);
1323 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001324 }
Marcel Holtmann6bd57412006-11-18 22:14:22 +01001325
1326 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327}
1328
Marcel Holtmannf8558552008-07-14 20:13:49 +02001329static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
1330{
1331 struct hci_cp_auth_requested *cp;
1332 struct hci_conn *conn;
1333
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001334 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmannf8558552008-07-14 20:13:49 +02001335
1336 if (!status)
1337 return;
1338
1339 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
1340 if (!cp)
1341 return;
1342
1343 hci_dev_lock(hdev);
1344
1345 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1346 if (conn) {
1347 if (conn->state == BT_CONFIG) {
1348 hci_proto_connect_cfm(conn, status);
1349 hci_conn_put(conn);
1350 }
1351 }
1352
1353 hci_dev_unlock(hdev);
1354}
1355
1356static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
1357{
1358 struct hci_cp_set_conn_encrypt *cp;
1359 struct hci_conn *conn;
1360
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001361 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmannf8558552008-07-14 20:13:49 +02001362
1363 if (!status)
1364 return;
1365
1366 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
1367 if (!cp)
1368 return;
1369
1370 hci_dev_lock(hdev);
1371
1372 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1373 if (conn) {
1374 if (conn->state == BT_CONFIG) {
1375 hci_proto_connect_cfm(conn, status);
1376 hci_conn_put(conn);
1377 }
1378 }
1379
1380 hci_dev_unlock(hdev);
1381}
1382
Johan Hedberg127178d2010-11-18 22:22:29 +02001383static int hci_outgoing_auth_needed(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -03001384 struct hci_conn *conn)
Johan Hedberg392599b2010-11-18 22:22:28 +02001385{
Johan Hedberg392599b2010-11-18 22:22:28 +02001386 if (conn->state != BT_CONFIG || !conn->out)
1387 return 0;
1388
Johan Hedberg765c2a92011-01-19 12:06:52 +05301389 if (conn->pending_sec_level == BT_SECURITY_SDP)
Johan Hedberg392599b2010-11-18 22:22:28 +02001390 return 0;
1391
1392 /* Only request authentication for SSP connections or non-SSP
Vinicius Costa Gomese9bf2bf2011-09-02 14:51:20 -03001393 * devices with sec_level HIGH or if MITM protection is requested */
Gustavo Padovan807deac2012-05-17 00:36:24 -03001394 if (!hci_conn_ssp_enabled(conn) && !(conn->auth_type & 0x01) &&
1395 conn->pending_sec_level != BT_SECURITY_HIGH)
Johan Hedberg392599b2010-11-18 22:22:28 +02001396 return 0;
1397
Johan Hedberg392599b2010-11-18 22:22:28 +02001398 return 1;
1399}
1400
Gustavo Padovan6039aa732012-05-23 04:04:18 -03001401static int hci_resolve_name(struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001402 struct inquiry_entry *e)
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001403{
1404 struct hci_cp_remote_name_req cp;
1405
1406 memset(&cp, 0, sizeof(cp));
1407
1408 bacpy(&cp.bdaddr, &e->data.bdaddr);
1409 cp.pscan_rep_mode = e->data.pscan_rep_mode;
1410 cp.pscan_mode = e->data.pscan_mode;
1411 cp.clock_offset = e->data.clock_offset;
1412
1413 return hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
1414}
1415
Johan Hedbergb644ba32012-01-17 21:48:47 +02001416static bool hci_resolve_next_name(struct hci_dev *hdev)
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001417{
1418 struct discovery_state *discov = &hdev->discovery;
1419 struct inquiry_entry *e;
1420
Johan Hedbergb644ba32012-01-17 21:48:47 +02001421 if (list_empty(&discov->resolve))
1422 return false;
1423
1424 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY, NAME_NEEDED);
Ram Malovanyc8100892012-07-19 10:26:09 +03001425 if (!e)
1426 return false;
1427
Johan Hedbergb644ba32012-01-17 21:48:47 +02001428 if (hci_resolve_name(hdev, e) == 0) {
1429 e->name_state = NAME_PENDING;
1430 return true;
1431 }
1432
1433 return false;
1434}
1435
1436static void hci_check_pending_name(struct hci_dev *hdev, struct hci_conn *conn,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001437 bdaddr_t *bdaddr, u8 *name, u8 name_len)
Johan Hedbergb644ba32012-01-17 21:48:47 +02001438{
1439 struct discovery_state *discov = &hdev->discovery;
1440 struct inquiry_entry *e;
1441
1442 if (conn && !test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001443 mgmt_device_connected(hdev, bdaddr, ACL_LINK, 0x00, 0, name,
1444 name_len, conn->dev_class);
Johan Hedbergb644ba32012-01-17 21:48:47 +02001445
1446 if (discov->state == DISCOVERY_STOPPED)
1447 return;
1448
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001449 if (discov->state == DISCOVERY_STOPPING)
1450 goto discov_complete;
1451
1452 if (discov->state != DISCOVERY_RESOLVING)
1453 return;
1454
1455 e = hci_inquiry_cache_lookup_resolve(hdev, bdaddr, NAME_PENDING);
Ram Malovany7cc83802012-07-19 10:26:10 +03001456 /* If the device was not found in a list of found devices names of which
1457 * are pending. there is no need to continue resolving a next name as it
1458 * will be done upon receiving another Remote Name Request Complete
1459 * Event */
1460 if (!e)
1461 return;
1462
1463 list_del(&e->list);
1464 if (name) {
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001465 e->name_state = NAME_KNOWN;
Ram Malovany7cc83802012-07-19 10:26:10 +03001466 mgmt_remote_name(hdev, bdaddr, ACL_LINK, 0x00,
1467 e->data.rssi, name, name_len);
Ram Malovanyc3e7c0d2012-07-19 10:26:11 +03001468 } else {
1469 e->name_state = NAME_NOT_KNOWN;
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001470 }
1471
Johan Hedbergb644ba32012-01-17 21:48:47 +02001472 if (hci_resolve_next_name(hdev))
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001473 return;
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001474
1475discov_complete:
1476 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1477}
1478
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001479static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
1480{
Johan Hedberg127178d2010-11-18 22:22:29 +02001481 struct hci_cp_remote_name_req *cp;
1482 struct hci_conn *conn;
1483
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001484 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Johan Hedberg127178d2010-11-18 22:22:29 +02001485
1486 /* If successful wait for the name req complete event before
1487 * checking for the need to do authentication */
1488 if (!status)
1489 return;
1490
1491 cp = hci_sent_cmd_data(hdev, HCI_OP_REMOTE_NAME_REQ);
1492 if (!cp)
1493 return;
1494
1495 hci_dev_lock(hdev);
1496
1497 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
Johan Hedbergb644ba32012-01-17 21:48:47 +02001498
1499 if (test_bit(HCI_MGMT, &hdev->dev_flags))
1500 hci_check_pending_name(hdev, conn, &cp->bdaddr, NULL, 0);
1501
Johan Hedberg79c6c702011-04-28 11:28:55 -07001502 if (!conn)
1503 goto unlock;
1504
1505 if (!hci_outgoing_auth_needed(hdev, conn))
1506 goto unlock;
1507
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001508 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02001509 struct hci_cp_auth_requested cp;
1510 cp.handle = __cpu_to_le16(conn->handle);
1511 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
1512 }
1513
Johan Hedberg79c6c702011-04-28 11:28:55 -07001514unlock:
Johan Hedberg127178d2010-11-18 22:22:29 +02001515 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001516}
1517
Marcel Holtmann769be972008-07-14 20:13:49 +02001518static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
1519{
1520 struct hci_cp_read_remote_features *cp;
1521 struct hci_conn *conn;
1522
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001523 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmann769be972008-07-14 20:13:49 +02001524
1525 if (!status)
1526 return;
1527
1528 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
1529 if (!cp)
1530 return;
1531
1532 hci_dev_lock(hdev);
1533
1534 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1535 if (conn) {
1536 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001537 hci_proto_connect_cfm(conn, status);
1538 hci_conn_put(conn);
1539 }
1540 }
1541
1542 hci_dev_unlock(hdev);
1543}
1544
1545static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
1546{
1547 struct hci_cp_read_remote_ext_features *cp;
1548 struct hci_conn *conn;
1549
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001550 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmann769be972008-07-14 20:13:49 +02001551
1552 if (!status)
1553 return;
1554
1555 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
1556 if (!cp)
1557 return;
1558
1559 hci_dev_lock(hdev);
1560
1561 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1562 if (conn) {
1563 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001564 hci_proto_connect_cfm(conn, status);
1565 hci_conn_put(conn);
1566 }
1567 }
1568
1569 hci_dev_unlock(hdev);
1570}
1571
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001572static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
1573{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001574 struct hci_cp_setup_sync_conn *cp;
1575 struct hci_conn *acl, *sco;
1576 __u16 handle;
1577
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001578 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001579
1580 if (!status)
1581 return;
1582
1583 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
1584 if (!cp)
1585 return;
1586
1587 handle = __le16_to_cpu(cp->handle);
1588
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001589 BT_DBG("%s handle 0x%4.4x", hdev->name, handle);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001590
1591 hci_dev_lock(hdev);
1592
1593 acl = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001594 if (acl) {
1595 sco = acl->link;
1596 if (sco) {
1597 sco->state = BT_CLOSED;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001598
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001599 hci_proto_connect_cfm(sco, status);
1600 hci_conn_del(sco);
1601 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001602 }
1603
1604 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001605}
1606
1607static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
1608{
1609 struct hci_cp_sniff_mode *cp;
1610 struct hci_conn *conn;
1611
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001612 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001613
1614 if (!status)
1615 return;
1616
1617 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
1618 if (!cp)
1619 return;
1620
1621 hci_dev_lock(hdev);
1622
1623 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001624 if (conn) {
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001625 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001626
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001627 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001628 hci_sco_setup(conn, status);
1629 }
1630
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001631 hci_dev_unlock(hdev);
1632}
1633
1634static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
1635{
1636 struct hci_cp_exit_sniff_mode *cp;
1637 struct hci_conn *conn;
1638
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001639 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001640
1641 if (!status)
1642 return;
1643
1644 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
1645 if (!cp)
1646 return;
1647
1648 hci_dev_lock(hdev);
1649
1650 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001651 if (conn) {
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001652 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001653
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001654 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001655 hci_sco_setup(conn, status);
1656 }
1657
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001658 hci_dev_unlock(hdev);
1659}
1660
Johan Hedberg88c3df12012-02-09 14:27:38 +02001661static void hci_cs_disconnect(struct hci_dev *hdev, u8 status)
1662{
1663 struct hci_cp_disconnect *cp;
1664 struct hci_conn *conn;
1665
1666 if (!status)
1667 return;
1668
1669 cp = hci_sent_cmd_data(hdev, HCI_OP_DISCONNECT);
1670 if (!cp)
1671 return;
1672
1673 hci_dev_lock(hdev);
1674
1675 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1676 if (conn)
1677 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001678 conn->dst_type, status);
Johan Hedberg88c3df12012-02-09 14:27:38 +02001679
1680 hci_dev_unlock(hdev);
1681}
1682
Ville Tervofcd89c02011-02-10 22:38:47 -03001683static void hci_cs_le_create_conn(struct hci_dev *hdev, __u8 status)
1684{
Ville Tervofcd89c02011-02-10 22:38:47 -03001685 struct hci_conn *conn;
1686
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001687 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Ville Tervofcd89c02011-02-10 22:38:47 -03001688
Ville Tervofcd89c02011-02-10 22:38:47 -03001689 if (status) {
Andre Guedesf00a06a2012-07-27 15:10:13 -03001690 hci_dev_lock(hdev);
Ville Tervofcd89c02011-02-10 22:38:47 -03001691
Andre Guedes0c95ab72012-07-27 15:10:14 -03001692 conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
Andre Guedesf00a06a2012-07-27 15:10:13 -03001693 if (!conn) {
1694 hci_dev_unlock(hdev);
1695 return;
1696 }
1697
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001698 BT_DBG("%s bdaddr %pMR conn %p", hdev->name, &conn->dst, conn);
Andre Guedesf00a06a2012-07-27 15:10:13 -03001699
1700 conn->state = BT_CLOSED;
Andre Guedes0c95ab72012-07-27 15:10:14 -03001701 mgmt_connect_failed(hdev, &conn->dst, conn->type,
Andre Guedesf00a06a2012-07-27 15:10:13 -03001702 conn->dst_type, status);
1703 hci_proto_connect_cfm(conn, status);
1704 hci_conn_del(conn);
1705
1706 hci_dev_unlock(hdev);
1707 }
Ville Tervofcd89c02011-02-10 22:38:47 -03001708}
1709
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03001710static void hci_cs_le_start_enc(struct hci_dev *hdev, u8 status)
1711{
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001712 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03001713}
1714
Andrei Emeltchenkoa02226d2012-09-27 17:26:19 +03001715static void hci_cs_create_phylink(struct hci_dev *hdev, u8 status)
1716{
Andrei Emeltchenko93c284e2012-09-27 17:26:20 +03001717 struct hci_cp_create_phy_link *cp;
1718
Andrei Emeltchenkoa02226d2012-09-27 17:26:19 +03001719 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Andrei Emeltchenko93c284e2012-09-27 17:26:20 +03001720
1721 if (status)
1722 return;
1723
1724 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_PHY_LINK);
1725 if (!cp)
1726 return;
1727
1728 amp_write_remote_assoc(hdev, cp->phy_handle);
Andrei Emeltchenkoa02226d2012-09-27 17:26:19 +03001729}
1730
Andrei Emeltchenko0b26ab92012-09-27 17:26:24 +03001731static void hci_cs_accept_phylink(struct hci_dev *hdev, u8 status)
1732{
1733 struct hci_cp_accept_phy_link *cp;
1734
1735 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1736
1737 if (status)
1738 return;
1739
1740 cp = hci_sent_cmd_data(hdev, HCI_OP_ACCEPT_PHY_LINK);
1741 if (!cp)
1742 return;
1743
1744 amp_write_remote_assoc(hdev, cp->phy_handle);
1745}
1746
Gustavo Padovan6039aa732012-05-23 04:04:18 -03001747static void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001748{
1749 __u8 status = *((__u8 *) skb->data);
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001750 struct discovery_state *discov = &hdev->discovery;
1751 struct inquiry_entry *e;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001752
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001753 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001754
Johan Hedberg23bb5762010-12-21 23:01:27 +02001755 hci_req_complete(hdev, HCI_OP_INQUIRY, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001756
1757 hci_conn_check_pending(hdev);
Andre Guedes89352e72011-11-04 14:16:53 -03001758
1759 if (!test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
1760 return;
1761
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001762 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001763 return;
1764
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001765 hci_dev_lock(hdev);
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001766
Andre Guedes343f9352012-02-17 20:39:37 -03001767 if (discov->state != DISCOVERY_FINDING)
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001768 goto unlock;
1769
1770 if (list_empty(&discov->resolve)) {
1771 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1772 goto unlock;
1773 }
1774
1775 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY, NAME_NEEDED);
1776 if (e && hci_resolve_name(hdev, e) == 0) {
1777 e->name_state = NAME_PENDING;
1778 hci_discovery_set_state(hdev, DISCOVERY_RESOLVING);
1779 } else {
1780 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1781 }
1782
1783unlock:
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001784 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001785}
1786
Gustavo Padovan6039aa732012-05-23 04:04:18 -03001787static void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788{
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001789 struct inquiry_data data;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001790 struct inquiry_info *info = (void *) (skb->data + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 int num_rsp = *((__u8 *) skb->data);
1792
1793 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1794
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001795 if (!num_rsp)
1796 return;
1797
Andre Guedes1519cc12012-03-21 00:03:38 -03001798 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
1799 return;
1800
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001802
Johan Hedberge17acd42011-03-30 23:57:16 +03001803 for (; num_rsp; num_rsp--, info++) {
Johan Hedberg388fc8f2012-02-23 00:38:59 +02001804 bool name_known, ssp;
Johan Hedberg31754052012-01-04 13:39:52 +02001805
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 bacpy(&data.bdaddr, &info->bdaddr);
1807 data.pscan_rep_mode = info->pscan_rep_mode;
1808 data.pscan_period_mode = info->pscan_period_mode;
1809 data.pscan_mode = info->pscan_mode;
1810 memcpy(data.dev_class, info->dev_class, 3);
1811 data.clock_offset = info->clock_offset;
1812 data.rssi = 0x00;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001813 data.ssp_mode = 0x00;
Johan Hedberg31754052012-01-04 13:39:52 +02001814
Johan Hedberg388fc8f2012-02-23 00:38:59 +02001815 name_known = hci_inquiry_cache_update(hdev, &data, false, &ssp);
Johan Hedberg48264f02011-11-09 13:58:58 +02001816 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001817 info->dev_class, 0, !name_known, ssp, NULL,
1818 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001820
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 hci_dev_unlock(hdev);
1822}
1823
Gustavo Padovan6039aa732012-05-23 04:04:18 -03001824static void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001826 struct hci_ev_conn_complete *ev = (void *) skb->data;
1827 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001829 BT_DBG("%s", hdev->name);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001830
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001832
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001833 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann94992372009-04-19 19:30:03 +02001834 if (!conn) {
1835 if (ev->link_type != SCO_LINK)
1836 goto unlock;
1837
1838 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1839 if (!conn)
1840 goto unlock;
1841
1842 conn->type = SCO_LINK;
1843 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001844
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001845 if (!ev->status) {
1846 conn->handle = __le16_to_cpu(ev->handle);
Marcel Holtmann769be972008-07-14 20:13:49 +02001847
1848 if (conn->type == ACL_LINK) {
1849 conn->state = BT_CONFIG;
1850 hci_conn_hold(conn);
Szymon Janca9ea3ed2012-07-19 14:46:08 +02001851
1852 if (!conn->out && !hci_conn_ssp_enabled(conn) &&
1853 !hci_find_link_key(hdev, &ev->bdaddr))
1854 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
1855 else
1856 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann769be972008-07-14 20:13:49 +02001857 } else
1858 conn->state = BT_CONNECTED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001859
Marcel Holtmann9eba32b2009-08-22 14:19:26 -07001860 hci_conn_hold_device(conn);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001861 hci_conn_add_sysfs(conn);
1862
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001863 if (test_bit(HCI_AUTH, &hdev->flags))
1864 conn->link_mode |= HCI_LM_AUTH;
1865
1866 if (test_bit(HCI_ENCRYPT, &hdev->flags))
1867 conn->link_mode |= HCI_LM_ENCRYPT;
1868
1869 /* Get remote features */
1870 if (conn->type == ACL_LINK) {
1871 struct hci_cp_read_remote_features cp;
1872 cp.handle = ev->handle;
Marcel Holtmann769be972008-07-14 20:13:49 +02001873 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001874 sizeof(cp), &cp);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001875 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001876
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001877 /* Set packet type for incoming connection */
Andrei Emeltchenkod095c1e2011-12-01 14:33:27 +02001878 if (!conn->out && hdev->hci_ver < BLUETOOTH_VER_2_0) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001879 struct hci_cp_change_conn_ptype cp;
1880 cp.handle = ev->handle;
Marcel Holtmanna8746412008-07-14 20:13:46 +02001881 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001882 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE, sizeof(cp),
1883 &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001884 }
Johan Hedberg17d5c042011-01-22 06:09:08 +02001885 } else {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001886 conn->state = BT_CLOSED;
Johan Hedberg17d5c042011-01-22 06:09:08 +02001887 if (conn->type == ACL_LINK)
Johan Hedberg744cf192011-11-08 20:40:14 +02001888 mgmt_connect_failed(hdev, &ev->bdaddr, conn->type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001889 conn->dst_type, ev->status);
Johan Hedberg17d5c042011-01-22 06:09:08 +02001890 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001891
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001892 if (conn->type == ACL_LINK)
1893 hci_sco_setup(conn, ev->status);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001894
Marcel Holtmann769be972008-07-14 20:13:49 +02001895 if (ev->status) {
1896 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001897 hci_conn_del(conn);
Marcel Holtmannc89b6e62009-01-15 21:57:03 +01001898 } else if (ev->link_type != ACL_LINK)
1899 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001900
1901unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001903
1904 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905}
1906
Gustavo Padovan6039aa732012-05-23 04:04:18 -03001907static void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001909 struct hci_ev_conn_request *ev = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 int mask = hdev->link_mode;
1911
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001912 BT_DBG("%s bdaddr %pMR type 0x%x", hdev->name, &ev->bdaddr,
Gustavo Padovan807deac2012-05-17 00:36:24 -03001913 ev->link_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914
1915 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
1916
Szymon Janc138d22e2011-02-17 16:44:23 +01001917 if ((mask & HCI_LM_ACCEPT) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03001918 !hci_blacklist_lookup(hdev, &ev->bdaddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 /* Connection accepted */
Marcel Holtmannc7bdd502008-07-14 20:13:47 +02001920 struct inquiry_entry *ie;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922
1923 hci_dev_lock(hdev);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001924
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02001925 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
1926 if (ie)
Marcel Holtmannc7bdd502008-07-14 20:13:47 +02001927 memcpy(ie->data.dev_class, ev->dev_class, 3);
1928
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03001929 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type,
1930 &ev->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 if (!conn) {
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02001932 conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr);
1933 if (!conn) {
Gustavo F. Padovan893ef972010-07-18 15:13:37 -03001934 BT_ERR("No memory for new connection");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 hci_dev_unlock(hdev);
1936 return;
1937 }
1938 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001939
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 memcpy(conn->dev_class, ev->dev_class, 3);
1941 conn->state = BT_CONNECT;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001942
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 hci_dev_unlock(hdev);
1944
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001945 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
1946 struct hci_cp_accept_conn_req cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001948 bacpy(&cp.bdaddr, &ev->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001950 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
1951 cp.role = 0x00; /* Become master */
1952 else
1953 cp.role = 0x01; /* Remain slave */
1954
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001955 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp),
1956 &cp);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001957 } else {
1958 struct hci_cp_accept_sync_conn_req cp;
1959
1960 bacpy(&cp.bdaddr, &ev->bdaddr);
Marcel Holtmanna8746412008-07-14 20:13:46 +02001961 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001962
Andrei Emeltchenko82781e62012-05-25 11:38:27 +03001963 cp.tx_bandwidth = __constant_cpu_to_le32(0x00001f40);
1964 cp.rx_bandwidth = __constant_cpu_to_le32(0x00001f40);
1965 cp.max_latency = __constant_cpu_to_le16(0xffff);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001966 cp.content_format = cpu_to_le16(hdev->voice_setting);
1967 cp.retrans_effort = 0xff;
1968
1969 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001970 sizeof(cp), &cp);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001971 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 } else {
1973 /* Connection rejected */
1974 struct hci_cp_reject_conn_req cp;
1975
1976 bacpy(&cp.bdaddr, &ev->bdaddr);
Andrei Emeltchenko9f5a0d72011-11-07 14:20:25 +02001977 cp.reason = HCI_ERROR_REJ_BAD_ADDR;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001978 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 }
1980}
1981
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02001982static u8 hci_to_mgmt_reason(u8 err)
1983{
1984 switch (err) {
1985 case HCI_ERROR_CONNECTION_TIMEOUT:
1986 return MGMT_DEV_DISCONN_TIMEOUT;
1987 case HCI_ERROR_REMOTE_USER_TERM:
1988 case HCI_ERROR_REMOTE_LOW_RESOURCES:
1989 case HCI_ERROR_REMOTE_POWER_OFF:
1990 return MGMT_DEV_DISCONN_REMOTE;
1991 case HCI_ERROR_LOCAL_HOST_TERM:
1992 return MGMT_DEV_DISCONN_LOCAL_HOST;
1993 default:
1994 return MGMT_DEV_DISCONN_UNKNOWN;
1995 }
1996}
1997
Gustavo Padovan6039aa732012-05-23 04:04:18 -03001998static void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002000 struct hci_ev_disconn_complete *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002001 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002003 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 hci_dev_lock(hdev);
2006
Marcel Holtmann04837f62006-07-03 10:02:33 +02002007 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergf7520542011-01-20 12:34:39 +02002008 if (!conn)
2009 goto unlock;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02002010
Johan Hedberg37d9ef72011-11-10 15:54:39 +02002011 if (ev->status == 0)
2012 conn->state = BT_CLOSED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013
Johan Hedbergb644ba32012-01-17 21:48:47 +02002014 if (test_and_clear_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03002015 (conn->type == ACL_LINK || conn->type == LE_LINK)) {
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02002016 if (ev->status) {
Johan Hedberg88c3df12012-02-09 14:27:38 +02002017 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
Gustavo Padovan807deac2012-05-17 00:36:24 -03002018 conn->dst_type, ev->status);
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02002019 } else {
2020 u8 reason = hci_to_mgmt_reason(ev->reason);
2021
Johan Hedbergafc747a2012-01-15 18:11:07 +02002022 mgmt_device_disconnected(hdev, &conn->dst, conn->type,
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02002023 conn->dst_type, reason);
2024 }
Johan Hedberg37d9ef72011-11-10 15:54:39 +02002025 }
Johan Hedbergf7520542011-01-20 12:34:39 +02002026
Johan Hedberg37d9ef72011-11-10 15:54:39 +02002027 if (ev->status == 0) {
Vishal Agarwal6ec5bca2012-04-16 14:44:44 +05302028 if (conn->type == ACL_LINK && conn->flush_key)
2029 hci_remove_link_key(hdev, &conn->dst);
Johan Hedberg37d9ef72011-11-10 15:54:39 +02002030 hci_proto_disconn_cfm(conn, ev->reason);
2031 hci_conn_del(conn);
2032 }
Johan Hedbergf7520542011-01-20 12:34:39 +02002033
2034unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 hci_dev_unlock(hdev);
2036}
2037
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002038static void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002039{
2040 struct hci_ev_auth_complete *ev = (void *) skb->data;
2041 struct hci_conn *conn;
2042
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002043 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002044
2045 hci_dev_lock(hdev);
2046
2047 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002048 if (!conn)
2049 goto unlock;
2050
2051 if (!ev->status) {
Johan Hedbergaa64a8b2012-01-18 21:33:12 +02002052 if (!hci_conn_ssp_enabled(conn) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03002053 test_bit(HCI_CONN_REAUTH_PEND, &conn->flags)) {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002054 BT_INFO("re-auth of legacy device is not possible.");
Johan Hedberg2a611692011-02-19 12:06:00 -03002055 } else {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002056 conn->link_mode |= HCI_LM_AUTH;
2057 conn->sec_level = conn->pending_sec_level;
Johan Hedberg2a611692011-02-19 12:06:00 -03002058 }
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002059 } else {
Johan Hedbergbab73cb2012-02-09 16:07:29 +02002060 mgmt_auth_failed(hdev, &conn->dst, conn->type, conn->dst_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002061 ev->status);
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002062 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002063
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002064 clear_bit(HCI_CONN_AUTH_PEND, &conn->flags);
2065 clear_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002066
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002067 if (conn->state == BT_CONFIG) {
Johan Hedbergaa64a8b2012-01-18 21:33:12 +02002068 if (!ev->status && hci_conn_ssp_enabled(conn)) {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002069 struct hci_cp_set_conn_encrypt cp;
2070 cp.handle = ev->handle;
2071 cp.encrypt = 0x01;
2072 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
Gustavo Padovan807deac2012-05-17 00:36:24 -03002073 &cp);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002074 } else {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002075 conn->state = BT_CONNECTED;
2076 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002077 hci_conn_put(conn);
2078 }
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002079 } else {
2080 hci_auth_cfm(conn, ev->status);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002081
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002082 hci_conn_hold(conn);
2083 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
2084 hci_conn_put(conn);
2085 }
2086
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002087 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002088 if (!ev->status) {
2089 struct hci_cp_set_conn_encrypt cp;
2090 cp.handle = ev->handle;
2091 cp.encrypt = 0x01;
2092 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
Gustavo Padovan807deac2012-05-17 00:36:24 -03002093 &cp);
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002094 } else {
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002095 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002096 hci_encrypt_cfm(conn, ev->status, 0x00);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002097 }
2098 }
2099
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02002100unlock:
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002101 hci_dev_unlock(hdev);
2102}
2103
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002104static void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002105{
Johan Hedberg127178d2010-11-18 22:22:29 +02002106 struct hci_ev_remote_name *ev = (void *) skb->data;
2107 struct hci_conn *conn;
2108
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002109 BT_DBG("%s", hdev->name);
2110
2111 hci_conn_check_pending(hdev);
Johan Hedberg127178d2010-11-18 22:22:29 +02002112
2113 hci_dev_lock(hdev);
2114
2115 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedbergb644ba32012-01-17 21:48:47 +02002116
2117 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
2118 goto check_auth;
2119
2120 if (ev->status == 0)
2121 hci_check_pending_name(hdev, conn, &ev->bdaddr, ev->name,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002122 strnlen(ev->name, HCI_MAX_NAME_LENGTH));
Johan Hedbergb644ba32012-01-17 21:48:47 +02002123 else
2124 hci_check_pending_name(hdev, conn, &ev->bdaddr, NULL, 0);
2125
2126check_auth:
Johan Hedberg79c6c702011-04-28 11:28:55 -07002127 if (!conn)
2128 goto unlock;
2129
2130 if (!hci_outgoing_auth_needed(hdev, conn))
2131 goto unlock;
2132
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002133 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02002134 struct hci_cp_auth_requested cp;
2135 cp.handle = __cpu_to_le16(conn->handle);
2136 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
2137 }
2138
Johan Hedberg79c6c702011-04-28 11:28:55 -07002139unlock:
Johan Hedberg127178d2010-11-18 22:22:29 +02002140 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002141}
2142
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002143static void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002144{
2145 struct hci_ev_encrypt_change *ev = (void *) skb->data;
2146 struct hci_conn *conn;
2147
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002148 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002149
2150 hci_dev_lock(hdev);
2151
2152 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2153 if (conn) {
2154 if (!ev->status) {
Marcel Holtmannae293192008-07-14 20:13:45 +02002155 if (ev->encrypt) {
2156 /* Encryption implies authentication */
2157 conn->link_mode |= HCI_LM_AUTH;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002158 conn->link_mode |= HCI_LM_ENCRYPT;
Vinicius Costa Gomesda85e5e2011-06-09 18:50:53 -03002159 conn->sec_level = conn->pending_sec_level;
Marcel Holtmannae293192008-07-14 20:13:45 +02002160 } else
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002161 conn->link_mode &= ~HCI_LM_ENCRYPT;
2162 }
2163
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002164 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002165
Gustavo Padovana7d77232012-05-13 03:20:07 -03002166 if (ev->status && conn->state == BT_CONNECTED) {
Gustavo Padovand839c812012-05-16 12:17:12 -03002167 hci_acl_disconn(conn, HCI_ERROR_AUTH_FAILURE);
Gustavo Padovana7d77232012-05-13 03:20:07 -03002168 hci_conn_put(conn);
2169 goto unlock;
2170 }
2171
Marcel Holtmannf8558552008-07-14 20:13:49 +02002172 if (conn->state == BT_CONFIG) {
2173 if (!ev->status)
2174 conn->state = BT_CONNECTED;
2175
2176 hci_proto_connect_cfm(conn, ev->status);
2177 hci_conn_put(conn);
2178 } else
2179 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002180 }
2181
Gustavo Padovana7d77232012-05-13 03:20:07 -03002182unlock:
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002183 hci_dev_unlock(hdev);
2184}
2185
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002186static void hci_change_link_key_complete_evt(struct hci_dev *hdev,
2187 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002188{
2189 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
2190 struct hci_conn *conn;
2191
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002192 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002193
2194 hci_dev_lock(hdev);
2195
2196 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2197 if (conn) {
2198 if (!ev->status)
2199 conn->link_mode |= HCI_LM_SECURE;
2200
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002201 clear_bit(HCI_CONN_AUTH_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002202
2203 hci_key_change_cfm(conn, ev->status);
2204 }
2205
2206 hci_dev_unlock(hdev);
2207}
2208
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002209static void hci_remote_features_evt(struct hci_dev *hdev,
2210 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002211{
2212 struct hci_ev_remote_features *ev = (void *) skb->data;
2213 struct hci_conn *conn;
2214
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002215 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002216
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002217 hci_dev_lock(hdev);
2218
2219 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergccd556f2010-11-10 17:11:51 +02002220 if (!conn)
2221 goto unlock;
Marcel Holtmann769be972008-07-14 20:13:49 +02002222
Johan Hedbergccd556f2010-11-10 17:11:51 +02002223 if (!ev->status)
2224 memcpy(conn->features, ev->features, 8);
2225
2226 if (conn->state != BT_CONFIG)
2227 goto unlock;
2228
2229 if (!ev->status && lmp_ssp_capable(hdev) && lmp_ssp_capable(conn)) {
2230 struct hci_cp_read_remote_ext_features cp;
2231 cp.handle = ev->handle;
2232 cp.page = 0x01;
2233 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES,
Gustavo Padovan807deac2012-05-17 00:36:24 -03002234 sizeof(cp), &cp);
Johan Hedberg392599b2010-11-18 22:22:28 +02002235 goto unlock;
2236 }
2237
Johan Hedberg671267b2012-05-12 16:11:50 -03002238 if (!ev->status && !test_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02002239 struct hci_cp_remote_name_req cp;
2240 memset(&cp, 0, sizeof(cp));
2241 bacpy(&cp.bdaddr, &conn->dst);
2242 cp.pscan_rep_mode = 0x02;
2243 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
Johan Hedbergb644ba32012-01-17 21:48:47 +02002244 } else if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
2245 mgmt_device_connected(hdev, &conn->dst, conn->type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002246 conn->dst_type, 0, NULL, 0,
2247 conn->dev_class);
Johan Hedberg392599b2010-11-18 22:22:28 +02002248
Johan Hedberg127178d2010-11-18 22:22:29 +02002249 if (!hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedbergccd556f2010-11-10 17:11:51 +02002250 conn->state = BT_CONNECTED;
2251 hci_proto_connect_cfm(conn, ev->status);
2252 hci_conn_put(conn);
Marcel Holtmann769be972008-07-14 20:13:49 +02002253 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002254
Johan Hedbergccd556f2010-11-10 17:11:51 +02002255unlock:
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002256 hci_dev_unlock(hdev);
2257}
2258
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002259static void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002260{
2261 BT_DBG("%s", hdev->name);
2262}
2263
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002264static void hci_qos_setup_complete_evt(struct hci_dev *hdev,
2265 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002266{
2267 BT_DBG("%s", hdev->name);
2268}
2269
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002270static void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002271{
2272 struct hci_ev_cmd_complete *ev = (void *) skb->data;
2273 __u16 opcode;
2274
2275 skb_pull(skb, sizeof(*ev));
2276
2277 opcode = __le16_to_cpu(ev->opcode);
2278
2279 switch (opcode) {
2280 case HCI_OP_INQUIRY_CANCEL:
2281 hci_cc_inquiry_cancel(hdev, skb);
2282 break;
2283
Andre Guedes4d934832012-03-21 00:03:35 -03002284 case HCI_OP_PERIODIC_INQ:
2285 hci_cc_periodic_inq(hdev, skb);
2286 break;
2287
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002288 case HCI_OP_EXIT_PERIODIC_INQ:
2289 hci_cc_exit_periodic_inq(hdev, skb);
2290 break;
2291
2292 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
2293 hci_cc_remote_name_req_cancel(hdev, skb);
2294 break;
2295
2296 case HCI_OP_ROLE_DISCOVERY:
2297 hci_cc_role_discovery(hdev, skb);
2298 break;
2299
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02002300 case HCI_OP_READ_LINK_POLICY:
2301 hci_cc_read_link_policy(hdev, skb);
2302 break;
2303
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002304 case HCI_OP_WRITE_LINK_POLICY:
2305 hci_cc_write_link_policy(hdev, skb);
2306 break;
2307
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02002308 case HCI_OP_READ_DEF_LINK_POLICY:
2309 hci_cc_read_def_link_policy(hdev, skb);
2310 break;
2311
2312 case HCI_OP_WRITE_DEF_LINK_POLICY:
2313 hci_cc_write_def_link_policy(hdev, skb);
2314 break;
2315
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002316 case HCI_OP_RESET:
2317 hci_cc_reset(hdev, skb);
2318 break;
2319
2320 case HCI_OP_WRITE_LOCAL_NAME:
2321 hci_cc_write_local_name(hdev, skb);
2322 break;
2323
2324 case HCI_OP_READ_LOCAL_NAME:
2325 hci_cc_read_local_name(hdev, skb);
2326 break;
2327
2328 case HCI_OP_WRITE_AUTH_ENABLE:
2329 hci_cc_write_auth_enable(hdev, skb);
2330 break;
2331
2332 case HCI_OP_WRITE_ENCRYPT_MODE:
2333 hci_cc_write_encrypt_mode(hdev, skb);
2334 break;
2335
2336 case HCI_OP_WRITE_SCAN_ENABLE:
2337 hci_cc_write_scan_enable(hdev, skb);
2338 break;
2339
2340 case HCI_OP_READ_CLASS_OF_DEV:
2341 hci_cc_read_class_of_dev(hdev, skb);
2342 break;
2343
2344 case HCI_OP_WRITE_CLASS_OF_DEV:
2345 hci_cc_write_class_of_dev(hdev, skb);
2346 break;
2347
2348 case HCI_OP_READ_VOICE_SETTING:
2349 hci_cc_read_voice_setting(hdev, skb);
2350 break;
2351
2352 case HCI_OP_WRITE_VOICE_SETTING:
2353 hci_cc_write_voice_setting(hdev, skb);
2354 break;
2355
2356 case HCI_OP_HOST_BUFFER_SIZE:
2357 hci_cc_host_buffer_size(hdev, skb);
2358 break;
2359
Marcel Holtmann333140b2008-07-14 20:13:48 +02002360 case HCI_OP_WRITE_SSP_MODE:
2361 hci_cc_write_ssp_mode(hdev, skb);
2362 break;
2363
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002364 case HCI_OP_READ_LOCAL_VERSION:
2365 hci_cc_read_local_version(hdev, skb);
2366 break;
2367
2368 case HCI_OP_READ_LOCAL_COMMANDS:
2369 hci_cc_read_local_commands(hdev, skb);
2370 break;
2371
2372 case HCI_OP_READ_LOCAL_FEATURES:
2373 hci_cc_read_local_features(hdev, skb);
2374 break;
2375
Andre Guedes971e3a42011-06-30 19:20:52 -03002376 case HCI_OP_READ_LOCAL_EXT_FEATURES:
2377 hci_cc_read_local_ext_features(hdev, skb);
2378 break;
2379
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002380 case HCI_OP_READ_BUFFER_SIZE:
2381 hci_cc_read_buffer_size(hdev, skb);
2382 break;
2383
2384 case HCI_OP_READ_BD_ADDR:
2385 hci_cc_read_bd_addr(hdev, skb);
2386 break;
2387
Andrei Emeltchenko350ee4c2011-12-07 15:56:51 +02002388 case HCI_OP_READ_DATA_BLOCK_SIZE:
2389 hci_cc_read_data_block_size(hdev, skb);
2390 break;
2391
Johan Hedberg23bb5762010-12-21 23:01:27 +02002392 case HCI_OP_WRITE_CA_TIMEOUT:
2393 hci_cc_write_ca_timeout(hdev, skb);
2394 break;
2395
Andrei Emeltchenko1e89cff2011-11-24 14:52:02 +02002396 case HCI_OP_READ_FLOW_CONTROL_MODE:
2397 hci_cc_read_flow_control_mode(hdev, skb);
2398 break;
2399
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +03002400 case HCI_OP_READ_LOCAL_AMP_INFO:
2401 hci_cc_read_local_amp_info(hdev, skb);
2402 break;
2403
Andrei Emeltchenko903e4542012-09-27 17:26:09 +03002404 case HCI_OP_READ_LOCAL_AMP_ASSOC:
2405 hci_cc_read_local_amp_assoc(hdev, skb);
2406 break;
2407
Johan Hedbergb0916ea2011-01-10 13:44:55 +02002408 case HCI_OP_DELETE_STORED_LINK_KEY:
2409 hci_cc_delete_stored_link_key(hdev, skb);
2410 break;
2411
Johan Hedbergd5859e22011-01-25 01:19:58 +02002412 case HCI_OP_SET_EVENT_MASK:
2413 hci_cc_set_event_mask(hdev, skb);
2414 break;
2415
2416 case HCI_OP_WRITE_INQUIRY_MODE:
2417 hci_cc_write_inquiry_mode(hdev, skb);
2418 break;
2419
2420 case HCI_OP_READ_INQ_RSP_TX_POWER:
2421 hci_cc_read_inq_rsp_tx_power(hdev, skb);
2422 break;
2423
2424 case HCI_OP_SET_EVENT_FLT:
2425 hci_cc_set_event_flt(hdev, skb);
2426 break;
2427
Johan Hedberg980e1a52011-01-22 06:10:07 +02002428 case HCI_OP_PIN_CODE_REPLY:
2429 hci_cc_pin_code_reply(hdev, skb);
2430 break;
2431
2432 case HCI_OP_PIN_CODE_NEG_REPLY:
2433 hci_cc_pin_code_neg_reply(hdev, skb);
2434 break;
2435
Szymon Jancc35938b2011-03-22 13:12:21 +01002436 case HCI_OP_READ_LOCAL_OOB_DATA:
2437 hci_cc_read_local_oob_data_reply(hdev, skb);
2438 break;
2439
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002440 case HCI_OP_LE_READ_BUFFER_SIZE:
2441 hci_cc_le_read_buffer_size(hdev, skb);
2442 break;
2443
Johan Hedberga5c29682011-02-19 12:05:57 -03002444 case HCI_OP_USER_CONFIRM_REPLY:
2445 hci_cc_user_confirm_reply(hdev, skb);
2446 break;
2447
2448 case HCI_OP_USER_CONFIRM_NEG_REPLY:
2449 hci_cc_user_confirm_neg_reply(hdev, skb);
2450 break;
2451
Brian Gix1143d452011-11-23 08:28:34 -08002452 case HCI_OP_USER_PASSKEY_REPLY:
2453 hci_cc_user_passkey_reply(hdev, skb);
2454 break;
2455
2456 case HCI_OP_USER_PASSKEY_NEG_REPLY:
2457 hci_cc_user_passkey_neg_reply(hdev, skb);
Szymon Janc16cde992012-04-13 12:32:42 +02002458 break;
Andre Guedes07f7fa52011-12-02 21:13:31 +09002459
2460 case HCI_OP_LE_SET_SCAN_PARAM:
2461 hci_cc_le_set_scan_param(hdev, skb);
Brian Gix1143d452011-11-23 08:28:34 -08002462 break;
2463
Andre Guedeseb9d91f2011-05-26 16:23:52 -03002464 case HCI_OP_LE_SET_SCAN_ENABLE:
2465 hci_cc_le_set_scan_enable(hdev, skb);
2466 break;
2467
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03002468 case HCI_OP_LE_LTK_REPLY:
2469 hci_cc_le_ltk_reply(hdev, skb);
2470 break;
2471
2472 case HCI_OP_LE_LTK_NEG_REPLY:
2473 hci_cc_le_ltk_neg_reply(hdev, skb);
2474 break;
2475
Andre Guedesf9b49302011-06-30 19:20:53 -03002476 case HCI_OP_WRITE_LE_HOST_SUPPORTED:
2477 hci_cc_write_le_host_supported(hdev, skb);
2478 break;
2479
Andrei Emeltchenko93c284e2012-09-27 17:26:20 +03002480 case HCI_OP_WRITE_REMOTE_AMP_ASSOC:
2481 hci_cc_write_remote_amp_assoc(hdev, skb);
2482 break;
2483
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002484 default:
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002485 BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002486 break;
2487 }
2488
Ville Tervo6bd32322011-02-16 16:32:41 +02002489 if (ev->opcode != HCI_OP_NOP)
2490 del_timer(&hdev->cmd_timer);
2491
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002492 if (ev->ncmd) {
2493 atomic_set(&hdev->cmd_cnt, 1);
2494 if (!skb_queue_empty(&hdev->cmd_q))
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002495 queue_work(hdev->workqueue, &hdev->cmd_work);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002496 }
2497}
2498
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002499static void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002500{
2501 struct hci_ev_cmd_status *ev = (void *) skb->data;
2502 __u16 opcode;
2503
2504 skb_pull(skb, sizeof(*ev));
2505
2506 opcode = __le16_to_cpu(ev->opcode);
2507
2508 switch (opcode) {
2509 case HCI_OP_INQUIRY:
2510 hci_cs_inquiry(hdev, ev->status);
2511 break;
2512
2513 case HCI_OP_CREATE_CONN:
2514 hci_cs_create_conn(hdev, ev->status);
2515 break;
2516
2517 case HCI_OP_ADD_SCO:
2518 hci_cs_add_sco(hdev, ev->status);
2519 break;
2520
Marcel Holtmannf8558552008-07-14 20:13:49 +02002521 case HCI_OP_AUTH_REQUESTED:
2522 hci_cs_auth_requested(hdev, ev->status);
2523 break;
2524
2525 case HCI_OP_SET_CONN_ENCRYPT:
2526 hci_cs_set_conn_encrypt(hdev, ev->status);
2527 break;
2528
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002529 case HCI_OP_REMOTE_NAME_REQ:
2530 hci_cs_remote_name_req(hdev, ev->status);
2531 break;
2532
Marcel Holtmann769be972008-07-14 20:13:49 +02002533 case HCI_OP_READ_REMOTE_FEATURES:
2534 hci_cs_read_remote_features(hdev, ev->status);
2535 break;
2536
2537 case HCI_OP_READ_REMOTE_EXT_FEATURES:
2538 hci_cs_read_remote_ext_features(hdev, ev->status);
2539 break;
2540
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002541 case HCI_OP_SETUP_SYNC_CONN:
2542 hci_cs_setup_sync_conn(hdev, ev->status);
2543 break;
2544
2545 case HCI_OP_SNIFF_MODE:
2546 hci_cs_sniff_mode(hdev, ev->status);
2547 break;
2548
2549 case HCI_OP_EXIT_SNIFF_MODE:
2550 hci_cs_exit_sniff_mode(hdev, ev->status);
2551 break;
2552
Johan Hedberg8962ee72011-01-20 12:40:27 +02002553 case HCI_OP_DISCONNECT:
Johan Hedberg88c3df12012-02-09 14:27:38 +02002554 hci_cs_disconnect(hdev, ev->status);
Johan Hedberg8962ee72011-01-20 12:40:27 +02002555 break;
2556
Ville Tervofcd89c02011-02-10 22:38:47 -03002557 case HCI_OP_LE_CREATE_CONN:
2558 hci_cs_le_create_conn(hdev, ev->status);
2559 break;
2560
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03002561 case HCI_OP_LE_START_ENC:
2562 hci_cs_le_start_enc(hdev, ev->status);
2563 break;
2564
Andrei Emeltchenkoa02226d2012-09-27 17:26:19 +03002565 case HCI_OP_CREATE_PHY_LINK:
2566 hci_cs_create_phylink(hdev, ev->status);
2567 break;
2568
Andrei Emeltchenko0b26ab92012-09-27 17:26:24 +03002569 case HCI_OP_ACCEPT_PHY_LINK:
2570 hci_cs_accept_phylink(hdev, ev->status);
2571 break;
2572
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002573 default:
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002574 BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002575 break;
2576 }
2577
Ville Tervo6bd32322011-02-16 16:32:41 +02002578 if (ev->opcode != HCI_OP_NOP)
2579 del_timer(&hdev->cmd_timer);
2580
Gustavo F. Padovan10572132011-03-16 15:36:29 -03002581 if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags)) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002582 atomic_set(&hdev->cmd_cnt, 1);
2583 if (!skb_queue_empty(&hdev->cmd_q))
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002584 queue_work(hdev->workqueue, &hdev->cmd_work);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002585 }
2586}
2587
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002588static void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002589{
2590 struct hci_ev_role_change *ev = (void *) skb->data;
2591 struct hci_conn *conn;
2592
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002593 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002594
2595 hci_dev_lock(hdev);
2596
2597 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2598 if (conn) {
2599 if (!ev->status) {
2600 if (ev->role)
2601 conn->link_mode &= ~HCI_LM_MASTER;
2602 else
2603 conn->link_mode |= HCI_LM_MASTER;
2604 }
2605
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002606 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002607
2608 hci_role_switch_cfm(conn, ev->status, ev->role);
2609 }
2610
2611 hci_dev_unlock(hdev);
2612}
2613
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002614static void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002616 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 int i;
2618
Andrei Emeltchenko32ac5b92011-12-19 16:31:29 +02002619 if (hdev->flow_ctl_mode != HCI_FLOW_CTL_MODE_PACKET_BASED) {
2620 BT_ERR("Wrong event for mode %d", hdev->flow_ctl_mode);
2621 return;
2622 }
2623
Andrei Emeltchenkoc5993de2011-12-30 12:07:47 +02002624 if (skb->len < sizeof(*ev) || skb->len < sizeof(*ev) +
Gustavo Padovan807deac2012-05-17 00:36:24 -03002625 ev->num_hndl * sizeof(struct hci_comp_pkts_info)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626 BT_DBG("%s bad parameters", hdev->name);
2627 return;
2628 }
2629
Andrei Emeltchenkoc5993de2011-12-30 12:07:47 +02002630 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
2631
Andrei Emeltchenko613a1c02011-12-19 16:31:30 +02002632 for (i = 0; i < ev->num_hndl; i++) {
2633 struct hci_comp_pkts_info *info = &ev->handles[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002634 struct hci_conn *conn;
2635 __u16 handle, count;
2636
Andrei Emeltchenko613a1c02011-12-19 16:31:30 +02002637 handle = __le16_to_cpu(info->handle);
2638 count = __le16_to_cpu(info->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639
2640 conn = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenkof4280912011-12-07 15:56:52 +02002641 if (!conn)
2642 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643
Andrei Emeltchenkof4280912011-12-07 15:56:52 +02002644 conn->sent -= count;
2645
2646 switch (conn->type) {
2647 case ACL_LINK:
2648 hdev->acl_cnt += count;
2649 if (hdev->acl_cnt > hdev->acl_pkts)
2650 hdev->acl_cnt = hdev->acl_pkts;
2651 break;
2652
2653 case LE_LINK:
2654 if (hdev->le_pkts) {
2655 hdev->le_cnt += count;
2656 if (hdev->le_cnt > hdev->le_pkts)
2657 hdev->le_cnt = hdev->le_pkts;
2658 } else {
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002659 hdev->acl_cnt += count;
2660 if (hdev->acl_cnt > hdev->acl_pkts)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661 hdev->acl_cnt = hdev->acl_pkts;
2662 }
Andrei Emeltchenkof4280912011-12-07 15:56:52 +02002663 break;
2664
2665 case SCO_LINK:
2666 hdev->sco_cnt += count;
2667 if (hdev->sco_cnt > hdev->sco_pkts)
2668 hdev->sco_cnt = hdev->sco_pkts;
2669 break;
2670
2671 default:
2672 BT_ERR("Unknown type %d conn %p", conn->type, conn);
2673 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674 }
2675 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002676
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -02002677 queue_work(hdev->workqueue, &hdev->tx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678}
2679
Andrei Emeltchenko76ef7cf2012-10-10 17:38:29 +03002680static struct hci_conn *__hci_conn_lookup_handle(struct hci_dev *hdev,
2681 __u16 handle)
2682{
2683 struct hci_chan *chan;
2684
2685 switch (hdev->dev_type) {
2686 case HCI_BREDR:
2687 return hci_conn_hash_lookup_handle(hdev, handle);
2688 case HCI_AMP:
2689 chan = hci_chan_lookup_handle(hdev, handle);
2690 if (chan)
2691 return chan->conn;
2692 break;
2693 default:
2694 BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type);
2695 break;
2696 }
2697
2698 return NULL;
2699}
2700
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002701static void hci_num_comp_blocks_evt(struct hci_dev *hdev, struct sk_buff *skb)
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002702{
2703 struct hci_ev_num_comp_blocks *ev = (void *) skb->data;
2704 int i;
2705
2706 if (hdev->flow_ctl_mode != HCI_FLOW_CTL_MODE_BLOCK_BASED) {
2707 BT_ERR("Wrong event for mode %d", hdev->flow_ctl_mode);
2708 return;
2709 }
2710
2711 if (skb->len < sizeof(*ev) || skb->len < sizeof(*ev) +
Gustavo Padovan807deac2012-05-17 00:36:24 -03002712 ev->num_hndl * sizeof(struct hci_comp_blocks_info)) {
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002713 BT_DBG("%s bad parameters", hdev->name);
2714 return;
2715 }
2716
2717 BT_DBG("%s num_blocks %d num_hndl %d", hdev->name, ev->num_blocks,
Gustavo Padovan807deac2012-05-17 00:36:24 -03002718 ev->num_hndl);
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002719
2720 for (i = 0; i < ev->num_hndl; i++) {
2721 struct hci_comp_blocks_info *info = &ev->handles[i];
Andrei Emeltchenko76ef7cf2012-10-10 17:38:29 +03002722 struct hci_conn *conn = NULL;
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002723 __u16 handle, block_count;
2724
2725 handle = __le16_to_cpu(info->handle);
2726 block_count = __le16_to_cpu(info->blocks);
2727
Andrei Emeltchenko76ef7cf2012-10-10 17:38:29 +03002728 conn = __hci_conn_lookup_handle(hdev, handle);
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002729 if (!conn)
2730 continue;
2731
2732 conn->sent -= block_count;
2733
2734 switch (conn->type) {
2735 case ACL_LINK:
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002736 case AMP_LINK:
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002737 hdev->block_cnt += block_count;
2738 if (hdev->block_cnt > hdev->num_blocks)
2739 hdev->block_cnt = hdev->num_blocks;
2740 break;
2741
2742 default:
2743 BT_ERR("Unknown type %d conn %p", conn->type, conn);
2744 break;
2745 }
2746 }
2747
2748 queue_work(hdev->workqueue, &hdev->tx_work);
2749}
2750
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002751static void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002753 struct hci_ev_mode_change *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002754 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002756 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757
2758 hci_dev_lock(hdev);
2759
Marcel Holtmann04837f62006-07-03 10:02:33 +02002760 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2761 if (conn) {
2762 conn->mode = ev->mode;
2763 conn->interval = __le16_to_cpu(ev->interval);
2764
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03002765 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND,
2766 &conn->flags)) {
Marcel Holtmann04837f62006-07-03 10:02:33 +02002767 if (conn->mode == HCI_CM_ACTIVE)
Johan Hedberg58a681e2012-01-16 06:47:28 +02002768 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002769 else
Johan Hedberg58a681e2012-01-16 06:47:28 +02002770 clear_bit(HCI_CONN_POWER_SAVE, &conn->flags);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002771 }
Marcel Holtmanne73439d2010-07-26 10:06:00 -04002772
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002773 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
Marcel Holtmanne73439d2010-07-26 10:06:00 -04002774 hci_sco_setup(conn, ev->status);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002775 }
2776
2777 hci_dev_unlock(hdev);
2778}
2779
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002780static void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002782 struct hci_ev_pin_code_req *ev = (void *) skb->data;
2783 struct hci_conn *conn;
2784
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002785 BT_DBG("%s", hdev->name);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002786
2787 hci_dev_lock(hdev);
2788
2789 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Waldemar Rymarkiewiczb6f98042011-09-23 10:01:30 +02002790 if (!conn)
2791 goto unlock;
2792
2793 if (conn->state == BT_CONNECTED) {
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002794 hci_conn_hold(conn);
2795 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
2796 hci_conn_put(conn);
2797 }
2798
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02002799 if (!test_bit(HCI_PAIRABLE, &hdev->dev_flags))
Johan Hedberg03b555e2011-01-04 15:40:05 +02002800 hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
Gustavo Padovan807deac2012-05-17 00:36:24 -03002801 sizeof(ev->bdaddr), &ev->bdaddr);
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02002802 else if (test_bit(HCI_MGMT, &hdev->dev_flags)) {
Waldemar Rymarkiewicza770bb52011-04-28 12:07:59 +02002803 u8 secure;
2804
2805 if (conn->pending_sec_level == BT_SECURITY_HIGH)
2806 secure = 1;
2807 else
2808 secure = 0;
2809
Johan Hedberg744cf192011-11-08 20:40:14 +02002810 mgmt_pin_code_request(hdev, &ev->bdaddr, secure);
Waldemar Rymarkiewicza770bb52011-04-28 12:07:59 +02002811 }
Johan Hedberg980e1a52011-01-22 06:10:07 +02002812
Waldemar Rymarkiewiczb6f98042011-09-23 10:01:30 +02002813unlock:
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002814 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815}
2816
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002817static void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818{
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002819 struct hci_ev_link_key_req *ev = (void *) skb->data;
2820 struct hci_cp_link_key_reply cp;
2821 struct hci_conn *conn;
2822 struct link_key *key;
2823
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002824 BT_DBG("%s", hdev->name);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002825
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02002826 if (!test_bit(HCI_LINK_KEYS, &hdev->dev_flags))
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002827 return;
2828
2829 hci_dev_lock(hdev);
2830
2831 key = hci_find_link_key(hdev, &ev->bdaddr);
2832 if (!key) {
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03002833 BT_DBG("%s link key not found for %pMR", hdev->name,
2834 &ev->bdaddr);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002835 goto not_found;
2836 }
2837
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03002838 BT_DBG("%s found key type %u for %pMR", hdev->name, key->type,
2839 &ev->bdaddr);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002840
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02002841 if (!test_bit(HCI_DEBUG_KEYS, &hdev->dev_flags) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03002842 key->type == HCI_LK_DEBUG_COMBINATION) {
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002843 BT_DBG("%s ignoring debug key", hdev->name);
2844 goto not_found;
2845 }
2846
2847 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002848 if (conn) {
2849 if (key->type == HCI_LK_UNAUTH_COMBINATION &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03002850 conn->auth_type != 0xff && (conn->auth_type & 0x01)) {
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002851 BT_DBG("%s ignoring unauthenticated key", hdev->name);
2852 goto not_found;
2853 }
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002854
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002855 if (key->type == HCI_LK_COMBINATION && key->pin_len < 16 &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03002856 conn->pending_sec_level == BT_SECURITY_HIGH) {
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03002857 BT_DBG("%s ignoring key unauthenticated for high security",
2858 hdev->name);
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002859 goto not_found;
2860 }
2861
2862 conn->key_type = key->type;
2863 conn->pin_length = key->pin_len;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002864 }
2865
2866 bacpy(&cp.bdaddr, &ev->bdaddr);
Andrei Emeltchenko9b3b4462012-05-23 11:31:20 +03002867 memcpy(cp.link_key, key->val, HCI_LINK_KEY_SIZE);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002868
2869 hci_send_cmd(hdev, HCI_OP_LINK_KEY_REPLY, sizeof(cp), &cp);
2870
2871 hci_dev_unlock(hdev);
2872
2873 return;
2874
2875not_found:
2876 hci_send_cmd(hdev, HCI_OP_LINK_KEY_NEG_REPLY, 6, &ev->bdaddr);
2877 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878}
2879
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002880static void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002882 struct hci_ev_link_key_notify *ev = (void *) skb->data;
2883 struct hci_conn *conn;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002884 u8 pin_len = 0;
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002885
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002886 BT_DBG("%s", hdev->name);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002887
2888 hci_dev_lock(hdev);
2889
2890 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2891 if (conn) {
2892 hci_conn_hold(conn);
2893 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Johan Hedberg980e1a52011-01-22 06:10:07 +02002894 pin_len = conn->pin_length;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02002895
2896 if (ev->key_type != HCI_LK_CHANGED_COMBINATION)
2897 conn->key_type = ev->key_type;
2898
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002899 hci_conn_put(conn);
2900 }
2901
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02002902 if (test_bit(HCI_LINK_KEYS, &hdev->dev_flags))
Johan Hedbergd25e28a2011-04-28 11:28:59 -07002903 hci_add_link_key(hdev, conn, 1, &ev->bdaddr, ev->link_key,
Gustavo Padovan807deac2012-05-17 00:36:24 -03002904 ev->key_type, pin_len);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002905
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002906 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907}
2908
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002909static void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmann04837f62006-07-03 10:02:33 +02002910{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002911 struct hci_ev_clock_offset *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002912 struct hci_conn *conn;
2913
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002914 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002915
2916 hci_dev_lock(hdev);
2917
2918 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919 if (conn && !ev->status) {
2920 struct inquiry_entry *ie;
2921
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002922 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2923 if (ie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 ie->data.clock_offset = ev->clock_offset;
2925 ie->timestamp = jiffies;
2926 }
2927 }
2928
2929 hci_dev_unlock(hdev);
2930}
2931
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002932static void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna8746412008-07-14 20:13:46 +02002933{
2934 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
2935 struct hci_conn *conn;
2936
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002937 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna8746412008-07-14 20:13:46 +02002938
2939 hci_dev_lock(hdev);
2940
2941 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2942 if (conn && !ev->status)
2943 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
2944
2945 hci_dev_unlock(hdev);
2946}
2947
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002948static void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002949{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002950 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002951 struct inquiry_entry *ie;
2952
2953 BT_DBG("%s", hdev->name);
2954
2955 hci_dev_lock(hdev);
2956
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002957 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
2958 if (ie) {
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002959 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
2960 ie->timestamp = jiffies;
2961 }
2962
2963 hci_dev_unlock(hdev);
2964}
2965
Gustavo Padovan6039aa732012-05-23 04:04:18 -03002966static void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev,
2967 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002968{
2969 struct inquiry_data data;
2970 int num_rsp = *((__u8 *) skb->data);
Johan Hedberg388fc8f2012-02-23 00:38:59 +02002971 bool name_known, ssp;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002972
2973 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
2974
2975 if (!num_rsp)
2976 return;
2977
Andre Guedes1519cc12012-03-21 00:03:38 -03002978 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
2979 return;
2980
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002981 hci_dev_lock(hdev);
2982
2983 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
Szymon Janc138d22e2011-02-17 16:44:23 +01002984 struct inquiry_info_with_rssi_and_pscan_mode *info;
2985 info = (void *) (skb->data + 1);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002986
Johan Hedberge17acd42011-03-30 23:57:16 +03002987 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002988 bacpy(&data.bdaddr, &info->bdaddr);
2989 data.pscan_rep_mode = info->pscan_rep_mode;
2990 data.pscan_period_mode = info->pscan_period_mode;
2991 data.pscan_mode = info->pscan_mode;
2992 memcpy(data.dev_class, info->dev_class, 3);
2993 data.clock_offset = info->clock_offset;
2994 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002995 data.ssp_mode = 0x00;
Johan Hedberg31754052012-01-04 13:39:52 +02002996
2997 name_known = hci_inquiry_cache_update(hdev, &data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002998 false, &ssp);
Johan Hedberg48264f02011-11-09 13:58:58 +02002999 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003000 info->dev_class, info->rssi,
3001 !name_known, ssp, NULL, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003002 }
3003 } else {
3004 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
3005
Johan Hedberge17acd42011-03-30 23:57:16 +03003006 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003007 bacpy(&data.bdaddr, &info->bdaddr);
3008 data.pscan_rep_mode = info->pscan_rep_mode;
3009 data.pscan_period_mode = info->pscan_period_mode;
3010 data.pscan_mode = 0x00;
3011 memcpy(data.dev_class, info->dev_class, 3);
3012 data.clock_offset = info->clock_offset;
3013 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02003014 data.ssp_mode = 0x00;
Johan Hedberg31754052012-01-04 13:39:52 +02003015 name_known = hci_inquiry_cache_update(hdev, &data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003016 false, &ssp);
Johan Hedberg48264f02011-11-09 13:58:58 +02003017 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003018 info->dev_class, info->rssi,
3019 !name_known, ssp, NULL, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003020 }
3021 }
3022
3023 hci_dev_unlock(hdev);
3024}
3025
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003026static void hci_remote_ext_features_evt(struct hci_dev *hdev,
3027 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003028{
Marcel Holtmann41a96212008-07-14 20:13:48 +02003029 struct hci_ev_remote_ext_features *ev = (void *) skb->data;
3030 struct hci_conn *conn;
3031
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003032 BT_DBG("%s", hdev->name);
Marcel Holtmann41a96212008-07-14 20:13:48 +02003033
Marcel Holtmann41a96212008-07-14 20:13:48 +02003034 hci_dev_lock(hdev);
3035
3036 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergccd556f2010-11-10 17:11:51 +02003037 if (!conn)
3038 goto unlock;
Marcel Holtmann41a96212008-07-14 20:13:48 +02003039
Johan Hedbergccd556f2010-11-10 17:11:51 +02003040 if (!ev->status && ev->page == 0x01) {
3041 struct inquiry_entry *ie;
Marcel Holtmann41a96212008-07-14 20:13:48 +02003042
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02003043 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
3044 if (ie)
Johan Hedberg02b7cc62012-02-28 02:28:43 +02003045 ie->data.ssp_mode = (ev->features[0] & LMP_HOST_SSP);
Marcel Holtmann769be972008-07-14 20:13:49 +02003046
Johan Hedberg02b7cc62012-02-28 02:28:43 +02003047 if (ev->features[0] & LMP_HOST_SSP)
Johan Hedberg58a681e2012-01-16 06:47:28 +02003048 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
Marcel Holtmann41a96212008-07-14 20:13:48 +02003049 }
3050
Johan Hedbergccd556f2010-11-10 17:11:51 +02003051 if (conn->state != BT_CONFIG)
3052 goto unlock;
3053
Johan Hedberg671267b2012-05-12 16:11:50 -03003054 if (!ev->status && !test_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02003055 struct hci_cp_remote_name_req cp;
3056 memset(&cp, 0, sizeof(cp));
3057 bacpy(&cp.bdaddr, &conn->dst);
3058 cp.pscan_rep_mode = 0x02;
3059 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
Johan Hedbergb644ba32012-01-17 21:48:47 +02003060 } else if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
3061 mgmt_device_connected(hdev, &conn->dst, conn->type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003062 conn->dst_type, 0, NULL, 0,
3063 conn->dev_class);
Johan Hedberg392599b2010-11-18 22:22:28 +02003064
Johan Hedberg127178d2010-11-18 22:22:29 +02003065 if (!hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedbergccd556f2010-11-10 17:11:51 +02003066 conn->state = BT_CONNECTED;
3067 hci_proto_connect_cfm(conn, ev->status);
3068 hci_conn_put(conn);
3069 }
3070
3071unlock:
Marcel Holtmann41a96212008-07-14 20:13:48 +02003072 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003073}
3074
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003075static void hci_sync_conn_complete_evt(struct hci_dev *hdev,
3076 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003077{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02003078 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
3079 struct hci_conn *conn;
3080
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03003081 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02003082
3083 hci_dev_lock(hdev);
3084
3085 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann9dc0a3a2008-07-14 20:13:46 +02003086 if (!conn) {
3087 if (ev->link_type == ESCO_LINK)
3088 goto unlock;
3089
3090 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
3091 if (!conn)
3092 goto unlock;
3093
3094 conn->type = SCO_LINK;
3095 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02003096
Marcel Holtmann732547f2009-04-19 19:14:14 +02003097 switch (ev->status) {
3098 case 0x00:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02003099 conn->handle = __le16_to_cpu(ev->handle);
3100 conn->state = BT_CONNECTED;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02003101
Marcel Holtmann9eba32b2009-08-22 14:19:26 -07003102 hci_conn_hold_device(conn);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02003103 hci_conn_add_sysfs(conn);
Marcel Holtmann732547f2009-04-19 19:14:14 +02003104 break;
3105
Stephen Coe705e5712010-02-16 11:29:44 -05003106 case 0x11: /* Unsupported Feature or Parameter Value */
Marcel Holtmann732547f2009-04-19 19:14:14 +02003107 case 0x1c: /* SCO interval rejected */
Nick Pelly1038a002010-02-03 11:42:26 -08003108 case 0x1a: /* Unsupported Remote Feature */
Marcel Holtmann732547f2009-04-19 19:14:14 +02003109 case 0x1f: /* Unspecified error */
3110 if (conn->out && conn->attempt < 2) {
3111 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
3112 (hdev->esco_type & EDR_ESCO_MASK);
3113 hci_setup_sync(conn, conn->link->handle);
3114 goto unlock;
3115 }
3116 /* fall through */
3117
3118 default:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02003119 conn->state = BT_CLOSED;
Marcel Holtmann732547f2009-04-19 19:14:14 +02003120 break;
3121 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02003122
3123 hci_proto_connect_cfm(conn, ev->status);
3124 if (ev->status)
3125 hci_conn_del(conn);
3126
3127unlock:
3128 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003129}
3130
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003131static void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003132{
3133 BT_DBG("%s", hdev->name);
3134}
3135
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003136static void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmann04837f62006-07-03 10:02:33 +02003137{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003138 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02003139
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03003140 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmann04837f62006-07-03 10:02:33 +02003141}
3142
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003143static void hci_extended_inquiry_result_evt(struct hci_dev *hdev,
3144 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003145{
3146 struct inquiry_data data;
3147 struct extended_inquiry_info *info = (void *) (skb->data + 1);
3148 int num_rsp = *((__u8 *) skb->data);
Vishal Agarwal9d939d92012-04-26 19:19:56 +05303149 size_t eir_len;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003150
3151 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
3152
3153 if (!num_rsp)
3154 return;
3155
Andre Guedes1519cc12012-03-21 00:03:38 -03003156 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
3157 return;
3158
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003159 hci_dev_lock(hdev);
3160
Johan Hedberge17acd42011-03-30 23:57:16 +03003161 for (; num_rsp; num_rsp--, info++) {
Johan Hedberg388fc8f2012-02-23 00:38:59 +02003162 bool name_known, ssp;
Johan Hedberg561aafb2012-01-04 13:31:59 +02003163
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003164 bacpy(&data.bdaddr, &info->bdaddr);
Szymon Janc138d22e2011-02-17 16:44:23 +01003165 data.pscan_rep_mode = info->pscan_rep_mode;
3166 data.pscan_period_mode = info->pscan_period_mode;
3167 data.pscan_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003168 memcpy(data.dev_class, info->dev_class, 3);
Szymon Janc138d22e2011-02-17 16:44:23 +01003169 data.clock_offset = info->clock_offset;
3170 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02003171 data.ssp_mode = 0x01;
Johan Hedberg561aafb2012-01-04 13:31:59 +02003172
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003173 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg4ddb1932012-01-15 20:04:43 +02003174 name_known = eir_has_data_type(info->data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003175 sizeof(info->data),
3176 EIR_NAME_COMPLETE);
Johan Hedberg561aafb2012-01-04 13:31:59 +02003177 else
3178 name_known = true;
3179
Johan Hedberg388fc8f2012-02-23 00:38:59 +02003180 name_known = hci_inquiry_cache_update(hdev, &data, name_known,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003181 &ssp);
Vishal Agarwal9d939d92012-04-26 19:19:56 +05303182 eir_len = eir_get_length(info->data, sizeof(info->data));
Johan Hedberg48264f02011-11-09 13:58:58 +02003183 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003184 info->dev_class, info->rssi, !name_known,
Vishal Agarwal9d939d92012-04-26 19:19:56 +05303185 ssp, info->data, eir_len);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003186 }
3187
3188 hci_dev_unlock(hdev);
3189}
3190
Johan Hedberg1c2e0042012-06-08 23:31:13 +08003191static void hci_key_refresh_complete_evt(struct hci_dev *hdev,
3192 struct sk_buff *skb)
3193{
3194 struct hci_ev_key_refresh_complete *ev = (void *) skb->data;
3195 struct hci_conn *conn;
3196
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03003197 BT_DBG("%s status 0x%2.2x handle 0x%4.4x", hdev->name, ev->status,
Johan Hedberg1c2e0042012-06-08 23:31:13 +08003198 __le16_to_cpu(ev->handle));
3199
3200 hci_dev_lock(hdev);
3201
3202 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3203 if (!conn)
3204 goto unlock;
3205
3206 if (!ev->status)
3207 conn->sec_level = conn->pending_sec_level;
3208
3209 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
3210
3211 if (ev->status && conn->state == BT_CONNECTED) {
3212 hci_acl_disconn(conn, HCI_ERROR_AUTH_FAILURE);
3213 hci_conn_put(conn);
3214 goto unlock;
3215 }
3216
3217 if (conn->state == BT_CONFIG) {
3218 if (!ev->status)
3219 conn->state = BT_CONNECTED;
3220
3221 hci_proto_connect_cfm(conn, ev->status);
3222 hci_conn_put(conn);
3223 } else {
3224 hci_auth_cfm(conn, ev->status);
3225
3226 hci_conn_hold(conn);
3227 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
3228 hci_conn_put(conn);
3229 }
3230
3231unlock:
3232 hci_dev_unlock(hdev);
3233}
3234
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003235static u8 hci_get_auth_req(struct hci_conn *conn)
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003236{
3237 /* If remote requests dedicated bonding follow that lead */
3238 if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) {
3239 /* If both remote and local IO capabilities allow MITM
3240 * protection then require it, otherwise don't */
3241 if (conn->remote_cap == 0x03 || conn->io_capability == 0x03)
3242 return 0x02;
3243 else
3244 return 0x03;
3245 }
3246
3247 /* If remote requests no-bonding follow that lead */
3248 if (conn->remote_auth == 0x00 || conn->remote_auth == 0x01)
Waldemar Rymarkiewicz58797bf2011-04-28 12:07:58 +02003249 return conn->remote_auth | (conn->auth_type & 0x01);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003250
3251 return conn->auth_type;
3252}
3253
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003254static void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmann04936842008-07-14 20:13:48 +02003255{
3256 struct hci_ev_io_capa_request *ev = (void *) skb->data;
3257 struct hci_conn *conn;
3258
3259 BT_DBG("%s", hdev->name);
3260
3261 hci_dev_lock(hdev);
3262
3263 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg03b555e2011-01-04 15:40:05 +02003264 if (!conn)
3265 goto unlock;
Marcel Holtmann04936842008-07-14 20:13:48 +02003266
Johan Hedberg03b555e2011-01-04 15:40:05 +02003267 hci_conn_hold(conn);
3268
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003269 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg03b555e2011-01-04 15:40:05 +02003270 goto unlock;
3271
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003272 if (test_bit(HCI_PAIRABLE, &hdev->dev_flags) ||
Gustavo Padovan807deac2012-05-17 00:36:24 -03003273 (conn->remote_auth & ~0x01) == HCI_AT_NO_BONDING) {
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003274 struct hci_cp_io_capability_reply cp;
3275
3276 bacpy(&cp.bdaddr, &ev->bdaddr);
Hemant Gupta7a7f1e72012-01-16 13:34:29 +05303277 /* Change the IO capability from KeyboardDisplay
3278 * to DisplayYesNo as it is not supported by BT spec. */
3279 cp.capability = (conn->io_capability == 0x04) ?
3280 0x01 : conn->io_capability;
Johan Hedberg7cbc9bd2011-04-28 11:29:04 -07003281 conn->auth_type = hci_get_auth_req(conn);
3282 cp.authentication = conn->auth_type;
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003283
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03003284 if (hci_find_remote_oob_data(hdev, &conn->dst) &&
3285 (conn->out || test_bit(HCI_CONN_REMOTE_OOB, &conn->flags)))
Szymon Jancce85ee12011-03-22 13:12:23 +01003286 cp.oob_data = 0x01;
3287 else
3288 cp.oob_data = 0x00;
3289
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003290 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_REPLY,
Gustavo Padovan807deac2012-05-17 00:36:24 -03003291 sizeof(cp), &cp);
Johan Hedberg03b555e2011-01-04 15:40:05 +02003292 } else {
3293 struct hci_cp_io_capability_neg_reply cp;
3294
3295 bacpy(&cp.bdaddr, &ev->bdaddr);
Andrei Emeltchenko9f5a0d72011-11-07 14:20:25 +02003296 cp.reason = HCI_ERROR_PAIRING_NOT_ALLOWED;
Johan Hedberg03b555e2011-01-04 15:40:05 +02003297
3298 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_NEG_REPLY,
Gustavo Padovan807deac2012-05-17 00:36:24 -03003299 sizeof(cp), &cp);
Johan Hedberg03b555e2011-01-04 15:40:05 +02003300 }
3301
3302unlock:
3303 hci_dev_unlock(hdev);
3304}
3305
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003306static void hci_io_capa_reply_evt(struct hci_dev *hdev, struct sk_buff *skb)
Johan Hedberg03b555e2011-01-04 15:40:05 +02003307{
3308 struct hci_ev_io_capa_reply *ev = (void *) skb->data;
3309 struct hci_conn *conn;
3310
3311 BT_DBG("%s", hdev->name);
3312
3313 hci_dev_lock(hdev);
3314
3315 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3316 if (!conn)
3317 goto unlock;
3318
Johan Hedberg03b555e2011-01-04 15:40:05 +02003319 conn->remote_cap = ev->capability;
Johan Hedberg03b555e2011-01-04 15:40:05 +02003320 conn->remote_auth = ev->authentication;
Johan Hedberg58a681e2012-01-16 06:47:28 +02003321 if (ev->oob_data)
3322 set_bit(HCI_CONN_REMOTE_OOB, &conn->flags);
Johan Hedberg03b555e2011-01-04 15:40:05 +02003323
3324unlock:
Marcel Holtmann04936842008-07-14 20:13:48 +02003325 hci_dev_unlock(hdev);
3326}
3327
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003328static void hci_user_confirm_request_evt(struct hci_dev *hdev,
3329 struct sk_buff *skb)
Johan Hedberga5c29682011-02-19 12:05:57 -03003330{
3331 struct hci_ev_user_confirm_req *ev = (void *) skb->data;
Johan Hedberg55bc1a32011-04-28 11:28:56 -07003332 int loc_mitm, rem_mitm, confirm_hint = 0;
Johan Hedberg7a828902011-04-28 11:28:53 -07003333 struct hci_conn *conn;
Johan Hedberga5c29682011-02-19 12:05:57 -03003334
3335 BT_DBG("%s", hdev->name);
3336
3337 hci_dev_lock(hdev);
3338
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003339 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg7a828902011-04-28 11:28:53 -07003340 goto unlock;
Johan Hedberga5c29682011-02-19 12:05:57 -03003341
Johan Hedberg7a828902011-04-28 11:28:53 -07003342 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3343 if (!conn)
3344 goto unlock;
3345
3346 loc_mitm = (conn->auth_type & 0x01);
3347 rem_mitm = (conn->remote_auth & 0x01);
3348
3349 /* If we require MITM but the remote device can't provide that
3350 * (it has NoInputNoOutput) then reject the confirmation
3351 * request. The only exception is when we're dedicated bonding
3352 * initiators (connect_cfm_cb set) since then we always have the MITM
3353 * bit set. */
3354 if (!conn->connect_cfm_cb && loc_mitm && conn->remote_cap == 0x03) {
3355 BT_DBG("Rejecting request: remote device can't provide MITM");
3356 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_NEG_REPLY,
Gustavo Padovan807deac2012-05-17 00:36:24 -03003357 sizeof(ev->bdaddr), &ev->bdaddr);
Johan Hedberg7a828902011-04-28 11:28:53 -07003358 goto unlock;
3359 }
3360
3361 /* If no side requires MITM protection; auto-accept */
3362 if ((!loc_mitm || conn->remote_cap == 0x03) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03003363 (!rem_mitm || conn->io_capability == 0x03)) {
Johan Hedberg55bc1a32011-04-28 11:28:56 -07003364
3365 /* If we're not the initiators request authorization to
3366 * proceed from user space (mgmt_user_confirm with
3367 * confirm_hint set to 1). */
Johan Hedberg51a8efd2012-01-16 06:10:31 +02003368 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Johan Hedberg55bc1a32011-04-28 11:28:56 -07003369 BT_DBG("Confirming auto-accept as acceptor");
3370 confirm_hint = 1;
3371 goto confirm;
3372 }
3373
Johan Hedberg9f616562011-04-28 11:28:54 -07003374 BT_DBG("Auto-accept of user confirmation with %ums delay",
Gustavo Padovan807deac2012-05-17 00:36:24 -03003375 hdev->auto_accept_delay);
Johan Hedberg9f616562011-04-28 11:28:54 -07003376
3377 if (hdev->auto_accept_delay > 0) {
3378 int delay = msecs_to_jiffies(hdev->auto_accept_delay);
3379 mod_timer(&conn->auto_accept_timer, jiffies + delay);
3380 goto unlock;
3381 }
3382
Johan Hedberg7a828902011-04-28 11:28:53 -07003383 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY,
Gustavo Padovan807deac2012-05-17 00:36:24 -03003384 sizeof(ev->bdaddr), &ev->bdaddr);
Johan Hedberg7a828902011-04-28 11:28:53 -07003385 goto unlock;
3386 }
3387
Johan Hedberg55bc1a32011-04-28 11:28:56 -07003388confirm:
Johan Hedberg272d90d2012-02-09 15:26:12 +02003389 mgmt_user_confirm_request(hdev, &ev->bdaddr, ACL_LINK, 0, ev->passkey,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003390 confirm_hint);
Johan Hedberg7a828902011-04-28 11:28:53 -07003391
3392unlock:
Johan Hedberga5c29682011-02-19 12:05:57 -03003393 hci_dev_unlock(hdev);
3394}
3395
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003396static void hci_user_passkey_request_evt(struct hci_dev *hdev,
3397 struct sk_buff *skb)
Brian Gix1143d452011-11-23 08:28:34 -08003398{
3399 struct hci_ev_user_passkey_req *ev = (void *) skb->data;
3400
3401 BT_DBG("%s", hdev->name);
3402
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003403 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg272d90d2012-02-09 15:26:12 +02003404 mgmt_user_passkey_request(hdev, &ev->bdaddr, ACL_LINK, 0);
Brian Gix1143d452011-11-23 08:28:34 -08003405}
3406
Johan Hedberg92a25252012-09-06 18:39:26 +03003407static void hci_user_passkey_notify_evt(struct hci_dev *hdev,
3408 struct sk_buff *skb)
3409{
3410 struct hci_ev_user_passkey_notify *ev = (void *) skb->data;
3411 struct hci_conn *conn;
3412
3413 BT_DBG("%s", hdev->name);
3414
3415 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3416 if (!conn)
3417 return;
3418
3419 conn->passkey_notify = __le32_to_cpu(ev->passkey);
3420 conn->passkey_entered = 0;
3421
3422 if (test_bit(HCI_MGMT, &hdev->dev_flags))
3423 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
3424 conn->dst_type, conn->passkey_notify,
3425 conn->passkey_entered);
3426}
3427
3428static void hci_keypress_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
3429{
3430 struct hci_ev_keypress_notify *ev = (void *) skb->data;
3431 struct hci_conn *conn;
3432
3433 BT_DBG("%s", hdev->name);
3434
3435 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3436 if (!conn)
3437 return;
3438
3439 switch (ev->type) {
3440 case HCI_KEYPRESS_STARTED:
3441 conn->passkey_entered = 0;
3442 return;
3443
3444 case HCI_KEYPRESS_ENTERED:
3445 conn->passkey_entered++;
3446 break;
3447
3448 case HCI_KEYPRESS_ERASED:
3449 conn->passkey_entered--;
3450 break;
3451
3452 case HCI_KEYPRESS_CLEARED:
3453 conn->passkey_entered = 0;
3454 break;
3455
3456 case HCI_KEYPRESS_COMPLETED:
3457 return;
3458 }
3459
3460 if (test_bit(HCI_MGMT, &hdev->dev_flags))
3461 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
3462 conn->dst_type, conn->passkey_notify,
3463 conn->passkey_entered);
3464}
3465
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003466static void hci_simple_pair_complete_evt(struct hci_dev *hdev,
3467 struct sk_buff *skb)
Marcel Holtmann04936842008-07-14 20:13:48 +02003468{
3469 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
3470 struct hci_conn *conn;
3471
3472 BT_DBG("%s", hdev->name);
3473
3474 hci_dev_lock(hdev);
3475
3476 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg2a611692011-02-19 12:06:00 -03003477 if (!conn)
3478 goto unlock;
Marcel Holtmann04936842008-07-14 20:13:48 +02003479
Johan Hedberg2a611692011-02-19 12:06:00 -03003480 /* To avoid duplicate auth_failed events to user space we check
3481 * the HCI_CONN_AUTH_PEND flag which will be set if we
3482 * initiated the authentication. A traditional auth_complete
3483 * event gets always produced as initiator and is also mapped to
3484 * the mgmt_auth_failed event */
Mikel Astizfa1bd912012-08-09 09:52:29 +02003485 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags) && ev->status)
Johan Hedbergbab73cb2012-02-09 16:07:29 +02003486 mgmt_auth_failed(hdev, &conn->dst, conn->type, conn->dst_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003487 ev->status);
Johan Hedberg2a611692011-02-19 12:06:00 -03003488
3489 hci_conn_put(conn);
3490
3491unlock:
Marcel Holtmann04936842008-07-14 20:13:48 +02003492 hci_dev_unlock(hdev);
3493}
3494
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003495static void hci_remote_host_features_evt(struct hci_dev *hdev,
3496 struct sk_buff *skb)
Marcel Holtmann41a96212008-07-14 20:13:48 +02003497{
3498 struct hci_ev_remote_host_features *ev = (void *) skb->data;
3499 struct inquiry_entry *ie;
3500
3501 BT_DBG("%s", hdev->name);
3502
3503 hci_dev_lock(hdev);
3504
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02003505 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
3506 if (ie)
Johan Hedberg02b7cc62012-02-28 02:28:43 +02003507 ie->data.ssp_mode = (ev->features[0] & LMP_HOST_SSP);
Marcel Holtmann41a96212008-07-14 20:13:48 +02003508
3509 hci_dev_unlock(hdev);
3510}
3511
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003512static void hci_remote_oob_data_request_evt(struct hci_dev *hdev,
3513 struct sk_buff *skb)
Szymon Janc2763eda2011-03-22 13:12:22 +01003514{
3515 struct hci_ev_remote_oob_data_request *ev = (void *) skb->data;
3516 struct oob_data *data;
3517
3518 BT_DBG("%s", hdev->name);
3519
3520 hci_dev_lock(hdev);
3521
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003522 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
Szymon Jance1ba1f12011-04-06 13:01:59 +02003523 goto unlock;
3524
Szymon Janc2763eda2011-03-22 13:12:22 +01003525 data = hci_find_remote_oob_data(hdev, &ev->bdaddr);
3526 if (data) {
3527 struct hci_cp_remote_oob_data_reply cp;
3528
3529 bacpy(&cp.bdaddr, &ev->bdaddr);
3530 memcpy(cp.hash, data->hash, sizeof(cp.hash));
3531 memcpy(cp.randomizer, data->randomizer, sizeof(cp.randomizer));
3532
3533 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_REPLY, sizeof(cp),
Gustavo Padovan807deac2012-05-17 00:36:24 -03003534 &cp);
Szymon Janc2763eda2011-03-22 13:12:22 +01003535 } else {
3536 struct hci_cp_remote_oob_data_neg_reply cp;
3537
3538 bacpy(&cp.bdaddr, &ev->bdaddr);
3539 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_NEG_REPLY, sizeof(cp),
Gustavo Padovan807deac2012-05-17 00:36:24 -03003540 &cp);
Szymon Janc2763eda2011-03-22 13:12:22 +01003541 }
3542
Szymon Jance1ba1f12011-04-06 13:01:59 +02003543unlock:
Szymon Janc2763eda2011-03-22 13:12:22 +01003544 hci_dev_unlock(hdev);
3545}
3546
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003547static void hci_le_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Ville Tervofcd89c02011-02-10 22:38:47 -03003548{
3549 struct hci_ev_le_conn_complete *ev = (void *) skb->data;
3550 struct hci_conn *conn;
3551
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03003552 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Ville Tervofcd89c02011-02-10 22:38:47 -03003553
3554 hci_dev_lock(hdev);
3555
Andre Guedesb47a09b2012-07-27 15:10:15 -03003556 conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
Ville Tervob62f3282011-02-10 22:38:50 -03003557 if (!conn) {
3558 conn = hci_conn_add(hdev, LE_LINK, &ev->bdaddr);
3559 if (!conn) {
3560 BT_ERR("No memory for new connection");
Andre Guedes230fd162012-07-27 15:10:10 -03003561 goto unlock;
Ville Tervob62f3282011-02-10 22:38:50 -03003562 }
Andre Guedes29b79882011-05-31 14:20:54 -03003563
3564 conn->dst_type = ev->bdaddr_type;
Andre Guedesb9b343d2012-07-27 15:10:11 -03003565
3566 if (ev->role == LE_CONN_ROLE_MASTER) {
3567 conn->out = true;
3568 conn->link_mode |= HCI_LM_MASTER;
3569 }
Ville Tervob62f3282011-02-10 22:38:50 -03003570 }
Ville Tervofcd89c02011-02-10 22:38:47 -03003571
Andre Guedescd17dec2012-07-27 15:10:16 -03003572 if (ev->status) {
3573 mgmt_connect_failed(hdev, &conn->dst, conn->type,
3574 conn->dst_type, ev->status);
3575 hci_proto_connect_cfm(conn, ev->status);
3576 conn->state = BT_CLOSED;
3577 hci_conn_del(conn);
3578 goto unlock;
3579 }
3580
Johan Hedbergb644ba32012-01-17 21:48:47 +02003581 if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
3582 mgmt_device_connected(hdev, &ev->bdaddr, conn->type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003583 conn->dst_type, 0, NULL, 0, NULL);
Vinicius Costa Gomes83bc71b2011-05-06 18:41:43 -03003584
Vinicius Costa Gomes7b5c0d52011-06-09 18:50:50 -03003585 conn->sec_level = BT_SECURITY_LOW;
Ville Tervofcd89c02011-02-10 22:38:47 -03003586 conn->handle = __le16_to_cpu(ev->handle);
3587 conn->state = BT_CONNECTED;
3588
3589 hci_conn_hold_device(conn);
3590 hci_conn_add_sysfs(conn);
3591
3592 hci_proto_connect_cfm(conn, ev->status);
3593
3594unlock:
3595 hci_dev_unlock(hdev);
3596}
3597
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003598static void hci_le_adv_report_evt(struct hci_dev *hdev, struct sk_buff *skb)
Andre Guedes9aa04c92011-05-26 16:23:51 -03003599{
Andre Guedese95beb42011-09-26 20:48:35 -03003600 u8 num_reports = skb->data[0];
3601 void *ptr = &skb->data[1];
Andre Guedes3c9e9192012-01-10 18:20:50 -03003602 s8 rssi;
Andre Guedes9aa04c92011-05-26 16:23:51 -03003603
3604 hci_dev_lock(hdev);
3605
Andre Guedese95beb42011-09-26 20:48:35 -03003606 while (num_reports--) {
3607 struct hci_ev_le_advertising_info *ev = ptr;
Andre Guedes9aa04c92011-05-26 16:23:51 -03003608
Andre Guedes3c9e9192012-01-10 18:20:50 -03003609 rssi = ev->data[ev->length];
3610 mgmt_device_found(hdev, &ev->bdaddr, LE_LINK, ev->bdaddr_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003611 NULL, rssi, 0, 1, ev->data, ev->length);
Andre Guedes3c9e9192012-01-10 18:20:50 -03003612
Andre Guedese95beb42011-09-26 20:48:35 -03003613 ptr += sizeof(*ev) + ev->length + 1;
Andre Guedes9aa04c92011-05-26 16:23:51 -03003614 }
3615
3616 hci_dev_unlock(hdev);
3617}
3618
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003619static void hci_le_ltk_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003620{
3621 struct hci_ev_le_ltk_req *ev = (void *) skb->data;
3622 struct hci_cp_le_ltk_reply cp;
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03003623 struct hci_cp_le_ltk_neg_reply neg;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003624 struct hci_conn *conn;
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03003625 struct smp_ltk *ltk;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003626
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03003627 BT_DBG("%s handle 0x%4.4x", hdev->name, __le16_to_cpu(ev->handle));
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003628
3629 hci_dev_lock(hdev);
3630
3631 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03003632 if (conn == NULL)
3633 goto not_found;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003634
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03003635 ltk = hci_find_ltk(hdev, ev->ediv, ev->random);
3636 if (ltk == NULL)
3637 goto not_found;
3638
3639 memcpy(cp.ltk, ltk->val, sizeof(ltk->val));
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003640 cp.handle = cpu_to_le16(conn->handle);
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03003641
3642 if (ltk->authenticated)
3643 conn->sec_level = BT_SECURITY_HIGH;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003644
3645 hci_send_cmd(hdev, HCI_OP_LE_LTK_REPLY, sizeof(cp), &cp);
3646
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03003647 if (ltk->type & HCI_SMP_STK) {
3648 list_del(&ltk->list);
3649 kfree(ltk);
3650 }
3651
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003652 hci_dev_unlock(hdev);
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03003653
3654 return;
3655
3656not_found:
3657 neg.handle = ev->handle;
3658 hci_send_cmd(hdev, HCI_OP_LE_LTK_NEG_REPLY, sizeof(neg), &neg);
3659 hci_dev_unlock(hdev);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003660}
3661
Gustavo Padovan6039aa732012-05-23 04:04:18 -03003662static void hci_le_meta_evt(struct hci_dev *hdev, struct sk_buff *skb)
Ville Tervofcd89c02011-02-10 22:38:47 -03003663{
3664 struct hci_ev_le_meta *le_ev = (void *) skb->data;
3665
3666 skb_pull(skb, sizeof(*le_ev));
3667
3668 switch (le_ev->subevent) {
3669 case HCI_EV_LE_CONN_COMPLETE:
3670 hci_le_conn_complete_evt(hdev, skb);
3671 break;
3672
Andre Guedes9aa04c92011-05-26 16:23:51 -03003673 case HCI_EV_LE_ADVERTISING_REPORT:
3674 hci_le_adv_report_evt(hdev, skb);
3675 break;
3676
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003677 case HCI_EV_LE_LTK_REQ:
3678 hci_le_ltk_request_evt(hdev, skb);
3679 break;
3680
Ville Tervofcd89c02011-02-10 22:38:47 -03003681 default:
3682 break;
3683 }
3684}
3685
Andrei Emeltchenko9495b2e2012-09-27 17:26:22 +03003686static void hci_chan_selected_evt(struct hci_dev *hdev, struct sk_buff *skb)
3687{
3688 struct hci_ev_channel_selected *ev = (void *) skb->data;
3689 struct hci_conn *hcon;
3690
3691 BT_DBG("%s handle 0x%2.2x", hdev->name, ev->phy_handle);
3692
3693 skb_pull(skb, sizeof(*ev));
3694
3695 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3696 if (!hcon)
3697 return;
3698
3699 amp_read_loc_assoc_final_data(hdev, hcon);
3700}
3701
Linus Torvalds1da177e2005-04-16 15:20:36 -07003702void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
3703{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003704 struct hci_event_hdr *hdr = (void *) skb->data;
3705 __u8 event = hdr->evt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003706
3707 skb_pull(skb, HCI_EVENT_HDR_SIZE);
3708
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003709 switch (event) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003710 case HCI_EV_INQUIRY_COMPLETE:
3711 hci_inquiry_complete_evt(hdev, skb);
3712 break;
3713
3714 case HCI_EV_INQUIRY_RESULT:
3715 hci_inquiry_result_evt(hdev, skb);
3716 break;
3717
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003718 case HCI_EV_CONN_COMPLETE:
3719 hci_conn_complete_evt(hdev, skb);
Marcel Holtmann21d9e302005-09-13 01:32:25 +02003720 break;
3721
Linus Torvalds1da177e2005-04-16 15:20:36 -07003722 case HCI_EV_CONN_REQUEST:
3723 hci_conn_request_evt(hdev, skb);
3724 break;
3725
Linus Torvalds1da177e2005-04-16 15:20:36 -07003726 case HCI_EV_DISCONN_COMPLETE:
3727 hci_disconn_complete_evt(hdev, skb);
3728 break;
3729
Linus Torvalds1da177e2005-04-16 15:20:36 -07003730 case HCI_EV_AUTH_COMPLETE:
3731 hci_auth_complete_evt(hdev, skb);
3732 break;
3733
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003734 case HCI_EV_REMOTE_NAME:
3735 hci_remote_name_evt(hdev, skb);
3736 break;
3737
Linus Torvalds1da177e2005-04-16 15:20:36 -07003738 case HCI_EV_ENCRYPT_CHANGE:
3739 hci_encrypt_change_evt(hdev, skb);
3740 break;
3741
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003742 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
3743 hci_change_link_key_complete_evt(hdev, skb);
3744 break;
3745
3746 case HCI_EV_REMOTE_FEATURES:
3747 hci_remote_features_evt(hdev, skb);
3748 break;
3749
3750 case HCI_EV_REMOTE_VERSION:
3751 hci_remote_version_evt(hdev, skb);
3752 break;
3753
3754 case HCI_EV_QOS_SETUP_COMPLETE:
3755 hci_qos_setup_complete_evt(hdev, skb);
3756 break;
3757
3758 case HCI_EV_CMD_COMPLETE:
3759 hci_cmd_complete_evt(hdev, skb);
3760 break;
3761
3762 case HCI_EV_CMD_STATUS:
3763 hci_cmd_status_evt(hdev, skb);
3764 break;
3765
3766 case HCI_EV_ROLE_CHANGE:
3767 hci_role_change_evt(hdev, skb);
3768 break;
3769
3770 case HCI_EV_NUM_COMP_PKTS:
3771 hci_num_comp_pkts_evt(hdev, skb);
3772 break;
3773
3774 case HCI_EV_MODE_CHANGE:
3775 hci_mode_change_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776 break;
3777
3778 case HCI_EV_PIN_CODE_REQ:
3779 hci_pin_code_request_evt(hdev, skb);
3780 break;
3781
3782 case HCI_EV_LINK_KEY_REQ:
3783 hci_link_key_request_evt(hdev, skb);
3784 break;
3785
3786 case HCI_EV_LINK_KEY_NOTIFY:
3787 hci_link_key_notify_evt(hdev, skb);
3788 break;
3789
3790 case HCI_EV_CLOCK_OFFSET:
3791 hci_clock_offset_evt(hdev, skb);
3792 break;
3793
Marcel Holtmanna8746412008-07-14 20:13:46 +02003794 case HCI_EV_PKT_TYPE_CHANGE:
3795 hci_pkt_type_change_evt(hdev, skb);
3796 break;
3797
Marcel Holtmann85a1e932005-08-09 20:28:02 -07003798 case HCI_EV_PSCAN_REP_MODE:
3799 hci_pscan_rep_mode_evt(hdev, skb);
3800 break;
3801
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003802 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
3803 hci_inquiry_result_with_rssi_evt(hdev, skb);
3804 break;
3805
3806 case HCI_EV_REMOTE_EXT_FEATURES:
3807 hci_remote_ext_features_evt(hdev, skb);
3808 break;
3809
3810 case HCI_EV_SYNC_CONN_COMPLETE:
3811 hci_sync_conn_complete_evt(hdev, skb);
3812 break;
3813
3814 case HCI_EV_SYNC_CONN_CHANGED:
3815 hci_sync_conn_changed_evt(hdev, skb);
3816 break;
3817
Marcel Holtmann04837f62006-07-03 10:02:33 +02003818 case HCI_EV_SNIFF_SUBRATE:
3819 hci_sniff_subrate_evt(hdev, skb);
3820 break;
3821
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003822 case HCI_EV_EXTENDED_INQUIRY_RESULT:
3823 hci_extended_inquiry_result_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003824 break;
3825
Johan Hedberg1c2e0042012-06-08 23:31:13 +08003826 case HCI_EV_KEY_REFRESH_COMPLETE:
3827 hci_key_refresh_complete_evt(hdev, skb);
3828 break;
3829
Marcel Holtmann04936842008-07-14 20:13:48 +02003830 case HCI_EV_IO_CAPA_REQUEST:
3831 hci_io_capa_request_evt(hdev, skb);
3832 break;
3833
Johan Hedberg03b555e2011-01-04 15:40:05 +02003834 case HCI_EV_IO_CAPA_REPLY:
3835 hci_io_capa_reply_evt(hdev, skb);
3836 break;
3837
Johan Hedberga5c29682011-02-19 12:05:57 -03003838 case HCI_EV_USER_CONFIRM_REQUEST:
3839 hci_user_confirm_request_evt(hdev, skb);
3840 break;
3841
Brian Gix1143d452011-11-23 08:28:34 -08003842 case HCI_EV_USER_PASSKEY_REQUEST:
3843 hci_user_passkey_request_evt(hdev, skb);
3844 break;
3845
Johan Hedberg92a25252012-09-06 18:39:26 +03003846 case HCI_EV_USER_PASSKEY_NOTIFY:
3847 hci_user_passkey_notify_evt(hdev, skb);
3848 break;
3849
3850 case HCI_EV_KEYPRESS_NOTIFY:
3851 hci_keypress_notify_evt(hdev, skb);
3852 break;
3853
Marcel Holtmann04936842008-07-14 20:13:48 +02003854 case HCI_EV_SIMPLE_PAIR_COMPLETE:
3855 hci_simple_pair_complete_evt(hdev, skb);
3856 break;
3857
Marcel Holtmann41a96212008-07-14 20:13:48 +02003858 case HCI_EV_REMOTE_HOST_FEATURES:
3859 hci_remote_host_features_evt(hdev, skb);
3860 break;
3861
Ville Tervofcd89c02011-02-10 22:38:47 -03003862 case HCI_EV_LE_META:
3863 hci_le_meta_evt(hdev, skb);
3864 break;
3865
Andrei Emeltchenko9495b2e2012-09-27 17:26:22 +03003866 case HCI_EV_CHANNEL_SELECTED:
3867 hci_chan_selected_evt(hdev, skb);
3868 break;
3869
Szymon Janc2763eda2011-03-22 13:12:22 +01003870 case HCI_EV_REMOTE_OOB_DATA_REQUEST:
3871 hci_remote_oob_data_request_evt(hdev, skb);
3872 break;
3873
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02003874 case HCI_EV_NUM_COMP_BLOCKS:
3875 hci_num_comp_blocks_evt(hdev, skb);
3876 break;
3877
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003878 default:
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03003879 BT_DBG("%s event 0x%2.2x", hdev->name, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003880 break;
3881 }
3882
3883 kfree_skb(skb);
3884 hdev->stat.evt_rx++;
3885}