blob: 33120b48cbc5cf46facdc905eb7d666c72b7f3db [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070048/* Handle HCI Event packets */
49
Marcel Holtmanna9de9242007-10-20 13:33:56 +020050static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020052 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Marcel Holtmanna9de9242007-10-20 13:33:56 +020054 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Marcel Holtmanna9de9242007-10-20 13:33:56 +020056 if (status)
57 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Johan Hedberg314b2382011-04-27 10:29:57 -040059 if (test_bit(HCI_MGMT, &hdev->flags) &&
60 test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
61 mgmt_discovering(hdev->id, 0);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010062
Johan Hedberg23bb5762010-12-21 23:01:27 +020063 hci_req_complete(hdev, HCI_OP_INQUIRY_CANCEL, status);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010064
Marcel Holtmanna9de9242007-10-20 13:33:56 +020065 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066}
67
Marcel Holtmanna9de9242007-10-20 13:33:56 +020068static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070069{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020070 __u8 status = *((__u8 *) skb->data);
71
72 BT_DBG("%s status 0x%x", hdev->name, status);
73
74 if (status)
75 return;
76
Johan Hedberg314b2382011-04-27 10:29:57 -040077 if (test_bit(HCI_MGMT, &hdev->flags) &&
78 test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
79 mgmt_discovering(hdev->id, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +020080
81 hci_conn_check_pending(hdev);
82}
83
84static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev, struct sk_buff *skb)
85{
86 BT_DBG("%s", hdev->name);
87}
88
89static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb)
90{
91 struct hci_rp_role_discovery *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
Marcel Holtmanna9de9242007-10-20 13:33:56 +020094 BT_DBG("%s status 0x%x", hdev->name, rp->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
Marcel Holtmanna9de9242007-10-20 13:33:56 +020096 if (rp->status)
97 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Marcel Holtmanna9de9242007-10-20 13:33:56 +020099 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200101 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
102 if (conn) {
103 if (rp->role)
104 conn->link_mode &= ~HCI_LM_MASTER;
105 else
106 conn->link_mode |= HCI_LM_MASTER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200108
109 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110}
111
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200112static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
113{
114 struct hci_rp_read_link_policy *rp = (void *) skb->data;
115 struct hci_conn *conn;
116
117 BT_DBG("%s status 0x%x", hdev->name, rp->status);
118
119 if (rp->status)
120 return;
121
122 hci_dev_lock(hdev);
123
124 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
125 if (conn)
126 conn->link_policy = __le16_to_cpu(rp->policy);
127
128 hci_dev_unlock(hdev);
129}
130
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200131static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200133 struct hci_rp_write_link_policy *rp = (void *) skb->data;
134 struct hci_conn *conn;
135 void *sent;
136
137 BT_DBG("%s status 0x%x", hdev->name, rp->status);
138
139 if (rp->status)
140 return;
141
142 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
143 if (!sent)
144 return;
145
146 hci_dev_lock(hdev);
147
148 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200149 if (conn)
Harvey Harrison83985312008-05-02 16:25:46 -0700150 conn->link_policy = get_unaligned_le16(sent + 2);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200151
152 hci_dev_unlock(hdev);
153}
154
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200155static void hci_cc_read_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
156{
157 struct hci_rp_read_def_link_policy *rp = (void *) skb->data;
158
159 BT_DBG("%s status 0x%x", hdev->name, rp->status);
160
161 if (rp->status)
162 return;
163
164 hdev->link_policy = __le16_to_cpu(rp->policy);
165}
166
167static void hci_cc_write_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
168{
169 __u8 status = *((__u8 *) skb->data);
170 void *sent;
171
172 BT_DBG("%s status 0x%x", hdev->name, status);
173
174 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
175 if (!sent)
176 return;
177
178 if (!status)
179 hdev->link_policy = get_unaligned_le16(sent);
180
Johan Hedberg23bb5762010-12-21 23:01:27 +0200181 hci_req_complete(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, status);
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200182}
183
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200184static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
185{
186 __u8 status = *((__u8 *) skb->data);
187
188 BT_DBG("%s status 0x%x", hdev->name, status);
189
Gustavo F. Padovan10572132011-03-16 15:36:29 -0300190 clear_bit(HCI_RESET, &hdev->flags);
191
Johan Hedberg23bb5762010-12-21 23:01:27 +0200192 hci_req_complete(hdev, HCI_OP_RESET, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200193}
194
195static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
196{
197 __u8 status = *((__u8 *) skb->data);
198 void *sent;
199
200 BT_DBG("%s status 0x%x", hdev->name, status);
201
202 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
203 if (!sent)
204 return;
205
Johan Hedbergb312b1612011-03-16 14:29:37 +0200206 if (test_bit(HCI_MGMT, &hdev->flags))
207 mgmt_set_local_name_complete(hdev->id, sent, status);
208
209 if (status)
210 return;
211
Johan Hedberg1f6c6372011-03-16 14:29:35 +0200212 memcpy(hdev->dev_name, sent, HCI_MAX_NAME_LENGTH);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200213}
214
215static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
216{
217 struct hci_rp_read_local_name *rp = (void *) skb->data;
218
219 BT_DBG("%s status 0x%x", hdev->name, rp->status);
220
221 if (rp->status)
222 return;
223
Johan Hedberg1f6c6372011-03-16 14:29:35 +0200224 memcpy(hdev->dev_name, rp->name, HCI_MAX_NAME_LENGTH);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200225}
226
227static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
228{
229 __u8 status = *((__u8 *) skb->data);
230 void *sent;
231
232 BT_DBG("%s status 0x%x", hdev->name, status);
233
234 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
235 if (!sent)
236 return;
237
238 if (!status) {
239 __u8 param = *((__u8 *) sent);
240
241 if (param == AUTH_ENABLED)
242 set_bit(HCI_AUTH, &hdev->flags);
243 else
244 clear_bit(HCI_AUTH, &hdev->flags);
245 }
246
Johan Hedberg23bb5762010-12-21 23:01:27 +0200247 hci_req_complete(hdev, HCI_OP_WRITE_AUTH_ENABLE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200248}
249
250static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
251{
252 __u8 status = *((__u8 *) skb->data);
253 void *sent;
254
255 BT_DBG("%s status 0x%x", hdev->name, status);
256
257 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
258 if (!sent)
259 return;
260
261 if (!status) {
262 __u8 param = *((__u8 *) sent);
263
264 if (param)
265 set_bit(HCI_ENCRYPT, &hdev->flags);
266 else
267 clear_bit(HCI_ENCRYPT, &hdev->flags);
268 }
269
Johan Hedberg23bb5762010-12-21 23:01:27 +0200270 hci_req_complete(hdev, HCI_OP_WRITE_ENCRYPT_MODE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200271}
272
273static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
274{
275 __u8 status = *((__u8 *) skb->data);
276 void *sent;
277
278 BT_DBG("%s status 0x%x", hdev->name, status);
279
280 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
281 if (!sent)
282 return;
283
284 if (!status) {
285 __u8 param = *((__u8 *) sent);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200286 int old_pscan, old_iscan;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200287
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200288 old_pscan = test_and_clear_bit(HCI_PSCAN, &hdev->flags);
289 old_iscan = test_and_clear_bit(HCI_ISCAN, &hdev->flags);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200290
Johan Hedberg73f22f62010-12-29 16:00:25 +0200291 if (param & SCAN_INQUIRY) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200292 set_bit(HCI_ISCAN, &hdev->flags);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200293 if (!old_iscan)
294 mgmt_discoverable(hdev->id, 1);
295 } else if (old_iscan)
Johan Hedberg73f22f62010-12-29 16:00:25 +0200296 mgmt_discoverable(hdev->id, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200297
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200298 if (param & SCAN_PAGE) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200299 set_bit(HCI_PSCAN, &hdev->flags);
Johan Hedberg9fbcbb42010-12-30 00:18:33 +0200300 if (!old_pscan)
301 mgmt_connectable(hdev->id, 1);
302 } else if (old_pscan)
303 mgmt_connectable(hdev->id, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200304 }
305
Johan Hedberg23bb5762010-12-21 23:01:27 +0200306 hci_req_complete(hdev, HCI_OP_WRITE_SCAN_ENABLE, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200307}
308
309static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
310{
311 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
312
313 BT_DBG("%s status 0x%x", hdev->name, rp->status);
314
315 if (rp->status)
316 return;
317
318 memcpy(hdev->dev_class, rp->dev_class, 3);
319
320 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
321 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
322}
323
324static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
325{
326 __u8 status = *((__u8 *) skb->data);
327 void *sent;
328
329 BT_DBG("%s status 0x%x", hdev->name, status);
330
Marcel Holtmannf383f272008-07-14 20:13:47 +0200331 if (status)
332 return;
333
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200334 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
335 if (!sent)
336 return;
337
Marcel Holtmannf383f272008-07-14 20:13:47 +0200338 memcpy(hdev->dev_class, sent, 3);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200339}
340
341static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
342{
343 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 __u16 setting;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200345
346 BT_DBG("%s status 0x%x", hdev->name, rp->status);
347
348 if (rp->status)
349 return;
350
351 setting = __le16_to_cpu(rp->voice_setting);
352
Marcel Holtmannf383f272008-07-14 20:13:47 +0200353 if (hdev->voice_setting == setting)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200354 return;
355
356 hdev->voice_setting = setting;
357
358 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
359
360 if (hdev->notify) {
361 tasklet_disable(&hdev->tx_task);
362 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
363 tasklet_enable(&hdev->tx_task);
364 }
365}
366
367static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
368{
369 __u8 status = *((__u8 *) skb->data);
Marcel Holtmannf383f272008-07-14 20:13:47 +0200370 __u16 setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 void *sent;
372
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200373 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
Marcel Holtmannf383f272008-07-14 20:13:47 +0200375 if (status)
376 return;
377
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200378 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
379 if (!sent)
380 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Marcel Holtmannf383f272008-07-14 20:13:47 +0200382 setting = get_unaligned_le16(sent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Marcel Holtmannf383f272008-07-14 20:13:47 +0200384 if (hdev->voice_setting == setting)
385 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
Marcel Holtmannf383f272008-07-14 20:13:47 +0200387 hdev->voice_setting = setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Marcel Holtmannf383f272008-07-14 20:13:47 +0200389 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
390
391 if (hdev->notify) {
392 tasklet_disable(&hdev->tx_task);
393 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
394 tasklet_enable(&hdev->tx_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 }
396}
397
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200398static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200400 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200402 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Johan Hedberg23bb5762010-12-21 23:01:27 +0200404 hci_req_complete(hdev, HCI_OP_HOST_BUFFER_SIZE, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405}
406
Marcel Holtmann333140b2008-07-14 20:13:48 +0200407static void hci_cc_read_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
408{
409 struct hci_rp_read_ssp_mode *rp = (void *) skb->data;
410
411 BT_DBG("%s status 0x%x", hdev->name, rp->status);
412
413 if (rp->status)
414 return;
415
416 hdev->ssp_mode = rp->mode;
417}
418
419static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
420{
421 __u8 status = *((__u8 *) skb->data);
422 void *sent;
423
424 BT_DBG("%s status 0x%x", hdev->name, status);
425
426 if (status)
427 return;
428
429 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
430 if (!sent)
431 return;
432
433 hdev->ssp_mode = *((__u8 *) sent);
434}
435
Johan Hedbergd5859e22011-01-25 01:19:58 +0200436static u8 hci_get_inquiry_mode(struct hci_dev *hdev)
437{
438 if (hdev->features[6] & LMP_EXT_INQ)
439 return 2;
440
441 if (hdev->features[3] & LMP_RSSI_INQ)
442 return 1;
443
444 if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 &&
445 hdev->lmp_subver == 0x0757)
446 return 1;
447
448 if (hdev->manufacturer == 15) {
449 if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963)
450 return 1;
451 if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963)
452 return 1;
453 if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965)
454 return 1;
455 }
456
457 if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 &&
458 hdev->lmp_subver == 0x1805)
459 return 1;
460
461 return 0;
462}
463
464static void hci_setup_inquiry_mode(struct hci_dev *hdev)
465{
466 u8 mode;
467
468 mode = hci_get_inquiry_mode(hdev);
469
470 hci_send_cmd(hdev, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode);
471}
472
473static void hci_setup_event_mask(struct hci_dev *hdev)
474{
475 /* The second byte is 0xff instead of 0x9f (two reserved bits
476 * disabled) since a Broadcom 1.2 dongle doesn't respond to the
477 * command otherwise */
478 u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 };
479
480 /* Events for 1.2 and newer controllers */
481 if (hdev->lmp_ver > 1) {
482 events[4] |= 0x01; /* Flow Specification Complete */
483 events[4] |= 0x02; /* Inquiry Result with RSSI */
484 events[4] |= 0x04; /* Read Remote Extended Features Complete */
485 events[5] |= 0x08; /* Synchronous Connection Complete */
486 events[5] |= 0x10; /* Synchronous Connection Changed */
487 }
488
489 if (hdev->features[3] & LMP_RSSI_INQ)
490 events[4] |= 0x04; /* Inquiry Result with RSSI */
491
492 if (hdev->features[5] & LMP_SNIFF_SUBR)
493 events[5] |= 0x20; /* Sniff Subrating */
494
495 if (hdev->features[5] & LMP_PAUSE_ENC)
496 events[5] |= 0x80; /* Encryption Key Refresh Complete */
497
498 if (hdev->features[6] & LMP_EXT_INQ)
499 events[5] |= 0x40; /* Extended Inquiry Result */
500
501 if (hdev->features[6] & LMP_NO_FLUSH)
502 events[7] |= 0x01; /* Enhanced Flush Complete */
503
504 if (hdev->features[7] & LMP_LSTO)
505 events[6] |= 0x80; /* Link Supervision Timeout Changed */
506
507 if (hdev->features[6] & LMP_SIMPLE_PAIR) {
508 events[6] |= 0x01; /* IO Capability Request */
509 events[6] |= 0x02; /* IO Capability Response */
510 events[6] |= 0x04; /* User Confirmation Request */
511 events[6] |= 0x08; /* User Passkey Request */
512 events[6] |= 0x10; /* Remote OOB Data Request */
513 events[6] |= 0x20; /* Simple Pairing Complete */
514 events[7] |= 0x04; /* User Passkey Notification */
515 events[7] |= 0x08; /* Keypress Notification */
516 events[7] |= 0x10; /* Remote Host Supported
517 * Features Notification */
518 }
519
520 if (hdev->features[4] & LMP_LE)
521 events[7] |= 0x20; /* LE Meta-Event */
522
523 hci_send_cmd(hdev, HCI_OP_SET_EVENT_MASK, sizeof(events), events);
524}
525
526static void hci_setup(struct hci_dev *hdev)
527{
528 hci_setup_event_mask(hdev);
529
530 if (hdev->lmp_ver > 1)
531 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL);
532
533 if (hdev->features[6] & LMP_SIMPLE_PAIR) {
534 u8 mode = 0x01;
535 hci_send_cmd(hdev, HCI_OP_WRITE_SSP_MODE, sizeof(mode), &mode);
536 }
537
538 if (hdev->features[3] & LMP_RSSI_INQ)
539 hci_setup_inquiry_mode(hdev);
540
541 if (hdev->features[7] & LMP_INQ_TX_PWR)
542 hci_send_cmd(hdev, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL);
543}
544
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200545static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
546{
547 struct hci_rp_read_local_version *rp = (void *) skb->data;
548
549 BT_DBG("%s status 0x%x", hdev->name, rp->status);
550
551 if (rp->status)
552 return;
553
554 hdev->hci_ver = rp->hci_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200555 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200556 hdev->lmp_ver = rp->lmp_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200557 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200558 hdev->lmp_subver = __le16_to_cpu(rp->lmp_subver);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200559
560 BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
561 hdev->manufacturer,
562 hdev->hci_ver, hdev->hci_rev);
Johan Hedbergd5859e22011-01-25 01:19:58 +0200563
564 if (test_bit(HCI_INIT, &hdev->flags))
565 hci_setup(hdev);
566}
567
568static void hci_setup_link_policy(struct hci_dev *hdev)
569{
570 u16 link_policy = 0;
571
572 if (hdev->features[0] & LMP_RSWITCH)
573 link_policy |= HCI_LP_RSWITCH;
574 if (hdev->features[0] & LMP_HOLD)
575 link_policy |= HCI_LP_HOLD;
576 if (hdev->features[0] & LMP_SNIFF)
577 link_policy |= HCI_LP_SNIFF;
578 if (hdev->features[1] & LMP_PARK)
579 link_policy |= HCI_LP_PARK;
580
581 link_policy = cpu_to_le16(link_policy);
582 hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY,
583 sizeof(link_policy), &link_policy);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200584}
585
586static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb)
587{
588 struct hci_rp_read_local_commands *rp = (void *) skb->data;
589
590 BT_DBG("%s status 0x%x", hdev->name, rp->status);
591
592 if (rp->status)
Johan Hedbergd5859e22011-01-25 01:19:58 +0200593 goto done;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200594
595 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
Johan Hedbergd5859e22011-01-25 01:19:58 +0200596
597 if (test_bit(HCI_INIT, &hdev->flags) && (hdev->commands[5] & 0x10))
598 hci_setup_link_policy(hdev);
599
600done:
601 hci_req_complete(hdev, HCI_OP_READ_LOCAL_COMMANDS, rp->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200602}
603
604static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb)
605{
606 struct hci_rp_read_local_features *rp = (void *) skb->data;
607
608 BT_DBG("%s status 0x%x", hdev->name, rp->status);
609
610 if (rp->status)
611 return;
612
613 memcpy(hdev->features, rp->features, 8);
614
615 /* Adjust default settings according to features
616 * supported by device. */
617
618 if (hdev->features[0] & LMP_3SLOT)
619 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
620
621 if (hdev->features[0] & LMP_5SLOT)
622 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
623
624 if (hdev->features[1] & LMP_HV2) {
625 hdev->pkt_type |= (HCI_HV2);
626 hdev->esco_type |= (ESCO_HV2);
627 }
628
629 if (hdev->features[1] & LMP_HV3) {
630 hdev->pkt_type |= (HCI_HV3);
631 hdev->esco_type |= (ESCO_HV3);
632 }
633
634 if (hdev->features[3] & LMP_ESCO)
635 hdev->esco_type |= (ESCO_EV3);
636
637 if (hdev->features[4] & LMP_EV4)
638 hdev->esco_type |= (ESCO_EV4);
639
640 if (hdev->features[4] & LMP_EV5)
641 hdev->esco_type |= (ESCO_EV5);
642
Marcel Holtmannefc76882009-02-06 09:13:37 +0100643 if (hdev->features[5] & LMP_EDR_ESCO_2M)
644 hdev->esco_type |= (ESCO_2EV3);
645
646 if (hdev->features[5] & LMP_EDR_ESCO_3M)
647 hdev->esco_type |= (ESCO_3EV3);
648
649 if (hdev->features[5] & LMP_EDR_3S_ESCO)
650 hdev->esco_type |= (ESCO_2EV5 | ESCO_3EV5);
651
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200652 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
653 hdev->features[0], hdev->features[1],
654 hdev->features[2], hdev->features[3],
655 hdev->features[4], hdev->features[5],
656 hdev->features[6], hdev->features[7]);
657}
658
659static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
660{
661 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
662
663 BT_DBG("%s status 0x%x", hdev->name, rp->status);
664
665 if (rp->status)
666 return;
667
668 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
669 hdev->sco_mtu = rp->sco_mtu;
670 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
671 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
672
673 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
674 hdev->sco_mtu = 64;
675 hdev->sco_pkts = 8;
676 }
677
678 hdev->acl_cnt = hdev->acl_pkts;
679 hdev->sco_cnt = hdev->sco_pkts;
680
681 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
682 hdev->acl_mtu, hdev->acl_pkts,
683 hdev->sco_mtu, hdev->sco_pkts);
684}
685
686static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
687{
688 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
689
690 BT_DBG("%s status 0x%x", hdev->name, rp->status);
691
692 if (!rp->status)
693 bacpy(&hdev->bdaddr, &rp->bdaddr);
694
Johan Hedberg23bb5762010-12-21 23:01:27 +0200695 hci_req_complete(hdev, HCI_OP_READ_BD_ADDR, rp->status);
696}
697
698static void hci_cc_write_ca_timeout(struct hci_dev *hdev, struct sk_buff *skb)
699{
700 __u8 status = *((__u8 *) skb->data);
701
702 BT_DBG("%s status 0x%x", hdev->name, status);
703
704 hci_req_complete(hdev, HCI_OP_WRITE_CA_TIMEOUT, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200705}
706
Johan Hedbergb0916ea2011-01-10 13:44:55 +0200707static void hci_cc_delete_stored_link_key(struct hci_dev *hdev,
708 struct sk_buff *skb)
709{
710 __u8 status = *((__u8 *) skb->data);
711
712 BT_DBG("%s status 0x%x", hdev->name, status);
713
714 hci_req_complete(hdev, HCI_OP_DELETE_STORED_LINK_KEY, status);
715}
716
Johan Hedbergd5859e22011-01-25 01:19:58 +0200717static void hci_cc_set_event_mask(struct hci_dev *hdev, struct sk_buff *skb)
718{
719 __u8 status = *((__u8 *) skb->data);
720
721 BT_DBG("%s status 0x%x", hdev->name, status);
722
723 hci_req_complete(hdev, HCI_OP_SET_EVENT_MASK, status);
724}
725
726static void hci_cc_write_inquiry_mode(struct hci_dev *hdev,
727 struct sk_buff *skb)
728{
729 __u8 status = *((__u8 *) skb->data);
730
731 BT_DBG("%s status 0x%x", hdev->name, status);
732
733 hci_req_complete(hdev, HCI_OP_WRITE_INQUIRY_MODE, status);
734}
735
736static void hci_cc_read_inq_rsp_tx_power(struct hci_dev *hdev,
737 struct sk_buff *skb)
738{
739 __u8 status = *((__u8 *) skb->data);
740
741 BT_DBG("%s status 0x%x", hdev->name, status);
742
743 hci_req_complete(hdev, HCI_OP_READ_INQ_RSP_TX_POWER, status);
744}
745
746static void hci_cc_set_event_flt(struct hci_dev *hdev, struct sk_buff *skb)
747{
748 __u8 status = *((__u8 *) skb->data);
749
750 BT_DBG("%s status 0x%x", hdev->name, status);
751
752 hci_req_complete(hdev, HCI_OP_SET_EVENT_FLT, status);
753}
754
Johan Hedberg980e1a52011-01-22 06:10:07 +0200755static void hci_cc_pin_code_reply(struct hci_dev *hdev, struct sk_buff *skb)
756{
757 struct hci_rp_pin_code_reply *rp = (void *) skb->data;
758 struct hci_cp_pin_code_reply *cp;
759 struct hci_conn *conn;
760
761 BT_DBG("%s status 0x%x", hdev->name, rp->status);
762
763 if (test_bit(HCI_MGMT, &hdev->flags))
764 mgmt_pin_code_reply_complete(hdev->id, &rp->bdaddr, rp->status);
765
766 if (rp->status != 0)
767 return;
768
769 cp = hci_sent_cmd_data(hdev, HCI_OP_PIN_CODE_REPLY);
770 if (!cp)
771 return;
772
773 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
774 if (conn)
775 conn->pin_length = cp->pin_len;
776}
777
778static void hci_cc_pin_code_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
779{
780 struct hci_rp_pin_code_neg_reply *rp = (void *) skb->data;
781
782 BT_DBG("%s status 0x%x", hdev->name, rp->status);
783
784 if (test_bit(HCI_MGMT, &hdev->flags))
785 mgmt_pin_code_neg_reply_complete(hdev->id, &rp->bdaddr,
786 rp->status);
787}
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300788static void hci_cc_le_read_buffer_size(struct hci_dev *hdev,
789 struct sk_buff *skb)
790{
791 struct hci_rp_le_read_buffer_size *rp = (void *) skb->data;
792
793 BT_DBG("%s status 0x%x", hdev->name, rp->status);
794
795 if (rp->status)
796 return;
797
798 hdev->le_mtu = __le16_to_cpu(rp->le_mtu);
799 hdev->le_pkts = rp->le_max_pkt;
800
801 hdev->le_cnt = hdev->le_pkts;
802
803 BT_DBG("%s le mtu %d:%d", hdev->name, hdev->le_mtu, hdev->le_pkts);
804
805 hci_req_complete(hdev, HCI_OP_LE_READ_BUFFER_SIZE, rp->status);
806}
Johan Hedberg980e1a52011-01-22 06:10:07 +0200807
Johan Hedberga5c29682011-02-19 12:05:57 -0300808static void hci_cc_user_confirm_reply(struct hci_dev *hdev, struct sk_buff *skb)
809{
810 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
811
812 BT_DBG("%s status 0x%x", hdev->name, rp->status);
813
814 if (test_bit(HCI_MGMT, &hdev->flags))
815 mgmt_user_confirm_reply_complete(hdev->id, &rp->bdaddr,
816 rp->status);
817}
818
819static void hci_cc_user_confirm_neg_reply(struct hci_dev *hdev,
820 struct sk_buff *skb)
821{
822 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
823
824 BT_DBG("%s status 0x%x", hdev->name, rp->status);
825
826 if (test_bit(HCI_MGMT, &hdev->flags))
827 mgmt_user_confirm_neg_reply_complete(hdev->id, &rp->bdaddr,
828 rp->status);
829}
830
Szymon Jancc35938b2011-03-22 13:12:21 +0100831static void hci_cc_read_local_oob_data_reply(struct hci_dev *hdev,
832 struct sk_buff *skb)
833{
834 struct hci_rp_read_local_oob_data *rp = (void *) skb->data;
835
836 BT_DBG("%s status 0x%x", hdev->name, rp->status);
837
838 mgmt_read_local_oob_data_reply_complete(hdev->id, rp->hash,
839 rp->randomizer, rp->status);
840}
841
Andre Guedeseb9d91f2011-05-26 16:23:52 -0300842static void hci_cc_le_set_scan_enable(struct hci_dev *hdev,
843 struct sk_buff *skb)
844{
845 struct hci_cp_le_set_scan_enable *cp;
846 __u8 status = *((__u8 *) skb->data);
847
848 BT_DBG("%s status 0x%x", hdev->name, status);
849
850 if (status)
851 return;
852
853 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_SCAN_ENABLE);
854 if (!cp)
855 return;
856
857 hci_dev_lock(hdev);
858
Andre Guedes35815082011-05-26 16:23:53 -0300859 if (cp->enable == 0x01) {
860 del_timer(&hdev->adv_timer);
Andre Guedeseb9d91f2011-05-26 16:23:52 -0300861 hci_adv_entries_clear(hdev);
Andre Guedes35815082011-05-26 16:23:53 -0300862 } else if (cp->enable == 0x00) {
863 mod_timer(&hdev->adv_timer, jiffies + ADV_CLEAR_TIMEOUT);
864 }
Andre Guedeseb9d91f2011-05-26 16:23:52 -0300865
866 hci_dev_unlock(hdev);
867}
868
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200869static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
870{
871 BT_DBG("%s status 0x%x", hdev->name, status);
872
873 if (status) {
Johan Hedberg23bb5762010-12-21 23:01:27 +0200874 hci_req_complete(hdev, HCI_OP_INQUIRY, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200875 hci_conn_check_pending(hdev);
Johan Hedberg314b2382011-04-27 10:29:57 -0400876 return;
877 }
878
879 if (test_bit(HCI_MGMT, &hdev->flags) &&
880 !test_and_set_bit(HCI_INQUIRY,
881 &hdev->flags))
882 mgmt_discovering(hdev->id, 1);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200883}
884
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
886{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200887 struct hci_cp_create_conn *cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200890 BT_DBG("%s status 0x%x", hdev->name, status);
891
892 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 if (!cp)
894 return;
895
896 hci_dev_lock(hdev);
897
898 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
899
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200900 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
902 if (status) {
903 if (conn && conn->state == BT_CONNECT) {
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200904 if (status != 0x0c || conn->attempt > 2) {
905 conn->state = BT_CLOSED;
906 hci_proto_connect_cfm(conn, status);
907 hci_conn_del(conn);
908 } else
909 conn->state = BT_CONNECT2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 }
911 } else {
912 if (!conn) {
913 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
914 if (conn) {
915 conn->out = 1;
916 conn->link_mode |= HCI_LM_MASTER;
917 } else
Gustavo F. Padovan893ef972010-07-18 15:13:37 -0300918 BT_ERR("No memory for new connection");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 }
920 }
921
922 hci_dev_unlock(hdev);
923}
924
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200925static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200927 struct hci_cp_add_sco *cp;
928 struct hci_conn *acl, *sco;
929 __u16 handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200931 BT_DBG("%s status 0x%x", hdev->name, status);
932
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200933 if (!status)
934 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200936 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
937 if (!cp)
938 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200940 handle = __le16_to_cpu(cp->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200942 BT_DBG("%s handle %d", hdev->name, handle);
Marcel Holtmann6bd57412006-11-18 22:14:22 +0100943
944 hci_dev_lock(hdev);
945
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200946 acl = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200947 if (acl) {
948 sco = acl->link;
949 if (sco) {
950 sco->state = BT_CLOSED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200951
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +0200952 hci_proto_connect_cfm(sco, status);
953 hci_conn_del(sco);
954 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200955 }
Marcel Holtmann6bd57412006-11-18 22:14:22 +0100956
957 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958}
959
Marcel Holtmannf8558552008-07-14 20:13:49 +0200960static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
961{
962 struct hci_cp_auth_requested *cp;
963 struct hci_conn *conn;
964
965 BT_DBG("%s status 0x%x", hdev->name, status);
966
967 if (!status)
968 return;
969
970 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
971 if (!cp)
972 return;
973
974 hci_dev_lock(hdev);
975
976 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
977 if (conn) {
978 if (conn->state == BT_CONFIG) {
979 hci_proto_connect_cfm(conn, status);
980 hci_conn_put(conn);
981 }
982 }
983
984 hci_dev_unlock(hdev);
985}
986
987static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
988{
989 struct hci_cp_set_conn_encrypt *cp;
990 struct hci_conn *conn;
991
992 BT_DBG("%s status 0x%x", hdev->name, status);
993
994 if (!status)
995 return;
996
997 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
998 if (!cp)
999 return;
1000
1001 hci_dev_lock(hdev);
1002
1003 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1004 if (conn) {
1005 if (conn->state == BT_CONFIG) {
1006 hci_proto_connect_cfm(conn, status);
1007 hci_conn_put(conn);
1008 }
1009 }
1010
1011 hci_dev_unlock(hdev);
1012}
1013
Johan Hedberg127178d2010-11-18 22:22:29 +02001014static int hci_outgoing_auth_needed(struct hci_dev *hdev,
Szymon Janc138d22e2011-02-17 16:44:23 +01001015 struct hci_conn *conn)
Johan Hedberg392599b2010-11-18 22:22:28 +02001016{
Johan Hedberg392599b2010-11-18 22:22:28 +02001017 if (conn->state != BT_CONFIG || !conn->out)
1018 return 0;
1019
Johan Hedberg765c2a92011-01-19 12:06:52 +05301020 if (conn->pending_sec_level == BT_SECURITY_SDP)
Johan Hedberg392599b2010-11-18 22:22:28 +02001021 return 0;
1022
1023 /* Only request authentication for SSP connections or non-SSP
1024 * devices with sec_level HIGH */
1025 if (!(hdev->ssp_mode > 0 && conn->ssp_mode > 0) &&
Johan Hedberg765c2a92011-01-19 12:06:52 +05301026 conn->pending_sec_level != BT_SECURITY_HIGH)
Johan Hedberg392599b2010-11-18 22:22:28 +02001027 return 0;
1028
Johan Hedberg392599b2010-11-18 22:22:28 +02001029 return 1;
1030}
1031
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001032static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
1033{
Johan Hedberg127178d2010-11-18 22:22:29 +02001034 struct hci_cp_remote_name_req *cp;
1035 struct hci_conn *conn;
1036
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001037 BT_DBG("%s status 0x%x", hdev->name, status);
Johan Hedberg127178d2010-11-18 22:22:29 +02001038
1039 /* If successful wait for the name req complete event before
1040 * checking for the need to do authentication */
1041 if (!status)
1042 return;
1043
1044 cp = hci_sent_cmd_data(hdev, HCI_OP_REMOTE_NAME_REQ);
1045 if (!cp)
1046 return;
1047
1048 hci_dev_lock(hdev);
1049
1050 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
Johan Hedberg79c6c702011-04-28 11:28:55 -07001051 if (!conn)
1052 goto unlock;
1053
1054 if (!hci_outgoing_auth_needed(hdev, conn))
1055 goto unlock;
1056
1057 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02001058 struct hci_cp_auth_requested cp;
1059 cp.handle = __cpu_to_le16(conn->handle);
1060 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
1061 }
1062
Johan Hedberg79c6c702011-04-28 11:28:55 -07001063unlock:
Johan Hedberg127178d2010-11-18 22:22:29 +02001064 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001065}
1066
Marcel Holtmann769be972008-07-14 20:13:49 +02001067static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
1068{
1069 struct hci_cp_read_remote_features *cp;
1070 struct hci_conn *conn;
1071
1072 BT_DBG("%s status 0x%x", hdev->name, status);
1073
1074 if (!status)
1075 return;
1076
1077 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
1078 if (!cp)
1079 return;
1080
1081 hci_dev_lock(hdev);
1082
1083 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1084 if (conn) {
1085 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001086 hci_proto_connect_cfm(conn, status);
1087 hci_conn_put(conn);
1088 }
1089 }
1090
1091 hci_dev_unlock(hdev);
1092}
1093
1094static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
1095{
1096 struct hci_cp_read_remote_ext_features *cp;
1097 struct hci_conn *conn;
1098
1099 BT_DBG("%s status 0x%x", hdev->name, status);
1100
1101 if (!status)
1102 return;
1103
1104 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
1105 if (!cp)
1106 return;
1107
1108 hci_dev_lock(hdev);
1109
1110 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1111 if (conn) {
1112 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001113 hci_proto_connect_cfm(conn, status);
1114 hci_conn_put(conn);
1115 }
1116 }
1117
1118 hci_dev_unlock(hdev);
1119}
1120
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001121static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
1122{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001123 struct hci_cp_setup_sync_conn *cp;
1124 struct hci_conn *acl, *sco;
1125 __u16 handle;
1126
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001127 BT_DBG("%s status 0x%x", hdev->name, status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001128
1129 if (!status)
1130 return;
1131
1132 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
1133 if (!cp)
1134 return;
1135
1136 handle = __le16_to_cpu(cp->handle);
1137
1138 BT_DBG("%s handle %d", hdev->name, handle);
1139
1140 hci_dev_lock(hdev);
1141
1142 acl = hci_conn_hash_lookup_handle(hdev, handle);
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001143 if (acl) {
1144 sco = acl->link;
1145 if (sco) {
1146 sco->state = BT_CLOSED;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001147
Andrei Emeltchenko5a08ecc2011-01-11 17:20:20 +02001148 hci_proto_connect_cfm(sco, status);
1149 hci_conn_del(sco);
1150 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001151 }
1152
1153 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001154}
1155
1156static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
1157{
1158 struct hci_cp_sniff_mode *cp;
1159 struct hci_conn *conn;
1160
1161 BT_DBG("%s status 0x%x", hdev->name, status);
1162
1163 if (!status)
1164 return;
1165
1166 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
1167 if (!cp)
1168 return;
1169
1170 hci_dev_lock(hdev);
1171
1172 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001173 if (conn) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001174 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
1175
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001176 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
1177 hci_sco_setup(conn, status);
1178 }
1179
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001180 hci_dev_unlock(hdev);
1181}
1182
1183static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
1184{
1185 struct hci_cp_exit_sniff_mode *cp;
1186 struct hci_conn *conn;
1187
1188 BT_DBG("%s status 0x%x", hdev->name, status);
1189
1190 if (!status)
1191 return;
1192
1193 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
1194 if (!cp)
1195 return;
1196
1197 hci_dev_lock(hdev);
1198
1199 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001200 if (conn) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001201 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
1202
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001203 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
1204 hci_sco_setup(conn, status);
1205 }
1206
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001207 hci_dev_unlock(hdev);
1208}
1209
Ville Tervofcd89c02011-02-10 22:38:47 -03001210static void hci_cs_le_create_conn(struct hci_dev *hdev, __u8 status)
1211{
1212 struct hci_cp_le_create_conn *cp;
1213 struct hci_conn *conn;
1214
1215 BT_DBG("%s status 0x%x", hdev->name, status);
1216
1217 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_CREATE_CONN);
1218 if (!cp)
1219 return;
1220
1221 hci_dev_lock(hdev);
1222
1223 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &cp->peer_addr);
1224
1225 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->peer_addr),
1226 conn);
1227
1228 if (status) {
1229 if (conn && conn->state == BT_CONNECT) {
1230 conn->state = BT_CLOSED;
1231 hci_proto_connect_cfm(conn, status);
1232 hci_conn_del(conn);
1233 }
1234 } else {
1235 if (!conn) {
1236 conn = hci_conn_add(hdev, LE_LINK, &cp->peer_addr);
1237 if (conn)
1238 conn->out = 1;
1239 else
1240 BT_ERR("No memory for new connection");
1241 }
1242 }
1243
1244 hci_dev_unlock(hdev);
1245}
1246
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001247static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1248{
1249 __u8 status = *((__u8 *) skb->data);
1250
1251 BT_DBG("%s status %d", hdev->name, status);
1252
Johan Hedberg314b2382011-04-27 10:29:57 -04001253 if (test_bit(HCI_MGMT, &hdev->flags) &&
1254 test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
1255 mgmt_discovering(hdev->id, 0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001256
Johan Hedberg23bb5762010-12-21 23:01:27 +02001257 hci_req_complete(hdev, HCI_OP_INQUIRY, status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001258
1259 hci_conn_check_pending(hdev);
1260}
1261
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1263{
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001264 struct inquiry_data data;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001265 struct inquiry_info *info = (void *) (skb->data + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 int num_rsp = *((__u8 *) skb->data);
1267
1268 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1269
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001270 if (!num_rsp)
1271 return;
1272
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001274
Johan Hedberg314b2382011-04-27 10:29:57 -04001275 if (!test_and_set_bit(HCI_INQUIRY, &hdev->flags)) {
1276
1277 if (test_bit(HCI_MGMT, &hdev->flags))
1278 mgmt_discovering(hdev->id, 1);
1279 }
1280
Johan Hedberge17acd42011-03-30 23:57:16 +03001281 for (; num_rsp; num_rsp--, info++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 bacpy(&data.bdaddr, &info->bdaddr);
1283 data.pscan_rep_mode = info->pscan_rep_mode;
1284 data.pscan_period_mode = info->pscan_period_mode;
1285 data.pscan_mode = info->pscan_mode;
1286 memcpy(data.dev_class, info->dev_class, 3);
1287 data.clock_offset = info->clock_offset;
1288 data.rssi = 0x00;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001289 data.ssp_mode = 0x00;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 hci_inquiry_cache_update(hdev, &data);
Johan Hedberge17acd42011-03-30 23:57:16 +03001291 mgmt_device_found(hdev->id, &info->bdaddr, info->dev_class, 0,
1292 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001294
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 hci_dev_unlock(hdev);
1296}
1297
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001298static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001300 struct hci_ev_conn_complete *ev = (void *) skb->data;
1301 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001303 BT_DBG("%s", hdev->name);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001304
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001306
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001307 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann94992372009-04-19 19:30:03 +02001308 if (!conn) {
1309 if (ev->link_type != SCO_LINK)
1310 goto unlock;
1311
1312 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1313 if (!conn)
1314 goto unlock;
1315
1316 conn->type = SCO_LINK;
1317 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001318
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001319 if (!ev->status) {
1320 conn->handle = __le16_to_cpu(ev->handle);
Marcel Holtmann769be972008-07-14 20:13:49 +02001321
1322 if (conn->type == ACL_LINK) {
1323 conn->state = BT_CONFIG;
1324 hci_conn_hold(conn);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001325 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Johan Hedbergf7520542011-01-20 12:34:39 +02001326 mgmt_connected(hdev->id, &ev->bdaddr);
Marcel Holtmann769be972008-07-14 20:13:49 +02001327 } else
1328 conn->state = BT_CONNECTED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001329
Marcel Holtmann9eba32b2009-08-22 14:19:26 -07001330 hci_conn_hold_device(conn);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001331 hci_conn_add_sysfs(conn);
1332
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001333 if (test_bit(HCI_AUTH, &hdev->flags))
1334 conn->link_mode |= HCI_LM_AUTH;
1335
1336 if (test_bit(HCI_ENCRYPT, &hdev->flags))
1337 conn->link_mode |= HCI_LM_ENCRYPT;
1338
1339 /* Get remote features */
1340 if (conn->type == ACL_LINK) {
1341 struct hci_cp_read_remote_features cp;
1342 cp.handle = ev->handle;
Marcel Holtmann769be972008-07-14 20:13:49 +02001343 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
1344 sizeof(cp), &cp);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001345 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001346
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001347 /* Set packet type for incoming connection */
Marcel Holtmanna8746412008-07-14 20:13:46 +02001348 if (!conn->out && hdev->hci_ver < 3) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001349 struct hci_cp_change_conn_ptype cp;
1350 cp.handle = ev->handle;
Marcel Holtmanna8746412008-07-14 20:13:46 +02001351 cp.pkt_type = cpu_to_le16(conn->pkt_type);
1352 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
1353 sizeof(cp), &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001354 }
Johan Hedberg17d5c042011-01-22 06:09:08 +02001355 } else {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001356 conn->state = BT_CLOSED;
Johan Hedberg17d5c042011-01-22 06:09:08 +02001357 if (conn->type == ACL_LINK)
1358 mgmt_connect_failed(hdev->id, &ev->bdaddr, ev->status);
1359 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001360
Marcel Holtmanne73439d2010-07-26 10:06:00 -04001361 if (conn->type == ACL_LINK)
1362 hci_sco_setup(conn, ev->status);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -07001363
Marcel Holtmann769be972008-07-14 20:13:49 +02001364 if (ev->status) {
1365 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001366 hci_conn_del(conn);
Marcel Holtmannc89b6e62009-01-15 21:57:03 +01001367 } else if (ev->link_type != ACL_LINK)
1368 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001369
1370unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001372
1373 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374}
1375
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1377{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001378 struct hci_ev_conn_request *ev = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 int mask = hdev->link_mode;
1380
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001381 BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
1382 batostr(&ev->bdaddr), ev->link_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383
1384 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
1385
Szymon Janc138d22e2011-02-17 16:44:23 +01001386 if ((mask & HCI_LM_ACCEPT) &&
1387 !hci_blacklist_lookup(hdev, &ev->bdaddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 /* Connection accepted */
Marcel Holtmannc7bdd502008-07-14 20:13:47 +02001389 struct inquiry_entry *ie;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
1392 hci_dev_lock(hdev);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001393
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02001394 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
1395 if (ie)
Marcel Holtmannc7bdd502008-07-14 20:13:47 +02001396 memcpy(ie->data.dev_class, ev->dev_class, 3);
1397
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
1399 if (!conn) {
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02001400 conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr);
1401 if (!conn) {
Gustavo F. Padovan893ef972010-07-18 15:13:37 -03001402 BT_ERR("No memory for new connection");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 hci_dev_unlock(hdev);
1404 return;
1405 }
1406 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001407
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 memcpy(conn->dev_class, ev->dev_class, 3);
1409 conn->state = BT_CONNECT;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001410
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 hci_dev_unlock(hdev);
1412
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001413 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
1414 struct hci_cp_accept_conn_req cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001416 bacpy(&cp.bdaddr, &ev->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001418 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
1419 cp.role = 0x00; /* Become master */
1420 else
1421 cp.role = 0x01; /* Remain slave */
1422
1423 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
1424 sizeof(cp), &cp);
1425 } else {
1426 struct hci_cp_accept_sync_conn_req cp;
1427
1428 bacpy(&cp.bdaddr, &ev->bdaddr);
Marcel Holtmanna8746412008-07-14 20:13:46 +02001429 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001430
1431 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
1432 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
1433 cp.max_latency = cpu_to_le16(0xffff);
1434 cp.content_format = cpu_to_le16(hdev->voice_setting);
1435 cp.retrans_effort = 0xff;
1436
1437 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
1438 sizeof(cp), &cp);
1439 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 } else {
1441 /* Connection rejected */
1442 struct hci_cp_reject_conn_req cp;
1443
1444 bacpy(&cp.bdaddr, &ev->bdaddr);
1445 cp.reason = 0x0f;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001446 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 }
1448}
1449
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1451{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001452 struct hci_ev_disconn_complete *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001453 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454
1455 BT_DBG("%s status %d", hdev->name, ev->status);
1456
Johan Hedberg8962ee72011-01-20 12:40:27 +02001457 if (ev->status) {
1458 mgmt_disconnect_failed(hdev->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 return;
Johan Hedberg8962ee72011-01-20 12:40:27 +02001460 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461
1462 hci_dev_lock(hdev);
1463
Marcel Holtmann04837f62006-07-03 10:02:33 +02001464 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergf7520542011-01-20 12:34:39 +02001465 if (!conn)
1466 goto unlock;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001467
Johan Hedbergf7520542011-01-20 12:34:39 +02001468 conn->state = BT_CLOSED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469
Vinicius Costa Gomes83bc71b2011-05-06 18:41:43 -03001470 if (conn->type == ACL_LINK || conn->type == LE_LINK)
Johan Hedbergf7520542011-01-20 12:34:39 +02001471 mgmt_disconnected(hdev->id, &conn->dst);
1472
1473 hci_proto_disconn_cfm(conn, ev->reason);
1474 hci_conn_del(conn);
1475
1476unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 hci_dev_unlock(hdev);
1478}
1479
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001480static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1481{
1482 struct hci_ev_auth_complete *ev = (void *) skb->data;
1483 struct hci_conn *conn;
1484
1485 BT_DBG("%s status %d", hdev->name, ev->status);
1486
1487 hci_dev_lock(hdev);
1488
1489 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1490 if (conn) {
Johan Hedberg765c2a92011-01-19 12:06:52 +05301491 if (!ev->status) {
Waldemar Rymarkiewicz19f8def2011-05-31 15:49:25 +02001492 if (!(conn->ssp_mode > 0 && hdev->ssp_mode > 0) &&
1493 test_bit(HCI_CONN_REAUTH_PEND,
1494 &conn->pend)) {
1495 BT_INFO("re-auth of legacy device is not"
1496 "possible.");
1497 } else {
1498 conn->link_mode |= HCI_LM_AUTH;
1499 conn->sec_level = conn->pending_sec_level;
1500 }
Johan Hedberg2a611692011-02-19 12:06:00 -03001501 } else {
1502 mgmt_auth_failed(hdev->id, &conn->dst, ev->status);
Johan Hedberg2a611692011-02-19 12:06:00 -03001503 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001504
1505 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
Waldemar Rymarkiewicz19f8def2011-05-31 15:49:25 +02001506 clear_bit(HCI_CONN_REAUTH_PEND, &conn->pend);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001507
Marcel Holtmannf8558552008-07-14 20:13:49 +02001508 if (conn->state == BT_CONFIG) {
1509 if (!ev->status && hdev->ssp_mode > 0 &&
1510 conn->ssp_mode > 0) {
1511 struct hci_cp_set_conn_encrypt cp;
1512 cp.handle = ev->handle;
1513 cp.encrypt = 0x01;
1514 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1515 sizeof(cp), &cp);
1516 } else {
1517 conn->state = BT_CONNECTED;
1518 hci_proto_connect_cfm(conn, ev->status);
1519 hci_conn_put(conn);
1520 }
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001521 } else {
Marcel Holtmannf8558552008-07-14 20:13:49 +02001522 hci_auth_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001523
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001524 hci_conn_hold(conn);
1525 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
1526 hci_conn_put(conn);
1527 }
1528
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001529 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
1530 if (!ev->status) {
1531 struct hci_cp_set_conn_encrypt cp;
Marcel Holtmannf8558552008-07-14 20:13:49 +02001532 cp.handle = ev->handle;
1533 cp.encrypt = 0x01;
1534 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1535 sizeof(cp), &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001536 } else {
1537 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1538 hci_encrypt_cfm(conn, ev->status, 0x00);
1539 }
1540 }
1541 }
1542
1543 hci_dev_unlock(hdev);
1544}
1545
1546static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
1547{
Johan Hedberg127178d2010-11-18 22:22:29 +02001548 struct hci_ev_remote_name *ev = (void *) skb->data;
1549 struct hci_conn *conn;
1550
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001551 BT_DBG("%s", hdev->name);
1552
1553 hci_conn_check_pending(hdev);
Johan Hedberg127178d2010-11-18 22:22:29 +02001554
1555 hci_dev_lock(hdev);
1556
Johan Hedberga88a9652011-03-30 13:18:12 +03001557 if (ev->status == 0 && test_bit(HCI_MGMT, &hdev->flags))
1558 mgmt_remote_name(hdev->id, &ev->bdaddr, ev->name);
1559
Johan Hedberg127178d2010-11-18 22:22:29 +02001560 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg79c6c702011-04-28 11:28:55 -07001561 if (!conn)
1562 goto unlock;
1563
1564 if (!hci_outgoing_auth_needed(hdev, conn))
1565 goto unlock;
1566
1567 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
Johan Hedberg127178d2010-11-18 22:22:29 +02001568 struct hci_cp_auth_requested cp;
1569 cp.handle = __cpu_to_le16(conn->handle);
1570 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
1571 }
1572
Johan Hedberg79c6c702011-04-28 11:28:55 -07001573unlock:
Johan Hedberg127178d2010-11-18 22:22:29 +02001574 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001575}
1576
1577static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1578{
1579 struct hci_ev_encrypt_change *ev = (void *) skb->data;
1580 struct hci_conn *conn;
1581
1582 BT_DBG("%s status %d", hdev->name, ev->status);
1583
1584 hci_dev_lock(hdev);
1585
1586 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1587 if (conn) {
1588 if (!ev->status) {
Marcel Holtmannae293192008-07-14 20:13:45 +02001589 if (ev->encrypt) {
1590 /* Encryption implies authentication */
1591 conn->link_mode |= HCI_LM_AUTH;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001592 conn->link_mode |= HCI_LM_ENCRYPT;
Marcel Holtmannae293192008-07-14 20:13:45 +02001593 } else
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001594 conn->link_mode &= ~HCI_LM_ENCRYPT;
1595 }
1596
1597 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1598
Marcel Holtmannf8558552008-07-14 20:13:49 +02001599 if (conn->state == BT_CONFIG) {
1600 if (!ev->status)
1601 conn->state = BT_CONNECTED;
1602
1603 hci_proto_connect_cfm(conn, ev->status);
1604 hci_conn_put(conn);
1605 } else
1606 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001607 }
1608
1609 hci_dev_unlock(hdev);
1610}
1611
1612static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1613{
1614 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
1615 struct hci_conn *conn;
1616
1617 BT_DBG("%s status %d", hdev->name, ev->status);
1618
1619 hci_dev_lock(hdev);
1620
1621 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1622 if (conn) {
1623 if (!ev->status)
1624 conn->link_mode |= HCI_LM_SECURE;
1625
1626 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1627
1628 hci_key_change_cfm(conn, ev->status);
1629 }
1630
1631 hci_dev_unlock(hdev);
1632}
1633
1634static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1635{
1636 struct hci_ev_remote_features *ev = (void *) skb->data;
1637 struct hci_conn *conn;
1638
1639 BT_DBG("%s status %d", hdev->name, ev->status);
1640
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001641 hci_dev_lock(hdev);
1642
1643 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergccd556f2010-11-10 17:11:51 +02001644 if (!conn)
1645 goto unlock;
Marcel Holtmann769be972008-07-14 20:13:49 +02001646
Johan Hedbergccd556f2010-11-10 17:11:51 +02001647 if (!ev->status)
1648 memcpy(conn->features, ev->features, 8);
1649
1650 if (conn->state != BT_CONFIG)
1651 goto unlock;
1652
1653 if (!ev->status && lmp_ssp_capable(hdev) && lmp_ssp_capable(conn)) {
1654 struct hci_cp_read_remote_ext_features cp;
1655 cp.handle = ev->handle;
1656 cp.page = 0x01;
1657 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES,
Marcel Holtmann769be972008-07-14 20:13:49 +02001658 sizeof(cp), &cp);
Johan Hedberg392599b2010-11-18 22:22:28 +02001659 goto unlock;
1660 }
1661
Johan Hedberg127178d2010-11-18 22:22:29 +02001662 if (!ev->status) {
1663 struct hci_cp_remote_name_req cp;
1664 memset(&cp, 0, sizeof(cp));
1665 bacpy(&cp.bdaddr, &conn->dst);
1666 cp.pscan_rep_mode = 0x02;
1667 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
1668 }
Johan Hedberg392599b2010-11-18 22:22:28 +02001669
Johan Hedberg127178d2010-11-18 22:22:29 +02001670 if (!hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedbergccd556f2010-11-10 17:11:51 +02001671 conn->state = BT_CONNECTED;
1672 hci_proto_connect_cfm(conn, ev->status);
1673 hci_conn_put(conn);
Marcel Holtmann769be972008-07-14 20:13:49 +02001674 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001675
Johan Hedbergccd556f2010-11-10 17:11:51 +02001676unlock:
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001677 hci_dev_unlock(hdev);
1678}
1679
1680static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
1681{
1682 BT_DBG("%s", hdev->name);
1683}
1684
1685static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1686{
1687 BT_DBG("%s", hdev->name);
1688}
1689
1690static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1691{
1692 struct hci_ev_cmd_complete *ev = (void *) skb->data;
1693 __u16 opcode;
1694
1695 skb_pull(skb, sizeof(*ev));
1696
1697 opcode = __le16_to_cpu(ev->opcode);
1698
1699 switch (opcode) {
1700 case HCI_OP_INQUIRY_CANCEL:
1701 hci_cc_inquiry_cancel(hdev, skb);
1702 break;
1703
1704 case HCI_OP_EXIT_PERIODIC_INQ:
1705 hci_cc_exit_periodic_inq(hdev, skb);
1706 break;
1707
1708 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
1709 hci_cc_remote_name_req_cancel(hdev, skb);
1710 break;
1711
1712 case HCI_OP_ROLE_DISCOVERY:
1713 hci_cc_role_discovery(hdev, skb);
1714 break;
1715
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001716 case HCI_OP_READ_LINK_POLICY:
1717 hci_cc_read_link_policy(hdev, skb);
1718 break;
1719
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001720 case HCI_OP_WRITE_LINK_POLICY:
1721 hci_cc_write_link_policy(hdev, skb);
1722 break;
1723
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001724 case HCI_OP_READ_DEF_LINK_POLICY:
1725 hci_cc_read_def_link_policy(hdev, skb);
1726 break;
1727
1728 case HCI_OP_WRITE_DEF_LINK_POLICY:
1729 hci_cc_write_def_link_policy(hdev, skb);
1730 break;
1731
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001732 case HCI_OP_RESET:
1733 hci_cc_reset(hdev, skb);
1734 break;
1735
1736 case HCI_OP_WRITE_LOCAL_NAME:
1737 hci_cc_write_local_name(hdev, skb);
1738 break;
1739
1740 case HCI_OP_READ_LOCAL_NAME:
1741 hci_cc_read_local_name(hdev, skb);
1742 break;
1743
1744 case HCI_OP_WRITE_AUTH_ENABLE:
1745 hci_cc_write_auth_enable(hdev, skb);
1746 break;
1747
1748 case HCI_OP_WRITE_ENCRYPT_MODE:
1749 hci_cc_write_encrypt_mode(hdev, skb);
1750 break;
1751
1752 case HCI_OP_WRITE_SCAN_ENABLE:
1753 hci_cc_write_scan_enable(hdev, skb);
1754 break;
1755
1756 case HCI_OP_READ_CLASS_OF_DEV:
1757 hci_cc_read_class_of_dev(hdev, skb);
1758 break;
1759
1760 case HCI_OP_WRITE_CLASS_OF_DEV:
1761 hci_cc_write_class_of_dev(hdev, skb);
1762 break;
1763
1764 case HCI_OP_READ_VOICE_SETTING:
1765 hci_cc_read_voice_setting(hdev, skb);
1766 break;
1767
1768 case HCI_OP_WRITE_VOICE_SETTING:
1769 hci_cc_write_voice_setting(hdev, skb);
1770 break;
1771
1772 case HCI_OP_HOST_BUFFER_SIZE:
1773 hci_cc_host_buffer_size(hdev, skb);
1774 break;
1775
Marcel Holtmann333140b2008-07-14 20:13:48 +02001776 case HCI_OP_READ_SSP_MODE:
1777 hci_cc_read_ssp_mode(hdev, skb);
1778 break;
1779
1780 case HCI_OP_WRITE_SSP_MODE:
1781 hci_cc_write_ssp_mode(hdev, skb);
1782 break;
1783
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001784 case HCI_OP_READ_LOCAL_VERSION:
1785 hci_cc_read_local_version(hdev, skb);
1786 break;
1787
1788 case HCI_OP_READ_LOCAL_COMMANDS:
1789 hci_cc_read_local_commands(hdev, skb);
1790 break;
1791
1792 case HCI_OP_READ_LOCAL_FEATURES:
1793 hci_cc_read_local_features(hdev, skb);
1794 break;
1795
1796 case HCI_OP_READ_BUFFER_SIZE:
1797 hci_cc_read_buffer_size(hdev, skb);
1798 break;
1799
1800 case HCI_OP_READ_BD_ADDR:
1801 hci_cc_read_bd_addr(hdev, skb);
1802 break;
1803
Johan Hedberg23bb5762010-12-21 23:01:27 +02001804 case HCI_OP_WRITE_CA_TIMEOUT:
1805 hci_cc_write_ca_timeout(hdev, skb);
1806 break;
1807
Johan Hedbergb0916ea2011-01-10 13:44:55 +02001808 case HCI_OP_DELETE_STORED_LINK_KEY:
1809 hci_cc_delete_stored_link_key(hdev, skb);
1810 break;
1811
Johan Hedbergd5859e22011-01-25 01:19:58 +02001812 case HCI_OP_SET_EVENT_MASK:
1813 hci_cc_set_event_mask(hdev, skb);
1814 break;
1815
1816 case HCI_OP_WRITE_INQUIRY_MODE:
1817 hci_cc_write_inquiry_mode(hdev, skb);
1818 break;
1819
1820 case HCI_OP_READ_INQ_RSP_TX_POWER:
1821 hci_cc_read_inq_rsp_tx_power(hdev, skb);
1822 break;
1823
1824 case HCI_OP_SET_EVENT_FLT:
1825 hci_cc_set_event_flt(hdev, skb);
1826 break;
1827
Johan Hedberg980e1a52011-01-22 06:10:07 +02001828 case HCI_OP_PIN_CODE_REPLY:
1829 hci_cc_pin_code_reply(hdev, skb);
1830 break;
1831
1832 case HCI_OP_PIN_CODE_NEG_REPLY:
1833 hci_cc_pin_code_neg_reply(hdev, skb);
1834 break;
1835
Szymon Jancc35938b2011-03-22 13:12:21 +01001836 case HCI_OP_READ_LOCAL_OOB_DATA:
1837 hci_cc_read_local_oob_data_reply(hdev, skb);
1838 break;
1839
Ville Tervo6ed58ec2011-02-10 22:38:48 -03001840 case HCI_OP_LE_READ_BUFFER_SIZE:
1841 hci_cc_le_read_buffer_size(hdev, skb);
1842 break;
1843
Johan Hedberga5c29682011-02-19 12:05:57 -03001844 case HCI_OP_USER_CONFIRM_REPLY:
1845 hci_cc_user_confirm_reply(hdev, skb);
1846 break;
1847
1848 case HCI_OP_USER_CONFIRM_NEG_REPLY:
1849 hci_cc_user_confirm_neg_reply(hdev, skb);
1850 break;
1851
Andre Guedeseb9d91f2011-05-26 16:23:52 -03001852 case HCI_OP_LE_SET_SCAN_ENABLE:
1853 hci_cc_le_set_scan_enable(hdev, skb);
1854 break;
1855
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001856 default:
1857 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1858 break;
1859 }
1860
Ville Tervo6bd32322011-02-16 16:32:41 +02001861 if (ev->opcode != HCI_OP_NOP)
1862 del_timer(&hdev->cmd_timer);
1863
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001864 if (ev->ncmd) {
1865 atomic_set(&hdev->cmd_cnt, 1);
1866 if (!skb_queue_empty(&hdev->cmd_q))
Marcel Holtmannc78ae282009-11-18 01:02:54 +01001867 tasklet_schedule(&hdev->cmd_task);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001868 }
1869}
1870
1871static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1872{
1873 struct hci_ev_cmd_status *ev = (void *) skb->data;
1874 __u16 opcode;
1875
1876 skb_pull(skb, sizeof(*ev));
1877
1878 opcode = __le16_to_cpu(ev->opcode);
1879
1880 switch (opcode) {
1881 case HCI_OP_INQUIRY:
1882 hci_cs_inquiry(hdev, ev->status);
1883 break;
1884
1885 case HCI_OP_CREATE_CONN:
1886 hci_cs_create_conn(hdev, ev->status);
1887 break;
1888
1889 case HCI_OP_ADD_SCO:
1890 hci_cs_add_sco(hdev, ev->status);
1891 break;
1892
Marcel Holtmannf8558552008-07-14 20:13:49 +02001893 case HCI_OP_AUTH_REQUESTED:
1894 hci_cs_auth_requested(hdev, ev->status);
1895 break;
1896
1897 case HCI_OP_SET_CONN_ENCRYPT:
1898 hci_cs_set_conn_encrypt(hdev, ev->status);
1899 break;
1900
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001901 case HCI_OP_REMOTE_NAME_REQ:
1902 hci_cs_remote_name_req(hdev, ev->status);
1903 break;
1904
Marcel Holtmann769be972008-07-14 20:13:49 +02001905 case HCI_OP_READ_REMOTE_FEATURES:
1906 hci_cs_read_remote_features(hdev, ev->status);
1907 break;
1908
1909 case HCI_OP_READ_REMOTE_EXT_FEATURES:
1910 hci_cs_read_remote_ext_features(hdev, ev->status);
1911 break;
1912
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001913 case HCI_OP_SETUP_SYNC_CONN:
1914 hci_cs_setup_sync_conn(hdev, ev->status);
1915 break;
1916
1917 case HCI_OP_SNIFF_MODE:
1918 hci_cs_sniff_mode(hdev, ev->status);
1919 break;
1920
1921 case HCI_OP_EXIT_SNIFF_MODE:
1922 hci_cs_exit_sniff_mode(hdev, ev->status);
1923 break;
1924
Johan Hedberg8962ee72011-01-20 12:40:27 +02001925 case HCI_OP_DISCONNECT:
1926 if (ev->status != 0)
1927 mgmt_disconnect_failed(hdev->id);
1928 break;
1929
Ville Tervofcd89c02011-02-10 22:38:47 -03001930 case HCI_OP_LE_CREATE_CONN:
1931 hci_cs_le_create_conn(hdev, ev->status);
1932 break;
1933
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001934 default:
1935 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1936 break;
1937 }
1938
Ville Tervo6bd32322011-02-16 16:32:41 +02001939 if (ev->opcode != HCI_OP_NOP)
1940 del_timer(&hdev->cmd_timer);
1941
Gustavo F. Padovan10572132011-03-16 15:36:29 -03001942 if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags)) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001943 atomic_set(&hdev->cmd_cnt, 1);
1944 if (!skb_queue_empty(&hdev->cmd_q))
Marcel Holtmannc78ae282009-11-18 01:02:54 +01001945 tasklet_schedule(&hdev->cmd_task);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001946 }
1947}
1948
1949static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1950{
1951 struct hci_ev_role_change *ev = (void *) skb->data;
1952 struct hci_conn *conn;
1953
1954 BT_DBG("%s status %d", hdev->name, ev->status);
1955
1956 hci_dev_lock(hdev);
1957
1958 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1959 if (conn) {
1960 if (!ev->status) {
1961 if (ev->role)
1962 conn->link_mode &= ~HCI_LM_MASTER;
1963 else
1964 conn->link_mode |= HCI_LM_MASTER;
1965 }
1966
1967 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1968
1969 hci_role_switch_cfm(conn, ev->status, ev->role);
1970 }
1971
1972 hci_dev_unlock(hdev);
1973}
1974
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1976{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001977 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08001978 __le16 *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 int i;
1980
1981 skb_pull(skb, sizeof(*ev));
1982
1983 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1984
1985 if (skb->len < ev->num_hndl * 4) {
1986 BT_DBG("%s bad parameters", hdev->name);
1987 return;
1988 }
1989
1990 tasklet_disable(&hdev->tx_task);
1991
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08001992 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 struct hci_conn *conn;
1994 __u16 handle, count;
1995
Harvey Harrison83985312008-05-02 16:25:46 -07001996 handle = get_unaligned_le16(ptr++);
1997 count = get_unaligned_le16(ptr++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998
1999 conn = hci_conn_hash_lookup_handle(hdev, handle);
2000 if (conn) {
2001 conn->sent -= count;
2002
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02002003 if (conn->type == ACL_LINK) {
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002004 hdev->acl_cnt += count;
2005 if (hdev->acl_cnt > hdev->acl_pkts)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 hdev->acl_cnt = hdev->acl_pkts;
Ville Tervo6ed58ec2011-02-10 22:38:48 -03002007 } else if (conn->type == LE_LINK) {
2008 if (hdev->le_pkts) {
2009 hdev->le_cnt += count;
2010 if (hdev->le_cnt > hdev->le_pkts)
2011 hdev->le_cnt = hdev->le_pkts;
2012 } else {
2013 hdev->acl_cnt += count;
2014 if (hdev->acl_cnt > hdev->acl_pkts)
2015 hdev->acl_cnt = hdev->acl_pkts;
2016 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02002017 } else {
Andrei Emeltchenko70f230202010-12-01 16:58:25 +02002018 hdev->sco_cnt += count;
2019 if (hdev->sco_cnt > hdev->sco_pkts)
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02002020 hdev->sco_cnt = hdev->sco_pkts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 }
2022 }
2023 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002024
Marcel Holtmannc78ae282009-11-18 01:02:54 +01002025 tasklet_schedule(&hdev->tx_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026
2027 tasklet_enable(&hdev->tx_task);
2028}
2029
Marcel Holtmann04837f62006-07-03 10:02:33 +02002030static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002032 struct hci_ev_mode_change *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002033 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034
2035 BT_DBG("%s status %d", hdev->name, ev->status);
2036
2037 hci_dev_lock(hdev);
2038
Marcel Holtmann04837f62006-07-03 10:02:33 +02002039 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2040 if (conn) {
2041 conn->mode = ev->mode;
2042 conn->interval = __le16_to_cpu(ev->interval);
2043
2044 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
2045 if (conn->mode == HCI_CM_ACTIVE)
2046 conn->power_save = 1;
2047 else
2048 conn->power_save = 0;
2049 }
Marcel Holtmanne73439d2010-07-26 10:06:00 -04002050
2051 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
2052 hci_sco_setup(conn, ev->status);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002053 }
2054
2055 hci_dev_unlock(hdev);
2056}
2057
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
2059{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002060 struct hci_ev_pin_code_req *ev = (void *) skb->data;
2061 struct hci_conn *conn;
2062
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002063 BT_DBG("%s", hdev->name);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002064
2065 hci_dev_lock(hdev);
2066
2067 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Marcel Holtmann3d7a9d12009-05-09 12:09:21 -07002068 if (conn && conn->state == BT_CONNECTED) {
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002069 hci_conn_hold(conn);
2070 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
2071 hci_conn_put(conn);
2072 }
2073
Johan Hedberg03b555e2011-01-04 15:40:05 +02002074 if (!test_bit(HCI_PAIRABLE, &hdev->flags))
2075 hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
2076 sizeof(ev->bdaddr), &ev->bdaddr);
Johan Hedberg582fbe92011-04-28 11:28:58 -07002077 else if (test_bit(HCI_MGMT, &hdev->flags)) {
Waldemar Rymarkiewicza770bb52011-04-28 12:07:59 +02002078 u8 secure;
2079
2080 if (conn->pending_sec_level == BT_SECURITY_HIGH)
2081 secure = 1;
2082 else
2083 secure = 0;
2084
2085 mgmt_pin_code_request(hdev->id, &ev->bdaddr, secure);
2086 }
Johan Hedberg980e1a52011-01-22 06:10:07 +02002087
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002088 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089}
2090
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
2092{
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002093 struct hci_ev_link_key_req *ev = (void *) skb->data;
2094 struct hci_cp_link_key_reply cp;
2095 struct hci_conn *conn;
2096 struct link_key *key;
2097
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002098 BT_DBG("%s", hdev->name);
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002099
2100 if (!test_bit(HCI_LINK_KEYS, &hdev->flags))
2101 return;
2102
2103 hci_dev_lock(hdev);
2104
2105 key = hci_find_link_key(hdev, &ev->bdaddr);
2106 if (!key) {
2107 BT_DBG("%s link key not found for %s", hdev->name,
2108 batostr(&ev->bdaddr));
2109 goto not_found;
2110 }
2111
2112 BT_DBG("%s found key type %u for %s", hdev->name, key->type,
2113 batostr(&ev->bdaddr));
2114
Waldemar Rymarkiewiczb6020ba2011-04-28 12:07:53 +02002115 if (!test_bit(HCI_DEBUG_KEYS, &hdev->flags) &&
2116 key->type == HCI_LK_DEBUG_COMBINATION) {
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002117 BT_DBG("%s ignoring debug key", hdev->name);
2118 goto not_found;
2119 }
2120
2121 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002122 if (conn) {
2123 if (key->type == HCI_LK_UNAUTH_COMBINATION &&
2124 conn->auth_type != 0xff &&
2125 (conn->auth_type & 0x01)) {
2126 BT_DBG("%s ignoring unauthenticated key", hdev->name);
2127 goto not_found;
2128 }
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002129
Waldemar Rymarkiewicz60b83f52011-04-28 12:07:56 +02002130 if (key->type == HCI_LK_COMBINATION && key->pin_len < 16 &&
2131 conn->pending_sec_level == BT_SECURITY_HIGH) {
2132 BT_DBG("%s ignoring key unauthenticated for high \
2133 security", hdev->name);
2134 goto not_found;
2135 }
2136
2137 conn->key_type = key->type;
2138 conn->pin_length = key->pin_len;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002139 }
2140
2141 bacpy(&cp.bdaddr, &ev->bdaddr);
2142 memcpy(cp.link_key, key->val, 16);
2143
2144 hci_send_cmd(hdev, HCI_OP_LINK_KEY_REPLY, sizeof(cp), &cp);
2145
2146 hci_dev_unlock(hdev);
2147
2148 return;
2149
2150not_found:
2151 hci_send_cmd(hdev, HCI_OP_LINK_KEY_NEG_REPLY, 6, &ev->bdaddr);
2152 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153}
2154
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
2156{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002157 struct hci_ev_link_key_notify *ev = (void *) skb->data;
2158 struct hci_conn *conn;
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002159 u8 pin_len = 0;
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002160
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002161 BT_DBG("%s", hdev->name);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002162
2163 hci_dev_lock(hdev);
2164
2165 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2166 if (conn) {
2167 hci_conn_hold(conn);
2168 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Johan Hedberg980e1a52011-01-22 06:10:07 +02002169 pin_len = conn->pin_length;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +02002170
2171 if (ev->key_type != HCI_LK_CHANGED_COMBINATION)
2172 conn->key_type = ev->key_type;
2173
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002174 hci_conn_put(conn);
2175 }
2176
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002177 if (test_bit(HCI_LINK_KEYS, &hdev->flags))
Johan Hedbergd25e28a2011-04-28 11:28:59 -07002178 hci_add_link_key(hdev, conn, 1, &ev->bdaddr, ev->link_key,
Johan Hedberg55ed8ca12011-01-17 14:41:05 +02002179 ev->key_type, pin_len);
2180
Marcel Holtmann052b30b2009-04-26 20:01:22 +02002181 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182}
2183
Marcel Holtmann04837f62006-07-03 10:02:33 +02002184static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
2185{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002186 struct hci_ev_clock_offset *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002187 struct hci_conn *conn;
2188
2189 BT_DBG("%s status %d", hdev->name, ev->status);
2190
2191 hci_dev_lock(hdev);
2192
2193 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194 if (conn && !ev->status) {
2195 struct inquiry_entry *ie;
2196
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002197 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2198 if (ie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199 ie->data.clock_offset = ev->clock_offset;
2200 ie->timestamp = jiffies;
2201 }
2202 }
2203
2204 hci_dev_unlock(hdev);
2205}
2206
Marcel Holtmanna8746412008-07-14 20:13:46 +02002207static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
2208{
2209 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
2210 struct hci_conn *conn;
2211
2212 BT_DBG("%s status %d", hdev->name, ev->status);
2213
2214 hci_dev_lock(hdev);
2215
2216 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2217 if (conn && !ev->status)
2218 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
2219
2220 hci_dev_unlock(hdev);
2221}
2222
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002223static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
2224{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002225 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002226 struct inquiry_entry *ie;
2227
2228 BT_DBG("%s", hdev->name);
2229
2230 hci_dev_lock(hdev);
2231
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002232 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
2233 if (ie) {
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002234 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
2235 ie->timestamp = jiffies;
2236 }
2237
2238 hci_dev_unlock(hdev);
2239}
2240
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002241static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
2242{
2243 struct inquiry_data data;
2244 int num_rsp = *((__u8 *) skb->data);
2245
2246 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
2247
2248 if (!num_rsp)
2249 return;
2250
2251 hci_dev_lock(hdev);
2252
Johan Hedberg314b2382011-04-27 10:29:57 -04002253 if (!test_and_set_bit(HCI_INQUIRY, &hdev->flags)) {
2254
2255 if (test_bit(HCI_MGMT, &hdev->flags))
2256 mgmt_discovering(hdev->id, 1);
2257 }
2258
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002259 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
Szymon Janc138d22e2011-02-17 16:44:23 +01002260 struct inquiry_info_with_rssi_and_pscan_mode *info;
2261 info = (void *) (skb->data + 1);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002262
Johan Hedberge17acd42011-03-30 23:57:16 +03002263 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002264 bacpy(&data.bdaddr, &info->bdaddr);
2265 data.pscan_rep_mode = info->pscan_rep_mode;
2266 data.pscan_period_mode = info->pscan_period_mode;
2267 data.pscan_mode = info->pscan_mode;
2268 memcpy(data.dev_class, info->dev_class, 3);
2269 data.clock_offset = info->clock_offset;
2270 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002271 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002272 hci_inquiry_cache_update(hdev, &data);
Johan Hedberge17acd42011-03-30 23:57:16 +03002273 mgmt_device_found(hdev->id, &info->bdaddr,
2274 info->dev_class, info->rssi,
2275 NULL);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002276 }
2277 } else {
2278 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
2279
Johan Hedberge17acd42011-03-30 23:57:16 +03002280 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002281 bacpy(&data.bdaddr, &info->bdaddr);
2282 data.pscan_rep_mode = info->pscan_rep_mode;
2283 data.pscan_period_mode = info->pscan_period_mode;
2284 data.pscan_mode = 0x00;
2285 memcpy(data.dev_class, info->dev_class, 3);
2286 data.clock_offset = info->clock_offset;
2287 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002288 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002289 hci_inquiry_cache_update(hdev, &data);
Johan Hedberge17acd42011-03-30 23:57:16 +03002290 mgmt_device_found(hdev->id, &info->bdaddr,
2291 info->dev_class, info->rssi,
2292 NULL);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002293 }
2294 }
2295
2296 hci_dev_unlock(hdev);
2297}
2298
2299static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
2300{
Marcel Holtmann41a96212008-07-14 20:13:48 +02002301 struct hci_ev_remote_ext_features *ev = (void *) skb->data;
2302 struct hci_conn *conn;
2303
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002304 BT_DBG("%s", hdev->name);
Marcel Holtmann41a96212008-07-14 20:13:48 +02002305
Marcel Holtmann41a96212008-07-14 20:13:48 +02002306 hci_dev_lock(hdev);
2307
2308 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Johan Hedbergccd556f2010-11-10 17:11:51 +02002309 if (!conn)
2310 goto unlock;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002311
Johan Hedbergccd556f2010-11-10 17:11:51 +02002312 if (!ev->status && ev->page == 0x01) {
2313 struct inquiry_entry *ie;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002314
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002315 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2316 if (ie)
Johan Hedbergccd556f2010-11-10 17:11:51 +02002317 ie->data.ssp_mode = (ev->features[0] & 0x01);
Marcel Holtmann769be972008-07-14 20:13:49 +02002318
Johan Hedbergccd556f2010-11-10 17:11:51 +02002319 conn->ssp_mode = (ev->features[0] & 0x01);
Marcel Holtmann41a96212008-07-14 20:13:48 +02002320 }
2321
Johan Hedbergccd556f2010-11-10 17:11:51 +02002322 if (conn->state != BT_CONFIG)
2323 goto unlock;
2324
Johan Hedberg127178d2010-11-18 22:22:29 +02002325 if (!ev->status) {
2326 struct hci_cp_remote_name_req cp;
2327 memset(&cp, 0, sizeof(cp));
2328 bacpy(&cp.bdaddr, &conn->dst);
2329 cp.pscan_rep_mode = 0x02;
2330 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
2331 }
Johan Hedberg392599b2010-11-18 22:22:28 +02002332
Johan Hedberg127178d2010-11-18 22:22:29 +02002333 if (!hci_outgoing_auth_needed(hdev, conn)) {
Johan Hedbergccd556f2010-11-10 17:11:51 +02002334 conn->state = BT_CONNECTED;
2335 hci_proto_connect_cfm(conn, ev->status);
2336 hci_conn_put(conn);
2337 }
2338
2339unlock:
Marcel Holtmann41a96212008-07-14 20:13:48 +02002340 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002341}
2342
2343static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
2344{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002345 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
2346 struct hci_conn *conn;
2347
2348 BT_DBG("%s status %d", hdev->name, ev->status);
2349
2350 hci_dev_lock(hdev);
2351
2352 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann9dc0a3a2008-07-14 20:13:46 +02002353 if (!conn) {
2354 if (ev->link_type == ESCO_LINK)
2355 goto unlock;
2356
2357 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
2358 if (!conn)
2359 goto unlock;
2360
2361 conn->type = SCO_LINK;
2362 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002363
Marcel Holtmann732547f2009-04-19 19:14:14 +02002364 switch (ev->status) {
2365 case 0x00:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002366 conn->handle = __le16_to_cpu(ev->handle);
2367 conn->state = BT_CONNECTED;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02002368
Marcel Holtmann9eba32b2009-08-22 14:19:26 -07002369 hci_conn_hold_device(conn);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02002370 hci_conn_add_sysfs(conn);
Marcel Holtmann732547f2009-04-19 19:14:14 +02002371 break;
2372
Stephen Coe705e5712010-02-16 11:29:44 -05002373 case 0x11: /* Unsupported Feature or Parameter Value */
Marcel Holtmann732547f2009-04-19 19:14:14 +02002374 case 0x1c: /* SCO interval rejected */
Nick Pelly1038a002010-02-03 11:42:26 -08002375 case 0x1a: /* Unsupported Remote Feature */
Marcel Holtmann732547f2009-04-19 19:14:14 +02002376 case 0x1f: /* Unspecified error */
2377 if (conn->out && conn->attempt < 2) {
2378 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
2379 (hdev->esco_type & EDR_ESCO_MASK);
2380 hci_setup_sync(conn, conn->link->handle);
2381 goto unlock;
2382 }
2383 /* fall through */
2384
2385 default:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002386 conn->state = BT_CLOSED;
Marcel Holtmann732547f2009-04-19 19:14:14 +02002387 break;
2388 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02002389
2390 hci_proto_connect_cfm(conn, ev->status);
2391 if (ev->status)
2392 hci_conn_del(conn);
2393
2394unlock:
2395 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002396}
2397
2398static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
2399{
2400 BT_DBG("%s", hdev->name);
2401}
2402
Marcel Holtmann04837f62006-07-03 10:02:33 +02002403static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
2404{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002405 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02002406
2407 BT_DBG("%s status %d", hdev->name, ev->status);
Marcel Holtmann04837f62006-07-03 10:02:33 +02002408}
2409
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002410static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
2411{
2412 struct inquiry_data data;
2413 struct extended_inquiry_info *info = (void *) (skb->data + 1);
2414 int num_rsp = *((__u8 *) skb->data);
2415
2416 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
2417
2418 if (!num_rsp)
2419 return;
2420
Johan Hedberg314b2382011-04-27 10:29:57 -04002421 if (!test_and_set_bit(HCI_INQUIRY, &hdev->flags)) {
2422
2423 if (test_bit(HCI_MGMT, &hdev->flags))
2424 mgmt_discovering(hdev->id, 1);
2425 }
2426
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002427 hci_dev_lock(hdev);
2428
Johan Hedberge17acd42011-03-30 23:57:16 +03002429 for (; num_rsp; num_rsp--, info++) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002430 bacpy(&data.bdaddr, &info->bdaddr);
Szymon Janc138d22e2011-02-17 16:44:23 +01002431 data.pscan_rep_mode = info->pscan_rep_mode;
2432 data.pscan_period_mode = info->pscan_period_mode;
2433 data.pscan_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002434 memcpy(data.dev_class, info->dev_class, 3);
Szymon Janc138d22e2011-02-17 16:44:23 +01002435 data.clock_offset = info->clock_offset;
2436 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02002437 data.ssp_mode = 0x01;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002438 hci_inquiry_cache_update(hdev, &data);
Johan Hedberge17acd42011-03-30 23:57:16 +03002439 mgmt_device_found(hdev->id, &info->bdaddr, info->dev_class,
2440 info->rssi, info->data);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002441 }
2442
2443 hci_dev_unlock(hdev);
2444}
2445
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002446static inline u8 hci_get_auth_req(struct hci_conn *conn)
2447{
2448 /* If remote requests dedicated bonding follow that lead */
2449 if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) {
2450 /* If both remote and local IO capabilities allow MITM
2451 * protection then require it, otherwise don't */
2452 if (conn->remote_cap == 0x03 || conn->io_capability == 0x03)
2453 return 0x02;
2454 else
2455 return 0x03;
2456 }
2457
2458 /* If remote requests no-bonding follow that lead */
2459 if (conn->remote_auth == 0x00 || conn->remote_auth == 0x01)
Waldemar Rymarkiewicz58797bf2011-04-28 12:07:58 +02002460 return conn->remote_auth | (conn->auth_type & 0x01);
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002461
2462 return conn->auth_type;
2463}
2464
Marcel Holtmann04936842008-07-14 20:13:48 +02002465static inline void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
2466{
2467 struct hci_ev_io_capa_request *ev = (void *) skb->data;
2468 struct hci_conn *conn;
2469
2470 BT_DBG("%s", hdev->name);
2471
2472 hci_dev_lock(hdev);
2473
2474 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg03b555e2011-01-04 15:40:05 +02002475 if (!conn)
2476 goto unlock;
Marcel Holtmann04936842008-07-14 20:13:48 +02002477
Johan Hedberg03b555e2011-01-04 15:40:05 +02002478 hci_conn_hold(conn);
2479
2480 if (!test_bit(HCI_MGMT, &hdev->flags))
2481 goto unlock;
2482
2483 if (test_bit(HCI_PAIRABLE, &hdev->flags) ||
2484 (conn->remote_auth & ~0x01) == HCI_AT_NO_BONDING) {
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002485 struct hci_cp_io_capability_reply cp;
2486
2487 bacpy(&cp.bdaddr, &ev->bdaddr);
2488 cp.capability = conn->io_capability;
Johan Hedberg7cbc9bd2011-04-28 11:29:04 -07002489 conn->auth_type = hci_get_auth_req(conn);
2490 cp.authentication = conn->auth_type;
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002491
Szymon Jancce85ee12011-03-22 13:12:23 +01002492 if ((conn->out == 0x01 || conn->remote_oob == 0x01) &&
2493 hci_find_remote_oob_data(hdev, &conn->dst))
2494 cp.oob_data = 0x01;
2495 else
2496 cp.oob_data = 0x00;
2497
Johan Hedberg17fa4b92011-01-25 13:28:33 +02002498 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_REPLY,
2499 sizeof(cp), &cp);
Johan Hedberg03b555e2011-01-04 15:40:05 +02002500 } else {
2501 struct hci_cp_io_capability_neg_reply cp;
2502
2503 bacpy(&cp.bdaddr, &ev->bdaddr);
Johan Hedbergbe771592011-04-28 11:28:57 -07002504 cp.reason = 0x18; /* Pairing not allowed */
Johan Hedberg03b555e2011-01-04 15:40:05 +02002505
2506 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_NEG_REPLY,
2507 sizeof(cp), &cp);
2508 }
2509
2510unlock:
2511 hci_dev_unlock(hdev);
2512}
2513
2514static inline void hci_io_capa_reply_evt(struct hci_dev *hdev, struct sk_buff *skb)
2515{
2516 struct hci_ev_io_capa_reply *ev = (void *) skb->data;
2517 struct hci_conn *conn;
2518
2519 BT_DBG("%s", hdev->name);
2520
2521 hci_dev_lock(hdev);
2522
2523 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2524 if (!conn)
2525 goto unlock;
2526
Johan Hedberg03b555e2011-01-04 15:40:05 +02002527 conn->remote_cap = ev->capability;
2528 conn->remote_oob = ev->oob_data;
2529 conn->remote_auth = ev->authentication;
2530
2531unlock:
Marcel Holtmann04936842008-07-14 20:13:48 +02002532 hci_dev_unlock(hdev);
2533}
2534
Johan Hedberga5c29682011-02-19 12:05:57 -03002535static inline void hci_user_confirm_request_evt(struct hci_dev *hdev,
2536 struct sk_buff *skb)
2537{
2538 struct hci_ev_user_confirm_req *ev = (void *) skb->data;
Johan Hedberg55bc1a32011-04-28 11:28:56 -07002539 int loc_mitm, rem_mitm, confirm_hint = 0;
Johan Hedberg7a828902011-04-28 11:28:53 -07002540 struct hci_conn *conn;
Johan Hedberga5c29682011-02-19 12:05:57 -03002541
2542 BT_DBG("%s", hdev->name);
2543
2544 hci_dev_lock(hdev);
2545
Johan Hedberg7a828902011-04-28 11:28:53 -07002546 if (!test_bit(HCI_MGMT, &hdev->flags))
2547 goto unlock;
Johan Hedberga5c29682011-02-19 12:05:57 -03002548
Johan Hedberg7a828902011-04-28 11:28:53 -07002549 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2550 if (!conn)
2551 goto unlock;
2552
2553 loc_mitm = (conn->auth_type & 0x01);
2554 rem_mitm = (conn->remote_auth & 0x01);
2555
2556 /* If we require MITM but the remote device can't provide that
2557 * (it has NoInputNoOutput) then reject the confirmation
2558 * request. The only exception is when we're dedicated bonding
2559 * initiators (connect_cfm_cb set) since then we always have the MITM
2560 * bit set. */
2561 if (!conn->connect_cfm_cb && loc_mitm && conn->remote_cap == 0x03) {
2562 BT_DBG("Rejecting request: remote device can't provide MITM");
2563 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_NEG_REPLY,
2564 sizeof(ev->bdaddr), &ev->bdaddr);
2565 goto unlock;
2566 }
2567
2568 /* If no side requires MITM protection; auto-accept */
2569 if ((!loc_mitm || conn->remote_cap == 0x03) &&
2570 (!rem_mitm || conn->io_capability == 0x03)) {
Johan Hedberg55bc1a32011-04-28 11:28:56 -07002571
2572 /* If we're not the initiators request authorization to
2573 * proceed from user space (mgmt_user_confirm with
2574 * confirm_hint set to 1). */
2575 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
2576 BT_DBG("Confirming auto-accept as acceptor");
2577 confirm_hint = 1;
2578 goto confirm;
2579 }
2580
Johan Hedberg9f616562011-04-28 11:28:54 -07002581 BT_DBG("Auto-accept of user confirmation with %ums delay",
2582 hdev->auto_accept_delay);
2583
2584 if (hdev->auto_accept_delay > 0) {
2585 int delay = msecs_to_jiffies(hdev->auto_accept_delay);
2586 mod_timer(&conn->auto_accept_timer, jiffies + delay);
2587 goto unlock;
2588 }
2589
Johan Hedberg7a828902011-04-28 11:28:53 -07002590 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY,
2591 sizeof(ev->bdaddr), &ev->bdaddr);
2592 goto unlock;
2593 }
2594
Johan Hedberg55bc1a32011-04-28 11:28:56 -07002595confirm:
2596 mgmt_user_confirm_request(hdev->id, &ev->bdaddr, ev->passkey,
2597 confirm_hint);
Johan Hedberg7a828902011-04-28 11:28:53 -07002598
2599unlock:
Johan Hedberga5c29682011-02-19 12:05:57 -03002600 hci_dev_unlock(hdev);
2601}
2602
Marcel Holtmann04936842008-07-14 20:13:48 +02002603static inline void hci_simple_pair_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
2604{
2605 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
2606 struct hci_conn *conn;
2607
2608 BT_DBG("%s", hdev->name);
2609
2610 hci_dev_lock(hdev);
2611
2612 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Johan Hedberg2a611692011-02-19 12:06:00 -03002613 if (!conn)
2614 goto unlock;
Marcel Holtmann04936842008-07-14 20:13:48 +02002615
Johan Hedberg2a611692011-02-19 12:06:00 -03002616 /* To avoid duplicate auth_failed events to user space we check
2617 * the HCI_CONN_AUTH_PEND flag which will be set if we
2618 * initiated the authentication. A traditional auth_complete
2619 * event gets always produced as initiator and is also mapped to
2620 * the mgmt_auth_failed event */
2621 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->pend) && ev->status != 0)
2622 mgmt_auth_failed(hdev->id, &conn->dst, ev->status);
2623
2624 hci_conn_put(conn);
2625
2626unlock:
Marcel Holtmann04936842008-07-14 20:13:48 +02002627 hci_dev_unlock(hdev);
2628}
2629
Marcel Holtmann41a96212008-07-14 20:13:48 +02002630static inline void hci_remote_host_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
2631{
2632 struct hci_ev_remote_host_features *ev = (void *) skb->data;
2633 struct inquiry_entry *ie;
2634
2635 BT_DBG("%s", hdev->name);
2636
2637 hci_dev_lock(hdev);
2638
Andrei Emeltchenkocc11b9c2010-11-22 13:21:37 +02002639 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
2640 if (ie)
Marcel Holtmann41a96212008-07-14 20:13:48 +02002641 ie->data.ssp_mode = (ev->features[0] & 0x01);
2642
2643 hci_dev_unlock(hdev);
2644}
2645
Szymon Janc2763eda2011-03-22 13:12:22 +01002646static inline void hci_remote_oob_data_request_evt(struct hci_dev *hdev,
2647 struct sk_buff *skb)
2648{
2649 struct hci_ev_remote_oob_data_request *ev = (void *) skb->data;
2650 struct oob_data *data;
2651
2652 BT_DBG("%s", hdev->name);
2653
2654 hci_dev_lock(hdev);
2655
Szymon Jance1ba1f12011-04-06 13:01:59 +02002656 if (!test_bit(HCI_MGMT, &hdev->flags))
2657 goto unlock;
2658
Szymon Janc2763eda2011-03-22 13:12:22 +01002659 data = hci_find_remote_oob_data(hdev, &ev->bdaddr);
2660 if (data) {
2661 struct hci_cp_remote_oob_data_reply cp;
2662
2663 bacpy(&cp.bdaddr, &ev->bdaddr);
2664 memcpy(cp.hash, data->hash, sizeof(cp.hash));
2665 memcpy(cp.randomizer, data->randomizer, sizeof(cp.randomizer));
2666
2667 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_REPLY, sizeof(cp),
2668 &cp);
2669 } else {
2670 struct hci_cp_remote_oob_data_neg_reply cp;
2671
2672 bacpy(&cp.bdaddr, &ev->bdaddr);
2673 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_NEG_REPLY, sizeof(cp),
2674 &cp);
2675 }
2676
Szymon Jance1ba1f12011-04-06 13:01:59 +02002677unlock:
Szymon Janc2763eda2011-03-22 13:12:22 +01002678 hci_dev_unlock(hdev);
2679}
2680
Ville Tervofcd89c02011-02-10 22:38:47 -03002681static inline void hci_le_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
2682{
2683 struct hci_ev_le_conn_complete *ev = (void *) skb->data;
2684 struct hci_conn *conn;
2685
2686 BT_DBG("%s status %d", hdev->name, ev->status);
2687
2688 hci_dev_lock(hdev);
2689
2690 conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &ev->bdaddr);
Ville Tervob62f3282011-02-10 22:38:50 -03002691 if (!conn) {
2692 conn = hci_conn_add(hdev, LE_LINK, &ev->bdaddr);
2693 if (!conn) {
2694 BT_ERR("No memory for new connection");
2695 hci_dev_unlock(hdev);
2696 return;
2697 }
2698 }
Ville Tervofcd89c02011-02-10 22:38:47 -03002699
2700 if (ev->status) {
Vinicius Costa Gomes83bc71b2011-05-06 18:41:43 -03002701 mgmt_connect_failed(hdev->id, &ev->bdaddr, ev->status);
Ville Tervofcd89c02011-02-10 22:38:47 -03002702 hci_proto_connect_cfm(conn, ev->status);
2703 conn->state = BT_CLOSED;
2704 hci_conn_del(conn);
2705 goto unlock;
2706 }
2707
Vinicius Costa Gomes83bc71b2011-05-06 18:41:43 -03002708 mgmt_connected(hdev->id, &ev->bdaddr);
2709
Ville Tervofcd89c02011-02-10 22:38:47 -03002710 conn->handle = __le16_to_cpu(ev->handle);
2711 conn->state = BT_CONNECTED;
2712
2713 hci_conn_hold_device(conn);
2714 hci_conn_add_sysfs(conn);
2715
2716 hci_proto_connect_cfm(conn, ev->status);
2717
2718unlock:
2719 hci_dev_unlock(hdev);
2720}
2721
Andre Guedes9aa04c92011-05-26 16:23:51 -03002722static inline void hci_le_adv_report_evt(struct hci_dev *hdev,
2723 struct sk_buff *skb)
2724{
2725 struct hci_ev_le_advertising_info *ev;
2726 u8 num_reports;
2727
2728 num_reports = skb->data[0];
2729 ev = (void *) &skb->data[1];
2730
2731 hci_dev_lock(hdev);
2732
2733 hci_add_adv_entry(hdev, ev);
2734
2735 while (--num_reports) {
2736 ev = (void *) (ev->data + ev->length + 1);
2737 hci_add_adv_entry(hdev, ev);
2738 }
2739
2740 hci_dev_unlock(hdev);
2741}
2742
Ville Tervofcd89c02011-02-10 22:38:47 -03002743static inline void hci_le_meta_evt(struct hci_dev *hdev, struct sk_buff *skb)
2744{
2745 struct hci_ev_le_meta *le_ev = (void *) skb->data;
2746
2747 skb_pull(skb, sizeof(*le_ev));
2748
2749 switch (le_ev->subevent) {
2750 case HCI_EV_LE_CONN_COMPLETE:
2751 hci_le_conn_complete_evt(hdev, skb);
2752 break;
2753
Andre Guedes9aa04c92011-05-26 16:23:51 -03002754 case HCI_EV_LE_ADVERTISING_REPORT:
2755 hci_le_adv_report_evt(hdev, skb);
2756 break;
2757
Ville Tervofcd89c02011-02-10 22:38:47 -03002758 default:
2759 break;
2760 }
2761}
2762
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
2764{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002765 struct hci_event_hdr *hdr = (void *) skb->data;
2766 __u8 event = hdr->evt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767
2768 skb_pull(skb, HCI_EVENT_HDR_SIZE);
2769
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002770 switch (event) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771 case HCI_EV_INQUIRY_COMPLETE:
2772 hci_inquiry_complete_evt(hdev, skb);
2773 break;
2774
2775 case HCI_EV_INQUIRY_RESULT:
2776 hci_inquiry_result_evt(hdev, skb);
2777 break;
2778
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002779 case HCI_EV_CONN_COMPLETE:
2780 hci_conn_complete_evt(hdev, skb);
Marcel Holtmann21d9e302005-09-13 01:32:25 +02002781 break;
2782
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783 case HCI_EV_CONN_REQUEST:
2784 hci_conn_request_evt(hdev, skb);
2785 break;
2786
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787 case HCI_EV_DISCONN_COMPLETE:
2788 hci_disconn_complete_evt(hdev, skb);
2789 break;
2790
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791 case HCI_EV_AUTH_COMPLETE:
2792 hci_auth_complete_evt(hdev, skb);
2793 break;
2794
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002795 case HCI_EV_REMOTE_NAME:
2796 hci_remote_name_evt(hdev, skb);
2797 break;
2798
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799 case HCI_EV_ENCRYPT_CHANGE:
2800 hci_encrypt_change_evt(hdev, skb);
2801 break;
2802
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002803 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
2804 hci_change_link_key_complete_evt(hdev, skb);
2805 break;
2806
2807 case HCI_EV_REMOTE_FEATURES:
2808 hci_remote_features_evt(hdev, skb);
2809 break;
2810
2811 case HCI_EV_REMOTE_VERSION:
2812 hci_remote_version_evt(hdev, skb);
2813 break;
2814
2815 case HCI_EV_QOS_SETUP_COMPLETE:
2816 hci_qos_setup_complete_evt(hdev, skb);
2817 break;
2818
2819 case HCI_EV_CMD_COMPLETE:
2820 hci_cmd_complete_evt(hdev, skb);
2821 break;
2822
2823 case HCI_EV_CMD_STATUS:
2824 hci_cmd_status_evt(hdev, skb);
2825 break;
2826
2827 case HCI_EV_ROLE_CHANGE:
2828 hci_role_change_evt(hdev, skb);
2829 break;
2830
2831 case HCI_EV_NUM_COMP_PKTS:
2832 hci_num_comp_pkts_evt(hdev, skb);
2833 break;
2834
2835 case HCI_EV_MODE_CHANGE:
2836 hci_mode_change_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837 break;
2838
2839 case HCI_EV_PIN_CODE_REQ:
2840 hci_pin_code_request_evt(hdev, skb);
2841 break;
2842
2843 case HCI_EV_LINK_KEY_REQ:
2844 hci_link_key_request_evt(hdev, skb);
2845 break;
2846
2847 case HCI_EV_LINK_KEY_NOTIFY:
2848 hci_link_key_notify_evt(hdev, skb);
2849 break;
2850
2851 case HCI_EV_CLOCK_OFFSET:
2852 hci_clock_offset_evt(hdev, skb);
2853 break;
2854
Marcel Holtmanna8746412008-07-14 20:13:46 +02002855 case HCI_EV_PKT_TYPE_CHANGE:
2856 hci_pkt_type_change_evt(hdev, skb);
2857 break;
2858
Marcel Holtmann85a1e932005-08-09 20:28:02 -07002859 case HCI_EV_PSCAN_REP_MODE:
2860 hci_pscan_rep_mode_evt(hdev, skb);
2861 break;
2862
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002863 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
2864 hci_inquiry_result_with_rssi_evt(hdev, skb);
2865 break;
2866
2867 case HCI_EV_REMOTE_EXT_FEATURES:
2868 hci_remote_ext_features_evt(hdev, skb);
2869 break;
2870
2871 case HCI_EV_SYNC_CONN_COMPLETE:
2872 hci_sync_conn_complete_evt(hdev, skb);
2873 break;
2874
2875 case HCI_EV_SYNC_CONN_CHANGED:
2876 hci_sync_conn_changed_evt(hdev, skb);
2877 break;
2878
Marcel Holtmann04837f62006-07-03 10:02:33 +02002879 case HCI_EV_SNIFF_SUBRATE:
2880 hci_sniff_subrate_evt(hdev, skb);
2881 break;
2882
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002883 case HCI_EV_EXTENDED_INQUIRY_RESULT:
2884 hci_extended_inquiry_result_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885 break;
2886
Marcel Holtmann04936842008-07-14 20:13:48 +02002887 case HCI_EV_IO_CAPA_REQUEST:
2888 hci_io_capa_request_evt(hdev, skb);
2889 break;
2890
Johan Hedberg03b555e2011-01-04 15:40:05 +02002891 case HCI_EV_IO_CAPA_REPLY:
2892 hci_io_capa_reply_evt(hdev, skb);
2893 break;
2894
Johan Hedberga5c29682011-02-19 12:05:57 -03002895 case HCI_EV_USER_CONFIRM_REQUEST:
2896 hci_user_confirm_request_evt(hdev, skb);
2897 break;
2898
Marcel Holtmann04936842008-07-14 20:13:48 +02002899 case HCI_EV_SIMPLE_PAIR_COMPLETE:
2900 hci_simple_pair_complete_evt(hdev, skb);
2901 break;
2902
Marcel Holtmann41a96212008-07-14 20:13:48 +02002903 case HCI_EV_REMOTE_HOST_FEATURES:
2904 hci_remote_host_features_evt(hdev, skb);
2905 break;
2906
Ville Tervofcd89c02011-02-10 22:38:47 -03002907 case HCI_EV_LE_META:
2908 hci_le_meta_evt(hdev, skb);
2909 break;
2910
Szymon Janc2763eda2011-03-22 13:12:22 +01002911 case HCI_EV_REMOTE_OOB_DATA_REQUEST:
2912 hci_remote_oob_data_request_evt(hdev, skb);
2913 break;
2914
Marcel Holtmanna9de9242007-10-20 13:33:56 +02002915 default:
2916 BT_DBG("%s event 0x%x", hdev->name, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917 break;
2918 }
2919
2920 kfree_skb(skb);
2921 hdev->stat.evt_rx++;
2922}
2923
2924/* Generate internal stack event */
2925void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
2926{
2927 struct hci_event_hdr *hdr;
2928 struct hci_ev_stack_internal *ev;
2929 struct sk_buff *skb;
2930
2931 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
2932 if (!skb)
2933 return;
2934
2935 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
2936 hdr->evt = HCI_EV_STACK_INTERNAL;
2937 hdr->plen = sizeof(*ev) + dlen;
2938
2939 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
2940 ev->type = type;
2941 memcpy(ev->data, data, dlen);
2942
Marcel Holtmann576c7d82005-08-06 12:36:54 +02002943 bt_cb(skb)->incoming = 1;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07002944 __net_timestamp(skb);
Marcel Holtmann576c7d82005-08-06 12:36:54 +02002945
Marcel Holtmann0d48d932005-08-09 20:30:28 -07002946 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 skb->dev = (void *) hdev;
Johan Hedbergeec8d2b2010-12-16 10:17:38 +02002948 hci_send_to_sock(hdev, skb, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 kfree_skb(skb);
2950}