blob: a40170e022e84e5e88f4ccbe4eb8724d5411c49d [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 <linux/module.h>
28
29#include <linux/types.h>
30#include <linux/errno.h>
31#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/slab.h>
33#include <linux/poll.h>
34#include <linux/fcntl.h>
35#include <linux/init.h>
36#include <linux/skbuff.h>
37#include <linux/interrupt.h>
38#include <linux/notifier.h>
39#include <net/sock.h>
40
41#include <asm/system.h>
Andrei Emeltchenko70f230202010-12-01 16:58:25 +020042#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <asm/unaligned.h>
44
45#include <net/bluetooth/bluetooth.h>
46#include <net/bluetooth/hci_core.h>
47
Andre Guedese6100a22011-06-30 19:20:54 -030048static int enable_le;
49
Linus Torvalds1da177e2005-04-16 15:20:36 -070050/* Handle HCI Event packets */
51
Marcel Holtmanna9de9242007-10-20 13:33:56 +020052static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070053{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020054 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Marcel Holtmanna9de9242007-10-20 13:33:56 +020056 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
Marcel Holtmanna9de9242007-10-20 13:33:56 +020058 if (status)
59 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Johan Hedberg314b2382011-04-27 10:29:57 -040061 if (test_bit(HCI_MGMT, &hdev->flags) &&
62 test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
63 mgmt_discovering(hdev->id, 0);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010064
Johan Hedberg23bb5762010-12-21 23:01:27 +020065 hci_req_complete(hdev, HCI_OP_INQUIRY_CANCEL, status);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010066
Marcel Holtmanna9de9242007-10-20 13:33:56 +020067 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068}
69
Marcel Holtmanna9de9242007-10-20 13:33:56 +020070static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020072 __u8 status = *((__u8 *) skb->data);
73
74 BT_DBG("%s status 0x%x", hdev->name, status);
75
76 if (status)
77 return;
78
Johan Hedberg314b2382011-04-27 10:29:57 -040079 if (test_bit(HCI_MGMT, &hdev->flags) &&
80 test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
81 mgmt_discovering(hdev->id, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +020082
83 hci_conn_check_pending(hdev);
84}
85
86static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev, struct sk_buff *skb)
87{
88 BT_DBG("%s", hdev->name);
89}
90
91static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb)
92{
93 struct hci_rp_role_discovery *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
Marcel Holtmanna9de9242007-10-20 13:33:56 +020096 BT_DBG("%s status 0x%x", hdev->name, rp->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Marcel Holtmanna9de9242007-10-20 13:33:56 +020098 if (rp->status)
99 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200101 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200103 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
104 if (conn) {
105 if (rp->role)
106 conn->link_mode &= ~HCI_LM_MASTER;
107 else
108 conn->link_mode |= HCI_LM_MASTER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200110
111 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112}
113
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200114static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
115{
116 struct hci_rp_read_link_policy *rp = (void *) skb->data;
117 struct hci_conn *conn;
118
119 BT_DBG("%s status 0x%x", hdev->name, rp->status);
120
121 if (rp->status)
122 return;
123
124 hci_dev_lock(hdev);
125
126 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
127 if (conn)
128 conn->link_policy = __le16_to_cpu(rp->policy);
129
130 hci_dev_unlock(hdev);
131}
132
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200133static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200135 struct hci_rp_write_link_policy *rp = (void *) skb->data;
136 struct hci_conn *conn;
137 void *sent;
138
139 BT_DBG("%s status 0x%x", hdev->name, rp->status);
140
141 if (rp->status)
142 return;
143
144 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
145 if (!sent)
146 return;
147
148 hci_dev_lock(hdev);
149
150 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200151 if (conn)
Harvey Harrison83985312008-05-02 16:25:46 -0700152 conn->link_policy = get_unaligned_le16(sent + 2);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200153
154 hci_dev_unlock(hdev);
155}
156
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200157static void hci_cc_read_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
158{
159 struct hci_rp_read_def_link_policy *rp = (void *) skb->data;
160
161 BT_DBG("%s status 0x%x", hdev->name, rp->status);
162
163 if (rp->status)
164 return;
165
166 hdev->link_policy = __le16_to_cpu(rp->policy);
167}
168
169static void hci_cc_write_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
170{
171 __u8 status = *((__u8 *) skb->data);
172 void *sent;
173
174 BT_DBG("%s status 0x%x", hdev->name, status);
175
176 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
177 if (!sent)
178 return;
179
180 if (!status)
181 hdev->link_policy = get_unaligned_le16(sent);
182
Johan Hedberg23bb5762010-12-21 23:01:27 +0200183 hci_req_complete(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, status);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200184}
185
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200186static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
187{
188 __u8 status = *((__u8 *) skb->data);
189
190 BT_DBG("%s status 0x%x", hdev->name, status);
191
Gustavo F. Padovan10572132011-03-16 15:36:29 -0300192 clear_bit(HCI_RESET, &hdev->flags);
193
Johan Hedberg23bb5762010-12-21 23:01:27 +0200194 hci_req_complete(hdev, HCI_OP_RESET, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200195}
196
197static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
198{
199 __u8 status = *((__u8 *) skb->data);
200 void *sent;
201
202 BT_DBG("%s status 0x%x", hdev->name, status);
203
204 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
205 if (!sent)
206 return;
207
Johan Hedbergb312b1612011-03-16 14:29:37 +0200208 if (test_bit(HCI_MGMT, &hdev->flags))
209 mgmt_set_local_name_complete(hdev->id, sent, status);
210
211 if (status)
212 return;
213
Johan Hedberg1f6c6372011-03-16 14:29:35 +0200214 memcpy(hdev->dev_name, sent, HCI_MAX_NAME_LENGTH);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200215}
216
217static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
218{
219 struct hci_rp_read_local_name *rp = (void *) skb->data;
220
221 BT_DBG("%s status 0x%x", hdev->name, rp->status);
222
223 if (rp->status)
224 return;
225
Johan Hedberg1f6c6372011-03-16 14:29:35 +0200226 memcpy(hdev->dev_name, rp->name, HCI_MAX_NAME_LENGTH);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200227}
228
229static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
230{
231 __u8 status = *((__u8 *) skb->data);
232 void *sent;
233
234 BT_DBG("%s status 0x%x", hdev->name, status);
235
236 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
237 if (!sent)
238 return;
239
240 if (!status) {
241 __u8 param = *((__u8 *) sent);
242
243 if (param == AUTH_ENABLED)
244 set_bit(HCI_AUTH, &hdev->flags);
245 else
246 clear_bit(HCI_AUTH, &hdev->flags);
247 }
248
Johan Hedberg23bb5762010-12-21 23:01:27 +0200249 hci_req_complete(hdev, HCI_OP_WRITE_AUTH_ENABLE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200250}
251
252static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
253{
254 __u8 status = *((__u8 *) skb->data);
255 void *sent;
256
257 BT_DBG("%s status 0x%x", hdev->name, status);
258
259 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
260 if (!sent)
261 return;
262
263 if (!status) {
264 __u8 param = *((__u8 *) sent);
265
266 if (param)
267 set_bit(HCI_ENCRYPT, &hdev->flags);
268 else
269 clear_bit(HCI_ENCRYPT, &hdev->flags);
270 }
271
Johan Hedberg23bb5762010-12-21 23:01:27 +0200272 hci_req_complete(hdev, HCI_OP_WRITE_ENCRYPT_MODE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200273}
274
275static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
276{
277 __u8 status = *((__u8 *) skb->data);
278 void *sent;
279
280 BT_DBG("%s status 0x%x", hdev->name, status);
281
282 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
283 if (!sent)
284 return;
285
286 if (!status) {
287 __u8 param = *((__u8 *) sent);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200288 int old_pscan, old_iscan;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200289
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200290 old_pscan = test_and_clear_bit(HCI_PSCAN, &hdev->flags);
291 old_iscan = test_and_clear_bit(HCI_ISCAN, &hdev->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200292
Johan Hedberg73f22f62010-12-29 16:00:25 +0200293 if (param & SCAN_INQUIRY) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200294 set_bit(HCI_ISCAN, &hdev->flags);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200295 if (!old_iscan)
296 mgmt_discoverable(hdev->id, 1);
297 } else if (old_iscan)
Johan Hedberg73f22f62010-12-29 16:00:25 +0200298 mgmt_discoverable(hdev->id, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200299
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200300 if (param & SCAN_PAGE) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200301 set_bit(HCI_PSCAN, &hdev->flags);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200302 if (!old_pscan)
303 mgmt_connectable(hdev->id, 1);
304 } else if (old_pscan)
305 mgmt_connectable(hdev->id, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200306 }
307
Johan Hedberg23bb5762010-12-21 23:01:27 +0200308 hci_req_complete(hdev, HCI_OP_WRITE_SCAN_ENABLE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200309}
310
311static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
312{
313 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
314
315 BT_DBG("%s status 0x%x", hdev->name, rp->status);
316
317 if (rp->status)
318 return;
319
320 memcpy(hdev->dev_class, rp->dev_class, 3);
321
322 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
323 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
324}
325
326static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
327{
328 __u8 status = *((__u8 *) skb->data);
329 void *sent;
330
331 BT_DBG("%s status 0x%x", hdev->name, status);
332
Marcel Holtmannf383f272008-07-14 20:13:47 +0200333 if (status)
334 return;
335
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200336 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
337 if (!sent)
338 return;
339
Marcel Holtmannf383f272008-07-14 20:13:47 +0200340 memcpy(hdev->dev_class, sent, 3);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200341}
342
343static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
344{
345 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 __u16 setting;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200347
348 BT_DBG("%s status 0x%x", hdev->name, rp->status);
349
350 if (rp->status)
351 return;
352
353 setting = __le16_to_cpu(rp->voice_setting);
354
Marcel Holtmannf383f272008-07-14 20:13:47 +0200355 if (hdev->voice_setting == setting)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200356 return;
357
358 hdev->voice_setting = setting;
359
360 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
361
362 if (hdev->notify) {
363 tasklet_disable(&hdev->tx_task);
364 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
365 tasklet_enable(&hdev->tx_task);
366 }
367}
368
369static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
370{
371 __u8 status = *((__u8 *) skb->data);
Marcel Holtmannf383f272008-07-14 20:13:47 +0200372 __u16 setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 void *sent;
374
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200375 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
Marcel Holtmannf383f272008-07-14 20:13:47 +0200377 if (status)
378 return;
379
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200380 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
381 if (!sent)
382 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Marcel Holtmannf383f272008-07-14 20:13:47 +0200384 setting = get_unaligned_le16(sent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Marcel Holtmannf383f272008-07-14 20:13:47 +0200386 if (hdev->voice_setting == setting)
387 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Marcel Holtmannf383f272008-07-14 20:13:47 +0200389 hdev->voice_setting = setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Marcel Holtmannf383f272008-07-14 20:13:47 +0200391 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
392
393 if (hdev->notify) {
394 tasklet_disable(&hdev->tx_task);
395 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
396 tasklet_enable(&hdev->tx_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 }
398}
399
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200400static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200402 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200404 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
Johan Hedberg23bb5762010-12-21 23:01:27 +0200406 hci_req_complete(hdev, HCI_OP_HOST_BUFFER_SIZE, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407}
408
Marcel Holtmann333140b2008-07-14 20:13:48 +0200409static void hci_cc_read_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
410{
411 struct hci_rp_read_ssp_mode *rp = (void *) skb->data;
412
413 BT_DBG("%s status 0x%x", hdev->name, rp->status);
414
415 if (rp->status)
416 return;
417
418 hdev->ssp_mode = rp->mode;
419}
420
421static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
422{
423 __u8 status = *((__u8 *) skb->data);
424 void *sent;
425
426 BT_DBG("%s status 0x%x", hdev->name, status);
427
428 if (status)
429 return;
430
431 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
432 if (!sent)
433 return;
434
435 hdev->ssp_mode = *((__u8 *) sent);
436}
437
Johan Hedbergd5859e22011-01-25 01:19:58 +0200438static u8 hci_get_inquiry_mode(struct hci_dev *hdev)
439{
440 if (hdev->features[6] & LMP_EXT_INQ)
441 return 2;
442
443 if (hdev->features[3] & LMP_RSSI_INQ)
444 return 1;
445
446 if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 &&
447 hdev->lmp_subver == 0x0757)
448 return 1;
449
450 if (hdev->manufacturer == 15) {
451 if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963)
452 return 1;
453 if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963)
454 return 1;
455 if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965)
456 return 1;
457 }
458
459 if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 &&
460 hdev->lmp_subver == 0x1805)
461 return 1;
462
463 return 0;
464}
465
466static void hci_setup_inquiry_mode(struct hci_dev *hdev)
467{
468 u8 mode;
469
470 mode = hci_get_inquiry_mode(hdev);
471
472 hci_send_cmd(hdev, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode);
473}
474
475static void hci_setup_event_mask(struct hci_dev *hdev)
476{
477 /* The second byte is 0xff instead of 0x9f (two reserved bits
478 * disabled) since a Broadcom 1.2 dongle doesn't respond to the
479 * command otherwise */
480 u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 };
481
Ville Tervo6de6c182011-05-27 11:16:21 +0300482 /* CSR 1.1 dongles does not accept any bitfield so don't try to set
483 * any event mask for pre 1.2 devices */
484 if (hdev->lmp_ver <= 1)
485 return;
486
487 events[4] |= 0x01; /* Flow Specification Complete */
488 events[4] |= 0x02; /* Inquiry Result with RSSI */
489 events[4] |= 0x04; /* Read Remote Extended Features Complete */
490 events[5] |= 0x08; /* Synchronous Connection Complete */
491 events[5] |= 0x10; /* Synchronous Connection Changed */
Johan Hedbergd5859e22011-01-25 01:19:58 +0200492
493 if (hdev->features[3] & LMP_RSSI_INQ)
494 events[4] |= 0x04; /* Inquiry Result with RSSI */
495
496 if (hdev->features[5] & LMP_SNIFF_SUBR)
497 events[5] |= 0x20; /* Sniff Subrating */
498
499 if (hdev->features[5] & LMP_PAUSE_ENC)
500 events[5] |= 0x80; /* Encryption Key Refresh Complete */
501
502 if (hdev->features[6] & LMP_EXT_INQ)
503 events[5] |= 0x40; /* Extended Inquiry Result */
504
505 if (hdev->features[6] & LMP_NO_FLUSH)
506 events[7] |= 0x01; /* Enhanced Flush Complete */
507
508 if (hdev->features[7] & LMP_LSTO)
509 events[6] |= 0x80; /* Link Supervision Timeout Changed */
510
511 if (hdev->features[6] & LMP_SIMPLE_PAIR) {
512 events[6] |= 0x01; /* IO Capability Request */
513 events[6] |= 0x02; /* IO Capability Response */
514 events[6] |= 0x04; /* User Confirmation Request */
515 events[6] |= 0x08; /* User Passkey Request */
516 events[6] |= 0x10; /* Remote OOB Data Request */
517 events[6] |= 0x20; /* Simple Pairing Complete */
518 events[7] |= 0x04; /* User Passkey Notification */
519 events[7] |= 0x08; /* Keypress Notification */
520 events[7] |= 0x10; /* Remote Host Supported
521 * Features Notification */
522 }
523
524 if (hdev->features[4] & LMP_LE)
525 events[7] |= 0x20; /* LE Meta-Event */
526
527 hci_send_cmd(hdev, HCI_OP_SET_EVENT_MASK, sizeof(events), events);
528}
529
Andre Guedese6100a22011-06-30 19:20:54 -0300530static void hci_set_le_support(struct hci_dev *hdev)
531{
532 struct hci_cp_write_le_host_supported cp;
533
534 memset(&cp, 0, sizeof(cp));
535
536 if (enable_le) {
537 cp.le = 1;
538 cp.simul = !!(hdev->features[6] & LMP_SIMUL_LE_BR);
539 }
540
541 hci_send_cmd(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), &cp);
542}
543
Johan Hedbergd5859e22011-01-25 01:19:58 +0200544static void hci_setup(struct hci_dev *hdev)
545{
546 hci_setup_event_mask(hdev);
547
548 if (hdev->lmp_ver > 1)
549 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL);
550
551 if (hdev->features[6] & LMP_SIMPLE_PAIR) {
552 u8 mode = 0x01;
553 hci_send_cmd(hdev, HCI_OP_WRITE_SSP_MODE, sizeof(mode), &mode);
554 }
555
556 if (hdev->features[3] & LMP_RSSI_INQ)
557 hci_setup_inquiry_mode(hdev);
558
559 if (hdev->features[7] & LMP_INQ_TX_PWR)
560 hci_send_cmd(hdev, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL);
Andre Guedes971e3a42011-06-30 19:20:52 -0300561
562 if (hdev->features[7] & LMP_EXTFEATURES) {
563 struct hci_cp_read_local_ext_features cp;
564
565 cp.page = 0x01;
566 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_EXT_FEATURES,
567 sizeof(cp), &cp);
568 }
Andre Guedese6100a22011-06-30 19:20:54 -0300569
570 if (hdev->features[4] & LMP_LE)
571 hci_set_le_support(hdev);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200572}
573
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200574static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
575{
576 struct hci_rp_read_local_version *rp = (void *) skb->data;
577
578 BT_DBG("%s status 0x%x", hdev->name, rp->status);
579
580 if (rp->status)
581 return;
582
583 hdev->hci_ver = rp->hci_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200584 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200585 hdev->lmp_ver = rp->lmp_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200586 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200587 hdev->lmp_subver = __le16_to_cpu(rp->lmp_subver);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200588
589 BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
590 hdev->manufacturer,
591 hdev->hci_ver, hdev->hci_rev);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200592
593 if (test_bit(HCI_INIT, &hdev->flags))
594 hci_setup(hdev);
595}
596
597static void hci_setup_link_policy(struct hci_dev *hdev)
598{
599 u16 link_policy = 0;
600
601 if (hdev->features[0] & LMP_RSWITCH)
602 link_policy |= HCI_LP_RSWITCH;
603 if (hdev->features[0] & LMP_HOLD)
604 link_policy |= HCI_LP_HOLD;
605 if (hdev->features[0] & LMP_SNIFF)
606 link_policy |= HCI_LP_SNIFF;
607 if (hdev->features[1] & LMP_PARK)
608 link_policy |= HCI_LP_PARK;
609
610 link_policy = cpu_to_le16(link_policy);
611 hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY,
612 sizeof(link_policy), &link_policy);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200613}
614
615static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb)
616{
617 struct hci_rp_read_local_commands *rp = (void *) skb->data;
618
619 BT_DBG("%s status 0x%x", hdev->name, rp->status);
620
621 if (rp->status)
Johan Hedbergd5859e22011-01-25 01:19:58 +0200622 goto done;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200623
624 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
Johan Hedbergd5859e22011-01-25 01:19:58 +0200625
626 if (test_bit(HCI_INIT, &hdev->flags) && (hdev->commands[5] & 0x10))
627 hci_setup_link_policy(hdev);
628
629done:
630 hci_req_complete(hdev, HCI_OP_READ_LOCAL_COMMANDS, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200631}
632
633static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb)
634{
635 struct hci_rp_read_local_features *rp = (void *) skb->data;
636
637 BT_DBG("%s status 0x%x", hdev->name, rp->status);
638
639 if (rp->status)
640 return;
641
642 memcpy(hdev->features, rp->features, 8);
643
644 /* Adjust default settings according to features
645 * supported by device. */
646
647 if (hdev->features[0] & LMP_3SLOT)
648 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
649
650 if (hdev->features[0] & LMP_5SLOT)
651 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
652
653 if (hdev->features[1] & LMP_HV2) {
654 hdev->pkt_type |= (HCI_HV2);
655 hdev->esco_type |= (ESCO_HV2);
656 }
657
658 if (hdev->features[1] & LMP_HV3) {
659 hdev->pkt_type |= (HCI_HV3);
660 hdev->esco_type |= (ESCO_HV3);
661 }
662
663 if (hdev->features[3] & LMP_ESCO)
664 hdev->esco_type |= (ESCO_EV3);
665
666 if (hdev->features[4] & LMP_EV4)
667 hdev->esco_type |= (ESCO_EV4);
668
669 if (hdev->features[4] & LMP_EV5)
670 hdev->esco_type |= (ESCO_EV5);
671
Marcel Holtmannefc76882009-02-06 09:13:37 +0100672 if (hdev->features[5] & LMP_EDR_ESCO_2M)
673 hdev->esco_type |= (ESCO_2EV3);
674
675 if (hdev->features[5] & LMP_EDR_ESCO_3M)
676 hdev->esco_type |= (ESCO_3EV3);
677
678 if (hdev->features[5] & LMP_EDR_3S_ESCO)
679 hdev->esco_type |= (ESCO_2EV5 | ESCO_3EV5);
680
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200681 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
682 hdev->features[0], hdev->features[1],
683 hdev->features[2], hdev->features[3],
684 hdev->features[4], hdev->features[5],
685 hdev->features[6], hdev->features[7]);
686}
687
Andre Guedes971e3a42011-06-30 19:20:52 -0300688static void hci_cc_read_local_ext_features(struct hci_dev *hdev,
689 struct sk_buff *skb)
690{
691 struct hci_rp_read_local_ext_features *rp = (void *) skb->data;
692
693 BT_DBG("%s status 0x%x", hdev->name, rp->status);
694
695 if (rp->status)
696 return;
697
698 memcpy(hdev->extfeatures, rp->features, 8);
699
700 hci_req_complete(hdev, HCI_OP_READ_LOCAL_EXT_FEATURES, rp->status);
701}
702
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200703static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
704{
705 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
706
707 BT_DBG("%s status 0x%x", hdev->name, rp->status);
708
709 if (rp->status)
710 return;
711
712 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
713 hdev->sco_mtu = rp->sco_mtu;
714 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
715 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
716
717 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
718 hdev->sco_mtu = 64;
719 hdev->sco_pkts = 8;
720 }
721
722 hdev->acl_cnt = hdev->acl_pkts;
723 hdev->sco_cnt = hdev->sco_pkts;
724
725 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
726 hdev->acl_mtu, hdev->acl_pkts,
727 hdev->sco_mtu, hdev->sco_pkts);
728}
729
730static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
731{
732 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
733
734 BT_DBG("%s status 0x%x", hdev->name, rp->status);
735
736 if (!rp->status)
737 bacpy(&hdev->bdaddr, &rp->bdaddr);
738
Johan Hedberg23bb5762010-12-21 23:01:27 +0200739 hci_req_complete(hdev, HCI_OP_READ_BD_ADDR, rp->status);
740}
741
742static void hci_cc_write_ca_timeout(struct hci_dev *hdev, struct sk_buff *skb)
743{
744 __u8 status = *((__u8 *) skb->data);
745
746 BT_DBG("%s status 0x%x", hdev->name, status);
747
748 hci_req_complete(hdev, HCI_OP_WRITE_CA_TIMEOUT, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200749}
750
Johan Hedbergb0916ea2011-01-10 13:44:55 +0200751static void hci_cc_delete_stored_link_key(struct hci_dev *hdev,
752 struct sk_buff *skb)
753{
754 __u8 status = *((__u8 *) skb->data);
755
756 BT_DBG("%s status 0x%x", hdev->name, status);
757
758 hci_req_complete(hdev, HCI_OP_DELETE_STORED_LINK_KEY, status);
759}
760
Johan Hedbergd5859e22011-01-25 01:19:58 +0200761static void hci_cc_set_event_mask(struct hci_dev *hdev, struct sk_buff *skb)
762{
763 __u8 status = *((__u8 *) skb->data);
764
765 BT_DBG("%s status 0x%x", hdev->name, status);
766
767 hci_req_complete(hdev, HCI_OP_SET_EVENT_MASK, status);
768}
769
770static void hci_cc_write_inquiry_mode(struct hci_dev *hdev,
771 struct sk_buff *skb)
772{
773 __u8 status = *((__u8 *) skb->data);
774
775 BT_DBG("%s status 0x%x", hdev->name, status);
776
777 hci_req_complete(hdev, HCI_OP_WRITE_INQUIRY_MODE, status);
778}
779
780static void hci_cc_read_inq_rsp_tx_power(struct hci_dev *hdev,
781 struct sk_buff *skb)
782{
783 __u8 status = *((__u8 *) skb->data);
784
785 BT_DBG("%s status 0x%x", hdev->name, status);
786
787 hci_req_complete(hdev, HCI_OP_READ_INQ_RSP_TX_POWER, status);
788}
789
790static void hci_cc_set_event_flt(struct hci_dev *hdev, struct sk_buff *skb)
791{
792 __u8 status = *((__u8 *) skb->data);
793
794 BT_DBG("%s status 0x%x", hdev->name, status);
795
796 hci_req_complete(hdev, HCI_OP_SET_EVENT_FLT, status);
797}
798
Johan Hedberg980e1a52011-01-22 06:10:07 +0200799static void hci_cc_pin_code_reply(struct hci_dev *hdev, struct sk_buff *skb)
800{
801 struct hci_rp_pin_code_reply *rp = (void *) skb->data;
802 struct hci_cp_pin_code_reply *cp;
803 struct hci_conn *conn;
804
805 BT_DBG("%s status 0x%x", hdev->name, rp->status);
806
807 if (test_bit(HCI_MGMT, &hdev->flags))
808 mgmt_pin_code_reply_complete(hdev->id, &rp->bdaddr, rp->status);
809
810 if (rp->status != 0)
811 return;
812
813 cp = hci_sent_cmd_data(hdev, HCI_OP_PIN_CODE_REPLY);
814 if (!cp)
815 return;
816
817 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
818 if (conn)
819 conn->pin_length = cp->pin_len;
820}
821
822static void hci_cc_pin_code_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
823{
824 struct hci_rp_pin_code_neg_reply *rp = (void *) skb->data;
825
826 BT_DBG("%s status 0x%x", hdev->name, rp->status);
827
828 if (test_bit(HCI_MGMT, &hdev->flags))
829 mgmt_pin_code_neg_reply_complete(hdev->id, &rp->bdaddr,
830 rp->status);
831}
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300832static void hci_cc_le_read_buffer_size(struct hci_dev *hdev,
833 struct sk_buff *skb)
834{
835 struct hci_rp_le_read_buffer_size *rp = (void *) skb->data;
836
837 BT_DBG("%s status 0x%x", hdev->name, rp->status);
838
839 if (rp->status)
840 return;
841
842 hdev->le_mtu = __le16_to_cpu(rp->le_mtu);
843 hdev->le_pkts = rp->le_max_pkt;
844
845 hdev->le_cnt = hdev->le_pkts;
846
847 BT_DBG("%s le mtu %d:%d", hdev->name, hdev->le_mtu, hdev->le_pkts);
848
849 hci_req_complete(hdev, HCI_OP_LE_READ_BUFFER_SIZE, rp->status);
850}
Johan Hedberg980e1a52011-01-22 06:10:07 +0200851
Johan Hedberga5c29682011-02-19 12:05:57 -0300852static void hci_cc_user_confirm_reply(struct hci_dev *hdev, struct sk_buff *skb)
853{
854 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
855
856 BT_DBG("%s status 0x%x", hdev->name, rp->status);
857
858 if (test_bit(HCI_MGMT, &hdev->flags))
859 mgmt_user_confirm_reply_complete(hdev->id, &rp->bdaddr,
860 rp->status);
861}
862
863static void hci_cc_user_confirm_neg_reply(struct hci_dev *hdev,
864 struct sk_buff *skb)
865{
866 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
867
868 BT_DBG("%s status 0x%x", hdev->name, rp->status);
869
870 if (test_bit(HCI_MGMT, &hdev->flags))
871 mgmt_user_confirm_neg_reply_complete(hdev->id, &rp->bdaddr,
872 rp->status);
873}
874
Szymon Jancc35938b2011-03-22 13:12:21 +0100875static void hci_cc_read_local_oob_data_reply(struct hci_dev *hdev,
876 struct sk_buff *skb)
877{
878 struct hci_rp_read_local_oob_data *rp = (void *) skb->data;
879
880 BT_DBG("%s status 0x%x", hdev->name, rp->status);
881
882 mgmt_read_local_oob_data_reply_complete(hdev->id, rp->hash,
883 rp->randomizer, rp->status);
884}
885
Andre Guedeseb9d91f2011-05-26 16:23:52 -0300886static void hci_cc_le_set_scan_enable(struct hci_dev *hdev,
887 struct sk_buff *skb)
888{
889 struct hci_cp_le_set_scan_enable *cp;
890 __u8 status = *((__u8 *) skb->data);
891
892 BT_DBG("%s status 0x%x", hdev->name, status);
893
894 if (status)
895 return;
896
897 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_SCAN_ENABLE);
898 if (!cp)
899 return;
900
901 hci_dev_lock(hdev);
902
Andre Guedes35815082011-05-26 16:23:53 -0300903 if (cp->enable == 0x01) {
904 del_timer(&hdev->adv_timer);
Andre Guedeseb9d91f2011-05-26 16:23:52 -0300905 hci_adv_entries_clear(hdev);
Andre Guedes35815082011-05-26 16:23:53 -0300906 } else if (cp->enable == 0x00) {
907 mod_timer(&hdev->adv_timer, jiffies + ADV_CLEAR_TIMEOUT);
908 }
Andre Guedeseb9d91f2011-05-26 16:23:52 -0300909
910 hci_dev_unlock(hdev);
911}
912
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300913static void hci_cc_le_ltk_reply(struct hci_dev *hdev, struct sk_buff *skb)
914{
915 struct hci_rp_le_ltk_reply *rp = (void *) skb->data;
916
917 BT_DBG("%s status 0x%x", hdev->name, rp->status);
918
919 if (rp->status)
920 return;
921
922 hci_req_complete(hdev, HCI_OP_LE_LTK_REPLY, rp->status);
923}
924
925static void hci_cc_le_ltk_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
926{
927 struct hci_rp_le_ltk_neg_reply *rp = (void *) skb->data;
928
929 BT_DBG("%s status 0x%x", hdev->name, rp->status);
930
931 if (rp->status)
932 return;
933
934 hci_req_complete(hdev, HCI_OP_LE_LTK_NEG_REPLY, rp->status);
935}
936
Andre Guedesf9b49302011-06-30 19:20:53 -0300937static inline void hci_cc_write_le_host_supported(struct hci_dev *hdev,
938 struct sk_buff *skb)
939{
940 struct hci_cp_read_local_ext_features cp;
941 __u8 status = *((__u8 *) skb->data);
942
943 BT_DBG("%s status 0x%x", hdev->name, status);
944
945 if (status)
946 return;
947
948 cp.page = 0x01;
949 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_EXT_FEATURES, sizeof(cp), &cp);
950}
951
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200952static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
953{
954 BT_DBG("%s status 0x%x", hdev->name, status);
955
956 if (status) {
Johan Hedberg23bb5762010-12-21 23:01:27 +0200957 hci_req_complete(hdev, HCI_OP_INQUIRY, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200958 hci_conn_check_pending(hdev);
Johan Hedberg314b2382011-04-27 10:29:57 -0400959 return;
960 }
961
962 if (test_bit(HCI_MGMT, &hdev->flags) &&
963 !test_and_set_bit(HCI_INQUIRY,
964 &hdev->flags))
965 mgmt_discovering(hdev->id, 1);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200966}
967
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
969{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200970 struct hci_cp_create_conn *cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200973 BT_DBG("%s status 0x%x", hdev->name, status);
974
975 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 if (!cp)
977 return;
978
979 hci_dev_lock(hdev);
980
981 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
982
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200983 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984
985 if (status) {
986 if (conn && conn->state == BT_CONNECT) {
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200987 if (status != 0x0c || conn->attempt > 2) {
988 conn->state = BT_CLOSED;
989 hci_proto_connect_cfm(conn, status);
990 hci_conn_del(conn);
991 } else
992 conn->state = BT_CONNECT2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 }
994 } else {
995 if (!conn) {
996 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
997 if (conn) {
998 conn->out = 1;
999 conn->link_mode |= HCI_LM_MASTER;
1000 } else
Gustavo F. Padovan893ef972010-07-18 15:13:37 -03001001 BT_ERR("No memory for new connection");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 }
1003 }
1004
1005 hci_dev_unlock(hdev);
1006}
1007
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001008static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001010 struct hci_cp_add_sco *cp;
1011 struct hci_conn *acl, *sco;
1012 __u16 handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001014 BT_DBG("%s status 0x%x", hdev->name, status);
1015
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001016 if (!status)
1017 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001019 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
1020 if (!cp)
1021 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001023 handle = __le16_to_cpu(cp->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001025 BT_DBG("%s handle %d", hdev->name, handle);
Marcel Holtmann6bd57412006-11-18 22:14:22 +01001026
1027 hci_dev_lock(hdev);
1028
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001029 acl = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001030 if (acl) {
1031 sco = acl->link;
1032 if (sco) {
1033 sco->state = BT_CLOSED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001034
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001035 hci_proto_connect_cfm(sco, status);
1036 hci_conn_del(sco);
1037 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001038 }
Marcel Holtmann6bd57412006-11-18 22:14:22 +01001039
1040 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041}
1042
Marcel Holtmannf8558552008-07-14 20:13:49 +02001043static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
1044{
1045 struct hci_cp_auth_requested *cp;
1046 struct hci_conn *conn;
1047
1048 BT_DBG("%s status 0x%x", hdev->name, status);
1049
1050 if (!status)
1051 return;
1052
1053 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
1054 if (!cp)
1055 return;
1056
1057 hci_dev_lock(hdev);
1058
1059 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1060 if (conn) {
1061 if (conn->state == BT_CONFIG) {
1062 hci_proto_connect_cfm(conn, status);
1063 hci_conn_put(conn);
1064 }
1065 }
1066
1067 hci_dev_unlock(hdev);
1068}
1069
1070static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
1071{
1072 struct hci_cp_set_conn_encrypt *cp;
1073 struct hci_conn *conn;
1074
1075 BT_DBG("%s status 0x%x", hdev->name, status);
1076
1077 if (!status)
1078 return;
1079
1080 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
1081 if (!cp)
1082 return;
1083
1084 hci_dev_lock(hdev);
1085
1086 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1087 if (conn) {
1088 if (conn->state == BT_CONFIG) {
1089 hci_proto_connect_cfm(conn, status);
1090 hci_conn_put(conn);
1091 }
1092 }
1093
1094 hci_dev_unlock(hdev);
1095}
1096
Johan Hedberg127178d2010-11-18 22:22:29 +02001097static int hci_outgoing_auth_needed(struct hci_dev *hdev,
Szymon Janc138d22e2011-02-17 16:44:23 +01001098 struct hci_conn *conn)
Johan Hedberg392599b2010-11-18 22:22:28 +02001099{
Johan Hedberg392599b2010-11-18 22:22:28 +02001100 if (conn->state != BT_CONFIG || !conn->out)
1101 return 0;
1102
Johan Hedberg765c2a92011-01-19 12:06:52 +05301103 if (conn->pending_sec_level == BT_SECURITY_SDP)
Johan Hedberg392599b2010-11-18 22:22:28 +02001104 return 0;
1105
1106 /* Only request authentication for SSP connections or non-SSP
1107 * devices with sec_level HIGH */
1108 if (!(hdev->ssp_mode > 0 && conn->ssp_mode > 0) &&
Johan Hedberg765c2a92011-01-19 12:06:52 +05301109 conn->pending_sec_level != BT_SECURITY_HIGH)
Johan Hedberg392599b2010-11-18 22:22:28 +02001110 return 0;
1111
Johan Hedberg392599b2010-11-18 22:22:28 +02001112 return 1;
1113}
1114
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001115static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
1116{
Johan Hedberg127178d2010-11-18 22:22:29 +02001117 struct hci_cp_remote_name_req *cp;
1118 struct hci_conn *conn;
1119
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001120 BT_DBG("%s status 0x%x", hdev->name, status);
Johan Hedberg127178d2010-11-18 22:22:29 +02001121
1122 /* If successful wait for the name req complete event before
1123 * checking for the need to do authentication */
1124 if (!status)
1125 return;
1126
1127 cp = hci_sent_cmd_data(hdev, HCI_OP_REMOTE_NAME_REQ);
1128 if (!cp)
1129 return;
1130
1131 hci_dev_lock(hdev);
1132
1133 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
Johan Hedberg79c6c702011-04-28 11:28:55 -07001134 if (!conn)
1135 goto unlock;
1136
1137 if (!hci_outgoing_auth_needed(hdev, conn))
1138 goto unlock;
1139
1140 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02001141 struct hci_cp_auth_requested cp;
1142 cp.handle = __cpu_to_le16(conn->handle);
1143 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
1144 }
1145
Johan Hedberg79c6c702011-04-28 11:28:55 -07001146unlock:
Johan Hedberg127178d2010-11-18 22:22:29 +02001147 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001148}
1149
Marcel Holtmann769be972008-07-14 20:13:49 +02001150static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
1151{
1152 struct hci_cp_read_remote_features *cp;
1153 struct hci_conn *conn;
1154
1155 BT_DBG("%s status 0x%x", hdev->name, status);
1156
1157 if (!status)
1158 return;
1159
1160 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
1161 if (!cp)
1162 return;
1163
1164 hci_dev_lock(hdev);
1165
1166 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1167 if (conn) {
1168 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001169 hci_proto_connect_cfm(conn, status);
1170 hci_conn_put(conn);
1171 }
1172 }
1173
1174 hci_dev_unlock(hdev);
1175}
1176
1177static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
1178{
1179 struct hci_cp_read_remote_ext_features *cp;
1180 struct hci_conn *conn;
1181
1182 BT_DBG("%s status 0x%x", hdev->name, status);
1183
1184 if (!status)
1185 return;
1186
1187 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
1188 if (!cp)
1189 return;
1190
1191 hci_dev_lock(hdev);
1192
1193 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1194 if (conn) {
1195 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001196 hci_proto_connect_cfm(conn, status);
1197 hci_conn_put(conn);
1198 }
1199 }
1200
1201 hci_dev_unlock(hdev);
1202}
1203
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001204static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
1205{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001206 struct hci_cp_setup_sync_conn *cp;
1207 struct hci_conn *acl, *sco;
1208 __u16 handle;
1209
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001210 BT_DBG("%s status 0x%x", hdev->name, status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001211
1212 if (!status)
1213 return;
1214
1215 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
1216 if (!cp)
1217 return;
1218
1219 handle = __le16_to_cpu(cp->handle);
1220
1221 BT_DBG("%s handle %d", hdev->name, handle);
1222
1223 hci_dev_lock(hdev);
1224
1225 acl = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001226 if (acl) {
1227 sco = acl->link;
1228 if (sco) {
1229 sco->state = BT_CLOSED;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001230
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001231 hci_proto_connect_cfm(sco, status);
1232 hci_conn_del(sco);
1233 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001234 }
1235
1236 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001237}
1238
1239static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
1240{
1241 struct hci_cp_sniff_mode *cp;
1242 struct hci_conn *conn;
1243
1244 BT_DBG("%s status 0x%x", hdev->name, status);
1245
1246 if (!status)
1247 return;
1248
1249 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
1250 if (!cp)
1251 return;
1252
1253 hci_dev_lock(hdev);
1254
1255 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001256 if (conn) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001257 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
1258
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001259 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
1260 hci_sco_setup(conn, status);
1261 }
1262
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001263 hci_dev_unlock(hdev);
1264}
1265
1266static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
1267{
1268 struct hci_cp_exit_sniff_mode *cp;
1269 struct hci_conn *conn;
1270
1271 BT_DBG("%s status 0x%x", hdev->name, status);
1272
1273 if (!status)
1274 return;
1275
1276 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
1277 if (!cp)
1278 return;
1279
1280 hci_dev_lock(hdev);
1281
1282 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001283 if (conn) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001284 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
1285
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001286 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
1287 hci_sco_setup(conn, status);
1288 }
1289
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001290 hci_dev_unlock(hdev);
1291}
1292
Ville Tervofcd89c02011-02-10 22:38:47 -03001293static void hci_cs_le_create_conn(struct hci_dev *hdev, __u8 status)
1294{
1295 struct hci_cp_le_create_conn *cp;
1296 struct hci_conn *conn;
1297
1298 BT_DBG("%s status 0x%x", hdev->name, status);
1299
1300 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_CREATE_CONN);
1301 if (!cp)
1302 return;
1303
1304 hci_dev_lock(hdev);
1305
1306 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &cp->peer_addr);
1307
1308 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->peer_addr),
1309 conn);
1310
1311 if (status) {
1312 if (conn && conn->state == BT_CONNECT) {
1313 conn->state = BT_CLOSED;
1314 hci_proto_connect_cfm(conn, status);
1315 hci_conn_del(conn);
1316 }
1317 } else {
1318 if (!conn) {
1319 conn = hci_conn_add(hdev, LE_LINK, &cp->peer_addr);
Andre Guedes29b79882011-05-31 14:20:54 -03001320 if (conn) {
1321 conn->dst_type = cp->peer_addr_type;
Ville Tervofcd89c02011-02-10 22:38:47 -03001322 conn->out = 1;
Andre Guedes29b79882011-05-31 14:20:54 -03001323 } else {
Ville Tervofcd89c02011-02-10 22:38:47 -03001324 BT_ERR("No memory for new connection");
Andre Guedes29b79882011-05-31 14:20:54 -03001325 }
Ville Tervofcd89c02011-02-10 22:38:47 -03001326 }
1327 }
1328
1329 hci_dev_unlock(hdev);
1330}
1331
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03001332static void hci_cs_le_start_enc(struct hci_dev *hdev, u8 status)
1333{
1334 BT_DBG("%s status 0x%x", hdev->name, status);
1335}
1336
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001337static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1338{
1339 __u8 status = *((__u8 *) skb->data);
1340
1341 BT_DBG("%s status %d", hdev->name, status);
1342
Johan Hedberg314b2382011-04-27 10:29:57 -04001343 if (test_bit(HCI_MGMT, &hdev->flags) &&
1344 test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
1345 mgmt_discovering(hdev->id, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001346
Johan Hedberg23bb5762010-12-21 23:01:27 +02001347 hci_req_complete(hdev, HCI_OP_INQUIRY, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001348
1349 hci_conn_check_pending(hdev);
1350}
1351
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1353{
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001354 struct inquiry_data data;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001355 struct inquiry_info *info = (void *) (skb->data + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 int num_rsp = *((__u8 *) skb->data);
1357
1358 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1359
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001360 if (!num_rsp)
1361 return;
1362
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001364
Johan Hedberg314b2382011-04-27 10:29:57 -04001365 if (!test_and_set_bit(HCI_INQUIRY, &hdev->flags)) {
1366
1367 if (test_bit(HCI_MGMT, &hdev->flags))
1368 mgmt_discovering(hdev->id, 1);
1369 }
1370
Johan Hedberge17acd42011-03-30 23:57:16 +03001371 for (; num_rsp; num_rsp--, info++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 bacpy(&data.bdaddr, &info->bdaddr);
1373 data.pscan_rep_mode = info->pscan_rep_mode;
1374 data.pscan_period_mode = info->pscan_period_mode;
1375 data.pscan_mode = info->pscan_mode;
1376 memcpy(data.dev_class, info->dev_class, 3);
1377 data.clock_offset = info->clock_offset;
1378 data.rssi = 0x00;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001379 data.ssp_mode = 0x00;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 hci_inquiry_cache_update(hdev, &data);
Johan Hedberge17acd42011-03-30 23:57:16 +03001381 mgmt_device_found(hdev->id, &info->bdaddr, info->dev_class, 0,
1382 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001384
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 hci_dev_unlock(hdev);
1386}
1387
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001388static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001390 struct hci_ev_conn_complete *ev = (void *) skb->data;
1391 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001393 BT_DBG("%s", hdev->name);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001394
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001396
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001397 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann94992372009-04-19 19:30:03 +02001398 if (!conn) {
1399 if (ev->link_type != SCO_LINK)
1400 goto unlock;
1401
1402 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1403 if (!conn)
1404 goto unlock;
1405
1406 conn->type = SCO_LINK;
1407 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001408
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001409 if (!ev->status) {
1410 conn->handle = __le16_to_cpu(ev->handle);
Marcel Holtmann769be972008-07-14 20:13:49 +02001411
1412 if (conn->type == ACL_LINK) {
1413 conn->state = BT_CONFIG;
1414 hci_conn_hold(conn);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001415 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Johan Hedbergf7520542011-01-20 12:34:39 +02001416 mgmt_connected(hdev->id, &ev->bdaddr);
Marcel Holtmann769be972008-07-14 20:13:49 +02001417 } else
1418 conn->state = BT_CONNECTED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001419
Marcel Holtmann9eba32b2009-08-22 14:19:26 -07001420 hci_conn_hold_device(conn);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001421 hci_conn_add_sysfs(conn);
1422
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001423 if (test_bit(HCI_AUTH, &hdev->flags))
1424 conn->link_mode |= HCI_LM_AUTH;
1425
1426 if (test_bit(HCI_ENCRYPT, &hdev->flags))
1427 conn->link_mode |= HCI_LM_ENCRYPT;
1428
1429 /* Get remote features */
1430 if (conn->type == ACL_LINK) {
1431 struct hci_cp_read_remote_features cp;
1432 cp.handle = ev->handle;
Marcel Holtmann769be972008-07-14 20:13:49 +02001433 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
1434 sizeof(cp), &cp);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001435 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001436
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001437 /* Set packet type for incoming connection */
Marcel Holtmanna8746412008-07-14 20:13:46 +02001438 if (!conn->out && hdev->hci_ver < 3) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001439 struct hci_cp_change_conn_ptype cp;
1440 cp.handle = ev->handle;
Marcel Holtmanna8746412008-07-14 20:13:46 +02001441 cp.pkt_type = cpu_to_le16(conn->pkt_type);
1442 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
1443 sizeof(cp), &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001444 }
Johan Hedberg17d5c042011-01-22 06:09:08 +02001445 } else {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001446 conn->state = BT_CLOSED;
Johan Hedberg17d5c042011-01-22 06:09:08 +02001447 if (conn->type == ACL_LINK)
1448 mgmt_connect_failed(hdev->id, &ev->bdaddr, ev->status);
1449 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001450
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001451 if (conn->type == ACL_LINK)
1452 hci_sco_setup(conn, ev->status);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001453
Marcel Holtmann769be972008-07-14 20:13:49 +02001454 if (ev->status) {
1455 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001456 hci_conn_del(conn);
Marcel Holtmannc89b6e62009-01-15 21:57:03 +01001457 } else if (ev->link_type != ACL_LINK)
1458 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001459
1460unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001462
1463 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464}
1465
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1467{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001468 struct hci_ev_conn_request *ev = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 int mask = hdev->link_mode;
1470
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001471 BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
1472 batostr(&ev->bdaddr), ev->link_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473
1474 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
1475
Szymon Janc138d22e2011-02-17 16:44:23 +01001476 if ((mask & HCI_LM_ACCEPT) &&
1477 !hci_blacklist_lookup(hdev, &ev->bdaddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 /* Connection accepted */
Marcel Holtmannc7bdd502008-07-14 20:13:47 +02001479 struct inquiry_entry *ie;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481
1482 hci_dev_lock(hdev);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001483
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02001484 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
1485 if (ie)
Marcel Holtmannc7bdd502008-07-14 20:13:47 +02001486 memcpy(ie->data.dev_class, ev->dev_class, 3);
1487
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
1489 if (!conn) {
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02001490 conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr);
1491 if (!conn) {
Gustavo F. Padovan893ef972010-07-18 15:13:37 -03001492 BT_ERR("No memory for new connection");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 hci_dev_unlock(hdev);
1494 return;
1495 }
1496 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001497
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 memcpy(conn->dev_class, ev->dev_class, 3);
1499 conn->state = BT_CONNECT;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001500
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 hci_dev_unlock(hdev);
1502
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001503 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
1504 struct hci_cp_accept_conn_req cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001506 bacpy(&cp.bdaddr, &ev->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001508 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
1509 cp.role = 0x00; /* Become master */
1510 else
1511 cp.role = 0x01; /* Remain slave */
1512
1513 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
1514 sizeof(cp), &cp);
1515 } else {
1516 struct hci_cp_accept_sync_conn_req cp;
1517
1518 bacpy(&cp.bdaddr, &ev->bdaddr);
Marcel Holtmanna8746412008-07-14 20:13:46 +02001519 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001520
1521 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
1522 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
1523 cp.max_latency = cpu_to_le16(0xffff);
1524 cp.content_format = cpu_to_le16(hdev->voice_setting);
1525 cp.retrans_effort = 0xff;
1526
1527 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
1528 sizeof(cp), &cp);
1529 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 } else {
1531 /* Connection rejected */
1532 struct hci_cp_reject_conn_req cp;
1533
1534 bacpy(&cp.bdaddr, &ev->bdaddr);
1535 cp.reason = 0x0f;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001536 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 }
1538}
1539
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1541{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001542 struct hci_ev_disconn_complete *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001543 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544
1545 BT_DBG("%s status %d", hdev->name, ev->status);
1546
Johan Hedberg8962ee72011-01-20 12:40:27 +02001547 if (ev->status) {
1548 mgmt_disconnect_failed(hdev->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 return;
Johan Hedberg8962ee72011-01-20 12:40:27 +02001550 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551
1552 hci_dev_lock(hdev);
1553
Marcel Holtmann04837f62006-07-03 10:02:33 +02001554 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergf7520542011-01-20 12:34:39 +02001555 if (!conn)
1556 goto unlock;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001557
Johan Hedbergf7520542011-01-20 12:34:39 +02001558 conn->state = BT_CLOSED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559
Vinicius Costa Gomes83bc71b2011-05-06 18:41:43 -03001560 if (conn->type == ACL_LINK || conn->type == LE_LINK)
Johan Hedbergf7520542011-01-20 12:34:39 +02001561 mgmt_disconnected(hdev->id, &conn->dst);
1562
1563 hci_proto_disconn_cfm(conn, ev->reason);
1564 hci_conn_del(conn);
1565
1566unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 hci_dev_unlock(hdev);
1568}
1569
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001570static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1571{
1572 struct hci_ev_auth_complete *ev = (void *) skb->data;
1573 struct hci_conn *conn;
1574
1575 BT_DBG("%s status %d", hdev->name, ev->status);
1576
1577 hci_dev_lock(hdev);
1578
1579 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001580 if (!conn)
1581 goto unlock;
1582
1583 if (!ev->status) {
1584 if (!(conn->ssp_mode > 0 && hdev->ssp_mode > 0) &&
1585 test_bit(HCI_CONN_REAUTH_PEND, &conn->pend)) {
1586 BT_INFO("re-auth of legacy device is not possible.");
Johan Hedberg2a611692011-02-19 12:06:00 -03001587 } else {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001588 conn->link_mode |= HCI_LM_AUTH;
1589 conn->sec_level = conn->pending_sec_level;
Johan Hedberg2a611692011-02-19 12:06:00 -03001590 }
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001591 } else {
1592 mgmt_auth_failed(hdev->id, &conn->dst, ev->status);
1593 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001594
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001595 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1596 clear_bit(HCI_CONN_REAUTH_PEND, &conn->pend);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001597
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001598 if (conn->state == BT_CONFIG) {
1599 if (!ev->status && hdev->ssp_mode > 0 && conn->ssp_mode > 0) {
1600 struct hci_cp_set_conn_encrypt cp;
1601 cp.handle = ev->handle;
1602 cp.encrypt = 0x01;
1603 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
1604 &cp);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001605 } else {
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001606 conn->state = BT_CONNECTED;
1607 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001608 hci_conn_put(conn);
1609 }
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001610 } else {
1611 hci_auth_cfm(conn, ev->status);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001612
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001613 hci_conn_hold(conn);
1614 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
1615 hci_conn_put(conn);
1616 }
1617
1618 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
1619 if (!ev->status) {
1620 struct hci_cp_set_conn_encrypt cp;
1621 cp.handle = ev->handle;
1622 cp.encrypt = 0x01;
1623 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
1624 &cp);
1625 } else {
1626 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1627 hci_encrypt_cfm(conn, ev->status, 0x00);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001628 }
1629 }
1630
Waldemar Rymarkiewiczd7556e22011-05-31 15:49:26 +02001631unlock:
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001632 hci_dev_unlock(hdev);
1633}
1634
1635static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
1636{
Johan Hedberg127178d2010-11-18 22:22:29 +02001637 struct hci_ev_remote_name *ev = (void *) skb->data;
1638 struct hci_conn *conn;
1639
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001640 BT_DBG("%s", hdev->name);
1641
1642 hci_conn_check_pending(hdev);
Johan Hedberg127178d2010-11-18 22:22:29 +02001643
1644 hci_dev_lock(hdev);
1645
Johan Hedberga88a9652011-03-30 13:18:12 +03001646 if (ev->status == 0 && test_bit(HCI_MGMT, &hdev->flags))
1647 mgmt_remote_name(hdev->id, &ev->bdaddr, ev->name);
1648
Johan Hedberg127178d2010-11-18 22:22:29 +02001649 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg79c6c702011-04-28 11:28:55 -07001650 if (!conn)
1651 goto unlock;
1652
1653 if (!hci_outgoing_auth_needed(hdev, conn))
1654 goto unlock;
1655
1656 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02001657 struct hci_cp_auth_requested cp;
1658 cp.handle = __cpu_to_le16(conn->handle);
1659 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
1660 }
1661
Johan Hedberg79c6c702011-04-28 11:28:55 -07001662unlock:
Johan Hedberg127178d2010-11-18 22:22:29 +02001663 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001664}
1665
1666static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1667{
1668 struct hci_ev_encrypt_change *ev = (void *) skb->data;
1669 struct hci_conn *conn;
1670
1671 BT_DBG("%s status %d", hdev->name, ev->status);
1672
1673 hci_dev_lock(hdev);
1674
1675 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1676 if (conn) {
1677 if (!ev->status) {
Marcel Holtmannae293192008-07-14 20:13:45 +02001678 if (ev->encrypt) {
1679 /* Encryption implies authentication */
1680 conn->link_mode |= HCI_LM_AUTH;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001681 conn->link_mode |= HCI_LM_ENCRYPT;
Vinicius Costa Gomesda85e5e2011-06-09 18:50:53 -03001682 conn->sec_level = conn->pending_sec_level;
Marcel Holtmannae293192008-07-14 20:13:45 +02001683 } else
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001684 conn->link_mode &= ~HCI_LM_ENCRYPT;
1685 }
1686
1687 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1688
Marcel Holtmannf8558552008-07-14 20:13:49 +02001689 if (conn->state == BT_CONFIG) {
1690 if (!ev->status)
1691 conn->state = BT_CONNECTED;
1692
1693 hci_proto_connect_cfm(conn, ev->status);
1694 hci_conn_put(conn);
1695 } else
1696 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001697 }
1698
1699 hci_dev_unlock(hdev);
1700}
1701
1702static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1703{
1704 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
1705 struct hci_conn *conn;
1706
1707 BT_DBG("%s status %d", hdev->name, ev->status);
1708
1709 hci_dev_lock(hdev);
1710
1711 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1712 if (conn) {
1713 if (!ev->status)
1714 conn->link_mode |= HCI_LM_SECURE;
1715
1716 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1717
1718 hci_key_change_cfm(conn, ev->status);
1719 }
1720
1721 hci_dev_unlock(hdev);
1722}
1723
1724static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1725{
1726 struct hci_ev_remote_features *ev = (void *) skb->data;
1727 struct hci_conn *conn;
1728
1729 BT_DBG("%s status %d", hdev->name, ev->status);
1730
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001731 hci_dev_lock(hdev);
1732
1733 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergccd556f2010-11-10 17:11:51 +02001734 if (!conn)
1735 goto unlock;
Marcel Holtmann769be972008-07-14 20:13:49 +02001736
Johan Hedbergccd556f2010-11-10 17:11:51 +02001737 if (!ev->status)
1738 memcpy(conn->features, ev->features, 8);
1739
1740 if (conn->state != BT_CONFIG)
1741 goto unlock;
1742
1743 if (!ev->status && lmp_ssp_capable(hdev) && lmp_ssp_capable(conn)) {
1744 struct hci_cp_read_remote_ext_features cp;
1745 cp.handle = ev->handle;
1746 cp.page = 0x01;
1747 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES,
Marcel Holtmann769be972008-07-14 20:13:49 +02001748 sizeof(cp), &cp);
Johan Hedberg392599b2010-11-18 22:22:28 +02001749 goto unlock;
1750 }
1751
Johan Hedberg127178d2010-11-18 22:22:29 +02001752 if (!ev->status) {
1753 struct hci_cp_remote_name_req cp;
1754 memset(&cp, 0, sizeof(cp));
1755 bacpy(&cp.bdaddr, &conn->dst);
1756 cp.pscan_rep_mode = 0x02;
1757 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
1758 }
Johan Hedberg392599b2010-11-18 22:22:28 +02001759
Johan Hedberg127178d2010-11-18 22:22:29 +02001760 if (!hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedbergccd556f2010-11-10 17:11:51 +02001761 conn->state = BT_CONNECTED;
1762 hci_proto_connect_cfm(conn, ev->status);
1763 hci_conn_put(conn);
Marcel Holtmann769be972008-07-14 20:13:49 +02001764 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001765
Johan Hedbergccd556f2010-11-10 17:11:51 +02001766unlock:
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001767 hci_dev_unlock(hdev);
1768}
1769
1770static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
1771{
1772 BT_DBG("%s", hdev->name);
1773}
1774
1775static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1776{
1777 BT_DBG("%s", hdev->name);
1778}
1779
1780static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1781{
1782 struct hci_ev_cmd_complete *ev = (void *) skb->data;
1783 __u16 opcode;
1784
1785 skb_pull(skb, sizeof(*ev));
1786
1787 opcode = __le16_to_cpu(ev->opcode);
1788
1789 switch (opcode) {
1790 case HCI_OP_INQUIRY_CANCEL:
1791 hci_cc_inquiry_cancel(hdev, skb);
1792 break;
1793
1794 case HCI_OP_EXIT_PERIODIC_INQ:
1795 hci_cc_exit_periodic_inq(hdev, skb);
1796 break;
1797
1798 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
1799 hci_cc_remote_name_req_cancel(hdev, skb);
1800 break;
1801
1802 case HCI_OP_ROLE_DISCOVERY:
1803 hci_cc_role_discovery(hdev, skb);
1804 break;
1805
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001806 case HCI_OP_READ_LINK_POLICY:
1807 hci_cc_read_link_policy(hdev, skb);
1808 break;
1809
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001810 case HCI_OP_WRITE_LINK_POLICY:
1811 hci_cc_write_link_policy(hdev, skb);
1812 break;
1813
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001814 case HCI_OP_READ_DEF_LINK_POLICY:
1815 hci_cc_read_def_link_policy(hdev, skb);
1816 break;
1817
1818 case HCI_OP_WRITE_DEF_LINK_POLICY:
1819 hci_cc_write_def_link_policy(hdev, skb);
1820 break;
1821
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001822 case HCI_OP_RESET:
1823 hci_cc_reset(hdev, skb);
1824 break;
1825
1826 case HCI_OP_WRITE_LOCAL_NAME:
1827 hci_cc_write_local_name(hdev, skb);
1828 break;
1829
1830 case HCI_OP_READ_LOCAL_NAME:
1831 hci_cc_read_local_name(hdev, skb);
1832 break;
1833
1834 case HCI_OP_WRITE_AUTH_ENABLE:
1835 hci_cc_write_auth_enable(hdev, skb);
1836 break;
1837
1838 case HCI_OP_WRITE_ENCRYPT_MODE:
1839 hci_cc_write_encrypt_mode(hdev, skb);
1840 break;
1841
1842 case HCI_OP_WRITE_SCAN_ENABLE:
1843 hci_cc_write_scan_enable(hdev, skb);
1844 break;
1845
1846 case HCI_OP_READ_CLASS_OF_DEV:
1847 hci_cc_read_class_of_dev(hdev, skb);
1848 break;
1849
1850 case HCI_OP_WRITE_CLASS_OF_DEV:
1851 hci_cc_write_class_of_dev(hdev, skb);
1852 break;
1853
1854 case HCI_OP_READ_VOICE_SETTING:
1855 hci_cc_read_voice_setting(hdev, skb);
1856 break;
1857
1858 case HCI_OP_WRITE_VOICE_SETTING:
1859 hci_cc_write_voice_setting(hdev, skb);
1860 break;
1861
1862 case HCI_OP_HOST_BUFFER_SIZE:
1863 hci_cc_host_buffer_size(hdev, skb);
1864 break;
1865
Marcel Holtmann333140b2008-07-14 20:13:48 +02001866 case HCI_OP_READ_SSP_MODE:
1867 hci_cc_read_ssp_mode(hdev, skb);
1868 break;
1869
1870 case HCI_OP_WRITE_SSP_MODE:
1871 hci_cc_write_ssp_mode(hdev, skb);
1872 break;
1873
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001874 case HCI_OP_READ_LOCAL_VERSION:
1875 hci_cc_read_local_version(hdev, skb);
1876 break;
1877
1878 case HCI_OP_READ_LOCAL_COMMANDS:
1879 hci_cc_read_local_commands(hdev, skb);
1880 break;
1881
1882 case HCI_OP_READ_LOCAL_FEATURES:
1883 hci_cc_read_local_features(hdev, skb);
1884 break;
1885
Andre Guedes971e3a42011-06-30 19:20:52 -03001886 case HCI_OP_READ_LOCAL_EXT_FEATURES:
1887 hci_cc_read_local_ext_features(hdev, skb);
1888 break;
1889
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001890 case HCI_OP_READ_BUFFER_SIZE:
1891 hci_cc_read_buffer_size(hdev, skb);
1892 break;
1893
1894 case HCI_OP_READ_BD_ADDR:
1895 hci_cc_read_bd_addr(hdev, skb);
1896 break;
1897
Johan Hedberg23bb5762010-12-21 23:01:27 +02001898 case HCI_OP_WRITE_CA_TIMEOUT:
1899 hci_cc_write_ca_timeout(hdev, skb);
1900 break;
1901
Johan Hedbergb0916ea2011-01-10 13:44:55 +02001902 case HCI_OP_DELETE_STORED_LINK_KEY:
1903 hci_cc_delete_stored_link_key(hdev, skb);
1904 break;
1905
Johan Hedbergd5859e22011-01-25 01:19:58 +02001906 case HCI_OP_SET_EVENT_MASK:
1907 hci_cc_set_event_mask(hdev, skb);
1908 break;
1909
1910 case HCI_OP_WRITE_INQUIRY_MODE:
1911 hci_cc_write_inquiry_mode(hdev, skb);
1912 break;
1913
1914 case HCI_OP_READ_INQ_RSP_TX_POWER:
1915 hci_cc_read_inq_rsp_tx_power(hdev, skb);
1916 break;
1917
1918 case HCI_OP_SET_EVENT_FLT:
1919 hci_cc_set_event_flt(hdev, skb);
1920 break;
1921
Johan Hedberg980e1a52011-01-22 06:10:07 +02001922 case HCI_OP_PIN_CODE_REPLY:
1923 hci_cc_pin_code_reply(hdev, skb);
1924 break;
1925
1926 case HCI_OP_PIN_CODE_NEG_REPLY:
1927 hci_cc_pin_code_neg_reply(hdev, skb);
1928 break;
1929
Szymon Jancc35938b2011-03-22 13:12:21 +01001930 case HCI_OP_READ_LOCAL_OOB_DATA:
1931 hci_cc_read_local_oob_data_reply(hdev, skb);
1932 break;
1933
Ville Tervo6ed58ec2011-02-10 22:38:48 -03001934 case HCI_OP_LE_READ_BUFFER_SIZE:
1935 hci_cc_le_read_buffer_size(hdev, skb);
1936 break;
1937
Johan Hedberga5c29682011-02-19 12:05:57 -03001938 case HCI_OP_USER_CONFIRM_REPLY:
1939 hci_cc_user_confirm_reply(hdev, skb);
1940 break;
1941
1942 case HCI_OP_USER_CONFIRM_NEG_REPLY:
1943 hci_cc_user_confirm_neg_reply(hdev, skb);
1944 break;
1945
Andre Guedeseb9d91f2011-05-26 16:23:52 -03001946 case HCI_OP_LE_SET_SCAN_ENABLE:
1947 hci_cc_le_set_scan_enable(hdev, skb);
1948 break;
1949
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03001950 case HCI_OP_LE_LTK_REPLY:
1951 hci_cc_le_ltk_reply(hdev, skb);
1952 break;
1953
1954 case HCI_OP_LE_LTK_NEG_REPLY:
1955 hci_cc_le_ltk_neg_reply(hdev, skb);
1956 break;
1957
Andre Guedesf9b49302011-06-30 19:20:53 -03001958 case HCI_OP_WRITE_LE_HOST_SUPPORTED:
1959 hci_cc_write_le_host_supported(hdev, skb);
1960 break;
1961
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001962 default:
1963 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1964 break;
1965 }
1966
Ville Tervo6bd32322011-02-16 16:32:41 +02001967 if (ev->opcode != HCI_OP_NOP)
1968 del_timer(&hdev->cmd_timer);
1969
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001970 if (ev->ncmd) {
1971 atomic_set(&hdev->cmd_cnt, 1);
1972 if (!skb_queue_empty(&hdev->cmd_q))
Marcel Holtmannc78ae282009-11-18 01:02:54 +01001973 tasklet_schedule(&hdev->cmd_task);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001974 }
1975}
1976
1977static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1978{
1979 struct hci_ev_cmd_status *ev = (void *) skb->data;
1980 __u16 opcode;
1981
1982 skb_pull(skb, sizeof(*ev));
1983
1984 opcode = __le16_to_cpu(ev->opcode);
1985
1986 switch (opcode) {
1987 case HCI_OP_INQUIRY:
1988 hci_cs_inquiry(hdev, ev->status);
1989 break;
1990
1991 case HCI_OP_CREATE_CONN:
1992 hci_cs_create_conn(hdev, ev->status);
1993 break;
1994
1995 case HCI_OP_ADD_SCO:
1996 hci_cs_add_sco(hdev, ev->status);
1997 break;
1998
Marcel Holtmannf8558552008-07-14 20:13:49 +02001999 case HCI_OP_AUTH_REQUESTED:
2000 hci_cs_auth_requested(hdev, ev->status);
2001 break;
2002
2003 case HCI_OP_SET_CONN_ENCRYPT:
2004 hci_cs_set_conn_encrypt(hdev, ev->status);
2005 break;
2006
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002007 case HCI_OP_REMOTE_NAME_REQ:
2008 hci_cs_remote_name_req(hdev, ev->status);
2009 break;
2010
Marcel Holtmann769be972008-07-14 20:13:49 +02002011 case HCI_OP_READ_REMOTE_FEATURES:
2012 hci_cs_read_remote_features(hdev, ev->status);
2013 break;
2014
2015 case HCI_OP_READ_REMOTE_EXT_FEATURES:
2016 hci_cs_read_remote_ext_features(hdev, ev->status);
2017 break;
2018
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002019 case HCI_OP_SETUP_SYNC_CONN:
2020 hci_cs_setup_sync_conn(hdev, ev->status);
2021 break;
2022
2023 case HCI_OP_SNIFF_MODE:
2024 hci_cs_sniff_mode(hdev, ev->status);
2025 break;
2026
2027 case HCI_OP_EXIT_SNIFF_MODE:
2028 hci_cs_exit_sniff_mode(hdev, ev->status);
2029 break;
2030
Johan Hedberg8962ee72011-01-20 12:40:27 +02002031 case HCI_OP_DISCONNECT:
2032 if (ev->status != 0)
2033 mgmt_disconnect_failed(hdev->id);
2034 break;
2035
Ville Tervofcd89c02011-02-10 22:38:47 -03002036 case HCI_OP_LE_CREATE_CONN:
2037 hci_cs_le_create_conn(hdev, ev->status);
2038 break;
2039
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03002040 case HCI_OP_LE_START_ENC:
2041 hci_cs_le_start_enc(hdev, ev->status);
2042 break;
2043
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002044 default:
2045 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
2046 break;
2047 }
2048
Ville Tervo6bd32322011-02-16 16:32:41 +02002049 if (ev->opcode != HCI_OP_NOP)
2050 del_timer(&hdev->cmd_timer);
2051
Gustavo F. Padovan10572132011-03-16 15:36:29 -03002052 if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags)) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002053 atomic_set(&hdev->cmd_cnt, 1);
2054 if (!skb_queue_empty(&hdev->cmd_q))
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002055 tasklet_schedule(&hdev->cmd_task);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002056 }
2057}
2058
2059static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
2060{
2061 struct hci_ev_role_change *ev = (void *) skb->data;
2062 struct hci_conn *conn;
2063
2064 BT_DBG("%s status %d", hdev->name, ev->status);
2065
2066 hci_dev_lock(hdev);
2067
2068 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2069 if (conn) {
2070 if (!ev->status) {
2071 if (ev->role)
2072 conn->link_mode &= ~HCI_LM_MASTER;
2073 else
2074 conn->link_mode |= HCI_LM_MASTER;
2075 }
2076
2077 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
2078
2079 hci_role_switch_cfm(conn, ev->status, ev->role);
2080 }
2081
2082 hci_dev_unlock(hdev);
2083}
2084
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
2086{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002087 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08002088 __le16 *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 int i;
2090
2091 skb_pull(skb, sizeof(*ev));
2092
2093 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
2094
2095 if (skb->len < ev->num_hndl * 4) {
2096 BT_DBG("%s bad parameters", hdev->name);
2097 return;
2098 }
2099
2100 tasklet_disable(&hdev->tx_task);
2101
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08002102 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 struct hci_conn *conn;
2104 __u16 handle, count;
2105
Harvey Harrison83985312008-05-02 16:25:46 -07002106 handle = get_unaligned_le16(ptr++);
2107 count = get_unaligned_le16(ptr++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108
2109 conn = hci_conn_hash_lookup_handle(hdev, handle);
2110 if (conn) {
2111 conn->sent -= count;
2112
Marcel Holtmann5b7f99092007-07-11 09:51:55 +02002113 if (conn->type == ACL_LINK) {
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002114 hdev->acl_cnt += count;
2115 if (hdev->acl_cnt > hdev->acl_pkts)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 hdev->acl_cnt = hdev->acl_pkts;
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002117 } else if (conn->type == LE_LINK) {
2118 if (hdev->le_pkts) {
2119 hdev->le_cnt += count;
2120 if (hdev->le_cnt > hdev->le_pkts)
2121 hdev->le_cnt = hdev->le_pkts;
2122 } else {
2123 hdev->acl_cnt += count;
2124 if (hdev->acl_cnt > hdev->acl_pkts)
2125 hdev->acl_cnt = hdev->acl_pkts;
2126 }
Marcel Holtmann5b7f99092007-07-11 09:51:55 +02002127 } else {
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002128 hdev->sco_cnt += count;
2129 if (hdev->sco_cnt > hdev->sco_pkts)
Marcel Holtmann5b7f99092007-07-11 09:51:55 +02002130 hdev->sco_cnt = hdev->sco_pkts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 }
2132 }
2133 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002134
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002135 tasklet_schedule(&hdev->tx_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136
2137 tasklet_enable(&hdev->tx_task);
2138}
2139
Marcel Holtmann04837f62006-07-03 10:02:33 +02002140static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002142 struct hci_ev_mode_change *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002143 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144
2145 BT_DBG("%s status %d", hdev->name, ev->status);
2146
2147 hci_dev_lock(hdev);
2148
Marcel Holtmann04837f62006-07-03 10:02:33 +02002149 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2150 if (conn) {
2151 conn->mode = ev->mode;
2152 conn->interval = __le16_to_cpu(ev->interval);
2153
2154 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
2155 if (conn->mode == HCI_CM_ACTIVE)
2156 conn->power_save = 1;
2157 else
2158 conn->power_save = 0;
2159 }
Marcel Holtmanne73439d2010-07-26 10:06:00 -04002160
2161 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
2162 hci_sco_setup(conn, ev->status);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002163 }
2164
2165 hci_dev_unlock(hdev);
2166}
2167
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
2169{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002170 struct hci_ev_pin_code_req *ev = (void *) skb->data;
2171 struct hci_conn *conn;
2172
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002173 BT_DBG("%s", hdev->name);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002174
2175 hci_dev_lock(hdev);
2176
2177 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Marcel Holtmann3d7a9d12009-05-09 12:09:21 -07002178 if (conn && conn->state == BT_CONNECTED) {
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002179 hci_conn_hold(conn);
2180 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
2181 hci_conn_put(conn);
2182 }
2183
Johan Hedberg03b555e2011-01-04 15:40:05 +02002184 if (!test_bit(HCI_PAIRABLE, &hdev->flags))
2185 hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
2186 sizeof(ev->bdaddr), &ev->bdaddr);
Johan Hedberg582fbe92011-04-28 11:28:58 -07002187 else if (test_bit(HCI_MGMT, &hdev->flags)) {
Waldemar Rymarkiewicza770bb52011-04-28 12:07:59 +02002188 u8 secure;
2189
2190 if (conn->pending_sec_level == BT_SECURITY_HIGH)
2191 secure = 1;
2192 else
2193 secure = 0;
2194
2195 mgmt_pin_code_request(hdev->id, &ev->bdaddr, secure);
2196 }
Johan Hedberg980e1a52011-01-22 06:10:07 +02002197
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002198 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199}
2200
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
2202{
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002203 struct hci_ev_link_key_req *ev = (void *) skb->data;
2204 struct hci_cp_link_key_reply cp;
2205 struct hci_conn *conn;
2206 struct link_key *key;
2207
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002208 BT_DBG("%s", hdev->name);
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002209
2210 if (!test_bit(HCI_LINK_KEYS, &hdev->flags))
2211 return;
2212
2213 hci_dev_lock(hdev);
2214
2215 key = hci_find_link_key(hdev, &ev->bdaddr);
2216 if (!key) {
2217 BT_DBG("%s link key not found for %s", hdev->name,
2218 batostr(&ev->bdaddr));
2219 goto not_found;
2220 }
2221
2222 BT_DBG("%s found key type %u for %s", hdev->name, key->type,
2223 batostr(&ev->bdaddr));
2224
Waldemar Rymarkiewiczb6020ba2011-04-28 12:07:53 +02002225 if (!test_bit(HCI_DEBUG_KEYS, &hdev->flags) &&
2226 key->type == HCI_LK_DEBUG_COMBINATION) {
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002227 BT_DBG("%s ignoring debug key", hdev->name);
2228 goto not_found;
2229 }
2230
2231 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002232 if (conn) {
2233 if (key->type == HCI_LK_UNAUTH_COMBINATION &&
2234 conn->auth_type != 0xff &&
2235 (conn->auth_type & 0x01)) {
2236 BT_DBG("%s ignoring unauthenticated key", hdev->name);
2237 goto not_found;
2238 }
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002239
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002240 if (key->type == HCI_LK_COMBINATION && key->pin_len < 16 &&
2241 conn->pending_sec_level == BT_SECURITY_HIGH) {
2242 BT_DBG("%s ignoring key unauthenticated for high \
2243 security", hdev->name);
2244 goto not_found;
2245 }
2246
2247 conn->key_type = key->type;
2248 conn->pin_length = key->pin_len;
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002249 }
2250
2251 bacpy(&cp.bdaddr, &ev->bdaddr);
2252 memcpy(cp.link_key, key->val, 16);
2253
2254 hci_send_cmd(hdev, HCI_OP_LINK_KEY_REPLY, sizeof(cp), &cp);
2255
2256 hci_dev_unlock(hdev);
2257
2258 return;
2259
2260not_found:
2261 hci_send_cmd(hdev, HCI_OP_LINK_KEY_NEG_REPLY, 6, &ev->bdaddr);
2262 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263}
2264
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
2266{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002267 struct hci_ev_link_key_notify *ev = (void *) skb->data;
2268 struct hci_conn *conn;
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002269 u8 pin_len = 0;
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002270
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002271 BT_DBG("%s", hdev->name);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002272
2273 hci_dev_lock(hdev);
2274
2275 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2276 if (conn) {
2277 hci_conn_hold(conn);
2278 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Johan Hedberg980e1a52011-01-22 06:10:07 +02002279 pin_len = conn->pin_length;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02002280
2281 if (ev->key_type != HCI_LK_CHANGED_COMBINATION)
2282 conn->key_type = ev->key_type;
2283
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002284 hci_conn_put(conn);
2285 }
2286
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002287 if (test_bit(HCI_LINK_KEYS, &hdev->flags))
Johan Hedbergd25e28a2011-04-28 11:28:59 -07002288 hci_add_link_key(hdev, conn, 1, &ev->bdaddr, ev->link_key,
Johan Hedberg55ed8ca2011-01-17 14:41:05 +02002289 ev->key_type, pin_len);
2290
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002291 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292}
2293
Marcel Holtmann04837f62006-07-03 10:02:33 +02002294static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
2295{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002296 struct hci_ev_clock_offset *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002297 struct hci_conn *conn;
2298
2299 BT_DBG("%s status %d", hdev->name, ev->status);
2300
2301 hci_dev_lock(hdev);
2302
2303 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 if (conn && !ev->status) {
2305 struct inquiry_entry *ie;
2306
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002307 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2308 if (ie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 ie->data.clock_offset = ev->clock_offset;
2310 ie->timestamp = jiffies;
2311 }
2312 }
2313
2314 hci_dev_unlock(hdev);
2315}
2316
Marcel Holtmanna8746412008-07-14 20:13:46 +02002317static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
2318{
2319 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
2320 struct hci_conn *conn;
2321
2322 BT_DBG("%s status %d", hdev->name, ev->status);
2323
2324 hci_dev_lock(hdev);
2325
2326 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2327 if (conn && !ev->status)
2328 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
2329
2330 hci_dev_unlock(hdev);
2331}
2332
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002333static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
2334{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002335 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002336 struct inquiry_entry *ie;
2337
2338 BT_DBG("%s", hdev->name);
2339
2340 hci_dev_lock(hdev);
2341
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002342 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
2343 if (ie) {
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002344 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
2345 ie->timestamp = jiffies;
2346 }
2347
2348 hci_dev_unlock(hdev);
2349}
2350
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002351static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
2352{
2353 struct inquiry_data data;
2354 int num_rsp = *((__u8 *) skb->data);
2355
2356 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
2357
2358 if (!num_rsp)
2359 return;
2360
2361 hci_dev_lock(hdev);
2362
Johan Hedberg314b2382011-04-27 10:29:57 -04002363 if (!test_and_set_bit(HCI_INQUIRY, &hdev->flags)) {
2364
2365 if (test_bit(HCI_MGMT, &hdev->flags))
2366 mgmt_discovering(hdev->id, 1);
2367 }
2368
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002369 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
Szymon Janc138d22e2011-02-17 16:44:23 +01002370 struct inquiry_info_with_rssi_and_pscan_mode *info;
2371 info = (void *) (skb->data + 1);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002372
Johan Hedberge17acd42011-03-30 23:57:16 +03002373 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002374 bacpy(&data.bdaddr, &info->bdaddr);
2375 data.pscan_rep_mode = info->pscan_rep_mode;
2376 data.pscan_period_mode = info->pscan_period_mode;
2377 data.pscan_mode = info->pscan_mode;
2378 memcpy(data.dev_class, info->dev_class, 3);
2379 data.clock_offset = info->clock_offset;
2380 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002381 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002382 hci_inquiry_cache_update(hdev, &data);
Johan Hedberge17acd42011-03-30 23:57:16 +03002383 mgmt_device_found(hdev->id, &info->bdaddr,
2384 info->dev_class, info->rssi,
2385 NULL);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002386 }
2387 } else {
2388 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
2389
Johan Hedberge17acd42011-03-30 23:57:16 +03002390 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002391 bacpy(&data.bdaddr, &info->bdaddr);
2392 data.pscan_rep_mode = info->pscan_rep_mode;
2393 data.pscan_period_mode = info->pscan_period_mode;
2394 data.pscan_mode = 0x00;
2395 memcpy(data.dev_class, info->dev_class, 3);
2396 data.clock_offset = info->clock_offset;
2397 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002398 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002399 hci_inquiry_cache_update(hdev, &data);
Johan Hedberge17acd42011-03-30 23:57:16 +03002400 mgmt_device_found(hdev->id, &info->bdaddr,
2401 info->dev_class, info->rssi,
2402 NULL);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002403 }
2404 }
2405
2406 hci_dev_unlock(hdev);
2407}
2408
2409static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
2410{
Marcel Holtmann41a96212008-07-14 20:13:48 +02002411 struct hci_ev_remote_ext_features *ev = (void *) skb->data;
2412 struct hci_conn *conn;
2413
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002414 BT_DBG("%s", hdev->name);
Marcel Holtmann41a96212008-07-14 20:13:48 +02002415
Marcel Holtmann41a96212008-07-14 20:13:48 +02002416 hci_dev_lock(hdev);
2417
2418 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergccd556f2010-11-10 17:11:51 +02002419 if (!conn)
2420 goto unlock;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002421
Johan Hedbergccd556f2010-11-10 17:11:51 +02002422 if (!ev->status && ev->page == 0x01) {
2423 struct inquiry_entry *ie;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002424
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002425 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2426 if (ie)
Johan Hedbergccd556f2010-11-10 17:11:51 +02002427 ie->data.ssp_mode = (ev->features[0] & 0x01);
Marcel Holtmann769be972008-07-14 20:13:49 +02002428
Johan Hedbergccd556f2010-11-10 17:11:51 +02002429 conn->ssp_mode = (ev->features[0] & 0x01);
Marcel Holtmann41a96212008-07-14 20:13:48 +02002430 }
2431
Johan Hedbergccd556f2010-11-10 17:11:51 +02002432 if (conn->state != BT_CONFIG)
2433 goto unlock;
2434
Johan Hedberg127178d2010-11-18 22:22:29 +02002435 if (!ev->status) {
2436 struct hci_cp_remote_name_req cp;
2437 memset(&cp, 0, sizeof(cp));
2438 bacpy(&cp.bdaddr, &conn->dst);
2439 cp.pscan_rep_mode = 0x02;
2440 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
2441 }
Johan Hedberg392599b2010-11-18 22:22:28 +02002442
Johan Hedberg127178d2010-11-18 22:22:29 +02002443 if (!hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedbergccd556f2010-11-10 17:11:51 +02002444 conn->state = BT_CONNECTED;
2445 hci_proto_connect_cfm(conn, ev->status);
2446 hci_conn_put(conn);
2447 }
2448
2449unlock:
Marcel Holtmann41a96212008-07-14 20:13:48 +02002450 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002451}
2452
2453static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
2454{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002455 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
2456 struct hci_conn *conn;
2457
2458 BT_DBG("%s status %d", hdev->name, ev->status);
2459
2460 hci_dev_lock(hdev);
2461
2462 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann9dc0a3a2008-07-14 20:13:46 +02002463 if (!conn) {
2464 if (ev->link_type == ESCO_LINK)
2465 goto unlock;
2466
2467 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
2468 if (!conn)
2469 goto unlock;
2470
2471 conn->type = SCO_LINK;
2472 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002473
Marcel Holtmann732547f2009-04-19 19:14:14 +02002474 switch (ev->status) {
2475 case 0x00:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002476 conn->handle = __le16_to_cpu(ev->handle);
2477 conn->state = BT_CONNECTED;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02002478
Marcel Holtmann9eba32b2009-08-22 14:19:26 -07002479 hci_conn_hold_device(conn);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02002480 hci_conn_add_sysfs(conn);
Marcel Holtmann732547f2009-04-19 19:14:14 +02002481 break;
2482
Stephen Coe705e5712010-02-16 11:29:44 -05002483 case 0x11: /* Unsupported Feature or Parameter Value */
Marcel Holtmann732547f2009-04-19 19:14:14 +02002484 case 0x1c: /* SCO interval rejected */
Nick Pelly1038a002010-02-03 11:42:26 -08002485 case 0x1a: /* Unsupported Remote Feature */
Marcel Holtmann732547f2009-04-19 19:14:14 +02002486 case 0x1f: /* Unspecified error */
2487 if (conn->out && conn->attempt < 2) {
2488 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
2489 (hdev->esco_type & EDR_ESCO_MASK);
2490 hci_setup_sync(conn, conn->link->handle);
2491 goto unlock;
2492 }
2493 /* fall through */
2494
2495 default:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002496 conn->state = BT_CLOSED;
Marcel Holtmann732547f2009-04-19 19:14:14 +02002497 break;
2498 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002499
2500 hci_proto_connect_cfm(conn, ev->status);
2501 if (ev->status)
2502 hci_conn_del(conn);
2503
2504unlock:
2505 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002506}
2507
2508static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
2509{
2510 BT_DBG("%s", hdev->name);
2511}
2512
Marcel Holtmann04837f62006-07-03 10:02:33 +02002513static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
2514{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002515 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002516
2517 BT_DBG("%s status %d", hdev->name, ev->status);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002518}
2519
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002520static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
2521{
2522 struct inquiry_data data;
2523 struct extended_inquiry_info *info = (void *) (skb->data + 1);
2524 int num_rsp = *((__u8 *) skb->data);
2525
2526 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
2527
2528 if (!num_rsp)
2529 return;
2530
Johan Hedberg314b2382011-04-27 10:29:57 -04002531 if (!test_and_set_bit(HCI_INQUIRY, &hdev->flags)) {
2532
2533 if (test_bit(HCI_MGMT, &hdev->flags))
2534 mgmt_discovering(hdev->id, 1);
2535 }
2536
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002537 hci_dev_lock(hdev);
2538
Johan Hedberge17acd42011-03-30 23:57:16 +03002539 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002540 bacpy(&data.bdaddr, &info->bdaddr);
Szymon Janc138d22e2011-02-17 16:44:23 +01002541 data.pscan_rep_mode = info->pscan_rep_mode;
2542 data.pscan_period_mode = info->pscan_period_mode;
2543 data.pscan_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002544 memcpy(data.dev_class, info->dev_class, 3);
Szymon Janc138d22e2011-02-17 16:44:23 +01002545 data.clock_offset = info->clock_offset;
2546 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002547 data.ssp_mode = 0x01;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002548 hci_inquiry_cache_update(hdev, &data);
Johan Hedberge17acd42011-03-30 23:57:16 +03002549 mgmt_device_found(hdev->id, &info->bdaddr, info->dev_class,
2550 info->rssi, info->data);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002551 }
2552
2553 hci_dev_unlock(hdev);
2554}
2555
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002556static inline u8 hci_get_auth_req(struct hci_conn *conn)
2557{
2558 /* If remote requests dedicated bonding follow that lead */
2559 if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) {
2560 /* If both remote and local IO capabilities allow MITM
2561 * protection then require it, otherwise don't */
2562 if (conn->remote_cap == 0x03 || conn->io_capability == 0x03)
2563 return 0x02;
2564 else
2565 return 0x03;
2566 }
2567
2568 /* If remote requests no-bonding follow that lead */
2569 if (conn->remote_auth == 0x00 || conn->remote_auth == 0x01)
Waldemar Rymarkiewicz58797bf2011-04-28 12:07:58 +02002570 return conn->remote_auth | (conn->auth_type & 0x01);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002571
2572 return conn->auth_type;
2573}
2574
Marcel Holtmann04936842008-07-14 20:13:48 +02002575static inline void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
2576{
2577 struct hci_ev_io_capa_request *ev = (void *) skb->data;
2578 struct hci_conn *conn;
2579
2580 BT_DBG("%s", hdev->name);
2581
2582 hci_dev_lock(hdev);
2583
2584 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg03b555e2011-01-04 15:40:05 +02002585 if (!conn)
2586 goto unlock;
Marcel Holtmann04936842008-07-14 20:13:48 +02002587
Johan Hedberg03b555e2011-01-04 15:40:05 +02002588 hci_conn_hold(conn);
2589
2590 if (!test_bit(HCI_MGMT, &hdev->flags))
2591 goto unlock;
2592
2593 if (test_bit(HCI_PAIRABLE, &hdev->flags) ||
2594 (conn->remote_auth & ~0x01) == HCI_AT_NO_BONDING) {
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002595 struct hci_cp_io_capability_reply cp;
2596
2597 bacpy(&cp.bdaddr, &ev->bdaddr);
2598 cp.capability = conn->io_capability;
Johan Hedberg7cbc9bd2011-04-28 11:29:04 -07002599 conn->auth_type = hci_get_auth_req(conn);
2600 cp.authentication = conn->auth_type;
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002601
Szymon Jancce85ee12011-03-22 13:12:23 +01002602 if ((conn->out == 0x01 || conn->remote_oob == 0x01) &&
2603 hci_find_remote_oob_data(hdev, &conn->dst))
2604 cp.oob_data = 0x01;
2605 else
2606 cp.oob_data = 0x00;
2607
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002608 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_REPLY,
2609 sizeof(cp), &cp);
Johan Hedberg03b555e2011-01-04 15:40:05 +02002610 } else {
2611 struct hci_cp_io_capability_neg_reply cp;
2612
2613 bacpy(&cp.bdaddr, &ev->bdaddr);
Johan Hedbergbe771592011-04-28 11:28:57 -07002614 cp.reason = 0x18; /* Pairing not allowed */
Johan Hedberg03b555e2011-01-04 15:40:05 +02002615
2616 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_NEG_REPLY,
2617 sizeof(cp), &cp);
2618 }
2619
2620unlock:
2621 hci_dev_unlock(hdev);
2622}
2623
2624static inline void hci_io_capa_reply_evt(struct hci_dev *hdev, struct sk_buff *skb)
2625{
2626 struct hci_ev_io_capa_reply *ev = (void *) skb->data;
2627 struct hci_conn *conn;
2628
2629 BT_DBG("%s", hdev->name);
2630
2631 hci_dev_lock(hdev);
2632
2633 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2634 if (!conn)
2635 goto unlock;
2636
Johan Hedberg03b555e2011-01-04 15:40:05 +02002637 conn->remote_cap = ev->capability;
2638 conn->remote_oob = ev->oob_data;
2639 conn->remote_auth = ev->authentication;
2640
2641unlock:
Marcel Holtmann04936842008-07-14 20:13:48 +02002642 hci_dev_unlock(hdev);
2643}
2644
Johan Hedberga5c29682011-02-19 12:05:57 -03002645static inline void hci_user_confirm_request_evt(struct hci_dev *hdev,
2646 struct sk_buff *skb)
2647{
2648 struct hci_ev_user_confirm_req *ev = (void *) skb->data;
Johan Hedberg55bc1a32011-04-28 11:28:56 -07002649 int loc_mitm, rem_mitm, confirm_hint = 0;
Johan Hedberg7a828902011-04-28 11:28:53 -07002650 struct hci_conn *conn;
Johan Hedberga5c29682011-02-19 12:05:57 -03002651
2652 BT_DBG("%s", hdev->name);
2653
2654 hci_dev_lock(hdev);
2655
Johan Hedberg7a828902011-04-28 11:28:53 -07002656 if (!test_bit(HCI_MGMT, &hdev->flags))
2657 goto unlock;
Johan Hedberga5c29682011-02-19 12:05:57 -03002658
Johan Hedberg7a828902011-04-28 11:28:53 -07002659 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2660 if (!conn)
2661 goto unlock;
2662
2663 loc_mitm = (conn->auth_type & 0x01);
2664 rem_mitm = (conn->remote_auth & 0x01);
2665
2666 /* If we require MITM but the remote device can't provide that
2667 * (it has NoInputNoOutput) then reject the confirmation
2668 * request. The only exception is when we're dedicated bonding
2669 * initiators (connect_cfm_cb set) since then we always have the MITM
2670 * bit set. */
2671 if (!conn->connect_cfm_cb && loc_mitm && conn->remote_cap == 0x03) {
2672 BT_DBG("Rejecting request: remote device can't provide MITM");
2673 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_NEG_REPLY,
2674 sizeof(ev->bdaddr), &ev->bdaddr);
2675 goto unlock;
2676 }
2677
2678 /* If no side requires MITM protection; auto-accept */
2679 if ((!loc_mitm || conn->remote_cap == 0x03) &&
2680 (!rem_mitm || conn->io_capability == 0x03)) {
Johan Hedberg55bc1a32011-04-28 11:28:56 -07002681
2682 /* If we're not the initiators request authorization to
2683 * proceed from user space (mgmt_user_confirm with
2684 * confirm_hint set to 1). */
2685 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
2686 BT_DBG("Confirming auto-accept as acceptor");
2687 confirm_hint = 1;
2688 goto confirm;
2689 }
2690
Johan Hedberg9f616562011-04-28 11:28:54 -07002691 BT_DBG("Auto-accept of user confirmation with %ums delay",
2692 hdev->auto_accept_delay);
2693
2694 if (hdev->auto_accept_delay > 0) {
2695 int delay = msecs_to_jiffies(hdev->auto_accept_delay);
2696 mod_timer(&conn->auto_accept_timer, jiffies + delay);
2697 goto unlock;
2698 }
2699
Johan Hedberg7a828902011-04-28 11:28:53 -07002700 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY,
2701 sizeof(ev->bdaddr), &ev->bdaddr);
2702 goto unlock;
2703 }
2704
Johan Hedberg55bc1a32011-04-28 11:28:56 -07002705confirm:
2706 mgmt_user_confirm_request(hdev->id, &ev->bdaddr, ev->passkey,
2707 confirm_hint);
Johan Hedberg7a828902011-04-28 11:28:53 -07002708
2709unlock:
Johan Hedberga5c29682011-02-19 12:05:57 -03002710 hci_dev_unlock(hdev);
2711}
2712
Marcel Holtmann04936842008-07-14 20:13:48 +02002713static inline void hci_simple_pair_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
2714{
2715 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
2716 struct hci_conn *conn;
2717
2718 BT_DBG("%s", hdev->name);
2719
2720 hci_dev_lock(hdev);
2721
2722 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg2a611692011-02-19 12:06:00 -03002723 if (!conn)
2724 goto unlock;
Marcel Holtmann04936842008-07-14 20:13:48 +02002725
Johan Hedberg2a611692011-02-19 12:06:00 -03002726 /* To avoid duplicate auth_failed events to user space we check
2727 * the HCI_CONN_AUTH_PEND flag which will be set if we
2728 * initiated the authentication. A traditional auth_complete
2729 * event gets always produced as initiator and is also mapped to
2730 * the mgmt_auth_failed event */
2731 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->pend) && ev->status != 0)
2732 mgmt_auth_failed(hdev->id, &conn->dst, ev->status);
2733
2734 hci_conn_put(conn);
2735
2736unlock:
Marcel Holtmann04936842008-07-14 20:13:48 +02002737 hci_dev_unlock(hdev);
2738}
2739
Marcel Holtmann41a96212008-07-14 20:13:48 +02002740static inline void hci_remote_host_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
2741{
2742 struct hci_ev_remote_host_features *ev = (void *) skb->data;
2743 struct inquiry_entry *ie;
2744
2745 BT_DBG("%s", hdev->name);
2746
2747 hci_dev_lock(hdev);
2748
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002749 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
2750 if (ie)
Marcel Holtmann41a96212008-07-14 20:13:48 +02002751 ie->data.ssp_mode = (ev->features[0] & 0x01);
2752
2753 hci_dev_unlock(hdev);
2754}
2755
Szymon Janc2763eda2011-03-22 13:12:22 +01002756static inline void hci_remote_oob_data_request_evt(struct hci_dev *hdev,
2757 struct sk_buff *skb)
2758{
2759 struct hci_ev_remote_oob_data_request *ev = (void *) skb->data;
2760 struct oob_data *data;
2761
2762 BT_DBG("%s", hdev->name);
2763
2764 hci_dev_lock(hdev);
2765
Szymon Jance1ba1f12011-04-06 13:01:59 +02002766 if (!test_bit(HCI_MGMT, &hdev->flags))
2767 goto unlock;
2768
Szymon Janc2763eda2011-03-22 13:12:22 +01002769 data = hci_find_remote_oob_data(hdev, &ev->bdaddr);
2770 if (data) {
2771 struct hci_cp_remote_oob_data_reply cp;
2772
2773 bacpy(&cp.bdaddr, &ev->bdaddr);
2774 memcpy(cp.hash, data->hash, sizeof(cp.hash));
2775 memcpy(cp.randomizer, data->randomizer, sizeof(cp.randomizer));
2776
2777 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_REPLY, sizeof(cp),
2778 &cp);
2779 } else {
2780 struct hci_cp_remote_oob_data_neg_reply cp;
2781
2782 bacpy(&cp.bdaddr, &ev->bdaddr);
2783 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_NEG_REPLY, sizeof(cp),
2784 &cp);
2785 }
2786
Szymon Jance1ba1f12011-04-06 13:01:59 +02002787unlock:
Szymon Janc2763eda2011-03-22 13:12:22 +01002788 hci_dev_unlock(hdev);
2789}
2790
Ville Tervofcd89c02011-02-10 22:38:47 -03002791static inline void hci_le_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
2792{
2793 struct hci_ev_le_conn_complete *ev = (void *) skb->data;
2794 struct hci_conn *conn;
2795
2796 BT_DBG("%s status %d", hdev->name, ev->status);
2797
2798 hci_dev_lock(hdev);
2799
2800 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &ev->bdaddr);
Ville Tervob62f3282011-02-10 22:38:50 -03002801 if (!conn) {
2802 conn = hci_conn_add(hdev, LE_LINK, &ev->bdaddr);
2803 if (!conn) {
2804 BT_ERR("No memory for new connection");
2805 hci_dev_unlock(hdev);
2806 return;
2807 }
Andre Guedes29b79882011-05-31 14:20:54 -03002808
2809 conn->dst_type = ev->bdaddr_type;
Ville Tervob62f3282011-02-10 22:38:50 -03002810 }
Ville Tervofcd89c02011-02-10 22:38:47 -03002811
2812 if (ev->status) {
Vinicius Costa Gomes83bc71b2011-05-06 18:41:43 -03002813 mgmt_connect_failed(hdev->id, &ev->bdaddr, ev->status);
Ville Tervofcd89c02011-02-10 22:38:47 -03002814 hci_proto_connect_cfm(conn, ev->status);
2815 conn->state = BT_CLOSED;
2816 hci_conn_del(conn);
2817 goto unlock;
2818 }
2819
Vinicius Costa Gomes83bc71b2011-05-06 18:41:43 -03002820 mgmt_connected(hdev->id, &ev->bdaddr);
2821
Vinicius Costa Gomes7b5c0d52011-06-09 18:50:50 -03002822 conn->sec_level = BT_SECURITY_LOW;
Ville Tervofcd89c02011-02-10 22:38:47 -03002823 conn->handle = __le16_to_cpu(ev->handle);
2824 conn->state = BT_CONNECTED;
2825
2826 hci_conn_hold_device(conn);
2827 hci_conn_add_sysfs(conn);
2828
2829 hci_proto_connect_cfm(conn, ev->status);
2830
2831unlock:
2832 hci_dev_unlock(hdev);
2833}
2834
Andre Guedes9aa04c92011-05-26 16:23:51 -03002835static inline void hci_le_adv_report_evt(struct hci_dev *hdev,
2836 struct sk_buff *skb)
2837{
2838 struct hci_ev_le_advertising_info *ev;
2839 u8 num_reports;
2840
2841 num_reports = skb->data[0];
2842 ev = (void *) &skb->data[1];
2843
2844 hci_dev_lock(hdev);
2845
2846 hci_add_adv_entry(hdev, ev);
2847
2848 while (--num_reports) {
2849 ev = (void *) (ev->data + ev->length + 1);
2850 hci_add_adv_entry(hdev, ev);
2851 }
2852
2853 hci_dev_unlock(hdev);
2854}
2855
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03002856static inline void hci_le_ltk_request_evt(struct hci_dev *hdev,
2857 struct sk_buff *skb)
2858{
2859 struct hci_ev_le_ltk_req *ev = (void *) skb->data;
2860 struct hci_cp_le_ltk_reply cp;
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03002861 struct hci_cp_le_ltk_neg_reply neg;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03002862 struct hci_conn *conn;
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03002863 struct link_key *ltk;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03002864
2865 BT_DBG("%s handle %d", hdev->name, cpu_to_le16(ev->handle));
2866
2867 hci_dev_lock(hdev);
2868
2869 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03002870 if (conn == NULL)
2871 goto not_found;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03002872
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03002873 ltk = hci_find_ltk(hdev, ev->ediv, ev->random);
2874 if (ltk == NULL)
2875 goto not_found;
2876
2877 memcpy(cp.ltk, ltk->val, sizeof(ltk->val));
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03002878 cp.handle = cpu_to_le16(conn->handle);
Vinicius Costa Gomes726b4ff2011-07-08 18:31:45 -03002879 conn->pin_length = ltk->pin_len;
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03002880
2881 hci_send_cmd(hdev, HCI_OP_LE_LTK_REPLY, sizeof(cp), &cp);
2882
2883 hci_dev_unlock(hdev);
Vinicius Costa Gomesbea710f2011-07-07 18:59:37 -03002884
2885 return;
2886
2887not_found:
2888 neg.handle = ev->handle;
2889 hci_send_cmd(hdev, HCI_OP_LE_LTK_NEG_REPLY, sizeof(neg), &neg);
2890 hci_dev_unlock(hdev);
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03002891}
2892
Ville Tervofcd89c02011-02-10 22:38:47 -03002893static inline void hci_le_meta_evt(struct hci_dev *hdev, struct sk_buff *skb)
2894{
2895 struct hci_ev_le_meta *le_ev = (void *) skb->data;
2896
2897 skb_pull(skb, sizeof(*le_ev));
2898
2899 switch (le_ev->subevent) {
2900 case HCI_EV_LE_CONN_COMPLETE:
2901 hci_le_conn_complete_evt(hdev, skb);
2902 break;
2903
Andre Guedes9aa04c92011-05-26 16:23:51 -03002904 case HCI_EV_LE_ADVERTISING_REPORT:
2905 hci_le_adv_report_evt(hdev, skb);
2906 break;
2907
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -03002908 case HCI_EV_LE_LTK_REQ:
2909 hci_le_ltk_request_evt(hdev, skb);
2910 break;
2911
Ville Tervofcd89c02011-02-10 22:38:47 -03002912 default:
2913 break;
2914 }
2915}
2916
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
2918{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002919 struct hci_event_hdr *hdr = (void *) skb->data;
2920 __u8 event = hdr->evt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921
2922 skb_pull(skb, HCI_EVENT_HDR_SIZE);
2923
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002924 switch (event) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925 case HCI_EV_INQUIRY_COMPLETE:
2926 hci_inquiry_complete_evt(hdev, skb);
2927 break;
2928
2929 case HCI_EV_INQUIRY_RESULT:
2930 hci_inquiry_result_evt(hdev, skb);
2931 break;
2932
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002933 case HCI_EV_CONN_COMPLETE:
2934 hci_conn_complete_evt(hdev, skb);
Marcel Holtmann21d9e302005-09-13 01:32:25 +02002935 break;
2936
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 case HCI_EV_CONN_REQUEST:
2938 hci_conn_request_evt(hdev, skb);
2939 break;
2940
Linus Torvalds1da177e2005-04-16 15:20:36 -07002941 case HCI_EV_DISCONN_COMPLETE:
2942 hci_disconn_complete_evt(hdev, skb);
2943 break;
2944
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945 case HCI_EV_AUTH_COMPLETE:
2946 hci_auth_complete_evt(hdev, skb);
2947 break;
2948
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002949 case HCI_EV_REMOTE_NAME:
2950 hci_remote_name_evt(hdev, skb);
2951 break;
2952
Linus Torvalds1da177e2005-04-16 15:20:36 -07002953 case HCI_EV_ENCRYPT_CHANGE:
2954 hci_encrypt_change_evt(hdev, skb);
2955 break;
2956
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002957 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
2958 hci_change_link_key_complete_evt(hdev, skb);
2959 break;
2960
2961 case HCI_EV_REMOTE_FEATURES:
2962 hci_remote_features_evt(hdev, skb);
2963 break;
2964
2965 case HCI_EV_REMOTE_VERSION:
2966 hci_remote_version_evt(hdev, skb);
2967 break;
2968
2969 case HCI_EV_QOS_SETUP_COMPLETE:
2970 hci_qos_setup_complete_evt(hdev, skb);
2971 break;
2972
2973 case HCI_EV_CMD_COMPLETE:
2974 hci_cmd_complete_evt(hdev, skb);
2975 break;
2976
2977 case HCI_EV_CMD_STATUS:
2978 hci_cmd_status_evt(hdev, skb);
2979 break;
2980
2981 case HCI_EV_ROLE_CHANGE:
2982 hci_role_change_evt(hdev, skb);
2983 break;
2984
2985 case HCI_EV_NUM_COMP_PKTS:
2986 hci_num_comp_pkts_evt(hdev, skb);
2987 break;
2988
2989 case HCI_EV_MODE_CHANGE:
2990 hci_mode_change_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991 break;
2992
2993 case HCI_EV_PIN_CODE_REQ:
2994 hci_pin_code_request_evt(hdev, skb);
2995 break;
2996
2997 case HCI_EV_LINK_KEY_REQ:
2998 hci_link_key_request_evt(hdev, skb);
2999 break;
3000
3001 case HCI_EV_LINK_KEY_NOTIFY:
3002 hci_link_key_notify_evt(hdev, skb);
3003 break;
3004
3005 case HCI_EV_CLOCK_OFFSET:
3006 hci_clock_offset_evt(hdev, skb);
3007 break;
3008
Marcel Holtmanna8746412008-07-14 20:13:46 +02003009 case HCI_EV_PKT_TYPE_CHANGE:
3010 hci_pkt_type_change_evt(hdev, skb);
3011 break;
3012
Marcel Holtmann85a1e932005-08-09 20:28:02 -07003013 case HCI_EV_PSCAN_REP_MODE:
3014 hci_pscan_rep_mode_evt(hdev, skb);
3015 break;
3016
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003017 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
3018 hci_inquiry_result_with_rssi_evt(hdev, skb);
3019 break;
3020
3021 case HCI_EV_REMOTE_EXT_FEATURES:
3022 hci_remote_ext_features_evt(hdev, skb);
3023 break;
3024
3025 case HCI_EV_SYNC_CONN_COMPLETE:
3026 hci_sync_conn_complete_evt(hdev, skb);
3027 break;
3028
3029 case HCI_EV_SYNC_CONN_CHANGED:
3030 hci_sync_conn_changed_evt(hdev, skb);
3031 break;
3032
Marcel Holtmann04837f62006-07-03 10:02:33 +02003033 case HCI_EV_SNIFF_SUBRATE:
3034 hci_sniff_subrate_evt(hdev, skb);
3035 break;
3036
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003037 case HCI_EV_EXTENDED_INQUIRY_RESULT:
3038 hci_extended_inquiry_result_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039 break;
3040
Marcel Holtmann04936842008-07-14 20:13:48 +02003041 case HCI_EV_IO_CAPA_REQUEST:
3042 hci_io_capa_request_evt(hdev, skb);
3043 break;
3044
Johan Hedberg03b555e2011-01-04 15:40:05 +02003045 case HCI_EV_IO_CAPA_REPLY:
3046 hci_io_capa_reply_evt(hdev, skb);
3047 break;
3048
Johan Hedberga5c29682011-02-19 12:05:57 -03003049 case HCI_EV_USER_CONFIRM_REQUEST:
3050 hci_user_confirm_request_evt(hdev, skb);
3051 break;
3052
Marcel Holtmann04936842008-07-14 20:13:48 +02003053 case HCI_EV_SIMPLE_PAIR_COMPLETE:
3054 hci_simple_pair_complete_evt(hdev, skb);
3055 break;
3056
Marcel Holtmann41a96212008-07-14 20:13:48 +02003057 case HCI_EV_REMOTE_HOST_FEATURES:
3058 hci_remote_host_features_evt(hdev, skb);
3059 break;
3060
Ville Tervofcd89c02011-02-10 22:38:47 -03003061 case HCI_EV_LE_META:
3062 hci_le_meta_evt(hdev, skb);
3063 break;
3064
Szymon Janc2763eda2011-03-22 13:12:22 +01003065 case HCI_EV_REMOTE_OOB_DATA_REQUEST:
3066 hci_remote_oob_data_request_evt(hdev, skb);
3067 break;
3068
Marcel Holtmanna9de9242007-10-20 13:33:56 +02003069 default:
3070 BT_DBG("%s event 0x%x", hdev->name, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003071 break;
3072 }
3073
3074 kfree_skb(skb);
3075 hdev->stat.evt_rx++;
3076}
3077
3078/* Generate internal stack event */
3079void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
3080{
3081 struct hci_event_hdr *hdr;
3082 struct hci_ev_stack_internal *ev;
3083 struct sk_buff *skb;
3084
3085 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
3086 if (!skb)
3087 return;
3088
3089 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
3090 hdr->evt = HCI_EV_STACK_INTERNAL;
3091 hdr->plen = sizeof(*ev) + dlen;
3092
3093 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
3094 ev->type = type;
3095 memcpy(ev->data, data, dlen);
3096
Marcel Holtmann576c7d82005-08-06 12:36:54 +02003097 bt_cb(skb)->incoming = 1;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07003098 __net_timestamp(skb);
Marcel Holtmann576c7d82005-08-06 12:36:54 +02003099
Marcel Holtmann0d48d932005-08-09 20:30:28 -07003100 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003101 skb->dev = (void *) hdev;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02003102 hci_send_to_sock(hdev, skb, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003103 kfree_skb(skb);
3104}
Andre Guedese6100a22011-06-30 19:20:54 -03003105
3106module_param(enable_le, bool, 0444);
3107MODULE_PARM_DESC(enable_le, "Enable LE support");