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
 701         struct sk_buff_head data_q;
 702         struct list_head chan_list;
 703
 704         struct delayed_work disc_work;
 705         struct delayed_work auto_accept_work;
 706         struct delayed_work idle_work;
 707         struct delayed_work le_conn_timeout;
 708         struct work_struct  le_scan_cleanup;
 709
 710         struct device   dev;
 711         struct dentry   *debugfs;
 712
 713         struct hci_dev  *hdev;
 714         void            *l2cap_data;
 715         void            *sco_data;
 716         struct amp_mgr  *amp_mgr;
 717
 718 #ifdef TIZEN_BT
 719         bool            rssi_monitored;
 720         __u8            sco_role;
 721         __u16           voice_setting;
 722 #endif
 723         struct hci_conn *link;
 724
 725         void (*connect_cfm_cb)  (struct hci_conn *conn, u8 status);
 726         void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
 727         void (*disconn_cfm_cb)  (struct hci_conn *conn, u8 reason);
 728 };
 729
 730 struct hci_chan {
 731         struct list_head list;
 732         __u16 handle;
 733         struct hci_conn *conn;
 734         struct sk_buff_head data_q;
 735         unsigned int    sent;
 736         __u8            state;
 737         bool            amp;
 738 };
 739
 740 struct hci_conn_params {
 741         struct list_head list;
 742         struct list_head action;
 743
 744         bdaddr_t addr;
 745         u8 addr_type;
 746
 747         u16 conn_min_interval;
 748         u16 conn_max_interval;
 749         u16 conn_latency;
 750         u16 supervision_timeout;
 751
 752         enum {
 753                 HCI_AUTO_CONN_DISABLED,
 754                 HCI_AUTO_CONN_REPORT,
 755                 HCI_AUTO_CONN_DIRECT,
 756                 HCI_AUTO_CONN_ALWAYS,
 757                 HCI_AUTO_CONN_LINK_LOSS,
 758                 HCI_AUTO_CONN_EXPLICIT,
 759         } auto_connect;
 760
 761         struct hci_conn *conn;
 762         bool explicit_connect;
 763         u32 current_flags;
 764 };
 765
 766 extern struct list_head hci_dev_list;
 767 extern struct list_head hci_cb_list;
 768 extern rwlock_t hci_dev_list_lock;
 769 extern struct mutex hci_cb_list_lock;
 770
 771 #define hci_dev_set_flag(hdev, nr)             set_bit((nr), (hdev)->dev_flags)
 772 #define hci_dev_clear_flag(hdev, nr)           clear_bit((nr), (hdev)->dev_flags)
 773 #define hci_dev_change_flag(hdev, nr)          change_bit((nr), (hdev)->dev_flags)
 774 #define hci_dev_test_flag(hdev, nr)            test_bit((nr), (hdev)->dev_flags)
 775 #define hci_dev_test_and_set_flag(hdev, nr)    test_and_set_bit((nr), (hdev)->dev_flags)
 776 #define hci_dev_test_and_clear_flag(hdev, nr)  test_and_clear_bit((nr), (hdev)->dev_flags)
 777 #define hci_dev_test_and_change_flag(hdev, nr) test_and_change_bit((nr), (hdev)->dev_flags)
 778
 779 #define hci_dev_clear_volatile_flags(hdev)                      \
 780         do {                                                    \
 781                 hci_dev_clear_flag(hdev, HCI_LE_SCAN);          \
 782                 hci_dev_clear_flag(hdev, HCI_LE_ADV);           \
 783                 hci_dev_clear_flag(hdev, HCI_LL_RPA_RESOLUTION);\
 784                 hci_dev_clear_flag(hdev, HCI_PERIODIC_INQ);     \
 785         } while (0)
 786
 787 /* ----- HCI interface to upper protocols ----- */
 788 int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
 789 int l2cap_disconn_ind(struct hci_conn *hcon);
 790 void l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
 791
 792 #if IS_ENABLED(CONFIG_BT_BREDR)
 793 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
 794 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
 795 #else
 796 static inline int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
 797                                   __u8 *flags)
 798 {
 799         return 0;
 800 }
 801
 802 static inline void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 803 {
 804 }
 805 #endif
 806
 807 /* ----- Inquiry cache ----- */
 808 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   /* 30 seconds */
 809 #define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   /* 60 seconds */
 810
 811 static inline void discovery_init(struct hci_dev *hdev)
 812 {
 813         hdev->discovery.state = DISCOVERY_STOPPED;
 814         INIT_LIST_HEAD(&hdev->discovery.all);
 815         INIT_LIST_HEAD(&hdev->discovery.unknown);
 816         INIT_LIST_HEAD(&hdev->discovery.resolve);
 817         hdev->discovery.report_invalid_rssi = true;
 818         hdev->discovery.rssi = HCI_RSSI_INVALID;
 819 }
 820
 821 static inline void hci_discovery_filter_clear(struct hci_dev *hdev)
 822 {
 823         hdev->discovery.result_filtering = false;
 824         hdev->discovery.report_invalid_rssi = true;
 825         hdev->discovery.rssi = HCI_RSSI_INVALID;
 826         hdev->discovery.uuid_count = 0;
 827         kfree(hdev->discovery.uuids);
 828         hdev->discovery.uuids = NULL;
 829         hdev->discovery.scan_start = 0;
 830         hdev->discovery.scan_duration = 0;
 831 }
 832
 833 bool hci_discovery_active(struct hci_dev *hdev);
 834
 835 void hci_discovery_set_state(struct hci_dev *hdev, int state);
 836
 837 static inline int inquiry_cache_empty(struct hci_dev *hdev)
 838 {
 839         return list_empty(&hdev->discovery.all);
 840 }
 841
 842 static inline long inquiry_cache_age(struct hci_dev *hdev)
 843 {
 844         struct discovery_state *c = &hdev->discovery;
 845         return jiffies - c->timestamp;
 846 }
 847
 848 static inline long inquiry_entry_age(struct inquiry_entry *e)
 849 {
 850         return jiffies - e->timestamp;
 851 }
 852
 853 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
 854                                                bdaddr_t *bdaddr);
 855 struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
 856                                                        bdaddr_t *bdaddr);
 857 struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
 858                                                        bdaddr_t *bdaddr,
 859                                                        int state);
 860 void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
 861                                       struct inquiry_entry *ie);
 862 u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
 863                              bool name_known);
 864 void hci_inquiry_cache_flush(struct hci_dev *hdev);
 865
 866 /* ----- HCI Connections ----- */
 867 enum {
 868         HCI_CONN_AUTH_PEND,
 869         HCI_CONN_REAUTH_PEND,
 870         HCI_CONN_ENCRYPT_PEND,
 871         HCI_CONN_RSWITCH_PEND,
 872         HCI_CONN_MODE_CHANGE_PEND,
 873         HCI_CONN_SCO_SETUP_PEND,
 874         HCI_CONN_MGMT_CONNECTED,
 875         HCI_CONN_SSP_ENABLED,
 876         HCI_CONN_SC_ENABLED,
 877         HCI_CONN_AES_CCM,
 878         HCI_CONN_POWER_SAVE,
 879         HCI_CONN_FLUSH_KEY,
 880         HCI_CONN_ENCRYPT,
 881         HCI_CONN_AUTH,
 882         HCI_CONN_SECURE,
 883         HCI_CONN_FIPS,
 884         HCI_CONN_STK_ENCRYPT,
 885         HCI_CONN_AUTH_INITIATOR,
 886         HCI_CONN_DROP,
 887         HCI_CONN_PARAM_REMOVAL_PEND,
 888         HCI_CONN_NEW_LINK_KEY,
 889         HCI_CONN_SCANNING,
 890         HCI_CONN_AUTH_FAILURE,
 891 };
 892
 893 static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
 894 {
 895         struct hci_dev *hdev = conn->hdev;
 896         return hci_dev_test_flag(hdev, HCI_SSP_ENABLED) &&
 897                test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
 898 }
 899
 900 static inline bool hci_conn_sc_enabled(struct hci_conn *conn)
 901 {
 902         struct hci_dev *hdev = conn->hdev;
 903         return hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
 904                test_bit(HCI_CONN_SC_ENABLED, &conn->flags);
 905 }
 906
 907 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
 908 {
 909         struct hci_conn_hash *h = &hdev->conn_hash;
 910         list_add_rcu(&c->list, &h->list);
 911         switch (c->type) {
 912         case ACL_LINK:
 913                 h->acl_num++;
 914                 break;
 915         case AMP_LINK:
 916                 h->amp_num++;
 917                 break;
 918         case LE_LINK:
 919                 h->le_num++;
 920                 if (c->role == HCI_ROLE_SLAVE)
 921                         h->le_num_peripheral++;
 922                 break;
 923         case SCO_LINK:
 924         case ESCO_LINK:
 925                 h->sco_num++;
 926                 break;
 927         }
 928 }
 929
 930 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
 931 {
 932         struct hci_conn_hash *h = &hdev->conn_hash;
 933
 934         list_del_rcu(&c->list);
 935         synchronize_rcu();
 936
 937         switch (c->type) {
 938         case ACL_LINK:
 939                 h->acl_num--;
 940                 break;
 941         case AMP_LINK:
 942                 h->amp_num--;
 943                 break;
 944         case LE_LINK:
 945                 h->le_num--;
 946                 if (c->role == HCI_ROLE_SLAVE)
 947                         h->le_num_peripheral--;
 948                 break;
 949         case SCO_LINK:
 950         case ESCO_LINK:
 951                 h->sco_num--;
 952                 break;
 953         }
 954 }
 955
 956 static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
 957 {
 958         struct hci_conn_hash *h = &hdev->conn_hash;
 959         switch (type) {
 960         case ACL_LINK:
 961                 return h->acl_num;
 962         case AMP_LINK:
 963                 return h->amp_num;
 964         case LE_LINK:
 965                 return h->le_num;
 966         case SCO_LINK:
 967         case ESCO_LINK:
 968                 return h->sco_num;
 969         default:
 970                 return 0;
 971         }
 972 }
 973
 974 static inline unsigned int hci_conn_count(struct hci_dev *hdev)
 975 {
 976         struct hci_conn_hash *c = &hdev->conn_hash;
 977
 978         return c->acl_num + c->amp_num + c->sco_num + c->le_num;
 979 }
 980
 981 static inline __u8 hci_conn_lookup_type(struct hci_dev *hdev, __u16 handle)
 982 {
 983         struct hci_conn_hash *h = &hdev->conn_hash;
 984         struct hci_conn *c;
 985         __u8 type = INVALID_LINK;
 986
 987         rcu_read_lock();
 988
 989         list_for_each_entry_rcu(c, &h->list, list) {
 990                 if (c->handle == handle) {
 991                         type = c->type;
 992                         break;
 993                 }
 994         }
 995
 996         rcu_read_unlock();
 997
 998         return type;
 999 }
1000
1001 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
1002                                                                 __u16 handle)
1003 {
1004         struct hci_conn_hash *h = &hdev->conn_hash;
1005         struct hci_conn  *c;
1006
1007         rcu_read_lock();
1008
1009         list_for_each_entry_rcu(c, &h->list, list) {
1010                 if (c->handle == handle) {
1011                         rcu_read_unlock();
1012                         return c;
1013                 }
1014         }
1015         rcu_read_unlock();
1016
1017         return NULL;
1018 }
1019
1020 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
1021                                                         __u8 type, bdaddr_t *ba)
1022 {
1023         struct hci_conn_hash *h = &hdev->conn_hash;
1024         struct hci_conn  *c;
1025
1026         rcu_read_lock();
1027
1028         list_for_each_entry_rcu(c, &h->list, list) {
1029                 if (c->type == type && !bacmp(&c->dst, ba)) {
1030                         rcu_read_unlock();
1031                         return c;
1032                 }
1033         }
1034
1035         rcu_read_unlock();
1036
1037         return NULL;
1038 }
1039
1040 static inline struct hci_conn *hci_conn_hash_lookup_le(struct hci_dev *hdev,
1041                                                        bdaddr_t *ba,
1042                                                        __u8 ba_type)
1043 {
1044         struct hci_conn_hash *h = &hdev->conn_hash;
1045         struct hci_conn  *c;
1046
1047         rcu_read_lock();
1048
1049         list_for_each_entry_rcu(c, &h->list, list) {
1050                 if (c->type != LE_LINK)
1051                        continue;
1052
1053                 if (ba_type == c->dst_type && !bacmp(&c->dst, ba)) {
1054                         rcu_read_unlock();
1055                         return c;
1056                 }
1057         }
1058
1059         rcu_read_unlock();
1060
1061         return NULL;
1062 }
1063
1064 static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
1065                                                         __u8 type, __u16 state)
1066 {
1067         struct hci_conn_hash *h = &hdev->conn_hash;
1068         struct hci_conn  *c;
1069
1070         rcu_read_lock();
1071
1072         list_for_each_entry_rcu(c, &h->list, list) {
1073                 if (c->type == type && c->state == state) {
1074                         rcu_read_unlock();
1075                         return c;
1076                 }
1077         }
1078
1079         rcu_read_unlock();
1080
1081         return NULL;
1082 }
1083
1084 static inline struct hci_conn *hci_lookup_le_connect(struct hci_dev *hdev)
1085 {
1086         struct hci_conn_hash *h = &hdev->conn_hash;
1087         struct hci_conn  *c;
1088
1089         rcu_read_lock();
1090
1091         list_for_each_entry_rcu(c, &h->list, list) {
1092                 if (c->type == LE_LINK && c->state == BT_CONNECT &&
1093                     !test_bit(HCI_CONN_SCANNING, &c->flags)) {
1094                         rcu_read_unlock();
1095                         return c;
1096                 }
1097         }
1098
1099         rcu_read_unlock();
1100
1101         return NULL;
1102 }
1103
1104 #ifdef TIZEN_BT
1105 static inline bool hci_conn_rssi_state_set(struct hci_dev *hdev,
1106                                         __u8 type, bdaddr_t *ba, bool value)
1107 {
1108         struct hci_conn_hash *h = &hdev->conn_hash;
1109         struct hci_conn  *c;
1110         __u8 conn_type;
1111
1112         if (type == 0x01)
1113                 conn_type = LE_LINK;
1114         else
1115                 conn_type = ACL_LINK;
1116
1117         rcu_read_lock();
1118
1119         list_for_each_entry_rcu(c, &h->list, list) {
1120                 if (c->type == conn_type && !bacmp(&c->dst, ba)) {
1121                         c->rssi_monitored = value;
1122                         rcu_read_unlock();
1123                         return true;
1124                 }
1125         }
1126
1127         rcu_read_unlock();
1128         return false;
1129 }
1130
1131 static inline void hci_conn_rssi_unset_all(struct hci_dev *hdev,
1132                                         __u8 type)
1133 {
1134         struct hci_conn_hash *h = &hdev->conn_hash;
1135         struct hci_conn  *c;
1136         __u8 conn_type;
1137
1138         if (type == 0x01)
1139                 conn_type = LE_LINK;
1140         else
1141                 conn_type = ACL_LINK;
1142
1143         rcu_read_lock();
1144         list_for_each_entry_rcu(c, &h->list, list) {
1145                 if (c->type == conn_type)
1146                         c->rssi_monitored = false;
1147         }
1148         rcu_read_unlock();
1149 }
1150
1151 static inline int hci_conn_hash_lookup_rssi_count(struct hci_dev *hdev)
1152 {
1153         struct hci_conn_hash *h = &hdev->conn_hash;
1154         struct hci_conn  *c;
1155         int count = 0;
1156
1157         rcu_read_lock();
1158         list_for_each_entry_rcu(c, &h->list, list) {
1159                 if (c->rssi_monitored == true)
1160                         ++count;
1161         }
1162         rcu_read_unlock();
1163
1164         return count;
1165 }
1166
1167 bool hci_le_discovery_active(struct hci_dev *hdev);
1168 void hci_le_discovery_set_state(struct hci_dev *hdev, int state);
1169
1170 static inline struct hci_conn *hci_conn_hash_lookup_sco(struct hci_dev *hdev)
1171 {
1172         struct hci_conn_hash *h = &hdev->conn_hash;
1173         struct hci_conn  *c;
1174
1175         rcu_read_lock();
1176         list_for_each_entry_rcu(c, &h->list, list) {
1177                 if (c->type == SCO_LINK || c->type == ESCO_LINK) {
1178                         rcu_read_unlock();
1179                         return c;
1180                 }
1181         }
1182         rcu_read_unlock();
1183
1184         return NULL;
1185 }
1186 #endif
1187
1188 int hci_disconnect(struct hci_conn *conn, __u8 reason);
1189 bool hci_setup_sync(struct hci_conn *conn, __u16 handle);
1190 void hci_sco_setup(struct hci_conn *conn, __u8 status);
1191
1192 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
1193                               u8 role);
1194 int hci_conn_del(struct hci_conn *conn);
1195 void hci_conn_hash_flush(struct hci_dev *hdev);
1196 void hci_conn_check_pending(struct hci_dev *hdev);
1197
1198 struct hci_chan *hci_chan_create(struct hci_conn *conn);
1199 void hci_chan_del(struct hci_chan *chan);
1200 void hci_chan_list_flush(struct hci_conn *conn);
1201 struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle);
1202
1203 struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
1204                                      u8 dst_type, u8 sec_level,
1205                                      u16 conn_timeout,
1206                                      enum conn_reasons conn_reason);
1207 struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
1208                                 u8 dst_type, u8 sec_level, u16 conn_timeout,
1209                                 u8 role, bdaddr_t *direct_rpa);
1210 struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
1211                                  u8 sec_level, u8 auth_type,
1212                                  enum conn_reasons conn_reason);
1213 struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
1214                                  __u16 setting);
1215 int hci_conn_check_link_mode(struct hci_conn *conn);
1216 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
1217 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
1218                       bool initiator);
1219 int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
1220
1221 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
1222
1223 void hci_le_conn_failed(struct hci_conn *conn, u8 status);
1224
1225 /*
1226  * hci_conn_get() and hci_conn_put() are used to control the life-time of an
1227  * "hci_conn" object. They do not guarantee that the hci_conn object is running,
1228  * working or anything else. They just guarantee that the object is available
1229  * and can be dereferenced. So you can use its locks, local variables and any
1230  * other constant data.
1231  * Before accessing runtime data, you _must_ lock the object and then check that
1232  * it is still running. As soon as you release the locks, the connection might
1233  * get dropped, though.
1234  *
1235  * On the other hand, hci_conn_hold() and hci_conn_drop() are used to control
1236  * how long the underlying connection is held. So every channel that runs on the
1237  * hci_conn object calls this to prevent the connection from disappearing. As
1238  * long as you hold a device, you must also guarantee that you have a valid
1239  * reference to the device via hci_conn_get() (or the initial reference from
1240  * hci_conn_add()).
1241  * The hold()/drop() ref-count is known to drop below 0 sometimes, which doesn't
1242  * break because nobody cares for that. But this means, we cannot use
1243  * _get()/_drop() in it, but require the caller to have a valid ref (FIXME).
1244  */
1245
1246 static inline struct hci_conn *hci_conn_get(struct hci_conn *conn)
1247 {
1248         get_device(&conn->dev);
1249         return conn;
1250 }
1251
1252 static inline void hci_conn_put(struct hci_conn *conn)
1253 {
1254         put_device(&conn->dev);
1255 }
1256
1257 static inline void hci_conn_hold(struct hci_conn *conn)
1258 {
1259         BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1260
1261         atomic_inc(&conn->refcnt);
1262         cancel_delayed_work(&conn->disc_work);
1263 }
1264
1265 static inline void hci_conn_drop(struct hci_conn *conn)
1266 {
1267         BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1268
1269         if (atomic_dec_and_test(&conn->refcnt)) {
1270                 unsigned long timeo;
1271
1272                 switch (conn->type) {
1273                 case ACL_LINK:
1274                 case LE_LINK:
1275                         cancel_delayed_work(&conn->idle_work);
1276                         if (conn->state == BT_CONNECTED) {
1277                                 timeo = conn->disc_timeout;
1278                                 if (!conn->out)
1279                                         timeo *= 2;
1280                         } else {
1281                                 timeo = 0;
1282                         }
1283                         break;
1284
1285                 case AMP_LINK:
1286                         timeo = conn->disc_timeout;
1287                         break;
1288
1289                 default:
1290                         timeo = 0;
1291                         break;
1292                 }
1293
1294                 cancel_delayed_work(&conn->disc_work);
1295                 queue_delayed_work(conn->hdev->workqueue,
1296                                    &conn->disc_work, timeo);
1297         }
1298 }
1299
1300 /* ----- HCI Devices ----- */
1301 static inline void hci_dev_put(struct hci_dev *d)
1302 {
1303         BT_DBG("%s orig refcnt %d", d->name,
1304                kref_read(&d->dev.kobj.kref));
1305
1306         put_device(&d->dev);
1307 }
1308
1309 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
1310 {
1311         BT_DBG("%s orig refcnt %d", d->name,
1312                kref_read(&d->dev.kobj.kref));
1313
1314         get_device(&d->dev);
1315         return d;
1316 }
1317
1318 #define hci_dev_lock(d)         mutex_lock(&d->lock)
1319 #define hci_dev_unlock(d)       mutex_unlock(&d->lock)
1320
1321 #define to_hci_dev(d) container_of(d, struct hci_dev, dev)
1322 #define to_hci_conn(c) container_of(c, struct hci_conn, dev)
1323
1324 static inline void *hci_get_drvdata(struct hci_dev *hdev)
1325 {
1326         return dev_get_drvdata(&hdev->dev);
1327 }
1328
1329 static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
1330 {
1331         dev_set_drvdata(&hdev->dev, data);
1332 }
1333
1334 static inline void *hci_get_priv(struct hci_dev *hdev)
1335 {
1336         return (char *)hdev + sizeof(*hdev);
1337 }
1338
1339 struct hci_dev *hci_dev_get(int index);
1340 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src, u8 src_type);
1341
1342 struct hci_dev *hci_alloc_dev_priv(int sizeof_priv);
1343
1344 static inline struct hci_dev *hci_alloc_dev(void)
1345 {
1346         return hci_alloc_dev_priv(0);
1347 }
1348
1349 void hci_free_dev(struct hci_dev *hdev);
1350 int hci_register_dev(struct hci_dev *hdev);
1351 void hci_unregister_dev(struct hci_dev *hdev);
1352 void hci_release_dev(struct hci_dev *hdev);
1353 int hci_suspend_dev(struct hci_dev *hdev);
1354 int hci_resume_dev(struct hci_dev *hdev);
1355 int hci_reset_dev(struct hci_dev *hdev);
1356 int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb);
1357 int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb);
1358 __printf(2, 3) void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...);
1359 __printf(2, 3) void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...);
1360
1361 static inline void hci_set_msft_opcode(struct hci_dev *hdev, __u16 opcode)
1362 {
1363 #if IS_ENABLED(CONFIG_BT_MSFTEXT)
1364         hdev->msft_opcode = opcode;
1365 #endif
1366 }
1367
1368 static inline void hci_set_aosp_capable(struct hci_dev *hdev)
1369 {
1370 #if IS_ENABLED(CONFIG_BT_AOSPEXT)
1371         hdev->aosp_capable = true;
1372 #endif
1373 }
1374
1375 int hci_dev_open(__u16 dev);
1376 int hci_dev_close(__u16 dev);
1377 int hci_dev_do_close(struct hci_dev *hdev);
1378 int hci_dev_reset(__u16 dev);
1379 int hci_dev_reset_stat(__u16 dev);
1380 int hci_dev_cmd(unsigned int cmd, void __user *arg);
1381 int hci_get_dev_list(void __user *arg);
1382 int hci_get_dev_info(void __user *arg);
1383 int hci_get_conn_list(void __user *arg);
1384 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
1385 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
1386 int hci_inquiry(void __user *arg);
1387
1388 struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *list,
1389                                            bdaddr_t *bdaddr, u8 type);
1390 struct bdaddr_list_with_irk *hci_bdaddr_list_lookup_with_irk(
1391                                     struct list_head *list, bdaddr_t *bdaddr,
1392                                     u8 type);
1393 struct bdaddr_list_with_flags *
1394 hci_bdaddr_list_lookup_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1395                                   u8 type);
1396 int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1397 int hci_bdaddr_list_add_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1398                                  u8 type, u8 *peer_irk, u8 *local_irk);
1399 int hci_bdaddr_list_add_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1400                                    u8 type, u32 flags);
1401 int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1402 int hci_bdaddr_list_del_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1403                                  u8 type);
1404 int hci_bdaddr_list_del_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1405                                    u8 type);
1406 void hci_bdaddr_list_clear(struct list_head *list);
1407
1408 struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev,
1409                                                bdaddr_t *addr, u8 addr_type);
1410 struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev,
1411                                             bdaddr_t *addr, u8 addr_type);
1412 void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type);
1413 void hci_conn_params_clear_disabled(struct hci_dev *hdev);
1414
1415 struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list,
1416                                                   bdaddr_t *addr,
1417                                                   u8 addr_type);
1418
1419 void hci_uuids_clear(struct hci_dev *hdev);
1420
1421 void hci_link_keys_clear(struct hci_dev *hdev);
1422 struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1423 struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn,
1424                                   bdaddr_t *bdaddr, u8 *val, u8 type,
1425                                   u8 pin_len, bool *persistent);
1426 struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1427                             u8 addr_type, u8 type, u8 authenticated,
1428                             u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand);
1429 struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1430                              u8 addr_type, u8 role);
1431 int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type);
1432 void hci_smp_ltks_clear(struct hci_dev *hdev);
1433 int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1434
1435 struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa);
1436 struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
1437                                      u8 addr_type);
1438 struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1439                             u8 addr_type, u8 val[16], bdaddr_t *rpa);
1440 void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type);
1441 bool hci_is_blocked_key(struct hci_dev *hdev, u8 type, u8 val[16]);
1442 void hci_blocked_keys_clear(struct hci_dev *hdev);
1443 void hci_smp_irks_clear(struct hci_dev *hdev);
1444
1445 bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1446
1447 void hci_remote_oob_data_clear(struct hci_dev *hdev);
1448 struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
1449                                           bdaddr_t *bdaddr, u8 bdaddr_type);
1450 int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1451                             u8 bdaddr_type, u8 *hash192, u8 *rand192,
1452                             u8 *hash256, u8 *rand256);
1453 int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1454                                u8 bdaddr_type);
1455
1456 void hci_adv_instances_clear(struct hci_dev *hdev);
1457 struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance);
1458 struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance);
1459 int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags,
1460                          u16 adv_data_len, u8 *adv_data,
1461                          u16 scan_rsp_len, u8 *scan_rsp_data,
1462                          u16 timeout, u16 duration, s8 tx_power,
1463                          u32 min_interval, u32 max_interval);
1464 int hci_set_adv_instance_data(struct hci_dev *hdev, u8 instance,
1465                          u16 adv_data_len, u8 *adv_data,
1466                          u16 scan_rsp_len, u8 *scan_rsp_data);
1467 int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance);
1468 void hci_adv_instances_set_rpa_expired(struct hci_dev *hdev, bool rpa_expired);
1469
1470 void hci_adv_monitors_clear(struct hci_dev *hdev);
1471 void hci_free_adv_monitor(struct hci_dev *hdev, struct adv_monitor *monitor);
1472 int hci_add_adv_patterns_monitor_complete(struct hci_dev *hdev, u8 status);
1473 int hci_remove_adv_monitor_complete(struct hci_dev *hdev, u8 status);
1474 bool hci_add_adv_monitor(struct hci_dev *hdev, struct adv_monitor *monitor,
1475                         int *err);
1476 bool hci_remove_single_adv_monitor(struct hci_dev *hdev, u16 handle, int *err);
1477 bool hci_remove_all_adv_monitor(struct hci_dev *hdev, int *err);
1478 bool hci_is_adv_monitoring(struct hci_dev *hdev);
1479 int hci_get_adv_monitor_offload_ext(struct hci_dev *hdev);
1480
1481 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
1482
1483 void hci_init_sysfs(struct hci_dev *hdev);
1484 void hci_conn_init_sysfs(struct hci_conn *conn);
1485 void hci_conn_add_sysfs(struct hci_conn *conn);
1486 void hci_conn_del_sysfs(struct hci_conn *conn);
1487
1488 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
1489
1490 /* ----- LMP capabilities ----- */
1491 #define lmp_encrypt_capable(dev)   ((dev)->features[0][0] & LMP_ENCRYPT)
1492 #define lmp_rswitch_capable(dev)   ((dev)->features[0][0] & LMP_RSWITCH)
1493 #define lmp_hold_capable(dev)      ((dev)->features[0][0] & LMP_HOLD)
1494 #define lmp_sniff_capable(dev)     ((dev)->features[0][0] & LMP_SNIFF)
1495 #define lmp_park_capable(dev)      ((dev)->features[0][1] & LMP_PARK)
1496 #define lmp_inq_rssi_capable(dev)  ((dev)->features[0][3] & LMP_RSSI_INQ)
1497 #define lmp_esco_capable(dev)      ((dev)->features[0][3] & LMP_ESCO)
1498 #define lmp_bredr_capable(dev)     (!((dev)->features[0][4] & LMP_NO_BREDR))
1499 #define lmp_le_capable(dev)        ((dev)->features[0][4] & LMP_LE)
1500 #define lmp_sniffsubr_capable(dev) ((dev)->features[0][5] & LMP_SNIFF_SUBR)
1501 #define lmp_pause_enc_capable(dev) ((dev)->features[0][5] & LMP_PAUSE_ENC)
1502 #define lmp_esco_2m_capable(dev)   ((dev)->features[0][5] & LMP_EDR_ESCO_2M)
1503 #define lmp_ext_inq_capable(dev)   ((dev)->features[0][6] & LMP_EXT_INQ)
1504 #define lmp_le_br_capable(dev)     (!!((dev)->features[0][6] & LMP_SIMUL_LE_BR))
1505 #define lmp_ssp_capable(dev)       ((dev)->features[0][6] & LMP_SIMPLE_PAIR)
1506 #define lmp_no_flush_capable(dev)  ((dev)->features[0][6] & LMP_NO_FLUSH)
1507 #define lmp_lsto_capable(dev)      ((dev)->features[0][7] & LMP_LSTO)
1508 #define lmp_inq_tx_pwr_capable(dev) ((dev)->features[0][7] & LMP_INQ_TX_PWR)
1509 #define lmp_ext_feat_capable(dev)  ((dev)->features[0][7] & LMP_EXTFEATURES)
1510 #define lmp_transp_capable(dev)    ((dev)->features[0][2] & LMP_TRANSPARENT)
1511 #define lmp_edr_2m_capable(dev)    ((dev)->features[0][3] & LMP_EDR_2M)
1512 #define lmp_edr_3m_capable(dev)    ((dev)->features[0][3] & LMP_EDR_3M)
1513 #define lmp_edr_3slot_capable(dev) ((dev)->features[0][4] & LMP_EDR_3SLOT)
1514 #define lmp_edr_5slot_capable(dev) ((dev)->features[0][5] & LMP_EDR_5SLOT)
1515
1516 /* ----- Extended LMP capabilities ----- */
1517 #define lmp_cpb_central_capable(dev) ((dev)->features[2][0] & LMP_CPB_CENTRAL)
1518 #define lmp_cpb_peripheral_capable(dev) ((dev)->features[2][0] & LMP_CPB_PERIPHERAL)
1519 #define lmp_sync_train_capable(dev) ((dev)->features[2][0] & LMP_SYNC_TRAIN)
1520 #define lmp_sync_scan_capable(dev)  ((dev)->features[2][0] & LMP_SYNC_SCAN)
1521 #define lmp_sc_capable(dev)         ((dev)->features[2][1] & LMP_SC)
1522 #define lmp_ping_capable(dev)       ((dev)->features[2][1] & LMP_PING)
1523
1524 /* ----- Host capabilities ----- */
1525 #define lmp_host_ssp_capable(dev)  ((dev)->features[1][0] & LMP_HOST_SSP)
1526 #define lmp_host_sc_capable(dev)   ((dev)->features[1][0] & LMP_HOST_SC)
1527 #define lmp_host_le_capable(dev)   (!!((dev)->features[1][0] & LMP_HOST_LE))
1528 #define lmp_host_le_br_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE_BREDR))
1529
1530 #define hdev_is_powered(dev)   (test_bit(HCI_UP, &(dev)->flags) && \
1531                                 !hci_dev_test_flag(dev, HCI_AUTO_OFF))
1532 #define bredr_sc_enabled(dev)  (lmp_sc_capable(dev) && \
1533                                 hci_dev_test_flag(dev, HCI_SC_ENABLED))
1534 #define rpa_valid(dev)         (bacmp(&dev->rpa, BDADDR_ANY) && \
1535                                 !hci_dev_test_flag(dev, HCI_RPA_EXPIRED))
1536 #define adv_rpa_valid(adv)     (bacmp(&adv->random_addr, BDADDR_ANY) && \
1537                                 !adv->rpa_expired)
1538
1539 #define scan_1m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_1M) || \
1540                       ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_1M))
1541
1542 #define scan_2m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_2M) || \
1543                       ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_2M))
1544
1545 #define scan_coded(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_CODED) || \
1546                          ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_CODED))
1547
1548 /* Use LL Privacy based address resolution if supported */
1549 #define use_ll_privacy(dev) ((dev)->le_features[0] & HCI_LE_LL_PRIVACY)
1550
1551 /* Use ext scanning if set ext scan param and ext scan enable is supported */
1552 #define use_ext_scan(dev) (((dev)->commands[37] & 0x20) && \
1553                            ((dev)->commands[37] & 0x40))
1554 /* Use ext create connection if command is supported */
1555 #define use_ext_conn(dev) ((dev)->commands[37] & 0x80)
1556
1557 /* Extended advertising support */
1558 #define ext_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_EXT_ADV))
1559
1560 /* ----- HCI protocols ----- */
1561 #define HCI_PROTO_DEFER             0x01
1562
1563 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
1564                                         __u8 type, __u8 *flags)
1565 {
1566         switch (type) {
1567         case ACL_LINK:
1568                 return l2cap_connect_ind(hdev, bdaddr);
1569
1570         case SCO_LINK:
1571         case ESCO_LINK:
1572                 return sco_connect_ind(hdev, bdaddr, flags);
1573
1574         default:
1575                 BT_ERR("unknown link type %d", type);
1576                 return -EINVAL;
1577         }
1578 }
1579
1580 static inline int hci_proto_disconn_ind(struct hci_conn *conn)
1581 {
1582         if (conn->type != ACL_LINK && conn->type != LE_LINK)
1583                 return HCI_ERROR_REMOTE_USER_TERM;
1584
1585         return l2cap_disconn_ind(conn);
1586 }
1587
1588 /* ----- HCI callbacks ----- */
1589 struct hci_cb {
1590         struct list_head list;
1591
1592         char *name;
1593
1594         void (*connect_cfm)     (struct hci_conn *conn, __u8 status);
1595         void (*disconn_cfm)     (struct hci_conn *conn, __u8 status);
1596         void (*security_cfm)    (struct hci_conn *conn, __u8 status,
1597                                                                 __u8 encrypt);
1598         void (*key_change_cfm)  (struct hci_conn *conn, __u8 status);
1599         void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
1600 };
1601
1602 static inline void hci_connect_cfm(struct hci_conn *conn, __u8 status)
1603 {
1604         struct hci_cb *cb;
1605
1606         mutex_lock(&hci_cb_list_lock);
1607         list_for_each_entry(cb, &hci_cb_list, list) {
1608                 if (cb->connect_cfm)
1609                         cb->connect_cfm(conn, status);
1610         }
1611         mutex_unlock(&hci_cb_list_lock);
1612
1613         if (conn->connect_cfm_cb)
1614                 conn->connect_cfm_cb(conn, status);
1615 }
1616
1617 static inline void hci_disconn_cfm(struct hci_conn *conn, __u8 reason)
1618 {
1619         struct hci_cb *cb;
1620
1621         mutex_lock(&hci_cb_list_lock);
1622         list_for_each_entry(cb, &hci_cb_list, list) {
1623                 if (cb->disconn_cfm)
1624                         cb->disconn_cfm(conn, reason);
1625         }
1626         mutex_unlock(&hci_cb_list_lock);
1627
1628         if (conn->disconn_cfm_cb)
1629                 conn->disconn_cfm_cb(conn, reason);
1630 }
1631
1632 static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
1633 {
1634         struct hci_cb *cb;
1635         __u8 encrypt;
1636
1637         if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
1638                 return;
1639
1640         encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00;
1641
1642         mutex_lock(&hci_cb_list_lock);
1643         list_for_each_entry(cb, &hci_cb_list, list) {
1644                 if (cb->security_cfm)
1645                         cb->security_cfm(conn, status, encrypt);
1646         }
1647         mutex_unlock(&hci_cb_list_lock);
1648
1649         if (conn->security_cfm_cb)
1650                 conn->security_cfm_cb(conn, status);
1651 }
1652
1653 static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status)
1654 {
1655         struct hci_cb *cb;
1656         __u8 encrypt;
1657
1658         if (conn->state == BT_CONFIG) {
1659                 if (!status)
1660                         conn->state = BT_CONNECTED;
1661
1662                 hci_connect_cfm(conn, status);
1663                 hci_conn_drop(conn);
1664                 return;
1665         }
1666
1667         if (!test_bit(HCI_CONN_ENCRYPT, &conn->flags))
1668                 encrypt = 0x00;
1669         else if (test_bit(HCI_CONN_AES_CCM, &conn->flags))
1670                 encrypt = 0x02;
1671         else
1672                 encrypt = 0x01;
1673
1674         if (!status) {
1675                 if (conn->sec_level == BT_SECURITY_SDP)
1676                         conn->sec_level = BT_SECURITY_LOW;
1677
1678                 if (conn->pending_sec_level > conn->sec_level)
1679                         conn->sec_level = conn->pending_sec_level;
1680         }
1681
1682         mutex_lock(&hci_cb_list_lock);
1683         list_for_each_entry(cb, &hci_cb_list, list) {
1684                 if (cb->security_cfm)
1685                         cb->security_cfm(conn, status, encrypt);
1686         }
1687         mutex_unlock(&hci_cb_list_lock);
1688
1689         if (conn->security_cfm_cb)
1690                 conn->security_cfm_cb(conn, status);
1691 }
1692
1693 static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
1694 {
1695         struct hci_cb *cb;
1696
1697         mutex_lock(&hci_cb_list_lock);
1698         list_for_each_entry(cb, &hci_cb_list, list) {
1699                 if (cb->key_change_cfm)
1700                         cb->key_change_cfm(conn, status);
1701         }
1702         mutex_unlock(&hci_cb_list_lock);
1703 }
1704
1705 static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
1706                                                                 __u8 role)
1707 {
1708         struct hci_cb *cb;
1709
1710         mutex_lock(&hci_cb_list_lock);
1711         list_for_each_entry(cb, &hci_cb_list, list) {
1712                 if (cb->role_switch_cfm)
1713                         cb->role_switch_cfm(conn, status, role);
1714         }
1715         mutex_unlock(&hci_cb_list_lock);
1716 }
1717
1718 static inline void *eir_get_data(u8 *eir, size_t eir_len, u8 type,
1719                                  size_t *data_len)
1720 {
1721         size_t parsed = 0;
1722
1723         if (eir_len < 2)
1724                 return NULL;
1725
1726         while (parsed < eir_len - 1) {
1727                 u8 field_len = eir[0];
1728
1729                 if (field_len == 0)
1730                         break;
1731
1732                 parsed += field_len + 1;
1733
1734                 if (parsed > eir_len)
1735                         break;
1736
1737                 if (eir[1] != type) {
1738                         eir += field_len + 1;
1739                         continue;
1740                 }
1741
1742                 /* Zero length data */
1743                 if (field_len == 1)
1744                         return NULL;
1745
1746                 if (data_len)
1747                         *data_len = field_len - 1;
1748
1749                 return &eir[2];
1750         }
1751
1752         return NULL;
1753 }
1754
1755 static inline bool hci_bdaddr_is_rpa(bdaddr_t *bdaddr, u8 addr_type)
1756 {
1757         if (addr_type != ADDR_LE_DEV_RANDOM)
1758                 return false;
1759
1760         if ((bdaddr->b[5] & 0xc0) == 0x40)
1761                return true;
1762
1763         return false;
1764 }
1765
1766 static inline bool hci_is_identity_address(bdaddr_t *addr, u8 addr_type)
1767 {
1768         if (addr_type == ADDR_LE_DEV_PUBLIC)
1769                 return true;
1770
1771         /* Check for Random Static address type */
1772         if ((addr->b[5] & 0xc0) == 0xc0)
1773                 return true;
1774
1775         return false;
1776 }
1777
1778 static inline struct smp_irk *hci_get_irk(struct hci_dev *hdev,
1779                                           bdaddr_t *bdaddr, u8 addr_type)
1780 {
1781         if (!hci_bdaddr_is_rpa(bdaddr, addr_type))
1782                 return NULL;
1783
1784         return hci_find_irk_by_rpa(hdev, bdaddr);
1785 }
1786
1787 static inline int hci_check_conn_params(u16 min, u16 max, u16 latency,
1788                                         u16 to_multiplier)
1789 {
1790         u16 max_latency;
1791
1792         if (min > max || min < 6 || max > 3200)
1793                 return -EINVAL;
1794
1795         if (to_multiplier < 10 || to_multiplier > 3200)
1796                 return -EINVAL;
1797
1798         if (max >= to_multiplier * 8)
1799                 return -EINVAL;
1800
1801         max_latency = (to_multiplier * 4 / max) - 1;
1802         if (latency > 499 || latency > max_latency)
1803                 return -EINVAL;
1804
1805         return 0;
1806 }
1807
1808 int hci_register_cb(struct hci_cb *hcb);
1809 int hci_unregister_cb(struct hci_cb *hcb);
1810
1811 struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1812                                const void *param, u32 timeout);
1813 struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen,
1814                                   const void *param, u8 event, u32 timeout);
1815 int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen,
1816                    const void *param);
1817
1818 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
1819                  const void *param);
1820 void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
1821 void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
1822
1823 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
1824
1825 struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1826                              const void *param, u32 timeout);
1827
1828 u32 hci_conn_get_phy(struct hci_conn *conn);
1829
1830 /* ----- HCI Sockets ----- */
1831 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
1832 void hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
1833                          int flag, struct sock *skip_sk);
1834 void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
1835 void hci_send_monitor_ctrl_event(struct hci_dev *hdev, u16 event,
1836                                  void *data, u16 data_len, ktime_t tstamp,
1837                                  int flag, struct sock *skip_sk);
1838
1839 void hci_sock_dev_event(struct hci_dev *hdev, int event);
1840
1841 #define HCI_MGMT_VAR_LEN        BIT(0)
1842 #define HCI_MGMT_NO_HDEV        BIT(1)
1843 #define HCI_MGMT_UNTRUSTED      BIT(2)
1844 #define HCI_MGMT_UNCONFIGURED   BIT(3)
1845 #define HCI_MGMT_HDEV_OPTIONAL  BIT(4)
1846
1847 struct hci_mgmt_handler {
1848         int (*func) (struct sock *sk, struct hci_dev *hdev, void *data,
1849                      u16 data_len);
1850         size_t data_len;
1851         unsigned long flags;
1852 };
1853
1854 struct hci_mgmt_chan {
1855         struct list_head list;
1856         unsigned short channel;
1857         size_t handler_count;
1858         const struct hci_mgmt_handler *handlers;
1859 #ifdef TIZEN_BT
1860         size_t tizen_handler_count;
1861         const struct hci_mgmt_handler *tizen_handlers;
1862 #endif
1863         void (*hdev_init) (struct sock *sk, struct hci_dev *hdev);
1864 };
1865
1866 int hci_mgmt_chan_register(struct hci_mgmt_chan *c);
1867 void hci_mgmt_chan_unregister(struct hci_mgmt_chan *c);
1868
1869 /* Management interface */
1870 #define DISCOV_TYPE_BREDR               (BIT(BDADDR_BREDR))
1871 #define DISCOV_TYPE_LE                  (BIT(BDADDR_LE_PUBLIC) | \
1872                                          BIT(BDADDR_LE_RANDOM))
1873 #define DISCOV_TYPE_INTERLEAVED         (BIT(BDADDR_BREDR) | \
1874                                          BIT(BDADDR_LE_PUBLIC) | \
1875                                          BIT(BDADDR_LE_RANDOM))
1876
1877 /* These LE scan and inquiry parameters were chosen according to LE General
1878  * Discovery Procedure specification.
1879  */
1880 #define DISCOV_LE_SCAN_WIN              0x12
1881 #define DISCOV_LE_SCAN_INT              0x12
1882 #define DISCOV_LE_TIMEOUT               10240   /* msec */
1883 #define DISCOV_INTERLEAVED_TIMEOUT      5120    /* msec */
1884 #define DISCOV_INTERLEAVED_INQUIRY_LEN  0x04
1885 #define DISCOV_BREDR_INQUIRY_LEN        0x08
1886 #define DISCOV_LE_RESTART_DELAY         msecs_to_jiffies(200)   /* msec */
1887 #define DISCOV_LE_FAST_ADV_INT_MIN      0x00A0  /* 100 msec */
1888 #define DISCOV_LE_FAST_ADV_INT_MAX      0x00F0  /* 150 msec */
1889
1890 void mgmt_fill_version_info(void *ver);
1891 int mgmt_new_settings(struct hci_dev *hdev);
1892 void mgmt_index_added(struct hci_dev *hdev);
1893 void mgmt_index_removed(struct hci_dev *hdev);
1894 void mgmt_set_powered_failed(struct hci_dev *hdev, int err);
1895 void mgmt_power_on(struct hci_dev *hdev, int err);
1896 void __mgmt_power_off(struct hci_dev *hdev);
1897 void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
1898                        bool persistent);
1899 void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
1900                            u8 *name, u8 name_len);
1901 void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
1902                               u8 link_type, u8 addr_type, u8 reason,
1903                               bool mgmt_connected);
1904 void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
1905                             u8 link_type, u8 addr_type, u8 status);
1906 void mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1907                          u8 addr_type, u8 status);
1908 void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
1909 void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1910                                   u8 status);
1911 void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1912                                       u8 status);
1913 int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1914                               u8 link_type, u8 addr_type, u32 value,
1915                               u8 confirm_hint);
1916 int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1917                                      u8 link_type, u8 addr_type, u8 status);
1918 int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1919                                          u8 link_type, u8 addr_type, u8 status);
1920 int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1921                               u8 link_type, u8 addr_type);
1922 int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1923                                      u8 link_type, u8 addr_type, u8 status);
1924 int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1925                                          u8 link_type, u8 addr_type, u8 status);
1926 int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
1927                              u8 link_type, u8 addr_type, u32 passkey,
1928                              u8 entered);
1929 void mgmt_auth_failed(struct hci_conn *conn, u8 status);
1930 void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
1931 void mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1932 void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
1933                                     u8 status);
1934 void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
1935 void mgmt_start_discovery_complete(struct hci_dev *hdev, u8 status);
1936 void mgmt_stop_discovery_complete(struct hci_dev *hdev, u8 status);
1937 void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1938                        u8 addr_type, u8 *dev_class, s8 rssi, u32 flags,
1939                        u8 *eir, u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len);
1940 void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1941                       u8 addr_type, s8 rssi, u8 *name, u8 name_len);
1942 void mgmt_discovering(struct hci_dev *hdev, u8 discovering);
1943 void mgmt_suspending(struct hci_dev *hdev, u8 state);
1944 void mgmt_resuming(struct hci_dev *hdev, u8 reason, bdaddr_t *bdaddr,
1945                    u8 addr_type);
1946 bool mgmt_powering_down(struct hci_dev *hdev);
1947 void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent);
1948 void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk, bool persistent);
1949 void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
1950                    bool persistent);
1951 void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr,
1952                          u8 bdaddr_type, u8 store_hint, u16 min_interval,
1953                          u16 max_interval, u16 latency, u16 timeout);
1954 void mgmt_smp_complete(struct hci_conn *conn, bool complete);
1955 bool mgmt_get_connectable(struct hci_dev *hdev);
1956 void mgmt_set_connectable_complete(struct hci_dev *hdev, u8 status);
1957 void mgmt_set_discoverable_complete(struct hci_dev *hdev, u8 status);
1958 u8 mgmt_get_adv_discov_flags(struct hci_dev *hdev);
1959 void mgmt_advertising_added(struct sock *sk, struct hci_dev *hdev,
1960                             u8 instance);
1961 void mgmt_advertising_removed(struct sock *sk, struct hci_dev *hdev,
1962                               u8 instance);
1963 void mgmt_adv_monitor_removed(struct hci_dev *hdev, u16 handle);
1964 int mgmt_phy_configuration_changed(struct hci_dev *hdev, struct sock *skip);
1965 int mgmt_add_adv_patterns_monitor_complete(struct hci_dev *hdev, u8 status);
1966 int mgmt_remove_adv_monitor_complete(struct hci_dev *hdev, u8 status);
1967
1968 #ifdef TIZEN_BT
1969 void mgmt_rssi_enable_success(struct sock *sk, struct hci_dev *hdev,
1970                 void *data, struct hci_cc_rsp_enable_rssi *rp, int success);
1971 void mgmt_rssi_disable_success(struct sock *sk, struct hci_dev *hdev,
1972                 void *data, struct hci_cc_rsp_enable_rssi *rp, int success);
1973 int mgmt_set_rssi_threshold(struct sock *sk, struct hci_dev *hdev,
1974                 void *data, u16 len);
1975 void mgmt_rssi_alert_evt(struct hci_dev *hdev, u16 conn_handle,
1976                 s8 alert_type, s8 rssi_dbm);
1977 void mgmt_raw_rssi_response(struct hci_dev *hdev,
1978                 struct hci_cc_rp_get_raw_rssi *rp, int success);
1979 void mgmt_enable_rssi_cc(struct hci_dev *hdev, void *response, u8 status);
1980 int mgmt_device_name_update(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *name,
1981                 u8 name_len);
1982 void mgmt_le_discovering(struct hci_dev *hdev, u8 discovering);
1983 int mgmt_le_conn_updated(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type,
1984                 u8 dst_type, u16 conn_interval, u16 conn_latency,
1985                 u16 supervision_timeout);
1986 int mgmt_le_conn_update_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
1987                 u8 link_type, u8 addr_type, u8 status);
1988 void mgmt_hardware_error(struct hci_dev *hdev, u8 err_code);
1989 void mgmt_tx_timeout_error(struct hci_dev *hdev);
1990 /*  Pass adv type in the le device found */
1991 void mgmt_le_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1992                 u8 addr_type, u8 *dev_class, s8 rssi, u32 flags, u8 *eir,
1993                 u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len, u8 adv_type);
1994 void mgmt_multi_adv_state_change_evt(struct hci_dev *hdev, u8 adv_instance,
1995                 u8 state_change_reason, u16 connection_handle);
1996 #endif
1997
1998 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
1999                       u16 to_multiplier);
2000 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
2001                       __u8 ltk[16], __u8 key_size);
2002
2003 void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr,
2004                                u8 *bdaddr_type);
2005
2006 #define SCO_AIRMODE_MASK       0x0003
2007 #define SCO_AIRMODE_CVSD       0x0000
2008 #define SCO_AIRMODE_TRANSP     0x0003
2009
2010 #endif /* __HCI_CORE_H */