add support for tga2; from NetBSD

7 files changed, 645 insertions, 1596 deletions

diff --git a/sys/dev/pci/files.pci b/sys/dev/pci/files.pci
index 103da7c300d..dd248516bf0 100644
--- a/sys/dev/pci/files.pci
+++ b/sys/dev/pci/files.pci
@@ -1,4 +1,4 @@
-#	$OpenBSD: files.pci,v 1.79 2000/07/20 21:45:19 deraadt Exp $
+#	$OpenBSD: files.pci,v 1.80 2000/08/04 16:00:56 ericj Exp $
 #	$NetBSD: files.pci,v 1.20 1996/09/24 17:47:15 christos Exp $
 #
 # Config file and device description for machine-independent PCI code.
@@ -24,8 +24,8 @@ device	tga: wsemuldisplaydev, wsrasteremulops
 attach	tga at pci
 file	dev/pci/tga.c			tga		needs-flag
 file	dev/pci/tga_conf.c		tga
-file	dev/pci/tga_bt463.c		tga
-file	dev/pci/tga_bt485.c		tga
+file	dev/ic/bt463.c			tga
+file	dev/ic/bt485.c			tga
 
 # Cypress 82c693 hyperCache(tm) Stand-Alone PCI Peripheral Controller
 # with USB.  This is a combo chip:
diff --git a/sys/dev/pci/tga.c b/sys/dev/pci/tga.c
index d7033c29ddb..ba99edd1d8a 100644
--- a/sys/dev/pci/tga.c
+++ b/sys/dev/pci/tga.c
@@ -47,6 +47,7 @@
 #include <dev/pci/tgareg.h>
 #include <dev/pci/tgavar.h>
 #include <dev/ic/bt485reg.h>
+#include <dev/ic/bt485var.h>
 
 #include <dev/rcons/raster.h>
 #include <dev/wscons/wsconsio.h>
@@ -67,8 +68,8 @@ struct cfattach tga_ca = {
 
 int	tga_identify __P((tga_reg_t *));
 const struct tga_conf *tga_getconf __P((int));
-void	tga_getdevconfig __P((bus_space_tag_t memt, pci_chipset_tag_t pc,
-	    pcitag_t tag, struct tga_devconfig *dc));
+void    tga_getdevconfig __P((bus_space_tag_t memt, pci_chipset_tag_t pc,
+            pcitag_t tag, struct tga_devconfig *dc));
 
 struct tga_devconfig tga_console_dc;
 
@@ -89,6 +90,18 @@ static int tga_rop_htov __P((struct raster *, int, int, int, int,
 static int tga_rop_vtov __P((struct raster *, int, int, int, int,
 	int, struct raster *, int, int ));
 
+void tga2_init __P((struct tga_devconfig *, int));
+
+/* RAMDAC interface functions */
+int             tga_sched_update __P((void *, void (*)(void *)));
+void            tga_ramdac_wr __P((void *, u_int, u_int8_t));
+u_int8_t        tga_ramdac_rd __P((void *, u_int));
+void            tga2_ramdac_wr __P((void *, u_int, u_int8_t));
+u_int8_t        tga2_ramdac_rd __P((void *, u_int));
+
+/* Interrupt handler */
+int     tga_intr __P((void *));
+
 struct wsdisplay_emulops tga_emulops = {
 	rcons_cursor,			/* could use hardware cursor; punt */
 	rcons_mapchar,
@@ -137,11 +150,17 @@ tgamatch(parent, match, aux)
 {
 	struct pci_attach_args *pa = aux;
 
-	if (PCI_VENDOR(pa->pa_id) != PCI_VENDOR_DEC ||
-	    PCI_PRODUCT(pa->pa_id) != PCI_PRODUCT_DEC_21030)
-		return (0);
-
-	return (10);
+	if (PCI_VENDOR(pa->pa_id) != PCI_VENDOR_DEC)
+                return (0);
+
+        switch (PCI_PRODUCT(pa->pa_id)) {
+        case PCI_PRODUCT_DEC_21030:
+        case PCI_PRODUCT_DEC_PBXGB:
+                return 10;
+        default:
+                return 0;
+        }
+        return (0);
 }
 
 void
@@ -152,7 +171,6 @@ tga_getdevconfig(memt, pc, tag, dc)
 	struct tga_devconfig *dc;
 {
 	const struct tga_conf *tgac;
-	const struct tga_ramdac_conf *tgar;
 	struct raster *rap;
 	struct rcons *rcp;
 	bus_size_t pcisize;
@@ -182,6 +200,7 @@ printf("bus_space_map(%x, %x, %x, 0, %p): %d\n", memt, dc->dc_pcipaddr, pcisize,
 
 	dc->dc_regs = (tga_reg_t *)(dc->dc_vaddr + TGA_MEM_CREGS);
 	dc->dc_tga_type = tga_identify(dc->dc_regs);
+
 	tgac = dc->dc_tgaconf = tga_getconf(dc->dc_tga_type);
 	if (tgac == NULL) {
 printf("tgac==0\n");
@@ -194,7 +213,28 @@ printf("tgac==0\n");
 		panic("tga_getdevconfig: memory size mismatch?");
 #endif
 
-	tgar = tgac->tgac_ramdac;
+	switch (dc->dc_regs[TGA_REG_GREV] & 0xff) {
+	case 0x01:
+	case 0x02:
+	case 0x03:
+	case 0x04:
+		dc->dc_tga2 = 0;
+		break;
+	case 0x20:
+	case 0x21:
+	case 0x22:
+		dc->dc_tga2 = 1;
+		break;
+	default:
+		panic("tga_getdevconfig: TGA Revision not recognized");
+	}
+
+	if (dc->dc_tga2) {
+		int        monitor;
+
+		monitor = (~dc->dc_regs[TGA_REG_GREV] >> 16) & 0x0f;
+		tga2_init(dc, monitor);
+	}
 
 	switch (dc->dc_regs[TGA_REG_VHCR] & 0x1ff) {		/* XXX */
 	case 0:
@@ -291,74 +331,95 @@ tgaattach(parent, self, aux)
 		sc->sc_dc = (struct tga_devconfig *)
 		    malloc(sizeof(struct tga_devconfig), M_DEVBUF, M_WAITOK);
 		bzero(sc->sc_dc, sizeof(struct tga_devconfig));
-		tga_getdevconfig(pa->pa_memt, pa->pa_pc, pa->pa_tag, sc->sc_dc);
+		tga_getdevconfig(pa->pa_memt, pa->pa_pc, pa->pa_tag, 
+			sc->sc_dc);
 	}
 	if (sc->sc_dc->dc_vaddr == NULL) {
 		printf(": couldn't map memory space; punt!\n");
 		return;
 	}
 
-	/* XXX say what's going on. */
-	intrstr = NULL;
-	if (sc->sc_dc->dc_tgaconf->tgac_ramdac->tgar_intr != NULL) {
-		if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
-		    pa->pa_intrline, &intrh)) {
-			printf(": couldn't map interrupt");
-			return;
-		}
-		intrstr = pci_intr_string(pa->pa_pc, intrh);
-		sc->sc_intr = pci_intr_establish(pa->pa_pc, intrh, IPL_TTY,
-		    sc->sc_dc->dc_tgaconf->tgac_ramdac->tgar_intr, sc->sc_dc,
-		    sc->sc_dev.dv_xname);
-		if (sc->sc_intr == NULL) {
-			printf(": couldn't establish interrupt");
-			if (intrstr != NULL)
-				printf("at %s", intrstr);
-			printf("\n");
-			return;
-		}
-	}
-
-	/*
-	 * Initialize the RAMDAC and allocate any private storage it needs.
-	 * Initialization includes disabling cursor, setting a sane
-	 * colormap, etc.
-	 */
-	(*sc->sc_dc->dc_tgaconf->tgac_ramdac->tgar_init)(sc->sc_dc, 1);
-
-	printf(": DC21030 ");
-	rev = PCI_REVISION(pa->pa_class);
-	switch (rev) {
-	case 1: case 2: case 3:
-		printf("step %c", 'A' + rev - 1);
-		break;
-
-	default:
-		printf("unknown stepping (0x%x)", rev);
-		break;
-	}
-	printf(", ");
-
-	if (sc->sc_dc->dc_tgaconf == NULL) {
-		printf("unknown board configuration\n");
-		return;
-	}
-	printf("board type %s\n", sc->sc_dc->dc_tgaconf->tgac_name);
-	printf("%s: %d x %d, %dbpp, %s RAMDAC\n", sc->sc_dev.dv_xname,
-	    sc->sc_dc->dc_wid, sc->sc_dc->dc_ht,
-	    sc->sc_dc->dc_tgaconf->tgac_phys_depth,
-	    sc->sc_dc->dc_tgaconf->tgac_ramdac->tgar_name);
-
-	if (intrstr != NULL)
-		printf("%s: interrupting at %s\n", sc->sc_dev.dv_xname,
-		    intrstr);
-
-	aa.console = console;
-	aa.scrdata = &tga_screenlist;
-	aa.accessops = &tga_accessops;
-	aa.accesscookie = sc;
-
-	config_found(self, &aa, wsemuldisplaydevprint);
+        /* XXX say what's going on. */
+        intrstr = NULL;
+        if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
+            pa->pa_intrline, &intrh)) {
+                printf(": couldn't map interrupt");
+                return;
+        }
+        intrstr = pci_intr_string(pa->pa_pc, intrh);
+        sc->sc_intr = pci_intr_establish(pa->pa_pc, intrh, IPL_TTY, tga_intr,
+            sc->sc_dc, sc->sc_dev.dv_xname);
+        if (sc->sc_intr == NULL) {
+                printf(": couldn't establish interrupt");
+                if (intrstr != NULL)
+                        printf("at %s", intrstr);
+                printf("\n");
+                return;
+        }
+
+        rev = PCI_REVISION(pa->pa_class);
+        switch (rev) {
+        case 0x1:
+        case 0x2:
+        case 0x3:
+                printf(": DC21030 step %c", 'A' + rev - 1);
+                break;
+        case 0x20:
+                printf(": TGA2 abstract software model");
+                break;
+        case 0x21: 
+	case 0x22:
+                printf(": TGA2 pass %d", rev - 0x20);
+                break;
+
+        default:
+                printf("unknown stepping (0x%x)", rev);
+                break;
+        }
+        printf(", ");
+
+        /*
+         * Get RAMDAC function vectors and call the RAMDAC functions
+         * to allocate its private storage and pass that back to us.
+         */
+        sc->sc_dc->dc_ramdac_funcs = bt485_funcs();
+        if (!sc->sc_dc->dc_tga2) {
+                sc->sc_dc->dc_ramdac_cookie = bt485_register(
+                    sc->sc_dc, tga_sched_update, tga_ramdac_wr,
+                    tga_ramdac_rd);
+        } else {
+                sc->sc_dc->dc_ramdac_cookie = bt485_register(
+                    sc->sc_dc, tga_sched_update, tga2_ramdac_wr,
+                    tga2_ramdac_rd);
+        }
+
+        /*
+         * Initialize the RAMDAC.  Initialization includes disabling
+         * cursor, setting a sane colormap, etc.
+         */
+        (*sc->sc_dc->dc_ramdac_funcs->ramdac_init)(sc->sc_dc->dc_ramdac_cookie);
+        sc->sc_dc->dc_regs[TGA_REG_SISR] = 0x00000001;                 /* XXX */
+
+        if (sc->sc_dc->dc_tgaconf == NULL) {
+                printf("unknown board configuration\n");
+                return;
+        }
+        printf("board type %s\n", sc->sc_dc->dc_tgaconf->tgac_name);
+        printf("%s: %d x %d, %dbpp, %s RAMDAC\n", sc->sc_dev.dv_xname,
+            sc->sc_dc->dc_wid, sc->sc_dc->dc_ht,
+            sc->sc_dc->dc_tgaconf->tgac_phys_depth,
+            sc->sc_dc->dc_ramdac_funcs->ramdac_name);
+
+        if (intrstr != NULL)
+                printf("%s: interrupting at %s\n", sc->sc_dev.dv_xname,
+                    intrstr);
+
+        aa.console = console;
+        aa.scrdata = &tga_screenlist;
+        aa.accessops = &tga_accessops;
+        aa.accesscookie = sc;
+
+        config_found(self, &aa, wsemuldisplaydevprint);
 }
 
 int
@@ -371,63 +432,91 @@ tga_ioctl(v, cmd, data, flag, p)
 {
 	struct tga_softc *sc = v;
 	struct tga_devconfig *dc = sc->sc_dc;
-	const struct tga_ramdac_conf *tgar = dc->dc_tgaconf->tgac_ramdac;
-
-	switch (cmd) {
-	case WSDISPLAYIO_GTYPE:
-		*(u_int *)data = WSDISPLAY_TYPE_TGA;
-		return (0);
-
-	case WSDISPLAYIO_GINFO:
-#define	wsd_fbip ((struct wsdisplay_fbinfo *)data)
-		wsd_fbip->height = sc->sc_dc->dc_ht;
-		wsd_fbip->width = sc->sc_dc->dc_wid;
-		wsd_fbip->depth = sc->sc_dc->dc_tgaconf->tgac_phys_depth;
-		wsd_fbip->cmsize = 256;		/* XXX ??? */
+        struct ramdac_funcs *dcrf = dc->dc_ramdac_funcs;
+        struct ramdac_cookie *dcrc = dc->dc_ramdac_cookie;
+
+        switch (cmd) {
+        case WSDISPLAYIO_GTYPE:
+                *(u_int *)data = WSDISPLAY_TYPE_TGA;
+                return (0);
+
+        case WSDISPLAYIO_GINFO:
+#define wsd_fbip ((struct wsdisplay_fbinfo *)data)
+                wsd_fbip->height = sc->sc_dc->dc_ht;
+                wsd_fbip->width = sc->sc_dc->dc_wid;
+                wsd_fbip->depth = sc->sc_dc->dc_tgaconf->tgac_phys_depth;
+                wsd_fbip->cmsize = 256;                /* XXX ??? */
 #undef wsd_fbip
-		return (0);
-
-	case WSDISPLAYIO_GETCMAP:
-		return (*tgar->tgar_get_cmap)(dc,
-		    (struct wsdisplay_cmap *)data);
-
-	case WSDISPLAYIO_PUTCMAP:
-		return (*tgar->tgar_set_cmap)(dc,
-		    (struct wsdisplay_cmap *)data);
-
-	case WSDISPLAYIO_SVIDEO:
-		if (*(u_int *)data == WSDISPLAYIO_VIDEO_OFF)
-			tga_blank(sc->sc_dc);
-		else
-			tga_unblank(sc->sc_dc);
-		return (0);
-
-	case WSDISPLAYIO_GVIDEO:
-		*(u_int *)data = dc->dc_blanked ?
-		    WSDISPLAYIO_VIDEO_OFF : WSDISPLAYIO_VIDEO_ON;
-		return (0);
-
-	case WSDISPLAYIO_GCURPOS:
-		return (*tgar->tgar_get_curpos)(dc,
-		    (struct wsdisplay_curpos *)data);
-
-	case WSDISPLAYIO_SCURPOS:
-		return (*tgar->tgar_set_curpos)(dc,
-		    (struct wsdisplay_curpos *)data);
+                return (0);
+
+        case WSDISPLAYIO_GETCMAP:
+                return (*dcrf->ramdac_get_cmap)(dcrc,
+                    (struct wsdisplay_cmap *)data);
+
+        case WSDISPLAYIO_PUTCMAP:
+                return (*dcrf->ramdac_set_cmap)(dcrc,
+                    (struct wsdisplay_cmap *)data);
+
+        case WSDISPLAYIO_SVIDEO:
+                if (*(u_int *)data == WSDISPLAYIO_VIDEO_OFF)
+                        tga_blank(sc->sc_dc);
+                else
+                        tga_unblank(sc->sc_dc);
+                return (0);
+
+        case WSDISPLAYIO_GVIDEO:
+                *(u_int *)data = dc->dc_blanked ?
+                    WSDISPLAYIO_VIDEO_OFF : WSDISPLAYIO_VIDEO_ON;
+                return (0);
+
+        case WSDISPLAYIO_GCURPOS:
+                return (*dcrf->ramdac_get_curpos)(dcrc,
+                    (struct wsdisplay_curpos *)data);
+
+        case WSDISPLAYIO_SCURPOS:
+                return (*dcrf->ramdac_set_curpos)(dcrc,
+                    (struct wsdisplay_curpos *)data);
+
+        case WSDISPLAYIO_GCURMAX:
+                return (*dcrf->ramdac_get_curmax)(dcrc,
+                    (struct wsdisplay_curpos *)data);
+
+        case WSDISPLAYIO_GCURSOR:
+                return (*dcrf->ramdac_get_cursor)(dcrc,
+                    (struct wsdisplay_cursor *)data);
+
+        case WSDISPLAYIO_SCURSOR:
+                return (*dcrf->ramdac_set_cursor)(dcrc,
+                    (struct wsdisplay_cursor *)data);
+        }
+        return (-1);
+}
 
-	case WSDISPLAYIO_GCURMAX:
-		return (*tgar->tgar_get_curmax)(dc,
-		    (struct wsdisplay_curpos *)data);
+int
+tga_sched_update(v, f)
+        void        *v;
+        void        (*f) __P((void *));
+{
+        struct tga_devconfig *dc = v;
 
-	case WSDISPLAYIO_GCURSOR:
-		return (*tgar->tgar_get_cursor)(dc,
-		    (struct wsdisplay_cursor *)data);
+        dc->dc_regs[TGA_REG_SISR] = 0x00010000;
+        dc->dc_ramdac_intr = f;
+        return 0;
+}
 
-	case WSDISPLAYIO_SCURSOR:
-		return (*tgar->tgar_set_cursor)(dc,
-		    (struct wsdisplay_cursor *)data);
-	}
-	return (-1);
+int
+tga_intr(v)
+        void *v;
+{
+        struct tga_devconfig *dc = v;
+        struct ramdac_cookie *dcrc= dc->dc_ramdac_cookie;
+
+        if ((dc->dc_regs[TGA_REG_SISR] & 0x00010001) != 0x00010001)
+                return 0;
+        dc->dc_ramdac_intr(dcrc);
+        dc->dc_ramdac_intr = NULL;
+        dc->dc_regs[TGA_REG_SISR] = 0x00000001;
+        return (1);
 }
 
 int
@@ -507,8 +596,9 @@ tga_cnattach(iot, memt, pc, bus, device, function)
 	struct tga_devconfig *dcp = &tga_console_dc;
 	long defattr;
 
-	tga_getdevconfig(memt, pc,
-	    pci_make_tag(pc, bus, device, function), dcp);
+        /* XXX -- we know this isn't a TGA2 for now.  rcd */
+        tga_getdevconfig(memt, pc,
+            pci_make_tag(pc, bus, device, function), dcp);
 
 	/* sanity checks */
 	if (dcp->dc_vaddr == NULL)
@@ -523,7 +613,16 @@ tga_cnattach(iot, memt, pc, bus, device, function)
 	 * Initialization includes disabling cursor, setting a sane
 	 * colormap, etc.  It will be reinitialized in tgaattach().
 	 */
-	(*dcp->dc_tgaconf->tgac_ramdac->tgar_init)(dcp, 0);
+
+        /* XXX -- this only works for bt485, but then we only support that,
+         *  currently. 
+         */
+	if (dcp->dc_tga2) 
+		bt485_cninit(dcp, tga_sched_update, tga2_ramdac_wr,
+			tga2_ramdac_rd);
+	else
+		bt485_cninit(dcp, tga_sched_update, tga_ramdac_wr,
+			tga_ramdac_rd);
 
 	rcons_alloc_attr(&dcp->dc_rcons, 0, 0, 0, &defattr);
 
@@ -566,12 +665,13 @@ tga_builtin_set_cursor(dc, cursorp)
 	struct tga_devconfig *dc;
 	struct wsdisplay_cursor *cursorp;
 {
+        struct ramdac_funcs *dcrf = dc->dc_ramdac_funcs;
+        struct ramdac_cookie *dcrc = dc->dc_ramdac_cookie;
 	int count, error, v;
 
 	v = cursorp->which;
 	if (v & WSDISPLAY_CURSOR_DOCMAP) {
-		error = (*dc->dc_tgaconf->tgac_ramdac->tgar_check_curcmap)(dc,
-		    cursorp);
+		error = dcrf->ramdac_check_curcmap(dcrc, cursorp);
 		if (error)
 			return (error);
 	}
@@ -605,7 +705,7 @@ tga_builtin_set_cursor(dc, cursorp)
 	}
 	if (v & WSDISPLAY_CURSOR_DOCMAP) {
 		/* can't fail. */
-		(*dc->dc_tgaconf->tgac_ramdac->tgar_set_curcmap)(dc, cursorp);
+		dcrf->ramdac_set_curcmap(dcrc, cursorp);
 	}
 	if (v & WSDISPLAY_CURSOR_DOSHAPE) {
 		count = ((64 * 2) / NBBY) * cursorp->size.y;
@@ -624,27 +724,29 @@ tga_builtin_get_cursor(dc, cursorp)
 	struct tga_devconfig *dc;
 	struct wsdisplay_cursor *cursorp;
 {
-	int count, error;
-
-	cursorp->which = WSDISPLAY_CURSOR_DOALL &
-	    ~(WSDISPLAY_CURSOR_DOHOT | WSDISPLAY_CURSOR_DOCMAP);
-	cursorp->enable = (dc->dc_regs[TGA_REG_VVVR] & 0x04) != 0;
-	cursorp->pos.x = dc->dc_regs[TGA_REG_CXYR] & 0xfff;
-	cursorp->pos.y = (dc->dc_regs[TGA_REG_CXYR] >> 12) & 0xfff;
-	cursorp->size.x = 64;
-	cursorp->size.y = (dc->dc_regs[TGA_REG_CCBR] >> 10) & 0x3f;
-
-	if (cursorp->image != NULL) {
-		count = (cursorp->size.y * 64 * 2) / NBBY;
-		error = copyout((char *)(dc->dc_vaddr +
-		      (dc->dc_regs[TGA_REG_CCBR] & 0x3ff)),
-		    cursorp->image, count);
-		if (error)
-			return (error);
-		/* No mask */
-	}
-	error = (*dc->dc_tgaconf->tgac_ramdac->tgar_get_curcmap)(dc, cursorp);
-	return (error);
+        struct ramdac_funcs *dcrf = dc->dc_ramdac_funcs;
+        struct ramdac_cookie *dcrc = dc->dc_ramdac_cookie;
+        int count, error;
+
+        cursorp->which = WSDISPLAY_CURSOR_DOALL &
+            ~(WSDISPLAY_CURSOR_DOHOT | WSDISPLAY_CURSOR_DOCMAP);
+        cursorp->enable = (dc->dc_regs[TGA_REG_VVVR] & 0x04) != 0;
+        cursorp->pos.x = dc->dc_regs[TGA_REG_CXYR] & 0xfff;
+        cursorp->pos.y = (dc->dc_regs[TGA_REG_CXYR] >> 12) & 0xfff;
+        cursorp->size.x = 64;
+        cursorp->size.y = (dc->dc_regs[TGA_REG_CCBR] >> 10) & 0x3f;
+
+        if (cursorp->image != NULL) {
+                count = (cursorp->size.y * 64 * 2) / NBBY;
+                error = copyout((char *)(dc->dc_vaddr +
+                      (dc->dc_regs[TGA_REG_CCBR] & 0x3ff)),
+                    cursorp->image, count);
+                if (error)
+                        return (error);
+                /* No mask */
+        }
+        error = dcrf->ramdac_get_curcmap(dcrc, cursorp);
+        return (error);
 }
 
 int
@@ -889,3 +991,193 @@ tga_rop_vtov(dst, dx, dy, w, h, rop, src, sx, sy)
 	regs0[TGA_REG_GMOR] = 0x0000;		/* Simple mode */
 	return 0;
 }
+
+void
+tga_ramdac_wr(v, btreg, val)
+        void *v;
+        u_int btreg;
+        u_int8_t val;
+{
+        struct tga_devconfig *dc = v;
+        volatile tga_reg_t *tgaregs = dc->dc_regs;
+
+        if (btreg > BT485_REG_MAX)
+                panic("tga_ramdac_wr: reg %d out of range\n", btreg);
+
+        tgaregs[TGA_REG_EPDR] = (btreg << 9) | (0 << 8 ) | val; /* XXX */
+#ifdef __alpha__
+        alpha_mb();
+#endif
+}
+
+void
+tga2_ramdac_wr(v, btreg, val)
+        void *v;
+        u_int btreg;
+        u_int8_t val;
+{
+        struct tga_devconfig *dc = v;
+        volatile tga_reg_t *ramdac;
+
+        if (btreg > BT485_REG_MAX)
+                panic("tga_ramdac_wr: reg %d out of range\n", btreg);
+
+        ramdac = (tga_reg_t *)(dc->dc_vaddr + TGA2_MEM_RAMDAC +
+            (0xe << 12) + (btreg << 8));
+        *ramdac = val & 0xff;
+#ifdef __alpha__
+        alpha_mb();
+#endif
+}
+
+u_int8_t
+tga_ramdac_rd(v, btreg)
+        void *v;
+        u_int btreg;
+{
+        struct tga_devconfig *dc = v;
+        volatile tga_reg_t *tgaregs = dc->dc_regs;
+        tga_reg_t rdval;
+
+        if (btreg > BT485_REG_MAX)
+                panic("tga_ramdac_rd: reg %d out of range\n", btreg);
+
+        tgaregs[TGA_REG_EPSR] = (btreg << 1) | 0x1;                /* XXX */
+#ifdef __alpha__
+        alpha_mb();
+#endif
+
+        rdval = tgaregs[TGA_REG_EPDR];
+        return (rdval >> 16) & 0xff;                                /* XXX */
+}
+
+u_int8_t
+tga2_ramdac_rd(v, btreg)
+        void *v;
+        u_int btreg;
+{
+        struct tga_devconfig *dc = v;
+        volatile tga_reg_t *ramdac;
+        u_int8_t retval;
+
+        if (btreg > BT485_REG_MAX)
+                panic("tga_ramdac_rd: reg %d out of range\n", btreg);
+
+        ramdac = (tga_reg_t *)(dc->dc_vaddr + TGA2_MEM_RAMDAC +
+            (0xe << 12) + (btreg << 8));
+        retval = (u_int8_t)(*ramdac & 0xff);
+#ifdef __alpha__
+        alpha_mb();
+#endif
+        return retval;
+}
+
+#include <dev/ic/decmonitors.c>
+void tga2_ics9110_wr __P((
+        struct tga_devconfig *dc,
+        int dotclock
+));
+
+void
+tga2_init(dc, m)
+        struct tga_devconfig *dc;
+        int m;
+{
+
+        tga2_ics9110_wr(dc, decmonitors[m].dotclock);
+        dc->dc_regs[TGA_REG_VHCR] =
+             ((decmonitors[m].hbp / 4) << 21) |
+             ((decmonitors[m].hsync / 4) << 14) |
+#if 0
+            (((decmonitors[m].hfp - 4) / 4) << 9) |
+             ((decmonitors[m].cols + 4) / 4);
+#else
+            (((decmonitors[m].hfp) / 4) << 9) |
+             ((decmonitors[m].cols) / 4);
+#endif
+        dc->dc_regs[TGA_REG_VVCR] =
+            (decmonitors[m].vbp << 22) |
+            (decmonitors[m].vsync << 16) |
+            (decmonitors[m].vfp << 11) |
+            (decmonitors[m].rows);
+        dc->dc_regs[TGA_REG_VVBR] = 1;          alpha_mb();
+        dc->dc_regs[TGA_REG_VVVR] |= 1;                alpha_mb();
+        dc->dc_regs[TGA_REG_GPMR] = 0xffffffff;        alpha_mb();
+}
+
+void
+tga2_ics9110_wr(dc, dotclock)
+        struct tga_devconfig *dc;
+        int dotclock;
+{
+        volatile tga_reg_t *clock;
+        u_int32_t valU;
+        int N, M, R, V, X;
+        int i;
+
+        switch (dotclock) {
+        case 130808000:
+                N = 0x40; M = 0x7; V = 0x0; X = 0x1; R = 0x1; break;
+        case 119840000:
+                N = 0x2d; M = 0x2b; V = 0x1; X = 0x1; R = 0x1; break;
+        case 108180000:
+                N = 0x11; M = 0x9; V = 0x1; X = 0x1; R = 0x2; break;
+        case 103994000:
+                N = 0x6d; M = 0xf; V = 0x0; X = 0x1; R = 0x1; break;
+        case 175000000:
+                N = 0x5F; M = 0x3E; V = 0x1; X = 0x1; R = 0x1; break;
+        case  75000000:
+                N = 0x6e; M = 0x15; V = 0x0; X = 0x1; R = 0x1; break;
+        case  74000000:
+                N = 0x2a; M = 0x41; V = 0x1; X = 0x1; R = 0x1; break;
+        case  69000000:
+                N = 0x35; M = 0xb; V = 0x0; X = 0x1; R = 0x1; break;
+        case  65000000:
+                N = 0x6d; M = 0x0c; V = 0x0; X = 0x1; R = 0x2; break;
+        case  50000000:
+                N = 0x37; M = 0x3f; V = 0x1; X = 0x1; R = 0x2; break;
+        case  40000000:
+                N = 0x5f; M = 0x11; V = 0x0; X = 0x1; R = 0x2; break;
+        case  31500000:
+                N = 0x16; M = 0x05; V = 0x0; X = 0x1; R = 0x2; break;
+        case  25175000:
+                N = 0x66; M = 0x1d; V = 0x0; X = 0x1; R = 0x2; break;
+        case 135000000:
+                N = 0x42; M = 0x07; V = 0x0; X = 0x1; R = 0x1; break;
+        case 110000000:
+                N = 0x60; M = 0x32; V = 0x1; X = 0x1; R = 0x2; break;
+        case 202500000:
+                N = 0x60; M = 0x32; V = 0x1; X = 0x1; R = 0x2; break;
+        default:
+                panic("unrecognized clock rate %d\n", dotclock);
+        }
+
+        /* XXX -- hard coded, bad */
+        valU  = N | ( M << 7 ) | (V << 14);
+        valU |= (X << 15) | (R << 17);
+        valU |= 0x17 << 19;
+
+
+        clock = (tga_reg_t *)(dc->dc_vaddr + TGA2_MEM_EXTDEV +
+            TGA2_MEM_CLOCK + (0xe << 12)); /* XXX */
+
+        for (i=24; i>0; i--) {
+                u_int32_t       writeval;
+                
+                writeval = valU & 0x1;
+                if (i == 1)  
+                        writeval |= 0x2; 
+                valU >>= 1;
+                *clock = writeval;
+#ifdef __alpha__
+                alpha_mb();
+#endif
+        }       
+        clock = (tga_reg_t *)(dc->dc_vaddr + TGA2_MEM_EXTDEV +
+            TGA2_MEM_CLOCK + (0xe << 12) + (0x1 << 11)); /* XXX */
+        clock += 0x1 << 9;
+        *clock = 0x0;
+#ifdef __alpha__
+                alpha_mb();
+#endif
+}
diff --git a/sys/dev/pci/tga_bt463.c b/sys/dev/pci/tga_bt463.c
deleted file mode 100644
index 1ffcf23b924..00000000000
--- a/sys/dev/pci/tga_bt463.c
+++ /dev/null
@@ -1,605 +0,0 @@
-/* $NetBSD: tga_bt463.c,v 1.4 1999/04/30 02:47:42 nathanw Exp $ */
-
-/*-
- * Copyright (c) 1998 The NetBSD Foundation, Inc.
- * All rights reserved.
- *
- * This code is derived from software contributed to The NetBSD Foundation
- * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
- * NASA Ames Research Center.
- *
- * 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
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the NetBSD
- *	Foundation, Inc. and its contributors.
- * 4. Neither the name of The NetBSD Foundation nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * 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.
- */
-
-/*
- * Copyright (c) 1995, 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Chris G. Demetriou
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/device.h>
-#include <sys/buf.h>
-#include <sys/kernel.h>
-#include <sys/malloc.h>
-#include <vm/vm.h>
-
-#include <dev/pci/pcivar.h>
-#include <dev/pci/tgareg.h>
-#include <dev/pci/tgavar.h>
-#include <dev/ic/bt463reg.h>
-
-#include <dev/wscons/wsconsio.h>
-
-/*
- * Functions exported via the RAMDAC configuration table.
- */
-void	tga_bt463_init __P((struct tga_devconfig *, int));
-int	tga_bt463_intr __P((void *));
-int	tga_bt463_set_cmap __P((struct tga_devconfig *,
-	    struct wsdisplay_cmap *));
-int	tga_bt463_get_cmap __P((struct tga_devconfig *,
-	    struct wsdisplay_cmap *));
-
-int	tga_bt463_check_curcmap __P((struct tga_devconfig *,
-	    struct wsdisplay_cursor *cursorp));
-void	tga_bt463_set_curcmap __P((struct tga_devconfig *,
-	    struct wsdisplay_cursor *cursorp));
-int	tga_bt463_get_curcmap __P((struct tga_devconfig *,
-	    struct wsdisplay_cursor *cursorp));
-
-const struct tga_ramdac_conf tga_ramdac_bt463 = {
-	"Bt463",
-	tga_bt463_init,
-	tga_bt463_intr,
-	tga_bt463_set_cmap,
-	tga_bt463_get_cmap,
-	tga_builtin_set_cursor,
-	tga_builtin_get_cursor,
-	tga_builtin_set_curpos,
-	tga_builtin_get_curpos,
-	tga_builtin_get_curmax,
-	tga_bt463_check_curcmap,
-	tga_bt463_set_curcmap,
-	tga_bt463_get_curcmap,
-};
-
-/*
- * Private data.
- */
-struct bt463data {
-	int	changed;			/* what changed; see below */
-	char curcmap_r[2];			/* cursor colormap */
-	char curcmap_g[2];
-	char curcmap_b[2];
-	char cmap_r[BT463_NCMAP_ENTRIES];	/* colormap */
-	char cmap_g[BT463_NCMAP_ENTRIES];
-	char cmap_b[BT463_NCMAP_ENTRIES];
-	int window_type[16]; /* 16 24-bit window type table entries */
-};
-
-#define	DATA_CURCMAP_CHANGED	0x01	/* cursor colormap changed */
-#define	DATA_CMAP_CHANGED	0x02	/* colormap changed */
-#define	DATA_WTYPE_CHANGED	0x04	/* window type table changed */
-#define	DATA_ALL_CHANGED	0x07
-
-/*
- * Internal functions.
- */
-inline void tga_bt463_wr_d __P((bus_space_tag_t, bus_space_handle_t,
-		u_int, u_int8_t));
-inline u_int8_t tga_bt463_rd_d __P((bus_space_tag_t, bus_space_handle_t,
-		u_int));
-inline void tga_bt463_wraddr __P((bus_space_tag_t, bus_space_handle_t,
-		u_int16_t));
-
-void	tga_bt463_update __P((bus_space_tag_t, bus_space_handle_t, 
-		struct bt463data *));
-
-#define	tga_bt463_sched_update(tag,regs)					\
-	bus_space_write_4((tag), (regs), (TGA_REG_SISR*4), (0x00010000))
-
-/*****************************************************************************/
-
-/*
- * Functions exported via the RAMDAC configuration table.
- */
-
-void
-tga_bt463_init(dc, alloc)
-	struct tga_devconfig *dc;
-	int alloc;
-{
-	struct bt463data tmp, *data;
-	bus_space_tag_t tag;
-	bus_space_handle_t regs;
-	int i;
-
-	/*
-	 * Init the BT463 for normal operation.
-	 */
-
-	tag = dc->dc_memt;
-	bus_space_subregion(tag, dc->dc_vaddr, TGA_MEM_CREGS, 512, 
-						&regs);
-	/*
-	 * Setup:
-	 * reg 0: 4:1 multiplexing, 25/75 blink.
-	 * reg 1: Overlay mapping: mapped to common palette, 
-	 *        14 window type entries, 24-plane configuration mode,
-	 *        4 overlay planes, underlays disabled, no cursor. 
-	 * reg 2: sync-on-green disabled, pedestal enabled.
-	 */
-	tga_bt463_wraddr(tag, regs, BT463_IREG_COMMAND_0);
-	tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA, 0x40);
-
-	tga_bt463_wraddr(tag, regs, BT463_IREG_COMMAND_1);
-	tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA, 0x48);
-
-	tga_bt463_wraddr(tag, regs, BT463_IREG_COMMAND_2);
-	tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA, 0x40);
-
-	/*
-	 * Initialize the read mask.
-	 */
-	tga_bt463_wraddr(tag, regs, BT463_IREG_READ_MASK_P0_P7);
-	for (i = 0; i < 3; i++)
-		tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA, 0xff);
-
-	/*
-	 * Initialize the blink mask.
-	 */
-	tga_bt463_wraddr(tag, regs, BT463_IREG_BLINK_MASK_P0_P7);
-	for (i = 0; i < 3; i++)
-		tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA, 0);
-
-	/*
-	 * Clear test register
-	 */
-	tga_bt463_wraddr(tag, regs, BT463_IREG_TEST);
-	tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA, 0);
-
-	/*
-	 * If we should allocate a new private info struct, do so.
-	 * Otherwise, use the one we have (if it's there), or
-	 * use the temporary one on the stack.
-	 */
-	if (alloc) {
-		if (dc->dc_ramdac_private != NULL)
-			panic("tga_bt463_init: already have private struct");
-		dc->dc_ramdac_private = malloc(sizeof *data, M_DEVBUF,
-		    M_WAITOK);
-	}
-	if (dc->dc_ramdac_private != NULL)
-		data = dc->dc_ramdac_private;
-	else
-		data = &tmp;
-
-	/*
-	 * Initalize the RAMDAC info struct to hold all of our
-	 * data, and fill it in.
-	 */
-	data->changed = DATA_ALL_CHANGED;
-
-	/* initial cursor colormap: 0 is black, 1 is white */
-	data->curcmap_r[0] = data->curcmap_g[0] = data->curcmap_b[0] = 0;
-	data->curcmap_r[1] = data->curcmap_g[1] = data->curcmap_b[1] = 0xff;
-
-	/* Initial colormap: 0 is black, everything else is white */
-	data->cmap_r[0] = data->cmap_g[0] = data->cmap_b[0] = 0;
-	for (i = 1; i < 256; i++)
-		data->cmap_r[i] = data->cmap_g[i] = data->cmap_b[i] = 255;
-
-
-	/* Initialize the window type table:
-	 * Entry 0: 8-plane pseudocolor in the bottom 8 bits, 
-	 *          overlays disabled, colormap starting at 0. 
-	 *
-	 *  Lookup table bypass:       no (    0 << 23 & 0x800000)       0
-	 *  Colormap address:       0x000 (0x000 << 17 & 0x7e0000)       0 
-	 *  Overlay mask:             0x0 (    0 << 13 & 0x01e000)       0
-	 *  Overlay location:    P<27:24> (    0 << 12 & 0x001000)       0
-	 *  Display mode:     Pseudocolor (    1 <<  9 & 0x000e00)   0x200
-	 *  Number of planes:           8 (    8 <<  5 & 0x0001e0)   0x100
-	 *  Plane shift:               16 (   16 <<  0 & 0x00001f)      10
-	 *                                                        --------
-	 *                                                           0x310
-	 */	  
-	data->window_type[0] = 0x310;
-	/* The colormap interface to the world only supports one colormap, 
-	 * so having an entry for the 'alternate' colormap in the bt463 
-	 * probably isn't useful.
-	 */
-	/* Entry 1: 24-plane truecolor, overlays disabled. */
-	data->window_type[1] = 0x200;
-
-	/* Fill the remaining table entries with clones of entry 0 until we 
-	 * figure out a better use for them.
-	 */
-
-	for (i = 2; i < BT463_NWTYPE_ENTRIES; i++) {
-		data->window_type[i] = 0x310;
-	}
-
-	/* The Bt463 won't accept window type table data
-	 * except during a blanking interval. Normally we would 
-	 * do this by scheduling an interrupt, but this is run 
-	 * during autoconfiguration, when interrupts are disabled. 
-	 * So we spin on the end-of-frame interrupt bit. 
-	 */
-
-	bus_space_write_4(tag, regs, TGA_REG_SISR*4, 0x00010001);
-	bus_space_barrier(tag, regs, TGA_REG_SISR*4, 4, BUS_BARRIER_WRITE);
-	while ((bus_space_read_4(tag, regs, (TGA_REG_SISR * 4))& 0x00000001) == 0);
-
-	tga_bt463_update(tag, regs, data);
-
-	bus_space_write_4(tag, regs, TGA_REG_SISR*4, 0x00000001);
-	bus_space_barrier(tag, regs, TGA_REG_SISR*4, 4, BUS_BARRIER_WRITE);
-
-	tga_bt463_sched_update(tag, regs);
-
-}
-
-int
-tga_bt463_set_cmap(dc, cmapp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_cmap *cmapp;
-{
-	struct bt463data *data = dc->dc_ramdac_private;
-	bus_space_tag_t tag = dc->dc_memt;
-	bus_space_handle_t regs;
-	int count, index, s;
-
-	bus_space_subregion(tag, dc->dc_vaddr, TGA_MEM_CREGS, 512, 
-						&regs);
-	
-
-	if ((u_int)cmapp->index >= BT463_NCMAP_ENTRIES ||
-	    ((u_int)cmapp->index + (u_int)cmapp->count) > BT463_NCMAP_ENTRIES)
-		return (EINVAL);
-#ifdef UVM
-	if (!uvm_useracc(cmapp->red, cmapp->count, B_READ) ||
-	    !uvm_useracc(cmapp->green, cmapp->count, B_READ) ||
-	    !uvm_useracc(cmapp->blue, cmapp->count, B_READ))
-		return (EFAULT);
-#else
-	if (!useracc(cmapp->red, cmapp->count, B_READ) ||
-	    !useracc(cmapp->green, cmapp->count, B_READ) ||
-	    !useracc(cmapp->blue, cmapp->count, B_READ))
-		return (EFAULT);
-#endif
-
-	s = spltty();
-
-	index = cmapp->index;
-	count = cmapp->count;
-	copyin(cmapp->red, &data->cmap_r[index], count);
-	copyin(cmapp->green, &data->cmap_g[index], count);
-	copyin(cmapp->blue, &data->cmap_b[index], count);
-
-	data->changed |= DATA_CMAP_CHANGED;
-
-	tga_bt463_sched_update(tag, regs);
-	splx(s);
-
-	return (0);
-}
-
-int
-tga_bt463_get_cmap(dc, cmapp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_cmap *cmapp;
-{
-	struct bt463data *data = dc->dc_ramdac_private;
-	int error, count, index;
-
-	if ((u_int)cmapp->index >= BT463_NCMAP_ENTRIES ||
-	    ((u_int)cmapp->index + (u_int)cmapp->count) > BT463_NCMAP_ENTRIES)
-		return (EINVAL);
-
-	count = cmapp->count;
-	index = cmapp->index;
-
-	error = copyout(&data->cmap_r[index], cmapp->red, count);
-	if (error)
-		return (error);
-	error = copyout(&data->cmap_g[index], cmapp->green, count);
-	if (error)
-		return (error);
-	error = copyout(&data->cmap_b[index], cmapp->blue, count);
-	return (error);
-}
-
-int
-tga_bt463_check_curcmap(dc, cursorp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_cursor *cursorp;
-{
-	int count;
-
-	if ((u_int)cursorp->cmap.index > 2 ||
-	    ((u_int)cursorp->cmap.index +
-	     (u_int)cursorp->cmap.count) > 2)
-		return (EINVAL);
-	count = cursorp->cmap.count; 
-#ifdef UVM
-	if (!uvm_useracc(cursorp->cmap.red, count, B_READ) ||
-	    !uvm_useracc(cursorp->cmap.green, count, B_READ) ||
-	    !uvm_useracc(cursorp->cmap.blue, count, B_READ))
-		return (EFAULT);
-#else
-	if (!useracc(cursorp->cmap.red, count, B_READ) ||
-	    !useracc(cursorp->cmap.green, count, B_READ) ||
-	    !useracc(cursorp->cmap.blue, count, B_READ))
-		return (EFAULT);
-#endif
-	return (0);
-}
-
-void
-tga_bt463_set_curcmap(dc, cursorp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_cursor *cursorp;
-{
-	struct bt463data *data = dc->dc_ramdac_private;
-	int count, index;
-	bus_space_tag_t tag = dc->dc_memt;
-	bus_space_handle_t regs;
-
-	bus_space_subregion(tag, dc->dc_vaddr, TGA_MEM_CREGS, 512, 
-						&regs);
-
-	/* can't fail; parameters have already been checked. */
-	count = cursorp->cmap.count;
-	index = cursorp->cmap.index;
-	copyin(cursorp->cmap.red, &data->curcmap_r[index], count);
-	copyin(cursorp->cmap.green, &data->curcmap_g[index], count);
-	copyin(cursorp->cmap.blue, &data->curcmap_b[index], count);
-	data->changed |= DATA_CURCMAP_CHANGED;
-	tga_bt463_sched_update(tag, regs);
-}
-
-int
-tga_bt463_get_curcmap(dc, cursorp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_cursor *cursorp;
-{
-	struct bt463data *data = dc->dc_ramdac_private;
-	int error;
-
-	cursorp->cmap.index = 0;	/* DOCMAP */
-	cursorp->cmap.count = 2;
-	if (cursorp->cmap.red != NULL) {
-		error = copyout(data->curcmap_r, cursorp->cmap.red, 2);
-		if (error)
-			return (error);
-	}
-	if (cursorp->cmap.green != NULL) {
-		error = copyout(data->curcmap_g, cursorp->cmap.green, 2);
-		if (error)
-			return (error);
-	}
-	if (cursorp->cmap.blue != NULL) {
-		error = copyout(data->curcmap_b, cursorp->cmap.blue, 2);
-		if (error)
-			return (error);
-	}
-	return (0);
-}
-
-int
-tga_bt463_intr(v)
-	void *v;
-{
-	struct tga_devconfig *dc = v;
-	bus_space_tag_t tag = dc->dc_memt;
-	bus_space_handle_t regs;
-
-	bus_space_subregion(tag, dc->dc_vaddr, TGA_MEM_CREGS, 512, 
-						&regs);
-
-	if ( (bus_space_read_4(tag, regs, TGA_REG_SISR*4) & 0x00010001) != 
-		 0x00010001) {
-		printf("Spurious interrupt");
-		return 0;
-	}
-
-	tga_bt463_update(tag, regs, dc->dc_ramdac_private);
-
-	bus_space_write_4(tag, regs, TGA_REG_SISR*4, 0x00000001);
-	bus_space_barrier(tag, regs, TGA_REG_SISR*4, 4, BUS_BARRIER_WRITE);
-	return (1);
-}
-
-/*****************************************************************************/
-
-/*
- * Internal functions.
- */
-
-inline void
-tga_bt463_wr_d(tag, regs, btreg, val)
-	 bus_space_tag_t tag;
-	 bus_space_handle_t regs;
-	u_int btreg;
-	u_int8_t val;
-{
-
-	if (btreg > BT463_REG_MAX)
-		panic("tga_bt463_wr_d: reg %d out of range\n", btreg);
-
-	/* 
-	 * In spite of the 21030 documentation, to set the MPU bus bits for
-	 * a write, you set them in the upper bits of EPDR, not EPSR.
-	 */
-	
-	/* 
-	 * Strobe CE# (high->low->high) since status and data are latched on
-	 * the falling and rising edges of this active-low signal.
-	 */
-	   
-	bus_space_barrier(tag, regs, TGA_REG_EPDR*4, 4, BUS_BARRIER_WRITE);
-	bus_space_write_4(tag, regs, TGA_REG_EPDR*4, (btreg << 10 ) | 0x100 | val);
-	bus_space_barrier(tag, regs, TGA_REG_EPDR*4, 4, BUS_BARRIER_WRITE);
-	bus_space_write_4(tag, regs, TGA_REG_EPDR*4, (btreg << 10 ) | 0x000 | val);
-	bus_space_barrier(tag, regs, TGA_REG_EPDR*4, 4, BUS_BARRIER_WRITE);
-	bus_space_write_4(tag, regs, TGA_REG_EPDR*4, (btreg << 10 ) | 0x100 | val);
-}
-
-inline u_int8_t
-tga_bt463_rd_d(tag, regs, btreg)
-	 bus_space_tag_t tag;
-	 bus_space_handle_t regs;
-	u_int btreg;
-{
-	tga_reg_t rdval;
-
-	if (btreg > BT463_REG_MAX)
-		panic("tga_bt463_rd_d: reg %d out of range\n", btreg);
-
-	/* 
-	 * Strobe CE# (high->low->high) since status and data are latched on 
-	 * the falling and rising edges of this active-low signal.
-	 */
-
-	bus_space_barrier(tag, regs, TGA_REG_EPSR*4, 4, BUS_BARRIER_WRITE);
-	bus_space_write_4(tag, regs, TGA_REG_EPSR*4, (btreg << 2) | 2 | 1);
-	bus_space_barrier(tag, regs, TGA_REG_EPSR*4, 4, BUS_BARRIER_WRITE);
-	bus_space_write_4(tag, regs, TGA_REG_EPSR*4, (btreg << 2) | 2 | 0);
-
-	bus_space_barrier(tag, regs, TGA_REG_EPSR*4, 4, BUS_BARRIER_READ);
-
-	rdval = bus_space_read_4(tag, regs, TGA_REG_EPDR*4);
-	bus_space_barrier(tag, regs, TGA_REG_EPSR*4, 4, BUS_BARRIER_WRITE);
-	bus_space_write_4(tag, regs, TGA_REG_EPSR*4, (btreg << 2) | 2 | 1);
-
-	return (rdval >> 16) & 0xff;
-}
-
-inline void
-tga_bt463_wraddr(tag, regs, ireg)
-	 bus_space_tag_t tag;
-	 bus_space_handle_t regs;
-	u_int16_t ireg;
-{
-	tga_bt463_wr_d(tag, regs, BT463_REG_ADDR_LOW, ireg & 0xff);
-	tga_bt463_wr_d(tag, regs, BT463_REG_ADDR_HIGH, (ireg >> 8) & 0xff);
-}
-
-void
-tga_bt463_update(tag, regs, data)
-	 bus_space_tag_t tag;
-	 bus_space_handle_t regs;
-	struct bt463data *data;
-{
-	int i, v, valid, blanked;
-
-	v = data->changed;
-
-	/* The Bt463 won't accept window type data except during a blanking
-	 * interval. So we (1) do this early in the interrupt, in case it 
-	 * takes a long time, and (2) blank the screen while doing so, in case
-	 * we run out normal vertical blanking. 
-	 */
-	if (v & DATA_WTYPE_CHANGED) {
-		valid = bus_space_read_4(tag, regs, TGA_REG_VVVR*4);
-		blanked = valid | VVR_BLANK;
-		bus_space_write_4(tag, regs, TGA_REG_VVVR*4, blanked);
-		bus_space_barrier(tag, regs, TGA_REG_VVVR*4, 4, 
-			BUS_BARRIER_WRITE);
-		/* spit out the window type data */
-		for (i = 0; i < BT463_NWTYPE_ENTRIES; i++) {
-			tga_bt463_wraddr(tag, regs, BT463_IREG_WINDOW_TYPE_TABLE + i);
-			tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA, 
-				(data->window_type[i]) & 0xff);         /* B0-7   */
-			tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA, 
-				(data->window_type[i] >> 8) & 0xff);    /* B8-15  */
-			tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA, 
-				(data->window_type[i] >> 16) & 0xff);   /* B16-23 */
-
-		}
-		bus_space_write_4(tag, regs, TGA_REG_VVVR*4, valid);
-		bus_space_barrier(tag, regs, TGA_REG_VVVR*4, 4, 
-			BUS_BARRIER_WRITE);
-	}
-
-	if (v & DATA_CURCMAP_CHANGED) {
-		tga_bt463_wraddr(tag, regs, BT463_IREG_CURSOR_COLOR_0);
-		/* spit out the cursor data */
-		for (i = 0; i < 2; i++) {
-			tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA,
-			    data->curcmap_r[i]);
-			tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA,
-			    data->curcmap_g[i]);
-			tga_bt463_wr_d(tag, regs, BT463_REG_IREG_DATA,
-			    data->curcmap_b[i]);
-		}
-	}
-
-	if (v & DATA_CMAP_CHANGED) {
-
-		tga_bt463_wraddr(tag, regs, BT463_IREG_CPALETTE_RAM);
-		/* spit out the colormap data */
-		for (i = 0; i < BT463_NCMAP_ENTRIES; i++) {
-			tga_bt463_wr_d(tag, regs, BT463_REG_CMAP_DATA,
-			    data->cmap_r[i]);
-			tga_bt463_wr_d(tag, regs, BT463_REG_CMAP_DATA,
-			    data->cmap_g[i]);
-			tga_bt463_wr_d(tag, regs, BT463_REG_CMAP_DATA,
-			    data->cmap_b[i]);
-		}
-	}
-
-	data->changed = 0;
-
-
-}
diff --git a/sys/dev/pci/tga_bt485.c b/sys/dev/pci/tga_bt485.c
deleted file mode 100644
index 91b7b4049df..00000000000
--- a/sys/dev/pci/tga_bt485.c
+++ /dev/null
@@ -1,624 +0,0 @@
-/* $NetBSD: tga_bt485.c,v 1.3 1998/08/18 08:22:49 thorpej Exp $ */
-
-/*
- * Copyright (c) 1995, 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Chris G. Demetriou
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/device.h>
-#include <sys/buf.h>
-#include <sys/kernel.h>
-#include <sys/malloc.h>
-#include <vm/vm.h>
-
-#include <dev/pci/pcivar.h>
-#include <dev/pci/tgareg.h>
-#include <dev/pci/tgavar.h>
-#include <dev/ic/bt485reg.h>
-
-#include <dev/wscons/wsconsio.h>
-
-/*
- * Functions exported via the RAMDAC configuration table.
- */
-void	tga_bt485_init __P((struct tga_devconfig *, int));
-int	tga_bt485_intr __P((void *));
-int	tga_bt485_set_cmap __P((struct tga_devconfig *,
-	    struct wsdisplay_cmap *));
-int	tga_bt485_get_cmap __P((struct tga_devconfig *,
-	    struct wsdisplay_cmap *));
-int	tga_bt485_set_cursor __P((struct tga_devconfig *,
-	    struct wsdisplay_cursor *));
-int	tga_bt485_get_cursor __P((struct tga_devconfig *,
-	    struct wsdisplay_cursor *));
-int	tga_bt485_set_curpos __P((struct tga_devconfig *,
-	    struct wsdisplay_curpos *));
-int	tga_bt485_get_curpos __P((struct tga_devconfig *,
-	    struct wsdisplay_curpos *));
-int	tga_bt485_get_curmax __P((struct tga_devconfig *,
-	    struct wsdisplay_curpos *));
-
-const struct tga_ramdac_conf tga_ramdac_bt485 = {
-	"Bt485",
-	tga_bt485_init,
-	tga_bt485_intr,
-	tga_bt485_set_cmap,
-	tga_bt485_get_cmap,
-	tga_bt485_set_cursor,
-	tga_bt485_get_cursor,
-	tga_bt485_set_curpos,
-	tga_bt485_get_curpos,
-	tga_bt485_get_curmax,
-	NULL,			/* check_curcmap; not needed */
-	NULL,			/* set_curcmap; not needed */
-	NULL,			/* get_curcmap; not needed */
-};
-
-/*
- * Private data.
- */
-struct bt485data {
-	int	changed;			/* what changed; see below */
-	int	curenb;				/* cursor enabled */
-	struct wsdisplay_curpos curpos;		/* current cursor position */
-	struct wsdisplay_curpos curhot;		/* cursor hotspot */
-	char curcmap_r[2];			/* cursor colormap */
-	char curcmap_g[2];
-	char curcmap_b[2];
-	struct wsdisplay_curpos cursize;	/* current cursor size */
-	char curimage[512];			/* cursor image data */
-	char curmask[512];			/* cursor mask data */
-	char cmap_r[256];				/* colormap */
-	char cmap_g[256];
-	char cmap_b[256];
-};
-
-#define	DATA_ENB_CHANGED	0x01	/* cursor enable changed */
-#define	DATA_CURCMAP_CHANGED	0x02	/* cursor colormap changed */
-#define	DATA_CURSHAPE_CHANGED	0x04	/* cursor size, image, mask changed */
-#define	DATA_CMAP_CHANGED	0x08	/* colormap changed */
-#define	DATA_ALL_CHANGED	0x0f
-
-#define	CURSOR_MAX_SIZE		64
-
-/*
- * Internal functions.
- */
-inline void	tga_bt485_wr_d __P((volatile tga_reg_t *, u_int, u_int8_t));
-inline u_int8_t tga_bt485_rd_d __P((volatile tga_reg_t *, u_int));
-inline void	tga_bt485_wr_i  __P((volatile tga_reg_t *, u_int8_t, u_int8_t));
-inline u_int8_t tga_bt485_rd_i __P((volatile tga_reg_t *, u_int8_t));
-void	tga_bt485_update __P((struct tga_devconfig *, struct bt485data *));
-void	tga_bt485_update_curpos __P((struct tga_devconfig *, struct bt485data *));
-
-#define	tga_bt485_sched_update(dc)					\
-    ((dc)->dc_regs[TGA_REG_SISR] = 0x00010000)			/* XXX */
-
-/*****************************************************************************/
-
-/*
- * Functions exported via the RAMDAC configuration table.
- */
-
-void
-tga_bt485_init(dc, alloc)
-	struct tga_devconfig *dc;
-	int alloc;
-{
-	u_int8_t regval;
-	struct bt485data tmp, *data;
-	int i;
-
-	/*
-	 * Init the BT485 for normal operation.
-	 */
-
-	/*
-	 * Allow indirect register access.  (Actually, this is
-	 * already enabled.  In fact, if it is _disabled_, for
-	 * some reason the monitor appears to lose sync!!! (?!?!)
-	 */
-	regval = tga_bt485_rd_d(dc->dc_regs, BT485_REG_COMMAND_0);
-	regval |= 0x80;
-	tga_bt485_wr_d(dc->dc_regs, BT485_REG_COMMAND_0, regval);
-
-	/* Set the RAMDAC to 8BPP (no interestion options). */
-	tga_bt485_wr_d(dc->dc_regs, BT485_REG_COMMAND_1, 0x40);
-
-	/* Disable the cursor (for now) */
-	regval = tga_bt485_rd_d(dc->dc_regs, BT485_REG_COMMAND_2);
-	regval &= ~0x03;
-	tga_bt485_wr_d(dc->dc_regs, BT485_REG_COMMAND_2, regval);
-
-	/* Use a 64x64x2 cursor */
-	regval = tga_bt485_rd_d(dc->dc_regs, BT485_IREG_COMMAND_3);
-	regval |= 0x04;
-	tga_bt485_wr_d(dc->dc_regs, BT485_IREG_COMMAND_3, regval);
-
-	/*
-	 * If we should allocate a new private info struct, do so.
-	 * Otherwise, use the one we have (if it's there), or
-	 * use the temporary one on the stack.
-	 */
-	if (alloc) {
-		if (dc->dc_ramdac_private != NULL)
-			panic("tga_bt485_init: already have private struct");
-		dc->dc_ramdac_private = malloc(sizeof *data, M_DEVBUF,
-		    M_WAITOK);
-	}
-	if (dc->dc_ramdac_private != NULL)
-		data = dc->dc_ramdac_private;
-	else
-		data = &tmp;
-
-	/*
-	 * Initalize the RAMDAC info struct to hold all of our
-	 * data, and fill it in.
-	 */
-	data->changed = DATA_ALL_CHANGED;
-
-	data->curenb = 0;				/* cursor disabled */
-	data->curpos.x = data->curpos.y = 0;		/* right now at 0,0 */
-	data->curhot.x = data->curhot.y = 0;		/* hot spot at 0,0 */
-
-	/* initial cursor colormap: 0 is black, 1 is white */
-	data->curcmap_r[0] = data->curcmap_g[0] = data->curcmap_b[0] = 0;
-	data->curcmap_r[1] = data->curcmap_g[1] = data->curcmap_b[1] = 0xff;
-
-	/* initial cursor data: 64x64 block of white. */
-	data->cursize.x = data->cursize.y = 64;
-	for (i = 0; i < 512; i++)
-		data->curimage[i] = data->curmask[i] = 0xff;
-
-	/* Initial colormap: 0 is black, everything else is white */
-	data->cmap_r[0] = data->cmap_g[0] = data->cmap_b[0] = 0;
-	for (i = 1; i < 256; i++)
-		data->cmap_r[i] = data->cmap_g[i] = data->cmap_b[i] = 255;
-
-	tga_bt485_update(dc, data);
-
-	dc->dc_regs[TGA_REG_SISR] = 0x00000001;			/* XXX */
-}
-
-int
-tga_bt485_set_cmap(dc, cmapp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_cmap *cmapp;
-{
-	struct bt485data *data = dc->dc_ramdac_private;
-	int count, index, s;
-
-	if ((u_int)cmapp->index >= 256 ||
-	    ((u_int)cmapp->index + (u_int)cmapp->count) > 256)
-		return (EINVAL);
-#ifdef UVM
-	if (!uvm_useracc(cmapp->red, cmapp->count, B_READ) ||
-	    !uvm_useracc(cmapp->green, cmapp->count, B_READ) ||
-	    !uvm_useracc(cmapp->blue, cmapp->count, B_READ))
-		return (EFAULT);
-#else
-	if (!useracc(cmapp->red, cmapp->count, B_READ) ||
-	    !useracc(cmapp->green, cmapp->count, B_READ) ||
-	    !useracc(cmapp->blue, cmapp->count, B_READ))
-		return (EFAULT);
-#endif
-
-	s = spltty();
-
-	index = cmapp->index;
-	count = cmapp->count;
-	copyin(cmapp->red, &data->cmap_r[index], count);
-	copyin(cmapp->green, &data->cmap_g[index], count);
-	copyin(cmapp->blue, &data->cmap_b[index], count);
-
-	data->changed |= DATA_CMAP_CHANGED;
-
-	tga_bt485_sched_update(dc);
-	splx(s);
-
-	return (0);
-}
-
-int
-tga_bt485_get_cmap(dc, cmapp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_cmap *cmapp;
-{
-	struct bt485data *data = dc->dc_ramdac_private;
-	int error, count, index;
-
-	if ((u_int)cmapp->index >= 256 ||
-	    ((u_int)cmapp->index + (u_int)cmapp->count) > 256)
-		return (EINVAL);
-
-	count = cmapp->count;
-	index = cmapp->index;
-
-	error = copyout(&data->cmap_r[index], cmapp->red, count);
-	if (error)
-		return (error);
-	error = copyout(&data->cmap_g[index], cmapp->green, count);
-	if (error)
-		return (error);
-	error = copyout(&data->cmap_b[index], cmapp->blue, count);
-	return (error);
-}
-
-int
-tga_bt485_set_cursor(dc, cursorp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_cursor *cursorp;
-{
-	struct bt485data *data = dc->dc_ramdac_private;
-	int count, index, v, s;
-
-	v = cursorp->which;
-
-	/*
-	 * For DOCMAP and DOSHAPE, verify that parameters are OK
-	 * before we do anything that we can't recover from.
-	 */
-	if (v & WSDISPLAY_CURSOR_DOCMAP) {
-		if ((u_int)cursorp->cmap.index > 2 ||
-		    ((u_int)cursorp->cmap.index +
-		     (u_int)cursorp->cmap.count) > 2)
-			return (EINVAL);
-		count = cursorp->cmap.count;
-#ifdef UVM
-		if (!uvm_useracc(cursorp->cmap.red, count, B_READ) ||
-		    !uvm_useracc(cursorp->cmap.green, count, B_READ) ||
-		    !uvm_useracc(cursorp->cmap.blue, count, B_READ))
-			return (EFAULT);
-#else
-		if (!useracc(cursorp->cmap.red, count, B_READ) ||
-		    !useracc(cursorp->cmap.green, count, B_READ) ||
-		    !useracc(cursorp->cmap.blue, count, B_READ))
-			return (EFAULT);
-#endif
-	}
-	if (v & WSDISPLAY_CURSOR_DOSHAPE) {
-		if ((u_int)cursorp->size.x > CURSOR_MAX_SIZE ||
-		    (u_int)cursorp->size.y > CURSOR_MAX_SIZE)
-			return (EINVAL);
-		count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
-#ifdef UVM
-		if (!uvm_useracc(cursorp->image, count, B_READ) ||
-		    !uvm_useracc(cursorp->mask, count, B_READ))
-			return (EFAULT);
-#else
-		if (!useracc(cursorp->image, count, B_READ) ||
-		    !useracc(cursorp->mask, count, B_READ))
-			return (EFAULT);
-#endif
-	}
-
-	if (v & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOCUR)) {
-		if (v & WSDISPLAY_CURSOR_DOPOS)
-			data->curpos = cursorp->pos;
-		if (v & WSDISPLAY_CURSOR_DOCUR)
-			data->curhot = cursorp->hot;
-		tga_bt485_update_curpos(dc, data);
-	}
-
-	s = spltty();
-
-	/* Parameters are OK; perform the requested operations. */
-	if (v & WSDISPLAY_CURSOR_DOCUR) {
-		data->curenb = cursorp->enable;
-		data->changed |= DATA_ENB_CHANGED;
-	}
-	if (v & WSDISPLAY_CURSOR_DOCMAP) {
-		count = cursorp->cmap.count;
-		index = cursorp->cmap.index;
-		copyin(cursorp->cmap.red, &data->curcmap_r[index], count);
-		copyin(cursorp->cmap.green, &data->curcmap_g[index], count);
-		copyin(cursorp->cmap.blue, &data->curcmap_b[index], count);
-		data->changed |= DATA_CURCMAP_CHANGED;
-	}
-	if (v & WSDISPLAY_CURSOR_DOSHAPE) {
-		data->cursize = cursorp->size;
-		count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
-		bzero(data->curimage, sizeof data->curimage);
-		bzero(data->curmask, sizeof data->curmask);
-		copyin(cursorp->image, data->curimage, count);	/* can't fail */
-		copyin(cursorp->mask, data->curmask, count);	/* can't fail */
-		data->changed |= DATA_CURSHAPE_CHANGED;
-	}
-
-	if (data->changed)
-		tga_bt485_sched_update(dc);
-	splx(s);
-
-	return (0);
-}
-
-int
-tga_bt485_get_cursor(dc, cursorp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_cursor *cursorp;
-{
-	struct bt485data *data = dc->dc_ramdac_private;
-	int error, count;
-
-	/* we return everything they want */
-	cursorp->which = WSDISPLAY_CURSOR_DOALL;
-
-	cursorp->enable = data->curenb;	/* DOCUR */
-	cursorp->pos = data->curpos;	/* DOPOS */
-	cursorp->hot = data->curhot;	/* DOHOT */
-
-	cursorp->cmap.index = 0;	/* DOCMAP */
-	cursorp->cmap.count = 2;
-	if (cursorp->cmap.red != NULL) {
-		error = copyout(data->curcmap_r, cursorp->cmap.red, 2);
-		if (error)
-			return (error);
-	}
-	if (cursorp->cmap.green != NULL) {
-		error = copyout(data->curcmap_g, cursorp->cmap.green, 2);
-		if (error)
-			return (error);
-	}
-	if (cursorp->cmap.blue != NULL) {
-		error = copyout(data->curcmap_b, cursorp->cmap.blue, 2);
-		if (error)
-			return (error);
-	}
-
-	cursorp->size = data->cursize;	/* DOSHAPE */
-	if (cursorp->image != NULL) {
-		count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
-		error = copyout(data->curimage, cursorp->image, count);
-		if (error)
-			return (error);
-		error = copyout(data->curmask, cursorp->mask, count);
-		if (error)
-			return (error);
-	}
-
-	return (0);
-}
-
-int
-tga_bt485_set_curpos(dc, curposp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_curpos *curposp;
-{
-	struct bt485data *data = dc->dc_ramdac_private;
-
-	data->curpos = *curposp;
-	tga_bt485_update_curpos(dc, data);
-
-	return (0);
-}
-
-int
-tga_bt485_get_curpos(dc, curposp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_curpos *curposp;
-{
-	struct bt485data *data = dc->dc_ramdac_private;
-
-	*curposp = data->curpos;
-	return (0);
-}
-
-int
-tga_bt485_get_curmax(dc, curposp)
-	struct tga_devconfig *dc;
-	struct wsdisplay_curpos *curposp;
-{
-
-	curposp->x = curposp->y = CURSOR_MAX_SIZE;
-	return (0);
-}
-
-int
-tga_bt485_intr(v)
-	void *v;
-{
-	struct tga_devconfig *dc = v;
-
-	if ((dc->dc_regs[TGA_REG_SISR] & 0x00010001) != 0x00010001)
-		return 0;
-	tga_bt485_update(dc, dc->dc_ramdac_private);
-	dc->dc_regs[TGA_REG_SISR] = 0x00000001;
-	return (1);
-}
-
-/*****************************************************************************/
-
-/*
- * Internal functions.
- */
-
-inline void
-tga_bt485_wr_d(tgaregs, btreg, val)
-	volatile tga_reg_t *tgaregs;
-	u_int btreg;
-	u_int8_t val;
-{
-
-	if (btreg > BT485_REG_MAX)
-		panic("tga_bt485_wr_d: reg %d out of range\n", btreg);
-
-	tgaregs[TGA_REG_EPDR] = (btreg << 9) | (0 << 8 ) | val; /* XXX */
-#ifdef __alpha__
-	alpha_mb();
-#endif
-}
-
-inline u_int8_t
-tga_bt485_rd_d(tgaregs, btreg)
-	volatile tga_reg_t *tgaregs;
-	u_int btreg;
-{
-	tga_reg_t rdval;
-
-	if (btreg > BT485_REG_MAX)
-		panic("tga_bt485_rd_d: reg %d out of range\n", btreg);
-
-	tgaregs[TGA_REG_EPSR] = (btreg << 1) | 0x1;		/* XXX */
-#ifdef __alpha__
-	alpha_mb();
-#endif
-
-	rdval = tgaregs[TGA_REG_EPDR];
-	return (rdval >> 16) & 0xff;				/* XXX */
-}
-
-inline void
-tga_bt485_wr_i(tgaregs, ireg, val)
-	volatile tga_reg_t *tgaregs;
-	u_int8_t ireg;
-	u_int8_t val;
-{
-	tga_bt485_wr_d(tgaregs, BT485_REG_PCRAM_WRADDR, ireg);
-	tga_bt485_wr_d(tgaregs, BT485_REG_EXTENDED, val);
-}
-
-inline u_int8_t
-tga_bt485_rd_i(tgaregs, ireg)
-	volatile tga_reg_t *tgaregs;
-	u_int8_t ireg;
-{
-	tga_bt485_wr_d(tgaregs, BT485_REG_PCRAM_WRADDR, ireg);
-	return (tga_bt485_rd_d(tgaregs, BT485_REG_EXTENDED));
-}
-
-void
-tga_bt485_update(dc, data)
-	struct tga_devconfig *dc;
-	struct bt485data *data;
-{
-	u_int8_t regval;
-	int count, i, v;
-
-	v = data->changed;
-	data->changed = 0;
-
-	if (v & DATA_ENB_CHANGED) {
-		regval = tga_bt485_rd_d(dc->dc_regs, BT485_REG_COMMAND_2);
-		if (data->curenb)
-			regval |= 0x01;
-		else
-			regval &= ~0x03;
-                tga_bt485_wr_d(dc->dc_regs, BT485_REG_COMMAND_2, regval);
-	}
-
-	if (v & DATA_CURCMAP_CHANGED) {
-		/* addr[9:0] assumed to be 0 */
-		/* set addr[7:0] to 1 */
-                tga_bt485_wr_d(dc->dc_regs, BT485_REG_COC_WRADDR, 0x01);
-
-		/* spit out the cursor data */
-		for (i = 0; i < 2; i++) {
-                	tga_bt485_wr_d(dc->dc_regs, BT485_REG_COCDATA,
-			    data->curcmap_r[i]);
-                	tga_bt485_wr_d(dc->dc_regs, BT485_REG_COCDATA,
-			    data->curcmap_g[i]);
-                	tga_bt485_wr_d(dc->dc_regs, BT485_REG_COCDATA,
-			    data->curcmap_b[i]);
-		}
-	}
-
-	if (v & DATA_CURSHAPE_CHANGED) {
-		count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
-
-		/*
-		 * Write the cursor image data:
-		 *	set addr[9:8] to 0,
-		 *	set addr[7:0] to 0,
-		 *	spit it all out.
-		 */
-		regval = tga_bt485_rd_i(dc->dc_regs,
-		    BT485_IREG_COMMAND_3);
-		regval &= ~0x03;
-		tga_bt485_wr_i(dc->dc_regs, BT485_IREG_COMMAND_3,
-		    regval);
-                tga_bt485_wr_d(dc->dc_regs, BT485_REG_PCRAM_WRADDR, 0);
-		for (i = 0; i < count; i++)
-			tga_bt485_wr_d(dc->dc_regs, BT485_REG_CURSOR_RAM,
-			    data->curimage[i]);
-		
-		/*
-		 * Write the cursor mask data:
-		 *	set addr[9:8] to 2,
-		 *	set addr[7:0] to 0,
-		 *	spit it all out.
-		 */
-		regval = tga_bt485_rd_i(dc->dc_regs,
-		    BT485_IREG_COMMAND_3);
-		regval &= ~0x03; regval |= 0x02;
-		tga_bt485_wr_i(dc->dc_regs, BT485_IREG_COMMAND_3,
-		    regval);
-                tga_bt485_wr_d(dc->dc_regs, BT485_REG_PCRAM_WRADDR, 0);
-		for (i = 0; i < count; i++)
-			tga_bt485_wr_d(dc->dc_regs, BT485_REG_CURSOR_RAM,
-			    data->curmask[i]);
-
-		/* set addr[9:0] back to 0 */
-		regval = tga_bt485_rd_i(dc->dc_regs, BT485_IREG_COMMAND_3);
-		regval &= ~0x03;
-		tga_bt485_wr_i(dc->dc_regs, BT485_IREG_COMMAND_3, regval);
-	}
-
-	if (v & DATA_CMAP_CHANGED) {
-		/* addr[9:0] assumed to be 0 */
-		/* set addr[7:0] to 0 */
-                tga_bt485_wr_d(dc->dc_regs, BT485_REG_PCRAM_WRADDR, 0x00);
-
-		/* spit out the cursor data */
-		for (i = 0; i < 256; i++) {
-                	tga_bt485_wr_d(dc->dc_regs, BT485_REG_PALETTE,
-			    data->cmap_r[i]);
-                	tga_bt485_wr_d(dc->dc_regs, BT485_REG_PALETTE,
-			    data->cmap_g[i]);
-                	tga_bt485_wr_d(dc->dc_regs, BT485_REG_PALETTE,
-			    data->cmap_b[i]);
-		}
-	}
-}
-
-void
-tga_bt485_update_curpos(dc, data)
-	struct tga_devconfig *dc;
-	struct bt485data *data;
-{
-	int s, x, y;
-
-	s = spltty();
-
-	x = data->curpos.x + CURSOR_MAX_SIZE - data->curhot.x;
-	y = data->curpos.y + CURSOR_MAX_SIZE - data->curhot.y;
-	tga_bt485_wr_d(dc->dc_regs, BT485_REG_CURSOR_X_LOW, x & 0xff);
-	tga_bt485_wr_d(dc->dc_regs, BT485_REG_CURSOR_X_HIGH, (x >> 8) & 0x0f);
-	tga_bt485_wr_d(dc->dc_regs, BT485_REG_CURSOR_Y_LOW, y & 0xff);
-	tga_bt485_wr_d(dc->dc_regs, BT485_REG_CURSOR_Y_HIGH, (y >> 8) & 0x0f);
-
-	splx(s);
-}
diff --git a/sys/dev/pci/tga_conf.c b/sys/dev/pci/tga_conf.c
index 88b5e206dc1..85a382200f1 100644
--- a/sys/dev/pci/tga_conf.c
+++ b/sys/dev/pci/tga_conf.c
@@ -1,4 +1,4 @@
-/* $NetBSD: tga_conf.c,v 1.1 1998/04/15 20:16:32 drochner Exp $ */
+/* $NetBSD: tga_conf.c,v 1.4 2000/04/02 18:59:32 nathanw Exp $ */
 
 /*
  * Copyright (c) 1995, 1996 Carnegie-Mellon University.
@@ -34,82 +34,85 @@
 #include <dev/pci/tgareg.h>
 #include <dev/pci/tgavar.h>
 
+#include <dev/ic/bt485var.h>
+#include <dev/ic/bt463var.h>
+
 #undef KB
-#define KB		* 1024
+#define KB              * 1024
 #undef MB
-#define	MB		* 1024 * 1024
+#define MB                * 1024 * 1024
 
 static const struct tga_conf tga_configs[TGA_TYPE_UNKNOWN] = {
-	/* TGA_TYPE_T8_01 */
-	{
-		"T8-01",
-		&tga_ramdac_bt485,
-		8,
-		4 MB,
-		2 KB,
-		1,	{  2 MB,     0 },	{ 1 MB,    0 },
-		0,	{     0,     0 },	{    0,    0 },
-	},
-	/* TGA_TYPE_T8_02 */
-	{
-		"T8-02",
-		&tga_ramdac_bt485,
-		8,
-		4 MB,
-		4 KB,
-		1,	{  2 MB,     0 },	{ 2 MB,    0 },
-		0,	{     0,     0 },	{    0,    0 },
-	},
-	/* TGA_TYPE_T8_22 */
-	{
-		"T8-22",
-		&tga_ramdac_bt485,
-		8,
-		8 MB,
-		4 KB,
-		1,	{  4 MB,     0 },	{ 2 MB,    0 },
-		1,	{  6 MB,     0 },	{ 2 MB,    0 },
-	},
-	/* TGA_TYPE_T8_44 */
-	{
-		"T8-44",
-		&tga_ramdac_bt485,
-		8,
-		16 MB,
-		4 KB,
-		2,	{  8 MB, 12 MB },	{ 2 MB, 2 MB },
-		2,	{ 10 MB, 14 MB },	{ 2 MB, 2 MB },
-	},
-	/* TGA_TYPE_T32_04 */
-	{
-		"T32-04",
-		&tga_ramdac_bt463,
-		32,
-		16 MB,
-		8 KB,
-		1,	{  8 MB,     0 },	{ 4 MB,    0 },
-		0,	{     0,     0 },	{    0,    0 },
-	},
-	/* TGA_TYPE_T32_08 */
-	{
-		"T32-08",
-		&tga_ramdac_bt463,
-		32,
-		16 MB,
-		16 KB,
-		1,	{  8 MB,    0 },	{ 8 MB,    0 },
-		0,	{     0,    0 },	{    0,    0 },
-	},
-	/* TGA_TYPE_T32_88 */
-	{
-		"T32-88",
-		&tga_ramdac_bt463,
-		32,
-		32 MB,
-		16 KB,
-		1,	{ 16 MB,    0 },	{ 8 MB,    0 },
-		1,	{ 24 MB,    0 },	{ 8 MB,    0 },
-	},
+        /* TGA_TYPE_T8_01 */
+        {
+                "T8-01",
+                bt485_funcs,
+                8,
+                4 MB,
+                2 KB,
+                1,        {  2 MB,     0 },        { 1 MB,    0 },
+                0,        {     0,     0 },        {    0,    0 },
+        },
+        /* TGA_TYPE_T8_02 */
+        {
+                "T8-02",
+                bt485_funcs,
+                8,
+                4 MB,
+                4 KB,
+                1,        {  2 MB,     0 },        { 2 MB,    0 },
+                0,        {     0,     0 },        {    0,    0 },
+        },
+        /* TGA_TYPE_T8_22 */
+        {
+                "T8-22",
+                bt485_funcs,
+                8,
+                8 MB,
+                4 KB,
+                1,        {  4 MB,     0 },        { 2 MB,    0 },
+                1,        {  6 MB,     0 },        { 2 MB,    0 },
+        },
+        /* TGA_TYPE_T8_44 */
+        {
+                "T8-44",
+                bt485_funcs,
+                8,
+                16 MB,
+                4 KB,
+                2,        {  8 MB, 12 MB },        { 2 MB, 2 MB },
+                2,        { 10 MB, 14 MB },        { 2 MB, 2 MB },
+        },
+        /* TGA_TYPE_T32_04 */
+        {
+                "T32-04",
+                bt463_funcs,
+                32,
+                16 MB,
+                8 KB,
+                1,        {  8 MB,     0 },        { 4 MB,    0 },
+                0,        {     0,     0 },        {    0,    0 },
+        },
+        /* TGA_TYPE_T32_08 */
+        {
+                "T32-08",
+                bt463_funcs,
+                32,
+                16 MB,
+                16 KB,
+                1,        {  8 MB,    0 },        { 8 MB,    0 },
+                0,        {     0,    0 },        {    0,    0 },
+        },
+        /* TGA_TYPE_T32_88 */
+        {
+                "T32-88",
+                bt463_funcs,
+                32,
+                32 MB,
+                16 KB,
+                1,        { 16 MB,    0 },        { 8 MB,    0 },
+                1,        { 24 MB,    0 },        { 8 MB,    0 },
+        },
 };
 
 #undef KB
@@ -119,65 +122,64 @@ int
 tga_identify(regs)
 	tga_reg_t *regs;
 {
-	int type;
-	int deep, addrmask, wide;
-
-	deep = (regs[TGA_REG_GDER] & 0x1) != 0;		/* XXX */
-	addrmask = ((regs[TGA_REG_GDER] >> 2) & 0x7);	/* XXX */
-	wide = (regs[TGA_REG_GDER] & 0x200) == 0;	/* XXX */
-
-	type = TGA_TYPE_UNKNOWN;
-
-	if (!deep) {
-		/* 8bpp frame buffer */
-
-		if (addrmask == 0x0) {
-			/* 4MB core map; T8-01 or T8-02 */
-
-			if (!wide)
-				type = TGA_TYPE_T8_01;
-			else
-				type = TGA_TYPE_T8_02;
-		} else if (addrmask == 0x1) {
-			/* 8MB core map; T8-22 */
-
-			if (wide)			/* sanity */
-				type = TGA_TYPE_T8_22;
-		} else if (addrmask == 0x3) {
-			/* 16MB core map; T8-44 */
-
-			if (wide)			/* sanity */
-				type = TGA_TYPE_T8_44;
-		}
-	} else {
-		/* 32bpp frame buffer */
-
-		if (addrmask == 0x3) {
-			/* 16MB core map; T32-04 or T32-08 */
-
-			if (!wide)
-				type = TGA_TYPE_T32_04;
-			else
-				type = TGA_TYPE_T32_08;
-		} else if (addrmask == 0x7) {
-			/* 32MB core map; T32-88 */
-
-			if (wide)			/* sanity */
-				type = TGA_TYPE_T32_88;
-		}
-	}
-
-	return (type);
+        int type;
+        int deep, addrmask, wide;
+
+	deep = (regs[TGA_REG_GDER] & 0x1) != 0;                /* XXX */
+	addrmask = ((regs[TGA_REG_GDER] >> 2) & 0x7);        /* XXX */
+	wide = (regs[TGA_REG_GDER] & 0x200) == 0;        /* XXX */
+
+        type = TGA_TYPE_UNKNOWN;
+
+        if (!deep) {
+                /* 8bpp frame buffer */
+
+                if (addrmask == 0x0) {
+                        /* 4MB core map; T8-01 or T8-02 */
+
+                        if (!wide)
+                                type = TGA_TYPE_T8_01;
+                        else
+                                type = TGA_TYPE_T8_02;
+                } else if (addrmask == 0x1) {
+                        /* 8MB core map; T8-22 */
+
+                        if (wide)                        /* sanity */
+                                type = TGA_TYPE_T8_22;
+                } else if (addrmask == 0x3) {
+                        /* 16MB core map; T8-44 */
+
+                        if (wide)                        /* sanity */
+                                type = TGA_TYPE_T8_44;
+                }
+        } else {
+                /* 32bpp frame buffer */
+
+                if (addrmask == 0x3) {
+                        /* 16MB core map; T32-04 or T32-08 */
+
+                        if (!wide)
+                                type = TGA_TYPE_T32_04;
+                        else
+                                type = TGA_TYPE_T32_08;
+                } else if (addrmask == 0x7) {
+                        /* 32MB core map; T32-88 */
+
+                        if (wide)                        /* sanity */
+                                type = TGA_TYPE_T32_88;
+                }
+        }
+
+        return (type);
 }
 
 const struct tga_conf *
 tga_getconf(type)
-	int type;
+        int type;
 {
 
-	if (type >= 0 && type < TGA_TYPE_UNKNOWN)
-		return &tga_configs[type];
+        if (type >= 0 && type < TGA_TYPE_UNKNOWN)
+                return &tga_configs[type];
 
-	return (NULL);
+        return (NULL);
 }
-
diff --git a/sys/dev/pci/tgareg.h b/sys/dev/pci/tgareg.h
index d47033fce82..18f66ebc4c7 100644
--- a/sys/dev/pci/tgareg.h
+++ b/sys/dev/pci/tgareg.h
@@ -1,4 +1,4 @@
-/* $NetBSD: tgareg.h,v 1.2 1998/04/29 02:11:19 thorpej Exp $ */
+/* $NetBSD: tgareg.h,v 1.3 2000/03/04 10:28:00 elric Exp $ */
 
 /*
  * Copyright (c) 1995, 1996 Carnegie-Mellon University.
@@ -43,7 +43,12 @@
  */
 
 #define	TGA_MEM_ALTROM	0x0000000	/* 0MB -- Alternate ROM space */
+#define TGA2_MEM_EXTDEV	0x0000000	/* 0MB -- External Device Access */
 #define	TGA_MEM_CREGS	0x0100000	/* 1MB -- Core Registers */
+
+#define TGA2_MEM_CLOCK	0x0060000	/* TGA2 Clock access */
+#define TGA2_MEM_RAMDAC	0x0080000	/* TGA2 RAMDAC access */
+
 /* Display and Back Buffers mapped at config-dependent addresses */
 
 /*
@@ -76,7 +81,8 @@ typedef u_int32_t tga_reg_t;
 
 #define	TGA_REG_GCTR	0x013		/* Continue */
 #define	TGA_REG_GDER	0x014		/* Deep */
-/*	reserved	0x015 */
+#define TGA_REG_GREV	0x015		/* Start/Version on TGA,
+					 * Revision on TGA2 */
 #define	TGA_REG_GSMR	0x016		/* Stencil Mode */
 #define	TGA_REG_GPXR_P	0x017		/* Pixel Mask (persistent) */
 #define	TGA_REG_CCBR	0x018		/* Cursor Base Address */
diff --git a/sys/dev/pci/tgavar.h b/sys/dev/pci/tgavar.h
index 59d9b1017af..89b108f2c5f 100644
--- a/sys/dev/pci/tgavar.h
+++ b/sys/dev/pci/tgavar.h
@@ -1,4 +1,4 @@
-/* $NetBSD: tgavar.h,v 1.4 1998/08/18 08:23:46 thorpej Exp $ */
+/* $NetBSD: tgavar.h,v 1.8 2000/04/02 19:01:11 nathanw Exp $ */
 
 /*
  * Copyright (c) 1995, 1996 Carnegie-Mellon University.
@@ -27,6 +27,7 @@
  * rights to redistribute these changes.
  */
 
+#include <dev/ic/ramdac.h>
 #include <dev/pci/tgareg.h>
 #include <dev/rcons/raster.h>
 #include <dev/wscons/wsconsio.h>
@@ -37,119 +38,96 @@ struct fbcmap;
 struct fbcursor;
 struct fbcurpos;
 
-struct tga_ramdac_conf {
-	char	*tgar_name;
-	void	(*tgar_init) __P((struct tga_devconfig *, int));
-	int	(*tgar_intr) __P((void *));
-	int	(*tgar_set_cmap) __P((struct tga_devconfig *,
-		    struct wsdisplay_cmap *));
-	int	(*tgar_get_cmap) __P((struct tga_devconfig *,
-		    struct wsdisplay_cmap *));
-	int	(*tgar_set_cursor) __P((struct tga_devconfig *,
-		    struct wsdisplay_cursor *));
-	int	(*tgar_get_cursor) __P((struct tga_devconfig *,
-		    struct wsdisplay_cursor *));
-	int	(*tgar_set_curpos) __P((struct tga_devconfig *,
-		    struct wsdisplay_curpos *));
-	int	(*tgar_get_curpos) __P((struct tga_devconfig *,
-		    struct wsdisplay_curpos *));
-	int	(*tgar_get_curmax) __P((struct tga_devconfig *,
-		    struct wsdisplay_curpos *));
-
-	/* Only called from the TGA built-in cursor handling code. */
-	int	(*tgar_check_curcmap) __P((struct tga_devconfig *,
-		    struct wsdisplay_cursor *));
-	void	(*tgar_set_curcmap) __P((struct tga_devconfig *,
-		    struct wsdisplay_cursor *));
-	int	(*tgar_get_curcmap) __P((struct tga_devconfig *,
-		    struct wsdisplay_cursor *));
-};
-
 struct tga_conf {
-	char	    *tgac_name;		/* name for this board type */
+        char            *tgac_name;                /* name for this board type */
 
-	const struct tga_ramdac_conf
-		    *tgac_ramdac;	/* the RAMDAC type; see above */
-	int	    tgac_phys_depth;	/* physical frame buffer depth */
-	vsize_t   tgac_cspace_size;	/* core space size */
-	vsize_t   tgac_vvbr_units;	/* what '1' in the VVBR means */
+        struct ramdac_funcs *(*ramdac_funcs) __P((void));
 
-	int	    tgac_ndbuf;		/* number of display buffers */
-	vaddr_t tgac_dbuf[2];	/* display buffer offsets/addresses */
-	vsize_t   tgac_dbufsz[2];	/* display buffer sizes */
+        int            tgac_phys_depth;        /* physical frame buffer depth */
+        vsize_t   tgac_cspace_size;        /* core space size */
+        vsize_t   tgac_vvbr_units;        /* what '1' in the VVBR means */
 
-	int	    tgac_nbbuf;		/* number of display buffers */
-	vaddr_t tgac_bbuf[2];	/* back buffer offsets/addresses */
-	vsize_t   tgac_bbufsz[2];	/* back buffer sizes */
+        int            tgac_ndbuf;                /* number of display buffers */
+        vaddr_t tgac_dbuf[2];        /* display buffer offsets/addresses */
+        vsize_t   tgac_dbufsz[2];        /* display buffer sizes */
+
+        int            tgac_nbbuf;                /* number of display buffers */
+        vaddr_t tgac_bbuf[2];        /* back buffer offsets/addresses */
+        vsize_t   tgac_bbufsz[2];        /* back buffer sizes */
 };
 
 struct tga_devconfig {
-	bus_space_tag_t dc_memt;
+        bus_space_tag_t dc_memt;
 	pci_chipset_tag_t dc_pc;
+        pcitag_t            dc_pcitag;        /* PCI tag */
+        bus_addr_t         dc_pcipaddr;        /* PCI phys addr. */
 
-	pcitag_t   	 dc_pcitag;	/* PCI tag */
-	bus_addr_t	 dc_pcipaddr;	/* PCI phys addr. */
+	tga_reg_t   *dc_regs;                /* registers; XXX: need aliases */
+        int            dc_tga_type;        /* the device type; see below */
+        int            dc_tga2;                /* True if it is a TGA2 */
+        const struct tga_conf *dc_tgaconf; /* device buffer configuration */
 
-	tga_reg_t   *dc_regs;		/* registers; XXX: need aliases */
+        struct ramdac_funcs
+                    *dc_ramdac_funcs;        /* The RAMDAC functions */
+        struct ramdac_cookie
+                    *dc_ramdac_cookie;        /* the RAMDAC type; see above */
 
-	int	    dc_tga_type;	/* the device type; see below */
-	const struct tga_conf *dc_tgaconf; /* device buffer configuration */
+        vaddr_t dc_vaddr;                /* memory space virtual base address */
+        paddr_t dc_paddr;                /* memory space physical base address */
 
-	vaddr_t dc_vaddr;		/* memory space virtual base address */
-	paddr_t dc_paddr;		/* memory space physical base address */
+        int            dc_wid;                /* width of frame buffer */
+        int            dc_ht;                /* height of frame buffer */
+        int            dc_rowbytes;        /* bytes in a FB scan line */
 
-	int	    dc_wid;		/* width of frame buffer */
-	int	    dc_ht;		/* height of frame buffer */
-	int	    dc_rowbytes;	/* bytes in a FB scan line */
+        vaddr_t dc_videobase;        /* base of flat frame buffer */
 
-	vaddr_t dc_videobase;	/* base of flat frame buffer */
+        struct raster        dc_raster;        /* raster description */
+        struct rcons        dc_rcons;        /* raster blitter control info */
 
-	struct raster	dc_raster;	/* raster description */
-	struct rcons	dc_rcons;	/* raster blitter control info */
+        int            dc_blanked;                /* currently had video disabled */
+        void            *dc_ramdac_private; /* RAMDAC private storage */
 
-	int	    dc_blanked;		/* currently had video disabled */
-	void	    *dc_ramdac_private; /* RAMDAC private storage */
+        void            (*dc_ramdac_intr) __P((void *));
+        int                dc_intrenabled; /* can we depend on interrupts yet? */
 };
-	
+        
 struct tga_softc {
-	struct	device sc_dev;
+        struct        device sc_dev;
 
-	struct	tga_devconfig *sc_dc;	/* device configuration */
-	void	*sc_intr;		/* interrupt handler info */
-	/* XXX should record intr fns/arg */
+        struct        tga_devconfig *sc_dc;        /* device configuration */
+        void        *sc_intr;                /* interrupt handler info */
+        /* XXX should record intr fns/arg */
 
-	int nscreens;
+        int nscreens;
 };
 
-#define	TGA_TYPE_T8_01		0	/* 8bpp, 1MB */
-#define	TGA_TYPE_T8_02		1	/* 8bpp, 2MB */
-#define	TGA_TYPE_T8_22		2	/* 8bpp, 4MB */
-#define	TGA_TYPE_T8_44		3	/* 8bpp, 8MB */
-#define	TGA_TYPE_T32_04		4	/* 32bpp, 4MB */
-#define	TGA_TYPE_T32_08		5	/* 32bpp, 8MB */
-#define	TGA_TYPE_T32_88		6	/* 32bpp, 16MB */
-#define	TGA_TYPE_UNKNOWN	7	/* unknown */
+#define TGA_TYPE_T8_01                0        /* 8bpp, 1MB */
+#define TGA_TYPE_T8_02                1        /* 8bpp, 2MB */
+#define TGA_TYPE_T8_22                2        /* 8bpp, 4MB */
+#define TGA_TYPE_T8_44                3        /* 8bpp, 8MB */
+#define TGA_TYPE_T32_04                4        /* 32bpp, 4MB */
+#define TGA_TYPE_T32_08                5        /* 32bpp, 8MB */
+#define TGA_TYPE_T32_88                6        /* 32bpp, 16MB */
+#define TGA_TYPE_UNKNOWN        7        /* unknown */
 
-#define	DEVICE_IS_TGA(class, id)					\
-	    ((PCI_VENDOR(id) == PCI_VENDOR_DEC &&			\
-	     PCI_PRODUCT(id) == PCI_PRODUCT_DEC_21030) ? 10 : 0)
+#define DEVICE_IS_TGA(class, id)                                        \
+            (((PCI_VENDOR(id) == PCI_VENDOR_DEC &&                        \
+               PCI_PRODUCT(id) == PCI_PRODUCT_DEC_21030) ||                \
+               PCI_PRODUCT(id) == PCI_PRODUCT_DEC_PBXGB) ? 10 : 0)
 
 int tga_cnattach __P((bus_space_tag_t, bus_space_tag_t, pci_chipset_tag_t,
-		      int, int, int));
+                      int, int, int));
 
-int	tga_identify __P((tga_reg_t *));
+int     tga_identify __P((tga_reg_t *));
 const struct tga_conf *tga_getconf __P((int));
 
-extern const struct tga_ramdac_conf tga_ramdac_bt463;
-extern const struct tga_ramdac_conf tga_ramdac_bt485;
-
 int     tga_builtin_set_cursor __P((struct tga_devconfig *,
-	    struct wsdisplay_cursor *));
+            struct wsdisplay_cursor *));
 int     tga_builtin_get_cursor __P((struct tga_devconfig *,
-	    struct wsdisplay_cursor *));
+            struct wsdisplay_cursor *));
 int     tga_builtin_set_curpos __P((struct tga_devconfig *,
-	    struct wsdisplay_curpos *));
+            struct wsdisplay_curpos *));
 int     tga_builtin_get_curpos __P((struct tga_devconfig *,
-	    struct wsdisplay_curpos *));
+            struct wsdisplay_curpos *));
 int     tga_builtin_get_curmax __P((struct tga_devconfig *,
-	    struct wsdisplay_curpos *));
+            struct wsdisplay_curpos *));