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