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