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#include <linux/kstrtox.h>
26
27#include <net/bluetooth/bluetooth.h>
28#include <net/bluetooth/hci_core.h>
29
30#include "smp.h"
31#include "hci_debugfs.h"
32
33#define DEFINE_QUIRK_ATTRIBUTE(__name, __quirk) \
34static ssize_t __name ## _read(struct file *file, \
35 char __user *user_buf, \
36 size_t count, loff_t *ppos) \
37{ \
38 struct hci_dev *hdev = file->private_data; \
39 char buf[3]; \
40 \
41 buf[0] = test_bit(__quirk, &hdev->quirks) ? 'Y' : 'N'; \
42 buf[1] = '\n'; \
43 buf[2] = '\0'; \
44 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); \
45} \
46 \
47static ssize_t __name ## _write(struct file *file, \
48 const char __user *user_buf, \
49 size_t count, loff_t *ppos) \
50{ \
51 struct hci_dev *hdev = file->private_data; \
52 bool enable; \
53 int err; \
54 \
55 if (test_bit(HCI_UP, &hdev->flags)) \
56 return -EBUSY; \
57 \
58 err = kstrtobool_from_user(user_buf, count, &enable); \
59 if (err) \
60 return err; \
61 \
62 if (enable == test_bit(__quirk, &hdev->quirks)) \
63 return -EALREADY; \
64 \
65 change_bit(__quirk, &hdev->quirks); \
66 \
67 return count; \
68} \
69 \
70static const struct file_operations __name ## _fops = { \
71 .open = simple_open, \
72 .read = __name ## _read, \
73 .write = __name ## _write, \
74 .llseek = default_llseek, \
75} \
76
77#define DEFINE_INFO_ATTRIBUTE(__name, __field) \
78static int __name ## _show(struct seq_file *f, void *ptr) \
79{ \
80 struct hci_dev *hdev = f->private; \
81 \
82 hci_dev_lock(hdev); \
83 seq_printf(f, "%s\n", hdev->__field ? : ""); \
84 hci_dev_unlock(hdev); \
85 \
86 return 0; \
87} \
88 \
89DEFINE_SHOW_ATTRIBUTE(__name)
90
91static int features_show(struct seq_file *f, void *ptr)
92{
93 struct hci_dev *hdev = f->private;
94 u8 p;
95
96 hci_dev_lock(hdev);
97 for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++)
98 seq_printf(f, "%2u: %8ph\n", p, hdev->features[p]);
99 if (lmp_le_capable(hdev))
100 seq_printf(f, "LE: %8ph\n", hdev->le_features);
101 hci_dev_unlock(hdev);
102
103 return 0;
104}
105
106DEFINE_SHOW_ATTRIBUTE(features);
107
108static int device_id_show(struct seq_file *f, void *ptr)
109{
110 struct hci_dev *hdev = f->private;
111
112 hci_dev_lock(hdev);
113 seq_printf(f, "%4.4x:%4.4x:%4.4x:%4.4x\n", hdev->devid_source,
114 hdev->devid_vendor, hdev->devid_product, hdev->devid_version);
115 hci_dev_unlock(hdev);
116
117 return 0;
118}
119
120DEFINE_SHOW_ATTRIBUTE(device_id);
121
122static int device_list_show(struct seq_file *f, void *ptr)
123{
124 struct hci_dev *hdev = f->private;
125 struct hci_conn_params *p;
126 struct bdaddr_list *b;
127
128 hci_dev_lock(hdev);
129 list_for_each_entry(b, &hdev->accept_list, list)
130 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
131 list_for_each_entry(p, &hdev->le_conn_params, list) {
132 seq_printf(f, "%pMR (type %u) %u\n", &p->addr, p->addr_type,
133 p->auto_connect);
134 }
135 hci_dev_unlock(hdev);
136
137 return 0;
138}
139
140DEFINE_SHOW_ATTRIBUTE(device_list);
141
142static int blacklist_show(struct seq_file *f, void *p)
143{
144 struct hci_dev *hdev = f->private;
145 struct bdaddr_list *b;
146
147 hci_dev_lock(hdev);
148 list_for_each_entry(b, &hdev->reject_list, list)
149 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
150 hci_dev_unlock(hdev);
151
152 return 0;
153}
154
155DEFINE_SHOW_ATTRIBUTE(blacklist);
156
157static int blocked_keys_show(struct seq_file *f, void *p)
158{
159 struct hci_dev *hdev = f->private;
160 struct blocked_key *key;
161
162 rcu_read_lock();
163 list_for_each_entry_rcu(key, &hdev->blocked_keys, list)
164 seq_printf(f, "%u %*phN\n", key->type, 16, key->val);
165 rcu_read_unlock();
166
167 return 0;
168}
169
170DEFINE_SHOW_ATTRIBUTE(blocked_keys);
171
172static int uuids_show(struct seq_file *f, void *p)
173{
174 struct hci_dev *hdev = f->private;
175 struct bt_uuid *uuid;
176
177 hci_dev_lock(hdev);
178 list_for_each_entry(uuid, &hdev->uuids, list) {
179 u8 i, val[16];
180
181 /* The Bluetooth UUID values are stored in big endian,
182 * but with reversed byte order. So convert them into
183 * the right order for the %pUb modifier.
184 */
185 for (i = 0; i < 16; i++)
186 val[i] = uuid->uuid[15 - i];
187
188 seq_printf(f, "%pUb\n", val);
189 }
190 hci_dev_unlock(hdev);
191
192 return 0;
193}
194
195DEFINE_SHOW_ATTRIBUTE(uuids);
196
197static int remote_oob_show(struct seq_file *f, void *ptr)
198{
199 struct hci_dev *hdev = f->private;
200 struct oob_data *data;
201
202 hci_dev_lock(hdev);
203 list_for_each_entry(data, &hdev->remote_oob_data, list) {
204 seq_printf(f, "%pMR (type %u) %u %*phN %*phN %*phN %*phN\n",
205 &data->bdaddr, data->bdaddr_type, data->present,
206 16, data->hash192, 16, data->rand192,
207 16, data->hash256, 16, data->rand256);
208 }
209 hci_dev_unlock(hdev);
210
211 return 0;
212}
213
214DEFINE_SHOW_ATTRIBUTE(remote_oob);
215
216static int conn_info_min_age_set(void *data, u64 val)
217{
218 struct hci_dev *hdev = data;
219
220 hci_dev_lock(hdev);
221 if (val == 0 || val > hdev->conn_info_max_age) {
222 hci_dev_unlock(hdev);
223 return -EINVAL;
224 }
225
226 hdev->conn_info_min_age = val;
227 hci_dev_unlock(hdev);
228
229 return 0;
230}
231
232static int conn_info_min_age_get(void *data, u64 *val)
233{
234 struct hci_dev *hdev = data;
235
236 hci_dev_lock(hdev);
237 *val = hdev->conn_info_min_age;
238 hci_dev_unlock(hdev);
239
240 return 0;
241}
242
243DEFINE_DEBUGFS_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get,
244 conn_info_min_age_set, "%llu\n");
245
246static int conn_info_max_age_set(void *data, u64 val)
247{
248 struct hci_dev *hdev = data;
249
250 hci_dev_lock(hdev);
251 if (val == 0 || val < hdev->conn_info_min_age) {
252 hci_dev_unlock(hdev);
253 return -EINVAL;
254 }
255
256 hdev->conn_info_max_age = val;
257 hci_dev_unlock(hdev);
258
259 return 0;
260}
261
262static int conn_info_max_age_get(void *data, u64 *val)
263{
264 struct hci_dev *hdev = data;
265
266 hci_dev_lock(hdev);
267 *val = hdev->conn_info_max_age;
268 hci_dev_unlock(hdev);
269
270 return 0;
271}
272
273DEFINE_DEBUGFS_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get,
274 conn_info_max_age_set, "%llu\n");
275
276static ssize_t use_debug_keys_read(struct file *file, char __user *user_buf,
277 size_t count, loff_t *ppos)
278{
279 struct hci_dev *hdev = file->private_data;
280 char buf[3];
281
282 buf[0] = hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS) ? 'Y' : 'N';
283 buf[1] = '\n';
284 buf[2] = '\0';
285 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
286}
287
288static const struct file_operations use_debug_keys_fops = {
289 .open = simple_open,
290 .read = use_debug_keys_read,
291 .llseek = default_llseek,
292};
293
294static ssize_t sc_only_mode_read(struct file *file, char __user *user_buf,
295 size_t count, loff_t *ppos)
296{
297 struct hci_dev *hdev = file->private_data;
298 char buf[3];
299
300 buf[0] = hci_dev_test_flag(hdev, HCI_SC_ONLY) ? 'Y' : 'N';
301 buf[1] = '\n';
302 buf[2] = '\0';
303 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
304}
305
306static const struct file_operations sc_only_mode_fops = {
307 .open = simple_open,
308 .read = sc_only_mode_read,
309 .llseek = default_llseek,
310};
311
312DEFINE_INFO_ATTRIBUTE(hardware_info, hw_info);
313DEFINE_INFO_ATTRIBUTE(firmware_info, fw_info);
314
315void hci_debugfs_create_common(struct hci_dev *hdev)
316{
317 debugfs_create_file("features", 0444, hdev->debugfs, hdev,
318 &features_fops);
319 debugfs_create_u16("manufacturer", 0444, hdev->debugfs,
320 &hdev->manufacturer);
321 debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver);
322 debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev);
323 debugfs_create_u8("hardware_error", 0444, hdev->debugfs,
324 &hdev->hw_error_code);
325 debugfs_create_file("device_id", 0444, hdev->debugfs, hdev,
326 &device_id_fops);
327
328 debugfs_create_file("device_list", 0444, hdev->debugfs, hdev,
329 &device_list_fops);
330 debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev,
331 &blacklist_fops);
332 debugfs_create_file("blocked_keys", 0444, hdev->debugfs, hdev,
333 &blocked_keys_fops);
334 debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops);
335 debugfs_create_file("remote_oob", 0400, hdev->debugfs, hdev,
336 &remote_oob_fops);
337
338 debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev,
339 &conn_info_min_age_fops);
340 debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev,
341 &conn_info_max_age_fops);
342
343 if (lmp_ssp_capable(hdev) || lmp_le_capable(hdev))
344 debugfs_create_file("use_debug_keys", 0444, hdev->debugfs,
345 hdev, &use_debug_keys_fops);
346
347 if (lmp_sc_capable(hdev) || lmp_le_capable(hdev))
348 debugfs_create_file("sc_only_mode", 0444, hdev->debugfs,
349 hdev, &sc_only_mode_fops);
350
351 if (hdev->hw_info)
352 debugfs_create_file("hardware_info", 0444, hdev->debugfs,
353 hdev, &hardware_info_fops);
354
355 if (hdev->fw_info)
356 debugfs_create_file("firmware_info", 0444, hdev->debugfs,
357 hdev, &firmware_info_fops);
358}
359
360static int inquiry_cache_show(struct seq_file *f, void *p)
361{
362 struct hci_dev *hdev = f->private;
363 struct discovery_state *cache = &hdev->discovery;
364 struct inquiry_entry *e;
365
366 hci_dev_lock(hdev);
367
368 list_for_each_entry(e, &cache->all, all) {
369 struct inquiry_data *data = &e->data;
370 seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n",
371 &data->bdaddr,
372 data->pscan_rep_mode, data->pscan_period_mode,
373 data->pscan_mode, data->dev_class[2],
374 data->dev_class[1], data->dev_class[0],
375 __le16_to_cpu(data->clock_offset),
376 data->rssi, data->ssp_mode, e->timestamp);
377 }
378
379 hci_dev_unlock(hdev);
380
381 return 0;
382}
383
384DEFINE_SHOW_ATTRIBUTE(inquiry_cache);
385
386static int link_keys_show(struct seq_file *f, void *ptr)
387{
388 struct hci_dev *hdev = f->private;
389 struct link_key *key;
390
391 rcu_read_lock();
392 list_for_each_entry_rcu(key, &hdev->link_keys, list)
393 seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type,
394 HCI_LINK_KEY_SIZE, key->val, key->pin_len);
395 rcu_read_unlock();
396
397 return 0;
398}
399
400DEFINE_SHOW_ATTRIBUTE(link_keys);
401
402static int dev_class_show(struct seq_file *f, void *ptr)
403{
404 struct hci_dev *hdev = f->private;
405
406 hci_dev_lock(hdev);
407 seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2],
408 hdev->dev_class[1], hdev->dev_class[0]);
409 hci_dev_unlock(hdev);
410
411 return 0;
412}
413
414DEFINE_SHOW_ATTRIBUTE(dev_class);
415
416static int voice_setting_get(void *data, u64 *val)
417{
418 struct hci_dev *hdev = data;
419
420 hci_dev_lock(hdev);
421 *val = hdev->voice_setting;
422 hci_dev_unlock(hdev);
423
424 return 0;
425}
426
427DEFINE_DEBUGFS_ATTRIBUTE(voice_setting_fops, voice_setting_get,
428 NULL, "0x%4.4llx\n");
429
430static ssize_t ssp_debug_mode_read(struct file *file, char __user *user_buf,
431 size_t count, loff_t *ppos)
432{
433 struct hci_dev *hdev = file->private_data;
434 char buf[3];
435
436 buf[0] = hdev->ssp_debug_mode ? 'Y' : 'N';
437 buf[1] = '\n';
438 buf[2] = '\0';
439 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
440}
441
442static const struct file_operations ssp_debug_mode_fops = {
443 .open = simple_open,
444 .read = ssp_debug_mode_read,
445 .llseek = default_llseek,
446};
447
448static int auto_accept_delay_set(void *data, u64 val)
449{
450 struct hci_dev *hdev = data;
451
452 hci_dev_lock(hdev);
453 hdev->auto_accept_delay = val;
454 hci_dev_unlock(hdev);
455
456 return 0;
457}
458
459static int min_encrypt_key_size_set(void *data, u64 val)
460{
461 struct hci_dev *hdev = data;
462
463 if (val < 1 || val > 16)
464 return -EINVAL;
465
466 hci_dev_lock(hdev);
467 hdev->min_enc_key_size = val;
468 hci_dev_unlock(hdev);
469
470 return 0;
471}
472
473static int min_encrypt_key_size_get(void *data, u64 *val)
474{
475 struct hci_dev *hdev = data;
476
477 hci_dev_lock(hdev);
478 *val = hdev->min_enc_key_size;
479 hci_dev_unlock(hdev);
480
481 return 0;
482}
483
484DEFINE_DEBUGFS_ATTRIBUTE(min_encrypt_key_size_fops,
485 min_encrypt_key_size_get,
486 min_encrypt_key_size_set, "%llu\n");
487
488static int auto_accept_delay_get(void *data, u64 *val)
489{
490 struct hci_dev *hdev = data;
491
492 hci_dev_lock(hdev);
493 *val = hdev->auto_accept_delay;
494 hci_dev_unlock(hdev);
495
496 return 0;
497}
498
499DEFINE_DEBUGFS_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
500 auto_accept_delay_set, "%llu\n");
501
502static ssize_t force_bredr_smp_read(struct file *file,
503 char __user *user_buf,
504 size_t count, loff_t *ppos)
505{
506 struct hci_dev *hdev = file->private_data;
507 char buf[3];
508
509 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP) ? 'Y' : 'N';
510 buf[1] = '\n';
511 buf[2] = '\0';
512 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
513}
514
515static ssize_t force_bredr_smp_write(struct file *file,
516 const char __user *user_buf,
517 size_t count, loff_t *ppos)
518{
519 struct hci_dev *hdev = file->private_data;
520 bool enable;
521 int err;
522
523 err = kstrtobool_from_user(user_buf, count, &enable);
524 if (err)
525 return err;
526
527 err = smp_force_bredr(hdev, enable);
528 if (err)
529 return err;
530
531 return count;
532}
533
534static const struct file_operations force_bredr_smp_fops = {
535 .open = simple_open,
536 .read = force_bredr_smp_read,
537 .write = force_bredr_smp_write,
538 .llseek = default_llseek,
539};
540
541static int idle_timeout_set(void *data, u64 val)
542{
543 struct hci_dev *hdev = data;
544
545 if (val != 0 && (val < 500 || val > 3600000))
546 return -EINVAL;
547
548 hci_dev_lock(hdev);
549 hdev->idle_timeout = val;
550 hci_dev_unlock(hdev);
551
552 return 0;
553}
554
555static int idle_timeout_get(void *data, u64 *val)
556{
557 struct hci_dev *hdev = data;
558
559 hci_dev_lock(hdev);
560 *val = hdev->idle_timeout;
561 hci_dev_unlock(hdev);
562
563 return 0;
564}
565
566DEFINE_DEBUGFS_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
567 idle_timeout_set, "%llu\n");
568
569static int sniff_min_interval_set(void *data, u64 val)
570{
571 struct hci_dev *hdev = data;
572
573 hci_dev_lock(hdev);
574 if (val == 0 || val % 2 || val > hdev->sniff_max_interval) {
575 hci_dev_unlock(hdev);
576 return -EINVAL;
577 }
578
579 hdev->sniff_min_interval = val;
580 hci_dev_unlock(hdev);
581
582 return 0;
583}
584
585static int sniff_min_interval_get(void *data, u64 *val)
586{
587 struct hci_dev *hdev = data;
588
589 hci_dev_lock(hdev);
590 *val = hdev->sniff_min_interval;
591 hci_dev_unlock(hdev);
592
593 return 0;
594}
595
596DEFINE_DEBUGFS_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
597 sniff_min_interval_set, "%llu\n");
598
599static int sniff_max_interval_set(void *data, u64 val)
600{
601 struct hci_dev *hdev = data;
602
603 hci_dev_lock(hdev);
604 if (val == 0 || val % 2 || val < hdev->sniff_min_interval) {
605 hci_dev_unlock(hdev);
606 return -EINVAL;
607 }
608
609 hdev->sniff_max_interval = val;
610 hci_dev_unlock(hdev);
611
612 return 0;
613}
614
615static int sniff_max_interval_get(void *data, u64 *val)
616{
617 struct hci_dev *hdev = data;
618
619 hci_dev_lock(hdev);
620 *val = hdev->sniff_max_interval;
621 hci_dev_unlock(hdev);
622
623 return 0;
624}
625
626DEFINE_DEBUGFS_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
627 sniff_max_interval_set, "%llu\n");
628
629void hci_debugfs_create_bredr(struct hci_dev *hdev)
630{
631 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev,
632 &inquiry_cache_fops);
633 debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev,
634 &link_keys_fops);
635 debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev,
636 &dev_class_fops);
637 debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev,
638 &voice_setting_fops);
639
640 /* If the controller does not support BR/EDR Secure Connections
641 * feature, then the BR/EDR SMP channel shall not be present.
642 *
643 * To test this with Bluetooth 4.0 controllers, create a debugfs
644 * switch that allows forcing BR/EDR SMP support and accepting
645 * cross-transport pairing on non-AES encrypted connections.
646 */
647 if (!lmp_sc_capable(hdev))
648 debugfs_create_file("force_bredr_smp", 0644, hdev->debugfs,
649 hdev, &force_bredr_smp_fops);
650
651 if (lmp_ssp_capable(hdev)) {
652 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
653 hdev, &ssp_debug_mode_fops);
654 debugfs_create_file("min_encrypt_key_size", 0644, hdev->debugfs,
655 hdev, &min_encrypt_key_size_fops);
656 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
657 hdev, &auto_accept_delay_fops);
658 }
659
660 if (lmp_sniff_capable(hdev)) {
661 debugfs_create_file("idle_timeout", 0644, hdev->debugfs,
662 hdev, &idle_timeout_fops);
663 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs,
664 hdev, &sniff_min_interval_fops);
665 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs,
666 hdev, &sniff_max_interval_fops);
667 }
668}
669
670static int identity_show(struct seq_file *f, void *p)
671{
672 struct hci_dev *hdev = f->private;
673 bdaddr_t addr;
674 u8 addr_type;
675
676 hci_dev_lock(hdev);
677
678 hci_copy_identity_address(hdev, &addr, &addr_type);
679
680 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type,
681 16, hdev->irk, &hdev->rpa);
682
683 hci_dev_unlock(hdev);
684
685 return 0;
686}
687
688DEFINE_SHOW_ATTRIBUTE(identity);
689
690static int rpa_timeout_set(void *data, u64 val)
691{
692 struct hci_dev *hdev = data;
693
694 /* Require the RPA timeout to be at least 30 seconds and at most
695 * 24 hours.
696 */
697 if (val < 30 || val > (60 * 60 * 24))
698 return -EINVAL;
699
700 hci_dev_lock(hdev);
701 hdev->rpa_timeout = val;
702 hci_dev_unlock(hdev);
703
704 return 0;
705}
706
707static int rpa_timeout_get(void *data, u64 *val)
708{
709 struct hci_dev *hdev = data;
710
711 hci_dev_lock(hdev);
712 *val = hdev->rpa_timeout;
713 hci_dev_unlock(hdev);
714
715 return 0;
716}
717
718DEFINE_DEBUGFS_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
719 rpa_timeout_set, "%llu\n");
720
721static int random_address_show(struct seq_file *f, void *p)
722{
723 struct hci_dev *hdev = f->private;
724
725 hci_dev_lock(hdev);
726 seq_printf(f, "%pMR\n", &hdev->random_addr);
727 hci_dev_unlock(hdev);
728
729 return 0;
730}
731
732DEFINE_SHOW_ATTRIBUTE(random_address);
733
734static int static_address_show(struct seq_file *f, void *p)
735{
736 struct hci_dev *hdev = f->private;
737
738 hci_dev_lock(hdev);
739 seq_printf(f, "%pMR\n", &hdev->static_addr);
740 hci_dev_unlock(hdev);
741
742 return 0;
743}
744
745DEFINE_SHOW_ATTRIBUTE(static_address);
746
747static ssize_t force_static_address_read(struct file *file,
748 char __user *user_buf,
749 size_t count, loff_t *ppos)
750{
751 struct hci_dev *hdev = file->private_data;
752 char buf[3];
753
754 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y' : 'N';
755 buf[1] = '\n';
756 buf[2] = '\0';
757 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
758}
759
760static ssize_t force_static_address_write(struct file *file,
761 const char __user *user_buf,
762 size_t count, loff_t *ppos)
763{
764 struct hci_dev *hdev = file->private_data;
765 bool enable;
766 int err;
767
768 if (hdev_is_powered(hdev))
769 return -EBUSY;
770
771 err = kstrtobool_from_user(user_buf, count, &enable);
772 if (err)
773 return err;
774
775 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
776 return -EALREADY;
777
778 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
779
780 return count;
781}
782
783static const struct file_operations force_static_address_fops = {
784 .open = simple_open,
785 .read = force_static_address_read,
786 .write = force_static_address_write,
787 .llseek = default_llseek,
788};
789
790static int white_list_show(struct seq_file *f, void *ptr)
791{
792 struct hci_dev *hdev = f->private;
793 struct bdaddr_list *b;
794
795 hci_dev_lock(hdev);
796 list_for_each_entry(b, &hdev->le_accept_list, list)
797 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
798 hci_dev_unlock(hdev);
799
800 return 0;
801}
802
803DEFINE_SHOW_ATTRIBUTE(white_list);
804
805static int resolv_list_show(struct seq_file *f, void *ptr)
806{
807 struct hci_dev *hdev = f->private;
808 struct bdaddr_list *b;
809
810 hci_dev_lock(hdev);
811 list_for_each_entry(b, &hdev->le_resolv_list, list)
812 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
813 hci_dev_unlock(hdev);
814
815 return 0;
816}
817
818DEFINE_SHOW_ATTRIBUTE(resolv_list);
819
820static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
821{
822 struct hci_dev *hdev = f->private;
823 struct smp_irk *irk;
824
825 rcu_read_lock();
826 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
827 seq_printf(f, "%pMR (type %u) %*phN %pMR\n",
828 &irk->bdaddr, irk->addr_type,
829 16, irk->val, &irk->rpa);
830 }
831 rcu_read_unlock();
832
833 return 0;
834}
835
836DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
837
838static int long_term_keys_show(struct seq_file *f, void *ptr)
839{
840 struct hci_dev *hdev = f->private;
841 struct smp_ltk *ltk;
842
843 rcu_read_lock();
844 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list)
845 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n",
846 <k->bdaddr, ltk->bdaddr_type, ltk->authenticated,
847 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv),
848 __le64_to_cpu(ltk->rand), 16, ltk->val);
849 rcu_read_unlock();
850
851 return 0;
852}
853
854DEFINE_SHOW_ATTRIBUTE(long_term_keys);
855
856static int conn_min_interval_set(void *data, u64 val)
857{
858 struct hci_dev *hdev = data;
859
860 hci_dev_lock(hdev);
861 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval) {
862 hci_dev_unlock(hdev);
863 return -EINVAL;
864 }
865
866 hdev->le_conn_min_interval = val;
867 hci_dev_unlock(hdev);
868
869 return 0;
870}
871
872static int conn_min_interval_get(void *data, u64 *val)
873{
874 struct hci_dev *hdev = data;
875
876 hci_dev_lock(hdev);
877 *val = hdev->le_conn_min_interval;
878 hci_dev_unlock(hdev);
879
880 return 0;
881}
882
883DEFINE_DEBUGFS_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
884 conn_min_interval_set, "%llu\n");
885
886static int conn_max_interval_set(void *data, u64 val)
887{
888 struct hci_dev *hdev = data;
889
890 hci_dev_lock(hdev);
891 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval) {
892 hci_dev_unlock(hdev);
893 return -EINVAL;
894 }
895
896 hdev->le_conn_max_interval = val;
897 hci_dev_unlock(hdev);
898
899 return 0;
900}
901
902static int conn_max_interval_get(void *data, u64 *val)
903{
904 struct hci_dev *hdev = data;
905
906 hci_dev_lock(hdev);
907 *val = hdev->le_conn_max_interval;
908 hci_dev_unlock(hdev);
909
910 return 0;
911}
912
913DEFINE_DEBUGFS_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
914 conn_max_interval_set, "%llu\n");
915
916static int conn_latency_set(void *data, u64 val)
917{
918 struct hci_dev *hdev = data;
919
920 if (val > 0x01f3)
921 return -EINVAL;
922
923 hci_dev_lock(hdev);
924 hdev->le_conn_latency = val;
925 hci_dev_unlock(hdev);
926
927 return 0;
928}
929
930static int conn_latency_get(void *data, u64 *val)
931{
932 struct hci_dev *hdev = data;
933
934 hci_dev_lock(hdev);
935 *val = hdev->le_conn_latency;
936 hci_dev_unlock(hdev);
937
938 return 0;
939}
940
941DEFINE_DEBUGFS_ATTRIBUTE(conn_latency_fops, conn_latency_get,
942 conn_latency_set, "%llu\n");
943
944static int supervision_timeout_set(void *data, u64 val)
945{
946 struct hci_dev *hdev = data;
947
948 if (val < 0x000a || val > 0x0c80)
949 return -EINVAL;
950
951 hci_dev_lock(hdev);
952 hdev->le_supv_timeout = val;
953 hci_dev_unlock(hdev);
954
955 return 0;
956}
957
958static int supervision_timeout_get(void *data, u64 *val)
959{
960 struct hci_dev *hdev = data;
961
962 hci_dev_lock(hdev);
963 *val = hdev->le_supv_timeout;
964 hci_dev_unlock(hdev);
965
966 return 0;
967}
968
969DEFINE_DEBUGFS_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
970 supervision_timeout_set, "%llu\n");
971
972static int adv_channel_map_set(void *data, u64 val)
973{
974 struct hci_dev *hdev = data;
975
976 if (val < 0x01 || val > 0x07)
977 return -EINVAL;
978
979 hci_dev_lock(hdev);
980 hdev->le_adv_channel_map = val;
981 hci_dev_unlock(hdev);
982
983 return 0;
984}
985
986static int adv_channel_map_get(void *data, u64 *val)
987{
988 struct hci_dev *hdev = data;
989
990 hci_dev_lock(hdev);
991 *val = hdev->le_adv_channel_map;
992 hci_dev_unlock(hdev);
993
994 return 0;
995}
996
997DEFINE_DEBUGFS_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
998 adv_channel_map_set, "%llu\n");
999
1000static int adv_min_interval_set(void *data, u64 val)
1001{
1002 struct hci_dev *hdev = data;
1003
1004 hci_dev_lock(hdev);
1005 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval) {
1006 hci_dev_unlock(hdev);
1007 return -EINVAL;
1008 }
1009
1010 hdev->le_adv_min_interval = val;
1011 hci_dev_unlock(hdev);
1012
1013 return 0;
1014}
1015
1016static int adv_min_interval_get(void *data, u64 *val)
1017{
1018 struct hci_dev *hdev = data;
1019
1020 hci_dev_lock(hdev);
1021 *val = hdev->le_adv_min_interval;
1022 hci_dev_unlock(hdev);
1023
1024 return 0;
1025}
1026
1027DEFINE_DEBUGFS_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
1028 adv_min_interval_set, "%llu\n");
1029
1030static int adv_max_interval_set(void *data, u64 val)
1031{
1032 struct hci_dev *hdev = data;
1033
1034 hci_dev_lock(hdev);
1035 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval) {
1036 hci_dev_unlock(hdev);
1037 return -EINVAL;
1038 }
1039
1040 hdev->le_adv_max_interval = val;
1041 hci_dev_unlock(hdev);
1042
1043 return 0;
1044}
1045
1046static int adv_max_interval_get(void *data, u64 *val)
1047{
1048 struct hci_dev *hdev = data;
1049
1050 hci_dev_lock(hdev);
1051 *val = hdev->le_adv_max_interval;
1052 hci_dev_unlock(hdev);
1053
1054 return 0;
1055}
1056
1057DEFINE_DEBUGFS_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
1058 adv_max_interval_set, "%llu\n");
1059
1060static int min_key_size_set(void *data, u64 val)
1061{
1062 struct hci_dev *hdev = data;
1063
1064 hci_dev_lock(hdev);
1065 if (val > hdev->le_max_key_size || val < SMP_MIN_ENC_KEY_SIZE) {
1066 hci_dev_unlock(hdev);
1067 return -EINVAL;
1068 }
1069
1070 hdev->le_min_key_size = val;
1071 hci_dev_unlock(hdev);
1072
1073 return 0;
1074}
1075
1076static int min_key_size_get(void *data, u64 *val)
1077{
1078 struct hci_dev *hdev = data;
1079
1080 hci_dev_lock(hdev);
1081 *val = hdev->le_min_key_size;
1082 hci_dev_unlock(hdev);
1083
1084 return 0;
1085}
1086
1087DEFINE_DEBUGFS_ATTRIBUTE(min_key_size_fops, min_key_size_get,
1088 min_key_size_set, "%llu\n");
1089
1090static int max_key_size_set(void *data, u64 val)
1091{
1092 struct hci_dev *hdev = data;
1093
1094 hci_dev_lock(hdev);
1095 if (val > SMP_MAX_ENC_KEY_SIZE || val < hdev->le_min_key_size) {
1096 hci_dev_unlock(hdev);
1097 return -EINVAL;
1098 }
1099
1100 hdev->le_max_key_size = val;
1101 hci_dev_unlock(hdev);
1102
1103 return 0;
1104}
1105
1106static int max_key_size_get(void *data, u64 *val)
1107{
1108 struct hci_dev *hdev = data;
1109
1110 hci_dev_lock(hdev);
1111 *val = hdev->le_max_key_size;
1112 hci_dev_unlock(hdev);
1113
1114 return 0;
1115}
1116
1117DEFINE_DEBUGFS_ATTRIBUTE(max_key_size_fops, max_key_size_get,
1118 max_key_size_set, "%llu\n");
1119
1120static int auth_payload_timeout_set(void *data, u64 val)
1121{
1122 struct hci_dev *hdev = data;
1123
1124 if (val < 0x0001 || val > 0xffff)
1125 return -EINVAL;
1126
1127 hci_dev_lock(hdev);
1128 hdev->auth_payload_timeout = val;
1129 hci_dev_unlock(hdev);
1130
1131 return 0;
1132}
1133
1134static int auth_payload_timeout_get(void *data, u64 *val)
1135{
1136 struct hci_dev *hdev = data;
1137
1138 hci_dev_lock(hdev);
1139 *val = hdev->auth_payload_timeout;
1140 hci_dev_unlock(hdev);
1141
1142 return 0;
1143}
1144
1145DEFINE_DEBUGFS_ATTRIBUTE(auth_payload_timeout_fops,
1146 auth_payload_timeout_get,
1147 auth_payload_timeout_set, "%llu\n");
1148
1149static ssize_t force_no_mitm_read(struct file *file,
1150 char __user *user_buf,
1151 size_t count, loff_t *ppos)
1152{
1153 struct hci_dev *hdev = file->private_data;
1154 char buf[3];
1155
1156 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_NO_MITM) ? 'Y' : 'N';
1157 buf[1] = '\n';
1158 buf[2] = '\0';
1159 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
1160}
1161
1162static ssize_t force_no_mitm_write(struct file *file,
1163 const char __user *user_buf,
1164 size_t count, loff_t *ppos)
1165{
1166 struct hci_dev *hdev = file->private_data;
1167 char buf[32];
1168 size_t buf_size = min(count, (sizeof(buf) - 1));
1169 bool enable;
1170
1171 if (copy_from_user(buf, user_buf, buf_size))
1172 return -EFAULT;
1173
1174 buf[buf_size] = '\0';
1175 if (kstrtobool(buf, &enable))
1176 return -EINVAL;
1177
1178 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_NO_MITM))
1179 return -EALREADY;
1180
1181 hci_dev_change_flag(hdev, HCI_FORCE_NO_MITM);
1182
1183 return count;
1184}
1185
1186static const struct file_operations force_no_mitm_fops = {
1187 .open = simple_open,
1188 .read = force_no_mitm_read,
1189 .write = force_no_mitm_write,
1190 .llseek = default_llseek,
1191};
1192
1193DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
1194 HCI_QUIRK_STRICT_DUPLICATE_FILTER);
1195DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
1196 HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
1197
1198void hci_debugfs_create_le(struct hci_dev *hdev)
1199{
1200 debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
1201 &identity_fops);
1202 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
1203 &rpa_timeout_fops);
1204 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
1205 &random_address_fops);
1206 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
1207 &static_address_fops);
1208
1209 /* For controllers with a public address, provide a debug
1210 * option to force the usage of the configured static
1211 * address. By default the public address is used.
1212 */
1213 if (bacmp(&hdev->bdaddr, BDADDR_ANY))
1214 debugfs_create_file("force_static_address", 0644,
1215 hdev->debugfs, hdev,
1216 &force_static_address_fops);
1217
1218 debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
1219 &hdev->le_accept_list_size);
1220 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
1221 &white_list_fops);
1222 debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs,
1223 &hdev->le_resolv_list_size);
1224 debugfs_create_file("resolv_list", 0444, hdev->debugfs, hdev,
1225 &resolv_list_fops);
1226 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
1227 hdev, &identity_resolving_keys_fops);
1228 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
1229 &long_term_keys_fops);
1230 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
1231 &conn_min_interval_fops);
1232 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
1233 &conn_max_interval_fops);
1234 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
1235 &conn_latency_fops);
1236 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
1237 &supervision_timeout_fops);
1238 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
1239 &adv_channel_map_fops);
1240 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
1241 &adv_min_interval_fops);
1242 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
1243 &adv_max_interval_fops);
1244 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
1245 &hdev->discov_interleaved_timeout);
1246 debugfs_create_file("min_key_size", 0644, hdev->debugfs, hdev,
1247 &min_key_size_fops);
1248 debugfs_create_file("max_key_size", 0644, hdev->debugfs, hdev,
1249 &max_key_size_fops);
1250 debugfs_create_file("auth_payload_timeout", 0644, hdev->debugfs, hdev,
1251 &auth_payload_timeout_fops);
1252 debugfs_create_file("force_no_mitm", 0644, hdev->debugfs, hdev,
1253 &force_no_mitm_fops);
1254
1255 debugfs_create_file("quirk_strict_duplicate_filter", 0644,
1256 hdev->debugfs, hdev,
1257 &quirk_strict_duplicate_filter_fops);
1258 debugfs_create_file("quirk_simultaneous_discovery", 0644,
1259 hdev->debugfs, hdev,
1260 &quirk_simultaneous_discovery_fops);
1261}
1262
1263void hci_debugfs_create_conn(struct hci_conn *conn)
1264{
1265 struct hci_dev *hdev = conn->hdev;
1266 char name[6];
1267
1268 if (IS_ERR_OR_NULL(hdev->debugfs) || conn->debugfs)
1269 return;
1270
1271 snprintf(name, sizeof(name), "%u", conn->handle);
1272 conn->debugfs = debugfs_create_dir(name, hdev->debugfs);
1273}
1274
1275static ssize_t dut_mode_read(struct file *file, char __user *user_buf,
1276 size_t count, loff_t *ppos)
1277{
1278 struct hci_dev *hdev = file->private_data;
1279 char buf[3];
1280
1281 buf[0] = hci_dev_test_flag(hdev, HCI_DUT_MODE) ? 'Y' : 'N';
1282 buf[1] = '\n';
1283 buf[2] = '\0';
1284 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
1285}
1286
1287static ssize_t dut_mode_write(struct file *file, const char __user *user_buf,
1288 size_t count, loff_t *ppos)
1289{
1290 struct hci_dev *hdev = file->private_data;
1291 struct sk_buff *skb;
1292 bool enable;
1293 int err;
1294
1295 if (!test_bit(HCI_UP, &hdev->flags))
1296 return -ENETDOWN;
1297
1298 err = kstrtobool_from_user(user_buf, count, &enable);
1299 if (err)
1300 return err;
1301
1302 if (enable == hci_dev_test_flag(hdev, HCI_DUT_MODE))
1303 return -EALREADY;
1304
1305 hci_req_sync_lock(hdev);
1306 if (enable)
1307 skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL,
1308 HCI_CMD_TIMEOUT);
1309 else
1310 skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL,
1311 HCI_CMD_TIMEOUT);
1312 hci_req_sync_unlock(hdev);
1313
1314 if (IS_ERR(skb))
1315 return PTR_ERR(skb);
1316
1317 kfree_skb(skb);
1318
1319 hci_dev_change_flag(hdev, HCI_DUT_MODE);
1320
1321 return count;
1322}
1323
1324static const struct file_operations dut_mode_fops = {
1325 .open = simple_open,
1326 .read = dut_mode_read,
1327 .write = dut_mode_write,
1328 .llseek = default_llseek,
1329};
1330
1331static ssize_t vendor_diag_read(struct file *file, char __user *user_buf,
1332 size_t count, loff_t *ppos)
1333{
1334 struct hci_dev *hdev = file->private_data;
1335 char buf[3];
1336
1337 buf[0] = hci_dev_test_flag(hdev, HCI_VENDOR_DIAG) ? 'Y' : 'N';
1338 buf[1] = '\n';
1339 buf[2] = '\0';
1340 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
1341}
1342
1343static ssize_t vendor_diag_write(struct file *file, const char __user *user_buf,
1344 size_t count, loff_t *ppos)
1345{
1346 struct hci_dev *hdev = file->private_data;
1347 bool enable;
1348 int err;
1349
1350 err = kstrtobool_from_user(user_buf, count, &enable);
1351 if (err)
1352 return err;
1353
1354 /* When the diagnostic flags are not persistent and the transport
1355 * is not active or in user channel operation, then there is no need
1356 * for the vendor callback. Instead just store the desired value and
1357 * the setting will be programmed when the controller gets powered on.
1358 */
1359 if (test_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks) &&
1360 (!test_bit(HCI_RUNNING, &hdev->flags) ||
1361 hci_dev_test_flag(hdev, HCI_USER_CHANNEL)))
1362 goto done;
1363
1364 hci_req_sync_lock(hdev);
1365 err = hdev->set_diag(hdev, enable);
1366 hci_req_sync_unlock(hdev);
1367
1368 if (err < 0)
1369 return err;
1370
1371done:
1372 if (enable)
1373 hci_dev_set_flag(hdev, HCI_VENDOR_DIAG);
1374 else
1375 hci_dev_clear_flag(hdev, HCI_VENDOR_DIAG);
1376
1377 return count;
1378}
1379
1380static const struct file_operations vendor_diag_fops = {
1381 .open = simple_open,
1382 .read = vendor_diag_read,
1383 .write = vendor_diag_write,
1384 .llseek = default_llseek,
1385};
1386
1387void hci_debugfs_create_basic(struct hci_dev *hdev)
1388{
1389 debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev,
1390 &dut_mode_fops);
1391
1392 if (hdev->set_diag)
1393 debugfs_create_file("vendor_diag", 0644, hdev->debugfs, hdev,
1394 &vendor_diag_fops);
1395}
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}