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