/*
|
* Analogy for Linux, command 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>
|
|
/* --- Command descriptor management functions --- */
|
int a4l_fill_cmddesc(struct a4l_device_context *cxt, struct a4l_cmd_desc *desc,
|
unsigned int **chan_descs, void *arg)
|
{
|
unsigned int *tmpchans = NULL;
|
int ret = 0;
|
|
ret = rtdm_safe_copy_from_user(rtdm_private_to_fd(cxt),
|
desc, arg, sizeof(struct a4l_cmd_desc));
|
if (ret != 0)
|
goto out_cmddesc;
|
|
|
if (desc->nb_chan == 0) {
|
ret = -EINVAL;
|
goto out_cmddesc;
|
}
|
|
tmpchans = rtdm_malloc(desc->nb_chan * sizeof(unsigned int));
|
if (tmpchans == NULL) {
|
ret = -ENOMEM;
|
goto out_cmddesc;
|
}
|
|
ret = rtdm_safe_copy_from_user(rtdm_private_to_fd(cxt),
|
tmpchans,
|
desc->chan_descs,
|
desc->nb_chan * sizeof(unsigned int));
|
if (ret != 0) {
|
__a4l_err("%s invalid arguments \n", __FUNCTION__);
|
goto out_cmddesc;
|
}
|
|
*chan_descs = desc->chan_descs;
|
desc->chan_descs = tmpchans;
|
|
__a4l_dbg(1, core_dbg, "desc dump: \n");
|
__a4l_dbg(1, core_dbg, "\t->idx_subd=%u\n", desc->idx_subd);
|
__a4l_dbg(1, core_dbg, "\t->flags=%lu\n", desc->flags);
|
__a4l_dbg(1, core_dbg, "\t->nb_chan=%u\n", desc->nb_chan);
|
__a4l_dbg(1, core_dbg, "\t->chan_descs=0x%x\n", *desc->chan_descs);
|
__a4l_dbg(1, core_dbg, "\t->data_len=%u\n", desc->data_len);
|
__a4l_dbg(1, core_dbg, "\t->pdata=0x%p\n", desc->data);
|
|
out_cmddesc:
|
|
if (ret != 0) {
|
__a4l_err("a4l_fill_cmddesc: %d \n", ret);
|
if (tmpchans != NULL)
|
rtdm_free(tmpchans);
|
desc->chan_descs = NULL;
|
}
|
|
return ret;
|
}
|
|
void a4l_free_cmddesc(struct a4l_cmd_desc * desc)
|
{
|
if (desc->chan_descs != NULL)
|
rtdm_free(desc->chan_descs);
|
}
|
|
int a4l_check_cmddesc(struct a4l_device_context * cxt, struct a4l_cmd_desc * desc)
|
{
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
struct a4l_subdevice *subd;
|
|
if (desc->idx_subd >= dev->transfer.nb_subd) {
|
__a4l_err("a4l_check_cmddesc: "
|
"subdevice index out of range (idx=%u)\n",
|
desc->idx_subd);
|
return -EINVAL;
|
}
|
|
subd = dev->transfer.subds[desc->idx_subd];
|
|
if ((subd->flags & A4L_SUBD_TYPES) == A4L_SUBD_UNUSED) {
|
__a4l_err("a4l_check_cmddesc: "
|
"subdevice type incoherent\n");
|
return -EIO;
|
}
|
|
if (!(subd->flags & A4L_SUBD_CMD)) {
|
__a4l_err("a4l_check_cmddesc: operation not supported, "
|
"synchronous only subdevice\n");
|
return -EIO;
|
}
|
|
if (test_bit(A4L_SUBD_BUSY, &subd->status)) {
|
__a4l_err("a4l_check_cmddesc: subdevice busy\n");
|
return -EBUSY;
|
}
|
|
return a4l_check_chanlist(dev->transfer.subds[desc->idx_subd],
|
desc->nb_chan, desc->chan_descs);
|
}
|
|
/* --- Command checking functions --- */
|
|
int a4l_check_generic_cmdcnt(struct a4l_cmd_desc * desc)
|
{
|
unsigned int tmp1, tmp2;
|
|
/* Makes sure trigger sources are trivially valid */
|
tmp1 =
|
desc->start_src & ~(TRIG_NOW | TRIG_INT | TRIG_EXT | TRIG_FOLLOW);
|
tmp2 = desc->start_src & (TRIG_NOW | TRIG_INT | TRIG_EXT | TRIG_FOLLOW);
|
if (tmp1 != 0 || tmp2 == 0) {
|
__a4l_err("a4l_check_cmddesc: start_src, weird trigger\n");
|
return -EINVAL;
|
}
|
|
tmp1 = desc->scan_begin_src & ~(TRIG_TIMER | TRIG_EXT | TRIG_FOLLOW);
|
tmp2 = desc->scan_begin_src & (TRIG_TIMER | TRIG_EXT | TRIG_FOLLOW);
|
if (tmp1 != 0 || tmp2 == 0) {
|
__a4l_err("a4l_check_cmddesc: scan_begin_src, , weird trigger\n");
|
return -EINVAL;
|
}
|
|
tmp1 = desc->convert_src & ~(TRIG_TIMER | TRIG_EXT | TRIG_NOW);
|
tmp2 = desc->convert_src & (TRIG_TIMER | TRIG_EXT | TRIG_NOW);
|
if (tmp1 != 0 || tmp2 == 0) {
|
__a4l_err("a4l_check_cmddesc: convert_src, weird trigger\n");
|
return -EINVAL;
|
}
|
|
tmp1 = desc->scan_end_src & ~(TRIG_COUNT);
|
if (tmp1 != 0) {
|
__a4l_err("a4l_check_cmddesc: scan_end_src, weird trigger\n");
|
return -EINVAL;
|
}
|
|
tmp1 = desc->stop_src & ~(TRIG_COUNT | TRIG_NONE);
|
tmp2 = desc->stop_src & (TRIG_COUNT | TRIG_NONE);
|
if (tmp1 != 0 || tmp2 == 0) {
|
__a4l_err("a4l_check_cmddesc: stop_src, weird trigger\n");
|
return -EINVAL;
|
}
|
|
/* Makes sure trigger sources are unique */
|
if (desc->start_src != TRIG_NOW &&
|
desc->start_src != TRIG_INT &&
|
desc->start_src != TRIG_EXT && desc->start_src != TRIG_FOLLOW) {
|
__a4l_err("a4l_check_cmddesc: start_src, "
|
"only one trigger should be set\n");
|
return -EINVAL;
|
}
|
|
if (desc->scan_begin_src != TRIG_TIMER &&
|
desc->scan_begin_src != TRIG_EXT &&
|
desc->scan_begin_src != TRIG_FOLLOW) {
|
__a4l_err("a4l_check_cmddesc: scan_begin_src, "
|
"only one trigger should be set\n");
|
return -EINVAL;
|
}
|
|
if (desc->convert_src != TRIG_TIMER &&
|
desc->convert_src != TRIG_EXT && desc->convert_src != TRIG_NOW) {
|
__a4l_err("a4l_check_cmddesc: convert_src, "
|
"only one trigger should be set\n");
|
return -EINVAL;
|
}
|
|
if (desc->stop_src != TRIG_COUNT && desc->stop_src != TRIG_NONE) {
|
__a4l_err("a4l_check_cmddesc: stop_src, "
|
"only one trigger should be set\n");
|
return -EINVAL;
|
}
|
|
/* Makes sure arguments are trivially compatible */
|
tmp1 = desc->start_src & (TRIG_NOW | TRIG_FOLLOW | TRIG_INT);
|
tmp2 = desc->start_arg;
|
if (tmp1 != 0 && tmp2 != 0) {
|
__a4l_err("a4l_check_cmddesc: no start_arg expected\n");
|
return -EINVAL;
|
}
|
|
tmp1 = desc->scan_begin_src & TRIG_FOLLOW;
|
tmp2 = desc->scan_begin_arg;
|
if (tmp1 != 0 && tmp2 != 0) {
|
__a4l_err("a4l_check_cmddesc: no scan_begin_arg expected\n");
|
return -EINVAL;
|
}
|
|
tmp1 = desc->convert_src & TRIG_NOW;
|
tmp2 = desc->convert_arg;
|
if (tmp1 != 0 && tmp2 != 0) {
|
__a4l_err("a4l_check_cmddesc: no convert_arg expected\n");
|
return -EINVAL;
|
}
|
|
tmp1 = desc->stop_src & TRIG_NONE;
|
tmp2 = desc->stop_arg;
|
if (tmp1 != 0 && tmp2 != 0) {
|
__a4l_err("a4l_check_cmddesc: no stop_arg expected\n");
|
return -EINVAL;
|
}
|
|
return 0;
|
}
|
|
int a4l_check_specific_cmdcnt(struct a4l_device_context * cxt, struct a4l_cmd_desc * desc)
|
{
|
unsigned int tmp1, tmp2;
|
struct a4l_device *dev = a4l_get_dev(cxt);
|
struct a4l_cmd_desc *cmd_mask = dev->transfer.subds[desc->idx_subd]->cmd_mask;
|
|
if (cmd_mask == NULL)
|
return 0;
|
|
if (cmd_mask->start_src != 0) {
|
tmp1 = desc->start_src & ~(cmd_mask->start_src);
|
tmp2 = desc->start_src & (cmd_mask->start_src);
|
if (tmp1 != 0 || tmp2 == 0) {
|
__a4l_err("a4l_check_cmddesc: start_src, "
|
"trigger unsupported\n");
|
return -EINVAL;
|
}
|
}
|
|
if (cmd_mask->scan_begin_src != 0) {
|
tmp1 = desc->scan_begin_src & ~(cmd_mask->scan_begin_src);
|
tmp2 = desc->scan_begin_src & (cmd_mask->scan_begin_src);
|
if (tmp1 != 0 || tmp2 == 0) {
|
__a4l_err("a4l_check_cmddesc: scan_begin_src, "
|
"trigger unsupported\n");
|
return -EINVAL;
|
}
|
}
|
|
if (cmd_mask->convert_src != 0) {
|
tmp1 = desc->convert_src & ~(cmd_mask->convert_src);
|
tmp2 = desc->convert_src & (cmd_mask->convert_src);
|
if (tmp1 != 0 || tmp2 == 0) {
|
__a4l_err("a4l_check_cmddesc: convert_src, "
|
"trigger unsupported\n");
|
return -EINVAL;
|
}
|
}
|
|
if (cmd_mask->scan_end_src != 0) {
|
tmp1 = desc->scan_end_src & ~(cmd_mask->scan_end_src);
|
if (tmp1 != 0) {
|
__a4l_err("a4l_check_cmddesc: scan_end_src, "
|
"trigger unsupported\n");
|
return -EINVAL;
|
}
|
}
|
|
if (cmd_mask->stop_src != 0) {
|
tmp1 = desc->stop_src & ~(cmd_mask->stop_src);
|
tmp2 = desc->stop_src & (cmd_mask->stop_src);
|
if (tmp1 != 0 || tmp2 == 0) {
|
__a4l_err("a4l_check_cmddesc: stop_src, "
|
"trigger unsupported\n");
|
return -EINVAL;
|
}
|
}
|
|
return 0;
|
}
|
|
/* --- IOCTL / FOPS function --- */
|
|
int a4l_ioctl_cmd(struct a4l_device_context * ctx, void *arg)
|
{
|
int ret = 0, simul_flag = 0;
|
struct a4l_cmd_desc *cmd_desc = NULL;
|
struct a4l_device *dev = a4l_get_dev(ctx);
|
unsigned int *chan_descs, *tmp;
|
struct a4l_subdevice *subd;
|
|
/* The command launching cannot be done in real-time because
|
of some possible buffer allocations in the drivers */
|
if (rtdm_in_rt_context())
|
return -ENOSYS;
|
|
/* Basically check the device */
|
if (!test_bit(A4L_DEV_ATTACHED_NR, &dev->flags)) {
|
__a4l_err("a4l_ioctl_cmd: cannot command "
|
"an unattached device\n");
|
return -EINVAL;
|
}
|
|
/* Allocates the command */
|
cmd_desc = (struct a4l_cmd_desc *) rtdm_malloc(sizeof(struct a4l_cmd_desc));
|
if (cmd_desc == NULL)
|
return -ENOMEM;
|
memset(cmd_desc, 0, sizeof(struct a4l_cmd_desc));
|
|
/* Gets the command */
|
ret = a4l_fill_cmddesc(ctx, cmd_desc, &chan_descs, arg);
|
if (ret != 0)
|
goto out_ioctl_cmd;
|
|
/* Checks the command */
|
ret = a4l_check_cmddesc(ctx, cmd_desc);
|
if (ret != 0)
|
goto out_ioctl_cmd;
|
|
ret = a4l_check_generic_cmdcnt(cmd_desc);
|
if (ret != 0)
|
goto out_ioctl_cmd;
|
|
ret = a4l_check_specific_cmdcnt(ctx, cmd_desc);
|
if (ret != 0)
|
goto out_ioctl_cmd;
|
|
__a4l_dbg(1, core_dbg,"1st cmd checks passed\n");
|
subd = dev->transfer.subds[cmd_desc->idx_subd];
|
|
/* Tests the command with the cmdtest function */
|
if (cmd_desc->flags & A4L_CMD_SIMUL) {
|
simul_flag = 1;
|
|
if (!subd->do_cmdtest) {
|
__a4l_err("a4l_ioctl_cmd: driver's cmd_test NULL\n");
|
ret = -EINVAL;
|
goto out_ioctl_cmd;
|
}
|
|
ret = subd->do_cmdtest(subd, cmd_desc);
|
if (ret != 0) {
|
__a4l_err("a4l_ioctl_cmd: driver's cmd_test failed\n");
|
goto out_ioctl_cmd;
|
}
|
__a4l_dbg(1, core_dbg, "driver's cmd checks passed\n");
|
goto out_ioctl_cmd;
|
}
|
|
|
/* Gets the transfer system ready */
|
ret = a4l_setup_buffer(ctx, cmd_desc);
|
if (ret < 0)
|
goto out_ioctl_cmd;
|
|
/* Eventually launches the command */
|
ret = subd->do_cmd(subd, cmd_desc);
|
|
if (ret != 0) {
|
a4l_cancel_buffer(ctx);
|
goto out_ioctl_cmd;
|
}
|
|
out_ioctl_cmd:
|
|
if (simul_flag) {
|
/* copy the kernel based descriptor */
|
tmp = cmd_desc->chan_descs;
|
/* return the user based descriptor */
|
cmd_desc->chan_descs = chan_descs;
|
rtdm_safe_copy_to_user(rtdm_private_to_fd(ctx), arg, cmd_desc,
|
sizeof(struct a4l_cmd_desc));
|
/* make sure we release the memory associated to the kernel */
|
cmd_desc->chan_descs = tmp;
|
|
}
|
|
if (ret != 0 || simul_flag == 1) {
|
a4l_free_cmddesc(cmd_desc);
|
rtdm_free(cmd_desc);
|
}
|
|
return ret;
|
}
|
