6012 lines
165 KiB
C
6012 lines
165 KiB
C
/**
|
|
* @file me4600_ao.c
|
|
*
|
|
* @brief ME-4000 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
|
|
|
|
///Common part. (For normal and Bosch builds.)
|
|
|
|
/* Includes
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
#include <asm/io.h>
|
|
#include <asm/uaccess.h>
|
|
#include <linux/types.h>
|
|
#include <linux/version.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/delay.h>
|
|
|
|
#include "medefines.h"
|
|
#include "meinternal.h"
|
|
#include "meerror.h"
|
|
|
|
#include "medebug.h"
|
|
#include "meids.h"
|
|
#include "me4600_reg.h"
|
|
#include "me4600_ao_reg.h"
|
|
#include "me4600_ao.h"
|
|
|
|
/* Defines
|
|
*/
|
|
|
|
static int me4600_ao_query_range_by_min_max(me_subdevice_t * subdevice,
|
|
int unit,
|
|
int *min,
|
|
int *max, int *maxdata, int *range);
|
|
|
|
static int me4600_ao_query_number_ranges(me_subdevice_t * subdevice,
|
|
int unit, int *count);
|
|
|
|
static int me4600_ao_query_range_info(me_subdevice_t * subdevice,
|
|
int range,
|
|
int *unit,
|
|
int *min, int *max, int *maxdata);
|
|
|
|
static int me4600_ao_query_timer(me_subdevice_t * subdevice,
|
|
int timer,
|
|
int *base_frequency,
|
|
long long *min_ticks, long long *max_ticks);
|
|
|
|
static int me4600_ao_query_number_channels(me_subdevice_t * subdevice,
|
|
int *number);
|
|
|
|
static int me4600_ao_query_subdevice_type(me_subdevice_t * subdevice,
|
|
int *type, int *subtype);
|
|
|
|
static int me4600_ao_query_subdevice_caps(me_subdevice_t * subdevice,
|
|
int *caps);
|
|
|
|
static int me4600_ao_query_subdevice_caps_args(struct me_subdevice *subdevice,
|
|
int cap, int *args, int count);
|
|
|
|
#ifndef BOSCH
|
|
/// @note NORMAL BUILD
|
|
/// @author Krzysztof Gantzke (k.gantzke@meilhaus.de)
|
|
/* Includes
|
|
*/
|
|
|
|
# include <linux/workqueue.h>
|
|
|
|
/* Defines
|
|
*/
|
|
|
|
/** Remove subdevice.
|
|
*/
|
|
static void me4600_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 me4600_ao_io_reset_subdevice(me_subdevice_t * subdevice,
|
|
struct file *filep, int flags);
|
|
|
|
/** Set output as single
|
|
*/
|
|
static int me4600_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 me4600_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 me4600_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 me4600_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 me4600_ao_io_stream_new_values(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int time_out, int *count, int flags);
|
|
|
|
/** Start streaming.
|
|
*/
|
|
static int me4600_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 me4600_ao_io_stream_status(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int wait,
|
|
int *status, int *values, int flags);
|
|
|
|
/** Stop streaming.
|
|
*/
|
|
static int me4600_ao_io_stream_stop(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int stop_mode, int flags);
|
|
|
|
/** Write datas to buffor.
|
|
*/
|
|
static int me4600_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 me4600_ao_isr(int irq, void *dev_id
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
|
|
, struct pt_regs *regs
|
|
#endif
|
|
);
|
|
/** Copy data from circular buffer to fifo (fast) in wraparound mode.
|
|
*/
|
|
int inline ao_write_data_wraparound(me4600_ao_subdevice_t * instance, int count,
|
|
int start_pos);
|
|
|
|
/** Copy data from circular buffer to fifo (fast).
|
|
*/
|
|
int inline ao_write_data(me4600_ao_subdevice_t * instance, int count,
|
|
int start_pos);
|
|
|
|
/** Copy data from circular buffer to fifo (slow).
|
|
*/
|
|
int inline ao_write_data_pooling(me4600_ao_subdevice_t * instance, int count,
|
|
int start_pos);
|
|
|
|
/** Copy data from user space to circular buffer.
|
|
*/
|
|
int inline ao_get_data_from_user(me4600_ao_subdevice_t * instance, int count,
|
|
int *user_values);
|
|
|
|
/** Stop presentation. Preserve FIFOs.
|
|
*/
|
|
int inline ao_stop_immediately(me4600_ao_subdevice_t * instance);
|
|
|
|
/** Task for asynchronical state verifying.
|
|
*/
|
|
static void me4600_ao_work_control_task(
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
|
|
void *subdevice
|
|
#else
|
|
struct work_struct *work
|
|
#endif
|
|
);
|
|
/* Functions
|
|
*/
|
|
|
|
static int me4600_ao_io_reset_subdevice(me_subdevice_t * subdevice,
|
|
struct file *filep, int flags)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
uint32_t tmp;
|
|
|
|
instance = (me4600_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 &=
|
|
~((ME4600_AO_SYNC_HOLD | ME4600_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 &=
|
|
~((ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG) << instance->
|
|
ao_idx);
|
|
spin_unlock(instance->preload_reg_lock);
|
|
|
|
//Set single mode, dissable FIFO, dissable external trigger, set output to analog, block interrupt.
|
|
outl(ME4600_AO_MODE_SINGLE | ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP | ME4600_AO_CTRL_BIT_RESET_IRQ,
|
|
instance->ctrl_reg);
|
|
PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n", instance->reg_base,
|
|
instance->ctrl_reg - instance->reg_base,
|
|
ME4600_AO_MODE_SINGLE | ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP |
|
|
ME4600_AO_CTRL_BIT_RESET_IRQ);
|
|
|
|
//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 me4600_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)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
uint32_t ctrl;
|
|
uint32_t sync;
|
|
unsigned long cpu_flags;
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
PDEBUG("executed. idx=%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;
|
|
}
|
|
|
|
switch (trig_type) {
|
|
case ME_TRIG_TYPE_SW:
|
|
if (trig_edge != ME_TRIG_EDGE_NONE) {
|
|
PERROR
|
|
("Invalid trigger edge. Software trigger has not edge.\n");
|
|
return ME_ERRNO_INVALID_TRIG_EDGE;
|
|
}
|
|
break;
|
|
|
|
case 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;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
PERROR
|
|
("Invalid trigger type. Trigger must be software or digital.\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 (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;
|
|
}
|
|
// Set control register.
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
// Set stop bit. Stop streaming mode.
|
|
ctrl = inl(instance->ctrl_reg);
|
|
//Reset all bits.
|
|
ctrl = ME4600_AO_CTRL_BIT_IMMEDIATE_STOP | ME4600_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 |= ME4600_AO_CTRL_BIT_EX_TRIG_EDGE | ME4600_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH;
|
|
instance->ctrl_trg =
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE |
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH;
|
|
} else if (trig_edge == ME_TRIG_EDGE_FALLING) {
|
|
// ctrl |= ME4600_AO_CTRL_BIT_EX_TRIG_EDGE;
|
|
instance->ctrl_trg = ME4600_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);
|
|
|
|
// Set preload/synchronization register.
|
|
spin_lock(instance->preload_reg_lock);
|
|
if (trig_type == ME_TRIG_TYPE_SW) {
|
|
*instance->preload_flags &=
|
|
~(ME4600_AO_SYNC_EXT_TRIG << instance->ao_idx);
|
|
} else //if (trig_type == ME_TRIG_TYPE_EXT_DIGITAL)
|
|
{
|
|
*instance->preload_flags |=
|
|
ME4600_AO_SYNC_EXT_TRIG << instance->ao_idx;
|
|
}
|
|
|
|
if (trig_chan == ME_TRIG_CHAN_DEFAULT) {
|
|
*instance->preload_flags &=
|
|
~(ME4600_AO_SYNC_HOLD << instance->ao_idx);
|
|
} else //if (trig_chan == ME_TRIG_CHAN_SYNCHRONOUS)
|
|
{
|
|
*instance->preload_flags |=
|
|
ME4600_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 &= ~(ME4600_AO_SYNC_EXT_TRIG << instance->ao_idx);
|
|
sync |= ME4600_AO_SYNC_HOLD << instance->ao_idx;
|
|
|
|
//Output configured in default (safe) mode.
|
|
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 me4600_ao_io_single_read(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int channel,
|
|
int *value, int time_out, int flags)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
|
|
unsigned long j;
|
|
unsigned long delay = 0;
|
|
|
|
instance = (me4600_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 (time_out < 0) {
|
|
PERROR("Invalid timeout specified.\n");
|
|
return ME_ERRNO_INVALID_TIMEOUT;
|
|
}
|
|
|
|
if (channel != 0) {
|
|
PERROR("Invalid channel number specified.\n");
|
|
return ME_ERRNO_INVALID_CHANNEL;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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 +
|
|
1 : 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 me4600_ao_io_single_write(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int channel,
|
|
int value, int time_out, int flags)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
unsigned long cpu_flags;
|
|
unsigned long j;
|
|
unsigned long delay = 0x0;
|
|
|
|
//Registry handling variables.
|
|
uint32_t sync_mask;
|
|
uint32_t mode;
|
|
uint32_t tmp;
|
|
uint32_t ctrl;
|
|
uint32_t status;
|
|
|
|
instance = (me4600_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 (time_out < 0) {
|
|
PERROR("Invalid timeout specified.\n");
|
|
return ME_ERRNO_INVALID_TIMEOUT;
|
|
}
|
|
|
|
if (value & ~ME4600_AO_MAX_DATA) {
|
|
PERROR("Invalid value provided.\n");
|
|
return ME_ERRNO_VALUE_OUT_OF_RANGE;
|
|
}
|
|
|
|
if (channel != 0) {
|
|
PERROR("Invalid channel number specified.\n");
|
|
return ME_ERRNO_INVALID_CHANNEL;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
|
|
ctrl = inl(instance->ctrl_reg);
|
|
|
|
if (!instance->fifo) { //No FIFO
|
|
//Set the single mode.
|
|
ctrl &= ~ME4600_AO_CTRL_MODE_MASK;
|
|
|
|
//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);
|
|
} else { // mix-mode
|
|
//Set speed
|
|
outl(ME4600_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)ME4600_AO_MIN_CHAN_TICKS);
|
|
instance->hardware_stop_delay = HZ / 10; //100ms
|
|
|
|
status = inl(instance->status_reg);
|
|
|
|
//Set the continous mode.
|
|
ctrl &= ~ME4600_AO_CTRL_MODE_MASK;
|
|
ctrl |= ME4600_AO_MODE_CONTINUOUS;
|
|
|
|
//Prepare FIFO
|
|
if (!(ctrl & ME4600_AO_CTRL_BIT_ENABLE_FIFO)) { //FIFO wasn't enabeled. Do it.
|
|
PINFO("Enableing FIFO.\n");
|
|
ctrl &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
ctrl |=
|
|
ME4600_AO_CTRL_BIT_ENABLE_FIFO |
|
|
ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
} else { //Check if FIFO is empty
|
|
if (status & ME4600_AO_STATUS_BIT_EF) { //FIFO not empty
|
|
PINFO("Reseting FIFO.\n");
|
|
ctrl &=
|
|
~(ME4600_AO_CTRL_BIT_ENABLE_FIFO |
|
|
ME4600_AO_CTRL_BIT_ENABLE_IRQ);
|
|
ctrl |= ME4600_AO_CTRL_BIT_RESET_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 |=
|
|
ME4600_AO_CTRL_BIT_ENABLE_FIFO |
|
|
ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
} else { //FIFO empty, only interrupt needs to be disabled!
|
|
ctrl &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
ctrl |= ME4600_AO_CTRL_BIT_RESET_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);
|
|
|
|
//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);
|
|
}
|
|
}
|
|
|
|
mode = *instance->preload_flags >> instance->ao_idx;
|
|
mode &= (ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG);
|
|
|
|
PINFO("Triggering mode: 0x%x\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: //Individual software
|
|
ctrl &= ~ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG;
|
|
|
|
if (!instance->fifo) { // No FIFO - In this case resetting 'ME4600_AO_SYNC_HOLD' will trigger output.
|
|
if ((sync_mask & ((ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG) << instance->ao_idx)) != ME4600_AO_SYNC_HOLD) { //Now we can set correct mode. This is exception. It is set to synchronous and triggered later.
|
|
sync_mask &=
|
|
~(ME4600_AO_SYNC_EXT_TRIG << instance->
|
|
ao_idx);
|
|
sync_mask |=
|
|
ME4600_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 { // FIFO
|
|
if ((sync_mask & ((ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG) << instance->ao_idx)) != 0x0) { //Now we can set correct mode.
|
|
sync_mask &=
|
|
~((ME4600_AO_SYNC_EXT_TRIG |
|
|
ME4600_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 ME4600_AO_SYNC_EXT_TRIG: //Individual hardware
|
|
ctrl |= ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG;
|
|
|
|
if (!instance->fifo) { // No FIFO - In this case resetting 'ME4600_AO_SYNC_HOLD' will trigger output.
|
|
if ((sync_mask & ((ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG) << instance->ao_idx)) != ME4600_AO_SYNC_HOLD) { //Now we can set correct mode
|
|
sync_mask &=
|
|
~(ME4600_AO_SYNC_EXT_TRIG << instance->
|
|
ao_idx);
|
|
sync_mask |=
|
|
ME4600_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 { // FIFO
|
|
if ((sync_mask & ((ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG) << instance->ao_idx)) != 0x0) { //Now we can set correct mode.
|
|
sync_mask &=
|
|
~((ME4600_AO_SYNC_EXT_TRIG |
|
|
ME4600_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 ME4600_AO_SYNC_HOLD: //Synchronous software
|
|
ctrl &= ~ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG;
|
|
|
|
// if((sync_mask & ((ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG) << instance->ao_idx)) != ME4600_AO_SYNC_HOLD)
|
|
if ((sync_mask & ((ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG) << instance->ao_idx)) != (ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG)) { //Now we can set correct mode
|
|
sync_mask |=
|
|
ME4600_AO_SYNC_EXT_TRIG << instance->ao_idx;
|
|
// sync_mask &= ~(ME4600_AO_SYNC_EXT_TRIG << instance->ao_idx);
|
|
sync_mask |= ME4600_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 (ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG): //Synchronous hardware
|
|
ctrl |= ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG;
|
|
if ((sync_mask & ((ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG) << instance->ao_idx)) != (ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG)) { //Now we can set correct mode
|
|
sync_mask |=
|
|
(ME4600_AO_SYNC_HOLD | ME4600_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);
|
|
}
|
|
break;
|
|
}
|
|
// spin_unlock(instance->preload_reg_lock); // Moved down.
|
|
|
|
//Activate ISM (remove 'stop' bits)
|
|
ctrl &=
|
|
~(ME4600_AO_CTRL_BIT_EX_TRIG_EDGE |
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH);
|
|
ctrl |= instance->ctrl_trg;
|
|
ctrl &= ~(ME4600_AO_CTRL_BIT_STOP | ME4600_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!
|
|
|
|
if (!instance->fifo) { //No FIFO
|
|
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 &= ~(ME4600_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);
|
|
} else if (!mode) { // Add this channel to list
|
|
outl(sync_mask &
|
|
~(ME4600_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 & ~(ME4600_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);
|
|
}
|
|
|
|
} else { // mix-mode - begin
|
|
if (flags & ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS) { //Trigger outputs
|
|
//Add channel to start list
|
|
outl(sync_mask |
|
|
(ME4600_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 | (ME4600_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 //<== Unnecessary. Removed.
|
|
outl(sync_mask & ~(ME4600_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, tmp);
|
|
*/
|
|
//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 //<== Unnecessary. Removed.
|
|
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);
|
|
*/
|
|
}
|
|
}
|
|
spin_unlock(instance->preload_reg_lock);
|
|
|
|
j = jiffies;
|
|
instance->status = ao_status_single_run_wait;
|
|
|
|
instance->timeout.delay = delay;
|
|
instance->timeout.start_time = j;
|
|
instance->ao_control_task_flag = 1;
|
|
queue_delayed_work(instance->me4600_workqueue,
|
|
&instance->ao_control_task, 1);
|
|
|
|
if (!(flags & ME_IO_SINGLE_TYPE_WRITE_NONBLOCKING)) {
|
|
|
|
//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 (((!delay) || ((jiffies - j) <= delay))
|
|
&& (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");
|
|
} 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 me4600_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)
|
|
{
|
|
me4600_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 = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
PDEBUG("executed. idx=%d\n", instance->ao_idx);
|
|
|
|
if (!instance->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
|
|
| ME_IO_STREAM_CONFIG_BIT_PATTERN)) {
|
|
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;
|
|
}
|
|
|
|
switch (trigger->iAcqStartTrigType) {
|
|
case ME_TRIG_TYPE_SW:
|
|
if (trigger->iAcqStartTrigEdge != ME_TRIG_EDGE_NONE) {
|
|
PERROR
|
|
("Invalid acquisition start trigger edge specified.\n");
|
|
return ME_ERRNO_INVALID_ACQ_START_TRIG_EDGE;
|
|
}
|
|
break;
|
|
|
|
case ME_TRIG_TYPE_EXT_DIGITAL:
|
|
switch (trigger->iAcqStartTrigEdge) {
|
|
case ME_TRIG_EDGE_ANY:
|
|
case ME_TRIG_EDGE_RISING:
|
|
case ME_TRIG_EDGE_FALLING:
|
|
break;
|
|
|
|
default:
|
|
PERROR
|
|
("Invalid acquisition start trigger edge specified.\n");
|
|
return ME_ERRNO_INVALID_ACQ_START_TRIG_EDGE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
PERROR("Invalid acquisition start trigger type specified.\n");
|
|
return ME_ERRNO_INVALID_ACQ_START_TRIG_TYPE;
|
|
}
|
|
|
|
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 < ME4600_AO_MIN_CHAN_TICKS)
|
|
|| (conv_ticks > ME4600_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;
|
|
}
|
|
}
|
|
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;
|
|
|
|
if ((flags & ME_IO_STREAM_CONFIG_BIT_PATTERN) && !instance->bitpattern) {
|
|
PERROR("This subdevice not support output redirection.\n");
|
|
ME_SUBDEVICE_EXIT;
|
|
return ME_ERRNO_INVALID_FLAGS;
|
|
}
|
|
//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 =
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP | ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_RESET_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);
|
|
|
|
//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 |= ME4600_AO_MODE_WRAPAROUND;
|
|
instance->mode = ME4600_AO_HW_WRAP_MODE;
|
|
} else { //Software wraparound
|
|
PINFO("Software wraparound.\n");
|
|
ctrl |= ME4600_AO_MODE_CONTINUOUS;
|
|
instance->mode = ME4600_AO_SW_WRAP_MODE;
|
|
}
|
|
} else { //Continous
|
|
PINFO("Continous.\n");
|
|
ctrl |= ME4600_AO_MODE_CONTINUOUS;
|
|
instance->mode = ME4600_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 = ME4600_AO_EXT_TRIG;
|
|
/*
|
|
ctrl |= ME4600_AO_CTRL_BIT_ENABLE_EX_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 |= ME4600_AO_CTRL_BIT_EX_TRIG_EDGE;
|
|
instance->ctrl_trg = ME4600_AO_CTRL_BIT_EX_TRIG_EDGE;
|
|
break;
|
|
|
|
case ME_TRIG_EDGE_ANY:
|
|
PINFO("Set the trigger edge: both edges.\n");
|
|
// ctrl |= ME4600_AO_CTRL_BIT_EX_TRIG_EDGE | ME4600_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH;
|
|
instance->ctrl_trg =
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE |
|
|
ME4600_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 = ME4600_AO_ACQ_STOP_MODE;
|
|
instance->stop_count = trigger->iAcqStopCount;
|
|
} else if (trigger->iScanStopTrigType == ME_TRIG_TYPE_COUNT) { //Amount of 'scans'
|
|
instance->stop_mode = ME4600_AO_SCAN_STOP_MODE;
|
|
instance->stop_count = trigger->iScanStopCount;
|
|
} else { //Infinite
|
|
instance->stop_mode = ME4600_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 |= ME4600_AO_SYNC_HOLD;
|
|
if (trigger->iAcqStartTrigType == ME_TRIG_TYPE_EXT_DIGITAL) { //Externaly triggered
|
|
PINFO("Synchronous start. Externaly trigger active.\n");
|
|
instance->start_mode |= ME4600_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) / ME4600_AO_BASE_FREQUENCY; //<== MUST be with cast!
|
|
|
|
//Conect outputs to analog or digital port.
|
|
if (flags & ME_IO_STREAM_CONFIG_BIT_PATTERN) {
|
|
ctrl |= ME4600_AO_CTRL_BIT_ENABLE_DO;
|
|
}
|
|
// 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 me4600_ao_io_stream_new_values(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int time_out, int *count, int flags)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
long t = 0;
|
|
long j;
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
PDEBUG("executed. idx=%d\n", instance->ao_idx);
|
|
|
|
if (!instance->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)
|
|
&
|
|
ME4600_AO_STATUS_BIT_FSM)),
|
|
t);
|
|
|
|
if (!(inl(instance->status_reg) & ME4600_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 me4600_ao_io_stream_start(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int start_mode, int time_out, int flags)
|
|
{
|
|
me4600_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 = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
PDEBUG("executed. idx=%d\n", instance->ao_idx);
|
|
|
|
if (!instance->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 == ME4600_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 = ME4600_AO_MAX_DATA + 1;
|
|
instance->single_value_in_fifo = ME4600_AO_MAX_DATA + 1;
|
|
|
|
//Setting stop points
|
|
if (instance->stop_mode == ME4600_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 & ME4600_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 |=
|
|
ME4600_AO_CTRL_BIT_ENABLE_FIFO |
|
|
ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
|
|
instance->preloaded_count = 0;
|
|
instance->data_count = 0;
|
|
} else { //Block IRQ
|
|
ctrl |= ME4600_AO_CTRL_BIT_RESET_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 | ME4600_AO_CTRL_BIT_RESET_IRQ);
|
|
|
|
//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 & ME4600_AO_STATUS_BIT_EF)) { //FIFO empty
|
|
if (instance->stop_data_count == 0) {
|
|
count = ME4600_AO_FIFO_COUNT;
|
|
} else {
|
|
count =
|
|
(ME4600_AO_FIFO_COUNT <
|
|
instance->
|
|
stop_data_count) ? ME4600_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 &=
|
|
~((ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG) << instance->
|
|
ao_idx);
|
|
synch |=
|
|
(instance->start_mode & ~ME4600_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 == ME4600_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 == ME4600_AO_INF_STOP_MODE)
|
|
&& (circ_buffer_count <= ME4600_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 &= ~ME4600_AO_CTRL_MODE_MASK;
|
|
ctrl |= ME4600_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
|
|
ctrl &= ~(ME4600_AO_CTRL_BIT_STOP | ME4600_AO_CTRL_BIT_IMMEDIATE_STOP);
|
|
if (instance->start_mode == ME4600_AO_EXT_TRIG) { // External trigger.
|
|
PINFO("External trigger.\n");
|
|
ctrl |= ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG;
|
|
}
|
|
if (!(status & ME4600_AO_STATUS_BIT_HF)) { //More than half!
|
|
if ((ctrl & ME4600_AO_CTRL_MODE_MASK) == ME4600_AO_MODE_CONTINUOUS) { //Enable IRQ only when hardware_continous is set and FIFO is more than half
|
|
ctrl &= ~ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
ctrl |= ME4600_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
|
|
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 | (ME4600_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 | (ME4600_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
|
|
/*
|
|
//Remove channel from start list. // <== Unnecessary. Removed.
|
|
spin_lock(instance->preload_reg_lock);
|
|
synch = inl(instance->preload_reg);
|
|
outl(synch & ~(ME4600_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 & ~(ME4600_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. // <== Unnecessary. Removed.
|
|
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
|
|
ref = jiffies;
|
|
instance->timeout.delay = delay;
|
|
instance->timeout.start_time = ref;
|
|
|
|
if (status & ME4600_AO_STATUS_BIT_HF) { //Less than half but not empty!
|
|
PINFO("Less than half.\n");
|
|
if (instance->stop_data_count != 0) {
|
|
count = ME4600_AO_FIFO_COUNT / 2;
|
|
} else {
|
|
count =
|
|
((ME4600_AO_FIFO_COUNT / 2) <
|
|
instance->stop_data_count) ? ME4600_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 == ME4600_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 & ME4600_AO_STATUS_BIT_HF)) { //More than half!
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
ctrl = inl(instance->ctrl_reg);
|
|
ctrl &= ~ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
ctrl |= ME4600_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 != ME4600_AO_INF_STOP_MODE)
|
|
&& (instance->mode == ME4600_AO_SW_WRAP_MODE)
|
|
&& (circ_buffer_count <= (ME4600_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)) & ME4600_AO_STATUS_BIT_HF)) { //FIFO is more than half. Enable IRQ and end copy.
|
|
spin_lock_irqsave(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
ctrl = inl(instance->ctrl_reg);
|
|
ctrl &= ~ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
ctrl |= ME4600_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->me4600_workqueue,
|
|
&instance->ao_control_task, 1);
|
|
|
|
if (start_mode == ME_START_MODE_BLOCKING) { //Wait for start.
|
|
//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;
|
|
} else 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");
|
|
} 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 me4600_ao_io_stream_status(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int wait,
|
|
int *status, int *values, int flags)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
PDEBUG("executed. idx=%d\n", instance->ao_idx);
|
|
|
|
if (!instance->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) & ME4600_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 me4600_ao_io_stream_stop(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int stop_mode, int flags)
|
|
{ // Stop work and empty buffer and FIFO
|
|
int err = ME_ERRNO_SUCCESS;
|
|
me4600_ao_subdevice_t *instance;
|
|
unsigned long cpu_flags;
|
|
volatile uint32_t ctrl;
|
|
|
|
instance = (me4600_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) {
|
|
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) & ME4600_AO_CTRL_MODE_MASK;
|
|
if (ctrl == ME4600_AO_MODE_WRAPAROUND) { //Hardware wraparound => Hardware stop.
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
ctrl = inl(instance->ctrl_reg);
|
|
ctrl |=
|
|
ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
ctrl &= ~ME4600_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);
|
|
}
|
|
//Only runing process will interrupt this call. Events are signaled when status change.
|
|
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 |=
|
|
ME4600_AO_CTRL_BIT_STOP | ME4600_AO_CTRL_BIT_IMMEDIATE_STOP |
|
|
ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
ctrl &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
if (!flags) { //Reset FIFO
|
|
ctrl &= ~ME4600_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);
|
|
|
|
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 me4600_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;
|
|
me4600_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 = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
PDEBUG("executed. idx=%d\n", instance->ao_idx);
|
|
|
|
//Checking arguments
|
|
if (!instance->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;
|
|
}
|
|
/// @note If no 'pre-load' is used. stream_start() will move data to FIFO.
|
|
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 starting engine.
|
|
break;
|
|
|
|
default:
|
|
PERROR("Invalid write mode specified.\n");
|
|
return ME_ERRNO_INVALID_WRITE_MODE;
|
|
}
|
|
|
|
if (instance->mode & ME4600_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 == ME4600_AO_HW_WRAP_MODE) && (write_mode != ME_WRITE_MODE_PRELOAD)) { // hardware wrap_around mode.
|
|
//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 & ME4600_AO_CTRL_BIT_ENABLE_FIFO)) { //FIFO not active. Enable it.
|
|
reg_copy |= ME4600_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 & ME4600_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 == ME4600_AO_CONTINOUS) && (reg_copy & ME4600_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 &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
reg_copy |= ME4600_AO_CTRL_BIT_RESET_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, ME4600_AO_FIFO_COUNT / 2,
|
|
0);
|
|
if (copied_values > 0) {
|
|
instance->circ_buf.tail += copied_values;
|
|
instance->circ_buf.tail &=
|
|
instance->circ_buf.mask;
|
|
continue;
|
|
}
|
|
// Activate interrupts.
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
reg_copy = inl(instance->ctrl_reg);
|
|
//reg_copy |= ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
reg_copy &= ~ME4600_AO_CTRL_BIT_RESET_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("COPING FINISH WITH 0!\n");
|
|
}
|
|
|
|
if (copied_values < 0) { //This was checked and never should happend!
|
|
PERROR_CRITICAL
|
|
("COPING FINISH WITH AN 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 & ME4600_AO_WRAP_MODE) { //Error too much datas! Wraparound is limited in size!
|
|
PERROR
|
|
("Too much data for wraparound mode! Exceeded size of %ld.\n",
|
|
ME4600_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, ME4600_AO_FIFO_COUNT,
|
|
instance->preloaded_count);
|
|
instance->preloaded_count += copied_values;
|
|
instance->data_count += copied_values;
|
|
|
|
if ((instance->mode == ME4600_AO_HW_WRAP_MODE)
|
|
&& (me_circ_buf_values(&instance->circ_buf) >
|
|
ME4600_AO_FIFO_COUNT)) {
|
|
PERROR
|
|
("Too much data for hardware wraparound mode! Exceeded size of %d.\n",
|
|
ME4600_AO_FIFO_COUNT);
|
|
err = ME_ERRNO_FIFO_BUFFER_OVERFLOW;
|
|
}
|
|
}
|
|
|
|
*count = *count - left_to_copy_from_user;
|
|
ME_SUBDEVICE_EXIT;
|
|
|
|
return err;
|
|
}
|
|
static irqreturn_t me4600_ao_isr(int irq, void *dev_id
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
|
|
, struct pt_regs *regs
|
|
#endif
|
|
)
|
|
{
|
|
me4600_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 & (ME4600_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 &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
ctrl |=
|
|
ME4600_AO_CTRL_BIT_RESET_IRQ |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP | ME4600_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 & ME4600_AO_STATUS_BIT_FSM)) { //Too late. Not working! END? BROKEN PIPE?
|
|
PDEBUG("Interrupt come but ISM is not working!\n");
|
|
//Block interrupts. Stop machine.
|
|
ctrl = inl(instance->ctrl_reg);
|
|
ctrl &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
ctrl |=
|
|
ME4600_AO_CTRL_BIT_RESET_IRQ | ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_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);
|
|
|
|
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 & ME4600_AO_STATUS_BIT_HF) { //OK less than half
|
|
|
|
//Block interrupts
|
|
ctrl = inl(instance->ctrl_reg);
|
|
ctrl &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
ctrl |= ME4600_AO_CTRL_BIT_RESET_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 : ME4600_AO_FIFO_COUNT / 2;
|
|
if (ME4600_AO_FIFO_COUNT / 2 < count) {
|
|
count = ME4600_AO_FIFO_COUNT / 2;
|
|
}
|
|
//Copy data
|
|
if (instance->mode == ME4600_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 == ME4600_AO_SW_WRAP_MODE) && ((ctrl & ME4600_AO_CTRL_MODE_MASK) == ME4600_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)) & ME4600_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 &= ~ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
ctrl |= ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
} else { //Normal work but there are no more data in buffer. Interrupt active but blocked. stream_write() will unblock it.
|
|
PDEBUG
|
|
("No data in software buffer. Interrupt blocked.\n");
|
|
ctrl |= ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
}
|
|
} 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");
|
|
//Reset pending interrupt
|
|
ctrl = inl(instance->ctrl_reg);
|
|
ctrl |= ME4600_AO_CTRL_BIT_RESET_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 &= ~ME4600_AO_CTRL_BIT_RESET_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);
|
|
}
|
|
|
|
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);
|
|
|
|
//Inform user
|
|
wake_up_interruptible_all(&instance->wait_queue);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static void me4600_ao_destructor(struct me_subdevice *subdevice)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
PDEBUG("executed. idx=%d\n", instance->ao_idx);
|
|
|
|
instance->ao_control_task_flag = 0;
|
|
|
|
// Reset subdevice to asure clean exit.
|
|
me4600_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) {
|
|
if (instance->irq) {
|
|
free_irq(instance->irq, instance);
|
|
instance->irq = 0;
|
|
}
|
|
|
|
if (instance->circ_buf.buf) {
|
|
free_pages((unsigned long)instance->circ_buf.buf,
|
|
ME4600_AO_CIRC_BUF_SIZE_ORDER);
|
|
}
|
|
instance->circ_buf.buf = NULL;
|
|
}
|
|
|
|
me_subdevice_deinit(&instance->base);
|
|
kfree(instance);
|
|
}
|
|
|
|
me4600_ao_subdevice_t *me4600_ao_constructor(uint32_t reg_base,
|
|
spinlock_t * preload_reg_lock,
|
|
uint32_t * preload_flags,
|
|
int ao_idx,
|
|
int fifo,
|
|
int irq,
|
|
struct workqueue_struct *me4600_wq)
|
|
{
|
|
me4600_ao_subdevice_t *subdevice;
|
|
int err;
|
|
|
|
PDEBUG("executed. idx=%d\n", ao_idx);
|
|
|
|
// Allocate memory for subdevice instance.
|
|
subdevice = kmalloc(sizeof(me4600_ao_subdevice_t), GFP_KERNEL);
|
|
|
|
if (!subdevice) {
|
|
PERROR("Cannot get memory for subdevice instance.\n");
|
|
return NULL;
|
|
}
|
|
|
|
memset(subdevice, 0, sizeof(me4600_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;
|
|
|
|
// Store analog output index.
|
|
subdevice->ao_idx = ao_idx;
|
|
|
|
// Store if analog output has fifo.
|
|
subdevice->fifo = (ao_idx < fifo) ? 1 : 0;
|
|
|
|
if (subdevice->fifo) { // Allocate and initialize circular buffer.
|
|
subdevice->circ_buf.mask = ME4600_AO_CIRC_BUF_COUNT - 1;
|
|
|
|
subdevice->circ_buf.buf =
|
|
(void *)__get_free_pages(GFP_KERNEL,
|
|
ME4600_AO_CIRC_BUF_SIZE_ORDER);
|
|
PDEBUG("circ_buf = %p size=%ld\n", subdevice->circ_buf.buf,
|
|
ME4600_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, ME4600_AO_CIRC_BUF_SIZE);
|
|
} else { // No FIFO.
|
|
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;
|
|
|
|
// Register interrupt service routine.
|
|
if (subdevice->fifo) {
|
|
subdevice->irq = irq;
|
|
if (request_irq(subdevice->irq, me4600_ao_isr,
|
|
#ifdef IRQF_DISABLED
|
|
IRQF_DISABLED | IRQF_SHARED,
|
|
#else
|
|
SA_INTERRUPT | SA_SHIRQ,
|
|
#endif
|
|
ME4600_NAME, subdevice)) {
|
|
PERROR("Cannot get interrupt line.\n");
|
|
PDEBUG("free circ_buf = %p size=%d",
|
|
subdevice->circ_buf.buf,
|
|
PAGE_SHIFT << ME4600_AO_CIRC_BUF_SIZE_ORDER);
|
|
free_pages((unsigned long)subdevice->circ_buf.buf,
|
|
ME4600_AO_CIRC_BUF_SIZE_ORDER);
|
|
me_subdevice_deinit((me_subdevice_t *) subdevice);
|
|
kfree(subdevice);
|
|
return NULL;
|
|
}
|
|
PINFO("Registered irq=%d.\n", subdevice->irq);
|
|
} else {
|
|
subdevice->irq = 0;
|
|
}
|
|
|
|
// Initialize registers.
|
|
subdevice->irq_status_reg = reg_base + ME4600_IRQ_STATUS_REG;
|
|
subdevice->preload_reg = reg_base + ME4600_AO_SYNC_REG;
|
|
if (ao_idx == 0) {
|
|
subdevice->ctrl_reg = reg_base + ME4600_AO_00_CTRL_REG;
|
|
subdevice->status_reg = reg_base + ME4600_AO_00_STATUS_REG;
|
|
subdevice->fifo_reg = reg_base + ME4600_AO_00_FIFO_REG;
|
|
subdevice->single_reg = reg_base + ME4600_AO_00_SINGLE_REG;
|
|
subdevice->timer_reg = reg_base + ME4600_AO_00_TIMER_REG;
|
|
subdevice->reg_base = reg_base;
|
|
subdevice->bitpattern = 0;
|
|
} else if (ao_idx == 1) {
|
|
subdevice->ctrl_reg = reg_base + ME4600_AO_01_CTRL_REG;
|
|
subdevice->status_reg = reg_base + ME4600_AO_01_STATUS_REG;
|
|
subdevice->fifo_reg = reg_base + ME4600_AO_01_FIFO_REG;
|
|
subdevice->single_reg = reg_base + ME4600_AO_01_SINGLE_REG;
|
|
subdevice->timer_reg = reg_base + ME4600_AO_01_TIMER_REG;
|
|
subdevice->reg_base = reg_base;
|
|
subdevice->bitpattern = 0;
|
|
} else if (ao_idx == 2) {
|
|
subdevice->ctrl_reg = reg_base + ME4600_AO_02_CTRL_REG;
|
|
subdevice->status_reg = reg_base + ME4600_AO_02_STATUS_REG;
|
|
subdevice->fifo_reg = reg_base + ME4600_AO_02_FIFO_REG;
|
|
subdevice->single_reg = reg_base + ME4600_AO_02_SINGLE_REG;
|
|
subdevice->timer_reg = reg_base + ME4600_AO_02_TIMER_REG;
|
|
subdevice->reg_base = reg_base;
|
|
subdevice->bitpattern = 0;
|
|
} else if (ao_idx == 3) {
|
|
subdevice->ctrl_reg = reg_base + ME4600_AO_03_CTRL_REG;
|
|
subdevice->status_reg = reg_base + ME4600_AO_03_STATUS_REG;
|
|
subdevice->fifo_reg = reg_base + ME4600_AO_03_FIFO_REG;
|
|
subdevice->single_reg = reg_base + ME4600_AO_03_SINGLE_REG;
|
|
subdevice->timer_reg = reg_base + ME4600_AO_03_TIMER_REG;
|
|
subdevice->reg_base = reg_base;
|
|
subdevice->bitpattern = 1;
|
|
} else {
|
|
PERROR_CRITICAL("WRONG SUBDEVICE idx=%d!", ao_idx);
|
|
me_subdevice_deinit((me_subdevice_t *) subdevice);
|
|
if (subdevice->fifo) {
|
|
free_pages((unsigned long)subdevice->circ_buf.buf,
|
|
ME4600_AO_CIRC_BUF_SIZE_ORDER);
|
|
}
|
|
subdevice->circ_buf.buf = NULL;
|
|
kfree(subdevice);
|
|
return NULL;
|
|
}
|
|
|
|
// Override base class methods.
|
|
subdevice->base.me_subdevice_destructor = me4600_ao_destructor;
|
|
subdevice->base.me_subdevice_io_reset_subdevice =
|
|
me4600_ao_io_reset_subdevice;
|
|
subdevice->base.me_subdevice_io_single_config =
|
|
me4600_ao_io_single_config;
|
|
subdevice->base.me_subdevice_io_single_read = me4600_ao_io_single_read;
|
|
subdevice->base.me_subdevice_io_single_write =
|
|
me4600_ao_io_single_write;
|
|
subdevice->base.me_subdevice_io_stream_config =
|
|
me4600_ao_io_stream_config;
|
|
subdevice->base.me_subdevice_io_stream_new_values =
|
|
me4600_ao_io_stream_new_values;
|
|
subdevice->base.me_subdevice_io_stream_write =
|
|
me4600_ao_io_stream_write;
|
|
subdevice->base.me_subdevice_io_stream_start =
|
|
me4600_ao_io_stream_start;
|
|
subdevice->base.me_subdevice_io_stream_status =
|
|
me4600_ao_io_stream_status;
|
|
subdevice->base.me_subdevice_io_stream_stop = me4600_ao_io_stream_stop;
|
|
subdevice->base.me_subdevice_query_number_channels =
|
|
me4600_ao_query_number_channels;
|
|
subdevice->base.me_subdevice_query_subdevice_type =
|
|
me4600_ao_query_subdevice_type;
|
|
subdevice->base.me_subdevice_query_subdevice_caps =
|
|
me4600_ao_query_subdevice_caps;
|
|
subdevice->base.me_subdevice_query_subdevice_caps_args =
|
|
me4600_ao_query_subdevice_caps_args;
|
|
subdevice->base.me_subdevice_query_range_by_min_max =
|
|
me4600_ao_query_range_by_min_max;
|
|
subdevice->base.me_subdevice_query_number_ranges =
|
|
me4600_ao_query_number_ranges;
|
|
subdevice->base.me_subdevice_query_range_info =
|
|
me4600_ao_query_range_info;
|
|
subdevice->base.me_subdevice_query_timer = me4600_ao_query_timer;
|
|
|
|
// Prepare work queue
|
|
subdevice->me4600_workqueue = me4600_wq;
|
|
|
|
/* workqueue API changed in kernel 2.6.20 */
|
|
#if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) )
|
|
INIT_WORK(&subdevice->ao_control_task, me4600_ao_work_control_task,
|
|
(void *)subdevice);
|
|
#else
|
|
INIT_DELAYED_WORK(&subdevice->ao_control_task,
|
|
me4600_ao_work_control_task);
|
|
#endif
|
|
|
|
if (subdevice->fifo) { // Set speed for single operations.
|
|
outl(ME4600_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).
|
|
*/
|
|
int inline ao_stop_immediately(me4600_ao_subdevice_t * instance)
|
|
{
|
|
unsigned long cpu_flags;
|
|
uint32_t ctrl;
|
|
int timeout;
|
|
int i;
|
|
|
|
timeout =
|
|
(instance->hardware_stop_delay >
|
|
(HZ / 10)) ? instance->hardware_stop_delay : HZ / 10;
|
|
for (i = 0; i <= timeout; i++) {
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
// Stop all actions. No conditions! Block interrupts. Leave FIFO untouched!
|
|
ctrl = inl(instance->ctrl_reg);
|
|
ctrl |=
|
|
ME4600_AO_CTRL_BIT_STOP | ME4600_AO_CTRL_BIT_IMMEDIATE_STOP
|
|
| ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
ctrl &=
|
|
~(ME4600_AO_CTRL_BIT_ENABLE_IRQ |
|
|
ME4600_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) & ME4600_AO_STATUS_BIT_FSM)) { // Exit.
|
|
break;
|
|
}
|
|
//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.
|
|
*/
|
|
int inline ao_write_data_wraparound(me4600_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 & ME4600_AO_STATUS_BIT_FF)) { //FIFO is full before all datas were copied!
|
|
PERROR("FIFO was full before all datas were copied! idx=%d\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("WRAPAROUND LOADED %d values. idx=%d\n", local_count,
|
|
instance->ao_idx);
|
|
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.
|
|
*/
|
|
int inline ao_write_data(me4600_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 & ME4600_AO_STATUS_BIT_FF)) { //FIFO is full before all datas were copied!
|
|
PERROR("FIFO was full before all datas were copied! idx=%d\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("FAST LOADED %d values. idx=%d\n", local_count, instance->ao_idx);
|
|
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.
|
|
*/
|
|
int inline ao_write_data_pooling(me4600_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("SLOW LOADED: Wrong count! idx=%d\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("SLOW LOADED: No data to copy! idx=%d\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 & ME4600_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("SLOW LOADED %d values. idx=%d\n", local_count, instance->ao_idx);
|
|
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.
|
|
*/
|
|
int inline ao_get_data_from_user(me4600_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
|
|
("BUFFER LOADED: get_user(0x%p) return an error: %d. idx=%d\n",
|
|
user_values + i, err, instance->ao_idx);
|
|
return -ME_ERRNO_INTERNAL;
|
|
}
|
|
/// @note The analog output in me4600 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("BUFFER LOADED %d values. idx=%d\n", copied, instance->ao_idx);
|
|
return copied;
|
|
}
|
|
|
|
/** @brief Checking actual hardware and logical state.
|
|
* @param instance The subdevice instance (pointer).
|
|
*/
|
|
static void me4600_ao_work_control_task(
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
|
|
void *subdevice
|
|
#else
|
|
struct work_struct *work
|
|
#endif
|
|
)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
unsigned long cpu_flags = 0;
|
|
uint32_t status;
|
|
uint32_t ctrl;
|
|
uint32_t synch;
|
|
int reschedule = 0;
|
|
int signaling = 0;
|
|
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
#else
|
|
instance =
|
|
container_of((void *)work, me4600_ao_subdevice_t, ao_control_task);
|
|
#endif
|
|
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);
|
|
|
|
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;
|
|
|
|
case ao_status_stream_end:
|
|
if (!instance->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 (status & ME4600_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 |=
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP | ME4600_AO_CTRL_BIT_STOP
|
|
| ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
ctrl &=
|
|
~(ME4600_AO_CTRL_BIT_ENABLE_IRQ |
|
|
ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG);
|
|
ctrl &=
|
|
~(ME4600_AO_CTRL_BIT_EX_TRIG_EDGE |
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH);
|
|
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;
|
|
|
|
// Single modes
|
|
case ao_status_single_run_wait:
|
|
case ao_status_single_run:
|
|
case ao_status_single_end_wait:
|
|
|
|
if (!(status & ME4600_AO_STATUS_BIT_FSM)) { // State machine is not working.
|
|
if (((instance->fifo)
|
|
&& (!(status & ME4600_AO_STATUS_BIT_EF)))
|
|
|| (!(instance->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;
|
|
|
|
// 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 |=
|
|
ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP |
|
|
ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
ctrl &=
|
|
~(ME4600_AO_CTRL_BIT_ENABLE_IRQ |
|
|
ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG);
|
|
/// Fix for timeout error.
|
|
ctrl &=
|
|
~(ME4600_AO_CTRL_BIT_EX_TRIG_EDGE |
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH);
|
|
if (instance->fifo) { //Disabling FIFO
|
|
ctrl &= ~ME4600_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);
|
|
|
|
spin_lock(instance->preload_reg_lock);
|
|
//Remove from synchronous start. Block triggering from this output.
|
|
synch = inl(instance->preload_reg);
|
|
synch &=
|
|
~((ME4600_AO_SYNC_HOLD | ME4600_AO_SYNC_EXT_TRIG) <<
|
|
instance->ao_idx);
|
|
if (!(instance->fifo)) { // No FIFO - set to single safe mode
|
|
synch |=
|
|
ME4600_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);
|
|
spin_unlock(instance->preload_reg_lock);
|
|
|
|
if (!(instance->fifo)) { // No FIFO
|
|
// 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;
|
|
|
|
// Stream modes
|
|
case ao_status_stream_run_wait:
|
|
if (!instance->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 & ME4600_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 & ME4600_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 |=
|
|
ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP |
|
|
ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
ctrl &=
|
|
~(ME4600_AO_CTRL_BIT_ENABLE_IRQ |
|
|
ME4600_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);
|
|
spin_lock(instance->preload_reg_lock);
|
|
//Remove from synchronous start. Block triggering from this output.
|
|
synch = inl(instance->preload_reg);
|
|
synch &=
|
|
~((ME4600_AO_SYNC_HOLD | ME4600_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) {
|
|
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 & ME4600_AO_STATUS_BIT_FSM)) { // State machine is not working. This is an error.
|
|
// BROKEN PIPE!
|
|
if (!(status & ME4600_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) {
|
|
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 & ME4600_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->me4600_workqueue,
|
|
&instance->ao_control_task, 1);
|
|
} else {
|
|
PINFO("<%s> Ending control task.\n", __func__);
|
|
}
|
|
|
|
}
|
|
#else
|
|
/// @note SPECIAL BUILD FOR BOSCH
|
|
/// @author Guenter Gebhardt
|
|
static int me4600_ao_io_reset_subdevice(me_subdevice_t * subdevice,
|
|
struct file *filep, int flags)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
uint32_t tmp;
|
|
unsigned long status;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
ME_SUBDEVICE_ENTER spin_lock_irqsave(&instance->subdevice_lock, status);
|
|
spin_lock(instance->preload_reg_lock);
|
|
tmp = inl(instance->preload_reg);
|
|
tmp &= ~(0x10001 << instance->ao_idx);
|
|
outl(tmp, instance->preload_reg);
|
|
*instance->preload_flags &= ~(0x1 << instance->ao_idx);
|
|
spin_unlock(instance->preload_reg_lock);
|
|
|
|
tmp = inl(instance->ctrl_reg);
|
|
tmp |= ME4600_AO_CTRL_BIT_STOP | ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
while (inl(instance->status_reg) & ME4600_AO_STATUS_BIT_FSM) ;
|
|
|
|
outl(ME4600_AO_CTRL_BIT_STOP | ME4600_AO_CTRL_BIT_IMMEDIATE_STOP,
|
|
instance->ctrl_reg);
|
|
|
|
outl(0x8000, instance->single_reg);
|
|
|
|
instance->single_value = 0x8000;
|
|
instance->circ_buf.head = 0;
|
|
instance->circ_buf.tail = 0;
|
|
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, status);
|
|
|
|
ME_SUBDEVICE_EXIT;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int me4600_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)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
uint32_t tmp;
|
|
unsigned long cpu_flags;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
ME_SUBDEVICE_ENTER
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
|
|
if (inl(instance->status_reg) & ME4600_AO_STATUS_BIT_FSM) {
|
|
PERROR("Subdevice is busy.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (channel == 0) {
|
|
if (single_config == 0) {
|
|
if (ref == ME_REF_AO_GROUND) {
|
|
if (trig_chan == ME_TRIG_CHAN_DEFAULT) {
|
|
if (trig_type == ME_TRIG_TYPE_SW) {
|
|
tmp = inl(instance->ctrl_reg);
|
|
tmp |=
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp, instance->ctrl_reg);
|
|
tmp =
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
spin_lock(instance->
|
|
preload_reg_lock);
|
|
tmp =
|
|
inl(instance->preload_reg);
|
|
tmp &=
|
|
~(0x10001 << instance->
|
|
ao_idx);
|
|
outl(tmp,
|
|
instance->preload_reg);
|
|
*instance->preload_flags &=
|
|
~(0x1 << instance->ao_idx);
|
|
spin_unlock(instance->
|
|
preload_reg_lock);
|
|
} else if (trig_type ==
|
|
ME_TRIG_TYPE_EXT_DIGITAL) {
|
|
if (trig_edge ==
|
|
ME_TRIG_EDGE_RISING) {
|
|
tmp =
|
|
inl(instance->
|
|
ctrl_reg);
|
|
tmp |=
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
tmp =
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP
|
|
|
|
|
ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
} else if (trig_edge ==
|
|
ME_TRIG_EDGE_FALLING)
|
|
{
|
|
tmp =
|
|
inl(instance->
|
|
ctrl_reg);
|
|
tmp |=
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
tmp =
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP
|
|
|
|
|
ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG
|
|
|
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
} else if (trig_edge ==
|
|
ME_TRIG_EDGE_ANY) {
|
|
tmp =
|
|
inl(instance->
|
|
ctrl_reg);
|
|
tmp |=
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
tmp =
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP
|
|
|
|
|
ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG
|
|
|
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE
|
|
|
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
} else {
|
|
PERROR
|
|
("Invalid trigger edge.\n");
|
|
err =
|
|
ME_ERRNO_INVALID_TRIG_EDGE;
|
|
goto ERROR;
|
|
}
|
|
|
|
spin_lock(instance->
|
|
preload_reg_lock);
|
|
|
|
tmp =
|
|
inl(instance->preload_reg);
|
|
tmp &=
|
|
~(0x10001 << instance->
|
|
ao_idx);
|
|
tmp |= 0x1 << instance->ao_idx;
|
|
outl(tmp,
|
|
instance->preload_reg);
|
|
*instance->preload_flags &=
|
|
~(0x1 << instance->ao_idx);
|
|
spin_unlock(instance->
|
|
preload_reg_lock);
|
|
} else {
|
|
PERROR
|
|
("Invalid trigger type.\n");
|
|
err =
|
|
ME_ERRNO_INVALID_TRIG_TYPE;
|
|
goto ERROR;
|
|
}
|
|
} else if (trig_chan ==
|
|
ME_TRIG_CHAN_SYNCHRONOUS) {
|
|
if (trig_type == ME_TRIG_TYPE_SW) {
|
|
tmp = inl(instance->ctrl_reg);
|
|
tmp |=
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp, instance->ctrl_reg);
|
|
tmp =
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
spin_lock(instance->
|
|
preload_reg_lock);
|
|
tmp =
|
|
inl(instance->preload_reg);
|
|
tmp &=
|
|
~(0x10001 << instance->
|
|
ao_idx);
|
|
tmp |= 0x1 << instance->ao_idx;
|
|
outl(tmp,
|
|
instance->preload_reg);
|
|
*instance->preload_flags |=
|
|
0x1 << instance->ao_idx;
|
|
spin_unlock(instance->
|
|
preload_reg_lock);
|
|
} else if (trig_type ==
|
|
ME_TRIG_TYPE_EXT_DIGITAL) {
|
|
if (trig_edge ==
|
|
ME_TRIG_EDGE_RISING) {
|
|
tmp =
|
|
inl(instance->
|
|
ctrl_reg);
|
|
tmp |=
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
tmp =
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
} else if (trig_edge ==
|
|
ME_TRIG_EDGE_FALLING)
|
|
{
|
|
tmp =
|
|
inl(instance->
|
|
ctrl_reg);
|
|
tmp |=
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
tmp =
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP
|
|
|
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
} else if (trig_edge ==
|
|
ME_TRIG_EDGE_ANY) {
|
|
tmp =
|
|
inl(instance->
|
|
ctrl_reg);
|
|
tmp |=
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
tmp =
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP
|
|
|
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE
|
|
|
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH;
|
|
outl(tmp,
|
|
instance->
|
|
ctrl_reg);
|
|
} else {
|
|
PERROR
|
|
("Invalid trigger edge.\n");
|
|
err =
|
|
ME_ERRNO_INVALID_TRIG_EDGE;
|
|
goto ERROR;
|
|
}
|
|
|
|
spin_lock(instance->
|
|
preload_reg_lock);
|
|
|
|
tmp =
|
|
inl(instance->preload_reg);
|
|
tmp |=
|
|
0x10001 << instance->ao_idx;
|
|
outl(tmp,
|
|
instance->preload_reg);
|
|
*instance->preload_flags &=
|
|
~(0x1 << instance->ao_idx);
|
|
spin_unlock(instance->
|
|
preload_reg_lock);
|
|
} else {
|
|
PERROR
|
|
("Invalid trigger type.\n");
|
|
err =
|
|
ME_ERRNO_INVALID_TRIG_TYPE;
|
|
goto ERROR;
|
|
}
|
|
} else {
|
|
PERROR
|
|
("Invalid trigger channel specified.\n");
|
|
err = ME_ERRNO_INVALID_REF;
|
|
goto ERROR;
|
|
}
|
|
} else {
|
|
PERROR("Invalid analog reference specified.\n");
|
|
err = ME_ERRNO_INVALID_REF;
|
|
goto ERROR;
|
|
}
|
|
} else {
|
|
PERROR("Invalid single config specified.\n");
|
|
err = ME_ERRNO_INVALID_SINGLE_CONFIG;
|
|
goto ERROR;
|
|
}
|
|
} else {
|
|
PERROR("Invalid channel number specified.\n");
|
|
err = ME_ERRNO_INVALID_CHANNEL;
|
|
goto ERROR;
|
|
}
|
|
|
|
ERROR:
|
|
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
|
|
ME_SUBDEVICE_EXIT;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int me4600_ao_io_single_read(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int channel,
|
|
int *value, int time_out, int flags)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
unsigned long tmp;
|
|
unsigned long cpu_flags;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
if (channel != 0) {
|
|
PERROR("Invalid channel number specified.\n");
|
|
return ME_ERRNO_INVALID_CHANNEL;
|
|
}
|
|
|
|
ME_SUBDEVICE_ENTER
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
tmp = inl(instance->ctrl_reg);
|
|
|
|
if (tmp & 0x3) {
|
|
PERROR("Not in single mode.\n");
|
|
err = ME_ERRNO_PREVIOUS_CONFIG;
|
|
} else {
|
|
*value = instance->single_value;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
|
|
ME_SUBDEVICE_EXIT;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int me4600_ao_io_single_write(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int channel,
|
|
int value, int time_out, int flags)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
unsigned long mask = 0;
|
|
unsigned long tmp;
|
|
unsigned long cpu_flags;
|
|
int i;
|
|
wait_queue_head_t queue;
|
|
unsigned long j;
|
|
unsigned long delay = 0;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
init_waitqueue_head(&queue);
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
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;
|
|
}
|
|
|
|
if (time_out) {
|
|
delay = (time_out * HZ) / 1000;
|
|
|
|
if (delay == 0)
|
|
delay = 1;
|
|
}
|
|
|
|
ME_SUBDEVICE_ENTER
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
|
|
tmp = inl(instance->ctrl_reg);
|
|
|
|
if (tmp & 0x3) {
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
PERROR("Not in single mode.\n");
|
|
err = ME_ERRNO_PREVIOUS_CONFIG;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (tmp & ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG) {
|
|
outl(value, instance->single_reg);
|
|
instance->single_value = value;
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
|
|
if (!(flags & ME_IO_SINGLE_TYPE_WRITE_NONBLOCKING)) {
|
|
j = jiffies;
|
|
|
|
while (inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM) {
|
|
interruptible_sleep_on_timeout(&queue, 1);
|
|
|
|
if (signal_pending(current)) {
|
|
PERROR
|
|
("Wait on external trigger interrupted by signal.\n");
|
|
err = ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (delay && ((jiffies - j) > delay)) {
|
|
PERROR("Timeout reached.\n");
|
|
err = ME_ERRNO_TIMEOUT;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
}
|
|
} else if ((inl(instance->preload_reg) & (0x10001 << instance->ao_idx))
|
|
== (0x10001 << instance->ao_idx)) {
|
|
if (flags & ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS) {
|
|
tmp |= ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG;
|
|
outl(tmp, instance->ctrl_reg);
|
|
outl(value, instance->single_reg);
|
|
instance->single_value = value;
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
|
|
if (!(flags & ME_IO_SINGLE_TYPE_WRITE_NONBLOCKING)) {
|
|
j = jiffies;
|
|
|
|
while (inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM) {
|
|
interruptible_sleep_on_timeout(&queue,
|
|
1);
|
|
|
|
if (signal_pending(current)) {
|
|
PERROR
|
|
("Wait on external trigger interrupted by signal.\n");
|
|
err = ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (delay && ((jiffies - j) > delay)) {
|
|
PERROR("Timeout reached.\n");
|
|
err = ME_ERRNO_TIMEOUT;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
outl(value, instance->single_reg);
|
|
instance->single_value = value;
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
}
|
|
} else if ((inl(instance->preload_reg) & (0x10001 << instance->ao_idx))
|
|
== (0x1 << instance->ao_idx)) {
|
|
outl(value, instance->single_reg);
|
|
instance->single_value = value;
|
|
|
|
PDEBUG("Synchronous SW, flags = 0x%X.\n", flags);
|
|
|
|
if (flags & ME_IO_SINGLE_TYPE_TRIG_SYNCHRONOUS) {
|
|
PDEBUG("Trigger synchronous SW.\n");
|
|
spin_lock(instance->preload_reg_lock);
|
|
tmp = inl(instance->preload_reg);
|
|
|
|
for (i = 0; i < ME4600_AO_MAX_SUBDEVICES; i++) {
|
|
if ((*instance->preload_flags & (0x1 << i))) {
|
|
if ((tmp & (0x10001 << i)) ==
|
|
(0x1 << i)) {
|
|
mask |= 0x1 << i;
|
|
}
|
|
}
|
|
}
|
|
|
|
tmp &= ~(mask);
|
|
|
|
outl(tmp, instance->preload_reg);
|
|
spin_unlock(instance->preload_reg_lock);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
} else {
|
|
outl(value, instance->single_reg);
|
|
instance->single_value = value;
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
}
|
|
|
|
ERROR:
|
|
|
|
ME_SUBDEVICE_EXIT;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int me4600_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)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
unsigned long ctrl;
|
|
unsigned long tmp;
|
|
unsigned long cpu_flags;
|
|
uint64_t conv_ticks;
|
|
unsigned int conv_start_ticks_low = trigger->iConvStartTicksLow;
|
|
unsigned int conv_start_ticks_high = trigger->iConvStartTicksHigh;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
conv_ticks =
|
|
(uint64_t) conv_start_ticks_low +
|
|
((uint64_t) conv_start_ticks_high << 32);
|
|
|
|
if (!instance->fifo) {
|
|
PERROR("Not a streaming ao.\n");
|
|
return ME_ERRNO_NOT_SUPPORTED;
|
|
}
|
|
|
|
ME_SUBDEVICE_ENTER
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
|
|
if ((inl(instance->status_reg)) & ME4600_AO_STATUS_BIT_FSM) {
|
|
PERROR("Subdevice is busy.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
ctrl = inl(instance->ctrl_reg);
|
|
ctrl |= ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(ctrl, instance->ctrl_reg);
|
|
ctrl = ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(ctrl, instance->ctrl_reg);
|
|
|
|
if (count != 1) {
|
|
PERROR("Invalid stream configuration list count specified.\n");
|
|
err = ME_ERRNO_INVALID_CONFIG_LIST_COUNT;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (config_list[0].iChannel != 0) {
|
|
PERROR("Invalid channel number specified.\n");
|
|
err = ME_ERRNO_INVALID_CHANNEL;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (config_list[0].iStreamConfig != 0) {
|
|
PERROR("Invalid stream config specified.\n");
|
|
err = ME_ERRNO_INVALID_STREAM_CONFIG;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (config_list[0].iRef != ME_REF_AO_GROUND) {
|
|
PERROR("Invalid analog reference.\n");
|
|
err = ME_ERRNO_INVALID_REF;
|
|
goto ERROR;
|
|
}
|
|
|
|
if ((trigger->iAcqStartTicksLow != 0)
|
|
|| (trigger->iAcqStartTicksHigh != 0)) {
|
|
PERROR
|
|
("Invalid acquisition start trigger argument specified.\n");
|
|
err = ME_ERRNO_INVALID_ACQ_START_ARG;
|
|
goto ERROR;
|
|
}
|
|
|
|
switch (trigger->iAcqStartTrigType) {
|
|
|
|
case ME_TRIG_TYPE_SW:
|
|
break;
|
|
|
|
case ME_TRIG_TYPE_EXT_DIGITAL:
|
|
ctrl |= ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG;
|
|
|
|
switch (trigger->iAcqStartTrigEdge) {
|
|
|
|
case ME_TRIG_EDGE_RISING:
|
|
break;
|
|
|
|
case ME_TRIG_EDGE_FALLING:
|
|
ctrl |= ME4600_AO_CTRL_BIT_EX_TRIG_EDGE;
|
|
|
|
break;
|
|
|
|
case ME_TRIG_EDGE_ANY:
|
|
ctrl |=
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE |
|
|
ME4600_AO_CTRL_BIT_EX_TRIG_EDGE_BOTH;
|
|
|
|
break;
|
|
|
|
default:
|
|
PERROR
|
|
("Invalid acquisition start trigger edge specified.\n");
|
|
|
|
err = ME_ERRNO_INVALID_ACQ_START_TRIG_EDGE;
|
|
|
|
goto ERROR;
|
|
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
PERROR("Invalid acquisition start trigger type specified.\n");
|
|
|
|
err = ME_ERRNO_INVALID_ACQ_START_TRIG_TYPE;
|
|
|
|
goto ERROR;
|
|
|
|
break;
|
|
}
|
|
|
|
switch (trigger->iScanStartTrigType) {
|
|
|
|
case ME_TRIG_TYPE_FOLLOW:
|
|
break;
|
|
|
|
default:
|
|
PERROR("Invalid scan start trigger type specified.\n");
|
|
|
|
err = ME_ERRNO_INVALID_SCAN_START_TRIG_TYPE;
|
|
|
|
goto ERROR;
|
|
|
|
break;
|
|
}
|
|
|
|
switch (trigger->iConvStartTrigType) {
|
|
|
|
case ME_TRIG_TYPE_TIMER:
|
|
if ((conv_ticks < ME4600_AO_MIN_CHAN_TICKS)
|
|
|| (conv_ticks > ME4600_AO_MAX_CHAN_TICKS)) {
|
|
PERROR
|
|
("Invalid conv start trigger argument specified.\n");
|
|
err = ME_ERRNO_INVALID_CONV_START_ARG;
|
|
goto ERROR;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
PERROR("Invalid conv start trigger type specified.\n");
|
|
|
|
err = ME_ERRNO_INVALID_CONV_START_TRIG_TYPE;
|
|
|
|
goto ERROR;
|
|
|
|
break;
|
|
}
|
|
|
|
/* Preset to hardware wraparound mode */
|
|
instance->flags &= ~(ME4600_AO_FLAGS_SW_WRAP_MODE_MASK);
|
|
|
|
switch (trigger->iScanStopTrigType) {
|
|
|
|
case ME_TRIG_TYPE_NONE:
|
|
if (flags & ME_IO_STREAM_CONFIG_WRAPAROUND) {
|
|
/* Set flags to indicate usage of software mode. */
|
|
instance->flags |= ME4600_AO_FLAGS_SW_WRAP_MODE_INF;
|
|
instance->wrap_count = 0;
|
|
instance->wrap_remaining = 0;
|
|
}
|
|
|
|
break;
|
|
|
|
case ME_TRIG_TYPE_COUNT:
|
|
if (flags & ME_IO_STREAM_CONFIG_WRAPAROUND) {
|
|
if (trigger->iScanStopCount <= 0) {
|
|
PERROR("Invalid scan stop count specified.\n");
|
|
err = ME_ERRNO_INVALID_SCAN_STOP_ARG;
|
|
goto ERROR;
|
|
}
|
|
|
|
/* Set flags to indicate usage of software mode. */
|
|
instance->flags |= ME4600_AO_FLAGS_SW_WRAP_MODE_FIN;
|
|
instance->wrap_count = trigger->iScanStopCount;
|
|
instance->wrap_remaining = trigger->iScanStopCount;
|
|
} else {
|
|
PERROR("Invalid scan stop trigger type specified.\n");
|
|
err = ME_ERRNO_INVALID_ACQ_STOP_TRIG_TYPE;
|
|
goto ERROR;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
PERROR("Invalid scan stop trigger type specified.\n");
|
|
|
|
err = ME_ERRNO_INVALID_SCAN_STOP_TRIG_TYPE;
|
|
|
|
goto ERROR;
|
|
|
|
break;
|
|
}
|
|
|
|
switch (trigger->iAcqStopTrigType) {
|
|
|
|
case ME_TRIG_TYPE_NONE:
|
|
break;
|
|
|
|
case ME_TRIG_TYPE_COUNT:
|
|
if (trigger->iScanStopTrigType != ME_TRIG_TYPE_NONE) {
|
|
PERROR("Invalid acq stop trigger type specified.\n");
|
|
err = ME_ERRNO_INVALID_ACQ_STOP_TRIG_TYPE;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (flags & ME_IO_STREAM_CONFIG_WRAPAROUND) {
|
|
if (trigger->iAcqStopCount <= 0) {
|
|
PERROR("Invalid acq stop count specified.\n");
|
|
err = ME_ERRNO_INVALID_ACQ_STOP_ARG;
|
|
goto ERROR;
|
|
}
|
|
|
|
/* Set flags to indicate usage of software mode. */
|
|
instance->flags |= ME4600_AO_FLAGS_SW_WRAP_MODE_FIN;
|
|
instance->wrap_count = trigger->iAcqStopCount;
|
|
instance->wrap_remaining = trigger->iAcqStopCount;
|
|
} else {
|
|
PERROR("Invalid acp stop trigger type specified.\n");
|
|
err = ME_ERRNO_INVALID_ACQ_STOP_TRIG_TYPE;
|
|
goto ERROR;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
PERROR("Invalid acq stop trigger type specified.\n");
|
|
err = ME_ERRNO_INVALID_ACQ_STOP_TRIG_TYPE;
|
|
goto ERROR;
|
|
break;
|
|
}
|
|
|
|
switch (trigger->iAcqStartTrigChan) {
|
|
|
|
case ME_TRIG_CHAN_DEFAULT:
|
|
spin_lock(instance->preload_reg_lock);
|
|
tmp = inl(instance->preload_reg);
|
|
tmp &= ~(0x10001 << instance->ao_idx);
|
|
outl(tmp, instance->preload_reg);
|
|
spin_unlock(instance->preload_reg_lock);
|
|
|
|
break;
|
|
|
|
case ME_TRIG_CHAN_SYNCHRONOUS:
|
|
if (trigger->iAcqStartTrigType == ME_TRIG_TYPE_SW) {
|
|
spin_lock(instance->preload_reg_lock);
|
|
tmp = inl(instance->preload_reg);
|
|
tmp &= ~(0x10001 << instance->ao_idx);
|
|
outl(tmp, instance->preload_reg);
|
|
tmp |= 0x1 << instance->ao_idx;
|
|
outl(tmp, instance->preload_reg);
|
|
spin_unlock(instance->preload_reg_lock);
|
|
} else {
|
|
ctrl &= ~(ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG);
|
|
spin_lock(instance->preload_reg_lock);
|
|
tmp = inl(instance->preload_reg);
|
|
tmp &= ~(0x10001 << instance->ao_idx);
|
|
outl(tmp, instance->preload_reg);
|
|
tmp |= 0x10000 << instance->ao_idx;
|
|
outl(tmp, instance->preload_reg);
|
|
spin_unlock(instance->preload_reg_lock);
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
PERROR("Invalid acq start trigger channel specified.\n");
|
|
err = ME_ERRNO_INVALID_ACQ_START_TRIG_CHAN;
|
|
goto ERROR;
|
|
|
|
break;
|
|
}
|
|
|
|
outl(conv_ticks - 2, instance->timer_reg);
|
|
|
|
if (flags & ME_IO_STREAM_CONFIG_BIT_PATTERN) {
|
|
if (instance->ao_idx == 3) {
|
|
ctrl |= ME4600_AO_CTRL_BIT_ENABLE_DO;
|
|
} else {
|
|
err = ME_ERRNO_INVALID_FLAGS;
|
|
goto ERROR;
|
|
}
|
|
} else {
|
|
if (instance->ao_idx == 3) {
|
|
ctrl &= ~ME4600_AO_CTRL_BIT_ENABLE_DO;
|
|
}
|
|
}
|
|
|
|
/* Set hardware mode. */
|
|
if (flags & ME_IO_STREAM_CONFIG_WRAPAROUND) {
|
|
ctrl |= ME4600_AO_CTRL_BIT_MODE_0;
|
|
} else {
|
|
ctrl |= ME4600_AO_CTRL_BIT_MODE_1;
|
|
}
|
|
|
|
PDEBUG("Preload word = 0x%X.\n", inl(instance->preload_reg));
|
|
|
|
PDEBUG("Ctrl word = 0x%lX.\n", ctrl);
|
|
outl(ctrl, instance->ctrl_reg); // Write the control word
|
|
|
|
ERROR:
|
|
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
|
|
ME_SUBDEVICE_EXIT;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int me4600_ao_io_stream_new_values(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int time_out, int *count, int flags)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
long t = 0;
|
|
long j;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
if (!instance->fifo) {
|
|
PERROR("Not a streaming ao.\n");
|
|
return ME_ERRNO_NOT_SUPPORTED;
|
|
}
|
|
|
|
if (time_out < 0) {
|
|
PERROR("Invalid time_out specified.\n");
|
|
return ME_ERRNO_INVALID_TIMEOUT;
|
|
}
|
|
|
|
if (time_out) {
|
|
t = (time_out * HZ) / 1000;
|
|
|
|
if (t == 0)
|
|
t = 1;
|
|
}
|
|
|
|
*count = 0;
|
|
|
|
ME_SUBDEVICE_ENTER;
|
|
|
|
if (t) {
|
|
j = jiffies;
|
|
wait_event_interruptible_timeout(instance->wait_queue,
|
|
((me_circ_buf_space
|
|
(&instance->circ_buf))
|
|
|| !(inl(instance->status_reg)
|
|
&
|
|
ME4600_AO_STATUS_BIT_FSM)),
|
|
t);
|
|
|
|
if (!(inl(instance->status_reg) & ME4600_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");
|
|
err = ME_ERRNO_SIGNAL;
|
|
} else if ((jiffies - j) >= t) {
|
|
PERROR("Wait on values timed out.\n");
|
|
err = ME_ERRNO_TIMEOUT;
|
|
} else {
|
|
*count = me_circ_buf_space(&instance->circ_buf);
|
|
}
|
|
} else {
|
|
wait_event_interruptible(instance->wait_queue,
|
|
((me_circ_buf_space
|
|
(&instance->circ_buf))
|
|
|| !(inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)));
|
|
|
|
if (!(inl(instance->status_reg) & ME4600_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");
|
|
err = ME_ERRNO_SIGNAL;
|
|
} else {
|
|
*count = me_circ_buf_space(&instance->circ_buf);
|
|
}
|
|
}
|
|
|
|
ME_SUBDEVICE_EXIT;
|
|
|
|
return err;
|
|
}
|
|
|
|
static void stop_immediately(me4600_ao_subdevice_t * instance)
|
|
{
|
|
unsigned long cpu_flags;
|
|
uint32_t tmp;
|
|
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
tmp = inl(instance->ctrl_reg);
|
|
tmp |= ME4600_AO_CTRL_BIT_STOP | ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
while (inl(instance->status_reg) & ME4600_AO_STATUS_BIT_FSM) ;
|
|
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
}
|
|
|
|
static int me4600_ao_io_stream_start(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int start_mode, int time_out, int flags)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
unsigned long cpu_flags = 0;
|
|
unsigned long ref;
|
|
unsigned long tmp;
|
|
unsigned long delay = 0;
|
|
wait_queue_head_t queue;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
init_waitqueue_head(&queue);
|
|
|
|
if (time_out < 0) {
|
|
PERROR("Invalid timeout specified.\n");
|
|
return ME_ERRNO_INVALID_TIMEOUT;
|
|
}
|
|
|
|
if (time_out) {
|
|
delay = (time_out * HZ) / 1000;
|
|
|
|
if (delay == 0)
|
|
delay = 1;
|
|
}
|
|
|
|
if (!instance->fifo) {
|
|
PERROR("Not a streaming ao.\n");
|
|
return ME_ERRNO_NOT_SUPPORTED;
|
|
}
|
|
|
|
ME_SUBDEVICE_ENTER
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
|
|
tmp = inl(instance->ctrl_reg);
|
|
|
|
switch (tmp & (ME4600_AO_CTRL_MASK_MODE)) {
|
|
|
|
case 0: // Single mode
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
PERROR("Subdevice is configured in single mode.\n");
|
|
err = ME_ERRNO_PREVIOUS_CONFIG;
|
|
goto ERROR;
|
|
|
|
case 1: // Wraparound mode
|
|
if (tmp & ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG) { // Normal wraparound with external trigger
|
|
|
|
if ((inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
PERROR("Conversion is already running.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_ENABLE_IRQ |
|
|
ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP);
|
|
|
|
outl(tmp, instance->ctrl_reg);
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
|
|
if (start_mode == ME_START_MODE_BLOCKING) {
|
|
init_waitqueue_head(&queue);
|
|
|
|
if (delay) {
|
|
ref = jiffies;
|
|
|
|
while (!
|
|
(inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
interruptible_sleep_on_timeout
|
|
(&queue, 1);
|
|
|
|
if (signal_pending(current)) {
|
|
PERROR
|
|
("Wait on start of state machine interrupted.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err = ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (((jiffies - ref) >= delay)) {
|
|
PERROR
|
|
("Timeout reached.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err = ME_ERRNO_TIMEOUT;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
} else {
|
|
while (!
|
|
(inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
interruptible_sleep_on_timeout
|
|
(&queue, 1);
|
|
|
|
if (signal_pending(current)) {
|
|
PERROR
|
|
("Wait on start of state machine interrupted.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err = ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
}
|
|
} else if (start_mode == ME_START_MODE_NONBLOCKING) {
|
|
} else {
|
|
PERROR("Invalid start mode specified.\n");
|
|
err = ME_ERRNO_INVALID_START_MODE;
|
|
goto ERROR;
|
|
}
|
|
} else if ((inl(instance->preload_reg) & (0x10001 << instance->ao_idx)) == (0x10000 << instance->ao_idx)) { // Synchronous with external trigger
|
|
|
|
if ((inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
PERROR("Conversion is already running.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (flags & ME_IO_STREAM_START_TYPE_TRIG_SYNCHRONOUS) {
|
|
tmp |= ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG;
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_ENABLE_IRQ |
|
|
ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP);
|
|
outl(tmp, instance->ctrl_reg);
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
|
|
if (start_mode == ME_START_MODE_BLOCKING) {
|
|
init_waitqueue_head(&queue);
|
|
|
|
if (delay) {
|
|
ref = jiffies;
|
|
|
|
while (!
|
|
(inl
|
|
(instance->
|
|
status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM))
|
|
{
|
|
interruptible_sleep_on_timeout
|
|
(&queue, 1);
|
|
|
|
if (signal_pending
|
|
(current)) {
|
|
PERROR
|
|
("Wait on start of state machine interrupted.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err =
|
|
ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (((jiffies - ref) >=
|
|
delay)) {
|
|
PERROR
|
|
("Timeout reached.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err =
|
|
ME_ERRNO_TIMEOUT;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
} else {
|
|
while (!
|
|
(inl
|
|
(instance->
|
|
status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM))
|
|
{
|
|
interruptible_sleep_on_timeout
|
|
(&queue, 1);
|
|
|
|
if (signal_pending
|
|
(current)) {
|
|
PERROR
|
|
("Wait on start of state machine interrupted.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err =
|
|
ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
}
|
|
} else if (start_mode ==
|
|
ME_START_MODE_NONBLOCKING) {
|
|
} else {
|
|
PERROR
|
|
("Invalid start mode specified.\n");
|
|
err = ME_ERRNO_INVALID_START_MODE;
|
|
goto ERROR;
|
|
}
|
|
} else {
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_ENABLE_IRQ |
|
|
ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP);
|
|
outl(tmp, instance->ctrl_reg);
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
}
|
|
} else if ((inl(instance->preload_reg) & (0x10001 << instance->ao_idx)) == (0x1 << instance->ao_idx)) { // Synchronous wraparound with sw trigger
|
|
|
|
if ((inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
PERROR("Conversion is already running.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_ENABLE_IRQ |
|
|
ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP);
|
|
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
if (flags & ME_IO_STREAM_START_TYPE_TRIG_SYNCHRONOUS) {
|
|
outl(0x8000, instance->single_reg);
|
|
instance->single_value = 0x8000;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
} else { // Software start
|
|
|
|
if ((inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
PERROR("Conversion is already running.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_ENABLE_IRQ |
|
|
ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP);
|
|
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
outl(0x8000, instance->single_reg);
|
|
instance->single_value = 0x8000;
|
|
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
}
|
|
|
|
break;
|
|
|
|
case 2: // Continuous mode
|
|
if (tmp & ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG) { // Externally triggered
|
|
|
|
if ((inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
PERROR("Conversion is already running.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP);
|
|
tmp |= ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
outl(tmp, instance->ctrl_reg);
|
|
instance->wrap_remaining = instance->wrap_count;
|
|
instance->circ_buf.tail = 0;
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
|
|
if (start_mode == ME_START_MODE_BLOCKING) {
|
|
init_waitqueue_head(&queue);
|
|
|
|
if (delay) {
|
|
ref = jiffies;
|
|
|
|
while (!
|
|
(inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
interruptible_sleep_on_timeout
|
|
(&queue, 1);
|
|
|
|
if (signal_pending(current)) {
|
|
PERROR
|
|
("Wait on start of state machine interrupted.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err = ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (((jiffies - ref) >= delay)) {
|
|
PERROR
|
|
("Timeout reached.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err = ME_ERRNO_TIMEOUT;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
} else {
|
|
while (!
|
|
(inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
interruptible_sleep_on_timeout
|
|
(&queue, 1);
|
|
|
|
if (signal_pending(current)) {
|
|
PERROR
|
|
("Wait on start of state machine interrupted.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err = ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
}
|
|
} else if (start_mode == ME_START_MODE_NONBLOCKING) {
|
|
/* Do nothing */
|
|
} else {
|
|
PERROR("Invalid start mode specified.\n");
|
|
stop_immediately(instance);
|
|
err = ME_ERRNO_INVALID_START_MODE;
|
|
goto ERROR;
|
|
}
|
|
} else if ((inl(instance->preload_reg) & (0x10001 << instance->ao_idx)) == (0x10000 << instance->ao_idx)) { // Synchronous with external trigger
|
|
|
|
if ((inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
PERROR("Conversion is already running.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (flags & ME_IO_STREAM_START_TYPE_TRIG_SYNCHRONOUS) {
|
|
tmp |=
|
|
ME4600_AO_CTRL_BIT_ENABLE_EX_TRIG |
|
|
ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP);
|
|
outl(tmp, instance->ctrl_reg);
|
|
instance->wrap_remaining = instance->wrap_count;
|
|
instance->circ_buf.tail = 0;
|
|
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
|
|
if (start_mode == ME_START_MODE_BLOCKING) {
|
|
init_waitqueue_head(&queue);
|
|
|
|
if (delay) {
|
|
ref = jiffies;
|
|
|
|
while (!
|
|
(inl
|
|
(instance->
|
|
status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM))
|
|
{
|
|
interruptible_sleep_on_timeout
|
|
(&queue, 1);
|
|
|
|
if (signal_pending
|
|
(current)) {
|
|
PERROR
|
|
("Wait on start of state machine interrupted.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err =
|
|
ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (((jiffies - ref) >=
|
|
delay)) {
|
|
PERROR
|
|
("Timeout reached.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err =
|
|
ME_ERRNO_TIMEOUT;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
} else {
|
|
while (!
|
|
(inl
|
|
(instance->
|
|
status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM))
|
|
{
|
|
interruptible_sleep_on_timeout
|
|
(&queue, 1);
|
|
|
|
if (signal_pending
|
|
(current)) {
|
|
PERROR
|
|
("Wait on start of state machine interrupted.\n");
|
|
stop_immediately
|
|
(instance);
|
|
err =
|
|
ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
}
|
|
} else if (start_mode ==
|
|
ME_START_MODE_NONBLOCKING) {
|
|
} else {
|
|
PERROR
|
|
("Invalid start mode specified.\n");
|
|
stop_immediately(instance);
|
|
err = ME_ERRNO_INVALID_START_MODE;
|
|
goto ERROR;
|
|
}
|
|
} else {
|
|
tmp |= ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP);
|
|
outl(tmp, instance->ctrl_reg);
|
|
instance->wrap_remaining = instance->wrap_count;
|
|
instance->circ_buf.tail = 0;
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
}
|
|
} else if ((inl(instance->preload_reg) & (0x10001 << instance->ao_idx)) == (0x1 << instance->ao_idx)) { // Synchronous wraparound with sw trigger
|
|
|
|
if ((inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
PERROR("Conversion is already running.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP);
|
|
tmp |= ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
instance->wrap_remaining = instance->wrap_count;
|
|
instance->circ_buf.tail = 0;
|
|
PDEBUG("CTRL Reg = 0x%X.\n", inl(instance->ctrl_reg));
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
if (flags & ME_IO_STREAM_START_TYPE_TRIG_SYNCHRONOUS) {
|
|
outl(0x8000, instance->single_reg);
|
|
instance->single_value = 0x8000;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
} else { // Software start
|
|
|
|
if ((inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
PERROR("Conversion is already running.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP);
|
|
|
|
tmp |= ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
outl(tmp, instance->ctrl_reg);
|
|
outl(0x8000, instance->single_reg);
|
|
instance->single_value = 0x8000;
|
|
instance->wrap_remaining = instance->wrap_count;
|
|
instance->circ_buf.tail = 0;
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
PERROR("Invalid mode configured.\n");
|
|
err = ME_ERRNO_INTERNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
ERROR:
|
|
|
|
ME_SUBDEVICE_EXIT;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int me4600_ao_io_stream_status(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int wait,
|
|
int *status, int *values, int flags)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
wait_queue_head_t queue;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
init_waitqueue_head(&queue);
|
|
|
|
if (!instance->fifo) {
|
|
PERROR("Not a streaming ao.\n");
|
|
return ME_ERRNO_NOT_SUPPORTED;
|
|
}
|
|
|
|
ME_SUBDEVICE_ENTER;
|
|
|
|
if (wait == ME_WAIT_NONE) {
|
|
*status =
|
|
(inl(instance->status_reg) & ME4600_AO_STATUS_BIT_FSM) ?
|
|
ME_STATUS_BUSY : ME_STATUS_IDLE;
|
|
*values = me_circ_buf_space(&instance->circ_buf);
|
|
} else if (wait == ME_WAIT_IDLE) {
|
|
while (inl(instance->status_reg) & ME4600_AO_STATUS_BIT_FSM) {
|
|
interruptible_sleep_on_timeout(&queue, 1);
|
|
|
|
if (instance->flags & ME4600_AO_FLAGS_BROKEN_PIPE) {
|
|
PERROR("Output stream was interrupted.\n");
|
|
*status = ME_STATUS_ERROR;
|
|
err = ME_ERRNO_SUCCESS;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (signal_pending(current)) {
|
|
PERROR
|
|
("Wait on state machine interrupted by signal.\n");
|
|
*status = ME_STATUS_INVALID;
|
|
err = ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
|
|
*status = ME_STATUS_IDLE;
|
|
|
|
*values = me_circ_buf_space(&instance->circ_buf);
|
|
} else {
|
|
PERROR("Invalid wait argument specified.\n");
|
|
*status = ME_STATUS_INVALID;
|
|
err = ME_ERRNO_INVALID_WAIT;
|
|
goto ERROR;
|
|
}
|
|
|
|
ERROR:
|
|
|
|
ME_SUBDEVICE_EXIT;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int me4600_ao_io_stream_stop(me_subdevice_t * subdevice,
|
|
struct file *filep,
|
|
int stop_mode, int flags)
|
|
{
|
|
int err = ME_ERRNO_SUCCESS;
|
|
me4600_ao_subdevice_t *instance;
|
|
unsigned long cpu_flags;
|
|
unsigned long tmp;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
if (!instance->fifo) {
|
|
PERROR("Not a streaming ao.\n");
|
|
return ME_ERRNO_NOT_SUPPORTED;
|
|
}
|
|
|
|
ME_SUBDEVICE_ENTER;
|
|
|
|
if (stop_mode == ME_STOP_MODE_IMMEDIATE) {
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
tmp = inl(instance->ctrl_reg);
|
|
tmp |=
|
|
ME4600_AO_CTRL_BIT_STOP | ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
while (inl(instance->status_reg) & ME4600_AO_STATUS_BIT_FSM) ;
|
|
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
} else if (stop_mode == ME_STOP_MODE_LAST_VALUE) {
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
tmp = inl(instance->ctrl_reg);
|
|
tmp |= ME4600_AO_CTRL_BIT_STOP;
|
|
outl(tmp, instance->ctrl_reg);
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
} else {
|
|
PERROR("Invalid stop mode specified.\n");
|
|
err = ME_ERRNO_INVALID_STOP_MODE;
|
|
goto ERROR;
|
|
}
|
|
|
|
ERROR:
|
|
|
|
ME_SUBDEVICE_EXIT;
|
|
|
|
return err;
|
|
}
|
|
|
|
static int me4600_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;
|
|
me4600_ao_subdevice_t *instance;
|
|
unsigned long tmp;
|
|
int i;
|
|
int value;
|
|
int cnt = *count;
|
|
int c;
|
|
int k;
|
|
int ret = 0;
|
|
unsigned long cpu_flags = 0;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
if (!instance->fifo) {
|
|
PERROR("Not a streaming ao.\n");
|
|
return ME_ERRNO_NOT_SUPPORTED;
|
|
}
|
|
|
|
ME_SUBDEVICE_ENTER;
|
|
|
|
if (*count <= 0) {
|
|
PERROR("Invalid count of values specified.\n");
|
|
err = ME_ERRNO_INVALID_VALUE_COUNT;
|
|
goto ERROR;
|
|
}
|
|
|
|
spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
|
|
|
|
tmp = inl(instance->ctrl_reg);
|
|
|
|
switch (tmp & 0x3) {
|
|
|
|
case 1: // Wraparound mode
|
|
if (instance->bosch_fw) { // Bosch firmware
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
|
|
if (cnt != 7) {
|
|
PERROR
|
|
("Invalid count of values specified. 7 expected.\n");
|
|
err = ME_ERRNO_INVALID_VALUE_COUNT;
|
|
goto ERROR;
|
|
}
|
|
|
|
for (i = 0; i < 7; i++) {
|
|
if (get_user(value, values)) {
|
|
PERROR
|
|
("Can't copy value from user space.\n");
|
|
err = ME_ERRNO_INTERNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (i == 0) {
|
|
/* Maximum voltage */
|
|
value <<= 16;
|
|
value |=
|
|
inl(instance->reg_base +
|
|
0xD4) & 0xFFFF;
|
|
outl(value, instance->reg_base + 0xD4);
|
|
} else if (i == 1) {
|
|
/* Minimum voltage */
|
|
value &= 0xFFFF;
|
|
value |=
|
|
inl(instance->reg_base +
|
|
0xD4) & 0xFFFF0000;
|
|
outl(value, instance->reg_base + 0xD4);
|
|
} else if (i == 2) {
|
|
/* Delta up */
|
|
value <<= 16;
|
|
value |=
|
|
inl(instance->reg_base +
|
|
0xD8) & 0xFFFF;
|
|
outl(value, instance->reg_base + 0xD8);
|
|
} else if (i == 3) {
|
|
/* Delta down */
|
|
value &= 0xFFFF;
|
|
value |=
|
|
inl(instance->reg_base +
|
|
0xD8) & 0xFFFF0000;
|
|
outl(value, instance->reg_base + 0xD8);
|
|
} else if (i == 4) {
|
|
/* Start value */
|
|
outl(value, instance->reg_base + 0xDC);
|
|
} else if (i == 5) {
|
|
/* Invert */
|
|
if (value) {
|
|
value = inl(instance->ctrl_reg);
|
|
value |= 0x100;
|
|
outl(value, instance->ctrl_reg);
|
|
} else {
|
|
value = inl(instance->ctrl_reg);
|
|
value &= ~0x100;
|
|
outl(value, instance->ctrl_reg);
|
|
}
|
|
} else if (i == 6) {
|
|
/* Timer for positive ramp */
|
|
outl(value, instance->reg_base + 0xE0);
|
|
}
|
|
|
|
values++;
|
|
}
|
|
} else { // Normal firmware
|
|
PDEBUG("Write for wraparound mode.\n");
|
|
|
|
if (inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM) {
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
PERROR
|
|
("There is already a conversion running.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
tmp |= ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
tmp &= ~ME4600_AO_CTRL_BIT_ENABLE_FIFO;
|
|
outl(tmp, instance->ctrl_reg);
|
|
tmp |= ME4600_AO_CTRL_BIT_ENABLE_FIFO;
|
|
|
|
if ((*count > ME4600_AO_FIFO_COUNT) ||
|
|
((instance->
|
|
flags & ME4600_AO_FLAGS_SW_WRAP_MODE_MASK) ==
|
|
ME4600_AO_FLAGS_SW_WRAP_MODE_FIN)) {
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_MODE_0 |
|
|
ME4600_AO_CTRL_BIT_MODE_1);
|
|
tmp |= ME4600_AO_CTRL_BIT_MODE_1;
|
|
}
|
|
|
|
outl(tmp, instance->ctrl_reg);
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
|
|
if ((*count <= ME4600_AO_FIFO_COUNT) &&
|
|
((instance->
|
|
flags & ME4600_AO_FLAGS_SW_WRAP_MODE_MASK) ==
|
|
ME4600_AO_FLAGS_SW_WRAP_MODE_INF)) {
|
|
for (i = 0; i < *count; i++) {
|
|
if (get_user(value, values + i)) {
|
|
PERROR
|
|
("Cannot copy value from user space.\n");
|
|
err = ME_ERRNO_INTERNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (instance->ao_idx & 0x1)
|
|
value <<= 16;
|
|
|
|
outl(value, instance->fifo_reg);
|
|
}
|
|
} else if ((*count <= ME4600_AO_CIRC_BUF_COUNT) &&
|
|
((instance->
|
|
flags & ME4600_AO_FLAGS_SW_WRAP_MODE_MASK)
|
|
== ME4600_AO_FLAGS_SW_WRAP_MODE_INF)) {
|
|
for (i = 0; i < *count; i++) {
|
|
if (get_user(value, values + i)) {
|
|
PERROR
|
|
("Cannot copy value from user space.\n");
|
|
err = ME_ERRNO_INTERNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
instance->circ_buf.buf[i] = value; /* Used to hold the values. */
|
|
}
|
|
|
|
instance->circ_buf.tail = 0; /* Used as the current read position. */
|
|
instance->circ_buf.head = *count; /* Used as the buffer size. */
|
|
|
|
/* Preload the FIFO. */
|
|
|
|
for (i = 0; i < ME4600_AO_FIFO_COUNT;
|
|
i++, instance->circ_buf.tail++) {
|
|
if (instance->circ_buf.tail >=
|
|
instance->circ_buf.head)
|
|
instance->circ_buf.tail = 0;
|
|
|
|
if (instance->ao_idx & 0x1)
|
|
outl(instance->circ_buf.
|
|
buf[instance->circ_buf.
|
|
tail] << 16,
|
|
instance->fifo_reg);
|
|
else
|
|
outl(instance->circ_buf.
|
|
buf[instance->circ_buf.
|
|
tail],
|
|
instance->fifo_reg);
|
|
}
|
|
} else if ((*count <= ME4600_AO_CIRC_BUF_COUNT) &&
|
|
((instance->
|
|
flags & ME4600_AO_FLAGS_SW_WRAP_MODE_MASK)
|
|
== ME4600_AO_FLAGS_SW_WRAP_MODE_FIN)) {
|
|
unsigned int preload_count;
|
|
|
|
for (i = 0; i < *count; i++) {
|
|
if (get_user(value, values + i)) {
|
|
PERROR
|
|
("Cannot copy value from user space.\n");
|
|
err = ME_ERRNO_INTERNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
instance->circ_buf.buf[i] = value; /* Used to hold the values. */
|
|
}
|
|
|
|
instance->circ_buf.tail = 0; /* Used as the current read position. */
|
|
instance->circ_buf.head = *count; /* Used as the buffer size. */
|
|
|
|
/* Try to preload the whole FIFO. */
|
|
preload_count = ME4600_AO_FIFO_COUNT;
|
|
|
|
if (preload_count > instance->wrap_count)
|
|
preload_count = instance->wrap_count;
|
|
|
|
/* Preload the FIFO. */
|
|
for (i = 0; i < preload_count;
|
|
i++, instance->circ_buf.tail++) {
|
|
if (instance->circ_buf.tail >=
|
|
instance->circ_buf.head)
|
|
instance->circ_buf.tail = 0;
|
|
|
|
if (instance->ao_idx & 0x1)
|
|
outl(instance->circ_buf.
|
|
buf[instance->circ_buf.
|
|
tail] << 16,
|
|
instance->fifo_reg);
|
|
else
|
|
outl(instance->circ_buf.
|
|
buf[instance->circ_buf.
|
|
tail],
|
|
instance->fifo_reg);
|
|
}
|
|
|
|
instance->wrap_remaining =
|
|
instance->wrap_count - preload_count;
|
|
} else {
|
|
PERROR("To many values written.\n");
|
|
err = ME_ERRNO_INVALID_VALUE_COUNT;
|
|
goto ERROR;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case 2: // Continuous mode
|
|
/* Check if in SW wrapround mode */
|
|
if (instance->flags & ME4600_AO_FLAGS_SW_WRAP_MODE_MASK) {
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
PERROR("Subdevice is configured SW wrapround mode.\n");
|
|
err = ME_ERRNO_PREVIOUS_CONFIG;
|
|
goto ERROR;
|
|
}
|
|
|
|
switch (write_mode) {
|
|
|
|
case ME_WRITE_MODE_BLOCKING:
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
|
|
PDEBUG("Write for blocking continuous mode.\n");
|
|
|
|
while (cnt > 0) {
|
|
wait_event_interruptible(instance->wait_queue,
|
|
(c =
|
|
me_circ_buf_space_to_end
|
|
(&instance->
|
|
circ_buf)));
|
|
|
|
if (instance->
|
|
flags & ME4600_AO_FLAGS_BROKEN_PIPE) {
|
|
PERROR
|
|
("Broken pipe in blocking write.\n");
|
|
err = ME_ERRNO_SUBDEVICE_NOT_RUNNING;
|
|
goto ERROR;
|
|
} else if (signal_pending(current)) {
|
|
PERROR
|
|
("Wait for free buffer interrupted from signal.\n");
|
|
err = ME_ERRNO_SIGNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
PDEBUG("Space to end = %d.\n", c);
|
|
|
|
/* Only able to write size of free buffer or size of count */
|
|
|
|
if (cnt < c)
|
|
c = cnt;
|
|
k = sizeof(int) * c;
|
|
k -= copy_from_user(instance->circ_buf.buf +
|
|
instance->circ_buf.head,
|
|
values, k);
|
|
c = k / sizeof(int);
|
|
|
|
PDEBUG("Copy %d values from user space.\n", c);
|
|
|
|
if (!c) {
|
|
PERROR
|
|
("Cannot copy values from user space.\n");
|
|
err = ME_ERRNO_INTERNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
instance->circ_buf.head =
|
|
(instance->circ_buf.head +
|
|
c) & (instance->circ_buf.mask);
|
|
|
|
values += c;
|
|
cnt -= c;
|
|
ret += c;
|
|
|
|
/* Values are now available so enable interrupts */
|
|
spin_lock_irqsave(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
|
|
if (me_circ_buf_space(&instance->circ_buf)) {
|
|
tmp = inl(instance->ctrl_reg);
|
|
tmp |= ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
outl(tmp, instance->ctrl_reg);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
}
|
|
|
|
*count = ret;
|
|
|
|
break;
|
|
|
|
case ME_WRITE_MODE_NONBLOCKING:
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
|
|
PDEBUG("Write for non blocking continuous mode.\n");
|
|
|
|
while (cnt > 0) {
|
|
if (instance->
|
|
flags & ME4600_AO_FLAGS_BROKEN_PIPE) {
|
|
PERROR
|
|
("ME4600:Broken pipe in nonblocking write.\n");
|
|
err = ME_ERRNO_SUBDEVICE_NOT_RUNNING;
|
|
goto ERROR;
|
|
}
|
|
|
|
c = me_circ_buf_space_to_end(&instance->
|
|
circ_buf);
|
|
|
|
if (!c) {
|
|
PDEBUG
|
|
("Returning from nonblocking write.\n");
|
|
break;
|
|
}
|
|
|
|
PDEBUG("Space to end = %d.\n", c);
|
|
|
|
/* Only able to write size of free buffer or size of count */
|
|
|
|
if (cnt < c)
|
|
c = cnt;
|
|
k = sizeof(int) * c;
|
|
k -= copy_from_user(instance->circ_buf.buf +
|
|
instance->circ_buf.head,
|
|
values, k);
|
|
c = k / sizeof(int);
|
|
|
|
PDEBUG("Copy %d values from user space.\n", c);
|
|
|
|
if (!c) {
|
|
PERROR
|
|
("Cannot copy values from user space.\n");
|
|
err = ME_ERRNO_INTERNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
instance->circ_buf.head =
|
|
(instance->circ_buf.head +
|
|
c) & (instance->circ_buf.mask);
|
|
|
|
values += c;
|
|
cnt -= c;
|
|
ret += c;
|
|
|
|
/* Values are now available so enable interrupts */
|
|
spin_lock_irqsave(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
|
|
if (me_circ_buf_space(&instance->circ_buf)) {
|
|
tmp = inl(instance->ctrl_reg);
|
|
tmp |= ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
outl(tmp, instance->ctrl_reg);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
}
|
|
|
|
*count = ret;
|
|
|
|
break;
|
|
|
|
case ME_WRITE_MODE_PRELOAD:
|
|
PDEBUG("Write for preload continuous mode.\n");
|
|
|
|
if ((inl(instance->status_reg) &
|
|
ME4600_AO_STATUS_BIT_FSM)) {
|
|
spin_unlock_irqrestore(&instance->
|
|
subdevice_lock,
|
|
cpu_flags);
|
|
PERROR
|
|
("Can't Preload DAC FIFO while conversion is running.\n");
|
|
err = ME_ERRNO_SUBDEVICE_BUSY;
|
|
goto ERROR;
|
|
}
|
|
|
|
tmp = inl(instance->ctrl_reg);
|
|
|
|
tmp |=
|
|
ME4600_AO_CTRL_BIT_STOP |
|
|
ME4600_AO_CTRL_BIT_IMMEDIATE_STOP;
|
|
outl(tmp, instance->ctrl_reg);
|
|
tmp &=
|
|
~(ME4600_AO_CTRL_BIT_ENABLE_FIFO |
|
|
ME4600_AO_CTRL_BIT_ENABLE_IRQ);
|
|
outl(tmp, instance->ctrl_reg);
|
|
tmp |= ME4600_AO_CTRL_BIT_ENABLE_FIFO;
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
instance->circ_buf.head = 0;
|
|
instance->circ_buf.tail = 0;
|
|
instance->flags &= ~ME4600_AO_FLAGS_BROKEN_PIPE;
|
|
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
|
|
c = ME4600_AO_FIFO_COUNT;
|
|
|
|
if (cnt < c)
|
|
c = cnt;
|
|
|
|
for (i = 0; i < c; i++) {
|
|
if (get_user(value, values)) {
|
|
PERROR
|
|
("Can't copy value from user space.\n");
|
|
err = ME_ERRNO_INTERNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
if (instance->ao_idx & 0x1)
|
|
value <<= 16;
|
|
|
|
outl(value, instance->fifo_reg);
|
|
|
|
values++;
|
|
}
|
|
|
|
cnt -= c;
|
|
|
|
ret += c;
|
|
|
|
PDEBUG("Wrote %d values to fifo.\n", c);
|
|
|
|
while (1) {
|
|
c = me_circ_buf_space_to_end(&instance->
|
|
circ_buf);
|
|
|
|
if (c == 0)
|
|
break;
|
|
|
|
if (cnt < c)
|
|
c = cnt;
|
|
|
|
if (c <= 0)
|
|
break;
|
|
|
|
k = sizeof(int) * c;
|
|
|
|
k -= copy_from_user(instance->circ_buf.buf +
|
|
instance->circ_buf.head,
|
|
values, k);
|
|
|
|
c = k / sizeof(int);
|
|
|
|
PDEBUG("Wrote %d values to circular buffer.\n",
|
|
c);
|
|
|
|
if (!c) {
|
|
PERROR
|
|
("Can't copy values from user space.\n");
|
|
err = ME_ERRNO_INTERNAL;
|
|
goto ERROR;
|
|
}
|
|
|
|
instance->circ_buf.head =
|
|
(instance->circ_buf.head +
|
|
c) & (instance->circ_buf.mask);
|
|
|
|
values += c;
|
|
cnt -= c;
|
|
ret += c;
|
|
}
|
|
|
|
*count = ret;
|
|
|
|
break;
|
|
|
|
default:
|
|
spin_unlock_irqrestore(&instance->subdevice_lock,
|
|
cpu_flags);
|
|
|
|
PERROR("Invalid write mode specified.\n");
|
|
|
|
err = ME_ERRNO_INVALID_WRITE_MODE;
|
|
|
|
goto ERROR;
|
|
}
|
|
|
|
break;
|
|
|
|
default: // Single mode of invalid
|
|
spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
|
|
PERROR("Subdevice is configured in single mode.\n");
|
|
err = ME_ERRNO_PREVIOUS_CONFIG;
|
|
goto ERROR;
|
|
}
|
|
|
|
ERROR:
|
|
|
|
ME_SUBDEVICE_EXIT;
|
|
|
|
return err;
|
|
}
|
|
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
|
|
static irqreturn_t me4600_ao_isr(int irq, void *dev_id)
|
|
#else
|
|
static irqreturn_t me4600_ao_isr(int irq, void *dev_id, struct pt_regs *regs)
|
|
#endif
|
|
{
|
|
unsigned long tmp;
|
|
int value;
|
|
me4600_ao_subdevice_t *instance = dev_id;
|
|
int i;
|
|
int c = 0;
|
|
int c1 = 0;
|
|
|
|
if (irq != instance->irq) {
|
|
PDEBUG("Incorrect interrupt num: %d.\n", irq);
|
|
return IRQ_NONE;
|
|
}
|
|
|
|
if (!((0x1 << (instance->ao_idx + 3)) & inl(instance->irq_status_reg))) {
|
|
return IRQ_NONE;
|
|
}
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
tmp = inl(instance->status_reg);
|
|
|
|
if (!(tmp & ME4600_AO_STATUS_BIT_EF) &&
|
|
(tmp & ME4600_AO_STATUS_BIT_HF) &&
|
|
(tmp & ME4600_AO_STATUS_BIT_HF)) {
|
|
c = ME4600_AO_FIFO_COUNT;
|
|
PDEBUG("Fifo empty.\n");
|
|
} else if ((tmp & ME4600_AO_STATUS_BIT_EF) &&
|
|
(tmp & ME4600_AO_STATUS_BIT_HF) &&
|
|
(tmp & ME4600_AO_STATUS_BIT_HF)) {
|
|
c = ME4600_AO_FIFO_COUNT / 2;
|
|
PDEBUG("Fifo under half full.\n");
|
|
} else {
|
|
c = 0;
|
|
PDEBUG("Fifo full.\n");
|
|
}
|
|
|
|
PDEBUG("Try to write 0x%04X values.\n", c);
|
|
|
|
if ((instance->flags & ME4600_AO_FLAGS_SW_WRAP_MODE_MASK) ==
|
|
ME4600_AO_FLAGS_SW_WRAP_MODE_INF) {
|
|
while (c) {
|
|
c1 = c;
|
|
|
|
if (c1 > (instance->circ_buf.head - instance->circ_buf.tail)) /* Only up to the end of the buffer */
|
|
c1 = (instance->circ_buf.head -
|
|
instance->circ_buf.tail);
|
|
|
|
/* Write the values to the FIFO */
|
|
for (i = 0; i < c1; i++, instance->circ_buf.tail++, c--) {
|
|
if (instance->ao_idx & 0x1)
|
|
outl(instance->circ_buf.
|
|
buf[instance->circ_buf.tail] << 16,
|
|
instance->fifo_reg);
|
|
else
|
|
outl(instance->circ_buf.
|
|
buf[instance->circ_buf.tail],
|
|
instance->fifo_reg);
|
|
}
|
|
|
|
if (instance->circ_buf.tail >= instance->circ_buf.head) /* Start from beginning */
|
|
instance->circ_buf.tail = 0;
|
|
}
|
|
|
|
spin_lock(&instance->subdevice_lock);
|
|
|
|
tmp = inl(instance->ctrl_reg);
|
|
tmp |= ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
outl(tmp, instance->ctrl_reg);
|
|
tmp &= ~ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
if (!(inl(instance->status_reg) & ME4600_AO_STATUS_BIT_FSM)) {
|
|
PERROR("Broken pipe.\n");
|
|
instance->flags |= ME4600_AO_FLAGS_BROKEN_PIPE;
|
|
tmp &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
outl(tmp, instance->ctrl_reg);
|
|
}
|
|
|
|
spin_unlock(&instance->subdevice_lock);
|
|
} else if ((instance->flags & ME4600_AO_FLAGS_SW_WRAP_MODE_MASK) ==
|
|
ME4600_AO_FLAGS_SW_WRAP_MODE_FIN) {
|
|
while (c && instance->wrap_remaining) {
|
|
c1 = c;
|
|
|
|
if (c1 > (instance->circ_buf.head - instance->circ_buf.tail)) /* Only up to the end of the buffer */
|
|
c1 = (instance->circ_buf.head -
|
|
instance->circ_buf.tail);
|
|
|
|
if (c1 > instance->wrap_remaining) /* Only up to count of user defined number of values */
|
|
c1 = instance->wrap_remaining;
|
|
|
|
/* Write the values to the FIFO */
|
|
for (i = 0; i < c1;
|
|
i++, instance->circ_buf.tail++, c--,
|
|
instance->wrap_remaining--) {
|
|
if (instance->ao_idx & 0x1)
|
|
outl(instance->circ_buf.
|
|
buf[instance->circ_buf.tail] << 16,
|
|
instance->fifo_reg);
|
|
else
|
|
outl(instance->circ_buf.
|
|
buf[instance->circ_buf.tail],
|
|
instance->fifo_reg);
|
|
}
|
|
|
|
if (instance->circ_buf.tail >= instance->circ_buf.head) /* Start from beginning */
|
|
instance->circ_buf.tail = 0;
|
|
}
|
|
|
|
spin_lock(&instance->subdevice_lock);
|
|
|
|
tmp = inl(instance->ctrl_reg);
|
|
|
|
if (!instance->wrap_remaining) {
|
|
PDEBUG("Finite SW wraparound done.\n");
|
|
tmp &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
}
|
|
|
|
tmp |= ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
|
|
outl(tmp, instance->ctrl_reg);
|
|
tmp &= ~ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
if (!(inl(instance->status_reg) & ME4600_AO_STATUS_BIT_FSM)) {
|
|
PERROR("Broken pipe.\n");
|
|
instance->flags |= ME4600_AO_FLAGS_BROKEN_PIPE;
|
|
tmp &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
outl(tmp, instance->ctrl_reg);
|
|
}
|
|
|
|
spin_unlock(&instance->subdevice_lock);
|
|
|
|
} else { /* Regular continuous mode */
|
|
|
|
while (1) {
|
|
c1 = me_circ_buf_values_to_end(&instance->circ_buf);
|
|
PDEBUG("Values to end = %d.\n", c1);
|
|
|
|
if (c1 > c)
|
|
c1 = c;
|
|
|
|
if (c1 <= 0) {
|
|
PDEBUG("Work done or buffer empty.\n");
|
|
break;
|
|
}
|
|
|
|
if (instance->ao_idx & 0x1) {
|
|
for (i = 0; i < c1; i++) {
|
|
value =
|
|
*(instance->circ_buf.buf +
|
|
instance->circ_buf.tail +
|
|
i) << 16;
|
|
outl(value, instance->fifo_reg);
|
|
}
|
|
} else
|
|
outsl(instance->fifo_reg,
|
|
instance->circ_buf.buf +
|
|
instance->circ_buf.tail, c1);
|
|
|
|
instance->circ_buf.tail =
|
|
(instance->circ_buf.tail +
|
|
c1) & (instance->circ_buf.mask);
|
|
|
|
PDEBUG("%d values wrote to port 0x%04X.\n", c1,
|
|
instance->fifo_reg);
|
|
|
|
c -= c1;
|
|
}
|
|
|
|
spin_lock(&instance->subdevice_lock);
|
|
|
|
tmp = inl(instance->ctrl_reg);
|
|
|
|
if (!me_circ_buf_values(&instance->circ_buf)) {
|
|
PDEBUG
|
|
("Disable Interrupt because no values left in buffer.\n");
|
|
tmp &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
}
|
|
|
|
tmp |= ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
|
|
outl(tmp, instance->ctrl_reg);
|
|
tmp &= ~ME4600_AO_CTRL_BIT_RESET_IRQ;
|
|
outl(tmp, instance->ctrl_reg);
|
|
|
|
if (!(inl(instance->status_reg) & ME4600_AO_STATUS_BIT_FSM)) {
|
|
PDEBUG("Broken pipe in me4600_ao_isr.\n");
|
|
instance->flags |= ME4600_AO_FLAGS_BROKEN_PIPE;
|
|
tmp &= ~ME4600_AO_CTRL_BIT_ENABLE_IRQ;
|
|
outl(tmp, instance->ctrl_reg);
|
|
}
|
|
|
|
spin_unlock(&instance->subdevice_lock);
|
|
|
|
wake_up_interruptible(&instance->wait_queue);
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static void me4600_ao_destructor(struct me_subdevice *subdevice)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
free_irq(instance->irq, instance);
|
|
kfree(instance->circ_buf.buf);
|
|
me_subdevice_deinit(&instance->base);
|
|
kfree(instance);
|
|
}
|
|
|
|
me4600_ao_subdevice_t *me4600_ao_constructor(uint32_t reg_base,
|
|
spinlock_t * preload_reg_lock,
|
|
uint32_t * preload_flags,
|
|
int ao_idx, int fifo, int irq)
|
|
{
|
|
me4600_ao_subdevice_t *subdevice;
|
|
int err;
|
|
|
|
PDEBUG("executed.\n");
|
|
|
|
/* Allocate memory for subdevice instance */
|
|
subdevice = kmalloc(sizeof(me4600_ao_subdevice_t), GFP_KERNEL);
|
|
|
|
if (!subdevice) {
|
|
PERROR("Cannot get memory for subdevice instance.\n");
|
|
return NULL;
|
|
}
|
|
|
|
memset(subdevice, 0, sizeof(me4600_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;
|
|
|
|
/* Allocate and initialize circular buffer */
|
|
subdevice->circ_buf.mask = ME4600_AO_CIRC_BUF_COUNT - 1;
|
|
subdevice->circ_buf.buf = kmalloc(ME4600_AO_CIRC_BUF_SIZE, GFP_KERNEL);
|
|
|
|
if (!subdevice->circ_buf.buf) {
|
|
PERROR("Cannot initialize subdevice base class instance.\n");
|
|
me_subdevice_deinit((me_subdevice_t *) subdevice);
|
|
kfree(subdevice);
|
|
return NULL;
|
|
}
|
|
|
|
memset(subdevice->circ_buf.buf, 0, ME4600_AO_CIRC_BUF_SIZE);
|
|
|
|
subdevice->circ_buf.head = 0;
|
|
subdevice->circ_buf.tail = 0;
|
|
|
|
/* Initialize wait queue */
|
|
init_waitqueue_head(&subdevice->wait_queue);
|
|
|
|
/* Initialize single value to 0V */
|
|
subdevice->single_value = 0x8000;
|
|
|
|
/* Store analog output index */
|
|
subdevice->ao_idx = ao_idx;
|
|
|
|
/* Store if analog output has fifo */
|
|
subdevice->fifo = fifo;
|
|
|
|
/* Initialize registers */
|
|
|
|
if (ao_idx == 0) {
|
|
subdevice->ctrl_reg = reg_base + ME4600_AO_00_CTRL_REG;
|
|
subdevice->status_reg = reg_base + ME4600_AO_00_STATUS_REG;
|
|
subdevice->fifo_reg = reg_base + ME4600_AO_00_FIFO_REG;
|
|
subdevice->single_reg = reg_base + ME4600_AO_00_SINGLE_REG;
|
|
subdevice->timer_reg = reg_base + ME4600_AO_00_TIMER_REG;
|
|
subdevice->reg_base = reg_base;
|
|
|
|
if (inl(subdevice->reg_base + ME4600_AO_BOSCH_REG) == 0x20000) {
|
|
PINFO("Bosch firmware in use for channel 0.\n");
|
|
subdevice->bosch_fw = 1;
|
|
} else {
|
|
subdevice->bosch_fw = 0;
|
|
}
|
|
} else if (ao_idx == 1) {
|
|
subdevice->ctrl_reg = reg_base + ME4600_AO_01_CTRL_REG;
|
|
subdevice->status_reg = reg_base + ME4600_AO_01_STATUS_REG;
|
|
subdevice->fifo_reg = reg_base + ME4600_AO_01_FIFO_REG;
|
|
subdevice->single_reg = reg_base + ME4600_AO_01_SINGLE_REG;
|
|
subdevice->timer_reg = reg_base + ME4600_AO_01_TIMER_REG;
|
|
subdevice->reg_base = reg_base;
|
|
subdevice->bosch_fw = 0;
|
|
} else if (ao_idx == 2) {
|
|
subdevice->ctrl_reg = reg_base + ME4600_AO_02_CTRL_REG;
|
|
subdevice->status_reg = reg_base + ME4600_AO_02_STATUS_REG;
|
|
subdevice->fifo_reg = reg_base + ME4600_AO_02_FIFO_REG;
|
|
subdevice->single_reg = reg_base + ME4600_AO_02_SINGLE_REG;
|
|
subdevice->timer_reg = reg_base + ME4600_AO_02_TIMER_REG;
|
|
subdevice->reg_base = reg_base;
|
|
subdevice->bosch_fw = 0;
|
|
} else {
|
|
subdevice->ctrl_reg = reg_base + ME4600_AO_03_CTRL_REG;
|
|
subdevice->status_reg = reg_base + ME4600_AO_03_STATUS_REG;
|
|
subdevice->fifo_reg = reg_base + ME4600_AO_03_FIFO_REG;
|
|
subdevice->single_reg = reg_base + ME4600_AO_03_SINGLE_REG;
|
|
subdevice->timer_reg = reg_base + ME4600_AO_03_TIMER_REG;
|
|
subdevice->reg_base = reg_base;
|
|
subdevice->bosch_fw = 0;
|
|
}
|
|
|
|
subdevice->irq_status_reg = reg_base + ME4600_IRQ_STATUS_REG;
|
|
subdevice->preload_reg = reg_base + ME4600_AO_LOADSETREG_XX;
|
|
|
|
/* Register interrupt service routine */
|
|
subdevice->irq = irq;
|
|
|
|
if (request_irq
|
|
(subdevice->irq, me4600_ao_isr, SA_INTERRUPT | SA_SHIRQ,
|
|
ME4600_NAME, subdevice)) {
|
|
PERROR("Cannot get interrupt line.\n");
|
|
me_subdevice_deinit((me_subdevice_t *) subdevice);
|
|
kfree(subdevice->circ_buf.buf);
|
|
kfree(subdevice);
|
|
return NULL;
|
|
}
|
|
|
|
/* Override base class methods. */
|
|
subdevice->base.me_subdevice_destructor = me4600_ao_destructor;
|
|
subdevice->base.me_subdevice_io_reset_subdevice =
|
|
me4600_ao_io_reset_subdevice;
|
|
subdevice->base.me_subdevice_io_single_config =
|
|
me4600_ao_io_single_config;
|
|
subdevice->base.me_subdevice_io_single_read = me4600_ao_io_single_read;
|
|
subdevice->base.me_subdevice_io_single_write =
|
|
me4600_ao_io_single_write;
|
|
subdevice->base.me_subdevice_io_stream_config =
|
|
me4600_ao_io_stream_config;
|
|
subdevice->base.me_subdevice_io_stream_new_values =
|
|
me4600_ao_io_stream_new_values;
|
|
subdevice->base.me_subdevice_io_stream_write =
|
|
me4600_ao_io_stream_write;
|
|
subdevice->base.me_subdevice_io_stream_start =
|
|
me4600_ao_io_stream_start;
|
|
subdevice->base.me_subdevice_io_stream_status =
|
|
me4600_ao_io_stream_status;
|
|
subdevice->base.me_subdevice_io_stream_stop = me4600_ao_io_stream_stop;
|
|
subdevice->base.me_subdevice_query_number_channels =
|
|
me4600_ao_query_number_channels;
|
|
subdevice->base.me_subdevice_query_subdevice_type =
|
|
me4600_ao_query_subdevice_type;
|
|
subdevice->base.me_subdevice_query_subdevice_caps =
|
|
me4600_ao_query_subdevice_caps;
|
|
subdevice->base.me_subdevice_query_subdevice_caps_args =
|
|
me4600_ao_query_subdevice_caps_args;
|
|
subdevice->base.me_subdevice_query_range_by_min_max =
|
|
me4600_ao_query_range_by_min_max;
|
|
subdevice->base.me_subdevice_query_number_ranges =
|
|
me4600_ao_query_number_ranges;
|
|
subdevice->base.me_subdevice_query_range_info =
|
|
me4600_ao_query_range_info;
|
|
subdevice->base.me_subdevice_query_timer = me4600_ao_query_timer;
|
|
|
|
return subdevice;
|
|
}
|
|
|
|
#endif // BOSCH
|
|
|
|
/* Common functions
|
|
*/
|
|
|
|
static int me4600_ao_query_range_by_min_max(me_subdevice_t * subdevice,
|
|
int unit,
|
|
int *min,
|
|
int *max, int *maxdata, int *range)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
|
|
instance = (me4600_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 <= (ME4600_AO_MAX_RANGE + 1000))
|
|
&& (*min >= ME4600_AO_MIN_RANGE)) {
|
|
*min = ME4600_AO_MIN_RANGE;
|
|
*max = ME4600_AO_MAX_RANGE;
|
|
*maxdata = ME4600_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 me4600_ao_query_number_ranges(me_subdevice_t * subdevice,
|
|
int unit, int *count)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
|
|
instance = (me4600_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 me4600_ao_query_range_info(me_subdevice_t * subdevice,
|
|
int range,
|
|
int *unit,
|
|
int *min, int *max, int *maxdata)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
PDEBUG("executed. idx=%d\n", instance->ao_idx);
|
|
|
|
if (range == 0) {
|
|
*unit = ME_UNIT_VOLT;
|
|
*min = ME4600_AO_MIN_RANGE;
|
|
*max = ME4600_AO_MAX_RANGE;
|
|
*maxdata = ME4600_AO_MAX_DATA;
|
|
} else {
|
|
PERROR("Invalid range number specified.\n");
|
|
return ME_ERRNO_INVALID_RANGE;
|
|
}
|
|
|
|
return ME_ERRNO_SUCCESS;
|
|
}
|
|
|
|
static int me4600_ao_query_timer(me_subdevice_t * subdevice,
|
|
int timer,
|
|
int *base_frequency,
|
|
long long *min_ticks, long long *max_ticks)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
PDEBUG("executed. idx=%d\n", instance->ao_idx);
|
|
|
|
if ((timer != ME_TIMER_ACQ_START) && (timer != ME_TIMER_CONV_START)) {
|
|
PERROR("Invalid timer specified.\n");
|
|
return ME_ERRNO_INVALID_TIMER;
|
|
}
|
|
|
|
if (instance->fifo) { //Streaming device.
|
|
*base_frequency = ME4600_AO_BASE_FREQUENCY;
|
|
if (timer == ME_TIMER_ACQ_START) {
|
|
*min_ticks = ME4600_AO_MIN_ACQ_TICKS;
|
|
*max_ticks = ME4600_AO_MAX_ACQ_TICKS;
|
|
} else if (timer == ME_TIMER_CONV_START) {
|
|
*min_ticks = ME4600_AO_MIN_CHAN_TICKS;
|
|
*max_ticks = ME4600_AO_MAX_CHAN_TICKS;
|
|
}
|
|
} else { //Not streaming device!
|
|
*base_frequency = 0;
|
|
*min_ticks = 0;
|
|
*max_ticks = 0;
|
|
}
|
|
|
|
return ME_ERRNO_SUCCESS;
|
|
}
|
|
|
|
static int me4600_ao_query_number_channels(me_subdevice_t * subdevice,
|
|
int *number)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
PDEBUG("executed. idx=%d\n", instance->ao_idx);
|
|
|
|
*number = 1;
|
|
|
|
return ME_ERRNO_SUCCESS;
|
|
}
|
|
|
|
static int me4600_ao_query_subdevice_type(me_subdevice_t * subdevice,
|
|
int *type, int *subtype)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
|
|
instance = (me4600_ao_subdevice_t *) subdevice;
|
|
|
|
PDEBUG("executed. idx=%d\n", instance->ao_idx);
|
|
|
|
*type = ME_TYPE_AO;
|
|
*subtype = (instance->fifo) ? ME_SUBTYPE_STREAMING : ME_SUBTYPE_SINGLE;
|
|
|
|
return ME_ERRNO_SUCCESS;
|
|
}
|
|
|
|
static int me4600_ao_query_subdevice_caps(me_subdevice_t * subdevice, int *caps)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
instance = (me4600_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 me4600_ao_query_subdevice_caps_args(struct me_subdevice *subdevice,
|
|
int cap, int *args, int count)
|
|
{
|
|
me4600_ao_subdevice_t *instance;
|
|
int err = ME_ERRNO_SUCCESS;
|
|
|
|
instance = (me4600_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) ? ME4600_AO_FIFO_COUNT : 0;
|
|
break;
|
|
|
|
case ME_CAP_AI_BUFFER_SIZE:
|
|
args[0] =
|
|
(instance->circ_buf.buf) ? ME4600_AO_CIRC_BUF_COUNT : 0;
|
|
break;
|
|
|
|
default:
|
|
PERROR("Invalid capability.\n");
|
|
err = ME_ERRNO_INVALID_CAP;
|
|
args[0] = 0;
|
|
}
|
|
|
|
return err;
|
|
}
|