Club Amiga de Montreal - CAM/CAM_CD_1.iso/files/171.lha/SupLib/dio.c

C/C++ Source or Header | 1988-04-28 | 10.9 KB | 423 lines

/*
 *  DIO.C
 *
 *  (C)Copyright 1987 by Matthew Dillon, All rights reserved
 *  Freely distributable.  Donations Welcome.  This is NOT shareware,
 *  This is NOT public domain.
 *
 *    Matthew Dillon
 *    891 Regal Rd.
 *    Berkeley, Ca. 94708
 *
 *  EXEC device driver IO support routines... makes everything easy.
 *
 *  dfd = dio_open(name, unit, flags, req/NULL)
 *
 *    open an IO device.  Note: in some cases you might have to provide
 *    a request structure with some fields initialized (example, the
 *    console device requires certain fields to be initialized).  For
 *    instance, if openning the SERIAL.DEVICE, you would want to give
 *    an IOExtSer structure which is completely blank execept for the
 *    io_SerFlags field.
 *
 *    The request structure's message and reply ports need not be
 *    initialized.  The request structure is no longer needed after
 *    the dio_open().
 *
 *    NULL = error, else descriptor (a pointer) returned.
 *
 *
 *  dio_close(dfd)
 *
 *    close an IO device.  Any pending asyncronous requests are
 *    AbortIO()'d and then Wait'ed on for completion.
 *
 *
 *  dio_closegrp(dfd)
 *
 *    close EVERY DIO DESCRIPTOR ASSOCIATED WITH THE dio_open() call
 *    that was the parent for this descriptor.  That is, you can get
 *    a descriptor using dio_open(), dio_dup() it a couple of times,
 *    then use dio_closegrp() on any ONE of the resulting descriptors
 *    to close ALL of them.
 *
 *
 *  dio_ddl(dfd,bool)
 *
 *    Disable BUF and LEN fields in dio_ctl[_to].. dummy parameters
 *    must still be passed, but they are not loaded into the io_Data
 *    and io_Length fields of the io request.  This is for devices
 *    like the AUDIO.DEVICE which has io_Data/io_Length in non-standard
 *    places.
 *
 *  dio_cact(dfd,bool)
 *
 *    If an error occurs (io_Error field), the io_Actual field is usually
 *    not modified by the device driver, and thus contains garbage.  To
 *    provide a cleaner interface, you can have DIO_CTL() and DIO_CTL_TO()
 *    calls automatically pre-clear this field so if an io_Error does
 *    occur, the field is a definate 0 instead of garbage.
 *
 *    In most cases you will want to do this.  An exception is the
 *    TIMER.DEVICE, which uses the io_Actual field for part of the
 *    timeout structure.
 *
 *    This flags the particular dio descriptor to do the pre-clear, and
 *    any new descriptors obtained by DIO_DUP()ing this one will also
 *    have the pre-clear flag set.
 *
 *
 *  dio_dup(dfd)
 *
 *    Returns a new channel descriptor referencing the same device.
 *    The new descriptor has it's own signal and IO request structure.
 *    For instance, if you openned the serial device, you might want
 *    to dup the descriptor so you can use one channel to pend an
 *    asyncronous read, and the other channel to write out to the device
 *    and do other things without disturbing the asyncronous read.
 *
 *
 *  sig = dio_signal(dfd)
 *
 *    get the signal number (0..31) used for a DIO descriptor.
 *    This allows you to Wait() for asyncronous requests.  Note that
 *    if your Wait() returns, you should double check using dio_isdone()
 *
 *      dio_flags(dfd, or, ~and)
 *
 *    Modify the io_Flags field in the request, ORing it with the OR
 *    mask, and ANDing it with ~AND mask.  E.G., the AUDIO.DEVICE requires
 *    some flags be put in io_Flags.
 *
 *  req = dio_ctl_to(dfd, command, buf, len, to)
 *
 *    Same as DIO_CTL() below, but (A) is always syncronous, and
 *    (B) will attempt to AbortIO()+WaitIO() the request if the
 *    timeout occurs before the IO completes.
 *
 *    the 'to' argument is in microseconds.
 *
 *    If timeout occurs before request completes, and DIO aborts the
 *    request, some devices do not have the io_Actual field set
 *    properly.
 *
 *  req = dio_ctl(dfd, command, buf, len)
 *
 *    DIO_CTL() is the basis for the entire library.  It works as follows:
 *
 *    (1) If the channel isn't clear (there is an asyncronous IO request
 *        still pending), DIO_CTL() waits for it to complete
 *
 *    (2) If the command is 0, simply return a pointer to the io
 *        request structure.
 *
 *    (3) If the DIO_CACT() flag is TRUE, the io_Actual field of the
 *        request is cleared.
 *
 *    (4) Set the io_Data field to 'buf', and io_Length field to 'len'
 *        If the command is positive, use DoIO().  If the command
 *        negative, take it's absolute value and then do a SendIO().
 *        (The command is placed in the io_Command field, of course).
 *
 *    (5) return the IO request structure
 *
 *
 *  bool= dio_isdone(dfd)
 *
 *    return 1 if current channel is clear (done processing), else 0.
 *    e.g. if you did, say, an asyncronous read, and dio_isdone() returns
 *    true, you can now use the data buffer returned and look at the
 *    io_Actual field.
 *
 *    You need not do a dio_wait() after dio_isdone() returns 1.
 *
 *
 *  req = dio_wait(dfd)
 *
 *    Wait on the current channel for the request to complete and
 *    then return the request structure. (nop if channel is clear)
 *
 *
 *  req = dio_abort(dfd)
 *
 *    Abort the request on the current channel (nop if channel is
 *    clear).  Sends an AbortIO() if the channel is active and then
 *    WaitIO()'s the request.
 *
 *
 *  MACROS: SEE DIO.H
 *
 */

#include <exec/types.h>
#include <exec/io.h>
#include <exec/memory.h>
#include <exec/ports.h>
#include <devices/timer.h>
#include <local/xmisc.h>

#define MPC        (MEMF_CLEAR|MEMF_PUBLIC)
#define CPORT        ior.ior.io_Message.mn_ReplyPort
#define MAXREQSIZE  128     /* big enough to hold all Amiga iorequests */

typedef struct IORequest IOR;
typedef struct IOStdReq  STD;
typedef struct MsgPort     PORT;

typedef struct {
    STD ior;
    char filler[MAXREQSIZE-sizeof(STD)];
} MAXIOR;

typedef struct {
    struct _CHAN *list;
    short refs;
} DIO;

typedef struct _CHAN {
    MAXIOR  ior;
    DIO     *base;
    XLIST   link;    /* doubly linked list */
    STD     timer;
    char    notclear;
    char    cact;    /* automatic io_Actual field clear  */
    char    ddl;
    UBYTE   flagmask;
} CHAN;

extern CHAN *dio_ctl(), *dio_ctl_to(), *dio_wait(), *dio_abort();
extern PORT *CreatePort();
extern char *AllocMem();

CHAN *
dio_open(name, unit, flags, req)
char *name;
MAXIOR *req;     /* not really this big  */
{
    register CHAN *chan;
    register DIO *dio;
    register PORT *port;
    int ret;

    dio = (DIO *)AllocMem(sizeof(DIO), MPC);    if (!dio)   goto fail3;
    chan= (CHAN *)AllocMem(sizeof(CHAN), MPC);  if (!chan)   goto fail2;
    if (req)
    chan->ior = *req;
    chan->CPORT = CreatePort(NULL,0);           if (!chan->CPORT) goto fail1;
    chan->ior.ior.io_Message.mn_Node.ln_Type = NT_MESSAGE;
    chan->base = dio;
    chan->flagmask = 0xF0;
    dio->refs = 1;
    if (OpenDevice(name, unit, &chan->ior, flags)) {
    DeletePort(chan->CPORT);
fail1:    FreeMem(chan, sizeof(CHAN));
fail2:    FreeMem(dio, sizeof(DIO));
fail3:    return(NULL);
    }
    llink(&dio->list, &chan->link);
    chan->ior.ior.io_Flags = 0;
    return(chan);
}

void
dio_dfm(chan,mask)
CHAN *chan;
{
    chan->flagmask = mask;
}

void
dio_ddl(chan,n)
CHAN *chan;
{
    chan->ddl = n;
}

void
dio_cact(chan,n)
CHAN *chan;
{
    chan->cact = n;
}

void
dio_close(chan)
register CHAN *chan;
{
    dio_abort(chan);
    lunlink(&chan->link);
    if (--chan->base->refs == 0) {
    FreeMem(chan->base, sizeof(DIO));
    CloseDevice(&chan->ior);
    }
    if (chan->timer.io_Message.mn_ReplyPort)
    CloseDevice(&chan->timer);
    DeletePort(chan->CPORT);
    FreeMem(chan, sizeof(CHAN));
}

void
dio_closegroup(chan)
register CHAN *chan;
{
    register CHAN *nextc;

    for (chan = chan->base->list; chan; chan = nextc) {
    chan = (CHAN *)((char *)chan - ((char *)&chan->link - (char *)chan));
    nextc = (CHAN *)chan->link.next;
    dio_close(chan);
    }
}


CHAN *
dio_dup(chan)
register CHAN *chan;
{
    register CHAN *nc;

    if (chan) {
    nc = (CHAN *)AllocMem(sizeof(CHAN), MPC);   if (!nc) goto fail2;
    nc->ior = chan->ior;
    nc->base = chan->base;
    nc->CPORT = CreatePort(NULL,0);         if (!nc->CPORT) goto fail1;
    nc->ior.ior.io_Flags = NULL;
    nc->cact = chan->cact;
    nc->ddl = chan->ddl;
    nc->flagmask = chan->flagmask;
    ++nc->base->refs;
    llink(&nc->base->list, &nc->link);
    return(nc);
fail1:    FreeMem(nc, sizeof(CHAN));
    }
fail2:
    return(NULL);
}

dio_signal(chan)
CHAN *chan;
{
    return(chan->CPORT->mp_SigBit);
}

dio_flags(chan,or,and)
long chan;
{
    IOR *ior = (void *)chan;

    ior->io_Flags = (ior->io_Flags | or) & ~and;
}


CHAN *
dio_ctl_to(chan, com, buf, len, to)
register CHAN *chan;
char *buf;
{
    register long mask;

    if (chan->timer.io_Message.mn_ReplyPort == NULL) {
    chan->timer.io_Message.mn_ReplyPort = chan->CPORT;
    chan->timer.io_Message.mn_Node.ln_Type = NT_MESSAGE;
    if (OpenDevice("timer.device", UNIT_VBLANK, &chan->timer, 0)) {
        puts("Panic: DIO_CTL_TO: No timer.device");
    }
    chan->timer.io_Command = TR_ADDREQUEST;
    }
    mask = 1 << chan->CPORT->mp_SigBit;
    dio_ctl(chan, (com>0)?-com:com, buf, len);  /* SendIO the request */
    chan->timer.io_Actual = to / 1000000;
    chan->timer.io_Length = to % 1000000;    /* setup timer          */
    chan->timer.io_Flags = 0;
    BeginIO(&chan->timer);          /* start timer running  */
    while (Wait(mask)) {            /* Wait for something   */
    if (CheckIO(chan))          /* request done         */
        break;
    if (CheckIO(&chan->timer)) {    /* timeout?           */
        dio_abort(chan);
        break;
    }
    }
    AbortIO(&chan->timer);          /*  kill the timer  */
    WaitIO(&chan->timer);           /*  remove from rp  */
    return(chan);                   /*  return ior  */
}


CHAN *
dio_ctl(chan, com, buf, len)
register CHAN *chan;
char *buf;
{
    if (chan->notclear) {   /* wait previous req to finish */
    WaitIO(chan);
    chan->notclear = 0;
    }
    if (com) {
    if (chan->cact)
        chan->ior.ior.io_Actual = 0;    /* initialize io_Actual to 0*/
    chan->ior.ior.io_Error = 0;        /* initialize error to 0 */
    if (!chan->ddl) {
        chan->ior.ior.io_Data = (APTR)buf;  /* buffer   */
        chan->ior.ior.io_Length = len;    /* length   */
    }
    if (com < 0) {                      /* asyncronous IO  */
        chan->ior.ior.io_Command = -com;
        chan->notclear = 1;
        chan->ior.ior.io_Flags &= chan->flagmask;
        BeginIO(chan);
    } else {                /* syncronous IO  */
        chan->ior.ior.io_Command = com;
        chan->ior.ior.io_Flags = (chan->ior.ior.io_Flags & chan->flagmask) | IOF_QUICK;
        BeginIO(chan);
        if (!(chan->ior.ior.io_Flags & IOF_QUICK))
        WaitIO(chan);
    }
    }
    return(chan);
}


CHAN *
dio_isdone(chan)
register CHAN *chan;
{
    if (chan->notclear) {       /* if not clear */
    if (CheckIO(chan)) {    /* if done      */
        WaitIO(chan);       /* clear        */
        chan->notclear = 0;
        return(chan);       /* done         */
    }
    return(NULL);           /* notdone      */
    }
    return(chan);               /* done         */
}


CHAN *
dio_wait(chan)
register CHAN *chan;
{
    if (chan->notclear) {
    WaitIO(chan);           /* wait and remove from rp */
    chan->notclear = 0;
    }
    return(chan);
}


CHAN *
dio_abort(chan)
register CHAN *chan;
{
    if (chan->notclear) {
    AbortIO(chan);          /* Abort it   */
    WaitIO(chan);           /* wait and remove from rp */
    chan->notclear = 0;
    }
    return(chan);
}