6809 Monitor
Diane Bruce
db at db.net
Tue Oct 2 14:46:21 CDT 2018
On Tue, Oct 02, 2018 at 12:24:47PM -0700, tim lindner via cctalk wrote:
> Does anyone have source to a 6809 monitor program?
>
> I'm looking for something I can make work in a CoCo.
>
> Functionality I'm looking for is something that will let me read and
> write to memory.
I have a copy of psymon.s if you want it.
>
> --
> --
> tim lindner
>
> "Proper User Policy apparently means Simon Says."
--
- db at FreeBSD.org db at db.net http://artemis.db.net/~db
-------------- next part --------------
*************************************************
* psymon version 1.00
*
* copyright (c) 1979 percom data company, inc.
* percom data company, inc. grants unrestricted
* royalty-free license for the use of this
* program provided the user clearly acknowledges
* its origin.
*
* while this monitor is very simple, its true
* power lies in its extensibility and in the
* tools that it provides for other software
* to use. This operating system is dedicated
* to harold mauch and his legendary 512 byte
* operating system.
*
* psymon Much modified version 4.00
*
* commands:
* m <address> - memory examine/change
* o <address> - memory change (output to I/O port no read)
* g <address> - go to address
* r <register> - register examine/change
* l <address> - load program from tape, optional load address
* s <start> <end> - save program to tape
* b <address> - set/list breakpoints
* u <address> - unset breakpoints
* e start end dest - Burn EEPROM at dest with data from start, end
*
* other comments to be added here later
*
* Extensive modifications for GPE
* - acia changed to 68681 DUART, I know strange to use a 68k part on 6809
* - removed 'z' command
* - moved I/O,ram,rom addresses as needed
* - removed special code for special dcb's for punch since
* debug port will be used for all uploads/downloads and need the bytes.
* (There is lots of ROM on target system, but I am unwilling to attempt
* relocating monitor since that would entail working out padding,
* see my next note)
* - Original programmer did not make use of 'lbra' and 'lbsr' instructions
* for reaching code ie. used 'stepping stone' technique, makes me wonder
* if this was originally a 6800 monitor?
* - Added 'o' command
* - DCB is obviously "Device Control Block" but no reference to that
* in "FLEX" or "OS9" so I have no idea where this came from.
*
* DB. Feb 19 1990
* DB. Feb 25 1990
*************************************************
* system address constants (GPE version)
RUNSYS equ 1 ; if bottom bit is set on INPORT, Run 2nd ROM
rom1 equ 0F800H ; base add of psymon rom
rom2 equ 0C000H ; base add of extension rom
ram equ 0000 ; base add of ram
termnl equ 8000H ; system terminal acia
* ascii character constants
cr equ 0dH ; carriage return
lf equ 0AH ; line feed
sp equ 20H ; space
* acia control configurations
MREG equ 0 ; Mode register (MR1,MR2)
SREG equ 1 ; Status register
CSREG equ 1 ; Clock select register
CREG equ 2 ; Command register
RHR equ 3 ; Receiver holding register
THR equ 3 ; Transmitter holding register
OPCR equ 0DH ; Output port conf reg.
INPORT equ 0DH ; Same as above, read input port
SETOP equ 0EH
RESETOP equ 0FH
* yes, THR is the same as RHR
*
* Bit masks for SREG (status register)
*
RXRDY equ 01H ; RXRDY equ %00000001
TXRDY equ 04H ; TXRDY equ %00000100
RXBRK equ 80H ; RXBRK equ %10000000
FRAME equ 40H ; FRAME equ %01000000
PARER equ 20H ; PARER equ %00100000
OVRUN equ 10H ; OVRUN equ %00010000
*
* Commands for CREG
*
RESETRX equ 20H ; RESETRX equ %00100000
RESETTX equ 30H ; RESETTX equ %00110000
RESETMR equ 10H ; RESETMR equ %00010000
ENBTX equ 04H ; ENBTX equ %00000100 Enable Transmitter
ENBRX equ 01H ; ENBRX equ %00000001 Enable Receiver
DISTX equ 08H ; DISTX equ %00001000 Disable Transmitter
DISRX equ 02H ; DISRX equ %00000010 Disable Receiver
ENABLE equ 05H ; ENABLE equ %00000101 Enable both RX and TX
*
* Commands for MR
* Whenever MR is pointing to MR1 and then is written to, MR flips to MR2.
*
RXRTSNO equ 0
RXRTSYES equ 80H ; RXRTSYES equ %10000000
RXINTRDY equ 0
RXINTFUL equ 40H ; RXINTFUL equ %01000000
*
* MR1 equ RXRTSNO|RXINTRDY|ERRORCHAR|NOPARITY|BITS8
MR1 equ 13H ; MR1 equ %00010011
*MR2 equ NORMAL|TXRTSNO|CTSCTLNO|STOP1
MR2 equ 07H ; MR2 equ %00000111
*
* Commands for CSREG
*
B9600 equ 0BBH ; B9600 equ %10111011
*
BURNRAM equ 1400H ; where EEPROM routine goes
*
* psymon dcb offsets
dcblnk equ 0 ; ptr to next dcb in chain
dcbdid equ 2 ; ascii 2 char device id
dcbdvr equ 4 ; device driver address
dcbioa equ 6 ; device io address
dcberr equ 8 ; error status code
dcbext equ 9 ; dcb extension byte count
dcbapp equ 10 ; driver dcb appendage
* psymon dcb function codes
readfn equ 01H ; read
writfn equ 02H ; write
statfn equ 04H ; read status
initfn equ 08H ; init the 68681
baudfn equ 10H ; set baud rate (for 68681 only)
* psymon ram definitions (mp-a2 version)
org ram
* psymon internal stack (& register) space
rmb 800H ; stack space
stack:
regc: rmb 1 ; condition code register
rega: rmb 1 ; a register
regb: rmb 1 ; b register
regd: rmb 1 ; dp register
regx: rmb 2 ; x register
regy: rmb 2 ; y register
regu: rmb 2 ; u register
regp: rmb 2 ; pc
* psymon breakpoint table
bptabl: rmb 30 ; space for 10 breakpoints
bptend:
* psymon work areas
memptr: rmb 2 ; pointer for M command
usrtbl: rmb 2 ; address of user command table
comand: rmb 1 ; command char storage
cksum: rmb 1 ; load & save checksum
begadd: rmb 2 ; begin address for save
endadd: rmb 2 ; end address for save
offsetflg: rmb 1
offset: rmb 2
stkptr: rmb 2 ; contents of stack pointer
* the psymon console dcb
condcb: rmb 10 ; no extensions
* psymon dcb pointers
dcbchn: rmb 2 ; base of dcb chain
cidcb: rmb 2 ; console input dcb
cedcb: rmb 2 ; console echo dcb
codcb: rmb 2 ; console output dcb
tpdcb: rmb 2 ; cassette tape dcb
* psymon vectors
swi3v: rmb 2 ; software interrupt 3
swi2v: rmb 2 ; software interrupt 2
firqv: rmb 2 ; fast interrupt request
irqv: rmb 2 ; interrupt request
swiv: rmb 2 ; software interrupt
nmiv: rmb 2 ; non-maskable interrupt
restrt: rmb 2 ; re-entry into psymon
* psymon rom coding
org 0F800H ; rom1
*************************************************
* psymon initialization
*************************************************
init: ld s #stack ; set up stack pointer
tfr s x ; point x at stack
init1: clr ,x+ ; clear a byte
cmp x #condcb+2 ; all fields clear?
bne init1 ; loop if not
lea y ramint,pcr ; point to ram data
init2: ld d ,y++ ; move 2 bytes
st d ,x++
cmp x #restrt+2 ; end of ram?
bne init2 ; loop if not
ld x #condcb ; point to dcb
ld b #initfn
lbsr reqio ; reset acia
ld x #termnl
ld a INPORT,x
bit a #RUNSYS ; Run the system ROM?
bne monent
ld a rom2 ; check for second rom
cmp a #'V' ; is there a version code there?
bne monent ; branch if not
jmp rom2+4 ; else call second rom
*************************************************
* psymon user entry
*************************************************
monent: ld s #stack ; set stack pointer
st s stkptr
*************************************************
* get command
*************************************************
getcmd: lea x prompt,pcr ; display prompt
lbsr pstrng
lbsr inchr ; input command character
cmp a #'a'
blo getupper
and a #0DFH ; convert to upper
getupper: bsr lookup ; look it up
bne getcmd ; loop if not found
lbsr outsp ; output a space
jsr [0,x] ; call command routine
bra getcmd ; go back for more
prompt: fcb cr,lf
str "cmd"
fcb '?'+80H ; end of string
*************************************************
* look up command in table
*************************************************
lookup: ld y #comand ; point y at command
st a ,y ; save command character
ld x usrtbl ; get user table address
beq look1 ; branch if none
bsr search ; else search user table
beq serchx ; go if found
look1: lea x cmdtbl,pcr ; search internal table
*************************************************
* general table search
*
* entry requirements: x - points to table
* y - points to item
* first byte of table must
* contain item length
* last byte must be ff
*
* exit conditions: c - z set if found, clear
* if not found
* x - points to address of routine
* for match
* a,b - changed
*
*************************************************
search: ld b ,x+ ; get item length
serch1: bsr compar ; compare current item
abx ; advance to next item
beq serchx ; exit if match
lea x 2,x ; step over address
tst ,x ; end of table?
bpl serch1 ; loop if not
serchx: rts
*************************************************
* general string compare
*
* entry requirements: x - address of string 1
* y - address of string 2
* b - length of strings
*
* exit conditions: c - set per compare 1:2
* b,x,y - unchanged
* a - changed
*
*************************************************
compar: pshs b x y ; save registers
comp1: ld a ,x+ ; get next char
cmp a ,y+ ; compare it
bne comp2 ; exit if unmatched
dec b ; decrement loop count
bne comp1
comp2: puls b x y pc ; restore registers & return
*************************************************
* load program from tape, with optional load address
*************************************************
tload: clr offsetflg
lbsr gethex ; get optional offset value
beq tload0
st x offset
ld a #1
st a offsetflg
tload0: ld x cedcb ; save default echo mode
pshs x
clr a ; set d to 0
clr b
st d cedcb ; set no echo
bsr load ; load the tape
puls x ; restore echo mode
st x cedcb
tst cksum ; any errors?
beq loadx ; branch if not
*************************************************
* display error indicator of '?'
*************************************************
error: ld a #'?' ; display error indicator
lbra outchr
*************************************************
* load program in hex format
*
* entry requirements: none
*
* exit conditions: all registers changed
* cksum non-zero if error
*
*************************************************
load: tfr s y ; mark stack for error recovery
load1: lbsr inchr ; get a character
load2: cmp a #'S' ; start of record?
bne load1 ; loop if not
lbsr inchr ; get another character
cmp a #'9' ; end of load?
beq loadx ; branch if yes
cmp a #'1' ; start of record?
bne load2 ; loop if not
clr cksum ; init checksum
bsr inbyte ; read length
sub a #2 ; adjust it
tfr a b ; save in b
bsr inbyte ; get address hi
st a ,--s ; save on stack
bsr inbyte ; get address lo
st a 1,s ; put on stack
puls x ; address now in x
tst offsetflg
beq load3
exg d x
sub d offset ; subtract from given load address
exg d x
load3: bsr inbyte ; read a byte
dec b ; decrement count
beq load4 ; branch if done
st a ,x ; store byte
cmp a ,x+ ; verify good store
bne load5 ; branch if error
bra load3
load4: inc cksum ; check checksum
beq load1 ; loop if good
load5: ld a #0ffH ; set error flag
st a cksum
tfr y s ; restore stack
loadx: rts
*************************************************
* input a byte
*************************************************
inbyte: bsr inhex ; get hex digit
beq load4 ; branch if error
asl a ; shift to ms half
asl a
asl a
asl a
pshs a ; save digit
bsr inhex ; get another digit
beq load4 ; branch if error
add a ,s ; combine halves
st a ,s ; save on stack
add a cksum ; add to checksum
st a cksum
puls a pc ; get result & return
*************************************************
* get hex number from console
*
* entry requirements: none
*
* exit conditions: a - last char input
* b - hex digit count
* x - hex number
* c - set according to b
*
*************************************************
gethex: clr b ; init digit count & result
ld x #0
gethx1: bsr inhex ; get a digit
beq gethx2 ; go if not hex
exg d x ; old result to a,b
asl b ; shift left 1 digit
rol a
asl b
rol a
asl b
rol a
asl b
rol a
exg d x ; replace result
lea x a,x ; add in new digit
inc b ; add to digit count
bra gethx1 ; loop for more
gethx2: tst b ; set/reset z flag
rts
*************************************************
* get hex digit from console
*
* entry requirements: none
*
* exit conditions: a - hex digit or non-hex
* c - z flag set if a not hex
* all other regs preserved
*
*************************************************
inhex: bsr inchr ; get a character
cmp a #'a'
blo inhexupper
and a #0DFH ; convert to upper
inhexupper: pshs a ; save it
sub a #30H ; convert to binary
bmi inhex2 ; branch if not numeric
cmp a #09H ; greater than 9?
bls inhex1 ; branch if not
sub a #07H ; else convert letter
inhex1: cmp a #0fH ; greater than 15?
bls inhex3 ; branch if not
inhex2: ld a ,s ; get original char back
inhex3: cmp a ,s+ ; set/reset z flag
rts
*************************************************
* console input routine
*
* entry requirements: none
*
* exit conditions: a - character with parity removed
* all other regs except c preserved
*
*************************************************
inchr: pshs b x ; save registers
ld x cidcb ; point to input dcb
ld b #readfn ; set up for read
bsr reqio ; read a character
and a #7fH ; remove parity
ld x cedcb ; point to echo dcb
pshs a ; save character
bne outch1 ; branch if echo
puls a b x pc ; else restore regs & return
*************************************************
* console output routine
*
* entry requirements: a - character to be output
*
* exit conditions: all registers preserved except c
*
*************************************************
outchr: pshs a b x ; save registers
ld x codcb ; point to output dcb
outch1: ld b #writfn ; set function
bsr reqio ; output the character
puls a b x pc ; restore regs & return
*************************************************
* perform io requests
*
* entry requirements: a - driver parameter
* b - function code
* x - dcb address
*
* exit conditions: a - driver result
* all other regs except c preserved
*
*************************************************
reqio: pshs b x y ; save registers
jsr [dcbdvr,x] ; call driver
puls b x y pc ; restore regs & return
*************************************************
* display double byte
*
* entry requirements: a,b - double byte to print
*
* exit conditions: all regs preserved but c
*
*************************************************
dspdby: bsr outhex ; display a as 2 hex digits
exg a b
bsr dspsby ; display b as 2 hex digits
exg a b ; restore a & b
rts
*************************************************
* display a byte and space
*
* entry requirements: a - byte to be displayed
*
* exit conditions: all regs but c preserved
*
*************************************************
dspsby: bsr outhex ; display byte in a
*************************************************
* output a space to the console *
* *
* entry requirements: none *
* *
* exit conditions: all registers reserved *
* except c *
* *
*************************************************
outsp: pshs a ; save a register
ld a #sp ; output a space
*************************************************
* output character, restore a, & return *
*************************************************
outchx: bsr outchr ; display character
puls a pc ; restore & exit
*************************************************
* display a register as 2 hex digits *
* *
* entry requirements: a - byte to display *
* *
* exit conditions: all registers preserved *
* except c *
* *
*************************************************
outhex: pshs a ; save the byte
lsr a ; get ms byte
lsr a
lsr a
lsr a
bsr outdig ; display it
ld a ,s ; get ls digit
bsr outdig ; display it
puls a pc ; restore a & return
*************************************************
* display a hex digit *
*************************************************
outdig: and a #0fH ; mask off digit
add a #30H ; convert to ascii
cmp a #39H ; bigger than 9?
bls outchr ; go if not
add a #07H ; convert to letter
bra outchr ; print and exit
*************************************************
* print a string to the console *
* *
* entry conditions: x - points to string *
* last byte has bit 7 on *
* *
* exit conditions: x - points 1 byte past end *
* a,c - changed *
* *
*************************************************
pstrng: ld a ,x ; get a character
and a #7fH ; mask off
bsr outchr ; display it
tst ,x+ ; was it last?
bpl pstrng ; loop if not
rts
*************************************************
* print cr/lf on console *
* *
* entry requirements: none *
* *
* exit conditions: all registers preserved *
* except c *
* *
**************************************************
crlf: pshs a ; save a register
ld a #cr ; output cr
bsr outchr
ld a #lf ; output lf & exit
bra outchx
**************************************************
* save program on tape *
**************************************************
tsave: lbsr gethex ; get start address
beq tsave2 ; go if none
st x begadd ; save start
lbsr gethex ; get end address
bne tsave1 ; go if entered
ld x begadd ; duplicate address
inc b ; set address indicator
tsave1: st x endadd ; save end
tsave2: pshs a ; save terminator
tst b ; any address entered?
beq tsave3 ; go if not
bsr save ; save the program
tsave3: puls a ; get terminator
cmp a #cr ; was it return?
bne tsave4 ; go if not
ld b #'9' ; output s9 record
bsr outsn
tsave4: rts
*************************************************
* save a program in hex *
* *
* entry requirements: save addresses are in *
* begaddr & endaddr *
* *
* exit conditions: all registers change *
* *
*************************************************
save: ld x begadd ; point at first byte
save1: ld b #'1' ; begin new s1 record
bsr outsn
clr cksum ; init checksum
ld d endadd ; calculate bytes to save
pshs x
sub d ,s++
tst a ; greater than 255?
bne save2 ; go if yes
cmp b #16 ; less than full record?
blo save3 ; go if yes
save2: ld b #15 ; set full record size
save3: inc b ; correct record size
tfr b a ; output record size
add a #3 ; adjust for address,count
bsr outbyt
pshs x ; address to stack
puls a ; output address high
bsr outbyt
puls a ; output address low
bsr outbyt
save4: ld a ,x+ ; save a data byte
bsr outbyt
dec b ; loop until 0
bne save4
ld a cksum ; get checksum
com a ; compliment it because it was good
bsr outbyt ; output it
lea y -1,x ;
cmp y endadd
bne save1 ; loop if not
rts
************************************************
* output byte as hex and add to checksum *
************************************************
outbyt: lbsr outhex ; output byte as hex
add a cksum ; add to checksum
st a cksum
rts
************************************************
* output 'S' tape record headers *
************************************************
outsn: lbsr crlf ; begin new line
ld a #'S' ; output 'S' header
lbsr outchr
tfr b a ; record type to a
lbra outchr
************************************************
* memory examine and change *
************************************************
memec: lbsr gethex ; get address
bne memec1 ; go if good
ld x memptr ; use previous
memec1: st x memptr ; update ram pointer
lbsr crlf ; begin new line
tfr x d ; display address
lbsr dspdby
ld a ,x+ ; get contents
lbsr dspsby ; display them
tfr x y ; save address in y
lbsr gethex ; get change data
exg d x ; save delim, get new
beq memec2 ; go if no change
st b -1,y ; update memory
cmp b -1,y ; verify good store
beq memec2 ; go if good store
lbsr error ; display error
memec2: tfr x d ; get delimiter in a
tfr y x ; get next address in x
cmp a #cr ; end of update?
beq memec3 ; go if yes
cmp a #':' ; backing up?
bne memec1 ; loop if not
lea x ,--x ; back up 2
bra memec1 ; continue
memec3: rts
************************************************
* memory change *
************************************************
change: lbsr gethex ; get address
bne change1 ; go if good
ld x memptr ; use previous
change1: st x memptr ; update ram pointer
lbsr crlf ; begin new line
tfr x d ; display address
lbsr dspdby
lea x 1,x
tfr x y ; save address in y
lbsr gethex ; get change data
exg d x ; save delim, get new
beq change2 ; go if no change
st b -1,y ; update memory
change2: tfr x d ; get delimiter in a
tfr y x ; get next address in x
cmp a #cr ; end of update?
beq change3 ; go if yes
cmp a #':' ; backing up?
bne change1 ; loop if not
lea x ,--x ; back up 2
bra change1 ; continue
change3: rts
****
* eeprom
* Rather specialized code to burn EEPROMs
*
****
eeprom:
lea x burnrom,pcr ; Copy ROM EEPROM code to RAM
ld y #BURNRAM ; Where RAM portion will be
ld b #2AH ; endburnrom-burnrom+1
prom0: ld a ,x+ ; copy code to ram
st a ,y+
dec b
bne prom0
*
lbsr gethex ; read hex # for Source object
beq promerror ; if none given this is error
st x begadd
lbsr gethex ; get second hex #
tfr x d
sub d begadd ; ensure is above start address
blo promerror
tfr d y ; save # bytes to copy
lea y 1,y ; bump # bytes to copy
lbsr gethex ; get destination address
beq promerror ; none given, give up.
tfr x u
ld x begadd
jsr BURNRAM
promerror: rts
*
* This code is copied into RAM
* it is called with
* x -> source address of data to be written to eprom
* u -> destination eprom address
* y -> number of bytes to write
*
burnrom: pshs x
ld x #termnl
ld a #0
st a OPCR,x ; set all bits for output
ld a #18H ; %11000 ; clear bits 3 + 4 to enable ROM for writes
st a SETOP,x
puls x
burnnext: ld b ,x+
st b ,u
burnpoll: ld a ,u ; keep looping
pshs b ; until dest byte = source byte
cmp a ,s+
bne burnpoll
lea u 1,u ; bump dest.
lea y -1,y ; bump down byte counter
bne burnnext
ld x #termnl
ld a #18H ; %11000 ; reset bits 3 + 4 to disable ROM for writes
st a RESETOP,x
rts
endburnrom:
************************************************
* go to address *
************************************************
go: ld s stkptr ; set up stack
lbsr gethex ; get target address
beq go1 ; go if none
st x regp
go1: ld x regp
st x 10,s ; store in pc on stack
ld a regc
or a #80H ; set 'e' flag in cc
st a ,s
ld a rega ; set 'a' reg
st a 1,s
ld a regb
st a 2,s
ld a regd
st a 3,s
ld d regx
st d 4,s
ld d regy
st d 6,s
ld d regu
st d 8,s
intret: rti ; load registers and go
***********************************************
* breakpoint (software interrupt) trap *
************************************************
brkpnt: ld x 10,s ; get program counter
lea x -1,x ; decrement by 1
st x 10,s ; replace on stack
ld b #0FFH ; $ff flag for single removal
lbsr rembk ; remove breakpoint
************************************************
* interrupt (hardware/software) trap *
************************************************
trap: st s stkptr ; save stack pointer
lbsr crlf ; begin new line
bsr regdmp ; dump registers
lbra getcmd ; get next command
************************************************
* register examine and change *
************************************************
regec: lbsr inchr ; get register to examine
cmp a #'a'
blo regupper
and a #0DFH ; convert to upper
regupper: lbsr crlf ; begin new line
clr b ; clear offset count
lea x regids,pcr ; point to register id string
regec1: cmp a b,x ; check register name
beq regec2 ; go if found
inc b ; advance count
cmp b #11 ; end of list?
bls regec1 ; loop if not
bra regdmp ; bad id - dump all
regec2: pshs b ; save offset
bsr rdump ; display the reg & contents
lbsr gethex ; get new value
puls b ; restore offset
beq regecx ; go if no change
lea y b,y ; point to reg on stack
cmp b #3 ; single byte reg?
tfr x d ; get new data in a,b
bls regec3 ; go if single
st a ,y+ ; store ms byte
regec3: st b ,y ; store ls byte
regecx: rts
regids: str "CABDXXYYUUPP"
************************************************
* complete register dump *
************************************************
regdmp: lea x regids,pcr ; point to id string
clr b ; clear offset counter
rgdmp1: ld a b,x ; get reg name
bsr rdump ; display it
inc b ; bump to next reg
cmp b #11 ; all printed?
bls rgdmp1 ; loop if not
ld a #'S' ; display stack id
bsr dspid
ld y #stkptr-12 ; y+b=>stkptr
bra rdump1
************************************************
* display register contents *
************************************************
rdump: bsr dspid ; display register id
ld y stkptr ; point y at stack
cmp b #3 ; single byte reg?
bls rdump2 ; go if yes
rdump1: ld a b,y ; display ms byte
lbsr outhex
inc b ; advance offset
rdump2: ld a b,y ; display a byte
lbra dspsby
************************************************
* display register id *
************************************************
dspid: lbsr outchr ; display reg name
ld a #'=' ; display '='
lbra outchr
************************************************
* set a breakpoint *
************************************************
setbk: lbsr gethex ; get address
beq dspbk ; go if none entered
bsr initbp ; point y at bp table
setbk1: ld d ,y ; empty slot?
beq setbk2 ; go if yes
bsr nextbp ; advance to next slot
bne setbk1 ; loop if not end
bra dspbk ; exit
setbk2: st x ,y ; save address
beq dspbk ; go if address = 0
ld a ,x ; get contents
st a 2,y ; save in table
ld a #3fH ; swi op code
st a ,x ; set break
************************************************
* display all breakpoints *
************************************************
dspbk: lbsr crlf ; begin new line
bsr initbp ; point y at bp table
dspbk1: ld d ,y ; get address of bp
beq dspbk2 ; go if inactive
lbsr dspdby ; display address
dspbk2: bsr nextbp ; advance pointer
bne dspbk1 ; loop if not end
rts
************************************************
* initialize breakpoint table pointer *
************************************************
initbp: ld y #bptabl ; point y at bp table
rts
************************************************
* advance breakpoint table pointer *
************************************************
nextbp: lea y 3,y ; advance to next entry
cmp y #bptend ; check for end of table
rts
************************************************
* unset a breakpoint *
************************************************
unsbk: lbsr gethex ; get address
************************************************
* remove one or more breakpoints *
************************************************
rembk: bsr initbp ; point y at bp table
rembk1: tst b ; remove all?
beq rembk2 ; go if yes
cmp x ,y ; find address?
beq unset ; go if yes
bra rembk3 ; loop if no
rembk2: bsr unset ; unset it
rembk3: bsr nextbp ; advance pointer
bne rembk1 ; loop if not end
rts
*************************************************
* remove a breakpoint *
*************************************************
unset: ld x ,y ; get address of bp
beq unset1 ; go if inactive
ld a 2,y ; get contents
st a ,x ; replace bp
clr 0,y ; mark bp inactive
clr 1,y
unset1: rts
*************************************************
* terminal driver (acia) *
*************************************************
termdr: clr dcberr,x ; no errors possible
ld x dcbioa,x ; get i/o address
lsr b ; read function?
bcs termrd ; go if yes
lsr b ; write functions?
bcs termwt ; go if yes
lsr b ; status function?
bcs termst ; go if yes
lsr b ; init function?
bcc term1 ; go if not
ld b #RESETRX
st b CREG,x
ld b #RESETTX
st b CREG,x
ld b #RESETMR
st b CREG,x
ld b #MR1
st b MREG,x ; This store flips MREG to MR2
ld b #MR2
st b MREG,x
ld b #B9600
st b CSREG,x
ld b #ENABLE ; enable RX and TX
st b CREG,x
term1: rts
termrd: ld b SREG,x ; get status
bit b #RXRDY
beq termrd ; loop if no input
ld a RHR,x ; get character
rts
termwt: ld b SREG,x ; get status
bit b #TXRDY ; ready for output?
beq termwt ; loop if not
st a THR,x ; output character
rts
termst: ld a SREG,x ; get status
and a #0FH ; $F mask off ready bits
rts
************************************************
* psymon command table *
************************************************
cmdtbl: fcb 1 ; item length
fcb 'M' ; memory examine/change
fdb memec
fcb 'O' ; memory change
fdb change
fcb 'E' ; EEPROM burn!
fdb eeprom
fcb 'G' ; goto address
fdb go
fcb 'L' ; program load
fdb tload
fcb 'S' ; program save
fdb tsave
fcb 'R' ; register examine/change
fdb regec
fcb 'B' ; set/print breakpoints
fdb setbk
fcb 'U' ; unset breakpoints
fdb unsbk
fcb 0ffH ; end sentinel
************************************************
* ram initialization data *
************************************************
ramint: str "cn" ; console dcb id
fdb termdr ; console driver
fdb termnl ; console I/O address
fdb 0 ; error status, ext
fdb condcb ; dcb chain pointer
fdb condcb ; dcb pointers
fdb condcb
fdb condcb
fdb condcb
fdb trap ; interrupt vectors
fdb trap
fdb intret
fdb trap
fdb brkpnt
fdb trap
fdb monent
************************************************
* interrupt handlers *
************************************************
hwswi3: jmp [swi3v] ; software interrupt 3
hwswi2: jmp [swi2v] ; software interrupt 2
firq: jmp [firqv] ; fast interrupt request
hwirq: jmp [irqv] ; interrupt request
hwswi: jmp [swiv] ; software interrupt
nmi: jmp [nmiv] ; non-maskable interrupt
************************************************
* software vectors *
************************************************
org 0FFE0H ; $ffe0
fdb dspsby ; display single byte
fdb dspdby ; display double byte
fdb gethex ; get hex number from console
fdb pstrng ; print string to console
fdb inchr ; input character
fdb outchr ; output character
fdb reqio ; perform I/O request
fdb monent ; monitor re-entry
************************************************
* hardware vectors *
************************************************
fdb init ; reserved by motorola
fdb hwswi3 ; software interrupt 3
fdb hwswi2 ; software interrupt 2
fdb firq ; fast interruupt request
fdb hwirq ; interrupt request
fdb hwswi ; software interrupt
fdb nmi ; non-maskable interrupt
fdb init ; restart
end
More information about the cctalk
mailing list