H:\Develop\CoPro\6812\Serial12.lst - generated by MGTEK Assembler ASM12 V1.26 Build 144 for WIN32 (x86) - Sun Oct 08 06:43:19 2023 1: ; Boilerplate definitions to build with MGTEK 68x12 MiniIDE 2: INCLUDE 'derivative.inc' 1: =000000CC SCI0SR1: equ $000000CC ;*** SCI0SR1 - SCI 0 Status Register 1 *** 2: =000000CB SCI0CR2: equ $000000CB ;*** SCI0CR2 - SCI 0 Control Register 2 *** 3: =000000CF SCI0DRL: equ $000000CF ;*** SCI0DRL - SCI 0 Data Register Low *** 4: ; bit position masks 5: =00000001 mSCI0SR1_PF: equ %00000001 6: =00000002 mSCI0SR1_FE: equ %00000010 7: =00000004 mSCI0SR1_NF: equ %00000100 8: =00000008 mSCI0SR1_OR: equ %00001000 9: =00000010 mSCI0SR1_IDLE: equ %00010000 10: =00000020 mSCI0SR1_RDRF: equ %00100000 11: =00000040 mSCI0SR1_TC: equ %01000000 12: =00000080 mSCI0SR1_TDRE: equ %10000000 13: ; bit position masks 14: =00000001 mSCI0CR2_SBK: equ %00000001 15: =00000002 mSCI0CR2_RWU: equ %00000010 16: =00000004 mSCI0CR2_RE: equ %00000100 17: =00000008 mSCI0CR2_TE: equ %00001000 18: =00000010 mSCI0CR2_ILIE: equ %00010000 19: =00000020 mSCI0CR2_RIE: equ %00100000 20: =00000040 mSCI0CR2_TCIE: equ %01000000 21: =00000080 mSCI0CR2_SCTIE: equ %10000000 3: 4: ; 9S12 Serial Tube Client Code 5: ; ============================ 6: ; Copyright (C)2010 J.G.Harston - mdfs.net/tube 7: ; Copyright (C)2011 J.S.Flynn 8: ; 9: ; v0.10 01-Jan-2012 JSF: Converted from 6809 client 10: ; v0.11 01-Jul-2012 JGH: Added full OSWORD handler 11: ; v0.12 15-Nov-2013 JGH: Added software vectors, hardware vectors in RAM 12: ; 21-Nov-2013 JGH: JMP [addr] fixed, replaced with JMP [addr,PC] 13: ; TRAP $Fn -> MOS API call 14: ; v0.24 08-Dec-2014 JGH: Brought up to same version as hardware Tube client. 15: ; Added PRHEX and HR2HEX, execute enters at PROGRAM 16: ; MEMTOP moved below code if code is in high memory. 17: ; Added PR_STRING. Implemented KBDTST for 6812 BIOS calls. 18: ; STARTUP and OSCLI use internal stack. Execute checks 19: ; code header. WARM resets MEMBOT & MEMTOP. 20: ; EXECUTE enters code with A=1 or A=0, PROG saved and 21: ; restored, soft Break will re-enter at PROG. OSCLI saves 22: ; all registers. Raw code is not made the current program. 23: ; Supervisor prompt makes itself current program. Full 24: ; header (C) check. 25: ; v0.25 20-Dec-2014 JGH: Added local *GO and *HELP commands, LPTR set to command 26: ; line, OSBYTE 142 sets null LPTR. OSBYTE $82-$84 return 27: ; address/256 in Y. Squashed some JSRs into BSRs. 28: ; v1.00 01-Jan-2015 JGH: Rolled over to version 1.00. 29: ; v1.01 22-Jun-2017 JGH: EXECUTE passes caller's stack to callee. EXECUTE does not 30: ; set code as current program, that is now responsibility of 31: ; INITERR/OSINIT. OSCLI stack saving is now recursable. 32: ; 23-Jun-2017 JGH: Precheck for '*RUN' to point LPTR to correct parameters. 33: ; More stack space for transient OSCLI commands. 34: ; v1.02 05-Aug-2017 JGH: Optimised PRHEX routines. Only Transfer Type &Cx updates 35: ; ADDRESS, uses 16-bit address. Slightly optimised BYTE_HI. 36: ; v1.03 06-Aug-2017 JGH: Rolled over to version 1.03 to match Tube client. 37: ; 08-Aug-2017 JGH: Command table re-ordered to optimise dispatch. Optimised 38: ; some ADD #$80 into ASLA. Bugfix for */(space)filename. 39: ; 12-Aug-2017 JGH: *HELP always displays help message. Optimised *HELP. 40: ; 15-Aug-2017 JGH: Forced JMP opcode at RAWVDU entry. 41: ; v1.04 22-Aug-2017 JGH: Rolled over to version 1.04. 42: ; 24-Aug-2017 JGH: Optimised SEND_BLOCK and WAIT_BLOCK. 43: ; v1.05 25-Aug-2017 JGH: OSFILE/OSGBPB/OSARGS use big-endian control blocks 44: ; 22-Sep-2017 JGH: PRTEXT preserves X as with Z80 Client. 45: ; 12-Jul-2019 JGH: KBDTST/KBDIN routines use pending character input 46: =00000000 KBDPEND: EQU 0 ; KBDTST/KBDIN pending input 47: ; v1.06 25-Jun-2017 JGH: Rolled over to version 1.06. 48: =00000105 VERSION: EQU $0105 49: =00000002 BUILD: EQU 2 50: ; 51: ; 52: =00000001 BIGENDIAN: EQU 1 ; Big-endian control block contents for OSFILE/OSGBPB/OSARGS 53: ; 54: ; 55: ; Based on 6809 Serial Tube Client 56: ; This code may be freely reused. 57: 58: ; NOTE! Only tested in CodeWarrior simulator 59: ; Interupt Vector Base Register is used to remap hardware vectors 60: 61: ; +-------------+--------------------------------------------------+ 62: ; | 0000-0FFF | Registers, I/O, EEPROM, system RAM | 63: ; | 0800-09FF | Workspace if at bottom of very low memory | 64: ; | 0E00-0FFF | Workspace if at top of very low memory | 65: ; | 1000- | Onboard RAM | 66: ; | | On 9S12E series RAM extends upwards from 1000, | 67: ; | | extra RAM moving RAMTOP upwards. | 68: ; | | On 9S12D series RAM extends downwards from 7FFF, | 69: ; | | extra RAM moving RAMBOT downwards. | 70: ; | BUT! 1000-1FFF can be paged out! swapping out workspace! | 71: ; | | | 72: ; | 1000-103F | Internal variables if in low user memory | 73: ; | 1040-10FF | Text buffers if in low user memory | 74: ; | 1100-11FF | Hardware vectors if mapped to low user memory | 75: ; | 1100- | Start of user memory if vectors in ROM | 76: ; | 1200- | Start of user memory if vectors in RAM | 77: ; | -3FFF | If 12K RAM present | 78: ; | -7FFF | If 12K+16K RAM present | 79: ; | | Client should really count memory | 80: ; | | | 81: ; | -xxFF | ^^^ User stack ^^^ | 82: ; | xE00-xEFF | Hardware vectors if mapped to high memory | 83: ; | xF00-xFBF | Text buffers if in high memory | 84: ; | xFC0-xFFF | Internal variables if in high memory | 85: ; +-------------+--------------------------------------------------+ 86: ; | F800-FFFF | Client ROM | 87: ; | F800-F815 | Monitor ROM entry vectors | 88: ; | FE00-FEFF | Hardware vectors if mapped to ROM | 89: ; | FF80- | Internal variables if running from RAM | 90: ; | -FFF9 | BBC MOS entry block | 91: ; +-------------+--------------------------------------------------+ 92: ; Client error implemented with SWI (equivalent of 6502 BRK, Z80 RST &38, etc.) 93: ; TRAP nn>$3F used for system calls (equivalent of 6809's SWI2, SWI3, etc.) 94: ; Note to self: CMP sets Carry Z80-style, CS=lower, CC=same+higher 95: 96: ; Tube client system configuration tweekables 97: ; =========================================== 98: ; Workspace in low memory 99: ; ----------------------- 100: =00001000 WORKSP: EQU $1000 ; Workspace at bottom of RAM 101: ;WORKSP: EQU $0800 ; Workspace at bottom of low RAM 102: =00001100 VECBASE: EQU WORKSP+$100 ; Hardware vectors redirected to RAM 103: =00001200 RAMSTART: EQU WORKSP+$200 ; Start of user RAM 104: =00004000 RAMEND: EQU $4000 ; End of user RAM+1 with 12K RAM 105: ;RAMEND: EQU $8000 ; End of user RAM+1 with 12K+16K RAM 106: =0000F800 ROMSTART: EQU $F800 ; Start of code 107: =00000000 ESCOFF: EQU $00 ; Workspace goes upwards in memory 108: =00004000 STACK: EQU RAMEND ; System stack at top of user RAM 109: =00000001 LOCAL_GO: EQU 1 ; Include local *GO command 110: =00000001 LOCAL_HELP: EQU 1 ; Include local *HELP command 111: =00000001 LOCAL_RUN: EQU 1 ; Include local *RUN command 112: ; Note: if VECBASE is in ROM there is not enough space for both *GO and *HELP 113: 114: ; ; Workspace in high memory 115: ; ; ------------------------ 116: ; RAMSTART: EQU $1000 ; Start of user RAM 117: ; ;RAMSTART: EQU $0800 ; Start of user RAM 118: ; WORKSP: EQU $3FC0 ; Workspace at top of RAM 119: ; VECBASE: EQU WORKSP-$1C0 ; Hardware vectors redirected to RAM 120: ; RAMEND: EQU VECBASE ; End of user RAM+1 121: ; ROMSTART: EQU $F800 ; Start of code 122: ; ESCOFF: EQU $FF ; Workspace goes downwards in memory 123: ; STACK: EQU RAMEND ; System stack at top of user RAM 124: ; LOCAL_GO EQU 1 ; Include local *GO command 125: ; LOCAL_HELP EQU 1 ; Include local *HELP command 126: ; LOCAL_RUN: EQU 1 ; Include local *RUN command 127: ; ; Note: if VECBASE is in ROM there is not enough space for both *GO and *HELP 128: 129: ; ToDo: Workspace use can be crushed down to 16 bytes to fit on the S912A/B/C which 130: ; only have RAM at $0800-$0BFF or -$0FFF. This needs conditional assembly adding to 131: ; remove vectors and text buffers, program space then $0810-$0BFF or $0800-$0BEF. 132: 133: 134: ; Serial I/O Addresses 135: ; ==================== 136: =000000CC TxSTATUS EQU SCI0SR1 137: =000000CB TxCTRL EQU SCI0CR2 138: =000000CF TxDATA EQU SCI0DRL 139: =000000CC RxSTATUS EQU SCI0SR1 140: =000000CB RxCTRL EQU SCI0CR2 141: =000000CF RxDATA EQU SCI0DRL 142: =00000080 TxRDY EQU mSCI0SR1_TDRE 143: =00000020 RxRDY EQU mSCI0SR1_RDRF 144: =00000004 RxINIT EQU mSCI0CR2_RE 145: =00000008 TxINIT EQU mSCI0CR2_TE 146: 147: 148: ; 68HC12 I/O and Registers 149: ; ======================== 150: =00000121 IO_IVBR: EQU $0121 ; Interupt vector base high byte of address 151: 152: 153: ; Serial Tube system values 154: ; ========================= 155: =0000009B esc EQU $9B 156: 157: 158: ; Client MOS Workspace 159: ; ==================== 160: IF ESCOFF = $00 161: ; Workspace runs from low memory upwards 162: ; -------------------------------------- 163: =00001000 ESCFLG: EQU WORKSP+$00 ; $1000 - Escape flag 164: =00001001 DMA_TYPE: EQU WORKSP+$01 ; $1001 - Tube personality 165: =00001002 FAULT: EQU WORKSP+$02 ; $1002 - Last error message 166: =00001004 WORK04: EQU WORKSP+$04 ; $1004 - Not used 167: =00001006 LPTR: EQU WORKSP+$06 ; $1006 - Command line tail 168: =00001008 MEMBOT: EQU WORKSP+$08 ; $1008 - Bottom of user memory 169: =0000100A MEMTOP: EQU WORKSP+$0A ; $100A - Top of user memory 170: =0000100C ADDRESS: EQU WORKSP+$0C ; $100C - Tube execution address 171: =0000100E TRANSFER: EQU WORKSP+$0E ; $100E - Tube transfer address 172: =00001010 PROGRAM: EQU WORKSP+$10 ; $1010 - Program entry address 173: =00001012 CTRL: EQU WORKSP+$12 ; $1012 - Control address 174: =00001012 ADDRHI: EQU WORKSP+$12 ; $1012 - Address high word 175: =0000101E DMADONE: EQU WORKSP+$1E ; $101E - Transfer completion flag 176: =0000101F PENDA: EQU WORKSP+$1F ; $101F - Pending keypress 177: 178: ; ; 6809 Hardware vectors 179: ; ; --------------------- 180: ; SWI3V: EQU WORKSP+$14 ; $1014 181: ; SWI2V: EQU WORKSP+$16 ; $1016 182: ; FIRQV: EQU WORKSP+$18 ; $1018 183: ; IRQV: EQU WORKSP+$1A ; $101A 184: ; SWIV: EQU WORKSP+$1C ; $101C 185: 186: ; Software vectors 187: ; ---------------- 188: =00001020 EVENTV: EQU WORKSP+$20 ; $1020 189: =00001022 BRKV: EQU WORKSP+$22 ; $1022 190: =00001024 xxx2V: EQU WORKSP+$24 ; $1024 191: =00001026 QUITV: EQU WORKSP+$26 ; $1026 192: =00001028 CLIV: EQU WORKSP+$28 ; $1028 193: =0000102A BYTEV: EQU WORKSP+$2A ; $102A 194: =0000102C WORDV: EQU WORKSP+$2C ; $102C 195: =0000102E WRCHV: EQU WORKSP+$2E ; $102E 196: =00001030 RDCHV: EQU WORKSP+$30 ; $1030 197: =00001032 FILEV: EQU WORKSP+$32 ; $1032 198: =00001034 ARGSV: EQU WORKSP+$34 ; $1034 199: =00001036 BGETV: EQU WORKSP+$36 ; $1036 200: =00001038 BPUTV: EQU WORKSP+$38 ; $1038 201: =0000103A GBPBV: EQU WORKSP+$3A ; $103A 202: =0000103C FINDV: EQU WORKSP+$3C ; $103C 203: 204: ; Text buffers 205: ; ------------ 206: =00001040 ERRBLK: EQU WORKSP+$40 ; $1040 - Buffer to store host error block, 207: ; allowed to overflow into CLIBUF 208: =00001060 CLIBUF: EQU WORKSP+$60 ; $1060 - Buffer to enter command line from CLI prompt 209: =00001100 CLIEND: EQU WORKSP+$100 ; $1100 - 160 bytes for command line 210: ; $1100 - Redirected hardware vectors if in RAM 260: ENDIF 261: 262: =00001100 ERRSTK: EQU CLIEND 263: =00001060 CLISTK: EQU CLIBUF 264: =00000003 LOCAL_CMDS: EQU LOCAL_GO + LOCAL_HELP + LOCAL_RUN 265: 266: 267: ; START OF ROM CODE 268: ; ================= 269: =0000F800 ORG ROMSTART 270: 271: ; 68xx BIOS entry block always at F800 272: ; ==================================== 273: =0000F800 ORG $F800 274: F800 F83A COLD: FDB RESET ; $F800 - cold start 275: F802 F837 WARM: FDB WARMS ; $F802 - warm start 276: F804 FFE0 INCH: FDB OSRDCH ; $F804 - char input 277: F806 F91A INCHE: FDB INECHO ; $F806 - char input with echo 278: F808 F92E INCHECK: FDB KBDTST ; $F808 - test for char input 279: F80A FFEE OUTCH: FDB OSWRCH ; $F80A - char output 280: F80C F923 PDATA: FDB PRDAT ; $F80C - output string until EOT 281: F80E FFE7 PCRLF: FDB OSNEWL ; $F80E - output CR/LF 282: F810 F920 PSTRING: FDB PRTST ; $F810 - output CR/LF then string until EOT 283: F812 F919 LRA: FDB LREAL ; $F812 - Load Real Address 284: F814 20 21 BRA WARMS ; $F814 - for FLEX compatibility 285: 286: F816 BANNER: 287: F816 0D FCB 13 288: F817 4D 43 39 53 31 32 FCC "MC9S12XE SERIAL TUBE" F81D 58 45 20 53 45 52 F823 49 41 4C 20 54 55 F829 42 45 289: IF RAMEND = $4000 290: F82B 20 31 32 4B FCC " 12K" 291: ENDIF 292: IF RAMEND = $8000 294: ENDIF 295: F82F 20 FCC " " 296: F830 31 FCB ((VERSION >> 8) & 15) + $30 297: F831 2E FCB "." 298: F832 30 FCB ((VERSION >> 4) & 15) +$30 299: F833 35 FCB (VERSION & 15) + $30 300: IF BUILD 301: F834 62 FCB BUILD+96 304: ENDIF 305: F835 0D 00 FCB 13,0 306: 307: F837 06 F892 WARMS: JMP CLILOOP 308: 309: ; RESET 310: ; ===== 311: ; Ensure code is executable, then continue into STARTUP 312: ; Normally, all HC12 platforms have the client in ROM 313: ; 314: F83A RESET: 315: ; SEI ; Ensure interupts disabled 316: ; IF WORKSP > ROMSTART 317: ; LDS #STACK ; Set up system stack at top of user memory 318: ; LDX #ROMSTART ; Start at start of ROM 319: ;RESETLP1: 320: ; LDAA ,X ; Get a byte from ROM 321: ; STAA 1,X+ ; Store to RAM and increment X 322: ; CPX #IOADDRS 323: ; BNE RESETLP1 ; Loop until hit I/O space 324: ; LDX #ROMHIGH ; Point to ROM after I/O space 325: ;RESETLP2: 326: ; LDAA ,X 327: ; STAA 1,X+ 328: ; CPX #0 329: ; BNE RESETLP2 ; Copy top part of ROM to RAM 330: ; ENDIF 331: 332: 333: ; STARTUP 334: ; ======= 335: ; Reset all vectors, initialise Client state, tell Host we've restarted 336: ; 337: F83A STARTUP: 338: F83A 1410 SEI ; Disable interupts 339: F83C CF 1060 LDS #CLISTK ; Put stack in temporary stack area 340: F83F CE 1100 LDX #VECBASE ; Set up hardware vectors 341: F842 B7 54 TFR X,D ; Copy VECBASE to AB 342: F844 7A 0121 STA >IO_IVBR ; Set high byte of CPU's Interupt Vector Base 343: 344: IF VECBASE < ROMSTART 345: ; If hardware vectors in RAM, initialise them to null ISRs 346: ; -------------------------------------------------------- 347: F847 CD FE28 LDY #RTI ; Point all vectors to null routine 348: F84A C6 80 LDB #$80 ; 128 vectors to set up 349: F84C VECLOOP1: 350: F84C 6D 31 STY 2,X+ ; Store vector, increment X by 2 351: F84E 53 DECB ; Decrement number to do 352: F84F 26 FB BNE VECLOOP1 ; Loop until add done 353: ENDIF 354: 355: ; Initialise software vectors and workspace 356: ; ----------------------------------------- 357: F851 CE FF40 LDX #VECTORS ; Copy default vectors and workspace 358: F854 CD 1020 LDY #EVENTV 359: F857 C6 20 LDB #$20 360: F859 VECLOOP2: 361: F859 A6 30 LDA 1,X+ ; Get byte from default vectors 362: F85B 6A 70 STA 1,Y+ ; Store in vectors 363: F85D 53 DECB ; Decrement number of bytes 364: F85E 26 F9 BNE VECLOOP2 ; Loop until add done 365: 366: ; Count available memory 367: ; ---------------------- 368: ; This doesn't work when inaccessible memory accesses mirrors of accessible memory 369: ; 370: ; LDY DEFBOT 371: ; TFR Y,X 372: ; LDAA #0 ; 0K found 373: ; RAMLOOP: 374: ; LDAB ,X ; Get byte 375: ; EORB #$55 ; Toggle it 376: ; STAB ,X ; Store it back 377: ; CMPB ,X ; Did store work? 378: ; BNE ROMFOUND ; No, no more RAM 379: ; EORB #$55 ; Toggle byte back 380: ; STAB ,X ; And restore it 381: ; ADDA #4 ; Add 4K 382: ; DAA ; Update BCD count 383: ; LEAX $1000,X ; X=X+4K 384: ; CMPX DEFTOP ; 385: ; BCC RAMLOOP ; Check next 4K 386: ; ROMFOUND: 387: ; STY MEMBOT ; Initialise bottom of memory 388: ; STX MEMTOP ; Initialise top of memory 389: ; TFR X,S ; Put stack at top of memory 390: ; ; A=amount of RAM in BCD 391: 392: F860 96 CB LDAA TxCTRL 393: F862 8A 08 ORAA #TxINIT 394: F864 7A 00CB STAA >TxCTRL ; Initialise data port and page ROM out 395: F867 96 CB LDAA RxCTRL 396: F869 8A 04 ORAA #RxINIT 397: F86B 7A 00CB STAA >RxCTRL ; Initialise data port 398: ; Accessing I/O registers will page ROM out if running 399: ; from RAM. Once ROM is paged out we can do subroutine 400: ; calls as we can now read from stack in RAM. 401: 402: F86E 07 6F BSR MEM_INIT ; Set up SWIV, TRAPV, MEMBOT, MEMTOP, BRKV 403: F870 FE 1010 LDX PROGRAM ; Copy current PROGRAM to ADDRESS 404: F873 7E 100C STX ADDRESS ; so will re-enter on Soft Break 405: F876 10EF CLI ; Enable interupts 406: 407: ; Tell the Host that we've restarted 408: ; ---------------------------------- 409: ; Serial Tube data: $18 $00 $FF &FF -- Cy Y X 410: ; followed by string 411: ; 412: ; Note for Host authors: Host MUST NOT respond by echoing back a SoftReset as 413: ; the Client will be trapped in an infinite STARTUP loop. 414: ; 415: F878 86 FF LDA #$FF ; As we are using a serial link, we don't share a 416: F87A CE 0000 LDX #$00 ; hardware Reset, so we have to tell Host we have 417: F87D CD 00FF LDY #$FF ; restarted. 418: F880 16 FB0C JSR FSC ; Send FSC &FF,&00,&FF - Soft Reset command 419: F883 B7 54 TFR X,D 420: F885 37 PSHB ; Save Soft Reset result, will be &00 if no response 421: F886 16 F96C JSR PR_HELP ; Print startup banner via Tube wrch protocol 422: F889 16 FFE7 JSR OSNEWL 423: 424: ; If we share a hardware Reset, we wait for an Ack here 425: ; LDAA #0 426: ; JSR OSWRCH ; Send terminating zero byte 427: ; CLC ; Clear Carry Flag to indicate Reset 428: ; JSR CLI_WAIT ; Wait for result byte 429: 430: F88C 32 PULA ; We sent a Software Reset, so use the Ack from that 431: F88D 10FE CLC ; Clear Carry Flag to indicate Reset 432: F88F 16 FA64 JSR CLI_CHECK ; Check result byte 433: ; ; Fall through to CLICOM if nothing executed 434: 435: ; Supervisor command line prompt 436: ; ============================== 437: ; Allow user to enter *commands 438: ; 439: F892 CLILOOP: 440: F892 CF 1060 LDS #CLISTK ; Initially use internal stack 441: F895 07 53 BSR COM_INIT ; Reset user memory limits and error handler 442: F897 FF 100A LDS MEMTOP ; Reset stack to top of user memory 443: F89A CE FFB9 LDX #CLICOM ; Make CLICOM the current program to re-enter 444: F89D 7E 1010 STX PROGRAM ; on soft reset 445: F8A0 10EF CLI ; Enable interupts 446: F8A2 CLILOOP2: 447: F8A2 CE F8B5 LDX #PROMPT 448: F8A5 16 F96F JSR SEND_TXT ; Display prompt 449: ; LDAA #0 ; A=0 to read text line (SEND_TXT returns A=0) 450: ; LDX #COM_BLK ; Point to control block (SEND_TXT returns X=COM_BLK) 451: F8A8 16 FFF1 JSR OSWORD ; Read a line of text 452: F8AB 25 14 BCS COM_ESC ; Escape pressed 453: F8AD CE 1060 LDX #CLIBUF 454: F8B0 16 FFF7 JSR OS_CLI ; Execute command 455: F8B3 20 ED BRA CLILOOP2 ; Loop back for another line 456: F8B5 PROMPT: 457: F8B5 39 53 31 32 3E 2A FCC "9S12>*" ; Command prompt 458: F8BB 00 FCB 0 459: F8BC COM_BLK: 460: F8BC 1060 FDB CLIBUF ; Input buffer 461: F8BE 9F FCB CLIEND-CLIBUF-1 ; Buffer size 462: F8BF 20 FCB 32 ; Lowest acceptable CHR$32 463: F8C0 FF FCB 255 ; Highest acceptable CHR$255 464: ; 465: F8C1 COM_ESC: 466: F8C1 86 7E LDAA #126 467: F8C3 16 FFF4 JSR OSBYTE ; Acknowledge Escape 468: F8C6 ESCAPE: 469: F8C6 3F SWI 470: F8C7 11 FCB 17 471: F8C8 45 73 63 61 70 65 FCC "Escape" 472: F8CE 00 FCB 0 473: 474: F8CF COM_ERR: 475: F8CF FF 100A LDS MEMTOP ; Reset stack to top of user memory 476: F8D2 16 FFE7 JSR OSNEWL 477: F8D5 A6 30 LDAA 1,X+ ; Step X past error number 478: F8D7 16 F96F JSR SEND_TXT ; Print text at X 479: F8DA 16 FFE7 JSR OSNEWL 480: F8DD 20 C3 BRA CLILOOP2 ; Return to command prompt 481: 482: F8DF MEM_INIT: 483: F8DF 86 00 LDAA #0 484: F8E1 7A 1000 STAA ESCFLG 485: F8E4 B6 FF81 LDAA $FF81 486: F8E7 7A 1001 STAA DMA_TYPE 487: F8EA COM_INIT: 488: F8EA FC FF88 LDD DEFBOT ; Initialise bottom of user memory 489: F8ED 7C 1008 STD MEMBOT 490: F8F0 FC FF8A LDD DEFTOP ; Initialise top of user memory 491: F8F3 7C 100A STD MEMTOP 492: F8F6 COM_BRKV: 493: F8F6 CC F8CF LDD #COM_ERR ; Get Supervisor error handler address 494: F8F9 7C 1022 STD BRKV ; Set error handler 495: F8FC ERR_INIT: 496: F8FC 97 TSTA 497: F8FD 26 06 BNE ERR_INIT2 ; A<>$00, just read values 498: F8FF FC 100E LDD TRANSFER ; Set last entered code as current program 499: F902 7C 1010 STD PROGRAM 500: F905 ERR_INIT2: 501: IF VECBASE < ROMSTART 502: F905 CE FE03 LDX #TRAP_HANDLE 503: F908 7E 11F8 STX VECBASE+$F8 504: F90B CC FDF7 LDD #SWI_HANDLE ; Get default SWI address = error handler 505: F90E 7C 11F6 STD VECBASE+$F6 ; Point SWI vector to error handler 506: ENDIF 507: F911 CE 1022 LDX #BRKV 508: F914 CD 1000 LDY #ESCFLG ; Return X=>BRKV, Y=>ESCFLG, NE=little-endian FS calls 509: IF BIGENDIAN 510: F917 C7 CLRB 511: F918 87 CLRA ; Return EQ=big-endian filing system calls 512: ENDIF 513: F919 PREND: 514: F919 LREAL: 515: F919 3D RTS 516: 517: 518: ; FLEX/OS-9 BIOS code 519: ; =================== 520: F91A 16 FFE0 INECHO: JSR OSRDCH 521: F91D 06 FFEE JMP OSWRCH 522: F920 16 FFE7 PRTST: JSR OSNEWL 523: F923 A6 30 PRDAT: LDAA 1,X+ ; Get character 524: F925 81 04 CMPA #4 ; EOT character? 525: F927 27 F0 BEQ PREND ; End printing 526: F929 16 FFEE JSR OSWRCH ; Print character 527: F92C 20 F5 BRA PRDAT ; Loop to next 528: F92E 36 KBDTST: PSHA 529: F92F 34 PSHX 530: F930 35 PSHY 531: F931 86 80 LDA #$80 532: F933 CE FFFF LDX #$FFFF ; Should check ADVAL(-2) if Serial is current input stream 533: F936 B7 56 TFR X,Y 534: F938 16 FFF4 JSR OSBYTE ; ADVAL(-1) - keyboard input buffer 535: F93B 8E 0000 CPX #0 ; Set Z/NZ from X 536: F93E 31 PULY 537: F93F 30 PULX 538: F940 32 PULA 539: F941 3D RTS 540: 541: 542: ; ***************** 543: ; Printout Routines 544: ; ***************** 545: 546: ; Print X as 4-digit hex 547: ; ====================== 548: ; API allows A to be corrupted 549: ; All other registers preserved (v1.04 including B) 550: F942 PR_2HEX: 551: F942 37 PSHB 552: F943 B7 54 TFR X,D ; Copy X to D, so copy b8-b15 to A 553: F945 07 03 BSR PR_HEX ; Print it 554: F947 B7 10 TFR B,A ; Copy other b0-b7 to A 555: F949 33 PULB ; Restore B 556: ; Fall through into PR_HEX 557: 558: 559: ; Print A as 2-digit hex 560: ; ====================== 561: ; API allows A to be corrupted 562: ; All other registers preserved 563: F94A PR_HEX: 564: F94A 36 PSHA ; Standard hex-print code 565: F94B 44 LSRA 566: F94C 44 LSRA 567: F94D 44 LSRA 568: F94E 44 LSRA 569: F94F 07 01 BSR PR_NYBBLE 570: F951 32 PULA ; Get A back 571: ; Fall through into PR_NYBBLE 572: F952 PR_NYBBLE: 573: F952 84 0F ANDA #$0F 574: F954 81 0A CMPA #$0A 575: F956 25 02 BCS PR_DIGIT 576: F958 8B 07 ADDA #7 577: F95A PR_DIGIT: 578: F95A 8B 30 ADDA #$30 579: F95C 06 FFEE JMP OSWRCH 580: 581: ; Print inline text 582: ; ================= 583: ; On exit: A=$00 584: ; 585: F95F PR_TEXT: 586: IF VERSION*16+BUILD>$1050 587: F95F 34 PSHX ; Save X 588: F960 EE F3 0002 LDX [2,SP] ; Get stacked PC to X 589: F964 07 09 BSR SEND_TXT ; Print text 590: F966 6E F3 0002 STX [2,SP] ; Update stacked PC 591: F96A 30 PULX ; Restore X 596: ENDIF 597: F96B SEND_END: 598: F96B 3D RTS ; And return to code 599: 600: ; Print text string at X 601: ; ====================== 602: ; On entry: X=>zero-terminated text string 603: ; On exit: X=>byte after zero byte terminator 604: ; A=$00 605: ; 606: F96C PR_HELP: 607: F96C CE F816 LDX #BANNER ; Print startup banner 608: F96F SEND_TXT: 609: F96F A6 30 LDA 1,X+ ; Get byte from X, increment X 610: F971 27 F8 BEQ SEND_END ; End if $00 byte 611: F973 16 FFE3 JSR OSASCI ; Send to OSASCI 612: F976 20 F7 BRA SEND_TXT ; Loop until $00 byte 613: 614: 615: ; ********************** 616: ; Line scanning Routines 617: ; ********************** 618: 619: ; Scan hex string 620: ; =============== 621: ; On entry, X=>start of hex string 622: ; On exit, X=>first non-hex character 623: ; Y=hex value 624: ; A=terminating character 625: ; B=corrupted 626: ; CS if number terminated, eg 123 X or 123 627: ; CC if number not terminated, eg 123X 628: ; 629: F978 RD_HEX: 630: IF LOCAL_GO 631: F978 CD 0000 LDY #0 ; Clear hex accumulator 632: F97B RD_HEXLP: 633: F97B A6 30 LDA 1,X+ ; Get current character 634: F97D 81 30 CMPA #$30 ; <'0', exit 635: F97F 25 34 BCS RD_HEXDONE 636: F981 81 3A CMPA #$3A ; '0'..'9', add to accumulator 637: F983 25 0A BCS RD_HEXADD 638: F985 84 DF ANDA #$DF ; Ensure upper case letter 639: F987 80 07 SUBA #$07 ; Convert letter, if <'A', exit 640: F989 25 2A BCS RD_HEXDONE 641: F98B 81 40 CMPA #$40 642: F98D 24 26 BCC RD_HEXDONE ; If >'F', exit 643: F98F RD_HEXADD: 644: F98F 84 0F ANDA #$0F ; AB=0Nxx, X=>line Y=acc 645: F991 B7 C6 EXG D,Y ; AB=acc, X=>line Y=0Nxx 646: F993 58 ASLB 647: F994 45 ROLA 648: F995 58 ASLB 649: F996 45 ROLA 650: F997 58 ASLB 651: F998 45 ROLA 652: F999 58 ASLB 653: F99A 45 ROLA ; AB=acc*16, X=>line, Y=0Nxx 654: F99B B7 D6 EXG X,Y ; AB=acc*16, X=0Nxx, Y=>line 655: F99D B7 C5 EXG D,X ; AB=0Nxx, X=acc*16, Y=>line 656: F99F B7 81 EXG A,B ; AB=xx0N, X=acc*16, Y=>line 657: F9A1 1AE5 ABX ; AB=xx0N, X=acc*16+N, Y=>line 658: F9A3 B7 D6 EXG X,Y ; AB=xx0N, X=>line, Y=acc*16+N 659: F9A5 20 D4 BRA RD_HEXLP ; Move to next character 662: ENDIF 663: 664: IF LOCAL_CMDS 665: ; Skip parameter word 666: ; =================== 667: ; On entry, X=>command line 668: ; On exit, X=>first non-space character after current parameter word 669: ; A=first non-space character 670: F9A7 SKIPWORD: 671: F9A7 A6 30 LDA 1,X+ ; Step past parameter 672: F9A9 81 21 CMPA #'!' 673: F9AB 24 FA BCC SKIPWORD 674: F9AD 1A 1F LEAX -1,X ; Step back, then skip spaces 675: 676: ; Skip spaces 677: ; =========== 678: ; On entry, X=>command line 679: ; On exit, X=>first non-space character 680: ; A=first non-space character 681: F9AF SKIPSPC: 682: F9AF A6 30 LDA 1,X+ 683: F9B1 81 20 CMPA #' ' 684: F9B3 27 FA BEQ SKIPSPC ; Skip space characters 685: F9B5 RD_HEXDONE: 686: F9B5 1A 1F LEAX -1,X ; Point to non-hex/non-space char 687: F9B7 81 21 CMPA #'!' ; Return CS if no following character 688: F9B9 3D RTS 689: ENDIF 690: 691: 692: ; ********************** 693: ; MOS Interface Routines 694: ; ********************** 695: 696: ; OSCLI - Execute command 697: ; ======================= 698: ; On entry: X=>command string 699: ; On exit: A holds any return value 700: ; 701: ; First check for local commands, then pass on to host 702: ; 703: F9BA CLI: 704: F9BA 37 PSHB 705: F9BB 34 PSHX 706: F9BC 35 PSHY ; Save everything on caller's stack, except A and CC 707: ; IF WORKSP > ROMSTART 708: ; CMPS #ROMSTART ; Check where the stack is 709: ; BCC CLI_SYSSTK ; We're already using internal stack 710: ; STS STKSAVE-2 ; As a *command may result in data transfer, that 711: ; LDS #CLISTK ; data may end up overwriting stack in user memory, 712: ;CLI_SYSSTK: ; so use a temporary stack to do OS_CLI. If OS_CLI 713: ; ENDIF 714: F9BD 07 11 BSR CLI_GO ; ends up jumping to a new process, new stack will 715: ; LDS #0 ; be set up by that new process. 716: ;STKSAVE: 717: F9BF 31 PULY 718: F9C0 30 PULX 719: F9C1 33 PULB ; Restore everything and return contents of A. 720: F9C2 3D RTS 721: 722: ; Local *commands 723: ; --------------- 724: F9C3 CLI_TABLE: 725: IF LOCAL_GO 726: F9C3 47 4F FCC "GO" 727: F9C5 80 FCB $80 728: ENDIF 729: IF LOCAL_HELP 730: F9C6 48 45 4C 50 FCC "HELP" 731: F9CA 81 FCB $81 732: ENDIF 733: IF LOCAL_RUN 734: F9CB 52 55 4E FCC "RUN" 735: F9CE 82 FCB $82 736: ENDIF 737: IF LOCAL_CMDS 738: F9CF 00 FCB 0 739: 740: ; OSCLI - Check for local commands 741: ; -------------------------------- 742: ; On entry: X=>command string 743: ; 744: F9D0 CLI_GO: 745: F9D0 CLI_LP1: 746: F9D0 07 DD BSR SKIPSPC ; Skip leading spaces 747: F9D2 A6 30 LDA 1,X+ 748: F9D4 81 2A CMPA #'*' 749: F9D6 27 F8 BEQ CLI_LP1 ; Skip leading '*'s 750: F9D8 1A 1F LEAX -1,X 751: F9DA 34 PSHX ; Save start of command text 752: IF LOCAL_RUN 753: F9DB 81 2F CMPA #'/' ; Skip to parameters for '*/name' and '*/ name' 754: F9DD 27 6C BEQ CMD_SLASH 755: ENDIF 756: F9DF 07 C6 BSR SKIPWORD ; Step past command 757: F9E1 7E 1006 STX LPTR ; Point LPTR to command parameters 758: 759: F9E4 CD F9C3 LDY #CLI_TABLE ; Point to command table 760: F9E7 CLI_LOOP0: 761: F9E7 EE 80 LDX ,SP ; Get start of command text back 762: F9E9 A6 00 LDA ,X ; Get first character 763: F9EB 81 41 CMPA #'A' 764: F9ED 25 67 BCS CLI_TUBE ; Not a letter, pass to host 765: F9EF CLI_LOOP2: 766: F9EF A6 30 LDA 1,X+ ; Get character from command line 767: F9F1 84 DF ANDA #$DF ; Force to upper case 768: F9F3 A1 70 CMPA 1,Y+ ; Compare with table entry 769: F9F5 27 F8 BEQ CLI_LOOP2 ; Characters match, check next 770: F9F7 A6 6F LDA 1,-Y ; Step to command token 771: F9F9 2B 16 BMI CLI_MATCH ; Match 772: F9FB A6 1F LDA -1,X ; Get character from command line 773: F9FD 81 2E CMPA #'.' 774: F9FF 27 0A BEQ CLI_DOT ; Abbreviated command 775: FA01 CLI_NEXT: 776: FA01 A6 70 LDA 1,Y+ ; Search for command token 777: FA03 2A FC BPL CLI_NEXT ; Step to end of table entry 778: FA05 A6 40 LDA ,Y 779: FA07 26 DE BNE CLI_LOOP0 ; Not end of table 780: FA09 20 4B BRA CLI_TUBE ; Pass to host 781: FA0B CLI_DOT: 782: FA0B A6 70 LDA 1,Y+ ; Search for command token 783: FA0D 2A FC BPL CLI_DOT ; Step to end of table entry 784: FA0F 20 06 BRA CLI_MATCH2 785: FA11 CLI_MATCH: 786: FA11 E6 2F LDB 1,-X ; Get current character 787: FA13 C1 21 CMPB #'!' 788: FA15 24 3F BCC CLI_TUBE ; Command line longer than table entry 789: FA17 CLI_MATCH2: 790: FA17 81 81 CMPA #$81 791: FA19 27 2D BEQ CMD_HELP 792: FA1B 24 30 BCC CMD_RUN 793: ENDIF 794: 795: ; *GO ; parameters 796: ; ----------------------- 797: IF LOCAL_GO 798: FA1D CMD_GO: 799: FA1D 07 90 BSR SKIPSPC 800: FA1F FD 1010 LDY PROGRAM ; Default to re-enter current program 801: FA22 81 0D CMPA #13 802: FA24 27 18 BEQ CLI_GO2 ; *GO - enter current program 803: FA26 81 3B CMPA #';' 804: FA28 27 12 BEQ CLI_GO1 ; *GO ;params - enter current program 805: FA2A 16 FFA1 JSR SCANHEX ; Get hex address 806: FA2D 24 27 BCC CLI_TUBE ; Malformed hex address, pass to host 807: FA2F 16 F9AF JSR SKIPSPC 808: FA32 81 3B CMPA #';' ; Check for ';' parameter marker 809: FA34 27 06 BEQ CLI_GO1 ; *GO ;params or *GO ;params 810: FA36 81 0D CMPA #13 811: FA38 26 1C BNE CLI_TUBE ; *GO ... or *GO .... 812: FA3A 1A 1F LEAX -1,X ; Balance following 1,X 813: FA3C CLI_GO1: 814: FA3C 1A 01 LEAX 1,X ; Step past ';' 815: FA3E CLI_GO2: 816: FA3E 7E 1006 STX LPTR ; Save pointer to command parameters 817: FA41 30 PULX ; Drop old line pointer 818: FA42 B7 65 TFR Y,X ; X=entry address 819: FA44 1401 SEC ; Set Carry to indicate OSCLI 820: FA46 20 22 BRA EXECUTE2 821: ENDIF 822: 823: ; *HELP () 824: ; --------------- 825: IF LOCAL_HELP 826: FA48 CMD_HELP: 827: ; JSR SKIPSPC 828: ; BCS CMD_HELP2 ; *HELP - display help 829: ; CMPA #'.' ; *HELP . - display help 830: ; BNE CLI_TUBE ; Otherwise, pass stright to host 831: FA48 CMD_HELP2: 832: FA48 16 F96C JSR PR_HELP ; Print banner as help message 833: ; Fall through to CLI_TUBE, harmlessly updating LPTR 834: ENDIF 835: 836: ; *RUN - updates LPTR to point to correct parameters 837: ; -------------------------------------------------------------------------- 838: IF LOCAL_RUN 839: FA4B CMD_SLASH: 840: FA4B 1A 01 LEAX 1,X ; Step past '/' 841: FA4D CMD_RUN: 842: FA4D 16 F9AF JSR SKIPSPC 843: FA50 16 F9A7 JSR SKIPWORD ; Step past *RUN filename 844: FA53 7E 1006 STX LPTR ; Update LPTR to parameters 845: ENDIF 846: 847: 848: ; OSCLI - Send command line to host 849: ; ================================= 850: ; On entry: X=>command string 851: ; On exit: All registers possibly corrupted 852: ; Registers should be preserved by calling code 853: ; 854: ; Tube data: $02 string $0D -- $7F or $80 855: ; 856: IF LOCAL_CMDS 857: FA56 CLI_TUBE: 858: FA56 30 PULX ; Get command string back 861: ENDIF 862: FA57 86 02 LDAA #2 863: FA59 16 FD21 JSR SendCommand ; Send command $02 = OSCLI 864: FA5C 16 FCC2 JSR SEND_STR ; Send string at X 865: FA5F CLI_WAIT1: 866: FA5F 1401 SEC ; Clear Carry to indicate OSCLI (SEND_STR returns CC) 867: FA61 CLI_WAIT: 868: FA61 16 FD34 JSR WaitByte ; Wait for result via Tube R2 (preserves Cy) 869: FA64 CLI_CHECK: 870: FA64 97 TSTA ; Check return code 871: FA65 2A 4C BPL CLI_DONE ; Nothing to execute, return 872: 873: 874: ; EXECUTE - Enter code at ADDRESS 875: ; =============================== 876: ; Checks for possible code header, makes code current PROGRAM. 877: ; On entry, ADDRESS=code entry address 878: ; CS=entering from OSCLI 879: ; CC=enteriung from RESET 880: ; 881: ; If code in high memory, MEMTOP moved to below code. 882: ; If code returns, MEMTOP and PROGRAM restored to previous value. 883: ; 884: ; If code has a header it is entered with A=1. If not, it is entered with A=0. 885: ; Code has a small initial stack with 100 bytes available on it (eg 50 subroutine 886: ; calls) unless OSCLI calls OSCLI recursively. If the code calls OSINIT it 887: ; becomes the current program and is re-entered at soft reset. Code that becomes 888: ; the current program must set up their own stack in user space. 889: ; 890: ; If called from RESET and not 6812 code, error not reported, jumps directly 891: ; to CLICOM. In future this is the point where a disk operating system would 892: ; be checked for and booted. 893: ; 894: FA67 EXECUTE: 895: FA67 FE 100C LDX ADDRESS ; Get transfer address, note: big-endian 896: FA6A EXECUTE2: 897: FA6A 39 PSHC ; Save RESET/OSCLI flag 898: FA6B 34 PSHX ; Save address on stack 899: FA6C E6 07 LDB 7,X ; Get (C) offset 900: FA6E 1AE5 ABX ; X=>(C) string 901: FA70 CD FAC0 LDY #EXEC_CHK+4 ; Y=>check string 902: FA73 C6 04 LDB #4 ; 4 bytes to check 903: FA75 EXEC_LP: 904: FA75 A6 30 LDA 1,X+ ; Get byte from header 905: FA77 A1 60 CMPA -1,-Y ; Compare with check string 906: FA79 26 39 BNE EXEC_JUMP ; No match, enter as raw code 907: FA7B 53 DECB 908: FA7C 26 F7 BNE EXEC_LP ; Loop to check all four bytes 909: FA7E 31 PULY ; Get entry address back 910: FA7F A6 46 LDA 6,Y ; Get code type 911: FA81 48 ASLA ; Check b6 by moving it into b7 912: FA82 2A 3C BPL ERR_NOTCODE 913: FA84 84 1E ANDA #2*15 ; Byte has been moved up, so mask and compare with 2*n 914: FA86 81 06 CMPA #2*3 ; NB: 3=6809, need a further check for 6812 915: FA88 26 36 BNE ERR_NOT6812 916: 917: IF 0 921: ENDIF 922: 923: FA8A 1A 1C LEAX -4,X 924: FA8C 7E 1002 STX FAULT ; Point FAULT to (C) string (should be version string) 925: FA8F 32 PULA ; Get RESET/OSCLI flag to A 926: FA90 FE 1010 LDX PROGRAM 927: FA93 34 PSHX ; Save current PROGRAM 928: FA94 FE 100A LDX MEMTOP 929: FA97 34 PSHX ; Save current MEMTOP 930: FA98 8D 8000 CPY #$8000 931: FA9B 25 03 BCS EXEC_ENTER ; Entering code in low memory, leave MEMTOP where it is 932: FA9D 7D 100A STY MEMTOP ; Entering in high memory, put MEMTOP below entered code 933: FAA0 EXEC_ENTER: 934: FAA0 7D 100E STY TRANSFER ; Set as last entered code 935: FAA3 FE 1006 LDX LPTR ; X=>command line 936: FAA6 46 RORA ; Move RESET/OSCLI flag back into Carry 937: FAA7 86 01 LDA #1 ; A=1 for code with a header 938: FAA9 15 40 JSR ,Y ; Call program execution address 939: FAAB 31 PULY 940: FAAC 7D 100A STY MEMTOP ; Restore previous MEMTOP if code returns 941: FAAF 31 PULY 942: FAB0 7D 1010 STY PROGRAM ; Restore previous PROGRAM 943: FAB3 NULL: ; Null routines 944: FAB3 CLI_DONE: 945: FAB3 3D RTS ; Return 946: FAB4 EXEC_JUMP: 947: FAB4 FE 1006 LDX LPTR ; X=>command line 948: FAB7 31 PULY ; Get entry address back 949: FAB8 87 CLRA ; A=0 for raw code 950: FAB9 38 PULC ; Get RESET/OSCLI flag 951: FABA 05 40 JMP ,Y ; Enter raw code 952: FABC EXEC_CHK: 953: FABC 29 43 28 FCC ")C(" ; Deliberately backwards so doesn't match itself 954: FABF 00 FCB 0 955: FAC0 ERR_NOTCODE: 956: ; PULC ; Get RESET/OSCLI flag 957: ; LBCC CLICOM ; If called from RESET, drop straight into Supervisor 958: ; JSR COM_BRKV 959: ; SWI 960: ; FCB 249 961: ; FCC "Not code" 962: ; FCB 0 963: FAC0 ERR_NOT6812: 964: FAC0 38 PULC ; Get RESET/OSCLI flag 965: FAC1 1824 04F4 LBCC CLICOM ; If called from RESET, drop straight into Supervisor 966: ; Here is where we would check if this is hard reset, 967: ; and look for a disk operating system to boot instead. 968: FAC5 16 F8F6 JSR COM_BRKV ; Error handler may have been overwritten, so set up 969: FAC8 3F SWI ; Supervisor error handler 970: FAC9 F9 FCB 249 971: FACA 4E 6F 74 20 36 38 FCC "Not 6812 code" FAD0 31 32 20 63 6F 64 FAD6 65 972: FAD7 00 FCB 0 973: 974: 975: ; OSRDCH - Wait for character from input stream 976: ; ============================================= 977: ; On exit: A=char, Cy=carry 978: ; 979: FAD8 RDCH: 980: FAD8 RDCH_RAW: 981: FAD8 16 FD34 JSR WaitByte ; Wait for character 982: FADB 36 PSHA ; Save character 983: FADC B6 1000 LDAA >ESCFLG ; Get Escape flag 984: FADF 48 ASLA ; Copy b7 of ESCFLG to Carry 985: FAE0 32 PULA ; Get character back 986: FAE1 BYTE_DONE: 987: FAE1 3D RTS 988: 989: 990: ; OSRDCH_IO - Request character via Tube API 991: ; ========================================== 992: ; Tube data: $00 -- Carry Char 993: ; 994: ; On exit: A=char, Cy=carry 995: ; 996: FAE2 RDCH_IO: 997: FAE2 86 00 LDAA #0 998: FAE4 16 FD21 JSR SendCommand ; Send command $00 - OSRDCH 999: FAE7 WAIT_CHAR: 1000: FAE7 16 FD34 JSR WaitByte ; Get returned byte 1001: FAEA 48 ASLA ; Move b7 into Carry 1002: FAEB 06 FD34 JMP WaitByte ; Jump to get character 1003: 1004: 1005: ; OSBYTE 1006: ; ====== 1007: ; On entry: A,X,Y=OSBYTE parameters 1008: ; On exit: A preserved 1009: ; If A<$80, X=returned value 1010: ; If A>$7F, X, Y, Carry=returned values 1011: ; 1012: ; Tube data: $04 X A -- X 1013: ; $06 X Y A -- Cy Y X 1014: ; 1015: FAEE BYTE: 1016: FAEE 3B PSHD 1017: FAEF 97 TSTA 1018: FAF0 2B 29 BMI BYTE_HI 1019: FAF2 86 04 LDAA #4 1020: FAF4 16 FD21 JSR SendCommand ; Send command $04 - short BYTE 1021: FAF7 B7 54 TFR X,D ; B=X 1022: FAF9 16 FD0B JSR SendByteB ; Send second parameter from B 1023: FAFC 3A PULD 1024: FAFD 3B PSHD 1025: FAFE 16 FD0D JSR SendByte ; Send first parameter 1026: FB01 16 FD34 JSR WaitByte ; Wait for response 1027: FB04 B7 01 TFR A,B ; Move result to low byte 1028: FB06 86 00 LDAA #0 ; Ensure AB is only 8-bit value 1029: FB08 B7 45 TFR D,X 1030: FB0A 3A PULD 1031: FB0B 3D RTS 1032: 1033: ; OSFSC 1034: ; ===== 1035: ; On entry: A,X,Y=OSFSC parameters 1036: ; NB: Only implemented for A>$7F 1037: ; On exit: A preserved 1038: ; X, Y, Carry=returned values 1039: ; 1040: ; Tube data: $18 X Y A -- Cy Y X 1041: ; 1042: FB0C FSC: 1043: FB0C 3B PSHD 1044: FB0D 86 18 LDAA #$18 ; Set command $18 - FSC 1045: FB0F 20 16 BRA BYTE_CMD ; Jump to send command 1046: 1047: FB11 BYTE_WAIT: 1048: FB11 CE F816 LDX #BANNER ; Point LPTR to 1049: FB14 7E 1006 STX LPTR 1050: FB17 1820 FF44 LBRA CLI_WAIT1 ; Wait for program start 1051: 1052: ; OSBYTE >$7F 1053: ; ----------- 1054: FB1B BYTE_HI: 1055: FB1B 81 82 CMPA #$82 1056: FB1D 25 06 BCS BYTE_HI1 ; <$82, not a memory OSBYTE 1057: FB1F 27 36 BEQ MEM82 ; =$82, fetch address high word 1058: FB21 81 85 CMPA #$85 1059: FB23 25 34 BCS MEM83 ; <$85, fetch low/high memory limit 1060: FB25 BYTE_HI1: 1061: FB25 86 06 LDAA #6 ; Set command $06 - long BYTE 1062: FB27 BYTE_CMD: 1063: FB27 16 FD21 JSR SendCommand ; Send command 1064: FB2A B7 54 TFR X,D ; B=X - second parameter 1065: FB2C 16 FD0B JSR SendByteB ; Send second parameter from B 1066: FB2F 16 FD09 JSR SendByteY ; Send third parameter from Y 1067: FB32 3A PULD 1068: FB33 16 FD0D JSR SendByte ; Send first parameter 1069: FB36 81 9D CMPA #$9D ; Was it fast BPUT? 1070: FB38 27 A7 BEQ BYTE_DONE ; Don't wait for response 1071: FB3A 81 8E CMPA #$8E ; Was it start language? 1072: FB3C 27 D3 BEQ BYTE_WAIT ; Wait for program start 1073: FB3E 3B PSHD 1074: FB3F 16 FD34 JSR WaitByte ; Wait for response 1075: FB42 48 ASLA ; Move b7 into carry 1076: FB43 39 PSHC ; Save flags 1077: FB44 16 FD34 JSR WaitByte ; Wait for response 1078: FB47 B7 01 TFR A,B ; Move result to low byte 1079: FB49 86 00 LDAA #0 ; Ensure AB is only 8-bit value 1080: FB4B B7 46 TFR D,Y ; Return result in Y 1081: FB4D 16 FD34 JSR WaitByte ; Wait for response, high byte still in B 1082: FB50 B7 81 EXG A,B ; Swap so high byte is Y, low byte is fetched byte 1083: FB52 B7 45 TFR D,X ; Return result in X is Y*256+X 1084: FB54 38 PULC ; Get flags back 1085: FB55 3A PULD 1086: FB56 3D RTS 1087: FB57 MEM82: 1088: FB57 86 88 LDA #$88 1089: FB59 MEM83: 1090: FB59 MEM84: 1091: FB59 48 ASLA ; A=16,8,10 1092: FB5A CE 1002 LDX #MEMBOT-6 ; Point to addresses 1093: FB5D EC E4 LDD A,X ; Fetch address value 1094: FB5F B7 45 TFR D,X ; Return X=address 1095: FB61 B7 01 TFR A,B ; Copy top byte to bottom byte 1096: FB63 87 CLRA ; Clear top byte 1097: FB64 B7 46 TFR D,Y ; Return Y=address DIV 256 1098: FB66 3A PULD 1099: FB67 3D RTS 1100: 1101: 1102: ; OSWORD 1103: ; ====== 1104: ; On entry: A=OSWORD number 1105: ; X=>control block 1106: ; 1107: FB68 WORD: 1108: FB68 97 TSTA 1109: FB69 27 50 BEQ RDLINE ; Jump with OSWORD 0 - RDLINE 1110: 1111: ; OSWORD <>&00 1112: ; ------------ 1113: ; Tube data: &08 function in_length block out_length -- block 1114: ; 1115: FB6B 3B PSHD ; Save AB 1116: FB6C 35 PSHY ; Save Y 1117: FB6D 34 PSHX ; Save X=>control block 1118: FB6E B7 01 TFR A,B ; B=function 1119: FB70 86 08 LDAA #$08 1120: FB72 16 FD21 JSR SendCommand ; Send command $08 - OSWORD 1121: FB75 16 FD0B JSR SendByteB ; Send OSWORD function from B 1122: FB78 D7 TSTB ; Check OSWORD function 1123: FB79 2B 0B BMI WORD_SEND ; Jump to send control block 1124: FB7B WORD_TXLO: 1125: FB7B 86 10 LDAA #$10 1126: FB7D C1 15 CMPB #$15 ; Check OSWORD function 1127: FB7F 24 07 BCC WORD_SEND1 ; Use 16 bytes for OSWORD &15 to &7F 1128: FB81 CE FBEA LDX #WORDTX-1 ; X=>send length table for OSWORD 1 to &14 1129: FB84 1AE5 ABX ; X=X+B, X=>send length 1130: FB86 WORD_SEND: 1131: FB86 A6 00 LDAA ,X ; Get send block length from control block or table 1132: FB88 WORD_SEND1: 1133: FB88 B7 01 TFR A,B ; B=control block length 1134: FB8A EE F3 0000 LDX [0,SP] ; Get X=>control block back 1135: FB8E 16 FD0B JSR SendByteB ; Send outward block length 1136: FB91 53 DECB 1137: FB92 2B 04 BMI WORD_NOTX ; Only send length 1 to 128 1138: FB94 52 INCB 1139: FB95 16 FCCC JSR SEND_BLOCK ; B=length, X=>block, returns B=0, X=>block 1140: FB98 WORD_NOTX: 1141: FB98 E6 F3 0002 LDAB [2,SP] ; Get OSWORD function 1142: FB9C 2B 0B BMI WORD_RECV ; Jump to send control block with function>&7F 1143: FB9E WORD_RXLO: 1144: FB9E 86 10 LDAA #$10 1145: FBA0 C1 15 CMPB #$15 ; Check OSWORD function 1146: FBA2 24 07 BCC WORD_RECV1 ; Use 16 bytes for OSWORD &15 to &7F 1147: FBA4 CE FBFD LDX #WORDRX-2 ; X=>receive length table for OSWORD 1 to &14 1148: FBA7 1AE5 ABX ; X=X+B, X=>receive length 1149: FBA9 WORD_RECV: 1150: FBA9 A6 01 LDAA 1,X ; Get receive length from table or control block 1151: FBAB WORD_RECV1: 1152: FBAB B7 01 TFR A,B ; B=send block length 1153: FBAD 30 PULX ; Get X=>control block back 1154: FBAE 16 FD0B JSR SendByteB ; Send inward block length 1155: FBB1 53 DECB 1156: FBB2 2B 04 BMI WORD_NORX ; Only receive length 1 to 128 1157: FBB4 52 INCB 1158: FBB5 16 FCD7 JSR WAIT_BLOCK ; Wait for returned control block 1159: FBB8 WORD_NORX: 1160: FBB8 31 PULY ; Restore Y 1161: FBB9 3A PULD ; Restore AB 1162: FBBA 3D RTS 1163: 1164: 1165: ; OSWORD 0 - Read a line of text 1166: ; ------------------------------ 1167: ; On entry: X=>addr.hi, addr.lo, maxlen, charlo, charhi 1168: ; On exit: Cy=0: Ok, Cy=1: Escape 1169: ; Y=length of returned string in buffer at addr 1170: ; 1171: ; Note: Address of text string in control block is local big-endian address 1172: ; All other OSWORD calls use little-endian addresses to match Host 1173: ; 1174: ; Tube data: $0A block -- $FF or $7F string $0D 1175: ; 1176: FBBB RDLINE: 1177: FBBB 86 0A LDA #10 1178: FBBD 16 FD21 JSR SendCommand ; Send Command $0A - RDLINE 1179: FBC0 37 PSHB 1180: FBC1 1A 02 LEAX 2,X ; X=X+2, point to parameters 1181: FBC3 C6 03 LDB #3 1182: FBC5 16 FCCC JSR SEND_BLOCK ; Send 3-byte control block 1183: FBC8 86 07 LDA #7 1184: FBCA 16 FD0D JSR SendByte ; Send $0700 1185: FBCD 16 FD0B JSR SendByteB ; Sent $00 as B=0 from SEND_BLK 1186: FBD0 16 FD34 JSR WaitByte ; Wait for response 1187: FBD3 48 ASLA ; Move b7 into Carry 1188: FBD4 25 0F BCS RD_DONE 1189: FBD6 EE E3 FFFE LDX [-2,X] ; Get text pointer from control block 1190: ; CLRB ; B=number received - B already zero from SEND_BLK 1191: FBDA RD_STR: 1192: FBDA 16 FD34 JSR WaitByte ; Wait for byte from Tube 1193: FBDD 6A 30 STA 1,X+ ; Store in text buffer, increment X 1194: FBDF 52 INCB ; Increment character count 1195: FBE0 81 0D CMPA #13 ; Check current byte 1196: FBE2 26 F6 BNE RD_STR ; Loop until 1197: FBE4 53 DECB ; Decrement character count to balance 1198: ; CLC ; Clear Carry (already CC from CMPA #13) 1199: FBE5 RD_DONE: 1200: FBE5 86 00 LDA #0 ; Clear A without clearing Carry 1201: FBE7 B7 46 TFR D,Y ; Y=length 1202: FBE9 33 PULB ; Restore B 1203: FBEA 3D RTS 1204: 1205: ; Table of OSWORD control block lengths for &01-&14 1206: ; ------------------------------------------------- 1207: FBEB WORDTX: 1208: FBEB 00 05 00 05 04 FCB $00,$05,$00,$05,$04 1209: FBF0 05 08 0E 04 01 FCB $05,$08,$0E,$04,$01 1210: FBF5 01 05 00 10 20 FCB $01,$05,$00,$10,$20 1211: FBFA 10 0D 00 08 80 FCB $10,$0D,$00,$08,$80 1212: FBFF WORDRX: 1213: FBFF 05 00 05 00 05 FCB $05,$00,$05,$00,$05 1214: FC04 00 00 00 05 09 FCB $00,$00,$00,$05,$09 1215: FC09 05 00 08 19 00 FCB $05,$00,$08,$19,$00 1216: FC0E 01 0D 80 08 80 FCB $01,$0D,$80,$08,$80 1217: 1218: 1219: ; OSARGS - Read info on open file 1220: ; =============================== 1221: ; On entry: A=action 1222: ; X=>data (little-endian) 1223: ; Y=handle 1224: ; On exit: A=returned value 1225: ; X preserved 1226: ; X=>any returned data 1227: ; Y preserved 1228: ; 1229: ; Tube Data: $0C handle block function -- result block 1230: ; 1231: FC13 ARGS: 1232: FC13 35 PSHY ; Save handle 1233: FC14 3B PSHD ; Save function and B 1234: FC15 86 0C LDAA #$0C 1235: FC17 16 FD21 JSR SendCommand ; Send command $0C - OSARGS 1236: FC1A 16 FD09 JSR SendByteY ; Send handle 1237: IF BIGENDIAN 1238: FC1D C7 CLRB ; Point to first byte of word to send 1239: FC1E 16 FCE2 JSR SEND_WORDS ; Send four-byte control block 1243: ENDIF 1244: FC21 32 PULA ; Get action back 1245: FC22 16 FD0D JSR SendByte ; Send action 1246: FC25 16 FD34 JSR WaitByte ; Wait for returned result 1247: FC28 36 PSHA ; Save result 1248: IF BIGENDIAN 1249: FC29 C7 CLRB ; Point to first byte of word to read 1250: FC2A 16 FCF5 JSR WAIT_WORDS ; Wait for four-byte control block 1254: ENDIF 1255: FC2D 3A PULD ; Get result and B back 1256: FC2E 31 PULY ; Get original handle back 1257: FC2F 3D RTS 1258: 1259: 1260: ; OSBGET - Get a byte from open file 1261: ; ================================== 1262: ; On entry: Y=handle 1263: ; On exit: A=byte Read 1264: ; Y=preserved 1265: ; Cy set if EOF 1266: ; 1267: ; Tube data: $0E handle -- Carry byte 1268: ; 1269: FC30 BGet: 1270: FC30 37 PSHB 1271: FC31 86 0E LDAA #$0E 1272: FC33 16 FD21 JSR SendCommand ; Send command $0E - OSBGET 1273: FC36 16 FD09 JSR SendByteY ; Send handle 1274: FC39 33 PULB 1275: FC3A 06 FAE7 JMP WAIT_CHAR ; Wait for Carry, Byte 1276: 1277: 1278: ; OSBPUT - Put a byte to an open file 1279: ; =================================== 1280: ; On entry: A=byte to write 1281: ; Y=handle 1282: ; On exit: A=preserved 1283: ; Y=preserved 1284: ; 1285: ; Tube data: $10 handle byte -- $7F 1286: ; 1287: FC3D BPut: 1288: FC3D 3B PSHD ; Save byte 1289: FC3E 86 10 LDAA #$10 1290: FC40 16 FD21 JSR SendCommand ; Send command $10 - OSBPUT 1291: FC43 16 FD09 JSR SendByteY ; Send handle 1292: FC46 3A PULD ; Get A and B back 1293: FC47 3B PSHD 1294: FC48 16 FD0D JSR SendByte ; Send byte to Tube 1295: FC4B 16 FD34 JSR WaitByte ; Wait for acknowledgement 1296: FC4E 3A PULD ; Restore A 1297: FC4F 3D RTS 1298: 1299: 1300: ; OSFIND - Open or Close a file 1301: ; ============================= 1302: ; On entry: A=function 1303: ; Y=handle or X=>filename 1304: ; On exit: A=zero or handle 1305: ; X,Y preserved 1306: ; 1307: ; Tube data: $12 function string $0D -- handle 1308: ; $12 $00 handle -- $7F 1309: ; 1310: FC50 FIND: 1311: FC50 3B PSHD ; Save A 1312: FC51 86 12 LDAA #$12 1313: FC53 16 FD21 JSR SendCommand ; Send command $12 - OSFIND 1314: FC56 3A PULD ; Get A back 1315: FC57 16 FD0D JSR SendByte ; Send function 1316: FC5A 97 TSTA ; Check function 1317: FC5B 27 06 BEQ Close ; Jump to deal with Close 1318: FC5D 16 FCC2 JSR SEND_STR ; Send string at X 1319: FC60 06 FD34 JMP WaitByte ; Wait for returned handle 1320: FC63 Close: 1321: FC63 37 PSHB 1322: FC64 16 FD09 JSR SendByteY ; Send handle 1323: FC67 16 FD34 JSR WaitByte ; Wait for acknowledgement 1324: FC6A 33 PULB 1325: FC6B 86 00 LDAA #0 ; Zero A 1326: FC6D 3D RTS 1327: 1328: 1329: ; OSFILE - Operate on whole files 1330: ; =============================== 1331: ; On entry: A=function 1332: ; X=>control block 1333: ; On exit: A=result 1334: ; X preserved 1335: ; control block updated 1336: ; 1337: ; Note: Address of text string in control block is local big-endian address 1338: ; All other MOS calls use little-endian addresses to match Host 1339: ; 1340: ; Tube data: $14 block string function -- result block 1341: ; 1342: FC6E FILE: 1343: FC6E 35 PSHY ; Save Y 1344: FC6F 34 PSHX ; Save X 1345: FC70 3B PSHD ; Save function and B 1346: FC71 86 14 LDAA #$14 1347: FC73 16 FD21 JSR SendCommand ; Send command $14 - OSFILE 1348: FC76 1A 02 LEAX 2,X ; Point to control block contents 1349: IF BIGENDIAN 1350: FC78 C6 0C LDB #12 ; Point to first byte to send 1351: FC7A 16 FCE2 JSR SEND_WORDS ; Send 16-byte control block 1355: ENDIF 1356: FC7D EE E3 FFFE LDX [-2,X] ; Get big-endian filename pointer 1357: FC81 16 FCC2 JSR SEND_STR ; Send filename string 1358: FC84 32 PULA ; Get function back 1359: FC85 16 FD0D JSR SendByte ; Send function 1360: FC88 16 FD34 JSR WaitByte ; Wait for returned result 1361: ; ; Data transfer via interupts may happen while waiting 1362: FC8B 33 PULB ; Get saved B from stack 1363: FC8C 30 PULX ; Get control block pointer back 1364: FC8D 3B PSHD ; Save result and B 1365: FC8E 1A 02 LEAX 2,X ; Point to control block contents 1366: IF BIGENDIAN 1367: FC90 C6 0C LDB #12 ; Point to first byte to read 1368: FC92 16 FCF5 JSR WAIT_WORDS ; Wait for 16-byte control block 1372: ENDIF 1373: FC95 1A 1E LEAX -2,X ; Restore X 1374: FC97 3A PULD ; Get result and B back 1375: FC98 31 PULY ; Get Y back 1376: FC99 3D RTS 1377: 1378: 1379: ; OSGBPB - Multiple byte Read and write 1380: ; ===================================== 1381: ; On entry: A=function 1382: ; X=>control block 1383: ; On exit: A=returned value 1384: ; control block updated 1385: ; 1386: ; Tube data: $16 block function -- block Carry result 1387: ; 1388: FC9A GBPB: 1389: FC9A 35 PSHY ; Save Y 1390: FC9B 3B PSHD ; Save function and B 1391: FC9C 86 16 LDAA #$16 1392: FC9E 16 FD21 JSR SendCommand ; Send command $16 - OSGBPB 1393: IF BIGENDIAN 1394: FCA1 1A 01 LEAX 1,X ; Step past handle 1395: FCA3 C6 08 LDB #8 ; Point to first byte to send 1396: FCA5 16 FCE2 JSR SEND_WORDS ; Send 12-byte control block 1397: FCA8 A6 2F LDAA 1,-X ; Decrement X, get handle 1398: FCAA 16 FD0D JSR SendByte ; Send 0th byte of control block 1402: ENDIF 1403: FCAD 32 PULA ; Get function back 1404: FCAE 16 FD0D JSR SendByte ; Send function 1405: IF BIGENDIAN 1406: FCB1 1A 01 LEAX 1,X ; Step past handle 1407: FCB3 C6 08 LDB #8 ; Point to first byte to read 1408: FCB5 16 FCF5 JSR WAIT_WORDS ; Read 12-byte control block 1409: FCB8 16 FD34 JSR WaitByte ; Get 0th byte of control block 1410: FCBB 6A 2F STAA 1,-X ; Decrement X, store cycle 1414: ENDIF 1415: FCBD 33 PULB ; Get B back 1416: FCBE 31 PULY ; Get Y back 1417: FCBF 06 FAE7 JMP WAIT_CHAR ; Get Carry and result byte 1418: 1419: 1420: ; ***************** 1421: ; Tube I/O routines 1422: ; ***************** 1423: 1424: ; Send cr-string at X to Tube 1425: ; =========================== 1426: FCC2 SEND_STR: 1427: FCC2 A6 30 LDAA 1,X+ ; Get byte from X, increment X 1428: FCC4 16 FD0D JSR SendByte ; Send byte 1429: FCC7 81 0D CMPA #13 ; Test current character 1430: FCC9 26 F7 BNE SEND_STR ; Loop until sent 1431: FCCB 3D RTS 1432: 1433: 1434: ; Send block at X to Tube, B=block length 1435: ; ======================================= 1436: ; Returns X=preserved, B=0 1437: FCCC SEND_BLOCK: 1438: FCCC 1AE5 ABX ; X=X+B, X points to end of block+1 1439: FCCE SEND_BLKLP: 1440: FCCE A6 2F LDAA 1,-X ; Decrement X, get byte from X 1441: FCD0 16 FD0D JSR SendByte ; Send byte 1442: FCD3 53 DECB ; Decrement count of bytes to send 1443: FCD4 26 F8 BNE SEND_BLKLP ; Loop until all bytes sent 1444: FCD6 3D RTS 1445: 1446: 1447: ; Wait for block at X from Tube, B=block length 1448: ; ============================================= 1449: ; Returns X=preserved, B=0 1450: FCD7 WAIT_BLOCK: 1451: FCD7 1AE5 ABX ; X=X+B, X points to end of block+1 1452: FCD9 WAIT_BLKLP: 1453: FCD9 16 FD34 JSR WaitByte ; Get byte 1454: FCDC 6A 2F STAA 1,-X ; Decrement X, store byte at X 1455: FCDE 53 DECB ; Decrement count of bytes 1456: FCDF 26 F8 BNE WAIT_BLKLP ; Loop until all bytes sent 1457: FCE1 3D RTS 1458: 1459: IF BIGENDIAN 1460: ; Send big-endian block at X to Tube Register 2, B=>first word 1461: ; ============================================================= 1462: ; Returns X=preserved, B<0 1463: FCE2 SEND_WORDS: 1464: FCE2 1AE5 ABX ; X=X+B, X=>first byte to send 1465: FCE4 SEND_WDLP: 1466: FCE4 A6 30 LDAA 1,X+ ; Get byte from X, increment X 1467: FCE6 07 25 BSR SendByte ; Send byte via Tube R2 1468: FCE8 53 DECB ; Decrement byte count 1469: FCE9 C5 03 BITB #3 1470: FCEB 26 F7 BNE SEND_WDLP ; Loop for four bytes 1471: FCED 1A 18 LEAX -8,X ; Point to next word down 1472: FCEF D7 TSTB 1473: FCF0 2A F2 BPL SEND_WDLP ; Another word to do 1474: FCF2 1A 04 LEAX 4,X ; Restore X 1475: FCF4 3D RTS 1476: 1477: ; Wait for big-endian block at X from Tube Register 2, B=>first word 1478: ; ================================================================== 1479: ; Returns X=preserved, B<0 1480: FCF5 WAIT_WORDS: 1481: FCF5 1AE5 ABX ; X=X+B, X=>first byte to receive 1482: FCF7 WAIT_WDLP: 1483: FCF7 16 FD34 JSR WaitByte ; Get byte via Tube R2 1484: FCFA 6A 30 STA 1,X+ ; Store byte at X, increment X 1485: FCFC 53 DECB ; Decrement count of bytes 1486: FCFD C5 03 BITB #3 1487: FCFF 26 F6 BNE WAIT_WDLP ; Loop for four bytes 1488: FD01 1A 18 LEAX -8,X ; Point to next word down 1489: FD03 D7 TSTB 1490: FD04 2A F1 BPL WAIT_WDLP ; Another word to do 1491: FD06 1A 04 LEAX 4,X ; Restore X 1492: FD08 3D RTS 1493: ENDIF 1494: 1495: 1496: ; Send byte in Y to Tube via B 1497: ; ============================ 1498: FD09 SendByteY: 1499: FD09 B7 64 TFR Y,D 1500: ; ; Fall through into SendByteB 1501: 1502: 1503: ; Send byte in B to Tube 1504: ; ====================== 1505: FD0B SendByteB: 1506: FD0B B7 10 TFR B,A 1507: ; ; Fall through into SendByte 1508: 1509: 1510: ; OSWRCH - Send character in A to Tube 1511: ; ==================================== 1512: ; On entry, A =character 1513: ; On exit, A =preserved 1514: FD0D WRCH: 1515: ; ; WRCH is simply SendByte 1516: 1517: 1518: ; Tube Core I/O Routines 1519: ; ====================== 1520: ; Characters and commands are sent over the same single port 1521: ; Outward commands are escaped, and inward responses are escaped 1522: ; 1523: ; Outward 1524: ; x VDU x 1525: ; esc,esc VDU esc 1526: ; esc,n MOS function, control block follows 1527: ; 1528: ; Inward 1529: ; x char/byte x 1530: ; esc,esc char/byte esc 1531: ; esc,&00 BRK, error number+text+null follows 1532: ; esc,<&80 read returned control block set length 1533: ; esc,&8n Escape change, b0=new state 1534: ; esc,&9x,Y,X,A Event 1535: ; esc,&Ax reserved for networking 1536: ; esc,&Bx end transfer 1537: ; esc,&Cx,addr set address 1538: ; esc,&Dx,addr execute address 1539: ; esc,&Ex,addr start load from address 1540: ; esc,&Fx,addr start save from address 1541: ; All commands are data inward, except esc,&Fx which is data outward 1542: 1543: 1544: ; Send byte in A, escaping it if needed 1545: ; ===================================== 1546: FD0D SendByte: 1547: FD0D 81 9B CMPA #esc ; Escape character? 1548: FD0F 26 03 BNE SEND_DATA ; No, send raw 1549: FD11 16 FD14 JSR SEND_DATA ; Double escape character 1550: FD14 SEND_DATA: 1551: FD14 36 PSHA ; Save byte 1552: FD15 SEND_WAIT: 1553: FD15 B6 00CC LDAA >TxSTATUS 1554: FD18 84 80 ANDA #TxRDY ; Flag is 1 when TXDR is empty 1555: FD1A 27 F9 BEQ SEND_WAIT ; Loop until data can be sent 1556: FD1C 32 PULA ; Get byte back 1557: FD1D 7A 00CF STAA >TxDATA ; Send data 1558: FD20 3D RTS 1559: 1560: 1561: ; Send an escaped command 1562: ; ======================= 1563: FD21 SendCommand: 1564: FD21 36 PSHA ; Save command byte 1565: ; Should flush input here 1566: FD22 86 9B LDAA #esc 1567: FD24 16 FD14 JSR SEND_DATA ; Send esc prefix 1568: FD27 32 PULA 1569: FD28 BA 1001 ORAA >DMA_TYPE ; Add personality bits 1570: FD2B 20 E7 BRA SEND_DATA ; Send command byte 1571: 1572: 1573: ; Check if a byte is waiting, and read it if there 1574: ; ================================================ 1575: FD2D READ_BYTE: 1576: FD2D B6 00CC LDAA >RxSTATUS 1577: FD30 84 20 ANDA #RxRDY ; Flag is 1 when RXDR is full 1578: FD32 27 17 BEQ WAIT_EXIT ; Nothing pending, return 1579: ; ; Continue into WaitByte 1580: 1581: 1582: ; Wait for a byte, decoding escaped data 1583: ; ====================================== 1584: ; On exit, A =byte 1585: ; F =preserved 1586: ; 1587: FD34 WaitByte: 1588: FD34 39 PSHC ; Save flags 1589: FD35 WaitByteLP: 1590: FD35 16 FD4C JSR WAIT_DATA 1591: FD38 26 10 BNE WaitByteOK ; Not esc, return 1592: FD3A 16 FD4C JSR WAIT_DATA ; Get another byte 1593: FD3D 27 0B BEQ WaitByteOK ; esc,esc, return 1594: FD3F 34 PSHX 1595: FD40 35 PSHY 1596: FD41 37 PSHB ; Push all registers 1597: FD42 16 FD59 JSR WAIT_COMMAND ; Decode escaped command 1598: FD45 33 PULB 1599: FD46 31 PULY 1600: FD47 30 PULX ; Pop all registers 1601: FD48 20 EB BRA WaitByteLP 1602: FD4A WaitByteOK: 1603: FD4A 38 PULC ; Pop flags 1604: FD4B WAIT_EXIT: 1605: FD4B 3D RTS 1606: 1607: 1608: ; Wait for data 1609: ; ============= 1610: ; On exit, A =byte 1611: ; F =Z byte=esc, NZ byte<>esc 1612: ; 1613: FD4C WAIT_DATA: 1614: FD4C B6 00CC LDAA >RxSTATUS 1615: FD4F 84 20 ANDA #RxRDY 1616: FD51 27 F9 BEQ WAIT_DATA ; Loop until data present 1617: FD53 B6 00CF LDAA >RxDATA ; Fetch data 1618: FD56 81 9B CMPA #esc ; Is it esc prefix? 1619: FD58 3D RTS 1620: 1621: 1622: ; Decode escaped command 1623: ; ====================== 1624: ; On entry, A=command 1625: ; All registers can be trashed 1626: ; 1627: FD59 WAIT_COMMAND: 1628: FD59 97 TSTA 1629: FD5A 27 0B BEQ WAIT_ERROR ; esc,&00 - error 1630: FD5C 2B 30 BMI WAIT_TRANSFER ; esc,>&7F - data transfer 1631: 1632: ; esc,1..127 - read a control block 1633: ; ================================= 1634: ; This depends on MOS calls storing control block address, 1635: ; which none of them do for this CPU. 1636: ; Just read data and absorb it. 1637: ; 1638: FD5E B7 01 TFR A,B ; Move count to low byte of AB 1639: FD60 WAIT_LEN: 1640: FD60 16 FD34 JSR WaitByte ; Wait for a byte 1641: FD63 53 DECB ; Decrement count of bytes read 1642: FD64 26 FA BNE WAIT_LEN ; Loop to read all bytes 1643: FD66 3D RTS ; Return to WaitByte 1644: 1645: ; esc,&00 - error 1646: ; =============== 1647: FD67 WAIT_ERROR: 1648: FD67 CF 1100 LDS #ERRSTK ; Collapse stack 1649: FD6A CE 1040 LDX #ERRBLK ; Point to error buffer 1650: FD6D 86 3F LDA #$3F ; SWI opcode 1651: FD6F 6A 30 STAA 1,X+ ; Store BRK 1652: FD71 16 FD34 JSR WaitByte ; Get error number 1653: FD74 6A 30 STAA 1,X+ ; Store error number 1654: FD76 FIRQ_R4LP: 1655: FD76 16 FD34 JSR WaitByte ; Wait for byte of error string 1656: FD79 6A 30 STAA 1,X+ ; Store in error buffer 1657: FD7B 26 F9 BNE FIRQ_R4LP ; Loop until terminating $00 received 1658: ;;;6502 Client pauses at this point 1659: FD7D B6 1041 LDAA ERRBLK+1 1660: FD80 BA 1042 ORAA ERRBLK+2 ; Check for error 0,"" 1661: FD83 1827 FAB3 LBEQ STARTUP ; Reset all vectors and restart client 1662: FD87 CE 1041 LDX #ERRBLK+1 ; Point to error block after SWI opcode 1663: FD8A 34 PSHX ; Push error pointer onto stack 1664: FD8B 06 FFBC JMP ERRJMP ; Jump to generate error 1665: 1666: ; esc,&8n - Escape change 1667: ; ======================= 1668: FD8E WAIT_TRANSFER: 1669: FD8E 81 C0 CMPA #$C0 1670: FD90 24 2E BCC WAIT_START 1671: FD92 81 A0 CMPA #$A0 1672: FD94 24 23 BCC WAIT_END 1673: FD96 81 90 CMPA #$90 1674: FD98 24 06 BCC WAIT_EVENT 1675: FD9A 44 LSRA 1676: FD9B 46 RORA ; Move b0 into b7, b6=0 1677: FD9C 7A 1000 STAA >ESCFLG ; Store Escape flag 1678: FD9F 3D RTS 1679: 1680: ; esc,&9x - Event 1681: ; =============== 1682: FDA0 WAIT_EVENT: 1683: FDA0 16 FD34 JSR WaitByte ; Get event Y parameter 1684: FDA3 B7 01 TFR A,B 1685: FDA5 86 00 LDAA #0 1686: FDA7 B7 46 TFR D,Y 1687: FDA9 16 FD34 JSR WaitByte ; Get event X parameter 1688: FDAC B7 01 TFR A,B 1689: FDAE 86 00 LDAA #0 1690: FDB0 B7 45 TFR D,X 1691: FDB2 16 FD34 JSR WaitByte ; Get event A parameter 1692: FDB5 05 FB 1020 JMP [EVENTV,PC] ; Dispatch event 1693: 1694: ; esc,&Ax - Reserved 1695: ; ================== 1696: FDB9 WAIT_END: 1697: FDB9 81 B0 CMPA #$B0 1698: FDBB 25 8E BCS WAIT_EXIT ; &Ax - Return to WaitByte 1699: 1700: ; esc,&Bx - End transfer 1701: ; ====================== 1702: FDBD 1B 8A LEAS 10,SP ; Drop data from stack to fall 1703: ; ; out of WaitSave/WaitLoad loop 1704: ; 1705: FDBF WAIT_EXIT2: 1706: FDBF 3D RTS ; Return to WaitByte 1707: 1708: ; esc,&C0+ - Start transfer 1709: ; ========================= 1710: FDC0 WAIT_START: 1711: FDC0 36 PSHA ; Save transfer type 1712: FDC1 16 FD34 JSR WaitByte ; Get data address MSB 1713: FDC4 16 FD34 JSR WaitByte 1714: FDC7 16 FD34 JSR WaitByte ; Get data address 1715: FDCA B7 81 EXG A,B 1716: FDCC 16 FD34 JSR WaitByte ; Get data address LSB 1717: FDCF B7 81 EXG A,B ; D=data address 1718: FDD1 B7 45 TFR D,X ; X=data address 1719: FDD3 32 PULA ; Get transfer type back 1720: FDD4 81 D0 CMPA #$D0 1721: FDD6 2D 1B BLT WAIT_ADDR ; &Cx - set address 1722: FDD8 81 E0 CMPA #$E0 1723: FDDA 2D 15 BLT WAIT_CODE ; &Dx - enter code 1724: FDDC 81 F0 CMPA #$F0 1725: FDDE 24 07 BCC WAIT_SAVE ; &Fx - save data 1726: FDE0 WAIT_LOAD: 1727: FDE0 16 FD34 JSR WaitByte ; &Ex - load data 1728: FDE3 6A 30 STAA 1,X+ ; Get byte, store it 1729: FDE5 20 F9 BRA WAIT_LOAD ; Loop until terminated 1730: FDE7 WAIT_SAVE: 1731: FDE7 A6 30 LDAA 1,X+ ; Get byte 1732: FDE9 16 FD0D JSR SendByte ; Send it 1733: FDEC 16 FD2D JSR READ_BYTE ; Poll input for termination 1734: FDEF 20 F6 BRA WAIT_SAVE ; Loop until terminated 1735: FDF1 WAIT_CODE: 1736: FDF1 05 00 JMP ,X ; Jump directly to code 1737: FDF3 WAIT_ADDR: 1738: FDF3 7E 100C STX ADDRESS ; Set entry address 1739: FDF6 3D RTS 1740: 1741: 1742: ; SWI - Generate an error 1743: ; ======================= 1744: FDF7 SWI_HANDLE: 1745: FDF7 1B 87 LEAS 7,SP ; Step past stack contents 1746: FDF9 ERR_HANDLE: 1747: FDF9 30 PULX ; Pop PC to X 1748: FDFA 7E 1002 STX FAULT ; Save pointer to last error 1749: FDFD 10 00 ANDCC #$00 ; Clear all flags, enable interupts 1750: FDFF 05 FB 1022 JMP [BRKV,PC] ; Jump to current error handler 1751: 1752: 1753: ; TRAP - Trap handler 1754: ; =================== 1755: ; TRAP $FF -> OSQUIT -> $FF0C 1756: ; TRAP $FE -> OSCLI -> $FF10 1757: ; TRAP $FD -> OSBYTE -> $FF14 1758: ; TRAP $FC -> OSWORD -> $FF18 1759: ; TRAP $FB -> OSWRCH -> $FF1C 1760: ; TRAP $FA -> OSRDCH -> $FF20 1761: ; TRAP $F9 -> OSFILE -> $FF24 1762: ; TRAP $F8 -> OSARGS -> $FF28 1763: ; TRAP $F7 -> OSBGET -> $FF2C 1764: ; TRAP $F6 -> OSBPUT -> $FF30 1765: ; TRAP $F5 -> OSGBPB -> $FF34 1766: ; TRAP $F4 -> OSFIND -> $FF38 1767: ; TRAP $F3 -> MISC 1768: ; TRAP $F2 -> SYS 1769: ; TRAP $F1 -> RDINF 1770: ; TRAP $F0 -> WRINF 1771: 1772: ; SP -> CCR, AB, X, Y, RET 1773: FE03 TRAP_HANDLE: 1774: FE03 EE F3 0007 LDX [7,SP] ; Get return address 1775: FE07 E6 E3 FFFF LDAB [-1,X] ; Get TRAP number 1776: FE0B C1 F4 CMPB #$F4 1777: FE0D 25 19 BCS RTI ; <$F4, just return 1778: ; Should pass on to a further vector 1779: FE0F C8 FF EORB #$FF 1780: FE11 58 ASLB 1781: FE12 58 ASLB ; Multiply TRAP number by 4 1782: FE13 CB 0C ADDB #$0C ; A is now low byte of dispatch jump 1783: FE15 86 FF LDAA #$FF ; AB is now dispatch address 1784: FE17 16 FE29 JSR TRAP_GO ; Call the dispatch address 1785: FE1A 6C F3 0001 STD [1,SP] ; Update stacked registers with return values 1786: FE1E 6E F3 0003 STX [3,SP] 1787: FE22 6D F3 0005 STY [5,SP] 1788: FE26 32 PULA ; Drop stacked CCR 1789: FE27 39 PSHC ; Replace it with current CCR 1790: ; todo: TRAP should call MOS entry and catch any error, returning V=0 if ok, 1791: ; returning 1, D=>error if error occured. cf PDP-11, 32016 and ARM. 1792: 1793: ; Null interupt routines 1794: ; ====================== 1795: FE28 RTI: 1796: FE28 0B RTI 1797: 1798: FE29 TRAP_GO: 1799: ; SP -> RET, CCR, AB, X, Y, RET 1800: FE29 3B PSHD ; SP -> ADDR, RET, CCR, AB, X, Y, RET 1801: FE2A EC F3 0005 LDD [5,SP] ; Fetch entry AB from stack 1802: FE2E 3D RTS ; Jump to dispatch block via stack 1803: 1804: 1805: ; END of movable ROM part 1806: ; ======================= 1807: 1808: 1809: IF VECBASE > ROMSTART 1829: ENDIF 1830: 1831: ; Hardware vectors: 1832: ; VECBASE+$F2 IRQ 1833: ; VECBASE+$F4 XIRQ 1834: ; VECBASE+$F6 SWI 1835: ; VECBASE+$F8 TRAP 1836: ; VECBASE+$FA COP 1837: ; VECBASE+$FC CLOCK 1838: ; VECBASE+$FE RESET 1839: 1840: 1841: ; Vector dispatch 1842: ; =============== 1843: =0000FF00 ORG $FF00 1844: FF00 05 FB 1020 XEVENT: JMP [EVENTV,PC] ; $FF00 via $1020 1845: FF04 05 FB 1022 XBRK: JMP [BRKV,PC] ; $FF04 via $1022 1846: FF08 05 FB 1024 Xxx2: JMP [xxx2V,PC] ; $FF08 via $1024 1847: FF0C 05 FB 1026 XQUIT: JMP [QUITV,PC] ; $FF0C via $1026 TRAP $FF OS_QUIT 1848: FF10 05 FB 1028 XCLI: JMP [CLIV,PC] ; $FF10 via $1028 TRAP $FE OS_CLI 1849: FF14 05 FB 102A XBYTE: JMP [BYTEV,PC] ; $FF14 via $102A TRAP $FD OS_BYTE 1850: FF18 05 FB 102C XWORD: JMP [WORDV,PC] ; $FF18 via $102C TRAP $FC OS_WORD 1851: FF1C 05 FB 102E XWRCH: JMP [WRCHV,PC] ; $FF1C via $102E TRAP $FB OS_WRCH 1852: FF20 05 FB 1030 XRDCH: JMP [RDCHV,PC] ; $FF20 via $1030 TRAP $FA OS_RDCH 1853: FF24 05 FB 1032 XFILE: JMP [FILEV,PC] ; $FF24 via $1032 TRAP $F9 OS_FILE 1854: FF28 05 FB 1034 XARGS: JMP [ARGSV,PC] ; $FF28 via $1034 TRAP $F8 OS_ARGS 1855: FF2C 05 FB 1036 XBGet: JMP [BGETV,PC] ; $FF2C via $1036 TRAP $F7 OS_BGET 1856: FF30 05 FB 1038 XBPut: JMP [BPUTV,PC] ; $FF30 via $1038 TRAP $F6 OS_BPUT 1857: FF34 05 FB 103A XGBPB: JMP [GBPBV,PC] ; $FF34 via $103A TRAP $F5 OS_GBPB 1858: FF38 05 FB 103C XFIND: JMP [FINDV,PC] ; $FF38 via $103C TRAP $F4 OS_FIND 1859: FF3C 05 FB 103E JMP [FINDV+2,PC] ; $FF3C via $103E 1860: 1861: ; Default software vectors 1862: ; ------------------------ 1863: =0000FF40 ORG $FF40 1864: FF40 VECTORS: 1865: FF40 FAB3 FDB NULL ; $FF40 -> EVENTV 1866: FF42 F8CF FDB COM_ERR ; $FF42 -> BRKV 1867: FF44 FAB3 FDB NULL ; $FF44 -> xxx2V 1868: FF46 FFB9 FDB CLICOM ; $FF46 -> QUITV 1869: FF48 F9BA FDB CLI ; $FF48 -> CLIV 1870: FF4A FAEE FDB BYTE ; $FF4A -> BYTEV 1871: FF4C FB68 FDB WORD ; $FF4C -> WORDV 1872: FF4E FD0D FDB WRCH ; $FF4E -> WRCHV 1873: FF50 FAD8 FDB RDCH ; $FF50 -> RDCHV 1874: FF52 FC6E FDB FILE ; $FF52 -> FILEV 1875: FF54 FC13 FDB ARGS ; $FF54 -> ARGSV 1876: FF56 FC30 FDB BGet ; $FF56 -> BGETV 1877: FF58 FC3D FDB BPut ; $FF58 -> BPUTV 1878: FF5A FC9A FDB GBPB ; $FF5A -> GBPBV 1879: FF5C FC50 FDB FIND ; $FF5C -> FINDV 1880: FF5E F837 FDB WARMS ; $FF5E -> PROGRAM 1881: 1882: 1883: ; Tube system defaults and MOS entry block 1884: ; ========================================= 1885: =0000FF80 ORG $FF80 1886: ; Use same addresses as Z80 1887: FF80 00 FCB 0 ; $FF80 ; Escape flag 1888: FF81 00 FCB 0 ; $FF81 ; TempA/Client personality 1889: FF82 F816 FDB BANNER ; $FF82 ; Last error message 1890: FF84 F8CF DEFERR: FDB COM_ERR ; $FF84 ; Default error handler 1891: FF86 F816 FDB BANNER ; $FF86 ; Command line tail 1892: FF88 1200 DEFBOT: FDB RAMSTART ; $FF88 ; Bottom of user memory 1893: FF8A 4000 DEFTOP: FDB RAMEND ; $FF8A ; Top of user memory 1894: FF8C 0000 FDB 0 ; $FF8C ; Tube execution address 1895: FF8E 0000 FDB 0 ; $FF8E ; Tube transfer address 1896: FF90 F837 FDB WARMS ; $FF90 ; Program entry address 1897: FF92 0000 FDB 0 ; $FF92 ; Address high word 1898: FF94 00 FCB 0 ; $FF94 ; Transfer completion flag 1899: 1900: ; BBC MOS entry points 1901: ; -------------------- 1902: =0000FF95 ORG $FF95 1903: FF95 06 FAB3 JMP >NULL ; &FF95 ; Service 1904: FF98 06 F83A OSCOLD: JMP >RESET ; &FF98 ; Cold 1905: FF9B 06 F96F PRSTRING: JMP >SEND_TXT ; &FF9B ; Print ASCIIZ text at X 1906: FF9E 06 FCB $06 ; &FF9E ; Force a JMP opcode 1907: FF9F FFEE FDB OSWRCH 1908: FFA1 06 F978 SCANHEX: JMP >RD_HEX ; &FFA1 ; ReadHex 1909: FFA4 06 FAB3 DISKACC: JMP >NULL ; &FFA4 ; DiskAccess 1910: FFA7 06 FAB3 DISKCCP: JMP >NULL ; &FFA7 1911: FFAA 06 F94A PRHEX: JMP >PR_HEX ; &FFAA ; Print A as 8-bit hex 1912: FFAD 06 F942 PR2HEX: JMP >PR_2HEX ; &FFAD ; Print X as 16-bit hex 1913: FFB0 06 FAB3 USERINT: JMP >NULL ; &FFB0 ; Pass on FIRQs if not Tube FIRQ 1914: FFB3 06 F95F PRTEXT: JMP >PR_TEXT ; &FFB3 ; Print inline ASCIIZ text 1915: FFB6 06 FAB3 JMP >NULL ; &FFB6 ; VecDef/PrntC 1916: FFB9 CLICOM: 1917: FFB9 06 F892 OSQUIT: JMP >CLILOOP ; &FFB9 ; Quit current process, enter Supervisor 1918: FFBC ERRJMP: 1919: FFBC 06 FDF9 OSERROR: JMP >ERR_HANDLE; &FFBC ; Generate an error 1920: FFBF INITERR: 1921: FFBF 06 F8FC OSINIT: JMP >ERR_INIT ; &FFBF ; Initialise default error handler 1922: FFC2 06 FAB3 DISKRST: JMP >NULL ; &FFC2 ; DiskReset 1923: FFC5 06 FAB3 JMP >NULL ; &FFC5 ; Deprecated 1924: FFC8 06 FAB3 JMP >NULL ; &FFC8 1925: FFCB 06 FB0C JMP >FSC ; &FFCB 1926: 1927: ; MOS file entry points 1928: ; --------------------- 1929: FFCE 06 FF38 OSFIND: JMP >XFIND ; $FFCE 1930: FFD1 06 FF34 OSGBPB: JMP >XGBPB ; $FFD1 1931: FFD4 06 FF30 OSBPUT: JMP >XBPut ; $FFD4 1932: FFD7 06 FF2C OSBGET: JMP >XBGet ; $FFD7 1933: FFDA 06 FF28 OSARGS: JMP >XARGS ; $FFDA 1934: FFDD 06 FF24 OSFILE: JMP >XFILE ; $FFDD 1935: 1936: ; MOS character entry points 1937: ; -------------------------- 1938: FFE0 06 FF20 OSRDCH: JMP >XRDCH ; $FFE0 1939: FFE3 81 0D OSASCI: CMPA #13 ; $FFE3 1940: FFE5 26 07 BNE OSWRCH 1941: FFE7 86 0A OSNEWL: LDA #10 ; $FFE7 1942: FFE9 16 FFEE JSR >OSWRCH 1943: FFEC 86 0D OSWRCR: LDA #13 ; $FFEC 1944: FFEE 06 FF1C OSWRCH: JMP >XWRCH ; $FFEE 1945: 1946: ; MOS system entry points 1947: ; ----------------------- 1948: FFF1 06 FF18 OSWORD: JMP >XWORD ; $FFF1 1949: FFF4 06 FF14 OSBYTE: JMP >XBYTE ; $FFF4 1950: FFF7 06 FF10 OS_CLI: JMP >XCLI ; $FFF7 1951: 1952: ; Standard RESET locations (These don't remap even if Vector Base changed) 1953: ; ======================================================================== 1954: FFFA FE28 L_FFFA: FDB RTI ; $FFFA - COP failure reset 1955: FFFC FE28 L_FFFC: FDB RTI ; $FFFC - COP monitor fail reset 1956: FFFE F83A L_FFFE: FDB RESET ; $FFFE - Reset vector 1957: Symbols: address *0000100c args *0000fc13 argsv *00001034 banner *0000f816 bget *0000fc30 bgetv *00001036 bigendian *00000001 bput *0000fc3d bputv *00001038 brkv *00001022 build *00000002 byte *0000faee byte_cmd *0000fb27 byte_done *0000fae1 byte_hi *0000fb1b byte_hi1 *0000fb25 byte_wait *0000fb11 bytev *0000102a cli *0000f9ba cli_check *0000fa64 cli_done *0000fab3 cli_dot *0000fa0b cli_go *0000f9d0 cli_go1 *0000fa3c cli_go2 *0000fa3e cli_loop0 *0000f9e7 cli_loop2 *0000f9ef cli_lp1 *0000f9d0 cli_match *0000fa11 cli_match2 *0000fa17 cli_next *0000fa01 cli_table *0000f9c3 cli_tube *0000fa56 cli_wait1 *0000fa5f clibuf *00001060 clicom *0000ffb9 cliend *00001100 cliloop *0000f892 cliloop2 *0000f8a2 clistk *00001060 cliv *00001028 close *0000fc63 cmd_help *0000fa48 cmd_run *0000fa4d cmd_slash *0000fa4b com_brkv *0000f8f6 com_err *0000f8cf com_esc *0000f8c1 com_init *0000f8ea defbot *0000ff88 deftop *0000ff8a dma_type *00001001 err_handle *0000fdf9 err_init *0000f8fc err_init2 *0000f905 err_not6812 *0000fac0 err_notcode *0000fac0 errblk *00001040 errjmp *0000ffbc errstk *00001100 esc *0000009b escflg *00001000 escoff *00000000 eventv *00001020 exec_chk *0000fabc exec_enter *0000faa0 exec_jump *0000fab4 exec_lp *0000fa75 execute2 *0000fa6a fault *00001002 file *0000fc6e filev *00001032 find *0000fc50 findv *0000103c firq_r4lp *0000fd76 fsc *0000fb0c gbpb *0000fc9a gbpbv *0000103a inecho *0000f91a io_ivbr *00000121 kbdtst *0000f92e local_cmds *00000003 local_go *00000001 local_help *00000001 local_run *00000001 lptr *00001006 lreal *0000f919 mem82 *0000fb57 mem83 *0000fb59 mem_init *0000f8df membot *00001008 memtop *0000100a msci0cr2_re *00000004 msci0cr2_te *00000008 msci0sr1_rdrf *00000020 msci0sr1_tdre *00000080 null *0000fab3 os_cli *0000fff7 osasci *0000ffe3 osbyte *0000fff4 osnewl *0000ffe7 osrdch *0000ffe0 osword *0000fff1 oswrch *0000ffee pr_2hex *0000f942 pr_digit *0000f95a pr_help *0000f96c pr_hex *0000f94a pr_nybble *0000f952 pr_text *0000f95f prdat *0000f923 prend *0000f919 program *00001010 prompt *0000f8b5 prtst *0000f920 quitv *00001026 ramend *00004000 ramstart *00001200 rd_done *0000fbe5 rd_hex *0000f978 rd_hexadd *0000f98f rd_hexdone *0000f9b5 rd_hexlp *0000f97b rd_str *0000fbda rdch *0000fad8 rdchv *00001030 rdline *0000fbbb read_byte *0000fd2d reset *0000f83a romstart *0000f800 rti *0000fe28 rxctrl *000000cb rxdata *000000cf rxinit *00000004 rxrdy *00000020 rxstatus *000000cc scanhex *0000ffa1 sci0cr2 *000000cb sci0drl *000000cf sci0sr1 *000000cc send_blklp *0000fcce send_block *0000fccc send_data *0000fd14 send_end *0000f96b send_str *0000fcc2 send_txt *0000f96f send_wait *0000fd15 send_wdlp *0000fce4 send_words *0000fce2 sendbyte *0000fd0d sendbyteb *0000fd0b sendbytey *0000fd09 sendcommand *0000fd21 skipspc *0000f9af skipword *0000f9a7 startup *0000f83a swi_handle *0000fdf7 transfer *0000100e trap_go *0000fe29 trap_handle *0000fe03 txctrl *000000cb txdata *000000cf txinit *00000008 txrdy *00000080 txstatus *000000cc vecbase *00001100 vecloop1 *0000f84c vecloop2 *0000f859 vectors *0000ff40 version *00000105 wait_addr *0000fdf3 wait_blklp *0000fcd9 wait_block *0000fcd7 wait_char *0000fae7 wait_code *0000fdf1 wait_command *0000fd59 wait_data *0000fd4c wait_end *0000fdb9 wait_error *0000fd67 wait_event *0000fda0 wait_exit *0000fd4b wait_len *0000fd60 wait_load *0000fde0 wait_save *0000fde7 wait_start *0000fdc0 wait_transfer *0000fd8e wait_wdlp *0000fcf7 wait_words *0000fcf5 waitbyte *0000fd34 waitbytelp *0000fd35 waitbyteok *0000fd4a warms *0000f837 word *0000fb68 word_norx *0000fbb8 word_notx *0000fb98 word_recv *0000fba9 word_recv1 *0000fbab word_send *0000fb86 word_send1 *0000fb88 wordrx *0000fbff wordtx *0000fbeb wordv *0000102c worksp *00001000 wrch *0000fd0d wrchv *0000102e xargs *0000ff28 xbget *0000ff2c xbput *0000ff30 xbyte *0000ff14 xcli *0000ff10 xfile *0000ff24 xfind *0000ff38 xgbpb *0000ff34 xrdch *0000ff20 xword *0000ff18 xwrch *0000ff1c xxx2v *00001024