LST OFF ORG $1D00 ; SST.SUBS ($1D00-$23FF) USE EDD.PAGE0 USE EDD.ROM ******************************** * * * SST SUBS * * (c) Saltine * * Source by Deckard * * * ******************************** * EDD.MAIN ERSBTM EQU $1610 ; erase the 2 bottom lines of the screen * Apple II ram PARMBUFSV EQU $2500 ; backup of EDD parameters buffer (unpack with ; "your parms" option) H7800 EQU $7800 ; $7800-$93FF track buffer H9400 EQU $9400 ; $9400-$AFFF timing bit buffer * EDD.B000.B4FF CONTRLP EQU $B100 ; prewrite routine buffer LTC EQU $B230 ; lookup table for divide routine POS EQU $B280 ; original slot POD EQU $B281 ; original drive PDS EQU $B282 ; duplicate slot PDD EQU $B283 ; duplicate drive DRVCOUNT EQU $B285 ; one or two drives CTRKO EQU $B286 ; original track CTRKD EQU $B287 ; duplicate track STARTRK EQU $B288 ; start track ENDTRK EQU $B289 ; end track STEP EQU $B28A ; step TRACK EQU $B28B ; track SYNCFLG EQU $B28C ; synchronized track flag NBLCFLG EQU $B28D ; nibble count flag PARMS EQU $B300 ; parameter buffer * SST.CONTROLER CTL_DO_MOVE EQU $B523 ; switch SST bank 2 and EDD CTL_XCH1 EQU $B539 ; switch module CTL_EDDREAD EQU $B560 CTL_EDDWRITE EQU $B566 CTL_VAR1 EQU $B56D ; "packed parms" or "your parms" CTL_VAR2 EQU $B56E ; [$00 or $FF] CTL_VAR3 EQU $B56F ; copy or pack or unpack [0..2] CTL_POS EQU $B570 ; original slot CTL_PDS EQU $B571 ; duplicate slot CTL_POD EQU $B572 ; original drive CTL_PDD EQU $B573 ; duplicate drive CTL_DRVCOUNT EQU $B574 ; 1 or 2 drives CTL_STARTRK EQU $B575 ; start track CTL_ENDTRK EQU $B576 ; end track CTL_STEP EQU $B577 ; step CTL_NBLCFLG EQU $B578 ; nibble count flag CTL_SYNCFLG EQU $B579 ; synchronized track flag CTL_SIDE EQU $B57A ; "side" CTL_TRACK EQU $B57B ; track * SST.RWTS CMD_READ = 1 CMD_WRITE = 2 CMD_FORMAT = 4 RWTS_TABLE EQU $B7E8 RWTS_SNUM16 = RWTS_TABLE+1 ; slot * 16 RWTS_DNUM = RWTS_TABLE+2 ; drive number RWTS_VOLEXPT = RWTS_TABLE+3 ; volume number expected RWTS_TNUM = RWTS_TABLE+4 ; track number RWTS_SNUM = RWTS_TABLE+5 ; sector number RWTS_USRBUF = RWTS_TABLE+8 ; R/W buffer RWTS_CMDCODE = RWTS_TABLE+12 ; command RWTS: EQU $BD00 ; RWTS entry point * EDD.DRIVE ARMV EQU $B87D ; move disk II drive's arm to a track *------------------------------* * * * Switch * * EDD disk drive routines mod * * and SST RWTS * * * *------------------------------* * Switch EDD ($B700-$BFFF) <=> BANK 2 SST ($D700-$DFFF) SBS_XCHANGE LDA #>$B700 STA $3D LDA #>$D700 STA $3F LDA #0 ; low STA $3C STA $3E TAY LDA #>$C000 ; end STA $42 JMP CTL_XCH1 ; exec switch *------------------------------* * * * Set pointers up * * * *------------------------------* * Out: ($3C) track buff * ($3E) timing bit buff SBS_PUP LDA #>H7800 ; track buffer addr high STA $3D LDA #>H9400 ; timing bit buffer addr high STA $3F LDA #$00 ; low STA $3C STA $3E TAY ; Y=0 RTS *------------------------------* * * * Build the timing bit buffer * * with the loaded track buffer * * (Unpack) * * * *------------------------------- * in : track buffer (with flag on every bit 7) * for every nibble: bit 7 = 0 => timing bit * bit 7 = 1 => no timing bit * Out: track buffer * for every nibble: bit 7 = 1 (normal) * timing bit buffer * for every byte: bit 0 = 0 => no timing bit * bit 0 = 1 => timing bit SBS_BUILDTBB JSR SBS_PUP ; set pointers SBS_BTBB1 LDA ($3C),Y ; nibble from track buffer CMP #$80 ; bit 7 = 0? BCC SBS_SETBIT ; yes, set timing bit LDA #0 ; no timing bit JMP SBS_STRBIT SBS_SETBIT EOR #$80 ; normal nibble always has bit 7 on STA ($3C),Y ; store nibble without this "flag" LDA #1 ; set timing bit SBS_STRBIT STA ($3E),Y ; fill timing bit buffer INY ; next nibble BNE SBS_BTBB1 INC $3D ; next page INC $3F LDA $3F CMP #>$B000 ; until $AFFF (end of timing bit buff) BNE SBS_BTBB1 ; continue RTS *------------------------------* * * * Clear 40c TXT window * * middle to bottom * * * *------------------------------* SBS_CLMID LDA #12 STA WNDTOP JSR HOME RTS *------------------------------* * * * Check that the floppy is a * * SST data disk * * * *------------------------------* * If pack option, this is always the case because * the program has a correct program variables storage * buffer. * If unpack option, page $B2 ($B200-$B2FF) is loaded * from the disk. SBS_CHKDSK LDY #0 :1 LDA LTC,Y ; reference bytes CMP SBS_DSKCMP,Y ; copy of standard LTC stored inside SST BNE SBS_BAD ; difference means error (sector $02) INY ; next ref byte CPY #5 BNE :1 CLC ; ok no error JMP SBS_GOOD * Bad disk (occurs only for Unpack) SBS_BAD JSR ERSBTM ; clean bottom of screen JSR SBS_SETCRS ; set pos 22 LDA CTL_SIDE ; include side number into message STA SBS_SIDEA LDY #0 ; display the "wrong disk" message SBS_BAD1 LDA SBS_WDSK,Y CMP #$FF ; terminator? BEQ SBS_BAD2 ; yes, end of string JSR COUT ; display char INY ; next char JMP SBS_BAD1 * Wait for a key and retry SBS_BAD2 JSR SBS_GETKEY ; waiting for a key LDA CTL_TRACK ; retry this track JMP SBS_DOTRACK ; do it again *------------------------------- SBS_WDSK ASC " WRONG DISK!!!! Insert data disk side " SBS_SIDEA ASC "1"8D ASC " and press return."FF *------------------------------- SBS_GOOD JMP SBS_RST_EDD ; continue => restore EDD environment *------------------------------* * * * Call the DOS 3.3 RWTS * * * *------------------------------* * In : RWTS_TNUM disk 1 => [$00..$22] * disk 2 => [$23..$45] replaced by * [$00..$22] * * Out: carry = 0 : ok * carry = 1 : cancelled/error SBS_RWTS LDA #"1" ; first part of the .NIB (.dsk #1) STA CTL_SIDE LDA RWTS_TNUM CMP #$23 ; track <$23? BCC SBS_RWTSKEY ; yep CMP #$24 ; track >=$24? BCS :1 ; yes ; special case: track 0 of 2nd disk (T$23) JSR SBS_TDO ; message "turn disk over" + key JMP :2 :1 LDA #"2" ; 2nd part of the .NIB (.dsk #2) STA CTL_SIDE :2 LDA RWTS_TNUM SEC ; remove offset SBC #$23 STA RWTS_TNUM ; set correct track number SBS_RWTSKEY LDA KEY ; check if esc key pressed CMP #$9B ; esc BEQ :1 ; yep ; no esc LDA #>RWTS_TABLE LDY # 1* NIB floppy disk SBS_DOUNPACK BIT STROBE JSR SBS_XCHANGE ; save EDD disk drive rt & retrieve RWTS * Fill RWTS parameters (for original disk drive) LDA POD ; original EDD drive number STA RWTS_DNUM LDA POS ; original EDD slot*16 ASL ASL ASL ASL STA RWTS_SNUM16 LDA #CMD_READ ; read 16 sectors floppy disk STA RWTS_CMDCODE JSR SBS_RWPROG ; read the track buffer from disk JMP CTL_DO_MOVE ; get EDD routines & save SST subs *------------------------------* * * * Pack entry point * * * *------------------------------* * 1* NIB floppy disk => 2* DSK floppy disks SBS_DOPACK JSR SBS_XCHANGE ; retrieve RWTS (and store EDD disk drive rt) * Fill RWTS parameters (for duplicate disk drive) LDA PDS ; duplicate EDD slot *16 ASL ASL ASL ASL STA RWTS_SNUM16 LDA PDD ; duplicate EDD disk drive number STA RWTS_DNUM JSR SBS_MERGE ; merge timing bits and raw data buffers LDA #CMD_WRITE ; command=write 16 sectors disk STA RWTS_CMDCODE JSR SBS_RWPROG ; save the track buffer to duplicate disk JMP CTL_DO_MOVE ; get EDD routines & save SST subs *------------------------------* * * * Shared routine : RWTS access * * * *------------------------------* * In : TRACK [$00..$88] step 4 (track $00 to $22) * [$8C] (extra track. E.g.:$23) * * NOTE: TRACK LENGTH IS $1C00 (NOT $1A00 as in .NIB files) SBS_RWPROG * Set parameters (EDD to SST) LDA POS ; original slot STA CTL_POS LDA PDS ; duplicate slot STA CTL_PDS LDA POD ; original disk drive STA CTL_POD LDA PDD ; duplicate disk drive STA CTL_PDD LDA DRVCOUNT ; nbr of drives STA CTL_DRVCOUNT LDA TRACK ; track "to do" STA CTL_TRACK LDA CTL_VAR1 ; 0=packed parms, 1=your parms BEQ :1 ; "your parms" option (unpack) LDA NBLCFLG ; nibble count flag STA CTL_NBLCFLG LDA SYNCFLG ; track synchro flag STA CTL_SYNCFLG LDY #0 ; save EDD parameter buffer ($B300-$B3FF) :2 LDA PARMS,Y STA PARMBUFSV,Y INY BNE :2 :1 LDA STARTRK ; start track (track "to do", not the 1st track) STA CTL_STARTRK LDA ENDTRK ; end track STA CTL_ENDTRK LDA STEP ; step STA CTL_STEP * Set parameters (RWTS) SBS_DOTRACK LDA CTL_TRACK ; quarter track format to "double disk" format LSR ; /2 STA RWTS_TNUM LDA #>H7800 ; start=1st page of track buffer STA RWTS_USRBUF+1 ; buffer high LDA #H9400 ; end of buffer? BEQ SBS_H1EE7 ; yes DEC RWTS_SNUM ; previous sector BPL SBS_H1ECA ; >=0 LDA #$0F ; continue to sector $0F STA RWTS_SNUM INC RWTS_TNUM ; of the next track (track ASCending) JMP SBS_H1ECA * Read/Save the EDD buffers for EVERY track buffer ; ok, the $1C00 track buffer is done. ; now add/read 3 additionnal sectors SBS_H1EE7 DEC RWTS_SNUM ; sector $03 LDA #>CONTRLP STA RWTS_USRBUF+1 JSR SBS_RWTSKEY ; prewrite routine buffer ($B100-$B1FF) DEC RWTS_SNUM ; sector $02 INC RWTS_USRBUF+1 JSR SBS_RWTSKEY ; program variable storage buffer ($B200-$B2FF) DEC RWTS_SNUM ; sector $01 INC RWTS_USRBUF+1 JSR SBS_RWTSKEY ; parameter buffer ($B300-$B3FF) BCC SBS_GOCHKDSK ; no err JSR SBS_XCHANGE ; err. Retrieve EDD.DRIVE & store SST.RWTS RTS SBS_GOCHKDSK JMP SBS_CHKDSK ; check SST data disk & continue *------------------------------* * * * Restore EDD environment * * * *------------------------------* * Called by SBS_GOOD SBS_RST_EDD LDA POS ; unpack => USE RESTORED VALUES!!! (BUG) CMP PDS ; original slot = duplicate slot? BNE SBS_H1F30 ; no LDA POD ; unpack => USE RESTORED VALUES!!! (BUG) CMP PDD ; original drive # = duplicate drive #? BNE SBS_H1F30 ; no ; the user has only 1 drive for the process. ; theorically this is done only with pack option ; because Saltine said that the unpack process ; is exec with an emulator (and 2 disk drives) LDA RWTS_TNUM ; track*4 to get EDD internal track # ASL ASL STA CTRK JSR SBS_XCHANGE ; retrieve EDD.DRIVE and store SST.RWTS LDA TRACK JSR ARMV ; move arm to good track (due to original/duplicate ; track mapping difference) JMP SBS_H1F33 ; continue (EDD.DRIVE already in place) SBS_H1F30 JSR SBS_XCHANGE ; retrieve EDD.DRIVE and store SST.RWTS SBS_H1F33 LDA CTL_VAR3 CMP #$02 ; unpack option? BNE SBS_H1F4E ; no ; unpack JSR SBS_BUILDTBB ; build timing bit buffer LDA CTL_VAR2 CMP #$FF BEQ SBS_H1F4E ; always LDA TRACK ; not used... SEC SBC STEP STA CTRKD * Set parameters (SST to EDD) SBS_H1F4E LDA TRACK STA CTRK LDA #0 STA CTL_VAR2 JSR ERSBTM LDA CTL_POD STA POD LDA CTL_POS STA POS LDA CTL_PDS STA PDS LDA CTL_PDD STA PDD LDA CTL_DRVCOUNT STA DRVCOUNT LDA CTL_STARTRK STA STARTRK LDA CTL_ENDTRK STA ENDTRK LDA CTL_STEP STA STEP LDA CTL_VAR1 ; packed parms? BEQ SBS_RILDON ; yes LDA CTL_NBLCFLG ; nibble count STA NBLCFLG LDA CTL_SYNCFLG ; syncronized track STA SYNCFLG LDY #0 SBS_RPARM LDA PARMBUFSV,Y ; restore EDD parameter buffer STA PARMS,Y INY BNE SBS_RPARM SBS_RILDON RTS *------------------------------* * * * Copy of LTC bytes * * * *------------------------------* * Use the table for divide routine as reference SBS_DSKCMP DA 10000,1000 HEX 64 *------------------------------* * * * Choose menu sub-option * * (Pirate a Disk) * * * *------------------------------* * Out: CTL_VAR3 [0=EDD copy,1=pack,2=unpack] * CTL_VAR2 $FF * CTL_VAR1 [0=packed parms,1=your parms] if unpack * [0=packed parms] if EDD copy or pack SBS_CHOOSE JSR SBS_CLMID ; clear window: middle to bottom LDA #$FF STA CTL_VAR2 STA CTRKO ; EDD original track LDY #0 BIT STROBE :1 LDA SBS_CHTXT,Y ; display sub-menu: Pirate a disk CMP #$FF ; terminator? BEQ :2 ; yep JSR COUT ; print character INY ; next char JMP :1 ; string loop :2 LDA KEY ; wait for a key BPL :2 CMP #$9B ; esc? BNE :3 ; no RTS ; return to main menu ; check selection validity :3 CMP #"1" ; <"1" BCC :2 ; bad: wait for another key CMP #"4" ; >="4" BCS :2 ; bad: wait for another key SEC ; ["1","3"] => [0,2] SBC #"1" STA CTL_VAR3 CMP #2 ; unpack BNE :8 ; copy or pack -> finished * Unpack: ask for detail JSR HOME BIT STROBE LDY #0 ; display sub-menu: unpack :5 LDA SBS_PARMTXT,Y CMP #$FF ; terminator BEQ :4 JSR COUT ; print character INY ; next char JMP :5 ; string loop :4 LDA KEY ; get key BPL :4 ; bad, try again CMP #$9B ; esc BNE :6 ; no RTS ; return to main menu ; check selection validity :6 CMP #"1" ; <"1" BCC :4 ; bad: wait for another key CMP #"3" ; >="2" BCS :4 ; bad: wait for another key SEC ; ["1","2"] => [0,1] SBC #"1" STA CTL_VAR1 JMP :7 :8 LDA #0 ; packed parm for copy/pack STA CTL_VAR1 :7 BIT STROBE RTS *------------------------------* * * * TEXT STRINGS * * * *------------------------------* * Sub-menu: Pirate a disk SBS_CHTXT ASC " 1) Copy " ASC " 2) Pack " ASC " 3) Unpack" HEX FF ; terminator SBS_PARMTXT ASC " 1) Packed parms " ASC " 2) Your parms" HEX FF ; terminator SBS_INITEXT ASC " riginal or uplicate drive?" HEX FF ; terminator SBS_PAKTXT ASC " Press a key when ready" HEX FF ; terminator DS 79," " HEX FF ; terminator *------------------------------* * * * Turn Disk Over * * * *------------------------------* SBS_TDO JSR SBS_SETCRS ; pos line 22 LDY #0 :1 LDA SBS_TURNDSK,Y ; display "turn disk over" message CMP #$20 ; JMP of next intruction (=terminator) BEQ SBS_GETKEY JSR COUT ; print character INY ; next char JMP :1 ; string loop SBS_GETKEY BIT STROBE :1 LDA KEY ; wait any key BPL :1 JSR ERSBTM ; clear bottom of screen RTS SBS_TURNDSK ASC " Turn DATA disk over and press RETURN" *------------------------------* * * * Initialize a disk * * Exec routine * * * *------------------------------* SBS_INIT JSR ERSBTM ; clear bottom of screen JSR SBS_XCHANGE ; retrieve RWTS (store EDD disk drive rt) BIT $C010 JSR SBS_SETCRS ; pos line 22 LDY #0 :2 LDA SBS_INITEXT,Y ; msg asking for original of duplicate drive CMP #$FF ; terminator? BEQ :1 ; yes JSR COUT ; print character INY ; next char JMP :2 ; string loop :1 LDA KEY ; wait key BPL :1 ; check selection validity BIT STROBE CMP #"O" ; original? BEQ :3 ; yes CMP #"D" ; duplicate? BEQ :4 ; yes JMP :1 ; bad: wait for another key * Fill RWTS parameters for original disk :3 LDA POD ; original drive STA RWTS_DNUM LDA POS ; original slot*16 ASL ASL ASL ASL STA RWTS_SNUM16 JMP :5 ; wait key * Fill RWTS parameters for duplicator disk :4 LDA PDD ; duplicate drive STA RWTS_DNUM LDA PDS ; duplicate slot*16 ASL ASL ASL ASL STA RWTS_SNUM16 * Wait for a key (=disk ready) :5 BIT STROBE JSR ERSBTM ; clear bottom screen JSR SBS_SETCRS ; pos line 22 LDY #0 ; display press a key (pak) message :7 LDA SBS_PAKTXT,Y CMP #$FF ; terminator BEQ :6 ; yep JSR COUT ; print character INY ; next char JMP :7 ; string loop :6 LDA KEY ; wait for any key BPL :6 BIT STROBE LDA #0 ; any volume STA RWTS_VOLEXPT LDA #CMD_FORMAT ; rwts command STA RWTS_CMDCODE JSR SBS_RWTS ; do format disk JSR ERSBTM ; clear bottom of screen JSR SBS_XCHANGE ; store RWTS and retrieve EDD disk drive rt RTS *------------------------------* * * * Cursor position line 22 * * * *------------------------------* SBS_SETCRS LDA #0 ; set X STA CH LDA #22 ; set Y STA CV JMP VTAB ; position *------------------------------* * * * Merge timing bit buffer and * * raw data buffer * * * *------------------------------* * Default EDD parm#9=1 (TIMEBITS $B309) * Normal mode SBS_MERGE JSR SBS_PUP ; set pointers up ; Y=0 :1 LDA ($3E),Y ; 0 or 1 or 2 (timing bit) %00000011 ASL ASL ASL ASL ASL ASL ASL ; keep only default value!!!! (TIMEBITS=2 lost) EOR ($3C),Y ; merge with nibble STA ($3C),Y ; store result INY BNE :1 INC $3D ; merge the full rawdata buffer INC $3F LDA $3F CMP #>$B000 BNE :1 RTS *------------------------------* * * * Read/Write an extra track * * typically Track 35 ($23) * * * *------------------------------* SBS_TRK35 JSR SBS_TDO ; message "turn disk over" + key ; use the holes left by the tracks $00-$22 process LDA #0 ; Begin with sector $00 STA RWTS_SNUM LDA #1 ; and track $01 STA RWTS_TNUM LDA #"2" ; not used (no effect!!) STA CTL_SIDE SBS_H2266 JSR SBS_RWTS BCC SBS_H226C ; no err RTS ; Ooops! Missing code: JSR SBS_XCHANGE + restore ; EDD parms. Assume no I/O err. 16 sector disk ; must be ok. SBS_H226C INC RWTS_TNUM ; next sector 2 tracks later INC RWTS_TNUM INC RWTS_USRBUF+1 ; high LDA RWTS_USRBUF+1 CMP #>H9400 ; end of track buffer? BNE SBS_H2266 ; no * Continue with the 3 extra sectors (EDD buffers) LDA #>CONTRLP ; prewrite routine buffer STA RWTS_USRBUF+1 SBS_H2281 JSR SBS_RWTS ; T$16 S$00 INC RWTS_USRBUF+1 ; program variable storage buffer INC RWTS_TNUM INC RWTS_TNUM JSR SBS_RWTS ; T$18 S$00 INC RWTS_USRBUF+1 ; parameter buffer INC RWTS_TNUM INC RWTS_TNUM JSR SBS_RWTS ; T$1A S$00 ; assume no I/O err!!! JMP SBS_GOCHKDSK ; check SST data disk & continue DS \,0 DS $100,0 SAV OBJ/DECKARD/SST.SUBS