libedt.c

/* #pragma ident "@(#)libedt.c  1.462 12/08/10 EDT" */

#include "edtinc.h"

#if defined(__linux__) || defined(__APPLE__)
#include <unistd.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <sys/resource.h>
#endif

#include <stdlib.h>
#include <ctype.h>

#ifndef _NT_
#include <sys/ioctl.h>
#endif

#ifdef VXWORKS
#include "vmLib.h"
#include "cacheLib.h"
extern int sysGetVmPageSize();
/* #include <strings.h>*/
#include <string.h>
#endif

#ifdef _NT_

#include <process.h>

#else

#ifndef VXWORKS
#include <sys/errno.h>
#endif

#endif

#ifdef __sun
#include <thread.h>
#endif
#ifdef __sun
#include <sys/mman.h>
#endif
#ifdef __sun
#include <sys/priocntl.h>
#include <sys/rtpriocntl.h>
#include <sys/tspriocntl.h>
#endif

#if defined(_NT_)
#include <process.h>
#elif defined(__sun) || defined(__linux__) || defined(__APPLE__)
#include <sys/wait.h>
#endif


#ifndef PAGE_SHIFT
#define PAGE_SHIFT (12)
#endif

#ifndef PAGE_SIZE
#define PAGE_SIZE (1UL << PAGE_SHIFT)
#endif

#ifndef PAGE_MASK
#define PAGE_MASK (PAGE_SIZE-1)
#endif


/*
* EDT Library
* 
* Copyright (c) 1998, 2005 by Engineering Design Team, Inc.
* 
* DESCRIPTION Provides a 'C' language   interface to the EDT PCI DMA cards
* to simplify the       ring buffer method of reading data.
* 
* All routines access a specific device, whose handle is created and returned
* by    the edt_open() routine.
* 
*/

/* support for dmy device */
static u_int dmy_started = 0 ;


int dump_reg_access = 0;

void edt_set_dump_reg_access(int on)

{
    dump_reg_access = on;
}

#ifndef _NT_

extern int errno;

static void
edt_set_errno(int val)

{
    errno = val;
}

#else

#define edt_set_errno(val)

#endif



int edt_clear_wait_status(EdtDev *edt_p);

#ifndef SECTOR_SIZE
#define SECTOR_SIZE 512
#endif

#ifndef PAGESIZE
#define PAGESIZE 4096
#endif

#define DEFAULT_BUFFER_GRANULARITY PAGESIZE
#define MINHEADERSIZE SECTOR_SIZE
/* shorthand debug level */
#define EDTDEBUG EDTLIB_MSG_INFO_2
#define EDTFATAL EDTLIB_MSG_FATAL
#define EDTWARN EDTLIB_MSG_WARNING

#if defined(__APPLE__)
void *edt_mac_open(char *classname, int unit, int channel);
void *edt_mac_ioctl(void *dataPort, int code, void *eis);
#endif

#ifdef _NT_
static u_int WINAPI 
edt_wait_event_thread(void *);

int
edt_get_kernel_event(EdtDev *edt_p, int event_num);
static
void
edt_clear_event_func(EdtEventHandler * p);

#else
#ifndef VXWORKS
static void *
edt_wait_event_thread(void *);
#endif

#endif

#ifndef VXWORKS
static char *BaseEventNames[] =
{
    NULL,
    EDT_EODMA_EVENT_NAME,
    EDT_BUF_EVENT_NAME,
    EDT_STAT_EVENT_NAME,
    EDT_P16D_DINT_EVENT_NAME,
    EDT_P11W_ATTN_EVENT_NAME,
    EDT_P11W_CNT_EVENT_NAME,
    EDT_PDV_ACQUIRE_EVENT_NAME,
    EDT_EVENT_PCD_STAT1_NAME,
    EDT_EVENT_PCD_STAT2_NAME,
    EDT_EVENT_PCD_STAT3_NAME,
    EDT_EVENT_PCD_STAT4_NAME,
    EDT_PDV_STROBE_EVENT_NAME,
    EDT_EVENT_P53B_SRQ_NAME,
    EDT_EVENT_P53B_INTERVAL_NAME,
    EDT_EVENT_P53B_MODECODE_NAME,
    EDT_EVENT_P53B_DONE_NAME,
    EDT_PDV_EVENT_FVAL_NAME,
    EDT_PDV_EVENT_TRIGINT_NAME,
    EDT_EVENT_TEMP_NAME,
    NULL
};
#endif

#ifdef USB

u_int
usb_reg_read (EdtDev *edt_p, u_int desc)
{
    int i, addr;
    u_int retval = 0 ;
    unsigned char setup[3];
    unsigned char buf[5];
    int bytes;

    if (usb_claim_interface(edt_p->usb_p, 0) < 0)
    {
        edt_set_errno(EBUSY); ;
        return 0 ;
    }

    addr = EDT_REG_ADDR(desc) ;

    for (i = 0; i < EDT_REG_SIZE(desc); i++)
    {
        setup[0] = 0x03 ;
        setup[1] = addr ;

        /* Send setup bytes */
        if ((usb_bulk_write(edt_p->usb_p, 0x01, setup, 2,
            edt_p->usb_rtimeout)) < 0) 
        {
            usb_release_interface(edt_p->usb_p, 0);
            edt_set_errno(EINVAL); ;
            return 0 ;
        }

        /* Read back setup bytes to verify */
        bytes = usb_bulk_read(edt_p->usb_p, 0x81, buf, 1, edt_p->usb_rtimeout);

        if (bytes < 1)
        {
            extern int errno ;
            usb_release_interface(edt_p->usb_p, 0);
            edt_set_errno(EINVAL); ;
            return 0 ;
        }

        ++addr ;
        retval |= ((u_int) buf[0] << (i * 8)) ;
    }

    usb_release_interface(edt_p->usb_p, 0);

    return retval ;
}

void
usb_reg_write(EdtDev *edt_p, u_int desc, u_int value)
{
    int i, addr, size;
    unsigned char setup[4];
    unsigned char buf[4];

    if (usb_claim_interface(edt_p->usb_p, 0) < 0)
    {
        edt_set_errno(EBUSY); ;
        return ;
    }

    addr = EDT_REG_ADDR(desc) ;

    for (i = 0; i < EDT_REG_SIZE(desc); i++)
    {
        if (EDT_REG_TYPE(desc) == REMOTE_USB_TYPE)
        {
            setup[0] = 0x04;
            setup[1] = addr ;
            setup[2] = value & 0xff ;
            size = 3 ;
        }
        else if (EDT_REG_TYPE(desc) == LOCAL_USB_TYPE)
        {
            setup[0] = 0x01;
            setup[1] = value & 0xff ;
            size = 2 ;
        }

        /* Send setup bytes */
        if ((usb_bulk_write(edt_p->usb_p, 0x01, setup, size,
            edt_p->usb_wtimeout)) < 0) 
        {
            usb_release_interface(edt_p->usb_p, 0);
            edt_set_errno(EINVAL); ;
            return ;
        }

        addr++ ;
        value >>= 8 ;
    }

    usb_release_interface(edt_p->usb_p, 0);
}


/*
* find the EDT USB board attached
*/
struct usb_device *edt_find_usb_board(int unit)
{
    struct usb_bus *p;
    struct usb_device *q;

    for (p = usb_busses; p; p = p->next)
    {
        q = p->devices;
        while(q)
        {
            if ((q->descriptor.idVendor==0x04b4) &&
                (q->descriptor.idProduct=0x8613))
                return q;
            else
                q = q->next;
        }
    }

    return NULL;
}
#endif /* USB */


static int             edt_parse_devname(EdtDev *edt_p, char *edt_devname, int unit, int channel);


EdtDev *edt_open_device(char *device_name, int unit, int channel, int verbose)

{
    EdtDev *edt_p;              /* ptr video device struct */
    static char *debug_env = NULL;
    u_int   dmy;
    int edt_debug;
    static char *debug_file = NULL;
    int level;

    if ((debug_env == NULL)
        && ((debug_env = (char *) getenv("EDTDEBUG")) != NULL)
        && *debug_env != '0')
    {
        edt_debug = atoi(debug_env);
        level = edt_msg_default_level();
        if (edt_debug > 0) 
        {
            level |= EDTLIB_MSG_INFO_1;
            level |= EDTLIB_MSG_INFO_2;
        }
        edt_msg_set_level(edt_msg_default_handle(), level);

        if ((debug_file == NULL)
            && ((debug_file = (char *) getenv("EDTDEBUGFILE")) != NULL)
            && *debug_file != '0')
        {
            edt_msg_set_name(edt_msg_default_handle(), debug_file);
        }

        edt_msg(EDTDEBUG, "environment DEBUG set to %d: enabling debug in edtlib\n", edt_debug);
    }

    if ((edt_p = (EdtDev *) calloc(1, sizeof(EdtDev))) == NULL)
    {
        char errstr[128];
        sprintf(errstr, "edtlib: malloc (%x) in edt_open failed\n", (int)sizeof(EdtDev));
        edt_msg_perror(EDTWARN, errstr);
        return (NULL);
    }

    if(verbose)
        edt_msg(EDTDEBUG, "edt_open_device(%s, %d)\n", device_name, unit);

    if ((strncmp(device_name, "dmy", 3) == 0) || (strncmp(device_name, "DMY", 3) == 0))
        edt_p->devid = DMY_ID;
#ifdef USB
    else if (strncasecmp(device_name, "usb", 3) == 0)
        edt_p->devtype = USB_ID; /* Set until true ID retrieved from device */
#endif


    if (edt_parse_devname(edt_p, device_name, unit, channel) != 0)
    {
        edt_msg(EDTFATAL, "Illegal EDT device name (edt_open_device):  %s\n", device_name);
        return NULL;
    }

    edt_p->unit_no = unit;
    edt_p->channel_no = channel;

#ifdef USB
    if (edt_p->devtype == USB_ID)
    {
        struct usb_device *current_device = NULL;

        usb_init();
        usb_find_busses();
        usb_find_devices();

        current_device = edt_find_usb_board(unit);

        if(current_device==NULL)
        {
            edt_set_errno(ENODEV); ;
            return NULL;
        } 

        edt_p->usb_p = usb_open(current_device);

        /*
        * The following assume that large buffer reads occur
        * on endpoints 82, 84, 86, and 88.  82 is channel 2,
        * 84 channel 1, etc.  Large buffer writes occur on
        * endpoints 2, 4, 6, and 8.
        */
        edt_p->usb_bulk_read_endpoint = 0x80 + (channel * 2) + 2 ;
        edt_p->usb_bulk_write_endpoint = (channel * 2) + 2 ;

    }
    else
#endif
    {

#ifdef _NT_
        edt_p->fd = CreateFile(edt_p->edt_devname,
            GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ | FILE_SHARE_WRITE,
            NULL,
            edt_p->devid == (DMY_ID) ? OPEN_ALWAYS 
            : OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,
            NULL);

        if (edt_p->fd == INVALID_HANDLE_VALUE)
        {
            if (verbose)
                edt_msg(EDTWARN, "EDT %s open failed.\nCheck board installation and unit number, and try restarting the computer\n", device_name);

            return (NULL);
        }
#else
#if defined (__APPLE__)
        /* dataPort = edt_mac_open("pcd",0) ;*/
        if (verbose)
            edt_msg(EDTWARN, "edt_devname %s unit %d channel %d\n",edt_p->edt_devname,unit,channel) ;
        if (edt_p->devid != DMY_ID)
        {
            if ((edt_p->fd = edt_mac_open(edt_p->edt_devname, unit, channel)) <= 0 )
            {
                if (verbose)
                    edt_msg(EDTWARN, "EDT %s open failed.\nCheck board installation and unit number, and try restarting the computer\n", edt_p->edt_devname);
                return (NULL);
            }
            {
                edt_ioctl(edt_p, EDTG_DEVID, &edt_p->devid);
                if (edt_is_pdv(edt_p))
                {
                    if (strncmp(device_name, "pdv", 3) != 0)
                    {
                        if (verbose)
                            printf("%s not match for pdv\n",edt_p->edt_devname) ;
                        close(edt_p->fd) ;
                        return(NULL);
                    }
                }
                else if (edt_is_pcd(edt_p))
                {
                    if (strncmp(device_name, "pcd", 3) != 0)
                    {
                        if (verbose)
                            printf("%s not match for pcd\n",edt_p->edt_devname) ;
                        close(edt_p->fd) ;
                        return(NULL);
                    }
                }
            }
        }
        else
        {
            if (!edt_p->fd)
            {
                if ((edt_p->fd = open(edt_p->edt_devname, O_RDWR|O_CREAT, 0666)) < 0 )
                {
                    if (verbose)
                        edt_msg(EDTWARN, "EDT %s open failed.\nCheck board installation and unit number, and try restarting the computer\n", edt_p->edt_devname);
                    return (NULL);
                }
            }
            /* printf("skipping open with fd already open\n") ;*/
        }
#else

        if ((edt_p->fd = open(edt_p->edt_devname, O_RDWR, 0666)) < 0 )
        {
            if (verbose)
                edt_msg(EDTWARN, "EDT %s open failed.\nCheck board installation and unit number, and try restarting the computer\n", edt_p->edt_devname);
            return (NULL);
        }
        /* make sure fd not carried across exec */
#if defined( __linux__) || defined(__sun)
        fcntl(edt_p->fd, F_SETFD, FD_CLOEXEC);
#endif

#endif /* not apple */
#endif
    }



    edt_msg(EDTDEBUG, "edt_open for %s unit %d succeeded\n", device_name, unit);

    if (edt_p->devid != DMY_ID)
    {
        edt_ioctl(edt_p, EDTG_DEVID, &edt_p->devid);
        edt_ioctl(edt_p, EDTS_RESETCOUNT, &dmy);
        dmy = edt_p->channel_no ;
        edt_ioctl(edt_p, EDTS_RESETSERIAL, &dmy);
        edt_p->DMA_channels = edtdev_channels_from_type(edt_p);

#ifdef _NT_
        edt_get_kernel_event(edt_p, EDT_EVENT_BUF);
        edt_get_kernel_event(edt_p, EDT_EVENT_STAT);
        if (edt_p->devid == P53B_ID)
        {
            edt_get_kernel_event(edt_p, EDT_EVENT_P53B_SRQ);
            edt_get_kernel_event(edt_p, EDT_EVENT_P53B_INTERVAL);
            edt_get_kernel_event(edt_p, EDT_EVENT_P53B_MODECODE);
            edt_get_kernel_event(edt_p, EDT_EVENT_P53B_DONE);
        }
#endif
    }

    edt_p->devtype = edt_devtype_from_id(edt_p->devid);
    edt_p->donecount = 0;
    edt_p->tmpbuf = 0;
    edt_p->dd_p = 0;
    edt_p->b_count = 0;
    edt_p->buffer_granularity = DEFAULT_BUFFER_GRANULARITY;
    edt_p->mezz.id = MEZZ_ID_UNKNOWN;

    return edt_p;
}


EdtDev *
edt_open(char *device_name, int unit)
{

    return edt_open_device(device_name, unit, 0, 1);
}


EdtDev *
edt_open_quiet(char *device_name, int unit)
{
    return edt_open_device(device_name, unit, 0, 0); 
}

EdtDev *
edt_open_channel(char *device_name, int unit, int channel)
{
    return edt_open_device(device_name, unit, channel, 1); 
}

static int
edt_parse_devname(EdtDev *edt_p, char *device_name, int unit, int channel)
{

    char *format;

    char dev_string[512];

    if (!device_name)
        return -1;

    if (device_name[0] == '\\' || device_name[0] == '/')
    {
        strcpy(edt_p->edt_devname, device_name);
    }
    else if (edt_p->devid == DMY_ID)
    {
#ifdef _NT_
        format = ".\\%s%d" ;
#else
        format = "./%s%d" ;
#endif
        (void) sprintf(edt_p->edt_devname, format, device_name, unit) ;
    }
    else
    {
        int i;

        strncpy(dev_string, device_name,511);

        for (i=0;dev_string[i]; i++)
            dev_string[i] = tolower(dev_string[i]);

#ifdef _NT_
        dev_string[0] = toupper(dev_string[0]);
#endif

#if defined(__linux__)
        if (strcmp(dev_string, "pcd") == 0)
            strcpy(dev_string, "pcicd");
#endif


#ifdef _NT_
        if (channel > 0)
        {
            format = "\\\\.\\%s%d_%d"; 
        } 
        else
        {
            format = "\\\\.\\%s%d";
        }
#else
        if (channel > 0)
        {
            format = "/dev/%s%d_%d"; 
        } 
        else
        {
            format = "/dev/%s%d";
        }
#endif
        (void) sprintf(edt_p->edt_devname, format, dev_string, unit, channel);

    }
    edt_msg(EDTDEBUG, "parse open to %s\n",edt_p->edt_devname) ;

    return 0;
}

int
edt_close(EdtDev *edt_p)

{
    u_int   i;
#ifdef __sun
    EdtEventHandler *p;
#endif

    edt_msg(EDTDEBUG, "edt_close()\n");

    for (i = 0; i < EDT_MAX_KERNEL_EVENTS; i++)
    {


#ifdef __sun
        p = &edt_p->event_funcs[i];
        if (p->active)
        {
            p->active = 0;

            edt_ioctl(p->owner, EDTS_DEL_EVENT_FUNC, &i);
            edt_ioctl(p->owner, EDTS_CLR_EVENT, &i);
            sema_destroy(&p->sema_thread);
            thr_join(NULL, NULL, NULL);
        }
#else
#ifndef NO_PTHREAD

        edt_remove_event_func(edt_p, i);
#endif
#endif
    }

    if (edt_p->ring_buffers_configured)
        edt_disable_ring_buffers(edt_p);

    if (edt_p->fd)
    {
#ifdef _NT_
        CloseHandle(edt_p->fd);
#else
#if defined (__APPLE__)
        edt_mac_close(edt_p->fd) ;
#else
        close(edt_p->fd);
#endif
#endif
    }
    free(edt_p);

    return 0;
}



#ifdef __sun

typedef struct
{
    uint_t  index;
    uint_t  writeflag;
    EdtDev *edt_p;
}       thr_buf_args;

static void *
aio_thread(   void   *arg)

{
    thr_buf_args *bufp = (thr_buf_args *) arg;
    int     ret;
    u_char *addr;
    uint_t  size;
    int     index;
    EdtDev *edt_p;
    extern int errno;

    edt_p = bufp->edt_p;
    index = bufp->index;
    addr = edt_p->ring_buffers[index];
    size = edt_p->rb_control[index].size;

    /*
    * Start a read which will block forever in this thread. aioread() does
    * the same thing but won't allow as much concurrency.  Lseek orders the
    * buffers inside the driver. also aioread has exit problems
    */
    edt_msg(EDTDEBUG, "start %s for %d addr %x\n",
        bufp->writeflag ? "write" : "read", index, (u_int) addr);
    edt_set_errno(0);;
    if (bufp->writeflag)
        ret = pwrite(edt_p->fd, addr, size, index * 512);
    else
        ret = pread(edt_p->fd, addr, size, index * 512);
    if (ret == -1)
    {
        char    errstr[128];

        if (errno)
            perror("pread");
        sprintf(errstr, "aio buffer %d at 0x%x", index, (u_int) addr);
        edt_msg_perror(EDTDEBUG, errstr);
        edt_msg_perror(EDTDEBUG, "aiothread\n");
    }
    edt_msg(EDTDEBUG, "end aiothread for %d\n", index);
    return (0);
}

#endif

int
edt_use_umem_lock(EdtDev *edt_p, u_int use_lock)
{
    int ret = 0 ;
    if (edt_p->ring_buffers_configured)
    {
        printf("Can't change umem lock method when ring buffers active\n") ;
        return(1) ;
    }
    edt_msg(EDTDEBUG, "use umem lock %d ",use_lock) ;
    ret = edt_ioctl(edt_p, EDTS_UMEM_LOCK, &use_lock) ;
    edt_msg(EDTDEBUG, "returns %d\n",ret) ;
    if (ret)
    {
        edt_msg(EDTDEBUG,
            "Can't use Umem lock expect on solaris 2.8 or above\n") ;
    }
    else
    {
        edt_msg(EDTDEBUG,"Setting umem lock\n") ;
    }
    return(ret) ;
}

int
edt_get_umem_lock(EdtDev *edt_p)
{
    u_int using_lock ;
    edt_ioctl(edt_p, EDTG_UMEM_LOCK, &using_lock) ;
    edt_msg(EDTDEBUG,"Using lock returns %d\n",using_lock) ;
    return(using_lock) ;
}

int
edt_get_numbufs(EdtDev *edt_p)

{
    int nb = 0;
    edt_ioctl(edt_p, EDTG_NUMBUFS, &nb);
    return nb;
}

/*
* edt_configure_ring_buffer
*
* configures PCI Bus Configurable DMA Interface ring buffers
*
* @param edt_p: device handle returned from edt_open
*      bufsize: size of each buffer
*        nbufs: number of buffers
*   data_direction:     indicates whether this connection is to
*                      be used for output or input
*     bufarray: array of pointers to application-allocated buffers
*
* @return 0 on success; -1 on error
*/

static int
edt_configure_ring_buffer(EdtDev * edt_p,
                          int index,
                          int bufsize,
                          int write_flag,
                          unsigned char *pdata)

{
    buf_args sysargs;
    int allocated_size = bufsize;
    EdtRingBuffer *pring;
    int rc;

    if (index < 0 || index >= MAX_DMA_BUFFERS)
    {
        edt_set_errno(EINVAL); 

        fprintf(stderr,
            "invalid buffer index %d < 0 or >= MAX_DMA_BUFFERS (%d)\n",
            index, MAX_DMA_BUFFERS);
        return -1;
    }

    pring = &edt_p->rb_control[index];



    pring->size = bufsize;
    pring->write_flag = write_flag;

    if (pdata || (edt_p->mmap_buffers))
    {
        pring->owned = FALSE;
        if (edt_p->fullbufsize)
            allocated_size = edt_p->fullbufsize;
    }
    else
    {
#ifdef _NT_
        /* round up to full page for fast file access */
        if (allocated_size & (SECTOR_SIZE-1))
            allocated_size = ((allocated_size / SECTOR_SIZE)+1)* SECTOR_SIZE;
#endif
        pdata =
            edt_alloc(allocated_size);
        pring->owned = TRUE;
    }

    pring->allocated_size = allocated_size;

    edt_p->ring_buffers[index] = pdata;

    sysargs.index = index;
    sysargs.writeflag = write_flag;
#ifdef WIN32
    sysargs.addr = (uint64_t) (pdata);
#else
    sysargs.addr = (uint64_t) ((unsigned long)pdata);
#endif

    sysargs.size = bufsize;
#ifdef __hpux
    bzero(sysargs.addr,sysargs.size) ;
#endif

    if (edt_p->mmap_buffers)
    {
        if ((rc = edt_ioctl(edt_p, EDTS_BUF_MMAP, &sysargs)) == 0)
        {
#ifdef __sun
            int  using_lock = 0 ;
            int     count;
            thr_buf_args bufargs;

            using_lock = edt_get_umem_lock(edt_p) ;

            if (!using_lock)
            {
                bufargs.edt_p = edt_p;
                bufargs.index = index;
                bufargs.writeflag = write_flag;

                edt_msg(EDTDEBUG, "%d buffer thread\n", index);
                if (thr_create(NULL, 0,
                    aio_thread,
                    (void *) &bufargs, THR_BOUND,
                    &pring->ring_tid))
                {
                    edt_msg_perror(EDTWARN, "thr_create");
                }
            }
            count = index + 1;

            edt_msg(EDTDEBUG, "Before WAITN");
            edt_ioctl(edt_p, EDTS_WAITN, &count);
            edt_msg(EDTDEBUG, "After WAITN");
#endif
            return 0;

        }       
        else
        {
            edt_msg(EDT_MSG_FATAL, "Unable to configure ring buffer\n");
            edt_msg(EDT_MSG_FATAL, "rc = %d\n", rc);
            return rc;
        }
    } 
    else if (edt_ioctl(edt_p, EDTS_BUF, &sysargs) == 0)
    {
#ifdef __sun
        int  using_lock = 0 ;
        int     count;
        thr_buf_args bufargs;

        using_lock = edt_get_umem_lock(edt_p) ;

        if (!using_lock)
        {
            bufargs.edt_p = edt_p;
            bufargs.index = index;
            bufargs.writeflag = write_flag;

            edt_msg(EDTDEBUG, "%d buffer thread\n", index);
            if (thr_create(NULL, 0,
                aio_thread,
                (void *) &bufargs, THR_BOUND,
                &pring->ring_tid))
            {
                edt_msg_perror(EDTWARN, "thr_create");
            }
            count = index + 1;

            edt_msg(EDTDEBUG, "Before WAITN");
            edt_ioctl(edt_p, EDTS_WAITN, &count);
            edt_msg(EDTDEBUG, "After WAITN");
        }
#endif
        return 0;
    }
    return (-1);
}

/*
* Obsolete - was used as a workaround for edt_set_direction().
* Still used in legacy code, so keep for compatibility.
* TODO: needs to be made compatible with edt_p->mmap_buffers.
*/
int
edt_add_ring_buffer(EdtDev * edt_p,
                    unsigned int bufsize,
                    int write_flag,
                    void *pdata)
{

    int     index = -1;

    int     i;

    if (!edt_p->mmap_buffers)
    {

        /* allocate a slot for the data */

        for (i = 0; i < MAX_DMA_BUFFERS; i++)
            if (edt_p->ring_buffers[i] == NULL)
                break;

        if (i == MAX_DMA_BUFFERS)
            return -1;

        index = i;

        edt_p->ring_buffer_numbufs++;

        edt_ioctl(edt_p, EDTS_NUMBUFS, &edt_p->ring_buffer_numbufs);

        edt_configure_ring_buffer(edt_p, index, bufsize, write_flag, pdata);
    }

    return index;
}


/*
* Obsolete - was used as a workaround for edt_set_direction(), but
* no longer needed.  Still may show up in customer code, so keep.
* 
* @return 0 on success, -1 on failure
*/
int
edt_configure_channel_ring_buffers(EdtDev *edt_p, int bufsize, int numbufs,
                                   int write_flag, unsigned char **bufarray)
{
    return edt_configure_ring_buffers(edt_p, bufsize, numbufs,
        write_flag, bufarray) ;
}

static
int edt_check_ring_buf_parms(EdtDev *edt_p, int numbufs, int bufsize, 
                             unsigned char *pdata, unsigned char ** bufarray)

{

    int maxbufs;

    if (!edt_p)
    {
        edt_msg_perror(EDTFATAL, "Invalid edt handle\n");
        return -1;
    }


    /* Odd number of bytes is illegal.  Mark & Chet Oct'2000 */
    if (bufsize & 0x01)
    {
        edt_set_errno(EINVAL); ;

        edt_msg_perror(EDTFATAL, "edt_configure_ring_buffers: bufsize must be an even number of bytes\n") ;
        return -1 ;
    }
    maxbufs = edt_get_max_buffers(edt_p) ;
    if (numbufs > maxbufs)
    {

        edt_set_errno(EINVAL); ;

        edt_msg_perror(EDTFATAL, 
            "edt_configure_ring_buffers: number of bufs exceeds maximum\n") ;
        edt_msg_perror(EDTFATAL, 
            "use edt_set_max_buffers to increase max\n") ;
        return -1 ;
    }   

    edt_p->mmap_buffers = edt_get_mmap_buffers(edt_p);

    if (edt_p->mmap_buffers)
    {
        if (edt_p->buffer_granularity < PAGE_SIZE)
            edt_p->buffer_granularity = PAGE_SIZE;

    }

    if (edt_p->mmap_buffers && ((pdata != NULL) || (bufarray != NULL)))
    {

        edt_set_errno(EINVAL); ;

        edt_msg_perror(EDTFATAL, 
            "edt_configure_ring_buffers: can't pass in user pointer when using mmap kernel buffers\n") ;

        return -1;
    }

    return 0;
}

#define EDT_DMAMEM_OFFSET 0x10000000

int
edt_unmap_dmamem(EdtDev *edt_p)
{

#ifdef __linux__

    if (edt_p->base_buffer)
        munmap(edt_p->base_buffer, edt_p->totalsize);

#endif

    return 0;
}

caddr_t
edt_map_dmamem(EdtDev *edt_p)
{

    caddr_t     ret = NULL;


#ifdef __linux__
    int pagen = EDT_DMAMEM_OFFSET;

    ret = (caddr_t) mmap((caddr_t)0, edt_p->totalsize, PROT_READ|PROT_WRITE,
        MAP_SHARED, edt_p->fd, pagen);
#endif


    if (ret == ((caddr_t)-1)) {
        perror("mmap call");
        return(0) ;
    }   

    return(ret) ;
}

static int
edt_allocate_ring_buffer_memory(EdtDev *edt_p, int bufsize, int numbufs, u_char *user_mem, u_char **buffers)

{

    unsigned char * bp;
    int i;

    edt_p->fullbufsize = edt_get_total_bufsize(edt_p, bufsize, edt_p->header_size);

    edt_p->totalsize = edt_p->fullbufsize * numbufs;

    if (edt_p->mmap_buffers)
    {
        /* don't allocate, we'll do that later */
        for (i=0;i<numbufs;i++)
            buffers[i] = NULL;

        return 0;
    }

    if (edt_p->base_buffer)
    {
        edt_free(edt_p->base_buffer);
        edt_p->base_buffer = NULL;
    }

    if (user_mem)
    {
        bp = user_mem;
    }
    else
    {


        edt_p->ring_buffers_allocated = TRUE;
        edt_p->base_buffer = edt_alloc(edt_p->totalsize);

        if (!edt_p->base_buffer)
        {
            edt_msg_perror(EDTFATAL, "Unable to allocate buffer memory\n");
            return -1;
        }

        bp = edt_p->base_buffer;


    }

    if (edt_p->header_offset < 0)
        bp += ((int) edt_p->header_size);

    for (i=0;i<numbufs;i++)
    {
        buffers[i] = bp;
        bp += edt_p->fullbufsize;
    }


    return 0;

}


static int
edt_setup_ring_buffers(EdtDev *edt_p, int bufsize, int numbufs,
                       int write_flag, unsigned char *pdata, unsigned char **bufarray)
{
    int     i;
    int rc;

    u_char *localbuf[MAX_DMA_BUFFERS];
    u_char ** buffers;

    buffers = (bufarray != NULL)?bufarray:localbuf;

    if ((rc = edt_check_ring_buf_parms(edt_p, numbufs, bufsize,  pdata, bufarray)) != 0)
        return rc;

    if (edt_p->ring_buffers_configured)
        edt_disable_ring_buffers(edt_p);

    edt_p->nextwbuf = 0;
    edt_p->donecount = 0;
    edt_p->ring_buffer_bufsize = bufsize;
    edt_p->ring_buffer_numbufs = numbufs;

    if (write_flag)
        edt_set_direction(edt_p, EDT_WRITE);
    else
        edt_set_direction(edt_p, EDT_READ);

    edt_p->write_flag = write_flag;

    edt_ioctl(edt_p, EDTS_NUMBUFS, &numbufs);

    if (bufarray == NULL)
    {
        edt_allocate_ring_buffer_memory(edt_p, bufsize, numbufs, pdata, buffers);

        edt_p->ring_buffers_allocated = !edt_p->mmap_buffers && (pdata == NULL);
    }

    for (i = 0; i < numbufs; i++)
    {
        if (edt_configure_ring_buffer(edt_p, i,
            bufsize,
            write_flag,
            buffers[i]) == 0)
        {

        }
        else
        {
            return -1;
        }

#ifdef __hpux
        edt_dmasync_fordev(edt_p, i, 0, 0) ;
#endif

    }


#if defined(__hpux)
    {
        int pret ;
        /* pret = plock(DATLOCK) ;*/
        pret = plock(PROCSHLIBLOCK) ;
    }
#elif defined(sgi)
    mlockall(MCL_FUTURE); 
#endif

    if (edt_p->mmap_buffers)
    {
        u_char *bp;

        edt_p->base_buffer = (u_char *) edt_map_dmamem(edt_p);
        bp = edt_p->base_buffer;

        for (i=0;i<numbufs;i++)
        {
            edt_p->ring_buffers[i] = bp;
            bp += edt_p->fullbufsize;
        }

        /* go ahead and page it in */
        bp = edt_p->base_buffer;
        for (i=0; i<(int)edt_p->totalsize;i += PAGE_SIZE)
            bp[i] = 0x5a;


    }

    edt_p->ring_buffers_configured = 1;

    return 0;
}



void edt_set_buffer_granularity(EdtDev *edt_p, u_int granularity)

{
    edt_p->buffer_granularity = granularity;
}


int
edt_get_total_bufsize(EdtDev *edt_p,
                      int bufsize, 
                      int header_size)

{
    int fullbufsize;

    fullbufsize = header_size + bufsize;

    if (edt_p->buffer_granularity)
        if (fullbufsize % edt_p->buffer_granularity)
            fullbufsize = ((fullbufsize / edt_p->buffer_granularity)+1)* edt_p->buffer_granularity;     

    return fullbufsize;
}


int
edt_configure_ring_buffers(EdtDev *edt_p, int bufsize, int numbufs,
                           int write_flag, unsigned char **bufarray)
{
    return edt_setup_ring_buffers(edt_p, bufsize, numbufs, write_flag, NULL, bufarray);

}

int
edt_configure_block_buffers_mem(EdtDev *edt_p, 
                                int bufsize, 
                                int numbufs, 
                                int write_flag,
                                int header_size, 
                                int header_before,
                                u_char *user_mem)

{

    /* check for valid arguments */
    if (header_before && header_size)
    {   
        if (header_size & (SECTOR_SIZE-1))
            header_size = ((header_size / SECTOR_SIZE)+1)* SECTOR_SIZE; 
    }


    edt_p->header_size = header_size;
    edt_p->header_offset = (header_before)? -header_size : bufsize;


    return edt_setup_ring_buffers(edt_p, bufsize, numbufs, write_flag, user_mem, NULL);

}


int
edt_configure_block_buffers(EdtDev *edt_p, int bufsize, int numbufs, int write_flag,
                            int header_size, int header_before)

{

    return edt_configure_block_buffers_mem(edt_p,
        bufsize,
        numbufs,
        write_flag,
        header_size,
        header_before,
        NULL);

}


int
edt_disable_ring_buffer(EdtDev *edt_p, 
                        int whichone)

{
    if (edt_p->ring_buffers[whichone])
    {
        /* detach buffer from DMA resources */

        edt_ioctl(edt_p, EDTS_FREEBUF, &whichone);
        edt_msg(EDTDEBUG, "free buf %d\n", whichone);

#ifdef __sun
        {
            u_int using_lock ;
            using_lock = edt_get_umem_lock(edt_p) ;
            if (!using_lock)
            {
                edt_msg(EDTDEBUG, "joining user buf %d tid %x\n", 
                    whichone, edt_p->rb_control[whichone].ring_tid);
                thr_join(edt_p->rb_control[whichone].ring_tid, NULL, NULL);

                edt_msg(EDTDEBUG, "join user buf %d done\n", whichone);
            }
        }
#endif
        /* free data pointer if we own it */
        if (edt_p->rb_control[whichone].owned)
        {
            edt_msg(EDTDEBUG, "free user buf %d\n", whichone);
            edt_free(edt_p->ring_buffers[whichone]);
        }

        edt_p->ring_buffers[whichone] = NULL;

    }
#if defined(__hpux)
    {
        int pret ;
        pret = plock(UNLOCK) ;
    }
#endif

    return 0;

}


int
edt_disable_ring_buffers(EdtDev *edt_p)

{
    int   i;

    /* for (i = 0; i < edt_p->ring_buffer_numbufs; i++)*/
    for (i = edt_p->ring_buffer_numbufs - 1; i >= 0 ; i--)
    {
        edt_disable_ring_buffer(edt_p,i);
    }

    edt_p->ring_buffers_configured = 0;
    edt_p->ring_buffers_allocated = 0;
#if defined(__hpux)
    {
        int pret ;
        pret = plock(UNLOCK) ;
    }
#elif defined(sgi)
    munlockall();
#endif

    if (edt_p->base_buffer )
    {

        if (edt_p->mmap_buffers)
            edt_unmap_dmamem(edt_p);
        else
            edt_free(edt_p->base_buffer);
        edt_p->base_buffer = NULL;
    }
    /* Steve 1/11/01 to fix pdv_setsize bug */
    /* added NUMBUFS to fix dmaid issue 2/19/03 */
    {
        int one = 1;
        edt_p->ring_buffer_numbufs = 0;
        edt_ioctl(edt_p, EDTS_NUMBUFS, &one);
        edt_ioctl(edt_p, EDTS_CLEAR_DMAID, &one);
    }

    return 0;
}

int
edt_start_buffers(EdtDev *edt_p, uint_t count)
{
    if (edt_p->devid == DMY_ID && edt_p->dd_p)
        dmy_started += count ;
    edt_msg(EDTDEBUG, "edt_start_buffers %d\n", count);
    edt_ioctl(edt_p, EDTS_STARTBUF, &count);
    return 0;
}


int
edt_lockoff(EdtDev * edt_p)
{
    int     count = 0;

    edt_ioctl(edt_p, EDTS_STARTBUF, &count);
    return 0;
}

unsigned int
edt_allocated_size(EdtDev *edt_p, int buffer)

{
    if (buffer >= 0 && buffer < (int) edt_p->ring_buffer_numbufs)
    {
        return edt_p->rb_control[buffer].allocated_size;
    }
    return 0;
}

int
edt_set_buffer(EdtDev *edt_p, uint_t bufnum)
{
    edt_ioctl(edt_p, EDTS_SETBUF, &bufnum);
    edt_p->donecount = bufnum;
    if (edt_p->ring_buffer_numbufs)
        edt_p->nextwbuf = bufnum % edt_p->ring_buffer_numbufs;
    return 0;
}

int
edt_read(EdtDev *edt_p, 
         void   *buf, 
         uint_t  size)
{
    int     retval;

#ifdef USB
    if (edt_p->devtype == USB_ID)
    {
        if (usb_claim_interface(edt_p->usb_p, 0) < 0)
        {
            edt_set_errno(EBUSY); ;
            return -1 ;
        }

        retval = usb_bulk_read(edt_p->usb_p, edt_p->usb_bulk_read_endpoint,
            buf, size, edt_p->usb_rtimeout);

        usb_release_interface(edt_p->usb_p, 0);
    }
    else
#endif /* USB */
    {

#ifdef _NT_
        uint_t  Length;
#endif

        if (size & 0x01) /* Odd no of bytes illegal.  Mark & Chet Oct'2000 */
            -- size ;

        if (edt_p->last_direction != 1)
            edt_set_direction(edt_p, EDT_READ);
#ifdef _NT_
        if ((retval = ReadFile(edt_p->fd, buf, size, &Length, NULL)) == 0)
            edt_msg_perror(EDTFATAL, "edt_read:ReadFile");
        retval = Length;
#else
#if defined(__APPLE__)
        if (edt_p->devid != DMY_ID)
        {
            int retval ;
            unsigned char *bufarray[1] ;
            bufarray[0] = buf ;
            retval = edt_configure_ring_buffers(edt_p, size, 1, EDT_READ, bufarray) ;
            if (retval) return retval;

            edt_start_buffers(edt_p, 1) ;
            retval = edt_wait_for_buffers(edt_p, 1) ;
            if (retval < 0)
            {
                size = edt_get_timeout_count(edt_p);
                edt_msg(EDTDEBUG, "edt_read timeout with count %d\n", retval);
            }
            edt_disable_ring_buffers(edt_p) ;
            return(size) ;
        }
#endif
        edt_p->b_count += size ;
        if (edt_p->b_count > 0x40000000) /* 1GB */
        {
            lseek(edt_p->fd, 0, 0) ;
            edt_p->b_count = 0 ;
        }
        if ((retval = read(edt_p->fd, buf, size)) < 0)
        {
#if defined(__sun) || defined(__linux__)
            if (errno == ETIMEDOUT)
            {
                retval = edt_get_timeout_count(edt_p);
                edt_msg(EDTDEBUG, "edt_read timeout with count %d\n", retval);
            }
            else
#endif
                edt_msg_perror(EDTDEBUG, "edt_read:Read");
        }
#endif
    }
    return (retval);
}

int
edt_write(EdtDev *edt_p,
          void   *buf,
          uint_t  size)

{
    uint_t  Length = 0;

#ifdef USB
    if (edt_p->devtype == USB_ID)
    {
        if (usb_claim_interface(edt_p->usb_p, 0) < 0)
        {
            edt_set_errno(EBUSY); ;
            return -1 ;
        }

        Length = usb_bulk_write(edt_p->usb_p, edt_p->usb_bulk_write_endpoint,
            buf, size, edt_p->usb_wtimeout);

        usb_release_interface(edt_p->usb_p, 0);
    }
    else
#endif /* USB */
    {

        if (size & 0x01) /* Odd no of bytes illegal.  Mark & Chet Oct'2000 */
            -- size ;

        if (edt_p->last_direction != (EDT_WRITE+1))
            edt_set_direction(edt_p, EDT_WRITE);
#ifdef _NT_
        if (!WriteFile(edt_p->fd, buf, size, &Length, NULL))
            edt_msg_perror(EDTWARN, "WRITEFile");
#else
#if defined(__APPLE__)
        if (edt_p->devid != DMY_ID)
        {
            int retval ;
            unsigned char *bufarray[1] ;
            bufarray[0] = buf ;
            retval = edt_configure_ring_buffers(edt_p, size, 1, EDT_WRITE, bufarray) ;
            edt_start_buffers(edt_p, 1) ;
            /* edt_wait_for_buffers(edt_p, 1) ; */
            return(size) ;
        }
#endif
        edt_p->b_count += size ;
        if (edt_p->b_count > 0x40000000) /* 1GB */
        {
            lseek(edt_p->fd, 0, 0) ;
            edt_p->b_count = 0 ;
        }
        if (write(edt_p->fd, buf, size) < 0)
        {
            edt_msg_perror(EDTDEBUG, "write");
            Length = -1;
        }
        else
            Length = size;
#endif
    }

    return (Length);
}

int
edt_write_pio(EdtDev *edt_p, u_char *buf, int size)

{
    edt_sized_buffer argbuf;

    argbuf.size = size;

    memcpy(argbuf.data, buf, size);

    return edt_ioctl(edt_p, EDTS_WRITE_PIO, &argbuf);

}


unsigned char *
edt_next_writebuf(   EdtDev *edt_p)

{
    unsigned char *buf_p;

    buf_p = edt_p->ring_buffers[edt_p->nextwbuf];
    edt_p->nextwbuf = ++edt_p->nextwbuf % edt_p->ring_buffer_numbufs;
    return buf_p;
}

unsigned char **
edt_buffer_addresses(EdtDev *edt_p)
{
    return (edt_p->ring_buffers);
}

unsigned char *
edt_wait_buffers_timed(EdtDev * edt_p, int count, u_int * timep)
{
    u_char *ret;

    edt_msg(EDTDEBUG, "edt_wait_buffers_timed()\n");

    ret = edt_wait_for_buffers(edt_p, count);
    edt_get_timestamp(edt_p, timep, edt_p->donecount - 1);

    edt_msg(EDTDEBUG, "buf %d done %s (%x %x)\n",
        edt_p->donecount,
        edt_timestring(timep),
        timep[0], timep[1]);

    return (ret);
}

unsigned char *
edt_last_buffer(EdtDev * edt_p)
{
    u_char *ret;
    bufcnt_t     donecount;
    bufcnt_t     last_wait;
    int     delta;

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

    edt_msg(EDTDEBUG, "edt_last_buffer() last %d cur %d\n",
        last_wait, donecount);

    delta = donecount - last_wait;

    if (delta == 0)
        delta = 1;

    ret = edt_wait_for_buffers(edt_p, delta) ;
    return (ret);
}

unsigned char *
edt_last_buffer_timed(EdtDev * edt_p, u_int * timep)
{
    u_char *ret;
    bufcnt_t     donecount;
    bufcnt_t     last_wait;
    int     delta;

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

    edt_msg(EDTDEBUG, "edt_last_buffer_timed() last %d cur %d\n",
        last_wait, donecount);

    delta = donecount - last_wait;

    if (delta == 0)
        delta = 1;

    ret = edt_wait_buffers_timed(edt_p, delta, timep);
    return (ret);
}

char   *
edt_timestring(u_int * timep)
{
    static char timestr[100];
    struct tm *tm_p;
    time_t testtm ;

    /* timep is sec,nsec in two 32 bit ints */
    /* works when passed to localtime on 32 bit system, but not 64 */
    testtm = timep[0] ;
    tm_p = localtime(&testtm);
    timep++;
    sprintf(timestr, "%02d:%02d:%02d.%06d",
        tm_p->tm_hour,
        tm_p->tm_min,
        tm_p->tm_sec,
        *timep);

    return timestr;
}

int                        
edt_do_timeout(EdtDev *edt_p)

{
    int dummy;

    return edt_ioctl(edt_p,EDTS_DOTIMEOUT,&dummy);

}

unsigned char *
edt_wait_for_buffers(EdtDev * edt_p, int count)
{
    int     bufnum;
    int     ret = 0;
    bufcnt_t tmpcnt = count ;
#ifdef _NT_
    int timeoutval = edt_get_rtimeout(edt_p);
#endif

    edt_msg(EDTDEBUG, "edt_wait_for_buffers(%d)\n", count);

    if (edt_p->ring_buffer_numbufs == 0)
    {
        edt_msg(EDTDEBUG, "wait for buffers called with 0 buffers\n");
        return (0);
    }
    tmpcnt += edt_p->donecount;

#ifdef _NT_

    edt_p->last_wait_ret = EDT_WAIT_OK;

    if (edt_get_drivertype(edt_p) != EDT_WDM_DRIVER)

    {
        HANDLE event;
        int rc;

        if (!edt_p->event_funcs[EDT_EVENT_BUF].wait_event)
        {
            edt_get_kernel_event(edt_p, EDT_EVENT_BUF);
        }

        event = edt_p->event_funcs[EDT_EVENT_BUF].wait_event;

        while (edt_done_count(edt_p) < tmpcnt)
        {

            /* wait for event */

            if (timeoutval == 0)
                timeoutval = INFINITE;

            ret = EDT_WAIT_OK;
            edt_clear_wait_status(edt_p);

            rc = WaitForSingleObject(event, timeoutval);

            if (rc == WAIT_TIMEOUT)
            {
                if (edt_get_timeout_ok(edt_p))
                {
                    ret = EDT_WAIT_OK_TIMEOUT;
                }
                else
                {
                    edt_msg(EDTDEBUG, "timeout...\n");

                    /* deal with timeout */

                    edt_do_timeout(edt_p);
                    ResetEvent(event) ;
                    ret = EDT_WAIT_TIMEOUT;
                }
                break;
            }
            else if (edt_had_user_dma_wakeup(edt_p))
            {
                ret = EDT_WAIT_USER_WAKEUP;

            }
        }
    }
    else
    {
        ret = edt_ioctl(edt_p, EDTS_WAITBUF, &tmpcnt);
    }
#else

    ret = edt_ioctl(edt_p, EDTS_WAITBUF, &tmpcnt);
    ret = edt_get_wait_status(edt_p);

#endif


    edt_msg(EDTDEBUG, "edt_wait_for_buffers %d done ret = %d\n", count,
        ret);
    if (ret  == EDT_WAIT_OK || ret == EDT_WAIT_TIMEOUT)
        edt_p->donecount = tmpcnt;

    /* avoid error if close happened in another thread */

    if (edt_p->ring_buffer_numbufs)
        bufnum = (edt_p->donecount - 1) % edt_p->ring_buffer_numbufs;
    else
        return NULL;

#ifdef VXWORKS
    /* TODO - move this to dma done */
    /* ATTN - not right - should be bytecount? */
    CACHE_DMA_INVALIDATE(edt_p->ring_buffers[bufnum],
        edt_p->rb_control[bufnum].size);
#if defined(AV3_BOARD)
    printf("cache inv %x %x\n",
        edt_p->ring_buffers[bufnum], edt_p->rb_control[bufnum].size);
    bslPpcCacheInv(edt_p->ring_buffers[bufnum], edt_p->rb_control[bufnum].size);
#endif
#endif

        edt_p->last_wait_ret = ret;
        
        return (edt_p->ring_buffers[bufnum]);

}

int
edt_get_timestamp(EdtDev * edt_p, u_int * timep, u_int bufnum)
{
    /* we return sec and nsec - change to usec */
    u_int   timevals[3];

    timevals[0] = bufnum;
    if (edt_p->devid == DMY_ID)
    {
        u_int inttime ;
        double testtime ;
        timevals[0] = bufnum ;
        testtime = edt_timestamp();
        inttime = (u_int)testtime ;
        testtime -= inttime ;
        *timep++ = inttime ;
        *timep++ = (u_int)(testtime * 1000000.0) ;
    }
    else
    {
        edt_ioctl(edt_p, EDTG_TMSTAMP, timevals);

        edt_msg(EDTDEBUG, "%x %x %x %x ", bufnum,
            timevals[0],
            timevals[1],
            timevals[2]);
        *timep++ = timevals[1];
        *timep++ = timevals[2];
    }

    return (timevals[0]);
}

unsigned char *
edt_wait_for_next_buffer(EdtDev *edt_p)

{
    bufcnt_t count;
    unsigned int bufnum;
#ifdef _NT_
    int timeoutval = edt_get_rtimeout(edt_p);
#endif

    edt_ioctl(edt_p, EDTG_BUFDONE, &count);
    count++;
    if (edt_p->ring_buffer_numbufs == 0) {
        /* maybe they forgot edt_configure_ring_buffers */
        return NULL; 
    }
    bufnum = (count - 1) % edt_p->ring_buffer_numbufs;

#ifdef _NT_
    if (edt_get_drivertype(edt_p) != EDT_WDM_DRIVER)

    {
        HANDLE event;
        int rc;

        if (!edt_p->event_funcs[EDT_EVENT_BUF].wait_event)
        {
            edt_get_kernel_event(edt_p, EDT_EVENT_BUF);
        }

        event = edt_p->event_funcs[EDT_EVENT_BUF].wait_event;

        while (edt_done_count(edt_p) < (bufcnt_t) count)
        {

            /* wait for event */

            if (timeoutval == 0)
                timeoutval = INFINITE;

            rc = WaitForSingleObject(event, timeoutval);

            if (rc == WAIT_TIMEOUT)
            {
                edt_msg(EDTDEBUG, "timeout...\n");

                /* deal with timeout */

                edt_do_timeout(edt_p);
                ResetEvent(event) ;

                break;
            }

        }

    }
    else
    {
        edt_ioctl(edt_p, EDTS_WAITBUF, &count);
    }
#else

    edt_ioctl(edt_p, EDTS_WAITBUF, &count);

#endif

    edt_msg(EDTDEBUG, "edt_wait_for_next_buffer %d done\n", count);
    edt_p->donecount = count;
    return (edt_p->ring_buffers[bufnum]);
}


unsigned char *
edt_get_current_dma_buf(EdtDev * edt_p)
{
    unsigned int count;
    unsigned int bufnum;
    unsigned int todo ;
    /* find out how many are done */

    edt_ioctl(edt_p, EDTG_BUFDONE, &count);

    todo = edt_get_todo(edt_p);

    /* if a dma is currently started
    * go to next buffer */

    if (todo == 0 || todo > count)
        count ++;

    bufnum = (count - 1) % edt_p->ring_buffer_numbufs;

    return (edt_p->ring_buffers[bufnum]);

}

unsigned char *
edt_check_for_buffers(EdtDev *edt_p, uint_t count)
{
    unsigned int driver_count;
    unsigned int bufnum;
    unsigned int target;

    target = count + edt_p->donecount;
    bufnum = (target - 1) % edt_p->ring_buffer_numbufs;
    edt_ioctl(edt_p, EDTG_BUFDONE, &driver_count);
    if (driver_count >= target)
    {
        return edt_wait_for_buffers(edt_p, count);
    }
    else
        return (NULL);
}

bufcnt_t
edt_done_count(EdtDev * edt_p)
{
    bufcnt_t  donecount = 0;

    if (edt_p->devid == DMY_ID)
    {
        if (edt_p->dd_p)
        {
            donecount = dmy_started;
        }
        else printf("DEBUG - dd_p not set for DMY_ID\n") ;
    }
    else
        edt_ioctl(edt_p, EDTG_BUFDONE, &donecount);
    return (donecount);
}

uint_t
edt_overflow(EdtDev * edt_p)
{
    uint_t  overflow;

    edt_ioctl(edt_p, EDTG_OVERFLOW, &overflow);
    return (overflow);
}


void
edt_perror(char *errstr)
{
#ifdef _NT_
    LPVOID  lpMsgBuf;

    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
        NULL,
        GetLastError(),
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),      /* Default language */
        (LPTSTR) & lpMsgBuf,
        0,
        NULL
        );

    edt_msg(EDTWARN, "%s: %s\n", errstr, lpMsgBuf);
#else
    edt_msg_perror(EDTWARN, errstr);
#endif
}

u_int
edt_errno(void)
{
#ifdef _NT_
    return GetLastError();
#else 
    extern int errno;
    return errno;
#endif
}

uint_t
edt_reg_read(EdtDev * edt_p, uint_t desc)
{
    int     ret;
    edt_buf buf = {0, 0};


#ifdef USB
    if (EDT_REG_TYPE(desc) == REMOTE_USB_TYPE)
    {
        buf.value = usb_reg_read(edt_p, desc) ;
    }
    else
#endif /* USB */
    {
        buf.desc = desc;
        ret = edt_ioctl(edt_p, EDTG_REG, &buf);
        if (ret < 0)
            return ret;
    }

    if (dump_reg_access && 
        desc != 0x04000084 &&
        desc != 0x01010040 &&
        desc != 0x01010042)
        printf("reg read %08x %08x\n", desc, (uint_t) buf.value);
    return (u_int) buf.value;
}

uint_t
edt_reg_or(EdtDev * edt_p, uint_t desc, uint_t mask)
{
    int     ret;
    uint_t  val;
    edt_buf buf;

    buf.desc = desc;
    buf.value = mask;
    ret = edt_ioctl(edt_p, EDTS_REG_OR, &buf);
    if (ret < 0)
        edt_msg_perror(EDTFATAL, "edt_ioctl(EDT_REG_OR)");

    if (dump_reg_access && 
        desc != 0x04000084 &&
        desc != 0x01010040 &&
        desc != 0x01010042)
        printf("reg or %08x %02x\n", desc, mask);
    val = (u_int) buf.value;
    return val;

}

uint_t
edt_reg_and(EdtDev * edt_p, uint_t desc, uint_t mask)
{
    int     ret;
    uint_t  val;
    edt_buf buf;

    buf.desc = desc;
    buf.value = mask;
    ret = edt_ioctl(edt_p, EDTS_REG_AND, &buf);
    if (ret < 0)
        edt_msg_perror(EDTFATAL, "edt_ioctl(EDT_REG_AND)");

    if (dump_reg_access && 
        desc != 0x04000084 &&
        desc != 0x01010040 &&
        desc != 0x01010042)
        printf("reg and %08x %02x\n", desc, mask);
    val = (u_int) buf.value;
    return val;
}

void
edt_reg_clearset(EdtDev * edt_p, uint_t desc, uint_t mask)
{
    int     ret;
    edt_buf buf;

    buf.desc = desc;
    buf.value = mask;
    ret = edt_ioctl(edt_p, EDTS_REG_BIT_CLEARSET, &buf);
    if (ret < 0)
        edt_msg_perror(EDTFATAL, "edt_ioctl(EDT_REG_BIT_CLEARSET)");

    return;
}

void
edt_reg_setclear(EdtDev * edt_p, uint_t desc, uint_t mask)
{
    int     ret;
    edt_buf buf;

    buf.desc = desc;
    buf.value = mask;
    ret = edt_ioctl(edt_p, EDTS_REG_BIT_SETCLEAR, &buf);
    if (ret < 0)
        edt_msg_perror(EDTFATAL, "edt_ioctl(EDT_REG_BIT_SETCLEAR)");

    return;
}

void
edt_reg_write(EdtDev * edt_p, uint_t desc, uint_t value)
{
    int     ret;
    edt_buf buf;

#ifdef USB
    if (edt_p->devtype == USB_ID)
    {
        usb_reg_write(edt_p, desc, value) ;
    }
    else
#endif /* USB */
    {
        buf.desc = desc;
        buf.value = value;

        ret = edt_ioctl(edt_p, EDTS_REG, &buf);
        if (ret < 0)
            edt_msg_perror(EDTFATAL, "write");

        if (dump_reg_access && 
            desc != 0x04000084 &&
            desc != 0x01010040 &&
            desc != 0x01010042)
            printf("reg write %08x %02x\n", desc, value);
    }
}

void
edt_startdma_action(EdtDev * edt_p, uint_t val)
{
    (void) edt_ioctl(edt_p, EDTS_STARTACT, &val);
}

void
edt_enddma_action(EdtDev * edt_p, uint_t val)
{
    (void) edt_ioctl(edt_p, EDTS_ENDACT, &val);
}

void
edt_startdma_reg(EdtDev * edt_p, uint_t desc, uint_t val)
{
    int     ret;
    edt_buf buf;

    buf.desc = desc;
    buf.value = val;
    ret = edt_ioctl(edt_p, EDTS_STARTDMA, &buf);
    if (ret < 0)
        edt_msg_perror(EDTFATAL, "write");
}

void
edt_enddma_reg(EdtDev * edt_p, uint_t desc, uint_t val)
{
    int     ret;
    edt_buf buf;

    buf.desc = desc;
    buf.value = val;
    ret = edt_ioctl(edt_p, EDTS_ENDDMA, &buf);
    if (ret < 0)
        edt_msg_perror(EDTFATAL, "write");
}



void
edt_read_start_action(EdtDev * edt_p, u_int enable, u_int reg_desc,
        u_char set, u_char clear, u_char setclear, u_char clearset,
        int delay1, int delay2)
{
    edt_buf buf;
    u_int delays;

    delays = ((delay1 << 16) & 0xffff0000) | (delay2 & 0xffff);
    (void) edt_ioctl(edt_p, EDTS_READ_START_DELAYS, &delays);

    buf.flags = enable;
    buf.desc  = reg_desc;
    buf.value = set | (clear << 8) | (setclear << 16) | (clearset << 24);

    (void) edt_ioctl(edt_p, EDTS_READ_STARTACT, &buf);
}



void
edt_read_end_action(EdtDev * edt_p, u_int enable, u_int reg_desc,
        u_char set, u_char clear, u_char setclear, u_char clearset,
        int delay1, int delay2)
{
    edt_buf buf;
    u_int delays;

    delays = ((delay1 << 16) & 0xffff0000) | (delay2 & 0xffff);
    (void) edt_ioctl(edt_p, EDTS_READ_END_DELAYS, &delays);

    buf.flags = enable;
    buf.desc  = reg_desc;
    buf.value = set | (clear << 8) | (setclear << 16) | (clearset << 24);

    (void) edt_ioctl(edt_p, EDTS_READ_ENDACT, &buf);
}



void
edt_write_start_action(EdtDev * edt_p, u_int enable, u_int reg_desc,
        u_char set, u_char clear, u_char setclear, u_char clearset,
        int delay1, int delay2)
{
    edt_buf buf;
    u_int delays;

    delays = ((delay1 << 16) & 0xffff0000) | (delay2 & 0xffff);
    (void) edt_ioctl(edt_p, EDTS_WRITE_START_DELAYS, &delays);

    buf.flags = enable;
    buf.desc  = reg_desc;
    buf.value = set | (clear << 8) | (setclear << 16) | (clearset << 24);

    (void) edt_ioctl(edt_p, EDTS_WRITE_STARTACT, &buf);
}



void
edt_write_end_action(EdtDev * edt_p, u_int enable, u_int reg_desc,
        u_char set, u_char clear, u_char setclear, u_char clearset,
        int delay1, int delay2)
{
    edt_buf buf;
    u_int delays;

    delays = ((delay1 << 16) & 0xffff0000) | (delay2 & 0xffff);
    (void) edt_ioctl(edt_p, EDTS_WRITE_END_DELAYS, &delays);

    buf.flags = enable;
    buf.desc  = reg_desc;
    buf.value = set | (clear << 8) | (setclear << 16) | (clearset << 24);

    (void) edt_ioctl(edt_p, EDTS_WRITE_ENDACT, &buf);
}



u_char
edt_intfc_read(EdtDev * edt_p, uint_t offset)
{
    u_int   read;

    read = edt_reg_read(edt_p, INTFC_BYTE | (offset & 0xffff));
    return ((u_char) read & 0xff);
}

void
edt_intfc_write(EdtDev * edt_p, uint_t offset, u_char data)
{
    edt_reg_write(edt_p, INTFC_BYTE | (offset & 0xffff), data);
}

u_short
edt_intfc_read_short(EdtDev * edt_p, uint_t offset)
{
    u_int   read;

    read = edt_reg_read(edt_p, INTFC_WORD | (offset & 0xffff));
    return (read & 0xffff);
}

void
edt_intfc_write_short(EdtDev * edt_p, uint_t offset, u_short data)
{
    edt_reg_write(edt_p, INTFC_WORD | (offset & 0xffff), data);
}

uint_t
edt_intfc_read_32(EdtDev * edt_p, uint_t offset)
{
    uint_t  read;

    read = edt_reg_read(edt_p, INTFC_32 | (offset & 0xffff));
    return (read);
}

void
edt_intfc_write_32(EdtDev * edt_p, uint_t offset, uint_t data)
{
    edt_reg_write(edt_p, INTFC_32 | (offset & 0xffff), data);
}


int 
edt_set_rci_chan(EdtDev *edt_p, int unit, int channel)
{
    int ret ;
    edt_buf buf;
    buf.desc = unit;
    buf.value = channel;
    edt_msg(EDTDEBUG, "set rci unit %d chan %d\n",unit,channel) ;
    ret = edt_ioctl(edt_p, EDTS_RCI_CHAN, &buf);
    return (ret) ;
}

int 
edt_get_rci_chan(EdtDev *edt_p, int unit)
{
    int channel ;
    edt_buf buf;
    buf.desc = unit;
    edt_ioctl(edt_p, EDTG_RCI_CHAN, &buf);
    channel = (u_int) buf.value ;
    edt_msg(EDTDEBUG, "get rci unit %d chan %d\n",unit,channel) ;
    return (channel) ;
}

int
edt_set_rci_dma(EdtDev * edt_p, int unit, int channel)

{
    char msg[5];
    sprintf(msg,"D %d",channel);

    edt_send_msg(edt_p,unit,msg,3);
    edt_set_rci_chan(edt_p, unit, channel) ;

    return 0;
}

int
edt_get_rci_dma(EdtDev * edt_p, int unit)

{
    char msgbuf[5];
    int channel;
    msgbuf[1] = 0;

    edt_send_msg(edt_p, unit, "D", 1);
    edt_serial_wait(edt_p, 100, 0) ;
    edt_get_msg(edt_p, msgbuf, sizeof(msgbuf));

    channel = atoi(&msgbuf[2]);

    return channel;

}

int
edt_set_foiunit(EdtDev * edt_p, int val)
{
    edt_p->foi_unit = val;
    return (edt_ioctl(edt_p, EDTS_FOIUNIT, &val));
}

/*
* OBSOLETE (FOI no longer supported).
*
* Returns the number of RCI modules connected to the EDT FOI (fiber
* optic interface) board.
*/
int
edt_get_foiunit(EdtDev * edt_p)
{
    int     unit;

    edt_ioctl(edt_p, EDTG_FOIUNIT, &unit);
    return (unit);
}

/*
* OBSOLETE (FOI no longer supported).
*
* sets which RCI unit to address with subsequent serial and register 
* read/write functions
*
* @param edt_p:    device struct returned from edt_open
*        unit:     unit number of RCI unit
*
* @return 0 on success; -1 on failure
*/

int
edt_set_foicount(EdtDev * edt_p, int val)
{
    return (edt_ioctl(edt_p, EDTS_FOICOUNT, &val));
}

int
edt_get_foicount(EdtDev * edt_p)
{
    int     val;

    edt_ioctl(edt_p, EDTG_FOICOUNT, &val);
    return (val);
}

int
edt_set_burst_enable(EdtDev * edt_p, int onoff)
{
    return (edt_ioctl(edt_p, EDTS_BURST_EN, &onoff));
}


int
edt_get_burst_enable(EdtDev * edt_p)
{
    int     val;

    edt_ioctl(edt_p, EDTG_BURST_EN, &val);
    return (val);
}

int
edt_set_continuous(EdtDev * edt_p, int val)
{
#ifdef PDV
    u_int tmp ;
    tmp = edt_p->dd_p->datapath_reg ;
    /* tmp = edt_reg_read(edt_p, PDV_DATA_PATH) & ~PDV_CONTINUOUS ;*/
    edt_ioctl(edt_p, EDTS_PDVDPATH, &tmp);
    return (edt_ioctl(edt_p, EDTS_PDVCONT, &val));
#else
    return 0;
#endif
}

void
edt_foi_autoconfig(EdtDev * edt_p)
{
    edt_reset_serial(edt_p);
    edt_set_foicount(edt_p, 0);
    edt_check_foi(edt_p);
}

void
edt_reset_counts(EdtDev * edt_p)
{
    int     dmy;

    edt_ioctl(edt_p, EDTS_RESETCOUNT, &dmy);
}

void
edt_reset_serial(EdtDev * edt_p)
{
    int     dmy;

    dmy = edt_p->channel_no ;
    edt_ioctl(edt_p, EDTS_RESETSERIAL, &dmy);
}

#if defined( PCD ) || defined(UCD) || defined(PDV)

u_char
pcd_get_option(EdtDev * edt_p)
{
    return (edt_intfc_read(edt_p, PCD_OPTION));
}

u_char
pcd_get_cmd(EdtDev * edt_p)
{
    return (edt_intfc_read(edt_p, PCD_CMD));
}

void
pcd_set_cmd(EdtDev * edt_p, u_char val)
{
    edt_intfc_write(edt_p, PCD_CMD, val);
}

u_char
pcd_get_funct(EdtDev * edt_p)
{
    return (edt_intfc_read(edt_p, PCD_FUNCT));
}

void
pcd_set_funct(EdtDev * edt_p, u_char val)
{
    edt_intfc_write(edt_p, PCD_FUNCT, val);
}

u_char
pcd_get_stat(EdtDev * edt_p)
{
    return ((u_char) edt_intfc_read(edt_p, PCD_STAT));
}

u_char
pcd_get_stat_polarity(EdtDev * edt_p)
{
    return (edt_intfc_read(edt_p, PCD_STAT_POLARITY));
}

void
pcd_set_stat_polarity(EdtDev * edt_p, u_char val)
{
    edt_intfc_write(edt_p, PCD_STAT_POLARITY, val);
}

void
pcd_set_byteswap(EdtDev * edt_p, int val)
{
    u_char  tmp;

    tmp = edt_intfc_read(edt_p, PCD_CONFIG);
    if (val)
        tmp |= PCD_BYTESWAP;
    else
        tmp &= ~PCD_BYTESWAP;
    edt_intfc_write(edt_p, PCD_CONFIG, tmp);
}


void
edt_flush_channel(EdtDev *edt_p, int channel)

{
    u_int dma_cfg = edt_reg_read(edt_p, EDT_DMA_CFG) ;

    dma_cfg &= ~(EDT_EMPTY_CHAN | EDT_EMPTY_CHAN_FIFO) ;

    /*
    * Set the channel number and enable the rfifo and related logic.
    */
    dma_cfg |= ((channel << EDT_EMPTY_CHAN_SHIFT) | EDT_RFIFO_ENB) ;
    edt_reg_write(edt_p, EDT_DMA_CFG, dma_cfg) ;

    /*
    * Set then reset the channel fifo flush bit.
    */
    dma_cfg |= EDT_EMPTY_CHAN_FIFO ;
    edt_reg_write(edt_p, EDT_DMA_CFG, dma_cfg) ;

    dma_cfg &= ~EDT_EMPTY_CHAN_FIFO ;
    edt_reg_write(edt_p, EDT_DMA_CFG, dma_cfg) ;


}



void
pcd_flush_channel(EdtDev * edt_p, int channel)
{
    u_short ssd16_chen = edt_reg_read(edt_p, SSD16_CHEN) ;

    ssd16_chen &= ~(1 << channel);
    edt_reg_write(edt_p, SSD16_CHEN, ssd16_chen) ;

    edt_flush_channel(edt_p,channel);


    ssd16_chen |= (1 << channel);
    edt_reg_write(edt_p, SSD16_CHEN, ssd16_chen) ;

}

/*****************************************************************************
*
* pio routines:  programmed I/O for PCD DMA boards.
*
*****************************************************************************/

static volatile u_int  *reg_fifo_io  = NULL ;
static volatile u_char *reg_fifo_cnt = NULL ;
static volatile u_char *reg_fifo_ctl = NULL ;
static volatile u_char *reg_intfc_off ;         /* mmap to intfc regs      */
static volatile u_char *reg_intfc_dat ;         /* mmap to intfc regs      */
static volatile int io_direction = -1 ;

void
pcd_pio_intfc_write(EdtDev *edt_p, u_int desc, u_char val) 
{
    int dmy ;

    *reg_intfc_off = desc & 0xff ;
    dmy = *reg_intfc_off ;

    *reg_intfc_dat = val ;
    dmy = *reg_intfc_dat ;
}

u_char
pcd_pio_intfc_read(EdtDev *edt_p, u_int desc) 
{
    int dmy ;

    *reg_intfc_off = desc & 0xff ;
    dmy = *reg_intfc_off ;

    return(*reg_intfc_dat) ;
}



void
pcd_pio_set_direction(EdtDev *edt_p, int direction)
{
    u_char  cmd = pcd_pio_intfc_read(edt_p, PCD_CMD) ;

    if (direction)
    {
        pcd_pio_intfc_write(edt_p, PCD_DIRA, 0x0f);

        cmd &= ~PCD_DIR;
        cmd |= PCD_ENABLE;

    }
    else
    {
        pcd_pio_intfc_write(edt_p, PCD_DIRA, 0xf0);

        cmd |= PCD_DIR | PCD_ENABLE ;
    }

    pcd_pio_intfc_write(edt_p, PCD_CMD, cmd);
}

static void
pcd_pio_quick_flush(EdtDev *edt_p)
{
    u_char tmpc ;

    tmpc = *reg_fifo_ctl ;
    tmpc &= ~1 ;
    *reg_fifo_ctl = tmpc ;
    tmpc |= 1 ;
    *reg_fifo_ctl = tmpc ;
}


void
pcd_pio_flush_fifo(EdtDev * edt_p)
{
    unsigned char cmd;
    unsigned int dmy;

    /* reset the interface fifos */
    *reg_intfc_off = PCD_CMD & 0xff ;
    dmy = *reg_intfc_off ;
    cmd = *reg_intfc_dat ;
    cmd &= ~PCD_ENABLE;
    *reg_intfc_dat = cmd ;
    dmy = *reg_intfc_dat ;
    cmd |= PCD_ENABLE;
    *reg_intfc_dat = cmd ;
    dmy = *reg_intfc_dat ;

    pcd_pio_quick_flush(edt_p) ;

}

void
pcd_pio_init(EdtDev *edt_p)
{
    static u_char * mapaddr = 0 ;

    if (mapaddr == 0)
    {
        mapaddr = (u_char *) edt_mapmem(edt_p, 0, 256) ;
        reg_fifo_io  = (u_int *)(mapaddr + (EDT_GP_OUTPUT & 0xff)) ;
        reg_fifo_cnt  = (u_char *)(mapaddr + (EDT_DMA_CFG & 0xff) + 3) ;
        reg_fifo_ctl = (u_char *)(mapaddr + (EDT_DMA_CFG & 0xff) + 1) ;
        reg_intfc_off  = (volatile u_char *) mapaddr + (EDT_REMOTE_OFFSET & 0xff) ;
        reg_intfc_dat = (volatile u_char *) mapaddr + (EDT_REMOTE_DATA & 0xff) ;
    }
    pcd_pio_intfc_write(edt_p, PCD_DIRB, 0xcc);
    pcd_pio_flush_fifo(edt_p) ;
}

int
pcd_pio_write(EdtDev *edt_p, u_char *buf, int size)
{
    int i;
    u_int *tmpl = (u_int *) buf ;

    pcd_pio_set_direction(edt_p, EDT_WRITE) ;

    for (i = 0 ; i < size / 4 ; i++) 
        *reg_fifo_io = *tmpl++ ;

    return(size);
}

int
pcd_pio_read(EdtDev *edt_p, u_char *buf, int size)
{
    u_int *tmpl = (u_int *) buf ;
    int wordcnt = 0 ;
    int words_avail ;
    int words_requested = size / 4 ;

    pcd_pio_set_direction(edt_p, EDT_READ) ;

    while (wordcnt < words_requested)
    {
        words_avail = *reg_fifo_cnt & 0xf ;

        while (words_avail && wordcnt < words_requested)
        {
            -- words_avail ;
            *tmpl = *reg_fifo_io ;
            wordcnt++ ;
            tmpl++ ;
        }

        if ((wordcnt == words_requested - 1) && (*reg_fifo_cnt & 0x1f) == 0x10)
        {
            *tmpl = *reg_fifo_io ;
            wordcnt++ ;
        }
    }

    pcd_pio_quick_flush(edt_p);

    return(size) ;
}

void
pcd_set_abortdma_onintr(EdtDev *edt_p, int flag)
{
    if (flag == 0)
    {
        edt_reg_and(edt_p, PCD_CMD, ~PCD_STAT_INT_1) ;
    }

    edt_ioctl(edt_p, EDTS_ABORTDMA_ONINTR, &flag) ;

    if (flag)
    {
        edt_reg_or(edt_p, PCD_CMD, PCD_STAT_INT_1 | PCD_ENABLE) ;
        edt_reg_or(edt_p, PCD_STAT_POLARITY, PCD_STAT_INT_ENA) ;
        edt_set_remote_intr(edt_p, TRUE);
    }
}

#endif                          /* PCD */



void
edt_flush_fifo(EdtDev * edt_p)
{
    uint_t  tmp;
    unsigned char cmd;
    unsigned char cfg;
    unsigned int dmy;

    edt_msg(EDTDEBUG, "edt_flush_fifo\n") ;
    /* Turn off the PCI fifo */
    tmp = edt_reg_read(edt_p, EDT_DMA_INTCFG);
    tmp &= (~EDT_RFIFO_ENB);
    edt_reg_write(edt_p, EDT_DMA_INTCFG, tmp);
    dmy = edt_reg_read(edt_p, EDT_DMA_INTCFG);

    if (edt_is_pcd(edt_p) || edt_p->devid == PDVAERO_ID)
    {
        /* reset the interface fifos */
        cmd = edt_intfc_read(edt_p, PCD_CMD);
        cmd &= ~PCD_ENABLE;
        edt_intfc_write(edt_p, PCD_CMD, cmd);
        dmy = edt_intfc_read(edt_p, PCD_CMD);
        cmd |= PCD_ENABLE;
        edt_intfc_write(edt_p, PCD_CMD, cmd);
        dmy = edt_intfc_read(edt_p, PCD_CMD);
    }
    else if (edt_is_pdv(edt_p))
    {
        if (edt_p->devid == PDVFOI_ID)
        {
            edt_p->foi_unit = edt_get_foiunit(edt_p);
            edt_init_mac8100(edt_p) ;
            edt_send_msg(edt_p, edt_p->foi_unit, "z", 1);
            edt_intfc_write(edt_p, PDV_CMD, PDV_RESET_INTFC);
        }
        else
        {
            int cont = edt_reg_read(edt_p, PDV_DATA_PATH) & PDV_CONTINUOUS;

            cfg = edt_intfc_read(edt_p, PDV_CFG);
            cfg &= ~PDV_FIFO_RESET;
            edt_intfc_write(edt_p, PDV_CFG, (u_char) (cfg | PDV_FIFO_RESET));
            edt_intfc_write(edt_p, PDV_CMD, PDV_RESET_INTFC);
            edt_intfc_write(edt_p, PDV_CFG, cfg);

            if (cont)
                edt_reg_or(edt_p,PDV_DATA_PATH, PDV_CONTINUOUS);
        }
    }


    /* Turn     on the PCI fifos, which flushes them */
    tmp |= (EDT_RFIFO_ENB);
    edt_reg_write(edt_p, EDT_DMA_INTCFG, tmp);
    dmy = edt_reg_read(edt_p, EDT_DMA_INTCFG);

}

uint_t
edt_get_bytecount(EdtDev * edt_p)
{
    uint_t  tmp;

    if (edt_ioctl(edt_p, EDTG_BYTECOUNT, &tmp) < 0)
        edt_msg_perror(EDTFATAL, "edt_ioctl(EDTG_BYTECOUNT)");

    return (tmp);
}

uint_t
edt_get_timeout_count(EdtDev * edt_p)
{
    uint_t  tmp;

    if (edt_ioctl(edt_p, EDTG_TIMECOUNT, &tmp) < 0)
        edt_msg_perror(EDTFATAL, "edt_ioctl(EDTG_TIMECOUNT)");

    return (tmp);
}
unsigned short
edt_get_direction(EdtDev * edt_p)
{
    unsigned short dirreg;

    /* Set the direction register for DMA output */
    dirreg = edt_intfc_read(edt_p, PCD_DIRA);
    dirreg |= edt_intfc_read(edt_p, PCD_DIRB) << 8;
    return (dirreg);
}

int
edt_cancel_current_dma(EdtDev * edt_p)
{
    unsigned int finish_current = 0;

    return edt_ioctl(edt_p, EDTS_STOPBUF, &finish_current);
}


void
edt_set_direction(EdtDev * edt_p, int direction)
{


    if (edt_is_pcd(edt_p) || edt_p->devid == PDVAERO_ID)
    {
        edt_ioctl(edt_p, EDTS_DIRECTION, &direction);
    }

    edt_p->last_direction = (direction) ? 2: 1;

}

/*
* EDT IOCTL Interface Routines
* 
* DESCRIPTION General   Purpose device control layer for EDT PCI and SBus
* interface products
* 
* All routines access a specific device, whose handle is created and returned
* by    the <device>_open() routine.
*/


#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif


int
edt_ioctl(EdtDev * edt_p, int code, void *arg)
{
    int     get, set;
    int     size;
    edt_ioctl_struct eis;
#ifdef __APPLE__
    int     ret ;
#endif

#if 0 /* produces too much output for the normal case, but may still be useful...*/
    edt_msg(EDTDEBUG, "edt_ioctl(%04x, %04x)\n", code, arg);
#endif

    if (edt_p->devid == DMY_ID)
        return (0);
    eis.device = edt_p->fd;
    eis.controlCode = EIO_DECODE_ACTION(code);
    size = EIO_DECODE_SIZE(code);
    set = EIO_DECODE_SET(code);
    get = EIO_DECODE_GET(code);
    eis.inSize = 0;
    eis.inBuffer = NULL;
    eis.outSize = 0;
    eis.outBuffer = NULL;
    eis.bytesReturned = 0 ;
#ifdef __APPLE__
    eis.channel = edt_p->channel_no ;
    eis.unit = edt_p->unit_no ;
#endif


    if (set)
    {
        eis.inSize = size;
        eis.inBuffer = arg;
    }

    if (get)
    {
        eis.outSize = size;
        eis.outBuffer = arg;
    }


#ifdef _NT_

    if (!DeviceIoControl(
        (HANDLE) edt_p->fd,
        EDT_MAKE_IOCTL(EDT_DEVICE_TYPE, eis.controlCode),
        eis.inBuffer,
        eis.inSize,
        eis.outBuffer,
        eis.outSize,
        &eis.bytesReturned,
        NULL))
    {
        return -1;
    }
    return 0;

#else
#ifdef VXWORKS
    return ioctl(edt_p->fd, EDT_NT_IOCTL, (int)&eis);
#else
#if defined(__APPLE__)

    eis.device = edt_p->channel_no ;
    ret = edt_mac_ioctl((u_int)edt_p->fd, EDT_NT_IOCTL, &eis) ;
    return(ret);
#else
    return ioctl(edt_p->fd, EDT_NT_IOCTL, &eis);
#endif /* apple */
#endif
#endif

}

int
edt_ioctl_nt(EdtDev * edt_p, int controlCode, void *inBuffer, int inSize,
             void *outBuffer, int outSize, int *bytesReturned)
{
    int     ret = 0;

    edt_ioctl_struct eis;

    eis.device = edt_p->fd;
    eis.controlCode = controlCode;
    eis.inBuffer = inBuffer;
    eis.inSize = inSize;
    eis.outBuffer = outBuffer;
    eis.outSize = outSize;
    eis.bytesReturned = 0;
#ifdef __APPLE__
    eis.channel = edt_p->channel_no ;
    eis.unit = edt_p->unit_no ;
#endif

#ifdef _NT_

    if (inSize == 0 && outSize == 0)
        return ret ;

    if (!DeviceIoControl(
        eis.device,
        eis.controlCode,
        eis.inBuffer,
        eis.inSize,
        eis.outBuffer,
        eis.outSize,
        &eis.bytesReturned,
        NULL))
    {

    }

#else
#ifdef VXWORKS
    if ((ret = ioctl(eis.device, EDT_NT_IOCTL, (int)&eis)) == 0)
#else /* vxworks */
#if defined(__APPLE__)
    if ((ret = edt_mac_ioctl((u_int)edt_p->fd, EDT_NT_IOCTL, &eis)) == 0)
#else
    if ((ret = ioctl(eis.device, EDT_NT_IOCTL, &eis)) == 0)
#endif /* apple */
#endif /* vxworks */
#endif /* nt */
    {
        *bytesReturned = eis.bytesReturned;
    }
    return ret;
}


uint_t
edt_debugval(EdtDev * edt_p)
{
    uint_t  debugval = 0;

    return (debugval);
}

int
edt_timeouts(EdtDev * edt_p)
{
    int     timeouts;

    if (edt_p->devid == DMY_ID)
        return (0);
    edt_ioctl(edt_p, EDTG_TIMEOUTS, &timeouts);
    return (timeouts);
}

int
edt_set_dependent(EdtDev * edt_p, void *addr)
{
    if (addr == NULL)
        return (-1);
    if (edt_p->devid == DMY_ID)
    {
#ifdef _NT_
        edt_p->fd = CreateFile(
            edt_p->edt_devname,
            GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ | FILE_SHARE_WRITE,
            NULL,
            OPEN_ALWAYS,
            FILE_ATTRIBUTE_NORMAL,
            NULL);
#else
        if (edt_p->fd)
        {
            /* printf("fd already open\n") ;*/
        }
        else
        {
            edt_p->fd = open(edt_p->edt_devname, O_RDWR, 0666);
        }
#endif
        edt_write(edt_p, addr, sizeof(Dependent));
#ifdef _NT_
        CloseHandle(edt_p->fd);
        edt_p->fd = NULL;
#else
        close(edt_p->fd);
        edt_p->fd = 0;
#endif
        return (0);
    }
    return (edt_ioctl(edt_p, EDTS_DEPENDENT, addr));
}

int
edt_get_dependent(EdtDev * edt_p, void *addr)
{
    if (addr == NULL)
        return (-1);
    if (edt_p->devid == DMY_ID)
    {
        int ret ;
#ifdef _NT_
        edt_p->fd = CreateFile(
            edt_p->edt_devname,
            GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ | FILE_SHARE_WRITE,
            NULL,
            OPEN_ALWAYS,
            FILE_ATTRIBUTE_NORMAL,
            NULL);
#else
        edt_p->fd = open(edt_p->edt_devname, O_RDWR, 0666);
#endif
        ret = edt_read(edt_p, addr, sizeof(Dependent));
#ifdef _NT_
        CloseHandle(edt_p->fd);
        edt_p->fd = NULL;
#else
        close(edt_p->fd);
        edt_p->fd = 0;
#endif
        if (ret != sizeof(Dependent))
            return (-1) ;
        return (0);
    }
    return (edt_ioctl(edt_p, EDTG_DEPENDENT, addr));
}

int
edt_dump_sglist( EdtDev * edt_p, int val)
{
    return (edt_ioctl(edt_p, EDTS_DUMP_SGLIST, &val));
}

int
edt_set_debug(EdtDev * edt_p, int val)
{
    return (edt_ioctl(edt_p, EDTS_DEBUG, &val));
}

int
edt_get_debug(EdtDev * edt_p)
{
    int     val;

    edt_ioctl(edt_p, EDTG_DEBUG, &val);
    return (val);
}

int
edt_set_rtimeout(EdtDev * edt_p, int value)
{
    edt_msg(EDTDEBUG, "edt_set_rtimeout(%d)\n", value);
    return edt_ioctl(edt_p, EDTS_RTIMEOUT, &value);
}

int
edt_set_wtimeout(EdtDev * edt_p, int value)
{
    edt_msg(EDTDEBUG, "edt_set_wtimeout(%d)\n", value);
    return edt_ioctl(edt_p, EDTS_WTIMEOUT, &value);
}

int
edt_get_rtimeout(EdtDev * edt_p)
{
    int     value;

    edt_ioctl(edt_p, EDTG_RTIMEOUT, &value);
    return (value);
}

int
edt_get_wtimeout(EdtDev * edt_p)
{
    int     value;

    edt_ioctl(edt_p, EDTG_WTIMEOUT, &value);
    return (value);
}

int
edt_get_tracebuf(EdtDev * edt_p, u_int * addr)
{
    if (addr == NULL)
        return (-1);
    return (edt_ioctl(edt_p, EDTG_TRACEBUF, addr));
}

u_short
edt_read_mac8100(EdtDev * edt_p, u_int add)
{
    u_int   read;

    read = edt_reg_read(edt_p, MAC8100_WORD | (add & 0xff));
    return (read & 0xffff);
}

void
edt_write_mac8100(EdtDev * edt_p, u_int add, u_short data)
{
    edt_reg_write(edt_p, MAC8100_WORD | (add & 0xff), data);
}

void
edt_send_dma(EdtDev * edt_p, int unit, u_int start_val)
{
    u_int   stat;
    int     loop = 0;

    stat = edt_reg_read(edt_p, FOI_WR_MSG_STAT);
    while ((stat & FOI_MSG_BSY) != 0)
    {
        if (loop++ > 1000000)
        {
            edt_msg(EDTDEBUG, "failed send dma stat %x\n", stat);
            return;
        }
        stat = edt_reg_read(edt_p, FOI_WR_MSG_STAT);
    }
    /* routing byte */
    edt_reg_write(edt_p, FOI_WR_MSG_DATA, 0x00 | (unit & 0x1f));
    while ((stat & FOI_TX_FIFO_FULL) == 0)
    {
        edt_reg_write(edt_p, FOI_WR_MSG_DATA, start_val++);

        stat = edt_reg_read(edt_p, FOI_WR_MSG_STAT);
    }
    edt_reg_write(edt_p, FOI_WR_MSG_STAT, FOI_MSG_SEND);
}

#define END_MARKER      0xffff
static u_short init_mac8100_data[] = {
    0, 0x0,
    1, 0x0,
    2, 0x0,
    3, 0x0,
    4, 0x0,
    5, 0x0,
    6, 0x0,
    7, 0x07c2,
    /* 7, 0x7d8 */ /* this inserts status and crc */
    /* 7, 0x07ca,*/
    8, 0x0ec0,
    /* 8, 0x800,*/ /* 800 to accept all packets */
    9, 0x2400, /* autoclear RXDC, counters roll */
    11, 0x0000,
    14, 0x8800,
    17, 0x843f,
    18, 0x0000,
    /* 18, 0x4000 */ /* sets receive fifo watermark 1,2 */
    19, 0x4000,
    20, 0x001f,
    21, 0x0000,
    END_MARKER, 0x0000
};

static u_short init_mac8101_data[] = {
    7,  0x03e1,
    8,  0x0ec0,
    9,  0x2400, /* autoclear RXDC, counters roll */
    10, 0x0000,
    17, 0xf43e,
    18, 0xf080,
    19, 0x4000,
    END_MARKER, 0x0000
};

void
edt_init_mac8100(EdtDev * edt_p)
{

    int is_mac8101;

    u_short *init_tab = init_mac8100_data;
    u_int   tmpcfg;

    /* enable mac8100 */
    tmpcfg = edt_reg_read(edt_p, EDT_DMA_CFG);
    edt_reg_write(edt_p, EDT_DMA_CFG, tmpcfg | 0x200);
    edt_msleep(2) ;

    /* do reset */
    edt_write_mac8100(edt_p, 7, 0x8000) ;
    /* self clears in 1 usec */
    edt_msleep(2) ;


    /* read a xilinx register? */
    (void) edt_reg_read(edt_p, FOI_MSG);

    /* read part ID */
    is_mac8101 = edt_read_mac8100(edt_p, 32) & 0x1000;

    if (! is_mac8101)  {
        init_tab = init_mac8100_data;                   /* for old 5v PCIFOI */
    }
    else
    {
        init_tab = init_mac8101_data;                   /* for new 3v PCIFOI */
        edt_reg_write(edt_p, 0x010000c5, 0x02);         /* clr fifo's, inrpts */
        edt_reg_write(edt_p, 0x040000d4, 0x80000000);   /* reset Xilinx */
        edt_reg_write(edt_p, 0x040000d4, 0x36000000);   /* RXRBDIR + RXBUIG */
    }


    while (*init_tab != END_MARKER)
    {
        edt_write_mac8100(edt_p, (u_int) * init_tab, *(init_tab + 1));
        init_tab += 2;
    }
    /* reset message fifos */
    edt_reg_write(edt_p, FOI_WR_MSG_STAT, FOI_FIFO_FLUSH);

}



int
edt_send_msg(EdtDev * edt_p, int unit, const char *msg, int size)
{
    int dummy ;
    ser_buf ser ;
    ser.unit = unit ;
    ser.size = size ;
    ser.flags = EDT_SERIAL_SAVERESP ;
    memcpy(ser.buf,msg,size) ;

    edt_ioctl_nt(edt_p, ES_SERIAL, &ser, size + EDT_SERBUF_OVRHD,
        NULL, 0, &dummy);
    return (0);
}

int
edt_get_msg_unit(EdtDev * edt_p, char *msgbuf, int maxsize, int unit)
{
    ser_buf ser ;
    int     bytes = 0;
    ser.unit = unit ;
    ser.size = maxsize ;

    edt_ioctl_nt(edt_p, EG_SERIAL, &ser, EDT_SERBUF_OVRHD,
        msgbuf, maxsize, &bytes);
    if (bytes < maxsize)
        msgbuf[bytes] = '\0';
    return (bytes);
}

int
edt_get_msg(EdtDev * edt_p, char *msgbuf, int maxsize)
{
    if (edt_p->devid == PDVFOI_ID)
        return(edt_get_msg_unit(edt_p, msgbuf, maxsize, edt_p->foi_unit)) ;
    else if (edt_is_dvcl(edt_p) || edt_is_dvfox(edt_p) || edt_p->devid == PDVAERO_ID)
        return(edt_get_msg_unit(edt_p, msgbuf, maxsize, edt_p->channel_no)) ;
    else return(edt_get_msg_unit(edt_p, msgbuf, maxsize, 0)) ;
}


void
edt_check_foi(EdtDev * edt_p)
{
    int     retval = 0;
    char    msgbuf[256];
    int     foicount;
    int     loop = 0;

    if (edt_p->devid == PDVFOI_ID)
    {
        int     count = edt_get_foicount(edt_p);

        if (count)
        {
            edt_msg(EDTDEBUG, "foi_count %d cur unit %d\n", count, edt_p->foi_unit);
        }
        else while (retval == 0)
        {
            char   *tmpp = msgbuf;

            if (loop)
                edt_msleep(1000);

            edt_msg(EDTDEBUG, "foi count 0 - doing autoconfig\n");
            edt_reset_serial(edt_p);
            edt_init_mac8100(edt_p);
            edt_msleep(100);
#if 1
            /* for now -  to flush full mac8101 receive fifo on pcifoi mac8100 hw reset */
            /*  - send to unit 14 so no response */
            edt_send_msg(edt_p, 0x2e, "b", 1);
            edt_serial_wait(edt_p, 100, 0) ;
            edt_msleep(100);
#endif
            edt_send_msg(edt_p, 0x3f, "A", 1);
            edt_serial_wait(edt_p, 100, 0) ;
            /*
            * give rci time to turn off passthru (~1ms)
            */
            edt_msleep(100);
            /* assign first rci in path as unit 0 */
            edt_send_msg(edt_p, 0x3f, "U 0", 3);
            edt_serial_wait(edt_p, 100, 0) ;
            retval = 0;
            foicount = 0;
            edt_msleep(1000);
            /* default to 0 */
            edt_set_foiunit(edt_p, 0);

            edt_msleep(100);
            retval = edt_get_msg(edt_p, msgbuf, sizeof(msgbuf));
            if (retval != 0)
            {
                while (tmpp < &tmpp[retval - 4])
                {
                    edt_msg(EDTDEBUG, "string <%s>\n", tmpp);
                    if (tmpp[0] == 0x3f && tmpp[1] == 'U' && tmpp[2] == ' ')
                    {
                        foicount = atoi(&tmpp[3]);
                        edt_msg(EDTDEBUG, "setting foi count to %d\n", foicount);
                        edt_set_foicount(edt_p, foicount);
                        break;
                    }
                    tmpp++;
                }
            }
            if (loop++ > 3)
            {
                edt_msg(EDTDEBUG, "leaving checkfoi without response\n");
                return;
            }
            edt_msleep(1000);

            edt_msg(EDTDEBUG, "done with auto config\n");
            edt_send_msg(edt_p, 0, "i", 1);
            edt_msleep(100);
            edt_get_msg(edt_p, msgbuf, sizeof(msgbuf));
            edt_send_msg(edt_p, 0, "z", 1);
            edt_msleep(100);
            edt_get_msg(edt_p, msgbuf, sizeof(msgbuf));
            edt_msg(EDTDEBUG, "done with init and flush\n");
        }
    }
}

int
edt_set_statsig(EdtDev * edt_p, int event, int sig)
{
    edt_buf buf;

    buf.desc = event;
    buf.value = sig;
    return (edt_ioctl(edt_p, EDTS_EVENT_SIG, &buf));
}

int
edt_set_eodma_int(EdtDev * edt_p, int sig)
{
    return (edt_ioctl(edt_p, EDTS_EODMA_SIG, &sig));
}

int
edt_set_autodir(EdtDev * edt_p, int val)
{
    return (edt_ioctl(edt_p, EDTS_AUTODIR, &val));
}

int
edt_set_firstflush(EdtDev * edt_p, int flag)
{
    return (edt_ioctl(edt_p, EDTS_FIRSTFLUSH, &flag));
}


int
edt_get_firstflush(EdtDev * edt_p)
{

    int val;

    edt_ioctl(edt_p, EDTG_FIRSTFLUSH, &val);

    return val;
}


u_char
edt_set_funct_bit(EdtDev * edt_p, u_char mask)
{
    unsigned char funct;

    funct = edt_reg_read(edt_p, PCD_FUNCT);
    funct |= mask;
    edt_reg_write(edt_p, PCD_FUNCT, funct);
    return (funct);
}

u_char
edt_clr_funct_bit(EdtDev * edt_p, u_char mask)
{
    u_char  funct;

    funct = edt_reg_read(edt_p, PCD_FUNCT);
    funct &= ~mask;
    edt_reg_write(edt_p, PCD_FUNCT, funct);
    return (funct);
}


static void
shft_av9110(EdtDev * edt_p, u_int data, u_int numbits)
{
    int use_pcd_method;

    if (ID_IS_PCD(edt_p->devid) || edt_p->devid == PDVAERO_ID)
        use_pcd_method = 1;
    else
        use_pcd_method = 0;

    while (numbits)
    {
        if (use_pcd_method)
        {
            if (data & 0x1)
                edt_set_funct_bit(edt_p, EDT_FUNCT_DATA);
            else
                edt_clr_funct_bit(edt_p, EDT_FUNCT_DATA);
            /* clock it in */
            edt_set_funct_bit(edt_p, EDT_FUNCT_CLK);
            edt_clr_funct_bit(edt_p, EDT_FUNCT_CLK);
        }
        else
        {
            if (data & 0x1)
                edt_set_pllct_bit(edt_p, EDT_FUNCT_DATA);
            else
                edt_clr_pllct_bit(edt_p, EDT_FUNCT_DATA);
            /* clock it in */
            edt_set_pllct_bit(edt_p, EDT_FUNCT_CLK);
            edt_clr_pllct_bit(edt_p, EDT_FUNCT_CLK);

        }
        data = data >> 1;
        numbits--;
    }
}

u_char
edt_set_pllct_bit(EdtDev * edt_p, u_char mask)
{
    unsigned char pll_ct;

    pll_ct = edt_reg_read(edt_p, PDV_PLL_CTL);
    pll_ct |= mask;
    edt_reg_write(edt_p, PDV_PLL_CTL, pll_ct);
    return (pll_ct);
}

u_char
edt_clr_pllct_bit(EdtDev * edt_p, u_char mask)
{
    u_char  pll_ct;

    pll_ct = edt_reg_read(edt_p, PDV_PLL_CTL);
    pll_ct &= ~mask;
    edt_reg_write(edt_p, PDV_PLL_CTL, pll_ct);
    return (pll_ct);
}

void
edt_set_out_clk(EdtDev * edt_p, edt_pll * clk_data)
{
    int use_pcd_method;

    unsigned char opt_e = 0;
    u_int   svfnct;

    if (ID_IS_PCD(edt_p->devid) || edt_p->devid == PDVAERO_ID)
        use_pcd_method = 1;
    else
        use_pcd_method = 0;

    switch (clk_data->h)
    {
    case 1:
        opt_e = EDT_FAST_DIV1;
        break;

    case 3:
        opt_e = EDT_FAST_DIV3;
        break;

    case 5:
        opt_e = EDT_FAST_DIV5;
        break;

    case 7:
        opt_e = EDT_FAST_DIV7;
        break;

    default:
        edt_msg(EDTDEBUG, "Illegal value %d for xilinx fast clk divide\n",
            clk_data->h);
        opt_e = EDT_FAST_DIV1;
        clk_data->h = 1;
        break;
    }
    opt_e |= ((clk_data->l - 1) << EDT_X_DIVN_SHFT);


    if (use_pcd_method)
    {
        edt_reg_write(edt_p, EDT_OUT_SCALE, opt_e);
        edt_reg_write(edt_p, EDT_REF_SCALE, clk_data->x - 1);
        svfnct = edt_reg_read(edt_p, PCD_FUNCT);
        edt_set_funct_bit(edt_p, EDT_FUNCT_SELAV);
        edt_clr_funct_bit(edt_p, EDT_FUNCT_CLK);


    }
    else
    {
        edt_reg_write(edt_p, PDV_OUT_SCALE, opt_e);
        edt_reg_write(edt_p, PDV_REF_SCALE, clk_data->x - 1);
        svfnct = edt_reg_read(edt_p, PDV_PLL_CTL);
        edt_set_pllct_bit(edt_p, EDT_FUNCT_SELAV);
        edt_clr_pllct_bit(edt_p, EDT_FUNCT_CLK);

    }


    svfnct &= ~EDT_FUNCT_SELAV;  /* Must turn this off when done - jerry */

    /* shift out data */
    shft_av9110(edt_p, clk_data->n, 7);
    shft_av9110(edt_p, clk_data->m, 7);
    /* set vco preescale */
    if (clk_data->v == 1)
        shft_av9110(edt_p, 0, 1);
    else
        shft_av9110(edt_p, 1, 1);
    /* clkx divide is not used (right now) so set to div 1 */
    switch (clk_data->r)
    {
    case 1:
        shft_av9110(edt_p, 0x170, 9);
        break;

    case 2:
        shft_av9110(edt_p, 0x174, 9);
        break;

    case 4:
        shft_av9110(edt_p, 0x178, 9);
        break;

    case 8:
        shft_av9110(edt_p, 0x17c, 9);
        break;

    default:
        edt_msg(EDTDEBUG, "illegal value %d for AV9110 aoutput divide\n",
            clk_data->r);
        shft_av9110(edt_p, 0x5c, 7);
        break;
    }
    /* restore fnct bits */

    if (use_pcd_method)
        edt_reg_write(edt_p, PCD_FUNCT, svfnct);
    else
        edt_reg_write(edt_p, PDV_PLL_CTL, svfnct);

}

u_int
edt_set_sglist(EdtDev *edt_p, 
               uint_t bufnum, 
               uint_t *log_list,
               uint_t log_entrys)
{
    int ret ;
    buf_args sg_args ;
    sg_args.index = bufnum ;
    sg_args.size = log_entrys ;
#ifdef WIN32
    sg_args.addr = (uint64_t) (log_list);
#else
    sg_args.addr = (uint64_t) ((unsigned long) log_list);
#endif
    ret = edt_ioctl(edt_p, EDTS_SGLIST, &sg_args);

    return ret;
}

u_int
edt_set_sgbuf(EdtDev * edt_p, u_int sgbuf, u_int bufsize, u_int bufdir, u_int verbose)
{
    edt_set_buffer_size(edt_p, sgbuf, bufsize, bufdir) ;
    return 0;
}

int
edt_set_timeout_action(EdtDev * edt_p, u_int action)

{

    if (!edt_p)
    {
        return -1;

    }

    edt_ioctl(edt_p, EDTS_TIMEOUT_ACTION, &action);

    return 0;
}

int
edt_get_timeout_goodbits(EdtDev * edt_p)

{

    u_int   nGoodBits;

    if (!edt_p)
    {
        return 0;
    }

    edt_ioctl(edt_p, EDTG_TIMEOUT_GOODBITS, &nGoodBits);

    return nGoodBits;
}

int
edt_get_goodbits(EdtDev * edt_p)

{

    u_int   nGoodBits;

    if (!edt_p)
    {
        return 0;
    }

    edt_ioctl(edt_p, EDTG_GOODBITS, &nGoodBits);

    return nGoodBits;
}

#ifdef _NT_

int
edt_get_kernel_event(EdtDev *edt_p, int event_type)

{
    EdtEventHandler *p;
    char    fullname[128];
    char   *Name;
    char *edt_devname;

    if (edt_p == NULL 
        || (event_type < 0)
        || (event_type >= EDT_MAX_KERNEL_EVENTS)
        || ((Name = BaseEventNames[event_type]) == NULL)
        || ((p = &edt_p->event_funcs[event_type]) == NULL))
    {
        /* out of range */
        edt_msg(EDTDEBUG, "Invalid argument to edt_get_kernel_event\n");
        return -1;
    }

    switch(edt_p->devid)
    {
    case P11W_ID:
        edt_devname = "P11w";
        break;

    case P16D_ID:
        edt_devname = "P16d";
        break;

    case PCD20_ID:
    case PCD40_ID:
    case PCD60_ID:
    case PCD_16_ID:
    case PGP20_ID:
    case PGP40_ID:
    case PGP60_ID:
    case PGP_ECL_ID:
    case PSS4_ID:
    case PSS16_ID:
    case PGS4_ID:
    case PGS16_ID:
    case PCDA_ID:
    case PCDCL_ID:
    case PCDA16_ID:
    case PCDFCI_SIM_ID:
    case PCDFCI_PCD_ID:
    case PCDFOX_ID:
    case PE8LX1_ID:
    case PE8LX16_LS_ID:
    case PE8LX16_ID:
    case PE8LX64_ID:
    case PE4AMC16_ID:
         
        edt_devname = "Pcd";
        break;

    case PDV_ID:
    case PDVA_ID:
    case PDVA16_ID:
    case PGP_RGB_ID:
    case PDVK_ID:
    case PDVCL_ID:
    case PDVCL2_ID:
    case PE4DVCL_ID:
    case PE4DVFOX_ID:
    case PE8DVCL_ID:
    case PE8DVCLS_ID:
    case PE8DVFOX_ID:
    case PDV44_ID:
    case PDVFOI_ID:
    case PDVFCI_AIAG_ID:
    case PDVFCI_USPS_ID:
    case PDVFOX_ID:
    case PDVAERO_ID:
        edt_devname = "Pdv";
        break;

    case P53B_ID:
        edt_devname = "P53b";
        break;

    default:
        edt_devname = NULL;
        edt_msg(EDTDEBUG, "Unknown device type %d\n", edt_p->devid);
        return -1;

    }

    sprintf(fullname, "%s%s%d%d", edt_devname, Name, edt_p->unit_no, edt_p->channel_no);

    if ((p->wait_event =
        CreateEvent(NULL, FALSE, FALSE,fullname)) == NULL)
    {
        if ((p->wait_event =
            OpenEvent(SYNCHRONIZE, FALSE, fullname)) == NULL)
        {

            edt_msg(EDTDEBUG, "Unable to open event %s\n", fullname);
            edt_msg_perror(EDTFATAL, "event") ;

            return -1;

        }
        else
        {
            ResetEvent(p->wait_event) ;
            return(0) ;
        }

    }
    else
    {
        edt_buf argbuf ;
        argbuf.desc = event_type ;
        argbuf.value = (uint64_t)p->wait_event ;
        edt_ioctl(edt_p, EDTS_EVENT_HNDL, &argbuf);
        ResetEvent(p->wait_event) ;
    }

    return 0;

}

/********************************************************
* Close everything and zero memory
********************************************************/

static
void
edt_clear_event_func(EdtEventHandler * p)

{
    if (p->wait_thread)
        CloseHandle(p->wait_thread);
    if (p->wait_event)
        CloseHandle(p->wait_event);
    if (p->closing_event)
        CloseHandle(p->closing_event);

    memset(p, 0, sizeof(*p));

}

/********************************************************/
/* Thread function to wait on a particular driver event */
/********************************************************/

static u_int WINAPI
edt_wait_event_thread(void *pObj)
{
    EdtEventHandler *p = (EdtEventHandler *) pObj;
    int     rc = WAIT_OBJECT_0;
    HANDLE  events[2];
    u_int   tmp;


    if (p)
    {
        events[0] = p->wait_event;
        events[1] = p->closing_event;

        while (p->active)
        {

#ifndef NEW_WAY
            rc = WaitForMultipleObjects(2, events, FALSE, INFINITE);
#else

            edt_ioctl(p->owner, EDTS_WAIT_EVENT, &p->event_type);
#endif

            if (p->active && rc == WAIT_OBJECT_0)
            {
                edt_ioctl(p->owner, EDTS_CLR_EVENT, &p->event_type);

                if (p->callback)
                    p->callback(p->data);

            }

            if (p->continuous == 0)
            {
                edt_ioctl(p->owner, EDTS_DEL_EVENT_FUNC, &p->event_type);

                /* May need this later -- Mark 01/99 */
                tmp = p->thrdid;
                /*p->active = 0 ;*/
                edt_clear_event_func(p);
                p->thrdid = tmp;

                break;
            }
        }
    }
    return 0;
}

/* ****************************************************** */
/* Add an event function for an event_type               */
/* Name is derived from event type -                     */
/* only works for "base events" defined for all boards   */
/* ****************************************************** */

int
edt_set_event_func(EdtDev * edt_p, int event_type, EdtEventFunc func, void *data,
                   int continuous)
{
    EdtEventHandler *p;
    char   *Name;
    HANDLE event;

    edt_msg(EDTDEBUG, "edt_set_event_func(type %d cont %d)\n", event_type, continuous);

    if (edt_p == NULL || (func == NULL)
        || (event_type < 0)
        || (event_type >= EDT_MAX_KERNEL_EVENTS)
        || ((Name = BaseEventNames[event_type]) == NULL)
        || ((p = &edt_p->event_funcs[event_type]) == NULL))
    {
        /* out of range */
        return -1;
    }


    if (p->callback)
    {
        /* whoops - we're already going */

        /* if it's the same callback, no problem */

        if (p->callback == func && p->data == data)
            return 0;
        else
            return -1;
    }

    /* Set the function */
    p->callback = func;
    /* Set the data */
    p->data = data;

    p->owner = edt_p;
    p->active = TRUE;
    p->event_type = event_type;
    p->continuous = continuous;


    /* Unlock */

    /* Launch the thread */


    edt_get_kernel_event(edt_p, event_type) ;
    event = edt_p->event_funcs[event_type].wait_event;

    if (event == NULL)
    {
        edt_clear_event_func(p);
        return -1;

    }

    if ((p->closing_event = CreateEvent(NULL, TRUE, FALSE, NULL)) == NULL)
    {
        edt_clear_event_func(p);
        return -1;
    }

    if ((p->wait_thread = (thread_t)
        _beginthreadex(NULL, 0, edt_wait_event_thread, p, CREATE_SUSPENDED,
        &p->thrdid)) == NULL)
    {
        edt_clear_event_func(p);
        return -1;
    }

    /*
    * The continuous parameter now supports one of three modes:
    *
    *           EDT_EVENT_MODE_ONCE             (0)
    *           EDT_EVENT_MODE_CONTINUOUS       (1)
    *           EDT_EVENT_MODE_SERIALIZE        (2)
    *
    * The mode is passed to the driver in the high byte of event_type.
    */
    event_type |= ((continuous << EDT_EVENT_MODE_SHFT) & EDT_EVENT_MODE_MASK) ;
    edt_ioctl(edt_p, EDTS_ADD_EVENT_FUNC, &event_type);
    event_type &= ~EDT_EVENT_MODE_MASK ;

    ResumeThread(p->wait_thread);

    /*SetThreadPriority(p->wait_thread, THREAD_PRIORITY_HIGHEST);*/

    return 0;
}

int
edt_remove_event_func(EdtDev * edt_p, int event_type)

{
    EdtEventHandler *p;

    if (edt_p == NULL || event_type < 0 || event_type >= EDT_MAX_KERNEL_EVENTS)
    {
        /* out of range */
        return -1;
    }

    p = &edt_p->event_funcs[event_type];

    /*
    * Try and close the thread gracefully
    */

    if (p->wait_thread && p->wait_event)
    {
        p->active = FALSE;

        SetEvent(p->closing_event);

        edt_ioctl(edt_p, EDTS_DEL_EVENT_FUNC, &event_type);

        WaitForSingleObject(p->wait_thread, INFINITE);

        edt_clear_event_func(p);

    }else
        edt_clear_event_func(p);

    return 0;
}

#elif defined(__sun)            /* _NT_ */

/* *******************************************************/
/* Add an event function for an event_type               */
/* Name is derived from event type                       */
/* - only works for "base events" defined for all boards */
/* *******************************************************/

int
edt_set_event_func(EdtDev * edt_p, int event_type, EdtEventFunc f, void *data,
                   int continuous)
{
    EdtEventHandler *p;
    char    fullname[128];
    char   *Name;


    if (edt_p == NULL || (f == NULL)
        || (event_type < 0)
        || (event_type >= EDT_MAX_KERNEL_EVENTS)
        || ((Name = BaseEventNames[event_type]) == NULL)
        || ((p = &edt_p->event_funcs[event_type]) == NULL))
    {
        /* out of range */
        return -1;
    }

    if (p->active && p->callback)
    {
        /* whoops - we're already going */
        edt_remove_event_func(edt_p, event_type);
    }
    /*
    * Solaris:  if another thread has run for this event, wait for it.
    * Otherwise it stays alive and uses mmap() resources.  Mark  01/99
    */
    else if (p->thrdid)
        thr_join(p->thrdid, NULL, NULL);

    /* Set the function */
    p->callback = f;
    /* Set the data */
    p->data = data;

    p->owner = edt_p;
    p->active = TRUE;
    p->event_type = event_type;
    p->continuous = continuous;

    sema_init(&p->sema_thread, 0, USYNC_PROCESS, NULL);

    /*
    * The continuous parameter now supports one of three modes:
    *
    *           EDT_EVENT_MODE_ONCE             (0)
    *           EDT_EVENT_MODE_CONTINUOUS       (1)
    *           EDT_EVENT_MODE_SERIALIZE        (2)
    *
    * The mode is passed to the driver in the high byte of event_type.
    */
    event_type |= ((continuous << EDT_EVENT_MODE_SHFT) & EDT_EVENT_MODE_MASK) ;
    edt_ioctl(edt_p, EDTS_ADD_EVENT_FUNC, &event_type);
    event_type &= ~EDT_EVENT_MODE_MASK ;

    /* Launch the thread */

    sprintf(fullname, "%s%d%d", Name, edt_p->unit_no, edt_p->channel_no);
    if (thr_create(NULL, 0, edt_wait_event_thread, (void *) p,
        THR_NEW_LWP | THR_BOUND, &p->thrdid))
    {
        edt_msg_perror(EDTFATAL, "edt_set_event_func: thr_create");
        edt_msg(EDTWARN, "Unable to create eventthread %s\n", fullname);
        edt_msg(EDTWARN, "thr_create:  use \"-lthread\" compile option\n", stderr);
        return -1;
    }

    sema_wait(&p->sema_thread);
    thr_yield();

    return 0;
}

/********************************************************/
/* Close everything and zero memory                      */
/********************************************************/

static
void
edt_clear_event_func(EdtEventHandler * p)

{
    /* TODO - anything else need to be done here for solaris?  -- Mark 01/99 */
    memset(p, 0, sizeof(*p));
}


/********************************************************/
/* Thread function to wait on a particular driver event */
/********************************************************/

static void *
edt_wait_event_thread(void *pObj)

{
    EdtEventHandler *p = (EdtEventHandler *) pObj;
    thread_t tmp;
    int     ret;

#ifdef __sun
    if (p->owner->use_RT_for_event_func)
        edt_set_RT(1) ;         /* This isn't a good idea unless
                                * you really can't live without it.  - Mark
                                */
#endif

    if (p)
    {
        while (p->active)
        {
            sema_post(&p->sema_thread);
            if (p->continuous == 0)
                edt_ioctl(p->owner, EDTS_WAIT_EVENT_ONCE, &p->event_type);
            else
                edt_ioctl(p->owner, EDTS_WAIT_EVENT, &p->event_type);

            if (p->active && p->callback)
                p->callback(p->data);

            if (p->continuous == 0)
            {
                edt_ioctl(p->owner, EDTS_DEL_EVENT_FUNC, &p->event_type);

                /* Need this later for thr_join() in set_event_func() */
                tmp = p->thrdid;
                edt_clear_event_func(p);
                p->thrdid = tmp;

                break;
            }
        }
    }

    thr_exit(NULL);

    return pObj;
}

/* *******************************************************/
/* Delete an event handler                               */
/* *******************************************************/

int
edt_remove_event_func(EdtDev * edt_p, int event_type)
{
    EdtEventHandler *p;

    if (edt_p == NULL || event_type < 0 || event_type >= EDT_MAX_KERNEL_EVENTS)
    {
        /* out of range */
        return -1;
    }

    p = &edt_p->event_funcs[event_type];

    /*
    * Try and close the thread gracefully
    */

    if (p->active)
    {
        p->active = FALSE;

        edt_ioctl(edt_p, EDTS_DEL_EVENT_FUNC, &event_type);

        thr_join(p->thrdid, NULL, NULL);

        edt_clear_event_func(p);
    }

    return 0;
}
#elif defined(sgi) || defined(__linux__) || defined(__APPLE__)

#ifndef NO_PTHREAD

#include <pthread.h>

/* *******************************************************/
/* Add an event function for an event_type               */
/* Name is derived from event type                       */
/* - only works for "base events" defined for all boards */
/* *******************************************************/

int
edt_set_event_func(EdtDev * edt_p, int event_type, EdtEventFunc f, void *data,
                   int continuous)
{
    EdtEventHandler *p;
    char    fullname[128];
    char   *Name;


    if (edt_p == NULL || (f == NULL)
        || (event_type < 0)
        || (event_type >= EDT_MAX_KERNEL_EVENTS)
        || ((Name = BaseEventNames[event_type]) == NULL)
        || ((p = &edt_p->event_funcs[event_type]) == NULL))
    {
        /* out of range */
        return -1;
    }

    if (p->active && p->callback)
    {
        /* whoops - we're already going */
        edt_remove_event_func(edt_p, event_type);
    }
    /*
    * pthreads:  if another thread has run for this event, wait for it.
    * Otherwise it stays alive and uses mmap() resources.  Mark  01/99
    */
    else if (p->thrdid)
        pthread_join(p->thrdid, NULL);

    /* Set the function */
    p->callback = f;
    /* Set the data */
    p->data = data;

    p->owner = edt_p;
    p->active = TRUE;
    p->event_type = event_type;
    p->continuous = continuous;


    /* sema_init(&p->sema_thread, 0, USYNC_PROCESS, NULL); */

    /*
    * The continuous parameter now supports one of three modes:
    *
    *           EDT_EVENT_MODE_ONCE             (0)
    *           EDT_EVENT_MODE_CONTINUOUS       (1)
    *           EDT_EVENT_MODE_SERIALIZE        (2)
    *
    * The mode is passed to the driver in the high byte of event_type.
    */
    event_type |= ((continuous << EDT_EVENT_MODE_SHFT) & EDT_EVENT_MODE_MASK) ;
    edt_ioctl(edt_p, EDTS_ADD_EVENT_FUNC, &event_type);
    event_type &= ~EDT_EVENT_MODE_MASK ;

    /* Launch the thread */

    sprintf(fullname, "%s%d%d", Name, edt_p->unit_no, edt_p->channel_no);
    if (pthread_create(&p->thrdid, 0, edt_wait_event_thread, (void *) p)
        != 0)
    {
        edt_msg_perror(EDTFATAL, "edt_set_event_func: thr_create");
        edt_msg(EDTWARN, "Unable to create eventthread %s\n", fullname);
        edt_msg(EDTWARN, "thr_create:  use \"-lthread\" compile option\n", stderr);
        return -1;
    }

    /* sema_wait(&p->sema_thread); */
    /* thr_yield(); */

    return 0;
}

/********************************************************/
/* Close everything and zero memory                      */
/********************************************************/

static
void
edt_clear_event_func(EdtEventHandler * p)

{
    /* TODO - anything else need to be done here for solaris?  -- Mark 01/99 */
    memset(p, 0, sizeof(*p));
}


/********************************************************/
/* Thread function to wait on a particular driver event */
/********************************************************/

static void *
edt_wait_event_thread(void *pObj)

{
    EdtEventHandler *p = (EdtEventHandler *) pObj;
    pthread_t tmp;

    if (p)
    {
        while (p->active)
        {
            /* sema_post(&p->sema_thread); */
            if (p->continuous == 0)
                edt_ioctl(p->owner, EDTS_WAIT_EVENT_ONCE, &p->event_type);
            else
                edt_ioctl(p->owner, EDTS_WAIT_EVENT, &p->event_type);

            if (p->active && p->callback)
                p->callback(p->data);

            if (p->continuous == 0)
            {
                edt_ioctl(p->owner, EDTS_DEL_EVENT_FUNC, &p->event_type);

                /* Need this later for thr_join() in set_event_func() */
                tmp = p->thrdid;
                edt_clear_event_func(p);
                p->thrdid = tmp;

                break;
            }
        }
    }

    pthread_exit(NULL);

    return pObj;
}

/* *******************************************************/
/* Delete an event handler                               */
/* *******************************************************/

int
edt_remove_event_func(EdtDev * edt_p, int event_type)
{
    EdtEventHandler *p;

    if (edt_p == NULL || event_type < 0 || event_type >= EDT_MAX_KERNEL_EVENTS)
    {
        /* out of range */
        return -1;
    }

    p = &edt_p->event_funcs[event_type];

    /*
    * Try and close the thread gracefully
    */

    if (p->active)
    {
        p->active = FALSE;

        edt_ioctl(edt_p, EDTS_DEL_EVENT_FUNC, &event_type);

        pthread_join(p->thrdid, NULL);

        edt_clear_event_func(p);
    }

    return 0;
}
#endif   /* NOT PTHREAD */

#elif defined(_AIX) || defined(__hpux)

/* *******************************************************
* Add an event function for an event_type
* Name is derived from event type - only works
* for "base events" defined for all boards
* *******************************************************/

int
edt_set_event_func(EdtDev * edt_p, int event_type, EdtEventFunc f, void *data,
                   int continuous)
{
    return -1;
}

/********************************************************
* Close everything and zero memory
********************************************************/

static
void
edt_clear_event_func(EdtEventHandler * p)

{

}


/********************************************************
* Thread function to wait on a particular driver event *
********************************************************/

static void *
edt_wait_event_thread(void *pObj)

{
    return NULL;
}

/* *******************************************************
* Delete an event handler                                                               *
* *******************************************************/

int
edt_remove_event_func(EdtDev * edt_p, int event_type)
{
    return -1;
}

#else

int
edt_remove_event_func(EdtDev * edt_p, int event_type)
{
    return -1;
}

#endif                          /* _NT_ */

int
edt_enable_event(EdtDev * edt_p, int event_type)
{
    edt_msg(EDTDEBUG, "edt_enable_event(type %d)\n", event_type) ;

    if (edt_p == NULL 
        || (event_type < 0)
        || (event_type >= EDT_MAX_KERNEL_EVENTS))
    {
        /* out of range */
        return -1;
    }

#ifdef _NT_
    edt_get_kernel_event(edt_p, event_type) ;
#endif

    edt_ioctl(edt_p, EDTS_ADD_EVENT_FUNC, &event_type);

    return 0 ;
}

int
edt_wait_event(EdtDev * edt_p, int event_type, int timeoutval)
{
    int ret = 0 ;
    edt_msg(EDTDEBUG, "edt_wait_event(type %d)\n", event_type) ;
#ifdef _NT_
    {
        HANDLE event;
        int rc;

        if (!edt_p->event_funcs[event_type].wait_event)
        {
            edt_get_kernel_event(edt_p, event_type);
        }

        event = edt_p->event_funcs[event_type].wait_event;

        /* wait for event */

        if (timeoutval == 0)
            timeoutval = INFINITE;

        rc = WaitForSingleObject(event, timeoutval);

        if (rc == WAIT_TIMEOUT)
        {
            /* edt_msg(EDTDEBUG, "timeout...\n");*/

            /* deal with timeout */

            edt_do_timeout(edt_p);

            ret = 1 ;
        }
    }
#else
    edt_ioctl(edt_p, EDTS_WAIT_EVENT, &event_type);
#endif

    edt_msg(EDTDEBUG, "edt_wait_event(type %d)\n", event_type, ret) ;

    return(ret) ;
}


int
edt_reset_event_counter(EdtDev * edt_p, int event_type)
{
    return edt_ioctl(edt_p, EDTS_RESET_EVENT_COUNTER, &event_type);
}



int
edt_stop_buffers(EdtDev * edt_p)

{
    unsigned int finish_current = 1;

    edt_msg(EDTDEBUG, "edt_stop_buffers\n");
    edt_ioctl(edt_p, EDTS_STOPBUF, &finish_current);
    return 0;
}

int
edt_reset_ring_buffers(EdtDev * edt_p, uint_t bufnum)

{
    bufcnt_t     curdone;
    int     curbuf = -1;

    curdone = edt_done_count(edt_p);
    edt_cancel_current_dma(edt_p);
    if (edt_p->ring_buffer_numbufs)
    {
        curbuf = curdone % edt_p->ring_buffer_numbufs;
        edt_set_buffer(edt_p, bufnum);
    }
    edt_msg(EDTDEBUG, "edt_reset_ring_buffers buf %d curdone %d curbuf %d\n",
        bufnum, curdone, curbuf);
    return 0;
}

int
edt_abort_dma(EdtDev * edt_p)

{
    edt_msg(EDTDEBUG, "edt_abort_dma\n");
    edt_reset_ring_buffers(edt_p, edt_done_count(edt_p));
    return 0;
}

int
edt_abort_current_dma(EdtDev * edt_p)

{
    edt_msg(EDTDEBUG, "edt_abort_current_dma\n");
    edt_reset_ring_buffers(edt_p, edt_done_count(edt_p) + 1);
    return 0;
}

int
edt_ring_buffer_overrun(EdtDev *edt_p)

{
    bufcnt_t   dmacount;

    dmacount = edt_done_count(edt_p);

    if (dmacount >= edt_p->donecount + edt_p->ring_buffer_numbufs)
        return (1);
    else
        return (0);
}


#ifdef P16D

u_short
p16d_get_command(EdtDev * edt_p)
{
    return (edt_reg_read(edt_p, P16_COMMAND));
}

void
p16d_set_command(EdtDev * edt_p, u_short val)
{
    edt_reg_write(edt_p, P16_COMMAND, val);
}

u_short
p16d_get_config(EdtDev * edt_p)
{
    return (edt_reg_read(edt_p, P16_CONFIG));
}

void
p16d_set_config(EdtDev * edt_p, u_short val)
{
    edt_reg_write(edt_p, P16_CONFIG, val);
}

u_short
p16d_get_stat(EdtDev * edt_p)
{
    return (edt_reg_read(edt_p, P16_STATUS));
}

#endif                          /* P16D */


int
edt_parse_unit_channel(const char *instr, 
                       char *dev, 
                       const char *default_dev,
                       int *channel_ptr)
{
    int     unit = -1;
    int         channel = -1;
    size_t              last;

    char    retdev[256];
    char    str[256];


    edt_msg(EDTDEBUG, "edt_parse_unit_channel %s dev %s default %s: ", 
        instr, dev, default_dev);

    if (default_dev)
        strcpy(retdev, default_dev);
    else
        strcpy(retdev, EDT_INTERFACE);

    strcpy(str,instr);

    if (strlen(str))
    {
        last = strlen(str)-1;

        /* find the channel or unit */

        if (isdigit(str[last]))
        {
            while (last && isdigit(str[last]))
            {
                last--;
            }

            if (!isdigit(str[last]))
            {
                last++;
            }

            channel = atoi(str+last);

            if (str[0] != '/' && str[0] != '\\')
                str[last] = 0;

            if (last>0)
                last--;

            if (last && str[last] == '_')
            {

                last--;

                if (isdigit(str[last]))
                {
                    size_t enddigit = last;
                    char checkstr[80];

                    while (last && isdigit(str[last]))
                    {
                        last--;
                    }

                    if (!isdigit(str[last]))
                    {
                        last++;
                    }

                    strncpy(checkstr,str+last,(enddigit - last)+1);

                    unit = atoi(checkstr);

                    if (str[0] != '/' && str[0] != '\\')
                        str[last] = 0;

                }       
                else
                {
                    unit = channel;
                    channel = -1;
                }
            }
            else
            {
                unit = channel;
                channel = -1;
            }

        }
        else
            unit = 0;
    }
    else
        unit = 0;
    
    if (str[0])
        strcpy(retdev, str);

    strcpy(dev, retdev);

    if (channel_ptr && (channel != -1))
        *channel_ptr = channel;

    return (unit);
}

int
edt_parse_unit(const char *str, char *dev, const char *default_dev)
{
    int channel = 0;

    return edt_parse_unit_channel(str,dev,default_dev, &channel);


}
int
edt_serial_wait(EdtDev * edt_p, int msecs, int count) 
{
    edt_buf tmp;
    int     ret;

    tmp.desc = msecs;
    tmp.value = count;
    edt_ioctl(edt_p, EDTS_SERIALWAIT, &tmp);
    ret = (u_int) tmp.value;

    edt_msg(EDTDEBUG, "edt_serial_wait(%d, %d) %d\n", msecs, count, ret);
    return (ret);
}

int                        
edt_ref_tmstamp(EdtDev *edt_p, u_int val)

{
    return edt_ioctl(edt_p,EDTS_REFTMSTAMP,&val);

}

uint_t
edt_get_bufbytecount(EdtDev * edt_p, u_int *cur_buffer)
{
    uint_t args[2] ;

    if (edt_ioctl(edt_p, EDTG_BUFBYTECOUNT, &args) < 0)
        edt_msg_perror(EDTFATAL, "edt_ioctl(EDTG_BUFBYTECOUNT)");

    if (cur_buffer)
        *cur_buffer = args[1] ;
    return (args[0]);
}


void
edt_dmasync_fordev(EdtDev *edt, int bufnum, int offset, int bytecount)
{
    u_int args[3] ;

    args[0] = bufnum ;
    args[1] = offset ;
    args[2] = bytecount ;

    edt_ioctl(edt, EDTS_DMASYNC_FORDEV, args) ;
}

void
edt_dmasync_forcpu(EdtDev *edt, int bufnum, int offset, int bytecount)
{
    u_int args[3] ;

    args[0] = bufnum ;
    args[1] = offset ;
    args[2] = bytecount ;

    edt_ioctl(edt, EDTS_DMASYNC_FORCPU, args) ;
}

/* return true if machine is little_endian */
int
edt_little_endian()
{
    u_short test;
    u_char *byte_p;

    byte_p = (u_char *) & test;
    *byte_p++ = 0x11;
    *byte_p = 0x22;
    if (test == 0x1122)
    {
        edt_msg(EDTDEBUG, "edt_endian: BIG (SPARC, PowerPC)\n");
        return (0);
    }
    else
    {
        edt_msg(EDTDEBUG, "edt_endian: LITTLE (X86, AMD, SPARCv9)\n");
        return (1);
    }
}

int
edt_set_buffer_size(EdtDev * edt_p, uint_t index, uint_t size, uint_t write_flag)

{

    buf_args sysargs;

    if (edt_p->ring_buffers[index])
    {
        if (size > (u_int) edt_p->rb_control[index].allocated_size)
        {
            edt_msg_perror(EDTFATAL, "edt_set_buffer_size: Attempt to set size greater than allocated\n");
            return -1;
        }

        edt_p->rb_control[index].size = size;
        sysargs.index = index;
        sysargs.writeflag = write_flag;
        sysargs.addr = 0;
        sysargs.size = size;

        return edt_ioctl(edt_p, EDTS_BUF, &sysargs);

    }
    else
    {
        edt_msg_perror(EDTFATAL, "edt_set_buffer_size: Attempt to set size on unallocated buffer\n");

        return -1;
    }
}

int
edt_set_max_buffers(EdtDev *edt_p, int newmax)

{
    edt_msg(EDTDEBUG, "edt_set_max_buffers\n");

    return 
        edt_ioctl(edt_p, EDTS_MAX_BUFFERS, &newmax);
}

int
edt_get_max_buffers(EdtDev *edt_p)

{
    u_int val;

    if (edt_p->devid == DMY_ID) val = MAX_DMA_BUFFERS ;
    else edt_ioctl(edt_p, EDTG_MAX_BUFFERS, &val);

    return val;

}


void
edt_resume(EdtDev * edt_p)
{
    u_int dmy ;

    edt_msg(EDTDEBUG, "edt_resume\n") ;
    edt_ioctl(edt_p, EDTS_RESUME, &dmy);
}

uint_t
edt_get_todo(EdtDev * edt_p)
{
    u_int todo ;
    if (edt_p->devid == DMY_ID)
        todo = dmy_started ;
    else
        edt_ioctl(edt_p, EDTG_TODO, &todo);
    edt_msg(EDTDEBUG, "edt_get_todo: %d\n",todo) ;
    return todo;
}

uint_t
edt_get_drivertype(EdtDev * edt_p)
{
    u_int type ;
    edt_ioctl(edt_p, EDTG_DRIVER_TYPE, &type);
    edt_msg(EDTDEBUG, "edt_get_drivertype: %x\n",type) ;
    return type;
}

/* only for testing */
int
edt_set_drivertype(EdtDev *edt_p, u_int type)
{
    edt_msg(EDTDEBUG, "edt_set_drivertype\n");
    return edt_ioctl(edt_p, EDTS_DRIVER_TYPE, &type);
}

int
edt_get_reftime(EdtDev * edt_p, u_int * timep) 
{
    /* we return sec and nsec - change to usec */
    u_int   timevals[2];

    edt_ioctl(edt_p, EDTG_REFTIME, &timevals[0]);
    edt_msg(EDTDEBUG, "%x %x ",
        timevals[0],
        timevals[1]) ;
    timep[0] = timevals[0];
    timep[1] = timevals[1];
    return (timevals[1]) ;
}

void
edt_set_timetype(EdtDev * edt_p, u_int type)
{
    edt_ioctl(edt_p, EDTS_TIMETYPE, &type);
}

void
edt_set_abortintr(EdtDev * edt_p, u_int val)
{
    edt_ioctl(edt_p, EDTS_ABORTINTR, &val);
}


caddr_t
edt_mapmem(EdtDev *edt_p, u_int addr, int size)
{
    caddr_t     ret;
#if defined(VXWORKS) || defined(_NT_) || defined(__APPLE__)
    edt_buf tmp;

    tmp.value = size;
    tmp.desc = addr;

    edt_ioctl(edt_p, EDTS_MAPMEM, &tmp);
    /* KLUDGE */
    ret = (caddr_t) tmp.desc ;
    edt_msg(EDTDEBUG, "edt_mapmem(%x, %x) %x %x\n", addr, size, tmp.desc,tmp.value);
    return (ret);
#else
    ret = (caddr_t) mmap((caddr_t)0, size, PROT_READ|PROT_WRITE,
        MAP_SHARED, edt_p->fd, addr);
    if (ret == ((caddr_t)-1)) {
        perror("mmap call");
        return(0) ;
    }
    return(ret) ;
#endif
}

u_int edt_get_mappable_size(EdtDev *edt_p)

{
    u_int value = 0;

    edt_ioctl(edt_p, EDTG_MEMSIZE, &value);

    return value;

}


#ifdef __sun

static id_t
schedinfo(char *name, short *maxpri)
{
    pcinfo_t info;
    tsinfo_t *tsinfop;
    rtinfo_t *rtinfop;

    (void) strcpy(info.pc_clname, name);
    if (priocntl(0L, 0L, PC_GETCID, (char *) &info) == -1L)
    {
        return (-1);
    }
    if (strcmp(name, "TS") == 0)
    {
        tsinfop = (struct tsinfo *) info.pc_clinfo;
        *maxpri = tsinfop->ts_maxupri;
    }
    else if (strcmp(name, "RT") == 0)
    {
        rtinfop = (struct rtinfo *) info.pc_clinfo;
        *maxpri = rtinfop->rt_maxpri;
    }
    else
    {
        return (-1);
    }
    return (info.pc_cid);
}

void
edt_set_RT(u_int pri)
{
    pcparms_t pcparms;
    rtparms_t *rtparmsp;
    id_t    rtID;
    short   maxrtpri;

    /* Get highest valid RT priority. */
    if ((rtID = schedinfo("RT", &maxrtpri)) == -1)
    {
        edt_msg_perror(EDTFATAL, "schedinfo failed for RT");
        exit(2);
    }

    /* Change proc to RT, highest prio - 1, default time slice */
    pcparms.pc_cid = rtID;
    rtparmsp = (struct rtparms *) pcparms.pc_clparms;
    rtparmsp->rt_pri = maxrtpri - (1 + pri) ;
    rtparmsp->rt_tqnsecs = RT_TQDEF;

    if (priocntl(P_LWPID, P_MYID, PC_SETPARMS, (char *) &pcparms) == -1)
    {
        edt_msg_perror(EDTFATAL, "PC_SETPARMS failed");
        exit(3);
    }
}
#endif /* __sun */


#ifdef PCD
/*
* SSE (fast serial) support.
*/

/* These bits are in hi word of long, must split into two to do AND's, OR's */
#define XPLLBYP (0x1<<17)
#define XPLLCLK (0x1<<18)
#define XPLLDAT (0x1<<19)
#define XPLLSTB (0x1<<20)

#define XC_X16  (0x00)          /* PC Only: hi for SCLK=16MHz, not SCLK=CCLK */
#define XC_AVSEL (0x80)         /* GP Only: hi for SCLK=AVCLK, not SCLK=16MHz*/

#define XC_CCLK (0x01)          /* These codes interpreted by sse_wpp() */
#define XC_DIN  (0x02)          /*  Xilinx config data and clock */
#define XC_PROG (0x04)          /*  inverted in sse_wpp() when driving PROGL */
#define XC_INITL (0x04)         /* Actual bit positions in status register */
#define XC_DONE  (0x08)

/* Write encoded data to parallel port data register */
static void
sse_wpp(EdtDev *edt_p, int val)
{
    unsigned char bits;

    bits = edt_intfc_read(edt_p, PCD_FUNCT) & 0x08;     /* Preserve SWAPEND */

    if (val & XC_DIN)   bits |= 0x04;
    if (val & XC_PROG)  bits |= 0x01;
    if (val & XC_AVSEL) bits |= 0x80;

    edt_intfc_write(edt_p, PCD_FUNCT, bits);

    if (val & XC_CCLK)          /* strobe the clock hi then low */
    {
        edt_intfc_write(edt_p, PCD_FUNCT, (unsigned char) (bits | 0x02));
        edt_intfc_write(edt_p, PCD_FUNCT, bits);
    }

    edt_msg(EDTDEBUG, "sse_wpp(%02x)  ", bits);
}


static int
sse_spal(EdtDev * edt_p, int v)
{
    edt_msleep(1);
    edt_intfc_write(edt_p, PCD_PAL0, (unsigned char) (v >> 0));
    edt_intfc_write(edt_p, PCD_PAL1, (unsigned char) (v >> 8));
    edt_intfc_write(edt_p, PCD_PAL2, (unsigned char) (v >> 16));

    return (edt_intfc_read(edt_p, PCD_PAL3));
}

static void
sse_xosc(EdtDev * edt_p, int val)
{
    int     n, s;       /* First set up MC12430 lines, CLK=0, DAT=0, STB=0 */
    int   gspv = edt_intfc_read(edt_p, PCD_PAL0)
        | edt_intfc_read(edt_p, PCD_PAL1) << 8 
        | edt_intfc_read(edt_p, PCD_PAL2) << 16;

    gspv = (gspv & ~XPLLBYP & ~XPLLCLK & ~XPLLDAT & ~XPLLSTB);
    sse_wpp(edt_p, 0);

    edt_msleep(1);              /* Shut down AVSEL */

    for (n = 13; n >= 0; n--)
    {                           /* Send 14 bits of data to MC12430 */
        s = val & (0x1 << n);   /* get the current data bit */

        if (s)
        {
            sse_spal(edt_p, gspv | XPLLDAT);    /* Set up data, then clock it */
            sse_spal(edt_p, gspv | XPLLDAT | XPLLCLK);
        }
        else
        {
            sse_spal(edt_p, gspv);      /* Strobe clock only, no data */
            sse_spal(edt_p, gspv | XPLLCLK);
        }

        edt_msg(EDTDEBUG, "sse_xosc:  n:%d  s:%x\n", n, (s != 0));
    }

    sse_spal(edt_p, gspv | XPLLSTB);    /* Strobe serial_load */
    sse_spal(edt_p, gspv);              /* Clear the strobe */


    if ((val >> 11) == 6)
    {
        gspv |= XPLLBYP;
        sse_spal(edt_p, gspv);

        sse_wpp(edt_p, XC_AVSEL);       /* On GP, drive SCLK from AV9110 */
    }
    else
        sse_wpp(edt_p, 0);


    if (XC_X16)
        sse_wpp(edt_p, XC_X16);         /* On PC, drive SCLK with 16 MHz ref */
}


double
sse_set_out_clk(EdtDev * edt_p, double fmhz)
{                               /* Set ECL clock to freq specified in MHz */
    int     m, n, t, hex, nn, fx;
    edt_pll avp;
    double  avf = 0.0; /* should this have a more reasonable value? --doug */

    if (fmhz < 0)
    {
        printf("sse_set_pll_freq: Invalid argument %f\n", fmhz);
        return 0;
    }

    fx = (int) fmhz;

    if ((fmhz > 800.0) || (fmhz < 0.000050))
    {
        printf("Error, %f MHz requested.  Min of 0.000050, max of 800Mhz\n",
            fmhz);
        return (0);
    }
    else if (fx > 400)
    {
        t = 0;
        n = 3;
        m = fx / 2;
        nn = 1;
    }                           /* Every 2 MHz */
    else if (fx > 200)
    {
        t = 0;
        n = 0;
        m = fx;
        nn = 2;
    }                           /* Every 1 MHz */
    else if (fx > 100)
    {
        t = 0;
        n = 1;
        m = fx * 2;
        nn = 4;
    }                           /* Every 500 KHz */
    else if (fx >= 50)
    {
        t = 0;
        n = 2;
        m = fx * 4;
        nn = 8;
    }                           /* Every 250 KHz */
    else
    {
        avf = edt_find_vco_frequency(edt_p, fmhz * 1E6, (double) 30E6, &avp, 0);
        if (avf != 0)
            edt_set_out_clk(edt_p, &avp);       /* Load AV9110 */
        t = 6;
        n = 3;
        m = 200;
        nn = 4;                 /* Put MC12430 in bypass, use AV9110 */
    }

    hex = (t << 11) | (n << 9) | m;

    sse_xosc(edt_p, hex);       /* Load MC12430 hw */

    if (t != 6)
    {
        edt_msg(EDTDEBUG,
            "sse_set_out_clk:  %f MHz  MC12430: t:%d  n:%d  m:%d  hex:0x%04x\n",
            (2.0 * m / nn), t, n, m, hex);
        return (2.0 * m / nn);  /* Freq of MC12430 in MHz */
    }
    else
    {
        edt_msg(EDTDEBUG,
            "sse_set_out_clk: %f MHz AV9110:  m:%d n:%d v:%d r:%d h:%d l:%d x:%d\n",
            (avf / 1E6), avp.m, avp.n, avp.v, avp.r, avp.h, avp.l, avp.x);
        return (avf / 1E6);     /* Freq of AV9110 in MHz */
    }
}




void
sse_shift(EdtDev *edt_p, int shift)
{
    int n ;
    unsigned char  old;

    if (shift)
    {
        old = edt_intfc_read(edt_p, PCD_PAL1) & ~0x02;
        edt_intfc_write(edt_p, PCD_PAL1, old);

        for (n = 0; n < shift; n++)
        {
            edt_msleep(1);
            edt_intfc_write(edt_p, PCD_PAL1, (unsigned char) (0x02 | old));
            edt_msleep(1);
            edt_intfc_write(edt_p, PCD_PAL1, old);
        }
    }
}
/*
To swallow a clock on channel 0, strobe bit 9,  so PCD_PAL1 0x02
To swallow a clock on channel 1, strobe bit 21, so PCD_PAL2 0x20
*/
void
sse_shift_chan(EdtDev *edt_p, int shift, int channel)
{
    int n ;
    unsigned char  old;

    if (shift) {
        if (channel==0) {
            old = edt_intfc_read(edt_p, PCD_PAL1) & ~0x02;
            edt_intfc_write(edt_p, PCD_PAL1, old);

            for (n = 0; n < shift; n++)
            {
                edt_msleep(1);
                edt_intfc_write(edt_p, PCD_PAL1, (unsigned char) (0x02 | old));
                edt_msleep(1);
                edt_intfc_write(edt_p, PCD_PAL1, old);
            }
        } else {
            old = edt_intfc_read(edt_p, PCD_PAL2) & ~0x20;
            edt_intfc_write(edt_p, PCD_PAL2, old);

            for (n = 0; n < shift; n++)
            {
                edt_msleep(1);
                edt_intfc_write(edt_p, PCD_PAL2, (unsigned char) (0x20 | old));
                edt_msleep(1);
                edt_intfc_write(edt_p, PCD_PAL2, old);
            }
        }
    }
}
#endif /* PCD */


#ifdef P11W

#include "p11w.h"

u_short
p11w_get_command(EdtDev * edt_p)
{
    return (edt_reg_read(edt_p, P11_COMMAND));
}

void
p11w_set_command(EdtDev * edt_p, u_short val)
{
    edt_reg_write(edt_p, P11_COMMAND, val);
}

u_short
p11w_get_config(EdtDev * edt_p)
{
    return (edt_reg_read(edt_p, P11_CONFIG));
}

void
p11w_set_config(EdtDev * edt_p, u_short val)
{
    edt_reg_write(edt_p, P11_CONFIG, val);
}

u_short
p11w_get_data(EdtDev * edt_p)
{
    return (edt_reg_read(edt_p, P11_DATA));
}

void
p11w_set_data(EdtDev * edt_p, u_short val)
{
    edt_reg_write(edt_p, P11_DATA, val);
}

u_short
p11w_get_stat(EdtDev * edt_p)
{
    return (edt_reg_read(edt_p, P11_STATUS));
}

u_int
p11w_get_count(EdtDev * edt_p)
{
    return (edt_reg_read(edt_p, P11_COUNT));
}

/*
* The following routine is deprecated.  Use the one following
* this, p11w_set_abortdma_onintr().     Mark  6/04
*/
void
p11w_abortdma_onattn(EdtDev *edt_p, int flag)
{
    int arg = 0x11 ;
    u_short readcmd ;


    if (flag)
    {
        edt_ioctl(edt_p, P11G_READ_COMMAND, &readcmd) ;
        readcmd |= P11W_EN_ATT ;
        edt_ioctl(edt_p, P11S_READ_COMMAND, &readcmd) ;

        edt_ioctl(edt_p, EDTS_CUSTOMER, &arg) ;
    }
    else
    {
        edt_ioctl(edt_p, P11G_READ_COMMAND, &readcmd) ;
        readcmd &= ~P11W_EN_ATT ;
        edt_ioctl(edt_p, P11S_READ_COMMAND, &readcmd) ;

        arg = 0 ;
        edt_ioctl(edt_p, EDTS_CUSTOMER, &arg) ;
    }
}

void
p11w_set_abortdma_onintr(EdtDev *edt_p, int flag)
{
    u_short readcmd, writecmd ;

    if (flag == 0)
    {
        edt_ioctl(edt_p, P11G_READ_COMMAND, &readcmd) ;
        readcmd &= ~P11W_EN_ATT ;
        edt_ioctl(edt_p, P11S_READ_COMMAND, &readcmd) ;

        edt_ioctl(edt_p, P11G_WRITE_COMMAND, &writecmd) ;
        writecmd &= ~P11W_EN_ATT ;
        edt_ioctl(edt_p, P11S_WRITE_COMMAND, &writecmd) ;
    }

    edt_ioctl(edt_p, EDTS_ABORTDMA_ONINTR, &flag) ;

    if (flag)
    {
        edt_ioctl(edt_p, P11G_READ_COMMAND, &readcmd) ;
        readcmd |= P11W_EN_ATT ;
        edt_ioctl(edt_p, P11S_READ_COMMAND, &readcmd) ;

        edt_ioctl(edt_p, P11G_WRITE_COMMAND, &writecmd) ;
        writecmd |= P11W_EN_ATT ;
        edt_ioctl(edt_p, P11S_WRITE_COMMAND, &writecmd) ;
    }
}

#endif                          /* P11W */

int
edt_device_id(EdtDev *edt_p)
{
    if (edt_p)
        return edt_p->devid;
    return -1;
}

int
edt_check_1_vs_4(EdtDev *edt_p)
{   
    char name[129];
    int pci_channels = 4;

    edt_x_get_fname(edt_p, name);

    if (isdigit(name[strlen(name)-1]))
    {
        if (strlen(name) >= 2 && isdigit(name[strlen(name)-2]))
        {
            pci_channels = atoi(name + strlen(name)-2);
        }
        else
        {
            pci_channels = atoi(name + strlen(name)-1);
        }
    }

    return pci_channels;
}


int
edtdev_channels_from_type(EdtDev *edt_p)

{

    switch(edt_p->devid) {
  case PCD20_ID:
  case PCD40_ID:
  case PCD60_ID:

  case PGP20_ID:
  case PGP40_ID:
  case PGP60_ID:
  case PGP_ECL_ID:
  case PDVFOI_ID:
  case PDVAERO_ID:

  case PDVCL2_ID:
      return 4;

  case PSS4_ID:
  case PGS4_ID:
  case PCDFOX_ID:
  case PCDA_ID:
  case PCDCL_ID:
  case PDVFOX_ID:
  case PE4DVFOX_ID:
  case PE8DVFOX_ID:
      return edt_check_1_vs_4(edt_p);

  case PDVFCI_USPS_ID:
  case PE4DVFCI_ID:
  case PE8DVFCI_ID:
  case PE8DVCLS_ID:
      return 2;

  case PE4DVCL_ID:
  case PE8DVCL_ID:
  case PDVCL_ID:
      return 3;

  case P53B_ID:
      return 34;

  case PCD_16_ID:
  case PSS16_ID:
  case PGS16_ID:
  case PCDA16_ID:
  case PE8LX16_ID:
  case PE8LX16_LS_ID:
    case PE4AMC16_ID:
       
      return 16;

  case PE8LX64_ID:
      return 64;

    }

    return 1;

}

int
edt_devtype_from_id(int id)
{
    switch(id)
    {
    case P11W_ID:               return p11w;
    case P16D_ID:               return p16d;

    case PDV_ID:                
    case PDVA_ID:               
    case PDVA16_ID:             
    case PDVK_ID:               
    case PDVRGB_ID:             
    case PDV44_ID:              
    case PDVCL_ID:              
    case PDVCL2_ID:             

    case PE4DVCL_ID:            
    case PE8DVCL_ID:            
    case PE8DVCLS_ID:           

    case PDVAERO_ID:            return pdv;



    case PCD20_ID:              
    case PCD40_ID:              
    case PCD60_ID:              
    case PCDA_ID:               
    case PCDCL_ID:              
    case PGP20_ID:              
    case PGP40_ID:              
    case PGP60_ID:              

    case PGP_THARAS_ID:         
    case PGP_ECL_ID:            
    case PCD_16_ID:             
    case PCDA16_ID:             

    case PDVFCI_AIAG_ID:        
    case PDVFCI_USPS_ID:        
    case PCDFCI_SIM_ID:         
    case PCDFCI_PCD_ID:         
    case PCDFOX_ID:             
    case PDVFOX_ID:             
    case PE4DVFOX_ID:           
    case PE8DVFOX_ID:           
    case P53B_ID:               
    case PDVFOI_ID:             
    case PSS4_ID:               
    case PSS16_ID:              
    case PGS4_ID:               
    case PGS16_ID:              
    case PE8LX1_ID:             
    case PE8LX16_LS_ID:         
    case PE8LX16_ID:            
    case PE8LX64_ID:            
    case PE4AMC16_ID:           return pcd;

    case DMY_ID:                
    case DMYK_ID:               return dummy;

    default:                    return unknown;
    }
}



char *
edt_idstr(int id)
{
    switch(id)
    {
    case P11W_ID:               return("pci 11w");
    case P16D_ID:               return("pci 16d");
    case PDV_ID:                return("pci dv");
    case PDVA_ID:               return("pci dva");
    case PDVA16_ID:             return("pci dva16");
    case PDVK_ID:               return("pci dvk");
    case PDVRGB_ID:             return("pci dv-rgb");
    case PDV44_ID:              return("pci dv44");
    case PDVCL_ID:              return("pci dv c-link");
    case PDVCL2_ID:             return("pci dv cls");
    case PE4DVCL_ID:            return("pcie4 dv c-link");
    case PE8DVCL_ID:            return("pcie8 dv c-link");
    case PE8DVCLS_ID:           return("pcie8 dv cls");
    case PDVAERO_ID:            return("pcd dv aero serial");
    case PCD20_ID:              return("pci cd-20");
    case PCD40_ID:              return("pci cd-40");
    case PCD60_ID:              return("pci cd-60");
    case PCDA_ID:               return("pci cda");
    case PCDCL_ID:              return("pci cd cl");
    case PGP20_ID:              return("pci gp-20");
    case PGP40_ID:              return("pci gp-40");
    case PGP60_ID:              return("pci gp-60");

    case PGP_THARAS_ID:         return("pci gp-tharas");
    case PGP_ECL_ID:            return("pci gp-ecl");
    case PCD_16_ID:             return("pci cd-16");
    case PCDA16_ID:             return("pci cda16");

    case PDVFCI_AIAG_ID:        return("pci-fci aiag");
    case PDVFCI_USPS_ID:        return("pci-fci usps");
    case PCDFCI_SIM_ID:         return("pci-fci sim");
    case PCDFCI_PCD_ID:         return("pci-fci pcd");
    case PCDFOX_ID:             return("pcd fox");
    case PDVFOX_ID:             return("pci dv fox");
    case PE4DVFOX_ID:           return("pcie4 dv fox");
    case PE8DVFOX_ID:           return("pcie8 dv fox");
    case P53B_ID:               return("pci 53b");
    case PDVFOI_ID:             return("pdv foi");
    case PSS4_ID:               return("pci ss-4");
    case PSS16_ID:              return("pci ss-16");
    case PGS4_ID:               return("pci gs-4");
    case PGS16_ID:              return("pci gs-16");
    case PE8LX1_ID:             return("pcie8 lx-1");
    case PE8LX16_LS_ID:         return("pcie8 lx-16 (slow)");
    case PE8LX16_ID:            return("pcie8 lx-16");
    case PE8LX64_ID:            return("pcie8 lx-64");
    case PE4AMC16_ID:           return("pcie4 AMC16");
    case DMY_ID:                return("dummy");
    case DMYK_ID:               return("dummy pci dvk/44/foi");
    default:                    return("unknown");
    }
}


#if defined(VXWORKS) || defined(TEST_VXWORKS)
/* writable command string for vxworks calling edt_system() */
char edt_vxw_cmdstr[512];

/*
* The following two arrays are used to register a function name with a
* function pointer for vxworks calling edt_system().  Only 32 unique
* program names are supported; most programs use less than 5.
*
* STRATEGY:  Preference is simplicity, but works with most applications.
*/
static char *program_func_name[32] = { NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
static void * edt_vx_system_func[32] = { NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};

/*
* VxWorks programs calling edt_system() must first register the progam name
* and the program function.
*/
int
edt_vx_system_register_func(const char *funcstr, int (funcptr)(char *))
{
    int i;

    for (i = 0; i < 32; i++)
    {
        if (program_func_name[i] == NULL)
            break;
    }

    if (i == 32)
        return(-1);
    else
    {
        program_func_name[i] =  edt_alloc(strlen(funcstr) + 1);
        strcpy(program_func_name[i], funcstr);
        edt_vx_system_func[i] = funcptr;
        return 0;
    }
}
#endif

int
edt_system(const char *cmdstr)
{
#if defined(_NT_)

    int ret;
    char *newstr = malloc(512) ;
    char *p = newstr ;
    int nowait = 0;
    char *arg[32] = { NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
        NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
        NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
        NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
    };
    int i ;

    if (cmdstr == NULL || *cmdstr == '\0')
        return(0) ;

    strncpy(newstr, cmdstr, 511) ;
    for (i = 0; (i < 32) && (p && *p); i++)
    {
        while (*p == ' ' || *p == '\t')
            *p++ = '\0' ;

        arg[i] = p ;

        while (*p != ' ' && *p != '\t' && *p != '\0')
            ++ p ;
    }

    if (*arg[i-1] == '&')
    {
        arg[i-1] = NULL;
        nowait = 1;
    }

    ret = spawnv((nowait) ? _P_NOWAIT : _P_WAIT, arg[0], arg);
    free(newstr);
    return ret;
#elif defined(VXWORKS) || defined(TEST_VXWORKS)
    /*
    * VxWorks programs calling edt_system() must first register the progam name
    * and the program function.  Here the string argument to edt_system() is
    * parsed into the command name and options.  The command name is looked up
    * and matched with a function pointer, then the function is called with
    * the option string.
    */
    {
        int i;
        char *cmd;
        char *opts;
        char *tmp;
        int (*fnp)(char *);

        strncpy(edt_vxw_cmdstr, cmdstr, 511);
        cmd = edt_vxw_cmdstr;
        opts = strchr(edt_vxw_cmdstr, ' ');

        if (opts)
            *opts++ = '\0';

        tmp = strrchr(edt_vxw_cmdstr, '/');
        if (tmp)
            cmd = tmp + 1;


        edt_msg(EDTDEBUG, "VXWORKS_test: edt_system(%s, %s)\n", cmd, opts);
#if defined(TEST_VXWORKS)
        printf("VXWORKS_test: edt_system(%s, %s)\n", cmd, opts);
#endif

        for (i = 0; i < 32; i++)
        {
            if (program_func_name[i] == NULL)
                return -1;
            else if (strncmp(program_func_name[i], cmd, 511) == 0)
            {
                fnp = (int (*)(char*)) edt_vx_system_func[i];
                edt_msg(EDTDEBUG, "VXWORKS_test: found name %s func %p\n", cmd, fnp);
                return fnp(opts);
            }
        }

        if (i == 32) /* Not found */
        {
            edt_msg(EDTDEBUG, "VXWORKS_test: name not found %s, must be registered with edt_vx_system_register_func()\n", cmd);
            return -1;
        }
        return(0);
    }
#else

    int ret ;

    ret = system(cmdstr) ;

#if defined(__sun) || defined(__linux__) || defined(__APPLE__)
    if (ret == -1 || WIFEXITED(ret) == 0)
        return -1 ;
    else
        return WEXITSTATUS(ret) ;
#else
    return ret ;
#endif
#endif
}

#define MEZZ_PATH_FIELD_CHAR '|'

char *
edt_get_last_bitpath(EdtDev *edt_p)

{
    FILE *f;
    static char cache_name[MAXPATH];


    sprintf(cache_name, ".interface_bitfile.%d", edt_p->unit_no);

    if ((f = fopen(cache_name, "r")))
    {

        volatile char *throwaway = fgets(cache_name, MAXPATH, f);

        if (strlen(cache_name))
        {

        if (cache_name[strlen(cache_name)-1] == '\n')
            cache_name[strlen(cache_name)-1] = 0;
        }

        fclose(f);

        return cache_name;
    }

    return NULL;
}


void
edt_set_last_bitpath(EdtDev *edt_p, const char *fullpath)

{
    FILE *f;
    char cache_name[MAXPATH];

    sprintf(cache_name, ".interface_bitfile.%d", edt_p->unit_no);

    if ((f = fopen(cache_name, "w")))
    {

        fputs(fullpath, f);

        fclose(f);

    }
}


int
edt_set_mezz_chan_bitpath(EdtDev *edt_p, const char *bitpath, int channel)
{
    edt_bitpath pathbuf, chan0, chan1;
    const char *s1;
    int sp;
    int rc;

    /* scan back for / in path - we may not have room for full path */

    if (strlen(bitpath))
    {
        sp = (int) strlen(bitpath) - 1;

        while (sp >= 0 && bitpath[sp] != '/' && bitpath[sp] != '\\')
            sp --;

        if (sp >= 0)
            sp++;
        else
            sp = 0;
    }
    else
        sp = 0;

    s1 = bitpath + sp;

    edt_get_mezz_chan_bitpath(edt_p,chan0, sizeof(chan0),0);
    edt_get_mezz_chan_bitpath(edt_p,chan1, sizeof(chan1),1);

    if (channel == 0)
        sprintf(pathbuf,"%s%c%s",s1,MEZZ_PATH_FIELD_CHAR,chan1);
    else
        sprintf(pathbuf,"%s%c%s",chan0, MEZZ_PATH_FIELD_CHAR, s1);

    rc = edt_ioctl(edt_p, EDTS_MEZZ_BITPATH, pathbuf);

        edt_get_mezz_chan_bitpath(edt_p, edt_p->bfd.mezz_name0,
                sizeof(edt_p->bfd.mezz_name0),0);
        edt_get_mezz_chan_bitpath(edt_p, edt_p->bfd.mezz_name1,
                sizeof(edt_p->bfd.mezz_name1),1);

    return rc;
}


int
edt_get_mezz_chan_bitpath(EdtDev *edt_p, char *bitpath, int size, int channel)
{
    int ret = 0 ;
    edt_bitpath pathbuf ;
    char *s2, *s3;
    int sp;
    /* split into channels */

    ret = edt_ioctl(edt_p, EDTG_MEZZ_BITPATH, pathbuf);

    s2 = pathbuf;
    sp = 0;
    while (sp < (int)strlen(pathbuf) && pathbuf[sp] != MEZZ_PATH_FIELD_CHAR)
        sp++;

    s3 = s2 + sp;
    if (s3[0] == MEZZ_PATH_FIELD_CHAR)
    {
        s3[0] = 0;
        s3++;
    }

    if (channel == 0)
        strncpy(bitpath, s2, size - 1) ;
    else
        strncpy(bitpath, s3, size - 1) ;

    return ret ;
}

int
edt_set_mezz_bitpath(EdtDev *edt_p, const char *bitpath)
{
    edt_bitpath pathbuf;
    int rc;
    int i = (int) strlen(bitpath)-1;

    while (i>= 0 && bitpath[i] != '\\' && bitpath[i] != '/')
        i--;

    if (i >= 0)
        i++;
    else
        i = 0;

    strncpy(pathbuf, bitpath+i, sizeof(edt_bitpath) - 1) ;
    rc =  edt_ioctl(edt_p, EDTS_MEZZ_BITPATH, pathbuf);

    return rc;
}


int
edt_get_mezz_bitpath(EdtDev *edt_p, char *bitpath, int size)
{
    int ret = 0 ;
    edt_bitpath pathbuf ;

    ret = edt_ioctl(edt_p, EDTG_MEZZ_BITPATH, pathbuf);
    strncpy(bitpath, pathbuf, size - 1) ;
    return ret ;
}


int
edt_set_bitpath(EdtDev *edt_p, const char *bitpath)
{
    edt_bitpath pathbuf ;
    int rc;

    strncpy(pathbuf, bitpath, sizeof(edt_bitpath) - 1) ;
    rc =  edt_ioctl(edt_p, EDTS_BITPATH, pathbuf);

    edt_get_bitname(edt_p, edt_p->bfd.bitfile_name,
        sizeof(edt_p->bfd.bitfile_name));

    edt_set_last_bitpath(edt_p, bitpath);    

    return rc;
}


int
edt_get_bitpath(EdtDev *edt_p, char *bitpath, int size)
{
    int ret = 0 ;
    edt_bitpath pathbuf ;
    pathbuf[0] = '\0';
    ret = edt_ioctl(edt_p, EDTG_BITPATH, pathbuf);

    strncpy(bitpath, pathbuf, size - 1) ;
    return ret ;
}

int
edt_get_bitname(EdtDev *edt_p, char *bitpath, int size)
{
    int ret = 0 ;
    char *name;
    edt_bitpath pathbuf ;

    pathbuf[0] = '\0';
    ret = edt_ioctl(edt_p, EDTG_BITPATH, pathbuf);

    /*  Remove the leading path from the bitfile name */
    if ((name = strrchr(pathbuf, '/')) || (name = strrchr(pathbuf, '\\')))
        ++ name;
    else
        name = pathbuf;

    strcpy(bitpath, name) ;

    return ret ;
}

int
edt_get_driver_version(EdtDev *edt_p, char *version, int size)
{
    int ret = 0 ;
    edt_version_string vbuf ;

    ret = edt_ioctl(edt_p, EDTG_VERSION, vbuf);

    strncpy(version, vbuf, size - 1) ;
    return ret ;
}

int
edt_get_driver_buildid(EdtDev *edt_p, char *build, int size)
{
    int ret = 0 ;
    edt_version_string vbuf ;

    ret = edt_ioctl(edt_p, EDTG_BUILDID, vbuf);

    strncpy(build, vbuf, size - 1) ;
    return ret ;
}

static char * edt_library_version = EDT_LIBRARY_VERSION;
static char * edt_library_buildid = FULLBUILD;

int
edt_get_library_version(EdtDev *edt_p, char *version, int size)
{
    strncpy(version, edt_library_version, size - 1) ;
    return 0 ;
}

int
edt_get_library_buildid(EdtDev *edt_p, char *build, int size)
{
    strncpy(build, edt_library_buildid, size - 1) ;
    return 0 ;
}


int
edt_check_version(EdtDev *edt_p)

{
    edt_version_string check;

    edt_get_driver_version(edt_p, check, sizeof(check));

    return (!strcmp(check,edt_library_version));

}

static u_int
epr_cfg(EdtDev *edt_p, int addr)
{
    int ret ;
    edt_buf buf ;
    buf.desc = addr ;
    if ((addr<0) || (addr>0x3c)) {
        edt_msg(EDTWARN, "epr_cfg: addr out of range\n");
        return(0);
    } 
    ret = edt_ioctl(edt_p,EDTG_CONFIG,&buf) ;
    if (ret < 0)
    {
        edt_perror("EDTG_CONFIG") ;
    }
    return(u_int) (buf.value) ;
}

static void
epw_cfg(EdtDev *edt_p, int addr, int value)
{
    int ret ;
    edt_buf buf ;
    buf.desc = addr ;
    if ((addr<0) || (addr>0x3c)) {
        edt_msg(EDTWARN, "epw_cfg: addr out of range\n");
        return;
    } 
    buf.value = value ;
    ret = edt_ioctl(edt_p,EDTS_CONFIG,&buf) ;
    if (ret < 0)
    {
        edt_perror("EDTS_CONFIG") ;
    }
}

int
edt_pci_reboot(EdtDev *edt_p)
{
    int  addr, data;
    int  buf[0x40];
    int  rst, copy, new;
    int  ret = 0;
    FILE *fd2;
    char *tmpfname = "TMPfPciReboot.cfg";

    if ((fd2 = fopen(tmpfname, "wb")) == NULL)  {
        edt_msg(EDTFATAL,"edt_pci_reboot: Couldn't write to temp file %s\n", tmpfname);
        return -1;
    }
    for (addr=0; addr<=0x3c; addr+=4) {
        data  = epr_cfg(edt_p, addr);
        buf[addr] = data;
        putc(data, fd2);
        putc(data>>8, fd2);
        putc(data>>16, fd2);
        putc(data>>24, fd2);
        /* printf("%02x:  %08x\n", addr, data); */
    }
    fclose(fd2);
    edt_msg(EDTDEBUG, "Wrote config space state out to %s\n", tmpfname);

    edt_reg_write(edt_p, 0x01000085, 0x40) ;
    edt_msleep(2000) ;

    edt_msg(EDTDEBUG, "  copy     reset     new\n");
    for (addr=0; addr<=0x3c; addr+=4) {
        rst  = epr_cfg(edt_p, addr);
        copy  =  buf[addr];
        epw_cfg(edt_p, addr, copy) ;
        new  = epr_cfg(edt_p, addr);

        edt_msg(EDTDEBUG, "%02x:  %08x  %08x  %08x       ", addr, copy, rst, new);
        if      (copy != new)   edt_msg(EDTDEBUG, "ERROR\n");
        else if (rst != new)    edt_msg(EDTDEBUG, "changed\n");
        else                    edt_msg(EDTDEBUG, "\n");

        /* specifically check line cache reg to make sure it was reset by OS after cleared */
        if (addr == 0x0c)
        {
            if ((rst & 0xff) == (new & 0xff))
                ret = -1;
        }

    }
    return ret;
}

int
edt_set_merge(EdtDev * edt_p, u_int size, int span, u_int offset, u_int count)
{
    edt_merge_args tmp;
    int     ret;

    tmp.line_size = size ;
    tmp.line_span = span;
    tmp.line_offset = offset;
    tmp.line_count = count;
    ret = edt_ioctl(edt_p, EDTS_MERGEPARMS, &tmp);
    return (ret);
}

/* flip the bits inside a byte */
u_char
edt_flipbits(u_char val)
{
    int     i;
    u_char  ret = 0;

    for (i = 0; i < 8; i++)
    {
        if (val & (1 << i))
            ret |= 0x80 >> i;
    }
    return (ret);
}
/* 
*
* edt_set_kernel_buffers
*
* Turn on or off th