projects/linux·blob master · refs

839 lines · 16.8 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
4 */
5
6#include <linux/cleanup.h>
7#include <linux/debugfs.h>
8#include <linux/dma-mapping.h>
9#include <linux/slab.h>
10#include <linux/uaccess.h>
11
12#include <soc/tegra/bpmp.h>
13#include <soc/tegra/bpmp-abi.h>
14
15static DEFINE_MUTEX(bpmp_debug_lock);
16
17struct seqbuf {
18 char *buf;
19 size_t pos;
20 size_t size;
21};
22
23static void seqbuf_init(struct seqbuf *seqbuf, void *buf, size_t size)
24{
25 seqbuf->buf = buf;
26 seqbuf->size = size;
27 seqbuf->pos = 0;
28}
29
30static size_t seqbuf_avail(struct seqbuf *seqbuf)
31{
32 return seqbuf->pos < seqbuf->size ? seqbuf->size - seqbuf->pos : 0;
33}
34
35static size_t seqbuf_status(struct seqbuf *seqbuf)
36{
37 return seqbuf->pos <= seqbuf->size ? 0 : -EOVERFLOW;
38}
39
40static int seqbuf_eof(struct seqbuf *seqbuf)
41{
42 return seqbuf->pos >= seqbuf->size;
43}
44
45static int seqbuf_read(struct seqbuf *seqbuf, void *buf, size_t nbyte)
46{
47 nbyte = min(nbyte, seqbuf_avail(seqbuf));
48 memcpy(buf, seqbuf->buf + seqbuf->pos, nbyte);
49 seqbuf->pos += nbyte;
50 return seqbuf_status(seqbuf);
51}
52
53static int seqbuf_read_u32(struct seqbuf *seqbuf, u32 *v)
54{
55 return seqbuf_read(seqbuf, v, 4);
56}
57
58static int seqbuf_read_str(struct seqbuf *seqbuf, const char **str)
59{
60 *str = seqbuf->buf + seqbuf->pos;
61 seqbuf->pos += strnlen(*str, seqbuf_avail(seqbuf));
62 seqbuf->pos++;
63 return seqbuf_status(seqbuf);
64}
65
66static void seqbuf_seek(struct seqbuf *seqbuf, ssize_t offset)
67{
68 seqbuf->pos += offset;
69}
70
71/* map filename in Linux debugfs to corresponding entry in BPMP */
72static const char *get_filename(struct tegra_bpmp *bpmp,
73 const struct file *file, char *buf, int size)
74{
75 const char *root_path, *filename = NULL;
76 char *root_path_buf;
77 size_t root_len;
78 size_t root_path_buf_len = 512;
79
80 root_path_buf = kzalloc(root_path_buf_len, GFP_KERNEL);
81 if (!root_path_buf)
82 return NULL;
83
84 root_path = dentry_path(bpmp->debugfs_mirror, root_path_buf,
85 root_path_buf_len);
86 if (IS_ERR(root_path))
87 goto out;
88
89 root_len = strlen(root_path);
90
91 filename = dentry_path(file->f_path.dentry, buf, size);
92 if (IS_ERR(filename)) {
93 filename = NULL;
94 goto out;
95 }
96
97 if (strlen(filename) < root_len || strncmp(filename, root_path, root_len)) {
98 filename = NULL;
99 goto out;
100 }
101
102 filename += root_len;
103
104out:
105 kfree(root_path_buf);
106 return filename;
107}
108
109static int mrq_debug_open(struct tegra_bpmp *bpmp, const char *name,
110 u32 *fd, u32 *len, bool write)
111{
112 struct mrq_debug_request req = {
113 .cmd = write ? CMD_DEBUG_OPEN_WO : CMD_DEBUG_OPEN_RO,
114 };
115 struct mrq_debug_response resp;
116 struct tegra_bpmp_message msg = {
117 .mrq = MRQ_DEBUG,
118 .tx = {
119 .data = &req,
120 .size = sizeof(req),
121 },
122 .rx = {
123 .data = &resp,
124 .size = sizeof(resp),
125 },
126 };
127 ssize_t sz_name;
128 int err = 0;
129
130 sz_name = strscpy(req.fop.name, name, sizeof(req.fop.name));
131 if (sz_name < 0) {
132 pr_err("File name too large: %s\n", name);
133 return -EINVAL;
134 }
135
136 err = tegra_bpmp_transfer(bpmp, &msg);
137 if (err < 0)
138 return err;
139 else if (msg.rx.ret < 0)
140 return -EINVAL;
141
142 *len = resp.fop.datalen;
143 *fd = resp.fop.fd;
144
145 return 0;
146}
147
148static int mrq_debug_close(struct tegra_bpmp *bpmp, u32 fd)
149{
150 struct mrq_debug_request req = {
151 .cmd = CMD_DEBUG_CLOSE,
152 .frd = {
153 .fd = fd,
154 },
155 };
156 struct mrq_debug_response resp;
157 struct tegra_bpmp_message msg = {
158 .mrq = MRQ_DEBUG,
159 .tx = {
160 .data = &req,
161 .size = sizeof(req),
162 },
163 .rx = {
164 .data = &resp,
165 .size = sizeof(resp),
166 },
167 };
168 int err = 0;
169
170 err = tegra_bpmp_transfer(bpmp, &msg);
171 if (err < 0)
172 return err;
173 else if (msg.rx.ret < 0)
174 return -EINVAL;
175
176 return 0;
177}
178
179static int mrq_debug_read(struct tegra_bpmp *bpmp, const char *name,
180 char *data, size_t sz_data, u32 *nbytes)
181{
182 struct mrq_debug_request req = {
183 .cmd = CMD_DEBUG_READ,
184 };
185 struct mrq_debug_response resp;
186 struct tegra_bpmp_message msg = {
187 .mrq = MRQ_DEBUG,
188 .tx = {
189 .data = &req,
190 .size = sizeof(req),
191 },
192 .rx = {
193 .data = &resp,
194 .size = sizeof(resp),
195 },
196 };
197 u32 fd = 0, len = 0;
198 int remaining, err, close_err;
199
200 mutex_lock(&bpmp_debug_lock);
201 err = mrq_debug_open(bpmp, name, &fd, &len, 0);
202 if (err)
203 goto out;
204
205 if (len > sz_data) {
206 err = -EFBIG;
207 goto close;
208 }
209
210 req.frd.fd = fd;
211 remaining = len;
212
213 while (remaining > 0) {
214 err = tegra_bpmp_transfer(bpmp, &msg);
215 if (err < 0) {
216 goto close;
217 } else if (msg.rx.ret < 0) {
218 err = -EINVAL;
219 goto close;
220 }
221
222 if (resp.frd.readlen > remaining) {
223 pr_err("%s: read data length invalid\n", __func__);
224 err = -EINVAL;
225 goto close;
226 }
227
228 memcpy(data, resp.frd.data, resp.frd.readlen);
229 data += resp.frd.readlen;
230 remaining -= resp.frd.readlen;
231 }
232
233 *nbytes = len;
234
235close:
236 close_err = mrq_debug_close(bpmp, fd);
237 if (!err)
238 err = close_err;
239out:
240 mutex_unlock(&bpmp_debug_lock);
241 return err;
242}
243
244static int mrq_debug_write(struct tegra_bpmp *bpmp, const char *name,
245 uint8_t *data, size_t sz_data)
246{
247 struct mrq_debug_request req = {
248 .cmd = CMD_DEBUG_WRITE
249 };
250 struct mrq_debug_response resp;
251 struct tegra_bpmp_message msg = {
252 .mrq = MRQ_DEBUG,
253 .tx = {
254 .data = &req,
255 .size = sizeof(req),
256 },
257 .rx = {
258 .data = &resp,
259 .size = sizeof(resp),
260 },
261 };
262 u32 fd = 0, len = 0;
263 size_t remaining;
264 int err;
265
266 mutex_lock(&bpmp_debug_lock);
267 err = mrq_debug_open(bpmp, name, &fd, &len, 1);
268 if (err)
269 goto out;
270
271 if (sz_data > len) {
272 err = -EINVAL;
273 goto close;
274 }
275
276 req.fwr.fd = fd;
277 remaining = sz_data;
278
279 while (remaining > 0) {
280 len = min(remaining, sizeof(req.fwr.data));
281 memcpy(req.fwr.data, data, len);
282 req.fwr.datalen = len;
283
284 err = tegra_bpmp_transfer(bpmp, &msg);
285 if (err < 0) {
286 goto close;
287 } else if (msg.rx.ret < 0) {
288 err = -EINVAL;
289 goto close;
290 }
291
292 data += req.fwr.datalen;
293 remaining -= req.fwr.datalen;
294 }
295
296close:
297 err = mrq_debug_close(bpmp, fd);
298out:
299 mutex_unlock(&bpmp_debug_lock);
300 return err;
301}
302
303static int bpmp_debug_show(struct seq_file *m, void *p)
304{
305 struct file *file = m->private;
306 struct inode *inode = file_inode(file);
307 struct tegra_bpmp *bpmp = inode->i_private;
308 char fnamebuf[256];
309 const char *filename;
310 struct mrq_debug_request req = {
311 .cmd = CMD_DEBUG_READ,
312 };
313 struct mrq_debug_response resp;
314 struct tegra_bpmp_message msg = {
315 .mrq = MRQ_DEBUG,
316 .tx = {
317 .data = &req,
318 .size = sizeof(req),
319 },
320 .rx = {
321 .data = &resp,
322 .size = sizeof(resp),
323 },
324 };
325 u32 fd = 0, len = 0;
326 int remaining, err, close_err;
327
328 filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf));
329 if (!filename)
330 return -ENOENT;
331
332 mutex_lock(&bpmp_debug_lock);
333 err = mrq_debug_open(bpmp, filename, &fd, &len, 0);
334 if (err)
335 goto out;
336
337 req.frd.fd = fd;
338 remaining = len;
339
340 while (remaining > 0) {
341 err = tegra_bpmp_transfer(bpmp, &msg);
342 if (err < 0) {
343 goto close;
344 } else if (msg.rx.ret < 0) {
345 err = -EINVAL;
346 goto close;
347 }
348
349 if (resp.frd.readlen > remaining) {
350 pr_err("%s: read data length invalid\n", __func__);
351 err = -EINVAL;
352 goto close;
353 }
354
355 seq_write(m, resp.frd.data, resp.frd.readlen);
356 remaining -= resp.frd.readlen;
357 }
358
359close:
360 close_err = mrq_debug_close(bpmp, fd);
361 if (!err)
362 err = close_err;
363out:
364 mutex_unlock(&bpmp_debug_lock);
365 return err;
366}
367
368static ssize_t bpmp_debug_store(struct file *file, const char __user *buf,
369 size_t count, loff_t *f_pos)
370{
371 struct inode *inode = file_inode(file);
372 struct tegra_bpmp *bpmp = inode->i_private;
373 char *databuf = NULL;
374 char fnamebuf[256];
375 const char *filename;
376 ssize_t err;
377
378 filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf));
379 if (!filename)
380 return -ENOENT;
381
382 databuf = memdup_user(buf, count);
383 if (IS_ERR(databuf))
384 return PTR_ERR(databuf);
385
386 err = mrq_debug_write(bpmp, filename, databuf, count);
387 kfree(databuf);
388
389 return err ?: count;
390}
391
392static int bpmp_debug_open(struct inode *inode, struct file *file)
393{
394 return single_open_size(file, bpmp_debug_show, file, SZ_256K);
395}
396
397static const struct file_operations bpmp_debug_fops = {
398 .open = bpmp_debug_open,
399 .read = seq_read,
400 .llseek = seq_lseek,
401 .write = bpmp_debug_store,
402 .release = single_release,
403};
404
405static int bpmp_populate_debugfs_inband(struct tegra_bpmp *bpmp,
406 struct dentry *parent,
407 char *ppath)
408{
409 const size_t pathlen = SZ_256;
410 const size_t bufsize = SZ_16K;
411 struct dentry *dentry;
412 u32 dsize, attrs = 0;
413 struct seqbuf seqbuf;
414 char *buf, *pathbuf;
415 const char *name;
416 int err = 0;
417
418 if (!bpmp || !parent || !ppath)
419 return -EINVAL;
420
421 buf = kmalloc(bufsize, GFP_KERNEL);
422 if (!buf)
423 return -ENOMEM;
424
425 pathbuf = kzalloc(pathlen, GFP_KERNEL);
426 if (!pathbuf) {
427 kfree(buf);
428 return -ENOMEM;
429 }
430
431 err = mrq_debug_read(bpmp, ppath, buf, bufsize, &dsize);
432 if (err)
433 goto out;
434
435 seqbuf_init(&seqbuf, buf, dsize);
436
437 while (!seqbuf_eof(&seqbuf)) {
438 err = seqbuf_read_u32(&seqbuf, &attrs);
439 if (err)
440 goto out;
441
442 err = seqbuf_read_str(&seqbuf, &name);
443 if (err < 0)
444 goto out;
445
446 if (attrs & DEBUGFS_S_ISDIR) {
447 size_t len;
448
449 dentry = debugfs_create_dir(name, parent);
450 if (IS_ERR(dentry)) {
451 err = PTR_ERR(dentry);
452 goto out;
453 }
454
455 len = snprintf(pathbuf, pathlen, "%s%s/", ppath, name);
456 if (len >= pathlen) {
457 err = -EINVAL;
458 goto out;
459 }
460
461 err = bpmp_populate_debugfs_inband(bpmp, dentry,
462 pathbuf);
463 if (err < 0)
464 goto out;
465 } else {
466 umode_t mode;
467
468 mode = attrs & DEBUGFS_S_IRUSR ? 0400 : 0;
469 mode |= attrs & DEBUGFS_S_IWUSR ? 0200 : 0;
470 dentry = debugfs_create_file(name, mode, parent, bpmp,
471 &bpmp_debug_fops);
472 if (IS_ERR(dentry)) {
473 err = PTR_ERR(dentry);
474 goto out;
475 }
476 }
477 }
478
479out:
480 kfree(pathbuf);
481 kfree(buf);
482
483 return err;
484}
485
486static int mrq_debugfs_read(struct tegra_bpmp *bpmp,
487 dma_addr_t name, size_t sz_name,
488 dma_addr_t data, size_t sz_data,
489 size_t *nbytes)
490{
491 struct mrq_debugfs_request req = {
492 .cmd = CMD_DEBUGFS_READ,
493 .fop = {
494 .fnameaddr = (u32)name,
495 .fnamelen = (u32)sz_name,
496 .dataaddr = (u32)data,
497 .datalen = (u32)sz_data,
498 },
499 };
500 struct mrq_debugfs_response resp;
501 struct tegra_bpmp_message msg = {
502 .mrq = MRQ_DEBUGFS,
503 .tx = {
504 .data = &req,
505 .size = sizeof(req),
506 },
507 .rx = {
508 .data = &resp,
509 .size = sizeof(resp),
510 },
511 };
512 int err;
513
514 err = tegra_bpmp_transfer(bpmp, &msg);
515 if (err < 0)
516 return err;
517 else if (msg.rx.ret < 0)
518 return -EINVAL;
519
520 *nbytes = (size_t)resp.fop.nbytes;
521
522 return 0;
523}
524
525static int mrq_debugfs_write(struct tegra_bpmp *bpmp,
526 dma_addr_t name, size_t sz_name,
527 dma_addr_t data, size_t sz_data)
528{
529 const struct mrq_debugfs_request req = {
530 .cmd = CMD_DEBUGFS_WRITE,
531 .fop = {
532 .fnameaddr = (u32)name,
533 .fnamelen = (u32)sz_name,
534 .dataaddr = (u32)data,
535 .datalen = (u32)sz_data,
536 },
537 };
538 struct tegra_bpmp_message msg = {
539 .mrq = MRQ_DEBUGFS,
540 .tx = {
541 .data = &req,
542 .size = sizeof(req),
543 },
544 };
545
546 return tegra_bpmp_transfer(bpmp, &msg);
547}
548
549static int mrq_debugfs_dumpdir(struct tegra_bpmp *bpmp, dma_addr_t addr,
550 size_t size, size_t *nbytes)
551{
552 const struct mrq_debugfs_request req = {
553 .cmd = CMD_DEBUGFS_DUMPDIR,
554 .dumpdir = {
555 .dataaddr = (u32)addr,
556 .datalen = (u32)size,
557 },
558 };
559 struct mrq_debugfs_response resp;
560 struct tegra_bpmp_message msg = {
561 .mrq = MRQ_DEBUGFS,
562 .tx = {
563 .data = &req,
564 .size = sizeof(req),
565 },
566 .rx = {
567 .data = &resp,
568 .size = sizeof(resp),
569 },
570 };
571 int err;
572
573 err = tegra_bpmp_transfer(bpmp, &msg);
574 if (err < 0)
575 return err;
576 else if (msg.rx.ret < 0)
577 return -EINVAL;
578
579 *nbytes = (size_t)resp.dumpdir.nbytes;
580
581 return 0;
582}
583
584static int debugfs_show(struct seq_file *m, void *p)
585{
586 struct file *file = m->private;
587 struct inode *inode = file_inode(file);
588 struct tegra_bpmp *bpmp = inode->i_private;
589 const size_t datasize = m->size;
590 const size_t namesize = SZ_256;
591 void *datavirt, *namevirt;
592 dma_addr_t dataphys, namephys;
593 char buf[256];
594 const char *filename;
595 size_t len, nbytes;
596 int err;
597
598 filename = get_filename(bpmp, file, buf, sizeof(buf));
599 if (!filename)
600 return -ENOENT;
601
602 namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys,
603 GFP_KERNEL | GFP_DMA32);
604 if (!namevirt)
605 return -ENOMEM;
606
607 datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys,
608 GFP_KERNEL | GFP_DMA32);
609 if (!datavirt) {
610 err = -ENOMEM;
611 goto free_namebuf;
612 }
613
614 len = strlen(filename);
615 strscpy_pad(namevirt, filename, namesize);
616
617 err = mrq_debugfs_read(bpmp, namephys, len, dataphys, datasize,
618 &nbytes);
619
620 if (!err)
621 seq_write(m, datavirt, nbytes);
622
623 dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys);
624free_namebuf:
625 dma_free_coherent(bpmp->dev, namesize, namevirt, namephys);
626
627 return err;
628}
629
630static int debugfs_open(struct inode *inode, struct file *file)
631{
632 return single_open_size(file, debugfs_show, file, SZ_128K);
633}
634
635static ssize_t debugfs_store(struct file *file, const char __user *buf,
636 size_t count, loff_t *f_pos)
637{
638 struct inode *inode = file_inode(file);
639 struct tegra_bpmp *bpmp = inode->i_private;
640 const size_t datasize = count;
641 const size_t namesize = SZ_256;
642 void *datavirt, *namevirt;
643 dma_addr_t dataphys, namephys;
644 char fnamebuf[256];
645 const char *filename;
646 size_t len;
647 int err;
648
649 filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf));
650 if (!filename)
651 return -ENOENT;
652
653 namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys,
654 GFP_KERNEL | GFP_DMA32);
655 if (!namevirt)
656 return -ENOMEM;
657
658 datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys,
659 GFP_KERNEL | GFP_DMA32);
660 if (!datavirt) {
661 err = -ENOMEM;
662 goto free_namebuf;
663 }
664
665 len = strlen(filename);
666 strscpy_pad(namevirt, filename, namesize);
667
668 if (copy_from_user(datavirt, buf, count)) {
669 err = -EFAULT;
670 goto free_databuf;
671 }
672
673 err = mrq_debugfs_write(bpmp, namephys, len, dataphys,
674 count);
675
676free_databuf:
677 dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys);
678free_namebuf:
679 dma_free_coherent(bpmp->dev, namesize, namevirt, namephys);
680
681 return err ?: count;
682}
683
684static const struct file_operations debugfs_fops = {
685 .open = debugfs_open,
686 .read = seq_read,
687 .llseek = seq_lseek,
688 .write = debugfs_store,
689 .release = single_release,
690};
691
692static int bpmp_populate_dir(struct tegra_bpmp *bpmp, struct seqbuf *seqbuf,
693 struct dentry *parent, u32 depth)
694{
695 int err;
696 u32 d, t;
697 const char *name;
698 struct dentry *dentry;
699
700 while (!seqbuf_eof(seqbuf)) {
701 err = seqbuf_read_u32(seqbuf, &d);
702 if (err < 0)
703 return err;
704
705 if (d < depth) {
706 seqbuf_seek(seqbuf, -4);
707 /* go up a level */
708 return 0;
709 } else if (d != depth) {
710 /* malformed data received from BPMP */
711 return -EIO;
712 }
713
714 err = seqbuf_read_u32(seqbuf, &t);
715 if (err < 0)
716 return err;
717 err = seqbuf_read_str(seqbuf, &name);
718 if (err < 0)
719 return err;
720
721 if (t & DEBUGFS_S_ISDIR) {
722 dentry = debugfs_create_dir(name, parent);
723 if (IS_ERR(dentry))
724 return PTR_ERR(dentry);
725 err = bpmp_populate_dir(bpmp, seqbuf, dentry, depth+1);
726 if (err < 0)
727 return err;
728 } else {
729 umode_t mode;
730
731 mode = t & DEBUGFS_S_IRUSR ? S_IRUSR : 0;
732 mode |= t & DEBUGFS_S_IWUSR ? S_IWUSR : 0;
733 dentry = debugfs_create_file(name, mode,
734 parent, bpmp,
735 &debugfs_fops);
736 if (IS_ERR(dentry))
737 return PTR_ERR(dentry);
738 }
739 }
740
741 return 0;
742}
743
744static int bpmp_populate_debugfs_shmem(struct tegra_bpmp *bpmp)
745{
746 struct seqbuf seqbuf;
747 const size_t sz = SZ_512K;
748 dma_addr_t phys;
749 size_t nbytes;
750 void *virt;
751 int err;
752
753 virt = dma_alloc_coherent(bpmp->dev, sz, &phys,
754 GFP_KERNEL | GFP_DMA32);
755 if (!virt)
756 return -ENOMEM;
757
758 err = mrq_debugfs_dumpdir(bpmp, phys, sz, &nbytes);
759 if (err < 0) {
760 goto free;
761 } else if (nbytes > sz) {
762 err = -EINVAL;
763 goto free;
764 }
765
766 seqbuf_init(&seqbuf, virt, nbytes);
767 err = bpmp_populate_dir(bpmp, &seqbuf, bpmp->debugfs_mirror, 0);
768free:
769 dma_free_coherent(bpmp->dev, sz, virt, phys);
770
771 return err;
772}
773
774static DEFINE_MUTEX(bpmp_debugfs_root_lock);
775static struct dentry *bpmp_debugfs_root;
776
777static struct dentry *bpmp_debugfs_get_root(void)
778{
779 guard(mutex)(&bpmp_debugfs_root_lock);
780 if (!bpmp_debugfs_root)
781 bpmp_debugfs_root = debugfs_create_dir("bpmp", NULL);
782 return bpmp_debugfs_root;
783}
784
785int tegra_bpmp_init_debugfs(struct tegra_bpmp *bpmp)
786{
787 struct dentry *root, *d;
788 char name[32];
789 bool inband;
790 int err;
791
792 inband = tegra_bpmp_mrq_is_supported(bpmp, MRQ_DEBUG);
793
794 if (!inband && !tegra_bpmp_mrq_is_supported(bpmp, MRQ_DEBUGFS))
795 return 0;
796
797 root = bpmp_debugfs_get_root();
798 if (IS_ERR(root))
799 return PTR_ERR(root);
800
801 if (dev_to_node(bpmp->dev) == NUMA_NO_NODE) {
802 d = root;
803 } else {
804 snprintf(name, sizeof(name), "%d-bpmp", dev_to_node(bpmp->dev));
805 d = debugfs_create_dir(name, root);
806 if (IS_ERR(d)) {
807 err = PTR_ERR(d);
808 goto out;
809 }
810 }
811
812 bpmp->debugfs_mirror = debugfs_create_dir("debug", d);
813 if (IS_ERR(bpmp->debugfs_mirror)) {
814 err = PTR_ERR(bpmp->debugfs_mirror);
815 goto out;
816 }
817
818 if (inband)
819 err = bpmp_populate_debugfs_inband(bpmp, bpmp->debugfs_mirror,
820 "/");
821 else
822 err = bpmp_populate_debugfs_shmem(bpmp);
823
824out:
825 if (err < 0) {
826 if (!IS_ERR(d))
827 debugfs_remove_recursive(d);
828
829 guard(mutex)(&bpmp_debugfs_root_lock);
830 if (root == d) {
831 bpmp_debugfs_root = NULL;
832 } else if (simple_empty(root)) {
833 debugfs_remove(root);
834 bpmp_debugfs_root = NULL;
835 }
836 }
837
838 return err;
839}