libedt.c

/* #pragma ident "@(#)libedt.c  1.396 05/29/07 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();
#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
static void *
edt_wait_event_thread(void *);

#endif

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

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

int edt_driver_type = -1;

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 (%lx) in edt_open failed\n", 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->foi_unit ;
        edt_ioctl(edt_p, EDTS_RESETSERIAL, &dmy);

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

    edt_driver_type = edt_get_drivertype(edt_p);

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

unsigned char *
edt_alloc(int size)
{
    unsigned char *ret;

#ifdef _NT_
    ret = (unsigned char *)
        VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
#else
#if defined(AV3_BOARD) || defined(XCALIBURCOMMON)
    ret = (unsigned char *) edt_vmalloc(size);
#else
    ret = (unsigned char *) valloc(size);
#if defined(__linux__) || defined(sgi) || defined(VXWORKS)
    if (ret)
    {
        u_char *tmp_p;

        for (tmp_p = ret; tmp_p < ret + size; tmp_p += 4096)
        {
            /* edt_msg(EDTDEBUG, "touching %x\n",tmp_p) ; */
            *tmp_p = 0xa5;
        }
    }
#endif
#endif

#endif
    return (ret);
}

void
edt_free(uchar_t *ptr)
{
#ifdef _NT_
    VirtualFree(ptr, 0, MEM_RELEASE);
#else
#if defined(AV3_BOARD) || defined(XCALIBURCOMMON)
    edt_vfree(ptr);
#else
    free(ptr);
#endif
#endif
}


#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;
    }
    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;
    int pagen = EDT_DMAMEM_OFFSET;


#ifdef __linux__

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