drivers/firmware/tegra/bpmp-debugfs.c

   1 /*
   2  * Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  */
  14 #include <linux/debugfs.h>
  15 #include <linux/dma-mapping.h>
  16 #include <linux/uaccess.h>
  17
  18 #include <soc/tegra/bpmp.h>
  19 #include <soc/tegra/bpmp-abi.h>
  20
  21 struct seqbuf {
  22         char *buf;
  23         size_t pos;
  24         size_t size;
  25 };
  26
  27 static void seqbuf_init(struct seqbuf *seqbuf, void *buf, size_t size)
  28 {
  29         seqbuf->buf = buf;
  30         seqbuf->size = size;
  31         seqbuf->pos = 0;
  32 }
  33
  34 static size_t seqbuf_avail(struct seqbuf *seqbuf)
  35 {
  36         return seqbuf->pos < seqbuf->size ? seqbuf->size - seqbuf->pos : 0;
  37 }
  38
  39 static size_t seqbuf_status(struct seqbuf *seqbuf)
  40 {
  41         return seqbuf->pos <= seqbuf->size ? 0 : -EOVERFLOW;
  42 }
  43
  44 static int seqbuf_eof(struct seqbuf *seqbuf)
  45 {
  46         return seqbuf->pos >= seqbuf->size;
  47 }
  48
  49 static int seqbuf_read(struct seqbuf *seqbuf, void *buf, size_t nbyte)
  50 {
  51         nbyte = min(nbyte, seqbuf_avail(seqbuf));
  52         memcpy(buf, seqbuf->buf + seqbuf->pos, nbyte);
  53         seqbuf->pos += nbyte;
  54         return seqbuf_status(seqbuf);
  55 }
  56
  57 static int seqbuf_read_u32(struct seqbuf *seqbuf, uint32_t *v)
  58 {
  59         int err;
  60
  61         err = seqbuf_read(seqbuf, v, 4);
  62         *v = le32_to_cpu(*v);
  63         return err;
  64 }
  65
  66 static int seqbuf_read_str(struct seqbuf *seqbuf, const char **str)
  67 {
  68         *str = seqbuf->buf + seqbuf->pos;
  69         seqbuf->pos += strnlen(*str, seqbuf_avail(seqbuf));
  70         seqbuf->pos++;
  71         return seqbuf_status(seqbuf);
  72 }
  73
  74 static void seqbuf_seek(struct seqbuf *seqbuf, ssize_t offset)
  75 {
  76         seqbuf->pos += offset;
  77 }
  78
  79 /* map filename in Linux debugfs to corresponding entry in BPMP */
  80 static const char *get_filename(struct tegra_bpmp *bpmp,
  81                                 const struct file *file, char *buf, int size)
  82 {
  83         char root_path_buf[512];
  84         const char *root_path;
  85         const char *filename;
  86         size_t root_len;
  87
  88         root_path = dentry_path(bpmp->debugfs_mirror, root_path_buf,
  89                                 sizeof(root_path_buf));
  90         if (IS_ERR(root_path))
  91                 return NULL;
  92
  93         root_len = strlen(root_path);
  94
  95         filename = dentry_path(file->f_path.dentry, buf, size);
  96         if (IS_ERR(filename))
  97                 return NULL;
  98
  99         if (strlen(filename) < root_len ||
 100                         strncmp(filename, root_path, root_len))
 101                 return NULL;
 102
 103         filename += root_len;
 104
 105         return filename;
 106 }
 107
 108 static int mrq_debugfs_read(struct tegra_bpmp *bpmp,
 109                             dma_addr_t name, size_t sz_name,
 110                             dma_addr_t data, size_t sz_data,
 111                             size_t *nbytes)
 112 {
 113         struct mrq_debugfs_request req = {
 114                 .cmd = cpu_to_le32(CMD_DEBUGFS_READ),
 115                 .fop = {
 116                         .fnameaddr = cpu_to_le32((uint32_t)name),
 117                         .fnamelen = cpu_to_le32((uint32_t)sz_name),
 118                         .dataaddr = cpu_to_le32((uint32_t)data),
 119                         .datalen = cpu_to_le32((uint32_t)sz_data),
 120                 },
 121         };
 122         struct mrq_debugfs_response resp;
 123         struct tegra_bpmp_message msg = {
 124                 .mrq = MRQ_DEBUGFS,
 125                 .tx = {
 126                         .data = &req,
 127                         .size = sizeof(req),
 128                 },
 129                 .rx = {
 130                         .data = &resp,
 131                         .size = sizeof(resp),
 132                 },
 133         };
 134         int err;
 135
 136         err = tegra_bpmp_transfer(bpmp, &msg);
 137         if (err < 0)
 138                 return err;
 139
 140         *nbytes = (size_t)resp.fop.nbytes;
 141
 142         return 0;
 143 }
 144
 145 static int mrq_debugfs_write(struct tegra_bpmp *bpmp,
 146                              dma_addr_t name, size_t sz_name,
 147                              dma_addr_t data, size_t sz_data)
 148 {
 149         const struct mrq_debugfs_request req = {
 150                 .cmd = cpu_to_le32(CMD_DEBUGFS_WRITE),
 151                 .fop = {
 152                         .fnameaddr = cpu_to_le32((uint32_t)name),
 153                         .fnamelen = cpu_to_le32((uint32_t)sz_name),
 154                         .dataaddr = cpu_to_le32((uint32_t)data),
 155                         .datalen = cpu_to_le32((uint32_t)sz_data),
 156                 },
 157         };
 158         struct tegra_bpmp_message msg = {
 159                 .mrq = MRQ_DEBUGFS,
 160                 .tx = {
 161                         .data = &req,
 162                         .size = sizeof(req),
 163                 },
 164         };
 165
 166         return tegra_bpmp_transfer(bpmp, &msg);
 167 }
 168
 169 static int mrq_debugfs_dumpdir(struct tegra_bpmp *bpmp, dma_addr_t addr,
 170                                size_t size, size_t *nbytes)
 171 {
 172         const struct mrq_debugfs_request req = {
 173                 .cmd = cpu_to_le32(CMD_DEBUGFS_DUMPDIR),
 174                 .dumpdir = {
 175                         .dataaddr = cpu_to_le32((uint32_t)addr),
 176                         .datalen = cpu_to_le32((uint32_t)size),
 177                 },
 178         };
 179         struct mrq_debugfs_response resp;
 180         struct tegra_bpmp_message msg = {
 181                 .mrq = MRQ_DEBUGFS,
 182                 .tx = {
 183                         .data = &req,
 184                         .size = sizeof(req),
 185                 },
 186                 .rx = {
 187                         .data = &resp,
 188                         .size = sizeof(resp),
 189                 },
 190         };
 191         int err;
 192
 193         err = tegra_bpmp_transfer(bpmp, &msg);
 194         if (err < 0)
 195                 return err;
 196
 197         *nbytes = (size_t)resp.dumpdir.nbytes;
 198
 199         return 0;
 200 }
 201
 202 static int debugfs_show(struct seq_file *m, void *p)
 203 {
 204         struct file *file = m->private;
 205         struct inode *inode = file_inode(file);
 206         struct tegra_bpmp *bpmp = inode->i_private;
 207         const size_t datasize = m->size;
 208         const size_t namesize = SZ_256;
 209         void *datavirt, *namevirt;
 210         dma_addr_t dataphys, namephys;
 211         char buf[256];
 212         const char *filename;
 213         size_t len, nbytes;
 214         int ret;
 215
 216         filename = get_filename(bpmp, file, buf, sizeof(buf));
 217         if (!filename)
 218                 return -ENOENT;
 219
 220         namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys,
 221                                       GFP_KERNEL | GFP_DMA32);
 222         if (!namevirt)
 223                 return -ENOMEM;
 224
 225         datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys,
 226                                       GFP_KERNEL | GFP_DMA32);
 227         if (!datavirt) {
 228                 ret = -ENOMEM;
 229                 goto free_namebuf;
 230         }
 231
 232         len = strlen(filename);
 233         strncpy(namevirt, filename, namesize);
 234
 235         ret = mrq_debugfs_read(bpmp, namephys, len, dataphys, datasize,
 236                                &nbytes);
 237
 238         if (!ret)
 239                 seq_write(m, datavirt, nbytes);
 240
 241         dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys);
 242 free_namebuf:
 243         dma_free_coherent(bpmp->dev, namesize, namevirt, namephys);
 244
 245         return ret;
 246 }
 247
 248 static int debugfs_open(struct inode *inode, struct file *file)
 249 {
 250         return single_open_size(file, debugfs_show, file, SZ_128K);
 251 }
 252
 253 static ssize_t debugfs_store(struct file *file, const char __user *buf,
 254                 size_t count, loff_t *f_pos)
 255 {
 256         struct inode *inode = file_inode(file);
 257         struct tegra_bpmp *bpmp = inode->i_private;
 258         const size_t datasize = count;
 259         const size_t namesize = SZ_256;
 260         void *datavirt, *namevirt;
 261         dma_addr_t dataphys, namephys;
 262         char fnamebuf[256];
 263         const char *filename;
 264         size_t len;
 265         int ret;
 266
 267         filename = get_filename(bpmp, file, fnamebuf, sizeof(fnamebuf));
 268         if (!filename)
 269                 return -ENOENT;
 270
 271         namevirt = dma_alloc_coherent(bpmp->dev, namesize, &namephys,
 272                                       GFP_KERNEL | GFP_DMA32);
 273         if (!namevirt)
 274                 return -ENOMEM;
 275
 276         datavirt = dma_alloc_coherent(bpmp->dev, datasize, &dataphys,
 277                                       GFP_KERNEL | GFP_DMA32);
 278         if (!datavirt) {
 279                 ret = -ENOMEM;
 280                 goto free_namebuf;
 281         }
 282
 283         len = strlen(filename);
 284         strncpy(namevirt, filename, namesize);
 285
 286         if (copy_from_user(datavirt, buf, count)) {
 287                 ret = -EFAULT;
 288                 goto free_databuf;
 289         }
 290
 291         ret = mrq_debugfs_write(bpmp, namephys, len, dataphys,
 292                                 count);
 293
 294 free_databuf:
 295         dma_free_coherent(bpmp->dev, datasize, datavirt, dataphys);
 296 free_namebuf:
 297         dma_free_coherent(bpmp->dev, namesize, namevirt, namephys);
 298
 299         return ret ?: count;
 300 }
 301
 302 static const struct file_operations debugfs_fops = {
 303         .open           = debugfs_open,
 304         .read           = seq_read,
 305         .llseek         = seq_lseek,
 306         .write          = debugfs_store,
 307         .release        = single_release,
 308 };
 309
 310 static int bpmp_populate_dir(struct tegra_bpmp *bpmp, struct seqbuf *seqbuf,
 311                              struct dentry *parent, uint32_t depth)
 312 {
 313         int err;
 314         uint32_t d, t;
 315         const char *name;
 316         struct dentry *dentry;
 317
 318         while (!seqbuf_eof(seqbuf)) {
 319                 err = seqbuf_read_u32(seqbuf, &d);
 320                 if (err < 0)
 321                         return err;
 322
 323                 if (d < depth) {
 324                         seqbuf_seek(seqbuf, -4);
 325                         /* go up a level */
 326                         return 0;
 327                 } else if (d != depth) {
 328                         /* malformed data received from BPMP */
 329                         return -EIO;
 330                 }
 331
 332                 err = seqbuf_read_u32(seqbuf, &t);
 333                 if (err < 0)
 334                         return err;
 335                 err = seqbuf_read_str(seqbuf, &name);
 336                 if (err < 0)
 337                         return err;
 338
 339                 if (t & DEBUGFS_S_ISDIR) {
 340                         dentry = debugfs_create_dir(name, parent);
 341                         if (!dentry)
 342                                 return -ENOMEM;
 343                         err = bpmp_populate_dir(bpmp, seqbuf, dentry, depth+1);
 344                         if (err < 0)
 345                                 return err;
 346                 } else {
 347                         umode_t mode;
 348
 349                         mode = t & DEBUGFS_S_IRUSR ? S_IRUSR : 0;
 350                         mode |= t & DEBUGFS_S_IWUSR ? S_IWUSR : 0;
 351                         dentry = debugfs_create_file(name, mode,
 352                                                      parent, bpmp,
 353                                                      &debugfs_fops);
 354                         if (!dentry)
 355                                 return -ENOMEM;
 356                 }
 357         }
 358
 359         return 0;
 360 }
 361
 362 static int create_debugfs_mirror(struct tegra_bpmp *bpmp, void *buf,
 363                                  size_t bufsize, struct dentry *root)
 364 {
 365         struct seqbuf seqbuf;
 366         int err;
 367
 368         bpmp->debugfs_mirror = debugfs_create_dir("debug", root);
 369         if (!bpmp->debugfs_mirror)
 370                 return -ENOMEM;
 371
 372         seqbuf_init(&seqbuf, buf, bufsize);
 373         err = bpmp_populate_dir(bpmp, &seqbuf, bpmp->debugfs_mirror, 0);
 374         if (err < 0) {
 375                 debugfs_remove_recursive(bpmp->debugfs_mirror);
 376                 bpmp->debugfs_mirror = NULL;
 377         }
 378
 379         return err;
 380 }
 381
 382 static int mrq_is_supported(struct tegra_bpmp *bpmp, unsigned int mrq)
 383 {
 384         struct mrq_query_abi_request req = { .mrq = cpu_to_le32(mrq) };
 385         struct mrq_query_abi_response resp;
 386         struct tegra_bpmp_message msg = {
 387                 .mrq = MRQ_QUERY_ABI,
 388                 .tx = {
 389                         .data = &req,
 390                         .size = sizeof(req),
 391                 },
 392                 .rx = {
 393                         .data = &resp,
 394                         .size = sizeof(resp),
 395                 },
 396         };
 397         int ret;
 398
 399         ret = tegra_bpmp_transfer(bpmp, &msg);
 400         if (ret < 0) {
 401                 /* something went wrong; assume not supported */
 402                 dev_warn(bpmp->dev, "tegra_bpmp_transfer failed (%d)\n", ret);
 403                 return 0;
 404         }
 405
 406         return resp.status ? 0 : 1;
 407 }
 408
 409 int tegra_bpmp_init_debugfs(struct tegra_bpmp *bpmp)
 410 {
 411         dma_addr_t phys;
 412         void *virt;
 413         const size_t sz = SZ_256K;
 414         size_t nbytes;
 415         int ret;
 416         struct dentry *root;
 417
 418         if (!mrq_is_supported(bpmp, MRQ_DEBUGFS))
 419                 return 0;
 420
 421         root = debugfs_create_dir("bpmp", NULL);
 422         if (!root)
 423                 return -ENOMEM;
 424
 425         virt = dma_alloc_coherent(bpmp->dev, sz, &phys,
 426                                   GFP_KERNEL | GFP_DMA32);
 427         if (!virt) {
 428                 ret = -ENOMEM;
 429                 goto out;
 430         }
 431
 432         ret = mrq_debugfs_dumpdir(bpmp, phys, sz, &nbytes);
 433         if (ret < 0)
 434                 goto free;
 435
 436         ret = create_debugfs_mirror(bpmp, virt, nbytes, root);
 437 free:
 438         dma_free_coherent(bpmp->dev, sz, virt, phys);
 439 out:
 440         if (ret < 0)
 441                 debugfs_remove(root);
 442
 443         return ret;
 444 }