~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/bluetooth/hci_debugfs.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 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 
447 DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
448                         auto_accept_delay_set, "%llu\n");
449 
450 static 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 
464 static 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 
475 DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
476                         idle_timeout_set, "%llu\n");
477 
478 static 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 
492 static 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 
503 DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
504                         sniff_min_interval_set, "%llu\n");
505 
506 static 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 
520 static 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 
531 DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
532                         sniff_max_interval_set, "%llu\n");
533 
534 void hci_debugfs_create_bredr(struct hci_dev *hdev)
535 {
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 
545         if (lmp_ssp_capable(hdev)) {
546                 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
547                                     hdev, &ssp_debug_mode_fops);
548                 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
549                                     hdev, &auto_accept_delay_fops);
550         }
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         }
560 }
561 
562 static 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 
580 DEFINE_SHOW_ATTRIBUTE(identity);
581 
582 static 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 
599 static 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 
610 DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
611                         rpa_timeout_set, "%llu\n");
612 
613 static 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 
624 DEFINE_SHOW_ATTRIBUTE(random_address);
625 
626 static 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 
637 DEFINE_SHOW_ATTRIBUTE(static_address);
638 
639 static 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 
646         buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y': 'N';
647         buf[1] = '\n';
648         buf[2] = '\0';
649         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
650 }
651 
652 static 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;
657         bool enable;
658         int err;
659 
660         if (test_bit(HCI_UP, &hdev->flags))
661                 return -EBUSY;
662 
663         err = kstrtobool_from_user(user_buf, count, &enable);
664         if (err)
665                 return err;
666 
667         if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
668                 return -EALREADY;
669 
670         hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
671 
672         return count;
673 }
674 
675 static 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 
682 static 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 
695 DEFINE_SHOW_ATTRIBUTE(white_list);
696 
697 static 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 
710 DEFINE_SHOW_ATTRIBUTE(resolv_list);
711 
712 static 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 
728 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
729 
730 static 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 
746 DEFINE_SHOW_ATTRIBUTE(long_term_keys);
747 
748 static 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 
762 static 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 
773 DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
774                         conn_min_interval_set, "%llu\n");
775 
776 static 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 
790 static 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 
801 DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
802                         conn_max_interval_set, "%llu\n");
803 
804 static 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 
818 static 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 
829 DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get,
830                         conn_latency_set, "%llu\n");
831 
832 static 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 
846 static 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 
857 DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
858                         supervision_timeout_set, "%llu\n");
859 
860 static 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 
874 static 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 
885 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
886                         adv_channel_map_set, "%llu\n");
887 
888 static 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 
902 static 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 
913 DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
914                         adv_min_interval_set, "%llu\n");
915 
916 static 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 
930 static 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 
941 DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
942                         adv_max_interval_set, "%llu\n");
943 
944 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
945                        HCI_QUIRK_STRICT_DUPLICATE_FILTER);
946 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
947                        HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
948 
949 void hci_debugfs_create_le(struct hci_dev *hdev)
950 {
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);
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);
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);
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);
1004 }
1005 
1006 void 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 }
1017 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp