home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / simtel / sigm / vols200 / vol250 / cpm68k.txt < prev    next >
Text File  |  1986-02-11  |  10KB  |  420 lines
  1. ; An article relating to the following code appeared in the Vol 1 No 5
  2. ; issue of Micro/Systems Journal and is presented here with the per-
  3. ; mission of the publisher. The code alone should be sufficient to
  4. ; use the program.  However, back copies of the article are available from
  5. ; Micro/Systems Journal, Box 1192, Mountainside, NJ 07092.
  6. \p\#12
  7.                             LISTING 1
  8.  
  9.  
  10. ********************************************************************
  11. *                                                                  *
  12. *     A MONITOR FOR THE MOTOROLA 68000 MICROPROCESSOR TO ENABLE    *
  13. *   LOADING PROGRAMS, CHANGING DATA VALUES, AND BEGIN EXECUTION    *
  14. *     AT ANY MEMORY LOCATION.   68000 ASSEMBLY LANGUAGE LISTING.   *
  15. *                                                                  *
  16. *   Copyright (C) 1985, Jack L. Calaway.  All rights reserved.     *
  17. *                                                                  *
  18. ********************************************************************
  19. *
  20.  
  21. * EQUATES
  22. *
  23. DATA    EQU.L    $0FF0010        * CONSOLE UART DATA
  24. STATUS    EQU.L    $0FF0011        * CONSOLE UART STATUS
  25. SDATA    EQU.L    $0FF0020        * DOWN LOAD UART DATA
  26. SSTAT    EQU.L    $0FF0021        * DOWN LOAD UART STATUS
  27. STACK    EQU.L    $0000300        * STACK BELOW CP/M-68K
  28.  
  29.     ORG    $0FD0000
  30.  
  31. *
  32. * START UP CODE FOR GODBOUT CPU
  33. *   ON HARDWARE RESET, PROMS ON CPU BOARD ARE GLOBAL
  34. *
  35.  
  36.     DC.L    $8            * FIRST INSTRUCTION ADDRESS
  37.     DC.L    STACK            * INITAL STACK VALUE
  38.     JSR.L    INIT            * SWITCH PROMS TO REAL ADDRESS
  39.  
  40. *
  41. * DO INITIALIZING TASKS
  42. *
  43.  
  44. INIT:
  45.     MOVEA.L    #STACK,A7        * SET STACK POINTER
  46.  
  47.     BSR    CRLF            * OUTPUT A CR/LF PAIR
  48.     MOVEQ    #$04D,D0        * THEN LOAD AND OUTPUT   
  49.     BSR    OUTCH                   * THE MONITOR SIGN-ON
  50.     MOVEQ    #$036,D0        * MESSAGE: M68K
  51.     BSR    OUTCH
  52.     MOVEQ    #$038,D0        
  53.     BSR    OUTCH
  54.     MOVEQ    #$04B,D0    
  55.     BSR    OUTCH
  56.  
  57. *
  58. * BEGIN PROCESSING COMMANDS.  THE PROGRAM 
  59. * RETURNS TO THIS POINT BETWEEN COMMANDS
  60. *è
  61. START:
  62.     MOVEA.L    #STACK,A7        * RESET STACK POINTER
  63.     BSR    CRLF            * NEXT LINE
  64.     MOVEQ    #$02E,D0        * OUTPUT THE MONITOR
  65.     BSR    OUTCH                   * PROMPT CHARACTER: '.'
  66.     BSR    INCH            * GET A COMMAND
  67.     CMPI.B    #$0D,D0
  68.     BEQ.S    START            * IGNORE CARRIAGE RETURN
  69.     BSR    OUTCH            * ECHO THE CHARACTER
  70.     CMPI.B    #$053,D0        * 'S' = SUBSTITUTE
  71.     BNE.S    START1            * NOT 'S', TRY NEXT COMMAND
  72.     BSR    SUBST            * ON 'S' GO TO SUBSTITUTE
  73.     BSR    CRLF                    * ROUTINE.
  74.     BRA.S    START                   * BACK TO START
  75.  
  76. START1:
  77.     CMPI.B    #$047,D0        * IF COMMAND IS A 'G',
  78.     BNE.S    START2                  * JUMP TO GOTO AND BEGIN
  79.     BSR    GOTO            * EXECUTION
  80.     BSR    CRLF
  81.     BRA.S    START
  82.  
  83. START2:
  84.     CMPI.B    #$04C,D0        * ON 'L' COMMAND, JUMP
  85.     BNE.S    START                   * TO THE LOAD ROUTINE
  86.     BSR    LOAD
  87.     BSR    CRLF
  88.     BRA.S    START                   * NONE OF THE ABOVE
  89.  
  90.  
  91. **********************************************************************
  92. *                                                                    *
  93. *                           GOTO                                     *
  94. *   THIS ROUTINE WILL JUMP TO INPUT ADDRESS AND BEGIN EXECUTION      *
  95. *                                                                    *
  96. **********************************************************************
  97.  
  98.  
  99. GOTO:
  100.     BSR    INADR            * GET THE ADDRESS
  101.     JMP    (A0)            * JUMP TO IT
  102.  
  103. *********************************************************************
  104. *                                                                   *
  105. *                           LOAD                                    *
  106. *   THIS ROUTINE WILL DOWN LOAD AN S-FILE INTO THE 68000 MEMORY     *
  107. *                                                                   *
  108. *********************************************************************
  109.  
  110.  
  111. LOAD:
  112.     BSR    CRLF            * WE ARE HERE
  113.  
  114. *è* FIND THE S-RECORD HEADER
  115. *
  116.  
  117. LOAD1:
  118.     CLR.B    D4            * D4=LENGTH FLAG
  119.     BSR    GCHR            * GET CHARACTER
  120.     CMPI.B    #$053,D0        * IS IT AN 'S'?
  121.     BNE.S    LOAD1            * IF NOT, TRY AGAIN 
  122.     BSR    GCHR
  123.     CMPI.B    #$030,D0        * CHARACTER EQUALS ZERO
  124.     BEQ.S    LOAD1            * TRY AGAIN IF SO
  125.     CMPI.B    #$039,D0        * CHECK FOR FILE END, (9)
  126.     BEQ.S    LOADX            * DONE IF SO
  127.     CMPI.B    #$032,D0        * 4, OR 6 BYTES OF ADDRESS
  128.     BEQ.S    LOAD3
  129.     ADDQ.B    #$001,D4        * PUT 1 IN LENGTH FLAG
  130.  
  131. *
  132. * GET BYTE COUNT
  133. *
  134.  
  135. LOAD3:
  136.     BSR    GHEX            * GET RECORD LENGTH
  137.     MOVE.B    D0,D2            * SAVE IN COUNTER
  138.     SUBI.B    #$03,D2            * ADJUST COUNT, AND TEST
  139.     TST.B    D4            * AND TEST FOR LONG OR SHORT ADDRESS
  140.     BNE.S    LOAD4            * SHORT
  141.     SUBQ.B    #$001,D2        * LONG, SUBTRACT ONE MORE
  142.  
  143. *
  144. * GET LOAD ADDRESS OF RECORD
  145. *
  146.  
  147. LOAD4:
  148.     BSR    GADR            
  149.  
  150. *
  151. * NOW GET FILE DATA
  152. *
  153.  
  154. LOAD2:
  155.     BSR    GHEX            * GET BYTE OF DATA
  156.     MOVE.B    D0,(A0)+        * STORE IN MEMORY 
  157.     SUBQ.B    #$001,D2        * DECREMENT COUNT
  158.     BNE.S    LOAD2            * CONTINUE
  159.     BRA.S    LOAD1            * SKIP CHECKSUM
  160.  
  161.  
  162. LOADX:
  163.     RTS                * RETURN FOR NEW COMMAND
  164.  
  165.  
  166. *
  167. * GET TWO ASCII CHARACTERS FROM SERIAL PORT
  168. * AND CONVERT TO ONE BINARY BYTEè* RETURNS THE DATA IN THE D0 REGISTER
  169. * D1 IS CLOBBERED
  170. *
  171.  
  172. GHEX:
  173.     CLR.B    D1            * CLEAR TEMPORARY
  174.     JSR    CAHEX            * GET HIGH NIBBLE
  175.     ASL.B    #$4,D1                  * SHIFT TEMPORARY LEFT
  176.     OR.B    D0,D1                   * 'OR' WITH D1
  177.     JSR    CAHEX            * GET LOW NIBBLE
  178.     ASL.B    #$4,D1                  * POSITION HIGH NIBBLE
  179.     OR    D1,D0                   * COMBINE LOW AND HIGH
  180.     ANDI.L    #$0000FF,D0
  181.     RTS
  182.  
  183. *
  184. * CONVERT ASCII TO HEX
  185. *
  186.  
  187. CAHEX:
  188.     BSR    GCHR            * GET CHARACTER
  189.     SUBI.B    #$030,D0        * REMOVE ASCII
  190.     CMPI.B    #$00A,D0        * A-F?
  191.     BLT.S    CAHEX1            * NO
  192.     SUBI.B    #$007,D0        * YES, SUBTRACT 7
  193.  
  194. CAHEX1:
  195.     RTS
  196.  
  197. *
  198. * GET LOAD ADDRESS FROM SERIAL PORT
  199. * RETURNS WITH THE ADDRESS IN REGISTER A0
  200. * WORKS JUST LIKE GHEX, BUT DOES 2 OR 3 BYTES
  201. * RATHER THAN JUST ONE
  202. *
  203.  
  204. GADR:
  205.     CLR.L    D3            * TEMPORARY=0
  206.     BSR    GHEX
  207.     ASL.L    #$08,D3            * MAKE ROOM FOR NIBBLE
  208.     OR.L    D0,D3
  209.     BSR    GHEX
  210.     ASL.L    #$08,D3
  211.     OR.L    D0,D3
  212.     TST.B    D4            * LONG OR SHORT ADDRESS?
  213.     BNE.S    GADRX            * SHORT
  214.     BSR    GHEX
  215.     ASL.L    #$08,D3            * LAST BYTE
  216.     OR.L    D0,D3
  217.  
  218. GADRX:
  219.     MOVE.L    D3,A0
  220.     RTS
  221.  
  222. *è* GET SERIAL CHAR
  223. *
  224.  
  225. GCHR:
  226.     ANDI.B    #$02,SSTAT        * ANY WAITING?
  227.     BEQ.S    GCHR            * NO
  228.     MOVE.B    SDATA,D0        * GET IT
  229.     ANDI.B    #$07F,D0        * STRIP HIGH BIT
  230.     RTS
  231.  
  232. *******************************************************************
  233. *                                                                 *
  234. *                        SUBSTITUTE                               *
  235. *   THIS ROUTINE WILL SUBSTITUTE DATA AT ANY MEMORY LOCATION      *
  236. *                                                                 *
  237. *******************************************************************
  238.  
  239.  
  240. SUBST:
  241.     BSR    INADR            * GET ADDRESS
  242.     BSR    CRLF            * CLEAN UP
  243.  
  244. SUBST1:
  245.     BSR    CRLF            * FOR NEW LINE
  246.     BSR    PADR            * PRINT ADDRESS
  247.     MOVEQ    #$020,D0        * SPACE
  248.     BSR    OUTCH
  249.     MOVE.B    (A0),D0
  250.     BSR    PHEX            * PRINT CURRENT DATA
  251.     MOVEQ    #$020,D0
  252.     BSR    OUTCH            * SPACE
  253.     BSR    INCH            * GET KEYBOARD CHAR
  254.     CMPI.B    #$0D,D0            * NEXT ADDRESS?
  255.     BEQ.S    SUBST4            * YES
  256.     BSR    OUTCH            * ECHO
  257.     CMPI.B    #$02E,D0        * PERIOD EQUAL DONE?
  258.     BEQ.S    SUBSTX            * YES, EXIT
  259.  
  260. *
  261. * INPUT NEW BYTE OF DATA 
  262. *
  263.     CLR.B    D1            * CLEAR REGISTER
  264.  
  265. *
  266. * CONVERT 1 OR 2 ASCII CHARACTER
  267. * TO BINARY BYTE
  268. *
  269.  
  270. SUBST2:
  271.     SUBI.B    #$030,D0        * STRIP ASCII
  272.     CMPI.B    #$0A,D0
  273.     BLT.S    SUBST3
  274.     SUBI.B    #$07,D0
  275. SUBST3:
  276.     ANDI.L    #$0000000F,D0è    ASL.L    #$04,D1
  277.     OR.L    D0,D1
  278.     BSR    INCH            * NEXT
  279.     CMPI.B    #$0D,D0            * DONE?
  280.     BEQ.S    SUBST5            * YES
  281.     BSR    OUTCH            * NO
  282.     BRA.S    SUBST2
  283. SUBST5:
  284.     MOVE.B    D1,(A0)            * STORE NEW DATA
  285. SUBST4:
  286.     ADDQ.L    #$001,A0        * NEXT MEMORY ADDRESS
  287.     BRA.S    SUBST1
  288. SUBSTX:
  289.     RTS                * FINI
  290.  
  291. *
  292. * INPUT ADDRESS FROM CONSLOE
  293. * EXIT WITH A0=ADDRESS
  294. *
  295.  
  296. INADR:
  297.     CLR.L    D1            * TEMPORAY = 0
  298. INADR1:
  299.     BSR.S    INCH            * GET ASCII CHARACTER
  300.     CMPI.B    #$0D,D0            * CR=END?
  301.     BEQ.S    INADRX            * YES
  302.     BSR    OUTCH            * SHOW
  303.     SUBI.B    #$030,D0        * STRIP ASCII
  304.     CMPI.B    #$0A,D0            * 0-9
  305.     BLT.S    INADR2
  306.     SUBI.B    #$07,D0            * FOR A-F
  307. INADR2:
  308.     ANDI.L    #$0000000F,D0        * CLEAR
  309.     ASL.L    #$04,D1            * POSITION HIGH NIBBLE
  310.     OR.L    D0,D1            * MAKE ONE BYTE FROM TWO NIBBLES
  311.     BRA.S    INADR1
  312. INADRX:
  313.     MOVE.L    D1,A0            * ADDRESS TO ADDRESS REGISTER
  314.     RTS
  315.  
  316. *
  317. * PRINT ADDRESS
  318. * (A0)=DATA
  319. *
  320.  
  321. PADR:
  322.     MOVEQ    #$04,D2            * PRINT FOUR BYTES
  323.     MOVE.L    A0,D1            * COPY ADDRESS
  324. PADR1:
  325.     ROL.L    #$08,D1            * SHIFT BYTES
  326.     MOVE.B    D1,D0
  327.     ANDI.B    #$0FF,D0
  328.     BSR.S    PHEX            * PRINT BYTE
  329.     SUBQ.B    #$001,D2        * COUNTER -1
  330.     BNE.S    PADR1            * MORE TO PRINTè    RTS
  331.  
  332. *
  333. * PRINT HEX
  334. * D0=DATA
  335. *
  336.  
  337. PHEX:
  338.     MOVE.B    D0,-(SP)        * SAVE LOW NIBBLE
  339.     ROR.B    #$04,D0            * PRINT HIGH NIBBLE FIRST
  340.     BSR.S    PHEX1
  341.     MOVE.B    (SP)+,D0        * GET LOW NIBBLE BACK
  342. PHEX1:
  343.     ANDI.B    #$0F,D0            * CLEAR LOW NIBBLE
  344.     CMP.B    #$0A,D0            * A-F?
  345.     BLT.S    PHEX2            * NO
  346.     ADD.B    #$07,D0            * YES - CORRECT
  347. PHEX2:
  348.     ADD.B    #$030,D0        * MAKE ASCII
  349.     BSR.S    OUTCH
  350.     RTS
  351.  
  352. *
  353. * CRLF TO CONSOLE
  354. *
  355.  
  356. CRLF:
  357.     MOVEQ    #$0D,D0            * CR
  358.     BSR.S    OUTCH
  359.     MOVEQ    #$0A,D0            * LF
  360.  
  361. *
  362. * PRINT CHAR IN REG D0 TO CONSOLE
  363. *
  364.  
  365. OUTCH:
  366.     ANDI.B    #$01,STATUS        * BUSY?
  367.     BEQ.S    OUTCH            * YES
  368.     MOVE.B    D0,DATA            * SEND
  369.     RTS
  370.  
  371. *
  372. * INPUT CHAR FROM CONSOLE
  373. *
  374.  
  375. INCH:
  376.     ANDI.B    #$02,STATUS        * WAITING
  377.     BEQ.S    INCH            * NO
  378.     MOVE.B    DATA,D0            * GET IT
  379.     ANDI.B    #$07F,D0        * CLEAR HIGH BIT
  380.     RTS
  381.  
  382. *********************************************************************
  383. *                                                                   *
  384. *           T H A T ' S   A L L  F O L K S                          *è*                                                                   *
  385. *********************************************************************
  386.  
  387.     END
  388.  
  389. -----------------------------------------------------------------
  390.  
  391.                             LISTING 2
  392.  
  393.  
  394. ****************************************************************
  395. *                                                              *
  396. *                        BTEST                                 *
  397. *      A PROGRAM TO TEST THE BIOS CHANGES IN 68000 SYSTEM.     *
  398. *             *  WRITTEN BY J. L. CALAWAY, 03/17/85            *
  399. *                                                              *
  400. ****************************************************************
  401.  
  402. *
  403. * ENTER THIS TEST PROGRAM WITH A CALL AFTER FIRST PATCHING THE
  404. * REQUIRED VALUES IN REGISTERS D0, D1, AND D2 WITH THE MONITOR.
  405. *
  406.  
  407.     ORG.L    $002000    
  408.  
  409.     MOVE.L    #$00000000,D0        * MOVE PATCHED DATA
  410.     MOVE.L  #$00000000,D1        * TO REGISTERS
  411.     MOVE.L  #$00000000,D2        
  412.  
  413.     TRAP    #3            * READ CONSOLE CHAR IN
  414.  
  415.     MOVE.L    D0,RESULT        * RETURN FROM TRAP WITH
  416.     RTS                * DATA IN 'RESULT' REGISTER
  417.                                         * D0; SAVE IN MEMORY LOCATION
  418. RESULT: DC.L    $0
  419.  
  420.     END