Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
omap-iommu-debug.c
Go to the documentation of this file.
1 /*
2  * omap iommu: debugfs interface
3  *
4  * Copyright (C) 2008-2009 Nokia Corporation
5  *
6  * Written by Hiroshi DOYU <[email protected]>
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 
22 #include <plat/iommu.h>
23 #include <plat/iovmm.h>
24 
25 #include <plat/iopgtable.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, 600)
358 #define DEBUG_ADD_FILE_RO(name) __DEBUG_ADD_FILE(name, 400)
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 <[email protected]>");
444 MODULE_LICENSE("GPL v2");
Generated on Thu Jan 10 2013 13:40:49 for Linux Kernel by   doxygen 1.8.2