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/idr.h>
  29 #include <linux/leds.h>
  30 #include <linux/rculist.h>
  31
  32 #include <net/bluetooth/hci.h>
  33 #include <net/bluetooth/hci_sock.h>
  34
  35 /* HCI priority */
  36 #define HCI_PRIO_MAX    7
  37
  38 /* HCI maximum id value */
  39 #define HCI_MAX_ID 10000
  40
  41 /* HCI Core structures */
  42 struct inquiry_data {
  43         bdaddr_t        bdaddr;
  44         __u8            pscan_rep_mode;
  45         __u8            pscan_period_mode;
  46         __u8            pscan_mode;
  47         __u8            dev_class[3];
  48         __le16          clock_offset;
  49         __s8            rssi;
  50         __u8            ssp_mode;
  51 };
  52
  53 struct inquiry_entry {
  54         struct list_head        all;            /* inq_cache.all */
  55         struct list_head        list;           /* unknown or resolve */
  56         enum {
  57                 NAME_NOT_KNOWN,
  58                 NAME_NEEDED,
  59                 NAME_PENDING,
  60                 NAME_KNOWN,
  61         } name_state;
  62         __u32                   timestamp;
  63         struct inquiry_data     data;
  64 };
  65
  66 struct discovery_state {
  67         int                     type;
  68         enum {
  69                 DISCOVERY_STOPPED,
  70                 DISCOVERY_STARTING,
  71                 DISCOVERY_FINDING,
  72                 DISCOVERY_RESOLVING,
  73                 DISCOVERY_STOPPING,
  74         } state;
  75         struct list_head        all;    /* All devices found during inquiry */
  76         struct list_head        unknown;        /* Name state not known */
  77         struct list_head        resolve;        /* Name needs to be resolved */
  78         __u32                   timestamp;
  79         bdaddr_t                last_adv_addr;
  80         u8                      last_adv_addr_type;
  81         s8                      last_adv_rssi;
  82         u32                     last_adv_flags;
  83         u8                      last_adv_data[HCI_MAX_AD_LENGTH];
  84         u8                      last_adv_data_len;
  85         bool                    report_invalid_rssi;
  86         bool                    result_filtering;
  87         bool                    limited;
  88         s8                      rssi;
  89         u16                     uuid_count;
  90         u8                      (*uuids)[16];
  91         unsigned long           scan_start;
  92         unsigned long           scan_duration;
  93 };
  94
  95 #define SUSPEND_NOTIFIER_TIMEOUT        msecs_to_jiffies(2000) /* 2 seconds */
  96
  97 enum suspend_tasks {
  98         SUSPEND_PAUSE_DISCOVERY,
  99         SUSPEND_UNPAUSE_DISCOVERY,
 100
 101         SUSPEND_PAUSE_ADVERTISING,
 102         SUSPEND_UNPAUSE_ADVERTISING,
 103
 104         SUSPEND_SCAN_DISABLE,
 105         SUSPEND_SCAN_ENABLE,
 106         SUSPEND_DISCONNECTING,
 107
 108         SUSPEND_POWERING_DOWN,
 109
 110         SUSPEND_PREPARE_NOTIFIER,
 111
 112         SUSPEND_SET_ADV_FILTER,
 113         __SUSPEND_NUM_TASKS
 114 };
 115
 116 enum suspended_state {
 117         BT_RUNNING = 0,
 118         BT_SUSPEND_DISCONNECT,
 119         BT_SUSPEND_CONFIGURE_WAKE,
 120 };
 121
 122 struct hci_conn_hash {
 123         struct list_head list;
 124         unsigned int     acl_num;
 125         unsigned int     amp_num;
 126         unsigned int     sco_num;
 127         unsigned int     le_num;
 128         unsigned int     le_num_peripheral;
 129 };
 130
 131 struct bdaddr_list {
 132         struct list_head list;
 133         bdaddr_t bdaddr;
 134         u8 bdaddr_type;
 135 };
 136
 137 struct bdaddr_list_with_irk {
 138         struct list_head list;
 139         bdaddr_t bdaddr;
 140         u8 bdaddr_type;
 141         u8 peer_irk[16];
 142         u8 local_irk[16];
 143 };
 144
 145 struct bdaddr_list_with_flags {
 146         struct list_head list;
 147         bdaddr_t bdaddr;
 148         u8 bdaddr_type;
 149         u32 current_flags;
 150 };
 151
 152 enum hci_conn_flags {
 153         HCI_CONN_FLAG_REMOTE_WAKEUP,
 154         HCI_CONN_FLAG_MAX
 155 };
 156
 157 #define hci_conn_test_flag(nr, flags) ((flags) & (1U << nr))
 158
 159 /* Make sure number of flags doesn't exceed sizeof(current_flags) */
 160 static_assert(HCI_CONN_FLAG_MAX < 32);
 161
 162 struct bt_uuid {
 163         struct list_head list;
 164         u8 uuid[16];
 165         u8 size;
 166         u8 svc_hint;
 167 };
 168
 169 struct blocked_key {
 170         struct list_head list;
 171         struct rcu_head rcu;
 172         u8 type;
 173         u8 val[16];
 174 };
 175
 176 struct smp_csrk {
 177         bdaddr_t bdaddr;
 178         u8 bdaddr_type;
 179         u8 type;
 180         u8 val[16];
 181 };
 182
 183 struct smp_ltk {
 184         struct list_head list;
 185         struct rcu_head rcu;
 186         bdaddr_t bdaddr;
 187         u8 bdaddr_type;
 188         u8 authenticated;
 189         u8 type;
 190         u8 enc_size;
 191         __le16 ediv;
 192         __le64 rand;
 193         u8 val[16];
 194 };
 195
 196 struct smp_irk {
 197         struct list_head list;
 198         struct rcu_head rcu;
 199         bdaddr_t rpa;
 200         bdaddr_t bdaddr;
 201         u8 addr_type;
 202         u8 val[16];
 203 };
 204
 205 struct link_key {
 206         struct list_head list;
 207         struct rcu_head rcu;
 208         bdaddr_t bdaddr;
 209         u8 type;
 210         u8 val[HCI_LINK_KEY_SIZE];
 211         u8 pin_len;
 212 };
 213
 214 struct oob_data {
 215         struct list_head list;
 216         bdaddr_t bdaddr;
 217         u8 bdaddr_type;
 218         u8 present;
 219         u8 hash192[16];
 220         u8 rand192[16];
 221         u8 hash256[16];
 222         u8 rand256[16];
 223 };
 224
 225 struct adv_info {
 226         struct list_head list;
 227         bool enabled;
 228         bool pending;
 229         __u8    instance;
 230         __u32   flags;
 231         __u16   timeout;
 232         __u16   remaining_time;
 233         __u16   duration;
 234         __u16   adv_data_len;
 235         __u8    adv_data[HCI_MAX_EXT_AD_LENGTH];
 236         __u16   scan_rsp_len;
 237         __u8    scan_rsp_data[HCI_MAX_EXT_AD_LENGTH];
 238         __s8    tx_power;
 239         __u32   min_interval;
 240         __u32   max_interval;
 241         bdaddr_t        random_addr;
 242         bool            rpa_expired;
 243         struct delayed_work     rpa_expired_cb;
 244 };
 245
 246 #define HCI_MAX_ADV_INSTANCES           5
 247 #define HCI_DEFAULT_ADV_DURATION        2
 248
 249 #define HCI_ADV_TX_POWER_NO_PREFERENCE 0x7F
 250
 251 struct adv_pattern {
 252         struct list_head list;
 253         __u8 ad_type;
 254         __u8 offset;
 255         __u8 length;
 256         __u8 value[HCI_MAX_AD_LENGTH];
 257 };
 258
 259 struct adv_rssi_thresholds {
 260         __s8 low_threshold;
 261         __s8 high_threshold;
 262         __u16 low_threshold_timeout;
 263         __u16 high_threshold_timeout;
 264         __u8 sampling_period;
 265 };
 266
 267 struct adv_monitor {
 268         struct list_head patterns;
 269         struct adv_rssi_thresholds rssi;
 270         __u16           handle;
 271
 272         enum {
 273                 ADV_MONITOR_STATE_NOT_REGISTERED,
 274                 ADV_MONITOR_STATE_REGISTERED,
 275                 ADV_MONITOR_STATE_OFFLOADED
 276         } state;
 277 };
 278
 279 #define HCI_MIN_ADV_MONITOR_HANDLE              1
 280 #define HCI_MAX_ADV_MONITOR_NUM_HANDLES         32
 281 #define HCI_MAX_ADV_MONITOR_NUM_PATTERNS        16
 282 #define HCI_ADV_MONITOR_EXT_NONE                1
 283 #define HCI_ADV_MONITOR_EXT_MSFT                2
 284
 285 #define HCI_MAX_SHORT_NAME_LENGTH       10
 286
 287 /* Min encryption key size to match with SMP */
 288 #define HCI_MIN_ENC_KEY_SIZE            7
 289
 290 /* Default LE RPA expiry time, 15 minutes */
 291 #define HCI_DEFAULT_RPA_TIMEOUT         (15 * 60)
 292
 293 /* Default min/max age of connection information (1s/3s) */
 294 #define DEFAULT_CONN_INFO_MIN_AGE       1000
 295 #define DEFAULT_CONN_INFO_MAX_AGE       3000
 296 /* Default authenticated payload timeout 30s */
 297 #define DEFAULT_AUTH_PAYLOAD_TIMEOUT   0x0bb8
 298
 299 struct amp_assoc {
 300         __u16   len;
 301         __u16   offset;
 302         __u16   rem_len;
 303         __u16   len_so_far;
 304         __u8    data[HCI_MAX_AMP_ASSOC_SIZE];
 305 };
 306
 307 #define HCI_MAX_PAGES   3
 308
 309 #ifdef TIZEN_BT
 310 #define HCI_MAX_EIR_MANUFACTURER_DATA_LENGTH    100
 311 #endif
 312
 313 struct hci_dev {
 314         struct list_head list;
 315         struct mutex    lock;
 316
 317         char            name[8];
 318         unsigned long   flags;
 319         __u16           id;
 320         __u8            bus;
 321         __u8            dev_type;
 322         bdaddr_t        bdaddr;
 323         bdaddr_t        setup_addr;
 324         bdaddr_t        public_addr;
 325         bdaddr_t        random_addr;
 326         bdaddr_t        static_addr;
 327         __u8            adv_addr_type;
 328         __u8            dev_name[HCI_MAX_NAME_LENGTH];
 329         __u8            short_name[HCI_MAX_SHORT_NAME_LENGTH];
 330         __u8            eir[HCI_MAX_EIR_LENGTH];
 331         __u16           appearance;
 332         __u8            dev_class[3];
 333         __u8            major_class;
 334         __u8            minor_class;
 335         __u8            max_page;
 336         __u8            features[HCI_MAX_PAGES][8];
 337         __u8            le_features[8];
 338         __u8            le_accept_list_size;
 339         __u8            le_resolv_list_size;
 340         __u8            le_num_of_adv_sets;
 341         __u8            le_states[8];
 342         __u8            commands[64];
 343         __u8            hci_ver;
 344         __u16           hci_rev;
 345         __u8            lmp_ver;
 346         __u16           manufacturer;
 347         __u16           lmp_subver;
 348         __u16           voice_setting;
 349         __u8            num_iac;
 350         __u8            stored_max_keys;
 351         __u8            stored_num_keys;
 352         __u8            io_capability;
 353         __s8            inq_tx_power;
 354         __u8            err_data_reporting;
 355         __u16           page_scan_interval;
 356         __u16           page_scan_window;
 357         __u8            page_scan_type;
 358         __u8            le_adv_channel_map;
 359         __u16           le_adv_min_interval;
 360         __u16           le_adv_max_interval;
 361         __u8            le_scan_type;
 362         __u16           le_scan_interval;
 363         __u16           le_scan_window;
 364         __u16           le_scan_int_suspend;
 365         __u16           le_scan_window_suspend;
 366         __u16           le_scan_int_discovery;
 367         __u16           le_scan_window_discovery;
 368         __u16           le_scan_int_adv_monitor;
 369         __u16           le_scan_window_adv_monitor;
 370         __u16           le_scan_int_connect;
 371         __u16           le_scan_window_connect;
 372         __u16           le_conn_min_interval;
 373         __u16           le_conn_max_interval;
 374         __u16           le_conn_latency;
 375         __u16           le_supv_timeout;
 376         __u16           le_def_tx_len;
 377         __u16           le_def_tx_time;
 378         __u16           le_max_tx_len;
 379         __u16           le_max_tx_time;
 380         __u16           le_max_rx_len;
 381         __u16           le_max_rx_time;
 382         __u8            le_max_key_size;
 383         __u8            le_min_key_size;
 384         __u16           discov_interleaved_timeout;
 385         __u16           conn_info_min_age;
 386         __u16           conn_info_max_age;
 387         __u16           auth_payload_timeout;
 388         __u8            min_enc_key_size;
 389         __u8            max_enc_key_size;
 390         __u8            pairing_opts;
 391         __u8            ssp_debug_mode;
 392         __u8            hw_error_code;
 393         __u32           clock;
 394         __u16           advmon_allowlist_duration;
 395         __u16           advmon_no_filter_duration;
 396         __u8            enable_advmon_interleave_scan;
 397
 398         __u16           devid_source;
 399         __u16           devid_vendor;
 400         __u16           devid_product;
 401         __u16           devid_version;
 402
 403         __u8            def_page_scan_type;
 404         __u16           def_page_scan_int;
 405         __u16           def_page_scan_window;
 406         __u8            def_inq_scan_type;
 407         __u16           def_inq_scan_int;
 408         __u16           def_inq_scan_window;
 409         __u16           def_br_lsto;
 410         __u16           def_page_timeout;
 411         __u16           def_multi_adv_rotation_duration;
 412         __u16           def_le_autoconnect_timeout;
 413         __s8            min_le_tx_power;
 414         __s8            max_le_tx_power;
 415
 416         __u16           pkt_type;
 417         __u16           esco_type;
 418         __u16           link_policy;
 419         __u16           link_mode;
 420
 421         __u32           idle_timeout;
 422         __u16           sniff_min_interval;
 423         __u16           sniff_max_interval;
 424
 425         __u8            amp_status;
 426         __u32           amp_total_bw;
 427         __u32           amp_max_bw;
 428         __u32           amp_min_latency;
 429         __u32           amp_max_pdu;
 430         __u8            amp_type;
 431         __u16           amp_pal_cap;
 432         __u16           amp_assoc_size;
 433         __u32           amp_max_flush_to;
 434         __u32           amp_be_flush_to;
 435
 436         struct amp_assoc        loc_assoc;
 437
 438         __u8            flow_ctl_mode;
 439
 440         unsigned int    auto_accept_delay;
 441
 442         unsigned long   quirks;
 443
 444         atomic_t        cmd_cnt;
 445         unsigned int    acl_cnt;
 446         unsigned int    sco_cnt;
 447         unsigned int    le_cnt;
 448
 449         unsigned int    acl_mtu;
 450         unsigned int    sco_mtu;
 451         unsigned int    le_mtu;
 452         unsigned int    acl_pkts;
 453         unsigned int    sco_pkts;
 454         unsigned int    le_pkts;
 455
 456         __u16           block_len;
 457         __u16           block_mtu;
 458         __u16           num_blocks;
 459         __u16           block_cnt;
 460
 461         unsigned long   acl_last_tx;
 462         unsigned long   sco_last_tx;
 463         unsigned long   le_last_tx;
 464
 465         __u8            le_tx_def_phys;
 466         __u8            le_rx_def_phys;
 467
 468         struct workqueue_struct *workqueue;
 469         struct workqueue_struct *req_workqueue;
 470
 471         struct work_struct      power_on;
 472         struct delayed_work     power_off;
 473         struct work_struct      error_reset;
 474
 475         __u16                   discov_timeout;
 476         struct delayed_work     discov_off;
 477
 478         struct delayed_work     service_cache;
 479
 480         struct delayed_work     cmd_timer;
 481         struct delayed_work     ncmd_timer;
 482
 483         struct work_struct      rx_work;
 484         struct work_struct      cmd_work;
 485         struct work_struct      tx_work;
 486
 487         struct work_struct      discov_update;
 488         struct work_struct      bg_scan_update;
 489         struct work_struct      scan_update;
 490         struct work_struct      connectable_update;
 491         struct work_struct      discoverable_update;
 492         struct delayed_work     le_scan_disable;
 493         struct delayed_work     le_scan_restart;
 494
 495         struct sk_buff_head     rx_q;
 496         struct sk_buff_head     raw_q;
 497         struct sk_buff_head     cmd_q;
 498
 499         struct sk_buff          *sent_cmd;
 500
 501         struct mutex            req_lock;
 502         wait_queue_head_t       req_wait_q;
 503         __u32                   req_status;
 504         __u32                   req_result;
 505         struct sk_buff          *req_skb;
 506
 507         void                    *smp_data;
 508         void                    *smp_bredr_data;
 509
 510         struct discovery_state  discovery;
 511
 512         int                     discovery_old_state;
 513         bool                    discovery_paused;
 514         int                     advertising_old_state;
 515         bool                    advertising_paused;
 516
 517         struct notifier_block   suspend_notifier;
 518         struct work_struct      suspend_prepare;
 519         enum suspended_state    suspend_state_next;
 520         enum suspended_state    suspend_state;
 521         bool                    scanning_paused;
 522         bool                    suspended;
 523         u8                      wake_reason;
 524         bdaddr_t                wake_addr;
 525         u8                      wake_addr_type;
 526
 527         wait_queue_head_t       suspend_wait_q;
 528         DECLARE_BITMAP(suspend_tasks, __SUSPEND_NUM_TASKS);
 529
 530 #ifdef TIZEN_BT
 531         struct discovery_state  le_discovery;
 532 #endif
 533         struct hci_conn_hash    conn_hash;
 534
 535         struct list_head        mgmt_pending;
 536         struct list_head        reject_list;
 537         struct list_head        accept_list;
 538         struct list_head        uuids;
 539         struct list_head        link_keys;
 540         struct list_head        long_term_keys;
 541         struct list_head        identity_resolving_keys;
 542         struct list_head        remote_oob_data;
 543         struct list_head        le_accept_list;
 544         struct list_head        le_resolv_list;
 545         struct list_head        le_conn_params;
 546         struct list_head        pend_le_conns;
 547         struct list_head        pend_le_reports;
 548         struct list_head        blocked_keys;
 549
 550         struct hci_dev_stats    stat;
 551
 552         atomic_t                promisc;
 553
 554         const char              *hw_info;
 555         const char              *fw_info;
 556         struct dentry           *debugfs;
 557
 558         struct device           dev;
 559
 560         struct rfkill           *rfkill;
 561
 562         DECLARE_BITMAP(dev_flags, __HCI_NUM_FLAGS);
 563
 564         __s8                    adv_tx_power;
 565         __u8                    adv_data[HCI_MAX_EXT_AD_LENGTH];
 566         __u8                    adv_data_len;
 567         __u8                    scan_rsp_data[HCI_MAX_EXT_AD_LENGTH];
 568         __u8                    scan_rsp_data_len;
 569
 570         struct list_head        adv_instances;
 571         unsigned int            adv_instance_cnt;
 572         __u8                    cur_adv_instance;
 573         __u16                   adv_instance_timeout;
 574         struct delayed_work     adv_instance_expire;
 575
 576         struct idr              adv_monitors_idr;
 577         unsigned int            adv_monitors_cnt;
 578
 579         __u8                    irk[16];
 580         __u32                   rpa_timeout;
 581         struct delayed_work     rpa_expired;
 582         bdaddr_t                rpa;
 583
 584         enum {
 585                 INTERLEAVE_SCAN_NONE,
 586                 INTERLEAVE_SCAN_NO_FILTER,
 587                 INTERLEAVE_SCAN_ALLOWLIST
 588         } interleave_scan_state;
 589
 590         struct delayed_work     interleave_scan;
 591
 592 #if IS_ENABLED(CONFIG_BT_LEDS)
 593         struct led_trigger      *power_led;
 594 #endif
 595
 596 #if IS_ENABLED(CONFIG_BT_MSFTEXT)
 597         __u16                   msft_opcode;
 598         void                    *msft_data;
 599         bool                    msft_curve_validity;
 600 #endif
 601
 602 #if IS_ENABLED(CONFIG_BT_AOSPEXT)
 603         bool                    aosp_capable;
 604 #endif
 605
 606 #ifdef TIZEN_BT
 607         __u8                    adv_filter_policy;
 608         __u8                    adv_type;
 609         __u8                    manufacturer_len;
 610         __u8                    manufacturer_data[HCI_MAX_EIR_MANUFACTURER_DATA_LENGTH];
 611 #endif
 612
 613         int (*open)(struct hci_dev *hdev);
 614         int (*close)(struct hci_dev *hdev);
 615         int (*flush)(struct hci_dev *hdev);
 616         int (*setup)(struct hci_dev *hdev);
 617         int (*shutdown)(struct hci_dev *hdev);
 618         int (*send)(struct hci_dev *hdev, struct sk_buff *skb);
 619         void (*notify)(struct hci_dev *hdev, unsigned int evt);
 620         void (*hw_error)(struct hci_dev *hdev, u8 code);
 621         int (*post_init)(struct hci_dev *hdev);
 622         int (*set_diag)(struct hci_dev *hdev, bool enable);
 623         int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr);
 624         void (*cmd_timeout)(struct hci_dev *hdev);
 625         bool (*prevent_wake)(struct hci_dev *hdev);
 626 };
 627
 628 #define HCI_PHY_HANDLE(handle)  (handle & 0xff)
 629
 630 enum conn_reasons {
 631         CONN_REASON_PAIR_DEVICE,
 632         CONN_REASON_L2CAP_CHAN,
 633         CONN_REASON_SCO_CONNECT,
 634 };
 635
 636 struct hci_conn {
 637         struct list_head list;
 638
 639         atomic_t        refcnt;
 640
 641         bdaddr_t        dst;
 642         __u8            dst_type;
 643         bdaddr_t        src;
 644         __u8            src_type;
 645         bdaddr_t        init_addr;
 646         __u8            init_addr_type;
 647         bdaddr_t        resp_addr;
 648         __u8            resp_addr_type;
 649         __u8            adv_instance;
 650         __u16           handle;
 651         __u16           state;
 652         __u8            mode;
 653         __u8            type;
 654         __u8            role;
 655         bool            out;
 656         __u8            attempt;
 657         __u8            dev_class[3];
 658         __u8            features[HCI_MAX_PAGES][8];
 659         __u16           pkt_type;
 660         __u16           link_policy;
 661         __u8            key_type;
 662         __u8            auth_type;
 663         __u8            sec_level;
 664         __u8            pending_sec_level;
 665         __u8            pin_length;
 666         __u8            enc_key_size;
 667         __u8            io_capability;
 668         __u32           passkey_notify;
 669         __u8            passkey_entered;
 670         __u16           disc_timeout;
 671         __u16           conn_timeout;
 672         __u16           setting;
 673         __u16           auth_payload_timeout;
 674         __u16           le_conn_min_interval;
 675         __u16           le_conn_max_interval;
 676         __u16           le_conn_interval;
 677         __u16           le_conn_latency;
 678         __u16           le_supv_timeout;
 679         __u8            le_adv_data[HCI_MAX_AD_LENGTH];
 680         __u8            le_adv_data_len;
 681         __u8            le_tx_phy;
 682         __u8            le_rx_phy;
 683         __s8            rssi;
 684         __s8            tx_power;
 685         __s8            max_tx_power;
 686         unsigned long   flags;
 687
 688         enum conn_reasons conn_reason;
 689
 690         __u32           clock;
 691         __u16           clock_accuracy;
 692
 693         unsigned long   conn_info_timestamp;
 694
 695         __u8            remote_cap;
 696         __u8            remote_auth;
 697         __u8            remote_id;
 698
 699         unsigned int    sent;
 700 #ifdef TIZEN_BT
 701         __u16           tx_len;
 702         __u16           tx_time;
 703         __u16           rx_len;
 704         __u16           rx_time;
 705 #endif
 706
 707         struct sk_buff_head data_q;
 708         struct list_head chan_list;
 709
 710         struct delayed_work disc_work;
 711         struct delayed_work auto_accept_work;
 712         struct delayed_work idle_work;
 713         struct delayed_work le_conn_timeout;
 714         struct work_struct  le_scan_cleanup;
 715
 716         struct device   dev;
 717         struct dentry   *debugfs;
 718
 719         struct hci_dev  *hdev;
 720         void            *l2cap_data;
 721         void            *sco_data;
 722         struct amp_mgr  *amp_mgr;
 723
 724 #ifdef TIZEN_BT
 725         bool            rssi_monitored;
 726         __u8            sco_role;
 727         __u16           voice_setting;
 728 #endif
 729         struct hci_conn *link;
 730
 731         void (*connect_cfm_cb)  (struct hci_conn *conn, u8 status);
 732         void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
 733         void (*disconn_cfm_cb)  (struct hci_conn *conn, u8 reason);
 734 };
 735
 736 struct hci_chan {
 737         struct list_head list;
 738         __u16 handle;
 739         struct hci_conn *conn;
 740         struct sk_buff_head data_q;
 741         unsigned int    sent;
 742         __u8            state;
 743         bool            amp;
 744 };
 745
 746 struct hci_conn_params {
 747         struct list_head list;
 748         struct list_head action;
 749
 750         bdaddr_t addr;
 751         u8 addr_type;
 752
 753         u16 conn_min_interval;
 754         u16 conn_max_interval;
 755         u16 conn_latency;
 756         u16 supervision_timeout;
 757
 758 #ifdef TIZEN_BT
 759         u16 max_tx_octets;
 760         u16 max_tx_time;
 761 #endif
 762         enum {
 763                 HCI_AUTO_CONN_DISABLED,
 764                 HCI_AUTO_CONN_REPORT,
 765                 HCI_AUTO_CONN_DIRECT,
 766                 HCI_AUTO_CONN_ALWAYS,
 767                 HCI_AUTO_CONN_LINK_LOSS,
 768                 HCI_AUTO_CONN_EXPLICIT,
 769         } auto_connect;
 770
 771         struct hci_conn *conn;
 772         bool explicit_connect;
 773         u32 current_flags;
 774 };
 775
 776 extern struct list_head hci_dev_list;
 777 extern struct list_head hci_cb_list;
 778 extern rwlock_t hci_dev_list_lock;
 779 extern struct mutex hci_cb_list_lock;
 780
 781 #define hci_dev_set_flag(hdev, nr)             set_bit((nr), (hdev)->dev_flags)
 782 #define hci_dev_clear_flag(hdev, nr)           clear_bit((nr), (hdev)->dev_flags)
 783 #define hci_dev_change_flag(hdev, nr)          change_bit((nr), (hdev)->dev_flags)
 784 #define hci_dev_test_flag(hdev, nr)            test_bit((nr), (hdev)->dev_flags)
 785 #define hci_dev_test_and_set_flag(hdev, nr)    test_and_set_bit((nr), (hdev)->dev_flags)
 786 #define hci_dev_test_and_clear_flag(hdev, nr)  test_and_clear_bit((nr), (hdev)->dev_flags)
 787 #define hci_dev_test_and_change_flag(hdev, nr) test_and_change_bit((nr), (hdev)->dev_flags)
 788
 789 #define hci_dev_clear_volatile_flags(hdev)                      \
 790         do {                                                    \
 791                 hci_dev_clear_flag(hdev, HCI_LE_SCAN);          \
 792                 hci_dev_clear_flag(hdev, HCI_LE_ADV);           \
 793                 hci_dev_clear_flag(hdev, HCI_LL_RPA_RESOLUTION);\
 794                 hci_dev_clear_flag(hdev, HCI_PERIODIC_INQ);     \
 795         } while (0)
 796
 797 /* ----- HCI interface to upper protocols ----- */
 798 int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
 799 int l2cap_disconn_ind(struct hci_conn *hcon);
 800 void l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
 801
 802 #if IS_ENABLED(CONFIG_BT_BREDR)
 803 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
 804 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
 805 #else
 806 static inline int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
 807                                   __u8 *flags)
 808 {
 809         return 0;
 810 }
 811
 812 static inline void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 813 {
 814 }
 815 #endif
 816
 817 /* ----- Inquiry cache ----- */
 818 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   /* 30 seconds */
 819 #define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   /* 60 seconds */
 820
 821 static inline void discovery_init(struct hci_dev *hdev)
 822 {
 823         hdev->discovery.state = DISCOVERY_STOPPED;
 824         INIT_LIST_HEAD(&hdev->discovery.all);
 825         INIT_LIST_HEAD(&hdev->discovery.unknown);
 826         INIT_LIST_HEAD(&hdev->discovery.resolve);
 827         hdev->discovery.report_invalid_rssi = true;
 828         hdev->discovery.rssi = HCI_RSSI_INVALID;
 829 }
 830
 831 static inline void hci_discovery_filter_clear(struct hci_dev *hdev)
 832 {
 833         hdev->discovery.result_filtering = false;
 834         hdev->discovery.report_invalid_rssi = true;
 835         hdev->discovery.rssi = HCI_RSSI_INVALID;
 836         hdev->discovery.uuid_count = 0;
 837         kfree(hdev->discovery.uuids);
 838         hdev->discovery.uuids = NULL;
 839         hdev->discovery.scan_start = 0;
 840         hdev->discovery.scan_duration = 0;
 841 }
 842
 843 bool hci_discovery_active(struct hci_dev *hdev);
 844
 845 void hci_discovery_set_state(struct hci_dev *hdev, int state);
 846
 847 static inline int inquiry_cache_empty(struct hci_dev *hdev)
 848 {
 849         return list_empty(&hdev->discovery.all);
 850 }
 851
 852 static inline long inquiry_cache_age(struct hci_dev *hdev)
 853 {
 854         struct discovery_state *c = &hdev->discovery;
 855         return jiffies - c->timestamp;
 856 }
 857
 858 static inline long inquiry_entry_age(struct inquiry_entry *e)
 859 {
 860         return jiffies - e->timestamp;
 861 }
 862
 863 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
 864                                                bdaddr_t *bdaddr);
 865 struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
 866                                                        bdaddr_t *bdaddr);
 867 struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
 868                                                        bdaddr_t *bdaddr,
 869                                                        int state);
 870 void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
 871                                       struct inquiry_entry *ie);
 872 u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
 873                              bool name_known);
 874 void hci_inquiry_cache_flush(struct hci_dev *hdev);
 875
 876 /* ----- HCI Connections ----- */
 877 #ifdef TIZEN_BT
 878 #define LINK_SUPERVISION_TIMEOUT        0x1F40   /* n * 0.625 = 5 seconds */
 879 #endif /* TIZEN_BT */
 880
 881 enum {
 882         HCI_CONN_AUTH_PEND,
 883         HCI_CONN_REAUTH_PEND,
 884         HCI_CONN_ENCRYPT_PEND,
 885         HCI_CONN_RSWITCH_PEND,
 886         HCI_CONN_MODE_CHANGE_PEND,
 887         HCI_CONN_SCO_SETUP_PEND,
 888         HCI_CONN_MGMT_CONNECTED,
 889         HCI_CONN_SSP_ENABLED,
 890         HCI_CONN_SC_ENABLED,
 891         HCI_CONN_AES_CCM,
 892         HCI_CONN_POWER_SAVE,
 893         HCI_CONN_FLUSH_KEY,
 894         HCI_CONN_ENCRYPT,
 895         HCI_CONN_AUTH,
 896         HCI_CONN_SECURE,
 897         HCI_CONN_FIPS,
 898         HCI_CONN_STK_ENCRYPT,
 899         HCI_CONN_AUTH_INITIATOR,
 900         HCI_CONN_DROP,
 901         HCI_CONN_PARAM_REMOVAL_PEND,
 902         HCI_CONN_NEW_LINK_KEY,
 903         HCI_CONN_SCANNING,
 904         HCI_CONN_AUTH_FAILURE,
 905 };
 906
 907 static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
 908 {
 909         struct hci_dev *hdev = conn->hdev;
 910         return hci_dev_test_flag(hdev, HCI_SSP_ENABLED) &&
 911                test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
 912 }
 913
 914 static inline bool hci_conn_sc_enabled(struct hci_conn *conn)
 915 {
 916         struct hci_dev *hdev = conn->hdev;
 917         return hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
 918                test_bit(HCI_CONN_SC_ENABLED, &conn->flags);
 919 }
 920
 921 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
 922 {
 923         struct hci_conn_hash *h = &hdev->conn_hash;
 924         list_add_rcu(&c->list, &h->list);
 925         switch (c->type) {
 926         case ACL_LINK:
 927                 h->acl_num++;
 928                 break;
 929         case AMP_LINK:
 930                 h->amp_num++;
 931                 break;
 932         case LE_LINK:
 933                 h->le_num++;
 934                 if (c->role == HCI_ROLE_SLAVE)
 935                         h->le_num_peripheral++;
 936                 break;
 937         case SCO_LINK:
 938         case ESCO_LINK:
 939                 h->sco_num++;
 940                 break;
 941         }
 942 }
 943
 944 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
 945 {
 946         struct hci_conn_hash *h = &hdev->conn_hash;
 947
 948         list_del_rcu(&c->list);
 949         synchronize_rcu();
 950
 951         switch (c->type) {
 952         case ACL_LINK:
 953                 h->acl_num--;
 954                 break;
 955         case AMP_LINK:
 956                 h->amp_num--;
 957                 break;
 958         case LE_LINK:
 959                 h->le_num--;
 960                 if (c->role == HCI_ROLE_SLAVE)
 961                         h->le_num_peripheral--;
 962                 break;
 963         case SCO_LINK:
 964         case ESCO_LINK:
 965                 h->sco_num--;
 966                 break;
 967         }
 968 }
 969
 970 static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
 971 {
 972         struct hci_conn_hash *h = &hdev->conn_hash;
 973         switch (type) {
 974         case ACL_LINK:
 975                 return h->acl_num;
 976         case AMP_LINK:
 977                 return h->amp_num;
 978         case LE_LINK:
 979                 return h->le_num;
 980         case SCO_LINK:
 981         case ESCO_LINK:
 982                 return h->sco_num;
 983         default:
 984                 return 0;
 985         }
 986 }
 987
 988 static inline unsigned int hci_conn_count(struct hci_dev *hdev)
 989 {
 990         struct hci_conn_hash *c = &hdev->conn_hash;
 991
 992         return c->acl_num + c->amp_num + c->sco_num + c->le_num;
 993 }
 994
 995 static inline __u8 hci_conn_lookup_type(struct hci_dev *hdev, __u16 handle)
 996 {
 997         struct hci_conn_hash *h = &hdev->conn_hash;
 998         struct hci_conn *c;
 999         __u8 type = INVALID_LINK;
1000
1001         rcu_read_lock();
1002
1003         list_for_each_entry_rcu(c, &h->list, list) {
1004                 if (c->handle == handle) {
1005                         type = c->type;
1006                         break;
1007                 }
1008         }
1009
1010         rcu_read_unlock();
1011
1012         return type;
1013 }
1014
1015 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
1016                                                                 __u16 handle)
1017 {
1018         struct hci_conn_hash *h = &hdev->conn_hash;
1019         struct hci_conn  *c;
1020
1021         rcu_read_lock();
1022
1023         list_for_each_entry_rcu(c, &h->list, list) {
1024                 if (c->handle == handle) {
1025                         rcu_read_unlock();
1026                         return c;
1027                 }
1028         }
1029         rcu_read_unlock();
1030
1031         return NULL;
1032 }
1033
1034 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
1035                                                         __u8 type, bdaddr_t *ba)
1036 {
1037         struct hci_conn_hash *h = &hdev->conn_hash;
1038         struct hci_conn  *c;
1039
1040         rcu_read_lock();
1041
1042         list_for_each_entry_rcu(c, &h->list, list) {
1043                 if (c->type == type && !bacmp(&c->dst, ba)) {
1044                         rcu_read_unlock();
1045                         return c;
1046                 }
1047         }
1048
1049         rcu_read_unlock();
1050
1051         return NULL;
1052 }
1053
1054 static inline struct hci_conn *hci_conn_hash_lookup_le(struct hci_dev *hdev,
1055                                                        bdaddr_t *ba,
1056                                                        __u8 ba_type)
1057 {
1058         struct hci_conn_hash *h = &hdev->conn_hash;
1059         struct hci_conn  *c;
1060
1061         rcu_read_lock();
1062
1063         list_for_each_entry_rcu(c, &h->list, list) {
1064                 if (c->type != LE_LINK)
1065                        continue;
1066
1067                 if (ba_type == c->dst_type && !bacmp(&c->dst, ba)) {
1068                         rcu_read_unlock();
1069                         return c;
1070                 }
1071         }
1072
1073         rcu_read_unlock();
1074
1075         return NULL;
1076 }
1077
1078 static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
1079                                                         __u8 type, __u16 state)
1080 {
1081         struct hci_conn_hash *h = &hdev->conn_hash;
1082         struct hci_conn  *c;
1083
1084         rcu_read_lock();
1085
1086         list_for_each_entry_rcu(c, &h->list, list) {
1087                 if (c->type == type && c->state == state) {
1088                         rcu_read_unlock();
1089                         return c;
1090                 }
1091         }
1092
1093         rcu_read_unlock();
1094
1095         return NULL;
1096 }
1097
1098 static inline struct hci_conn *hci_lookup_le_connect(struct hci_dev *hdev)
1099 {
1100         struct hci_conn_hash *h = &hdev->conn_hash;
1101         struct hci_conn  *c;
1102
1103         rcu_read_lock();
1104
1105         list_for_each_entry_rcu(c, &h->list, list) {
1106                 if (c->type == LE_LINK && c->state == BT_CONNECT &&
1107                     !test_bit(HCI_CONN_SCANNING, &c->flags)) {
1108                         rcu_read_unlock();
1109                         return c;
1110                 }
1111         }
1112
1113         rcu_read_unlock();
1114
1115         return NULL;
1116 }
1117
1118 #ifdef TIZEN_BT
1119 static inline bool hci_conn_rssi_state_set(struct hci_dev *hdev,
1120                                         __u8 type, bdaddr_t *ba, bool value)
1121 {
1122         struct hci_conn_hash *h = &hdev->conn_hash;
1123         struct hci_conn  *c;
1124         __u8 conn_type;
1125
1126         if (type == 0x01)
1127                 conn_type = LE_LINK;
1128         else
1129                 conn_type = ACL_LINK;
1130
1131         rcu_read_lock();
1132
1133         list_for_each_entry_rcu(c, &h->list, list) {
1134                 if (c->type == conn_type && !bacmp(&c->dst, ba)) {
1135                         c->rssi_monitored = value;
1136                         rcu_read_unlock();
1137                         return true;
1138                 }
1139         }
1140
1141         rcu_read_unlock();
1142         return false;
1143 }
1144
1145 static inline void hci_conn_rssi_unset_all(struct hci_dev *hdev,
1146                                         __u8 type)
1147 {
1148         struct hci_conn_hash *h = &hdev->conn_hash;
1149         struct hci_conn  *c;
1150         __u8 conn_type;
1151
1152         if (type == 0x01)
1153                 conn_type = LE_LINK;
1154         else
1155                 conn_type = ACL_LINK;
1156
1157         rcu_read_lock();
1158         list_for_each_entry_rcu(c, &h->list, list) {
1159                 if (c->type == conn_type)
1160                         c->rssi_monitored = false;
1161         }
1162         rcu_read_unlock();
1163 }
1164
1165 static inline int hci_conn_hash_lookup_rssi_count(struct hci_dev *hdev)
1166 {
1167         struct hci_conn_hash *h = &hdev->conn_hash;
1168         struct hci_conn  *c;
1169         int count = 0;
1170
1171         rcu_read_lock();
1172         list_for_each_entry_rcu(c, &h->list, list) {
1173                 if (c->rssi_monitored == true)
1174                         ++count;
1175         }
1176         rcu_read_unlock();
1177
1178         return count;
1179 }
1180
1181 int hci_conn_change_supervision_timeout(struct hci_conn *conn, __u16 timeout);
1182 bool hci_le_discovery_active(struct hci_dev *hdev);
1183 void hci_le_discovery_set_state(struct hci_dev *hdev, int state);
1184
1185 static inline struct hci_conn *hci_conn_hash_lookup_sco(struct hci_dev *hdev)
1186 {
1187         struct hci_conn_hash *h = &hdev->conn_hash;
1188         struct hci_conn  *c;
1189
1190         rcu_read_lock();
1191         list_for_each_entry_rcu(c, &h->list, list) {
1192                 if (c->type == SCO_LINK || c->type == ESCO_LINK) {
1193                         rcu_read_unlock();
1194                         return c;
1195                 }
1196         }
1197         rcu_read_unlock();
1198
1199         return NULL;
1200 }
1201 #endif
1202
1203 int hci_disconnect(struct hci_conn *conn, __u8 reason);
1204 bool hci_setup_sync(struct hci_conn *conn, __u16 handle);
1205 void hci_sco_setup(struct hci_conn *conn, __u8 status);
1206
1207 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
1208                               u8 role);
1209 int hci_conn_del(struct hci_conn *conn);
1210 void hci_conn_hash_flush(struct hci_dev *hdev);
1211 void hci_conn_check_pending(struct hci_dev *hdev);
1212
1213 struct hci_chan *hci_chan_create(struct hci_conn *conn);
1214 void hci_chan_del(struct hci_chan *chan);
1215 void hci_chan_list_flush(struct hci_conn *conn);
1216 struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle);
1217
1218 struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
1219                                      u8 dst_type, u8 sec_level,
1220                                      u16 conn_timeout,
1221                                      enum conn_reasons conn_reason);
1222 struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
1223                                 u8 dst_type, u8 sec_level, u16 conn_timeout,
1224                                 u8 role, bdaddr_t *direct_rpa);
1225 struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
1226                                  u8 sec_level, u8 auth_type,
1227                                  enum conn_reasons conn_reason);
1228 struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
1229                                  __u16 setting);
1230 int hci_conn_check_link_mode(struct hci_conn *conn);
1231 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
1232 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
1233                       bool initiator);
1234 int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
1235
1236 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
1237
1238 void hci_le_conn_failed(struct hci_conn *conn, u8 status);
1239
1240 /*
1241  * hci_conn_get() and hci_conn_put() are used to control the life-time of an
1242  * "hci_conn" object. They do not guarantee that the hci_conn object is running,
1243  * working or anything else. They just guarantee that the object is available
1244  * and can be dereferenced. So you can use its locks, local variables and any
1245  * other constant data.
1246  * Before accessing runtime data, you _must_ lock the object and then check that
1247  * it is still running. As soon as you release the locks, the connection might
1248  * get dropped, though.
1249  *
1250  * On the other hand, hci_conn_hold() and hci_conn_drop() are used to control
1251  * how long the underlying connection is held. So every channel that runs on the
1252  * hci_conn object calls this to prevent the connection from disappearing. As
1253  * long as you hold a device, you must also guarantee that you have a valid
1254  * reference to the device via hci_conn_get() (or the initial reference from
1255  * hci_conn_add()).
1256  * The hold()/drop() ref-count is known to drop below 0 sometimes, which doesn't
1257  * break because nobody cares for that. But this means, we cannot use
1258  * _get()/_drop() in it, but require the caller to have a valid ref (FIXME).
1259  */
1260
1261 static inline struct hci_conn *hci_conn_get(struct hci_conn *conn)
1262 {
1263         get_device(&conn->dev);
1264         return conn;
1265 }
1266
1267 static inline void hci_conn_put(struct hci_conn *conn)
1268 {
1269         put_device(&conn->dev);
1270 }
1271
1272 static inline void hci_conn_hold(struct hci_conn *conn)
1273 {
1274         BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1275
1276         atomic_inc(&conn->refcnt);
1277         cancel_delayed_work(&conn->disc_work);
1278 }
1279
1280 static inline void hci_conn_drop(struct hci_conn *conn)
1281 {
1282         BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1283
1284         if (atomic_dec_and_test(&conn->refcnt)) {
1285                 unsigned long timeo;
1286
1287                 switch (conn->type) {
1288                 case ACL_LINK:
1289                 case LE_LINK:
1290                         cancel_delayed_work(&conn->idle_work);
1291                         if (conn->state == BT_CONNECTED) {
1292                                 timeo = conn->disc_timeout;
1293                                 if (!conn->out)
1294                                         timeo *= 2;
1295                         } else {
1296                                 timeo = 0;
1297                         }
1298                         break;
1299
1300                 case AMP_LINK:
1301                         timeo = conn->disc_timeout;
1302                         break;
1303
1304                 default:
1305                         timeo = 0;
1306                         break;
1307                 }
1308
1309                 cancel_delayed_work(&conn->disc_work);
1310                 queue_delayed_work(conn->hdev->workqueue,
1311                                    &conn->disc_work, timeo);
1312         }
1313 }
1314
1315 /* ----- HCI Devices ----- */
1316 static inline void hci_dev_put(struct hci_dev *d)
1317 {
1318         BT_DBG("%s orig refcnt %d", d->name,
1319                kref_read(&d->dev.kobj.kref));
1320
1321         put_device(&d->dev);
1322 }
1323
1324 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
1325 {
1326         BT_DBG("%s orig refcnt %d", d->name,
1327                kref_read(&d->dev.kobj.kref));
1328
1329         get_device(&d->dev);
1330         return d;
1331 }
1332
1333 #define hci_dev_lock(d)         mutex_lock(&d->lock)
1334 #define hci_dev_unlock(d)       mutex_unlock(&d->lock)
1335
1336 #define to_hci_dev(d) container_of(d, struct hci_dev, dev)
1337 #define to_hci_conn(c) container_of(c, struct hci_conn, dev)
1338
1339 static inline void *hci_get_drvdata(struct hci_dev *hdev)
1340 {
1341         return dev_get_drvdata(&hdev->dev);
1342 }
1343
1344 static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
1345 {
1346         dev_set_drvdata(&hdev->dev, data);
1347 }
1348
1349 static inline void *hci_get_priv(struct hci_dev *hdev)
1350 {
1351         return (char *)hdev + sizeof(*hdev);
1352 }
1353
1354 struct hci_dev *hci_dev_get(int index);
1355 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src, u8 src_type);
1356
1357 struct hci_dev *hci_alloc_dev_priv(int sizeof_priv);
1358
1359 static inline struct hci_dev *hci_alloc_dev(void)
1360 {
1361         return hci_alloc_dev_priv(0);
1362 }
1363
1364 void hci_free_dev(struct hci_dev *hdev);
1365 int hci_register_dev(struct hci_dev *hdev);
1366 void hci_unregister_dev(struct hci_dev *hdev);
1367 void hci_release_dev(struct hci_dev *hdev);
1368 int hci_suspend_dev(struct hci_dev *hdev);
1369 int hci_resume_dev(struct hci_dev *hdev);
1370 int hci_reset_dev(struct hci_dev *hdev);
1371 int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb);
1372 int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb);
1373 __printf(2, 3) void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...);
1374 __printf(2, 3) void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...);
1375
1376 static inline void hci_set_msft_opcode(struct hci_dev *hdev, __u16 opcode)
1377 {
1378 #if IS_ENABLED(CONFIG_BT_MSFTEXT)
1379         hdev->msft_opcode = opcode;
1380 #endif
1381 }
1382
1383 static inline void hci_set_aosp_capable(struct hci_dev *hdev)
1384 {
1385 #if IS_ENABLED(CONFIG_BT_AOSPEXT)
1386         hdev->aosp_capable = true;
1387 #endif
1388 }
1389
1390 int hci_dev_open(__u16 dev);
1391 int hci_dev_close(__u16 dev);
1392 int hci_dev_do_close(struct hci_dev *hdev);
1393 int hci_dev_reset(__u16 dev);
1394 int hci_dev_reset_stat(__u16 dev);
1395 int hci_dev_cmd(unsigned int cmd, void __user *arg);
1396 int hci_get_dev_list(void __user *arg);
1397 int hci_get_dev_info(void __user *arg);
1398 int hci_get_conn_list(void __user *arg);
1399 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
1400 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
1401 #ifdef TIZEN_BT
1402 u32 get_link_mode(struct hci_conn *conn);
1403 #endif
1404 int hci_inquiry(void __user *arg);
1405
1406 struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *list,
1407                                            bdaddr_t *bdaddr, u8 type);
1408 struct bdaddr_list_with_irk *hci_bdaddr_list_lookup_with_irk(
1409                                     struct list_head *list, bdaddr_t *bdaddr,
1410                                     u8 type);
1411 struct bdaddr_list_with_flags *
1412 hci_bdaddr_list_lookup_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1413                                   u8 type);
1414 int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1415 int hci_bdaddr_list_add_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1416                                  u8 type, u8 *peer_irk, u8 *local_irk);
1417 int hci_bdaddr_list_add_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1418                                    u8 type, u32 flags);
1419 int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1420 int hci_bdaddr_list_del_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1421                                  u8 type);
1422 int hci_bdaddr_list_del_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1423                                    u8 type);
1424 void hci_bdaddr_list_clear(struct list_head *list);
1425
1426 struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev,
1427                                                bdaddr_t *addr, u8 addr_type);
1428 struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev,
1429                                             bdaddr_t *addr, u8 addr_type);
1430 void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type);
1431 void hci_conn_params_clear_disabled(struct hci_dev *hdev);
1432
1433 struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list,
1434                                                   bdaddr_t *addr,
1435                                                   u8 addr_type);
1436
1437 void hci_uuids_clear(struct hci_dev *hdev);
1438
1439 void hci_link_keys_clear(struct hci_dev *hdev);
1440 struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1441 struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn,
1442                                   bdaddr_t *bdaddr, u8 *val, u8 type,
1443                                   u8 pin_len, bool *persistent);
1444 struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1445                             u8 addr_type, u8 type, u8 authenticated,
1446                             u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand);
1447 struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1448                              u8 addr_type, u8 role);
1449 int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type);
1450 void hci_smp_ltks_clear(struct hci_dev *hdev);
1451 int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1452
1453 struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa);
1454 struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
1455                                      u8 addr_type);
1456 struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1457                             u8 addr_type, u8 val[16], bdaddr_t *rpa);
1458 void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type);
1459 bool hci_is_blocked_key(struct hci_dev *hdev, u8 type, u8 val[16]);
1460 void hci_blocked_keys_clear(struct hci_dev *hdev);
1461 void hci_smp_irks_clear(struct hci_dev *hdev);
1462
1463 bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1464
1465 void hci_remote_oob_data_clear(struct hci_dev *hdev);
1466 struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
1467                                           bdaddr_t *bdaddr, u8 bdaddr_type);
1468 int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1469                             u8 bdaddr_type, u8 *hash192, u8 *rand192,
1470                             u8 *hash256, u8 *rand256);
1471 int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1472                                u8 bdaddr_type);
1473
1474 void hci_adv_instances_clear(struct hci_dev *hdev);
1475 struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance);
1476 struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance);
1477 int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags,
1478                          u16 adv_data_len, u8 *adv_data,
1479                          u16 scan_rsp_len, u8 *scan_rsp_data,
1480                          u16 timeout, u16 duration, s8 tx_power,
1481                          u32 min_interval, u32 max_interval);
1482 int hci_set_adv_instance_data(struct hci_dev *hdev, u8 instance,
1483                          u16 adv_data_len, u8 *adv_data,
1484                          u16 scan_rsp_len, u8 *scan_rsp_data);
1485 int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance);
1486 void hci_adv_instances_set_rpa_expired(struct hci_dev *hdev, bool rpa_expired);
1487
1488 void hci_adv_monitors_clear(struct hci_dev *hdev);
1489 void hci_free_adv_monitor(struct hci_dev *hdev, struct adv_monitor *monitor);
1490 int hci_add_adv_patterns_monitor_complete(struct hci_dev *hdev, u8 status);
1491 int hci_remove_adv_monitor_complete(struct hci_dev *hdev, u8 status);
1492 bool hci_add_adv_monitor(struct hci_dev *hdev, struct adv_monitor *monitor,
1493                         int *err);
1494 bool hci_remove_single_adv_monitor(struct hci_dev *hdev, u16 handle, int *err);
1495 bool hci_remove_all_adv_monitor(struct hci_dev *hdev, int *err);
1496 bool hci_is_adv_monitoring(struct hci_dev *hdev);
1497 int hci_get_adv_monitor_offload_ext(struct hci_dev *hdev);
1498
1499 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
1500
1501 void hci_init_sysfs(struct hci_dev *hdev);
1502 void hci_conn_init_sysfs(struct hci_conn *conn);
1503 void hci_conn_add_sysfs(struct hci_conn *conn);
1504 void hci_conn_del_sysfs(struct hci_conn *conn);
1505
1506 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
1507
1508 /* ----- LMP capabilities ----- */
1509 #define lmp_encrypt_capable(dev)   ((dev)->features[0][0] & LMP_ENCRYPT)
1510 #define lmp_rswitch_capable(dev)   ((dev)->features[0][0] & LMP_RSWITCH)
1511 #define lmp_hold_capable(dev)      ((dev)->features[0][0] & LMP_HOLD)
1512 #define lmp_sniff_capable(dev)     ((dev)->features[0][0] & LMP_SNIFF)
1513 #define lmp_park_capable(dev)      ((dev)->features[0][1] & LMP_PARK)
1514 #define lmp_inq_rssi_capable(dev)  ((dev)->features[0][3] & LMP_RSSI_INQ)
1515 #define lmp_esco_capable(dev)      ((dev)->features[0][3] & LMP_ESCO)
1516 #define lmp_bredr_capable(dev)     (!((dev)->features[0][4] & LMP_NO_BREDR))
1517 #define lmp_le_capable(dev)        ((dev)->features[0][4] & LMP_LE)
1518 #define lmp_sniffsubr_capable(dev) ((dev)->features[0][5] & LMP_SNIFF_SUBR)
1519 #define lmp_pause_enc_capable(dev) ((dev)->features[0][5] & LMP_PAUSE_ENC)
1520 #define lmp_esco_2m_capable(dev)   ((dev)->features[0][5] & LMP_EDR_ESCO_2M)
1521 #define lmp_ext_inq_capable(dev)   ((dev)->features[0][6] & LMP_EXT_INQ)
1522 #define lmp_le_br_capable(dev)     (!!((dev)->features[0][6] & LMP_SIMUL_LE_BR))
1523 #define lmp_ssp_capable(dev)       ((dev)->features[0][6] & LMP_SIMPLE_PAIR)
1524 #define lmp_no_flush_capable(dev)  ((dev)->features[0][6] & LMP_NO_FLUSH)
1525 #define lmp_lsto_capable(dev)      ((dev)->features[0][7] & LMP_LSTO)
1526 #define lmp_inq_tx_pwr_capable(dev) ((dev)->features[0][7] & LMP_INQ_TX_PWR)
1527 #define lmp_ext_feat_capable(dev)  ((dev)->features[0][7] & LMP_EXTFEATURES)
1528 #define lmp_transp_capable(dev)    ((dev)->features[0][2] & LMP_TRANSPARENT)
1529 #define lmp_edr_2m_capable(dev)    ((dev)->features[0][3] & LMP_EDR_2M)
1530 #define lmp_edr_3m_capable(dev)    ((dev)->features[0][3] & LMP_EDR_3M)
1531 #define lmp_edr_3slot_capable(dev) ((dev)->features[0][4] & LMP_EDR_3SLOT)
1532 #define lmp_edr_5slot_capable(dev) ((dev)->features[0][5] & LMP_EDR_5SLOT)
1533
1534 /* ----- Extended LMP capabilities ----- */
1535 #define lmp_cpb_central_capable(dev) ((dev)->features[2][0] & LMP_CPB_CENTRAL)
1536 #define lmp_cpb_peripheral_capable(dev) ((dev)->features[2][0] & LMP_CPB_PERIPHERAL)
1537 #define lmp_sync_train_capable(dev) ((dev)->features[2][0] & LMP_SYNC_TRAIN)
1538 #define lmp_sync_scan_capable(dev)  ((dev)->features[2][0] & LMP_SYNC_SCAN)
1539 #define lmp_sc_capable(dev)         ((dev)->features[2][1] & LMP_SC)
1540 #define lmp_ping_capable(dev)       ((dev)->features[2][1] & LMP_PING)
1541
1542 /* ----- Host capabilities ----- */
1543 #define lmp_host_ssp_capable(dev)  ((dev)->features[1][0] & LMP_HOST_SSP)
1544 #define lmp_host_sc_capable(dev)   ((dev)->features[1][0] & LMP_HOST_SC)
1545 #define lmp_host_le_capable(dev)   (!!((dev)->features[1][0] & LMP_HOST_LE))
1546 #define lmp_host_le_br_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE_BREDR))
1547
1548 #define hdev_is_powered(dev)   (test_bit(HCI_UP, &(dev)->flags) && \
1549                                 !hci_dev_test_flag(dev, HCI_AUTO_OFF))
1550 #define bredr_sc_enabled(dev)  (lmp_sc_capable(dev) && \
1551                                 hci_dev_test_flag(dev, HCI_SC_ENABLED))
1552 #define rpa_valid(dev)         (bacmp(&dev->rpa, BDADDR_ANY) && \
1553                                 !hci_dev_test_flag(dev, HCI_RPA_EXPIRED))
1554 #define adv_rpa_valid(adv)     (bacmp(&adv->random_addr, BDADDR_ANY) && \
1555                                 !adv->rpa_expired)
1556
1557 #define scan_1m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_1M) || \
1558                       ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_1M))
1559
1560 #define scan_2m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_2M) || \
1561                       ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_2M))
1562
1563 #define scan_coded(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_CODED) || \
1564                          ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_CODED))
1565
1566 /* Use LL Privacy based address resolution if supported */
1567 #define use_ll_privacy(dev) ((dev)->le_features[0] & HCI_LE_LL_PRIVACY)
1568
1569 /* Use ext scanning if set ext scan param and ext scan enable is supported */
1570 #define use_ext_scan(dev) (((dev)->commands[37] & 0x20) && \
1571                            ((dev)->commands[37] & 0x40))
1572 /* Use ext create connection if command is supported */
1573 #define use_ext_conn(dev) ((dev)->commands[37] & 0x80)
1574
1575 /* Extended advertising support */
1576 #define ext_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_EXT_ADV))
1577
1578 /* ----- HCI protocols ----- */
1579 #define HCI_PROTO_DEFER             0x01
1580
1581 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
1582                                         __u8 type, __u8 *flags)
1583 {
1584         switch (type) {
1585         case ACL_LINK:
1586                 return l2cap_connect_ind(hdev, bdaddr);
1587
1588         case SCO_LINK:
1589         case ESCO_LINK:
1590                 return sco_connect_ind(hdev, bdaddr, flags);
1591
1592         default:
1593                 BT_ERR("unknown link type %d", type);
1594                 return -EINVAL;
1595         }
1596 }
1597
1598 static inline int hci_proto_disconn_ind(struct hci_conn *conn)
1599 {
1600         if (conn->type != ACL_LINK && conn->type != LE_LINK)
1601                 return HCI_ERROR_REMOTE_USER_TERM;
1602
1603         return l2cap_disconn_ind(conn);
1604 }
1605
1606 /* ----- HCI callbacks ----- */
1607 struct hci_cb {
1608         struct list_head list;
1609
1610         char *name;
1611
1612         void (*connect_cfm)     (struct hci_conn *conn, __u8 status);
1613         void (*disconn_cfm)     (struct hci_conn *conn, __u8 status);
1614         void (*security_cfm)    (struct hci_conn *conn, __u8 status,
1615                                                                 __u8 encrypt);
1616         void (*key_change_cfm)  (struct hci_conn *conn, __u8 status);
1617         void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
1618 };
1619
1620 static inline void hci_connect_cfm(struct hci_conn *conn, __u8 status)
1621 {
1622         struct hci_cb *cb;
1623
1624         mutex_lock(&hci_cb_list_lock);
1625         list_for_each_entry(cb, &hci_cb_list, list) {
1626                 if (cb->connect_cfm)
1627                         cb->connect_cfm(conn, status);
1628         }
1629         mutex_unlock(&hci_cb_list_lock);
1630
1631         if (conn->connect_cfm_cb)
1632                 conn->connect_cfm_cb(conn, status);
1633 }
1634
1635 static inline void hci_disconn_cfm(struct hci_conn *conn, __u8 reason)
1636 {
1637         struct hci_cb *cb;
1638
1639         mutex_lock(&hci_cb_list_lock);
1640         list_for_each_entry(cb, &hci_cb_list, list) {
1641                 if (cb->disconn_cfm)
1642                         cb->disconn_cfm(conn, reason);
1643         }
1644         mutex_unlock(&hci_cb_list_lock);
1645
1646         if (conn->disconn_cfm_cb)
1647                 conn->disconn_cfm_cb(conn, reason);
1648 }
1649
1650 static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
1651 {
1652         struct hci_cb *cb;
1653         __u8 encrypt;
1654
1655         if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
1656                 return;
1657
1658         encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00;
1659
1660         mutex_lock(&hci_cb_list_lock);
1661         list_for_each_entry(cb, &hci_cb_list, list) {
1662                 if (cb->security_cfm)
1663                         cb->security_cfm(conn, status, encrypt);
1664         }
1665         mutex_unlock(&hci_cb_list_lock);
1666
1667         if (conn->security_cfm_cb)
1668                 conn->security_cfm_cb(conn, status);
1669 }
1670
1671 static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status)
1672 {
1673         struct hci_cb *cb;
1674         __u8 encrypt;
1675
1676         if (conn->state == BT_CONFIG) {
1677                 if (!status)
1678                         conn->state = BT_CONNECTED;
1679
1680                 hci_connect_cfm(conn, status);
1681                 hci_conn_drop(conn);
1682                 return;
1683         }
1684
1685         if (!test_bit(HCI_CONN_ENCRYPT, &conn->flags))
1686                 encrypt = 0x00;
1687         else if (test_bit(HCI_CONN_AES_CCM, &conn->flags))
1688                 encrypt = 0x02;
1689         else
1690                 encrypt = 0x01;
1691
1692         if (!status) {
1693                 if (conn->sec_level == BT_SECURITY_SDP)
1694                         conn->sec_level = BT_SECURITY_LOW;
1695
1696                 if (conn->pending_sec_level > conn->sec_level)
1697                         conn->sec_level = conn->pending_sec_level;
1698         }
1699
1700         mutex_lock(&hci_cb_list_lock);
1701         list_for_each_entry(cb, &hci_cb_list, list) {
1702                 if (cb->security_cfm)
1703                         cb->security_cfm(conn, status, encrypt);
1704         }
1705         mutex_unlock(&hci_cb_list_lock);
1706
1707         if (conn->security_cfm_cb)
1708                 conn->security_cfm_cb(conn, status);
1709 }
1710
1711 static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
1712 {
1713         struct hci_cb *cb;
1714
1715         mutex_lock(&hci_cb_list_lock);
1716         list_for_each_entry(cb, &hci_cb_list, list) {
1717                 if (cb->key_change_cfm)
1718                         cb->key_change_cfm(conn, status);
1719         }
1720         mutex_unlock(&hci_cb_list_lock);
1721 }
1722
1723 static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
1724                                                                 __u8 role)
1725 {
1726         struct hci_cb *cb;
1727
1728         mutex_lock(&hci_cb_list_lock);
1729         list_for_each_entry(cb, &hci_cb_list, list) {
1730                 if (cb->role_switch_cfm)
1731                         cb->role_switch_cfm(conn, status, role);
1732         }
1733         mutex_unlock(&hci_cb_list_lock);
1734 }
1735
1736 static inline void *eir_get_data(u8 *eir, size_t eir_len, u8 type,
1737                                  size_t *data_len)
1738 {
1739         size_t parsed = 0;
1740
1741         if (eir_len < 2)
1742                 return NULL;
1743
1744         while (parsed < eir_len - 1) {
1745                 u8 field_len = eir[0];
1746
1747                 if (field_len == 0)
1748                         break;
1749
1750                 parsed += field_len + 1;
1751
1752                 if (parsed > eir_len)
1753                         break;
1754
1755                 if (eir[1] != type) {
1756                         eir += field_len + 1;
1757                         continue;
1758                 }
1759
1760                 /* Zero length data */
1761                 if (field_len == 1)
1762                         return NULL;
1763
1764                 if (data_len)
1765                         *data_len = field_len - 1;
1766
1767                 return &eir[2];
1768         }
1769
1770         return NULL;
1771 }
1772
1773 static inline bool hci_bdaddr_is_rpa(bdaddr_t *bdaddr, u8 addr_type)
1774 {
1775         if (addr_type != ADDR_LE_DEV_RANDOM)
1776                 return false;
1777
1778         if ((bdaddr->b[5] & 0xc0) == 0x40)
1779                return true;
1780
1781         return false;
1782 }
1783
1784 static inline bool hci_is_identity_address(bdaddr_t *addr, u8 addr_type)
1785 {
1786         if (addr_type == ADDR_LE_DEV_PUBLIC)
1787                 return true;
1788
1789         /* Check for Random Static address type */
1790         if ((addr->b[5] & 0xc0) == 0xc0)
1791                 return true;
1792
1793         return false;
1794 }
1795
1796 static inline struct smp_irk *hci_get_irk(struct hci_dev *hdev,
1797                                           bdaddr_t *bdaddr, u8 addr_type)
1798 {
1799         if (!hci_bdaddr_is_rpa(bdaddr, addr_type))
1800                 return NULL;
1801
1802         return hci_find_irk_by_rpa(hdev, bdaddr);
1803 }
1804
1805 static inline int hci_check_conn_params(u16 min, u16 max, u16 latency,
1806                                         u16 to_multiplier)
1807 {
1808         u16 max_latency;
1809
1810         if (min > max || min < 6 || max > 3200)
1811                 return -EINVAL;
1812
1813         if (to_multiplier < 10 || to_multiplier > 3200)
1814                 return -EINVAL;
1815
1816         if (max >= to_multiplier * 8)
1817                 return -EINVAL;
1818
1819         max_latency = (to_multiplier * 4 / max) - 1;
1820         if (latency > 499 || latency > max_latency)
1821                 return -EINVAL;
1822
1823         return 0;
1824 }
1825
1826 int hci_register_cb(struct hci_cb *hcb);
1827 int hci_unregister_cb(struct hci_cb *hcb);
1828
1829 struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1830                                const void *param, u32 timeout);
1831 struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen,
1832                                   const void *param, u8 event, u32 timeout);
1833 int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen,
1834                    const void *param);
1835
1836 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
1837                  const void *param);
1838 void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
1839 void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
1840
1841 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
1842
1843 struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1844                              const void *param, u32 timeout);
1845
1846 u32 hci_conn_get_phy(struct hci_conn *conn);
1847
1848 /* ----- HCI Sockets ----- */
1849 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
1850 void hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
1851                          int flag, struct sock *skip_sk);
1852 void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
1853 void hci_send_monitor_ctrl_event(struct hci_dev *hdev, u16 event,
1854                                  void *data, u16 data_len, ktime_t tstamp,
1855                                  int flag, struct sock *skip_sk);
1856
1857 void hci_sock_dev_event(struct hci_dev *hdev, int event);
1858
1859 #define HCI_MGMT_VAR_LEN        BIT(0)
1860 #define HCI_MGMT_NO_HDEV        BIT(1)
1861 #define HCI_MGMT_UNTRUSTED      BIT(2)
1862 #define HCI_MGMT_UNCONFIGURED   BIT(3)
1863 #define HCI_MGMT_HDEV_OPTIONAL  BIT(4)
1864
1865 struct hci_mgmt_handler {
1866         int (*func) (struct sock *sk, struct hci_dev *hdev, void *data,
1867                      u16 data_len);
1868         size_t data_len;
1869         unsigned long flags;
1870 };
1871
1872 struct hci_mgmt_chan {
1873         struct list_head list;
1874         unsigned short channel;
1875         size_t handler_count;
1876         const struct hci_mgmt_handler *handlers;
1877 #ifdef TIZEN_BT
1878         size_t tizen_handler_count;
1879         const struct hci_mgmt_handler *tizen_handlers;
1880 #endif
1881         void (*hdev_init) (struct sock *sk, struct hci_dev *hdev);
1882 };
1883
1884 int hci_mgmt_chan_register(struct hci_mgmt_chan *c);
1885 void hci_mgmt_chan_unregister(struct hci_mgmt_chan *c);
1886
1887 /* Management interface */
1888 #define DISCOV_TYPE_BREDR               (BIT(BDADDR_BREDR))
1889 #define DISCOV_TYPE_LE                  (BIT(BDADDR_LE_PUBLIC) | \
1890                                          BIT(BDADDR_LE_RANDOM))
1891 #define DISCOV_TYPE_INTERLEAVED         (BIT(BDADDR_BREDR) | \
1892                                          BIT(BDADDR_LE_PUBLIC) | \
1893                                          BIT(BDADDR_LE_RANDOM))
1894
1895 /* These LE scan and inquiry parameters were chosen according to LE General
1896  * Discovery Procedure specification.
1897  */
1898 #define DISCOV_LE_SCAN_WIN              0x12
1899 #define DISCOV_LE_SCAN_INT              0x12
1900 #define DISCOV_LE_TIMEOUT               10240   /* msec */
1901 #define DISCOV_INTERLEAVED_TIMEOUT      5120    /* msec */
1902 #define DISCOV_INTERLEAVED_INQUIRY_LEN  0x04
1903 #define DISCOV_BREDR_INQUIRY_LEN        0x08
1904 #define DISCOV_LE_RESTART_DELAY         msecs_to_jiffies(200)   /* msec */
1905 #define DISCOV_LE_FAST_ADV_INT_MIN      0x00A0  /* 100 msec */
1906 #define DISCOV_LE_FAST_ADV_INT_MAX      0x00F0  /* 150 msec */
1907
1908 void mgmt_fill_version_info(void *ver);
1909 int mgmt_new_settings(struct hci_dev *hdev);
1910 void mgmt_index_added(struct hci_dev *hdev);
1911 void mgmt_index_removed(struct hci_dev *hdev);
1912 void mgmt_set_powered_failed(struct hci_dev *hdev, int err);
1913 void mgmt_power_on(struct hci_dev *hdev, int err);
1914 void __mgmt_power_off(struct hci_dev *hdev);
1915 void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
1916                        bool persistent);
1917 void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
1918                            u8 *name, u8 name_len);
1919 void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
1920                               u8 link_type, u8 addr_type, u8 reason,
1921                               bool mgmt_connected);
1922 void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
1923                             u8 link_type, u8 addr_type, u8 status);
1924 void mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1925                          u8 addr_type, u8 status);
1926 void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
1927 void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1928                                   u8 status);
1929 void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1930                                       u8 status);
1931 int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1932                               u8 link_type, u8 addr_type, u32 value,
1933                               u8 confirm_hint);
1934 int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1935                                      u8 link_type, u8 addr_type, u8 status);
1936 int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1937                                          u8 link_type, u8 addr_type, u8 status);
1938 int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1939                               u8 link_type, u8 addr_type);
1940 int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1941                                      u8 link_type, u8 addr_type, u8 status);
1942 int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1943                                          u8 link_type, u8 addr_type, u8 status);
1944 int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
1945                              u8 link_type, u8 addr_type, u32 passkey,
1946                              u8 entered);
1947 void mgmt_auth_failed(struct hci_conn *conn, u8 status);
1948 void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
1949 void mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1950 void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
1951                                     u8 status);
1952 void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
1953 void mgmt_start_discovery_complete(struct hci_dev *hdev, u8 status);
1954 void mgmt_stop_discovery_complete(struct hci_dev *hdev, u8 status);
1955 void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1956                        u8 addr_type, u8 *dev_class, s8 rssi, u32 flags,
1957                        u8 *eir, u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len);
1958 void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1959                       u8 addr_type, s8 rssi, u8 *name, u8 name_len);
1960 void mgmt_discovering(struct hci_dev *hdev, u8 discovering);
1961 void mgmt_suspending(struct hci_dev *hdev, u8 state);
1962 void mgmt_resuming(struct hci_dev *hdev, u8 reason, bdaddr_t *bdaddr,
1963                    u8 addr_type);
1964 bool mgmt_powering_down(struct hci_dev *hdev);
1965 void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent);
1966 void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk, bool persistent);
1967 void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
1968                    bool persistent);
1969 void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr,
1970                          u8 bdaddr_type, u8 store_hint, u16 min_interval,
1971                          u16 max_interval, u16 latency, u16 timeout);
1972 void mgmt_smp_complete(struct hci_conn *conn, bool complete);
1973 bool mgmt_get_connectable(struct hci_dev *hdev);
1974 void mgmt_set_connectable_complete(struct hci_dev *hdev, u8 status);
1975 void mgmt_set_discoverable_complete(struct hci_dev *hdev, u8 status);
1976 u8 mgmt_get_adv_discov_flags(struct hci_dev *hdev);
1977 void mgmt_advertising_added(struct sock *sk, struct hci_dev *hdev,
1978                             u8 instance);
1979 void mgmt_advertising_removed(struct sock *sk, struct hci_dev *hdev,
1980                               u8 instance);
1981 void mgmt_adv_monitor_removed(struct hci_dev *hdev, u16 handle);
1982 int mgmt_phy_configuration_changed(struct hci_dev *hdev, struct sock *skip);
1983 int mgmt_add_adv_patterns_monitor_complete(struct hci_dev *hdev, u8 status);
1984 int mgmt_remove_adv_monitor_complete(struct hci_dev *hdev, u8 status);
1985
1986 #ifdef TIZEN_BT
1987 void mgmt_rssi_enable_success(struct sock *sk, struct hci_dev *hdev,
1988                 void *data, struct hci_cc_rsp_enable_rssi *rp, int success);
1989 void mgmt_rssi_disable_success(struct sock *sk, struct hci_dev *hdev,
1990                 void *data, struct hci_cc_rsp_enable_rssi *rp, int success);
1991 int mgmt_set_rssi_threshold(struct sock *sk, struct hci_dev *hdev,
1992                 void *data, u16 len);
1993 void mgmt_rssi_alert_evt(struct hci_dev *hdev, u16 conn_handle,
1994                 s8 alert_type, s8 rssi_dbm);
1995 void mgmt_raw_rssi_response(struct hci_dev *hdev,
1996                 struct hci_cc_rp_get_raw_rssi *rp, int success);
1997 void mgmt_enable_rssi_cc(struct hci_dev *hdev, void *response, u8 status);
1998 int mgmt_device_name_update(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *name,
1999                 u8 name_len);
2000 void mgmt_le_discovering(struct hci_dev *hdev, u8 discovering);
2001 int mgmt_le_conn_updated(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type,
2002                 u8 dst_type, u16 conn_interval, u16 conn_latency,
2003                 u16 supervision_timeout);
2004 int mgmt_le_conn_update_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
2005                 u8 link_type, u8 addr_type, u8 status);
2006 void mgmt_hardware_error(struct hci_dev *hdev, u8 err_code);
2007 void mgmt_tx_timeout_error(struct hci_dev *hdev);
2008 /*  Pass adv type in the le device found */
2009 void mgmt_le_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
2010                 u8 addr_type, u8 *dev_class, s8 rssi, u32 flags, u8 *eir,
2011                 u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len, u8 adv_type);
2012 void mgmt_multi_adv_state_change_evt(struct hci_dev *hdev, u8 adv_instance,
2013                 u8 state_change_reason, u16 connection_handle);
2014 void mgmt_6lowpan_conn_changed(struct hci_dev *hdev, char if_name[16],
2015                 bdaddr_t *bdaddr, u8 addr_type, bool connected);
2016 void mgmt_le_read_maximum_data_length_complete(struct hci_dev *hdev,
2017                 u8 status);
2018 void mgmt_le_write_host_suggested_data_length_complete(struct hci_dev *hdev,
2019                 u8 status);
2020 void mgmt_le_read_host_suggested_data_length_complete(struct hci_dev *hdev,
2021                 u8 status);
2022 void mgmt_le_data_length_change_complete(struct hci_dev *hdev,
2023                 bdaddr_t *bdaddr, u16 tx_octets, u16 tx_time,
2024                 u16 rx_octets, u16 rx_time);
2025 int hci_le_set_data_length(struct hci_conn *conn, u16 tx_octets, u16 tx_time);
2026 #endif
2027
2028 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
2029                       u16 to_multiplier);
2030 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
2031                       __u8 ltk[16], __u8 key_size);
2032
2033 void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr,
2034                                u8 *bdaddr_type);
2035
2036 #define SCO_AIRMODE_MASK       0x0003
2037 #define SCO_AIRMODE_CVSD       0x0000
2038 #define SCO_AIRMODE_TRANSP     0x0003
2039
2040 #endif /* __HCI_CORE_H */