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