Home | History | Annotate | Line # | Download | only in dev
nextdisplay.c revision 1.28 
      1 /* $NetBSD: nextdisplay.c,v 1.28 2023/02/11 02:31:34 tsutsui 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.28 2023/02/11 02:31:34 tsutsui 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/kmem.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(device_t, cfdata_t, void *);
     61 void nextdisplay_attach(device_t, device_t, void *);
     62 
     63 CFATTACH_DECL_NEW(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(void *, void *, u_long, void *, int,
    110 		    struct lwp *);
    111 static paddr_t	nextdisplay_mmap(void *, void *, off_t, int);
    112 static int	nextdisplay_alloc_screen(void *, const struct wsscreen_descr *,
    113 		void **, int *, int *, long *);
    114 static void	nextdisplay_free_screen(void *, void *);
    115 static int	nextdisplay_show_screen(void *, void *, int,
    116 					void (*) (void *, int, int), void *);
    117 static int	nextdisplay_load_font(void *, void *, struct wsdisplay_font *);
    118 
    119 const struct wsdisplay_accessops nextdisplay_accessops = {
    120 	nextdisplay_ioctl,
    121 	nextdisplay_mmap,
    122 	nextdisplay_alloc_screen,
    123 	nextdisplay_free_screen,
    124 	nextdisplay_show_screen,
    125 	nextdisplay_load_font
    126 };
    127 
    128 void nextdisplay_init(struct nextdisplay_config *, int);
    129 int nextdisplay_intr(void *);
    130 
    131 vaddr_t nextdisplay_consaddr;
    132 static int nextdisplay_is_console(vaddr_t);
    133 
    134 static struct nextdisplay_config nextdisplay_console_dc;
    135 
    136 static int
    137 nextdisplay_is_console(vaddr_t addr)
    138 {
    139 	return nextdisplay_console_dc.isconsole &&
    140 	    addr == nextdisplay_consaddr;
    141 }
    142 
    143 int
    144 nextdisplay_match(device_t parent, cfdata_t match, void *aux)
    145 {
    146 	if (rom_machine_type == NeXT_WARP9 ||
    147 	    rom_machine_type == NeXT_X15 ||
    148 	    rom_machine_type == NeXT_WARP9C ||
    149 	    rom_machine_type == NeXT_TURBO_MONO ||
    150 	    rom_machine_type == NeXT_TURBO_COLOR)
    151 		return 1;
    152 	else
    153 		return 0;
    154 }
    155 
    156 void
    157 nextdisplay_init(struct nextdisplay_config *dc, int color)
    158 {
    159 	struct raster *rap;
    160 	struct rcons *rcp;
    161 	int i;
    162 
    163 	/* printf("in nextdisplay_init\n"); */
    164 
    165 	dc->dc_vaddr = fbbase;
    166 	dc->dc_paddr = fbbasepa;
    167 	dc->dc_size = color ? NEXT_P_C16_VIDEOSIZE : NEXT_P_VIDEOSIZE;
    168 
    169 	dc->dc_wid = 1120;
    170 	dc->dc_ht = 832;
    171 	dc->dc_depth = color ? 16 : 2;
    172 	dc->dc_rowbytes = (turbo ? 1120 : 1152) * dc->dc_depth / 8;
    173 
    174 	dc->dc_videobase = dc->dc_vaddr;
    175 
    176 #if 0
    177 	printf("intiobase at: %08x\n", intiobase);
    178 	printf("intiolimit at: %08x\n", intiolimit);
    179 	printf("videobase at: %08x\n", fbbase);
    180 	printf("videolimit at: %08x\n", fblimit);
    181 
    182 	printf("virtual fb at: %08x\n", dc->dc_vaddr);
    183 	printf("physical fb at: %08x\n", dc->dc_paddr);
    184 	printf("fb size: %08x\n", dc->dc_size);
    185 
    186 	printf("dc_wid: %08x\n", dc->dc_wid);
    187 	printf("dc_ht: %08x\n", dc->dc_ht);
    188 	printf("dc_depth: %08x\n", dc->dc_depth);
    189 	printf("dc_rowbytes: %08x\n", dc->dc_rowbytes);
    190 	printf("dc_videobase: %08x\n", dc->dc_videobase);
    191 #endif
    192 
    193 	/* clear the screen */
    194 	for (i = 0; i < dc->dc_ht * dc->dc_rowbytes; i += sizeof(uint32_t))
    195 		*(uint32_t *)(dc->dc_videobase + i) =
    196 		    color ? 0x0 : 0xffffffff;
    197 
    198 	rap = &dc->dc_raster;
    199 	rap->width = dc->dc_wid;
    200 	rap->height = dc->dc_ht;
    201 	rap->depth = color ? 16 : 2;
    202 	rap->linelongs = dc->dc_rowbytes / sizeof(uint32_t);
    203 	rap->pixels = (uint32_t *)dc->dc_videobase;
    204 
    205 	/* initialize the raster console blitter */
    206 	rcp = &dc->dc_rcons;
    207 	rcp->rc_sp = rap;
    208 	rcp->rc_crow = rcp->rc_ccol = -1;
    209 	rcp->rc_crowp = &rcp->rc_crow;
    210 	rcp->rc_ccolp = &rcp->rc_ccol;
    211 	rcons_init(rcp, 34, 80);
    212 
    213 	if (color) {
    214 		nextdisplay_color.nrows = dc->dc_rcons.rc_maxrow;
    215 		nextdisplay_color.ncols = dc->dc_rcons.rc_maxcol;
    216 	} else {
    217 		nextdisplay_mono.nrows = dc->dc_rcons.rc_maxrow;
    218 		nextdisplay_mono.ncols = dc->dc_rcons.rc_maxcol;
    219 	}
    220 }
    221 
    222 void
    223 nextdisplay_attach(device_t parent, device_t self, void *aux)
    224 {
    225 	struct nextdisplay_softc *sc = device_private(self);
    226 	struct wsemuldisplaydev_attach_args waa;
    227 	int isconsole;
    228 	vaddr_t addr;
    229 
    230 	sc->sc_dev = self;
    231 
    232 	addr = fbbase;
    233 
    234 	isconsole = nextdisplay_is_console(addr);
    235 
    236 	if (isconsole) {
    237 		sc->sc_dc = &nextdisplay_console_dc;
    238 		sc->nscreens = 1;
    239 	} else {
    240 		sc->sc_dc = kmem_alloc(sizeof(struct nextdisplay_config),
    241 		    KM_SLEEP);
    242 		nextdisplay_init(sc->sc_dc, iscolor);
    243 	}
    244 
    245 	printf(": %d x %d, %dbpp\n", sc->sc_dc->dc_wid, sc->sc_dc->dc_ht,
    246 	    sc->sc_dc->dc_depth);
    247 
    248 	if (iscolor) {
    249 #if 0
    250 		uint8_t x;
    251 
    252 		x = *(volatile uint8_t *)IIOV(NEXT_P_C16_CMD_REG);
    253 		aprint_debug_dev(sc->sc_dev, "cmd=%02x\n", x);
    254 #endif
    255 		*(volatile uint8_t *)IIOV(NEXT_P_C16_CMD_REG) = 0x05;
    256 		isrlink_autovec(nextdisplay_intr, sc,
    257 		    NEXT_I_IPL(NEXT_I_C16_VIDEO), 1, NULL);
    258 		INTR_ENABLE(NEXT_I_C16_VIDEO);
    259 	}
    260 
    261 	/* initialize the raster */
    262 	waa.console = isconsole;
    263 	waa.scrdata = iscolor ?
    264 	    &nextdisplay_screenlist_color : &nextdisplay_screenlist_mono;
    265 	waa.accessops = &nextdisplay_accessops;
    266 	waa.accesscookie = sc;
    267 #if 0
    268 	printf("nextdisplay: access cookie is %p\n", sc);
    269 #endif
    270 	config_found(self, &waa, wsemuldisplaydevprint, CFARGS_NONE);
    271 }
    272 
    273 int
    274 nextdisplay_intr(void *arg)
    275 {
    276 #if 0
    277 	uint8_t x;
    278 #endif
    279 
    280 	if (!INTR_OCCURRED(NEXT_I_C16_VIDEO))
    281 		return 0;
    282 #if 0
    283 	x = *(volatile uint8_t *)IIOV(NEXT_P_C16_CMD_REG);
    284 	printf("I%02x", x);
    285 #endif
    286 	*(volatile uint8_t *)IIOV(NEXT_P_C16_CMD_REG) = 0x05;
    287 	return 1;
    288 }
    289 
    290 int
    291 nextdisplay_ioctl(void *v, void *vs, u_long cmd, void *data, int flag,
    292     struct lwp *l)
    293 {
    294 	struct nextdisplay_softc *sc = v;
    295 	struct nextdisplay_config *dc = sc->sc_dc;
    296 
    297 	switch (cmd) {
    298 	case WSDISPLAYIO_GTYPE:
    299 		*(int *)data = dc->dc_type;
    300 		return 0;
    301 
    302 	case WSDISPLAYIO_SCURSOR:
    303 		printf("nextdisplay_ioctl: wsdisplayio_scursor\n");
    304 		return EPASSTHROUGH;
    305 
    306 	case WSDISPLAYIO_SCURPOS:
    307 		printf("nextdisplay_ioctl: wsdisplayio_scurpos\n");
    308 		return EPASSTHROUGH;
    309 
    310 	case WSDISPLAYIO_GINFO:
    311 	case WSDISPLAYIO_GETCMAP:
    312 	case WSDISPLAYIO_PUTCMAP:
    313 	case WSDISPLAYIO_GVIDEO:
    314 	case WSDISPLAYIO_SVIDEO:
    315 	case WSDISPLAYIO_GCURPOS:
    316 	case WSDISPLAYIO_GCURMAX:
    317 	case WSDISPLAYIO_GCURSOR:
    318 		printf("nextdisplay_ioctl: listed but unsupported ioctl\n");
    319 		return EPASSTHROUGH;
    320 	}
    321 
    322 	return EPASSTHROUGH;
    323 }
    324 
    325 static paddr_t
    326 nextdisplay_mmap(void *v, void *vs, off_t offset, int prot)
    327 {
    328 
    329 	/* XXX */
    330 	printf("nextdisplay_mmap: failed\n");
    331 	return -1;
    332 }
    333 
    334 int
    335 nextdisplay_alloc_screen(void *v, const struct wsscreen_descr *type,
    336     void **cookiep, int *curxp, int *curyp, long *defattrp)
    337 {
    338 	struct nextdisplay_softc *sc = v;
    339 	long defattr;
    340 
    341 	/* only allow one screen */
    342 	if (sc->nscreens > 0)
    343 		return ENOMEM;
    344 
    345 	*cookiep = &sc->sc_dc->dc_rcons; /* one and only for now */
    346 	*curxp = 0;
    347 	*curyp = 0;
    348 	rcons_allocattr(&sc->sc_dc->dc_rcons, 0, 0,
    349 	    (strcmp(type->name, "color") == 0) ? 0 : WSATTR_REVERSE, &defattr);
    350 	*defattrp = defattr;
    351 	sc->nscreens++;
    352 #if 0
    353 	printf("nextdisplay: allocating screen\n");
    354 #endif
    355 	return 0;
    356 }
    357 
    358 void
    359 nextdisplay_free_screen(void *v, void *cookie)
    360 {
    361 	struct nextdisplay_softc *sc = v;
    362 
    363 	if (sc->sc_dc == &nextdisplay_console_dc)
    364 		panic("nextdisplay_free_screen: console");
    365 
    366 	sc->nscreens--;
    367 }
    368 
    369 int
    370 nextdisplay_show_screen(void *v, void *cookie, int waitok,
    371     void (*cb)(void *, int, int), void *cbarg)
    372 {
    373 
    374 	return 0;
    375 }
    376 
    377 static int
    378 nextdisplay_load_font(void *v, void *cookie, struct wsdisplay_font *font)
    379 {
    380 
    381 	return EPASSTHROUGH;
    382 }
    383 
    384 int
    385 nextdisplay_cnattach(void)
    386 {
    387 	struct nextdisplay_config *dc = &nextdisplay_console_dc;
    388 	long defattr;
    389 
    390 	/* set up the display */
    391 	nextdisplay_init(&nextdisplay_console_dc, iscolor);
    392 	nextdisplay_consaddr = nextdisplay_console_dc.dc_vaddr;
    393 
    394 	rcons_allocattr(&dc->dc_rcons, 0, 0,
    395 	    iscolor ? 0 : WSATTR_REVERSE, &defattr);
    396 
    397 	wsdisplay_cnattach(iscolor ? &nextdisplay_color : &nextdisplay_mono,
    398 	    &dc->dc_rcons, 0, 0, defattr);
    399 
    400 	dc->isconsole = 1;
    401 	return 0;
    402 }
    403