libedt.h

Go to the documentation of this file.

/* #pragma ident "@(#)libedt.h  1.302 04/03/08 EDT" */

/* Copyright (c) 1995 by Engineering Design Team, Inc. */

#ifndef INCLUDE_edtlib_h
#define INCLUDE_edtlib_h

#ifdef USB
#include <usb.h>
#endif

#ifdef DOXYGEN_SHOW_UNDOC

#endif


#ifdef DOXYGEN_SHOW_UNDOC

#endif
#ifdef DOXYGEN_SHOW_UNDOC
 /* end dma_updown_internal group */
#endif



#ifdef DOXYGEN_SHOW_UNDOC

#endif
#ifdef DOXYGEN_SHOW_UNDOC
 /* end dma_fifo_internal group */
#endif



#ifdef DOXYGEN_SHOW_UNDOC

#endif
#ifdef DOXYGEN_SHOW_UNDOC
 /* end dma_inout_internal group */
#endif



#ifdef DOXYGEN_SHOW_UNDOC

#endif
#ifdef DOXYGEN_SHOW_UNDOC
 /* end dma_registers_internal group */
#endif


#ifdef DOXYGEN_SHOW_UNDOC

#endif
#ifdef DOXYGEN_SHOW_UNDOC
 /* end dma_utility_internal group */
#endif



#ifdef DOXYGEN_SHOW_UNDOC

#endif
#ifdef DOXYGEN_SHOW_UNDOC
 /* end dma_internal */
#endif


#define event_t HANDLE
/*****************************************************
 * Kernel events                                     *
 *****************************************************/

typedef char edt_version_string[128];

/* undefined this to turn off event handling  */

#define USE_EVENT_HANDLERS


/* Event flags */
/* These act as flag bits indicating our interest in these events */

#define EDT_MAX_KERNEL_EVENTS           20
#define EDT_BASE_EVENTS                 1

#define EDT_EODMA_EVENT                 (EDT_BASE_EVENTS + 0)
#define EDT_EODMA_EVENT_NAME            "edt_eodma"
#define EV_EODMA                        EDT_EODMA_EVENT /* compat */

#define EDT_EVENT_BUF                   (EDT_BASE_EVENTS + 1)
#define EDT_BUF_EVENT_NAME              "edt_buf"

#define EDT_EVENT_STAT                  (EDT_BASE_EVENTS + 2)
#define EDT_STAT_EVENT_NAME             "edt_stat"

#define EDT_EVENT_P16D_DINT             (EDT_BASE_EVENTS + 3)
#define EDT_P16D_DINT_EVENT_NAME        "edt_p16dint"

#define EDT_EVENT_P11W_ATTN             (EDT_BASE_EVENTS + 4)
#define EDT_P11W_ATTN_EVENT_NAME        "edt_p11wattn"

#define EDT_EVENT_P11W_CNT              (EDT_BASE_EVENTS + 5)
#define EDT_P11W_CNT_EVENT_NAME         "edt_cnt"

#define EDT_PDV_EVENT_ACQUIRE           (EDT_BASE_EVENTS + 6)
#define EDT_EVENT_ACQUIRE               EDT_PDV_EVENT_ACQUIRE /* compat */
#define EDT_PDV_ACQUIRE_EVENT_NAME      "edt_acquire"

#define EDT_EVENT_PCD_STAT1             (EDT_BASE_EVENTS + 7)
#define EDT_EVENT_PCD_STAT1_NAME        "edt_pcd_stat1"

#define EDT_EVENT_PCD_STAT2             (EDT_BASE_EVENTS + 8)
#define EDT_EVENT_PCD_STAT2_NAME        "edt_pcd_stat2"

#define EDT_EVENT_PCD_STAT3             (EDT_BASE_EVENTS + 9)
#define EDT_EVENT_PCD_STAT3_NAME        "edt_pcd_stat3"

#define EDT_EVENT_PCD_STAT4             (EDT_BASE_EVENTS + 10)
#define EDT_EVENT_PCD_STAT4_NAME        "edt_pcd_stat4"

#define EDT_PDV_STROBE_EVENT            (EDT_BASE_EVENTS + 11)
#define EDT_PDV_STROBE_EVENT_NAME       "edt_pdv_strobe"

#define EDT_EVENT_P53B_SRQ              (EDT_BASE_EVENTS + 12)
#define EDT_EVENT_P53B_SRQ_NAME         "edt_p53b_srq"

#define EDT_EVENT_P53B_INTERVAL         (EDT_BASE_EVENTS + 13)
#define EDT_EVENT_P53B_INTERVAL_NAME    "edt_p53b_interval"

#define EDT_EVENT_P53B_MODECODE         (EDT_BASE_EVENTS + 14)
#define EDT_EVENT_P53B_MODECODE_NAME    "edt_p53b_modecode"

#define EDT_EVENT_P53B_DONE             (EDT_BASE_EVENTS + 15)
#define EDT_EVENT_P53B_DONE_NAME        "edt_p53b_done"

#define EDT_PDV_EVENT_FVAL              (EDT_BASE_EVENTS + 16)
#define EDT_PDV_EVENT_FVAL_NAME         "edt_pdv_fval"

#define EDT_PDV_EVENT_TRIGINT           (EDT_BASE_EVENTS + 17)
#define EDT_PDV_EVENT_TRIGINT_NAME      "edt_pdv_trigint"

#define EDT_EVENT_TEMP          (EDT_BASE_EVENTS + 18)
#define EDT_EVENT_TEMP_NAME     "edt_temp_intr"

#define EDT_MAX_EVENT_TYPES     (EDT_EVENT_TEMP + 1)

/*
 * The EVENT_MODE controls the way the driver responds to events.
 * Mode 0 is similar to ACT_ONCE; mode 1 is similar to ACT_ALWAYS,
 * and mode 2 is similar to ACT_ALWAYS but disables the event
 * while user code is processing it to prevent OS lockups.
 */
#define EDT_EVENT_MODE_MASK             0xFF000000
#define EDT_EVENT_MODE_SHFT             24
#define EDT_EVENT_MODE_ONCE             0
#define EDT_EVENT_MODE_CONTINUOUS       1
#define EDT_EVENT_MODE_SERIALIZE        2

#if defined(WIN32) || defined(_NT_DRIVER_)
typedef unsigned __int64 uint64_t ;
typedef __int64 int64_t ;
typedef unsigned int  uint32_t ;
typedef int int32_t ;
#endif

/*
 * legal PCI proms for pciload and other prom detect code
 */
#define PROM_UNKN       0
#define AMD_4013E       1
#define AMD_4013XLA     2
#define AMD_4028XLA     3
#define AMD_XC2S150     4
#define AMD_XC2S200_4M  5
#define AMD_XC2S200_8M  6
#define AMD_XC2S100_8M  7
#define AMD_XC2S300E    8
#define SPI_XC3S1200E   9
#define AMD_XC5VLX30T   10      /* WAS SPI_XC5VLX30T    */
#define AMD_XC5VLX50T   11      /* WAS SPI_XC5VLX50T */
#define AMD_EP2SGX30D   12

/*
 * structure to set up phase locked loop parameters.
 * some of these values go into the AV9110-02 PLL chip
 * and others set up prescalars in the xilinx.
 */
#ifdef USE_LONG_BUFCNT
#if defined(_NT_) || defined(_NT_DRIVER_)
typedef unsigned long long bufcnt_t ;
#else
typedef uint64_t bufcnt_t ;
#endif
#else
typedef u_int bufcnt_t ;
#endif

typedef struct
{
    int m; /* AV9110 refernce frequency divide range 3-127 */
    int n; /* AV9110 VCO feedback frequency divide range 3-127 */
    int v; /* AV9110 VCO feedback frequency prescalar range 1 or 8 */
    int r; /* AV9110 VCO output divider 1, 2, 4, 8 */
    int h; /* xilinx high speed divider (vco output) 1,3,5,7 */
    int l; /* xilinx divide by n 1-64 */
    int x; /* xilinx AV9110 prescale of 30MHz oscillator 1-256 */
} edt_pll ;

/*
 * Typedef for edt_bitpath to send and retrieve bitfile pathnames
 * from the driver.
 */
typedef char edt_bitpath[128] ;

/*
 * SBus Device struct
 */
#define EDT_READ 0
#define EDT_WRITE 1

#ifndef TRUE

#define TRUE 1
#define FALSE 0

#endif

/* for edt_get_dma_info */
typedef struct
{
    uint_t      used_dma ;      /* dma started within current open/close */
    uint_t      alloc_dma ;     /* has allocated > 1 ring buffer */
    uint_t      active_dma ;    /* dma is currently active */
} edt_dma_info ;

/* defines for edt_set_kernel_buffers */
#define EDT_USER_BUFS 0
#define EDT_COPY_KBUFS 1
#define EDT_MMAP_KBUFS  2
#define EDT_PERSISTENT_KBUFS  4

#define MAX_EXTENDED_WORDS 32
typedef struct _EdtMezzDescriptor {
    int  id;
    int  n_extended_words;
    int  extended_rev;
    uint_t extended_data[MAX_EXTENDED_WORDS];
} EdtMezzDescriptor;
#ifndef _KERNEL
/* Event callback stuff */


typedef void (*EdtEventFunc)(void *); 

typedef struct edt_event_handler {
    struct edt_event_handler *next; /* in case we want linked lists */
    EdtEventFunc    callback;       /* function to call when event occurs */
    struct edt_device *owner;           /* reflexive pointer */
    uint_t          event_type;
    void *          data;               /* closure pointer for callback */    
    u_char          active;             /* flag for a graceful death */
    u_char          continuous;         /* flag for continuing events */
#ifdef _NT_
    thread_t        wait_thread;        /* thread handle */
    event_t         wait_event;         /* kernel event handle */
    event_t         closing_event;      /* abort event handle */
    uint_t          thrdid;             /* thread id # */
#elif defined(__sun)
    thread_t        thrdid ;            /* thread handle and ID in Solaris */
    sema_t                      sema_thread ;   /* thread sync semaphore */
#elif defined(__linux__) 

  
    thread_t thrdid;
#elif defined(__APPLE__)
    pthread_t thrdid ;

#endif /* _NT_ */

} EdtEventHandler;


/* An EdtBdFilterFunction ("Bd" = Board) function is used by
 * edt_detect_boards_filter() to determine if a board with the given
 * dev (e.g. "pcd"), unit number, and bd_id (eg.. PCD_ID) should be 
 * included with the results of the board detection function. 
 * This is used, for example, by hubload.c to do a detect of only "ltx"
 * boards which are those matching a small number of bd_ids. 
 * The data parameter is passed to edt_detect_boards_filter, and 
 * subsequently passed on to the filter function; it can be either NULL
 * or any data which the filter function wants to help it do its job. 
 * Returns true for matches, false otherwise. */
typedef int (*EdtBdFilterFunction) (char *dev, int unit, int bd_id, void *data);

typedef struct {
    char type[8]; /* board family e.g., "pcd" */
    int id; /* board unit number */
    int bd_id; /* board id, e.g. PCD_ID */
} Edt_bdinfo ;


/*
 * embedded info
 */
typedef struct {
    int clock; /* 4 */
    char sn[11];        
    char pn[11];
    char opt[11];
    int  rev; /* 4 */
    char ifx[11];
} Edt_embinfo;

typedef struct {
        char  fpga[32];                                 /* MUST match a pkg directory name */
        char  promdesc[32];                             /* description may include size */
        char  busdesc[8];                               /* PCI, PCIe, ... */
        int   xtype;                                    /* XTYPE_X, XTYPE_BT, XTYPE_LTX, XTYPE_SPI */
        int   magic;                                    /* magic code (not the magic # itself but a code */
        u_int sectorsize;                               /* sector size in bytes */
        u_int sectsperseg;                              /* sectors per segment */
        int   defaultseg;                               /* default unprotected segment */
        u_int (*id_addr)(u_long, int);                  /* id address function pointer */
#if 0 /* cool idea -- lets try to get this done, but filling in all the fields */
      /* will take some time and need lots of care, so commented out for now */
        struct sector_struct sector[16];                /* all sectors */
#endif
} Edt_prominfo ;

#define MAX_DMA_BUFFERS 1024

typedef struct {

    int size;

    int allocated_size;


#if defined(__sun)

    thread_t ring_tid;

#endif

    char write_flag;

 
    char owned;

} EdtRingBuffer;

typedef struct _dma_data_block {
    u_int buffernum;
    u_char *pointer;
    u_int  offset;
    u_int  length;
} EdtDMADataBlock;

#define EDT_SS_TYPE 1
#define EDT_GS_TYPE 2
#define EDT_CD_TYPE 3




typedef struct _optionstr_fields {
   int  board_type;
    int  DMA_channels;
    char mezzanine_type[68];
    char filename[68];
    int  version_number;
    int  rev_number;
    char date[12];
    int  custom_DMA_channels;
    int  available_DMA_channels;
} EdtOptionStringFields;

typedef struct _EdtBitfileDescriptor {
    edt_bitpath bitfile_name;
    edt_bitpath mezz_name0;
    edt_bitpath mezz_name1;
    char optionstr[68];
    char mezz_optionstr0[32];
    char mezz_optionstr1[32];

    EdtOptionStringFields ostr;

    int  revision_register;
    int  string_type;

} EdtBitfileDescriptor;

typedef struct edt_device {
#ifdef __APPLE__
    u_int               fd;
#else
    HANDLE              fd ;           /* file descriptor of opened device     */
#endif
    u_int               unit_no ;
    u_int               spi_reg_base ; /* Base address for SPI_ access registers (0 specifies default of 0x60) */
    uint_t              devid ;
    uint_t              devtype ;          /* 0 == PCI; 1 == USB; ... */
    uint_t              todo;          /* n buffers started            */
    uint_t              b_count;       /* per open byte counter for edt_read/write */

    /* flags for each ring buffer */
    EdtRingBuffer       rb_control[MAX_DMA_BUFFERS];

    /* addresses kept in own array for backward compatibility */

    unsigned char * ring_buffers[MAX_DMA_BUFFERS];

    unsigned char *     tmpbuf;          /* for interlace merging, etc. */

    uint_t              tmpbufsize;

    char                edt_devname[64] ;
    uint_t              cursample ;
    uint_t              minchunk ;
    bufcnt_t            donecount ;
    uint_t              nextwbuf ;     /* for edt_next_writebuf      */

    uint_t              ring_buffer_numbufs ;
    uint_t              ring_buffer_bufsize ;
    uint_t              ring_buffers_allocated ;
    uint_t              ring_buffers_configured ;
    uint_t              loops ;
    uint_t              ring_buffer_allocated_size ; /* if rounded up to page boundaries */

    uint_t              write_flag ;

    uint_t              foi_unit;

    uint_t              debug_level ;
    Dependent           *dd_p ;   /* device dependent struct        */
    void                *Pdma_p;  /* Pdma struct when Pdma used     */

    u_char *            data_end; /* end of base_buffer + 1 */

    /* For callback rountines */

    EdtEventHandler     event_funcs[EDT_MAX_KERNEL_EVENTS];
    u_int               use_RT_for_event_func ;


    u_int channel_no;

    /* Use this for allocating all ring-buffers in a single chunk (w/possible headers before or 
       after the ring-buffers). This is useful when trying to DMA into multiple ring-buffers which
       can be written/read as a block to a file*/

    unsigned char *     base_buffer;

    u_int               header_size;
    int                 header_offset;

    u_int               pending_samples; /* dma samples */

    int                 hubidx;
    volatile caddr_t    mapaddr;

    void *              pInterleaver; /* for post-processing data, such as deinterleaving image */

    unsigned char *output_base;
    unsigned char **output_buffers; /* for results from post-processing */

#ifdef USB
    usb_dev_handle *usb_p ;
    int usb_bulk_read_endpoint ;
    int usb_bulk_write_endpoint ;
    int usb_rtimeout ;
    int usb_wtimeout ;
#endif

    u_int buffer_granularity;
    u_int mmap_buffers;
    u_int totalsize;
    u_int               fullbufsize;

    /* low-latency dma routine fields
     * If we didn't need compatibility this could be a lot cleaner
    */

    EdtDMADataBlock     *blocks;

    double              last_buffer_time;
    double              next_sample;
    u_int               period;
     
    u_char *            last_sample_end;

    u_char              wait_mode;
    u_char              freerun;

    u_char              DMA_channels;

    EdtBitfileDescriptor bfd;
        EdtMezzDescriptor mezz;

    char                last_direction;

} EdtDev;



/* Function declarations for EdtDev */



#ifdef _NT_

#define EDTAPI __declspec(dllexport)

#ifdef LIBDLL

#define EDTIMPORT __declspec(dllimport)

#else

#define EDTIMPORT

#endif

#define strncasecmp strnicmp
#define strcasecmp stricmp

#else

#define EDTAPI
#define EDTIMPORT

#endif

/* Header file for functions exported by libedt */

EDTAPI EdtDev *        edt_open(char *device_name, int unit) ;
EDTAPI EdtDev *        edt_open_quiet(char *device_name, int unit) ;
EDTAPI EdtDev *        edt_open_channel(char *device_name, int unit, int channel) ;
EDTAPI int             edt_close(EdtDev *edt_p) ;
 /* end updown group */

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

EDTAPI int             edt_configure_ring_buffers(EdtDev *edt_p, int bufsize, 
                                                  int numbufs, int write_flag, 
                                                  unsigned char **bufarray) ;

EDTAPI 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);
EDTAPI int             edt_configure_block_buffers(EdtDev *edt_p, int bufsize, 
                                                   int numbufs, int write_flag, 
                                                   int header_size, int header_before);
                                           

EDTAPI int             edt_disable_ring_buffers(EdtDev *edt_p) ;

EDTAPI int              edt_get_numbufs(EdtDev *edt_p);

EDTAPI int                              edt_reset_ring_buffers(EdtDev *edt_p, uint_t bufnum);
EDTAPI int                              edt_abort_dma(EdtDev *edt_p);
EDTAPI int                              edt_abort_current_dma(EdtDev *edt_p);
EDTAPI int                              edt_stop_buffers(EdtDev *edt_p);
EDTAPI int                              edt_start_buffers(EdtDev *edt_p, uint_t count);


EDTAPI int     edt_set_buffer_size(EdtDev *edt_p,
                                   uint_t which_buf,
                                   uint_t size,
                                   uint_t write_flag);

EDTAPI unsigned int             edt_allocated_size(EdtDev *edt_p, int bufnum);
EDTAPI int              edt_get_total_bufsize(EdtDev *edt_p,
                                              int bufsize, 
                                              int header_size);

EDTAPI unsigned char   *edt_wait_for_buffers(EdtDev *edt_p, int count) ;


EDTAPI int                 edt_ref_tmstamp(EdtDev *edt_p, u_int val) ;
EDTAPI int                         edt_get_timestamp(EdtDev *edt_p, u_int *timep, u_int bufnum) ;
EDTAPI int                         edt_get_reftime(EdtDev *edt_p, u_int *timep) ;
EDTAPI unsigned char   *edt_wait_for_next_buffer(EdtDev *edt_p);
EDTAPI unsigned char   *edt_last_buffer_timed(EdtDev *edt_p, u_int *timep) ;
EDTAPI unsigned char   *edt_last_buffer(EdtDev *edt_p) ;
EDTAPI unsigned char   *edt_wait_buffers_timed(EdtDev *edt_p, int count, u_int *timep);
EDTAPI int             edt_set_buffer(EdtDev *edt_p, uint_t bufnum) ;
EDTAPI unsigned char*  edt_next_writebuf(EdtDev    *edt_p) ;
EDTAPI unsigned char** edt_buffer_addresses(EdtDev *edt_p) ;
EDTAPI unsigned char * edt_get_current_dma_buf(EdtDev * edt_p);

EDTAPI bufcnt_t        edt_done_count(EdtDev   *edt_p) ;
EDTAPI unsigned char * edt_check_for_buffers(EdtDev *edt_p, uint_t count);

EDTAPI uint_t                   edt_get_bytecount(EdtDev *edt_p) ;
EDTAPI uint_t                   edt_get_timecount(EdtDev *edt_p) ;
EDTAPI void                             edt_set_direction(EdtDev *edt_p, int direction) ;
EDTAPI uint_t edt_get_timeout_count(EdtDev *edt_p);
EDTAPI unsigned short  edt_get_direction(EdtDev *edt_p) ;

EDTAPI void            edt_startdma_reg(EdtDev *edt_p, uint_t  desc, uint_t val) ;
EDTAPI void            edt_enddma_reg(EdtDev *edt_p, uint_t    desc, uint_t val) ;
EDTAPI void            edt_startdma_action(EdtDev *edt_p, uint_t   val) ;
EDTAPI void            edt_enddma_action(EdtDev *edt_p, uint_t val) ;

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

EDTAPI int                              edt_set_timeout_action(EdtDev *edt_p, u_int action);
EDTAPI int                      edt_get_timeout_goodbits(EdtDev *edt_p);
EDTAPI int                      edt_get_goodbits(EdtDev *edt_p);

EDTAPI int                              edt_set_event_func(EdtDev *edt_p, int event_type, EdtEventFunc f, void *data, int continuous) ;
EDTAPI int                              edt_remove_event_func(EdtDev *edt_p, int event_type) ;

EDTAPI uint_t           edt_get_todo(EdtDev *edt_p) ;
EDTAPI int             edt_ring_buffer_overrun(EdtDev *edt_p) ;
 /* end dma_inout */

/* Internal or obsolete, etc. - we don't want to document these. */
EDTAPI int             edt_configure_channel_ring_buffers(EdtDev *edt_p,
                                                          int bufsize, int numbufs, int write_flag,
                                                          unsigned char **bufarray) ;
EDTAPI int                              edt_disable_ring_buffer(EdtDev *edt_p, 
                                                                int nIndex);
EDTAPI int             edt_cancel_current_dma(EdtDev *edt_p) ;
EDTAPI int             edt_user_dma_wakeup(EdtDev *edt_p);
EDTAPI int             edt_had_user_dma_wakeup(EdtDev *edt_p);

EDTAPI uint_t          edt_reg_read(EdtDev *edt_p, uint_t desc) ;
EDTAPI void            edt_reg_write(EdtDev *edt_p, uint_t desc, uint_t val) ;
EDTAPI uint_t          edt_reg_or(EdtDev *edt_p, uint_t desc, uint_t val) ;
EDTAPI uint_t          edt_reg_and(EdtDev *edt_p, uint_t desc, uint_t val) ;
EDTAPI void          edt_reg_clearset(EdtDev *edt_p, uint_t desc, uint_t val) ;
EDTAPI void          edt_reg_setclear(EdtDev *edt_p, uint_t desc, uint_t val) ;
EDTAPI void            edt_intfc_write(EdtDev *edt_p, uint_t offset, uchar_t val) ;
EDTAPI uchar_t         edt_intfc_read(EdtDev *edt_p, uint_t    offset) ;
EDTAPI void            edt_intfc_write_short(EdtDev *edt_p, uint_t offset, u_short val) ;
EDTAPI u_short         edt_intfc_read_short(EdtDev *edt_p, uint_t offset) ;
EDTAPI void            edt_intfc_write_32(EdtDev   *edt_p, uint_t offset,  uint_t val) ;
EDTAPI uint_t          edt_intfc_read_32(EdtDev *edt_p, uint_t offset) ;
 /* end dma_control */
EDTAPI void                             edt_flush_fifo(EdtDev *edt_p) ;
EDTAPI int                              edt_set_firstflush(EdtDev *edt_p, int val)      ;
EDTAPI int                              edt_get_firstflush(EdtDev *edt_p) ;
EDTAPI void             edt_flush_channel(EdtDev * edt_p, int channel) ;
 /* end dma_fifo */


EDTAPI int             edt_get_wait_status(EdtDev *edt_p);
EDTAPI int             edt_set_timeout_ok(EdtDev *edt_p, int val);
EDTAPI int             edt_get_timeout_ok(EdtDev *edt_p);


/* for a while it was called "eodma_sig" */
EDTAPI void                             pcd_set_funct(EdtDev *edt_p, uchar_t val)       ;
EDTAPI int                              edt_set_eodma_int(EdtDev *edt_p, int sig) ;
EDTAPI int                              edt_set_autodir(EdtDev  *edt_p, int     val) ;


EDTAPI int             edt_send_msg(EdtDev *edt_p, int unit, char *msg, int size) ;
EDTAPI int             edt_get_msg(EdtDev *edt_p, char *msgbuf, int maxsize) ;
EDTAPI int             edt_get_msg_unit(EdtDev *edt_p, char *msgbuf, int maxsize, int unit) ;
EDTAPI int             edt_serial_wait(EdtDev *edt_p, int size, int timeout) ;

EDTAPI void            edt_send_dma(EdtDev *edt_p, int unit, uint_t    start_val) ;
EDTAPI int             edt_wait_avail(EdtDev *edt_p) ;
EDTAPI void            edt_init_mac8100(EdtDev *edt_p) ;
EDTAPI u_short         edt_read_mac8100(EdtDev *edt_p, uint_t add) ;
EDTAPI void            edt_write_mac8100(EdtDev *edt_p, uint_t add, u_short data) ;

EDTAPI int             edt_get_dependent(EdtDev *edt_p, void *addr) ;
EDTAPI int             edt_set_dependent(EdtDev *edt_p, void *addr) ;

EDTAPI int             edt_flush_resp(EdtDev *edt_p) ;
EDTAPI int             edt_get_tracebuf(EdtDev *edt_p, uint_t *addr)   ;
EDTAPI int             edt_set_flush(EdtDev *edt_p, int val) ;
EDTAPI int             edt_timeouts(EdtDev *edt_p) ; /* end dma_inout */


EDTAPI void            edt_flush_mode(EdtDev *edt_p, uint_t    val) ;

EDTAPI void            edt_check_foi(EdtDev *edt_p) ;
EDTAPI void            edt_foi_autoconfig(EdtDev *edt_p) ;
EDTAPI int             edt_set_foiunit(EdtDev *edt_p, int unit) ;
EDTAPI int             edt_get_foiunit(EdtDev *edt_p) ;

EDTAPI int             edt_set_rci_dma(EdtDev *edt_p, int unit, int channel) ;
EDTAPI int             edt_get_rci_dma(EdtDev *edt_p, int unit) ;                       
EDTAPI int             edt_set_rci_chan(EdtDev *edt_p, int unit, int channel) ;
EDTAPI int             edt_get_rci_chan(EdtDev *edt_p, int unit) ;


EDTAPI void            edt_reset_counts(EdtDev *edt_p) ;
EDTAPI void            edt_reset_serial(EdtDev *edt_p) ;
EDTAPI int             edt_set_foicount(EdtDev *edt_p, int count) ;
EDTAPI int             edt_get_foicount(EdtDev *edt_p) ;


EDTAPI int             edt_set_debug(EdtDev *edt_p, int count) ;
EDTAPI int             edt_get_debug(EdtDev *edt_p) ;


EDTAPI int             edt_set_burst_enable(EdtDev *edt_p, int on) ;
EDTAPI int             edt_get_burst_enable(EdtDev *edt_p) ;

EDTAPI int             edt_set_rtimeout(EdtDev *edt_p, int value) ;
EDTAPI int             edt_set_wtimeout(EdtDev *edt_p, int value) ;

EDTAPI int             edt_get_rtimeout(EdtDev *edt_p) ;
EDTAPI int             edt_get_wtimeout(EdtDev *edt_p) ; /* end dma_inout */

EDTAPI void            edt_set_out_clk(EdtDev *edt_p, edt_pll *clk_data) ;
EDTAPI u_char          edt_set_funct_bit(EdtDev    *edt_p, u_char mask) ;
EDTAPI u_char          edt_clr_funct_bit(EdtDev    *edt_p, u_char mask) ;
EDTAPI u_char          edt_set_pllct_bit(EdtDev * edt_p, u_char mask);
EDTAPI u_char          edt_clr_pllct_bit(EdtDev * edt_p, u_char mask);
EDTAPI int             edt_set_ignore_signals(EdtDev *edt_p, int ignore);







EDTAPI int             edt_device_id(EdtDev *edt_p);
EDTAPI char *          edt_idstr(int id) ;
EDTAPI uchar_t *       edt_alloc(int size) ;
EDTAPI void            edt_free(uchar_t *ptr) ;
EDTAPI int                         edt_access(char *fname, int perm) ;
EDTAPI int                         edt_parse_unit(const char *str, char *dev, const char *default_dev) ;
EDTAPI int                         edt_parse_unit_channel(const char *str, char *dev, 
                                                          const char *default_dev,
                                                          int *channel) ;
EDTAPI int             edt_access(char *fname, int perm);
EDTAPI void            edt_correct_slashes(char *str);
EDTAPI void            edt_fwd_to_back(char *str);
EDTAPI void            edt_back_to_fwd(char *str);
EDTAPI int             edt_find_xpn(char *partnum, char *xilinx);
EDTAPI uint_t          edt_overflow(EdtDev *edt_p) ;
EDTAPI void            edt_perror(char *str) ;
EDTAPI u_int           edt_errno(void) ;

EDTAPI char *           edt_timestring(u_int *timep) ;
EDTAPI int             edt_system(const char *cmdstr) ;
EDTAPI int              edt_fix_millennium(char *str, int rollover);

EDTAPI char             *edt_fmt_pn(char *pn, char *pn_str);
EDTAPI int              edt_parse_esn(char *str, Edt_embinfo *ei);
EDTAPI void             edt_get_sns(EdtDev *edt_p, char *esn, char *osn);
EDTAPI void             edt_get_sns_sector(EdtDev *edt_p, char *esn, char *osn, int sector);
EDTAPI void             edt_get_osn(EdtDev *edt_p, char *osn);
EDTAPI void             edt_get_esn(EdtDev *edt_p, char *esn);

EDTAPI DIRHANDLE edt_opendir(char *dirname);
EDTAPI int edt_readdir(DIRHANDLE h, char *name);
EDTAPI void edt_closedir(DIRHANDLE h);


/* System time functions */
EDTAPI double          edt_dtime(void);
EDTAPI double          edt_timestamp(void);
EDTAPI double          edt_elapsed(u_char reset);

EDTAPI void            edt_msleep(int  msecs) ;
EDTAPI void