Linux 5.7.7
[linux/fpc-iii.git] / net / bluetooth / hci_debugfs.c
blob6b1314c738b8e3729ac705c31900cd392550d757
1 /*
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 "smp.h"
30 #include "hci_debugfs.h"
32 #define DEFINE_QUIRK_ATTRIBUTE(__name, __quirk) \
33 static ssize_t __name ## _read(struct file *file, \
34 char __user *user_buf, \
35 size_t count, loff_t *ppos) \
36 { \
37 struct hci_dev *hdev = file->private_data; \
38 char buf[3]; \
40 buf[0] = test_bit(__quirk, &hdev->quirks) ? 'Y' : 'N'; \
41 buf[1] = '\n'; \
42 buf[2] = '\0'; \
43 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); \
44 } \
46 static ssize_t __name ## _write(struct file *file, \
47 const char __user *user_buf, \
48 size_t count, loff_t *ppos) \
49 { \
50 struct hci_dev *hdev = file->private_data; \
51 bool enable; \
52 int err; \
54 if (test_bit(HCI_UP, &hdev->flags)) \
55 return -EBUSY; \
57 err = kstrtobool_from_user(user_buf, count, &enable); \
58 if (err) \
59 return err; \
61 if (enable == test_bit(__quirk, &hdev->quirks)) \
62 return -EALREADY; \
64 change_bit(__quirk, &hdev->quirks); \
66 return count; \
67 } \
69 static const struct file_operations __name ## _fops = { \
70 .open = simple_open, \
71 .read = __name ## _read, \
72 .write = __name ## _write, \
73 .llseek = default_llseek, \
74 } \
76 #define DEFINE_INFO_ATTRIBUTE(__name, __field) \
77 static int __name ## _show(struct seq_file *f, void *ptr) \
78 { \
79 struct hci_dev *hdev = f->private; \
81 hci_dev_lock(hdev); \
82 seq_printf(f, "%s\n", hdev->__field ? : ""); \
83 hci_dev_unlock(hdev); \
85 return 0; \
86 } \
88 DEFINE_SHOW_ATTRIBUTE(__name)
90 static int features_show(struct seq_file *f, void *ptr)
92 struct hci_dev *hdev = f->private;
93 u8 p;
95 hci_dev_lock(hdev);
96 for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++)
97 seq_printf(f, "%2u: %8ph\n", p, hdev->features[p]);
98 if (lmp_le_capable(hdev))
99 seq_printf(f, "LE: %8ph\n", hdev->le_features);
100 hci_dev_unlock(hdev);
102 return 0;
105 DEFINE_SHOW_ATTRIBUTE(features);
107 static int device_id_show(struct seq_file *f, void *ptr)
109 struct hci_dev *hdev = f->private;
111 hci_dev_lock(hdev);
112 seq_printf(f, "%4.4x:%4.4x:%4.4x:%4.4x\n", hdev->devid_source,
113 hdev->devid_vendor, hdev->devid_product, hdev->devid_version);
114 hci_dev_unlock(hdev);
116 return 0;
119 DEFINE_SHOW_ATTRIBUTE(device_id);
121 static int device_list_show(struct seq_file *f, void *ptr)
123 struct hci_dev *hdev = f->private;
124 struct hci_conn_params *p;
125 struct bdaddr_list *b;
127 hci_dev_lock(hdev);
128 list_for_each_entry(b, &hdev->whitelist, list)
129 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
130 list_for_each_entry(p, &hdev->le_conn_params, list) {
131 seq_printf(f, "%pMR (type %u) %u\n", &p->addr, p->addr_type,
132 p->auto_connect);
134 hci_dev_unlock(hdev);
136 return 0;
139 DEFINE_SHOW_ATTRIBUTE(device_list);
141 static int blacklist_show(struct seq_file *f, void *p)
143 struct hci_dev *hdev = f->private;
144 struct bdaddr_list *b;
146 hci_dev_lock(hdev);
147 list_for_each_entry(b, &hdev->blacklist, list)
148 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
149 hci_dev_unlock(hdev);
151 return 0;
154 DEFINE_SHOW_ATTRIBUTE(blacklist);
156 static int blocked_keys_show(struct seq_file *f, void *p)
158 struct hci_dev *hdev = f->private;
159 struct blocked_key *key;
161 rcu_read_lock();
162 list_for_each_entry_rcu(key, &hdev->blocked_keys, list)
163 seq_printf(f, "%u %*phN\n", key->type, 16, key->val);
164 rcu_read_unlock();
166 return 0;
169 DEFINE_SHOW_ATTRIBUTE(blocked_keys);
171 static int uuids_show(struct seq_file *f, void *p)
173 struct hci_dev *hdev = f->private;
174 struct bt_uuid *uuid;
176 hci_dev_lock(hdev);
177 list_for_each_entry(uuid, &hdev->uuids, list) {
178 u8 i, val[16];
180 /* The Bluetooth UUID values are stored in big endian,
181 * but with reversed byte order. So convert them into
182 * the right order for the %pUb modifier.
184 for (i = 0; i < 16; i++)
185 val[i] = uuid->uuid[15 - i];
187 seq_printf(f, "%pUb\n", val);
189 hci_dev_unlock(hdev);
191 return 0;
194 DEFINE_SHOW_ATTRIBUTE(uuids);
196 static int remote_oob_show(struct seq_file *f, void *ptr)
198 struct hci_dev *hdev = f->private;
199 struct oob_data *data;
201 hci_dev_lock(hdev);
202 list_for_each_entry(data, &hdev->remote_oob_data, list) {
203 seq_printf(f, "%pMR (type %u) %u %*phN %*phN %*phN %*phN\n",
204 &data->bdaddr, data->bdaddr_type, data->present,
205 16, data->hash192, 16, data->rand192,
206 16, data->hash256, 16, data->rand256);
208 hci_dev_unlock(hdev);
210 return 0;
213 DEFINE_SHOW_ATTRIBUTE(remote_oob);
215 static int conn_info_min_age_set(void *data, u64 val)
217 struct hci_dev *hdev = data;
219 if (val == 0 || val > hdev->conn_info_max_age)
220 return -EINVAL;
222 hci_dev_lock(hdev);
223 hdev->conn_info_min_age = val;
224 hci_dev_unlock(hdev);
226 return 0;
229 static int conn_info_min_age_get(void *data, u64 *val)
231 struct hci_dev *hdev = data;
233 hci_dev_lock(hdev);
234 *val = hdev->conn_info_min_age;
235 hci_dev_unlock(hdev);
237 return 0;
240 DEFINE_SIMPLE_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get,
241 conn_info_min_age_set, "%llu\n");
243 static int conn_info_max_age_set(void *data, u64 val)
245 struct hci_dev *hdev = data;
247 if (val == 0 || val < hdev->conn_info_min_age)
248 return -EINVAL;
250 hci_dev_lock(hdev);
251 hdev->conn_info_max_age = val;
252 hci_dev_unlock(hdev);
254 return 0;
257 static int conn_info_max_age_get(void *data, u64 *val)
259 struct hci_dev *hdev = data;
261 hci_dev_lock(hdev);
262 *val = hdev->conn_info_max_age;
263 hci_dev_unlock(hdev);
265 return 0;
268 DEFINE_SIMPLE_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get,
269 conn_info_max_age_set, "%llu\n");
271 static ssize_t use_debug_keys_read(struct file *file, char __user *user_buf,
272 size_t count, loff_t *ppos)
274 struct hci_dev *hdev = file->private_data;
275 char buf[3];
277 buf[0] = hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS) ? 'Y': 'N';
278 buf[1] = '\n';
279 buf[2] = '\0';
280 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
283 static const struct file_operations use_debug_keys_fops = {
284 .open = simple_open,
285 .read = use_debug_keys_read,
286 .llseek = default_llseek,
289 static ssize_t sc_only_mode_read(struct file *file, char __user *user_buf,
290 size_t count, loff_t *ppos)
292 struct hci_dev *hdev = file->private_data;
293 char buf[3];
295 buf[0] = hci_dev_test_flag(hdev, HCI_SC_ONLY) ? 'Y': 'N';
296 buf[1] = '\n';
297 buf[2] = '\0';
298 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
301 static const struct file_operations sc_only_mode_fops = {
302 .open = simple_open,
303 .read = sc_only_mode_read,
304 .llseek = default_llseek,
307 DEFINE_INFO_ATTRIBUTE(hardware_info, hw_info);
308 DEFINE_INFO_ATTRIBUTE(firmware_info, fw_info);
310 void hci_debugfs_create_common(struct hci_dev *hdev)
312 debugfs_create_file("features", 0444, hdev->debugfs, hdev,
313 &features_fops);
314 debugfs_create_u16("manufacturer", 0444, hdev->debugfs,
315 &hdev->manufacturer);
316 debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver);
317 debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev);
318 debugfs_create_u8("hardware_error", 0444, hdev->debugfs,
319 &hdev->hw_error_code);
320 debugfs_create_file("device_id", 0444, hdev->debugfs, hdev,
321 &device_id_fops);
323 debugfs_create_file("device_list", 0444, hdev->debugfs, hdev,
324 &device_list_fops);
325 debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev,
326 &blacklist_fops);
327 debugfs_create_file("blocked_keys", 0444, hdev->debugfs, hdev,
328 &blocked_keys_fops);
329 debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops);
330 debugfs_create_file("remote_oob", 0400, hdev->debugfs, hdev,
331 &remote_oob_fops);
333 debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev,
334 &conn_info_min_age_fops);
335 debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev,
336 &conn_info_max_age_fops);
338 if (lmp_ssp_capable(hdev) || lmp_le_capable(hdev))
339 debugfs_create_file("use_debug_keys", 0444, hdev->debugfs,
340 hdev, &use_debug_keys_fops);
342 if (lmp_sc_capable(hdev) || lmp_le_capable(hdev))
343 debugfs_create_file("sc_only_mode", 0444, hdev->debugfs,
344 hdev, &sc_only_mode_fops);
346 if (hdev->hw_info)
347 debugfs_create_file("hardware_info", 0444, hdev->debugfs,
348 hdev, &hardware_info_fops);
350 if (hdev->fw_info)
351 debugfs_create_file("firmware_info", 0444, hdev->debugfs,
352 hdev, &firmware_info_fops);
355 static int inquiry_cache_show(struct seq_file *f, void *p)
357 struct hci_dev *hdev = f->private;
358 struct discovery_state *cache = &hdev->discovery;
359 struct inquiry_entry *e;
361 hci_dev_lock(hdev);
363 list_for_each_entry(e, &cache->all, all) {
364 struct inquiry_data *data = &e->data;
365 seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n",
366 &data->bdaddr,
367 data->pscan_rep_mode, data->pscan_period_mode,
368 data->pscan_mode, data->dev_class[2],
369 data->dev_class[1], data->dev_class[0],
370 __le16_to_cpu(data->clock_offset),
371 data->rssi, data->ssp_mode, e->timestamp);
374 hci_dev_unlock(hdev);
376 return 0;
379 DEFINE_SHOW_ATTRIBUTE(inquiry_cache);
381 static int link_keys_show(struct seq_file *f, void *ptr)
383 struct hci_dev *hdev = f->private;
384 struct link_key *key;
386 rcu_read_lock();
387 list_for_each_entry_rcu(key, &hdev->link_keys, list)
388 seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type,
389 HCI_LINK_KEY_SIZE, key->val, key->pin_len);
390 rcu_read_unlock();
392 return 0;
395 DEFINE_SHOW_ATTRIBUTE(link_keys);
397 static int dev_class_show(struct seq_file *f, void *ptr)
399 struct hci_dev *hdev = f->private;
401 hci_dev_lock(hdev);
402 seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2],
403 hdev->dev_class[1], hdev->dev_class[0]);
404 hci_dev_unlock(hdev);
406 return 0;
409 DEFINE_SHOW_ATTRIBUTE(dev_class);
411 static int voice_setting_get(void *data, u64 *val)
413 struct hci_dev *hdev = data;
415 hci_dev_lock(hdev);
416 *val = hdev->voice_setting;
417 hci_dev_unlock(hdev);
419 return 0;
422 DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get,
423 NULL, "0x%4.4llx\n");
425 static ssize_t ssp_debug_mode_read(struct file *file, char __user *user_buf,
426 size_t count, loff_t *ppos)
428 struct hci_dev *hdev = file->private_data;
429 char buf[3];
431 buf[0] = hdev->ssp_debug_mode ? 'Y': 'N';
432 buf[1] = '\n';
433 buf[2] = '\0';
434 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
437 static const struct file_operations ssp_debug_mode_fops = {
438 .open = simple_open,
439 .read = ssp_debug_mode_read,
440 .llseek = default_llseek,
443 static int auto_accept_delay_set(void *data, u64 val)
445 struct hci_dev *hdev = data;
447 hci_dev_lock(hdev);
448 hdev->auto_accept_delay = val;
449 hci_dev_unlock(hdev);
451 return 0;
454 static int min_encrypt_key_size_set(void *data, u64 val)
456 struct hci_dev *hdev = data;
458 if (val < 1 || val > 16)
459 return -EINVAL;
461 hci_dev_lock(hdev);
462 hdev->min_enc_key_size = val;
463 hci_dev_unlock(hdev);
465 return 0;
468 static int min_encrypt_key_size_get(void *data, u64 *val)
470 struct hci_dev *hdev = data;
472 hci_dev_lock(hdev);
473 *val = hdev->min_enc_key_size;
474 hci_dev_unlock(hdev);
476 return 0;
479 DEFINE_SIMPLE_ATTRIBUTE(min_encrypt_key_size_fops,
480 min_encrypt_key_size_get,
481 min_encrypt_key_size_set, "%llu\n");
483 static int auto_accept_delay_get(void *data, u64 *val)
485 struct hci_dev *hdev = data;
487 hci_dev_lock(hdev);
488 *val = hdev->auto_accept_delay;
489 hci_dev_unlock(hdev);
491 return 0;
494 DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
495 auto_accept_delay_set, "%llu\n");
497 static int idle_timeout_set(void *data, u64 val)
499 struct hci_dev *hdev = data;
501 if (val != 0 && (val < 500 || val > 3600000))
502 return -EINVAL;
504 hci_dev_lock(hdev);
505 hdev->idle_timeout = val;
506 hci_dev_unlock(hdev);
508 return 0;
511 static int idle_timeout_get(void *data, u64 *val)
513 struct hci_dev *hdev = data;
515 hci_dev_lock(hdev);
516 *val = hdev->idle_timeout;
517 hci_dev_unlock(hdev);
519 return 0;
522 DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
523 idle_timeout_set, "%llu\n");
525 static int sniff_min_interval_set(void *data, u64 val)
527 struct hci_dev *hdev = data;
529 if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
530 return -EINVAL;
532 hci_dev_lock(hdev);
533 hdev->sniff_min_interval = val;
534 hci_dev_unlock(hdev);
536 return 0;
539 static int sniff_min_interval_get(void *data, u64 *val)
541 struct hci_dev *hdev = data;
543 hci_dev_lock(hdev);
544 *val = hdev->sniff_min_interval;
545 hci_dev_unlock(hdev);
547 return 0;
550 DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
551 sniff_min_interval_set, "%llu\n");
553 static int sniff_max_interval_set(void *data, u64 val)
555 struct hci_dev *hdev = data;
557 if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
558 return -EINVAL;
560 hci_dev_lock(hdev);
561 hdev->sniff_max_interval = val;
562 hci_dev_unlock(hdev);
564 return 0;
567 static int sniff_max_interval_get(void *data, u64 *val)
569 struct hci_dev *hdev = data;
571 hci_dev_lock(hdev);
572 *val = hdev->sniff_max_interval;
573 hci_dev_unlock(hdev);
575 return 0;
578 DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
579 sniff_max_interval_set, "%llu\n");
581 void hci_debugfs_create_bredr(struct hci_dev *hdev)
583 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev,
584 &inquiry_cache_fops);
585 debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev,
586 &link_keys_fops);
587 debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev,
588 &dev_class_fops);
589 debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev,
590 &voice_setting_fops);
592 if (lmp_ssp_capable(hdev)) {
593 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
594 hdev, &ssp_debug_mode_fops);
595 debugfs_create_file("min_encrypt_key_size", 0644, hdev->debugfs,
596 hdev, &min_encrypt_key_size_fops);
597 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
598 hdev, &auto_accept_delay_fops);
601 if (lmp_sniff_capable(hdev)) {
602 debugfs_create_file("idle_timeout", 0644, hdev->debugfs,
603 hdev, &idle_timeout_fops);
604 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs,
605 hdev, &sniff_min_interval_fops);
606 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs,
607 hdev, &sniff_max_interval_fops);
611 static int identity_show(struct seq_file *f, void *p)
613 struct hci_dev *hdev = f->private;
614 bdaddr_t addr;
615 u8 addr_type;
617 hci_dev_lock(hdev);
619 hci_copy_identity_address(hdev, &addr, &addr_type);
621 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type,
622 16, hdev->irk, &hdev->rpa);
624 hci_dev_unlock(hdev);
626 return 0;
629 DEFINE_SHOW_ATTRIBUTE(identity);
631 static int rpa_timeout_set(void *data, u64 val)
633 struct hci_dev *hdev = data;
635 /* Require the RPA timeout to be at least 30 seconds and at most
636 * 24 hours.
638 if (val < 30 || val > (60 * 60 * 24))
639 return -EINVAL;
641 hci_dev_lock(hdev);
642 hdev->rpa_timeout = val;
643 hci_dev_unlock(hdev);
645 return 0;
648 static int rpa_timeout_get(void *data, u64 *val)
650 struct hci_dev *hdev = data;
652 hci_dev_lock(hdev);
653 *val = hdev->rpa_timeout;
654 hci_dev_unlock(hdev);
656 return 0;
659 DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
660 rpa_timeout_set, "%llu\n");
662 static int random_address_show(struct seq_file *f, void *p)
664 struct hci_dev *hdev = f->private;
666 hci_dev_lock(hdev);
667 seq_printf(f, "%pMR\n", &hdev->random_addr);
668 hci_dev_unlock(hdev);
670 return 0;
673 DEFINE_SHOW_ATTRIBUTE(random_address);
675 static int static_address_show(struct seq_file *f, void *p)
677 struct hci_dev *hdev = f->private;
679 hci_dev_lock(hdev);
680 seq_printf(f, "%pMR\n", &hdev->static_addr);
681 hci_dev_unlock(hdev);
683 return 0;
686 DEFINE_SHOW_ATTRIBUTE(static_address);
688 static ssize_t force_static_address_read(struct file *file,
689 char __user *user_buf,
690 size_t count, loff_t *ppos)
692 struct hci_dev *hdev = file->private_data;
693 char buf[3];
695 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y': 'N';
696 buf[1] = '\n';
697 buf[2] = '\0';
698 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
701 static ssize_t force_static_address_write(struct file *file,
702 const char __user *user_buf,
703 size_t count, loff_t *ppos)
705 struct hci_dev *hdev = file->private_data;
706 bool enable;
707 int err;
709 if (test_bit(HCI_UP, &hdev->flags))
710 return -EBUSY;
712 err = kstrtobool_from_user(user_buf, count, &enable);
713 if (err)
714 return err;
716 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
717 return -EALREADY;
719 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
721 return count;
724 static const struct file_operations force_static_address_fops = {
725 .open = simple_open,
726 .read = force_static_address_read,
727 .write = force_static_address_write,
728 .llseek = default_llseek,
731 static int white_list_show(struct seq_file *f, void *ptr)
733 struct hci_dev *hdev = f->private;
734 struct bdaddr_list *b;
736 hci_dev_lock(hdev);
737 list_for_each_entry(b, &hdev->le_white_list, list)
738 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
739 hci_dev_unlock(hdev);
741 return 0;
744 DEFINE_SHOW_ATTRIBUTE(white_list);
746 static int resolv_list_show(struct seq_file *f, void *ptr)
748 struct hci_dev *hdev = f->private;
749 struct bdaddr_list *b;
751 hci_dev_lock(hdev);
752 list_for_each_entry(b, &hdev->le_resolv_list, list)
753 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
754 hci_dev_unlock(hdev);
756 return 0;
759 DEFINE_SHOW_ATTRIBUTE(resolv_list);
761 static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
763 struct hci_dev *hdev = f->private;
764 struct smp_irk *irk;
766 rcu_read_lock();
767 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
768 seq_printf(f, "%pMR (type %u) %*phN %pMR\n",
769 &irk->bdaddr, irk->addr_type,
770 16, irk->val, &irk->rpa);
772 rcu_read_unlock();
774 return 0;
777 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
779 static int long_term_keys_show(struct seq_file *f, void *ptr)
781 struct hci_dev *hdev = f->private;
782 struct smp_ltk *ltk;
784 rcu_read_lock();
785 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list)
786 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n",
787 &ltk->bdaddr, ltk->bdaddr_type, ltk->authenticated,
788 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv),
789 __le64_to_cpu(ltk->rand), 16, ltk->val);
790 rcu_read_unlock();
792 return 0;
795 DEFINE_SHOW_ATTRIBUTE(long_term_keys);
797 static int conn_min_interval_set(void *data, u64 val)
799 struct hci_dev *hdev = data;
801 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval)
802 return -EINVAL;
804 hci_dev_lock(hdev);
805 hdev->le_conn_min_interval = val;
806 hci_dev_unlock(hdev);
808 return 0;
811 static int conn_min_interval_get(void *data, u64 *val)
813 struct hci_dev *hdev = data;
815 hci_dev_lock(hdev);
816 *val = hdev->le_conn_min_interval;
817 hci_dev_unlock(hdev);
819 return 0;
822 DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
823 conn_min_interval_set, "%llu\n");
825 static int conn_max_interval_set(void *data, u64 val)
827 struct hci_dev *hdev = data;
829 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval)
830 return -EINVAL;
832 hci_dev_lock(hdev);
833 hdev->le_conn_max_interval = val;
834 hci_dev_unlock(hdev);
836 return 0;
839 static int conn_max_interval_get(void *data, u64 *val)
841 struct hci_dev *hdev = data;
843 hci_dev_lock(hdev);
844 *val = hdev->le_conn_max_interval;
845 hci_dev_unlock(hdev);
847 return 0;
850 DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
851 conn_max_interval_set, "%llu\n");
853 static int conn_latency_set(void *data, u64 val)
855 struct hci_dev *hdev = data;
857 if (val > 0x01f3)
858 return -EINVAL;
860 hci_dev_lock(hdev);
861 hdev->le_conn_latency = val;
862 hci_dev_unlock(hdev);
864 return 0;
867 static int conn_latency_get(void *data, u64 *val)
869 struct hci_dev *hdev = data;
871 hci_dev_lock(hdev);
872 *val = hdev->le_conn_latency;
873 hci_dev_unlock(hdev);
875 return 0;
878 DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get,
879 conn_latency_set, "%llu\n");
881 static int supervision_timeout_set(void *data, u64 val)
883 struct hci_dev *hdev = data;
885 if (val < 0x000a || val > 0x0c80)
886 return -EINVAL;
888 hci_dev_lock(hdev);
889 hdev->le_supv_timeout = val;
890 hci_dev_unlock(hdev);
892 return 0;
895 static int supervision_timeout_get(void *data, u64 *val)
897 struct hci_dev *hdev = data;
899 hci_dev_lock(hdev);
900 *val = hdev->le_supv_timeout;
901 hci_dev_unlock(hdev);
903 return 0;
906 DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
907 supervision_timeout_set, "%llu\n");
909 static int adv_channel_map_set(void *data, u64 val)
911 struct hci_dev *hdev = data;
913 if (val < 0x01 || val > 0x07)
914 return -EINVAL;
916 hci_dev_lock(hdev);
917 hdev->le_adv_channel_map = val;
918 hci_dev_unlock(hdev);
920 return 0;
923 static int adv_channel_map_get(void *data, u64 *val)
925 struct hci_dev *hdev = data;
927 hci_dev_lock(hdev);
928 *val = hdev->le_adv_channel_map;
929 hci_dev_unlock(hdev);
931 return 0;
934 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
935 adv_channel_map_set, "%llu\n");
937 static int adv_min_interval_set(void *data, u64 val)
939 struct hci_dev *hdev = data;
941 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval)
942 return -EINVAL;
944 hci_dev_lock(hdev);
945 hdev->le_adv_min_interval = val;
946 hci_dev_unlock(hdev);
948 return 0;
951 static int adv_min_interval_get(void *data, u64 *val)
953 struct hci_dev *hdev = data;
955 hci_dev_lock(hdev);
956 *val = hdev->le_adv_min_interval;
957 hci_dev_unlock(hdev);
959 return 0;
962 DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
963 adv_min_interval_set, "%llu\n");
965 static int adv_max_interval_set(void *data, u64 val)
967 struct hci_dev *hdev = data;
969 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval)
970 return -EINVAL;
972 hci_dev_lock(hdev);
973 hdev->le_adv_max_interval = val;
974 hci_dev_unlock(hdev);
976 return 0;
979 static int adv_max_interval_get(void *data, u64 *val)
981 struct hci_dev *hdev = data;
983 hci_dev_lock(hdev);
984 *val = hdev->le_adv_max_interval;
985 hci_dev_unlock(hdev);
987 return 0;
990 DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
991 adv_max_interval_set, "%llu\n");
993 static int min_key_size_set(void *data, u64 val)
995 struct hci_dev *hdev = data;
997 if (val > hdev->le_max_key_size || val < SMP_MIN_ENC_KEY_SIZE)
998 return -EINVAL;
1000 hci_dev_lock(hdev);
1001 hdev->le_min_key_size = val;
1002 hci_dev_unlock(hdev);
1004 return 0;
1007 static int min_key_size_get(void *data, u64 *val)
1009 struct hci_dev *hdev = data;
1011 hci_dev_lock(hdev);
1012 *val = hdev->le_min_key_size;
1013 hci_dev_unlock(hdev);
1015 return 0;
1018 DEFINE_SIMPLE_ATTRIBUTE(min_key_size_fops, min_key_size_get,
1019 min_key_size_set, "%llu\n");
1021 static int max_key_size_set(void *data, u64 val)
1023 struct hci_dev *hdev = data;
1025 if (val > SMP_MAX_ENC_KEY_SIZE || val < hdev->le_min_key_size)
1026 return -EINVAL;
1028 hci_dev_lock(hdev);
1029 hdev->le_max_key_size = val;
1030 hci_dev_unlock(hdev);
1032 return 0;
1035 static int max_key_size_get(void *data, u64 *val)
1037 struct hci_dev *hdev = data;
1039 hci_dev_lock(hdev);
1040 *val = hdev->le_max_key_size;
1041 hci_dev_unlock(hdev);
1043 return 0;
1046 DEFINE_SIMPLE_ATTRIBUTE(max_key_size_fops, max_key_size_get,
1047 max_key_size_set, "%llu\n");
1049 static int auth_payload_timeout_set(void *data, u64 val)
1051 struct hci_dev *hdev = data;
1053 if (val < 0x0001 || val > 0xffff)
1054 return -EINVAL;
1056 hci_dev_lock(hdev);
1057 hdev->auth_payload_timeout = val;
1058 hci_dev_unlock(hdev);
1060 return 0;
1063 static int auth_payload_timeout_get(void *data, u64 *val)
1065 struct hci_dev *hdev = data;
1067 hci_dev_lock(hdev);
1068 *val = hdev->auth_payload_timeout;
1069 hci_dev_unlock(hdev);
1071 return 0;
1074 DEFINE_SIMPLE_ATTRIBUTE(auth_payload_timeout_fops,
1075 auth_payload_timeout_get,
1076 auth_payload_timeout_set, "%llu\n");
1078 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
1079 HCI_QUIRK_STRICT_DUPLICATE_FILTER);
1080 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
1081 HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
1083 void hci_debugfs_create_le(struct hci_dev *hdev)
1085 debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
1086 &identity_fops);
1087 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
1088 &rpa_timeout_fops);
1089 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
1090 &random_address_fops);
1091 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
1092 &static_address_fops);
1094 /* For controllers with a public address, provide a debug
1095 * option to force the usage of the configured static
1096 * address. By default the public address is used.
1098 if (bacmp(&hdev->bdaddr, BDADDR_ANY))
1099 debugfs_create_file("force_static_address", 0644,
1100 hdev->debugfs, hdev,
1101 &force_static_address_fops);
1103 debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
1104 &hdev->le_white_list_size);
1105 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
1106 &white_list_fops);
1107 debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs,
1108 &hdev->le_resolv_list_size);
1109 debugfs_create_file("resolv_list", 0444, hdev->debugfs, hdev,
1110 &resolv_list_fops);
1111 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
1112 hdev, &identity_resolving_keys_fops);
1113 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
1114 &long_term_keys_fops);
1115 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
1116 &conn_min_interval_fops);
1117 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
1118 &conn_max_interval_fops);
1119 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
1120 &conn_latency_fops);
1121 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
1122 &supervision_timeout_fops);
1123 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
1124 &adv_channel_map_fops);
1125 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
1126 &adv_min_interval_fops);
1127 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
1128 &adv_max_interval_fops);
1129 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
1130 &hdev->discov_interleaved_timeout);
1131 debugfs_create_file("min_key_size", 0644, hdev->debugfs, hdev,
1132 &min_key_size_fops);
1133 debugfs_create_file("max_key_size", 0644, hdev->debugfs, hdev,
1134 &max_key_size_fops);
1135 debugfs_create_file("auth_payload_timeout", 0644, hdev->debugfs, hdev,
1136 &auth_payload_timeout_fops);
1138 debugfs_create_file("quirk_strict_duplicate_filter", 0644,
1139 hdev->debugfs, hdev,
1140 &quirk_strict_duplicate_filter_fops);
1141 debugfs_create_file("quirk_simultaneous_discovery", 0644,
1142 hdev->debugfs, hdev,
1143 &quirk_simultaneous_discovery_fops);
1146 void hci_debugfs_create_conn(struct hci_conn *conn)
1148 struct hci_dev *hdev = conn->hdev;
1149 char name[6];
1151 if (IS_ERR_OR_NULL(hdev->debugfs))
1152 return;
1154 snprintf(name, sizeof(name), "%u", conn->handle);
1155 conn->debugfs = debugfs_create_dir(name, hdev->debugfs);