{
 File name:  Raven.mc
 Description: Raven LSEP (Low Speed Electronic Printer) microcode
 Author: Pitts PXJ   ,
 Created: March 14, 1980,
 Last Edited:
 	Julio JxC     ,  7-Feb-85 17:07:05 Added CopyRight notice.
	Neil NXS         , 16-Jan-85 11:59:45 Rewrite to even out overhead between
	  scan line involving bandswitch and scan line without bandswitch.  This 
	  allows a common version of microcode to drive Ravens, Banshee and Fuji 
	  model 35s, with varying clock rates.
	AeF AEF     ,  6-Feb-84 17:37:47  Move initialization of displayBase1 to
          start of code.
	AeF AEF     , 13-Oct-83 11:04:28  Change references for IOPage move.
	CrF   CRF, 21-Oct-82 18:25:35  Rewrite vertical registration code to allow
	  shorter delay between line sync and first data bit sent.
	AeF AEF     , August 3, 1982  1:54 PM  Change CSB Offset names
	AeF AEF     , July 6, 1982  11:42 AM  Move WakeupMaskOffset definition to
	  Dandelion.df
	RXG   , July 30, 1981  11:51 PM: added ClrDPRq & PCtl¬ after endBand
	  so that hardware fix to allow slower LSEP's works.  (Note that the click
	  at endBand can be eliminated if the click before uses nibCarry.)
	PXO     , March 23, 1981  5:25 PM: Remove some unneeded CANCELBR's
	PXJ   , November 25, 1980  2:14 PM
}
  
{	Copyright (C) 1980, 1981, 1982, 1983, 1984, 1985 by Xerox Corporation.  All rights reserved. }

{
WARNING:  this microcode is extremely timing dependent.  Don't attempt to change it without fully understanding the timing constraints.
Notes:
1. There is a parameterized delay loop that controls the amount of JYW   video data between the rising edge of the line sync signal and the first actual video data bit (pixel) sent to the printer.  This delay is adjusted by the operator to align the printed image with the paper on a particular printing device.  The unit of delay at the Face level is 16 pixels.  After line sync is sensed, a 16-bit counter is enabled in the DLion Raven Controller.  This counter is clocked by the video data clock from the printer, and is used to cause a wakeup every 16 pixels.
2. There are six DLion clicks of overhead every time we switch from one band of 16 scan lines to the next band.  The hardware wakeup register remains set after a data wakeup until the microcode executes a ClrDPRq.  By not executing a ClrDPRq in the six click band overhead code, it is possible to get those six clicks to run in six consecutive rounds, taking only 2.057 microseconds each, rather than 16*printerDataRate each (for Raven each full tick of the video clock is .278 microseconds, so data wakeups happen every 4.48 microseconds) if we waited for the next data wakeup each time.  There is an "Overhead" loop to equalize the band switch/non band switch time between line sync and the registartion delay loop.
3. This overhead must be accounted for as part of the registartion delay, as the Raven Spec calls for a minimum delay of 70 pixels. For Raven the ratio of rounds to data wakeups is close to 2 to 1, so the six rounds of band overhead get counted as three data wakeups, or two counts through the delay loop.  This means the minimum delay for Raven is three data wakeups, or about 48 pixels, counting the delay loop exit click.  For Banshee the ratio is about 7 to 2, (pixel clock is .444 microseconds, data wakeups happen every 7.104 microseconds) so minimum delay is 32 pixels.  This is acceptable within the allowances of the Banshee registation switches.  Due to the design of the DLion Raven Controller, the first data wakeup comes about 4 pixels after line sync, so the actual minimum delay possible is 4 pixels longer.
}

{
Printer Control register on X-Bus
~ClearLineActive	8	zero inhibits data wakeups and forces video to all
				JYW   until next line sync
ForceRequest		4	forces printer wakeups every round
~VideoWhite		2	zero forces video to JYW  
EnablePrinter		1	enables printer and memory refresh task wakeups
}

Set[EndActiveScanCtl, 1];
Set[EndBandScanCtl, 5];
Set[StartScanCtl, 9];
Set[StartActiveCtl, 0B];

{Raven CSB  (read once per page, immediately after code detects run#0)
	run		non-zero=> index of 1st band record (displayBase0
			relative), read then zeroed
	overrun		non-zero=> over ran band buffer
	interruptMask	Mesa process stuff
	bandSize	number of lines in a band
	active scan	number of words in line buffer actually sent to printer
	line size	number of words in line buffer
	tab		number of words skipped from line sync before sending image
			to printer
	scans		number of blank lines sent to printer at start of page}

{Raven band record
	pointer		real address of band (displayBase1 relative)
	next		index of next band record (displayBase0 relative)
	status		0 => empty, #0 => full, <0 => last band}

SetTask[1];
StartAddress[PrinterInit];

PrinterInit:
	PCtl¬ EndActiveScanCtl, CancelDisp[$]{wakeup on next line sync}	,c1;
nextPage:
	displayBase0 ¬ IOPageHigh, ClrDPRq {band buffer in first 64K}	,c2;
	rD0 ¬ uIOPage							,c3;

pageGap:
	MAR¬ [displayBase0, rD0 + RavenRunOffset] {wait for run # 0}	,c1;
	MDR¬ 0, CancelPgCross[$, 0], LOOPHOLE[wok] {clear immediately}	,c2;
	rD1¬ MD								,c3;

	uThis¬ rD1, ZeroBr						,c1;
	rD1¬ 0A, BRANCH[startPage, $]		{rD1¬ AltUaddr index}	,c2;
	PCtl¬ EndActiveScanCtl, GOTO[pageGap]				,c3;

startPage:
	Noop								,c3;

	{clear overrun}
	rD0 ¬ MAR ¬ [displayBase0, rD0 + RavenOverrunOffset]		,c1;	
	MDR ¬ 0, CancelPgCross[$, 0], LOOPHOLE[wok]			,c2;
	displayBase1 ¬ 0						,c3;

loadParam:
	MAR¬ [displayBase0, rD0+1], rD0¬ rD0+1	{load parameters}	,c1;
	uScans¬ rD0, CancelPgCross[$]					,c2;
	rD0¬ MD								,c3;

	Ybus¬ rD1, rD1¬ rD1+1, NibCarryBr, AltUaddr			,c1;
	uyParamBase¬ rD0, BRANCH[$, fixUTabCnt]				,c2;
	rD0¬ uScans, GOTO[loadParam]					,c3;

fixUTabCnt:
	rD1¬ uTabCnt							,c3;

	rD1¬ rD1-3	{for compatability with previous versions}	,c1;
	uTabCnt¬ rD1							,c2;

skipLines:
	rD0¬ rD0-1, ZeroBr			{loaded uScans last}	,c3;

	BRANCH[$, firstBand]			{line sync wakeup}	,c1;
	PCtl¬ EndActiveScanCtl, GOTO[skipLines]				,c2;

firstBand:
	GOTO[thisBand]			{avoid allocation constraints}	,c2;

nextBand:
	Noop								,c2;
thisBand:
	rD0¬ uThis							,c3;

	MAR¬ [displayBase0, rD0], rD0¬ rD0+1	{line sync wakeup}	,c1;
	CancelPgCross[$]						,c2;
	rD1¬ MD					{pointer to band}	,c3;

	MAR¬ [displayBase0, rD0], rD0¬ rD0+1				,c1;
	uLineAddress¬ rD1, CancelPgCross[$]				,c2;
	rD1¬ MD					{next band}		,c3;

	MAR¬ [displayBase0, rD0], uBandStatus¬ rD0			,c1;
		{save address for later}
	uThis¬ rD1, CancelPgCross[$]					,c2;
	rD1¬ MD					{status of this band}	,c3;

	[]¬ rD1, ZeroBr							,c1;
	rD1¬ uLineAddress, BRANCH[$, RavenOverrun]			,c2;
	rD0¬ uBandSize							,c3;

	uLineCount¬ rD0, GOTO[startLine1]				,c1;

startLine:
	PCtl¬ EndActiveScanCtl						,c1;
	rD0¬ uLineSize							,c2;
	rD1¬ uLineAddress						,c3;

	rD1¬ rD1+rD0				{line sync wakeup}	,c1;
	uLineAddress¬ rD1						,c2;
	rD0¬ 3			{3 clicks more overhead if band switch}	,c3;

overhead:
	Noop								,c1;
	rD0¬ rD0-1, ZeroBr		{equalize band switch overhead}	,c2;
	BRANCH[overhead, $]						,c3;

	Noop								,c1;
startLine1:
	PCtl¬ StartScanCtl						,c2;
	rD0¬ uTabCnt							,c3;

idle:
	rD0¬ rD0-1, ZeroBr			{tab in to active area}	,c1;
	BRANCH[$, startActive], ClrDPRq					,c2;
	Noop, GOTO[idle]						,c3;

startActive:
	PCtl¬ StartActiveCtl		{stop forcing video JYW  }	,c3;

scan:
	MAR¬ [displayBase1, rD1+0], ClrDPRq				,c1;
	MDR¬ rD0{= zero}, rD1¬ rD1+1, PgCarryBr				,c2;
	POData¬ MD, BRANCH[scan, endLine]				,c3;

endLine:
	rD1¬ uLineCount, ClrDPRq		{play out last word}	,c1;
	rD1¬ rD1-1, ZeroBr						,c2;
	uLineCount¬ rD1, BRANCH[startLine, endBand]			,c3;

endBand:
	Noop								,c1;
	PCtl¬ EndBandScanCtl						,c2;
	rD0¬ uBandStatus						,c3;

	MAR¬ [displayBase0, rD0+0]		{mark band empty}	,c1;
	MDR¬ rD1				{... and get next band}	,c2;
	rD1¬ MD					{negative=> last band}	,c3;

	rD0¬ uWP							,c1;
	rD0¬ uInterruptMask or rD0, MesaIntRq				,c2;
	uWP¬ rD0		{initiate band complete interrupt}	,c3;

	Noop								,c1;
	Noop								,c2;
endBand1:
	[]¬ rD1, NegBr				{neg => last band done}	,c3;
	PCtl¬ EndActiveScanCtl, BRANCH[nextBand, nextPage]		,c1;

RavenOverrun:
	rD1¬ uBandStatus						,c3;

	rD1¬ rD1-2							,c1;
	uThis ¬ rD1				{back up pointer}	,c2;
	rD0¬ uIOPage							,c3;

	MAR¬ [displayBase0, rD0 + RavenOverrunOffset]	{set overrun}	,c1;
	rD1¬ MDR ¬ 1, CancelPgCross[endBand1, 0], LOOPHOLE[wok]		,c2;


{Memory Refresh Task}

SetTask[3];
StartAddress[RefreshGo];

	Set[HalfFieldSize, 0E0];

RefreshGo:
	uClockBits ¬ 0, CancelDisp[$]					,c1;
	displayBase2 ¬ IOPageHigh					,c2;
RefreshField:
	rD2 ¬ uIOPage							,c3;

	MAR ¬ [displayBase2, rD2 + WakeupMaskOffset]			,c1;
	Noop, CancelPgCross[$, 0]					,c2;
	rD2 ¬ MD							,c3;

	uPWakeup ¬ rD2							,c1;
	Noop								,c2;
	Noop								,c3;

{This code looks this way because uWP must be updated within one click.}
	rD2 ¬ uWP							,c1;
	rD2 ¬ uPWakeup or rD2, MesaIntRq				,c2;
	uWP ¬ rD2							,c3;

	rD2 ¬ LShift1 HalfFieldSize					,c1;
	uRefreshLine ¬ rD2						,c2;
	ClrRefRq							,c3;

Refresh:
	rD2 ¬ uClockLow, Refresh					,c1;
	rD2 ¬ rD2 + 1, CarryBr						,c2;
	uRefreshTemp ¬ rD2, BRANCH[$, RefreshCarry]			,c3;

	Refresh								,c1;
	Noop								,c2;
Refresh1:
	uClockLow ¬ rD2							,c3;

	rD2 ¬ uRefreshLine, ZeroBr					,c1;
	rD2 ¬ rD2 - 1, BRANCH[$, RefreshField]				,c2;
	uRefreshLine ¬ rD2, ClrRefRq, GOTO[Refresh]			,c3;

RefreshCarry:
	rD2 ¬ uClockHigh, Refresh					,c1;
	rD2 ¬ rD2 + 1							,c2;
	Noop								,c3;

	uClockHigh ¬ rD2						,c1;
	rD2 ¬ uRefreshTemp, GOTO[Refresh1]				,c2;