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 seq_printf(s, "%08x %08x %01x\n", cr->cam, cr->ram, 139 (cr->cam & MMU_CAM_P) ? 1 : 0); 140 return 0; 141 } 142 143 static size_t omap_dump_tlb_entries(struct omap_iommu *obj, struct seq_file *s) 144 { 145 int i, num; 146 struct cr_regs *cr; 147 148 num = obj->nr_tlb_entries; 149 150 cr = kcalloc(num, sizeof(*cr), GFP_KERNEL); 151 if (!cr) 152 return 0; 153 154 num = __dump_tlb_entries(obj, cr, num); 155 for (i = 0; i < num; i++) 156 iotlb_dump_cr(obj, cr + i, s); 157 kfree(cr); 158 159 return 0; 160 } 161 162 static int debug_read_tlb(struct seq_file *s, void *data) 163 { 164 struct omap_iommu *obj = s->private; 165 166 if (is_omap_iommu_detached(obj)) 167 return -EPERM; 168 169 mutex_lock(&iommu_debug_lock); 170 171 seq_printf(s, "%8s %8s\n", "cam:", "ram:"); 172 seq_puts(s, "-----------------------------------------\n"); 173 omap_dump_tlb_entries(obj, s); 174 175 mutex_unlock(&iommu_debug_lock); 176 177 return 0; 178 } 179 180 static void dump_ioptable(struct seq_file *s) 181 { 182 int i, j; 183 u32 da; 184 u32 *iopgd, *iopte; 185 struct omap_iommu *obj = s->private; 186 187 spin_lock(&obj->page_table_lock); 188 189 iopgd = iopgd_offset(obj, 0); 190 for (i = 0; i < PTRS_PER_IOPGD; i++, iopgd++) { 191 if (!*iopgd) 192 continue; 193 194 if (!(*iopgd & IOPGD_TABLE)) { 195 da = i << IOPGD_SHIFT; 196 seq_printf(s, "1: 0x%08x 0x%08x\n", da, *iopgd); 197 continue; 198 } 199 200 iopte = iopte_offset(iopgd, 0); 201 for (j = 0; j < PTRS_PER_IOPTE; j++, iopte++) { 202 if (!*iopte) 203 continue; 204 205 da = (i << IOPGD_SHIFT) + (j << IOPTE_SHIFT); 206 seq_printf(s, "2: 0x%08x 0x%08x\n", da, *iopte); 207 } 208 } 209 210 spin_unlock(&obj->page_table_lock); 211 } 212 213 static int debug_read_pagetable(struct seq_file *s, void *data) 214 { 215 struct omap_iommu *obj = s->private; 216 217 if (is_omap_iommu_detached(obj)) 218 return -EPERM; 219 220 mutex_lock(&iommu_debug_lock); 221 222 seq_printf(s, "L: %8s %8s\n", "da:", "pte:"); 223 seq_puts(s, "--------------------------\n"); 224 dump_ioptable(s); 225 226 mutex_unlock(&iommu_debug_lock); 227 228 return 0; 229 } 230 231 #define DEBUG_SEQ_FOPS_RO(name) \ 232 static int debug_open_##name(struct inode *inode, struct file *file) \ 233 { \ 234 return single_open(file, debug_read_##name, inode->i_private); \ 235 } \ 236 \ 237 static const struct file_operations debug_##name##_fops = { \ 238 .open = debug_open_##name, \ 239 .read = seq_read, \ 240 .llseek = seq_lseek, \ 241 .release = single_release, \ 242 } 243 244 #define DEBUG_FOPS_RO(name) \ 245 static const struct file_operations debug_##name##_fops = { \ 246 .open = simple_open, \ 247 .read = debug_read_##name, \ 248 .llseek = generic_file_llseek, \ 249 } 250 251 DEBUG_FOPS_RO(regs); 252 DEBUG_SEQ_FOPS_RO(tlb); 253 DEBUG_SEQ_FOPS_RO(pagetable); 254 255 #define __DEBUG_ADD_FILE(attr, mode) \ 256 { \ 257 struct dentry *dent; \ 258 dent = debugfs_create_file(#attr, mode, obj->debug_dir, \ 259 obj, &debug_##attr##_fops); \ 260 if (!dent) \ 261 goto err; \ 262 } 263 264 #define DEBUG_ADD_FILE_RO(name) __DEBUG_ADD_FILE(name, 0400) 265 266 void omap_iommu_debugfs_add(struct omap_iommu *obj) 267 { 268 struct dentry *d; 269 270 if (!iommu_debug_root) 271 return; 272 273 obj->debug_dir = debugfs_create_dir(obj->name, iommu_debug_root); 274 if (!obj->debug_dir) 275 return; 276 277 d = debugfs_create_u8("nr_tlb_entries", 0400, obj->debug_dir, 278 (u8 *)&obj->nr_tlb_entries); 279 if (!d) 280 return; 281 282 DEBUG_ADD_FILE_RO(regs); 283 DEBUG_ADD_FILE_RO(tlb); 284 DEBUG_ADD_FILE_RO(pagetable); 285 286 return; 287 288 err: 289 debugfs_remove_recursive(obj->debug_dir); 290 } 291 292 void omap_iommu_debugfs_remove(struct omap_iommu *obj) 293 { 294 if (!obj->debug_dir) 295 return; 296 297 debugfs_remove_recursive(obj->debug_dir); 298 } 299 300 void __init omap_iommu_debugfs_init(void) 301 { 302 iommu_debug_root = debugfs_create_dir("omap_iommu", NULL); 303 if (!iommu_debug_root) 304 pr_err("can't create debugfs dir\n"); 305 } 306 307 void __exit omap_iommu_debugfs_exit(void) 308 { 309 debugfs_remove(iommu_debug_root); 310 } 311