PAGE	50,132	
	 TITLE	MIDI Interface Device Driver
	 %OUT	MIDI Interface Device Driver
	 ;***************************************************************
	 ;*			     MPU401				*
	 ;*								*
	 ;* This program is loaded as an I/O driver during MSDOS initi-	*
	 ;* alization. It contains a driver for a MIDI (Music Instru-	*
	 ;* ment Digital Interface) interface, the MPU401 from Roland	*
	 ;* Corp. This software has been tsted using an MPU401 with	*
	 ;* software revision level 1.5A.				*
	 ;*								*
	 ;* This driver acknowledges only three function requests from	*
	 ;* DOS, namely INIT, CHIN and CHOUT. INIT is for usage by DOS	*
	 ;* during system start-up. CHOUT receives control data setting	*
	 ;* the software interrupt number. The CHIN request passes an	*
	 ;* infinite stream of characters denoting the current software	*
	 ;* interrupt number. Consequently, an application program can	*
	 ;* set and read what software interrupt is used.		*
	 ;*								*
	 ;* Software interrupts lower than 35H are not allowed, because	*
	 ;* they may conflict with values used by MSDOS. Higher values	*
	 ;* may also conflict with DOS, but for these it is more unli-	*
	 ;* kely. Eventually you will need to find an own soft inter-	*
	 ;* rupt number. The default (68H) works nicely on the system	*
	 ;* where the driver was developed. You can set the software	*
	 ;* interrupt level by editing your CONFIG.SYS file.		*
	 ;*								*
	 ;* All access to the driver from a user program (except set-	*
	 ;* ting/reading the software interrupt number) is done using	*
	 ;* software interrupts, since then you don't have to pass	*
	 ;* through DOS's dispatcher etc. Software interrupt is much	*
	 ;* faster.							*
	 ;*								*
	 ;* When the application program issues a software interrupt,	*
	 ;* register AX should contain the desired 'function code',	*
	 ;* similar to a DOS INT21 call. Note that AX, not AH is used.	*
	 ;* The following 'function codes' are defined:			*
	 ;*								*
	 ;* 0	SINIT	Driver initialize				*
	 ;* 1	SFINI	Driver finitialize				*
	 ;* 2	SSTAT	Get driver status				*
	 ;* 3	SRERR	Reset error flags				*
	 ;* 4	SSTIM	Set timer					*
	 ;* 5	SRTIM	Read timer					*
	 ;* 6	SFBUF	Flush input data buffer				*
	 ;* 7	SRBUF	Read input data buffer				*
	 ;* 8	STBUF	Test input data buffer				*
	 ;* 9	SDXBF	Define exclusive message buffer			*
	 ;* 10  SFXBF	Flush exclusive message buffer			*
	 ;* 11	SRXBF	Read exclusive message buffer			*
	 ;* 12	STXBF	Test exclusive message buffer			*
	 ;* 13	SOCMD	Send MPU command				*
	 ;* 14	SODAT	Send MPU data					*
	 ;*								*
	 ;* Some software interrupts return with a completion code in	*
	 ;* register DX and/or a return value in AX. (DX-AX are the	*
	 ;* registers for a 'long' return value used by most 'C' com-	*
	 ;* pilers - MicroSoft, Wizard, DeSmet, and (yech!) Digital	*
	 ;* Research. Lattice uses BX-AX).				*
	 ;*								*
	 ;* Data coming from the MPU401 is by default buffered in an	*
	 ;* internal buffer ('DBUF') which has a default size of 1 kb.	*
	 ;* At driver initialization, another size may be selected for	*
	 ;* this buffer. An application program may also allocate it's	*
	 ;* own data buffer, which will then be used by the driver in-	*
	 ;* stead of the internal one. MIDI exclusive messages are not	*
	 ;* buffered by default - they are just ignored. An applica-	*
	 ;* tion may set up an own buffer for these.			*
	 ;*								*
	 ;* The driver responds to certain parameters in the invoca-	*
	 ;* tion line in CONFIG.SYS:					*
	 ;*								*
	 ;* DEVICE=MPU401.DEV /B:nnnn /H:n /P:nnnn /S:nn		*
	 ;*								*
	 ;* /B:nnnn	Set Internal Buffer Size to nnnn (200H <= n	*
	 ;*		<= 8000H)					*
	 ;* /H:n	Set Hardware Interrupt to n (0-0FH for an AT,	*
	 ;*		0-7 for an XT).					*
	 ;* /P:nnnn	Set MPU401 Port Address to nnnn (0-3FFH).	*
	 ;* /S:nn	Set Software Interrupt number to nn (35H-0FFH).	*
	 ;*		(May also be changed by application.)		*
	 ;*								*
	 ;* (n, nn, and nnnn are given in hexadecimal notation.)	*
	 ;***************************************************************
	 ;*								*
	 ;* Original Author B. Larsson - All wrongs reserved.		*
	 ;*								*
	 ;* (Many ideas taken from the CMU MIDI Toolkit sources -	*
	 ;*  notably aintr.asm, mpu.c and cintr.c. Regards to the	*
	 ;*  authors of all those).					*
	 ;*								*
	 ;***************************************************************
	 ;* I herewith place this software is in the PUBLIC DOMAIN. You	*
	 ;* are free to make any modifications to it that you want. THE	*
	 ;* ONLY RESTRICTION is that you PLEASE leave the credit notes	*
	 ;* of all previous authors in the source. Please also maintain	*
	 ;* a proper change log, so that followers see what has been	*
	 ;* done, and WHY! Thank You!					*
	 ;***************************************************************
	 ;*								*
	 ;* 1.0:  Started:					870105	*
	 ;*	  Functional and debugged except exclusive		*
	 ;*	  soft ints:					870112	*
	 ;* 1.1:  Exclusive buffer implemented:			870117	*
	 ;* 1.2:  Does 5000 dummy byte reads from MPU401 at		*
	 ;*	  initialization before it gives up (did just		*
	 ;*	  200):						870118	*
	 ;* 1.30: Cute little sign-on string:			871109	*
	 ;***************************************************************
	 ;
CODSEG	 SEGMENT PUBLIC PARA 'CODE'
	 ASSUME	 CS:CODSEG,ES:NOTHING,DS:NOTHING
	 ;
	 SUBTTL	Equates
	 %OUT	Equates
	 PAGE
	 ;
	 ;***************************************************************
	 ;* Equates							*
	 ;***************************************************************
	 ;
	 ;* ASCII Equates.
	 ;
ASCICR	 EQU	0DH				;CARRIAGE RETURN
ASCILF	 EQU	0AH				;LINE FEED
UCMASK	 EQU	5FH				;MASKS LOWER CASE TO UPPER
	 ;
	 ;* System related equates.
	 ;
SYSTEM	 EQU	21H				;SYSTEM CALL
PRTSTR	 EQU	9				;PRINT STRING REQUEST
JFAROPC	 EQU	0EAH				;JUMP FAR OP-CODE
	 ;
	 ;* Device driver equates.
	 ;
DEVATR	 EQU	1000000000000000B		;DEVICE ATTRIBUTES
INITRQ	 EQU	0				;INIT FUNCTION REQUEST
CHINRQ	 EQU	4				;CHIN FUNCTION REQUEST
CHOUTRQ	 EQU	8				;CHOUT FUNCTION REQUEST
	 ;
RDYSTT	 EQU	0000000100000000B		;READY STATUS	 RETURN CODE
WRPSTT	 EQU	1000000000000000B		;WRITE PROTECT	 RETURN CODE
ILLSTT	 EQU	1000000000000011B		;BAD REQ STATUS	 RETURN CODE
	 ;
	 ;* I/O Request header offsets.
	 ;
CMDOFS	 EQU	2				;REQUEST CODE	 REQ HDR OFS
STTOFS	 EQU	3				;RETURN STATUS	 REQ HDR OFS
UNCOFS	 EQU	13				;RETURN UNITCODE REQ HDR OFS
EOFOFS	 EQU	14				;END ADDR OFFSET REQ HDR OFS
ESGOFS	 EQU	16				;END ADDR SEG	 REQ HDR OFS
PDOOFS	 EQU	14				;PARM WRD OFS	 REQ HDR OFS
PDSOFS	 EQU	16				;PARM WRD SEG	 REQ HDR OFS
BCTOFS	 EQU	18				;BYTE COUNT	 REQ HDR OFS
PMOOFS	 EQU	18				;ARGUMENT OFFS	 REQ HDR OFS
PMSOFS	 EQU	20				;ARGUMENT SEG	 REQ HDR OFS
	 ;
	 ;* Default values.
	 ;
DDATPORT EQU	330H				;DEFAULT DATA PORT LOCATION
DCTLPORT EQU	331H				;DEFAULT CTRL PORT LOCATION
PORTMAX	 EQU	7FEH				;MAX PORT LOCATION
DHRDINT	 EQU	2				;DEFAULT HARD INT TO USE
DSFTINT	 EQU	68H				;DEFAULT SOFT INT TO USE
MINSFTI	 EQU	35H				;MINIMUM SOFT INT TO USE
MAXSFTI	 EQU	0FFH				;MAXIMUM SOFT INT TO USE
	 ;
	 ;* MIDI port values.
	 ;
DSRBIT	 EQU	80H				;DSR BIT MASK
DRRBIT	 EQU	40H				;DRR BIT MASK
	 ;
	 ;* Buffer size values.
	 ;
MINBSIZ	 EQU	512				;MIN BUFFER SIZE
DIBSIZ	 EQU	1024				;DEFAULT 1K INTERNAL BUFFER
MAXBSIZ	 EQU	32768				;MAX BUFFER SIZE
	 ;
	 ;* Software interrupt completion codes.
	 ;
CPLOK	 EQU	0				;OK COMPLETION
CPLIFNC	 EQU	1				;ILLEGAL FUNCTION CODE
CPLPASS	 EQU	2				;DRIVER INACTIVE
CPLMOFL	 EQU	3				;MIDI PROVIDES TOO MUCH DATA
CPLPRTE	 EQU	4				;MIDI PROTOCOL ERROR
CPLBERR	 EQU	5				;INVALID BUFFER SPECIFICATION
CPLTERR	 EQU	6				;MIDI TIMEOUT ERROR
CPLNOXB	 EQU	7				;EXCLUSIVE BUFFER NOT DEFINED
	 ;
	 ;* MPU401 and MIDI command and status codes.
	 ;
MPURES	 EQU	0FFH				;MPU401 RESET COMMAND
MPUACK	 EQU	0FEH				;MPU401 'ACK' BYTE
MPUOFLO	 EQU	0F8H				;INDICATES MPU TIMER OVERFLOW
MPUNOOP	 EQU	0F8H				;NOOP MPU MARK CODE
MPUGRCT	 EQU	0ABH				;GET MPU RECORD COUNTER CMD
FAKEDAT	 EQU	0F8H				;FAKE DATA USED AT TIMEOUT
MPUMAXT	 EQU	0EFH				;MAX TIME BYTE FROM MPU401
MPUSBIT	 EQU	80H				;MASK FOR RUNNING STATUS BIT
MPUSMSK	 EQU	0F0H				;MASK FOR RUN STATUS NIB
MPUSMAX	 EQU	0EFH				;MAX RUN STATUS VALUE
ATCHMSK	 EQU	0E0H				;MASKS Cx AND Dx TO C0
ATOUCH	 EQU	0C0H				;AFTERTOUCH STATUS BYTE
MPUSYSM	 EQU	0FFH				;STATUS BYTE FOR SYSTEM MSG
MPUMIDX	 EQU	0F0H				;YTE FOR SYSTEM EXCLUSIVE MSG
	 ;
	 ;* Miscellaneous.
	 ;
EOICMD	 EQU	20H				;EOI COMMAND FOR 8259 CHIP
OFLTIM	 EQU	240				;MPU TIMEOUT VALUE
	 ;
	 SUBTTL	Static Data Area
	 %OUT	Static Data Area
	 PAGE
	 ;
	 ;***************************************************************
	 ;* Static storage						*
	 ;***************************************************************
	 ;
DVNXT:	 DW	0FFFFH				;PTR TO NEXT DRIVER HEADER
	 DW	0FFFFH
DVATR:	 DW	DEVATR				;DEVICE'S ATTRIBUTES
DVSTRA:	 DW	OFFSET STRAT			;ADDRESS OF STRATEGY ENTRY
DVEXEC:	 DW	OFFSET EXEC			;ADDRESS OF EXEC ('INT') ENTRY
DVNAME:	 DB	'MPU401$$'			;DEVICE NAME
	 ;
	 ;*  Buffer related values.
	 ;
IBSIZ:	 DW	0				;SIZE OF BUILT-IN BUFFER
BFADR:	 DD	0				;BUFFER ADDRESS
BFSIZ:	 DW	0				;SIZE OF CURRENT BUFFER
BFPUT:	 DW	0				;WRITE INDEX INTO BUFFER
BFPIC:	 DW	0				;READ INDEX INTO BUFFER
NENT:	 DW	0				;BYTES IN BUFFER
XBFADR:	 DD	0				;EXCL BUFFER ADDRESS
XBFSIZ:	 DW	0				;SIZE OF EXCLUSIVE BUFFER
XBFPUT:	 DW	0				;WRITE INDEX INTO EXCL BUFFER
XBFPIC:	 DW	0				;READ INDEX INTO EXCL BUFFER
XNENT:	 DW	0				;BYTES IN EXCL BUFER
	 ;
	 ;* Port addresses etc.
	 ;
DATPORT: DW	0				;MIDI DATA PORT ADDRESS
CTLPORT: DW	0				;MIDI CONTROL PORT ADDRESS
EOIPORT: DW	0				;PORT ADDRESS FOR EOI
ENAPORT: DW	0				;PORT ADDRESS FOR EN/DISABLE
	 ;
	 ;* Temporary storage locations.
	 ;
RHPTR:	 DD	0				;DWORD POINTER TO REQ HDR
TMPSP:	 DW	0				;INTERRUPTED PROGRAM'S SP
TMPSS:	 DW	0				;INTERRUPTED PROGRAM'S SS
	 ;
	 ;* Interrupt related values.
	 ;
HRDINT:	 DB	0				;HARDWARE INTERRUPT NUMBER
SFTINT:	 DB	0				;SOFTWARE INTERRUPT NUMBER
OSWVEC:	 DD	0				;ORIGINAL SW VECTOR
HWVECAD: DW	0				;HW VECTOR ADDRESS IN SEGM 0
ENAMASK: DB	0				;INT ENABLE MASK
DISMASK: DB	0				;INT DISABLE MASK
	 ;
	 ;* Miscellaneous flags etc.
	 ;
STATREC: DW	0				;STATUS RECORD
						;BIT 15 DRIVER ACTIVE
						;BIT 14 USED FOR REPORTING
						; AT/XT STATUS. NOT WRITTEN
						; IN THIS WORD.
						;BIT 10 MPU CMD ACK'ED
						;BIT 9 DATA IN EXCL BUFFER
						;BIT 8 DATA IN BUFFER
						;BIT 3 INPUT PROTOCOL ERROR
						;BIT 2 TIMEOUT ERROR
						;BIT 1 EXCL BUFFER OVERFLOW
						;BIT 0 BUFFER OVERFLOW
FNCTAB:	 DW	FNCTABI				;CURRENT FUNCTION JUMP TABLE
MPUDELY: DW	0				;MAX TIME TO WAIT FOR MPU401
ATFLAG:	 DB	0				;NON-ZERO IF PC-AT
ORGENA:	 DB	0				;ORIGINAL INT ENABLE MASK
LASTTIM: DB	0				;TIME OF LAST ERROR
LASTERR: DB	0				;BYTE OF LAST ERROR
MIDISTT: DB	0				;MIDI RUNNING STATUS BYTE
	 ;
	 ;* Real-time timer accumulator
	 ;
ACKTIME: DB	0				;FLAGS MPUACK AWAITS TIME BYTE
TIMER:	 DD	0				;32 BITS TIMER ACKUMULATOR
	 ;
	 ;* Function jump table for active driver.
	 ;
FNCTABA: DW	SINITA				;INITIALIZE
	 DW	SFINIA				;FINITIALIZE
	 DW	SSTAT				;GET DRIVER STATUS
	 DW	SRERR				;RESET ERROR FLAGS
	 DW	SSTIM				;SET TIMER
	 DW	SRTIMA				;READ TIMER
	 DW	SFBUF				;FLUSH INPUT BUFFER
	 DW	SRBUFA				;READ INPUT BUFFER
	 DW	STBUFA				;TEST INPUT BUFFER
	 DW	SDXBFA				;DEFINE EXCLUSIVE BUFFER
	 DW	SFXBF				;FLUSH EXCLUSIVE BUFFER
	 DW	SRXBFA				;READ EXCLUSIVE BUFFER
	 DW	STXBFA				;TEST EXCLUSIVE BUFFER
	 DW	SOCMDA				;SEND COMMAND
	 DW	SODATA				;SEND DATA
	 ;
	 ;* Function jump table for inactive driver.
	 ;
FNCTABI: DW	SINITI				;INITIALIZE
	 DW	SFINII				;FINITIALIZE
	 DW	SSTAT				;GET DRIVER STATUS
	 DW	SRERR				;RESET ERROR FLAGS
	 DW	SSTIM				;SET TIMER
	 DW	SRTIMI				;READ TIMER
	 DW	SFBUF				;FLUSH INPUT BUFFER
	 DW	SRBUFI				;READ INPUT BUFFER
	 DW	STBUFI				;TEST INPUT BUFFER
	 DW	SDXBFI				;DEFINE EXCLUSIVE BUFFER
	 DW	SFXBF				;FLUSH EXCLUSIVE BUFFER
	 DW	SRXBFI				;READ EXCLUSIVE BUFFER
	 DW	STXBFI				;TEST EXCLUSIVE BUFFER
	 DW	SOCMDI				;SEND COMMAND
	 DW	SODATI				;SEND DATA
	 ;
MAXFNC	 EQU	($-FNCTABI) / 2			;NUMBER OF TABLE ENTRIES
	 ;
REVCOD:	 DB	'MPU401 v.1.30 - 871109, '
	 DB	'Author Bjorn Larsson, Stockholm 1987 '
	 ;
STACK:	 DB	200 DUP ( 0 )			;OUR OWN STACK
STKTOP:	 DB	0				;TOP OF IT
	 ;
	 SUBTTL	Driver Entry Points
	 %OUT	Driver Entry Points
	 PAGE
	 ;
	 ;***************************************************************
	 ;* Strategy routine.						*
	 ;*								*
	 ;* Just stores away the request header pointer in RHPTR.	*
	 ;***************************************************************
	 ;
STRAT	 proc	far
	 ;
	 MOV	WORD PTR CS:RHPTR,BX		;SAVE OFFSET
	 MOV	WORD PTR CS:RHPTR+2,ES		;AND PARAGRAPH
	 RET
	 ;
STRAT	 endp
	 ;
	 ;***************************************************************
	 ;* 'Interrupt' routine.					*
	 ;*								*
	 ;* Performs the action specified at the call to the strategy	*
	 ;* routine.							*
	 ;***************************************************************
	 ;
EXEC	 proc	far
	 ;
	 PUSH	DS				;SAVE MACHINE STATE
	 PUSH	ES
	 PUSH	SI
	 PUSH	DI
	 PUSH	AX
	 PUSH	BX
	 PUSH	CX
	 PUSH	DX
	 ;
	 PUSH	CS				;MAKE DS = CS
	 POP	DS
	 ;
	 MOV	BX,WORD PTR RHPTR		;PICK UP POINTER TO REQ HDR
	 MOV	ES,WORD PTR RHPTR+2
	 MOV	AL,ES:[BX]+CMDOFS		;GET FUNCTION CODE
	 ;
	 CMP	AL,INITRQ			;INIT?
	 JNZ	EXEC1
	 ;
	 CALL	INIT				;DO INIT REQUEST
	 JMP	SHORT READY
	 ;
EXEC1:	 CMP	AL,CHINRQ			;CHIN?
	 JZ	CHIN
	 CMP	AL,CHOUTRQ			;CHOUT?
	 JZ	CHOUT
	 ;
	 NOP
	 NOP
	 ;
ILLREQ:	 MOV	ES:WORD PTR STTOFS[BX],ILLSTT	;SAY ILLEGAL REQUEST
	 JMP	SHORT EXIT
	 ;
READY:	 MOV	ES:WORD PTR STTOFS[BX],RDYSTT	;SAY OK
	 ;
EXIT:	 POP	DX				;RESTORE MACHINE STATE
	 POP	CX
	 POP	BX
	 POP	AX
	 POP	DI
	 POP	SI
	 POP	ES
	 POP	DS
	 RET
	 ;
	 ;***************************************************************
	 ;* CHIN (4)							*
	 ;*								*
	 ;* Always sends back the software interrupt number in the form	*
	 ;* of one character.						*
	 ;***************************************************************
	 ;
CHIN:	 MOV	DS,ES:WORD PTR PDSOFS[BX]	;GET SEGM OF DTA
	 MOV	DI,ES:WORD PTR PDOOFS[BX]	;AND OFFSET
	 MOV	AL,CS:BYTE PTR SFTINT		;GET SOFT INT NUMBER
	 MOV	BYTE PTR DS:[DI],AL		;AND RETURN IT AS A CHAR
	 JMP	READY				;SUCCESSFULL RETURN
	 ;
	 ;***************************************************************
	 ;* CHOUT (8)							*
	 ;*								*
	 ;* Installs the software interrupt number given by the charac-	*
	 ;* ter passed.							*
	 ;***************************************************************
	 ;
CHOUT:	 MOV	DS,ES:WORD PTR PDSOFS[BX]	;GET SEGM OF DTA
	 MOV	DI,ES:WORD PTR PDOOFS[BX]	;AND OFFSET
	 MOV	CL,BYTE PTR DS:[DI]		;GET SOFT INT NUMBER
	 ;
	 CMP	CL,MINSFTI			;CHECK VALID INT NUMBER
	 JAE	CHOUTOK				;MUST BE GREATER
	 ;
	 MOV	ES:WORD PTR STTOFS[BX],WRPSTT	;SAY WRITE PROTECT
	 JMP	EXIT				;ERROR RETURN
	 ;
	 ;* Valid new value. First restore old vector.
	 ;
CHOUTOK: XOR	AX,AX				;CLEAR DS
	 MOV	DS,AX
	 MOV	AL,CS:BYTE PTR SFTINT		;GET SOFT INT
	 ADD	AX,AX				;MULT BY 4
	 ADD	AX,AX
	 MOV	SI,AX
	 MOV	AX,CS:WORD PTR OSWVEC		;GET OLD VECTOR'S OFFSET
	 MOV	WORD PTR DS:[SI],AX		;RESTORE IT
	 MOV	AX,CS:WORD PTR OSWVEC+2		;GET SEGMENT
	 MOV	WORD PTR DS:2[SI],AX		;AND RESTORE
	 ;
	 ;* Now install the new value.
	 ;
	 MOV	CS:BYTE PTR SFTINT,CL		;INSTALL IT
	 XOR	CH,CH				;IN CX
	 ADD	CX,CX				;MULT BY 4
	 ADD	CX,CX
	 MOV	SI,CX
	 ;
	 MOV	AX,WORD PTR DS:[SI]		;GET OLD VECTOR'S OFFSET
	 MOV	CS:WORD PTR OSWVEC,AX		;SAVE IT
	 MOV	AX,WORD PTR DS:2[SI]		;GET SEGMENT
	 MOV	CS:WORD PTR OSWVEC+2,AX		;AND SAVE
	 ;
	 MOV	DS:WORD PTR [SI],OFFSET SWIHNL	;INSTALL SOFTWARE INTERRUPT
	 MOV	DS:WORD PTR 2[SI],CS		;HANDLER ADDRESS	
	 ;
	 JMP	READY				;SUCCESSFULL RETURN
	 ;
EXEC	 endp
	 ;
	 SUBTTL	Soft Interrupt Dispatcher
	 %OUT	Soft Interrupt Dispatcher
	 PAGE
	 ;
	 ;***************************************************************
	 ;* Software Interrupt Handler.					*
	 ;*								*
	 ;* You come here when an application program wants to do some-	*
	 ;* thing with the MPU401, and tries to use the software int.	*
	 ;*								*
	 ;* At entry, reg AX contains the Function Code, and any input	*
	 ;* parameter is passed in BX, CX and DX.			*
	 ;*								*
	 ;* The individal functions return any data in AX.		*
	 ;* Functions that can detect errors return an error code in	*
	 ;* DX. Functions that do not detecte errors (always success-	*
	 ;* full) do not set DX.					*
	 ;*								*
	 ;* Completion code may be					*
	 ;*								*
	 ;* 0:		OK, no error.					*
	 ;* 1:		Illegal Function Code.				*
	 ;* 2:		Driver not activated.				*
	 ;* 3:		MIDI data overflow error.			*
	 ;* 4:		MIDI protocol error.				*
	 ;* 5:		Illegal buffer specification.			*
	 ;* 6:		MIDI timeout error.				*
	 ;*								*
	 ;* This entry point will destroy the AX and DX register only.	*
	 ;***************************************************************
	 ;
SWIHNL	 proc	far
	 ;
	 STI					;RE-ENABLE INTERRUPTS
	 CMP	AX,MAXFNC			;VALID FUNCTION CODE?
	 JB	SWIHNL1				;JUMP IF SO
	 ;
	 MOV	DX,CPLIFNC			;ILLEGAL FUNCTION CODE
	 IRET
	 ;
SWIHNL1: PUSH	DI
	 PUSH	DS				;SAVE DS
	 PUSH	CS				;SET DS=CS
	 POP	DS
	 ADD	AX,AX				;SHIFT LEFT FOR WORD INDEX
	 MOV	DI,WORD PTR FNCTAB		;GET THE JUMP TABLE
	 ADD	DI,AX
	 JMP	WORD PTR [DI]			;GO TO HANDLER
	 ;
	 SUBTTL	Soft Interrupt Init
	 %OUT	Soft Interrupt Init
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 0:	SINIT:							*
	 ;*								*
	 ;* If the driver was currently active, it is set inactive.	*
	 ;*								*
	 ;* if BX is non-zero, DX:CX is the address of a non-default	*
	 ;* data buffer, and BX is the size of it. If BX is 0, the in-	*
	 ;* ternal buffer is used. Then some hardware initialization is	*
	 ;* done to the MPU401. Extensive checks are made that the	*
	 ;* MPU401 is present and responds correctly. If something does	*
	 ;* not work properly, the initialization is not performed and	*
	 ;* an error is reported. If all goes well, DX returns CPLOK.	*
	 ;***************************************************************
	 ;
	 ;* For active driver (must finitialize first).
	 ;
SINITA:	 CALL	FINITIT				;DO DRIVER FINITIALIZE
	 AND	DX,DX				;SEE IF OK?
	 JZ	SINITI				;THEN JUMP
	 ;
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET					;RETURN FROM FINITI'S ERROR
	 ;
	 ;* For inactive driver (normal initialization).
	 ;
SINITI:	 PUSH	CX
	 ;
	 ;* First initialize most values to defaults.
	 ;
	 MOV	WORD PTR BFADR,OFFSET DBUF	;SET UP TO USE INTERNAL BUFFER
	 MOV	WORD PTR BFADR+2,CS		;SEGMENT
	 MOV	AX,WORD PTR IBSIZ		;BUFFER SIZE
	 MOV	WORD PTR BFSIZ,AX
	 XOR	AX,AX				;CLEAR CS
	 MOV	WORD PTR BFPIC,AX		;CLEAR INDICES
	 MOV	WORD PTR BFPUT,AX
	 MOV	WORD PTR XBFPIC,AX
	 MOV	WORD PTR XBFPUT,AX
	 MOV	WORD PTR XBFSIZ,AX		;NO EXCL BUFFER
	 MOV	WORD PTR NENT,AX		;NO ENTRIES IN BUFFER YET
	 MOV	WORD PTR XNENT,AX		;NO EXCL ENTRIES
	 MOV	WORD PTR TIMER,AX		;CLEAR TIME RECORD
	 MOV	WORD PTR TIMER+2,AX
	 MOV	BYTE PTR ACKTIME,AL		;CLEAR TIME EXPECTATION FLAG
	 MOV	BYTE PTR MIDISTT,90H		;INITIAL MIDI RUNNING STATUS
	 ;
	 ;* Check if non-default buffer is to be used.
	 ;
	 AND	BX,BX				;CHECK IF NON-DEFAULT BUFFER?
	 JZ	SINIT4				;JUMP IF NOT
	 ;
	 CMP	BX,MINBSIZ			;ERROR IF SIZE < MIN
	 JB	SINIT1
	 ;
	 CMP	BX,MAXBSIZ			;ERROR IF SIZE > MAX
	 JBE	SINIT2				;JUMP IF OK
	 ;
SINIT1:	 MOV	DX,CPLBERR			;ERROR CODE
	 JMP	SINITX				;RETURN
	 ;
SINIT2:	 CMP	CX,10H				;MAKE OFFSET < 1 PARAGRAPH
	 JB	SINIT3
	 ;
	 SUB	CX,10H				;STEP OFFSET DOWN
	 INC	DX				;AND SEGMENT UP
	 JMP	SINIT2				;LOOP UNTIL DONE
	 ;
SINIT3:	 MOV	WORD PTR BFSIZ,BX		;INSTALL NEW VALUES
	 MOV	WORD PTR BFADR,CX		;ADDRESS OFFSET
	 MOV	WORD PTR BFADR+2,DX		;AND SEGMENT
	 ;
	 ;* Read any data there is in the MPU401 (max 5000 bytes).
	 ;
SINIT4:	 MOV	CX,5000				;MAX 5000 BYTES
	 ;
SINIT5:	 MOV	DX,WORD PTR CTLPORT		;STATUS PORT
	 IN	AL,DX				;GET STATUS
	 AND	AL,DSRBIT			;SEE IF DATA THERE?
	 JNZ	SINIT7				;JUMP IF NOT
	 ;
	 DEC	DX				;DATA PORT
	 IN	AL,DX				;DO A READ
	 INC	DX				;CTRL PORT
	 MOV	AL,200
SINIT6:	 DEC	AL				;SHORT DELAY LOOP
	 JNZ	SINIT6
	 ;
	 DEC	CX				;DOWN COUNT
	 JNZ	SINIT5				;LOOP IF NOT COUNTED OUT
	 ;
	 MOV	DX,CPLMOFL			;TO MUCH DATA ERROR CODE
	 JMP	SINITX
	 ;
	 ;* MPU401 buffer empty. Await MPU401 ready for command.
	 ;
SINIT7:	 MOV	CX,500				;TIMEOUT FOR DRR LOW
	 ;
SINIT8:	 IN	AL,DX				;WAIT FOR DRR LOW
	 AND	AL,DRRBIT			;CHECK IT
	 JZ	SINIT9
	 ;
	 DEC	CX				;COUNT DOWN
	 JNZ	SINIT8
	 ;
	 ;* Timeout, MPU401 never gets ready for command. Error return.
	 ;
	 JMP	SHORT SINIT12
	 ;
	 ;* MPU401 ready for command. Reset it to known initial state.
	 ;
SINIT9:	 MOV	AL,MPURES			;MIDI RESET CODE
	 OUT	DX,AL				;DO IT
	 ;
	 MOV	CX,WORD PTR MPUDELY		;TIMEOUT FOR RESPONSE
	 ;
SINIT10: IN	AL,DX				;GET STATUS
	 AND	AL,DSRBIT			;SEE IF DATA THERE?
	 JZ	SINIT11				;THEN JUMP
	 ;
	 DEC	CX				;TIME OUT YET?
	 JNZ	SINIT10				;TRY AGAIN IF NOT
	 ;
	 ;* Timeout, no acknowledge from MPU401. Error return.
	 ;
	 MOV	DX,CPLTERR			;TIMEOUT ERROR
	 JMP	SINITX
	 ;
	 ;* MPU401 replied with a byte. Check it's ACK.
	 ;
SINIT11: DEC	DX				;DATA PORT
	 IN	AL,DX
	 CMP	AL,MPUACK			;SHOULD BE 'ACKNOWLEDGE'
	 JZ	SINIT13				;JUMP IF OK
	 ;
SINIT12: MOV	DX,CPLPRTE			;PROTOCOL ERROR
	 JMP	SINITX
	 ;
	 ;* Coming here, the MPU401 is present, and responds correctly.
	 ;* Now initialize some more values.
	 ;
SINIT13: MOV	WORD PTR STATREC,8400H		;DRIVER ACTIVE, NO ERROR/DATA
	 MOV	AX,OFFSET FNCTABA		;ACTIVE DRIVER JUMP TABLE
	 MOV	WORD PTR FNCTAB,AX		;USE IT IN FUTURE
	 ;
	 ;* Save original hardware interrupt vector and replace it
	 ;* by our own.
	 ;
	 PUSH	DS
	 XOR	AX,AX				;CLEAR CS
	 MOV	DS,AX				;FOR ACCESS TO SEGM 0
	 MOV	DI,CS:WORD PTR HWVECAD		;VECTOR LOCATION
	 CLI					;SHUT OFF DOING THIS
	 MOV	AX,WORD PTR [DI]		;GET ORIGINAL VECTOR OFFS
	 MOV	CS:WORD PTR OHWVEC,AX		;SAVE IT
	 MOV	AX,WORD PTR 2[DI]		;GET SEGMENT
	 MOV	CS:WORD PTR OHWVEC+2,AX		;SAVE IT
	 MOV	WORD PTR [DI],OFFSET HWIHNL	;INSTALL OUR OFFSET
	 MOV	WORD PTR 2[DI],CS		;INSTALL OUR SEGMENT
	 STI					;ALLOW INT BACK ON
	 POP	DS				;RECOVER DS (=CS)
	 ;
	 ;* Give a (probably unnessecary) EOI to interrupt controller.
	 ;
	 MOV	DX,WORD PTR EOIPORT		;PORT TO COMMAND EOI TO
	 MOV	AL,EOICMD			;CLEAR IN-SERVICE FLIP-FLOP
	 OUT	DX,AL				;IN INT CONTROLLER
	 ;
	 ;* Enable hardware interrupts in 8259.
	 ;
	 MOV	DX,WORD PTR ENAPORT		;ENABLE MASK PORT
	 IN	AL,DX				;GET CURRENT SETTINGS
	 MOV	BYTE PTR ORGENA,AL		;KEEP ORIGINAL MASK
	 AND	AL,BYTE PTR ENAMASK		;CLEAR BIT TO ENABLE
	 OUT	DX,AL				;RESTORE TO CONTROLLER
	 ;
	 ;* All is well, return OK.
	 ;
	 MOV	DX,CPLOK			;OK RETURN
	 ;
SINITX:	 POP	CX				;RECOVER REGS
	 POP	DS
	 POP	DI
	 IRET
	 ;
	 SUBTTL	Soft Interrupt Finit
	 %OUT	Soft Interrupt Finit
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 1:  SFINI							*
	 ;*								*
	 ;* If driver is already inactive, simply returns 'OK' result.	*
	 ;* Otherwise, things are set back to the state when it was	*
	 ;* initialized. Extensive tests are made that everything works	*
	 ;* properly. If some problem is present, the finitialization	*
	 ;* not performed and an error is reported in DX. Otherwies, DX	*
	 ;* returns CPLOK.						*
	 ;***************************************************************
	 ;
	 ;* Finitialize inactive driver (dummy operation).
	 ;
SFINII:	 MOV	DX,CPLOK			;OK COMPLETION CODE
	 JMP	SHORT SFINI0			;AND RETURN
	 ;
	 ;* Finitialize active driver (normal finitialization).
	 ;
SFINIA:	 CALL	FINITIT				;DO THE JOB
SFINI0:	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 ;***************************************************************
	 ;* FINITIT							*
	 ;* This one does the real finit work for FINIT routines. Also	*
	 ;* called by SINITA.						*
	 ;***************************************************************
	 ;
FINITIT	 proc near
	 ;
	 ;* Reset the MPU401, taking all precautions.
	 ;
	 MOV	DX,WORD PTR ENAPORT		;ENABLE MASK PORT
	 IN	AL,DX				;GET CURRENT SETTINGS
	 OR	AL,BYTE PTR DISMASK		;DISABLE INTERRUPTS
	 OUT	DX,AL				;RESTORE TO CONTROLLER
	 ;
	 ;* Read any data there is in the MPU401 (max 200 bytes).
	 ;
	 MOV	DX,WORD PTR CTLPORT		;CONTROL PORT ADDRESS
	 PUSH	CX				;SAVE REG USED AS DOWN-COUNTER
	 MOV	CX,200				;MAX 200 BYTE
FINITI1: IN	AL,DX				;GET STATUS
	 AND	AL,DSRBIT			;SEE IF DATA EMPTY
	 JNZ	FINITI3				;THEN JUMP
	 ;
	 DEC	CX				;ADJUST TIMEOUT
	 JZ	FINITI2				;ERROR IF TIMEOUT
	 ;
	 DEC	DX				;DATA PORT
	 IN	AL,DX				;READ A BYTE
	 INC	DX				;CTRL PORT
	 JMP	FINITI1				;LOOP AGAIN
	 ;
FINITI2: POP	CX
	 MOV	DX,CPLMOFL			;MPU DATA OFLO ERROR CODE
	 RET
	 ;
	 ;* MPU401 buffer empty. Await MPU401 ready for command.
	 ;
FINITI3: MOV	CX,WORD PTR MPUDELY		;TIMEOUT COUNT
FINITI4: IN	AL,DX				;GET STATUSS
	 AND	AL,DRRBIT			;MPU READY FOR COMMAND
	 JZ	FINITI5				;JUMP IF SO
	 ;
	 DEC	CX				;BUMP TIMEOUT
	 JNZ	FINITI4				;LOOP IF NOT
	 ;
	 JMP	SHORT FINITI7			;TIMEOUT ERROR
	 ;
	 ;* MPU401 ready for command. Reset it to known final state.
	 ;
FINITI5: MOV	AL,MPURES			;RESET COMMAND
	 OUT	DX,AL
	 ;
	 MOV	CX,WORD PTR MPUDELY		;TIMEOUT DELAY
FINITI6: IN	AL,DX				;GET STATUS
	 AND	AL,DSRBIT			;SEE IF DATA THERE
	 JZ	FINITI8				;THEN JUMP
	 ;
	 DEC	CX				;BUMP TIMEOUT
	 JNZ	FINITI6				;LOOP IF NON-0
	 ;
FINITI7: POP	CX
	 MOV	DX,CPLTERR			;TIMEOUT ERROR
	 RET
	 ;
	 ;* MPU401 replied with a byte. Check it's ACK.
	 ;
FINITI8: DEC	DX				;DATA PORT
	 IN	AL,DX				;GET BYTE
	 CMP	AL,MPUACK			;SHOULD BE ACKNOWLEDGE
	 JZ	FINITI9				;JUMP IF OK
	 ;
	 POP	CX				;RECOVE REG
	 MOV	DX,CPLPRTE			;PROTOCOL ERROR
	 RET
	 ;
FINITI9: POP	CX				;RECOVER REG
	 ;
	 ;* MPU401 properly reset. Now restore hardware int enable
	 ;* status in 8259.
	 ;
	 MOV	AH,BYTE PTR ORGENA		;GET ORIGINAL SETTING
	 AND	AH,BYTE PTR DISMASK		;ISOLATE OUR BIT
	 MOV	DX,WORD PTR ENAPORT		;ENABLE MASK PORT
	 IN	AL,DX				;GET CURRENT SETTINGS
	 AND	AL,BYTE PTR ENAMASK		;REMOVE OUR BIT
	 OR	AL,AH				;INSERT IT
	 OUT	DX,AL				;RESTORE TO CONTROLLER
	 ;
	 ;* Restore original hardware interrupt vector to segment 0.
	 ;
	 PUSH	DS
	 XOR	AX,AX				;ACCESS SEGMENT 0
	 MOV	DS,AX
	 MOV	DI,CS:WORD PTR HWVECAD		;VECTOR LOCATION
	 MOV	AX,CS:WORD PTR OHWVEC		;GET OFFSET
	 CLI					;SHUT OFF DOING THIS
	 MOV	WORD PTR [DI],AX		;RESTORE IT
	 MOV	AX,CS:WORD PTR OHWVEC+2		;GET SEGMENT
	 MOV	WORD PTR 2[DI],AX
	 STI
	 POP	DS
	 ;
	 ;* Now finitialize some values and return.
	 ;
	 MOV	AX,OFFSET FNCTABI		;INACTIVE DRIVER JUMP TABLE
	 MOV	WORD PTR FNCTAB,AX		;USE IT IN FUTURE
	 MOV	WORD PTR STATREC,0		;DRIVER INACTIVE
	 ;
	 MOV	DX,CPLOK
	 RET
	 ;
FINITIT	 endp
	 ;
	 SUBTTL	Soft Interrupt Driver Status
	 %OUT	Soft Interrupt Driver Status
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 2:	SSTAT							*
	 ;*								*
	 ;* Get driver status. Returns status in AX as follows:		*
	 ;*								*
	 ;* Bit		Flags						*
	 ;*								*
	 ;* 0	Overflow has occured in the data buffer.		*
	 ;* 1	Overflow has occured in the exclusive buffer.		*
	 ;* 2	Timeout error has occured in the MPU401 protocol	*
	 ;* 3	A protocol error has been found in the input from the	*
	 ;*	MPU401 - unexpected bytes arrived. (Note that this	*
	 ;*	driver currently does not support all possible valid	*
	 ;*	data sequences).					*
	 ;* 8	Unread data in data buffer.				*
	 ;* 9	Unread data in exclusive buffer.			*
	 ;* 10	Last MPU command code has been acknowledged.		*
	 ;* 14	The machine is not a PC-XT, but an AT.			*
	 ;* 15	Driver is in the active state.				*
	 ;*								*
	 ;* SSTAT does not return any error status. DX returns two	*
	 ;* bytes of error data (the two last bytes read from the	*
	 ;* MPU401). DX is only relevant if a protocol error has	*
	 ;* occured (indicated by bit 3 of AX).				*
	 ;***************************************************************
	 ;
	 ;* Include AT bit by special test.
	 ;
SSTAT:	 MOV	AL,BYTE PTR ATFLAG		;SEE IF WE ARE AN AT
	 AND	AX,0FFH
	 JZ	SSTAT1
	 ;
	 MOV	AX,4000H			;SET AT BIT
	 ;
SSTAT1:	 OR	AX,WORD PTR STATREC		;ADD OTHER BITS
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 SUBTTL	Soft Interrupt Error Reset
	 %OUT	Soft Interrupt Error Reset
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 2:	SRERR							*
	 ;*								*
	 ;* Reset all error flags.					*
	 ;* SRERR does not return any error status. DX is not set.	*
	 ;***************************************************************
	 ;
SRERR:	 MOV	BYTE PTR STATREC,0		;CLEAR ERROR HALF OF STATREC
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 SUBTTL	Soft Interrupt Set Timer
	 %OUT	Soft Interrupt Set Timer
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 4:  SSTIM	Set timer					*
	 ;*								*
	 ;* The internal timer is initialized with the value in DX and	*
	 ;* CX. DX holds the high order word. 				*
	 ;* SSTIM does not return any error status. DX is not set.	*
	 ;***************************************************************
	 ;
SSTIM:	 ADD	CX,CX				;SHIFT UP INPUT VALUE 2 BITS
	 ADC	DX,DX
	 ADD	CX,CX
	 ADC	DX,DX
	 CLI					;DON'T CHANGE BETWEEN WRITES
	 MOV	WORD PTR TIMER,CX		;SET LOW WORD
	 MOV	WORD PTR TIMER+2,DX		;SET HIGH WORD
	 STI					;ALLOW CHANGES
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 ;
	 SUBTTL	Soft Interrupt Read Timer
	 %OUT	Soft Interrupt Read Timer
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 5:  SRTIM	Read timer					*
	 ;*								*
	 ;* The internal timer is read (if neccessary MPU401 time is	*
	 ;* requested and included), and the value is returned in DX	*
	 ;* and AX. DX holds the high order word. Note that this func-	*
	 ;* tion does not return any error status, but DX will hold the	*
	 ;* high order word of the return value. If an error should	*
	 ;* occur, the only way to check it is by reading the status	*
	 ;* record (with SSTAT) and check the error flags.		*
	 ;***************************************************************
	 ;
	 ;* Entry for active driver - requst fraction from MPU401
	 ;
SRTIMA:	 MOV	DL,MPUGRCT			;GET MPU RECORD COUNTER
	 CALL	PUTCMD				;SEND THE COMMAND
	 ;
	 ;* Entry for inactive driver
	 ;
SRTIMI:	 MOV	DX,WORD PTR MPUDELY		;TIMEOUT DELAY
	 ;
SRTIM1:	 TEST	BYTE PTR STATREC+1,4		;LAST CMD ACK'ED?
	 JNZ	SRTIM2
	 ;
	 DEC	DX				;BUMP TIMEOUT
	 JNZ	SRTIM1				;LOOP IF NO TIMEOUT
	 ;
	 OR	BYTE PTR STATREC,4		;SET TIMEOUT ERROR BIT
	 ;
SRTIM2:	 CLI					;DON'T CHANGE BETWEEN READS
	 MOV	AX,WORD PTR TIMER		;READ LOW WORD
	 MOV	DX,WORD PTR TIMER+2		;READ HIGH WORD
	 STI					;ALLOW CHANGES
	 RCR	DX,1				;SHIFT RESULT RIGHT 2
	 RCR	AX,1
	 RCR	DX,1
	 RCR	AX,1
	 AND	DH,3FH				;CLEAR SHIFTED GARBAGE
	 POP	DS				;RECOVER REGSS
	 POP	DI
	 IRET
	 ;
	 SUBTTL	Soft Interrupt Flush Buffer
	 %OUT	Soft Interrupt Flush Buffer
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 6:  SFBUF	Flush Buffer					*
	 ;*								*
	 ;* Flush input buffer. No error possible, DX not set.		*
	 ;***************************************************************
	 ;
SFBUF:	 XOR	AX,AX				;CLEAR TO 0
	 CLI					;NO INT WHILE WORKING
	 MOV	WORD PTR BFPUT,AX		;CLEAR BUFFER POINTERS
	 MOV	WORD PTR BFPIC,AX
	 MOV	WORD PTR NENT,AX		;CLEAR BYTE COUNT
	 AND	BYTE PTR STATREC+1,0FEH		;CLEAR DATA FLAG
	 STI
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 SUBTTL	Soft Interrupt Read Buffer
	 %OUT	Soft Interrupt Read Buffer
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 7:  SRBUF	Read Buffer					*
	 ;*								*
	 ;* If the driver is inactive, nothing is done and an error is	*
	 ;* returned. If driver is active, waits for a data byte in	*
	 ;* the buffer and then returns it. DX is CPLOK in this case.	*
	 ;***************************************************************
	 ;
	 ;* Read inactive driver is an error
	 ;
SRBUFI:	 MOV	DX,CPLPASS			;ERROR CODE
	 XOR	AX,AX				;CLEAR RETURN VALUE
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 ;* Read active driver (normal entry)
	 ;
SRBUFA:	 TEST	BYTE PTR STATREC+1,1		;TEST IF DATA THERE
	 JZ	SRBUFA
	 ;
	 MOV	DX,WORD PTR BFADR		;GET BUFFER OFFSET
	 MOV	DI,WORD PTR BFPIC		;GET PICK POINTER
	 ADD	DX,DI				;GET BUFFER POS
	 XCHG	DI,DX				;PUT IN INDEX REG
	 PUSH	DS
	 MOV	DS,WORD PTR BFADR+2		;GET BUFFER SEGMENT
	 MOV	AL,[DI]				;GET BUFFER DATA BYTE
	 POP	DS
	 ;
	 INC	DX				;NEXT BUF POS
	 CMP	DX,WORD PTR BFSIZ		;CHECK IF WRAP AROUND
	 JB	SRBUFA1				;JUMP IF NOT
	 ;
	 XOR	DX,DX
	 ;
SRBUFA1: MOV	WORD PTR BFPIC,DX		;UPDATE POINTER
	 CLI					;NO INTS NOW
	 DEC	WORD PTR NENT			;ADJUST BUFFER CONTENTS
	 JG	SRBUFA2				;IF STILL MORE
	 ;
	 AND	BYTE PTR STATREC+1,0FEH		;CLEAR DATA FLAG
	 ;
SRBUFA2: STI					;ALLOW IT NOW
	 XOR	AH,AH				;CLEAR HIGH RETURN VALUE
	 MOV	DX,CPLOK			;RETURN CODE
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 SUBTTL	Soft Interrupt Test Buffer
	 %OUT	Soft Interrupt Test Buffer
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 8:  STBUF	Test Buffer					*
	 ;*								*
	 ;* If the driver is inactive, nothing is done and an error is	*
	 ;* returned. If driver is active, returns 0 in AX if there is	*
	 ;* no data in the buffer waitung to be read. Returns 1 if data	*
	 ;* is available. DX set to CPLOK in this case.			*
	 ;***************************************************************
	 ;
	 ;* Test for inactive driver is an error
	 ;
STBUFI:	 MOV	DX,CPLPASS			;ERROR CODE
	 MOV	AX,1				;PRETEND BYTE TO AVOID HANGUP
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 ;* Test for activer driver (normal entry)
	 ;
STBUFA:	 XOR	AX,AX				;ASSUME NO DATA
	 TEST	BYTE PTR STATREC+1,1		;SEE IF DATA
	 JZ	STBUFA1				;JUMP IF NOT
	 ;
	 INC	AX				;SET IT TO 1
	 ;
STBUFA1: MOV	DX,CPLOK			;OK RETURN
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 SUBTTL	Soft Interrupt Define Exclusive Buffer
	 %OUT	Soft Interrupt Define Exclusive Buffer
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 9:  SDXBF	Define exclusive buffer				*
	 ;*								*
	 ;* If the driver is inactive, an error is returned. If the	*
	 ;* driver is active, and if if BX is non-zero, then DX:CX is	*
	 ;* the address of a non-default exclusive buffer, and BX is	*
	 ;* the size of it. If BX is 0, the exclusive buffer is un-	*
	 ;* defined, i.e. exclusive data is unbuffered. This is also	*
	 ;* the default after the driver is initialized. The buffer	*
	 ;* size must be >= 512, and <= 32768.				*
	 ;***************************************************************
	 ;
	 ;* Refuse if driver inactive
	 ;
SDXBFI:	 MOV	DX,CPLPASS			;ERROR RETURN CODE
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 ;* Entry for active driver (normal case)
	 ;
SDXBFA:  OR	BX,BX				;CHECK IF UNDEF. BUFFER?
	 JZ	SDXBF2
	 ;
	 CMP	BX,MINBSIZ			;CHECK IF BIG ENOUGH?
	 JB	SDXBF1				;JUMP IF NOT
	 ;
	 CMP	BX,MAXBSIZ			;CHECK IF TOO BIG?
	 JBE	SDXBF2				;JUMP IF OK
	 ;
SDXBF1:	 MOV	DX,CPLBERR			;BAD BUFFER CPL CODE
	 POP	DS
	 POP	DI
	 IRET					;ERROR RETURN
	 ;
SDXBF2:	 MOV	WORD PTR XBFADR,CX		;INSTALL OFFSET
	 MOV	WORD PTR XBFADR+2,DX		;INSTALL EGMENT
	 MOV	DX,CPLOK			;OK COMPLETION CODE
	 ;
	 XOR	AX,AX				;FOR CLEARING THINGS
	 CLI					;NO INT WHILE SETTING
	 MOV	WORD PTR XBFSIZ,BX		;INSTALL SIZE
	 MOV	WORD PTR XBFPUT,AX		;CLEAR BUFFER POINTERS
	 MOV	WORD PTR XBFPIC,AX
	 MOV	WORD PTR XNENT,AX		;CLEAR BUFFER CONTENTS
	 AND	WORD PTR STATREC,0FDFDH		;CLEAR XBUF RELATED BITS
	 POP	DS
	 POP	DI
	 IRET					;RESTORES INT STATUS
	 ;
	 SUBTTL	Soft Interrupt Flush Exclusive Buffer
	 %OUT	Soft Interrupt Flush Exclusive Buffer
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 10: SFXBF	Flush exclusive buffer				*
	 ;*								*
	 ;* Flush exclusive buffer. No error possible.			*
	 ;***************************************************************
	 ;
	 ;* Clear buffer pointers etc.
	 ;
SFXBF:	 MOV	DX,CPLOK			;RETURN OK CODE
	 POP	DS				;RECOVER REGS
	 POP	DI
	 ;
 	 XOR	AX,AX				;CLEAR TO 0
	 CLI					;NO INT WHILE WORKING
	 MOV	WORD PTR XBFPUT,AX		;CLEAR BUFFER POINTERS
	 MOV	WORD PTR XBFPIC,AX
	 MOV	WORD PTR XNENT,AX		;CLEAR BYTE COUNT
	 AND	BYTE PTR STATREC+1,0FDH		;CLEAR DATA FLAG
	 IRET					;RESTORES INT STATUS
	 ;
	 SUBTTL	Soft Interrupt Read Exclusive Buffer
	 %OUT	Soft Interrupt Read Exclusive Buffer
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 11: SRXBF	Read Exclusive Buffer				*
	 ;*								*
	 ;* If the driver is inactive, or the driver is active but no	*
	 ;* exclusive buffer is defined, nothing is done and an error	*
	 ;* is returned. If driver is active and has a buffer, waits	*
	 ;* for a data byte and then returns it. DX returns CPLOK in	*
	 ;* this case.							*
	 ;***************************************************************
	 ;
	 ;* Read inactive driver is an error
	 ;
SRXBFI:	 MOV	DX,CPLPASS			;ERROR CODE
	 XOR	AX,AX				;CLEAR RETURN VALUE
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 ;* Read from active driver (normal entry)
	 ;
SRXBFA:	 MOV	AX,WORD PTR XBFSIZ		;SEE IF THERE IS A BUFFER?
	 AND 	AX,AX
	 JNZ	SRXBFA1				;JUMP IF A BUFFER THERE
	 ;
	 ;* Read non-existent buffer is an error
	 ;
	 MOV	DX,CPLNOXB			;NO EXCLUSIVE BUFFER
	 POP	DS
	 POP	DI
	 IRET					;ERROR RETURN
	 ;
SRXBFA1: TEST	BYTE PTR STATREC+1,2		;TEST IF DATA THERE
	 JZ	SRXBFA1
	 ;
	 MOV	DX,WORD PTR XBFADR		;GET BUFFER OFFSET
	 MOV	DI,WORD PTR XBFPIC		;GET PICK POINTER
	 ADD	DX,DI				;GET BUFFER POS
	 XCHG	DI,DX				;PUT IN INDEX REG
	 PUSH	DS
	 MOV	DS,WORD PTR XBFADR+2		;GET BUFFER SEGMENT
	 MOV	AL,[DI]				;GET BUFFER DATA BYTE
	 POP	DS
	 ;
	 INC	DX				;NEXT BUF POS
	 CMP	DX,WORD PTR XBFSIZ		;CHECK IF WRAP AROUND
	 JB	SRXBFA2				;JUMP IF NOT
	 ;
	 XOR	DX,DX
	 ;
SRXBFA2: MOV	WORD PTR XBFPIC,DX		;UPDATE POINTER
	 CLI					;NO INTS NOW
	 DEC	WORD PTR XNENT			;ADJUST BUFFER CONTENTS
	 JG	SRXBFA3				;IF STILL MORE
	 ;
	 AND	BYTE PTR STATREC+1,0FDH		;CLEAR DATA FLAG
	 ;
SRXBFA3: STI					;ALLOW IT NOW
	 XOR	AH,AH				;CLEAR HIGH RETURN VALUE
	 MOV	DX,CPLOK			;RETURN CODE
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 SUBTTL	Soft Interrupt Test Exclusive Buffer
	 %OUT	Soft Interrupt Test Exclusive Buffer
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 12: STXBF	Test Exclusive Buffer				*
	 ;*								*
	 ;* If the driver is inactive, nothing is done and an error is	*
	 ;* returned. If driver is active, returns 0 in AX if there is	*
	 ;* no data in the buffer waiting to be read. Returns 1 if data	*
	 ;* is available. DX set to CPLOK in this case.			*
	 ;***************************************************************
	 ;
	 ;* Test for inactive driver is an error
	 ;
STXBFI:	 MOV	DX,CPLPASS			;ERROR CODE
	 MOV	AX,1				;PRETEND BYTE TO AVOID HANGUP
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 ;* Test for active driver (normal entry)
	 ;
STXBFA:	 XOR	AX,AX				;ASSUME NO DATA
	 TEST	BYTE PTR STATREC+1,2		;SEE IF DATA
	 JZ	STXBFA1				;JUMP IF NOT
	 ;
	 INC	AX				;SET IT TO 1
	 ;
STXBFA1: MOV	DX,CPLOK			;OK RETURN
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 SUBTTL	Soft Interrupt Send Command
	 %OUT	Soft Interrupt Send Command
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 13: SOCMD	Send a command byte				*
	 ;*								*
	 ;* If the driver is inactive, nothing is done and an error is	*
	 ;* returned. If driver is active, waits until the previous	*
	 ;* command has finished processing. Then sends the command	*
	 ;* byte (in DL). Set TIMEACK non-0 if the command requests	*
	 ;* record counter contents (used by SRTIM).			*
	 ;***************************************************************
	 ;
	 ;* Refuse to send if driver inactive.
	 ;
SOCMDI:	 MOV	DX,CPLPASS			;ERROR RETURN CODE
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 ;* Normal entry to send a command byte.
	 ;
SOCMDA:	 CALL	PUTCMD				;SEND OUT THE COMMAND
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 ;***************************************************************
	 ;* PUTCMD							*
	 ;*								*
	 ;* Writes a command byte from DL to the MPU401. Returns a	*
	 ;* completion code in DX. DS must be = CS when entering!	*
	 ;***************************************************************
	 ;
PUTCMD	 proc near
	 ;
	 MOV	AX,WORD PTR MPUDELY		;TIMEOUT COUNT
	 ;
PUTCMD1: TEST	BYTE PTR STATREC+1,4		;CHECK IF LAST CMD ACK'ED
	 JNZ	PUTCMD2				;JUMP IF OK
	 ;
	 DEC	AX				;BUMP TIMEOUT
	 JNZ	PUTCMD1				;LOOP IF NO TIMEOUT YET
	 ;
	 MOV	DX,CPLTERR
	 RET
	 ;
PUTCMD2: PUSH	CX				;USE AS TIMEOUT COUNTER
	 MOV	AH,DL				;INPUT DATA BYTE
	 MOV	CX,WORD PTR MPUDELY		;TIMEOUT COUNT
PUTCMD3: MOV	DX,WORD PTR CTLPORT		;GET STATUS
	 IN	AL,DX
	 AND	AL,DRRBIT			;CHECK IF READY TO RECEIVE
	 JZ	PUTCMD4
	 ;
	 DEC	CX				;BUMP TIMEOUT
	 JNZ	PUTCMD3				;LOOP IF TIME LEFT
	 ;
	 POP	CX
	 MOV	DX,CPLTERR			;TIMEOUT ERROR CODE
	 RET
	 ;
PUTCMD4: POP	CX				;BALANCE STACK
	 MOV	BYTE PTR ACKTIME,0		;CLEAR TIME EXPECTATION FLAG
	 CMP	AH,MPUGRCT			;WILL WE EXPECT A DATA BYTE?
	 JNZ	PUTCMD5				;JUMP IF NOT
	 ;
	 MOV	BYTE PTR ACKTIME,0FFH		;ELSE FLAG WE DO
	 ;
PUTCMD5: AND	BYTE PTR STATREC+1,0FBH		;CLEAR ACK'ED BIT
	 MOV	AL,AH				;SEND THE COMMAND
	 OUT	DX,AL
	 ;
	 MOV	DX,CPLOK			;ALL WELL
	 RET
	 ;
PUTCMD	 endp
	 ;
	 SUBTTL	Soft Interrupt Send Data
	 %OUT	Soft Interrupt Send Data
	 PAGE
	 ;
	 ;***************************************************************
	 ;* 14: SODAT	Send a data byte				*
	 ;*								*
	 ;* If the driver is inactive, nothing is done and an error is	*
	 ;* returned. If driver is active, sends the data byte in DL	*
	 ;* to the MPU401. Returns error if output timeout.		*
	 ;***************************************************************
	 ;
	 ;* Refuse to send if driver inactive.
	 ;
SODATI:	 MOV	DX,CPLPASS			;ERROR RETURN CODE
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
	 ;* Normal entry to send a data byte.
	 ;
SODATA:	 PUSH	CX				;SAVE TIMEOUT REG
	 MOV	CX,WORD PTR MPUDELY		;TIMEOUT COUNT
	 ;
	 ;* Don't send data until last cmd has beed acknowledged
	 ;
SODAT1:	 TEST	BYTE PTR STATREC+1,4		;CHECK IF LAST CMD ACK'ED
	 JNZ	SODAT2				;JUMP IF OK
	 ;
	 DEC	CX				;BUMP TIMEOUT
	 JNZ	SODAT1				;LOOP IF NO TIMEOUT YET
	 ;
	 MOV	DX,CPLTERR			;TIMEOUT ERROR
	 JMP	SHORT SODAT5
	 ;
SODAT2:	 MOV	AH,DL				;INPUT DATA
	 MOV	CX,WORD PTR MPUDELY		;TIMEOUT COUNT
	 MOV	DX,WORD PTR CTLPORT		;CONTROL PORT
	 ;
SODAT3:	 IN	AL,DX				;CHECK IF READY TO RECEIVE
	 AND	AL,DRRBIT
	 JZ	SODAT4				;JUMP IF SO
	 ;
	 DEC	CX				;BUMP TIMEOUT COUNT
	 JNZ	SODAT3				;LOOP IF NO TIMEOUT
	 ;
	 MOV	DX,CPLTERR			;TIMEOUT ERROR
	 JMP	SHORT SODAT5
	 ;
SODAT4:	 DEC	DX				;DATA PORT
	 MOV	AL,AH				;SEND DATA
	 OUT	DX,AL
	 MOV	DX,CPLOK			;OK COMPLETION
	 ;
SODAT5:	 POP	CX
	 POP	DS				;RECOVER REGS
	 POP	DI
	 IRET
	 ;
SWIHNL	 endp
	 ;
	 SUBTTL	Hard Interrupt Handler
	 %OUT	Hard Interrupt Handler
	 PAGE
	 ;
	 ;***************************************************************
	 ;* Hardware Interrupt Handler.					*
	 ;*								*
	 ;* You come here when the hardware pulls the interrupt line.	*
	 ;***************************************************************
	 ;
HWIHNL	 proc far
	 ;
	 ;* First check if it was the MPU401 that interrupted.
	 ;
	 PUSH	AX				;SAVE REGS ON CALLER STACK
	 PUSH	DX
	 MOV	DX,CS:WORD PTR CTLPORT		;CHECK IF MPU401 INTERRUPT
	 IN	AL,DX				;BY POLLING DSRBIT
	 AND	AL,DSRBIT
	 JZ	OURINT				;JUMP IF KEYBOARD INT
	 ;
	 ;* Interrupt, but not by the MPU401 - go to original
	 ;* interrupt handler (this is abnormal practice on a PC,
	 ;* where each interrupt line should be driven by only
	 ;* one source, but, as we all know... )
	 ;
	 POP	DX				;RECOVER REGS
	 POP	AX
	 DB	JFAROPC				;JMP FAR OP-CODE
OHWVEC	 DD	0				;ORIGINAL HW VECTOR
	 ;
	 ;* Now set up to use own stack - we don't know how much
	 ;* stack the interrupted routine provides.
	 ;
OURINT:	 MOV	CS:WORD PTR TMPSP,SP		;SAVE CALLER'S SP
	 MOV	CS:WORD PTR TMPSS,SS		;AND SS
	 CLI					;DON'T ALLOW INTERRUPT NOW!
	 MOV	AX,CS
	 MOV	SS,AX
	 MOV	SP,OFFSET STKTOP		;OUR OWN STACK
	 STI
	 PUSH	DS				;SAVE REGS
	 PUSH	CX
	 PUSH	CS				;SET DS = CS
	 POP	DS
	 ;
	 ;* Get the interrupting byte from MPU401 and branch accordingly.
	 ;
HWILOOP: MOV	DX,WORD PTR DATPORT		;PORT TO READ
	 IN	AL,DX				;GET IT
	 ;
	 CMP	AL,MPUOFLO			;TIMER OVERFLOW?
	 JNZ	NOOFLO
	 ;
	 ;* Timer overflow, adjust our internal 32-bit timer.
	 ;
	 ADD	WORD PTR TIMER,OFLTIM		;ADD OVERFLOW VALUE
	 ADC	WORD PTR TIMER+2,0		;32 BIT ADD
	 JMP	GOTMSG				;DONE
	 ;
	 ;* Not a timer overflow.
	 ;
NOOFLO:	 CMP	AL,MPUACK			;MPU ACKNOWLEDGE?
	 JNZ	NOACK
	 ;
	 ;* MPU command acknowledge. Flag it in STATREC, and read
	 ;* any extra accompanying time byte.
	 ;
	 OR	BYTE PTR STATREC+1,4		;SET ACK BIT IN STATUS RECORD
	 AND	AL,BYTE PTR ACKTIME		;IS DATA ASSOCIATED WITH IT?
	 JNZ	MPUTIM				;JUMP DISTANCE TOO FAR
	 JMP	GOTMSG
	 ;
MPUTIM:	 CALL	GETDATA				;GET THE DATA
	 ADD	WORD PTR TIMER,AX		;ADD TO THE TIMER ACKUMULATOR
	 ADC	WORD PTR TIMER+2,0		;32 BIT ADD
	 MOV	BYTE PTR ACKTIME,0		;CLEAR THE FLAG
	 JMP	GOTMSG				;DONE
	 ;
	 ;* Not an MPU401 command acknowledgement.
	 ;
NOACK:	 CMP	AL,MPUMAXT			;IS IT A TIME BYTE?
	 JBE	TIMEBYT				;JUMP IF NOT
	 ;
	 ;* Not a leading time byte.
	 ;
	 CMP	AL,MPUSYSM			;SYSTEM MESSAGE?
	 JNZ	HWIERR0				;TREAT ALL OTHERS AS ERROR
	 ;
	 ;* MPU401 sent a system message
	 ;
	 CALL	GETDATA				;SEE WHAT SYSTEM MESSAGE
	 CMP	AL,MPUMIDX			;SEE IF MIDI EXCLUSIVE?
HWIERR0: JNZ	HWIERR				;TREAT AS ERROR IF NOT
	 ;
	 ;* MPU401 reported a system exclusive message. Read it (and
	 ;* store it if we have a buffer).
	 ;
	 PUSH	DI				;SAVE REGS
	 PUSH	BX
	 MOV	DX,WORD PTR XBFSIZ		;BUFFER SIZE
	 MOV	BX,WORD PTR XBFPUT		;PUTTER INDEX
	 MOV	DI,WORD PTR XBFADR		;BUFFER ADDRESS OFFSET
	 PUSH	DS
	 MOV	DS,CS:WORD PTR XBFADR+2		;BUFFER ADDRESS SEGMENT
	 ;
PUTXMSG: OR	DX,DX				;SEE IF WE HAVE A BUFFER?
	 JZ	PUTXMS2				;JUMP IF NOT
	 ;
	 MOV	CH,AL				;FOR BUFFER PUTTING
	 CALL	PUTBUF				;PUT IT IN BUFFER
	 OR	CS:BYTE PTR STATREC+1,2		;SET DATA FLAG IN STATREC
	 ;
PUTXMS1: MOV	CS:WORD PTR XBFPUT,BX		;UPDATE BUFFER INDEX
	 INC	CS:WORD PTR XNENT		;BUMP BYTES IN XBUF
	 CMP	DX,CS:WORD PTR XNENT		;SEE IF BUFFER OVERFLOW?
	 JA	PUTXMS2				;JUMP IF NOT
	 ;
	 DEC	CS:WORD PTR XNENT		;CANNOT INCREASE
	 OR	CS:BYTE PTR STATREC,2		;SET BUFFER OVERFLOW BIT
	 ;
PUTXMS2: TEST	AL,MPUSBIT			;SEE IF IT WAS A STATUS BYTE
	 JZ	PUTXMS3				;THEN LOOP ON
	 ;
	 CMP	AL,MPUMIDX			;CHECK IF NEW EXCLUSIVE STATUS
	 JNZ	PUTXMS4				;BREAK LOOP IF NOT
	 ;
PUTXMS3: PUSH	DX				;GETDATA CHANGES DX
	 CALL	GETDATA				;GET NEXT BYTE
	 POP	DX
	 JMP	PUTXMSG				;GO STORE IT
	 ;
PUTXMS4: POP	DS				;RECOVER REGS
	 POP	BX
	 POP	DI
	 JMP	GOTMSG
	 ;
	 ;* MIDI timing byte
	 ;
TIMEBYT: MOV	BYTE PTR LASTTIM,AL		;SAVE IT AS POTENTIAL ERROR
	 XOR	AH,AH				;CLEAR UPPER BYTE
	 ADD	WORD PTR TIMER,AX		;ADD TO THE TIMER ACKUMULATOR
	 ADC	WORD PTR TIMER+2,0		;32 BIT ADD
	 ;
	 CALL	GETDATA				;GET NEXT BYTE
	 TEST	AL,MPUSBIT			;SEE IF RUNNING STATUS BYTE
	 JNZ	RSTAT				;JUMP IF SO
	 ;
	 ;* Message without running status. Use recorded status.	
	 ;
	 MOV	CH,BYTE PTR MIDISTT		;USE OLD RUNNING STATUS
	 JMP	SHORT GETMSG
	 ;
	 ;* We got time byte + something that can be either running
	 ;* status or an MPU MARK
	 ;
RSTAT:	 CMP	AL,MPUSMAX			;MAX RUNSTAT VALUE
	 JBE	MPUSTAT				;IT'S NO MARK, GET RUN STATUS
	 ;
	 ;* MIDI mark came from MPU401. Read and check it.
	 ;
MPUMARK: CMP	AL,MPUNOOP			;NOOP WE JUST IGNORE
	 JZ	GOTMSG				;OTHERS WE TREAT AS ERROR
	 ;
HWIERR:	 MOV	BYTE PTR LASTERR,AL		;SAVE FOR ERROR REPORTS
	 OR	BYTE PTR STATREC,8		;SET ERROR BIT IN STATREC
	 JMP	GOTMSG
	 ;
	 ;* We got a running status byte + message. Save status and
	 ;* prepare to get the message.
	 ;
MPUSTAT: MOV	BYTE PTR MIDISTT,AL		;STORE AWAY
	 MOV	CH,AL				;KEEP IT IN BH
	 CALL	GETDATA				;AND GET NEXT BYTE
	 ;
	 ;* Get the message itself. We already have the first byte
	 ;* in AL, and current running status in CH.
	 ;
GETMSG:	 MOV	CL,AL				;FIRST BYTE TO CL
	 MOV	AL,CH				;GET STATUS TO AL
	 AND	AL,ATCHMSK			;MASK TO CHECK FOR 0CH/0DH
	 SUB	AL,ATOUCH			;SEE IF ONE OF THEM (0 IF NOT)
	 JZ	PUTMSG				;THEN GO STORE THEM
	 ;
	 CALL	GETDATA				;GET 2:ND BYTE TOO
	 ;
	 ;* We now have status in CH, first byte in CL and (if
	 ;* applicable) second byte in AL.
	 ;
PUTMSG:  MOV	DX,WORD PTR NENT		;SEE IF BUFFER FULL?
	 ADD	DX,8				;8 BYTES HEADROOM
	 CMP	DX,WORD PTR BFSIZ		;CHECK IF TOO MUCH?
	 JB	PUTMSG1				;JUMP IF ROOM IN BUFFER
	 ;
	 OR	BYTE PTR STATREC,1		;SET STATREC BUFFER OFLOW BIT
	 JMP	SHORT GOTMSG
	 ;
	 ;* Put the data bytes in the buffer.
	 ;
PUTMSG1: PUSH	DI				;SAVE REGS
	 PUSH	BX
	 MOV	DX,WORD PTR BFSIZ		;BUFFER SIZE
	 MOV	BX,WORD PTR BFPUT		;PUTTER INDEX
	 MOV	DI,WORD PTR BFADR		;BUFFER ADDRESS OFFSET
	 PUSH	DS
	 MOV	DS,CS:WORD PTR BFADR+2		;BUFFER ADDRESS SEGMENT
	 ;
	 CALL	PUTBUF				;PUT IT IN BUFFER
	 MOV	CH,CL				;FIRST BYTE
	 CALL	PUTBUF				;PUT IT IN BUFFER
	 MOV	CH,AL				;SECOND BYTE
	 CALL	PUTBUF				;PUT IT IN BUFFER
	 XOR	CH,CH				;A DUMMY BYTE
	 CALL	PUTBUF				;PUT IT IN BUFFER
	 POP	DS				;RECOVER REGISTERS
	 MOV	WORD PTR BFPUT,BX		;UPDATE BUFFER INDEX
	 POP	BX
	 POP	DI
	 OR	BYTE PTR STATREC+1,1		;SET DATA FLAG IN STATREC
	 ADD	WORD PTR NENT,4			;UP BUFFER OCCUPANCY
	 ;
	 ;* MPU Message processed. Check if more data there.
	 ;
GOTMSG:	 MOV	DX,WORD PTR CTLPORT		;SEE IF ANOTHER MESSAGE?
	 IN	AL,DX
	 AND	AL,DSRBIT			;CHECK STATUS
	 JNZ	HWIEXIT				;IF NOTHING THERE, EXIT
	 JMP	HWILOOP				;ELSE GO GET IT
	 ;
	 ;* Done, Make an EOI, restore the interrupted routine's
	 ;* stack and return to it.
	 ;
HWIEXIT: MOV	DX,WORD PTR EOIPORT		;INT CONTROLLER CMD PORT
	 MOV	AL,EOICMD
	 POP	CX				;RESTORE REGS
	 POP	DS
	 CLI
	 MOV	SP,CS:WORD PTR TMPSP		;RESTORE CALLER'S SP
	 MOV	SS,CS:WORD PTR TMPSS		;AND SS
	 OUT	DX,AL				;SEND THE EOI COMMAND
	 POP	DX				;RECOVER FROM CALLER STACK
	 POP	AX
	 IRET					;RESTORES INITIAL EI STATUS
	 ;
HWIHNL	 endp
	 ;
	 ;***************************************************************
	 ;* GETDATA							*
	 ;*								*
	 ;* Read a byte from the data port. Returns the value in AX.	*
	 ;* Sets the timeout error bit in STATREC if no data before	*
	 ;* time-out. If time-out, returns FAKEDAT in AX.		*
	 ;***************************************************************
	 ;
GETDATA	 proc near
	 ;
	 PUSH	CX				;SAVE REG
	 MOV	CX,CS:WORD PTR MPUDELY		;TIMEOUT VALUE
	 MOV	DX,CS:WORD PTR CTLPORT
	 ;
GETDAT1: IN	AL,DX
	 AND	AX,DSRBIT			;CHECK IF DATA THERE
	 JZ	GETDAT2				;THEN JUMP
	 ;
	 DEC	CX				;BUMP TIMEOUT
	 JNZ	GETDAT1				;LOOP IF NOT TIMED OUT
	 ;
	 POP	CX				;RECOVER REG
	 OR	CS:BYTE PTR STATREC,4		;SET TIMEOUT ERROR BIT
	 MOV	AX,FAKEDAT			;FAKED RETURN DATA
	 RET
	 ;
GETDAT2: POP	CX				;RECOVER REG
	 DEC	DX				;DATA PORT
	 IN	AL,DX				;GET DATA (AH=0)
	 RET
	 ;
GETDATA	 endp
	 ;
	 ;***************************************************************
	 ;* PUTBUF							*
	 ;*								*
	 ;* Put CH at the location addressed by DS:BX[DI], and adjust	*
	 ;* BX properly thereafter. DX holds the buffer size. It is	*
	 ;* assumed that any buffer overflow checks have already been	*
	 ;* made.							*
	 ;***************************************************************
	 ;
PUTBUF	 proc near
	 ;
;* !!! Does not this basic addressing mode exist on the 8088/86???!!:
;*	 MOV	DS:BYTE PTR BX[DI],CH		;STORE THE BYTE
;* !!! Trivial on 68K [MOVE.B 0(Dn,An),Dm] - This makes me upset!!!
;* !!! I'm sure you can do it, but maybe not with any regs?
	 ;
	 PUSH	DI				;SAVE DI
	 XCHG	BX,DI				;SAVE BX
	 ADD	BX,DI				;TOTAL OFFSET INTO SEGMENT
	 XCHG	BX,DI				;RECOVER BX
	 MOV	DS:[DI],CH				;PUT IT DOWN
	 POP	DI				;RECOVER DI
	 ;
	 INC	BX				;NEXT BUFFER POS.
	 CMP	BX,DX				;CHECK IF BEYOND BUFFER
	 JB	PUTBUF1
	 ;
	 XOR	BX,BX				;WRAP TO BUFFER START
	 ;
PUTBUF1: RET
	 ;
PUTBUF	 endp
	 ;
	 SUBTTL	Driver Init Code / Buffer Area
	 %OUT	Driver Init Code / Buffer Area
	 PAGE
	 ;
	 ;***************************************************************
	 ;* INIT (0)							*
	 ;*								*
	 ;* This code performs the INIT request, done only once when	*
	 ;* starting the operating system. This code will be overwrit-	*
	 ;* ten by the MIDI buffer later. Therefore it is located at	*
	 ;* the end of the driver.					*
	 ;***************************************************************
	 ;
DBUF	 EQU	$				;START OF MIDI BUFFER
	 ;
INIT	 proc near
	 ;
	 ;* First of all, determine if we are an XT or an AT.
	 ;* Set MPU401 delay accordingly.
	 ;
	 MOV	WORD PTR MPUDELY,2000H		;TIME FOR AN XT
	 MOV	CX,SP				;SAVE CURRENT SP
	 PUSH	SP				;PUSH IT
	 POP	AX				;GET THE VALUE WE JUST PUSHED
	 CMP	AX,CX				;IS IT SAME AS BEFORE PUSH?
	 JNE	INITXT				;NO, WE ARE AN 8086/88
	 ;
	 MOV	CS:BYTE PTR ATFLAG,1		;80286, FLAG IT
	 MOV	WORD PTR MPUDELY,6000H		;TIME FOR AN AT
	 ;
	 ;* Now install default values.
	 ;
INITXT:	 MOV	CS:WORD PTR DATPORT,DDATPORT	;SET UP DEFAULT PORT ADDRESSES
	 MOV	CS:WORD PTR CTLPORT,DCTLPORT
	 MOV	CS:BYTE PTR HRDINT,DHRDINT	;AND INT NUMBERS
	 MOV	CS:BYTE PTR SFTINT,DSFTINT
	 MOV	CS:WORD PTR IBSIZ,DIBSIZ	;AND BUILT-IN BUFFER SIZE
	 MOV	CS:WORD PTR FNCTAB,OFFSET FNCTABI ;INACTIVE DRIVER JUMP TABLE
	 ;
	 ;* Now read and act upon any ASCII parameters. They will
	 ;* supercede the defaults.
	 ;
	 MOV	DS,ES:WORD PTR PMSOFS[BX]	;GET PARAMETER SEGMENT
	 MOV	SI,ES:WORD PTR PMOOFS[BX]	;GET PARAMETER OFFSET
	 ;
PARMLP:	 MOV	AL,BYTE PTR[SI]			;GET CHARACTER
	 INC	SI
	 CMP	AL,'/'				;'/' STARTS ALL PARAMETERS
	 JZ	PARM
	 CMP	AL,ASCILF			;IS IT AN LF (END OF STRING)?
	 JNZ	PARMLP				;LOOP IF NOT
	 ;
	 JMP	INIT2				;END OF PARM STRING
	 ;
PARM:	 MOV	AL,BYTE PTR[SI]			;GET WHAT PARAM
	 INC	SI
	 AND	AL,UCMASK			;UPPER CASE IT
	 MOV	DX,OFFSET ERRMSG1		;ERROR ANTICIPATED
	 MOV	CS:BYTE PTR ERRMS1I,AL		;PUT PARM NAME THERE
	 CMP	AL,'B'				;BUILT-IN BUFFER SIZE?
	 JZ	PARM1
	 CMP	AL,'H'				;HARDWARE INT NUMBER?
	 JZ	PARM1
	 CMP	AL,'P'				;PORT ADDRESS?
	 JZ	PARM1
	 CMP	AL,'S'				;SOFTWARE INT NUMBER?
	 JNZ	PARMERR
	 ;
PARM1:	 MOV	AL,BYTE PTR[SI]			;GET COLON - SHOULD BE ONE!
	 INC	SI
	 MOV	DX,OFFSET ERRMSG2		;ANTICIPATE ERROR
	 CMP	AL,':'				;MUST BE A COLON!
	 JNZ	PARMERR
	 ;
	 CALL	GETHEX				;GET PARAMETER VALUE
	 MOV	AL,CS:BYTE PTR ERRMS1I		;GET PARM NAME
	 CMP	AL,'P'				;PORT ADDRESS?
	 JNZ	PARM2
	 ;
	 MOV	DX,OFFSET ERRMSG3		;ANTICIPATE ERROR
	 CMP	CX,PORTMAX			;MAX ALLOWED PORT ADDRESS
	 JA	PARMERR
	 ;
	 MOV	CS:WORD PTR DATPORT,CX		;NEW DATA PORT ADDRESS
	 INC	DX				;CTRL PORT ADDRES ONE HIGHER
	 MOV	CS:WORD PTR CTLPORT,CX
	 JMP	PARMLP
	 ;
PARM2:	 CMP	AL,'S'				;SOFTWARE INTERRUPT?
	 JNZ	PARM3
	 ;
	 MOV	DX,OFFSET ERRMSG4		;ANTICIPATE ERROR
	 CMP	CX,MAXSFTI			;SEE IF HIGHER THAN ALLOWED
	 JA	PARMERR
	 ;
	 CMP	CX,MINSFTI			;SEE IF LOWER THAN ALLOWED?
	 JB	PARMERR
	 ;
	 MOV	CS:BYTE PTR SFTINT,CL		;INSTALL NEW SOFT INT NUMBER
	 JMP	PARMLP
	 ;
PARM3:	 CMP	AL,'H'				;HARDWARE INTERRUPT?
	 JNZ	PARM5
	 ;
	 MOV	DX,OFFSET ERRMSG5		;ANTICIPATE ERROR
	 CMP	CX,0FH				;CHECK INT IS 0-0FH!
	 JA	PARMERR				;ELSE ERROR!
	 ;
	 MOV	AL,CS:BYTE PTR ATFLAG		;SEE IF AT
	 AND	AL,AL
	 JNZ	PARM4				;IF SO JUMP
	 ;
	 MOV	DX,OFFSET ERRMSG6		;ANTICIPATE ERROR
	 CMP	CL,7				;FOR XT, ONLY 0-7 ARE ALLOWED
	 JA	PARMERR
	 ;
PARM4:	 MOV	CS:BYTE PTR HRDINT,CL		;INSTALL NEW HARD INT NUMBER
	 JMP	PARMLP
	 ;
PARM5:	 MOV	DX,OFFSET ERRMSG7		;BUFSIZ - ANTICIPATE ERROR
	 CMP	CX,MINBSIZ			;CHECK VALUE LIMITS
	 JB	PARMERR
	 CMP	CX,MAXBSIZ
	 JA	PARMERR
	 ;
	 MOV	CS:WORD PTR IBSIZ,CX		;INSTALL NEW BUFFER SIZE
	 JMP	PARMLP
	 ;
	 ;* You come here when an invalid parameter has been found.
	 ;* Print an error message and stop scanning parameters.
	 ;* Leave things as they are and continue.
	 ;*
	 ;* (What you would want to do is print the error, then
	 ;* set the driver size to zero to avoid installing it.
	 ;* This is possible according to the PC-DOS tech man.
	 ;* HOWEVER, it *** DOES NOT WORK ***. MicroSoft them-
	 ;* selves do some tricks to overcome this in their
	 ;* Mouse Driver.)
	 ;
PARMERR: PUSH	CS				;MAKE DS=CS
	 POP	DS
	 PUSH	DX				;SAVE MSG ADDRESS
	 MOV	DX,OFFSET ERRMSG0
	 MOV	AH,PRTSTR
	 INT	SYSTEM				;TYPE DRIVER NAME
	 POP	DX
	 MOV	AH,PRTSTR			;TYPE IT
	 INT	SYSTEM
	 ;
;	 ;* Set size of driver to 0 (DOES NOT WORK - crashes the PC
;	 ;* during boot - bug in MSDOS's initialization code !).
;	 ;
;	 MOV	ES:WORD PTR EOFOFS[BX],0	;SET END OFFSET
;	 MOV	ES:WORD PTR ESGOFS[BX],CS	;SET END PARAGRAPH = BEGINING
;	 RET
	 ;
	 ;* Parameters found and processed. Now install the software
	 ;* interrupt vector after first saving the original value.
	 ;
INIT2:	 XOR	AX,AX				;CLEAR DS
	 MOV	DS,AX
	 MOV	AL,CS:BYTE PTR SFTINT		;GET SOFT INT
	 ADD	AX,AX				;MULT BY 4
	 ADD	AX,AX
	 MOV	SI,AX
	 MOV	AX,WORD PTR DS:[SI]		;GET OLD VECTOR'S OFFSET
	 MOV	CS:WORD PTR OSWVEC,AX		;SAVE IT
	 MOV	AX,WORD PTR DS:2[SI]		;GET SEGMENT
	 MOV	CS:WORD PTR OSWVEC+2,AX		;AND SAVE
	 ;
	 MOV	DS:WORD PTR [SI],OFFSET SWIHNL	;INSTALL SOFTWARE INTERRUPT
	 MOV	DS:WORD PTR 2[SI],CS		;HANDLER ADDRESS	
	 ;
	 ;* Now set up hardware interrupt dependent values.
	 ;
	 MOV	CX,OFFSET XTTAB			;ASSUME WE ARE AN XT
	 MOV	AL,CS:BYTE PTR ATFLAG		;CHECK THAT
	 AND	AX,0FFH				;CLEARS AH FOR LATER
	 JE	INIT3
	 ;
	 MOV	CX,OFFSET ATTAB			;NO, WE ARE AN AT
	 ;
INIT3:	 MOV	AL,CS:BYTE PTR HRDINT		;GET INT NUMBER
	 ADD	AX,AX				;SHIFT UP 2 (AH = 0)
	 ADD	AX,AX
	 ADD	AX,CX				;POINT TO PROPER TABLE ENTRY
	 MOV	SI,AX
	 MOV	AL,CS:BYTE PTR [SI]		;GET EOI PORT ADDRESS (8 BITS)
	 MOV	CS:BYTE PTR EOIPORT,AL		;INSTALL VALUE
	 INC	SI
	 MOV	AL,CS:BYTE PTR [SI]		;GET ENABLE PORT (8 BITS)
	 MOV	CS:BYTE PTR ENAPORT,AL		;INSTALL VALUE
	 INC	SI
	 MOV	AL,CS:BYTE PTR [SI]		;GET BIT MASK (8 BITS)
	 MOV	CS:BYTE PTR DISMASK,AL		;INSTALL DISABLE MASK
	 NOT	AL				;INVERT IT
	 MOV	CS:BYTE PTR ENAMASK,AL		;INSTALL ENABLE MASK
	 INC	SI
	 MOV	AL,CS:BYTE PTR [SI]		;GET VECTOR ADDR/4
	 XOR	AH,AH
	 ADD	AX,AX
	 ADD	AX,AX
	 MOV	CS:WORD PTR HWVECAD,AX		;INSTALL VECTOR ADDRESS
	 ;
	 ;* Now finally return driver values.
	 ;
	 PUSH	CS
	 POP	DS
	 MOV	DX,OFFSET SIGNON
	 MOV	AH,PRTSTR
	 INT	SYSTEM
	 ;
	 PUSH	CS				;GET CODE PARAGRAPH TO DX
	 POP	DX
	 MOV	AX,OFFSET DBUF + 16		;GET DRIVER'S LENGTH + EXTRA
	 ADD	AX,CS:WORD PTR IBSIZ		;ADD BUILT-IN BUFFER SIZE
	 MOV	CL,4				;SHIFT BY 4 TO GET # PARAGR.
	 AND	AL,0F0H				;CLEAR 4 LOW BITS
	 ROR	AX,CL
	 ADD	DX,AX				;END PARAGRAPH IN DX NOW
	 MOV	ES:WORD PTR EOFOFS[BX],0	;SET END OFFSET
	 MOV	ES:WORD PTR ESGOFS[BX],DX	;SET END PARAGRAPH
	 ;
	 RET
	 ;
INIT	 endp
	 ;
	 ;***************************************************************
	 ;* GETHEX							*
	 ;*								*
	 ;* Reads hex characters from string at DS:0[SI] and builds	*
	 ;* value in CX. Terminates on non-hex character. Only used	*
	 ;* during driver initialization. Overwritten by buffer.	*
	 ;***************************************************************
	 ;
GETHEX	 proc near
	 ;
	 XOR	CX,CX				;CLEAR RESULT
	 ;
GETHXLP: MOV	AL,BYTE PTR[SI]			;GET CHAR	 
	 CMP	AL,'0'				;SEE IF < DEC LOW
	 JB	GETHXEX				;THEN EXIT
	 ;
	 CMP	AL,'9'				;SEE IF DEC DIGIT
	 JBE	GETHX1				;THEN JUMP
	 ;
	 AND	AL,UCMASK			;MASK TO UPPER CASE
	 CMP	AL,'A'				;SEE IF < HEX DIGIT
	 JB	GETHXEX				;THEN EXIT
	 ;
	 CMP	AL,'F'				;SEE IF > HEX DIGIT
	 JA	GETHXEX				;THEN JUMP
	 ;
	 SUB	AL,7				;FOR ASCII 'A'-'F' OFFSET 
	 ;
GETHX1:	 AND	AX,0FH				;MASK DIGIT
	 ADD	CX,CX				;SHIFT CX UP 4
	 ADD	CX,CX
	 ADD	CX,CX
	 ADD	CX,CX
	 ADD	CX,AX				;ADD IN LAST DIGIT
	 INC	SI				;NEXT CHARACTER
	 JMP	GETHXLP
	 ;
GETHXEX: RET
	 ;
GETHEX	 endp
	 ;
	 SUBTTL	Initialization Tables
	 %OUT	Initialization Tables
	 PAGE
	 ;
	 ;***************************************************************
	 ;* Initialization tables					*
	 ;***************************************************************
	 ;
	 ;* These tables contain, in each entry:
	 ;*
	 ;* - the EOI command output port address,
	 ;* - the enable/disable interrupt port address,
	 ;* - the interrupt enable bit mask, (bit is a one),
	 ;* - the memory address where to put the vector for the
	 ;*   corresponding interrupt level (divided by 4 to fit
	 ;*   it in a byte).
	 ;
	 ;* First the table for an XT machine.
	 ;
XTTAB:	 DB	20H, 21H, 00000001B,   8		;DATA FOR XT INT 0
	 DB	20H, 21H, 00000010B,   9		;FOR XT INT 1
	 DB	20H, 21H, 00000100B, 0AH		;FOR XT INT 2
	 DB	20H, 21H, 00001000B, 0BH		;FOR XT INT 3
	 DB	20H, 21H, 00010000B, 0CH		;FOR XT INT 4
	 DB	20H, 21H, 00100000B, 0DH		;FOR XT INT 5
	 DB	20H, 21H, 01000000B, 0EH		;FOR XT INT 6
	 DB	20H, 21H, 10000000B, 0FH		;FOR XT INT 7
	 ;
	 ;* Now, the table for an AT machine.
	 ;
	 ;* !!!NOTE!!! The data in the ATTAB table is NOT CORRECT!!!
	 ;* (Due to lack of needed information about AT interrupts).
	 ;
ATTAB:	 DB	20H, 21H, 00000001B,   8		;DATA FOR AT INT 0
	 DB	20H, 21H, 00000010B,   9		;FOR AT INT 1
	 DB	20H, 21H, 00000100B, 0AH		;FOR AT INT 2
	 DB	20H, 21H, 00001000B, 0BH		;FOR AT INT 3
	 DB	20H, 21H, 00010000B, 0CH		;FOR AT INT 4
	 DB	20H, 21H, 00100000B, 0DH		;FOR AT INT 5
	 DB	20H, 21H, 01000000B, 0EH		;FOR AT INT 6
	 DB	20H, 21H, 10000000B, 0FH		;FOR AT INT 7
	 DB	20H, 21H, 00000001B,   8		;FOR AT INT 8
	 DB	20H, 21H, 00000010B,   9		;FOR AT INT 9
	 DB	20H, 21H, 00000100B, 0AH		;FOR AT INT 10
	 DB	20H, 21H, 00001000B, 0BH		;FOR AT INT 11
	 DB	20H, 21H, 00010000B, 0CH		;FOR AT INT 12
	 DB	20H, 21H, 00100000B, 0DH		;FOR AT INT 13
	 DB	20H, 21H, 01000000B, 0EH		;FOR AT INT 14
	 DB	20H, 21H, 10000000B, 0FH		;FOR AT INT 15
	 ;
	 SUBTTL	Error Messages
	 %OUT	Error Messages
	 PAGE
	 ;
	 ;***************************************************************
	 ;* Error messages						*
	 ;***************************************************************
	 ;
SIGNON:  DB	'--- Installing CMT MIDI  MPU401   Device Driver'
	 DB	' v1.30 ---',ASCICR, ASCILF,'$'
	 ;
ERRMSG0: DB	'MPU401 MIDI Driver: $'
	 ;
ERRMSG1: DB	'Unknown Init Parameter "'
ERRMS1I: DB	' "'				;CHAR TO BE INSERTED
	 DB	ASCICR,ASCILF,'$'
	 ;
ERRMSG2: DB	'No ":" After Parm Name'
	 DB	ASCICR,ASCILF,'$'
	 ;
ERRMSG3: DB	'Illegal Port Address'
	 DB	ASCICR,ASCILF,'$'
	 ;
ERRMSG4: DB	'Illegal Software Interrupt'
	 DB	ASCICR,ASCILF,'$'
	 ;
ERRMSG5: DB	'Illegal Hardware Interrupt'
	 DB	ASCICR,ASCILF,'$'
	 ;
ERRMSG6: DB	'Hard Int 8-15 Allowed On PC-AT Only'
	 DB	ASCICR,ASCILF,'$'
	 ;
ERRMSG7: DB	'Illegal Buffer Size'
	 DB	ASCICR,ASCILF,'$'
	 ;
CODSEG	 ENDS
	 IF1
	 %OUT	---------- Pass 1 Completed ----------
	 ENDIF
	 IF2
	 %OUT	---------- Pass 2 Completed ----------
	 ENDIF
	 SUBTTL	Symbols
	 END