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 "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 /* The Bluetooth UUID values are stored in big endian,
181 * but with reversed byte order. So convert them into
182 * the right order for the %pUb modifier.
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 /* Require the RPA timeout to be at least 30 seconds and at most
636 * 24 hours.
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 /* For controllers with a public address, provide a debug
1139 * option to force the usage of the configured static
1140 * address. By default the public address is used.
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}