URL https://opencores.org/ocsvn/light8080/light8080/trunk

Subversion Repositories light8080

[/] [light8080/] [trunk/] [c/] [hello.asm] - Blame information for rev 73

Go to most recent revision | Details | Compare with Previous | View Log


; <><><>   Small-C  V1.2  DOS--CP/M Cross Compiler   <><><>
; <><><><><>   CP/M Large String Space Version   <><><><><>
; <><><><><><><><><><>   By Ron Cain   <><><><><><><><><><>
;
        code
        org #0000
        ld hl,3072
        ld sp,hl
        call __main
;//---------------------------------------------------------------------------------------
;//     Project:                        light8080 SOC           WiCores Solutions
;//
;//     File name:                      hello.c                                 (February 04, 2012)
;//
;//     Writer:                         Moti Litochevski
;//
;//     Description:
;//             This file contains a simple program written in Small-C that sends a string to
;//             the UART and then switches to echo received bytes.
;//             This example also include a simple interrupt example which will work with the
;//             verilog testbench. the testbench
;//
;//     Revision History:
;//
;//     Rev                                             
;//             
;//---------------------------------------------------------------------------------------
;// define interrupt vectors
;// note that this file must be edited to enable interrupt used
;#include intr_vec.h
;//---------------------------------------------------------------------------------------
;//     Project:                        light8080 SOC           WiCores Solutions
;//
;//     File name:                      intr_vec.h                      (March 03, 2012)
;//
;//     Writer:                         Moti Litochevski
;//
;//     Description:
;//             This file contains a simple example of calling interrupt service routine. this
;//             file defines the interrupt vector for external interrupt 0 located at address
;//             0x0008. the interrupts vectors addresses are set in the verilog interrupt
;//             controller "intr_ctrl.v" file.
;//             Code is generated for all 4 supported external interrupts but non used interrupt
;//             are not called.
;//             On execution of an interrupt the CPU will automatically clear the interrupt
;//             enable flag set by the EI instruction. the interrupt vectors in this example
;//             enable the interrupts again after interrupt service routine execution. to enable
;//             nested interrupts just move the EI instruction to the code executed before the
;//             call instruction to the service routine (see comments below).
;//             Note that this code is not optimized in any way. this is just an example to
;//             verify the interrupt mechanism of the light8080 CPU and show a simple example.
;//
;//     Revision History:
;//
;//     Rev                                             
;//             
;//---------------------------------------------------------------------------------------
;// to support interrupt enable the respective interrupt vector is defined here at the
;// beginning of the output assembly file. only the interrupt vector for used interrupts
;// should call a valid interrupt service routine name defined in the C source file. the
;// C function name should be prefixed by "__".
;#asm
;Preserve space for interrupt routines
;interrupt 0 vector
        org #0008
        push af
        push bc
        push de
        push hl
;       ei                                      ; to enable nested interrupts uncomment this instruction
        call __int0_isr
        pop hl
        pop de
        pop bc
        pop af
        ei                                      ; interrupt are not enabled during the execution os the isr
        ret
;interrupt 1 vector
        org #0018
        push af
        push bc
        push de
        push hl
;       call __int1_isr         ; interrupt not used
        pop hl
        pop de
        pop bc
        pop af
        ei
        ret
;interrupt 2 vector
        org #0028
        push af
        push bc
        push de
        push hl
;       call __int2_isr         ; interrupt not used
        pop hl
        pop de
        pop bc
        pop af
        ei
        ret
;interrupt 3 vector
        org #0038
        push af
        push bc
        push de
        push hl
;       call __int3_isr         ; interrupt not used
        pop hl
        pop de
        pop bc
        pop af
        ei
        ret
;//---------------------------------------------------------------------------------------
;//                                             Th.. Th.. Th.. Thats all folks !!!
;//---------------------------------------------------------------------------------------
;// insert c80 assmbly library to the output file
;#include ..\tools\c80\c80.lib
;#asm
;
;------------------------------------------------------------------
;       Small-C  Run-time Librray
;
;       V4d     As of July 16, 1980 (gtf)
;                  Added EXIT() function
;------------------------------------------------------------------
;
;Fetch a single byte from the address in HL and sign extend into HL
ccgchar:
        ld a,(hl)
ccsxt:
        ld l,a
        rlca
        sbc     a
        ld      h,a
        ret
;Fetch a full 16-bit integer from the address in HL
ccgint:
        ld a,(hl)
        inc     hl
        ld      h,(hl)
        ld l,a
        ret
;Store a single byte from HL at the address in DE
ccpchar:
        ld      a,l
        ld      (de),a
        ret
;Store a 16-bit integer in HL at the address in DE
ccpint:
        ld      a,l
        ld      (de),a
        inc     de
        ld      a,h
        ld      (de),a
        ret
;Inclusive "or" HL and DE into HL
ccor:
        ld      a,l
        or      e
        ld l,a
        ld      a,h
        or      d
        ld      h,a
        ret
;Exclusive "or" HL and DE into HL
ccxor:
        ld      a,l
        xor     e
        ld l,a
        ld      a,h
        xor     d
        ld      h,a
        ret
;"And" HL and DE into HL
ccand:
        ld      a,l
        and     e
        ld l,a
        ld      a,h
        and     d
        ld      h,a
        ret
;Test if HL = DE and set HL = 1 if true else 0
cceq:
        call cccmp
        ret z
        dec     hl
        ret
;Test if DE ~= HL
ccne:
        call cccmp
        ret nz
        dec     hl
        ret
;Test if DE > HL (signed)
ccgt:
        ex de,hl
        call cccmp
        ret c
        dec     hl
        ret
;Test if DE <= HL (signed)
ccle:
        call cccmp
        ret z
        ret c
        dec hl
        ret
;Test if DE >= HL (signed)
ccge:
        call cccmp
        ret nc
        dec hl
        ret
;Test if DE < HL (signed)
cclt:
        call cccmp
        ret c
        dec hl
        ret
; Signed compare of DE and HL
; Performs DE - HL and sets the conditions:
;       Carry reflects sign of difference (set means DE < HL)
;       Zero/non-zero set according to equality.
cccmp:
        ld      a,e
        sub     l
        ld      e,a
        ld      a,d
        sbc     h
        ld      hl,1
        jp      m,cccmp1
        or      e       ;"OR" resets carry
        ret
cccmp1:
        or      e
        scf             ;set carry to signal minus
        ret
;Test if DE >= HL (unsigned)
ccuge:
        call ccucmp
        ret nc
        dec hl
        ret
;Test if DE < HL (unsigned)
ccult:
        call ccucmp
        ret c
        dec hl
        ret
;Test if DE > HL (unsigned)
ccugt:
        ex de,hl
        call ccucmp
        ret c
        dec hl
        ret
;Test if DE <= HL (unsigned)
ccule:
        call ccucmp
        ret z
        ret c
        dec hl
        ret
;Routine to perform unsigned compare
;carry set if DE < HL
;zero/nonzero set accordingly
ccucmp:
        ld      a,d
        cp      h
        jp      nz,$+5
        ld      a,e
        cp      l
        ld      hl,1
        ret
;Shift DE arithmetically right by HL and return in HL
ccasr:
        ex      de,hl
        ld      a,h
        rla
        ld      a,h
        rra
        ld      h,a
        ld      a,l
        rra
        ld      l,a
        dec     e
        jp      nz,ccasr+1
        ret
;Shift DE arithmetically left by HL and return in HL
ccasl:
        ex      de,hl
        add     hl,hl
        dec     e
        jp      nz,ccasl+1
        ret
;Subtract HL from DE and return in HL
ccsub:
        ld      a,e
        sub     l
        ld l,a
        ld      a,d
        sbc     h
        ld      h,a
        ret
;Form the two's complement of HL
ccneg:
        call cccom
        inc     hl
        ret
;Form the one's complement of HL
cccom:
        ld      a,h
        cpl
        ld      h,a
        ld      a,l
        cpl
        ld l,a
        ret
;Multiply DE by HL and return in HL
ccmult:
        ld      b,h
        ld      c,l
        ld      hl,0
ccmult1:
        ld      a,c
        rrca
        jp      nc,$+4
        add     hl,de
        xor     a
        ld      a,b
        rra
        ld      b,a
        ld      a,c
        rra
        ld      c,a
        or      b
        ret z
        xor     a
        ld      a,e
        rla
        ld      e,a
        ld      a,d
        rla
        ld      d,a
        or      e
        ret z
        jp      ccmult1
;Divide DE by HL and return quotient in HL, remainder in DE
ccdiv:
        ld      b,h
        ld      c,l
        ld      a,d
        xor     b
        push af
        ld      a,d
        or      a
        call m,ccdeneg
        ld      a,b
        or      a
        call m,ccbcneg
        ld      a,16
        push af
        ex      de,hl
        ld      de,0
ccdiv1:
        add hl,hl
        call ccrdel
        jp      z,ccdiv2
        call cccmpbcde
        jp      m,ccdiv2
        ld      a,l
        or      1
        ld l,a
        ld      a,e
        sub     c
        ld      e,a
        ld      a,d
        sbc     b
        ld      d,a
ccdiv2:
        pop af
        dec     a
        jp      z,ccdiv3
        push af
        jp      ccdiv1
ccdiv3:
        pop af
        ret     p
        call ccdeneg
        ex de,hl
        call ccdeneg
        ex de,hl
        ret
ccdeneg:
        ld      a,d
        cpl
        ld      d,a
        ld      a,e
        cpl
        ld      e,a
        inc     de
        ret
ccbcneg:
        ld      a,b
        cpl
        ld      b,a
        ld      a,c
        cpl
        ld      c,a
        inc     bc
        ret
ccrdel:
        ld      a,e
        rla
        ld      e,a
        ld      a,d
        rla
        ld      d,a
        or      e
        ret
cccmpbcde:
        ld      a,e
        sub     c
        ld      a,d
        sbc     b
        ret
;// UART IO registers
;port (128) UDATA;              // uart data register used for both transmit and receive
;port (129) UBAUDL;             // low byte of baud rate register
;port (130) UBAUDH;             // low byte of baud rate register
;port (131) USTAT;              // uart status register
;// digital IO ports registers
;port (132) P1DATA;             // port 1 data register
;port (133) P1DIR;              // port 1 direction register control
;port (134) P2DATA;             // port 2 data register
;port (135) P2DIR;              // port 2 direction register control
;// interrupt controller register
;port (136) INTRENA;            // interrupts enable register
;// simulation end register
;// writing any value to this port will end the verilog simulation when using tb_l80soc
;// test bench.
;port (255) SIMEND;
;// registers bit fields definition
;// uart status register decoding
;#define UTXBUSY                1
;#define URXFULL                16
;// globals
;char rxbyte;           // byte received from the uart
;int tstary[2] = {1234, 5678};
;//---------------------------------------------------------------------------------------
;// send a single byte to the UART
;sendbyte(by)
__sendbyte:
;char by;
;{
;       while (USTAT & UTXBUSY);
cc2:
        in a,(131)
        call ccsxt
        push hl
        ld hl,1
        pop de
        call ccand
        ld a,h
        or l
        jp z,cc3
        jp cc2
cc3:
;       UDATA = by;
        ld hl,2
        add hl,sp
        call ccgchar
        ld a,l
        out (128),a
 
;}
        ret
;// check if a byte was received by the uart
;getbyte()
__getbyte:
;{
;       if (USTAT & URXFULL) {
        in a,(131)
        call ccsxt
        push hl
        ld hl,16
        pop de
        call ccand
        ld a,h
        or l
        jp z,cc4
;               rxbyte = UDATA;
        in a,(128)
        call ccsxt
        ld a,l
        ld (__rxbyte),a
;               return 1;
        ld hl,1
        ret
;       }
;       else
        jp cc5
cc4:
;               return 0;
        ld hl,0
        ret
cc5:
;}
        ret
;// send new line to the UART
;nl()
__nl:
;{
;       sendbyte(13);
        ld hl,13
        push hl
        call __sendbyte
        pop bc
;       sendbyte(10);
        ld hl,10
        push hl
        call __sendbyte
        pop bc
;}
        ret
;// sends a string to the UART
;printstr(sptr)
__printstr:
;char *sptr;
;{
;       while (*sptr != 0)
cc6:
        ld hl,2
        add hl,sp
        call ccgint
        call ccgchar
        push hl
        ld hl,0
        pop de
        call ccne
        ld a,h
        or l
        jp z,cc7
;               sendbyte(*sptr++);
        ld hl,2
        add hl,sp
        push hl
        call ccgint
        inc hl
        pop de
        call ccpint
        dec hl
        call ccgchar
        push hl
        call __sendbyte
        pop bc
        jp cc6
cc7:
;}
        ret
;// sends a decimal value to the UART
;printdec(dval)
__printdec:
;int dval;
;{
;       if (dval<0) {
        ld hl,2
        add hl,sp
        call ccgint
        push hl
        ld hl,0
        pop de
        call cclt
        ld a,h
        or l
        jp z,cc8
;               sendbyte('-');
        ld hl,45
        push hl
        call __sendbyte
        pop bc
;               dval = -dval;
        ld hl,2
        add hl,sp
        push hl
        ld hl,4
        add hl,sp
        call ccgint
        call ccneg
        pop de
        call ccpint
;       }
;       outint(dval);
cc8:
        ld hl,2
        add hl,sp
        call ccgint
        push hl
        call __outint
        pop bc
;}
        ret
;// function copied from c80dos.c
;outint(n)
__outint:
;int n;
;{
;int q;
        push bc
;       q = n/10;
        ld hl,0
        add hl,sp
        push hl
        ld hl,6
        add hl,sp
        call ccgint
        push hl
        ld hl,10
        pop de
        call ccdiv
        pop de
        call ccpint
;       if (q) outint(q);
        ld hl,0
        add hl,sp
        call ccgint
        ld a,h
        or l
        jp z,cc9
        ld hl,0
        add hl,sp
        call ccgint
        push hl
        call __outint
        pop bc
;       sendbyte('0'+(n-q*10));
cc9:
        ld hl,48
        push hl
        ld hl,6
        add hl,sp
        call ccgint
        push hl
        ld hl,4
        add hl,sp
        call ccgint
        push hl
        ld hl,10
        pop de
        call ccmult
        pop de
        call ccsub
        pop de
        add hl,de
        push hl
        call __sendbyte
        pop bc
;}
        pop bc
        ret
;// sends a hexadecimal value to the UART
;printhex(hval)
__printhex:
;int hval;
;{
;int q;
        push bc
;       q = hval/16;
        ld hl,0
        add hl,sp
        push hl
        ld hl,6
        add hl,sp
        call ccgint
        push hl
        ld hl,16
        pop de
        call ccdiv
        pop de
        call ccpint
;       if (q) printhex(q);
        ld hl,0
        add hl,sp
        call ccgint
        ld a,h
        or l
        jp z,cc10
        ld hl,0
        add hl,sp
        call ccgint
        push hl
        call __printhex
        pop bc
;       q = hval-q*16;
cc10:
        ld hl,0
        add hl,sp
        push hl
        ld hl,6
        add hl,sp
        call ccgint
        push hl
        ld hl,4
        add hl,sp
        call ccgint
        push hl
        ld hl,16
        pop de
        call ccmult
        pop de
        call ccsub
        pop de
        call ccpint
;       if (q > 9)
        ld hl,0
        add hl,sp
        call ccgint
        push hl
        ld hl,9
        pop de
        call ccgt
        ld a,h
        or l
        jp z,cc11
;               sendbyte('A'+q-10);
        ld hl,65
        push hl
        ld hl,2
        add hl,sp
        call ccgint
        pop de
        add hl,de
        push hl
        ld hl,10
        pop de
        call ccsub
        push hl
        call __sendbyte
        pop bc
;       else
        jp cc12
cc11:
;               sendbyte('0'+q);
        ld hl,48
        push hl
        ld hl,2
        add hl,sp
        call ccgint
        pop de
        add hl,de
        push hl
        call __sendbyte
        pop bc
cc12:
;}
        pop bc
        ret
;// external interrupt 0 service routine
;int0_isr()
__int0_isr:
;{
;       printstr("Interrupt 0 was asserted."); nl();
        ld hl,cc1+0
        push hl
        call __printstr
        pop bc
        call __nl
;}
        ret
;// program main routine
;main()
__main:
;{
;       // configure UART baud rate - set to 9600 for 30MHz clock
;       // BAUD = round(//16) = round(30e6/9600/16) = 195
;       // Note: Usage of a minimum divider value of 1 will accelerate the RTL simulation.
;       UBAUDL = 195;
        ld hl,195
        ld a,l
        out (129),a
 
;       UBAUDH = 0;
        ld hl,0
        ld a,l
        out (130),a
 
;       // configure both ports to output and digital outputs as zeros
;       P1DATA = 0x00;
        ld hl,0
        ld a,l
        out (132),a
 
;       P1DIR = 0xff;
        ld hl,255
        ld a,l
        out (133),a
 
;       P2DATA = 0x00;
        ld hl,0
        ld a,l
        out (134),a
 
;       P2DIR = 0xff;
        ld hl,255
        ld a,l
        out (135),a
 
;       // enable interrupt 0 only
;       INTRENA = 0x01;
        ld hl,1
        ld a,l
        out (136),a
 
;       // enable CPU interrupt
;#asm
        ei
;       // print message
;       printstr("Hello World!!!"); nl();
        ld hl,cc1+26
        push hl
        call __printstr
        pop bc
        call __nl
;       printstr("Dec value: "); printdec(tstary[1]); nl();
        ld hl,cc1+41
        push hl
        call __printstr
        pop bc
        ld hl,__tstary
        push hl
        ld hl,1
        add hl,hl
        pop de
        add hl,de
        call ccgint
        push hl
        call __printdec
        pop bc
        call __nl
;       printstr("Hex value: 0x"); printhex(tstary[0]); nl();
        ld hl,cc1+53
        push hl
        call __printstr
        pop bc
        ld hl,__tstary
        push hl
        ld hl,0
        add hl,hl
        pop de
        add hl,de
        call ccgint
        push hl
        call __printhex
        pop bc
        call __nl
;       // assert bit 0 of port 1 to test external interrupt 0
;       P1DATA = 0x01;
        ld hl,1
        ld a,l
        out (132),a
 
;
;       printstr("Echoing received bytes: "); nl();
        ld hl,cc1+67
        push hl
        call __printstr
        pop bc
        call __nl
;       // loop forever
;       while (1) {
cc13:
        ld hl,1
        ld a,h
        or l
        jp z,cc14
;               // check if a new byte was received
;               if (getbyte())
        call __getbyte
        ld a,h
        or l
        jp z,cc15
;                       // echo the received byte to the UART
;                       sendbyte(rxbyte);
        ld a,(__rxbyte)
        call ccsxt
        push hl
        call __sendbyte
        pop bc
;       }
cc15:
        jp cc13
cc14:
;}
        ret
;//---------------------------------------------------------------------------------------
;//                                             Th.. Th.. Th.. Thats all folks !!!
;//---------------------------------------------------------------------------------------
cc1:
        db 73,110,116,101,114,114,117,112,116,32
        db 48,32,119,97,115,32,97,115,115,101
        db 114,116,101,100,46,0,72,101,108,108
        db 111,32,87,111,114,108,100,33,33,33
        db 0,68,101,99,32,118,97,108,117,101
        db 58,32,0,72,101,120,32,118,97,108
        db 117,101,58,32,48,120,0,69,99,104
        db 111,105,110,103,32,114,101,99,101,105
        db 118,101,100,32,98,121,116,101,115,58
        db 32,0
__rxbyte:
        ds 1
__tstary:
        db -46,4,46,22
 
; --- End of Compilation ---

Line No.	Rev	Author	Line
1	65	motilito	`; <><><> Small-C V1.2 DOS--CP/M Cross Compiler <><><>`
2			`; <><><><><> CP/M Large String Space Version <><><><><>`
3			`; <><><><><><><><><><> By Ron Cain <><><><><><><><><><>`
4			`;`
5			`code`
6			`org #0000`
7			`ld hl,3072`
8			`ld sp,hl`
9			`call __main`
10			`;//---------------------------------------------------------------------------------------`
11			`;// Project: light8080 SOC WiCores Solutions`
12			`;//`
13			`;// File name: hello.c (February 04, 2012)`
14			`;//`
15			`;// Writer: Moti Litochevski`
16			`;//`
17			`;// Description:`
18			`;// This file contains a simple program written in Small-C that sends a string to`
19			`;// the UART and then switches to echo received bytes.`
20	66	motilito	`;// This example also include a simple interrupt example which will work with the`
21			`;// verilog testbench. the testbench`
22	65	motilito	`;//`
23			`;// Revision History:`
24			`;//`
25			`;// Rev`
26			`;//`
27			`;//---------------------------------------------------------------------------------------`
28	66	motilito	`;// define interrupt vectors`
29			`;// note that this file must be edited to enable interrupt used`
30			`;#include intr_vec.h`
31			`;//---------------------------------------------------------------------------------------`
32			`;// Project: light8080 SOC WiCores Solutions`
33			`;//`
34			`;// File name: intr_vec.h (March 03, 2012)`
35			`;//`
36			`;// Writer: Moti Litochevski`
37			`;//`
38			`;// Description:`
39			`;// This file contains a simple example of calling interrupt service routine. this`
40			`;// file defines the interrupt vector for external interrupt 0 located at address`
41			`;// 0x0008. the interrupts vectors addresses are set in the verilog interrupt`
42			`;// controller "intr_ctrl.v" file.`
43			`;// Code is generated for all 4 supported external interrupts but non used interrupt`
44			`;// are not called.`
45			`;// On execution of an interrupt the CPU will automatically clear the interrupt`
46			`;// enable flag set by the EI instruction. the interrupt vectors in this example`
47			`;// enable the interrupts again after interrupt service routine execution. to enable`
48			`;// nested interrupts just move the EI instruction to the code executed before the`
49			`;// call instruction to the service routine (see comments below).`
50			`;// Note that this code is not optimized in any way. this is just an example to`
51			`;// verify the interrupt mechanism of the light8080 CPU and show a simple example.`
52			`;//`
53			`;// Revision History:`
54			`;//`
55			`;// Rev`
56			`;//`
57			`;//---------------------------------------------------------------------------------------`
58			`;// to support interrupt enable the respective interrupt vector is defined here at the`
59			`;// beginning of the output assembly file. only the interrupt vector for used interrupts`
60			`;// should call a valid interrupt service routine name defined in the C source file. the`
61			`;// C function name should be prefixed by "__".`
62			`;#asm`
63			`;Preserve space for interrupt routines`
64			`;interrupt 0 vector`
65			`org #0008`
66			`push af`
67			`push bc`
68			`push de`
69			`push hl`
70			`; ei ; to enable nested interrupts uncomment this instruction`
71			`call __int0_isr`
72			`pop hl`
73			`pop de`
74			`pop bc`
75			`pop af`
76			`ei ; interrupt are not enabled during the execution os the isr`
77			`ret`
78			`;interrupt 1 vector`
79			`org #0018`
80			`push af`
81			`push bc`
82			`push de`
83			`push hl`
84			`; call __int1_isr ; interrupt not used`
85			`pop hl`
86			`pop de`
87			`pop bc`
88			`pop af`
89			`ei`
90			`ret`
91			`;interrupt 2 vector`
92			`org #0028`
93			`push af`
94			`push bc`
95			`push de`
96			`push hl`
97			`; call __int2_isr ; interrupt not used`
98			`pop hl`
99			`pop de`
100			`pop bc`
101			`pop af`
102			`ei`
103			`ret`
104			`;interrupt 3 vector`
105			`org #0038`
106			`push af`
107			`push bc`
108			`push de`
109			`push hl`
110			`; call __int3_isr ; interrupt not used`
111			`pop hl`
112			`pop de`
113			`pop bc`
114			`pop af`
115			`ei`
116			`ret`
117			`;//---------------------------------------------------------------------------------------`
118			`;// Th.. Th.. Th.. Thats all folks !!!`
119			`;//---------------------------------------------------------------------------------------`
120			`;// insert c80 assmbly library to the output file`
121	65	motilito	`;#include ..\tools\c80\c80.lib`
122			`;#asm`
123			`;`
124			`;------------------------------------------------------------------`
125			`; Small-C Run-time Librray`
126			`;`
127			`; V4d As of July 16, 1980 (gtf)`
128			`; Added EXIT() function`
129			`;------------------------------------------------------------------`
130			`;`
131			`;Fetch a single byte from the address in HL and sign extend into HL`
132			`ccgchar:`
133			`ld a,(hl)`
134			`ccsxt:`
135			`ld l,a`
136			`rlca`
137			`sbc a`
138			`ld h,a`
139			`ret`
140			`;Fetch a full 16-bit integer from the address in HL`
141			`ccgint:`
142			`ld a,(hl)`
143			`inc hl`
144			`ld h,(hl)`
145			`ld l,a`
146			`ret`
147			`;Store a single byte from HL at the address in DE`
148			`ccpchar:`
149			`ld a,l`
150			`ld (de),a`
151			`ret`
152			`;Store a 16-bit integer in HL at the address in DE`
153			`ccpint:`
154			`ld a,l`
155			`ld (de),a`
156			`inc de`
157			`ld a,h`
158			`ld (de),a`
159			`ret`
160			`;Inclusive "or" HL and DE into HL`
161			`ccor:`
162			`ld a,l`
163			`or e`
164			`ld l,a`
165			`ld a,h`
166			`or d`
167			`ld h,a`
168			`ret`
169			`;Exclusive "or" HL and DE into HL`
170			`ccxor:`
171			`ld a,l`
172			`xor e`
173			`ld l,a`
174			`ld a,h`
175			`xor d`
176			`ld h,a`
177			`ret`
178			`;"And" HL and DE into HL`
179			`ccand:`
180			`ld a,l`
181			`and e`
182			`ld l,a`
183			`ld a,h`
184			`and d`
185			`ld h,a`
186			`ret`
187			`;Test if HL = DE and set HL = 1 if true else 0`
188			`cceq:`
189			`call cccmp`
190			`ret z`
191			`dec hl`
192			`ret`
193			`;Test if DE ~= HL`
194			`ccne:`
195			`call cccmp`
196			`ret nz`
197			`dec hl`
198			`ret`
199			`;Test if DE > HL (signed)`
200			`ccgt:`
201			`ex de,hl`
202			`call cccmp`
203			`ret c`
204			`dec hl`
205			`ret`
206			`;Test if DE <= HL (signed)`
207			`ccle:`
208			`call cccmp`
209			`ret z`
210			`ret c`
211			`dec hl`
212			`ret`
213			`;Test if DE >= HL (signed)`
214			`ccge:`
215			`call cccmp`
216			`ret nc`
217			`dec hl`
218			`ret`
219			`;Test if DE < HL (signed)`
220			`cclt:`
221			`call cccmp`
222			`ret c`
223			`dec hl`
224			`ret`
225			`; Signed compare of DE and HL`
226			`; Performs DE - HL and sets the conditions:`
227			`; Carry reflects sign of difference (set means DE < HL)`
228			`; Zero/non-zero set according to equality.`
229			`cccmp:`
230			`ld a,e`
231			`sub l`
232			`ld e,a`
233			`ld a,d`
234			`sbc h`
235			`ld hl,1`
236			`jp m,cccmp1`
237			`or e ;"OR" resets carry`
238			`ret`
239			`cccmp1:`
240			`or e`
241			`scf ;set carry to signal minus`
242			`ret`
243			`;Test if DE >= HL (unsigned)`
244			`ccuge:`
245			`call ccucmp`
246			`ret nc`
247			`dec hl`
248			`ret`
249			`;Test if DE < HL (unsigned)`
250			`ccult:`
251			`call ccucmp`
252			`ret c`
253			`dec hl`
254			`ret`
255			`;Test if DE > HL (unsigned)`
256			`ccugt:`
257			`ex de,hl`
258			`call ccucmp`
259			`ret c`
260			`dec hl`
261			`ret`
262			`;Test if DE <= HL (unsigned)`
263			`ccule:`
264			`call ccucmp`
265			`ret z`
266			`ret c`
267			`dec hl`
268			`ret`
269			`;Routine to perform unsigned compare`
270			`;carry set if DE < HL`
271			`;zero/nonzero set accordingly`
272			`ccucmp:`
273			`ld a,d`
274			`cp h`
275			`jp nz,$+5`
276			`ld a,e`
277			`cp l`
278			`ld hl,1`
279			`ret`
280			`;Shift DE arithmetically right by HL and return in HL`
281			`ccasr:`
282			`ex de,hl`
283			`ld a,h`
284			`rla`
285			`ld a,h`
286			`rra`
287			`ld h,a`
288			`ld a,l`
289			`rra`
290			`ld l,a`
291			`dec e`
292			`jp nz,ccasr+1`
293			`ret`
294			`;Shift DE arithmetically left by HL and return in HL`
295			`ccasl:`
296			`ex de,hl`
297			`add hl,hl`
298			`dec e`
299			`jp nz,ccasl+1`
300			`ret`
301			`;Subtract HL from DE and return in HL`
302			`ccsub:`
303			`ld a,e`
304			`sub l`
305			`ld l,a`
306			`ld a,d`
307			`sbc h`
308			`ld h,a`
309			`ret`
310			`;Form the two's complement of HL`
311			`ccneg:`
312			`call cccom`
313			`inc hl`
314			`ret`
315			`;Form the one's complement of HL`
316			`cccom:`
317			`ld a,h`
318			`cpl`
319			`ld h,a`
320			`ld a,l`
321			`cpl`
322			`ld l,a`
323			`ret`
324			`;Multiply DE by HL and return in HL`
325			`ccmult:`
326			`ld b,h`
327			`ld c,l`
328			`ld hl,0`
329			`ccmult1:`
330			`ld a,c`
331			`rrca`
332			`jp nc,$+4`
333			`add hl,de`
334			`xor a`
335			`ld a,b`
336			`rra`
337			`ld b,a`
338			`ld a,c`
339			`rra`
340			`ld c,a`
341			`or b`
342			`ret z`
343			`xor a`
344			`ld a,e`
345			`rla`
346			`ld e,a`
347			`ld a,d`
348			`rla`
349			`ld d,a`
350			`or e`
351			`ret z`
352			`jp ccmult1`
353			`;Divide DE by HL and return quotient in HL, remainder in DE`
354			`ccdiv:`
355			`ld b,h`
356			`ld c,l`
357			`ld a,d`
358			`xor b`
359			`push af`
360			`ld a,d`
361			`or a`
362			`call m,ccdeneg`
363			`ld a,b`
364			`or a`
365			`call m,ccbcneg`
366			`ld a,16`
367			`push af`
368			`ex de,hl`
369			`ld de,0`
370			`ccdiv1:`
371			`add hl,hl`
372			`call ccrdel`
373			`jp z,ccdiv2`
374			`call cccmpbcde`
375			`jp m,ccdiv2`
376			`ld a,l`
377			`or 1`
378			`ld l,a`
379			`ld a,e`
380			`sub c`
381			`ld e,a`
382			`ld a,d`
383			`sbc b`
384			`ld d,a`
385			`ccdiv2:`
386			`pop af`
387			`dec a`
388			`jp z,ccdiv3`
389			`push af`
390			`jp ccdiv1`
391			`ccdiv3:`
392			`pop af`
393			`ret p`
394			`call ccdeneg`
395			`ex de,hl`
396			`call ccdeneg`
397			`ex de,hl`
398			`ret`
399			`ccdeneg:`
400			`ld a,d`
401			`cpl`
402			`ld d,a`
403			`ld a,e`
404			`cpl`
405			`ld e,a`
406			`inc de`
407			`ret`
408			`ccbcneg:`
409			`ld a,b`
410			`cpl`
411			`ld b,a`
412			`ld a,c`
413			`cpl`
414			`ld c,a`
415			`inc bc`
416			`ret`
417			`ccrdel:`
418			`ld a,e`
419			`rla`
420			`ld e,a`
421			`ld a,d`
422			`rla`
423			`ld d,a`
424			`or e`
425			`ret`
426			`cccmpbcde:`
427			`ld a,e`
428			`sub c`
429			`ld a,d`
430			`sbc b`
431			`ret`
432			`;// UART IO registers`
433			`;port (128) UDATA; // uart data register used for both transmit and receive`
434			`;port (129) UBAUDL; // low byte of baud rate register`
435			`;port (130) UBAUDH; // low byte of baud rate register`
436			`;port (131) USTAT; // uart status register`
437			`;// digital IO ports registers`
438	66	motilito	`;port (132) P1DATA; // port 1 data register`
439			`;port (133) P1DIR; // port 1 direction register control`
440			`;port (134) P2DATA; // port 2 data register`
441			`;port (135) P2DIR; // port 2 direction register control`
442			`;// interrupt controller register`
443			`;port (136) INTRENA; // interrupts enable register`
444	65	motilito	`;// simulation end register`
445			`;// writing any value to this port will end the verilog simulation when using tb_l80soc`
446			`;// test bench.`
447			`;port (255) SIMEND;`
448			`;// registers bit fields definition`
449			`;// uart status register decoding`
450			`;#define UTXBUSY 1`
451			`;#define URXFULL 16`
452			`;// globals`
453			`;char rxbyte; // byte received from the uart`
454			`;int tstary[2] = {1234, 5678};`
455			`;//---------------------------------------------------------------------------------------`
456			`;// send a single byte to the UART`
457			`;sendbyte(by)`
458			`__sendbyte:`
459			`;char by;`
460			`;{`
461			`; while (USTAT & UTXBUSY);`
462			`cc2:`
463			`in a,(131)`
464			`call ccsxt`
465			`push hl`
466			`ld hl,1`
467			`pop de`
468			`call ccand`
469			`ld a,h`
470			`or l`
471			`jp z,cc3`
472			`jp cc2`
473			`cc3:`
474			`; UDATA = by;`
475			`ld hl,2`
476			`add hl,sp`
477			`call ccgchar`
478			`ld a,l`
479			`out (128),a`
480
481			`;}`
482			`ret`
483			`;// check if a byte was received by the uart`
484			`;getbyte()`
485			`__getbyte:`
486			`;{`
487			`; if (USTAT & URXFULL) {`
488			`in a,(131)`
489			`call ccsxt`
490			`push hl`
491			`ld hl,16`
492			`pop de`
493			`call ccand`
494			`ld a,h`
495			`or l`
496			`jp z,cc4`
497			`; rxbyte = UDATA;`
498			`in a,(128)`
499			`call ccsxt`
500			`ld a,l`

Browse

Tools

Subversion Repositories light8080

[/] [light8080/] [trunk/] [c/] [hello.asm] - Blame information for rev 73