home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / develop / hc11dev / talkers / talker51.txt < prev    next >
Text File  |  1995-02-27  |  12KB  |  238 lines
  1. ************************ TALKER51.TXT 9/8/89 *******************************
  2. *   Written by R.Soja, Motorola, East Kilbride                             *
  3. *   Motorola Copyright 1989                                                *
  4. *   MCU resident, Interrupt driven Communication routines for HC11         *
  5. *   monitor. Provides low level memory and stack read/write operations.    *
  6. *   Also provides a mechanism for breakpoint handling.                     *
  7. *   Works with Host user interface program PCBUG11.EXE and a 65C51 ACIA to *
  8. *   communicate through the Host's RS232 serial port.                      *
  9. *                                                                          *
  10. *   The communication protocol consists of a series of bytes which         *
  11. *   depend on the type of the first (Command) Byte.                        *
  12. *   Five different commands are supported:                                 *
  13. *                                                                          *
  14. * 1/ MEMORY READ: (Command Byte=$01)                                       *
  15. *    Data stream:                                                          *
  16. *    $01,Count Byte,High Addr Byte,Low Addr Byte,Data Byte 1..Byte N       *
  17. *                                                                          *
  18. *    Where Count Byte=N, and if N=0 then 256 Data bytes are transferred    *
  19. *    from target MCU to host.                                              *
  20. *                                                                          *
  21. * 2/ MEMORY WRITE: (Command Byte=$41)                                      *
  22. *    Data stream:                                                          *
  23. *    $41,Count Byte,High Addr Byte,Low Addr Byte,Data Byte 1..Byte N       *
  24. *                                                                          *
  25. *    Where Count Byte=N, and if N=0 then 256 Data bytes are transferred    *
  26. *    from host to target MCU.                                              *
  27. *                                                                          *
  28. * 3/ STACK READ: (Command Byte=$81)                                        *
  29. *    Data stream:                                                          *
  30. *    $81,SPH,SPL,CCR,ACCB,ACCA,IXH,IXL,IYH,IYL,PCH,PCL                     *
  31. *                                                                          *
  32. *    All register values are transferred from MCU to host.                 *
  33. *                                                                          *
  34. * 4/ STACK WRITE: (Command Byte=$C1)                                       *
  35. *    Data stream:                                                          *
  36. *    $C1,SPH,SPL,CCR,ACCB,ACCA,IXH,IXL,IYH,IYL,PCH,PCL                     *
  37. *                                                                          *
  38. *    All register values are transferred from host to MCU.                 *
  39. *                                                                          *
  40. * 5/ BREAKPOINT ACKNOWLEDGE: (Command Byte=$B5)                            *
  41. *    Data stream:                                                          *
  42. *    $B5,BPH,BPL,CCR,ACCB,ACCA,IXH,IXL,IYH,IYL,PCH,PCL                     *
  43. *                                                                          *
  44. *    BPH:BPL is the address following the breakpoint.                      *
  45. *    All register values are transferred from MCU to host.                 *
  46. *    Breakpoints are inserted by replacing a single byte at the required   *
  47. *    address with the SWI instruction. The Talker code includes a SWI      *
  48. *    handler which returns the code byte $A5 to the host.                  *
  49. *                                                                          *
  50. * Note: The Command Byte,Count Byte, High and Low Address Bytes are always *
  51. *       transmitted from the host to the MCU.                              *
  52. *       During memory reads, the data bytes are transmitted from the MCU   *
  53. *       to the host.                                                       *
  54. *       During memory writes, the data bytes are transmitted from the host *
  55. *       to the MCU.                                                        *
  56. *       Count Byte,High Addr Byte,Low Addr Byte,SPH,SPL,BPH,BPL are        *
  57. *       transferred without handshake.                                     *
  58. *       All other bytes are transferred using a software echo handshake.   *
  59. *       The ACIA receiver routine (INACIA) incorporates RS232 break        *
  60. *       detection. This allows any data transfer to be aborted by the host.*
  61. *       The memory write routine (TWRITMEM) incorporates a data polling    *
  62. *       algorithm which allows PCBUG11 to transparently write to 2864,     *
  63. *       38C32 or similar EEPROMs. The algorithm is of course compatible    *
  64. *       with standard RAMs. A timeout is included in the event of a memory *
  65. *       or bus failure.                                                    *
  66. *       Other timeouts are built in for other reasons. See comments in the *
  67. *       source code for details on these.                                  *
  68. *                                                                          *
  69. * CONSTANTS
  70. TALKBASE  equ $6000
  71. TALKVECT  equ $FFF4       Start address of vectors used by TALKER51
  72. ACIA      equ $9000
  73. BRKCODE   equ $4A         Break point signal code to host.
  74. BRKACK    equ $B5         Break point acknowledge code from host.
  75. *
  76. * ACIA MASKS
  77. TDRE      equ $10
  78. RDRF      equ $08
  79. FE        equ $02
  80. *
  81. * PROGRAM
  82.           org TALKBASE
  83. *
  84. TALKSTART EQU *
  85.           LDS #$1FF
  86.           LDD #$C91E    Init ACIA to 9600 baud, 8 bit, no parity, Rx intr.
  87.           STD ACIA+2    Note: Control reg set up for 1.843MHz xtal.
  88. *
  89. USERSTART EQU *         This is entry point of user defined reset.
  90.           TPA           XIRQ must be enabled (Clear X bit in CCR)
  91.           ANDA #$BF
  92.           TAP
  93. IDLE      JMP IDLE      Now hang around for interruption from host.
  94. * A RESET from host changes above jump destination to start of user code.
  95. *
  96. XIRQSRV   EQU *
  97.           LDAA ACIA+1   If ACIA has generated interrupt, then
  98.           BMI TXIRQ     Talker code processes received data
  99.           JMP >TXIRQEX
  100. * Above 3 bytes are replaced by JMP USERXIRQ instruction from host monitor, if
  101. * user specified XIRQ vector is detected during download of user code.
  102. *
  103. XIRQUJMP  EQU *-2       Label equates to JMP operand.
  104. *
  105. TXIRQ     EQU *
  106.           LDAA ACIA     Read command byte, & echo it as acknowledge
  107.           BSR OUTACIA   to host.
  108.           BMI INH1      If command bit 7 set, then process inherent command
  109.           BSR INACIA    else read byte count from host into ACCB.(0=256)
  110.           XGDX          Save command and byte count.
  111.           BSR INACIA    Read high address byte
  112.           TBA           into ACCA
  113.           BSR INACIA    then low address byte into ACCB
  114.           XGDX          Restore command in ACCA,count in ACCB,address in X
  115.           CMPA #$01
  116.           BNE TXIRQ1    If command is memory read, then
  117. *
  118. TREADMEM  EQU *         REPEAT
  119.           LDAA ,X       read required address
  120.           BSR OUTACIA   send it to host
  121.           TBA           (save byte count)
  122.           BSR INACIA    and wait for acknowledge
  123.           TAB           (restore byte count)
  124.           INX           Increment address
  125.           DECB          Decrement byte count
  126.           BNE TREADMEM  UNTIL all done
  127.           RTI           and return to idle loop or user code.
  128. *
  129. TXIRQ1    EQU *
  130.           CMPA #$41
  131.           BNE TXIRQEX   If command is memory write then
  132. *
  133.           TBA           move byte count to ACCA
  134. TWRITMEM  EQU *         REPEAT
  135.           BSR INACIA    Read next byte from host into ACCB,
  136.           STAB ,X       and store at required address.
  137.           LDY #20000/14 Set up timeout count of ~10mS
  138. *
  139. WAITPOLL  CMPB ,X       Wait until read back data matches written data
  140.           BEQ WAITEND
  141.           DEY           or timeout reached,
  142.           BNE WAITPOLL
  143.           BRA USERSTART in which case, restart without reloading DSP.
  144. *
  145. WAITEND   LDAB ,X       Read stored byte and
  146.           STAB ACIA     echo it back to host,
  147.           INX
  148.           DECA          Decrement byte count
  149.           BNE TWRITMEM  UNTIL all done
  150. *
  151.           LDY #4000/7   Wait ~2mS to permit PCBUG11 to enable write protect
  152. TXWAITEX  DEY
  153.           BNE TXWAITEX
  154. TXIRQEX   RTI           and return
  155. *
  156. INACIA    EQU *
  157.           LDAB ACIA+1
  158.           BITB #FE      If break detected then
  159.           BEQ INACIA1   clean up stack and
  160.           LDS #$1FF     restart from user start,
  161.           BRA USERSTART
  162. *
  163. INACIA1   ANDB #RDRF    else if new data received from host
  164.           BEQ INACIA
  165.           LDAB ACIA     then read it
  166.           RTS           and return with data in ACCB
  167. *
  168. OUTACIA   EQU *         Only register Y modified.
  169.           XGDY          Enter with data to send in ACCA, saved in Y
  170. OUTACIA1  LDAA ACIA+1
  171.           ANDA #TDRE
  172.           BEQ OUTACIA1
  173.           XGDY          Restore ACCA
  174.           LDY #$180
  175. OUTDELAY  DEY           Wait until transmission complete (@ 9600 baud)
  176.           BNE OUTDELAY  (to fix spurious loss of transmitted character!)
  177.           STAA ACIA     Important - Updates CCR!
  178.           RTS
  179. *
  180. INH1      EQU *
  181.           CMPA #$81     If command is read MCU registers then
  182.           BNE INH2
  183. *
  184. INH1A     TSX           Move stack pointer to X
  185.           XGDX          then to ACCD
  186.           BSR OUTACIA   send stack pointer to host (high byte first)
  187.           TBA
  188.           BSR OUTACIA   then low byte
  189.           TSX           Restore X (=stack pointer)
  190.           LDAB #9       then return 9 bytes on stack
  191.           BRA TREADMEM  i.e. CCR,ACCB,ACCA,IXH,IXL,IYH,IYL,PCH,PCL
  192. *
  193. INH2      EQU *
  194.           CMPA #$C1     If command is write MCU registers then
  195.           BNE SWISRV1
  196. *
  197.           BSR INACIA    get stack pointer from host (High byte first)
  198.           TBA
  199.           BSR INACIA
  200.           XGDX          Move to X reg
  201.           TXS           and copy to stack pointer
  202.           LDAA #9       Then put next 9 bytes from host on to stack
  203.           BRA TWRITMEM
  204. *
  205. SWISRV    EQU *         Breakpoints generated by host-placed SWI instruction.
  206.           LDAA #BRKCODE Force host to process breakpoints
  207.           BSR OUTACIA   by sending it the break signal
  208. SWIIDLE   BRA SWIIDLE   then wait for response from host. (Ibit=1,Xbit=0)
  209. *
  210. SWISRV1   EQU *
  211.           CMPA #BRKACK  If host has acknowledged breakpoint state then
  212.           BNE TXIRQEX
  213.           TSX           move stack pointer to SWI stack frame and
  214.           LDAB #9
  215.           ABX
  216.           TXS
  217.           LDD 7,X       Send user code breakpoint return address to host
  218.           BSR OUTACIA   (high byte first)
  219.           TBA
  220.           BSR OUTACIA   (low byte next)
  221.           LDD #IDLE     force idle loop on return from breakpoint processing
  222.           STD 7,X
  223.           BRA INH1A     but first return all MCU registers to host
  224. *
  225. ILLOPSRV  equ *
  226.           STOP
  227.           BRA ILLOPSRV
  228. *
  229.           org TALKVECT
  230.           FDB XIRQSRV
  231.           FDB TXIRQEX   SWI (Changed by Break and Trace monitor commands)
  232.           FDB ILLOPSRV
  233.           FDB TXIRQEX   COP Software fail (Unused)
  234.           FDB TXIRQEX   COP Clock Monitor fail (Reassigned by PCBUG11 Reset)
  235.           FDB TALKSTART
  236. *
  237.           END
  238.