Loading...
1/*
2 BlueZ - Bluetooth protocol stack for Linux
3
4 Copyright (C) 2014 Intel Corporation
5
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;
9
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.
18
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.
22*/
23
24#include <linux/debugfs.h>
25
26#include <net/bluetooth/bluetooth.h>
27#include <net/bluetooth/hci_core.h>
28
29#include "hci_debugfs.h"
30
31#define DEFINE_QUIRK_ATTRIBUTE(__name, __quirk) \
32static ssize_t __name ## _read(struct file *file, \
33 char __user *user_buf, \
34 size_t count, loff_t *ppos) \
35{ \
36 struct hci_dev *hdev = file->private_data; \
37 char buf[3]; \
38 \
39 buf[0] = test_bit(__quirk, &hdev->quirks) ? 'Y' : 'N'; \
40 buf[1] = '\n'; \
41 buf[2] = '\0'; \
42 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); \
43} \
44 \
45static ssize_t __name ## _write(struct file *file, \
46 const char __user *user_buf, \
47 size_t count, loff_t *ppos) \
48{ \
49 struct hci_dev *hdev = file->private_data; \
50 bool enable; \
51 int err; \
52 \
53 if (test_bit(HCI_UP, &hdev->flags)) \
54 return -EBUSY; \
55 \
56 err = kstrtobool_from_user(user_buf, count, &enable); \
57 if (err) \
58 return err; \
59 \
60 if (enable == test_bit(__quirk, &hdev->quirks)) \
61 return -EALREADY; \
62 \
63 change_bit(__quirk, &hdev->quirks); \
64 \
65 return count; \
66} \
67 \
68static const struct file_operations __name ## _fops = { \
69 .open = simple_open, \
70 .read = __name ## _read, \
71 .write = __name ## _write, \
72 .llseek = default_llseek, \
73} \
74
75#define DEFINE_INFO_ATTRIBUTE(__name, __field) \
76static int __name ## _show(struct seq_file *f, void *ptr) \
77{ \
78 struct hci_dev *hdev = f->private; \
79 \
80 hci_dev_lock(hdev); \
81 seq_printf(f, "%s\n", hdev->__field ? : ""); \
82 hci_dev_unlock(hdev); \
83 \
84 return 0; \
85} \
86 \
87DEFINE_SHOW_ATTRIBUTE(__name)
88
89static int features_show(struct seq_file *f, void *ptr)
90{
91 struct hci_dev *hdev = f->private;
92 u8 p;
93
94 hci_dev_lock(hdev);
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);
99 hci_dev_unlock(hdev);
100
101 return 0;
102}
103
104DEFINE_SHOW_ATTRIBUTE(features);
105
106static int device_id_show(struct seq_file *f, void *ptr)
107{
108 struct hci_dev *hdev = f->private;
109
110 hci_dev_lock(hdev);
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);
114
115 return 0;
116}
117
118DEFINE_SHOW_ATTRIBUTE(device_id);
119
120static int device_list_show(struct seq_file *f, void *ptr)
121{
122 struct hci_dev *hdev = f->private;
123 struct hci_conn_params *p;
124 struct bdaddr_list *b;
125
126 hci_dev_lock(hdev);
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,
131 p->auto_connect);
132 }
133 hci_dev_unlock(hdev);
134
135 return 0;
136}
137
138DEFINE_SHOW_ATTRIBUTE(device_list);
139
140static int blacklist_show(struct seq_file *f, void *p)
141{
142 struct hci_dev *hdev = f->private;
143 struct bdaddr_list *b;
144
145 hci_dev_lock(hdev);
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);
149
150 return 0;
151}
152
153DEFINE_SHOW_ATTRIBUTE(blacklist);
154
155static int uuids_show(struct seq_file *f, void *p)
156{
157 struct hci_dev *hdev = f->private;
158 struct bt_uuid *uuid;
159
160 hci_dev_lock(hdev);
161 list_for_each_entry(uuid, &hdev->uuids, list) {
162 u8 i, val[16];
163
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.
167 */
168 for (i = 0; i < 16; i++)
169 val[i] = uuid->uuid[15 - i];
170
171 seq_printf(f, "%pUb\n", val);
172 }
173 hci_dev_unlock(hdev);
174
175 return 0;
176}
177
178DEFINE_SHOW_ATTRIBUTE(uuids);
179
180static int remote_oob_show(struct seq_file *f, void *ptr)
181{
182 struct hci_dev *hdev = f->private;
183 struct oob_data *data;
184
185 hci_dev_lock(hdev);
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);
191 }
192 hci_dev_unlock(hdev);
193
194 return 0;
195}
196
197DEFINE_SHOW_ATTRIBUTE(remote_oob);
198
199static int conn_info_min_age_set(void *data, u64 val)
200{
201 struct hci_dev *hdev = data;
202
203 if (val == 0 || val > hdev->conn_info_max_age)
204 return -EINVAL;
205
206 hci_dev_lock(hdev);
207 hdev->conn_info_min_age = val;
208 hci_dev_unlock(hdev);
209
210 return 0;
211}
212
213static int conn_info_min_age_get(void *data, u64 *val)
214{
215 struct hci_dev *hdev = data;
216
217 hci_dev_lock(hdev);
218 *val = hdev->conn_info_min_age;
219 hci_dev_unlock(hdev);
220
221 return 0;
222}
223
224DEFINE_SIMPLE_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get,
225 conn_info_min_age_set, "%llu\n");
226
227static int conn_info_max_age_set(void *data, u64 val)
228{
229 struct hci_dev *hdev = data;
230
231 if (val == 0 || val < hdev->conn_info_min_age)
232 return -EINVAL;
233
234 hci_dev_lock(hdev);
235 hdev->conn_info_max_age = val;
236 hci_dev_unlock(hdev);
237
238 return 0;
239}
240
241static int conn_info_max_age_get(void *data, u64 *val)
242{
243 struct hci_dev *hdev = data;
244
245 hci_dev_lock(hdev);
246 *val = hdev->conn_info_max_age;
247 hci_dev_unlock(hdev);
248
249 return 0;
250}
251
252DEFINE_SIMPLE_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get,
253 conn_info_max_age_set, "%llu\n");
254
255static ssize_t use_debug_keys_read(struct file *file, char __user *user_buf,
256 size_t count, loff_t *ppos)
257{
258 struct hci_dev *hdev = file->private_data;
259 char buf[3];
260
261 buf[0] = hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS) ? 'Y': 'N';
262 buf[1] = '\n';
263 buf[2] = '\0';
264 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
265}
266
267static const struct file_operations use_debug_keys_fops = {
268 .open = simple_open,
269 .read = use_debug_keys_read,
270 .llseek = default_llseek,
271};
272
273static ssize_t sc_only_mode_read(struct file *file, char __user *user_buf,
274 size_t count, loff_t *ppos)
275{
276 struct hci_dev *hdev = file->private_data;
277 char buf[3];
278
279 buf[0] = hci_dev_test_flag(hdev, HCI_SC_ONLY) ? 'Y': 'N';
280 buf[1] = '\n';
281 buf[2] = '\0';
282 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
283}
284
285static const struct file_operations sc_only_mode_fops = {
286 .open = simple_open,
287 .read = sc_only_mode_read,
288 .llseek = default_llseek,
289};
290
291DEFINE_INFO_ATTRIBUTE(hardware_info, hw_info);
292DEFINE_INFO_ATTRIBUTE(firmware_info, fw_info);
293
294void hci_debugfs_create_common(struct hci_dev *hdev)
295{
296 debugfs_create_file("features", 0444, hdev->debugfs, hdev,
297 &features_fops);
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,
305 &device_id_fops);
306
307 debugfs_create_file("device_list", 0444, hdev->debugfs, hdev,
308 &device_list_fops);
309 debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev,
310 &blacklist_fops);
311 debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops);
312 debugfs_create_file("remote_oob", 0400, hdev->debugfs, hdev,
313 &remote_oob_fops);
314
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);
319
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);
323
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);
327
328 if (hdev->hw_info)
329 debugfs_create_file("hardware_info", 0444, hdev->debugfs,
330 hdev, &hardware_info_fops);
331
332 if (hdev->fw_info)
333 debugfs_create_file("firmware_info", 0444, hdev->debugfs,
334 hdev, &firmware_info_fops);
335}
336
337static int inquiry_cache_show(struct seq_file *f, void *p)
338{
339 struct hci_dev *hdev = f->private;
340 struct discovery_state *cache = &hdev->discovery;
341 struct inquiry_entry *e;
342
343 hci_dev_lock(hdev);
344
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",
348 &data->bdaddr,
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);
354 }
355
356 hci_dev_unlock(hdev);
357
358 return 0;
359}
360
361DEFINE_SHOW_ATTRIBUTE(inquiry_cache);
362
363static int link_keys_show(struct seq_file *f, void *ptr)
364{
365 struct hci_dev *hdev = f->private;
366 struct link_key *key;
367
368 rcu_read_lock();
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);
372 rcu_read_unlock();
373
374 return 0;
375}
376
377DEFINE_SHOW_ATTRIBUTE(link_keys);
378
379static int dev_class_show(struct seq_file *f, void *ptr)
380{
381 struct hci_dev *hdev = f->private;
382
383 hci_dev_lock(hdev);
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);
387
388 return 0;
389}
390
391DEFINE_SHOW_ATTRIBUTE(dev_class);
392
393static int voice_setting_get(void *data, u64 *val)
394{
395 struct hci_dev *hdev = data;
396
397 hci_dev_lock(hdev);
398 *val = hdev->voice_setting;
399 hci_dev_unlock(hdev);
400
401 return 0;
402}
403
404DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get,
405 NULL, "0x%4.4llx\n");
406
407static ssize_t ssp_debug_mode_read(struct file *file, char __user *user_buf,
408 size_t count, loff_t *ppos)
409{
410 struct hci_dev *hdev = file->private_data;
411 char buf[3];
412
413 buf[0] = hdev->ssp_debug_mode ? 'Y': 'N';
414 buf[1] = '\n';
415 buf[2] = '\0';
416 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
417}
418
419static const struct file_operations ssp_debug_mode_fops = {
420 .open = simple_open,
421 .read = ssp_debug_mode_read,
422 .llseek = default_llseek,
423};
424
425static int auto_accept_delay_set(void *data, u64 val)
426{
427 struct hci_dev *hdev = data;
428
429 hci_dev_lock(hdev);
430 hdev->auto_accept_delay = val;
431 hci_dev_unlock(hdev);
432
433 return 0;
434}
435
436static int min_encrypt_key_size_set(void *data, u64 val)
437{
438 struct hci_dev *hdev = data;
439
440 if (val < 1 || val > 16)
441 return -EINVAL;
442
443 hci_dev_lock(hdev);
444 hdev->min_enc_key_size = val;
445 hci_dev_unlock(hdev);
446
447 return 0;
448}
449
450static int min_encrypt_key_size_get(void *data, u64 *val)
451{
452 struct hci_dev *hdev = data;
453
454 hci_dev_lock(hdev);
455 *val = hdev->min_enc_key_size;
456 hci_dev_unlock(hdev);
457
458 return 0;
459}
460
461DEFINE_SIMPLE_ATTRIBUTE(min_encrypt_key_size_fops,
462 min_encrypt_key_size_get,
463 min_encrypt_key_size_set, "%llu\n");
464
465static int auto_accept_delay_get(void *data, u64 *val)
466{
467 struct hci_dev *hdev = data;
468
469 hci_dev_lock(hdev);
470 *val = hdev->auto_accept_delay;
471 hci_dev_unlock(hdev);
472
473 return 0;
474}
475
476DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
477 auto_accept_delay_set, "%llu\n");
478
479static int idle_timeout_set(void *data, u64 val)
480{
481 struct hci_dev *hdev = data;
482
483 if (val != 0 && (val < 500 || val > 3600000))
484 return -EINVAL;
485
486 hci_dev_lock(hdev);
487 hdev->idle_timeout = val;
488 hci_dev_unlock(hdev);
489
490 return 0;
491}
492
493static int idle_timeout_get(void *data, u64 *val)
494{
495 struct hci_dev *hdev = data;
496
497 hci_dev_lock(hdev);
498 *val = hdev->idle_timeout;
499 hci_dev_unlock(hdev);
500
501 return 0;
502}
503
504DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
505 idle_timeout_set, "%llu\n");
506
507static int sniff_min_interval_set(void *data, u64 val)
508{
509 struct hci_dev *hdev = data;
510
511 if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
512 return -EINVAL;
513
514 hci_dev_lock(hdev);
515 hdev->sniff_min_interval = val;
516 hci_dev_unlock(hdev);
517
518 return 0;
519}
520
521static int sniff_min_interval_get(void *data, u64 *val)
522{
523 struct hci_dev *hdev = data;
524
525 hci_dev_lock(hdev);
526 *val = hdev->sniff_min_interval;
527 hci_dev_unlock(hdev);
528
529 return 0;
530}
531
532DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
533 sniff_min_interval_set, "%llu\n");
534
535static int sniff_max_interval_set(void *data, u64 val)
536{
537 struct hci_dev *hdev = data;
538
539 if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
540 return -EINVAL;
541
542 hci_dev_lock(hdev);
543 hdev->sniff_max_interval = val;
544 hci_dev_unlock(hdev);
545
546 return 0;
547}
548
549static int sniff_max_interval_get(void *data, u64 *val)
550{
551 struct hci_dev *hdev = data;
552
553 hci_dev_lock(hdev);
554 *val = hdev->sniff_max_interval;
555 hci_dev_unlock(hdev);
556
557 return 0;
558}
559
560DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
561 sniff_max_interval_set, "%llu\n");
562
563void hci_debugfs_create_bredr(struct hci_dev *hdev)
564{
565 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev,
566 &inquiry_cache_fops);
567 debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev,
568 &link_keys_fops);
569 debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev,
570 &dev_class_fops);
571 debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev,
572 &voice_setting_fops);
573
574 if (lmp_ssp_capable(hdev)) {
575 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
576 hdev, &ssp_debug_mode_fops);
577 debugfs_create_file("min_encrypt_key_size", 0644, hdev->debugfs,
578 hdev, &min_encrypt_key_size_fops);
579 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
580 hdev, &auto_accept_delay_fops);
581 }
582
583 if (lmp_sniff_capable(hdev)) {
584 debugfs_create_file("idle_timeout", 0644, hdev->debugfs,
585 hdev, &idle_timeout_fops);
586 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs,
587 hdev, &sniff_min_interval_fops);
588 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs,
589 hdev, &sniff_max_interval_fops);
590 }
591}
592
593static int identity_show(struct seq_file *f, void *p)
594{
595 struct hci_dev *hdev = f->private;
596 bdaddr_t addr;
597 u8 addr_type;
598
599 hci_dev_lock(hdev);
600
601 hci_copy_identity_address(hdev, &addr, &addr_type);
602
603 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type,
604 16, hdev->irk, &hdev->rpa);
605
606 hci_dev_unlock(hdev);
607
608 return 0;
609}
610
611DEFINE_SHOW_ATTRIBUTE(identity);
612
613static int rpa_timeout_set(void *data, u64 val)
614{
615 struct hci_dev *hdev = data;
616
617 /* Require the RPA timeout to be at least 30 seconds and at most
618 * 24 hours.
619 */
620 if (val < 30 || val > (60 * 60 * 24))
621 return -EINVAL;
622
623 hci_dev_lock(hdev);
624 hdev->rpa_timeout = val;
625 hci_dev_unlock(hdev);
626
627 return 0;
628}
629
630static int rpa_timeout_get(void *data, u64 *val)
631{
632 struct hci_dev *hdev = data;
633
634 hci_dev_lock(hdev);
635 *val = hdev->rpa_timeout;
636 hci_dev_unlock(hdev);
637
638 return 0;
639}
640
641DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
642 rpa_timeout_set, "%llu\n");
643
644static int random_address_show(struct seq_file *f, void *p)
645{
646 struct hci_dev *hdev = f->private;
647
648 hci_dev_lock(hdev);
649 seq_printf(f, "%pMR\n", &hdev->random_addr);
650 hci_dev_unlock(hdev);
651
652 return 0;
653}
654
655DEFINE_SHOW_ATTRIBUTE(random_address);
656
657static int static_address_show(struct seq_file *f, void *p)
658{
659 struct hci_dev *hdev = f->private;
660
661 hci_dev_lock(hdev);
662 seq_printf(f, "%pMR\n", &hdev->static_addr);
663 hci_dev_unlock(hdev);
664
665 return 0;
666}
667
668DEFINE_SHOW_ATTRIBUTE(static_address);
669
670static ssize_t force_static_address_read(struct file *file,
671 char __user *user_buf,
672 size_t count, loff_t *ppos)
673{
674 struct hci_dev *hdev = file->private_data;
675 char buf[3];
676
677 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y': 'N';
678 buf[1] = '\n';
679 buf[2] = '\0';
680 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
681}
682
683static ssize_t force_static_address_write(struct file *file,
684 const char __user *user_buf,
685 size_t count, loff_t *ppos)
686{
687 struct hci_dev *hdev = file->private_data;
688 bool enable;
689 int err;
690
691 if (test_bit(HCI_UP, &hdev->flags))
692 return -EBUSY;
693
694 err = kstrtobool_from_user(user_buf, count, &enable);
695 if (err)
696 return err;
697
698 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
699 return -EALREADY;
700
701 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
702
703 return count;
704}
705
706static const struct file_operations force_static_address_fops = {
707 .open = simple_open,
708 .read = force_static_address_read,
709 .write = force_static_address_write,
710 .llseek = default_llseek,
711};
712
713static int white_list_show(struct seq_file *f, void *ptr)
714{
715 struct hci_dev *hdev = f->private;
716 struct bdaddr_list *b;
717
718 hci_dev_lock(hdev);
719 list_for_each_entry(b, &hdev->le_white_list, list)
720 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
721 hci_dev_unlock(hdev);
722
723 return 0;
724}
725
726DEFINE_SHOW_ATTRIBUTE(white_list);
727
728static int resolv_list_show(struct seq_file *f, void *ptr)
729{
730 struct hci_dev *hdev = f->private;
731 struct bdaddr_list *b;
732
733 hci_dev_lock(hdev);
734 list_for_each_entry(b, &hdev->le_resolv_list, list)
735 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
736 hci_dev_unlock(hdev);
737
738 return 0;
739}
740
741DEFINE_SHOW_ATTRIBUTE(resolv_list);
742
743static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
744{
745 struct hci_dev *hdev = f->private;
746 struct smp_irk *irk;
747
748 rcu_read_lock();
749 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
750 seq_printf(f, "%pMR (type %u) %*phN %pMR\n",
751 &irk->bdaddr, irk->addr_type,
752 16, irk->val, &irk->rpa);
753 }
754 rcu_read_unlock();
755
756 return 0;
757}
758
759DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
760
761static int long_term_keys_show(struct seq_file *f, void *ptr)
762{
763 struct hci_dev *hdev = f->private;
764 struct smp_ltk *ltk;
765
766 rcu_read_lock();
767 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list)
768 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n",
769 <k->bdaddr, ltk->bdaddr_type, ltk->authenticated,
770 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv),
771 __le64_to_cpu(ltk->rand), 16, ltk->val);
772 rcu_read_unlock();
773
774 return 0;
775}
776
777DEFINE_SHOW_ATTRIBUTE(long_term_keys);
778
779static int conn_min_interval_set(void *data, u64 val)
780{
781 struct hci_dev *hdev = data;
782
783 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval)
784 return -EINVAL;
785
786 hci_dev_lock(hdev);
787 hdev->le_conn_min_interval = val;
788 hci_dev_unlock(hdev);
789
790 return 0;
791}
792
793static int conn_min_interval_get(void *data, u64 *val)
794{
795 struct hci_dev *hdev = data;
796
797 hci_dev_lock(hdev);
798 *val = hdev->le_conn_min_interval;
799 hci_dev_unlock(hdev);
800
801 return 0;
802}
803
804DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
805 conn_min_interval_set, "%llu\n");
806
807static int conn_max_interval_set(void *data, u64 val)
808{
809 struct hci_dev *hdev = data;
810
811 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval)
812 return -EINVAL;
813
814 hci_dev_lock(hdev);
815 hdev->le_conn_max_interval = val;
816 hci_dev_unlock(hdev);
817
818 return 0;
819}
820
821static int conn_max_interval_get(void *data, u64 *val)
822{
823 struct hci_dev *hdev = data;
824
825 hci_dev_lock(hdev);
826 *val = hdev->le_conn_max_interval;
827 hci_dev_unlock(hdev);
828
829 return 0;
830}
831
832DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
833 conn_max_interval_set, "%llu\n");
834
835static int conn_latency_set(void *data, u64 val)
836{
837 struct hci_dev *hdev = data;
838
839 if (val > 0x01f3)
840 return -EINVAL;
841
842 hci_dev_lock(hdev);
843 hdev->le_conn_latency = val;
844 hci_dev_unlock(hdev);
845
846 return 0;
847}
848
849static int conn_latency_get(void *data, u64 *val)
850{
851 struct hci_dev *hdev = data;
852
853 hci_dev_lock(hdev);
854 *val = hdev->le_conn_latency;
855 hci_dev_unlock(hdev);
856
857 return 0;
858}
859
860DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get,
861 conn_latency_set, "%llu\n");
862
863static int supervision_timeout_set(void *data, u64 val)
864{
865 struct hci_dev *hdev = data;
866
867 if (val < 0x000a || val > 0x0c80)
868 return -EINVAL;
869
870 hci_dev_lock(hdev);
871 hdev->le_supv_timeout = val;
872 hci_dev_unlock(hdev);
873
874 return 0;
875}
876
877static int supervision_timeout_get(void *data, u64 *val)
878{
879 struct hci_dev *hdev = data;
880
881 hci_dev_lock(hdev);
882 *val = hdev->le_supv_timeout;
883 hci_dev_unlock(hdev);
884
885 return 0;
886}
887
888DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
889 supervision_timeout_set, "%llu\n");
890
891static int adv_channel_map_set(void *data, u64 val)
892{
893 struct hci_dev *hdev = data;
894
895 if (val < 0x01 || val > 0x07)
896 return -EINVAL;
897
898 hci_dev_lock(hdev);
899 hdev->le_adv_channel_map = val;
900 hci_dev_unlock(hdev);
901
902 return 0;
903}
904
905static int adv_channel_map_get(void *data, u64 *val)
906{
907 struct hci_dev *hdev = data;
908
909 hci_dev_lock(hdev);
910 *val = hdev->le_adv_channel_map;
911 hci_dev_unlock(hdev);
912
913 return 0;
914}
915
916DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
917 adv_channel_map_set, "%llu\n");
918
919static int adv_min_interval_set(void *data, u64 val)
920{
921 struct hci_dev *hdev = data;
922
923 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval)
924 return -EINVAL;
925
926 hci_dev_lock(hdev);
927 hdev->le_adv_min_interval = val;
928 hci_dev_unlock(hdev);
929
930 return 0;
931}
932
933static int adv_min_interval_get(void *data, u64 *val)
934{
935 struct hci_dev *hdev = data;
936
937 hci_dev_lock(hdev);
938 *val = hdev->le_adv_min_interval;
939 hci_dev_unlock(hdev);
940
941 return 0;
942}
943
944DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
945 adv_min_interval_set, "%llu\n");
946
947static int adv_max_interval_set(void *data, u64 val)
948{
949 struct hci_dev *hdev = data;
950
951 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval)
952 return -EINVAL;
953
954 hci_dev_lock(hdev);
955 hdev->le_adv_max_interval = val;
956 hci_dev_unlock(hdev);
957
958 return 0;
959}
960
961static int adv_max_interval_get(void *data, u64 *val)
962{
963 struct hci_dev *hdev = data;
964
965 hci_dev_lock(hdev);
966 *val = hdev->le_adv_max_interval;
967 hci_dev_unlock(hdev);
968
969 return 0;
970}
971
972DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
973 adv_max_interval_set, "%llu\n");
974
975static int auth_payload_timeout_set(void *data, u64 val)
976{
977 struct hci_dev *hdev = data;
978
979 if (val < 0x0001 || val > 0xffff)
980 return -EINVAL;
981
982 hci_dev_lock(hdev);
983 hdev->auth_payload_timeout = val;
984 hci_dev_unlock(hdev);
985
986 return 0;
987}
988
989static int auth_payload_timeout_get(void *data, u64 *val)
990{
991 struct hci_dev *hdev = data;
992
993 hci_dev_lock(hdev);
994 *val = hdev->auth_payload_timeout;
995 hci_dev_unlock(hdev);
996
997 return 0;
998}
999
1000DEFINE_SIMPLE_ATTRIBUTE(auth_payload_timeout_fops,
1001 auth_payload_timeout_get,
1002 auth_payload_timeout_set, "%llu\n");
1003
1004DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
1005 HCI_QUIRK_STRICT_DUPLICATE_FILTER);
1006DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
1007 HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
1008
1009void hci_debugfs_create_le(struct hci_dev *hdev)
1010{
1011 debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
1012 &identity_fops);
1013 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
1014 &rpa_timeout_fops);
1015 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
1016 &random_address_fops);
1017 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
1018 &static_address_fops);
1019
1020 /* For controllers with a public address, provide a debug
1021 * option to force the usage of the configured static
1022 * address. By default the public address is used.
1023 */
1024 if (bacmp(&hdev->bdaddr, BDADDR_ANY))
1025 debugfs_create_file("force_static_address", 0644,
1026 hdev->debugfs, hdev,
1027 &force_static_address_fops);
1028
1029 debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
1030 &hdev->le_white_list_size);
1031 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
1032 &white_list_fops);
1033 debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs,
1034 &hdev->le_resolv_list_size);
1035 debugfs_create_file("resolv_list", 0444, hdev->debugfs, hdev,
1036 &resolv_list_fops);
1037 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
1038 hdev, &identity_resolving_keys_fops);
1039 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
1040 &long_term_keys_fops);
1041 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
1042 &conn_min_interval_fops);
1043 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
1044 &conn_max_interval_fops);
1045 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
1046 &conn_latency_fops);
1047 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
1048 &supervision_timeout_fops);
1049 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
1050 &adv_channel_map_fops);
1051 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
1052 &adv_min_interval_fops);
1053 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
1054 &adv_max_interval_fops);
1055 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
1056 &hdev->discov_interleaved_timeout);
1057 debugfs_create_file("auth_payload_timeout", 0644, hdev->debugfs, hdev,
1058 &auth_payload_timeout_fops);
1059
1060 debugfs_create_file("quirk_strict_duplicate_filter", 0644,
1061 hdev->debugfs, hdev,
1062 &quirk_strict_duplicate_filter_fops);
1063 debugfs_create_file("quirk_simultaneous_discovery", 0644,
1064 hdev->debugfs, hdev,
1065 &quirk_simultaneous_discovery_fops);
1066}
1067
1068void hci_debugfs_create_conn(struct hci_conn *conn)
1069{
1070 struct hci_dev *hdev = conn->hdev;
1071 char name[6];
1072
1073 if (IS_ERR_OR_NULL(hdev->debugfs))
1074 return;
1075
1076 snprintf(name, sizeof(name), "%u", conn->handle);
1077 conn->debugfs = debugfs_create_dir(name, hdev->debugfs);
1078}
1/*
2 BlueZ - Bluetooth protocol stack for Linux
3
4 Copyright (C) 2014 Intel Corporation
5
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;
9
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.
18
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.
22*/
23
24#include <linux/debugfs.h>
25
26#include <net/bluetooth/bluetooth.h>
27#include <net/bluetooth/hci_core.h>
28
29#include "hci_debugfs.h"
30
31#define DEFINE_QUIRK_ATTRIBUTE(__name, __quirk) \
32static ssize_t __name ## _read(struct file *file, \
33 char __user *user_buf, \
34 size_t count, loff_t *ppos) \
35{ \
36 struct hci_dev *hdev = file->private_data; \
37 char buf[3]; \
38 \
39 buf[0] = test_bit(__quirk, &hdev->quirks) ? 'Y' : 'N'; \
40 buf[1] = '\n'; \
41 buf[2] = '\0'; \
42 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); \
43} \
44 \
45static ssize_t __name ## _write(struct file *file, \
46 const char __user *user_buf, \
47 size_t count, loff_t *ppos) \
48{ \
49 struct hci_dev *hdev = file->private_data; \
50 char buf[32]; \
51 size_t buf_size = min(count, (sizeof(buf) - 1)); \
52 bool enable; \
53 \
54 if (test_bit(HCI_UP, &hdev->flags)) \
55 return -EBUSY; \
56 \
57 if (copy_from_user(buf, user_buf, buf_size)) \
58 return -EFAULT; \
59 \
60 buf[buf_size] = '\0'; \
61 if (strtobool(buf, &enable)) \
62 return -EINVAL; \
63 \
64 if (enable == test_bit(__quirk, &hdev->quirks)) \
65 return -EALREADY; \
66 \
67 change_bit(__quirk, &hdev->quirks); \
68 \
69 return count; \
70} \
71 \
72static const struct file_operations __name ## _fops = { \
73 .open = simple_open, \
74 .read = __name ## _read, \
75 .write = __name ## _write, \
76 .llseek = default_llseek, \
77} \
78
79static int features_show(struct seq_file *f, void *ptr)
80{
81 struct hci_dev *hdev = f->private;
82 u8 p;
83
84 hci_dev_lock(hdev);
85 for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) {
86 seq_printf(f, "%2u: 0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x "
87 "0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x\n", p,
88 hdev->features[p][0], hdev->features[p][1],
89 hdev->features[p][2], hdev->features[p][3],
90 hdev->features[p][4], hdev->features[p][5],
91 hdev->features[p][6], hdev->features[p][7]);
92 }
93 if (lmp_le_capable(hdev))
94 seq_printf(f, "LE: 0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x "
95 "0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x\n",
96 hdev->le_features[0], hdev->le_features[1],
97 hdev->le_features[2], hdev->le_features[3],
98 hdev->le_features[4], hdev->le_features[5],
99 hdev->le_features[6], hdev->le_features[7]);
100 hci_dev_unlock(hdev);
101
102 return 0;
103}
104
105static int features_open(struct inode *inode, struct file *file)
106{
107 return single_open(file, features_show, inode->i_private);
108}
109
110static const struct file_operations features_fops = {
111 .open = features_open,
112 .read = seq_read,
113 .llseek = seq_lseek,
114 .release = single_release,
115};
116
117static int device_id_show(struct seq_file *f, void *ptr)
118{
119 struct hci_dev *hdev = f->private;
120
121 hci_dev_lock(hdev);
122 seq_printf(f, "%4.4x:%4.4x:%4.4x:%4.4x\n", hdev->devid_source,
123 hdev->devid_vendor, hdev->devid_product, hdev->devid_version);
124 hci_dev_unlock(hdev);
125
126 return 0;
127}
128
129static int device_id_open(struct inode *inode, struct file *file)
130{
131 return single_open(file, device_id_show, inode->i_private);
132}
133
134static const struct file_operations device_id_fops = {
135 .open = device_id_open,
136 .read = seq_read,
137 .llseek = seq_lseek,
138 .release = single_release,
139};
140
141static int device_list_show(struct seq_file *f, void *ptr)
142{
143 struct hci_dev *hdev = f->private;
144 struct hci_conn_params *p;
145 struct bdaddr_list *b;
146
147 hci_dev_lock(hdev);
148 list_for_each_entry(b, &hdev->whitelist, list)
149 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
150 list_for_each_entry(p, &hdev->le_conn_params, list) {
151 seq_printf(f, "%pMR (type %u) %u\n", &p->addr, p->addr_type,
152 p->auto_connect);
153 }
154 hci_dev_unlock(hdev);
155
156 return 0;
157}
158
159static int device_list_open(struct inode *inode, struct file *file)
160{
161 return single_open(file, device_list_show, inode->i_private);
162}
163
164static const struct file_operations device_list_fops = {
165 .open = device_list_open,
166 .read = seq_read,
167 .llseek = seq_lseek,
168 .release = single_release,
169};
170
171static int blacklist_show(struct seq_file *f, void *p)
172{
173 struct hci_dev *hdev = f->private;
174 struct bdaddr_list *b;
175
176 hci_dev_lock(hdev);
177 list_for_each_entry(b, &hdev->blacklist, list)
178 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
179 hci_dev_unlock(hdev);
180
181 return 0;
182}
183
184static int blacklist_open(struct inode *inode, struct file *file)
185{
186 return single_open(file, blacklist_show, inode->i_private);
187}
188
189static const struct file_operations blacklist_fops = {
190 .open = blacklist_open,
191 .read = seq_read,
192 .llseek = seq_lseek,
193 .release = single_release,
194};
195
196static int uuids_show(struct seq_file *f, void *p)
197{
198 struct hci_dev *hdev = f->private;
199 struct bt_uuid *uuid;
200
201 hci_dev_lock(hdev);
202 list_for_each_entry(uuid, &hdev->uuids, list) {
203 u8 i, val[16];
204
205 /* The Bluetooth UUID values are stored in big endian,
206 * but with reversed byte order. So convert them into
207 * the right order for the %pUb modifier.
208 */
209 for (i = 0; i < 16; i++)
210 val[i] = uuid->uuid[15 - i];
211
212 seq_printf(f, "%pUb\n", val);
213 }
214 hci_dev_unlock(hdev);
215
216 return 0;
217}
218
219static int uuids_open(struct inode *inode, struct file *file)
220{
221 return single_open(file, uuids_show, inode->i_private);
222}
223
224static const struct file_operations uuids_fops = {
225 .open = uuids_open,
226 .read = seq_read,
227 .llseek = seq_lseek,
228 .release = single_release,
229};
230
231static int remote_oob_show(struct seq_file *f, void *ptr)
232{
233 struct hci_dev *hdev = f->private;
234 struct oob_data *data;
235
236 hci_dev_lock(hdev);
237 list_for_each_entry(data, &hdev->remote_oob_data, list) {
238 seq_printf(f, "%pMR (type %u) %u %*phN %*phN %*phN %*phN\n",
239 &data->bdaddr, data->bdaddr_type, data->present,
240 16, data->hash192, 16, data->rand192,
241 16, data->hash256, 16, data->rand256);
242 }
243 hci_dev_unlock(hdev);
244
245 return 0;
246}
247
248static int remote_oob_open(struct inode *inode, struct file *file)
249{
250 return single_open(file, remote_oob_show, inode->i_private);
251}
252
253static const struct file_operations remote_oob_fops = {
254 .open = remote_oob_open,
255 .read = seq_read,
256 .llseek = seq_lseek,
257 .release = single_release,
258};
259
260static int conn_info_min_age_set(void *data, u64 val)
261{
262 struct hci_dev *hdev = data;
263
264 if (val == 0 || val > hdev->conn_info_max_age)
265 return -EINVAL;
266
267 hci_dev_lock(hdev);
268 hdev->conn_info_min_age = val;
269 hci_dev_unlock(hdev);
270
271 return 0;
272}
273
274static int conn_info_min_age_get(void *data, u64 *val)
275{
276 struct hci_dev *hdev = data;
277
278 hci_dev_lock(hdev);
279 *val = hdev->conn_info_min_age;
280 hci_dev_unlock(hdev);
281
282 return 0;
283}
284
285DEFINE_SIMPLE_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get,
286 conn_info_min_age_set, "%llu\n");
287
288static int conn_info_max_age_set(void *data, u64 val)
289{
290 struct hci_dev *hdev = data;
291
292 if (val == 0 || val < hdev->conn_info_min_age)
293 return -EINVAL;
294
295 hci_dev_lock(hdev);
296 hdev->conn_info_max_age = val;
297 hci_dev_unlock(hdev);
298
299 return 0;
300}
301
302static int conn_info_max_age_get(void *data, u64 *val)
303{
304 struct hci_dev *hdev = data;
305
306 hci_dev_lock(hdev);
307 *val = hdev->conn_info_max_age;
308 hci_dev_unlock(hdev);
309
310 return 0;
311}
312
313DEFINE_SIMPLE_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get,
314 conn_info_max_age_set, "%llu\n");
315
316static ssize_t use_debug_keys_read(struct file *file, char __user *user_buf,
317 size_t count, loff_t *ppos)
318{
319 struct hci_dev *hdev = file->private_data;
320 char buf[3];
321
322 buf[0] = hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS) ? 'Y': 'N';
323 buf[1] = '\n';
324 buf[2] = '\0';
325 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
326}
327
328static const struct file_operations use_debug_keys_fops = {
329 .open = simple_open,
330 .read = use_debug_keys_read,
331 .llseek = default_llseek,
332};
333
334static ssize_t sc_only_mode_read(struct file *file, char __user *user_buf,
335 size_t count, loff_t *ppos)
336{
337 struct hci_dev *hdev = file->private_data;
338 char buf[3];
339
340 buf[0] = hci_dev_test_flag(hdev, HCI_SC_ONLY) ? 'Y': 'N';
341 buf[1] = '\n';
342 buf[2] = '\0';
343 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
344}
345
346static const struct file_operations sc_only_mode_fops = {
347 .open = simple_open,
348 .read = sc_only_mode_read,
349 .llseek = default_llseek,
350};
351
352void hci_debugfs_create_common(struct hci_dev *hdev)
353{
354 debugfs_create_file("features", 0444, hdev->debugfs, hdev,
355 &features_fops);
356 debugfs_create_u16("manufacturer", 0444, hdev->debugfs,
357 &hdev->manufacturer);
358 debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver);
359 debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev);
360 debugfs_create_u8("hardware_error", 0444, hdev->debugfs,
361 &hdev->hw_error_code);
362 debugfs_create_file("device_id", 0444, hdev->debugfs, hdev,
363 &device_id_fops);
364
365 debugfs_create_file("device_list", 0444, hdev->debugfs, hdev,
366 &device_list_fops);
367 debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev,
368 &blacklist_fops);
369 debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops);
370 debugfs_create_file("remote_oob", 0400, hdev->debugfs, hdev,
371 &remote_oob_fops);
372
373 debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev,
374 &conn_info_min_age_fops);
375 debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev,
376 &conn_info_max_age_fops);
377
378 if (lmp_ssp_capable(hdev) || lmp_le_capable(hdev))
379 debugfs_create_file("use_debug_keys", 0444, hdev->debugfs,
380 hdev, &use_debug_keys_fops);
381
382 if (lmp_sc_capable(hdev) || lmp_le_capable(hdev))
383 debugfs_create_file("sc_only_mode", 0444, hdev->debugfs,
384 hdev, &sc_only_mode_fops);
385}
386
387static int inquiry_cache_show(struct seq_file *f, void *p)
388{
389 struct hci_dev *hdev = f->private;
390 struct discovery_state *cache = &hdev->discovery;
391 struct inquiry_entry *e;
392
393 hci_dev_lock(hdev);
394
395 list_for_each_entry(e, &cache->all, all) {
396 struct inquiry_data *data = &e->data;
397 seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n",
398 &data->bdaddr,
399 data->pscan_rep_mode, data->pscan_period_mode,
400 data->pscan_mode, data->dev_class[2],
401 data->dev_class[1], data->dev_class[0],
402 __le16_to_cpu(data->clock_offset),
403 data->rssi, data->ssp_mode, e->timestamp);
404 }
405
406 hci_dev_unlock(hdev);
407
408 return 0;
409}
410
411static int inquiry_cache_open(struct inode *inode, struct file *file)
412{
413 return single_open(file, inquiry_cache_show, inode->i_private);
414}
415
416static const struct file_operations inquiry_cache_fops = {
417 .open = inquiry_cache_open,
418 .read = seq_read,
419 .llseek = seq_lseek,
420 .release = single_release,
421};
422
423static int link_keys_show(struct seq_file *f, void *ptr)
424{
425 struct hci_dev *hdev = f->private;
426 struct link_key *key;
427
428 rcu_read_lock();
429 list_for_each_entry_rcu(key, &hdev->link_keys, list)
430 seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type,
431 HCI_LINK_KEY_SIZE, key->val, key->pin_len);
432 rcu_read_unlock();
433
434 return 0;
435}
436
437static int link_keys_open(struct inode *inode, struct file *file)
438{
439 return single_open(file, link_keys_show, inode->i_private);
440}
441
442static const struct file_operations link_keys_fops = {
443 .open = link_keys_open,
444 .read = seq_read,
445 .llseek = seq_lseek,
446 .release = single_release,
447};
448
449static int dev_class_show(struct seq_file *f, void *ptr)
450{
451 struct hci_dev *hdev = f->private;
452
453 hci_dev_lock(hdev);
454 seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2],
455 hdev->dev_class[1], hdev->dev_class[0]);
456 hci_dev_unlock(hdev);
457
458 return 0;
459}
460
461static int dev_class_open(struct inode *inode, struct file *file)
462{
463 return single_open(file, dev_class_show, inode->i_private);
464}
465
466static const struct file_operations dev_class_fops = {
467 .open = dev_class_open,
468 .read = seq_read,
469 .llseek = seq_lseek,
470 .release = single_release,
471};
472
473static int voice_setting_get(void *data, u64 *val)
474{
475 struct hci_dev *hdev = data;
476
477 hci_dev_lock(hdev);
478 *val = hdev->voice_setting;
479 hci_dev_unlock(hdev);
480
481 return 0;
482}
483
484DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get,
485 NULL, "0x%4.4llx\n");
486
487static ssize_t ssp_debug_mode_read(struct file *file, char __user *user_buf,
488 size_t count, loff_t *ppos)
489{
490 struct hci_dev *hdev = file->private_data;
491 char buf[3];
492
493 buf[0] = hdev->ssp_debug_mode ? 'Y': 'N';
494 buf[1] = '\n';
495 buf[2] = '\0';
496 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
497}
498
499static const struct file_operations ssp_debug_mode_fops = {
500 .open = simple_open,
501 .read = ssp_debug_mode_read,
502 .llseek = default_llseek,
503};
504
505static int auto_accept_delay_set(void *data, u64 val)
506{
507 struct hci_dev *hdev = data;
508
509 hci_dev_lock(hdev);
510 hdev->auto_accept_delay = val;
511 hci_dev_unlock(hdev);
512
513 return 0;
514}
515
516static int auto_accept_delay_get(void *data, u64 *val)
517{
518 struct hci_dev *hdev = data;
519
520 hci_dev_lock(hdev);
521 *val = hdev->auto_accept_delay;
522 hci_dev_unlock(hdev);
523
524 return 0;
525}
526
527DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
528 auto_accept_delay_set, "%llu\n");
529
530static int idle_timeout_set(void *data, u64 val)
531{
532 struct hci_dev *hdev = data;
533
534 if (val != 0 && (val < 500 || val > 3600000))
535 return -EINVAL;
536
537 hci_dev_lock(hdev);
538 hdev->idle_timeout = val;
539 hci_dev_unlock(hdev);
540
541 return 0;
542}
543
544static int idle_timeout_get(void *data, u64 *val)
545{
546 struct hci_dev *hdev = data;
547
548 hci_dev_lock(hdev);
549 *val = hdev->idle_timeout;
550 hci_dev_unlock(hdev);
551
552 return 0;
553}
554
555DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
556 idle_timeout_set, "%llu\n");
557
558static int sniff_min_interval_set(void *data, u64 val)
559{
560 struct hci_dev *hdev = data;
561
562 if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
563 return -EINVAL;
564
565 hci_dev_lock(hdev);
566 hdev->sniff_min_interval = val;
567 hci_dev_unlock(hdev);
568
569 return 0;
570}
571
572static int sniff_min_interval_get(void *data, u64 *val)
573{
574 struct hci_dev *hdev = data;
575
576 hci_dev_lock(hdev);
577 *val = hdev->sniff_min_interval;
578 hci_dev_unlock(hdev);
579
580 return 0;
581}
582
583DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
584 sniff_min_interval_set, "%llu\n");
585
586static int sniff_max_interval_set(void *data, u64 val)
587{
588 struct hci_dev *hdev = data;
589
590 if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
591 return -EINVAL;
592
593 hci_dev_lock(hdev);
594 hdev->sniff_max_interval = val;
595 hci_dev_unlock(hdev);
596
597 return 0;
598}
599
600static int sniff_max_interval_get(void *data, u64 *val)
601{
602 struct hci_dev *hdev = data;
603
604 hci_dev_lock(hdev);
605 *val = hdev->sniff_max_interval;
606 hci_dev_unlock(hdev);
607
608 return 0;
609}
610
611DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
612 sniff_max_interval_set, "%llu\n");
613
614void hci_debugfs_create_bredr(struct hci_dev *hdev)
615{
616 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev,
617 &inquiry_cache_fops);
618 debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev,
619 &link_keys_fops);
620 debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev,
621 &dev_class_fops);
622 debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev,
623 &voice_setting_fops);
624
625 if (lmp_ssp_capable(hdev)) {
626 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
627 hdev, &ssp_debug_mode_fops);
628 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
629 hdev, &auto_accept_delay_fops);
630 }
631
632 if (lmp_sniff_capable(hdev)) {
633 debugfs_create_file("idle_timeout", 0644, hdev->debugfs,
634 hdev, &idle_timeout_fops);
635 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs,
636 hdev, &sniff_min_interval_fops);
637 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs,
638 hdev, &sniff_max_interval_fops);
639 }
640}
641
642static int identity_show(struct seq_file *f, void *p)
643{
644 struct hci_dev *hdev = f->private;
645 bdaddr_t addr;
646 u8 addr_type;
647
648 hci_dev_lock(hdev);
649
650 hci_copy_identity_address(hdev, &addr, &addr_type);
651
652 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type,
653 16, hdev->irk, &hdev->rpa);
654
655 hci_dev_unlock(hdev);
656
657 return 0;
658}
659
660static int identity_open(struct inode *inode, struct file *file)
661{
662 return single_open(file, identity_show, inode->i_private);
663}
664
665static const struct file_operations identity_fops = {
666 .open = identity_open,
667 .read = seq_read,
668 .llseek = seq_lseek,
669 .release = single_release,
670};
671
672static int rpa_timeout_set(void *data, u64 val)
673{
674 struct hci_dev *hdev = data;
675
676 /* Require the RPA timeout to be at least 30 seconds and at most
677 * 24 hours.
678 */
679 if (val < 30 || val > (60 * 60 * 24))
680 return -EINVAL;
681
682 hci_dev_lock(hdev);
683 hdev->rpa_timeout = val;
684 hci_dev_unlock(hdev);
685
686 return 0;
687}
688
689static int rpa_timeout_get(void *data, u64 *val)
690{
691 struct hci_dev *hdev = data;
692
693 hci_dev_lock(hdev);
694 *val = hdev->rpa_timeout;
695 hci_dev_unlock(hdev);
696
697 return 0;
698}
699
700DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
701 rpa_timeout_set, "%llu\n");
702
703static int random_address_show(struct seq_file *f, void *p)
704{
705 struct hci_dev *hdev = f->private;
706
707 hci_dev_lock(hdev);
708 seq_printf(f, "%pMR\n", &hdev->random_addr);
709 hci_dev_unlock(hdev);
710
711 return 0;
712}
713
714static int random_address_open(struct inode *inode, struct file *file)
715{
716 return single_open(file, random_address_show, inode->i_private);
717}
718
719static const struct file_operations random_address_fops = {
720 .open = random_address_open,
721 .read = seq_read,
722 .llseek = seq_lseek,
723 .release = single_release,
724};
725
726static int static_address_show(struct seq_file *f, void *p)
727{
728 struct hci_dev *hdev = f->private;
729
730 hci_dev_lock(hdev);
731 seq_printf(f, "%pMR\n", &hdev->static_addr);
732 hci_dev_unlock(hdev);
733
734 return 0;
735}
736
737static int static_address_open(struct inode *inode, struct file *file)
738{
739 return single_open(file, static_address_show, inode->i_private);
740}
741
742static const struct file_operations static_address_fops = {
743 .open = static_address_open,
744 .read = seq_read,
745 .llseek = seq_lseek,
746 .release = single_release,
747};
748
749static ssize_t force_static_address_read(struct file *file,
750 char __user *user_buf,
751 size_t count, loff_t *ppos)
752{
753 struct hci_dev *hdev = file->private_data;
754 char buf[3];
755
756 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y': 'N';
757 buf[1] = '\n';
758 buf[2] = '\0';
759 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
760}
761
762static ssize_t force_static_address_write(struct file *file,
763 const char __user *user_buf,
764 size_t count, loff_t *ppos)
765{
766 struct hci_dev *hdev = file->private_data;
767 char buf[32];
768 size_t buf_size = min(count, (sizeof(buf)-1));
769 bool enable;
770
771 if (test_bit(HCI_UP, &hdev->flags))
772 return -EBUSY;
773
774 if (copy_from_user(buf, user_buf, buf_size))
775 return -EFAULT;
776
777 buf[buf_size] = '\0';
778 if (strtobool(buf, &enable))
779 return -EINVAL;
780
781 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
782 return -EALREADY;
783
784 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
785
786 return count;
787}
788
789static const struct file_operations force_static_address_fops = {
790 .open = simple_open,
791 .read = force_static_address_read,
792 .write = force_static_address_write,
793 .llseek = default_llseek,
794};
795
796static int white_list_show(struct seq_file *f, void *ptr)
797{
798 struct hci_dev *hdev = f->private;
799 struct bdaddr_list *b;
800
801 hci_dev_lock(hdev);
802 list_for_each_entry(b, &hdev->le_white_list, list)
803 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
804 hci_dev_unlock(hdev);
805
806 return 0;
807}
808
809static int white_list_open(struct inode *inode, struct file *file)
810{
811 return single_open(file, white_list_show, inode->i_private);
812}
813
814static const struct file_operations white_list_fops = {
815 .open = white_list_open,
816 .read = seq_read,
817 .llseek = seq_lseek,
818 .release = single_release,
819};
820
821static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
822{
823 struct hci_dev *hdev = f->private;
824 struct smp_irk *irk;
825
826 rcu_read_lock();
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);
831 }
832 rcu_read_unlock();
833
834 return 0;
835}
836
837static int identity_resolving_keys_open(struct inode *inode, struct file *file)
838{
839 return single_open(file, identity_resolving_keys_show,
840 inode->i_private);
841}
842
843static const struct file_operations identity_resolving_keys_fops = {
844 .open = identity_resolving_keys_open,
845 .read = seq_read,
846 .llseek = seq_lseek,
847 .release = single_release,
848};
849
850static int long_term_keys_show(struct seq_file *f, void *ptr)
851{
852 struct hci_dev *hdev = f->private;
853 struct smp_ltk *ltk;
854
855 rcu_read_lock();
856 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list)
857 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n",
858 <k->bdaddr, ltk->bdaddr_type, ltk->authenticated,
859 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv),
860 __le64_to_cpu(ltk->rand), 16, ltk->val);
861 rcu_read_unlock();
862
863 return 0;
864}
865
866static int long_term_keys_open(struct inode *inode, struct file *file)
867{
868 return single_open(file, long_term_keys_show, inode->i_private);
869}
870
871static const struct file_operations long_term_keys_fops = {
872 .open = long_term_keys_open,
873 .read = seq_read,
874 .llseek = seq_lseek,
875 .release = single_release,
876};
877
878static int conn_min_interval_set(void *data, u64 val)
879{
880 struct hci_dev *hdev = data;
881
882 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval)
883 return -EINVAL;
884
885 hci_dev_lock(hdev);
886 hdev->le_conn_min_interval = val;
887 hci_dev_unlock(hdev);
888
889 return 0;
890}
891
892static int conn_min_interval_get(void *data, u64 *val)
893{
894 struct hci_dev *hdev = data;
895
896 hci_dev_lock(hdev);
897 *val = hdev->le_conn_min_interval;
898 hci_dev_unlock(hdev);
899
900 return 0;
901}
902
903DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
904 conn_min_interval_set, "%llu\n");
905
906static int conn_max_interval_set(void *data, u64 val)
907{
908 struct hci_dev *hdev = data;
909
910 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval)
911 return -EINVAL;
912
913 hci_dev_lock(hdev);
914 hdev->le_conn_max_interval = val;
915 hci_dev_unlock(hdev);
916
917 return 0;
918}
919
920static int conn_max_interval_get(void *data, u64 *val)
921{
922 struct hci_dev *hdev = data;
923
924 hci_dev_lock(hdev);
925 *val = hdev->le_conn_max_interval;
926 hci_dev_unlock(hdev);
927
928 return 0;
929}
930
931DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
932 conn_max_interval_set, "%llu\n");
933
934static int conn_latency_set(void *data, u64 val)
935{
936 struct hci_dev *hdev = data;
937
938 if (val > 0x01f3)
939 return -EINVAL;
940
941 hci_dev_lock(hdev);
942 hdev->le_conn_latency = val;
943 hci_dev_unlock(hdev);
944
945 return 0;
946}
947
948static int conn_latency_get(void *data, u64 *val)
949{
950 struct hci_dev *hdev = data;
951
952 hci_dev_lock(hdev);
953 *val = hdev->le_conn_latency;
954 hci_dev_unlock(hdev);
955
956 return 0;
957}
958
959DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get,
960 conn_latency_set, "%llu\n");
961
962static int supervision_timeout_set(void *data, u64 val)
963{
964 struct hci_dev *hdev = data;
965
966 if (val < 0x000a || val > 0x0c80)
967 return -EINVAL;
968
969 hci_dev_lock(hdev);
970 hdev->le_supv_timeout = val;
971 hci_dev_unlock(hdev);
972
973 return 0;
974}
975
976static int supervision_timeout_get(void *data, u64 *val)
977{
978 struct hci_dev *hdev = data;
979
980 hci_dev_lock(hdev);
981 *val = hdev->le_supv_timeout;
982 hci_dev_unlock(hdev);
983
984 return 0;
985}
986
987DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
988 supervision_timeout_set, "%llu\n");
989
990static int adv_channel_map_set(void *data, u64 val)
991{
992 struct hci_dev *hdev = data;
993
994 if (val < 0x01 || val > 0x07)
995 return -EINVAL;
996
997 hci_dev_lock(hdev);
998 hdev->le_adv_channel_map = val;
999 hci_dev_unlock(hdev);
1000
1001 return 0;
1002}
1003
1004static int adv_channel_map_get(void *data, u64 *val)
1005{
1006 struct hci_dev *hdev = data;
1007
1008 hci_dev_lock(hdev);
1009 *val = hdev->le_adv_channel_map;
1010 hci_dev_unlock(hdev);
1011
1012 return 0;
1013}
1014
1015DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
1016 adv_channel_map_set, "%llu\n");
1017
1018static int adv_min_interval_set(void *data, u64 val)
1019{
1020 struct hci_dev *hdev = data;
1021
1022 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval)
1023 return -EINVAL;
1024
1025 hci_dev_lock(hdev);
1026 hdev->le_adv_min_interval = val;
1027 hci_dev_unlock(hdev);
1028
1029 return 0;
1030}
1031
1032static int adv_min_interval_get(void *data, u64 *val)
1033{
1034 struct hci_dev *hdev = data;
1035
1036 hci_dev_lock(hdev);
1037 *val = hdev->le_adv_min_interval;
1038 hci_dev_unlock(hdev);
1039
1040 return 0;
1041}
1042
1043DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
1044 adv_min_interval_set, "%llu\n");
1045
1046static int adv_max_interval_set(void *data, u64 val)
1047{
1048 struct hci_dev *hdev = data;
1049
1050 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval)
1051 return -EINVAL;
1052
1053 hci_dev_lock(hdev);
1054 hdev->le_adv_max_interval = val;
1055 hci_dev_unlock(hdev);
1056
1057 return 0;
1058}
1059
1060static int adv_max_interval_get(void *data, u64 *val)
1061{
1062 struct hci_dev *hdev = data;
1063
1064 hci_dev_lock(hdev);
1065 *val = hdev->le_adv_max_interval;
1066 hci_dev_unlock(hdev);
1067
1068 return 0;
1069}
1070
1071DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
1072 adv_max_interval_set, "%llu\n");
1073
1074DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
1075 HCI_QUIRK_STRICT_DUPLICATE_FILTER);
1076DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
1077 HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
1078
1079void hci_debugfs_create_le(struct hci_dev *hdev)
1080{
1081 debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
1082 &identity_fops);
1083 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
1084 &rpa_timeout_fops);
1085 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
1086 &random_address_fops);
1087 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
1088 &static_address_fops);
1089
1090 /* For controllers with a public address, provide a debug
1091 * option to force the usage of the configured static
1092 * address. By default the public address is used.
1093 */
1094 if (bacmp(&hdev->bdaddr, BDADDR_ANY))
1095 debugfs_create_file("force_static_address", 0644,
1096 hdev->debugfs, hdev,
1097 &force_static_address_fops);
1098
1099 debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
1100 &hdev->le_white_list_size);
1101 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
1102 &white_list_fops);
1103 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
1104 hdev, &identity_resolving_keys_fops);
1105 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
1106 &long_term_keys_fops);
1107 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
1108 &conn_min_interval_fops);
1109 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
1110 &conn_max_interval_fops);
1111 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
1112 &conn_latency_fops);
1113 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
1114 &supervision_timeout_fops);
1115 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
1116 &adv_channel_map_fops);
1117 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
1118 &adv_min_interval_fops);
1119 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
1120 &adv_max_interval_fops);
1121 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
1122 &hdev->discov_interleaved_timeout);
1123
1124 debugfs_create_file("quirk_strict_duplicate_filter", 0644,
1125 hdev->debugfs, hdev,
1126 &quirk_strict_duplicate_filter_fops);
1127 debugfs_create_file("quirk_simultaneous_discovery", 0644,
1128 hdev->debugfs, hdev,
1129 &quirk_simultaneous_discovery_fops);
1130}
1131
1132void hci_debugfs_create_conn(struct hci_conn *conn)
1133{
1134 struct hci_dev *hdev = conn->hdev;
1135 char name[6];
1136
1137 if (IS_ERR_OR_NULL(hdev->debugfs))
1138 return;
1139
1140 snprintf(name, sizeof(name), "%u", conn->handle);
1141 conn->debugfs = debugfs_create_dir(name, hdev->debugfs);
1142}