blob: 184ba0a88ec0883e93b4cd919b9b9c10f66c4fca [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
Marcel Holtmannefc76882009-02-06 09:13:37 +0100487 if (hdev->features[5] & LMP_EDR_ESCO_2M)
488 hdev->esco_type |= (ESCO_2EV3);
489
490 if (hdev->features[5] & LMP_EDR_ESCO_3M)
491 hdev->esco_type |= (ESCO_3EV3);
492
493 if (hdev->features[5] & LMP_EDR_3S_ESCO)
494 hdev->esco_type |= (ESCO_2EV5 | ESCO_3EV5);
495
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200496 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
497 hdev->features[0], hdev->features[1],
498 hdev->features[2], hdev->features[3],
499 hdev->features[4], hdev->features[5],
500 hdev->features[6], hdev->features[7]);
501}
502
503static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
504{
505 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
506
507 BT_DBG("%s status 0x%x", hdev->name, rp->status);
508
509 if (rp->status)
510 return;
511
512 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
513 hdev->sco_mtu = rp->sco_mtu;
514 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
515 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
516
517 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
518 hdev->sco_mtu = 64;
519 hdev->sco_pkts = 8;
520 }
521
522 hdev->acl_cnt = hdev->acl_pkts;
523 hdev->sco_cnt = hdev->sco_pkts;
524
525 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
526 hdev->acl_mtu, hdev->acl_pkts,
527 hdev->sco_mtu, hdev->sco_pkts);
528}
529
530static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
531{
532 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
533
534 BT_DBG("%s status 0x%x", hdev->name, rp->status);
535
536 if (!rp->status)
537 bacpy(&hdev->bdaddr, &rp->bdaddr);
538
539 hci_req_complete(hdev, rp->status);
540}
541
542static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
543{
544 BT_DBG("%s status 0x%x", hdev->name, status);
545
546 if (status) {
547 hci_req_complete(hdev, status);
548
549 hci_conn_check_pending(hdev);
550 } else
551 set_bit(HCI_INQUIRY, &hdev->flags);
552}
553
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
555{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200556 struct hci_cp_create_conn *cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200559 BT_DBG("%s status 0x%x", hdev->name, status);
560
561 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 if (!cp)
563 return;
564
565 hci_dev_lock(hdev);
566
567 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
568
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200569 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
571 if (status) {
572 if (conn && conn->state == BT_CONNECT) {
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200573 if (status != 0x0c || conn->attempt > 2) {
574 conn->state = BT_CLOSED;
575 hci_proto_connect_cfm(conn, status);
576 hci_conn_del(conn);
577 } else
578 conn->state = BT_CONNECT2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 }
580 } else {
581 if (!conn) {
582 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
583 if (conn) {
584 conn->out = 1;
585 conn->link_mode |= HCI_LM_MASTER;
586 } else
587 BT_ERR("No memmory for new connection");
588 }
589 }
590
591 hci_dev_unlock(hdev);
592}
593
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200594static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200596 struct hci_cp_add_sco *cp;
597 struct hci_conn *acl, *sco;
598 __u16 handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200600 BT_DBG("%s status 0x%x", hdev->name, status);
601
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200602 if (!status)
603 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200605 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
606 if (!cp)
607 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200609 handle = __le16_to_cpu(cp->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200611 BT_DBG("%s handle %d", hdev->name, handle);
Marcel Holtmann6bd57412006-11-18 22:14:22 +0100612
613 hci_dev_lock(hdev);
614
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200615 acl = hci_conn_hash_lookup_handle(hdev, handle);
616 if (acl && (sco = acl->link)) {
617 sco->state = BT_CLOSED;
618
619 hci_proto_connect_cfm(sco, status);
620 hci_conn_del(sco);
621 }
Marcel Holtmann6bd57412006-11-18 22:14:22 +0100622
623 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624}
625
Marcel Holtmannf8558552008-07-14 20:13:49 +0200626static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
627{
628 struct hci_cp_auth_requested *cp;
629 struct hci_conn *conn;
630
631 BT_DBG("%s status 0x%x", hdev->name, status);
632
633 if (!status)
634 return;
635
636 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
637 if (!cp)
638 return;
639
640 hci_dev_lock(hdev);
641
642 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
643 if (conn) {
644 if (conn->state == BT_CONFIG) {
645 hci_proto_connect_cfm(conn, status);
646 hci_conn_put(conn);
647 }
648 }
649
650 hci_dev_unlock(hdev);
651}
652
653static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
654{
655 struct hci_cp_set_conn_encrypt *cp;
656 struct hci_conn *conn;
657
658 BT_DBG("%s status 0x%x", hdev->name, status);
659
660 if (!status)
661 return;
662
663 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
664 if (!cp)
665 return;
666
667 hci_dev_lock(hdev);
668
669 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
670 if (conn) {
671 if (conn->state == BT_CONFIG) {
672 hci_proto_connect_cfm(conn, status);
673 hci_conn_put(conn);
674 }
675 }
676
677 hci_dev_unlock(hdev);
678}
679
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200680static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
681{
682 BT_DBG("%s status 0x%x", hdev->name, status);
683}
684
Marcel Holtmann769be972008-07-14 20:13:49 +0200685static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
686{
687 struct hci_cp_read_remote_features *cp;
688 struct hci_conn *conn;
689
690 BT_DBG("%s status 0x%x", hdev->name, status);
691
692 if (!status)
693 return;
694
695 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
696 if (!cp)
697 return;
698
699 hci_dev_lock(hdev);
700
701 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
702 if (conn) {
703 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +0200704 hci_proto_connect_cfm(conn, status);
705 hci_conn_put(conn);
706 }
707 }
708
709 hci_dev_unlock(hdev);
710}
711
712static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
713{
714 struct hci_cp_read_remote_ext_features *cp;
715 struct hci_conn *conn;
716
717 BT_DBG("%s status 0x%x", hdev->name, status);
718
719 if (!status)
720 return;
721
722 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
723 if (!cp)
724 return;
725
726 hci_dev_lock(hdev);
727
728 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
729 if (conn) {
730 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +0200731 hci_proto_connect_cfm(conn, status);
732 hci_conn_put(conn);
733 }
734 }
735
736 hci_dev_unlock(hdev);
737}
738
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200739static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
740{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200741 struct hci_cp_setup_sync_conn *cp;
742 struct hci_conn *acl, *sco;
743 __u16 handle;
744
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200745 BT_DBG("%s status 0x%x", hdev->name, status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200746
747 if (!status)
748 return;
749
750 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
751 if (!cp)
752 return;
753
754 handle = __le16_to_cpu(cp->handle);
755
756 BT_DBG("%s handle %d", hdev->name, handle);
757
758 hci_dev_lock(hdev);
759
760 acl = hci_conn_hash_lookup_handle(hdev, handle);
761 if (acl && (sco = acl->link)) {
762 sco->state = BT_CLOSED;
763
764 hci_proto_connect_cfm(sco, status);
765 hci_conn_del(sco);
766 }
767
768 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200769}
770
771static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
772{
773 struct hci_cp_sniff_mode *cp;
774 struct hci_conn *conn;
775
776 BT_DBG("%s status 0x%x", hdev->name, status);
777
778 if (!status)
779 return;
780
781 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
782 if (!cp)
783 return;
784
785 hci_dev_lock(hdev);
786
787 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
788 if (conn)
789 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
790
791 hci_dev_unlock(hdev);
792}
793
794static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
795{
796 struct hci_cp_exit_sniff_mode *cp;
797 struct hci_conn *conn;
798
799 BT_DBG("%s status 0x%x", hdev->name, status);
800
801 if (!status)
802 return;
803
804 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
805 if (!cp)
806 return;
807
808 hci_dev_lock(hdev);
809
810 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
811 if (conn)
812 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
813
814 hci_dev_unlock(hdev);
815}
816
817static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
818{
819 __u8 status = *((__u8 *) skb->data);
820
821 BT_DBG("%s status %d", hdev->name, status);
822
823 clear_bit(HCI_INQUIRY, &hdev->flags);
824
825 hci_req_complete(hdev, status);
826
827 hci_conn_check_pending(hdev);
828}
829
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
831{
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700832 struct inquiry_data data;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200833 struct inquiry_info *info = (void *) (skb->data + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 int num_rsp = *((__u8 *) skb->data);
835
836 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
837
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700838 if (!num_rsp)
839 return;
840
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700842
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 for (; num_rsp; num_rsp--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 bacpy(&data.bdaddr, &info->bdaddr);
845 data.pscan_rep_mode = info->pscan_rep_mode;
846 data.pscan_period_mode = info->pscan_period_mode;
847 data.pscan_mode = info->pscan_mode;
848 memcpy(data.dev_class, info->dev_class, 3);
849 data.clock_offset = info->clock_offset;
850 data.rssi = 0x00;
Marcel Holtmann41a96212008-07-14 20:13:48 +0200851 data.ssp_mode = 0x00;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 info++;
853 hci_inquiry_cache_update(hdev, &data);
854 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700855
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 hci_dev_unlock(hdev);
857}
858
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200859static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200861 struct hci_ev_conn_complete *ev = (void *) skb->data;
862 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200864 BT_DBG("%s", hdev->name);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700865
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700867
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200868 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann94992372009-04-19 19:30:03 +0200869 if (!conn) {
870 if (ev->link_type != SCO_LINK)
871 goto unlock;
872
873 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
874 if (!conn)
875 goto unlock;
876
877 conn->type = SCO_LINK;
878 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700879
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200880 if (!ev->status) {
881 conn->handle = __le16_to_cpu(ev->handle);
Marcel Holtmann769be972008-07-14 20:13:49 +0200882
883 if (conn->type == ACL_LINK) {
884 conn->state = BT_CONFIG;
885 hci_conn_hold(conn);
Marcel Holtmann052b30b2009-04-26 20:01:22 +0200886 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann769be972008-07-14 20:13:49 +0200887 } else
888 conn->state = BT_CONNECTED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200889
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200890 hci_conn_add_sysfs(conn);
891
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200892 if (test_bit(HCI_AUTH, &hdev->flags))
893 conn->link_mode |= HCI_LM_AUTH;
894
895 if (test_bit(HCI_ENCRYPT, &hdev->flags))
896 conn->link_mode |= HCI_LM_ENCRYPT;
897
898 /* Get remote features */
899 if (conn->type == ACL_LINK) {
900 struct hci_cp_read_remote_features cp;
901 cp.handle = ev->handle;
Marcel Holtmann769be972008-07-14 20:13:49 +0200902 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
903 sizeof(cp), &cp);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700904 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700905
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200906 /* Set packet type for incoming connection */
Marcel Holtmanna8746412008-07-14 20:13:46 +0200907 if (!conn->out && hdev->hci_ver < 3) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200908 struct hci_cp_change_conn_ptype cp;
909 cp.handle = ev->handle;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200910 cp.pkt_type = cpu_to_le16(conn->pkt_type);
911 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
912 sizeof(cp), &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200913 }
914 } else
915 conn->state = BT_CLOSED;
916
917 if (conn->type == ACL_LINK) {
918 struct hci_conn *sco = conn->link;
919 if (sco) {
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200920 if (!ev->status) {
921 if (lmp_esco_capable(hdev))
922 hci_setup_sync(sco, conn->handle);
923 else
924 hci_add_sco(sco, conn->handle);
925 } else {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200926 hci_proto_connect_cfm(sco, ev->status);
927 hci_conn_del(sco);
928 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700929 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700931
Marcel Holtmann769be972008-07-14 20:13:49 +0200932 if (ev->status) {
933 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200934 hci_conn_del(conn);
Marcel Holtmannc89b6e62009-01-15 21:57:03 +0100935 } else if (ev->link_type != ACL_LINK)
936 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200937
938unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200940
941 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942}
943
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
945{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200946 struct hci_ev_conn_request *ev = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 int mask = hdev->link_mode;
948
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200949 BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
950 batostr(&ev->bdaddr), ev->link_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951
952 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
953
954 if (mask & HCI_LM_ACCEPT) {
955 /* Connection accepted */
Marcel Holtmannc7bdd502008-07-14 20:13:47 +0200956 struct inquiry_entry *ie;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
959 hci_dev_lock(hdev);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200960
Marcel Holtmannc7bdd502008-07-14 20:13:47 +0200961 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))
962 memcpy(ie->data.dev_class, ev->dev_class, 3);
963
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
965 if (!conn) {
966 if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
967 BT_ERR("No memmory for new connection");
968 hci_dev_unlock(hdev);
969 return;
970 }
971 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200972
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 memcpy(conn->dev_class, ev->dev_class, 3);
974 conn->state = BT_CONNECT;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200975
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 hci_dev_unlock(hdev);
977
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200978 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
979 struct hci_cp_accept_conn_req cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200981 bacpy(&cp.bdaddr, &ev->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200983 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
984 cp.role = 0x00; /* Become master */
985 else
986 cp.role = 0x01; /* Remain slave */
987
988 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
989 sizeof(cp), &cp);
990 } else {
991 struct hci_cp_accept_sync_conn_req cp;
992
993 bacpy(&cp.bdaddr, &ev->bdaddr);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200994 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200995
996 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
997 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
998 cp.max_latency = cpu_to_le16(0xffff);
999 cp.content_format = cpu_to_le16(hdev->voice_setting);
1000 cp.retrans_effort = 0xff;
1001
1002 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
1003 sizeof(cp), &cp);
1004 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 } else {
1006 /* Connection rejected */
1007 struct hci_cp_reject_conn_req cp;
1008
1009 bacpy(&cp.bdaddr, &ev->bdaddr);
1010 cp.reason = 0x0f;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001011 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 }
1013}
1014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1016{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001017 struct hci_ev_disconn_complete *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001018 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
1020 BT_DBG("%s status %d", hdev->name, ev->status);
1021
1022 if (ev->status)
1023 return;
1024
1025 hci_dev_lock(hdev);
1026
Marcel Holtmann04837f62006-07-03 10:02:33 +02001027 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 if (conn) {
1029 conn->state = BT_CLOSED;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001030
Marcel Holtmann2950f212009-02-12 14:02:50 +01001031 hci_proto_disconn_cfm(conn, ev->reason);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 hci_conn_del(conn);
1033 }
1034
1035 hci_dev_unlock(hdev);
1036}
1037
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001038static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1039{
1040 struct hci_ev_auth_complete *ev = (void *) skb->data;
1041 struct hci_conn *conn;
1042
1043 BT_DBG("%s status %d", hdev->name, ev->status);
1044
1045 hci_dev_lock(hdev);
1046
1047 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1048 if (conn) {
1049 if (!ev->status)
1050 conn->link_mode |= HCI_LM_AUTH;
1051
1052 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1053
Marcel Holtmannf8558552008-07-14 20:13:49 +02001054 if (conn->state == BT_CONFIG) {
1055 if (!ev->status && hdev->ssp_mode > 0 &&
1056 conn->ssp_mode > 0) {
1057 struct hci_cp_set_conn_encrypt cp;
1058 cp.handle = ev->handle;
1059 cp.encrypt = 0x01;
1060 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1061 sizeof(cp), &cp);
1062 } else {
1063 conn->state = BT_CONNECTED;
1064 hci_proto_connect_cfm(conn, ev->status);
1065 hci_conn_put(conn);
1066 }
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001067 } else {
Marcel Holtmannf8558552008-07-14 20:13:49 +02001068 hci_auth_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001069
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001070 hci_conn_hold(conn);
1071 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
1072 hci_conn_put(conn);
1073 }
1074
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001075 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
1076 if (!ev->status) {
1077 struct hci_cp_set_conn_encrypt cp;
Marcel Holtmannf8558552008-07-14 20:13:49 +02001078 cp.handle = ev->handle;
1079 cp.encrypt = 0x01;
1080 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1081 sizeof(cp), &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001082 } else {
1083 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1084 hci_encrypt_cfm(conn, ev->status, 0x00);
1085 }
1086 }
1087 }
1088
1089 hci_dev_unlock(hdev);
1090}
1091
1092static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
1093{
1094 BT_DBG("%s", hdev->name);
1095
1096 hci_conn_check_pending(hdev);
1097}
1098
1099static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1100{
1101 struct hci_ev_encrypt_change *ev = (void *) skb->data;
1102 struct hci_conn *conn;
1103
1104 BT_DBG("%s status %d", hdev->name, ev->status);
1105
1106 hci_dev_lock(hdev);
1107
1108 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1109 if (conn) {
1110 if (!ev->status) {
Marcel Holtmannae293192008-07-14 20:13:45 +02001111 if (ev->encrypt) {
1112 /* Encryption implies authentication */
1113 conn->link_mode |= HCI_LM_AUTH;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001114 conn->link_mode |= HCI_LM_ENCRYPT;
Marcel Holtmannae293192008-07-14 20:13:45 +02001115 } else
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001116 conn->link_mode &= ~HCI_LM_ENCRYPT;
1117 }
1118
1119 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1120
Marcel Holtmannf8558552008-07-14 20:13:49 +02001121 if (conn->state == BT_CONFIG) {
1122 if (!ev->status)
1123 conn->state = BT_CONNECTED;
1124
1125 hci_proto_connect_cfm(conn, ev->status);
1126 hci_conn_put(conn);
1127 } else
1128 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001129 }
1130
1131 hci_dev_unlock(hdev);
1132}
1133
1134static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1135{
1136 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
1137 struct hci_conn *conn;
1138
1139 BT_DBG("%s status %d", hdev->name, ev->status);
1140
1141 hci_dev_lock(hdev);
1142
1143 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1144 if (conn) {
1145 if (!ev->status)
1146 conn->link_mode |= HCI_LM_SECURE;
1147
1148 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1149
1150 hci_key_change_cfm(conn, ev->status);
1151 }
1152
1153 hci_dev_unlock(hdev);
1154}
1155
1156static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1157{
1158 struct hci_ev_remote_features *ev = (void *) skb->data;
1159 struct hci_conn *conn;
1160
1161 BT_DBG("%s status %d", hdev->name, ev->status);
1162
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001163 hci_dev_lock(hdev);
1164
1165 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Marcel Holtmann769be972008-07-14 20:13:49 +02001166 if (conn) {
1167 if (!ev->status)
1168 memcpy(conn->features, ev->features, 8);
1169
1170 if (conn->state == BT_CONFIG) {
1171 if (!ev->status && lmp_ssp_capable(hdev) &&
1172 lmp_ssp_capable(conn)) {
1173 struct hci_cp_read_remote_ext_features cp;
1174 cp.handle = ev->handle;
1175 cp.page = 0x01;
1176 hci_send_cmd(hdev,
1177 HCI_OP_READ_REMOTE_EXT_FEATURES,
1178 sizeof(cp), &cp);
1179 } else {
1180 conn->state = BT_CONNECTED;
1181 hci_proto_connect_cfm(conn, ev->status);
1182 hci_conn_put(conn);
1183 }
1184 }
1185 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001186
1187 hci_dev_unlock(hdev);
1188}
1189
1190static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
1191{
1192 BT_DBG("%s", hdev->name);
1193}
1194
1195static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1196{
1197 BT_DBG("%s", hdev->name);
1198}
1199
1200static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1201{
1202 struct hci_ev_cmd_complete *ev = (void *) skb->data;
1203 __u16 opcode;
1204
1205 skb_pull(skb, sizeof(*ev));
1206
1207 opcode = __le16_to_cpu(ev->opcode);
1208
1209 switch (opcode) {
1210 case HCI_OP_INQUIRY_CANCEL:
1211 hci_cc_inquiry_cancel(hdev, skb);
1212 break;
1213
1214 case HCI_OP_EXIT_PERIODIC_INQ:
1215 hci_cc_exit_periodic_inq(hdev, skb);
1216 break;
1217
1218 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
1219 hci_cc_remote_name_req_cancel(hdev, skb);
1220 break;
1221
1222 case HCI_OP_ROLE_DISCOVERY:
1223 hci_cc_role_discovery(hdev, skb);
1224 break;
1225
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001226 case HCI_OP_READ_LINK_POLICY:
1227 hci_cc_read_link_policy(hdev, skb);
1228 break;
1229
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001230 case HCI_OP_WRITE_LINK_POLICY:
1231 hci_cc_write_link_policy(hdev, skb);
1232 break;
1233
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001234 case HCI_OP_READ_DEF_LINK_POLICY:
1235 hci_cc_read_def_link_policy(hdev, skb);
1236 break;
1237
1238 case HCI_OP_WRITE_DEF_LINK_POLICY:
1239 hci_cc_write_def_link_policy(hdev, skb);
1240 break;
1241
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001242 case HCI_OP_RESET:
1243 hci_cc_reset(hdev, skb);
1244 break;
1245
1246 case HCI_OP_WRITE_LOCAL_NAME:
1247 hci_cc_write_local_name(hdev, skb);
1248 break;
1249
1250 case HCI_OP_READ_LOCAL_NAME:
1251 hci_cc_read_local_name(hdev, skb);
1252 break;
1253
1254 case HCI_OP_WRITE_AUTH_ENABLE:
1255 hci_cc_write_auth_enable(hdev, skb);
1256 break;
1257
1258 case HCI_OP_WRITE_ENCRYPT_MODE:
1259 hci_cc_write_encrypt_mode(hdev, skb);
1260 break;
1261
1262 case HCI_OP_WRITE_SCAN_ENABLE:
1263 hci_cc_write_scan_enable(hdev, skb);
1264 break;
1265
1266 case HCI_OP_READ_CLASS_OF_DEV:
1267 hci_cc_read_class_of_dev(hdev, skb);
1268 break;
1269
1270 case HCI_OP_WRITE_CLASS_OF_DEV:
1271 hci_cc_write_class_of_dev(hdev, skb);
1272 break;
1273
1274 case HCI_OP_READ_VOICE_SETTING:
1275 hci_cc_read_voice_setting(hdev, skb);
1276 break;
1277
1278 case HCI_OP_WRITE_VOICE_SETTING:
1279 hci_cc_write_voice_setting(hdev, skb);
1280 break;
1281
1282 case HCI_OP_HOST_BUFFER_SIZE:
1283 hci_cc_host_buffer_size(hdev, skb);
1284 break;
1285
Marcel Holtmann333140b2008-07-14 20:13:48 +02001286 case HCI_OP_READ_SSP_MODE:
1287 hci_cc_read_ssp_mode(hdev, skb);
1288 break;
1289
1290 case HCI_OP_WRITE_SSP_MODE:
1291 hci_cc_write_ssp_mode(hdev, skb);
1292 break;
1293
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001294 case HCI_OP_READ_LOCAL_VERSION:
1295 hci_cc_read_local_version(hdev, skb);
1296 break;
1297
1298 case HCI_OP_READ_LOCAL_COMMANDS:
1299 hci_cc_read_local_commands(hdev, skb);
1300 break;
1301
1302 case HCI_OP_READ_LOCAL_FEATURES:
1303 hci_cc_read_local_features(hdev, skb);
1304 break;
1305
1306 case HCI_OP_READ_BUFFER_SIZE:
1307 hci_cc_read_buffer_size(hdev, skb);
1308 break;
1309
1310 case HCI_OP_READ_BD_ADDR:
1311 hci_cc_read_bd_addr(hdev, skb);
1312 break;
1313
1314 default:
1315 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1316 break;
1317 }
1318
1319 if (ev->ncmd) {
1320 atomic_set(&hdev->cmd_cnt, 1);
1321 if (!skb_queue_empty(&hdev->cmd_q))
1322 hci_sched_cmd(hdev);
1323 }
1324}
1325
1326static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1327{
1328 struct hci_ev_cmd_status *ev = (void *) skb->data;
1329 __u16 opcode;
1330
1331 skb_pull(skb, sizeof(*ev));
1332
1333 opcode = __le16_to_cpu(ev->opcode);
1334
1335 switch (opcode) {
1336 case HCI_OP_INQUIRY:
1337 hci_cs_inquiry(hdev, ev->status);
1338 break;
1339
1340 case HCI_OP_CREATE_CONN:
1341 hci_cs_create_conn(hdev, ev->status);
1342 break;
1343
1344 case HCI_OP_ADD_SCO:
1345 hci_cs_add_sco(hdev, ev->status);
1346 break;
1347
Marcel Holtmannf8558552008-07-14 20:13:49 +02001348 case HCI_OP_AUTH_REQUESTED:
1349 hci_cs_auth_requested(hdev, ev->status);
1350 break;
1351
1352 case HCI_OP_SET_CONN_ENCRYPT:
1353 hci_cs_set_conn_encrypt(hdev, ev->status);
1354 break;
1355
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001356 case HCI_OP_REMOTE_NAME_REQ:
1357 hci_cs_remote_name_req(hdev, ev->status);
1358 break;
1359
Marcel Holtmann769be972008-07-14 20:13:49 +02001360 case HCI_OP_READ_REMOTE_FEATURES:
1361 hci_cs_read_remote_features(hdev, ev->status);
1362 break;
1363
1364 case HCI_OP_READ_REMOTE_EXT_FEATURES:
1365 hci_cs_read_remote_ext_features(hdev, ev->status);
1366 break;
1367
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001368 case HCI_OP_SETUP_SYNC_CONN:
1369 hci_cs_setup_sync_conn(hdev, ev->status);
1370 break;
1371
1372 case HCI_OP_SNIFF_MODE:
1373 hci_cs_sniff_mode(hdev, ev->status);
1374 break;
1375
1376 case HCI_OP_EXIT_SNIFF_MODE:
1377 hci_cs_exit_sniff_mode(hdev, ev->status);
1378 break;
1379
1380 default:
1381 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1382 break;
1383 }
1384
1385 if (ev->ncmd) {
1386 atomic_set(&hdev->cmd_cnt, 1);
1387 if (!skb_queue_empty(&hdev->cmd_q))
1388 hci_sched_cmd(hdev);
1389 }
1390}
1391
1392static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1393{
1394 struct hci_ev_role_change *ev = (void *) skb->data;
1395 struct hci_conn *conn;
1396
1397 BT_DBG("%s status %d", hdev->name, ev->status);
1398
1399 hci_dev_lock(hdev);
1400
1401 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1402 if (conn) {
1403 if (!ev->status) {
1404 if (ev->role)
1405 conn->link_mode &= ~HCI_LM_MASTER;
1406 else
1407 conn->link_mode |= HCI_LM_MASTER;
1408 }
1409
1410 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1411
1412 hci_role_switch_cfm(conn, ev->status, ev->role);
1413 }
1414
1415 hci_dev_unlock(hdev);
1416}
1417
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1419{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001420 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08001421 __le16 *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 int i;
1423
1424 skb_pull(skb, sizeof(*ev));
1425
1426 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1427
1428 if (skb->len < ev->num_hndl * 4) {
1429 BT_DBG("%s bad parameters", hdev->name);
1430 return;
1431 }
1432
1433 tasklet_disable(&hdev->tx_task);
1434
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08001435 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 struct hci_conn *conn;
1437 __u16 handle, count;
1438
Harvey Harrison83985312008-05-02 16:25:46 -07001439 handle = get_unaligned_le16(ptr++);
1440 count = get_unaligned_le16(ptr++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441
1442 conn = hci_conn_hash_lookup_handle(hdev, handle);
1443 if (conn) {
1444 conn->sent -= count;
1445
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001446 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
1448 hdev->acl_cnt = hdev->acl_pkts;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001449 } else {
1450 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
1451 hdev->sco_cnt = hdev->sco_pkts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 }
1453 }
1454 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001455
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 hci_sched_tx(hdev);
1457
1458 tasklet_enable(&hdev->tx_task);
1459}
1460
Marcel Holtmann04837f62006-07-03 10:02:33 +02001461static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001463 struct hci_ev_mode_change *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001464 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465
1466 BT_DBG("%s status %d", hdev->name, ev->status);
1467
1468 hci_dev_lock(hdev);
1469
Marcel Holtmann04837f62006-07-03 10:02:33 +02001470 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1471 if (conn) {
1472 conn->mode = ev->mode;
1473 conn->interval = __le16_to_cpu(ev->interval);
1474
1475 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1476 if (conn->mode == HCI_CM_ACTIVE)
1477 conn->power_save = 1;
1478 else
1479 conn->power_save = 0;
1480 }
1481 }
1482
1483 hci_dev_unlock(hdev);
1484}
1485
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1487{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001488 struct hci_ev_pin_code_req *ev = (void *) skb->data;
1489 struct hci_conn *conn;
1490
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001491 BT_DBG("%s", hdev->name);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001492
1493 hci_dev_lock(hdev);
1494
1495 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
Marcel Holtmann3d7a9d12009-05-09 12:09:21 -07001496 if (conn && conn->state == BT_CONNECTED) {
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001497 hci_conn_hold(conn);
1498 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
1499 hci_conn_put(conn);
1500 }
1501
1502 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503}
1504
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1506{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001507 BT_DBG("%s", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508}
1509
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1511{
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001512 struct hci_ev_link_key_notify *ev = (void *) skb->data;
1513 struct hci_conn *conn;
1514
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001515 BT_DBG("%s", hdev->name);
Marcel Holtmann052b30b2009-04-26 20:01:22 +02001516
1517 hci_dev_lock(hdev);
1518
1519 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1520 if (conn) {
1521 hci_conn_hold(conn);
1522 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
1523 hci_conn_put(conn);
1524 }
1525
1526 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527}
1528
Marcel Holtmann04837f62006-07-03 10:02:33 +02001529static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1530{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001531 struct hci_ev_clock_offset *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001532 struct hci_conn *conn;
1533
1534 BT_DBG("%s status %d", hdev->name, ev->status);
1535
1536 hci_dev_lock(hdev);
1537
1538 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 if (conn && !ev->status) {
1540 struct inquiry_entry *ie;
1541
1542 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1543 ie->data.clock_offset = ev->clock_offset;
1544 ie->timestamp = jiffies;
1545 }
1546 }
1547
1548 hci_dev_unlock(hdev);
1549}
1550
Marcel Holtmanna8746412008-07-14 20:13:46 +02001551static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1552{
1553 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
1554 struct hci_conn *conn;
1555
1556 BT_DBG("%s status %d", hdev->name, ev->status);
1557
1558 hci_dev_lock(hdev);
1559
1560 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1561 if (conn && !ev->status)
1562 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
1563
1564 hci_dev_unlock(hdev);
1565}
1566
Marcel Holtmann85a1e932005-08-09 20:28:02 -07001567static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1568{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001569 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
Marcel Holtmann85a1e932005-08-09 20:28:02 -07001570 struct inquiry_entry *ie;
1571
1572 BT_DBG("%s", hdev->name);
1573
1574 hci_dev_lock(hdev);
1575
1576 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1577 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1578 ie->timestamp = jiffies;
1579 }
1580
1581 hci_dev_unlock(hdev);
1582}
1583
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001584static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1585{
1586 struct inquiry_data data;
1587 int num_rsp = *((__u8 *) skb->data);
1588
1589 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1590
1591 if (!num_rsp)
1592 return;
1593
1594 hci_dev_lock(hdev);
1595
1596 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1597 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1598
1599 for (; num_rsp; num_rsp--) {
1600 bacpy(&data.bdaddr, &info->bdaddr);
1601 data.pscan_rep_mode = info->pscan_rep_mode;
1602 data.pscan_period_mode = info->pscan_period_mode;
1603 data.pscan_mode = info->pscan_mode;
1604 memcpy(data.dev_class, info->dev_class, 3);
1605 data.clock_offset = info->clock_offset;
1606 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001607 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001608 info++;
1609 hci_inquiry_cache_update(hdev, &data);
1610 }
1611 } else {
1612 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1613
1614 for (; num_rsp; num_rsp--) {
1615 bacpy(&data.bdaddr, &info->bdaddr);
1616 data.pscan_rep_mode = info->pscan_rep_mode;
1617 data.pscan_period_mode = info->pscan_period_mode;
1618 data.pscan_mode = 0x00;
1619 memcpy(data.dev_class, info->dev_class, 3);
1620 data.clock_offset = info->clock_offset;
1621 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001622 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001623 info++;
1624 hci_inquiry_cache_update(hdev, &data);
1625 }
1626 }
1627
1628 hci_dev_unlock(hdev);
1629}
1630
1631static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1632{
Marcel Holtmann41a96212008-07-14 20:13:48 +02001633 struct hci_ev_remote_ext_features *ev = (void *) skb->data;
1634 struct hci_conn *conn;
1635
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001636 BT_DBG("%s", hdev->name);
Marcel Holtmann41a96212008-07-14 20:13:48 +02001637
Marcel Holtmann41a96212008-07-14 20:13:48 +02001638 hci_dev_lock(hdev);
1639
1640 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1641 if (conn) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001642 if (!ev->status && ev->page == 0x01) {
1643 struct inquiry_entry *ie;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001644
Marcel Holtmann769be972008-07-14 20:13:49 +02001645 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)))
1646 ie->data.ssp_mode = (ev->features[0] & 0x01);
Marcel Holtmann41a96212008-07-14 20:13:48 +02001647
Marcel Holtmann769be972008-07-14 20:13:49 +02001648 conn->ssp_mode = (ev->features[0] & 0x01);
1649 }
1650
1651 if (conn->state == BT_CONFIG) {
Marcel Holtmannf8558552008-07-14 20:13:49 +02001652 if (!ev->status && hdev->ssp_mode > 0 &&
Marcel Holtmann8c1b2352009-01-15 21:58:04 +01001653 conn->ssp_mode > 0 && conn->out &&
1654 conn->sec_level != BT_SECURITY_SDP) {
Marcel Holtmannf1c08ca2008-09-09 07:19:19 +02001655 struct hci_cp_auth_requested cp;
1656 cp.handle = ev->handle;
1657 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED,
Marcel Holtmannf8558552008-07-14 20:13:49 +02001658 sizeof(cp), &cp);
Marcel Holtmannf8558552008-07-14 20:13:49 +02001659 } else {
1660 conn->state = BT_CONNECTED;
1661 hci_proto_connect_cfm(conn, ev->status);
1662 hci_conn_put(conn);
1663 }
Marcel Holtmann769be972008-07-14 20:13:49 +02001664 }
Marcel Holtmann41a96212008-07-14 20:13:48 +02001665 }
1666
1667 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001668}
1669
1670static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1671{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001672 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1673 struct hci_conn *conn;
1674
1675 BT_DBG("%s status %d", hdev->name, ev->status);
1676
1677 hci_dev_lock(hdev);
1678
1679 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann9dc0a3a2008-07-14 20:13:46 +02001680 if (!conn) {
1681 if (ev->link_type == ESCO_LINK)
1682 goto unlock;
1683
1684 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1685 if (!conn)
1686 goto unlock;
1687
1688 conn->type = SCO_LINK;
1689 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001690
Marcel Holtmann732547f2009-04-19 19:14:14 +02001691 switch (ev->status) {
1692 case 0x00:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001693 conn->handle = __le16_to_cpu(ev->handle);
1694 conn->state = BT_CONNECTED;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001695
1696 hci_conn_add_sysfs(conn);
Marcel Holtmann732547f2009-04-19 19:14:14 +02001697 break;
1698
1699 case 0x1c: /* SCO interval rejected */
1700 case 0x1f: /* Unspecified error */
1701 if (conn->out && conn->attempt < 2) {
1702 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
1703 (hdev->esco_type & EDR_ESCO_MASK);
1704 hci_setup_sync(conn, conn->link->handle);
1705 goto unlock;
1706 }
1707 /* fall through */
1708
1709 default:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001710 conn->state = BT_CLOSED;
Marcel Holtmann732547f2009-04-19 19:14:14 +02001711 break;
1712 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001713
1714 hci_proto_connect_cfm(conn, ev->status);
1715 if (ev->status)
1716 hci_conn_del(conn);
1717
1718unlock:
1719 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001720}
1721
1722static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1723{
1724 BT_DBG("%s", hdev->name);
1725}
1726
Marcel Holtmann04837f62006-07-03 10:02:33 +02001727static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1728{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001729 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001730 struct hci_conn *conn;
1731
1732 BT_DBG("%s status %d", hdev->name, ev->status);
1733
1734 hci_dev_lock(hdev);
1735
1736 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1737 if (conn) {
1738 }
1739
1740 hci_dev_unlock(hdev);
1741}
1742
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001743static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1744{
1745 struct inquiry_data data;
1746 struct extended_inquiry_info *info = (void *) (skb->data + 1);
1747 int num_rsp = *((__u8 *) skb->data);
1748
1749 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1750
1751 if (!num_rsp)
1752 return;
1753
1754 hci_dev_lock(hdev);
1755
1756 for (; num_rsp; num_rsp--) {
1757 bacpy(&data.bdaddr, &info->bdaddr);
1758 data.pscan_rep_mode = info->pscan_rep_mode;
1759 data.pscan_period_mode = info->pscan_period_mode;
1760 data.pscan_mode = 0x00;
1761 memcpy(data.dev_class, info->dev_class, 3);
1762 data.clock_offset = info->clock_offset;
1763 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001764 data.ssp_mode = 0x01;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001765 info++;
1766 hci_inquiry_cache_update(hdev, &data);
1767 }
1768
1769 hci_dev_unlock(hdev);
1770}
1771
Marcel Holtmann04936842008-07-14 20:13:48 +02001772static inline void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1773{
1774 struct hci_ev_io_capa_request *ev = (void *) skb->data;
1775 struct hci_conn *conn;
1776
1777 BT_DBG("%s", hdev->name);
1778
1779 hci_dev_lock(hdev);
1780
1781 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1782 if (conn)
1783 hci_conn_hold(conn);
1784
1785 hci_dev_unlock(hdev);
1786}
1787
1788static inline void hci_simple_pair_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1789{
1790 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
1791 struct hci_conn *conn;
1792
1793 BT_DBG("%s", hdev->name);
1794
1795 hci_dev_lock(hdev);
1796
1797 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1798 if (conn)
1799 hci_conn_put(conn);
1800
1801 hci_dev_unlock(hdev);
1802}
1803
Marcel Holtmann41a96212008-07-14 20:13:48 +02001804static inline void hci_remote_host_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1805{
1806 struct hci_ev_remote_host_features *ev = (void *) skb->data;
1807 struct inquiry_entry *ie;
1808
1809 BT_DBG("%s", hdev->name);
1810
1811 hci_dev_lock(hdev);
1812
1813 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))
1814 ie->data.ssp_mode = (ev->features[0] & 0x01);
1815
1816 hci_dev_unlock(hdev);
1817}
1818
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1820{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001821 struct hci_event_hdr *hdr = (void *) skb->data;
1822 __u8 event = hdr->evt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823
1824 skb_pull(skb, HCI_EVENT_HDR_SIZE);
1825
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001826 switch (event) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 case HCI_EV_INQUIRY_COMPLETE:
1828 hci_inquiry_complete_evt(hdev, skb);
1829 break;
1830
1831 case HCI_EV_INQUIRY_RESULT:
1832 hci_inquiry_result_evt(hdev, skb);
1833 break;
1834
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001835 case HCI_EV_CONN_COMPLETE:
1836 hci_conn_complete_evt(hdev, skb);
Marcel Holtmann21d9e302005-09-13 01:32:25 +02001837 break;
1838
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 case HCI_EV_CONN_REQUEST:
1840 hci_conn_request_evt(hdev, skb);
1841 break;
1842
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 case HCI_EV_DISCONN_COMPLETE:
1844 hci_disconn_complete_evt(hdev, skb);
1845 break;
1846
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 case HCI_EV_AUTH_COMPLETE:
1848 hci_auth_complete_evt(hdev, skb);
1849 break;
1850
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001851 case HCI_EV_REMOTE_NAME:
1852 hci_remote_name_evt(hdev, skb);
1853 break;
1854
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 case HCI_EV_ENCRYPT_CHANGE:
1856 hci_encrypt_change_evt(hdev, skb);
1857 break;
1858
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001859 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
1860 hci_change_link_key_complete_evt(hdev, skb);
1861 break;
1862
1863 case HCI_EV_REMOTE_FEATURES:
1864 hci_remote_features_evt(hdev, skb);
1865 break;
1866
1867 case HCI_EV_REMOTE_VERSION:
1868 hci_remote_version_evt(hdev, skb);
1869 break;
1870
1871 case HCI_EV_QOS_SETUP_COMPLETE:
1872 hci_qos_setup_complete_evt(hdev, skb);
1873 break;
1874
1875 case HCI_EV_CMD_COMPLETE:
1876 hci_cmd_complete_evt(hdev, skb);
1877 break;
1878
1879 case HCI_EV_CMD_STATUS:
1880 hci_cmd_status_evt(hdev, skb);
1881 break;
1882
1883 case HCI_EV_ROLE_CHANGE:
1884 hci_role_change_evt(hdev, skb);
1885 break;
1886
1887 case HCI_EV_NUM_COMP_PKTS:
1888 hci_num_comp_pkts_evt(hdev, skb);
1889 break;
1890
1891 case HCI_EV_MODE_CHANGE:
1892 hci_mode_change_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 break;
1894
1895 case HCI_EV_PIN_CODE_REQ:
1896 hci_pin_code_request_evt(hdev, skb);
1897 break;
1898
1899 case HCI_EV_LINK_KEY_REQ:
1900 hci_link_key_request_evt(hdev, skb);
1901 break;
1902
1903 case HCI_EV_LINK_KEY_NOTIFY:
1904 hci_link_key_notify_evt(hdev, skb);
1905 break;
1906
1907 case HCI_EV_CLOCK_OFFSET:
1908 hci_clock_offset_evt(hdev, skb);
1909 break;
1910
Marcel Holtmanna8746412008-07-14 20:13:46 +02001911 case HCI_EV_PKT_TYPE_CHANGE:
1912 hci_pkt_type_change_evt(hdev, skb);
1913 break;
1914
Marcel Holtmann85a1e932005-08-09 20:28:02 -07001915 case HCI_EV_PSCAN_REP_MODE:
1916 hci_pscan_rep_mode_evt(hdev, skb);
1917 break;
1918
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001919 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1920 hci_inquiry_result_with_rssi_evt(hdev, skb);
1921 break;
1922
1923 case HCI_EV_REMOTE_EXT_FEATURES:
1924 hci_remote_ext_features_evt(hdev, skb);
1925 break;
1926
1927 case HCI_EV_SYNC_CONN_COMPLETE:
1928 hci_sync_conn_complete_evt(hdev, skb);
1929 break;
1930
1931 case HCI_EV_SYNC_CONN_CHANGED:
1932 hci_sync_conn_changed_evt(hdev, skb);
1933 break;
1934
Marcel Holtmann04837f62006-07-03 10:02:33 +02001935 case HCI_EV_SNIFF_SUBRATE:
1936 hci_sniff_subrate_evt(hdev, skb);
1937 break;
1938
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001939 case HCI_EV_EXTENDED_INQUIRY_RESULT:
1940 hci_extended_inquiry_result_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 break;
1942
Marcel Holtmann04936842008-07-14 20:13:48 +02001943 case HCI_EV_IO_CAPA_REQUEST:
1944 hci_io_capa_request_evt(hdev, skb);
1945 break;
1946
1947 case HCI_EV_SIMPLE_PAIR_COMPLETE:
1948 hci_simple_pair_complete_evt(hdev, skb);
1949 break;
1950
Marcel Holtmann41a96212008-07-14 20:13:48 +02001951 case HCI_EV_REMOTE_HOST_FEATURES:
1952 hci_remote_host_features_evt(hdev, skb);
1953 break;
1954
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001955 default:
1956 BT_DBG("%s event 0x%x", hdev->name, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 break;
1958 }
1959
1960 kfree_skb(skb);
1961 hdev->stat.evt_rx++;
1962}
1963
1964/* Generate internal stack event */
1965void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1966{
1967 struct hci_event_hdr *hdr;
1968 struct hci_ev_stack_internal *ev;
1969 struct sk_buff *skb;
1970
1971 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1972 if (!skb)
1973 return;
1974
1975 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1976 hdr->evt = HCI_EV_STACK_INTERNAL;
1977 hdr->plen = sizeof(*ev) + dlen;
1978
1979 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
1980 ev->type = type;
1981 memcpy(ev->data, data, dlen);
1982
Marcel Holtmann576c7d82005-08-06 12:36:54 +02001983 bt_cb(skb)->incoming = 1;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001984 __net_timestamp(skb);
Marcel Holtmann576c7d82005-08-06 12:36:54 +02001985
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001986 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 skb->dev = (void *) hdev;
1988 hci_send_to_sock(hdev, skb);
1989 kfree_skb(skb);
1990}