/* $NetBSD: lcspx.c,v 1.2 2004/03/19 20:12:07 mhitch Exp $ */ /* * Copyright (c) 1998 Ludd, University of Lule}, Sweden. * 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 at Ludd, University of * Lule}, Sweden and its contributors. * 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 __KERNEL_RCSID(0, "$NetBSD: lcspx.c,v 1.2 2004/03/19 20:12:07 mhitch Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "machine/scb.h" #include "dzkbd.h" #include "opt_wsfont.h" /* Safety guard */ #ifndef FONT_QVSS8x15 #include #endif /* Screen hardware defs */ #define SPX_COLS 160 /* char width of screen */ #define SPX_ROWS 68 /* rows of char on screen */ #define SPX_CHEIGHT 15 /* lines a char consists of */ #define SPX_CWIDTH 8 /* cols a char consists of */ #define SPX_NEXTROW (SPX_COLS * SPX_CHEIGHT * SPX_CWIDTH) #define SPX_YWIDTH 1024 #define SPX_XWIDTH 1280 #define SPXADDR 0x38000000 /* Frame buffer */ #define SPXSIZE 0x00800000 /* 8MB in size */ static int lcspx_match(struct device *, struct cfdata *, void *); static void lcspx_attach(struct device *, struct device *, void *); struct lcspx_softc { struct device ss_dev; }; CFATTACH_DECL(lcspx, sizeof(struct lcspx_softc), lcspx_match, lcspx_attach, NULL, NULL); static void lcspx_cursor(void *, int, int, int); static int lcspx_mapchar(void *, int, unsigned int *); static void lcspx_putchar(void *, int, int, u_int, long); static void lcspx_copycols(void *, int, int, int,int); static void lcspx_erasecols(void *, int, int, int, long); static void lcspx_copyrows(void *, int, int, int); static void lcspx_eraserows(void *, int, int, long); static int lcspx_allocattr(void *, int, int, int, long *); const struct wsdisplay_emulops lcspx_emulops = { lcspx_cursor, lcspx_mapchar, lcspx_putchar, lcspx_copycols, lcspx_erasecols, lcspx_copyrows, lcspx_eraserows, lcspx_allocattr }; const struct wsscreen_descr lcspx_stdscreen = { "160x68", SPX_COLS, SPX_ROWS, &lcspx_emulops, 8, SPX_CHEIGHT, WSSCREEN_UNDERLINE|WSSCREEN_REVERSE, }; const struct wsscreen_descr *_lcspx_scrlist[] = { &lcspx_stdscreen, }; const struct wsscreen_list lcspx_screenlist = { sizeof(_lcspx_scrlist) / sizeof(struct wsscreen_descr *), _lcspx_scrlist, }; static char *lcspxaddr; extern struct wsdisplay_font qvss8x15; static u_char *qf; #define QCHAR(c) (c < 32 ? 32 : (c > 127 ? c - 66 : c - 32)) #define QFONT(c,line) qf[QCHAR(c) * 15 + line] #define SPX_ADDR(row, col, line, dot) \ lcspxaddr[(col * SPX_CWIDTH) + (row * SPX_CHEIGHT * SPX_XWIDTH) + \ line * SPX_XWIDTH + dot] static int lcspx_ioctl(void *, u_long, caddr_t, int, struct proc *); static paddr_t lcspx_mmap(void *, off_t, int); static int lcspx_alloc_screen(void *, const struct wsscreen_descr *, void **, int *, int *, long *); static void lcspx_free_screen(void *, void *); static int lcspx_show_screen(void *, void *, int, void (*) (void *, int, int), void *); static void lcspx_crsr_blink(void *); const struct wsdisplay_accessops lcspx_accessops = { lcspx_ioctl, lcspx_mmap, lcspx_alloc_screen, lcspx_free_screen, lcspx_show_screen, 0 /* load_font */ }; struct lcspx_screen { int ss_curx; int ss_cury; u_char ss_image[SPX_ROWS][SPX_COLS]; /* Image of current screen */ u_char ss_attr[SPX_ROWS][SPX_COLS]; /* Reversed etc... */ }; static struct lcspx_screen lcspx_conscreen; static struct lcspx_screen *curscr; static struct callout lcspx_cursor_ch = CALLOUT_INITIALIZER; int lcspx_match(struct device *parent, struct cfdata *match, void *aux) { struct vsbus_softc *sc = (void *)parent; struct vsbus_attach_args *va = aux; char *ch = (char *)va->va_addr; if (vax_boardtype != VAX_BTYP_49) return 0; *ch = 1; if ((*ch & 1) == 0) return 0; *ch = 0; if ((*ch & 1) != 0) return 0; sc->sc_mask = 0x04; /* XXX - should be generated */ scb_fake(0x120, 0x15); return 20; } void lcspx_attach(struct device *parent, struct device *self, void *aux) { struct vsbus_attach_args *va = aux; struct wsemuldisplaydev_attach_args aa; printf("\n"); aa.console = lcspxaddr != NULL; if (lcspxaddr == 0) lcspxaddr = (caddr_t)vax_map_physmem(va->va_paddr, (SPXSIZE/VAX_NBPG)); if (lcspxaddr == 0) { printf("%s: Couldn't alloc graphics memory.\n", self->dv_xname); return; } curscr = &lcspx_conscreen; aa.scrdata = &lcspx_screenlist; aa.accessops = &lcspx_accessops; qf = qvss8x15.data; /* enable software cursor */ callout_reset(&lcspx_cursor_ch, hz / 2, lcspx_crsr_blink, NULL); config_found(self, &aa, wsemuldisplaydevprint); } static char *cursor; static int cur_on; static void lcspx_crsr_blink(void *arg) { int i; if (cur_on) for (i = 0; i < 8; ++i) cursor[i] ^= 255; callout_reset(&lcspx_cursor_ch, hz / 2, lcspx_crsr_blink, NULL); } void lcspx_cursor(void *id, int on, int row, int col) { struct lcspx_screen *ss = id; int i; if (ss == curscr) { char ch = QFONT(ss->ss_image[ss->ss_cury][ss->ss_curx], 14); if (cursor != NULL) for (i = 0; i < 8; i++) cursor[i] = (ch >> i) & 1; cursor = &SPX_ADDR(row, col, 14, 0); if ((cur_on = on)) for (i = 0; i < 8; i++) cursor[i] ^= cursor[i]; } ss->ss_curx = col; ss->ss_cury = row; } int lcspx_mapchar(void *id, int uni, unsigned int *index) { if (uni < 256) { *index = uni; return (5); } *index = ' '; return (0); } static void lcspx_putchar(void *id, int row, int col, u_int c, long attr) { struct lcspx_screen *ss = id; int i, j; c &= 0xff; ss->ss_image[row][col] = c; ss->ss_attr[row][col] = attr; if (ss != curscr) return; for (i = 0; i < 15; i++) { unsigned char ch = QFONT(c, i); char dot; for (j = 0; j < 8; j++) { dot = (ch >> j) & 1; if (attr & WSATTR_REVERSE) dot = (~dot) & 1; SPX_ADDR(row, col, i, j) = dot; } } if (attr & WSATTR_UNDERLINE) { char *p = &SPX_ADDR(row, col, i, 0); for (i = 0; i < 8; i++) p[i] = ~p[i]; } } /* * copies columns inside a row. */ static void lcspx_copycols(void *id, int row, int srccol, int dstcol, int ncols) { struct lcspx_screen *ss = id; int i; bcopy(&ss->ss_image[row][srccol], &ss->ss_image[row][dstcol], ncols); bcopy(&ss->ss_attr[row][srccol], &ss->ss_attr[row][dstcol], ncols); if (ss != curscr) return; for (i = 0; i < SPX_CHEIGHT; i++) memcpy(&SPX_ADDR(row, dstcol, i, 0), &SPX_ADDR(row,srccol, i, 0), ncols * SPX_CWIDTH); } /* * Erases a bunch of chars inside one row. */ static void lcspx_erasecols(void *id, int row, int startcol, int ncols, long fillattr) { struct lcspx_screen *ss = id; int i; bzero(&ss->ss_image[row][startcol], ncols); bzero(&ss->ss_attr[row][startcol], ncols); if (ss != curscr) return; for (i = 0; i < SPX_CHEIGHT; i++) memset(&SPX_ADDR(row, startcol, i, 0), 0, ncols * SPX_CWIDTH); } static void lcspx_copyrows(void *id, int srcrow, int dstrow, int nrows) { struct lcspx_screen *ss = id; bcopy(&ss->ss_image[srcrow][0], &ss->ss_image[dstrow][0], nrows * SPX_COLS); bcopy(&ss->ss_attr[srcrow][0], &ss->ss_attr[dstrow][0], nrows * SPX_COLS); if (ss != curscr) return; memcpy(&lcspxaddr[dstrow * SPX_NEXTROW], &lcspxaddr[srcrow * SPX_NEXTROW], nrows * SPX_NEXTROW); } static void lcspx_eraserows(void *id, int startrow, int nrows, long fillattr) { struct lcspx_screen *ss = id; bzero(&ss->ss_image[startrow][0], nrows * SPX_COLS); bzero(&ss->ss_attr[startrow][0], nrows * SPX_COLS); if (ss != curscr) return; memset(&lcspxaddr[startrow * SPX_NEXTROW], 0, nrows * SPX_NEXTROW); } static int lcspx_allocattr(void *id, int fg, int bg, int flags, long *attrp) { *attrp = flags; return 0; } int lcspx_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p) { struct wsdisplay_fbinfo *fb = (void *)data; switch (cmd) { case WSDISPLAYIO_GTYPE: *(u_int *)data = WSDISPLAY_TYPE_SPX; break; case WSDISPLAYIO_GINFO: fb->height = SPX_YWIDTH; fb->width = SPX_XWIDTH; fb->depth = 1; fb->cmsize = 2; break; #if 0 case WSDISPLAYIO_SVIDEO: if (*(u_int *)data == WSDISPLAYIO_VIDEO_ON) { curcmd = curc; } else { curc = curcmd; curcmd &= ~(CUR_CMD_FOPA|CUR_CMD_ENPA); curcmd |= CUR_CMD_FOPB; } WRITECUR(CUR_CMD, curcmd); break; case WSDISPLAYIO_GVIDEO: *(u_int *)data = (curcmd & CUR_CMD_FOPB ? WSDISPLAYIO_VIDEO_OFF : WSDISPLAYIO_VIDEO_ON); break; #endif default: return EPASSTHROUGH; } return 0; } static paddr_t lcspx_mmap(void *v, off_t offset, int prot) { if (offset >= SPXSIZE || offset < 0) return -1; return (SPXADDR + offset) >> PGSHIFT; } int lcspx_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep, int *curxp, int *curyp, long *defattrp) { *cookiep = malloc(sizeof(struct lcspx_screen), M_DEVBUF, M_WAITOK); bzero(*cookiep, sizeof(struct lcspx_screen)); *curxp = *curyp = *defattrp = 0; return 0; } void lcspx_free_screen(void *v, void *cookie) { } int lcspx_show_screen(void *v, void *cookie, int waitok, void (*cb)(void *, int, int), void *cbarg) { struct lcspx_screen *ss = cookie; int row, col, line; if (ss == curscr) return (0); for (row = 0; row < SPX_ROWS; row++) for (line = 0; line < SPX_CHEIGHT; line++) { for (col = 0; col < SPX_COLS; col++) { u_char s, c = ss->ss_image[row][col]; if (c < 32) c = 32; s = QFONT(c, line); if (ss->ss_attr[row][col] & WSATTR_REVERSE) s ^= 255; SPX_ADDR(row, col, line, 0) = s; } if (ss->ss_attr[row][col] & WSATTR_UNDERLINE) SPX_ADDR(row, col, line, 0) = 255; } cursor = &lcspxaddr[(ss->ss_cury * SPX_CHEIGHT * SPX_COLS) + ss->ss_curx + ((SPX_CHEIGHT - 1) * SPX_COLS)]; curscr = ss; return (0); } cons_decl(lcspx); void lcspxcninit(struct consdev *cndev) { /* Clear screen */ memset(lcspxaddr, 0, SPX_XWIDTH * SPX_YWIDTH); curscr = &lcspx_conscreen; wsdisplay_cnattach(&lcspx_stdscreen, &lcspx_conscreen, 0, 0, 0); cn_tab->cn_pri = CN_INTERNAL; qf = qvss8x15.data; #if NDZKBD > 0 dzkbd_cnattach(0); /* Connect keyboard and screen together */ #endif } /* * Called very early to setup the glass tty as console. * Because it's called before the VM system is inited, virtual memory * for the framebuffer can be stolen directly without disturbing anything. */ void lcspxcnprobe(struct consdev *cndev) { extern vaddr_t virtual_avail; extern const struct cdevsw wsdisplay_cdevsw; if (vax_boardtype != VAX_BTYP_49) return; /* Only for 4000/90 */ if (vax_confdata & 8) return; /* Diagnostic console */ lcspxaddr = (caddr_t)virtual_avail; virtual_avail += SPXSIZE; ioaccess((vaddr_t)lcspxaddr, SPXADDR, (SPXSIZE/VAX_NBPG)); cndev->cn_pri = CN_INTERNAL; cndev->cn_dev = makedev(cdevsw_lookup_major(&wsdisplay_cdevsw), 0); }