Home | History | Annotate | Line # | Download | only in wsfb
genfb.c revision 1.24
      1 /*	$NetBSD: genfb.c,v 1.24 2009/02/20 00:08:00 jmcneill Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 2007 Michael Lorenz
      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  *
     16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     26  * POSSIBILITY OF SUCH DAMAGE.
     27  */
     28 
     29 #include <sys/cdefs.h>
     30 __KERNEL_RCSID(0, "$NetBSD: genfb.c,v 1.24 2009/02/20 00:08:00 jmcneill Exp $");
     31 
     32 #include <sys/param.h>
     33 #include <sys/systm.h>
     34 #include <sys/kernel.h>
     35 #include <sys/device.h>
     36 #include <sys/proc.h>
     37 #include <sys/mutex.h>
     38 #include <sys/ioctl.h>
     39 #include <sys/kernel.h>
     40 #include <sys/systm.h>
     41 #include <sys/kmem.h>
     42 
     43 #include <dev/wscons/wsconsio.h>
     44 #include <dev/wscons/wsdisplayvar.h>
     45 #include <dev/rasops/rasops.h>
     46 #include <dev/wsfont/wsfont.h>
     47 
     48 #include <dev/wscons/wsdisplay_vconsvar.h>
     49 
     50 #include <dev/wsfb/genfbvar.h>
     51 
     52 #include "opt_genfb.h"
     53 #include "opt_wsfb.h"
     54 
     55 #ifdef GENFB_DEBUG
     56 #define GPRINTF panic
     57 #else
     58 #define GPRINTF aprint_verbose
     59 #endif
     60 
     61 static int	genfb_ioctl(void *, void *, u_long, void *, int, struct lwp *);
     62 static paddr_t	genfb_mmap(void *, void *, off_t, int);
     63 static void	genfb_init_screen(void *, struct vcons_screen *, int, long *);
     64 
     65 static int	genfb_putcmap(struct genfb_softc *, struct wsdisplay_cmap *);
     66 static int 	genfb_getcmap(struct genfb_softc *, struct wsdisplay_cmap *);
     67 static void	genfb_restore_palette(struct genfb_softc *);
     68 static int 	genfb_putpalreg(struct genfb_softc *, uint8_t, uint8_t,
     69 			    uint8_t, uint8_t);
     70 
     71 extern const u_char rasops_cmap[768];
     72 
     73 static int genfb_cnattach_called = 0;
     74 static int genfb_enabled = 1;
     75 
     76 struct wsdisplay_accessops genfb_accessops = {
     77 	genfb_ioctl,
     78 	genfb_mmap,
     79 	NULL,	/* alloc_screen */
     80 	NULL,	/* free_screen */
     81 	NULL,	/* show_screen */
     82 	NULL, 	/* load_font */
     83 	NULL,	/* pollc */
     84 	NULL	/* scroll */
     85 };
     86 
     87 static struct genfb_softc *genfb_softc = NULL;
     88 
     89 void
     90 genfb_init(struct genfb_softc *sc)
     91 {
     92 	prop_dictionary_t dict;
     93 	uint64_t cmap_cb;
     94 	uint32_t fboffset;
     95 
     96 	dict = device_properties(&sc->sc_dev);
     97 #ifdef GENFB_DEBUG
     98 	printf(prop_dictionary_externalize(dict));
     99 #endif
    100 	if (!prop_dictionary_get_uint32(dict, "width", &sc->sc_width)) {
    101 		GPRINTF("no width property\n");
    102 		return;
    103 	}
    104 	if (!prop_dictionary_get_uint32(dict, "height", &sc->sc_height)) {
    105 		GPRINTF("no height property\n");
    106 		return;
    107 	}
    108 	if (!prop_dictionary_get_uint32(dict, "depth", &sc->sc_depth)) {
    109 		GPRINTF("no depth property\n");
    110 		return;
    111 	}
    112 
    113 	/* XXX should be a 64bit value */
    114 	if (!prop_dictionary_get_uint32(dict, "address", &fboffset)) {
    115 		GPRINTF("no address property\n");
    116 		return;
    117 	}
    118 
    119 	sc->sc_fboffset = fboffset;
    120 
    121 	if (!prop_dictionary_get_uint32(dict, "linebytes", &sc->sc_stride))
    122 		sc->sc_stride = (sc->sc_width * sc->sc_depth) >> 3;
    123 
    124 	/*
    125 	 * deal with a bug in the Raptor firmware which always sets
    126 	 * stride = width even when depth != 8
    127 	 */
    128 	if (sc->sc_stride < sc->sc_width * (sc->sc_depth >> 3))
    129 		sc->sc_stride = sc->sc_width * (sc->sc_depth >> 3);
    130 
    131 	sc->sc_fbsize = sc->sc_height * sc->sc_stride;
    132 
    133 	/* optional colour map callback */
    134 	sc->sc_cmcb = NULL;
    135 	if (prop_dictionary_get_uint64(dict, "cmap_callback", &cmap_cb)) {
    136 		if (cmap_cb != 0)
    137 			sc->sc_cmcb = (void *)(vaddr_t)cmap_cb;
    138 	}
    139 }
    140 
    141 int
    142 genfb_attach(struct genfb_softc *sc, struct genfb_ops *ops)
    143 {
    144 	struct wsemuldisplaydev_attach_args aa;
    145 	prop_dictionary_t dict;
    146 	struct rasops_info *ri;
    147 	uint16_t crow;
    148 	long defattr;
    149 	int i, j;
    150 	bool console;
    151 
    152 	dict = device_properties(&sc->sc_dev);
    153 	prop_dictionary_get_bool(dict, "is_console", &console);
    154 
    155 	if (prop_dictionary_get_uint16(dict, "cursor-row", &crow) == false)
    156 		crow = 0;
    157 	if (prop_dictionary_get_bool(dict, "clear-screen", &sc->sc_want_clear)
    158 	    == false)
    159 		sc->sc_want_clear = true;
    160 
    161 	/* do not attach when we're not console */
    162 	if (!console) {
    163 		aprint_normal_dev(&sc->sc_dev, "no console, unable to continue\n");
    164 		return -1;
    165 	}
    166 
    167 	aprint_verbose_dev(&sc->sc_dev, "framebuffer at %p, size %dx%d, depth %d, "
    168 	    "stride %d\n",
    169 	    sc->sc_fboffset ? (void *)sc->sc_fboffset : sc->sc_fbaddr,
    170 	    sc->sc_width, sc->sc_height, sc->sc_depth, sc->sc_stride);
    171 
    172 	sc->sc_defaultscreen_descr = (struct wsscreen_descr){
    173 		"default",
    174 		0, 0,
    175 		NULL,
    176 		8, 16,
    177 		WSSCREEN_WSCOLORS | WSSCREEN_HILIT,
    178 		NULL
    179 	};
    180 	sc->sc_screens[0] = &sc->sc_defaultscreen_descr;
    181 	sc->sc_screenlist = (struct wsscreen_list){1, sc->sc_screens};
    182 	memcpy(&sc->sc_ops, ops, sizeof(struct genfb_ops));
    183 	sc->sc_mode = WSDISPLAYIO_MODE_EMUL;
    184 
    185 	sc->sc_shadowfb = kmem_alloc(sc->sc_fbsize, KM_SLEEP);
    186 	if (sc->sc_want_clear == false && sc->sc_shadowfb != NULL)
    187 		memcpy(sc->sc_shadowfb, sc->sc_fbaddr, sc->sc_fbsize);
    188 
    189 	vcons_init(&sc->vd, sc, &sc->sc_defaultscreen_descr,
    190 	    &genfb_accessops);
    191 	sc->vd.init_screen = genfb_init_screen;
    192 
    193 	/* Do not print anything between this point and the screen
    194 	 * clear operation below.  Otherwise it will be lost. */
    195 
    196 	ri = &sc->sc_console_screen.scr_ri;
    197 
    198 	vcons_init_screen(&sc->vd, &sc->sc_console_screen, 1,
    199 	    &defattr);
    200 	sc->sc_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC;
    201 
    202 	sc->sc_defaultscreen_descr.textops = &ri->ri_ops;
    203 	sc->sc_defaultscreen_descr.capabilities = ri->ri_caps;
    204 	sc->sc_defaultscreen_descr.nrows = ri->ri_rows;
    205 	sc->sc_defaultscreen_descr.ncols = ri->ri_cols;
    206 	wsdisplay_cnattach(&sc->sc_defaultscreen_descr, ri, 0, crow,
    207 	    defattr);
    208 
    209 	/* Clear the whole screen to bring it to a known state. */
    210 	if (sc->sc_want_clear)
    211 		(*ri->ri_ops.eraserows)(ri, 0, ri->ri_rows, defattr);
    212 
    213 	j = 0;
    214 	for (i = 0; i < (1 << sc->sc_depth); i++) {
    215 
    216 		sc->sc_cmap_red[i] = rasops_cmap[j];
    217 		sc->sc_cmap_green[i] = rasops_cmap[j + 1];
    218 		sc->sc_cmap_blue[i] = rasops_cmap[j + 2];
    219 		genfb_putpalreg(sc, i, rasops_cmap[j], rasops_cmap[j + 1],
    220 		    rasops_cmap[j + 2]);
    221 		j += 3;
    222 	}
    223 
    224 	if (genfb_softc == NULL)
    225 		genfb_softc = sc;
    226 
    227 	aa.console = console;
    228 	aa.scrdata = &sc->sc_screenlist;
    229 	aa.accessops = &genfb_accessops;
    230 	aa.accesscookie = &sc->vd;
    231 
    232 	config_found(&sc->sc_dev, &aa, wsemuldisplaydevprint);
    233 
    234 	return 0;
    235 }
    236 
    237 static int
    238 genfb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag,
    239 	struct lwp *l)
    240 {
    241 	struct vcons_data *vd = v;
    242 	struct genfb_softc *sc = vd->cookie;
    243 	struct wsdisplay_fbinfo *wdf;
    244 	struct vcons_screen *ms = vd->active;
    245 	int new_mode, error;
    246 
    247 	switch (cmd) {
    248 		case WSDISPLAYIO_GINFO:
    249 			if (ms == NULL)
    250 				return ENODEV;
    251 			wdf = (void *)data;
    252 			wdf->height = ms->scr_ri.ri_height;
    253 			wdf->width = ms->scr_ri.ri_width;
    254 			wdf->depth = ms->scr_ri.ri_depth;
    255 			wdf->cmsize = 256;
    256 			return 0;
    257 
    258 		case WSDISPLAYIO_GETCMAP:
    259 			return genfb_getcmap(sc,
    260 			    (struct wsdisplay_cmap *)data);
    261 
    262 		case WSDISPLAYIO_PUTCMAP:
    263 			return genfb_putcmap(sc,
    264 			    (struct wsdisplay_cmap *)data);
    265 
    266 		case WSDISPLAYIO_LINEBYTES:
    267 			*(u_int *)data = sc->sc_stride;
    268 			return 0;
    269 
    270 		case WSDISPLAYIO_SMODE:
    271 			new_mode = *(int *)data;
    272 
    273 			/* notify the bus backend */
    274 			error = 0;
    275 			if (sc->sc_ops.genfb_ioctl)
    276 				error = sc->sc_ops.genfb_ioctl(sc, vs,
    277 					    cmd, data, flag, l);
    278 			if (error)
    279 				return error;
    280 
    281 			if (new_mode != sc->sc_mode) {
    282 				sc->sc_mode = new_mode;
    283 				if (new_mode == WSDISPLAYIO_MODE_EMUL) {
    284 					genfb_restore_palette(sc);
    285 					vcons_redraw_screen(ms);
    286 				}
    287 			}
    288 			return 0;
    289 		default:
    290 			if (sc->sc_ops.genfb_ioctl)
    291 				return sc->sc_ops.genfb_ioctl(sc, vs, cmd,
    292 				    data, flag, l);
    293 	}
    294 	return EPASSTHROUGH;
    295 }
    296 
    297 static paddr_t
    298 genfb_mmap(void *v, void *vs, off_t offset, int prot)
    299 {
    300 	struct vcons_data *vd = v;
    301 	struct genfb_softc *sc = vd->cookie;
    302 
    303 	if (sc->sc_ops.genfb_mmap)
    304 		return sc->sc_ops.genfb_mmap(sc, vs, offset, prot);
    305 
    306 	return -1;
    307 }
    308 
    309 static void
    310 genfb_init_screen(void *cookie, struct vcons_screen *scr,
    311     int existing, long *defattr)
    312 {
    313 	struct genfb_softc *sc = cookie;
    314 	struct rasops_info *ri = &scr->scr_ri;
    315 
    316 	ri->ri_depth = sc->sc_depth;
    317 	ri->ri_width = sc->sc_width;
    318 	ri->ri_height = sc->sc_height;
    319 	ri->ri_stride = sc->sc_stride;
    320 	ri->ri_flg = RI_CENTER;
    321 	if (sc->sc_want_clear)
    322 		ri->ri_flg |= RI_FULLCLEAR;
    323 
    324 	if (sc->sc_shadowfb != NULL) {
    325 
    326 		ri->ri_hwbits = (char *)sc->sc_fbaddr;
    327 		ri->ri_bits = (char *)sc->sc_shadowfb;
    328 	} else
    329 		ri->ri_bits = (char *)sc->sc_fbaddr;
    330 
    331 	if (existing && sc->sc_want_clear) {
    332 		ri->ri_flg |= RI_CLEAR;
    333 	}
    334 
    335 	rasops_init(ri, sc->sc_height / 8, sc->sc_width / 8);
    336 	ri->ri_caps = WSSCREEN_WSCOLORS;
    337 
    338 	rasops_reconfig(ri, sc->sc_height / ri->ri_font->fontheight,
    339 		    sc->sc_width / ri->ri_font->fontwidth);
    340 
    341 	ri->ri_hw = scr;
    342 }
    343 
    344 static int
    345 genfb_putcmap(struct genfb_softc *sc, struct wsdisplay_cmap *cm)
    346 {
    347 	u_char *r, *g, *b;
    348 	u_int index = cm->index;
    349 	u_int count = cm->count;
    350 	int i, error;
    351 	u_char rbuf[256], gbuf[256], bbuf[256];
    352 
    353 #ifdef GENFB_DEBUG
    354 	aprint_debug("putcmap: %d %d\n",index, count);
    355 #endif
    356 	if (cm->index >= 256 || cm->count > 256 ||
    357 	    (cm->index + cm->count) > 256)
    358 		return EINVAL;
    359 	error = copyin(cm->red, &rbuf[index], count);
    360 	if (error)
    361 		return error;
    362 	error = copyin(cm->green, &gbuf[index], count);
    363 	if (error)
    364 		return error;
    365 	error = copyin(cm->blue, &bbuf[index], count);
    366 	if (error)
    367 		return error;
    368 
    369 	memcpy(&sc->sc_cmap_red[index], &rbuf[index], count);
    370 	memcpy(&sc->sc_cmap_green[index], &gbuf[index], count);
    371 	memcpy(&sc->sc_cmap_blue[index], &bbuf[index], count);
    372 
    373 	r = &sc->sc_cmap_red[index];
    374 	g = &sc->sc_cmap_green[index];
    375 	b = &sc->sc_cmap_blue[index];
    376 
    377 	for (i = 0; i < count; i++) {
    378 		genfb_putpalreg(sc, index, *r, *g, *b);
    379 		index++;
    380 		r++, g++, b++;
    381 	}
    382 	return 0;
    383 }
    384 
    385 static int
    386 genfb_getcmap(struct genfb_softc *sc, struct wsdisplay_cmap *cm)
    387 {
    388 	u_int index = cm->index;
    389 	u_int count = cm->count;
    390 	int error;
    391 
    392 	if (index >= 255 || count > 256 || index + count > 256)
    393 		return EINVAL;
    394 
    395 	error = copyout(&sc->sc_cmap_red[index],   cm->red,   count);
    396 	if (error)
    397 		return error;
    398 	error = copyout(&sc->sc_cmap_green[index], cm->green, count);
    399 	if (error)
    400 		return error;
    401 	error = copyout(&sc->sc_cmap_blue[index],  cm->blue,  count);
    402 	if (error)
    403 		return error;
    404 
    405 	return 0;
    406 }
    407 
    408 static void
    409 genfb_restore_palette(struct genfb_softc *sc)
    410 {
    411 	int i;
    412 
    413 	for (i = 0; i < (1 << sc->sc_depth); i++) {
    414 		genfb_putpalreg(sc, i, sc->sc_cmap_red[i],
    415 		    sc->sc_cmap_green[i], sc->sc_cmap_blue[i]);
    416 	}
    417 }
    418 
    419 static int
    420 genfb_putpalreg(struct genfb_softc *sc, uint8_t idx, uint8_t r, uint8_t g,
    421     uint8_t b)
    422 {
    423 
    424 	if (sc->sc_cmcb) {
    425 
    426 		sc->sc_cmcb->gcc_set_mapreg(sc->sc_cmcb->gcc_cookie,
    427 		    idx, r, g, b);
    428 	}
    429 	return 0;
    430 }
    431 
    432 void
    433 genfb_cnattach(void)
    434 {
    435 	genfb_cnattach_called = 1;
    436 }
    437 
    438 void
    439 genfb_disable(void)
    440 {
    441 	genfb_enabled = 0;
    442 }
    443 
    444 int
    445 genfb_is_console(void)
    446 {
    447 	return genfb_cnattach_called;
    448 }
    449 
    450 int
    451 genfb_is_enabled(void)
    452 {
    453 	return genfb_enabled;
    454 }
    455 
    456 int
    457 genfb_borrow(bus_addr_t addr, bus_space_handle_t *hdlp)
    458 {
    459 	struct genfb_softc *sc = genfb_softc;
    460 
    461 	if (sc && sc->sc_ops.genfb_borrow)
    462 		return sc->sc_ops.genfb_borrow(sc, addr, hdlp);
    463 	return 0;
    464 }
    465