~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/net/bluetooth/hci_core.h

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp