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