
;*******************************************************
;
;	SCSI Driver Management Routines.
;
;	Written by Matt Gulick.		Started May 16,1988
;
;	Copyright Apple Computer, Inc. 1988,89
;
;*******************************************************

;*******************************************************
;
;	This file contains the subroutines needed by the
;	SCSI Driver for things such as Getting RAM, Building
;	data areas, calling outside routines for DIB
;	management, as well as other generic routines that
;	are used to make life easier for the driver.  Also
;	included in this file is the record definition for
;	the DIB structure including all it's extensions.
;
;*******************************************************

;*******************************************************
;
;	Revision History:
;
;*******************************************************

;	May 16, 1988	File started.
;	May 17,	1988	DIB Record defined.
;	June 6,	1988	Main Driver Written.
;	Jun 20,	1988	Update Input/Output Data in Comments
;	Apr	14,	1989	Added Conditional Logic to remove
;					block routines from character device
;					assemblies.

				STRING		PASCAL
				BLANKS		OFF
				PAGESIZE	70
				PRINT		NOGEN
				PRINT		NOMDIR
				MACHINE		M65816

				IMPORT		master_uid
				IMPORT		scsi_uid
				IMPORT		scsi_mgrnum
				IMPORT		rout2_s_disp
				IMPORT		hndl_offset
				IMPORT		buff_len
				IMPORT		page_cnt
				IMPORT		dpi_overide
				IMPORT		call_type
				IMPORT		main_drvr
				IMPORT		internal
;				IMPORT		disk_switch
				IMPORT		ram_page_cnt
				IMPORT		internal_buff
				IMPORT		default_dib
				IMPORT		first_time
				IMPORT		only_one
				IMPORT		part_cnt
				IMPORT		t_dvc_blocks
				IMPORT		f_partition
				IMPORT		part_num
				IMPORT		vPart_cnt
				IMPORT		rebuild
				IMPORT		trash_it
				IMPORT		direct_page
				IMPORT		exit_dpage
				IMPORT		gsos_dpage
				IMPORT		saved_zp
				IMPORT		valid
				IMPORT		dvc_ram
				IMPORT		sense_data
				IMPORT		dvc_count
				IMPORT		result
				IMPORT		divend
				IMPORT		divsor
				IMPORT		max_blk_cnt
				IMPORT		tot_dib_cnt
				IMPORT		dib_data_struct
				IMPORT		main_caller
				IMPORT		curr_hndl
				IMPORT		new_dib
				IMPORT		scratch0
				IMPORT		scratch1
				IMPORT		scratch2
				IMPORT		scratch3
				IMPORT		killer_blk
				IMPORT		auto_sense_data
				IMPORT		temp_acc
				IMPORT		pdi_flag
				IMPORT		new_list
				IMPORT		new_dib_cnt
				IMPORT		new_dib_list
				IMPORT		real_unit			;*************************

				IMPORT		m_blk_size
				IMPORT		m_blk_cnt
				IMPORT		m_rslt

				ENTRY		zero_mem
				ENTRY		get_space

				ENTRY		make_dib
				ENTRY		find_empty
				ENTRY		chk_ram

				ENTRY		rebld_dibs
				ENTRY		dibicise_new_ram
				ENTRY		dibicise_new_dib
				ENTRY		set_link_ptrs
				ENTRY		major_update
				ENTRY		minor_update

				ENTRY		fix_unit_1
				ENTRY		add_dib_ptr
				ENTRY		do_post_install

				ENTRY		read_pm_blk
				ENTRY		pm_blk_num
				ENTRY		chk_map
				ENTRY		no_partition
				ENTRY		check_map_entry

				ENTRY		c_strt_buffer
				ENTRY		c_strt_rqst_cnt
				ENTRY		c_strt_blk_num
				ENTRY		cache_valid
				ENTRY		put_in_cache
				ENTRY		get_from_cache

				ENTRY		test_unit_rdy
				ENTRY		read_capacity

				ENTRY		start_unit
				ENTRY		stop_unit
				ENTRY		set_512_mode

				ENTRY		notify_me

				ENTRY		set_disk_sw
				ENTRY		trash_volume
				ENTRY		save_dp
				ENTRY		restore_dp
				ENTRY		set_our_dp
				ENTRY		check_532_rw
				ENTRY		munge_532
				ENTRY		divide

				PRINT		OFF

				INCLUDE		'scsihd.equates'
				INCLUDE		'M16.MEMORY'
				INCLUDE		'M16.UTIL'
				INCLUDE		'M16.MISCTOOL'
				PRINT		ON

				EJECT
;____Mem_Manager_____
;*******************************************************
;
;	This routine is used to Get a User ID from the
;	memory manager for the SCSI Driver.  This is
;	required to get a userID for access reference.
;
;	Inputs:		None.
;
;	Outputs:	SCSID_uID	=	userID.
;				Registers	=	Scrambled
;
;	Errors:		$0207	iderr	Invalid userID.
;
;*******************************************************

			EXPORT	get_mm_id
get_mm_id	PROC
								;
								; Get userID.
								;
			pushword	#$0000

			pushword	#scsi_duid

			_GetNewID
			pla
			sta		|master_uid
			sta		|scsi_uid
@rts		rts
			
			ENDP

			EJECT

;*******************************************************
;
;	This routine is used to get the SCSI Manager Number
;	from the Supervisory Dispatcher at startup time.
;
;	Inputs:		None.
;
;	Outputs:	scsi_mgrnum		=	SCSI Manager Number
;				All Registers	=	scrambled
;
;	Errors:		None.
;
;*******************************************************

			EXPORT	get_scsimgr
get_scsimgr	PROC
								;
								; Get userID.
								;
			lda		#$0000		; Supervisor Driver Number (Unknown at this time)
			tax					; Supervisor Call Number ($0000)
			ldy		#$0002		; Spervisor ID for SCSI Manager ($0002)
			jsr		|rout2_s_disp
			stx		|scsi_mgrnum	; Preserve SCSI Driver Number for later use.
			rts
			
			ENDP

			EJECT

;*******************************************************
;
;	'zero_mem'
;
;	This routine will fill a section of memory with
;	$00s.
;
;	Inputs:		Acc			=	Buffer Size
;				X			=	Low Byte of new RAM Address
;				Y			=	High Byte of new RAM Address
;
;	Outputs:	scsi_zp0	=	Long Pointer to new RAM
;								Address
;				Acc			=	Scrambled
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	zero_mem
zero_mem		PROC
										;
										; Save the buffer size.
										;
				sta		@buff_size
										;
										; Setup MOVE_INFO call for a
										; non-incrementing source and an
										; incrementing destination.
										;
				pushlong	#null_buff	;Source
				phy						;Destination High Word
				phx						;Destination Low Word
										;
										; Restore buffer size.  If = 0 then
										; we are to do an entire bank or at
										; least 64k bytes.  This may cross
										; banks.
										;
				lda		@buff_size
				beq		@do_64k
				pea		$0000
				pha
				bra		@move_type

@do_64k			pea		$0001
				pea		$0000

@move_type		pea		#move_scon_dinc
				jsl		move_info

@rts			rts
										;
										; Data for this call
										;
@buff_size		dc.w	null
null_buff		dc.w	null

				ENDP

				EJECT

;*******************************************************
;
;	This routine is used to request a section of RAM from
;	the memory manager for use by the driver.  This
;	routine allocates space for as requested by the byte
;	count in the Acc.
;
;	Inputs:		Acc			=	Number of bytes requested.
;								0 = 1 bank
;
;				Y			=	Offset to where the Handle
;								should be stored within
;								the allocated structure.
;
;	Outputs:	X			=	Low Word of new RAM Address
;				Y			=	High Word of new RAM Address
;				scsi_zp0	=	Long Pointer to new RAM
;								Address
;				Acc			=	Scrambled
;
;	Errors:		Not enough memory if carry set.
;
;*******************************************************

				EXPORT	get_space
get_space		PROC
										;
										; Request Acc bytes of RAM from
										; Memory Manager.
										;
				sty		|hndl_offset

				pushlong #00000000		;Space for result handle

				cmp		$0000			;Is it Null?
				beq		@null			;Yes. Request 1 bank

				pushword #0000			;Size in bytes of requested memory.
				bra		@stuff_a

@null			pushword #0001			;Request 1 bank

@stuff_a		sta		|buff_len
				pha
			
				pushword scsi_uid		;Our User ID
			
										;Attributes of requested mem.
				pea		attrfixed++\
						attrnocross++\
						attrnospec++\
						attrpage

				pushlong #00000000		;Location Pointer.  Unused.

				_newhandle

				plx						; Get handle
				ply

				bcs		@rts			; Exit if an error.

										;
										; Save Handle for later
										;
				phy
				phx
										;
										; DEREF the Handle and get a
										; pointer for the new RAM.
										;
				stx		<scsi_zp0
				sty		<scsi_zp0+2
				ldy		#$0002
				lda		[scsi_zp0]
				tax
				lda		[scsi_zp0],y
				tay
										;
										; Stuff pointer for indirect access.
										;
				stx		<scsi_zp0
				sty		<scsi_zp0+2
										;
										; Call routine to zero out the
										; new memory
										;
				lda		|buff_len
				jsr		zero_mem
										;
										; Stuff Handle in RAM. Low byte first
										;
				ldy		|hndl_offset
				pullword [scsi_zp0],y
				iny
				iny
				pullword [scsi_zp0],y
										;
										; Restore X and Y to pointer status
										;
				ldx		<scsi_zp0
				ldy		<scsi_zp0+2
										;
										; Clean Exit.
										;
				clc
@rts			rts

				ENDP

				EJECT

;*******************************************************
;
;	This routine is used to request a section of RAM from
;	the memory manager for use by the driver.  This
;	routine allocates space for the get_devices call to
;	the SCSI Manager.
;
;	Inputs:		None.
;
;	Outputs:	dvc_list	=	Long Pointer to device List
;				next_dib	=	Long Pointer to First DIB
;				first_dib	=	Long Pointer to the beginning
;								of the RAM Allocated for the
;								new DIBs.
;				Acc			=	Scrambled
;
;	Errors:		Not enough memory if carry set.
;
;*******************************************************

				EXPORT	get_dvc_ram
get_dvc_ram		PROC
											;
											; Request the maximum device list
											; size bytes of RAM from GS/OS
											; System Service calls.
											;
				lda		#max_gdvc_buf+4		; Allocate space for list.
				ldy		#$0000

				ldx		|direct_page		;If this is the first time, then
				bne		@use_ours
				phx							;we don't want a DP setting of
											;NULL
											;
											; Save away GS/OS Direct Page values
											; until we have our own direct Page.
											;
				jsr		save_dp

				lda		#max_gdvc_buf+4		; Allocate space for list.
				ldy		#$0000

				ldx		|gsos_dpage
				stx		|direct_page

				jsr		|get_space

				pla							;Restore our settings preserving X & Y
				sta		|direct_page
				sta		|exit_dpage
				bra		@over_use_ours

@use_ours		jsr		|get_space
											;
											; Store newly allocated buffer
											; pointer into the parm list for
											; the get devices call.  Account
											; for the first 4 bytes that
											; contain the handle associated
											; with this memory segment.
											;
@over_use_ours	bcs		@rts_long
				clc
				txa
				sta		|dvc_ram
				adc		#$0004
				sta		|dvc_buff
				sta		<dvc_list
				tya
				sta		|dvc_ram+2
				adc		#$0000
				sta		|dvc_buff+2
				sta		<dvc_list+2
											;
											; Setup Pointer to our parm list
											; in GS/OS Direct Page.
											;
				ldx		|gsos_dpage
				lda		#get_dev_lst
				sta		>smgr_pl_ptr,x
				lda		#^get_dev_lst
				sta		>smgr_pl_ptr+2,x
											;
											; Load registers with their
											; required values.
											;
				lda		|scsi_mgrnum
				ldx		#cmd_get_dvc
				jsr		|rout2_s_disp
@rts_long		bcs		@rts
											;
											; Restore our direct page Device List
											;
				lda		|dvc_buff
				sta		<dvc_list
				lda		|dvc_buff+2
				sta		<dvc_list+2
											;
											; First word in [dvc_list}] contains
											; the address of a 1 page area that
											; we will be using for our direct
											; page.  Get it and move the
											; 'dvc_list' pointer to our direct
											; page area, but only if we have not
											; yet done it.
											;
				lda		|direct_page
				bne		@we_did_it			;It's already been done.

				lda		[dvc_list]
				tax
				lda		<dvc_list
				sta		>dvc_list,x
				lda		<dvc_list+2
				sta		>dvc_list+2,x
				txa
				sta		|direct_page
				sta		|exit_dpage
											;
											; Set our Direct Page with the first
											; 'x' Bytes equal to the GS/OS DP
											; settings.
											;
											;
				clc							; Calculate Source Address of GS/OS
				tdc							; Direct Page that we want.
				sta		|gsos_dpage			; Preserving GS/OS DP for later use.
				adc		#dev_num
				pea		$0000
				pha
											;
				clc							; Calculate Destination Address of
				lda		|direct_page		; our Direct Page that we want.
				adc		#dev_num
				pea		$0000
				pha
				
				pushlong	#dib_ptr+4		;Length of the move
				
				pushword	#move_sinc_dinc

				jsl		move_info			;Move the data
											;
											; Restore the Direct Page that we
											; borrowed until this was done.
											;
				jsr		restore_dp
											;
											; Set our Direct Page.
											;
				lda		|direct_page
				tcd
											;
											; Check for zero Devices.
											;
@we_did_it		ldy		#$0002
				lda		[dvc_list],y
				beq		@no_devices
											;
											; Ensure that device count is
											; in range.
											;
				cmp		#$0100+1			;No more than 256 devices
				blt		@count_ok
				lda		#max_dvc_cnt		;Max Count
@count_ok		sta		|dvc_count
				jsr		|make_dib
				stx		<next_dib
				stx		<first_dib
				sty		<next_dib+2
				sty		<first_dib+2

				lda		#no_error
				clc
											;
											; Restore the Direct Page that we
											; borrowed until this was done.
											;
@rts			pha
				php
				jsr		restore_dp
				plp
				pla
				rts
											;
											; No Devices Error.
											;
											; Restore the Direct Page that we
											; borrowed until this was done.
											;
@no_devices		jsr		restore_dp
				lda		#drvr_no_dev
				sec
				rts

get_dev_lst		dc.w	scsi_dtype
				dc.l	notify_me
dvc_buff		dc.l	null

				ENDP

				EJECT

;*******************************************************
;
;	This routine is the inverse of the above routine.
;	It calls the memory manager to deallocate the space
;	we used to request the device list from the SCSI
;	manager.
;
;	Inputs:		X			=	Low byte of Buffer pointer
;				Y			=	High byte of Buffer pointer
;
;	Outputs:	All Regs	=	Scrambled
;
;	Errors:		Not enough memory if carry set.
;
;*******************************************************

				EXPORT	fre_dvc_ram
fre_dvc_ram		PROC
										;
										; Remove the device list from
										; active use and free the mem.
										;
										; Stuff pointer for indirect access.
										;
				lda		|dvc_ram
				sta		<scsi_zp0
				lda		|dvc_ram+2
				sta		<scsi_zp0+2

				ldy		#$0002			;High byte first on stack
				pushword [scsi_zp0],y
				pushword [scsi_zp0]

				_disposehandle					

				rts

				ENDP

				EJECT

;____DIB_Mem_Mgr_____
;*******************************************************
;
;	This routine is used to request a section of RAM from
;	the memory manager for use by the driver.  This
;	routine allocates space for 1 DIB.
;
;	Inputs:		Acc			=	$00xx = DIB Count.
;								Null = $0100
;
;	Outputs:	X			=	Low Byte of new RAM Address
;				Y			=	High Byte of new RAM Address
;				scsi_zp0	=	Long Pointer to new RAM
;								Address
;				Acc			=	Scrambled
;
;	Errors:		Not enough memory if carry set.
;
;*******************************************************

				EXPORT	make_dib
make_dib		PROC
										;
										; Request $100 bytes of RAM for
										; each DIB from GS/OS System
										; Service calls.
										;
				and		#$00ff
				sta		|ram_page_cnt
				xba						;Cheap multiply by $0100
				ldy		#dib.handle		;Offset to where we want the handle
				jsr		|get_space		;Allocate space for DIBs.
				bcc		@rts
				stz		|ram_page_cnt
@rts			rts
			
				ENDP

				EJECT

;*******************************************************
;
;	This routine is called via a 'jsl' and returns the
;	page number of the caller in X and Y with X being
;	the low byte.  This is intended for use by the
;	completion routines in the DIB as a tool to find
;	the DIB's starting location in memory
;
;	Inputs:		None.
;
;	Outputs:	X			=	Low byte of callers page
;				Y			=	High byte of callers page
;				Acc			=	Scrambled
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	g_dib_ptr
g_dib_ptr		PROC
									;
									; Get the callers return
									; address from the stack,
									; strip down to a page number,
									; transfer to X and Y and
									; return to caller via an 'rtl'
									;
				lda		<1,s
				sec
				sbc		#dib.complet+3-dib.linkptr
				tax
				lda		<3,s
				and		#$00ff
				tay
				rtl

				ENDP

				EJECT

;*******************************************************
;
;	'ADD_DIB_RAM'
;
;	This routine searches for the last DIB for this
;	driver, allocates enough ram for 4 additional DIBs
;	and links them in.
;
;	Inputs:		dib_ptr			=	Last DIB in Device link
;				add_dib_here	=	Where the new DIB is to be built
;				Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Outputs:	Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Errors:		Carry set if not enough memory
;
;*******************************************************

				EXPORT	add_dib_ram
add_dib_ram		PROC
											;
											; 'ADD_DIB_HERE' Pointer now points
											; to the last DIB currently allocated
											; and preserve location of last DIB.
											;
				lda		<add_dib_here
				sta		<last_dib
				pha							;Save and later restore
				lda		<add_dib_here+2
				sta		<last_dib+2
				pha							;Save and later restore
											;
											; Get some RAM for a few more DIBs..
											;
				lda		#dibs_2_make
				jsr		make_dib
				bcc		@over_0
											;
											; Got an Error. Fix the Stack and Exit.
											;
				tax

				pla							;Saved, and now restore
				sta		<last_dib+2
				pla							;Saved, and now restore
				sta		<last_dib

				txa

				rts
											;
											; Do First link
											;
@over_0			sty		<first_dib+2
				stx		<first_dib
											;
											; Dibicise first new DIB in the new
											; Memory.
											;
				sec							;Don't do the links.
				jsr		dibicise_new_ram
											;
											; Do the Head and Forward links also.
											;
				lda		#null
				ldy		#dib.headlnk
				sta		[first_dib],y

				ldy		#dib.fdvclnk
				sta		[first_dib],y

				ldy		#dib.unitnum		;Don't forget the unit number
				sta		[first_dib],y
											;
											; Finalise the new DIB Structure.
											;
				dec		|main_caller
											;********
											;******** 6/12/89  Begin fix MSG
											;******** rebuild flag being destroyed.
											;********
				lda		|rebuild			;The state of this flag must be preserved.
				pha
				stz		|rebuild			;Set to zero.  (Full Rebuild)

				jsr		set_link_ptrs		;Now we do the links.

				pla
				sta		|rebuild			;Restore the callers state for this flag.

;				stz		|rebuild			;Set to zero.  (Full Rebuild)

;				jsr		set_link_ptrs		;Now we do the links.
											;********
											;******** 6/12/89  End fix MSG
											;******** rebuild flag being destroyed.
											;********
											;
											; Finish the last three links.  They
											; live in the new memory segment.
											;
				lda		#dibs_2_make-1
				sta		@loop_cnt

@link_loop		clc

				lda		<next_dib
				sta		<last_dib
				adc		#dib_size
				sta		<next_dib

				lda		<next_dib+2
				sta		<last_dib+2
				adc		#^dib_size
				sta		<next_dib+2

				dec		|main_caller
											;********
											;******** 6/12/89  Begin fix MSG
											;******** rebuild flag being destroyed.
											;********
				lda		|rebuild			;The state of this flag must be preserved.
				pha
				stz		|rebuild			;Set to zero.  (Full Rebuild)

				jsr		dibicise_new_dib

				pla
				sta		|rebuild			;Restore the callers state for this flag.

;				stz		|rebuild

;				jsr		dibicise_new_dib
											;********
											;******** 6/12/89  End fix MSG
											;******** rebuild flag being destroyed.
											;********
				dec		@loop_cnt
				bne		@link_loop
											;
											; Clean Exit
											;
											; Reinitialise mem_dib_cnt to zero.
											;
				lda		#null
				ldy		#dib.mem_dib_cnt
				sta		[first_dib],y
											;
											; Wipe out last link pointer to no where.
											;
				sta		[next_dib]
				ldy		#dib.linkptr+2
				sta		[next_dib],y

				pla							;Saved, and now restore
				sta		<last_dib+2
				pla							;Saved, and now restore
				sta		<last_dib

				clc
				rts
											;
											; Data Area.
											;
@loop_cnt		dc.w	null

				ENDP

				EJECT

;*******************************************************
;
;	FIND_EMPTY
;
;	This routine serches forward from the current DIB
;	looking for an empty.  If it exits with the carry
;	clear, then one has been found.  If the carry is
;	set, then it points to the last DIB in the linked
;	list and found non empty.
;
;	Inputs:		<DIB_PTR		=	Last DIB Location
;				Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Outputs:	<ADD_DIB_HERE	=	Empty DIB if found
;				Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Errors:		Carry set if no empties were found
;
;*******************************************************

				EXPORT	find_empty
find_empty		PROC
										;
										; Are we at the last DIB? Set beginning
										; pointer for check.
										;
				lda		<dib_ptr
				sta		<last_dib
				sta		<add_dib_here
				lda		<dib_ptr+2
				sta		<last_dib+2
				sta		<add_dib_here+2
										;
										; Are we at the last DIB? (LOOP)
										;
@fnd_empty_lup	ldy		#$0002
				lda		[add_dib_here]
				tax

				lda		[add_dib_here],y;Should never be in Bank $00
				bne		@advance_ptr	;No.

@sec			sec						;Yes. Exit
				rts
										;
										; Advance Ptr to next DIB.
										;
@advance_ptr	sta		<add_dib_here+2
				stx		<add_dib_here
										;
										; Is it Free?
										;
										; Must have a zero Head Link Ptr,
										; Forward Device Link Ptr, and
										; DIB Device Number to be considered
										; free.
										;
				ldy		#dib.devnum
				lda		[add_dib_here],y
				bne		@fnd_empty_lup	;No.  Check next one.

				ldy		#dib.headlnk
				lda		[add_dib_here],y
				bne		@fnd_empty_lup	;No.  Check next one.

				ldy		#dib.fdvclnk
				lda		[add_dib_here],y
				bne		@fnd_empty_lup	;No.  Check next one.
										;
										; Make the DIB Device Number non-zero
										; to prvent it from being selected
										; again before it is started up by
										; the operating system.
										;
				ldy		#dib.devnum
				lda		[add_dib_here],y
				inc		a
				sta		[add_dib_here],y

				clc						;Yes. Exit
				rts

				ENDP

				EJECT
			
;*******************************************************
;
;	'chk_ram'
;
;	This routine checks to see if we have any room left
;	in this memory segment for another DIB.  If not then
;	the memory manager is called and the new RAM is
;	dibicised.
;		
;	Inputs:		Acc			=	Unspecified
;				Carry		=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Carry		=	1
;					Acc		=	Error
;				Carry		=	0
;					Acc		=	ram_page_cnt
;							=	0	no more devices
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None.
;
;*******************************************************
										;
										; Start of the code segment for this.
										;
				EXPORT	chk_ram
chk_ram			PROC
										;
										; All done with the DIB Update now
										; do we have any more RAM left to
										; build further DIBs?
										;
				dec		|ram_page_cnt
				bne		@adv_ptrs		;Yes we do.  Continue on.

										;
										; Account for 'part_cnt' being equal
										; to the Actual Partition Count - 1
										;
				sec
;				clc						;Bug Fix 4/3/89

				lda		|dvc_count		;No we don't.  Get the remaining device
				adc		|part_cnt		;count and add the remaining Part count
;				dec		a				;Subtract our current working device
;				dec		a				;Subtract our current working DIB
				beq		@exit			;Are we done? Yes.
				bmi		@exit			;Yes.
				cmp		#$00ff+1		;No. Bound check the result and
				blt		@call_make_dib

@set_max		lda		#$00ff			;Set to max if greater.
@call_make_dib	jsr		make_dib		;Call routine to make the DIB RAM
				bcc		@update_new		;available.  ERROR?
				cmp		#drvr_no_dev	;Yes.  Then Exit
				bne		@sec
				clc
				rts
@sec			sec
				rts
										;
										; We had room in the current RAM
										; Space so we will advance all the
										; pointers to their next values
										; within that space.
										;
@adv_ptrs		clc
				lda		<next_dib
				sta		<last_dib
				adc		#dib_size
				sta		<next_dib
				lda		<next_dib+2
				sta		<last_dib+2
				adc		#^dib_size
				sta		<next_dib+2
				jsr		dibicise_new_dib
				bra		@exit
											;
											; We have a new memory segment so
											; we need to account for this when
											; we advance our pointers.
											;
@update_new		stx		<first_dib
				sty		<first_dib+2
				lda		<next_dib
				sta		<last_dib
				lda		<next_dib+2
				sta		<last_dib+2
				clc							;Do Links Also
				jsr		dibicise_new_ram
											;
											; Clean exit.
											;
@exit			lda		|ram_page_cnt
				clc
				rts

				ENDP

				EJECT

;____DIB_Building____
;*******************************************************
;
;	REBLD_DIBS
;
;	It is the function of this routine to blindly
;	rebuild the DIBs for the physical device attached to
;	the current DIB.  If that device is non-partitioned,
;	then only one DIB will be built, and a DISK SWITCHED
;	will be issued.  If there are more than one device,
;	as in partitioned media, then all the DIBs for the
;	partitions will be re-built.  This is treated as if
;	the device just came online for the first time.  If
;	the new device has fewer partitions than there are
;	DIBs that are already allocated, then the left over
;	will be marked as being offline.  If, on the other
;	hand, there are more partitions than DIBs, then new
;	ones will be allocated and built.  These will then be
;	permanantly linked to that physical device.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if operation could not be
;				completed.  Out of memory for example.
;
;*******************************************************
										;
										; Start of the code segment for this.
										;
				EXPORT	rebld_dibs
rebld_dibs		PROC
										;
										; Clear Linked Device Flag.  This will
										; account for the situation where a
										; partitioned disk has been reduced to
										; a single volume.
										;
				stz		@linked
										;
										; Zero the count of new devices to be
										; started.
										;
				stz		|new_dib_cnt
										;
										; Point to first DIB in link if any.
										; If it is zero, then we are already
										; there.
										;
				ldy		#dib.headptr+2
				lda		[dib_ptr],y
				ldy		#dib.headptr
				ora		[dib_ptr],y
				beq		@over
										;
										; It's non-zero.  Set up DIB_PTR
										;
				lda		[dib_ptr],y
				tax
				ldy		#dib.headptr+2
				lda		[dib_ptr],y
				sta		<dib_ptr+2
				stx		<dib_ptr
										;
										; Set Temp Pointer to first DIB in the link.
										;
@over			lda		<dib_ptr
				sta		<scsi_zp6
				lda		<dib_ptr+2
				sta		<scsi_zp6+2 
										;
										; Mark each DIB in the link as offline
										; and switched.
										;
@loop			ldy		#dib.dvcflag
				lda		[scsi_zp6],y
				and		#(dvc_online++\
						pdos_part)--\
						$ffff
				ora		#dvc_switch++\
						dvc_hardofl
				sta		[scsi_zp6],y
										;
										; Mark each DIB in the link as Unlinked.
										;
				ldy		#dib.dvcchar
				lda		[scsi_zp6],y
				and		#linked_dvc--\
						$ffff
				sta		[scsi_zp6],y
										;
										; Zero Partition Offset for each DIB
										;
				lda		#null
				ldy		#dib.start_blk
				sta		[scsi_zp6],y
				ldy		#dib.start_blk+2
				sta		[scsi_zp6],y
										;
										; It's non-zero.  Set up next DIB_PTR
										;
				clc
				ldy		#dib.fdvcptr
				lda		[scsi_zp6],y
				tax
				beq		@null

				sec

@null			ldy		#dib.fdvcptr+2
				lda		[scsi_zp6],y
				bne		@doit
				bcc		@over_0

@doit			sta		<scsi_zp6+2
				stx		<scsi_zp6

				bra		@loop
										;
										; Initialize a few values.
										;
@over_0			lda		#$ffff			;The following values will be incrimented
				sta		|first_time		;with zero indicating special action.
				sta		|rebuild		;This is set to $ffff so that it will only
				sta		|only_one		;occur on the first pass through.

				stz		|part_cnt
				stz		|pm_blk_num
				stz		|new_dib
										;
										; MAIN LOOP OF CODE SEGMENT.
										;
@main_loop		jsr		read_pm_blk
				bcc		@with_data		;This device is with data
				lda		auto_sense_data+\		;Is it an audio disk?
						rqst_sens.addnl_sens_code
				and		#$00fe			;Checking for $84, $64, or $63
				cmp		#$0064			;This cover $63, $64
				beq		@single
				cmp		#$0084
				beq		@single
				sec
				rts						;There was an error!
										;
										; Valid Partition Map?
										;
@with_data		jsr		chk_map
				bcs		@done
				bne		@main
										;
										; We have a vaild Partition Map so
										; we need to make an entry for each
										; partition other than those with
										; the partition types of 'MAP',
										; 'SCRATCH', and 'FREE'.  All others
										; will be considered valid.  We also
										; only accept up to 'max_partitions'
										; partitions per disk.
										;
										; How many partitions are there?
										;
				lda		|pm.MapBlkCnt\
						+internal_buff
				bne		@force_max
				lda		|pm.MapBlkCnt+2\
						+internal_buff
				xba						;Value is High --> Low
				cmp		#max_partitions+1
				blt		@cnt_ok
@force_max		lda		#max_partitions
@cnt_ok			sta		|part_cnt

				cmp		#$0002+1
				blt		@non_linked
				dec		@linked
@non_linked		dec		|part_cnt
				bpl		@main
										;
										; No valid entry.  Set as if no
										; partitions.
										;
				jsr		no_partition
				jsr		trash_volume	;Trash the volume if caller wishes.
										;See |trash_it flag in trash_volume
										;
										; Mark DIB as online and switched.
										;
@single			ldy		#dib.dvcflag
				lda		[dib_ptr],y
				and		#dvc_hardofl--\
						$ffff
				ora		#dvc_switch++\
						dvc_online
				sta		[dib_ptr],y

				lda		#null
				clc
				rts
										;
										; Check validity of partiton map.
										;
@main			jsr		check_map_entry
				bcc		@chk_pdos
										;
										; It was undefined or unusable
										;
										; Is the Pointer good?
										;
										; Is it a cold DIB?
										;
				ldy		#dib.dvcflag
				lda		[add_dib_here],y
				and		#cold_dib
				beq		@over_cold		;No.  Skip clear code.
										;
										; Mark DIB to the Default.
										;
				ldy		#dib.dvcflag
				lda		#wait_mode++\	; Wait Mode is default
						cold_dib		; and they start cold.
				sta		[add_dib_here],y
										;
										; Must set Head Link Ptr, Forward
										; Device Link Ptr, and DIB Device
										; Number to Null.
										;
				lda		#null

				ldy		#dib.devnum
				sta		[add_dib_here],y

				ldy		#dib.headlnk
				sta		[add_dib_here],y

				ldy		#dib.fdvclnk
				sta		[add_dib_here],y
										;
										; And skip it.
										; Is there more to do?
										;
@over_cold		dec		|part_cnt
				bmi		@do_dpi			;No!
				jmp		@main_loop		;Yes!
										;
										; Check to see if the post driver install
										; list contains any entries.
										;
@do_dpi			jsr		do_post_install		
										;
										; Check the only one flag.  If true
										; then unlink it.
										;
				lda		|only_one
				bne		@done

				ldy		#dib.dvcchar
				lda		[rebuild_zp],y
				and		#linked_dvc--\
						$ffff
				sta		[rebuild_zp],y
										;
										; Clean exit.
										;
@done			clc
@rts			rts
										;
										; Check the Overflow bit.  If it is set,
										; then this is a ProDOS Partition and we
										; need to set the correct bit in the DIB.
										;
@chk_pdos		bvc		@over_1
										;
										; Set the ProDOS Bit.
										;
				ldy		#dib.dvcflag
				lda		[dib_ptr],y
				ora		#pdos_part
				sta		[dib_ptr],y
										;
										; Issue call to fix unit 1.  This will
										; guarantee that the first unit is also
										; the first ProDOS Partition on the disk.
										;
				jsr		fix_unit_1
										;
										; Get the Block Count for this
										; Partition and store it in the
										; DIB.  The count as it exists
										; in the partition data is stored
										; High byte to Low byte.  We will
										; need to alter this to Low --> High
										; format.
										;
@over_1			ldy		#dib.blkcnt
				lda		|pm.PartBlkCnt+2\
						+internal_buff
				xba
				sta		[dib_ptr],y
				ldy		#dib.blkcnt+2
				lda		|pm.PartBlkCnt\
						+internal_buff
				xba
				sta		[dib_ptr],y
										;
										; Now we need to get the starting
										; location for this partition.  This
										; will be added to the requested
										; block to generate a real block
										; address.  Also in High --> Low format.
										;
				ldy		#dib.start_blk+2
				lda		|pm.PyPartStart+2\
						+internal_buff
				sta		[dib_ptr],y
				ldy		#dib.start_blk
				lda		|pm.PyPartStart\
						+internal_buff
				sta		[dib_ptr],y
										;
										; Get Location of this partition on disk.
										;
				ldy		#dib.part_blk
				lda		|pm_blk_num
				sta		[dib_ptr],y
										;
										; Mark DIB as online and switched.
										;
				ldy		#dib.dvcflag
				lda		[dib_ptr],y
				and		#dvc_hardofl--\
						$ffff
				ora		#dvc_switch++\
						dvc_online
				sta		[dib_ptr],y
										;
										; Mark DIB as Linked.
										;
				lda		@linked
				bpl		@skip_link
				ldy		#dib.dvcchar
				lda		[dib_ptr],y
				ora		#linked_dvc
				sta		[dib_ptr],y
										;
										; Inc the ONLY_ONE Flag.  If it is
										; null then save the dib_ptr.  On
										; exit we will check this flag and
										; if = 0 we will use this pointer
										; to clear the linked flag.
										;
				inc		|only_one
				bne		@skip_link

				lda		<dib_ptr
				sta		<rebuild_zp
				lda		<dib_ptr+2
				sta		<rebuild_zp+2
										;
										; Wipe out block 2 of partition or
										; volume
										;
@skip_link		jsr		trash_volume
										;
										; Is this a new dib?
										;
				bit		|new_dib
				bpl		@set_dsw		;No.  Set disk switch

				ldx		<dib_ptr
				ldy		<dib_ptr+2
				jsr		add_dib_ptr		;Yes. Add to the list for post driver
				bra		@over_dsw		; install.
										;
										; Set the DISK SWITCHED
										;
@set_dsw
;				jsr		set_disk_sw
										;
										; Is there more to do?
										;
@over_dsw		stz		|new_dib
				dec		|part_cnt
				bpl		@over_do_dpi	;Yes!
				jmp		@do_dpi			;No!
										;
										; All done with the DIB Update now
										; do we have any more DIBs, for this
										; linked device?
										;
@over_do_dpi	ldy		#dib.fdvcptr
				lda		[dib_ptr],y
				tax

				ldy		#dib.fdvcptr+2
				ora		[dib_ptr],y
				beq		@over_2
				lda		[dib_ptr],y

				sta		<dib_ptr+2
				stx		<dib_ptr
										;
										; Do the next one.
										;
@jmp_main		jmp		@main_loop
										;
										; It's zero.  Need to add DIBs
										;
										; Is there an empty DIB some where?
										;
@over_2			jsr		find_empty
				bcc		@found_empty
										;
										; Get room for some more DIBs.
										;
				jsr		add_dib_ram
				bcc		@over_2
				

				rts
										;
										; We need to set some pointers for
										; the routines that we will be
										; calling.  These pointers are similar
										; to those used in the startup code
										;
										; 1st.  Set the pointer to the next
										; DIB to be build.
										;
@found_empty	lda		<add_dib_here
				sta		<dib_ptr
				sta		<next_dib
				lda		<add_dib_here+2
				sta		<dib_ptr+2
				sta		<next_dib+2
										;
										; Preserve the Link Pointer.  Otherwise
										; it will be destroyed by the dibicise
										; routine.
										;
				ldy		#dib.linkptr+2
				lda		[next_dib]
				pha
				lda		[next_dib],y
				pha
										;
										; Set the 'first_dib' pointer to the
										; first dib in the same memory segment
										; from the memory manager as the one
										; that contains the space to be used
										; for this new dib.  first we get the
										; handle.
										;
				ldy		#dib.handle
				lda		[next_dib],y
				sta		<first_dib

				ldy		#dib.handle+2
				lda		[next_dib],y
				sta		<first_dib+2
										;
										; then we deref the handle.
										;
				ldy		#$0002
				lda		[first_dib]
				tax
				lda		[first_dib],y
				sta		<first_dib+2
				stx		<first_dib
										;
										; Tell the dibicize routine that this
										; is not from the startup code.  This
										; also forces the descriptive names
										; minor id to be changed leaving the
										; major or device portion as it is.
										;
				dec		|main_caller
										;
										; Dibicise the new dib.
										;
				jsr		dibicise_new_dib
										;
										; Restore the Link Pointer.  Otherwise
										; it is destroyed by the dibicise
										; routine.
										;
				ldy		#dib.linkptr+2
				pla
				sta		[next_dib],y
				pla
				sta		[next_dib]
										;
										; Rev the unit number to be unique
										;
				ldy		#dib.unitnum
				lda		[next_dib],y
				tax
				and		#max_p_mask
				cmp		#max_p_mask
				beq		@all_done

				txa
				clc
				adc		#p_mask_adder
				sta		[next_dib],y
										;
										; This flag indicates that this is a
										; new dib and that the routine that
										; finalizes this dib will have to
										; issue a post driver install call.
										;
				dec		|new_dib
										;
										; Go back to the main loop where this
										; dib will be finalized and installed.
										;
				jmp		@main_loop
										;
										; Clean Exit
										;
@all_done		clc
				rts
										;
										; Misc Data for this sub-routine
										;
@linked			dc.w		null
@part_num		dc.w		null
@vPart_cnt		dc.w		null

				ENDP

				EJECT
			
;*******************************************************
;
;	'do_part_dib'
;
;	This routine issues a READ call to the device and
;	then uses the data returned to check for any
;	partitions on the media.  If partitions do exist, it
;	then creates the needed dibs from those that have
;	been allocated but unused, or if needed will create
;	a new memory segment and continue on.
;		
;	Inputs:		<next_dib	=	Next DIB start		(LONG)
;				Acc			=	Unspecified
;				Carry		=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	<next_dib	=	last DIB Built		(LONG)
;				Acc			=	Unspecified
;				Carry		=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None.
;
;*******************************************************
										;
										; Start of the code segment for this.
										;
				EXPORT	do_part_dib
do_part_dib		PROC

;-------------------------------------------------------------------------------

				IF			part_suprt = true		THEN

										;
										; MAIN LOOP OF CODE SEGMENT.
										;
@main_loop		jsr		read_pm_blk
				bcc		@chk_map		;Was there an error?
				
				jsr		no_partition										;
				bra		@done
										; Valid Partition Map?
										;
@chk_map		jsr		chk_map
				bcs		@done
				bne		@main
										;
										; We have a vaild Partition Map so
										; we need to make an entry for each
										; partition other than those with
										; the partition types of 'MAP',
										; 'SCRATCH', and 'FREE'.  All others
										; will be considered valid.  We also
										; only accept up to 'max_partitions'
										; partitions per disk.
										;
										; How many partitions are there?
										;
				lda		|pm.MapBlkCnt\
						+internal_buff
				bne		@force_max
				lda		|pm.MapBlkCnt+2\
						+internal_buff
				xba						;Value is High --> Low
				cmp		#max_partitions+1
				blt		@cnt_ok
@force_max		lda		#max_partitions
@cnt_ok			sta		|part_cnt

				dec		|part_cnt
				bpl		@main
										;
										; No valid entry.  Set as if no
										; partitions.
										;
				jsr		no_partition
				clc
				rts
										;
										; Check validity of partiton map.
										;
@main			jsr		check_map_entry
				bcc		@chk_pdos
										;
										; It was undefined or unusable
										; Mark DIB to the Default.
										;
				ldy		#dib.dvcflag
				lda		#wait_mode++\	; Wait Mode is default
						cold_dib		; and they start cold.
				sta		[next_dib],y
										;
										; Must set Head Link Ptr, Forward
										; Device Link Ptr, and DIB Device
										; Number to Null.
										;
				lda		#null

				ldy		#dib.devnum
				sta		[next_dib],y

				ldy		#dib.headlnk
				sta		[next_dib],y

				ldy		#dib.fdvclnk
				sta		[next_dib],y
										;
										; And skip it.
										; Is there more to do?
										;
				dec		|part_cnt
				bpl		@main_loop
										;
										; Clean exit.
										;
@done			clc
@rts			rts
										;
										; Check the Overflow bit.  If it is set,
										; then this is a ProDOS Partition and we
										; need to set the correct bit in the DIB.
										;
@chk_pdos		bvc		@over
										;
										; Set the ProDOS Bit.
										;
				ldy		#dib.dvcflag
				lda		[next_dib],y
				ora		#pdos_part
				sta		[next_dib],y
										;
										; Issue call to fix unit 1.  This will
										; guarantee that the first unit is also
										; the first ProDOS Partition on the disk.
										;
				jsr		fix_unit_1
										;
										; Get the Block Count for this
										; Partition and store it in the
										; DIB.  The count as it exists
										; in the partition data is stored
										; High byte to Low byte.  We will
										; need to alter this to Low --> High
										; format.
										;
@over			ldy		#dib.blkcnt
				lda		|pm.PartBlkCnt+2\
						+internal_buff
				xba
				sta		[next_dib],y
				ldy		#dib.blkcnt+2
				lda		|pm.PartBlkCnt\
						+internal_buff
				xba
				sta		[next_dib],y
										;
										; Now we need to get the starting
										; location for this partition.  This
										; will be added to the requested
										; block to generate a real block
										; address.  Also in High --> Low format.
										;
				ldy		#dib.start_blk+2
				lda		|pm.PyPartStart+2\
						+internal_buff
				sta		[next_dib],y
				ldy		#dib.start_blk
				lda		|pm.PyPartStart\
						+internal_buff
				sta		[next_dib],y
										;
										; Get Location of this partition on disk.
										;
				ldy		#dib.part_blk
				lda		|pm_blk_num
				sta		[next_dib],y
										;
										; Set this device to ONLINE.
										;
				ldy		#dib.dvcflag
				lda		[next_dib],y
				ora		#dvc_online
				sta		[next_dib],y
										;
										; Increment the partition count.
										;										
				inc		|part_num
				beq		@chk_ram
										;
										; Update the High seven bits of the
										; unit number checking for the max
										; value of 'max_partitions'.
										;
				ldy		#dib.unitnum
				lda		[next_dib],y
				tax
				and		#max_p_mask
				cmp		#max_p_mask
				beq		@all_done
				txa
				clc
				adc		#p_mask_adder
				sta		[next_dib],y
				inc		|vPart_cnt
										;
										; All done with the DIB Update now
										; do we have any more DIBs, and if
										; so, do we have any more RAM left
										; to build further DIBs?
										;
@chk_ram		dec		|part_cnt		
				bmi		@all_done
				dec		|main_caller
				jsr		chk_ram
				bcs		@bad_call		;ERROR?
				jmp		@main_loop		;No. Do the next one.
@bad_call		cmp		#drvr_no_dev	;Yes.  Then Exit
				bne		@sec
				clc
				rts
@sec			sec
				rts
										;
										; Clean Exit
										;
@all_done		clc
				rts

				ELSE

;-------------------------------------------------------------------------------

										;
										; Clean Exit
										;
				lda		#null
				clc
				rts

				ENDIF

;-------------------------------------------------------------------------------

				ENDP

				EJECT
			
;*******************************************************
;
;	'dibicise_new_ram'
;
;	This routine takes the DIB located at [last_dib] and
;	copies it into the new ram space.  It does this
;	while preserving the handle at offset 'dib.handle'.
;	By so doing, it will be possible to free this ram
;	space at some later time if that is deemed correct.
;		
;	Inputs:		<last_dib		=	Last DIB built		(LONG)
;				<first_dib		=	Pointer to new		(LONG)
;									ram space.
;				Acc				=	Unspecified
;				Carry	Clear	=	Do Link Pointers
;						Set		=	Skip Link Pointers
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Outputs:	<last_dib		=	unchanged			(LONG)
;				<first_dib		=	unchanged			(LONG)
;				<next_dib		=	<first_dib			(LONG)
;				|curr_hndl		=	Handle for new ram	(LONG)
;
;				Acc				=	Unspecified
;				Carry			=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;		If Carry Set on entry then
;
;				|tot_dib_cnt	=	$0000				(WORD)
;
;		If Carry Clear on entry then
;
;				[last_dib]		=	points to this DIB	(LONG)
;				[first_dib]		=	defaults set		(PTR)
;				'Int Pntrs'		=	Set to this DIB		(LONG)s
;				'dispname'		=	Device Name			(STR)
;				|tot_dib_cnt	=	# of valid DIBs		(WORD)
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	dibicise_new_ram
dibicise_new_ram	PROC
											;
											; Save Do Links Flag.
											;
				php
											;
											; Preserve Handle for this
											; memory segment.
											;
				ldy		#dib.handle
				lda		[first_dib],y
				sta		|curr_hndl
				ldy		#dib.handle+2
				lda		[first_dib],y
				sta		|curr_hndl+2
											;
											; Using the built in move routine,
											; copy the last DIB built to the 
											; first_dib location for the next
											; dib to be built.
											;
				pushlong	<last_dib
				pushlong	<first_dib
				pushlong	#dib_size
				pushword	#move_sinc_dinc

				jsl		move_info			;Move the data
											;
											; Restore the handle to it's
											; origonal location.  This will
											; then be copied to every other
											; dib that is built in this
											; memory segment.
											;
				ldy		#dib.handle
				lda		|curr_hndl
				sta		[first_dib],y
				ldy		#dib.handle+2
				lda		|curr_hndl+2
				sta		[first_dib],y
											;
											; Set 'next_dib' pointer to the
											; first dib in this memory
											; segment.
											;
				lda		<first_dib
				sta		<next_dib
				lda		<first_dib+2
				sta		<next_dib+2

				ldy		#dib.dvcflag
				lda		[first_dib],y
				ora		#cold_dib			;New DIB.  Do Cold Start.
				sta		[first_dib],y
											;
											; Reinitialise mem_dib_cnt to zero.
											;
				lda		#null
				ldy		#dib.mem_dib_cnt
				sta		[first_dib],y
											;
											; Reinitialise DIB Dev Number also.
											;
				ldy		#dib.devnum
				sta		[first_dib],y
											;
											; Finalise the new DIB Structure?
											;
				plp
				bcc		set_link_ptrs
				rts

				ENDP

				EJECT
			
;*******************************************************
;
;	'dibicise_new_dib'
;
;	This routine takes the DIB located at [last_dib] and
;	copies it into the new ram space.
;		
;	Inputs:		<last_dib	=	Last DIB built		(LONG)
;				<next_dib	=	Next DIB start		(LONG)
;				Acc			=	Unspecified
;				Carry		=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	<last_dib	=	unchanged			(LONG)
;				<next_dib	=	unchanged			(LONG)
;				[last_dib]	=	points to this DIB	(LONG)
;				[next_dib]	=	defaults set		(PTR)
;				'Int Pntrs'	=	Set to this DIB		(LONG)s
;				'dispname'	=	Device Name			(STR)
;				|tot_dib_cnt=	# of valid DIBs		(WORD)
;				Acc			=	Unspecified
;				Carry		=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	dibicise_new_dib
dibicise_new_dib	PROC
											;
											; Using the built in move routine,
											; copy the last DIB built to the 
											; next_dib location for the next
											; dib to be built.
											;
				pushlong	<last_dib
				pushlong	<next_dib
				pushlong	#dib_size
				pushword	#move_sinc_dinc

				jsl		move_info			;Move the data

											;
											; Finalise the new DIB Structure.
											;
				EXPORT	set_link_ptrs
											;
											; Update Links and DIB ext ptrs
											;
set_link_ptrs	bit		|rebuild
				bmi		@rebuild_links

				clc							;we are going to add
				lda		<next_dib			;get low word of this dib
				sta		[last_dib]			;store in last dib (implied y = 0)

				adc		#dib.start_blk		;adc offset to ext dib ptr
				ldy		#dib.ext_ptr		;get offset to where this goes
				sta		[next_dib],y		;and store low word of ptr

				ldy		#dib.linkptr+2		;get offset to high word
				lda		<next_dib+2			;get the high word and
				sta		[last_dib],y		;store it in the last dib

				adc		#^dib.start_blk		;adc high offset to ext ptr
				ldy		#dib.ext_ptr+2		;get offset to where this goes
				sta		[next_dib],y		;and store the high word ptr
											;
											; Zero out the Link for this DIB
											;
				lda		#null
				ldy		#dib.linkptr
				sta		[next_dib],y
				ldy		#dib.linkptr+2
				sta		[next_dib],y
											;
											; Zero out the Starting Block for this DIB
											;
@rebuild_links	lda		#null
				ldy		#dib.start_blk
				sta		[next_dib],y
				ldy		#dib.start_blk+2
				sta		[next_dib],y
											;
											; Increment the number of active DIBs in
											; this memory segement.
											;
				ldy		#dib.mem_dib_cnt
				lda		[first_dib],y
				inc		a
				sta		[first_dib],y
											;
											; In the DIB Extension as defined for this
											; driver is the root structure of the
											; pointers that are used to call the SCSI
											; Manager.  At this time we need to update
											; them so that they too point into this
											; dib and not the last one.
											;
				clc
				lda		<next_dib			;Low word of Completion Pointer
				adc		#dib.complet
				ldy		#dib.compvec
				sta		[next_dib],y

				lda		<next_dib+2			;High word of Completion Pointer
				adc		#^dib.complet
				ldy		#dib.compvec+2
				sta		[next_dib],y

				clc
				lda		<next_dib			;Low word of Command Packet Pointer
				adc		#dib.scsicmd
				ldy		#dib.cp_ptr
				sta		[next_dib],y

				lda		<next_dib+2			;High word of Command Packet Pointer
				adc		#^dib.scsicmd
				ldy		#dib.cp_ptr+2
				sta		[next_dib],y

				clc
				lda		<next_dib			;Low word of Send Structure Pointer
				adc		#dib.trx_buff
				ldy		#dib.trx_ptr
				sta		[next_dib],y

				lda		<next_dib+2			;High word of Send Structure Pointer
				adc		#^dib.trx_buff
				ldy		#dib.trx_ptr+2
				sta		[next_dib],y
											;
											; Were we called from the
											; main outside loop?
											;
				lda		|main_caller
				bne		@skip_links			; No.  Do device links.
											;
											; Zero out the HEAD LINK and FORWARD LINK
											; pointers.
											;
				ldy		#dib.headlnk
				sta		[next_dib],y		;Acc = 0. See Load.
				ldy		#dib.fdvclnk
				sta		[next_dib],y
				ldy		#dib.headptr
				sta		[next_dib],y		;Acc = 0. See Load.
				ldy		#dib.fdvcptr
				sta		[next_dib],y
				ldy		#dib.headptr+2
				sta		[next_dib],y		;Acc = 0. See Load.
				ldy		#dib.fdvcptr+2
				sta		[next_dib],y
											;
											; Set slot and device words in dib
											;
				lda		[dvc_list]

				ldy		#dib.slotnum
				sta		[next_dib],y

				ldy		#$0002
				lda		[dvc_list],y

				ldy		#dib.unitnum
				sta		[next_dib],y
											;
											; Set pointer to the descriptive or
											; device name so that we can rev the
											; name to prevent duplicates.
											;
@skip_links		clc
				lda		<next_dib
				adc		#dib.namelen
				sta		<scsi_zp0
				lda		<next_dib+2
				adc		#^dib.namelen
				sta		<scsi_zp0+2
											;
											; Was internal or externally called?
											; If internal, then we need to update
											; the major revision part of the
											; descriptive name.  If it was external,
											; then we will update the minor revision
											; part only.
											;
				lda		|main_caller
				beq		@do_major
											;
											; Do the minor revision.
											;
				jsr		minor_update
				bra		@clear_busy
											;
											; Do the major revision.
											;
@do_major		jsr		major_update
											;
											; Clear artifacts.  We copied this data
											; from the first dib that has the
											; call_active bit set.  Clear the sucker.
											;
@clear_busy		ldy		#dib.dvcchar
				lda		[next_dib],y
				and		#call_active--\
						$ffff
				sta		[next_dib],y
											;
											; Clear the ProDOS Bit.
											;
				ldy		#dib.dvcflag
				lda		[next_dib],y
				and		#pdos_part--\
						$ffff
				sta		[next_dib],y
											;
											; Inc the DIB Count at this point.
											; Every DIB that is succesfully built
											; will be modified by the above code.
											;
				stz		|main_caller
				inc		|tot_dib_cnt
				clc
				rts

				ENDP

				EJECT

;*******************************************************
;
;	MAJOR_UPDATE
;
;	This routine updates the major revision portion of
;	the descriptive name portion of the DIB.
;
;	Inputs:		<DIB_PTR		=	DIB Location
;				Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Outputs:	Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Errors:		Better be none.
;
;*******************************************************

				EXPORT	major_update
major_update	PROC
									;
									; Change name so as not to conflict
									; with any other name already built.
									; All names end with '00' - '99'.
									;
				short

				ldx		#$02		;Don't change this value.
				sec
				lda		[scsi_zp0]
									;
									; Reset Minor Revision to '00'.
									;
				pha
				tay
				lda		#'0'
				sta		[scsi_zp0],y
				dey
				sta		[scsi_zp0],y
				pla

				sbc		#$03
				tay
@name_loop		lda		[scsi_zp0],y
				inc		a
				cmp		#'9'+1
				blt		@update
				lda		#'0'
				dex
@update			sta		[scsi_zp0],y
				dey
				dex
				beq		@name_loop

				longmx

				rts

				ENDP

				EJECT

;*******************************************************
;
;	MINOR_UPDATE
;
;	This routine updates the minor revision portion of
;	the descriptive name portion of the DIB.
;
;	Inputs:		<DIB_PTR		=	DIB Location
;				Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Outputs:	Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Errors:		Better be none.
;
;*******************************************************

				EXPORT	minor_update
minor_update	PROC
									;
									; Change name so as not to conflict
									; with any other name already built.
									; All names end with '00' - '99'.
									;
				short

				ldx		#$02		;Don't change this value.
				lda		[scsi_zp0]
									;
									; Check the length of the string.  If
									; it is different from the one in the
									; Default DIB, then we need to assume
									; that it has been renamed.  In this
									; case, we will crank the count up by
									; 2 but not past the max count of 31
									; and append the version number
									; change to that.
									;
				cmp		|default_dib+\
						dib.namelen
				beq		@len_ok
									;
									; Has it already been adjusted?
									;
				tay
				lda		[scsi_zp0],y
				cmp		#'0'
				blt		@fix_it
				cmp		#'9'+1
				bge		@fix_it
				dey
				lda		[scsi_zp0],y
				cmp		#'0'
				blt		@fix_it
				cmp		#'9'+1
				bge		@fix_it
				iny
				bra		@name_loop

@fix_it			lda		[scsi_zp0]
				inc		a
				inc		a
				cmp		#$31
				blt		@set_new_len

				lda		#$31
@set_new_len	sta		[scsi_zp0]

@len_ok			tay
@name_loop		lda		[scsi_zp0],y
				inc		a

				cmp		#'1'
				blt		@force_zero

				cmp		#'9'+1
				blt		@update

@force_zero		lda		#'0'
				dex
@update			sta		[scsi_zp0],y
				dey
				dex
				beq		@name_loop

				longmx

				rts

				ENDP

				EJECT

;____DIB_Support_____
;*******************************************************
;
;	This call is used to determine if the current DIB is
;	the first device.  This routine will return true
;	(with the carry clear) if the device is unlinked or,
;	if linked, then it will return true if this is the
;	head device.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if Unit is not the first
;				device or it's equivelent.
;
;*******************************************************

				EXPORT	chk_first_dvc
chk_first_dvc	PROC

;-------------------------------------------------------------------------------

				IF			part_suprt = true		THEN

									;
									; Check Linkes to see if single device.
									;
				ldy		#dib.headlnk
				lda		[dib_ptr],y
				bne		@check_devnum
									;
									; Head Link = 0.  Return True.
									;
@true			clc
				rts
									;
									; Check to see if the Device Number and
									; Head Links are the same.  If not then
									; we return false (carry set).
									;
@check_devnum	ldy		#dib.devnum
				cmp		[dib_ptr],y
				beq		@true
									;
									; Return False.
									;
				sec
				rts

				ELSE

;-------------------------------------------------------------------------------

				lda		#null
				clc
				rts

				ENDIF

;-------------------------------------------------------------------------------


				ENDP

				EJECT

;*******************************************************
;
;	This call checks to see if the other device tied to
;	it are offline.  If they are then the carry will be
;	clear on exit.  If this device is tied to any other
;	device that is currently online, then the carry will
;	be set on exit.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if Unit is not the only
;				device in this link that is still
;				online.
;
;*******************************************************

				EXPORT	chk_lnk_offline
chk_lnk_offline	PROC

;-------------------------------------------------------------------------------

				IF			part_suprt = true		THEN

									;
									; Get the Head Pointer. Check for null.
									;
				clc
				ldy		#dib.headptr
				lda		[dib_ptr],y
				sta		<scsi_zp6
				beq		@over_0
				sec
@over_0			ldy		#dib.headptr+2
				lda		[dib_ptr],y
				sta		<scsi_zp6+2
									;
									; Check if ­ null.
									;
				bne		@check_it_loop
				bcs		@check_it_loop
									;
									; It was null.  This may be the head
									; of the link. Check it out.
									;
				ldy		#dib.fdvcptr
				lda		[dib_ptr],y
				ldy		#dib.fdvcptr+2
				ora		[dib_ptr],y
				beq		@no_link	;No. Return to the caller with the carry clear.
									;
									; Yes. This was the head of the link.
									; Set our pointer to this DIB.
									;
				lda		<dib_ptr
				sta		<scsi_zp6
				lda		<dib_ptr+2
				sta		<scsi_zp6+2
									;
									; At this point, 'scsi_zp6' points to the
									; head of the link.  Now walk the links
									; checking for online.  If a device is
									; online we will need to check if it is the
									; callers device. if so, then we will
									; continue the search.  If not, we will then
									; exit with the carry set.
									;
@check_it_loop	ldy		#dib.dvcflag

				lda		[scsi_zp6],y
				and		#dvc_online		;Is it online?
				beq		@not_online		;No.

				lda		[scsi_zp6],y	;Yes.  Maybe.  Check hard offline
				and		#dvc_hardofl	;Is it hard offline?
				bne		@not_online		;Yes.

				lda		<scsi_zp6+2	;Is it the caller device?
				cmp		<dib_ptr+2
				bne		@linked		;No.
				lda		<scsi_zp6
				cmp		<dib_ptr
				bne		@linked		;No.
									;
									; Point to next device.
									;
@not_online		clc
				ldy		#dib.fdvcptr
				lda		[scsi_zp6],y
				tax
				beq		@over_2
				sec
@over_2			ldy		#dib.fdvcptr+2
				lda		[scsi_zp6],y
				bne		@save_it
				bcc		@no_link
@save_it		sta		<scsi_zp6+2
				stx		<scsi_zp6

				bra		@check_it_loop
				
									;
									; Only device online.
									;
@no_link		clc
				rts
									;
									; Not the only device online.
									;
@linked			sec
				rts

				ELSE

;-------------------------------------------------------------------------------

				lda		#null
				clc
				rts

				ENDIF

;-------------------------------------------------------------------------------


				ENDP

				EJECT

;*******************************************************
;
;	'wake_me_up'
;
;	This call walks the DIBs, slaps them in the face and
;	pours cold water on them.  It seems that they have
;	been sleeping while P8 was running.
;
;				!!!! WAAAAAAAAKE  UUUUUUUP !!!!
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	wake_me_up
wake_me_up		PROC

;-------------------------------------------------------------------------------

				IF		warm_ss_suprt = true		THEN

											;
											; Start with the first DIB after
											; the default DIB
											;
				lda		|default_dib
				sta		<first_dib
				sta		<next_dib
				lda		|default_dib+2
				sta		<first_dib+2
				sta		<next_dib+2
											;
											; Is he asleep?
											;
@check_it_loop	ldy		#dib.dvcflag
				lda		[next_dib],y
				tax
				and		#relaxing
				beq		@next_dib			;No he is not asleep
											;
											; Yes he is!  Is he also Hard
											; Offline?
											;
				txa
				and		#dvc_hardofl
				beq		@not_hardofl		;No.  Wake him up all the way then.

				txa							;Yes.  Only Clear Sleep Bit.
				and		#relaxing--\		;Don't set online.
						$ffff
				sta		[next_dib],y

				bra		@next_dib
											;
											; Yes he is, wake him up.
											;
@not_hardofl	txa
				and		#relaxing--\
						$ffff
				ora		#dvc_online
				sta		[next_dib],y
											;
											; Advance to the next one
											;
@next_dib		clc
				ldy		#dib.linkptr
				lda		[next_dib],y
				tax
				beq		@over_0
				sec
@over_0			ldy		#dib.linkptr+2
				lda		[next_dib],y
				sta		<next_dib+2
				stx		<next_dib
											;
											; Check if ­ null.
											;
				bne		@check_it_loop
				bcs		@check_it_loop
											;
											; That was the last one.
											;
											; By default of the branches above,
											; the Acc. = 0 and the carry is clear.
											;
				rts

;-------------------------------------------------------------------------------

 				ELSE

;-------------------------------------------------------------------------------

				clc
				rts

 				ENDIF

;-------------------------------------------------------------------------------


				ENDP

				EJECT

;*******************************************************
;
;	'fix_unit_1'
;
;	This call walks the DIBs, ensuring that unit 1 is
;	the first ProDOS Partition on the disk..
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	fix_unit_1
fix_unit_1		PROC

;-------------------------------------------------------------------------------

				IF		part_suprt = true		THEN

										;
										; Check the pdos Bit for the Unit number 1.
										; This may or may not be the head device.
										;
				ldy		#dib.headptr
				lda		[dib_ptr],y
				sta		<scsi_zp0
				ldy		#dib.headptr+2
				lda		[dib_ptr],y
				sta		<scsi_zp0+2
				ora		<scsi_zp0		;Are we at the Head Now?
				bne		@check_it		;No.
										;
										; We were already at the head.  Set pointer
										; to this DIB before going on.
										;
				lda		<dib_ptr
				sta		<scsi_zp0
				lda		<dib_ptr+2
				sta		<scsi_zp0+2
										;
										; Is this unit number 1?
										;
@check_it		ldy		#dib.unitnum
				lda		[scsi_zp0],y
				and		#max_p_mask
				beq		@unit_1			;Yes.
										;
										; No.  It's not unit number one.  Check the
										; next DIB in the link if it is non-zero.
										;
				clc
				ldy		#dib.fdvcptr
				lda		[scsi_zp0],y
				tax

				beq		@over_sec
				sec

@over_sec		ldy		#dib.fdvcptr+2
				lda		[scsi_zp0],y

				bne		@set_ptr
				bcc		@out

@set_ptr		sta		<scsi_zp0+2
				stx		<scsi_zp0
				bra		@check_it
										;
										; This is unit 1.  Is it a ProDOS Partition?
										;
@unit_1			ldy		#dib.dvcflag
				lda		[scsi_zp0],y
				and		#pdos_part
				bne		@out			;It's ProDOS, Get out of here.
										;
										; We're out of here.
										;
@out			clc
				rts

;-------------------------------------------------------------------------------

 				ELSE					;part_suprt = true

;-------------------------------------------------------------------------------

				clc
				rts

 				ENDIF					;part_suprt = true

;-------------------------------------------------------------------------------


				ENDP					;fix_unit_1

				EJECT

;*******************************************************
;
;	ADD_DIB_PTR
;
;	This routine adds a pointer to a list of dibs to be
;	installed by the 'POST_DRIVER_INSTALL' System
;	Service call.  Refer to the System Service ERS for
;	details of how this works.
;
;	Inputs:		Acc				=	Unspecified
;				Y register		=	High word of dib ptr
;				X register		=	Low word of dib ptr
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Outputs:	<DIB_PTR		=	Empty DIB if found
;				Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Errors:		None
;
;*******************************************************

				EXPORT	add_dib_ptr
add_dib_ptr		PROC

;-------------------------------------------------------------------------------

				IF			part_suprt = true		THEN

										;
										; Check to see if this has an overide
										; placed on it.
										;
				lda		|dpi_overide
				bmi		@exit			;Yes.
										;
										; Is this the first time that this has been
										; called for this session.  Only the
										; do_post_install can clear this flag.
										;
				lda		|new_list
				beq		@start_over		; Acc. = 0
										;
										; Inc the count of new devices to be started.
										;
				lda		|new_dib_cnt
@start_over		pha
				inc		a
				sta		|new_dib_cnt
				sta		|new_list
				pla
												;
												; Calculate offset for next ptr.
												;
				asl		a
				asl		a
				pha
				txa
				plx
				sta		|new_dib_list,x			;Place Ptr in list
				sta		<scsi_zp0				;and on zero page.

				tya
				sta		|new_dib_list+2,x		;Place Ptr in list
				sta		<scsi_zp0+2				;and on zero page.

				ldy		#dib.dvcflag
				lda		[scsi_zp0],y
				ora		#cold_dib				;New DIB.  Do Cold Start.
				sta		[scsi_zp0],y

@exit			clc
				rts

				ELSE

;-------------------------------------------------------------------------------

				lda		#null
				clc
				rts

				ENDIF

;-------------------------------------------------------------------------------

				ENDP

				EJECT

;*******************************************************
;
;	DO_POST_INSTALL
;
;	This routine calls the 'POST_DRIVER_INSTALL' System
;	Service call.  Refer to the System Service ERS for
;	details of how this works.
;
;	Inputs:		Acc				=	Unspecified
;				Y register		=	High word of dib ptr
;				X register		=	Low word of dib ptr
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Outputs:	<DIB_PTR		=	Empty DIB if found
;				Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Errors:		None
;
;*******************************************************

				EXPORT	do_post_install
do_post_install	PROC

;-------------------------------------------------------------------------------

				IF			part_suprt = true		THEN

										;
										; Check to see if this has an overide
										; placed on it.
										;
				lda		|dpi_overide
				bmi		@exit			;Yes.
										;
										; Clear flag indicating that the call was
										; sent.
										;
				stz		|pdi_flag
				stz		|new_list
										;
										; Check the count of new devices to be
										; started.
										;
				lda		|new_dib_cnt
				beq		@exit
										;
										; Make the call
										;
				lda		|gsos_dpage
				tcd
				ldx		#new_dib_cnt
				ldy		#^new_dib_cnt

				jsl		install_driver
				pha
				lda		|direct_page
				tcd
				pla

				bcs		@exit
				dec		|pdi_flag
				
@exit			clc
				rts

				ELSE

;-------------------------------------------------------------------------------

				lda		#null
				clc
				rts

				ENDIF

;-------------------------------------------------------------------------------

				ENDP

				EJECT

;____Part_Support____

;-------------------------------------------------------------------------------

				IF			part_suprt = true		THEN

;*******************************************************
;
;	READ_PM_BLK
;
;	
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if operation could not be
;				completed.  Out of memory for example.
;
;*******************************************************

				EXPORT	read_pm_blk
read_pm_blk		PROC
										;
										; Tell the Main Driver where
										; our command structure resides.
										;
				lda		#@read_part
				sta		<scsi_mdrvr
				lda		#^@read_part
				sta		<scsi_mdrvr+2
										;
										; And our buffer
										;
				lda		#internal_buff
				sta		<buff_ptr
				lda		#^internal_buff
				sta		<buff_ptr+2
										;
										; Was this from the STARTUP Call?
										;
				bit		|rebuild
				bmi		@over			;No.
										;
										; Yes, then stuff the pointer to
										; the dib that we are building into
										; the Direct Page locations.  The
										; main driver will use this to build
										; the SCSI READ BLOCK Command that
										; we will issue.
										;
				lda		<next_dib
				sta		<dib_ptr
				lda		<next_dib+2
				sta		<dib_ptr+2
										;
										; And our length from the DIB's
										; Block Size value
										;
@over			lda		#block_size
				sta		<rqst_cnt
				lda		#^block_size
				sta		<rqst_cnt+2
										;
										; Set block to read for the next
										; partition map block.  This field
										; is initialized to zero.  Because
										; the first partition map block is
										; on block 1, this will be initialized
										; to zero and then blindly incremented
										; until we are finished.
										;
										; *** This is High --> Low format ***
										;
				lda		|pm_blk_num
				xba
				inc		a
				xba
				sta		|pm_blk_num
										;
										; Set internal command flag
										;
				dec		|internal
										;
										; Set the Partition call flag
										;
				dec		|f_partition
										;
										; Set the Call Type and Issue the
										; READ BLOCK Command.
										;
				lda		#scsit_stat
				sta		|call_type
										;
										; Issue the call.
										;
				jsr		check_532_rw

@rts			rts
										;
										; Data for the READ BLOCK Command
										;
@read_part		dc.b		$08
				dc.b		null
				EXPORT		pm_blk_num
pm_blk_num		dc.w		null
				dcb.b		10,null

				ENDP

				EJECT

;*******************************************************
;
;	CHK_MAP
;
;	This routine checks the validity of the partition
;	map block currently loaded in the internal buffer.
;	This need only be called once per device.  If the
;	map is valid, then the carry will be clear.  The 'Z'
;	flag will also be set if this is not the first time
;	that this routine was called for this device.  If
;	the carry is set, then the map was invalid and the
;	block count at 'T_DVC_BLOCKS' has been placed in the
;	DIB pointed to by 'DIB_PTR'.  The starting block will
;	also have been set to null.
;
;	Inputs:		<DIB_PTR		=	DIB Location
;				|T_DVC_BLOCKS	=	Total blocks for this device
;				Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Outputs:	Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;								=	Z = 0 if routine called before
;								=	C = 1 if not a partition map
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Errors:		Carry set if 'internal_buff does not
;				contain a valid Partition map entry.
;
;*******************************************************

				EXPORT	chk_map
chk_map			PROC
										;
										; Valid Partition Map?
										;
@over_0			inc		|first_time		;Don't need to do this but once.
				bne		@clc			;Already done if taken.
				
				lda		|pm.Sig\
						+internal_buff
				cmp		#Part_sig
				bne		no_partition	;No.

@clc			clc
				rts
										;
										; We didn't have a valid partition
										; map, so this device will be
										; treated as a single non-partitioned
										; device.
										;
				EXPORT	no_partition

no_partition	ldy		#dib.blkcnt
				lda		|t_dvc_blocks
				sta		[dib_ptr],y
				ldy		#dib.blkcnt+2
				lda		|t_dvc_blocks+2
				sta		[dib_ptr],y
				ldy		#dib.start_blk
				lda		#null
				sta		[dib_ptr],y
				ldy		#dib.start_blk+2
				sta		[dib_ptr],y
										;
										; Mark DIB as online and switched.
										;
				ldy		#dib.dvcflag
				lda		[dib_ptr],y
				and		#dvc_hardofl--\
						$ffff
				ora		#dvc_switch++\
						dvc_online
				sta		[dib_ptr],y

				sec
				rts

				ENDP

				EJECT

;*******************************************************
;
;	'check_map_entry'
;
;	Check the Partition Map Entry currently loaded in
;	the internal buffer.  If it is of type
;	'Apple_partition_map', 'Apple_Free', or
;	'Apple_Scratch', then this routine will return with
;	the carry set.  Any other type will return with the
;	carry clear.  In addition, 'Apple_ProDOS' will
;	return with the overflow flag set.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if Partition Map Entry is not
;				for a valid Volume.  Overflow set if the
;				Partition is a ProDOS Partition.
;
;*******************************************************

				EXPORT	check_map_entry
check_map_entry	PROC
										;
										; This routine runs in
										; 8 bit m and x only.
										;
				short
										;
										; Is it ProDOS?
										;
				ldx		#@p_map-@prodos-2
				ldy		#null

@loop			lda		|pm.PartType\
						+internal_buff,y
				beq		@over_0			;Yes or null.  Either way we do the rest.
				cmp		@prodos,y
				beq		@next
				eor		#'A'--'a'
				cmp		@prodos,y
				bne		@over_0			;No.  Continue on.
@next			iny
				dex
				bpl		@loop
				brl		@pdos_part		;Skip over 8 bit code area to 16 bit area.
										;
										; Is it the Partition Map?
										;
@over_0			ldx		#32-1
				ldy		#null

@loop_0			lda		|pm.PartType\
						+internal_buff,y
				beq		@skip			;Yes or null.  Either way we skip it.
				cmp		@p_map,y
				beq		@next_0
				eor		#'A'--'a'
				cmp		@p_map,y
				bne		@over_1			;No.  Continue on.
@next_0			iny
				dex
				bpl		@loop_0
				bra		@skip			;Yes. Skip it.
										;
										; Is it a FREE Partition?
										;
@over_1			ldx		#32-1
				ldy		#null

@loop_1			lda		|pm.PartType\
						+internal_buff,y
				beq		@skip			;Yes or null.  Either way we skip it.
				cmp		@free,y
				beq		@next_1
				eor		#'A'--'a'
				cmp		@free,y
				bne		@over_2			;No.  Continue on.
@next_1			iny
				dex
				bpl		@loop_1
				bra		@skip			;Yes. Skip it.
										;
										; Is it a SCRATCH Partition?
										;
@over_2			ldx		#32-1
				ldy		#null

@loop_2			lda		|pm.PartType\
						+internal_buff,y
				beq		@skip			;Yes or null.  Either way we skip it.
				cmp		@scratch,y
				beq		@next_2
				eor		#'A'--'a'
				cmp		@scratch,y
				bne		@over_3			;No.  Continue on.
@next_2			iny
				dex
				bpl		@loop_2
										;
										; At this point the Current Partition
										; Type matched one of the three types
										; checked for.  Exit with the carry
										; set.
										;
@skip			longmx
				sec
				rts
										;
										; At this point the Current Partition
										; Type did not match one of the three
										; types checked for and it was not a
										; ProDOS Partition..  Exit with the
										; Carry and Overflow bits clear.
										;
@over_3			longmx
				clc
				clv
				rts
										;
										; At this point the Current Partition
										; Type is a ProDOS Partition.  Exit with
										; the Carry clear and Overflow set.
										;
@pdos_part		longmx
				clc
				sep		#%01000000		;Set the v flag
				rts
										;
										; Inactive Partion Types to check for.
										;
				STRING		ASIS

@prodos			dc.b		'Apple_ProDOS'
				dc.b		$00
@p_map			dc.b		'Apple_partition_map'	
				dc.b		$00
@free			dc.b		'Apple_Free'
				dc.b		$00
@scratch		dc.b		'Apple_Scratch'
				dc.b		$00

				STRING		PASCAL

				ENDP

				EJECT

				ELSE					;part_suprt = true

;-------------------------------------------------------------------------------

				EXPORT		read_pm_blk
read_pm_blk		PROC

				EXPORT		check_map_entry
check_map_entry
				lda		#null
				clc
				clv
				rts


				EXPORT		pm_blk_num
pm_blk_num		dc.w	null

				EXPORT		chk_map
chk_map
										;
										; We can't have a valid partition
										; map, so this device will be
										; treated as a single non-partitioned
										; device.
										;
				EXPORT	no_partition

no_partition	ldy		#dib.blkcnt
				lda		|t_dvc_blocks
				sta		[dib_ptr],y
				ldy		#dib.blkcnt+2
				lda		|t_dvc_blocks+2
				sta		[dib_ptr],y
				ldy		#dib.start_blk
				lda		#null
				sta		[dib_ptr],y
				ldy		#dib.start_blk+2
				sta		[dib_ptr],y
										;
										; Mark DIB as online and switched.
										;
				ldy		#dib.dvcflag
				lda		[dib_ptr],y
				and		#dvc_hardofl--\
						$ffff
				ora		#dvc_switch++\
						dvc_online
				sta		[dib_ptr],y

				sec
				rts

				ENDIF					;part_suprt = true

;-------------------------------------------------------------------------------

;____Cache_Suport____

;-------------------------------------------------------------------------------

				IF			cache_blks = true	THEN

;*******************************************************
;
;	'r_all_in_cache'
;
;	This routine is used to check if the entire
;	requested block count is in the cache.  This routine
;	will check each block individually, incrementing the
;	block count and subtracting the block size from the
;	request count until either a block is found that is
;	not in the cache (Exit Carry Set) or request count
;	has been exausted (Exit Carry Clear).
;
;	On entry this routine clears some values to indicate
;	it's starting point for this call.  As it goes
;	throughthe cache looking for blocks, it will fetch
;	the block from the cache and advance the starting
;	point.  What this does is eliminate double searches
;	throughthe cache and if a read is needed, these
;	blocks will not have to be transfered.  When this
;	routine exits, the caller will think that the first
;	block that we found that was not in the cache was
;	the first block requested.  For this reason, any
;	code that uses this call will need to preserve those
;	values so that they can be restored on exit.
;
;	If we receive a Read Call for 256 blocks and the
;	first 128 are in the cache, then we don't want to
;	re-read them, and we don't want to do a find again
;	later when we fetch them.  let's fetch them now and
;	advance our pointers.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				<buff_ptr	=	Original Starting Buffer
;				<rqst_cnt	=	Original Request Count
;				<block_num	=	Original Starting Block
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				<buff_ptr	=	New Starting Buffer
;				<rqst_cnt	=	New Request Count
;				<block_num	=	New Starting Block
;				Data Bank	=	Ours
;
;	Errors:		Acc = 0 and Carry set if 1 or more
;				blocks of the request are not in the
;				cache.
;
;				Acc <> 0 if any other error occurs.
;				Error code is in Acc.
;
;*******************************************************

				EXPORT	r_all_in_cache
r_all_in_cache	PROC
										;
										; Switch Direct Pages.
										;
				lda		|gsos_dpage
				tcd
										;
										; Get the requested count and devide
										; by block size to get the loop counter.
										; If Count = 0, then exit.
										;
				lda		<rqst_cnt
				sta		|divend
				lda		<rqst_cnt+2
				sta		|divend+2

				ora		<rqst_cnt
				bne		@continue

				lda		|direct_page
				tcd
				lda		#null
				clc
@rts			rts

										;
										; Call divide routine.
										;
@continue		lda		<blk_size
				sta		|divsor

				jsr		divide
				bcc		@over_divide

				lda		|direct_page
				tcd

				lda		#drvr_bad_cnt	;non-integral rqst count.
				sec
				rts
										;
										; Count = count -1.  This way we can
										; use a BMI to exit with.
										;
@over_divide	lda		|result+2
				sta		@blk_cnt+2
				lda		|result
				sta		@blk_cnt
				bne		@over_dec_high
				dec		@blk_cnt+2
@over_dec_high	dec		@blk_cnt
										;
										; Setup is now completed.  Now we start to
										; check to see if the blocks are in the
										; cache.
										;
@chk_blk_loop	sec						;return error if not in cache. Don't add.
				jsr		|get_from_cache
				bcc		@found
				lda		#null			;Not there.  Clear the Acc. and Exit.
				bra		@restore
										;
										; Are there any more to do?
										;
@found			lda		@blk_cnt
				bne		@over_dec
				dec		@blk_cnt+2
				bpl		@over_dec
										;
										; No. Count is exausted.
										;
				lda		#null
				clc
				bra		@restore
										;
										; Yes. Finish the DEC and update the
										; Buffer Pointer, Request Count, and
										; the Block Number.
										;
@over_dec		dec		@blk_cnt

				clc						;Bump Buffer Pointer
				lda		<buff_ptr
				adc		<blk_size
				sta		<buff_ptr
				lda		<buff_ptr+2
				adc		#null
				sta		<buff_ptr+2

				sec						;Back off Request Count
				lda		<rqst_cnt
				sbc		<blk_size
				sta		<rqst_cnt
				lda		<rqst_cnt+2
				sbc		#null
				sta		<rqst_cnt+2

				inc		<block_num		;Inc the Block Number
				bne		@chk_blk_loop
				inc		<block_num+2
				bra		@chk_blk_loop
										;
										; We are finished.  We don't need to
										; know if we were succesfull.  We only
										; need to restore the state of the
										; corrupted direct page values while
										; preserving the Acc. and Carry bit.
										;
@restore		pha
				php

				ldx		|direct_page

				lda		<buff_ptr
				sta		>buff_ptr,x
				sta		|c_strt_buffer
				lda		<buff_ptr+2
				sta		>buff_ptr+2,x
				sta		|c_strt_buffer+2

				lda		<rqst_cnt
				sta		>rqst_cnt,x
				sta		|c_strt_rqst_cnt
				lda		<rqst_cnt+2
				sta		>rqst_cnt+2,x
				sta		|c_strt_rqst_cnt+2

				lda		<block_num
				sta		>block_num,x
				sta		|c_strt_blk_num
				lda		<block_num+2
				sta		>block_num+2,x
				sta		|c_strt_blk_num+2
										;
										; Validate Flag for the Read Cache
										; Routines
										;
				dec		|cache_valid

				txa
				tcd

				plp
				pla
				rts
										;
										; Internal Data
										;
@blk_cnt		dc.l	null
										;
										; The following values are used to advance
										; the starting point of the cache calls.
										;
				EXPORT		c_strt_buffer
				EXPORT		c_strt_rqst_cnt
				EXPORT		c_strt_blk_num
				EXPORT		cache_valid

c_strt_buffer	dc.l	null			;Starting Buffer Pointer
c_strt_rqst_cnt	dc.l	null			;Starting Request Count
c_strt_blk_num	dc.l	null			;Starting Block Number
cache_valid		dc.w	null

				ENDP

				EJECT

;*******************************************************
;
;	'w_update_cache'
;
;	This routine is used when writting data to the disk
;	with a cache priority of $0000.  If the block is in
;	the cache, then the cache will be updated.  If not,
;	then nothing will happen.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;				Carry Clear	=	Always place in cache
;				Carry set	=	Only place in cache if
;								already there.
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if requested block is not
;				added to the cache.
;
;*******************************************************

				EXPORT	w_update_cache
w_update_cache	PROC
										;
										; Zero Deferred Write failed flag.
										;
				stz		@deferred
										;
										; Preserve Carry Flag for later.
										;
				php
										;
										; Set GS/OS Direct Page
										;
				lda		|gsos_dpage
				tcd
										;
										; Preserve Block Number and request
										; count.  Set count to 1 block per
										; call.
										;
				lda		<buff_ptr
				sta		@orig_buff

				lda		<rqst_cnt
				sta		@bytes_rem

				lda		<block_num
				sta		@start_blk

				lda		<buff_ptr+2
				sta		@orig_buff+2

				lda		<rqst_cnt+2
				sta		@bytes_rem+2

				lda		<block_num+2
				sta		@start_blk+2
										;
										; Is the requested block in the cache?
										;
@do_cache		plp
				php
				jsr		put_in_cache
				bcc		@cached			;Carry set only if a deferred write
				dec		@deferred		;failed to go in the cache.
										;
										; Advance to the next block.
										;
@cached			inc		<block_num
				bne		@over
				inc		<block_num+2
										;
										; Bump Buffer Pointer.
										;
@over			clc
				lda		<buff_ptr
				adc		<blk_size
				sta		<buff_ptr
				bcc		@over_1
				inc		<buff_ptr+2
										;
										; Any Data Left
										;
@over_1			sec
				lda		@bytes_rem
				sbc		<blk_size
				sta		@bytes_rem
				sta		|temp_acc

				lda		@bytes_rem+2
				sbc		#null
				sta		@bytes_rem+2
				ora		|temp_acc

				bne		@do_cache		;Yes.
				clc
										;
										; Restore Values.
										;

@restore		lda		@orig_buff
				sta		<buff_ptr

				lda		@start_blk
				sta		<block_num

				lda		@orig_buff+2
				sta		<buff_ptr+2

				lda		@start_blk+2
				sta		<block_num+2
										;
										; Exit.
										;
				lda		|direct_page
				tcd

				lda		@deferred
				beq		@clean_out
				plp						;Restore the Stack.
				sec
				rts

@clean_out		plp						;Restore the Stack.
				clc
				rts
										;
										; Internal Data
										;
@deferred		dc.w	null
@orig_buff		dc.l	null
@bytes_rem		dc.l	null
@start_blk		dc.l	null

				ENDP

				EJECT

;*******************************************************
;
;	'put_in_cache'
;
;	This routine is used to place the current block in
;	the cache.  First we will check if the requested
;	block is in the cache.  If the block is not in the
;	cache then we will add it.  if there is no room and
;	the driver call was issued in deferred mode then we
;	will exit with the carry set.  In all other cases
;	we will exit Carry Clear.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;				Carry Clear	=	Always place in cache
;				Carry set	=	Only place in cache if
;								already there.
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if requested block is not
;				added to the cache in deferred mode
;				only.
;
;*******************************************************

				EXPORT	put_in_cache
put_in_cache	PROC
										;
										; Is the requested block in the cache?
										;
				php

				clc
				jsl		cache_find_blk

				bcc		@move_it_in		;Yes. It is.
				plp
				bcs		@clc
										;
										; Not there.  Allocate space.
										;
				jsl		cache_add_blk
				bcc		@skip_fix
				lda		<cache_prio		;Deferred Mode?
				bpl		@clc			;No.  Exit Carry Clear.
				rts						;Yes. Exit carry set
										;
										; Move the block in.
										;
@move_it_in		plp						;Restore the stack.

@skip_fix		pei		<buff_ptr+2
				pei		<buff_ptr
				pei		<cache_ptr+2
				pei		<cache_ptr
				pea		$0000
				pei		<blk_size
				pea		|move_sinc_dinc
				jsl		move_info
										;
										; Exit.
										;
@clc			clc
@rts			rts

				ENDP

				EJECT

;*******************************************************
;
;	'r_get_cache'
;
;	This routine is used when reading data from the disk
;	with a cache priority of $0000.  If the block is in
;	the cache, then the data will be updated.  If not,
;	then nothing will happen.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;				Carry Clear	=	Always place in cache
;				Carry set	=	Only place in cache if
;								already there.
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if requested block is not
;				added to the cache.
;
;*******************************************************

				EXPORT	r_get_cache
r_get_cache		PROC
										;
										; Preserve Carry Flag for later.
										;
				php
										;
										; Check Validity of the call.
										;
				lda		|cache_valid
				bmi		@valid

				plp
				lda		#drvr_bad_code
				sec
				rts
										;
										; Set GS/OS Direct Page
										;
@valid			lda		|gsos_dpage
				tcd
										;
										; Get Request count.
										;
				lda		|c_strt_rqst_cnt
				sta		@bytes_rem
				lda		|c_strt_rqst_cnt+2
				sta		@bytes_rem+2
										;
										; Is the requested block in the cache?
										;
@do_cache		plp
				php
				jsr		get_from_cache
										;
										; Advance to the next block.
										;
				inc		<block_num
				bne		@over
				inc		<block_num+2
										;
										; Bump Buffer Pointer.
										;
@over			clc
				lda		<buff_ptr
				adc		<blk_size
				sta		<buff_ptr
				bcc		@over_1
				inc		<buff_ptr+2
										;
										; Any Data Left
										;
@over_1			sec
				lda		@bytes_rem
				sbc		<blk_size
				sta		@bytes_rem
				sta		|temp_acc

				lda		@bytes_rem+2
				sbc		#null
				sta		@bytes_rem+2
				ora		|temp_acc

				bne		@do_cache		;Yes.
										;
										; Exit.
										;
				stz		|cache_valid	;Cache Values no longer valid

				lda		|direct_page
				tcd

				plp						;Restore the Stack.
				clc
				rts
									;
									; Internal Data
									;
@bytes_rem		dc.l	null

				ENDP

				EJECT

;*******************************************************
;
;	'get_from_cache'
;
;	This routine is used to get the current block from
;	the cache.  First we will check if the requested
;	block is in the cache.  If the block is not in the
;	cache then we will exit with the Carry Set.  If it
;	is found, then we will move it to the requested ram
;	and exit Carry Clear.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if requested block is not
;				in the cache.
;
;*******************************************************

				EXPORT	get_from_cache
get_from_cache	PROC
										;
										; Is the requested block in the cache?
										;
				php

				clc
				jsl		cache_find_blk

				bcc		@move_it_in		;Yes. It is.
				plp
				bcs		@rts
										;
										; Not there.  Allocate space.
										;
				jsl		cache_add_blk
				bcs		@rts

				pei		<buff_ptr+2
				pei		<buff_ptr
				pei		<cache_ptr+2
				pei		<cache_ptr
				pea		$0000
				pei		<blk_size
				pea		|move_sinc_dinc
				jsl		move_info

				bra		@clc
										;
										; Move the block in.
										;
@move_it_in		plp						;Restore the stack.

@skip_fix		pei		<cache_ptr+2
				pei		<cache_ptr
				pei		<buff_ptr+2
				pei		<buff_ptr
				pea		$0000
				pei		<blk_size
				pea		|move_sinc_dinc
				jsl		move_info
										;
										; Exit.
										;
@clc			clc
@rts			rts

				ENDP

				EJECT

;*******************************************************
;
;	'ko_cache'
;
;	This routine is used to kill all blocks that are
;	cached that are included in a device specific write
;	type call.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	ko_cache
ko_cache		PROC
									;
									; Switch Direct Pages.
									;
				lda		|gsos_dpage
				tcd
									;
									; Preserve the block number on direct
									; page.
									;
				lda		<block_num
				sta		|scratch0
				lda		<block_num+2
				sta		|scratch1
									;
									; Set our starting block number on
									; direct page.
									;
				lda		|killer_blk
				sta		<block_num
				lda		|killer_blk+2
				sta		<block_num+2
									;
									; Get the requested count and devide
									; by block size to get the loop counter.
									; If Count = 0, then exit.
									;
				lda		<rqst_cnt+2
				sta		|divend+2
				lda		<rqst_cnt
				sta		|divend
				ora		<rqst_cnt+2
				bne		@do_devide

				clc
@rts			bra		@restore
									;
									; Call divide routine.
									;
@do_devide		lda		<blk_size
				sta		|divsor

				jsr		divide
				bcc		@over_divide
				lda		#drvr_bad_cnt	;non-integral rqst count.
				sec
				bra		@restore
									;
									; Count = count -1.  This way we can
									; use a BMI to exit with.
									;
@over_divide	lda		|result+2
				sta		@blk_cnt+2
				lda		|result
				sta		@blk_cnt
				bne		@over_dec_high
				dec		@blk_cnt+2
@over_dec_high	dec		@blk_cnt
									;
									; Setup is now completed.  Now we start to
									; check to see if the blocks are in the
									; cache.
									;
@chk_blk_loop	jsl		cache_kil_blk
									;
									; Are there any more to do?
									;
				lda		@blk_cnt
				bne		@over_dec
				dec		@blk_cnt+2
				bpl		@over_dec
									;
									; No. Count is exausted.
									;
				clc
				bra		@restore
									;
									; Yes. Finish the DEC and update
									; the block number.
									;
@over_dec		dec		@blk_cnt

				inc		<block_num
				bne		@chk_blk_loop
				inc		<block_num+2
				bra		@chk_blk_loop
									;
									; We are finished.  We don't need to
									; know if we were succesfull.  We only
									; need to restore the state of the
									; corrupted direct page values while
									; preserving the Acc. and Carry bit.
									;
@restore		pha
				php
				lda		|scratch0
				sta		<block_num
				lda		|scratch1
				sta		<block_num+2

				lda		|direct_page
				tcd

				plp
				pla
				rts
									;
									; Internal Data
									;
@blk_cnt		dc.l	null

				ENDP

				EJECT

				ELSE

;-------------------------------------------------------------------------------

				EXPORT		put_in_cache

put_in_cache	PROC

				EXPORT		get_from_cache
				EXPORT		c_strt_buffer
				EXPORT		c_strt_rqst_cnt
				EXPORT		c_strt_blk_num
				EXPORT		cache_valid

get_from_cache	sec
				rts

c_strt_buffer
c_strt_rqst_cnt
c_strt_blk_num
cache_valid		dc.w	null

				ENDP

				EJECT

				ENDIF

;-------------------------------------------------------------------------------

;____Device_Tests____
;*******************************************************
;
;	'unit_state'
;
;	Tests the Target Device to see if it is ready to
;	accept our commands.  If the device responds with a
;	CHECK CONDITION, then we will find out why and
;	perform the correct actions.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;				<dib_ptr	=	Called DIB
;
;	Outputs:	Acc			=	Error Code if any
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;				<dib_ptr	=	Called DIB
;
;	Errors:		Carry set if Unit no ready.
;
;*******************************************************

				EXPORT	unit_state
unit_state		PROC
										;
										; This device is removable.  Now we
										; need to check to see if the unit
										; has gone offline, (then we need to
										; report that to the OS) or if the
										; unit has come back online (Rebuild
										; the DIBs).
										;
				jsr		test_unit_rdy	;Is there anything that we should know about?
				bcc		@ready_to_go	;No.

				lda		|auto_sense_data+\
						rqst_sens.sense_key
				beq		@ready_to_go

				and		#$00ff
				cmp		#$0006
				beq		@do_switch

;-------------------------------------------------------------------------------

				IF			scsi_dtype = direct_acc		THEN

				lda		auto_sense_data+\		;Was it a RESET?
						rqst_sens.addnl_sens_code
				and		#$00fe
				cmp		#$0028			;Checking for $28 (Medium Changed), $29 (RESET)
				bne		@io_error

				ENDIF

;-------------------------------------------------------------------------------

				IF			scsi_dtype = apple_cd		THEN

				lda		auto_sense_data+\		;Was it a RESET?
						rqst_sens.addnl_sens_code
				and		#$00ff
				cmp		#$00b7			;Checking for $B7 (Media being mounted)
				beq		@do_switch
				cmp		#$00b0			;Checking for $B0 (NO MEDIA)
				beq		@off_line
				and		#$00fe
				cmp		#$0028			;Checking for $28 (Medium Changed), $29 (RESET)
				bne		@io_error
										;
										; Set this location to a $B0.  This will
										; prevent problems if the device is reset
										; durring startup while auto sensing is
										; off.
										;
				lda		#$00b0
				sta		auto_sense_data+\
						rqst_sens.addnl_sens_code
				bra		unit_state

				ENDIF

;-------------------------------------------------------------------------------

											;
											; Rebuild the DIBs.
											;
@do_switch		jsr		test_unit_rdy		;Is it ready yet?
				bcc		@its_ready			;Yes.
				lda		auto_sense_data+\	;Is there media in the drive?
						rqst_sens.addnl_sens_code
				and		#$00ff
				cmp		#$00b0				;Checking for $B0 (NO MEDIA)
				bne		@do_switch			;No.

@its_ready		jsr		set_512_mode
										;
										; Issue the READ CAPACITY Command.
										;
				jsr		read_capacity
				bcs		@over_0			;Was there an error?
										;
										; Get the Block Count (Stored
										; High >> Low.  Must be switched
										; to Low >> High).  This is the last
										; readable block number.  Add 1 to
										; it for comparison reasons.
										;
				lda		|block.count\
						+internal_buff\
						+2
				xba
				adc		#$0001
				sta		|t_dvc_blocks
				lda		|block.count\
						+internal_buff
				xba
				adc		#null
				sta		|t_dvc_blocks+2

@over_0			stz		|trash_it		;DO NOT TRASH THIS DISK.

				pei		<dib_ptr
				pei		<dib_ptr+2

				jsr		rebld_dibs		;Rebuild DIBs and Issue a DISK_SW for each

				tax
				pla
				sta		<dib_ptr+2
				pla
				sta		<dib_ptr
				txa

				php
										;
										; Restore the original Direct Page values.
										;
				jsr		set_our_dp
				plp
				bcc		@switch_error
				jsr		test_unit_rdy
				bcs		@io_error
										;
										; Disk Switched Error.
										;
@switch_error	lda		#drvr_dsk_swch
				sec
				rts
										;
										; Are we really ready to go?  If the
										; dvc_hard_sw flag is set, then we
										; will clear it and report the device
										; as switched.
										;
@ready_to_go	ldy		#dib.dvcflag
				lda		[dib_ptr],y
				tax

				and		#dvc_hard_sw
				beq		@no_switch

				txa
				and		#dvc_hard_sw--\
						$ffff
				sta		[dib_ptr],y

@no_switch		lda		#null
				clc
@rts			rts
										;
										; Some kind of I/O Error.
										;
@io_error		lda		#drvr_io
				sec
				rts
										;
										; Device is currently offline.
										;
@off_line		lda		#drvr_off_line
				sec
				rts

				ENDP

				EJECT

;*******************************************************
;
;	'test_unit_rdy'
;
;	Test the Target Device to see if it is ready to
;	accept our commands.  If the device responds with a
;	CHECK CONDITION, then it will be up to the caller of
;	this routine to find out why.  This is not a test
;	routine.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Error Code if any
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if Unit no ready.
;
;*******************************************************

				EXPORT	test_unit_rdy
test_unit_rdy	PROC
									;
									; Set Internal Command Flag
									;
				dec		|internal
									;
									; Set Parm Pointer.
									;
				lda		#@test_unit_p
				sta		<scsi_mdrvr
				lda		#^@test_unit_p
				sta		<scsi_mdrvr+2
									;
									; It's a Status Call.
									;
				lda		#scsit_stat
				sta		|call_type
									;
									; Issue the Call
									;
				jmp		|main_drvr
									;
									; Data for this call
									; TEST UNIT READY Command Packet
									;
@test_unit_p	dc.b	$00			;Command Number
				dc.b	$00			;SCSI Command Flags
				dcb.b	3,$00		;Reserved
				dc.b	$00			;Vendor Unique
				dcb.b	6,$00		;Resrved

				ENDP

				EJECT

;*******************************************************
;
;	'CHK_PLAY_MODE'
;
;	This command is used to tell if the device is
;	currently in Audio Play Mode.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Error Code if any
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set not in play mode
;
;*******************************************************

;-------------------------------------------------------------------------------

				IF		scsi_dtype = apple_cd	THEN

				EXPORT	chk_play_mode
chk_play_mode	PROC
										;
										; First, disable auto sensing.
										;
				ldy		#dib.rslt_ptr
				lda		[dib_ptr],y
				pha
				lda		#null
				sta		[dib_ptr],y

				ldy		#dib.rslt_ptr+2
				lda		[dib_ptr],y
				pha
				lda		#null
				sta		[dib_ptr],y
										;
										; Set Internal Command Flag
										;
				dec		|internal
										;
										; Set Parm length.
										;
				lda		#$0006
				sta		<rqst_cnt
				stz		<rqst_cnt+2
										;
										; Set Parm Pointer.
										;
				lda		#@chk_play
				sta		<scsi_mdrvr
				lda		#^@chk_play
				sta		<scsi_mdrvr+2
										;
										; Set Buff Pointer.
										;
				lda		#@play_data
				sta		<buff_ptr
				lda		#^@play_data
				sta		<buff_ptr+2
										;
										; It's a Status Call.
										;
				lda		#scsit_stat
				sta		|call_type
										;
										; Issue the Call
										;
				jsr		|main_drvr
				bcs		@restore_dp		;Carry is set.  Not play mode
										;
										; Check the Status.
										;
										; Status $00 = In play mode
										;		 $01 = Pause (Play Mode)
										;		 $02 = Muting (Play Mode)
										;
										;		 $03 = Play completed (No Play)
										;		 $04 = Error (No Play)
										;		 $05 = Play not requested.
										;
				lda		@play_data
				and		#$0007
				cmp		#$0003			; <3 = Carry Clear. =>3 = Carry set
										;
										; Restore the Direct Page Values.
										;
@restore_dp		php
				jsr		set_our_dp
				plp
										;
										; Restore Auto Sensing Pointer.
										;
				ldy		#dib.rslt_ptr+2
				pla
				sta		[dib_ptr],y

				ldy		#dib.rslt_ptr
				pla
				sta		[dib_ptr],y

				rts
										;
										; AUDIO STATUS Command Packet
										;
@chk_play		dc.b	$cc				;Command Number
				dc.b	null			;SCSI Command Flags
				dcb.b	10,null			;Reserved
										;
										; Data received for this call
										;
@play_data		dcb.b	6,null

				ENDP

				ENDIF

;-------------------------------------------------------------------------------

				EJECT

;*******************************************************
;
;	The REQUEST SENSE Call is used to request any
;	information from the target device that might tell
;	us something about the way that the last call
;	competed.  This call should always be issued if any
;	SCSI Command returns from the SCSI Manager with a
;	CHECK CONDITION in the status result field.  The
;	data returned will be kept until the next REQUEST
;	SENSE Command is issued.  A flag however will be set
;	if any other commands are received by the SCSI Driver
;	indicating that this data is outdated.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Error Code if any
;				|sense_data	=	Data returned by the device
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if Unit no ready.
;
;*******************************************************

				EXPORT	rqst_sense
rqst_sense		PROC
									;
									; Set Internal Command Flag
									;
				dec		|internal
									;
									; Set Parm Pointer.
									;
				lda		#@rqst_sens_p
				sta		<scsi_mdrvr
				lda		#^@rqst_sens_p
				sta		<scsi_mdrvr+2
									;
									; Preserve the Current Direct
									; Page values stored in the
									; buff_ptr and rqst_cnt fields.
									;
				pei		<buff_ptr
				pei		<buff_ptr+2
				pei		<rqst_cnt
				pei		<rqst_cnt+2
									;
									; Set our own buffer pointer
									; for this call.
									;
				lda		#sense_data
				sta		<buff_ptr
				lda		#^sense_data
				sta		<buff_ptr+2
									;
									; Set our own request count
									; for this call.
									;
				lda		#$0010
				sta		<rqst_cnt
				stz		<rqst_cnt+2
									;
									; It's a Status Call.
									;
				lda		#scsit_stat
				sta		|call_type
									;
									; Issue the Call
									;
				stz		@error
				jsr		|main_drvr
				bcc		@return_dp
									;
									; Save error code
									;
				sta		@error
									;
									; Restore the Direct Page Values.
									;
@return_dp		pla
				sta		<rqst_cnt+2
				pla
				sta		<rqst_cnt
				pla
				sta		<buff_ptr+2
				pla
				sta		<buff_ptr
									;
									; Restore the Acc resutl.
									;
				lda		@error
				cmp		#$0001
				rts
									;
									; Data for this call
									;
@error			dc.w	null
									;
									; REQUEST SENSE Command Packet
									;
@rqst_sens_p	dc.b	$03			;Command Number
				dc.b	$00			;SCSI Command Flags
				dcb.b	3,$00		;Reserved
				dc.b	$00			;Vendor Unique
				dcb.b	6,$00		;Reserved

				ENDP

				EJECT

;*******************************************************
;
;	'reserve_unit'
;
;	The RESERVE UNIT Call is used to reserve the target
;	device for use by this host only.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Error Code if any
;				|sense_data	=	Data returned by the device
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if Unit already reserved.
;
;*******************************************************

				EXPORT	reserve_unit
reserve_unit	PROC


				lda		#null
				clc
				rts

				ENDP

				EJECT

;*******************************************************
;
;	'release_unit'
;
;	The RELEASE UNIT Call is used to release the target
;	device from use by this host only.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Error Code if any
;				|sense_data	=	Data returned by the device
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	release_unit
release_unit	PROC

				lda		#null
				clc
				rts

				ENDP

				EJECT
			
;*******************************************************
;
;	'mode_sense'
;
;	This routine issues an MODE SENSE call to the device.
;		
;	Inputs:		<dib_ptr	=	DIB start			(LONG)
;				Acc			=	Unspecified
;				Carry		=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Carry		=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	mode_sense
mode_sense		PROC
										;
										; Initialize the Page code to 1
										;
				lda		#$0001
				sta		@page_code
										;
										; Set internal command flag
										;
@try_again		dec		|internal
										;
										; Tell the Main Driver where
										; our command structure resides.
										;
				lda		#@start_mode
				sta		<scsi_mdrvr
				lda		#^@start_mode
				sta		<scsi_mdrvr+2
										;
										; And our buffer
										;
				lda		#internal_buff
				sta		<buff_ptr
				lda		#^internal_buff
				sta		<buff_ptr+2
										;
										; And our length of $ff Bytes
										;
				lda		#$0014
				sta		<rqst_cnt
				stz		<rqst_cnt+2
										;
										; Set the Call Type and Issue the
										; MODE SENSE Command.
										;
				lda		#scsit_stat
				sta		|call_type
				jsr		|main_drvr
				bcc		@rts
				pha
				lda		@page_code
				beq		@pla
				pla
				stz		@page_code
				bra		@try_again
				
@pla			pla
@rts			rts
										;
										; Data for the MODE SENSE Command
										;
@start_mode		dc.b	$1a
				dc.b	$00
@page_code		dc.b	$01
				dcb.b	9,$00

				ENDP

				EJECT
			
;*******************************************************
;
;	'read_capacity'
;
;	This routine issues an READ CAPACITY call to the
;	device and then uses the data returned to fill in
;	some of the blank holes in the DIB.
;		
;	Inputs:		<dib_ptr	=	DIB start			(LONG)
;				Acc			=	Unspecified
;				Carry		=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Carry		=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	read_capacity
read_capacity	PROC

;-------------------------------------------------------------------------------

				IF			block_dvc = true\
				AND			character_dvc = false		THEN
										;
										; Set internal command flag
										;
				dec		|internal
										;
										; Tell the Main Driver where
										; our command structure resides.
										;
				lda		#@read_cap
				sta		<scsi_mdrvr
				lda		#^@read_cap
				sta		<scsi_mdrvr+2
										;
										; And our buffer
										;
				lda		#internal_buff
				sta		<buff_ptr
				lda		#^internal_buff
				sta		<buff_ptr+2
										;
										; And our length of $ff Bytes
										;
				lda		#$0008
				sta		<rqst_cnt
				stz		<rqst_cnt+2
										; Set the Call Type and Issue the
										; READ CAPACITY Command.
										;
				lda		#scsit_stat
				sta		|call_type
				jsr		|main_drvr
				rts
										;
										; Data for the READ CAPACITY Command
										;
@read_cap		dc.b	$25
				dcb.b	11,$00

				ELSE

;-------------------------------------------------------------------------------

				lda		#null
				clc
				rts

				ENDIF

;-------------------------------------------------------------------------------

				ENDP

				EJECT

;*******************************************************
;
;	'get_data_status'
;
;	The GET DATA STATUS Call is used to find out how
;	much data is available to be read from the Scanner.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Error Code if any
;				|sense_data	=	Data returned by the device
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	get_data_status
get_data_status	PROC


				lda		#null
				clc
				rts

				ENDP

				EJECT

;____Dvc_Controls____
;*******************************************************
;
;	'start_unit'
;
;	Issue a START UNIT Command to the target device
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Error Code if any
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None
;
;*******************************************************

				EXPORT	start_unit
start_unit		PROC

;-------------------------------------------------------------------------------

				IF			scsi_dtype = direct_acc	THEN

				ldy		#dib.dvcchar
				lda		[dib_ptr],y
				and		#removable
				bne		@do_it
				rts

@do_it

				ELSE

;-------------------------------------------------------------------------------

										;
										; Set Stop Flag
										;
				lda		#$0001
				tsb		|stop_bit
				bra		start_stop

				ENDIF

;-------------------------------------------------------------------------------

				EJECT

;*******************************************************
;
;	'stop_unit'
;
;	Issue a STOP UNIT Command to the target device
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Error Code if any
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		None
;
;*******************************************************

				EXPORT	stop_unit
stop_unit

;-------------------------------------------------------------------------------

				IF			scsi_dtype = direct_acc	THEN

				ldy		#dib.dvcchar
				lda		[dib_ptr],y
				and		#removable
				bne		@do_it
				rts

@do_it

				ELSE

;-------------------------------------------------------------------------------

									;
									; Set Stop Flag
									;
				lda		#$0001
				trb		|stop_bit
									;
									; Secondary entry point for START_UNIT
									; Command
									;
				EXPORT	start_stop
start_stop
									;
									; Set Internal Command Flag
									;
				dec		|internal
									;
									; Set Parm Pointer.
									;
				lda		#@start_stop_p
				sta		<scsi_mdrvr
				lda		#^@start_stop_p
				sta		<scsi_mdrvr+2
									;
									; Set IMMED Bit
									;
				lda		#immed_loc
				tsb		@immed_loc
									;
									; It's a Control Call.
									;
				lda		#scsit_cont
				sta		|call_type
									;
									; Issue the Call
									;
				jmp		|main_drvr
									;
									; Data for this call
									; TEST UNIT READY Command Packet
									;
@start_stop_p	dc.b	$1B			;Command Number
@immed_loc		dc.b	$00			;SCSI Command Flags
				dcb.b	2,$00		;Reserved
				EXPORT	stop_bit
stop_bit		dc.b	$00			;Start/Stop Bit
				dc.b	$00			;Vendor Unique
				dcb.b	6,$00		;Resrved

				ENDIF

;-------------------------------------------------------------------------------

				ENDP

				EJECT

;*******************************************************
;
;	'SET 512 MODE'
;
;	This command is used to tell the device to set it's
;	block size to 512 mode.  This is used for the CD-ROM
;	Drives as well as any others that may need this
;	function.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Error Code if any
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if call failed
;
;*******************************************************

				EXPORT	set_512_mode
set_512_mode	PROC

;-------------------------------------------------------------------------------

				IF			block_dvc = true\
				AND			character_dvc = false		THEN
										;
										; Set try twice flag.
										;
				dec		@try_twice
										;
										; Set Internal Command Flag
										;
				dec		|internal
										;
										; Set Parm length.
										;
				lda		#end_4_512-\
						data_4_512
				sta		<rqst_cnt
				stz		<rqst_cnt+2
										;
										; Set Parm Pointer.
										;
@try_again		lda		#@set_512_p
				sta		<scsi_mdrvr
				lda		#^@set_512_p
				sta		<scsi_mdrvr+2
										;
										; Set Parm Pointer.
										;
				lda		#data_4_512
				sta		<buff_ptr
				lda		#^data_4_512
				sta		<buff_ptr+2
										;
										; It's a Control Call.
										;
				lda		#scsit_cont
				sta		|call_type
										;
										; Issue the Call
										;
				jsr		|main_drvr
				bcc		@alles_klar
										;
										; Set Parm length.
										;
				lda		#$0000000c
				sta		<rqst_cnt
				stz		<rqst_cnt+2

				inc		@try_twice
				beq		@try_again
										;
										; Restore the values we destroyed
										;
@alles_klar		stz		@try_twice
				php
				pha
				jsr		set_our_dp
				pla
				plp
				rts
										;
										; Data for this call
										;
@try_twice		dc.w	null
										;
										; TEST UNIT READY Command Packet
										;
@set_512_p		dc.b	$15				;Command Number

;-------------------------------------------------------------------------------

				IF		scsi_dtype = direct_acc	THEN
										;
										; Set bit to save these values
										;
				dc.b	$01

				ENDIF					;scsi_dtype = direct_acc

;-------------------------------------------------------------------------------

				IF		scsi_dtype = apple_cd	THEN
										;
										; Clear bit to save these values
										;
				dc.b	$00

				ENDIF					;scsi_dtype = apple_cd

;-------------------------------------------------------------------------------

				dcb.b	3,$00			;Reserved
				dc.b	$00				;Vendor Unique
				dcb.b	6,$00			;Resrved
										;
										; Data sent durring this call
										;
data_4_512		dc.b	null
				dc.b	$00
				dc.b	null
				dc.b	$08
										;number of blocks
				dc.b	null
				dc.b	$00
				dc.b	$00
				dc.b	$00
										;block size
				dc.b	null
				dc.b	$00
				dc.b	$02
				dc.b	$00

;-------------------------------------------------------------------------------

				IF		scsi_dtype = apple_cd	THEN

end_4_512

				EXPORT		select_page_num
select_page_num	dc.b	$01				;Page Number
				dc.b	$06				;Page Length
				dc.b	$e4				;Error Correction Flags
				dc.b	$03				;Retry Count
				dc.b	$00				;Correction Span
				dc.b	$00				;Head Offset Count
				dc.b	$00				;Data Strobe Offset
				dc.b	$00				;Recovery Time Limit

				ELSE					;scsi_dtype = apple_cd

;-------------------------------------------------------------------------------

										;Page 1 Data
				EXPORT		select_page_num
select_page_num	dc.b	$01				;Page Number
				dc.b	$06				;Page Length
				dc.b	$e4				;Error Correction Flags
				dc.b	$03				;Retry Count
				dc.b	$00				;Correction Span
				dc.b	$00				;Head Offset Count
				dc.b	$00				;Data Strobe Offset
				dc.b	$00				;Recovery Time Limit
end_4_512

				ENDIF					;scsi_dtype = apple_cd

;-------------------------------------------------------------------------------

				ELSE					;block_dvc = true

;-------------------------------------------------------------------------------

				lda		#null
				clc
				rts

				ENDIF					;block_dvc = true

;-------------------------------------------------------------------------------

				ENDP

				EJECT

;____Evnt_Support____
;*******************************************************
;
;	'notify_me'
;
;	This routine gets called by the SCSI Manager when
;	some event occurs that is out of the ordinary.
;
;	Inputs:		None Yet
;
;	Outputs:	All Regs	=	Scrambled
;
;	Errors:		None Yet
;
;*******************************************************

				EXPORT	notify_me
notify_me		PROC
										;
										; Vector for the SCSI Manager
										; to call when an event occurs
										; that affects my DIB
										; structures.  This could be a
										; new device online or media
										; insertion.
										;
				clc						;Add CODE LATER
				rtl

				ENDP

				EJECT

;____Misc_Support____
;*******************************************************
;
;	SET_DISK_SW
;
;	This routine checks the validity of the partition
;	map block currently loaded in the internal buffer.
;	This need only be called once per device.  If the
;	map is valid, then the carry will be clear.  The 'Z'
;	flag will also be set if this is not the first time
;	that this routine was called for this device.  If
;	the carry is set, then the map was invalid and the
;	block count at 'T_DVC_BLOCKS' has been placed in the
;	DIB pointed to by 'DIB_PTR'.  The starting block will
;	also have been set to null.
;
;	Inputs:		<DIB_PTR		=	DIB Location
;				Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Outputs:	Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;								=	Z = 0 if routine called before
;								=	C = 1 if not a partition map
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Errors:		Only those allowed by the System Service
;				Call SET_DISKSW.
;
;*******************************************************

				EXPORT	set_disk_sw
set_disk_sw		PROC

;-------------------------------------------------------------------------------

				IF			block_dvc = true\
				AND			character_dvc = false		THEN
										;
										; Check the removable flag.  If the media
										; is removable, then we will only set the
										; switch flag and let the status calls do
										; their thing before this device goes
										; online.  If it is non-removable, then
										; we need to say that the device is
										; switched, but also set the online bits.
										;
				ldy		#dib.dvcchar
				lda		[dib_ptr],y
				and		#removable
				beq		@non_removable
										;
										; Set the Disk Switched Bit in Status.
										;
				ldy		#dib.dvcflag
				lda		[dib_ptr],y
				ora		#dvc_switch
				sta		[dib_ptr],y
				bra		@over1
										;
										; Set the Disk Online Bit in Status.
										;
@non_removable	ldy		#dib.dvcflag
				lda		[dib_ptr],y
				and		#$ffff--\
						dvc_switch--\
						dvc_hardofl
				ora		#dvc_online
				sta		[dib_ptr],y
										;
										; Preserve the World from this.
										;
@over1			ldx		|gsos_dpage

				lda		>dev_num,x
				pha
				lda		>dib_ptr,x
				pha
				lda		>dib_ptr+2,x
				pha
				lda		<dev_num
				sta		>dev_num,x
				lda		<dib_ptr
				sta		>dib_ptr,x
				lda		<dib_ptr+2
				sta		>dib_ptr+2,x

				txa
				tcd

				jsl		set_disksw
				tay

				lda		|direct_page
				tcd

				ldx		|gsos_dpage
				pla
				sta		>dib_ptr+2,x
				pla
				sta		>dib_ptr,x
				pla
				sta		>dev_num,x

				tya
				cmp		#$0001
				rts

				ELSE

;-------------------------------------------------------------------------------

				lda		#null
				clc
				rts

				ENDIF

;-------------------------------------------------------------------------------

				ENDP

				EJECT

;*******************************************************
;
;	TRASH_VOLUME
;
;	This routine write a non-formatted pattern to block
;	2 of the volume whose DIB is [dib_ptr].  This is to
;	force the OS to re-format or lay down the OS data for
;	that volume rather than using what is already there
;	and appears to be valid.
;
;	Inputs:		<DIB_PTR		=	DIB Location
;				|trash_it		=	Boolean
;							0	=	Trash the Volume
;				Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Outputs:	Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	Ours
;				Data Bank		=	Ours
;
;	Errors:		Better be none.
;
;*******************************************************

				EXPORT	trash_volume
trash_volume	PROC

;-------------------------------------------------------------------------------

				IF			scsi_dtype = direct_acc	THEN

										;
										; Should we really trash the volume?
										;
				lda		|trash_it
				beq		@dont_trash
										;
										; Set Main Driver Pointer to
										; our data for the command.
										;
				lda		#@cmd_$800A
				sta		<scsi_mdrvr
				lda		#^@cmd_$800A
				sta		<scsi_mdrvr+2
										;
										; Set our buffer Pointer to
										; our data for the command.
										;
				lda		#@destructo_data
				sta		<buff_ptr
				lda		#^@destructo_data
				sta		<buff_ptr+2
										;
										; Set length of our data for the
										; command.
										;
				lda		#block_size
				sta		<rqst_cnt
				stz		<rqst_cnt+2
										;
										; Call Main Driver
										;
				lda		#scsit_cont
				sta		|call_type
										;
										; Issue the call.
										;
				jsr		check_532_rw

@dont_trash		rts

										;
										; Command Data for this call.
										;
@cmd_$800A		dc.b	$0A
				dc.b	$00
				dc.w	$0002
				dc.b	$01
				dcb.b	7,$00

@destructo_data	dcb.b	512,$6c

				ELSE

;-------------------------------------------------------------------------------

				lda		#null
				clc
				rts

				ENDIF

;-------------------------------------------------------------------------------

				ENDP

				EJECT

;*******************************************************
;
;	'SAVE_DP'
;
;	This routine is only called durring the initial
;	startup.  It saves away the current values on GS/OS
;	Direct Page so that we can use the space until we
;	have our own Direct Page.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	GS/OS
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	GS/OS
;				Data Bank	=	Ours
;
;	Errors:		None.
;
;*******************************************************

				EXPORT	save_dp
save_dp			PROC
											;
											; Check to see if this call was
											; nested.
											;
				lda		|valid
				bne		@exit
											;
											; Calculate Source Address.
											;
				clc
				lda		|gsos_dpage
				adc		#start_our_zp
				pea		$0000
				pha
											;
											; Destination Address of temporary
											; storage
											;
				pushlong	#saved_zp
				
				pushlong	#end_our_zp-\	;Length of the move
							start_our_zp
				
				pushword	#move_sinc_dinc

				jsl		move_info			;Move the data

				dec		|valid

@exit			rts

				ENDP

				EJECT

;*******************************************************
;
;	Move the contents of the first $20 bytes of GS/OS
;	Direct Page to our Direct Page.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if Unit is not the only
;				device in this linke that is still
;				online.
;
;*******************************************************

				EXPORT	restore_dp
restore_dp		PROC
											;
											; Check to see if this call was
											; nested.
											;
				lda		|valid
				beq		@exit
											;
											; Source Address of temporary
											; storage
											;
				pushlong	#saved_zp
											;
											; Calculate Destination Address.
											;
				clc
				lda		|gsos_dpage
				adc		#start_our_zp
				pea		$0000
				pha
				
				pushlong	#end_our_zp-\	;Length of the move
							start_our_zp
				
				pushword	#move_sinc_dinc

				jsl		move_info			;Move the data

				stz		|valid

@exit			rts

				ENDP

				EJECT

;*******************************************************
;
;	Move the contents of the first $20 bytes of GS/OS
;	Direct Page to our Direct Page.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Errors:		Carry set if Unit is not the only
;				device in this linke that is still
;				online.
;
;*******************************************************

				EXPORT	set_our_dp
set_our_dp		PROC
										;
										; Calculate Source Address.
										;
				clc
				lda		|gsos_dpage
				adc		#dev_num
				pea		$0000
				pha
										;
										; Calculate Destination Address of
										; our Direct Page that we want.
										;
				clc
				lda		|direct_page
				adc		#dev_num
				pea		$0000
				pha
				
				pushlong	#dib_ptr+4	;Length of the move
				
				pushword	#move_sinc_dinc

				jsl		move_info		;Move the data
				rts
				ENDP

				EJECT

;*******************************************************
;
;	'check_532_rw'
;
;	There are a few drives that have been formated with
;	512 ($214) bytes per block.  These devices work
;	perfectly fine in single block I/O, padding the end
;	with 20 bytes in a write, or stripping them for a
;	read, but when doing a multi-block transaction we
;	need to account for the 20 bytes between the end of
;	real data for this block and the beginning of the
;	next block.  Because of this, we will need to build
;	a data chaining structure that will read or write
;	512 bytes of data to the users buffer, followed by
;	20 bytes read or written to ROM space.  Doing this
;	will hinder performance and will prevent caching
;	from working.  If these are important to the user,
;	they can reformat their drive.
;
;	This routine is called in place of calling the Main
;	Driver.  It decides if the call should go via the
;	normal or 532 method.  All Inputs, Outputs and Setup
;	Structures are the same.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	GS/OS Direct Page
;				Data Bank	=	Ours
;
;	Errors:		None
;
;*******************************************************

				EXPORT	check_532_rw
check_532_rw	PROC

;-------------------------------------------------------------------------------

				IF			scsi_dtype = direct_acc	THEN

										;
										; Check for 532 byte block.
										;
				ldy		#dib.blksize
				lda		[dib_ptr],y
				cmp		#$214
				beq		@do_532
				jmp		|main_drvr

@do_532			jmp		munge_532

;-------------------------------------------------------------------------------

				ELSE

				jmp		|main_drvr

				ENDIF

;-------------------------------------------------------------------------------

				ENDP

				EJECT

;*******************************************************
;
;	'munge_532'
;
;	There are a few drives that have been formated with
;	512 ($214) bytes per block.  These devices work
;	perfectly fine in single block I/O, padding the end
;	with 20 bytes in a write, or stripping them for a
;	read, but when doing a multi-block transaction we
;	need to account for the 20 bytes between the end of
;	real data for this block and the beginning of the
;	next block.  Because of this, we will need to build
;	a data chaining structure that will read or write
;	512 bytes of data to the users buffer, followed by
;	20 bytes read or written to ROM space.  Doing this
;	will hinder performance and will prevent caching
;	from working.  If these are important to the user,
;	they can reformat their drive.
;
;	This routine is called in place of calling the Main
;	Driver.  All Inputs, Outputs and Setup Structures
;	are the same.
;
;	Inputs:		Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	Ours
;				Data Bank	=	Ours
;
;	Outputs:	Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	GS/OS Direct Page
;				Data Bank	=	Ours
;
;	Errors:		None
;
;*******************************************************

				EXPORT	munge_532
munge_532		PROC

;-------------------------------------------------------------------------------

				IF			scsi_dtype = direct_acc	THEN

										;
										; Set User's buffer location
										;
				lda		<buff_ptr
				sta		|@User_buff
				lda		<buff_ptr+2
				sta		|@User_buff+2
										;
										; Generate a block count.
										;
				stz		@block_cnt
				lda		<rqst_cnt+2
				sta		@block_cnt+1
				lda		<rqst_cnt
				and		#$fe00
				cmp		<rqst_cnt
				beq		@equal_512

				lda		#drvr_bad_cnt
				sec
				rts

@equal_512		lsr		@block_cnt+1
				ror		a
				tsb		@block_cnt-1
										;
										; Adjust users request cnt to reflect
										; that there are 20 bytes/block more
										; to transfer than the user requested.
										; This is done by multiplying the block
										; count that we just calculated bu $14.
										;
										; First preserve the old value.
										;
				lda		<rqst_cnt+2
				sta		@rqst_cnt+2
				lda		<rqst_cnt
				sta		@rqst_cnt
										;
										; Now adjust count.
										;
				lda		@block_cnt+2
				sta		|scratch0+2
				lda		@block_cnt
				sta		|scratch0
										;
										; x4 first
										;
				asl		|scratch0		;x2
				asl		|scratch0+2

				asl		|scratch0		;x2 (x4)
				asl		|scratch0+2
										;
										; Save the x4.
										;
				lda		|scratch0
				sta		|scratch2
				lda		|scratch0+2
				sta		|scratch2+2
										;
										; Finish the x16
										;
				asl		|scratch0		;x2 (x8)
				asl		|scratch0+2

				asl		|scratch0		;x2 (x16)
				asl		|scratch0+2
										;
										; Add the x4 to x16 for x20
										;
				clc
				lda		|scratch0
				adc		|scratch2
				sta		|scratch0
				lda		|scratch0+2
				adc		|scratch2+2
				sta		|scratch0+2
										;
										; Add the x20 to the original
										; request count.
										;
				clc
				lda		|scratch0
				adc		<rqst_cnt
				sta		<rqst_cnt
				lda		|scratch0+2
				adc		<rqst_cnt+2
				sta		<rqst_cnt+2
										;
										; Preserve the data pointer currently
										; used in the DIB and replace it with
										; a pointer to our 532 byte block
										; Data Chaining instructions.
										;
				clc
				ldy		#dib.trx_ptr
				lda		[dib_ptr],y
				sta		|dib_data_struct

				lda		#@munger_DC
				sta		[dib_ptr],y

				ldy		#dib.trx_ptr+2
				lda		[dib_ptr],y
				sta		|dib_data_struct+2

				lda		#^@munger_DC
				sta		[dib_ptr],y
										;
										; Preserve the Block size and replace
										; it with $0214
										;
				lda		<blk_size
				sta		@blk_size
				lda		#$0214
				sta		<blk_size
										;
										; Issue the call.
										;
				jsr		|main_drvr
										;
										; Preserve the result.
										;
				pha
				php
										;
										; Restore the Block size.
										;
				lda		@blk_size
				sta		<blk_size
										;
										; Restore DIB's data pointer.
										;

				ldy		#dib.trx_ptr
				lda		|dib_data_struct
				sta		[dib_ptr],y

				ldy		#dib.trx_ptr+2
				lda		|dib_data_struct+2
				sta		[dib_ptr],y
										;
										; Restore the original request count.
										;
				lda		@rqst_cnt+2
				sta		<rqst_cnt+2
				lda		@rqst_cnt
				sta		<rqst_cnt
										;
										; Restore state of the call's exit.
										;
				plp
				pla
										;
										; Exit.
										;
				rts
										;
										; Temp Storage area.
										;
@rqst_cnt		dc.l	null
@blk_size		dc.w	null

@munger_DC								;
										; Data Chaining Structure.
										;
@User_buff		dc.l	$00000000		;Users Buffer Space
				dc.l	$00000200		;Request Count
				dc.l	$00000200		;Add to buffer at each pass
				dc.l	$00000000		;Reserved.

				dc.l	$00ff0600		;Location for spare bytes (ROM)
				dc.l	$00000014		;Number of bogus bytes
				dc.l	$00000000		;Leave buffer pointer alone
				dc.l	$00000000		;Reserved.

				dc.l	$ffffffff		;Looping Command
@block_cnt		dc.l	$00000000		;Block Count
				dc.l	$00000000-2		;Go Back 2 commands
				dc.l	$00000000		;Reserved

				dc.l	$00000000		;DCStop Command
				dc.l	$00000000		;DCStop Command
				dc.l	$00000000		;DCStop Command
				dc.l	$00000000		;DCStop Command

				dc.l	$00000000		;Safety space

;-------------------------------------------------------------------------------

				ELSE

				lda		#null
				clc
				rts

				ENDIF

;-------------------------------------------------------------------------------

				ENDP

				EJECT

;*******************************************************
;
;	'divide'
;
;	This routine divides a 16 bit number stored in
;	'divsor' into the 32 bit number stored in 'divend'.
;	The result will be in 'result' if no error occured.
;	If 'divend' is not an integral multiple of 'divsor'
;	an error will be returned.
;
;	Inputs:		'divsor'		=	16 bit number
;				'divend'		=	32 bit number
;				'max_blk_cnt'	=	Max Result Allowed
;				Acc				=	Unspecified
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	GS/OS Direct Page
;				Data Bank		=	Ours
;
;	Outputs:	'result'		=	result of division
;				Acc				=	Error Code if Carry Set
;				'max_blk_cnt'	=	null if no error
;									Intact if an error is returned
;				Y register		=	Unspecified
;				X register		=	Unspecified
;				P register		=	0=M=X=e
;				Direct Page		=	GS/OS Direct Page
;				Data Bank		=	Ours
;
;	Errors:		Carry set if non-integral result
;
;*******************************************************

				EXPORT	divide
divide			PROC

;-------------------------------------------------------------------------------

				IF			block_dvc = true\
				AND			character_dvc = false		THEN
												;
												; Clear Result field
												;
				stz		|result
				stz		|result+2
												;
												; 32 bits in result.
												;
				ldx		#32-1
												;
												; Make 'divsor' an odd value.
												; This is nothing more than
												; deviding both numbers by 16
												; until 'divsor' is an odd value.
												; If any bits roll out of 'divend'
												; then this was an incorrect call.
												;
@div16_loop		lda		|divsor
				cmp		#block_size				;Special Case /block_size
				bne		@not_512
				lda		|divend
				and		#block_size-1
				bne		@error

;-------------------------------------------------------------------------------

				IF			scsi_dtype = direct_acc	THEN
												;
												; Quick Divide by block_size
												;
				lda		|divend+3
				and		#$00ff
				lsr		a
				sta		|result+2

				lda		|divend+1
				ror		a
				sta		|result

				jmp		@chk_rslt

				ENDIF

;-------------------------------------------------------------------------------

				IF			scsi_dtype = apple_cd	THEN
												;
												; Quick Divide by $0200
												;
				lda		|divend+3
				and		#$00ff
				lsr		a
				sta		|result+2

				lda		|divend+1
				ror		a
				sta		|result

				jmp		@chk_rslt

				ENDIF

;-------------------------------------------------------------------------------

@not_512		and		#bit_0
				bne		@do_divide
				lsr		|divsor
				lsr		|divend+2
				ror		|divend
				bcc		@div16_loop
				bra		@error
												;
												; Main division loop.  We will
												; continue to divide the divsor
												; by 16 until finished.  Each
												; time that divsor becomes odd,
												; we will subtract divend and
												; roll a bit into the high end
												; of result.
												;
@do_divide		lda		|divend
				and		#bit_0
				clc								;We must clear the carry incase
				beq		@do_div16				;the branch is taken.
												;
												; We are odd. Do the subtraction.
												;
				sec
				lda		|divend
				sbc		|divsor
				sta		|divend
				lda		|divend+2
				sbc		#$0000
				sta		|divend+2
				bcc		@error					;If this is taken, bad data.
												;
												; Divide both the divsor and 
												; results by 16.  The carry will
												; roll into the reult from the
												; high bit end.
												;
@do_div16		php
				lsr		|divend+2
				ror		|divend
				plp
@clean_up		ror		|result+2
				ror		|result
												;
												; Have we done 32 bits yet?
												;
				dex
				bmi		@chk_rslt				;Yes.
												;
												; No we havent.  If divsor is
												; non-zero then do next itteration.
												; If it is = zero then clean up
												; result and exit.
												;
				lda		|divend+2
				ora		|divend
				bne		@do_divide
												;
												; Clean up Result.
												;
				clc
				bra		@clean_up
												;
												; Here for bcs offset.
												;
@error			sec
				lda		#drvr_bad_cnt
				rts
												;
												; Check to see if the result is within
												; the max.
												;
@chk_rslt		lda		|max_blk_cnt
				ora		|max_blk_cnt+2
				beq		@out

				sec
				lda		|max_blk_cnt
				sbc		|result
				sta		@temp
				lda		|max_blk_cnt+2
				sbc		|result+2
				bge		@clean
												;
												; Exit
												;
				sec
				lda		#drvr_bad_parm
				rts

@clean			stz		|max_blk_cnt
				stz		|max_blk_cnt+2
@out			clc
				rts
													;
													; Data Area.
													;
@temp			dc.w	null

				ELSE

;-------------------------------------------------------------------------------

				lda		#null
				clc
				rts

				ENDIF

;-------------------------------------------------------------------------------

				ENDP

				EJECT

;*******************************************************
;
;	'calc_bytes'
;
;	This routine Multiplies a 16 bit number stored in
;	'm_blk_size' by a 32 bit number stored in 'm_blk_cnt'.
;	The result will be in 'm_rslt'.
;
;	Inputs:		'm_blk_size'=	16 bit Block Size
;				'm_blk_cnt'	=	32 bit Block Count
;				Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	GS/OS Direct Page
;				Data Bank	=	Ours
;
;	Outputs:	'm_rslt'	=	result of division
;				Acc			=	Unspecified
;				Y register	=	Unspecified
;				X register	=	Unspecified
;				P register	=	0=M=X=e
;				Direct Page	=	GS/OS Direct Page
;				Data Bank	=	Ours
;
;	Errors:		None
;
;*******************************************************

				EXPORT	calc_bytes
calc_bytes		PROC

;-------------------------------------------------------------------------------

				IF			block_dvc = true\
				AND			character_dvc = false		THEN
											;
											; Clear Result field
											;
				stz		|m_rslt
				stz		|m_rslt+2
											;
											; Check 'm_blk_size' against the block
											; size for this device.  If it is Equal,
											; the do cheap processing.  Otherwise do
											; full multiply logic.
											;
@div16_loop		lda		|m_blk_size
				cmp		#block_size			;Special Case *block_size
				bne		@not_512

;-------------------------------------------------------------------------------

				IF			scsi_dtype = direct_acc	THEN
											;
											; Quick Multiply by $0200
											;
				lda		|m_blk_cnt
				asl		a
				sta		|m_rslt+1

				lda		|m_blk_cnt+2
				and		#$007f
				rol		a
				ora		|m_rslt+3			;Watch out for that +4 value.
				sta		|m_rslt+3			;It doesn't belong to us.

				jmp		@clean

				ENDIF

;-------------------------------------------------------------------------------

				IF			scsi_dtype = apple_cd	THEN
											;
											; Quick Multiply by $0200
											;
				lda		|m_blk_cnt
				asl		a
				sta		|m_rslt+1

				lda		|m_blk_cnt+2
				and		#$007f
				rol		a
				ora		|m_rslt+3			;Watch out for that +4 value.
				sta		|m_rslt+3			;It doesn't belong to us.

				jmp		@clean

				ENDIF

;-------------------------------------------------------------------------------

@not_512
											;
											; Actual Multiply Loop.
											;
				lsr		|m_blk_size
				bcc		@shift_cnt			;Don't Add this one.
											;
											; Add in Current Byte Count.
				clc
				lda		|m_rslt
				adc		|m_blk_cnt
				sta		|m_rslt
				lda		|m_rslt+2
				adc		|m_blk_cnt+2
				sta		|m_rslt+2
											;
											; Multiply Count by 2.
											;
@shift_cnt		asl		|m_blk_cnt
				rol		|m_blk_cnt+2

				lda		|m_blk_size
				bne		@not_512			;only do till 0  ( <16 times )
											;
											; Clean Exit.
											;
@clean			clc
				rts

				ELSE

;-------------------------------------------------------------------------------

				lda		#null
				clc
				rts

				ENDIF

;-------------------------------------------------------------------------------

				ENDP

				EJECT

				END