arch/x86/mm/testmmiotrace.c

   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");