home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / LANGUAGES / xlate.lzh / test2.68 < prev    next >
Text File  |  1994-08-10  |  20KB  |  341 lines
  1. * TRANSLATION CARRIED OUT IN 68020 MODE VIA TAB 
  2.             ttl subroutines * ttl Subroutines
  3.             pag         *                    PAG
  4. **************************************************************
  5. ***     txenbla         enable transmit interrupt to async ***
  6. **************************************************************
  7.  
  8. txenbla     move.b      xstata(a6),d1        * LDB XSTATA check to see if interrupt already on.
  9.             bmi.s       txenbla1             * BMI TXENBLA1 branch if so.
  10.             move.b      #$01,d1              * LDB #$01 set interrupt flag to first interrupt.
  11.             move.b      d1,xstata(a6)        * STB XSTATA store new flag value
  12.  
  13. txenbla1    move.b      comreg(a6),d1        * LDB COMREG load usart command retuster
  14.             and.b       #$f3,d1              * ANDB #$F3 strip off unused bits.
  15.             or.b        #$04,d1              * ORB #$04 set uart to transmit.
  16.             move.b      d1,comreg(a6)        * STB COMREG
  17.             rts                              * RTS RETURN
  18.  
  19. **************************************************************
  20. ***     rxrsetu         break sync & reset usart receiver  *** 
  21. **************************************************************
  22.  
  23. rxrsetu     move.b      #$0f,d0              * LDA #$0F break sync, reset reciever.
  24.             move.b      d0,contu(a6)         * STA CONTU store in usart control register.
  25.             move.b      #$26,d0              * LDA #$26 enable reciever and reciever interrupt.
  26.             move.b      d0,contu(a6)         * STA CONTU store in usart control register.
  27.             rts                              * RTS RETURN
  28.  
  29. **************************************************************
  30. ***     rxstrpu         set usart receiver not strip syncs ***
  31. **************************************************************
  32.  
  33. rxstrpu     move.b      #$22,d0              * LDA #$22 set usart to not strip syncs.
  34.             move.b      d0,contu(a6)         * STA CONTU store in usart control register.
  35.             rts                              * RTS RETURN
  36.  
  37.  
  38. **************************************************************
  39. ***     txrsetu          reset usart transmitter           ***
  40. **************************************************************
  41.  
  42. txrsetu     move.b      #$0f,d0              * LDA #$0F reset usart transmiter
  43.             move.b      d0,contu(a6)         * STA CONTU store in part.
  44.             rts                              * RTS RETRUN
  45.  
  46.  
  47. **************************************************************
  48. ***     txerrenu         set usart rcv error interrupt     ***
  49. **************************************************************
  50.  
  51. txerrenu    move.w      #$490c,d2            * LDD #$490C set error interrupt enable.   
  52.             move.w      d2,contu(a6)         * STD CONTU store in usart.
  53.             move.w      #$09ec,d2            * LDD #$09EC
  54.             move.w      d2,contu(a6)         * STD CONTU reset transmit interrupt enable.
  55.             rts                              * RTS RETURN
  56.  
  57.             pag         *                    PAG
  58. *****************************************************
  59. ***   r t s h i g h   rtshigh switching routine   ***
  60. *****************************************************
  61.  
  62. rtshigh     move.b      latch_hl(a6),d0      * LDA LATCH.HL load current latch settings.
  63.  
  64. rtsh00      and.b       #$fe,d0              * ANDA #$FE set dcd high for transmition of text to host.
  65.             move.b      d0,latch_hl(a6)      * STA LATCH.HL save latch settings in ram.
  66.             move.b      d0,latch(a6)         * STA LATCH set hardware latch.
  67.  
  68. rtsh5u      move.w      #$0b6c,d2            * LDD #$0B6C reset pointers.
  69.             move.w      d2,contu(a6)         * STD CONTU point to transmit register.
  70.             move.w      #$4b0c,d2            * LDD #$4B0C reset all sorts of stuff.
  71.             move.w      d2,contu(a6)         * STD CONTU store in usart.
  72.  
  73.             move.b      #$04,d0              * LDA #$04 load number of sync characters
  74.             move.b      d0,sync_cnt(a6)      * STA SYNC.CNT store for interrupt to handle.
  75.  
  76.             move.w      #$cbff,d2            * LDD #$CBFF preload sync character.
  77.             move.w      d2,contu(a6)         * STD CONTU store in usart.
  78.  
  79. rtsh7u      move.b      #$01,d0              * LDA #$01 set transmit state on interrupt.
  80.             move.b      d0,xmt_mode(a6)      * STA XMT.MODE store in indicator.
  81.             move.b      #$d9,d0              * LDA #$D9 enable usart to transmit.
  82.             move.b      d0,contu(a6)         * STA CONTU store character in part.
  83.             rts                              * RTS
  84.  
  85.  
  86.  
  87. *******************************************************************
  88. ***     rtslow          drop rts signals and reset transmiter   ***
  89. *******************************************************************
  90.  
  91. rtslow      move.b      latch_hl(a6),d0      * LDA LATCH.HL load current latch settings.
  92.             or.b        #$01,d0              * ORA #$01 drop all rts signals to sync side.
  93.             move.b      d0,latch_hl(a6)      * STA LATCH.HL save current latch settings.
  94.             move.b      d0,latch(a6)         * STA LATCH store in hardware latch.
  95.  
  96.             move.w      #$0b6c,d2            * LDD #$0B6C disable xmit,recieve,clr sync.
  97.             move.w      d2,contu(a6)         * STD CONTU store in usart.
  98.             clr.b       fiqt_pas(a6)         * CLR FIQT.PAS clear pass indicator.
  99.             rts                              * RTS RETURN.
  100.  
  101.             pag         *                    PAG
  102. ***********************************
  103. ***     initialize free list   ****
  104. ***********************************
  105.  
  106. intfree     move.l      #buf_spc,a0          * LDX #BUF_SPC load beginning of buffer space.
  107.             move.l      a0,free_node(a6)     * STX Free.Node store in free node.
  108.  
  109.             move.w      #buf_spc,d2          * LDD #BUF_SPC load first node.
  110.             clr.b       d1                   * CLRB
  111.  
  112. intfre1     addq.b      #1,d0                * INCA POINT to next node
  113.             move.b      d0,(a0)              * STA ,X store successor node.
  114.             bhs.s       intfre2              * BHS INTFRE2 branch if so.
  115.  
  116.             move.w      d2,a0                * TFR D,X point to next location
  117.             bra.s       intfre1              * BRA INTFRE1 go do next node.
  118.  
  119. intfre2     move.b      #$00,d0              * LDA #$00 store `null' successor node at end of list.
  120.             move.b      d0,(a0)              * STA ,X store in node.
  121.             move.b      #max_node,d0         * LDA #MAX_NODE load number of nodes you just initialized.
  122.             move.b      d0,free_cnt(a6)      * STA Free.cnt store as free node count.
  123.             rts                              * RTS RETURN.
  124.  
  125.  
  126.  
  127. ***************************************
  128. ***          initialize queues      ***
  129. ***************************************
  130.  
  131. initque     move.l      free_node(a6),a0     * LDX Free.Node get node from free list.
  132.             move.b      (a0),d0              * LDA ,X load successor node.         
  133.             clr.b       d1                   * CLRB MAKE sure b is clear.
  134.             move.l      a0,sique_wr(a6)      * STX SiQue.wr store queue pointers
  135.             move.l      a0,sique_rd(a6)      * STX SiQue.rd
  136.             move.b      d1,sique_ct(a6)      * STB SiQue.ct set count to 00
  137.             move.b      d1,sique_sm(a6)      * STB SiQue.sm reset semaphore bit on queue.
  138.  
  139.             move.w      d2,a0                * TFR D,X point to next node on list.
  140.             move.b      (a0),d0              * LDA ,X load successor node.         
  141.             move.l      a0,soque_wr(a6)      * STX SoQue.wr store queue pointers
  142.             move.l      a0,soque_rd(a6)      * STX SoQue.rd
  143.             move.b      d1,soque_ct(a6)      * STB SoQue.ct set count to 00
  144.             move.b      d1,soque_sm(a6)      * STB SoQue.sm reset semaphore bit on queue.
  145.  
  146.             move.w      d2,a0                * TFR D,X point to next node on list.
  147.             move.b      (a0),d0              * LDA ,X load successor node.         
  148.             move.l      a0,otque_wr(a6)      * STX OtQue.wr store queue pointers
  149.             move.l      a0,otque_rd(a6)      * STX OtQue.rd
  150.             move.b      d1,otque_ct(a6)      * STB OtQue.ct set count to 00
  151.             move.b      d1,otque_sm(a6)      * STB OtQue.sm reset semaphore bit on queue.
  152.  
  153.             move.w      d2,a0                * TFR D,X point to next node on list.
  154.             move.b      (a0),d0              * LDA ,X load successor node.         
  155.             move.l      a0,inque_wr(a6)      * STX InQue.wr store queue pointers
  156.             move.l      a0,inque_rd(a6)      * STX InQue.rd
  157.             move.b      d1,inque_ct(a6)      * STB InQue.ct set count to 00
  158.             move.b      d1,inque_sm(a6)      * STB InQue.sm reset semaphore bit on queue.
  159.  
  160.             move.w      d2,free_node(a6)     * STD Free.Node store pointer back on free list
  161.             move.b      free_cnt(a6),d1      * LDB Free.cnt load count of nodes on free list.
  162.             move.b      d1,free_cnt(a6)      * STB Free.cnt store new count.
  163.             rts                              * RTS RETURN.
  164.  
  165. *****************************************************
  166. ***     incqueue        increment queue pointers  ***
  167. *****************************************************
  168. *
  169. *            x = pointer to queue control block
  170. incqueue    move.w      write(a0),d2         * LDD Write,X load queue entry pointer.
  171.             add.w       #que_entry,d2        * ADDD #Que_Entry point to next entry.
  172.             move.w      d2,write(a0)         * STD Write,X store queue entry pointer.
  173.             addq.b      #1,quecnt(a0)        * INC QueCnt,X increment queue entry count.
  174.             rts                              * RTS RETURN
  175.  
  176. *****************************************************
  177. ***     decqueue        decrement queue pointers  ***
  178. *****************************************************
  179. *
  180. *            x = pointer to queue control block
  181. decqueue    move.w      read(a0),d2          * LDD Read,X load queue entry pointer.
  182.             add.w       #que_entry,d2        * ADDD #Que_Entry point to next entry.
  183.             move.w      d2,read(a0)          * STD Read,X store queue entry pointer.
  184.             subq.b      #1,quecnt(a0)        * DEC QueCnt,X decrement queue entry count.
  185.             rts                              * RTS RETURN
  186.  
  187.  
  188.             pag         *                    PAG
  189. quebuf      move.l      #otque_wr,a6         * LDU #OtQue.wr load address of queue pointers.
  190.             jsr         quemsg(a6)           * JSR QUEMSG put message on output queue.
  191.             move.b      inque_rd+1(a6),d1    * LDB InQue.rd+1 increment input queue read pointer.
  192.             add.b       #que_entry,d1        * ADDB #Que_Entry
  193.             move.b      d1,inque_rd+1(a6)    * STB InQue.rd+1 store new queue pointer.
  194.             subq.b      #1,inque_ct(a6)      * DEC InQue.ct decrement number of queued items.
  195.             rts                              * RTS RETURN (usually back to top of txa)
  196.  
  197.  
  198. *********************************************************
  199. ***     quemsg          put buffer on output queue.   ***
  200. quemsg      move.l      write(a6),a1         * LDY Write,U load output queue write pointer.
  201. *                       move buffer pointers onto queue.
  202.             move.w      (a0),d2              * LDD ,X
  203.             move.w      d2,(a1)              * STD ,Y (write pointer)
  204.             move.w      2(a0),d2             * LDD 2,X
  205.             move.w      d2,2(a1)             * STD 2,Y (read pointer)
  206.             move.b      4(a0),d0             * LDA 4,X
  207.             move.b      d0,4(a1)             * STA 4,Y (count of nodes)
  208.             move.b      write_pnt(a6),d1     * LDB Write.pnt,U increment write pointer.
  209.             add.b       #que_entry,d1        * ADDB #Que_Entry
  210.             move.b      d1,write_pnt(a6)     * STB Write.pnt,U store new queue pointer.
  211.             addq.b      #1,quecnt(a6)        * INC QueCnt,U increment count of queued elements.
  212.             rts                              * RTS RETURN.
  213.             pag         *                    PAG
  214.  
  215. reque       tst.b       sem(a6)              * TST Sem,U check queue write semaphore flag
  216.             beq.s       reque1               * BEQ REQUE1 branch if ok to write.
  217.  
  218.             trap        #1                   * SWI2
  219.             bra.s       reque                * BRA REQUE else wait for flag to clear.
  220.  
  221. reque1      addq.b      #1,sem(a6)           * INC Sem,U set semaphore flag.
  222.             move.l      write(a6),a1         * LDY Write,U load queue write pointer.
  223.             move.l      read(a6),a0          * LDX Read,U load queue read pointer.
  224. *            move queue entry from read to write.  (8 bytes to move)
  225.             move.w      (a0),d2              * LDD ,X
  226.             move.w      d2,(a1)              * STD ,Y
  227.             move.w      2(a0),d2             * LDD 2,X
  228.             move.w      d2,2(a1)             * STD 2,Y
  229.             move.w      4(a0),d2             * LDD 4,X
  230.             move.w      6(a0),d2             * LDD 6,X
  231.             move.w      d2,6(a1)             * STD 6,Y
  232.             move.b      write_pnt(a6),d1     * LDB Write.pnt,U inc write pointer. (msb of pointer constant)
  233.             add.b       #que_entry,d1        * ADDB #Que_Entry
  234.             move.b      d1,write_pnt(a6)     * STB Write.pnt,U store new queue pointer.
  235.             move.b      read_pnt(a6),d1      * LDB Read.pnt,U inc read pointer. (msb of pointer constant)
  236.             add.b       #que_entry,d1        * ADDB #Que_Entry
  237.             move.b      d1,read_pnt(a6)      * STB Read.pnt,U store new queue pointer.
  238.             clr.b       sem(a6)              * CLR Sem,U reset semaphore flag.
  239.             rts                              * RTS RETURN.
  240.             pag         *                    PAG
  241.  
  242. alocate     move        ccr,-(a7)            * PSHS CC 
  243.             ori         #$50,ccr             * ORCC #$50
  244.             move.w      free_node(a6),d2     * LDD Free.Node load free node pointer (note: lsb = 00)
  245.             beq.s       aloc010              * BEQ ALOC010 branch if error (no space on free list)
  246.  
  247.             move.w      d2,write(a6)         * STD Write,U save node pointers for this node
  248.             move.w      d2,read(a6)          * STD Read,U
  249.             clr.b       write_pnt(a6)        * CLR Write.pnt,U
  250.             move.b      ([write,a6]),d1      * LDB [Write,U] load successor pointer
  251.             move.b      d1,free_node(a6)     * STB Free.Node store in free node pointer.
  252.             addq.b      #1,node_cnt(a6)      * INC Node.cnt,U set number of nodes for this buffer.
  253.             move.b      #$01,d0              * LDA #$01 point to first data element in node.
  254.             move.b      d0,write_pnt(a6)     * STA Write.pnt,U
  255.             move.b      d0,read_pnt(a6)      * STA Read.pnt,U
  256.             move        (a7)+,ccr            * PULS CC 
  257.             move.l      write(a6),a0         * LDX Write,U set cc <> 0 for good return.
  258.             rts                              * RTS RETURN
  259.  
  260. aloc010     move        (a7)+,ccr            * PULS CC 
  261.             clr.b       d1                   * CLRB SET condition code = 0 for error.
  262.             rts                              * RTS RETURN. (no more space!)
  263.             pag         *                    PAG
  264. dealoc      move        ccr,-(a7)            * PSHS CC 
  265.             ori         #$50,ccr             * ORCC #$50
  266.             clr.b       write_pnt(a6)        * CLR Write.pnt,U set pointer to successor of write node.
  267.             move.b      read(a6),d1          * LDB Read,U load beginning of buffer
  268.             move.l      free_node(a6),a0     * LDX Free.Node load free list pointer
  269.             move.b      d1,free_node(a6)     * STB Free.Node
  270.             move.l      a0,([write,a6])      * STX [Write,U] store as successor of write node.
  271.             move.b      node_cnt(a6),d0      * LDA Node.cnt,U load buffer element counter.
  272.             add.b       free_cnt(a6),d0      * ADDA Free.cnt add to count of free nodes.
  273.             move.b      d0,free_cnt(a6)      * STA Free.cnt store as new free count.
  274.             clr.b       node_cnt(a6)         * CLR Node.cnt,U reset node count of buffer control block.
  275.             move        (a7)+,ccr            * PULS CC 
  276.             rts                              * RTS RETURN.
  277.             pag         *                    PAG
  278. ***********************************
  279. ***     put buffer              ***
  280. trputbuf    cmp.b       #$17,d0              * CMPA #$17 check for [etb]
  281.             bhi.s       putbuf               * BHI PUTBUF if normal character dont make transparent
  282.             beq.s       trptbf1              * BEQ TRPTBF1
  283.             cmp.b       #$10,d0              * CMPA #$10 check for [dle]
  284.             beq.s       trptbf1              * BEQ TRPTBF1
  285.             cmp.b       #$03,d0              * CMPA #$03 check for [soh] [stx] or [etx]
  286.             bhi.s       putbuf               * BHI PUTBUF else must be normal control character
  287.             cmp.b       #$00,d0              * CMPA #$00
  288.             beq.s       putbuf               * BEQ PUTBUF don't make nul's transparent.
  289.  
  290. trptbf1     movem.l     d0,-(a7)             * PSHS A SAVE CHARACTER ON STACK.
  291.             move.b      #$10,d0              * LDA #$10 put [dle] into buffer.
  292.             bsr.s       putbuf               * BSR PUTBUF
  293.             movem.l     (a7)+,d0             * PULS A RESTORE CHARACTER.
  294.  
  295.  
  296. putbuf      move.b      d0,([write,a6])      * STA [Write,U] store character in buffer
  297.             addq.b      #1,write_pnt(a6)     * INC Write.pnt,U increment write pointer.
  298.             bne.s       putbuf1              * BNE PUTBUF1 branch if not at end of node.
  299.  
  300.             move.b      free_node(a6),d1     * LDB Free.Node load free node pointer
  301.             beq.s       putbuf2              * BEQ PUTBUF2 branch if none left.     (error)
  302.  
  303.             move.b      d1,([write,a6])      * STB [Write,U] store sucessor pointer on last node.
  304.             move.b      d1,write(a6)         * STB Write,U store next node pointer.
  305.             move.b      ([write,a6]),d1      * LDB [Write,U] load sucessor of next node.
  306.             move.b      d1,free_node(a6)     * STB Free.Node store as next free node pointer.
  307.             subq.b      #1,free_cnt(a6)      * DEC Free.cnt decrement count of free nodes.
  308.             addq.b      #1,node_cnt(a6)      * INC Node.cnt,U increment buffer node count.
  309.             addq.b      #1,write_pnt(a6)     * INC Write.pnt,U store value.
  310.             rts                              * RTS RETURN. cc <> 0   good return.
  311.  
  312.  
  313. putbuf1     move.b      #$01,d1              * LDB #$01 set cc <> 0 good return
  314.             rts                              * RTS RETURN
  315. *            error exit.
  316.  
  317. putbuf2     subq.b      #1,write_pnt(a6)     * DEC Write.pnt,U reset write pointer to what  it was at start.
  318.             clr.b       d1                   * CLRB SET condition code = 0 for error. (no more space!)
  319.  
  320. qputbuf     move.b      d0,([write,a6])      * STA [Write,U] store character in buffer
  321.             addq.b      #1,write_pnt(a6)     * INC Write.pnt,U increment write pointer.
  322.             rts                              * RTS RETURN.
  323.  
  324.  
  325. getbuf      movem.l     d1,-(a7)             * PSHS B
  326.             move.b      ([mid,a6]),d0        * LDA [Mid,U] load character from buffer.
  327.             addq.b      #1,mid_pnt(a6)       * INC Mid.pnt,U increment buffer pointer.
  328.             bne.s       getbuf10             * BNE GETBUF10 branch if node wrap.
  329.             move.b      ([mid,a6]),d1        * LDB [Mid,U] load successor pointer.
  330.             bmi.s       getbuf20             * BMI GETBUF20 branch if not valid sucessor (terminate)
  331.  
  332.             move.b      d1,mid(a6)           * STB Mid,U store as next read node.
  333.             addq.b      #1,mid_pnt(a6)       * INC Mid.pnt,U increment off successor pointer.
  334. getbuf10    movem.l     (a7)+,d1             * PULS B,PC RETURN.
  335.             rts 
  336.  
  337. getbuf20    clr.b       d1                   * CLRB SET condition code to error.
  338.             movem.l     (a7)+,d1             * PULS B,PC RETURN.
  339.             rts 
  340.  
  341.