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 25 #define DRIVER_NAME "uio_pdrv_genirq" 26 27 struct uio_pdrv_genirq_platdata { 28 struct uio_info *uioinfo; 29 spinlock_t lock; 30 unsigned long flags; 31 struct platform_device *pdev; 32 }; 33 34 static int uio_pdrv_genirq_open(struct uio_info *info, struct inode *inode) 35 { 36 struct uio_pdrv_genirq_platdata *priv = info->priv; 37 38 /* Wait until the Runtime PM code has woken up the device */ 39 pm_runtime_get_sync(&priv->pdev->dev); 40 return 0; 41 } 42 43 static int uio_pdrv_genirq_release(struct uio_info *info, struct inode *inode) 44 { 45 struct uio_pdrv_genirq_platdata *priv = info->priv; 46 47 /* Tell the Runtime PM code that the device has become idle */ 48 pm_runtime_put_sync(&priv->pdev->dev); 49 return 0; 50 } 51 52 static irqreturn_t uio_pdrv_genirq_handler(int irq, struct uio_info *dev_info) 53 { 54 struct uio_pdrv_genirq_platdata *priv = dev_info->priv; 55 56 /* Just disable the interrupt in the interrupt controller, and 57 * remember the state so we can allow user space to enable it later. 58 */ 59 60 if (!test_and_set_bit(0, &priv->flags)) 61 disable_irq_nosync(irq); 62 63 return IRQ_HANDLED; 64 } 65 66 static int uio_pdrv_genirq_irqcontrol(struct uio_info *dev_info, s32 irq_on) 67 { 68 struct uio_pdrv_genirq_platdata *priv = dev_info->priv; 69 unsigned long flags; 70 71 /* Allow user space to enable and disable the interrupt 72 * in the interrupt controller, but keep track of the 73 * state to prevent per-irq depth damage. 74 * 75 * Serialize this operation to support multiple tasks. 76 */ 77 78 spin_lock_irqsave(&priv->lock, flags); 79 if (irq_on) { 80 if (test_and_clear_bit(0, &priv->flags)) 81 enable_irq(dev_info->irq); 82 } else { 83 if (!test_and_set_bit(0, &priv->flags)) 84 disable_irq(dev_info->irq); 85 } 86 spin_unlock_irqrestore(&priv->lock, flags); 87 88 return 0; 89 } 90 91 static int uio_pdrv_genirq_probe(struct platform_device *pdev) 92 { 93 struct uio_info *uioinfo = pdev->dev.platform_data; 94 struct uio_pdrv_genirq_platdata *priv; 95 struct uio_mem *uiomem; 96 int ret = -EINVAL; 97 int i; 98 99 if (!uioinfo || !uioinfo->name || !uioinfo->version) { 100 dev_err(&pdev->dev, "missing platform_data\n"); 101 goto bad0; 102 } 103 104 if (uioinfo->handler || uioinfo->irqcontrol || 105 uioinfo->irq_flags & IRQF_SHARED) { 106 dev_err(&pdev->dev, "interrupt configuration error\n"); 107 goto bad0; 108 } 109 110 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 111 if (!priv) { 112 ret = -ENOMEM; 113 dev_err(&pdev->dev, "unable to kmalloc\n"); 114 goto bad0; 115 } 116 117 priv->uioinfo = uioinfo; 118 spin_lock_init(&priv->lock); 119 priv->flags = 0; /* interrupt is enabled to begin with */ 120 priv->pdev = pdev; 121 122 uiomem = &uioinfo->mem[0]; 123 124 for (i = 0; i < pdev->num_resources; ++i) { 125 struct resource *r = &pdev->resource[i]; 126 127 if (r->flags != IORESOURCE_MEM) 128 continue; 129 130 if (uiomem >= &uioinfo->mem[MAX_UIO_MAPS]) { 131 dev_warn(&pdev->dev, "device has more than " 132 __stringify(MAX_UIO_MAPS) 133 " I/O memory resources.\n"); 134 break; 135 } 136 137 uiomem->memtype = UIO_MEM_PHYS; 138 uiomem->addr = r->start; 139 uiomem->size = r->end - r->start + 1; 140 ++uiomem; 141 } 142 143 while (uiomem < &uioinfo->mem[MAX_UIO_MAPS]) { 144 uiomem->size = 0; 145 ++uiomem; 146 } 147 148 /* This driver requires no hardware specific kernel code to handle 149 * interrupts. Instead, the interrupt handler simply disables the 150 * interrupt in the interrupt controller. User space is responsible 151 * for performing hardware specific acknowledge and re-enabling of 152 * the interrupt in the interrupt controller. 153 * 154 * Interrupt sharing is not supported. 155 */ 156 157 uioinfo->irq_flags |= IRQF_DISABLED; 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 kfree(priv); 193 return 0; 194 } 195 196 static int uio_pdrv_genirq_runtime_nop(struct device *dev) 197 { 198 /* Runtime PM callback shared between ->runtime_suspend() 199 * and ->runtime_resume(). Simply returns success. 200 * 201 * In this driver pm_runtime_get_sync() and pm_runtime_put_sync() 202 * are used at open() and release() time. This allows the 203 * Runtime PM code to turn off power to the device while the 204 * device is unused, ie before open() and after release(). 205 * 206 * This Runtime PM callback does not need to save or restore 207 * any registers since user space is responsbile for hardware 208 * register reinitialization after open(). 209 */ 210 return 0; 211 } 212 213 static const struct dev_pm_ops uio_pdrv_genirq_dev_pm_ops = { 214 .runtime_suspend = uio_pdrv_genirq_runtime_nop, 215 .runtime_resume = uio_pdrv_genirq_runtime_nop, 216 }; 217 218 static struct platform_driver uio_pdrv_genirq = { 219 .probe = uio_pdrv_genirq_probe, 220 .remove = uio_pdrv_genirq_remove, 221 .driver = { 222 .name = DRIVER_NAME, 223 .owner = THIS_MODULE, 224 .pm = &uio_pdrv_genirq_dev_pm_ops, 225 }, 226 }; 227 228 static int __init uio_pdrv_genirq_init(void) 229 { 230 return platform_driver_register(&uio_pdrv_genirq); 231 } 232 233 static void __exit uio_pdrv_genirq_exit(void) 234 { 235 platform_driver_unregister(&uio_pdrv_genirq); 236 } 237 238 module_init(uio_pdrv_genirq_init); 239 module_exit(uio_pdrv_genirq_exit); 240 241 MODULE_AUTHOR("Magnus Damm"); 242 MODULE_DESCRIPTION("Userspace I/O platform driver with generic IRQ handling"); 243 MODULE_LICENSE("GPL v2"); 244 MODULE_ALIAS("platform:" DRIVER_NAME); 245