root/include/net/bluetooth/hci_core.h

/* [<][>][^][v][top][bottom][index][help] */

INCLUDED FROM


DEFINITIONS

This source file includes following definitions.
  1. sco_connect_ind
  2. sco_recv_scodata
  3. discovery_init
  4. hci_discovery_filter_clear
  5. inquiry_cache_empty
  6. inquiry_cache_age
  7. inquiry_entry_age
  8. hci_conn_ssp_enabled
  9. hci_conn_sc_enabled
  10. hci_conn_hash_add
  11. hci_conn_hash_del
  12. hci_conn_num
  13. hci_conn_count
  14. hci_conn_lookup_type
  15. hci_conn_hash_lookup_handle
  16. hci_conn_hash_lookup_ba
  17. hci_conn_hash_lookup_le
  18. hci_conn_hash_lookup_state
  19. hci_lookup_le_connect
  20. hci_conn_get
  21. hci_conn_put
  22. hci_conn_hold
  23. hci_conn_drop
  24. hci_dev_put
  25. hci_dev_hold
  26. hci_get_drvdata
  27. hci_set_drvdata
  28. hci_proto_connect_ind
  29. hci_proto_disconn_ind
  30. hci_connect_cfm
  31. hci_disconn_cfm
  32. hci_auth_cfm
  33. hci_encrypt_cfm
  34. hci_key_change_cfm
  35. hci_role_switch_cfm
  36. eir_get_data
  37. hci_bdaddr_is_rpa
  38. hci_is_identity_address
  39. hci_get_irk
  40. hci_check_conn_params

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

/* [<][>][^][v][top][bottom][index][help] */