1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * drivers/uio/uio_pdrv_genirq.c 4 * 5 * Userspace I/O platform driver with generic IRQ handling code. 6 * 7 * Copyright (C) 2008 Magnus Damm 8 * 9 * Based on uio_pdrv.c by Uwe Kleine-Koenig, 10 * Copyright (C) 2008 by Digi International Inc. 11 * All rights reserved. 12 */ 13 14 #include <linux/platform_device.h> 15 #include <linux/uio_driver.h> 16 #include <linux/spinlock.h> 17 #include <linux/bitops.h> 18 #include <linux/module.h> 19 #include <linux/interrupt.h> 20 #include <linux/stringify.h> 21 #include <linux/pm_runtime.h> 22 #include <linux/slab.h> 23 24 #include <linux/of.h> 25 #include <linux/of_platform.h> 26 #include <linux/of_address.h> 27 28 #define DRIVER_NAME "uio_pdrv_genirq" 29 30 struct uio_pdrv_genirq_platdata { 31 struct uio_info *uioinfo; 32 spinlock_t lock; 33 unsigned long flags; 34 struct platform_device *pdev; 35 }; 36 37 /* Bits in uio_pdrv_genirq_platdata.flags */ 38 enum { 39 UIO_IRQ_DISABLED = 0, 40 }; 41 42 static int uio_pdrv_genirq_open(struct uio_info *info, struct inode *inode) 43 { 44 struct uio_pdrv_genirq_platdata *priv = info->priv; 45 46 /* Wait until the Runtime PM code has woken up the device */ 47 pm_runtime_get_sync(&priv->pdev->dev); 48 return 0; 49 } 50 51 static int uio_pdrv_genirq_release(struct uio_info *info, struct inode *inode) 52 { 53 struct uio_pdrv_genirq_platdata *priv = info->priv; 54 55 /* Tell the Runtime PM code that the device has become idle */ 56 pm_runtime_put_sync(&priv->pdev->dev); 57 return 0; 58 } 59 60 static irqreturn_t uio_pdrv_genirq_handler(int irq, struct uio_info *dev_info) 61 { 62 struct uio_pdrv_genirq_platdata *priv = dev_info->priv; 63 64 /* Just disable the interrupt in the interrupt controller, and 65 * remember the state so we can allow user space to enable it later. 66 */ 67 68 spin_lock(&priv->lock); 69 if (!__test_and_set_bit(UIO_IRQ_DISABLED, &priv->flags)) 70 disable_irq_nosync(irq); 71 spin_unlock(&priv->lock); 72 73 return IRQ_HANDLED; 74 } 75 76 static int uio_pdrv_genirq_irqcontrol(struct uio_info *dev_info, s32 irq_on) 77 { 78 struct uio_pdrv_genirq_platdata *priv = dev_info->priv; 79 unsigned long flags; 80 81 /* Allow user space to enable and disable the interrupt 82 * in the interrupt controller, but keep track of the 83 * state to prevent per-irq depth damage. 84 * 85 * Serialize this operation to support multiple tasks and concurrency 86 * with irq handler on SMP systems. 87 */ 88 89 spin_lock_irqsave(&priv->lock, flags); 90 if (irq_on) { 91 if (__test_and_clear_bit(UIO_IRQ_DISABLED, &priv->flags)) 92 enable_irq(dev_info->irq); 93 } else { 94 if (!__test_and_set_bit(UIO_IRQ_DISABLED, &priv->flags)) 95 disable_irq_nosync(dev_info->irq); 96 } 97 spin_unlock_irqrestore(&priv->lock, flags); 98 99 return 0; 100 } 101 102 static int uio_pdrv_genirq_probe(struct platform_device *pdev) 103 { 104 struct uio_info *uioinfo = dev_get_platdata(&pdev->dev); 105 struct uio_pdrv_genirq_platdata *priv; 106 struct uio_mem *uiomem; 107 int ret = -EINVAL; 108 int i; 109 110 if (pdev->dev.of_node) { 111 /* alloc uioinfo for one device */ 112 uioinfo = devm_kzalloc(&pdev->dev, sizeof(*uioinfo), 113 GFP_KERNEL); 114 if (!uioinfo) { 115 dev_err(&pdev->dev, "unable to kmalloc\n"); 116 return -ENOMEM; 117 } 118 uioinfo->name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "%pOFn", 119 pdev->dev.of_node); 120 uioinfo->version = "devicetree"; 121 /* Multiple IRQs are not supported */ 122 } 123 124 if (!uioinfo || !uioinfo->name || !uioinfo->version) { 125 dev_err(&pdev->dev, "missing platform_data\n"); 126 return ret; 127 } 128 129 if (uioinfo->handler || uioinfo->irqcontrol || 130 uioinfo->irq_flags & IRQF_SHARED) { 131 dev_err(&pdev->dev, "interrupt configuration error\n"); 132 return ret; 133 } 134 135 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 136 if (!priv) { 137 dev_err(&pdev->dev, "unable to kmalloc\n"); 138 return -ENOMEM; 139 } 140 141 priv->uioinfo = uioinfo; 142 spin_lock_init(&priv->lock); 143 priv->flags = 0; /* interrupt is enabled to begin with */ 144 priv->pdev = pdev; 145 146 if (!uioinfo->irq) { 147 ret = platform_get_irq(pdev, 0); 148 uioinfo->irq = ret; 149 if (ret == -ENXIO && pdev->dev.of_node) 150 uioinfo->irq = UIO_IRQ_NONE; 151 else if (ret < 0) { 152 dev_err(&pdev->dev, "failed to get IRQ\n"); 153 return ret; 154 } 155 } 156 157 uiomem = &uioinfo->mem[0]; 158 159 for (i = 0; i < pdev->num_resources; ++i) { 160 struct resource *r = &pdev->resource[i]; 161 162 if (r->flags != IORESOURCE_MEM) 163 continue; 164 165 if (uiomem >= &uioinfo->mem[MAX_UIO_MAPS]) { 166 dev_warn(&pdev->dev, "device has more than " 167 __stringify(MAX_UIO_MAPS) 168 " I/O memory resources.\n"); 169 break; 170 } 171 172 uiomem->memtype = UIO_MEM_PHYS; 173 uiomem->addr = r->start; 174 uiomem->size = resource_size(r); 175 uiomem->name = r->name; 176 ++uiomem; 177 } 178 179 while (uiomem < &uioinfo->mem[MAX_UIO_MAPS]) { 180 uiomem->size = 0; 181 ++uiomem; 182 } 183 184 /* This driver requires no hardware specific kernel code to handle 185 * interrupts. Instead, the interrupt handler simply disables the 186 * interrupt in the interrupt controller. User space is responsible 187 * for performing hardware specific acknowledge and re-enabling of 188 * the interrupt in the interrupt controller. 189 * 190 * Interrupt sharing is not supported. 191 */ 192 193 uioinfo->handler = uio_pdrv_genirq_handler; 194 uioinfo->irqcontrol = uio_pdrv_genirq_irqcontrol; 195 uioinfo->open = uio_pdrv_genirq_open; 196 uioinfo->release = uio_pdrv_genirq_release; 197 uioinfo->priv = priv; 198 199 /* Enable Runtime PM for this device: 200 * The device starts in suspended state to allow the hardware to be 201 * turned off by default. The Runtime PM bus code should power on the 202 * hardware and enable clocks at open(). 203 */ 204 pm_runtime_enable(&pdev->dev); 205 206 ret = uio_register_device(&pdev->dev, priv->uioinfo); 207 if (ret) { 208 dev_err(&pdev->dev, "unable to register uio device\n"); 209 pm_runtime_disable(&pdev->dev); 210 return ret; 211 } 212 213 platform_set_drvdata(pdev, priv); 214 return 0; 215 } 216 217 static int uio_pdrv_genirq_remove(struct platform_device *pdev) 218 { 219 struct uio_pdrv_genirq_platdata *priv = platform_get_drvdata(pdev); 220 221 uio_unregister_device(priv->uioinfo); 222 pm_runtime_disable(&pdev->dev); 223 224 priv->uioinfo->handler = NULL; 225 priv->uioinfo->irqcontrol = NULL; 226 227 return 0; 228 } 229 230 static int uio_pdrv_genirq_runtime_nop(struct device *dev) 231 { 232 /* Runtime PM callback shared between ->runtime_suspend() 233 * and ->runtime_resume(). Simply returns success. 234 * 235 * In this driver pm_runtime_get_sync() and pm_runtime_put_sync() 236 * are used at open() and release() time. This allows the 237 * Runtime PM code to turn off power to the device while the 238 * device is unused, ie before open() and after release(). 239 * 240 * This Runtime PM callback does not need to save or restore 241 * any registers since user space is responsbile for hardware 242 * register reinitialization after open(). 243 */ 244 return 0; 245 } 246 247 static const struct dev_pm_ops uio_pdrv_genirq_dev_pm_ops = { 248 .runtime_suspend = uio_pdrv_genirq_runtime_nop, 249 .runtime_resume = uio_pdrv_genirq_runtime_nop, 250 }; 251 252 #ifdef CONFIG_OF 253 static struct of_device_id uio_of_genirq_match[] = { 254 { /* This is filled with module_parm */ }, 255 { /* Sentinel */ }, 256 }; 257 MODULE_DEVICE_TABLE(of, uio_of_genirq_match); 258 module_param_string(of_id, uio_of_genirq_match[0].compatible, 128, 0); 259 MODULE_PARM_DESC(of_id, "Openfirmware id of the device to be handled by uio"); 260 #endif 261 262 static struct platform_driver uio_pdrv_genirq = { 263 .probe = uio_pdrv_genirq_probe, 264 .remove = uio_pdrv_genirq_remove, 265 .driver = { 266 .name = DRIVER_NAME, 267 .pm = &uio_pdrv_genirq_dev_pm_ops, 268 .of_match_table = of_match_ptr(uio_of_genirq_match), 269 }, 270 }; 271 272 module_platform_driver(uio_pdrv_genirq); 273 274 MODULE_AUTHOR("Magnus Damm"); 275 MODULE_DESCRIPTION("Userspace I/O platform driver with generic IRQ handling"); 276 MODULE_LICENSE("GPL v2"); 277 MODULE_ALIAS("platform:" DRIVER_NAME); 278