.Page
;++
;
;		Read
;
; Read will read a sector from Drive/Side/Track/Sector, doing offtrack
; stepping if neccessary to find the data.  It will also verify the
; checksum found if commanded to do so.
;
; REGISTERS
;  IN
;	All =	Any value
;  OUT
;	All =	Destroyed
;
; CALLS
;	Seek	Seeks to Drive/Track/Side
;	RdAdr	Read address header field
;	Read16	Reads data and checksum
;	VfyCkSum	Verifies checksum that was read
;	BadAddr	Handles all errors during read
;++

ReadBf	.Equ *				; Read w/o checksum verify entry point
	Lda	#0FF
	Bne	Read01

Read	.Equ *
	Lda	#00
Read01	Sta	RwCsmFlg			; Save in global flag
	Jsr	Seek			; Seek to track, zero error cnts, init retry
Read1	Jsr	RdAdr			; Find Sector
	Bcs	Read3			; Error, go and check it
	Jsr	Read16			; Read the sector
	Bcs	Read3
	Ldx	RwCsmFlg			; Fetch the checksum flag
	Bne	Read4			; If <> 0 then ignore checksum verify
	Jsr	VfyCkSum			; Verify the checksum
	Bcc	Read4			; If carry clear, then all is fine
	Inc	CSError			; Increment the checksum error counter

Read3	Jsr	BadAddr			; Find out what went wrong ( ccC = 1)
	Bcc	Read1			; Try once more
	Lda	#SErrRd			; No goog, signal read error
Read4	Rts
.Page
;++
;		BadAddr
;--
;
; REGISTERS
;  IN
;	All =	Any value
;  OUT
;	All =	Destroyed
;	Carry =	Retry status (=Clear, don't retry; =Set, please retry)
;
; CALLS
;	Recalbrt	Recalibrate the drive
;	SeekAlt	Seek to Track/Side
;--
.Page
BadAddr	.Equ *				; Entry point of BadAddr (ccC =1)
	Dec	RetryCnt			; If we've tried enough times to find data
	Beq	BadAddr2
	Clc
	Lda	RaStrt			; Or we can't find start bitslip
	Adc	RaTrk			; Or we're on the wrong trk
	Beq	BadGood			; Try again
	Cmp	RecalCnt			; if >= recalibration count then abort
	Beq	BadBad			; ccC = 1 when A = memory
	Cmp	RtyFlg			; See if new RaStrt or RaTrk error
	Beq	BadGood			; If equal then no change from last time
	Sta	RtyFlg			; a change -- save new error count
	Bne	BadAddr4			; Recalibrate head location
BadAddrd2	Dec	RecalCnt
	Beq	BadBad			; abort upon timeout (ccC still = 1)

BadAddr4	Jsr	Recalbrt			; But don't bother with spd errors at this time
	Jsr	SeekAlt			; And get back to where we were on target track
	Lda	MaxRetry			; Pick up fresh maximum number of retrys count
	Sta	RetryCnt			; and refresh the counter
BadGood	Clc				; We're trying again mate!
BadBad	Rts

.Page
;++
;
;			RESTART
;
; Restart is the entry point after a reest to the 6504.  This is also reffered
; to as a cold start.  It will first wait for memory to be valid, then it will
; setup the stack, reset the drives, clear all of the used RAM, transfer all
; "soft" parameters from the ROM to the RAM, initialize all timing constants,
; Check for Disk In Place and clamp any disks that are there, raise the DISK
; DIAG line and then finally look for a command.
;
;--
;
; REGISTERS
;  In
;	Random values assumed
;  Out
;	All Destroyed
;++
.Page
;++

Restart	.Equ *				; Main entry point for the 6504 from reset

;	Clear decimal mode;
;	Disable interrupts to the 6504;
;	Switch off interrupt to the 68K;
;	Set stack pointer to 0B0;
;	Enable MEMPOY for 68K

	Cld				; Clear decimal mode
	Sei				; Mask off interrupts
					; Following 3 steps needed only for warm restart
DnWhWt	Sta	BootL			; Tell host I'm not ready yet
	Sta	FDirL			; Set FDir Low, no interrupt yet to the 68K
	Sta	DisL			; Enable 68K to read memory
	Ldx	#StackSt
	Txs				; Set stack to grow down from 01CF
	Jsr	HardInit			; Initialize hardware -- PWM, IWM, Latches
	Jsr	RomTest			; Will never return if error is found
	Jsr	RamTest			; currently an Rts
	Lda	#00
	Jsr	Wait			; Wait for Sony to power up -- about 1.25 second

;	For x:=#LstUsed DOWNTO 000 DO			Reset variable memory for 6504
;	   Mmemory,x := 000;			This resets all counters to 000

	Ldx	#LstUsed			; Length of variable area
	Lda	#00			; something to clear with
Restart1	Sta	GoByte,x			; Init to 0
	Dex
	Bne	Restart1
	Sta	GoByte			; and do the last/first byte

;	For x:=sharesz down to 0 do			Initialize shared variables
;	   ShareRam,x := ShareRom,x;

	Ldx	#SharesZ			; Length of shared variable space
Restart2	Lda	ShareRom,X		; Move Bytes from Rom
	Sta	ShareRam,X		; and into RAM
	Dex				; Next Byte
	Bpl	Restart2			; Done yet?

	Ldx	#4			; move 5 bytes, zero based
Xfer1	Lda	SavAdr,x
	Sta	AdrMk1,x			; initialize Address mark table
	Lda	SavDat,x
	Sta	DatMk1,x			; initialize Data mark table
	Dex
	Bpl	Xfer1

	Dec	KOff
	Ldx	#CmdLength
	Stx	CmdX			; Index for command saving
	Ldx	#SavIndex
	Stx	SaveL

	Lda	MaxDDly
	Sta	WtHih
	Bne	Loop1			; Must see if a disk is inserted

;	*** NOTE *** Loop must be the very next routine
.Page

;++
;
;			LOOP
;
; This is the main 'idle' loop where the 6504 spends most of its time when not
; doing anything useful.  The main functions of the 'LOOP' is to shut off the
; motors after they have been used, sample the DIP and BUTTON when needed,
; and look for commands from the 68K.
;
; REGISTERS
;  In
;	A =	Any value
;	X =	Any value
;	Y =	Any value
;  Out
;	Loop never exits, only calls other procedures
;
; CALLS
;	GetDIP	Get the DIP status
;	Trnrk	Park the heads and turn off the motors
;	Cmd	Interprets, syntax checks, and dispatches all commands
;
;++
.Page

;++
;	Decrement 3 byte counter.  When all 3 bytes = 0 then turn motors off
;	( even if they are already off ), & look for disk in place
;--

Loop	.Equ *			; Start of main loop
	Inc	ImAlive
	Dec	WtLow		; Decremnent low byte of motor off wait
	Bne	Loop2
	Dec	WtMid		; Decrement Middle byte
	Bne	Loop2
Loop1	.Equ *			; Entry point for immediate check of DIP
	Jsr	GetDIP		; Time to make some noise and get some status
	Dec	WtHih		; Decrement high byte
	Bne	Loop2
	Jsr	TrMtOff		; turn off motor and reset motor on flag to zero
	Lda	MaxDDly
	Sta	WithHih

Loop2	Lda	Iob+GoByte
	Bpl	Loop
	Jsr	Cmd		; Try to execute the command
	Jmp	Loop		; Go back to the loop ands spin some more

.Page
;++
;		ROMTest
;--

RomTest	.Equ *			; Entry point to test checksum of Eprom
	Rts
	Lda	#0
	Tay
	Sta	RangeL
	Sta	RangeH
	Sta	InxPtrL
	Lda	#10
	Sta	InxPtrH
	Tax
$21	Clc
	Iny			; y = +1
	Lda	RangeL
	Adc	@InxPtr,y		; This should be (InxPtr),y   ARS 12 JAN 89
	Sta	RangeL
	Dey			; y = +0
	Lda	RangeH
	Adc	@InxPtr,y
	Sta	RangeH
	Clc
	Bpl	$43
	Sec
$43	Rol	RangeH
	Rol	RangeH
	Iny
	Iny			; Y = +2
	Bne	$21
	Lda	RangeL
	Bne	RomErr
	Lda	RangeH
	Beq	RamTest
RomErr	Sta	Iob+DrvError
	Sta	DisL		; Enable 68K to read memory
	Sta	BootH		; And reset flag line also
	Jmp	ProgErr1		; Bad Eprom -- tell host & loop forever

RamTest	.Equ *			; Test for bar Ram
	Rts

;++
;
;			GetDIP
;
; REGISTERS
;
;	All are destroyed
;
; CALLS
;	UpdInt	Updates interrupt status and raises FDir if needed
;	ReadDIP	Read DIP status
;	EnblTest	Test IMsk	against x-reg if drive is enabled
; Note:
;	Should code ever get modified for a two drive system, this should
; be re-written to alow commands to be received during the one second wait
;++
.Page

GetDIP	.Equ *				; Entry point for GetDIP
	Lda	DrvConn
	Bne	$40			; if <> 0 then drive is connected
	Jsr	ChkDrv			; check for drive connected & number of sides
	Bcs	GetDip5			; Exit if still no drive connected
$40	Sta	BootL			; Set flag to tell host I'm busy
	Jsr	ReadDIP			; Read the status of the DIP into carry
	Bcs	GetDIP4			; ccC = 1 ==> no DIP -- clear Clamped Disk Flag
	Lda	Clamped			; Already a clamped disk?
	Bne	GetDIP5			; No, need to clamp if not already clamped

	Lda	#OneSec			; One second wait constant
	Jsr	Wait			; Wait for Sony drive to return to it's senses
	Jsr	ReCalMtr			; Turn on motor & make sure head is at track 0
	Dec	Clamped			; Set clamped falg to 'FF'

	Jsr	EnablTest			; If drive enabled then tell host disk inserted
	Bcc	GetDIP5			; If carry set then disk enabled

	Lda	#010			; use drive 80
GetDIP2	Ora	Ist			; Combine with current Ist
	Sta	Ist
	Bne	GetDIP5

GetDIP3	.Equ *

GetDip4	Lda	#00
	Sta	Clamped			; Tell me no disk is clamped

GetDIP5	.Equ *				; Fall through and test for button pressed
	Sta	BootH			; Clear busy flag to host
					; Fall thru & update interrupt to host ( maybe )

.Page

UpdInt	.Equ *				; Entry point for UpdInt

; Ist.7 := Ist.6 or Ist.5 or Ist.4;

	Lda	Ist
	And	#070
	Beq	UpdInt2			; Skip if none is on
	Ora	#080			; Set bit 7 if any bit is on
	Sta	Ist			; And put back into Ist

; if (Ist.7 and Imsk.7) then
;    FDir := High
; Else
;    FDir := Low
; Return from UpdInt

UpdInt2	And	Imsk			; Now test against the mask
	Sta	OkToGo			; Remember if an interrupt is pending
	Beq	UpdInt3			; Skip if no interrupt is pending
	Sta	FDirH			; Raise interrupt
	Rts
UpdInt3	Sta	FDirL			; Clear interrupt
	Rts

.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