projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bluetooth: use get/put_unaligned_* helpers
[deliverable/linux.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) {
886 if (ev->encrypt)
887 conn->link_mode |= HCI_LM_ENCRYPT;
888 else
889 conn->link_mode &= ~HCI_LM_ENCRYPT;
890 }
891
892 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
893
894 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
895 }
896
897 hci_dev_unlock(hdev);
898}
899
a9de9248 900static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 901{
a9de9248 902 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
04837f64 903 struct hci_conn *conn;
1da177e4
LT		 904
905 BT_DBG("%s status %d", hdev->name, ev->status);
906
907 hci_dev_lock(hdev);
908
04837f64 909 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 910 if (conn) {
911 if (!ev->status)
912 conn->link_mode |= HCI_LM_SECURE;
913
914 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
915
916 hci_key_change_cfm(conn, ev->status);
917 }
918
919 hci_dev_unlock(hdev);
920}
921
a9de9248 922static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 923{
a9de9248
MH		 924 struct hci_ev_remote_features *ev = (void *) skb->data;
925 struct hci_conn *conn;
926
927 BT_DBG("%s status %d", hdev->name, ev->status);
928
929 if (ev->status)
930 return;
931
932 hci_dev_lock(hdev);
933
934 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
935 if (conn)
936 memcpy(conn->features, ev->features, 8);
937
938 hci_dev_unlock(hdev);
1da177e4
LT		 939}
940
a9de9248 941static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 942{
a9de9248 943 BT_DBG("%s", hdev->name);
1da177e4
LT		 944}
945
a9de9248 946static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 947{
a9de9248 948 BT_DBG("%s", hdev->name);
1da177e4
LT		 949}
950
a9de9248
MH		 951static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
952{
953 struct hci_ev_cmd_complete *ev = (void *) skb->data;
954 __u16 opcode;
955
956 skb_pull(skb, sizeof(*ev));
957
958 opcode = __le16_to_cpu(ev->opcode);
959
960 switch (opcode) {
961 case HCI_OP_INQUIRY_CANCEL:
962 hci_cc_inquiry_cancel(hdev, skb);
963 break;
964
965 case HCI_OP_EXIT_PERIODIC_INQ:
966 hci_cc_exit_periodic_inq(hdev, skb);
967 break;
968
969 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
970 hci_cc_remote_name_req_cancel(hdev, skb);
971 break;
972
973 case HCI_OP_ROLE_DISCOVERY:
974 hci_cc_role_discovery(hdev, skb);
975 break;
976
977 case HCI_OP_WRITE_LINK_POLICY:
978 hci_cc_write_link_policy(hdev, skb);
979 break;
980
981 case HCI_OP_RESET:
982 hci_cc_reset(hdev, skb);
983 break;
984
985 case HCI_OP_WRITE_LOCAL_NAME:
986 hci_cc_write_local_name(hdev, skb);
987 break;
988
989 case HCI_OP_READ_LOCAL_NAME:
990 hci_cc_read_local_name(hdev, skb);
991 break;
992
993 case HCI_OP_WRITE_AUTH_ENABLE:
994 hci_cc_write_auth_enable(hdev, skb);
995 break;
996
997 case HCI_OP_WRITE_ENCRYPT_MODE:
998 hci_cc_write_encrypt_mode(hdev, skb);
999 break;
1000
1001 case HCI_OP_WRITE_SCAN_ENABLE:
1002 hci_cc_write_scan_enable(hdev, skb);
1003 break;
1004
1005 case HCI_OP_READ_CLASS_OF_DEV:
1006 hci_cc_read_class_of_dev(hdev, skb);
1007 break;
1008
1009 case HCI_OP_WRITE_CLASS_OF_DEV:
1010 hci_cc_write_class_of_dev(hdev, skb);
1011 break;
1012
1013 case HCI_OP_READ_VOICE_SETTING:
1014 hci_cc_read_voice_setting(hdev, skb);
1015 break;
1016
1017 case HCI_OP_WRITE_VOICE_SETTING:
1018 hci_cc_write_voice_setting(hdev, skb);
1019 break;
1020
1021 case HCI_OP_HOST_BUFFER_SIZE:
1022 hci_cc_host_buffer_size(hdev, skb);
1023 break;
1024
1025 case HCI_OP_READ_LOCAL_VERSION:
1026 hci_cc_read_local_version(hdev, skb);
1027 break;
1028
1029 case HCI_OP_READ_LOCAL_COMMANDS:
1030 hci_cc_read_local_commands(hdev, skb);
1031 break;
1032
1033 case HCI_OP_READ_LOCAL_FEATURES:
1034 hci_cc_read_local_features(hdev, skb);
1035 break;
1036
1037 case HCI_OP_READ_BUFFER_SIZE:
1038 hci_cc_read_buffer_size(hdev, skb);
1039 break;
1040
1041 case HCI_OP_READ_BD_ADDR:
1042 hci_cc_read_bd_addr(hdev, skb);
1043 break;
1044
1045 default:
1046 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1047 break;
1048 }
1049
1050 if (ev->ncmd) {
1051 atomic_set(&hdev->cmd_cnt, 1);
1052 if (!skb_queue_empty(&hdev->cmd_q))
1053 hci_sched_cmd(hdev);
1054 }
1055}
1056
1057static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1058{
1059 struct hci_ev_cmd_status *ev = (void *) skb->data;
1060 __u16 opcode;
1061
1062 skb_pull(skb, sizeof(*ev));
1063
1064 opcode = __le16_to_cpu(ev->opcode);
1065
1066 switch (opcode) {
1067 case HCI_OP_INQUIRY:
1068 hci_cs_inquiry(hdev, ev->status);
1069 break;
1070
1071 case HCI_OP_CREATE_CONN:
1072 hci_cs_create_conn(hdev, ev->status);
1073 break;
1074
1075 case HCI_OP_ADD_SCO:
1076 hci_cs_add_sco(hdev, ev->status);
1077 break;
1078
1079 case HCI_OP_REMOTE_NAME_REQ:
1080 hci_cs_remote_name_req(hdev, ev->status);
1081 break;
1082
1083 case HCI_OP_SETUP_SYNC_CONN:
1084 hci_cs_setup_sync_conn(hdev, ev->status);
1085 break;
1086
1087 case HCI_OP_SNIFF_MODE:
1088 hci_cs_sniff_mode(hdev, ev->status);
1089 break;
1090
1091 case HCI_OP_EXIT_SNIFF_MODE:
1092 hci_cs_exit_sniff_mode(hdev, ev->status);
1093 break;
1094
1095 default:
1096 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1097 break;
1098 }
1099
1100 if (ev->ncmd) {
1101 atomic_set(&hdev->cmd_cnt, 1);
1102 if (!skb_queue_empty(&hdev->cmd_q))
1103 hci_sched_cmd(hdev);
1104 }
1105}
1106
1107static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1108{
1109 struct hci_ev_role_change *ev = (void *) skb->data;
1110 struct hci_conn *conn;
1111
1112 BT_DBG("%s status %d", hdev->name, ev->status);
1113
1114 hci_dev_lock(hdev);
1115
1116 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1117 if (conn) {
1118 if (!ev->status) {
1119 if (ev->role)
1120 conn->link_mode &= ~HCI_LM_MASTER;
1121 else
1122 conn->link_mode |= HCI_LM_MASTER;
1123 }
1124
1125 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1126
1127 hci_role_switch_cfm(conn, ev->status, ev->role);
1128 }
1129
1130 hci_dev_unlock(hdev);
1131}
1132
1133static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1134{
1135 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
1136 __le16 *ptr;
1137 int i;
1138
1139 skb_pull(skb, sizeof(*ev));
1140
1141 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1142
1143 if (skb->len < ev->num_hndl * 4) {
1144 BT_DBG("%s bad parameters", hdev->name);
1145 return;
1146 }
1147
1148 tasklet_disable(&hdev->tx_task);
1149
1150 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
1151 struct hci_conn *conn;
1152 __u16 handle, count;
1153
83985319
HH		 1154 handle = get_unaligned_le16(ptr++);
1155 count = get_unaligned_le16(ptr++);
a9de9248
MH		 1156
1157 conn = hci_conn_hash_lookup_handle(hdev, handle);
1158 if (conn) {
1159 conn->sent -= count;
1160
1161 if (conn->type == ACL_LINK) {
1162 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
1163 hdev->acl_cnt = hdev->acl_pkts;
1164 } else {
1165 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
1166 hdev->sco_cnt = hdev->sco_pkts;
1167 }
1168 }
1169 }
1170
1171 hci_sched_tx(hdev);
1172
1173 tasklet_enable(&hdev->tx_task);
1174}
1175
1176static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
04837f64 1177{
a9de9248 1178 struct hci_ev_mode_change *ev = (void *) skb->data;
04837f64
MH		 1179 struct hci_conn *conn;
1180
1181 BT_DBG("%s status %d", hdev->name, ev->status);
1182
1183 hci_dev_lock(hdev);
1184
1185 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
a9de9248
MH		 1186 if (conn) {
1187 conn->mode = ev->mode;
1188 conn->interval = __le16_to_cpu(ev->interval);
1189
1190 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1191 if (conn->mode == HCI_CM_ACTIVE)
1192 conn->power_save = 1;
1193 else
1194 conn->power_save = 0;
1195 }
04837f64
MH		 1196 }
1197
1198 hci_dev_unlock(hdev);
1199}
1200
a9de9248
MH		 1201static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1202{
1203 BT_DBG("%s", hdev->name);
1204}
1205
1206static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1207{
1208 BT_DBG("%s", hdev->name);
1209}
1210
1211static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1212{
1213 BT_DBG("%s", hdev->name);
1214}
1215
1da177e4
LT		 1216static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1217{
a9de9248 1218 struct hci_ev_clock_offset *ev = (void *) skb->data;
04837f64 1219 struct hci_conn *conn;
1da177e4
LT		 1220
1221 BT_DBG("%s status %d", hdev->name, ev->status);
1222
1223 hci_dev_lock(hdev);
1224
04837f64 1225 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 1226 if (conn && !ev->status) {
1227 struct inquiry_entry *ie;
1228
1229 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1230 ie->data.clock_offset = ev->clock_offset;
1231 ie->timestamp = jiffies;
1232 }
1233 }
1234
1235 hci_dev_unlock(hdev);
1236}
1237
85a1e930
MH		 1238static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1239{
a9de9248 1240 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
85a1e930
MH		 1241 struct inquiry_entry *ie;
1242
1243 BT_DBG("%s", hdev->name);
1244
1245 hci_dev_lock(hdev);
1246
1247 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1248 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1249 ie->timestamp = jiffies;
1250 }
1251
1252 hci_dev_unlock(hdev);
1253}
1254
a9de9248
MH		 1255static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1256{
1257 struct inquiry_data data;
1258 int num_rsp = *((__u8 *) skb->data);
1259
1260 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1261
1262 if (!num_rsp)
1263 return;
1264
1265 hci_dev_lock(hdev);
1266
1267 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1268 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1269
1270 for (; num_rsp; num_rsp--) {
1271 bacpy(&data.bdaddr, &info->bdaddr);
1272 data.pscan_rep_mode = info->pscan_rep_mode;
1273 data.pscan_period_mode = info->pscan_period_mode;
1274 data.pscan_mode = info->pscan_mode;
1275 memcpy(data.dev_class, info->dev_class, 3);
1276 data.clock_offset = info->clock_offset;
1277 data.rssi = info->rssi;
1278 info++;
1279 hci_inquiry_cache_update(hdev, &data);
1280 }
1281 } else {
1282 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1283
1284 for (; num_rsp; num_rsp--) {
1285 bacpy(&data.bdaddr, &info->bdaddr);
1286 data.pscan_rep_mode = info->pscan_rep_mode;
1287 data.pscan_period_mode = info->pscan_period_mode;
1288 data.pscan_mode = 0x00;
1289 memcpy(data.dev_class, info->dev_class, 3);
1290 data.clock_offset = info->clock_offset;
1291 data.rssi = info->rssi;
1292 info++;
1293 hci_inquiry_cache_update(hdev, &data);
1294 }
1295 }
1296
1297 hci_dev_unlock(hdev);
1298}
1299
1300static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1301{
1302 BT_DBG("%s", hdev->name);
1303}
1304
1305static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1306{
b6a0dc82
MH		 1307 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1308 struct hci_conn *conn;
1309
1310 BT_DBG("%s status %d", hdev->name, ev->status);
1311
1312 hci_dev_lock(hdev);
1313
1314 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
1315 if (!conn)
1316 goto unlock;
1317
1318 if (!ev->status) {
1319 conn->handle = __le16_to_cpu(ev->handle);
1320 conn->state = BT_CONNECTED;
1321 } else
1322 conn->state = BT_CLOSED;
1323
1324 hci_proto_connect_cfm(conn, ev->status);
1325 if (ev->status)
1326 hci_conn_del(conn);
1327
1328unlock:
1329 hci_dev_unlock(hdev);
a9de9248
MH		 1330}
1331
1332static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1333{
1334 BT_DBG("%s", hdev->name);
1335}
1336
04837f64
MH		 1337static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1338{
a9de9248 1339 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
04837f64
MH		 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) {
1348 }
1349
1350 hci_dev_unlock(hdev);
1351}
1352
a9de9248 1353static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1354{
a9de9248
MH		 1355 struct inquiry_data data;
1356 struct extended_inquiry_info *info = (void *) (skb->data + 1);
1357 int num_rsp = *((__u8 *) skb->data);
1da177e4 1358
a9de9248 1359 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1da177e4 1360
a9de9248
MH		 1361 if (!num_rsp)
1362 return;
1da177e4 1363
a9de9248
MH		 1364 hci_dev_lock(hdev);
1365
1366 for (; num_rsp; num_rsp--) {
1367 bacpy(&data.bdaddr, &info->bdaddr);
1368 data.pscan_rep_mode = info->pscan_rep_mode;
1369 data.pscan_period_mode = info->pscan_period_mode;
1370 data.pscan_mode = 0x00;
1371 memcpy(data.dev_class, info->dev_class, 3);
1372 data.clock_offset = info->clock_offset;
1373 data.rssi = info->rssi;
1374 info++;
1375 hci_inquiry_cache_update(hdev, &data);
1376 }
1377
1378 hci_dev_unlock(hdev);
1379}
1da177e4 1380
a9de9248
MH		 1381void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1382{
1383 struct hci_event_hdr *hdr = (void *) skb->data;
1384 __u8 event = hdr->evt;
1385
1386 skb_pull(skb, HCI_EVENT_HDR_SIZE);
1387
1388 switch (event) {
1da177e4
LT		 1389 case HCI_EV_INQUIRY_COMPLETE:
1390 hci_inquiry_complete_evt(hdev, skb);
1391 break;
1392
1393 case HCI_EV_INQUIRY_RESULT:
1394 hci_inquiry_result_evt(hdev, skb);
1395 break;
1396
a9de9248
MH		 1397 case HCI_EV_CONN_COMPLETE:
1398 hci_conn_complete_evt(hdev, skb);
21d9e30e
MH		 1399 break;
1400
1da177e4
LT		 1401 case HCI_EV_CONN_REQUEST:
1402 hci_conn_request_evt(hdev, skb);
1403 break;
1404
1da177e4
LT		 1405 case HCI_EV_DISCONN_COMPLETE:
1406 hci_disconn_complete_evt(hdev, skb);
1407 break;
1408
1da177e4
LT		 1409 case HCI_EV_AUTH_COMPLETE:
1410 hci_auth_complete_evt(hdev, skb);
1411 break;
1412
a9de9248
MH		 1413 case HCI_EV_REMOTE_NAME:
1414 hci_remote_name_evt(hdev, skb);
1415 break;
1416
1da177e4
LT		 1417 case HCI_EV_ENCRYPT_CHANGE:
1418 hci_encrypt_change_evt(hdev, skb);
1419 break;
1420
a9de9248
MH		 1421 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
1422 hci_change_link_key_complete_evt(hdev, skb);
1423 break;
1424
1425 case HCI_EV_REMOTE_FEATURES:
1426 hci_remote_features_evt(hdev, skb);
1427 break;
1428
1429 case HCI_EV_REMOTE_VERSION:
1430 hci_remote_version_evt(hdev, skb);
1431 break;
1432
1433 case HCI_EV_QOS_SETUP_COMPLETE:
1434 hci_qos_setup_complete_evt(hdev, skb);
1435 break;
1436
1437 case HCI_EV_CMD_COMPLETE:
1438 hci_cmd_complete_evt(hdev, skb);
1439 break;
1440
1441 case HCI_EV_CMD_STATUS:
1442 hci_cmd_status_evt(hdev, skb);
1443 break;
1444
1445 case HCI_EV_ROLE_CHANGE:
1446 hci_role_change_evt(hdev, skb);
1447 break;
1448
1449 case HCI_EV_NUM_COMP_PKTS:
1450 hci_num_comp_pkts_evt(hdev, skb);
1451 break;
1452
1453 case HCI_EV_MODE_CHANGE:
1454 hci_mode_change_evt(hdev, skb);
1da177e4
LT		 1455 break;
1456
1457 case HCI_EV_PIN_CODE_REQ:
1458 hci_pin_code_request_evt(hdev, skb);
1459 break;
1460
1461 case HCI_EV_LINK_KEY_REQ:
1462 hci_link_key_request_evt(hdev, skb);
1463 break;
1464
1465 case HCI_EV_LINK_KEY_NOTIFY:
1466 hci_link_key_notify_evt(hdev, skb);
1467 break;
1468
1469 case HCI_EV_CLOCK_OFFSET:
1470 hci_clock_offset_evt(hdev, skb);
1471 break;
1472
85a1e930
MH		 1473 case HCI_EV_PSCAN_REP_MODE:
1474 hci_pscan_rep_mode_evt(hdev, skb);
1475 break;
1476
a9de9248
MH		 1477 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1478 hci_inquiry_result_with_rssi_evt(hdev, skb);
04837f64
MH		 1479 break;
1480
a9de9248
MH		 1481 case HCI_EV_REMOTE_EXT_FEATURES:
1482 hci_remote_ext_features_evt(hdev, skb);
1da177e4
LT		 1483 break;
1484
a9de9248
MH		 1485 case HCI_EV_SYNC_CONN_COMPLETE:
1486 hci_sync_conn_complete_evt(hdev, skb);
1487 break;
1da177e4 1488
a9de9248
MH		 1489 case HCI_EV_SYNC_CONN_CHANGED:
1490 hci_sync_conn_changed_evt(hdev, skb);
1491 break;
1da177e4 1492
a9de9248
MH		 1493 case HCI_EV_SNIFF_SUBRATE:
1494 hci_sniff_subrate_evt(hdev, skb);
1495 break;
1da177e4 1496
a9de9248
MH		 1497 case HCI_EV_EXTENDED_INQUIRY_RESULT:
1498 hci_extended_inquiry_result_evt(hdev, skb);
1499 break;
1da177e4 1500
a9de9248
MH		 1501 default:
1502 BT_DBG("%s event 0x%x", hdev->name, event);
1da177e4
LT		 1503 break;
1504 }
1505
1506 kfree_skb(skb);
1507 hdev->stat.evt_rx++;
1508}
1509
1510/* Generate internal stack event */
1511void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1512{
1513 struct hci_event_hdr *hdr;
1514 struct hci_ev_stack_internal *ev;
1515 struct sk_buff *skb;
1516
1517 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1518 if (!skb)
1519 return;
1520
1521 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1522 hdr->evt = HCI_EV_STACK_INTERNAL;
1523 hdr->plen = sizeof(*ev) + dlen;
1524
1525 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
1526 ev->type = type;
1527 memcpy(ev->data, data, dlen);
1528
576c7d85 1529 bt_cb(skb)->incoming = 1;
a61bbcf2 1530 __net_timestamp(skb);
576c7d85 1531
0d48d939 1532 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
1da177e4
LT		 1533 skb->dev = (void *) hdev;
1534 hci_send_to_sock(hdev, skb);
1535 kfree_skb(skb);
1536}
Linux kernel - Deliverables
This page took 0.40653 seconds and 5 git commands to generate.