blob: 6fa909075cebf9c2a88edd7d69327c7afb6c7e0b [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <asm/unaligned.h>
28
29#include <net/bluetooth/bluetooth.h>
30#include <net/bluetooth/hci_core.h>
Mikel Astizf0d6a0e2012-08-09 09:52:30 +020031#include <net/bluetooth/mgmt.h>
Andrei Emeltchenko8e2a0d92012-09-27 17:26:08 +030032#include <net/bluetooth/a2mp.h>
Andrei Emeltchenko903e4542012-09-27 17:26:09 +030033#include <net/bluetooth/amp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Linus Torvalds1da177e2005-04-16 15:20:36 -070035/* Handle HCI Event packets */
36
Marcel Holtmanna9de9242007-10-20 13:33:56 +020037static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070038{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020039 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +030041 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Andre Guedese6d465c2011-11-09 17:14:26 -030043 if (status) {
44 hci_dev_lock(hdev);
45 mgmt_stop_discovery_failed(hdev, status);
46 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +020047 return;
Andre Guedese6d465c2011-11-09 17:14:26 -030048 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Andre Guedes89352e72011-11-04 14:16:53 -030050 clear_bit(HCI_INQUIRY, &hdev->flags);
Andre Guedes3e13fa12013-03-27 20:04:56 -030051 smp_mb__after_clear_bit(); /* wake_up_bit advises about this barrier */
52 wake_up_bit(&hdev->flags, HCI_INQUIRY);
Andre Guedes89352e72011-11-04 14:16:53 -030053
Johan Hedberg56e5cb82011-11-08 20:40:16 +020054 hci_dev_lock(hdev);
Johan Hedbergff9ef572012-01-04 14:23:45 +020055 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
Johan Hedberg56e5cb82011-11-08 20:40:16 +020056 hci_dev_unlock(hdev);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010057
Marcel Holtmanna9de9242007-10-20 13:33:56 +020058 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059}
60
Andre Guedes4d934832012-03-21 00:03:35 -030061static void hci_cc_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
62{
63 __u8 status = *((__u8 *) skb->data);
64
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +030065 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Andre Guedesae854a72012-03-21 00:03:36 -030066
67 if (status)
68 return;
69
70 set_bit(HCI_PERIODIC_INQ, &hdev->dev_flags);
Andre Guedes4d934832012-03-21 00:03:35 -030071}
72
Marcel Holtmanna9de9242007-10-20 13:33:56 +020073static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020075 __u8 status = *((__u8 *) skb->data);
76
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +030077 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +020078
79 if (status)
80 return;
81
Andre Guedesae854a72012-03-21 00:03:36 -030082 clear_bit(HCI_PERIODIC_INQ, &hdev->dev_flags);
83
Marcel Holtmanna9de9242007-10-20 13:33:56 +020084 hci_conn_check_pending(hdev);
85}
86
Gustavo Padovan807deac2012-05-17 00:36:24 -030087static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev,
88 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +020089{
90 BT_DBG("%s", hdev->name);
91}
92
93static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb)
94{
95 struct hci_rp_role_discovery *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +030098 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200100 if (rp->status)
101 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200103 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200105 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
106 if (conn) {
107 if (rp->role)
108 conn->link_mode &= ~HCI_LM_MASTER;
109 else
110 conn->link_mode |= HCI_LM_MASTER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200112
113 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114}
115
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200116static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
117{
118 struct hci_rp_read_link_policy *rp = (void *) skb->data;
119 struct hci_conn *conn;
120
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300121 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200122
123 if (rp->status)
124 return;
125
126 hci_dev_lock(hdev);
127
128 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
129 if (conn)
130 conn->link_policy = __le16_to_cpu(rp->policy);
131
132 hci_dev_unlock(hdev);
133}
134
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200135static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200137 struct hci_rp_write_link_policy *rp = (void *) skb->data;
138 struct hci_conn *conn;
139 void *sent;
140
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300141 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200142
143 if (rp->status)
144 return;
145
146 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
147 if (!sent)
148 return;
149
150 hci_dev_lock(hdev);
151
152 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200153 if (conn)
Harvey Harrison83985312008-05-02 16:25:46 -0700154 conn->link_policy = get_unaligned_le16(sent + 2);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200155
156 hci_dev_unlock(hdev);
157}
158
Gustavo Padovan807deac2012-05-17 00:36:24 -0300159static void hci_cc_read_def_link_policy(struct hci_dev *hdev,
160 struct sk_buff *skb)
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200161{
162 struct hci_rp_read_def_link_policy *rp = (void *) skb->data;
163
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300164 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200165
166 if (rp->status)
167 return;
168
169 hdev->link_policy = __le16_to_cpu(rp->policy);
170}
171
Gustavo Padovan807deac2012-05-17 00:36:24 -0300172static void hci_cc_write_def_link_policy(struct hci_dev *hdev,
173 struct sk_buff *skb)
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200174{
175 __u8 status = *((__u8 *) skb->data);
176 void *sent;
177
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300178 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200179
180 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
181 if (!sent)
182 return;
183
184 if (!status)
185 hdev->link_policy = get_unaligned_le16(sent);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200186}
187
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200188static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
189{
190 __u8 status = *((__u8 *) skb->data);
191
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300192 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200193
Gustavo F. Padovan10572132011-03-16 15:36:29 -0300194 clear_bit(HCI_RESET, &hdev->flags);
195
Johan Hedberga297e972012-02-21 17:55:47 +0200196 /* Reset all non-persistent flags */
Johan Hedberg2cc6fb02013-03-15 17:06:57 -0500197 hdev->dev_flags &= ~HCI_PERSISTENT_MASK;
Andre Guedes69775ff2012-02-23 16:50:05 +0200198
199 hdev->discovery.state = DISCOVERY_STOPPED;
Johan Hedbergbbaf4442012-11-08 01:22:59 +0100200 hdev->inq_tx_power = HCI_TX_POWER_INVALID;
201 hdev->adv_tx_power = HCI_TX_POWER_INVALID;
Johan Hedberg3f0f5242012-11-08 01:23:00 +0100202
203 memset(hdev->adv_data, 0, sizeof(hdev->adv_data));
204 hdev->adv_data_len = 0;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200205}
206
207static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
208{
209 __u8 status = *((__u8 *) skb->data);
210 void *sent;
211
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300212 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200213
214 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
215 if (!sent)
216 return;
217
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200218 hci_dev_lock(hdev);
219
Johan Hedbergf51d5b22012-02-22 18:17:32 +0200220 if (test_bit(HCI_MGMT, &hdev->dev_flags))
221 mgmt_set_local_name_complete(hdev, sent, status);
Johan Hedberg28cc7bd2012-02-22 21:06:55 +0200222 else if (!status)
223 memcpy(hdev->dev_name, sent, HCI_MAX_NAME_LENGTH);
Johan Hedbergf51d5b22012-02-22 18:17:32 +0200224
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200225 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200226}
227
228static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
229{
230 struct hci_rp_read_local_name *rp = (void *) skb->data;
231
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300232 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200233
234 if (rp->status)
235 return;
236
Johan Hedbergdb99b5f2012-02-22 20:14:22 +0200237 if (test_bit(HCI_SETUP, &hdev->dev_flags))
238 memcpy(hdev->dev_name, rp->name, HCI_MAX_NAME_LENGTH);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200239}
240
241static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
242{
243 __u8 status = *((__u8 *) skb->data);
244 void *sent;
245
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300246 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200247
248 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
249 if (!sent)
250 return;
251
252 if (!status) {
253 __u8 param = *((__u8 *) sent);
254
255 if (param == AUTH_ENABLED)
256 set_bit(HCI_AUTH, &hdev->flags);
257 else
258 clear_bit(HCI_AUTH, &hdev->flags);
259 }
260
Johan Hedberg33ef95e2012-02-16 23:56:27 +0200261 if (test_bit(HCI_MGMT, &hdev->dev_flags))
262 mgmt_auth_enable_complete(hdev, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200263}
264
265static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
266{
267 __u8 status = *((__u8 *) skb->data);
268 void *sent;
269
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300270 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200271
272 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
273 if (!sent)
274 return;
275
276 if (!status) {
277 __u8 param = *((__u8 *) sent);
278
279 if (param)
280 set_bit(HCI_ENCRYPT, &hdev->flags);
281 else
282 clear_bit(HCI_ENCRYPT, &hdev->flags);
283 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200284}
285
286static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
287{
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200288 __u8 param, status = *((__u8 *) skb->data);
289 int old_pscan, old_iscan;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200290 void *sent;
291
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300292 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200293
294 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
295 if (!sent)
296 return;
297
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200298 param = *((__u8 *) sent);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200299
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200300 hci_dev_lock(hdev);
301
Mikel Astizfa1bd912012-08-09 09:52:29 +0200302 if (status) {
Johan Hedberg744cf192011-11-08 20:40:14 +0200303 mgmt_write_scan_failed(hdev, param, status);
Johan Hedberg2d7cee52011-11-07 22:16:03 +0200304 hdev->discov_timeout = 0;
305 goto done;
306 }
307
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200308 old_pscan = test_and_clear_bit(HCI_PSCAN, &hdev->flags);
309 old_iscan = test_and_clear_bit(HCI_ISCAN, &hdev->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200310
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200311 if (param & SCAN_INQUIRY) {
312 set_bit(HCI_ISCAN, &hdev->flags);
313 if (!old_iscan)
Johan Hedberg744cf192011-11-08 20:40:14 +0200314 mgmt_discoverable(hdev, 1);
Johan Hedberg16ab91a2011-11-07 22:16:02 +0200315 if (hdev->discov_timeout > 0) {
316 int to = msecs_to_jiffies(hdev->discov_timeout * 1000);
317 queue_delayed_work(hdev->workqueue, &hdev->discov_off,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300318 to);
Johan Hedberg16ab91a2011-11-07 22:16:02 +0200319 }
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200320 } else if (old_iscan)
Johan Hedberg744cf192011-11-08 20:40:14 +0200321 mgmt_discoverable(hdev, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200322
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200323 if (param & SCAN_PAGE) {
324 set_bit(HCI_PSCAN, &hdev->flags);
325 if (!old_pscan)
Johan Hedberg744cf192011-11-08 20:40:14 +0200326 mgmt_connectable(hdev, 1);
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200327 } else if (old_pscan)
Johan Hedberg744cf192011-11-08 20:40:14 +0200328 mgmt_connectable(hdev, 0);
Johan Hedberg36f7fc72011-11-04 00:17:45 +0200329
330done:
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200331 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200332}
333
334static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
335{
336 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
337
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300338 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200339
340 if (rp->status)
341 return;
342
343 memcpy(hdev->dev_class, rp->dev_class, 3);
344
345 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300346 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200347}
348
349static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
350{
351 __u8 status = *((__u8 *) skb->data);
352 void *sent;
353
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300354 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200355
356 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
357 if (!sent)
358 return;
359
Marcel Holtmann7f9a9032012-02-22 18:38:01 +0100360 hci_dev_lock(hdev);
361
362 if (status == 0)
363 memcpy(hdev->dev_class, sent, 3);
364
365 if (test_bit(HCI_MGMT, &hdev->dev_flags))
366 mgmt_set_class_of_dev_complete(hdev, sent, status);
367
368 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200369}
370
371static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
372{
373 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 __u16 setting;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200375
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300376 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200377
378 if (rp->status)
379 return;
380
381 setting = __le16_to_cpu(rp->voice_setting);
382
Marcel Holtmannf383f272008-07-14 20:13:47 +0200383 if (hdev->voice_setting == setting)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200384 return;
385
386 hdev->voice_setting = setting;
387
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300388 BT_DBG("%s voice setting 0x%4.4x", hdev->name, setting);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200389
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200390 if (hdev->notify)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200391 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200392}
393
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300394static void hci_cc_write_voice_setting(struct hci_dev *hdev,
395 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200396{
397 __u8 status = *((__u8 *) skb->data);
Marcel Holtmannf383f272008-07-14 20:13:47 +0200398 __u16 setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 void *sent;
400
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300401 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
Marcel Holtmannf383f272008-07-14 20:13:47 +0200403 if (status)
404 return;
405
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200406 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
407 if (!sent)
408 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
Marcel Holtmannf383f272008-07-14 20:13:47 +0200410 setting = get_unaligned_le16(sent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
Marcel Holtmannf383f272008-07-14 20:13:47 +0200412 if (hdev->voice_setting == setting)
413 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
Marcel Holtmannf383f272008-07-14 20:13:47 +0200415 hdev->voice_setting = setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300417 BT_DBG("%s voice setting 0x%4.4x", hdev->name, setting);
Marcel Holtmannf383f272008-07-14 20:13:47 +0200418
Gustavo F. Padovan3c547112011-12-14 22:58:44 -0200419 if (hdev->notify)
Marcel Holtmannf383f272008-07-14 20:13:47 +0200420 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421}
422
Marcel Holtmann333140b2008-07-14 20:13:48 +0200423static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
424{
425 __u8 status = *((__u8 *) skb->data);
Johan Hedberg5ed8eb22012-10-25 00:09:51 +0300426 struct hci_cp_write_ssp_mode *sent;
Marcel Holtmann333140b2008-07-14 20:13:48 +0200427
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300428 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmann333140b2008-07-14 20:13:48 +0200429
Marcel Holtmann333140b2008-07-14 20:13:48 +0200430 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
431 if (!sent)
432 return;
433
Johan Hedberg5ed8eb22012-10-25 00:09:51 +0300434 if (!status) {
435 if (sent->mode)
436 hdev->host_features[0] |= LMP_HOST_SSP;
437 else
438 hdev->host_features[0] &= ~LMP_HOST_SSP;
439 }
440
Johan Hedberged2c4ee2012-02-17 00:56:28 +0200441 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg5ed8eb22012-10-25 00:09:51 +0300442 mgmt_ssp_enable_complete(hdev, sent->mode, status);
Johan Hedbergc0ecddc2012-02-22 12:38:31 +0200443 else if (!status) {
Johan Hedberg5ed8eb22012-10-25 00:09:51 +0300444 if (sent->mode)
Johan Hedbergc0ecddc2012-02-22 12:38:31 +0200445 set_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
446 else
447 clear_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
448 }
Marcel Holtmann333140b2008-07-14 20:13:48 +0200449}
450
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200451static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
452{
453 struct hci_rp_read_local_version *rp = (void *) skb->data;
454
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300455 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200456
457 if (rp->status)
Johan Hedberg42c6b122013-03-05 20:37:49 +0200458 return;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200459
460 hdev->hci_ver = rp->hci_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200461 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200462 hdev->lmp_ver = rp->lmp_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200463 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200464 hdev->lmp_subver = __le16_to_cpu(rp->lmp_subver);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200465
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300466 BT_DBG("%s manufacturer 0x%4.4x hci ver %d:%d", hdev->name,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300467 hdev->manufacturer, hdev->hci_ver, hdev->hci_rev);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200468}
469
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300470static void hci_cc_read_local_commands(struct hci_dev *hdev,
471 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200472{
473 struct hci_rp_read_local_commands *rp = (void *) skb->data;
474
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300475 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200476
Johan Hedberg2177bab2013-03-05 20:37:43 +0200477 if (!rp->status)
478 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200479}
480
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -0300481static void hci_cc_read_local_features(struct hci_dev *hdev,
482 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200483{
484 struct hci_rp_read_local_features *rp = (void *) skb->data;
485
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300486 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200487
488 if (rp->status)
489 return;
490
491 memcpy(hdev->features, rp->features, 8);
492
493 /* Adjust default settings according to features
494 * supported by device. */
495
496 if (hdev->features[0] & LMP_3SLOT)
497 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
498
499 if (hdev->features[0] & LMP_5SLOT)
500 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
501
502 if (hdev->features[1] & LMP_HV2) {
503 hdev->pkt_type |= (HCI_HV2);
504 hdev->esco_type |= (ESCO_HV2);
505 }
506
507 if (hdev->features[1] & LMP_HV3) {
508 hdev->pkt_type |= (HCI_HV3);
509 hdev->esco_type |= (ESCO_HV3);
510 }
511
Andre Guedes45db810f2012-07-24 15:03:49 -0300512 if (lmp_esco_capable(hdev))
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200513 hdev->esco_type |= (ESCO_EV3);
514
515 if (hdev->features[4] & LMP_EV4)
516 hdev->esco_type |= (ESCO_EV4);
517
518 if (hdev->features[4] & LMP_EV5)
519 hdev->esco_type |= (ESCO_EV5);
520
Marcel Holtmannefc76882009-02-06 09:13:37 +0100521 if (hdev->features[5] & LMP_EDR_ESCO_2M)
522 hdev->esco_type |= (ESCO_2EV3);
523
524 if (hdev->features[5] & LMP_EDR_ESCO_3M)
525 hdev->esco_type |= (ESCO_3EV3);
526
527 if (hdev->features[5] & LMP_EDR_3S_ESCO)
528 hdev->esco_type |= (ESCO_2EV5 | ESCO_3EV5);
529
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200530 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300531 hdev->features[0], hdev->features[1],
532 hdev->features[2], hdev->features[3],
533 hdev->features[4], hdev->features[5],
534 hdev->features[6], hdev->features[7]);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200535}
536
Andre Guedes971e3a42011-06-30 19:20:52 -0300537static void hci_cc_read_local_ext_features(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300538 struct sk_buff *skb)
Andre Guedes971e3a42011-06-30 19:20:52 -0300539{
540 struct hci_rp_read_local_ext_features *rp = (void *) skb->data;
541
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300542 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Andre Guedes971e3a42011-06-30 19:20:52 -0300543
544 if (rp->status)
Johan Hedberg42c6b122013-03-05 20:37:49 +0200545 return;
Andre Guedes971e3a42011-06-30 19:20:52 -0300546
Andre Guedesb5b32b62011-12-30 10:34:04 -0300547 switch (rp->page) {
548 case 0:
549 memcpy(hdev->features, rp->features, 8);
550 break;
551 case 1:
552 memcpy(hdev->host_features, rp->features, 8);
553 break;
554 }
Andre Guedes971e3a42011-06-30 19:20:52 -0300555}
556
Andrei Emeltchenko1e89cff2011-11-24 14:52:02 +0200557static void hci_cc_read_flow_control_mode(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300558 struct sk_buff *skb)
Andrei Emeltchenko1e89cff2011-11-24 14:52:02 +0200559{
560 struct hci_rp_read_flow_control_mode *rp = (void *) skb->data;
561
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300562 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Andrei Emeltchenko1e89cff2011-11-24 14:52:02 +0200563
Johan Hedberg42c6b122013-03-05 20:37:49 +0200564 if (!rp->status)
565 hdev->flow_ctl_mode = rp->mode;
Andrei Emeltchenko1e89cff2011-11-24 14:52:02 +0200566}
567
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200568static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
569{
570 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
571
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300572 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200573
574 if (rp->status)
575 return;
576
577 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
578 hdev->sco_mtu = rp->sco_mtu;
579 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
580 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
581
582 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
583 hdev->sco_mtu = 64;
584 hdev->sco_pkts = 8;
585 }
586
587 hdev->acl_cnt = hdev->acl_pkts;
588 hdev->sco_cnt = hdev->sco_pkts;
589
Gustavo Padovan807deac2012-05-17 00:36:24 -0300590 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name, hdev->acl_mtu,
591 hdev->acl_pkts, hdev->sco_mtu, hdev->sco_pkts);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200592}
593
594static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
595{
596 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
597
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300598 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200599
600 if (!rp->status)
601 bacpy(&hdev->bdaddr, &rp->bdaddr);
Johan Hedberg23bb5762010-12-21 23:01:27 +0200602}
603
Johan Hedbergf332ec62013-03-15 17:07:11 -0500604static void hci_cc_read_page_scan_activity(struct hci_dev *hdev,
605 struct sk_buff *skb)
606{
607 struct hci_rp_read_page_scan_activity *rp = (void *) skb->data;
608
609 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
610
611 if (test_bit(HCI_INIT, &hdev->flags) && !rp->status) {
612 hdev->page_scan_interval = __le16_to_cpu(rp->interval);
613 hdev->page_scan_window = __le16_to_cpu(rp->window);
614 }
615}
616
Johan Hedberg4a3ee762013-03-15 17:07:12 -0500617static void hci_cc_write_page_scan_activity(struct hci_dev *hdev,
618 struct sk_buff *skb)
619{
620 u8 status = *((u8 *) skb->data);
621 struct hci_cp_write_page_scan_activity *sent;
622
623 BT_DBG("%s status 0x%2.2x", hdev->name, status);
624
625 if (status)
626 return;
627
628 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_PAGE_SCAN_ACTIVITY);
629 if (!sent)
630 return;
631
632 hdev->page_scan_interval = __le16_to_cpu(sent->interval);
633 hdev->page_scan_window = __le16_to_cpu(sent->window);
634}
635
Johan Hedbergf332ec62013-03-15 17:07:11 -0500636static void hci_cc_read_page_scan_type(struct hci_dev *hdev,
637 struct sk_buff *skb)
638{
639 struct hci_rp_read_page_scan_type *rp = (void *) skb->data;
640
641 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
642
643 if (test_bit(HCI_INIT, &hdev->flags) && !rp->status)
644 hdev->page_scan_type = rp->type;
645}
646
Johan Hedberg4a3ee762013-03-15 17:07:12 -0500647static void hci_cc_write_page_scan_type(struct hci_dev *hdev,
648 struct sk_buff *skb)
649{
650 u8 status = *((u8 *) skb->data);
651 u8 *type;
652
653 BT_DBG("%s status 0x%2.2x", hdev->name, status);
654
655 if (status)
656 return;
657
658 type = hci_sent_cmd_data(hdev, HCI_OP_WRITE_PAGE_SCAN_TYPE);
659 if (type)
660 hdev->page_scan_type = *type;
661}
662
Andrei Emeltchenko350ee4c2011-12-07 15:56:51 +0200663static void hci_cc_read_data_block_size(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300664 struct sk_buff *skb)
Andrei Emeltchenko350ee4c2011-12-07 15:56:51 +0200665{
666 struct hci_rp_read_data_block_size *rp = (void *) skb->data;
667
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300668 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Andrei Emeltchenko350ee4c2011-12-07 15:56:51 +0200669
670 if (rp->status)
671 return;
672
673 hdev->block_mtu = __le16_to_cpu(rp->max_acl_len);
674 hdev->block_len = __le16_to_cpu(rp->block_len);
675 hdev->num_blocks = __le16_to_cpu(rp->num_blocks);
676
677 hdev->block_cnt = hdev->num_blocks;
678
679 BT_DBG("%s blk mtu %d cnt %d len %d", hdev->name, hdev->block_mtu,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300680 hdev->block_cnt, hdev->block_len);
Andrei Emeltchenko350ee4c2011-12-07 15:56:51 +0200681}
682
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +0300683static void hci_cc_read_local_amp_info(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300684 struct sk_buff *skb)
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +0300685{
686 struct hci_rp_read_local_amp_info *rp = (void *) skb->data;
687
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300688 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +0300689
690 if (rp->status)
Andrei Emeltchenko8e2a0d92012-09-27 17:26:08 +0300691 goto a2mp_rsp;
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +0300692
693 hdev->amp_status = rp->amp_status;
694 hdev->amp_total_bw = __le32_to_cpu(rp->total_bw);
695 hdev->amp_max_bw = __le32_to_cpu(rp->max_bw);
696 hdev->amp_min_latency = __le32_to_cpu(rp->min_latency);
697 hdev->amp_max_pdu = __le32_to_cpu(rp->max_pdu);
698 hdev->amp_type = rp->amp_type;
699 hdev->amp_pal_cap = __le16_to_cpu(rp->pal_cap);
700 hdev->amp_assoc_size = __le16_to_cpu(rp->max_assoc_size);
701 hdev->amp_be_flush_to = __le32_to_cpu(rp->be_flush_to);
702 hdev->amp_max_flush_to = __le32_to_cpu(rp->max_flush_to);
703
Andrei Emeltchenko8e2a0d92012-09-27 17:26:08 +0300704a2mp_rsp:
705 a2mp_send_getinfo_rsp(hdev);
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +0300706}
707
Andrei Emeltchenko903e4542012-09-27 17:26:09 +0300708static void hci_cc_read_local_amp_assoc(struct hci_dev *hdev,
709 struct sk_buff *skb)
710{
711 struct hci_rp_read_local_amp_assoc *rp = (void *) skb->data;
712 struct amp_assoc *assoc = &hdev->loc_assoc;
713 size_t rem_len, frag_len;
714
715 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
716
717 if (rp->status)
718 goto a2mp_rsp;
719
720 frag_len = skb->len - sizeof(*rp);
721 rem_len = __le16_to_cpu(rp->rem_len);
722
723 if (rem_len > frag_len) {
Andrei Emeltchenko2e430be32012-09-28 14:44:23 +0300724 BT_DBG("frag_len %zu rem_len %zu", frag_len, rem_len);
Andrei Emeltchenko903e4542012-09-27 17:26:09 +0300725
726 memcpy(assoc->data + assoc->offset, rp->frag, frag_len);
727 assoc->offset += frag_len;
728
729 /* Read other fragments */
730 amp_read_loc_assoc_frag(hdev, rp->phy_handle);
731
732 return;
733 }
734
735 memcpy(assoc->data + assoc->offset, rp->frag, rem_len);
736 assoc->len = assoc->offset + rem_len;
737 assoc->offset = 0;
738
739a2mp_rsp:
740 /* Send A2MP Rsp when all fragments are received */
741 a2mp_send_getampassoc_rsp(hdev, rp->status);
Andrei Emeltchenko9495b2e2012-09-27 17:26:22 +0300742 a2mp_send_create_phy_link_req(hdev, rp->status);
Andrei Emeltchenko903e4542012-09-27 17:26:09 +0300743}
744
Johan Hedbergd5859e22011-01-25 01:19:58 +0200745static void hci_cc_read_inq_rsp_tx_power(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300746 struct sk_buff *skb)
Johan Hedbergd5859e22011-01-25 01:19:58 +0200747{
Marcel Holtmann91c4e9b2012-03-11 19:27:21 -0700748 struct hci_rp_read_inq_rsp_tx_power *rp = (void *) skb->data;
Johan Hedbergd5859e22011-01-25 01:19:58 +0200749
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300750 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200751
Marcel Holtmann91c4e9b2012-03-11 19:27:21 -0700752 if (!rp->status)
753 hdev->inq_tx_power = rp->tx_power;
Johan Hedbergd5859e22011-01-25 01:19:58 +0200754}
755
Johan Hedberg980e1a52011-01-22 06:10:07 +0200756static void hci_cc_pin_code_reply(struct hci_dev *hdev, struct sk_buff *skb)
757{
758 struct hci_rp_pin_code_reply *rp = (void *) skb->data;
759 struct hci_cp_pin_code_reply *cp;
760 struct hci_conn *conn;
761
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300762 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200763
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200764 hci_dev_lock(hdev);
765
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200766 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg744cf192011-11-08 20:40:14 +0200767 mgmt_pin_code_reply_complete(hdev, &rp->bdaddr, rp->status);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200768
Mikel Astizfa1bd912012-08-09 09:52:29 +0200769 if (rp->status)
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200770 goto unlock;
Johan Hedberg980e1a52011-01-22 06:10:07 +0200771
772 cp = hci_sent_cmd_data(hdev, HCI_OP_PIN_CODE_REPLY);
773 if (!cp)
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200774 goto unlock;
Johan Hedberg980e1a52011-01-22 06:10:07 +0200775
776 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
777 if (conn)
778 conn->pin_length = cp->pin_len;
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200779
780unlock:
781 hci_dev_unlock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200782}
783
784static void hci_cc_pin_code_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
785{
786 struct hci_rp_pin_code_neg_reply *rp = (void *) skb->data;
787
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300788 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200789
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200790 hci_dev_lock(hdev);
791
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200792 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg744cf192011-11-08 20:40:14 +0200793 mgmt_pin_code_neg_reply_complete(hdev, &rp->bdaddr,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300794 rp->status);
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200795
796 hci_dev_unlock(hdev);
Johan Hedberg980e1a52011-01-22 06:10:07 +0200797}
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200798
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300799static void hci_cc_le_read_buffer_size(struct hci_dev *hdev,
800 struct sk_buff *skb)
801{
802 struct hci_rp_le_read_buffer_size *rp = (void *) skb->data;
803
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300804 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300805
806 if (rp->status)
807 return;
808
809 hdev->le_mtu = __le16_to_cpu(rp->le_mtu);
810 hdev->le_pkts = rp->le_max_pkt;
811
812 hdev->le_cnt = hdev->le_pkts;
813
814 BT_DBG("%s le mtu %d:%d", hdev->name, hdev->le_mtu, hdev->le_pkts);
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300815}
Johan Hedberg980e1a52011-01-22 06:10:07 +0200816
Johan Hedberg60e77322013-01-22 14:01:59 +0200817static void hci_cc_le_read_local_features(struct hci_dev *hdev,
818 struct sk_buff *skb)
819{
820 struct hci_rp_le_read_local_features *rp = (void *) skb->data;
821
822 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
823
824 if (!rp->status)
825 memcpy(hdev->le_features, rp->features, 8);
Johan Hedberg60e77322013-01-22 14:01:59 +0200826}
827
Johan Hedberg8fa19092012-10-19 20:57:49 +0300828static void hci_cc_le_read_adv_tx_power(struct hci_dev *hdev,
829 struct sk_buff *skb)
830{
831 struct hci_rp_le_read_adv_tx_power *rp = (void *) skb->data;
832
833 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
834
Johan Hedberg04b4edc2013-03-15 17:07:01 -0500835 if (!rp->status)
Johan Hedberg8fa19092012-10-19 20:57:49 +0300836 hdev->adv_tx_power = rp->tx_power;
Johan Hedberg8fa19092012-10-19 20:57:49 +0300837}
838
Johan Hedberga5c29682011-02-19 12:05:57 -0300839static void hci_cc_user_confirm_reply(struct hci_dev *hdev, struct sk_buff *skb)
840{
841 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
842
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300843 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Johan Hedberga5c29682011-02-19 12:05:57 -0300844
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200845 hci_dev_lock(hdev);
846
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200847 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300848 mgmt_user_confirm_reply_complete(hdev, &rp->bdaddr, ACL_LINK, 0,
849 rp->status);
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200850
851 hci_dev_unlock(hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -0300852}
853
854static void hci_cc_user_confirm_neg_reply(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300855 struct sk_buff *skb)
Johan Hedberga5c29682011-02-19 12:05:57 -0300856{
857 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
858
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300859 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Johan Hedberga5c29682011-02-19 12:05:57 -0300860
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200861 hci_dev_lock(hdev);
862
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200863 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg744cf192011-11-08 20:40:14 +0200864 mgmt_user_confirm_neg_reply_complete(hdev, &rp->bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300865 ACL_LINK, 0, rp->status);
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200866
867 hci_dev_unlock(hdev);
Johan Hedberga5c29682011-02-19 12:05:57 -0300868}
869
Brian Gix1143d452011-11-23 08:28:34 -0800870static void hci_cc_user_passkey_reply(struct hci_dev *hdev, struct sk_buff *skb)
871{
872 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
873
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300874 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Brian Gix1143d452011-11-23 08:28:34 -0800875
876 hci_dev_lock(hdev);
877
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200878 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg272d90d2012-02-09 15:26:12 +0200879 mgmt_user_passkey_reply_complete(hdev, &rp->bdaddr, ACL_LINK,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300880 0, rp->status);
Brian Gix1143d452011-11-23 08:28:34 -0800881
882 hci_dev_unlock(hdev);
883}
884
885static void hci_cc_user_passkey_neg_reply(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300886 struct sk_buff *skb)
Brian Gix1143d452011-11-23 08:28:34 -0800887{
888 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
889
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300890 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Brian Gix1143d452011-11-23 08:28:34 -0800891
892 hci_dev_lock(hdev);
893
Johan Hedberga8b2d5c2012-01-08 23:11:15 +0200894 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Brian Gix1143d452011-11-23 08:28:34 -0800895 mgmt_user_passkey_neg_reply_complete(hdev, &rp->bdaddr,
Gustavo F. Padovan04124682012-03-08 01:25:00 -0300896 ACL_LINK, 0, rp->status);
Brian Gix1143d452011-11-23 08:28:34 -0800897
898 hci_dev_unlock(hdev);
899}
900
Szymon Jancc35938b2011-03-22 13:12:21 +0100901static void hci_cc_read_local_oob_data_reply(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300902 struct sk_buff *skb)
Szymon Jancc35938b2011-03-22 13:12:21 +0100903{
904 struct hci_rp_read_local_oob_data *rp = (void *) skb->data;
905
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300906 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
Szymon Jancc35938b2011-03-22 13:12:21 +0100907
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200908 hci_dev_lock(hdev);
Johan Hedberg744cf192011-11-08 20:40:14 +0200909 mgmt_read_local_oob_data_reply_complete(hdev, rp->hash,
Szymon Jancc35938b2011-03-22 13:12:21 +0100910 rp->randomizer, rp->status);
Johan Hedberg56e5cb82011-11-08 20:40:16 +0200911 hci_dev_unlock(hdev);
Szymon Jancc35938b2011-03-22 13:12:21 +0100912}
913
Johan Hedbergc1d5dc42012-11-08 01:23:01 +0100914static void hci_cc_le_set_adv_enable(struct hci_dev *hdev, struct sk_buff *skb)
915{
916 __u8 *sent, status = *((__u8 *) skb->data);
917
918 BT_DBG("%s status 0x%2.2x", hdev->name, status);
919
920 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_ADV_ENABLE);
921 if (!sent)
922 return;
923
924 hci_dev_lock(hdev);
925
926 if (!status) {
927 if (*sent)
928 set_bit(HCI_LE_PERIPHERAL, &hdev->dev_flags);
929 else
930 clear_bit(HCI_LE_PERIPHERAL, &hdev->dev_flags);
931 }
932
Johan Hedberg04b4edc2013-03-15 17:07:01 -0500933 if (!test_bit(HCI_INIT, &hdev->flags)) {
934 struct hci_request req;
Johan Hedbergc1d5dc42012-11-08 01:23:01 +0100935
Johan Hedberg04b4edc2013-03-15 17:07:01 -0500936 hci_req_init(&req, hdev);
937 hci_update_ad(&req);
938 hci_req_run(&req, NULL);
939 }
940
941 hci_dev_unlock(hdev);
Johan Hedbergc1d5dc42012-11-08 01:23:01 +0100942}
943
Andre Guedes07f7fa52011-12-02 21:13:31 +0900944static void hci_cc_le_set_scan_param(struct hci_dev *hdev, struct sk_buff *skb)
945{
946 __u8 status = *((__u8 *) skb->data);
947
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300948 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Andre Guedes7ba8b4b2012-02-03 17:47:59 -0300949
Andre Guedes3fd24152012-02-03 17:48:01 -0300950 if (status) {
951 hci_dev_lock(hdev);
952 mgmt_start_discovery_failed(hdev, status);
953 hci_dev_unlock(hdev);
954 return;
955 }
Andre Guedes07f7fa52011-12-02 21:13:31 +0900956}
957
Andre Guedeseb9d91f2011-05-26 16:23:52 -0300958static void hci_cc_le_set_scan_enable(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -0300959 struct sk_buff *skb)
Andre Guedeseb9d91f2011-05-26 16:23:52 -0300960{
961 struct hci_cp_le_set_scan_enable *cp;
962 __u8 status = *((__u8 *) skb->data);
963
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +0300964 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Andre Guedeseb9d91f2011-05-26 16:23:52 -0300965
Andre Guedeseb9d91f2011-05-26 16:23:52 -0300966 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_SCAN_ENABLE);
967 if (!cp)
968 return;
969
Andrei Emeltchenko68a8aea2011-12-19 16:14:18 +0200970 switch (cp->enable) {
971 case LE_SCANNING_ENABLED:
Andre Guedes3fd24152012-02-03 17:48:01 -0300972 if (status) {
973 hci_dev_lock(hdev);
974 mgmt_start_discovery_failed(hdev, status);
975 hci_dev_unlock(hdev);
Andre Guedes7ba8b4b2012-02-03 17:47:59 -0300976 return;
Andre Guedes3fd24152012-02-03 17:48:01 -0300977 }
Andre Guedes7ba8b4b2012-02-03 17:47:59 -0300978
Andre Guedesd23264a2011-11-25 20:53:38 -0300979 set_bit(HCI_LE_SCAN, &hdev->dev_flags);
980
Andre Guedesa8f13c82011-09-09 18:56:24 -0300981 hci_dev_lock(hdev);
Andre Guedes343f9352012-02-17 20:39:37 -0300982 hci_discovery_set_state(hdev, DISCOVERY_FINDING);
Andre Guedesa8f13c82011-09-09 18:56:24 -0300983 hci_dev_unlock(hdev);
Andrei Emeltchenko68a8aea2011-12-19 16:14:18 +0200984 break;
985
986 case LE_SCANNING_DISABLED:
Andre Guedesc9ecc482012-03-15 16:52:08 -0300987 if (status) {
988 hci_dev_lock(hdev);
989 mgmt_stop_discovery_failed(hdev, status);
990 hci_dev_unlock(hdev);
Andre Guedes7ba8b4b2012-02-03 17:47:59 -0300991 return;
Andre Guedesc9ecc482012-03-15 16:52:08 -0300992 }
Andre Guedes7ba8b4b2012-02-03 17:47:59 -0300993
Andre Guedesd23264a2011-11-25 20:53:38 -0300994 clear_bit(HCI_LE_SCAN, &hdev->dev_flags);
995
Andre Guedesbc3dd332012-03-06 19:37:06 -0300996 if (hdev->discovery.type == DISCOV_TYPE_INTERLEAVED &&
997 hdev->discovery.state == DISCOVERY_FINDING) {
Andre Guedes5e0452c2012-02-17 20:39:38 -0300998 mgmt_interleaved_discovery(hdev);
999 } else {
1000 hci_dev_lock(hdev);
1001 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1002 hci_dev_unlock(hdev);
1003 }
1004
Andrei Emeltchenko68a8aea2011-12-19 16:14:18 +02001005 break;
1006
1007 default:
1008 BT_ERR("Used reserved LE_Scan_Enable param %d", cp->enable);
1009 break;
Andre Guedes35815082011-05-26 16:23:53 -03001010 }
Andre Guedeseb9d91f2011-05-26 16:23:52 -03001011}
1012
Johan Hedbergcf1d0812013-01-22 14:02:00 +02001013static void hci_cc_le_read_white_list_size(struct hci_dev *hdev,
1014 struct sk_buff *skb)
1015{
1016 struct hci_rp_le_read_white_list_size *rp = (void *) skb->data;
1017
1018 BT_DBG("%s status 0x%2.2x size %u", hdev->name, rp->status, rp->size);
1019
1020 if (!rp->status)
1021 hdev->le_white_list_size = rp->size;
Johan Hedbergcf1d0812013-01-22 14:02:00 +02001022}
1023
Johan Hedberg9b008c02013-01-22 14:02:01 +02001024static void hci_cc_le_read_supported_states(struct hci_dev *hdev,
1025 struct sk_buff *skb)
1026{
1027 struct hci_rp_le_read_supported_states *rp = (void *) skb->data;
1028
1029 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1030
1031 if (!rp->status)
1032 memcpy(hdev->le_states, rp->le_states, 8);
Johan Hedberg9b008c02013-01-22 14:02:01 +02001033}
1034
Gustavo Padovan6039aa72012-05-23 04:04:18 -03001035static void hci_cc_write_le_host_supported(struct hci_dev *hdev,
1036 struct sk_buff *skb)
Andre Guedesf9b49302011-06-30 19:20:53 -03001037{
Johan Hedberg06199cf2012-02-22 16:37:11 +02001038 struct hci_cp_write_le_host_supported *sent;
Andre Guedesf9b49302011-06-30 19:20:53 -03001039 __u8 status = *((__u8 *) skb->data);
1040
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001041 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Andre Guedesf9b49302011-06-30 19:20:53 -03001042
Johan Hedberg06199cf2012-02-22 16:37:11 +02001043 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED);
Johan Hedberg8f984df2012-02-28 01:07:22 +02001044 if (!sent)
Andre Guedesf9b49302011-06-30 19:20:53 -03001045 return;
1046
Johan Hedberg8f984df2012-02-28 01:07:22 +02001047 if (!status) {
1048 if (sent->le)
1049 hdev->host_features[0] |= LMP_HOST_LE;
1050 else
1051 hdev->host_features[0] &= ~LMP_HOST_LE;
Johan Hedberg53b2caa2012-10-24 21:11:59 +03001052
1053 if (sent->simul)
1054 hdev->host_features[0] |= LMP_HOST_LE_BREDR;
1055 else
1056 hdev->host_features[0] &= ~LMP_HOST_LE_BREDR;
Johan Hedberg8f984df2012-02-28 01:07:22 +02001057 }
1058
1059 if (test_bit(HCI_MGMT, &hdev->dev_flags) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03001060 !test_bit(HCI_INIT, &hdev->flags))
Johan Hedberg8f984df2012-02-28 01:07:22 +02001061 mgmt_le_enable_complete(hdev, sent->le, status);
Andre Guedesf9b49302011-06-30 19:20:53 -03001062}
1063
Andrei Emeltchenko93c284e2012-09-27 17:26:20 +03001064static void hci_cc_write_remote_amp_assoc(struct hci_dev *hdev,
1065 struct sk_buff *skb)
1066{
1067 struct hci_rp_write_remote_amp_assoc *rp = (void *) skb->data;
1068
1069 BT_DBG("%s status 0x%2.2x phy_handle 0x%2.2x",
1070 hdev->name, rp->status, rp->phy_handle);
1071
1072 if (rp->status)
1073 return;
1074
1075 amp_write_rem_assoc_continue(hdev, rp->phy_handle);
1076}
1077
Gustavo Padovan6039aa72012-05-23 04:04:18 -03001078static void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001079{
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001080 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001081
1082 if (status) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001083 hci_conn_check_pending(hdev);
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001084 hci_dev_lock(hdev);
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001085 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Andre Guedes7a135102011-11-09 17:14:25 -03001086 mgmt_start_discovery_failed(hdev, status);
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001087 hci_dev_unlock(hdev);
Johan Hedberg314b2382011-04-27 10:29:57 -04001088 return;
1089 }
1090
Andre Guedes89352e72011-11-04 14:16:53 -03001091 set_bit(HCI_INQUIRY, &hdev->flags);
1092
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001093 hci_dev_lock(hdev);
Andre Guedes343f9352012-02-17 20:39:37 -03001094 hci_discovery_set_state(hdev, DISCOVERY_FINDING);
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001095 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001096}
1097
Gustavo Padovan6039aa72012-05-23 04:04:18 -03001098static void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001100 struct hci_cp_create_conn *cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001103 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001104
1105 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 if (!cp)
1107 return;
1108
1109 hci_dev_lock(hdev);
1110
1111 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
1112
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001113 BT_DBG("%s bdaddr %pMR hcon %p", hdev->name, &cp->bdaddr, conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114
1115 if (status) {
1116 if (conn && conn->state == BT_CONNECT) {
Marcel Holtmann4c67bc72006-10-15 17:30:56 +02001117 if (status != 0x0c || conn->attempt > 2) {
1118 conn->state = BT_CLOSED;
1119 hci_proto_connect_cfm(conn, status);
1120 hci_conn_del(conn);
1121 } else
1122 conn->state = BT_CONNECT2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 }
1124 } else {
1125 if (!conn) {
1126 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
1127 if (conn) {
Johan Hedberga0c808b2012-01-16 09:49:58 +02001128 conn->out = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 conn->link_mode |= HCI_LM_MASTER;
1130 } else
Gustavo F. Padovan893ef972010-07-18 15:13:37 -03001131 BT_ERR("No memory for new connection");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 }
1133 }
1134
1135 hci_dev_unlock(hdev);
1136}
1137
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001138static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001140 struct hci_cp_add_sco *cp;
1141 struct hci_conn *acl, *sco;
1142 __u16 handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001144 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001145
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001146 if (!status)
1147 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001149 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
1150 if (!cp)
1151 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001153 handle = __le16_to_cpu(cp->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001155 BT_DBG("%s handle 0x%4.4x", hdev->name, handle);
Marcel Holtmann6bd57412006-11-18 22:14:22 +01001156
1157 hci_dev_lock(hdev);
1158
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001159 acl = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001160 if (acl) {
1161 sco = acl->link;
1162 if (sco) {
1163 sco->state = BT_CLOSED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001164
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001165 hci_proto_connect_cfm(sco, status);
1166 hci_conn_del(sco);
1167 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001168 }
Marcel Holtmann6bd57412006-11-18 22:14:22 +01001169
1170 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171}
1172
Marcel Holtmannf8558552008-07-14 20:13:49 +02001173static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
1174{
1175 struct hci_cp_auth_requested *cp;
1176 struct hci_conn *conn;
1177
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001178 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmannf8558552008-07-14 20:13:49 +02001179
1180 if (!status)
1181 return;
1182
1183 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
1184 if (!cp)
1185 return;
1186
1187 hci_dev_lock(hdev);
1188
1189 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1190 if (conn) {
1191 if (conn->state == BT_CONFIG) {
1192 hci_proto_connect_cfm(conn, status);
David Herrmann76a68ba2013-04-06 20:28:37 +02001193 hci_conn_drop(conn);
Marcel Holtmannf8558552008-07-14 20:13:49 +02001194 }
1195 }
1196
1197 hci_dev_unlock(hdev);
1198}
1199
1200static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
1201{
1202 struct hci_cp_set_conn_encrypt *cp;
1203 struct hci_conn *conn;
1204
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001205 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmannf8558552008-07-14 20:13:49 +02001206
1207 if (!status)
1208 return;
1209
1210 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
1211 if (!cp)
1212 return;
1213
1214 hci_dev_lock(hdev);
1215
1216 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1217 if (conn) {
1218 if (conn->state == BT_CONFIG) {
1219 hci_proto_connect_cfm(conn, status);
David Herrmann76a68ba2013-04-06 20:28:37 +02001220 hci_conn_drop(conn);
Marcel Holtmannf8558552008-07-14 20:13:49 +02001221 }
1222 }
1223
1224 hci_dev_unlock(hdev);
1225}
1226
Johan Hedberg127178d2010-11-18 22:22:29 +02001227static int hci_outgoing_auth_needed(struct hci_dev *hdev,
Gustavo Padovan807deac2012-05-17 00:36:24 -03001228 struct hci_conn *conn)
Johan Hedberg392599b2010-11-18 22:22:28 +02001229{
Johan Hedberg392599b2010-11-18 22:22:28 +02001230 if (conn->state != BT_CONFIG || !conn->out)
1231 return 0;
1232
Johan Hedberg765c2a92011-01-19 12:06:52 +05301233 if (conn->pending_sec_level == BT_SECURITY_SDP)
Johan Hedberg392599b2010-11-18 22:22:28 +02001234 return 0;
1235
1236 /* Only request authentication for SSP connections or non-SSP
Vinicius Costa Gomese9bf2bf2011-09-02 14:51:20 -03001237 * devices with sec_level HIGH or if MITM protection is requested */
Gustavo Padovan807deac2012-05-17 00:36:24 -03001238 if (!hci_conn_ssp_enabled(conn) && !(conn->auth_type & 0x01) &&
1239 conn->pending_sec_level != BT_SECURITY_HIGH)
Johan Hedberg392599b2010-11-18 22:22:28 +02001240 return 0;
1241
Johan Hedberg392599b2010-11-18 22:22:28 +02001242 return 1;
1243}
1244
Gustavo Padovan6039aa72012-05-23 04:04:18 -03001245static int hci_resolve_name(struct hci_dev *hdev,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001246 struct inquiry_entry *e)
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001247{
1248 struct hci_cp_remote_name_req cp;
1249
1250 memset(&cp, 0, sizeof(cp));
1251
1252 bacpy(&cp.bdaddr, &e->data.bdaddr);
1253 cp.pscan_rep_mode = e->data.pscan_rep_mode;
1254 cp.pscan_mode = e->data.pscan_mode;
1255 cp.clock_offset = e->data.clock_offset;
1256
1257 return hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
1258}
1259
Johan Hedbergb644ba32012-01-17 21:48:47 +02001260static bool hci_resolve_next_name(struct hci_dev *hdev)
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001261{
1262 struct discovery_state *discov = &hdev->discovery;
1263 struct inquiry_entry *e;
1264
Johan Hedbergb644ba32012-01-17 21:48:47 +02001265 if (list_empty(&discov->resolve))
1266 return false;
1267
1268 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY, NAME_NEEDED);
Ram Malovanyc8100892012-07-19 10:26:09 +03001269 if (!e)
1270 return false;
1271
Johan Hedbergb644ba32012-01-17 21:48:47 +02001272 if (hci_resolve_name(hdev, e) == 0) {
1273 e->name_state = NAME_PENDING;
1274 return true;
1275 }
1276
1277 return false;
1278}
1279
1280static void hci_check_pending_name(struct hci_dev *hdev, struct hci_conn *conn,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001281 bdaddr_t *bdaddr, u8 *name, u8 name_len)
Johan Hedbergb644ba32012-01-17 21:48:47 +02001282{
1283 struct discovery_state *discov = &hdev->discovery;
1284 struct inquiry_entry *e;
1285
1286 if (conn && !test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001287 mgmt_device_connected(hdev, bdaddr, ACL_LINK, 0x00, 0, name,
1288 name_len, conn->dev_class);
Johan Hedbergb644ba32012-01-17 21:48:47 +02001289
1290 if (discov->state == DISCOVERY_STOPPED)
1291 return;
1292
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001293 if (discov->state == DISCOVERY_STOPPING)
1294 goto discov_complete;
1295
1296 if (discov->state != DISCOVERY_RESOLVING)
1297 return;
1298
1299 e = hci_inquiry_cache_lookup_resolve(hdev, bdaddr, NAME_PENDING);
Ram Malovany7cc83802012-07-19 10:26:10 +03001300 /* If the device was not found in a list of found devices names of which
1301 * are pending. there is no need to continue resolving a next name as it
1302 * will be done upon receiving another Remote Name Request Complete
1303 * Event */
1304 if (!e)
1305 return;
1306
1307 list_del(&e->list);
1308 if (name) {
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001309 e->name_state = NAME_KNOWN;
Ram Malovany7cc83802012-07-19 10:26:10 +03001310 mgmt_remote_name(hdev, bdaddr, ACL_LINK, 0x00,
1311 e->data.rssi, name, name_len);
Ram Malovanyc3e7c0d2012-07-19 10:26:11 +03001312 } else {
1313 e->name_state = NAME_NOT_KNOWN;
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001314 }
1315
Johan Hedbergb644ba32012-01-17 21:48:47 +02001316 if (hci_resolve_next_name(hdev))
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001317 return;
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001318
1319discov_complete:
1320 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1321}
1322
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001323static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
1324{
Johan Hedberg127178d2010-11-18 22:22:29 +02001325 struct hci_cp_remote_name_req *cp;
1326 struct hci_conn *conn;
1327
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001328 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Johan Hedberg127178d2010-11-18 22:22:29 +02001329
1330 /* If successful wait for the name req complete event before
1331 * checking for the need to do authentication */
1332 if (!status)
1333 return;
1334
1335 cp = hci_sent_cmd_data(hdev, HCI_OP_REMOTE_NAME_REQ);
1336 if (!cp)
1337 return;
1338
1339 hci_dev_lock(hdev);
1340
1341 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
Johan Hedbergb644ba32012-01-17 21:48:47 +02001342
1343 if (test_bit(HCI_MGMT, &hdev->dev_flags))
1344 hci_check_pending_name(hdev, conn, &cp->bdaddr, NULL, 0);
1345
Johan Hedberg79c6c702011-04-28 11:28:55 -07001346 if (!conn)
1347 goto unlock;
1348
1349 if (!hci_outgoing_auth_needed(hdev, conn))
1350 goto unlock;
1351
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001352 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02001353 struct hci_cp_auth_requested cp;
1354 cp.handle = __cpu_to_le16(conn->handle);
1355 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
1356 }
1357
Johan Hedberg79c6c702011-04-28 11:28:55 -07001358unlock:
Johan Hedberg127178d2010-11-18 22:22:29 +02001359 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001360}
1361
Marcel Holtmann769be972008-07-14 20:13:49 +02001362static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
1363{
1364 struct hci_cp_read_remote_features *cp;
1365 struct hci_conn *conn;
1366
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001367 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmann769be972008-07-14 20:13:49 +02001368
1369 if (!status)
1370 return;
1371
1372 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
1373 if (!cp)
1374 return;
1375
1376 hci_dev_lock(hdev);
1377
1378 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1379 if (conn) {
1380 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001381 hci_proto_connect_cfm(conn, status);
David Herrmann76a68ba2013-04-06 20:28:37 +02001382 hci_conn_drop(conn);
Marcel Holtmann769be972008-07-14 20:13:49 +02001383 }
1384 }
1385
1386 hci_dev_unlock(hdev);
1387}
1388
1389static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
1390{
1391 struct hci_cp_read_remote_ext_features *cp;
1392 struct hci_conn *conn;
1393
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001394 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmann769be972008-07-14 20:13:49 +02001395
1396 if (!status)
1397 return;
1398
1399 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
1400 if (!cp)
1401 return;
1402
1403 hci_dev_lock(hdev);
1404
1405 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1406 if (conn) {
1407 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001408 hci_proto_connect_cfm(conn, status);
David Herrmann76a68ba2013-04-06 20:28:37 +02001409 hci_conn_drop(conn);
Marcel Holtmann769be972008-07-14 20:13:49 +02001410 }
1411 }
1412
1413 hci_dev_unlock(hdev);
1414}
1415
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001416static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
1417{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001418 struct hci_cp_setup_sync_conn *cp;
1419 struct hci_conn *acl, *sco;
1420 __u16 handle;
1421
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001422 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001423
1424 if (!status)
1425 return;
1426
1427 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
1428 if (!cp)
1429 return;
1430
1431 handle = __le16_to_cpu(cp->handle);
1432
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001433 BT_DBG("%s handle 0x%4.4x", hdev->name, handle);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001434
1435 hci_dev_lock(hdev);
1436
1437 acl = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001438 if (acl) {
1439 sco = acl->link;
1440 if (sco) {
1441 sco->state = BT_CLOSED;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001442
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001443 hci_proto_connect_cfm(sco, status);
1444 hci_conn_del(sco);
1445 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001446 }
1447
1448 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001449}
1450
1451static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
1452{
1453 struct hci_cp_sniff_mode *cp;
1454 struct hci_conn *conn;
1455
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001456 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001457
1458 if (!status)
1459 return;
1460
1461 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
1462 if (!cp)
1463 return;
1464
1465 hci_dev_lock(hdev);
1466
1467 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001468 if (conn) {
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001469 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001470
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001471 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001472 hci_sco_setup(conn, status);
1473 }
1474
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001475 hci_dev_unlock(hdev);
1476}
1477
1478static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
1479{
1480 struct hci_cp_exit_sniff_mode *cp;
1481 struct hci_conn *conn;
1482
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001483 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001484
1485 if (!status)
1486 return;
1487
1488 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
1489 if (!cp)
1490 return;
1491
1492 hci_dev_lock(hdev);
1493
1494 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001495 if (conn) {
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001496 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001497
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001498 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001499 hci_sco_setup(conn, status);
1500 }
1501
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001502 hci_dev_unlock(hdev);
1503}
1504
Johan Hedberg88c3df12012-02-09 14:27:38 +02001505static void hci_cs_disconnect(struct hci_dev *hdev, u8 status)
1506{
1507 struct hci_cp_disconnect *cp;
1508 struct hci_conn *conn;
1509
1510 if (!status)
1511 return;
1512
1513 cp = hci_sent_cmd_data(hdev, HCI_OP_DISCONNECT);
1514 if (!cp)
1515 return;
1516
1517 hci_dev_lock(hdev);
1518
1519 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1520 if (conn)
1521 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001522 conn->dst_type, status);
Johan Hedberg88c3df12012-02-09 14:27:38 +02001523
1524 hci_dev_unlock(hdev);
1525}
1526
Ville Tervofcd89c02011-02-10 22:38:47 -03001527static void hci_cs_le_create_conn(struct hci_dev *hdev, __u8 status)
1528{
Ville Tervofcd89c02011-02-10 22:38:47 -03001529 struct hci_conn *conn;
1530
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001531 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Ville Tervofcd89c02011-02-10 22:38:47 -03001532
Ville Tervofcd89c02011-02-10 22:38:47 -03001533 if (status) {
Andre Guedesf00a06a2012-07-27 15:10:13 -03001534 hci_dev_lock(hdev);
Ville Tervofcd89c02011-02-10 22:38:47 -03001535
Andre Guedes0c95ab72012-07-27 15:10:14 -03001536 conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
Andre Guedesf00a06a2012-07-27 15:10:13 -03001537 if (!conn) {
1538 hci_dev_unlock(hdev);
1539 return;
1540 }
1541
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001542 BT_DBG("%s bdaddr %pMR conn %p", hdev->name, &conn->dst, conn);
Andre Guedesf00a06a2012-07-27 15:10:13 -03001543
1544 conn->state = BT_CLOSED;
Andre Guedes0c95ab72012-07-27 15:10:14 -03001545 mgmt_connect_failed(hdev, &conn->dst, conn->type,
Andre Guedesf00a06a2012-07-27 15:10:13 -03001546 conn->dst_type, status);
1547 hci_proto_connect_cfm(conn, status);
1548 hci_conn_del(conn);
1549
1550 hci_dev_unlock(hdev);
1551 }
Ville Tervofcd89c02011-02-10 22:38:47 -03001552}
1553
Andrei Emeltchenkoa02226d2012-09-27 17:26:19 +03001554static void hci_cs_create_phylink(struct hci_dev *hdev, u8 status)
1555{
Andrei Emeltchenko93c284e2012-09-27 17:26:20 +03001556 struct hci_cp_create_phy_link *cp;
1557
Andrei Emeltchenkoa02226d2012-09-27 17:26:19 +03001558 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Andrei Emeltchenko93c284e2012-09-27 17:26:20 +03001559
Andrei Emeltchenko93c284e2012-09-27 17:26:20 +03001560 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_PHY_LINK);
1561 if (!cp)
1562 return;
1563
Andrei Emeltchenkoe58917b2012-10-31 15:46:33 +02001564 hci_dev_lock(hdev);
1565
1566 if (status) {
1567 struct hci_conn *hcon;
1568
1569 hcon = hci_conn_hash_lookup_handle(hdev, cp->phy_handle);
1570 if (hcon)
1571 hci_conn_del(hcon);
1572 } else {
1573 amp_write_remote_assoc(hdev, cp->phy_handle);
1574 }
1575
1576 hci_dev_unlock(hdev);
Andrei Emeltchenkoa02226d2012-09-27 17:26:19 +03001577}
1578
Andrei Emeltchenko0b26ab92012-09-27 17:26:24 +03001579static void hci_cs_accept_phylink(struct hci_dev *hdev, u8 status)
1580{
1581 struct hci_cp_accept_phy_link *cp;
1582
1583 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1584
1585 if (status)
1586 return;
1587
1588 cp = hci_sent_cmd_data(hdev, HCI_OP_ACCEPT_PHY_LINK);
1589 if (!cp)
1590 return;
1591
1592 amp_write_remote_assoc(hdev, cp->phy_handle);
1593}
1594
Gustavo Padovan6039aa72012-05-23 04:04:18 -03001595static void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001596{
1597 __u8 status = *((__u8 *) skb->data);
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001598 struct discovery_state *discov = &hdev->discovery;
1599 struct inquiry_entry *e;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001600
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001601 BT_DBG("%s status 0x%2.2x", hdev->name, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001602
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001603 hci_conn_check_pending(hdev);
Andre Guedes89352e72011-11-04 14:16:53 -03001604
1605 if (!test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
1606 return;
1607
Andre Guedes3e13fa12013-03-27 20:04:56 -03001608 smp_mb__after_clear_bit(); /* wake_up_bit advises about this barrier */
1609 wake_up_bit(&hdev->flags, HCI_INQUIRY);
1610
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02001611 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001612 return;
1613
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001614 hci_dev_lock(hdev);
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001615
Andre Guedes343f9352012-02-17 20:39:37 -03001616 if (discov->state != DISCOVERY_FINDING)
Johan Hedberg30dc78e2012-01-04 15:44:20 +02001617 goto unlock;
1618
1619 if (list_empty(&discov->resolve)) {
1620 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1621 goto unlock;
1622 }
1623
1624 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY, NAME_NEEDED);
1625 if (e && hci_resolve_name(hdev, e) == 0) {
1626 e->name_state = NAME_PENDING;
1627 hci_discovery_set_state(hdev, DISCOVERY_RESOLVING);
1628 } else {
1629 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1630 }
1631
1632unlock:
Johan Hedberg56e5cb82011-11-08 20:40:16 +02001633 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001634}
1635
Gustavo Padovan6039aa72012-05-23 04:04:18 -03001636static void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637{
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001638 struct inquiry_data data;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001639 struct inquiry_info *info = (void *) (skb->data + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 int num_rsp = *((__u8 *) skb->data);
1641
1642 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1643
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001644 if (!num_rsp)
1645 return;
1646
Andre Guedes1519cc12012-03-21 00:03:38 -03001647 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
1648 return;
1649
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001651
Johan Hedberge17acd42011-03-30 23:57:16 +03001652 for (; num_rsp; num_rsp--, info++) {
Johan Hedberg388fc8f2012-02-23 00:38:59 +02001653 bool name_known, ssp;
Johan Hedberg31754052012-01-04 13:39:52 +02001654
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 bacpy(&data.bdaddr, &info->bdaddr);
1656 data.pscan_rep_mode = info->pscan_rep_mode;
1657 data.pscan_period_mode = info->pscan_period_mode;
1658 data.pscan_mode = info->pscan_mode;
1659 memcpy(data.dev_class, info->dev_class, 3);
1660 data.clock_offset = info->clock_offset;
1661 data.rssi = 0x00;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001662 data.ssp_mode = 0x00;
Johan Hedberg31754052012-01-04 13:39:52 +02001663
Johan Hedberg388fc8f2012-02-23 00:38:59 +02001664 name_known = hci_inquiry_cache_update(hdev, &data, false, &ssp);
Johan Hedberg48264f02011-11-09 13:58:58 +02001665 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001666 info->dev_class, 0, !name_known, ssp, NULL,
1667 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001669
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 hci_dev_unlock(hdev);
1671}
1672
Gustavo Padovan6039aa72012-05-23 04:04:18 -03001673static void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001675 struct hci_ev_conn_complete *ev = (void *) skb->data;
1676 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001678 BT_DBG("%s", hdev->name);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001679
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001681
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001682 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann94992372009-04-19 19:30:03 +02001683 if (!conn) {
1684 if (ev->link_type != SCO_LINK)
1685 goto unlock;
1686
1687 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1688 if (!conn)
1689 goto unlock;
1690
1691 conn->type = SCO_LINK;
1692 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001693
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001694 if (!ev->status) {
1695 conn->handle = __le16_to_cpu(ev->handle);
Marcel Holtmann769be972008-07-14 20:13:49 +02001696
1697 if (conn->type == ACL_LINK) {
1698 conn->state = BT_CONFIG;
1699 hci_conn_hold(conn);
Szymon Janca9ea3ed2012-07-19 14:46:08 +02001700
1701 if (!conn->out && !hci_conn_ssp_enabled(conn) &&
1702 !hci_find_link_key(hdev, &ev->bdaddr))
1703 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
1704 else
1705 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann769be972008-07-14 20:13:49 +02001706 } else
1707 conn->state = BT_CONNECTED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001708
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001709 hci_conn_add_sysfs(conn);
1710
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001711 if (test_bit(HCI_AUTH, &hdev->flags))
1712 conn->link_mode |= HCI_LM_AUTH;
1713
1714 if (test_bit(HCI_ENCRYPT, &hdev->flags))
1715 conn->link_mode |= HCI_LM_ENCRYPT;
1716
1717 /* Get remote features */
1718 if (conn->type == ACL_LINK) {
1719 struct hci_cp_read_remote_features cp;
1720 cp.handle = ev->handle;
Marcel Holtmann769be972008-07-14 20:13:49 +02001721 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001722 sizeof(cp), &cp);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001723 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001724
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001725 /* Set packet type for incoming connection */
Andrei Emeltchenkod095c1e2011-12-01 14:33:27 +02001726 if (!conn->out && hdev->hci_ver < BLUETOOTH_VER_2_0) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001727 struct hci_cp_change_conn_ptype cp;
1728 cp.handle = ev->handle;
Marcel Holtmanna8746412008-07-14 20:13:46 +02001729 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001730 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE, sizeof(cp),
1731 &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001732 }
Johan Hedberg17d5c042011-01-22 06:09:08 +02001733 } else {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001734 conn->state = BT_CLOSED;
Johan Hedberg17d5c042011-01-22 06:09:08 +02001735 if (conn->type == ACL_LINK)
Johan Hedberg744cf192011-11-08 20:40:14 +02001736 mgmt_connect_failed(hdev, &ev->bdaddr, conn->type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001737 conn->dst_type, ev->status);
Johan Hedberg17d5c042011-01-22 06:09:08 +02001738 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001739
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001740 if (conn->type == ACL_LINK)
1741 hci_sco_setup(conn, ev->status);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001742
Marcel Holtmann769be972008-07-14 20:13:49 +02001743 if (ev->status) {
1744 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001745 hci_conn_del(conn);
Marcel Holtmannc89b6e62009-01-15 21:57:03 +01001746 } else if (ev->link_type != ACL_LINK)
1747 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001748
1749unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001751
1752 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753}
1754
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001755void hci_conn_accept(struct hci_conn *conn, int mask)
1756{
1757 struct hci_dev *hdev = conn->hdev;
1758
1759 BT_DBG("conn %p", conn);
1760
1761 conn->state = BT_CONFIG;
1762
1763 if (!lmp_esco_capable(hdev)) {
1764 struct hci_cp_accept_conn_req cp;
1765
1766 bacpy(&cp.bdaddr, &conn->dst);
1767
1768 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
1769 cp.role = 0x00; /* Become master */
1770 else
1771 cp.role = 0x01; /* Remain slave */
1772
1773 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
1774 } else /* lmp_esco_capable(hdev)) */ {
1775 struct hci_cp_accept_sync_conn_req cp;
1776
1777 bacpy(&cp.bdaddr, &conn->dst);
1778 cp.pkt_type = cpu_to_le16(conn->pkt_type);
1779
1780 cp.tx_bandwidth = __constant_cpu_to_le32(0x00001f40);
1781 cp.rx_bandwidth = __constant_cpu_to_le32(0x00001f40);
1782 cp.max_latency = __constant_cpu_to_le16(0xffff);
1783 cp.content_format = cpu_to_le16(hdev->voice_setting);
1784 cp.retrans_effort = 0xff;
1785
1786 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
1787 sizeof(cp), &cp);
1788 }
1789}
1790
Gustavo Padovan6039aa72012-05-23 04:04:18 -03001791static void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001793 struct hci_ev_conn_request *ev = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 int mask = hdev->link_mode;
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001795 __u8 flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03001797 BT_DBG("%s bdaddr %pMR type 0x%x", hdev->name, &ev->bdaddr,
Gustavo Padovan807deac2012-05-17 00:36:24 -03001798 ev->link_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001800 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type,
1801 &flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802
Szymon Janc138d22e2011-02-17 16:44:23 +01001803 if ((mask & HCI_LM_ACCEPT) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03001804 !hci_blacklist_lookup(hdev, &ev->bdaddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 /* Connection accepted */
Marcel Holtmannc7bdd502008-07-14 20:13:47 +02001806 struct inquiry_entry *ie;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808
1809 hci_dev_lock(hdev);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001810
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02001811 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
1812 if (ie)
Marcel Holtmannc7bdd502008-07-14 20:13:47 +02001813 memcpy(ie->data.dev_class, ev->dev_class, 3);
1814
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03001815 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type,
1816 &ev->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 if (!conn) {
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02001818 conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr);
1819 if (!conn) {
Gustavo F. Padovan893ef972010-07-18 15:13:37 -03001820 BT_ERR("No memory for new connection");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 hci_dev_unlock(hdev);
1822 return;
1823 }
1824 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001825
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 memcpy(conn->dev_class, ev->dev_class, 3);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001827
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 hci_dev_unlock(hdev);
1829
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001830 if (ev->link_type == ACL_LINK ||
1831 (!(flags & HCI_PROTO_DEFER) && !lmp_esco_capable(hdev))) {
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001832 struct hci_cp_accept_conn_req cp;
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001833 conn->state = BT_CONNECT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001835 bacpy(&cp.bdaddr, &ev->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001837 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
1838 cp.role = 0x00; /* Become master */
1839 else
1840 cp.role = 0x01; /* Remain slave */
1841
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001842 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp),
1843 &cp);
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001844 } else if (!(flags & HCI_PROTO_DEFER)) {
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001845 struct hci_cp_accept_sync_conn_req cp;
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001846 conn->state = BT_CONNECT;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001847
1848 bacpy(&cp.bdaddr, &ev->bdaddr);
Marcel Holtmanna8746412008-07-14 20:13:46 +02001849 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001850
Andrei Emeltchenko82781e62012-05-25 11:38:27 +03001851 cp.tx_bandwidth = __constant_cpu_to_le32(0x00001f40);
1852 cp.rx_bandwidth = __constant_cpu_to_le32(0x00001f40);
1853 cp.max_latency = __constant_cpu_to_le16(0xffff);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001854 cp.content_format = cpu_to_le16(hdev->voice_setting);
1855 cp.retrans_effort = 0xff;
1856
1857 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001858 sizeof(cp), &cp);
Frédéric Dalleau20714bf2012-11-21 10:51:12 +01001859 } else {
1860 conn->state = BT_CONNECT2;
1861 hci_proto_connect_cfm(conn, 0);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001862 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 } else {
1864 /* Connection rejected */
1865 struct hci_cp_reject_conn_req cp;
1866
1867 bacpy(&cp.bdaddr, &ev->bdaddr);
Andrei Emeltchenko9f5a0d72011-11-07 14:20:25 +02001868 cp.reason = HCI_ERROR_REJ_BAD_ADDR;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001869 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 }
1871}
1872
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02001873static u8 hci_to_mgmt_reason(u8 err)
1874{
1875 switch (err) {
1876 case HCI_ERROR_CONNECTION_TIMEOUT:
1877 return MGMT_DEV_DISCONN_TIMEOUT;
1878 case HCI_ERROR_REMOTE_USER_TERM:
1879 case HCI_ERROR_REMOTE_LOW_RESOURCES:
1880 case HCI_ERROR_REMOTE_POWER_OFF:
1881 return MGMT_DEV_DISCONN_REMOTE;
1882 case HCI_ERROR_LOCAL_HOST_TERM:
1883 return MGMT_DEV_DISCONN_LOCAL_HOST;
1884 default:
1885 return MGMT_DEV_DISCONN_UNKNOWN;
1886 }
1887}
1888
Gustavo Padovan6039aa72012-05-23 04:04:18 -03001889static void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001891 struct hci_ev_disconn_complete *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001892 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001894 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 hci_dev_lock(hdev);
1897
Marcel Holtmann04837f62006-07-03 10:02:33 +02001898 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergf7520542011-01-20 12:34:39 +02001899 if (!conn)
1900 goto unlock;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001901
Johan Hedberg37d9ef72011-11-10 15:54:39 +02001902 if (ev->status == 0)
1903 conn->state = BT_CLOSED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904
Johan Hedbergb644ba32012-01-17 21:48:47 +02001905 if (test_and_clear_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03001906 (conn->type == ACL_LINK || conn->type == LE_LINK)) {
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02001907 if (ev->status) {
Johan Hedberg88c3df12012-02-09 14:27:38 +02001908 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
Gustavo Padovan807deac2012-05-17 00:36:24 -03001909 conn->dst_type, ev->status);
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02001910 } else {
1911 u8 reason = hci_to_mgmt_reason(ev->reason);
1912
Johan Hedbergafc747a2012-01-15 18:11:07 +02001913 mgmt_device_disconnected(hdev, &conn->dst, conn->type,
Mikel Astizf0d6a0e2012-08-09 09:52:30 +02001914 conn->dst_type, reason);
1915 }
Johan Hedberg37d9ef72011-11-10 15:54:39 +02001916 }
Johan Hedbergf7520542011-01-20 12:34:39 +02001917
Johan Hedberg37d9ef72011-11-10 15:54:39 +02001918 if (ev->status == 0) {
Vishal Agarwal6ec5bca2012-04-16 14:44:44 +05301919 if (conn->type == ACL_LINK && conn->flush_key)
1920 hci_remove_link_key(hdev, &conn->dst);
Johan Hedberg37d9ef72011-11-10 15:54:39 +02001921 hci_proto_disconn_cfm(conn, ev->reason);
1922 hci_conn_del(conn);
1923 }
Johan Hedbergf7520542011-01-20 12:34:39 +02001924
1925unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 hci_dev_unlock(hdev);
1927}
1928
Gustavo Padovan6039aa72012-05-23 04:04:18 -03001929static void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001930{
1931 struct hci_ev_auth_complete *ev = (void *) skb->data;
1932 struct hci_conn *conn;
1933
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03001934 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001935
1936 hci_dev_lock(hdev);
1937
1938 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001939 if (!conn)
1940 goto unlock;
1941
1942 if (!ev->status) {
Johan Hedbergaa64a8b2012-01-18 21:33:12 +02001943 if (!hci_conn_ssp_enabled(conn) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03001944 test_bit(HCI_CONN_REAUTH_PEND, &conn->flags)) {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001945 BT_INFO("re-auth of legacy device is not possible.");
Johan Hedberg2a611692011-02-19 12:06:00 -03001946 } else {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001947 conn->link_mode |= HCI_LM_AUTH;
1948 conn->sec_level = conn->pending_sec_level;
Johan Hedberg2a611692011-02-19 12:06:00 -03001949 }
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001950 } else {
Johan Hedbergbab73cb2012-02-09 16:07:29 +02001951 mgmt_auth_failed(hdev, &conn->dst, conn->type, conn->dst_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03001952 ev->status);
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001953 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001954
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001955 clear_bit(HCI_CONN_AUTH_PEND, &conn->flags);
1956 clear_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001957
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001958 if (conn->state == BT_CONFIG) {
Johan Hedbergaa64a8b2012-01-18 21:33:12 +02001959 if (!ev->status && hci_conn_ssp_enabled(conn)) {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001960 struct hci_cp_set_conn_encrypt cp;
1961 cp.handle = ev->handle;
1962 cp.encrypt = 0x01;
1963 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
Gustavo Padovan807deac2012-05-17 00:36:24 -03001964 &cp);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001965 } else {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001966 conn->state = BT_CONNECTED;
1967 hci_proto_connect_cfm(conn, ev->status);
David Herrmann76a68ba2013-04-06 20:28:37 +02001968 hci_conn_drop(conn);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001969 }
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001970 } else {
1971 hci_auth_cfm(conn, ev->status);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001972
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001973 hci_conn_hold(conn);
1974 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
David Herrmann76a68ba2013-04-06 20:28:37 +02001975 hci_conn_drop(conn);
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001976 }
1977
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001978 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001979 if (!ev->status) {
1980 struct hci_cp_set_conn_encrypt cp;
1981 cp.handle = ev->handle;
1982 cp.encrypt = 0x01;
1983 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
Gustavo Padovan807deac2012-05-17 00:36:24 -03001984 &cp);
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001985 } else {
Johan Hedberg51a8efd2012-01-16 06:10:31 +02001986 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001987 hci_encrypt_cfm(conn, ev->status, 0x00);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001988 }
1989 }
1990
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001991unlock:
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001992 hci_dev_unlock(hdev);
1993}
1994
Gustavo Padovan6039aa72012-05-23 04:04:18 -03001995static void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001996{
Johan Hedberg127178d2010-11-18 22:22:29 +02001997 struct hci_ev_remote_name *ev = (void *) skb->data;
1998 struct hci_conn *conn;
1999
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002000 BT_DBG("%s", hdev->name);
2001
2002 hci_conn_check_pending(hdev);
Johan Hedberg127178d2010-11-18 22:22:29 +02002003
2004 hci_dev_lock(hdev);
2005
2006 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedbergb644ba32012-01-17 21:48:47 +02002007
2008 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
2009 goto check_auth;
2010
2011 if (ev->status == 0)
2012 hci_check_pending_name(hdev, conn, &ev->bdaddr, ev->name,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002013 strnlen(ev->name, HCI_MAX_NAME_LENGTH));
Johan Hedbergb644ba32012-01-17 21:48:47 +02002014 else
2015 hci_check_pending_name(hdev, conn, &ev->bdaddr, NULL, 0);
2016
2017check_auth:
Johan Hedberg79c6c702011-04-28 11:28:55 -07002018 if (!conn)
2019 goto unlock;
2020
2021 if (!hci_outgoing_auth_needed(hdev, conn))
2022 goto unlock;
2023
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002024 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02002025 struct hci_cp_auth_requested cp;
2026 cp.handle = __cpu_to_le16(conn->handle);
2027 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
2028 }
2029
Johan Hedberg79c6c702011-04-28 11:28:55 -07002030unlock:
Johan Hedberg127178d2010-11-18 22:22:29 +02002031 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002032}
2033
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002034static void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002035{
2036 struct hci_ev_encrypt_change *ev = (void *) skb->data;
2037 struct hci_conn *conn;
2038
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002039 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002040
2041 hci_dev_lock(hdev);
2042
2043 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2044 if (conn) {
2045 if (!ev->status) {
Marcel Holtmannae293192008-07-14 20:13:45 +02002046 if (ev->encrypt) {
2047 /* Encryption implies authentication */
2048 conn->link_mode |= HCI_LM_AUTH;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002049 conn->link_mode |= HCI_LM_ENCRYPT;
Vinicius Costa Gomesda85e5e2011-06-09 18:50:53 -03002050 conn->sec_level = conn->pending_sec_level;
Marcel Holtmannae293192008-07-14 20:13:45 +02002051 } else
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002052 conn->link_mode &= ~HCI_LM_ENCRYPT;
2053 }
2054
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002055 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002056
Gustavo Padovana7d77232012-05-13 03:20:07 -03002057 if (ev->status && conn->state == BT_CONNECTED) {
Andre Guedesbed71742013-01-30 11:50:56 -03002058 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
David Herrmann76a68ba2013-04-06 20:28:37 +02002059 hci_conn_drop(conn);
Gustavo Padovana7d77232012-05-13 03:20:07 -03002060 goto unlock;
2061 }
2062
Marcel Holtmannf8558552008-07-14 20:13:49 +02002063 if (conn->state == BT_CONFIG) {
2064 if (!ev->status)
2065 conn->state = BT_CONNECTED;
2066
2067 hci_proto_connect_cfm(conn, ev->status);
David Herrmann76a68ba2013-04-06 20:28:37 +02002068 hci_conn_drop(conn);
Marcel Holtmannf8558552008-07-14 20:13:49 +02002069 } else
2070 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002071 }
2072
Gustavo Padovana7d77232012-05-13 03:20:07 -03002073unlock:
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002074 hci_dev_unlock(hdev);
2075}
2076
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002077static void hci_change_link_key_complete_evt(struct hci_dev *hdev,
2078 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002079{
2080 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
2081 struct hci_conn *conn;
2082
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002083 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002084
2085 hci_dev_lock(hdev);
2086
2087 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2088 if (conn) {
2089 if (!ev->status)
2090 conn->link_mode |= HCI_LM_SECURE;
2091
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002092 clear_bit(HCI_CONN_AUTH_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002093
2094 hci_key_change_cfm(conn, ev->status);
2095 }
2096
2097 hci_dev_unlock(hdev);
2098}
2099
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002100static void hci_remote_features_evt(struct hci_dev *hdev,
2101 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002102{
2103 struct hci_ev_remote_features *ev = (void *) skb->data;
2104 struct hci_conn *conn;
2105
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002106 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002107
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002108 hci_dev_lock(hdev);
2109
2110 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergccd556f2010-11-10 17:11:51 +02002111 if (!conn)
2112 goto unlock;
Marcel Holtmann769be972008-07-14 20:13:49 +02002113
Johan Hedbergccd556f2010-11-10 17:11:51 +02002114 if (!ev->status)
2115 memcpy(conn->features, ev->features, 8);
2116
2117 if (conn->state != BT_CONFIG)
2118 goto unlock;
2119
2120 if (!ev->status && lmp_ssp_capable(hdev) && lmp_ssp_capable(conn)) {
2121 struct hci_cp_read_remote_ext_features cp;
2122 cp.handle = ev->handle;
2123 cp.page = 0x01;
2124 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES,
Gustavo Padovan807deac2012-05-17 00:36:24 -03002125 sizeof(cp), &cp);
Johan Hedberg392599b2010-11-18 22:22:28 +02002126 goto unlock;
2127 }
2128
Johan Hedberg671267b2012-05-12 16:11:50 -03002129 if (!ev->status && !test_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02002130 struct hci_cp_remote_name_req cp;
2131 memset(&cp, 0, sizeof(cp));
2132 bacpy(&cp.bdaddr, &conn->dst);
2133 cp.pscan_rep_mode = 0x02;
2134 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
Johan Hedbergb644ba32012-01-17 21:48:47 +02002135 } else if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
2136 mgmt_device_connected(hdev, &conn->dst, conn->type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002137 conn->dst_type, 0, NULL, 0,
2138 conn->dev_class);
Johan Hedberg392599b2010-11-18 22:22:28 +02002139
Johan Hedberg127178d2010-11-18 22:22:29 +02002140 if (!hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedbergccd556f2010-11-10 17:11:51 +02002141 conn->state = BT_CONNECTED;
2142 hci_proto_connect_cfm(conn, ev->status);
David Herrmann76a68ba2013-04-06 20:28:37 +02002143 hci_conn_drop(conn);
Marcel Holtmann769be972008-07-14 20:13:49 +02002144 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002145
Johan Hedbergccd556f2010-11-10 17:11:51 +02002146unlock:
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002147 hci_dev_unlock(hdev);
2148}
2149
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002150static void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002151{
2152 struct hci_ev_cmd_complete *ev = (void *) skb->data;
Johan Hedberg9238f362013-03-05 20:37:48 +02002153 u8 status = skb->data[sizeof(*ev)];
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002154 __u16 opcode;
2155
2156 skb_pull(skb, sizeof(*ev));
2157
2158 opcode = __le16_to_cpu(ev->opcode);
2159
2160 switch (opcode) {
2161 case HCI_OP_INQUIRY_CANCEL:
2162 hci_cc_inquiry_cancel(hdev, skb);
2163 break;
2164
Andre Guedes4d934832012-03-21 00:03:35 -03002165 case HCI_OP_PERIODIC_INQ:
2166 hci_cc_periodic_inq(hdev, skb);
2167 break;
2168
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002169 case HCI_OP_EXIT_PERIODIC_INQ:
2170 hci_cc_exit_periodic_inq(hdev, skb);
2171 break;
2172
2173 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
2174 hci_cc_remote_name_req_cancel(hdev, skb);
2175 break;
2176
2177 case HCI_OP_ROLE_DISCOVERY:
2178 hci_cc_role_discovery(hdev, skb);
2179 break;
2180
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02002181 case HCI_OP_READ_LINK_POLICY:
2182 hci_cc_read_link_policy(hdev, skb);
2183 break;
2184
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002185 case HCI_OP_WRITE_LINK_POLICY:
2186 hci_cc_write_link_policy(hdev, skb);
2187 break;
2188
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02002189 case HCI_OP_READ_DEF_LINK_POLICY:
2190 hci_cc_read_def_link_policy(hdev, skb);
2191 break;
2192
2193 case HCI_OP_WRITE_DEF_LINK_POLICY:
2194 hci_cc_write_def_link_policy(hdev, skb);
2195 break;
2196
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002197 case HCI_OP_RESET:
2198 hci_cc_reset(hdev, skb);
2199 break;
2200
2201 case HCI_OP_WRITE_LOCAL_NAME:
2202 hci_cc_write_local_name(hdev, skb);
2203 break;
2204
2205 case HCI_OP_READ_LOCAL_NAME:
2206 hci_cc_read_local_name(hdev, skb);
2207 break;
2208
2209 case HCI_OP_WRITE_AUTH_ENABLE:
2210 hci_cc_write_auth_enable(hdev, skb);
2211 break;
2212
2213 case HCI_OP_WRITE_ENCRYPT_MODE:
2214 hci_cc_write_encrypt_mode(hdev, skb);
2215 break;
2216
2217 case HCI_OP_WRITE_SCAN_ENABLE:
2218 hci_cc_write_scan_enable(hdev, skb);
2219 break;
2220
2221 case HCI_OP_READ_CLASS_OF_DEV:
2222 hci_cc_read_class_of_dev(hdev, skb);
2223 break;
2224
2225 case HCI_OP_WRITE_CLASS_OF_DEV:
2226 hci_cc_write_class_of_dev(hdev, skb);
2227 break;
2228
2229 case HCI_OP_READ_VOICE_SETTING:
2230 hci_cc_read_voice_setting(hdev, skb);
2231 break;
2232
2233 case HCI_OP_WRITE_VOICE_SETTING:
2234 hci_cc_write_voice_setting(hdev, skb);
2235 break;
2236
Marcel Holtmann333140b2008-07-14 20:13:48 +02002237 case HCI_OP_WRITE_SSP_MODE:
2238 hci_cc_write_ssp_mode(hdev, skb);
2239 break;
2240
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002241 case HCI_OP_READ_LOCAL_VERSION:
2242 hci_cc_read_local_version(hdev, skb);
2243 break;
2244
2245 case HCI_OP_READ_LOCAL_COMMANDS:
2246 hci_cc_read_local_commands(hdev, skb);
2247 break;
2248
2249 case HCI_OP_READ_LOCAL_FEATURES:
2250 hci_cc_read_local_features(hdev, skb);
2251 break;
2252
Andre Guedes971e3a42011-06-30 19:20:52 -03002253 case HCI_OP_READ_LOCAL_EXT_FEATURES:
2254 hci_cc_read_local_ext_features(hdev, skb);
2255 break;
2256
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002257 case HCI_OP_READ_BUFFER_SIZE:
2258 hci_cc_read_buffer_size(hdev, skb);
2259 break;
2260
2261 case HCI_OP_READ_BD_ADDR:
2262 hci_cc_read_bd_addr(hdev, skb);
2263 break;
2264
Johan Hedbergf332ec62013-03-15 17:07:11 -05002265 case HCI_OP_READ_PAGE_SCAN_ACTIVITY:
2266 hci_cc_read_page_scan_activity(hdev, skb);
2267 break;
2268
Johan Hedberg4a3ee762013-03-15 17:07:12 -05002269 case HCI_OP_WRITE_PAGE_SCAN_ACTIVITY:
2270 hci_cc_write_page_scan_activity(hdev, skb);
2271 break;
2272
Johan Hedbergf332ec62013-03-15 17:07:11 -05002273 case HCI_OP_READ_PAGE_SCAN_TYPE:
2274 hci_cc_read_page_scan_type(hdev, skb);
2275 break;
2276
Johan Hedberg4a3ee762013-03-15 17:07:12 -05002277 case HCI_OP_WRITE_PAGE_SCAN_TYPE:
2278 hci_cc_write_page_scan_type(hdev, skb);
2279 break;
2280
Andrei Emeltchenko350ee4c2011-12-07 15:56:51 +02002281 case HCI_OP_READ_DATA_BLOCK_SIZE:
2282 hci_cc_read_data_block_size(hdev, skb);
2283 break;
2284
Andrei Emeltchenko1e89cff2011-11-24 14:52:02 +02002285 case HCI_OP_READ_FLOW_CONTROL_MODE:
2286 hci_cc_read_flow_control_mode(hdev, skb);
2287 break;
2288
Andrei Emeltchenko928abaa2011-10-12 10:53:57 +03002289 case HCI_OP_READ_LOCAL_AMP_INFO:
2290 hci_cc_read_local_amp_info(hdev, skb);
2291 break;
2292
Andrei Emeltchenko903e4542012-09-27 17:26:09 +03002293 case HCI_OP_READ_LOCAL_AMP_ASSOC:
2294 hci_cc_read_local_amp_assoc(hdev, skb);
2295 break;
2296
Johan Hedbergd5859e22011-01-25 01:19:58 +02002297 case HCI_OP_READ_INQ_RSP_TX_POWER:
2298 hci_cc_read_inq_rsp_tx_power(hdev, skb);
2299 break;
2300
Johan Hedberg980e1a52011-01-22 06:10:07 +02002301 case HCI_OP_PIN_CODE_REPLY:
2302 hci_cc_pin_code_reply(hdev, skb);
2303 break;
2304
2305 case HCI_OP_PIN_CODE_NEG_REPLY:
2306 hci_cc_pin_code_neg_reply(hdev, skb);
2307 break;
2308
Szymon Jancc35938b2011-03-22 13:12:21 +01002309 case HCI_OP_READ_LOCAL_OOB_DATA:
2310 hci_cc_read_local_oob_data_reply(hdev, skb);
2311 break;
2312
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002313 case HCI_OP_LE_READ_BUFFER_SIZE:
2314 hci_cc_le_read_buffer_size(hdev, skb);
2315 break;
2316
Johan Hedberg60e77322013-01-22 14:01:59 +02002317 case HCI_OP_LE_READ_LOCAL_FEATURES:
2318 hci_cc_le_read_local_features(hdev, skb);
2319 break;
2320
Johan Hedberg8fa19092012-10-19 20:57:49 +03002321 case HCI_OP_LE_READ_ADV_TX_POWER:
2322 hci_cc_le_read_adv_tx_power(hdev, skb);
2323 break;
2324
Johan Hedberga5c29682011-02-19 12:05:57 -03002325 case HCI_OP_USER_CONFIRM_REPLY:
2326 hci_cc_user_confirm_reply(hdev, skb);
2327 break;
2328
2329 case HCI_OP_USER_CONFIRM_NEG_REPLY:
2330 hci_cc_user_confirm_neg_reply(hdev, skb);
2331 break;
2332
Brian Gix1143d452011-11-23 08:28:34 -08002333 case HCI_OP_USER_PASSKEY_REPLY:
2334 hci_cc_user_passkey_reply(hdev, skb);
2335 break;
2336
2337 case HCI_OP_USER_PASSKEY_NEG_REPLY:
2338 hci_cc_user_passkey_neg_reply(hdev, skb);
Szymon Janc16cde992012-04-13 12:32:42 +02002339 break;
Andre Guedes07f7fa52011-12-02 21:13:31 +09002340
2341 case HCI_OP_LE_SET_SCAN_PARAM:
2342 hci_cc_le_set_scan_param(hdev, skb);
Brian Gix1143d452011-11-23 08:28:34 -08002343 break;
2344
Johan Hedbergc1d5dc42012-11-08 01:23:01 +01002345 case HCI_OP_LE_SET_ADV_ENABLE:
2346 hci_cc_le_set_adv_enable(hdev, skb);
2347 break;
2348
Andre Guedeseb9d91f2011-05-26 16:23:52 -03002349 case HCI_OP_LE_SET_SCAN_ENABLE:
2350 hci_cc_le_set_scan_enable(hdev, skb);
2351 break;
2352
Johan Hedbergcf1d0812013-01-22 14:02:00 +02002353 case HCI_OP_LE_READ_WHITE_LIST_SIZE:
2354 hci_cc_le_read_white_list_size(hdev, skb);
2355 break;
2356
Johan Hedberg9b008c02013-01-22 14:02:01 +02002357 case HCI_OP_LE_READ_SUPPORTED_STATES:
2358 hci_cc_le_read_supported_states(hdev, skb);
2359 break;
2360
Andre Guedesf9b49302011-06-30 19:20:53 -03002361 case HCI_OP_WRITE_LE_HOST_SUPPORTED:
2362 hci_cc_write_le_host_supported(hdev, skb);
2363 break;
2364
Andrei Emeltchenko93c284e2012-09-27 17:26:20 +03002365 case HCI_OP_WRITE_REMOTE_AMP_ASSOC:
2366 hci_cc_write_remote_amp_assoc(hdev, skb);
2367 break;
2368
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002369 default:
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002370 BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002371 break;
2372 }
2373
Johan Hedbergad82cdd2013-03-09 09:53:50 +02002374 if (opcode != HCI_OP_NOP)
Ville Tervo6bd32322011-02-16 16:32:41 +02002375 del_timer(&hdev->cmd_timer);
2376
Johan Hedbergad82cdd2013-03-09 09:53:50 +02002377 hci_req_cmd_complete(hdev, opcode, status);
Johan Hedberg9238f362013-03-05 20:37:48 +02002378
Szymon Jancdbccd792012-12-11 08:51:19 +01002379 if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags)) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002380 atomic_set(&hdev->cmd_cnt, 1);
2381 if (!skb_queue_empty(&hdev->cmd_q))
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002382 queue_work(hdev->workqueue, &hdev->cmd_work);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002383 }
2384}
2385
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002386static void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002387{
2388 struct hci_ev_cmd_status *ev = (void *) skb->data;
2389 __u16 opcode;
2390
2391 skb_pull(skb, sizeof(*ev));
2392
2393 opcode = __le16_to_cpu(ev->opcode);
2394
2395 switch (opcode) {
2396 case HCI_OP_INQUIRY:
2397 hci_cs_inquiry(hdev, ev->status);
2398 break;
2399
2400 case HCI_OP_CREATE_CONN:
2401 hci_cs_create_conn(hdev, ev->status);
2402 break;
2403
2404 case HCI_OP_ADD_SCO:
2405 hci_cs_add_sco(hdev, ev->status);
2406 break;
2407
Marcel Holtmannf8558552008-07-14 20:13:49 +02002408 case HCI_OP_AUTH_REQUESTED:
2409 hci_cs_auth_requested(hdev, ev->status);
2410 break;
2411
2412 case HCI_OP_SET_CONN_ENCRYPT:
2413 hci_cs_set_conn_encrypt(hdev, ev->status);
2414 break;
2415
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002416 case HCI_OP_REMOTE_NAME_REQ:
2417 hci_cs_remote_name_req(hdev, ev->status);
2418 break;
2419
Marcel Holtmann769be972008-07-14 20:13:49 +02002420 case HCI_OP_READ_REMOTE_FEATURES:
2421 hci_cs_read_remote_features(hdev, ev->status);
2422 break;
2423
2424 case HCI_OP_READ_REMOTE_EXT_FEATURES:
2425 hci_cs_read_remote_ext_features(hdev, ev->status);
2426 break;
2427
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002428 case HCI_OP_SETUP_SYNC_CONN:
2429 hci_cs_setup_sync_conn(hdev, ev->status);
2430 break;
2431
2432 case HCI_OP_SNIFF_MODE:
2433 hci_cs_sniff_mode(hdev, ev->status);
2434 break;
2435
2436 case HCI_OP_EXIT_SNIFF_MODE:
2437 hci_cs_exit_sniff_mode(hdev, ev->status);
2438 break;
2439
Johan Hedberg8962ee72011-01-20 12:40:27 +02002440 case HCI_OP_DISCONNECT:
Johan Hedberg88c3df12012-02-09 14:27:38 +02002441 hci_cs_disconnect(hdev, ev->status);
Johan Hedberg8962ee72011-01-20 12:40:27 +02002442 break;
2443
Ville Tervofcd89c02011-02-10 22:38:47 -03002444 case HCI_OP_LE_CREATE_CONN:
2445 hci_cs_le_create_conn(hdev, ev->status);
2446 break;
2447
Andrei Emeltchenkoa02226d2012-09-27 17:26:19 +03002448 case HCI_OP_CREATE_PHY_LINK:
2449 hci_cs_create_phylink(hdev, ev->status);
2450 break;
2451
Andrei Emeltchenko0b26ab92012-09-27 17:26:24 +03002452 case HCI_OP_ACCEPT_PHY_LINK:
2453 hci_cs_accept_phylink(hdev, ev->status);
2454 break;
2455
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002456 default:
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002457 BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002458 break;
2459 }
2460
Johan Hedbergad82cdd2013-03-09 09:53:50 +02002461 if (opcode != HCI_OP_NOP)
Ville Tervo6bd32322011-02-16 16:32:41 +02002462 del_timer(&hdev->cmd_timer);
2463
Johan Hedberg02350a72013-04-03 21:50:29 +03002464 if (ev->status ||
2465 (hdev->sent_cmd && !bt_cb(hdev->sent_cmd)->req.event))
2466 hci_req_cmd_complete(hdev, opcode, ev->status);
Johan Hedberg9238f362013-03-05 20:37:48 +02002467
Gustavo F. Padovan10572132011-03-16 15:36:29 -03002468 if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags)) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002469 atomic_set(&hdev->cmd_cnt, 1);
2470 if (!skb_queue_empty(&hdev->cmd_q))
Gustavo F. Padovanc347b762011-12-14 23:53:47 -02002471 queue_work(hdev->workqueue, &hdev->cmd_work);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002472 }
2473}
2474
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002475static void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002476{
2477 struct hci_ev_role_change *ev = (void *) skb->data;
2478 struct hci_conn *conn;
2479
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002480 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002481
2482 hci_dev_lock(hdev);
2483
2484 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2485 if (conn) {
2486 if (!ev->status) {
2487 if (ev->role)
2488 conn->link_mode &= ~HCI_LM_MASTER;
2489 else
2490 conn->link_mode |= HCI_LM_MASTER;
2491 }
2492
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002493 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002494
2495 hci_role_switch_cfm(conn, ev->status, ev->role);
2496 }
2497
2498 hci_dev_unlock(hdev);
2499}
2500
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002501static void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002503 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 int i;
2505
Andrei Emeltchenko32ac5b92011-12-19 16:31:29 +02002506 if (hdev->flow_ctl_mode != HCI_FLOW_CTL_MODE_PACKET_BASED) {
2507 BT_ERR("Wrong event for mode %d", hdev->flow_ctl_mode);
2508 return;
2509 }
2510
Andrei Emeltchenkoc5993de2011-12-30 12:07:47 +02002511 if (skb->len < sizeof(*ev) || skb->len < sizeof(*ev) +
Gustavo Padovan807deac2012-05-17 00:36:24 -03002512 ev->num_hndl * sizeof(struct hci_comp_pkts_info)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513 BT_DBG("%s bad parameters", hdev->name);
2514 return;
2515 }
2516
Andrei Emeltchenkoc5993de2011-12-30 12:07:47 +02002517 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
2518
Andrei Emeltchenko613a1c02011-12-19 16:31:30 +02002519 for (i = 0; i < ev->num_hndl; i++) {
2520 struct hci_comp_pkts_info *info = &ev->handles[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521 struct hci_conn *conn;
2522 __u16 handle, count;
2523
Andrei Emeltchenko613a1c02011-12-19 16:31:30 +02002524 handle = __le16_to_cpu(info->handle);
2525 count = __le16_to_cpu(info->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526
2527 conn = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenkof4280912011-12-07 15:56:52 +02002528 if (!conn)
2529 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002530
Andrei Emeltchenkof4280912011-12-07 15:56:52 +02002531 conn->sent -= count;
2532
2533 switch (conn->type) {
2534 case ACL_LINK:
2535 hdev->acl_cnt += count;
2536 if (hdev->acl_cnt > hdev->acl_pkts)
2537 hdev->acl_cnt = hdev->acl_pkts;
2538 break;
2539
2540 case LE_LINK:
2541 if (hdev->le_pkts) {
2542 hdev->le_cnt += count;
2543 if (hdev->le_cnt > hdev->le_pkts)
2544 hdev->le_cnt = hdev->le_pkts;
2545 } else {
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002546 hdev->acl_cnt += count;
2547 if (hdev->acl_cnt > hdev->acl_pkts)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 hdev->acl_cnt = hdev->acl_pkts;
2549 }
Andrei Emeltchenkof4280912011-12-07 15:56:52 +02002550 break;
2551
2552 case SCO_LINK:
2553 hdev->sco_cnt += count;
2554 if (hdev->sco_cnt > hdev->sco_pkts)
2555 hdev->sco_cnt = hdev->sco_pkts;
2556 break;
2557
2558 default:
2559 BT_ERR("Unknown type %d conn %p", conn->type, conn);
2560 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561 }
2562 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002563
Gustavo F. Padovan3eff45e2011-12-15 00:50:02 -02002564 queue_work(hdev->workqueue, &hdev->tx_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565}
2566
Andrei Emeltchenko76ef7cf2012-10-10 17:38:29 +03002567static struct hci_conn *__hci_conn_lookup_handle(struct hci_dev *hdev,
2568 __u16 handle)
2569{
2570 struct hci_chan *chan;
2571
2572 switch (hdev->dev_type) {
2573 case HCI_BREDR:
2574 return hci_conn_hash_lookup_handle(hdev, handle);
2575 case HCI_AMP:
2576 chan = hci_chan_lookup_handle(hdev, handle);
2577 if (chan)
2578 return chan->conn;
2579 break;
2580 default:
2581 BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type);
2582 break;
2583 }
2584
2585 return NULL;
2586}
2587
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002588static void hci_num_comp_blocks_evt(struct hci_dev *hdev, struct sk_buff *skb)
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002589{
2590 struct hci_ev_num_comp_blocks *ev = (void *) skb->data;
2591 int i;
2592
2593 if (hdev->flow_ctl_mode != HCI_FLOW_CTL_MODE_BLOCK_BASED) {
2594 BT_ERR("Wrong event for mode %d", hdev->flow_ctl_mode);
2595 return;
2596 }
2597
2598 if (skb->len < sizeof(*ev) || skb->len < sizeof(*ev) +
Gustavo Padovan807deac2012-05-17 00:36:24 -03002599 ev->num_hndl * sizeof(struct hci_comp_blocks_info)) {
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002600 BT_DBG("%s bad parameters", hdev->name);
2601 return;
2602 }
2603
2604 BT_DBG("%s num_blocks %d num_hndl %d", hdev->name, ev->num_blocks,
Gustavo Padovan807deac2012-05-17 00:36:24 -03002605 ev->num_hndl);
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002606
2607 for (i = 0; i < ev->num_hndl; i++) {
2608 struct hci_comp_blocks_info *info = &ev->handles[i];
Andrei Emeltchenko76ef7cf2012-10-10 17:38:29 +03002609 struct hci_conn *conn = NULL;
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002610 __u16 handle, block_count;
2611
2612 handle = __le16_to_cpu(info->handle);
2613 block_count = __le16_to_cpu(info->blocks);
2614
Andrei Emeltchenko76ef7cf2012-10-10 17:38:29 +03002615 conn = __hci_conn_lookup_handle(hdev, handle);
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002616 if (!conn)
2617 continue;
2618
2619 conn->sent -= block_count;
2620
2621 switch (conn->type) {
2622 case ACL_LINK:
Andrei Emeltchenkobd1eb662012-10-10 17:38:30 +03002623 case AMP_LINK:
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02002624 hdev->block_cnt += block_count;
2625 if (hdev->block_cnt > hdev->num_blocks)
2626 hdev->block_cnt = hdev->num_blocks;
2627 break;
2628
2629 default:
2630 BT_ERR("Unknown type %d conn %p", conn->type, conn);
2631 break;
2632 }
2633 }
2634
2635 queue_work(hdev->workqueue, &hdev->tx_work);
2636}
2637
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002638static void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002640 struct hci_ev_mode_change *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002641 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002643 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002644
2645 hci_dev_lock(hdev);
2646
Marcel Holtmann04837f62006-07-03 10:02:33 +02002647 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2648 if (conn) {
2649 conn->mode = ev->mode;
2650 conn->interval = __le16_to_cpu(ev->interval);
2651
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03002652 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND,
2653 &conn->flags)) {
Marcel Holtmann04837f62006-07-03 10:02:33 +02002654 if (conn->mode == HCI_CM_ACTIVE)
Johan Hedberg58a681e2012-01-16 06:47:28 +02002655 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002656 else
Johan Hedberg58a681e2012-01-16 06:47:28 +02002657 clear_bit(HCI_CONN_POWER_SAVE, &conn->flags);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002658 }
Marcel Holtmanne73439d2010-07-26 10:06:00 -04002659
Johan Hedberg51a8efd2012-01-16 06:10:31 +02002660 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
Marcel Holtmanne73439d2010-07-26 10:06:00 -04002661 hci_sco_setup(conn, ev->status);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002662 }
2663
2664 hci_dev_unlock(hdev);
2665}
2666
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002667static void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002669 struct hci_ev_pin_code_req *ev = (void *) skb->data;
2670 struct hci_conn *conn;
2671
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002672 BT_DBG("%s", hdev->name);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002673
2674 hci_dev_lock(hdev);
2675
2676 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Waldemar Rymarkiewiczb6f98042011-09-23 10:01:30 +02002677 if (!conn)
2678 goto unlock;
2679
2680 if (conn->state == BT_CONNECTED) {
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002681 hci_conn_hold(conn);
2682 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
David Herrmann76a68ba2013-04-06 20:28:37 +02002683 hci_conn_drop(conn);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002684 }
2685
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02002686 if (!test_bit(HCI_PAIRABLE, &hdev->dev_flags))
Johan Hedberg03b555e2011-01-04 15:40:05 +02002687 hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
Gustavo Padovan807deac2012-05-17 00:36:24 -03002688 sizeof(ev->bdaddr), &ev->bdaddr);
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02002689 else if (test_bit(HCI_MGMT, &hdev->dev_flags)) {
Waldemar Rymarkiewicza770bb52011-04-28 12:07:59 +02002690 u8 secure;
2691
2692 if (conn->pending_sec_level == BT_SECURITY_HIGH)
2693 secure = 1;
2694 else
2695 secure = 0;
2696
Johan Hedberg744cf192011-11-08 20:40:14 +02002697 mgmt_pin_code_request(hdev, &ev->bdaddr, secure);
Waldemar Rymarkiewicza770bb52011-04-28 12:07:59 +02002698 }
Johan Hedberg980e1a52011-01-22 06:10:07 +02002699
Waldemar Rymarkiewiczb6f98042011-09-23 10:01:30 +02002700unlock:
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002701 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002702}
2703
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002704static void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705{
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002706 struct hci_ev_link_key_req *ev = (void *) skb->data;
2707 struct hci_cp_link_key_reply cp;
2708 struct hci_conn *conn;
2709 struct link_key *key;
2710
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002711 BT_DBG("%s", hdev->name);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002712
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02002713 if (!test_bit(HCI_LINK_KEYS, &hdev->dev_flags))
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002714 return;
2715
2716 hci_dev_lock(hdev);
2717
2718 key = hci_find_link_key(hdev, &ev->bdaddr);
2719 if (!key) {
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03002720 BT_DBG("%s link key not found for %pMR", hdev->name,
2721 &ev->bdaddr);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002722 goto not_found;
2723 }
2724
Andrei Emeltchenko6ed93dc2012-09-25 12:49:43 +03002725 BT_DBG("%s found key type %u for %pMR", hdev->name, key->type,
2726 &ev->bdaddr);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002727
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02002728 if (!test_bit(HCI_DEBUG_KEYS, &hdev->dev_flags) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03002729 key->type == HCI_LK_DEBUG_COMBINATION) {
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002730 BT_DBG("%s ignoring debug key", hdev->name);
2731 goto not_found;
2732 }
2733
2734 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002735 if (conn) {
2736 if (key->type == HCI_LK_UNAUTH_COMBINATION &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03002737 conn->auth_type != 0xff && (conn->auth_type & 0x01)) {
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002738 BT_DBG("%s ignoring unauthenticated key", hdev->name);
2739 goto not_found;
2740 }
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002741
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002742 if (key->type == HCI_LK_COMBINATION && key->pin_len < 16 &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03002743 conn->pending_sec_level == BT_SECURITY_HIGH) {
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03002744 BT_DBG("%s ignoring key unauthenticated for high security",
2745 hdev->name);
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002746 goto not_found;
2747 }
2748
2749 conn->key_type = key->type;
2750 conn->pin_length = key->pin_len;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002751 }
2752
2753 bacpy(&cp.bdaddr, &ev->bdaddr);
Andrei Emeltchenko9b3b4462012-05-23 11:31:20 +03002754 memcpy(cp.link_key, key->val, HCI_LINK_KEY_SIZE);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002755
2756 hci_send_cmd(hdev, HCI_OP_LINK_KEY_REPLY, sizeof(cp), &cp);
2757
2758 hci_dev_unlock(hdev);
2759
2760 return;
2761
2762not_found:
2763 hci_send_cmd(hdev, HCI_OP_LINK_KEY_NEG_REPLY, 6, &ev->bdaddr);
2764 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002765}
2766
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002767static void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002769 struct hci_ev_link_key_notify *ev = (void *) skb->data;
2770 struct hci_conn *conn;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002771 u8 pin_len = 0;
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002772
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002773 BT_DBG("%s", hdev->name);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002774
2775 hci_dev_lock(hdev);
2776
2777 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2778 if (conn) {
2779 hci_conn_hold(conn);
2780 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Johan Hedberg980e1a52011-01-22 06:10:07 +02002781 pin_len = conn->pin_length;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02002782
2783 if (ev->key_type != HCI_LK_CHANGED_COMBINATION)
2784 conn->key_type = ev->key_type;
2785
David Herrmann76a68ba2013-04-06 20:28:37 +02002786 hci_conn_drop(conn);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002787 }
2788
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02002789 if (test_bit(HCI_LINK_KEYS, &hdev->dev_flags))
Johan Hedbergd25e28a2011-04-28 11:28:59 -07002790 hci_add_link_key(hdev, conn, 1, &ev->bdaddr, ev->link_key,
Gustavo Padovan807deac2012-05-17 00:36:24 -03002791 ev->key_type, pin_len);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002792
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002793 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794}
2795
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002796static void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmann04837f62006-07-03 10:02:33 +02002797{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002798 struct hci_ev_clock_offset *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002799 struct hci_conn *conn;
2800
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002801 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002802
2803 hci_dev_lock(hdev);
2804
2805 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806 if (conn && !ev->status) {
2807 struct inquiry_entry *ie;
2808
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002809 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2810 if (ie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 ie->data.clock_offset = ev->clock_offset;
2812 ie->timestamp = jiffies;
2813 }
2814 }
2815
2816 hci_dev_unlock(hdev);
2817}
2818
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002819static void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmanna8746412008-07-14 20:13:46 +02002820{
2821 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
2822 struct hci_conn *conn;
2823
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002824 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmanna8746412008-07-14 20:13:46 +02002825
2826 hci_dev_lock(hdev);
2827
2828 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2829 if (conn && !ev->status)
2830 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
2831
2832 hci_dev_unlock(hdev);
2833}
2834
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002835static void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002836{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002837 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002838 struct inquiry_entry *ie;
2839
2840 BT_DBG("%s", hdev->name);
2841
2842 hci_dev_lock(hdev);
2843
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002844 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
2845 if (ie) {
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002846 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
2847 ie->timestamp = jiffies;
2848 }
2849
2850 hci_dev_unlock(hdev);
2851}
2852
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002853static void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev,
2854 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002855{
2856 struct inquiry_data data;
2857 int num_rsp = *((__u8 *) skb->data);
Johan Hedberg388fc8f2012-02-23 00:38:59 +02002858 bool name_known, ssp;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002859
2860 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
2861
2862 if (!num_rsp)
2863 return;
2864
Andre Guedes1519cc12012-03-21 00:03:38 -03002865 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
2866 return;
2867
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002868 hci_dev_lock(hdev);
2869
2870 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
Szymon Janc138d22e2011-02-17 16:44:23 +01002871 struct inquiry_info_with_rssi_and_pscan_mode *info;
2872 info = (void *) (skb->data + 1);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002873
Johan Hedberge17acd42011-03-30 23:57:16 +03002874 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002875 bacpy(&data.bdaddr, &info->bdaddr);
2876 data.pscan_rep_mode = info->pscan_rep_mode;
2877 data.pscan_period_mode = info->pscan_period_mode;
2878 data.pscan_mode = info->pscan_mode;
2879 memcpy(data.dev_class, info->dev_class, 3);
2880 data.clock_offset = info->clock_offset;
2881 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002882 data.ssp_mode = 0x00;
Johan Hedberg31754052012-01-04 13:39:52 +02002883
2884 name_known = hci_inquiry_cache_update(hdev, &data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002885 false, &ssp);
Johan Hedberg48264f02011-11-09 13:58:58 +02002886 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002887 info->dev_class, info->rssi,
2888 !name_known, ssp, NULL, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002889 }
2890 } else {
2891 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
2892
Johan Hedberge17acd42011-03-30 23:57:16 +03002893 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002894 bacpy(&data.bdaddr, &info->bdaddr);
2895 data.pscan_rep_mode = info->pscan_rep_mode;
2896 data.pscan_period_mode = info->pscan_period_mode;
2897 data.pscan_mode = 0x00;
2898 memcpy(data.dev_class, info->dev_class, 3);
2899 data.clock_offset = info->clock_offset;
2900 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002901 data.ssp_mode = 0x00;
Johan Hedberg31754052012-01-04 13:39:52 +02002902 name_known = hci_inquiry_cache_update(hdev, &data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002903 false, &ssp);
Johan Hedberg48264f02011-11-09 13:58:58 +02002904 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002905 info->dev_class, info->rssi,
2906 !name_known, ssp, NULL, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002907 }
2908 }
2909
2910 hci_dev_unlock(hdev);
2911}
2912
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002913static void hci_remote_ext_features_evt(struct hci_dev *hdev,
2914 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002915{
Marcel Holtmann41a96212008-07-14 20:13:48 +02002916 struct hci_ev_remote_ext_features *ev = (void *) skb->data;
2917 struct hci_conn *conn;
2918
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002919 BT_DBG("%s", hdev->name);
Marcel Holtmann41a96212008-07-14 20:13:48 +02002920
Marcel Holtmann41a96212008-07-14 20:13:48 +02002921 hci_dev_lock(hdev);
2922
2923 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergccd556f2010-11-10 17:11:51 +02002924 if (!conn)
2925 goto unlock;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002926
Johan Hedbergccd556f2010-11-10 17:11:51 +02002927 if (!ev->status && ev->page == 0x01) {
2928 struct inquiry_entry *ie;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002929
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002930 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2931 if (ie)
Johan Hedberg02b7cc62012-02-28 02:28:43 +02002932 ie->data.ssp_mode = (ev->features[0] & LMP_HOST_SSP);
Marcel Holtmann769be972008-07-14 20:13:49 +02002933
Jaganath Kanakkasserybbb0ead2013-04-16 20:16:30 +05302934 if (ev->features[0] & LMP_HOST_SSP) {
Johan Hedberg58a681e2012-01-16 06:47:28 +02002935 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
Jaganath Kanakkasserybbb0ead2013-04-16 20:16:30 +05302936 } else {
2937 /* It is mandatory by the Bluetooth specification that
2938 * Extended Inquiry Results are only used when Secure
2939 * Simple Pairing is enabled, but some devices violate
2940 * this.
2941 *
2942 * To make these devices work, the internal SSP
2943 * enabled flag needs to be cleared if the remote host
2944 * features do not indicate SSP support */
2945 clear_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
2946 }
Marcel Holtmann41a96212008-07-14 20:13:48 +02002947 }
2948
Johan Hedbergccd556f2010-11-10 17:11:51 +02002949 if (conn->state != BT_CONFIG)
2950 goto unlock;
2951
Johan Hedberg671267b2012-05-12 16:11:50 -03002952 if (!ev->status && !test_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02002953 struct hci_cp_remote_name_req cp;
2954 memset(&cp, 0, sizeof(cp));
2955 bacpy(&cp.bdaddr, &conn->dst);
2956 cp.pscan_rep_mode = 0x02;
2957 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
Johan Hedbergb644ba32012-01-17 21:48:47 +02002958 } else if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
2959 mgmt_device_connected(hdev, &conn->dst, conn->type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03002960 conn->dst_type, 0, NULL, 0,
2961 conn->dev_class);
Johan Hedberg392599b2010-11-18 22:22:28 +02002962
Johan Hedberg127178d2010-11-18 22:22:29 +02002963 if (!hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedbergccd556f2010-11-10 17:11:51 +02002964 conn->state = BT_CONNECTED;
2965 hci_proto_connect_cfm(conn, ev->status);
David Herrmann76a68ba2013-04-06 20:28:37 +02002966 hci_conn_drop(conn);
Johan Hedbergccd556f2010-11-10 17:11:51 +02002967 }
2968
2969unlock:
Marcel Holtmann41a96212008-07-14 20:13:48 +02002970 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002971}
2972
Gustavo Padovan6039aa72012-05-23 04:04:18 -03002973static void hci_sync_conn_complete_evt(struct hci_dev *hdev,
2974 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002975{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002976 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
2977 struct hci_conn *conn;
2978
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03002979 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002980
2981 hci_dev_lock(hdev);
2982
2983 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann9dc0a3a2008-07-14 20:13:46 +02002984 if (!conn) {
2985 if (ev->link_type == ESCO_LINK)
2986 goto unlock;
2987
2988 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
2989 if (!conn)
2990 goto unlock;
2991
2992 conn->type = SCO_LINK;
2993 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002994
Marcel Holtmann732547f2009-04-19 19:14:14 +02002995 switch (ev->status) {
2996 case 0x00:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002997 conn->handle = __le16_to_cpu(ev->handle);
2998 conn->state = BT_CONNECTED;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02002999
3000 hci_conn_add_sysfs(conn);
Marcel Holtmann732547f2009-04-19 19:14:14 +02003001 break;
3002
Stephen Coe705e5712010-02-16 11:29:44 -05003003 case 0x11: /* Unsupported Feature or Parameter Value */
Marcel Holtmann732547f2009-04-19 19:14:14 +02003004 case 0x1c: /* SCO interval rejected */
Nick Pelly1038a002010-02-03 11:42:26 -08003005 case 0x1a: /* Unsupported Remote Feature */
Marcel Holtmann732547f2009-04-19 19:14:14 +02003006 case 0x1f: /* Unspecified error */
3007 if (conn->out && conn->attempt < 2) {
3008 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
3009 (hdev->esco_type & EDR_ESCO_MASK);
3010 hci_setup_sync(conn, conn->link->handle);
3011 goto unlock;
3012 }
3013 /* fall through */
3014
3015 default:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02003016 conn->state = BT_CLOSED;
Marcel Holtmann732547f2009-04-19 19:14:14 +02003017 break;
3018 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02003019
3020 hci_proto_connect_cfm(conn, ev->status);
3021 if (ev->status)
3022 hci_conn_del(conn);
3023
3024unlock:
3025 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003026}
3027
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003028static void hci_extended_inquiry_result_evt(struct hci_dev *hdev,
3029 struct sk_buff *skb)
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003030{
3031 struct inquiry_data data;
3032 struct extended_inquiry_info *info = (void *) (skb->data + 1);
3033 int num_rsp = *((__u8 *) skb->data);
Vishal Agarwal9d939d92012-04-26 19:19:56 +05303034 size_t eir_len;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003035
3036 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
3037
3038 if (!num_rsp)
3039 return;
3040
Andre Guedes1519cc12012-03-21 00:03:38 -03003041 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
3042 return;
3043
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003044 hci_dev_lock(hdev);
3045
Johan Hedberge17acd42011-03-30 23:57:16 +03003046 for (; num_rsp; num_rsp--, info++) {
Johan Hedberg388fc8f2012-02-23 00:38:59 +02003047 bool name_known, ssp;
Johan Hedberg561aafb2012-01-04 13:31:59 +02003048
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003049 bacpy(&data.bdaddr, &info->bdaddr);
Szymon Janc138d22e2011-02-17 16:44:23 +01003050 data.pscan_rep_mode = info->pscan_rep_mode;
3051 data.pscan_period_mode = info->pscan_period_mode;
3052 data.pscan_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003053 memcpy(data.dev_class, info->dev_class, 3);
Szymon Janc138d22e2011-02-17 16:44:23 +01003054 data.clock_offset = info->clock_offset;
3055 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02003056 data.ssp_mode = 0x01;
Johan Hedberg561aafb2012-01-04 13:31:59 +02003057
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003058 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg4ddb1932012-01-15 20:04:43 +02003059 name_known = eir_has_data_type(info->data,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003060 sizeof(info->data),
3061 EIR_NAME_COMPLETE);
Johan Hedberg561aafb2012-01-04 13:31:59 +02003062 else
3063 name_known = true;
3064
Johan Hedberg388fc8f2012-02-23 00:38:59 +02003065 name_known = hci_inquiry_cache_update(hdev, &data, name_known,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003066 &ssp);
Vishal Agarwal9d939d92012-04-26 19:19:56 +05303067 eir_len = eir_get_length(info->data, sizeof(info->data));
Johan Hedberg48264f02011-11-09 13:58:58 +02003068 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003069 info->dev_class, info->rssi, !name_known,
Vishal Agarwal9d939d92012-04-26 19:19:56 +05303070 ssp, info->data, eir_len);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003071 }
3072
3073 hci_dev_unlock(hdev);
3074}
3075
Johan Hedberg1c2e0042012-06-08 23:31:13 +08003076static void hci_key_refresh_complete_evt(struct hci_dev *hdev,
3077 struct sk_buff *skb)
3078{
3079 struct hci_ev_key_refresh_complete *ev = (void *) skb->data;
3080 struct hci_conn *conn;
3081
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03003082 BT_DBG("%s status 0x%2.2x handle 0x%4.4x", hdev->name, ev->status,
Johan Hedberg1c2e0042012-06-08 23:31:13 +08003083 __le16_to_cpu(ev->handle));
3084
3085 hci_dev_lock(hdev);
3086
3087 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3088 if (!conn)
3089 goto unlock;
3090
3091 if (!ev->status)
3092 conn->sec_level = conn->pending_sec_level;
3093
3094 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
3095
3096 if (ev->status && conn->state == BT_CONNECTED) {
Andre Guedesbed71742013-01-30 11:50:56 -03003097 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
David Herrmann76a68ba2013-04-06 20:28:37 +02003098 hci_conn_drop(conn);
Johan Hedberg1c2e0042012-06-08 23:31:13 +08003099 goto unlock;
3100 }
3101
3102 if (conn->state == BT_CONFIG) {
3103 if (!ev->status)
3104 conn->state = BT_CONNECTED;
3105
3106 hci_proto_connect_cfm(conn, ev->status);
David Herrmann76a68ba2013-04-06 20:28:37 +02003107 hci_conn_drop(conn);
Johan Hedberg1c2e0042012-06-08 23:31:13 +08003108 } else {
3109 hci_auth_cfm(conn, ev->status);
3110
3111 hci_conn_hold(conn);
3112 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
David Herrmann76a68ba2013-04-06 20:28:37 +02003113 hci_conn_drop(conn);
Johan Hedberg1c2e0042012-06-08 23:31:13 +08003114 }
3115
3116unlock:
3117 hci_dev_unlock(hdev);
3118}
3119
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003120static u8 hci_get_auth_req(struct hci_conn *conn)
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003121{
3122 /* If remote requests dedicated bonding follow that lead */
3123 if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) {
3124 /* If both remote and local IO capabilities allow MITM
3125 * protection then require it, otherwise don't */
3126 if (conn->remote_cap == 0x03 || conn->io_capability == 0x03)
3127 return 0x02;
3128 else
3129 return 0x03;
3130 }
3131
3132 /* If remote requests no-bonding follow that lead */
3133 if (conn->remote_auth == 0x00 || conn->remote_auth == 0x01)
Waldemar Rymarkiewicz58797bf2011-04-28 12:07:58 +02003134 return conn->remote_auth | (conn->auth_type & 0x01);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003135
3136 return conn->auth_type;
3137}
3138
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003139static void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
Marcel Holtmann04936842008-07-14 20:13:48 +02003140{
3141 struct hci_ev_io_capa_request *ev = (void *) skb->data;
3142 struct hci_conn *conn;
3143
3144 BT_DBG("%s", hdev->name);
3145
3146 hci_dev_lock(hdev);
3147
3148 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg03b555e2011-01-04 15:40:05 +02003149 if (!conn)
3150 goto unlock;
Marcel Holtmann04936842008-07-14 20:13:48 +02003151
Johan Hedberg03b555e2011-01-04 15:40:05 +02003152 hci_conn_hold(conn);
3153
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003154 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg03b555e2011-01-04 15:40:05 +02003155 goto unlock;
3156
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003157 if (test_bit(HCI_PAIRABLE, &hdev->dev_flags) ||
Gustavo Padovan807deac2012-05-17 00:36:24 -03003158 (conn->remote_auth & ~0x01) == HCI_AT_NO_BONDING) {
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003159 struct hci_cp_io_capability_reply cp;
3160
3161 bacpy(&cp.bdaddr, &ev->bdaddr);
Hemant Gupta7a7f1e72012-01-16 13:34:29 +05303162 /* Change the IO capability from KeyboardDisplay
3163 * to DisplayYesNo as it is not supported by BT spec. */
3164 cp.capability = (conn->io_capability == 0x04) ?
3165 0x01 : conn->io_capability;
Johan Hedberg7cbc9bd2011-04-28 11:29:04 -07003166 conn->auth_type = hci_get_auth_req(conn);
3167 cp.authentication = conn->auth_type;
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003168
Gustavo Padovan8fc9ced2012-05-23 04:04:21 -03003169 if (hci_find_remote_oob_data(hdev, &conn->dst) &&
3170 (conn->out || test_bit(HCI_CONN_REMOTE_OOB, &conn->flags)))
Szymon Jancce85ee12011-03-22 13:12:23 +01003171 cp.oob_data = 0x01;
3172 else
3173 cp.oob_data = 0x00;
3174
Johan Hedberg17fa4b92011-01-25 13:28:33 +02003175 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_REPLY,
Gustavo Padovan807deac2012-05-17 00:36:24 -03003176 sizeof(cp), &cp);
Johan Hedberg03b555e2011-01-04 15:40:05 +02003177 } else {
3178 struct hci_cp_io_capability_neg_reply cp;
3179
3180 bacpy(&cp.bdaddr, &ev->bdaddr);
Andrei Emeltchenko9f5a0d72011-11-07 14:20:25 +02003181 cp.reason = HCI_ERROR_PAIRING_NOT_ALLOWED;
Johan Hedberg03b555e2011-01-04 15:40:05 +02003182
3183 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_NEG_REPLY,
Gustavo Padovan807deac2012-05-17 00:36:24 -03003184 sizeof(cp), &cp);
Johan Hedberg03b555e2011-01-04 15:40:05 +02003185 }
3186
3187unlock:
3188 hci_dev_unlock(hdev);
3189}
3190
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003191static void hci_io_capa_reply_evt(struct hci_dev *hdev, struct sk_buff *skb)
Johan Hedberg03b555e2011-01-04 15:40:05 +02003192{
3193 struct hci_ev_io_capa_reply *ev = (void *) skb->data;
3194 struct hci_conn *conn;
3195
3196 BT_DBG("%s", hdev->name);
3197
3198 hci_dev_lock(hdev);
3199
3200 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3201 if (!conn)
3202 goto unlock;
3203
Johan Hedberg03b555e2011-01-04 15:40:05 +02003204 conn->remote_cap = ev->capability;
Johan Hedberg03b555e2011-01-04 15:40:05 +02003205 conn->remote_auth = ev->authentication;
Johan Hedberg58a681e2012-01-16 06:47:28 +02003206 if (ev->oob_data)
3207 set_bit(HCI_CONN_REMOTE_OOB, &conn->flags);
Johan Hedberg03b555e2011-01-04 15:40:05 +02003208
3209unlock:
Marcel Holtmann04936842008-07-14 20:13:48 +02003210 hci_dev_unlock(hdev);
3211}
3212
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003213static void hci_user_confirm_request_evt(struct hci_dev *hdev,
3214 struct sk_buff *skb)
Johan Hedberga5c29682011-02-19 12:05:57 -03003215{
3216 struct hci_ev_user_confirm_req *ev = (void *) skb->data;
Johan Hedberg55bc1a32011-04-28 11:28:56 -07003217 int loc_mitm, rem_mitm, confirm_hint = 0;
Johan Hedberg7a828902011-04-28 11:28:53 -07003218 struct hci_conn *conn;
Johan Hedberga5c29682011-02-19 12:05:57 -03003219
3220 BT_DBG("%s", hdev->name);
3221
3222 hci_dev_lock(hdev);
3223
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003224 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg7a828902011-04-28 11:28:53 -07003225 goto unlock;
Johan Hedberga5c29682011-02-19 12:05:57 -03003226
Johan Hedberg7a828902011-04-28 11:28:53 -07003227 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3228 if (!conn)
3229 goto unlock;
3230
3231 loc_mitm = (conn->auth_type & 0x01);
3232 rem_mitm = (conn->remote_auth & 0x01);
3233
3234 /* If we require MITM but the remote device can't provide that
3235 * (it has NoInputNoOutput) then reject the confirmation
3236 * request. The only exception is when we're dedicated bonding
3237 * initiators (connect_cfm_cb set) since then we always have the MITM
3238 * bit set. */
3239 if (!conn->connect_cfm_cb && loc_mitm && conn->remote_cap == 0x03) {
3240 BT_DBG("Rejecting request: remote device can't provide MITM");
3241 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_NEG_REPLY,
Gustavo Padovan807deac2012-05-17 00:36:24 -03003242 sizeof(ev->bdaddr), &ev->bdaddr);
Johan Hedberg7a828902011-04-28 11:28:53 -07003243 goto unlock;
3244 }
3245
3246 /* If no side requires MITM protection; auto-accept */
3247 if ((!loc_mitm || conn->remote_cap == 0x03) &&
Gustavo Padovan807deac2012-05-17 00:36:24 -03003248 (!rem_mitm || conn->io_capability == 0x03)) {
Johan Hedberg55bc1a32011-04-28 11:28:56 -07003249
3250 /* If we're not the initiators request authorization to
3251 * proceed from user space (mgmt_user_confirm with
3252 * confirm_hint set to 1). */
Johan Hedberg51a8efd2012-01-16 06:10:31 +02003253 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
Johan Hedberg55bc1a32011-04-28 11:28:56 -07003254 BT_DBG("Confirming auto-accept as acceptor");
3255 confirm_hint = 1;
3256 goto confirm;
3257 }
3258
Johan Hedberg9f616562011-04-28 11:28:54 -07003259 BT_DBG("Auto-accept of user confirmation with %ums delay",
Gustavo Padovan807deac2012-05-17 00:36:24 -03003260 hdev->auto_accept_delay);
Johan Hedberg9f616562011-04-28 11:28:54 -07003261
3262 if (hdev->auto_accept_delay > 0) {
3263 int delay = msecs_to_jiffies(hdev->auto_accept_delay);
3264 mod_timer(&conn->auto_accept_timer, jiffies + delay);
3265 goto unlock;
3266 }
3267
Johan Hedberg7a828902011-04-28 11:28:53 -07003268 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY,
Gustavo Padovan807deac2012-05-17 00:36:24 -03003269 sizeof(ev->bdaddr), &ev->bdaddr);
Johan Hedberg7a828902011-04-28 11:28:53 -07003270 goto unlock;
3271 }
3272
Johan Hedberg55bc1a32011-04-28 11:28:56 -07003273confirm:
Johan Hedberg272d90d2012-02-09 15:26:12 +02003274 mgmt_user_confirm_request(hdev, &ev->bdaddr, ACL_LINK, 0, ev->passkey,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003275 confirm_hint);
Johan Hedberg7a828902011-04-28 11:28:53 -07003276
3277unlock:
Johan Hedberga5c29682011-02-19 12:05:57 -03003278 hci_dev_unlock(hdev);
3279}
3280
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003281static void hci_user_passkey_request_evt(struct hci_dev *hdev,
3282 struct sk_buff *skb)
Brian Gix1143d452011-11-23 08:28:34 -08003283{
3284 struct hci_ev_user_passkey_req *ev = (void *) skb->data;
3285
3286 BT_DBG("%s", hdev->name);
3287
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003288 if (test_bit(HCI_MGMT, &hdev->dev_flags))
Johan Hedberg272d90d2012-02-09 15:26:12 +02003289 mgmt_user_passkey_request(hdev, &ev->bdaddr, ACL_LINK, 0);
Brian Gix1143d452011-11-23 08:28:34 -08003290}
3291
Johan Hedberg92a25252012-09-06 18:39:26 +03003292static void hci_user_passkey_notify_evt(struct hci_dev *hdev,
3293 struct sk_buff *skb)
3294{
3295 struct hci_ev_user_passkey_notify *ev = (void *) skb->data;
3296 struct hci_conn *conn;
3297
3298 BT_DBG("%s", hdev->name);
3299
3300 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3301 if (!conn)
3302 return;
3303
3304 conn->passkey_notify = __le32_to_cpu(ev->passkey);
3305 conn->passkey_entered = 0;
3306
3307 if (test_bit(HCI_MGMT, &hdev->dev_flags))
3308 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
3309 conn->dst_type, conn->passkey_notify,
3310 conn->passkey_entered);
3311}
3312
3313static void hci_keypress_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
3314{
3315 struct hci_ev_keypress_notify *ev = (void *) skb->data;
3316 struct hci_conn *conn;
3317
3318 BT_DBG("%s", hdev->name);
3319
3320 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3321 if (!conn)
3322 return;
3323
3324 switch (ev->type) {
3325 case HCI_KEYPRESS_STARTED:
3326 conn->passkey_entered = 0;
3327 return;
3328
3329 case HCI_KEYPRESS_ENTERED:
3330 conn->passkey_entered++;
3331 break;
3332
3333 case HCI_KEYPRESS_ERASED:
3334 conn->passkey_entered--;
3335 break;
3336
3337 case HCI_KEYPRESS_CLEARED:
3338 conn->passkey_entered = 0;
3339 break;
3340
3341 case HCI_KEYPRESS_COMPLETED:
3342 return;
3343 }
3344
3345 if (test_bit(HCI_MGMT, &hdev->dev_flags))
3346 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
3347 conn->dst_type, conn->passkey_notify,
3348 conn->passkey_entered);
3349}
3350
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003351static void hci_simple_pair_complete_evt(struct hci_dev *hdev,
3352 struct sk_buff *skb)
Marcel Holtmann04936842008-07-14 20:13:48 +02003353{
3354 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
3355 struct hci_conn *conn;
3356
3357 BT_DBG("%s", hdev->name);
3358
3359 hci_dev_lock(hdev);
3360
3361 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg2a611692011-02-19 12:06:00 -03003362 if (!conn)
3363 goto unlock;
Marcel Holtmann04936842008-07-14 20:13:48 +02003364
Johan Hedberg2a611692011-02-19 12:06:00 -03003365 /* To avoid duplicate auth_failed events to user space we check
3366 * the HCI_CONN_AUTH_PEND flag which will be set if we
3367 * initiated the authentication. A traditional auth_complete
3368 * event gets always produced as initiator and is also mapped to
3369 * the mgmt_auth_failed event */
Mikel Astizfa1bd912012-08-09 09:52:29 +02003370 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags) && ev->status)
Johan Hedbergbab73cb2012-02-09 16:07:29 +02003371 mgmt_auth_failed(hdev, &conn->dst, conn->type, conn->dst_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003372 ev->status);
Johan Hedberg2a611692011-02-19 12:06:00 -03003373
David Herrmann76a68ba2013-04-06 20:28:37 +02003374 hci_conn_drop(conn);
Johan Hedberg2a611692011-02-19 12:06:00 -03003375
3376unlock:
Marcel Holtmann04936842008-07-14 20:13:48 +02003377 hci_dev_unlock(hdev);
3378}
3379
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003380static void hci_remote_host_features_evt(struct hci_dev *hdev,
3381 struct sk_buff *skb)
Marcel Holtmann41a96212008-07-14 20:13:48 +02003382{
3383 struct hci_ev_remote_host_features *ev = (void *) skb->data;
3384 struct inquiry_entry *ie;
3385
3386 BT_DBG("%s", hdev->name);
3387
3388 hci_dev_lock(hdev);
3389
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02003390 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
3391 if (ie)
Johan Hedberg02b7cc62012-02-28 02:28:43 +02003392 ie->data.ssp_mode = (ev->features[0] & LMP_HOST_SSP);
Marcel Holtmann41a96212008-07-14 20:13:48 +02003393
3394 hci_dev_unlock(hdev);
3395}
3396
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003397static void hci_remote_oob_data_request_evt(struct hci_dev *hdev,
3398 struct sk_buff *skb)
Szymon Janc2763eda2011-03-22 13:12:22 +01003399{
3400 struct hci_ev_remote_oob_data_request *ev = (void *) skb->data;
3401 struct oob_data *data;
3402
3403 BT_DBG("%s", hdev->name);
3404
3405 hci_dev_lock(hdev);
3406
Johan Hedberga8b2d5c2012-01-08 23:11:15 +02003407 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
Szymon Jance1ba1f12011-04-06 13:01:59 +02003408 goto unlock;
3409
Szymon Janc2763eda2011-03-22 13:12:22 +01003410 data = hci_find_remote_oob_data(hdev, &ev->bdaddr);
3411 if (data) {
3412 struct hci_cp_remote_oob_data_reply cp;
3413
3414 bacpy(&cp.bdaddr, &ev->bdaddr);
3415 memcpy(cp.hash, data->hash, sizeof(cp.hash));
3416 memcpy(cp.randomizer, data->randomizer, sizeof(cp.randomizer));
3417
3418 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_REPLY, sizeof(cp),
Gustavo Padovan807deac2012-05-17 00:36:24 -03003419 &cp);
Szymon Janc2763eda2011-03-22 13:12:22 +01003420 } else {
3421 struct hci_cp_remote_oob_data_neg_reply cp;
3422
3423 bacpy(&cp.bdaddr, &ev->bdaddr);
3424 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_NEG_REPLY, sizeof(cp),
Gustavo Padovan807deac2012-05-17 00:36:24 -03003425 &cp);
Szymon Janc2763eda2011-03-22 13:12:22 +01003426 }
3427
Szymon Jance1ba1f12011-04-06 13:01:59 +02003428unlock:
Szymon Janc2763eda2011-03-22 13:12:22 +01003429 hci_dev_unlock(hdev);
3430}
3431
Andrei Emeltchenkod5e91192012-10-25 15:20:44 +03003432static void hci_phy_link_complete_evt(struct hci_dev *hdev,
3433 struct sk_buff *skb)
3434{
3435 struct hci_ev_phy_link_complete *ev = (void *) skb->data;
3436 struct hci_conn *hcon, *bredr_hcon;
3437
3438 BT_DBG("%s handle 0x%2.2x status 0x%2.2x", hdev->name, ev->phy_handle,
3439 ev->status);
3440
3441 hci_dev_lock(hdev);
3442
3443 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3444 if (!hcon) {
3445 hci_dev_unlock(hdev);
3446 return;
3447 }
3448
3449 if (ev->status) {
3450 hci_conn_del(hcon);
3451 hci_dev_unlock(hdev);
3452 return;
3453 }
3454
3455 bredr_hcon = hcon->amp_mgr->l2cap_conn->hcon;
3456
3457 hcon->state = BT_CONNECTED;
3458 bacpy(&hcon->dst, &bredr_hcon->dst);
3459
3460 hci_conn_hold(hcon);
3461 hcon->disc_timeout = HCI_DISCONN_TIMEOUT;
David Herrmann76a68ba2013-04-06 20:28:37 +02003462 hci_conn_drop(hcon);
Andrei Emeltchenkod5e91192012-10-25 15:20:44 +03003463
Andrei Emeltchenkod5e91192012-10-25 15:20:44 +03003464 hci_conn_add_sysfs(hcon);
3465
Andrei Emeltchenkocf70ff22012-10-31 15:46:36 +02003466 amp_physical_cfm(bredr_hcon, hcon);
3467
Andrei Emeltchenkod5e91192012-10-25 15:20:44 +03003468 hci_dev_unlock(hdev);
Andrei Emeltchenkod5e91192012-10-25 15:20:44 +03003469}
3470
Andrei Emeltchenko27695fb2012-10-25 15:20:45 +03003471static void hci_loglink_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
3472{
3473 struct hci_ev_logical_link_complete *ev = (void *) skb->data;
3474 struct hci_conn *hcon;
3475 struct hci_chan *hchan;
3476 struct amp_mgr *mgr;
3477
3478 BT_DBG("%s log_handle 0x%4.4x phy_handle 0x%2.2x status 0x%2.2x",
3479 hdev->name, le16_to_cpu(ev->handle), ev->phy_handle,
3480 ev->status);
3481
3482 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3483 if (!hcon)
3484 return;
3485
3486 /* Create AMP hchan */
3487 hchan = hci_chan_create(hcon);
3488 if (!hchan)
3489 return;
3490
3491 hchan->handle = le16_to_cpu(ev->handle);
3492
3493 BT_DBG("hcon %p mgr %p hchan %p", hcon, hcon->amp_mgr, hchan);
3494
3495 mgr = hcon->amp_mgr;
3496 if (mgr && mgr->bredr_chan) {
3497 struct l2cap_chan *bredr_chan = mgr->bredr_chan;
3498
3499 l2cap_chan_lock(bredr_chan);
3500
3501 bredr_chan->conn->mtu = hdev->block_mtu;
3502 l2cap_logical_cfm(bredr_chan, hchan, 0);
3503 hci_conn_hold(hcon);
3504
3505 l2cap_chan_unlock(bredr_chan);
3506 }
3507}
3508
Andrei Emeltchenko606e2a12012-10-31 15:46:31 +02003509static void hci_disconn_loglink_complete_evt(struct hci_dev *hdev,
3510 struct sk_buff *skb)
3511{
3512 struct hci_ev_disconn_logical_link_complete *ev = (void *) skb->data;
3513 struct hci_chan *hchan;
3514
3515 BT_DBG("%s log handle 0x%4.4x status 0x%2.2x", hdev->name,
3516 le16_to_cpu(ev->handle), ev->status);
3517
3518 if (ev->status)
3519 return;
3520
3521 hci_dev_lock(hdev);
3522
3523 hchan = hci_chan_lookup_handle(hdev, le16_to_cpu(ev->handle));
3524 if (!hchan)
3525 goto unlock;
3526
3527 amp_destroy_logical_link(hchan, ev->reason);
3528
3529unlock:
3530 hci_dev_unlock(hdev);
3531}
3532
Andrei Emeltchenko9eef6b32012-10-31 15:46:32 +02003533static void hci_disconn_phylink_complete_evt(struct hci_dev *hdev,
3534 struct sk_buff *skb)
3535{
3536 struct hci_ev_disconn_phy_link_complete *ev = (void *) skb->data;
3537 struct hci_conn *hcon;
3538
3539 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
3540
3541 if (ev->status)
3542 return;
3543
3544 hci_dev_lock(hdev);
3545
3546 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3547 if (hcon) {
3548 hcon->state = BT_CLOSED;
3549 hci_conn_del(hcon);
3550 }
3551
3552 hci_dev_unlock(hdev);
3553}
3554
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003555static void hci_le_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Ville Tervofcd89c02011-02-10 22:38:47 -03003556{
3557 struct hci_ev_le_conn_complete *ev = (void *) skb->data;
3558 struct hci_conn *conn;
3559
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03003560 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
Ville Tervofcd89c02011-02-10 22:38:47 -03003561
3562 hci_dev_lock(hdev);
3563
Andre Guedesb47a09b2012-07-27 15:10:15 -03003564 conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
Ville Tervob62f3282011-02-10 22:38:50 -03003565 if (!conn) {
3566 conn = hci_conn_add(hdev, LE_LINK, &ev->bdaddr);
3567 if (!conn) {
3568 BT_ERR("No memory for new connection");
Andre Guedes230fd162012-07-27 15:10:10 -03003569 goto unlock;
Ville Tervob62f3282011-02-10 22:38:50 -03003570 }
Andre Guedes29b79882011-05-31 14:20:54 -03003571
3572 conn->dst_type = ev->bdaddr_type;
Andre Guedesb9b343d2012-07-27 15:10:11 -03003573
3574 if (ev->role == LE_CONN_ROLE_MASTER) {
3575 conn->out = true;
3576 conn->link_mode |= HCI_LM_MASTER;
3577 }
Ville Tervob62f3282011-02-10 22:38:50 -03003578 }
Ville Tervofcd89c02011-02-10 22:38:47 -03003579
Andre Guedescd17dec2012-07-27 15:10:16 -03003580 if (ev->status) {
3581 mgmt_connect_failed(hdev, &conn->dst, conn->type,
3582 conn->dst_type, ev->status);
3583 hci_proto_connect_cfm(conn, ev->status);
3584 conn->state = BT_CLOSED;
3585 hci_conn_del(conn);
3586 goto unlock;
3587 }
3588
Johan Hedbergb644ba32012-01-17 21:48:47 +02003589 if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
3590 mgmt_device_connected(hdev, &ev->bdaddr, conn->type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003591 conn->dst_type, 0, NULL, 0, NULL);
Vinicius Costa Gomes83bc71b2011-05-06 18:41:43 -03003592
Vinicius Costa Gomes7b5c0d52011-06-09 18:50:50 -03003593 conn->sec_level = BT_SECURITY_LOW;
Ville Tervofcd89c02011-02-10 22:38:47 -03003594 conn->handle = __le16_to_cpu(ev->handle);
3595 conn->state = BT_CONNECTED;
3596
Ville Tervofcd89c02011-02-10 22:38:47 -03003597 hci_conn_add_sysfs(conn);
3598
3599 hci_proto_connect_cfm(conn, ev->status);
3600
3601unlock:
3602 hci_dev_unlock(hdev);
3603}
3604
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003605static void hci_le_adv_report_evt(struct hci_dev *hdev, struct sk_buff *skb)
Andre Guedes9aa04c92011-05-26 16:23:51 -03003606{
Andre Guedese95beb42011-09-26 20:48:35 -03003607 u8 num_reports = skb->data[0];
3608 void *ptr = &skb->data[1];
Andre Guedes3c9e9192012-01-10 18:20:50 -03003609 s8 rssi;
Andre Guedes9aa04c92011-05-26 16:23:51 -03003610
Andre Guedese95beb42011-09-26 20:48:35 -03003611 while (num_reports--) {
3612 struct hci_ev_le_advertising_info *ev = ptr;
Andre Guedes9aa04c92011-05-26 16:23:51 -03003613
Andre Guedes3c9e9192012-01-10 18:20:50 -03003614 rssi = ev->data[ev->length];
3615 mgmt_device_found(hdev, &ev->bdaddr, LE_LINK, ev->bdaddr_type,
Gustavo F. Padovan04124682012-03-08 01:25:00 -03003616 NULL, rssi, 0, 1, ev->data, ev->length);
Andre Guedes3c9e9192012-01-10 18:20:50 -03003617
Andre Guedese95beb42011-09-26 20:48:35 -03003618 ptr += sizeof(*ev) + ev->length + 1;
Andre Guedes9aa04c92011-05-26 16:23:51 -03003619 }
Andre Guedes9aa04c92011-05-26 16:23:51 -03003620}
3621
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003622static void hci_le_ltk_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003623{
3624 struct hci_ev_le_ltk_req *ev = (void *) skb->data;
3625 struct hci_cp_le_ltk_reply cp;
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03003626 struct hci_cp_le_ltk_neg_reply neg;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003627 struct hci_conn *conn;
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03003628 struct smp_ltk *ltk;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003629
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03003630 BT_DBG("%s handle 0x%4.4x", hdev->name, __le16_to_cpu(ev->handle));
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003631
3632 hci_dev_lock(hdev);
3633
3634 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03003635 if (conn == NULL)
3636 goto not_found;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003637
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03003638 ltk = hci_find_ltk(hdev, ev->ediv, ev->random);
3639 if (ltk == NULL)
3640 goto not_found;
3641
3642 memcpy(cp.ltk, ltk->val, sizeof(ltk->val));
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003643 cp.handle = cpu_to_le16(conn->handle);
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03003644
3645 if (ltk->authenticated)
3646 conn->sec_level = BT_SECURITY_HIGH;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003647
3648 hci_send_cmd(hdev, HCI_OP_LE_LTK_REPLY, sizeof(cp), &cp);
3649
Vinicius Costa Gomesc9839a12012-02-02 21:08:01 -03003650 if (ltk->type & HCI_SMP_STK) {
3651 list_del(&ltk->list);
3652 kfree(ltk);
3653 }
3654
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003655 hci_dev_unlock(hdev);
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03003656
3657 return;
3658
3659not_found:
3660 neg.handle = ev->handle;
3661 hci_send_cmd(hdev, HCI_OP_LE_LTK_NEG_REPLY, sizeof(neg), &neg);
3662 hci_dev_unlock(hdev);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003663}
3664
Gustavo Padovan6039aa72012-05-23 04:04:18 -03003665static void hci_le_meta_evt(struct hci_dev *hdev, struct sk_buff *skb)
Ville Tervofcd89c02011-02-10 22:38:47 -03003666{
3667 struct hci_ev_le_meta *le_ev = (void *) skb->data;
3668
3669 skb_pull(skb, sizeof(*le_ev));
3670
3671 switch (le_ev->subevent) {
3672 case HCI_EV_LE_CONN_COMPLETE:
3673 hci_le_conn_complete_evt(hdev, skb);
3674 break;
3675
Andre Guedes9aa04c92011-05-26 16:23:51 -03003676 case HCI_EV_LE_ADVERTISING_REPORT:
3677 hci_le_adv_report_evt(hdev, skb);
3678 break;
3679
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03003680 case HCI_EV_LE_LTK_REQ:
3681 hci_le_ltk_request_evt(hdev, skb);
3682 break;
3683
Ville Tervofcd89c02011-02-10 22:38:47 -03003684 default:
3685 break;
3686 }
3687}
3688
Andrei Emeltchenko9495b2e2012-09-27 17:26:22 +03003689static void hci_chan_selected_evt(struct hci_dev *hdev, struct sk_buff *skb)
3690{
3691 struct hci_ev_channel_selected *ev = (void *) skb->data;
3692 struct hci_conn *hcon;
3693
3694 BT_DBG("%s handle 0x%2.2x", hdev->name, ev->phy_handle);
3695
3696 skb_pull(skb, sizeof(*ev));
3697
3698 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3699 if (!hcon)
3700 return;
3701
3702 amp_read_loc_assoc_final_data(hdev, hcon);
3703}
3704
Linus Torvalds1da177e2005-04-16 15:20:36 -07003705void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
3706{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003707 struct hci_event_hdr *hdr = (void *) skb->data;
3708 __u8 event = hdr->evt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003709
Johan Hedbergb6ddb632013-04-02 13:34:31 +03003710 hci_dev_lock(hdev);
3711
3712 /* Received events are (currently) only needed when a request is
3713 * ongoing so avoid unnecessary memory allocation.
3714 */
3715 if (hdev->req_status == HCI_REQ_PEND) {
3716 kfree_skb(hdev->recv_evt);
3717 hdev->recv_evt = skb_clone(skb, GFP_KERNEL);
3718 }
3719
3720 hci_dev_unlock(hdev);
3721
Linus Torvalds1da177e2005-04-16 15:20:36 -07003722 skb_pull(skb, HCI_EVENT_HDR_SIZE);
3723
Johan Hedberg02350a72013-04-03 21:50:29 +03003724 if (hdev->sent_cmd && bt_cb(hdev->sent_cmd)->req.event == event) {
3725 struct hci_command_hdr *hdr = (void *) hdev->sent_cmd->data;
3726 u16 opcode = __le16_to_cpu(hdr->opcode);
3727
3728 hci_req_cmd_complete(hdev, opcode, 0);
3729 }
3730
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003731 switch (event) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003732 case HCI_EV_INQUIRY_COMPLETE:
3733 hci_inquiry_complete_evt(hdev, skb);
3734 break;
3735
3736 case HCI_EV_INQUIRY_RESULT:
3737 hci_inquiry_result_evt(hdev, skb);
3738 break;
3739
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003740 case HCI_EV_CONN_COMPLETE:
3741 hci_conn_complete_evt(hdev, skb);
Marcel Holtmann21d9e302005-09-13 01:32:25 +02003742 break;
3743
Linus Torvalds1da177e2005-04-16 15:20:36 -07003744 case HCI_EV_CONN_REQUEST:
3745 hci_conn_request_evt(hdev, skb);
3746 break;
3747
Linus Torvalds1da177e2005-04-16 15:20:36 -07003748 case HCI_EV_DISCONN_COMPLETE:
3749 hci_disconn_complete_evt(hdev, skb);
3750 break;
3751
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752 case HCI_EV_AUTH_COMPLETE:
3753 hci_auth_complete_evt(hdev, skb);
3754 break;
3755
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003756 case HCI_EV_REMOTE_NAME:
3757 hci_remote_name_evt(hdev, skb);
3758 break;
3759
Linus Torvalds1da177e2005-04-16 15:20:36 -07003760 case HCI_EV_ENCRYPT_CHANGE:
3761 hci_encrypt_change_evt(hdev, skb);
3762 break;
3763
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003764 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
3765 hci_change_link_key_complete_evt(hdev, skb);
3766 break;
3767
3768 case HCI_EV_REMOTE_FEATURES:
3769 hci_remote_features_evt(hdev, skb);
3770 break;
3771
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003772 case HCI_EV_CMD_COMPLETE:
3773 hci_cmd_complete_evt(hdev, skb);
3774 break;
3775
3776 case HCI_EV_CMD_STATUS:
3777 hci_cmd_status_evt(hdev, skb);
3778 break;
3779
3780 case HCI_EV_ROLE_CHANGE:
3781 hci_role_change_evt(hdev, skb);
3782 break;
3783
3784 case HCI_EV_NUM_COMP_PKTS:
3785 hci_num_comp_pkts_evt(hdev, skb);
3786 break;
3787
3788 case HCI_EV_MODE_CHANGE:
3789 hci_mode_change_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003790 break;
3791
3792 case HCI_EV_PIN_CODE_REQ:
3793 hci_pin_code_request_evt(hdev, skb);
3794 break;
3795
3796 case HCI_EV_LINK_KEY_REQ:
3797 hci_link_key_request_evt(hdev, skb);
3798 break;
3799
3800 case HCI_EV_LINK_KEY_NOTIFY:
3801 hci_link_key_notify_evt(hdev, skb);
3802 break;
3803
3804 case HCI_EV_CLOCK_OFFSET:
3805 hci_clock_offset_evt(hdev, skb);
3806 break;
3807
Marcel Holtmanna8746412008-07-14 20:13:46 +02003808 case HCI_EV_PKT_TYPE_CHANGE:
3809 hci_pkt_type_change_evt(hdev, skb);
3810 break;
3811
Marcel Holtmann85a1e932005-08-09 20:28:02 -07003812 case HCI_EV_PSCAN_REP_MODE:
3813 hci_pscan_rep_mode_evt(hdev, skb);
3814 break;
3815
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003816 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
3817 hci_inquiry_result_with_rssi_evt(hdev, skb);
3818 break;
3819
3820 case HCI_EV_REMOTE_EXT_FEATURES:
3821 hci_remote_ext_features_evt(hdev, skb);
3822 break;
3823
3824 case HCI_EV_SYNC_CONN_COMPLETE:
3825 hci_sync_conn_complete_evt(hdev, skb);
3826 break;
3827
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003828 case HCI_EV_EXTENDED_INQUIRY_RESULT:
3829 hci_extended_inquiry_result_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003830 break;
3831
Johan Hedberg1c2e0042012-06-08 23:31:13 +08003832 case HCI_EV_KEY_REFRESH_COMPLETE:
3833 hci_key_refresh_complete_evt(hdev, skb);
3834 break;
3835
Marcel Holtmann04936842008-07-14 20:13:48 +02003836 case HCI_EV_IO_CAPA_REQUEST:
3837 hci_io_capa_request_evt(hdev, skb);
3838 break;
3839
Johan Hedberg03b555e2011-01-04 15:40:05 +02003840 case HCI_EV_IO_CAPA_REPLY:
3841 hci_io_capa_reply_evt(hdev, skb);
3842 break;
3843
Johan Hedberga5c29682011-02-19 12:05:57 -03003844 case HCI_EV_USER_CONFIRM_REQUEST:
3845 hci_user_confirm_request_evt(hdev, skb);
3846 break;
3847
Brian Gix1143d452011-11-23 08:28:34 -08003848 case HCI_EV_USER_PASSKEY_REQUEST:
3849 hci_user_passkey_request_evt(hdev, skb);
3850 break;
3851
Johan Hedberg92a25252012-09-06 18:39:26 +03003852 case HCI_EV_USER_PASSKEY_NOTIFY:
3853 hci_user_passkey_notify_evt(hdev, skb);
3854 break;
3855
3856 case HCI_EV_KEYPRESS_NOTIFY:
3857 hci_keypress_notify_evt(hdev, skb);
3858 break;
3859
Marcel Holtmann04936842008-07-14 20:13:48 +02003860 case HCI_EV_SIMPLE_PAIR_COMPLETE:
3861 hci_simple_pair_complete_evt(hdev, skb);
3862 break;
3863
Marcel Holtmann41a96212008-07-14 20:13:48 +02003864 case HCI_EV_REMOTE_HOST_FEATURES:
3865 hci_remote_host_features_evt(hdev, skb);
3866 break;
3867
Ville Tervofcd89c02011-02-10 22:38:47 -03003868 case HCI_EV_LE_META:
3869 hci_le_meta_evt(hdev, skb);
3870 break;
3871
Andrei Emeltchenko9495b2e2012-09-27 17:26:22 +03003872 case HCI_EV_CHANNEL_SELECTED:
3873 hci_chan_selected_evt(hdev, skb);
3874 break;
3875
Szymon Janc2763eda2011-03-22 13:12:22 +01003876 case HCI_EV_REMOTE_OOB_DATA_REQUEST:
3877 hci_remote_oob_data_request_evt(hdev, skb);
3878 break;
3879
Andrei Emeltchenkod5e91192012-10-25 15:20:44 +03003880 case HCI_EV_PHY_LINK_COMPLETE:
3881 hci_phy_link_complete_evt(hdev, skb);
3882 break;
3883
Andrei Emeltchenko27695fb2012-10-25 15:20:45 +03003884 case HCI_EV_LOGICAL_LINK_COMPLETE:
3885 hci_loglink_complete_evt(hdev, skb);
3886 break;
3887
Andrei Emeltchenko606e2a12012-10-31 15:46:31 +02003888 case HCI_EV_DISCONN_LOGICAL_LINK_COMPLETE:
3889 hci_disconn_loglink_complete_evt(hdev, skb);
3890 break;
3891
Andrei Emeltchenko9eef6b32012-10-31 15:46:32 +02003892 case HCI_EV_DISCONN_PHY_LINK_COMPLETE:
3893 hci_disconn_phylink_complete_evt(hdev, skb);
3894 break;
3895
Andrei Emeltchenko25e89e92012-01-04 12:41:58 +02003896 case HCI_EV_NUM_COMP_BLOCKS:
3897 hci_num_comp_blocks_evt(hdev, skb);
3898 break;
3899
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003900 default:
Andrei Emeltchenko9f1db002012-07-11 14:32:43 +03003901 BT_DBG("%s event 0x%2.2x", hdev->name, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902 break;
3903 }
3904
3905 kfree_skb(skb);
3906 hdev->stat.evt_rx++;
3907}