Home | History | Annotate | Line # | Download | only in vsa
smg.c revision 1.9
      1  1.9       mrg /*	$NetBSD: smg.c,v 1.9 1998/11/19 15:38:25 mrg Exp $ */
      2  1.1     ragge /*
      3  1.1     ragge  * Copyright (c) 1998 Ludd, University of Lule}, Sweden.
      4  1.1     ragge  * All rights reserved.
      5  1.1     ragge  *
      6  1.1     ragge  * Redistribution and use in source and binary forms, with or without
      7  1.1     ragge  * modification, are permitted provided that the following conditions
      8  1.1     ragge  * are met:
      9  1.1     ragge  * 1. Redistributions of source code must retain the above copyright
     10  1.1     ragge  *    notice, this list of conditions and the following disclaimer.
     11  1.1     ragge  * 2. Redistributions in binary form must reproduce the above copyright
     12  1.1     ragge  *    notice, this list of conditions and the following disclaimer in the
     13  1.1     ragge  *    documentation and/or other materials provided with the distribution.
     14  1.1     ragge  * 3. All advertising materials mentioning features or use of this software
     15  1.1     ragge  *    must display the following acknowledgement:
     16  1.6     ragge  *	This product includes software developed at Ludd, University of
     17  1.6     ragge  *	Lule}, Sweden and its contributors.
     18  1.1     ragge  * 4. The name of the author may not be used to endorse or promote products
     19  1.1     ragge  *    derived from this software without specific prior written permission
     20  1.1     ragge  *
     21  1.1     ragge  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     22  1.1     ragge  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     23  1.1     ragge  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     24  1.1     ragge  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     25  1.1     ragge  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     26  1.1     ragge  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     27  1.1     ragge  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     28  1.1     ragge  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     29  1.1     ragge  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     30  1.1     ragge  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     31  1.1     ragge  */
     32  1.1     ragge 
     33  1.1     ragge #include <sys/param.h>
     34  1.1     ragge #include <sys/device.h>
     35  1.1     ragge #include <sys/systm.h>
     36  1.1     ragge #include <sys/time.h>
     37  1.1     ragge #include <sys/malloc.h>
     38  1.1     ragge #include <sys/conf.h>
     39  1.6     ragge #include <sys/kernel.h>
     40  1.1     ragge 
     41  1.1     ragge #include <dev/cons.h>
     42  1.1     ragge 
     43  1.1     ragge #include <dev/wscons/wsdisplayvar.h>
     44  1.1     ragge #include <dev/wscons/wsconsio.h>
     45  1.1     ragge #include <dev/wscons/wscons_callbacks.h>
     46  1.1     ragge 
     47  1.1     ragge #include <machine/vsbus.h>
     48  1.1     ragge #include <machine/sid.h>
     49  1.1     ragge 
     50  1.1     ragge #include "lkc.h"
     51  1.1     ragge 
     52  1.6     ragge #define SM_COLS		128	/* char width of screen */
     53  1.6     ragge #define SM_ROWS		57	/* rows of char on screen */
     54  1.6     ragge #define SM_CHEIGHT	15	/* lines a char consists of */
     55  1.6     ragge #define SM_NEXTROW	(SM_COLS * SM_CHEIGHT)
     56  1.1     ragge 
     57  1.1     ragge static	int smg_match __P((struct device *, struct cfdata *, void *));
     58  1.1     ragge static	void smg_attach __P((struct device *, struct device *, void *));
     59  1.1     ragge 
     60  1.1     ragge struct	smg_softc {
     61  1.1     ragge 	struct	device ss_dev;
     62  1.1     ragge };
     63  1.1     ragge 
     64  1.1     ragge struct cfattach smg_ca = {
     65  1.1     ragge 	sizeof(struct smg_softc), smg_match, smg_attach,
     66  1.1     ragge };
     67  1.1     ragge 
     68  1.1     ragge static void	smg_cursor __P((void *, int, int, int));
     69  1.5  drochner unsigned int	smg_mapchar __P((void *, int));
     70  1.4  drochner static void	smg_putchar __P((void *, int, int, u_int, long));
     71  1.1     ragge static void	smg_copycols __P((void *, int, int, int,int));
     72  1.1     ragge static void	smg_erasecols __P((void *, int, int, int, long));
     73  1.1     ragge static void	smg_copyrows __P((void *, int, int, int));
     74  1.1     ragge static void	smg_eraserows __P((void *, int, int, long));
     75  1.1     ragge static int	smg_alloc_attr __P((void *, int, int, int, long *));
     76  1.1     ragge 
     77  1.1     ragge const struct wsdisplay_emulops smg_emulops = {
     78  1.1     ragge 	smg_cursor,
     79  1.5  drochner 	smg_mapchar,
     80  1.4  drochner 	smg_putchar,
     81  1.1     ragge 	smg_copycols,
     82  1.1     ragge 	smg_erasecols,
     83  1.1     ragge 	smg_copyrows,
     84  1.1     ragge 	smg_eraserows,
     85  1.1     ragge 	smg_alloc_attr
     86  1.1     ragge };
     87  1.1     ragge 
     88  1.1     ragge const struct wsscreen_descr smg_stdscreen = {
     89  1.6     ragge 	"128x57", SM_COLS, SM_ROWS,
     90  1.6     ragge 	&smg_emulops,
     91  1.6     ragge 	8, SM_CHEIGHT,
     92  1.6     ragge 	WSSCREEN_UNDERLINE|WSSCREEN_REVERSE,
     93  1.1     ragge };
     94  1.1     ragge 
     95  1.1     ragge const struct wsscreen_descr *_smg_scrlist[] = {
     96  1.1     ragge 	&smg_stdscreen,
     97  1.1     ragge };
     98  1.1     ragge 
     99  1.1     ragge const struct wsscreen_list smg_screenlist = {
    100  1.1     ragge 	sizeof(_smg_scrlist) / sizeof(struct wsscreen_descr *),
    101  1.1     ragge 	_smg_scrlist,
    102  1.1     ragge };
    103  1.1     ragge 
    104  1.6     ragge extern char q_font[];
    105  1.6     ragge #define QCHAR(c) (c < 32 ? 32 : (c > 127 ? c - 66 : c - 32))
    106  1.6     ragge #define QFONT(c,line)	q_font[QCHAR(c) * 15 + line]
    107  1.6     ragge #define	SM_ADDR(row, col, line) \
    108  1.6     ragge 	sm_addr[col + (row * SM_CHEIGHT * SM_COLS) + line * SM_COLS]
    109  1.6     ragge 
    110  1.6     ragge 
    111  1.1     ragge static int	smg_ioctl __P((void *, u_long, caddr_t, int, struct proc *));
    112  1.1     ragge static int	smg_mmap __P((void *, off_t, int));
    113  1.1     ragge static int	smg_alloc_screen __P((void *, const struct wsscreen_descr *,
    114  1.6     ragge 				      void **, int *, int *, long *));
    115  1.1     ragge static void	smg_free_screen __P((void *, void *));
    116  1.1     ragge static void	smg_show_screen __P((void *, void *));
    117  1.1     ragge static int	smg_load_font __P((void *, void *, int, int, int, void *));
    118  1.6     ragge static void	smg_crsr_blink __P((void *));
    119  1.1     ragge 
    120  1.1     ragge const struct wsdisplay_accessops smg_accessops = {
    121  1.1     ragge 	smg_ioctl,
    122  1.1     ragge 	smg_mmap,
    123  1.1     ragge 	smg_alloc_screen,
    124  1.1     ragge 	smg_free_screen,
    125  1.1     ragge 	smg_show_screen,
    126  1.1     ragge 	smg_load_font
    127  1.1     ragge };
    128  1.1     ragge 
    129  1.1     ragge struct	smg_screen {
    130  1.1     ragge 	int	ss_curx;
    131  1.1     ragge 	int	ss_cury;
    132  1.2     ragge 	u_char	ss_image[SM_ROWS][SM_COLS];	/* Image of current screen */
    133  1.6     ragge 	u_char	ss_attr[SM_ROWS][SM_COLS];	/* Reversed etc... */
    134  1.1     ragge };
    135  1.1     ragge 
    136  1.2     ragge static	struct smg_screen smg_conscreen;
    137  1.2     ragge static	struct smg_screen *curscr;
    138  1.1     ragge 
    139  1.1     ragge int
    140  1.1     ragge smg_match(parent, match, aux)
    141  1.1     ragge 	struct device *parent;
    142  1.1     ragge 	struct cfdata *match;
    143  1.1     ragge 	void *aux;
    144  1.1     ragge {
    145  1.6     ragge 	struct	vsbus_attach_args *va = aux;
    146  1.1     ragge 
    147  1.8     ragge 	if (va->va_type != inr_vf)
    148  1.1     ragge 		return 0;
    149  1.1     ragge #ifdef DIAGNOSTIC
    150  1.1     ragge 	if (sm_addr == 0)
    151  1.1     ragge 		panic("smg: inconsistency in smg address mapping");
    152  1.1     ragge #endif
    153  1.1     ragge 	return 1;
    154  1.1     ragge }
    155  1.1     ragge 
    156  1.1     ragge void
    157  1.1     ragge smg_attach(parent, self, aux)
    158  1.1     ragge 	struct device *parent, *self;
    159  1.1     ragge 	void *aux;
    160  1.1     ragge {
    161  1.1     ragge 	struct wsemuldisplaydev_attach_args aa;
    162  1.1     ragge 
    163  1.1     ragge 	printf("\n");
    164  1.2     ragge 	curscr = &smg_conscreen;
    165  1.1     ragge 	aa.console = !(vax_confdata & 0x20);
    166  1.1     ragge 	aa.scrdata = &smg_screenlist;
    167  1.1     ragge 	aa.accessops = &smg_accessops;
    168  1.6     ragge 	timeout(smg_crsr_blink, 0, hz/2);
    169  1.1     ragge 
    170  1.1     ragge 	config_found(self, &aa, wsemuldisplaydevprint);
    171  1.1     ragge }
    172  1.1     ragge 
    173  1.6     ragge static	u_char *cursor;
    174  1.6     ragge static	int cur_on;
    175  1.6     ragge 
    176  1.6     ragge static void
    177  1.6     ragge smg_crsr_blink(arg)
    178  1.6     ragge 	void *arg;
    179  1.6     ragge {
    180  1.6     ragge 	if (cur_on)
    181  1.6     ragge 		*cursor ^= 255;
    182  1.6     ragge 	timeout(smg_crsr_blink, 0, hz/2);
    183  1.6     ragge }
    184  1.6     ragge 
    185  1.1     ragge void
    186  1.1     ragge smg_cursor(id, on, row, col)
    187  1.1     ragge 	void *id;
    188  1.1     ragge 	int on, row, col;
    189  1.1     ragge {
    190  1.2     ragge 	struct smg_screen *ss = id;
    191  1.2     ragge 
    192  1.6     ragge 	if (ss == curscr) {
    193  1.6     ragge 		SM_ADDR(ss->ss_cury, ss->ss_curx, 14) =
    194  1.6     ragge 		    QFONT(ss->ss_image[ss->ss_cury][ss->ss_curx], 14);
    195  1.6     ragge 		cursor = &SM_ADDR(row, col, 14);
    196  1.6     ragge 		if ((cur_on = on))
    197  1.6     ragge 			*cursor ^= 255;
    198  1.6     ragge 	}
    199  1.2     ragge 	ss->ss_curx = col;
    200  1.2     ragge 	ss->ss_cury = row;
    201  1.5  drochner }
    202  1.5  drochner 
    203  1.5  drochner unsigned int
    204  1.5  drochner smg_mapchar(id, uni)
    205  1.5  drochner 	void *id;
    206  1.5  drochner 	int uni;
    207  1.5  drochner {
    208  1.5  drochner 	if (uni < 256)
    209  1.5  drochner 		return (uni);
    210  1.5  drochner 	return (0);
    211  1.1     ragge }
    212  1.1     ragge 
    213  1.1     ragge static void
    214  1.4  drochner smg_putchar(id, row, col, c, attr)
    215  1.1     ragge 	void *id;
    216  1.1     ragge 	int row, col;
    217  1.4  drochner 	u_int c;
    218  1.1     ragge 	long attr;
    219  1.1     ragge {
    220  1.2     ragge 	struct smg_screen *ss = id;
    221  1.4  drochner 	int i;
    222  1.1     ragge 
    223  1.4  drochner 	c &= 0xff;
    224  1.4  drochner 
    225  1.4  drochner 	ss->ss_image[row][col] = c;
    226  1.6     ragge 	ss->ss_attr[row][col] = attr;
    227  1.2     ragge 	if (ss != curscr)
    228  1.2     ragge 		return;
    229  1.6     ragge 	for (i = 0; i < 15; i++) {
    230  1.6     ragge 		unsigned char ch = QFONT(c, i);
    231  1.6     ragge 
    232  1.6     ragge 		SM_ADDR(row, col, i) = (attr & WSATTR_REVERSE ? ~ch : ch);
    233  1.6     ragge 
    234  1.6     ragge 	}
    235  1.6     ragge 	if (attr & WSATTR_UNDERLINE)
    236  1.6     ragge 		SM_ADDR(row, col, 14) ^= SM_ADDR(row, col, 14);
    237  1.1     ragge }
    238  1.1     ragge 
    239  1.1     ragge /*
    240  1.1     ragge  * copies columns inside a row.
    241  1.1     ragge  */
    242  1.1     ragge static void
    243  1.1     ragge smg_copycols(id, row, srccol, dstcol, ncols)
    244  1.1     ragge 	void *id;
    245  1.1     ragge 	int row, srccol, dstcol, ncols;
    246  1.1     ragge {
    247  1.2     ragge 	struct smg_screen *ss = id;
    248  1.1     ragge 	int i;
    249  1.1     ragge 
    250  1.2     ragge 	bcopy(&ss->ss_image[row][srccol], &ss->ss_image[row][dstcol], ncols);
    251  1.6     ragge 	bcopy(&ss->ss_attr[row][srccol], &ss->ss_attr[row][dstcol], ncols);
    252  1.2     ragge 	if (ss != curscr)
    253  1.2     ragge 		return;
    254  1.1     ragge 	for (i = 0; i < SM_CHEIGHT; i++)
    255  1.6     ragge 		bcopy(&SM_ADDR(row,srccol, i), &SM_ADDR(row, dstcol, i),ncols);
    256  1.1     ragge }
    257  1.1     ragge 
    258  1.1     ragge /*
    259  1.1     ragge  * Erases a bunch of chars inside one row.
    260  1.1     ragge  */
    261  1.1     ragge static void
    262  1.1     ragge smg_erasecols(id, row, startcol, ncols, fillattr)
    263  1.1     ragge 	void *id;
    264  1.1     ragge 	int row, startcol, ncols;
    265  1.1     ragge 	long fillattr;
    266  1.1     ragge {
    267  1.2     ragge 	struct smg_screen *ss = id;
    268  1.1     ragge 	int i;
    269  1.1     ragge 
    270  1.2     ragge 	bzero(&ss->ss_image[row][startcol], ncols);
    271  1.6     ragge 	bzero(&ss->ss_attr[row][startcol], ncols);
    272  1.2     ragge 	if (ss != curscr)
    273  1.2     ragge 		return;
    274  1.1     ragge 	for (i = 0; i < SM_CHEIGHT; i++)
    275  1.6     ragge 		bzero(&SM_ADDR(row, startcol, i), ncols);
    276  1.1     ragge }
    277  1.1     ragge 
    278  1.1     ragge static void
    279  1.1     ragge smg_copyrows(id, srcrow, dstrow, nrows)
    280  1.1     ragge 	void *id;
    281  1.1     ragge 	int srcrow, dstrow, nrows;
    282  1.1     ragge {
    283  1.2     ragge 	struct smg_screen *ss = id;
    284  1.1     ragge 	int frows;
    285  1.1     ragge 
    286  1.6     ragge 	bcopy(&ss->ss_image[srcrow][0], &ss->ss_image[dstrow][0],
    287  1.6     ragge 	    nrows * SM_COLS);
    288  1.6     ragge 	bcopy(&ss->ss_attr[srcrow][0], &ss->ss_attr[dstrow][0],
    289  1.6     ragge 	    nrows * SM_COLS);
    290  1.2     ragge 	if (ss != curscr)
    291  1.2     ragge 		return;
    292  1.1     ragge 	if (nrows > 25) {
    293  1.1     ragge 		frows = nrows >> 1;
    294  1.1     ragge 		if (srcrow > dstrow) {
    295  1.1     ragge 			bcopy(&sm_addr[(srcrow * SM_NEXTROW)],
    296  1.1     ragge 			    &sm_addr[(dstrow * SM_NEXTROW)],
    297  1.1     ragge 			    frows * SM_NEXTROW);
    298  1.1     ragge 			bcopy(&sm_addr[((srcrow + frows) * SM_NEXTROW)],
    299  1.1     ragge 			    &sm_addr[((dstrow + frows) * SM_NEXTROW)],
    300  1.1     ragge 			    (nrows - frows) * SM_NEXTROW);
    301  1.1     ragge 		} else {
    302  1.1     ragge 			bcopy(&sm_addr[((srcrow + frows) * SM_NEXTROW)],
    303  1.1     ragge 			    &sm_addr[((dstrow + frows) * SM_NEXTROW)],
    304  1.1     ragge 			    (nrows - frows) * SM_NEXTROW);
    305  1.1     ragge 			bcopy(&sm_addr[(srcrow * SM_NEXTROW)],
    306  1.1     ragge 			    &sm_addr[(dstrow * SM_NEXTROW)],
    307  1.1     ragge 			    frows * SM_NEXTROW);
    308  1.1     ragge 		}
    309  1.1     ragge 	} else
    310  1.1     ragge 		bcopy(&sm_addr[(srcrow * SM_NEXTROW)],
    311  1.1     ragge 		    &sm_addr[(dstrow * SM_NEXTROW)], nrows * SM_NEXTROW);
    312  1.1     ragge }
    313  1.1     ragge 
    314  1.1     ragge static void
    315  1.1     ragge smg_eraserows(id, startrow, nrows, fillattr)
    316  1.1     ragge 	void *id;
    317  1.1     ragge 	int startrow, nrows;
    318  1.1     ragge 	long fillattr;
    319  1.1     ragge {
    320  1.2     ragge 	struct smg_screen *ss = id;
    321  1.1     ragge 	int frows;
    322  1.1     ragge 
    323  1.6     ragge 	bzero(&ss->ss_image[startrow][0], nrows * SM_COLS);
    324  1.6     ragge 	bzero(&ss->ss_attr[startrow][0], nrows * SM_COLS);
    325  1.2     ragge 	if (ss != curscr)
    326  1.2     ragge 		return;
    327  1.1     ragge 	if (nrows > 25) {
    328  1.1     ragge 		frows = nrows >> 1;
    329  1.1     ragge 		bzero(&sm_addr[(startrow * SM_NEXTROW)], frows * SM_NEXTROW);
    330  1.1     ragge 		bzero(&sm_addr[((startrow + frows) * SM_NEXTROW)],
    331  1.1     ragge 		    (nrows - frows) * SM_NEXTROW);
    332  1.1     ragge 	} else
    333  1.1     ragge 		bzero(&sm_addr[(startrow * SM_NEXTROW)], nrows * SM_NEXTROW);
    334  1.1     ragge }
    335  1.1     ragge 
    336  1.1     ragge static int
    337  1.1     ragge smg_alloc_attr(id, fg, bg, flags, attrp)
    338  1.1     ragge 	void *id;
    339  1.1     ragge 	int fg, bg;
    340  1.1     ragge 	int flags;
    341  1.1     ragge 	long *attrp;
    342  1.1     ragge {
    343  1.6     ragge 	*attrp = flags;
    344  1.1     ragge 	return 0;
    345  1.1     ragge }
    346  1.1     ragge 
    347  1.1     ragge int
    348  1.1     ragge smg_ioctl(v, cmd, data, flag, p)
    349  1.1     ragge 	void *v;
    350  1.1     ragge 	u_long cmd;
    351  1.1     ragge 	caddr_t data;
    352  1.1     ragge 	int flag;
    353  1.1     ragge 	struct proc *p;
    354  1.1     ragge {
    355  1.8     ragge 	struct wsdisplay_fbinfo fb;
    356  1.8     ragge 
    357  1.8     ragge 	switch (cmd) {
    358  1.8     ragge 	case WSDISPLAYIO_GTYPE:
    359  1.8     ragge 		*(u_int *)data = WSDISPLAY_TYPE_PM_MONO;
    360  1.8     ragge 		break;
    361  1.8     ragge 
    362  1.8     ragge 	case WSDISPLAYIO_GINFO:
    363  1.8     ragge 		fb.height = 864;
    364  1.8     ragge 		fb.width = 1024;
    365  1.8     ragge 		return copyout(&fb, data, sizeof(struct wsdisplay_fbinfo));
    366  1.8     ragge 
    367  1.8     ragge 
    368  1.8     ragge 	default:
    369  1.8     ragge 		return -1;
    370  1.8     ragge 	}
    371  1.8     ragge 	return 0;
    372  1.1     ragge }
    373  1.1     ragge 
    374  1.1     ragge static int
    375  1.1     ragge smg_mmap(v, offset, prot)
    376  1.1     ragge 	void *v;
    377  1.1     ragge 	off_t offset;
    378  1.1     ragge 	int prot;
    379  1.1     ragge {
    380  1.9       mrg 	if (offset >= SMSIZE || offset < 0)
    381  1.8     ragge 		return -1;
    382  1.8     ragge 	return (SMADDR + offset) >> CLSHIFT;
    383  1.1     ragge }
    384  1.1     ragge 
    385  1.1     ragge int
    386  1.1     ragge smg_alloc_screen(v, type, cookiep, curxp, curyp, defattrp)
    387  1.1     ragge 	void *v;
    388  1.1     ragge 	const struct wsscreen_descr *type;
    389  1.1     ragge 	void **cookiep;
    390  1.1     ragge 	int *curxp, *curyp;
    391  1.1     ragge 	long *defattrp;
    392  1.1     ragge {
    393  1.2     ragge 	*cookiep = malloc(sizeof(struct smg_screen), M_DEVBUF, M_WAITOK);
    394  1.3     ragge 	bzero(*cookiep, sizeof(struct smg_screen));
    395  1.3     ragge 	*curxp = *curyp = *defattrp = 0;
    396  1.1     ragge 	return 0;
    397  1.1     ragge }
    398  1.1     ragge 
    399  1.1     ragge void
    400  1.1     ragge smg_free_screen(v, cookie)
    401  1.1     ragge 	void *v;
    402  1.1     ragge 	void *cookie;
    403  1.1     ragge {
    404  1.1     ragge }
    405  1.1     ragge 
    406  1.1     ragge void
    407  1.1     ragge smg_show_screen(v, cookie)
    408  1.1     ragge 	void *v;
    409  1.1     ragge 	void *cookie;
    410  1.1     ragge {
    411  1.2     ragge 	struct smg_screen *ss = cookie;
    412  1.2     ragge 	int row, col, line;
    413  1.2     ragge 
    414  1.2     ragge 	if (ss == curscr)
    415  1.2     ragge 		return;
    416  1.2     ragge 
    417  1.6     ragge 	for (row = 0; row < SM_ROWS; row++)
    418  1.8     ragge 		for (line = 0; line < SM_CHEIGHT; line++) {
    419  1.6     ragge 			for (col = 0; col < SM_COLS; col++) {
    420  1.6     ragge 				u_char s, c = ss->ss_image[row][col];
    421  1.6     ragge 
    422  1.6     ragge 				if (c < 32)
    423  1.6     ragge 					c = 32;
    424  1.6     ragge 				s = QFONT(c, line);
    425  1.6     ragge 				if (ss->ss_attr[row][col] & WSATTR_REVERSE)
    426  1.6     ragge 					s ^= 255;
    427  1.6     ragge 				SM_ADDR(row, col, line) = s;
    428  1.2     ragge 			}
    429  1.8     ragge 			if (ss->ss_attr[row][col] & WSATTR_UNDERLINE)
    430  1.8     ragge 				SM_ADDR(row, col, line) = 255;
    431  1.8     ragge 		}
    432  1.6     ragge 	cursor = &sm_addr[(ss->ss_cury * SM_CHEIGHT * SM_COLS) + ss->ss_curx +
    433  1.6     ragge 	    ((SM_CHEIGHT - 1) * SM_COLS)];
    434  1.2     ragge 	curscr = ss;
    435  1.1     ragge }
    436  1.1     ragge 
    437  1.1     ragge static int
    438  1.1     ragge smg_load_font(v, cookie, first, num, stride, data)
    439  1.1     ragge 	void *v;
    440  1.1     ragge 	void *cookie;
    441  1.1     ragge 	int first, num, stride;
    442  1.1     ragge 	void *data;
    443  1.1     ragge {
    444  1.1     ragge 	return 0;
    445  1.1     ragge }
    446  1.1     ragge 
    447  1.1     ragge cons_decl(smg);
    448  1.1     ragge 
    449  1.6     ragge #define WSCONSOLEMAJOR 68
    450  1.1     ragge 
    451  1.1     ragge void
    452  1.1     ragge smgcninit(cndev)
    453  1.6     ragge 	struct	consdev *cndev;
    454  1.1     ragge {
    455  1.1     ragge 	extern void lkccninit __P((struct consdev *));
    456  1.1     ragge 	extern int lkccngetc __P((dev_t));
    457  1.1     ragge 	/* Clear screen */
    458  1.1     ragge 	blkclr(sm_addr, 128*864);
    459  1.1     ragge 
    460  1.2     ragge 	curscr = &smg_conscreen;
    461  1.2     ragge 	wsdisplay_cnattach(&smg_stdscreen, &smg_conscreen, 0, 0, 0);
    462  1.1     ragge 	cn_tab->cn_dev = makedev(WSCONSOLEMAJOR, 0);
    463  1.1     ragge #if NLKC
    464  1.1     ragge 	lkccninit(cndev);
    465  1.1     ragge 	wsdisplay_set_cons_kbd(lkccngetc, nullcnpollc);
    466  1.1     ragge #endif
    467  1.1     ragge }
    468  1.1     ragge 
    469  1.1     ragge int smgprobe(void);
    470  1.1     ragge int
    471  1.1     ragge smgprobe()
    472  1.1     ragge {
    473  1.1     ragge 	switch (vax_boardtype) {
    474  1.1     ragge 	case VAX_BTYP_410:
    475  1.1     ragge 	case VAX_BTYP_420:
    476  1.1     ragge 	case VAX_BTYP_43:
    477  1.1     ragge 		if (vax_confdata & 0x20) /* doesn't use graphics console */
    478  1.1     ragge 			break;
    479  1.1     ragge 		if (sm_addr == 0) /* Haven't mapped graphic area */
    480  1.1     ragge 			break;
    481  1.1     ragge 
    482  1.1     ragge 		return 1;
    483  1.1     ragge 
    484  1.1     ragge 	default:
    485  1.1     ragge 		break;
    486  1.1     ragge 	}
    487  1.1     ragge 	return 0;
    488  1.1     ragge }
    489