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;