1
0
mirror of https://github.com/hsoft/collapseos.git synced 2024-12-26 06:58:05 +11:00
collapseos/kernel/ti/lcd.asm
Virgil Dupras 7274dccbe7 Move ASCII consts to ascii.h
And made them shorter in name. The new ascii.h file allow reuse in userspace
code.
2019-11-13 20:38:06 -05:00

351 lines
7.2 KiB
NASM

; lcd
;
; Implement PutC on TI-84+ (for now)'s LCD screen.
;
; The screen is 96x64 pixels. The 64 rows are addressed directly with CMD_ROW
; but columns are addressed in chunks of 6 or 8 bits (there are two modes).
;
; In 6-bit mode, there are 16 visible columns. In 8-bit mode, there are 12.
;
; Note that "X-increment" and "Y-increment" work in the opposite way than what
; most people expect. Y moves left and right, X moves up and down.
;
; *** Z-Offset ***
;
; This LCD has a "Z-Offset" parameter, allowing to offset rows on the
; screen however we wish. This is handy because it allows us to scroll more
; efficiently. Instead of having to copy the LCD ram around at each linefeed
; (or instead of having to maintain an in-memory buffer), we can use this
; feature.
;
; The Z-Offet goes upwards, with wrapping. For example, if we have an 8 pixels
; high line at row 0 and if our offset is 8, that line will go up 8 pixels,
; wrapping itself to the bottom of the screen.
;
; The principle is this: The active line is always the bottom one. Therefore,
; when active row is 0, Z is FNT_HEIGHT+1, when row is 1, Z is (FNT_HEIGHT+1)*2,
; When row is 8, Z is 0.
;
; *** 6/8 bit columns and smaller fonts ***
;
; If your glyphs, including padding, are 6 or 8 pixels wide, you're in luck
; because pushing them to the LCD can be done in a very efficient manner.
; Unfortunately, this makes the LCD unsuitable for a Collapse OS shell: 6
; pixels per glyph gives us only 16 characters per line, which is hardly
; usable.
;
; This is why we have this buffering system. How it works is that we're always
; in 8-bit mode and we hold the whole area (8 pixels wide by FNT_HEIGHT high)
; in memory. When we want to put a glyph to screen, we first read the contents
; of that area, then add our new glyph, offsetted and masked, to that buffer,
; then push the buffer back to the LCD. If the glyph is split, move to the next
; area and finish the job.
;
; That being said, it's important to define clearly what CURX and CURY variable
; mean. Those variable keep track of the current position *in pixels*, in both
; axes.
;
; *** Requirements ***
; fnt/mgm
;
; *** Constants ***
.equ LCD_PORT_CMD 0x10
.equ LCD_PORT_DATA 0x11
.equ LCD_CMD_6BIT 0x00
.equ LCD_CMD_8BIT 0x01
.equ LCD_CMD_DISABLE 0x02
.equ LCD_CMD_ENABLE 0x03
.equ LCD_CMD_XDEC 0x04
.equ LCD_CMD_XINC 0x05
.equ LCD_CMD_YDEC 0x06
.equ LCD_CMD_YINC 0x07
.equ LCD_CMD_COL 0x20
.equ LCD_CMD_ZOFFSET 0x40
.equ LCD_CMD_ROW 0x80
.equ LCD_CMD_CONTRAST 0xc0
; *** Variables ***
; Current Y position on the LCD, that is, where re're going to spit our next
; glyph.
.equ LCD_CURY LCD_RAMSTART
; Current X position
.equ LCD_CURX @+1
; two pixel buffers that are 8 pixels wide (1b) by FNT_HEIGHT pixels high.
; This is where we compose our resulting pixels blocks when spitting a glyph.
.equ LCD_BUF @+1
.equ LCD_RAMEND @+FNT_HEIGHT*2
; *** Code ***
lcdInit:
; Initialize variables
xor a
ld (LCD_CURY), a
ld (LCD_CURX), a
; Clear screen
call lcdClrScr
; We begin with a Z offset of FNT_HEIGHT+1
ld a, LCD_CMD_ZOFFSET+FNT_HEIGHT+1
call lcdCmd
; Enable the LCD
ld a, LCD_CMD_ENABLE
call lcdCmd
; Hack to get LCD to work. According to WikiTI, we're not sure why TIOS
; sends these, but it sends it, and it is required to make the LCD
; work. So...
ld a, 0x17
call lcdCmd
ld a, 0x0b
call lcdCmd
; Set some usable contrast
ld a, LCD_CMD_CONTRAST+0x34
call lcdCmd
; Enable 8-bit mode.
ld a, LCD_CMD_8BIT
call lcdCmd
ret
; Wait until the lcd is ready to receive a command
lcdWait:
push af
.loop:
in a, (LCD_PORT_CMD)
; When 7th bit is cleared, we can send a new command
rla
jr c, .loop
pop af
ret
; Send cmd A to LCD
lcdCmd:
out (LCD_PORT_CMD), a
jr lcdWait
; Send data A to LCD
lcdDataSet:
out (LCD_PORT_DATA), a
jr lcdWait
; Get data from LCD into A
lcdDataGet:
in a, (LCD_PORT_DATA)
jr lcdWait
; Turn LCD off
lcdOff:
push af
ld a, LCD_CMD_DISABLE
call lcdCmd
out (LCD_PORT_CMD), a
pop af
ret
; Set LCD's current column to A
lcdSetCol:
push af
; The col index specified in A is compounded with LCD_CMD_COL
add a, LCD_CMD_COL
call lcdCmd
pop af
ret
; Set LCD's current row to A
lcdSetRow:
push af
; The col index specified in A is compounded with LCD_CMD_COL
add a, LCD_CMD_ROW
call lcdCmd
pop af
ret
; Send the glyph that HL points to to the LCD, at its current position.
; After having called this, the LCD's position will have advanced by one
; position
lcdSendGlyph:
push af
push bc
push hl
push ix
ld a, (LCD_CURY)
call lcdSetRow
ld a, (LCD_CURX)
srl a \ srl a \ srl a ; div by 8
call lcdSetCol
; First operation: read the LCD memory for the "left" side of the
; buffer. We assume the right side to always be empty, so we don't
; read it. After having read each line, compose it with glyph line at
; HL
; Before we start, what is our bit offset?
ld a, (LCD_CURX)
and 0b111
; that's our offset, store it in C
ld c, a
ld a, LCD_CMD_XINC
call lcdCmd
ld ix, LCD_BUF
ld b, FNT_HEIGHT
; A dummy read is needed after a movement.
call lcdDataGet
.loop1:
; let's go get that glyph data
ld a, (hl)
ld (ix), a
call .shiftIX
; now let's go get existing pixel on LCD
call lcdDataGet
; and now let's do some compositing!
or (ix)
ld (ix), a
inc hl
inc ix
djnz .loop1
; Buffer set! now let's send it.
ld a, (LCD_CURY)
call lcdSetRow
ld hl, LCD_BUF
ld b, FNT_HEIGHT
.loop2:
ld a, (hl)
call lcdDataSet
inc hl
djnz .loop2
; And finally, let's send the "right side" of the buffer
ld a, (LCD_CURY)
call lcdSetRow
ld a, (LCD_CURX)
srl a \ srl a \ srl a ; div by 8
inc a
call lcdSetCol
ld hl, LCD_BUF+FNT_HEIGHT
ld b, FNT_HEIGHT
.loop3:
ld a, (hl)
call lcdDataSet
inc hl
djnz .loop3
; Increase column and wrap if necessary
ld a, (LCD_CURX)
add a, FNT_WIDTH+1
ld (LCD_CURX), a
cp 96-FNT_WIDTH
jr c, .skip ; A < 96-FNT_WIDTH
call lcdLinefeed
.skip:
pop ix
pop hl
pop bc
pop af
ret
; Shift glyph in (IX) to the right C times, sending carry into (IX+FNT_HEIGHT)
.shiftIX:
dec c \ inc c
ret z ; zero? nothing to do
push bc ; --> lvl 1
xor a
ld (ix+FNT_HEIGHT), a
.shiftLoop:
srl (ix)
rr (ix+FNT_HEIGHT)
dec c
jr nz, .shiftLoop
pop bc ; <-- lvl 1
ret
; Changes the current line and go back to leftmost column
lcdLinefeed:
push af
ld a, (LCD_CURY)
call .addFntH
ld (LCD_CURY), a
call lcdClrLn
; Now, lets set Z offset which is CURROW+FNT_HEIGHT+1
call .addFntH
add a, LCD_CMD_ZOFFSET
call lcdCmd
xor a
ld (LCD_CURX), a
pop af
ret
.addFntH:
add a, FNT_HEIGHT+1
cp 64
ret c ; A < 64? no wrap
; we have to wrap around
xor a
ret
; Clears B rows starting at row A
; B is not preserved by this routine
lcdClrX:
push af
call lcdSetRow
.outer:
push bc ; --> lvl 1
ld b, 11
ld a, LCD_CMD_YINC
call lcdCmd
xor a
call lcdSetCol
.inner:
call lcdDataSet
djnz .inner
ld a, LCD_CMD_XINC
call lcdCmd
xor a
call lcdDataSet
pop bc ; <-- lvl 1
djnz .outer
pop af
ret
lcdClrLn:
push bc
ld b, FNT_HEIGHT+1
call lcdClrX
pop bc
ret
lcdClrScr:
push bc
ld b, 64
call lcdClrX
pop bc
ret
lcdPutC:
cp LF
jp z, lcdLinefeed
cp BS
jr z, .bs
push hl
call fntGet
jr nz, .end
call lcdSendGlyph
.end:
pop hl
ret
.bs:
ld a, (LCD_CURX)
or a
ret z ; going back one line is too complicated.
; not implemented yet
sub FNT_WIDTH+1
ld (LCD_CURX), a
ret