/* $OpenBSD: ite_rt.c,v 1.2 1996/05/02 06:44:14 niklas Exp $ */ /* $NetBSD: ite_rt.c,v 1.16 1996/04/23 22:53:12 veego Exp $ */ /* * Copyright (c) 1993 Markus Wild * Copyright (c) 1993 Lutz Vieweg * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Lutz Vieweg. * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "grfrt.h" #if NGRFRT > 0 #include <sys/param.h> #include <sys/conf.h> #include <sys/proc.h> #include <sys/device.h> #include <sys/ioctl.h> #include <sys/tty.h> #include <sys/systm.h> #include <dev/cons.h> #include <machine/cpu.h> #include <amiga/amiga/device.h> #include <amiga/dev/itevar.h> #include <amiga/dev/grfioctl.h> #include <amiga/dev/grfvar.h> #include <amiga/dev/grf_rtreg.h> int retina_console = 1; void retina_cursor __P((struct ite_softc *,int)); void retina_scroll __P((struct ite_softc *,int,int,int,int)); void retina_deinit __P((struct ite_softc *)); void retina_clear __P((struct ite_softc *,int,int,int,int)); void retina_putc __P((struct ite_softc *,int,int,int,int)); void retina_init __P((struct ite_softc *)); #ifdef RETINA_SPEED_HACK static void screen_up __P((struct ite_softc *, int, int, int)); static void screen_down __P((struct ite_softc *, int, int, int)); #endif /* * this function is called from grf_rt to init the grf_softc->g_conpri * field each time a retina is attached. */ int grfrt_cnprobe() { static int done; int rv; if (retina_console && done == 0) rv = CN_INTERNAL; else rv = CN_NORMAL; done = 1; return(rv); } /* * init the required fields in the grf_softc struct for a * grf to function as an ite. */ void grfrt_iteinit(gp) struct grf_softc *gp; { gp->g_iteinit = retina_init; gp->g_itedeinit = retina_deinit; gp->g_iteclear = retina_clear; gp->g_iteputc = retina_putc; gp->g_itescroll = retina_scroll; gp->g_itecursor = retina_cursor; } void retina_init(ip) struct ite_softc *ip; { struct MonDef *md; ip->priv = ip->grf->g_data; md = (struct MonDef *) ip->priv; ip->cols = md->TX; ip->rows = md->TY; } void retina_cursor(ip, flag) struct ite_softc *ip; int flag; { volatile caddr_t ba = ip->grf->g_regkva; if (flag == ERASE_CURSOR) { /* disable cursor */ WCrt (ba, CRT_ID_CURSOR_START, RCrt (ba, CRT_ID_CURSOR_START) | 0x20); } else { int pos = ip->curx + ip->cury * ip->cols; /* make sure to enable cursor */ WCrt (ba, CRT_ID_CURSOR_START, RCrt (ba, CRT_ID_CURSOR_START) & ~0x20); /* and position it */ WCrt (ba, CRT_ID_CURSOR_LOC_HIGH, (u_char) (pos >> 8)); WCrt (ba, CRT_ID_CURSOR_LOC_LOW, (u_char) pos); ip->cursorx = ip->curx; ip->cursory = ip->cury; } } #ifdef RETINA_SPEED_HACK static void screen_up(ip, top, bottom, lines) struct ite_softc *ip; int top; int bottom; int lines; { volatile caddr_t ba = ip->grf->g_regkva; volatile caddr_t fb = ip->grf->g_fbkva; const struct MonDef * md = (struct MonDef *) ip->priv; #ifdef BANKEDDEVPAGER int bank; #endif /* do some bounds-checking here.. */ if (top >= bottom) return; if (top + lines >= bottom) { retina_clear (ip, top, 0, bottom - top, ip->cols); return; } #ifdef BANKEDDEVPAGER /* make sure to save/restore active bank (and if it's only for tests of the feature in text-mode..) */ bank = (RSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO) | (RSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI) << 8)); #endif /* the trick here is to use a feature of the NCR chip. It can optimize data access in various read/write modes. One of the modes is able to read/write from/to different zones. Thus, by setting the read-offset to lineN, and the write-offset to line0, we just cause read/write cycles for all characters up to the last line, and have the chip transfer the data. The `addqb' are the cheapest way to cause read/write cycles (DONT use `tas' on the Amiga!), their results are completely ignored by the NCR chip, it just replicates what it just read. */ /* write to primary, read from secondary */ WSeq (ba, SEQ_ID_EXTENDED_MEM_ENA, (RSeq(ba, SEQ_ID_EXTENDED_MEM_ENA) & 0x1f) | 0 ); /* clear extended chain4 mode */ WSeq (ba, SEQ_ID_EXT_VIDEO_ADDR, RSeq(ba, SEQ_ID_EXT_VIDEO_ADDR) & ~0x02); /* set write mode 1, "[...] data in the read latches is written to memory during CPU memory write cycles. [...]" */ WGfx (ba, GCT_ID_GRAPHICS_MODE, (RGfx(ba, GCT_ID_GRAPHICS_MODE) & 0xfc) | 1); { /* write to line TOP */ long toploc = top * (md->TX / 16); WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, ((unsigned char)toploc)); WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, ((unsigned char)(toploc >> 8))); } { /* read from line TOP + LINES */ long fromloc = (top+lines) * (md->TX / 16); WSeq (ba, SEQ_ID_SEC_HOST_OFF_LO, ((unsigned char)fromloc)) ; WSeq (ba, SEQ_ID_SEC_HOST_OFF_HI, ((unsigned char)(fromloc >> 8))) ; } { caddr_t p = (caddr_t)fb; /* transfer all characters but LINES lines, unroll by 16 */ short x = (1 + bottom - (top + lines)) * (md->TX / 16) - 1; do { asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@+" : "=a" (p) : "0" (p)); } while (x--); } /* reset to default values */ WSeq (ba, SEQ_ID_SEC_HOST_OFF_HI, 0); WSeq (ba, SEQ_ID_SEC_HOST_OFF_LO, 0); WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, 0); WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, 0); /* write mode 0 */ WGfx (ba, GCT_ID_GRAPHICS_MODE, (RGfx(ba, GCT_ID_GRAPHICS_MODE) & 0xfc) | 0); /* extended chain4 enable */ WSeq (ba, SEQ_ID_EXT_VIDEO_ADDR, RSeq(ba, SEQ_ID_EXT_VIDEO_ADDR) | 0x02); /* read/write to primary on A0, secondary on B0 */ WSeq (ba, SEQ_ID_EXTENDED_MEM_ENA, (RSeq(ba, SEQ_ID_EXTENDED_MEM_ENA) & 0x1f) | 0x40); /* fill the free lines with spaces */ { /* feed latches with value */ unsigned short * f = (unsigned short *) fb; f += (1 + bottom - lines) * md->TX * 2; *f = 0x2010; } /* clear extended chain4 mode */ WSeq (ba, SEQ_ID_EXT_VIDEO_ADDR, RSeq(ba, SEQ_ID_EXT_VIDEO_ADDR) & ~0x02); /* set write mode 1, "[...] data in the read latches is written to memory during CPU memory write cycles. [...]" */ WGfx (ba, GCT_ID_GRAPHICS_MODE, (RGfx(ba, GCT_ID_GRAPHICS_MODE) & 0xfc) | 1); { unsigned long * p = (unsigned long *) fb; short x = (lines * (md->TX/16)) - 1; const unsigned long dummyval = 0; p += (1 + bottom - lines) * (md->TX/4); do { *p++ = dummyval; *p++ = dummyval; *p++ = dummyval; *p++ = dummyval; } while (x--); } /* write mode 0 */ WGfx (ba, GCT_ID_GRAPHICS_MODE, (RGfx(ba, GCT_ID_GRAPHICS_MODE) & 0xfc) | 0); /* extended chain4 enable */ WSeq (ba, SEQ_ID_EXT_VIDEO_ADDR , RSeq(ba, SEQ_ID_EXT_VIDEO_ADDR) | 0x02); #ifdef BANKEDDEVPAGER /* restore former bank */ WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, (unsigned char) bank); bank >>= 8; WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, (unsigned char) bank); #endif }; static void screen_down(ip, top, bottom, lines) struct ite_softc *ip; int top; int bottom; int lines; { volatile caddr_t ba = ip->grf->g_regkva; volatile caddr_t fb = ip->grf->g_fbkva; const struct MonDef * md = (struct MonDef *) ip->priv; #ifdef BANKEDDEVPAGER int bank; #endif /* do some bounds-checking here.. */ if (top >= bottom) return; if (top + lines >= bottom) { retina_clear (ip, top, 0, bottom - top, ip->cols); return; } #ifdef BANKEDDEVPAGER /* make sure to save/restore active bank (and if it's only for tests of the feature in text-mode..) */ bank = (RSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO) | (RSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI) << 8)); #endif /* see screen_up() for explanation of chip-tricks */ /* write to primary, read from secondary */ WSeq (ba, SEQ_ID_EXTENDED_MEM_ENA, (RSeq(ba, SEQ_ID_EXTENDED_MEM_ENA) & 0x1f) | 0 ); /* clear extended chain4 mode */ WSeq (ba, SEQ_ID_EXT_VIDEO_ADDR, RSeq(ba, SEQ_ID_EXT_VIDEO_ADDR) & ~0x02); /* set write mode 1, "[...] data in the read latches is written to memory during CPU memory write cycles. [...]" */ WGfx (ba, GCT_ID_GRAPHICS_MODE, (RGfx(ba, GCT_ID_GRAPHICS_MODE) & 0xfc) | 1); { /* write to line TOP + LINES */ long toloc = (top + lines) * (md->TX / 16); WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, ((unsigned char)toloc)); WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, ((unsigned char)(toloc >> 8))); } { /* read from line TOP */ long fromloc = top * (md->TX / 16); WSeq (ba, SEQ_ID_SEC_HOST_OFF_LO, ((unsigned char)fromloc)); WSeq (ba, SEQ_ID_SEC_HOST_OFF_HI, ((unsigned char)(fromloc >> 8))) ; } { caddr_t p = (caddr_t)fb; short x = (1 + bottom - (top + lines)) * (md->TX / 16) - 1; p += (1 + bottom - (top + lines)) * md->TX; do { asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); asm volatile("addqb #1,%0@-" : "=a" (p) : "0" (p)); } while (x--); } WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, 0); WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, 0); WSeq (ba, SEQ_ID_SEC_HOST_OFF_HI, 0); WSeq (ba, SEQ_ID_SEC_HOST_OFF_LO, 0); /* write mode 0 */ WGfx (ba, GCT_ID_GRAPHICS_MODE, (RGfx(ba, GCT_ID_GRAPHICS_MODE) & 0xfc) | 0); /* extended chain4 enable */ WSeq (ba, SEQ_ID_EXT_VIDEO_ADDR , RSeq(ba, SEQ_ID_EXT_VIDEO_ADDR) | 0x02); /* read/write to primary on A0, secondary on B0 */ WSeq (ba, SEQ_ID_EXTENDED_MEM_ENA, (RSeq(ba, SEQ_ID_EXTENDED_MEM_ENA) & 0x1f) | 0x40 ); /* fill the free lines with spaces */ { /* feed latches with value */ unsigned short * f = (unsigned short *) fb; f += top * md->TX * 2; *f = 0x2010; } /* clear extended chain4 mode */ WSeq (ba, SEQ_ID_EXT_VIDEO_ADDR, RSeq(ba, SEQ_ID_EXT_VIDEO_ADDR) & ~0x02); /* set write mode 1, "[...] data in the read latches is written to memory during CPU memory write cycles. [...]" */ WGfx (ba, GCT_ID_GRAPHICS_MODE, (RGfx(ba, GCT_ID_GRAPHICS_MODE) & 0xfc) | 1); { unsigned long * p = (unsigned long *) fb; short x = (lines * (md->TX/16)) - 1; const unsigned long dummyval = 0; p += top * (md->TX/4); do { *p++ = dummyval; *p++ = dummyval; *p++ = dummyval; *p++ = dummyval; } while (x--); } /* write mode 0 */ WGfx (ba, GCT_ID_GRAPHICS_MODE, (RGfx(ba, GCT_ID_GRAPHICS_MODE) & 0xfc) | 0); /* extended chain4 enable */ WSeq (ba, SEQ_ID_EXT_VIDEO_ADDR , RSeq(ba, SEQ_ID_EXT_VIDEO_ADDR) | 0x02); #ifdef BANKEDDEVPAGER /* restore former bank */ WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, (unsigned char) bank); bank >>= 8; WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, (unsigned char) bank); #endif }; #endif /* RETINA_SPEED_HACK */ void retina_deinit(ip) struct ite_softc *ip; { ip->flags &= ~ITE_INITED; } void retina_putc(ip, c, dy, dx, mode) struct ite_softc *ip; int c; int dy; int dx; int mode; { volatile caddr_t fb = ip->grf->g_fbkva; register u_char attr; attr = (mode & ATTR_INV) ? 0x21 : 0x10; if (mode & ATTR_UL) attr = 0x01; /* ???????? */ if (mode & ATTR_BOLD) attr |= 0x08; if (mode & ATTR_BLINK) attr |= 0x80; fb += 4 * (dy * ip->cols + dx); *fb++ = c; *fb = attr; } void retina_clear(ip, sy, sx, h, w) struct ite_softc *ip; int sy; int sx; int h; int w; { u_short * fb = (u_short *) ip->grf->g_fbkva; short x; const u_short fillval = 0x2010; /* could probably be optimized just like the scrolling functions !! */ fb += 2 * (sy * ip->cols + sx); while (h--) { for (x = 2 * (w - 1); x >= 0; x -= 2) fb[x] = fillval; fb += 2 * ip->cols; } } /* * RETINA_SPEED_HACK code seems to work on some boards and on others * it causes text to smear horizontally */ void retina_scroll(ip, sy, sx, count, dir) struct ite_softc *ip; int sy; int sx; int count; int dir; { volatile caddr_t ba; u_long *fb; ba = ip->grf->g_regkva; fb = (u_long *)ip->grf->g_fbkva; retina_cursor(ip, ERASE_CURSOR); if (dir == SCROLL_UP) { #ifdef RETINA_SPEED_HACK screen_up(ip, sy - count, ip->bottom_margin, count); #else bcopy(fb + sy * ip->cols, fb + (sy - count) * ip->cols, 4 * (ip->bottom_margin - sy + 1) * ip->cols); retina_clear(ip, ip->bottom_margin + 1 - count, 0, count, ip->cols); #endif } else if (dir == SCROLL_DOWN) { #ifdef RETINA_SPEED_HACK screen_down(ip, sy, ip->bottom_margin, count); #else bcopy(fb + sy * ip->cols, fb + (sy + count) * ip->cols, 4 * (ip->bottom_margin - sy - count + 1) * ip->cols); retina_clear(ip, sy, 0, count, ip->cols); #endif } else if (dir == SCROLL_RIGHT) { bcopy(fb + sx + sy * ip->cols, fb + sx + sy * ip->cols + count, 4 * (ip->cols - (sx + count))); retina_clear(ip, sy, sx, 1, count); } else { bcopy(fb + sx + sy * ip->cols, fb + sx - count + sy * ip->cols, 4 * (ip->cols - sx)); retina_clear(ip, sy, ip->cols - count, 1, count); } #ifndef RETINA_SPEED_HACK retina_cursor(ip, !ERASE_CURSOR); #endif } #endif /* NGRFRT */