/*
|
* Analogy for Linux, device related features
|
*
|
* Copyright (C) 1997-2000 David A. Schleef <ds@schleef.org>
|
* Copyright (C) 2008 Alexis Berlemont <alexis.berlemont@free.fr>
|
*
|
* Xenomai 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.
|
*
|
* Xenomai 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 Xenomai; if not, write to the Free Software Foundation,
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
*/
|
#include <linux/module.h>
|
#include <linux/fs.h>
|
#include <linux/proc_fs.h>
|
#include <linux/string.h>
|
#include <rtdm/analogy/device.h>
|
|
#include "proc.h"
|
|
static struct a4l_device a4l_devs[A4L_NB_DEVICES];
|
|
/* --- Device tab management functions --- */
|
|
void a4l_init_devs(void)
|
{
|
int i;
|
memset(a4l_devs, 0, A4L_NB_DEVICES * sizeof(struct a4l_device));
|
for (i = 0; i < A4L_NB_DEVICES; i++) {
|
rtdm_lock_init(&a4l_devs[i].lock);
|
a4l_devs[i].transfer.irq_desc.irq = A4L_IRQ_UNUSED;
|
}
|
}
|
|
int a4l_check_cleanup_devs(void)
|
{
|
int i, ret = 0;
|
|
for (i = 0; i < A4L_NB_DEVICES && ret == 0; i++)
|
if (test_bit(A4L_DEV_ATTACHED_NR, &a4l_devs[i].flags))
|
ret = -EBUSY;
|
|
return ret;
|
}
|
|
void a4l_set_dev(struct a4l_device_context *cxt)
|
{
|
/* Retrieve the minor index */
|
const int minor = a4l_get_minor(cxt);
|
/* Fill the dev fields accordingly */
|
cxt->dev = &(a4l_devs[minor]);
|
}
|
|
/* --- Device tab proc section --- */
|
|
#ifdef CONFIG_PROC_FS
|
|
int a4l_rdproc_devs(struct seq_file *p, void *data)
|
{
|
int i;
|
|
seq_printf(p, "-- Analogy devices --\n\n");
|
seq_printf(p, "| idx | status | driver\n");
|
|
for (i = 0; i < A4L_NB_DEVICES; i++) {
|
char *status, *name;
|
|
/* Gets the device's state */
|
if (a4l_devs[i].flags == 0) {
|
status = "Unused";
|
name = "No driver";
|
} else if (test_bit(A4L_DEV_ATTACHED_NR, &a4l_devs[i].flags)) {
|
status = "Linked";
|
name = a4l_devs[i].driver->driver_name;
|
} else {
|
status = "Broken";
|
name = "Unknown";
|
}
|
|
seq_printf(p, "| %02d | %s | %s\n", i, status, name);
|
}
|
return 0;
|
}
|
|
static int a4l_proc_transfer_open(struct inode *inode, struct file *file)
|
{
|
return single_open(file, a4l_rdproc_transfer, pde_data(inode));
|
}
|
|
static const DEFINE_PROC_OPS(a4l_proc_transfer_ops,
|
a4l_proc_transfer_open,
|
single_release,
|
seq_read,
|
NULL);
|
|
int a4l_proc_attach(struct a4l_device_context * cxt)
|
{
|
int ret = 0;
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
struct proc_dir_entry *entry;
|
char *entry_name;
|
|
/* Allocate the buffer for the file name */
|
entry_name = rtdm_malloc(A4L_NAMELEN + 4);
|
if (entry_name == NULL) {
|
__a4l_err("a4l_proc_attach: failed to allocate buffer\n");
|
return -ENOMEM;
|
}
|
|
/* Create the proc file name */
|
ksformat(entry_name, A4L_NAMELEN + 4, "%02d-%s",
|
a4l_get_minor(cxt), dev->driver->board_name);
|
|
/* Create the proc entry */
|
entry = proc_create_data(entry_name, 0444, a4l_proc_root,
|
&a4l_proc_transfer_ops, &dev->transfer);
|
if (entry == NULL) {
|
__a4l_err("a4l_proc_attach: "
|
"failed to create /proc/analogy/%s\n",
|
entry_name);
|
ret = -ENOMEM;
|
}
|
|
rtdm_free(entry_name);
|
|
return ret;
|
}
|
|
void a4l_proc_detach(struct a4l_device_context * cxt)
|
{
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
char *entry_name;
|
|
entry_name = rtdm_malloc(A4L_NAMELEN + 4);
|
if (entry_name == NULL) {
|
__a4l_err("a4l_proc_detach: "
|
"failed to allocate filename buffer\n");
|
return;
|
}
|
|
ksformat(entry_name, A4L_NAMELEN + 4, "%02d-%s",
|
a4l_get_minor(cxt), dev->driver->board_name);
|
|
remove_proc_entry(entry_name, a4l_proc_root);
|
|
rtdm_free(entry_name);
|
}
|
|
#else /* !CONFIG_PROC_FS */
|
|
int a4l_proc_attach(struct a4l_device_context * cxt)
|
{
|
return 0;
|
}
|
|
void a4l_proc_detach(struct a4l_device_context * cxt)
|
{
|
}
|
|
#endif /* CONFIG_PROC_FS */
|
|
/* --- Attach / detach section --- */
|
|
int a4l_fill_lnkdesc(struct a4l_device_context * cxt,
|
a4l_lnkdesc_t * link_arg, void *arg)
|
{
|
struct rtdm_fd *fd = rtdm_private_to_fd(cxt);
|
int ret;
|
char *tmpname = NULL;
|
void *tmpopts = NULL;
|
|
ret = rtdm_safe_copy_from_user(fd,
|
link_arg, arg, sizeof(a4l_lnkdesc_t));
|
if (ret != 0) {
|
__a4l_err("a4l_fill_lnkdesc: "
|
"call1(copy_from_user) failed\n");
|
goto out_get_lnkdesc;
|
}
|
|
if (link_arg->bname_size != 0 && link_arg->bname != NULL) {
|
tmpname = rtdm_malloc(link_arg->bname_size + 1);
|
if (tmpname == NULL) {
|
__a4l_err("a4l_fill_lnkdesc: "
|
"call1(alloc) failed\n");
|
ret = -ENOMEM;
|
goto out_get_lnkdesc;
|
}
|
tmpname[link_arg->bname_size] = 0;
|
|
ret = rtdm_safe_copy_from_user(fd,
|
tmpname,
|
link_arg->bname,
|
link_arg->bname_size);
|
if (ret != 0) {
|
__a4l_err("a4l_fill_lnkdesc: "
|
"call2(copy_from_user) failed\n");
|
goto out_get_lnkdesc;
|
}
|
} else {
|
__a4l_err("a4l_fill_lnkdesc: board name missing\n");
|
ret = -EINVAL;
|
goto out_get_lnkdesc;
|
}
|
|
if (link_arg->opts_size != 0 && link_arg->opts != NULL) {
|
tmpopts = rtdm_malloc(link_arg->opts_size);
|
|
if (tmpopts == NULL) {
|
__a4l_err("a4l_fill_lnkdesc: "
|
"call2(alloc) failed\n");
|
ret = -ENOMEM;
|
goto out_get_lnkdesc;
|
}
|
|
ret = rtdm_safe_copy_from_user(fd,
|
tmpopts,
|
link_arg->opts,
|
link_arg->opts_size);
|
if (ret != 0) {
|
__a4l_err("a4l_fill_lnkdesc: "
|
"call3(copy_from_user) failed\n");
|
goto out_get_lnkdesc;
|
}
|
}
|
|
link_arg->bname = tmpname;
|
link_arg->opts = tmpopts;
|
|
out_get_lnkdesc:
|
|
if (tmpname == NULL) {
|
link_arg->bname = NULL;
|
link_arg->bname_size = 0;
|
}
|
|
if (tmpopts == NULL) {
|
link_arg->opts = NULL;
|
link_arg->opts_size = 0;
|
}
|
|
return ret;
|
}
|
|
void a4l_free_lnkdesc(struct a4l_device_context * cxt, a4l_lnkdesc_t * link_arg)
|
{
|
if (link_arg->bname != NULL)
|
rtdm_free(link_arg->bname);
|
|
if (link_arg->opts != NULL)
|
rtdm_free(link_arg->opts);
|
}
|
|
int a4l_assign_driver(struct a4l_device_context * cxt,
|
struct a4l_driver * drv, a4l_lnkdesc_t * link_arg)
|
{
|
int ret = 0;
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
|
dev->driver = drv;
|
INIT_LIST_HEAD(&dev->subdvsq);
|
|
if (drv->privdata_size == 0)
|
__a4l_dbg(1, core_dbg, " warning! "
|
"the field priv will not be usable\n");
|
else {
|
dev->priv = rtdm_malloc(drv->privdata_size);
|
if (dev->priv == NULL) {
|
__a4l_err("a4l_assign_driver: "
|
"call(alloc) failed\n");
|
ret = -ENOMEM;
|
goto out_assign_driver;
|
}
|
|
/* Initialize the private data even if it not our role
|
(the driver should do it), that may prevent hard to
|
find bugs */
|
memset(dev->priv, 0, drv->privdata_size);
|
}
|
|
if ((ret = drv->attach(dev, link_arg)) != 0)
|
__a4l_err("a4l_assign_driver: "
|
"call(drv->attach) failed (ret=%d)\n",
|
ret);
|
|
out_assign_driver:
|
|
/* Increments module's count */
|
if (ret == 0 && (!try_module_get(drv->owner))) {
|
__a4l_err("a4l_assign_driver: "
|
"driver's owner field wrongly set\n");
|
ret = -ENODEV;
|
}
|
|
if (ret != 0 && dev->priv != NULL) {
|
rtdm_free(dev->priv);
|
dev->driver = NULL;
|
}
|
|
return ret;
|
}
|
|
int a4l_release_driver(struct a4l_device_context * cxt)
|
{
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
struct a4l_subdevice *subd, *tmp;
|
int ret = 0;
|
|
if ((ret = dev->driver->detach(dev)) != 0)
|
goto out_release_driver;
|
|
module_put(dev->driver->owner);
|
|
/* In case, the driver developer did not free the subdevices */
|
if (!list_empty(&dev->subdvsq))
|
list_for_each_entry_safe(subd, tmp, &dev->subdvsq, list) {
|
list_del(&subd->list);
|
rtdm_free(subd);
|
}
|
|
/* Free the private field */
|
if (dev->priv)
|
rtdm_free(dev->priv);
|
|
dev->driver = NULL;
|
|
out_release_driver:
|
return ret;
|
}
|
|
int a4l_device_attach(struct a4l_device_context * cxt, void *arg)
|
{
|
int ret = 0;
|
a4l_lnkdesc_t link_arg;
|
struct a4l_driver *drv = NULL;
|
|
if ((ret = a4l_fill_lnkdesc(cxt, &link_arg, arg)) != 0)
|
goto out_attach;
|
|
if ((ret = a4l_lct_drv(link_arg.bname, &drv)) != 0) {
|
__a4l_err("a4l_device_attach: "
|
"cannot find board name %s\n", link_arg.bname);
|
goto out_attach;
|
}
|
|
if ((ret = a4l_assign_driver(cxt, drv, &link_arg)) != 0)
|
goto out_attach;
|
|
out_attach:
|
a4l_free_lnkdesc(cxt, &link_arg);
|
return ret;
|
}
|
|
int a4l_device_detach(struct a4l_device_context * cxt)
|
{
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
|
if (dev->driver == NULL) {
|
__a4l_err("a4l_device_detach: "
|
"incoherent state, driver not reachable\n");
|
return -ENXIO;
|
}
|
|
return a4l_release_driver(cxt);
|
}
|
|
/* --- IOCTL / FOPS functions --- */
|
|
int a4l_ioctl_devcfg(struct a4l_device_context * cxt, void *arg)
|
{
|
int ret = 0;
|
|
if (rtdm_in_rt_context())
|
return -ENOSYS;
|
|
if (arg == NULL) {
|
/* Basic checking */
|
if (!test_bit(A4L_DEV_ATTACHED_NR, &(a4l_get_dev(cxt)->flags))) {
|
__a4l_err("a4l_ioctl_devcfg: "
|
"free device, no driver to detach\n");
|
return -EINVAL;
|
}
|
/* Pre-cleanup of the transfer structure, we ensure
|
that nothing is busy */
|
if ((ret = a4l_precleanup_transfer(cxt)) != 0)
|
return ret;
|
/* Remove the related proc file */
|
a4l_proc_detach(cxt);
|
/* Free the device and the driver from each other */
|
if ((ret = a4l_device_detach(cxt)) == 0)
|
clear_bit(A4L_DEV_ATTACHED_NR,
|
&(a4l_get_dev(cxt)->flags));
|
/* Free the transfer structure and its related data */
|
if ((ret = a4l_cleanup_transfer(cxt)) != 0)
|
return ret;
|
} else {
|
/* Basic checking */
|
if (test_bit
|
(A4L_DEV_ATTACHED_NR, &(a4l_get_dev(cxt)->flags))) {
|
__a4l_err("a4l_ioctl_devcfg: "
|
"linked device, cannot attach more driver\n");
|
return -EINVAL;
|
}
|
/* Pre-initialization of the transfer structure */
|
a4l_presetup_transfer(cxt);
|
/* Link the device with the driver */
|
if ((ret = a4l_device_attach(cxt, arg)) != 0)
|
return ret;
|
/* Create the transfer structure and
|
the related proc file */
|
if ((ret = a4l_setup_transfer(cxt)) != 0 ||
|
(ret = a4l_proc_attach(cxt)) != 0)
|
a4l_device_detach(cxt);
|
else
|
set_bit(A4L_DEV_ATTACHED_NR,
|
&(a4l_get_dev(cxt)->flags));
|
}
|
|
return ret;
|
}
|
|
int a4l_ioctl_devinfo(struct a4l_device_context * cxt, void *arg)
|
{
|
struct rtdm_fd *fd = rtdm_private_to_fd(cxt);
|
a4l_dvinfo_t info;
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
|
memset(&info, 0, sizeof(a4l_dvinfo_t));
|
|
if (test_bit(A4L_DEV_ATTACHED_NR, &dev->flags)) {
|
int len = (strlen(dev->driver->board_name) > A4L_NAMELEN) ?
|
A4L_NAMELEN : strlen(dev->driver->board_name);
|
|
memcpy(info.board_name, dev->driver->board_name, len);
|
|
len = (strlen(dev->driver->driver_name) > A4L_NAMELEN) ?
|
A4L_NAMELEN : strlen(dev->driver->driver_name);
|
|
memcpy(info.driver_name, dev->driver->driver_name, len);
|
|
info.nb_subd = dev->transfer.nb_subd;
|
/* TODO: for API compatibility issue, find the first
|
read subdevice and write subdevice */
|
}
|
|
if (rtdm_safe_copy_to_user(fd,
|
arg, &info, sizeof(a4l_dvinfo_t)) != 0)
|
return -EFAULT;
|
|
return 0;
|
}
|
