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 "smp.h"
30#include "hci_debugfs.h"
31
32#define DEFINE_QUIRK_ATTRIBUTE(__name, __quirk) \
33static 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]; \
39 \
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} \
45 \
46static 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; \
53 \
54 if (test_bit(HCI_UP, &hdev->flags)) \
55 return -EBUSY; \
56 \
57 err = kstrtobool_from_user(user_buf, count, &enable); \
58 if (err) \
59 return err; \
60 \
61 if (enable == test_bit(__quirk, &hdev->quirks)) \
62 return -EALREADY; \
63 \
64 change_bit(__quirk, &hdev->quirks); \
65 \
66 return count; \
67} \
68 \
69static const struct file_operations __name ## _fops = { \
70 .open = simple_open, \
71 .read = __name ## _read, \
72 .write = __name ## _write, \
73 .llseek = default_llseek, \
74} \
75
76#define DEFINE_INFO_ATTRIBUTE(__name, __field) \
77static int __name ## _show(struct seq_file *f, void *ptr) \
78{ \
79 struct hci_dev *hdev = f->private; \
80 \
81 hci_dev_lock(hdev); \
82 seq_printf(f, "%s\n", hdev->__field ? : ""); \
83 hci_dev_unlock(hdev); \
84 \
85 return 0; \
86} \
87 \
88DEFINE_SHOW_ATTRIBUTE(__name)
89
90static int features_show(struct seq_file *f, void *ptr)
91{
92 struct hci_dev *hdev = f->private;
93 u8 p;
94
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);
101
102 return 0;
103}
104
105DEFINE_SHOW_ATTRIBUTE(features);
106
107static int device_id_show(struct seq_file *f, void *ptr)
108{
109 struct hci_dev *hdev = f->private;
110
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);
115
116 return 0;
117}
118
119DEFINE_SHOW_ATTRIBUTE(device_id);
120
121static int device_list_show(struct seq_file *f, void *ptr)
122{
123 struct hci_dev *hdev = f->private;
124 struct hci_conn_params *p;
125 struct bdaddr_list *b;
126
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);
133 }
134 hci_dev_unlock(hdev);
135
136 return 0;
137}
138
139DEFINE_SHOW_ATTRIBUTE(device_list);
140
141static int blacklist_show(struct seq_file *f, void *p)
142{
143 struct hci_dev *hdev = f->private;
144 struct bdaddr_list *b;
145
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);
150
151 return 0;
152}
153
154DEFINE_SHOW_ATTRIBUTE(blacklist);
155
156static int blocked_keys_show(struct seq_file *f, void *p)
157{
158 struct hci_dev *hdev = f->private;
159 struct blocked_key *key;
160
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();
165
166 return 0;
167}
168
169DEFINE_SHOW_ATTRIBUTE(blocked_keys);
170
171static int uuids_show(struct seq_file *f, void *p)
172{
173 struct hci_dev *hdev = f->private;
174 struct bt_uuid *uuid;
175
176 hci_dev_lock(hdev);
177 list_for_each_entry(uuid, &hdev->uuids, list) {
178 u8 i, val[16];
179
180
181
182
183
184 for (i = 0; i < 16; i++)
185 val[i] = uuid->uuid[15 - i];
186
187 seq_printf(f, "%pUb\n", val);
188 }
189 hci_dev_unlock(hdev);
190
191 return 0;
192}
193
194DEFINE_SHOW_ATTRIBUTE(uuids);
195
196static int remote_oob_show(struct seq_file *f, void *ptr)
197{
198 struct hci_dev *hdev = f->private;
199 struct oob_data *data;
200
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);
207 }
208 hci_dev_unlock(hdev);
209
210 return 0;
211}
212
213DEFINE_SHOW_ATTRIBUTE(remote_oob);
214
215static int conn_info_min_age_set(void *data, u64 val)
216{
217 struct hci_dev *hdev = data;
218
219 if (val == 0 || val > hdev->conn_info_max_age)
220 return -EINVAL;
221
222 hci_dev_lock(hdev);
223 hdev->conn_info_min_age = val;
224 hci_dev_unlock(hdev);
225
226 return 0;
227}
228
229static int conn_info_min_age_get(void *data, u64 *val)
230{
231 struct hci_dev *hdev = data;
232
233 hci_dev_lock(hdev);
234 *val = hdev->conn_info_min_age;
235 hci_dev_unlock(hdev);
236
237 return 0;
238}
239
240DEFINE_SIMPLE_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get,
241 conn_info_min_age_set, "%llu\n");
242
243static int conn_info_max_age_set(void *data, u64 val)
244{
245 struct hci_dev *hdev = data;
246
247 if (val == 0 || val < hdev->conn_info_min_age)
248 return -EINVAL;
249
250 hci_dev_lock(hdev);
251 hdev->conn_info_max_age = val;
252 hci_dev_unlock(hdev);
253
254 return 0;
255}
256
257static int conn_info_max_age_get(void *data, u64 *val)
258{
259 struct hci_dev *hdev = data;
260
261 hci_dev_lock(hdev);
262 *val = hdev->conn_info_max_age;
263 hci_dev_unlock(hdev);
264
265 return 0;
266}
267
268DEFINE_SIMPLE_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get,
269 conn_info_max_age_set, "%llu\n");
270
271static ssize_t use_debug_keys_read(struct file *file, char __user *user_buf,
272 size_t count, loff_t *ppos)
273{
274 struct hci_dev *hdev = file->private_data;
275 char buf[3];
276
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);
281}
282
283static const struct file_operations use_debug_keys_fops = {
284 .open = simple_open,
285 .read = use_debug_keys_read,
286 .llseek = default_llseek,
287};
288
289static ssize_t sc_only_mode_read(struct file *file, char __user *user_buf,
290 size_t count, loff_t *ppos)
291{
292 struct hci_dev *hdev = file->private_data;
293 char buf[3];
294
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);
299}
300
301static const struct file_operations sc_only_mode_fops = {
302 .open = simple_open,
303 .read = sc_only_mode_read,
304 .llseek = default_llseek,
305};
306
307DEFINE_INFO_ATTRIBUTE(hardware_info, hw_info);
308DEFINE_INFO_ATTRIBUTE(firmware_info, fw_info);
309
310void hci_debugfs_create_common(struct hci_dev *hdev)
311{
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);
322
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);
332
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);
337
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);
341
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);
345
346 if (hdev->hw_info)
347 debugfs_create_file("hardware_info", 0444, hdev->debugfs,
348 hdev, &hardware_info_fops);
349
350 if (hdev->fw_info)
351 debugfs_create_file("firmware_info", 0444, hdev->debugfs,
352 hdev, &firmware_info_fops);
353}
354
355static int inquiry_cache_show(struct seq_file *f, void *p)
356{
357 struct hci_dev *hdev = f->private;
358 struct discovery_state *cache = &hdev->discovery;
359 struct inquiry_entry *e;
360
361 hci_dev_lock(hdev);
362
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);
372 }
373
374 hci_dev_unlock(hdev);
375
376 return 0;
377}
378
379DEFINE_SHOW_ATTRIBUTE(inquiry_cache);
380
381static int link_keys_show(struct seq_file *f, void *ptr)
382{
383 struct hci_dev *hdev = f->private;
384 struct link_key *key;
385
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();
391
392 return 0;
393}
394
395DEFINE_SHOW_ATTRIBUTE(link_keys);
396
397static int dev_class_show(struct seq_file *f, void *ptr)
398{
399 struct hci_dev *hdev = f->private;
400
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);
405
406 return 0;
407}
408
409DEFINE_SHOW_ATTRIBUTE(dev_class);
410
411static int voice_setting_get(void *data, u64 *val)
412{
413 struct hci_dev *hdev = data;
414
415 hci_dev_lock(hdev);
416 *val = hdev->voice_setting;
417 hci_dev_unlock(hdev);
418
419 return 0;
420}
421
422DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get,
423 NULL, "0x%4.4llx\n");
424
425static ssize_t ssp_debug_mode_read(struct file *file, char __user *user_buf,
426 size_t count, loff_t *ppos)
427{
428 struct hci_dev *hdev = file->private_data;
429 char buf[3];
430
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);
435}
436
437static const struct file_operations ssp_debug_mode_fops = {
438 .open = simple_open,
439 .read = ssp_debug_mode_read,
440 .llseek = default_llseek,
441};
442
443static int auto_accept_delay_set(void *data, u64 val)
444{
445 struct hci_dev *hdev = data;
446
447 hci_dev_lock(hdev);
448 hdev->auto_accept_delay = val;
449 hci_dev_unlock(hdev);
450
451 return 0;
452}
453
454static int min_encrypt_key_size_set(void *data, u64 val)
455{
456 struct hci_dev *hdev = data;
457
458 if (val < 1 || val > 16)
459 return -EINVAL;
460
461 hci_dev_lock(hdev);
462 hdev->min_enc_key_size = val;
463 hci_dev_unlock(hdev);
464
465 return 0;
466}
467
468static int min_encrypt_key_size_get(void *data, u64 *val)
469{
470 struct hci_dev *hdev = data;
471
472 hci_dev_lock(hdev);
473 *val = hdev->min_enc_key_size;
474 hci_dev_unlock(hdev);
475
476 return 0;
477}
478
479DEFINE_SIMPLE_ATTRIBUTE(min_encrypt_key_size_fops,
480 min_encrypt_key_size_get,
481 min_encrypt_key_size_set, "%llu\n");
482
483static int auto_accept_delay_get(void *data, u64 *val)
484{
485 struct hci_dev *hdev = data;
486
487 hci_dev_lock(hdev);
488 *val = hdev->auto_accept_delay;
489 hci_dev_unlock(hdev);
490
491 return 0;
492}
493
494DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
495 auto_accept_delay_set, "%llu\n");
496
497static int idle_timeout_set(void *data, u64 val)
498{
499 struct hci_dev *hdev = data;
500
501 if (val != 0 && (val < 500 || val > 3600000))
502 return -EINVAL;
503
504 hci_dev_lock(hdev);
505 hdev->idle_timeout = val;
506 hci_dev_unlock(hdev);
507
508 return 0;
509}
510
511static int idle_timeout_get(void *data, u64 *val)
512{
513 struct hci_dev *hdev = data;
514
515 hci_dev_lock(hdev);
516 *val = hdev->idle_timeout;
517 hci_dev_unlock(hdev);
518
519 return 0;
520}
521
522DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
523 idle_timeout_set, "%llu\n");
524
525static int sniff_min_interval_set(void *data, u64 val)
526{
527 struct hci_dev *hdev = data;
528
529 if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
530 return -EINVAL;
531
532 hci_dev_lock(hdev);
533 hdev->sniff_min_interval = val;
534 hci_dev_unlock(hdev);
535
536 return 0;
537}
538
539static int sniff_min_interval_get(void *data, u64 *val)
540{
541 struct hci_dev *hdev = data;
542
543 hci_dev_lock(hdev);
544 *val = hdev->sniff_min_interval;
545 hci_dev_unlock(hdev);
546
547 return 0;
548}
549
550DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
551 sniff_min_interval_set, "%llu\n");
552
553static int sniff_max_interval_set(void *data, u64 val)
554{
555 struct hci_dev *hdev = data;
556
557 if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
558 return -EINVAL;
559
560 hci_dev_lock(hdev);
561 hdev->sniff_max_interval = val;
562 hci_dev_unlock(hdev);
563
564 return 0;
565}
566
567static int sniff_max_interval_get(void *data, u64 *val)
568{
569 struct hci_dev *hdev = data;
570
571 hci_dev_lock(hdev);
572 *val = hdev->sniff_max_interval;
573 hci_dev_unlock(hdev);
574
575 return 0;
576}
577
578DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
579 sniff_max_interval_set, "%llu\n");
580
581void hci_debugfs_create_bredr(struct hci_dev *hdev)
582{
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);
591
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);
599 }
600
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);
608 }
609}
610
611static int identity_show(struct seq_file *f, void *p)
612{
613 struct hci_dev *hdev = f->private;
614 bdaddr_t addr;
615 u8 addr_type;
616
617 hci_dev_lock(hdev);
618
619 hci_copy_identity_address(hdev, &addr, &addr_type);
620
621 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type,
622 16, hdev->irk, &hdev->rpa);
623
624 hci_dev_unlock(hdev);
625
626 return 0;
627}
628
629DEFINE_SHOW_ATTRIBUTE(identity);
630
631static int rpa_timeout_set(void *data, u64 val)
632{
633 struct hci_dev *hdev = data;
634
635
636
637
638 if (val < 30 || val > (60 * 60 * 24))
639 return -EINVAL;
640
641 hci_dev_lock(hdev);
642 hdev->rpa_timeout = val;
643 hci_dev_unlock(hdev);
644
645 return 0;
646}
647
648static int rpa_timeout_get(void *data, u64 *val)
649{
650 struct hci_dev *hdev = data;
651
652 hci_dev_lock(hdev);
653 *val = hdev->rpa_timeout;
654 hci_dev_unlock(hdev);
655
656 return 0;
657}
658
659DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
660 rpa_timeout_set, "%llu\n");
661
662static int random_address_show(struct seq_file *f, void *p)
663{
664 struct hci_dev *hdev = f->private;
665
666 hci_dev_lock(hdev);
667 seq_printf(f, "%pMR\n", &hdev->random_addr);
668 hci_dev_unlock(hdev);
669
670 return 0;
671}
672
673DEFINE_SHOW_ATTRIBUTE(random_address);
674
675static int static_address_show(struct seq_file *f, void *p)
676{
677 struct hci_dev *hdev = f->private;
678
679 hci_dev_lock(hdev);
680 seq_printf(f, "%pMR\n", &hdev->static_addr);
681 hci_dev_unlock(hdev);
682
683 return 0;
684}
685
686DEFINE_SHOW_ATTRIBUTE(static_address);
687
688static ssize_t force_static_address_read(struct file *file,
689 char __user *user_buf,
690 size_t count, loff_t *ppos)
691{
692 struct hci_dev *hdev = file->private_data;
693 char buf[3];
694
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);
699}
700
701static ssize_t force_static_address_write(struct file *file,
702 const char __user *user_buf,
703 size_t count, loff_t *ppos)
704{
705 struct hci_dev *hdev = file->private_data;
706 bool enable;
707 int err;
708
709 if (test_bit(HCI_UP, &hdev->flags))
710 return -EBUSY;
711
712 err = kstrtobool_from_user(user_buf, count, &enable);
713 if (err)
714 return err;
715
716 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
717 return -EALREADY;
718
719 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
720
721 return count;
722}
723
724static 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,
729};
730
731static int white_list_show(struct seq_file *f, void *ptr)
732{
733 struct hci_dev *hdev = f->private;
734 struct bdaddr_list *b;
735
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);
740
741 return 0;
742}
743
744DEFINE_SHOW_ATTRIBUTE(white_list);
745
746static int resolv_list_show(struct seq_file *f, void *ptr)
747{
748 struct hci_dev *hdev = f->private;
749 struct bdaddr_list *b;
750
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);
755
756 return 0;
757}
758
759DEFINE_SHOW_ATTRIBUTE(resolv_list);
760
761static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
762{
763 struct hci_dev *hdev = f->private;
764 struct smp_irk *irk;
765
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);
771 }
772 rcu_read_unlock();
773
774 return 0;
775}
776
777DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
778
779static int long_term_keys_show(struct seq_file *f, void *ptr)
780{
781 struct hci_dev *hdev = f->private;
782 struct smp_ltk *ltk;
783
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 <k->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();
791
792 return 0;
793}
794
795DEFINE_SHOW_ATTRIBUTE(long_term_keys);
796
797static int conn_min_interval_set(void *data, u64 val)
798{
799 struct hci_dev *hdev = data;
800
801 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval)
802 return -EINVAL;
803
804 hci_dev_lock(hdev);
805 hdev->le_conn_min_interval = val;
806 hci_dev_unlock(hdev);
807
808 return 0;
809}
810
811static int conn_min_interval_get(void *data, u64 *val)
812{
813 struct hci_dev *hdev = data;
814
815 hci_dev_lock(hdev);
816 *val = hdev->le_conn_min_interval;
817 hci_dev_unlock(hdev);
818
819 return 0;
820}
821
822DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
823 conn_min_interval_set, "%llu\n");
824
825static int conn_max_interval_set(void *data, u64 val)
826{
827 struct hci_dev *hdev = data;
828
829 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval)
830 return -EINVAL;
831
832 hci_dev_lock(hdev);
833 hdev->le_conn_max_interval = val;
834 hci_dev_unlock(hdev);
835
836 return 0;
837}
838
839static int conn_max_interval_get(void *data, u64 *val)
840{
841 struct hci_dev *hdev = data;
842
843 hci_dev_lock(hdev);
844 *val = hdev->le_conn_max_interval;
845 hci_dev_unlock(hdev);
846
847 return 0;
848}
849
850DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
851 conn_max_interval_set, "%llu\n");
852
853static int conn_latency_set(void *data, u64 val)
854{
855 struct hci_dev *hdev = data;
856
857 if (val > 0x01f3)
858 return -EINVAL;
859
860 hci_dev_lock(hdev);
861 hdev->le_conn_latency = val;
862 hci_dev_unlock(hdev);
863
864 return 0;
865}
866
867static int conn_latency_get(void *data, u64 *val)
868{
869 struct hci_dev *hdev = data;
870
871 hci_dev_lock(hdev);
872 *val = hdev->le_conn_latency;
873 hci_dev_unlock(hdev);
874
875 return 0;
876}
877
878DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get,
879 conn_latency_set, "%llu\n");
880
881static int supervision_timeout_set(void *data, u64 val)
882{
883 struct hci_dev *hdev = data;
884
885 if (val < 0x000a || val > 0x0c80)
886 return -EINVAL;
887
888 hci_dev_lock(hdev);
889 hdev->le_supv_timeout = val;
890 hci_dev_unlock(hdev);
891
892 return 0;
893}
894
895static int supervision_timeout_get(void *data, u64 *val)
896{
897 struct hci_dev *hdev = data;
898
899 hci_dev_lock(hdev);
900 *val = hdev->le_supv_timeout;
901 hci_dev_unlock(hdev);
902
903 return 0;
904}
905
906DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
907 supervision_timeout_set, "%llu\n");
908
909static int adv_channel_map_set(void *data, u64 val)
910{
911 struct hci_dev *hdev = data;
912
913 if (val < 0x01 || val > 0x07)
914 return -EINVAL;
915
916 hci_dev_lock(hdev);
917 hdev->le_adv_channel_map = val;
918 hci_dev_unlock(hdev);
919
920 return 0;
921}
922
923static int adv_channel_map_get(void *data, u64 *val)
924{
925 struct hci_dev *hdev = data;
926
927 hci_dev_lock(hdev);
928 *val = hdev->le_adv_channel_map;
929 hci_dev_unlock(hdev);
930
931 return 0;
932}
933
934DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
935 adv_channel_map_set, "%llu\n");
936
937static int adv_min_interval_set(void *data, u64 val)
938{
939 struct hci_dev *hdev = data;
940
941 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval)
942 return -EINVAL;
943
944 hci_dev_lock(hdev);
945 hdev->le_adv_min_interval = val;
946 hci_dev_unlock(hdev);
947
948 return 0;
949}
950
951static int adv_min_interval_get(void *data, u64 *val)
952{
953 struct hci_dev *hdev = data;
954
955 hci_dev_lock(hdev);
956 *val = hdev->le_adv_min_interval;
957 hci_dev_unlock(hdev);
958
959 return 0;
960}
961
962DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
963 adv_min_interval_set, "%llu\n");
964
965static int adv_max_interval_set(void *data, u64 val)
966{
967 struct hci_dev *hdev = data;
968
969 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval)
970 return -EINVAL;
971
972 hci_dev_lock(hdev);
973 hdev->le_adv_max_interval = val;
974 hci_dev_unlock(hdev);
975
976 return 0;
977}
978
979static int adv_max_interval_get(void *data, u64 *val)
980{
981 struct hci_dev *hdev = data;
982
983 hci_dev_lock(hdev);
984 *val = hdev->le_adv_max_interval;
985 hci_dev_unlock(hdev);
986
987 return 0;
988}
989
990DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
991 adv_max_interval_set, "%llu\n");
992
993static int min_key_size_set(void *data, u64 val)
994{
995 struct hci_dev *hdev = data;
996
997 if (val > hdev->le_max_key_size || val < SMP_MIN_ENC_KEY_SIZE)
998 return -EINVAL;
999
1000 hci_dev_lock(hdev);
1001 hdev->le_min_key_size = val;
1002 hci_dev_unlock(hdev);
1003
1004 return 0;
1005}
1006
1007static int min_key_size_get(void *data, u64 *val)
1008{
1009 struct hci_dev *hdev = data;
1010
1011 hci_dev_lock(hdev);
1012 *val = hdev->le_min_key_size;
1013 hci_dev_unlock(hdev);
1014
1015 return 0;
1016}
1017
1018DEFINE_SIMPLE_ATTRIBUTE(min_key_size_fops, min_key_size_get,
1019 min_key_size_set, "%llu\n");
1020
1021static int max_key_size_set(void *data, u64 val)
1022{
1023 struct hci_dev *hdev = data;
1024
1025 if (val > SMP_MAX_ENC_KEY_SIZE || val < hdev->le_min_key_size)
1026 return -EINVAL;
1027
1028 hci_dev_lock(hdev);
1029 hdev->le_max_key_size = val;
1030 hci_dev_unlock(hdev);
1031
1032 return 0;
1033}
1034
1035static int max_key_size_get(void *data, u64 *val)
1036{
1037 struct hci_dev *hdev = data;
1038
1039 hci_dev_lock(hdev);
1040 *val = hdev->le_max_key_size;
1041 hci_dev_unlock(hdev);
1042
1043 return 0;
1044}
1045
1046DEFINE_SIMPLE_ATTRIBUTE(max_key_size_fops, max_key_size_get,
1047 max_key_size_set, "%llu\n");
1048
1049static int auth_payload_timeout_set(void *data, u64 val)
1050{
1051 struct hci_dev *hdev = data;
1052
1053 if (val < 0x0001 || val > 0xffff)
1054 return -EINVAL;
1055
1056 hci_dev_lock(hdev);
1057 hdev->auth_payload_timeout = val;
1058 hci_dev_unlock(hdev);
1059
1060 return 0;
1061}
1062
1063static int auth_payload_timeout_get(void *data, u64 *val)
1064{
1065 struct hci_dev *hdev = data;
1066
1067 hci_dev_lock(hdev);
1068 *val = hdev->auth_payload_timeout;
1069 hci_dev_unlock(hdev);
1070
1071 return 0;
1072}
1073
1074DEFINE_SIMPLE_ATTRIBUTE(auth_payload_timeout_fops,
1075 auth_payload_timeout_get,
1076 auth_payload_timeout_set, "%llu\n");
1077
1078static ssize_t force_no_mitm_read(struct file *file,
1079 char __user *user_buf,
1080 size_t count, loff_t *ppos)
1081{
1082 struct hci_dev *hdev = file->private_data;
1083 char buf[3];
1084
1085 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_NO_MITM) ? 'Y' : 'N';
1086 buf[1] = '\n';
1087 buf[2] = '\0';
1088 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
1089}
1090
1091static ssize_t force_no_mitm_write(struct file *file,
1092 const char __user *user_buf,
1093 size_t count, loff_t *ppos)
1094{
1095 struct hci_dev *hdev = file->private_data;
1096 char buf[32];
1097 size_t buf_size = min(count, (sizeof(buf) - 1));
1098 bool enable;
1099
1100 if (copy_from_user(buf, user_buf, buf_size))
1101 return -EFAULT;
1102
1103 buf[buf_size] = '\0';
1104 if (strtobool(buf, &enable))
1105 return -EINVAL;
1106
1107 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_NO_MITM))
1108 return -EALREADY;
1109
1110 hci_dev_change_flag(hdev, HCI_FORCE_NO_MITM);
1111
1112 return count;
1113}
1114
1115static const struct file_operations force_no_mitm_fops = {
1116 .open = simple_open,
1117 .read = force_no_mitm_read,
1118 .write = force_no_mitm_write,
1119 .llseek = default_llseek,
1120};
1121
1122DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
1123 HCI_QUIRK_STRICT_DUPLICATE_FILTER);
1124DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
1125 HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
1126
1127void hci_debugfs_create_le(struct hci_dev *hdev)
1128{
1129 debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
1130 &identity_fops);
1131 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
1132 &rpa_timeout_fops);
1133 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
1134 &random_address_fops);
1135 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
1136 &static_address_fops);
1137
1138
1139
1140
1141
1142 if (bacmp(&hdev->bdaddr, BDADDR_ANY))
1143 debugfs_create_file("force_static_address", 0644,
1144 hdev->debugfs, hdev,
1145 &force_static_address_fops);
1146
1147 debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
1148 &hdev->le_white_list_size);
1149 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
1150 &white_list_fops);
1151 debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs,
1152 &hdev->le_resolv_list_size);
1153 debugfs_create_file("resolv_list", 0444, hdev->debugfs, hdev,
1154 &resolv_list_fops);
1155 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
1156 hdev, &identity_resolving_keys_fops);
1157 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
1158 &long_term_keys_fops);
1159 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
1160 &conn_min_interval_fops);
1161 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
1162 &conn_max_interval_fops);
1163 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
1164 &conn_latency_fops);
1165 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
1166 &supervision_timeout_fops);
1167 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
1168 &adv_channel_map_fops);
1169 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
1170 &adv_min_interval_fops);
1171 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
1172 &adv_max_interval_fops);
1173 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
1174 &hdev->discov_interleaved_timeout);
1175 debugfs_create_file("min_key_size", 0644, hdev->debugfs, hdev,
1176 &min_key_size_fops);
1177 debugfs_create_file("max_key_size", 0644, hdev->debugfs, hdev,
1178 &max_key_size_fops);
1179 debugfs_create_file("auth_payload_timeout", 0644, hdev->debugfs, hdev,
1180 &auth_payload_timeout_fops);
1181 debugfs_create_file("force_no_mitm", 0644, hdev->debugfs, hdev,
1182 &force_no_mitm_fops);
1183
1184 debugfs_create_file("quirk_strict_duplicate_filter", 0644,
1185 hdev->debugfs, hdev,
1186 &quirk_strict_duplicate_filter_fops);
1187 debugfs_create_file("quirk_simultaneous_discovery", 0644,
1188 hdev->debugfs, hdev,
1189 &quirk_simultaneous_discovery_fops);
1190}
1191
1192void hci_debugfs_create_conn(struct hci_conn *conn)
1193{
1194 struct hci_dev *hdev = conn->hdev;
1195 char name[6];
1196
1197 if (IS_ERR_OR_NULL(hdev->debugfs))
1198 return;
1199
1200 snprintf(name, sizeof(name), "%u", conn->handle);
1201 conn->debugfs = debugfs_create_dir(name, hdev->debugfs);
1202}
1203
