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