:IF[WithUIB]; *********************************************

  TITLE[DUIB];
%
Tom Rich September 8, 1982: WithTor => WithUIB.
Ed Fiala 26 April 1982: Absorb DUIBDefs; use WithTOR conditional;
  eliminate uibNotifyInterruptPage; pick up ESS changes from Tom Rich as
  conditional assembly.
Villano February 26, 1981  9:32 AM changed DoInt to NotifyInterrupt
rej January 9, 1981  2:21 PM output gotcha: removed task in cursLoad;add nops in curschec
rej September 22, 1980  11:19 AM bypass gotcha on CursBitmapPtr in curs loading
rej September 22, 1980  10:02 AM   update CSB cursorLoadControl with PSTORE1
rej September 22, 1980  8:53 AM  IOCBscanlines _ IOCBscanlines-2
rej September 18, 1980  3:30 PM  correct offset in init of cursor quad
rej September 11, 1980  3:58 PM  change cursor, buttons, keys as per spec
rej August 21, 1980  10:04 AM  init InterruptLine to be -1
rej August 21, 1980  9:59 AM  move taskout in VSnotify  - loadpage gotcha
rej August 15, 1980  3:38 PM  set uibWordsPerLine and uibIOCBparms to be same reg
rej August 15, 1980  1:54 PM  tempreg2 instead of 1 in scanline interrupt setup
rej July 18, 1980  9:31 AM one IOFetch16 per line cursload; flag for zero width IOCB
rej June 25, 1980  1:47 PM  adjust CursY by one; sub 1 from interruptline in uibDCBdone
rej June 20, 1980  1:49 PM  fix CursY problem  created in previous mod
rej June 20, 1980  8:57 AM  fix nocursor test in displaysetup, adjust cursY
rej June 19, 1980  2:26 PM  two IOfetch16s per line for cursorload
rej June 19, 1980  12:42 PM fix field set in cursorload
rej June 17, 1980  1:24 PM  zerobase fetch of cursIOCB in curs loading
rej June 17, 1980  9:41 AM  wait text line before cursor load; for debug only
rej June 17, 1980  9:05 AM cursor loading - move cursorX changes to after PSTORE4
rej June 16, 1980  2:07 PM  cursor field fix in loading, one IOFetch 16
rej June 16, 1980  11:38 AM  set to 32 bit cursor in uibNextDCB
rej June 13, 1980  3:26 PM bypass gotcha in uibCursLoadLoop
rej June 12, 1980  5:15 PM make sure uibCSBuiStatus gets fetched before update
rej June 11, 1980  11:03 AM  bypass problem in uibD0vsInterrupt
rej June 6, 1980  9:11 AM  increment uibVideoBitmapPtr after last fetch
rej June 5, 1980  4:24 PM  add "uibVideoUnloadPtr _ uibBufferSize" to uibDCBdone and uibCheckIOCBhead
rej June 5, 1980  10:15 AM  mod for uiCSB and cursorIOCB format change
rej April 9, 1980  1:21 PM  csbBase init in initcode; CursBitmapBase  in curs load
rej April 9, 1980  9:12 AM  fix cursor setup; finish waitscanline
rej April 8, 1980  5:05 PM  setup for waitscanline
rej April 8, 1980  4:37 PM  csbbase init in endfield;fix mousedelxy
rej March 27, 1980  5:08 PM  zerobase
rej March 27, 1980  1:45 PM  wait scanline
rej March 25, 1980  2:20 PM  last IOFETCH16 covers new dcb
%
SET[uibTASKL, LSHIFT[uibTASK,4]]; *FOR DEVICE ADDRESSES

SET[uibClearAddr,0]; *OUTPUT DEVICE ADDRESSES
SET[uibDATABUFaddr,ADD[uibTASKL,1]];
SET[uibControlRegAddr,2];
SET[uibMESAregAddr,3];
SET[uibCursorPointerAddr,4];
SET[uibHTABaddr,5];
SET[uibBPREG,6];
SET[AuibCursMemAddr,7];
SET[uibCursMemAddr,ADD[uibTASKL,7]];
SET[uibOutChannelBuffAddr,ADD[uibTASKL,10]];

SET[uibDeviceIDregAddr, 0]; *INPUT DEVICE ADDRESSES	*new INPUT decodes
SET[uibInChannelBuffAddr,ADD[uibTASKL,1]];
SET[uibStatusReg1Addr, 2];
SET[uibUIBdataAddr, 3];

SET[uibFifoCommandsDispLoc, OR[LSHIFT[uibPage,10],100]];
SET[uibFifoDataTypesDispLoc, OR[LSHIFT[uibPage,10],120]];

MC[uibAllowWU,220];				*control register for init (old was 222)

MC[uiblhLinesPerField,400]; *617B this is 2 less than actual count (R<0  adds 2 more)
MC[uibrhLinesPerField,217];
MC[uibNonDisplayCount,41];*4 less than retrace time; 1 to sync; 1 for R<0; 2 not counted(int&setup)
SET[uibFifoEntriesPerScanLine,3];
MC[uibStartFifoEntryCount,SUB[uibFifoEntriesPerScanLine,2]];

MC[uibTurnOffCursor,2000];			*cursor control
MC[uibLargePositiveNumber,10000];
MC[uibCursFieldBump,40000];
MC[uibCursLinesPerFrame,42];
MC[uibCursXeven,100000];
MC[uibCursBitmapFieldOffset,200];*uibmode - 128d nibbles/field

SET[uibDisplayCSB, uibTask];
SET[uibSCBcsb, 17];
SET[uibKEYcsb, 16];
SET[uibCSBpage, 377];
SET[uibCSBbank, 0];
MC[uiblhCSBbase,LSHIFT[uibCSBpage,10]];		*uib CSB base addresses
MC[uibrhCSBbase,LSHIFT[uibDisplayCSB,4]];
MC[uiblhCSBbase1,LSHIFT[uibCSBbank,10]];
MC[uibrhCSBbase1,ADD[uibCSBbank,1]];

SET[uibMouseXcoordOffset,0];			*uib display CSB constants
SET[uibTouchOffset,2];
SET[uibCSBLineInterruptMaskOffset,4];
SET[uibD0vsInterruptMaskOffset,6];
SET[uibCSBuiStatusOffset,7];
SET[uibCursBitmapBaseOffset,10];
SET[uibCursXOffset,12];
SET[uibIOCBheadOffset,14];
SET[uibCursLoadControlOffset,15];
SET[uibBitmapBaseOffset,16];

SET[uibSCBcsbOffset, LSHIFT[SUB[uibSCBcsb,uibDisplayCSB], 4]];
SET[uibKEYcsbOffset, LSHIFT[SUB[uibKEYcsb,uibDisplayCSB], 4]];

MC[uibKeyBitsQuad0Offset,ADD[uibKEYcsbOffset,0]];			*KEY CSB constants
MC[uibKeyBitsQuad1Offset,ADD[uibKEYcsbOffset,4]];
MC[uibKeyBitsQuad2Offset,ADD[uibKEYcsbOffset,10]];
MC[uibMouseButtonWordOffset,ADD[uibKEYcsbOffset,3]];

MC[uibSCBcsbQuad0offset,ADD[uibSCBcsbOffset,0]];			*SCB CSB constants
MC[uibSCBcsbQuad1offset,ADD[uibSCBcsbOffset,4]];
MC[uibChannelIOCBbaseOffset,ADD[uibSCBcsbOffset,10]];
MC[uibSCBinterruptMaskOffset,ADD[uibSCBcsbOffset,12]];
MC[uibChannelTransferFlagsOffset,ADD[uibSCBcsbOffset,13]];
MC[uibSCBsavedQuadOffset,ADD[uibSCBcsbOffset,14]];

MC[uibInputChannelFlag,1];*flag indicates transfer type: INPUT(1), OUTPUT(0)
MC[uibExecuteChannelTransfer,100000];*flag causes transfer rather than FIFO read

MC[uibUIstatusKeyMask,	100000];		*Display status masks (bits in lh byte)
MC[uibUIstatusTouchMask,	 40000];			*who changed
MC[uibUIstatusMouseXYMask, 20000];
MC[uibUIstatusButtonMask,	 10000];

MC[uibBufferSize,377];				*buffer parameters
MC[uibBuffLessOneBlk,357];

MC[uibButtonsUp,377];

SetTask[uibTask];	*REGISTER PARAMETERS
Set[uibRbase, AND[60, uibTASKL]];
*TEMPORARY REGISTERS

RV[uibTempReg1,ADD[uibRbase,0]]; 
RV[uibTempReg2,ADD[uibRbase,1]]; 
RV[uibTempReg3,ADD[uibRbase,2]]; 
RV[uibTempReg4,ADD[uibRbase,3]]; 


*REGISTERS AND CONSTANTS USED BY UIB TASK DURING DISPLAY PERIOD
* registers 0 and 1 are also used by NotifyInterrupt
RV[uibHTAB,ADD[uibRbase,0]]; 
RV[uibIOCBhead,ADD[uibRbase,0]]; 
RV[uibVideoLoopControl,ADD[uibRbase,0]]; 
RV[uibCursLoadControl,ADD[uibRbase,1]]; 
RV[uibBitmapBase,ADD[uibRbase,2]]; 
RV[uibBitmapBase1,ADD[uibRbase,3]]; 

RV[uibIOCBlink,ADD[uibRbase,4]]; *IOCB WORD 0
RV[uibIOCBparms,ADD[uibRbase,5]]; *IOCB WORD 1
RV[uibWordsPerLine,ADD[uibRbase,5]]; *IOCB WORD 1
RV[uibVideoBitmapPtr,ADD[uibRbase,6]]; *IOCB WORD 2
RV[uibIOCBscanlines,ADD[uibRbase,7]]; *IOCB WORD 3

RV[uibScanLineNotifyMask,ADD[uibRbase,10]];
RV[uibInterruptLine,ADD[uibRbase,11]];
RV[uibCursX,ADD[uibRbase,12]]; 
RV[uibCursY,ADD[uibRbase,13]]; 

RV[uibVideoUnloadPtr,ADD[uibRbase,14]];
RV[uibVideoPtrs,ADD[uibRbase,14]];
RV[uibZeroBase,ADD[uibRbase,15]]; 
RV[uibScanLineCount,ADD[uibRbase,16]]; 
RV[uibStatusReg1,ADD[uibRbase,17]]; 


*REGISTERS USED BY UIB TASK DURING FIFO PERIOD
* registers 0 and 1 are also used by NotifyInterrupt
RV[uibTempReg1,ADD[uibRbase,0]]; 
RV[uibTempReg2,ADD[uibRbase,1]]; 
RV[uibUIBdata,ADD[uibRbase,2]]; 
RV[uibControlReg,ADD[uibRbase,3]]; 
RV[uibFifoEntryCount,ADD[uibRbase,3]]; 

RV[uibMouseButtonWord,ADD[uibRbase,4]];
RV[uibUIstatus,ADD[uibRbase,5]]; 
RV[uibChannelTransferFlags,ADD[uibRbase,7]]; 


RV[uibMouseDelXY,ADD[uibRbase,12]];

RV[uibMouseXcoord,ADD[uibRbase,10]];
RV[uibMouseYcoord,ADD[uibRbase,11]];


RV[uibTouchX,ADD[uibRbase,10]];
RV[uibTouchY,ADD[uibRbase,11]];

RV[uibQuadWord0,ADD[uibRbase,10]];
RV[uibQuadWord1,ADD[uibRbase,11]];
RV[uibQuadWord2,ADD[uibRbase,12]];
RV[uibQuadWord3,ADD[uibRbase,13]]; 

RV[uibScanLineNotifyMask,ADD[uibRbase,10]];
RV[uibInterruptLine,ADD[uibRbase,11]]; 
RV[uibD0vsInterruptMask,ADD[uibRbase,12]];
RV[uibCSBuiStatus,ADD[uibRbase,13]];

RV[uibSCBinterruptMask,ADD[uibRbase,10]];

RV[uibChannelIOCBbase,ADD[uibRbase,10]];

RV[uibChannelBuffBase,ADD[uibRbase,10]];
RV[uibChannelBuffBase1,ADD[uibRbase,11]];
RV[uibChannelBlockCnt,ADD[uibRbase,12]];
RV[uibChannelBuffPtr,ADD[uibRbase,13]]; 

RV[uibCSBbase,ADD[uibRbase,14]]; *BASE REGISTER PAIR
RV[uibCSBbase1,ADD[uibRbase,15]];
RV[uibScanLineCount,ADD[uibRbase,16]]; 
RV[uibStatusReg1,ADD[uibRbase,17]]; 

*REGISTERS USED DURING CURSOR LOADING

RV[uibIOCBhead,ADD[uibRbase,0]]; 
RV[uibCursLoadControl,ADD[uibRbase,1]]; 
RV[uibBitmapBase,ADD[uibRbase,2]]; 
RV[uibBitmapBase1,ADD[uibRbase,3]]; 

RV[uibCursLineCount,ADD[uibRbase,4]];
RV[uibCursZeroBase,ADD[uibRbase,5]]; 
RV[uibCursBitmapPtr,ADD[uibRbase,5]]; 

RV[uibCursBitmapBase,ADD[uibRbase,10]];
RV[uibCursBitmapBase1,ADD[uibRbase,11]];
RV[uibCursX,ADD[uibRbase,12]]; 
RV[uibCursY,ADD[uibRbase,13]]; 

RV[uibCSBbase,ADD[uibRbase,14]]; *BASE REGISTER PAIR
RV[uibCSBbase1,ADD[uibRbase,15]];
RV[uibScanLineCount,ADD[uibRbase,16]]; 
RV[uibStatusReg1,ADD[uibRbase,17]]; 
**********************************************
*INIT CODE
**********************************************
SetTask[uibTask];

uibInit:
	uibControlReg _ (uibAllowWU), At[UIBInitLoc];
	OUTPUT[uibControlReg,uibControlRegAddr]; *ALLOW WAKEUPS
	uibCSBbase_uibrhCSBbase;
	uibCSBbase_(uibCSBbase) OR (uiblhCSBbase);
	uibCSBbase1_uibrhCSBbase1;
	uibCSBbase1_(uibCSBbase1) OR (uiblhCSBbase1);
*set keyboard words to -1 (key up)
	uibTempReg4 _ (ZERO)-1;
	uibTempReg2_ (ZERO)-1;
	uibTempReg3 _ (ZERO)-1;
	uibTempReg1 _ (ZERO)-1;
*init   CSBs and KeyBits --store ones
	t_uibSCBsavedQuadOffset;
	PSTORE4[uibCSBbase, uibTempReg1];
	t_uibKeyBitsQuad0Offset;
	PSTORE4[uibCSBbase,uibTempReg1];*keys up
	t_uibKeyBitsQuad1Offset;
	PSTORE4[uibCSBbase,uibTempReg1];*keys up
:IF[ESSMode]; **************************************
	t_uibKeyBitsQuad2Offset;
	PSTORE4[uibCSBbase,uibTempReg1];*keys up
:ENDIF; ********************************************
	PSTORE4[uibCSBbase,uibTempReg1,uibMouseXcoordOffset];*no touch; mouse at origin
*init   CSBs --store zeros
	uibTempReg4 _ zero;
	uibTempReg2_ zero;
	uibTempReg3 _ zero;
	uibTempReg1 _ zero;
	t_uibSCBcsbQuad0offset;
	PSTORE4[uibCSBbase, uibTempReg1];
	t_uibSCBcsbQuad1offset;
	PSTORE4[uibCSBbase, uibTempReg1];
	t_uibChannelIOCBbaseOffset;
	PSTORE4[uibCSBbase, uibTempReg1];
	PSTORE4[uibCSBbase,uibTempReg1,uibIOCBheadOffset];
	uibTempReg2_ (ZERO)-1;	*init InterruptLine
	nop;*so PSTORE gets updated uibTempReg2
	PSTORE4[uibCSBbase,uibTempReg1,uibCSBLineInterruptMaskOffset];
	uibTempReg3_ (7000c);	*turn off cursor display
	nop;*so PSTORE gets updated uibTempReg3
	PSTORE4[uibCSBbase,uibTempReg1,uibCursBitmapBaseOffset];

SETTASK[uibTASK];
	LOADPAGE[uibPage] ;
	gotop[.+1];
ONPAGE[uibPage];
	CALL[uibTaskOut];
	GOTO[uibENDFIELD];
************************************************
*First wakeup at uibENDFIELD
************************************************

**********************************************
*END DISPLAY 		
**********************************************
uibENDFIELD:
	uibVideoUnloadPtr _ uibBufferSize;
	call[uibCheckCursor], OUTPUT[uibVideoUnloadPtr,uibBPREG];

	uibHTAB_200C; *send black background
	OUTPUT[uibHTAB,uibHTABaddr];
	uibCSBbase_uibrhCSBbase;
	uibCSBbase_(uibCSBbase) OR (uiblhCSBbase);
	uibCSBbase1_uibrhCSBbase1;
	CALL[uibSyncWithVS], uibCSBbase1_(uibCSBbase1) OR (uiblhCSBbase1);
**********************************************
*VERTICAL SYNC
**********************************************
uibSyncWithVS:
	INPUT[uibStatusReg1, uibStatusReg1Addr];
	LU_LDF[uibStatusReg1, 15,1] ;	*vertical ?
	GOTO[uibSleep,ALU=0], uibScanLineCount_uibNonDisplayCount;
**********************************************
*CURSOR LOADING
**********************************************
uibD0cursor:
uibInitCursorLoading:
	PFETCH1[uibCSBbase, uibCursLoadControl,uibCursLoadControlOffset];	*fetch uibCursLoadControl
	uibCursBitmapPtr_zero;	*offset into cursor bitmap	
	uibCursLineCount_(17c);
	SKIP[R<0], LU_uibCursLoadControl;* check need for load
	     GOTO[uibCursOff1], uibCursX_(uibTurnOffCursor);
	PFETCH2[uibCSBbase, uibCursBitmapBase,uibCursBitmapBaseOffset];

	t_LDF[uibCursLoadControl,2,2];  *or in XC8 and XC9 selecting 1 of 4 cursors
	uibCursX_t;
	LU_LDF[uibStatusReg1,14,1];	*check field
	GOTO[.+3, ALU#0], uibCursX_(uibCursX) OR (100000c);
	     uibCursBitmapPtr_(uibCursBitmapPtr)+(uibCursBitmapFieldOffset);
	     uibCursX_(uibCursX) AND NOT (100000c);	*select upper or lower half of RAM
	OUTPUT[uibCursX, uibCursorPointerAddr];

uibCursLoadLoop:
	     CALL[uibSleep], t_uibCursBitmapPtr;
	     GOTO[uibCursEndLoad,R<0], uibCursLineCount_(uibCursLineCount)-(2c);
*******************  for 2 IOFETCH16s per scanline
*	     GOTO[uibCursOff,R<0], uibCursLineCount_(uibCursLineCount)-(4c);
*	          IOFETCH20[uibCursBitmapBase, uibCursMemAddr];
*	          CALL[uibTaskOut], t_(uibCursBitmapPtr)_(uibCursBitmapPtr)+(20c);
*******************  for 2 IOFETCH16s per scanline
	          IOFETCH20[uibCursBitmapBase, uibCursMemAddr];
	          GOTO[uibCursLoadLoop], uibCursBitmapPtr_(uibCursBitmapPtr)+(20c);

uibCursEndLoad:
	uibCursLoadControl_(uibCursLoadControl) + (uibCursFieldBump);	*  add one per field
	PSTORE1[uibCSBbase, uibCursLoadControl,uibCursLoadControlOffset];*STORE uibCursLoadControl
uibCursOff:
	uibCursX_(uibTurnOffCursor);
uibCursOff1:
	OUTPUT[uibCursX, uibCursorPointerAddr]; *turn off cursor


**********************************************
*FIFO
**********************************************
**********************************************
*restore state:
*	1) retrieve saved quad from CSB
*	2) retrieve ChannelTransferFlags word from CSB
**********************************************
uibFifo:
uibFIFOstateRestore:
	t_uibChannelTransferFlagsOffset;
	PFETCH1[uibCSBbase, uibChannelTransferFlags];
	uibUIstatus_(zero);
	uibFifoEntryCount_(zero);	*will execute loop twice
	t_uibSCBsavedQuadOffset;
	GOTO[uibPreEntryLoop], PFETCH4[uibCSBbase, uibQuadWord0];

**********************************************
*process fifo entries 
**********************************************
uibProcessFifo:
uibFifoScanLineLoop:	*** do untill time for display (uibScanlineCount<0) 
	CALL[uibSleep];
	GOTO[uibFIFOstateSave, R<0], LU_(uibScanLineCount);
	GOTO[uibEntryLoop], uibFifoEntryCount_(uibStartFifoEntryCount);
uibEntryLoopEnd:
	     GOTO[uibFifoScanLineLoop,R<0], uibFifoEntryCount_(uibFifoEntryCount)-1;
	     NOP;*placement
uibPreEntryLoop:
	     CALL[uibTaskOut];	*task at  end of each  entry
uibEntryLoop:		*** do while entry  in Fifo(IOATTEN) or channel transfer and entryCount >=0 
	     GOTO[uibChannelTransfer, R<0], LU_uibChannelTransferFlags;	*channel transfer
	     SKIP[IOATTEN];
		GOTO[uibFifoScanLineLoop];				*FIFO empty
	     INPUT[uibUIBdata,uibUIBdataAddr];				*FIFO entry
	     SKIP[R<0],  DISPATCH[uibUIBdata,3,4], LU_uibUIBdata;
	          DISP[uibFifoCommands], t_RHMASK[uibUIBdata];
	     DISP[uibFifoDataTypes], t_RHMASK[uibUIBdata];
**********************************************
*fifo state save 
**********************************************
uibFIFOstateSave:
	t_uibSCBsavedQuadOffset;
	PSTORE4[uibCSBbase, uibQuadWord0];
	TASK, t_uibChannelTransferFlagsOffset;
	PSTORE1[uibCSBbase, uibChannelTransferFlags];
**********************************************
*VS interrupt 
**********************************************
uibD0vsInterrupt:
	PFETCH4[uibCSBbase,uibScanLineNotifyMask,uibCSBLineInterruptMaskOffset];
	t_uibUIstatus;
	uibCSBuiStatus_uibCSBuiStatus;	*make sure its there
	uibCSBuiStatus_t;
	t_uibD0vsInterruptMask;	* set t here to avoid bypass gotcha (3rd inst is in NotifyInterrupt)
	LOADPAGE[NotifyInterruptPage] ;
	CALLp[NotifyInterrupt],PSTORE4[uibCSBbase,uibScanLineNotifyMask,uibCSBLineInterruptMaskOffset];
	CALL[uibSleep], PFETCH4[uibCSBbase, uibIOCBhead,uibIOCBheadOffset];*fetch display control

**********************************************
*DISPLAY SETUP
**********************************************
uibLastNonDisplayLine: 
	PFETCH2[uibCSBbase, uibCursX, uibCursXOffset];*fetch cursor x and y
uibSetScanLineCount:
	uibScanLineCount_uiblhLinesPerField;
	uibScanLineCount _ (uibScanLineCount) OR (uibrhLinesPerField);
	t_uibInterruptLine, GOTO[uibCursorSet, R<0];*no scanline interrupt
	     uibTempReg2_t;*save uibInterruptLine
	     t_uibScanLineCount;
	     uibInterruptLine_t;
	     t_uibTempReg2;
	     uibInterruptLine_(uibInterruptLine)-t;* uibInterruptLine_total-uibInterruptLine
						*save remainder
	     uibScanLineCount_t;*set count for uibInterruptLine before notify
	     uibScanLineCount_(uibScanLineCount)-(2c);*two lines sent for count of 0
uibCursorSet:
	uibCursY_(uibCursY)+(1c);
	TASK, t_(uibCursX)-(3c);	*kludge
	uibCursX_(zero) - t;	*negate x value
	t _ LDF[uibStatusReg1,14,1];	*check for even/odd field
	t_(LDF[uibCursY,17,1] ) XOR t;
	GOTO[.+3,ALU#0], uibCursX_LDF[uibCursX,5,13];
	      uibCursX_(uibCursX) OR (uibCursXeven);
	      uibCursY_(uibCursY)-1;
uibCheckIOCBhead:
	uibZeroBase_zero;	
	t_uibIOCBhead;
	GOTO[uibGetFirstDCB, ALU#0], uibVideoUnloadPtr _ uibBufferSize;
	     OUTPUT[uibVideoUnloadPtr,uibBPREG];
	     call[uibCheckCursor],IOSTROBE;
	     goto[uibNoMoreDCBs];
uibGetFirstDCB:
	CALL[uibTaskOut], ODDPFETCH4[uibZeroBase,uibIOCBlink]; *Fetch IOCB
	GOTO[uibNextDCB],IOSTROBE;

**********************************************
*VIDEO	
**********************************************
**********************************************
*last thing you do after processing a scan line which is not the last of a DCB
**********************************************
uibNormalVideoExit:
	call[uibCheckCursor], uibVideoBitmapPtr_(uibVideoBitmapPtr)+(20C);*update after last fetch
uibVideoData:
	t_(uibWordsPerLine)-(21c);	*-1 since loop terminates on negative count
	uibVideoLoopControl_t ;	* set up count so last fetch16 is not in loop
	CALL[uibVideoLoop], t _uibVideoBitmapPtr;
uibVideoLoop:
	GOTO[uibVideoLastIOFetch, R<0], uibVideoLoopControl_(uibVideoLoopControl)-(20c);
	IOFETCH16[uibBitmapBase,uibDATABUFaddr];
	RETURN, uibVideoBitmapPtr_t_(uibVideoBitmapPtr)+(20C);
**********************************************
*finished with scan line;   end of field? end of DCB?
**********************************************
uibVideoLastIOFetch:
	***** IOSTROBE done early; next task is last for this line
	IOSTROBE, uibIOCBscanlines_(uibIOCBscanlines)-1,GOTO[uibDCBDONE, R<0];
uibDCBnotDone:
	     SKIP[R<0], LU_uibWordsPerLine;	* zero width IOCB flag
	     IOFETCH16[uibBitmapBase,uibDATABUFaddr];	*last fetch16, this path
	     uibScanLineCount _ (uibScanLineCount)-1,GOTO[uibDCBcontinue,R>=0]; 
	          GOTO[uibENDFIELD, R <0], t_uibInterruptLine;*more scanlines?
	               uibInterruptLine_(zero) -1;*set to no more scanlines
	               LOADPAGE[NotifyInterruptPage], uibScanLineCount_t;*set count for remainder
	               CALL[NotifyInterrupt], t_uibScanLineNotifyMask;
uibDCBcontinue:
	     t_(uibWordsPerLine) AND NOT (17c);*stay on 16 word boundary
	     GOTO[uibNormalVideoExit], uibVideoBitmapPtr_(uibVideoBitmapPtr)+t;

uibDCBdone:
	uibTempReg1_t;	*save t for last iofetch16; get next dcb first
 	t_(uibIOCBlink);
	GOTO[uibFinishLastDCB, ALU=0], uibVideoUnloadPtr _ uibBufferSize;
	     ODDPFETCH4[uibZeroBase,uibIOCBlink]; *Fetch IOCB
	     t_uibTempReg1;
	     SKIP[R<0], LU_uibWordsPerLine;	* zero width IOCB flag
	     IOFETCH16[uibBitmapBase,uibDATABUFaddr]; *last fetch16, this path
	     uibScanLineCount _ (uibScanLineCount)-1,GOTO[uibNextDCB,R>=0]; 
	          SKIP[R >=0], uibInterruptLine_(uibInterruptLine)-1;*test waitscanline 
	               GOTO[uibENDFIELD];
	          GOTO[uibNextDCB];*cannot do scanline notify and nextDCB


**********************************************
*Next DCB	set pointers - bitmap, load, unload 
**********************************************
uibNextDCB:		*covered by last IOFETCH16
	t_RHMASK[uibIOCBparms];
	LU_LDF[uibStatusReg1,14,1];	*check field
	SKIP[ALU#0], uibVideoUnloadPtr_(uibVideoUnloadPtr)-t;	*buffer size - words/line
	     uibVideoBitmapPtr_(uibVideoBitmapPtr) + t;	*interlace
	LU_LDF[uibVideoBitmapPtr,14,4];	*hex or octal align?
	SKIP[ALU=0],uibVideoBitmapPtr_(uibVideoBitmapPtr) AND NOT (17c);*force hex
	     uibVideoPtrs_(uibVideoPtrs)-(4000c);*sub 8 from loadPtr
	t_LSH[uibVideoUnloadPtr,10];	*compute loadPtr
	uibVideoPtrs_(uibVideoUnloadPtr) + t;
	OUTPUT[uibVideoPtrs,uibBPREG];
	CALL[uibCheckCursor], uibIOCBscanlines_(uibIOCBscanlines)-(2c); 

* the following code is executed the first part of the next scanline
	uibHTAB_277c;	*set for white background and 32 bit cursor
	t _ LDF[uibIOCBparms,2,6]; *calculate HTAB
	LU_LDF[uibIOCBparms,1,1]; *black background bit
	uibHTAB _ (uibHTAB) - (T),GOTO[.+2,ALU#0]; 
	      uibHTAB _ (uibHTAB) AND NOT (200C);
	OUTPUT[uibHTAB,uibHTABaddr]; 
	t_RHMASK[uibIOCBparms];
	SKIP[ALU#0], uibWordsPerLine_t; *uibWordsPerLine and  uibIOCBparms are the same reg !!!!! 
	      uibWordsPerLine _ (zero) - 1;	*flag for zero width IOCB
	goto[uibVideoData];


**********************************************
*no more DCBs
**********************************************
uibFinishLastDCB:
	OUTPUT[uibVideoUnloadPtr,uibBPREG];
	t_uibTempReg1;	*restore t for IOFETCH
	SKIP[R<0], LU_uibWordsPerLine;	* zero width IOCB flag
	IOFETCH16[uibBitmapBase,uibDATABUFaddr]; *last fetch16, this path;
uibNoMoreDCBscanlineCheck:
	uibScanLineCount _ (uibScanLineCount)-1,GOTO[uibNoMoreDCBtask,R>=0]; 
	     SKIP[R >=0], t_uibInterruptLine;*test waitscanline 
	          GOTO[uibENDFIELD];
	     uibInterruptLine_(zero) -1;*set to no more scanlines
	     LOADPAGE[NotifyInterruptPage], uibScanLineCount_t;*set count for remainder
	     CALL[NotifyInterrupt], t_uibScanLineNotifyMask;
uibNoMoreDCBtask:
	nop; *placement
	call[uibCheckCursor];
uibNoMoreDCBs:
	GOTO[uibNoMoreDCBscanlineCheck], IOSTROBE;


**********************************************
*FIFO	COMMANDS AND DATA
**********************************************
uibFifoCommands:
uibFetchKeyQuad:				AT[uibFifoCommandsDispLoc,0],
	t_uibKeyBitsQuad1Offset;
	GOTO[uibEntryLoopEnd], PFETCH4[uibCSBbase,uibQuadWord0];

uibStoreKeyQuad:				AT[uibFifoCommandsDispLoc,1],
	uibUIstatus_(uibUIstatus) OR  (uibUIstatusKeyMask);
	t_uibKeyBitsQuad1Offset;
	GOTO[uibEntryLoopEnd], PSTORE4[uibCSBbase,uibQuadWord0];

uibUpdateMouse:				AT[uibFifoCommandsDispLoc,2],
	t_uibMouseDelXY;
	uibTempReg1_t;* save since fetch will clobber uibMouseDelXY
	PFETCH4[uibCSBbase,uibMouseXcoord,uibMouseXcoordOffset];
	uibUIstatus_(uibUIstatus) OR  (uibUIstatusMouseXYMask);
	t_RHMASK[uibTempReg1];
	SKIP[NOH2BIT8], uibMouseXcoord_(uibMouseXcoord)+t;
	     uibMouseXcoord_(uibMouseXcoord) + (177400c);	*extend sign bit
	t_LDF[uibTempReg1,0,10];
	SKIP[NOH2BIT8],uibMouseYcoord_(uibMouseYcoord)+t;
	      uibMouseYcoord_(uibMouseYcoord) + (177400c);	*extend sign bit
	nop;	*allow write of uibMouseYcoord before store
	GOTO[uibEntryLoopEnd], PSTORE4[uibCSBbase,uibMouseXcoord,uibMouseXcoordOffset];

uibUpdateMouseButtons:				AT[uibFifoCommandsDispLoc,3],
	uibUIstatus_(uibUIstatus) OR (uibUIstatusButtonMask);
	uibMouseButtonWord_t;
	t_uibMouseButtonWordOffset;
	GOTO[uibEntryLoopEnd], PSTORE1[uibCSBbase, uibMouseButtonWord];

uibFetchSCBcsbQuad0:				AT[uibFifoCommandsDispLoc,4],
	t_uibSCBcsbQuad0offset;
	GOTO[uibEntryLoopEnd], PFETCH4[uibCSBbase,uibQuadWord0];

uibStoreSCBcsbQuad0:				AT[uibFifoCommandsDispLoc,5],
	t_uibSCBcsbQuad0offset;
	GOTO[uibEntryLoopEnd], PSTORE4[uibCSBbase,uibQuadWord0];

uibFetchSCBcsbQuad1:				AT[uibFifoCommandsDispLoc,6],
	t_uibSCBcsbQuad1offset;
	GOTO[uibEntryLoopEnd], PFETCH4[uibCSBbase,uibQuadWord0];

uibStoreSCBcsbQuad1:				AT[uibFifoCommandsDispLoc,7],
	t_uibSCBcsbQuad1offset;
	GOTO[uibEntryLoopEnd], PSTORE4[uibCSBbase,uibQuadWord0];

uibInputChanTransfer:				AT[uibFifoCommandsDispLoc,10],
	uibChannelTransferFlags_(uibChannelTransferFlags) OR (uibInputChannelFlag);
uibOutputChanTransfer:				AT[uibFifoCommandsDispLoc,11],
	uibChannelTransferFlags_(uibChannelTransferFlags) OR (uibExecuteChannelTransfer);
	t_(LDF[uibUIBdata,14,4]);	*get block count specifying amount of data
	uibChannelBlockCnt_t;
	uibUIBdata_(LDF[uibUIBdata,10,2]);*n th additional transfer of a multi-buffer transfer
	t_LSH[uibUIBdata,10];	*multiply by buffer size (256d)
	GOTO[uibEntryLoopEnd], uibChannelBuffPtr_(uibChannelBuffPtr)+t; * (start+n*256)

uibStoreTouch:					AT[uibFifoCommandsDispLoc,12],
	uibUIstatus_(uibUIstatus) OR  (uibUIstatusTouchMask);
	GOTO[uibEntryLoopEnd], PSTORE2[uibCSBbase,uibTouchX,uibTouchOffset];


uibNotifyMesaSCBdriver:				AT[uibFifoCommandsDispLoc,13],
	t_uibSCBinterruptMaskOffset;
	PFETCH1[uibCSBbase,uibSCBinterruptMask];
	LOADPAGE[NotifyInterruptPage];
	CALL[NotifyInterrupt], t_uibSCBinterruptMask;
	GOTO[uibEntryLoopEnd];

uibFetchChannelIOCB:				AT[uibFifoCommandsDispLoc,14],
	t_uibChannelIOCBbaseOffset;
	PFETCH2[uibCSBbase,uibChannelIOCBbase];*fetch pointer to IOCB table
	t_LDF[uibUIBdata,12,6];*select  IOCB
	LU_uibChannelIOCBbase;
	GOTO[uibEntryLoopEnd], PFETCH4[uibChannelIOCBbase,uibChannelBuffBase];*fetch IOCB

:IF[ESSMode]; *********************************
uibFetchKeyQuad2:				AT[uibFifoCommandsDispLoc,15],
	t_uibKeyBitsQuad2Offset;
	GOTO[uibEntryLoopEnd], PFETCH4[uibCSBbase,uibQuadWord0];

uibStoreKeyQuad2:				AT[uibFifoCommandsDispLoc,16],
	t_uibKeyBitsQuad2Offset;
	GOTO[uibEntryLoopEnd], PSTORE4[uibCSBbase,uibQuadWord0];
:ENDIF; ***************************************

uibFifoDataTypes:
uibReplaceQuadByte0:					AT[uibFifoDataTypesDispLoc,0],
	GOTO[uibEntryLoopEnd], uibQuadWord0_(LHMASK[uibQuadWord0]) OR t;
uibReplaceQuadByte1:					AT[uibFifoDataTypesDispLoc,1],
	t_LSH[uibUIBdata,10];
	GOTO[uibEntryLoopEnd], uibQuadWord0_(RHMASK[uibQuadWord0]) OR t;
uibReplaceQuadByte2:					AT[uibFifoDataTypesDispLoc,2],
	GOTO[uibEntryLoopEnd], uibQuadWord1_(LHMASK[uibQuadWord1]) OR t;
uibReplaceQuadByte3:					AT[uibFifoDataTypesDispLoc,3],
	t_LSH[uibUIBdata,10];
	GOTO[uibEntryLoopEnd], uibQuadWord1_(RHMASK[uibQuadWord1]) OR t;

uibReplaceQuadByte4:					AT[uibFifoDataTypesDispLoc,4],
	GOTO[uibEntryLoopEnd], uibQuadWord2_(LHMASK[uibQuadWord2]) OR t;
uibReplaceQuadByte5:					AT[uibFifoDataTypesDispLoc,5],
	t_LSH[uibUIBdata,10];
	GOTO[uibEntryLoopEnd], uibQuadWord2_(RHMASK[uibQuadWord2]) OR t;
uibReplaceQuadByte6:					AT[uibFifoDataTypesDispLoc,6],
	GOTO[uibEntryLoopEnd], uibQuadWord3_(LHMASK[uibQuadWord3]) OR t;
uibReplaceQuadByte7:					AT[uibFifoDataTypesDispLoc,7],
	t_LSH[uibUIBdata,10];
	GOTO[uibEntryLoopEnd], uibQuadWord3_(RHMASK[uibQuadWord3]) OR t;
uibMouseDeltaX:						AT[uibFifoDataTypesDispLoc,10],
	GOTO[uibEntryLoopEnd], uibMouseDelXY_(LHMASK[uibMouseDelXY]) OR t;
uibMouseDeltaY:						AT[uibFifoDataTypesDispLoc,11],
	t_LSH[uibUIBdata,10];
	GOTO[uibEntryLoopEnd], uibMouseDelXY_(RHMASK[uibMouseDelXY]) OR t;


**********************************************
*CHANNEL TRANSFER
**********************************************
uibChannelTransfer:
	GOTO[uibChannelTransferDone,R<0], uibChannelBlockCnt_(uibChannelBlockCnt)-1;
	t_uibChannelBuffPtr;
	SKIP[R EVEN], LU_uibChannelTransferFlags;
	     SKIP, IOSTORE16[uibChannelBuffBase,uibInChannelBuffAddr];
	IOFETCH16[uibChannelBuffBase,uibOutChannelBuffAddr];
	GOTO[uibEntryLoopEnd], uibChannelBuffPtr_(uibChannelBuffPtr)+(20c);
uibChannelTransferDone:
	GOTO[uibFifoScanLineLoop], uibChannelTransferFlags_zero;
**********************************************
*CALL IT QUITS FOR THIS SCAN LINE
**********************************************
uibSleep:
	IOSTROBE, uibScanLineCount_(uibScanLineCount)-1;
uibTaskOut:
	RETURN;

**********************************************
*CHECK CURSOR
**********************************************
*CursX is written once to start the cursor and once to turn it off

uibCheckCursor:
	GOTO[uibCursRet, r>=0], uibCursY_(uibCursY)-(2c);	*start cursor ?
	      LU_(uibCursY)+(4c);
	      GOTO[.+2,ALU<0];
	            GOTO[uibSendCursX];	*first line of cursor; send CursX
	      LU_(uibCursY)+(uibCursLinesPerFrame);
	      GOTO[.+2, ALU<0], uibCursX_LDF[uibCursX,16,2];	*maintain XC8 and XC9
	            GOTO[uibCursRet];
	      uibCursX_(uibCursX) OR (uibTurnOffCursor);	*finished w cursor; turn it off
	      uibCursY_uibLargePositiveNumber;
uibSendCursX:
	      OUTPUT[uibCursX, uibCursorPointerAddr];
	      nop;	*output gotcha
uibCursRet:
	nop;	*output gotcha
	nop;	*output gotcha
	GOTO[ uibTaskOut];

  END[DUIB];

:ELSE; ****************************************************

  TITLE[No.DUIB.unless.WithUIB.eq.1];

:ENDIF; ***************************************************
(1552)\2775b2B413b19B261b14B5378b105B1829b12B393b109B160b110B1642b100B462b1B1923b13B1415b8B2373b47B1263b12B765b118B3456b20B1385b16B528b32B178b12B