projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[Bluetooth] Update authentication status after successful encryption
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / hci_event.c
CommitLineData
8e87d142 1/*
1da177e4
LT		 2 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
8e87d142
YH		 15 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
1da177e4
LT		 18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
8e87d142
YH		 20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4
LT		 22 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth HCI event handling. */
26
1da177e4
LT		 27#include <linux/module.h>
28
29#include <linux/types.h>
30#include <linux/errno.h>
31#include <linux/kernel.h>
1da177e4
LT		 32#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
a9de9248 55static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 56{
a9de9248 57 __u8 status = *((__u8 *) skb->data);
1da177e4 58
a9de9248 59 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 60
a9de9248
MH		 61 if (status)
62 return;
1da177e4 63
a9de9248 64 clear_bit(HCI_INQUIRY, &hdev->flags);
6bd57416 65
a9de9248
MH		 66 hci_req_complete(hdev, status);
67
68 hci_conn_check_pending(hdev);
69}
6bd57416 70
a9de9248
MH		 71static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
72{
73 __u8 status = *((__u8 *) skb->data);
6bd57416 74
a9de9248 75 BT_DBG("%s status 0x%x", hdev->name, status);
6bd57416 76
a9de9248
MH		 77 if (status)
78 return;
1da177e4 79
a9de9248
MH		 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;
93 struct hci_conn *conn;
94
95 BT_DBG("%s status 0x%x", hdev->name, rp->status);
96
97 if (rp->status)
98 return;
99
100 hci_dev_lock(hdev);
101
102 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;
1da177e4 108 }
a9de9248
MH		 109
110 hci_dev_unlock(hdev);
1da177e4
LT		 111}
112
a9de9248 113static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 114{
a9de9248 115 struct hci_rp_write_link_policy *rp = (void *) skb->data;
1da177e4 116 struct hci_conn *conn;
04837f64 117 void *sent;
1da177e4 118
a9de9248 119 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 120
a9de9248
MH		 121 if (rp->status)
122 return;
1da177e4 123
a9de9248
MH		 124 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
125 if (!sent)
126 return;
1da177e4 127
a9de9248 128 hci_dev_lock(hdev);
1da177e4 129
a9de9248
MH		 130 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
131 if (conn) {
83985319 132 conn->link_policy = get_unaligned_le16(sent + 2);
a9de9248 133 }
1da177e4 134
a9de9248
MH		 135 hci_dev_unlock(hdev);
136}
1da177e4 137
a9de9248
MH		 138static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
139{
140 __u8 status = *((__u8 *) skb->data);
04837f64 141
a9de9248 142 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 143
a9de9248
MH		 144 hci_req_complete(hdev, status);
145}
04837f64 146
a9de9248
MH		 147static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
148{
149 __u8 status = *((__u8 *) skb->data);
150 void *sent;
04837f64 151
a9de9248 152 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 153
a9de9248
MH		 154 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
155 if (!sent)
156 return;
04837f64 157
a9de9248
MH		 158 if (!status)
159 memcpy(hdev->dev_name, sent, 248);
160}
161
162static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
163{
164 struct hci_rp_read_local_name *rp = (void *) skb->data;
165
166 BT_DBG("%s status 0x%x", hdev->name, rp->status);
167
168 if (rp->status)
169 return;
170
171 memcpy(hdev->dev_name, rp->name, 248);
172}
173
174static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
175{
176 __u8 status = *((__u8 *) skb->data);
177 void *sent;
178
179 BT_DBG("%s status 0x%x", hdev->name, status);
180
181 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
182 if (!sent)
183 return;
184
185 if (!status) {
186 __u8 param = *((__u8 *) sent);
187
188 if (param == AUTH_ENABLED)
189 set_bit(HCI_AUTH, &hdev->flags);
190 else
191 clear_bit(HCI_AUTH, &hdev->flags);
1da177e4 192 }
a9de9248
MH		 193
194 hci_req_complete(hdev, status);
1da177e4
LT		 195}
196
a9de9248 197static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 198{
a9de9248 199 __u8 status = *((__u8 *) skb->data);
1da177e4
LT		 200 void *sent;
201
a9de9248 202 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 203
a9de9248
MH		 204 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
205 if (!sent)
206 return;
1da177e4 207
a9de9248
MH		 208 if (!status) {
209 __u8 param = *((__u8 *) sent);
210
211 if (param)
212 set_bit(HCI_ENCRYPT, &hdev->flags);
213 else
214 clear_bit(HCI_ENCRYPT, &hdev->flags);
215 }
1da177e4 216
a9de9248
MH		 217 hci_req_complete(hdev, status);
218}
1da177e4 219
a9de9248
MH		 220static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
221{
222 __u8 status = *((__u8 *) skb->data);
223 void *sent;
1da177e4 224
a9de9248 225 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 226
a9de9248
MH		 227 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
228 if (!sent)
229 return;
1da177e4 230
a9de9248
MH		 231 if (!status) {
232 __u8 param = *((__u8 *) sent);
1da177e4 233
a9de9248
MH		 234 clear_bit(HCI_PSCAN, &hdev->flags);
235 clear_bit(HCI_ISCAN, &hdev->flags);
1da177e4 236
a9de9248
MH		 237 if (param & SCAN_INQUIRY)
238 set_bit(HCI_ISCAN, &hdev->flags);
1da177e4 239
a9de9248
MH		 240 if (param & SCAN_PAGE)
241 set_bit(HCI_PSCAN, &hdev->flags);
242 }
1da177e4 243
a9de9248
MH		 244 hci_req_complete(hdev, status);
245}
1da177e4 246
a9de9248
MH		 247static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
248{
249 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
1da177e4 250
a9de9248 251 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 252
a9de9248
MH		 253 if (rp->status)
254 return;
1da177e4 255
a9de9248 256 memcpy(hdev->dev_class, rp->dev_class, 3);
1da177e4 257
a9de9248
MH		 258 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
259 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
260}
1da177e4 261
a9de9248
MH		 262static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
263{
264 __u8 status = *((__u8 *) skb->data);
265 void *sent;
1da177e4 266
a9de9248 267 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 268
a9de9248
MH		 269 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
270 if (!sent)
271 return;
1da177e4 272
a9de9248
MH		 273 if (!status)
274 memcpy(hdev->dev_class, sent, 3);
275}
1da177e4 276
a9de9248
MH		 277static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
278{
279 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
280 __u16 setting;
281
282 BT_DBG("%s status 0x%x", hdev->name, rp->status);
283
284 if (rp->status)
285 return;
286
287 setting = __le16_to_cpu(rp->voice_setting);
288
289 if (hdev->voice_setting == setting )
290 return;
291
292 hdev->voice_setting = setting;
293
294 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
295
296 if (hdev->notify) {
297 tasklet_disable(&hdev->tx_task);
298 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
299 tasklet_enable(&hdev->tx_task);
300 }
301}
302
303static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
304{
305 __u8 status = *((__u8 *) skb->data);
306 void *sent;
307
308 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 309
a9de9248
MH		 310 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
311 if (!sent)
312 return;
1da177e4 313
a9de9248 314 if (!status) {
83985319 315 __u16 setting = get_unaligned_le16(sent);
1da177e4 316
a9de9248 317 if (hdev->voice_setting != setting) {
1da177e4
LT		 318 hdev->voice_setting = setting;
319
a9de9248 320 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
1da177e4
LT		 321
322 if (hdev->notify) {
323 tasklet_disable(&hdev->tx_task);
324 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
325 tasklet_enable(&hdev->tx_task);
326 }
327 }
1da177e4
LT		 328 }
329}
330
a9de9248 331static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 332{
a9de9248 333 __u8 status = *((__u8 *) skb->data);
1da177e4 334
a9de9248 335 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 336
a9de9248
MH		 337 hci_req_complete(hdev, status);
338}
1143e5a6 339
a9de9248
MH		 340static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
341{
342 struct hci_rp_read_local_version *rp = (void *) skb->data;
1143e5a6 343
a9de9248 344 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1143e5a6 345
a9de9248
MH		 346 if (rp->status)
347 return;
1143e5a6 348
a9de9248
MH		 349 hdev->hci_ver = rp->hci_ver;
350 hdev->hci_rev = btohs(rp->hci_rev);
351 hdev->manufacturer = btohs(rp->manufacturer);
1143e5a6 352
a9de9248
MH		 353 BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
354 hdev->manufacturer,
355 hdev->hci_ver, hdev->hci_rev);
356}
1da177e4 357
a9de9248
MH		 358static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb)
359{
360 struct hci_rp_read_local_commands *rp = (void *) skb->data;
1da177e4 361
a9de9248 362 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 363
a9de9248
MH		 364 if (rp->status)
365 return;
1da177e4 366
a9de9248
MH		 367 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
368}
1da177e4 369
a9de9248
MH		 370static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb)
371{
372 struct hci_rp_read_local_features *rp = (void *) skb->data;
5b7f9909 373
a9de9248 374 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 375
a9de9248
MH		 376 if (rp->status)
377 return;
5b7f9909 378
a9de9248 379 memcpy(hdev->features, rp->features, 8);
5b7f9909 380
a9de9248
MH		 381 /* Adjust default settings according to features
382 * supported by device. */
1da177e4 383
a9de9248
MH		 384 if (hdev->features[0] & LMP_3SLOT)
385 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
1da177e4 386
a9de9248
MH		 387 if (hdev->features[0] & LMP_5SLOT)
388 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
1da177e4 389
a9de9248
MH		 390 if (hdev->features[1] & LMP_HV2) {
391 hdev->pkt_type |= (HCI_HV2);
392 hdev->esco_type |= (ESCO_HV2);
393 }
1da177e4 394
a9de9248
MH		 395 if (hdev->features[1] & LMP_HV3) {
396 hdev->pkt_type |= (HCI_HV3);
397 hdev->esco_type |= (ESCO_HV3);
398 }
1da177e4 399
a9de9248
MH		 400 if (hdev->features[3] & LMP_ESCO)
401 hdev->esco_type |= (ESCO_EV3);
da1f5198 402
a9de9248
MH		 403 if (hdev->features[4] & LMP_EV4)
404 hdev->esco_type |= (ESCO_EV4);
da1f5198 405
a9de9248
MH		 406 if (hdev->features[4] & LMP_EV5)
407 hdev->esco_type |= (ESCO_EV5);
1da177e4 408
a9de9248
MH		 409 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
410 hdev->features[0], hdev->features[1],
411 hdev->features[2], hdev->features[3],
412 hdev->features[4], hdev->features[5],
413 hdev->features[6], hdev->features[7]);
414}
1da177e4 415
a9de9248
MH		 416static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
417{
418 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
1da177e4 419
a9de9248 420 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 421
a9de9248
MH		 422 if (rp->status)
423 return;
1da177e4 424
a9de9248
MH		 425 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
426 hdev->sco_mtu = rp->sco_mtu;
427 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
428 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
429
430 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
431 hdev->sco_mtu = 64;
432 hdev->sco_pkts = 8;
1da177e4 433 }
a9de9248
MH		 434
435 hdev->acl_cnt = hdev->acl_pkts;
436 hdev->sco_cnt = hdev->sco_pkts;
437
438 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
439 hdev->acl_mtu, hdev->acl_pkts,
440 hdev->sco_mtu, hdev->sco_pkts);
441}
442
443static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
444{
445 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
446
447 BT_DBG("%s status 0x%x", hdev->name, rp->status);
448
449 if (!rp->status)
450 bacpy(&hdev->bdaddr, &rp->bdaddr);
451
452 hci_req_complete(hdev, rp->status);
453}
454
455static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
456{
457 BT_DBG("%s status 0x%x", hdev->name, status);
458
459 if (status) {
460 hci_req_complete(hdev, status);
461
462 hci_conn_check_pending(hdev);
463 } else
464 set_bit(HCI_INQUIRY, &hdev->flags);
1da177e4
LT		 465}
466
1da177e4
LT		 467static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
468{
a9de9248 469 struct hci_cp_create_conn *cp;
1da177e4 470 struct hci_conn *conn;
1da177e4 471
a9de9248
MH		 472 BT_DBG("%s status 0x%x", hdev->name, status);
473
474 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
1da177e4
LT		 475 if (!cp)
476 return;
477
478 hci_dev_lock(hdev);
479
480 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
481
a9de9248 482 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
1da177e4
LT		 483
484 if (status) {
485 if (conn && conn->state == BT_CONNECT) {
4c67bc74
MH		 486 if (status != 0x0c || conn->attempt > 2) {
487 conn->state = BT_CLOSED;
488 hci_proto_connect_cfm(conn, status);
489 hci_conn_del(conn);
490 } else
491 conn->state = BT_CONNECT2;
1da177e4
LT		 492 }
493 } else {
494 if (!conn) {
495 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
496 if (conn) {
497 conn->out = 1;
498 conn->link_mode |= HCI_LM_MASTER;
499 } else
500 BT_ERR("No memmory for new connection");
501 }
502 }
503
504 hci_dev_unlock(hdev);
505}
506
a9de9248 507static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
1da177e4 508{
a9de9248
MH		 509 struct hci_cp_add_sco *cp;
510 struct hci_conn *acl, *sco;
511 __u16 handle;
1da177e4 512
b6a0dc82
MH		 513 BT_DBG("%s status 0x%x", hdev->name, status);
514
a9de9248
MH		 515 if (!status)
516 return;
1da177e4 517
a9de9248
MH		 518 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
519 if (!cp)
520 return;
1da177e4 521
a9de9248 522 handle = __le16_to_cpu(cp->handle);
1da177e4 523
a9de9248 524 BT_DBG("%s handle %d", hdev->name, handle);
1da177e4 525
a9de9248 526 hci_dev_lock(hdev);
1da177e4 527
a9de9248
MH		 528 acl = hci_conn_hash_lookup_handle(hdev, handle);
529 if (acl && (sco = acl->link)) {
530 sco->state = BT_CLOSED;
1da177e4 531
a9de9248
MH		 532 hci_proto_connect_cfm(sco, status);
533 hci_conn_del(sco);
534 }
1da177e4 535
a9de9248
MH		 536 hci_dev_unlock(hdev);
537}
1da177e4 538
a9de9248
MH		 539static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
540{
541 BT_DBG("%s status 0x%x", hdev->name, status);
542}
1da177e4 543
a9de9248
MH		 544static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
545{
b6a0dc82
MH		 546 struct hci_cp_setup_sync_conn *cp;
547 struct hci_conn *acl, *sco;
548 __u16 handle;
549
a9de9248 550 BT_DBG("%s status 0x%x", hdev->name, status);
b6a0dc82
MH		 551
552 if (!status)
553 return;
554
555 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
556 if (!cp)
557 return;
558
559 handle = __le16_to_cpu(cp->handle);
560
561 BT_DBG("%s handle %d", hdev->name, handle);
562
563 hci_dev_lock(hdev);
564
565 acl = hci_conn_hash_lookup_handle(hdev, handle);
566 if (acl && (sco = acl->link)) {
567 sco->state = BT_CLOSED;
568
569 hci_proto_connect_cfm(sco, status);
570 hci_conn_del(sco);
571 }
572
573 hci_dev_unlock(hdev);
1da177e4
LT		 574}
575
a9de9248 576static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
1da177e4 577{
a9de9248
MH		 578 struct hci_cp_sniff_mode *cp;
579 struct hci_conn *conn;
1da177e4 580
a9de9248 581 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 582
a9de9248
MH		 583 if (!status)
584 return;
04837f64 585
a9de9248
MH		 586 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
587 if (!cp)
588 return;
04837f64 589
a9de9248 590 hci_dev_lock(hdev);
04837f64 591
a9de9248
MH		 592 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
593 if (conn)
594 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
04837f64 595
a9de9248
MH		 596 hci_dev_unlock(hdev);
597}
04837f64 598
a9de9248
MH		 599static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
600{
601 struct hci_cp_exit_sniff_mode *cp;
602 struct hci_conn *conn;
04837f64 603
a9de9248 604 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 605
a9de9248
MH		 606 if (!status)
607 return;
04837f64 608
a9de9248
MH		 609 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
610 if (!cp)
611 return;
04837f64 612
a9de9248 613 hci_dev_lock(hdev);
1da177e4 614
a9de9248
MH		 615 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
616 if (conn)
617 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
1da177e4 618
a9de9248 619 hci_dev_unlock(hdev);
1da177e4
LT		 620}
621
1da177e4
LT		 622static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
623{
624 __u8 status = *((__u8 *) skb->data);
625
626 BT_DBG("%s status %d", hdev->name, status);
627
628 clear_bit(HCI_INQUIRY, &hdev->flags);
6bd57416 629
a9de9248 630 hci_req_complete(hdev, status);
6bd57416 631
a9de9248 632 hci_conn_check_pending(hdev);
1da177e4
LT		 633}
634
1da177e4
LT		 635static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
636{
45bb4bf0 637 struct inquiry_data data;
a9de9248 638 struct inquiry_info *info = (void *) (skb->data + 1);
1da177e4
LT		 639 int num_rsp = *((__u8 *) skb->data);
640
641 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
642
45bb4bf0
MH		 643 if (!num_rsp)
644 return;
645
1da177e4 646 hci_dev_lock(hdev);
45bb4bf0 647
1da177e4 648 for (; num_rsp; num_rsp--) {
1da177e4
LT		 649 bacpy(&data.bdaddr, &info->bdaddr);
650 data.pscan_rep_mode = info->pscan_rep_mode;
651 data.pscan_period_mode = info->pscan_period_mode;
652 data.pscan_mode = info->pscan_mode;
653 memcpy(data.dev_class, info->dev_class, 3);
654 data.clock_offset = info->clock_offset;
655 data.rssi = 0x00;
656 info++;
657 hci_inquiry_cache_update(hdev, &data);
658 }
45bb4bf0 659
1da177e4
LT		 660 hci_dev_unlock(hdev);
661}
662
1da177e4
LT		 663static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
664{
a9de9248
MH		 665 struct hci_ev_conn_complete *ev = (void *) skb->data;
666 struct hci_conn *conn;
1da177e4
LT		 667
668 BT_DBG("%s", hdev->name);
669
670 hci_dev_lock(hdev);
671
672 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
a9de9248
MH		 673 if (!conn)
674 goto unlock;
1da177e4
LT		 675
676 if (!ev->status) {
677 conn->handle = __le16_to_cpu(ev->handle);
678 conn->state = BT_CONNECTED;
679
680 if (test_bit(HCI_AUTH, &hdev->flags))
681 conn->link_mode |= HCI_LM_AUTH;
682
683 if (test_bit(HCI_ENCRYPT, &hdev->flags))
684 conn->link_mode |= HCI_LM_ENCRYPT;
685
04837f64
MH		 686 /* Get remote features */
687 if (conn->type == ACL_LINK) {
688 struct hci_cp_read_remote_features cp;
689 cp.handle = ev->handle;
a9de9248 690 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES, sizeof(cp), &cp);
04837f64
MH		 691 }
692
1da177e4
LT		 693 /* Set link policy */
694 if (conn->type == ACL_LINK && hdev->link_policy) {
695 struct hci_cp_write_link_policy cp;
696 cp.handle = ev->handle;
aca3192c 697 cp.policy = cpu_to_le16(hdev->link_policy);
a9de9248 698 hci_send_cmd(hdev, HCI_OP_WRITE_LINK_POLICY, sizeof(cp), &cp);
1da177e4
LT		 699 }
700
701 /* Set packet type for incoming connection */
702 if (!conn->out) {
703 struct hci_cp_change_conn_ptype cp;
704 cp.handle = ev->handle;
8e87d142 705 cp.pkt_type = (conn->type == ACL_LINK) ?
aca3192c
YH		 706 cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK):
707 cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
1da177e4 708
a9de9248 709 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE, sizeof(cp), &cp);
37e97b4e
MH		 710 } else {
711 /* Update disconnect timer */
712 hci_conn_hold(conn);
713 hci_conn_put(conn);
1da177e4
LT		 714 }
715 } else
716 conn->state = BT_CLOSED;
717
718 if (conn->type == ACL_LINK) {
719 struct hci_conn *sco = conn->link;
720 if (sco) {
b6a0dc82
MH		 721 if (!ev->status) {
722 if (lmp_esco_capable(hdev))
723 hci_setup_sync(sco, conn->handle);
724 else
725 hci_add_sco(sco, conn->handle);
726 } else {
1da177e4
LT		 727 hci_proto_connect_cfm(sco, ev->status);
728 hci_conn_del(sco);
729 }
730 }
731 }
732
733 hci_proto_connect_cfm(conn, ev->status);
734 if (ev->status)
735 hci_conn_del(conn);
736
a9de9248 737unlock:
1da177e4 738 hci_dev_unlock(hdev);
1da177e4 739
a9de9248 740 hci_conn_check_pending(hdev);
1da177e4
LT		 741}
742
a9de9248 743static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 744{
a9de9248
MH		 745 struct hci_ev_conn_request *ev = (void *) skb->data;
746 int mask = hdev->link_mode;
1da177e4 747
a9de9248
MH		 748 BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
749 batostr(&ev->bdaddr), ev->link_type);
1da177e4 750
a9de9248 751 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
1da177e4 752
a9de9248
MH		 753 if (mask & HCI_LM_ACCEPT) {
754 /* Connection accepted */
1da177e4 755 struct hci_conn *conn;
1da177e4 756
a9de9248 757 hci_dev_lock(hdev);
b6a0dc82 758
a9de9248
MH		 759 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
760 if (!conn) {
761 if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
762 BT_ERR("No memmory for new connection");
763 hci_dev_unlock(hdev);
764 return;
1da177e4
LT		 765 }
766 }
b6a0dc82 767
a9de9248
MH		 768 memcpy(conn->dev_class, ev->dev_class, 3);
769 conn->state = BT_CONNECT;
b6a0dc82 770
a9de9248 771 hci_dev_unlock(hdev);
1da177e4 772
b6a0dc82
MH		 773 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
774 struct hci_cp_accept_conn_req cp;
1da177e4 775
b6a0dc82
MH		 776 bacpy(&cp.bdaddr, &ev->bdaddr);
777
778 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
779 cp.role = 0x00; /* Become master */
780 else
781 cp.role = 0x01; /* Remain slave */
782
783 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
784 sizeof(cp), &cp);
785 } else {
786 struct hci_cp_accept_sync_conn_req cp;
787
788 bacpy(&cp.bdaddr, &ev->bdaddr);
789 cp.pkt_type = cpu_to_le16(hdev->esco_type);
790
791 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
792 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
793 cp.max_latency = cpu_to_le16(0xffff);
794 cp.content_format = cpu_to_le16(hdev->voice_setting);
795 cp.retrans_effort = 0xff;
1da177e4 796
b6a0dc82
MH		 797 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
798 sizeof(cp), &cp);
799 }
a9de9248
MH		 800 } else {
801 /* Connection rejected */
802 struct hci_cp_reject_conn_req cp;
1da177e4 803
a9de9248
MH		 804 bacpy(&cp.bdaddr, &ev->bdaddr);
805 cp.reason = 0x0f;
806 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
1da177e4 807 }
1da177e4
LT		 808}
809
a9de9248 810static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
04837f64 811{
a9de9248 812 struct hci_ev_disconn_complete *ev = (void *) skb->data;
04837f64
MH		 813 struct hci_conn *conn;
814
815 BT_DBG("%s status %d", hdev->name, ev->status);
816
a9de9248
MH		 817 if (ev->status)
818 return;
819
04837f64
MH		 820 hci_dev_lock(hdev);
821
822 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
823 if (conn) {
a9de9248
MH		 824 conn->state = BT_CLOSED;
825 hci_proto_disconn_ind(conn, ev->reason);
826 hci_conn_del(conn);
04837f64
MH		 827 }
828
829 hci_dev_unlock(hdev);
830}
831
1da177e4
LT		 832static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
833{
a9de9248 834 struct hci_ev_auth_complete *ev = (void *) skb->data;
04837f64 835 struct hci_conn *conn;
1da177e4
LT		 836
837 BT_DBG("%s status %d", hdev->name, ev->status);
838
839 hci_dev_lock(hdev);
840
04837f64 841 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 842 if (conn) {
843 if (!ev->status)
844 conn->link_mode |= HCI_LM_AUTH;
845
846 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
847
848 hci_auth_cfm(conn, ev->status);
849
850 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
851 if (!ev->status) {
852 struct hci_cp_set_conn_encrypt cp;
aca3192c 853 cp.handle = cpu_to_le16(conn->handle);
1da177e4 854 cp.encrypt = 1;
a9de9248
MH		 855 hci_send_cmd(conn->hdev,
856 HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
1da177e4
LT		 857 } else {
858 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
859 hci_encrypt_cfm(conn, ev->status, 0x00);
860 }
861 }
862 }
863
864 hci_dev_unlock(hdev);
865}
866
a9de9248 867static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 868{
a9de9248 869 BT_DBG("%s", hdev->name);
1da177e4 870
a9de9248
MH		 871 hci_conn_check_pending(hdev);
872}
873
874static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
875{
876 struct hci_ev_encrypt_change *ev = (void *) skb->data;
877 struct hci_conn *conn;
878
879 BT_DBG("%s status %d", hdev->name, ev->status);
1da177e4
LT		 880
881 hci_dev_lock(hdev);
882
04837f64 883 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 884 if (conn) {
885 if (!ev->status) {
ae293196
MH		 886 if (ev->encrypt) {
887 /* Encryption implies authentication */
888 conn->link_mode |= HCI_LM_AUTH;
1da177e4 889 conn->link_mode |= HCI_LM_ENCRYPT;
ae293196 890 } else
1da177e4
LT		 891 conn->link_mode &= ~HCI_LM_ENCRYPT;
892 }
893
894 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
895
896 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
897 }
898
899 hci_dev_unlock(hdev);
900}
901
a9de9248 902static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 903{
a9de9248 904 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
04837f64 905 struct hci_conn *conn;
1da177e4
LT		 906
907 BT_DBG("%s status %d", hdev->name, ev->status);
908
909 hci_dev_lock(hdev);
910
04837f64 911 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 912 if (conn) {
913 if (!ev->status)
914 conn->link_mode |= HCI_LM_SECURE;
915
916 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
917
918 hci_key_change_cfm(conn, ev->status);
919 }
920
921 hci_dev_unlock(hdev);
922}
923
a9de9248 924static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 925{
a9de9248
MH		 926 struct hci_ev_remote_features *ev = (void *) skb->data;
927 struct hci_conn *conn;
928
929 BT_DBG("%s status %d", hdev->name, ev->status);
930
931 if (ev->status)
932 return;
933
934 hci_dev_lock(hdev);
935
936 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
937 if (conn)
938 memcpy(conn->features, ev->features, 8);
939
940 hci_dev_unlock(hdev);
1da177e4
LT		 941}
942
a9de9248 943static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 944{
a9de9248 945 BT_DBG("%s", hdev->name);
1da177e4
LT		 946}
947
a9de9248 948static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 949{
a9de9248 950 BT_DBG("%s", hdev->name);
1da177e4
LT		 951}
952
a9de9248
MH		 953static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
954{
955 struct hci_ev_cmd_complete *ev = (void *) skb->data;
956 __u16 opcode;
957
958 skb_pull(skb, sizeof(*ev));
959
960 opcode = __le16_to_cpu(ev->opcode);
961
962 switch (opcode) {
963 case HCI_OP_INQUIRY_CANCEL:
964 hci_cc_inquiry_cancel(hdev, skb);
965 break;
966
967 case HCI_OP_EXIT_PERIODIC_INQ:
968 hci_cc_exit_periodic_inq(hdev, skb);
969 break;
970
971 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
972 hci_cc_remote_name_req_cancel(hdev, skb);
973 break;
974
975 case HCI_OP_ROLE_DISCOVERY:
976 hci_cc_role_discovery(hdev, skb);
977 break;
978
979 case HCI_OP_WRITE_LINK_POLICY:
980 hci_cc_write_link_policy(hdev, skb);
981 break;
982
983 case HCI_OP_RESET:
984 hci_cc_reset(hdev, skb);
985 break;
986
987 case HCI_OP_WRITE_LOCAL_NAME:
988 hci_cc_write_local_name(hdev, skb);
989 break;
990
991 case HCI_OP_READ_LOCAL_NAME:
992 hci_cc_read_local_name(hdev, skb);
993 break;
994
995 case HCI_OP_WRITE_AUTH_ENABLE:
996 hci_cc_write_auth_enable(hdev, skb);
997 break;
998
999 case HCI_OP_WRITE_ENCRYPT_MODE:
1000 hci_cc_write_encrypt_mode(hdev, skb);
1001 break;
1002
1003 case HCI_OP_WRITE_SCAN_ENABLE:
1004 hci_cc_write_scan_enable(hdev, skb);
1005 break;
1006
1007 case HCI_OP_READ_CLASS_OF_DEV:
1008 hci_cc_read_class_of_dev(hdev, skb);
1009 break;
1010
1011 case HCI_OP_WRITE_CLASS_OF_DEV:
1012 hci_cc_write_class_of_dev(hdev, skb);
1013 break;
1014
1015 case HCI_OP_READ_VOICE_SETTING:
1016 hci_cc_read_voice_setting(hdev, skb);
1017 break;
1018
1019 case HCI_OP_WRITE_VOICE_SETTING:
1020 hci_cc_write_voice_setting(hdev, skb);
1021 break;
1022
1023 case HCI_OP_HOST_BUFFER_SIZE:
1024 hci_cc_host_buffer_size(hdev, skb);
1025 break;
1026
1027 case HCI_OP_READ_LOCAL_VERSION:
1028 hci_cc_read_local_version(hdev, skb);
1029 break;
1030
1031 case HCI_OP_READ_LOCAL_COMMANDS:
1032 hci_cc_read_local_commands(hdev, skb);
1033 break;
1034
1035 case HCI_OP_READ_LOCAL_FEATURES:
1036 hci_cc_read_local_features(hdev, skb);
1037 break;
1038
1039 case HCI_OP_READ_BUFFER_SIZE:
1040 hci_cc_read_buffer_size(hdev, skb);
1041 break;
1042
1043 case HCI_OP_READ_BD_ADDR:
1044 hci_cc_read_bd_addr(hdev, skb);
1045 break;
1046
1047 default:
1048 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1049 break;
1050 }
1051
1052 if (ev->ncmd) {
1053 atomic_set(&hdev->cmd_cnt, 1);
1054 if (!skb_queue_empty(&hdev->cmd_q))
1055 hci_sched_cmd(hdev);
1056 }
1057}
1058
1059static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1060{
1061 struct hci_ev_cmd_status *ev = (void *) skb->data;
1062 __u16 opcode;
1063
1064 skb_pull(skb, sizeof(*ev));
1065
1066 opcode = __le16_to_cpu(ev->opcode);
1067
1068 switch (opcode) {
1069 case HCI_OP_INQUIRY:
1070 hci_cs_inquiry(hdev, ev->status);
1071 break;
1072
1073 case HCI_OP_CREATE_CONN:
1074 hci_cs_create_conn(hdev, ev->status);
1075 break;
1076
1077 case HCI_OP_ADD_SCO:
1078 hci_cs_add_sco(hdev, ev->status);
1079 break;
1080
1081 case HCI_OP_REMOTE_NAME_REQ:
1082 hci_cs_remote_name_req(hdev, ev->status);
1083 break;
1084
1085 case HCI_OP_SETUP_SYNC_CONN:
1086 hci_cs_setup_sync_conn(hdev, ev->status);
1087 break;
1088
1089 case HCI_OP_SNIFF_MODE:
1090 hci_cs_sniff_mode(hdev, ev->status);
1091 break;
1092
1093 case HCI_OP_EXIT_SNIFF_MODE:
1094 hci_cs_exit_sniff_mode(hdev, ev->status);
1095 break;
1096
1097 default:
1098 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1099 break;
1100 }
1101
1102 if (ev->ncmd) {
1103 atomic_set(&hdev->cmd_cnt, 1);
1104 if (!skb_queue_empty(&hdev->cmd_q))
1105 hci_sched_cmd(hdev);
1106 }
1107}
1108
1109static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1110{
1111 struct hci_ev_role_change *ev = (void *) skb->data;
1112 struct hci_conn *conn;
1113
1114 BT_DBG("%s status %d", hdev->name, ev->status);
1115
1116 hci_dev_lock(hdev);
1117
1118 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1119 if (conn) {
1120 if (!ev->status) {
1121 if (ev->role)
1122 conn->link_mode &= ~HCI_LM_MASTER;
1123 else
1124 conn->link_mode |= HCI_LM_MASTER;
1125 }
1126
1127 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1128
1129 hci_role_switch_cfm(conn, ev->status, ev->role);
1130 }
1131
1132 hci_dev_unlock(hdev);
1133}
1134
1135static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1136{
1137 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
1138 __le16 *ptr;
1139 int i;
1140
1141 skb_pull(skb, sizeof(*ev));
1142
1143 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1144
1145 if (skb->len < ev->num_hndl * 4) {
1146 BT_DBG("%s bad parameters", hdev->name);
1147 return;
1148 }
1149
1150 tasklet_disable(&hdev->tx_task);
1151
1152 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
1153 struct hci_conn *conn;
1154 __u16 handle, count;
1155
83985319
HH		 1156 handle = get_unaligned_le16(ptr++);
1157 count = get_unaligned_le16(ptr++);
a9de9248
MH		 1158
1159 conn = hci_conn_hash_lookup_handle(hdev, handle);
1160 if (conn) {
1161 conn->sent -= count;
1162
1163 if (conn->type == ACL_LINK) {
1164 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
1165 hdev->acl_cnt = hdev->acl_pkts;
1166 } else {
1167 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
1168 hdev->sco_cnt = hdev->sco_pkts;
1169 }
1170 }
1171 }
1172
1173 hci_sched_tx(hdev);
1174
1175 tasklet_enable(&hdev->tx_task);
1176}
1177
1178static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
04837f64 1179{
a9de9248 1180 struct hci_ev_mode_change *ev = (void *) skb->data;
04837f64
MH		 1181 struct hci_conn *conn;
1182
1183 BT_DBG("%s status %d", hdev->name, ev->status);
1184
1185 hci_dev_lock(hdev);
1186
1187 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
a9de9248
MH		 1188 if (conn) {
1189 conn->mode = ev->mode;
1190 conn->interval = __le16_to_cpu(ev->interval);
1191
1192 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1193 if (conn->mode == HCI_CM_ACTIVE)
1194 conn->power_save = 1;
1195 else
1196 conn->power_save = 0;
1197 }
04837f64
MH		 1198 }
1199
1200 hci_dev_unlock(hdev);
1201}
1202
a9de9248
MH		 1203static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1204{
1205 BT_DBG("%s", hdev->name);
1206}
1207
1208static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1209{
1210 BT_DBG("%s", hdev->name);
1211}
1212
1213static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1214{
1215 BT_DBG("%s", hdev->name);
1216}
1217
1da177e4
LT		 1218static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1219{
a9de9248 1220 struct hci_ev_clock_offset *ev = (void *) skb->data;
04837f64 1221 struct hci_conn *conn;
1da177e4
LT		 1222
1223 BT_DBG("%s status %d", hdev->name, ev->status);
1224
1225 hci_dev_lock(hdev);
1226
04837f64 1227 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 1228 if (conn && !ev->status) {
1229 struct inquiry_entry *ie;
1230
1231 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1232 ie->data.clock_offset = ev->clock_offset;
1233 ie->timestamp = jiffies;
1234 }
1235 }
1236
1237 hci_dev_unlock(hdev);
1238}
1239
85a1e930
MH		 1240static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1241{
a9de9248 1242 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
85a1e930
MH		 1243 struct inquiry_entry *ie;
1244
1245 BT_DBG("%s", hdev->name);
1246
1247 hci_dev_lock(hdev);
1248
1249 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1250 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1251 ie->timestamp = jiffies;
1252 }
1253
1254 hci_dev_unlock(hdev);
1255}
1256
a9de9248
MH		 1257static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1258{
1259 struct inquiry_data data;
1260 int num_rsp = *((__u8 *) skb->data);
1261
1262 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1263
1264 if (!num_rsp)
1265 return;
1266
1267 hci_dev_lock(hdev);
1268
1269 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1270 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1271
1272 for (; num_rsp; num_rsp--) {
1273 bacpy(&data.bdaddr, &info->bdaddr);
1274 data.pscan_rep_mode = info->pscan_rep_mode;
1275 data.pscan_period_mode = info->pscan_period_mode;
1276 data.pscan_mode = info->pscan_mode;
1277 memcpy(data.dev_class, info->dev_class, 3);
1278 data.clock_offset = info->clock_offset;
1279 data.rssi = info->rssi;
1280 info++;
1281 hci_inquiry_cache_update(hdev, &data);
1282 }
1283 } else {
1284 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1285
1286 for (; num_rsp; num_rsp--) {
1287 bacpy(&data.bdaddr, &info->bdaddr);
1288 data.pscan_rep_mode = info->pscan_rep_mode;
1289 data.pscan_period_mode = info->pscan_period_mode;
1290 data.pscan_mode = 0x00;
1291 memcpy(data.dev_class, info->dev_class, 3);
1292 data.clock_offset = info->clock_offset;
1293 data.rssi = info->rssi;
1294 info++;
1295 hci_inquiry_cache_update(hdev, &data);
1296 }
1297 }
1298
1299 hci_dev_unlock(hdev);
1300}
1301
1302static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1303{
1304 BT_DBG("%s", hdev->name);
1305}
1306
1307static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1308{
b6a0dc82
MH		 1309 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1310 struct hci_conn *conn;
1311
1312 BT_DBG("%s status %d", hdev->name, ev->status);
1313
1314 hci_dev_lock(hdev);
1315
1316 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
1317 if (!conn)
1318 goto unlock;
1319
1320 if (!ev->status) {
1321 conn->handle = __le16_to_cpu(ev->handle);
1322 conn->state = BT_CONNECTED;
1323 } else
1324 conn->state = BT_CLOSED;
1325
1326 hci_proto_connect_cfm(conn, ev->status);
1327 if (ev->status)
1328 hci_conn_del(conn);
1329
1330unlock:
1331 hci_dev_unlock(hdev);
a9de9248
MH		 1332}
1333
1334static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1335{
1336 BT_DBG("%s", hdev->name);
1337}
1338
04837f64
MH		 1339static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1340{
a9de9248 1341 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
04837f64
MH		 1342 struct hci_conn *conn;
1343
1344 BT_DBG("%s status %d", hdev->name, ev->status);
1345
1346 hci_dev_lock(hdev);
1347
1348 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1349 if (conn) {
1350 }
1351
1352 hci_dev_unlock(hdev);
1353}
1354
a9de9248 1355static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1356{
a9de9248
MH		 1357 struct inquiry_data data;
1358 struct extended_inquiry_info *info = (void *) (skb->data + 1);
1359 int num_rsp = *((__u8 *) skb->data);
1da177e4 1360
a9de9248 1361 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1da177e4 1362
a9de9248
MH		 1363 if (!num_rsp)
1364 return;
1da177e4 1365
a9de9248
MH		 1366 hci_dev_lock(hdev);
1367
1368 for (; num_rsp; num_rsp--) {
1369 bacpy(&data.bdaddr, &info->bdaddr);
1370 data.pscan_rep_mode = info->pscan_rep_mode;
1371 data.pscan_period_mode = info->pscan_period_mode;
1372 data.pscan_mode = 0x00;
1373 memcpy(data.dev_class, info->dev_class, 3);
1374 data.clock_offset = info->clock_offset;
1375 data.rssi = info->rssi;
1376 info++;
1377 hci_inquiry_cache_update(hdev, &data);
1378 }
1379
1380 hci_dev_unlock(hdev);
1381}
1da177e4 1382
a9de9248
MH		 1383void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1384{
1385 struct hci_event_hdr *hdr = (void *) skb->data;
1386 __u8 event = hdr->evt;
1387
1388 skb_pull(skb, HCI_EVENT_HDR_SIZE);
1389
1390 switch (event) {
1da177e4
LT		 1391 case HCI_EV_INQUIRY_COMPLETE:
1392 hci_inquiry_complete_evt(hdev, skb);
1393 break;
1394
1395 case HCI_EV_INQUIRY_RESULT:
1396 hci_inquiry_result_evt(hdev, skb);
1397 break;
1398
a9de9248
MH		 1399 case HCI_EV_CONN_COMPLETE:
1400 hci_conn_complete_evt(hdev, skb);
21d9e30e
MH		 1401 break;
1402
1da177e4
LT		 1403 case HCI_EV_CONN_REQUEST:
1404 hci_conn_request_evt(hdev, skb);
1405 break;
1406
1da177e4
LT		 1407 case HCI_EV_DISCONN_COMPLETE:
1408 hci_disconn_complete_evt(hdev, skb);
1409 break;
1410
1da177e4
LT		 1411 case HCI_EV_AUTH_COMPLETE:
1412 hci_auth_complete_evt(hdev, skb);
1413 break;
1414
a9de9248
MH		 1415 case HCI_EV_REMOTE_NAME:
1416 hci_remote_name_evt(hdev, skb);
1417 break;
1418
1da177e4
LT		 1419 case HCI_EV_ENCRYPT_CHANGE:
1420 hci_encrypt_change_evt(hdev, skb);
1421 break;
1422
a9de9248
MH		 1423 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
1424 hci_change_link_key_complete_evt(hdev, skb);
1425 break;
1426
1427 case HCI_EV_REMOTE_FEATURES:
1428 hci_remote_features_evt(hdev, skb);
1429 break;
1430
1431 case HCI_EV_REMOTE_VERSION:
1432 hci_remote_version_evt(hdev, skb);
1433 break;
1434
1435 case HCI_EV_QOS_SETUP_COMPLETE:
1436 hci_qos_setup_complete_evt(hdev, skb);
1437 break;
1438
1439 case HCI_EV_CMD_COMPLETE:
1440 hci_cmd_complete_evt(hdev, skb);
1441 break;
1442
1443 case HCI_EV_CMD_STATUS:
1444 hci_cmd_status_evt(hdev, skb);
1445 break;
1446
1447 case HCI_EV_ROLE_CHANGE:
1448 hci_role_change_evt(hdev, skb);
1449 break;
1450
1451 case HCI_EV_NUM_COMP_PKTS:
1452 hci_num_comp_pkts_evt(hdev, skb);
1453 break;
1454
1455 case HCI_EV_MODE_CHANGE:
1456 hci_mode_change_evt(hdev, skb);
1da177e4
LT		 1457 break;
1458
1459 case HCI_EV_PIN_CODE_REQ:
1460 hci_pin_code_request_evt(hdev, skb);
1461 break;
1462
1463 case HCI_EV_LINK_KEY_REQ:
1464 hci_link_key_request_evt(hdev, skb);
1465 break;
1466
1467 case HCI_EV_LINK_KEY_NOTIFY:
1468 hci_link_key_notify_evt(hdev, skb);
1469 break;
1470
1471 case HCI_EV_CLOCK_OFFSET:
1472 hci_clock_offset_evt(hdev, skb);
1473 break;
1474
85a1e930
MH		 1475 case HCI_EV_PSCAN_REP_MODE:
1476 hci_pscan_rep_mode_evt(hdev, skb);
1477 break;
1478
a9de9248
MH		 1479 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1480 hci_inquiry_result_with_rssi_evt(hdev, skb);
04837f64
MH		 1481 break;
1482
a9de9248
MH		 1483 case HCI_EV_REMOTE_EXT_FEATURES:
1484 hci_remote_ext_features_evt(hdev, skb);
1da177e4
LT		 1485 break;
1486
a9de9248
MH		 1487 case HCI_EV_SYNC_CONN_COMPLETE:
1488 hci_sync_conn_complete_evt(hdev, skb);
1489 break;
1da177e4 1490
a9de9248
MH		 1491 case HCI_EV_SYNC_CONN_CHANGED:
1492 hci_sync_conn_changed_evt(hdev, skb);
1493 break;
1da177e4 1494
a9de9248
MH		 1495 case HCI_EV_SNIFF_SUBRATE:
1496 hci_sniff_subrate_evt(hdev, skb);
1497 break;
1da177e4 1498
a9de9248
MH		 1499 case HCI_EV_EXTENDED_INQUIRY_RESULT:
1500 hci_extended_inquiry_result_evt(hdev, skb);
1501 break;
1da177e4 1502
a9de9248
MH		 1503 default:
1504 BT_DBG("%s event 0x%x", hdev->name, event);
1da177e4
LT		 1505 break;
1506 }
1507
1508 kfree_skb(skb);
1509 hdev->stat.evt_rx++;
1510}
1511
1512/* Generate internal stack event */
1513void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1514{
1515 struct hci_event_hdr *hdr;
1516 struct hci_ev_stack_internal *ev;
1517 struct sk_buff *skb;
1518
1519 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1520 if (!skb)
1521 return;
1522
1523 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1524 hdr->evt = HCI_EV_STACK_INTERNAL;
1525 hdr->plen = sizeof(*ev) + dlen;
1526
1527 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
1528 ev->type = type;
1529 memcpy(ev->data, data, dlen);
1530
576c7d85 1531 bt_cb(skb)->incoming = 1;
a61bbcf2 1532 __net_timestamp(skb);
576c7d85 1533
0d48d939 1534 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
1da177e4
LT		 1535 skb->dev = (void *) hdev;
1536 hci_send_to_sock(hdev, skb);
1537 kfree_skb(skb);
1538}
kernel source for telekom puls (alcatel/mediatek)