1 /* 2 BlueZ - Bluetooth protocol stack for Linux 3 Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved. 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 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 18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 19 20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 22 SOFTWARE IS DISCLAIMED. 23 */ 24 25 #ifndef __HCI_CORE_H 26 #define __HCI_CORE_H 27 28 #include <net/bluetooth/hci.h> 29 #include <net/bluetooth/hci_sock.h> 30 31 /* HCI priority */ 32 #define HCI_PRIO_MAX 7 33 34 /* HCI Core structures */ 35 struct inquiry_data { 36 bdaddr_t bdaddr; 37 __u8 pscan_rep_mode; 38 __u8 pscan_period_mode; 39 __u8 pscan_mode; 40 __u8 dev_class[3]; 41 __le16 clock_offset; 42 __s8 rssi; 43 __u8 ssp_mode; 44 }; 45 46 struct inquiry_entry { 47 struct list_head all; /* inq_cache.all */ 48 struct list_head list; /* unknown or resolve */ 49 enum { 50 NAME_NOT_KNOWN, 51 NAME_NEEDED, 52 NAME_PENDING, 53 NAME_KNOWN, 54 } name_state; 55 __u32 timestamp; 56 struct inquiry_data data; 57 }; 58 59 struct discovery_state { 60 int type; 61 enum { 62 DISCOVERY_STOPPED, 63 DISCOVERY_STARTING, 64 DISCOVERY_FINDING, 65 DISCOVERY_RESOLVING, 66 DISCOVERY_STOPPING, 67 } state; 68 struct list_head all; /* All devices found during inquiry */ 69 struct list_head unknown; /* Name state not known */ 70 struct list_head resolve; /* Name needs to be resolved */ 71 __u32 timestamp; 72 bdaddr_t last_adv_addr; 73 u8 last_adv_addr_type; 74 s8 last_adv_rssi; 75 u32 last_adv_flags; 76 u8 last_adv_data[HCI_MAX_AD_LENGTH]; 77 u8 last_adv_data_len; 78 bool report_invalid_rssi; 79 s8 rssi; 80 u16 uuid_count; 81 u8 (*uuids)[16]; 82 }; 83 84 struct hci_conn_hash { 85 struct list_head list; 86 unsigned int acl_num; 87 unsigned int amp_num; 88 unsigned int sco_num; 89 unsigned int le_num; 90 unsigned int le_num_slave; 91 }; 92 93 struct bdaddr_list { 94 struct list_head list; 95 bdaddr_t bdaddr; 96 u8 bdaddr_type; 97 }; 98 99 struct bt_uuid { 100 struct list_head list; 101 u8 uuid[16]; 102 u8 size; 103 u8 svc_hint; 104 }; 105 106 struct smp_csrk { 107 bdaddr_t bdaddr; 108 u8 bdaddr_type; 109 u8 master; 110 u8 val[16]; 111 }; 112 113 struct smp_ltk { 114 struct list_head list; 115 struct rcu_head rcu; 116 bdaddr_t bdaddr; 117 u8 bdaddr_type; 118 u8 authenticated; 119 u8 type; 120 u8 enc_size; 121 __le16 ediv; 122 __le64 rand; 123 u8 val[16]; 124 }; 125 126 struct smp_irk { 127 struct list_head list; 128 struct rcu_head rcu; 129 bdaddr_t rpa; 130 bdaddr_t bdaddr; 131 u8 addr_type; 132 u8 val[16]; 133 }; 134 135 struct link_key { 136 struct list_head list; 137 struct rcu_head rcu; 138 bdaddr_t bdaddr; 139 u8 type; 140 u8 val[HCI_LINK_KEY_SIZE]; 141 u8 pin_len; 142 }; 143 144 struct oob_data { 145 struct list_head list; 146 bdaddr_t bdaddr; 147 u8 bdaddr_type; 148 u8 hash192[16]; 149 u8 rand192[16]; 150 u8 hash256[16]; 151 u8 rand256[16]; 152 }; 153 154 #define HCI_MAX_SHORT_NAME_LENGTH 10 155 156 /* Default LE RPA expiry time, 15 minutes */ 157 #define HCI_DEFAULT_RPA_TIMEOUT (15 * 60) 158 159 /* Default min/max age of connection information (1s/3s) */ 160 #define DEFAULT_CONN_INFO_MIN_AGE 1000 161 #define DEFAULT_CONN_INFO_MAX_AGE 3000 162 163 struct amp_assoc { 164 __u16 len; 165 __u16 offset; 166 __u16 rem_len; 167 __u16 len_so_far; 168 __u8 data[HCI_MAX_AMP_ASSOC_SIZE]; 169 }; 170 171 #define HCI_MAX_PAGES 3 172 173 #define NUM_REASSEMBLY 4 174 struct hci_dev { 175 struct list_head list; 176 struct mutex lock; 177 178 char name[8]; 179 unsigned long flags; 180 __u16 id; 181 __u8 bus; 182 __u8 dev_type; 183 bdaddr_t bdaddr; 184 bdaddr_t setup_addr; 185 bdaddr_t public_addr; 186 bdaddr_t random_addr; 187 bdaddr_t static_addr; 188 __u8 adv_addr_type; 189 __u8 dev_name[HCI_MAX_NAME_LENGTH]; 190 __u8 short_name[HCI_MAX_SHORT_NAME_LENGTH]; 191 __u8 eir[HCI_MAX_EIR_LENGTH]; 192 __u8 dev_class[3]; 193 __u8 major_class; 194 __u8 minor_class; 195 __u8 max_page; 196 __u8 features[HCI_MAX_PAGES][8]; 197 __u8 le_features[8]; 198 __u8 le_white_list_size; 199 __u8 le_states[8]; 200 __u8 commands[64]; 201 __u8 hci_ver; 202 __u16 hci_rev; 203 __u8 lmp_ver; 204 __u16 manufacturer; 205 __u16 lmp_subver; 206 __u16 voice_setting; 207 __u8 num_iac; 208 __u8 io_capability; 209 __s8 inq_tx_power; 210 __u16 page_scan_interval; 211 __u16 page_scan_window; 212 __u8 page_scan_type; 213 __u8 le_adv_channel_map; 214 __u16 le_adv_min_interval; 215 __u16 le_adv_max_interval; 216 __u8 le_scan_type; 217 __u16 le_scan_interval; 218 __u16 le_scan_window; 219 __u16 le_conn_min_interval; 220 __u16 le_conn_max_interval; 221 __u16 le_conn_latency; 222 __u16 le_supv_timeout; 223 __u16 discov_interleaved_timeout; 224 __u16 conn_info_min_age; 225 __u16 conn_info_max_age; 226 __u8 ssp_debug_mode; 227 __u32 clock; 228 229 __u16 devid_source; 230 __u16 devid_vendor; 231 __u16 devid_product; 232 __u16 devid_version; 233 234 __u16 pkt_type; 235 __u16 esco_type; 236 __u16 link_policy; 237 __u16 link_mode; 238 239 __u32 idle_timeout; 240 __u16 sniff_min_interval; 241 __u16 sniff_max_interval; 242 243 __u8 amp_status; 244 __u32 amp_total_bw; 245 __u32 amp_max_bw; 246 __u32 amp_min_latency; 247 __u32 amp_max_pdu; 248 __u8 amp_type; 249 __u16 amp_pal_cap; 250 __u16 amp_assoc_size; 251 __u32 amp_max_flush_to; 252 __u32 amp_be_flush_to; 253 254 struct amp_assoc loc_assoc; 255 256 __u8 flow_ctl_mode; 257 258 unsigned int auto_accept_delay; 259 260 unsigned long quirks; 261 262 atomic_t cmd_cnt; 263 unsigned int acl_cnt; 264 unsigned int sco_cnt; 265 unsigned int le_cnt; 266 267 unsigned int acl_mtu; 268 unsigned int sco_mtu; 269 unsigned int le_mtu; 270 unsigned int acl_pkts; 271 unsigned int sco_pkts; 272 unsigned int le_pkts; 273 274 __u16 block_len; 275 __u16 block_mtu; 276 __u16 num_blocks; 277 __u16 block_cnt; 278 279 unsigned long acl_last_tx; 280 unsigned long sco_last_tx; 281 unsigned long le_last_tx; 282 283 struct workqueue_struct *workqueue; 284 struct workqueue_struct *req_workqueue; 285 286 struct work_struct power_on; 287 struct delayed_work power_off; 288 289 __u16 discov_timeout; 290 struct delayed_work discov_off; 291 292 struct delayed_work service_cache; 293 294 struct delayed_work cmd_timer; 295 296 struct work_struct rx_work; 297 struct work_struct cmd_work; 298 struct work_struct tx_work; 299 300 struct sk_buff_head rx_q; 301 struct sk_buff_head raw_q; 302 struct sk_buff_head cmd_q; 303 304 struct sk_buff *recv_evt; 305 struct sk_buff *sent_cmd; 306 struct sk_buff *reassembly[NUM_REASSEMBLY]; 307 308 struct mutex req_lock; 309 wait_queue_head_t req_wait_q; 310 __u32 req_status; 311 __u32 req_result; 312 313 void *smp_data; 314 void *smp_bredr_data; 315 316 struct discovery_state discovery; 317 struct hci_conn_hash conn_hash; 318 319 struct list_head mgmt_pending; 320 struct list_head blacklist; 321 struct list_head whitelist; 322 struct list_head uuids; 323 struct list_head link_keys; 324 struct list_head long_term_keys; 325 struct list_head identity_resolving_keys; 326 struct list_head remote_oob_data; 327 struct list_head le_white_list; 328 struct list_head le_conn_params; 329 struct list_head pend_le_conns; 330 struct list_head pend_le_reports; 331 332 struct hci_dev_stats stat; 333 334 atomic_t promisc; 335 336 struct dentry *debugfs; 337 338 struct device dev; 339 340 struct rfkill *rfkill; 341 342 unsigned long dbg_flags; 343 unsigned long dev_flags; 344 345 struct delayed_work le_scan_disable; 346 347 __s8 adv_tx_power; 348 __u8 adv_data[HCI_MAX_AD_LENGTH]; 349 __u8 adv_data_len; 350 __u8 scan_rsp_data[HCI_MAX_AD_LENGTH]; 351 __u8 scan_rsp_data_len; 352 353 __u8 irk[16]; 354 __u32 rpa_timeout; 355 struct delayed_work rpa_expired; 356 bdaddr_t rpa; 357 358 int (*open)(struct hci_dev *hdev); 359 int (*close)(struct hci_dev *hdev); 360 int (*flush)(struct hci_dev *hdev); 361 int (*setup)(struct hci_dev *hdev); 362 int (*send)(struct hci_dev *hdev, struct sk_buff *skb); 363 void (*notify)(struct hci_dev *hdev, unsigned int evt); 364 int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr); 365 }; 366 367 #define HCI_PHY_HANDLE(handle) (handle & 0xff) 368 369 struct hci_conn { 370 struct list_head list; 371 372 atomic_t refcnt; 373 374 bdaddr_t dst; 375 __u8 dst_type; 376 bdaddr_t src; 377 __u8 src_type; 378 bdaddr_t init_addr; 379 __u8 init_addr_type; 380 bdaddr_t resp_addr; 381 __u8 resp_addr_type; 382 __u16 handle; 383 __u16 state; 384 __u8 mode; 385 __u8 type; 386 __u8 role; 387 bool out; 388 __u8 attempt; 389 __u8 dev_class[3]; 390 __u8 features[HCI_MAX_PAGES][8]; 391 __u16 pkt_type; 392 __u16 link_policy; 393 __u8 key_type; 394 __u8 auth_type; 395 __u8 sec_level; 396 __u8 pending_sec_level; 397 __u8 pin_length; 398 __u8 enc_key_size; 399 __u8 io_capability; 400 __u32 passkey_notify; 401 __u8 passkey_entered; 402 __u16 disc_timeout; 403 __u16 conn_timeout; 404 __u16 setting; 405 __u16 le_conn_min_interval; 406 __u16 le_conn_max_interval; 407 __u16 le_conn_interval; 408 __u16 le_conn_latency; 409 __u16 le_supv_timeout; 410 __u8 le_adv_data[HCI_MAX_AD_LENGTH]; 411 __u8 le_adv_data_len; 412 __s8 rssi; 413 __s8 tx_power; 414 __s8 max_tx_power; 415 unsigned long flags; 416 417 __u32 clock; 418 __u16 clock_accuracy; 419 420 unsigned long conn_info_timestamp; 421 422 __u8 remote_cap; 423 __u8 remote_auth; 424 __u8 remote_id; 425 426 unsigned int sent; 427 428 struct sk_buff_head data_q; 429 struct list_head chan_list; 430 431 struct delayed_work disc_work; 432 struct delayed_work auto_accept_work; 433 struct delayed_work idle_work; 434 struct delayed_work le_conn_timeout; 435 436 struct device dev; 437 438 struct hci_dev *hdev; 439 void *l2cap_data; 440 void *sco_data; 441 struct amp_mgr *amp_mgr; 442 443 struct hci_conn *link; 444 445 void (*connect_cfm_cb) (struct hci_conn *conn, u8 status); 446 void (*security_cfm_cb) (struct hci_conn *conn, u8 status); 447 void (*disconn_cfm_cb) (struct hci_conn *conn, u8 reason); 448 }; 449 450 struct hci_chan { 451 struct list_head list; 452 __u16 handle; 453 struct hci_conn *conn; 454 struct sk_buff_head data_q; 455 unsigned int sent; 456 __u8 state; 457 }; 458 459 struct hci_conn_params { 460 struct list_head list; 461 struct list_head action; 462 463 bdaddr_t addr; 464 u8 addr_type; 465 466 u16 conn_min_interval; 467 u16 conn_max_interval; 468 u16 conn_latency; 469 u16 supervision_timeout; 470 471 enum { 472 HCI_AUTO_CONN_DISABLED, 473 HCI_AUTO_CONN_REPORT, 474 HCI_AUTO_CONN_DIRECT, 475 HCI_AUTO_CONN_ALWAYS, 476 HCI_AUTO_CONN_LINK_LOSS, 477 } auto_connect; 478 479 struct hci_conn *conn; 480 }; 481 482 extern struct list_head hci_dev_list; 483 extern struct list_head hci_cb_list; 484 extern rwlock_t hci_dev_list_lock; 485 extern rwlock_t hci_cb_list_lock; 486 487 /* ----- HCI interface to upper protocols ----- */ 488 int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr); 489 void l2cap_connect_cfm(struct hci_conn *hcon, u8 status); 490 int l2cap_disconn_ind(struct hci_conn *hcon); 491 void l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason); 492 int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt); 493 int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags); 494 495 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags); 496 void sco_connect_cfm(struct hci_conn *hcon, __u8 status); 497 void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason); 498 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb); 499 500 /* ----- Inquiry cache ----- */ 501 #define INQUIRY_CACHE_AGE_MAX (HZ*30) /* 30 seconds */ 502 #define INQUIRY_ENTRY_AGE_MAX (HZ*60) /* 60 seconds */ 503 504 static inline void discovery_init(struct hci_dev *hdev) 505 { 506 hdev->discovery.state = DISCOVERY_STOPPED; 507 INIT_LIST_HEAD(&hdev->discovery.all); 508 INIT_LIST_HEAD(&hdev->discovery.unknown); 509 INIT_LIST_HEAD(&hdev->discovery.resolve); 510 hdev->discovery.report_invalid_rssi = true; 511 hdev->discovery.rssi = HCI_RSSI_INVALID; 512 } 513 514 static inline void hci_discovery_filter_clear(struct hci_dev *hdev) 515 { 516 hdev->discovery.report_invalid_rssi = true; 517 hdev->discovery.rssi = HCI_RSSI_INVALID; 518 hdev->discovery.uuid_count = 0; 519 kfree(hdev->discovery.uuids); 520 hdev->discovery.uuids = NULL; 521 } 522 523 bool hci_discovery_active(struct hci_dev *hdev); 524 525 void hci_discovery_set_state(struct hci_dev *hdev, int state); 526 527 static inline int inquiry_cache_empty(struct hci_dev *hdev) 528 { 529 return list_empty(&hdev->discovery.all); 530 } 531 532 static inline long inquiry_cache_age(struct hci_dev *hdev) 533 { 534 struct discovery_state *c = &hdev->discovery; 535 return jiffies - c->timestamp; 536 } 537 538 static inline long inquiry_entry_age(struct inquiry_entry *e) 539 { 540 return jiffies - e->timestamp; 541 } 542 543 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 544 bdaddr_t *bdaddr); 545 struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 546 bdaddr_t *bdaddr); 547 struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 548 bdaddr_t *bdaddr, 549 int state); 550 void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 551 struct inquiry_entry *ie); 552 u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 553 bool name_known); 554 void hci_inquiry_cache_flush(struct hci_dev *hdev); 555 556 /* ----- HCI Connections ----- */ 557 enum { 558 HCI_CONN_AUTH_PEND, 559 HCI_CONN_REAUTH_PEND, 560 HCI_CONN_ENCRYPT_PEND, 561 HCI_CONN_RSWITCH_PEND, 562 HCI_CONN_MODE_CHANGE_PEND, 563 HCI_CONN_SCO_SETUP_PEND, 564 HCI_CONN_MGMT_CONNECTED, 565 HCI_CONN_SSP_ENABLED, 566 HCI_CONN_SC_ENABLED, 567 HCI_CONN_AES_CCM, 568 HCI_CONN_POWER_SAVE, 569 HCI_CONN_REMOTE_OOB, 570 HCI_CONN_FLUSH_KEY, 571 HCI_CONN_ENCRYPT, 572 HCI_CONN_AUTH, 573 HCI_CONN_SECURE, 574 HCI_CONN_FIPS, 575 HCI_CONN_STK_ENCRYPT, 576 HCI_CONN_AUTH_INITIATOR, 577 HCI_CONN_DROP, 578 HCI_CONN_PARAM_REMOVAL_PEND, 579 HCI_CONN_NEW_LINK_KEY, 580 }; 581 582 static inline bool hci_conn_ssp_enabled(struct hci_conn *conn) 583 { 584 struct hci_dev *hdev = conn->hdev; 585 return test_bit(HCI_SSP_ENABLED, &hdev->dev_flags) && 586 test_bit(HCI_CONN_SSP_ENABLED, &conn->flags); 587 } 588 589 static inline bool hci_conn_sc_enabled(struct hci_conn *conn) 590 { 591 struct hci_dev *hdev = conn->hdev; 592 return test_bit(HCI_SC_ENABLED, &hdev->dev_flags) && 593 test_bit(HCI_CONN_SC_ENABLED, &conn->flags); 594 } 595 596 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c) 597 { 598 struct hci_conn_hash *h = &hdev->conn_hash; 599 list_add_rcu(&c->list, &h->list); 600 switch (c->type) { 601 case ACL_LINK: 602 h->acl_num++; 603 break; 604 case AMP_LINK: 605 h->amp_num++; 606 break; 607 case LE_LINK: 608 h->le_num++; 609 if (c->role == HCI_ROLE_SLAVE) 610 h->le_num_slave++; 611 break; 612 case SCO_LINK: 613 case ESCO_LINK: 614 h->sco_num++; 615 break; 616 } 617 } 618 619 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c) 620 { 621 struct hci_conn_hash *h = &hdev->conn_hash; 622 623 list_del_rcu(&c->list); 624 synchronize_rcu(); 625 626 switch (c->type) { 627 case ACL_LINK: 628 h->acl_num--; 629 break; 630 case AMP_LINK: 631 h->amp_num--; 632 break; 633 case LE_LINK: 634 h->le_num--; 635 if (c->role == HCI_ROLE_SLAVE) 636 h->le_num_slave--; 637 break; 638 case SCO_LINK: 639 case ESCO_LINK: 640 h->sco_num--; 641 break; 642 } 643 } 644 645 static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type) 646 { 647 struct hci_conn_hash *h = &hdev->conn_hash; 648 switch (type) { 649 case ACL_LINK: 650 return h->acl_num; 651 case AMP_LINK: 652 return h->amp_num; 653 case LE_LINK: 654 return h->le_num; 655 case SCO_LINK: 656 case ESCO_LINK: 657 return h->sco_num; 658 default: 659 return 0; 660 } 661 } 662 663 static inline unsigned int hci_conn_count(struct hci_dev *hdev) 664 { 665 struct hci_conn_hash *c = &hdev->conn_hash; 666 667 return c->acl_num + c->amp_num + c->sco_num + c->le_num; 668 } 669 670 static inline __u8 hci_conn_lookup_type(struct hci_dev *hdev, __u16 handle) 671 { 672 struct hci_conn_hash *h = &hdev->conn_hash; 673 struct hci_conn *c; 674 __u8 type = INVALID_LINK; 675 676 rcu_read_lock(); 677 678 list_for_each_entry_rcu(c, &h->list, list) { 679 if (c->handle == handle) { 680 type = c->type; 681 break; 682 } 683 } 684 685 rcu_read_unlock(); 686 687 return type; 688 } 689 690 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev, 691 __u16 handle) 692 { 693 struct hci_conn_hash *h = &hdev->conn_hash; 694 struct hci_conn *c; 695 696 rcu_read_lock(); 697 698 list_for_each_entry_rcu(c, &h->list, list) { 699 if (c->handle == handle) { 700 rcu_read_unlock(); 701 return c; 702 } 703 } 704 rcu_read_unlock(); 705 706 return NULL; 707 } 708 709 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev, 710 __u8 type, bdaddr_t *ba) 711 { 712 struct hci_conn_hash *h = &hdev->conn_hash; 713 struct hci_conn *c; 714 715 rcu_read_lock(); 716 717 list_for_each_entry_rcu(c, &h->list, list) { 718 if (c->type == type && !bacmp(&c->dst, ba)) { 719 rcu_read_unlock(); 720 return c; 721 } 722 } 723 724 rcu_read_unlock(); 725 726 return NULL; 727 } 728 729 static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev, 730 __u8 type, __u16 state) 731 { 732 struct hci_conn_hash *h = &hdev->conn_hash; 733 struct hci_conn *c; 734 735 rcu_read_lock(); 736 737 list_for_each_entry_rcu(c, &h->list, list) { 738 if (c->type == type && c->state == state) { 739 rcu_read_unlock(); 740 return c; 741 } 742 } 743 744 rcu_read_unlock(); 745 746 return NULL; 747 } 748 749 int hci_disconnect(struct hci_conn *conn, __u8 reason); 750 bool hci_setup_sync(struct hci_conn *conn, __u16 handle); 751 void hci_sco_setup(struct hci_conn *conn, __u8 status); 752 753 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst, 754 u8 role); 755 int hci_conn_del(struct hci_conn *conn); 756 void hci_conn_hash_flush(struct hci_dev *hdev); 757 void hci_conn_check_pending(struct hci_dev *hdev); 758 759 struct hci_chan *hci_chan_create(struct hci_conn *conn); 760 void hci_chan_del(struct hci_chan *chan); 761 void hci_chan_list_flush(struct hci_conn *conn); 762 struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle); 763 764 struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst, 765 u8 dst_type, u8 sec_level, u16 conn_timeout, 766 u8 role); 767 struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst, 768 u8 sec_level, u8 auth_type); 769 struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst, 770 __u16 setting); 771 int hci_conn_check_link_mode(struct hci_conn *conn); 772 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level); 773 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type, 774 bool initiator); 775 int hci_conn_change_link_key(struct hci_conn *conn); 776 int hci_conn_switch_role(struct hci_conn *conn, __u8 role); 777 778 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active); 779 780 void hci_le_conn_failed(struct hci_conn *conn, u8 status); 781 782 /* 783 * hci_conn_get() and hci_conn_put() are used to control the life-time of an 784 * "hci_conn" object. They do not guarantee that the hci_conn object is running, 785 * working or anything else. They just guarantee that the object is available 786 * and can be dereferenced. So you can use its locks, local variables and any 787 * other constant data. 788 * Before accessing runtime data, you _must_ lock the object and then check that 789 * it is still running. As soon as you release the locks, the connection might 790 * get dropped, though. 791 * 792 * On the other hand, hci_conn_hold() and hci_conn_drop() are used to control 793 * how long the underlying connection is held. So every channel that runs on the 794 * hci_conn object calls this to prevent the connection from disappearing. As 795 * long as you hold a device, you must also guarantee that you have a valid 796 * reference to the device via hci_conn_get() (or the initial reference from 797 * hci_conn_add()). 798 * The hold()/drop() ref-count is known to drop below 0 sometimes, which doesn't 799 * break because nobody cares for that. But this means, we cannot use 800 * _get()/_drop() in it, but require the caller to have a valid ref (FIXME). 801 */ 802 803 static inline struct hci_conn *hci_conn_get(struct hci_conn *conn) 804 { 805 get_device(&conn->dev); 806 return conn; 807 } 808 809 static inline void hci_conn_put(struct hci_conn *conn) 810 { 811 put_device(&conn->dev); 812 } 813 814 static inline void hci_conn_hold(struct hci_conn *conn) 815 { 816 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt)); 817 818 atomic_inc(&conn->refcnt); 819 cancel_delayed_work(&conn->disc_work); 820 } 821 822 static inline void hci_conn_drop(struct hci_conn *conn) 823 { 824 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt)); 825 826 if (atomic_dec_and_test(&conn->refcnt)) { 827 unsigned long timeo; 828 829 switch (conn->type) { 830 case ACL_LINK: 831 case LE_LINK: 832 cancel_delayed_work(&conn->idle_work); 833 if (conn->state == BT_CONNECTED) { 834 timeo = conn->disc_timeout; 835 if (!conn->out) 836 timeo *= 2; 837 } else { 838 timeo = 0; 839 } 840 break; 841 842 case AMP_LINK: 843 timeo = conn->disc_timeout; 844 break; 845 846 default: 847 timeo = 0; 848 break; 849 } 850 851 cancel_delayed_work(&conn->disc_work); 852 queue_delayed_work(conn->hdev->workqueue, 853 &conn->disc_work, timeo); 854 } 855 } 856 857 /* ----- HCI Devices ----- */ 858 static inline void hci_dev_put(struct hci_dev *d) 859 { 860 BT_DBG("%s orig refcnt %d", d->name, 861 atomic_read(&d->dev.kobj.kref.refcount)); 862 863 put_device(&d->dev); 864 } 865 866 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d) 867 { 868 BT_DBG("%s orig refcnt %d", d->name, 869 atomic_read(&d->dev.kobj.kref.refcount)); 870 871 get_device(&d->dev); 872 return d; 873 } 874 875 #define hci_dev_lock(d) mutex_lock(&d->lock) 876 #define hci_dev_unlock(d) mutex_unlock(&d->lock) 877 878 #define to_hci_dev(d) container_of(d, struct hci_dev, dev) 879 #define to_hci_conn(c) container_of(c, struct hci_conn, dev) 880 881 static inline void *hci_get_drvdata(struct hci_dev *hdev) 882 { 883 return dev_get_drvdata(&hdev->dev); 884 } 885 886 static inline void hci_set_drvdata(struct hci_dev *hdev, void *data) 887 { 888 dev_set_drvdata(&hdev->dev, data); 889 } 890 891 struct hci_dev *hci_dev_get(int index); 892 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src); 893 894 struct hci_dev *hci_alloc_dev(void); 895 void hci_free_dev(struct hci_dev *hdev); 896 int hci_register_dev(struct hci_dev *hdev); 897 void hci_unregister_dev(struct hci_dev *hdev); 898 int hci_suspend_dev(struct hci_dev *hdev); 899 int hci_resume_dev(struct hci_dev *hdev); 900 int hci_reset_dev(struct hci_dev *hdev); 901 int hci_dev_open(__u16 dev); 902 int hci_dev_close(__u16 dev); 903 int hci_dev_reset(__u16 dev); 904 int hci_dev_reset_stat(__u16 dev); 905 int hci_dev_cmd(unsigned int cmd, void __user *arg); 906 int hci_get_dev_list(void __user *arg); 907 int hci_get_dev_info(void __user *arg); 908 int hci_get_conn_list(void __user *arg); 909 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg); 910 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg); 911 int hci_inquiry(void __user *arg); 912 913 struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *list, 914 bdaddr_t *bdaddr, u8 type); 915 int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type); 916 int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type); 917 void hci_bdaddr_list_clear(struct list_head *list); 918 919 struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 920 bdaddr_t *addr, u8 addr_type); 921 struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 922 bdaddr_t *addr, u8 addr_type); 923 int hci_conn_params_set(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type, 924 u8 auto_connect); 925 void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type); 926 void hci_conn_params_clear_all(struct hci_dev *hdev); 927 void hci_conn_params_clear_disabled(struct hci_dev *hdev); 928 929 struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 930 bdaddr_t *addr, 931 u8 addr_type); 932 933 void hci_update_background_scan(struct hci_dev *hdev); 934 935 void hci_uuids_clear(struct hci_dev *hdev); 936 937 void hci_link_keys_clear(struct hci_dev *hdev); 938 struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr); 939 struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 940 bdaddr_t *bdaddr, u8 *val, u8 type, 941 u8 pin_len, bool *persistent); 942 struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 943 u8 addr_type, u8 type, u8 authenticated, 944 u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand); 945 struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 946 u8 addr_type, u8 role); 947 int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type); 948 void hci_smp_ltks_clear(struct hci_dev *hdev); 949 int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr); 950 951 struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa); 952 struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 953 u8 addr_type); 954 struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 955 u8 addr_type, u8 val[16], bdaddr_t *rpa); 956 void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type); 957 void hci_smp_irks_clear(struct hci_dev *hdev); 958 959 void hci_remote_oob_data_clear(struct hci_dev *hdev); 960 struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 961 bdaddr_t *bdaddr, u8 bdaddr_type); 962 int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 963 u8 bdaddr_type, u8 *hash192, u8 *rand192, 964 u8 *hash256, u8 *rand256); 965 int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 966 u8 bdaddr_type); 967 968 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb); 969 970 int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb); 971 int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count); 972 973 void hci_init_sysfs(struct hci_dev *hdev); 974 void hci_conn_init_sysfs(struct hci_conn *conn); 975 void hci_conn_add_sysfs(struct hci_conn *conn); 976 void hci_conn_del_sysfs(struct hci_conn *conn); 977 978 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev)) 979 980 /* ----- LMP capabilities ----- */ 981 #define lmp_encrypt_capable(dev) ((dev)->features[0][0] & LMP_ENCRYPT) 982 #define lmp_rswitch_capable(dev) ((dev)->features[0][0] & LMP_RSWITCH) 983 #define lmp_hold_capable(dev) ((dev)->features[0][0] & LMP_HOLD) 984 #define lmp_sniff_capable(dev) ((dev)->features[0][0] & LMP_SNIFF) 985 #define lmp_park_capable(dev) ((dev)->features[0][1] & LMP_PARK) 986 #define lmp_inq_rssi_capable(dev) ((dev)->features[0][3] & LMP_RSSI_INQ) 987 #define lmp_esco_capable(dev) ((dev)->features[0][3] & LMP_ESCO) 988 #define lmp_bredr_capable(dev) (!((dev)->features[0][4] & LMP_NO_BREDR)) 989 #define lmp_le_capable(dev) ((dev)->features[0][4] & LMP_LE) 990 #define lmp_sniffsubr_capable(dev) ((dev)->features[0][5] & LMP_SNIFF_SUBR) 991 #define lmp_pause_enc_capable(dev) ((dev)->features[0][5] & LMP_PAUSE_ENC) 992 #define lmp_ext_inq_capable(dev) ((dev)->features[0][6] & LMP_EXT_INQ) 993 #define lmp_le_br_capable(dev) (!!((dev)->features[0][6] & LMP_SIMUL_LE_BR)) 994 #define lmp_ssp_capable(dev) ((dev)->features[0][6] & LMP_SIMPLE_PAIR) 995 #define lmp_no_flush_capable(dev) ((dev)->features[0][6] & LMP_NO_FLUSH) 996 #define lmp_lsto_capable(dev) ((dev)->features[0][7] & LMP_LSTO) 997 #define lmp_inq_tx_pwr_capable(dev) ((dev)->features[0][7] & LMP_INQ_TX_PWR) 998 #define lmp_ext_feat_capable(dev) ((dev)->features[0][7] & LMP_EXTFEATURES) 999 #define lmp_transp_capable(dev) ((dev)->features[0][2] & LMP_TRANSPARENT) 1000 1001 /* ----- Extended LMP capabilities ----- */ 1002 #define lmp_csb_master_capable(dev) ((dev)->features[2][0] & LMP_CSB_MASTER) 1003 #define lmp_csb_slave_capable(dev) ((dev)->features[2][0] & LMP_CSB_SLAVE) 1004 #define lmp_sync_train_capable(dev) ((dev)->features[2][0] & LMP_SYNC_TRAIN) 1005 #define lmp_sync_scan_capable(dev) ((dev)->features[2][0] & LMP_SYNC_SCAN) 1006 #define lmp_sc_capable(dev) ((dev)->features[2][1] & LMP_SC) 1007 #define lmp_ping_capable(dev) ((dev)->features[2][1] & LMP_PING) 1008 1009 /* ----- Host capabilities ----- */ 1010 #define lmp_host_ssp_capable(dev) ((dev)->features[1][0] & LMP_HOST_SSP) 1011 #define lmp_host_sc_capable(dev) ((dev)->features[1][0] & LMP_HOST_SC) 1012 #define lmp_host_le_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE)) 1013 #define lmp_host_le_br_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE_BREDR)) 1014 1015 #define hdev_is_powered(hdev) (test_bit(HCI_UP, &hdev->flags) && \ 1016 !test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 1017 #define bredr_sc_enabled(dev) ((lmp_sc_capable(dev) || \ 1018 test_bit(HCI_FORCE_SC, &(dev)->dbg_flags)) && \ 1019 test_bit(HCI_SC_ENABLED, &(dev)->dev_flags)) 1020 1021 /* ----- HCI protocols ----- */ 1022 #define HCI_PROTO_DEFER 0x01 1023 1024 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, 1025 __u8 type, __u8 *flags) 1026 { 1027 switch (type) { 1028 case ACL_LINK: 1029 return l2cap_connect_ind(hdev, bdaddr); 1030 1031 case SCO_LINK: 1032 case ESCO_LINK: 1033 return sco_connect_ind(hdev, bdaddr, flags); 1034 1035 default: 1036 BT_ERR("unknown link type %d", type); 1037 return -EINVAL; 1038 } 1039 } 1040 1041 static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status) 1042 { 1043 switch (conn->type) { 1044 case ACL_LINK: 1045 case LE_LINK: 1046 l2cap_connect_cfm(conn, status); 1047 break; 1048 1049 case SCO_LINK: 1050 case ESCO_LINK: 1051 sco_connect_cfm(conn, status); 1052 break; 1053 1054 default: 1055 BT_ERR("unknown link type %d", conn->type); 1056 break; 1057 } 1058 1059 if (conn->connect_cfm_cb) 1060 conn->connect_cfm_cb(conn, status); 1061 } 1062 1063 static inline int hci_proto_disconn_ind(struct hci_conn *conn) 1064 { 1065 if (conn->type != ACL_LINK && conn->type != LE_LINK) 1066 return HCI_ERROR_REMOTE_USER_TERM; 1067 1068 return l2cap_disconn_ind(conn); 1069 } 1070 1071 static inline void hci_proto_disconn_cfm(struct hci_conn *conn, __u8 reason) 1072 { 1073 switch (conn->type) { 1074 case ACL_LINK: 1075 case LE_LINK: 1076 l2cap_disconn_cfm(conn, reason); 1077 break; 1078 1079 case SCO_LINK: 1080 case ESCO_LINK: 1081 sco_disconn_cfm(conn, reason); 1082 break; 1083 1084 /* L2CAP would be handled for BREDR chan */ 1085 case AMP_LINK: 1086 break; 1087 1088 default: 1089 BT_ERR("unknown link type %d", conn->type); 1090 break; 1091 } 1092 1093 if (conn->disconn_cfm_cb) 1094 conn->disconn_cfm_cb(conn, reason); 1095 } 1096 1097 static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status) 1098 { 1099 __u8 encrypt; 1100 1101 if (conn->type != ACL_LINK && conn->type != LE_LINK) 1102 return; 1103 1104 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) 1105 return; 1106 1107 encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00; 1108 l2cap_security_cfm(conn, status, encrypt); 1109 1110 if (conn->security_cfm_cb) 1111 conn->security_cfm_cb(conn, status); 1112 } 1113 1114 static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status, 1115 __u8 encrypt) 1116 { 1117 if (conn->type != ACL_LINK && conn->type != LE_LINK) 1118 return; 1119 1120 l2cap_security_cfm(conn, status, encrypt); 1121 1122 if (conn->security_cfm_cb) 1123 conn->security_cfm_cb(conn, status); 1124 } 1125 1126 /* ----- HCI callbacks ----- */ 1127 struct hci_cb { 1128 struct list_head list; 1129 1130 char *name; 1131 1132 void (*security_cfm) (struct hci_conn *conn, __u8 status, 1133 __u8 encrypt); 1134 void (*key_change_cfm) (struct hci_conn *conn, __u8 status); 1135 void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role); 1136 }; 1137 1138 static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status) 1139 { 1140 struct hci_cb *cb; 1141 __u8 encrypt; 1142 1143 hci_proto_auth_cfm(conn, status); 1144 1145 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) 1146 return; 1147 1148 encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00; 1149 1150 read_lock(&hci_cb_list_lock); 1151 list_for_each_entry(cb, &hci_cb_list, list) { 1152 if (cb->security_cfm) 1153 cb->security_cfm(conn, status, encrypt); 1154 } 1155 read_unlock(&hci_cb_list_lock); 1156 } 1157 1158 static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status, 1159 __u8 encrypt) 1160 { 1161 struct hci_cb *cb; 1162 1163 if (conn->sec_level == BT_SECURITY_SDP) 1164 conn->sec_level = BT_SECURITY_LOW; 1165 1166 if (conn->pending_sec_level > conn->sec_level) 1167 conn->sec_level = conn->pending_sec_level; 1168 1169 hci_proto_encrypt_cfm(conn, status, encrypt); 1170 1171 read_lock(&hci_cb_list_lock); 1172 list_for_each_entry(cb, &hci_cb_list, list) { 1173 if (cb->security_cfm) 1174 cb->security_cfm(conn, status, encrypt); 1175 } 1176 read_unlock(&hci_cb_list_lock); 1177 } 1178 1179 static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status) 1180 { 1181 struct hci_cb *cb; 1182 1183 read_lock(&hci_cb_list_lock); 1184 list_for_each_entry(cb, &hci_cb_list, list) { 1185 if (cb->key_change_cfm) 1186 cb->key_change_cfm(conn, status); 1187 } 1188 read_unlock(&hci_cb_list_lock); 1189 } 1190 1191 static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status, 1192 __u8 role) 1193 { 1194 struct hci_cb *cb; 1195 1196 read_lock(&hci_cb_list_lock); 1197 list_for_each_entry(cb, &hci_cb_list, list) { 1198 if (cb->role_switch_cfm) 1199 cb->role_switch_cfm(conn, status, role); 1200 } 1201 read_unlock(&hci_cb_list_lock); 1202 } 1203 1204 static inline bool eir_has_data_type(u8 *data, size_t data_len, u8 type) 1205 { 1206 size_t parsed = 0; 1207 1208 if (data_len < 2) 1209 return false; 1210 1211 while (parsed < data_len - 1) { 1212 u8 field_len = data[0]; 1213 1214 if (field_len == 0) 1215 break; 1216 1217 parsed += field_len + 1; 1218 1219 if (parsed > data_len) 1220 break; 1221 1222 if (data[1] == type) 1223 return true; 1224 1225 data += field_len + 1; 1226 } 1227 1228 return false; 1229 } 1230 1231 static inline bool hci_bdaddr_is_rpa(bdaddr_t *bdaddr, u8 addr_type) 1232 { 1233 if (addr_type != ADDR_LE_DEV_RANDOM) 1234 return false; 1235 1236 if ((bdaddr->b[5] & 0xc0) == 0x40) 1237 return true; 1238 1239 return false; 1240 } 1241 1242 static inline bool hci_is_identity_address(bdaddr_t *addr, u8 addr_type) 1243 { 1244 if (addr_type == ADDR_LE_DEV_PUBLIC) 1245 return true; 1246 1247 /* Check for Random Static address type */ 1248 if ((addr->b[5] & 0xc0) == 0xc0) 1249 return true; 1250 1251 return false; 1252 } 1253 1254 static inline struct smp_irk *hci_get_irk(struct hci_dev *hdev, 1255 bdaddr_t *bdaddr, u8 addr_type) 1256 { 1257 if (!hci_bdaddr_is_rpa(bdaddr, addr_type)) 1258 return NULL; 1259 1260 return hci_find_irk_by_rpa(hdev, bdaddr); 1261 } 1262 1263 static inline int hci_check_conn_params(u16 min, u16 max, u16 latency, 1264 u16 to_multiplier) 1265 { 1266 u16 max_latency; 1267 1268 if (min > max || min < 6 || max > 3200) 1269 return -EINVAL; 1270 1271 if (to_multiplier < 10 || to_multiplier > 3200) 1272 return -EINVAL; 1273 1274 if (max >= to_multiplier * 8) 1275 return -EINVAL; 1276 1277 max_latency = (to_multiplier * 8 / max) - 1; 1278 if (latency > 499 || latency > max_latency) 1279 return -EINVAL; 1280 1281 return 0; 1282 } 1283 1284 int hci_register_cb(struct hci_cb *hcb); 1285 int hci_unregister_cb(struct hci_cb *hcb); 1286 1287 struct hci_request { 1288 struct hci_dev *hdev; 1289 struct sk_buff_head cmd_q; 1290 1291 /* If something goes wrong when building the HCI request, the error 1292 * value is stored in this field. 1293 */ 1294 int err; 1295 }; 1296 1297 void hci_req_init(struct hci_request *req, struct hci_dev *hdev); 1298 int hci_req_run(struct hci_request *req, hci_req_complete_t complete); 1299 void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 1300 const void *param); 1301 void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 1302 const void *param, u8 event); 1303 void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status); 1304 bool hci_req_pending(struct hci_dev *hdev); 1305 1306 void hci_req_add_le_scan_disable(struct hci_request *req); 1307 void hci_req_add_le_passive_scan(struct hci_request *req); 1308 1309 void hci_update_page_scan(struct hci_dev *hdev, struct hci_request *req); 1310 1311 struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 1312 const void *param, u32 timeout); 1313 struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 1314 const void *param, u8 event, u32 timeout); 1315 1316 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 1317 const void *param); 1318 void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags); 1319 void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb); 1320 1321 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode); 1322 1323 /* ----- HCI Sockets ----- */ 1324 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb); 1325 void hci_send_to_control(struct sk_buff *skb, struct sock *skip_sk); 1326 void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb); 1327 1328 void hci_sock_dev_event(struct hci_dev *hdev, int event); 1329 1330 /* Management interface */ 1331 #define DISCOV_TYPE_BREDR (BIT(BDADDR_BREDR)) 1332 #define DISCOV_TYPE_LE (BIT(BDADDR_LE_PUBLIC) | \ 1333 BIT(BDADDR_LE_RANDOM)) 1334 #define DISCOV_TYPE_INTERLEAVED (BIT(BDADDR_BREDR) | \ 1335 BIT(BDADDR_LE_PUBLIC) | \ 1336 BIT(BDADDR_LE_RANDOM)) 1337 1338 /* These LE scan and inquiry parameters were chosen according to LE General 1339 * Discovery Procedure specification. 1340 */ 1341 #define DISCOV_LE_SCAN_WIN 0x12 1342 #define DISCOV_LE_SCAN_INT 0x12 1343 #define DISCOV_LE_TIMEOUT 10240 /* msec */ 1344 #define DISCOV_INTERLEAVED_TIMEOUT 5120 /* msec */ 1345 #define DISCOV_INTERLEAVED_INQUIRY_LEN 0x04 1346 #define DISCOV_BREDR_INQUIRY_LEN 0x08 1347 1348 int mgmt_control(struct sock *sk, struct msghdr *msg, size_t len); 1349 int mgmt_new_settings(struct hci_dev *hdev); 1350 void mgmt_index_added(struct hci_dev *hdev); 1351 void mgmt_index_removed(struct hci_dev *hdev); 1352 void mgmt_set_powered_failed(struct hci_dev *hdev, int err); 1353 int mgmt_powered(struct hci_dev *hdev, u8 powered); 1354 int mgmt_update_adv_data(struct hci_dev *hdev); 1355 void mgmt_discoverable_timeout(struct hci_dev *hdev); 1356 void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key, 1357 bool persistent); 1358 void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn, 1359 u32 flags, u8 *name, u8 name_len); 1360 void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr, 1361 u8 link_type, u8 addr_type, u8 reason, 1362 bool mgmt_connected); 1363 void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, 1364 u8 link_type, u8 addr_type, u8 status); 1365 void mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type, 1366 u8 addr_type, u8 status); 1367 void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure); 1368 void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr, 1369 u8 status); 1370 void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr, 1371 u8 status); 1372 int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr, 1373 u8 link_type, u8 addr_type, u32 value, 1374 u8 confirm_hint); 1375 int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr, 1376 u8 link_type, u8 addr_type, u8 status); 1377 int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr, 1378 u8 link_type, u8 addr_type, u8 status); 1379 int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr, 1380 u8 link_type, u8 addr_type); 1381 int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr, 1382 u8 link_type, u8 addr_type, u8 status); 1383 int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr, 1384 u8 link_type, u8 addr_type, u8 status); 1385 int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr, 1386 u8 link_type, u8 addr_type, u32 passkey, 1387 u8 entered); 1388 void mgmt_auth_failed(struct hci_conn *conn, u8 status); 1389 void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status); 1390 void mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status); 1391 void mgmt_sc_enable_complete(struct hci_dev *hdev, u8 enable, u8 status); 1392 void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class, 1393 u8 status); 1394 void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status); 1395 void mgmt_read_local_oob_data_complete(struct hci_dev *hdev, u8 *hash192, 1396 u8 *rand192, u8 *hash256, u8 *rand256, 1397 u8 status); 1398 void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type, 1399 u8 addr_type, u8 *dev_class, s8 rssi, u32 flags, 1400 u8 *eir, u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len); 1401 void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type, 1402 u8 addr_type, s8 rssi, u8 *name, u8 name_len); 1403 void mgmt_discovering(struct hci_dev *hdev, u8 discovering); 1404 bool mgmt_powering_down(struct hci_dev *hdev); 1405 void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent); 1406 void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk); 1407 void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk, 1408 bool persistent); 1409 void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr, 1410 u8 bdaddr_type, u8 store_hint, u16 min_interval, 1411 u16 max_interval, u16 latency, u16 timeout); 1412 void mgmt_reenable_advertising(struct hci_dev *hdev); 1413 void mgmt_smp_complete(struct hci_conn *conn, bool complete); 1414 1415 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency, 1416 u16 to_multiplier); 1417 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand, 1418 __u8 ltk[16]); 1419 1420 int hci_update_random_address(struct hci_request *req, bool require_privacy, 1421 u8 *own_addr_type); 1422 void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 1423 u8 *bdaddr_type); 1424 1425 #define SCO_AIRMODE_MASK 0x0003 1426 #define SCO_AIRMODE_CVSD 0x0000 1427 #define SCO_AIRMODE_TRANSP 0x0003 1428 1429 #endif /* __HCI_CORE_H */ 1430