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