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