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