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