 @@ -1,14 +1,14 @@
-/* $NetBSD: crmfb.c,v 1.37 2013/12/16 15:45:29 mrg Exp $ */
+/* $NetBSD: crmfb.c,v 1.38 2014/09/02 15:44:44 macallan Exp $ */
 /*-
  * Copyright (c) 2007 Jared D. McNeill <jmcneill@invisible.ca>
  *               2008 Michael Lorenz <macallan@netbsd.org>
  * 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
 @@ -22,27 +22,27 @@
  * 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.
  */
 /*
  * SGI-CRM (O2) Framebuffer driver
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: crmfb.c,v 1.37 2013/12/16 15:45:29 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: crmfb.c,v 1.38 2014/09/02 15:44:44 macallan Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/malloc.h>
 #define _SGIMIPS_BUS_DMA_PRIVATE
 #include <machine/autoconf.h>
 #include <sys/bus.h>
 #include <machine/machtype.h>
 #include <machine/vmparam.h>
 #include <dev/arcbios/arcbios.h>
 @@ -143,30 +143,33 @@ struct crmfb_softc {
 	struct crmfb_dma	sc_dma;
 	struct crmfb_dma	sc_dmai;
 	int			sc_width;
 	int			sc_height;
 	int			sc_depth;
 	int			sc_console_depth;
 	int			sc_tiles_x, sc_tiles_y;
 	uint32_t		sc_fbsize;
 	int			sc_mte_direction;
 	int			sc_mte_x_shift;
 	uint32_t		sc_mte_mode;
 	uint32_t		sc_de_mode;
 	uint8_t			*sc_scratch;
 	paddr_t			sc_linear;
-	int			sc_wsmode;
+	uint32_t		sc_vtflags;
-	struct edid_info sc_edid_info;
+	int			sc_wsmode, sc_video_on;
 	uint8_t			sc_edid_data[128];
 	struct edid_info 	sc_edid_info;
 	/* cursor stuff */
 	int			sc_cur_x;
 	int			sc_cur_y;
 	int			sc_hot_x;
 	int			sc_hot_y;
 	u_char			sc_cmap_red[256];
 	u_char			sc_cmap_green[256];
 	u_char			sc_cmap_blue[256];
 };
 static int	crmfb_putcmap(struct crmfb_softc *, struct wsdisplay_cmap *);
 @@ -273,26 +276,30 @@ crmfb_attach(device_t parent, device_t s
 	sc->sc_width = (d >> CRMFB_VT_HCMAP_ON_SHIFT) & 0xfff;
 	d = bus_space_read_4(sc->sc_iot, sc->sc_ioh, CRMFB_VT_VCMAP);
 	sc->sc_height = (d >> CRMFB_VT_VCMAP_ON_SHIFT) & 0xfff;
 	d = bus_space_read_4(sc->sc_iot, sc->sc_ioh, CRMFB_FRM_TILESIZE);
 	h = (d >> CRMFB_FRM_TILESIZE_DEPTH_SHIFT) & 0x3;
 	if (h == 0)
 		sc->sc_depth = 8;
 	else if (h == 1)
 		sc->sc_depth = 16;
 	else
 		sc->sc_depth = 32;
 	if (sc->sc_width == 0 || sc->sc_height == 0) {
 		/*
 		 * XXX
 		 * actually, these days we probably could
 		 */
 		aprint_error_dev(sc->sc_dev,
 		    "device unusable if not setup by firmware\n");
 		bus_space_unmap(sc->sc_iot, sc->sc_ioh, 0 /* XXX */);
 		return;
+	}
 	aprint_normal_dev(sc->sc_dev, "initial resolution %dx%d\n",
 	    sc->sc_width, sc->sc_height);
 	sc->sc_console_depth = 8;
 	crmfb_setup_ddc(sc);
 	if ((sc->sc_edid_info.edid_preferred_mode != NULL)) {
 @@ -357,26 +364,27 @@ crmfb_attach(device_t parent, device_t s
 		p[i] = ((uint32_t)v >> 16) + i;
+	}
 	bus_dmamap_sync(sc->sc_dmat, sc->sc_dmai.map, 0, sc->sc_dmai.size,
 	    BUS_DMASYNC_PREWRITE);
 	sc->sc_scratch = (char *)KERNADDR(sc->sc_dma) + (0xf0000 * sc->sc_tiles_x);
 	sc->sc_linear = (paddr_t)DMAADDR(sc->sc_dma) + 0x100000 * sc->sc_tiles_x;
 	aprint_normal_dev(sc->sc_dev, "allocated %d byte fb @ %p (%p)\n",
 	    sc->sc_fbsize, KERNADDR(sc->sc_dmai), KERNADDR(sc->sc_dma));
 	crmfb_setup_video(sc, sc->sc_console_depth);
 	ri = &crmfb_console_screen.scr_ri;
 	memset(ri, 0, sizeof(struct rasops_info));
 	sc->sc_video_on = 1;
 	vcons_init(&sc->sc_vd, sc, &crmfb_defaultscreen, &crmfb_accessops);
 	sc->sc_vd.init_screen = crmfb_init_screen;
 	crmfb_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC;
 	vcons_init_screen(&sc->sc_vd, &crmfb_console_screen, 1, &defattr);
 	crmfb_defaultscreen.ncols = ri->ri_cols;
 	crmfb_defaultscreen.nrows = ri->ri_rows;
 	crmfb_defaultscreen.textops = &ri->ri_ops;
 	crmfb_defaultscreen.capabilities = ri->ri_caps;
 	crmfb_defaultscreen.modecookie = NULL;
 	crmfb_setup_palette(sc);
 @@ -418,27 +426,27 @@ static int
 crmfb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, struct lwp *l)
+{
 	struct vcons_data *vd;
 	struct crmfb_softc *sc;
 	struct wsdisplay_fbinfo *wdf;
 	int nmode;
 	vd = (struct vcons_data *)v;
 	sc = (struct crmfb_softc *)vd->cookie;
 	switch (cmd) {
 	case WSDISPLAYIO_GTYPE:
 		/* not really, but who cares? */
-		/* wsfb does */
+		/* xf86-video-crime does */
 		*(u_int *)data = WSDISPLAY_TYPE_CRIME;
 		return 0;
 	case WSDISPLAYIO_GINFO:
 		if (vd->active != NULL) {
 			wdf = (void *)data;
 			wdf->height = sc->sc_height;
 			wdf->width = sc->sc_width;
 			wdf->depth = 32;
 			wdf->cmsize = 256;
 			return 0;
 		} else
 			return ENODEV;
 	case WSDISPLAYIO_GETCMAP:
 @@ -458,28 +466,47 @@ crmfb_ioctl(void *v, void *vs, u_long cm
 		nmode = *(int *)data;
 		if (nmode != sc->sc_wsmode) {
 			sc->sc_wsmode = nmode;
 			if (nmode == WSDISPLAYIO_MODE_EMUL) {
 				crmfb_setup_video(sc, sc->sc_console_depth);
 				crmfb_setup_palette(sc);
 				vcons_redraw_screen(vd->active);
 			} else {
 				crmfb_setup_video(sc, 32);
+			}
+		}
 		return 0;
 	case WSDISPLAYIO_SVIDEO:
+		{
 			int d = *(int *)data;
 			if (d == sc->sc_video_on)
 				return 0;
 			sc->sc_video_on = d;
 			if (d == WSDISPLAYIO_VIDEO_ON) {
 				crmfb_write_reg(sc,
 				    CRMFB_VT_FLAGS, sc->sc_vtflags);
 			} else {
 				/* turn all SYNCs off */
 				crmfb_write_reg(sc, CRMFB_VT_FLAGS,
 				    sc->sc_vtflags | CRMFB_VT_FLAGS_VDRV_LOW |
 				     CRMFB_VT_FLAGS_HDRV_LOW |
 				     CRMFB_VT_FLAGS_SYNC_LOW);
+			}
+		}
 		return 0;
 	case WSDISPLAYIO_GVIDEO:
-		return ENODEV;	/* not supported yet */
+		*(int *)data = sc->sc_video_on;
 		return 0;
 	case WSDISPLAYIO_GCURPOS:
+		{
 			struct wsdisplay_curpos *pos;
 			pos = (struct wsdisplay_curpos *)data;
 			pos->x = sc->sc_cur_x;
 			pos->y = sc->sc_cur_y;
+		}
 		return 0;
 	case WSDISPLAYIO_SCURPOS:
+		{
 			struct wsdisplay_curpos *pos;
 @@ -501,26 +528,36 @@ crmfb_ioctl(void *v, void *vs, u_long cm
+		{
 			struct wsdisplay_cursor *cu;
 			cu = (struct wsdisplay_cursor *)data;
 			return crmfb_gcursor(sc, cu);
+		}
 	case WSDISPLAYIO_SCURSOR:
+		{
 			struct wsdisplay_cursor *cu;
 			cu = (struct wsdisplay_cursor *)data;
 			return crmfb_scursor(sc, cu);
+		}
 	case WSDISPLAYIO_GET_EDID: {
 		struct wsdisplayio_edid_info *d = data;
 		d->data_size = 128;
 		if (d->buffer_size < 128)
 			return EAGAIN;
 		if (sc->sc_edid_data[1] == 0)
 			return ENODATA;
 		return copyout(sc->sc_edid_data, d->edid_data, 128);
+	}
+	}
 	return EPASSTHROUGH;
+}
 static paddr_t
 crmfb_mmap(void *v, void *vs, off_t offset, int prot)
+{
 	struct vcons_data *vd;
 	struct crmfb_softc *sc;
 	paddr_t pa;
 	vd = (struct vcons_data *)v;
 	sc = (struct crmfb_softc *)vd->cookie;
 @@ -557,42 +594,45 @@ crmfb_init_screen(void *c, struct vcons_
     long *defattr)
+{
 	struct crmfb_softc *sc;
 	struct rasops_info *ri;
 	sc = (struct crmfb_softc *)c;
 	ri = &scr->scr_ri;
 	ri->ri_flg = RI_CENTER | RI_FULLCLEAR;
 	ri->ri_depth = sc->sc_console_depth;
 	ri->ri_width = sc->sc_width;
 	ri->ri_height = sc->sc_height;
 	ri->ri_stride = ri->ri_width * (ri->ri_depth / 8);
 #if 1
 	switch (ri->ri_depth) {
 	case 8:
 		ri->ri_flg |= RI_8BIT_IS_RGB;
 		break;
 	case 16:
 		ri->ri_rnum = ri->ri_gnum = ri->ri_bnum = 5;
 		ri->ri_rpos = 11;
 		ri->ri_gpos = 6;
 		ri->ri_bpos = 1;
 		break;
 	case 32:
 		ri->ri_rnum = ri->ri_gnum = ri->ri_bnum = 8;
 		ri->ri_rpos = 8;
 		ri->ri_gpos = 16;
 		ri->ri_bpos = 24;
 		break;
+	}
 #endif
 	ri->ri_bits = KERNADDR(sc->sc_dma);
 	if (existing)
 		ri->ri_flg |= RI_CLEAR;
 	rasops_init(ri, 0, 0);
 	ri->ri_caps = WSSCREEN_WSCOLORS;
 	rasops_reconfig(ri, ri->ri_height / ri->ri_font->fontheight,
 	    ri->ri_width / ri->ri_font->fontwidth);
 	ri->ri_hw = scr;
 	ri->ri_ops.cursor    = crmfb_cursor;
 	ri->ri_ops.copyrows  = crmfb_copyrows;
 @@ -804,27 +844,27 @@ crmfb_wait_dma_idle(struct crmfb_softc *
 		       ((bus_space_read_4(sc->sc_iot, sc->sc_ioh,
 		         CRMFB_DID_CONTROL) & 1) == 0);
 		if (!idle)
 			delay(10);
 		bail--;
 	} while ((!idle) && (bail > 0));
 	return idle;
+}
 static int
 crmfb_setup_video(struct crmfb_softc *sc, int depth)
+{
 	uint64_t reg;
-	uint32_t d, h, mode, page;
+	uint32_t d, h, page;
 	int i, bail, tile_width, tlbptr, lptr, j, tx, shift, overhang;
 	const char *wantsync;
 	uint16_t v;
 	/* disable DMA */
 	d = bus_space_read_4(sc->sc_iot, sc->sc_ioh, CRMFB_OVR_CONTROL);
 	d &= ~(1 << CRMFB_OVR_CONTROL_DMAEN_SHIFT);
 	crmfb_write_reg(sc, CRMFB_OVR_CONTROL, d);
 	DELAY(50000);
 	d = bus_space_read_4(sc->sc_iot, sc->sc_ioh, CRMFB_FRM_CONTROL);
 	d &= ~(1 << CRMFB_FRM_CONTROL_DMAEN_SHIFT);
 	crmfb_write_reg(sc, CRMFB_FRM_CONTROL, d);
 	DELAY(50000);
 @@ -852,27 +892,27 @@ crmfb_setup_video(struct crmfb_softc *sc
 		bail--;
+	}
 	/* reset FIFO */
 	d = bus_space_read_4(sc->sc_iot, sc->sc_ioh, CRMFB_FRM_TILESIZE);
 	d |= (1 << CRMFB_FRM_TILESIZE_FIFOR_SHIFT);
 	crmfb_write_reg(sc, CRMFB_FRM_TILESIZE, d);
 	d &= ~(1 << CRMFB_FRM_TILESIZE_FIFOR_SHIFT);
 	crmfb_write_reg(sc, CRMFB_FRM_TILESIZE, d);
 	/* setup colour mode */
 	switch (depth) {
 	case 8:
-		h = CRMFB_MODE_TYP_I8;
+		h = CRMFB_MODE_TYP_RG3B2;
 		tile_width = 512;
 		break;
 	case 16:
 		h = CRMFB_MODE_TYP_ARGB5;
 		tile_width = 256;
 		break;
 	case 32:
 		h = CRMFB_MODE_TYP_RGB8;
 		tile_width = 128;
 		break;
 	default:
 		panic("Unsupported depth");
+	}
 @@ -933,29 +973,27 @@ crmfb_setup_video(struct crmfb_softc *sc
 	d |= (1 << CRMFB_FRM_CONTROL_DMAEN_SHIFT);
 	crmfb_write_reg(sc, CRMFB_FRM_CONTROL, d);
 	/* enable drawing again */
 	crmfb_write_reg(sc, CRMFB_VT_XY, 0);
 	d = bus_space_read_4(sc->sc_iot, sc->sc_ioh, CRMFB_DOTCLOCK);
 	d |= (1 << CRMFB_DOTCLOCK_CLKRUN_SHIFT);
 	crmfb_write_reg(sc, CRMFB_DOTCLOCK, d);
 	/* turn off sync-on-green */
 	wantsync = arcbios_GetEnvironmentVariable("SyncOnGreen");
 	if ( (wantsync != NULL) && (wantsync[0] == 'n') ) {
-		d = ( 1 << CRMFB_VT_FLAGS_SYNC_LOW_LSB) &
+		sc->sc_vtflags |= CRMFB_VT_FLAGS_SYNC_LOW;
 		    CRMFB_REG_MASK(CRMFB_VT_FLAGS_SYNC_LOW_MSB,
 		    CRMFB_VT_FLAGS_SYNC_LOW_LSB);
 		crmfb_write_reg(sc, CRMFB_VT_FLAGS, d);
+	}
 	sc->sc_depth = depth;
 	/* finally set up the drawing engine's TLB A */
 	v = (DMAADDR(sc->sc_dma) >> 16) & 0xffff;
 	tlbptr = 0;
 	tx = ((sc->sc_width + (tile_width - 1)) & ~(tile_width - 1)) /
 	    tile_width;
 	DPRINTF("tx: %d\n", tx);
 @@ -1003,58 +1041,60 @@ crmfb_setup_video(struct crmfb_softc *sc
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_WINOFFSET_SRC, 0);
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_WINOFFSET_DST, 0);
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_PLANEMASK,
 xffffffff);
 	bus_space_write_8(sc->sc_iot, sc->sc_reh, 0x20, 0);
 	bus_space_write_8(sc->sc_iot, sc->sc_reh, 0x28, 0);
 	bus_space_write_8(sc->sc_iot, sc->sc_reh, 0x30, 0);
 	bus_space_write_8(sc->sc_iot, sc->sc_reh, 0x38, 0);
 	bus_space_write_8(sc->sc_iot, sc->sc_reh, 0x40, 0);
 	switch (depth) {
 		case 8:
-			mode = DE_MODE_TLB_A | DE_MODE_BUFDEPTH_8 |
+			sc->sc_de_mode = DE_MODE_TLB_A | DE_MODE_BUFDEPTH_8 |
 			    DE_MODE_TYPE_CI | DE_MODE_PIXDEPTH_8;
 			sc->sc_mte_mode = MTE_MODE_DST_ECC |
 			    (MTE_TLB_A << MTE_DST_TLB_SHIFT) |
 			    (MTE_TLB_A << MTE_SRC_TLB_SHIFT) |
 			    (MTE_DEPTH_8 << MTE_DEPTH_SHIFT);
 			sc->sc_mte_x_shift = 0;
 			break;
 		case 16:
-			mode = DE_MODE_TLB_A | DE_MODE_BUFDEPTH_16 |
+			sc->sc_de_mode = DE_MODE_TLB_A | DE_MODE_BUFDEPTH_16 |
 			    DE_MODE_TYPE_RGBA | DE_MODE_PIXDEPTH_16;
 			sc->sc_mte_mode = MTE_MODE_DST_ECC |
 			    (MTE_TLB_A << MTE_DST_TLB_SHIFT) |
 			    (MTE_TLB_A << MTE_SRC_TLB_SHIFT) |
 			    (MTE_DEPTH_16 << MTE_DEPTH_SHIFT);
 			sc->sc_mte_x_shift = 1;
 			break;
 		case 32:
-			mode = DE_MODE_TLB_A | DE_MODE_BUFDEPTH_32 |
+			sc->sc_de_mode = DE_MODE_TLB_A | DE_MODE_BUFDEPTH_32 |
 			    DE_MODE_TYPE_RGBA | DE_MODE_PIXDEPTH_32;
 			break;
 			sc->sc_mte_mode = MTE_MODE_DST_ECC |
 			    (MTE_TLB_A << MTE_DST_TLB_SHIFT) |
 			    (MTE_TLB_A << MTE_SRC_TLB_SHIFT) |
 			    (MTE_DEPTH_32 << MTE_DEPTH_SHIFT);
 			sc->sc_mte_x_shift = 2;
 		default:
 			panic("%s: unsuported colour depth %d\n", __func__,
 			    depth);
+	}
-	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_MODE_DST, mode);
+	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_MODE_DST,
-	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_MODE_SRC, mode);
+	    sc->sc_de_mode);
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_MODE_SRC,
 	    sc->sc_de_mode);
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_XFER_STEP_X, 1);
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_XFER_STEP_Y, 1);
 	/* initialize memory transfer engine */
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_MTE_MODE,
 	    sc->sc_mte_mode | MTE_MODE_COPY);
 	sc->sc_mte_direction = 1;
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_MTE_DST_Y_STEP, 1);
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_MTE_SRC_Y_STEP, 1);
 	return 0;
+}
 @@ -1113,26 +1153,28 @@ crmfb_fill_rect(struct crmfb_softc *sc,
 	    (rxa << 16) | (y & 0xffff));
 	bus_space_write_4(sc->sc_iot, sc->sc_reh,
 	    CRIME_MTE_DST1 | CRIME_DE_START,
 	    (rxe << 16) | ((y + height - 1) & 0xffff));
+}
 static void
 crmfb_bitblt(struct crmfb_softc *sc, int xs, int ys, int xd, int yd,
     int wi, int he, uint32_t rop)
+{
 	uint32_t prim = DE_PRIM_RECTANGLE;
 	int rxa, rya, rxe, rye, rxs, rys;
 	crmfb_wait_idle(sc);
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_MODE_SRC,
 	    sc->sc_de_mode);
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_DRAWMODE,
 	    DE_DRAWMODE_PLANEMASK | DE_DRAWMODE_BYTEMASK | DE_DRAWMODE_ROP |
 	    DE_DRAWMODE_XFER_EN);
 	bus_space_write_4(sc->sc_iot, sc->sc_reh, CRIME_DE_ROP, rop);
 	if (xs < xd) {
 		prim |= DE_PRIM_RL;
 		rxe = xd;
 		rxa = xd + wi - 1;
 		rxs = xs + wi - 1;
 	} else {
 		prim |= DE_PRIM_LR;
 		rxe = xd + wi - 1;
 		rxa = xd;
 @@ -1374,46 +1416,45 @@ crmfb_putchar(void *cookie, int row, int
 				    CRIME_DE_X_VERTEX_1 | CRIME_DE_START,
 				    ((x + wi) << 16) | y);
 				y++;
 				fd16++;
+			}
+		}
+	}
+}
 static void
 crmfb_setup_ddc(struct crmfb_softc *sc)
+{
 	int i;
 	char edid_data[128];
-	memset(edid_data, 0, 128);
+	memset(sc->sc_edid_data, 0, 128);
 	sc->sc_i2c.ic_cookie = sc;
 	sc->sc_i2c.ic_acquire_bus = crmfb_i2c_acquire_bus;
 	sc->sc_i2c.ic_release_bus = crmfb_i2c_release_bus;
 	sc->sc_i2c.ic_send_start = crmfb_i2c_send_start;
 	sc->sc_i2c.ic_send_stop = crmfb_i2c_send_stop;
 	sc->sc_i2c.ic_initiate_xfer = crmfb_i2c_initiate_xfer;
 	sc->sc_i2c.ic_read_byte = crmfb_i2c_read_byte;
 	sc->sc_i2c.ic_write_byte = crmfb_i2c_write_byte;
 	sc->sc_i2c.ic_exec = NULL;
 	i = 0;
-	while (edid_data[1] == 0 && i++ < 10)
+	while (sc->sc_edid_data[1] == 0 && i++ < 10)
-		ddc_read_edid(&sc->sc_i2c, edid_data, 128);
+		ddc_read_edid(&sc->sc_i2c, sc->sc_edid_data, 128);
 	if (i > 1)
 		aprint_debug_dev(sc->sc_dev,
 		    "had to try %d times to get EDID data\n", i);
 	if (i < 11) {
-		edid_parse(edid_data, &sc->sc_edid_info);
+		edid_parse(sc->sc_edid_data, &sc->sc_edid_info);
 		edid_print(&sc->sc_edid_info);
+	}
+}
 /* I2C bitbanging */
 static void
 crmfb_i2cbb_set_bits(void *cookie, uint32_t bits)
+{
 	struct crmfb_softc *sc = cookie;
 	bus_space_write_4(sc->sc_iot, sc->sc_ioh, CRMFB_I2C_VGA, bits ^ 3);
+}
 @@ -1600,26 +1641,27 @@ crmfb_set_mode(struct crmfb_softc *sc, c
 	d = (mode->htotal - 5) | ((mode->hdisplay - 5) << 12);
 	crmfb_write_reg(sc, CRMFB_VT_HBLANK, d);
 	d = mode->vtotal | (mode->vdisplay << 12);
 	crmfb_write_reg(sc, CRMFB_VT_VCMAP, d);
 	d = mode->htotal | (mode->hdisplay << 12);
 	crmfb_write_reg(sc, CRMFB_VT_HCMAP, d);
 	d = 0;
 	if (mode->flags & VID_NHSYNC) d |= CRMFB_VT_FLAGS_HDRV_INVERT;
 	if (mode->flags & VID_NVSYNC) d |= CRMFB_VT_FLAGS_VDRV_INVERT;
 	crmfb_write_reg(sc, CRMFB_VT_FLAGS, d);
 	sc->sc_vtflags = d;
 	diff = -abs(mode->vtotal - mode->vdisplay - 1);
 	d = ((uint32_t)diff << 12) & 0x00fff000;
 	d |= (mode->htotal - 20);
 	crmfb_write_reg(sc, CRMFB_VT_DID_STARTXY, d);
 	d = ((uint32_t)(diff + 1) << 12) & 0x00fff000;
 	d |= (mode->htotal - 54);
 	crmfb_write_reg(sc, CRMFB_VT_CRS_STARTXY, d);
 	d = ((uint32_t)diff << 12) & 0x00fff000;
 	d |= (mode->htotal - 4);
 	crmfb_write_reg(sc, CRMFB_VT_VC_STARTXY, d);