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>

#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)

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_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);
static int pdv_set_mode_atmel(PdvDev * pdv_p, char *mode);
static int pdv_set_mode_hamamatsu(PdvDev * pdv_p, char *mode);

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  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(char *dev_name, int unit, int channel)
{
    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_channel(tmpname, unit, channel)) == NULL)
        return NULL;


    if (pdv_p->devid == PDVFOI_ID)
    {
#ifdef _FOI_SUPPORTED
        edt_check_foi(pdv_p);
#else
        edt_msg(PDVFATAL, "pdv_open_channel: FOI not supported after v4.1.5.9\n"); 
        return NULL;
#endif
    }
    else 
    {
        pdv_p->foi_unit = channel;
    }

    /*
     * alloc and get the PCI DV 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;
    }

    if (pdv_p->devid == PDVFOI_ID)
    {
        pdv_p->foi_unit = edt_get_foiunit(pdv_p);
    }

    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;
    }

    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
                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;
}

pdv_get_dmasize(PdvDev * pdv_p)

{

    Dependent *dd_p = PDV_DEPENDENT(pdv_p);

    int     size;


    if (dd_p->swinterlace == PDV_INV_RT_INTLV_24_12)
                size = dd_p->width * dd_p->height * 3 / 2;
        else if (dd_p->depth > dd_p->extdepth) /* 24 bit bayer filter  or 1 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;
}

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

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

    dd_p->width = width;
    dd_p->height = height;

    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;

    int     width = dd_p->width;
    int     height = dd_p->height;


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

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

    if (pdv_p->dd_p->header_size && 
                (pdv_p->dd_p->header_position != PDV_HEADER_WITHIN))
                total += 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;

        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;

        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(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 |= 0x10;
            dd_p->dual_channel = reg;
            edt_reg_write(pdv_p, PDV_CL_DATA_PATH, dd_p->cl_data_path);
        }
    }

    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];
}

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

    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
        {
            if (dd_p->serial_format == SERIAL_ASCII_HEX)
                sprintf(cmdstr, "%s %02x", dd_p->serial_exposure, value);

            else if (dd_p->serial_format == SERIAL_PULNIX_1010)
                sprintf(cmdstr, "%s%d", dd_p->serial_exposure, value);

            else if (dd_p->serial_exposure[0] == ':')   /* pulnix 1300 fmt */
            {
                /*
                 * sprintf(cmdstr, "%s%c", dd_p->serial_exposure, '0' +
                 * value);
                 */
                sprintf(cmdstr, "%s%x", dd_p->serial_exposure, value);
                dd_p->serial_respcnt = 3;
            }
            else if (dd_p->serial_exposure[1] == '=')   /* thomson camelia fmt */
            {
                sprintf(cmdstr, "%s%d", dd_p->serial_exposure, value);
            }
            else                /* kodak format */
            {
                sprintf(cmdstr, "%s %d", dd_p->serial_exposure, value);
            }
        }

        ret = pdv_serial_command_flagged(pdv_p, cmdstr, SCFLAG_NORESP);
        if (pdv_p->devid == PDVFOI_ID)
            n = pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout, 0);
        else
            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 == 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;
}

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;
}

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

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

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

    return 0;
}

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

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

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

    return 0;
}

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

    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)
{
    Dependent *dd_p = pdv_p->dd_p;
    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)
{
    Dependent *dd_p = pdv_p->dd_p;
    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)
{
    Dependent *dd_p = pdv_p->dd_p;
    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)
{
    Dependent *dd_p = pdv_p->dd_p;
    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)
{
    Dependent *dd_p = pdv_p->dd_p;
    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)
{
    Dependent *dd_p = pdv_p->dd_p;
    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)
{
    Dependent *dd_p = pdv_p->dd_p;
    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)
{
    Dependent *dd_p = pdv_p->dd_p;
        
    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)
{
    Dependent *dd_p = pdv_p->dd_p;
        
    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;
    char    cmdstr[64];
    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 ((strlen(dd_p->serial_gain) > 0)
             && ((dd_p->serial_format == SERIAL_ASCII)
                 || (dd_p->serial_format == SERIAL_ASCII_HEX)))
    {
        if (dd_p->serial_gain[0] == ':')        /* pulnix 1300 format */
        {
            sprintf(cmdstr, "%s%x", dd_p->serial_gain, value);
            dd_p->serial_respcnt = 3;
        }
        if (dd_p->serial_gain[1] == '=')        /* thomson camelia format */
        {
            sprintf(cmdstr, "%s%x", dd_p->serial_gain, value);
        }
        else if (dd_p->serial_format == SERIAL_ASCII_HEX)
        {
            sprintf(cmdstr, "%s %02x", dd_p->serial_gain, value);
        }
        else                    /* kodak/other format */
            sprintf(cmdstr, "%s %d", dd_p->serial_gain, value);
        ret = pdv_serial_command_flagged(pdv_p, cmdstr, SCFLAG_NORESP);
        /*
         * pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout,
         * pdv_p->dd_p->serial_respcnt);
         */
        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->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);
}

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 ((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 ((strlen(dd_p->serial_offset) > 0)
             && ((dd_p->serial_format == SERIAL_ASCII)
                 || (dd_p->serial_format == SERIAL_ASCII_HEX)))
    {
        char    cmdstr[128];

        if (dd_p->serial_format == SERIAL_ASCII_HEX)
            sprintf(cmdstr, "%s %02x", dd_p->serial_offset, value);
        else
            sprintf(cmdstr, "%s %d", dd_p->serial_offset, value);
        ret = pdv_serial_command_flagged(pdv_p, cmdstr, SCFLAG_NORESP);
        pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout, pdv_p->dd_p->serial_respcnt);
        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);
}

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);
}

int
pdv_set_binning_generic(PdvDev * pdv_p, int value)
{
    int     ret = 0;
    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);
}

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;
    int     ret;

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

    if (pdv_p->devid == PDVFOI_ID)
    {
        char    buf[64];

        pdv_serial_wait(pdv_p, pdv_p->dd_p->serial_timeout, pdv_p->dd_p->serial_respcnt);
        if (*pdv_p->dd_p->serial_response)
            ret = pdv_serial_read(pdv_p, buf, 63);
    }

    /* 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;
}

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_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);
}


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;
    int     total = 0;
    Dependent *dd_p;

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

    dd_p = pdv_p->dd_p;

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

    if (pdv_p->devid == PDVFOI_ID)
    {
        char    tmpbuf[256];

        bytesReturned = edt_get_msg(pdv_p, tmpbuf, 256);
        if (bytesReturned <= PKT_OVERHEAD)
            return (0);
        if (Pdv_debug)
        {
            int     i, num = bytesReturned;

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

#if 0
    if (!pdv_get_width(pdv_p))
    {
        edt_msg(DBG2, "warning - serial_read called with uninitialized camera\n");
        return (0);
    }
#endif

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

    if (nullterm)
        buf[bytesReturned] = 0;

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

        if (num > 16)           /* limit number of bytes printed to 16 */
            num = 16;
        edt_msg(DBG2, "pdv_serial_read(<");
        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);
    }
    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, char *buf, int size)
{
    int i, ret = 0;
    int pause = ed->dd_p->pause_for_serial;
    char bbuf[32];

    /* 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, 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;

    if (pdv_p->devid == PDVFOI_ID)
    {
        ret = pdv_send_msg(pdv_p, pdv_p->foi_unit, buf, size);
        return (ret);
    }
    else
    {
        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 = 512;

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

int
pdv_get_serial_block_size()
{
    return pdv_serial_block_size;
}

int
pdv_serial_read_enable(PdvDev *pdv_p)

{

    edt_reg_or(pdv_p, PDV_SERIAL_DATA_CNTL,
            PDV_EN_TX | PDV_EN_RX |
            PDV_EN_RX_INT | PDV_EN_DEV_INT);

    edt_reg_or(pdv_p, EDT_DMA_INTCFG, EDT_RMT_EN_INTR | EDT_PCI_EN_INTR) ; 

    return 0;
}

int
pdv_serial_write(PdvDev *pdv_p, 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;

    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
        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
                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 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 */

    if (avail > size)
    {
                sleepval = (size * 1000) / sleepval;

                pdv_serial_wait(pdv_p, sleepval, size);

                return pdv_serial_read(pdv_p, buf, size);
    }
    else
    {

                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
                                printf("Reading %d chars total = %d\n", avail, offset + avail);
#endif
                                ret = pdv_serial_read(pdv_p, buf+offset, avail);
                                offset += avail;

                        }


                }

    }

    return 0;

}


int
pdv_serial_command(PdvDev * pdv_p, 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, char *cmd, u_int flag)
{
    char    *buf;
    int     ret;
    int     i;
    size_t     len=0;
    int     bufsize=8; /* arbitrary but should handle whatever extra is tacked on below */
    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 */

    /* prepend "c" for FOI */
    if (pdv_p->devid == PDVFOI_ID)
    {
        buf[len++] = 'c';

        /* 't' says don't wait for response */
        if (flag & SCFLAG_NORESP)
            buf[len++] = 't';
        buf[len++] = ' ';
    }

    /* new:  serial_prefix -- prepend if nonzero */
    if (*pdv_p->dd_p->serial_prefix)
    {
        strcpy(&(buf[len]), pdv_p->dd_p->serial_prefix);
        len += 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 += 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 == 0x02)
        {
            sprintf(pp, "<0x2>");
            pp += 5;
            len += 5;
            ++p;
        }
        else if (*p == 0x03)
        {
            sprintf(pp, "<0x3>");
            pp += 5;
            len += 5;
            ++p;
        }

        else if (*p == '\r')
        {
            sprintf(pp, "\\r");
            pp += 2;
            len += 2;
            ++p;
        }
        else if (*p == '\n')
        {
            sprintf(pp, "\\n");
            pp += 2;
            len += 2;
            ++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, 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, 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;

    /* prepend "c" for FOI */
    if (pdv_p->devid == PDVFOI_ID)
    {
        buf[tmplen++] = 'c';
        if (flag & SCFLAG_NORESP)
            buf[tmplen++] = 't';
        buf[tmplen++] = ' ';
    }

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

int
pdv_read(PdvDev * pdv_p, unsigned char *buf, unsigned long size)
{
    Dependent *dd_p;
    unsigned long newsize;
    int     readsize;
    int     dosi = 0;
    unsigned char *tbuf;


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

    pdv_setup_dma(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);

                readsize = pdv_get_dmasize(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->header_size && dd_p->header_dma)
    {
        readsize += dd_p->header_size;
    }

    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);

  

    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);
}


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)

{
        if (!pdv_process_inplace(pdv_p))
        {
                return  buf + pdv_get_dmasize(pdv_p);
        }
        else
                return buf;
}


unsigned char *
pdv_wait_images_raw(PdvDev * pdv_p, int count)
{
    u_char *buf;
    Dependent *dd_p;
    static int last_timeout = 0;

    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;

    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_image = buf;
                dd_p->last_raw = 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);
    }


    last_timeout = edt_timeouts(pdv_p);
    buf = edt_wait_for_buffers(pdv_p, count);

        return buf;

 
}


u_char *
pdv_wait_images(PdvDev *pdv_p, int count)

{
   u_char *buf;
    u_char *retval;
    Dependent *dd_p;

    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;

    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))
                {
                        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++ ;
        }


    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);
}


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

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

int
pdv_get_header_offset(PdvDev * pdv_p)
{
    switch (pdv_p->dd_p->header_position)
    {
        case PDV_HEADER_BEFORE:
        pdv_p->dd_p->header_offset = 0;
        break;
    case PDV_HEADER_AFTER:
        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_extra_headersize(PdvDev * pdv_p)

{
    if (pdv_p->dd_p->header_size && (!pdv_p->dd_p->header_dma) &&
        (pdv_p->dd_p->header_position != PDV_HEADER_WITHIN))
        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, int 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;
}
 /* end settings */

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

    return pdv_p->dd_p->camera_shutter_timing;
}

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);

}

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;

    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) %d\n", msecs, count, ret);
    return (ret);
}

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

    if (pdv_p->devid == PDVFOI_ID)
    {
        if (newcount)
            newcount += 2;
        ret = pdv_serial_wait(pdv_p, msecs, newcount);
        if (ret >= 2)
            ret -= 2;
    }
    else
        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;

    int     header_before = (pdv_p->dd_p->header_position == PDV_HEADER_BEFORE);


    extrasize = slop + pdv_extra_headersize(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,extrasize) * numbufs;

        return size;
        
}

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

{
    int size;

    int extrasize;

    int ret;
    int     header_before = (pdv_p->dd_p->header_position == PDV_HEADER_BEFORE);

    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, 
                                          extrasize, 
                                          header_before,
                                          block) ;


    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;

    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");

    if (pdv_p->devid == PDVFOI_ID)
    {
        char    tmpbuf[10];
        int     ret;

        ret = pdv_serial_wait(pdv_p, 100, 0);
        if (ret > 10)
            pdv_reset_serial(pdv_p);
        else
            pdv_serial_read(pdv_p, tmpbuf, ret);

    }
    /* clear first - let driver set */
    if (pdv_p->devid == PDVFOI_ID)
    {
        char    tmpbuf[10];
        int     ret;

        ret = pdv_serial_wait(pdv_p, 100, 0);
        if (ret > 10)
            pdv_reset_serial(pdv_p);
        else
            pdv_serial_read(pdv_p, tmpbuf, ret);

   }
    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;

    if (pdv_p->devid == PDVFOI_ID)
    {
        edt_reg_write(pdv_p,FOI_WR_MSG_STAT, FOI_FIFO_FLUSH);
    }

}

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;
}

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 (dd_p->xilinx_rev < 2 || dd_p->xilinx_rev > 32)
    {
        edt_msg(DBG2, "pdv_set_baud() warning: can't enable, N/A this xilinx (%x)\n",
                pdv_p->dd_p->xilinx_rev);
        return -1;
    }

    if (edt_is_dvcl(pdv_p) || edt_is_dvfox(pdv_p) || (id == PDVA_ID))
        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) (baudreg %x) readback ERROR\n", baud, baudreg);
                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);
    }

    return ret;
}

int
pdv_get_baud(PdvDev * pdv_p)
{
    u_int   baudbits;
    int     ret = 0;

    if (pdv_p->dd_p->xilinx_rev < 2 || pdv_p->dd_p->xilinx_rev > 32)
    {
        edt_msg(DBG2, "pdv_set_baud() WARNING: can't enable, N/A this xilinx (%x)\n",
                pdv_p->dd_p->xilinx_rev);
        return -1;
    }

    baudbits = edt_reg_read(pdv_p, PDV_SERIAL_DATA_CNTL) & PDV_BAUD_MASK;

    switch (baudbits)
    {
    case 0:
        return 9600;

    case PDV_BAUD0:
        return 19200;

    case PDV_BAUD1:
        return 38400;

    case PDV_BAUD0 | PDV_BAUD1:
        return 115200;

    default:
        edt_msg(DBG2, "ERROR: pdv_get_baud(%d) -- invalid bits???\n", baudbits);
        return 0;
    }
}

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(int sx, int sy, u_short * buf, u_char * addr, int stride)
{
/*
 * colors
 */
#define FG      200
#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_ras(u_char * addr, int n, int width, int height, int x, int y)
{
#define GAP     16
    set_square(x, y, digits[n / 1000000], addr, width);
    n %= 1000000;
    set_square(x + GAP, y, digits[n / 100000], addr, width);
    n %= 100000;
    set_square(x + (GAP * 2), y, digits[n / 10000], addr, width);
    n %= 10000;
    set_square(x + (GAP * 3), y, digits[n / 1000], addr, width);
    n %= 1000;
    set_square(x + (GAP * 4), y, digits[n / 100], addr, width);
    n %= 100;
    set_square(x + (GAP * 5), y, digits[n / 10], addr, width);
    n %= 10;
    set_square(x + (GAP * 6), y, digits[n], addr, width);
}

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, char *str, int length)
{
    char    buf[2];
    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)
{
    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);

    /*
     * ALERT: check for ROI xilinx capabilities here -- 4005 doesn't do ROI
     */
    if (dd_p->xilinx_rev < 2 || dd_p->xilinx_rev > 32)
    {
        edt_msg(DBG2, "pdv_set_roi(): WARNING: can't enable, N/A this xilinx (%x)\n",
                dd_p->xilinx_rev);
        return -1;
    }

    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 if dual chan, and regs set to value/2  */
    if (pdv_is_cameralink(pdv_p))
    {
        /* negative htaps is used for 24-bit (ex) coming in
           as a single 8-bit stream */

        if (dd_p->htaps > 0)
        {
            hactv = (hactv / dd_p->htaps) * dd_p->htaps;
            hskip = (hskip / dd_p->htaps) * dd_p->htaps;
        }
        vactv = (vactv / dd_p->vtaps) * dd_p->vtaps;
        vskip = (vskip / dd_p->vtaps) * dd_p->vtaps;

        
        if (dd_p->htaps > 0)
        {
            
            edt_reg_write(pdv_p, PDV_HSKIP, (hskip / dd_p->htaps));
            edt_reg_write(pdv_p, PDV_HACTV, (hactv / dd_p->htaps) - 1);
        }
        else
        {
            edt_reg_write(pdv_p, PDV_HSKIP, (hskip * -dd_p->htaps));
            edt_reg_write(pdv_p, PDV_HACTV, (hactv * -dd_p->htaps) - 1);
        }

        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 (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 = (htaps > vtaps)? htaps : vtaps;

    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);

    /*
     * ALERT: check for ROI xilinx capabilities here -- 4005 doesn't do ROI
     */
    if (dd_p->xilinx_rev < 2 || dd_p->xilinx_rev > 32)
    {
        edt_msg(DBG2, "pdv_dalsa_ls_set_expose(): WARNING: can't enable, N/A this xilinx (%x)\n", dd_p->xilinx_rev);
        return -1;
    }

    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, ~0x08); /* !! bit should have a label */
            pdv_setsize(pdv_p, dd_p->hactv, dd_p->vactv);
        }
        else /* disable */
        {
            edt_reg_or(pdv_p, PDV_CL_CFG, 0x08);
            pdv_setsize(pdv_p, dd_p->cam_width, dd_p->cam_height);
        }

        dd_p->roi_enabled = flag;

        return 0;
    }

    if (dd_p->xilinx_rev < 2 || dd_p->xilinx_rev > 32)
    {
        edt_msg(DBG2, "pdv_enable_roi(): can't enable, N/A this xilinx (%x)\n", dd_p->xilinx_rev);
        return -1;
    }

    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_access(char *fname, int perm)
{
    return edt_access(fname, perm);
}


int
pdv_strobe(PdvDev * pdv_p, int count, int delay)
{
    Dependent *dd_p = pdv_p->dd_p;

    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)
{
    Dependent *dd_p = pdv_p->dd_p;

    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 (pdv_p->devid == PDVFOI_ID)
        return -1;

    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;

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

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

        if (pdv_p->devid == PDVFOI_ID)
            return 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 */
        if (pdv_p->devid != PDVFOI_ID)
        {
            int     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;
}


pdv_set_strobe_dac(PdvDev * pdv_p, u_int value)
{
    int     i;
    int     reg;
    int     method;
    u_int   mcl, mask;
    u_char  data;
    Dependent *dd_p = pdv_p->dd_p;

    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_flush_fifo(pdv_p);
        return;
    }

    if (pdv_p->devid == PDVCL_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 ;
        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_intfc_write(pdv_p, PDV_CMD, PDV_RESET_INTFC);
        edt_intfc_write(pdv_p, PDV_CFG, cfg);
    }
    else if  (pdv_p->devid == PDVFOI_ID)
    {
        char tmpbuf[10];
        int ret;

        ret = pdv_serial_wait(pdv_p, 100, 0);
        if (ret > 10)
            pdv_reset_serial(pdv_p);
        else
            pdv_serial_read(pdv_p, tmpbuf, ret);
    }
    else
    {
    /* DV-FOX, PCIe C-Link */

        u_int cfg ;
        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;

    if (pdv_p->devid == PDVFOI_ID)
    {
        char    tmpbuf[10];
        int     ret;

        ret = pdv_serial_wait(pdv_p, 100, 0);
        if (ret > 10)
            pdv_reset_serial(pdv_p);
        else
            pdv_serial_read(pdv_p, tmpbuf, ret);
    }
}

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;
}

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(PDVWARN, "\npdv_posttrigger_specinst: invalid or missing serial\n");
        edt_msg(PDVWARN, "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;
}


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;
}

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;
}

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)
        || (strncmp(dd_p->serial_exposure, "SHT", 3) == 0)
        || (strncmp(dd_p->serial_exposure, "FBL", 3) == 0)
        || (strncmp(dd_p->serial_exposure, "AET", 3) == 0))
        return 1;
    return 0;
}



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;
}

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;
}

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;
}


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];
    char    *tmp_storage;
    int     length;
    int     ret;
    int     i, j, l;
    int     nfound = 0;

    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);

    /*
     * 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;
        }
        if (pdv_p->devid == PDVFOI_ID)
            pdv_serial_wait(pdv_p, 500, 0);
        else
            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;
    int     cont = 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;
    int     cont = 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)
{
    Dependent *dd_p = pdv_p->dd_p;
    int     cfg = 0;
    int     cont = 0;

    /* 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;
    int     cont = 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)  /* fra