#include <linux/module.h>
|
#include <rtdm/analogy/device.h>
|
|
#define LOOP_TASK_PERIOD 1000000
|
#define LOOP_NB_BITS 16
|
|
#define LOOP_INPUT_SUBD 0
|
#define LOOP_OUTPUT_SUBD 1
|
|
/* Channels descriptor */
|
static struct a4l_channels_desc loop_chandesc = {
|
.mode = A4L_CHAN_GLOBAL_CHANDESC,
|
.length = 8,
|
.chans = {
|
{A4L_CHAN_AREF_GROUND, LOOP_NB_BITS},
|
},
|
};
|
|
/* Ranges tab */
|
static struct a4l_rngtab loop_rngtab = {
|
.length = 2,
|
.rngs = {
|
RANGE_V(-5,5),
|
RANGE_V(-10,10),
|
},
|
};
|
/* Ranges descriptor */
|
struct a4l_rngdesc loop_rngdesc = RNG_GLOBAL(loop_rngtab);
|
|
/* Command options mask */
|
static struct a4l_cmd_desc loop_cmd_mask = {
|
.idx_subd = 0,
|
.start_src = TRIG_NOW | TRIG_INT,
|
.scan_begin_src = TRIG_TIMER,
|
.convert_src = TRIG_NOW | TRIG_TIMER,
|
.scan_end_src = TRIG_COUNT,
|
.stop_src = TRIG_COUNT| TRIG_NONE,
|
};
|
|
/* Private data organization */
|
struct loop_priv {
|
|
/* Task descriptor */
|
rtdm_task_t loop_task;
|
|
/* Misc fields */
|
int loop_running;
|
uint16_t loop_insn_value;
|
};
|
typedef struct loop_priv lpprv_t;
|
|
/* Attach arguments contents */
|
struct loop_attach_arg {
|
unsigned long period;
|
};
|
typedef struct loop_attach_arg lpattr_t;
|
|
static void loop_task_proc(void *arg);
|
|
/* --- Task part --- */
|
|
/* Timer task routine */
|
static void loop_task_proc(void *arg)
|
{
|
struct a4l_device *dev = (struct a4l_device*)arg;
|
struct a4l_subdevice *input_subd, *output_subd;
|
lpprv_t *priv = (lpprv_t *)dev->priv;
|
|
input_subd = a4l_get_subd(dev, LOOP_INPUT_SUBD);
|
output_subd = a4l_get_subd(dev, LOOP_OUTPUT_SUBD);
|
|
if (input_subd == NULL || output_subd == NULL) {
|
a4l_err(dev, "loop_task_proc: subdevices unavailable\n");
|
return;
|
}
|
|
while (1) {
|
|
int running;
|
|
running = priv->loop_running;
|
|
if (running) {
|
uint16_t value;
|
int ret=0;
|
|
while (ret==0) {
|
|
ret = a4l_buf_get(output_subd,
|
&value, sizeof(uint16_t));
|
if (ret == 0) {
|
|
a4l_info(dev,
|
"loop_task_proc: "
|
"data available\n");
|
|
a4l_buf_evt(output_subd, 0);
|
|
ret = a4l_buf_put(input_subd,
|
&value,
|
sizeof(uint16_t));
|
|
if (ret==0)
|
a4l_buf_evt(input_subd, 0);
|
}
|
}
|
}
|
|
rtdm_task_sleep(LOOP_TASK_PERIOD);
|
}
|
}
|
|
/* --- Analogy Callbacks --- */
|
|
/* Command callback */
|
int loop_cmd(struct a4l_subdevice *subd, struct a4l_cmd_desc *cmd)
|
{
|
a4l_info(subd->dev, "loop_cmd: (subd=%d)\n", subd->idx);
|
|
return 0;
|
|
}
|
|
/* Trigger callback */
|
int loop_trigger(struct a4l_subdevice *subd, lsampl_t trignum)
|
{
|
lpprv_t *priv = (lpprv_t *)subd->dev->priv;
|
|
a4l_info(subd->dev, "loop_trigger: (subd=%d)\n", subd->idx);
|
|
priv->loop_running = 1;
|
|
return 0;
|
}
|
|
/* Cancel callback */
|
void loop_cancel(struct a4l_subdevice *subd)
|
{
|
lpprv_t *priv = (lpprv_t *)subd->dev->priv;
|
|
a4l_info(subd->dev, "loop_cancel: (subd=%d)\n", subd->idx);
|
|
priv->loop_running = 0;
|
}
|
|
/* Read instruction callback */
|
int loop_insn_read(struct a4l_subdevice *subd, struct a4l_kernel_instruction *insn)
|
{
|
lpprv_t *priv = (lpprv_t*)subd->dev->priv;
|
uint16_t *data = (uint16_t *)insn->data;
|
|
/* Checks the buffer size */
|
if (insn->data_size != sizeof(uint16_t))
|
return -EINVAL;
|
|
/* Sets the memorized value */
|
data[0] = priv->loop_insn_value;
|
|
return 0;
|
}
|
|
/* Write instruction callback */
|
int loop_insn_write(struct a4l_subdevice *subd, struct a4l_kernel_instruction *insn)
|
{
|
lpprv_t *priv = (lpprv_t*)subd->dev->priv;
|
uint16_t *data = (uint16_t *)insn->data;
|
|
/* Checks the buffer size */
|
if (insn->data_size != sizeof(uint16_t))
|
return -EINVAL;
|
|
/* Retrieves the value to memorize */
|
priv->loop_insn_value = data[0];
|
|
return 0;
|
}
|
|
void setup_input_subd(struct a4l_subdevice *subd)
|
{
|
memset(subd, 0, sizeof(struct a4l_subdevice));
|
|
subd->flags |= A4L_SUBD_AI;
|
subd->flags |= A4L_SUBD_CMD;
|
subd->flags |= A4L_SUBD_MMAP;
|
subd->rng_desc = &loop_rngdesc;
|
subd->chan_desc = &loop_chandesc;
|
subd->do_cmd = loop_cmd;
|
subd->cancel = loop_cancel;
|
subd->cmd_mask = &loop_cmd_mask;
|
subd->insn_read = loop_insn_read;
|
subd->insn_write = loop_insn_write;
|
}
|
|
void setup_output_subd(struct a4l_subdevice *subd)
|
{
|
memset(subd, 0, sizeof(struct a4l_subdevice));
|
|
subd->flags = A4L_SUBD_AO;
|
subd->flags |= A4L_SUBD_CMD;
|
subd->flags |= A4L_SUBD_MMAP;
|
subd->rng_desc = &loop_rngdesc;
|
subd->chan_desc = &loop_chandesc;
|
subd->do_cmd = loop_cmd;
|
subd->cancel = loop_cancel;
|
subd->trigger = loop_trigger;
|
subd->cmd_mask = &loop_cmd_mask;
|
subd->insn_read = loop_insn_read;
|
subd->insn_write = loop_insn_write;
|
}
|
|
/* Attach callback */
|
int loop_attach(struct a4l_device *dev,
|
a4l_lnkdesc_t *arg)
|
{
|
int ret = 0;
|
struct a4l_subdevice *subd;
|
lpprv_t *priv = (lpprv_t *)dev->priv;
|
|
/* Add the fake input subdevice */
|
subd = a4l_alloc_subd(0, setup_input_subd);
|
if (subd == NULL)
|
return -ENOMEM;
|
|
ret = a4l_add_subd(dev, subd);
|
if (ret != LOOP_INPUT_SUBD)
|
/* Let Analogy free the lately allocated subdevice */
|
return (ret < 0) ? ret : -EINVAL;
|
|
/* Add the fake output subdevice */
|
subd = a4l_alloc_subd(0, setup_output_subd);
|
if (subd == NULL)
|
/* Let Analogy free the lately allocated subdevice */
|
return -ENOMEM;
|
|
ret = a4l_add_subd(dev, subd);
|
if (ret != LOOP_OUTPUT_SUBD)
|
/* Let Analogy free the lately allocated subdevices */
|
return (ret < 0) ? ret : -EINVAL;
|
|
priv->loop_running = 0;
|
priv->loop_insn_value = 0;
|
|
ret = rtmd_task_init(&priv->loop_task,
|
"a4l_loop task",
|
loop_task_proc,
|
dev, RTDM_TASK_HIGHEST_PRIORITY, 0);
|
|
return ret;
|
}
|
|
/* Detach callback */
|
int loop_detach(struct a4l_device *dev)
|
{
|
lpprv_t *priv = (lpprv_t *)dev->priv;
|
|
rtdm_task_destroy(&priv->loop_task);
|
|
return 0;
|
}
|
|
/* --- Module part --- */
|
|
static struct a4l_driver loop_drv = {
|
.owner = THIS_MODULE,
|
.board_name = "analogy_loop",
|
.attach = loop_attach,
|
.detach = loop_detach,
|
.privdata_size = sizeof(lpprv_t),
|
};
|
|
static int __init a4l_loop_init(void)
|
{
|
return a4l_register_drv(&loop_drv);
|
}
|
|
static void __exit a4l_loop_cleanup(void)
|
{
|
a4l_unregister_drv(&loop_drv);
|
}
|
|
MODULE_DESCRIPTION("Analogy loop driver");
|
MODULE_LICENSE("GPL");
|
|
module_init(a4l_loop_init);
|
module_exit(a4l_loop_cleanup);
|
