.Page
;++
;
;		WaitRom
;
; WaitRom switches off both motors and then waits until the 68000 diagnostics
; sets location 000 (68K = 000C00) first to #069 and then to #096.  The 6504
; will then do a cold start of the system
;
;--
;
; REGISTERS
;  IN
;	A =	Any value
;	X =	Any value
;	Y =	Any value
;  OUT
;	Returns via a cold start
;
;++

WaitRom	.Equ *				; Entry point for WaitRom
	Jsr	PrkClr0			; Park heads, turn motors off & clear GoByte

; Loop until 69/96 sequence occurrs

WaitRom1	Lda	000			; Wait for #069
	Cmp	#069
	Bne	WaitRom1

WaitRom2	Cmp	000			; Wait for #096
	Beq	WaitRom2

	Sec
	Adc	000			; Will be 0 if = 96
	Bne	Wait
	Rom1
	Jmp	DnWhWt			; Reset the world w/o memory wait

.Page
;++
;
;	CreCksum -- Create checksum using 524 byte i/o buffer
;
;	Algorithm:
;		A sector is composed of 524 user adata bytes and a 3 byte
;	checksum.  These are translated into 6 bit nibbles which are used to
;	Look up GCR codewords to be written to the disk.  The data is encode
;	as follows:  CSUMA, CSUMB, & CSUMC are "registers" used fo accumulating
;	the checksum.  ByteA, ByteB, & ByteC contain 3 bytes from the data buffer
;
;	1.	Rotate CSUMC left
;		CSUMC[65432107] <- CSUMC[76543210]
;		Carry <- CSUM[7]
;	2.	CSUMA <- CSUMA + ByteA + Carry from step 1
;	3.	ByteA <- ByteA Xor CSUMC
;	4.	CSUMC <- CSUMC + ByteB + Carry from step 2
;	5.	ByteB <- ByteB Xor CSUMA
;	6.	CSUMB <- CSUMB + ByteC + carry from Step 3
;	7.	ByteC <- ByteC Xor CSUC
;
;	Propagation of carry among three checksum bytes:
;
;         ------------------------
;	           v                   v	Note:  Carry out of CsumC is from rotate
;	^--CSUMC <-- CSUMB <-- CSUMA <--
;
; REGISTERS
;  IN
;	All =	Any valye
;  OUT
;	All =	Destroyed
;
;--
.Page

CreCksum	.Equ *				; Entry point for all callers
	Lda	#00
	Sta	Cksum1
	Sta	Cksum2			; Zero only two bytes
	Sta	InxptrL			; Init pointer for 5 cycle index fetch
	Sta	InxptrH
	Inc	InxPtrH			; Start on page 1
	Ldy	#0F4			; Last twelve bytes in page 1

CrTop	.Equ *				; Initially 'A' = 0
	Asl	A			; Move high bit to carry
	Php				; Save status bits on stack
	Adc	#00			; Move carry bit to low bit (8 bit rotate)
	Sta	Cksum3
	Plp				; Restore Status bits
	Lda	@InxPtrL,y		; First of three bytes in loop
	Tax
	Eor	Cksum3			; combine checksum w/ data
	Sta	@InxPtrL,y			; Data ==> buffer
	Txa
	Adc	CkSum1			; Add with above carry
	Sta	Cksum1
	Iny
	Bne	$20			; end of page two data
	Inc	InxPtr			; point to page three

$20	Lda	@InxPtrL,y			; Second of three bytes
	Tax
	Adc	Cksum2			; Add to second checksum byte
	Sta	Cksum2
	Txa
	Eor	Cksum1			; Combine checksum / data
	Sta	@InxPtrL			; Data ==> buffer
	Iny
	Beq	$60			; End of page three data

	Lda	@InxPtrL,y		; Third of three bytes
	Tax				; Save data value
	Eor	Cksum2			; Combine checksum w/ data value
	Sta	@InxPtrL,y		; Data ==> buffer
	Txa				; Restore data value
	Adc	Cksum3			; Add to third checksunm byte leave in A
	Iny
	Bne	CrTop			; Not at page boundary, loop
	Inc	InxPtrH			; start w/ page 2 data
	Bne	CrTop			; branch always taken

$60	Rts				; End of creating a checksum

.Page
;++
;			Format
;
;--
; REGISTERS
;  IN
;	All =	Any value
;  OUT
;	All =	Destroyed
;
; CALLS
;	ClrBuf	Clears 524 byte buffer and other variables
;	SelSide	Selects side
;	Recall	Recalibrates disk to optical index sensor
;	WriTrk	Write no. of sectors in TempSec
;	VerTrk	Verifies no. of sectors in TempSec
;	SeekAlt	Seeks the teack in IIob+Track and sets speed
;	WrSynTrk	Writes bitslip FF's and A9's then sector 0
;	WArd16	Write sector x, both header and data fields
;	RdAdr	Reads sector header
;	Read16	Reads data fields
;	VfyCksum	Verifies checksum that was read
;	PreNib	Prenibblizes certain bytes for timing purposes
;
;++
.Page
Format	.Equ *				; Format entry point
FormTrk	.Equ *
	Jsr	ClrBuf			; Clear the buffer to be written
	Lda	#7
	Sta	FmtGap
	Jsr	RecalMtr			; Turn on motor & start from a known point (Track 0 )
	Bcs	FormRts			; Abort upon error from Recal

FormTop	Jsr	SeekAlt			; Go to othe track in IIob+Track & set speed
	Ldy	CurClass
	Lda	SecPrtTrk,y		; Fetch number of sectors in current track
	Sta	TempSec			; Save it for WriTrk

	Jsr	WriTrk			; Write a track full of sectors

	Lda	IIob+Command		; If a format track
	Cmp	#FrmTrk			; Then we're done-exit the routine
	Beq	VT00			; Command = FormatTrack (5)

	Lda	Iob+NoSides		; 1 = single side, 2 = double side
	Cmp	#2
	Bne	$39			; if <> 2 then go to incr to next track
	Lda	#20
	Sta	IIob+Side
	Jsr	WriTrk			; Now write second side
	Lda	#00
	Sta	IIob+Side			; Restore to side 0

$39	Inc	IIob+Track
	Lda	IIob+Track
	Cmp	#MaxTrack+1
	Bcc	FormTop			; Until we run out of tracks
	Dec	IIob+Track
	Bne	VT00			; Skip tunring the motor on

Verify	.Equ *				; Verify entry point
	Lda	#MaxTrack
	Sta	IIob+Track		; From inside of disk to outer edge
VerTrk	.Equ *
	Jsr	RecalMtr			; Turn on motor & start from a know point ( track 0 )
	Bcs	FormRts			; Abort upon error from Recal

VT00	.Equ *
	Jsr	SeekAlt			; Go to track in IIob+Track & set speed
	Ldy	CurClass
	Lda	SecPrTrk,y		; Fetch the number of sectors in current track
	Sta	TempSec			; Save it for WriTrk routine

	Jsr	VerTrk
	Bcs	FormErr			; Error, exit from routine

	Lda	IIob+Command		; If a verify track
	Cmp	#FrmtTrk			; Then we're done-exit the routine
	Bcs	$41			; Command = FormatTrack (5) or VerifyTrack (6)

	Lda	Iob+NoSides		; 1 = Single side, 2 = double side
	Cmp	#2
	Bne	$39
	Lda	#20
	Sta	IIob+Side
	Jsr	VerTrk			; Now verify side 1, track x
	Bcs	FormErr			; Error, exit from routine
	Lda	#00
	Sta	IIob+Side

$39	Dec	IIob+Track
	Bpl	VT00

$41	Clc
	Rts

FormErr	Lda	IIob+Track		; Current track number
	Sta	Trkjl0dNumb		; Save for host's usage
	Lda	IIob+Side			; Current side
	And	#20			; leave bit 5 -- side bit
	Beq	$17
	Lda	#1
$17	Sta	SideNumb			; Save for host's usage
	Lda	#SErrFrmt			; Format error code
FormRts	Rts

TooSml	.Equ *
	.Byte	0., 5., 10., 15.		; Not used
	.Byte	20., 25., 30., 35.		; 4:7
	.Byte	40., 45., 50., 55.		; 8:11
	.Byte	60., 65., 70., 75.		; 12:15

JustRit	.Equ *
	.Byte	108., 99., 90., 81., 72.	; Sectors in class * 9 bytes per sector

;++
;  WriTrk will physically format a disk in a 2:1 interleave.  It will
; write sector 0, sector x, sector 1, sector y, etc.
;--
WriTrk	.Equ				; Entry for writing a track of 524 byte sectors
	Jsr	SelSide			; Select proper side
	Lda	TempSec			; Total number of sectors on current track
	Sta	TotCnt			; Init total number of sectors on current track
	Lsr	A			; Divide by 2 and put remainder into carry
	Adc	#0			; Round up by adding carry
	Sta	HihCnt			; Init counter for high sector values
	Lda	#00
	Sta	CntPtr			; Init pointer for which count to use
	Sta	LowCnt			; For counting up from Sector 0
	Sta	IIob+Sector		; Start w/ sector 0

	Jsr	WrSynTrk			; Write 20 usec nibbles and A9's before sector 0
	Dec	TotCnt			; Subtract 1 from total sector count
	Inc	LowCnt			; Increment value to next low sector (1)
$23	Ldx	CntPtr			; Pointer to which cnt to use -- low or high
	Beq	$35			; If = 0 then increment to 1
	Ldx	#0FF			; If = 1 then decrement to 0
$35	Inx
	Stx	CntPtr
	Lda	LowCnt,x			; Fetch sector number
	Sta	IIob+Sector
	Inc	LowCnt,x			; Increment to next sector number
	Jsr	WAdr16			; Write address and data fields
	Dec	TotCnt			; Decrement total sector count
	Bne	$23			; When = 0 then all sectors are written

	Lda	#00
	Sta	IIob+Sector
	Jsr	RdAdrTmt			; If =  then less than 256 bytes were counted
	Bne	IncrG1			; >256 bytes so increase inter-sector gap

	Ldy	FmtGap
	Lda	TooSml,y
	Cmp	RangeL
	Bcs	DecrG1			; a > normal cnt with current Gap amount

	Ldy	CurClass
	Adc	JustRit,y
	Cmp	RangeL
	Bcs	WrTkDone			; A > range so all OK

IncrG1	Lda	#14.
	Cmp	FmtGap			; Limit to 14. self-sync groups of five
	Beq	WrTkDone
	Inc	FmtGap			; incr count for next track

WrTkDone	.Equ *
	Rts

DecrG1	.Equ	*
	Lda	#4.
	Cmp	FmtGap
	Beq	WrTkDone			; Minimum gap is 4 counts of 5 20 usec bytes

;++
;
;--
VerTrk	.Equ *
	Jsr	SelSide			; Select proper side
	Lda	#00
	Sta	IIob+Sector
	Sta	ScTrCnt
VfyTrk1	Lda	MaxRetry
	Sta	RetryCnt

VfyTrk2	Jsr	RdAdr			; Read sector address field
	Bcs	VfyErr
	Jsr	Read16			; Read sector data
	Bcs	VfyErr
	Jsr	VfyCksum			; Verify the checksum
	Bcs	VfyErr			; Must Be zero
VfRtry	Inc	IIob+Sector
	Lda	IIob+Sector
	Cmp	TempSec
	Bne	VfyTrk1			; If equal then carry will be set
	Lda	SctrCnt
	Bne	$74
	Clc
$74	Rts

VfyErr	Dec	RetryCnt
	Bne	VfyTrk2
	Ldy	SctrCnt
	Lda	IIob+Sector		; Current Sector Number
	Sta	SctrSav,y			; Save for host usage
	Inc	SctrCnt
	Bne	VfrTry			; Go to next sector and try again

ClrBuf	.Equ *
	Lda	#00			; Clear the total buffer area
	Tay
$05	Sta	Page02,y			; Zero part of the data buffer
	Sta	Page03,y			; Zero the rest of the data buffer
	Iny
	Bne	$05
	Ldy	#Bufr12SZ			; For 12 bytes header buffer
$10	Sta	Bufr12,y
	Dey
	Bpl	$10
	Sta	Cksum1			; Clear the three checksum butes
	Sta	Cksum2
	Sta	Cksum3
	Jmp	PreNib			; Create 5 composite bytes & return to caller

.Page
;++
;			TrackClass will return the class (from 0 to 8) of
;		the track in IIOB+Track in the "Y" register
;
;		returns:		"Y" reg = class of track
;					"A" reg = IIOB+Track
;					"X" reg = unchanged
;--

TrkClss	.Equ *				; Entry point
	Lda	IIOB+Track		; Fetch current track value
	Ldy	#MaxClass		; Maximum class value
$21	Cmp	ClssTbl,Y		; Track >= Table entry?
	Bcs	$42			; Yep
	Dey
	Bne	$21			; Try the next track class
$42	Rts				; "Y" reg = track class value


ClssTbl	.Equ *				; Start of track class table
	.Byte 00			; Track  0:15
	.Byte 10			; Track 16:31
	.Byte 20			; Track 32:47
	.Byte 30			; Track 48:63
	.Byte 40			; Track 64:79

.ABSOLUTE
.PROC LISA
.LIST
.TITLE "Sony DRIVER FOR LISA"
.INCLUDE VAR
.ORG	1000
.INCLUDE TABLES
.INCLUDE TRKCLASS
.INCLUDE FR3TO1
.INCLUDE DENIBBLE
.INCLUDE NEWRWADDR
.INCLUDE Interface
.INCLUDE LOOP
.INCLUDE CLRTRK
.INCLUDE PRENIB
.INCLUDE CMD
.INCLUDE SEEK
.INCLUDE WAITROM
.INCLUDE NMREAD16
.INCLUDE READ
.INCLUDE CRECKSUM
.INCLUDE VFYCKSUM
.INCLUDE WRITE
.INCLUDE WRITE16
.INCLUDE FORMAT
.INCLUDE RECAL
.INCLUDE Npwm
.INCLUDE HIMEM
.End

.Page
;++
;--

TimIt	.Equ *
	Lda	#5				; Time 6 pulses
	Sta	Temp2
	Clc					; Should stay clear unless explicitly set
	Jsr	WtZero				; Look for low, then first high
	Bcs	RsOut				; 2,3	10	No edge within timeout period
	Jsr	RsEdge				; 8	8	Now at known locationo
	Bcs	RsOut				; 2,3	10	No edge within timeout period
	Lda	#0				; 2	12
	Sta	RangeL				; 3	15
	Sta	RangeH				; 3	18	Zero both bytes of counter

;++
;	WtZero & RsEdge both have 36 cycles (18.0 uSec) per tick of RangeL:H
;--

$20	Jsr	WtZero				; Look for low
	Bcs	RsOut				; 2,3
	Jsr	RsEdge				; Wait for next edge on pulse
	Bcs	RsOut				; 2,3
	Dec	Temp2				; 5		When less than zero then exit
	Bpl	$20				; 2,3	15*(2+@+%+#) = 180 cycles

RsOut	.Equ *
	Rts					; 6		Common exit point

WtZero	.Equ *
	Bit	K000				; 3		ccV set to Zero
	Bvc	RsEd				; 3	6

RsEdge	.Equ *					;		Look for a rising edge
	Bit	K0FF				; 3	3	ccV eq 0 == low, ccV eq 1 == high
	Bvs	ReEd				; 3	6
RsEd	.Equ *
	Ldy	#00				; 2	8
	Ldx	#0A0				; 2	10	Constant timeout for pulse counting

$10	Dey					; 2	2
	Bne	$20				; 2,3	4,5
	Dex					; 2	6
	Bne	$30				; 2,3	8,9
	Sec					; 2	10	When X-reg = 0 then return error
	Rts

$20	Nop					; 2	7
	Nop					; 2	9	Waste time

$30	Inc	RangeL				; 5	14
	Bne	$40				; 2,3	16,17
	Inc	RangeH				; 5	21
	Bne	$50				; 3	24	Always taken ??

$40	Pha					; 3	20	Waste more time
	Pla					; 4	24

$50	Lda	Q7L				; 4		Bit7=0 ==>tach low, else tach high
	Bvc	$70				; 2,3	30,31	ccV ==> look for low
	Bpl	$90				; 2,3	32,33	If high then fall thru & exit
	Nop					; 2	34
$60	Rts					; 6

$70	Bpl	$60				; 2,3	33,34	If low then exit

$90	Bcc	$10				; 3	36	Always taken?? -- 18.0 uSec loop

ChkLrg	.Equ *
	Lda	#Lrge				; 5
	Sta	Temp1				; For speed adjustment
	Lda	#WLow
	Beq	ChkComm

ChkSml	.Equ *
	Lda	#Smal				; 1
	Sta	Temp1
	Lda	#TLow

;++
;  ChkComm
;     if H < TL
;       then AdjPlus
;     else if H > TL
;       then TstHih
;     else  if L < Tl
;       then AdjPlus
;     else if L = TL
;       then OK
;  TstHih
;     If H > Th
;        then AdjMinus
;     else if H <> Th
;        then OK
;     else if L <= TH
;        then OK
;     else AdjMinus
;--

ChkComm	.Equ *
	Sta	InxPtrL			; Ptr to which constraints ( low of high )
	Lda	CurClass			; Current track class
	Asl	A			; *2 to address word array
	Tay
	Lda	RangeH
	Cmp	@InxPtrL,y		; High must be greater than or equal to lowtable,y
	Bcc	AdjPlus			; High byte low, must spin slower
	Bne	TsHih			; High byte greater -- must see if w/in high boundary
	Inc
	Lda	RangeL
	Cmp	@InxPtrL,y		; Must be greater than or equal to table,y
	Bcc	AdjPlus			; High bytes = and low byte low - slow it down
	Beq	ChkOK			; Both bytes are equal so within range
	Clc
TsHih	.Equ *				; ccC=1 if branched to here so add +1 for not 'Iny'
	Tya
	Adc	#TblJmp			; 9.
	Tay				; Index now points at high side of range
	Lda	@InxPtrL,y
	Cmp	RangeH			; High byte must be <= high boundary
	Bcc	AdjMinus			; High byte is too high, spin disk faster
	Bne	ChkOK			; If <> then low byte must be w/in range
	Iny				; Point @ low byte of boundary value
	Lda	@InxPtrL,y
	Cmp	RangeL			; Low byte is too high, spin disk faster

ChjkOK	.Equ *
	Clc
	Rts

AdjPlus	.Equ *				; ccC = 0 already
	Ldy	CurClass
	Lda	MSpdTbl,y
	Adc	TEmp1			; Add adjustment value
	Sta	MSpdTbl,y
	Sec
	Rts

AdjMinus	.Equ *
	Ldy	CurClass
	Lda	MSpdTbl,y
	Sec
	Sbc	Temp1
	Sta	MSpdTbl,y
	Sec
	Rts

SpdChk	.Equ *				; Main entry point for speed check
	Lda	#WHih			; '11'x
	Sta	InxPtrH
	Jsr	SetTach			; Make sure in Tach sense mode
	Jsr	TimIt			; Time 6 pulses & abort on timeout
	Bcs	SpdErr
	Jsr	ChkLrg			; Must be within +/- 2%
	Bcc	SpdDone
	Lda	#101.			; 100 times total for attempts to adjust
	Sta	Counter

$10	Dec	Counter
	Beq	SpdErr			; Try for 100 times and abort upon inability to adjust
	Jsr	SetSpeed
	Lda	ScDly
	Jsr	Wait
	Jsr	Timit
	Bcs	SpdErr
	Jsr	ChkLrg
	Bcs	$10			; Loop until speed within +/- 2%

$32	Sec				; Make sure error flag is set
	Dec	Counter
	Beq	SpdErr			; Try for 100 times and abort upon inability to adjust
	Jsr	ChkSml			; Now loop until within +/- .5%
	Bcc	SpdDone
	Jsr	SetSpeed
	Lda	ScDelay
	Jsr	Wait
	Jsr	TimIt
	Bcc	$32

SpdErr	.Equ*
	Lda	#SErrTmt

SpdDone	.Equ *
	Rts