Home | History | Annotate | Line # | Download | only in dev
nextdisplay.c revision 1.15 
      1 /* $NetBSD: nextdisplay.c,v 1.15 2003/10/05 22:00:25 mycroft Exp $ */
      2 
      3 /*
      4  * Copyright (c) 1998 Matt DeBergalis
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *      This product includes software developed by Matt DeBergalis
     18  * 4. The name of the author may not be used to endorse or promote products
     19  *    derived from this software without specific prior written permission
     20  *
     21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     31  */
     32 
     33 #include <sys/cdefs.h>
     34 __KERNEL_RCSID(0, "$NetBSD: nextdisplay.c,v 1.15 2003/10/05 22:00:25 mycroft Exp $");
     35 
     36 #include <sys/cdefs.h>			/* RCS ID & Copyright macro defns */
     37 
     38 #include <sys/param.h>
     39 #include <sys/systm.h>
     40 #include <sys/kernel.h>
     41 #include <sys/device.h>
     42 #include <sys/malloc.h>
     43 
     44 #include <machine/bus.h>
     45 #include <machine/cpu.h>
     46 
     47 #include <next68k/next68k/nextrom.h>
     48 #include <next68k/next68k/isr.h>
     49 
     50 #include <next68k/dev/intiovar.h>
     51 #include <next68k/dev/nextdisplayvar.h>
     52 #include <dev/wscons/wsconsio.h>
     53 
     54 #include <dev/rcons/raster.h>
     55 #include <dev/wscons/wscons_raster.h>
     56 #include <dev/wscons/wsdisplayvar.h>
     57 
     58 extern int turbo;
     59 
     60 int nextdisplay_match __P((struct device *, struct cfdata *, void *));
     61 void nextdisplay_attach __P((struct device *, struct device *, void *));
     62 
     63 CFATTACH_DECL(nextdisplay, sizeof(struct nextdisplay_softc),
     64     nextdisplay_match, nextdisplay_attach, NULL, NULL);
     65 
     66 const struct wsdisplay_emulops nextdisplay_mono_emulops = {
     67 	rcons_cursor,
     68 	rcons_mapchar,
     69 	rcons_putchar,
     70 	rcons_copycols,
     71 	rcons_erasecols,
     72 	rcons_copyrows,
     73 	rcons_eraserows,
     74 	rcons_allocattr
     75 };
     76 
     77 struct wsscreen_descr nextdisplay_mono = {
     78 	"mono",
     79 	0, 0, /* will be filled in -- XXX shouldn't, it's global */
     80 	&nextdisplay_mono_emulops,
     81 	0, 0
     82 };
     83 
     84 struct wsscreen_descr nextdisplay_color = {
     85         "color",
     86         0, 0, /* again, filled in */
     87         &nextdisplay_mono_emulops,
     88         0, 0
     89 };
     90 
     91 const struct wsscreen_descr *_nextdisplay_scrlist_mono[] = {
     92 	&nextdisplay_mono,
     93 };
     94 
     95 const struct wsscreen_descr *_nextdisplay_scrlist_color[] = {
     96         &nextdisplay_color,
     97 };
     98 
     99 const struct wsscreen_list nextdisplay_screenlist_mono = {
    100 	sizeof(_nextdisplay_scrlist_mono) / sizeof(struct wsscreen_descr *),
    101 	_nextdisplay_scrlist_mono
    102 };
    103 
    104 const struct wsscreen_list nextdisplay_screenlist_color = {
    105 	sizeof(_nextdisplay_scrlist_color) / sizeof(struct wsscreen_descr *),
    106 	_nextdisplay_scrlist_color
    107 };
    108 
    109 static int	nextdisplay_ioctl __P((void *, u_long, caddr_t, int, struct proc *));
    110 static paddr_t	nextdisplay_mmap __P((void *, off_t, int));
    111 static int	nextdisplay_alloc_screen __P((void *, const struct wsscreen_descr *,
    112 		void **, int *, int *, long *));
    113 static void	nextdisplay_free_screen __P((void *, void *));
    114 static int	nextdisplay_show_screen __P((void *, void *, int,
    115 					     void (*) (void *, int, int), void *));
    116 static int	nextdisplay_load_font __P((void *, void *, struct wsdisplay_font *));
    117 
    118 const struct wsdisplay_accessops nextdisplay_accessops = {
    119 	nextdisplay_ioctl,
    120 	nextdisplay_mmap,
    121 	nextdisplay_alloc_screen,
    122 	nextdisplay_free_screen,
    123 	nextdisplay_show_screen,
    124 	nextdisplay_load_font
    125 };
    126 
    127 void nextdisplay_init(struct nextdisplay_config *, int);
    128 int nextdisplay_intr __P((void *));
    129 
    130 vaddr_t nextdisplay_consaddr;
    131 static int nextdisplay_is_console __P((vaddr_t addr));
    132 
    133 static struct nextdisplay_config nextdisplay_console_dc;
    134 
    135 static int
    136 nextdisplay_is_console(vaddr_t addr)
    137 {
    138 	return (nextdisplay_console_dc.isconsole
    139 			&& (addr == nextdisplay_consaddr));
    140 }
    141 
    142 int
    143 nextdisplay_match(parent, match, aux)
    144 	struct device *parent;
    145 	struct cfdata *match;
    146 	void *aux;
    147 {
    148 	if (rom_machine_type == NeXT_WARP9 ||
    149 	    rom_machine_type == NeXT_X15 ||
    150 	    rom_machine_type == NeXT_WARP9C ||
    151 	    rom_machine_type == NeXT_TURBO_MONO ||
    152 	    rom_machine_type == NeXT_TURBO_COLOR)
    153 		return (1);
    154 	else
    155 		return (0);
    156 }
    157 
    158 void
    159 nextdisplay_init(dc, color)
    160 	struct nextdisplay_config *dc;
    161 	int color;
    162 {
    163 	struct raster *rap;
    164 	struct rcons *rcp;
    165 	int i;
    166 
    167 	/* printf("in nextdisplay_init\n"); */
    168 
    169 	if (color) {
    170 		dc->dc_vaddr = colorbase;
    171 		dc->dc_paddr = COLORBASE;
    172 		dc->dc_size = NEXT_P_C16_VIDEOSIZE;
    173 	} else {
    174 		dc->dc_vaddr = monobase;
    175 		dc->dc_paddr = MONOBASE;
    176 		dc->dc_size = NEXT_P_VIDEOSIZE;
    177 	}
    178 
    179 	dc->dc_wid = 1120;
    180 	dc->dc_ht = 832;
    181 	dc->dc_depth = color ? 16 : 2;
    182 	dc->dc_rowbytes = (turbo ? 1120 : 1152) * dc->dc_depth / 8;
    183 
    184 	dc->dc_videobase = dc->dc_vaddr;
    185 
    186 #if 0
    187 	printf("intiobase at: %08x\n", intiobase);
    188 	printf("intiolimit at: %08x\n", intiolimit);
    189 	printf("videobase at: %08x\n", color ? colorbase : monobase);
    190 	printf("videolimit at: %08x\n", color ? colorlimit : monolimit);
    191 
    192 	printf("virtual fb at: %08x\n", dc->dc_vaddr);
    193 	printf("physical fb at: %08x\n", dc->dc_paddr);
    194 	printf("fb size: %08x\n", dc->dc_size);
    195 
    196 	printf("dc_wid: %08x\n", dc->dc_wid);
    197 	printf("dc_ht: %08x\n", dc->dc_ht);
    198 	printf("dc_depth: %08x\n", dc->dc_depth);
    199 	printf("dc_rowbytes: %08x\n", dc->dc_rowbytes);
    200 	printf("dc_videobase: %08x\n", dc->dc_videobase);
    201 #endif
    202 
    203 	/* clear the screen */
    204 	for (i = 0; i < dc->dc_ht * dc->dc_rowbytes; i += sizeof(u_int32_t))
    205 		*(u_int32_t *)(dc->dc_videobase + i) =
    206 			(color ? 0x0 : 0xffffffff);
    207 
    208 	printf("done clearing\n");
    209 
    210 	rap = &dc->dc_raster;
    211 	rap->width = dc->dc_wid;
    212 	rap->height = dc->dc_ht;
    213 	rap->depth = color ? 16 : 2;
    214 	rap->linelongs = dc->dc_rowbytes / sizeof(u_int32_t);
    215 	rap->pixels = (u_int32_t *)dc->dc_videobase;
    216 
    217 	/* initialize the raster console blitter */
    218 	rcp = &dc->dc_rcons;
    219 	rcp->rc_sp = rap;
    220 	rcp->rc_crow = rcp->rc_ccol = -1;
    221 	rcp->rc_crowp = &rcp->rc_crow;
    222 	rcp->rc_ccolp = &rcp->rc_ccol;
    223 	rcons_init(rcp, 34, 80);
    224 
    225 	if (color) {
    226 		nextdisplay_color.nrows = dc->dc_rcons.rc_maxrow;
    227 		nextdisplay_color.ncols = dc->dc_rcons.rc_maxcol;
    228 	} else {
    229 		nextdisplay_mono.nrows = dc->dc_rcons.rc_maxrow;
    230 		nextdisplay_mono.ncols = dc->dc_rcons.rc_maxcol;
    231 	}
    232 }
    233 
    234 void
    235 nextdisplay_attach(parent, self, aux)
    236 	struct device *parent;
    237 	struct device *self;
    238 	void *aux;
    239 {
    240 	struct nextdisplay_softc *sc = (void *)self;
    241 	struct wsemuldisplaydev_attach_args waa;
    242 	int isconsole;
    243 	int iscolor;
    244 	paddr_t addr;
    245 
    246 	if (rom_machine_type == NeXT_WARP9C ||
    247 	    rom_machine_type == NeXT_TURBO_COLOR) {
    248 		iscolor = 1;
    249 		addr = colorbase;
    250 	} else {
    251 		iscolor = 0;
    252 		addr = monobase;
    253 	}
    254 
    255 	isconsole = nextdisplay_is_console(addr);
    256 
    257 	if (isconsole) {
    258 		sc->sc_dc = &nextdisplay_console_dc;
    259 		sc->nscreens = 1;
    260 	} else {
    261 		sc->sc_dc = (struct nextdisplay_config *)
    262 				malloc(sizeof(struct nextdisplay_config), M_DEVBUF, M_WAITOK);
    263 		nextdisplay_init(sc->sc_dc, iscolor);
    264 	}
    265 
    266 	printf(": %d x %d, %dbpp\n", sc->sc_dc->dc_wid, sc->sc_dc->dc_ht,
    267 	       sc->sc_dc->dc_depth);
    268 
    269 	if (iscolor) {
    270 #if 0
    271 		uint8_t x;
    272 
    273 		x = *(volatile uint8_t *)IIOV(NEXT_P_C16_CMD_REG);
    274 		printf("%s: cmd=%02x\n", sc->sc_dev.dv_xname, x);
    275 #endif
    276 		*(volatile uint8_t *)IIOV(NEXT_P_C16_CMD_REG) = 0x05;
    277 		isrlink_autovec(nextdisplay_intr, sc, NEXT_I_IPL(NEXT_I_C16_VIDEO), 1, NULL);
    278 		INTR_ENABLE(NEXT_I_C16_VIDEO);
    279 	}
    280 
    281 	/* initialize the raster */
    282 	waa.console = isconsole;
    283 	waa.scrdata = iscolor ? &nextdisplay_screenlist_color : &nextdisplay_screenlist_mono;
    284 	waa.accessops = &nextdisplay_accessops;
    285 	waa.accesscookie = sc;
    286 #if 0
    287 	printf("nextdisplay: access cookie is %p\n", sc);
    288 #endif
    289 	config_found(self, &waa, wsemuldisplaydevprint);
    290 }
    291 
    292 int
    293 nextdisplay_intr(arg)
    294 	void *arg;
    295 {
    296 #if 0
    297 	uint8_t x;
    298 #endif
    299 
    300 	if (!INTR_OCCURRED(NEXT_I_C16_VIDEO))
    301 		return (0);
    302 #if 0
    303 	x = *(volatile uint8_t *)IIOV(NEXT_P_C16_CMD_REG);
    304 	printf("I%02x", x);
    305 #endif
    306 	*(volatile uint8_t *)IIOV(NEXT_P_C16_CMD_REG) = 0x05;
    307 	return (1);
    308 }
    309 
    310 int
    311 nextdisplay_ioctl(v, cmd, data, flag, p)
    312 	void *v;
    313 	u_long cmd;
    314 	caddr_t data;
    315 	int flag;
    316 	struct proc *p;
    317 {
    318 	struct nextdisplay_softc *sc = v;
    319 	struct nextdisplay_config *dc = sc->sc_dc;
    320 
    321 	switch (cmd) {
    322 	case WSDISPLAYIO_GTYPE:
    323 		*(int *)data = dc->dc_type;
    324 		return 0;
    325 
    326 	case WSDISPLAYIO_SCURSOR:
    327 		printf("nextdisplay_ioctl: wsdisplayio_scursor\n");
    328 		return EPASSTHROUGH;
    329 
    330 	case WSDISPLAYIO_SCURPOS:
    331 		printf("nextdisplay_ioctl: wsdisplayio_scurpos\n");
    332 		return EPASSTHROUGH;
    333 
    334 	case WSDISPLAYIO_GINFO:
    335 	case WSDISPLAYIO_GETCMAP:
    336 	case WSDISPLAYIO_PUTCMAP:
    337 	case WSDISPLAYIO_GVIDEO:
    338 	case WSDISPLAYIO_SVIDEO:
    339 	case WSDISPLAYIO_GCURPOS:
    340 	case WSDISPLAYIO_GCURMAX:
    341 	case WSDISPLAYIO_GCURSOR:
    342 		printf("nextdisplay_ioctl: listed but unsupported ioctl\n");
    343 		return EPASSTHROUGH;
    344 	}
    345 
    346 	return EPASSTHROUGH;
    347 }
    348 
    349 static paddr_t
    350 nextdisplay_mmap(v, offset, prot)
    351 	void *v;
    352 	off_t offset;
    353 	int prot;
    354 {
    355 
    356 	/* XXX */
    357 	printf("nextdisplay_mmap: failed\n");
    358 	return -1;
    359 }
    360 
    361 int
    362 nextdisplay_alloc_screen(v, type, cookiep, curxp, curyp, defattrp)
    363 	void *v;
    364 	const struct wsscreen_descr *type;
    365 	void **cookiep;
    366 	int *curxp, *curyp;
    367 	long *defattrp;
    368 {
    369 	struct nextdisplay_softc *sc = v;
    370 	long defattr;
    371 
    372 	/* only allow one screen */
    373 	if (sc->nscreens > 0)
    374 		return (ENOMEM);
    375 
    376 	*cookiep = &sc->sc_dc->dc_rcons; /* one and only for now */
    377 	*curxp = 0;
    378 	*curyp = 0;
    379 	rcons_allocattr(&sc->sc_dc->dc_rcons, 0, 0,
    380 			(strcmp(type->name, "color") == 0)
    381 			? 0
    382 			: WSATTR_REVERSE, &defattr);
    383 	*defattrp = defattr;
    384 	sc->nscreens++;
    385 #if 0
    386 	printf("nextdisplay: allocating screen\n");
    387 #endif
    388 	return (0);
    389 }
    390 
    391 void
    392 nextdisplay_free_screen(v, cookie)
    393 	void *v;
    394 	void *cookie;
    395 {
    396 	struct nextdisplay_softc *sc = v;
    397 
    398 	if (sc->sc_dc == &nextdisplay_console_dc)
    399 		panic("nextdisplay_free_screen: console");
    400 
    401 	sc->nscreens--;
    402 }
    403 
    404 int
    405 nextdisplay_show_screen(v, cookie, waitok, cb, cbarg)
    406 	void *v;
    407 	void *cookie;
    408 	int waitok;
    409 	void (*cb) __P((void *, int, int));
    410 	void *cbarg;
    411 {
    412 
    413 	return (0);
    414 }
    415 
    416 static int
    417 nextdisplay_load_font(v, cookie, font)
    418 	void *v;
    419 	void *cookie;
    420 	struct wsdisplay_font *font;
    421 {
    422 	return (EPASSTHROUGH);
    423 }
    424 
    425 int
    426 nextdisplay_cnattach(void)
    427 {
    428 	struct nextdisplay_config *dc = &nextdisplay_console_dc;
    429 	long defattr;
    430 	int iscolor;
    431 
    432 	if (rom_machine_type == NeXT_WARP9C ||
    433 	    rom_machine_type == NeXT_TURBO_COLOR)
    434 		iscolor = 1;
    435 	else
    436 		iscolor = 0;
    437 
    438 	/* set up the display */
    439 	nextdisplay_init(&nextdisplay_console_dc, iscolor);
    440 	nextdisplay_consaddr = nextdisplay_console_dc.dc_vaddr;
    441 
    442 	rcons_allocattr(&dc->dc_rcons, 0, 0,
    443 			iscolor ? 0 : WSATTR_REVERSE, &defattr);
    444 
    445 	wsdisplay_cnattach(iscolor ? &nextdisplay_color : &nextdisplay_mono,
    446 			   &dc->dc_rcons, 0, 0, defattr);
    447 
    448 	dc->isconsole = 1;
    449 	return (0);
    450 }
    451