blob: ad7a553d77131c469bf4c9ebc3bc8bbfe84d1a33 [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
48#ifndef CONFIG_BT_HCI_CORE_DEBUG
49#undef BT_DBG
50#define BT_DBG(D...)
51#endif
52
53/* Handle HCI Event packets */
54
Marcel Holtmanna9de9242007-10-20 13:33:56 +020055static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070056{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020057 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Marcel Holtmanna9de9242007-10-20 13:33:56 +020059 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Marcel Holtmanna9de9242007-10-20 13:33:56 +020061 if (status)
62 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Marcel Holtmanna9de9242007-10-20 13:33:56 +020064 clear_bit(HCI_INQUIRY, &hdev->flags);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010065
Marcel Holtmanna9de9242007-10-20 13:33:56 +020066 hci_req_complete(hdev, status);
Marcel Holtmann6bd57412006-11-18 22:14:22 +010067
Marcel Holtmanna9de9242007-10-20 13:33:56 +020068 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069}
70
Marcel Holtmanna9de9242007-10-20 13:33:56 +020071static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070072{
Marcel Holtmanna9de9242007-10-20 13:33:56 +020073 __u8 status = *((__u8 *) skb->data);
74
75 BT_DBG("%s status 0x%x", hdev->name, status);
76
77 if (status)
78 return;
79
80 clear_bit(HCI_INQUIRY, &hdev->flags);
81
82 hci_conn_check_pending(hdev);
83}
84
85static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev, struct sk_buff *skb)
86{
87 BT_DBG("%s", hdev->name);
88}
89
90static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb)
91{
92 struct hci_rp_role_discovery *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Marcel Holtmanna9de9242007-10-20 13:33:56 +020095 BT_DBG("%s status 0x%x", hdev->name, rp->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Marcel Holtmanna9de9242007-10-20 13:33:56 +020097 if (rp->status)
98 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200100 hci_dev_lock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200102 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
103 if (conn) {
104 if (rp->role)
105 conn->link_mode &= ~HCI_LM_MASTER;
106 else
107 conn->link_mode |= HCI_LM_MASTER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200109
110 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111}
112
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200113static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
114{
115 struct hci_rp_read_link_policy *rp = (void *) skb->data;
116 struct hci_conn *conn;
117
118 BT_DBG("%s status 0x%x", hdev->name, rp->status);
119
120 if (rp->status)
121 return;
122
123 hci_dev_lock(hdev);
124
125 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
126 if (conn)
127 conn->link_policy = __le16_to_cpu(rp->policy);
128
129 hci_dev_unlock(hdev);
130}
131
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200132static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200134 struct hci_rp_write_link_policy *rp = (void *) skb->data;
135 struct hci_conn *conn;
136 void *sent;
137
138 BT_DBG("%s status 0x%x", hdev->name, rp->status);
139
140 if (rp->status)
141 return;
142
143 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
144 if (!sent)
145 return;
146
147 hci_dev_lock(hdev);
148
149 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200150 if (conn)
Harvey Harrison83985312008-05-02 16:25:46 -0700151 conn->link_policy = get_unaligned_le16(sent + 2);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200152
153 hci_dev_unlock(hdev);
154}
155
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200156static void hci_cc_read_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
157{
158 struct hci_rp_read_def_link_policy *rp = (void *) skb->data;
159
160 BT_DBG("%s status 0x%x", hdev->name, rp->status);
161
162 if (rp->status)
163 return;
164
165 hdev->link_policy = __le16_to_cpu(rp->policy);
166}
167
168static void hci_cc_write_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
169{
170 __u8 status = *((__u8 *) skb->data);
171 void *sent;
172
173 BT_DBG("%s status 0x%x", hdev->name, status);
174
175 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
176 if (!sent)
177 return;
178
179 if (!status)
180 hdev->link_policy = get_unaligned_le16(sent);
181
182 hci_req_complete(hdev, status);
183}
184
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200185static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
186{
187 __u8 status = *((__u8 *) skb->data);
188
189 BT_DBG("%s status 0x%x", hdev->name, status);
190
191 hci_req_complete(hdev, status);
192}
193
194static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
195{
196 __u8 status = *((__u8 *) skb->data);
197 void *sent;
198
199 BT_DBG("%s status 0x%x", hdev->name, status);
200
Marcel Holtmannf383f272008-07-14 20:13:47 +0200201 if (status)
202 return;
203
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200204 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
205 if (!sent)
206 return;
207
Marcel Holtmannf383f272008-07-14 20:13:47 +0200208 memcpy(hdev->dev_name, sent, 248);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200209}
210
211static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
212{
213 struct hci_rp_read_local_name *rp = (void *) skb->data;
214
215 BT_DBG("%s status 0x%x", hdev->name, rp->status);
216
217 if (rp->status)
218 return;
219
220 memcpy(hdev->dev_name, rp->name, 248);
221}
222
223static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
224{
225 __u8 status = *((__u8 *) skb->data);
226 void *sent;
227
228 BT_DBG("%s status 0x%x", hdev->name, status);
229
230 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
231 if (!sent)
232 return;
233
234 if (!status) {
235 __u8 param = *((__u8 *) sent);
236
237 if (param == AUTH_ENABLED)
238 set_bit(HCI_AUTH, &hdev->flags);
239 else
240 clear_bit(HCI_AUTH, &hdev->flags);
241 }
242
243 hci_req_complete(hdev, status);
244}
245
246static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
247{
248 __u8 status = *((__u8 *) skb->data);
249 void *sent;
250
251 BT_DBG("%s status 0x%x", hdev->name, status);
252
253 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
254 if (!sent)
255 return;
256
257 if (!status) {
258 __u8 param = *((__u8 *) sent);
259
260 if (param)
261 set_bit(HCI_ENCRYPT, &hdev->flags);
262 else
263 clear_bit(HCI_ENCRYPT, &hdev->flags);
264 }
265
266 hci_req_complete(hdev, status);
267}
268
269static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
270{
271 __u8 status = *((__u8 *) skb->data);
272 void *sent;
273
274 BT_DBG("%s status 0x%x", hdev->name, status);
275
276 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
277 if (!sent)
278 return;
279
280 if (!status) {
281 __u8 param = *((__u8 *) sent);
282
283 clear_bit(HCI_PSCAN, &hdev->flags);
284 clear_bit(HCI_ISCAN, &hdev->flags);
285
286 if (param & SCAN_INQUIRY)
287 set_bit(HCI_ISCAN, &hdev->flags);
288
289 if (param & SCAN_PAGE)
290 set_bit(HCI_PSCAN, &hdev->flags);
291 }
292
293 hci_req_complete(hdev, status);
294}
295
296static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
297{
298 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
299
300 BT_DBG("%s status 0x%x", hdev->name, rp->status);
301
302 if (rp->status)
303 return;
304
305 memcpy(hdev->dev_class, rp->dev_class, 3);
306
307 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
308 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
309}
310
311static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
312{
313 __u8 status = *((__u8 *) skb->data);
314 void *sent;
315
316 BT_DBG("%s status 0x%x", hdev->name, status);
317
Marcel Holtmannf383f272008-07-14 20:13:47 +0200318 if (status)
319 return;
320
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200321 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
322 if (!sent)
323 return;
324
Marcel Holtmannf383f272008-07-14 20:13:47 +0200325 memcpy(hdev->dev_class, sent, 3);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200326}
327
328static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
329{
330 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 __u16 setting;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200332
333 BT_DBG("%s status 0x%x", hdev->name, rp->status);
334
335 if (rp->status)
336 return;
337
338 setting = __le16_to_cpu(rp->voice_setting);
339
Marcel Holtmannf383f272008-07-14 20:13:47 +0200340 if (hdev->voice_setting == setting)
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200341 return;
342
343 hdev->voice_setting = setting;
344
345 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
346
347 if (hdev->notify) {
348 tasklet_disable(&hdev->tx_task);
349 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
350 tasklet_enable(&hdev->tx_task);
351 }
352}
353
354static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
355{
356 __u8 status = *((__u8 *) skb->data);
Marcel Holtmannf383f272008-07-14 20:13:47 +0200357 __u16 setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 void *sent;
359
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200360 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Marcel Holtmannf383f272008-07-14 20:13:47 +0200362 if (status)
363 return;
364
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200365 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
366 if (!sent)
367 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
Marcel Holtmannf383f272008-07-14 20:13:47 +0200369 setting = get_unaligned_le16(sent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
Marcel Holtmannf383f272008-07-14 20:13:47 +0200371 if (hdev->voice_setting == setting)
372 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Marcel Holtmannf383f272008-07-14 20:13:47 +0200374 hdev->voice_setting = setting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
Marcel Holtmannf383f272008-07-14 20:13:47 +0200376 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
377
378 if (hdev->notify) {
379 tasklet_disable(&hdev->tx_task);
380 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
381 tasklet_enable(&hdev->tx_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 }
383}
384
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200385static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200387 __u8 status = *((__u8 *) skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200389 BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200391 hci_req_complete(hdev, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392}
393
Marcel Holtmann333140b2008-07-14 20:13:48 +0200394static void hci_cc_read_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
395{
396 struct hci_rp_read_ssp_mode *rp = (void *) skb->data;
397
398 BT_DBG("%s status 0x%x", hdev->name, rp->status);
399
400 if (rp->status)
401 return;
402
403 hdev->ssp_mode = rp->mode;
404}
405
406static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
407{
408 __u8 status = *((__u8 *) skb->data);
409 void *sent;
410
411 BT_DBG("%s status 0x%x", hdev->name, status);
412
413 if (status)
414 return;
415
416 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
417 if (!sent)
418 return;
419
420 hdev->ssp_mode = *((__u8 *) sent);
421}
422
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200423static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
424{
425 struct hci_rp_read_local_version *rp = (void *) skb->data;
426
427 BT_DBG("%s status 0x%x", hdev->name, rp->status);
428
429 if (rp->status)
430 return;
431
432 hdev->hci_ver = rp->hci_ver;
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200433 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
434 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200435
436 BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
437 hdev->manufacturer,
438 hdev->hci_ver, hdev->hci_rev);
439}
440
441static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb)
442{
443 struct hci_rp_read_local_commands *rp = (void *) skb->data;
444
445 BT_DBG("%s status 0x%x", hdev->name, rp->status);
446
447 if (rp->status)
448 return;
449
450 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
451}
452
453static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb)
454{
455 struct hci_rp_read_local_features *rp = (void *) skb->data;
456
457 BT_DBG("%s status 0x%x", hdev->name, rp->status);
458
459 if (rp->status)
460 return;
461
462 memcpy(hdev->features, rp->features, 8);
463
464 /* Adjust default settings according to features
465 * supported by device. */
466
467 if (hdev->features[0] & LMP_3SLOT)
468 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
469
470 if (hdev->features[0] & LMP_5SLOT)
471 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
472
473 if (hdev->features[1] & LMP_HV2) {
474 hdev->pkt_type |= (HCI_HV2);
475 hdev->esco_type |= (ESCO_HV2);
476 }
477
478 if (hdev->features[1] & LMP_HV3) {
479 hdev->pkt_type |= (HCI_HV3);
480 hdev->esco_type |= (ESCO_HV3);
481 }
482
483 if (hdev->features[3] & LMP_ESCO)
484 hdev->esco_type |= (ESCO_EV3);
485
486 if (hdev->features[4] & LMP_EV4)
487 hdev->esco_type |= (ESCO_EV4);
488
489 if (hdev->features[4] & LMP_EV5)
490 hdev->esco_type |= (ESCO_EV5);
491
492 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
493 hdev->features[0], hdev->features[1],
494 hdev->features[2], hdev->features[3],
495 hdev->features[4], hdev->features[5],
496 hdev->features[6], hdev->features[7]);
497}
498
499static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
500{
501 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
502
503 BT_DBG("%s status 0x%x", hdev->name, rp->status);
504
505 if (rp->status)
506 return;
507
508 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
509 hdev->sco_mtu = rp->sco_mtu;
510 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
511 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
512
513 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
514 hdev->sco_mtu = 64;
515 hdev->sco_pkts = 8;
516 }
517
518 hdev->acl_cnt = hdev->acl_pkts;
519 hdev->sco_cnt = hdev->sco_pkts;
520
521 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
522 hdev->acl_mtu, hdev->acl_pkts,
523 hdev->sco_mtu, hdev->sco_pkts);
524}
525
526static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
527{
528 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
529
530 BT_DBG("%s status 0x%x", hdev->name, rp->status);
531
532 if (!rp->status)
533 bacpy(&hdev->bdaddr, &rp->bdaddr);
534
535 hci_req_complete(hdev, rp->status);
536}
537
538static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
539{
540 BT_DBG("%s status 0x%x", hdev->name, status);
541
542 if (status) {
543 hci_req_complete(hdev, status);
544
545 hci_conn_check_pending(hdev);
546 } else
547 set_bit(HCI_INQUIRY, &hdev->flags);
548}
549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
551{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200552 struct hci_cp_create_conn *cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200555 BT_DBG("%s status 0x%x", hdev->name, status);
556
557 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 if (!cp)
559 return;
560
561 hci_dev_lock(hdev);
562
563 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
564
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200565 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
567 if (status) {
568 if (conn && conn->state == BT_CONNECT) {
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200569 if (status != 0x0c || conn->attempt > 2) {
570 conn->state = BT_CLOSED;
571 hci_proto_connect_cfm(conn, status);
572 hci_conn_del(conn);
573 } else
574 conn->state = BT_CONNECT2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 }
576 } else {
577 if (!conn) {
578 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
579 if (conn) {
580 conn->out = 1;
581 conn->link_mode |= HCI_LM_MASTER;
582 } else
583 BT_ERR("No memmory for new connection");
584 }
585 }
586
587 hci_dev_unlock(hdev);
588}
589
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200590static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200592 struct hci_cp_add_sco *cp;
593 struct hci_conn *acl, *sco;
594 __u16 handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200596 BT_DBG("%s status 0x%x", hdev->name, status);
597
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200598 if (!status)
599 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200601 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
602 if (!cp)
603 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200605 handle = __le16_to_cpu(cp->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200607 BT_DBG("%s handle %d", hdev->name, handle);
Marcel Holtmann6bd57412006-11-18 22:14:22 +0100608
609 hci_dev_lock(hdev);
610
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200611 acl = hci_conn_hash_lookup_handle(hdev, handle);
612 if (acl && (sco = acl->link)) {
613 sco->state = BT_CLOSED;
614
615 hci_proto_connect_cfm(sco, status);
616 hci_conn_del(sco);
617 }
Marcel Holtmann6bd57412006-11-18 22:14:22 +0100618
619 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620}
621
Marcel Holtmannf8558552008-07-14 20:13:49 +0200622static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
623{
624 struct hci_cp_auth_requested *cp;
625 struct hci_conn *conn;
626
627 BT_DBG("%s status 0x%x", hdev->name, status);
628
629 if (!status)
630 return;
631
632 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
633 if (!cp)
634 return;
635
636 hci_dev_lock(hdev);
637
638 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
639 if (conn) {
640 if (conn->state == BT_CONFIG) {
641 hci_proto_connect_cfm(conn, status);
642 hci_conn_put(conn);
643 }
644 }
645
646 hci_dev_unlock(hdev);
647}
648
649static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
650{
651 struct hci_cp_set_conn_encrypt *cp;
652 struct hci_conn *conn;
653
654 BT_DBG("%s status 0x%x", hdev->name, status);
655
656 if (!status)
657 return;
658
659 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
660 if (!cp)
661 return;
662
663 hci_dev_lock(hdev);
664
665 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
666 if (conn) {
667 if (conn->state == BT_CONFIG) {
668 hci_proto_connect_cfm(conn, status);
669 hci_conn_put(conn);
670 }
671 }
672
673 hci_dev_unlock(hdev);
674}
675
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200676static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
677{
678 BT_DBG("%s status 0x%x", hdev->name, status);
679}
680
Marcel Holtmann769be972008-07-14 20:13:49 +0200681static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
682{
683 struct hci_cp_read_remote_features *cp;
684 struct hci_conn *conn;
685
686 BT_DBG("%s status 0x%x", hdev->name, status);
687
688 if (!status)
689 return;
690
691 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
692 if (!cp)
693 return;
694
695 hci_dev_lock(hdev);
696
697 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
698 if (conn) {
699 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +0200700 hci_proto_connect_cfm(conn, status);
701 hci_conn_put(conn);
702 }
703 }
704
705 hci_dev_unlock(hdev);
706}
707
708static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
709{
710 struct hci_cp_read_remote_ext_features *cp;
711 struct hci_conn *conn;
712
713 BT_DBG("%s status 0x%x", hdev->name, status);
714
715 if (!status)
716 return;
717
718 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
719 if (!cp)
720 return;
721
722 hci_dev_lock(hdev);
723
724 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
725 if (conn) {
726 if (conn->state == BT_CONFIG) {
Marcel Holtmann769be972008-07-14 20:13:49 +0200727 hci_proto_connect_cfm(conn, status);
728 hci_conn_put(conn);
729 }
730 }
731
732 hci_dev_unlock(hdev);
733}
734
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200735static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
736{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200737 struct hci_cp_setup_sync_conn *cp;
738 struct hci_conn *acl, *sco;
739 __u16 handle;
740
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200741 BT_DBG("%s status 0x%x", hdev->name, status);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200742
743 if (!status)
744 return;
745
746 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
747 if (!cp)
748 return;
749
750 handle = __le16_to_cpu(cp->handle);
751
752 BT_DBG("%s handle %d", hdev->name, handle);
753
754 hci_dev_lock(hdev);
755
756 acl = hci_conn_hash_lookup_handle(hdev, handle);
757 if (acl && (sco = acl->link)) {
758 sco->state = BT_CLOSED;
759
760 hci_proto_connect_cfm(sco, status);
761 hci_conn_del(sco);
762 }
763
764 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200765}
766
767static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
768{
769 struct hci_cp_sniff_mode *cp;
770 struct hci_conn *conn;
771
772 BT_DBG("%s status 0x%x", hdev->name, status);
773
774 if (!status)
775 return;
776
777 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
778 if (!cp)
779 return;
780
781 hci_dev_lock(hdev);
782
783 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
784 if (conn)
785 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
786
787 hci_dev_unlock(hdev);
788}
789
790static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
791{
792 struct hci_cp_exit_sniff_mode *cp;
793 struct hci_conn *conn;
794
795 BT_DBG("%s status 0x%x", hdev->name, status);
796
797 if (!status)
798 return;
799
800 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
801 if (!cp)
802 return;
803
804 hci_dev_lock(hdev);
805
806 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
807 if (conn)
808 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
809
810 hci_dev_unlock(hdev);
811}
812
813static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
814{
815 __u8 status = *((__u8 *) skb->data);
816
817 BT_DBG("%s status %d", hdev->name, status);
818
819 clear_bit(HCI_INQUIRY, &hdev->flags);
820
821 hci_req_complete(hdev, status);
822
823 hci_conn_check_pending(hdev);
824}
825
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
827{
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700828 struct inquiry_data data;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200829 struct inquiry_info *info = (void *) (skb->data + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 int num_rsp = *((__u8 *) skb->data);
831
832 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
833
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700834 if (!num_rsp)
835 return;
836
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700838
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 for (; num_rsp; num_rsp--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 bacpy(&data.bdaddr, &info->bdaddr);
841 data.pscan_rep_mode = info->pscan_rep_mode;
842 data.pscan_period_mode = info->pscan_period_mode;
843 data.pscan_mode = info->pscan_mode;
844 memcpy(data.dev_class, info->dev_class, 3);
845 data.clock_offset = info->clock_offset;
846 data.rssi = 0x00;
Marcel Holtmann41a96212008-07-14 20:13:48 +0200847 data.ssp_mode = 0x00;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 info++;
849 hci_inquiry_cache_update(hdev, &data);
850 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700851
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 hci_dev_unlock(hdev);
853}
854
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200855static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200857 struct hci_ev_conn_complete *ev = (void *) skb->data;
858 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200860 BT_DBG("%s", hdev->name);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700861
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 hci_dev_lock(hdev);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700863
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200864 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
865 if (!conn)
866 goto unlock;
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700867
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200868 if (!ev->status) {
869 conn->handle = __le16_to_cpu(ev->handle);
Marcel Holtmann769be972008-07-14 20:13:49 +0200870
871 if (conn->type == ACL_LINK) {
872 conn->state = BT_CONFIG;
873 hci_conn_hold(conn);
874 } else
875 conn->state = BT_CONNECTED;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200876
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200877 hci_conn_add_sysfs(conn);
878
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200879 if (test_bit(HCI_AUTH, &hdev->flags))
880 conn->link_mode |= HCI_LM_AUTH;
881
882 if (test_bit(HCI_ENCRYPT, &hdev->flags))
883 conn->link_mode |= HCI_LM_ENCRYPT;
884
885 /* Get remote features */
886 if (conn->type == ACL_LINK) {
887 struct hci_cp_read_remote_features cp;
888 cp.handle = ev->handle;
Marcel Holtmann769be972008-07-14 20:13:49 +0200889 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
890 sizeof(cp), &cp);
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700891 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700892
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200893 /* Set packet type for incoming connection */
Marcel Holtmanna8746412008-07-14 20:13:46 +0200894 if (!conn->out && hdev->hci_ver < 3) {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200895 struct hci_cp_change_conn_ptype cp;
896 cp.handle = ev->handle;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200897 cp.pkt_type = cpu_to_le16(conn->pkt_type);
898 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
899 sizeof(cp), &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200900 }
901 } else
902 conn->state = BT_CLOSED;
903
904 if (conn->type == ACL_LINK) {
905 struct hci_conn *sco = conn->link;
906 if (sco) {
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200907 if (!ev->status) {
908 if (lmp_esco_capable(hdev))
909 hci_setup_sync(sco, conn->handle);
910 else
911 hci_add_sco(sco, conn->handle);
912 } else {
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200913 hci_proto_connect_cfm(sco, ev->status);
914 hci_conn_del(sco);
915 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700916 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 }
Marcel Holtmann45bb4bf2005-08-09 20:27:49 -0700918
Marcel Holtmann769be972008-07-14 20:13:49 +0200919 if (ev->status) {
920 hci_proto_connect_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200921 hci_conn_del(conn);
Marcel Holtmann769be972008-07-14 20:13:49 +0200922 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200923
924unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200926
927 hci_conn_check_pending(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928}
929
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
931{
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200932 struct hci_ev_conn_request *ev = (void *) skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 int mask = hdev->link_mode;
934
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200935 BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
936 batostr(&ev->bdaddr), ev->link_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
938 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
939
940 if (mask & HCI_LM_ACCEPT) {
941 /* Connection accepted */
Marcel Holtmannc7bdd502008-07-14 20:13:47 +0200942 struct inquiry_entry *ie;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
945 hci_dev_lock(hdev);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200946
Marcel Holtmannc7bdd502008-07-14 20:13:47 +0200947 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))
948 memcpy(ie->data.dev_class, ev->dev_class, 3);
949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
951 if (!conn) {
952 if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
953 BT_ERR("No memmory for new connection");
954 hci_dev_unlock(hdev);
955 return;
956 }
957 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200958
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 memcpy(conn->dev_class, ev->dev_class, 3);
960 conn->state = BT_CONNECT;
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200961
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 hci_dev_unlock(hdev);
963
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200964 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
965 struct hci_cp_accept_conn_req cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200967 bacpy(&cp.bdaddr, &ev->bdaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200969 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
970 cp.role = 0x00; /* Become master */
971 else
972 cp.role = 0x01; /* Remain slave */
973
974 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
975 sizeof(cp), &cp);
976 } else {
977 struct hci_cp_accept_sync_conn_req cp;
978
979 bacpy(&cp.bdaddr, &ev->bdaddr);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200980 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200981
982 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
983 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
984 cp.max_latency = cpu_to_le16(0xffff);
985 cp.content_format = cpu_to_le16(hdev->voice_setting);
986 cp.retrans_effort = 0xff;
987
988 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
989 sizeof(cp), &cp);
990 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 } else {
992 /* Connection rejected */
993 struct hci_cp_reject_conn_req cp;
994
995 bacpy(&cp.bdaddr, &ev->bdaddr);
996 cp.reason = 0x0f;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200997 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 }
999}
1000
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1002{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001003 struct hci_ev_disconn_complete *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001004 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
1006 BT_DBG("%s status %d", hdev->name, ev->status);
1007
1008 if (ev->status)
1009 return;
1010
1011 hci_dev_lock(hdev);
1012
Marcel Holtmann04837f62006-07-03 10:02:33 +02001013 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 if (conn) {
1015 conn->state = BT_CLOSED;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001016
1017 hci_conn_del_sysfs(conn);
1018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 hci_proto_disconn_ind(conn, ev->reason);
1020 hci_conn_del(conn);
1021 }
1022
1023 hci_dev_unlock(hdev);
1024}
1025
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001026static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1027{
1028 struct hci_ev_auth_complete *ev = (void *) skb->data;
1029 struct hci_conn *conn;
1030
1031 BT_DBG("%s status %d", hdev->name, ev->status);
1032
1033 hci_dev_lock(hdev);
1034
1035 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1036 if (conn) {
1037 if (!ev->status)
1038 conn->link_mode |= HCI_LM_AUTH;
1039
1040 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1041
Marcel Holtmannf8558552008-07-14 20:13:49 +02001042 if (conn->state == BT_CONFIG) {
1043 if (!ev->status && hdev->ssp_mode > 0 &&
1044 conn->ssp_mode > 0) {
1045 struct hci_cp_set_conn_encrypt cp;
1046 cp.handle = ev->handle;
1047 cp.encrypt = 0x01;
1048 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1049 sizeof(cp), &cp);
1050 } else {
1051 conn->state = BT_CONNECTED;
1052 hci_proto_connect_cfm(conn, ev->status);
1053 hci_conn_put(conn);
1054 }
1055 } else
1056 hci_auth_cfm(conn, ev->status);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001057
1058 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
1059 if (!ev->status) {
1060 struct hci_cp_set_conn_encrypt cp;
Marcel Holtmannf8558552008-07-14 20:13:49 +02001061 cp.handle = ev->handle;
1062 cp.encrypt = 0x01;
1063 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1064 sizeof(cp), &cp);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001065 } else {
1066 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1067 hci_encrypt_cfm(conn, ev->status, 0x00);
1068 }
1069 }
1070 }
1071
1072 hci_dev_unlock(hdev);
1073}
1074
1075static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
1076{
1077 BT_DBG("%s", hdev->name);
1078
1079 hci_conn_check_pending(hdev);
1080}
1081
1082static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1083{
1084 struct hci_ev_encrypt_change *ev = (void *) skb->data;
1085 struct hci_conn *conn;
1086
1087 BT_DBG("%s status %d", hdev->name, ev->status);
1088
1089 hci_dev_lock(hdev);
1090
1091 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1092 if (conn) {
1093 if (!ev->status) {
Marcel Holtmannae293192008-07-14 20:13:45 +02001094 if (ev->encrypt) {
1095 /* Encryption implies authentication */
1096 conn->link_mode |= HCI_LM_AUTH;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001097 conn->link_mode |= HCI_LM_ENCRYPT;
Marcel Holtmannae293192008-07-14 20:13:45 +02001098 } else
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001099 conn->link_mode &= ~HCI_LM_ENCRYPT;
1100 }
1101
1102 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1103
Marcel Holtmannf8558552008-07-14 20:13:49 +02001104 if (conn->state == BT_CONFIG) {
1105 if (!ev->status)
1106 conn->state = BT_CONNECTED;
1107
1108 hci_proto_connect_cfm(conn, ev->status);
1109 hci_conn_put(conn);
1110 } else
1111 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001112 }
1113
1114 hci_dev_unlock(hdev);
1115}
1116
1117static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1118{
1119 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
1120 struct hci_conn *conn;
1121
1122 BT_DBG("%s status %d", hdev->name, ev->status);
1123
1124 hci_dev_lock(hdev);
1125
1126 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1127 if (conn) {
1128 if (!ev->status)
1129 conn->link_mode |= HCI_LM_SECURE;
1130
1131 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1132
1133 hci_key_change_cfm(conn, ev->status);
1134 }
1135
1136 hci_dev_unlock(hdev);
1137}
1138
1139static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1140{
1141 struct hci_ev_remote_features *ev = (void *) skb->data;
1142 struct hci_conn *conn;
1143
1144 BT_DBG("%s status %d", hdev->name, ev->status);
1145
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001146 hci_dev_lock(hdev);
1147
1148 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Marcel Holtmann769be972008-07-14 20:13:49 +02001149 if (conn) {
1150 if (!ev->status)
1151 memcpy(conn->features, ev->features, 8);
1152
1153 if (conn->state == BT_CONFIG) {
1154 if (!ev->status && lmp_ssp_capable(hdev) &&
1155 lmp_ssp_capable(conn)) {
1156 struct hci_cp_read_remote_ext_features cp;
1157 cp.handle = ev->handle;
1158 cp.page = 0x01;
1159 hci_send_cmd(hdev,
1160 HCI_OP_READ_REMOTE_EXT_FEATURES,
1161 sizeof(cp), &cp);
1162 } else {
1163 conn->state = BT_CONNECTED;
1164 hci_proto_connect_cfm(conn, ev->status);
1165 hci_conn_put(conn);
1166 }
1167 }
1168 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001169
1170 hci_dev_unlock(hdev);
1171}
1172
1173static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
1174{
1175 BT_DBG("%s", hdev->name);
1176}
1177
1178static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1179{
1180 BT_DBG("%s", hdev->name);
1181}
1182
1183static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1184{
1185 struct hci_ev_cmd_complete *ev = (void *) skb->data;
1186 __u16 opcode;
1187
1188 skb_pull(skb, sizeof(*ev));
1189
1190 opcode = __le16_to_cpu(ev->opcode);
1191
1192 switch (opcode) {
1193 case HCI_OP_INQUIRY_CANCEL:
1194 hci_cc_inquiry_cancel(hdev, skb);
1195 break;
1196
1197 case HCI_OP_EXIT_PERIODIC_INQ:
1198 hci_cc_exit_periodic_inq(hdev, skb);
1199 break;
1200
1201 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
1202 hci_cc_remote_name_req_cancel(hdev, skb);
1203 break;
1204
1205 case HCI_OP_ROLE_DISCOVERY:
1206 hci_cc_role_discovery(hdev, skb);
1207 break;
1208
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001209 case HCI_OP_READ_LINK_POLICY:
1210 hci_cc_read_link_policy(hdev, skb);
1211 break;
1212
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001213 case HCI_OP_WRITE_LINK_POLICY:
1214 hci_cc_write_link_policy(hdev, skb);
1215 break;
1216
Marcel Holtmanne4e8e372008-07-14 20:13:47 +02001217 case HCI_OP_READ_DEF_LINK_POLICY:
1218 hci_cc_read_def_link_policy(hdev, skb);
1219 break;
1220
1221 case HCI_OP_WRITE_DEF_LINK_POLICY:
1222 hci_cc_write_def_link_policy(hdev, skb);
1223 break;
1224
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001225 case HCI_OP_RESET:
1226 hci_cc_reset(hdev, skb);
1227 break;
1228
1229 case HCI_OP_WRITE_LOCAL_NAME:
1230 hci_cc_write_local_name(hdev, skb);
1231 break;
1232
1233 case HCI_OP_READ_LOCAL_NAME:
1234 hci_cc_read_local_name(hdev, skb);
1235 break;
1236
1237 case HCI_OP_WRITE_AUTH_ENABLE:
1238 hci_cc_write_auth_enable(hdev, skb);
1239 break;
1240
1241 case HCI_OP_WRITE_ENCRYPT_MODE:
1242 hci_cc_write_encrypt_mode(hdev, skb);
1243 break;
1244
1245 case HCI_OP_WRITE_SCAN_ENABLE:
1246 hci_cc_write_scan_enable(hdev, skb);
1247 break;
1248
1249 case HCI_OP_READ_CLASS_OF_DEV:
1250 hci_cc_read_class_of_dev(hdev, skb);
1251 break;
1252
1253 case HCI_OP_WRITE_CLASS_OF_DEV:
1254 hci_cc_write_class_of_dev(hdev, skb);
1255 break;
1256
1257 case HCI_OP_READ_VOICE_SETTING:
1258 hci_cc_read_voice_setting(hdev, skb);
1259 break;
1260
1261 case HCI_OP_WRITE_VOICE_SETTING:
1262 hci_cc_write_voice_setting(hdev, skb);
1263 break;
1264
1265 case HCI_OP_HOST_BUFFER_SIZE:
1266 hci_cc_host_buffer_size(hdev, skb);
1267 break;
1268
Marcel Holtmann333140b2008-07-14 20:13:48 +02001269 case HCI_OP_READ_SSP_MODE:
1270 hci_cc_read_ssp_mode(hdev, skb);
1271 break;
1272
1273 case HCI_OP_WRITE_SSP_MODE:
1274 hci_cc_write_ssp_mode(hdev, skb);
1275 break;
1276
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001277 case HCI_OP_READ_LOCAL_VERSION:
1278 hci_cc_read_local_version(hdev, skb);
1279 break;
1280
1281 case HCI_OP_READ_LOCAL_COMMANDS:
1282 hci_cc_read_local_commands(hdev, skb);
1283 break;
1284
1285 case HCI_OP_READ_LOCAL_FEATURES:
1286 hci_cc_read_local_features(hdev, skb);
1287 break;
1288
1289 case HCI_OP_READ_BUFFER_SIZE:
1290 hci_cc_read_buffer_size(hdev, skb);
1291 break;
1292
1293 case HCI_OP_READ_BD_ADDR:
1294 hci_cc_read_bd_addr(hdev, skb);
1295 break;
1296
1297 default:
1298 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1299 break;
1300 }
1301
1302 if (ev->ncmd) {
1303 atomic_set(&hdev->cmd_cnt, 1);
1304 if (!skb_queue_empty(&hdev->cmd_q))
1305 hci_sched_cmd(hdev);
1306 }
1307}
1308
1309static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1310{
1311 struct hci_ev_cmd_status *ev = (void *) skb->data;
1312 __u16 opcode;
1313
1314 skb_pull(skb, sizeof(*ev));
1315
1316 opcode = __le16_to_cpu(ev->opcode);
1317
1318 switch (opcode) {
1319 case HCI_OP_INQUIRY:
1320 hci_cs_inquiry(hdev, ev->status);
1321 break;
1322
1323 case HCI_OP_CREATE_CONN:
1324 hci_cs_create_conn(hdev, ev->status);
1325 break;
1326
1327 case HCI_OP_ADD_SCO:
1328 hci_cs_add_sco(hdev, ev->status);
1329 break;
1330
Marcel Holtmannf8558552008-07-14 20:13:49 +02001331 case HCI_OP_AUTH_REQUESTED:
1332 hci_cs_auth_requested(hdev, ev->status);
1333 break;
1334
1335 case HCI_OP_SET_CONN_ENCRYPT:
1336 hci_cs_set_conn_encrypt(hdev, ev->status);
1337 break;
1338
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001339 case HCI_OP_REMOTE_NAME_REQ:
1340 hci_cs_remote_name_req(hdev, ev->status);
1341 break;
1342
Marcel Holtmann769be972008-07-14 20:13:49 +02001343 case HCI_OP_READ_REMOTE_FEATURES:
1344 hci_cs_read_remote_features(hdev, ev->status);
1345 break;
1346
1347 case HCI_OP_READ_REMOTE_EXT_FEATURES:
1348 hci_cs_read_remote_ext_features(hdev, ev->status);
1349 break;
1350
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001351 case HCI_OP_SETUP_SYNC_CONN:
1352 hci_cs_setup_sync_conn(hdev, ev->status);
1353 break;
1354
1355 case HCI_OP_SNIFF_MODE:
1356 hci_cs_sniff_mode(hdev, ev->status);
1357 break;
1358
1359 case HCI_OP_EXIT_SNIFF_MODE:
1360 hci_cs_exit_sniff_mode(hdev, ev->status);
1361 break;
1362
1363 default:
1364 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1365 break;
1366 }
1367
1368 if (ev->ncmd) {
1369 atomic_set(&hdev->cmd_cnt, 1);
1370 if (!skb_queue_empty(&hdev->cmd_q))
1371 hci_sched_cmd(hdev);
1372 }
1373}
1374
1375static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1376{
1377 struct hci_ev_role_change *ev = (void *) skb->data;
1378 struct hci_conn *conn;
1379
1380 BT_DBG("%s status %d", hdev->name, ev->status);
1381
1382 hci_dev_lock(hdev);
1383
1384 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1385 if (conn) {
1386 if (!ev->status) {
1387 if (ev->role)
1388 conn->link_mode &= ~HCI_LM_MASTER;
1389 else
1390 conn->link_mode |= HCI_LM_MASTER;
1391 }
1392
1393 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1394
1395 hci_role_switch_cfm(conn, ev->status, ev->role);
1396 }
1397
1398 hci_dev_unlock(hdev);
1399}
1400
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1402{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001403 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08001404 __le16 *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 int i;
1406
1407 skb_pull(skb, sizeof(*ev));
1408
1409 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1410
1411 if (skb->len < ev->num_hndl * 4) {
1412 BT_DBG("%s bad parameters", hdev->name);
1413 return;
1414 }
1415
1416 tasklet_disable(&hdev->tx_task);
1417
Marcel Holtmann1ebb9252005-11-08 09:57:21 -08001418 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 struct hci_conn *conn;
1420 __u16 handle, count;
1421
Harvey Harrison83985312008-05-02 16:25:46 -07001422 handle = get_unaligned_le16(ptr++);
1423 count = get_unaligned_le16(ptr++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424
1425 conn = hci_conn_hash_lookup_handle(hdev, handle);
1426 if (conn) {
1427 conn->sent -= count;
1428
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001429 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
1431 hdev->acl_cnt = hdev->acl_pkts;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001432 } else {
1433 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
1434 hdev->sco_cnt = hdev->sco_pkts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 }
1436 }
1437 }
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001438
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 hci_sched_tx(hdev);
1440
1441 tasklet_enable(&hdev->tx_task);
1442}
1443
Marcel Holtmann04837f62006-07-03 10:02:33 +02001444static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001446 struct hci_ev_mode_change *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001447 struct hci_conn *conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448
1449 BT_DBG("%s status %d", hdev->name, ev->status);
1450
1451 hci_dev_lock(hdev);
1452
Marcel Holtmann04837f62006-07-03 10:02:33 +02001453 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1454 if (conn) {
1455 conn->mode = ev->mode;
1456 conn->interval = __le16_to_cpu(ev->interval);
1457
1458 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1459 if (conn->mode == HCI_CM_ACTIVE)
1460 conn->power_save = 1;
1461 else
1462 conn->power_save = 0;
1463 }
1464 }
1465
1466 hci_dev_unlock(hdev);
1467}
1468
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469static inline void hci_pin_code_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_request_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
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1480{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001481 BT_DBG("%s", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482}
1483
Marcel Holtmann04837f62006-07-03 10:02:33 +02001484static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1485{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001486 struct hci_ev_clock_offset *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001487 struct hci_conn *conn;
1488
1489 BT_DBG("%s status %d", hdev->name, ev->status);
1490
1491 hci_dev_lock(hdev);
1492
1493 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 if (conn && !ev->status) {
1495 struct inquiry_entry *ie;
1496
1497 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1498 ie->data.clock_offset = ev->clock_offset;
1499 ie->timestamp = jiffies;
1500 }
1501 }
1502
1503 hci_dev_unlock(hdev);
1504}
1505
Marcel Holtmanna8746412008-07-14 20:13:46 +02001506static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1507{
1508 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
1509 struct hci_conn *conn;
1510
1511 BT_DBG("%s status %d", hdev->name, ev->status);
1512
1513 hci_dev_lock(hdev);
1514
1515 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1516 if (conn && !ev->status)
1517 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
1518
1519 hci_dev_unlock(hdev);
1520}
1521
Marcel Holtmann85a1e932005-08-09 20:28:02 -07001522static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1523{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001524 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
Marcel Holtmann85a1e932005-08-09 20:28:02 -07001525 struct inquiry_entry *ie;
1526
1527 BT_DBG("%s", hdev->name);
1528
1529 hci_dev_lock(hdev);
1530
1531 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1532 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1533 ie->timestamp = jiffies;
1534 }
1535
1536 hci_dev_unlock(hdev);
1537}
1538
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001539static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1540{
1541 struct inquiry_data data;
1542 int num_rsp = *((__u8 *) skb->data);
1543
1544 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1545
1546 if (!num_rsp)
1547 return;
1548
1549 hci_dev_lock(hdev);
1550
1551 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1552 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1553
1554 for (; num_rsp; num_rsp--) {
1555 bacpy(&data.bdaddr, &info->bdaddr);
1556 data.pscan_rep_mode = info->pscan_rep_mode;
1557 data.pscan_period_mode = info->pscan_period_mode;
1558 data.pscan_mode = info->pscan_mode;
1559 memcpy(data.dev_class, info->dev_class, 3);
1560 data.clock_offset = info->clock_offset;
1561 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001562 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001563 info++;
1564 hci_inquiry_cache_update(hdev, &data);
1565 }
1566 } else {
1567 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1568
1569 for (; num_rsp; num_rsp--) {
1570 bacpy(&data.bdaddr, &info->bdaddr);
1571 data.pscan_rep_mode = info->pscan_rep_mode;
1572 data.pscan_period_mode = info->pscan_period_mode;
1573 data.pscan_mode = 0x00;
1574 memcpy(data.dev_class, info->dev_class, 3);
1575 data.clock_offset = info->clock_offset;
1576 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001577 data.ssp_mode = 0x00;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001578 info++;
1579 hci_inquiry_cache_update(hdev, &data);
1580 }
1581 }
1582
1583 hci_dev_unlock(hdev);
1584}
1585
1586static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1587{
Marcel Holtmann41a96212008-07-14 20:13:48 +02001588 struct hci_ev_remote_ext_features *ev = (void *) skb->data;
1589 struct hci_conn *conn;
1590
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001591 BT_DBG("%s", hdev->name);
Marcel Holtmann41a96212008-07-14 20:13:48 +02001592
Marcel Holtmann41a96212008-07-14 20:13:48 +02001593 hci_dev_lock(hdev);
1594
1595 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1596 if (conn) {
Marcel Holtmann769be972008-07-14 20:13:49 +02001597 if (!ev->status && ev->page == 0x01) {
1598 struct inquiry_entry *ie;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001599
Marcel Holtmann769be972008-07-14 20:13:49 +02001600 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)))
1601 ie->data.ssp_mode = (ev->features[0] & 0x01);
Marcel Holtmann41a96212008-07-14 20:13:48 +02001602
Marcel Holtmann769be972008-07-14 20:13:49 +02001603 conn->ssp_mode = (ev->features[0] & 0x01);
1604 }
1605
1606 if (conn->state == BT_CONFIG) {
Marcel Holtmannf8558552008-07-14 20:13:49 +02001607 if (!ev->status && hdev->ssp_mode > 0 &&
Marcel Holtmannf1c08ca2008-09-09 07:19:19 +02001608 conn->ssp_mode > 0 && conn->out) {
1609 struct hci_cp_auth_requested cp;
1610 cp.handle = ev->handle;
1611 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED,
Marcel Holtmannf8558552008-07-14 20:13:49 +02001612 sizeof(cp), &cp);
Marcel Holtmannf8558552008-07-14 20:13:49 +02001613 } else {
1614 conn->state = BT_CONNECTED;
1615 hci_proto_connect_cfm(conn, ev->status);
1616 hci_conn_put(conn);
1617 }
Marcel Holtmann769be972008-07-14 20:13:49 +02001618 }
Marcel Holtmann41a96212008-07-14 20:13:48 +02001619 }
1620
1621 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001622}
1623
1624static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1625{
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001626 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1627 struct hci_conn *conn;
1628
1629 BT_DBG("%s status %d", hdev->name, ev->status);
1630
1631 hci_dev_lock(hdev);
1632
1633 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
Marcel Holtmann9dc0a3a2008-07-14 20:13:46 +02001634 if (!conn) {
1635 if (ev->link_type == ESCO_LINK)
1636 goto unlock;
1637
1638 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1639 if (!conn)
1640 goto unlock;
1641
1642 conn->type = SCO_LINK;
1643 }
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001644
1645 if (!ev->status) {
1646 conn->handle = __le16_to_cpu(ev->handle);
1647 conn->state = BT_CONNECTED;
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +02001648
1649 hci_conn_add_sysfs(conn);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001650 } else
1651 conn->state = BT_CLOSED;
1652
1653 hci_proto_connect_cfm(conn, ev->status);
1654 if (ev->status)
1655 hci_conn_del(conn);
1656
1657unlock:
1658 hci_dev_unlock(hdev);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001659}
1660
1661static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1662{
1663 BT_DBG("%s", hdev->name);
1664}
1665
Marcel Holtmann04837f62006-07-03 10:02:33 +02001666static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1667{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001668 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
Marcel Holtmann04837f62006-07-03 10:02:33 +02001669 struct hci_conn *conn;
1670
1671 BT_DBG("%s status %d", hdev->name, ev->status);
1672
1673 hci_dev_lock(hdev);
1674
1675 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1676 if (conn) {
1677 }
1678
1679 hci_dev_unlock(hdev);
1680}
1681
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001682static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1683{
1684 struct inquiry_data data;
1685 struct extended_inquiry_info *info = (void *) (skb->data + 1);
1686 int num_rsp = *((__u8 *) skb->data);
1687
1688 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1689
1690 if (!num_rsp)
1691 return;
1692
1693 hci_dev_lock(hdev);
1694
1695 for (; num_rsp; num_rsp--) {
1696 bacpy(&data.bdaddr, &info->bdaddr);
1697 data.pscan_rep_mode = info->pscan_rep_mode;
1698 data.pscan_period_mode = info->pscan_period_mode;
1699 data.pscan_mode = 0x00;
1700 memcpy(data.dev_class, info->dev_class, 3);
1701 data.clock_offset = info->clock_offset;
1702 data.rssi = info->rssi;
Marcel Holtmann41a96212008-07-14 20:13:48 +02001703 data.ssp_mode = 0x01;
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001704 info++;
1705 hci_inquiry_cache_update(hdev, &data);
1706 }
1707
1708 hci_dev_unlock(hdev);
1709}
1710
Marcel Holtmann04936842008-07-14 20:13:48 +02001711static inline void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1712{
1713 struct hci_ev_io_capa_request *ev = (void *) skb->data;
1714 struct hci_conn *conn;
1715
1716 BT_DBG("%s", hdev->name);
1717
1718 hci_dev_lock(hdev);
1719
1720 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1721 if (conn)
1722 hci_conn_hold(conn);
1723
1724 hci_dev_unlock(hdev);
1725}
1726
1727static inline void hci_simple_pair_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1728{
1729 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
1730 struct hci_conn *conn;
1731
1732 BT_DBG("%s", hdev->name);
1733
1734 hci_dev_lock(hdev);
1735
1736 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1737 if (conn)
1738 hci_conn_put(conn);
1739
1740 hci_dev_unlock(hdev);
1741}
1742
Marcel Holtmann41a96212008-07-14 20:13:48 +02001743static inline void hci_remote_host_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1744{
1745 struct hci_ev_remote_host_features *ev = (void *) skb->data;
1746 struct inquiry_entry *ie;
1747
1748 BT_DBG("%s", hdev->name);
1749
1750 hci_dev_lock(hdev);
1751
1752 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))
1753 ie->data.ssp_mode = (ev->features[0] & 0x01);
1754
1755 hci_dev_unlock(hdev);
1756}
1757
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1759{
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001760 struct hci_event_hdr *hdr = (void *) skb->data;
1761 __u8 event = hdr->evt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762
1763 skb_pull(skb, HCI_EVENT_HDR_SIZE);
1764
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001765 switch (event) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 case HCI_EV_INQUIRY_COMPLETE:
1767 hci_inquiry_complete_evt(hdev, skb);
1768 break;
1769
1770 case HCI_EV_INQUIRY_RESULT:
1771 hci_inquiry_result_evt(hdev, skb);
1772 break;
1773
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001774 case HCI_EV_CONN_COMPLETE:
1775 hci_conn_complete_evt(hdev, skb);
Marcel Holtmann21d9e302005-09-13 01:32:25 +02001776 break;
1777
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 case HCI_EV_CONN_REQUEST:
1779 hci_conn_request_evt(hdev, skb);
1780 break;
1781
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 case HCI_EV_DISCONN_COMPLETE:
1783 hci_disconn_complete_evt(hdev, skb);
1784 break;
1785
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 case HCI_EV_AUTH_COMPLETE:
1787 hci_auth_complete_evt(hdev, skb);
1788 break;
1789
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001790 case HCI_EV_REMOTE_NAME:
1791 hci_remote_name_evt(hdev, skb);
1792 break;
1793
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 case HCI_EV_ENCRYPT_CHANGE:
1795 hci_encrypt_change_evt(hdev, skb);
1796 break;
1797
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001798 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
1799 hci_change_link_key_complete_evt(hdev, skb);
1800 break;
1801
1802 case HCI_EV_REMOTE_FEATURES:
1803 hci_remote_features_evt(hdev, skb);
1804 break;
1805
1806 case HCI_EV_REMOTE_VERSION:
1807 hci_remote_version_evt(hdev, skb);
1808 break;
1809
1810 case HCI_EV_QOS_SETUP_COMPLETE:
1811 hci_qos_setup_complete_evt(hdev, skb);
1812 break;
1813
1814 case HCI_EV_CMD_COMPLETE:
1815 hci_cmd_complete_evt(hdev, skb);
1816 break;
1817
1818 case HCI_EV_CMD_STATUS:
1819 hci_cmd_status_evt(hdev, skb);
1820 break;
1821
1822 case HCI_EV_ROLE_CHANGE:
1823 hci_role_change_evt(hdev, skb);
1824 break;
1825
1826 case HCI_EV_NUM_COMP_PKTS:
1827 hci_num_comp_pkts_evt(hdev, skb);
1828 break;
1829
1830 case HCI_EV_MODE_CHANGE:
1831 hci_mode_change_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 break;
1833
1834 case HCI_EV_PIN_CODE_REQ:
1835 hci_pin_code_request_evt(hdev, skb);
1836 break;
1837
1838 case HCI_EV_LINK_KEY_REQ:
1839 hci_link_key_request_evt(hdev, skb);
1840 break;
1841
1842 case HCI_EV_LINK_KEY_NOTIFY:
1843 hci_link_key_notify_evt(hdev, skb);
1844 break;
1845
1846 case HCI_EV_CLOCK_OFFSET:
1847 hci_clock_offset_evt(hdev, skb);
1848 break;
1849
Marcel Holtmanna8746412008-07-14 20:13:46 +02001850 case HCI_EV_PKT_TYPE_CHANGE:
1851 hci_pkt_type_change_evt(hdev, skb);
1852 break;
1853
Marcel Holtmann85a1e932005-08-09 20:28:02 -07001854 case HCI_EV_PSCAN_REP_MODE:
1855 hci_pscan_rep_mode_evt(hdev, skb);
1856 break;
1857
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001858 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1859 hci_inquiry_result_with_rssi_evt(hdev, skb);
1860 break;
1861
1862 case HCI_EV_REMOTE_EXT_FEATURES:
1863 hci_remote_ext_features_evt(hdev, skb);
1864 break;
1865
1866 case HCI_EV_SYNC_CONN_COMPLETE:
1867 hci_sync_conn_complete_evt(hdev, skb);
1868 break;
1869
1870 case HCI_EV_SYNC_CONN_CHANGED:
1871 hci_sync_conn_changed_evt(hdev, skb);
1872 break;
1873
Marcel Holtmann04837f62006-07-03 10:02:33 +02001874 case HCI_EV_SNIFF_SUBRATE:
1875 hci_sniff_subrate_evt(hdev, skb);
1876 break;
1877
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001878 case HCI_EV_EXTENDED_INQUIRY_RESULT:
1879 hci_extended_inquiry_result_evt(hdev, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 break;
1881
Marcel Holtmann04936842008-07-14 20:13:48 +02001882 case HCI_EV_IO_CAPA_REQUEST:
1883 hci_io_capa_request_evt(hdev, skb);
1884 break;
1885
1886 case HCI_EV_SIMPLE_PAIR_COMPLETE:
1887 hci_simple_pair_complete_evt(hdev, skb);
1888 break;
1889
Marcel Holtmann41a96212008-07-14 20:13:48 +02001890 case HCI_EV_REMOTE_HOST_FEATURES:
1891 hci_remote_host_features_evt(hdev, skb);
1892 break;
1893
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001894 default:
1895 BT_DBG("%s event 0x%x", hdev->name, event);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 break;
1897 }
1898
1899 kfree_skb(skb);
1900 hdev->stat.evt_rx++;
1901}
1902
1903/* Generate internal stack event */
1904void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1905{
1906 struct hci_event_hdr *hdr;
1907 struct hci_ev_stack_internal *ev;
1908 struct sk_buff *skb;
1909
1910 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1911 if (!skb)
1912 return;
1913
1914 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1915 hdr->evt = HCI_EV_STACK_INTERNAL;
1916 hdr->plen = sizeof(*ev) + dlen;
1917
1918 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
1919 ev->type = type;
1920 memcpy(ev->data, data, dlen);
1921
Marcel Holtmann576c7d82005-08-06 12:36:54 +02001922 bt_cb(skb)->incoming = 1;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001923 __net_timestamp(skb);
Marcel Holtmann576c7d82005-08-06 12:36:54 +02001924
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001925 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 skb->dev = (void *) hdev;
1927 hci_send_to_sock(hdev, skb);
1928 kfree_skb(skb);
1929}