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->whitelist, 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->blacklist, 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_SIMPLE_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_SIMPLE_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_SIMPLE_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_SIMPLE_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_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
495 auto_accept_delay_set, "%llu\n");
496
idle_timeout_set(void * data,u64 val)497 static int idle_timeout_set(void *data, u64 val)
498 {
499 struct hci_dev *hdev = data;
500
501 if (val != 0 && (val < 500 || val > 3600000))
502 return -EINVAL;
503
504 hci_dev_lock(hdev);
505 hdev->idle_timeout = val;
506 hci_dev_unlock(hdev);
507
508 return 0;
509 }
510
idle_timeout_get(void * data,u64 * val)511 static int idle_timeout_get(void *data, u64 *val)
512 {
513 struct hci_dev *hdev = data;
514
515 hci_dev_lock(hdev);
516 *val = hdev->idle_timeout;
517 hci_dev_unlock(hdev);
518
519 return 0;
520 }
521
522 DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
523 idle_timeout_set, "%llu\n");
524
sniff_min_interval_set(void * data,u64 val)525 static int sniff_min_interval_set(void *data, u64 val)
526 {
527 struct hci_dev *hdev = data;
528
529 if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
530 return -EINVAL;
531
532 hci_dev_lock(hdev);
533 hdev->sniff_min_interval = val;
534 hci_dev_unlock(hdev);
535
536 return 0;
537 }
538
sniff_min_interval_get(void * data,u64 * val)539 static int sniff_min_interval_get(void *data, u64 *val)
540 {
541 struct hci_dev *hdev = data;
542
543 hci_dev_lock(hdev);
544 *val = hdev->sniff_min_interval;
545 hci_dev_unlock(hdev);
546
547 return 0;
548 }
549
550 DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
551 sniff_min_interval_set, "%llu\n");
552
sniff_max_interval_set(void * data,u64 val)553 static int sniff_max_interval_set(void *data, u64 val)
554 {
555 struct hci_dev *hdev = data;
556
557 if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
558 return -EINVAL;
559
560 hci_dev_lock(hdev);
561 hdev->sniff_max_interval = val;
562 hci_dev_unlock(hdev);
563
564 return 0;
565 }
566
sniff_max_interval_get(void * data,u64 * val)567 static int sniff_max_interval_get(void *data, u64 *val)
568 {
569 struct hci_dev *hdev = data;
570
571 hci_dev_lock(hdev);
572 *val = hdev->sniff_max_interval;
573 hci_dev_unlock(hdev);
574
575 return 0;
576 }
577
578 DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
579 sniff_max_interval_set, "%llu\n");
580
hci_debugfs_create_bredr(struct hci_dev * hdev)581 void hci_debugfs_create_bredr(struct hci_dev *hdev)
582 {
583 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev,
584 &inquiry_cache_fops);
585 debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev,
586 &link_keys_fops);
587 debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev,
588 &dev_class_fops);
589 debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev,
590 &voice_setting_fops);
591
592 if (lmp_ssp_capable(hdev)) {
593 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
594 hdev, &ssp_debug_mode_fops);
595 debugfs_create_file("min_encrypt_key_size", 0644, hdev->debugfs,
596 hdev, &min_encrypt_key_size_fops);
597 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
598 hdev, &auto_accept_delay_fops);
599 }
600
601 if (lmp_sniff_capable(hdev)) {
602 debugfs_create_file("idle_timeout", 0644, hdev->debugfs,
603 hdev, &idle_timeout_fops);
604 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs,
605 hdev, &sniff_min_interval_fops);
606 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs,
607 hdev, &sniff_max_interval_fops);
608 }
609 }
610
identity_show(struct seq_file * f,void * p)611 static int identity_show(struct seq_file *f, void *p)
612 {
613 struct hci_dev *hdev = f->private;
614 bdaddr_t addr;
615 u8 addr_type;
616
617 hci_dev_lock(hdev);
618
619 hci_copy_identity_address(hdev, &addr, &addr_type);
620
621 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type,
622 16, hdev->irk, &hdev->rpa);
623
624 hci_dev_unlock(hdev);
625
626 return 0;
627 }
628
629 DEFINE_SHOW_ATTRIBUTE(identity);
630
rpa_timeout_set(void * data,u64 val)631 static int rpa_timeout_set(void *data, u64 val)
632 {
633 struct hci_dev *hdev = data;
634
635 /* Require the RPA timeout to be at least 30 seconds and at most
636 * 24 hours.
637 */
638 if (val < 30 || val > (60 * 60 * 24))
639 return -EINVAL;
640
641 hci_dev_lock(hdev);
642 hdev->rpa_timeout = val;
643 hci_dev_unlock(hdev);
644
645 return 0;
646 }
647
rpa_timeout_get(void * data,u64 * val)648 static int rpa_timeout_get(void *data, u64 *val)
649 {
650 struct hci_dev *hdev = data;
651
652 hci_dev_lock(hdev);
653 *val = hdev->rpa_timeout;
654 hci_dev_unlock(hdev);
655
656 return 0;
657 }
658
659 DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
660 rpa_timeout_set, "%llu\n");
661
random_address_show(struct seq_file * f,void * p)662 static int random_address_show(struct seq_file *f, void *p)
663 {
664 struct hci_dev *hdev = f->private;
665
666 hci_dev_lock(hdev);
667 seq_printf(f, "%pMR\n", &hdev->random_addr);
668 hci_dev_unlock(hdev);
669
670 return 0;
671 }
672
673 DEFINE_SHOW_ATTRIBUTE(random_address);
674
static_address_show(struct seq_file * f,void * p)675 static int static_address_show(struct seq_file *f, void *p)
676 {
677 struct hci_dev *hdev = f->private;
678
679 hci_dev_lock(hdev);
680 seq_printf(f, "%pMR\n", &hdev->static_addr);
681 hci_dev_unlock(hdev);
682
683 return 0;
684 }
685
686 DEFINE_SHOW_ATTRIBUTE(static_address);
687
force_static_address_read(struct file * file,char __user * user_buf,size_t count,loff_t * ppos)688 static ssize_t force_static_address_read(struct file *file,
689 char __user *user_buf,
690 size_t count, loff_t *ppos)
691 {
692 struct hci_dev *hdev = file->private_data;
693 char buf[3];
694
695 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y': 'N';
696 buf[1] = '\n';
697 buf[2] = '\0';
698 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
699 }
700
force_static_address_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)701 static ssize_t force_static_address_write(struct file *file,
702 const char __user *user_buf,
703 size_t count, loff_t *ppos)
704 {
705 struct hci_dev *hdev = file->private_data;
706 bool enable;
707 int err;
708
709 if (test_bit(HCI_UP, &hdev->flags))
710 return -EBUSY;
711
712 err = kstrtobool_from_user(user_buf, count, &enable);
713 if (err)
714 return err;
715
716 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
717 return -EALREADY;
718
719 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
720
721 return count;
722 }
723
724 static const struct file_operations force_static_address_fops = {
725 .open = simple_open,
726 .read = force_static_address_read,
727 .write = force_static_address_write,
728 .llseek = default_llseek,
729 };
730
white_list_show(struct seq_file * f,void * ptr)731 static int white_list_show(struct seq_file *f, void *ptr)
732 {
733 struct hci_dev *hdev = f->private;
734 struct bdaddr_list *b;
735
736 hci_dev_lock(hdev);
737 list_for_each_entry(b, &hdev->le_white_list, list)
738 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
739 hci_dev_unlock(hdev);
740
741 return 0;
742 }
743
744 DEFINE_SHOW_ATTRIBUTE(white_list);
745
resolv_list_show(struct seq_file * f,void * ptr)746 static int resolv_list_show(struct seq_file *f, void *ptr)
747 {
748 struct hci_dev *hdev = f->private;
749 struct bdaddr_list *b;
750
751 hci_dev_lock(hdev);
752 list_for_each_entry(b, &hdev->le_resolv_list, list)
753 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
754 hci_dev_unlock(hdev);
755
756 return 0;
757 }
758
759 DEFINE_SHOW_ATTRIBUTE(resolv_list);
760
identity_resolving_keys_show(struct seq_file * f,void * ptr)761 static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
762 {
763 struct hci_dev *hdev = f->private;
764 struct smp_irk *irk;
765
766 rcu_read_lock();
767 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
768 seq_printf(f, "%pMR (type %u) %*phN %pMR\n",
769 &irk->bdaddr, irk->addr_type,
770 16, irk->val, &irk->rpa);
771 }
772 rcu_read_unlock();
773
774 return 0;
775 }
776
777 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
778
long_term_keys_show(struct seq_file * f,void * ptr)779 static int long_term_keys_show(struct seq_file *f, void *ptr)
780 {
781 struct hci_dev *hdev = f->private;
782 struct smp_ltk *ltk;
783
784 rcu_read_lock();
785 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list)
786 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n",
787 <k->bdaddr, ltk->bdaddr_type, ltk->authenticated,
788 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv),
789 __le64_to_cpu(ltk->rand), 16, ltk->val);
790 rcu_read_unlock();
791
792 return 0;
793 }
794
795 DEFINE_SHOW_ATTRIBUTE(long_term_keys);
796
conn_min_interval_set(void * data,u64 val)797 static int conn_min_interval_set(void *data, u64 val)
798 {
799 struct hci_dev *hdev = data;
800
801 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval)
802 return -EINVAL;
803
804 hci_dev_lock(hdev);
805 hdev->le_conn_min_interval = val;
806 hci_dev_unlock(hdev);
807
808 return 0;
809 }
810
conn_min_interval_get(void * data,u64 * val)811 static int conn_min_interval_get(void *data, u64 *val)
812 {
813 struct hci_dev *hdev = data;
814
815 hci_dev_lock(hdev);
816 *val = hdev->le_conn_min_interval;
817 hci_dev_unlock(hdev);
818
819 return 0;
820 }
821
822 DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
823 conn_min_interval_set, "%llu\n");
824
conn_max_interval_set(void * data,u64 val)825 static int conn_max_interval_set(void *data, u64 val)
826 {
827 struct hci_dev *hdev = data;
828
829 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval)
830 return -EINVAL;
831
832 hci_dev_lock(hdev);
833 hdev->le_conn_max_interval = val;
834 hci_dev_unlock(hdev);
835
836 return 0;
837 }
838
conn_max_interval_get(void * data,u64 * val)839 static int conn_max_interval_get(void *data, u64 *val)
840 {
841 struct hci_dev *hdev = data;
842
843 hci_dev_lock(hdev);
844 *val = hdev->le_conn_max_interval;
845 hci_dev_unlock(hdev);
846
847 return 0;
848 }
849
850 DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
851 conn_max_interval_set, "%llu\n");
852
conn_latency_set(void * data,u64 val)853 static int conn_latency_set(void *data, u64 val)
854 {
855 struct hci_dev *hdev = data;
856
857 if (val > 0x01f3)
858 return -EINVAL;
859
860 hci_dev_lock(hdev);
861 hdev->le_conn_latency = val;
862 hci_dev_unlock(hdev);
863
864 return 0;
865 }
866
conn_latency_get(void * data,u64 * val)867 static int conn_latency_get(void *data, u64 *val)
868 {
869 struct hci_dev *hdev = data;
870
871 hci_dev_lock(hdev);
872 *val = hdev->le_conn_latency;
873 hci_dev_unlock(hdev);
874
875 return 0;
876 }
877
878 DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get,
879 conn_latency_set, "%llu\n");
880
supervision_timeout_set(void * data,u64 val)881 static int supervision_timeout_set(void *data, u64 val)
882 {
883 struct hci_dev *hdev = data;
884
885 if (val < 0x000a || val > 0x0c80)
886 return -EINVAL;
887
888 hci_dev_lock(hdev);
889 hdev->le_supv_timeout = val;
890 hci_dev_unlock(hdev);
891
892 return 0;
893 }
894
supervision_timeout_get(void * data,u64 * val)895 static int supervision_timeout_get(void *data, u64 *val)
896 {
897 struct hci_dev *hdev = data;
898
899 hci_dev_lock(hdev);
900 *val = hdev->le_supv_timeout;
901 hci_dev_unlock(hdev);
902
903 return 0;
904 }
905
906 DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
907 supervision_timeout_set, "%llu\n");
908
adv_channel_map_set(void * data,u64 val)909 static int adv_channel_map_set(void *data, u64 val)
910 {
911 struct hci_dev *hdev = data;
912
913 if (val < 0x01 || val > 0x07)
914 return -EINVAL;
915
916 hci_dev_lock(hdev);
917 hdev->le_adv_channel_map = val;
918 hci_dev_unlock(hdev);
919
920 return 0;
921 }
922
adv_channel_map_get(void * data,u64 * val)923 static int adv_channel_map_get(void *data, u64 *val)
924 {
925 struct hci_dev *hdev = data;
926
927 hci_dev_lock(hdev);
928 *val = hdev->le_adv_channel_map;
929 hci_dev_unlock(hdev);
930
931 return 0;
932 }
933
934 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
935 adv_channel_map_set, "%llu\n");
936
adv_min_interval_set(void * data,u64 val)937 static int adv_min_interval_set(void *data, u64 val)
938 {
939 struct hci_dev *hdev = data;
940
941 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval)
942 return -EINVAL;
943
944 hci_dev_lock(hdev);
945 hdev->le_adv_min_interval = val;
946 hci_dev_unlock(hdev);
947
948 return 0;
949 }
950
adv_min_interval_get(void * data,u64 * val)951 static int adv_min_interval_get(void *data, u64 *val)
952 {
953 struct hci_dev *hdev = data;
954
955 hci_dev_lock(hdev);
956 *val = hdev->le_adv_min_interval;
957 hci_dev_unlock(hdev);
958
959 return 0;
960 }
961
962 DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
963 adv_min_interval_set, "%llu\n");
964
adv_max_interval_set(void * data,u64 val)965 static int adv_max_interval_set(void *data, u64 val)
966 {
967 struct hci_dev *hdev = data;
968
969 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval)
970 return -EINVAL;
971
972 hci_dev_lock(hdev);
973 hdev->le_adv_max_interval = val;
974 hci_dev_unlock(hdev);
975
976 return 0;
977 }
978
adv_max_interval_get(void * data,u64 * val)979 static int adv_max_interval_get(void *data, u64 *val)
980 {
981 struct hci_dev *hdev = data;
982
983 hci_dev_lock(hdev);
984 *val = hdev->le_adv_max_interval;
985 hci_dev_unlock(hdev);
986
987 return 0;
988 }
989
990 DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
991 adv_max_interval_set, "%llu\n");
992
min_key_size_set(void * data,u64 val)993 static int min_key_size_set(void *data, u64 val)
994 {
995 struct hci_dev *hdev = data;
996
997 hci_dev_lock(hdev);
998 if (val > hdev->le_max_key_size || val < SMP_MIN_ENC_KEY_SIZE) {
999 hci_dev_unlock(hdev);
1000 return -EINVAL;
1001 }
1002
1003 hdev->le_min_key_size = val;
1004 hci_dev_unlock(hdev);
1005
1006 return 0;
1007 }
1008
min_key_size_get(void * data,u64 * val)1009 static int min_key_size_get(void *data, u64 *val)
1010 {
1011 struct hci_dev *hdev = data;
1012
1013 hci_dev_lock(hdev);
1014 *val = hdev->le_min_key_size;
1015 hci_dev_unlock(hdev);
1016
1017 return 0;
1018 }
1019
1020 DEFINE_SIMPLE_ATTRIBUTE(min_key_size_fops, min_key_size_get,
1021 min_key_size_set, "%llu\n");
1022
max_key_size_set(void * data,u64 val)1023 static int max_key_size_set(void *data, u64 val)
1024 {
1025 struct hci_dev *hdev = data;
1026
1027 hci_dev_lock(hdev);
1028 if (val > SMP_MAX_ENC_KEY_SIZE || val < hdev->le_min_key_size) {
1029 hci_dev_unlock(hdev);
1030 return -EINVAL;
1031 }
1032
1033 hdev->le_max_key_size = val;
1034 hci_dev_unlock(hdev);
1035
1036 return 0;
1037 }
1038
max_key_size_get(void * data,u64 * val)1039 static int max_key_size_get(void *data, u64 *val)
1040 {
1041 struct hci_dev *hdev = data;
1042
1043 hci_dev_lock(hdev);
1044 *val = hdev->le_max_key_size;
1045 hci_dev_unlock(hdev);
1046
1047 return 0;
1048 }
1049
1050 DEFINE_SIMPLE_ATTRIBUTE(max_key_size_fops, max_key_size_get,
1051 max_key_size_set, "%llu\n");
1052
auth_payload_timeout_set(void * data,u64 val)1053 static int auth_payload_timeout_set(void *data, u64 val)
1054 {
1055 struct hci_dev *hdev = data;
1056
1057 if (val < 0x0001 || val > 0xffff)
1058 return -EINVAL;
1059
1060 hci_dev_lock(hdev);
1061 hdev->auth_payload_timeout = val;
1062 hci_dev_unlock(hdev);
1063
1064 return 0;
1065 }
1066
auth_payload_timeout_get(void * data,u64 * val)1067 static int auth_payload_timeout_get(void *data, u64 *val)
1068 {
1069 struct hci_dev *hdev = data;
1070
1071 hci_dev_lock(hdev);
1072 *val = hdev->auth_payload_timeout;
1073 hci_dev_unlock(hdev);
1074
1075 return 0;
1076 }
1077
1078 DEFINE_SIMPLE_ATTRIBUTE(auth_payload_timeout_fops,
1079 auth_payload_timeout_get,
1080 auth_payload_timeout_set, "%llu\n");
1081
force_no_mitm_read(struct file * file,char __user * user_buf,size_t count,loff_t * ppos)1082 static ssize_t force_no_mitm_read(struct file *file,
1083 char __user *user_buf,
1084 size_t count, loff_t *ppos)
1085 {
1086 struct hci_dev *hdev = file->private_data;
1087 char buf[3];
1088
1089 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_NO_MITM) ? 'Y' : 'N';
1090 buf[1] = '\n';
1091 buf[2] = '\0';
1092 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
1093 }
1094
force_no_mitm_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)1095 static ssize_t force_no_mitm_write(struct file *file,
1096 const char __user *user_buf,
1097 size_t count, loff_t *ppos)
1098 {
1099 struct hci_dev *hdev = file->private_data;
1100 char buf[32];
1101 size_t buf_size = min(count, (sizeof(buf) - 1));
1102 bool enable;
1103
1104 if (copy_from_user(buf, user_buf, buf_size))
1105 return -EFAULT;
1106
1107 buf[buf_size] = '\0';
1108 if (strtobool(buf, &enable))
1109 return -EINVAL;
1110
1111 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_NO_MITM))
1112 return -EALREADY;
1113
1114 hci_dev_change_flag(hdev, HCI_FORCE_NO_MITM);
1115
1116 return count;
1117 }
1118
1119 static const struct file_operations force_no_mitm_fops = {
1120 .open = simple_open,
1121 .read = force_no_mitm_read,
1122 .write = force_no_mitm_write,
1123 .llseek = default_llseek,
1124 };
1125
1126 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
1127 HCI_QUIRK_STRICT_DUPLICATE_FILTER);
1128 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
1129 HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
1130
hci_debugfs_create_le(struct hci_dev * hdev)1131 void hci_debugfs_create_le(struct hci_dev *hdev)
1132 {
1133 debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
1134 &identity_fops);
1135 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
1136 &rpa_timeout_fops);
1137 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
1138 &random_address_fops);
1139 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
1140 &static_address_fops);
1141
1142 /* For controllers with a public address, provide a debug
1143 * option to force the usage of the configured static
1144 * address. By default the public address is used.
1145 */
1146 if (bacmp(&hdev->bdaddr, BDADDR_ANY))
1147 debugfs_create_file("force_static_address", 0644,
1148 hdev->debugfs, hdev,
1149 &force_static_address_fops);
1150
1151 debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
1152 &hdev->le_white_list_size);
1153 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
1154 &white_list_fops);
1155 debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs,
1156 &hdev->le_resolv_list_size);
1157 debugfs_create_file("resolv_list", 0444, hdev->debugfs, hdev,
1158 &resolv_list_fops);
1159 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
1160 hdev, &identity_resolving_keys_fops);
1161 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
1162 &long_term_keys_fops);
1163 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
1164 &conn_min_interval_fops);
1165 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
1166 &conn_max_interval_fops);
1167 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
1168 &conn_latency_fops);
1169 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
1170 &supervision_timeout_fops);
1171 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
1172 &adv_channel_map_fops);
1173 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
1174 &adv_min_interval_fops);
1175 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
1176 &adv_max_interval_fops);
1177 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
1178 &hdev->discov_interleaved_timeout);
1179 debugfs_create_file("min_key_size", 0644, hdev->debugfs, hdev,
1180 &min_key_size_fops);
1181 debugfs_create_file("max_key_size", 0644, hdev->debugfs, hdev,
1182 &max_key_size_fops);
1183 debugfs_create_file("auth_payload_timeout", 0644, hdev->debugfs, hdev,
1184 &auth_payload_timeout_fops);
1185 debugfs_create_file("force_no_mitm", 0644, hdev->debugfs, hdev,
1186 &force_no_mitm_fops);
1187
1188 debugfs_create_file("quirk_strict_duplicate_filter", 0644,
1189 hdev->debugfs, hdev,
1190 &quirk_strict_duplicate_filter_fops);
1191 debugfs_create_file("quirk_simultaneous_discovery", 0644,
1192 hdev->debugfs, hdev,
1193 &quirk_simultaneous_discovery_fops);
1194 }
1195
hci_debugfs_create_conn(struct hci_conn * conn)1196 void hci_debugfs_create_conn(struct hci_conn *conn)
1197 {
1198 struct hci_dev *hdev = conn->hdev;
1199 char name[6];
1200
1201 if (IS_ERR_OR_NULL(hdev->debugfs))
1202 return;
1203
1204 snprintf(name, sizeof(name), "%u", conn->handle);
1205 conn->debugfs = debugfs_create_dir(name, hdev->debugfs);
1206 }
1207