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->accept_list, 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->reject_list, 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_DEBUGFS_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_DEBUGFS_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_DEBUGFS_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_DEBUGFS_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_DEBUGFS_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
495 auto_accept_delay_set, "%llu\n");
496
497static ssize_t force_bredr_smp_read(struct file *file,
498 char __user *user_buf,
499 size_t count, loff_t *ppos)
500{
501 struct hci_dev *hdev = file->private_data;
502 char buf[3];
503
504 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP) ? 'Y' : 'N';
505 buf[1] = '\n';
506 buf[2] = '\0';
507 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
508}
509
510static ssize_t force_bredr_smp_write(struct file *file,
511 const char __user *user_buf,
512 size_t count, loff_t *ppos)
513{
514 struct hci_dev *hdev = file->private_data;
515 bool enable;
516 int err;
517
518 err = kstrtobool_from_user(user_buf, count, &enable);
519 if (err)
520 return err;
521
522 err = smp_force_bredr(hdev, enable);
523 if (err)
524 return err;
525
526 return count;
527}
528
529static const struct file_operations force_bredr_smp_fops = {
530 .open = simple_open,
531 .read = force_bredr_smp_read,
532 .write = force_bredr_smp_write,
533 .llseek = default_llseek,
534};
535
536static int idle_timeout_set(void *data, u64 val)
537{
538 struct hci_dev *hdev = data;
539
540 if (val != 0 && (val < 500 || val > 3600000))
541 return -EINVAL;
542
543 hci_dev_lock(hdev);
544 hdev->idle_timeout = val;
545 hci_dev_unlock(hdev);
546
547 return 0;
548}
549
550static int idle_timeout_get(void *data, u64 *val)
551{
552 struct hci_dev *hdev = data;
553
554 hci_dev_lock(hdev);
555 *val = hdev->idle_timeout;
556 hci_dev_unlock(hdev);
557
558 return 0;
559}
560
561DEFINE_DEBUGFS_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
562 idle_timeout_set, "%llu\n");
563
564static int sniff_min_interval_set(void *data, u64 val)
565{
566 struct hci_dev *hdev = data;
567
568 if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
569 return -EINVAL;
570
571 hci_dev_lock(hdev);
572 hdev->sniff_min_interval = val;
573 hci_dev_unlock(hdev);
574
575 return 0;
576}
577
578static int sniff_min_interval_get(void *data, u64 *val)
579{
580 struct hci_dev *hdev = data;
581
582 hci_dev_lock(hdev);
583 *val = hdev->sniff_min_interval;
584 hci_dev_unlock(hdev);
585
586 return 0;
587}
588
589DEFINE_DEBUGFS_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
590 sniff_min_interval_set, "%llu\n");
591
592static int sniff_max_interval_set(void *data, u64 val)
593{
594 struct hci_dev *hdev = data;
595
596 if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
597 return -EINVAL;
598
599 hci_dev_lock(hdev);
600 hdev->sniff_max_interval = val;
601 hci_dev_unlock(hdev);
602
603 return 0;
604}
605
606static int sniff_max_interval_get(void *data, u64 *val)
607{
608 struct hci_dev *hdev = data;
609
610 hci_dev_lock(hdev);
611 *val = hdev->sniff_max_interval;
612 hci_dev_unlock(hdev);
613
614 return 0;
615}
616
617DEFINE_DEBUGFS_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
618 sniff_max_interval_set, "%llu\n");
619
620void hci_debugfs_create_bredr(struct hci_dev *hdev)
621{
622 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev,
623 &inquiry_cache_fops);
624 debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev,
625 &link_keys_fops);
626 debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev,
627 &dev_class_fops);
628 debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev,
629 &voice_setting_fops);
630
631
632
633
634
635
636
637
638 if (!lmp_sc_capable(hdev))
639 debugfs_create_file("force_bredr_smp", 0644, hdev->debugfs,
640 hdev, &force_bredr_smp_fops);
641
642 if (lmp_ssp_capable(hdev)) {
643 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
644 hdev, &ssp_debug_mode_fops);
645 debugfs_create_file("min_encrypt_key_size", 0644, hdev->debugfs,
646 hdev, &min_encrypt_key_size_fops);
647 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
648 hdev, &auto_accept_delay_fops);
649 }
650
651 if (lmp_sniff_capable(hdev)) {
652 debugfs_create_file("idle_timeout", 0644, hdev->debugfs,
653 hdev, &idle_timeout_fops);
654 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs,
655 hdev, &sniff_min_interval_fops);
656 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs,
657 hdev, &sniff_max_interval_fops);
658 }
659}
660
661static int identity_show(struct seq_file *f, void *p)
662{
663 struct hci_dev *hdev = f->private;
664 bdaddr_t addr;
665 u8 addr_type;
666
667 hci_dev_lock(hdev);
668
669 hci_copy_identity_address(hdev, &addr, &addr_type);
670
671 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type,
672 16, hdev->irk, &hdev->rpa);
673
674 hci_dev_unlock(hdev);
675
676 return 0;
677}
678
679DEFINE_SHOW_ATTRIBUTE(identity);
680
681static int rpa_timeout_set(void *data, u64 val)
682{
683 struct hci_dev *hdev = data;
684
685
686
687
688 if (val < 30 || val > (60 * 60 * 24))
689 return -EINVAL;
690
691 hci_dev_lock(hdev);
692 hdev->rpa_timeout = val;
693 hci_dev_unlock(hdev);
694
695 return 0;
696}
697
698static int rpa_timeout_get(void *data, u64 *val)
699{
700 struct hci_dev *hdev = data;
701
702 hci_dev_lock(hdev);
703 *val = hdev->rpa_timeout;
704 hci_dev_unlock(hdev);
705
706 return 0;
707}
708
709DEFINE_DEBUGFS_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
710 rpa_timeout_set, "%llu\n");
711
712static int random_address_show(struct seq_file *f, void *p)
713{
714 struct hci_dev *hdev = f->private;
715
716 hci_dev_lock(hdev);
717 seq_printf(f, "%pMR\n", &hdev->random_addr);
718 hci_dev_unlock(hdev);
719
720 return 0;
721}
722
723DEFINE_SHOW_ATTRIBUTE(random_address);
724
725static int static_address_show(struct seq_file *f, void *p)
726{
727 struct hci_dev *hdev = f->private;
728
729 hci_dev_lock(hdev);
730 seq_printf(f, "%pMR\n", &hdev->static_addr);
731 hci_dev_unlock(hdev);
732
733 return 0;
734}
735
736DEFINE_SHOW_ATTRIBUTE(static_address);
737
738static ssize_t force_static_address_read(struct file *file,
739 char __user *user_buf,
740 size_t count, loff_t *ppos)
741{
742 struct hci_dev *hdev = file->private_data;
743 char buf[3];
744
745 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y' : 'N';
746 buf[1] = '\n';
747 buf[2] = '\0';
748 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
749}
750
751static ssize_t force_static_address_write(struct file *file,
752 const char __user *user_buf,
753 size_t count, loff_t *ppos)
754{
755 struct hci_dev *hdev = file->private_data;
756 bool enable;
757 int err;
758
759 if (test_bit(HCI_UP, &hdev->flags))
760 return -EBUSY;
761
762 err = kstrtobool_from_user(user_buf, count, &enable);
763 if (err)
764 return err;
765
766 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
767 return -EALREADY;
768
769 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
770
771 return count;
772}
773
774static const struct file_operations force_static_address_fops = {
775 .open = simple_open,
776 .read = force_static_address_read,
777 .write = force_static_address_write,
778 .llseek = default_llseek,
779};
780
781static int white_list_show(struct seq_file *f, void *ptr)
782{
783 struct hci_dev *hdev = f->private;
784 struct bdaddr_list *b;
785
786 hci_dev_lock(hdev);
787 list_for_each_entry(b, &hdev->le_accept_list, list)
788 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
789 hci_dev_unlock(hdev);
790
791 return 0;
792}
793
794DEFINE_SHOW_ATTRIBUTE(white_list);
795
796static int resolv_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_resolv_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
809DEFINE_SHOW_ATTRIBUTE(resolv_list);
810
811static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
812{
813 struct hci_dev *hdev = f->private;
814 struct smp_irk *irk;
815
816 rcu_read_lock();
817 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
818 seq_printf(f, "%pMR (type %u) %*phN %pMR\n",
819 &irk->bdaddr, irk->addr_type,
820 16, irk->val, &irk->rpa);
821 }
822 rcu_read_unlock();
823
824 return 0;
825}
826
827DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
828
829static int long_term_keys_show(struct seq_file *f, void *ptr)
830{
831 struct hci_dev *hdev = f->private;
832 struct smp_ltk *ltk;
833
834 rcu_read_lock();
835 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list)
836 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n",
837 <k->bdaddr, ltk->bdaddr_type, ltk->authenticated,
838 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv),
839 __le64_to_cpu(ltk->rand), 16, ltk->val);
840 rcu_read_unlock();
841
842 return 0;
843}
844
845DEFINE_SHOW_ATTRIBUTE(long_term_keys);
846
847static int conn_min_interval_set(void *data, u64 val)
848{
849 struct hci_dev *hdev = data;
850
851 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval)
852 return -EINVAL;
853
854 hci_dev_lock(hdev);
855 hdev->le_conn_min_interval = val;
856 hci_dev_unlock(hdev);
857
858 return 0;
859}
860
861static int conn_min_interval_get(void *data, u64 *val)
862{
863 struct hci_dev *hdev = data;
864
865 hci_dev_lock(hdev);
866 *val = hdev->le_conn_min_interval;
867 hci_dev_unlock(hdev);
868
869 return 0;
870}
871
872DEFINE_DEBUGFS_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
873 conn_min_interval_set, "%llu\n");
874
875static int conn_max_interval_set(void *data, u64 val)
876{
877 struct hci_dev *hdev = data;
878
879 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval)
880 return -EINVAL;
881
882 hci_dev_lock(hdev);
883 hdev->le_conn_max_interval = val;
884 hci_dev_unlock(hdev);
885
886 return 0;
887}
888
889static int conn_max_interval_get(void *data, u64 *val)
890{
891 struct hci_dev *hdev = data;
892
893 hci_dev_lock(hdev);
894 *val = hdev->le_conn_max_interval;
895 hci_dev_unlock(hdev);
896
897 return 0;
898}
899
900DEFINE_DEBUGFS_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
901 conn_max_interval_set, "%llu\n");
902
903static int conn_latency_set(void *data, u64 val)
904{
905 struct hci_dev *hdev = data;
906
907 if (val > 0x01f3)
908 return -EINVAL;
909
910 hci_dev_lock(hdev);
911 hdev->le_conn_latency = val;
912 hci_dev_unlock(hdev);
913
914 return 0;
915}
916
917static int conn_latency_get(void *data, u64 *val)
918{
919 struct hci_dev *hdev = data;
920
921 hci_dev_lock(hdev);
922 *val = hdev->le_conn_latency;
923 hci_dev_unlock(hdev);
924
925 return 0;
926}
927
928DEFINE_DEBUGFS_ATTRIBUTE(conn_latency_fops, conn_latency_get,
929 conn_latency_set, "%llu\n");
930
931static int supervision_timeout_set(void *data, u64 val)
932{
933 struct hci_dev *hdev = data;
934
935 if (val < 0x000a || val > 0x0c80)
936 return -EINVAL;
937
938 hci_dev_lock(hdev);
939 hdev->le_supv_timeout = val;
940 hci_dev_unlock(hdev);
941
942 return 0;
943}
944
945static int supervision_timeout_get(void *data, u64 *val)
946{
947 struct hci_dev *hdev = data;
948
949 hci_dev_lock(hdev);
950 *val = hdev->le_supv_timeout;
951 hci_dev_unlock(hdev);
952
953 return 0;
954}
955
956DEFINE_DEBUGFS_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
957 supervision_timeout_set, "%llu\n");
958
959static int adv_channel_map_set(void *data, u64 val)
960{
961 struct hci_dev *hdev = data;
962
963 if (val < 0x01 || val > 0x07)
964 return -EINVAL;
965
966 hci_dev_lock(hdev);
967 hdev->le_adv_channel_map = val;
968 hci_dev_unlock(hdev);
969
970 return 0;
971}
972
973static int adv_channel_map_get(void *data, u64 *val)
974{
975 struct hci_dev *hdev = data;
976
977 hci_dev_lock(hdev);
978 *val = hdev->le_adv_channel_map;
979 hci_dev_unlock(hdev);
980
981 return 0;
982}
983
984DEFINE_DEBUGFS_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
985 adv_channel_map_set, "%llu\n");
986
987static int adv_min_interval_set(void *data, u64 val)
988{
989 struct hci_dev *hdev = data;
990
991 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval)
992 return -EINVAL;
993
994 hci_dev_lock(hdev);
995 hdev->le_adv_min_interval = val;
996 hci_dev_unlock(hdev);
997
998 return 0;
999}
1000
1001static int adv_min_interval_get(void *data, u64 *val)
1002{
1003 struct hci_dev *hdev = data;
1004
1005 hci_dev_lock(hdev);
1006 *val = hdev->le_adv_min_interval;
1007 hci_dev_unlock(hdev);
1008
1009 return 0;
1010}
1011
1012DEFINE_DEBUGFS_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
1013 adv_min_interval_set, "%llu\n");
1014
1015static int adv_max_interval_set(void *data, u64 val)
1016{
1017 struct hci_dev *hdev = data;
1018
1019 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval)
1020 return -EINVAL;
1021
1022 hci_dev_lock(hdev);
1023 hdev->le_adv_max_interval = val;
1024 hci_dev_unlock(hdev);
1025
1026 return 0;
1027}
1028
1029static int adv_max_interval_get(void *data, u64 *val)
1030{
1031 struct hci_dev *hdev = data;
1032
1033 hci_dev_lock(hdev);
1034 *val = hdev->le_adv_max_interval;
1035 hci_dev_unlock(hdev);
1036
1037 return 0;
1038}
1039
1040DEFINE_DEBUGFS_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
1041 adv_max_interval_set, "%llu\n");
1042
1043static int min_key_size_set(void *data, u64 val)
1044{
1045 struct hci_dev *hdev = data;
1046
1047 if (val > hdev->le_max_key_size || val < SMP_MIN_ENC_KEY_SIZE)
1048 return -EINVAL;
1049
1050 hci_dev_lock(hdev);
1051 hdev->le_min_key_size = val;
1052 hci_dev_unlock(hdev);
1053
1054 return 0;
1055}
1056
1057static int min_key_size_get(void *data, u64 *val)
1058{
1059 struct hci_dev *hdev = data;
1060
1061 hci_dev_lock(hdev);
1062 *val = hdev->le_min_key_size;
1063 hci_dev_unlock(hdev);
1064
1065 return 0;
1066}
1067
1068DEFINE_DEBUGFS_ATTRIBUTE(min_key_size_fops, min_key_size_get,
1069 min_key_size_set, "%llu\n");
1070
1071static int max_key_size_set(void *data, u64 val)
1072{
1073 struct hci_dev *hdev = data;
1074
1075 if (val > SMP_MAX_ENC_KEY_SIZE || val < hdev->le_min_key_size)
1076 return -EINVAL;
1077
1078 hci_dev_lock(hdev);
1079 hdev->le_max_key_size = val;
1080 hci_dev_unlock(hdev);
1081
1082 return 0;
1083}
1084
1085static int max_key_size_get(void *data, u64 *val)
1086{
1087 struct hci_dev *hdev = data;
1088
1089 hci_dev_lock(hdev);
1090 *val = hdev->le_max_key_size;
1091 hci_dev_unlock(hdev);
1092
1093 return 0;
1094}
1095
1096DEFINE_DEBUGFS_ATTRIBUTE(max_key_size_fops, max_key_size_get,
1097 max_key_size_set, "%llu\n");
1098
1099static int auth_payload_timeout_set(void *data, u64 val)
1100{
1101 struct hci_dev *hdev = data;
1102
1103 if (val < 0x0001 || val > 0xffff)
1104 return -EINVAL;
1105
1106 hci_dev_lock(hdev);
1107 hdev->auth_payload_timeout = val;
1108 hci_dev_unlock(hdev);
1109
1110 return 0;
1111}
1112
1113static int auth_payload_timeout_get(void *data, u64 *val)
1114{
1115 struct hci_dev *hdev = data;
1116
1117 hci_dev_lock(hdev);
1118 *val = hdev->auth_payload_timeout;
1119 hci_dev_unlock(hdev);
1120
1121 return 0;
1122}
1123
1124DEFINE_DEBUGFS_ATTRIBUTE(auth_payload_timeout_fops,
1125 auth_payload_timeout_get,
1126 auth_payload_timeout_set, "%llu\n");
1127
1128static ssize_t force_no_mitm_read(struct file *file,
1129 char __user *user_buf,
1130 size_t count, loff_t *ppos)
1131{
1132 struct hci_dev *hdev = file->private_data;
1133 char buf[3];
1134
1135 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_NO_MITM) ? 'Y' : 'N';
1136 buf[1] = '\n';
1137 buf[2] = '\0';
1138 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
1139}
1140
1141static ssize_t force_no_mitm_write(struct file *file,
1142 const char __user *user_buf,
1143 size_t count, loff_t *ppos)
1144{
1145 struct hci_dev *hdev = file->private_data;
1146 char buf[32];
1147 size_t buf_size = min(count, (sizeof(buf) - 1));
1148 bool enable;
1149
1150 if (copy_from_user(buf, user_buf, buf_size))
1151 return -EFAULT;
1152
1153 buf[buf_size] = '\0';
1154 if (strtobool(buf, &enable))
1155 return -EINVAL;
1156
1157 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_NO_MITM))
1158 return -EALREADY;
1159
1160 hci_dev_change_flag(hdev, HCI_FORCE_NO_MITM);
1161
1162 return count;
1163}
1164
1165static const struct file_operations force_no_mitm_fops = {
1166 .open = simple_open,
1167 .read = force_no_mitm_read,
1168 .write = force_no_mitm_write,
1169 .llseek = default_llseek,
1170};
1171
1172DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
1173 HCI_QUIRK_STRICT_DUPLICATE_FILTER);
1174DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
1175 HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
1176
1177void hci_debugfs_create_le(struct hci_dev *hdev)
1178{
1179 debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
1180 &identity_fops);
1181 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
1182 &rpa_timeout_fops);
1183 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
1184 &random_address_fops);
1185 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
1186 &static_address_fops);
1187
1188
1189
1190
1191
1192 if (bacmp(&hdev->bdaddr, BDADDR_ANY))
1193 debugfs_create_file("force_static_address", 0644,
1194 hdev->debugfs, hdev,
1195 &force_static_address_fops);
1196
1197 debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
1198 &hdev->le_accept_list_size);
1199 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
1200 &white_list_fops);
1201 debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs,
1202 &hdev->le_resolv_list_size);
1203 debugfs_create_file("resolv_list", 0444, hdev->debugfs, hdev,
1204 &resolv_list_fops);
1205 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
1206 hdev, &identity_resolving_keys_fops);
1207 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
1208 &long_term_keys_fops);
1209 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
1210 &conn_min_interval_fops);
1211 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
1212 &conn_max_interval_fops);
1213 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
1214 &conn_latency_fops);
1215 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
1216 &supervision_timeout_fops);
1217 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
1218 &adv_channel_map_fops);
1219 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
1220 &adv_min_interval_fops);
1221 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
1222 &adv_max_interval_fops);
1223 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
1224 &hdev->discov_interleaved_timeout);
1225 debugfs_create_file("min_key_size", 0644, hdev->debugfs, hdev,
1226 &min_key_size_fops);
1227 debugfs_create_file("max_key_size", 0644, hdev->debugfs, hdev,
1228 &max_key_size_fops);
1229 debugfs_create_file("auth_payload_timeout", 0644, hdev->debugfs, hdev,
1230 &auth_payload_timeout_fops);
1231 debugfs_create_file("force_no_mitm", 0644, hdev->debugfs, hdev,
1232 &force_no_mitm_fops);
1233
1234 debugfs_create_file("quirk_strict_duplicate_filter", 0644,
1235 hdev->debugfs, hdev,
1236 &quirk_strict_duplicate_filter_fops);
1237 debugfs_create_file("quirk_simultaneous_discovery", 0644,
1238 hdev->debugfs, hdev,
1239 &quirk_simultaneous_discovery_fops);
1240}
1241
1242void hci_debugfs_create_conn(struct hci_conn *conn)
1243{
1244 struct hci_dev *hdev = conn->hdev;
1245 char name[6];
1246
1247 if (IS_ERR_OR_NULL(hdev->debugfs))
1248 return;
1249
1250 snprintf(name, sizeof(name), "%u", conn->handle);
1251 conn->debugfs = debugfs_create_dir(name, hdev->debugfs);
1252}
1253
