Apple-2-SW/antoine-source
1
0
Fork 0
mirror of https://github.com/antoinevignau/source.git synced 2024-11-19 22:31:52 +00:00
Code Issues Projects Releases Wiki Activity
2f23dd37a0
antoine-source/scsi2/SCSI.Drivers/SCSI Driver Mgmt
Antoine Vignau d29484938c Our SCSI-2 Audio Driver 
What we wrote to make audio hearable on a SCSI-2 CD-ROM drive ;-)
2023-03-08 10:15:14 +01:00

1 line
163 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

;*******************************************************
;
; 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 stat_cont
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 rpm_blk_num
; ENTRY wpm_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 mode_sense
ENTRY mode_sense2
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++\
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
;
; Undocumented feature. Store the SCSI
; Managers Direct Page in the Default DIB
; for external Access.
;
clc
adc #$0100
sta >default_dib+dib.handle
;
; 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 |rpm_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.
;
@single jsr no_partition ;Marks DIB as online and switched also.
jsr trash_volume ;Trash the volume if caller wishes.
;See |trash_it flag in trash_volume
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
;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
IF scsi_dtype = mcd_40\
OR scsi_dtype = direct_acc THEN
jsr mode_sense
lda |internal_buff+1
bpl @write_enable
@write_protect ldy #dib.dvcchar
lda [dib_ptr],y
and #write_allow--\
$ffff
bra @wp_chk
@write_enable ldy #dib.dvcchar
lda [dib_ptr],y
ora #write_allow
@wp_chk sta [dib_ptr],y
lda #$0000
ENDIF
;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
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 |rpm_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
;-------------------------------------------------------------------------------
IF scsi_dtype = direct_acc THEN
;
; Set the Write Allow/Read Allow
; Mask byte to allow all bits to pass.
;
; This is used to filter or strip out the
; Write Enable bit in the case where the
; DIB Status says that the partition is
; write enabled but the disk is physically
; write protected. This can happen with a
; Partitioned Syquest Drive.
;
lda #$ffff
sta @mask_flag
;
; Is the device Removable?
;
ldy #dib.dvcchar
lda [dib_ptr],y
and #removable
beq @non_remove ;No.
;
; Issue the MODE SENSE Call to see if
; Write Protected.
;
jsr mode_sense2 ;Issue call to use Sense Buffer
bcs @non_remove
;
; Check the Write Protected Bit.
;
lda |sense_data+\
mode.w_protect-1 ;But bit in Hi Byte
bpl @non_remove
;
; Set the Write Allow/Read Allow
; Mask byte to filter the Write Allow out.
;
lda #write_allow--\
$ffff
sta @mask_flag
;
; Set the Characteristics to Match the
; Read and Write Enables in the Partition
; Status Field.
;
@non_remove lda |pm.PartStatus+2\
+internal_buff
xba
and #vconf_wr_enable++\
vconf_rd_enable
asl a
sta @temp
ldy #dib.dvcchar
lda [dib_ptr],y
and #write_allow++\
read_allow--\
$ffff
ora @temp
and @mask_flag
sta [dib_ptr],y
ENDIF
;-------------------------------------------------------------------------------
;
; 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
;
; Preserve the Handle for this RAM Segment.
; Otherwise it will be destroyed by the
; dibicise routine.
;
ldy #dib.handle+2
lda [next_dib],y
pha
ldy #dib.handle
lda [next_dib],y
pha
;
; Preserve the current Device Flags.
;
ldy #dib.dvcflag
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 current Device Flags.
;
pla
ldy #dib.dvcflag
sta [next_dib],y
;
; Restore the Handle for this RAM.
; Otherwise it is destroyed by the
; dibicise routine.
;
pla
ldy #dib.handle
sta [next_dib],y
pla
ldy #dib.handle+2
sta [next_dib],y
;
; Restore the Link Pointer. Otherwise
; it is destroyed by the dibicise
; routine.
;
pla
ldy #dib.linkptr+2
sta [next_dib],y
pla
sta [next_dib]
;
; Restore the DIB Extension Pointer.
; Otherwise it is destroyed by the
; dibicise routine.
;
clc ;we are going to add
lda <next_dib ;get low word of this dib
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
lda <next_dib+2 ;get low word of this 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
;
; 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
@temp dc.w null
@mask_flag 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 |rpm_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
;-------------------------------------------------------------------------------
IF scsi_dtype = direct_acc THEN
;
; Set the Characteristics to Match the
; Read and Write Enables in the Partition
; Status Field.
;
lda |pm.PartStatus+2\
+internal_buff
xba
and #vconf_wr_enable++\
vconf_rd_enable
asl a
sta @temp
ldy #dib.dvcchar
lda [next_dib],y
and #write_allow++\
read_allow--\
$ffff
ora @temp
sta [next_dib],y
ENDIF
;-------------------------------------------------------------------------------
;
; 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
;
; Data Area
;
@temp dc.w null
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.
lda #wait_mode++\ ;New DIB. Do Cold Start and in Wait Mode.
cold_dib
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
sta [next_dib]
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 <20> 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 <20> 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
;
; Was this from a Status or Control Call?
;
bit |stat_cont
bmi @block_set
;
; 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 |rpm_blk_num
xba
inc a
xba
sta |rpm_blk_num
;
; Set internal command flag
;
@block_set stz |stat_cont ;We used the flag, now clear it.
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 rpm_blk_num
rpm_blk_num dc.w null
dcb.b 10,null
ENDP
EJECT
;*******************************************************
;
; 'write_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 write_pm_blk
write_pm_blk PROC
;
; Tell the Main Driver where
; our command structure resides.
;
lda #@write_part
sta <scsi_mdrvr
lda #^@write_part
sta <scsi_mdrvr+2
;
; And our buffer
;
lda #internal_buff
sta <buff_ptr
lda #^internal_buff
sta <buff_ptr+2
;
; And our length from the DIB's
; Block Size value
;
lda #block_size
sta <rqst_cnt
lda #^block_size
sta <rqst_cnt+2
;
; 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_cont
sta |call_type
;
; Issue the call.
;
jsr check_532_rw
@rts rts
;
; Data for the READ BLOCK Command
;
@write_part dc.b $0A
dc.b null
EXPORT wpm_blk_num
wpm_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
;
; Issue the READ CAPACITY Command.
;
no_partition 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
ldy #dib.blkcnt
sta [dib_ptr],y
lda |block.count\
+internal_buff
xba
adc #null
ldy #dib.blkcnt+2
sta [dib_ptr],y
@over_0 ldy #dib.start_blk
lda #null
sta [dib_ptr],y
ldy #dib.start_blk+2
sta [dib_ptr],y
;
; Set Read and Write Enables
;
lda >default_dib+dib.dvcchar ;Get Default Settings for
and #write_allow++\ ;Write Enable
read_allow++\ ;Read Enable
format_allow ;And Format Allowed
ldy #dib.dvcchar
ora [dib_ptr],y ;Combine with the current
sta [dib_ptr],y ;Settings for this device
;
; 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_Driver', '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
;
; Is it a Driver Partition?
;
@over_3 ldx #32-1
ldy #null
@loop_3 lda |pm.PartType\
+internal_buff,y
beq @skip ;Yes or null. Either way we skip it.
cmp @driver,y
beq @next_3
eor #'A'--'a'
cmp @driver,y
bne @over_4 ;No. Continue on.
@next_3 iny
dex
bpl @loop_3
;
; 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_4 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
@driver dc.b 'Apple_Driver'
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 rpm_blk_num
rpm_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
;
; Issue the READ CAPACITY Command.
;
no_partition 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
ldy #dib.blkcnt
sta [dib_ptr],y
lda |block.count\
+internal_buff
xba
adc #null
ldy #dib.blkcnt+2
sta [dib_ptr],y
@over_0 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
;-------------------------------------------------------------------------------
put_in_cache PROC Export
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
stz |un_formatted ;**** test Code ****
;
; 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).
;
@try_again jsr test_unit_rdy ;Is there anything that we should know about?
bcs @turdy_fail ;Yes.
@rtg brl @ready_to_go ;No.
@turdy_fail
;-------------------------------------------------------------------------------
IF scsi_dtype = direct_acc THEN
cmp #$FE16
bne @not_down
brl @off_line
@not_down
ENDIF
;-------------------------------------------------------------------------------
lda |auto_sense_data+\
rqst_sens.sense_key
beq @rtg
cmp #$ffff
beq @try_again
and #$00ff
cmp #$0006
beq @do_switch
;-------------------------------------------------------------------------------
IF scsi_dtype = direct_acc THEN
cmp #$0002
bne @on_line_hd
brl @off_line
@on_line_hd 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\
OR scsi_dtype = changer 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)
bne @on_line_cd
brl @off_line
@on_line_cd and #$00fe
cmp #$0028 ;Checking for $28 (Medium Changed), $29 (RESET)
beq @no_error_cd
brl @io_error
@no_error_cd
;
; 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
;-------------------------------------------------------------------------------
IF scsi_dtype = mcd_40 THEN
cmp #$0008 ;**** test Code ****
bne @err_8 ;**** test Code ****
@no_format dec |un_formatted ;**** test Code ****
brl @io_error ;**** test Code ****
@err_8 lda auto_sense_data+\ ;Was it a RESET?
rqst_sens.addnl_sens_code
and #$00ff
cmp #$00a7 ;Checking for $A7 (Load Error, UnFormatted)
beq @no_format
cmp #$0010 ;Checking for $10 (ID CRC Medium Error)
beq @no_format
cmp #$0011 ;Checking for $11 (Unrecovered Read Error)
beq @no_format
cmp #$0015 ;Checking for $15 (Seek Position Error)
beq @no_format
cmp #$0019 ;Checking for $19 (Defect List Error)
beq @no_format
cmp #$0031 ;Checking for $31 (Medium Format corrupted)
beq @no_format
cmp #$0032 ;Checking for $32 (No Defect Spare Location Avail.)
beq @no_format
cmp #$00a8 ;Checking for $A8 (Media being mounted)
beq @do_switch
cmp #$00b0 ;Checking for $B0 (NO MEDIA)
bne @chk_other
;
; No Media. Mark the DIB Hard Ofline also.
;
ldy #dib.dvcflag
lda [dib_ptr],y
and #dvc_online--\
$ffff
ora #dvc_hardofl++\
dvc_switch++\
dvc_hard_sw
sta [dib_ptr],y
brl @off_line
@chk_other cmp #$0028 ;Checking for $28 (Medium Changed), $29 (RESET)
bne @io_error
ENDIF
;-------------------------------------------------------------------------------
;
; Rebuild the DIBs.
;
@do_switch jsr test_unit_rdy ;Is it ready yet?
bcc @its_ready ;Yes.
;**** test Code ****
lda |auto_sense_data+\
rqst_sens.sense_key
and #$00ff
cmp #$0008
bne @not_err_8
@no_format2 dec |un_formatted
bra @its_ready
; brl @io_error
;**** test Code ****
@not_err_8 lda auto_sense_data+\ ;Is there media in the drive?
rqst_sens.addnl_sens_code
and #$00ff
cmp #$00a7 ;Checking for $A7 (Load Error, UnFormatted)
beq @no_format2
;-------------------------------------------------------------------------------
IF scsi_dtype = mcd_40 THEN
cmp #$0028 ;Checking for $28 (Medium Changed)
beq @do_switch ;Yes.
cmp #$0029 ;Checking for $29 (Power On/Reset)
beq @do_switch ;Yes.
cmp #$00A8 ;Checking for $A8 (Cart Loading)
beq @do_switch ;Yes.
cmp #$00b0 ;Checking for $B0 (NO MEDIA)
bne @no_format2 ;No.
ELSE
;-------------------------------------------------------------------------------
cmp #$00b0 ;Checking for $B0 (NO MEDIA)
bne @do_switch ;No.
; bcs @do_switch ;*************************
ENDIF
;-------------------------------------------------------------------------------
@its_ready
;-------------------------------------------------------------------------------
IF scsi_dtype <> mcd_40 THEN
jsr set_512_mode
ENDIF
;-------------------------------------------------------------------------------
;
; 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
;
; Some kind of I/O Error.
;
@io_error lda #drvr_io
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
;
; Device is currently offline.
;
@off_line lda #drvr_off_line
sec
rts
EXPORT un_formatted ;**** test Code ****
un_formatted dc.w null ;**** test Code ****
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\
OR scsi_dtype = changer 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 #$0012
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
;-------------------------------------------------------------------------------
IF scsi_dtype = scanner THEN
;
; Set Internal Command Flag
;
dec |internal
;
; Set Parm Pointer.
;
lda #@rsrv_unit_p
sta <scsi_mdrvr
lda #^@rsrv_unit_p
sta <scsi_mdrvr+2
;
; It's a Control Call.
;
lda #scsit_cont
sta |call_type
;
; Issue the Call
;
jmp |main_drvr
;
; RESERVE UNIT Command Packet
;
@rsrv_unit_p dc.b $16 ;Command Number
dc.b $00 ;SCSI Command Flags
dcb.b 3,$00 ;Reserved
dc.b $00 ;Vendor Unique
dcb.b 6,$00 ;Reserved
ELSE ;scsi_dtype = scanner
;-------------------------------------------------------------------------------
lda #null
clc
rts
ENDIF ;scsi_dtype = scanner
;-------------------------------------------------------------------------------
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
;-------------------------------------------------------------------------------
IF scsi_dtype = scanner THEN
;
; Set Internal Command Flag
;
dec |internal
;
; Set Parm Pointer.
;
lda #@rles_unit_p
sta <scsi_mdrvr
lda #^@rles_unit_p
sta <scsi_mdrvr+2
;
; It's a Control Call.
;
lda #scsit_cont
sta |call_type
;
; Issue the Call
;
jmp |main_drvr
;
; RELEASE UNIT Command Packet
;
@rles_unit_p dc.b $17 ;Command Number
dc.b $00 ;SCSI Command Flags
dcb.b 3,$00 ;Reserved
dc.b $00 ;Vendor Unique
dcb.b 6,$00 ;Reserved
ELSE ;scsi_dtype = scanner
;-------------------------------------------------------------------------------
lda #null
clc
rts
ENDIF ;scsi_dtype = scanner
;-------------------------------------------------------------------------------
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
;
; And our buffer
;
lda #internal_buff
sta <buff_ptr
lda #^internal_buff
sta <buff_ptr+2
bra command_ptr
EXPORT mode_sense2
;
; And our buffer
;
mode_sense2 lda #sense_data
sta <buff_ptr
lda #^sense_data
sta <buff_ptr+2
;
; Tell the Main Driver where
; our command structure resides.
;
command_ptr lda #@start_mode
sta <scsi_mdrvr
lda #^@start_mode
sta <scsi_mdrvr+2
;
; And our length of $ff Bytes
;
lda #$0014
sta <rqst_cnt
stz <rqst_cnt+2
;
; Initialize the Page code to 1
;
lda #$0001
sta @page_code
;
; Set internal command flag
;
@try_again dec |internal
;
; 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
;-------------------------------------------------------------------------------
IF scsi_dtype = scanner THEN
;
; Set Internal Command Flag
;
dec |internal
;
; Set Parm Pointer.
;
lda #@get_d_stat_p
sta <scsi_mdrvr
lda #^@get_d_stat_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 #$000C
sta <rqst_cnt
stz <rqst_cnt+2
;
; It's a Status Call.
;
lda #scsit_stat
sta |call_type
;
; Issue the Call
;
jsr |main_drvr
;
; 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
;
; GET DATA STATUS Command Packet
;
@get_d_stat_p dc.b $34 ;Command Number
dc.b $00 ;SCSI Command Flags
dcb.b 3,$00 ;Reserved
dc.b $00 ;Vendor Unique
dcb.b 6,$00 ;Reserved
ELSE ;scsi_dtype = scanner
;-------------------------------------------------------------------------------
lda #null
clc
rts
ENDIF ;scsi_dtype = scanner
;-------------------------------------------------------------------------------
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
;-------------------------------------------------------------------------------
IF scsi_dtype = mcd_40 THEN
;
; Set IMMED Bit
;
lda #immed_load
ELSE
;-------------------------------------------------------------------------------
;
; Set IMMED Bit
;
lda #immed_loc
ENDIF
;-------------------------------------------------------------------------------
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
;-------------------------------------------------------------------------------
IF scsi_dtype = mcd_40 THEN
clc
rts
ELSE ;scsi_dtype = mcd_40 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\
OR scsi_dtype = changer THEN
;
; Clear bit to save these values
;
dc.b $00
ENDIF ;scsi_dtype = apple_cd or changer
;-------------------------------------------------------------------------------
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\
OR scsi_dtype = changer 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 or changer
;-------------------------------------------------------------------------------
;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 or changer
;-------------------------------------------------------------------------------
ENDIF ;scsi_dtype = mcd_40
;-------------------------------------------------------------------------------
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 lda leave_switched ; *** MSG 12/12/91 ***
bmi @over1 ; *** MSG 12/12/91 ***
ldy #dib.dvcflag ; *** MSG 12/12/91 ***
;@non_removable ldy #dib.dvcflag ; *** MSG 12/12/91 ***
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
stz leave_switched ;Clear this flag *** MSG 12/12/91 ***
tya
cmp #$0001
rts
;
; Data for this call
;
EXPORT leave_switched
leave_switched dc.w null ; *** MSG 12/12/91 ***
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 Code for the data for
; the command.
;
lda #trash_volume
sta <buff_ptr
lda #^trash_volume
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.b $00
dc.b $02
dc.b $01
dcb.b 7,$00
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
;
; Drop the Loop Counter by 1.
;
sec
lda @block_cnt
sbc #$0001
sta @block_cnt
lda @block_cnt+2
sbc #$0000
sta @block_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\
OR scsi_dtype = changer 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
;-------------------------------------------------------------------------------
IF scsi_dtype = mcd_40 THEN
;
; Quick Divide by $2000
;
stz |result
stz |result+2
lda |divend+2
sta |result
lda |divend ;$2000
asl a ;$4000
rol |result ;x2
rol |result+2 ;x2
asl a ;$8000
rol |result ;x4
rol |result+2 ;x4
asl a ;$0000
rol |result ;x8
rol |result+2 ;x8
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\
OR scsi_dtype = changer 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 = mcd_40 THEN
;
; Quick Multiply by $2000
;
lda |m_blk_cnt
sta |m_rslt+2 ;Cheap * $10000
lda |m_blk_cnt+2
lsr a
ror |m_rslt+2 ;Cheap * $8000 ( * $10000/2 )
ror |m_rslt ;Cheap * $8000 ( * $10000/2 )
lsr a
ror |m_rslt+2 ;Cheap * $4000 ( * $10000/4 )
ror |m_rslt ;Cheap * $4000 ( * $10000/4 )
lsr a
ror |m_rslt+2 ;Cheap * $2000 ( * $10000/8 )
ror |m_rslt ;Cheap * $2000 ( * $10000/8 )
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
Reference in New Issue View Git Blame Copy Permalink