projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[Bluetooth] Track status of Simple Pairing mode
[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
e4e8e37c
MH		 113static 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
a9de9248 132static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 133{
a9de9248 134 struct hci_rp_write_link_policy *rp = (void *) skb->data;
1da177e4 135 struct hci_conn *conn;
04837f64 136 void *sent;
1da177e4 137
a9de9248 138 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 139
a9de9248
MH		 140 if (rp->status)
141 return;
1da177e4 142
a9de9248
MH		 143 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
144 if (!sent)
145 return;
1da177e4 146
a9de9248 147 hci_dev_lock(hdev);
1da177e4 148
a9de9248 149 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
e4e8e37c 150 if (conn)
83985319 151 conn->link_policy = get_unaligned_le16(sent + 2);
1da177e4 152
a9de9248
MH		 153 hci_dev_unlock(hdev);
154}
1da177e4 155
e4e8e37c
MH		 156static 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
a9de9248
MH		 185static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
186{
187 __u8 status = *((__u8 *) skb->data);
04837f64 188
a9de9248 189 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 190
a9de9248
MH		 191 hci_req_complete(hdev, status);
192}
04837f64 193
a9de9248
MH		 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;
04837f64 198
a9de9248 199 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 200
f383f275
MH		 201 if (status)
202 return;
203
a9de9248
MH		 204 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
205 if (!sent)
206 return;
04837f64 207
f383f275 208 memcpy(hdev->dev_name, sent, 248);
a9de9248
MH		 209}
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);
1da177e4 241 }
a9de9248
MH		 242
243 hci_req_complete(hdev, status);
1da177e4
LT		 244}
245
a9de9248 246static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 247{
a9de9248 248 __u8 status = *((__u8 *) skb->data);
1da177e4
LT		 249 void *sent;
250
a9de9248 251 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 252
a9de9248
MH		 253 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
254 if (!sent)
255 return;
1da177e4 256
a9de9248
MH		 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 }
1da177e4 265
a9de9248
MH		 266 hci_req_complete(hdev, status);
267}
1da177e4 268
a9de9248
MH		 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;
1da177e4 273
a9de9248 274 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 275
a9de9248
MH		 276 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
277 if (!sent)
278 return;
1da177e4 279
a9de9248
MH		 280 if (!status) {
281 __u8 param = *((__u8 *) sent);
1da177e4 282
a9de9248
MH		 283 clear_bit(HCI_PSCAN, &hdev->flags);
284 clear_bit(HCI_ISCAN, &hdev->flags);
1da177e4 285
a9de9248
MH		 286 if (param & SCAN_INQUIRY)
287 set_bit(HCI_ISCAN, &hdev->flags);
1da177e4 288
a9de9248
MH		 289 if (param & SCAN_PAGE)
290 set_bit(HCI_PSCAN, &hdev->flags);
291 }
1da177e4 292
a9de9248
MH		 293 hci_req_complete(hdev, status);
294}
1da177e4 295
a9de9248
MH		 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;
1da177e4 299
a9de9248 300 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 301
a9de9248
MH		 302 if (rp->status)
303 return;
1da177e4 304
a9de9248 305 memcpy(hdev->dev_class, rp->dev_class, 3);
1da177e4 306
a9de9248
MH		 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}
1da177e4 310
a9de9248
MH		 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;
1da177e4 315
a9de9248 316 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 317
f383f275
MH		 318 if (status)
319 return;
320
a9de9248
MH		 321 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
322 if (!sent)
323 return;
1da177e4 324
f383f275 325 memcpy(hdev->dev_class, sent, 3);
a9de9248 326}
1da177e4 327
a9de9248
MH		 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;
331 __u16 setting;
332
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
f383f275 340 if (hdev->voice_setting == setting)
a9de9248
MH		 341 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);
f383f275 357 __u16 setting;
a9de9248
MH		 358 void *sent;
359
360 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 361
f383f275
MH		 362 if (status)
363 return;
364
a9de9248
MH		 365 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
366 if (!sent)
367 return;
1da177e4 368
f383f275 369 setting = get_unaligned_le16(sent);
1da177e4 370
f383f275
MH		 371 if (hdev->voice_setting == setting)
372 return;
373
374 hdev->voice_setting = setting;
1da177e4 375
f383f275 376 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
1da177e4 377
f383f275
MH		 378 if (hdev->notify) {
379 tasklet_disable(&hdev->tx_task);
380 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
381 tasklet_enable(&hdev->tx_task);
1da177e4
LT		 382 }
383}
384
a9de9248 385static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 386{
a9de9248 387 __u8 status = *((__u8 *) skb->data);
1da177e4 388
a9de9248 389 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 390
a9de9248
MH		 391 hci_req_complete(hdev, status);
392}
1143e5a6 393
333140b5
MH		 394static 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
a9de9248
MH		 423static 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;
1143e5a6 426
a9de9248 427 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1143e5a6 428
a9de9248
MH		 429 if (rp->status)
430 return;
1143e5a6 431
a9de9248 432 hdev->hci_ver = rp->hci_ver;
e4e8e37c
MH		 433 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
434 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
1143e5a6 435
a9de9248
MH		 436 BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
437 hdev->manufacturer,
438 hdev->hci_ver, hdev->hci_rev);
439}
1da177e4 440
a9de9248
MH		 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;
1da177e4 444
a9de9248 445 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 446
a9de9248
MH		 447 if (rp->status)
448 return;
1da177e4 449
a9de9248
MH		 450 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
451}
1da177e4 452
a9de9248
MH		 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;
5b7f9909 456
a9de9248 457 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 458
a9de9248
MH		 459 if (rp->status)
460 return;
5b7f9909 461
a9de9248 462 memcpy(hdev->features, rp->features, 8);
5b7f9909 463
a9de9248
MH		 464 /* Adjust default settings according to features
465 * supported by device. */
1da177e4 466
a9de9248
MH		 467 if (hdev->features[0] & LMP_3SLOT)
468 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
1da177e4 469
a9de9248
MH		 470 if (hdev->features[0] & LMP_5SLOT)
471 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
1da177e4 472
a9de9248
MH		 473 if (hdev->features[1] & LMP_HV2) {
474 hdev->pkt_type |= (HCI_HV2);
475 hdev->esco_type |= (ESCO_HV2);
476 }
1da177e4 477
a9de9248
MH		 478 if (hdev->features[1] & LMP_HV3) {
479 hdev->pkt_type |= (HCI_HV3);
480 hdev->esco_type |= (ESCO_HV3);
481 }
1da177e4 482
a9de9248
MH		 483 if (hdev->features[3] & LMP_ESCO)
484 hdev->esco_type |= (ESCO_EV3);
da1f5198 485
a9de9248
MH		 486 if (hdev->features[4] & LMP_EV4)
487 hdev->esco_type |= (ESCO_EV4);
da1f5198 488
a9de9248
MH		 489 if (hdev->features[4] & LMP_EV5)
490 hdev->esco_type |= (ESCO_EV5);
1da177e4 491
a9de9248
MH		 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}
1da177e4 498
a9de9248
MH		 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;
1da177e4 502
a9de9248 503 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 504
a9de9248
MH		 505 if (rp->status)
506 return;
1da177e4 507
a9de9248
MH		 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;
1da177e4 516 }
a9de9248
MH		 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);
1da177e4
LT		 548}
549
1da177e4
LT		 550static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
551{
a9de9248 552 struct hci_cp_create_conn *cp;
1da177e4 553 struct hci_conn *conn;
1da177e4 554
a9de9248
MH		 555 BT_DBG("%s status 0x%x", hdev->name, status);
556
557 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
1da177e4
LT		 558 if (!cp)
559 return;
560
561 hci_dev_lock(hdev);
562
563 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
564
a9de9248 565 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
1da177e4
LT		 566
567 if (status) {
568 if (conn && conn->state == BT_CONNECT) {
4c67bc74
MH		 569 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;
1da177e4
LT		 575 }
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
a9de9248 590static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
1da177e4 591{
a9de9248
MH		 592 struct hci_cp_add_sco *cp;
593 struct hci_conn *acl, *sco;
594 __u16 handle;
1da177e4 595
b6a0dc82
MH		 596 BT_DBG("%s status 0x%x", hdev->name, status);
597
a9de9248
MH		 598 if (!status)
599 return;
1da177e4 600
a9de9248
MH		 601 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
602 if (!cp)
603 return;
1da177e4 604
a9de9248 605 handle = __le16_to_cpu(cp->handle);
1da177e4 606
a9de9248 607 BT_DBG("%s handle %d", hdev->name, handle);
1da177e4 608
a9de9248 609 hci_dev_lock(hdev);
1da177e4 610
a9de9248
MH		 611 acl = hci_conn_hash_lookup_handle(hdev, handle);
612 if (acl && (sco = acl->link)) {
613 sco->state = BT_CLOSED;
1da177e4 614
a9de9248
MH		 615 hci_proto_connect_cfm(sco, status);
616 hci_conn_del(sco);
617 }
1da177e4 618
a9de9248
MH		 619 hci_dev_unlock(hdev);
620}
1da177e4 621
a9de9248
MH		 622static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
623{
624 BT_DBG("%s status 0x%x", hdev->name, status);
625}
1da177e4 626
a9de9248
MH		 627static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
628{
b6a0dc82
MH		 629 struct hci_cp_setup_sync_conn *cp;
630 struct hci_conn *acl, *sco;
631 __u16 handle;
632
a9de9248 633 BT_DBG("%s status 0x%x", hdev->name, status);
b6a0dc82
MH		 634
635 if (!status)
636 return;
637
638 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
639 if (!cp)
640 return;
641
642 handle = __le16_to_cpu(cp->handle);
643
644 BT_DBG("%s handle %d", hdev->name, handle);
645
646 hci_dev_lock(hdev);
647
648 acl = hci_conn_hash_lookup_handle(hdev, handle);
649 if (acl && (sco = acl->link)) {
650 sco->state = BT_CLOSED;
651
652 hci_proto_connect_cfm(sco, status);
653 hci_conn_del(sco);
654 }
655
656 hci_dev_unlock(hdev);
1da177e4
LT		 657}
658
a9de9248 659static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
1da177e4 660{
a9de9248
MH		 661 struct hci_cp_sniff_mode *cp;
662 struct hci_conn *conn;
1da177e4 663
a9de9248 664 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 665
a9de9248
MH		 666 if (!status)
667 return;
04837f64 668
a9de9248
MH		 669 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
670 if (!cp)
671 return;
04837f64 672
a9de9248 673 hci_dev_lock(hdev);
04837f64 674
a9de9248
MH		 675 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
676 if (conn)
677 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
04837f64 678
a9de9248
MH		 679 hci_dev_unlock(hdev);
680}
04837f64 681
a9de9248
MH		 682static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
683{
684 struct hci_cp_exit_sniff_mode *cp;
685 struct hci_conn *conn;
04837f64 686
a9de9248 687 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 688
a9de9248
MH		 689 if (!status)
690 return;
04837f64 691
a9de9248
MH		 692 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
693 if (!cp)
694 return;
04837f64 695
a9de9248 696 hci_dev_lock(hdev);
1da177e4 697
a9de9248
MH		 698 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
699 if (conn)
700 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
1da177e4 701
a9de9248 702 hci_dev_unlock(hdev);
1da177e4
LT		 703}
704
1da177e4
LT		 705static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
706{
707 __u8 status = *((__u8 *) skb->data);
708
709 BT_DBG("%s status %d", hdev->name, status);
710
711 clear_bit(HCI_INQUIRY, &hdev->flags);
6bd57416 712
a9de9248 713 hci_req_complete(hdev, status);
6bd57416 714
a9de9248 715 hci_conn_check_pending(hdev);
1da177e4
LT		 716}
717
1da177e4
LT		 718static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
719{
45bb4bf0 720 struct inquiry_data data;
a9de9248 721 struct inquiry_info *info = (void *) (skb->data + 1);
1da177e4
LT		 722 int num_rsp = *((__u8 *) skb->data);
723
724 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
725
45bb4bf0
MH		 726 if (!num_rsp)
727 return;
728
1da177e4 729 hci_dev_lock(hdev);
45bb4bf0 730
1da177e4 731 for (; num_rsp; num_rsp--) {
1da177e4
LT		 732 bacpy(&data.bdaddr, &info->bdaddr);
733 data.pscan_rep_mode = info->pscan_rep_mode;
734 data.pscan_period_mode = info->pscan_period_mode;
735 data.pscan_mode = info->pscan_mode;
736 memcpy(data.dev_class, info->dev_class, 3);
737 data.clock_offset = info->clock_offset;
738 data.rssi = 0x00;
739 info++;
740 hci_inquiry_cache_update(hdev, &data);
741 }
45bb4bf0 742
1da177e4
LT		 743 hci_dev_unlock(hdev);
744}
745
1da177e4
LT		 746static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
747{
a9de9248
MH		 748 struct hci_ev_conn_complete *ev = (void *) skb->data;
749 struct hci_conn *conn;
1da177e4
LT		 750
751 BT_DBG("%s", hdev->name);
752
753 hci_dev_lock(hdev);
754
755 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
a9de9248
MH		 756 if (!conn)
757 goto unlock;
1da177e4
LT		 758
759 if (!ev->status) {
760 conn->handle = __le16_to_cpu(ev->handle);
761 conn->state = BT_CONNECTED;
762
763 if (test_bit(HCI_AUTH, &hdev->flags))
764 conn->link_mode |= HCI_LM_AUTH;
765
766 if (test_bit(HCI_ENCRYPT, &hdev->flags))
767 conn->link_mode |= HCI_LM_ENCRYPT;
768
04837f64
MH		 769 /* Get remote features */
770 if (conn->type == ACL_LINK) {
771 struct hci_cp_read_remote_features cp;
772 cp.handle = ev->handle;
a9de9248 773 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES, sizeof(cp), &cp);
04837f64
MH		 774 }
775
1da177e4 776 /* Set packet type for incoming connection */
a8746417 777 if (!conn->out && hdev->hci_ver < 3) {
1da177e4
LT		 778 struct hci_cp_change_conn_ptype cp;
779 cp.handle = ev->handle;
a8746417
MH		 780 cp.pkt_type = cpu_to_le16(conn->pkt_type);
781 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
782 sizeof(cp), &cp);
37e97b4e
MH		 783 } else {
784 /* Update disconnect timer */
785 hci_conn_hold(conn);
786 hci_conn_put(conn);
1da177e4
LT		 787 }
788 } else
789 conn->state = BT_CLOSED;
790
791 if (conn->type == ACL_LINK) {
792 struct hci_conn *sco = conn->link;
793 if (sco) {
b6a0dc82
MH		 794 if (!ev->status) {
795 if (lmp_esco_capable(hdev))
796 hci_setup_sync(sco, conn->handle);
797 else
798 hci_add_sco(sco, conn->handle);
799 } else {
1da177e4
LT		 800 hci_proto_connect_cfm(sco, ev->status);
801 hci_conn_del(sco);
802 }
803 }
804 }
805
806 hci_proto_connect_cfm(conn, ev->status);
807 if (ev->status)
808 hci_conn_del(conn);
809
a9de9248 810unlock:
1da177e4 811 hci_dev_unlock(hdev);
1da177e4 812
a9de9248 813 hci_conn_check_pending(hdev);
1da177e4
LT		 814}
815
a9de9248 816static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 817{
a9de9248
MH		 818 struct hci_ev_conn_request *ev = (void *) skb->data;
819 int mask = hdev->link_mode;
1da177e4 820
a9de9248
MH		 821 BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
822 batostr(&ev->bdaddr), ev->link_type);
1da177e4 823
a9de9248 824 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
1da177e4 825
a9de9248
MH		 826 if (mask & HCI_LM_ACCEPT) {
827 /* Connection accepted */
c7bdd502 828 struct inquiry_entry *ie;
1da177e4 829 struct hci_conn *conn;
1da177e4 830
a9de9248 831 hci_dev_lock(hdev);
b6a0dc82 832
c7bdd502
MH		 833 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))
834 memcpy(ie->data.dev_class, ev->dev_class, 3);
835
a9de9248
MH		 836 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
837 if (!conn) {
838 if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
839 BT_ERR("No memmory for new connection");
840 hci_dev_unlock(hdev);
841 return;
1da177e4
LT		 842 }
843 }
b6a0dc82 844
a9de9248
MH		 845 memcpy(conn->dev_class, ev->dev_class, 3);
846 conn->state = BT_CONNECT;
b6a0dc82 847
a9de9248 848 hci_dev_unlock(hdev);
1da177e4 849
b6a0dc82
MH		 850 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
851 struct hci_cp_accept_conn_req cp;
1da177e4 852
b6a0dc82
MH		 853 bacpy(&cp.bdaddr, &ev->bdaddr);
854
855 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
856 cp.role = 0x00; /* Become master */
857 else
858 cp.role = 0x01; /* Remain slave */
859
860 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
861 sizeof(cp), &cp);
862 } else {
863 struct hci_cp_accept_sync_conn_req cp;
864
865 bacpy(&cp.bdaddr, &ev->bdaddr);
a8746417 866 cp.pkt_type = cpu_to_le16(conn->pkt_type);
b6a0dc82
MH		 867
868 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
869 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
870 cp.max_latency = cpu_to_le16(0xffff);
871 cp.content_format = cpu_to_le16(hdev->voice_setting);
872 cp.retrans_effort = 0xff;
1da177e4 873
b6a0dc82
MH		 874 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
875 sizeof(cp), &cp);
876 }
a9de9248
MH		 877 } else {
878 /* Connection rejected */
879 struct hci_cp_reject_conn_req cp;
1da177e4 880
a9de9248
MH		 881 bacpy(&cp.bdaddr, &ev->bdaddr);
882 cp.reason = 0x0f;
883 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
1da177e4 884 }
1da177e4
LT		 885}
886
a9de9248 887static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
04837f64 888{
a9de9248 889 struct hci_ev_disconn_complete *ev = (void *) skb->data;
04837f64
MH		 890 struct hci_conn *conn;
891
892 BT_DBG("%s status %d", hdev->name, ev->status);
893
a9de9248
MH		 894 if (ev->status)
895 return;
896
04837f64
MH		 897 hci_dev_lock(hdev);
898
899 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
900 if (conn) {
a9de9248
MH		 901 conn->state = BT_CLOSED;
902 hci_proto_disconn_ind(conn, ev->reason);
903 hci_conn_del(conn);
04837f64
MH		 904 }
905
906 hci_dev_unlock(hdev);
907}
908
1da177e4
LT		 909static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
910{
a9de9248 911 struct hci_ev_auth_complete *ev = (void *) skb->data;
04837f64 912 struct hci_conn *conn;
1da177e4
LT		 913
914 BT_DBG("%s status %d", hdev->name, ev->status);
915
916 hci_dev_lock(hdev);
917
04837f64 918 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 919 if (conn) {
920 if (!ev->status)
921 conn->link_mode |= HCI_LM_AUTH;
922
923 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
924
925 hci_auth_cfm(conn, ev->status);
926
927 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
928 if (!ev->status) {
929 struct hci_cp_set_conn_encrypt cp;
aca3192c 930 cp.handle = cpu_to_le16(conn->handle);
1da177e4 931 cp.encrypt = 1;
a9de9248
MH		 932 hci_send_cmd(conn->hdev,
933 HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
1da177e4
LT		 934 } else {
935 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
936 hci_encrypt_cfm(conn, ev->status, 0x00);
937 }
938 }
939 }
940
941 hci_dev_unlock(hdev);
942}
943
a9de9248 944static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 945{
a9de9248 946 BT_DBG("%s", hdev->name);
1da177e4 947
a9de9248
MH		 948 hci_conn_check_pending(hdev);
949}
950
951static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
952{
953 struct hci_ev_encrypt_change *ev = (void *) skb->data;
954 struct hci_conn *conn;
955
956 BT_DBG("%s status %d", hdev->name, ev->status);
1da177e4
LT		 957
958 hci_dev_lock(hdev);
959
04837f64 960 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 961 if (conn) {
962 if (!ev->status) {
ae293196
MH		 963 if (ev->encrypt) {
964 /* Encryption implies authentication */
965 conn->link_mode |= HCI_LM_AUTH;
1da177e4 966 conn->link_mode |= HCI_LM_ENCRYPT;
ae293196 967 } else
1da177e4
LT		 968 conn->link_mode &= ~HCI_LM_ENCRYPT;
969 }
970
971 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
972
973 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
974 }
975
976 hci_dev_unlock(hdev);
977}
978
a9de9248 979static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 980{
a9de9248 981 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
04837f64 982 struct hci_conn *conn;
1da177e4
LT		 983
984 BT_DBG("%s status %d", hdev->name, ev->status);
985
986 hci_dev_lock(hdev);
987
04837f64 988 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 989 if (conn) {
990 if (!ev->status)
991 conn->link_mode |= HCI_LM_SECURE;
992
993 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
994
995 hci_key_change_cfm(conn, ev->status);
996 }
997
998 hci_dev_unlock(hdev);
999}
1000
a9de9248 1001static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1002{
a9de9248
MH		 1003 struct hci_ev_remote_features *ev = (void *) skb->data;
1004 struct hci_conn *conn;
1005
1006 BT_DBG("%s status %d", hdev->name, ev->status);
1007
1008 if (ev->status)
1009 return;
1010
1011 hci_dev_lock(hdev);
1012
1013 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1014 if (conn)
1015 memcpy(conn->features, ev->features, 8);
1016
1017 hci_dev_unlock(hdev);
1da177e4
LT		 1018}
1019
a9de9248 1020static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1021{
a9de9248 1022 BT_DBG("%s", hdev->name);
1da177e4
LT		 1023}
1024
a9de9248 1025static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1026{
a9de9248 1027 BT_DBG("%s", hdev->name);
1da177e4
LT		 1028}
1029
a9de9248
MH		 1030static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1031{
1032 struct hci_ev_cmd_complete *ev = (void *) skb->data;
1033 __u16 opcode;
1034
1035 skb_pull(skb, sizeof(*ev));
1036
1037 opcode = __le16_to_cpu(ev->opcode);
1038
1039 switch (opcode) {
1040 case HCI_OP_INQUIRY_CANCEL:
1041 hci_cc_inquiry_cancel(hdev, skb);
1042 break;
1043
1044 case HCI_OP_EXIT_PERIODIC_INQ:
1045 hci_cc_exit_periodic_inq(hdev, skb);
1046 break;
1047
1048 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
1049 hci_cc_remote_name_req_cancel(hdev, skb);
1050 break;
1051
1052 case HCI_OP_ROLE_DISCOVERY:
1053 hci_cc_role_discovery(hdev, skb);
1054 break;
1055
e4e8e37c
MH		 1056 case HCI_OP_READ_LINK_POLICY:
1057 hci_cc_read_link_policy(hdev, skb);
1058 break;
1059
a9de9248
MH		 1060 case HCI_OP_WRITE_LINK_POLICY:
1061 hci_cc_write_link_policy(hdev, skb);
1062 break;
1063
e4e8e37c
MH		 1064 case HCI_OP_READ_DEF_LINK_POLICY:
1065 hci_cc_read_def_link_policy(hdev, skb);
1066 break;
1067
1068 case HCI_OP_WRITE_DEF_LINK_POLICY:
1069 hci_cc_write_def_link_policy(hdev, skb);
1070 break;
1071
a9de9248
MH		 1072 case HCI_OP_RESET:
1073 hci_cc_reset(hdev, skb);
1074 break;
1075
1076 case HCI_OP_WRITE_LOCAL_NAME:
1077 hci_cc_write_local_name(hdev, skb);
1078 break;
1079
1080 case HCI_OP_READ_LOCAL_NAME:
1081 hci_cc_read_local_name(hdev, skb);
1082 break;
1083
1084 case HCI_OP_WRITE_AUTH_ENABLE:
1085 hci_cc_write_auth_enable(hdev, skb);
1086 break;
1087
1088 case HCI_OP_WRITE_ENCRYPT_MODE:
1089 hci_cc_write_encrypt_mode(hdev, skb);
1090 break;
1091
1092 case HCI_OP_WRITE_SCAN_ENABLE:
1093 hci_cc_write_scan_enable(hdev, skb);
1094 break;
1095
1096 case HCI_OP_READ_CLASS_OF_DEV:
1097 hci_cc_read_class_of_dev(hdev, skb);
1098 break;
1099
1100 case HCI_OP_WRITE_CLASS_OF_DEV:
1101 hci_cc_write_class_of_dev(hdev, skb);
1102 break;
1103
1104 case HCI_OP_READ_VOICE_SETTING:
1105 hci_cc_read_voice_setting(hdev, skb);
1106 break;
1107
1108 case HCI_OP_WRITE_VOICE_SETTING:
1109 hci_cc_write_voice_setting(hdev, skb);
1110 break;
1111
1112 case HCI_OP_HOST_BUFFER_SIZE:
1113 hci_cc_host_buffer_size(hdev, skb);
1114 break;
1115
333140b5
MH		 1116 case HCI_OP_READ_SSP_MODE:
1117 hci_cc_read_ssp_mode(hdev, skb);
1118 break;
1119
1120 case HCI_OP_WRITE_SSP_MODE:
1121 hci_cc_write_ssp_mode(hdev, skb);
1122 break;
1123
a9de9248
MH		 1124 case HCI_OP_READ_LOCAL_VERSION:
1125 hci_cc_read_local_version(hdev, skb);
1126 break;
1127
1128 case HCI_OP_READ_LOCAL_COMMANDS:
1129 hci_cc_read_local_commands(hdev, skb);
1130 break;
1131
1132 case HCI_OP_READ_LOCAL_FEATURES:
1133 hci_cc_read_local_features(hdev, skb);
1134 break;
1135
1136 case HCI_OP_READ_BUFFER_SIZE:
1137 hci_cc_read_buffer_size(hdev, skb);
1138 break;
1139
1140 case HCI_OP_READ_BD_ADDR:
1141 hci_cc_read_bd_addr(hdev, skb);
1142 break;
1143
1144 default:
1145 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1146 break;
1147 }
1148
1149 if (ev->ncmd) {
1150 atomic_set(&hdev->cmd_cnt, 1);
1151 if (!skb_queue_empty(&hdev->cmd_q))
1152 hci_sched_cmd(hdev);
1153 }
1154}
1155
1156static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1157{
1158 struct hci_ev_cmd_status *ev = (void *) skb->data;
1159 __u16 opcode;
1160
1161 skb_pull(skb, sizeof(*ev));
1162
1163 opcode = __le16_to_cpu(ev->opcode);
1164
1165 switch (opcode) {
1166 case HCI_OP_INQUIRY:
1167 hci_cs_inquiry(hdev, ev->status);
1168 break;
1169
1170 case HCI_OP_CREATE_CONN:
1171 hci_cs_create_conn(hdev, ev->status);
1172 break;
1173
1174 case HCI_OP_ADD_SCO:
1175 hci_cs_add_sco(hdev, ev->status);
1176 break;
1177
1178 case HCI_OP_REMOTE_NAME_REQ:
1179 hci_cs_remote_name_req(hdev, ev->status);
1180 break;
1181
1182 case HCI_OP_SETUP_SYNC_CONN:
1183 hci_cs_setup_sync_conn(hdev, ev->status);
1184 break;
1185
1186 case HCI_OP_SNIFF_MODE:
1187 hci_cs_sniff_mode(hdev, ev->status);
1188 break;
1189
1190 case HCI_OP_EXIT_SNIFF_MODE:
1191 hci_cs_exit_sniff_mode(hdev, ev->status);
1192 break;
1193
1194 default:
1195 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1196 break;
1197 }
1198
1199 if (ev->ncmd) {
1200 atomic_set(&hdev->cmd_cnt, 1);
1201 if (!skb_queue_empty(&hdev->cmd_q))
1202 hci_sched_cmd(hdev);
1203 }
1204}
1205
1206static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1207{
1208 struct hci_ev_role_change *ev = (void *) skb->data;
1209 struct hci_conn *conn;
1210
1211 BT_DBG("%s status %d", hdev->name, ev->status);
1212
1213 hci_dev_lock(hdev);
1214
1215 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1216 if (conn) {
1217 if (!ev->status) {
1218 if (ev->role)
1219 conn->link_mode &= ~HCI_LM_MASTER;
1220 else
1221 conn->link_mode |= HCI_LM_MASTER;
1222 }
1223
1224 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1225
1226 hci_role_switch_cfm(conn, ev->status, ev->role);
1227 }
1228
1229 hci_dev_unlock(hdev);
1230}
1231
1232static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1233{
1234 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
1235 __le16 *ptr;
1236 int i;
1237
1238 skb_pull(skb, sizeof(*ev));
1239
1240 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1241
1242 if (skb->len < ev->num_hndl * 4) {
1243 BT_DBG("%s bad parameters", hdev->name);
1244 return;
1245 }
1246
1247 tasklet_disable(&hdev->tx_task);
1248
1249 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
1250 struct hci_conn *conn;
1251 __u16 handle, count;
1252
83985319
HH		 1253 handle = get_unaligned_le16(ptr++);
1254 count = get_unaligned_le16(ptr++);
a9de9248
MH		 1255
1256 conn = hci_conn_hash_lookup_handle(hdev, handle);
1257 if (conn) {
1258 conn->sent -= count;
1259
1260 if (conn->type == ACL_LINK) {
1261 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
1262 hdev->acl_cnt = hdev->acl_pkts;
1263 } else {
1264 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
1265 hdev->sco_cnt = hdev->sco_pkts;
1266 }
1267 }
1268 }
1269
1270 hci_sched_tx(hdev);
1271
1272 tasklet_enable(&hdev->tx_task);
1273}
1274
1275static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
04837f64 1276{
a9de9248 1277 struct hci_ev_mode_change *ev = (void *) skb->data;
04837f64
MH		 1278 struct hci_conn *conn;
1279
1280 BT_DBG("%s status %d", hdev->name, ev->status);
1281
1282 hci_dev_lock(hdev);
1283
1284 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
a9de9248
MH		 1285 if (conn) {
1286 conn->mode = ev->mode;
1287 conn->interval = __le16_to_cpu(ev->interval);
1288
1289 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1290 if (conn->mode == HCI_CM_ACTIVE)
1291 conn->power_save = 1;
1292 else
1293 conn->power_save = 0;
1294 }
04837f64
MH		 1295 }
1296
1297 hci_dev_unlock(hdev);
1298}
1299
a9de9248
MH		 1300static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1301{
1302 BT_DBG("%s", hdev->name);
1303}
1304
1305static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1306{
1307 BT_DBG("%s", hdev->name);
1308}
1309
1310static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1311{
1312 BT_DBG("%s", hdev->name);
1313}
1314
1da177e4
LT		 1315static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1316{
a9de9248 1317 struct hci_ev_clock_offset *ev = (void *) skb->data;
04837f64 1318 struct hci_conn *conn;
1da177e4
LT		 1319
1320 BT_DBG("%s status %d", hdev->name, ev->status);
1321
1322 hci_dev_lock(hdev);
1323
04837f64 1324 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 1325 if (conn && !ev->status) {
1326 struct inquiry_entry *ie;
1327
1328 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1329 ie->data.clock_offset = ev->clock_offset;
1330 ie->timestamp = jiffies;
1331 }
1332 }
1333
1334 hci_dev_unlock(hdev);
1335}
1336
a8746417
MH		 1337static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1338{
1339 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
1340 struct hci_conn *conn;
1341
1342 BT_DBG("%s status %d", hdev->name, ev->status);
1343
1344 hci_dev_lock(hdev);
1345
1346 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1347 if (conn && !ev->status)
1348 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
1349
1350 hci_dev_unlock(hdev);
1351}
1352
85a1e930
MH		 1353static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1354{
a9de9248 1355 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
85a1e930
MH		 1356 struct inquiry_entry *ie;
1357
1358 BT_DBG("%s", hdev->name);
1359
1360 hci_dev_lock(hdev);
1361
1362 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1363 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1364 ie->timestamp = jiffies;
1365 }
1366
1367 hci_dev_unlock(hdev);
1368}
1369
a9de9248
MH		 1370static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1371{
1372 struct inquiry_data data;
1373 int num_rsp = *((__u8 *) skb->data);
1374
1375 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1376
1377 if (!num_rsp)
1378 return;
1379
1380 hci_dev_lock(hdev);
1381
1382 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1383 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1384
1385 for (; num_rsp; num_rsp--) {
1386 bacpy(&data.bdaddr, &info->bdaddr);
1387 data.pscan_rep_mode = info->pscan_rep_mode;
1388 data.pscan_period_mode = info->pscan_period_mode;
1389 data.pscan_mode = info->pscan_mode;
1390 memcpy(data.dev_class, info->dev_class, 3);
1391 data.clock_offset = info->clock_offset;
1392 data.rssi = info->rssi;
1393 info++;
1394 hci_inquiry_cache_update(hdev, &data);
1395 }
1396 } else {
1397 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1398
1399 for (; num_rsp; num_rsp--) {
1400 bacpy(&data.bdaddr, &info->bdaddr);
1401 data.pscan_rep_mode = info->pscan_rep_mode;
1402 data.pscan_period_mode = info->pscan_period_mode;
1403 data.pscan_mode = 0x00;
1404 memcpy(data.dev_class, info->dev_class, 3);
1405 data.clock_offset = info->clock_offset;
1406 data.rssi = info->rssi;
1407 info++;
1408 hci_inquiry_cache_update(hdev, &data);
1409 }
1410 }
1411
1412 hci_dev_unlock(hdev);
1413}
1414
1415static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1416{
1417 BT_DBG("%s", hdev->name);
1418}
1419
1420static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1421{
b6a0dc82
MH		 1422 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1423 struct hci_conn *conn;
1424
1425 BT_DBG("%s status %d", hdev->name, ev->status);
1426
1427 hci_dev_lock(hdev);
1428
1429 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
9dc0a3af
MH		 1430 if (!conn) {
1431 if (ev->link_type == ESCO_LINK)
1432 goto unlock;
1433
1434 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1435 if (!conn)
1436 goto unlock;
1437
1438 conn->type = SCO_LINK;
1439 }
b6a0dc82
MH		 1440
1441 if (!ev->status) {
1442 conn->handle = __le16_to_cpu(ev->handle);
1443 conn->state = BT_CONNECTED;
1444 } else
1445 conn->state = BT_CLOSED;
1446
1447 hci_proto_connect_cfm(conn, ev->status);
1448 if (ev->status)
1449 hci_conn_del(conn);
1450
1451unlock:
1452 hci_dev_unlock(hdev);
a9de9248
MH		 1453}
1454
1455static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1456{
1457 BT_DBG("%s", hdev->name);
1458}
1459
04837f64
MH		 1460static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1461{
a9de9248 1462 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
04837f64
MH		 1463 struct hci_conn *conn;
1464
1465 BT_DBG("%s status %d", hdev->name, ev->status);
1466
1467 hci_dev_lock(hdev);
1468
1469 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1470 if (conn) {
1471 }
1472
1473 hci_dev_unlock(hdev);
1474}
1475
a9de9248 1476static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1477{
a9de9248
MH		 1478 struct inquiry_data data;
1479 struct extended_inquiry_info *info = (void *) (skb->data + 1);
1480 int num_rsp = *((__u8 *) skb->data);
1da177e4 1481
a9de9248 1482 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1da177e4 1483
a9de9248
MH		 1484 if (!num_rsp)
1485 return;
1da177e4 1486
a9de9248
MH		 1487 hci_dev_lock(hdev);
1488
1489 for (; num_rsp; num_rsp--) {
1490 bacpy(&data.bdaddr, &info->bdaddr);
1491 data.pscan_rep_mode = info->pscan_rep_mode;
1492 data.pscan_period_mode = info->pscan_period_mode;
1493 data.pscan_mode = 0x00;
1494 memcpy(data.dev_class, info->dev_class, 3);
1495 data.clock_offset = info->clock_offset;
1496 data.rssi = info->rssi;
1497 info++;
1498 hci_inquiry_cache_update(hdev, &data);
1499 }
1500
1501 hci_dev_unlock(hdev);
1502}
1da177e4 1503
0493684e
MH		 1504static inline void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1505{
1506 struct hci_ev_io_capa_request *ev = (void *) skb->data;
1507 struct hci_conn *conn;
1508
1509 BT_DBG("%s", hdev->name);
1510
1511 hci_dev_lock(hdev);
1512
1513 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1514 if (conn)
1515 hci_conn_hold(conn);
1516
1517 hci_dev_unlock(hdev);
1518}
1519
1520static inline void hci_simple_pair_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1521{
1522 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
1523 struct hci_conn *conn;
1524
1525 BT_DBG("%s", hdev->name);
1526
1527 hci_dev_lock(hdev);
1528
1529 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1530 if (conn)
1531 hci_conn_put(conn);
1532
1533 hci_dev_unlock(hdev);
1534}
1535
a9de9248
MH		 1536void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1537{
1538 struct hci_event_hdr *hdr = (void *) skb->data;
1539 __u8 event = hdr->evt;
1540
1541 skb_pull(skb, HCI_EVENT_HDR_SIZE);
1542
1543 switch (event) {
1da177e4
LT		 1544 case HCI_EV_INQUIRY_COMPLETE:
1545 hci_inquiry_complete_evt(hdev, skb);
1546 break;
1547
1548 case HCI_EV_INQUIRY_RESULT:
1549 hci_inquiry_result_evt(hdev, skb);
1550 break;
1551
a9de9248
MH		 1552 case HCI_EV_CONN_COMPLETE:
1553 hci_conn_complete_evt(hdev, skb);
21d9e30e
MH		 1554 break;
1555
1da177e4
LT		 1556 case HCI_EV_CONN_REQUEST:
1557 hci_conn_request_evt(hdev, skb);
1558 break;
1559
1da177e4
LT		 1560 case HCI_EV_DISCONN_COMPLETE:
1561 hci_disconn_complete_evt(hdev, skb);
1562 break;
1563
1da177e4
LT		 1564 case HCI_EV_AUTH_COMPLETE:
1565 hci_auth_complete_evt(hdev, skb);
1566 break;
1567
a9de9248
MH		 1568 case HCI_EV_REMOTE_NAME:
1569 hci_remote_name_evt(hdev, skb);
1570 break;
1571
1da177e4
LT		 1572 case HCI_EV_ENCRYPT_CHANGE:
1573 hci_encrypt_change_evt(hdev, skb);
1574 break;
1575
a9de9248
MH		 1576 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
1577 hci_change_link_key_complete_evt(hdev, skb);
1578 break;
1579
1580 case HCI_EV_REMOTE_FEATURES:
1581 hci_remote_features_evt(hdev, skb);
1582 break;
1583
1584 case HCI_EV_REMOTE_VERSION:
1585 hci_remote_version_evt(hdev, skb);
1586 break;
1587
1588 case HCI_EV_QOS_SETUP_COMPLETE:
1589 hci_qos_setup_complete_evt(hdev, skb);
1590 break;
1591
1592 case HCI_EV_CMD_COMPLETE:
1593 hci_cmd_complete_evt(hdev, skb);
1594 break;
1595
1596 case HCI_EV_CMD_STATUS:
1597 hci_cmd_status_evt(hdev, skb);
1598 break;
1599
1600 case HCI_EV_ROLE_CHANGE:
1601 hci_role_change_evt(hdev, skb);
1602 break;
1603
1604 case HCI_EV_NUM_COMP_PKTS:
1605 hci_num_comp_pkts_evt(hdev, skb);
1606 break;
1607
1608 case HCI_EV_MODE_CHANGE:
1609 hci_mode_change_evt(hdev, skb);
1da177e4
LT		 1610 break;
1611
1612 case HCI_EV_PIN_CODE_REQ:
1613 hci_pin_code_request_evt(hdev, skb);
1614 break;
1615
1616 case HCI_EV_LINK_KEY_REQ:
1617 hci_link_key_request_evt(hdev, skb);
1618 break;
1619
1620 case HCI_EV_LINK_KEY_NOTIFY:
1621 hci_link_key_notify_evt(hdev, skb);
1622 break;
1623
1624 case HCI_EV_CLOCK_OFFSET:
1625 hci_clock_offset_evt(hdev, skb);
1626 break;
1627
a8746417
MH		 1628 case HCI_EV_PKT_TYPE_CHANGE:
1629 hci_pkt_type_change_evt(hdev, skb);
1630 break;
1631
85a1e930
MH		 1632 case HCI_EV_PSCAN_REP_MODE:
1633 hci_pscan_rep_mode_evt(hdev, skb);
1634 break;
1635
a9de9248
MH		 1636 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1637 hci_inquiry_result_with_rssi_evt(hdev, skb);
04837f64
MH		 1638 break;
1639
a9de9248
MH		 1640 case HCI_EV_REMOTE_EXT_FEATURES:
1641 hci_remote_ext_features_evt(hdev, skb);
1da177e4
LT		 1642 break;
1643
a9de9248
MH		 1644 case HCI_EV_SYNC_CONN_COMPLETE:
1645 hci_sync_conn_complete_evt(hdev, skb);
1646 break;
1da177e4 1647
a9de9248
MH		 1648 case HCI_EV_SYNC_CONN_CHANGED:
1649 hci_sync_conn_changed_evt(hdev, skb);
1650 break;
1da177e4 1651
a9de9248
MH		 1652 case HCI_EV_SNIFF_SUBRATE:
1653 hci_sniff_subrate_evt(hdev, skb);
1654 break;
1da177e4 1655
a9de9248
MH		 1656 case HCI_EV_EXTENDED_INQUIRY_RESULT:
1657 hci_extended_inquiry_result_evt(hdev, skb);
1658 break;
1da177e4 1659
0493684e
MH		 1660 case HCI_EV_IO_CAPA_REQUEST:
1661 hci_io_capa_request_evt(hdev, skb);
1662 break;
1663
1664 case HCI_EV_SIMPLE_PAIR_COMPLETE:
1665 hci_simple_pair_complete_evt(hdev, skb);
1666 break;
1667
a9de9248
MH		 1668 default:
1669 BT_DBG("%s event 0x%x", hdev->name, event);
1da177e4
LT		 1670 break;
1671 }
1672
1673 kfree_skb(skb);
1674 hdev->stat.evt_rx++;
1675}
1676
1677/* Generate internal stack event */
1678void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1679{
1680 struct hci_event_hdr *hdr;
1681 struct hci_ev_stack_internal *ev;
1682 struct sk_buff *skb;
1683
1684 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1685 if (!skb)
1686 return;
1687
1688 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1689 hdr->evt = HCI_EV_STACK_INTERNAL;
1690 hdr->plen = sizeof(*ev) + dlen;
1691
1692 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
1693 ev->type = type;
1694 memcpy(ev->data, data, dlen);
1695
576c7d85 1696 bt_cb(skb)->incoming = 1;
a61bbcf2 1697 __net_timestamp(skb);
576c7d85 1698
0d48d939 1699 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
1da177e4
LT		 1700 skb->dev = (void *) hdev;
1701 hci_send_to_sock(hdev, skb);
1702 kfree_skb(skb);
1703}
kernel source for telekom puls (alcatel/mediatek)