Blame view
drivers/uio/uio_pdrv_genirq.c
7.45 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 |
}; |
34cb27528 UIO: Fix concurre... |
38 39 40 41 |
/* Bits in uio_pdrv_genirq_platdata.flags */ enum { UIO_IRQ_DISABLED = 0, }; |
af76756e6 uio: Runtime PM f... |
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
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 ... |
59 60 61 62 63 64 65 |
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. */ |
34cb27528 UIO: Fix concurre... |
66 67 |
spin_lock(&priv->lock); if (!__test_and_set_bit(UIO_IRQ_DISABLED, &priv->flags)) |
c767db0ab UIO: generic irq ... |
68 |
disable_irq_nosync(irq); |
34cb27528 UIO: Fix concurre... |
69 |
spin_unlock(&priv->lock); |
c767db0ab UIO: generic irq ... |
70 71 72 73 74 75 76 77 78 79 80 81 82 |
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. * |
34cb27528 UIO: Fix concurre... |
83 84 |
* Serialize this operation to support multiple tasks and concurrency * with irq handler on SMP systems. |
c767db0ab UIO: generic irq ... |
85 86 87 88 |
*/ spin_lock_irqsave(&priv->lock, flags); if (irq_on) { |
34cb27528 UIO: Fix concurre... |
89 |
if (__test_and_clear_bit(UIO_IRQ_DISABLED, &priv->flags)) |
c767db0ab UIO: generic irq ... |
90 91 |
enable_irq(dev_info->irq); } else { |
34cb27528 UIO: Fix concurre... |
92 93 |
if (!__test_and_set_bit(UIO_IRQ_DISABLED, &priv->flags)) disable_irq_nosync(dev_info->irq); |
c767db0ab UIO: generic irq ... |
94 95 96 97 98 99 100 101 |
} spin_unlock_irqrestore(&priv->lock, flags); return 0; } static int uio_pdrv_genirq_probe(struct platform_device *pdev) { |
08cb2e214 drivers: uio_pdrv... |
102 |
struct uio_info *uioinfo = dev_get_platdata(&pdev->dev); |
c767db0ab UIO: generic irq ... |
103 104 105 106 |
struct uio_pdrv_genirq_platdata *priv; struct uio_mem *uiomem; int ret = -EINVAL; int i; |
d5185c4eb drivers: uio: Onl... |
107 |
if (pdev->dev.of_node) { |
27760f868 uio: uio_pdrv_gen... |
108 |
/* alloc uioinfo for one device */ |
e6789cd3d uio: Simplify uio... |
109 110 |
uioinfo = devm_kzalloc(&pdev->dev, sizeof(*uioinfo), GFP_KERNEL); |
27760f868 uio: uio_pdrv_gen... |
111 |
if (!uioinfo) { |
27760f868 uio: uio_pdrv_gen... |
112 113 |
dev_err(&pdev->dev, "unable to kmalloc "); |
e6789cd3d uio: Simplify uio... |
114 |
return -ENOMEM; |
27760f868 uio: uio_pdrv_gen... |
115 116 117 |
} uioinfo->name = pdev->dev.of_node->name; uioinfo->version = "devicetree"; |
27760f868 uio: uio_pdrv_gen... |
118 |
/* Multiple IRQs are not supported */ |
27760f868 uio: uio_pdrv_gen... |
119 |
} |
c767db0ab UIO: generic irq ... |
120 121 122 |
if (!uioinfo || !uioinfo->name || !uioinfo->version) { dev_err(&pdev->dev, "missing platform_data "); |
e6789cd3d uio: Simplify uio... |
123 |
return ret; |
c767db0ab UIO: generic irq ... |
124 |
} |
e543ae896 UIO: uio_pdrv_gen... |
125 126 |
if (uioinfo->handler || uioinfo->irqcontrol || uioinfo->irq_flags & IRQF_SHARED) { |
c767db0ab UIO: generic irq ... |
127 128 |
dev_err(&pdev->dev, "interrupt configuration error "); |
e6789cd3d uio: Simplify uio... |
129 |
return ret; |
c767db0ab UIO: generic irq ... |
130 |
} |
e6789cd3d uio: Simplify uio... |
131 |
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); |
c767db0ab UIO: generic irq ... |
132 |
if (!priv) { |
c767db0ab UIO: generic irq ... |
133 134 |
dev_err(&pdev->dev, "unable to kmalloc "); |
e6789cd3d uio: Simplify uio... |
135 |
return -ENOMEM; |
c767db0ab UIO: generic irq ... |
136 137 138 139 140 |
} priv->uioinfo = uioinfo; spin_lock_init(&priv->lock); priv->flags = 0; /* interrupt is enabled to begin with */ |
af76756e6 uio: Runtime PM f... |
141 |
priv->pdev = pdev; |
c767db0ab UIO: generic irq ... |
142 |
|
94ca629e4 uio_pdrv_genirq: ... |
143 144 |
if (!uioinfo->irq) { ret = platform_get_irq(pdev, 0); |
e3a3c3a20 UIO: fix uio_pdrv... |
145 146 147 148 |
uioinfo->irq = ret; if (ret == -ENXIO && pdev->dev.of_node) uioinfo->irq = UIO_IRQ_NONE; else if (ret < 0) { |
94ca629e4 uio_pdrv_genirq: ... |
149 150 |
dev_err(&pdev->dev, "failed to get IRQ "); |
e6789cd3d uio: Simplify uio... |
151 |
return ret; |
94ca629e4 uio_pdrv_genirq: ... |
152 |
} |
94ca629e4 uio_pdrv_genirq: ... |
153 |
} |
e3a3c3a20 UIO: fix uio_pdrv... |
154 |
|
c767db0ab UIO: generic irq ... |
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 |
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... |
173 |
uiomem->size = resource_size(r); |
ecd43c0d7 uio_pdrv: set mem... |
174 |
uiomem->name = r->name; |
c767db0ab UIO: generic irq ... |
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 |
++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 ... |
191 192 |
uioinfo->handler = uio_pdrv_genirq_handler; uioinfo->irqcontrol = uio_pdrv_genirq_irqcontrol; |
af76756e6 uio: Runtime PM f... |
193 194 |
uioinfo->open = uio_pdrv_genirq_open; uioinfo->release = uio_pdrv_genirq_release; |
c767db0ab UIO: generic irq ... |
195 |
uioinfo->priv = priv; |
af76756e6 uio: Runtime PM f... |
196 197 198 199 200 201 |
/* 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 ... |
202 203 204 205 |
ret = uio_register_device(&pdev->dev, priv->uioinfo); if (ret) { dev_err(&pdev->dev, "unable to register uio device "); |
e6789cd3d uio: Simplify uio... |
206 207 |
pm_runtime_disable(&pdev->dev); return ret; |
c767db0ab UIO: generic irq ... |
208 209 210 211 |
} platform_set_drvdata(pdev, priv); return 0; |
c767db0ab UIO: generic irq ... |
212 213 214 215 216 217 218 |
} 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... |
219 |
pm_runtime_disable(&pdev->dev); |
47296b196 uio: clean uioinf... |
220 221 222 |
priv->uioinfo->handler = NULL; priv->uioinfo->irqcontrol = NULL; |
c767db0ab UIO: generic irq ... |
223 224 |
return 0; } |
af76756e6 uio: Runtime PM f... |
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 |
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... |
241 |
static const struct dev_pm_ops uio_pdrv_genirq_dev_pm_ops = { |
af76756e6 uio: Runtime PM f... |
242 243 244 |
.runtime_suspend = uio_pdrv_genirq_runtime_nop, .runtime_resume = uio_pdrv_genirq_runtime_nop, }; |
27760f868 uio: uio_pdrv_gen... |
245 |
#ifdef CONFIG_OF |
05c3e0bb5 UIO: allow bindin... |
246 247 248 |
static struct of_device_id uio_of_genirq_match[] = { { /* This is filled with module_parm */ }, { /* Sentinel */ }, |
27760f868 uio: uio_pdrv_gen... |
249 250 |
}; MODULE_DEVICE_TABLE(of, uio_of_genirq_match); |
05c3e0bb5 UIO: allow bindin... |
251 252 |
module_param_string(of_id, uio_of_genirq_match[0].compatible, 128, 0); MODULE_PARM_DESC(of_id, "Openfirmware id of the device to be handled by uio"); |
27760f868 uio: uio_pdrv_gen... |
253 |
#endif |
c767db0ab UIO: generic irq ... |
254 255 256 257 258 |
static struct platform_driver uio_pdrv_genirq = { .probe = uio_pdrv_genirq_probe, .remove = uio_pdrv_genirq_remove, .driver = { .name = DRIVER_NAME, |
af76756e6 uio: Runtime PM f... |
259 |
.pm = &uio_pdrv_genirq_dev_pm_ops, |
cee4fbd6c drivers: uio_pdrv... |
260 |
.of_match_table = of_match_ptr(uio_of_genirq_match), |
c767db0ab UIO: generic irq ... |
261 262 |
}, }; |
11e3123d9 uio: convert driv... |
263 |
module_platform_driver(uio_pdrv_genirq); |
c767db0ab UIO: generic irq ... |
264 265 266 267 268 |
MODULE_AUTHOR("Magnus Damm"); MODULE_DESCRIPTION("Userspace I/O platform driver with generic IRQ handling"); MODULE_LICENSE("GPL v2"); MODULE_ALIAS("platform:" DRIVER_NAME); |