Pileus Git - ~andy/linux/blob - drivers/iommu/omap-iommu-debug.c

   1 /*
   2  * omap iommu: debugfs interface
   3  *
   4  * Copyright (C) 2008-2009 Nokia Corporation
   5  *
   6  * Written by Hiroshi DOYU <Hiroshi.DOYU@nokia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/err.h>
  15 #include <linux/clk.h>
  16 #include <linux/io.h>
  17 #include <linux/slab.h>
  18 #include <linux/uaccess.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/debugfs.h>
  21 #include <linux/omap-iommu.h>
  22 #include <linux/platform_data/iommu-omap.h>
  23
  24 #include "omap-iopgtable.h"
  25 #include "omap-iommu.h"
  26
  27 #define MAXCOLUMN 100 /* for short messages */
  28
  29 static DEFINE_MUTEX(iommu_debug_lock);
  30
  31 static struct dentry *iommu_debug_root;
  32
  33 static ssize_t debug_read_ver(struct file *file, char __user *userbuf,
  34                               size_t count, loff_t *ppos)
  35 {
  36         u32 ver = omap_iommu_arch_version();
  37         char buf[MAXCOLUMN], *p = buf;
  38
  39         p += sprintf(p, "H/W version: %d.%d\n", (ver >> 4) & 0xf , ver & 0xf);
  40
  41         return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
  42 }
  43
  44 static ssize_t debug_read_regs(struct file *file, char __user *userbuf,
  45                                size_t count, loff_t *ppos)
  46 {
  47         struct device *dev = file->private_data;
  48         struct omap_iommu *obj = dev_to_omap_iommu(dev);
  49         char *p, *buf;
  50         ssize_t bytes;
  51
  52         buf = kmalloc(count, GFP_KERNEL);
  53         if (!buf)
  54                 return -ENOMEM;
  55         p = buf;
  56
  57         mutex_lock(&iommu_debug_lock);
  58
  59         bytes = omap_iommu_dump_ctx(obj, p, count);
  60         bytes = simple_read_from_buffer(userbuf, count, ppos, buf, bytes);
  61
  62         mutex_unlock(&iommu_debug_lock);
  63         kfree(buf);
  64
  65         return bytes;
  66 }
  67
  68 static ssize_t debug_read_tlb(struct file *file, char __user *userbuf,
  69                               size_t count, loff_t *ppos)
  70 {
  71         struct device *dev = file->private_data;
  72         struct omap_iommu *obj = dev_to_omap_iommu(dev);
  73         char *p, *buf;
  74         ssize_t bytes, rest;
  75
  76         buf = kmalloc(count, GFP_KERNEL);
  77         if (!buf)
  78                 return -ENOMEM;
  79         p = buf;
  80
  81         mutex_lock(&iommu_debug_lock);
  82
  83         p += sprintf(p, "%8s %8s\n", "cam:", "ram:");
  84         p += sprintf(p, "-----------------------------------------\n");
  85         rest = count - (p - buf);
  86         p += omap_dump_tlb_entries(obj, p, rest);
  87
  88         bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
  89
  90         mutex_unlock(&iommu_debug_lock);
  91         kfree(buf);
  92
  93         return bytes;
  94 }
  95
  96 static ssize_t debug_write_pagetable(struct file *file,
  97                      const char __user *userbuf, size_t count, loff_t *ppos)
  98 {
  99         struct iotlb_entry e;
 100         struct cr_regs cr;
 101         int err;
 102         struct device *dev = file->private_data;
 103         struct omap_iommu *obj = dev_to_omap_iommu(dev);
 104         char buf[MAXCOLUMN], *p = buf;
 105
 106         count = min(count, sizeof(buf));
 107
 108         mutex_lock(&iommu_debug_lock);
 109         if (copy_from_user(p, userbuf, count)) {
 110                 mutex_unlock(&iommu_debug_lock);
 111                 return -EFAULT;
 112         }
 113
 114         sscanf(p, "%x %x", &cr.cam, &cr.ram);
 115         if (!cr.cam || !cr.ram) {
 116                 mutex_unlock(&iommu_debug_lock);
 117                 return -EINVAL;
 118         }
 119
 120         omap_iotlb_cr_to_e(&cr, &e);
 121         err = omap_iopgtable_store_entry(obj, &e);
 122         if (err)
 123                 dev_err(obj->dev, "%s: fail to store cr\n", __func__);
 124
 125         mutex_unlock(&iommu_debug_lock);
 126         return count;
 127 }
 128
 129 #define dump_ioptable_entry_one(lv, da, val)                    \
 130         ({                                                      \
 131                 int __err = 0;                                  \
 132                 ssize_t bytes;                                  \
 133                 const int maxcol = 22;                          \
 134                 const char *str = "%d: %08x %08x\n";            \
 135                 bytes = snprintf(p, maxcol, str, lv, da, val);  \
 136                 p += bytes;                                     \
 137                 len -= bytes;                                   \
 138                 if (len < maxcol)                               \
 139                         __err = -ENOMEM;                        \
 140                 __err;                                          \
 141         })
 142
 143 static ssize_t dump_ioptable(struct omap_iommu *obj, char *buf, ssize_t len)
 144 {
 145         int i;
 146         u32 *iopgd;
 147         char *p = buf;
 148
 149         spin_lock(&obj->page_table_lock);
 150
 151         iopgd = iopgd_offset(obj, 0);
 152         for (i = 0; i < PTRS_PER_IOPGD; i++, iopgd++) {
 153                 int j, err;
 154                 u32 *iopte;
 155                 u32 da;
 156
 157                 if (!*iopgd)
 158                         continue;
 159
 160                 if (!(*iopgd & IOPGD_TABLE)) {
 161                         da = i << IOPGD_SHIFT;
 162
 163                         err = dump_ioptable_entry_one(1, da, *iopgd);
 164                         if (err)
 165                                 goto out;
 166                         continue;
 167                 }
 168
 169                 iopte = iopte_offset(iopgd, 0);
 170
 171                 for (j = 0; j < PTRS_PER_IOPTE; j++, iopte++) {
 172                         if (!*iopte)
 173                                 continue;
 174
 175                         da = (i << IOPGD_SHIFT) + (j << IOPTE_SHIFT);
 176                         err = dump_ioptable_entry_one(2, da, *iopgd);
 177                         if (err)
 178                                 goto out;
 179                 }
 180         }
 181 out:
 182         spin_unlock(&obj->page_table_lock);
 183
 184         return p - buf;
 185 }
 186
 187 static ssize_t debug_read_pagetable(struct file *file, char __user *userbuf,
 188                                     size_t count, loff_t *ppos)
 189 {
 190         struct device *dev = file->private_data;
 191         struct omap_iommu *obj = dev_to_omap_iommu(dev);
 192         char *p, *buf;
 193         size_t bytes;
 194
 195         buf = (char *)__get_free_page(GFP_KERNEL);
 196         if (!buf)
 197                 return -ENOMEM;
 198         p = buf;
 199
 200         p += sprintf(p, "L: %8s %8s\n", "da:", "pa:");
 201         p += sprintf(p, "-----------------------------------------\n");
 202
 203         mutex_lock(&iommu_debug_lock);
 204
 205         bytes = PAGE_SIZE - (p - buf);
 206         p += dump_ioptable(obj, p, bytes);
 207
 208         bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
 209
 210         mutex_unlock(&iommu_debug_lock);
 211         free_page((unsigned long)buf);
 212
 213         return bytes;
 214 }
 215
 216 static ssize_t debug_read_mmap(struct file *file, char __user *userbuf,
 217                                size_t count, loff_t *ppos)
 218 {
 219         struct device *dev = file->private_data;
 220         struct omap_iommu *obj = dev_to_omap_iommu(dev);
 221         char *p, *buf;
 222         struct iovm_struct *tmp;
 223         int uninitialized_var(i);
 224         ssize_t bytes;
 225
 226         buf = (char *)__get_free_page(GFP_KERNEL);
 227         if (!buf)
 228                 return -ENOMEM;
 229         p = buf;
 230
 231         p += sprintf(p, "%-3s %-8s %-8s %6s %8s\n",
 232                      "No", "start", "end", "size", "flags");
 233         p += sprintf(p, "-------------------------------------------------\n");
 234
 235         mutex_lock(&iommu_debug_lock);
 236
 237         list_for_each_entry(tmp, &obj->mmap, list) {
 238                 size_t len;
 239                 const char *str = "%3d %08x-%08x %6x %8x\n";
 240                 const int maxcol = 39;
 241
 242                 len = tmp->da_end - tmp->da_start;
 243                 p += snprintf(p, maxcol, str,
 244                               i, tmp->da_start, tmp->da_end, len, tmp->flags);
 245
 246                 if (PAGE_SIZE - (p - buf) < maxcol)
 247                         break;
 248                 i++;
 249         }
 250
 251         bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
 252
 253         mutex_unlock(&iommu_debug_lock);
 254         free_page((unsigned long)buf);
 255
 256         return bytes;
 257 }
 258
 259 static ssize_t debug_read_mem(struct file *file, char __user *userbuf,
 260                               size_t count, loff_t *ppos)
 261 {
 262         struct device *dev = file->private_data;
 263         char *p, *buf;
 264         struct iovm_struct *area;
 265         ssize_t bytes;
 266
 267         count = min_t(ssize_t, count, PAGE_SIZE);
 268
 269         buf = (char *)__get_free_page(GFP_KERNEL);
 270         if (!buf)
 271                 return -ENOMEM;
 272         p = buf;
 273
 274         mutex_lock(&iommu_debug_lock);
 275
 276         area = omap_find_iovm_area(dev, (u32)ppos);
 277         if (!area) {
 278                 bytes = -EINVAL;
 279                 goto err_out;
 280         }
 281         memcpy(p, area->va, count);
 282         p += count;
 283
 284         bytes = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
 285 err_out:
 286         mutex_unlock(&iommu_debug_lock);
 287         free_page((unsigned long)buf);
 288
 289         return bytes;
 290 }
 291
 292 static ssize_t debug_write_mem(struct file *file, const char __user *userbuf,
 293                                size_t count, loff_t *ppos)
 294 {
 295         struct device *dev = file->private_data;
 296         struct iovm_struct *area;
 297         char *p, *buf;
 298
 299         count = min_t(size_t, count, PAGE_SIZE);
 300
 301         buf = (char *)__get_free_page(GFP_KERNEL);
 302         if (!buf)
 303                 return -ENOMEM;
 304         p = buf;
 305
 306         mutex_lock(&iommu_debug_lock);
 307
 308         if (copy_from_user(p, userbuf, count)) {
 309                 count =  -EFAULT;
 310                 goto err_out;
 311         }
 312
 313         area = omap_find_iovm_area(dev, (u32)ppos);
 314         if (!area) {
 315                 count = -EINVAL;
 316                 goto err_out;
 317         }
 318         memcpy(area->va, p, count);
 319 err_out:
 320         mutex_unlock(&iommu_debug_lock);
 321         free_page((unsigned long)buf);
 322
 323         return count;
 324 }
 325
 326 #define DEBUG_FOPS(name)                                                \
 327         static const struct file_operations debug_##name##_fops = {     \
 328                 .open = simple_open,                                    \
 329                 .read = debug_read_##name,                              \
 330                 .write = debug_write_##name,                            \
 331                 .llseek = generic_file_llseek,                          \
 332         };
 333
 334 #define DEBUG_FOPS_RO(name)                                             \
 335         static const struct file_operations debug_##name##_fops = {     \
 336                 .open = simple_open,                                    \
 337                 .read = debug_read_##name,                              \
 338                 .llseek = generic_file_llseek,                          \
 339         };
 340
 341 DEBUG_FOPS_RO(ver);
 342 DEBUG_FOPS_RO(regs);
 343 DEBUG_FOPS_RO(tlb);
 344 DEBUG_FOPS(pagetable);
 345 DEBUG_FOPS_RO(mmap);
 346 DEBUG_FOPS(mem);
 347
 348 #define __DEBUG_ADD_FILE(attr, mode)                                    \
 349         {                                                               \
 350                 struct dentry *dent;                                    \
 351                 dent = debugfs_create_file(#attr, mode, parent,         \
 352                                            dev, &debug_##attr##_fops);  \
 353                 if (!dent)                                              \
 354                         return -ENOMEM;                                 \
 355         }
 356
 357 #define DEBUG_ADD_FILE(name) __DEBUG_ADD_FILE(name, 0600)
 358 #define DEBUG_ADD_FILE_RO(name) __DEBUG_ADD_FILE(name, 0400)
 359
 360 static int iommu_debug_register(struct device *dev, void *data)
 361 {
 362         struct platform_device *pdev = to_platform_device(dev);
 363         struct omap_iommu *obj = platform_get_drvdata(pdev);
 364         struct omap_iommu_arch_data *arch_data;
 365         struct dentry *d, *parent;
 366
 367         if (!obj || !obj->dev)
 368                 return -EINVAL;
 369
 370         arch_data = kzalloc(sizeof(*arch_data), GFP_KERNEL);
 371         if (!arch_data)
 372                 return -ENOMEM;
 373
 374         arch_data->iommu_dev = obj;
 375
 376         dev->archdata.iommu = arch_data;
 377
 378         d = debugfs_create_dir(obj->name, iommu_debug_root);
 379         if (!d)
 380                 goto nomem;
 381         parent = d;
 382
 383         d = debugfs_create_u8("nr_tlb_entries", 400, parent,
 384                               (u8 *)&obj->nr_tlb_entries);
 385         if (!d)
 386                 goto nomem;
 387
 388         DEBUG_ADD_FILE_RO(ver);
 389         DEBUG_ADD_FILE_RO(regs);
 390         DEBUG_ADD_FILE_RO(tlb);
 391         DEBUG_ADD_FILE(pagetable);
 392         DEBUG_ADD_FILE_RO(mmap);
 393         DEBUG_ADD_FILE(mem);
 394
 395         return 0;
 396
 397 nomem:
 398         kfree(arch_data);
 399         return -ENOMEM;
 400 }
 401
 402 static int iommu_debug_unregister(struct device *dev, void *data)
 403 {
 404         if (!dev->archdata.iommu)
 405                 return 0;
 406
 407         kfree(dev->archdata.iommu);
 408
 409         dev->archdata.iommu = NULL;
 410
 411         return 0;
 412 }
 413
 414 static int __init iommu_debug_init(void)
 415 {
 416         struct dentry *d;
 417         int err;
 418
 419         d = debugfs_create_dir("iommu", NULL);
 420         if (!d)
 421                 return -ENOMEM;
 422         iommu_debug_root = d;
 423
 424         err = omap_foreach_iommu_device(d, iommu_debug_register);
 425         if (err)
 426                 goto err_out;
 427         return 0;
 428
 429 err_out:
 430         debugfs_remove_recursive(iommu_debug_root);
 431         return err;
 432 }
 433 module_init(iommu_debug_init)
 434
 435 static void __exit iommu_debugfs_exit(void)
 436 {
 437         debugfs_remove_recursive(iommu_debug_root);
 438         omap_foreach_iommu_device(NULL, iommu_debug_unregister);
 439 }
 440 module_exit(iommu_debugfs_exit)
 441
 442 MODULE_DESCRIPTION("omap iommu: debugfs interface");
 443 MODULE_AUTHOR("Hiroshi DOYU <Hiroshi.DOYU@nokia.com>");
 444 MODULE_LICENSE("GPL v2");