2 BlueZ - Bluetooth protocol stack for Linux
4 Copyright (C) 2014 Intel Corporation
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License version 2 as
8 published by the Free Software Foundation;
10 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
11 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
13 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
14 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
15 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
20 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
21 SOFTWARE IS DISCLAIMED.
24 #include <linux/debugfs.h>
26 #include <net/bluetooth/bluetooth.h>
27 #include <net/bluetooth/hci_core.h>
29 #include "hci_debugfs.h"
31 #define DEFINE_QUIRK_ATTRIBUTE(__name, __quirk) \
32 static ssize_t __name ## _read(struct file *file, \
33 char __user *user_buf, \
34 size_t count, loff_t *ppos) \
36 struct hci_dev *hdev = file->private_data; \
39 buf[0] = test_bit(__quirk, &hdev->quirks) ? 'Y' : 'N'; \
42 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); \
45 static ssize_t __name ## _write(struct file *file, \
46 const char __user *user_buf, \
47 size_t count, loff_t *ppos) \
49 struct hci_dev *hdev = file->private_data; \
53 if (test_bit(HCI_UP, &hdev->flags)) \
56 err = kstrtobool_from_user(user_buf, count, &enable); \
60 if (enable == test_bit(__quirk, &hdev->quirks)) \
63 change_bit(__quirk, &hdev->quirks); \
68 static const struct file_operations __name ## _fops = { \
69 .open = simple_open, \
70 .read = __name ## _read, \
71 .write = __name ## _write, \
72 .llseek = default_llseek, \
75 #define DEFINE_INFO_ATTRIBUTE(__name, __field) \
76 static int __name ## _show(struct seq_file *f, void *ptr) \
78 struct hci_dev *hdev = f->private; \
81 seq_printf(f, "%s\n", hdev->__field ? : ""); \
82 hci_dev_unlock(hdev); \
87 DEFINE_SHOW_ATTRIBUTE(__name)
89 static int features_show(struct seq_file *f, void *ptr)
91 struct hci_dev *hdev = f->private;
95 for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++)
96 seq_printf(f, "%2u: %8ph\n", p, hdev->features[p]);
97 if (lmp_le_capable(hdev))
98 seq_printf(f, "LE: %8ph\n", hdev->le_features);
104 DEFINE_SHOW_ATTRIBUTE(features);
106 static int device_id_show(struct seq_file *f, void *ptr)
108 struct hci_dev *hdev = f->private;
111 seq_printf(f, "%4.4x:%4.4x:%4.4x:%4.4x\n", hdev->devid_source,
112 hdev->devid_vendor, hdev->devid_product, hdev->devid_version);
113 hci_dev_unlock(hdev);
118 DEFINE_SHOW_ATTRIBUTE(device_id);
120 static int device_list_show(struct seq_file *f, void *ptr)
122 struct hci_dev *hdev = f->private;
123 struct hci_conn_params *p;
124 struct bdaddr_list *b;
127 list_for_each_entry(b, &hdev->whitelist, list)
128 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
129 list_for_each_entry(p, &hdev->le_conn_params, list) {
130 seq_printf(f, "%pMR (type %u) %u\n", &p->addr, p->addr_type,
133 hci_dev_unlock(hdev);
138 DEFINE_SHOW_ATTRIBUTE(device_list);
140 static int blacklist_show(struct seq_file *f, void *p)
142 struct hci_dev *hdev = f->private;
143 struct bdaddr_list *b;
146 list_for_each_entry(b, &hdev->blacklist, list)
147 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
148 hci_dev_unlock(hdev);
153 DEFINE_SHOW_ATTRIBUTE(blacklist);
155 static int uuids_show(struct seq_file *f, void *p)
157 struct hci_dev *hdev = f->private;
158 struct bt_uuid *uuid;
161 list_for_each_entry(uuid, &hdev->uuids, list) {
164 /* The Bluetooth UUID values are stored in big endian,
165 * but with reversed byte order. So convert them into
166 * the right order for the %pUb modifier.
168 for (i = 0; i < 16; i++)
169 val[i] = uuid->uuid[15 - i];
171 seq_printf(f, "%pUb\n", val);
173 hci_dev_unlock(hdev);
178 DEFINE_SHOW_ATTRIBUTE(uuids);
180 static int remote_oob_show(struct seq_file *f, void *ptr)
182 struct hci_dev *hdev = f->private;
183 struct oob_data *data;
186 list_for_each_entry(data, &hdev->remote_oob_data, list) {
187 seq_printf(f, "%pMR (type %u) %u %*phN %*phN %*phN %*phN\n",
188 &data->bdaddr, data->bdaddr_type, data->present,
189 16, data->hash192, 16, data->rand192,
190 16, data->hash256, 16, data->rand256);
192 hci_dev_unlock(hdev);
197 DEFINE_SHOW_ATTRIBUTE(remote_oob);
199 static int conn_info_min_age_set(void *data, u64 val)
201 struct hci_dev *hdev = data;
203 if (val == 0 || val > hdev->conn_info_max_age)
207 hdev->conn_info_min_age = val;
208 hci_dev_unlock(hdev);
213 static int conn_info_min_age_get(void *data, u64 *val)
215 struct hci_dev *hdev = data;
218 *val = hdev->conn_info_min_age;
219 hci_dev_unlock(hdev);
224 DEFINE_SIMPLE_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get,
225 conn_info_min_age_set, "%llu\n");
227 static int conn_info_max_age_set(void *data, u64 val)
229 struct hci_dev *hdev = data;
231 if (val == 0 || val < hdev->conn_info_min_age)
235 hdev->conn_info_max_age = val;
236 hci_dev_unlock(hdev);
241 static int conn_info_max_age_get(void *data, u64 *val)
243 struct hci_dev *hdev = data;
246 *val = hdev->conn_info_max_age;
247 hci_dev_unlock(hdev);
252 DEFINE_SIMPLE_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get,
253 conn_info_max_age_set, "%llu\n");
255 static ssize_t use_debug_keys_read(struct file *file, char __user *user_buf,
256 size_t count, loff_t *ppos)
258 struct hci_dev *hdev = file->private_data;
261 buf[0] = hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS) ? 'Y': 'N';
264 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
267 static const struct file_operations use_debug_keys_fops = {
269 .read = use_debug_keys_read,
270 .llseek = default_llseek,
273 static ssize_t sc_only_mode_read(struct file *file, char __user *user_buf,
274 size_t count, loff_t *ppos)
276 struct hci_dev *hdev = file->private_data;
279 buf[0] = hci_dev_test_flag(hdev, HCI_SC_ONLY) ? 'Y': 'N';
282 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
285 static const struct file_operations sc_only_mode_fops = {
287 .read = sc_only_mode_read,
288 .llseek = default_llseek,
291 DEFINE_INFO_ATTRIBUTE(hardware_info, hw_info);
292 DEFINE_INFO_ATTRIBUTE(firmware_info, fw_info);
294 void hci_debugfs_create_common(struct hci_dev *hdev)
296 debugfs_create_file("features", 0444, hdev->debugfs, hdev,
298 debugfs_create_u16("manufacturer", 0444, hdev->debugfs,
299 &hdev->manufacturer);
300 debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver);
301 debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev);
302 debugfs_create_u8("hardware_error", 0444, hdev->debugfs,
303 &hdev->hw_error_code);
304 debugfs_create_file("device_id", 0444, hdev->debugfs, hdev,
307 debugfs_create_file("device_list", 0444, hdev->debugfs, hdev,
309 debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev,
311 debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops);
312 debugfs_create_file("remote_oob", 0400, hdev->debugfs, hdev,
315 debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev,
316 &conn_info_min_age_fops);
317 debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev,
318 &conn_info_max_age_fops);
320 if (lmp_ssp_capable(hdev) || lmp_le_capable(hdev))
321 debugfs_create_file("use_debug_keys", 0444, hdev->debugfs,
322 hdev, &use_debug_keys_fops);
324 if (lmp_sc_capable(hdev) || lmp_le_capable(hdev))
325 debugfs_create_file("sc_only_mode", 0444, hdev->debugfs,
326 hdev, &sc_only_mode_fops);
329 debugfs_create_file("hardware_info", 0444, hdev->debugfs,
330 hdev, &hardware_info_fops);
333 debugfs_create_file("firmware_info", 0444, hdev->debugfs,
334 hdev, &firmware_info_fops);
337 static int inquiry_cache_show(struct seq_file *f, void *p)
339 struct hci_dev *hdev = f->private;
340 struct discovery_state *cache = &hdev->discovery;
341 struct inquiry_entry *e;
345 list_for_each_entry(e, &cache->all, all) {
346 struct inquiry_data *data = &e->data;
347 seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n",
349 data->pscan_rep_mode, data->pscan_period_mode,
350 data->pscan_mode, data->dev_class[2],
351 data->dev_class[1], data->dev_class[0],
352 __le16_to_cpu(data->clock_offset),
353 data->rssi, data->ssp_mode, e->timestamp);
356 hci_dev_unlock(hdev);
361 DEFINE_SHOW_ATTRIBUTE(inquiry_cache);
363 static int link_keys_show(struct seq_file *f, void *ptr)
365 struct hci_dev *hdev = f->private;
366 struct link_key *key;
369 list_for_each_entry_rcu(key, &hdev->link_keys, list)
370 seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type,
371 HCI_LINK_KEY_SIZE, key->val, key->pin_len);
377 DEFINE_SHOW_ATTRIBUTE(link_keys);
379 static int dev_class_show(struct seq_file *f, void *ptr)
381 struct hci_dev *hdev = f->private;
384 seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2],
385 hdev->dev_class[1], hdev->dev_class[0]);
386 hci_dev_unlock(hdev);
391 DEFINE_SHOW_ATTRIBUTE(dev_class);
393 static int voice_setting_get(void *data, u64 *val)
395 struct hci_dev *hdev = data;
398 *val = hdev->voice_setting;
399 hci_dev_unlock(hdev);
404 DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get,
405 NULL, "0x%4.4llx\n");
407 static ssize_t ssp_debug_mode_read(struct file *file, char __user *user_buf,
408 size_t count, loff_t *ppos)
410 struct hci_dev *hdev = file->private_data;
413 buf[0] = hdev->ssp_debug_mode ? 'Y': 'N';
416 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
419 static const struct file_operations ssp_debug_mode_fops = {
421 .read = ssp_debug_mode_read,
422 .llseek = default_llseek,
425 static int auto_accept_delay_set(void *data, u64 val)
427 struct hci_dev *hdev = data;
430 hdev->auto_accept_delay = val;
431 hci_dev_unlock(hdev);
436 static int auto_accept_delay_get(void *data, u64 *val)
438 struct hci_dev *hdev = data;
441 *val = hdev->auto_accept_delay;
442 hci_dev_unlock(hdev);
447 DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
448 auto_accept_delay_set, "%llu\n");
450 static int idle_timeout_set(void *data, u64 val)
452 struct hci_dev *hdev = data;
454 if (val != 0 && (val < 500 || val > 3600000))
458 hdev->idle_timeout = val;
459 hci_dev_unlock(hdev);
464 static int idle_timeout_get(void *data, u64 *val)
466 struct hci_dev *hdev = data;
469 *val = hdev->idle_timeout;
470 hci_dev_unlock(hdev);
475 DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
476 idle_timeout_set, "%llu\n");
478 static int sniff_min_interval_set(void *data, u64 val)
480 struct hci_dev *hdev = data;
482 if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
486 hdev->sniff_min_interval = val;
487 hci_dev_unlock(hdev);
492 static int sniff_min_interval_get(void *data, u64 *val)
494 struct hci_dev *hdev = data;
497 *val = hdev->sniff_min_interval;
498 hci_dev_unlock(hdev);
503 DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
504 sniff_min_interval_set, "%llu\n");
506 static int sniff_max_interval_set(void *data, u64 val)
508 struct hci_dev *hdev = data;
510 if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
514 hdev->sniff_max_interval = val;
515 hci_dev_unlock(hdev);
520 static int sniff_max_interval_get(void *data, u64 *val)
522 struct hci_dev *hdev = data;
525 *val = hdev->sniff_max_interval;
526 hci_dev_unlock(hdev);
531 DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
532 sniff_max_interval_set, "%llu\n");
534 void hci_debugfs_create_bredr(struct hci_dev *hdev)
536 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev,
537 &inquiry_cache_fops);
538 debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev,
540 debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev,
542 debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev,
543 &voice_setting_fops);
545 if (lmp_ssp_capable(hdev)) {
546 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
547 hdev, &ssp_debug_mode_fops);
548 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
549 hdev, &auto_accept_delay_fops);
552 if (lmp_sniff_capable(hdev)) {
553 debugfs_create_file("idle_timeout", 0644, hdev->debugfs,
554 hdev, &idle_timeout_fops);
555 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs,
556 hdev, &sniff_min_interval_fops);
557 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs,
558 hdev, &sniff_max_interval_fops);
562 static int identity_show(struct seq_file *f, void *p)
564 struct hci_dev *hdev = f->private;
570 hci_copy_identity_address(hdev, &addr, &addr_type);
572 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type,
573 16, hdev->irk, &hdev->rpa);
575 hci_dev_unlock(hdev);
580 DEFINE_SHOW_ATTRIBUTE(identity);
582 static int rpa_timeout_set(void *data, u64 val)
584 struct hci_dev *hdev = data;
586 /* Require the RPA timeout to be at least 30 seconds and at most
589 if (val < 30 || val > (60 * 60 * 24))
593 hdev->rpa_timeout = val;
594 hci_dev_unlock(hdev);
599 static int rpa_timeout_get(void *data, u64 *val)
601 struct hci_dev *hdev = data;
604 *val = hdev->rpa_timeout;
605 hci_dev_unlock(hdev);
610 DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
611 rpa_timeout_set, "%llu\n");
613 static int random_address_show(struct seq_file *f, void *p)
615 struct hci_dev *hdev = f->private;
618 seq_printf(f, "%pMR\n", &hdev->random_addr);
619 hci_dev_unlock(hdev);
624 DEFINE_SHOW_ATTRIBUTE(random_address);
626 static int static_address_show(struct seq_file *f, void *p)
628 struct hci_dev *hdev = f->private;
631 seq_printf(f, "%pMR\n", &hdev->static_addr);
632 hci_dev_unlock(hdev);
637 DEFINE_SHOW_ATTRIBUTE(static_address);
639 static ssize_t force_static_address_read(struct file *file,
640 char __user *user_buf,
641 size_t count, loff_t *ppos)
643 struct hci_dev *hdev = file->private_data;
646 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y': 'N';
649 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
652 static ssize_t force_static_address_write(struct file *file,
653 const char __user *user_buf,
654 size_t count, loff_t *ppos)
656 struct hci_dev *hdev = file->private_data;
660 if (test_bit(HCI_UP, &hdev->flags))
663 err = kstrtobool_from_user(user_buf, count, &enable);
667 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
670 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
675 static const struct file_operations force_static_address_fops = {
677 .read = force_static_address_read,
678 .write = force_static_address_write,
679 .llseek = default_llseek,
682 static int white_list_show(struct seq_file *f, void *ptr)
684 struct hci_dev *hdev = f->private;
685 struct bdaddr_list *b;
688 list_for_each_entry(b, &hdev->le_white_list, list)
689 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
690 hci_dev_unlock(hdev);
695 DEFINE_SHOW_ATTRIBUTE(white_list);
697 static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
699 struct hci_dev *hdev = f->private;
703 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
704 seq_printf(f, "%pMR (type %u) %*phN %pMR\n",
705 &irk->bdaddr, irk->addr_type,
706 16, irk->val, &irk->rpa);
713 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
715 static int long_term_keys_show(struct seq_file *f, void *ptr)
717 struct hci_dev *hdev = f->private;
721 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list)
722 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n",
723 <k->bdaddr, ltk->bdaddr_type, ltk->authenticated,
724 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv),
725 __le64_to_cpu(ltk->rand), 16, ltk->val);
731 DEFINE_SHOW_ATTRIBUTE(long_term_keys);
733 static int conn_min_interval_set(void *data, u64 val)
735 struct hci_dev *hdev = data;
737 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval)
741 hdev->le_conn_min_interval = val;
742 hci_dev_unlock(hdev);
747 static int conn_min_interval_get(void *data, u64 *val)
749 struct hci_dev *hdev = data;
752 *val = hdev->le_conn_min_interval;
753 hci_dev_unlock(hdev);
758 DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
759 conn_min_interval_set, "%llu\n");
761 static int conn_max_interval_set(void *data, u64 val)
763 struct hci_dev *hdev = data;
765 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval)
769 hdev->le_conn_max_interval = val;
770 hci_dev_unlock(hdev);
775 static int conn_max_interval_get(void *data, u64 *val)
777 struct hci_dev *hdev = data;
780 *val = hdev->le_conn_max_interval;
781 hci_dev_unlock(hdev);
786 DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
787 conn_max_interval_set, "%llu\n");
789 static int conn_latency_set(void *data, u64 val)
791 struct hci_dev *hdev = data;
797 hdev->le_conn_latency = val;
798 hci_dev_unlock(hdev);
803 static int conn_latency_get(void *data, u64 *val)
805 struct hci_dev *hdev = data;
808 *val = hdev->le_conn_latency;
809 hci_dev_unlock(hdev);
814 DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get,
815 conn_latency_set, "%llu\n");
817 static int supervision_timeout_set(void *data, u64 val)
819 struct hci_dev *hdev = data;
821 if (val < 0x000a || val > 0x0c80)
825 hdev->le_supv_timeout = val;
826 hci_dev_unlock(hdev);
831 static int supervision_timeout_get(void *data, u64 *val)
833 struct hci_dev *hdev = data;
836 *val = hdev->le_supv_timeout;
837 hci_dev_unlock(hdev);
842 DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
843 supervision_timeout_set, "%llu\n");
845 static int adv_channel_map_set(void *data, u64 val)
847 struct hci_dev *hdev = data;
849 if (val < 0x01 || val > 0x07)
853 hdev->le_adv_channel_map = val;
854 hci_dev_unlock(hdev);
859 static int adv_channel_map_get(void *data, u64 *val)
861 struct hci_dev *hdev = data;
864 *val = hdev->le_adv_channel_map;
865 hci_dev_unlock(hdev);
870 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
871 adv_channel_map_set, "%llu\n");
873 static int adv_min_interval_set(void *data, u64 val)
875 struct hci_dev *hdev = data;
877 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval)
881 hdev->le_adv_min_interval = val;
882 hci_dev_unlock(hdev);
887 static int adv_min_interval_get(void *data, u64 *val)
889 struct hci_dev *hdev = data;
892 *val = hdev->le_adv_min_interval;
893 hci_dev_unlock(hdev);
898 DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
899 adv_min_interval_set, "%llu\n");
901 static int adv_max_interval_set(void *data, u64 val)
903 struct hci_dev *hdev = data;
905 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval)
909 hdev->le_adv_max_interval = val;
910 hci_dev_unlock(hdev);
915 static int adv_max_interval_get(void *data, u64 *val)
917 struct hci_dev *hdev = data;
920 *val = hdev->le_adv_max_interval;
921 hci_dev_unlock(hdev);
926 DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
927 adv_max_interval_set, "%llu\n");
929 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
930 HCI_QUIRK_STRICT_DUPLICATE_FILTER);
931 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
932 HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
934 void hci_debugfs_create_le(struct hci_dev *hdev)
936 debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
938 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
940 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
941 &random_address_fops);
942 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
943 &static_address_fops);
945 /* For controllers with a public address, provide a debug
946 * option to force the usage of the configured static
947 * address. By default the public address is used.
949 if (bacmp(&hdev->bdaddr, BDADDR_ANY))
950 debugfs_create_file("force_static_address", 0644,
952 &force_static_address_fops);
954 debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
955 &hdev->le_white_list_size);
956 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
958 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
959 hdev, &identity_resolving_keys_fops);
960 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
961 &long_term_keys_fops);
962 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
963 &conn_min_interval_fops);
964 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
965 &conn_max_interval_fops);
966 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
968 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
969 &supervision_timeout_fops);
970 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
971 &adv_channel_map_fops);
972 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
973 &adv_min_interval_fops);
974 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
975 &adv_max_interval_fops);
976 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
977 &hdev->discov_interleaved_timeout);
979 debugfs_create_file("quirk_strict_duplicate_filter", 0644,
981 &quirk_strict_duplicate_filter_fops);
982 debugfs_create_file("quirk_simultaneous_discovery", 0644,
984 &quirk_simultaneous_discovery_fops);
987 void hci_debugfs_create_conn(struct hci_conn *conn)
989 struct hci_dev *hdev = conn->hdev;
992 if (IS_ERR_OR_NULL(hdev->debugfs))
995 snprintf(name, sizeof(name), "%u", conn->handle);
996 conn->debugfs = debugfs_create_dir(name, hdev->debugfs);