/*
 *  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 "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);
}