Merge branch 'linus' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[linux-2.6-microblaze.git] / net / bluetooth / hci_debugfs.c
1 /*
2    BlueZ - Bluetooth protocol stack for Linux
3
4    Copyright (C) 2014 Intel Corporation
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License version 2 as
8    published by the Free Software Foundation;
9
10    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
11    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
13    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
14    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
15    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18
19    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
20    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
21    SOFTWARE IS DISCLAIMED.
22 */
23
24 #include <linux/debugfs.h>
25
26 #include <net/bluetooth/bluetooth.h>
27 #include <net/bluetooth/hci_core.h>
28
29 #include "hci_debugfs.h"
30
31 #define DEFINE_QUIRK_ATTRIBUTE(__name, __quirk)                               \
32 static 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                                                                               \
45 static ssize_t __name ## _write(struct file *file,                            \
46                                  const char __user *user_buf,                 \
47                                  size_t count, loff_t *ppos)                  \
48 {                                                                             \
49         struct hci_dev *hdev = file->private_data;                            \
50         bool enable;                                                          \
51         int err;                                                              \
52                                                                               \
53         if (test_bit(HCI_UP, &hdev->flags))                                   \
54                 return -EBUSY;                                                \
55                                                                               \
56         err = kstrtobool_from_user(user_buf, count, &enable);                 \
57         if (err)                                                              \
58                 return err;                                                   \
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                                                                               \
68 static const struct file_operations __name ## _fops = {                       \
69         .open           = simple_open,                                        \
70         .read           = __name ## _read,                                    \
71         .write          = __name ## _write,                                   \
72         .llseek         = default_llseek,                                     \
73 }                                                                             \
74
75 #define DEFINE_INFO_ATTRIBUTE(__name, __field)                                \
76 static 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                                                                               \
87 DEFINE_SHOW_ATTRIBUTE(__name)
88
89 static 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);
95         for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++)
96                 seq_printf(f, "%2u: %8ph\n", p, hdev->features[p]);
97         if (lmp_le_capable(hdev))
98                 seq_printf(f, "LE: %8ph\n", hdev->le_features);
99         hci_dev_unlock(hdev);
100
101         return 0;
102 }
103
104 DEFINE_SHOW_ATTRIBUTE(features);
105
106 static 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
118 DEFINE_SHOW_ATTRIBUTE(device_id);
119
120 static 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
138 DEFINE_SHOW_ATTRIBUTE(device_list);
139
140 static 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
153 DEFINE_SHOW_ATTRIBUTE(blacklist);
154
155 static 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
178 DEFINE_SHOW_ATTRIBUTE(uuids);
179
180 static 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,
190                            16, data->hash256, 16, data->rand256);
191         }
192         hci_dev_unlock(hdev);
193
194         return 0;
195 }
196
197 DEFINE_SHOW_ATTRIBUTE(remote_oob);
198
199 static 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
213 static 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
224 DEFINE_SIMPLE_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get,
225                         conn_info_min_age_set, "%llu\n");
226
227 static 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
241 static 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
252 DEFINE_SIMPLE_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get,
253                         conn_info_max_age_set, "%llu\n");
254
255 static 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
261         buf[0] = hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS) ? 'Y': 'N';
262         buf[1] = '\n';
263         buf[2] = '\0';
264         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
265 }
266
267 static const struct file_operations use_debug_keys_fops = {
268         .open           = simple_open,
269         .read           = use_debug_keys_read,
270         .llseek         = default_llseek,
271 };
272
273 static 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
279         buf[0] = hci_dev_test_flag(hdev, HCI_SC_ONLY) ? 'Y': 'N';
280         buf[1] = '\n';
281         buf[2] = '\0';
282         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
283 }
284
285 static const struct file_operations sc_only_mode_fops = {
286         .open           = simple_open,
287         .read           = sc_only_mode_read,
288         .llseek         = default_llseek,
289 };
290
291 DEFINE_INFO_ATTRIBUTE(hardware_info, hw_info);
292 DEFINE_INFO_ATTRIBUTE(firmware_info, fw_info);
293
294 void hci_debugfs_create_common(struct hci_dev *hdev)
295 {
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);
302         debugfs_create_u8("hardware_error", 0444, hdev->debugfs,
303                           &hdev->hw_error_code);
304         debugfs_create_file("device_id", 0444, hdev->debugfs, hdev,
305                             &device_id_fops);
306
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);
312         debugfs_create_file("remote_oob", 0400, hdev->debugfs, hdev,
313                             &remote_oob_fops);
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);
319
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
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);
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);
335 }
336
337 static 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
361 DEFINE_SHOW_ATTRIBUTE(inquiry_cache);
362
363 static 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
377 DEFINE_SHOW_ATTRIBUTE(link_keys);
378
379 static 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
391 DEFINE_SHOW_ATTRIBUTE(dev_class);
392
393 static 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
404 DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get,
405                         NULL, "0x%4.4llx\n");
406
407 static 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
419 static const struct file_operations ssp_debug_mode_fops = {
420         .open           = simple_open,
421         .read           = ssp_debug_mode_read,
422         .llseek         = default_llseek,
423 };
424
425 static 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
436 static int min_encrypt_key_size_set(void *data, u64 val)
437 {
438         struct hci_dev *hdev = data;
439
440         if (val < 1 || val > 16)
441                 return -EINVAL;
442
443         hci_dev_lock(hdev);
444         hdev->min_enc_key_size = val;
445         hci_dev_unlock(hdev);
446
447         return 0;
448 }
449
450 static int min_encrypt_key_size_get(void *data, u64 *val)
451 {
452         struct hci_dev *hdev = data;
453
454         hci_dev_lock(hdev);
455         *val = hdev->min_enc_key_size;
456         hci_dev_unlock(hdev);
457
458         return 0;
459 }
460
461 DEFINE_SIMPLE_ATTRIBUTE(min_encrypt_key_size_fops,
462                         min_encrypt_key_size_get,
463                         min_encrypt_key_size_set, "%llu\n");
464
465 static int auto_accept_delay_get(void *data, u64 *val)
466 {
467         struct hci_dev *hdev = data;
468
469         hci_dev_lock(hdev);
470         *val = hdev->auto_accept_delay;
471         hci_dev_unlock(hdev);
472
473         return 0;
474 }
475
476 DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
477                         auto_accept_delay_set, "%llu\n");
478
479 static int idle_timeout_set(void *data, u64 val)
480 {
481         struct hci_dev *hdev = data;
482
483         if (val != 0 && (val < 500 || val > 3600000))
484                 return -EINVAL;
485
486         hci_dev_lock(hdev);
487         hdev->idle_timeout = val;
488         hci_dev_unlock(hdev);
489
490         return 0;
491 }
492
493 static int idle_timeout_get(void *data, u64 *val)
494 {
495         struct hci_dev *hdev = data;
496
497         hci_dev_lock(hdev);
498         *val = hdev->idle_timeout;
499         hci_dev_unlock(hdev);
500
501         return 0;
502 }
503
504 DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
505                         idle_timeout_set, "%llu\n");
506
507 static int sniff_min_interval_set(void *data, u64 val)
508 {
509         struct hci_dev *hdev = data;
510
511         if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
512                 return -EINVAL;
513
514         hci_dev_lock(hdev);
515         hdev->sniff_min_interval = val;
516         hci_dev_unlock(hdev);
517
518         return 0;
519 }
520
521 static int sniff_min_interval_get(void *data, u64 *val)
522 {
523         struct hci_dev *hdev = data;
524
525         hci_dev_lock(hdev);
526         *val = hdev->sniff_min_interval;
527         hci_dev_unlock(hdev);
528
529         return 0;
530 }
531
532 DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
533                         sniff_min_interval_set, "%llu\n");
534
535 static int sniff_max_interval_set(void *data, u64 val)
536 {
537         struct hci_dev *hdev = data;
538
539         if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
540                 return -EINVAL;
541
542         hci_dev_lock(hdev);
543         hdev->sniff_max_interval = val;
544         hci_dev_unlock(hdev);
545
546         return 0;
547 }
548
549 static int sniff_max_interval_get(void *data, u64 *val)
550 {
551         struct hci_dev *hdev = data;
552
553         hci_dev_lock(hdev);
554         *val = hdev->sniff_max_interval;
555         hci_dev_unlock(hdev);
556
557         return 0;
558 }
559
560 DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
561                         sniff_max_interval_set, "%llu\n");
562
563 void hci_debugfs_create_bredr(struct hci_dev *hdev)
564 {
565         debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev,
566                             &inquiry_cache_fops);
567         debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev,
568                             &link_keys_fops);
569         debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev,
570                             &dev_class_fops);
571         debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev,
572                             &voice_setting_fops);
573
574         if (lmp_ssp_capable(hdev)) {
575                 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
576                                     hdev, &ssp_debug_mode_fops);
577                 debugfs_create_file("min_encrypt_key_size", 0644, hdev->debugfs,
578                                     hdev, &min_encrypt_key_size_fops);
579                 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
580                                     hdev, &auto_accept_delay_fops);
581         }
582
583         if (lmp_sniff_capable(hdev)) {
584                 debugfs_create_file("idle_timeout", 0644, hdev->debugfs,
585                                     hdev, &idle_timeout_fops);
586                 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs,
587                                     hdev, &sniff_min_interval_fops);
588                 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs,
589                                     hdev, &sniff_max_interval_fops);
590         }
591 }
592
593 static int identity_show(struct seq_file *f, void *p)
594 {
595         struct hci_dev *hdev = f->private;
596         bdaddr_t addr;
597         u8 addr_type;
598
599         hci_dev_lock(hdev);
600
601         hci_copy_identity_address(hdev, &addr, &addr_type);
602
603         seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type,
604                    16, hdev->irk, &hdev->rpa);
605
606         hci_dev_unlock(hdev);
607
608         return 0;
609 }
610
611 DEFINE_SHOW_ATTRIBUTE(identity);
612
613 static int rpa_timeout_set(void *data, u64 val)
614 {
615         struct hci_dev *hdev = data;
616
617         /* Require the RPA timeout to be at least 30 seconds and at most
618          * 24 hours.
619          */
620         if (val < 30 || val > (60 * 60 * 24))
621                 return -EINVAL;
622
623         hci_dev_lock(hdev);
624         hdev->rpa_timeout = val;
625         hci_dev_unlock(hdev);
626
627         return 0;
628 }
629
630 static int rpa_timeout_get(void *data, u64 *val)
631 {
632         struct hci_dev *hdev = data;
633
634         hci_dev_lock(hdev);
635         *val = hdev->rpa_timeout;
636         hci_dev_unlock(hdev);
637
638         return 0;
639 }
640
641 DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
642                         rpa_timeout_set, "%llu\n");
643
644 static int random_address_show(struct seq_file *f, void *p)
645 {
646         struct hci_dev *hdev = f->private;
647
648         hci_dev_lock(hdev);
649         seq_printf(f, "%pMR\n", &hdev->random_addr);
650         hci_dev_unlock(hdev);
651
652         return 0;
653 }
654
655 DEFINE_SHOW_ATTRIBUTE(random_address);
656
657 static int static_address_show(struct seq_file *f, void *p)
658 {
659         struct hci_dev *hdev = f->private;
660
661         hci_dev_lock(hdev);
662         seq_printf(f, "%pMR\n", &hdev->static_addr);
663         hci_dev_unlock(hdev);
664
665         return 0;
666 }
667
668 DEFINE_SHOW_ATTRIBUTE(static_address);
669
670 static ssize_t force_static_address_read(struct file *file,
671                                          char __user *user_buf,
672                                          size_t count, loff_t *ppos)
673 {
674         struct hci_dev *hdev = file->private_data;
675         char buf[3];
676
677         buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y': 'N';
678         buf[1] = '\n';
679         buf[2] = '\0';
680         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
681 }
682
683 static ssize_t force_static_address_write(struct file *file,
684                                           const char __user *user_buf,
685                                           size_t count, loff_t *ppos)
686 {
687         struct hci_dev *hdev = file->private_data;
688         bool enable;
689         int err;
690
691         if (test_bit(HCI_UP, &hdev->flags))
692                 return -EBUSY;
693
694         err = kstrtobool_from_user(user_buf, count, &enable);
695         if (err)
696                 return err;
697
698         if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
699                 return -EALREADY;
700
701         hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
702
703         return count;
704 }
705
706 static const struct file_operations force_static_address_fops = {
707         .open           = simple_open,
708         .read           = force_static_address_read,
709         .write          = force_static_address_write,
710         .llseek         = default_llseek,
711 };
712
713 static int white_list_show(struct seq_file *f, void *ptr)
714 {
715         struct hci_dev *hdev = f->private;
716         struct bdaddr_list *b;
717
718         hci_dev_lock(hdev);
719         list_for_each_entry(b, &hdev->le_white_list, list)
720                 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
721         hci_dev_unlock(hdev);
722
723         return 0;
724 }
725
726 DEFINE_SHOW_ATTRIBUTE(white_list);
727
728 static int resolv_list_show(struct seq_file *f, void *ptr)
729 {
730         struct hci_dev *hdev = f->private;
731         struct bdaddr_list *b;
732
733         hci_dev_lock(hdev);
734         list_for_each_entry(b, &hdev->le_resolv_list, list)
735                 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
736         hci_dev_unlock(hdev);
737
738         return 0;
739 }
740
741 DEFINE_SHOW_ATTRIBUTE(resolv_list);
742
743 static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
744 {
745         struct hci_dev *hdev = f->private;
746         struct smp_irk *irk;
747
748         rcu_read_lock();
749         list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
750                 seq_printf(f, "%pMR (type %u) %*phN %pMR\n",
751                            &irk->bdaddr, irk->addr_type,
752                            16, irk->val, &irk->rpa);
753         }
754         rcu_read_unlock();
755
756         return 0;
757 }
758
759 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
760
761 static int long_term_keys_show(struct seq_file *f, void *ptr)
762 {
763         struct hci_dev *hdev = f->private;
764         struct smp_ltk *ltk;
765
766         rcu_read_lock();
767         list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list)
768                 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n",
769                            &ltk->bdaddr, ltk->bdaddr_type, ltk->authenticated,
770                            ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv),
771                            __le64_to_cpu(ltk->rand), 16, ltk->val);
772         rcu_read_unlock();
773
774         return 0;
775 }
776
777 DEFINE_SHOW_ATTRIBUTE(long_term_keys);
778
779 static int conn_min_interval_set(void *data, u64 val)
780 {
781         struct hci_dev *hdev = data;
782
783         if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval)
784                 return -EINVAL;
785
786         hci_dev_lock(hdev);
787         hdev->le_conn_min_interval = val;
788         hci_dev_unlock(hdev);
789
790         return 0;
791 }
792
793 static int conn_min_interval_get(void *data, u64 *val)
794 {
795         struct hci_dev *hdev = data;
796
797         hci_dev_lock(hdev);
798         *val = hdev->le_conn_min_interval;
799         hci_dev_unlock(hdev);
800
801         return 0;
802 }
803
804 DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
805                         conn_min_interval_set, "%llu\n");
806
807 static int conn_max_interval_set(void *data, u64 val)
808 {
809         struct hci_dev *hdev = data;
810
811         if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval)
812                 return -EINVAL;
813
814         hci_dev_lock(hdev);
815         hdev->le_conn_max_interval = val;
816         hci_dev_unlock(hdev);
817
818         return 0;
819 }
820
821 static int conn_max_interval_get(void *data, u64 *val)
822 {
823         struct hci_dev *hdev = data;
824
825         hci_dev_lock(hdev);
826         *val = hdev->le_conn_max_interval;
827         hci_dev_unlock(hdev);
828
829         return 0;
830 }
831
832 DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
833                         conn_max_interval_set, "%llu\n");
834
835 static int conn_latency_set(void *data, u64 val)
836 {
837         struct hci_dev *hdev = data;
838
839         if (val > 0x01f3)
840                 return -EINVAL;
841
842         hci_dev_lock(hdev);
843         hdev->le_conn_latency = val;
844         hci_dev_unlock(hdev);
845
846         return 0;
847 }
848
849 static int conn_latency_get(void *data, u64 *val)
850 {
851         struct hci_dev *hdev = data;
852
853         hci_dev_lock(hdev);
854         *val = hdev->le_conn_latency;
855         hci_dev_unlock(hdev);
856
857         return 0;
858 }
859
860 DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get,
861                         conn_latency_set, "%llu\n");
862
863 static int supervision_timeout_set(void *data, u64 val)
864 {
865         struct hci_dev *hdev = data;
866
867         if (val < 0x000a || val > 0x0c80)
868                 return -EINVAL;
869
870         hci_dev_lock(hdev);
871         hdev->le_supv_timeout = val;
872         hci_dev_unlock(hdev);
873
874         return 0;
875 }
876
877 static int supervision_timeout_get(void *data, u64 *val)
878 {
879         struct hci_dev *hdev = data;
880
881         hci_dev_lock(hdev);
882         *val = hdev->le_supv_timeout;
883         hci_dev_unlock(hdev);
884
885         return 0;
886 }
887
888 DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
889                         supervision_timeout_set, "%llu\n");
890
891 static int adv_channel_map_set(void *data, u64 val)
892 {
893         struct hci_dev *hdev = data;
894
895         if (val < 0x01 || val > 0x07)
896                 return -EINVAL;
897
898         hci_dev_lock(hdev);
899         hdev->le_adv_channel_map = val;
900         hci_dev_unlock(hdev);
901
902         return 0;
903 }
904
905 static int adv_channel_map_get(void *data, u64 *val)
906 {
907         struct hci_dev *hdev = data;
908
909         hci_dev_lock(hdev);
910         *val = hdev->le_adv_channel_map;
911         hci_dev_unlock(hdev);
912
913         return 0;
914 }
915
916 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
917                         adv_channel_map_set, "%llu\n");
918
919 static int adv_min_interval_set(void *data, u64 val)
920 {
921         struct hci_dev *hdev = data;
922
923         if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval)
924                 return -EINVAL;
925
926         hci_dev_lock(hdev);
927         hdev->le_adv_min_interval = val;
928         hci_dev_unlock(hdev);
929
930         return 0;
931 }
932
933 static int adv_min_interval_get(void *data, u64 *val)
934 {
935         struct hci_dev *hdev = data;
936
937         hci_dev_lock(hdev);
938         *val = hdev->le_adv_min_interval;
939         hci_dev_unlock(hdev);
940
941         return 0;
942 }
943
944 DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
945                         adv_min_interval_set, "%llu\n");
946
947 static int adv_max_interval_set(void *data, u64 val)
948 {
949         struct hci_dev *hdev = data;
950
951         if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval)
952                 return -EINVAL;
953
954         hci_dev_lock(hdev);
955         hdev->le_adv_max_interval = val;
956         hci_dev_unlock(hdev);
957
958         return 0;
959 }
960
961 static int adv_max_interval_get(void *data, u64 *val)
962 {
963         struct hci_dev *hdev = data;
964
965         hci_dev_lock(hdev);
966         *val = hdev->le_adv_max_interval;
967         hci_dev_unlock(hdev);
968
969         return 0;
970 }
971
972 DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
973                         adv_max_interval_set, "%llu\n");
974
975 static int auth_payload_timeout_set(void *data, u64 val)
976 {
977         struct hci_dev *hdev = data;
978
979         if (val < 0x0001 || val > 0xffff)
980                 return -EINVAL;
981
982         hci_dev_lock(hdev);
983         hdev->auth_payload_timeout = val;
984         hci_dev_unlock(hdev);
985
986         return 0;
987 }
988
989 static int auth_payload_timeout_get(void *data, u64 *val)
990 {
991         struct hci_dev *hdev = data;
992
993         hci_dev_lock(hdev);
994         *val = hdev->auth_payload_timeout;
995         hci_dev_unlock(hdev);
996
997         return 0;
998 }
999
1000 DEFINE_SIMPLE_ATTRIBUTE(auth_payload_timeout_fops,
1001                         auth_payload_timeout_get,
1002                         auth_payload_timeout_set, "%llu\n");
1003
1004 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
1005                        HCI_QUIRK_STRICT_DUPLICATE_FILTER);
1006 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
1007                        HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
1008
1009 void hci_debugfs_create_le(struct hci_dev *hdev)
1010 {
1011         debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
1012                             &identity_fops);
1013         debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
1014                             &rpa_timeout_fops);
1015         debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
1016                             &random_address_fops);
1017         debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
1018                             &static_address_fops);
1019
1020         /* For controllers with a public address, provide a debug
1021          * option to force the usage of the configured static
1022          * address. By default the public address is used.
1023          */
1024         if (bacmp(&hdev->bdaddr, BDADDR_ANY))
1025                 debugfs_create_file("force_static_address", 0644,
1026                                     hdev->debugfs, hdev,
1027                                     &force_static_address_fops);
1028
1029         debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
1030                           &hdev->le_white_list_size);
1031         debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
1032                             &white_list_fops);
1033         debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs,
1034                           &hdev->le_resolv_list_size);
1035         debugfs_create_file("resolv_list", 0444, hdev->debugfs, hdev,
1036                             &resolv_list_fops);
1037         debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
1038                             hdev, &identity_resolving_keys_fops);
1039         debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
1040                             &long_term_keys_fops);
1041         debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
1042                             &conn_min_interval_fops);
1043         debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
1044                             &conn_max_interval_fops);
1045         debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
1046                             &conn_latency_fops);
1047         debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
1048                             &supervision_timeout_fops);
1049         debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
1050                             &adv_channel_map_fops);
1051         debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
1052                             &adv_min_interval_fops);
1053         debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
1054                             &adv_max_interval_fops);
1055         debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
1056                            &hdev->discov_interleaved_timeout);
1057         debugfs_create_file("auth_payload_timeout", 0644, hdev->debugfs, hdev,
1058                             &auth_payload_timeout_fops);
1059
1060         debugfs_create_file("quirk_strict_duplicate_filter", 0644,
1061                             hdev->debugfs, hdev,
1062                             &quirk_strict_duplicate_filter_fops);
1063         debugfs_create_file("quirk_simultaneous_discovery", 0644,
1064                             hdev->debugfs, hdev,
1065                             &quirk_simultaneous_discovery_fops);
1066 }
1067
1068 void hci_debugfs_create_conn(struct hci_conn *conn)
1069 {
1070         struct hci_dev *hdev = conn->hdev;
1071         char name[6];
1072
1073         if (IS_ERR_OR_NULL(hdev->debugfs))
1074                 return;
1075
1076         snprintf(name, sizeof(name), "%u", conn->handle);
1077         conn->debugfs = debugfs_create_dir(name, hdev->debugfs);
1078 }