drivers/firmware/tegra/bpmp-debugfs.c

   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         size_t root_path_buf_len = 512;
  81
  82         root_path_buf = kzalloc(root_path_buf_len, GFP_KERNEL);
  83         if (!root_path_buf)
  84                 goto out;
  85
  86         root_path = dentry_path(bpmp->debugfs_mirror, root_path_buf,
  87                                 root_path_buf_len);
  88         if (IS_ERR(root_path))
  89                 goto out;
  90
  91         root_len = strlen(root_path);
  92
  93         filename = dentry_path(file->f_path.dentry, buf, size);
  94         if (IS_ERR(filename)) {
  95                 filename = NULL;
  96                 goto out;
  97         }
  98
  99         if (strlen(filename) < root_len || strncmp(filename, root_path, root_len)) {
 100                 filename = NULL;
 101                 goto out;
 102         }
 103
 104         filename += root_len;
 105
 106 out:
 107         kfree(root_path_buf);
 108         return filename;
 109 }
 110
 111 static int mrq_debug_open(struct tegra_bpmp *bpmp, const char *name,
 112                           uint32_t *fd, uint32_t *len, bool write)
 113 {
 114         struct mrq_debug_request req = {
 115                 .cmd = cpu_to_le32(write ? CMD_DEBUG_OPEN_WO : CMD_DEBUG_OPEN_RO),
 116         };
 117         struct mrq_debug_response resp;
 118         struct tegra_bpmp_message msg = {
 119                 .mrq = MRQ_DEBUG,
 120                 .tx = {
 121                         .data = &req,
 122                         .size = sizeof(req),
 123                 },
 124                 .rx = {
 125                         .data = &resp,
 126                         .size = sizeof(resp),
 127                 },
 128         };
 129         ssize_t sz_name;
 130         int err = 0;
 131
 132         sz_name = strscpy(req.fop.name, name, sizeof(req.fop.name));
 133         if (sz_name < 0) {
 134                 pr_err("File name too large: %s\n", name);
 135                 return -EINVAL;
 136         }
 137
 138         err = tegra_bpmp_transfer(bpmp, &msg);
 139         if (err < 0)
 140                 return err;
 141         else if (msg.rx.ret < 0)
 142                 return -EINVAL;
 143
 144         *len = resp.fop.datalen;
 145         *fd = resp.fop.fd;
 146
 147         return 0;
 148 }
 149
 150 static int mrq_debug_close(struct tegra_bpmp *bpmp, uint32_t fd)
 151 {
 152         struct mrq_debug_request req = {
 153                 .cmd = cpu_to_le32(CMD_DEBUG_CLOSE),
 154                 .frd = {
 155                         .fd = fd,
 156                 },
 157         };
 158         struct mrq_debug_response resp;
 159         struct tegra_bpmp_message msg = {
 160                 .mrq = MRQ_DEBUG,
 161                 .tx = {
 162                         .data = &req,
 163                         .size = sizeof(req),
 164                 },
 165                 .rx = {
 166                         .data = &resp,
 167                         .size = sizeof(resp),
 168                 },
 169         };
 170         int err = 0;
 171
 172         err = tegra_bpmp_transfer(bpmp, &msg);
 173         if (err < 0)
 174                 return err;
 175         else if (msg.rx.ret < 0)
 176                 return -EINVAL;
 177
 178         return 0;
 179 }
 180
 181 static int mrq_debug_read(struct tegra_bpmp *bpmp, const char *name,
 182                           char *data, size_t sz_data, uint32_t *nbytes)
 183 {
 184         struct mrq_debug_request req = {
 185                 .cmd = cpu_to_le32(CMD_DEBUG_READ),
 186         };
 187         struct mrq_debug_response resp;
 188         struct tegra_bpmp_message msg = {
 189                 .mrq = MRQ_DEBUG,
 190                 .tx = {
 191                         .data = &req,
 192                         .size = sizeof(req),
 193                 },
 194                 .rx = {
 195                         .data = &resp,
 196                         .size = sizeof(resp),
 197                 },
 198         };
 199         uint32_t fd = 0, len = 0;
 200         int remaining, err;
 201
 202         mutex_lock(&bpmp_debug_lock);
 203         err = mrq_debug_open(bpmp, name, &fd, &len, 0);
 204         if (err)
 205                 goto out;
 206
 207         if (len > sz_data) {
 208                 err = -EFBIG;
 209                 goto close;
 210         }
 211
 212         req.frd.fd = fd;
 213         remaining = len;
 214
 215         while (remaining > 0) {
 216                 err = tegra_bpmp_transfer(bpmp, &msg);
 217                 if (err < 0) {
 218                         goto close;
 219                 } else if (msg.rx.ret < 0) {
 220                         err = -EINVAL;
 221                         goto close;
 222                 }
 223
 224                 if (resp.frd.readlen > remaining) {
 225                         pr_err("%s: read data length invalid\n", __func__);
 226                         err = -EINVAL;
 227                         goto close;
 228                 }
 229
 230                 memcpy(data, resp.frd.data, resp.frd.readlen);
 231                 data += resp.frd.readlen;
 232                 remaining -= resp.frd.readlen;
 233         }
 234
 235         *nbytes = len;
 236
 237 close:
 238         err = mrq_debug_close(bpmp, fd);
 239 out:
 240         mutex_unlock(&bpmp_debug_lock);
 241         return err;
 242 }
 243
 244 static 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 = cpu_to_le32(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         uint32_t 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
 296 close:
 297         err = mrq_debug_close(bpmp, fd);
 298 out:
 299         mutex_unlock(&bpmp_debug_lock);
 300         return err;
 301 }
 302
 303 static 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 = cpu_to_le32(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         uint32_t fd = 0, len = 0;
 326         int remaining, 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
 359 close:
 360         err = mrq_debug_close(bpmp, fd);
 361 out:
 362         mutex_unlock(&bpmp_debug_lock);
 363         return err;
 364 }
 365
 366 static ssize_t bpmp_debug_store(struct file *file, const char __user *buf,
 367                 size_t count, loff_t *f_pos)
 368 {
 369         struct inode *inode = file_inode(file);
 370         struct tegra_bpmp *bpmp = inode->i_private;
 371         char *databuf = NULL;
 372         char fnamebuf[256];
 373         const char *filename;
 374         ssize_t err;
 375
 376         filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf));
 377         if (!filename)
 378                 return -ENOENT;
 379
 380         databuf = kmalloc(count, GFP_KERNEL);
 381         if (!databuf)
 382                 return -ENOMEM;
 383
 384         if (copy_from_user(databuf, buf, count)) {
 385                 err = -EFAULT;
 386                 goto free_ret;
 387         }
 388
 389         err = mrq_debug_write(bpmp, filename, databuf, count);
 390
 391 free_ret:
 392         kfree(databuf);
 393
 394         return err ?: count;
 395 }
 396
 397 static int bpmp_debug_open(struct inode *inode, struct file *file)
 398 {
 399         return single_open_size(file, bpmp_debug_show, file, SZ_256K);
 400 }
 401
 402 static const struct file_operations bpmp_debug_fops = {
 403         .open           = bpmp_debug_open,
 404         .read           = seq_read,
 405         .llseek         = seq_lseek,
 406         .write          = bpmp_debug_store,
 407         .release        = single_release,
 408 };
 409
 410 static int bpmp_populate_debugfs_inband(struct tegra_bpmp *bpmp,
 411                                         struct dentry *parent,
 412                                         char *ppath)
 413 {
 414         const size_t pathlen = SZ_256;
 415         const size_t bufsize = SZ_16K;
 416         uint32_t dsize, attrs = 0;
 417         struct dentry *dentry;
 418         struct seqbuf seqbuf;
 419         char *buf, *pathbuf;
 420         const char *name;
 421         int err = 0;
 422
 423         if (!bpmp || !parent || !ppath)
 424                 return -EINVAL;
 425
 426         buf = kmalloc(bufsize, GFP_KERNEL);
 427         if (!buf)
 428                 return -ENOMEM;
 429
 430         pathbuf = kzalloc(pathlen, GFP_KERNEL);
 431         if (!pathbuf) {
 432                 kfree(buf);
 433                 return -ENOMEM;
 434         }
 435
 436         err = mrq_debug_read(bpmp, ppath, buf, bufsize, &dsize);
 437         if (err)
 438                 goto out;
 439
 440         seqbuf_init(&seqbuf, buf, dsize);
 441
 442         while (!seqbuf_eof(&seqbuf)) {
 443                 err = seqbuf_read_u32(&seqbuf, &attrs);
 444                 if (err)
 445                         goto out;
 446
 447                 err = seqbuf_read_str(&seqbuf, &name);
 448                 if (err < 0)
 449                         goto out;
 450
 451                 if (attrs & DEBUGFS_S_ISDIR) {
 452                         size_t len;
 453
 454                         dentry = debugfs_create_dir(name, parent);
 455                         if (IS_ERR(dentry)) {
 456                                 err = PTR_ERR(dentry);
 457                                 goto out;
 458                         }
 459
 460                         len = snprintf(pathbuf, pathlen, "%s%s/", ppath, name);
 461                         if (len >= pathlen) {
 462                                 err = -EINVAL;
 463                                 goto out;
 464                         }
 465
 466                         err = bpmp_populate_debugfs_inband(bpmp, dentry,
 467                                                            pathbuf);
 468                         if (err < 0)
 469                                 goto out;
 470                 } else {
 471                         umode_t mode;
 472
 473                         mode = attrs & DEBUGFS_S_IRUSR ? 0400 : 0;
 474                         mode |= attrs & DEBUGFS_S_IWUSR ? 0200 : 0;
 475                         dentry = debugfs_create_file(name, mode, parent, bpmp,
 476                                                      &bpmp_debug_fops);
 477                         if (!dentry) {
 478                                 err = -ENOMEM;
 479                                 goto out;
 480                         }
 481                 }
 482         }
 483
 484 out:
 485         kfree(pathbuf);
 486         kfree(buf);
 487
 488         return err;
 489 }
 490
 491 static int mrq_debugfs_read(struct tegra_bpmp *bpmp,
 492                             dma_addr_t name, size_t sz_name,
 493                             dma_addr_t data, size_t sz_data,
 494                             size_t *nbytes)
 495 {
 496         struct mrq_debugfs_request req = {
 497                 .cmd = cpu_to_le32(CMD_DEBUGFS_READ),
 498                 .fop = {
 499                         .fnameaddr = cpu_to_le32((uint32_t)name),
 500                         .fnamelen = cpu_to_le32((uint32_t)sz_name),
 501                         .dataaddr = cpu_to_le32((uint32_t)data),
 502                         .datalen = cpu_to_le32((uint32_t)sz_data),
 503                 },
 504         };
 505         struct mrq_debugfs_response resp;
 506         struct tegra_bpmp_message msg = {
 507                 .mrq = MRQ_DEBUGFS,
 508                 .tx = {
 509                         .data = &req,
 510                         .size = sizeof(req),
 511                 },
 512                 .rx = {
 513                         .data = &resp,
 514                         .size = sizeof(resp),
 515                 },
 516         };
 517         int err;
 518
 519         err = tegra_bpmp_transfer(bpmp, &msg);
 520         if (err < 0)
 521                 return err;
 522         else if (msg.rx.ret < 0)
 523                 return -EINVAL;
 524
 525         *nbytes = (size_t)resp.fop.nbytes;
 526
 527         return 0;
 528 }
 529
 530 static int mrq_debugfs_write(struct tegra_bpmp *bpmp,
 531                              dma_addr_t name, size_t sz_name,
 532                              dma_addr_t data, size_t sz_data)
 533 {
 534         const struct mrq_debugfs_request req = {
 535                 .cmd = cpu_to_le32(CMD_DEBUGFS_WRITE),
 536                 .fop = {
 537                         .fnameaddr = cpu_to_le32((uint32_t)name),
 538                         .fnamelen = cpu_to_le32((uint32_t)sz_name),
 539                         .dataaddr = cpu_to_le32((uint32_t)data),
 540                         .datalen = cpu_to_le32((uint32_t)sz_data),
 541                 },
 542         };
 543         struct tegra_bpmp_message msg = {
 544                 .mrq = MRQ_DEBUGFS,
 545                 .tx = {
 546                         .data = &req,
 547                         .size = sizeof(req),
 548                 },
 549         };
 550
 551         return tegra_bpmp_transfer(bpmp, &msg);
 552 }
 553
 554 static int mrq_debugfs_dumpdir(struct tegra_bpmp *bpmp, dma_addr_t addr,
 555                                size_t size, size_t *nbytes)
 556 {
 557         const struct mrq_debugfs_request req = {
 558                 .cmd = cpu_to_le32(CMD_DEBUGFS_DUMPDIR),
 559                 .dumpdir = {
 560                         .dataaddr = cpu_to_le32((uint32_t)addr),
 561                         .datalen = cpu_to_le32((uint32_t)size),
 562                 },
 563         };
 564         struct mrq_debugfs_response resp;
 565         struct tegra_bpmp_message msg = {
 566                 .mrq = MRQ_DEBUGFS,
 567                 .tx = {
 568                         .data = &req,
 569                         .size = sizeof(req),
 570                 },
 571                 .rx = {
 572                         .data = &resp,
 573                         .size = sizeof(resp),
 574                 },
 575         };
 576         int err;
 577
 578         err = tegra_bpmp_transfer(bpmp, &msg);
 579         if (err < 0)
 580                 return err;
 581         else if (msg.rx.ret < 0)
 582                 return -EINVAL;
 583
 584         *nbytes = (size_t)resp.dumpdir.nbytes;
 585
 586         return 0;
 587 }
 588
 589 static int debugfs_show(struct seq_file *m, void *p)
 590 {
 591         struct file *file = m->private;
 592         struct inode *inode = file_inode(file);
 593         struct tegra_bpmp *bpmp = inode->i_private;
 594         const size_t datasize = m->size;
 595         const size_t namesize = SZ_256;
 596         void *datavirt, *namevirt;
 597         dma_addr_t dataphys, namephys;
 598         char buf[256];
 599         const char *filename;
 600         size_t len, nbytes;
 601         int err;
 602
 603         filename = get_filename(bpmp, file, buf, sizeof(buf));
 604         if (!filename)
 605                 return -ENOENT;
 606
 607         namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys,
 608                                       GFP_KERNEL | GFP_DMA32);
 609         if (!namevirt)
 610                 return -ENOMEM;
 611
 612         datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys,
 613                                       GFP_KERNEL | GFP_DMA32);
 614         if (!datavirt) {
 615                 err = -ENOMEM;
 616                 goto free_namebuf;
 617         }
 618
 619         len = strlen(filename);
 620         strncpy(namevirt, filename, namesize);
 621
 622         err = mrq_debugfs_read(bpmp, namephys, len, dataphys, datasize,
 623                                &nbytes);
 624
 625         if (!err)
 626                 seq_write(m, datavirt, nbytes);
 627
 628         dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys);
 629 free_namebuf:
 630         dma_free_coherent(bpmp->dev, namesize, namevirt, namephys);
 631
 632         return err;
 633 }
 634
 635 static int debugfs_open(struct inode *inode, struct file *file)
 636 {
 637         return single_open_size(file, debugfs_show, file, SZ_128K);
 638 }
 639
 640 static ssize_t debugfs_store(struct file *file, const char __user *buf,
 641                 size_t count, loff_t *f_pos)
 642 {
 643         struct inode *inode = file_inode(file);
 644         struct tegra_bpmp *bpmp = inode->i_private;
 645         const size_t datasize = count;
 646         const size_t namesize = SZ_256;
 647         void *datavirt, *namevirt;
 648         dma_addr_t dataphys, namephys;
 649         char fnamebuf[256];
 650         const char *filename;
 651         size_t len;
 652         int err;
 653
 654         filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf));
 655         if (!filename)
 656                 return -ENOENT;
 657
 658         namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys,
 659                                       GFP_KERNEL | GFP_DMA32);
 660         if (!namevirt)
 661                 return -ENOMEM;
 662
 663         datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys,
 664                                       GFP_KERNEL | GFP_DMA32);
 665         if (!datavirt) {
 666                 err = -ENOMEM;
 667                 goto free_namebuf;
 668         }
 669
 670         len = strlen(filename);
 671         strncpy(namevirt, filename, namesize);
 672
 673         if (copy_from_user(datavirt, buf, count)) {
 674                 err = -EFAULT;
 675                 goto free_databuf;
 676         }
 677
 678         err = mrq_debugfs_write(bpmp, namephys, len, dataphys,
 679                                 count);
 680
 681 free_databuf:
 682         dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys);
 683 free_namebuf:
 684         dma_free_coherent(bpmp->dev, namesize, namevirt, namephys);
 685
 686         return err ?: count;
 687 }
 688
 689 static const struct file_operations debugfs_fops = {
 690         .open           = debugfs_open,
 691         .read           = seq_read,
 692         .llseek         = seq_lseek,
 693         .write          = debugfs_store,
 694         .release        = single_release,
 695 };
 696
 697 static int bpmp_populate_dir(struct tegra_bpmp *bpmp, struct seqbuf *seqbuf,
 698                              struct dentry *parent, uint32_t depth)
 699 {
 700         int err;
 701         uint32_t d, t;
 702         const char *name;
 703         struct dentry *dentry;
 704
 705         while (!seqbuf_eof(seqbuf)) {
 706                 err = seqbuf_read_u32(seqbuf, &d);
 707                 if (err < 0)
 708                         return err;
 709
 710                 if (d < depth) {
 711                         seqbuf_seek(seqbuf, -4);
 712                         /* go up a level */
 713                         return 0;
 714                 } else if (d != depth) {
 715                         /* malformed data received from BPMP */
 716                         return -EIO;
 717                 }
 718
 719                 err = seqbuf_read_u32(seqbuf, &t);
 720                 if (err < 0)
 721                         return err;
 722                 err = seqbuf_read_str(seqbuf, &name);
 723                 if (err < 0)
 724                         return err;
 725
 726                 if (t & DEBUGFS_S_ISDIR) {
 727                         dentry = debugfs_create_dir(name, parent);
 728                         if (!dentry)
 729                                 return -ENOMEM;
 730                         err = bpmp_populate_dir(bpmp, seqbuf, dentry, depth+1);
 731                         if (err < 0)
 732                                 return err;
 733                 } else {
 734                         umode_t mode;
 735
 736                         mode = t & DEBUGFS_S_IRUSR ? S_IRUSR : 0;
 737                         mode |= t & DEBUGFS_S_IWUSR ? S_IWUSR : 0;
 738                         dentry = debugfs_create_file(name, mode,
 739                                                      parent, bpmp,
 740                                                      &debugfs_fops);
 741                         if (!dentry)
 742                                 return -ENOMEM;
 743                 }
 744         }
 745
 746         return 0;
 747 }
 748
 749 static int bpmp_populate_debugfs_shmem(struct tegra_bpmp *bpmp)
 750 {
 751         struct seqbuf seqbuf;
 752         const size_t sz = SZ_512K;
 753         dma_addr_t phys;
 754         size_t nbytes;
 755         void *virt;
 756         int err;
 757
 758         virt = dma_alloc_coherent(bpmp->dev, sz, &phys,
 759                                   GFP_KERNEL | GFP_DMA32);
 760         if (!virt)
 761                 return -ENOMEM;
 762
 763         err = mrq_debugfs_dumpdir(bpmp, phys, sz, &nbytes);
 764         if (err < 0) {
 765                 goto free;
 766         } else if (nbytes > sz) {
 767                 err = -EINVAL;
 768                 goto free;
 769         }
 770
 771         seqbuf_init(&seqbuf, virt, nbytes);
 772         err = bpmp_populate_dir(bpmp, &seqbuf, bpmp->debugfs_mirror, 0);
 773 free:
 774         dma_free_coherent(bpmp->dev, sz, virt, phys);
 775
 776         return err;
 777 }
 778
 779 int tegra_bpmp_init_debugfs(struct tegra_bpmp *bpmp)
 780 {
 781         struct dentry *root;
 782         bool inband;
 783         int err;
 784
 785         inband = tegra_bpmp_mrq_is_supported(bpmp, MRQ_DEBUG);
 786
 787         if (!inband && !tegra_bpmp_mrq_is_supported(bpmp, MRQ_DEBUGFS))
 788                 return 0;
 789
 790         root = debugfs_create_dir("bpmp", NULL);
 791         if (!root)
 792                 return -ENOMEM;
 793
 794         bpmp->debugfs_mirror = debugfs_create_dir("debug", root);
 795         if (!bpmp->debugfs_mirror) {
 796                 err = -ENOMEM;
 797                 goto out;
 798         }
 799
 800         if (inband)
 801                 err = bpmp_populate_debugfs_inband(bpmp, bpmp->debugfs_mirror,
 802                                                    "/");
 803         else
 804                 err = bpmp_populate_debugfs_shmem(bpmp);
 805
 806 out:
 807         if (err < 0)
 808                 debugfs_remove_recursive(root);
 809
 810         return err;
 811 }