include/net/bluetooth/hci_core.h

   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 #ifdef TIZEN_BT
 386         struct discovery_state  le_discovery;
 387 #endif
 388         struct hci_conn_hash    conn_hash;
 389
 390         struct list_head        mgmt_pending;
 391         struct list_head        blacklist;
 392         struct list_head        whitelist;
 393         struct list_head        uuids;
 394         struct list_head        link_keys;
 395         struct list_head        long_term_keys;
 396         struct list_head        identity_resolving_keys;
 397         struct list_head        remote_oob_data;
 398         struct list_head        le_white_list;
 399         struct list_head        le_resolv_list;
 400         struct list_head        le_conn_params;
 401         struct list_head        pend_le_conns;
 402         struct list_head        pend_le_reports;
 403
 404         struct hci_dev_stats    stat;
 405
 406         atomic_t                promisc;
 407
 408         const char              *hw_info;
 409         const char              *fw_info;
 410         struct dentry           *debugfs;
 411
 412         struct device           dev;
 413
 414         struct rfkill           *rfkill;
 415
 416         DECLARE_BITMAP(dev_flags, __HCI_NUM_FLAGS);
 417
 418         __s8                    adv_tx_power;
 419         __u8                    adv_data[HCI_MAX_AD_LENGTH];
 420         __u8                    adv_data_len;
 421         __u8                    scan_rsp_data[HCI_MAX_AD_LENGTH];
 422         __u8                    scan_rsp_data_len;
 423
 424         struct list_head        adv_instances;
 425         unsigned int            adv_instance_cnt;
 426         __u8                    cur_adv_instance;
 427         __u16                   adv_instance_timeout;
 428         struct delayed_work     adv_instance_expire;
 429
 430         __u8                    irk[16];
 431         __u32                   rpa_timeout;
 432         struct delayed_work     rpa_expired;
 433         bdaddr_t                rpa;
 434
 435 #if IS_ENABLED(CONFIG_BT_LEDS)
 436         struct led_trigger      *power_led;
 437 #endif
 438
 439 #ifdef TIZEN_BT
 440         __u8                    adv_filter_policy;
 441         __u8                    adv_type;
 442 #endif
 443
 444         int (*open)(struct hci_dev *hdev);
 445         int (*close)(struct hci_dev *hdev);
 446         int (*flush)(struct hci_dev *hdev);
 447         int (*setup)(struct hci_dev *hdev);
 448         int (*shutdown)(struct hci_dev *hdev);
 449         int (*send)(struct hci_dev *hdev, struct sk_buff *skb);
 450         void (*notify)(struct hci_dev *hdev, unsigned int evt);
 451         void (*hw_error)(struct hci_dev *hdev, u8 code);
 452         int (*post_init)(struct hci_dev *hdev);
 453         int (*set_diag)(struct hci_dev *hdev, bool enable);
 454         int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr);
 455         void (*cmd_timeout)(struct hci_dev *hdev);
 456 };
 457
 458 #define HCI_PHY_HANDLE(handle)  (handle & 0xff)
 459
 460 struct hci_conn {
 461         struct list_head list;
 462
 463         atomic_t        refcnt;
 464
 465         bdaddr_t        dst;
 466         __u8            dst_type;
 467         bdaddr_t        src;
 468         __u8            src_type;
 469         bdaddr_t        init_addr;
 470         __u8            init_addr_type;
 471         bdaddr_t        resp_addr;
 472         __u8            resp_addr_type;
 473         __u16           handle;
 474         __u16           state;
 475         __u8            mode;
 476         __u8            type;
 477         __u8            role;
 478         bool            out;
 479         __u8            attempt;
 480         __u8            dev_class[3];
 481         __u8            features[HCI_MAX_PAGES][8];
 482         __u16           pkt_type;
 483         __u16           link_policy;
 484         __u8            key_type;
 485         __u8            auth_type;
 486         __u8            sec_level;
 487         __u8            pending_sec_level;
 488         __u8            pin_length;
 489         __u8            enc_key_size;
 490         __u8            io_capability;
 491         __u32           passkey_notify;
 492         __u8            passkey_entered;
 493         __u16           disc_timeout;
 494         __u16           conn_timeout;
 495         __u16           setting;
 496         __u16           auth_payload_timeout;
 497         __u16           le_conn_min_interval;
 498         __u16           le_conn_max_interval;
 499         __u16           le_conn_interval;
 500         __u16           le_conn_latency;
 501         __u16           le_supv_timeout;
 502         __u8            le_adv_data[HCI_MAX_AD_LENGTH];
 503         __u8            le_adv_data_len;
 504         __s8            rssi;
 505         __s8            tx_power;
 506         __s8            max_tx_power;
 507         unsigned long   flags;
 508
 509         __u32           clock;
 510         __u16           clock_accuracy;
 511
 512         unsigned long   conn_info_timestamp;
 513
 514         __u8            remote_cap;
 515         __u8            remote_auth;
 516         __u8            remote_id;
 517
 518         unsigned int    sent;
 519
 520         struct sk_buff_head data_q;
 521         struct list_head chan_list;
 522
 523         struct delayed_work disc_work;
 524         struct delayed_work auto_accept_work;
 525         struct delayed_work idle_work;
 526         struct delayed_work le_conn_timeout;
 527         struct work_struct  le_scan_cleanup;
 528
 529         struct device   dev;
 530         struct dentry   *debugfs;
 531
 532         struct hci_dev  *hdev;
 533         void            *l2cap_data;
 534         void            *sco_data;
 535         struct amp_mgr  *amp_mgr;
 536
 537 #ifdef TIZEN_BT
 538         bool            rssi_monitored;
 539 #endif
 540         struct hci_conn *link;
 541
 542         void (*connect_cfm_cb)  (struct hci_conn *conn, u8 status);
 543         void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
 544         void (*disconn_cfm_cb)  (struct hci_conn *conn, u8 reason);
 545 };
 546
 547 struct hci_chan {
 548         struct list_head list;
 549         __u16 handle;
 550         struct hci_conn *conn;
 551         struct sk_buff_head data_q;
 552         unsigned int    sent;
 553         __u8            state;
 554 };
 555
 556 struct hci_conn_params {
 557         struct list_head list;
 558         struct list_head action;
 559
 560         bdaddr_t addr;
 561         u8 addr_type;
 562
 563         u16 conn_min_interval;
 564         u16 conn_max_interval;
 565         u16 conn_latency;
 566         u16 supervision_timeout;
 567
 568         enum {
 569                 HCI_AUTO_CONN_DISABLED,
 570                 HCI_AUTO_CONN_REPORT,
 571                 HCI_AUTO_CONN_DIRECT,
 572                 HCI_AUTO_CONN_ALWAYS,
 573                 HCI_AUTO_CONN_LINK_LOSS,
 574                 HCI_AUTO_CONN_EXPLICIT,
 575         } auto_connect;
 576
 577         struct hci_conn *conn;
 578         bool explicit_connect;
 579 };
 580
 581 extern struct list_head hci_dev_list;
 582 extern struct list_head hci_cb_list;
 583 extern rwlock_t hci_dev_list_lock;
 584 extern struct mutex hci_cb_list_lock;
 585
 586 #define hci_dev_set_flag(hdev, nr)             set_bit((nr), (hdev)->dev_flags)
 587 #define hci_dev_clear_flag(hdev, nr)           clear_bit((nr), (hdev)->dev_flags)
 588 #define hci_dev_change_flag(hdev, nr)          change_bit((nr), (hdev)->dev_flags)
 589 #define hci_dev_test_flag(hdev, nr)            test_bit((nr), (hdev)->dev_flags)
 590 #define hci_dev_test_and_set_flag(hdev, nr)    test_and_set_bit((nr), (hdev)->dev_flags)
 591 #define hci_dev_test_and_clear_flag(hdev, nr)  test_and_clear_bit((nr), (hdev)->dev_flags)
 592 #define hci_dev_test_and_change_flag(hdev, nr) test_and_change_bit((nr), (hdev)->dev_flags)
 593
 594 #define hci_dev_clear_volatile_flags(hdev)                      \
 595         do {                                                    \
 596                 hci_dev_clear_flag(hdev, HCI_LE_SCAN);          \
 597                 hci_dev_clear_flag(hdev, HCI_LE_ADV);           \
 598                 hci_dev_clear_flag(hdev, HCI_PERIODIC_INQ);     \
 599         } while (0)
 600
 601 /* ----- HCI interface to upper protocols ----- */
 602 int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
 603 int l2cap_disconn_ind(struct hci_conn *hcon);
 604 void l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
 605
 606 #if IS_ENABLED(CONFIG_BT_BREDR)
 607 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
 608 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
 609 #else
 610 static inline int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
 611                                   __u8 *flags)
 612 {
 613         return 0;
 614 }
 615
 616 static inline void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 617 {
 618 }
 619 #endif
 620
 621 /* ----- Inquiry cache ----- */
 622 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   /* 30 seconds */
 623 #define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   /* 60 seconds */
 624
 625 static inline void discovery_init(struct hci_dev *hdev)
 626 {
 627         hdev->discovery.state = DISCOVERY_STOPPED;
 628         INIT_LIST_HEAD(&hdev->discovery.all);
 629         INIT_LIST_HEAD(&hdev->discovery.unknown);
 630         INIT_LIST_HEAD(&hdev->discovery.resolve);
 631         hdev->discovery.report_invalid_rssi = true;
 632         hdev->discovery.rssi = HCI_RSSI_INVALID;
 633 }
 634
 635 static inline void hci_discovery_filter_clear(struct hci_dev *hdev)
 636 {
 637         hdev->discovery.result_filtering = false;
 638         hdev->discovery.report_invalid_rssi = true;
 639         hdev->discovery.rssi = HCI_RSSI_INVALID;
 640         hdev->discovery.uuid_count = 0;
 641         kfree(hdev->discovery.uuids);
 642         hdev->discovery.uuids = NULL;
 643         hdev->discovery.scan_start = 0;
 644         hdev->discovery.scan_duration = 0;
 645 }
 646
 647 bool hci_discovery_active(struct hci_dev *hdev);
 648
 649 void hci_discovery_set_state(struct hci_dev *hdev, int state);
 650
 651 static inline int inquiry_cache_empty(struct hci_dev *hdev)
 652 {
 653         return list_empty(&hdev->discovery.all);
 654 }
 655
 656 static inline long inquiry_cache_age(struct hci_dev *hdev)
 657 {
 658         struct discovery_state *c = &hdev->discovery;
 659         return jiffies - c->timestamp;
 660 }
 661
 662 static inline long inquiry_entry_age(struct inquiry_entry *e)
 663 {
 664         return jiffies - e->timestamp;
 665 }
 666
 667 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
 668                                                bdaddr_t *bdaddr);
 669 struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
 670                                                        bdaddr_t *bdaddr);
 671 struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
 672                                                        bdaddr_t *bdaddr,
 673                                                        int state);
 674 void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
 675                                       struct inquiry_entry *ie);
 676 u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
 677                              bool name_known);
 678 void hci_inquiry_cache_flush(struct hci_dev *hdev);
 679
 680 /* ----- HCI Connections ----- */
 681 enum {
 682         HCI_CONN_AUTH_PEND,
 683         HCI_CONN_REAUTH_PEND,
 684         HCI_CONN_ENCRYPT_PEND,
 685         HCI_CONN_RSWITCH_PEND,
 686         HCI_CONN_MODE_CHANGE_PEND,
 687         HCI_CONN_SCO_SETUP_PEND,
 688         HCI_CONN_MGMT_CONNECTED,
 689         HCI_CONN_SSP_ENABLED,
 690         HCI_CONN_SC_ENABLED,
 691         HCI_CONN_AES_CCM,
 692         HCI_CONN_POWER_SAVE,
 693         HCI_CONN_FLUSH_KEY,
 694         HCI_CONN_ENCRYPT,
 695         HCI_CONN_AUTH,
 696         HCI_CONN_SECURE,
 697         HCI_CONN_FIPS,
 698         HCI_CONN_STK_ENCRYPT,
 699         HCI_CONN_AUTH_INITIATOR,
 700         HCI_CONN_DROP,
 701         HCI_CONN_PARAM_REMOVAL_PEND,
 702         HCI_CONN_NEW_LINK_KEY,
 703         HCI_CONN_SCANNING,
 704         HCI_CONN_AUTH_FAILURE,
 705 };
 706
 707 static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
 708 {
 709         struct hci_dev *hdev = conn->hdev;
 710         return hci_dev_test_flag(hdev, HCI_SSP_ENABLED) &&
 711                test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
 712 }
 713
 714 static inline bool hci_conn_sc_enabled(struct hci_conn *conn)
 715 {
 716         struct hci_dev *hdev = conn->hdev;
 717         return hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
 718                test_bit(HCI_CONN_SC_ENABLED, &conn->flags);
 719 }
 720
 721 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
 722 {
 723         struct hci_conn_hash *h = &hdev->conn_hash;
 724         list_add_rcu(&c->list, &h->list);
 725         switch (c->type) {
 726         case ACL_LINK:
 727                 h->acl_num++;
 728                 break;
 729         case AMP_LINK:
 730                 h->amp_num++;
 731                 break;
 732         case LE_LINK:
 733                 h->le_num++;
 734                 if (c->role == HCI_ROLE_SLAVE)
 735                         h->le_num_slave++;
 736                 break;
 737         case SCO_LINK:
 738         case ESCO_LINK:
 739                 h->sco_num++;
 740                 break;
 741         }
 742 }
 743
 744 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
 745 {
 746         struct hci_conn_hash *h = &hdev->conn_hash;
 747
 748         list_del_rcu(&c->list);
 749         synchronize_rcu();
 750
 751         switch (c->type) {
 752         case ACL_LINK:
 753                 h->acl_num--;
 754                 break;
 755         case AMP_LINK:
 756                 h->amp_num--;
 757                 break;
 758         case LE_LINK:
 759                 h->le_num--;
 760                 if (c->role == HCI_ROLE_SLAVE)
 761                         h->le_num_slave--;
 762                 break;
 763         case SCO_LINK:
 764         case ESCO_LINK:
 765                 h->sco_num--;
 766                 break;
 767         }
 768 }
 769
 770 static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
 771 {
 772         struct hci_conn_hash *h = &hdev->conn_hash;
 773         switch (type) {
 774         case ACL_LINK:
 775                 return h->acl_num;
 776         case AMP_LINK:
 777                 return h->amp_num;
 778         case LE_LINK:
 779                 return h->le_num;
 780         case SCO_LINK:
 781         case ESCO_LINK:
 782                 return h->sco_num;
 783         default:
 784                 return 0;
 785         }
 786 }
 787
 788 static inline unsigned int hci_conn_count(struct hci_dev *hdev)
 789 {
 790         struct hci_conn_hash *c = &hdev->conn_hash;
 791
 792         return c->acl_num + c->amp_num + c->sco_num + c->le_num;
 793 }
 794
 795 static inline __u8 hci_conn_lookup_type(struct hci_dev *hdev, __u16 handle)
 796 {
 797         struct hci_conn_hash *h = &hdev->conn_hash;
 798         struct hci_conn *c;
 799         __u8 type = INVALID_LINK;
 800
 801         rcu_read_lock();
 802
 803         list_for_each_entry_rcu(c, &h->list, list) {
 804                 if (c->handle == handle) {
 805                         type = c->type;
 806                         break;
 807                 }
 808         }
 809
 810         rcu_read_unlock();
 811
 812         return type;
 813 }
 814
 815 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
 816                                                                 __u16 handle)
 817 {
 818         struct hci_conn_hash *h = &hdev->conn_hash;
 819         struct hci_conn  *c;
 820
 821         rcu_read_lock();
 822
 823         list_for_each_entry_rcu(c, &h->list, list) {
 824                 if (c->handle == handle) {
 825                         rcu_read_unlock();
 826                         return c;
 827                 }
 828         }
 829         rcu_read_unlock();
 830
 831         return NULL;
 832 }
 833
 834 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
 835                                                         __u8 type, bdaddr_t *ba)
 836 {
 837         struct hci_conn_hash *h = &hdev->conn_hash;
 838         struct hci_conn  *c;
 839
 840         rcu_read_lock();
 841
 842         list_for_each_entry_rcu(c, &h->list, list) {
 843                 if (c->type == type && !bacmp(&c->dst, ba)) {
 844                         rcu_read_unlock();
 845                         return c;
 846                 }
 847         }
 848
 849         rcu_read_unlock();
 850
 851         return NULL;
 852 }
 853
 854 static inline struct hci_conn *hci_conn_hash_lookup_le(struct hci_dev *hdev,
 855                                                        bdaddr_t *ba,
 856                                                        __u8 ba_type)
 857 {
 858         struct hci_conn_hash *h = &hdev->conn_hash;
 859         struct hci_conn  *c;
 860
 861         rcu_read_lock();
 862
 863         list_for_each_entry_rcu(c, &h->list, list) {
 864                 if (c->type != LE_LINK)
 865                        continue;
 866
 867                 if (ba_type == c->dst_type && !bacmp(&c->dst, ba)) {
 868                         rcu_read_unlock();
 869                         return c;
 870                 }
 871         }
 872
 873         rcu_read_unlock();
 874
 875         return NULL;
 876 }
 877
 878 static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
 879                                                         __u8 type, __u16 state)
 880 {
 881         struct hci_conn_hash *h = &hdev->conn_hash;
 882         struct hci_conn  *c;
 883
 884         rcu_read_lock();
 885
 886         list_for_each_entry_rcu(c, &h->list, list) {
 887                 if (c->type == type && c->state == state) {
 888                         rcu_read_unlock();
 889                         return c;
 890                 }
 891         }
 892
 893         rcu_read_unlock();
 894
 895         return NULL;
 896 }
 897
 898 static inline struct hci_conn *hci_lookup_le_connect(struct hci_dev *hdev)
 899 {
 900         struct hci_conn_hash *h = &hdev->conn_hash;
 901         struct hci_conn  *c;
 902
 903         rcu_read_lock();
 904
 905         list_for_each_entry_rcu(c, &h->list, list) {
 906                 if (c->type == LE_LINK && c->state == BT_CONNECT &&
 907                     !test_bit(HCI_CONN_SCANNING, &c->flags)) {
 908                         rcu_read_unlock();
 909                         return c;
 910                 }
 911         }
 912
 913         rcu_read_unlock();
 914
 915         return NULL;
 916 }
 917
 918 #ifdef TIZEN_BT
 919 static inline bool hci_conn_rssi_state_set(struct hci_dev *hdev,
 920                                         __u8 type, bdaddr_t *ba, bool value)
 921 {
 922         struct hci_conn_hash *h = &hdev->conn_hash;
 923         struct hci_conn  *c;
 924         __u8 conn_type;
 925
 926         if (type == 0x01)
 927                 conn_type = LE_LINK;
 928         else
 929                 conn_type = ACL_LINK;
 930
 931         rcu_read_lock();
 932
 933         list_for_each_entry_rcu(c, &h->list, list) {
 934                 if (c->type == conn_type && !bacmp(&c->dst, ba)) {
 935                         c->rssi_monitored = value;
 936                         rcu_read_unlock();
 937                         return true;
 938                 }
 939         }
 940
 941         rcu_read_unlock();
 942         return false;
 943 }
 944
 945 static inline void hci_conn_rssi_unset_all(struct hci_dev *hdev,
 946                                         __u8 type)
 947 {
 948         struct hci_conn_hash *h = &hdev->conn_hash;
 949         struct hci_conn  *c;
 950         __u8 conn_type;
 951
 952         if (type == 0x01)
 953                 conn_type = LE_LINK;
 954         else
 955                 conn_type = ACL_LINK;
 956
 957         rcu_read_lock();
 958         list_for_each_entry_rcu(c, &h->list, list) {
 959                 if (c->type == conn_type)
 960                         c->rssi_monitored = false;
 961         }
 962         rcu_read_unlock();
 963 }
 964
 965 static inline int hci_conn_hash_lookup_rssi_count(struct hci_dev *hdev)
 966 {
 967         struct hci_conn_hash *h = &hdev->conn_hash;
 968         struct hci_conn  *c;
 969         int count = 0;
 970
 971         rcu_read_lock();
 972         list_for_each_entry_rcu(c, &h->list, list) {
 973                 if (c->rssi_monitored == true)
 974                         ++count;
 975         }
 976         rcu_read_unlock();
 977
 978         return count;
 979 }
 980
 981 bool hci_le_discovery_active(struct hci_dev *hdev);
 982 void hci_le_discovery_set_state(struct hci_dev *hdev, int state);
 983 #endif
 984
 985 int hci_disconnect(struct hci_conn *conn, __u8 reason);
 986 bool hci_setup_sync(struct hci_conn *conn, __u16 handle);
 987 void hci_sco_setup(struct hci_conn *conn, __u8 status);
 988
 989 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
 990                               u8 role);
 991 int hci_conn_del(struct hci_conn *conn);
 992 void hci_conn_hash_flush(struct hci_dev *hdev);
 993 void hci_conn_check_pending(struct hci_dev *hdev);
 994
 995 struct hci_chan *hci_chan_create(struct hci_conn *conn);
 996 void hci_chan_del(struct hci_chan *chan);
 997 void hci_chan_list_flush(struct hci_conn *conn);
 998 struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle);
 999
1000 struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
1001                                      u8 dst_type, u8 sec_level,
1002                                      u16 conn_timeout);
1003 struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
1004                                 u8 dst_type, u8 sec_level, u16 conn_timeout,
1005                                 u8 role, bdaddr_t *direct_rpa);
1006 struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
1007                                  u8 sec_level, u8 auth_type);
1008 struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
1009                                  __u16 setting);
1010 int hci_conn_check_link_mode(struct hci_conn *conn);
1011 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
1012 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
1013                       bool initiator);
1014 int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
1015
1016 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
1017
1018 void hci_le_conn_failed(struct hci_conn *conn, u8 status);
1019
1020 /*
1021  * hci_conn_get() and hci_conn_put() are used to control the life-time of an
1022  * "hci_conn" object. They do not guarantee that the hci_conn object is running,
1023  * working or anything else. They just guarantee that the object is available
1024  * and can be dereferenced. So you can use its locks, local variables and any
1025  * other constant data.
1026  * Before accessing runtime data, you _must_ lock the object and then check that
1027  * it is still running. As soon as you release the locks, the connection might
1028  * get dropped, though.
1029  *
1030  * On the other hand, hci_conn_hold() and hci_conn_drop() are used to control
1031  * how long the underlying connection is held. So every channel that runs on the
1032  * hci_conn object calls this to prevent the connection from disappearing. As
1033  * long as you hold a device, you must also guarantee that you have a valid
1034  * reference to the device via hci_conn_get() (or the initial reference from
1035  * hci_conn_add()).
1036  * The hold()/drop() ref-count is known to drop below 0 sometimes, which doesn't
1037  * break because nobody cares for that. But this means, we cannot use
1038  * _get()/_drop() in it, but require the caller to have a valid ref (FIXME).
1039  */
1040
1041 static inline struct hci_conn *hci_conn_get(struct hci_conn *conn)
1042 {
1043         get_device(&conn->dev);
1044         return conn;
1045 }
1046
1047 static inline void hci_conn_put(struct hci_conn *conn)
1048 {
1049         put_device(&conn->dev);
1050 }
1051
1052 static inline void hci_conn_hold(struct hci_conn *conn)
1053 {
1054         BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1055
1056         atomic_inc(&conn->refcnt);
1057         cancel_delayed_work(&conn->disc_work);
1058 }
1059
1060 static inline void hci_conn_drop(struct hci_conn *conn)
1061 {
1062         BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1063
1064         if (atomic_dec_and_test(&conn->refcnt)) {
1065                 unsigned long timeo;
1066
1067                 switch (conn->type) {
1068                 case ACL_LINK:
1069                 case LE_LINK:
1070                         cancel_delayed_work(&conn->idle_work);
1071                         if (conn->state == BT_CONNECTED) {
1072                                 timeo = conn->disc_timeout;
1073                                 if (!conn->out)
1074                                         timeo *= 2;
1075                         } else {
1076                                 timeo = 0;
1077                         }
1078                         break;
1079
1080                 case AMP_LINK:
1081                         timeo = conn->disc_timeout;
1082                         break;
1083
1084                 default:
1085                         timeo = 0;
1086                         break;
1087                 }
1088
1089                 cancel_delayed_work(&conn->disc_work);
1090                 queue_delayed_work(conn->hdev->workqueue,
1091                                    &conn->disc_work, timeo);
1092         }
1093 }
1094
1095 /* ----- HCI Devices ----- */
1096 static inline void hci_dev_put(struct hci_dev *d)
1097 {
1098         BT_DBG("%s orig refcnt %d", d->name,
1099                kref_read(&d->dev.kobj.kref));
1100
1101         put_device(&d->dev);
1102 }
1103
1104 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
1105 {
1106         BT_DBG("%s orig refcnt %d", d->name,
1107                kref_read(&d->dev.kobj.kref));
1108
1109         get_device(&d->dev);
1110         return d;
1111 }
1112
1113 #define hci_dev_lock(d)         mutex_lock(&d->lock)
1114 #define hci_dev_unlock(d)       mutex_unlock(&d->lock)
1115
1116 #define to_hci_dev(d) container_of(d, struct hci_dev, dev)
1117 #define to_hci_conn(c) container_of(c, struct hci_conn, dev)
1118
1119 static inline void *hci_get_drvdata(struct hci_dev *hdev)
1120 {
1121         return dev_get_drvdata(&hdev->dev);
1122 }
1123
1124 static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
1125 {
1126         dev_set_drvdata(&hdev->dev, data);
1127 }
1128
1129 struct hci_dev *hci_dev_get(int index);
1130 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src, u8 src_type);
1131
1132 struct hci_dev *hci_alloc_dev(void);
1133 void hci_free_dev(struct hci_dev *hdev);
1134 int hci_register_dev(struct hci_dev *hdev);
1135 void hci_unregister_dev(struct hci_dev *hdev);
1136 int hci_suspend_dev(struct hci_dev *hdev);
1137 int hci_resume_dev(struct hci_dev *hdev);
1138 int hci_reset_dev(struct hci_dev *hdev);
1139 int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb);
1140 int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb);
1141 __printf(2, 3) void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...);
1142 __printf(2, 3) void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...);
1143 int hci_dev_open(__u16 dev);
1144 int hci_dev_close(__u16 dev);
1145 int hci_dev_do_close(struct hci_dev *hdev);
1146 int hci_dev_reset(__u16 dev);
1147 int hci_dev_reset_stat(__u16 dev);
1148 int hci_dev_cmd(unsigned int cmd, void __user *arg);
1149 int hci_get_dev_list(void __user *arg);
1150 int hci_get_dev_info(void __user *arg);
1151 int hci_get_conn_list(void __user *arg);
1152 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
1153 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
1154 int hci_inquiry(void __user *arg);
1155
1156 struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *list,
1157                                            bdaddr_t *bdaddr, u8 type);
1158 struct bdaddr_list_with_irk *hci_bdaddr_list_lookup_with_irk(
1159                                     struct list_head *list, bdaddr_t *bdaddr,
1160                                     u8 type);
1161 int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1162 int hci_bdaddr_list_add_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1163                                         u8 type, u8 *peer_irk, u8 *local_irk);
1164 int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1165 int hci_bdaddr_list_del_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1166                                                                 u8 type);
1167 void hci_bdaddr_list_clear(struct list_head *list);
1168
1169 struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev,
1170                                                bdaddr_t *addr, u8 addr_type);
1171 struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev,
1172                                             bdaddr_t *addr, u8 addr_type);
1173 void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type);
1174 void hci_conn_params_clear_disabled(struct hci_dev *hdev);
1175
1176 struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list,
1177                                                   bdaddr_t *addr,
1178                                                   u8 addr_type);
1179
1180 void hci_uuids_clear(struct hci_dev *hdev);
1181
1182 void hci_link_keys_clear(struct hci_dev *hdev);
1183 struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1184 struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn,
1185                                   bdaddr_t *bdaddr, u8 *val, u8 type,
1186                                   u8 pin_len, bool *persistent);
1187 struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1188                             u8 addr_type, u8 type, u8 authenticated,
1189                             u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand);
1190 struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1191                              u8 addr_type, u8 role);
1192 int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type);
1193 void hci_smp_ltks_clear(struct hci_dev *hdev);
1194 int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1195
1196 struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa);
1197 struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
1198                                      u8 addr_type);
1199 struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1200                             u8 addr_type, u8 val[16], bdaddr_t *rpa);
1201 void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type);
1202 void hci_smp_irks_clear(struct hci_dev *hdev);
1203
1204 bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1205
1206 void hci_remote_oob_data_clear(struct hci_dev *hdev);
1207 struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
1208                                           bdaddr_t *bdaddr, u8 bdaddr_type);
1209 int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1210                             u8 bdaddr_type, u8 *hash192, u8 *rand192,
1211                             u8 *hash256, u8 *rand256);
1212 int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1213                                u8 bdaddr_type);
1214
1215 void hci_adv_instances_clear(struct hci_dev *hdev);
1216 struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance);
1217 struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance);
1218 int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags,
1219                          u16 adv_data_len, u8 *adv_data,
1220                          u16 scan_rsp_len, u8 *scan_rsp_data,
1221                          u16 timeout, u16 duration);
1222 int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance);
1223 void hci_adv_instances_set_rpa_expired(struct hci_dev *hdev, bool rpa_expired);
1224
1225 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
1226
1227 void hci_init_sysfs(struct hci_dev *hdev);
1228 void hci_conn_init_sysfs(struct hci_conn *conn);
1229 void hci_conn_add_sysfs(struct hci_conn *conn);
1230 void hci_conn_del_sysfs(struct hci_conn *conn);
1231
1232 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
1233
1234 /* ----- LMP capabilities ----- */
1235 #define lmp_encrypt_capable(dev)   ((dev)->features[0][0] & LMP_ENCRYPT)
1236 #define lmp_rswitch_capable(dev)   ((dev)->features[0][0] & LMP_RSWITCH)
1237 #define lmp_hold_capable(dev)      ((dev)->features[0][0] & LMP_HOLD)
1238 #define lmp_sniff_capable(dev)     ((dev)->features[0][0] & LMP_SNIFF)
1239 #define lmp_park_capable(dev)      ((dev)->features[0][1] & LMP_PARK)
1240 #define lmp_inq_rssi_capable(dev)  ((dev)->features[0][3] & LMP_RSSI_INQ)
1241 #define lmp_esco_capable(dev)      ((dev)->features[0][3] & LMP_ESCO)
1242 #define lmp_bredr_capable(dev)     (!((dev)->features[0][4] & LMP_NO_BREDR))
1243 #define lmp_le_capable(dev)        ((dev)->features[0][4] & LMP_LE)
1244 #define lmp_sniffsubr_capable(dev) ((dev)->features[0][5] & LMP_SNIFF_SUBR)
1245 #define lmp_pause_enc_capable(dev) ((dev)->features[0][5] & LMP_PAUSE_ENC)
1246 #define lmp_ext_inq_capable(dev)   ((dev)->features[0][6] & LMP_EXT_INQ)
1247 #define lmp_le_br_capable(dev)     (!!((dev)->features[0][6] & LMP_SIMUL_LE_BR))
1248 #define lmp_ssp_capable(dev)       ((dev)->features[0][6] & LMP_SIMPLE_PAIR)
1249 #define lmp_no_flush_capable(dev)  ((dev)->features[0][6] & LMP_NO_FLUSH)
1250 #define lmp_lsto_capable(dev)      ((dev)->features[0][7] & LMP_LSTO)
1251 #define lmp_inq_tx_pwr_capable(dev) ((dev)->features[0][7] & LMP_INQ_TX_PWR)
1252 #define lmp_ext_feat_capable(dev)  ((dev)->features[0][7] & LMP_EXTFEATURES)
1253 #define lmp_transp_capable(dev)    ((dev)->features[0][2] & LMP_TRANSPARENT)
1254 #define lmp_edr_2m_capable(dev)    ((dev)->features[0][3] & LMP_EDR_2M)
1255 #define lmp_edr_3m_capable(dev)    ((dev)->features[0][3] & LMP_EDR_3M)
1256 #define lmp_edr_3slot_capable(dev) ((dev)->features[0][4] & LMP_EDR_3SLOT)
1257 #define lmp_edr_5slot_capable(dev) ((dev)->features[0][5] & LMP_EDR_5SLOT)
1258
1259 /* ----- Extended LMP capabilities ----- */
1260 #define lmp_csb_master_capable(dev) ((dev)->features[2][0] & LMP_CSB_MASTER)
1261 #define lmp_csb_slave_capable(dev)  ((dev)->features[2][0] & LMP_CSB_SLAVE)
1262 #define lmp_sync_train_capable(dev) ((dev)->features[2][0] & LMP_SYNC_TRAIN)
1263 #define lmp_sync_scan_capable(dev)  ((dev)->features[2][0] & LMP_SYNC_SCAN)
1264 #define lmp_sc_capable(dev)         ((dev)->features[2][1] & LMP_SC)
1265 #define lmp_ping_capable(dev)       ((dev)->features[2][1] & LMP_PING)
1266
1267 /* ----- Host capabilities ----- */
1268 #define lmp_host_ssp_capable(dev)  ((dev)->features[1][0] & LMP_HOST_SSP)
1269 #define lmp_host_sc_capable(dev)   ((dev)->features[1][0] & LMP_HOST_SC)
1270 #define lmp_host_le_capable(dev)   (!!((dev)->features[1][0] & LMP_HOST_LE))
1271 #define lmp_host_le_br_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE_BREDR))
1272
1273 #define hdev_is_powered(dev)   (test_bit(HCI_UP, &(dev)->flags) && \
1274                                 !hci_dev_test_flag(dev, HCI_AUTO_OFF))
1275 #define bredr_sc_enabled(dev)  (lmp_sc_capable(dev) && \
1276                                 hci_dev_test_flag(dev, HCI_SC_ENABLED))
1277
1278 #define scan_1m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_1M) || \
1279                       ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_1M))
1280
1281 #define scan_2m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_2M) || \
1282                       ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_2M))
1283
1284 #define scan_coded(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_CODED) || \
1285                          ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_CODED))
1286
1287 /* Use ext scanning if set ext scan param and ext scan enable is supported */
1288 #define use_ext_scan(dev) (((dev)->commands[37] & 0x20) && \
1289                            ((dev)->commands[37] & 0x40))
1290 /* Use ext create connection if command is supported */
1291 #define use_ext_conn(dev) ((dev)->commands[37] & 0x80)
1292
1293 /* Extended advertising support */
1294 #define ext_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_EXT_ADV))
1295
1296 /* ----- HCI protocols ----- */
1297 #define HCI_PROTO_DEFER             0x01
1298
1299 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
1300                                         __u8 type, __u8 *flags)
1301 {
1302         switch (type) {
1303         case ACL_LINK:
1304                 return l2cap_connect_ind(hdev, bdaddr);
1305
1306         case SCO_LINK:
1307         case ESCO_LINK:
1308                 return sco_connect_ind(hdev, bdaddr, flags);
1309
1310         default:
1311                 BT_ERR("unknown link type %d", type);
1312                 return -EINVAL;
1313         }
1314 }
1315
1316 static inline int hci_proto_disconn_ind(struct hci_conn *conn)
1317 {
1318         if (conn->type != ACL_LINK && conn->type != LE_LINK)
1319                 return HCI_ERROR_REMOTE_USER_TERM;
1320
1321         return l2cap_disconn_ind(conn);
1322 }
1323
1324 /* ----- HCI callbacks ----- */
1325 struct hci_cb {
1326         struct list_head list;
1327
1328         char *name;
1329
1330         void (*connect_cfm)     (struct hci_conn *conn, __u8 status);
1331         void (*disconn_cfm)     (struct hci_conn *conn, __u8 status);
1332         void (*security_cfm)    (struct hci_conn *conn, __u8 status,
1333                                                                 __u8 encrypt);
1334         void (*key_change_cfm)  (struct hci_conn *conn, __u8 status);
1335         void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
1336 };
1337
1338 static inline void hci_connect_cfm(struct hci_conn *conn, __u8 status)
1339 {
1340         struct hci_cb *cb;
1341
1342         mutex_lock(&hci_cb_list_lock);
1343         list_for_each_entry(cb, &hci_cb_list, list) {
1344                 if (cb->connect_cfm)
1345                         cb->connect_cfm(conn, status);
1346         }
1347         mutex_unlock(&hci_cb_list_lock);
1348
1349         if (conn->connect_cfm_cb)
1350                 conn->connect_cfm_cb(conn, status);
1351 }
1352
1353 static inline void hci_disconn_cfm(struct hci_conn *conn, __u8 reason)
1354 {
1355         struct hci_cb *cb;
1356
1357         mutex_lock(&hci_cb_list_lock);
1358         list_for_each_entry(cb, &hci_cb_list, list) {
1359                 if (cb->disconn_cfm)
1360                         cb->disconn_cfm(conn, reason);
1361         }
1362         mutex_unlock(&hci_cb_list_lock);
1363
1364         if (conn->disconn_cfm_cb)
1365                 conn->disconn_cfm_cb(conn, reason);
1366 }
1367
1368 static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
1369 {
1370         struct hci_cb *cb;
1371         __u8 encrypt;
1372
1373         if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
1374                 return;
1375
1376         encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00;
1377
1378         mutex_lock(&hci_cb_list_lock);
1379         list_for_each_entry(cb, &hci_cb_list, list) {
1380                 if (cb->security_cfm)
1381                         cb->security_cfm(conn, status, encrypt);
1382         }
1383         mutex_unlock(&hci_cb_list_lock);
1384
1385         if (conn->security_cfm_cb)
1386                 conn->security_cfm_cb(conn, status);
1387 }
1388
1389 static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status,
1390                                                                 __u8 encrypt)
1391 {
1392         struct hci_cb *cb;
1393
1394         if (conn->sec_level == BT_SECURITY_SDP)
1395                 conn->sec_level = BT_SECURITY_LOW;
1396
1397         if (conn->pending_sec_level > conn->sec_level)
1398                 conn->sec_level = conn->pending_sec_level;
1399
1400         mutex_lock(&hci_cb_list_lock);
1401         list_for_each_entry(cb, &hci_cb_list, list) {
1402                 if (cb->security_cfm)
1403                         cb->security_cfm(conn, status, encrypt);
1404         }
1405         mutex_unlock(&hci_cb_list_lock);
1406
1407         if (conn->security_cfm_cb)
1408                 conn->security_cfm_cb(conn, status);
1409 }
1410
1411 static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
1412 {
1413         struct hci_cb *cb;
1414
1415         mutex_lock(&hci_cb_list_lock);
1416         list_for_each_entry(cb, &hci_cb_list, list) {
1417                 if (cb->key_change_cfm)
1418                         cb->key_change_cfm(conn, status);
1419         }
1420         mutex_unlock(&hci_cb_list_lock);
1421 }
1422
1423 static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
1424                                                                 __u8 role)
1425 {
1426         struct hci_cb *cb;
1427
1428         mutex_lock(&hci_cb_list_lock);
1429         list_for_each_entry(cb, &hci_cb_list, list) {
1430                 if (cb->role_switch_cfm)
1431                         cb->role_switch_cfm(conn, status, role);
1432         }
1433         mutex_unlock(&hci_cb_list_lock);
1434 }
1435
1436 static inline void *eir_get_data(u8 *eir, size_t eir_len, u8 type,
1437                                  size_t *data_len)
1438 {
1439         size_t parsed = 0;
1440
1441         if (eir_len < 2)
1442                 return NULL;
1443
1444         while (parsed < eir_len - 1) {
1445                 u8 field_len = eir[0];
1446
1447                 if (field_len == 0)
1448                         break;
1449
1450                 parsed += field_len + 1;
1451
1452                 if (parsed > eir_len)
1453                         break;
1454
1455                 if (eir[1] != type) {
1456                         eir += field_len + 1;
1457                         continue;
1458                 }
1459
1460                 /* Zero length data */
1461                 if (field_len == 1)
1462                         return NULL;
1463
1464                 if (data_len)
1465                         *data_len = field_len - 1;
1466
1467                 return &eir[2];
1468         }
1469
1470         return NULL;
1471 }
1472
1473 static inline bool hci_bdaddr_is_rpa(bdaddr_t *bdaddr, u8 addr_type)
1474 {
1475         if (addr_type != ADDR_LE_DEV_RANDOM)
1476                 return false;
1477
1478         if ((bdaddr->b[5] & 0xc0) == 0x40)
1479                return true;
1480
1481         return false;
1482 }
1483
1484 static inline bool hci_is_identity_address(bdaddr_t *addr, u8 addr_type)
1485 {
1486         if (addr_type == ADDR_LE_DEV_PUBLIC)
1487                 return true;
1488
1489         /* Check for Random Static address type */
1490         if ((addr->b[5] & 0xc0) == 0xc0)
1491                 return true;
1492
1493         return false;
1494 }
1495
1496 static inline struct smp_irk *hci_get_irk(struct hci_dev *hdev,
1497                                           bdaddr_t *bdaddr, u8 addr_type)
1498 {
1499         if (!hci_bdaddr_is_rpa(bdaddr, addr_type))
1500                 return NULL;
1501
1502         return hci_find_irk_by_rpa(hdev, bdaddr);
1503 }
1504
1505 static inline int hci_check_conn_params(u16 min, u16 max, u16 latency,
1506                                         u16 to_multiplier)
1507 {
1508         u16 max_latency;
1509
1510         if (min > max || min < 6 || max > 3200)
1511                 return -EINVAL;
1512
1513         if (to_multiplier < 10 || to_multiplier > 3200)
1514                 return -EINVAL;
1515
1516         if (max >= to_multiplier * 8)
1517                 return -EINVAL;
1518
1519         max_latency = (to_multiplier * 4 / max) - 1;
1520         if (latency > 499 || latency > max_latency)
1521                 return -EINVAL;
1522
1523         return 0;
1524 }
1525
1526 int hci_register_cb(struct hci_cb *hcb);
1527 int hci_unregister_cb(struct hci_cb *hcb);
1528
1529 struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1530                                const void *param, u32 timeout);
1531 struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen,
1532                                   const void *param, u8 event, u32 timeout);
1533 int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen,
1534                    const void *param);
1535
1536 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
1537                  const void *param);
1538 void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
1539 void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
1540
1541 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
1542
1543 struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1544                              const void *param, u32 timeout);
1545
1546 /* ----- HCI Sockets ----- */
1547 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
1548 void hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
1549                          int flag, struct sock *skip_sk);
1550 void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
1551 void hci_send_monitor_ctrl_event(struct hci_dev *hdev, u16 event,
1552                                  void *data, u16 data_len, ktime_t tstamp,
1553                                  int flag, struct sock *skip_sk);
1554
1555 void hci_sock_dev_event(struct hci_dev *hdev, int event);
1556
1557 #define HCI_MGMT_VAR_LEN        BIT(0)
1558 #define HCI_MGMT_NO_HDEV        BIT(1)
1559 #define HCI_MGMT_UNTRUSTED      BIT(2)
1560 #define HCI_MGMT_UNCONFIGURED   BIT(3)
1561
1562 struct hci_mgmt_handler {
1563         int (*func) (struct sock *sk, struct hci_dev *hdev, void *data,
1564                      u16 data_len);
1565         size_t data_len;
1566         unsigned long flags;
1567 };
1568
1569 struct hci_mgmt_chan {
1570         struct list_head list;
1571         unsigned short channel;
1572         size_t handler_count;
1573         const struct hci_mgmt_handler *handlers;
1574 #ifdef TIZEN_BT
1575         size_t tizen_handler_count;
1576         const struct hci_mgmt_handler *tizen_handlers;
1577 #endif
1578         void (*hdev_init) (struct sock *sk, struct hci_dev *hdev);
1579 };
1580
1581 int hci_mgmt_chan_register(struct hci_mgmt_chan *c);
1582 void hci_mgmt_chan_unregister(struct hci_mgmt_chan *c);
1583
1584 /* Management interface */
1585 #define DISCOV_TYPE_BREDR               (BIT(BDADDR_BREDR))
1586 #define DISCOV_TYPE_LE                  (BIT(BDADDR_LE_PUBLIC) | \
1587                                          BIT(BDADDR_LE_RANDOM))
1588 #define DISCOV_TYPE_INTERLEAVED         (BIT(BDADDR_BREDR) | \
1589                                          BIT(BDADDR_LE_PUBLIC) | \
1590                                          BIT(BDADDR_LE_RANDOM))
1591
1592 /* These LE scan and inquiry parameters were chosen according to LE General
1593  * Discovery Procedure specification.
1594  */
1595 #define DISCOV_LE_SCAN_WIN              0x12
1596 #define DISCOV_LE_SCAN_INT              0x12
1597 #define DISCOV_LE_TIMEOUT               10240   /* msec */
1598 #define DISCOV_INTERLEAVED_TIMEOUT      5120    /* msec */
1599 #define DISCOV_INTERLEAVED_INQUIRY_LEN  0x04
1600 #define DISCOV_BREDR_INQUIRY_LEN        0x08
1601 #define DISCOV_LE_RESTART_DELAY         msecs_to_jiffies(200)   /* msec */
1602 #define DISCOV_LE_FAST_ADV_INT_MIN     100     /* msec */
1603 #define DISCOV_LE_FAST_ADV_INT_MAX     150     /* msec */
1604
1605 void mgmt_fill_version_info(void *ver);
1606 int mgmt_new_settings(struct hci_dev *hdev);
1607 void mgmt_index_added(struct hci_dev *hdev);
1608 void mgmt_index_removed(struct hci_dev *hdev);
1609 void mgmt_set_powered_failed(struct hci_dev *hdev, int err);
1610 void mgmt_power_on(struct hci_dev *hdev, int err);
1611 void __mgmt_power_off(struct hci_dev *hdev);
1612 void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
1613                        bool persistent);
1614 void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
1615                            u32 flags, u8 *name, u8 name_len);
1616 void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
1617                               u8 link_type, u8 addr_type, u8 reason,
1618                               bool mgmt_connected);
1619 void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
1620                             u8 link_type, u8 addr_type, u8 status);
1621 void mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1622                          u8 addr_type, u8 status);
1623 void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
1624 void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1625                                   u8 status);
1626 void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1627                                       u8 status);
1628 int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1629                               u8 link_type, u8 addr_type, u32 value,
1630                               u8 confirm_hint);
1631 int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1632                                      u8 link_type, u8 addr_type, u8 status);
1633 int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1634                                          u8 link_type, u8 addr_type, u8 status);
1635 int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1636                               u8 link_type, u8 addr_type);
1637 int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1638                                      u8 link_type, u8 addr_type, u8 status);
1639 int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1640                                          u8 link_type, u8 addr_type, u8 status);
1641 int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
1642                              u8 link_type, u8 addr_type, u32 passkey,
1643                              u8 entered);
1644 void mgmt_auth_failed(struct hci_conn *conn, u8 status);
1645 void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
1646 void mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1647 void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
1648                                     u8 status);
1649 void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
1650 void mgmt_start_discovery_complete(struct hci_dev *hdev, u8 status);
1651 void mgmt_stop_discovery_complete(struct hci_dev *hdev, u8 status);
1652 void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1653                        u8 addr_type, u8 *dev_class, s8 rssi, u32 flags,
1654                        u8 *eir, u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len);
1655 void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1656                       u8 addr_type, s8 rssi, u8 *name, u8 name_len);
1657 void mgmt_discovering(struct hci_dev *hdev, u8 discovering);
1658 bool mgmt_powering_down(struct hci_dev *hdev);
1659 void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent);
1660 void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk, bool persistent);
1661 void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
1662                    bool persistent);
1663 void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr,
1664                          u8 bdaddr_type, u8 store_hint, u16 min_interval,
1665                          u16 max_interval, u16 latency, u16 timeout);
1666 void mgmt_smp_complete(struct hci_conn *conn, bool complete);
1667 bool mgmt_get_connectable(struct hci_dev *hdev);
1668 void mgmt_set_connectable_complete(struct hci_dev *hdev, u8 status);
1669 void mgmt_set_discoverable_complete(struct hci_dev *hdev, u8 status);
1670 u8 mgmt_get_adv_discov_flags(struct hci_dev *hdev);
1671 void mgmt_advertising_added(struct sock *sk, struct hci_dev *hdev,
1672                             u8 instance);
1673 void mgmt_advertising_removed(struct sock *sk, struct hci_dev *hdev,
1674                               u8 instance);
1675 int mgmt_phy_configuration_changed(struct hci_dev *hdev, struct sock *skip);
1676
1677 #ifdef TIZEN_BT
1678 void mgmt_rssi_enable_success(struct sock *sk, struct hci_dev *hdev,
1679                 void *data, struct hci_cc_rsp_enable_rssi *rp, int success);
1680 void mgmt_rssi_disable_success(struct sock *sk, struct hci_dev *hdev,
1681                 void *data, struct hci_cc_rsp_enable_rssi *rp, int success);
1682 int mgmt_set_rssi_threshold(struct sock *sk, struct hci_dev *hdev,
1683                 void *data, u16 len);
1684 void mgmt_rssi_alert_evt(struct hci_dev *hdev, struct sk_buff *skb);
1685 void mgmt_raw_rssi_response(struct hci_dev *hdev,
1686                 struct hci_cc_rp_get_raw_rssi *rp, int success);
1687 void mgmt_enable_rssi_cc(struct hci_dev *hdev, void *response, u8 status);
1688 int mgmt_device_name_update(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *name,
1689                 u8 name_len);
1690 void mgmt_le_discovering(struct hci_dev *hdev, u8 discovering);
1691 #endif
1692
1693 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
1694                       u16 to_multiplier);
1695 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
1696                       __u8 ltk[16], __u8 key_size);
1697
1698 void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr,
1699                                u8 *bdaddr_type);
1700
1701 #define SCO_AIRMODE_MASK       0x0003
1702 #define SCO_AIRMODE_CVSD       0x0000
1703 #define SCO_AIRMODE_TRANSP     0x0003
1704
1705 #endif /* __HCI_CORE_H */