OpenCores
URL https://opencores.org/ocsvn/System09/System09/trunk

Subversion Repositories System09

[/] [System09/] [trunk/] [src/] [dump/] [dump_cf8.asm] - Blame information for rev 209

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 59 davidgb
*
2
* Sector Dump Utility
3
* For Compact Flash Driver
4
* for the 6809
5
* Configured in 8 bit mode
6
*
7
* John Kent
8
* 21 May 2007
9
*
10
* Register Equates
11
*
12
CF_BASE    EQU $E040
13
CF_DATA    EQU CF_BASE+0
14
CF_ERROR   EQU CF_BASE+1 ; read error
15
CF_FEATURE EQU CF_BASE+1 ; write feature
16
CF_SECCNT  EQU CF_BASE+2
17
CF_SECNUM  EQU CF_BASE+3
18
CF_CYLLO   EQU CF_BASE+4
19
CF_CYLHI   EQU CF_BASE+5
20
CF_HEAD    EQU CF_BASE+6
21
CF_STATUS  EQU CF_BASE+7 ; read status
22
CF_COMAND  EQU CF_BASE+7 ; write command
23
*
24
* Command Equates
25
*
26
CMDREAD    EQU $20 ; Read Single sector
27
CMDWRITE   EQU $30 ; Write Single sector
28
CMDFEATURE EQU $EF
29
FEAT8BIT   EQU $01 ; enable 8 bit transfers
30
HEADLBA    EQU $E0
31
*
32
* Status bit equates
33
*
34
BUSY       EQU $80
35
DRDY       EQU $40
36
DRQ        EQU $08
37
ERR        EQU $01
38
*
39
* Start of Program
40
*
41
         ORG $0100
42
START    LBRA START1
43
*
44
* DATA STORAGE
45
*
46
SECNUM   FCB $00,$00,$00
47
CPORT    FDB $E000
48
ECHO     FCB $FF
49
*
50
* SECTOR BUFFER
51
*
52
SECBUF   RMB 512
53
*
54
* PROGRAM STACK
55
*
56
         RMB 64
57
STACK    EQU *
58
*
59
* Initialization
60
*
61
START1 LDS #STACK
62
*
63
* Clear sector buffer
64
*
65
       LDX #SECBUF
66
       LDY #512
67
ZEROLP CLR ,X+
68
       LEAY -1,Y
69
       BNE ZEROLP
70
*
71
* INITIALIZE CF CARD FOR 8 BIT LBA MODE
72
*
73
       JSR WAITRDY
74
       LDA #HEADLBA
75
       STA CF_HEAD
76
       JSR WAITRDY
77
       LDA #FEAT8BIT
78
       STA CF_FEATURE
79
       LDA #CMDFEATURE
80
       STA CF_COMAND
81
       JSR WAITRDY
82
*
83
* DISPLAY TITTLE BANNER
84
*
85
       LDX #TTLMSG
86
       JSR PDATA
87
*
88
* COMMAND LOOP
89
* R - READ
90
* W - WRITE
91
* N - NEXT
92
* P - PREV
93
* M - MODIFY
94
* Q - QUIT
95
*
96
CMDLP  LDX #CMDMSG
97
       JSR PDATA
98
       JSR ECHON
99
       CMPA #'R'
100
       BEQ READ
101
       CMPA #'N'
102
       BEQ NEXT
103
       CMPA #'P'
104
       BEQ PREV
105
       CMPA #'W'
106
       LBEQ WRITE
107
       CMPA #'M'
108
       BEQ MODIFY
109
       CMPA #'Q'
110
       BEQ QUIT
111
       LDX #WOTMSG
112
       JSR PSTRNG
113
       BRA CMDLP
114
*
115
* QUIT
116
*
117
QUIT   JMP [$F800]
118
*
119
* MODIFY SECTOR
120
*
121
MODIFY JSR MEMCHG
122
       BRA CMDLP
123
*
124
* NEXT SECTOR (READ)
125
* INCREMENT SECTOR NUMBER
126
* WRAPS AROUND TO ZERO ON $FFFFFF
127
*
128
NEXT   LDX SECNUM+1
129
       LEAX 1,X
130
       STX SECNUM+1
131
       BNE READS
132
       INC SECNUM
133
       BRA READS
134
*
135
* PREVIOUS SECTOR (READ)
136
* DECREMENT SECTOR NUMBER
137
* DON'T DECREMENT PAST $000000
138
*
139
PREV   LDX SECNUM+1
140
       BNE PREV1
141
       TST SECNUM
142
       BEQ READS
143
       DEC SECNUM
144
PREV1  LEAX -1,X
145
       STX SECNUM+1
146
       BRA READS
147
*
148
* READ SECTORS FROM CF
149
*
150
READ   LDX #SECPMT
151
       JSR PSTRNG
152
       JSR IN6HEX
153
       BVS RDEXIT
154
       STB SECNUM
155
       STX SECNUM+1
156
*
157
READS  LDA #$01
158
       STA CF_SECCNT
159
       LDA SECNUM+2
160
       STA CF_SECNUM
161
       LDA SECNUM+1
162
       STA CF_CYLLO
163
       LDA SECNUM+0
164
       STA CF_CYLHI
165
*
166
       LDA #CMDREAD ; IDE READ MULTIPLE
167
       STA CF_COMAND
168
       JSR WAITRDY
169
*
170
       LDX #SECBUF
171
       LDY #512
172
*
173
* READ LOOP
174
*
175
RDLOOP JSR WAITDRQ
176
       LDA CF_DATA
177
       STA ,X+
178
       LEAY -1,Y
179
       BNE RDLOOP
180
*
181
       JSR WAITRDY
182
       JSR MEMDUMP
183
RDEXIT JMP CMDLP
184
*
185
* WRITE SECTOR TO CF
186
*
187
WRITE  LDX #SECPMT
188
       JSR PSTRNG
189
       JSR IN6HEX
190
       BVS WREXIT
191
       STB SECNUM
192
       STX SECNUM+1
193
*
194
       LDA #$01
195
       STA CF_SECCNT
196
       LDA SECNUM+2
197
       STA CF_SECNUM
198
       LDA SECNUM+1
199
       STA CF_CYLLO
200
       LDA SECNUM+0
201
       STA CF_CYLHI
202
*
203
       LDA #CMDWRITE; IDE WRITE MULTIPLE
204
       STA CF_COMAND
205
       JSR WAITRDY
206
*
207
       LDX #SECBUF
208
       LDY #512
209
*
210
* WRITE LOOP
211
*
212
WRLOOP JSR WAITDRQ
213
       LDA ,X+
214
       STA CF_DATA
215
       LEAY -1,Y
216
       BNE WRLOOP
217
*
218
       JSR WAITRDY
219
WREXIT JMP CMDLP
220
*
221
* WAIT UNTIL READY
222
*
223
WAITRDY LDA CF_STATUS
224
        BITA #BUSY
225
        BNE WAITRDY
226
        LDA CF_STATUS
227
        BITA #DRDY
228
        BEQ WAITRDY
229
        RTS
230
*
231
* WAIT FOR DATA REQUEST
232
*
233
WAITDRQ LDA CF_STATUS
234
        BITA #DRQ
235
        BEQ WAITDRQ
236
        RTS
237
*
238
* DUMP SECTOR IN MEMORY
239
*
240
MEMDUMP LDX  #SECMSG
241
        JSR  PSTRNG
242
        LDA  SECNUM
243
        JSR  OUT2H
244
        LDX  SECNUM+1
245
        JSR  OUT4H
246
        JSR  PCRLF
247
        LDY  #$0000
248
        LEAX #$1FF,Y
249
*
250
* ADJUST LOWER AND UPPER ADDRESS LIMITS
251
* TO EVEN 16 BYTE BOUNDRIES.
252
*
253
* IF LOWER ADDR = $4532
254
* LOWER BOUNDS WILL BE ADJUSTED TO = $4530.
255
*
256
* IF UPPER ADDR = $4567
257
* UPPER BOUNDS WILL BE ADJUSTED TO = $4570.
258
*
259
* ENTER WITH LOWER ADDRESS IN X-REG.
260
*           -UPPER ADDRESS ON TOP OF STACK.
261
*
262
AJDUMP  TFR  X,D     GET UPPER ADDR IN D-REG
263
        ADDD #$10    ADD 16 TO UPPER ADDRESS
264
        ANDB #$F0    MASK TO EVEN 16 BYTE BOUNDRY
265
        PSHS A,B     SAVE ON STACK AS UPPER DUMP LIMIT
266
        TFR  Y,D     $F9A5 GET LOWER ADDRESS IN D-REG
267
        ANDB #$F0    MASK TO EVEN 16 BYTE BOUNDRY
268
        TFR  D,X     PUT IN X-REG AS LOWER DUMP LIMIT
269
NXTLIN  CMPX ,S      COMPARE LOWER TO UPPER LIMIT
270
        BEQ  SKPDMP  IF EQUAL SKIP HEX-ASCII DUMP
271
        LBSR INCHEK  CHECK FOR INPUT FROM KEYBOARD
272
        BEQ  EDUMP
273
SKPDMP  LEAS 2,S     READJUST STACK IF NOT DUMPING
274
        RTS          ;
275
*
276
* PRINT 16 HEX BYTES FOLLOWED BY 16 ASCII CHARACTERS
277
* FOR EACH LINE THROUGHOUT ADDRESS LIMITS.
278
*
279
EDUMP   PSHS X       PUSH LOWER ADDR LIMIT ON STACK
280
        LDX  #MSG5   POINT TO MSG " - "
281
        LBSR PSTRNG  PRINT MSG
282
        LDX  ,S      LOAD LOWER ADDR FROM TOP OF STACK
283
        LBSR OUT4H   PRINT THE ADDRESS
284
        LBSR OUT2S   2 SPACES
285
        LDB  #$10    LOAD COUNT OF 16 BYTES TO DUMP
286
ELOOP   LDA  SECBUF,X     GET FROM MEMORY HEX BYTE TO PRINT
287
        LEAX 1,X
288
        LBSR OUT2H   OUTPUT HEX BYTE AS ASCII
289
        LBSR OUT1S   OUTPUT SPACE
290
        DECB         $F9D1 DECREMENT BYTE COUNT
291
        BNE  ELOOP   CONTINUE TIL 16 HEX BYTES PRINTED
292
*
293
* PRINT 16 ASCII CHARACTERS
294
* IF NOT PRINTABLE OR NOT VALID
295
* ASCII PRINT A PERIOD (.)
296
        LBSR OUT2S   2 SPACES
297
        LDX  ,S++    GET LOW LIMIT FRM STACK - ADJ STACK
298
        LDB  #$10    SET ASCII CHAR TO PRINT = 16
299
EDPASC  LDA  SECBUF,X     GET CHARACTER FROM MEMORY
300
        LEAX 1,X
301
        CMPA #$20    IF LESS THAN $20, NON-PRINTABLE?
302
        BCS  PERIOD  IF SO, PRINT PERIOD INSTEAD
303
        CMPA #$7E    IS IT VALID ASCII?
304
        BLS  PRASC   IF SO PRINT IT
305
PERIOD  LDA  #'.     LOAD A PERIOD (.)
306
PRASC   LBSR OUTCH   PRINT ASCII CHARACTER
307
        DECB         DECREMENT COUNT
308
        BNE  EDPASC
309
        BRA  NXTLIN
310
*
311
*
312
***** "M" MEMORY EXAMINE AND CHANGE *****
313
*
314
* RESTRICT ADDRESSING RANGE TO 512 BYTES ($000 - $1FF)
315
*
316
MEMCHG  LDX  #MEMMSG
317
        JSR  PSTRNG
318
        LBSR IN3HEX  INPUT ADDRESS
319
        BVS  CHRTN   IF NOT HEX, RETURN
320
        CMPX #$0200
321
        BHS  CHRTN
322
        TFR  X,Y     SAVE ADDR IN "Y"
323
MEMC2   LDX  #MSG5   POINT TO MSG " - "
324
        LBSR PSTRNG  PRINT MSG
325
        TFR  Y,X     FETCH ADDRESS
326
        LBSR OUT4H   PRINT ADDR IN HEX
327
        LBSR OUT1S   OUTPUT SPACE
328
        LDA  SECBUF,Y GET CONTENTS OF CURRENT ADDR.
329
        LBSR OUT2H   OUTPUT CONTENTS IN ASCII
330
        LBSR OUT1S   OUTPUT SPACE
331
        LBSR BYTE    LOOP WAITING FOR OPERATOR INPUT
332
        BVC  CHANGE  IF VALID HEX GO CHANGE MEM. LOC.
333
        CMPA #8      IS IT A BACKSPACE (CNTRL H)?
334
        BEQ  MEMC2   PROMPT OPERATOR AGAIN
335
        CMPA #$18    IS IT A CANCEL (CNTRL X)?
336
        BEQ  MEMC2   PROMPT OPERATOR AGAIN
337
        CMPA #'^     IS IT AN UP ARROW?
338
        BEQ  BACK    DISPLAY PREVIOUS BYTE
339
        CMPA #$D     IS IT A CR?
340
        BNE  FORWRD  DISPLAY NEXT BYTE
341
CHRTN   RTS          EXIT ROUTINE
342
*
343
*
344
CHANGE  STA  SECBUF,Y      CHANGE BYTE IN MEMORY
345
        CMPA SECBUF,Y      DID MEMORY BYTE CHANGE?
346
        BEQ  FORWRD  $F972
347
        LBSR OUT1S   OUTPUT SPACE
348
        LDA  #'?     LOAD QUESTION MARK
349
        LBSR OUTCH   PRINT IT
350
FORWRD  CMPY #$01FF
351
        BEQ  MEMC2
352
        LEAY 1,Y     POINT TO NEXT HIGHER MEM LOCATION
353
        BRA  MEMC2   PRINT LOCATION & CONTENTS
354
BACK    CMPY #$0000
355
        BEQ  MEMC2
356
        LEAY -1,Y    POINT TO LAST MEM LOCATION
357
        BRA  MEMC2   PRINT LOCATION & CONTENTS
358
*
359
* THE FOLLOWING ROUTINE LOOPS WAITING FOR THE
360
* OPERATOR TO INPUT ONE VALID HEX ADDRESS. THE
361
* ADDRESS IS RETURNED IN THE "X" REGISTER.
362
*
363
* IN6HEX - MS BYTE IN ACCB
364
*          LS WORD IN X REG
365
*
366
IN6HEX LEAS -3,S
367
       BSR  BYTE
368
       BVS  NOTHEX
369
       STA  0,S
370
       BSR  BYTE
371
       BVS  NOTHEX
372
       STA  1,S
373
       BSR  BYTE
374
       BVS  NOTHEX
375
       STA  2,S
376
       CLRA
377
       PULS B,X,PC
378
*
379
* INPUT 3 HEX DIGITS
380
* RESULT RETURNED IN X
381
*
382
IN3HEX BSR INHEX INPUT HEX (1 HEX CHAR)
383
       BVS NOTHEX EXIT IF NOT VALID HEX
384
       TFR  D,X
385
       BSR BYTE INPUT BYTE (2 HEX CHAR)
386
       BVS NOTHEX
387
       PSHS X
388
       STA  1,S
389
       PULS X,PC
390
*
391
***** INPUT BYTE (2 HEX CHAR.) *****
392
*
393
BYTE   BSR INHEX GET HEX LEFT
394
       BVS NOTHEX EXIT IF NOT VALID HEX
395
       ASLA   ;
396
       ASLA   ;
397
       ASLA   ; SHIFT INTO LEFT NIBBLE
398
       ASLA   ;
399
       TFR  A,B PUT HEXL IN "B"
400
       BSR INHEX GET HEX RIGHT
401
       BVS NOTHEX EXIT IF NOT VALID HEX
402
       PSHS B PUSH HEXL ON STACK
403
       ADDA ,S+ ADD HEXL TO HEXR AND ADJ. STK
404
       RTS  RETURN WITH HEX L&R IN "A"
405
*
406
*
407
INHEX  BSR ECHON INPUT ASCII CHAR.
408
       CMPA #'0 IS IT > OR = "0" ?
409
       BCS NOTHEX IF LESS IT AIN'T HEX
410
       CMPA #'9 IS IT < OR = "9" ?
411
       BHI INHEXA IF > MAYBE IT'S ALPHA
412
       SUBA #$30 ASCII ADJ. NUMERIC
413
       RTS  ;
414
*
415
*
416
INHEXA CMPA #'A IS IT > OR = "A"
417
       BCS NOTHEX IF LESS IT AIN'T HEX
418
       CMPA #'F IS IT < OR = "F" ?
419
       BHI INHEXL IF > IT AIN'T HEX
420
       SUBA #$37 ASCII ADJ. ALPHA
421
       RTS  ;
422
*
423
INHEXL CMPA #'a IS IT > OR = "a"
424
       BCS NOTHEX IF LESS IT AIN'T HEX
425
       CMPA #'f IS IT < "f"
426
       BHI NOTHEX IF > IT AIN'T HEX
427
       SUBA #$57 ADJUST TO LOWER CASE
428
       RTS  ;
429
*
430
*
431
NOTHEX ORCC #2 SET (V) FLAG IN C-CODES REGISTER
432
       RTS  ;
433
*
434
*
435
OUT4H PSHS X PUSH X-REG. ON THE STACK
436
       PULS A POP MS BYTE OF X-REG INTO A-ACC.
437
       BSR OUTHL OUTPUT HEX LEFT
438
       PULS A POP LS BYTE OF X-REG INTO A-ACC.
439
OUTHL EQU *
440
OUT2H PSHS A SAVE IT BACK ON STACK
441
       LSRA CONVERT UPPER HEX NIBBLE TO ASCII
442
       LSRA  ;
443
       LSRA  ;
444
       LSRA  ;
445
       BSR XASCII PRINT HEX NIBBLE AS ASCII
446
OUTHR PULS A CONVERT LOWER HEX NIBBLE TO ASCII
447
       ANDA #$0F STRIP LEFT NIBBLE
448
XASCII ADDA #$30 ASCII ADJ
449
       CMPA #$39 IS IT < OR = "9" ?
450
       BLE  OUTC IF LESS, OUTPUT IT
451
       ADDA #7 IF > MAKE ASCII LETTER
452
OUTC BRA  OUTCH OUTPUT CHAR
453
*
454
* BINARY / ASCII --- THIS ROUTINE
455
* OUTPUTS A BYTE IN ENHANCED
456
* BINARY FORMAT. THE ENHANCEMENT
457
* IS DONE BY SUBSTITUTING ASCII
458
* LETTERS FOR THE ONES IN THE BYTE.
459
* THE ASCII ENHANCEMENT LETTERS
460
* ARE OBTAINED FROM THE STRING
461
* POINTED TO BY THE INDEX REG. "X".
462
*
463
BIASCI PSHS A SAVE "A" ON STACK
464
       LDB  #8 PRESET LOOP# TO BITS PER BYTE
465
OUTBA LDA ,X+ GET LETTER FROM STRING
466
       ASL  ,S TEST BYTE FOR "1" IN B7
467
       BCS PRTBA IF ONE PRINT LETTER
468
       LDA #'- IF ZERO PRINT "-"
469
PRTBA BSR OUTCH PRINT IT
470
       BSR OUT1S PRINT SPACE
471
       DECB SUB 1 FROM #BITS YET TO PRINT
472
       BNE OUTBA
473
       PULS A,PC
474
*
475
* PRINT STRING PRECEEDED BY A CR & LF.
476
*
477
PSTRNG BSR PCRLF PRINT CR/LF
478
       BRA  PDATA  PRINT STRING POINTED TO BY IX
479
*
480
* PCRLF
481
*
482
PCRLF  PSHS X SAVE IX
483
       LDX  #MSG2+1  POINT TO MSG CR/LF + 3 NULS
484
       BSR PDATA  PRINT MSG
485
       PULS X,PC RESTORE IX
486
PRINT  BSR OUTCH
487
*
488
* PDATA
489
*
490
PDATA  LDA  ,X+ GET 1st CHAR. TO PRINT
491
       CMPA #4 IS IT EOT?
492
       BNE  PRINT IF NOT EOT PRINT IT
493
       RTS  ;
494
*
495
*
496
ECHON  TST  ECHO IS ECHO REQUIRED ?
497
       BEQ  INCH ECHO NOT REQ. IF CLEAR
498
*
499
* INCHE
500
*
501
* ---GETS CHARACTER FROM TERMINAL AND
502
* ECHOS SAME. THE CHARACTER IS RETURNED
503
* IN THE "A" ACCUMULATOR WITH THE PARITY
504
* BIT MASKED OFF. ALL OTHER REGISTERS
505
* ARE PRESERVED.
506
*
507
INCHE  BSR INCH GET CHAR FROM TERMINAL
508
       ANDA #$7F      STRIP PARITY FROM CHAR.
509
       BRA  OUTCH     ECHO CHAR TO TERMINAL
510
*
511
* INCH
512
*
513
* GET CHARACTER FROM TERMINAL. RETURN
514
* CHARACTER IN "A" ACCUMULATOR AND PRESERVE
515
* ALL OTHER REGISTERS. THE INPUT CHARACTER
516
* IS 8 BITS AND IS NOT ECHOED.
517
*
518
*
519
INCH    PSHS X SAVE IX
520
GETSTA  LDX  CPORT POINT TO TERMINAL PORT
521
        LDA  ,X  FETCH PORT STATUS
522
        BITA #1 TEST READY BIT, RDRF ?
523
        BEQ  GETSTA IF NOT RDY, THEN TRY AGAIN
524
GETST1  LDA  1,X FETCH CHAR
525
        PULS X,PC RESTORE IX
526
*
527
* INCHEK
528
*
529
* CHECK FOR A CHARACTER AVAILABLE FROM
530
* THE TERMINAL. THE SERIAL PORT IS CHECKED
531
* FOR READ READY. ALL REGISTERS ARE
532
* PRESERVED, AND THE "Z" BIT WILL BE
533
* CLEAR IF A CHARACTER CAN BE READ.
534
*
535
*
536
INCHEK  PSHS A SAVE A ACCUM.
537
        LDA  [CPORT] FETCH PORT STATUS
538
        BITA #1 TEST READY BIT, RDRF ?
539
INCHEK1 PULS A,PC RESTORE A ACCUM.
540
*
541
OUT2S   BSR OUT1S OUTPUT 2 SPACES
542
OUT1S   LDA  #$20  OUTPUT 1 SPACE
543
*
544
*
545
* OUTCH
546
*
547
* OUTPUT CHARACTER TO TERMINAL.
548
* THE CHAR. TO BE OUTPUT IS
549
* PASSED IN THE A REGISTER.
550
* ALL REGISTERS ARE PRESERVED.
551
*
552
OUTCH   PSHS A,X    SAVE A ACCUM AND IX
553
        LDX  CPORT  GET ADDR. OF TERMINAL
554
FETSTA  LDA  ,X     FETCH PORT STATUS
555
        BITA #2     TEST TDRE, OK TO XMIT ?
556
        BEQ  FETSTA IF NOT LOOP UNTIL RDY
557
        PULS A      GET CHAR. FOR XMIT
558
        STA  1,X    XMIT CHAR.
559
        PULS X,PC   RESTORE IX
560
*
561
*
562
ACINIZ  LDX  CPORT  POINT TO CONTROL PORT ADDRESS
563
        LDA  #3     RESET ACIA PORT CODE
564
        STA  ,X     STORE IN CONTROL REGISTER
565
        LDA  #$11   SET 8 DATA, 2 STOP AN 0 PARITY
566
        STA  ,X     STORE IN CONTROL REGISTER
567
        TST  1,X    ANYTHING IN DATA REGISTER?
568
        LDA  #$FF   TURN ON ECHO FLAG
569
        STA  ECHO
570
        RTS
571
*
572
* MESSAGE STRINGS
573
*
574
TTLMSG FCB $0A,$0D
575
       FCC "COMPACT FLASH SECTOR READ/WRITE UTILITY"
576
       FCB $04
577
CMDMSG FCB $0A,$0D
578
       FCC "(R) READ SECTOR"
579
       FCB $0A,$0D
580
       FCC "(W) WRITE SECTOR"
581
       FCB $0A,$0D
582
       FCC "(N) NEXT SECTOR"
583
       FCB $0A,$0D
584
       FCC "(P) PREV SECTOR"
585
       FCB $0A,$0D
586
       FCC "(M) MODIFY SECTOR"
587
       FCB $0A,$0D
588
       FCC "(Q) QUIT"
589
       FCB $0A,$0D
590
       FCC ": "
591
       FCB $04
592
SECPMT FCC "SECTOR NUMBER (6 HEX) : "
593
       FCB $04
594
SECMSG FCC "SECTOR NUMBER - $"
595
       FCB $04
596
MEMMSG FCB $0D,$0A
597
       FCC "MEMORY ADDRESS (3 HEX): "
598
       FCB $04
599
MSG5   FCC " - "
600
       FCB $04
601
MSG2   FCB $00,$00,$0A,$0D,$00,$00,$00,$04
602
WOTMSG FCC "What ?"
603
       FCB $0D,$0A,$04
604
*
605
       END START

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.