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