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