/**
* @file me6000_ao.c
*
* @brief ME-6000 analog output subdevice instance.
* @note Copyright (C) 2007 Meilhaus Electronic GmbH (support@meilhaus.de)
* @author Guenter Gebhardt
* @author Krzysztof Gantzke (k.gantzke@meilhaus.de)
*/
/*
* Copyright (C) 2007 Meilhaus Electronic GmbH (support@meilhaus.de)
*
* This file 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.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __KERNEL__
# define __KERNEL__
#endif
/* Includes
*/
#include <linux/version.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/workqueue.h>
#include "medefines.h"
#include "meinternal.h"
#include "meerror.h"
#include "medebug.h"
#include "meids.h"
#include "me6000_reg.h"
#include "me6000_ao_reg.h"
#include "me6000_ao.h"
/* Defines
*/
static int me6000_ao_query_range_by_min_max(me_subdevice_t *subdevice,
int unit,
int *min,
int *max, int *maxdata, int *range);
static int me6000_ao_query_number_ranges(me_subdevice_t *subdevice,
int unit, int *count);
static int me6000_ao_query_range_info(me_subdevice_t *subdevice,
int range,
int *unit,
int *min, int *max, int *maxdata);
static int me6000_ao_query_timer(me_subdevice_t *subdevice,
int timer,
int *base_frequency,
long long *min_ticks, long long *max_ticks);
static int me6000_ao_query_number_channels(me_subdevice_t *subdevice,
int *number);
static int me6000_ao_query_subdevice_type(me_subdevice_t *subdevice,
int *type, int *subtype);
static int me6000_ao_query_subdevice_caps(me_subdevice_t *subdevice,
int *caps);
static int me6000_ao_query_subdevice_caps_args(struct me_subdevice *subdevice,
int cap, int *args, int count);
/** Remove subdevice. */
static void me6000_ao_destructor(struct me_subdevice *subdevice);
/** Reset subdevice. Stop all actions. Reset registry. Disable FIFO. Set output to 0V and status to 'none'. */
static int me6000_ao_io_reset_subdevice(me_subdevice_t *subdevice,
struct file *filep, int flags);
/** Set output as single */
static int me6000_ao_io_single_config(me_subdevice_t *subdevice,
struct file *filep,
int channel,
int single_config,
int ref,
int trig_chan,
int trig_type, int trig_edge, int flags);
/** Pass to user actual value of output. */
static int me6000_ao_io_single_read(me_subdevice_t *subdevice,
struct file *filep,
int channel,
int *value, int time_out, int flags);
/** Write to output requed value. */
static int me6000_ao_io_single_write(me_subdevice_t *subdevice,
struct file *filep,
int channel,
int value, int time_out, int flags);
/** Set output as streamed device. */
static int me6000_ao_io_stream_config(me_subdevice_t *subdevice,
struct file *filep,
meIOStreamConfig_t *config_list,
int count,
meIOStreamTrigger_t *trigger,
int fifo_irq_threshold, int flags);
/** Wait for / Check empty space in buffer. */
static int me6000_ao_io_stream_new_values(me_subdevice_t *subdevice,
struct file *filep,
int time_out, int *count, int flags);
/** Start streaming. */
static int me6000_ao_io_stream_start(me_subdevice_t *subdevice,
struct file *filep,
int start_mode, int time_out, int flags);
/** Check actual state. / Wait for end. */
static int me6000_ao_io_stream_status(me_subdevice_t *subdevice,
struct file *filep,
int wait,
int *status, int *values, int flags);
/** Stop streaming. */
static int me6000_ao_io_stream_stop(me_subdevice_t *subdevice,
struct file *filep,
int stop_mode, int flags);
/** Write datas to buffor. */
static int me6000_ao_io_stream_write(me_subdevice_t *subdevice,
struct file *filep,
int write_mode,
int *values, int *count, int flags);
/** Interrupt handler. Copy from buffer to FIFO. */
static irqreturn_t me6000_ao_isr(int irq, void *dev_id);
/** Copy data from circular buffer to fifo (fast) in wraparound mode. */
inline int ao_write_data_wraparound(me6000_ao_subdevice_t *instance, int count,
int start_pos);
/** Copy data from circular buffer to fifo (fast).*/
inline int ao_write_data(me6000_ao_subdevice_t *instance, int count,
int start_pos);
/** Copy data from circular buffer to fifo (slow).*/
inline int ao_write_data_pooling(me6000_ao_subdevice_t *instance, int count,
int start_pos);
/** Copy data from user space to circular buffer. */
inline int ao_get_data_from_user(me6000_ao_subdevice_t *instance, int count,
int *user_values);
/** Stop presentation. Preserve FIFOs. */
inline int ao_stop_immediately(me6000_ao_subdevice_t *instance);
/** Function for checking timeout in non-blocking mode. */
static void me6000_ao_work_control_task(struct work_struct *work);
/* Functions
*/
static int me6000_ao_io_reset_subdevice(me_subdevice_t *subdevice,
struct file *filep, int flags)
{
me6000_ao_subdevice_t *instance;
int err = ME_ERRNO_SUCCESS;
uint32_t tmp;
uint32_t ctrl;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (flags) {
PERROR("Invalid flag specified.\n");
return ME_ERRNO_INVALID_FLAGS;
}
ME_SUBDEVICE_ENTER;
instance->status = ao_status_none;
instance->ao_control_task_flag = 0;
cancel_delayed_work(&instance->ao_control_task);
instance->timeout.delay = 0;
instance->timeout.start_time = jiffies;
//Stop state machine.
err = ao_stop_immediately(instance);
//Remove from synchronous start.
spin_lock(instance->preload_reg_lock);
tmp = inl(instance->preload_reg);
tmp &=
~((ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG) << instance->
ao_idx);
outl(tmp, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->preload_reg - instance->reg_base, tmp);
*instance->preload_flags &=
~((ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG) << instance->
ao_idx);
//Reset triggering flag
*instance->triggering_flags &= ~(0x1 << instance->ao_idx);
spin_unlock(instance->preload_reg_lock);
if (instance->fifo) {
//Set single mode, dissable FIFO, dissable external trigger, block interrupt.
ctrl = ME6000_AO_MODE_SINGLE;
//Block ISM.
ctrl |=
(ME6000_AO_CTRL_BIT_STOP |
ME6000_AO_CTRL_BIT_IMMEDIATE_STOP);
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
//Set speed
outl(ME6000_AO_MIN_CHAN_TICKS - 1, instance->timer_reg);
//Reset interrupt latch
inl(instance->irq_reset_reg);
}
instance->hardware_stop_delay = HZ / 10; //100ms
//Set output to 0V
outl(0x8000, instance->single_reg);
PDEBUG_REG("single_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->single_reg - instance->reg_base, 0x8000);
instance->circ_buf.head = 0;
instance->circ_buf.tail = 0;
instance->preloaded_count = 0;
instance->data_count = 0;
instance->single_value = 0x8000;
instance->single_value_in_fifo = 0x8000;
//Set status to signal that device is unconfigured.
instance->status = ao_status_none;
//Signal reset if user is on wait.
wake_up_interruptible_all(&instance->wait_queue);
ME_SUBDEVICE_EXIT;
return err;
}
static int me6000_ao_io_single_config(me_subdevice_t *subdevice,
struct file *filep,
int channel,
int single_config,
int ref,
int trig_chan,
int trig_type, int trig_edge, int flags)
{
me6000_ao_subdevice_t *instance;
int err = ME_ERRNO_SUCCESS;
uint32_t ctrl;
uint32_t sync;
unsigned long cpu_flags;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. ID=%d\n", instance->ao_idx);
// Checking parameters
if (flags) {
PERROR
("Invalid flag specified. Must be ME_IO_SINGLE_CONFIG_NO_FLAGS.\n");
return ME_ERRNO_INVALID_FLAGS;
}
if (instance->fifo) { //Stream hardware (with or without fifo)
if ((trig_edge == ME_TRIG_TYPE_SW)
&& (trig_edge != ME_TRIG_EDGE_NONE)) {
PERROR
("Invalid trigger edge. Software trigger has not edge.\n");
return ME_ERRNO_INVALID_TRIG_EDGE;
}
if (trig_type == ME_TRIG_TYPE_EXT_DIGITAL) {
switch (trig_edge) {
case ME_TRIG_EDGE_ANY:
case ME_TRIG_EDGE_RISING:
case ME_TRIG_EDGE_FALLING:
break;
default:
PERROR("Invalid trigger edge.\n");
return ME_ERRNO_INVALID_TRIG_EDGE;
}
}
if ((trig_type != ME_TRIG_TYPE_SW)
&& (trig_type != ME_TRIG_TYPE_EXT_DIGITAL)) {
PERROR
("Invalid trigger type. Trigger must be software or digital.\n");
return ME_ERRNO_INVALID_TRIG_TYPE;
}
} else { //Single
if (trig_edge != ME_TRIG_EDGE_NONE) {
PERROR
("Invalid trigger edge. Single output trigger hasn't own edge.\n");
return ME_ERRNO_INVALID_TRIG_EDGE;
}
if (trig_type != ME_TRIG_TYPE_SW) {
PERROR
("Invalid trigger type. Trigger must be software.\n");
return ME_ERRNO_INVALID_TRIG_TYPE;
}
}
if ((trig_chan != ME_TRIG_CHAN_DEFAULT)
&& (trig_chan != ME_TRIG_CHAN_SYNCHRONOUS)) {
PERROR("Invalid trigger channel specified.\n");
return ME_ERRNO_INVALID_TRIG_CHAN;
}
/*
if ((trig_type == ME_TRIG_TYPE_EXT_DIGITAL) && (trig_chan != ME_TRIG_CHAN_SYNCHRONOUS))
{
PERROR("Invalid trigger channel specified. Must be synchronous when digital is choose.\n");
return ME_ERRNO_INVALID_TRIG_CHAN;
}
*/
if (ref != ME_REF_AO_GROUND) {
PERROR
("Invalid reference. Analog outputs have to have got REF_AO_GROUND.\n");
return ME_ERRNO_INVALID_REF;
}
if (single_config != 0) {
PERROR
("Invalid single config specified. Only one range for anlog outputs is available.\n");
return ME_ERRNO_INVALID_SINGLE_CONFIG;
}
if (channel != 0) {
PERROR
("Invalid channel number specified. Analog output have only one channel.\n");
return ME_ERRNO_INVALID_CHANNEL;
}
ME_SUBDEVICE_ENTER;
//Subdevice running in stream mode!
if ((instance->status >= ao_status_stream_run_wait)
&& (instance->status < ao_status_stream_end)) {
PERROR("Subdevice is busy.\n");
ME_SUBDEVICE_EXIT;
return ME_ERRNO_SUBDEVICE_BUSY;
}
/// @note For single all calls (config and write) are erasing previous state!
instance->status = ao_status_none;
// Correct single mirrors
instance->single_value_in_fifo = instance->single_value;
//Stop device
err = ao_stop_immediately(instance);
if (err) {
PERROR_CRITICAL("FSM IS BUSY!\n");
ME_SUBDEVICE_EXIT;
return ME_ERRNO_SUBDEVICE_BUSY;
}
if (instance->fifo) { // Set control register.
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
// Set stop bit. Stop streaming mode (If running.).
ctrl = inl(instance->ctrl_reg);
//Reset all bits.
ctrl =
ME6000_AO_CTRL_BIT_IMMEDIATE_STOP | ME6000_AO_CTRL_BIT_STOP;
if (trig_type == ME_TRIG_TYPE_EXT_DIGITAL) {
PINFO("External digital trigger.\n");
if (trig_edge == ME_TRIG_EDGE_ANY) {
// ctrl |= ME6000_AO_CTRL_BIT_EX_TRIG_EDGE | ME6000_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH;
instance->ctrl_trg =
ME6000_AO_CTRL_BIT_EX_TRIG_EDGE |
ME6000_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH;
} else if (trig_edge == ME_TRIG_EDGE_FALLING) {
// ctrl |= ME6000_AO_CTRL_BIT_EX_TRIG_EDGE;
instance->ctrl_trg =
ME6000_AO_CTRL_BIT_EX_TRIG_EDGE;
} else if (trig_edge == ME_TRIG_EDGE_RISING) {
instance->ctrl_trg = 0x0;
}
} else if (trig_type == ME_TRIG_TYPE_SW) {
PDEBUG("SOFTWARE TRIGGER\n");
instance->ctrl_trg = 0x0;
}
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
} else {
PDEBUG("SOFTWARE TRIGGER\n");
}
// Set preload/synchronization register.
spin_lock(instance->preload_reg_lock);
if (trig_type == ME_TRIG_TYPE_SW) {
*instance->preload_flags &=
~(ME6000_AO_SYNC_EXT_TRIG << instance->ao_idx);
} else //if (trig_type == ME_TRIG_TYPE_EXT_DIGITAL)
{
*instance->preload_flags |=
ME6000_AO_SYNC_EXT_TRIG << instance->ao_idx;
}
if (trig_chan == ME_TRIG_CHAN_DEFAULT) {
*instance->preload_flags &=
~(ME6000_AO_SYNC_HOLD << instance->ao_idx);
} else //if (trig_chan == ME_TRIG_CHAN_SYNCHRONOUS)
{
*instance->preload_flags |=
ME6000_AO_SYNC_HOLD << instance->ao_idx;
}
//Reset hardware register
sync = inl(instance->preload_reg);
PDEBUG_REG("preload_reg inl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->preload_reg - instance->reg_base, sync);
sync &= ~(ME6000_AO_SYNC_EXT_TRIG << instance->ao_idx);
sync |= ME6000_AO_SYNC_HOLD << instance->ao_idx;
//Output configured in default mode (safe one)
outl(sync, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->preload_reg - instance->reg_base, sync);
spin_unlock(instance->preload_reg_lock);
instance->status = ao_status_single_configured;
ME_SUBDEVICE_EXIT;
return err;
}
static int me6000_ao_io_single_read(me_subdevice_t *subdevice,
struct file *filep,
int channel,
int *value, int time_out, int flags)
{
me6000_ao_subdevice_t *instance;
int err = ME_ERRNO_SUCCESS;
unsigned long j;
unsigned long delay = 0;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (flags & ~ME_IO_SINGLE_NONBLOCKING) {
PERROR("Invalid flag specified. %d\n", flags);
return ME_ERRNO_INVALID_FLAGS;
}
if ((instance->status >= ao_status_stream_configured)
&& (instance->status <= ao_status_stream_end)) {
PERROR("Subdevice not configured to work in single mode!\n");
return ME_ERRNO_PREVIOUS_CONFIG;
}
if (channel != 0) {
PERROR("Invalid channel number specified.\n");
return ME_ERRNO_INVALID_CHANNEL;
}
if (time_out < 0) {
PERROR("Invalid timeout specified.\n");
return ME_ERRNO_INVALID_TIMEOUT;
}
ME_SUBDEVICE_ENTER;
if ((!flags) && (instance->status == ao_status_single_run_wait)) { //Blocking mode. Wait for trigger.
if (time_out) {
delay = (time_out * HZ) / 1000;
if (delay == 0)
delay = 1;
}
j = jiffies;
//Only runing process will interrupt this call. Events are signaled when status change. This procedure has own timeout.
wait_event_interruptible_timeout(instance->wait_queue,
(instance->status !=
ao_status_single_run_wait),
(delay) ? delay : LONG_MAX);
if (instance->status == ao_status_none) {
PDEBUG("Single canceled.\n");
err = ME_ERRNO_CANCELLED;
}
if (signal_pending(current)) {
PERROR("Wait on start of state machine interrupted.\n");
instance->status = ao_status_none;
ao_stop_immediately(instance);
err = ME_ERRNO_SIGNAL;
}
if ((delay) && ((jiffies - j) >= delay)) {
PDEBUG("Timeout reached.\n");
err = ME_ERRNO_TIMEOUT;
}
*value =
(!err) ? instance->single_value_in_fifo : instance->
single_value;
} else { //Non-blocking mode
//Read value
*value = instance->single_value;
}
ME_SUBDEVICE_EXIT;
return err;
}
static int me6000_ao_io_single_write(me_subdevice_t *subdevice,
struct file *filep,
int channel,
int value, int time_out, int flags)
{
me6000_ao_subdevice_t *instance;
int err = ME_ERRNO_SUCCESS;
unsigned long cpu_flags;
unsigned long j;
unsigned long delay = 0;
uint32_t sync_mask;
uint32_t mode;
uint32_t tmp;
/// Workaround for mix-mode - begin
uint32_t ctrl = 0x0;
uint32_t status;
/// Workaround for mix-mode - end
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (flags &
~(ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS |
ME_IO_SINGLE_TYPE_WRITE_NONBLOCKING)) {
PERROR("Invalid flag specified.\n");
return ME_ERRNO_INVALID_FLAGS;
}
if ((instance->status == ao_status_none)
|| (instance->status > ao_status_single_end)) {
PERROR("Subdevice not configured to work in single mode!\n");
return ME_ERRNO_PREVIOUS_CONFIG;
}
if (channel != 0) {
PERROR("Invalid channel number specified.\n");
return ME_ERRNO_INVALID_CHANNEL;
}
if (value & ~ME6000_AO_MAX_DATA) {
PERROR("Invalid value provided.\n");
return ME_ERRNO_VALUE_OUT_OF_RANGE;
}
if (time_out < 0) {
PERROR("Invalid timeout specified.\n");
return ME_ERRNO_INVALID_TIMEOUT;
}
ME_SUBDEVICE_ENTER;
/// @note For single all calls (config and write) are erasing previous state!
//Cancel control task
PDEBUG("Cancel control task. idx=%d\n", instance->ao_idx);
instance->ao_control_task_flag = 0;
cancel_delayed_work(&instance->ao_control_task);
// Correct single mirrors
instance->single_value_in_fifo = instance->single_value;
//Stop device
err = ao_stop_immediately(instance);
if (err) {
PERROR_CRITICAL("FSM IS BUSY!\n");
ME_SUBDEVICE_EXIT;
return ME_ERRNO_SUBDEVICE_BUSY;
}
if (time_out) {
delay = (time_out * HZ) / 1000;
if (delay == 0)
delay = 1;
}
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
instance->single_value_in_fifo = value;
if (instance->fifo) {
ctrl = inl(instance->ctrl_reg);
}
if (instance->fifo & ME6000_AO_HAS_FIFO) { /// Workaround for mix-mode - begin
//Set speed
outl(ME6000_AO_MIN_CHAN_TICKS - 1, instance->timer_reg);
PDEBUG_REG("timer_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->timer_reg - instance->reg_base,
(int)ME6000_AO_MIN_CHAN_TICKS);
instance->hardware_stop_delay = HZ / 10; //100ms
status = inl(instance->status_reg);
//Set the continous mode.
ctrl &= ~ME6000_AO_CTRL_MODE_MASK;
ctrl |= ME6000_AO_MODE_CONTINUOUS;
//Prepare FIFO
if (!(ctrl & ME6000_AO_CTRL_BIT_ENABLE_FIFO)) { //FIFO wasn't enabeled. Do it.
PINFO("Enableing FIFO.\n");
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_IRQ;
ctrl |= ME6000_AO_CTRL_BIT_ENABLE_FIFO;
} else { //Check if FIFO is empty
if (status & ME6000_AO_STATUS_BIT_EF) { //FIFO not empty
PINFO("Reseting FIFO.\n");
ctrl &=
~(ME6000_AO_CTRL_BIT_ENABLE_FIFO |
ME6000_AO_CTRL_BIT_ENABLE_IRQ);
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg -
instance->reg_base, ctrl);
ctrl |= ME6000_AO_CTRL_BIT_ENABLE_FIFO;
} else { //FIFO empty, only interrupt needs to be disabled!
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_IRQ;
}
}
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
//Reset interrupt latch
inl(instance->irq_reset_reg);
//Write output - 1 value to FIFO
if (instance->ao_idx & 0x1) {
outl(value <<= 16, instance->fifo_reg);
PDEBUG_REG("fifo_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->fifo_reg - instance->reg_base,
value <<= 16);
} else {
outl(value, instance->fifo_reg);
PDEBUG_REG("fifo_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->fifo_reg - instance->reg_base,
value);
}
/// Workaround for mix-mode - end
} else { //No FIFO - always in single mode
//Write value
PDEBUG("Write value\n");
outl(value, instance->single_reg);
PDEBUG_REG("single_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->single_reg - instance->reg_base, value);
}
mode = *instance->preload_flags >> instance->ao_idx;
mode &= (ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG);
PINFO("Triggering mode: 0x%08x\n", mode);
spin_lock(instance->preload_reg_lock);
sync_mask = inl(instance->preload_reg);
PDEBUG_REG("preload_reg inl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->preload_reg - instance->reg_base, sync_mask);
switch (mode) {
case 0: //0x00000000: Individual software
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_EX_TRIG;
if (instance->fifo & ME6000_AO_HAS_FIFO) { // FIFO - Continous mode
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_EX_TRIG;
if ((sync_mask & ((ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG) << instance->ao_idx)) != 0x0) { //Now we can set correct mode.
sync_mask &=
~((ME6000_AO_SYNC_EXT_TRIG |
ME6000_AO_SYNC_HOLD) << instance->
ao_idx);
outl(sync_mask, instance->preload_reg);
PDEBUG_REG
("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
sync_mask);
}
} else { // No FIFO - Single mode: In this case resetting 'ME6000_AO_SYNC_HOLD' will trigger output.
if ((sync_mask & ((ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG) << instance->ao_idx)) != ME6000_AO_SYNC_HOLD) { //Now we can set correct mode. This is exception. It is set to synchronous and triggered later.
sync_mask &=
~(ME6000_AO_SYNC_EXT_TRIG << instance->
ao_idx);
sync_mask |=
ME6000_AO_SYNC_HOLD << instance->ao_idx;
outl(sync_mask, instance->preload_reg);
PDEBUG_REG
("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
sync_mask);
}
}
instance->single_value = value;
break;
case ME6000_AO_SYNC_EXT_TRIG: //0x00010000: Individual hardware
PDEBUG("DIGITAL TRIGGER\n");
ctrl |= ME6000_AO_CTRL_BIT_ENABLE_EX_TRIG;
if (instance->fifo & ME6000_AO_HAS_FIFO) { // FIFO - Continous mode
if ((sync_mask & ((ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG) << instance->ao_idx)) != 0x0) { //Now we can set correct mode.
sync_mask &=
~((ME6000_AO_SYNC_EXT_TRIG |
ME6000_AO_SYNC_HOLD) << instance->
ao_idx);
outl(sync_mask, instance->preload_reg);
PDEBUG_REG
("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
sync_mask);
}
} else { // No FIFO - Single mode
if ((sync_mask &
((ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG) <<
instance->ao_idx)) != ME6000_AO_SYNC_HOLD) {
//Now we can set correct mode
sync_mask &=
~(ME6000_AO_SYNC_EXT_TRIG << instance->
ao_idx);
sync_mask |=
ME6000_AO_SYNC_HOLD << instance->ao_idx;
outl(sync_mask, instance->preload_reg);
PDEBUG_REG
("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
sync_mask);
}
}
break;
case ME6000_AO_SYNC_HOLD: //0x00000001: Synchronous software
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_EX_TRIG;
if ((sync_mask &
((ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG) <<
instance->ao_idx)) !=
(ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG)) {
//Now we can set correct mode
sync_mask |=
ME6000_AO_SYNC_EXT_TRIG << instance->ao_idx;
sync_mask |= ME6000_AO_SYNC_HOLD << instance->ao_idx;
outl(sync_mask, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
sync_mask);
}
//Set triggering flag
*instance->triggering_flags |= 0x1 << instance->ao_idx;
break;
case (ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG): //0x00010001: Synchronous hardware
PDEBUG("DIGITAL TRIGGER\n");
ctrl |= ME6000_AO_CTRL_BIT_ENABLE_EX_TRIG;
if ((sync_mask &
((ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG) <<
instance->ao_idx)) !=
(ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG)) {
//Now we can set correct mode
sync_mask |=
(ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG) <<
instance->ao_idx;
outl(sync_mask, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
sync_mask);
}
//Set triggering flag
*instance->triggering_flags |= 0x1 << instance->ao_idx;
break;
}
// spin_unlock(instance->preload_reg_lock); // Moved down.
if (instance->fifo) { //Activate ISM (remove 'stop' bits)
ctrl &=
~(ME6000_AO_CTRL_BIT_EX_TRIG_EDGE |
ME6000_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH);
ctrl |= instance->ctrl_trg;
ctrl &=
~(ME6000_AO_CTRL_BIT_STOP |
ME6000_AO_CTRL_BIT_IMMEDIATE_STOP);
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
}
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
/// @note When flag 'ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS' is set than output is triggered. ALWAYS!
PINFO("<%s> start mode= 0x%08x %s\n", __func__, mode,
(flags & ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS) ? "SYNCHRONOUS" :
"");
if (instance->fifo & ME6000_AO_HAS_FIFO) { // FIFO - Continous mode
if (flags & ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS) { //Trigger outputs
//Add channel to start list
outl(sync_mask |
(ME6000_AO_SYNC_HOLD << instance->ao_idx),
instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
sync_mask | (ME6000_AO_SYNC_HOLD <<
instance->ao_idx));
//Fire
PINFO
("Fired all software synchronous outputs by software trigger.\n");
outl(0x8000, instance->single_reg);
PDEBUG_REG("single_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->single_reg - instance->reg_base,
0x8000);
//Restore save settings
outl(sync_mask, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
sync_mask);
} else if (!mode) { //Trigger outputs
/* //Remove channel from start list
outl(sync_mask & ~(ME6000_AO_SYNC_HOLD << instance->ao_idx), instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base, instance->preload_reg - instance->reg_base, sync_mask & ~(ME6000_AO_SYNC_HOLD << instance->ao_idx));
*/
//Fire
PINFO("Software trigger.\n");
outl(0x8000, instance->single_reg);
PDEBUG_REG("single_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->single_reg - instance->reg_base,
0x8000);
/* //Restore save settings
outl(sync_mask, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base, instance->preload_reg - instance->reg_base, sync_mask);
*/
}
/// @note This is mix-mode case. For now I do not have possibility to trigger first 4 channels (continous mode) and other (single) ones at once.
/// @note Because triggering is not working it can not be add to synchronous list. First 4 channels don't need this information, anyway.
*instance->triggering_flags &= 0xFFFFFFF0;
} else { // No FIFO - Single mode
if (flags & ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS) { //Fired all software synchronous outputs.
tmp = ~(*instance->preload_flags | 0xFFFF0000);
PINFO
("Fired all software synchronous outputs. mask:0x%08x\n",
tmp);
tmp |= sync_mask & 0xFFFF0000;
// Add this channel to list
tmp &= ~(ME6000_AO_SYNC_HOLD << instance->ao_idx);
//Fire
PINFO("Software trigger.\n");
outl(tmp, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
tmp);
//Restore save settings
outl(sync_mask, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
sync_mask);
//Set all as triggered.
*instance->triggering_flags = 0x0;
} else if (!mode) { // Add this channel to list
outl(sync_mask &
~(ME6000_AO_SYNC_HOLD << instance->ao_idx),
instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
sync_mask & ~(ME6000_AO_SYNC_HOLD <<
instance->ao_idx));
//Fire
PINFO("Software trigger.\n");
//Restore save settings
outl(sync_mask, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
sync_mask);
//Set all as triggered.
*instance->triggering_flags = 0x0;
}
}
spin_unlock(instance->preload_reg_lock);
instance->status = ao_status_single_run_wait;
instance->timeout.delay = delay;
instance->timeout.start_time = jiffies;
instance->ao_control_task_flag = 1;
queue_delayed_work(instance->me6000_workqueue,
&instance->ao_control_task, 1);
if (!(flags & ME_IO_SINGLE_TYPE_WRITE_NONBLOCKING)) {
j = jiffies;
//Only runing process will interrupt this call. Events are signaled when status change. Extra timeout add for safe reason.
wait_event_interruptible_timeout(instance->wait_queue,
(instance->status !=
ao_status_single_run_wait),
(delay) ? delay +
1 : LONG_MAX);
if (instance->status != ao_status_single_end) {
PDEBUG("Single canceled.\n");
err = ME_ERRNO_CANCELLED;
}
if (signal_pending(current)) {
PERROR("Wait on start of state machine interrupted.\n");
instance->ao_control_task_flag = 0;
cancel_delayed_work(&instance->ao_control_task);
ao_stop_immediately(instance);
instance->status = ao_status_none;
err = ME_ERRNO_SIGNAL;
}
if ((delay) && ((jiffies - j) >= delay)) {
if (instance->status == ao_status_single_end) {
PDEBUG("Timeout reached.\n");
} else if ((jiffies - j) > delay) {
PERROR
("Timeout reached. Not handled by control task!\n");
ao_stop_immediately(instance);
} else {
PERROR
("Timeout reached. Signal come but status is strange: %d\n",
instance->status);
ao_stop_immediately(instance);
}
instance->ao_control_task_flag = 0;
cancel_delayed_work(&instance->ao_control_task);
instance->status = ao_status_single_end;
err = ME_ERRNO_TIMEOUT;
}
}
ME_SUBDEVICE_EXIT;
return err;
}
static int me6000_ao_io_stream_config(me_subdevice_t *subdevice,
struct file *filep,
meIOStreamConfig_t *config_list,
int count,
meIOStreamTrigger_t *trigger,
int fifo_irq_threshold, int flags)
{
me6000_ao_subdevice_t *instance;
int err = ME_ERRNO_SUCCESS;
uint32_t ctrl;
unsigned long cpu_flags;
uint64_t conv_ticks;
unsigned int conv_start_ticks_low = trigger->iConvStartTicksLow;
unsigned int conv_start_ticks_high = trigger->iConvStartTicksHigh;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (!(instance->fifo & ME6000_AO_HAS_FIFO)) {
PERROR("Not a streaming ao.\n");
return ME_ERRNO_NOT_SUPPORTED;
}
conv_ticks =
(uint64_t) conv_start_ticks_low +
((uint64_t) conv_start_ticks_high << 32);
if (flags &
~(ME_IO_STREAM_CONFIG_HARDWARE_ONLY |
ME_IO_STREAM_CONFIG_WRAPAROUND)) {
PERROR("Invalid flags.\n");
return ME_ERRNO_INVALID_FLAGS;
}
if (flags & ME_IO_STREAM_CONFIG_HARDWARE_ONLY) {
if (!(flags & ME_IO_STREAM_CONFIG_WRAPAROUND)) {
PERROR
("Hardware ME_IO_STREAM_CONFIG_HARDWARE_ONLY has to be with ME_IO_STREAM_CONFIG_WRAPAROUND.\n");
return ME_ERRNO_INVALID_FLAGS;
}
if ((trigger->iAcqStopTrigType != ME_TRIG_TYPE_NONE)
|| (trigger->iScanStopTrigType != ME_TRIG_TYPE_NONE)) {
PERROR
("Hardware wraparound mode must be in infinite mode.\n");
return ME_ERRNO_INVALID_FLAGS;
}
}
if (count != 1) {
PERROR("Only 1 entry in config list acceptable.\n");
return ME_ERRNO_INVALID_CONFIG_LIST_COUNT;
}
if (config_list[0].iChannel != 0) {
PERROR("Invalid channel number specified.\n");
return ME_ERRNO_INVALID_CHANNEL;
}
if (config_list[0].iStreamConfig != 0) {
PERROR("Only one range available.\n");
return ME_ERRNO_INVALID_STREAM_CONFIG;
}
if (config_list[0].iRef != ME_REF_AO_GROUND) {
PERROR("Output is referenced to ground.\n");
return ME_ERRNO_INVALID_REF;
}
if ((trigger->iAcqStartTicksLow != 0)
|| (trigger->iAcqStartTicksHigh != 0)) {
PERROR
("Invalid acquisition start trigger argument specified.\n");
return ME_ERRNO_INVALID_ACQ_START_ARG;
}
if (config_list[0].iFlags) {
PERROR("Invalid config list flag.\n");
return ME_ERRNO_INVALID_FLAGS;
}
if ((trigger->iAcqStartTrigType != ME_TRIG_TYPE_SW)
&& (trigger->iAcqStartTrigType != ME_TRIG_TYPE_EXT_DIGITAL)) {
PERROR("Invalid acquisition start trigger type specified.\n");
return ME_ERRNO_INVALID_ACQ_START_TRIG_TYPE;
}
if (trigger->iAcqStartTrigType == ME_TRIG_TYPE_EXT_DIGITAL) {
switch (trigger->iAcqStartTrigEdge) {
case ME_TRIG_EDGE_RISING:
case ME_TRIG_EDGE_FALLING:
case ME_TRIG_EDGE_ANY:
break;
default:
PERROR
("Invalid acquisition start trigger edge specified.\n");
return ME_ERRNO_INVALID_ACQ_START_TRIG_EDGE;
}
}
if ((trigger->iAcqStartTrigType == ME_TRIG_TYPE_SW)
&& (trigger->iAcqStartTrigEdge != ME_TRIG_TYPE_NONE)) {
PERROR("Invalid acquisition start trigger edge specified.\n");
return ME_ERRNO_INVALID_ACQ_START_TRIG_EDGE;
}
if (trigger->iScanStartTrigType != ME_TRIG_TYPE_FOLLOW) {
PERROR("Invalid scan start trigger type specified.\n");
return ME_ERRNO_INVALID_SCAN_START_TRIG_TYPE;
}
if (trigger->iConvStartTrigType != ME_TRIG_TYPE_TIMER) {
PERROR("Invalid conv start trigger type specified.\n");
return ME_ERRNO_INVALID_CONV_START_TRIG_TYPE;
}
if ((conv_ticks < ME6000_AO_MIN_CHAN_TICKS)
|| (conv_ticks > ME6000_AO_MAX_CHAN_TICKS)) {
PERROR("Invalid conv start trigger argument specified.\n");
return ME_ERRNO_INVALID_CONV_START_ARG;
}
if (trigger->iAcqStartTicksLow || trigger->iAcqStartTicksHigh) {
PERROR("Invalid acq start trigger argument specified.\n");
return ME_ERRNO_INVALID_ACQ_START_ARG;
}
if (trigger->iScanStartTicksLow || trigger->iScanStartTicksHigh) {
PERROR("Invalid scan start trigger argument specified.\n");
return ME_ERRNO_INVALID_SCAN_START_ARG;
}
switch (trigger->iScanStopTrigType) {
case ME_TRIG_TYPE_NONE:
if (trigger->iScanStopCount != 0) {
PERROR("Invalid scan stop count specified.\n");
return ME_ERRNO_INVALID_SCAN_STOP_ARG;
}
break;
case ME_TRIG_TYPE_COUNT:
if (flags & ME_IO_STREAM_CONFIG_WRAPAROUND) {
if (trigger->iScanStopCount <= 0) {
PERROR("Invalid scan stop count specified.\n");
return ME_ERRNO_INVALID_SCAN_STOP_ARG;
}
} else {
PERROR("The continous mode has not 'scan' contects.\n");
return ME_ERRNO_INVALID_ACQ_STOP_TRIG_TYPE;
}
break;
default:
PERROR("Invalid scan stop trigger type specified.\n");
return ME_ERRNO_INVALID_SCAN_STOP_TRIG_TYPE;
}
switch (trigger->iAcqStopTrigType) {
case ME_TRIG_TYPE_NONE:
if (trigger->iAcqStopCount != 0) {
PERROR("Invalid acq stop count specified.\n");
return ME_ERRNO_INVALID_ACQ_STOP_ARG;
}
break;
case ME_TRIG_TYPE_COUNT:
if (trigger->iScanStopTrigType != ME_TRIG_TYPE_NONE) {
PERROR("Invalid acq stop trigger type specified.\n");
return ME_ERRNO_INVALID_ACQ_STOP_TRIG_TYPE;
}
if (flags & ME_IO_STREAM_CONFIG_WRAPAROUND) {
if (trigger->iAcqStopCount <= 0) {
PERROR
("The continous mode has not 'scan' contects.\n");
return ME_ERRNO_INVALID_ACQ_STOP_ARG;
}
}
// else
// {
// PERROR("Invalid acq stop trigger type specified.\n");
// return ME_ERRNO_INVALID_ACQ_STOP_TRIG_TYPE;
// }
break;
default:
PERROR("Invalid acq stop trigger type specified.\n");
return ME_ERRNO_INVALID_ACQ_STOP_TRIG_TYPE;
}
switch (trigger->iAcqStartTrigChan) {
case ME_TRIG_CHAN_DEFAULT:
case ME_TRIG_CHAN_SYNCHRONOUS:
break;
default:
PERROR("Invalid acq start trigger channel specified.\n");
return ME_ERRNO_INVALID_ACQ_START_TRIG_CHAN;
}
ME_SUBDEVICE_ENTER;
//Stop device
//Cancel control task
PDEBUG("Cancel control task. idx=%d\n", instance->ao_idx);
instance->ao_control_task_flag = 0;
cancel_delayed_work(&instance->ao_control_task);
//Check if state machine is stopped.
err = ao_stop_immediately(instance);
if (err) {
PERROR_CRITICAL("FSM IS BUSY!\n");
ME_SUBDEVICE_EXIT;
return ME_ERRNO_SUBDEVICE_BUSY;
}
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
//Reset control register. Block all actions. Disable IRQ. Disable FIFO.
ctrl = ME6000_AO_CTRL_BIT_IMMEDIATE_STOP | ME6000_AO_CTRL_BIT_STOP;
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
//Reset interrupt latch
inl(instance->irq_reset_reg);
//This is paranoic, but to be sure.
instance->preloaded_count = 0;
instance->data_count = 0;
instance->circ_buf.head = 0;
instance->circ_buf.tail = 0;
/* Set mode. */
if (flags & ME_IO_STREAM_CONFIG_WRAPAROUND) { //Wraparound
if (flags & ME_IO_STREAM_CONFIG_HARDWARE_ONLY) { //Hardware wraparound
PINFO("Hardware wraparound.\n");
ctrl |= ME6000_AO_MODE_WRAPAROUND;
instance->mode = ME6000_AO_HW_WRAP_MODE;
} else { //Software wraparound
PINFO("Software wraparound.\n");
ctrl |= ME6000_AO_MODE_CONTINUOUS;
instance->mode = ME6000_AO_SW_WRAP_MODE;
}
} else { //Continous
PINFO("Continous.\n");
ctrl |= ME6000_AO_MODE_CONTINUOUS;
instance->mode = ME6000_AO_CONTINOUS;
}
//Set the trigger edge.
if (trigger->iAcqStartTrigType == ME_TRIG_TYPE_EXT_DIGITAL) { //Set the trigger type and edge for external trigger.
PINFO("External digital trigger.\n");
instance->start_mode = ME6000_AO_EXT_TRIG;
switch (trigger->iAcqStartTrigEdge) {
case ME_TRIG_EDGE_RISING:
PINFO("Set the trigger edge: rising.\n");
instance->ctrl_trg = 0x0;
break;
case ME_TRIG_EDGE_FALLING:
PINFO("Set the trigger edge: falling.\n");
// ctrl |= ME6000_AO_CTRL_BIT_EX_TRIG_EDGE;
instance->ctrl_trg = ME6000_AO_CTRL_BIT_EX_TRIG_EDGE;
break;
case ME_TRIG_EDGE_ANY:
PINFO("Set the trigger edge: both edges.\n");
// ctrl |= ME6000_AO_CTRL_BIT_EX_TRIG_EDGE | ME6000_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH;
instance->ctrl_trg =
ME6000_AO_CTRL_BIT_EX_TRIG_EDGE |
ME6000_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH;
break;
}
} else {
PINFO("Internal software trigger.\n");
instance->start_mode = 0;
}
//Set the stop mode and value.
if (trigger->iAcqStopTrigType == ME_TRIG_TYPE_COUNT) { //Amount of data
instance->stop_mode = ME6000_AO_ACQ_STOP_MODE;
instance->stop_count = trigger->iAcqStopCount;
} else if (trigger->iScanStopTrigType == ME_TRIG_TYPE_COUNT) { //Amount of 'scans'
instance->stop_mode = ME6000_AO_SCAN_STOP_MODE;
instance->stop_count = trigger->iScanStopCount;
} else { //Infinite
instance->stop_mode = ME6000_AO_INF_STOP_MODE;
instance->stop_count = 0;
}
PINFO("Stop count: %d.\n", instance->stop_count);
if (trigger->iAcqStartTrigChan == ME_TRIG_CHAN_SYNCHRONOUS) { //Synchronous start
instance->start_mode |= ME6000_AO_SYNC_HOLD;
if (trigger->iAcqStartTrigType == ME_TRIG_TYPE_EXT_DIGITAL) { //Externaly triggered
PINFO("Synchronous start. Externaly trigger active.\n");
instance->start_mode |= ME6000_AO_SYNC_EXT_TRIG;
}
#ifdef MEDEBUG_INFO
else {
PINFO
("Synchronous start. Externaly trigger dissabled.\n");
}
#endif
}
//Set speed
outl(conv_ticks - 2, instance->timer_reg);
PDEBUG_REG("timer_reg outl(0x%lX+0x%lX)=0x%llx\n", instance->reg_base,
instance->timer_reg - instance->reg_base, conv_ticks - 2);
instance->hardware_stop_delay = (int)(conv_ticks * HZ) / ME6000_AO_BASE_FREQUENCY; //<== MUST be with cast!
// Write the control word
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
//Set status.
instance->status = ao_status_stream_configured;
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
ME_SUBDEVICE_EXIT;
return err;
}
static int me6000_ao_io_stream_new_values(me_subdevice_t *subdevice,
struct file *filep,
int time_out, int *count, int flags)
{
me6000_ao_subdevice_t *instance;
int err = ME_ERRNO_SUCCESS;
long t = 0;
long j;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (!(instance->fifo & ME6000_AO_HAS_FIFO)) {
PERROR("Not a streaming ao.\n");
return ME_ERRNO_NOT_SUPPORTED;
}
if (flags) {
PERROR("Invalid flag specified.\n");
return ME_ERRNO_INVALID_FLAGS;
}
if (!instance->circ_buf.buf) {
PERROR("Circular buffer not exists.\n");
return ME_ERRNO_INTERNAL;
}
if (time_out < 0) {
PERROR("Invalid time_out specified.\n");
return ME_ERRNO_INVALID_TIMEOUT;
}
ME_SUBDEVICE_ENTER;
if (me_circ_buf_space(&instance->circ_buf)) { //The buffer is NOT full.
*count = me_circ_buf_space(&instance->circ_buf);
} else { //The buffer is full.
if (time_out) {
t = (time_out * HZ) / 1000;
if (t == 0)
t = 1;
} else { //Max time.
t = LONG_MAX;
}
*count = 0;
j = jiffies;
//Only runing process will interrupt this call. Interrupts are when FIFO HF is signaled.
wait_event_interruptible_timeout(instance->wait_queue,
((me_circ_buf_space
(&instance->circ_buf))
|| !(inl(instance->status_reg)
&
ME6000_AO_STATUS_BIT_FSM)),
t);
if (!(inl(instance->status_reg) & ME6000_AO_STATUS_BIT_FSM)) {
PERROR("AO subdevice is not running.\n");
err = ME_ERRNO_SUBDEVICE_NOT_RUNNING;
} else if (signal_pending(current)) {
PERROR("Wait on values interrupted from signal.\n");
instance->status = ao_status_none;
ao_stop_immediately(instance);
err = ME_ERRNO_SIGNAL;
} else if ((jiffies - j) >= t) {
PERROR("Wait on values timed out.\n");
err = ME_ERRNO_TIMEOUT;
} else { //Uff... all is good. Inform user about empty space.
*count = me_circ_buf_space(&instance->circ_buf);
}
}
ME_SUBDEVICE_EXIT;
return err;
}
static int me6000_ao_io_stream_start(me_subdevice_t *subdevice,
struct file *filep,
int start_mode, int time_out, int flags)
{
me6000_ao_subdevice_t *instance;
int err = ME_ERRNO_SUCCESS;
unsigned long cpu_flags = 0;
uint32_t status;
uint32_t ctrl;
uint32_t synch;
int count = 0;
int circ_buffer_count;
unsigned long ref;
unsigned long delay = 0;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (!(instance->fifo & ME6000_AO_HAS_FIFO)) {
PERROR("Not a streaming ao.\n");
return ME_ERRNO_NOT_SUPPORTED;
}
if (flags & ~ME_IO_STREAM_START_TYPE_TRIG_SYNCHRONOUS) {
PERROR("Invalid flags.\n");
return ME_ERRNO_INVALID_FLAGS;
}
if (time_out < 0) {
PERROR("Invalid timeout specified.\n");
return ME_ERRNO_INVALID_TIMEOUT;
}
if ((start_mode != ME_START_MODE_BLOCKING)
&& (start_mode != ME_START_MODE_NONBLOCKING)) {
PERROR("Invalid start mode specified.\n");
return ME_ERRNO_INVALID_START_MODE;
}
if (time_out) {
delay = (time_out * HZ) / 1000;
if (delay == 0)
delay = 1;
}
switch (instance->status) { //Checking actual mode.
case ao_status_stream_configured:
case ao_status_stream_end:
//Correct modes!
break;
//The device is in wrong mode.
case ao_status_none:
case ao_status_single_configured:
case ao_status_single_run_wait:
case ao_status_single_run:
case ao_status_single_end_wait:
PERROR
("Subdevice must be preinitialize correctly for streaming.\n");
return ME_ERRNO_PREVIOUS_CONFIG;
case ao_status_stream_fifo_error:
case ao_status_stream_buffer_error:
case ao_status_stream_error:
PDEBUG("Before restart broke stream 'STOP' must be caled.\n");
return ME_STATUS_ERROR;
case ao_status_stream_run_wait:
case ao_status_stream_run:
case ao_status_stream_end_wait:
PDEBUG("Stream is already working.\n");
return ME_ERRNO_SUBDEVICE_BUSY;
default:
instance->status = ao_status_stream_error;
PERROR_CRITICAL("Status is in wrong state!\n");
return ME_ERRNO_INTERNAL;
}
ME_SUBDEVICE_ENTER;
if (instance->mode == ME6000_AO_CONTINOUS) { //Continous
instance->circ_buf.tail += instance->preloaded_count;
instance->circ_buf.tail &= instance->circ_buf.mask;
}
circ_buffer_count = me_circ_buf_values(&instance->circ_buf);
if (!circ_buffer_count && !instance->preloaded_count) { //No values in buffer
ME_SUBDEVICE_EXIT;
PERROR("No values in buffer!\n");
return ME_ERRNO_LACK_OF_RESOURCES;
}
//Cancel control task
PDEBUG("Cancel control task. idx=%d\n", instance->ao_idx);
instance->ao_control_task_flag = 0;
cancel_delayed_work(&instance->ao_control_task);
//Stop device
err = ao_stop_immediately(instance);
if (err) {
PERROR_CRITICAL("FSM IS BUSY!\n");
ME_SUBDEVICE_EXIT;
return ME_ERRNO_SUBDEVICE_BUSY;
}
//Set values for single_read()
instance->single_value = ME6000_AO_MAX_DATA + 1;
instance->single_value_in_fifo = ME6000_AO_MAX_DATA + 1;
//Setting stop points
if (instance->stop_mode == ME6000_AO_SCAN_STOP_MODE) {
instance->stop_data_count =
instance->stop_count * circ_buffer_count;
} else {
instance->stop_data_count = instance->stop_count;
}
if ((instance->stop_data_count != 0)
&& (instance->stop_data_count < circ_buffer_count)) {
PERROR("More data in buffer than previously set limit!\n");
}
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
ctrl = inl(instance->ctrl_reg);
//Check FIFO
if (!(ctrl & ME6000_AO_CTRL_BIT_ENABLE_FIFO)) { //FIFO wasn't enabeled. Do it. <= This should be done by user call with ME_WRITE_MODE_PRELOAD
PINFO("Enableing FIFO.\n");
ctrl |= ME6000_AO_CTRL_BIT_ENABLE_FIFO;
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_IRQ;
instance->preloaded_count = 0;
instance->data_count = 0;
} else { //Block IRQ
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_IRQ;
}
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
//Reset interrupt latch
inl(instance->irq_reset_reg);
//Fill FIFO <= Generaly this should be done by user pre-load call but this is second place to do it.
status = inl(instance->status_reg);
if (!(status & ME6000_AO_STATUS_BIT_EF)) { //FIFO empty
if (instance->stop_data_count != 0) {
count = ME6000_AO_FIFO_COUNT;
} else {
count =
(ME6000_AO_FIFO_COUNT <
instance->
stop_data_count) ? ME6000_AO_FIFO_COUNT :
instance->stop_data_count;
}
//Copy data
count =
ao_write_data(instance, count, instance->preloaded_count);
if (count < 0) { //This should never happend!
PERROR_CRITICAL("COPY FINISH WITH ERROR!\n");
spin_unlock_irqrestore(&instance->subdevice_lock,
cpu_flags);
ME_SUBDEVICE_EXIT;
return ME_ERRNO_INTERNAL;
}
}
//Set pre-load features.
spin_lock(instance->preload_reg_lock);
synch = inl(instance->preload_reg);
synch &=
~((ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG) << instance->
ao_idx);
synch |=
(instance->start_mode & ~ME6000_AO_EXT_TRIG) << instance->ao_idx;
outl(synch, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->preload_reg - instance->reg_base, synch);
spin_unlock(instance->preload_reg_lock);
//Default count is '0'
if (instance->mode == ME6000_AO_CONTINOUS) { //Continous
instance->preloaded_count = 0;
instance->circ_buf.tail += count;
instance->circ_buf.tail &= instance->circ_buf.mask;
} else { //Wraparound
instance->preloaded_count += count;
instance->data_count += count;
//Special case: Infinite wraparound with less than FIFO datas always should runs in hardware mode.
if ((instance->stop_mode == ME6000_AO_INF_STOP_MODE)
&& (circ_buffer_count <= ME6000_AO_FIFO_COUNT)) { //Change to hardware wraparound
PDEBUG
("Changeing mode from software wraparound to hardware wraparound.\n");
//Copy all data
count =
ao_write_data(instance, circ_buffer_count,
instance->preloaded_count);
ctrl &= ~ME6000_AO_CTRL_MODE_MASK;
ctrl |= ME6000_AO_MODE_WRAPAROUND;
}
if (instance->preloaded_count == me_circ_buf_values(&instance->circ_buf)) { //Reset position indicator.
instance->preloaded_count = 0;
} else if (instance->preloaded_count > me_circ_buf_values(&instance->circ_buf)) { //This should never happend!
PERROR_CRITICAL
("PRELOADED MORE VALUES THAN ARE IN BUFFER!\n");
spin_unlock_irqrestore(&instance->subdevice_lock,
cpu_flags);
ME_SUBDEVICE_EXIT;
return ME_ERRNO_INTERNAL;
}
}
//Set status to 'wait for start'
instance->status = ao_status_stream_run_wait;
status = inl(instance->status_reg);
//Start state machine and interrupts
PINFO("<%s:%d> Start state machine.\n", __func__, __LINE__);
ctrl &= ~(ME6000_AO_CTRL_BIT_STOP | ME6000_AO_CTRL_BIT_IMMEDIATE_STOP);
if (instance->start_mode == ME6000_AO_EXT_TRIG) {
PDEBUG("DIGITAL TRIGGER\n");
ctrl |= ME6000_AO_CTRL_BIT_ENABLE_EX_TRIG;
}
if (!(status & ME6000_AO_STATUS_BIT_HF)) { //More than half!
if ((ctrl & ME6000_AO_CTRL_MODE_MASK) == ME6000_AO_MODE_CONTINUOUS) { //Enable IRQ only when hardware_continous is set and FIFO is more than half
PINFO("<%s:%d> Start interrupts.\n", __func__,
__LINE__);
ctrl |= ME6000_AO_CTRL_BIT_ENABLE_IRQ;
}
}
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
//Trigger output
PINFO("<%s> start mode= 0x%x %s\n", __func__, instance->start_mode,
(flags & ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS) ? "SYNCHRONOUS" :
"");
if (flags & ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS) { //Trigger outputs
spin_lock(instance->preload_reg_lock);
synch = inl(instance->preload_reg);
//Add channel to start list
outl(synch | (ME6000_AO_SYNC_HOLD << instance->ao_idx),
instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
synch | (ME6000_AO_SYNC_HOLD << instance->ao_idx));
//Fire
PINFO
("Fired all software synchronous outputs by software trigger.\n");
outl(0x8000, instance->single_reg);
PDEBUG_REG("single_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->single_reg - instance->reg_base, 0x8000);
//Restore save settings
outl(synch, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base, synch);
spin_unlock(instance->preload_reg_lock);
} else if (!instance->start_mode) { //Trigger outputs
/*
spin_lock(instance->preload_reg_lock);
synch = inl(instance->preload_reg);
//Remove channel from start list
outl(synch & ~(ME6000_AO_SYNC_HOLD << instance->ao_idx), instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base, instance->preload_reg - instance->reg_base, synch & ~(ME6000_AO_SYNC_HOLD << instance->ao_idx));
*/
//Fire
PINFO("Software trigger.\n");
outl(0x8000, instance->single_reg);
PDEBUG_REG("single_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->single_reg - instance->reg_base, 0x8000);
/*
//Restore save settings
outl(synch, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base, instance->preload_reg - instance->reg_base, synch);
spin_unlock(instance->preload_reg_lock);
*/
}
// Set control task's timeout
instance->timeout.delay = delay;
instance->timeout.start_time = jiffies;
if (status & ME6000_AO_STATUS_BIT_HF) { //Less than half but not empty!
PINFO("Less than half.\n");
if (instance->stop_data_count == 0) {
count = ME6000_AO_FIFO_COUNT / 2;
} else {
count =
((ME6000_AO_FIFO_COUNT / 2) <
instance->stop_data_count) ? ME6000_AO_FIFO_COUNT /
2 : instance->stop_data_count;
}
//Copy data
count =
ao_write_data(instance, count, instance->preloaded_count);
if (count < 0) { //This should never happend!
PERROR_CRITICAL("COPY FINISH WITH ERROR!\n");
ME_SUBDEVICE_EXIT;
return ME_ERRNO_INTERNAL;
}
if (instance->mode == ME6000_AO_CONTINOUS) { //Continous
instance->circ_buf.tail += count;
instance->circ_buf.tail &= instance->circ_buf.mask;
} else { //Wraparound
instance->data_count += count;
instance->preloaded_count += count;
if (instance->preloaded_count == me_circ_buf_values(&instance->circ_buf)) { //Reset position indicator.
instance->preloaded_count = 0;
} else if (instance->preloaded_count > me_circ_buf_values(&instance->circ_buf)) { //This should never happend!
PERROR_CRITICAL
("PRELOADED MORE VALUES THAN ARE IN BUFFER!\n");
ME_SUBDEVICE_EXIT;
return ME_ERRNO_INTERNAL;
}
}
status = inl(instance->status_reg);
if (!(status & ME6000_AO_STATUS_BIT_HF)) { //More than half!
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
PINFO("<%s:%d> Start interrupts.\n", __func__,
__LINE__);
ctrl = inl(instance->ctrl_reg);
ctrl |= ME6000_AO_CTRL_BIT_ENABLE_IRQ;
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base,
ctrl);
spin_unlock_irqrestore(&instance->subdevice_lock,
cpu_flags);
}
}
//Special case: Limited wraparound with less than HALF FIFO datas need work around to generate first interrupt.
if ((instance->stop_mode != ME6000_AO_INF_STOP_MODE)
&& (instance->mode == ME6000_AO_SW_WRAP_MODE)
&& (circ_buffer_count <= (ME6000_AO_FIFO_COUNT / 2))) { //Put more data to FIFO
PINFO("Limited wraparound with less than HALF FIFO datas.\n");
if (instance->preloaded_count) { //This should never happend!
PERROR_CRITICAL
("ERROR WHEN LOADING VALUES FOR WRAPAROUND!\n");
ME_SUBDEVICE_EXIT;
return ME_ERRNO_INTERNAL;
}
while (instance->stop_data_count > instance->data_count) { //Maximum data not set jet.
//Copy to buffer
if (circ_buffer_count != ao_write_data(instance, circ_buffer_count, 0)) { //This should never happend!
PERROR_CRITICAL
("ERROR WHEN LOADING VALUES FOR WRAPAROUND!\n");
ME_SUBDEVICE_EXIT;
return ME_ERRNO_INTERNAL;
}
instance->data_count += circ_buffer_count;
if (!((status = inl(instance->status_reg)) & ME6000_AO_STATUS_BIT_HF)) { //FIFO is more than half. Enable IRQ and end copy.
//Reset interrupt latch
inl(instance->irq_reset_reg);
spin_lock_irqsave(&instance->subdevice_lock,
cpu_flags);
PINFO("<%s:%d> Start interrupts.\n",
__func__, __LINE__);
ctrl = inl(instance->ctrl_reg);
ctrl |= ME6000_AO_CTRL_BIT_ENABLE_IRQ;
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg -
instance->reg_base, ctrl);
spin_unlock_irqrestore(&instance->
subdevice_lock,
cpu_flags);
break;
}
}
}
// Schedule control task
instance->ao_control_task_flag = 1;
queue_delayed_work(instance->me6000_workqueue,
&instance->ao_control_task, 1);
if (start_mode == ME_START_MODE_BLOCKING) { //Wait for start.
ref = jiffies;
//Only runing process will interrupt this call. Events are signaled when status change. Extra timeout add for safe reason.
wait_event_interruptible_timeout(instance->wait_queue,
(instance->status !=
ao_status_stream_run_wait),
(delay) ? delay +
1 : LONG_MAX);
if ((instance->status != ao_status_stream_run)
&& (instance->status != ao_status_stream_end)) {
PDEBUG("Starting stream canceled. %d\n",
instance->status);
err = ME_ERRNO_CANCELLED;
}
if (signal_pending(current)) {
PERROR("Wait on start of state machine interrupted.\n");
instance->status = ao_status_none;
ao_stop_immediately(instance);
err = ME_ERRNO_SIGNAL;
}
if ((delay) && ((jiffies - ref) >= delay)) {
if (instance->status != ao_status_stream_run) {
if (instance->status == ao_status_stream_end) {
PDEBUG("Timeout reached.\n");
} else if ((jiffies - ref) > delay) {
PERROR
("Timeout reached. Not handled by control task!\n");
ao_stop_immediately(instance);
} else {
PERROR
("Timeout reached. Signal come but status is strange: %d\n",
instance->status);
ao_stop_immediately(instance);
}
instance->ao_control_task_flag = 0;
cancel_delayed_work(&instance->ao_control_task);
instance->status = ao_status_stream_end;
err = ME_ERRNO_TIMEOUT;
}
}
}
ME_SUBDEVICE_EXIT;
return err;
}
static int me6000_ao_io_stream_status(me_subdevice_t *subdevice,
struct file *filep,
int wait,
int *status, int *values, int flags)
{
me6000_ao_subdevice_t *instance;
int err = ME_ERRNO_SUCCESS;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (!(instance->fifo & ME6000_AO_HAS_FIFO)) {
PERROR("Not a streaming ao.\n");
return ME_ERRNO_NOT_SUPPORTED;
}
if (flags) {
PERROR("Invalid flag specified.\n");
return ME_ERRNO_INVALID_FLAGS;
}
if ((wait != ME_WAIT_NONE) && (wait != ME_WAIT_IDLE)) {
PERROR("Invalid wait argument specified.\n");
*status = ME_STATUS_INVALID;
return ME_ERRNO_INVALID_WAIT;
}
ME_SUBDEVICE_ENTER;
switch (instance->status) {
case ao_status_single_configured:
case ao_status_single_end:
case ao_status_stream_configured:
case ao_status_stream_end:
case ao_status_stream_fifo_error:
case ao_status_stream_buffer_error:
case ao_status_stream_error:
*status = ME_STATUS_IDLE;
break;
case ao_status_single_run_wait:
case ao_status_single_run:
case ao_status_single_end_wait:
case ao_status_stream_run_wait:
case ao_status_stream_run:
case ao_status_stream_end_wait:
*status = ME_STATUS_BUSY;
break;
case ao_status_none:
default:
*status =
(inl(instance->status_reg) & ME6000_AO_STATUS_BIT_FSM) ?
ME_STATUS_BUSY : ME_STATUS_IDLE;
break;
}
if ((wait == ME_WAIT_IDLE) && (*status == ME_STATUS_BUSY)) {
//Only runing process will interrupt this call. Events are signaled when status change. Extra timeout add for safe reason.
wait_event_interruptible_timeout(instance->wait_queue,
((instance->status !=
ao_status_single_run_wait)
&& (instance->status !=
ao_status_single_run)
&& (instance->status !=
ao_status_single_end_wait)
&& (instance->status !=
ao_status_stream_run_wait)
&& (instance->status !=
ao_status_stream_run)
&& (instance->status !=
ao_status_stream_end_wait)),
LONG_MAX);
if (instance->status != ao_status_stream_end) {
PDEBUG("Wait for IDLE canceled. %d\n",
instance->status);
err = ME_ERRNO_CANCELLED;
}
if (signal_pending(current)) {
PERROR("Wait for IDLE interrupted.\n");
instance->status = ao_status_none;
ao_stop_immediately(instance);
err = ME_ERRNO_SIGNAL;
}
*status = ME_STATUS_IDLE;
}
*values = me_circ_buf_space(&instance->circ_buf);
ME_SUBDEVICE_EXIT;
return err;
}
static int me6000_ao_io_stream_stop(me_subdevice_t *subdevice,
struct file *filep,
int stop_mode, int flags)
{ /// @note Stop work and empty buffer and FIFO
int err = ME_ERRNO_SUCCESS;
me6000_ao_subdevice_t *instance;
unsigned long cpu_flags;
volatile uint32_t ctrl;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (flags & ~ME_IO_STREAM_STOP_PRESERVE_BUFFERS) {
PERROR("Invalid flag specified.\n");
return ME_ERRNO_INVALID_FLAGS;
}
if ((stop_mode != ME_STOP_MODE_IMMEDIATE)
&& (stop_mode != ME_STOP_MODE_LAST_VALUE)) {
PERROR("Invalid stop mode specified.\n");
return ME_ERRNO_INVALID_STOP_MODE;
}
if (!(instance->fifo & ME6000_AO_HAS_FIFO)) {
PERROR("Not a streaming ao.\n");
return ME_ERRNO_NOT_SUPPORTED;
}
if (instance->status < ao_status_stream_configured) {
//There is nothing to stop!
PERROR("Subdevice not in streaming mode. %d\n",
instance->status);
return ME_ERRNO_PREVIOUS_CONFIG;
}
ME_SUBDEVICE_ENTER;
//Mark as stopping. => Software stop.
instance->status = ao_status_stream_end_wait;
if (stop_mode == ME_STOP_MODE_IMMEDIATE) { //Stopped now!
err = ao_stop_immediately(instance);
} else if (stop_mode == ME_STOP_MODE_LAST_VALUE) {
ctrl = inl(instance->ctrl_reg) & ME6000_AO_CTRL_MODE_MASK;
if (ctrl == ME6000_AO_MODE_WRAPAROUND) { //Hardware wraparound => Hardware stop.
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
ctrl = inl(instance->ctrl_reg);
ctrl |= ME6000_AO_CTRL_BIT_STOP;
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_IRQ;
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base,
ctrl);
spin_unlock_irqrestore(&instance->subdevice_lock,
cpu_flags);
//Reset interrupt latch
inl(instance->irq_reset_reg);
}
//Only runing process will interrupt this call. Events are signaled when status change. Extra timeout add for safe reason.
wait_event_interruptible_timeout(instance->wait_queue,
(instance->status !=
ao_status_stream_end_wait),
LONG_MAX);
if (instance->status != ao_status_stream_end) {
PDEBUG("Stopping stream canceled.\n");
err = ME_ERRNO_CANCELLED;
}
if (signal_pending(current)) {
PERROR("Stopping stream interrupted.\n");
instance->status = ao_status_none;
ao_stop_immediately(instance);
err = ME_ERRNO_SIGNAL;
}
}
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
ctrl = inl(instance->ctrl_reg);
ctrl |= ME6000_AO_CTRL_BIT_STOP | ME6000_AO_CTRL_BIT_IMMEDIATE_STOP;
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_IRQ;
if (!flags) { //Reset FIFO
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_FIFO;
}
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
//Reset interrupt latch
inl(instance->irq_reset_reg);
if (!flags) { //Reset software buffer
instance->circ_buf.head = 0;
instance->circ_buf.tail = 0;
instance->preloaded_count = 0;
instance->data_count = 0;
}
ME_SUBDEVICE_EXIT;
return err;
}
static int me6000_ao_io_stream_write(me_subdevice_t *subdevice,
struct file *filep,
int write_mode,
int *values, int *count, int flags)
{
int err = ME_ERRNO_SUCCESS;
me6000_ao_subdevice_t *instance;
unsigned long cpu_flags = 0;
uint32_t reg_copy;
int copied_from_user = 0;
int left_to_copy_from_user = *count;
int copied_values;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
//Checking arguments
if (!(instance->fifo & ME6000_AO_HAS_FIFO)) {
PERROR("Not a streaming ao.\n");
return ME_ERRNO_NOT_SUPPORTED;
}
if (flags) {
PERROR("Invalid flag specified.\n");
return ME_ERRNO_INVALID_FLAGS;
}
if (*count <= 0) {
PERROR("Invalid count of values specified.\n");
return ME_ERRNO_INVALID_VALUE_COUNT;
}
if (values == NULL) {
PERROR("Invalid address of values specified.\n");
return ME_ERRNO_INVALID_POINTER;
}
if ((instance->status == ao_status_none) || (instance->status == ao_status_single_configured)) { //The device is in single mode.
PERROR
("Subdevice must be preinitialize correctly for streaming.\n");
return ME_ERRNO_PREVIOUS_CONFIG;
}
switch (write_mode) {
case ME_WRITE_MODE_PRELOAD:
//Device must be stopped.
if ((instance->status != ao_status_stream_configured)
&& (instance->status != ao_status_stream_end)) {
PERROR
("Subdevice mustn't be runing when 'pre-load' mode is used.\n");
return ME_ERRNO_PREVIOUS_CONFIG;
}
break;
case ME_WRITE_MODE_NONBLOCKING:
case ME_WRITE_MODE_BLOCKING:
/// @note In blocking mode: When device is not runing and there is not enought space call will blocked up!
/// @note Some other thread must empty buffer by strating engine.
break;
default:
PERROR("Invalid write mode specified.\n");
return ME_ERRNO_INVALID_WRITE_MODE;
}
if (instance->mode & ME6000_AO_WRAP_MODE) { //Wraparound mode. Device must be stopped.
if ((instance->status != ao_status_stream_configured)
&& (instance->status != ao_status_stream_end)) {
PERROR
("Subdevice mustn't be runing when 'pre-load' mode is used.\n");
return ME_ERRNO_INVALID_WRITE_MODE;
}
}
if ((instance->mode == ME6000_AO_HW_WRAP_MODE)
&& (write_mode != ME_WRITE_MODE_PRELOAD)) {
/*
PERROR("Only 'pre-load' write is acceptable in hardware wraparound mode.\n");
return ME_ERRNO_PREVIOUS_CONFIG;
*/
//This is transparent for user.
PDEBUG("Changing write_mode to ME_WRITE_MODE_PRELOAD.\n");
write_mode = ME_WRITE_MODE_PRELOAD;
}
ME_SUBDEVICE_ENTER;
if (write_mode == ME_WRITE_MODE_PRELOAD) { //Init enviroment - preload
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
reg_copy = inl(instance->ctrl_reg);
//Check FIFO
if (!(reg_copy & ME6000_AO_CTRL_BIT_ENABLE_FIFO)) { //FIFO not active. Enable it.
reg_copy |= ME6000_AO_CTRL_BIT_ENABLE_FIFO;
outl(reg_copy, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base,
reg_copy);
instance->preloaded_count = 0;
}
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
}
while (1) {
//Copy to buffer. This step is common for all modes.
copied_from_user =
ao_get_data_from_user(instance, left_to_copy_from_user,
values + (*count -
left_to_copy_from_user));
left_to_copy_from_user -= copied_from_user;
reg_copy = inl(instance->status_reg);
if ((instance->status == ao_status_stream_run) && !(reg_copy & ME6000_AO_STATUS_BIT_FSM)) { //BROKEN PIPE! The state machine is stoped but logical status show that should be working.
PERROR("Broken pipe in write.\n");
err = ME_ERRNO_SUBDEVICE_NOT_RUNNING;
break;
}
if ((instance->status == ao_status_stream_run) && (instance->mode == ME6000_AO_CONTINOUS) && (reg_copy & ME6000_AO_STATUS_BIT_HF)) { //Continous mode runing and data are below half!
// Block interrupts.
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
reg_copy = inl(instance->ctrl_reg);
reg_copy &= ~ME6000_AO_CTRL_BIT_ENABLE_IRQ;
outl(reg_copy, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base,
reg_copy);
spin_unlock_irqrestore(&instance->subdevice_lock,
cpu_flags);
//Fast copy
copied_values =
ao_write_data(instance, ME6000_AO_FIFO_COUNT / 2,
0);
if (copied_values > 0) {
instance->circ_buf.tail += copied_values;
instance->circ_buf.tail &=
instance->circ_buf.mask;
continue;
}
//Reset interrupt latch
inl(instance->irq_reset_reg);
// Activate interrupts.
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
reg_copy = inl(instance->ctrl_reg);
reg_copy |= ME6000_AO_CTRL_BIT_ENABLE_IRQ;
outl(reg_copy, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base,
reg_copy);
spin_unlock_irqrestore(&instance->subdevice_lock,
cpu_flags);
if (copied_values == 0) { //This was checked and never should happend!
PERROR_CRITICAL("COPY FINISH WITH 0!\n");
}
if (copied_values < 0) { //This was checked and never should happend!
PERROR_CRITICAL("COPY FINISH WITH ERROR!\n");
instance->status = ao_status_stream_fifo_error;
err = ME_ERRNO_FIFO_BUFFER_OVERFLOW;
break;
}
}
if (!left_to_copy_from_user) { //All datas were copied.
break;
} else { //Not all datas were copied.
if (instance->mode & ME6000_AO_WRAP_MODE) { //Error too much datas! Wraparound is limited in size!
PERROR
("Too much data for wraparound mode! Exceeded size of %ld.\n",
ME6000_AO_CIRC_BUF_COUNT - 1);
err = ME_ERRNO_RING_BUFFER_OVERFLOW;
break;
}
if (write_mode != ME_WRITE_MODE_BLOCKING) { //Non blocking calls
break;
}
wait_event_interruptible(instance->wait_queue,
me_circ_buf_space(&instance->
circ_buf));
if (signal_pending(current)) {
PERROR("Writing interrupted by signal.\n");
instance->status = ao_status_none;
ao_stop_immediately(instance);
err = ME_ERRNO_SIGNAL;
break;
}
if (instance->status == ao_status_none) { //Reset
PERROR("Writing interrupted by reset.\n");
err = ME_ERRNO_CANCELLED;
break;
}
}
}
if (write_mode == ME_WRITE_MODE_PRELOAD) { //Copy data to FIFO - preload
copied_values =
ao_write_data_pooling(instance, ME6000_AO_FIFO_COUNT,
instance->preloaded_count);
instance->preloaded_count += copied_values;
instance->data_count += copied_values;
if ((instance->mode == ME6000_AO_HW_WRAP_MODE)
&& (me_circ_buf_values(&instance->circ_buf) >
ME6000_AO_FIFO_COUNT)) {
PERROR
("Too much data for hardware wraparound mode! Exceeded size of %d.\n",
ME6000_AO_FIFO_COUNT);
err = ME_ERRNO_FIFO_BUFFER_OVERFLOW;
}
}
*count = *count - left_to_copy_from_user;
ME_SUBDEVICE_EXIT;
return err;
}
static irqreturn_t me6000_ao_isr(int irq, void *dev_id)
{
me6000_ao_subdevice_t *instance = dev_id;
uint32_t irq_status;
uint32_t ctrl;
uint32_t status;
int count = 0;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (irq != instance->irq) {
PERROR("Incorrect interrupt num: %d.\n", irq);
return IRQ_NONE;
}
irq_status = inl(instance->irq_status_reg);
if (!(irq_status & (ME6000_IRQ_STATUS_BIT_AO_HF << instance->ao_idx))) {
PINFO("%ld Shared interrupt. %s(): ID=%d: status_reg=0x%04X\n",
jiffies, __func__, instance->ao_idx, irq_status);
return IRQ_NONE;
}
if (!instance->circ_buf.buf) {
instance->status = ao_status_stream_error;
PERROR_CRITICAL("CIRCULAR BUFFER NOT EXISTS!\n");
//Block interrupts. Stop machine.
ctrl = inl(instance->ctrl_reg);
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_IRQ;
ctrl |=
ME6000_AO_CTRL_BIT_IMMEDIATE_STOP | ME6000_AO_CTRL_BIT_STOP;
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
//Inform user
wake_up_interruptible_all(&instance->wait_queue);
return IRQ_HANDLED;
}
status = inl(instance->status_reg);
if (!(status & ME6000_AO_STATUS_BIT_FSM)) { //Too late. Not working! END? BROKEN PIPE?
/// @note Error checking was moved to separate task.
PDEBUG("Interrupt come but ISM is not working!\n");
//Block interrupts. Stop machine.
ctrl = inl(instance->ctrl_reg);
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_IRQ;
ctrl |=
ME6000_AO_CTRL_BIT_STOP | ME6000_AO_CTRL_BIT_IMMEDIATE_STOP;
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
//Reset interrupt latch
inl(instance->irq_reset_reg);
/// @note User notification was also moved to separate task.
return IRQ_HANDLED;
}
//General procedure. Process more datas.
#ifdef MEDEBUG_DEBUG
if (!me_circ_buf_values(&instance->circ_buf)) { //Buffer is empty!
PDEBUG("Circular buffer empty!\n");
}
#endif
//Check FIFO
if (status & ME6000_AO_STATUS_BIT_HF) { //OK less than half
//Block interrupts
ctrl = inl(instance->ctrl_reg);
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_IRQ;
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
do {
//Calculate how many should be copied.
count =
(instance->stop_data_count) ? instance->
stop_data_count -
instance->data_count : ME6000_AO_FIFO_COUNT / 2;
if (ME6000_AO_FIFO_COUNT / 2 < count) {
count = ME6000_AO_FIFO_COUNT / 2;
}
//Copy data
if (instance->mode == ME6000_AO_CONTINOUS) { //Continous
count = ao_write_data(instance, count, 0);
if (count > 0) {
instance->circ_buf.tail += count;
instance->circ_buf.tail &=
instance->circ_buf.mask;
instance->data_count += count;
if ((instance->status == ao_status_stream_end_wait) && !me_circ_buf_values(&instance->circ_buf)) { //Stoping. Whole buffer was copied.
break;
}
}
} else if ((instance->mode == ME6000_AO_SW_WRAP_MODE) && ((ctrl & ME6000_AO_CTRL_MODE_MASK) == ME6000_AO_MODE_CONTINUOUS)) { //Wraparound (software)
if (instance->status == ao_status_stream_end_wait) { //We stoping => Copy to the end of the buffer.
count =
ao_write_data(instance, count, 0);
} else { //Copy in wraparound mode.
count =
ao_write_data_wraparound(instance,
count,
instance->
preloaded_count);
}
if (count > 0) {
instance->data_count += count;
instance->preloaded_count += count;
instance->preloaded_count %=
me_circ_buf_values(&instance->
circ_buf);
if ((instance->status == ao_status_stream_end_wait) && !instance->preloaded_count) { //Stoping. Whole buffer was copied.
break;
}
}
}
if ((count <= 0) || (instance->stop_data_count && (instance->stop_data_count <= instance->data_count))) { //End of work.
break;
}
} //Repeat if still is under half fifo
while ((status =
inl(instance->status_reg)) & ME6000_AO_STATUS_BIT_HF);
//Unblock interrupts
ctrl = inl(instance->ctrl_reg);
if (count >= 0) { //Copy was successful.
if (instance->stop_data_count && (instance->stop_data_count <= instance->data_count)) { //Finishing work. No more interrupts.
PDEBUG("Finishing work. Interrupt disabled.\n");
instance->status = ao_status_stream_end_wait;
} else if (count > 0) { //Normal work. Enable interrupt.
PDEBUG("Normal work. Enable interrupt.\n");
ctrl |= ME6000_AO_CTRL_BIT_ENABLE_IRQ;
} else { //Normal work but there are no more data in buffer. Interrupt blocked. stream_write() will unblock it.
PDEBUG
("No data in software buffer. Interrupt blocked.\n");
}
} else { //Error during copy.
instance->status = ao_status_stream_fifo_error;
}
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base, ctrl);
} else { //?? more than half
PDEBUG
("Interrupt come but FIFO more than half full! Reset interrupt.\n");
}
PINFO("ISR: Buffer count: %d.(T:%d H:%d)\n",
me_circ_buf_values(&instance->circ_buf), instance->circ_buf.tail,
instance->circ_buf.head);
PINFO("ISR: Stop count: %d.\n", instance->stop_count);
PINFO("ISR: Stop data count: %d.\n", instance->stop_data_count);
PINFO("ISR: Data count: %d.\n", instance->data_count);
//Reset interrupt latch
inl(instance->irq_reset_reg);
//Inform user
wake_up_interruptible_all(&instance->wait_queue);
return IRQ_HANDLED;
}
static void me6000_ao_destructor(struct me_subdevice *subdevice)
{
me6000_ao_subdevice_t *instance;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
instance->ao_control_task_flag = 0;
// Reset subdevice to asure clean exit.
me6000_ao_io_reset_subdevice(subdevice, NULL,
ME_IO_RESET_SUBDEVICE_NO_FLAGS);
// Remove any tasks from work queue. This is paranoic because it was done allready in reset().
if (!cancel_delayed_work(&instance->ao_control_task)) { //Wait 2 ticks to be sure that control task is removed from queue.
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(2);
}
if (instance->fifo & ME6000_AO_HAS_FIFO) {
if (instance->irq) {
free_irq(instance->irq, instance);
instance->irq = 0;
}
if (instance->circ_buf.buf) {
PDEBUG("free circ_buf = %p size=%d",
instance->circ_buf.buf,
PAGE_SHIFT << ME6000_AO_CIRC_BUF_SIZE_ORDER);
free_pages((unsigned long)instance->circ_buf.buf,
ME6000_AO_CIRC_BUF_SIZE_ORDER);
}
instance->circ_buf.buf = NULL;
}
me_subdevice_deinit(&instance->base);
kfree(instance);
}
me6000_ao_subdevice_t *me6000_ao_constructor(uint32_t reg_base,
spinlock_t *preload_reg_lock,
uint32_t *preload_flags,
uint32_t *triggering_flags,
int ao_idx,
int fifo,
int irq,
int high_range,
struct workqueue_struct *me6000_wq)
{
me6000_ao_subdevice_t *subdevice;
int err;
PDEBUG("executed ID=%d.\n", ao_idx);
/* Allocate memory for subdevice instance */
subdevice = kmalloc(sizeof(me6000_ao_subdevice_t), GFP_KERNEL);
if (!subdevice) {
PERROR("Cannot get memory for subdevice instance.\n");
return NULL;
}
memset(subdevice, 0, sizeof(me6000_ao_subdevice_t));
/* Initialize subdevice base class */
err = me_subdevice_init(&subdevice->base);
if (err) {
PERROR("Cannot initialize subdevice base class instance.\n");
kfree(subdevice);
return NULL;
}
// Initialize spin locks.
spin_lock_init(&subdevice->subdevice_lock);
subdevice->preload_reg_lock = preload_reg_lock;
subdevice->preload_flags = preload_flags;
subdevice->triggering_flags = triggering_flags;
/* Store analog output index */
subdevice->ao_idx = ao_idx;
/* Store if analog output has fifo */
subdevice->fifo = fifo;
if (subdevice->fifo & ME6000_AO_HAS_FIFO) {
/* Allocate and initialize circular buffer */
subdevice->circ_buf.mask = ME6000_AO_CIRC_BUF_COUNT - 1;
subdevice->circ_buf.buf =
(void *)__get_free_pages(GFP_KERNEL,
ME6000_AO_CIRC_BUF_SIZE_ORDER);
PDEBUG("circ_buf = %p size=%ld\n", subdevice->circ_buf.buf,
ME6000_AO_CIRC_BUF_SIZE);
if (!subdevice->circ_buf.buf) {
PERROR
("Cannot initialize subdevice base class instance.\n");
kfree(subdevice);
return NULL;
}
memset(subdevice->circ_buf.buf, 0, ME6000_AO_CIRC_BUF_SIZE);
} else {
subdevice->circ_buf.mask = 0;
subdevice->circ_buf.buf = NULL;
}
subdevice->circ_buf.head = 0;
subdevice->circ_buf.tail = 0;
subdevice->status = ao_status_none;
subdevice->ao_control_task_flag = 0;
subdevice->timeout.delay = 0;
subdevice->timeout.start_time = jiffies;
/* Initialize wait queue */
init_waitqueue_head(&subdevice->wait_queue);
/* Initialize single value to 0V */
subdevice->single_value = 0x8000;
subdevice->single_value_in_fifo = 0x8000;
/* Initialize range boarders */
if (high_range) {
subdevice->min = ME6000_AO_MIN_RANGE_HIGH;
subdevice->max = ME6000_AO_MAX_RANGE_HIGH;
} else {
subdevice->min = ME6000_AO_MIN_RANGE;
subdevice->max = ME6000_AO_MAX_RANGE;
}
/* Register interrupt service routine */
if (subdevice->fifo & ME6000_AO_HAS_FIFO) {
subdevice->irq = irq;
if (request_irq(subdevice->irq, me6000_ao_isr,
#ifdef IRQF_DISABLED
IRQF_DISABLED | IRQF_SHARED,
#else
SA_INTERRUPT | SA_SHIRQ,
#endif
ME6000_NAME, subdevice)) {
PERROR("Cannot get interrupt line.\n");
PDEBUG("free circ_buf = %p size=%d",
subdevice->circ_buf.buf,
PAGE_SHIFT << ME6000_AO_CIRC_BUF_SIZE_ORDER);
free_pages((unsigned long)subdevice->circ_buf.buf,
ME6000_AO_CIRC_BUF_SIZE_ORDER);
subdevice->circ_buf.buf = NULL;
kfree(subdevice);
return NULL;
}
PINFO("Registered irq=%d.\n", subdevice->irq);
} else {
subdevice->irq = 0;
}
/* Initialize registers */
// Only streamed subdevices support interrupts. For the rest this register has no meaning.
subdevice->irq_status_reg = reg_base + ME6000_AO_IRQ_STATUS_REG;
subdevice->preload_reg = reg_base + ME6000_AO_PRELOAD_REG;
if (ao_idx == 0) {
subdevice->ctrl_reg = reg_base + ME6000_AO_00_CTRL_REG;
subdevice->status_reg = reg_base + ME6000_AO_00_STATUS_REG;
subdevice->fifo_reg = reg_base + ME6000_AO_00_FIFO_REG;
subdevice->timer_reg = reg_base + ME6000_AO_00_TIMER_REG;
subdevice->irq_reset_reg =
reg_base + ME6000_AO_00_IRQ_RESET_REG;
subdevice->single_reg = reg_base + ME6000_AO_00_SINGLE_REG;
} else if (ao_idx == 1) {
subdevice->ctrl_reg = reg_base + ME6000_AO_01_CTRL_REG;
subdevice->status_reg = reg_base + ME6000_AO_01_STATUS_REG;
subdevice->fifo_reg = reg_base + ME6000_AO_01_FIFO_REG;
subdevice->timer_reg = reg_base + ME6000_AO_01_TIMER_REG;
subdevice->irq_reset_reg =
reg_base + ME6000_AO_01_IRQ_RESET_REG;
subdevice->single_reg = reg_base + ME6000_AO_01_SINGLE_REG;
} else if (ao_idx == 2) {
subdevice->ctrl_reg = reg_base + ME6000_AO_02_CTRL_REG;
subdevice->status_reg = reg_base + ME6000_AO_02_STATUS_REG;
subdevice->fifo_reg = reg_base + ME6000_AO_02_FIFO_REG;
subdevice->timer_reg = reg_base + ME6000_AO_02_TIMER_REG;
subdevice->irq_reset_reg =
reg_base + ME6000_AO_02_IRQ_RESET_REG;
subdevice->single_reg = reg_base + ME6000_AO_02_SINGLE_REG;
} else if (ao_idx == 3) {
subdevice->ctrl_reg = reg_base + ME6000_AO_03_CTRL_REG;
subdevice->status_reg = reg_base + ME6000_AO_03_STATUS_REG;
subdevice->fifo_reg = reg_base + ME6000_AO_03_FIFO_REG;
subdevice->timer_reg = reg_base + ME6000_AO_03_TIMER_REG;
subdevice->irq_reset_reg =
reg_base + ME6000_AO_03_IRQ_RESET_REG;
subdevice->single_reg = reg_base + ME6000_AO_03_SINGLE_REG;
} else {
subdevice->ctrl_reg = reg_base + ME6000_AO_DUMY;
subdevice->fifo_reg = reg_base + ME6000_AO_DUMY;
subdevice->timer_reg = reg_base + ME6000_AO_DUMY;
subdevice->irq_reset_reg = reg_base + ME6000_AO_DUMY;
subdevice->single_reg = reg_base + ME6000_AO_DUMY;
subdevice->status_reg = reg_base + ME6000_AO_SINGLE_STATUS_REG;
if (ao_idx == 4) {
subdevice->single_reg =
reg_base + ME6000_AO_04_SINGLE_REG;
} else if (ao_idx == 5) {
subdevice->single_reg =
reg_base + ME6000_AO_05_SINGLE_REG;
} else if (ao_idx == 6) {
subdevice->single_reg =
reg_base + ME6000_AO_06_SINGLE_REG;
} else if (ao_idx == 7) {
subdevice->single_reg =
reg_base + ME6000_AO_07_SINGLE_REG;
} else if (ao_idx == 8) {
subdevice->single_reg =
reg_base + ME6000_AO_08_SINGLE_REG;
} else if (ao_idx == 9) {
subdevice->single_reg =
reg_base + ME6000_AO_09_SINGLE_REG;
} else if (ao_idx == 10) {
subdevice->single_reg =
reg_base + ME6000_AO_10_SINGLE_REG;
} else if (ao_idx == 11) {
subdevice->single_reg =
reg_base + ME6000_AO_11_SINGLE_REG;
} else if (ao_idx == 12) {
subdevice->single_reg =
reg_base + ME6000_AO_12_SINGLE_REG;
} else if (ao_idx == 13) {
subdevice->single_reg =
reg_base + ME6000_AO_13_SINGLE_REG;
} else if (ao_idx == 14) {
subdevice->single_reg =
reg_base + ME6000_AO_14_SINGLE_REG;
} else if (ao_idx == 15) {
subdevice->single_reg =
reg_base + ME6000_AO_15_SINGLE_REG;
} else {
PERROR_CRITICAL("WRONG SUBDEVICE ID=%d!", ao_idx);
me_subdevice_deinit((me_subdevice_t *) subdevice);
if (subdevice->fifo) {
free_pages((unsigned long)subdevice->circ_buf.
buf, ME6000_AO_CIRC_BUF_SIZE_ORDER);
}
subdevice->circ_buf.buf = NULL;
kfree(subdevice);
return NULL;
}
}
#ifdef MEDEBUG_DEBUG_REG
subdevice->reg_base = reg_base;
#endif
/* Override base class methods. */
subdevice->base.me_subdevice_destructor = me6000_ao_destructor;
subdevice->base.me_subdevice_io_reset_subdevice =
me6000_ao_io_reset_subdevice;
subdevice->base.me_subdevice_io_single_config =
me6000_ao_io_single_config;
subdevice->base.me_subdevice_io_single_read = me6000_ao_io_single_read;
subdevice->base.me_subdevice_io_single_write =
me6000_ao_io_single_write;
subdevice->base.me_subdevice_io_stream_config =
me6000_ao_io_stream_config;
subdevice->base.me_subdevice_io_stream_new_values =
me6000_ao_io_stream_new_values;
subdevice->base.me_subdevice_io_stream_write =
me6000_ao_io_stream_write;
subdevice->base.me_subdevice_io_stream_start =
me6000_ao_io_stream_start;
subdevice->base.me_subdevice_io_stream_status =
me6000_ao_io_stream_status;
subdevice->base.me_subdevice_io_stream_stop = me6000_ao_io_stream_stop;
subdevice->base.me_subdevice_query_number_channels =
me6000_ao_query_number_channels;
subdevice->base.me_subdevice_query_subdevice_type =
me6000_ao_query_subdevice_type;
subdevice->base.me_subdevice_query_subdevice_caps =
me6000_ao_query_subdevice_caps;
subdevice->base.me_subdevice_query_subdevice_caps_args =
me6000_ao_query_subdevice_caps_args;
subdevice->base.me_subdevice_query_range_by_min_max =
me6000_ao_query_range_by_min_max;
subdevice->base.me_subdevice_query_number_ranges =
me6000_ao_query_number_ranges;
subdevice->base.me_subdevice_query_range_info =
me6000_ao_query_range_info;
subdevice->base.me_subdevice_query_timer = me6000_ao_query_timer;
//prepare work queue and work function
subdevice->me6000_workqueue = me6000_wq;
/* workqueue API changed in kernel 2.6.20 */
INIT_DELAYED_WORK(&subdevice->ao_control_task,
me6000_ao_work_control_task);
if (subdevice->fifo) { //Set speed
outl(ME6000_AO_MIN_CHAN_TICKS - 1, subdevice->timer_reg);
subdevice->hardware_stop_delay = HZ / 10; //100ms
}
return subdevice;
}
/** @brief Stop presentation. Preserve FIFOs.
*
* @param instance The subdevice instance (pointer).
*/
inline int ao_stop_immediately(me6000_ao_subdevice_t *instance)
{
unsigned long cpu_flags;
uint32_t ctrl;
int timeout;
int i;
uint32_t single_mask;
if (instance->ao_idx < ME6000_AO_SINGLE_STATUS_OFFSET)
single_mask = 0x0000;
else
single_mask = 0x0001 << (instance->ao_idx -
ME6000_AO_SINGLE_STATUS_OFFSET);
timeout =
(instance->hardware_stop_delay >
(HZ / 10)) ? instance->hardware_stop_delay : HZ / 10;
for (i = 0; i <= timeout; i++) {
if (instance->fifo) {
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
// Stop all actions. No conditions! Block interrupts. Leave FIFO untouched!
ctrl = inl(instance->ctrl_reg);
ctrl |=
ME6000_AO_CTRL_BIT_STOP |
ME6000_AO_CTRL_BIT_IMMEDIATE_STOP;
ctrl &=
~(ME6000_AO_CTRL_BIT_ENABLE_IRQ |
ME6000_AO_CTRL_BIT_ENABLE_EX_TRIG);
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base,
ctrl);
spin_unlock_irqrestore(&instance->subdevice_lock,
cpu_flags);
if (!(inl(instance->status_reg) & ME6000_AO_STATUS_BIT_FSM)) { // Exit.
break;
}
} else {
if (!(inl(instance->status_reg) & single_mask)) { // Exit.
break;
}
}
PINFO("<%s> Wait for stop: %d\n", __func__, i);
//Still working!
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(1);
}
if (i > timeout) {
PERROR_CRITICAL("FSM IS BUSY!\n");
return ME_ERRNO_INTERNAL;
}
return ME_ERRNO_SUCCESS;
}
/** @brief Copy data from circular buffer to fifo (fast) in wraparound.
* @note This is time critical function. Checking is done at begining and end only.
* @note The is not reasonable way to check how many walues was in FIFO at begining. The count must be managed externaly.
*
* @param instance The subdevice instance (pointer).
* @param count Maximum number of copied data.
* @param start_pos Position of the firs value in buffer.
*
* @return On success: Number of copied data.
* @return On error/success: 0. No datas were copied => no data in buffer.
* @return On error: -ME_ERRNO_FIFO_BUFFER_OVERFLOW.
*/
inline int ao_write_data_wraparound(me6000_ao_subdevice_t *instance, int count,
int start_pos)
{ /// @note This is time critical function!
uint32_t status;
uint32_t value;
int pos =
(instance->circ_buf.tail + start_pos) & instance->circ_buf.mask;
int local_count = count;
int i = 1;
if (count <= 0) { //Wrong count!
return 0;
}
while (i < local_count) {
//Get value from buffer
value = *(instance->circ_buf.buf + pos);
//Prepare it
if (instance->ao_idx & 0x1) {
value <<= 16;
}
//Put value to FIFO
outl(value, instance->fifo_reg);
//PDEBUG_REG("idx=%d fifo_reg outl(0x%lX+0x%lX)=0x%x\n", instance->ao_idx, instance->reg_base, instance->fifo_reg - instance->reg_base, value);
pos++;
pos &= instance->circ_buf.mask;
if (pos == instance->circ_buf.head) {
pos = instance->circ_buf.tail;
}
i++;
}
status = inl(instance->status_reg);
if (!(status & ME6000_AO_STATUS_BIT_FF)) { //FIFO is full before all datas were copied!
PERROR("idx=%d FIFO is full before all datas were copied!\n",
instance->ao_idx);
return -ME_ERRNO_FIFO_BUFFER_OVERFLOW;
} else { //Add last value
value = *(instance->circ_buf.buf + pos);
if (instance->ao_idx & 0x1) {
value <<= 16;
}
//Put value to FIFO
outl(value, instance->fifo_reg);
//PDEBUG_REG("idx=%d fifo_reg outl(0x%lX+0x%lX)=0x%x\n", instance->ao_idx, instance->reg_base, instance->fifo_reg - instance->reg_base, value);
}
PINFO("idx=%d WRAPAROUND LOADED %d values\n", instance->ao_idx,
local_count);
return local_count;
}
/** @brief Copy data from software buffer to fifo (fast).
* @note This is time critical function. Checking is done at begining and end only.
* @note The is not reasonable way to check how many walues was in FIFO at begining. The count must be managed externaly.
*
* @param instance The subdevice instance (pointer).
* @param count Maximum number of copied data.
* @param start_pos Position of the firs value in buffer.
*
* @return On success: Number of copied data.
* @return On error/success: 0. No datas were copied => no data in buffer.
* @return On error: -ME_ERRNO_FIFO_BUFFER_OVERFLOW.
*/
inline int ao_write_data(me6000_ao_subdevice_t *instance, int count,
int start_pos)
{ /// @note This is time critical function!
uint32_t status;
uint32_t value;
int pos =
(instance->circ_buf.tail + start_pos) & instance->circ_buf.mask;
int local_count = count;
int max_count;
int i = 1;
if (count <= 0) { //Wrong count!
return 0;
}
max_count = me_circ_buf_values(&instance->circ_buf) - start_pos;
if (max_count <= 0) { //No data to copy!
return 0;
}
if (max_count < count) {
local_count = max_count;
}
while (i < local_count) {
//Get value from buffer
value = *(instance->circ_buf.buf + pos);
//Prepare it
if (instance->ao_idx & 0x1) {
value <<= 16;
}
//Put value to FIFO
outl(value, instance->fifo_reg);
//PDEBUG_REG("idx=%d fifo_reg outl(0x%lX+0x%lX)=0x%x\n", instance->ao_idx, instance->reg_base, instance->fifo_reg - instance->reg_base, value);
pos++;
pos &= instance->circ_buf.mask;
i++;
}
status = inl(instance->status_reg);
if (!(status & ME6000_AO_STATUS_BIT_FF)) { //FIFO is full before all datas were copied!
PERROR("idx=%d FIFO is full before all datas were copied!\n",
instance->ao_idx);
return -ME_ERRNO_FIFO_BUFFER_OVERFLOW;
} else { //Add last value
value = *(instance->circ_buf.buf + pos);
if (instance->ao_idx & 0x1) {
value <<= 16;
}
//Put value to FIFO
outl(value, instance->fifo_reg);
//PDEBUG_REG("idx=%d fifo_reg outl(0x%lX+0x%lX)=0x%x\n", instance->ao_idx, instance->reg_base, instance->fifo_reg - instance->reg_base, value);
}
PINFO("idx=%d FAST LOADED %d values\n", instance->ao_idx, local_count);
return local_count;
}
/** @brief Copy data from software buffer to fifo (slow).
* @note This is slow function that copy all data from buffer to FIFO with full control.
*
* @param instance The subdevice instance (pointer).
* @param count Maximum number of copied data.
* @param start_pos Position of the firs value in buffer.
*
* @return On success: Number of copied values.
* @return On error/success: 0. FIFO was full at begining.
* @return On error: -ME_ERRNO_RING_BUFFER_UNDEFFLOW.
*/
inline int ao_write_data_pooling(me6000_ao_subdevice_t *instance, int count,
int start_pos)
{ /// @note This is slow function!
uint32_t status;
uint32_t value;
int pos =
(instance->circ_buf.tail + start_pos) & instance->circ_buf.mask;
int local_count = count;
int i;
int max_count;
if (count <= 0) { //Wrong count!
PERROR("idx=%d SLOW LOADED: Wrong count!\n", instance->ao_idx);
return 0;
}
max_count = me_circ_buf_values(&instance->circ_buf) - start_pos;
if (max_count <= 0) { //No data to copy!
PERROR("idx=%d SLOW LOADED: No data to copy!\n",
instance->ao_idx);
return 0;
}
if (max_count < count) {
local_count = max_count;
}
for (i = 0; i < local_count; i++) {
status = inl(instance->status_reg);
if (!(status & ME6000_AO_STATUS_BIT_FF)) { //FIFO is full!
return i;
}
//Get value from buffer
value = *(instance->circ_buf.buf + pos);
//Prepare it
if (instance->ao_idx & 0x1) {
value <<= 16;
}
//Put value to FIFO
outl(value, instance->fifo_reg);
//PDEBUG_REG("idx=%d fifo_reg outl(0x%lX+0x%lX)=0x%x\n", instance->ao_idx, instance->reg_base, instance->fifo_reg - instance->reg_base, value);
pos++;
pos &= instance->circ_buf.mask;
}
PINFO("idx=%d SLOW LOADED %d values\n", instance->ao_idx, local_count);
return local_count;
}
/** @brief Copy data from user space to circular buffer.
* @param instance The subdevice instance (pointer).
* @param count Number of datas in user space.
* @param user_values Buffer's pointer.
*
* @return On success: Number of copied values.
* @return On error: -ME_ERRNO_INTERNAL.
*/
inline int ao_get_data_from_user(me6000_ao_subdevice_t *instance, int count,
int *user_values)
{
int i, err;
int empty_space;
int copied;
int value;
empty_space = me_circ_buf_space(&instance->circ_buf);
//We have only this space free.
copied = (count < empty_space) ? count : empty_space;
for (i = 0; i < copied; i++) { //Copy from user to buffer
if ((err = get_user(value, (int *)(user_values + i)))) {
PERROR
("idx=%d BUFFER LOADED: get_user(0x%p) return an error: %d\n",
instance->ao_idx, user_values + i, err);
return -ME_ERRNO_INTERNAL;
}
/// @note The analog output in me6000 series has size of 16 bits.
*(instance->circ_buf.buf + instance->circ_buf.head) =
(uint16_t) value;
instance->circ_buf.head++;
instance->circ_buf.head &= instance->circ_buf.mask;
}
PINFO("idx=%d BUFFER LOADED %d values\n", instance->ao_idx, copied);
return copied;
}
static void me6000_ao_work_control_task(struct work_struct *work)
{
me6000_ao_subdevice_t *instance;
unsigned long cpu_flags = 0;
uint32_t status;
uint32_t ctrl;
uint32_t synch;
int reschedule = 0;
int signaling = 0;
uint32_t single_mask;
instance =
container_of((void *)work, me6000_ao_subdevice_t, ao_control_task);
PINFO("<%s: %ld> executed. idx=%d\n", __func__, jiffies,
instance->ao_idx);
status = inl(instance->status_reg);
PDEBUG_REG("status_reg inl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
instance->status_reg - instance->reg_base, status);
/// @note AO_STATUS_BIT_FSM doesn't work as should be for pure single channels (idx>=4)
// single_mask = (instance->ao_idx-ME6000_AO_SINGLE_STATUS_OFFSET < 0) ? 0x0000 : (0x0001 << (instance->ao_idx-ME6000_AO_SINGLE_STATUS_OFFSET));
single_mask = *instance->triggering_flags & (0x1 << instance->ao_idx);
switch (instance->status) { // Checking actual mode.
// Not configured for work.
case ao_status_none:
break;
//This are stable modes. No need to do anything. (?)
case ao_status_single_configured:
case ao_status_stream_configured:
case ao_status_stream_fifo_error:
case ao_status_stream_buffer_error:
case ao_status_stream_error:
PERROR("Shouldn't be running!.\n");
break;
// Single modes
case ao_status_single_run_wait:
case ao_status_single_run:
case ao_status_single_end_wait:
if (instance->fifo) { // Extra registers.
if (!(status & ME6000_AO_STATUS_BIT_FSM)) { // State machine is not working.
if (((instance->fifo & ME6000_AO_HAS_FIFO)
&& (!(status & ME6000_AO_STATUS_BIT_EF)))
|| (!(instance->fifo & ME6000_AO_HAS_FIFO))) { // Single is in end state.
PDEBUG
("Single call has been complited.\n");
// Set correct value for single_read();
instance->single_value =
instance->single_value_in_fifo;
// Set status as 'ao_status_single_end'
instance->status = ao_status_single_end;
spin_lock(instance->preload_reg_lock);
if ((single_mask) && (*instance->preload_flags & (ME6000_AO_SYNC_HOLD << instance->ao_idx))) { // This is one of synchronous start channels. Set all as triggered.
*instance->triggering_flags =
0x00000000;
} else {
//Set this channel as triggered (none active).
*instance->triggering_flags &=
~(0x1 << instance->ao_idx);
}
spin_unlock(instance->preload_reg_lock);
// Signal the end.
signaling = 1;
// Wait for stop ISM.
reschedule = 1;
break;
}
}
// Check timeout.
if ((instance->timeout.delay) && ((jiffies - instance->timeout.start_time) >= instance->timeout.delay)) { // Timeout
PDEBUG("Timeout reached.\n");
// Stop all actions. No conditions! Block interrupts and trigger. Leave FIFO untouched!
spin_lock_irqsave(&instance->subdevice_lock,
cpu_flags);
ctrl = inl(instance->ctrl_reg);
ctrl |=
ME6000_AO_CTRL_BIT_STOP |
ME6000_AO_CTRL_BIT_IMMEDIATE_STOP;
ctrl &=
~(ME6000_AO_CTRL_BIT_ENABLE_IRQ |
ME6000_AO_CTRL_BIT_ENABLE_EX_TRIG);
ctrl &=
~(ME6000_AO_CTRL_BIT_EX_TRIG_EDGE |
ME6000_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH);
//Disabling FIFO
ctrl &= ~ME6000_AO_CTRL_BIT_ENABLE_FIFO;
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg -
instance->reg_base, ctrl);
spin_unlock_irqrestore(&instance->
subdevice_lock,
cpu_flags);
//Reset interrupt latch
inl(instance->irq_reset_reg);
spin_lock(instance->preload_reg_lock);
//Remove from synchronous start. Block triggering from this output.
synch = inl(instance->preload_reg);
synch &=
~((ME6000_AO_SYNC_HOLD |
ME6000_AO_SYNC_EXT_TRIG) << instance->
ao_idx);
if (!(instance->fifo & ME6000_AO_HAS_FIFO)) { // No FIFO - set to single safe mode
synch |=
ME6000_AO_SYNC_HOLD << instance->
ao_idx;
}
outl(synch, instance->preload_reg);
PDEBUG_REG
("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
synch);
//Set this channel as triggered (none active).
*instance->triggering_flags &=
~(0x1 << instance->ao_idx);
spin_unlock(instance->preload_reg_lock);
// Set correct value for single_read();
instance->single_value_in_fifo =
instance->single_value;
instance->status = ao_status_single_end;
// Signal the end.
signaling = 1;
}
} else { // No extra registers.
/*
if (!(status & single_mask))
{// State machine is not working.
PDEBUG("Single call has been complited.\n");
// Set correct value for single_read();
instance->single_value = instance->single_value_in_fifo;
// Set status as 'ao_status_single_end'
instance->status = ao_status_single_end;
// Signal the end.
signaling = 1;
// Wait for stop ISM.
reschedule = 1;
break;
}
*/
if (!single_mask) { // Was triggered.
PDEBUG("Single call has been complited.\n");
// Set correct value for single_read();
instance->single_value =
instance->single_value_in_fifo;
// Set status as 'ao_status_single_end'
instance->status = ao_status_single_end;
// Signal the end.
signaling = 1;
break;
}
// Check timeout.
if ((instance->timeout.delay) && ((jiffies - instance->timeout.start_time) >= instance->timeout.delay)) { // Timeout
PDEBUG("Timeout reached.\n");
spin_lock(instance->preload_reg_lock);
//Remove from synchronous start. Block triggering from this output.
synch = inl(instance->preload_reg);
synch &=
~(ME6000_AO_SYNC_EXT_TRIG << instance->
ao_idx);
synch |=
ME6000_AO_SYNC_HOLD << instance->ao_idx;
outl(synch, instance->preload_reg);
PDEBUG_REG
("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
synch);
//Set this channel as triggered (none active).
*instance->triggering_flags &=
~(0x1 << instance->ao_idx);
spin_unlock(instance->preload_reg_lock);
// Restore old settings.
PDEBUG("Write old value back to register.\n");
outl(instance->single_value,
instance->single_reg);
PDEBUG_REG
("single_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->single_reg - instance->reg_base,
instance->single_value);
// Set correct value for single_read();
instance->single_value_in_fifo =
instance->single_value;
instance->status = ao_status_single_end;
// Signal the end.
signaling = 1;
}
}
// Wait for stop.
reschedule = 1;
break;
case ao_status_stream_end:
if (!(instance->fifo & ME6000_AO_HAS_FIFO)) { // No FIFO
PERROR_CRITICAL
("Streaming on single device! This feature is not implemented in this version!\n");
instance->status = ao_status_stream_error;
// Signal the end.
signaling = 1;
break;
}
case ao_status_single_end:
if (instance->fifo) { // Extra registers.
if (status & ME6000_AO_STATUS_BIT_FSM) { // State machine is working but the status is set to end. Force stop.
// Wait for stop.
reschedule = 1;
}
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
// Stop all actions. No conditions! Block interrupts and trigger. Leave FIFO untouched!
ctrl = inl(instance->ctrl_reg);
ctrl |=
ME6000_AO_CTRL_BIT_IMMEDIATE_STOP |
ME6000_AO_CTRL_BIT_STOP;
ctrl &=
~(ME6000_AO_CTRL_BIT_ENABLE_IRQ |
ME6000_AO_CTRL_BIT_ENABLE_EX_TRIG);
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base,
ctrl);
spin_unlock_irqrestore(&instance->subdevice_lock,
cpu_flags);
//Reset interrupt latch
inl(instance->irq_reset_reg);
} else { // No extra registers.
/*
if (status & single_mask)
{// State machine is working but the status is set to end. Force stop.
// Wait for stop.
reschedule = 1;
}
*/
}
break;
// Stream modes
case ao_status_stream_run_wait:
if (!(instance->fifo & ME6000_AO_HAS_FIFO)) { // No FIFO
PERROR_CRITICAL
("Streaming on single device! This feature is not implemented in this version!\n");
instance->status = ao_status_stream_error;
// Signal the end.
signaling = 1;
break;
}
if (status & ME6000_AO_STATUS_BIT_FSM) { // State machine is working. Waiting for start finish.
instance->status = ao_status_stream_run;
// Signal end of this step
signaling = 1;
} else { // State machine is not working.
if (!(status & ME6000_AO_STATUS_BIT_EF)) { // FIFO is empty. Procedure has started and finish already!
instance->status = ao_status_stream_end;
// Signal the end.
signaling = 1;
// Wait for stop.
reschedule = 1;
break;
}
}
// Check timeout.
if ((instance->timeout.delay) && ((jiffies - instance->timeout.start_time) >= instance->timeout.delay)) { // Timeout
PDEBUG("Timeout reached.\n");
// Stop all actions. No conditions! Block interrupts. Leave FIFO untouched!
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
ctrl = inl(instance->ctrl_reg);
ctrl |=
ME6000_AO_CTRL_BIT_STOP |
ME6000_AO_CTRL_BIT_IMMEDIATE_STOP;
ctrl &=
~(ME6000_AO_CTRL_BIT_ENABLE_IRQ |
ME6000_AO_CTRL_BIT_ENABLE_EX_TRIG);
outl(ctrl, instance->ctrl_reg);
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->ctrl_reg - instance->reg_base,
ctrl);
spin_unlock_irqrestore(&instance->subdevice_lock,
cpu_flags);
//Reset interrupt latch
inl(instance->irq_reset_reg);
spin_lock(instance->preload_reg_lock);
//Remove from synchronous start. Block triggering from this output.
synch = inl(instance->preload_reg);
synch &=
~((ME6000_AO_SYNC_HOLD | ME6000_AO_SYNC_EXT_TRIG) <<
instance->ao_idx);
outl(synch, instance->preload_reg);
PDEBUG_REG("preload_reg outl(0x%lX+0x%lX)=0x%x\n",
instance->reg_base,
instance->preload_reg - instance->reg_base,
synch);
spin_unlock(instance->preload_reg_lock);
instance->status = ao_status_stream_end;
// Signal the end.
signaling = 1;
}
// Wait for stop.
reschedule = 1;
break;
case ao_status_stream_run:
if (!(instance->fifo & ME6000_AO_HAS_FIFO)) { // No FIFO
PERROR_CRITICAL
("Streaming on single device! This feature is not implemented in this version!\n");
instance->status = ao_status_stream_error;
// Signal the end.
signaling = 1;
break;
}
if (!(status & ME6000_AO_STATUS_BIT_FSM)) { // State machine is not working. This is an error.
// BROKEN PIPE!
if (!(status & ME6000_AO_STATUS_BIT_EF)) { // FIFO is empty.
if (me_circ_buf_values(&instance->circ_buf)) { // Software buffer is not empty.
if (instance->stop_data_count && (instance->stop_data_count <= instance->data_count)) { //Finishing work. Requed data shown.
PDEBUG
("ISM stoped. No data in FIFO. Buffer is not empty.\n");
instance->status =
ao_status_stream_end;
} else {
PERROR
("Output stream has been broken. ISM stoped. No data in FIFO. Buffer is not empty.\n");
instance->status =
ao_status_stream_buffer_error;
}
} else { // Software buffer is empty.
PDEBUG
("ISM stoped. No data in FIFO. Buffer is empty.\n");
instance->status = ao_status_stream_end;
}
} else { // There are still datas in FIFO.
if (me_circ_buf_values(&instance->circ_buf)) { // Software buffer is not empty.
PERROR
("Output stream has been broken. ISM stoped but some data in FIFO and buffer.\n");
} else { // Software buffer is empty.
PERROR
("Output stream has been broken. ISM stoped but some data in FIFO. Buffer is empty.\n");
}
instance->status = ao_status_stream_fifo_error;
}
// Signal the failure.
signaling = 1;
break;
}
// Wait for stop.
reschedule = 1;
break;
case ao_status_stream_end_wait:
if (!(instance->fifo & ME6000_AO_HAS_FIFO)) { // No FIFO
PERROR_CRITICAL
("Streaming on single device! This feature is not implemented in this version!\n");
instance->status = ao_status_stream_error;
// Signal the end.
signaling = 1;
break;
}
if (!(status & ME6000_AO_STATUS_BIT_FSM)) { // State machine is not working. Waiting for stop finish.
instance->status = ao_status_stream_end;
signaling = 1;
}
// State machine is working.
reschedule = 1;
break;
default:
PERROR_CRITICAL("Status is in wrong state (%d)!\n",
instance->status);
instance->status = ao_status_stream_error;
// Signal the end.
signaling = 1;
break;
}
if (signaling) { //Signal it.
wake_up_interruptible_all(&instance->wait_queue);
}
if (instance->ao_control_task_flag && reschedule) { // Reschedule task
queue_delayed_work(instance->me6000_workqueue,
&instance->ao_control_task, 1);
} else {
PINFO("<%s> Ending control task.\n", __func__);
}
}
static int me6000_ao_query_range_by_min_max(me_subdevice_t *subdevice,
int unit,
int *min,
int *max, int *maxdata, int *range)
{
me6000_ao_subdevice_t *instance;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if ((*max - *min) < 0) {
PERROR("Invalid minimum and maximum values specified.\n");
return ME_ERRNO_INVALID_MIN_MAX;
}
if ((unit == ME_UNIT_VOLT) || (unit == ME_UNIT_ANY)) {
if ((*max <= (instance->max + 1000)) && (*min >= instance->min)) {
*min = instance->min;
*max = instance->max;
*maxdata = ME6000_AO_MAX_DATA;
*range = 0;
} else {
PERROR("No matching range available.\n");
return ME_ERRNO_NO_RANGE;
}
} else {
PERROR("Invalid physical unit specified.\n");
return ME_ERRNO_INVALID_UNIT;
}
return ME_ERRNO_SUCCESS;
}
static int me6000_ao_query_number_ranges(me_subdevice_t *subdevice,
int unit, int *count)
{
me6000_ao_subdevice_t *instance;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if ((unit == ME_UNIT_VOLT) || (unit == ME_UNIT_ANY)) {
*count = 1;
} else {
*count = 0;
}
return ME_ERRNO_SUCCESS;
}
static int me6000_ao_query_range_info(me_subdevice_t *subdevice,
int range,
int *unit,
int *min, int *max, int *maxdata)
{
me6000_ao_subdevice_t *instance;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (range == 0) {
*unit = ME_UNIT_VOLT;
*min = instance->min;
*max = instance->max;
*maxdata = ME6000_AO_MAX_DATA;
} else {
PERROR("Invalid range number specified.\n");
return ME_ERRNO_INVALID_RANGE;
}
return ME_ERRNO_SUCCESS;
}
static int me6000_ao_query_timer(me_subdevice_t *subdevice,
int timer,
int *base_frequency,
long long *min_ticks, long long *max_ticks)
{
me6000_ao_subdevice_t *instance;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (instance->fifo) { //Streaming device.
*base_frequency = ME6000_AO_BASE_FREQUENCY;
if (timer == ME_TIMER_ACQ_START) {
*min_ticks = ME6000_AO_MIN_ACQ_TICKS;
*max_ticks = ME6000_AO_MAX_ACQ_TICKS;
} else if (timer == ME_TIMER_CONV_START) {
*min_ticks = ME6000_AO_MIN_CHAN_TICKS;
*max_ticks = ME6000_AO_MAX_CHAN_TICKS;
}
} else { //Not streaming device!
*base_frequency = 0;
*min_ticks = 0;
*max_ticks = 0;
}
return ME_ERRNO_SUCCESS;
}
static int me6000_ao_query_number_channels(me_subdevice_t *subdevice,
int *number)
{
me6000_ao_subdevice_t *instance;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
*number = 1;
return ME_ERRNO_SUCCESS;
}
static int me6000_ao_query_subdevice_type(me_subdevice_t *subdevice,
int *type, int *subtype)
{
me6000_ao_subdevice_t *instance;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
*type = ME_TYPE_AO;
*subtype =
(instance->
fifo & ME6000_AO_HAS_FIFO) ? ME_SUBTYPE_STREAMING :
ME_SUBTYPE_SINGLE;
return ME_ERRNO_SUCCESS;
}
static int me6000_ao_query_subdevice_caps(me_subdevice_t *subdevice, int *caps)
{
me6000_ao_subdevice_t *instance;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
*caps =
ME_CAPS_AO_TRIG_SYNCHRONOUS | ((instance->fifo) ? ME_CAPS_AO_FIFO :
ME_CAPS_NONE);
return ME_ERRNO_SUCCESS;
}
static int me6000_ao_query_subdevice_caps_args(struct me_subdevice *subdevice,
int cap, int *args, int count)
{
me6000_ao_subdevice_t *instance;
int err = ME_ERRNO_SUCCESS;
instance = (me6000_ao_subdevice_t *) subdevice;
PDEBUG("executed. idx=%d\n", instance->ao_idx);
if (count != 1) {
PERROR("Invalid capability argument count.\n");
return ME_ERRNO_INVALID_CAP_ARG_COUNT;
}
switch (cap) {
case ME_CAP_AI_FIFO_SIZE:
args[0] = (instance->fifo) ? ME6000_AO_FIFO_COUNT : 0;
break;
case ME_CAP_AI_BUFFER_SIZE:
args[0] =
(instance->circ_buf.buf) ? ME6000_AO_CIRC_BUF_COUNT : 0;
break;
default:
PERROR("Invalid capability.\n");
err = ME_ERRNO_INVALID_CAP;
args[0] = 0;
}
return err;
}