1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * drivers/uio/uio_dmem_genirq.c 4 * 5 * Userspace I/O platform driver with generic IRQ handling code. 6 * 7 * Copyright (C) 2012 Damian Hobson-Garcia 8 * 9 * Based on uio_pdrv_genirq.c by Magnus Damm 10 */ 11 12 #include <linux/platform_device.h> 13 #include <linux/uio_driver.h> 14 #include <linux/spinlock.h> 15 #include <linux/bitops.h> 16 #include <linux/module.h> 17 #include <linux/interrupt.h> 18 #include <linux/platform_data/uio_dmem_genirq.h> 19 #include <linux/stringify.h> 20 #include <linux/pm_runtime.h> 21 #include <linux/dma-mapping.h> 22 #include <linux/slab.h> 23 24 #include <linux/of.h> 25 #include <linux/of_platform.h> 26 #include <linux/of_address.h> 27 28 #define DRIVER_NAME "uio_dmem_genirq" 29 #define DMEM_MAP_ERROR (~0) 30 31 struct uio_dmem_genirq_platdata { 32 struct uio_info *uioinfo; 33 spinlock_t lock; 34 unsigned long flags; 35 struct platform_device *pdev; 36 unsigned int dmem_region_start; 37 unsigned int num_dmem_regions; 38 void *dmem_region_vaddr[MAX_UIO_MAPS]; 39 struct mutex alloc_lock; 40 unsigned int refcnt; 41 }; 42 43 static int uio_dmem_genirq_open(struct uio_info *info, struct inode *inode) 44 { 45 struct uio_dmem_genirq_platdata *priv = info->priv; 46 struct uio_mem *uiomem; 47 int dmem_region = priv->dmem_region_start; 48 49 uiomem = &priv->uioinfo->mem[priv->dmem_region_start]; 50 51 mutex_lock(&priv->alloc_lock); 52 while (!priv->refcnt && uiomem < &priv->uioinfo->mem[MAX_UIO_MAPS]) { 53 void *addr; 54 if (!uiomem->size) 55 break; 56 57 addr = dma_alloc_coherent(&priv->pdev->dev, uiomem->size, 58 (dma_addr_t *)&uiomem->addr, GFP_KERNEL); 59 if (!addr) { 60 uiomem->addr = DMEM_MAP_ERROR; 61 } 62 priv->dmem_region_vaddr[dmem_region++] = addr; 63 ++uiomem; 64 } 65 priv->refcnt++; 66 67 mutex_unlock(&priv->alloc_lock); 68 /* Wait until the Runtime PM code has woken up the device */ 69 pm_runtime_get_sync(&priv->pdev->dev); 70 return 0; 71 } 72 73 static int uio_dmem_genirq_release(struct uio_info *info, struct inode *inode) 74 { 75 struct uio_dmem_genirq_platdata *priv = info->priv; 76 struct uio_mem *uiomem; 77 int dmem_region = priv->dmem_region_start; 78 79 /* Tell the Runtime PM code that the device has become idle */ 80 pm_runtime_put_sync(&priv->pdev->dev); 81 82 uiomem = &priv->uioinfo->mem[priv->dmem_region_start]; 83 84 mutex_lock(&priv->alloc_lock); 85 86 priv->refcnt--; 87 while (!priv->refcnt && uiomem < &priv->uioinfo->mem[MAX_UIO_MAPS]) { 88 if (!uiomem->size) 89 break; 90 if (priv->dmem_region_vaddr[dmem_region]) { 91 dma_free_coherent(&priv->pdev->dev, uiomem->size, 92 priv->dmem_region_vaddr[dmem_region], 93 uiomem->addr); 94 } 95 uiomem->addr = DMEM_MAP_ERROR; 96 ++dmem_region; 97 ++uiomem; 98 } 99 100 mutex_unlock(&priv->alloc_lock); 101 return 0; 102 } 103 104 static irqreturn_t uio_dmem_genirq_handler(int irq, struct uio_info *dev_info) 105 { 106 struct uio_dmem_genirq_platdata *priv = dev_info->priv; 107 108 /* Just disable the interrupt in the interrupt controller, and 109 * remember the state so we can allow user space to enable it later. 110 */ 111 112 if (!test_and_set_bit(0, &priv->flags)) 113 disable_irq_nosync(irq); 114 115 return IRQ_HANDLED; 116 } 117 118 static int uio_dmem_genirq_irqcontrol(struct uio_info *dev_info, s32 irq_on) 119 { 120 struct uio_dmem_genirq_platdata *priv = dev_info->priv; 121 unsigned long flags; 122 123 /* Allow user space to enable and disable the interrupt 124 * in the interrupt controller, but keep track of the 125 * state to prevent per-irq depth damage. 126 * 127 * Serialize this operation to support multiple tasks. 128 */ 129 130 spin_lock_irqsave(&priv->lock, flags); 131 if (irq_on) { 132 if (test_and_clear_bit(0, &priv->flags)) 133 enable_irq(dev_info->irq); 134 spin_unlock_irqrestore(&priv->lock, flags); 135 } else { 136 if (!test_and_set_bit(0, &priv->flags)) { 137 spin_unlock_irqrestore(&priv->lock, flags); 138 disable_irq(dev_info->irq); 139 } 140 } 141 142 return 0; 143 } 144 145 static int uio_dmem_genirq_probe(struct platform_device *pdev) 146 { 147 struct uio_dmem_genirq_pdata *pdata = dev_get_platdata(&pdev->dev); 148 struct uio_info *uioinfo = &pdata->uioinfo; 149 struct uio_dmem_genirq_platdata *priv; 150 struct uio_mem *uiomem; 151 int ret = -EINVAL; 152 int i; 153 154 if (pdev->dev.of_node) { 155 /* alloc uioinfo for one device */ 156 uioinfo = kzalloc(sizeof(*uioinfo), GFP_KERNEL); 157 if (!uioinfo) { 158 ret = -ENOMEM; 159 dev_err(&pdev->dev, "unable to kmalloc\n"); 160 goto bad2; 161 } 162 uioinfo->name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "%pOFn", 163 pdev->dev.of_node); 164 uioinfo->version = "devicetree"; 165 } 166 167 if (!uioinfo || !uioinfo->name || !uioinfo->version) { 168 dev_err(&pdev->dev, "missing platform_data\n"); 169 goto bad0; 170 } 171 172 if (uioinfo->handler || uioinfo->irqcontrol || 173 uioinfo->irq_flags & IRQF_SHARED) { 174 dev_err(&pdev->dev, "interrupt configuration error\n"); 175 goto bad0; 176 } 177 178 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 179 if (!priv) { 180 ret = -ENOMEM; 181 dev_err(&pdev->dev, "unable to kmalloc\n"); 182 goto bad0; 183 } 184 185 dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); 186 187 priv->uioinfo = uioinfo; 188 spin_lock_init(&priv->lock); 189 priv->flags = 0; /* interrupt is enabled to begin with */ 190 priv->pdev = pdev; 191 mutex_init(&priv->alloc_lock); 192 193 if (!uioinfo->irq) { 194 /* Multiple IRQs are not supported */ 195 ret = platform_get_irq(pdev, 0); 196 if (ret == -ENXIO && pdev->dev.of_node) 197 ret = UIO_IRQ_NONE; 198 else if (ret < 0) 199 goto bad1; 200 uioinfo->irq = ret; 201 } 202 uiomem = &uioinfo->mem[0]; 203 204 for (i = 0; i < pdev->num_resources; ++i) { 205 struct resource *r = &pdev->resource[i]; 206 207 if (r->flags != IORESOURCE_MEM) 208 continue; 209 210 if (uiomem >= &uioinfo->mem[MAX_UIO_MAPS]) { 211 dev_warn(&pdev->dev, "device has more than " 212 __stringify(MAX_UIO_MAPS) 213 " I/O memory resources.\n"); 214 break; 215 } 216 217 uiomem->memtype = UIO_MEM_PHYS; 218 uiomem->addr = r->start; 219 uiomem->size = resource_size(r); 220 ++uiomem; 221 } 222 223 priv->dmem_region_start = uiomem - &uioinfo->mem[0]; 224 priv->num_dmem_regions = pdata->num_dynamic_regions; 225 226 for (i = 0; i < pdata->num_dynamic_regions; ++i) { 227 if (uiomem >= &uioinfo->mem[MAX_UIO_MAPS]) { 228 dev_warn(&pdev->dev, "device has more than " 229 __stringify(MAX_UIO_MAPS) 230 " dynamic and fixed memory regions.\n"); 231 break; 232 } 233 uiomem->memtype = UIO_MEM_PHYS; 234 uiomem->addr = DMEM_MAP_ERROR; 235 uiomem->size = pdata->dynamic_region_sizes[i]; 236 ++uiomem; 237 } 238 239 while (uiomem < &uioinfo->mem[MAX_UIO_MAPS]) { 240 uiomem->size = 0; 241 ++uiomem; 242 } 243 244 /* This driver requires no hardware specific kernel code to handle 245 * interrupts. Instead, the interrupt handler simply disables the 246 * interrupt in the interrupt controller. User space is responsible 247 * for performing hardware specific acknowledge and re-enabling of 248 * the interrupt in the interrupt controller. 249 * 250 * Interrupt sharing is not supported. 251 */ 252 253 uioinfo->handler = uio_dmem_genirq_handler; 254 uioinfo->irqcontrol = uio_dmem_genirq_irqcontrol; 255 uioinfo->open = uio_dmem_genirq_open; 256 uioinfo->release = uio_dmem_genirq_release; 257 uioinfo->priv = priv; 258 259 /* Enable Runtime PM for this device: 260 * The device starts in suspended state to allow the hardware to be 261 * turned off by default. The Runtime PM bus code should power on the 262 * hardware and enable clocks at open(). 263 */ 264 pm_runtime_enable(&pdev->dev); 265 266 ret = uio_register_device(&pdev->dev, priv->uioinfo); 267 if (ret) { 268 dev_err(&pdev->dev, "unable to register uio device\n"); 269 pm_runtime_disable(&pdev->dev); 270 goto bad1; 271 } 272 273 platform_set_drvdata(pdev, priv); 274 return 0; 275 bad1: 276 kfree(priv); 277 bad0: 278 /* kfree uioinfo for OF */ 279 if (pdev->dev.of_node) 280 kfree(uioinfo); 281 bad2: 282 return ret; 283 } 284 285 static int uio_dmem_genirq_remove(struct platform_device *pdev) 286 { 287 struct uio_dmem_genirq_platdata *priv = platform_get_drvdata(pdev); 288 289 uio_unregister_device(priv->uioinfo); 290 pm_runtime_disable(&pdev->dev); 291 292 priv->uioinfo->handler = NULL; 293 priv->uioinfo->irqcontrol = NULL; 294 295 /* kfree uioinfo for OF */ 296 if (pdev->dev.of_node) 297 kfree(priv->uioinfo); 298 299 kfree(priv); 300 return 0; 301 } 302 303 static int uio_dmem_genirq_runtime_nop(struct device *dev) 304 { 305 /* Runtime PM callback shared between ->runtime_suspend() 306 * and ->runtime_resume(). Simply returns success. 307 * 308 * In this driver pm_runtime_get_sync() and pm_runtime_put_sync() 309 * are used at open() and release() time. This allows the 310 * Runtime PM code to turn off power to the device while the 311 * device is unused, ie before open() and after release(). 312 * 313 * This Runtime PM callback does not need to save or restore 314 * any registers since user space is responsbile for hardware 315 * register reinitialization after open(). 316 */ 317 return 0; 318 } 319 320 static const struct dev_pm_ops uio_dmem_genirq_dev_pm_ops = { 321 .runtime_suspend = uio_dmem_genirq_runtime_nop, 322 .runtime_resume = uio_dmem_genirq_runtime_nop, 323 }; 324 325 #ifdef CONFIG_OF 326 static const struct of_device_id uio_of_genirq_match[] = { 327 { /* empty for now */ }, 328 }; 329 MODULE_DEVICE_TABLE(of, uio_of_genirq_match); 330 #endif 331 332 static struct platform_driver uio_dmem_genirq = { 333 .probe = uio_dmem_genirq_probe, 334 .remove = uio_dmem_genirq_remove, 335 .driver = { 336 .name = DRIVER_NAME, 337 .pm = &uio_dmem_genirq_dev_pm_ops, 338 .of_match_table = of_match_ptr(uio_of_genirq_match), 339 }, 340 }; 341 342 module_platform_driver(uio_dmem_genirq); 343 344 MODULE_AUTHOR("Damian Hobson-Garcia"); 345 MODULE_DESCRIPTION("Userspace I/O platform driver with dynamic memory."); 346 MODULE_LICENSE("GPL v2"); 347 MODULE_ALIAS("platform:" DRIVER_NAME); 348