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>
25 #include <linux/kstrtox.h>
27 #include <net/bluetooth/bluetooth.h>
28 #include <net/bluetooth/hci_core.h>
31 #include "hci_request.h"
32 #include "hci_debugfs.h"
34 #define DEFINE_QUIRK_ATTRIBUTE(__name, __quirk) \
35 static ssize_t __name ## _read(struct file *file, \
36 char __user *user_buf, \
37 size_t count, loff_t *ppos) \
39 struct hci_dev *hdev = file->private_data; \
42 buf[0] = test_bit(__quirk, &hdev->quirks) ? 'Y' : 'N'; \
45 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); \
48 static ssize_t __name ## _write(struct file *file, \
49 const char __user *user_buf, \
50 size_t count, loff_t *ppos) \
52 struct hci_dev *hdev = file->private_data; \
56 if (test_bit(HCI_UP, &hdev->flags)) \
59 err = kstrtobool_from_user(user_buf, count, &enable); \
63 if (enable == test_bit(__quirk, &hdev->quirks)) \
66 change_bit(__quirk, &hdev->quirks); \
71 static const struct file_operations __name ## _fops = { \
72 .open = simple_open, \
73 .read = __name ## _read, \
74 .write = __name ## _write, \
75 .llseek = default_llseek, \
78 #define DEFINE_INFO_ATTRIBUTE(__name, __field) \
79 static int __name ## _show(struct seq_file *f, void *ptr) \
81 struct hci_dev *hdev = f->private; \
84 seq_printf(f, "%s\n", hdev->__field ? : ""); \
85 hci_dev_unlock(hdev); \
90 DEFINE_SHOW_ATTRIBUTE(__name)
92 static int features_show(struct seq_file *f, void *ptr)
94 struct hci_dev *hdev = f->private;
98 for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++)
99 seq_printf(f, "%2u: %8ph\n", p, hdev->features[p]);
100 if (lmp_le_capable(hdev))
101 seq_printf(f, "LE: %8ph\n", hdev->le_features);
102 hci_dev_unlock(hdev);
107 DEFINE_SHOW_ATTRIBUTE(features);
109 static int device_id_show(struct seq_file *f, void *ptr)
111 struct hci_dev *hdev = f->private;
114 seq_printf(f, "%4.4x:%4.4x:%4.4x:%4.4x\n", hdev->devid_source,
115 hdev->devid_vendor, hdev->devid_product, hdev->devid_version);
116 hci_dev_unlock(hdev);
121 DEFINE_SHOW_ATTRIBUTE(device_id);
123 static int device_list_show(struct seq_file *f, void *ptr)
125 struct hci_dev *hdev = f->private;
126 struct hci_conn_params *p;
127 struct bdaddr_list *b;
130 list_for_each_entry(b, &hdev->accept_list, list)
131 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
132 list_for_each_entry(p, &hdev->le_conn_params, list) {
133 seq_printf(f, "%pMR (type %u) %u\n", &p->addr, p->addr_type,
136 hci_dev_unlock(hdev);
141 DEFINE_SHOW_ATTRIBUTE(device_list);
143 static int blacklist_show(struct seq_file *f, void *p)
145 struct hci_dev *hdev = f->private;
146 struct bdaddr_list *b;
149 list_for_each_entry(b, &hdev->reject_list, list)
150 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
151 hci_dev_unlock(hdev);
156 DEFINE_SHOW_ATTRIBUTE(blacklist);
158 static int blocked_keys_show(struct seq_file *f, void *p)
160 struct hci_dev *hdev = f->private;
161 struct blocked_key *key;
164 list_for_each_entry_rcu(key, &hdev->blocked_keys, list)
165 seq_printf(f, "%u %*phN\n", key->type, 16, key->val);
171 DEFINE_SHOW_ATTRIBUTE(blocked_keys);
173 static int uuids_show(struct seq_file *f, void *p)
175 struct hci_dev *hdev = f->private;
176 struct bt_uuid *uuid;
179 list_for_each_entry(uuid, &hdev->uuids, list) {
182 /* The Bluetooth UUID values are stored in big endian,
183 * but with reversed byte order. So convert them into
184 * the right order for the %pUb modifier.
186 for (i = 0; i < 16; i++)
187 val[i] = uuid->uuid[15 - i];
189 seq_printf(f, "%pUb\n", val);
191 hci_dev_unlock(hdev);
196 DEFINE_SHOW_ATTRIBUTE(uuids);
198 static int remote_oob_show(struct seq_file *f, void *ptr)
200 struct hci_dev *hdev = f->private;
201 struct oob_data *data;
204 list_for_each_entry(data, &hdev->remote_oob_data, list) {
205 seq_printf(f, "%pMR (type %u) %u %*phN %*phN %*phN %*phN\n",
206 &data->bdaddr, data->bdaddr_type, data->present,
207 16, data->hash192, 16, data->rand192,
208 16, data->hash256, 16, data->rand256);
210 hci_dev_unlock(hdev);
215 DEFINE_SHOW_ATTRIBUTE(remote_oob);
217 static int conn_info_min_age_set(void *data, u64 val)
219 struct hci_dev *hdev = data;
222 if (val == 0 || val > hdev->conn_info_max_age) {
223 hci_dev_unlock(hdev);
227 hdev->conn_info_min_age = val;
228 hci_dev_unlock(hdev);
233 static int conn_info_min_age_get(void *data, u64 *val)
235 struct hci_dev *hdev = data;
238 *val = hdev->conn_info_min_age;
239 hci_dev_unlock(hdev);
244 DEFINE_DEBUGFS_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get,
245 conn_info_min_age_set, "%llu\n");
247 static int conn_info_max_age_set(void *data, u64 val)
249 struct hci_dev *hdev = data;
252 if (val == 0 || val < hdev->conn_info_min_age) {
253 hci_dev_unlock(hdev);
257 hdev->conn_info_max_age = val;
258 hci_dev_unlock(hdev);
263 static int conn_info_max_age_get(void *data, u64 *val)
265 struct hci_dev *hdev = data;
268 *val = hdev->conn_info_max_age;
269 hci_dev_unlock(hdev);
274 DEFINE_DEBUGFS_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get,
275 conn_info_max_age_set, "%llu\n");
277 static ssize_t use_debug_keys_read(struct file *file, char __user *user_buf,
278 size_t count, loff_t *ppos)
280 struct hci_dev *hdev = file->private_data;
283 buf[0] = hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS) ? 'Y' : 'N';
286 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
289 static const struct file_operations use_debug_keys_fops = {
291 .read = use_debug_keys_read,
292 .llseek = default_llseek,
295 static ssize_t sc_only_mode_read(struct file *file, char __user *user_buf,
296 size_t count, loff_t *ppos)
298 struct hci_dev *hdev = file->private_data;
301 buf[0] = hci_dev_test_flag(hdev, HCI_SC_ONLY) ? 'Y' : 'N';
304 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
307 static const struct file_operations sc_only_mode_fops = {
309 .read = sc_only_mode_read,
310 .llseek = default_llseek,
313 DEFINE_INFO_ATTRIBUTE(hardware_info, hw_info);
314 DEFINE_INFO_ATTRIBUTE(firmware_info, fw_info);
316 void hci_debugfs_create_common(struct hci_dev *hdev)
318 debugfs_create_file("features", 0444, hdev->debugfs, hdev,
320 debugfs_create_u16("manufacturer", 0444, hdev->debugfs,
321 &hdev->manufacturer);
322 debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver);
323 debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev);
324 debugfs_create_u8("hardware_error", 0444, hdev->debugfs,
325 &hdev->hw_error_code);
326 debugfs_create_file("device_id", 0444, hdev->debugfs, hdev,
329 debugfs_create_file("device_list", 0444, hdev->debugfs, hdev,
331 debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev,
333 debugfs_create_file("blocked_keys", 0444, hdev->debugfs, hdev,
335 debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops);
336 debugfs_create_file("remote_oob", 0400, hdev->debugfs, hdev,
339 debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev,
340 &conn_info_min_age_fops);
341 debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev,
342 &conn_info_max_age_fops);
344 if (lmp_ssp_capable(hdev) || lmp_le_capable(hdev))
345 debugfs_create_file("use_debug_keys", 0444, hdev->debugfs,
346 hdev, &use_debug_keys_fops);
348 if (lmp_sc_capable(hdev) || lmp_le_capable(hdev))
349 debugfs_create_file("sc_only_mode", 0444, hdev->debugfs,
350 hdev, &sc_only_mode_fops);
353 debugfs_create_file("hardware_info", 0444, hdev->debugfs,
354 hdev, &hardware_info_fops);
357 debugfs_create_file("firmware_info", 0444, hdev->debugfs,
358 hdev, &firmware_info_fops);
361 static int inquiry_cache_show(struct seq_file *f, void *p)
363 struct hci_dev *hdev = f->private;
364 struct discovery_state *cache = &hdev->discovery;
365 struct inquiry_entry *e;
369 list_for_each_entry(e, &cache->all, all) {
370 struct inquiry_data *data = &e->data;
371 seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n",
373 data->pscan_rep_mode, data->pscan_period_mode,
374 data->pscan_mode, data->dev_class[2],
375 data->dev_class[1], data->dev_class[0],
376 __le16_to_cpu(data->clock_offset),
377 data->rssi, data->ssp_mode, e->timestamp);
380 hci_dev_unlock(hdev);
385 DEFINE_SHOW_ATTRIBUTE(inquiry_cache);
387 static int link_keys_show(struct seq_file *f, void *ptr)
389 struct hci_dev *hdev = f->private;
390 struct link_key *key;
393 list_for_each_entry_rcu(key, &hdev->link_keys, list)
394 seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type,
395 HCI_LINK_KEY_SIZE, key->val, key->pin_len);
401 DEFINE_SHOW_ATTRIBUTE(link_keys);
403 static int dev_class_show(struct seq_file *f, void *ptr)
405 struct hci_dev *hdev = f->private;
408 seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2],
409 hdev->dev_class[1], hdev->dev_class[0]);
410 hci_dev_unlock(hdev);
415 DEFINE_SHOW_ATTRIBUTE(dev_class);
417 static int voice_setting_get(void *data, u64 *val)
419 struct hci_dev *hdev = data;
422 *val = hdev->voice_setting;
423 hci_dev_unlock(hdev);
428 DEFINE_DEBUGFS_ATTRIBUTE(voice_setting_fops, voice_setting_get,
429 NULL, "0x%4.4llx\n");
431 static ssize_t ssp_debug_mode_read(struct file *file, char __user *user_buf,
432 size_t count, loff_t *ppos)
434 struct hci_dev *hdev = file->private_data;
437 buf[0] = hdev->ssp_debug_mode ? 'Y' : 'N';
440 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
443 static const struct file_operations ssp_debug_mode_fops = {
445 .read = ssp_debug_mode_read,
446 .llseek = default_llseek,
449 static int auto_accept_delay_set(void *data, u64 val)
451 struct hci_dev *hdev = data;
454 hdev->auto_accept_delay = val;
455 hci_dev_unlock(hdev);
460 static int min_encrypt_key_size_set(void *data, u64 val)
462 struct hci_dev *hdev = data;
464 if (val < 1 || val > 16)
468 hdev->min_enc_key_size = val;
469 hci_dev_unlock(hdev);
474 static int min_encrypt_key_size_get(void *data, u64 *val)
476 struct hci_dev *hdev = data;
479 *val = hdev->min_enc_key_size;
480 hci_dev_unlock(hdev);
485 DEFINE_DEBUGFS_ATTRIBUTE(min_encrypt_key_size_fops,
486 min_encrypt_key_size_get,
487 min_encrypt_key_size_set, "%llu\n");
489 static int auto_accept_delay_get(void *data, u64 *val)
491 struct hci_dev *hdev = data;
494 *val = hdev->auto_accept_delay;
495 hci_dev_unlock(hdev);
500 DEFINE_DEBUGFS_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
501 auto_accept_delay_set, "%llu\n");
503 static ssize_t force_bredr_smp_read(struct file *file,
504 char __user *user_buf,
505 size_t count, loff_t *ppos)
507 struct hci_dev *hdev = file->private_data;
510 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP) ? 'Y' : 'N';
513 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
516 static ssize_t force_bredr_smp_write(struct file *file,
517 const char __user *user_buf,
518 size_t count, loff_t *ppos)
520 struct hci_dev *hdev = file->private_data;
524 err = kstrtobool_from_user(user_buf, count, &enable);
528 err = smp_force_bredr(hdev, enable);
535 static const struct file_operations force_bredr_smp_fops = {
537 .read = force_bredr_smp_read,
538 .write = force_bredr_smp_write,
539 .llseek = default_llseek,
542 static int idle_timeout_set(void *data, u64 val)
544 struct hci_dev *hdev = data;
546 if (val != 0 && (val < 500 || val > 3600000))
550 hdev->idle_timeout = val;
551 hci_dev_unlock(hdev);
556 static int idle_timeout_get(void *data, u64 *val)
558 struct hci_dev *hdev = data;
561 *val = hdev->idle_timeout;
562 hci_dev_unlock(hdev);
567 DEFINE_DEBUGFS_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
568 idle_timeout_set, "%llu\n");
570 static int sniff_min_interval_set(void *data, u64 val)
572 struct hci_dev *hdev = data;
575 if (val == 0 || val % 2 || val > hdev->sniff_max_interval) {
576 hci_dev_unlock(hdev);
580 hdev->sniff_min_interval = val;
581 hci_dev_unlock(hdev);
586 static int sniff_min_interval_get(void *data, u64 *val)
588 struct hci_dev *hdev = data;
591 *val = hdev->sniff_min_interval;
592 hci_dev_unlock(hdev);
597 DEFINE_DEBUGFS_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
598 sniff_min_interval_set, "%llu\n");
600 static int sniff_max_interval_set(void *data, u64 val)
602 struct hci_dev *hdev = data;
605 if (val == 0 || val % 2 || val < hdev->sniff_min_interval) {
606 hci_dev_unlock(hdev);
610 hdev->sniff_max_interval = val;
611 hci_dev_unlock(hdev);
616 static int sniff_max_interval_get(void *data, u64 *val)
618 struct hci_dev *hdev = data;
621 *val = hdev->sniff_max_interval;
622 hci_dev_unlock(hdev);
627 DEFINE_DEBUGFS_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
628 sniff_max_interval_set, "%llu\n");
630 void hci_debugfs_create_bredr(struct hci_dev *hdev)
632 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev,
633 &inquiry_cache_fops);
634 debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev,
636 debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev,
638 debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev,
639 &voice_setting_fops);
641 /* If the controller does not support BR/EDR Secure Connections
642 * feature, then the BR/EDR SMP channel shall not be present.
644 * To test this with Bluetooth 4.0 controllers, create a debugfs
645 * switch that allows forcing BR/EDR SMP support and accepting
646 * cross-transport pairing on non-AES encrypted connections.
648 if (!lmp_sc_capable(hdev))
649 debugfs_create_file("force_bredr_smp", 0644, hdev->debugfs,
650 hdev, &force_bredr_smp_fops);
652 if (lmp_ssp_capable(hdev)) {
653 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
654 hdev, &ssp_debug_mode_fops);
655 debugfs_create_file("min_encrypt_key_size", 0644, hdev->debugfs,
656 hdev, &min_encrypt_key_size_fops);
657 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
658 hdev, &auto_accept_delay_fops);
661 if (lmp_sniff_capable(hdev)) {
662 debugfs_create_file("idle_timeout", 0644, hdev->debugfs,
663 hdev, &idle_timeout_fops);
664 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs,
665 hdev, &sniff_min_interval_fops);
666 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs,
667 hdev, &sniff_max_interval_fops);
671 static int identity_show(struct seq_file *f, void *p)
673 struct hci_dev *hdev = f->private;
679 hci_copy_identity_address(hdev, &addr, &addr_type);
681 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type,
682 16, hdev->irk, &hdev->rpa);
684 hci_dev_unlock(hdev);
689 DEFINE_SHOW_ATTRIBUTE(identity);
691 static int rpa_timeout_set(void *data, u64 val)
693 struct hci_dev *hdev = data;
695 /* Require the RPA timeout to be at least 30 seconds and at most
698 if (val < 30 || val > (60 * 60 * 24))
702 hdev->rpa_timeout = val;
703 hci_dev_unlock(hdev);
708 static int rpa_timeout_get(void *data, u64 *val)
710 struct hci_dev *hdev = data;
713 *val = hdev->rpa_timeout;
714 hci_dev_unlock(hdev);
719 DEFINE_DEBUGFS_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
720 rpa_timeout_set, "%llu\n");
722 static int random_address_show(struct seq_file *f, void *p)
724 struct hci_dev *hdev = f->private;
727 seq_printf(f, "%pMR\n", &hdev->random_addr);
728 hci_dev_unlock(hdev);
733 DEFINE_SHOW_ATTRIBUTE(random_address);
735 static int static_address_show(struct seq_file *f, void *p)
737 struct hci_dev *hdev = f->private;
740 seq_printf(f, "%pMR\n", &hdev->static_addr);
741 hci_dev_unlock(hdev);
746 DEFINE_SHOW_ATTRIBUTE(static_address);
748 static ssize_t force_static_address_read(struct file *file,
749 char __user *user_buf,
750 size_t count, loff_t *ppos)
752 struct hci_dev *hdev = file->private_data;
755 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y' : 'N';
758 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
761 static ssize_t force_static_address_write(struct file *file,
762 const char __user *user_buf,
763 size_t count, loff_t *ppos)
765 struct hci_dev *hdev = file->private_data;
769 if (hdev_is_powered(hdev))
772 err = kstrtobool_from_user(user_buf, count, &enable);
776 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
779 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
784 static const struct file_operations force_static_address_fops = {
786 .read = force_static_address_read,
787 .write = force_static_address_write,
788 .llseek = default_llseek,
791 static int white_list_show(struct seq_file *f, void *ptr)
793 struct hci_dev *hdev = f->private;
794 struct bdaddr_list *b;
797 list_for_each_entry(b, &hdev->le_accept_list, list)
798 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
799 hci_dev_unlock(hdev);
804 DEFINE_SHOW_ATTRIBUTE(white_list);
806 static int resolv_list_show(struct seq_file *f, void *ptr)
808 struct hci_dev *hdev = f->private;
809 struct bdaddr_list *b;
812 list_for_each_entry(b, &hdev->le_resolv_list, list)
813 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
814 hci_dev_unlock(hdev);
819 DEFINE_SHOW_ATTRIBUTE(resolv_list);
821 static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
823 struct hci_dev *hdev = f->private;
827 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
828 seq_printf(f, "%pMR (type %u) %*phN %pMR\n",
829 &irk->bdaddr, irk->addr_type,
830 16, irk->val, &irk->rpa);
837 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
839 static int long_term_keys_show(struct seq_file *f, void *ptr)
841 struct hci_dev *hdev = f->private;
845 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list)
846 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n",
847 <k->bdaddr, ltk->bdaddr_type, ltk->authenticated,
848 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv),
849 __le64_to_cpu(ltk->rand), 16, ltk->val);
855 DEFINE_SHOW_ATTRIBUTE(long_term_keys);
857 static int conn_min_interval_set(void *data, u64 val)
859 struct hci_dev *hdev = data;
862 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval) {
863 hci_dev_unlock(hdev);
867 hdev->le_conn_min_interval = val;
868 hci_dev_unlock(hdev);
873 static int conn_min_interval_get(void *data, u64 *val)
875 struct hci_dev *hdev = data;
878 *val = hdev->le_conn_min_interval;
879 hci_dev_unlock(hdev);
884 DEFINE_DEBUGFS_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
885 conn_min_interval_set, "%llu\n");
887 static int conn_max_interval_set(void *data, u64 val)
889 struct hci_dev *hdev = data;
892 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval) {
893 hci_dev_unlock(hdev);
897 hdev->le_conn_max_interval = val;
898 hci_dev_unlock(hdev);
903 static int conn_max_interval_get(void *data, u64 *val)
905 struct hci_dev *hdev = data;
908 *val = hdev->le_conn_max_interval;
909 hci_dev_unlock(hdev);
914 DEFINE_DEBUGFS_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
915 conn_max_interval_set, "%llu\n");
917 static int conn_latency_set(void *data, u64 val)
919 struct hci_dev *hdev = data;
925 hdev->le_conn_latency = val;
926 hci_dev_unlock(hdev);
931 static int conn_latency_get(void *data, u64 *val)
933 struct hci_dev *hdev = data;
936 *val = hdev->le_conn_latency;
937 hci_dev_unlock(hdev);
942 DEFINE_DEBUGFS_ATTRIBUTE(conn_latency_fops, conn_latency_get,
943 conn_latency_set, "%llu\n");
945 static int supervision_timeout_set(void *data, u64 val)
947 struct hci_dev *hdev = data;
949 if (val < 0x000a || val > 0x0c80)
953 hdev->le_supv_timeout = val;
954 hci_dev_unlock(hdev);
959 static int supervision_timeout_get(void *data, u64 *val)
961 struct hci_dev *hdev = data;
964 *val = hdev->le_supv_timeout;
965 hci_dev_unlock(hdev);
970 DEFINE_DEBUGFS_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
971 supervision_timeout_set, "%llu\n");
973 static int adv_channel_map_set(void *data, u64 val)
975 struct hci_dev *hdev = data;
977 if (val < 0x01 || val > 0x07)
981 hdev->le_adv_channel_map = val;
982 hci_dev_unlock(hdev);
987 static int adv_channel_map_get(void *data, u64 *val)
989 struct hci_dev *hdev = data;
992 *val = hdev->le_adv_channel_map;
993 hci_dev_unlock(hdev);
998 DEFINE_DEBUGFS_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
999 adv_channel_map_set, "%llu\n");
1001 static int adv_min_interval_set(void *data, u64 val)
1003 struct hci_dev *hdev = data;
1006 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval) {
1007 hci_dev_unlock(hdev);
1011 hdev->le_adv_min_interval = val;
1012 hci_dev_unlock(hdev);
1017 static int adv_min_interval_get(void *data, u64 *val)
1019 struct hci_dev *hdev = data;
1022 *val = hdev->le_adv_min_interval;
1023 hci_dev_unlock(hdev);
1028 DEFINE_DEBUGFS_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
1029 adv_min_interval_set, "%llu\n");
1031 static int adv_max_interval_set(void *data, u64 val)
1033 struct hci_dev *hdev = data;
1036 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval) {
1037 hci_dev_unlock(hdev);
1041 hdev->le_adv_max_interval = val;
1042 hci_dev_unlock(hdev);
1047 static int adv_max_interval_get(void *data, u64 *val)
1049 struct hci_dev *hdev = data;
1052 *val = hdev->le_adv_max_interval;
1053 hci_dev_unlock(hdev);
1058 DEFINE_DEBUGFS_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
1059 adv_max_interval_set, "%llu\n");
1061 static int min_key_size_set(void *data, u64 val)
1063 struct hci_dev *hdev = data;
1066 if (val > hdev->le_max_key_size || val < SMP_MIN_ENC_KEY_SIZE) {
1067 hci_dev_unlock(hdev);
1071 hdev->le_min_key_size = val;
1072 hci_dev_unlock(hdev);
1077 static int min_key_size_get(void *data, u64 *val)
1079 struct hci_dev *hdev = data;
1082 *val = hdev->le_min_key_size;
1083 hci_dev_unlock(hdev);
1088 DEFINE_DEBUGFS_ATTRIBUTE(min_key_size_fops, min_key_size_get,
1089 min_key_size_set, "%llu\n");
1091 static int max_key_size_set(void *data, u64 val)
1093 struct hci_dev *hdev = data;
1096 if (val > SMP_MAX_ENC_KEY_SIZE || val < hdev->le_min_key_size) {
1097 hci_dev_unlock(hdev);
1101 hdev->le_max_key_size = val;
1102 hci_dev_unlock(hdev);
1107 static int max_key_size_get(void *data, u64 *val)
1109 struct hci_dev *hdev = data;
1112 *val = hdev->le_max_key_size;
1113 hci_dev_unlock(hdev);
1118 DEFINE_DEBUGFS_ATTRIBUTE(max_key_size_fops, max_key_size_get,
1119 max_key_size_set, "%llu\n");
1121 static int auth_payload_timeout_set(void *data, u64 val)
1123 struct hci_dev *hdev = data;
1125 if (val < 0x0001 || val > 0xffff)
1129 hdev->auth_payload_timeout = val;
1130 hci_dev_unlock(hdev);
1135 static int auth_payload_timeout_get(void *data, u64 *val)
1137 struct hci_dev *hdev = data;
1140 *val = hdev->auth_payload_timeout;
1141 hci_dev_unlock(hdev);
1146 DEFINE_DEBUGFS_ATTRIBUTE(auth_payload_timeout_fops,
1147 auth_payload_timeout_get,
1148 auth_payload_timeout_set, "%llu\n");
1150 static ssize_t force_no_mitm_read(struct file *file,
1151 char __user *user_buf,
1152 size_t count, loff_t *ppos)
1154 struct hci_dev *hdev = file->private_data;
1157 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_NO_MITM) ? 'Y' : 'N';
1160 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
1163 static ssize_t force_no_mitm_write(struct file *file,
1164 const char __user *user_buf,
1165 size_t count, loff_t *ppos)
1167 struct hci_dev *hdev = file->private_data;
1169 size_t buf_size = min(count, (sizeof(buf) - 1));
1172 if (copy_from_user(buf, user_buf, buf_size))
1175 buf[buf_size] = '\0';
1176 if (kstrtobool(buf, &enable))
1179 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_NO_MITM))
1182 hci_dev_change_flag(hdev, HCI_FORCE_NO_MITM);
1187 static const struct file_operations force_no_mitm_fops = {
1188 .open = simple_open,
1189 .read = force_no_mitm_read,
1190 .write = force_no_mitm_write,
1191 .llseek = default_llseek,
1194 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
1195 HCI_QUIRK_STRICT_DUPLICATE_FILTER);
1196 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
1197 HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
1199 void hci_debugfs_create_le(struct hci_dev *hdev)
1201 debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
1203 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
1205 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
1206 &random_address_fops);
1207 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
1208 &static_address_fops);
1210 /* For controllers with a public address, provide a debug
1211 * option to force the usage of the configured static
1212 * address. By default the public address is used.
1214 if (bacmp(&hdev->bdaddr, BDADDR_ANY))
1215 debugfs_create_file("force_static_address", 0644,
1216 hdev->debugfs, hdev,
1217 &force_static_address_fops);
1219 debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
1220 &hdev->le_accept_list_size);
1221 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
1223 debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs,
1224 &hdev->le_resolv_list_size);
1225 debugfs_create_file("resolv_list", 0444, hdev->debugfs, hdev,
1227 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
1228 hdev, &identity_resolving_keys_fops);
1229 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
1230 &long_term_keys_fops);
1231 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
1232 &conn_min_interval_fops);
1233 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
1234 &conn_max_interval_fops);
1235 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
1236 &conn_latency_fops);
1237 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
1238 &supervision_timeout_fops);
1239 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
1240 &adv_channel_map_fops);
1241 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
1242 &adv_min_interval_fops);
1243 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
1244 &adv_max_interval_fops);
1245 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
1246 &hdev->discov_interleaved_timeout);
1247 debugfs_create_file("min_key_size", 0644, hdev->debugfs, hdev,
1248 &min_key_size_fops);
1249 debugfs_create_file("max_key_size", 0644, hdev->debugfs, hdev,
1250 &max_key_size_fops);
1251 debugfs_create_file("auth_payload_timeout", 0644, hdev->debugfs, hdev,
1252 &auth_payload_timeout_fops);
1253 debugfs_create_file("force_no_mitm", 0644, hdev->debugfs, hdev,
1254 &force_no_mitm_fops);
1256 debugfs_create_file("quirk_strict_duplicate_filter", 0644,
1257 hdev->debugfs, hdev,
1258 &quirk_strict_duplicate_filter_fops);
1259 debugfs_create_file("quirk_simultaneous_discovery", 0644,
1260 hdev->debugfs, hdev,
1261 &quirk_simultaneous_discovery_fops);
1264 void hci_debugfs_create_conn(struct hci_conn *conn)
1266 struct hci_dev *hdev = conn->hdev;
1269 if (IS_ERR_OR_NULL(hdev->debugfs) || conn->debugfs)
1272 snprintf(name, sizeof(name), "%u", conn->handle);
1273 conn->debugfs = debugfs_create_dir(name, hdev->debugfs);
1276 static ssize_t dut_mode_read(struct file *file, char __user *user_buf,
1277 size_t count, loff_t *ppos)
1279 struct hci_dev *hdev = file->private_data;
1282 buf[0] = hci_dev_test_flag(hdev, HCI_DUT_MODE) ? 'Y' : 'N';
1285 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
1288 static ssize_t dut_mode_write(struct file *file, const char __user *user_buf,
1289 size_t count, loff_t *ppos)
1291 struct hci_dev *hdev = file->private_data;
1292 struct sk_buff *skb;
1296 if (!test_bit(HCI_UP, &hdev->flags))
1299 err = kstrtobool_from_user(user_buf, count, &enable);
1303 if (enable == hci_dev_test_flag(hdev, HCI_DUT_MODE))
1306 hci_req_sync_lock(hdev);
1308 skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL,
1311 skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL,
1313 hci_req_sync_unlock(hdev);
1316 return PTR_ERR(skb);
1320 hci_dev_change_flag(hdev, HCI_DUT_MODE);
1325 static const struct file_operations dut_mode_fops = {
1326 .open = simple_open,
1327 .read = dut_mode_read,
1328 .write = dut_mode_write,
1329 .llseek = default_llseek,
1332 static ssize_t vendor_diag_read(struct file *file, char __user *user_buf,
1333 size_t count, loff_t *ppos)
1335 struct hci_dev *hdev = file->private_data;
1338 buf[0] = hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) ? 'Y' : 'N';
1341 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
1344 static ssize_t vendor_diag_write(struct file *file, const char __user *user_buf,
1345 size_t count, loff_t *ppos)
1347 struct hci_dev *hdev = file->private_data;
1351 err = kstrtobool_from_user(user_buf, count, &enable);
1355 /* When the diagnostic flags are not persistent and the transport
1356 * is not active or in user channel operation, then there is no need
1357 * for the vendor callback. Instead just store the desired value and
1358 * the setting will be programmed when the controller gets powered on.
1360 if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) &&
1361 (!test_bit(HCI_RUNNING, &hdev->flags) ||
1362 hci_dev_test_flag(hdev, HCI_USER_CHANNEL)))
1365 hci_req_sync_lock(hdev);
1366 err = hdev->set_diag(hdev, enable);
1367 hci_req_sync_unlock(hdev);
1374 hci_dev_set_flag(hdev, HCI_VENDOR_DIAG);
1376 hci_dev_clear_flag(hdev, HCI_VENDOR_DIAG);
1381 static const struct file_operations vendor_diag_fops = {
1382 .open = simple_open,
1383 .read = vendor_diag_read,
1384 .write = vendor_diag_write,
1385 .llseek = default_llseek,
1388 void hci_debugfs_create_basic(struct hci_dev *hdev)
1390 debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev,
1394 debugfs_create_file("vendor_diag", 0644, hdev->debugfs, hdev,