libpdv.c

Go to the documentation of this file.

/* #pragma ident "@(#)libpdv.c  1.398 03/15/07 EDT" */

#include "edtinc.h"

#include <math.h>
/* #define NDEBUG  here or with make -DNDEBUG to turn off assert */
#include <assert.h>

#include "libedt_timing.h"

#ifdef _NT_
#define strncasecmp strnicmp
#endif

/* shorthand debug level */
#define PDVWARN PDVLIB_MSG_WARNING
#define PDVFATAL PDVLIB_MSG_FATAL
#define DBG1 PDVLIB_MSG_INFO_1
#define DBG2 PDVLIB_MSG_INFO_2

int Pdv_debug = 0;
int     Smd_type = NOT_SET;
int     Smd_rate = NOT_SET;

/*
* library routines
*/


#define PDV_DEPENDENT(pdv_p) ((pdv_p)->dd_p)

int check_register_wrap(EdtDev * edt_p);
static void debug_print_serial_command(char *cmd);
static void send_serial_binary_cmd(PdvDev * pdv_p, char *hexstr, int value);
static void pdv_trigger_specinst(PdvDev * pdv_p);
static void pdv_posttrigger_specinst(PdvDev * pdv_p);
static int pdv_specinst_setparam(PdvDev * pdv_p, char cmd, u_long offset, u_long value);

static int pdv_set_exposure_specinst(PdvDev * pdv_p, int value);
static int pdv_set_gain_specinst(PdvDev * pdv_p, int value);
static int pdv_set_exposure_adimec(PdvDev * pdv_p, int value);
static int pdv_set_exposure_su320(PdvDev * pdv_p, int value);
static int pdv_set_gain_adimec(PdvDev * pdv_p, int value);
static int pdv_set_blacklevel_adimec(PdvDev * pdv_p, int value);
static int pdv_set_exposure_smd(PdvDev * pdv_p, int value);
static int pdv_set_exposure_timc1001pf(PdvDev * pdv_p, int value);
static int pdv_set_exposure_ptm6710_1020(PdvDev * pdv_p, int value);
static int pdv_set_gain_ptm6710_1020(PdvDev * pdv_p, int value);
static int pdv_set_binning_generic(PdvDev * pdv_p, int value);
static int pdv_set_gain_smd(PdvDev * pdv_p, int value);
static int pdv_set_blacklevel_smd(PdvDev * pdv_p, int value);
static int pdv_set_gain_hc8484(PdvDev * pdv_p, int value);
static int pdv_set_exposure_toshiba(PdvDev * pdv_p, int value);
static int pdv_set_gain_toshiba(PdvDev * pdv_p, int value);
static int pdv_set_exposure_cohu(PdvDev * pdv_p, int value);
static int pdv_set_gain_cohu(PdvDev * pdv_p, int value);
static int pdv_set_blacklevel_cohu(PdvDev * pdv_p, int value);
static int pdv_total_block_size(PdvDev *pdv_p, int numbufs);
static void pdv_allocate_output_buffers(PdvDev *pdv_p);
static void pdv_free_output_buffers(PdvDev *pdv_p);
static int pdv_multibuf_block(PdvDev *pdv_p, int numbufs, u_char *block, int blocksize);
static int pdv_multibuf_separate(PdvDev *pdv_p, int numbufs, u_char **buffers);
static int pdv_set_roi_internal(PdvDev *pdv_p, int hskip, int hactv, int vskip, int vactv, int call_setsize) ;
static int pdv_specinst_serial_triggered(PdvDev * pdv_p);
static void CheckSumMessage(unsigned char *msg);
int     pdv_auto_set_timeout(PdvDev * pdv_p);
static int isafloat(char *str);
static int isdigits(char *str);
static int isxdigits(char *str);
static int update_int_from_serial(char **stat, int nstat, char *str, int *value);
static int update_string_from_serial(char **stat, int nstat, char *str, char *value, int maxlen);
static void update_hex_from_serial(char **stat, int nstat, char *str, int *value);
static void update_2dig_from_serial(char **stat, int nstat, char *str, int *val1, int *val2);
int     edt_get_rtimeout(PdvDev * pdv_p);
static int pdv_update_from_kodak_i(PdvDev * pdv_p);

static int pdv_update_from_atmel(PdvDev * pdv_p);
static int pdv_update_from_hamamatsu(PdvDev * pdv_p);
#ifdef IS_UNUSED
static int pdv_set_mode_atmel(PdvDev * pdv_p, char *mode);
static int pdv_set_mode_hamamatsu(PdvDev * pdv_p, char *mode);
#endif

static int pdv_set_exposure_timc1001pf(PdvDev * pdv_p, int value);

int     pdv_query_serial(PdvDev * pdv_p, char *cmd, char **resp);

/* from pdv_interlace.c */

void    pdv_dmy_data(void *buf, int width, int height, int depth);
void    pdv_alloc_tmpbuf(PdvDev * pdv_p);
extern  int pdv_process_inplace(PdvDev *pdv_p);
int     pdv_update_size(PdvDev * pdv_p);

static char *hex_to_str(char *resp, int n);

#ifdef DOXYGEN_SHOW_UNDOC

#endif

PdvDev *
pdv_open_channel(const char *dev_name, int unit, int channel)
{
    return pdv_open_device(dev_name, unit, channel, 1);
}

PdvDev *
pdv_open_device(const char *dev_name, int unit, int channel, int verbose)
{
    PdvDev *pdv_p;
    char    tmpname[64];
    Dependent *dd_p;
    static char *debug_env = NULL;
    int     level;

    if ((debug_env == NULL)
        && ((debug_env = (char *) getenv("PDVDEBUG")) != NULL)
        && *debug_env != '0')
    {
        Pdv_debug = atoi(debug_env);
        level = edt_msg_default_level();
        if (Pdv_debug > 0)
        {
            level |= DBG1;
            level |= DBG2;
        }
        edt_msg_set_level(edt_msg_default_handle(), level);

        edt_msg(DBG2, "environment DEBUG set to %d: enabling debug in pdvlib\n", Pdv_debug);
    }

    edt_msg(DBG2, "pdv_open_channel('%s', %d, %d)\n", dev_name ? dev_name : "NULL",
        unit, channel);

    if (dev_name == NULL)
        strcpy(tmpname, EDT_INTERFACE);
    else
        strcpy(tmpname, dev_name);
    if ((pdv_p = edt_open_device(tmpname, unit, channel, verbose)) == NULL)
        return NULL;


    /*
    * alloc and get the PDV dependent methods struct, which should have
    * been initialized in the driver by initcam.
    */
    if (sizeof(Dependent) > EDT_DEPSIZE)
    {
        edt_msg(PDVWARN, "pdv_open_channel: sizeof Dependent %d > DEPSIZE %d\n",
            sizeof(Dependent), EDT_DEPSIZE);
    }
    if ((dd_p = (Dependent *) malloc(EDT_DEPSIZE)) == NULL)
    {
        pdv_close(pdv_p);
        return NULL;
    }
    pdv_p->dd_p = dd_p;

    if (edt_get_dependent(pdv_p, dd_p) < 0)
    {
        free(dd_p);
        dd_p = 0;
        pdv_p->dd_p = NULL;
        pdv_close(pdv_p);
        return NULL;
    }

    pdv_p->tmpbufsize = 0;

    pdv_p->dd_p->xilinx_rev = 2;

    if (pdv_p->dd_p->swinterlace ||
        pdv_p->dd_p->interlace_module[0])
        pdv_setup_postproc(pdv_p, pdv_p->dd_p, NULL);

    return pdv_p;

}



PdvDev *
pdv_open(char *dev_name, int unit)
{
    return pdv_open_channel(dev_name, unit, 0);
}


void
pdv_setup_dma(PdvDev * pdv_p)

{
    /* This looks like bad stuff to put in the open function... */
    /* Since we might not always want to affect */

    edt_set_continuous(pdv_p, 0);
    pdv_p->dd_p->started_continuous = 0;

    edt_startdma_reg(pdv_p, PDV_CMD, PDV_ENABLE_GRAB);
}


int
pdv_close(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_close()\n");

    if (!pdv_p)
        return -1;
    if (pdv_p->dd_p)
    {
        free(pdv_p->dd_p);
        pdv_p->dd_p = 0;
    }

    pdv_free_output_buffers(pdv_p);

    return edt_close(pdv_p);
}

int
pdv_bytes_per_line(int width, int depth)

{
    if (depth == 1)
        return width >> 3;
    else if (depth == 2)
        return width >> 2;
    else if (depth == 4)
        return width >> 1;
    else if (depth == 80)
        return width + (width/4);
    else
        return width * bits2bytes(depth);
}

int
pdv_get_bytes_per_image(PdvDev *pdv_p)

{
    return pdv_p->dd_p->height * 
        pdv_bytes_per_line(pdv_p->dd_p->width, pdv_p->dd_p->depth);
}


int
pdv_get_width(PdvDev * pdv_p)
{
    if (!pdv_p->dd_p)
        return (0);

    edt_msg(DBG2, "pdv_get_width() %d\n", pdv_p->dd_p->width);


    return pdv_p->dd_p->width;
}

int
pdv_get_pitch(PdvDev * pdv_p)
{
    int pitch;

    if (!pdv_p->dd_p)
        return (0);

    pitch = pdv_bytes_per_line(pdv_p->dd_p->width, 
        pdv_p->dd_p->depth);

    edt_msg(DBG2, "pdv_get_pitch() %d\n", pitch);


    return pitch ;
}

int
pdv_get_cam_width(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_get_cam_width() %d\n", pdv_p->dd_p->cam_width);

    return pdv_p->dd_p->cam_width;
}

int
pdv_get_dmasize(PdvDev * pdv_p)
{
    Dependent *dd_p = PDV_DEPENDENT(pdv_p);

    int     size;
    int     extra_dma = 0;

    /* NEW header_within allocates extra buffer AND DMA the size of header_size */
    if (pdv_p->dd_p->header_position == HeaderBegin ||
        pdv_p->dd_p->header_position == HeaderMiddle ||
        pdv_p->dd_p->header_position == HeaderEnd)
        extra_dma = pdv_p->dd_p->header_size;

    if (dd_p->swinterlace == PDV_INV_RT_INTLV_24_12)
        size = dd_p->width * dd_p->height * 3 / 2;
    else if (dd_p->swinterlace == PDV_INTLV_10BIT_8TAP_PACKED
          || dd_p->swinterlace == PDV_INTLV_10BIT_8TAP_TO_8BIT)
        size = dd_p->height * pdv_bytes_per_line(pdv_p->dd_p->width, 80);
    else if (dd_p->depth > dd_p->extdepth) /* 24 bit bayer filter  or 1 bit or 80-bit data */
        size = dd_p->height * pdv_bytes_per_line(pdv_p->dd_p->width, pdv_p->dd_p->extdepth);
    else size = dd_p->height * pdv_bytes_per_line(pdv_p->dd_p->width, pdv_p->dd_p->depth);

    return size + extra_dma;
}

int
pdv_setsize(PdvDev * pdv_p, int width, int height)
{
    Dependent *dd_p = pdv_p->dd_p;
    int wuz_enabled = dd_p->roi_enabled;

    edt_msg(DBG2, "pdv_setsize(%d, %d)\n", width, height);

    dd_p->width = width;
    dd_p->height = height;
    pdv_set_roi_internal(pdv_p, dd_p->hskip, width, dd_p->vskip, height, 0);

    return pdv_update_size(pdv_p);

}

int
pdv_set_cam_width(PdvDev * pdv_p, int value)
{
    int     ret;
    Dependent *dd_p = pdv_p->dd_p;

    edt_msg(DBG2, "pdv_set_cam_width(%d)\n", value);

    dd_p->cam_width = value;

    ret = edt_set_dependent(pdv_p, dd_p);

    return ret;
}

int
pdv_get_imagesize(PdvDev * pdv_p)
{

    edt_msg(DBG2, "pdv_get_imagesize() %d\n", pdv_p->dd_p->imagesize);

    return pdv_p->dd_p->imagesize;
}

int
pdv_get_allocated_size(PdvDev * pdv_p)
{
    Dependent *dd_p = pdv_p->dd_p;
    int     total = 0;

    dd_p->imagesize = dd_p->width * dd_p->height * bits2bytes(dd_p->depth);

    total = pdv_p->dd_p->imagesize + pdv_p->dd_p->slop + pdv_p->dd_p->header_size;

#ifdef _NT_

    if (total % PAGESIZE)
    {
        total = ((total / PAGESIZE) + 1) * PAGESIZE;
    }
#endif

    edt_msg(DBG2, "pdv_get_allocated_size() %d\n", total);

    return total;

}

int
pdv_set_timeout(PdvDev * pdv_p, int value)
{
    Dependent *dd_p = pdv_p->dd_p;

    if (value < 0)
    {
        edt_msg(DBG2, "pdv_set_timeout(%d) (< 0, going back to auto)\n", value);

        pdv_p->dd_p->user_timeout_set = 0;
        edt_set_dependent(pdv_p, dd_p);
        return pdv_auto_set_timeout(pdv_p);
    }
    else
    {
        edt_msg(DBG2, "pdv_set_timeout(%d) (user set, overriding auto)\n", value);

        pdv_p->dd_p->user_timeout_set = 1;
        pdv_p->dd_p->user_timeout = value;
        edt_set_dependent(pdv_p, dd_p);
        return edt_set_rtimeout(pdv_p, value);
    }
}

int
pdv_get_timeout(PdvDev * pdv_p)
{

    edt_msg(DBG2, "pdv_get_timeout()\n");

    return edt_get_rtimeout(pdv_p);
}

int
pdv_picture_timeout(PdvDev * pdv_p, int value)
{
    return pdv_set_timeout(pdv_p, value);
}
 /* end settings */


int
pdv_timeouts(PdvDev * pdv_p)
{
    int     ret;

    ret = edt_timeouts(pdv_p);
    edt_msg(DBG2, "pdv_timeouts(%d)\n", ret);

    return ret;
}


int
pdv_timeout_cleanup(PdvDev * pdv_p)
{
    int     curdone, curtodo;

    curdone = edt_done_count(pdv_p);
    curtodo = edt_get_todo(pdv_p);
    pdv_stop_continuous(pdv_p);
    edt_msleep(500);
    edt_set_buffer(pdv_p, curdone);
    edt_reg_write(pdv_p, PDV_CMD, PDV_RESET_INTFC);
    pdv_setup_continuous(pdv_p);
    return curtodo - curdone;
}
 /* end acquisition */


int
pdv_get_height(PdvDev * pdv_p)
{
    if (!pdv_p->dd_p)
        return (0);

    edt_msg(DBG2, "pdv_get_height() %d\n", pdv_p->dd_p->height);

    return pdv_p->dd_p->height;
}

int
pdv_get_cam_height(PdvDev * pdv_p)
{

    edt_msg(DBG2, "pdv_get_cam_height() %d\n", pdv_p->dd_p->cam_height);

    return pdv_p->dd_p->cam_height;
}


int
pdv_get_frame_height(PdvDev * pdv_p)
{

    edt_msg(DBG2, "pdv_get_cam_height() %d\n", pdv_p->dd_p->cam_height);

    return pdv_p->dd_p->frame_height;
}
 /* end settings */

int
pdv_update_size(PdvDev *pdv_p)

{
    Dependent *dd_p = pdv_p->dd_p;
    int ret;

    edt_msg(DBG2, "update_size\n");

    dd_p->imagesize = dd_p->height * pdv_get_pitch(pdv_p);

    ret = edt_set_dependent(pdv_p, dd_p);

    if (pdv_p->ring_buffer_numbufs > 0)
        pdv_multibuf(pdv_p, pdv_p->ring_buffer_numbufs);

    if (dd_p->swinterlace)
    {
        pdv_alloc_tmpbuf(pdv_p);
    }

    return ret;
}

int
pdv_set_width(PdvDev * pdv_p, int value)
{
    Dependent *dd_p = pdv_p->dd_p;

    edt_msg(DBG2, "pdv_set_width(%d)\n", value);

    dd_p->width = value;

    pdv_set_roi(pdv_p, dd_p->hskip, dd_p->width, dd_p->vskip, dd_p->height);
    return pdv_update_size(pdv_p);

}

int
pdv_set_height(PdvDev * pdv_p, int value)
{
    Dependent *dd_p = pdv_p->dd_p;

    edt_msg(DBG2, "pdv_set_height(%d)\n", value);

    dd_p->height = value;

    pdv_set_roi(pdv_p, dd_p->hskip, dd_p->width, dd_p->vskip, dd_p->height);

    return pdv_update_size(pdv_p);

}

int
pdv_set_cam_height(PdvDev * pdv_p, int value)
{
    int     ret;
    Dependent *dd_p = pdv_p->dd_p;

    edt_msg(DBG2, "pdv_set_cam_height(%d)\n", value);

    dd_p->cam_height = value;

    ret = edt_set_dependent(pdv_p, dd_p);
    return ret;
}


int
pdv_get_depth(PdvDev * pdv_p)
{
    if (!pdv_p->dd_p)
        return (0);

    edt_msg(DBG2, "pdv_get_depth() %d\n", pdv_p->dd_p->depth);

    return pdv_p->dd_p->depth;
}

int
pdv_get_extdepth(PdvDev * pdv_p)
{

    edt_msg(DBG2, "pdv_get_extdepth() %d\n", pdv_p->dd_p->extdepth);

    return pdv_p->dd_p->extdepth;
}

int
pdv_set_depth_extdepth(PdvDev * pdv_p, int depth, int extdepth)
{
    /* just call the internal */
    return pdv_set_depth_extdepth_dpath(pdv_p, depth, extdepth, 0);
}

int
pdv_set_depth_extdepth_dpath(PdvDev * pdv_p, int depth, int extdepth, u_int dpath)
{
    Dependent *dd_p = pdv_p->dd_p;

    dd_p->depth = depth;
    dd_p->extdepth = extdepth;

    /* set cameralink data path register, if appropriate -- note that
    * odball values are generally  handled differently (e.g.
    * pdvcamlk_pir which has hard-coded depth)
    */
    if (pdv_is_cameralink(pdv_p))
    {
        if (dpath)
        {
            edt_reg_write(pdv_p, PDV_CL_DATA_PATH, dpath);
            dd_p->cl_data_path = dpath;
        }
        else
        {
            int reg;

            if ((depth == 10) && (extdepth == 80))
                reg = 0x79; /* 8-tap 10-bit packed */

            else if (depth == 24)
            {
                reg = 0x7;
                if (extdepth == 24) /* true RGB not bayer */
                    reg = 0x27;

            }

            else if (depth == 32)
                reg = 0x07; /* 4-tap RGBI */

            else if (depth == 30) /* is this anywhere? */
                reg = 0x09;

            else if ((depth >= 8) && (depth <= 16)) /* typical 10-16 bit */
                reg = depth-1;

            else reg = 0;

            if (reg)
            {
                if ((dd_p->dual_channel) && ((reg & 0xf0) == 0))
                    reg |= 0x10;
                dd_p->cl_data_path = reg;
                edt_reg_write(pdv_p, PDV_CL_DATA_PATH, dd_p->cl_data_path);
            }
        }
    }

    edt_msg(DBG2, "pdv_set_depth_extdepth_dpath(%d, %d, %02x (%02x))\n", depth, extdepth, dpath, dd_p->cl_data_path);

    return pdv_update_size(pdv_p);

}


int
pdv_set_depth(PdvDev * pdv_p, int value)
{
    Dependent *dd_p = pdv_p->dd_p;

    dd_p->depth = value;

    /* set cameralink data path register, if appropriate -- note that
    * odball values are generally  handled differently (e.g.
    * pdvcamlk_pir which has hard-coded depth)
    */
    if (pdv_is_cameralink(pdv_p))
    {
        int reg;

        if ((value >= 8) && (value <= 16))
            reg = value-1;
        else if (value == 24 || value == 32)
            reg = 0x7;
        else if (value == 30)
            reg = 0x9;
        else reg = 0;

        if (reg)
        {
            if ((dd_p->dual_channel) && ((reg & 0xf0) == 0))
                reg |= 0x10;
            dd_p->cl_data_path = reg;
            edt_reg_write(pdv_p, PDV_CL_DATA_PATH, dd_p->cl_data_path);
        }
    }

    edt_msg(DBG2, "pdv_set_depth(%d)\n", value);
    return pdv_update_size(pdv_p);

}

int
pdv_set_extdepth(PdvDev * pdv_p, int value)
{
    int     ret;
    Dependent *dd_p = pdv_p->dd_p;

    dd_p->extdepth = value;

    edt_msg(DBG2, "pdv_set_extdepth(%d)\n", value);

    ret = edt_set_dependent(pdv_p, dd_p);

    return ret;
}

int
pdv_set_cameratype(PdvDev * pdv_p, char *model)
{
    Dependent *dd_p = pdv_p->dd_p;

    edt_msg(DBG2, "pdv_set_cameratype(%s)\n", model);

    strcpy(dd_p->cameratype, model);

    return edt_set_dependent(pdv_p, dd_p);
}


char   *
pdv_get_cameratype(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_get_cameratype()\n");

    return pdv_p->dd_p->cameratype;
}


char   *
pdv_get_camera_class(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_get_camera_class()\n");

    return pdv_p->dd_p->camera_class;
}


char   *
pdv_get_camera_model(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_get_camera_model()\n");

    return pdv_p->dd_p->camera_model;
}

char   *
pdv_get_camera_info(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_get_camera_info()\n");

    return pdv_p->dd_p->camera_info;
}

char   *
pdv_camera_type(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_camera_type()\n");

    return pdv_p->dd_p->cameratype;
}
 /* end settings */

static int
smd_read_reg(PdvDev * pdv_p, int reg)
{
    u_char  buf[128];
    int     ret;

    /* flush out any junk */
    pdv_serial_read(pdv_p, (char *) buf, 64);

    /* read SMD frame rate register */
    buf[0] = (u_char) reg;
    pdv_serial_binary_command(pdv_p, (char *) buf, 1);

    ret = pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout, pdv_p->dd_p->serial_respcnt);
    if (ret == 0)
        return -1;
    pdv_serial_read(pdv_p, (char *) buf, ret);
    return (int) buf[0];
}

/*
* for serial_format new as of 4.2.3.2 -- allow serial_exposure/gain/blacklevel
* to be a %x or %d or some such, e.g. EXP %d or SM=%02x. Note: Up to 4 % expressions
* can be present but the same value will be entered for each
* ONE % expression. Allow \% to go through 
* RETURNS:  number of % expressions, or -1 if invalid format
*/
static int
check_valid_formatstr(char *str)
{
    int i, len = (int)strlen(str);
    int ret = 0;

    for (i=0; i<len; i++)
    {
        if (str[i] == '%')
        {
            if ((i > 0) && (str[i-1] != '\\')) /* escaped so never mind */
                ++ret;
            else if (i == len-1) /* % can't be the last character unless escaped */
            {
                ret = -1;
                break;
            }
            /* ALERT should be more checks here, for valid formatting */
        }
    }
    return ret;
}

int
pdv_set_exposure(PdvDev * pdv_p, int value)
{
    int     ret = -1;
    Dependent *dd_p = pdv_p->dd_p;
    char    cmdstr[64];
    int     n;

    cmdstr[0] = '\0';

    edt_msg(DBG2, "pdv_set_exposure(%d)\n", value);

    dd_p->shutter_speed = value;

    if (edt_set_dependent(pdv_p, dd_p) < 0)
    {
        edt_msg(DBG2, "pdv_set_exposure ret %d\n", ret);
        return -1;
    }

    pdv_auto_set_timeout(pdv_p);

    if ((dd_p->camera_shutter_timing == AIA_MCL)
        && (dd_p->mode_cntl_norm & 0xf0)
        && (!dd_p->trig_pulse))
    {
        ret = pdv_set_exposure_mcl(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == AIA_MCL_100US)
    {
        /* in this case do mcl even if trig_pulse */
        ret = pdv_set_exposure_mcl(pdv_p, value);
    }
    else if ((strlen(dd_p->serial_exposure) >= 0) && (dd_p->serial_format == SERIAL_BINARY))
    {
        send_serial_binary_cmd(pdv_p, dd_p->serial_exposure, value);
    }
    else if ((strlen(dd_p->serial_exposure) >= 0)
        && ((dd_p->serial_format == SERIAL_ASCII)
        || (dd_p->serial_format == SERIAL_ASCII_HEX)
        || (dd_p->serial_format == SERIAL_PULNIX_1010)))
    {
        /* special serial cmd for ham 4880 */
        /* ALERT: get rid of this, s/b camera_shutter_timing here and */
        /* in config files and everywhere else....! */
        if (dd_p->camera_shutter_timing == HAM_4880_SER)
        {
            int     minutes;
            int     seconds;
            int     useconds;

            minutes = value / 60000;
            value -= minutes * 60000;

            seconds = value / 1000;
            value -= seconds * 1000;

            useconds = value;

            sprintf(cmdstr, "%s %04d:%02d.%03d",
                dd_p->serial_exposure, minutes, seconds, useconds);
        }

        else switch(dd_p->serial_format)
        {

            case SERIAL_ASCII_HEX:
                sprintf(cmdstr, "%s %02x", dd_p->serial_exposure, value);
                break;

            case SERIAL_PULNIX_1010:
                sprintf(cmdstr, "%s%d", dd_p->serial_exposure, value);
                break;

            case SERIAL_ASCII:
            default:
                {
                    int n = check_valid_formatstr(dd_p->serial_exposure); 

                    cmdstr[0] = '\0';

                    if (n == 0) /* no % formatting, use old method */
                    {
                        if (dd_p->serial_exposure[0])
                            sprintf(cmdstr, "%s %d", dd_p->serial_exposure, value);
                    }
                    else if ((n > 0) && (n < 5))
                        sprintf(cmdstr, dd_p->serial_exposure, value, value, value, value);

                    if (cmdstr[0])
                    {
                        ret = pdv_serial_command_flagged(pdv_p, cmdstr, SCFLAG_NORESP);

                        pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout, 64);
                        if (*pdv_p->dd_p->serial_response)
                            pdv_serial_read(pdv_p, cmdstr, 63);
                    }
                }

                if (check_valid_formatstr(dd_p->serial_exposure) >= 1)
                    sprintf(cmdstr, dd_p->serial_exposure, value, value, value, value);
                else sprintf(cmdstr, "%s %d", dd_p->serial_exposure, value);
                break;
        }

        if (cmdstr[0])
        {
            ret = pdv_serial_command_flagged(pdv_p, cmdstr, SCFLAG_NORESP);
            n = pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout, pdv_p->dd_p->serial_respcnt);
            if (*pdv_p->dd_p->serial_response)
                if (n)
                    pdv_serial_read(pdv_p, cmdstr, n);
        }
    }
    else if ((dd_p->camera_shutter_timing == SPECINST_SERIAL)
        || (dd_p->camera_shutter_speed == SPECINST_SERIAL))
    {
        ret = pdv_set_exposure_specinst(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == SMD_SERIAL)
    {
        ret = pdv_set_exposure_smd(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == PTM6710_SERIAL)
    {
        ret = pdv_set_exposure_ptm6710_1020(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == TOSHIBA_SERIAL)
    {
        ret = pdv_set_exposure_toshiba(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == COHU_SERIAL)
    {
        ret = pdv_set_exposure_cohu(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == PTM1020_SERIAL)
    {
        ret = pdv_set_exposure_ptm6710_1020(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == TIMC1001_SERIAL)
    {
        ret = pdv_set_exposure_timc1001pf(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == ADIMEC_SERIAL)
    {
        ret = pdv_set_exposure_adimec(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == BASLER202K_SERIAL)
    {
        ret = pdv_set_exposure_basler202k(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == SU320_SERIAL)
    {
        ret = pdv_set_exposure_su320(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == HAM_4880_SER)
    {
        /* controlled by serial; do nothing */
    }
    else if (dd_p->camera_shutter_timing == AIA_SERIAL)
    {
        /* controlled by serial; do nothing */
    }
    else if (dd_p->camera_shutter_timing == AIA_SERIAL_ES40)
    {
        /* controlled by serial; do nothing */
    }
    else if (dd_p->camera_shutter_timing == AIA_TRIG)
    {
        ret = pdv_set_exposure_mcl(pdv_p, value);
    }
    else if (!dd_p->trig_pulse)
    {
        /* default to aia mcl if not trig_pulse */
        ret = pdv_set_exposure_mcl(pdv_p, value);
    }

    edt_msg(DBG2, "pdv_set_exposure returns %d\n", ret);
    return (ret);
}

int
pdv_set_exposure_mcl(PdvDev * pdv_p, int value)
{
    u_int   data_path;

    if (value < 0)
        value = 0;
    if (value > 25500)
        value = 25500;

    pdv_p->dd_p->shutter_speed = value;

    data_path = pdv_p->dd_p->datapath_reg;
    data_path &= ~PDV_MULTIPLIER_MASK;


    /*
    * special case microsecond shutter timer
    */
    if (pdv_p->dd_p->camera_shutter_timing == AIA_MCL_100US)
    {
        edt_msg(DBG2, "pdv_set_exposure_mcl(%d) (100US)\n", value);

        if (value < 256)
        {
            data_path |= PDV_MULTIPLIER_100US;
        }
        else if (value < 2560)
        {
            /* already turned off multiplier */
            value = (value + 5) / 10;
        }
        else if (value < 25600)
        {
            data_path |= PDV_MULTIPLIER_10MS;
            value = (value + 50) / 100;
        }
        else if (value < 256000)
        {
            data_path |= PDV_MULTIPLIER_100MS;
            value = (value + 50) / 1000;
        }
    }
    else
    {
        edt_msg(DBG2, "pdv_set_exposure_mcl(%d)\n", value);

        if (value < 256)
        {
            /* already turned off multiplier */
        }
        else if (value < 2560)
        {
            data_path |= PDV_MULTIPLIER_10MS;
            value = (value + 5) / 10;
        }
        else
        {
            data_path |= PDV_MULTIPLIER_100MS;
            value = (value + 50) / 100;
        }
    }

    pdv_p->dd_p->datapath_reg = data_path;
    edt_reg_write(pdv_p, PDV_SHUTTER, value);
    edt_reg_write(pdv_p, PDV_DATA_PATH, data_path);

    return 0;
}

static int
pdv_set_exposure_smd(PdvDev * pdv_p, int value)
{
    int     fp = 0;
    u_char  buf[128];
    int     n;
    int     ret = 0;
    int     smd_reg1, smd_reg3;


    if (Smd_type == NOT_SET)
    {
        Smd_type = smd_read_reg(pdv_p, SMD_READ_CAMTYPE);
        if ((Smd_type & 0xfff) == 0xfff)        /* sometimes there's garbage
                                            * at first; if so try again */
                                            Smd_type = smd_read_reg(pdv_p, SMD_READ_CAMTYPE);
    }

    /* send SMD write integration reg. command and arg */
    switch (Smd_type)
    {
    case SMD_TYPE_4M4:
        /*
        * set time to send, then write that based on msecs (value is int so
        * can't do 0.5msec, just use 0 for that -- $#^&*@ screwy way to do
        * it if you ask me.....) buf[0] = (u_char) SMD_4M4_WRITE_R2;
        */
        if (value == 0)         /* 500us */
            buf[1] = 0x7d;
        else if (value == 1)    /* 1ms */
            buf[1] = 0x7b;
        else if (value == 2)    /* 2ms */
            buf[1] = 0x77;
        else if (value <= 4)    /* 4ms */
            buf[1] = 0x6f;
        else if (value <= 8)    /* 8ms */
            buf[1] = 0x5f;
        else if (value <= 16)   /* 16ms */
            buf[1] = 0x3f;
        else                    /* 32ms (default) */
            buf[1] = 0x00;
        /*
        * send write r2 (integration reg) command
        */
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);
        break;

    case SMD_TYPE_BT25:
        /*
        * adjust timeout multiplier according to frame rate
        */
        buf[0] = (u_char) SMD_BT25_WRITE_R2;
        if (Smd_rate == NOT_SET)
        {
            if ((Smd_rate = smd_read_reg(pdv_p, SMD_BT25_READ_FRAMERATE)) == -1)
                edt_msg(PDVWARN, "libpdv: no response from SMD camera rate reg read\n");
            if (pdv_p->dd_p->timeout_multiplier < Smd_rate)
            {
                pdv_p->dd_p->timeout_multiplier = Smd_rate;
                pdv_auto_set_timeout(pdv_p);
            }
        }
        buf[1] = (u_char) value;
        /*
        * send write r2 (integration reg) command
        */
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);

        /* SMD doesn't resp but do a dummy wait to make sure its done */
        pdv_serial_wait(pdv_p, 100, 64);
        break;

    case SMD_TYPE_1M30P:
    case SMD_TYPE_6M3P:
        buf[0] = (u_char) SMD_1M30P_REG_W_INTEG0;
        buf[1] = value & 0xff;
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);

        buf[0] = (u_char) SMD_1M30P_REG_W_INTEG1;
        buf[1] = (value & 0xff00) >> 8;
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);

        buf[0] = (u_char) SMD_1M30P_REG_W_INTEG2;
        buf[1] = (value & 0xff0000) >> 16;
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);

        /*
        * SMD 1M30p  shutter speeds are in uSecs, so fake out
        * pdv_auto_set_timeout, then switch speed back to actual value
        */
        /*
        * ALERT: should take frame rate (& binning?) into account here too
        */
        pdv_p->dd_p->shutter_speed = value / 1000;
        pdv_auto_set_timeout(pdv_p);
        pdv_p->dd_p->shutter_speed = value;
        break;

    case SMD_TYPE_1M15P:
        if ((smd_reg1 = smd_read_reg(pdv_p, SMD_1M15P_READ_R1)) == -1)
        {
            edt_msg(PDVWARN, "libpdv: no response from SMD R1 reg read\n");
            return -1;
        }


        buf[0] = (u_char) SMD_1M15P_WRITE_R1;

        /*
        * valid values for this camera are 0, 1, 2, 4 and 8, but allow values
        * in between and just round down 
        */
        if (value == 0)
        {
            buf[1] = (smd_reg1 &~ SMD_1M15P_R1_INTMSK) | 0x0; /* NONE */
            fp = 65000;
        }
        else if (value == 1)
        {
            buf[1] = (smd_reg1 &~ SMD_1M15P_R1_INTMSK) | 0x7; /* 1 ms */
            fp = 65000;
        }
        else if (value < 4)
        {
            buf[1] = (smd_reg1 &~ SMD_1M15P_R1_INTMSK) | 0x6; /* 2 ms */
            fp = 64000;
        }
        else if (value < 7)
        {
            buf[1] = (smd_reg1 &~ SMD_1M15P_R1_INTMSK) | 0x5; /* 4 ms */
            fp = 62000;
        }
        else if (value == 8)
        {
            buf[1] = (smd_reg1 &~ SMD_1M15P_R1_INTMSK) | 0x4; /* 8 ms */
            fp = 58000;
        }
        else return -1;

        if (smd_reg1 & SMD_1M15P_R1_TRIGMODE)
        {
            /* if binned and triggered, use half the frame delay */ 
            smd_reg3 = smd_read_reg(pdv_p, SMD_1M15P_READ_R3);
            if (smd_reg3 & 0x40) /* 2x2 bin mode bit */
                fp /= 2;
            pdv_set_frame_period(pdv_p, fp, PDV_FVAL_ADJUST);
        }

        pdv_p->dd_p->shutter_speed = value;
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);
        break;

    default:
        ret = -1;
        edt_msg(PDVWARN, "libpdv: unknown SMD camera type %02x\n", Smd_type);
        break;
    }

    if (!ret)
    {
        /* SMD doesn't respond but do a dummy wait to make sure its done */
        n = pdv_serial_wait(pdv_p, 100, 64);
        if (n > 127)
            n = 127;
        if (n)
            pdv_serial_read(pdv_p, (char *) buf, n);
    }
    return ret;
}

static int
pdv_set_exposure_timc1001pf(PdvDev * pdv_p, int value)
{
    Dependent *dd_p = pdv_p->dd_p;
    u_int   mcl = edt_reg_read(pdv_p, PDV_MODE_CNTL) & 0xf1;

    if ((value >= 0) && (value <= 7))
    {
        dd_p->shutter_speed = value;
        mcl |= (value << 1);
        edt_reg_write(pdv_p, PDV_MODE_CNTL, mcl);
        return 0;
    }
    return -1;
}

static int
pdv_set_exposure_toshiba(PdvDev * pdv_p, int value)
{
    char    cmdbuf[128];
    int n;

    if ((value < 0) || (value > 0xff))
        return -1;

    cmdbuf[0] = 0x02;
    sprintf(cmdbuf+1, "68%02X", value);
    cmdbuf[5] = 0x03;
    pdv_serial_binary_command(pdv_p, (char *)cmdbuf, 6);

    /* response should be <STX><ACK><ETX> */
    if (n = pdv_serial_wait(pdv_p, 200, 3))
        pdv_serial_read(pdv_p, cmdbuf, n);

    cmdbuf[0] = 0x02;
    sprintf(cmdbuf+1, "6E01");
    cmdbuf[5] = 0x03;
    pdv_serial_binary_command(pdv_p, (char *)cmdbuf, 6);

    /* response should be <STX><ACK><ETX> */
    if (n = pdv_serial_wait(pdv_p, 200, 3))
        pdv_serial_read(pdv_p, cmdbuf, n);

    return 0;
}

static int
pdv_set_gain_toshiba(PdvDev * pdv_p, int value)
{
    char    cmdbuf[128];
    int n;

    if ((value < 0) || (value > 0xff))
        return -1;

    cmdbuf[0] = 0x02;
    sprintf(cmdbuf+1, "64%02X", value);
    cmdbuf[5] = 0x03;
    pdv_serial_binary_command(pdv_p, (char *)cmdbuf, 6);

    /* response should be <STX><ACK><ETX> */
    if (n = pdv_serial_wait(pdv_p, 200, 3))
        pdv_serial_read(pdv_p, cmdbuf, n);

    cmdbuf[0] = 0x02;
    sprintf(cmdbuf+1, "6E01");
    cmdbuf[5] = 0x03;
    pdv_serial_binary_command(pdv_p, (char *)cmdbuf, 6);

    /* response should be <STX><ACK><ETX> */
    if (n = pdv_serial_wait(pdv_p, 200, 3))
        pdv_serial_read(pdv_p, cmdbuf, n);

    return 0;
}

static int
pdv_set_exposure_cohu(PdvDev * pdv_p, int value)
{
    char    cmdbuf[128];
    int n, len;

    if ((value < 0) || (value > 10))
        return -1;

    /* send STX ID 'c' 'E' value 81 ETX (value is ASCII int, 81 is dummy checksum) */
    cmdbuf[0] = 0x02; /* STX */
    cmdbuf[1] = 0x01; /* Camera ID 1 */
    sprintf(cmdbuf+2, "cE2,%d", value);
    len = (int)strlen(cmdbuf);
    cmdbuf[len++] = (char)0x81;
    cmdbuf[len++] = (char)0x03;
    cmdbuf[len] = 0;
    pdv_serial_binary_command(pdv_p, (char *)cmdbuf, len);

    /* ALERT: check for specific response [ STX ID 'c' 'C' '0' CS ETX ] here? */
    if (n = pdv_serial_wait(pdv_p, 200, 7))
        pdv_serial_read(pdv_p, cmdbuf, n);

    /* send STX 'c' 'T' '0' 81 ETX (required to "make it so") */
    cmdbuf[0] = (char)0x02; /* STX */
    cmdbuf[1] = (char)0x01; /* Camera ID 1 */
    cmdbuf[2] = 'c';
    cmdbuf[3] = 'T';
    cmdbuf[4] = '0';
    cmdbuf[5] = (char)0x81;
    cmdbuf[6] = (char)0x03;
    pdv_serial_binary_command(pdv_p, (char *)cmdbuf, 7);

    /* ALERT: check for specific response [ STX ID 'c' 'C' '0' CS ETX ] here? */
    if (n = pdv_serial_wait(pdv_p, 200, 7))
        pdv_serial_read(pdv_p, cmdbuf, n);

    return 0;
}

static int
pdv_set_gain_cohu(PdvDev * pdv_p, int value)
{
    char    cmdbuf[128];
    int n, len;

    if ((value < 0) || (value > 320))
        return -1;

    /* send STX ID 'c' 'E' value 81 ETX (value is ASCII int, 81 is dummy checksum) */
    cmdbuf[0] = (char)0x02; /* STX */
    cmdbuf[1] = (char)0x01; /* Camera ID 1 */
    sprintf(cmdbuf+2, "cB1,%d", value);
    len = (int)strlen(cmdbuf);
    cmdbuf[len++] = (char)0x81;
    cmdbuf[len++] = (char)0x03;
    cmdbuf[len] = 0;
    pdv_serial_binary_command(pdv_p, (char *)cmdbuf, len);

    /* ALERT: check for specific response [ STX ID 'c' 'C' '0' CS ETX ] here? */
    if (n = pdv_serial_wait(pdv_p, 200, 7))
        pdv_serial_read(pdv_p, cmdbuf, n);

    /* send STX 'c' 'T' '0' 81 ETX (required to "make it so") */
    cmdbuf[0] = (char)0x02; /* STX */
    cmdbuf[1] = (char)0x01; /* Camera ID 1 */
    cmdbuf[2] = 'c';
    cmdbuf[3] = 'T';
    cmdbuf[4] = '0';
    cmdbuf[5] = (char)0x81;
    cmdbuf[6] = (char)0x03;
    pdv_serial_binary_command(pdv_p, (char *)cmdbuf, 7);

    /* ALERT: check for specific response [ STX ID 'c' 'C' '0' CS ETX ] here? */
    if (n = pdv_serial_wait(pdv_p, 200, 7))
        pdv_serial_read(pdv_p, cmdbuf, n);

    return 0;
}

static int
pdv_set_blacklevel_cohu(PdvDev * pdv_p, int value)
{
    char    cmdbuf[128];
    int n, len;

    if ((value < 0) || (value > 1023))
        return -1;

    /* send STX ID 'c' 'E' value 81 ETX (value is ASCII int, 81 is dummy checksum) */
    cmdbuf[0] = 0x02; /* STX */
    cmdbuf[1] = 0x01; /* Camera ID 1 */
    sprintf(cmdbuf+2, "cB0,%d", value);
    len = (int)strlen(cmdbuf);
    cmdbuf[len++] = (char)0x81;
    cmdbuf[len++] = (char)0x03;
    cmdbuf[len] = 0;
    pdv_serial_binary_command(pdv_p, (char *)cmdbuf, len);

    /* ALERT: check for specific response [ STX ID 'c' 'C' '0' CS ETX ] here? */
    if (n = pdv_serial_wait(pdv_p, 200, 7))
        pdv_serial_read(pdv_p, cmdbuf, n);

    /* send STX 'c' 'T' '0' 81 ETX (required to "make it so") */
    cmdbuf[0] = (char)0x02; /* STX */
    cmdbuf[1] = (char)0x01; /* Camera ID 1 */
    cmdbuf[2] = 'c';
    cmdbuf[3] = 'T';
    cmdbuf[4] = '0';
    cmdbuf[5] = (char)0x81;
    cmdbuf[6] = (char)0x03;
    pdv_serial_binary_command(pdv_p, (char *)cmdbuf, 7);

    /* ALERT: check for specific response [ STX ID 'c' 'C' '0' CS ETX ] here? */
    if (n = pdv_serial_wait(pdv_p, 200, 7))
        pdv_serial_read(pdv_p, cmdbuf, n);

    return 0;
}

static int
pdv_set_exposure_ptm6710_1020(PdvDev * pdv_p, int value)
{
    char    buf[128];

    if ((value < 0) || (value > 9))
        return -1;

    sprintf(buf, ":SM%d", value);
    pdv_serial_command_flagged(pdv_p, buf, SCFLAG_NORESP);

    return 0;
}

static int
pdv_set_gain_ptm6710_1020(PdvDev * pdv_p, int value)
{
    char    buf[128];

    if ((value < 0) || (value > 0xff))
        return -1;

    sprintf(buf, ":GM%02X", value);
    pdv_serial_command_flagged(pdv_p, buf, SCFLAG_NORESP);

    return 0;
}

static int
pdv_set_gain_hc8484(PdvDev * pdv_p, int value)
{
    char    buf[128];

    if ((value != 0) && (value != 1))
        return -1;
    sprintf(buf, "CEG %c", value ? 'H' : 'L');
    pdv_serial_command_flagged(pdv_p, buf, SCFLAG_NORESP);

    return 0;
}

static int
pdv_set_exposure_adimec(PdvDev * pdv_p, int value)
{
    char    cmdbuf[32];

    sprintf(cmdbuf, "@IT%d", value);
    pdv_serial_command(pdv_p, cmdbuf);
    return 0;
}

static int
pdv_set_gain_adimec(PdvDev * pdv_p, int value)
{
    char    cmdbuf[32];

    sprintf(cmdbuf, "@GA%d", value);
    pdv_serial_command(pdv_p, cmdbuf);
    return 0;
}

static int
pdv_set_blacklevel_adimec(PdvDev * pdv_p, int value)
{
    char    cmdbuf[32];

    sprintf(cmdbuf, "@BL%d;%d", value, value);
    pdv_serial_command(pdv_p, cmdbuf);
    return 0;
}


static int
pdv_set_exposure_specinst(PdvDev * pdv_p, int value)
{
    edt_msg(DBG2, "pdv_set_exposure_specinst(%d)\n", value);

    if (pdv_specinst_setparam(pdv_p, 'G', 8, value) != 0)
    {
        edt_msg(DBG2, "pdv_set_exposure_specinst() apparently FAILED\n");
        return -1;
    }
    return 0;
}

static int
pdv_set_gain_specinst(PdvDev * pdv_p, int value)
{
    edt_msg(DBG2, "pdv_set_gain_specinst(%d)\n", value);

    if (pdv_specinst_setparam(pdv_p, 'G', 11, value) != 0)
    {
        edt_msg(DBG2, "pdv_set_gain_specinst() apparently FAILED\n");
        return -1;
    }
    return 0;
}

static int
pdv_set_exposure_su320(PdvDev * pdv_p, int value)
{
    char    cmdbuf[32];
    char resp[1024];
    int n;

    sprintf(cmdbuf, "INT%d", value);
    pdv_serial_command(pdv_p, cmdbuf);
    pdv_serial_wait(pdv_p, 100, 20);
    if ((n = pdv_serial_read(pdv_p, resp, 20)) != 20)
        return -1;
    return 0;
}


static int
pdv_specinst_setparam(PdvDev * pdv_p, char cmd, u_long offset, u_long value)
{
    int     ret1, ret2, ret3;
    char    resp1[32];
    char    resp2[32];
    char    buf[32];
    u_char  cmdbuf[5];
    u_char  offsetbuf[5];
    u_char  parambuf[5];
    int     si_wait = 200;

    edt_msg(DBG2, "pdv_specinst_setparam(%c %04x %04x)\n", cmd, offset, value);

    dvu_long_to_charbuf(offset, offsetbuf);
    dvu_long_to_charbuf(value, parambuf);

    cmdbuf[0] = cmd;

    pdv_serial_binary_command(pdv_p, (char *) cmdbuf, 1);
    pdv_serial_wait_next(pdv_p, si_wait, 31);
    ret1 = pdv_serial_read(pdv_p, resp1, 31);

    pdv_serial_binary_command(pdv_p, (char *) offsetbuf, 4);
    pdv_serial_wait_next(pdv_p, si_wait, 31);
    ret2 = pdv_serial_read(pdv_p, buf, 31);

    pdv_serial_binary_command(pdv_p, (char *) parambuf, 4);
    pdv_serial_wait_next(pdv_p, si_wait, 31);
    ret3 = pdv_serial_read(pdv_p, resp2, 31);

    if ((ret1 != 1) || (ret3 != 1) || (resp1[0] != 'G') || (resp2[0] != 'Y'))
    {
        edt_msg(DBG1, "invalid or missing serial response from specinst\n");
        return -1;
    }
    return 0;
}

int
pdv_send_basler_command(PdvDev * pdv_p, int cmd, int rwflag, int len, int data)
{
    int       i;
    u_char    frame[32];
    u_char    rwbit = (rwflag & 0x1) << 7;

    frame[0] = cmd;                           
    frame[1] = ((u_char)len & 0xef) | rwbit;
    for (i=0; i<len; i++)
        frame[i+2] = (data >> (8 * i)) & 0xff;

    return pdv_send_basler_frame(pdv_p, frame, len+2);
}

int
pdv_set_exposure_basler202k(PdvDev * pdv_p, int value)
{
    u_char    rframe[8];

    memset(rframe, 0, 8);
    pdv_send_basler_command(pdv_p, 0xa6, 0, 3, value);
    pdv_read_basler_frame(pdv_p, rframe, 1);
    if (rframe[0] != 0x6) /* ACK */
        return -1;
    return 0;
}

int
pdv_set_gain_basler202k(PdvDev * pdv_p, int valuea, int valueb)
{
    u_char    rframe[8];

    memset(rframe, 0, 8);
    pdv_send_basler_command(pdv_p, 0x80, 0, 2, valuea);
    pdv_read_basler_frame(pdv_p, rframe, 1);
    if (rframe[0] != 0x6) /* ACK */
        return -1;

    memset(rframe, 0, 8);
    pdv_send_basler_command(pdv_p, 0x82, 0, 2, valueb);
    pdv_read_basler_frame(pdv_p, rframe, 1);
    if (rframe[0] != 0x6) /* ACK */
        return -1;

    return 0;
}

int
pdv_set_offset_basler202k(PdvDev * pdv_p, int valuea, int valueb)
{
    u_char    rframe[8];

    memset(rframe, 0, 8);
    pdv_send_basler_command(pdv_p, 0x81, 0, 2, valuea);
    pdv_read_basler_frame(pdv_p, rframe, 1);
    if (rframe[0] != 0x6) /* ACK */
        return -1;

    memset(rframe, 0, 8);
    pdv_send_basler_command(pdv_p, 0x83, 0, 2, valueb);
    pdv_read_basler_frame(pdv_p, rframe, 1);
    if (rframe[0] != 0x6) /* ACK */
        return -1;
    return 0;
}

int
pdv_set_exposure_duncan_ch(PdvDev * pdv_p, int value, int ch)
{
    u_char    msg[8];
    u_char    rmsg[16];

    msg[0] = 0x04;                              /* LSB size */
    msg[1] = 0x00;                              /* MSB size */
    msg[2] = 0x14;                              /* command byte */
    msg[3] = (u_char)(ch & 0xff);               /* channel*/
    msg[4] = (u_char)(value & 0xff);            /* value lsb */
    msg[5] = (u_char)((value >> 8) & 0xff);     /* value msb */
    pdv_send_duncan_frame(pdv_p, msg, 6);
    pdv_read_duncan_frame(pdv_p, rmsg);
    return 0;
}

int
pdv_set_gain_duncan_ch(PdvDev * pdv_p, int value, int ch)
{
    u_char    msg[8];
    u_char    rmsg[16];

    msg[0] = 0x04;                              /* LSB size */
    msg[1] = 0x00;                              /* MSB size */
    msg[2] = 0x02;                              /* command byte */
    msg[3] = (u_char)(ch & 0xff);               /* channel*/
    msg[4] = (u_char)(value & 0xff);            /* value lsb */
    msg[5] = (u_char)((value >> 8) & 0xff);     /* value msb */
    pdv_send_duncan_frame(pdv_p, msg, 6);
    pdv_read_duncan_frame(pdv_p, rmsg);
    return 0;
}


static void
send_serial_binary_cmd(PdvDev * pdv_p, char *hexstr, int value)
{
    int     nb;
    u_char  hbuf[2];
    char    resp[128];
    char    bs[16][3];
    int     ret;

    edt_msg(DBG2, "send_serial_binary_cmd(\"%s\", %d)\n", hexstr, value);

    nb = sscanf(hexstr, "%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
        bs[0], bs[1], bs[2], bs[3], bs[4], bs[5], bs[6], bs[7],
        bs[8], bs[9], bs[10], bs[11], bs[12], bs[13], bs[14], bs[15]);

    pdv_serial_binary_command(pdv_p, (char *) hbuf, nb);
    pdv_serial_wait(pdv_p, 100, 3);

    if (*pdv_p->dd_p->serial_response)
        ret = pdv_serial_read(pdv_p, resp, 50);

    {

        edt_msg(DBG2, "serial response <%s> (%d)\n", hex_to_str(resp, ret), ret);
    }
}

int
pdv_auto_set_timeout(PdvDev * pdv_p)
{
    Dependent *dd_p = pdv_p->dd_p;
    int     user_timeout = dd_p->user_timeout;
    int     user_set = dd_p->user_timeout_set;
    int     tmult = dd_p->timeout_multiplier;
    int     cur_timeout = edt_get_rtimeout(pdv_p);
    int     timeout;
    int     exposure;
    int     pdiv = 1;
    int     ret = 0;
    int     xfersize;

    /*
    * tmult is for cameras with non-standard integration times
    */
    if (tmult < 1)
        tmult = 1;

    /* pixel clock speed less than 5? Hope not! */
    if (dd_p->pclock_speed < 5)
        dd_p->pclock_speed = 5;
    pdiv = dd_p->pclock_speed / 5;

    if (((exposure = dd_p->shutter_speed)) < 500)
        exposure = 500; /* conservative enough? hope so */

    xfersize = dd_p->cam_width * dd_p->cam_height * bits2bytes(dd_p->depth);
    timeout = (((xfersize * tmult) / 4000) / pdiv) + exposure;

    edt_msg(DBG2, "pdv_auto_set_timeout(): current %d new %d exposure %d pclock %d pdiv %d mult %d user %d\n",
        cur_timeout, timeout, exposure, dd_p->pclock_speed, pdiv,
        tmult, user_timeout);

    /*
    * sticking an 0.5 sec min in here because sometimes small cameras are
    * problematic
    */
    if (timeout < 500)
        timeout = 500;

    if (user_set)
    {
        edt_msg(DBG2, "  user set to %d - overriding auto\n", user_timeout);

        if (timeout > user_timeout && user_timeout != 0)
        {
            edt_msg(DBG2, "  Warning: exposure %d msecs user specified timeout %d msecs\n", dd_p->shutter_speed, user_timeout);
            edt_msg(DBG2, "  not automatically increased since user specified\n");
        }
    }
    else
    {
        int     targ;

        edt_msg(DBG2, "  setting picture timeout from %d to %d\n", cur_timeout, timeout);
        targ = timeout;
        ret = edt_set_rtimeout(pdv_p, targ);
    }
    return ret;
}

int
pdv_set_gain(PdvDev * pdv_p, int value)
{
    int     ret;
    Dependent *dd_p = pdv_p->dd_p;

    edt_msg(DBG2, "pdv_set_gain(%d)\n", value);

    dd_p->gain = value;
    ret = edt_set_dependent(pdv_p, dd_p);

    if ((strlen(dd_p->serial_gain) > 0) && (dd_p->serial_format == SERIAL_BINARY))
        send_serial_binary_cmd(pdv_p, dd_p->serial_gain, value);

    else if (dd_p->serial_format == SERIAL_ASCII)
    {
        char cmdstr[64] = {'\0'};
        int n = check_valid_formatstr(dd_p->serial_gain); 

        if (n == 0) /* no % formatting, use old method */
        {
            if (dd_p->serial_gain[0])
                sprintf(cmdstr, "%s %d", dd_p->serial_gain, value);
        }
        else if ((n > 0) && (n < 5))
            sprintf(cmdstr, dd_p->serial_gain, value, value, value, value);

        if (cmdstr[0])
        {
            ret = pdv_serial_command_flagged(pdv_p, cmdstr, SCFLAG_NORESP);

            pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout, 64);
            if (*pdv_p->dd_p->serial_response)
                pdv_serial_read(pdv_p, cmdstr, 63);
        }
    }

    else if ((strncasecmp(dd_p->camera_class, "Hamamatsu", 9) == 0)
        && ((strncasecmp(dd_p->camera_model, "C8484", 5) == 0)
        || (strncasecmp(dd_p->camera_model, "8484", 4) == 0)))
    {
        ret = pdv_set_gain_hc8484(pdv_p, value);
    }

    else if ((dd_p->camera_shutter_timing == SPECINST_SERIAL)
        || (dd_p->camera_shutter_speed == SPECINST_SERIAL))
    {
        ret = pdv_set_gain_specinst(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == TOSHIBA_SERIAL)
    {
        ret = pdv_set_gain_toshiba(pdv_p, value);
    }
    else if (dd_p->camera_shutter_timing == COHU_SERIAL)
    {
        ret = pdv_set_gain_cohu(pdv_p, value);
    }
    else if (dd_p->set_gain == SMD_SERIAL)      /* smd binary serial method */
    {
        ret = pdv_set_gain_smd(pdv_p, value);
    }
    else if ((strncasecmp(dd_p->camera_class, "Adimec", 6) == 0))
    {
        ret = pdv_set_gain_adimec(pdv_p, value);
    }

    else if ((strncasecmp(dd_p->camera_class, "PULNiX", 6) == 0)
        && ((strncasecmp(dd_p->camera_model, "TM-6710", 7) == 0)
        || (strncasecmp(dd_p->camera_model, "TM-1020", 7) == 0)))
    {
        ret = pdv_set_gain_ptm6710_1020(pdv_p, value);
    }

    else if ((dd_p->set_gain == AIA_MC4)        /* mode cntl 4 method */
        && (dd_p->xilinx_rev >= 1 && dd_p->xilinx_rev <= 32))
    {
        u_int   util2 = edt_reg_read(pdv_p, PDV_UTIL2);
        u_int   mcl = edt_reg_read(pdv_p, PDV_MODE_CNTL);

        edt_reg_write(pdv_p, PDV_UTIL2, util2 & ~PDV_MC4);
        edt_reg_write(pdv_p, PDV_MODE_CNTL, dd_p->gain);
        edt_reg_write(pdv_p, PDV_UTIL2, util2 | PDV_MC4);
        edt_reg_write(pdv_p, PDV_MODE_CNTL, mcl);
    }

    edt_msg(DBG2, "pdv_set_gain returning %d\n", ret);
    return (ret);
}

static int
pdv_set_gain_smd(PdvDev * pdv_p, int value)
{
    char    buf[128];
    char    smd_config;
    int     smd_reg1;
    int     ret = 0;

    if (Smd_type == NOT_SET)
    {
        Smd_type = smd_read_reg(pdv_p, SMD_READ_CAMTYPE);
        if ((Smd_type & 0xfff) == 0xfff)        /* sometimes there's garbage
                                            * at first; if so try again */
                                            Smd_type = smd_read_reg(pdv_p, SMD_READ_CAMTYPE);
    }

    switch (Smd_type)
    {
    case SMD_TYPE_4M4:
        buf[0] = (char) SMD_4M4_READ_R1;
        pdv_serial_binary_command(pdv_p, buf, 1);
        pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout,
            pdv_p->dd_p->serial_respcnt);
        if (pdv_serial_read(pdv_p, buf, 63) == 1)
        {
            smd_config = buf[0];

            buf[0] = (char) SMD_4M4_WRITE_R1;
            pdv_serial_binary_command(pdv_p, buf, 1);

            if (value == 0)
                smd_config &= ~SMD_4M4_R1_GAIN;
            else
                smd_config |= SMD_4M4_R1_GAIN;
            buf[0] = smd_config;
            pdv_serial_binary_command(pdv_p, buf, 1);
            /* SMD doesn't resp but do a dummy wait to make sure its done */
            pdv_serial_wait(pdv_p, 100, 64);
        }
        else
            ret = -1;
        break;

    case SMD_TYPE_1M30P:
        buf[0] = (u_char) SMD_1M30P_REG_W_LS_GAIN;
        buf[1] = value & 0xff;
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);

        buf[0] = (u_char) SMD_1M30P_REG_W_MS_GAIN;
        buf[1] = (value & 0xff00) >> 8;
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);

        /* SMD doesn't respond but do a dmy wait to make sure its done */
        pdv_serial_wait(pdv_p, 100, 64);
        break;

    case SMD_TYPE_1M15P:
    case SMD_TYPE_6M3P:
        if ((smd_reg1 = smd_read_reg(pdv_p, SMD_1M15P_READ_R1)) == -1)
        {
            edt_msg(PDVWARN, "libpdv: no response from SMD R1 reg read\n");
            return -1;
        }

        buf[0] = (u_char) SMD_1M15P_WRITE_R1; /* same for 6M3P */

        /*
        * valid values for this camera are 0 or 1
        */
        if (value == 0)
            buf[1] = smd_reg1 &~ SMD_1M15P_R1_GAIN;
        else if (value == 1)
            buf[1] = smd_reg1 | SMD_1M15P_R1_GAIN;
        else return -1;

        pdv_serial_binary_command(pdv_p, (char *) buf, 2);
        pdv_p->dd_p->gain = value;

        /* SMD doesn't respond but do a dmy wait to make sure its done */
        pdv_serial_wait(pdv_p, 100, 64);
        break;
    }

    return ret;
}

int
pdv_set_gain_ch(PdvDev * pdv_p, int value, int chan)
{
    int     ret = -1;

    /* ALERT -- no methods implemented since ddcam went away... */
    edt_msg(DBG2, "pdv_set_gain_ch(%d, [%c]) ret %d\n",
        value, (chan == 1) ? 'A' : (chan == 2) ? 'B' : '?', ret);
    return (ret);
}

int
pdv_set_blacklevel(PdvDev * pdv_p, int value)
{
    Dependent *dd_p = pdv_p->dd_p;
    int     ret;

    edt_msg(DBG2, "pdv_set_blacklevel(%d)\n", value);

    dd_p->level = value;
    ret = edt_set_dependent(pdv_p, dd_p);

    if (dd_p->set_offset == SMD_SERIAL) /* smd binary serial method */
        ret = pdv_set_blacklevel_smd(pdv_p, value);

    else if (dd_p->camera_shutter_timing == COHU_SERIAL)
    {
        ret = pdv_set_blacklevel_cohu(pdv_p, value);
    }

    else if ((strncasecmp(dd_p->camera_class, "Adimec", 6) == 0))
    {
        ret = pdv_set_blacklevel_adimec(pdv_p, value);
    }

    else if ((strlen(dd_p->serial_offset) > 0) && (dd_p->serial_format == SERIAL_BINARY))
    {
        send_serial_binary_cmd(pdv_p, dd_p->serial_offset, value);
    }

    else if (dd_p->serial_format == SERIAL_ASCII)
    {
        char cmdstr[64] = {'\0'};
        int n = check_valid_formatstr(dd_p->serial_offset); 

        if (n == 0) /* no % formatting, use old method */
        {
            if (dd_p->serial_offset[0])
            sprintf(cmdstr, "%s %d", dd_p->serial_offset, value);
        }
        else if ((n > 0) && (n < 5))
            sprintf(cmdstr, dd_p->serial_offset, value, value, value, value);

        if (cmdstr[0])
        {
            ret = pdv_serial_command_flagged(pdv_p, cmdstr, SCFLAG_NORESP);

            pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout, 64);
            if (*pdv_p->dd_p->serial_response)
                pdv_serial_read(pdv_p, cmdstr, 63);
        }
    }

    edt_msg(DBG2, "pdv_set_blacklevel() %d\n", ret);
    return (ret);
}

static int
pdv_set_blacklevel_smd(PdvDev * pdv_p, int value)
{
    char    buf[128];
    int     ret = 0;
    int     tmpval = value & 0xfff;
    int     smd_reg2, smd_reg3;

    if (Smd_type == NOT_SET)
    {
        Smd_type = smd_read_reg(pdv_p, SMD_READ_CAMTYPE);
        if ((Smd_type & 0xfff) == 0xfff)        /* sometimes there's garbage
                                            * at first; if so try again */
                                            Smd_type = smd_read_reg(pdv_p, SMD_READ_CAMTYPE);
    }

    switch (Smd_type)
    {
    case SMD_TYPE_4M4:
    case SMD_TYPE_BT25:
        break;

    case SMD_TYPE_1M30P:
        buf[0] = (u_char) SMD_1M30P_REG_W_LS_OFFSET;
        buf[1] = value & 0xff;
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);

        buf[0] = (u_char) SMD_1M30P_REG_W_MS_OFFSET;
        buf[1] = (value & 0xff00) >> 8;
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);

        /* SMD doesn't respond but do a dmy wait to make sure its done */
        pdv_serial_wait(pdv_p, 100, 64);
        break;

    case SMD_TYPE_1M15P:
        if ((smd_reg3 = smd_read_reg(pdv_p, SMD_1M15P_READ_R3)) == -1)
        {
            edt_msg(PDVWARN, "libpdv: no response from Dalstar R3 reg read\n");
            ret = -1;
        }

        smd_reg2 =  tmpval >> 4;
        smd_reg3 = (smd_reg3 & ~0x0f) | (tmpval & 0x0f);

        /* write R3 */
        buf[0] = (u_char) SMD_1M15P_WRITE_R3;
        buf[1] = (u_char) smd_reg3;
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);

        /* must write R2 last */
        buf[0] = (u_char) SMD_1M15P_WRITE_R2;
        buf[1] = (u_char) smd_reg2;
        pdv_serial_binary_command(pdv_p, (char *) buf, 2);

        /* SMD doesn't respond but do a dmy wait to make sure its done */
        pdv_serial_wait(pdv_p, 100, 64);
        break;

    default:
        ret = -1;
    }

    return ret;
}

int
pdv_set_aperture(PdvDev * pdv_p, int value)
{
    edt_msg(PDVWARN, "pdv_set_aperture is OBSOLETE\n");
    return (-1);
}

int
pdv_set_binning(PdvDev * pdv_p, int xval, int yval)
{
    int     ret = -1;
    int     newvskip, newhskip, newwidth, newheight;
    Dependent *dd_p = pdv_p->dd_p;

    if (((xval != 1) && (xval % 2)) || ((yval != 1) && (yval % 2)))
    {
        edt_msg(PDVWARN, "pdv_set_binning(%d, %d) -- invalid value\n", xval, yval);
        return -1;
    }

    edt_msg(DBG2, "pdv_set_binning(%d, %d)\n", xval, yval);

    if (strcmp(dd_p->serial_binning, "BIN") == 0)       /* DVC */
    {
        ret = pdv_set_binning_dvc(pdv_p, xval, yval);
    }
    else if (strcmp(dd_p->serial_binning, "B=") == 0)   /* ATMEL */
    {
        ret = pdv_set_binning_generic(pdv_p, xval - 1);
    }
    else if (*dd_p->serial_binning)     /* Generic */
    {
        /* wing it */
        ret = pdv_set_binning_generic(pdv_p, xval);
    }
    else
        return -1;

    if (ret)
        return ret;

    if (dd_p->binx < 1)
        dd_p->binx = 1;
    if (dd_p->biny < 1)
        dd_p->biny = 1;

    newwidth = (((pdv_get_width(pdv_p) * dd_p->binx) / xval) / 4) * 4;
    newheight = (((pdv_get_height(pdv_p) * dd_p->biny) / yval)) ;

    if (dd_p->roi_enabled)
    {
        newhskip = (dd_p->hskip * dd_p->binx) / xval;
        newvskip = (dd_p->vskip * dd_p->biny) / yval;
        ret = pdv_set_roi(pdv_p, newhskip, newwidth, newvskip, newheight);
    }

    if (!ret)
    {
        dd_p->binx = xval;
        dd_p->biny = yval;
    }

    return (ret);
}

static int
pdv_set_binning_generic(PdvDev * pdv_p, int value)
{
    char    cmdstr[64];
    Dependent *dd_p = pdv_p->dd_p;

    if (dd_p->serial_binning[strlen(dd_p->serial_binning) - 1] == '=')  /* atmel */
        sprintf(cmdstr, "%s%d", dd_p->serial_binning, value);
    else
        sprintf(cmdstr, "%s %d", dd_p->serial_binning, value);
    pdv_serial_command_flagged(pdv_p, cmdstr, SCFLAG_NORESP);

    return (0);
}


int
pdv_get_exposure(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_get_exposure() %d\n", pdv_p->dd_p->shutter_speed);

    return (pdv_p->dd_p->shutter_speed);
}

void
pdv_set_defaults(PdvDev * pdv_p)
{
    Dependent *dd_p = pdv_p->dd_p;

    if (dd_p->default_shutter_speed != NOT_SET)
        pdv_set_exposure(pdv_p, dd_p->default_shutter_speed);
    if (dd_p->default_gain != NOT_SET)
        pdv_set_gain(pdv_p, dd_p->default_gain);
    if (dd_p->default_offset != NOT_SET)
        pdv_set_blacklevel(pdv_p, dd_p->default_offset);
}

int
pdv_read_response(PdvDev * pdv_p, char *buf)
{
    int     len;

    /*
    * serial_timeout comes from the config file, or default of 1 sec
    */
    len = pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout, 2048);
    if (len)
        pdv_serial_read(pdv_p, buf, len);
    return len;
}


int
pdv_get_gain(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_get_gain() %d\n", pdv_p->dd_p->gain);

    return (pdv_p->dd_p->gain);
}


int
pdv_get_blacklevel(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_get_blacklevel() %d\n", pdv_p->dd_p->level);

    return (pdv_p->dd_p->level);
}

int
pdv_get_aperture(PdvDev * pdv_p)
{
    edt_msg(PDVWARN, "pdv_get_aperture is OBSOLETE\n");
    return (-1);
}

void
pdv_invert(PdvDev * pdv_p, int val)
{
    u_int   data_path;

    /* data_path = edt_reg_read(pdv_p, PDV_DATA_PATH); */
    data_path = pdv_p->dd_p->datapath_reg;

    edt_msg(DBG2, "pdv_invert(%d)\n", val);

    if (val)
        data_path |= PDV_INVERT;
    else
        data_path &= ~PDV_INVERT;

    edt_reg_write(pdv_p, PDV_DATA_PATH, data_path);
    pdv_p->dd_p->datapath_reg = data_path;
}

int
pdv_get_invert(PdvDev * pdv_p)
{
    u_int   data_path;

    return (int)((edt_reg_read(pdv_p, PDV_DATA_PATH) & PDV_INVERT) != 0);
}


void
pdv_set_firstpixel_counter(PdvDev * pdv_p, int ena)
{
    if (pdv_p->devid >= PE8DVCL_ID)
    {
      u_int reg = edt_reg_read(pdv_p, PDV_CL_CFG2);
      if (ena)
          edt_reg_write(pdv_p, PDV_CL_CFG2, reg | PDV_CL_CFG2_PE8_FRMTAG2);
      else edt_reg_write(pdv_p, PDV_CL_CFG2, reg & ~PDV_CL_CFG2_PE8_FRMTAG2);
    }
}

int
pdv_get_firstpixel_counter(PdvDev * pdv_p)
{
    if (pdv_p->devid >= PE8DVCL_ID)
    {
      int reg = edt_reg_read(pdv_p, PDV_CL_CFG2);

      return (int)((edt_reg_read(pdv_p, PDV_CL_CFG2) & PDV_CL_CFG2_PE8_FRMTAG2) != 0);
    }

    return 0;
}
        

u_short
pdv_get_interlaced(PdvDev * pdv_p)

{
    edt_msg(DBG2, "pdv_get_interlaced() %u\n", pdv_p->dd_p->interlace);

    return (pdv_p->dd_p->interlace);
}

int
pdv_force_single(PdvDev * pdv_p)
{
    return pdv_p->dd_p->force_single;
}

int
pdv_variable_size(PdvDev * pdv_p)
{
    return pdv_p->dd_p->variable_size;
}



int
pdv_serial_read_nullterm(PdvDev * pdv_p, char *buf, int size, int nullterm)
{
#define PKT_OVERHEAD 2
#define PKT_SIZE_MAX 15

    int     bytesReturned;
    Dependent *dd_p;

    if (pdv_p == NULL || pdv_p->dd_p == NULL)
        return 0;

    pdv_serial_check_enabled(pdv_p);

    dd_p = pdv_p->dd_p;

    if (buf == NULL || pdv_p == NULL || size == 0)
        return (-1);

    bytesReturned = edt_get_msg(pdv_p, buf, size);
    assert(bytesReturned <= size);

    if (nullterm)
        buf[bytesReturned] = 0;

    if (Pdv_debug)
    {
        int     i, num = bytesReturned;
        int is_ascii = 1;

        if (num > 32)           /* limit number of bytes printed to 16 */
            num = 32;

        for (i=0;i<num; i++)
        {
            if (!isascii(buf[i]))
                is_ascii = 0;
        }
        edt_msg(DBG2, "pdv_serial_read(<");
        for (i = 0; i < num; i++)
        {
            if (is_ascii)
                edt_msg(DBG2, "%c", (char) buf[i]);
            else edt_msg(DBG2, "%02x%s", (u_char) buf[i], i < num-1?", ":"");
        }
        edt_msg(DBG2, ">, %d)\n", size);
    }
    return bytesReturned;
}

int
pdv_serial_read(PdvDev * pdv_p, char *buf, int count)
{

    return pdv_serial_read_nullterm(pdv_p,buf,count,TRUE);
}

int
pdv_send_msg(PdvDev *ed, int chan, const char *buf, int size)
{
    int i, ret = 0;
    int pause = ed->dd_p->pause_for_serial;
    char bbuf[32];

    pdv_serial_check_enabled(ed);

    /* sleep between bytes if indicated */
    if (pause)
    {
        for (i=0; i<size; i++)
        {
            bbuf[0] = buf[i];
            edt_msleep(ed->dd_p->pause_for_serial);
            if ((ret = edt_send_msg(ed, chan, bbuf, 1)) != 0)
                return ret;
        }
        return ret;
    }
    else return edt_send_msg(ed, chan, buf, size);
}

int
pdv_serial_write_single_block(PdvDev * pdv_p, const char *buf, int size)
{
    int     ret;
    Dependent *dd_p;

    if (size == 0)
        return (-1);

    if (Pdv_debug)
    {
        int     i, num = size;

        if (num > 16)           /* limit number of bytes printed to 16 */
            num = 16;
        edt_msg(DBG2, "pdv_serial_write_single_block(<");
        for (i = 0; i < num; i++)
        {
            edt_msg(DBG2, "%02x", (u_char) buf[i]);
            if (i + 1 < num)
                edt_msg(DBG2, ", ");
            else
                break;
        }
        edt_msg(DBG2, ">, %d)\n", size);
    }

    if (buf == NULL || pdv_p == NULL || pdv_p->dd_p == NULL)
        return (-1);
    dd_p = pdv_p->dd_p;

    ret = pdv_send_msg(pdv_p, pdv_p->channel_no, buf, size);
    return (ret);
}

int
pdv_serial_write_available(PdvDev *pdv_p)

{

    int avail;

    edt_ioctl(pdv_p, EDTG_SERIAL_WRITE_AVAIL, &avail);

    return avail;

}

static int pdv_serial_block_size = 1024;

void pdv_set_serial_block_size(int newsize)
{
    pdv_serial_block_size = newsize;
}

int
pdv_get_serial_block_size()
{
    return pdv_serial_block_size;
}

#define SERIAL_ENABLED_FLAGS (PDV_EN_TX | PDV_EN_RX | PDV_EN_RX_INT | PDV_EN_DEV_INT)

int
pdv_serial_read_enable(PdvDev *pdv_p)

{

    edt_reg_or(pdv_p, PDV_SERIAL_DATA_CNTL, SERIAL_ENABLED_FLAGS);

    edt_set_remote_intr(pdv_p, TRUE);

    pdv_p->is_serial_enabled = 1;

    return 0;
}


int  
pdv_serial_read_disable(PdvDev *pdv_p)

{
    edt_set_remote_intr(pdv_p, FALSE);
    edt_reg_and(pdv_p, PDV_SERIAL_DATA_CNTL, ~SERIAL_ENABLED_FLAGS);
    pdv_p->is_serial_enabled = 0;

    return 0;
}

int  
pdv_serial_check_enabled(PdvDev *pdv_p)

{
    if (!pdv_p->is_serial_enabled)
        return pdv_serial_read_enable(pdv_p);

    return 0;
}



int
pdv_serial_write(PdvDev *pdv_p, const char *buf, int size)

{
    int avail;
    int left = size;
    int ret = 0;
    int offset = 0;
    int speed = pdv_get_baud(pdv_p);
    int sleepval;
    int chunk = pdv_serial_block_size;

    pdv_serial_check_enabled(pdv_p);

    if (speed != 0)
        sleepval = speed/10;
    else
        sleepval = 10;

    sleepval = (chunk * 1000) / sleepval; /* time to send chunk chars */

    avail = pdv_serial_write_available(pdv_p);
    if (avail > size)
    {
        return pdv_serial_write_single_block(pdv_p, buf, size);
    }
    else
    {
        left -= avail;
        offset += avail;

#ifdef DBG_SERIAL_IO
        printf("Writing %d chars\n", avail);
#endif

        ret = pdv_serial_write_single_block(pdv_p, buf, avail);

        if (ret != 0)
            return ret;
        while (left > 0)
        {
            edt_msleep(sleepval);
            avail = pdv_serial_write_available(pdv_p);
            if (avail > 0)
            {
                if ( avail > left)
                {
                    avail = left;
                    left = 0;
                }
                else
                {
                    left -= avail;
                }

#ifdef DBG_SERIAL_IO
                printf("Writing %d chars\n", avail);
#endif
                ret = pdv_serial_write_single_block(pdv_p, buf+offset, avail);
                if (ret != 0)
                    return ret;
                offset += avail;

            }
        }
    }
    return 0;
}

int
pdv_serial_read_blocking(PdvDev *pdv_p, char *buf, int size)

{
    int left = size;
    int ret = 0;
    int offset = 0;
    int total = 0;


    int avail = 1024;
    int speed = pdv_get_baud(pdv_p);
    int sleepval;
    int chunk = pdv_serial_block_size;


    if (speed != 0)
        sleepval = speed/10;
    else
        sleepval = 10;

    sleepval = (chunk * 1000) / sleepval; /* time to send chunk chars */


    while (left > 0)
    {
        avail = pdv_serial_wait(pdv_p, sleepval, chunk);
        if (avail)
        {
            if ( avail > left)
            {
                avail = left;
                left = 0;
            }
            else
            {
                left -= avail;
            }

#ifdef DBG_SERIAL_IO
            printf("Reading %d chars total = %d\n", avail, offset + avail);
#endif
            ret = pdv_serial_read(pdv_p, buf+offset, avail);
            offset += avail;

            total += ret;

        }


    }



    return total;

}


int
pdv_serial_command(PdvDev * pdv_p, const char *cmd)
{
    /* older comment:
    * Sends a serial AIA command convenience wrapper for pdv_serial_write()
    * -- takes the command string and adds the '\r' and deals with the
    * string length issue... Prepends a 'c if FOI. Because of the FOI
    * issue, applications should ALWAYS use this or
    * pdv_serial_binary_command instead of calling pdv_serial_write
    * directly.
    * 
    * UNLESS -- serial_format is SERIAL_PULNIX_1010, in which case it prepends an
    * STX (0x2) and appends an ETX (0x3)
    */
    return pdv_serial_command_flagged(pdv_p, cmd, 0);
}

int
pdv_serial_command_flagged(PdvDev * pdv_p, const char *cmd, u_int flag)
{
    char    *buf;
    int     ret;
    int     i;
    int     len=0;
    int     bufsize=8; /* arbitrary but should handle whatever extra is tacked on below */
    const char    *p = cmd;

    if (pdv_p == NULL || pdv_p->dd_p == NULL)
        return -1;

    /* find the size (new, was fixed @ 256, now dynamic) */
    while (*p++)
        ++bufsize;
    buf = (char *)malloc(bufsize+16);
    /* 16 is arbitrary, to allow for serial_prefix/serial_term */


    /* new:  serial_prefix -- prepend if nonzero */
    if (*pdv_p->dd_p->serial_prefix)
    {
        strcpy(&(buf[len]), pdv_p->dd_p->serial_prefix);
        len += (int)strlen(pdv_p->dd_p->serial_prefix);
    }

    /* strip off  CR or LF, then add prepend/append STX/ETX */
    if (pdv_p->dd_p->serial_format == SERIAL_PULNIX_1010)
    {
        buf[len++] = 0x02;      /* prepend STX */
        for (i = 0; i < bufsize; i++)
            if (cmd[i] == '\r' || cmd[i] == '\n' || cmd[i] == 0)
                break;
            else
                buf[len++] = cmd[i];
        buf[len++] = 0x03;      /* append ETX */
    }
    else
    {
        /* strip off  CR or LF, then add serial_term */

        for (i = 0; i < bufsize; i++)
        {
            if (cmd[i] == '\r' || cmd[i] == '\n' || cmd[i] == 0)
                break;
            else
                buf[len++] = cmd[i];
        }
        /* ALERT! need to change for FOI if \\n! */
        sprintf(&(buf[len]), "%s", pdv_serial_term(pdv_p));
        len += (int)strlen(pdv_serial_term(pdv_p));
    }

    if (Pdv_debug)
        debug_print_serial_command(buf);
    ret = pdv_serial_write(pdv_p, buf, len);

    free(buf);
    return (ret);
}

char   *
pdv_serial_term(PdvDev * pdv_p)
{
    return pdv_p->dd_p->serial_term;
}

char   *
pdv_serial_prefix(PdvDev * pdv_p)
{
    return pdv_p->dd_p->serial_prefix;
}

void
pdv_set_serial_delimiters(PdvDev *pdv_p, char *prefix, char *term)

{
    if (prefix)
        strncpy(pdv_p->dd_p->serial_prefix,prefix, sizeof(pdv_p->dd_p->serial_prefix)-1);
    else
        pdv_p->dd_p->serial_prefix[0] = 0;

    if (term)
        strncpy(pdv_p->dd_p->serial_term,term, sizeof(pdv_p->dd_p->serial_term)-1);
    else
        pdv_p->dd_p->serial_term[0] = 0;

    edt_set_dependent(pdv_p,pdv_p->dd_p);
}


/* debug print ASCII serial command string, from pdv_serial_command */
static void
debug_print_serial_command(char *cmd)
{
    char    tmpbuf[256];
    char   *p = cmd;
    char   *pp = tmpbuf;
    int    len=0;

    while (*p != '\0')
    {
        if (*p == '\r')
        {
            sprintf(pp, "\\r");
            pp += 2;
            len += 2;
            ++p;
        }
        else if (*p == '\n')
        {
            sprintf(pp, "\\n");
            pp += 2;
            len += 2;
            ++p;
        }
        else if (!isprint(*p))
        {
            sprintf(pp, "<%02x>", (*p) & 0xff);
            pp += 4;
            len += 4;
            ++p;
        }
        else
        {
            *(pp++) = *(p++);
            ++len ;
        }
        if (len > 250) /* arbitrary max, just bail out so we don't crash */
            break;
    }
    *pp = '\0';
    edt_msg(DBG2, "pdv_serial_command(\"%s\")\n", tmpbuf);
}

int
pdv_serial_binary_command(PdvDev * pdv_p, const char *cmd, int len)
{
    return pdv_serial_binary_command_flagged(pdv_p, cmd, len, 0);
}


int
pdv_send_basler_frame(PdvDev * pdv_p, u_char *cmd, int len)
{
    int i;
    u_char frame[128];
    u_char *p = frame;
    u_char bcc = 0;

    *p++ = 0x02;
    for (i=0; i<len; i++)
    {
        bcc ^= cmd[i];
        *p++ = cmd[i];
    }
    *p++ = bcc;
    *p++ = 0x03;

    return pdv_serial_binary_command_flagged(pdv_p, (char *)frame, len+3, 0);
}

int
pdv_read_basler_frame(PdvDev * pdv_p, u_char *frame, int len)
{
    int n, nn;
    char tmpbuf[128];
    char *p;

    n = pdv_serial_wait(pdv_p, 500, len);
    if (n < 1)
        return 0;

    nn = pdv_serial_read(pdv_p, tmpbuf, n);

    if (tmpbuf[0] == 0x06) /* ACK */
    {
        frame[0] = 0x06;
        return 1;
    }

    if (tmpbuf[0] == 0x15) /* ACK */
    {
        frame[0] = 0x06;
        return 1;
    }

    if (tmpbuf[0] == 0x02)
    {
        p = &tmpbuf[nn];
        n = pdv_serial_wait(pdv_p, 50, len);
        pdv_serial_read(pdv_p, p, n);
        /* ALERT -- FINISH this! */
    }
    return n;
}

int
pdv_send_duncan_frame(PdvDev * pdv_p, u_char *cmdbuf, int size)
{
    int i;
    u_char frame[128];
    u_char *p = frame;

    *p++ = 0x02;
    for (i=0; i<size; i++)
        *p++ = cmdbuf[i];

    CheckSumMessage(frame);

    return pdv_serial_binary_command_flagged(pdv_p, (char *)frame, size+2, 0);
}

static void
CheckSumMessage(unsigned char *msg)
{
    unsigned short length; 
    unsigned char csum = 0;

    msg++;         
    length = *msg++;
    length += *msg++ << 8;
    if (length > 0)
    {
        for (; length > 0; length--)
            csum += *msg++;
        *msg = -csum;
    }
}


int
pdv_read_duncan_frame(PdvDev * pdv_p, u_char *frame)
{
    int n, nn;
    u_short length;

    /* read the STX and 2-byte length */
    n = pdv_serial_wait(pdv_p, 500, 3);
    if (n < 3)
        return 0;

    nn = pdv_serial_read(pdv_p, (char *)frame, 3);

    length = (u_short)frame[1] + (u_short)(frame[2] << 8);

    if (length)
        n = pdv_serial_wait(pdv_p, 1000, length+1);

    if (n)
        pdv_serial_read(pdv_p, (char *)(&frame[3]), n);

    return n+nn;
}

int
pdv_serial_binary_command_flagged(PdvDev * pdv_p, const char *cmd, int len, u_int flag)
{
    char    *buf;
    int     ret;
    int     i;
    int     tmplen = 0;

    edt_msg(DBG2, "pdv_serial_binary_command()\n");

    if (pdv_p == NULL || pdv_p->dd_p == NULL)
        return -1;

    if ((buf = (char *)malloc(len)) == NULL)
        return -1;

    /* don't include CR or LF */
    for (i = 0; i < len; i++)
    {
        buf[tmplen++] = cmd[i];
    }
    ret = pdv_serial_write(pdv_p, buf, tmplen);

    free(buf);
    return (ret);
}
 /* end serial */

int
pdv_read(PdvDev * pdv_p, unsigned char *buf, unsigned long size)
{
    Dependent *dd_p;
    unsigned long newsize;
    int     readsize;
    unsigned char *tbuf;
    u_int fc;
    int last_timeouts;

    if (pdv_p == NULL || pdv_p->dd_p == NULL)
        return 0; 

    edt_msg(DBG2, "pdv_read(%d)\n", size);

    pdv_setup_dma(pdv_p);

    last_timeouts = edt_timeouts(pdv_p);

    if (pdv_p->dd_p->start_delay)
        edt_msleep(pdv_p->dd_p->start_delay);


    if (pdv_specinst_serial_triggered(pdv_p))
    {
        edt_msg(PDVWARN, "libpdv invalid combination: SPECINST_SERIAL/pdv_read/i/f trigger");
        edt_msg(PDVWARN, "should use pdv_start_image() or external trigger");
    }

    if (pdv_p == NULL || pdv_p->dd_p == NULL)
        return -1;

    dd_p = pdv_p->dd_p;

    if (pdv_p->devid == DMY_ID)
    {
        pdv_dmy_data(buf, dd_p->width, dd_p->height, dd_p->depth);
        if (dd_p->markras)
            pdv_mark_ras(buf, dd_p->rascnt,
            dd_p->width, dd_p->height, dd_p->markrasx, dd_p->markrasy);
        if (dd_p->markbin)
            pdv_mark_bin(buf, dd_p->rascnt, dd_p->width, dd_p->height, 4, 0);
        if (dd_p->markbin || dd_p->markras) dd_p->rascnt++ ;
        printf("pdv_read rascnt %d\n",dd_p->rascnt) ;
        return (size);
    }

    readsize = pdv_get_dmasize(pdv_p);

    if (dd_p->swinterlace)
        pdv_alloc_tmpbuf(pdv_p);

    /*
    * specify register and value to set after starting dma
    */
    edt_startdma_reg(pdv_p, PDV_CMD, PDV_ENABLE_GRAB);
    if (edt_get_firstflush(pdv_p) != EDT_ACT_KBS)
        edt_set_firstflush(pdv_p, EDT_ACT_ONCE);


    if (dd_p->slop)
    {
        edt_msg(DBG2, "adjusting readsize %x by slop %x to %x\n",
            readsize, dd_p->slop, readsize - dd_p->slop);
        readsize -= dd_p->slop;
    }

    if (dd_p->swinterlace)
    {
        if (pdv_process_inplace(pdv_p))
            tbuf = buf;
        else
            tbuf = pdv_p->tmpbuf;

        newsize = edt_read(pdv_p, tbuf, readsize);
        dd_p->last_raw = tbuf;
        dd_p->last_image = buf;
    }
    else
    {
        tbuf = buf;
        newsize = edt_read(pdv_p, buf, readsize);
        dd_p->last_raw = buf;
        dd_p->last_image = buf;
    }

    dd_p->rascnt = 1;
    if (dd_p->markras)
        pdv_mark_ras(buf, dd_p->rascnt++, dd_p->width, dd_p->height,
        dd_p->markrasx, dd_p->markrasy);

    size = newsize;

    /* edt_startdma_reg(pdv_p, 0, 0) ; */

    edt_msg(DBG2, "swinterlace %d\n", dd_p->swinterlace);

    pdv_deinterlace(pdv_p, dd_p, tbuf, buf);

    if ((pdv_framesync_mode(pdv_p) == PDV_FRAMESYNC_EMULATE_TIMEOUT)
     && (pdv_check_framesync(pdv_p, buf, &fc) > 0)
     && (last_timeouts == edt_timeouts(pdv_p)))
        edt_do_timeout(pdv_p);

    return (size);
}


unsigned char *
pdv_image(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_image()\n");

    pdv_start_images(pdv_p, 1);
    return pdv_wait_images(pdv_p, 1);
}


unsigned char *
pdv_image_raw(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_image()\n");

    pdv_start_images(pdv_p, 1);
    return pdv_wait_images_raw(pdv_p, 1);
}

void
pdv_start_image(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_start_image()\n");

    pdv_start_images(pdv_p, 1);
}


void
pdv_start_images(PdvDev * pdv_p, int count)
{

    edt_msg(DBG2, "pdv_start_images(%d) %d\n", count, pdv_p->dd_p->started_continuous);

    if (pdv_p->dd_p->start_delay)
        edt_msleep(pdv_p->dd_p->start_delay);

    /* automatically alloc 1 buffer if none allocated */
    if (pdv_p->ring_buffer_numbufs < 1)
        pdv_multibuf(pdv_p, 1);

    /* 
    if (pdv_p->devid == DMY_ID)
    {
    dmystarted += count ;
    return;
    }
    */
    if (!pdv_p->dd_p->started_continuous)
    {
        pdv_setup_continuous(pdv_p);
    }
    if (pdv_force_single(pdv_p) && (count > 1))
    {
        edt_msg(PDVWARN,
            "pdv_start_images(): %d buffers requested; should only\n", count);
        edt_msg(PDVWARN,
            "start one at a time when 'force_single' is set in config file\n");
        count = 1;
    }


    edt_start_buffers(pdv_p, count);

    if (pdv_specinst_serial_triggered(pdv_p))
        pdv_trigger_specinst(pdv_p);
    else if (strlen(pdv_p->dd_p->serial_trigger) > 0)
        pdv_serial_command(pdv_p, pdv_p->dd_p->serial_trigger);
}


unsigned char *
pdv_wait_image(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_wait_image()\n");

    return pdv_wait_images(pdv_p, 1);
}

unsigned char *
pdv_wait_image_raw(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_wait_image()\n");

    return pdv_wait_images_raw(pdv_p, 1);
}


unsigned char *
pdv_wait_image_timed(PdvDev * pdv_p, u_int * timep)
{
    return pdv_wait_image_timed_raw(pdv_p, timep, FALSE);
}

unsigned char *
pdv_wait_image_timed_raw(PdvDev * pdv_p, u_int * timep, int doRaw)
{
    u_char *ret;

    edt_msg(DBG2, "pdv_wait_image()\n");

    if (doRaw)
        ret = pdv_wait_images_raw(pdv_p, 1);
    else
        ret = pdv_wait_images(pdv_p, 1);

    edt_get_timestamp(pdv_p, timep, pdv_p->donecount - 1);
    return (ret);
}

unsigned char *
pdv_wait_images_timed_raw(PdvDev * pdv_p, int count, u_int * timep, int doRaw)
{
    u_char *ret;

    edt_msg(DBG2, "pdv_wait_images_timed_raw(count=%d, doRaw=%d)\n", count, doRaw);
    if (doRaw)
        ret = pdv_wait_images_raw(pdv_p, count);
    else
        ret = pdv_wait_images(pdv_p, count);

    edt_get_timestamp(pdv_p, timep, pdv_p->donecount - 1);
    return (ret);
}

unsigned char *
pdv_wait_images_timed(PdvDev * pdv_p, int count, u_int * timep)
{
    return pdv_wait_images_timed_raw(pdv_p, count, timep, FALSE);
}

unsigned char *
pdv_last_image_timed_raw(PdvDev * pdv_p, u_int * timep, int doRaw)
{
    return pdv_wait_last_image_timed_raw(pdv_p, timep, doRaw);

}

unsigned char *
pdv_wait_last_image_timed_raw(PdvDev * pdv_p, u_int * timep, int doRaw)
{
    u_char *ret;
    int     donecount;
    int     last_wait;
    int     delta;

    donecount = edt_done_count(pdv_p);
    last_wait = pdv_p->donecount;

    edt_msg(DBG2, "pdv_wait_last_image_timed() last %d cur %d\n",
        last_wait, donecount);

    delta = donecount - last_wait;

    if (delta == 0)
        delta = 1;

    if (doRaw)
        ret = pdv_wait_images_raw(pdv_p, delta);
    else
        ret = pdv_wait_images(pdv_p, delta);

    edt_get_timestamp(pdv_p, timep, pdv_p->donecount - 1);
    return (ret);
}

unsigned char *
pdv_wait_last_image_timed(PdvDev * pdv_p, u_int * timep)
{
    return pdv_wait_last_image_timed_raw(pdv_p, timep, FALSE);
}

unsigned char *
pdv_last_image_timed(PdvDev * pdv_p, u_int * timep)
{

    return pdv_last_image_timed_raw(pdv_p, timep, FALSE);
}

unsigned char *
pdv_wait_last_image_raw(PdvDev * pdv_p, int *nSkipped, int doRaw)
{
    u_char *ret;
    int     donecount;
    int     last_wait;
    int     delta;

    donecount = edt_done_count(pdv_p);
    last_wait = pdv_p->donecount;

    edt_msg(DBG2, "pdv_wait_last_image() last %d cur %d\n",
        last_wait, donecount);

    delta = donecount - last_wait;

    if (nSkipped)
        *nSkipped = (delta) ? delta - 1 : 0;

    if (delta == 0)
        delta = 1;

    if (doRaw)
        ret = pdv_wait_images_raw(pdv_p, delta);
    else
        ret = pdv_wait_images(pdv_p, delta);

    return (ret);
}

unsigned char *
pdv_wait_last_image(PdvDev * pdv_p, int *nSkipped)
{
    return pdv_wait_last_image_raw(pdv_p, nSkipped, FALSE);
}

unsigned char *
pdv_wait_next_image_raw(PdvDev * pdv_p, int *nSkipped, int doRaw)
{
    u_char *ret;
    int     donecount;
    int     last_wait;
    int     delta;

    donecount = edt_done_count(pdv_p);
    last_wait = pdv_p->donecount;

    edt_msg(DBG2, "pdv_wait_last_image() last %d cur %d\n",
        last_wait, donecount);

    delta = donecount - last_wait;

    if (*nSkipped)
        *nSkipped = (delta) ? delta - 1 : 0;


    if (delta == 0)
        delta = 1;

    delta++;

    if (doRaw)
        ret = pdv_wait_images_raw(pdv_p, delta);
    else
        ret = pdv_wait_images(pdv_p, delta);

    return (ret);
}

unsigned char *
pdv_wait_next_image(PdvDev * pdv_p, int *nSkipped)
{

    return pdv_wait_next_image_raw(pdv_p, nSkipped, FALSE);
}


int
pdv_in_continuous(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_in_continuous() %x\n",
        pdv_p->dd_p->continuous);
    return pdv_p->dd_p->continuous;
}
 /* end acquisition */

void
pdv_check(PdvDev * pdv_p)
{
    int     stat;
    int     overrun;

    stat = edt_reg_read(pdv_p, PDV_STAT);
    overrun = edt_ring_buffer_overrun(pdv_p);
    edt_msg(DBG2, "pdv_check() stat %x overrun %x\n",
        stat, overrun);
    if ((stat & PDV_OVERRUN) || overrun)
    {
        if (pdv_p->dd_p->continuous)
            pdv_stop_hardware_continuous(pdv_p);

        pdv_flush_fifo(pdv_p);

        pdv_multibuf(pdv_p, pdv_p->ring_buffer_numbufs);

        if (pdv_p->dd_p->continuous)
            pdv_start_hardware_continuous(pdv_p);
    }
}

void
pdv_checkfrm(PdvDev * pdv_p, u_short * imagebuf, u_int imagesize, int verbose)
{
    u_short *tmpp;

    for (tmpp = (u_short *) imagebuf;
        tmpp < (u_short *) (&imagebuf[imagesize]); tmpp++)
    {
        if (*tmpp & 0xf000)
        {
            edt_msg(DBG2, "found start of image %x at %x %d\n",
                *tmpp >> 12,
                tmpp - (u_short *) imagebuf,
                tmpp - (u_short *) imagebuf);
            if (tmpp != imagebuf)
            {
                int     curdone;
                int     curtodo;

                edt_reg_write(pdv_p, PDV_CMD, PDV_RESET_INTFC);
                pdv_flush_fifo(pdv_p);
                curdone = edt_done_count(pdv_p);
                curtodo = edt_get_todo(pdv_p);
                edt_msg(DBG2, "done %d todo %d\n", curdone, curtodo);
                {
                    pdv_stop_continuous(pdv_p);
                    edt_set_buffer(pdv_p, curdone);
                    pdv_setup_continuous(pdv_p);
                    pdv_start_images(pdv_p, pdv_p->ring_buffer_numbufs -
                        (curtodo - curdone));
                }
            }
            break;
        }
    }
}

u_char *
pdv_get_interleave_data(PdvDev *pdv_p, u_char * buf, int bufnum)

{
    if (!pdv_process_inplace(pdv_p))
    {
        return  pdv_p->output_buffers[bufnum];
    }
    else
        return buf;
}


unsigned char *
pdv_wait_images_raw(PdvDev * pdv_p, int count)
{
    u_char *buf;
    Dependent *dd_p;
    u_int fc;
    int last_timeouts;

    edt_msg(DBG2, "pdv_wait_images_raw(%d)\n", count);

    if (pdv_p == NULL || pdv_p->dd_p == NULL)
        return NULL;

    dd_p = pdv_p->dd_p;

    last_timeouts = edt_timeouts(pdv_p);

    if (pdv_specinst_serial_triggered(pdv_p))
        pdv_posttrigger_specinst(pdv_p);

    if (pdv_p->devid == DMY_ID)
    {
        u_char *buf;
        u_int  *tmpp;

        buf = edt_next_writebuf(pdv_p);
        tmpp = (u_int *) buf;
        if (*tmpp != 0xaabbccdd)
        {
            pdv_dmy_data(buf, dd_p->width, dd_p->height, dd_p->depth);
        }
        *tmpp = 0xaabbccdd;
        dd_p->last_raw = buf;
        dd_p->last_image = buf;

        if (dd_p->markras)
            pdv_mark_ras(buf, dd_p->rascnt, dd_p->width, dd_p->height,
            dd_p->markrasx, dd_p->markrasy);
        if (dd_p->markbin)
            pdv_mark_bin(buf, dd_p->rascnt, dd_p->width, dd_p->height, 4, 0);

        if (dd_p->markbin || dd_p->markras) dd_p->rascnt++ ;
        return (buf);
    }
    
    buf = edt_wait_for_buffers(pdv_p, count);

    dd_p->last_raw = buf;
    dd_p->last_image = buf;

    if ((pdv_framesync_mode(pdv_p) == PDV_FRAMESYNC_EMULATE_TIMEOUT)
     && (pdv_check_framesync(pdv_p, buf, &fc) > 0)
     && (last_timeouts == edt_timeouts(pdv_p)))
        edt_do_timeout(pdv_p);

    return buf;
}


u_char *
pdv_wait_images(PdvDev *pdv_p, int count)

{
    u_char *buf;
    u_char *retval;
    Dependent *dd_p;
    u_int fc;
    int last_timeouts;

    edt_msg(DBG2, "pdv_wait_images(%d)\n", count);

    if (pdv_p == NULL || pdv_p->dd_p == NULL)
        return NULL;

    dd_p = pdv_p->dd_p;

    last_timeouts = edt_timeouts(pdv_p);

    if (dd_p->swinterlace)
    {
        pdv_alloc_tmpbuf(pdv_p);        
    }

    buf = pdv_wait_images_raw(pdv_p, count);


    if (dd_p->swinterlace)
    {

        if (!pdv_process_inplace(pdv_p))
        {

            int buf_index = pdv_p->donecount % pdv_p->ring_buffer_numbufs;

            /* INTERLACE FIX */
            retval = pdv_p->output_buffers[buf_index];

            /* retval = buf + pdv_get_dmasize(pdv_p); */
        }
        else
            retval = buf;

        pdv_deinterlace(pdv_p, dd_p, buf, retval);

        dd_p->last_raw = buf;
        dd_p->last_image = retval;
    }
    else
    {
        retval = buf;
        dd_p->last_raw = buf;
        dd_p->last_image = buf;
    }


    /* problem is that pdv_flshow calling images_raw directly - talk to steve */
    if (pdv_p->devid != DMY_ID)
    {
        if (dd_p->markras)
            pdv_mark_ras(buf, dd_p->rascnt, dd_p->width, dd_p->height,
            dd_p->markrasx, dd_p->markrasy);
        if (dd_p->markbin)
            pdv_mark_bin(buf, dd_p->rascnt, dd_p->width, dd_p->height, 4, 0);

        if (dd_p->markbin || dd_p->markras) dd_p->rascnt++ ;
    }

#if 0 /* NO! pdv_wait_images_raw does this */
    if ((pdv_framesync_mode(pdv_p) == PDV_FRAMESYNC_EMULATE_TIMEOUT)
     && (pdv_check_framesync(pdv_p, buf, &fc) > 0)
     && (last_timeouts == edt_timeouts(pdv_p)))
        edt_do_timeout(pdv_p);
#endif

    return (retval);
}

int
pdv_slop(PdvDev * pdv_p)
{
    return (pdv_p->dd_p->slop);
}


int
pdv_set_slop(PdvDev * pdv_p, int slop)
{
    edt_msg(DBG2, "pdv_set_slop()\n");

    pdv_p->dd_p->slop = slop;
    return (0);
}


pdv_set_header_type(PdvDev *pdv_p, int header_type, int irig_slave, int irig_offset, int irig_raw)
{

    switch(header_type)
    {
        case HDR_TYPE_NONE:
            if (edt_has_irigb(pdv_p))
            {
                edt_reg_and(pdv_p, PDV_UTILITY, ~(PDV_ENFRMCNT|PDVCL_IRIG2));
                pdv_p->dd_p->header_position = HeaderNone;
                pdv_p->dd_p->header_size = 0;
                pdv_p->dd_p->header_dma = 0;
                pdv_p->dd_p->header_type = 0;
            }
            break;
        case HDR_TYPE_IRIG2:
            if (!edt_has_irigb(pdv_p))
                return -1;

            edt_reg_and(pdv_p, PDV_UTILITY, ~(PDV_ENFRMCNT|PDVCL_IRIG2));
            pdv_p->dd_p->header_position = HeaderEnd;
            pdv_p->dd_p->header_size = 32;
            pdv_p->dd_p->header_dma = 1;
            edt_reg_or(pdv_p, PDV_UTILITY, PDVCL_IRIG2); /* just toggled off then back on resets */
            pdv_p->spi_reg_base = PDV_IRIG_SPI_BASE;
            if (pdv_p->channel_no == 1)
                pdv_p->spi_reg_base -= 0x40;

            pdv_irig_set_slave(pdv_p, irig_slave);
            if (!irig_slave)
            {
                pdv_irig_set_offset(pdv_p, irig_offset);
                pdv_irig_set_bcd(pdv_p, irig_raw);
            }
            pdv_p->dd_p->header_type = header_type;

            break;

        default:
            return -1;
    }

    edt_set_dependent(pdv_p, pdv_p->dd_p);

    return 0;
}

int
pdv_get_header_size(PdvDev * pdv_p)
{
    return (pdv_p->dd_p->header_size);
}

HdrPosition
pdv_get_header_position(PdvDev * pdv_p)
{
    return (HdrPosition) (pdv_p->dd_p->header_position);
}

int
pdv_get_header_offset(PdvDev * pdv_p)
{
    switch (pdv_p->dd_p->header_position)
    {
    case HeaderBefore:
        pdv_p->dd_p->header_offset = - (int) pdv_p->dd_p->header_size;
        break;
    case HeaderBegin:
        pdv_p->dd_p->header_offset = 0;
        break;
    case HeaderEnd:
        pdv_p->dd_p->header_offset = pdv_get_dmasize(pdv_p) - pdv_p->dd_p->header_size ;
        break;
    case HeaderAfter:
        pdv_p->dd_p->header_offset = pdv_p->dd_p->imagesize;
        break;

    }

    return (pdv_p->dd_p->header_offset);
}

int
pdv_get_header_dma(PdvDev * pdv_p)
{
    return (pdv_p->dd_p->header_dma);
}

int
pdv_get_header_within(PdvDev *pdv_p)

{
    return (pdv_p->dd_p->header_position == HeaderBegin ||
        pdv_p->dd_p->header_position == HeaderMiddle ||
        pdv_p->dd_p->header_position == HeaderEnd);
}

int
pdv_extra_headersize(PdvDev * pdv_p)

{
    if (pdv_p->dd_p->header_size && (!pdv_p->dd_p->header_dma) &&
        (pdv_p->dd_p->header_position ==  HeaderBefore || 
        pdv_p->dd_p->header_position == HeaderAfter))
        return pdv_p->dd_p->header_size;

    return 0;
}

void
pdv_set_header_size(PdvDev * pdv_p, int header_size)
{
    edt_msg(DBG2, "pdv_set_header_size()\n");

    pdv_p->dd_p->header_size = header_size;

}

void
pdv_set_header_position(PdvDev * pdv_p, HdrPosition header_position)

{
    edt_msg(DBG2, "pdv_set_header_position(%d)\n", header_position);

    pdv_p->dd_p->header_position = header_position;
}

void
pdv_set_header_dma(PdvDev * pdv_p, int header_dma)
{
    edt_msg(DBG2, "pdv_set_header_dma(%d,%d)\n", header_dma);

    pdv_p->dd_p->header_dma = header_dma;
}


void
pdv_set_header_offset(PdvDev * pdv_p, int header_offset)

{
    edt_msg(DBG2, "pdv_set_header_offset(%d,%d)\n", header_offset);

    pdv_p->dd_p->header_offset = header_offset;
}

int 
pdv_check_framesync(PdvDev *pdv_p, u_char *image_p, u_int *framecnt)
{
    Irig2Record *irp;   /* from pdv_irig.h */

    if ((image_p == NULL) || (pdv_framesync_mode(pdv_p) == 0))
        return -1;

    irp = (Irig2Record *)(image_p + pdv_get_header_offset(pdv_p));
    edt_msg(DBG2, "pdv_framesync(): magic %s framecnt %d\n", irp->magic == IRIG2_MAGIC? "OK ": "BAD", irp->framecnt);
    if (irp->magic == IRIG2_MAGIC)
    {
        *framecnt = irp->framecnt;
        return 0; /* success */
    }
    else *framecnt = 0;

    return 1; /* out-of-sync */
}

int
pdv_enable_framesync(PdvDev *pdv_p, int mode)
{
    int ret = 0;


    pdv_p->dd_p->framesync_mode = 0;

    if (!edt_has_irigb(pdv_p))
    {
        ret = -1;
    }
    else
    {
        if (mode)
        {
            if (pdv_set_header_type(pdv_p, HDR_TYPE_IRIG2, 1, 2, 0) < 0)
            {
                edt_msg(DBG2, "pdv_enable_framesync() FAIL\n");
                ret = -1;
            }
            else
            {
                pdv_p->dd_p->framesync_mode = mode;
                edt_msg(DBG2, "pdv_enable_framesync() OK\n");
            }
        }
        else
        {
            if (pdv_p->dd_p->header_type == HDR_TYPE_NONE)
                pdv_set_header_type(pdv_p, HDR_TYPE_NONE, 0, 0, 0);
        }
    }

    return ret;
}

int
pdv_framesync_mode(PdvDev *pdv_p)
{
    return pdv_p->dd_p->framesync_mode;
}

 /* end settings */

int
pdv_get_shutter_method(PdvDev * pdv_p, u_int *mcl)
{
    edt_msg(DBG2, "pdv_get_shutter_method()\n");

    *mcl = edt_reg_read(pdv_p, PDV_MODE_CNTL);

    return pdv_p->dd_p->camera_shutter_timing;
}

int
pdv_shutter_method(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_shutter_method()\n");

    return pdv_p->dd_p->camera_shutter_timing;
}

int
pdv_set_shutter_method(PdvDev *pdv_p, int method, unsigned int mcl)
{
    if (!pdv_p)
        return -1;

    edt_msg(DBG2, "pdv_set_shutter_method (%d, %02x)\n", method);

    pdv_p->dd_p->camera_shutter_timing = method;
    pdv_p->dd_p->mode_cntl_norm = mcl;

    edt_reg_write(pdv_p, PDV_MODE_CNTL, mcl);

    return 0;
}

void
pdv_set_interlace(PdvDev * pdv_p, int interlace)
{
    edt_msg(DBG2, "pdv_set_interlace()\n");

    pdv_p->dd_p->swinterlace = interlace;

    pdv_setup_postproc(pdv_p, pdv_p->dd_p, NULL);

}

int
pdv_interlace_method(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_interlace_method()\n");

    return pdv_p->dd_p->swinterlace;
}


int
pdv_debug(int flag)
{
    int     oldval = Pdv_debug;

    edt_msg(DBG2, "pdv_debug()\n");

    Pdv_debug = flag;
    return (oldval);
}

int
pdv_debug_level()
{
    return Pdv_debug;
}


int
pdv_overrun(PdvDev * pdv_p)
{
    int     overrun;

    edt_msg(DBG2, "pdv_overrun()\n");

    if (pdv_p->devid == DMY_ID)
        return (0);
    edt_ioctl(pdv_p, EDTG_OVERFLOW, &overrun);
    return (overrun);
}

int
pdv_serial_wait(PdvDev * pdv_p, int msecs, int count)
{
    edt_buf tmp;
    int     ret;

    pdv_serial_check_enabled(pdv_p);

    if (msecs == 0)
        msecs = pdv_p->dd_p->serial_timeout;

    tmp.desc = msecs;
    tmp.value = count;
    edt_ioctl(pdv_p, EDTS_SERIALWAIT, &tmp);
    ret = (int) tmp.value;
    edt_msg(DBG2, "pdv_serial_wait(%d, %d) ret %d\n", msecs, count, ret);
    return (ret);
}

int
pdv_serial_get_numbytes(PdvDev * pdv_p)
{
    edt_buf tmp;
    int     ret;

    tmp.desc = 0;
    tmp.value = 0;
    edt_ioctl(pdv_p, EDTS_SERIALWAIT, &tmp);
    ret = (int) tmp.value;
    edt_msg(DBG2, "pdv_serial_get_numbytes %d\n", ret);
    return (ret);
}

int
pdv_serial_wait_next(EdtDev * pdv_p, int msecs, int count)
{
    int     ret;
    int     newcount = count;

    ret = pdv_serial_wait(pdv_p, msecs, count);
    return (ret);
}

int
pdv_set_waitchar(PdvDev * pdv_p, int enable, u_char wchar)
{
    edt_buf tmp;
    int     ret;


    tmp.desc = enable;
    tmp.value = wchar;
    ret = edt_ioctl(pdv_p, EDTS_WAITCHAR, &tmp);
    pdv_p->dd_p->serial_waitc = wchar;
    if (!enable) /* top bit is flag for disabled (internally) */
        pdv_p->dd_p->serial_waitc |= 0x100;
    edt_msg(DBG2, "pdv_set_waitchar(%d, %02x) returns %d\n", enable, wchar, ret);
    return (ret);
}

int
pdv_get_waitchar(PdvDev * pdv_p, u_char *waitc)
{
    int ret;

    if (pdv_p->dd_p->serial_waitc & 0x100)
    {
        *waitc = pdv_p->dd_p->serial_waitc & 0xff;
        ret = 0;
    }
    else
    {
        *waitc = pdv_p->dd_p->serial_waitc;
        ret = 1;
    }
    return ret;
}


int
pdv_get_fulldma_size(PdvDev *pdv_p, int *extrasizep)

{
    int     size = pdv_get_imagesize(pdv_p);

    int     slop = pdv_slop(pdv_p);
    int     extrasize;
    Dependent *dd_p = pdv_p->dd_p;

    extrasize = slop + pdv_extra_headersize(pdv_p);

    if (pdv_get_header_dma(pdv_p) && (pdv_get_header_within(pdv_p)))
        size += pdv_get_header_size(pdv_p);

    if (dd_p->swinterlace || size != pdv_get_dmasize(pdv_p))
    {
        /* If extra buffer needed, put it after the data */

        if (!pdv_process_inplace(pdv_p) || size != pdv_get_dmasize(pdv_p))
        {
            int     newsize = pdv_get_dmasize(pdv_p);

            extrasize += size;  /* use second part of buffer for interlace result */
            size = newsize;
        }
    }

    if (extrasizep)
        *extrasizep = extrasize;

    return size;
}

int
pdv_total_block_size(PdvDev *pdv_p, int numbufs)

{
    int extrasize = 0;
    int size;

    size = pdv_get_fulldma_size(pdv_p, &extrasize);

    /* round up */
    size = edt_get_total_bufsize(pdv_p, size,/* INTERLACE FIX extrasize */ 0) * numbufs;

    return size;

}


void
pdv_free_output_buffers(PdvDev *pdv_p)

{
    if (pdv_p->output_buffers)
    {
        edt_free((uchar_t *)pdv_p->output_buffers);

        if (pdv_p->output_base)
            edt_free(pdv_p->output_base);

        pdv_p->output_base = NULL;
        pdv_p->output_buffers = NULL;
    }
}


void
pdv_allocate_output_buffers(PdvDev *pdv_p)

{
    /* determine if new allocation needed */

    if (pdv_p->output_buffers)
    {
        pdv_free_output_buffers(pdv_p);
    }

    if (pdv_p->dd_p->swinterlace)
    {
        int size = pdv_get_imagesize(pdv_p);

        u_int totalsize = size * pdv_p->ring_buffer_numbufs;

        if (totalsize > 0)
        {
            pdv_p->output_base = edt_alloc(totalsize);

            pdv_p->output_buffers = (unsigned char **)edt_alloc(sizeof(u_char *) * pdv_p->ring_buffer_numbufs);

            if (pdv_p->output_base && pdv_p->output_buffers)
            {
                int i;
                for (i=0;i<(int)pdv_p->ring_buffer_numbufs;i++)
                    pdv_p->output_buffers[i] = pdv_p->output_base + (size * i);
            }
        }
    }

}

int
pdv_multibuf_block(PdvDev *pdv_p, int numbufs, u_char *block, int blocksize)

{
    int size, extrasize = 0;
    int ret;
    int header_before = (pdv_p->dd_p->header_position == HeaderBefore);

    edt_msg(DBG2, "pdv_multibuf_block(%d, %d, %x)\n", numbufs, block, blocksize);

    /* FIXED INTERLACE */

    size = pdv_get_fulldma_size(pdv_p, &extrasize);


    pdv_setup_dma(pdv_p);

    ret = edt_configure_block_buffers_mem(pdv_p, 
        size, 
        numbufs, 
        EDT_READ, 
        /* INTERLACE FIX extrasize */ 0, 
        header_before,
        block) ;

    pdv_allocate_output_buffers(pdv_p); 

    return ret;

}

int
pdv_multibuf_separate(PdvDev *pdv_p, int numbufs, u_char **buffers)

{
    int     size = pdv_get_imagesize(pdv_p);
    int ret;

    Dependent *dd_p = pdv_p->dd_p;

    edt_msg(DBG2, "pdv_multibuf_separate(%d, %x)\n", numbufs, buffers);

    if (dd_p->swinterlace || size != pdv_get_dmasize(pdv_p))
    {
        /* If extra buffer needed, put it after the data */

        if (!pdv_process_inplace(pdv_p) || size != pdv_get_dmasize(pdv_p))
        {
            edt_msg_perror(PDVFATAL,"Interlace not inplace fails for multibuf_separate\n");
            return -1;
        }
    }

    size = pdv_get_fulldma_size(pdv_p, NULL);

    pdv_setup_dma(pdv_p);

    ret = edt_configure_ring_buffers(pdv_p, size, numbufs, EDT_READ, buffers) ;

    return ret;

}

int
pdv_multibuf(PdvDev * pdv_p, int numbufs)
{
    /* set number of buffers, library allocated. */

    /* define if not enough memory for contiguous allocation */
    /* but beware of interlace since currently not supported in separate */
    /* #ifdef RADSTONE*/
#if defined(XCALIBURCOMMON) || defined(VMIC)
    return pdv_multibuf_separate(pdv_p, numbufs,NULL);
#else
    return pdv_multibuf_block(pdv_p, numbufs, NULL, 0);
#endif

}

int
pdv_set_buffers(PdvDev * pdv_p, int numbufs, unsigned char **bufarray)
{
    /* set number of buffers, user allocated. */
    int     size = pdv_get_dmasize(pdv_p);

    edt_msg(DBG2, "pdv_set_buffers(%d %x) (size %d)\n", numbufs, bufarray, size);

    pdv_setup_dma(pdv_p);

    return (edt_configure_ring_buffers(pdv_p, size, numbufs, EDT_READ, bufarray));
}

/* plus size - so far just used for merge */
int
pdv_set_buffers_x(PdvDev * pdv_p, int numbufs, int size, unsigned char **bufs)
{

    edt_msg(DBG2, "pdv_set_buffers(%d %x) (size %d)\n", numbufs, bufs, size);

    pdv_setup_dma(pdv_p);

    return (edt_configure_ring_buffers(pdv_p, size, numbufs, EDT_READ, bufs));
}


int
pdv_image_size(PdvDev * pdv_p)
{
    int     size;

    size = pdv_p->dd_p->imagesize;

    if (pdv_p->dd_p->slop)
    {

        edt_msg(DBG2, "pdv_image_size: adjusting size %x by slop %x to %x\n",
            size, pdv_p->dd_p->slop, size - pdv_p->dd_p->slop);

        size -= pdv_p->dd_p->slop;

    }

    if (pdv_p->dd_p->header_dma)
        size += pdv_p->dd_p->header_size;

    edt_msg(DBG2, "pdv_image_size() %d\n", size);

    return size;

}


u_char *
pdv_get_last_image(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_get_last_image()\n");

    return (pdv_p->dd_p->last_image);
}

u_char *
pdv_get_last_raw(PdvDev * pdv_p)
{
    edt_msg(DBG2, "pdv_get_last_raw()\n");

    return (pdv_p->dd_p->last_raw);
}

u_char **
pdv_buffer_addresses(PdvDev * pdv_p)
{
    /* (same as edt_buffer_addresses) */
    return (pdv_p->ring_buffers);
}

void
pdv_start_hardware_continuous(PdvDev * pdv_p /* , int frames */ )
{
    int     data_path;

    /* data_path = edt_reg_read(pdv_p, PDV_DATA_PATH); */
    data_path = pdv_p->dd_p->datapath_reg & ~PDV_CONTINUOUS;
    /* data_path = 0x5 ; */
    edt_msg(DBG2, "pdv_start_hardware_continuous()\n");


    edt_reg_write(pdv_p, PDV_DATA_PATH, data_path | PDV_CONTINUOUS);
    pdv_p->dd_p->datapath_reg = data_path;
}


void
pdv_stop_hardware_continuous(PdvDev * pdv_p)
{
    int     data_path;

    /* data_path = edt_reg_read(pdv_p, PDV_DATA_PATH); */
    data_path = pdv_p->dd_p->datapath_reg;
    edt_msg(DBG2, "pdv_stop_hardware_continuous()\n");
    data_path &= ~PDV_CONTINUOUS;
    edt_reg_write(pdv_p, PDV_DATA_PATH, data_path);
    pdv_p->dd_p->datapath_reg = data_path;

}

int
pdv_set_serial_parity(PdvDev * pdv_p, char parity)
{
    if (pdv_p->devid == PDVAERO_ID)
    {
        int val = 0;
        switch(parity)
        {

        case 'e':
            val = 1;
            break;
        case 'o':
            val = 3;
            break;
        case 'n':
            val = 0;
            break;
        default:
            edt_msg(DBG1, "parity must be e, o, or n");
            return -1;
        }

        edt_reg_write(pdv_p,PDV_SERIAL_PARITY,val);
        return 0;
    }
    else
    {
        edt_msg(DBG1,"parity not an option for this board");
    }
    return -1;
}

int
pdv_set_baud(PdvDev * pdv_p, int baud)
{
    Dependent *dd_p = pdv_p->dd_p;
    u_int   baudbits = 0;
    int     id=pdv_p->devid;
    u_int   new, baudreg;
    u_int   cntl;
    int     donew        = 0;
    int     ret = 0;

    if (edt_is_dvcl(pdv_p) || edt_is_dvfox(pdv_p) || (id == PDVA_ID) || edt_is_dvcl2(pdv_p))
        donew = 1;

    switch (baud)
    {
    case 9600:
        baudbits = 0;
        baudreg = 0x80;
        break;

    case 19200:
        baudbits = PDV_BAUD0;
        baudreg = 0x3f;
        break;

    case 38400:
        baudbits = PDV_BAUD1;
        baudreg = 0x1f;
        break;

    case 115200:
        baudbits = PDV_BAUD0 | PDV_BAUD1;
        baudreg = 0x09;
        break;

    case 57600:
        baudbits = PDV_BAUD0 | PDV_BAUD1;       /* ALERT (funky old DV or DVK only) */
        donew = 1;
        baudreg = 0x014;
        break;

    default:
        donew = 1;
        baudreg = (unsigned int)(((20000000.0 / (16.0 * (double)baud)) - 2.0) + 0.5) ; 
        edt_msg(DBG2, "pdv_set_baud(%d) using new method, reg %02x\n", baud, baudreg);
        break;
    }

    if (donew && (!dd_p->register_wrap))
    {
        if (baudreg > 0xff)
        {
            edt_msg(DBG2, "pdv_set_baud(%d) (baudreg %x) BAD VALUE not set\n", baud, baudreg);
            ret = -1; 
        }
        else 
        {
            edt_msg(DBG2, "pdv_set_baud(%d) (baudreg %x) using NEW baud reg\n", baud, baudreg);
            edt_reg_write(pdv_p, PDV_BRATE, baudreg);
            new = edt_reg_read(pdv_p, PDV_BRATE);
            if (new != baudreg)
            {
                edt_msg(DBG2, "pdv_set_baud(%d) wrote %x read %x) readback ERROR\n", baud, baudreg, new);
                ret = -1;
            }
        }
    }

    else /* old way */
    {
        edt_msg(DBG2, "pdv_set_baud(%d) (baudbits %x) using OLD baud bits\n", baud, baudbits);
        cntl = edt_reg_read(pdv_p, PDV_SERIAL_DATA_CNTL);
        cntl &= ~PDV_BAUD_MASK;
        cntl |= baudbits;
        edt_reg_write(pdv_p, PDV_SERIAL_DATA_CNTL, cntl);
    }

    if (ret == 0)
    {
        pdv_p->dd_p->serial_baud = baud;
        edt_set_dependent(pdv_p, pdv_p->dd_p);
    }

    return ret;
}

int
pdv_get_baud(PdvDev * pdv_p)
{
    if (pdv_p->dd_p->serial_baud == NOT_SET)
        return 9600;
    return pdv_p->dd_p->serial_baud;
}

void
pdv_perror(char *err)
{
    edt_perror(err);
}

void
pdv_setdebug(PdvDev * pdv_p, int debug)
{
    Pdv_debug = debug;
}





void
pdv_reset_serial(PdvDev * pdv_p)
{
    edt_reset_serial(pdv_p);
}


uchar_t *
pdv_alloc(int size)
{
    return edt_alloc(size);
}


void
pdv_free(uchar_t * ptr)
{
    edt_free(ptr);
}



static u_short zero[] = {
    0x0F80,
    0x3FE0,
    0x38E0,
    0x7070,
    0x6030,
    0xE038,
    0xE038,
    0xE038,
    0xE038,
    0xE038,
    0xE038,
    0xE038,
    0x6030,
    0x7070,
    0x38E0,
    0x3FE0,
    0x0F80,
};
static u_short one[] = {
    0xFC00,
    0xFC00,
    0x1C00,
    0x1C00,
    0x1C00,
    0x1C00,
    0x1C00,
    0x1C00,
    0x1C00,
    0x1C00,
    0x1C00,
    0x1C00,
    0x1C00,
    0x1C00,
    0x1C00,
    0xFF80,
    0xFF80,
};
static u_short two[] = {
    0x7E00,
    0x7F80,
    0x4380,
    0x01C0,
    0x01C0,
    0x01C0,
    0x01C0,
    0x0380,
    0x0700,
    0x0E00,
    0x1C00,
    0x3800,
    0x3800,
    0x7000,
    0xE000,
    0xFFC0,
    0xFFC0,
};
static u_short three[] = {
    0x7E00,
    0xFF00,
    0x8780,
    0x0380,
    0x0380,
    0x0380,
    0x0F00,
    0x7C00,
    0x7E00,
    0x0F00,
    0x0380,
    0x0380,
    0x0380,
    0x0380,
    0x8700,
    0xFF00,
    0xFC00,
};
static u_short four[] = {
    0x0380,
    0x0780,
    0x0F80,
    0x0F80,
    0x1F80,
    0x1B80,
    0x3380,
    0x3380,
    0x6380,
    0xE380,
    0xFFE0,
    0xFFE0,
    0xFFE0,
    0x0380,
    0x0380,
    0x0380,
    0x0380,
};
static u_short five[] = {
    0xFF80,
    0xFF80,
    0xE000,
    0xE000,
    0xE000,
    0xC000,
    0xF800,
    0xFE00,
    0x0F00,
    0x0780,
    0x0380,
    0x0380,
    0x0380,
    0x0380,
    0x8700,
    0xFE00,
    0xFC00,
};
static u_short six[] = {
    0x07E0,
    0x1FE0,
    0x3C20,
    0x7000,
    0x7000,
    0xE000,
    0xE780,
    0xFFE0,
    0xF0E0,
    0xE070,
    0xE070,
    0xE070,
    0xE070,
    0x7070,
    0x70E0,
    0x3FC0,
    0x0F80,
};
static u_short seven[] = {
    0xFFC0,
    0xFFC0,
    0x01C0,
    0x0180,
    0x0380,
    0x0700,
    0x0700,
    0x0E00,
    0x0C00,
    0x1C00,
    0x1800,
    0x3800,
    0x3800,
    0x3000,
    0x7000,
    0x7000,
    0x7000,
};
static u_short eight[] = {
    0x0F80,
    0x3FC0,
    0x71E0,
    0x70E0,
    0x70E0,
    0x7DE0,
    0x3FC0,
    0x1F00,
    0x1FC0,
    0x7FE0,
    0xF1F0,
    0xE0F0,
    0xE070,
    0xE070,
    0xF0E0,
    0x7FE0,
    0x1F80,
};
static u_short nine[] = {
    0x1F00,
    0x3FC0,
    0x70E0,
    0xE0E0,
    0xE070,
    0xE070,
    0xE070,
    0xE070,
    0x70F0,
    0x7FF0,
    0x1E70,
    0x0070,
    0x00E0,
    0x00E0,
    0x43C0,
    0x7F80,
    0x7E00,
};

static u_short *digits[] = {
    zero,
    one,
    two,
    three,
    four,
    five,
    six,
    seven,
    eight,
    nine,
};


static void
set_square_32(int sx, int sy, u_short * buf, u_int * addr, int stride, int fg)
{
    /*
    * colors
    */

#define BG16    0

    /*
    * get offset to square
    */
    register u_int *svptr;
    register u_int *ptr;
    int     i;
    int     bit;
    u_short tmp;
    int     val;

    svptr = addr + (stride * sy) + (sx);

    for (i = 0; i < 17; i++)
    {
        ptr = svptr;
        tmp = *buf++;
        for (bit = 15; bit >= 0; bit--)
        {
            if (tmp & (1 << bit))
            {
                val = fg;
            }
            else
            {
                val = BG16;
            }
            *ptr++ = val;
        }
        svptr += stride;
    }
}


static void
set_square_16(int sx, int sy, u_short * buf, u_short * addr, int stride, int fg)
{
    /*
    * colors
    */

#define BG16    0

    /*
    * get offset to square
    */
    register u_short *svptr;
    register u_short *ptr;
    int     i;
    int     bit;
    u_short tmp;
    int     val;

    svptr = addr + (stride * sy) + (sx);

    for (i = 0; i < 17; i++)
    {
        ptr = svptr;
        tmp = *buf++;
        for (bit = 15; bit >= 0; bit--)
        {
            if (tmp & (1 << bit))
            {
                val = fg;
            }
            else
            {
                val = BG16;
            }
            *ptr++ = val;
        }
        svptr += stride;
    }
}

static void
set_square(int sx, int sy, u_short * buf, u_char * addr, int stride, int fg)
{
    /*
    * colors
    */

#define BG      0

    /*
    * get offset to square
    */
    register u_char *svptr;
    register u_char *ptr;
    int     i;
    int     bit;
    u_short tmp;
    int     val;

    svptr = addr + (stride * sy) + (sx);

    for (i = 0; i < 17; i++)
    {
        ptr = svptr;
        tmp = *buf++;
        for (bit = 15; bit >= 0; bit--)
        {
            if (tmp & (1 << bit))
            {
                val = fg;
            }
            else
            {
                val = BG;
            }
            *ptr++ = val;
        }
        svptr += stride;
    }
}

void
pdv_mark_digit_16(u_short * addr, int n, int width, int height, int x, int y,
                  int mask, int fg)

{
    int dig = n % 10;

    set_square_16(x, y, digits[dig], addr, width, fg);

}

void
pdv_mark_digit_32(u_int * addr, int n, int width, int height, int x, int y,
                  int mask, int fg)

{
    int dig = n % 10;

    set_square_32(x, y, digits[dig], addr, width, fg);

}

void
pdv_mark_digit_24(u_char * addr, int n, int width, int height, int x, int y,
                  int mask, int fg)

{
    int dig = n % 10;

    set_square(x, y, digits[dig], addr, width, fg);

}

void
pdv_mark_digit_8(u_char * addr, int n, int width, int height, int x, int y,
                 int mask, int fg)

{
    int dig = n % 10;

    set_square(x, y, digits[dig], addr, width, fg);

}

void
pdv_mark_ras_depth(void * addr, int n, int width, int height, int x, int y, int depth, int fg)
{
#define GAP     16
    int div = 1000000;

    int i;

    for (i=0;div>=1;i++)
    {

        if (n > div)
        {
            int val = (n / div) % 10;

            switch(depth)
            {
            case 8:
                pdv_mark_digit_8((u_char *) addr, val, width, height, x + (GAP * i), y, 1, fg);
                break;
            case 16:
                pdv_mark_digit_16((u_short *) addr, val, width, height, x + (GAP * i), y, 1, fg);
                break;
            case 24:
                pdv_mark_digit_24((u_char *) addr, val, width, height, x + (GAP * i), y, 1, fg);
                break;
            case 32:
                pdv_mark_digit_32((u_int *) addr, val, width, height, x + (GAP * i), y, 1, fg);
                break;
            }
        }

        div /= 10;
    }
}

void
pdv_mark_bin_16(u_short * addr, int n, int width, int height, int x, int y)
{
    u_int   val = n;
    u_char *svptr;

    svptr = (u_char *) addr + (width * y) + x;
    *svptr++ = (val >> 24) & 0xff;
    *svptr++ = (val >> 16) & 0xff;
    *svptr++ = (val >> 8) & 0xff;
    *svptr++ = val & 0xff;
}


void
pdv_mark_ras(u_char * addr, int n, int width, int height, int x, int y)
{
#define GAP     16
    int div = 1000000;
    int i;

    for (i=0;div;i++)
    {
        pdv_mark_digit_8(addr, n, width, height, x + (GAP * i), y, div, 200);
        div /= 10;
    }
}

void
pdv_mark_bin(u_char * addr, int n, int width, int height, int x, int y)
{
    u_int   val = n;
    u_char *svptr;

    svptr = (u_char *) addr + (width * y) + x;
    *svptr++ = (val >> 24) & 0xff;
    *svptr++ = (val >> 16) & 0xff;
    *svptr++ = (val >> 8) & 0xff;
    *svptr++ = val & 0xff;
}

int
pdv_serial_command_hex(PdvDev * pdv_p, const char *str, int length)
{
    char    buf[2];
    const char   *p = &str[2];
    u_int   lval;

    sscanf(p, "%x", &lval);
    buf[0] = (char) (lval & 0xff);
    edt_msg(DBG2, "pdv_serial_command_hex(%s),0x%x\n", str, (u_char) (buf[0]));

    return pdv_serial_binary_command(pdv_p, buf, 1);
}

int
pdv_set_roi(PdvDev * pdv_p, int hskip, int hactv, int vskip, int vactv)
{
    return pdv_set_roi_internal(pdv_p, hskip, hactv, vskip, vactv, 1);
}


int
pdv_set_roi_internal(PdvDev * pdv_p, int hskip, int hactv, int vskip, int vactv, int call_setsize)
{
    Dependent *dd_p = pdv_p->dd_p;
    int     cam_w, cam_h;       /* camera actual w/h */

    edt_msg(DBG2, "pdv_set_roi(hskip %d hactv %d vskip %d vactv %d)\n",
        hskip, hactv, vskip, vactv);

    cam_w = pdv_get_cam_width(pdv_p);
    cam_h = pdv_get_cam_height(pdv_p);

    /* check width/height for out of range, unless camera link or FOI */
    if (!pdv_is_cameralink(pdv_p))
    {
        if ((cam_w && ((hskip + hactv) > cam_w)) || ((hskip + hactv) <= 0))
        {
            edt_msg(DBG2, "ROI: horiz. skip/actv out of range error\n");
            return -1;
        }
        if ((cam_h && ((vskip + vactv) > cam_h)) || ((vskip + vactv) <= 0))
        {
            edt_msg(DBG2, "ROI: vert. skip/actv out of range error\n");
            return -1;
        }
    }

    /* vert must be even, and regs set to value/taps  */
    if (pdv_is_cameralink(pdv_p))
    {
        if (dd_p->htaps > 0)
        {
            hactv = (hactv / dd_p->htaps) * dd_p->htaps;
            hskip = (hskip / dd_p->htaps) * dd_p->htaps;

            edt_reg_write(pdv_p, PDV_HSKIP, (hskip / dd_p->htaps));
            edt_reg_write(pdv_p, PDV_HACTV, (hactv / dd_p->htaps) - 1);
        }

        if (dd_p->vtaps > 0)
        {
            vactv = (vactv / dd_p->vtaps) * dd_p->vtaps;
            vskip = (vskip / dd_p->vtaps) * dd_p->vtaps;

            edt_reg_write(pdv_p, PDV_VSKIP, (vskip / dd_p->vtaps));
            edt_reg_write(pdv_p, PDV_VACTV, (vactv / dd_p->vtaps) - 1);
        }
    }
    else if (dd_p->dual_channel)
    {
        vactv = (vactv / 2) * 2;
        vskip = (vskip / 2) * 2;
        edt_reg_write(pdv_p, PDV_VSKIP, (vskip / 2));
        edt_reg_write(pdv_p, PDV_HSKIP, hskip);
        edt_reg_write(pdv_p, PDV_VACTV, (vactv / 2) - 1);
        edt_reg_write(pdv_p, PDV_HACTV, hactv - 1);
    }
    else
    {
        edt_reg_write(pdv_p, PDV_HSKIP, hskip);
        edt_reg_write(pdv_p, PDV_VSKIP, vskip);
        edt_reg_write(pdv_p, PDV_HACTV, hactv - 1);
        edt_reg_write(pdv_p, PDV_VACTV, vactv - 1);
    }

    dd_p->hactv = hactv;
    dd_p->hskip = hskip;
    dd_p->vactv = vactv;
    dd_p->vskip = vskip;

    if (call_setsize && dd_p->roi_enabled)
        pdv_setsize(pdv_p, dd_p->hactv, dd_p->vactv);

    edt_set_dependent(pdv_p, dd_p);

    return 0;                   /* ALERT: need to return error from above if
                        * any */
}


void
pdv_cl_set_base_channels(PdvDev *pdv_p, int htaps, int vtaps)

{
    Dependent *dd_p = pdv_p->dd_p;
    int taps;

    if ((htaps > 1) && (vtaps > 1))
        taps = htaps + vtaps;
    else if (htaps > 1)
        taps = htaps;
    else if (vtaps > 1)
        taps = vtaps;
    else taps = 1;

    dd_p->cl_data_path = (taps - 1) << 4 | (dd_p->depth - 1);

    dd_p->htaps = htaps;
    dd_p->vtaps = vtaps;

    edt_reg_write(pdv_p, PDV_CL_DATA_PATH, dd_p->cl_data_path);

    edt_set_dependent(pdv_p, dd_p);

    pdv_set_roi(pdv_p, dd_p->hskip, dd_p->hactv, dd_p->vskip, dd_p->vactv);
}



/*****************************************************/
/* Set the Dalsa line scan using AIAG - hskip and hactv */
/* control the exposure time and the linerate */
/*****************************************************/

int
pdv_dalsa_ls_set_expose(PdvDev * pdv_p, int hskip, int hactv)
{
    Dependent *dd_p = pdv_p->dd_p;

    edt_msg(DBG2, "pdv_dalsa_ls_set_expose(hskip %d hactv %d)\n", hskip, hactv);

    edt_reg_write(pdv_p, PDV_HSKIP, hskip);
    edt_reg_write(pdv_p, PDV_HACTV, hactv - 1);

    dd_p->hactv = hactv;
    dd_p->hskip = hskip;

    edt_set_dependent(pdv_p, dd_p);
    pdv_enable_roi(pdv_p, 1);

    return 0;                   /* ALERT: need to return error from above if *
                        * any */
}


int
pdv_auto_set_roi(PdvDev * pdv_p)
{
    int     w = pdv_p->dd_p->width;
    int     h = pdv_p->dd_p->height;
    int     ret;

    edt_msg(DBG2, "pdv_auto_set_roi()\n");

    if ((ret = pdv_set_roi(pdv_p, 0, w, 0, h)) == 0)
    {
        if (pdv_is_cameralink(pdv_p))
            pdv_setsize(pdv_p, pdv_p->dd_p->hactv, pdv_p->dd_p->vactv);
        ret = pdv_enable_roi(pdv_p, 1);
    }

    return ret;
}

int
pdv_enable_roi(PdvDev * pdv_p, int flag)
{
    u_int   roictl;
    Dependent *dd_p = pdv_p->dd_p;

    /* NEW 6/20 -- CL NOT always enabled; modified accordingly */
    if (pdv_is_cameralink(pdv_p))
    {
        if (flag) /* enable */
        {
            edt_reg_and(pdv_p, PDV_CL_CFG, ~PDV_CL_CFG_ROIDIS);
            pdv_setsize(pdv_p, dd_p->hactv, dd_p->vactv);
        }
        else /* disable */
        {
            edt_reg_or(pdv_p, PDV_CL_CFG, PDV_CL_CFG_ROIDIS);
            pdv_setsize(pdv_p, dd_p->cam_width, dd_p->cam_height);
        }

        dd_p->roi_enabled = flag;

        return 0;
    }

    edt_msg(DBG2, "pdv_enable_roi(%d): %sabling\n", flag, flag ? "EN" : "DIS");

    /* edt_msleep(100); */

    roictl = edt_reg_read(pdv_p, PDV_ROICTL);


    if (flag)                   /* enable ROI */
    {
        roictl |= PDV_ROICTL_ROI_EN;
        edt_reg_write(pdv_p, PDV_ROICTL, roictl);
        pdv_setsize(pdv_p, dd_p->hactv, dd_p->vactv);
    }
    else                        /* disable ROI */
    {
        /* ALERT -- not a R/W reg so can't and/or bits */
        roictl &= ~PDV_ROICTL_ROI_EN;
        edt_reg_write(pdv_p, PDV_ROICTL, roictl);
        pdv_setsize(pdv_p, dd_p->cam_width, dd_p->cam_height);
    }

    dd_p->roi_enabled = flag;

    return 0;
}

int
pdv_get_roi_enabled(PdvDev *pdv_p)

{
    Dependent *dd_p = pdv_p->dd_p;

    if (pdv_is_cameralink(pdv_p))
    {
        dd_p->roi_enabled = (edt_reg_read(pdv_p, PDV_CL_CFG) & 0x08) != 0;
    }
    else
    {
        dd_p->roi_enabled = (edt_reg_read(pdv_p, PDV_ROICTL) & PDV_ROICTL_ROI_EN) != 0;
    }

    return dd_p->roi_enabled;
}

int
pdv_access(char *fname, int perm)
{
    return edt_access(fname, perm);
}


int
pdv_strobe(PdvDev * pdv_p, int count, int delay)
{
    if (pdv_strobe_method(pdv_p) != PDV_LHS_METHOD1)
        return -1;

    edt_msg(DBG2, "pdv_strobe(%d %d)\n", count, delay);

    edt_reg_write(pdv_p, PDV_SHUTTER, delay);

    /*
    * write to LSB loads the low byte, write to MSB loads high byte and also
    * fires the strobe
    */
    edt_reg_write(pdv_p, PDV_FIXEDLEN, count);

    return 0;
}

int
pdv_set_strobe_counters(PdvDev * pdv_p, int count, int delay, int period)
{
    if (pdv_strobe_method(pdv_p) != PDV_LHS_METHOD2)
        return -1;

    if (count > 0xfff)
    {
        edt_msg(DBG1, "pdv_set_strobe_counters() ERROR -- count out of range\n");
        return -1;
    }

    if (delay > 0xff)
    {
        edt_msg(PDVWARN, "pdv_set_strobe_counters() ERROR -- delay out of range\n");
        return -1;
    }

    if (period > 0xff)
    {
        edt_msg(PDVWARN, "pdv_set_strobe_counters() ERROR -- period out of range\n");
        return -1;
    }

    edt_msg(DBG2, "pdv_set_strobe_counters(%d %d %d)\n", count, delay, period);

    edt_reg_write(pdv_p, PDV_LHS_DELAY, delay);

    edt_reg_write(pdv_p, PDV_LHS_PERIOD, period);

    /*
    * write to the count (2 bytes, combined)
    */
    edt_reg_write(pdv_p, PDV_LHS_COUNT, count);

    return 0;
}

int
pdv_enable_strobe(PdvDev * pdv_p, int ena)
{
    int method = pdv_strobe_method(pdv_p);

    if (method == 0)
        return -1;

    if (method == PDV_LHS_METHOD1)
    {
        if (ena == 0)
            return -1;
        return 0;
    }

    if (ena)
        edt_reg_write(pdv_p, PDV_LHS_CONTROL, PDV_LHS_ENABLE);
    else edt_reg_write(pdv_p, PDV_LHS_CONTROL, 0);

    return 0;
}

int
pdv_strobe_method(PdvDev *pdv_p)
{
    Dependent *dd_p = pdv_p->dd_p;
    int status;

    if (dd_p->strobe_enabled == NOT_SET)
    {
        int reg ;

        /* default to not enabled */
        dd_p->strobe_enabled = 0;


        /* ALERT: figure out somehow whether LH strobe flash is loaded
        * but for now just return lhs2 */
        if (pdv_p->devid == PDVCL_ID)
        {
            dd_p->strobe_enabled = PDV_LHS_METHOD2;
            return dd_p->strobe_enabled;
        }

        /* old xilinx revs didn't have strobe, so just bail out here */
        if (dd_p->xilinx_rev < 2 || dd_p->xilinx_rev > 32)
            return 0;

        /*
        * see if new LHS registers are there (can be written/read)
        */
        if (!dd_p->register_wrap)
        {
            reg = edt_reg_read(pdv_p, PDV_LHS_COUNT_HI);
            edt_reg_write(pdv_p, PDV_LHS_COUNT_HI, 0x50);
            if (edt_reg_read(pdv_p, PDV_LHS_COUNT_HI) == 0x50)
            {
                edt_reg_write(pdv_p, PDV_LHS_COUNT_HI, reg);
                dd_p->strobe_enabled = PDV_LHS_METHOD2;
                return dd_p->strobe_enabled;
            }
        }

        /* still here? okay check for (infer) OLD strobe method */

        status = edt_reg_read(pdv_p, PDV_SERIAL_DATA_STAT);

        if (status & LHS_DONE)
            dd_p->strobe_enabled = PDV_LHS_METHOD1;

    }

    return dd_p->strobe_enabled;
}


int
pdv_set_strobe_dac(PdvDev * pdv_p, u_int value)
{
    int     i;
    int     reg;
    int     method;
    u_int   mcl, mask;
    u_char  data;

    if ((method = pdv_strobe_method(pdv_p)) == 0)
        return -1;

    if (method == PDV_LHS_METHOD2)
        reg = PDV_LHS_CONTROL;
    else reg = PDV_MODE_CNTL;

    edt_msg(DBG2, "pdv_strobe(%d)\n", value);

    mcl = edt_reg_read(pdv_p, reg) & 0x0f;      /* preserve low bits */

    /*
    * dac is high nibble of register with strobe xilinx first we clear, then
    * set low bit
    */
    edt_reg_write(pdv_p, reg, mcl | PDV_LHS_DAC_LOAD);

    /*
    * shift in 16 bits
    */
    for (i = 0; i < 16; i++)
    {
        mask = (value & (1 << (15 - i)));

        if (mask)
            data = PDV_LHS_DAC_DATA;
        else
            data = 0;

        edt_reg_write(pdv_p, reg, mcl | PDV_LHS_DAC_LOAD | data);
        edt_reg_write(pdv_p, reg, mcl | PDV_LHS_DAC_LOAD | PDV_LHS_DAC_CLOCK | data);
        edt_reg_write(pdv_p, reg, mcl | PDV_LHS_DAC_LOAD | data);
        edt_reg_write(pdv_p, reg, mcl | PDV_LHS_DAC_LOAD);
    }

    edt_reg_write(pdv_p, reg, mcl &~ PDV_LHS_DAC_LOAD);
    return 0;
}

void
pdv_flush_channel_fifo(PdvDev * pdv_p)
{

    /* now obsolete channel reset is fixed for FOX 
    jsc 3/6/06 */

    pdv_flush_fifo(pdv_p);
}

void
pdv_flush_fifo(PdvDev * pdv_p)
{
    /* previously in comment: @see edt_set_firstflush */
    if (pdv_p->devid == PDV_ID ||
        pdv_p->devid == PDVK_ID ||
        pdv_p->devid == PDVFOI_ID ||
        pdv_p->devid == PDVA_ID)
    {
        edt_msg(DBG2, "pdv_flush_fifo() [PCI]\n");
        edt_flush_fifo(pdv_p);
        return;
    }

    if (pdv_p->devid == PDVCL_ID   || 
        pdv_p->devid == PE1DVVL_ID ||
        pdv_p->devid == PE4DVVL_ID ||
        pdv_p->devid == PE4DVCL_ID ||
        pdv_p->devid == PE8DVCL_ID ||
        pdv_p->devid == PE4DVVLSIM_ID ||
        pdv_p->devid == PE8DVCLS_ID)
    {
        /* RFIFO doesnt exist on camera link */
        /* doing the reset intfc here may cause problems */
        /* possibly when it happens in same frame as grab - TODO - check */
        u_int cfg ;

        edt_msg(DBG2, "pdv_flush_fifo() [cameralink]\n");
        cfg = edt_intfc_read(pdv_p, PDV_CFG);
        cfg &= ~PDV_FIFO_RESET;
        edt_intfc_write(pdv_p, PDV_CMD, PDV_RESET_INTFC);
        edt_intfc_write(pdv_p, PDV_CFG, (u_char) (cfg | PDV_FIFO_RESET));
        edt_intfc_write(pdv_p, PDV_CFG, cfg);
        edt_flush_channel(pdv_p, pdv_p->channel_no);

    }
    else
    {
        /* DV-FOX, PCIe C-Link */

        u_int cfg ;

        edt_msg(DBG2, "pdv_flush_fifo() [DVFOX, PCIe4/8]");
        cfg = edt_intfc_read(pdv_p, PDV_CFG);
        cfg &= ~PDV_FIFO_RESET;
        edt_intfc_write(pdv_p, PDV_CFG, (u_char) (cfg | PDV_FIFO_RESET));
        edt_flush_channel(pdv_p, pdv_p->channel_no);
        edt_intfc_write(pdv_p, PDV_CFG, cfg);
    }
}

void
pdv_setup_continuous_channel(PdvDev * pdv_p)

{
    /* now obsolete channel reset is fixed for FOX 
    jsc 3/6/06 */
    pdv_setup_continuous(pdv_p);
}

void
pdv_setup_continuous(PdvDev * pdv_p)
{
    pdv_flush_fifo(pdv_p);

    if (pdv_p->devid == PDV_ID ||
        pdv_p->devid == PDVK_ID ||
        pdv_p->devid == PDVA_ID)
    {

        if (edt_get_firstflush(pdv_p) != EDT_ACT_KBS)
            edt_set_firstflush(pdv_p, EDT_ACT_ONCE);
    }
    else
    {
        edt_set_firstflush(pdv_p,EDT_ACT_NEVER) ;
        edt_set_autodir(pdv_p, 0) ;

    }

    edt_startdma_reg(pdv_p, PDV_CMD, PDV_ENABLE_GRAB);

    if (pdv_in_continuous(pdv_p))
    {
        /* pdv_start_hardware_continuous(pdv_p) ; */
        edt_set_continuous(pdv_p, 1);
    }
    else if (pdv_p->dd_p->fv_once)
    {
        pdv_start_hardware_continuous(pdv_p);
    }
    else
        edt_set_continuous(pdv_p, 0);

    pdv_p->dd_p->started_continuous = 1;

}

void
pdv_stop_continuous(PdvDev * pdv_p)
{

    if (pdv_in_continuous(pdv_p))
    {
        edt_set_continuous(pdv_p, 0);
    }
    else if (pdv_p->dd_p->fv_once)
        pdv_stop_hardware_continuous(pdv_p); 

    pdv_p->dd_p->started_continuous = 0;


}

int
pdv_timeout_restart(PdvDev * pdv_p, int restart)
{
    int     curdone, curtodo;

    curdone = edt_done_count(pdv_p);
    curtodo = edt_get_todo(pdv_p);

    edt_abort_dma(pdv_p);
    pdv_stop_continuous(pdv_p);

    edt_set_buffer(pdv_p, curdone);
    edt_reg_write(pdv_p, PDV_CMD, PDV_RESET_INTFC);
    pdv_setup_continuous(pdv_p);

    if (restart && 
        (curtodo - curdone))
        pdv_start_images(pdv_p, curtodo - curdone);

    return curtodo - curdone;
}
 /* end acquisition */

/* for debug printfs only */
static char hs[128];
static char *
hex_to_str(char *resp, int n)
{

    int     i;
    char   *p = hs;

    for (i = 0; i < n; i++)
    {
        sprintf(p, "%02x ", resp[i]);
        p += 3;
    }
    *p = '\0';
    return hs;
}


int
pdv_get_min_shutter(PdvDev * pdv_p)

{
    return pdv_p->dd_p->shutter_speed_min;
}


int
pdv_get_max_shutter(PdvDev * pdv_p)

{
    return pdv_p->dd_p->shutter_speed_max;
}


int
pdv_get_min_gain(PdvDev * pdv_p)

{
    return pdv_p->dd_p->gain_min;
}


int
pdv_get_max_gain(PdvDev * pdv_p)

{
    return pdv_p->dd_p->gain_max;
}


int
pdv_get_min_offset(PdvDev * pdv_p)

{
    return pdv_p->dd_p->offset_min;
}


int
pdv_get_max_offset(PdvDev * pdv_p)

{
    return pdv_p->dd_p->offset_max;
}

int
pdv_enable_lock(PdvDev * pdv_p, int flag)
{
    Dependent *dd_p = pdv_p->dd_p;
    int     ret;

    switch (dd_p->lock_shutter)
    {
    case KODAK_AIA_MCL:
        {
            int     mcl = edt_reg_read(pdv_p, PDV_MODE_CNTL);

            if (flag)
                mcl |= PDV_AIA_MC3;
            else
                mcl &= ~PDV_AIA_MC3;

            edt_reg_write(pdv_p, PDV_MODE_CNTL, mcl);
            ret = 0;
            break;
        }
    case KODAK_AIA_SER:
        {
            if (flag)
                ret = pdv_serial_command(pdv_p, "SHE OF");
            else
                ret = pdv_serial_command(pdv_p, "SHE ON");

            break;
        }
    case KODAK_SER_14I:
        {
            if (flag)
                ret = pdv_serial_command(pdv_p, "SHE FO");
            else
                ret = pdv_serial_command(pdv_p, "SHE ON");
            break;
        }
    case HAM_4880:
        {
            if (flag)
                ret = pdv_serial_command(pdv_p, "ASH O");
            else
                ret = pdv_serial_command(pdv_p, "ASH A");
            break;
        }
    }
    return (ret);
}


void
pdv_send_break(PdvDev * pdv_p)
{
    u_int   reg;

    edt_msg(DBG2, "pdv_send_break()");

    reg = edt_reg_read(pdv_p, PDV_UTIL2);
    edt_reg_write(pdv_p, PDV_UTIL2, reg & ~PDV_MC4);
    edt_reg_write(pdv_p, PDV_UTIL2, (reg | PDV_SEL_MC4) & ~PDV_MC4);
    edt_msleep(500);
    edt_reg_write(pdv_p, PDV_UTIL2, reg & ~PDV_SEL_MC4 & ~PDV_MC4);
    edt_reg_write(pdv_p, PDV_UTIL2, reg);
}

static void
pdv_trigger_specinst(PdvDev * pdv_p)
{
    char    cmd = pdv_p->dd_p->serial_trigger[0];

    edt_msg(DBG2, "pdv_trigger_specinst('%c')\n", cmd);

    pdv_serial_binary_command(pdv_p, &cmd, 1);

}

static void
pdv_posttrigger_specinst(PdvDev * pdv_p)
{
    char    cmd = pdv_p->dd_p->serial_trigger[0];
    char    resp[32];
    int     ret;
    int     waitcnt = 2;

    resp[0] = resp[1] = resp[2] = 0;

#ifdef SPECINST_WAS
    if (pdv_p->devid == PDVFOI_ID)
        waitcnt += 2;
    if ((ret = pdv_serial_wait(pdv_p, 1500, waitcnt)) == waitcnt)
        pdv_serial_read(pdv_p, resp, ret);
#else
    if (pdv_p->devid == PDVFOI_ID)
        pdv_serial_wait_next(pdv_p, 2000, 0);
    else
        pdv_serial_wait_next(pdv_p, 2000, 1);
    ret = pdv_serial_read(pdv_p, resp, 2);
#endif

    if ((ret != waitcnt)
        || (resp[0] != pdv_p->dd_p->serial_trigger[0])
        || (resp[1] != pdv_p->dd_p->serial_response[0]))
    {
        edt_msg(DBG2, "\npdv_posttrigger_specinst: invalid/missing serial?\n");
        edt_msg(DBG2, "response (sent %c, ret %d s/b %d, resp <%s>)\n", cmd, ret, waitcnt, (ret > 0) ? resp : "");
        return;
    }
}

static int
pdv_specinst_serial_triggered(PdvDev * pdv_p)
{
    if (((pdv_p->dd_p->camera_shutter_timing == SPECINST_SERIAL)
        || (pdv_p->dd_p->camera_shutter_speed == SPECINST_SERIAL))
        && (pdv_p->dd_p->serial_trigger[0]))
        return 1;
    return 0;
}

int
pdv_pause_for_serial(PdvDev * pdv_p)
{
    return pdv_p->dd_p->pause_for_serial;
}


static int
isafloat(char *str)
{
    unsigned int i;
    int     numdots = 0;
    int     numchars = 0;

    for (i = 0; i < strlen(str); i++)
    {
        if (str[i] == '.')
            ++numdots;
        else if (isdigit(str[i]))
            ++numchars;
        else
            return 0;
    }

    if (numdots == 1 && numchars > 0)
        return 1;
    return 0;
}

static int
isdigits(char *str)
{
    unsigned int i;
    int     numchars = 0;

    for (i = 0; i < strlen(str); i++)
    {
        if (isdigit(str[i]))
            ++numchars;
        else if ((str[i] == '-') && (i == 0))
            ;
        else
            return 0;
    }

    if (numchars > 0)
        return 1;
    return 0;
}

static int
isxdigits(char *str)
{
    unsigned int i;
    int     numchars = 0;

    for (i = 0; i < strlen(str); i++)
    {
        if (isxdigit(str[i]))
            ++numchars;
        else
            return 0;
    }

    if (numchars > 0)
        return 1;
    return 0;
}

int
pdv_is_kodak_i(PdvDev * pdv_p)
{
    Dependent *dd_p = pdv_p->dd_p;

    if ((strcmp(dd_p->serial_exposure, "EXE") == 0)
        || (strcmp(dd_p->serial_gain, "DGN") == 0)
        || (strcmp(dd_p->serial_offset, "GAE") == 0)
        || (strcmp(dd_p->serial_offset, "BKE") == 0))
        return 1;
    return 0;
}


int
pdv_is_atmel(PdvDev * pdv_p)
{
    Dependent *dd_p = pdv_p->dd_p;

    if ((strncasecmp(dd_p->camera_class, "Atmel", 5) == 0)
        || (strncmp(dd_p->serial_exposure, "I=", 2) == 0))
        return 1;
    return 0;
}

int
pdv_is_hamamatsu(PdvDev * pdv_p)
{
    Dependent *dd_p = pdv_p->dd_p;

    if ((strncasecmp(dd_p->camera_class, "Hamamatsu", 9) == 0))
        return 1;
    return 0;
}


int
pdv_update_values_from_camera(PdvDev * pdv_p)
{
    int     ret = 0;

    if (pdv_is_kodak_i(pdv_p))
        ret = pdv_update_from_kodak_i(pdv_p);
    else if (pdv_is_dvc(pdv_p))
        ret = pdv_update_from_dvc(pdv_p);
    else if (pdv_is_atmel(pdv_p))
        ret = pdv_update_from_atmel(pdv_p);
    else if (pdv_is_hamamatsu(pdv_p))
        ret = pdv_update_from_hamamatsu(pdv_p);
    /* add more here */
    else
        ret = -1;

    return ret;
}

static int
pdv_update_from_kodak_i(PdvDev * pdv_p)
{
    int     i, n, ret = 0;
    char   *stat[64];
    char  **stat_p = stat;
    Dependent *dd_p = pdv_p->dd_p;

    for (i = 0; i < 64; i++)
    {
        *stat_p = (char *) malloc(64 * sizeof(char));
        **stat_p = '\0';
        ++stat_p;
    }

    if ((n = pdv_query_serial(pdv_p, "STS?", stat)) < 1)
        ret = -1;
    else
    {
        update_int_from_serial(stat, n, "BKE", &dd_p->level);
        update_int_from_serial(stat, n, "GAE", &dd_p->gain);
        update_int_from_serial(stat, n, "DGN", &dd_p->gain);
        update_int_from_serial(stat, n, "EXE", &dd_p->shutter_speed);
        update_int_from_serial(stat, n, "BNS", &dd_p->binx);
        update_int_from_serial(stat, n, "BNS", &dd_p->biny);
    }

    for (i = 0; i < 64; i++)
        free(stat[i]);

    return ret;
}

static int
pdv_update_from_hamamatsu(PdvDev * pdv_p)
{
    int     i, n, ret = 0;
    char   *stat[64];
    char  **stat_p = stat;
    Dependent *dd_p = pdv_p->dd_p;

    for (i = 0; i < 64; i++)
    {
        *stat_p = (char *) malloc(64 * sizeof(char));
        **stat_p = '\0';
        ++stat_p;
    }

    if ((n = pdv_query_serial(pdv_p, "?CEG", stat)) < 1)
        ret = -1;
    else
        update_int_from_serial(stat, n, "CEG", &dd_p->gain);

    if ((n = pdv_query_serial(pdv_p, "?CEO", stat)) < 1)
        ret = -1;
    else
        update_int_from_serial(stat, n, "CEO", &dd_p->level);

    if ((n = pdv_query_serial(pdv_p, "?SHT", stat)) < 1)
        ret = -1;
    else
        update_int_from_serial(stat, n, "SHT", &dd_p->shutter_speed);

    for (i = 0; i < 64; i++)
        free(stat[i]);

    return ret;
}


static int
pdv_update_from_atmel(PdvDev * pdv_p)
{
    int     i, n, ret = 0;
    int     tmpval;
    char   *stat[64];
    char  **stat_p = stat;
    Dependent *dd_p = pdv_p->dd_p;

    for (i = 0; i < 64; i++)
    {
        *stat_p = (char *) malloc(64 * sizeof(char));
        **stat_p = '\0';
        ++stat_p;
    }

    if ((n = pdv_query_serial(pdv_p, "!=3", stat)) < 1)
        ret = -1;
    else
    {
        update_int_from_serial(stat, n, "G", &dd_p->gain);
        update_int_from_serial(stat, n, "I", &dd_p->shutter_speed);
        if (update_int_from_serial(stat, n, "B", &tmpval) == 0)
            dd_p->binx = dd_p->biny = tmpval + 1;
    }

    for (i = 0; i < 64; i++)
        free(stat[i]);

    return ret;
}

int
pdv_query_serial(PdvDev * pdv_p, char *cmd, char **resp)
{

    char   *buf_p;
    char    buf[2048];
    int     length;
    int     ret;
    int     i, j, l;
    int     nfound = 0;

    {
        char    *tmp_storage;
        if ((tmp_storage = (char *)malloc(strlen(cmd)+1)) == NULL)
            return 0;
        sprintf(tmp_storage, "%s\r", cmd);
        edt_msg(DBG2, "pdv_query_serial: writing <%s>\n", cmd);
        pdv_serial_command(pdv_p, tmp_storage);
        free(tmp_storage);
    }
    /*
    * serial_timeout comes from the config file (or -t override flag in this
    * app), or if not present defaults to 500
    */
    pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout, 64);

    /*
    * get the return string. How its printed out depends on whether its 1)
    * ASCII, 2) HEX, or 3) Pulnix STX/ETX format
    */
    buf_p = buf;
    length = 0;
    do
    {
        ret = pdv_serial_read(pdv_p, buf_p, 2048 - length);
        edt_msg(DBG2, "read returned %d\n", ret);

        if (ret != 0)
        {
            buf_p[ret + 1] = 0;
            buf_p += ret;
            length += ret;
        }
        pdv_serial_wait(pdv_p, 500, 64);
    } while (ret > 0);

    /*
    * copy the buffer to the string list
    */
    i = 0;
    j = 0;
    buf_p = buf;
    for (l = 0; l < length; l++)
    {
        if ((*buf_p == '\n') || (*buf_p == '\r'))
        {
            if (j != 0)
            {
                resp[i++][j] = '\0';
                j = 0;
            }
        }
        else
        {
            if (j == 0)
                ++nfound;
            resp[i][j++] = *buf_p;
            resp[i][j] = '\0';
        }

        ++buf_p;
    }


    return nfound;
}

static int
update_int_from_serial(char **stat, int nstats, char *cmd, int *value)
{
    int     i, ret = -1;
    int     len = (int) strlen(cmd);
    double  tmpf;
    char   *arg;

    /*
    * expected format: "CMD NN or CMD -NN or CMD F.F or CMD=N"
    */
    for (i = 0; i < nstats; i++)
    {
        arg = &stat[i][len + 1];
        if ((strncmp(stat[i], cmd, len) == 0)
            && ((stat[i][len] == ' ') || (stat[i][len] == '=')))
        {
            if (isdigits(arg))
            {
                *value = atoi(arg);
                ret = 0;
            }
            /* special case kodak 'i' decimal EXE */
            else if ((isafloat(arg) && strncmp(cmd, "EXE", 3) == 0))
            {
                tmpf = atof(arg);
                *value = (int) (tmpf / 0.063);
                ret = 0;
            }
        }
    }
    return ret;
}

static int
update_string_from_serial(char **stat, int nstats, char *cmd, char *value, int maxlen)
{
    int     i, ret = -1;
    int     len = (int) strlen(cmd);
    char   *arg;

    /*
    * expected format: "CMD NN or CMD -NN or CMD F.F or CMD=N"
    */
    for (i = 0; i < nstats; i++)
    {
        arg = &stat[i][len + 1];
        if ((strncmp(stat[i], cmd, len) == 0)
            && ((stat[i][len] == ' ') || (stat[i][len] == '=')))
        {
            strncpy(value, stat[i] + len + 1, maxlen);
        }
    }
    return ret;
}

static void
update_2dig_from_serial(char **stat, int nstats, char *cmd, int *val1, int *val2)
{
    int     i;
    int     len = (int) strlen(cmd);
    char   *arg;

    /*
    * expected format: "CMD XY"
    */
    for (i = 0; i < nstats; i++)
    {
        arg = &stat[i][len + 1];
        if ((strncmp(stat[i], cmd, len) == 0)
            && (stat[i][len] == ' '))
        {
            if (isdigits(arg) && strlen(arg) == 2)
            {
                *val1 = arg[0] - '0';
                *val2 = arg[1] - '0';
            }
        }
    }
}

static void
update_hex_from_serial(char **stat, int nstats, char *cmd, int *value)
{
    int     i;
    size_t     len = strlen(cmd);
    char   *arg;

    /*
    * expected format: "CMD XX"
    */
    for (i = 0; i < nstats; i++)
    {
        arg = &stat[i][len + 1];
        if ((strncmp(stat[i], cmd, len) == 0)
            && (stat[i][len] == ' '))
        {
            if (isxdigits(arg))
            {
                *value = strtol(arg, NULL, 16);
            }
        }
    }
}


int 
pdv_set_mode(PdvDev * pdv_p, char *mode, int mcl)
{
    edt_msg(PDVWARN, "pdv_set_aperture is OBSOLETE\n");
    return -1;
}


int 
pdv_set_mode_atmel(PdvDev * pdv_p, char *mode)
{
    Dependent *dd_p = pdv_p->dd_p;
    int     cfg = 0;

    if ((strcmp(mode, "T=0") == 0)      /* CONTINUOUS */
        || (strcmp(mode, "T=1") == 0))
    {
        if (strcmp(mode, "T=0") == 0)
        {
            dd_p->shutter_speed_min = 0;
            dd_p->shutter_speed_max = 0;
        }
        else
        {
            dd_p->shutter_speed_min = 1;
            dd_p->shutter_speed_max = 2000;
        }
        dd_p->camera_shutter_timing = AIA_SERIAL;
        dd_p->trig_pulse = 1;   /* probably N/A but its in the cfg so
                                * whatever */
        dd_p->mode_cntl_norm = 0x0;
        edt_reg_write(pdv_p, PDV_MODE_CNTL, dd_p->mode_cntl_norm);
        cfg = edt_reg_read(pdv_p, PDV_CFG) | PDV_TRIG | PDV_INV_SHUTTER;
        edt_reg_write(pdv_p, PDV_CFG, cfg);
        pdv_serial_command(pdv_p, mode);
        strcpy(dd_p->serial_exposure, "I=");
    }
    else if (strcmp(mode, "T=2") == 0)  /* TRIGGERED */
    {
        dd_p->timeout_multiplier = 1;
        dd_p->shutter_speed_min = 1;
        dd_p->shutter_speed_max = 0x414;
        dd_p->camera_shutter_timing = AIA_SERIAL;
        dd_p->trig_pulse = 1;
        dd_p->mode_cntl_norm = 0x10;
        edt_reg_write(pdv_p, PDV_MODE_CNTL, dd_p->mode_cntl_norm);
        cfg = edt_reg_read(pdv_p, PDV_CFG) | PDV_TRIG;
        edt_reg_write(pdv_p, PDV_CFG, cfg);
        pdv_serial_command(pdv_p, mode);
        strcpy(dd_p->serial_exposure, "I=");
    }
    else if (strcmp(mode, "T=3") == 0)  /* CONTOLLED (camelia linescan only?) */
    {
        dd_p->timeout_multiplier = 1;
        dd_p->shutter_speed_min = 1;
        dd_p->shutter_speed_max = 25500;
        dd_p->camera_shutter_timing = AIA_MCL;
        dd_p->trig_pulse = 0;
        dd_p->mode_cntl_norm = 0x10;
        edt_reg_write(pdv_p, PDV_MODE_CNTL, dd_p->mode_cntl_norm);
        cfg = edt_reg_read(pdv_p, PDV_CFG) & ~PDV_TRIG;
        edt_reg_write(pdv_p, PDV_CFG, cfg);
        pdv_serial_command(pdv_p, mode);
        dd_p->serial_exposure[0] = '\0';
    }
    else                        /* UNKNOWN */
    {
        edt_msg(PDVWARN, "WARNING: unsupported ATMEL mode: %s\n", mode);
        return -1;
    }
    return 0;
}

int 
pdv_set_mode_kodak(PdvDev * pdv_p, char *mode)
{
    Dependent *dd_p = pdv_p->dd_p;
    char    cmd[32];
    int     cfg = 0;

    if (strcmp(mode, "CS") == 0)/* CONTINUOUS */
    {
        dd_p->shutter_speed_min = 1;
        dd_p->shutter_speed_max = 512;
        dd_p->camera_shutter_timing = AIA_SERIAL;
        dd_p->trig_pulse = 1;   /* probably N/A but its in the cfg so
                                * whatever */
        dd_p->mode_cntl_norm = 0x0;
        edt_reg_write(pdv_p, PDV_MODE_CNTL, dd_p->mode_cntl_norm);
        cfg = edt_reg_read(pdv_p, PDV_CFG) | PDV_TRIG | PDV_INV_SHUTTER;
        edt_reg_write(pdv_p, PDV_CFG, cfg);
        sprintf(cmd, "MDE %s", mode);
        pdv_serial_command(pdv_p, cmd);
        strcpy(dd_p->serial_exposure, "EXE");
    }
    else if (strcmp(mode, "TR") == 0)   /* TRIGGERED */
    {
        dd_p->shutter_speed_min = 1;
        dd_p->shutter_speed_max = 255;
        dd_p->camera_shutter_timing = AIA_SERIAL;
        dd_p->trig_pulse = 1;
        dd_p->mode_cntl_norm = 0x10;
        edt_reg_write(pdv_p, PDV_MODE_CNTL, dd_p->mode_cntl_norm);
        cfg = edt_reg_read(pdv_p, PDV_CFG) | PDV_TRIG;
        edt_reg_write(pdv_p, PDV_CFG, cfg);
        sprintf(cmd, "MDE %s", mode);
        pdv_serial_command(pdv_p, cmd);
        strcpy(dd_p->serial_exposure, "EXE");
    }
    else if (strcmp(mode, "CD") == 0)   /* CONTROLLED */
    {
        dd_p->shutter_speed_min = 1;
        dd_p->shutter_speed_max = 25500;
        dd_p->camera_shutter_timing = AIA_MCL;
        dd_p->trig_pulse = 0;
        dd_p->mode_cntl_norm = 0x10;
        edt_reg_write(pdv_p, PDV_MODE_CNTL, dd_p->mode_cntl_norm);
        cfg = edt_reg_read(pdv_p, PDV_CFG) & ~PDV_TRIG;
        edt_reg_write(pdv_p, PDV_CFG, cfg);
        sprintf(cmd, "MDE %s", mode);
        pdv_serial_command(pdv_p, cmd);
        dd_p->serial_exposure[0] = '\0';
    }
    else                        /* PDI, PDP...? */
    {
        edt_msg(PDVWARN, "WARNING: unsupported DVC mode: %s\n", mode);
        return -1;
    }
    return 0;
}

int 
pdv_set_mode_hamamatsu(PdvDev * pdv_p, char *mode)
{
#if 0
    Dependent *dd_p = pdv_p->dd_p;
    int     cfg = 0;
    int     cont = 0;
#endif

    /* stub */

    return 0;

}
 /* end settings */


/*************************************************************
* DVC Camera Functions
*************************************************************/

int
pdv_is_dvc(PdvDev * pdv_p)
{
    Dependent *dd_p = pdv_p->dd_p;

    if ((strncasecmp(dd_p->camera_class, "DVC", 3) == 0)
        || (strncmp(dd_p->serial_exposure, "EXP", 3) == 0))
        return 1;
    return 0;
}

int
pdv_set_binning_dvc(PdvDev * pdv_p, int xval, int yval)
{
    int     ret = 0;
    char    cmdstr[64];
    Dependent *dd_p = pdv_p->dd_p;

    sprintf(cmdstr, "%s %d%d", dd_p->serial_binning, yval, xval);

    pdv_serial_command(pdv_p, cmdstr);

    return (ret);
}

int
pdv_update_from_dvc(PdvDev * pdv_p)
{
    int     i, n, ret = 0;
    char   *stat[64];
    char  **stat_p = stat;
    Dependent *dd_p = pdv_p->dd_p;

    for (i = 0; i < 64; i++)
    {
        *stat_p = (char *) malloc(64 * sizeof(char));
        **stat_p = '\0';
        ++stat_p;
    }

    if ((n = pdv_query_serial(pdv_p, "STA", stat)) < 1)
        ret = -1;
    else
    {
        update_hex_from_serial(stat, n, "OFS", &dd_p->level);
        update_hex_from_serial(stat, n, "GAI", &dd_p->gain);
        update_hex_from_serial(stat, n, "EXP", &dd_p->shutter_speed);
        update_2dig_from_serial(stat, n, "BIN", &dd_p->binx, &dd_p->biny);
    }

    for (i = 0; i < 64; i++)
        free(stat[i]);

    return ret;
}


int 
pdv_set_mode_dvc(PdvDev * pdv_p, char *mode)
{
    Dependent *dd_p = pdv_p->dd_p;
    char    cmd[32];
    int     cfg = 0;

    if ((strcmp(mode, "NOR") == 0)      /* CONTINUOUS */
        || (strcmp(mode, "ULT") == 0)
        || (strcmp(mode, "HNL") == 0)
        || (strcmp(mode, "HDL") == 0)
        || (strcmp(mode, "NFR") == 0)
        || (strcmp(mode, "NRR") == 0))
    {
        if (mode[0] == 'H')     /* one of the high-speed modes */
        {
            dd_p->shutter_speed_min = 1;
            dd_p->shutter_speed_max = 0x414;
        }
        else
        {
            if (strcmp(mode, "ULT") == 0)       /* ultra long term */
                dd_p->timeout_multiplier = 10;
            else if (strcmp(mode, "NFR") == 0)  /* frame time (87 msec) */
                dd_p->timeout_multiplier = 5;
            else
                dd_p->timeout_multiplier = 1;

            dd_p->shutter_speed_min = 1;
            dd_p->shutter_speed_max = 0x7ff;
        }
        dd_p->camera_shutter_timing = AIA_SERIAL;
        dd_p->trig_pulse = 1;   /* probably N/A but its in the cfg so
                                * whatever */
        dd_p->mode_cntl_norm = 0x0;
        edt_reg_write(pdv_p, PDV_MODE_CNTL, dd_p->mode_cntl_norm);
        cfg = edt_reg_read(pdv_p, PDV_CFG) | PDV_TRIG | PDV_INV_SHUTTER;
        edt_reg_write(pdv_p, PDV_CFG, cfg);
        sprintf(cmd, "MDE %s", mode);
        pdv_serial_command(pdv_p, cmd);
        strcpy(dd_p->serial_exposure, "EXP");
    }
    else if (strcmp(mode, "HDO") == 0)  /* TRIGGERED */
    {
        dd_p->timeout_multiplier = 1;
        dd_p->shutter_speed_min = 1;
        dd_p->shutter_speed_max = 0x414;
        dd_p->camera_shutter_timing = AIA_SERIAL;
        dd_p->trig_pulse = 1;
        dd_p->mode_cntl_norm = 0x10;
        edt_reg_write(pdv_p, PDV_MODE_CNTL, dd_p->mode_cntl_norm);
        cfg = edt_reg_read(pdv_p, PDV_CFG) | PDV_TRIG;
        edt_reg_write(pdv_p, PDV_CFG, cfg);
        sprintf(cmd, "MDE %s", mode);
        pdv_serial_command(pdv_p, cmd);
        strcpy(dd_p->serial_exposure, "EXP");
    }
    else if (strcmp(mode, "PDX") == 0)  /* CONTROLLED */
    {
        dd_p->timeout_multiplier = 1;
        dd_p->shutter_speed_min = 1;
        dd_p->shutter_speed_max = 25500;
        dd_p->camera_shutter_timing = AIA_MCL;
        dd_p->trig_pulse = 0;
        dd_p->mode_cntl_norm = 0x10;
        edt_reg_write(pdv_p, PDV_MODE_CNTL, dd_p->mode_cntl_norm);
        cfg = edt_reg_read(pdv_p, PDV_CFG) & ~PDV_TRIG;
        edt_reg_write(pdv_p, PDV_CFG, cfg);
        sprintf(cmd, "MDE %s", mode);
        pdv_serial_command(pdv_p, cmd);
        dd_p->serial_exposure[0] = '\0';
    }
    else                        /* PDI, PDP...? */
    {
        edt_msg(PDVWARN, "WARNING: unsupported DVC mode: %s\n", mode);
        return -1;
    }
    return 0;
}

int
pdv_get_dvc_state(PdvDev * pdv_p, DVCState * pState)

{
    int     i, n, ret = 0;
    char   *stat[64];
    char  **stat_p = stat;
    Dependent *dd_p = pdv_p->dd_p;

    for (i = 0; i < 64; i++)
    {
        *stat_p = (char *) malloc(64 * sizeof(char));
        **stat_p = '\0';
        ++stat_p;
    }

    if ((n = pdv_query_serial(pdv_p, "STA", stat)) < 1)
        ret = -1;
    else
    {
        update_hex_from_serial(stat, n, "OFS", &dd_p->level);
        update_hex_from_serial(stat, n, "GAI", &dd_p->gain);
        update_hex_from_serial(stat, n, "EXP", &dd_p->shutter_speed);
        update_2dig_from_serial(stat, n, "BIN", &dd_p->binx, &dd_p->biny);
    }

    pState->binx = dd_p->binx;
    pState->biny = dd_p->biny;
    pState->blackoffset = dd_p->level;
    pState->exposure = dd_p->shutter_speed;
    pState->gain = dd_p->gain;

    update_string_from_serial(stat, n, "MDE", pState->mode, 3);

    for (i = 0; i < 64; i++)
        free(stat[i]);

    return ret;


}


void
pdv_enable_external_trigger(PdvDev * pdv_p, int flag)
{
    int     mask = PDV_PHOTO_TRIGGER | PDV_FLDID_TRIGGER;
    int     util2 = edt_reg_read(pdv_p, PDV_UTIL2);
    int     bit = 0;

    if (flag & 1)
        bit &= PDV_PHOTO_TRIGGER;
    if (flag & 2)
        bit &= PDV_FLDID_TRIGGER;

    if (flag)
        edt_reg_write(pdv_p, PDV_UTIL2, util2 | flag);
    else
        edt_reg_write(pdv_p, PDV_UTIL2, util2 & ~mask);
}



void 
pdv_start_expose(PdvDev * pdv_p)

{
    edt_reg_write(pdv_p, PDV_CMD, PDV_EXP_STROBE);
}


void 
pdv_invert_fval_interrupt(PdvDev * pdv_p)

{

    edt_reg_or(pdv_p, PDV_UTIL3, PDV_FV_INT_INVERT);
}

int
pdv_set_frame_period(PdvDev *pdv_p, int period, int method)
{
    u_int util3 = edt_reg_read(pdv_p, PDV_UTIL3);

    if (pdv_p->dd_p->register_wrap)
        return -1;

    edt_reg_write(pdv_p, PDV_FRAME_PERIOD0, period & 0xff);
    edt_reg_write(pdv_p, PDV_FRAME_PERIOD1, (period >> 8) & 0xff);
    edt_reg_write(pdv_p, PDV_FRAME_PERIOD2, (period >> 16) & 0xff);

    if (method == 0)
        edt_reg_write(pdv_p, PDV_UTIL3, util3 & ~(PDV_FRENA | PDV_FVADJ));
    else if (method == PDV_FMRATE_ENABLE)
        edt_reg_write(pdv_p, PDV_UTIL3, (util3 | PDV_FRENA) & ~PDV_FVADJ);
    else if (method == PDV_FVAL_ADJUST)
        edt_reg_write(pdv_p, PDV_UTIL3, (util3 | PDV_FVADJ) & ~PDV_FRENA);

    return 0;
}

int
pdv_get_frame_period(PdvDev *pdv_p)
{
    int period;

    period = edt_reg_read(pdv_p, PDV_FRAME_PERIOD0);
    period |= (edt_reg_read(pdv_p, PDV_FRAME_PERIOD1) & 0xff) << 8;
    period |= (edt_reg_read(pdv_p, PDV_FRAME_PERIOD2) & 0xff) << 16;

    return period;
}

void
pdv_serial_txrx(PdvDev * pdv_p, char *txbuf, int txcount, char *rxbuf, int rxcount, int timeout, u_char *wchar)
{
    int     n, ena;
    u_char  savec;
    int     respflag = 0; /* default to response */
    char    dmybuf[1024];

    if (rxcount == 0)
        respflag = SCFLAG_NORESP;

    ena = pdv_get_waitchar(pdv_p, &savec);

    /*
    * flush any pending junk
    */
    if ((n = pdv_serial_wait(pdv_p, 1, 1024)) != 0)
        pdv_serial_read(pdv_p, dmybuf, n);

    if (*wchar) 
        pdv_set_waitchar(pdv_p, 1, *wchar);

    pdv_serial_binary_command_flagged(pdv_p, txbuf, txcount, respflag);

    if ((n = pdv_serial_wait(pdv_p, timeout, rxcount)) != 0)
        pdv_serial_read(pdv_p, rxbuf, n);

    /* set waitchar back to what it was */
    pdv_set_waitchar(pdv_p, ena, savec);
}


int
pdv_is_cameralink(PdvDev *pdv_p)
{
    if (edt_is_dvcl(pdv_p))
        return 1;

    /* Other camera link boards have the a PCI xilinx
    * ID that edt_is_dvcl() recognizes, but FOX doesn't.
    * The FOX units can be either camera link or not 
    * (depending on what they're hooked up to). So
    * when initcam sees camera link directives in the camera
    * .cfg file, it will set the pdv->dd_p->cameralink flag 
    * so we know this is connected to camera link:
    */
    if (pdv_p->dd_p->cameralink)
        return 1;

    return 0;
}

int
pdv_is_simulator(PdvDev *pdv_p)
{
    char xilinx_name[256];

    edt_flash_get_fname_auto(pdv_p, xilinx_name);

    /* CL2 (CLS) */
    if (edt_is_dvcl2(pdv_p))
        return 1;

    /* Legacy: old PCIe4 used the same ID whether it was loaded with sim FPGA or
    * not, so we check the xilinx name." Not any more, and  but nevertheless
    * keep this and the ID thing will win out if that's what we use.
    */
    if (pdv_p->devid == PE4DVCL_ID)
    {
        if ((strncmp(xilinx_name, "pedvclsim", 9) == 0)
            || (strncmp(xilinx_name, "pe4dvcls", 8) == 0)) /* never called it that but who knows... */
            return 1;
    }

    return 0;
}


void
pdv_set_fval_done(PdvDev *pdv_p, int enable)

{
    u_int i = (enable != 0);

    edt_ioctl(pdv_p, EDTS_FVAL_DONE, &i);

    if (enable != PDV_TRIGINT)
    {
        edt_reg_and(pdv_p, PDV_UTIL3, ~PDV_TRIGINT);
    }

    pdv_p->dd_p->fval_done = enable;
    edt_set_dependent(pdv_p, pdv_p->dd_p);

}

int
pdv_get_fval_done(PdvDev *pdv_p)

{
    return pdv_p->dd_p->fval_done;

}


int
pdv_get_lines_xferred(PdvDev *pdv_p)

{
    u_int rasterlines = 0;

    if (pdv_p->ring_buffer_numbufs)
        rasterlines  = (pdv_p->donecount-1) % pdv_p->ring_buffer_numbufs;

    edt_ioctl(pdv_p, EDTG_LINES_XFERRED, &rasterlines);

    return (rasterlines & 0xffff);

}

int
pdv_get_width_xferred(PdvDev *pdv_p)

{
    u_int rasterlines = (pdv_p->donecount-1) % pdv_p->ring_buffer_numbufs;

    edt_ioctl(pdv_p, EDTG_LINES_XFERRED, &rasterlines);

    return ((rasterlines >> 16) & 0xffff);

}

int
pdv_cl_get_fv_counter(PdvDev *pdv_p)

{
    return edt_reg_read(pdv_p, PDV_CL_FRMCNT);
}


void
pdv_cl_reset_fv_counter(PdvDev *pdv_p)

{
    edt_reg_write(pdv_p, PDV_CL_FRMCNT_RESET, 1);
    edt_reg_write(pdv_p, PDV_CL_FRMCNT_RESET, 0);
}

int
pdv_cl_camera_connected(PdvDev *pdv_p)

{
    int i, reg, ppl=0, changed=0;

    if (!pdv_is_cameralink(pdv_p))
        return 0;

    reg = edt_reg_read(pdv_p, PDV_UTILITY);
    /* WAS: edt_reg_or(pdv_p, PDV_UTILITY, PDVCL_PCLVFREE); */
    /* but that bit was overloaded as of some iteration of PCIe8 rev08, so as of rev09.... */
    edt_reg_or(pdv_p, PDV_CL_CFG2, PDV_CL_CFG2_PCLVFREE);
    for (i=0; i<5; i++)
    {
        int p;

        if ((p = edt_reg_read(pdv_p, PDV_CL_PIXELSPERLINE)) != ppl)
            ++changed;
        ppl = p;
        edt_msleep(1);
    }

    edt_reg_write(pdv_p, PDV_UTILITY, reg); /* restore */

    if (changed < 2)
        return 0;
    return 1;
}

void
pdv_new_debug(int val)
{
    int level ;
    Pdv_debug = val ;
    level = edt_msg_default_level();
    if (Pdv_debug > 0)
    {
        level |= DBG1;
        level |= DBG2;
    }
    edt_msg_set_level(edt_msg_default_handle(), level);
}

#ifdef DOXYGEN_SHOW_UNDOC
/* @} */ /* end weak dv group */
#endif


int
pdv_get_rawio_size(PdvDev *pdv_p)

{
    int size = pdv_get_dmasize(pdv_p);

    if (size % 512)
        size = (((size/512)+1)*512);

    return size;

}

/*
 * for #pdv_initcam and pdv_cls_set_dep only
 */
void
checkfpga_dep_wait(pdv_p)
{
}

void
pdv_check_fpga_rev(PdvDev *pdv_p)
{
    PdvDependent *dd_p = pdv_p->dd_p;

    if (dd_p->xilinx_rev == NOT_SET)
    {
        int     rev;

        edt_msg(DEBUG2, "checking for new rev xilinx\n");
        checkfpga_dep_wait(pdv_p);

        pdv_flush_fifo(pdv_p); /* ADDED  3/14/2012 RWH */

        edt_reg_write(pdv_p, PDV_STAT, 0xff);
        rev = edt_reg_read(pdv_p, PDV_REV);
        if (rev >= 1 && rev <= 32)
        {
            edt_msg(DEBUG2, "xilinx rev set to %d (0x%x)\n", rev, rev);
            dd_p->xilinx_rev = rev;
        }
        else
        {
            dd_p->xilinx_rev = 0;
            edt_msg(DEBUG2, "no xilinx rev from IOCTL, setting to 0\n");
        }

#ifdef NOT_DONE
        /* xilinx rev 2 we got option flag register */
        if ((dd_p->xilinx_rev >= 2) && (dd_p->xilinx_rev != 0xff))
            dd_p->xilinx_opt = edt_reg_read(pdv_p, PDV_XILINX_OPT);
#endif
        dd_p->register_wrap = check_register_wrap(pdv_p);
    }
}


/*
* this code checks for register wrap. Since newer xilinxs have larger
* register space, there's a possibility that we can read/write registers
* but they're actually wrapping by 32. So read/write the low register
* and check if it wraps to high. Uses MASK register and writes back
* when done
*
* RETURNS 1 if wrap, 0 if not
*/
int
check_register_wrap(EdtDev *pdv_p)
{
    int wrapped = 0;
    int r;
    int mask_lo, mask_lo_wrap;

    /* definately not in and OLD xilinx.... */
    if (pdv_p->dd_p->xilinx_rev < 2 || pdv_p->dd_p->xilinx_rev > 32)
        return 1;

    /* made it this far; check for wrap */
    mask_lo = edt_reg_read(pdv_p, PDV_MASK_LO);
    mask_lo_wrap = edt_reg_read(pdv_p, PDV_MASK_LO+32) ;
    edt_reg_write(pdv_p, PDV_MASK_LO+32, 0);
    edt_reg_write(pdv_p, PDV_MASK_LO, 0xa5);
    if ((r = edt_reg_read(pdv_p, PDV_MASK_LO+32)) == 0xa5)
        wrapped = 1;

    /* restore the register */
    edt_reg_write(pdv_p, PDV_MASK_LO, mask_lo);
    if (!wrapped)
        edt_reg_write(pdv_p, PDV_MASK_LO, mask_lo_wrap);

    edt_msg(DEBUG2, "registers %s\n", wrapped? "WRAPPING":"not wrapping");
    return wrapped;
}

---