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