linux/drivers/iommu/omap-iommu-debug.c
<<
>>
Prefs
   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
  29static DEFINE_MUTEX(iommu_debug_lock);
  30
  31static struct dentry *iommu_debug_root;
  32
  33static 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
  44static 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
  68static 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
  96static 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
 143static 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        }
 181out:
 182        spin_unlock(&obj->page_table_lock);
 183
 184        return p - buf;
 185}
 186
 187static 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
 216static 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
 259static 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);
 285err_out:
 286        mutex_unlock(&iommu_debug_lock);
 287        free_page((unsigned long)buf);
 288
 289        return bytes;
 290}
 291
 292static 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);
 319err_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
 341DEBUG_FOPS_RO(ver);
 342DEBUG_FOPS_RO(regs);
 343DEBUG_FOPS_RO(tlb);
 344DEBUG_FOPS(pagetable);
 345DEBUG_FOPS_RO(mmap);
 346DEBUG_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, 600)
 358#define DEBUG_ADD_FILE_RO(name) __DEBUG_ADD_FILE(name, 400)
 359
 360static 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
 397nomem:
 398        kfree(arch_data);
 399        return -ENOMEM;
 400}
 401
 402static 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
 414static 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
 429err_out:
 430        debugfs_remove_recursive(iommu_debug_root);
 431        return err;
 432}
 433module_init(iommu_debug_init)
 434
 435static void __exit iommu_debugfs_exit(void)
 436{
 437        debugfs_remove_recursive(iommu_debug_root);
 438        omap_foreach_iommu_device(NULL, iommu_debug_unregister);
 439}
 440module_exit(iommu_debugfs_exit)
 441
 442MODULE_DESCRIPTION("omap iommu: debugfs interface");
 443MODULE_AUTHOR("Hiroshi DOYU <Hiroshi.DOYU@nokia.com>");
 444MODULE_LICENSE("GPL v2");
 445
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.