Message

Reply | Reply all

Date Prev | Date Next | Thread Prev | Thread Next Date Index | Thread Index

From: cvs at opencores.org<cvs@o...>
Date: Fri Mar 14 16:52:49 CET 2008
Subject: [cvs-checkins] MODIFIED: System09 ...
Date: 00/08/03 14:16:52

Added: System09/src/dump dump_cf8.lst dump_cf8.s19 dump_cf8.sh
dump_cf8.txt dump_ide.lst dump_ide.s19 dump_ide.sh
dump_ide.txt
Log:
Updated software - XSA-3S1000 now runs FLEX on an IDE drive or CF card.


Revision Changes Path
1.1 System09/src/dump/dump_cf8.lst

http://www.opencores.org/cvsweb.shtml/System09/src/dump/dump_cf8.lst?rev=1.1&content-type=text/x-cvsweb-markup

Index: dump_cf8.lst
===================================================================
Assembler release DWC_2.0 version 2.11
May 6, 2004 (c) Motorola (free ware)
0001 *
0002 * Sector Dump Utility
0003 * For Compact Flash Driver
0004 * for the 6809
0005 * Configured in 8 bit mode
0006 *
0007 * John Kent
0008 * 21 May 2007
0009 *
0010 * Register Equates
0011 *
0012 E040 CF_BASE EQU $E040
0013 E040 CF_DATA EQU CF_BASE+0
0014 E041 CF_ERROR EQU CF_BASE+1 ; read error
0015 E041 CF_FEATURE EQU CF_BASE+1 ; write feature
0016 E042 CF_SECCNT EQU CF_BASE+2
0017 E043 CF_SECNUM EQU CF_BASE+3
0018 E044 CF_CYLLO EQU CF_BASE+4
0019 E045 CF_CYLHI EQU CF_BASE+5
0020 E046 CF_HEAD EQU CF_BASE+6
0021 E047 CF_STATUS EQU CF_BASE+7 ; read status
0022 E047 CF_COMAND EQU CF_BASE+7 ; write command
0023 *
0024 * Command Equates
0025 *
0026 0020 CMDREAD EQU $20 ; Read Single sector
0027 0030 CMDWRITE EQU $30 ; Write Single sector
0028 00EF CMDFEATURE EQU $EF
0029 0001 FEAT8BIT EQU $01 ; enable 8 bit transfers
0030 00E0 HEADLBA EQU $E0
0031 *
0032 * Status bit equates
0033 *
0034 0080 BUSY EQU $80
0035 0040 DRDY EQU $40
0036 0008 DRQ EQU $08
0037 0001 ERR EQU $01
0038 *
0039 * Start of Program
0040 *
0041 0100 ORG $0100
0042 0100 16 02 46 START LBRA START1
0043 *
0044 * DATA STORAGE
0045 *
0046 0103 00 00 00 SECNUM FCB $00,$00,$00
0047 0106 E0 00 CPORT FDB $E000
0048 0108 FF ECHO FCB $FF
0049 *
0050 * SECTOR BUFFER
0051 *
0052 0109 SECBUF RMB 512
0053 *
0054 * PROGRAM STACK
0055 *
0056 0309 RMB 64
0057 0349 STACK EQU *
0058 *
0059 * Initialization
0060 *
0061 0349 10 CE 03 49 START1 LDS #STACK
0062 *
0063 * Clear sector buffer
0064 *
0065 034D 8E 01 09 LDX #SECBUF
0066 0350 10 8E 02 00 LDY #512
0067 0354 6F 80 ZEROLP CLR ,X+
0068 0356 31 3F LEAY -1,Y
0069 0358 26 FA BNE ZEROLP
0070 *
0071 * INITIALIZE CF CARD FOR 8 BIT LBA MODE
0072 *
0073 035A BD 04 64 JSR WAITRDY
0074 035D 86 E0 LDA #HEADLBA
0075 035F B7 E0 46 STA CF_HEAD
0076 0362 BD 04 64 JSR WAITRDY
0077 0365 86 01 LDA #FEAT8BIT
0078 0367 B7 E0 41 STA CF_FEATURE
0079 036A 86 EF LDA #CMDFEATURE
0080 036C B7 E0 47 STA CF_COMAND
0081 036F BD 04 64 JSR WAITRDY
0082 *
0083 * DISPLAY TITTLE BANNER
0084 *
0085 0372 8E 06 4E LDX #TTLMSG 0086 0375 BD 05 FB JSR PDATA 0087 * 0088 * COMMAND LOOP 0089 * R - READ 0090 * W - WRITE 0091 * N - NEXT 0092 * P - PREV 0093 * M - MODIFY 0094 * Q - QUIT 0095 * 0096 0378 8E 06 78 CMDLP LDX #CMDMSG 0097 037B BD 05 FB JSR PDATA 0098 037E BD 06 02 JSR ECHON 0099 0381 81 52 CMPA #'R' 0100 0383 27 4A BEQ READ 0101 0385 81 4E CMPA #'N' 0102 0387 27 23 BEQ NEXT 0103 0389 81 50 CMPA #'P' 0104 038B 27 2E BEQ PREV 0105 038D 81 57 CMPA #'W' 0106 038F 10 27 00 88 LBEQ WRITE 0107 0393 81 4D CMPA #'M' 0108 0395 27 10 BEQ MODIFY 0109 0397 81 51 CMPA #'Q' 0110 0399 27 08 BEQ QUIT 0111 039B 8E 07 31 LDX #WOTMSG 0112 039E BD 05 EC JSR PSTRNG 0113 03A1 20 D5 BRA CMDLP 0114 * 0115 * QUIT 0116 * 0117 03A3 6E 9F F8 00 QUIT JMP [$F800] 0118 * 0119 * MODIFY SECTOR 0120 * 0121 03A7 BD 04 F3 MODIFY JSR MEMCHG 0122 03AA 20 CC BRA CMDLP 0123 * 0124 * NEXT SECTOR (READ) 0125 * INCREMENT SECTOR NUMBER 0126 * WRAPS AROUND TO ZERO ON $FFFFFF 0127 * 0128 03AC BE 01 04 NEXT LDX SECNUM+1 0129 03AF 30 01 LEAX 1,X 0130 03B1 BF 01 04 STX SECNUM+1 0131 03B4 26 2A BNE READS 0132 03B6 7C 01 03 INC SECNUM 0133 03B9 20 25 BRA READS 0134 * 0135 * PREVIOUS SECTOR (READ) 0136 * DECREMENT SECTOR NUMBER 0137 * DON'T DECREMENT PAST $000000 0138 * 0139 03BB BE 01 04 PREV LDX SECNUM+1 0140 03BE 26 08 BNE PREV1 0141 03C0 7D 01 03 TST SECNUM 0142 03C3 27 1B BEQ READS 0143 03C5 7A 01 03 DEC SECNUM 0144 03C8 30 1F PREV1 LEAX -1,X 0145 03CA BF 01 04 STX SECNUM+1 0146 03CD 20 11 BRA READS 0147 * 0148 * READ SECTORS FROM CF 0149 * 0150 03CF 8E 06 DF READ LDX #SECPMT 0151 03D2 BD 05 EC JSR PSTRNG 0152 03D5 BD 05 59 JSR IN6HEX 0153 03D8 29 3E BVS RDEXIT 0154 03DA F7 01 03 STB SECNUM 0155 03DD BF 01 04 STX SECNUM+1 0156 * 0157 03E0 86 01 READS LDA #$01 0158 03E2 B7 E0 42 STA CF_SECCNT 0159 03E5 B6 01 05 LDA SECNUM+2 0160 03E8 B7 E0 43 STA CF_SECNUM 0161 03EB B6 01 04 LDA SECNUM+1 0162 03EE B7 E0 44 STA CF_CYLLO 0163 03F1 B6 01 03 LDA SECNUM+0 0164 03F4 B7 E0 45 STA CF_CYLHI 0165 * 0166 03F7 86 20 LDA #CMDREAD ; IDE READ MULTIPLE 0167 03F9 B7 E0 47 STA CF_COMAND 0168 03FC BD 04 64 JSR WAITRDY 0169 * 0170 03FF 8E 01 09 LDX #SECBUF 0171 0402 10 8E 02 00 LDY #512 0172 * 0173 * READ LOOP 0174 * 0175 0406 BD 04 73 RDLOOP JSR WAITDRQ 0176 0409 B6 E0 40 LDA CF_DATA 0177 040C A7 80 STA ,X+ 0178 040E 31 3F LEAY -1,Y 0179 0410 26 F4 BNE RDLOOP 0180 * 0181 0412 BD 04 64 JSR WAITRDY 0182 0415 BD 04 7B JSR MEMDUMP 0183 0418 7E 03 78 RDEXIT JMP CMDLP 0184 * 0185 * WRITE SECTOR TO CF 0186 * 0187 041B 8E 06 DF WRITE LDX #SECPMT 0188 041E BD 05 EC JSR PSTRNG 0189 0421 BD 05 59 JSR IN6HEX 0190 0424 29 3B BVS WREXIT 0191 0426 F7 01 03 STB SECNUM 0192 0429 BF 01 04 STX SECNUM+1 0193 * 0194 042C 86 01 LDA #$01 0195 042E B7 E0 42 STA CF_SECCNT 0196 0431 B6 01 05 LDA SECNUM+2 0197 0434 B7 E0 43 STA CF_SECNUM 0198 0437 B6 01 04 LDA SECNUM+1 0199 043A B7 E0 44 STA CF_CYLLO 0200 043D B6 01 03 LDA SECNUM+0 0201 0440 B7 E0 45 STA CF_CYLHI 0202 * 0203 0443 86 30 LDA #CMDWRITE; IDE WRITE MULTIPLE 0204 0445 B7 E0 47 STA CF_COMAND 0205 0448 BD 04 64 JSR WAITRDY 0206 * 0207 044B 8E 01 09 LDX #SECBUF 0208 044E 10 8E 02 00 LDY #512 0209 * 0210 * WRITE LOOP 0211 * 0212 0452 BD 04 73 WRLOOP JSR WAITDRQ 0213 0455 A6 80 LDA ,X+ 0214 0457 B7 E0 40 STA CF_DATA 0215 045A 31 3F LEAY -1,Y 0216 045C 26 F4 BNE WRLOOP 0217 * 0218 045E BD 04 64 JSR WAITRDY 0219 0461 7E 03 78 WREXIT JMP CMDLP 0220 * 0221 * WAIT UNTIL READY 0222 * 0223 0464 B6 E0 47 WAITRDY LDA CF_STATUS 0224 0467 85 80 BITA #BUSY 0225 0469 26 F9 BNE WAITRDY 0226 046B B6 E0 47 LDA CF_STATUS 0227 046E 85 40 BITA #DRDY 0228 0470 27 F2 BEQ WAITRDY 0229 0472 39 RTS 0230 * 0231 * WAIT FOR DATA REQUEST 0232 * 0233 0473 B6 E0 47 WAITDRQ LDA CF_STATUS 0234 0476 85 08 BITA #DRQ 0235 0478 27 F9 BEQ WAITDRQ 0236 047A 39 RTS 0237 * 0238 * DUMP SECTOR IN MEMORY 0239 * 0240 047B 8E 06 F8 MEMDUMP LDX #SECMSG 0241 047E BD 05 EC JSR PSTRNG 0242 0481 B6 01 03 LDA SECNUM 0243 0484 BD 05 C1 JSR OUT2H 0244 0487 BE 01 04 LDX SECNUM+1 0245 048A BD 05 B9 JSR OUT4H 0246 048D BD 05 F0 JSR PCRLF 0247 0490 10 8E 00 00 LDY #$0000 0248 0494 30 A9 01 FF LEAX #$1FF,Y 0249 * 0250 * ADJUST LOWER AND UPPER ADDRESS LIMITS 0251 * TO EVEN 16 BYTE BOUNDRIES. 0252 * 0253 * IF LOWER ADDR = $4532 0254 * LOWER BOUNDS WILL BE ADJUSTED TO = $4530. 0255 * 0256 * IF UPPER ADDR = $4567 0257 * UPPER BOUNDS WILL BE ADJUSTED TO = $4570. 0258 * 0259 * ENTER WITH LOWER ADDRESS IN X-REG. 0260 * -UPPER ADDRESS ON TOP OF STACK. 0261 * 0262 0498 1F 10 AJDUMP TFR X,D GET UPPER ADDR IN D-REG 0263 049A C3 00 10 ADDD #$10 ADD 16 TO UPPER ADDRESS 0264 049D C4 F0 ANDB #$F0 MASK TO EVEN 16 BYTE BOUNDRY 0265 049F 34 06 PSHS A,B SAVE ON STACK AS UPPER DUMP LIMIT 0266 04A1 1F 20 TFR Y,D $F9A5 GET LOWER ADDRESS IN D-REG 0267 04A3 C4 F0 ANDB #$F0 MASK TO EVEN 16 BYTE BOUNDRY 0268 04A5 1F 01 TFR D,X PUT IN X-REG AS LOWER DUMP LIMIT 0269 04A7 AC E4 NXTLIN CMPX ,S COMPARE LOWER TO UPPER LIMIT 0270 04A9 27 05 BEQ SKPDMP IF EQUAL SKIP HEX-ASCII DUMP 0271 04AB 17 01 6E LBSR INCHEK CHECK FOR INPUT FROM KEYBOARD 0272 04AE 27 03 BEQ EDUMP 0273 04B0 32 62 SKPDMP LEAS 2,S READJUST STACK IF NOT DUMPING 0274 04B2 39 RTS ; 0275 * 0276 * PRINT 16 HEX BYTES FOLLOWED BY 16 ASCII CHARACTERS 0277 * FOR EACH LINE THROUGHOUT ADDRESS LIMITS. 0278 * 0279 04B3 34 10 EDUMP PSHS X PUSH LOWER ADDR LIMIT ON STACK 0280 04B5 8E 07 25 LDX #MSG5 POINT TO MSG " - " 0281 04B8 17 01 31 LBSR PSTRNG PRINT MSG 0282 04BB AE E4 LDX ,S LOAD LOWER ADDR FROM TOP OF STACK 0283 04BD 17 00 F9 LBSR OUT4H PRINT THE ADDRESS 0284 04C0 17 01 63 LBSR OUT2S 2 SPACES 0285 04C3 C6 10 LDB #$10 LOAD COUNT OF 16 BYTES TO DUMP 0286 04C5 A6 89 01 09 ELOOP LDA SECBUF,X GET FROM MEMORY HEX BYTE TO PRINT 0287 04C9 30 01 LEAX 1,X 0288 04CB 17 00 F3 LBSR OUT2H OUTPUT HEX BYTE AS ASCII 0289 04CE 17 01 57 LBSR OUT1S OUTPUT SPACE 0290 04D1 5A DECB $F9D1 DECREMENT BYTE COUNT 0291 04D2 26 F1 BNE ELOOP CONTINUE TIL 16 HEX BYTES PRINTED 0292 * 0293 * PRINT 16 ASCII CHARACTERS 0294 * IF NOT PRINTABLE OR NOT VALID 0295 * ASCII PRINT A PERIOD (.) 0296 04D4 17 01 4F LBSR OUT2S 2 SPACES 0297 04D7 AE E1 LDX ,S++ GET LOW LIMIT FRM STACK - ADJ STACK 0298 04D9 C6 10 LDB #$10 SET ASCII CHAR TO PRINT = 16 0299 04DB A6 89 01 09 EDPASC LDA SECBUF,X GET CHARACTER FROM MEMORY 0300 04DF 30 01 LEAX 1,X 0301 04E1 81 20 CMPA #$20 IF LESS THAN $20, NON-PRINTABLE? 0302 04E3 25 04 BCS PERIOD IF SO, PRINT PERIOD INSTEAD 0303 04E5 81 7E CMPA #$7E IS IT VALID ASCII? 0304 04E7 23 02 BLS PRASC IF SO PRINT IT 0305 04E9 86 2E PERIOD LDA #'. LOAD A PERIOD (.) 0306 04EB 17 01 3C PRASC LBSR OUTCH PRINT ASCII CHARACTER 0307 04EE 5A DECB DECREMENT COUNT 0308 04EF 26 EA BNE EDPASC 0309 04F1 20 B4 BRA NXTLIN 0310 * 0311 * 0312 ***** "M" MEMORY EXAMINE AND CHANGE ***** 0313 * 0314 * RESTRICT ADDRESSING RANGE TO 512 BYTES ($000 - $1FF) 0315 * 0316 04F3 8E 07 0A MEMCHG LDX #MEMMSG 0317 04F6 BD 05 EC JSR PSTRNG 0318 04F9 17 00 74 LBSR IN3HEX INPUT ADDRESS 0319 04FC 29 34 BVS CHRTN IF NOT HEX, RETURN 0320 04FE 8C 02 00 CMPX #$0200 0321 0501 24 2F BHS CHRTN 0322 0503 1F 12 TFR X,Y SAVE ADDR IN "Y" 0323 0505 8E 07 25 MEMC2 LDX #MSG5 POINT TO MSG " - " 0324 0508 17 00 E1 LBSR PSTRNG PRINT MSG 0325 050B 1F 21 TFR Y,X FETCH ADDRESS 0326 050D 17 00 A9 LBSR OUT4H PRINT ADDR IN HEX 0327 0510 17 01 15 LBSR OUT1S OUTPUT SPACE 0328 0513 A6 A9 01 09 LDA SECBUF,Y GET CONTENTS OF CURRENT ADDR. 0329 0517 17 00 A7 LBSR OUT2H OUTPUT CONTENTS IN ASCII 0330 051A 17 01 0B LBSR OUT1S OUTPUT SPACE 0331 051D 17 00 60 LBSR BYTE LOOP WAITING FOR OPERATOR INPUT 0332 0520 28 11 BVC CHANGE IF VALID HEX GO CHANGE MEM. LOC. 0333 0522 81 08 CMPA #8 IS IT A BACKSPACE (CNTRL H)? 0334 0524 27 DF BEQ MEMC2 PROMPT OPERATOR AGAIN 0335 0526 81 18 CMPA #$18 IS IT A CANCEL (CNTRL X)? 0336 0528 27 DB BEQ MEMC2 PROMPT OPERATOR AGAIN 0337 052A 81 5E CMPA #'^ IS IT AN UP ARROW? 0338 052C 27 21 BEQ BACK DISPLAY PREVIOUS BYTE 0339 052E 81 0D CMPA #$D IS IT A CR? 0340 0530 26 13 BNE FORWRD DISPLAY NEXT BYTE 0341 0532 39 CHRTN RTS EXIT ROUTINE 0342 * 0343 * 0344 0533 A7 A9 01 09 CHANGE STA SECBUF,Y CHANGE BYTE IN MEMORY 0345 0537 A1 A9 01 09 CMPA SECBUF,Y DID MEMORY BYTE CHANGE? 0346 053B 27 08 BEQ FORWRD $F972 0347 053D 17 00 E8 LBSR OUT1S OUTPUT SPACE 0348 0540 86 3F LDA #'? LOAD QUESTION MARK 0349 0542 17 00 E5 LBSR OUTCH PRINT IT 0350 0545 10 8C 01 FF FORWRD CMPY #$01FF 0351 0549 27 BA BEQ MEMC2 0352 054B 31 21 LEAY 1,Y POINT TO NEXT HIGHER MEM LOCATION 0353 054D 20 B6 BRA MEMC2 PRINT LOCATION & CONTENTS 0354 054F 10 8C 00 00 BACK CMPY #$0000 0355 0553 27 B0 BEQ MEMC2 0356 0555 31 3F LEAY -1,Y POINT TO LAST MEM LOCATION 0357 0557 20 AC BRA MEMC2 PRINT LOCATION & CONTENTS 0358 * 0359 * THE FOLLOWING ROUTINE LOOPS WAITING FOR THE 0360 * OPERATOR TO INPUT ONE VALID HEX ADDRESS. THE 0361 * ADDRESS IS RETURNED IN THE "X" REGISTER. 0362 * 0363 * IN6HEX - MS BYTE IN ACCB 0364 * LS WORD IN X REG 0365 * 0366 0559 32 7D IN6HEX LEAS -3,S 0367 055B 8D 23 BSR BYTE 0368 055D 29 57 BVS NOTHEX 0369 055F A7 E4 STA 0,S 0370 0561 8D 1D BSR BYTE 0371 0563 29 51 BVS NOTHEX 0372 0565 A7 61 STA 1,S 0373 0567 8D 17 BSR BYTE 0374 0569 29 4B BVS NOTHEX 0375 056B A7 62 STA 2,S 0376 056D 4F CLRA 0377 056E 35 94 PULS B,X,PC 0378 * 0379 * INPUT 3 HEX DIGITS 0380 * RESULT RETURNED IN X 0381 * 0382 0570 8D 21 IN3HEX BSR INHEX INPUT HEX (1 HEX CHAR) 0383 0572 29 42 BVS NOTHEX EXIT IF NOT VALID HEX 0384 0574 1F 01 TFR D,X 0385 0576 8D 08 BSR BYTE INPUT BYTE (2 HEX CHAR) 0386 0578 29 3C BVS NOTHEX 0387 057A 34 10 PSHS X 0388 057C A7 61 STA 1,S 0389 057E 35 90 PULS X,PC 0390 * 0391 ***** INPUT BYTE (2 HEX CHAR.) ***** 0392 * 0393 0580 8D 11 BYTE BSR INHEX GET HEX LEFT 0394 0582 29 32 BVS NOTHEX EXIT IF NOT VALID HEX 0395 0584 48 ASLA ; 0396 0585 48 ASLA ; 0397 0586 48 ASLA ; SHIFT INTO LEFT NIBBLE 0398 0587 48 ASLA ; 0399 0588 1F 89 TFR A,B PUT HEXL IN "B" 0400 058A 8D 07 BSR INHEX GET HEX RIGHT 0401 058C 29 28 BVS NOTHEX EXIT IF NOT VALID HEX 0402 058E 34 04 PSHS B PUSH HEXL ON STACK 0403 0590 AB E0 ADDA ,S+ ADD HEXL TO HEXR AND ADJ. STK 0404 0592 39 RTS RETURN WITH HEX L&R IN "A" 0405 * 0406 * 0407 0593 8D 6D INHEX BSR ECHON INPUT ASCII CHAR. 0408 0595 81 30 CMPA #'0 IS IT > OR = "0" ? 0409 0597 25 1D BCS NOTHEX IF LESS IT AIN'T HEX 0410 0599 81 39 CMPA #'9 IS IT < OR = "9" ? 0411 059B 22 03 BHI INHEXA IF > MAYBE IT'S ALPHA 0412 059D 80 30 SUBA #$30 ASCII ADJ. NUMERIC 0413 059F 39 RTS ; 0414 * 0415 * 0416 05A0 81 41 INHEXA CMPA #'A IS IT > OR = "A" 0417 05A2 25 12 BCS NOTHEX IF LESS IT AIN'T HEX 0418 05A4 81 46 CMPA #'F IS IT < OR = "F" ? 0419 05A6 22 03 BHI INHEXL IF > IT AIN'T HEX 0420 05A8 80 37 SUBA #$37 ASCII ADJ. ALPHA 0421 05AA 39 RTS ; 0422 * 0423 05AB 81 61 INHEXL CMPA #'a IS IT > OR = "a" 0424 05AD 25 07 BCS NOTHEX IF LESS IT AIN'T HEX 0425 05AF 81 66 CMPA #'f IS IT < "f" 0426 05B1 22 03 BHI NOTHEX IF > IT AIN'T HEX 0427 05B3 80 57 SUBA #$57 ADJUST TO LOWER CASE 0428 05B5 39 RTS ; 0429 * 0430 * 0431 05B6 1A 02 NOTHEX ORCC #2 SET (V) FLAG IN C-CODES REGISTER 0432 05B8 39 RTS ; 0433 * 0434 * 0435 05B9 34 10 OUT4H PSHS X PUSH X-REG. ON THE STACK 0436 05BB 35 02 PULS A POP MS BYTE OF X-REG INTO A-ACC. 0437 05BD 8D 02 BSR OUTHL OUTPUT HEX LEFT 0438 05BF 35 02 PULS A POP LS BYTE OF X-REG INTO A-ACC. 0439 05C1 OUTHL EQU * 0440 05C1 34 02 OUT2H PSHS A SAVE IT BACK ON STACK 0441 05C3 44 LSRA CONVERT UPPER HEX NIBBLE TO ASCII 0442 05C4 44 LSRA ; 0443 05C5 44 LSRA ; 0444 05C6 44 LSRA ; 0445 05C7 8D 04 BSR XASCII PRINT HEX NIBBLE AS ASCII 0446 05C9 35 02 OUTHR PULS A CONVERT LOWER HEX NIBBLE TO ASCII 0447 05CB 84 0F ANDA #$0F STRIP LEFT NIBBLE 0448 05CD 8B 30 XASCII ADDA #$30 ASCII ADJ 0449 05CF 81 39 CMPA #$39 IS IT < OR = "9" ? 0450 05D1 2F 02 BLE OUTC IF LESS, OUTPUT IT 0451 05D3 8B 07 ADDA #7 IF > MAKE ASCII LETTER 0452 05D5 20 53 OUTC BRA OUTCH OUTPUT CHAR 0453 * 0454 * BINARY / ASCII --- THIS ROUTINE 0455 * OUTPUTS A BYTE IN ENHANCED 0456 * BINARY FORMAT. THE ENHANCEMENT 0457 * IS DONE BY SUBSTITUTING ASCII 0458 * LETTERS FOR THE ONES IN THE BYTE. 0459 * THE ASCII ENHANCEMENT LETTERS 0460 * ARE OBTAINED FROM THE STRING 0461 * POINTED TO BY THE INDEX REG. "X". 0462 * 0463 05D7 34 02 BIASCI PSHS A SAVE "A" ON STACK 0464 05D9 C6 08 LDB #8 PRESET LOOP# TO BITS PER BYTE 0465 05DB A6 80 OUTBA LDA ,X+ GET LETTER FROM STRING 0466 05DD 68 E4 ASL ,S TEST BYTE FOR "1" IN B7 0467 05DF 25 02 BCS PRTBA IF ONE PRINT LETTER 0468 05E1 86 2D LDA #'- IF ZERO PRINT "-" 0469 05E3 8D 45 PRTBA BSR OUTCH PRINT IT 0470 05E5 8D 41 BSR OUT1S PRINT SPACE 0471 05E7 5A DECB SUB 1 FROM #BITS YET TO PRINT 0472 05E8 26 F1 BNE OUTBA 0473 05EA 35 82 PULS A,PC 0474 * 0475 * PRINT STRING PRECEEDED BY A CR & LF. 0476 * 0477 05EC 8D 02 PSTRNG BSR PCRLF PRINT CR/LF 0478 05EE 20 0B BRA PDATA PRINT STRING POINTED TO BY IX 0479 * 0480 * PCRLF 0481 * 0482 05F0 34 10 PCRLF PSHS X SAVE IX 0483 05F2 8E 07 2A LDX #MSG2+1 POINT TO MSG CR/LF + 3 NULS 0484 05F5 8D 04 BSR PDATA PRINT MSG 0485 05F7 35 90 PULS X,PC RESTORE IX 0486 05F9 8D 2F PRINT BSR OUTCH 0487 * 0488 * PDATA 0489 * 0490 05FB A6 80 PDATA LDA ,X+ GET 1st CHAR. TO PRINT 0491 05FD 81 04 CMPA #4 IS IT EOT? 0492 05FF 26 F8 BNE PRINT IF NOT EOT PRINT IT 0493 0601 39 RTS ; 0494 * 0495 * 0496 0602 7D 01 08 ECHON TST ECHO IS ECHO REQUIRED ? 0497 0605 27 06 BEQ INCH ECHO NOT REQ. IF CLEAR 0498 * 0499 * INCHE 0500 * 0501 * ---GETS CHARACTER FROM TERMINAL AND 0502 * ECHOS SAME. THE CHARACTER IS RETURNED 0503 * IN THE "A" ACCUMULATOR WITH THE PARITY 0504 * BIT MASKED OFF. ALL OTHER REGISTERS 0505 * ARE PRESERVED. 0506 * 0507 0607 8D 04 INCHE BSR INCH GET CHAR FROM TERMINAL 0508 0609 84 7F ANDA #$7F STRIP PARITY FROM CHAR. 0509 060B 20 1D BRA OUTCH ECHO CHAR TO TERMINAL 0510 * 0511 * INCH 0512 * 0513 * GET CHARACTER FROM TERMINAL. RETURN 0514 * CHARACTER IN "A" ACCUMULATOR AND PRESERVE 0515 * ALL OTHER REGISTERS. THE INPUT CHARACTER 0516 * IS 8 BITS AND IS NOT ECHOED. 0517 * 0518 * 0519 060D 34 10 INCH PSHS X SAVE IX 0520 060F BE 01 06 GETSTA LDX CPORT POINT TO TERMINAL PORT 0521 0612 A6 84 LDA ,X FETCH PORT STATUS 0522 0614 85 01 BITA #1 TEST READY BIT, RDRF ? 0523 0616 27 F7 BEQ GETSTA IF NOT RDY, THEN TRY AGAIN 0524 0618 A6 01 GETST1 LDA 1,X FETCH CHAR 0525 061A 35 90 PULS X,PC RESTORE IX 0526 * 0527 * INCHEK 0528 * 0529 * CHECK FOR A CHARACTER AVAILABLE FROM 0530 * THE TERMINAL. THE SERIAL PORT IS CHECKED 0531 * FOR READ READY. ALL REGISTERS ARE 0532 * PRESERVED, AND THE "Z" BIT WILL BE 0533 * CLEAR IF A CHARACTER CAN BE READ. 0534 * 0535 * 0536 061C 34 02 INCHEK PSHS A SAVE A ACCUM. 0537 061E A6 9F 01 06 LDA [CPORT] FETCH PORT STATUS 0538 0622 85 01 BITA #1 TEST READY BIT, RDRF ? 0539 0624 35 82 INCHEK1 PULS A,PC RESTORE A ACCUM. 0540 * 0541 0626 8D 00 OUT2S BSR OUT1S OUTPUT 2 SPACES 0542 0628 86 20 OUT1S LDA #$20 OUTPUT 1 SPACE 0543 * 0544 * 0545 * OUTCH 0546 * 0547 * OUTPUT CHARACTER TO TERMINAL. 0548 * THE CHAR. TO BE OUTPUT IS 0549 * PASSED IN THE A REGISTER. 0550 * ALL REGISTERS ARE PRESERVED. 0551 * 0552 062A 34 12 OUTCH PSHS A,X SAVE A ACCUM AND IX 0553 062C BE 01 06 LDX CPORT GET ADDR. OF TERMINAL 0554 062F A6 84 FETSTA LDA ,X FETCH PORT STATUS 0555 0631 85 02 BITA #2 TEST TDRE, OK TO XMIT ? 0556 0633 27 FA BEQ FETSTA IF NOT LOOP UNTIL RDY 0557 0635 35 02 PULS A GET CHAR. FOR XMIT 0558 0637 A7 01 STA 1,X XMIT CHAR. 0559 0639 35 90 PULS X,PC RESTORE IX 0560 * 0561 * 0562 063B BE 01 06 ACINIZ LDX CPORT POINT TO CONTROL PORT ADDRESS 0563 063E 86 03 LDA #3 RESET ACIA PORT CODE 0564 0640 A7 84 STA ,X STORE IN CONTROL REGISTER 0565 0642 86 11 LDA #$11 SET 8 DATA, 2 STOP AN 0 PARITY 0566 0644 A7 84 STA ,X STORE IN CONTROL REGISTER 0567 0646 6D 01 TST 1,X ANYTHING IN DATA REGISTER? 0568 0648 86 FF LDA #$FF TURN ON ECHO FLAG 0569 064A B7 01 08 STA ECHO 0570 064D 39 RTS 0571 * 0572 * MESSAGE STRINGS 0573 * 0574 064E 0A 0D TTLMSG FCB $0A,$0D 0575 0650 43 4F 4D 50 41 43 FCC "COMPACT FLASH SECTOR READ/WRITE UTILITY" 54 20 46 4C 41 53 48 20 53 45 43 54 4F 52 20 52 45 41 44 2F 57 52 49 54 45 20 55 54 49 4C 49 54 59 0576 0677 04 FCB $04 0577 0678 0A 0D CMDMSG FCB $0A,$0D 0578 067A 28 52 29 20 52 45 FCC "(R) READ SECTOR" 41 44 20 53 45 43 54 4F 52 0579 0689 0A 0D FCB $0A,$0D 0580 068B 28 57 29 20 57 52 FCC "(W) WRITE SECTOR" 49 54 45 20 53 45 43 54 4F 52 0581 069B 0A 0D FCB $0A,$0D 0582 069D 28 4E 29 20 4E 45 FCC "(N) NEXT SECTOR" 58 54 20 53 45 43 54 4F 52 0583 06AC 0A 0D FCB $0A,$0D 0584 06AE 28 50 29 20 50 52 FCC "(P) PREV SECTOR" 45 56 20 53 45 43 54 4F 52 0585 06BD 0A 0D FCB $0A,$0D 0586 06BF 28 4D 29 20 4D 4F FCC "(M) MODIFY SECTOR" 44 49 46 59 20 53 45 43 54 4F 52 0587 06D0 0A 0D FCB $0A,$0D 0588 06D2 28 51 29 20 51 55 FCC "(Q) QUIT" 49 54 0589 06DA 0A 0D FCB $0A,$0D 0590 06DC 3A 20 FCC ": " 0591 06DE 04 FCB $04 0592 06DF 53 45 43 54 4F 52 SECPMT FCC "SECTOR NUMBER (6 HEX) : " 20 4E 55 4D 42 45 52 20 28 36 20 48 45 58 29 20 3A 20 0593 06F7 04 FCB $04 0594 06F8 53 45 43 54 4F 52 SECMSG FCC "SECTOR NUMBER - $" 20 4E 55 4D 42 45 52 20 2D 20 24 0595 0709 04 FCB $04 0596 070A 0D 0A MEMMSG FCB $0D,$0A 0597 070C 4D 45 4D 4F 52 59 FCC "MEMORY ADDRESS (3 HEX): " 20 41 44 44 52 45 53 53 20 28 33 20 48 45 58 29 3A 20 0598 0724 04 FCB $04 0599 0725 20 2D 20 MSG5 FCC " - " 0600 0728 04 FCB $04 0601 0729 00 00 0A 0D 00 00 MSG2 FCB $00,$00,$0A,$0D,$00,$00,$00,$04 00 04 0602 0731 57 68 61 74 20 3F WOTMSG FCC "What ?" 0603 0737 0D 0A 04 FCB $0D,$0A,$04 0604 * 0605 END START Program + Init Data = 1018 bytes Error count = 0 1.1 System09/src/dump/dump_cf8.s19 http://www.opencores.org/cvsweb.shtml/System09/src/dump/dump_cf8.s19?rev=1.1&content-type=text/x-cvsweb-markup Index: dump_cf8.s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ystem09/src/dump/dump_cf8.sh http://www.opencores.org/cvsweb.shtml/System09/src/dump/dump_cf8.sh?rev=1.1&content-type=text/x-cvsweb-markup Index: dump_cf8.sh =================================================================== ../../Tools/as09/as09.exe dump_cf8.txt -l > dump_cf8.lst 1.1 System09/src/dump/dump_cf8.txt http://www.opencores.org/cvsweb.shtml/System09/src/dump/dump_cf8.txt?rev=1.1&content-type=text/x-cvsweb-markup Index: dump_cf8.txt =================================================================== * * Sector Dump Utility * For Compact Flash Driver * for the 6809 * Configured in 8 bit mode * * John Kent * 21 May 2007 * * Register Equates * CF_BASE EQU $E040 CF_DATA EQU CF_BASE+0 CF_ERROR EQU CF_BASE+1 ; read error CF_FEATURE EQU CF_BASE+1 ; write feature CF_SECCNT EQU CF_BASE+2 CF_SECNUM EQU CF_BASE+3 CF_CYLLO EQU CF_BASE+4 CF_CYLHI EQU CF_BASE+5 CF_HEAD EQU CF_BASE+6 CF_STATUS EQU CF_BASE+7 ; read status CF_COMAND EQU CF_BASE+7 ; write command * * Command Equates * CMDREAD EQU $20 ; Read Single sector CMDWRITE EQU $30 ; Write Single sector CMDFEATURE EQU $EF FEAT8BIT EQU $01 ; enable 8 bit transfers HEADLBA EQU $E0 * * Status bit equates * BUSY EQU $80 DRDY EQU $40 DRQ EQU $08 ERR EQU $01 * * Start of Program * ORG $0100 START LBRA START1 * * DATA STORAGE * SECNUM FCB $00,$00,$00 CPORT FDB $E000 ECHO FCB $FF * * SECTOR BUFFER * SECBUF RMB 512 * * PROGRAM STACK * RMB 64 STACK EQU * * * Initialization * START1 LDS #STACK * * Clear sector buffer * LDX #SECBUF LDY #512 ZEROLP CLR ,X+ LEAY -1,Y BNE ZEROLP * * INITIALIZE CF CARD FOR 8 BIT LBA MODE * JSR WAITRDY LDA #HEADLBA STA CF_HEAD JSR WAITRDY LDA #FEAT8BIT STA CF_FEATURE LDA #CMDFEATURE STA CF_COMAND JSR WAITRDY * * DISPLAY TITTLE BANNER * LDX #TTLMSG JSR PDATA * * COMMAND LOOP * R - READ * W - WRITE * N - NEXT * P - PREV * M - MODIFY * Q - QUIT * CMDLP LDX #CMDMSG JSR PDATA JSR ECHON CMPA #'R' BEQ READ CMPA #'N' BEQ NEXT CMPA #'P' BEQ PREV CMPA #'W' LBEQ WRITE CMPA #'M' BEQ MODIFY CMPA #'Q' BEQ QUIT LDX #WOTMSG JSR PSTRNG BRA CMDLP * * QUIT * QUIT JMP [$F800] * * MODIFY SECTOR * MODIFY JSR MEMCHG BRA CMDLP * * NEXT SECTOR (READ) * INCREMENT SECTOR NUMBER * WRAPS AROUND TO ZERO ON $FFFFFF * NEXT LDX SECNUM+1 LEAX 1,X STX SECNUM+1 BNE READS INC SECNUM BRA READS * * PREVIOUS SECTOR (READ) * DECREMENT SECTOR NUMBER * DON'T DECREMENT PAST $000000 * PREV LDX SECNUM+1 BNE PREV1 TST SECNUM BEQ READS DEC SECNUM PREV1 LEAX -1,X STX SECNUM+1 BRA READS * * READ SECTORS FROM CF * READ LDX #SECPMT JSR PSTRNG JSR IN6HEX BVS RDEXIT STB SECNUM STX SECNUM+1 * READS LDA #$01 STA CF_SECCNT LDA SECNUM+2 STA CF_SECNUM LDA SECNUM+1 STA CF_CYLLO LDA SECNUM+0 STA CF_CYLHI * LDA #CMDREAD ; IDE READ MULTIPLE STA CF_COMAND JSR WAITRDY * LDX #SECBUF LDY #512 * * READ LOOP * RDLOOP JSR WAITDRQ LDA CF_DATA STA ,X+ LEAY -1,Y BNE RDLOOP * JSR WAITRDY JSR MEMDUMP RDEXIT JMP CMDLP * * WRITE SECTOR TO CF * WRITE LDX #SECPMT JSR PSTRNG JSR IN6HEX BVS WREXIT STB SECNUM STX SECNUM+1 * LDA #$01 STA CF_SECCNT LDA SECNUM+2 STA CF_SECNUM LDA SECNUM+1 STA CF_CYLLO LDA SECNUM+0 STA CF_CYLHI * LDA #CMDWRITE; IDE WRITE MULTIPLE STA CF_COMAND JSR WAITRDY * LDX #SECBUF LDY #512 * * WRITE LOOP * WRLOOP JSR WAITDRQ LDA ,X+ STA CF_DATA LEAY -1,Y BNE WRLOOP * JSR WAITRDY WREXIT JMP CMDLP * * WAIT UNTIL READY * WAITRDY LDA CF_STATUS BITA #BUSY BNE WAITRDY LDA CF_STATUS BITA #DRDY BEQ WAITRDY RTS * * WAIT FOR DATA REQUEST * WAITDRQ LDA CF_STATUS BITA #DRQ BEQ WAITDRQ RTS * * DUMP SECTOR IN MEMORY * MEMDUMP LDX #SECMSG JSR PSTRNG LDA SECNUM JSR OUT2H LDX SECNUM+1 JSR OUT4H JSR PCRLF LDY #$0000 LEAX #$1FF,Y * * ADJUST LOWER AND UPPER ADDRESS LIMITS * TO EVEN 16 BYTE BOUNDRIES. * * IF LOWER ADDR = $4532 * LOWER BOUNDS WILL BE ADJUSTED TO = $4530. * * IF UPPER ADDR = $4567 * UPPER BOUNDS WILL BE ADJUSTED TO = $4570. * * ENTER WITH LOWER ADDRESS IN X-REG. * -UPPER ADDRESS ON TOP OF STACK. * AJDUMP TFR X,D GET UPPER ADDR IN D-REG ADDD #$10 ADD 16 TO UPPER ADDRESS ANDB #$F0 MASK TO EVEN 16 BYTE BOUNDRY PSHS A,B SAVE ON STACK AS UPPER DUMP LIMIT TFR Y,D $F9A5 GET LOWER ADDRESS IN D-REG ANDB #$F0 MASK TO EVEN 16 BYTE BOUNDRY TFR D,X PUT IN X-REG AS LOWER DUMP LIMIT NXTLIN CMPX ,S COMPARE LOWER TO UPPER LIMIT BEQ SKPDMP IF EQUAL SKIP HEX-ASCII DUMP LBSR INCHEK CHECK FOR INPUT FROM KEYBOARD BEQ EDUMP SKPDMP LEAS 2,S READJUST STACK IF NOT DUMPING RTS ; * * PRINT 16 HEX BYTES FOLLOWED BY 16 ASCII CHARACTERS * FOR EACH LINE THROUGHOUT ADDRESS LIMITS. * EDUMP PSHS X PUSH LOWER ADDR LIMIT ON STACK LDX #MSG5 POINT TO MSG " - " LBSR PSTRNG PRINT MSG LDX ,S LOAD LOWER ADDR FROM TOP OF STACK LBSR OUT4H PRINT THE ADDRESS LBSR OUT2S 2 SPACES LDB #$10 LOAD COUNT OF 16 BYTES TO DUMP ELOOP LDA SECBUF,X GET FROM MEMORY HEX BYTE TO PRINT LEAX 1,X LBSR OUT2H OUTPUT HEX BYTE AS ASCII LBSR OUT1S OUTPUT SPACE DECB $F9D1 DECREMENT BYTE COUNT BNE ELOOP CONTINUE TIL 16 HEX BYTES PRINTED * * PRINT 16 ASCII CHARACTERS * IF NOT PRINTABLE OR NOT VALID * ASCII PRINT A PERIOD (.) LBSR OUT2S 2 SPACES LDX ,S++ GET LOW LIMIT FRM STACK - ADJ STACK LDB #$10 SET ASCII CHAR TO PRINT = 16 EDPASC LDA SECBUF,X GET CHARACTER FROM MEMORY LEAX 1,X CMPA #$20 IF LESS THAN $20, NON-PRINTABLE? BCS PERIOD IF SO, PRINT PERIOD INSTEAD CMPA #$7E IS IT VALID ASCII? BLS PRASC IF SO PRINT IT PERIOD LDA #'. LOAD A PERIOD (.) PRASC LBSR OUTCH PRINT ASCII CHARACTER DECB DECREMENT COUNT BNE EDPASC BRA NXTLIN * * ***** "M" MEMORY EXAMINE AND CHANGE ***** * * RESTRICT ADDRESSING RANGE TO 512 BYTES ($000 - $1FF) * MEMCHG LDX #MEMMSG JSR PSTRNG LBSR IN3HEX INPUT ADDRESS BVS CHRTN IF NOT HEX, RETURN CMPX #$0200 BHS CHRTN TFR X,Y SAVE ADDR IN "Y" MEMC2 LDX #MSG5 POINT TO MSG " - " LBSR PSTRNG PRINT MSG TFR Y,X FETCH ADDRESS LBSR OUT4H PRINT ADDR IN HEX LBSR OUT1S OUTPUT SPACE LDA SECBUF,Y GET CONTENTS OF CURRENT ADDR. LBSR OUT2H OUTPUT CONTENTS IN ASCII LBSR OUT1S OUTPUT SPACE LBSR BYTE LOOP WAITING FOR OPERATOR INPUT BVC CHANGE IF VALID HEX GO CHANGE MEM. LOC. CMPA #8 IS IT A BACKSPACE (CNTRL H)? BEQ MEMC2 PROMPT OPERATOR AGAIN CMPA #$18 IS IT A CANCEL (CNTRL X)? BEQ MEMC2 PROMPT OPERATOR AGAIN CMPA #'^ IS IT AN UP ARROW? BEQ BACK DISPLAY PREVIOUS BYTE CMPA #$D IS IT A CR? BNE FORWRD DISPLAY NEXT BYTE CHRTN RTS EXIT ROUTINE * * CHANGE STA SECBUF,Y CHANGE BYTE IN MEMORY CMPA SECBUF,Y DID MEMORY BYTE CHANGE? BEQ FORWRD $F972 LBSR OUT1S OUTPUT SPACE LDA #'? LOAD QUESTION MARK LBSR OUTCH PRINT IT FORWRD CMPY #$01FF BEQ MEMC2 LEAY 1,Y POINT TO NEXT HIGHER MEM LOCATION BRA MEMC2 PRINT LOCATION & CONTENTS BACK CMPY #$0000 BEQ MEMC2 LEAY -1,Y POINT TO LAST MEM LOCATION BRA MEMC2 PRINT LOCATION & CONTENTS * * THE FOLLOWING ROUTINE LOOPS WAITING FOR THE * OPERATOR TO INPUT ONE VALID HEX ADDRESS. THE * ADDRESS IS RETURNED IN THE "X" REGISTER. * * IN6HEX - MS BYTE IN ACCB * LS WORD IN X REG * IN6HEX LEAS -3,S BSR BYTE BVS NOTHEX STA 0,S BSR BYTE BVS NOTHEX STA 1,S BSR BYTE BVS NOTHEX STA 2,S CLRA PULS B,X,PC * * INPUT 3 HEX DIGITS * RESULT RETURNED IN X * IN3HEX BSR INHEX INPUT HEX (1 HEX CHAR) BVS NOTHEX EXIT IF NOT VALID HEX TFR D,X BSR BYTE INPUT BYTE (2 HEX CHAR) BVS NOTHEX PSHS X STA 1,S PULS X,PC * ***** INPUT BYTE (2 HEX CHAR.) ***** * BYTE BSR INHEX GET HEX LEFT BVS NOTHEX EXIT IF NOT VALID HEX ASLA ; ASLA ; ASLA ; SHIFT INTO LEFT NIBBLE ASLA ; TFR A,B PUT HEXL IN "B" BSR INHEX GET HEX RIGHT BVS NOTHEX EXIT IF NOT VALID HEX PSHS B PUSH HEXL ON STACK ADDA ,S+ ADD HEXL TO HEXR AND ADJ. STK RTS RETURN WITH HEX L&R IN "A" * * INHEX BSR ECHON INPUT ASCII CHAR. CMPA #'0 IS IT > OR = "0" ? BCS NOTHEX IF LESS IT AIN'T HEX CMPA #'9 IS IT < OR = "9" ? BHI INHEXA IF > MAYBE IT'S ALPHA SUBA #$30 ASCII ADJ. NUMERIC RTS ; * * INHEXA CMPA #'A IS IT > OR = "A" BCS NOTHEX IF LESS IT AIN'T HEX CMPA #'F IS IT < OR = "F" ? BHI INHEXL IF > IT AIN'T HEX SUBA #$37 ASCII ADJ. ALPHA RTS ; * INHEXL CMPA #'a IS IT > OR = "a" BCS NOTHEX IF LESS IT AIN'T HEX CMPA #'f IS IT < "f" BHI NOTHEX IF > IT AIN'T HEX SUBA #$57 ADJUST TO LOWER CASE RTS ; * * NOTHEX ORCC #2 SET (V) FLAG IN C-CODES REGISTER RTS ; * * OUT4H PSHS X PUSH X-REG. ON THE STACK PULS A POP MS BYTE OF X-REG INTO A-ACC. BSR OUTHL OUTPUT HEX LEFT PULS A POP LS BYTE OF X-REG INTO A-ACC. OUTHL EQU * OUT2H PSHS A SAVE IT BACK ON STACK LSRA CONVERT UPPER HEX NIBBLE TO ASCII LSRA ; LSRA ; LSRA ; BSR XASCII PRINT HEX NIBBLE AS ASCII OUTHR PULS A CONVERT LOWER HEX NIBBLE TO ASCII ANDA #$0F STRIP LEFT NIBBLE XASCII ADDA #$30 ASCII ADJ CMPA #$39 IS IT < OR = "9" ? BLE OUTC IF LESS, OUTPUT IT ADDA #7 IF > MAKE ASCII LETTER OUTC BRA OUTCH OUTPUT CHAR * * BINARY / ASCII --- THIS ROUTINE * OUTPUTS A BYTE IN ENHANCED * BINARY FORMAT. THE ENHANCEMENT * IS DONE BY SUBSTITUTING ASCII * LETTERS FOR THE ONES IN THE BYTE. * THE ASCII ENHANCEMENT LETTERS * ARE OBTAINED FROM THE STRING * POINTED TO BY THE INDEX REG. "X". * BIASCI PSHS A SAVE "A" ON STACK LDB #8 PRESET LOOP# TO BITS PER BYTE OUTBA LDA ,X+ GET LETTER FROM STRING ASL ,S TEST BYTE FOR "1" IN B7 BCS PRTBA IF ONE PRINT LETTER LDA #'- IF ZERO PRINT "-" PRTBA BSR OUTCH PRINT IT BSR OUT1S PRINT SPACE DECB SUB 1 FROM #BITS YET TO PRINT BNE OUTBA PULS A,PC * * PRINT STRING PRECEEDED BY A CR & LF. * PSTRNG BSR PCRLF PRINT CR/LF BRA PDATA PRINT STRING POINTED TO BY IX * * PCRLF * PCRLF PSHS X SAVE IX LDX #MSG2+1 POINT TO MSG CR/LF + 3 NULS BSR PDATA PRINT MSG PULS X,PC RESTORE IX PRINT BSR OUTCH * * PDATA * PDATA LDA ,X+ GET 1st CHAR. TO PRINT CMPA #4 IS IT EOT? BNE PRINT IF NOT EOT PRINT IT RTS ; * * ECHON TST ECHO IS ECHO REQUIRED ? BEQ INCH ECHO NOT REQ. IF CLEAR * * INCHE * * ---GETS CHARACTER FROM TERMINAL AND * ECHOS SAME. THE CHARACTER IS RETURNED * IN THE "A" ACCUMULATOR WITH THE PARITY * BIT MASKED OFF. ALL OTHER REGISTERS * ARE PRESERVED. * INCHE BSR INCH GET CHAR FROM TERMINAL ANDA #$7F STRIP PARITY FROM CHAR. BRA OUTCH ECHO CHAR TO TERMINAL * * INCH * * GET CHARACTER FROM TERMINAL. RETURN * CHARACTER IN "A" ACCUMULATOR AND PRESERVE * ALL OTHER REGISTERS. THE INPUT CHARACTER * IS 8 BITS AND IS NOT ECHOED. * * INCH PSHS X SAVE IX GETSTA LDX CPORT POINT TO TERMINAL PORT LDA ,X FETCH PORT STATUS BITA #1 TEST READY BIT, RDRF ? BEQ GETSTA IF NOT RDY, THEN TRY AGAIN GETST1 LDA 1,X FETCH CHAR PULS X,PC RESTORE IX * * INCHEK * * CHECK FOR A CHARACTER AVAILABLE FROM * THE TERMINAL. THE SERIAL PORT IS CHECKED * FOR READ READY. ALL REGISTERS ARE * PRESERVED, AND THE "Z" BIT WILL BE * CLEAR IF A CHARACTER CAN BE READ. * * INCHEK PSHS A SAVE A ACCUM. LDA [CPORT] FETCH PORT STATUS BITA #1 TEST READY BIT, RDRF ? INCHEK1 PULS A,PC RESTORE A ACCUM. * OUT2S BSR OUT1S OUTPUT 2 SPACES OUT1S LDA #$20 OUTPUT 1 SPACE * * * OUTCH * * OUTPUT CHARACTER TO TERMINAL. * THE CHAR. TO BE OUTPUT IS * PASSED IN THE A REGISTER. * ALL REGISTERS ARE PRESERVED. * OUTCH PSHS A,X SAVE A ACCUM AND IX LDX CPORT GET ADDR. OF TERMINAL FETSTA LDA ,X FETCH PORT STATUS BITA #2 TEST TDRE, OK TO XMIT ? BEQ FETSTA IF NOT LOOP UNTIL RDY PULS A GET CHAR. FOR XMIT STA 1,X XMIT CHAR. PULS X,PC RESTORE IX * * ACINIZ LDX CPORT POINT TO CONTROL PORT ADDRESS LDA #3 RESET ACIA PORT CODE STA ,X STORE IN CONTROL REGISTER LDA #$11 SET 8 DATA, 2 STOP AN 0 PARITY STA ,X STORE IN CONTROL REGISTER TST 1,X ANYTHING IN DATA REGISTER? LDA #$FF TURN ON ECHO FLAG STA ECHO RTS * * MESSAGE STRINGS * TTLMSG FCB $0A,$0D FCC "COMPACT FLASH SECTOR READ/WRITE UTILITY" FCB $04 CMDMSG FCB $0A,$0D FCC "(R) READ SECTOR" FCB $0A,$0D FCC "(W) WRITE SECTOR" FCB $0A,$0D FCC "(N) NEXT SECTOR" FCB $0A,$0D FCC "(P) PREV SECTOR" FCB $0A,$0D FCC "(M) MODIFY SECTOR" FCB $0A,$0D FCC "(Q) QUIT" FCB $0A,$0D FCC ": " FCB $04 SECPMT FCC "SECTOR NUMBER (6 HEX) : " FCB $04 SECMSG FCC "SECTOR NUMBER - $" FCB $04 MEMMSG FCB $0D,$0A FCC "MEMORY ADDRESS (3 HEX): " FCB $04 MSG5 FCC " - " FCB $04 MSG2 FCB $00,$00,$0A,$0D,$00,$00,$00,$04 WOTMSG FCC "What ?" FCB $0D,$0A,$04 * END START 1.1 System09/src/dump/dump_ide.lst http://www.opencores.org/cvsweb.shtml/System09/src/dump/dump_ide.lst?rev=1.1&content-type=text/x-cvsweb-markup Index: dump_ide.lst =================================================================== Assembler release DWC_2.0 version 2.11 May 6, 2004 (c) Motorola (free ware) 0001 * 0002 * Sector Dump Utility 0003 * for IDE Drives or Compact Flash 0004 * for the 6809 0005 * revised for 16 bit peripheral bus 0006 * on XESS XSA-3S1000 / XST-3.0 0007 * 0008 * John Kent 0009 * 1 Feb 2008 0010 * 0011 * SYS09BUG 0012 * 0013 F800 MON_BASE EQU $F800 0014 F800 MONV EQU MON_BASE+0 0015 F802 NEXTCV EQU MON_BASE+2 0016 F804 INCHV EQU MON_BASE+4 0017 F806 INCHEV EQU MON_BASE+6 0018 F808 INCHEKV EQU MON_BASE+8 0019 F80A OUTCHV EQU MON_BASE+10 0020 F80C PDATAV EQU MON_BASE+12 0021 F80E PCRLFV EQU MON_BASE+14 0022 F810 PSTRGV EQU MON_BASE+16 0023 * 0024 * Register Equates 0025 * 0026 E100 CF_BASE EQU $E100 0027 E100 CF_DATA EQU CF_BASE+0 0028 E102 CF_ERROR EQU CF_BASE+2 ; read error 0029 E102 CF_FEATURE EQU CF_BASE+2 ; write feature 0030 E104 CF_SECCNT EQU CF_BASE+4 0031 E106 CF_SECNUM EQU CF_BASE+6 0032 E108 CF_CYLLO EQU CF_BASE+8 0033 E10A CF_CYLHI EQU CF_BASE+10 0034 E10C CF_HEAD EQU CF_BASE+12 0035 E10E CF_STATUS EQU CF_BASE+14 ; read status 0036 E10E CF_COMAND EQU CF_BASE+14 ; write command 0037 E11E CF_AUX EQU CF_BASE+30 0038 * 0039 * Command Equates 0040 * 0041 0006 AUXRESET EQU $06 ; CF_AUX Reset command 0042 0002 AUXRELEA EQU $02 0043 0020 CMDREAD EQU $20 ; Read Single sector 0044 0030 CMDWRITE EQU $30 ; Write Single sector 0045 00E0 HEADLBA EQU $E0 0046 * 0047 * Status bit equates 0048 * 0049 0080 BUSY EQU $80 0050 0040 DRDY EQU $40 0051 0008 DRQ EQU $08 0052 0001 ERR EQU $01 0053 * 0054 * Start of Program 0055 * 0056 0100 ORG $0100 0057 0100 16 02 46 START LBRA START1 0058 * 0059 * DATA STORAGE 0060 * 0061 0103 00 00 00 SECNUM FCB $00,$00,$00 0062 0106 E0 00 CPORT FDB $E000 0063 0108 FF ECHO FCB $FF 0064 * 0065 * SECTOR BUFFER 0066 * 0067 0109 SECBUF RMB 512 0068 * 0069 * PROGRAM STACK 0070 * 0071 0309 RMB 64 0072 0349 STACK EQU * 0073 * 0074 * Initialization 0075 * 0076 0349 10 CE 03 49 START1 LDS #STACK 0077 * 0078 * Clear sector buffer 0079 * 0080 034D 8E 01 09 LDX #SECBUF 0081 0350 10 8E 00 00 LDY #0 0082 0354 C6 00 LDB #0 0083 0356 10 AF 81 ZEROLP STY ,X++ 0084 0359 5A DECB 0085 035A 26 FA BNE ZEROLP 0086 * 0087 * INITIALIZE CF CARD FOR 8 BIT LBA MODE 0088 * 0089 035C CC 00 06 LDD #AUXRESET 0090 035F FD E1 1E STD CF_AUX 0091 0362 CC 00 02 LDD #AUXRELEA 0092 0365 FD E1 1E STD CF_AUX 0093 0368 BD 04 87 JSR WAITRDY 0094 036B CC 00 E0 LDD #HEADLBA 0095 036E FD E1 0C STD CF_HEAD 0096 0371 BD 04 87 JSR WAITRDY 0097 * 0098 * DISPLAY TITTLE BANNER 0099 * 0100 0374 8E 06 48 LDX #TTLMSG 0101 0377 BD 06 2B JSR PDATA 0102 * 0103 * COMMAND LOOP 0104 * R - READ 0105 * W - WRITE 0106 * N - NEXT 0107 * P - PREV 0108 * M - MODIFY 0109 * Q - QUIT 0110 * 0111 037A 8E 06 72 CMDLP LDX #CMDMSG 0112 037D BD 06 2B JSR PDATA 0113 0380 BD 06 2F JSR ECHON 0114 0383 81 52 CMPA #'R' 0115 0385 27 64 BEQ READ 0116 0387 81 4E CMPA #'N' 0117 0389 27 3D BEQ NEXT 0118 038B 81 50 CMPA #'P' 0119 038D 27 48 BEQ PREV 0120 038F 81 57 CMPA #'W' 0121 0391 10 27 00 A5 LBEQ WRITE 0122 0395 81 4D CMPA #'M' 0123 0397 27 2A BEQ MODIFY 0124 0399 81 51 CMPA #'Q' 0125 039B 27 22 BEQ QUIT 0126 039D 81 72 CMPA #'r' 0127 039F 27 4A BEQ READ 0128 03A1 81 6E CMPA #'n' 0129 03A3 27 23 BEQ NEXT 0130 03A5 81 70 CMPA #'p' 0131 03A7 27 2E BEQ PREV 0132 03A9 81 77 CMPA #'w' 0133 03AB 10 27 00 8B LBEQ WRITE 0134 03AF 81 6D CMPA #'m' 0135 03B1 27 10 BEQ MODIFY 0136 03B3 81 71 CMPA #'q' 0137 03B5 27 08 BEQ QUIT 0138 03B7 8E 07 3B LDX #WOTMSG 0139 03BA BD 06 23 JSR PSTRNG 0140 03BD 20 BB BRA CMDLP 0141 * 0142 * QUIT 0143 * 0144 03BF 6E 9F F8 00 QUIT JMP [MONV] 0145 * 0146 * MODIFY SECTOR 0147 * 0148 03C3 BD 05 2A MODIFY JSR MEMCHG 0149 03C6 20 B2 BRA CMDLP 0150 * 0151 * NEXT SECTOR (READ) 0152 * INCREMENT SECTOR NUMBER 0153 * WRAPS AROUND TO ZERO ON $FFFFFF 0154 * 0155 03C8 BE 01 04 NEXT LDX SECNUM+1 0156 03CB 30 01 LEAX 1,X 0157 03CD BF 01 04 STX SECNUM+1 0158 03D0 26 2A BNE READS 0159 03D2 7C 01 03 INC SECNUM 0160 03D5 20 25 BRA READS 0161 * 0162 * PREVIOUS SECTOR (READ) 0163 * DECREMENT SECTOR NUMBER 0164 * DON'T DECREMENT PAST $000000 0165 * 0166 03D7 BE 01 04 PREV LDX SECNUM+1 0167 03DA 26 08 BNE PREV1 0168 03DC 7D 01 03 TST SECNUM 0169 03DF 27 1B BEQ READS 0170 03E1 7A 01 03 DEC SECNUM 0171 03E4 30 1F PREV1 LEAX -1,X 0172 03E6 BF 01 04 STX SECNUM+1 0173 03E9 20 11 BRA READS 0174 * 0175 * READ SECTORS FROM CF 0176 * 0177 03EB 8E 06 E9 READ LDX #SECPMT 0178 03EE BD 06 23 JSR PSTRNG 0179 03F1 BD 05 90 JSR IN6HEX 0180 03F4 29 41 BVS RDEXIT 0181 03F6 F7 01 03 STB SECNUM 0182 03F9 BF 01 04 STX SECNUM+1 0183 * 0184 03FC 4F READS CLRA 0185 03FD C6 01 LDB #$01 0186 03FF FD E1 04 STD CF_SECCNT 0187 * 0188 0402 F6 01 05 LDB SECNUM+2 0189 0405 FD E1 06 STD CF_SECNUM 0190 * 0191 0408 F6 01 04 LDB SECNUM+1 0192 040B FD E1 08 STD CF_CYLLO 0193 * 0194 040E F6 01 03 LDB SECNUM+0 0195 0411 FD E1 0A STD CF_CYLHI 0196 * 0197 0414 C6 20 LDB #CMDREAD ; IDE READ MULTIPLE 0198 0416 FD E1 0E STD CF_COMAND 0199 0419 BD 04 87 JSR WAITRDY 0200 * 0201 041C 8E 01 09 LDX #SECBUF 0202 041F 10 8E 01 00 LDY #256 0203 * 0204 * READ LOOP 0205 * 0206 0423 BD 04 96 RDLOOP JSR WAITDRQ 0207 0426 FC E1 00 LDD CF_DATA ; reverse order of bytes 0208 0429 E7 80 STB ,X+ 0209 042B A7 80 STA ,X+ 0210 042D 31 3F LEAY -1,Y 0211 042F 26 F2 BNE RDLOOP 0212 * 0213 0431 BD 04 87 JSR WAITRDY 0214 0434 BD 04 9E JSR MEMDUMP 0215 0437 7E 03 7A RDEXIT JMP CMDLP 0216 * 0217 * WRITE SECTOR TO CF 0218 * 0219 043A 8E 06 E9 WRITE LDX #SECPMT 0220 043D BD 06 23 JSR PSTRNG 0221 0440 BD 05 90 JSR IN6HEX 0222 0443 29 3F BVS WREXIT 0223 0445 F7 01 03 STB SECNUM 0224 0448 BF 01 04 STX SECNUM+1 0225 * 0226 044B 4F CLRA 0227 044C C6 01 LDB #$01 0228 044E FD E1 04 STD CF_SECCNT 0229 * 0230 0451 F6 01 05 LDB SECNUM+2 0231 0454 FD E1 06 STD CF_SECNUM 0232 * 0233 0457 F6 01 04 LDB SECNUM+1 0234 045A FD E1 08 STD CF_CYLLO 0235 * 0236 045D F6 01 03 LDB SECNUM+0 0237 0460 FD E1 0A STD CF_CYLHI 0238 * 0239 0463 CC 00 30 LDD #CMDWRITE; IDE WRITE MULTIPLE 0240 0466 FD E1 0E STD CF_COMAND 0241 0469 BD 04 87 JSR WAITRDY 0242 * 0243 046C 8E 01 09 LDX #SECBUF 0244 046F 10 8E 01 00 LDY #256 0245 * 0246 * WRITE LOOP 0247 * 0248 0473 BD 04 96 WRLOOP JSR WAITDRQ 0249 0476 E6 80 LDB ,X+ ; reverse order of bytes 0250 0478 A6 80 LDA ,X+ 0251 047A FD E1 00 STD CF_DATA 0252 047D 31 3F LEAY -1,Y 0253 047F 26 F2 BNE WRLOOP 0254 * 0255 0481 BD 04 87 JSR WAITRDY 0256 0484 7E 03 7A WREXIT JMP CMDLP 0257 * 0258 * WAIT UNTIL READY 0259 * 0260 0487 FC E1 0E WAITRDY LDD CF_STATUS 0261 048A C5 80 BITB #BUSY 0262 048C 26 F9 BNE WAITRDY 0263 048E FC E1 0E LDD CF_STATUS 0264 0491 C5 40 BITB #DRDY 0265 0493 27 F2 BEQ WAITRDY 0266 0495 39 RTS 0267 * 0268 * WAIT FOR DATA REQUEST 0269 * 0270 0496 FC E1 0E WAITDRQ LDD CF_STATUS 0271 0499 C5 08 BITB #DRQ 0272 049B 27 F9 BEQ WAITDRQ 0273 049D 39 RTS 0274 * 0275 * DUMP SECTOR IN MEMORY 0276 * 0277 049E 8E 07 02 MEMDUMP LDX #SECMSG 0278 04A1 BD 06 23 JSR PSTRNG 0279 04A4 B6 01 03 LDA SECNUM 0280 04A7 BD 05 F8 JSR OUT2H 0281 04AA BE 01 04 LDX SECNUM+1 0282 04AD BD 05 F0 JSR OUT4H 0283 04B0 BD 06 27 JSR PCRLF 0284 * 0285 * Dump first 256 bytes 0286 * 0287 04B3 10 8E 00 00 LDY #$0000 0288 04B7 30 A9 00 FF LEAX #$0FF,Y 0289 04BB BD 04 CF JSR AJDUMP 0290 * 0291 * Prompt to continue 0292 * 0293 04BE 8E 07 44 LDX #PAGMSG 0294 04C1 BD 06 23 JSR PSTRNG 0295 04C4 BD 06 38 JSR INCH 0296 * 0297 * Dump second 256 bytes 0298 * 0299 04C7 10 8E 01 00 LDY #$0100 0300 04CB 30 A9 00 FF LEAX #$0FF,Y 0301 * 0302 * ADJUST LOWER AND UPPER ADDRESS LIMITS 0303 * TO EVEN 16 BYTE BOUNDRIES. 0304 * 0305 * IF LOWER ADDR = $4532 0306 * LOWER BOUNDS WILL BE ADJUSTED TO = $4530. 0307 * 0308 * IF UPPER ADDR = $4567 0309 * UPPER BOUNDS WILL BE ADJUSTED TO = $4570. 0310 * 0311 * ENTER WITH LOWER ADDRESS IN X-REG. 0312 * -UPPER ADDRESS ON TOP OF STACK. 0313 * 0314 04CF 1F 10 AJDUMP TFR X,D GET UPPER ADDR IN D-REG 0315 04D1 C3 00 10 ADDD #$10 ADD 16 TO UPPER ADDRESS 0316 04D4 C4 F0 ANDB #$F0 MASK TO EVEN 16 BYTE BOUNDRY 0317 04D6 34 06 PSHS A,B SAVE ON STACK AS UPPER DUMP LIMIT 0318 04D8 1F 20 TFR Y,D $F9A5 GET LOWER ADDRESS IN D-REG 0319 04DA C4 F0 ANDB #$F0 MASK TO EVEN 16 BYTE BOUNDRY 0320 04DC 1F 01 TFR D,X PUT IN X-REG AS LOWER DUMP LIMIT 0321 04DE AC E4 NXTLIN CMPX ,S COMPARE LOWER TO UPPER LIMIT 0322 04E0 27 05 BEQ SKPDMP IF EQUAL SKIP HEX-ASCII DUMP 0323 04E2 17 01 57 LBSR INCHEK CHECK FOR INPUT FROM KEYBOARD 0324 04E5 27 03 BEQ EDUMP 0325 04E7 32 62 SKPDMP LEAS 2,S READJUST STACK IF NOT DUMPING 0326 04E9 39 RTS ; 0327 * 0328 * PRINT 16 HEX BYTES FOLLOWED BY 16 ASCII CHARACTERS 0329 * FOR EACH LINE THROUGHOUT ADDRESS LIMITS. 0330 * 0331 04EA 34 10 EDUMP PSHS X PUSH LOWER ADDR LIMIT ON STACK 0332 04EC 8E 07 2F LDX #MSG5 POINT TO MSG " - " 0333 04EF 17 01 31 LBSR PSTRNG PRINT MSG 0334 04F2 AE E4 LDX ,S LOAD LOWER ADDR FROM TOP OF STACK 0335 04F4 17 00 F9 LBSR OUT4H PRINT THE ADDRESS 0336 04F7 17 01 46 LBSR OUT2S 2 SPACES 0337 04FA C6 10 LDB #$10 LOAD COUNT OF 16 BYTES TO DUMP 0338 04FC A6 89 01 09 ELOOP LDA SECBUF,X GET FROM MEMORY HEX BYTE TO PRINT 0339 0500 30 01 LEAX 1,X 0340 0502 17 00 F3 LBSR OUT2H OUTPUT HEX BYTE AS ASCII 0341 0505 17 01 3A LBSR OUT1S OUTPUT SPACE 0342 0508 5A DECB $F9D1 DECREMENT BYTE COUNT 0343 0509 26 F1 BNE ELOOP CONTINUE TIL 16 HEX BYTES PRINTED 0344 * 0345 * PRINT 16 ASCII CHARACTERS 0346 * IF NOT PRINTABLE OR NOT VALID 0347 * ASCII PRINT A PERIOD (.) 0348 050B 17 01 32 LBSR OUT2S 2 SPACES 0349 050E AE E1 LDX ,S++ GET LOW LIMIT FRM STACK - ADJ STACK 0350 0510 C6 10 LDB #$10 SET ASCII CHAR TO PRINT = 16 0351 0512 A6 89 01 09 EDPASC LDA SECBUF,X GET CHARACTER FROM MEMORY 0352 0516 30 01 LEAX 1,X 0353 0518 81 20 CMPA #$20 IF LESS THAN $20, NON-PRINTABLE? 0354 051A 25 04 BCS PERIOD IF SO, PRINT PERIOD INSTEAD 0355 051C 81 7E CMPA #$7E IS IT VALID ASCII? 0356 051E 23 02 BLS PRASC IF SO PRINT IT 0357 0520 86 2E PERIOD LDA #'. LOAD A PERIOD (.) 0358 0522 17 01 1F PRASC LBSR OUTCH PRINT ASCII CHARACTER 0359 0525 5A DECB DECREMENT COUNT 0360 0526 26 EA BNE EDPASC 0361 0528 20 B4 BRA NXTLIN 0362 * 0363 * 0364 ***** "M" MEMORY EXAMINE AND CHANGE ***** 0365 * 0366 * RESTRICT ADDRESSING RANGE TO 512 BYTES ($000 - $1FF) 0367 * 0368 052A 8E 07 14 MEMCHG LDX #MEMMSG 0369 052D BD 06 23 JSR PSTRNG 0370 0530 17 00 74 LBSR IN3HEX INPUT ADDRESS 0371 0533 29 34 BVS CHRTN IF NOT HEX, RETURN 0372 0535 8C 02 00 CMPX #$0200 0373 0538 24 2F BHS CHRTN 0374 053A 1F 12 TFR X,Y SAVE ADDR IN "Y" 0375 053C 8E 07 2F MEMC2 LDX #MSG5 POINT TO MSG " - " 0376 053F 17 00 E1 LBSR PSTRNG PRINT MSG 0377 0542 1F 21 TFR Y,X FETCH ADDRESS 0378 0544 17 00 A9 LBSR OUT4H PRINT ADDR IN HEX 0379 0547 17 00 F8 LBSR OUT1S OUTPUT SPACE 0380 054A A6 A9 01 09 LDA SECBUF,Y GET CONTENTS OF CURRENT ADDR. 0381 054E 17 00 A7 LBSR OUT2H OUTPUT CONTENTS IN ASCII 0382 0551 17 00 EE LBSR OUT1S OUTPUT SPACE 0383 0554 17 00 60 LBSR BYTE LOOP WAITING FOR OPERATOR INPUT 0384 0557 28 11 BVC CHANGE IF VALID HEX GO CHANGE MEM. LOC. 0385 0559 81 08 CMPA #8 IS IT A BACKSPACE (CNTRL H)? 0386 055B 27 DF BEQ MEMC2 PROMPT OPERATOR AGAIN 0387 055D 81 18 CMPA #$18 IS IT A CANCEL (CNTRL X)? 0388 055F 27 DB BEQ MEMC2 PROMPT OPERATOR AGAIN 0389 0561 81 5E CMPA #'^ IS IT AN UP ARROW? 0390 0563 27 21 BEQ BACK DISPLAY PREVIOUS BYTE 0391 0565 81 0D CMPA #$D IS IT A CR? 0392 0567 26 13 BNE FORWRD DISPLAY NEXT BYTE 0393 0569 39 CHRTN RTS EXIT ROUTINE 0394 * 0395 * 0396 056A A7 A9 01 09 CHANGE STA SECBUF,Y CHANGE BYTE IN MEMORY 0397 056E A1 A9 01 09 CMPA SECBUF,Y DID MEMORY BYTE CHANGE? 0398 0572 27 08 BEQ FORWRD $F972 0399 0574 17 00 CB LBSR OUT1S OUTPUT SPACE 0400 0577 86 3F LDA #'? LOAD QUESTION MARK 0401 0579 17 00 C8 LBSR OUTCH PRINT IT 0402 057C 10 8C 01 FF FORWRD CMPY #$01FF 0403 0580 27 BA BEQ MEMC2 0404 0582 31 21 LEAY 1,Y POINT TO NEXT HIGHER MEM LOCATION 0405 0584 20 B6 BRA MEMC2 PRINT LOCATION & CONTENTS 0406 0586 10 8C 00 00 BACK CMPY #$0000 0407 058A 27 B0 BEQ MEMC2 0408 058C 31 3F LEAY -1,Y POINT TO LAST MEM LOCATION 0409 058E 20 AC BRA MEMC2 PRINT LOCATION & CONTENTS 0410 * 0411 * THE FOLLOWING ROUTINE LOOPS WAITING FOR THE 0412 * OPERATOR TO INPUT ONE VALID HEX ADDRESS. THE 0413 * ADDRESS IS RETURNED IN THE "X" REGISTER. 0414 * 0415 * IN6HEX - MS BYTE IN ACCB 0416 * LS WORD IN X REG 0417 * 0418 0590 32 7D IN6HEX LEAS -3,S 0419 0592 8D 23 BSR BYTE 0420 0594 29 57 BVS NOTHEX 0421 0596 A7 E4 STA 0,S 0422 0598 8D 1D BSR BYTE 0423 059A 29 51 BVS NOTHEX 0424 059C A7 61 STA 1,S 0425 059E 8D 17 BSR BYTE 0426 05A0 29 4B BVS NOTHEX 0427 05A2 A7 62 STA 2,S 0428 05A4 4F CLRA 0429 05A5 35 94 PULS B,X,PC 0430 * 0431 * INPUT 3 HEX DIGITS 0432 * RESULT RETURNED IN X 0433 * 0434 05A7 8D 21 IN3HEX BSR INHEX INPUT HEX (1 HEX CHAR) 0435 05A9 29 42 BVS NOTHEX EXIT IF NOT VALID HEX 0436 05AB 1F 01 TFR D,X 0437 05AD 8D 08 BSR BYTE INPUT BYTE (2 HEX CHAR) 0438 05AF 29 3C BVS NOTHEX 0439 05B1 34 10 PSHS X 0440 05B3 A7 61 STA 1,S 0441 05B5 35 90 PULS X,PC 0442 * 0443 ***** INPUT BYTE (2 HEX CHAR.) ***** 0444 * 0445 05B7 8D 11 BYTE BSR INHEX GET HEX LEFT 0446 05B9 29 32 BVS NOTHEX EXIT IF NOT VALID HEX 0447 05BB 48 ASLA ; 0448 05BC 48 ASLA ; 0449 05BD 48 ASLA ; SHIFT INTO LEFT NIBBLE 0450 05BE 48 ASLA ; 0451 05BF 1F 89 TFR A,B PUT HEXL IN "B" 0452 05C1 8D 07 BSR INHEX GET HEX RIGHT 0453 05C3 29 28 BVS NOTHEX EXIT IF NOT VALID HEX 0454 05C5 34 04 PSHS B PUSH HEXL ON STACK 0455 05C7 AB E0 ADDA ,S+ ADD HEXL TO HEXR AND ADJ. STK 0456 05C9 39 RTS RETURN WITH HEX L&R IN "A" 0457 * 0458 * 0459 05CA 8D 63 INHEX BSR ECHON INPUT ASCII CHAR. 0460 05CC 81 30 CMPA #'0 IS IT > OR = "0" ? 0461 05CE 25 1D BCS NOTHEX IF LESS IT AIN'T HEX 0462 05D0 81 39 CMPA #'9 IS IT < OR = "9" ? 0463 05D2 22 03 BHI INHEXA IF > MAYBE IT'S ALPHA 0464 05D4 80 30 SUBA #$30 ASCII ADJ. NUMERIC 0465 05D6 39 RTS ; 0466 * 0467 * 0468 05D7 81 41 INHEXA CMPA #'A IS IT > OR = "A" 0469 05D9 25 12 BCS NOTHEX IF LESS IT AIN'T HEX 0470 05DB 81 46 CMPA #'F IS IT < OR = "F" ? 0471 05DD 22 03 BHI INHEXL IF > IT AIN'T HEX 0472 05DF 80 37 SUBA #$37 ASCII ADJ. ALPHA 0473 05E1 39 RTS ; 0474 * 0475 05E2 81 61 INHEXL CMPA #'a IS IT > OR = "a" 0476 05E4 25 07 BCS NOTHEX IF LESS IT AIN'T HEX 0477 05E6 81 66 CMPA #'f IS IT < "f" 0478 05E8 22 03 BHI NOTHEX IF > IT AIN'T HEX 0479 05EA 80 57 SUBA #$57 ADJUST TO LOWER CASE 0480 05EC 39 RTS ; 0481 * 0482 * 0483 05ED 1A 02 NOTHEX ORCC #2 SET (V) FLAG IN C-CODES REGISTER 0484 05EF 39 RTS ; 0485 * 0486 * 0487 05F0 34 10 OUT4H PSHS X PUSH X-REG. ON THE STACK 0488 05F2 35 02 PULS A POP MS BYTE OF X-REG INTO A-ACC. 0489 05F4 8D 02 BSR OUTHL OUTPUT HEX LEFT 0490 05F6 35 02 PULS A POP LS BYTE OF X-REG INTO A-ACC. 0491 05F8 OUTHL EQU * 0492 05F8 34 02 OUT2H PSHS A SAVE IT BACK ON STACK 0493 05FA 44 LSRA CONVERT UPPER HEX NIBBLE TO ASCII 0494 05FB 44 LSRA ; 0495 05FC 44 LSRA ; 0496 05FD 44 LSRA ; 0497 05FE 8D 04 BSR XASCII PRINT HEX NIBBLE AS ASCII 0498 0600 35 02 OUTHR PULS A CONVERT LOWER HEX NIBBLE TO ASCII 0499 0602 84 0F ANDA #$0F STRIP LEFT NIBBLE 0500 0604 8B 30 XASCII ADDA #$30 ASCII ADJ 0501 0606 81 39 CMPA #$39 IS IT < OR = "9" ? 0502 0608 2F 02 BLE OUTC IF LESS, OUTPUT IT 0503 060A 8B 07 ADDA #7 IF > MAKE ASCII LETTER 0504 060C 20 36 OUTC BRA OUTCH OUTPUT CHAR 0505 * 0506 * BINARY / ASCII --- THIS ROUTINE 0507 * OUTPUTS A BYTE IN ENHANCED 0508 * BINARY FORMAT. THE ENHANCEMENT 0509 * IS DONE BY SUBSTITUTING ASCII 0510 * LETTERS FOR THE ONES IN THE BYTE. 0511 * THE ASCII ENHANCEMENT LETTERS 0512 * ARE OBTAINED FROM THE STRING 0513 * POINTED TO BY THE INDEX REG. "X". 0514 * 0515 060E 34 02 BIASCI PSHS A SAVE "A" ON STACK 0516 0610 C6 08 LDB #8 PRESET LOOP# TO BITS PER BYTE 0517 0612 A6 80 OUTBA LDA ,X+ GET LETTER FROM STRING 0518 0614 68 E4 ASL ,S TEST BYTE FOR "1" IN B7 0519 0616 25 02 BCS PRTBA IF ONE PRINT LETTER 0520 0618 86 2D LDA #'- IF ZERO PRINT "-" 0521 061A 8D 28 PRTBA BSR OUTCH PRINT IT 0522 061C 8D 24 BSR OUT1S PRINT SPACE 0523 061E 5A DECB SUB 1 FROM #BITS YET TO PRINT 0524 061F 26 F1 BNE OUTBA 0525 0621 35 82 PULS A,PC 0526 * 0527 * PRINT STRING PRECEEDED BY A CR & LF. 0528 * 0529 0623 6E 9F F8 10 PSTRNG JMP [PSTRGV] PRINT CR/LF 0530 * 0531 * PCRLF 0532 * 0533 0627 6E 9F F8 0E PCRLF JMP [PCRLFV] 0534 * 0535 * PDATA 0536 * 0537 062B 6E 9F F8 0C PDATA JMP [PDATAV] 0538 * 0539 062F 7D 01 08 ECHON TST ECHO IS ECHO REQUIRED ? 0540 0632 27 04 BEQ INCH ECHO NOT REQ. IF CLEAR 0541 * 0542 * INCHE 0543 * 0544 * ---GETS CHARACTER FROM TERMINAL AND 0545 * ECHOS SAME. THE CHARACTER IS RETURNED 0546 * IN THE "A" ACCUMULATOR WITH THE PARITY 0547 * BIT MASKED OFF. ALL OTHER REGISTERS 0548 * ARE PRESERVED. 0549 * 0550 0634 6E 9F F8 06 INCHE JMP [INCHEV] 0551 * 0552 * INCH 0553 * 0554 * GET CHARACTER FROM TERMINAL. RETURN 0555 * CHARACTER IN "A" ACCUMULATOR AND PRESERVE 0556 * ALL OTHER REGISTERS. THE INPUT CHARACTER 0557 * IS 8 BITS AND IS NOT ECHOED. 0558 * 0559 * 0560 0638 6E 9F F8 04 INCH JMP [INCHV] 0561 * 0562 * INCHEK 0563 * 0564 * CHECK FOR A CHARACTER AVAILABLE FROM 0565 * THE TERMINAL. THE SERIAL PORT IS CHECKED 0566 * FOR READ READY. ALL REGISTERS ARE 0567 * PRESERVED, AND THE "Z" BIT WILL BE 0568 * CLEAR IF A CHARACTER CAN BE READ. 0569 * 0570 * 0571 063C 6E 9F F8 08 INCHEK JMP [INCHEKV] 0572 * 0573 0640 8D 00 OUT2S BSR OUT1S OUTPUT 2 SPACES 0574 0642 86 20 OUT1S LDA #$20 OUTPUT 1 SPACE 0575 * 0576 * 0577 * OUTCH 0578 * 0579 * OUTPUT CHARACTER TO TERMINAL. 0580 * THE CHAR. TO BE OUTPUT IS 0581 * PASSED IN THE A REGISTER. 0582 * ALL REGISTERS ARE PRESERVED. 0583 * 0584 0644 6E 9F F8 0A OUTCH JMP [OUTCHV] 0585 * 0586 * MESSAGE STRINGS 0587 * 0588 0648 0A 0D TTLMSG FCB $0A,$0D 0589 064A 43 4F 4D 50 41 43 FCC "COMPACT FLASH SECTOR READ/WRITE UTILITY" 54 20 46 4C 41 53 48 20 53 45 43 54 4F 52 20 52 45 41 44 2F 57 52 49 54 45 20 55 54 49 4C 49 54 59 0590 0671 04 FCB $04 0591 0672 0D 0A CMDMSG FCB $0D,$0A 0592 0674 28 52 29 20 52 45 FCC "(R) READ SECTOR " 41 44 20 53 45 43 54 4F 52 20 20 20 0593 0686 28 57 29 20 57 52 FCC "(W) WRITE SECTOR " 49 54 45 20 53 45 43 54 4F 52 20 20 0594 0698 0D 0A FCB $0D,$0A 0595 069A 28 4E 29 20 4E 45 FCC "(N) NEXT SECTOR " 58 54 20 53 45 43 54 4F 52 20 20 20 0596 06AC 28 50 29 20 50 52 FCC "(P) PREV SECTOR " 45 56 20 53 45 43 54 4F 52 20 20 20 0597 06BE 0D 0A FCB $0D,$0A 0598 06C0 28 4D 29 20 4D 4F FCC "(M) MODIFY SECTOR " 44 49 46 59 20 53 45 43 54 4F 52 20 0599 06D2 28 51 29 20 51 55 FCC "(Q) QUIT " 49 54 20 20 20 20 20 20 20 20 20 20 0600 06E4 0D 0A FCB $0D,$0A 0601 06E6 3A 20 FCC ": " 0602 06E8 04 FCB $04 0603 06E9 53 45 43 54 4F 52 SECPMT FCC "SECTOR NUMBER (6 HEX) : " 20 4E 55 4D 42 45 52 20 28 36 20 48 45 58 29 20 3A 20 0604 0701 04 FCB $04 0605 0702 53 45 43 54 4F 52 SECMSG FCC "SECTOR NUMBER - $" 20 4E 55 4D 42 45 52 20 2D 20 24 0606 0713 04 FCB $04 0607 0714 0D 0A MEMMSG FCB $0D,$0A 0608 0716 4D 45 4D 4F 52 59 FCC "MEMORY ADDRESS (3 HEX): " 20 41 44 44 52 45 53 53 20 28 33 20 48 45 58 29 3A 20 0609 072E 04 FCB $04 0610 072F 20 2D 20 MSG5 FCC " - " 0611 0732 04 FCB $04 0612 0733 00 00 0A 0D 00 00 MSG2 FCB $00,$00,$0A,$0D,$00,$00,$00,$04 00 04 0613 073B 57 68 61 74 20 3F WOTMSG FCC "What ?" 0614 0741 0D 0A 04 FCB $0D,$0A,$04 0615 0744 0D 0A PAGMSG FCB $0D,$0A 0616 0746 48 69 74 20 61 6E FCC "Hit any key to continue" 79 20 6B 65 79 20 74 6F 20 63 6F 6E 74 69 6E 75 65 0617 075D 04 FCB $04 0618 * 0619 END START Program + Init Data = 1054 bytes Error count = 0 1.1 System09/src/dump/dump_ide.s19 http://www.opencores.org/cvsweb.shtml/System09/src/dump/dump_ide.s19?rev=1.1&content-type=text/x-cvsweb-markup Index: dump_ide.s19 =================================================================== S10C0100160246000000E000FFB5 S123034910CE03498E0109108E0000C60010AF815A26FACC0006FDE11ECC0002FDE11EBD5B S12303690487CC00E0FDE10CBD04878E0648BD062B8E0672BD062BBD062F81522764814E2A S1230389273D815027488157102700A5814D272A815127228172274A816E27238170272EDB S12303A981771027008B816D2710817127088E073BBD062320BB6E9FF800BD052A20B2BE1E S12303C901043001BF0104262A7C01032025BE010426087D0103271B7A0103301FBF0104BC S12303E920118E06E9BD0623BD05902941F70103BF01044FC601FDE104F60105FDE106F613 S12304090104FDE108F60103FDE10AC620FDE10EBD04878E0109108E0100BD0496FCE1007D S1230429E780A780313F26F2BD0487BD049E7E037A8E06E9BD0623BD0590293FF70103BF20 S123044901044FC601FDE104F60105FDE106F60104FDE108F60103FDE10ACC0030FDE10E07 S1230469BD04878E0109108E0100BD0496E680A680FDE100313F26F2BD04877E037AFCE187 S12304890EC58026F9FCE10EC54027F239FCE10EC50827F9398E0702BD0623B60103BD0591 S12304A9F8BE0104BD05F0BD0627108E000030A900FFBD04CF8E0744BD0623BD0638108E7A S12304C9010030A900FF1F10C30010C4F034061F20C4F01F01ACE42705170157270332624A S12304E93934108E072F170131AEE41700F9170146C610A689010930011700F317013A5A6F S123050926F1170132AEE1C610A6890109300181202504817E2302862E17011F5A26EA203B S1230529B48E0714BD062317007429348C0200242F1F128E072F1700E11F211700A917009E S1230549F8A6A901091700A71700EE1700602811810827DF811827DB815E2721810D2613B2 S123056939A7A90109A1A9010927081700CB863F1700C8108C01FF27BA312120B6108C0091 S12305890027B0313F20AC327D8D232957A7E48D1D2951A7618D17294BA7624F35948D21BE S12305A929421F018D08293C3410A76135908D112932484848481F898D0729283404ABE02F S12305C9398D638130251D813922038030398141251281462203803739816125078166223E S12305E9038057391A0239341035028D0235023402444444448D043502840F8B3081392F00 S1230609028B0720363402C608A68068E42502862D8D288D245A26F135826E9FF8106E9FE3 S1230629F80E6E9FF80C7D010827046E9FF8066E9FF8046E9FF8088D0086206E9FF80A0A78 S12306490D434F4D5041435420464C41534820534543544F5220524541442F575249544505 S1230669205554494C495459040D0A285229205245414420534543544F5220202028572927 S123068920575249544520534543544F5220200D0A284E29204E45585420534543544F526D S12306A9202020285029205052455620534543544F522020200D0A284D29204D4F4449463B S12306C95920534543544F52202851292051554954202020202020202020200D0A3A2004EA S12306E9534543544F52204E554D4245522028362048455829203A2004534543544F52201A S12307094E554D424552202D2024040D0A4D454D4F52592041444452455353202833204875 S12307294558293A2004202D200400000A0D0000000457686174203F0D0A040D0A486974B2 S118074920616E79206B657920746F20636F6E74696E7565043A S9030000FC 1.1 System09/src/dump/dump_ide.sh http://www.opencores.org/cvsweb.shtml/System09/src/dump/dump_ide.sh?rev=1.1&content-type=text/x-cvsweb-markup Index: dump_ide.sh =================================================================== ../../Tools/as09/as09.exe dump_ide.txt -l > dump_ide.lst 1.1 System09/src/dump/dump_ide.txt http://www.opencores.org/cvsweb.shtml/System09/src/dump/dump_ide.txt?rev=1.1&content-type=text/x-cvsweb-markup Index: dump_ide.txt =================================================================== * * Sector Dump Utility * for IDE Drives or Compact Flash * for the 6809 * revised for 16 bit peripheral bus * on XESS XSA-3S1000 / XST-3.0 * * John Kent * 1 Feb 2008 * * SYS09BUG * MON_BASE EQU $F800 MONV EQU MON_BASE+0 NEXTCV EQU MON_BASE+2 INCHV EQU MON_BASE+4 INCHEV EQU MON_BASE+6 INCHEKV EQU MON_BASE+8 OUTCHV EQU MON_BASE+10 PDATAV EQU MON_BASE+12 PCRLFV EQU MON_BASE+14 PSTRGV EQU MON_BASE+16 * * Register Equates * CF_BASE EQU $E100 CF_DATA EQU CF_BASE+0 CF_ERROR EQU CF_BASE+2 ; read error CF_FEATURE EQU CF_BASE+2 ; write feature CF_SECCNT EQU CF_BASE+4 CF_SECNUM EQU CF_BASE+6 CF_CYLLO EQU CF_BASE+8 CF_CYLHI EQU CF_BASE+10 CF_HEAD EQU CF_BASE+12 CF_STATUS EQU CF_BASE+14 ; read status CF_COMAND EQU CF_BASE+14 ; write command CF_AUX EQU CF_BASE+30 * * Command Equates * AUXRESET EQU $06 ; CF_AUX Reset command AUXRELEA EQU $02 CMDREAD EQU $20 ; Read Single sector CMDWRITE EQU $30 ; Write Single sector HEADLBA EQU $E0 * * Status bit equates * BUSY EQU $80 DRDY EQU $40 DRQ EQU $08 ERR EQU $01 * * Start of Program * ORG $0100 START LBRA START1 * * DATA STORAGE * SECNUM FCB $00,$00,$00 CPORT FDB $E000 ECHO FCB $FF * * SECTOR BUFFER * SECBUF RMB 512 * * PROGRAM STACK * RMB 64 STACK EQU * * * Initialization * START1 LDS #STACK * * Clear sector buffer * LDX #SECBUF LDY #0 LDB #0 ZEROLP STY ,X++ DECB BNE ZEROLP * * INITIALIZE CF CARD FOR 8 BIT LBA MODE * LDD #AUXRESET STD CF_AUX LDD #AUXRELEA STD CF_AUX JSR WAITRDY LDD #HEADLBA STD CF_HEAD JSR WAITRDY * * DISPLAY TITTLE BANNER * LDX #TTLMSG JSR PDATA * * COMMAND LOOP * R - READ * W - WRITE * N - NEXT * P - PREV * M - MODIFY * Q - QUIT * CMDLP LDX #CMDMSG JSR PDATA JSR ECHON CMPA #'R' BEQ READ CMPA #'N' BEQ NEXT CMPA #'P' BEQ PREV CMPA #'W' LBEQ WRITE CMPA #'M' BEQ MODIFY CMPA #'Q' BEQ QUIT CMPA #'r' BEQ READ CMPA #'n' BEQ NEXT CMPA #'p' BEQ PREV CMPA #'w' LBEQ WRITE CMPA #'m' BEQ MODIFY CMPA #'q' BEQ QUIT LDX #WOTMSG JSR PSTRNG BRA CMDLP * * QUIT * QUIT JMP [MONV] * * MODIFY SECTOR * MODIFY JSR MEMCHG BRA CMDLP * * NEXT SECTOR (READ) * INCREMENT SECTOR NUMBER * WRAPS AROUND TO ZERO ON $FFFFFF * NEXT LDX SECNUM+1 LEAX 1,X STX SECNUM+1 BNE READS INC SECNUM BRA READS * * PREVIOUS SECTOR (READ) * DECREMENT SECTOR NUMBER * DON'T DECREMENT PAST $000000 * PREV LDX SECNUM+1 BNE PREV1 TST SECNUM BEQ READS DEC SECNUM PREV1 LEAX -1,X STX SECNUM+1 BRA READS * * READ SECTORS FROM CF * READ LDX #SECPMT JSR PSTRNG JSR IN6HEX BVS RDEXIT STB SECNUM STX SECNUM+1 * READS CLRA LDB #$01 STD CF_SECCNT * LDB SECNUM+2 STD CF_SECNUM * LDB SECNUM+1 STD CF_CYLLO * LDB SECNUM+0 STD CF_CYLHI * LDB #CMDREAD ; IDE READ MULTIPLE STD CF_COMAND JSR WAITRDY * LDX #SECBUF LDY #256 * * READ LOOP * RDLOOP JSR WAITDRQ LDD CF_DATA ; reverse order of bytes STB ,X+ STA ,X+ LEAY -1,Y BNE RDLOOP * JSR WAITRDY JSR MEMDUMP RDEXIT JMP CMDLP * * WRITE SECTOR TO CF * WRITE LDX #SECPMT JSR PSTRNG JSR IN6HEX BVS WREXIT STB SECNUM STX SECNUM+1 * CLRA LDB #$01 STD CF_SECCNT * LDB SECNUM+2 STD CF_SECNUM * LDB SECNUM+1 STD CF_CYLLO * LDB SECNUM+0 STD CF_CYLHI * LDD #CMDWRITE; IDE WRITE MULTIPLE STD CF_COMAND JSR WAITRDY * LDX #SECBUF LDY #256 * * WRITE LOOP * WRLOOP JSR WAITDRQ LDB ,X+ ; reverse order of bytes LDA ,X+ STD CF_DATA LEAY -1,Y BNE WRLOOP * JSR WAITRDY WREXIT JMP CMDLP * * WAIT UNTIL READY * WAITRDY LDD CF_STATUS BITB #BUSY BNE WAITRDY LDD CF_STATUS BITB #DRDY BEQ WAITRDY RTS * * WAIT FOR DATA REQUEST * WAITDRQ LDD CF_STATUS BITB #DRQ BEQ WAITDRQ RTS * * DUMP SECTOR IN MEMORY * MEMDUMP LDX #SECMSG JSR PSTRNG LDA SECNUM JSR OUT2H LDX SECNUM+1 JSR OUT4H JSR PCRLF * * Dump first 256 bytes * LDY #$0000 LEAX #$0FF,Y JSR AJDUMP * * Prompt to continue * LDX #PAGMSG JSR PSTRNG JSR INCH * * Dump second 256 bytes * LDY #$0100 LEAX #$0FF,Y * * ADJUST LOWER AND UPPER ADDRESS LIMITS * TO EVEN 16 BYTE BOUNDRIES. * * IF LOWER ADDR = $4532 * LOWER BOUNDS WILL BE ADJUSTED TO = $4530. * * IF UPPER ADDR = $4567 * UPPER BOUNDS WILL BE ADJUSTED TO = $4570. * * ENTER WITH LOWER ADDRESS IN X-REG. * -UPPER ADDRESS ON TOP OF STACK. * AJDUMP TFR X,D GET UPPER ADDR IN D-REG ADDD #$10 ADD 16 TO UPPER ADDRESS ANDB #$F0 MASK TO EVEN 16 BYTE BOUNDRY PSHS A,B SAVE ON STACK AS UPPER DUMP LIMIT TFR Y,D $F9A5 GET LOWER ADDRESS IN D-REG ANDB #$F0 MASK TO EVEN 16 BYTE BOUNDRY TFR D,X PUT IN X-REG AS LOWER DUMP LIMIT NXTLIN CMPX ,S COMPARE LOWER TO UPPER LIMIT BEQ SKPDMP IF EQUAL SKIP HEX-ASCII DUMP LBSR INCHEK CHECK FOR INPUT FROM KEYBOARD BEQ EDUMP SKPDMP LEAS 2,S READJUST STACK IF NOT DUMPING RTS ; * * PRINT 16 HEX BYTES FOLLOWED BY 16 ASCII CHARACTERS * FOR EACH LINE THROUGHOUT ADDRESS LIMITS. * EDUMP PSHS X PUSH LOWER ADDR LIMIT ON STACK LDX #MSG5 POINT TO MSG " - " LBSR PSTRNG PRINT MSG LDX ,S LOAD LOWER ADDR FROM TOP OF STACK LBSR OUT4H PRINT THE ADDRESS LBSR OUT2S 2 SPACES LDB #$10 LOAD COUNT OF 16 BYTES TO DUMP ELOOP LDA SECBUF,X GET FROM MEMORY HEX BYTE TO PRINT LEAX 1,X LBSR OUT2H OUTPUT HEX BYTE AS ASCII LBSR OUT1S OUTPUT SPACE DECB $F9D1 DECREMENT BYTE COUNT BNE ELOOP CONTINUE TIL 16 HEX BYTES PRINTED * * PRINT 16 ASCII CHARACTERS * IF NOT PRINTABLE OR NOT VALID * ASCII PRINT A PERIOD (.) LBSR OUT2S 2 SPACES LDX ,S++ GET LOW LIMIT FRM STACK - ADJ STACK LDB #$10 SET ASCII CHAR TO PRINT = 16 EDPASC LDA SECBUF,X GET CHARACTER FROM MEMORY LEAX 1,X CMPA #$20 IF LESS THAN $20, NON-PRINTABLE? BCS PERIOD IF SO, PRINT PERIOD INSTEAD CMPA #$7E IS IT VALID ASCII? BLS PRASC IF SO PRINT IT PERIOD LDA #'. LOAD A PERIOD (.) PRASC LBSR OUTCH PRINT ASCII CHARACTER DECB DECREMENT COUNT BNE EDPASC BRA NXTLIN * * ***** "M" MEMORY EXAMINE AND CHANGE ***** * * RESTRICT ADDRESSING RANGE TO 512 BYTES ($000 - $1FF) * MEMCHG LDX #MEMMSG JSR PSTRNG LBSR IN3HEX INPUT ADDRESS BVS CHRTN IF NOT HEX, RETURN CMPX #$0200 BHS CHRTN TFR X,Y SAVE ADDR IN "Y" MEMC2 LDX #MSG5 POINT TO MSG " - " LBSR PSTRNG PRINT MSG TFR Y,X FETCH ADDRESS LBSR OUT4H PRINT ADDR IN HEX LBSR OUT1S OUTPUT SPACE LDA SECBUF,Y GET CONTENTS OF CURRENT ADDR. LBSR OUT2H OUTPUT CONTENTS IN ASCII LBSR OUT1S OUTPUT SPACE LBSR BYTE LOOP WAITING FOR OPERATOR INPUT BVC CHANGE IF VALID HEX GO CHANGE MEM. LOC. CMPA #8 IS IT A BACKSPACE (CNTRL H)? BEQ MEMC2 PROMPT OPERATOR AGAIN CMPA #$18 IS IT A CANCEL (CNTRL X)? BEQ MEMC2 PROMPT OPERATOR AGAIN CMPA #'^ IS IT AN UP ARROW? BEQ BACK DISPLAY PREVIOUS BYTE CMPA #$D IS IT A CR? BNE FORWRD DISPLAY NEXT BYTE CHRTN RTS EXIT ROUTINE * * CHANGE STA SECBUF,Y CHANGE BYTE IN MEMORY CMPA SECBUF,Y DID MEMORY BYTE CHANGE? BEQ FORWRD $F972 LBSR OUT1S OUTPUT SPACE LDA #'? LOAD QUESTION MARK LBSR OUTCH PRINT IT FORWRD CMPY #$01FF BEQ MEMC2 LEAY 1,Y POINT TO NEXT HIGHER MEM LOCATION BRA MEMC2 PRINT LOCATION & CONTENTS BACK CMPY #$0000 BEQ MEMC2 LEAY -1,Y POINT TO LAST MEM LOCATION BRA MEMC2 PRINT LOCATION & CONTENTS * * THE FOLLOWING ROUTINE LOOPS WAITING FOR THE * OPERATOR TO INPUT ONE VALID HEX ADDRESS. THE * ADDRESS IS RETURNED IN THE "X" REGISTER. * * IN6HEX - MS BYTE IN ACCB * LS WORD IN X REG * IN6HEX LEAS -3,S BSR BYTE BVS NOTHEX STA 0,S BSR BYTE BVS NOTHEX STA 1,S BSR BYTE BVS NOTHEX STA 2,S CLRA PULS B,X,PC * * INPUT 3 HEX DIGITS * RESULT RETURNED IN X * IN3HEX BSR INHEX INPUT HEX (1 HEX CHAR) BVS NOTHEX EXIT IF NOT VALID HEX TFR D,X BSR BYTE INPUT BYTE (2 HEX CHAR) BVS NOTHEX PSHS X STA 1,S PULS X,PC * ***** INPUT BYTE (2 HEX CHAR.) ***** * BYTE BSR INHEX GET HEX LEFT BVS NOTHEX EXIT IF NOT VALID HEX ASLA ; ASLA ; ASLA ; SHIFT INTO LEFT NIBBLE ASLA ; TFR A,B PUT HEXL IN "B" BSR INHEX GET HEX RIGHT BVS NOTHEX EXIT IF NOT VALID HEX PSHS B PUSH HEXL ON STACK ADDA ,S+ ADD HEXL TO HEXR AND ADJ. STK RTS RETURN WITH HEX L&R IN "A" * * INHEX BSR ECHON INPUT ASCII CHAR. CMPA #'0 IS IT > OR = "0" ? BCS NOTHEX IF LESS IT AIN'T HEX CMPA #'9 IS IT < OR = "9" ? BHI INHEXA IF > MAYBE IT'S ALPHA SUBA #$30 ASCII ADJ. NUMERIC RTS ; * * INHEXA CMPA #'A IS IT > OR = "A" BCS NOTHEX IF LESS IT AIN'T HEX CMPA #'F IS IT < OR = "F" ? BHI INHEXL IF > IT AIN'T HEX SUBA #$37 ASCII ADJ. ALPHA RTS ; * INHEXL CMPA #'a IS IT > OR = "a" BCS NOTHEX IF LESS IT AIN'T HEX CMPA #'f IS IT < "f" BHI NOTHEX IF > IT AIN'T HEX SUBA #$57 ADJUST TO LOWER CASE RTS ; * * NOTHEX ORCC #2 SET (V) FLAG IN C-CODES REGISTER RTS ; * * OUT4H PSHS X PUSH X-REG. ON THE STACK PULS A POP MS BYTE OF X-REG INTO A-ACC. BSR OUTHL OUTPUT HEX LEFT PULS A POP LS BYTE OF X-REG INTO A-ACC. OUTHL EQU * OUT2H PSHS A SAVE IT BACK ON STACK LSRA CONVERT UPPER HEX NIBBLE TO ASCII LSRA ; LSRA ; LSRA ; BSR XASCII PRINT HEX NIBBLE AS ASCII OUTHR PULS A CONVERT LOWER HEX NIBBLE TO ASCII ANDA #$0F STRIP LEFT NIBBLE XASCII ADDA #$30 ASCII ADJ CMPA #$39 IS IT < OR = "9" ? BLE OUTC IF LESS, OUTPUT IT ADDA #7 IF > MAKE ASCII LETTER OUTC BRA OUTCH OUTPUT CHAR * * BINARY / ASCII --- THIS ROUTINE * OUTPUTS A BYTE IN ENHANCED * BINARY FORMAT. THE ENHANCEMENT * IS DONE BY SUBSTITUTING ASCII * LETTERS FOR THE ONES IN THE BYTE. * THE ASCII ENHANCEMENT LETTERS * ARE OBTAINED FROM THE STRING * POINTED TO BY THE INDEX REG. "X". * BIASCI PSHS A SAVE "A" ON STACK LDB #8 PRESET LOOP# TO BITS PER BYTE OUTBA LDA ,X+ GET LETTER FROM STRING ASL ,S TEST BYTE FOR "1" IN B7 BCS PRTBA IF ONE PRINT LETTER LDA #'- IF ZERO PRINT "-" PRTBA BSR OUTCH PRINT IT BSR OUT1S PRINT SPACE DECB SUB 1 FROM #BITS YET TO PRINT BNE OUTBA PULS A,PC * * PRINT STRING PRECEEDED BY A CR & LF. * PSTRNG JMP [PSTRGV] PRINT CR/LF * * PCRLF * PCRLF JMP [PCRLFV] * * PDATA * PDATA JMP [PDATAV] * ECHON TST ECHO IS ECHO REQUIRED ? BEQ INCH ECHO NOT REQ. IF CLEAR * * INCHE * * ---GETS CHARACTER FROM TERMINAL AND * ECHOS SAME. THE CHARACTER IS RETURNED * IN THE "A" ACCUMULATOR WITH THE PARITY * BIT MASKED OFF. ALL OTHER REGISTERS * ARE PRESERVED. * INCHE JMP [INCHEV] * * INCH * * GET CHARACTER FROM TERMINAL. RETURN * CHARACTER IN "A" ACCUMULATOR AND PRESERVE * ALL OTHER REGISTERS. THE INPUT CHARACTER * IS 8 BITS AND IS NOT ECHOED. * * INCH JMP [INCHV] * * INCHEK * * CHECK FOR A CHARACTER AVAILABLE FROM * THE TERMINAL. THE SERIAL PORT IS CHECKED * FOR READ READY. ALL REGISTERS ARE * PRESERVED, AND THE "Z" BIT WILL BE * CLEAR IF A CHARACTER CAN BE READ. * * INCHEK JMP [INCHEKV] * OUT2S BSR OUT1S OUTPUT 2 SPACES OUT1S LDA #$20 OUTPUT 1 SPACE * * * OUTCH * * OUTPUT CHARACTER TO TERMINAL. * THE CHAR. TO BE OUTPUT IS * PASSED IN THE A REGISTER. * ALL REGISTERS ARE PRESERVED. * OUTCH JMP [OUTCHV] * * MESSAGE STRINGS * TTLMSG FCB $0A,$0D FCC "COMPACT FLASH SECTOR READ/WRITE UTILITY" FCB $04 CMDMSG FCB $0D,$0A FCC "(R) READ SECTOR " FCC "(W) WRITE SECTOR " FCB $0D,$0A FCC "(N) NEXT SECTOR " FCC "(P) PREV SECTOR " FCB $0D,$0A FCC "(M) MODIFY SECTOR " FCC "(Q) QUIT " FCB $0D,$0A FCC ": " FCB $04 SECPMT FCC "SECTOR NUMBER (6 HEX) : " FCB $04 SECMSG FCC "SECTOR NUMBER - $" FCB $04 MEMMSG FCB $0D,$0A FCC "MEMORY ADDRESS (3 HEX): " FCB $04 MSG5 FCC " - " FCB $04 MSG2 FCB $00,$00,$0A,$0D,$00,$00,$00,$04 WOTMSG FCC "What ?" FCB $0D,$0A,$04 PAGMSG FCB $0D,$0A FCC "Hit any key to continue" FCB $04 * END START