1
0
mirror of git://projects.qi-hardware.com/openwrt-xburst.git synced 2024-10-30 03:03:08 +02:00
openwrt-xburst/target/linux/ubicom32/files/drivers/uio/uio_ubicom32ring.c

289 lines
7.3 KiB
C
Raw Normal View History

/*
* drivers/uio/uio_ubicom32ring.c
*
* Userspace I/O platform driver for Ubicom32 ring buffers
*
* (C) Copyright 2009, Ubicom, Inc.
*
* This file is part of the Ubicom32 Linux Kernel Port.
*
* Based on uio_ubicom32ring.c by Magnus Damm
*
* The Ubicom32 Linux Kernel Port is free software: you can redistribute
* it and/or modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, either version 2 of the
* License, or (at your option) any later version.
*
* The Ubicom32 Linux Kernel Port is distributed in the hope that it
* will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
* the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with the Ubicom32 Linux Kernel Port. If not,
* see <http://www.gnu.org/licenses/>.
*/
#include <linux/platform_device.h>
#include <linux/uio_driver.h>
#include <linux/spinlock.h>
#include <linux/bitops.h>
#include <linux/interrupt.h>
#include <linux/stringify.h>
#include <asm/ip5000.h>
#include <asm/ubicom32ring.h>
#define DRIVER_NAME "uio_ubicom32ring"
struct uio_ubicom32ring_data {
struct uio_info *uioinfo;
struct uio_ubicom32ring_regs *regs;
/*
* IRQ used to kick the ring buffer
*/
int irq_tx;
int irq_rx;
spinlock_t lock;
unsigned long flags;
char name[0];
};
static irqreturn_t uio_ubicom32ring_handler(int irq, struct uio_info *dev_info)
{
struct uio_ubicom32ring_data *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_ubicom32ring_irqcontrol(struct uio_info *dev_info, s32 irq_on)
{
struct uio_ubicom32ring_data *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 & 2) {
/*
* Kick the ring buffer (if we can)
*/
if (priv->irq_tx != 0xFF) {
ubicom32_set_interrupt(priv->irq_tx);
}
}
if (priv->irq_rx != 0xFF) {
if (irq_on & 1) {
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_ubicom32ring_probe(struct platform_device *pdev)
{
struct uio_info *uioinfo;
struct uio_mem *uiomem;
struct uio_ubicom32ring_data *priv;
struct uio_ubicom32ring_regs *regs;
struct resource *mem_resource;
struct resource *irqtx_resource;
struct resource *irqrx_resource;
int ret = -EINVAL;
int i;
uioinfo = kzalloc(sizeof(struct uio_info), GFP_KERNEL);
if (!uioinfo) {
dev_err(&pdev->dev, "unable to kmalloc\n");
return -ENOMEM;
}
/*
* Allocate private data with some string space after
*/
i = sizeof(DRIVER_NAME) + 1;
i += pdev->dev.platform_data ? strlen(pdev->dev.platform_data) : 0;
priv = kzalloc(sizeof(struct uio_ubicom32ring_data) + i, GFP_KERNEL);
if (!priv) {
dev_err(&pdev->dev, "unable to kmalloc\n");
kfree(uioinfo);
return -ENOMEM;
}
strcpy(priv->name, DRIVER_NAME ":");
if (pdev->dev.platform_data) {
strcat(priv->name, pdev->dev.platform_data);
}
uioinfo->priv = priv;
uioinfo->name = priv->name;
uioinfo->version = "0.1";
priv->uioinfo = uioinfo;
spin_lock_init(&priv->lock);
priv->flags = 0; /* interrupt is enabled to begin with */
/*
* Get our resources, the IRQ_TX and IRQ_RX are optional.
*/
priv->irq_tx = 0xFF;
irqtx_resource = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (irqtx_resource) {
priv->irq_tx = irqtx_resource->start;
}
uioinfo->irq = -1;
priv->irq_rx = 0xFF;
irqrx_resource = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
if (irqrx_resource) {
priv->irq_rx = irqrx_resource->start;
uioinfo->irq = priv->irq_rx;
uioinfo->handler = uio_ubicom32ring_handler;
}
mem_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem_resource || !mem_resource->start) {
dev_err(&pdev->dev, "No valid memory resource found\n");
ret = -ENODEV;
goto fail;
}
regs = (struct uio_ubicom32ring_regs *)mem_resource->start;
priv->regs = regs;
if (regs->version != UIO_UBICOM32RING_REG_VERSION) {
dev_err(&pdev->dev, "version %d not supported\n", regs->version);
ret = -ENODEV;
goto fail;
}
/*
* First range is the shared register space, if we have any
*/
uiomem = &uioinfo->mem[0];
if (regs->regs_size) {
uiomem->memtype = UIO_MEM_PHYS;
uiomem->addr = (u32_t)regs->regs;
uiomem->size = regs->regs_size;
++uiomem;
dev_info(&pdev->dev, "regs:%p (%u) / rings: %d found\n", regs->regs, regs->regs_size, regs->num_rings);
} else {
dev_info(&pdev->dev, "rings: %d found\n", regs->num_rings);
}
/*
* The rest of the range correspond to the rings
*/
for (i = 0; i < regs->num_rings; i++) {
dev_info(&pdev->dev, "\t%d: entries:%d ring:%p\n",
i, regs->rings[i]->entries, &(regs->rings[i]->ring));
if (uiomem >= &uioinfo->mem[MAX_UIO_MAPS]) {
dev_warn(&pdev->dev, "device has more than "
__stringify(MAX_UIO_MAPS)
" I/O memory resources.\n");
break;
}
uiomem->memtype = UIO_MEM_PHYS;
uiomem->addr = (u32_t)&(regs->rings[i]->head);
uiomem->size = (regs->rings[i]->entries * sizeof(u32_t)) +
sizeof(struct uio_ubicom32ring_desc);
++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.
*/
uioinfo->irq_flags = IRQF_DISABLED;
uioinfo->irqcontrol = uio_ubicom32ring_irqcontrol;
ret = uio_register_device(&pdev->dev, priv->uioinfo);
if (ret) {
dev_err(&pdev->dev, "unable to register uio device\n");
goto fail;
}
platform_set_drvdata(pdev, priv);
dev_info(&pdev->dev, "'%s' using irq: rx %d tx %d, regs %p\n",
priv->name, priv->irq_rx, priv->irq_tx, priv->regs);
return 0;
fail:
kfree(uioinfo);
kfree(priv);
return ret;
}
static int uio_ubicom32ring_remove(struct platform_device *pdev)
{
struct uio_ubicom32ring_data *priv = platform_get_drvdata(pdev);
uio_unregister_device(priv->uioinfo);
kfree(priv->uioinfo);
kfree(priv);
return 0;
}
static struct platform_driver uio_ubicom32ring = {
.probe = uio_ubicom32ring_probe,
.remove = uio_ubicom32ring_remove,
.driver = {
.name = DRIVER_NAME,
.owner = THIS_MODULE,
},
};
static int __init uio_ubicom32ring_init(void)
{
return platform_driver_register(&uio_ubicom32ring);
}
static void __exit uio_ubicom32ring_exit(void)
{
platform_driver_unregister(&uio_ubicom32ring);
}
module_init(uio_ubicom32ring_init);
module_exit(uio_ubicom32ring_exit);
MODULE_AUTHOR("Patrick Tjin");
MODULE_DESCRIPTION("Userspace I/O driver for Ubicom32 ring buffers");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:" DRIVER_NAME);