1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Written by Pekka Paalanen, 2008-2009 <pq@iki.fi> 4 */ 5 6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 7 8 #include <linux/module.h> 9 #include <linux/io.h> 10 #include <linux/mmiotrace.h> 11 12 static unsigned long mmio_address; 13 module_param_hw(mmio_address, ulong, iomem, 0); 14 MODULE_PARM_DESC(mmio_address, " Start address of the mapping of 16 kB " 15 "(or 8 MB if read_far is non-zero)."); 16 17 static unsigned long read_far = 0x400100; 18 module_param(read_far, ulong, 0); 19 MODULE_PARM_DESC(read_far, " Offset of a 32-bit read within 8 MB " 20 "(default: 0x400100)."); 21 22 static unsigned v16(unsigned i) 23 { 24 return i * 12 + 7; 25 } 26 27 static unsigned v32(unsigned i) 28 { 29 return i * 212371 + 13; 30 } 31 32 static void do_write_test(void __iomem *p) 33 { 34 unsigned int i; 35 pr_info("write test.\n"); 36 mmiotrace_printk("Write test.\n"); 37 38 for (i = 0; i < 256; i++) 39 iowrite8(i, p + i); 40 41 for (i = 1024; i < (5 * 1024); i += 2) 42 iowrite16(v16(i), p + i); 43 44 for (i = (5 * 1024); i < (16 * 1024); i += 4) 45 iowrite32(v32(i), p + i); 46 } 47 48 static void do_read_test(void __iomem *p) 49 { 50 unsigned int i; 51 unsigned errs[3] = { 0 }; 52 pr_info("read test.\n"); 53 mmiotrace_printk("Read test.\n"); 54 55 for (i = 0; i < 256; i++) 56 if (ioread8(p + i) != i) 57 ++errs[0]; 58 59 for (i = 1024; i < (5 * 1024); i += 2) 60 if (ioread16(p + i) != v16(i)) 61 ++errs[1]; 62 63 for (i = (5 * 1024); i < (16 * 1024); i += 4) 64 if (ioread32(p + i) != v32(i)) 65 ++errs[2]; 66 67 mmiotrace_printk("Read errors: 8-bit %d, 16-bit %d, 32-bit %d.\n", 68 errs[0], errs[1], errs[2]); 69 } 70 71 static void do_read_far_test(void __iomem *p) 72 { 73 pr_info("read far test.\n"); 74 mmiotrace_printk("Read far test.\n"); 75 76 ioread32(p + read_far); 77 } 78 79 static void do_test(unsigned long size) 80 { 81 void __iomem *p = ioremap_nocache(mmio_address, size); 82 if (!p) { 83 pr_err("could not ioremap, aborting.\n"); 84 return; 85 } 86 mmiotrace_printk("ioremap returned %p.\n", p); 87 do_write_test(p); 88 do_read_test(p); 89 if (read_far && read_far < size - 4) 90 do_read_far_test(p); 91 iounmap(p); 92 } 93 94 /* 95 * Tests how mmiotrace behaves in face of multiple ioremap / iounmaps in 96 * a short time. We had a bug in deferred freeing procedure which tried 97 * to free this region multiple times (ioremap can reuse the same address 98 * for many mappings). 99 */ 100 static void do_test_bulk_ioremapping(void) 101 { 102 void __iomem *p; 103 int i; 104 105 for (i = 0; i < 10; ++i) { 106 p = ioremap_nocache(mmio_address, PAGE_SIZE); 107 if (p) 108 iounmap(p); 109 } 110 111 /* Force freeing. If it will crash we will know why. */ 112 synchronize_rcu(); 113 } 114 115 static int __init init(void) 116 { 117 unsigned long size = (read_far) ? (8 << 20) : (16 << 10); 118 119 if (mmio_address == 0) { 120 pr_err("you have to use the module argument mmio_address.\n"); 121 pr_err("DO NOT LOAD THIS MODULE UNLESS YOU REALLY KNOW WHAT YOU ARE DOING!\n"); 122 return -ENXIO; 123 } 124 125 pr_warning("WARNING: mapping %lu kB @ 0x%08lx in PCI address space, " 126 "and writing 16 kB of rubbish in there.\n", 127 size >> 10, mmio_address); 128 do_test(size); 129 do_test_bulk_ioremapping(); 130 pr_info("All done.\n"); 131 return 0; 132 } 133 134 static void __exit cleanup(void) 135 { 136 pr_debug("unloaded.\n"); 137 } 138 139 module_init(init); 140 module_exit(cleanup); 141 MODULE_LICENSE("GPL"); 142