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