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