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