UIO Driver Info
Nick Burkitt
UIO Magic
The snickerdoodle prebuilt Linux image includes the uio_pdrv_genirq driver built into the kernel. This allows you talk to memory-mapped hardware, and even handle interrupts, from user-space code.
I've installed vsftpd on my snickerdoodle to facilitate transferring files.
Install package | # apt-get install vsftpd |
Edit /etc/vsftpd.conf, and uncomment this line. | #write_enable=YES |
Restart service | # service vsftpd restart |
Using the UIO Driver
Add a description of your device to the devicetree source. One quick and dirty way is just to decompile the dtb file from the boot image provided by krtkl, then modify and recompile it. The reader is encouraged to post better ways to do it.
There's no man page for dtc, but you can use
$ dtc --help
to see the syntax of the commands.
Add Your Device to the Devicetree BLOB
|
Reverse-compile the devicetree BLOB. |
$ dtc -I dtb -O dts -o reversed.dts devicetree.dtb |
|
Edit (a copy of, so you won't have to do it again) the reversed devicetree source. |
$ cp reversed.dts uio.dts $ vi uio.dts |
|
Add your devicetree node. This is what mine looked like. The reverse-compiled source has lost its symbols, such as that for the interrupt parent device, so look to see what other nodes are using. Of course if you know what you're doing, you may have a better idea. |
counters@0x43C00000 { compatible = "nix-uio"; // your unique id reg = < 0x43C00000 0x1000 >; // device address and size interrupts = <0 57 1>; // interrupt number interrupt-parent = <0x3>; // see what the other nodes use }; |
|
Recompile the modified devicetree source. I set DTS_SOURCE for convenience. |
$ export DTS_SOURCE=~/git/Snickerdoodle/snickerdoodle-linux/arch/arm/boot/dts $ dtc -I dts -i $DTS_SOURCE -O dtb -o uio.dtb uio.dts |
Modify the Boot Configuration
Modify uEnv.txt, which lives in snickerdoodle's BOOT partition, by changing the value of the "bootargs" parameter to include the string "uio_pdrv_genirq.of_id=my-uio" (excluding quotation marks).
You can do this on the board (as root).
|
Mount the BOOT partition. |
# mkdir /BOOT # mount /dev/mmcblk0p1 /BOOT |
|
Edit /BOOT/uEnv.txt. Add the blue part to the definition of bootargs, of course using the "compatible" string from your devicetree. |
bootargs=console=ttyPS0,115200 root=/dev/mmcblk0p2 rw rootwait earlyprintk uio_pdrv_genirq.of_id=nix-uio |
|
Copy your custom .dtb file to the BOOT partition of your snickerdoodle SD card. |
Read this post by Bush to see how to manage bistreams and their associated .dtb files. |
|
Unmount /BOOT |
# sync # umount /BOOT |
Now reboot, and
check for a device named /dev/uioN, where N is an integer, typically 0.
Simple C++ user space driver code is attached as an example. This version doesn't use interrupts.
Some Links, most of which are rather out-of-date.
http://fpga.org/2013/05/28/how-to-design-and-access-a-memory-mapped-device-part-one/
http://fpga.org/2013/05/28/how-to-design-and-access-a-memory-mapped-device-part-two/
http://alvarom.com/2014/12/17/linux-user-space-drivers-with-interrupts/
https://yurovsky.github.io/2014/10/10/linux-uio-gpio-interrupt/
weath...@krtkl.com
The device that you are accessing in the FPGA via UIO, what does it do? I saw the offsets declared but I was just curious so that I could understand.
It is one of our objectives to get a very very simple end to end example together showing C->UIO->Linux->FPGA->Simple Compute/I/O on snickerdoodle documented.
interrupts = < 57 >; // interrupt number
interrupt-parent = <0x3>; // see what the other nodes use
};
Recompile the modified devicetree source. I set DTS_SOURCE for convenience.
$ export DTS_SOURCE=~/git/Snickerdoodle/snickerdoodle-linux/arch/arm/boot/dts
$ dtc -I dts -i $DTS_SOURCE -O dtb -o uio.dtb uio.dts
Nick Burkitt
chrisnr...@gmail.com
Just to add in case anyone wants a C example of a UIO device driver. Below(tried to attach but did not see option in browser) is a UIO driver I used on another Zynq board for another project that interfaces with a FPGA hardware step generator component.
/*
*
*
* Userspace I/O platform driver
*
* 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>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/stringify.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/of_address.h>
#define DRIVER_NAME "mk_basic_step"
struct uio_pdrv_genirq_platdata {
struct uio_info *uioinfo;
spinlock_t lock;
unsigned long flags;
struct platform_device *pdev;
};
/* Bits in uio_pdrv_genirq_platdata.flags */
enum {
UIO_IRQ_DISABLED = 1,
};
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;
}
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_mk_basic_step_io_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;
if (pdev->dev.of_node) {
int irq;
/* alloc uioinfo for one device */
uioinfo = kzalloc(sizeof(*uioinfo), GFP_KERNEL);
if (!uioinfo) {
ret = -ENOMEM;
dev_err(&pdev->dev, "unable to kmalloc\n");
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;
}
if (!uioinfo || !uioinfo->name || !uioinfo->version) {
dev_err(&pdev->dev, "missing platform_data\n");
goto bad0;
}
if (uioinfo->handler || uioinfo->irqcontrol ||
uioinfo->irq_flags & IRQF_SHARED) {
dev_err(&pdev->dev, "interrupt configuration error\n");
goto bad0;
}
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
if (!priv) {
ret = -ENOMEM;
dev_err(&pdev->dev, "unable to kmalloc\n");
goto bad0;
}
priv->uioinfo = uioinfo;
spin_lock_init(&priv->lock);
priv->flags = 0; /* interrupt is enabled to begin with */
priv->pdev = pdev;
if (!uioinfo->irq) {
ret = platform_get_irq(pdev, 0);
if (ret < 0) {
dev_err(&pdev->dev, "setting: uioinfo->irq = UIO_IRQ_NONE \n");
// goto bad0;
uioinfo->irq = UIO_IRQ_NONE;
}
// uioinfo->irq = ret;
}
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.\n");
break;
}
uiomem->memtype = UIO_MEM_PHYS;
uiomem->addr = r->start;
uiomem->size = resource_size(r);
uiomem->name = r->name;
++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->handler = uio_pdrv_genirq_handler;
uioinfo->irqcontrol = uio_pdrv_genirq_irqcontrol;
uioinfo->open = uio_pdrv_genirq_open;
uioinfo->release = uio_pdrv_genirq_release;
uioinfo->priv = priv;
/* 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);
ret = uio_register_device(&pdev->dev, priv->uioinfo);
if (ret) {
dev_err(&pdev->dev, "unable to register uio device\n");
goto bad1;
}
platform_set_drvdata(pdev, priv);
return 0;
bad1:
kfree(priv);
pm_runtime_disable(&pdev->dev);
bad0:
/* kfree uioinfo for OF */
if (pdev->dev.of_node)
kfree(uioinfo);
bad2:
return ret;
}
static int uio_pdrv_mk_basic_step_io_remove(struct platform_device *pdev)
{
struct uio_pdrv_genirq_platdata *priv = platform_get_drvdata(pdev);
uio_unregister_device(priv->uioinfo);
pm_runtime_disable(&pdev->dev);
priv->uioinfo->handler = NULL;
priv->uioinfo->irqcontrol = NULL;
/* kfree uioinfo for OF */
if (pdev->dev.of_node)
kfree(priv->uioinfo);
kfree(priv);
return 0;
}
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;
}
static const struct dev_pm_ops uio_pdrv_genirq_dev_pm_ops = {
.runtime_suspend = uio_pdrv_genirq_runtime_nop,
.runtime_resume = uio_pdrv_genirq_runtime_nop,
};
#ifdef CONFIG_OF
static const struct of_device_id uio_of_genirq_match[] = {
{ .compatible = "xlnx,basic-stepper-1.3", },
{ }
};
MODULE_DEVICE_TABLE(of, uio_of_genirq_match);
#else
# define uio_of_genirq_match NULL
#endif
static struct platform_driver mk_basic_step = {
.probe = uio_pdrv_mk_basic_step_io_probe,
.remove = uio_pdrv_mk_basic_step_io_remove,
.driver = {
.name = DRIVER_NAME,
.owner = THIS_MODULE,
.pm = &uio_pdrv_genirq_dev_pm_ops,
.of_match_table = uio_of_genirq_match,
},
};
module_platform_driver(mk_basic_step);
MODULE_AUTHOR("Chris Rodriguez");
MODULE_DESCRIPTION("Stepper Userspace I/O platform driver with generic IRQ handling developed for Machinekit use");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:" DRIVER_NAME);
Nick Burkitt
On Friday, July 1, 2016 at 8:00:34 PM UTC-7, Nick Burkitt wrote: