/*
 * Glib - Generic LIBrarian and editor
 *
 * Machine dependent stuff for MIDI programs.
 *
 * This is for MS-DOS machines.  The screen operations should
 * work okay, but the MIDI I/O needs to be worked on.  It may
 * or may not be fast enough on some machines. 
 */

#include "dos.h"
#include "glib.h"

#define C86
#ifdef C86
#define inp inportb
#define outp outportb
#endif

int Rows = 24;
int Cols = 80;

flushmidi()
{
        while ( statmidi() )
                getmidi();
}

/* getmouse - get currect row and column of mouse */
getmouse(amr,amc)
int *amr;
int *amc;
{
        *amr = -1;
        *amc = -1;
}

/* statmouse - return mouse button state (0=nothing pressed,1=left,2=right) */
statmouse()
{
        return(-1);
}

/* Return when either a console key or mouse button is pressed. */
mouseorkey()
{
        return(getconsole());
}

flushconsole()
{
}

statconsole()
{
        struct regval sreg, rreg;
        sreg.ax = 0x0100;
        sysint(0x16, &sreg, &rreg);
        if ( rreg.ax != 0 )
                return(1);
        else
                return(0);
}

getconsole()
{
        struct regval sreg, rreg;
        sreg.ax = 0x0000;
        sysint(0x16, &sreg, &rreg);
        return(rreg.ax & 0x7f);
}

long milliclock()
{
        static int hour1 = -1, min1, sec1, hund1;
        struct regval sreg, rreg;
        int hours, mins, secs, hunds;
        long mills;

        sreg.ax = 0x2c00;
        sysint(0x21, &sreg, &rreg);
        hours = (rreg.cx >> 8) & 0x7f;
        mins = rreg.cx & 0x7f;
        secs = (rreg.dx >> 8) & 0x7f;
        hunds = rreg.dx & 0x7f ;
        if ( hour1 < 0 ) {
                mills = 0L;
                hour1 = hours;
                min1 = mins;
                sec1 = secs;
                hund1 = hunds;
        }
        else {
                mills = 10L*(hunds-hund1)+1000L*(secs-sec1)
                        +60000L*(mins-min1)+360000L*(hours-hour1);
        }
        return( mills );
}

char *
alloc(n)
{
        char *p;

        if ( (p=malloc((unsigned)n)) == (char *)NULL ) {
                printf("*** Whoops *** alloc has failed?!?  No more memory!\n");
                fflush(stdout);
                bye();
        }
        return(p);
}

windinit()
{
}

windgoto(r,c)
int r,c;
{
        struct regval sreg, rreg;
        sreg.ax = 0x200;
        sreg.bx = 0;
        sreg.dx = (r<<8) | c ;
        sysint(0x10, &sreg, &rreg);
}

winderaserow(r)
{
        struct regval sreg, rreg;
        sreg.ax = 0x0600;
        sreg.bx = 0;
        sreg.cx = (r<<8);       /* urow, lcol */
        sreg.dx = (r<<8) | 79;
        sysint(0x10, &sreg, &rreg);
}

windexit(r)
int r;
{
        /* windgoto(23,0);
        windrefresh();
        nocbreak();
        nl();
        echo();
        endwin(); */
}

windclear()
{
        struct regval sreg, rreg;
        sreg.ax = 0x0600;
        sreg.bx = 0;
        sreg.cx = 0;    /* urow, lcol */
        sreg.dx = (24<<8) | 79;
        sysint(0x10, &sreg, &rreg);
}

/* windgets - get a line of input from the console, handling backspaces */
windgets(s)
char *s;
{
        char *origs = s;
        int c;

        while ( (c=getconsole()) != '\n' && c!='\r' && c!= EOF ) {
                if ( c == '\b' ) {
                        if ( s > origs ) {
                                windstr("\b \b");
                                s--;
                        }
                }
                else {
                        windputc(c);
                        *s++ = c;
                }
                windrefresh();
        }
        *s = '\0';
}

windstr(s)
char *s;
{
        int c;

        while ( (c=(*s++)) != '\0' )
                windputc(c);
}

windputc(c)
int c;
{
        putchar(c);
}

windrefresh()
{
}

beep()
{
        putchar('\007');
}

windhigh()
{
}

windnorm()
{
}

/****************
 * openls(), nextls(), and closels() are used to scan the current directory.
 ***************/

openls()
{
}
char *
nextls()
{
        return(NULL);
}
closels()
{
}

/*
 * The following MPU code has been provided by Steve Frysinger (moss!spf).
 */

#define STATUS_PORT     0x0331
#define COMMAND_PORT    0x0331
#define DATA_PORT       0x0330
#define DATA_READY_MASK 0x40
#define DATA_AVAIL_MASK 0x80

int send_command_4001(val)      /* Patterned after Voyetra's reset_4001() */
unsigned val;
{
        unsigned x = 0;
        int flag;
        int ack_count,time_count;
        int retval=1; /* Assume success */
        inp(DATA_PORT);
        for (time_count=5000,flag=1;time_count&&flag;time_count--)
        {
                if (!(inp(STATUS_PORT)&DATA_READY_MASK)) flag=0;
        }
        if (flag)
        {
                fprintf(stderr,"Command timeout waiting for port!\n");
                retval = -1;
        }
        else
        {
                outp(COMMAND_PORT,val);
                for (time_count=10000,ack_count=5,flag=0;!flag;)
                {
                        if ((inp(STATUS_PORT)&DATA_AVAIL_MASK))
                        {
                                time_count--;
                                if (!time_count)
                                {
                                        flag++;
                                        fprintf(stderr,"Command timeout waiting for ACK.\n");
                                        retval = -1;
                                }
                        }
                        else
                        {
                                x = (unsigned)inp(DATA_PORT);
                                if (x == 0xfe)
                                {
                                        flag++;
                                        fprintf(stderr,"Got command acknowledgement\n");
                                }
                                else
                                {
                                        ack_count--;
                                        if (!ack_count)
                                        {
                                                printf("Too many data bytes without ACK\n");
                                                retval = -1;
                                        }
                                }
                        }
                }
        }
        return(retval);
} /* send_command_4001 */

getmidi()
{
        while (inp(STATUS_PORT) & DATA_AVAIL_MASK)
                ; /* Wait for data available */
        return(inp(DATA_PORT));
}

statmidi()
{
        if ( inp(STATUS_PORT) & DATA_AVAIL_MASK) /* data available ? */
                return(0);
        else
                return(1);
}

sendmidi(val)
int val;
{
        int timeout = 10000;

        unsigned status;
        status=inp(STATUS_PORT);
        while (status & DATA_READY_MASK)
                printf("Busy; read %d ",getmidi());
        /*
        This printf lets me know what's holding up the transfer; I usually get
        254 back, unless I press a synth key, when I get the key press parameters.
        */
        outp(DATA_PORT,val);
}

hello()
{
        send_command_4001(0xff);        /* reset */
        send_command_4001(0x96);        /* kill RT? */
        send_command_4001(0x94);        /* ?? */
        send_command_4001(0x90);        /* ?? */
        send_command_4001(0x3f);        /* go into uart mode */
}

bye()
{
        send_command_4001(0xff);        /* reset */
        windexit(0);
}