/*
|
* Analogy for Linux, subdevice, channel and range 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/ioport.h>
|
#include <linux/mman.h>
|
#include <asm/io.h>
|
#include <asm/errno.h>
|
#include <rtdm/analogy/device.h>
|
|
/* --- Common ranges declarations --- */
|
|
struct a4l_rngtab rng_bipolar10 = { 1, {
|
RANGE_V(-10, 10),
|
}};
|
struct a4l_rngdesc a4l_range_bipolar10 = RNG_GLOBAL(rng_bipolar10);
|
|
struct a4l_rngtab rng_bipolar5 = { 1, {
|
RANGE_V(-5, 5),
|
}};
|
struct a4l_rngdesc a4l_range_bipolar5 = RNG_GLOBAL(rng_bipolar5);
|
|
struct a4l_rngtab rng_unipolar10 = { 1, {
|
RANGE_V(0, 10),
|
}};
|
struct a4l_rngdesc a4l_range_unipolar10 = RNG_GLOBAL(rng_unipolar10);
|
|
struct a4l_rngtab rng_unipolar5 = { 1, {
|
RANGE_V(0, 5),
|
}};
|
struct a4l_rngdesc a4l_range_unipolar5 = RNG_GLOBAL(rng_unipolar5);
|
|
struct a4l_rngtab rng_unknown = { 1, {
|
RANGE(0, 1),
|
}};
|
struct a4l_rngdesc a4l_range_unknown = RNG_GLOBAL(rng_unknown);
|
|
struct a4l_rngtab rng_fake = { 0, {
|
RANGE(0, 0),
|
}};
|
struct a4l_rngdesc a4l_range_fake = RNG_GLOBAL(rng_fake);
|
|
/* --- Basic channel / range management functions --- */
|
|
struct a4l_channel *a4l_get_chfeat(struct a4l_subdevice *sb, int idx)
|
{
|
int i = (sb->chan_desc->mode != A4L_CHAN_GLOBAL_CHANDESC) ? idx : 0;
|
return &(sb->chan_desc->chans[i]);
|
}
|
|
struct a4l_range *a4l_get_rngfeat(struct a4l_subdevice *sb, int chidx, int rngidx)
|
{
|
int i = (sb->rng_desc->mode != A4L_RNG_GLOBAL_RNGDESC) ? chidx : 0;
|
return &(sb->rng_desc->rngtabs[i]->rngs[rngidx]);
|
}
|
|
int a4l_check_chanlist(struct a4l_subdevice *subd,
|
unsigned char nb_chan, unsigned int *chans)
|
{
|
int i, j;
|
|
if (nb_chan > subd->chan_desc->length)
|
return -EINVAL;
|
|
for (i = 0; i < nb_chan; i++) {
|
j = (subd->chan_desc->mode != A4L_CHAN_GLOBAL_CHANDESC) ? i : 0;
|
|
if (CR_CHAN(chans[i]) >= subd->chan_desc->length) {
|
__a4l_err("a4l_check_chanlist: "
|
"chan idx out_of range (%u>=%lu)\n",
|
CR_CHAN(chans[i]), subd->chan_desc->length);
|
return -EINVAL;
|
}
|
if (CR_AREF(chans[i]) != 0 &&
|
(CR_AREF(chans[i]) & subd->chan_desc->chans[j].flags) == 0)
|
{
|
__a4l_err("a4l_check_chanlist: "
|
"bad channel type\n");
|
return -EINVAL;
|
}
|
}
|
|
if (subd->rng_desc == NULL)
|
return 0;
|
|
for (i = 0; i < nb_chan; i++) {
|
j = (subd->rng_desc->mode != A4L_RNG_GLOBAL_RNGDESC) ? i : 0;
|
|
if (CR_RNG(chans[i]) > subd->rng_desc->rngtabs[j]->length) {
|
__a4l_err("a4l_check_chanlist: "
|
"rng idx out_of range (%u>=%u)\n",
|
CR_RNG(chans[i]),
|
subd->rng_desc->rngtabs[j]->length);
|
return -EINVAL;
|
}
|
}
|
|
return 0;
|
}
|
|
/* --- Upper layer functions --- */
|
|
struct a4l_subdevice * a4l_alloc_subd(int sizeof_priv,
|
void (*setup)(struct a4l_subdevice *))
|
{
|
struct a4l_subdevice *subd;
|
|
subd = rtdm_malloc(sizeof(struct a4l_subdevice) + sizeof_priv);
|
|
if(subd != NULL) {
|
memset(subd, 0 , sizeof(struct a4l_subdevice) + sizeof_priv);
|
if(setup != NULL)
|
setup(subd);
|
}
|
|
return subd;
|
}
|
|
int a4l_add_subd(struct a4l_device * dev, struct a4l_subdevice * subd)
|
{
|
struct list_head *this;
|
int i = 0;
|
|
/* Basic checking */
|
if (dev == NULL || subd == NULL)
|
return -EINVAL;
|
|
list_add_tail(&subd->list, &dev->subdvsq);
|
|
subd->dev = dev;
|
|
list_for_each(this, &dev->subdvsq) {
|
i++;
|
}
|
|
subd->idx = --i;
|
|
return i;
|
}
|
|
struct a4l_subdevice *a4l_get_subd(struct a4l_device *dev, int idx)
|
{
|
int i = 0;
|
struct a4l_subdevice *subd = NULL;
|
struct list_head *this;
|
|
/* This function is not optimized as we do not go through the
|
transfer structure */
|
|
list_for_each(this, &dev->subdvsq) {
|
if(idx == i++)
|
subd = list_entry(this, struct a4l_subdevice, list);
|
}
|
|
return subd;
|
}
|
|
/* --- IOCTL / FOPS functions --- */
|
|
int a4l_ioctl_subdinfo(struct a4l_device_context * cxt, void *arg)
|
{
|
struct rtdm_fd *fd = rtdm_private_to_fd(cxt);
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
int i, ret = 0;
|
a4l_sbinfo_t *subd_info;
|
|
/* Basic checking */
|
if (!test_bit(A4L_DEV_ATTACHED_NR, &dev->flags)) {
|
__a4l_err("a4l_ioctl_subdinfo: unattached device\n");
|
return -EINVAL;
|
}
|
|
subd_info = rtdm_malloc(dev->transfer.nb_subd *
|
sizeof(a4l_sbinfo_t));
|
if (subd_info == NULL)
|
return -ENOMEM;
|
|
for (i = 0; i < dev->transfer.nb_subd; i++) {
|
subd_info[i].flags = dev->transfer.subds[i]->flags;
|
subd_info[i].status = dev->transfer.subds[i]->status;
|
subd_info[i].nb_chan =
|
(dev->transfer.subds[i]->chan_desc != NULL) ?
|
dev->transfer.subds[i]->chan_desc->length : 0;
|
}
|
|
if (rtdm_safe_copy_to_user(fd,
|
arg,
|
subd_info, dev->transfer.nb_subd *
|
sizeof(a4l_sbinfo_t)) != 0)
|
ret = -EFAULT;
|
|
rtdm_free(subd_info);
|
|
return ret;
|
|
}
|
|
int a4l_ioctl_nbchaninfo(struct a4l_device_context * cxt, void *arg)
|
{
|
struct rtdm_fd *fd = rtdm_private_to_fd(cxt);
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
a4l_chinfo_arg_t inarg;
|
|
/* Basic checking */
|
if (!dev->flags & A4L_DEV_ATTACHED_NR) {
|
__a4l_err("a4l_ioctl_nbchaninfo: unattached device\n");
|
return -EINVAL;
|
}
|
|
if (rtdm_safe_copy_from_user(fd,
|
&inarg, arg,
|
sizeof(a4l_chinfo_arg_t)) != 0)
|
return -EFAULT;
|
|
if (inarg.idx_subd >= dev->transfer.nb_subd) {
|
__a4l_err("a4l_ioctl_nbchaninfo: subdevice index "
|
"out of range\n");
|
return -EINVAL;
|
}
|
|
if(dev->transfer.subds[inarg.idx_subd]->chan_desc == NULL)
|
inarg.info = (void *)0;
|
else
|
inarg.info = (void *)(unsigned long)
|
dev->transfer.subds[inarg.idx_subd]->chan_desc->length;
|
|
if (rtdm_safe_copy_to_user(fd,
|
arg,
|
&inarg, sizeof(a4l_chinfo_arg_t)) != 0)
|
return -EFAULT;
|
|
return 0;
|
}
|
|
int a4l_ioctl_chaninfo(struct a4l_device_context * cxt, void *arg)
|
{
|
struct rtdm_fd *fd = rtdm_private_to_fd(cxt);
|
int i, ret = 0;
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
a4l_chinfo_t *chan_info;
|
a4l_chinfo_arg_t inarg;
|
struct a4l_channels_desc *chan_desc;
|
struct a4l_rngdesc *rng_desc;
|
|
/* Basic checking */
|
if (!test_bit(A4L_DEV_ATTACHED_NR, &dev->flags)) {
|
__a4l_err("a4l_ioctl_chaninfo: unattached device\n");
|
return -EINVAL;
|
}
|
|
if (rtdm_safe_copy_from_user(fd,
|
&inarg, arg,
|
sizeof(a4l_chinfo_arg_t)) != 0)
|
return -EFAULT;
|
|
if (inarg.idx_subd >= dev->transfer.nb_subd) {
|
__a4l_err("a4l_ioctl_chaninfo: bad subdevice index\n");
|
return -EINVAL;
|
}
|
|
chan_desc = dev->transfer.subds[inarg.idx_subd]->chan_desc;
|
rng_desc = dev->transfer.subds[inarg.idx_subd]->rng_desc;
|
|
if (chan_desc == NULL) {
|
__a4l_err("a4l_ioctl_chaninfo: no channel descriptor "
|
"for subdevice %d\n", inarg.idx_subd);
|
return -EINVAL;
|
}
|
|
if(rng_desc == NULL)
|
rng_desc = &a4l_range_fake;
|
|
chan_info = rtdm_malloc(chan_desc->length * sizeof(a4l_chinfo_t));
|
if (chan_info == NULL)
|
return -ENOMEM;
|
|
/* If the channel descriptor is global, the fields are filled
|
with the same instance of channel descriptor */
|
for (i = 0; i < chan_desc->length; i++) {
|
int j =
|
(chan_desc->mode != A4L_CHAN_GLOBAL_CHANDESC) ? i : 0;
|
int k = (rng_desc->mode != A4L_RNG_GLOBAL_RNGDESC) ? i : 0;
|
|
chan_info[i].chan_flags = chan_desc->chans[j].flags;
|
chan_info[i].nb_bits = chan_desc->chans[j].nb_bits;
|
chan_info[i].nb_rng = rng_desc->rngtabs[k]->length;
|
|
if (chan_desc->mode == A4L_CHAN_GLOBAL_CHANDESC)
|
chan_info[i].chan_flags |= A4L_CHAN_GLOBAL;
|
}
|
|
if (rtdm_safe_copy_to_user(fd,
|
inarg.info,
|
chan_info,
|
chan_desc->length *
|
sizeof(a4l_chinfo_t)) != 0)
|
return -EFAULT;
|
|
rtdm_free(chan_info);
|
|
return ret;
|
}
|
|
int a4l_ioctl_nbrnginfo(struct a4l_device_context * cxt, void *arg)
|
{
|
int i;
|
struct rtdm_fd *fd = rtdm_private_to_fd(cxt);
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
a4l_rnginfo_arg_t inarg;
|
struct a4l_rngdesc *rng_desc;
|
|
/* Basic checking */
|
if (!test_bit(A4L_DEV_ATTACHED_NR, &dev->flags)) {
|
__a4l_err("a4l_ioctl_nbrnginfo: unattached device\n");
|
return -EINVAL;
|
}
|
|
if (rtdm_safe_copy_from_user(fd,
|
&inarg,
|
arg, sizeof(a4l_rnginfo_arg_t)) != 0)
|
return -EFAULT;
|
|
if (inarg.idx_subd >= dev->transfer.nb_subd) {
|
__a4l_err("a4l_ioctl_nbrnginfo: bad subdevice index\n");
|
return -EINVAL;
|
}
|
|
if (dev->transfer.subds[inarg.idx_subd]->chan_desc == NULL) {
|
__a4l_err("a4l_ioctl_nbrnginfo: no channel descriptor "
|
"for subdevice %d\n", inarg.idx_subd);
|
return -EINVAL;
|
}
|
|
if (inarg.idx_chan >=
|
dev->transfer.subds[inarg.idx_subd]->chan_desc->length) {
|
__a4l_err("a4l_ioctl_nbrnginfo: bad channel index\n");
|
return -EINVAL;
|
}
|
|
rng_desc = dev->transfer.subds[inarg.idx_subd]->rng_desc;
|
if (rng_desc != NULL) {
|
i = (rng_desc->mode != A4L_RNG_GLOBAL_RNGDESC) ?
|
inarg.idx_chan : 0;
|
inarg.info = (void *)(unsigned long)
|
rng_desc->rngtabs[i]->length;
|
} else
|
inarg.info = (void *)0;
|
|
|
if (rtdm_safe_copy_to_user(fd,
|
arg,
|
&inarg, sizeof(a4l_rnginfo_arg_t)) != 0)
|
return -EFAULT;
|
|
return 0;
|
}
|
|
int a4l_ioctl_rnginfo(struct a4l_device_context * cxt, void *arg)
|
{
|
struct rtdm_fd *fd = rtdm_private_to_fd(cxt);
|
int i, ret = 0;
|
unsigned int tmp;
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
struct a4l_rngdesc *rng_desc;
|
a4l_rnginfo_t *rng_info;
|
a4l_rnginfo_arg_t inarg;
|
|
/* Basic checking */
|
if (!test_bit(A4L_DEV_ATTACHED_NR, &dev->flags)) {
|
__a4l_err("a4l_ioctl_rnginfo: unattached device\n");
|
return -EINVAL;
|
}
|
|
if (rtdm_safe_copy_from_user(fd,
|
&inarg,
|
arg, sizeof(a4l_rnginfo_arg_t)) != 0)
|
return -EFAULT;
|
|
if (inarg.idx_subd >= dev->transfer.nb_subd) {
|
__a4l_err("a4l_ioctl_rnginfo: bad subdevice index\n");
|
return -EINVAL;
|
}
|
|
if (dev->transfer.subds[inarg.idx_subd]->chan_desc == NULL) {
|
__a4l_err("a4l_ioctl_rnginfo: no channel descriptor "
|
"for subdevice %d\n", inarg.idx_subd);
|
return -EINVAL;
|
}
|
|
if (inarg.idx_chan >=
|
dev->transfer.subds[inarg.idx_subd]->chan_desc->length) {
|
__a4l_err("a4l_ioctl_rnginfo: bad channel index\n");
|
return -EINVAL;
|
}
|
|
rng_desc = dev->transfer.subds[inarg.idx_subd]->rng_desc;
|
if (rng_desc == NULL) {
|
__a4l_err("a4l_ioctl_rnginfo: no range descriptor "
|
"for channel %d\n", inarg.idx_chan);
|
return -EINVAL;
|
}
|
|
/* If the range descriptor is global,
|
we take the first instance */
|
tmp = (rng_desc->mode != A4L_RNG_GLOBAL_RNGDESC) ?
|
inarg.idx_chan : 0;
|
|
rng_info = rtdm_malloc(rng_desc->rngtabs[tmp]->length *
|
sizeof(a4l_rnginfo_t));
|
if (rng_info == NULL)
|
return -ENOMEM;
|
|
for (i = 0; i < rng_desc->rngtabs[tmp]->length; i++) {
|
rng_info[i].min = rng_desc->rngtabs[tmp]->rngs[i].min;
|
rng_info[i].max = rng_desc->rngtabs[tmp]->rngs[i].max;
|
rng_info[i].flags = rng_desc->rngtabs[tmp]->rngs[i].flags;
|
|
if (rng_desc->mode == A4L_RNG_GLOBAL_RNGDESC)
|
rng_info[i].flags |= A4L_RNG_GLOBAL;
|
}
|
|
if (rtdm_safe_copy_to_user(fd,
|
inarg.info,
|
rng_info,
|
rng_desc->rngtabs[tmp]->length *
|
sizeof(a4l_rnginfo_t)) != 0)
|
return -EFAULT;
|
|
rtdm_free(rng_info);
|
|
return ret;
|
}
|
