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