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/io.h> 15 #include <linux/slab.h> 16 #include <linux/uaccess.h> 17 #include <linux/pm_runtime.h> 18 #include <linux/debugfs.h> 19 #include <linux/platform_data/iommu-omap.h> 20 21 #include "omap-iopgtable.h" 22 #include "omap-iommu.h" 23 24 static DEFINE_MUTEX(iommu_debug_lock); 25 26 static struct dentry *iommu_debug_root; 27 28 static inline bool is_omap_iommu_detached(struct omap_iommu *obj) 29 { 30 return !obj->domain; 31 } 32 33 #define pr_reg(name) \ 34 do { \ 35 ssize_t bytes; \ 36 const char *str = "%20s: %08x\n"; \ 37 const int maxcol = 32; \ 38 bytes = snprintf(p, maxcol, str, __stringify(name), \ 39 iommu_read_reg(obj, MMU_##name)); \ 40 p += bytes; \ 41 len -= bytes; \ 42 if (len < maxcol) \ 43 goto out; \ 44 } while (0) 45 46 static ssize_t 47 omap2_iommu_dump_ctx(struct omap_iommu *obj, char *buf, ssize_t len) 48 { 49 char *p = buf; 50 51 pr_reg(REVISION); 52 pr_reg(IRQSTATUS); 53 pr_reg(IRQENABLE); 54 pr_reg(WALKING_ST); 55 pr_reg(CNTL); 56 pr_reg(FAULT_AD); 57 pr_reg(TTB); 58 pr_reg(LOCK); 59 pr_reg(LD_TLB); 60 pr_reg(CAM); 61 pr_reg(RAM); 62 pr_reg(GFLUSH); 63 pr_reg(FLUSH_ENTRY); 64 pr_reg(READ_CAM); 65 pr_reg(READ_RAM); 66 pr_reg(EMU_FAULT_AD); 67 out: 68 return p - buf; 69 } 70 71 static ssize_t omap_iommu_dump_ctx(struct omap_iommu *obj, char *buf, 72 ssize_t bytes) 73 { 74 if (!obj || !buf) 75 return -EINVAL; 76 77 pm_runtime_get_sync(obj->dev); 78 79 bytes = omap2_iommu_dump_ctx(obj, buf, bytes); 80 81 pm_runtime_put_sync(obj->dev); 82 83 return bytes; 84 } 85 86 static ssize_t debug_read_regs(struct file *file, char __user *userbuf, 87 size_t count, loff_t *ppos) 88 { 89 struct omap_iommu *obj = file->private_data; 90 char *p, *buf; 91 ssize_t bytes; 92 93 if (is_omap_iommu_detached(obj)) 94 return -EPERM; 95 96 buf = kmalloc(count, GFP_KERNEL); 97 if (!buf) 98 return -ENOMEM; 99 p = buf; 100 101 mutex_lock(&iommu_debug_lock); 102 103 bytes = omap_iommu_dump_ctx(obj, p, count); 104 bytes = simple_read_from_buffer(userbuf, count, ppos, buf, bytes); 105 106 mutex_unlock(&iommu_debug_lock); 107 kfree(buf); 108 109 return bytes; 110 } 111 112 static int 113 __dump_tlb_entries(struct omap_iommu *obj, struct cr_regs *crs, int num) 114 { 115 int i; 116 struct iotlb_lock saved; 117 struct cr_regs tmp; 118 struct cr_regs *p = crs; 119 120 pm_runtime_get_sync(obj->dev); 121 iotlb_lock_get(obj, &saved); 122 123 for_each_iotlb_cr(obj, num, i, tmp) { 124 if (!iotlb_cr_valid(&tmp)) 125 continue; 126 *p++ = tmp; 127 } 128 129 iotlb_lock_set(obj, &saved); 130 pm_runtime_put_sync(obj->dev); 131 132 return p - crs; 133 } 134 135 static ssize_t iotlb_dump_cr(struct omap_iommu *obj, struct cr_regs *cr, 136 struct seq_file *s) 137 { 138 return seq_printf(s, "%08x %08x %01x\n", cr->cam, cr->ram, 139 (cr->cam & MMU_CAM_P) ? 1 : 0); 140 } 141 142 static size_t omap_dump_tlb_entries(struct omap_iommu *obj, struct seq_file *s) 143 { 144 int i, num; 145 struct cr_regs *cr; 146 147 num = obj->nr_tlb_entries; 148 149 cr = kcalloc(num, sizeof(*cr), GFP_KERNEL); 150 if (!cr) 151 return 0; 152 153 num = __dump_tlb_entries(obj, cr, num); 154 for (i = 0; i < num; i++) 155 iotlb_dump_cr(obj, cr + i, s); 156 kfree(cr); 157 158 return 0; 159 } 160 161 static int debug_read_tlb(struct seq_file *s, void *data) 162 { 163 struct omap_iommu *obj = s->private; 164 165 if (is_omap_iommu_detached(obj)) 166 return -EPERM; 167 168 mutex_lock(&iommu_debug_lock); 169 170 seq_printf(s, "%8s %8s\n", "cam:", "ram:"); 171 seq_puts(s, "-----------------------------------------\n"); 172 omap_dump_tlb_entries(obj, s); 173 174 mutex_unlock(&iommu_debug_lock); 175 176 return 0; 177 } 178 179 static void dump_ioptable(struct seq_file *s) 180 { 181 int i, j; 182 u32 da; 183 u32 *iopgd, *iopte; 184 struct omap_iommu *obj = s->private; 185 186 spin_lock(&obj->page_table_lock); 187 188 iopgd = iopgd_offset(obj, 0); 189 for (i = 0; i < PTRS_PER_IOPGD; i++, iopgd++) { 190 if (!*iopgd) 191 continue; 192 193 if (!(*iopgd & IOPGD_TABLE)) { 194 da = i << IOPGD_SHIFT; 195 seq_printf(s, "1: 0x%08x 0x%08x\n", da, *iopgd); 196 continue; 197 } 198 199 iopte = iopte_offset(iopgd, 0); 200 for (j = 0; j < PTRS_PER_IOPTE; j++, iopte++) { 201 if (!*iopte) 202 continue; 203 204 da = (i << IOPGD_SHIFT) + (j << IOPTE_SHIFT); 205 seq_printf(s, "2: 0x%08x 0x%08x\n", da, *iopte); 206 } 207 } 208 209 spin_unlock(&obj->page_table_lock); 210 } 211 212 static int debug_read_pagetable(struct seq_file *s, void *data) 213 { 214 struct omap_iommu *obj = s->private; 215 216 if (is_omap_iommu_detached(obj)) 217 return -EPERM; 218 219 mutex_lock(&iommu_debug_lock); 220 221 seq_printf(s, "L: %8s %8s\n", "da:", "pte:"); 222 seq_puts(s, "--------------------------\n"); 223 dump_ioptable(s); 224 225 mutex_unlock(&iommu_debug_lock); 226 227 return 0; 228 } 229 230 #define DEBUG_SEQ_FOPS_RO(name) \ 231 static int debug_open_##name(struct inode *inode, struct file *file) \ 232 { \ 233 return single_open(file, debug_read_##name, inode->i_private); \ 234 } \ 235 \ 236 static const struct file_operations debug_##name##_fops = { \ 237 .open = debug_open_##name, \ 238 .read = seq_read, \ 239 .llseek = seq_lseek, \ 240 .release = single_release, \ 241 } 242 243 #define DEBUG_FOPS_RO(name) \ 244 static const struct file_operations debug_##name##_fops = { \ 245 .open = simple_open, \ 246 .read = debug_read_##name, \ 247 .llseek = generic_file_llseek, \ 248 } 249 250 DEBUG_FOPS_RO(regs); 251 DEBUG_SEQ_FOPS_RO(tlb); 252 DEBUG_SEQ_FOPS_RO(pagetable); 253 254 #define __DEBUG_ADD_FILE(attr, mode) \ 255 { \ 256 struct dentry *dent; \ 257 dent = debugfs_create_file(#attr, mode, obj->debug_dir, \ 258 obj, &debug_##attr##_fops); \ 259 if (!dent) \ 260 goto err; \ 261 } 262 263 #define DEBUG_ADD_FILE_RO(name) __DEBUG_ADD_FILE(name, 0400) 264 265 void omap_iommu_debugfs_add(struct omap_iommu *obj) 266 { 267 struct dentry *d; 268 269 if (!iommu_debug_root) 270 return; 271 272 obj->debug_dir = debugfs_create_dir(obj->name, iommu_debug_root); 273 if (!obj->debug_dir) 274 return; 275 276 d = debugfs_create_u8("nr_tlb_entries", 0400, obj->debug_dir, 277 (u8 *)&obj->nr_tlb_entries); 278 if (!d) 279 return; 280 281 DEBUG_ADD_FILE_RO(regs); 282 DEBUG_ADD_FILE_RO(tlb); 283 DEBUG_ADD_FILE_RO(pagetable); 284 285 return; 286 287 err: 288 debugfs_remove_recursive(obj->debug_dir); 289 } 290 291 void omap_iommu_debugfs_remove(struct omap_iommu *obj) 292 { 293 if (!obj->debug_dir) 294 return; 295 296 debugfs_remove_recursive(obj->debug_dir); 297 } 298 299 void __init omap_iommu_debugfs_init(void) 300 { 301 iommu_debug_root = debugfs_create_dir("omap_iommu", NULL); 302 if (!iommu_debug_root) 303 pr_err("can't create debugfs dir\n"); 304 } 305 306 void __exit omap_iommu_debugfs_exit(void) 307 { 308 debugfs_remove(iommu_debug_root); 309 } 310