blob: f91ba690f5d29cfc932deb3cf0ae810ce6993ae5 [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
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
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>
42#include <asm/uaccess.h>
43#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
Marcel Holtmanna9de9242007-10-20 13:33:56 +020059 clear_bit(HCI_INQUIRY, &hdev->flags);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010060
Marcel Holtmanna9de9242007-10-20 13:33:56 +020061 hci_req_complete(hdev, status);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010062
Marcel Holtmanna9de9242007-10-20 13:33:56 +020063 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064}
65
Marcel Holtmanna9de9242007-10-20 13:33:56 +020066static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070067{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020068 __u8 status = *((__u8 *) skb->data);
69
70 BT_DBG("%s status 0x%x", hdev->name, status);
71
72 if (status)
73 return;
74
75 clear_bit(HCI_INQUIRY, &hdev->flags);
76
77 hci_conn_check_pending(hdev);
78}
79
80static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev, struct sk_buff *skb)
81{
82 BT_DBG("%s", hdev->name);
83}
84
85static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb)
86{
87 struct hci_rp_role_discovery *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Marcel Holtmanna9de9242007-10-20 13:33:56 +020090 BT_DBG("%s status 0x%x", hdev->name, rp->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Marcel Holtmanna9de9242007-10-20 13:33:56 +020092 if (rp->status)
93 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Marcel Holtmanna9de9242007-10-20 13:33:56 +020095 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Marcel Holtmanna9de9242007-10-20 13:33:56 +020097 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
98 if (conn) {
99 if (rp->role)
100 conn->link_mode &= ~HCI_LM_MASTER;
101 else
102 conn->link_mode |= HCI_LM_MASTER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200104
105 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106}
107
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200108static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
109{
110 struct hci_rp_read_link_policy *rp = (void *) skb->data;
111 struct hci_conn *conn;
112
113 BT_DBG("%s status 0x%x", hdev->name, rp->status);
114
115 if (rp->status)
116 return;
117
118 hci_dev_lock(hdev);
119
120 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
121 if (conn)
122 conn->link_policy = __le16_to_cpu(rp->policy);
123
124 hci_dev_unlock(hdev);
125}
126
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200127static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200129 struct hci_rp_write_link_policy *rp = (void *) skb->data;
130 struct hci_conn *conn;
131 void *sent;
132
133 BT_DBG("%s status 0x%x", hdev->name, rp->status);
134
135 if (rp->status)
136 return;
137
138 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
139 if (!sent)
140 return;
141
142 hci_dev_lock(hdev);
143
144 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200145 if (conn)
Harvey Harrison83985312008-05-02 16:25:46 -0700146 conn->link_policy = get_unaligned_le16(sent + 2);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200147
148 hci_dev_unlock(hdev);
149}
150
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200151static void hci_cc_read_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
152{
153 struct hci_rp_read_def_link_policy *rp = (void *) skb->data;
154
155 BT_DBG("%s status 0x%x", hdev->name, rp->status);
156
157 if (rp->status)
158 return;
159
160 hdev->link_policy = __le16_to_cpu(rp->policy);
161}
162
163static void hci_cc_write_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
164{
165 __u8 status = *((__u8 *) skb->data);
166 void *sent;
167
168 BT_DBG("%s status 0x%x", hdev->name, status);
169
170 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
171 if (!sent)
172 return;
173
174 if (!status)
175 hdev->link_policy = get_unaligned_le16(sent);
176
177 hci_req_complete(hdev, status);
178}
179
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200180static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
181{
182 __u8 status = *((__u8 *) skb->data);
183
184 BT_DBG("%s status 0x%x", hdev->name, status);
185
186 hci_req_complete(hdev, status);
187}
188
189static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
190{
191 __u8 status = *((__u8 *) skb->data);
192 void *sent;
193
194 BT_DBG("%s status 0x%x", hdev->name, status);
195
Marcel Holtmannf383f272008-07-14 20:13:47 +0200196 if (status)
197 return;
198
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200199 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
200 if (!sent)
201 return;
202
Marcel Holtmannf383f272008-07-14 20:13:47 +0200203 memcpy(hdev->dev_name, sent, 248);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200204}
205
206static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
207{
208 struct hci_rp_read_local_name *rp = (void *) skb->data;
209
210 BT_DBG("%s status 0x%x", hdev->name, rp->status);
211
212 if (rp->status)
213 return;
214
215 memcpy(hdev->dev_name, rp->name, 248);
216}
217
218static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
219{
220 __u8 status = *((__u8 *) skb->data);
221 void *sent;
222
223 BT_DBG("%s status 0x%x", hdev->name, status);
224
225 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
226 if (!sent)
227 return;
228
229 if (!status) {
230 __u8 param = *((__u8 *) sent);
231
232 if (param == AUTH_ENABLED)
233 set_bit(HCI_AUTH, &hdev->flags);
234 else
235 clear_bit(HCI_AUTH, &hdev->flags);
236 }
237
238 hci_req_complete(hdev, status);
239}
240
241static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
242{
243 __u8 status = *((__u8 *) skb->data);
244 void *sent;
245
246 BT_DBG("%s status 0x%x", hdev->name, status);
247
248 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
249 if (!sent)
250 return;
251
252 if (!status) {
253 __u8 param = *((__u8 *) sent);
254
255 if (param)
256 set_bit(HCI_ENCRYPT, &hdev->flags);
257 else
258 clear_bit(HCI_ENCRYPT, &hdev->flags);
259 }
260
261 hci_req_complete(hdev, status);
262}
263
264static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
265{
266 __u8 status = *((__u8 *) skb->data);
267 void *sent;
268
269 BT_DBG("%s status 0x%x", hdev->name, status);
270
271 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
272 if (!sent)
273 return;
274
275 if (!status) {
276 __u8 param = *((__u8 *) sent);
277
278 clear_bit(HCI_PSCAN, &hdev->flags);
279 clear_bit(HCI_ISCAN, &hdev->flags);
280
281 if (param & SCAN_INQUIRY)
282 set_bit(HCI_ISCAN, &hdev->flags);
283
284 if (param & SCAN_PAGE)
285 set_bit(HCI_PSCAN, &hdev->flags);
286 }
287
288 hci_req_complete(hdev, status);
289}
290
291static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
292{
293 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
294
295 BT_DBG("%s status 0x%x", hdev->name, rp->status);
296
297 if (rp->status)
298 return;
299
300 memcpy(hdev->dev_class, rp->dev_class, 3);
301
302 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
303 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
304}
305
306static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
307{
308 __u8 status = *((__u8 *) skb->data);
309 void *sent;
310
311 BT_DBG("%s status 0x%x", hdev->name, status);
312
Marcel Holtmannf383f272008-07-14 20:13:47 +0200313 if (status)
314 return;
315
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200316 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
317 if (!sent)
318 return;
319
Marcel Holtmannf383f272008-07-14 20:13:47 +0200320 memcpy(hdev->dev_class, sent, 3);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200321}
322
323static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
324{
325 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 __u16 setting;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200327
328 BT_DBG("%s status 0x%x", hdev->name, rp->status);
329
330 if (rp->status)
331 return;
332
333 setting = __le16_to_cpu(rp->voice_setting);
334
Marcel Holtmannf383f272008-07-14 20:13:47 +0200335 if (hdev->voice_setting == setting)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200336 return;
337
338 hdev->voice_setting = setting;
339
340 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
341
342 if (hdev->notify) {
343 tasklet_disable(&hdev->tx_task);
344 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
345 tasklet_enable(&hdev->tx_task);
346 }
347}
348
349static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
350{
351 __u8 status = *((__u8 *) skb->data);
Marcel Holtmannf383f272008-07-14 20:13:47 +0200352 __u16 setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 void *sent;
354
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200355 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
Marcel Holtmannf383f272008-07-14 20:13:47 +0200357 if (status)
358 return;
359
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200360 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
361 if (!sent)
362 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
Marcel Holtmannf383f272008-07-14 20:13:47 +0200364 setting = get_unaligned_le16(sent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Marcel Holtmannf383f272008-07-14 20:13:47 +0200366 if (hdev->voice_setting == setting)
367 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
Marcel Holtmannf383f272008-07-14 20:13:47 +0200369 hdev->voice_setting = setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
Marcel Holtmannf383f272008-07-14 20:13:47 +0200371 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
372
373 if (hdev->notify) {
374 tasklet_disable(&hdev->tx_task);
375 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
376 tasklet_enable(&hdev->tx_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 }
378}
379
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200380static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200382 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200384 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200386 hci_req_complete(hdev, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387}
388
Marcel Holtmann333140b2008-07-14 20:13:48 +0200389static void hci_cc_read_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
390{
391 struct hci_rp_read_ssp_mode *rp = (void *) skb->data;
392
393 BT_DBG("%s status 0x%x", hdev->name, rp->status);
394
395 if (rp->status)
396 return;
397
398 hdev->ssp_mode = rp->mode;
399}
400
401static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
402{
403 __u8 status = *((__u8 *) skb->data);
404 void *sent;
405
406 BT_DBG("%s status 0x%x", hdev->name, status);
407
408 if (status)
409 return;
410
411 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
412 if (!sent)
413 return;
414
415 hdev->ssp_mode = *((__u8 *) sent);
416}
417
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200418static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
419{
420 struct hci_rp_read_local_version *rp = (void *) skb->data;
421
422 BT_DBG("%s status 0x%x", hdev->name, rp->status);
423
424 if (rp->status)
425 return;
426
427 hdev->hci_ver = rp->hci_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200428 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
429 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200430
431 BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
432 hdev->manufacturer,
433 hdev->hci_ver, hdev->hci_rev);
434}
435
436static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb)
437{
438 struct hci_rp_read_local_commands *rp = (void *) skb->data;
439
440 BT_DBG("%s status 0x%x", hdev->name, rp->status);
441
442 if (rp->status)
443 return;
444
445 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
446}
447
448static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb)
449{
450 struct hci_rp_read_local_features *rp = (void *) skb->data;
451
452 BT_DBG("%s status 0x%x", hdev->name, rp->status);
453
454 if (rp->status)
455 return;
456
457 memcpy(hdev->features, rp->features, 8);
458
459 /* Adjust default settings according to features
460 * supported by device. */
461
462 if (hdev->features[0] & LMP_3SLOT)
463 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
464
465 if (hdev->features[0] & LMP_5SLOT)
466 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
467
468 if (hdev->features[1] & LMP_HV2) {
469 hdev->pkt_type |= (HCI_HV2);
470 hdev->esco_type |= (ESCO_HV2);
471 }
472
473 if (hdev->features[1] & LMP_HV3) {
474 hdev->pkt_type |= (HCI_HV3);
475 hdev->esco_type |= (ESCO_HV3);
476 }
477
478 if (hdev->features[3] & LMP_ESCO)
479 hdev->esco_type |= (ESCO_EV3);
480
481 if (hdev->features[4] & LMP_EV4)
482 hdev->esco_type |= (ESCO_EV4);
483
484 if (hdev->features[4] & LMP_EV5)
485 hdev->esco_type |= (ESCO_EV5);
486
487 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
488 hdev->features[0], hdev->features[1],
489 hdev->features[2], hdev->features[3],
490 hdev->features[4], hdev->features[5],
491 hdev->features[6], hdev->features[7]);
492}
493
494static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
495{
496 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
497
498 BT_DBG("%s status 0x%x", hdev->name, rp->status);
499
500 if (rp->status)
501 return;
502
503 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
504 hdev->sco_mtu = rp->sco_mtu;
505 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
506 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
507
508 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
509 hdev->sco_mtu = 64;
510 hdev->sco_pkts = 8;
511 }
512
513 hdev->acl_cnt = hdev->acl_pkts;
514 hdev->sco_cnt = hdev->sco_pkts;
515
516 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
517 hdev->acl_mtu, hdev->acl_pkts,
518 hdev->sco_mtu, hdev->sco_pkts);
519}
520
521static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
522{
523 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
524
525 BT_DBG("%s status 0x%x", hdev->name, rp->status);
526
527 if (!rp->status)
528 bacpy(&hdev->bdaddr, &rp->bdaddr);
529
530 hci_req_complete(hdev, rp->status);
531}
532
533static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
534{
535 BT_DBG("%s status 0x%x", hdev->name, status);
536
537 if (status) {
538 hci_req_complete(hdev, status);
539
540 hci_conn_check_pending(hdev);
541 } else
542 set_bit(HCI_INQUIRY, &hdev->flags);
543}
544
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
546{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200547 struct hci_cp_create_conn *cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200550 BT_DBG("%s status 0x%x", hdev->name, status);
551
552 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 if (!cp)
554 return;
555
556 hci_dev_lock(hdev);
557
558 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
559
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200560 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
562 if (status) {
563 if (conn && conn->state == BT_CONNECT) {
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200564 if (status != 0x0c || conn->attempt > 2) {
565 conn->state = BT_CLOSED;
566 hci_proto_connect_cfm(conn, status);
567 hci_conn_del(conn);
568 } else
569 conn->state = BT_CONNECT2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 }
571 } else {
572 if (!conn) {
573 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
574 if (conn) {
575 conn->out = 1;
576 conn->link_mode |= HCI_LM_MASTER;
577 } else
578 BT_ERR("No memmory for new connection");
579 }
580 }
581
582 hci_dev_unlock(hdev);
583}
584
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200585static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200587 struct hci_cp_add_sco *cp;
588 struct hci_conn *acl, *sco;
589 __u16 handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200591 BT_DBG("%s status 0x%x", hdev->name, status);
592
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200593 if (!status)
594 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200596 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
597 if (!cp)
598 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200600 handle = __le16_to_cpu(cp->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200602 BT_DBG("%s handle %d", hdev->name, handle);
Marcel Holtmann6bd57412006-11-18 22:14:22 +0100603
604 hci_dev_lock(hdev);
605
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200606 acl = hci_conn_hash_lookup_handle(hdev, handle);
607 if (acl && (sco = acl->link)) {
608 sco->state = BT_CLOSED;
609
610 hci_proto_connect_cfm(sco, status);
611 hci_conn_del(sco);
612 }
Marcel Holtmann6bd57412006-11-18 22:14:22 +0100613
614 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615}
616
Marcel Holtmannf8558552008-07-14 20:13:49 +0200617static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
618{
619 struct hci_cp_auth_requested *cp;
620 struct hci_conn *conn;
621
622 BT_DBG("%s status 0x%x", hdev->name, status);
623
624 if (!status)
625 return;
626
627 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
628 if (!cp)
629 return;
630
631 hci_dev_lock(hdev);
632
633 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
634 if (conn) {
635 if (conn->state == BT_CONFIG) {
636 hci_proto_connect_cfm(conn, status);
637 hci_conn_put(conn);
638 }
639 }
640
641 hci_dev_unlock(hdev);
642}
643
644static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
645{
646 struct hci_cp_set_conn_encrypt *cp;
647 struct hci_conn *conn;
648
649 BT_DBG("%s status 0x%x", hdev->name, status);
650
651 if (!status)
652 return;
653
654 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
655 if (!cp)
656 return;
657
658 hci_dev_lock(hdev);
659
660 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
661 if (conn) {
662 if (conn->state == BT_CONFIG) {
663 hci_proto_connect_cfm(conn, status);
664 hci_conn_put(conn);
665 }
666 }
667
668 hci_dev_unlock(hdev);
669}
670
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200671static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
672{
673 BT_DBG("%s status 0x%x", hdev->name, status);
674}
675
Marcel Holtmann769be972008-07-14 20:13:49 +0200676static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
677{
678 struct hci_cp_read_remote_features *cp;
679 struct hci_conn *conn;
680
681 BT_DBG("%s status 0x%x", hdev->name, status);
682
683 if (!status)
684 return;
685
686 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
687 if (!cp)
688 return;
689
690 hci_dev_lock(hdev);
691
692 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
693 if (conn) {
694 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +0200695 hci_proto_connect_cfm(conn, status);
696 hci_conn_put(conn);
697 }
698 }
699
700 hci_dev_unlock(hdev);
701}
702
703static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
704{
705 struct hci_cp_read_remote_ext_features *cp;
706 struct hci_conn *conn;
707
708 BT_DBG("%s status 0x%x", hdev->name, status);
709
710 if (!status)
711 return;
712
713 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
714 if (!cp)
715 return;
716
717 hci_dev_lock(hdev);
718
719 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
720 if (conn) {
721 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +0200722 hci_proto_connect_cfm(conn, status);
723 hci_conn_put(conn);
724 }
725 }
726
727 hci_dev_unlock(hdev);
728}
729
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200730static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
731{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200732 struct hci_cp_setup_sync_conn *cp;
733 struct hci_conn *acl, *sco;
734 __u16 handle;
735
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200736 BT_DBG("%s status 0x%x", hdev->name, status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200737
738 if (!status)
739 return;
740
741 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
742 if (!cp)
743 return;
744
745 handle = __le16_to_cpu(cp->handle);
746
747 BT_DBG("%s handle %d", hdev->name, handle);
748
749 hci_dev_lock(hdev);
750
751 acl = hci_conn_hash_lookup_handle(hdev, handle);
752 if (acl && (sco = acl->link)) {
753 sco->state = BT_CLOSED;
754
755 hci_proto_connect_cfm(sco, status);
756 hci_conn_del(sco);
757 }
758
759 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200760}
761
762static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
763{
764 struct hci_cp_sniff_mode *cp;
765 struct hci_conn *conn;
766
767 BT_DBG("%s status 0x%x", hdev->name, status);
768
769 if (!status)
770 return;
771
772 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
773 if (!cp)
774 return;
775
776 hci_dev_lock(hdev);
777
778 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
779 if (conn)
780 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
781
782 hci_dev_unlock(hdev);
783}
784
785static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
786{
787 struct hci_cp_exit_sniff_mode *cp;
788 struct hci_conn *conn;
789
790 BT_DBG("%s status 0x%x", hdev->name, status);
791
792 if (!status)
793 return;
794
795 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
796 if (!cp)
797 return;
798
799 hci_dev_lock(hdev);
800
801 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
802 if (conn)
803 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
804
805 hci_dev_unlock(hdev);
806}
807
808static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
809{
810 __u8 status = *((__u8 *) skb->data);
811
812 BT_DBG("%s status %d", hdev->name, status);
813
814 clear_bit(HCI_INQUIRY, &hdev->flags);
815
816 hci_req_complete(hdev, status);
817
818 hci_conn_check_pending(hdev);
819}
820
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
822{
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700823 struct inquiry_data data;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200824 struct inquiry_info *info = (void *) (skb->data + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 int num_rsp = *((__u8 *) skb->data);
826
827 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
828
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700829 if (!num_rsp)
830 return;
831
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700833
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 for (; num_rsp; num_rsp--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 bacpy(&data.bdaddr, &info->bdaddr);
836 data.pscan_rep_mode = info->pscan_rep_mode;
837 data.pscan_period_mode = info->pscan_period_mode;
838 data.pscan_mode = info->pscan_mode;
839 memcpy(data.dev_class, info->dev_class, 3);
840 data.clock_offset = info->clock_offset;
841 data.rssi = 0x00;
Marcel Holtmann41a96212008-07-14 20:13:48 +0200842 data.ssp_mode = 0x00;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 info++;
844 hci_inquiry_cache_update(hdev, &data);
845 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700846
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 hci_dev_unlock(hdev);
848}
849
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200850static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200852 struct hci_ev_conn_complete *ev = (void *) skb->data;
853 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200855 BT_DBG("%s", hdev->name);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700856
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700858
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200859 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
860 if (!conn)
861 goto unlock;
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700862
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200863 if (!ev->status) {
864 conn->handle = __le16_to_cpu(ev->handle);
Marcel Holtmann769be972008-07-14 20:13:49 +0200865
866 if (conn->type == ACL_LINK) {
867 conn->state = BT_CONFIG;
868 hci_conn_hold(conn);
869 } else
870 conn->state = BT_CONNECTED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200871
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200872 hci_conn_add_sysfs(conn);
873
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200874 if (test_bit(HCI_AUTH, &hdev->flags))
875 conn->link_mode |= HCI_LM_AUTH;
876
877 if (test_bit(HCI_ENCRYPT, &hdev->flags))
878 conn->link_mode |= HCI_LM_ENCRYPT;
879
880 /* Get remote features */
881 if (conn->type == ACL_LINK) {
882 struct hci_cp_read_remote_features cp;
883 cp.handle = ev->handle;
Marcel Holtmann769be972008-07-14 20:13:49 +0200884 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
885 sizeof(cp), &cp);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700886 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700887
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200888 /* Set packet type for incoming connection */
Marcel Holtmanna8746412008-07-14 20:13:46 +0200889 if (!conn->out && hdev->hci_ver < 3) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200890 struct hci_cp_change_conn_ptype cp;
891 cp.handle = ev->handle;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200892 cp.pkt_type = cpu_to_le16(conn->pkt_type);
893 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
894 sizeof(cp), &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200895 }
896 } else
897 conn->state = BT_CLOSED;
898
899 if (conn->type == ACL_LINK) {
900 struct hci_conn *sco = conn->link;
901 if (sco) {
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200902 if (!ev->status) {
903 if (lmp_esco_capable(hdev))
904 hci_setup_sync(sco, conn->handle);
905 else
906 hci_add_sco(sco, conn->handle);
907 } else {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200908 hci_proto_connect_cfm(sco, ev->status);
909 hci_conn_del(sco);
910 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700911 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700913
Marcel Holtmann769be972008-07-14 20:13:49 +0200914 if (ev->status) {
915 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200916 hci_conn_del(conn);
Marcel Holtmann769be972008-07-14 20:13:49 +0200917 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200918
919unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200921
922 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923}
924
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
926{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200927 struct hci_ev_conn_request *ev = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 int mask = hdev->link_mode;
929
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200930 BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
931 batostr(&ev->bdaddr), ev->link_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932
933 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
934
935 if (mask & HCI_LM_ACCEPT) {
936 /* Connection accepted */
Marcel Holtmannc7bdd502008-07-14 20:13:47 +0200937 struct inquiry_entry *ie;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939
940 hci_dev_lock(hdev);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200941
Marcel Holtmannc7bdd502008-07-14 20:13:47 +0200942 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))
943 memcpy(ie->data.dev_class, ev->dev_class, 3);
944
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
946 if (!conn) {
947 if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
948 BT_ERR("No memmory for new connection");
949 hci_dev_unlock(hdev);
950 return;
951 }
952 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200953
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 memcpy(conn->dev_class, ev->dev_class, 3);
955 conn->state = BT_CONNECT;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200956
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 hci_dev_unlock(hdev);
958
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200959 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
960 struct hci_cp_accept_conn_req cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200962 bacpy(&cp.bdaddr, &ev->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200964 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
965 cp.role = 0x00; /* Become master */
966 else
967 cp.role = 0x01; /* Remain slave */
968
969 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
970 sizeof(cp), &cp);
971 } else {
972 struct hci_cp_accept_sync_conn_req cp;
973
974 bacpy(&cp.bdaddr, &ev->bdaddr);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200975 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200976
977 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
978 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
979 cp.max_latency = cpu_to_le16(0xffff);
980 cp.content_format = cpu_to_le16(hdev->voice_setting);
981 cp.retrans_effort = 0xff;
982
983 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
984 sizeof(cp), &cp);
985 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 } else {
987 /* Connection rejected */
988 struct hci_cp_reject_conn_req cp;
989
990 bacpy(&cp.bdaddr, &ev->bdaddr);
991 cp.reason = 0x0f;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200992 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 }
994}
995
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
997{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200998 struct hci_ev_disconn_complete *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +0200999 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
1001 BT_DBG("%s status %d", hdev->name, ev->status);
1002
1003 if (ev->status)
1004 return;
1005
1006 hci_dev_lock(hdev);
1007
Marcel Holtmann04837f62006-07-03 10:02:33 +02001008 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 if (conn) {
1010 conn->state = BT_CLOSED;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001011
1012 hci_conn_del_sysfs(conn);
1013
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 hci_proto_disconn_ind(conn, ev->reason);
1015 hci_conn_del(conn);
1016 }
1017
1018 hci_dev_unlock(hdev);
1019}
1020
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001021static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1022{
1023 struct hci_ev_auth_complete *ev = (void *) skb->data;
1024 struct hci_conn *conn;
1025
1026 BT_DBG("%s status %d", hdev->name, ev->status);
1027
1028 hci_dev_lock(hdev);
1029
1030 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1031 if (conn) {
1032 if (!ev->status)
1033 conn->link_mode |= HCI_LM_AUTH;
1034
1035 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1036
Marcel Holtmannf8558552008-07-14 20:13:49 +02001037 if (conn->state == BT_CONFIG) {
1038 if (!ev->status && hdev->ssp_mode > 0 &&
1039 conn->ssp_mode > 0) {
1040 struct hci_cp_set_conn_encrypt cp;
1041 cp.handle = ev->handle;
1042 cp.encrypt = 0x01;
1043 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1044 sizeof(cp), &cp);
1045 } else {
1046 conn->state = BT_CONNECTED;
1047 hci_proto_connect_cfm(conn, ev->status);
1048 hci_conn_put(conn);
1049 }
1050 } else
1051 hci_auth_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001052
1053 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
1054 if (!ev->status) {
1055 struct hci_cp_set_conn_encrypt cp;
Marcel Holtmannf8558552008-07-14 20:13:49 +02001056 cp.handle = ev->handle;
1057 cp.encrypt = 0x01;
1058 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1059 sizeof(cp), &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001060 } else {
1061 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1062 hci_encrypt_cfm(conn, ev->status, 0x00);
1063 }
1064 }
1065 }
1066
1067 hci_dev_unlock(hdev);
1068}
1069
1070static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
1071{
1072 BT_DBG("%s", hdev->name);
1073
1074 hci_conn_check_pending(hdev);
1075}
1076
1077static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1078{
1079 struct hci_ev_encrypt_change *ev = (void *) skb->data;
1080 struct hci_conn *conn;
1081
1082 BT_DBG("%s status %d", hdev->name, ev->status);
1083
1084 hci_dev_lock(hdev);
1085
1086 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1087 if (conn) {
1088 if (!ev->status) {
Marcel Holtmannae293192008-07-14 20:13:45 +02001089 if (ev->encrypt) {
1090 /* Encryption implies authentication */
1091 conn->link_mode |= HCI_LM_AUTH;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001092 conn->link_mode |= HCI_LM_ENCRYPT;
Marcel Holtmannae293192008-07-14 20:13:45 +02001093 } else
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001094 conn->link_mode &= ~HCI_LM_ENCRYPT;
1095 }
1096
1097 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1098
Marcel Holtmannf8558552008-07-14 20:13:49 +02001099 if (conn->state == BT_CONFIG) {
1100 if (!ev->status)
1101 conn->state = BT_CONNECTED;
1102
1103 hci_proto_connect_cfm(conn, ev->status);
1104 hci_conn_put(conn);
1105 } else
1106 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001107 }
1108
1109 hci_dev_unlock(hdev);
1110}
1111
1112static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1113{
1114 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
1115 struct hci_conn *conn;
1116
1117 BT_DBG("%s status %d", hdev->name, ev->status);
1118
1119 hci_dev_lock(hdev);
1120
1121 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1122 if (conn) {
1123 if (!ev->status)
1124 conn->link_mode |= HCI_LM_SECURE;
1125
1126 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1127
1128 hci_key_change_cfm(conn, ev->status);
1129 }
1130
1131 hci_dev_unlock(hdev);
1132}
1133
1134static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1135{
1136 struct hci_ev_remote_features *ev = (void *) skb->data;
1137 struct hci_conn *conn;
1138
1139 BT_DBG("%s status %d", hdev->name, ev->status);
1140
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001141 hci_dev_lock(hdev);
1142
1143 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Marcel Holtmann769be972008-07-14 20:13:49 +02001144 if (conn) {
1145 if (!ev->status)
1146 memcpy(conn->features, ev->features, 8);
1147
1148 if (conn->state == BT_CONFIG) {
1149 if (!ev->status && lmp_ssp_capable(hdev) &&
1150 lmp_ssp_capable(conn)) {
1151 struct hci_cp_read_remote_ext_features cp;
1152 cp.handle = ev->handle;
1153 cp.page = 0x01;
1154 hci_send_cmd(hdev,
1155 HCI_OP_READ_REMOTE_EXT_FEATURES,
1156 sizeof(cp), &cp);
1157 } else {
1158 conn->state = BT_CONNECTED;
1159 hci_proto_connect_cfm(conn, ev->status);
1160 hci_conn_put(conn);
1161 }
1162 }
1163 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001164
1165 hci_dev_unlock(hdev);
1166}
1167
1168static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
1169{
1170 BT_DBG("%s", hdev->name);
1171}
1172
1173static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1174{
1175 BT_DBG("%s", hdev->name);
1176}
1177
1178static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1179{
1180 struct hci_ev_cmd_complete *ev = (void *) skb->data;
1181 __u16 opcode;
1182
1183 skb_pull(skb, sizeof(*ev));
1184
1185 opcode = __le16_to_cpu(ev->opcode);
1186
1187 switch (opcode) {
1188 case HCI_OP_INQUIRY_CANCEL:
1189 hci_cc_inquiry_cancel(hdev, skb);
1190 break;
1191
1192 case HCI_OP_EXIT_PERIODIC_INQ:
1193 hci_cc_exit_periodic_inq(hdev, skb);
1194 break;
1195
1196 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
1197 hci_cc_remote_name_req_cancel(hdev, skb);
1198 break;
1199
1200 case HCI_OP_ROLE_DISCOVERY:
1201 hci_cc_role_discovery(hdev, skb);
1202 break;
1203
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001204 case HCI_OP_READ_LINK_POLICY:
1205 hci_cc_read_link_policy(hdev, skb);
1206 break;
1207
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001208 case HCI_OP_WRITE_LINK_POLICY:
1209 hci_cc_write_link_policy(hdev, skb);
1210 break;
1211
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001212 case HCI_OP_READ_DEF_LINK_POLICY:
1213 hci_cc_read_def_link_policy(hdev, skb);
1214 break;
1215
1216 case HCI_OP_WRITE_DEF_LINK_POLICY:
1217 hci_cc_write_def_link_policy(hdev, skb);
1218 break;
1219
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001220 case HCI_OP_RESET:
1221 hci_cc_reset(hdev, skb);
1222 break;
1223
1224 case HCI_OP_WRITE_LOCAL_NAME:
1225 hci_cc_write_local_name(hdev, skb);
1226 break;
1227
1228 case HCI_OP_READ_LOCAL_NAME:
1229 hci_cc_read_local_name(hdev, skb);
1230 break;
1231
1232 case HCI_OP_WRITE_AUTH_ENABLE:
1233 hci_cc_write_auth_enable(hdev, skb);
1234 break;
1235
1236 case HCI_OP_WRITE_ENCRYPT_MODE:
1237 hci_cc_write_encrypt_mode(hdev, skb);
1238 break;
1239
1240 case HCI_OP_WRITE_SCAN_ENABLE:
1241 hci_cc_write_scan_enable(hdev, skb);
1242 break;
1243
1244 case HCI_OP_READ_CLASS_OF_DEV:
1245 hci_cc_read_class_of_dev(hdev, skb);
1246 break;
1247
1248 case HCI_OP_WRITE_CLASS_OF_DEV:
1249 hci_cc_write_class_of_dev(hdev, skb);
1250 break;
1251
1252 case HCI_OP_READ_VOICE_SETTING:
1253 hci_cc_read_voice_setting(hdev, skb);
1254 break;
1255
1256 case HCI_OP_WRITE_VOICE_SETTING:
1257 hci_cc_write_voice_setting(hdev, skb);
1258 break;
1259
1260 case HCI_OP_HOST_BUFFER_SIZE:
1261 hci_cc_host_buffer_size(hdev, skb);
1262 break;
1263
Marcel Holtmann333140b2008-07-14 20:13:48 +02001264 case HCI_OP_READ_SSP_MODE:
1265 hci_cc_read_ssp_mode(hdev, skb);
1266 break;
1267
1268 case HCI_OP_WRITE_SSP_MODE:
1269 hci_cc_write_ssp_mode(hdev, skb);
1270 break;
1271
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001272 case HCI_OP_READ_LOCAL_VERSION:
1273 hci_cc_read_local_version(hdev, skb);
1274 break;
1275
1276 case HCI_OP_READ_LOCAL_COMMANDS:
1277 hci_cc_read_local_commands(hdev, skb);
1278 break;
1279
1280 case HCI_OP_READ_LOCAL_FEATURES:
1281 hci_cc_read_local_features(hdev, skb);
1282 break;
1283
1284 case HCI_OP_READ_BUFFER_SIZE:
1285 hci_cc_read_buffer_size(hdev, skb);
1286 break;
1287
1288 case HCI_OP_READ_BD_ADDR:
1289 hci_cc_read_bd_addr(hdev, skb);
1290 break;
1291
1292 default:
1293 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1294 break;
1295 }
1296
1297 if (ev->ncmd) {
1298 atomic_set(&hdev->cmd_cnt, 1);
1299 if (!skb_queue_empty(&hdev->cmd_q))
1300 hci_sched_cmd(hdev);
1301 }
1302}
1303
1304static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1305{
1306 struct hci_ev_cmd_status *ev = (void *) skb->data;
1307 __u16 opcode;
1308
1309 skb_pull(skb, sizeof(*ev));
1310
1311 opcode = __le16_to_cpu(ev->opcode);
1312
1313 switch (opcode) {
1314 case HCI_OP_INQUIRY:
1315 hci_cs_inquiry(hdev, ev->status);
1316 break;
1317
1318 case HCI_OP_CREATE_CONN:
1319 hci_cs_create_conn(hdev, ev->status);
1320 break;
1321
1322 case HCI_OP_ADD_SCO:
1323 hci_cs_add_sco(hdev, ev->status);
1324 break;
1325
Marcel Holtmannf8558552008-07-14 20:13:49 +02001326 case HCI_OP_AUTH_REQUESTED:
1327 hci_cs_auth_requested(hdev, ev->status);
1328 break;
1329
1330 case HCI_OP_SET_CONN_ENCRYPT:
1331 hci_cs_set_conn_encrypt(hdev, ev->status);
1332 break;
1333
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001334 case HCI_OP_REMOTE_NAME_REQ:
1335 hci_cs_remote_name_req(hdev, ev->status);
1336 break;
1337
Marcel Holtmann769be972008-07-14 20:13:49 +02001338 case HCI_OP_READ_REMOTE_FEATURES:
1339 hci_cs_read_remote_features(hdev, ev->status);
1340 break;
1341
1342 case HCI_OP_READ_REMOTE_EXT_FEATURES:
1343 hci_cs_read_remote_ext_features(hdev, ev->status);
1344 break;
1345
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001346 case HCI_OP_SETUP_SYNC_CONN:
1347 hci_cs_setup_sync_conn(hdev, ev->status);
1348 break;
1349
1350 case HCI_OP_SNIFF_MODE:
1351 hci_cs_sniff_mode(hdev, ev->status);
1352 break;
1353
1354 case HCI_OP_EXIT_SNIFF_MODE:
1355 hci_cs_exit_sniff_mode(hdev, ev->status);
1356 break;
1357
1358 default:
1359 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1360 break;
1361 }
1362
1363 if (ev->ncmd) {
1364 atomic_set(&hdev->cmd_cnt, 1);
1365 if (!skb_queue_empty(&hdev->cmd_q))
1366 hci_sched_cmd(hdev);
1367 }
1368}
1369
1370static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1371{
1372 struct hci_ev_role_change *ev = (void *) skb->data;
1373 struct hci_conn *conn;
1374
1375 BT_DBG("%s status %d", hdev->name, ev->status);
1376
1377 hci_dev_lock(hdev);
1378
1379 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1380 if (conn) {
1381 if (!ev->status) {
1382 if (ev->role)
1383 conn->link_mode &= ~HCI_LM_MASTER;
1384 else
1385 conn->link_mode |= HCI_LM_MASTER;
1386 }
1387
1388 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1389
1390 hci_role_switch_cfm(conn, ev->status, ev->role);
1391 }
1392
1393 hci_dev_unlock(hdev);
1394}
1395
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1397{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001398 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08001399 __le16 *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 int i;
1401
1402 skb_pull(skb, sizeof(*ev));
1403
1404 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1405
1406 if (skb->len < ev->num_hndl * 4) {
1407 BT_DBG("%s bad parameters", hdev->name);
1408 return;
1409 }
1410
1411 tasklet_disable(&hdev->tx_task);
1412
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08001413 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 struct hci_conn *conn;
1415 __u16 handle, count;
1416
Harvey Harrison83985312008-05-02 16:25:46 -07001417 handle = get_unaligned_le16(ptr++);
1418 count = get_unaligned_le16(ptr++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419
1420 conn = hci_conn_hash_lookup_handle(hdev, handle);
1421 if (conn) {
1422 conn->sent -= count;
1423
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001424 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
1426 hdev->acl_cnt = hdev->acl_pkts;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001427 } else {
1428 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
1429 hdev->sco_cnt = hdev->sco_pkts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 }
1431 }
1432 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001433
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 hci_sched_tx(hdev);
1435
1436 tasklet_enable(&hdev->tx_task);
1437}
1438
Marcel Holtmann04837f62006-07-03 10:02:33 +02001439static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001441 struct hci_ev_mode_change *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001442 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443
1444 BT_DBG("%s status %d", hdev->name, ev->status);
1445
1446 hci_dev_lock(hdev);
1447
Marcel Holtmann04837f62006-07-03 10:02:33 +02001448 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1449 if (conn) {
1450 conn->mode = ev->mode;
1451 conn->interval = __le16_to_cpu(ev->interval);
1452
1453 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1454 if (conn->mode == HCI_CM_ACTIVE)
1455 conn->power_save = 1;
1456 else
1457 conn->power_save = 0;
1458 }
1459 }
1460
1461 hci_dev_unlock(hdev);
1462}
1463
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1465{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001466 BT_DBG("%s", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467}
1468
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1470{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001471 BT_DBG("%s", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472}
1473
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1475{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001476 BT_DBG("%s", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477}
1478
Marcel Holtmann04837f62006-07-03 10:02:33 +02001479static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1480{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001481 struct hci_ev_clock_offset *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001482 struct hci_conn *conn;
1483
1484 BT_DBG("%s status %d", hdev->name, ev->status);
1485
1486 hci_dev_lock(hdev);
1487
1488 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 if (conn && !ev->status) {
1490 struct inquiry_entry *ie;
1491
1492 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1493 ie->data.clock_offset = ev->clock_offset;
1494 ie->timestamp = jiffies;
1495 }
1496 }
1497
1498 hci_dev_unlock(hdev);
1499}
1500
Marcel Holtmanna8746412008-07-14 20:13:46 +02001501static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1502{
1503 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
1504 struct hci_conn *conn;
1505
1506 BT_DBG("%s status %d", hdev->name, ev->status);
1507
1508 hci_dev_lock(hdev);
1509
1510 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1511 if (conn && !ev->status)
1512 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
1513
1514 hci_dev_unlock(hdev);
1515}
1516
Marcel Holtmann85a1e932005-08-09 20:28:02 -07001517static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1518{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001519 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
Marcel Holtmann85a1e932005-08-09 20:28:02 -07001520 struct inquiry_entry *ie;
1521
1522 BT_DBG("%s", hdev->name);
1523
1524 hci_dev_lock(hdev);
1525
1526 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1527 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1528 ie->timestamp = jiffies;
1529 }
1530
1531 hci_dev_unlock(hdev);
1532}
1533
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001534static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1535{
1536 struct inquiry_data data;
1537 int num_rsp = *((__u8 *) skb->data);
1538
1539 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1540
1541 if (!num_rsp)
1542 return;
1543
1544 hci_dev_lock(hdev);
1545
1546 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1547 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1548
1549 for (; num_rsp; num_rsp--) {
1550 bacpy(&data.bdaddr, &info->bdaddr);
1551 data.pscan_rep_mode = info->pscan_rep_mode;
1552 data.pscan_period_mode = info->pscan_period_mode;
1553 data.pscan_mode = info->pscan_mode;
1554 memcpy(data.dev_class, info->dev_class, 3);
1555 data.clock_offset = info->clock_offset;
1556 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001557 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001558 info++;
1559 hci_inquiry_cache_update(hdev, &data);
1560 }
1561 } else {
1562 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1563
1564 for (; num_rsp; num_rsp--) {
1565 bacpy(&data.bdaddr, &info->bdaddr);
1566 data.pscan_rep_mode = info->pscan_rep_mode;
1567 data.pscan_period_mode = info->pscan_period_mode;
1568 data.pscan_mode = 0x00;
1569 memcpy(data.dev_class, info->dev_class, 3);
1570 data.clock_offset = info->clock_offset;
1571 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001572 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001573 info++;
1574 hci_inquiry_cache_update(hdev, &data);
1575 }
1576 }
1577
1578 hci_dev_unlock(hdev);
1579}
1580
1581static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1582{
Marcel Holtmann41a96212008-07-14 20:13:48 +02001583 struct hci_ev_remote_ext_features *ev = (void *) skb->data;
1584 struct hci_conn *conn;
1585
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001586 BT_DBG("%s", hdev->name);
Marcel Holtmann41a96212008-07-14 20:13:48 +02001587
Marcel Holtmann41a96212008-07-14 20:13:48 +02001588 hci_dev_lock(hdev);
1589
1590 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1591 if (conn) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001592 if (!ev->status && ev->page == 0x01) {
1593 struct inquiry_entry *ie;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001594
Marcel Holtmann769be972008-07-14 20:13:49 +02001595 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)))
1596 ie->data.ssp_mode = (ev->features[0] & 0x01);
Marcel Holtmann41a96212008-07-14 20:13:48 +02001597
Marcel Holtmann769be972008-07-14 20:13:49 +02001598 conn->ssp_mode = (ev->features[0] & 0x01);
1599 }
1600
1601 if (conn->state == BT_CONFIG) {
Marcel Holtmannf8558552008-07-14 20:13:49 +02001602 if (!ev->status && hdev->ssp_mode > 0 &&
Marcel Holtmannf1c08ca2008-09-09 07:19:19 +02001603 conn->ssp_mode > 0 && conn->out) {
1604 struct hci_cp_auth_requested cp;
1605 cp.handle = ev->handle;
1606 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED,
Marcel Holtmannf8558552008-07-14 20:13:49 +02001607 sizeof(cp), &cp);
Marcel Holtmannf8558552008-07-14 20:13:49 +02001608 } else {
1609 conn->state = BT_CONNECTED;
1610 hci_proto_connect_cfm(conn, ev->status);
1611 hci_conn_put(conn);
1612 }
Marcel Holtmann769be972008-07-14 20:13:49 +02001613 }
Marcel Holtmann41a96212008-07-14 20:13:48 +02001614 }
1615
1616 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001617}
1618
1619static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1620{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001621 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1622 struct hci_conn *conn;
1623
1624 BT_DBG("%s status %d", hdev->name, ev->status);
1625
1626 hci_dev_lock(hdev);
1627
1628 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann9dc0a3a2008-07-14 20:13:46 +02001629 if (!conn) {
1630 if (ev->link_type == ESCO_LINK)
1631 goto unlock;
1632
1633 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1634 if (!conn)
1635 goto unlock;
1636
1637 conn->type = SCO_LINK;
1638 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001639
1640 if (!ev->status) {
1641 conn->handle = __le16_to_cpu(ev->handle);
1642 conn->state = BT_CONNECTED;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001643
1644 hci_conn_add_sysfs(conn);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001645 } else
1646 conn->state = BT_CLOSED;
1647
1648 hci_proto_connect_cfm(conn, ev->status);
1649 if (ev->status)
1650 hci_conn_del(conn);
1651
1652unlock:
1653 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001654}
1655
1656static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1657{
1658 BT_DBG("%s", hdev->name);
1659}
1660
Marcel Holtmann04837f62006-07-03 10:02:33 +02001661static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1662{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001663 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001664 struct hci_conn *conn;
1665
1666 BT_DBG("%s status %d", hdev->name, ev->status);
1667
1668 hci_dev_lock(hdev);
1669
1670 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1671 if (conn) {
1672 }
1673
1674 hci_dev_unlock(hdev);
1675}
1676
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001677static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1678{
1679 struct inquiry_data data;
1680 struct extended_inquiry_info *info = (void *) (skb->data + 1);
1681 int num_rsp = *((__u8 *) skb->data);
1682
1683 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1684
1685 if (!num_rsp)
1686 return;
1687
1688 hci_dev_lock(hdev);
1689
1690 for (; num_rsp; num_rsp--) {
1691 bacpy(&data.bdaddr, &info->bdaddr);
1692 data.pscan_rep_mode = info->pscan_rep_mode;
1693 data.pscan_period_mode = info->pscan_period_mode;
1694 data.pscan_mode = 0x00;
1695 memcpy(data.dev_class, info->dev_class, 3);
1696 data.clock_offset = info->clock_offset;
1697 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001698 data.ssp_mode = 0x01;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001699 info++;
1700 hci_inquiry_cache_update(hdev, &data);
1701 }
1702
1703 hci_dev_unlock(hdev);
1704}
1705
Marcel Holtmann04936842008-07-14 20:13:48 +02001706static inline void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1707{
1708 struct hci_ev_io_capa_request *ev = (void *) skb->data;
1709 struct hci_conn *conn;
1710
1711 BT_DBG("%s", hdev->name);
1712
1713 hci_dev_lock(hdev);
1714
1715 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1716 if (conn)
1717 hci_conn_hold(conn);
1718
1719 hci_dev_unlock(hdev);
1720}
1721
1722static inline void hci_simple_pair_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1723{
1724 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
1725 struct hci_conn *conn;
1726
1727 BT_DBG("%s", hdev->name);
1728
1729 hci_dev_lock(hdev);
1730
1731 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1732 if (conn)
1733 hci_conn_put(conn);
1734
1735 hci_dev_unlock(hdev);
1736}
1737
Marcel Holtmann41a96212008-07-14 20:13:48 +02001738static inline void hci_remote_host_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1739{
1740 struct hci_ev_remote_host_features *ev = (void *) skb->data;
1741 struct inquiry_entry *ie;
1742
1743 BT_DBG("%s", hdev->name);
1744
1745 hci_dev_lock(hdev);
1746
1747 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))
1748 ie->data.ssp_mode = (ev->features[0] & 0x01);
1749
1750 hci_dev_unlock(hdev);
1751}
1752
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1754{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001755 struct hci_event_hdr *hdr = (void *) skb->data;
1756 __u8 event = hdr->evt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757
1758 skb_pull(skb, HCI_EVENT_HDR_SIZE);
1759
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001760 switch (event) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 case HCI_EV_INQUIRY_COMPLETE:
1762 hci_inquiry_complete_evt(hdev, skb);
1763 break;
1764
1765 case HCI_EV_INQUIRY_RESULT:
1766 hci_inquiry_result_evt(hdev, skb);
1767 break;
1768
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001769 case HCI_EV_CONN_COMPLETE:
1770 hci_conn_complete_evt(hdev, skb);
Marcel Holtmann21d9e302005-09-13 01:32:25 +02001771 break;
1772
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 case HCI_EV_CONN_REQUEST:
1774 hci_conn_request_evt(hdev, skb);
1775 break;
1776
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 case HCI_EV_DISCONN_COMPLETE:
1778 hci_disconn_complete_evt(hdev, skb);
1779 break;
1780
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 case HCI_EV_AUTH_COMPLETE:
1782 hci_auth_complete_evt(hdev, skb);
1783 break;
1784
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001785 case HCI_EV_REMOTE_NAME:
1786 hci_remote_name_evt(hdev, skb);
1787 break;
1788
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 case HCI_EV_ENCRYPT_CHANGE:
1790 hci_encrypt_change_evt(hdev, skb);
1791 break;
1792
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001793 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
1794 hci_change_link_key_complete_evt(hdev, skb);
1795 break;
1796
1797 case HCI_EV_REMOTE_FEATURES:
1798 hci_remote_features_evt(hdev, skb);
1799 break;
1800
1801 case HCI_EV_REMOTE_VERSION:
1802 hci_remote_version_evt(hdev, skb);
1803 break;
1804
1805 case HCI_EV_QOS_SETUP_COMPLETE:
1806 hci_qos_setup_complete_evt(hdev, skb);
1807 break;
1808
1809 case HCI_EV_CMD_COMPLETE:
1810 hci_cmd_complete_evt(hdev, skb);
1811 break;
1812
1813 case HCI_EV_CMD_STATUS:
1814 hci_cmd_status_evt(hdev, skb);
1815 break;
1816
1817 case HCI_EV_ROLE_CHANGE:
1818 hci_role_change_evt(hdev, skb);
1819 break;
1820
1821 case HCI_EV_NUM_COMP_PKTS:
1822 hci_num_comp_pkts_evt(hdev, skb);
1823 break;
1824
1825 case HCI_EV_MODE_CHANGE:
1826 hci_mode_change_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 break;
1828
1829 case HCI_EV_PIN_CODE_REQ:
1830 hci_pin_code_request_evt(hdev, skb);
1831 break;
1832
1833 case HCI_EV_LINK_KEY_REQ:
1834 hci_link_key_request_evt(hdev, skb);
1835 break;
1836
1837 case HCI_EV_LINK_KEY_NOTIFY:
1838 hci_link_key_notify_evt(hdev, skb);
1839 break;
1840
1841 case HCI_EV_CLOCK_OFFSET:
1842 hci_clock_offset_evt(hdev, skb);
1843 break;
1844
Marcel Holtmanna8746412008-07-14 20:13:46 +02001845 case HCI_EV_PKT_TYPE_CHANGE:
1846 hci_pkt_type_change_evt(hdev, skb);
1847 break;
1848
Marcel Holtmann85a1e932005-08-09 20:28:02 -07001849 case HCI_EV_PSCAN_REP_MODE:
1850 hci_pscan_rep_mode_evt(hdev, skb);
1851 break;
1852
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001853 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1854 hci_inquiry_result_with_rssi_evt(hdev, skb);
1855 break;
1856
1857 case HCI_EV_REMOTE_EXT_FEATURES:
1858 hci_remote_ext_features_evt(hdev, skb);
1859 break;
1860
1861 case HCI_EV_SYNC_CONN_COMPLETE:
1862 hci_sync_conn_complete_evt(hdev, skb);
1863 break;
1864
1865 case HCI_EV_SYNC_CONN_CHANGED:
1866 hci_sync_conn_changed_evt(hdev, skb);
1867 break;
1868
Marcel Holtmann04837f62006-07-03 10:02:33 +02001869 case HCI_EV_SNIFF_SUBRATE:
1870 hci_sniff_subrate_evt(hdev, skb);
1871 break;
1872
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001873 case HCI_EV_EXTENDED_INQUIRY_RESULT:
1874 hci_extended_inquiry_result_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 break;
1876
Marcel Holtmann04936842008-07-14 20:13:48 +02001877 case HCI_EV_IO_CAPA_REQUEST:
1878 hci_io_capa_request_evt(hdev, skb);
1879 break;
1880
1881 case HCI_EV_SIMPLE_PAIR_COMPLETE:
1882 hci_simple_pair_complete_evt(hdev, skb);
1883 break;
1884
Marcel Holtmann41a96212008-07-14 20:13:48 +02001885 case HCI_EV_REMOTE_HOST_FEATURES:
1886 hci_remote_host_features_evt(hdev, skb);
1887 break;
1888
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001889 default:
1890 BT_DBG("%s event 0x%x", hdev->name, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 break;
1892 }
1893
1894 kfree_skb(skb);
1895 hdev->stat.evt_rx++;
1896}
1897
1898/* Generate internal stack event */
1899void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1900{
1901 struct hci_event_hdr *hdr;
1902 struct hci_ev_stack_internal *ev;
1903 struct sk_buff *skb;
1904
1905 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1906 if (!skb)
1907 return;
1908
1909 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1910 hdr->evt = HCI_EV_STACK_INTERNAL;
1911 hdr->plen = sizeof(*ev) + dlen;
1912
1913 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
1914 ev->type = type;
1915 memcpy(ev->data, data, dlen);
1916
Marcel Holtmann576c7d82005-08-06 12:36:54 +02001917 bt_cb(skb)->incoming = 1;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001918 __net_timestamp(skb);
Marcel Holtmann576c7d82005-08-06 12:36:54 +02001919
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001920 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 skb->dev = (void *) hdev;
1922 hci_send_to_sock(hdev, skb);
1923 kfree_skb(skb);
1924}