1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
165
166
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
618
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
1021
1022
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}
1079
