* Copyright (c) 2006 Miodrag Vallat.

/* $NetBSD: gpx.c,v 1.4 2024/09/30 00:34:04 rin Exp $ */
/* $OpenBSD: gpx.c,v 1.25 2014/12/23 21:39:12 miod Exp $ */
/*
* Copyright (c) 2006 Miodrag Vallat.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice, this permission notice, and the disclaimer below
* appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*-
* Copyright (c) 1988 Regents of the University of California.
* 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
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University 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 REGENTS 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 REGENTS 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.
*
* @(#)qd.c 7.1 (Berkeley) 6/28/91
*/

/************************************************************************
* *
* Copyright (c) 1985-1988 by *
* Digital Equipment Corporation, Maynard, MA *
* All rights reserved. *
* *
* This software is furnished under a license and may be used and *
* copied only in accordance with the terms of such license and *
* with the inclusion of the above copyright notice. This *
* software or any other copies thereof may not be provided or *
* otherwise made available to any other person. No title to and *
* ownership of the software is hereby transferred. *
* *
* The information in this software is subject to change without *
* notice and should not be construed as a commitment by Digital *
* Equipment Corporation. *
* *
* Digital assumes no responsibility for the use or reliability *
* of its software on equipment which is not supplied by Digital. *
* *
*************************************************************************/

/*
* Driver for the GPX color option on VAXstation 3100, based on the
* MicroVAX II qdss driver.
*
* The frame buffer memory itself is not directly accessible (unlike
* the on-board monochrome smg frame buffer), and writes through the
* Dragon chip can only happen in multiples of 16 pixels, horizontally.
*
* Because of this limitation, the font image is copied to offscreen
* memory (which there is plenty of), and screen to screen blt operations
* are done for everything.
*/

#include "dzkbd.h"
#include "wsdisplay.h"

#include <sys/param.h>
#include <sys/device.h>
#include <sys/systm.h>
#include <sys/kmem.h>
#include <sys/conf.h>

#include <machine/sid.h>
#include <machine/cpu.h>
#include <machine/ka420.h>
#include <machine/scb.h>
#include <machine/vsbus.h>
#include <machine/qdreg.h>

#include <dev/cons.h>

#include <dev/dec/dzreg.h>
#include <dev/dec/dzvar.h>
#include <dev/dec/dzkbdvar.h>

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wscons_callbacks.h>
#include <dev/wscons/wsdisplayvar.h>
#include <dev/rasops/rasops.h>
#include <dev/wsfont/wsfont.h>

#if 0
#include <dev/ic/bt458reg.h>
#include <dev/ic/dc503reg.h>
#endif

#define GPXADDR 0x3c000000 /* base address on VAXstation 3100 */

#define GPX_ADDER_OFFSET 0x0000
#define GPX_VDAC_OFFSET 0x0300
#define GPX_CURSOR_OFFSET 0x0400 /* DC503 */
#define GPX_READBACK_OFFSET 0x0500

#define GPX_WIDTH 1024
#define GPX_VISHEIGHT 864
#define GPX_HEIGHT 2048

/* XXX these should be in <dev/ic/bt458reg.h> */
/*
* Brooktree Bt451, Bt457, Bt458 register definitions
*/
#define BT_OV0 0x00 /* overlay 0 */
#define BT_OV1 0x01 /* overlay 1 */
#define BT_OV2 0x02 /* overlay 2 */
#define BT_OV3 0x03 /* overlay 3 */
#define BT_RMR 0x04 /* read mask */
#define BT_BMR 0x05 /* blink mask */
#define BT_CR 0x06 /* control */
#define BT_CTR 0x07 /* control/test */

#define BTCR_MPLX_5 0x80 /* multiplex select, 5:1 */
#define BTCR_MPLX_4 0x00 /* multiplex select, 4:1 */
#define BTCR_RAMENA 0x40 /* use color palette RAM */
#define BTCR_BLINK_M 0x30 /* blink mask */
#define BTCR_BLINK_1648 0x00 /* 16 on, 48 off */
#define BTCR_BLINK_1616 0x10 /* 16 on, 16 off */
#define BTCR_BLINK_3232 0x20 /* 32 on, 32 off */
#define BTCR_BLINK_6464 0x30 /* 64 on, 64 off */
#define BTCR_BLINKENA_OV1 0x08 /* OV1 blink enable */
#define BTCR_BLINKENA_OV0 0x04 /* OV0 blink enable */
#define BTCR_DISPENA_OV1 0x02 /* OV1 display enable */
#define BTCR_DISPENA_OV0 0x01 /* OV0 display enable */

#define BTCTR_R_ENA 0x01 /* red channel enable */
#define BTCTR_G_ENA 0x02 /* green channel enable */
#define BTCTR_B_ENA 0x04 /* blue channel enable */
#define BTCTR_NIB_M 0x08 /* nibble mask: */
#define BTCTR_NIB_LOW 0x08 /* low */
#define BTCTR_NIB_HIGH 0x00 /* high */

/* 4 plane option RAMDAC */
struct ramdac4 {
uint16_t colormap[16];
uint8_t unknown[0x20];
uint16_t cursormap[4];
uint8_t unknown2[0x18];
uint16_t control;
#define RAMDAC4_INIT 0x0047
#define RAMDAC4_ENABLE 0x0002
};

/* 8 plane option RAMDAC - Bt458 or compatible */
struct ramdac8 {
uint16_t address;
uint16_t cmapdata;
uint16_t control;
uint16_t omapdata;
};

struct gpx_screen {
struct rasops_info ss_ri;
int ss_console;
u_int ss_depth;
u_int ss_gpr; /* font glyphs per row */
struct adder *ss_adder;
void *ss_vdac;
uint8_t ss_cmap[256 * 3];
#if 0
struct dc503reg *ss_cursor;
uint16_t ss_curcmd;
#endif
};

struct gpx_softc {
device_t sc_dev;
struct gpx_screen *sc_scr;
int sc_nscreens;
};

static int gpx_match(device_t, cfdata_t, void *);
static void gpx_attach(device_t, device_t, void *);

static int gpx_ioctl(void *, void *, u_long, void *, int, struct lwp *);
static paddr_t gpx_mmap(void *, void *, off_t, int);
static int gpx_alloc_screen(void *, const struct wsscreen_descr *,
void **, int *, int *, long *);
static void gpx_free_screen(void *, void *);
static int gpx_show_screen(void *, void *, int,
void (*) (void *, int, int), void *);

static void gpx_putchar(void *, int, int, u_int, long);
static void gpx_copycols(void *, int, int, int, int);
static void gpx_erasecols(void *, int, int, int, long);
static void gpx_copyrows(void *, int, int, int);
static void gpx_eraserows(void *, int, int, long);
static void gpx_do_cursor(struct rasops_info *);

static int gpx_wait(struct gpx_screen *, int);
static int gpx_viper_write(struct gpx_screen *, u_int, uint16_t);
static void gpx_reset_viper(struct gpx_screen *);
static void gpx_clear_screen(struct gpx_screen *);
static int gpx_setup_screen(struct gpx_screen *);
static void gpx_upload_font(struct gpx_screen *);
static void gpx_copyrect(struct gpx_screen *, int, int, int, int, int, int);
static void gpx_fillrect(struct gpx_screen *, int, int, int, int, long, u_int);
static int gpx_getcmap(struct gpx_screen *, struct wsdisplay_cmap *);
static int gpx_putcmap(struct gpx_screen *, struct wsdisplay_cmap *);
static void gpx_loadcmap(struct gpx_screen *, int, int);
static void gpx_resetcmap(struct gpx_screen *);

/* for console */
static struct gpx_screen gpx_consscr;

CFATTACH_DECL_NEW(gpx, sizeof(struct gpx_softc),
gpx_match, gpx_attach, NULL, NULL);

static struct wsscreen_descr gpx_stdscreen = {
"std",
};

static const struct wsscreen_descr *_gpx_scrlist[] = {
&gpx_stdscreen,
};

static const struct wsscreen_list gpx_screenlist = {
sizeof(_gpx_scrlist) / sizeof(struct wsscreen_descr *),
_gpx_scrlist,
};

static const struct wsdisplay_accessops gpx_accessops = {
.ioctl = gpx_ioctl,
.mmap = gpx_mmap,
.alloc_screen = gpx_alloc_screen,
.free_screen = gpx_free_screen,
.show_screen = gpx_show_screen,
.load_font = NULL
};

/*
* Autoconf glue
*/

static int
gpx_match(device_t parent, cfdata_t match, void *aux)
{
struct vsbus_attach_args *va = aux;
volatile struct adder *adder;
vaddr_t tmp;
u_int depth;
u_short status;

switch (vax_boardtype) {
default:
return 0;

case VAX_BTYP_410:
case VAX_BTYP_420:
case VAX_BTYP_43:
if (va->va_paddr != GPXADDR)
return 0;

/* not present on microvaxes */
if ((vax_confdata & KA420_CFG_MULTU) != 0)
return 0;

if ((vax_confdata & KA420_CFG_VIDOPT) == 0)
return 0;
break;
}

/* Check for hardware */
adder = (volatile struct adder *)
vax_map_physmem(va->va_paddr + GPX_ADDER_OFFSET, 1);
if (adder == NULL)
return 0;
adder->status = 0;
status = adder->status;
vax_unmap_physmem((vaddr_t)adder, 1);
if (status == offsetof(struct adder, status))
return 0;

/* Check for a recognized color depth */
tmp = vax_map_physmem(va->va_paddr + GPX_READBACK_OFFSET, 1);
if (tmp == 0L)
return 0;
depth = (*(volatile uint16_t *)tmp) & 0x00f0;
vax_unmap_physmem(tmp, 1);
if (depth != 0x00f0 && depth != 0x0080)
return 0;

/* when already running as console, always fake things */
if ((vax_confdata & KA420_CFG_L3CON) == 0
#if NWSDISPLAY > 0
&& cn_tab->cn_putc == wsdisplay_cnputc
#endif
) {
struct vsbus_softc *sc = device_private(parent);
sc->sc_mask = 0x08;
scb_fake(0x44, 0x15);
} else {
adder = (struct adder *)vax_map_physmem(va->va_paddr +
GPX_ADDER_OFFSET, 1);
if (adder == NULL)
return 0;
adder->interrupt_enable = FRAME_SYNC;
DELAY(100000); /* enough to get a retrace interrupt */
adder->interrupt_enable = 0;
vax_unmap_physmem((vaddr_t)adder, 1);
}
return 20;
}

static void
gpx_attach(device_t parent, device_t self, void *aux)
{
struct gpx_softc *sc = device_private(self);
struct vsbus_attach_args *va = aux;
struct gpx_screen *scr;
struct wsemuldisplaydev_attach_args aa;
int console;
vaddr_t tmp;

sc->sc_dev = self;
console =
#if NWSDISPLAY > 0
(vax_confdata & KA420_CFG_L3CON) == 0 &&
cn_tab->cn_putc == wsdisplay_cnputc;
#else
(vax_confdata & KA420_CFG_L3CON) == 0;
#endif
if (console) {
scr = &gpx_consscr;
sc->sc_nscreens = 1;
} else {
scr = kmem_zalloc(sizeof(*scr), KM_SLEEP);

tmp = vax_map_physmem(va->va_paddr + GPX_READBACK_OFFSET, 1);
if (tmp == 0L) {
printf(": can not probe depth\n");
goto bad1;
}
scr->ss_depth = (*(uint16_t *)tmp & 0x00f0) == 0x00f0 ? 4 : 8;
vax_unmap_physmem(tmp, 1);

scr->ss_adder = (struct adder *)vax_map_physmem(va->va_paddr +
GPX_ADDER_OFFSET, 1);
if (scr->ss_adder == NULL) {
aprint_error(": can not map frame buffer registers\n");
goto bad1;
}

scr->ss_vdac = (void *)vax_map_physmem(va->va_paddr +
GPX_VDAC_OFFSET, 1);
if (scr->ss_vdac == NULL) {
aprint_error(": can not map RAMDAC\n");
goto bad2;
}

#if 0
scr->ss_cursor =
(struct dc503reg *)vax_map_physmem(va->va_paddr +
GPX_CURSOR_OFFSET, 1);
if (scr->ss_cursor == NULL) {
aprint_error(": can not map cursor chip\n");
goto bad3;
}
#endif

if (gpx_setup_screen(scr) != 0) {
aprint_error(": initialization failed\n");
goto bad4;
}
}
sc->sc_scr = scr;

aprint_normal("\n");
aprint_normal_dev(self, "%dx%d %d plane color framebuffer\n",
GPX_WIDTH, GPX_VISHEIGHT, scr->ss_depth);

aa.console = console;
aa.scrdata = &gpx_screenlist;
aa.accessops = &gpx_accessops;
aa.accesscookie = sc;

config_found(self, &aa, wsemuldisplaydevprint, CFARGS_NONE);

return;

bad4:
#if 0
vax_unmap_physmem((vaddr_t)scr->ss_cursor, 1);
bad3:
#endif
vax_unmap_physmem((vaddr_t)scr->ss_vdac, 1);
bad2:
vax_unmap_physmem((vaddr_t)scr->ss_adder, 1);
bad1:
kmem_free(scr, sizeof(*scr));
}

/*
* wsdisplay accessops
*/

static int
gpx_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, struct lwp *l)
{
struct gpx_softc *sc = v;
struct gpx_screen *ss = sc->sc_scr;
struct wsdisplay_fbinfo *wdf;
struct wsdisplay_cmap *cm;
int error;

switch (cmd) {
case WSDISPLAYIO_GTYPE:
*(u_int *)data = WSDISPLAY_TYPE_GPX;
break;

case WSDISPLAYIO_GINFO:
wdf = (struct wsdisplay_fbinfo *)data;
wdf->height = ss->ss_ri.ri_height;
wdf->width = ss->ss_ri.ri_width;
wdf->depth = ss->ss_depth;
wdf->cmsize = 1 << ss->ss_depth;
break;

case WSDISPLAYIO_GETCMAP:
cm = (struct wsdisplay_cmap *)data;
error = gpx_getcmap(ss, cm);
if (error != 0)
return error;
break;
case WSDISPLAYIO_PUTCMAP:
cm = (struct wsdisplay_cmap *)data;
error = gpx_putcmap(ss, cm);
if (error != 0)
return error;
gpx_loadcmap(ss, cm->index, cm->count);
break;

case WSDISPLAYIO_GVIDEO:
case WSDISPLAYIO_SVIDEO:
break;

case WSDISPLAYIO_LINEBYTES: /* no linear mapping */
return -1;

default:
return EPASSTHROUGH;
}
return 0;
}

static paddr_t
gpx_mmap(void *v, void *vs, off_t offset, int prot)
{

return -1;
}

static int
gpx_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep,
int *curxp, int *curyp, long *defattrp)
{
struct gpx_softc *sc = v;
struct gpx_screen *ss = sc->sc_scr;
struct rasops_info *ri = &ss->ss_ri;

if (sc->sc_nscreens > 0)
return ENOMEM;

*cookiep = ri;
*curxp = *curyp = 0;
ri->ri_ops.allocattr(ri, 0, 0, 0, defattrp);
sc->sc_nscreens++;

return 0;
}

static void
gpx_free_screen(void *v, void *cookie)
{
struct gpx_softc *sc = v;

sc->sc_nscreens--;
}

static int
gpx_show_screen(void *v, void *cookie, int waitok,
void (*cb)(void *, int, int), void *cbarg)
{

return 0;
}

/*
* wsdisplay emulops
*/

static void
gpx_putchar(void *v, int row, int col, u_int uc, long attr)
{
struct rasops_info *ri = v;
struct gpx_screen *ss = ri->ri_hw;
struct wsdisplay_font *font = ri->ri_font;
int dx, dy, sx, sy, fg, bg, ul;

rasops_unpack_attr(attr, &fg, &bg, &ul);

/* find where to output the glyph... */
dx = col * font->fontwidth + ri->ri_xorigin;
dy = row * font->fontheight + ri->ri_yorigin;
/* ... and where to pick it from */
uc -= font->firstchar;
sx = (uc % ss->ss_gpr) * font->stride * NBBY;
sy = GPX_HEIGHT - (1 + uc / ss->ss_gpr) * font->fontheight;

/* setup VIPER operand control registers */
while (gpx_viper_write(ss, CS_UPDATE_MASK, 0x00ff))
continue;
gpx_viper_write(ss, SRC1_OCR_B,
EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
gpx_viper_write(ss, DST_OCR_B,
EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
gpx_viper_write(ss, MASK_1, 0xffff);
gpx_viper_write(ss, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, fg);
gpx_viper_write(ss, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, bg);
ss->ss_adder->x_clip_min = 0;
ss->ss_adder->x_clip_max = GPX_WIDTH;
ss->ss_adder->y_clip_min = 0;
ss->ss_adder->y_clip_max = GPX_VISHEIGHT;
/* load DESTINATION origin and vectors */
ss->ss_adder->fast_dest_dy = 0;
ss->ss_adder->slow_dest_dx = 0;
ss->ss_adder->error_1 = 0;
ss->ss_adder->error_2 = 0;
ss->ss_adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
gpx_wait(ss, RASTEROP_COMPLETE);
ss->ss_adder->destination_x = dx;
ss->ss_adder->fast_dest_dx = font->fontwidth;
ss->ss_adder->destination_y = dy;
ss->ss_adder->slow_dest_dy = font->fontheight;
/* load SOURCE origin and vectors */
ss->ss_adder->source_1_x = sx;
ss->ss_adder->source_1_y = sy;
ss->ss_adder->source_1_dx = font->fontwidth;
ss->ss_adder->source_1_dy = font->fontheight;
ss->ss_adder->cmd = RASTEROP | OCRB | S1E | DTE | LF_R1;

if (ul != 0) {
gpx_fillrect(ss, dx, dy + font->fontheight - 2, font->fontwidth,
1, attr, LF_R3); /* fg fill */
}
}

static void
gpx_copycols(void *v, int row, int src, int dst, int cnt)
{
struct rasops_info *ri = v;
struct gpx_screen *ss = ri->ri_hw;
struct wsdisplay_font *font = ri->ri_font;
int sx, y, dx, w, h;

sx = ri->ri_xorigin + src * font->fontwidth;
dx = ri->ri_xorigin + dst * font->fontwidth;
w = cnt * font->fontwidth;
y = ri->ri_yorigin + row * font->fontheight;
h = font->fontheight;

gpx_copyrect(ss, sx, y, dx, y, w, h);
}

static void
gpx_erasecols(void *v, int row, int col, int cnt, long attr)
{
struct rasops_info *ri = v;
struct gpx_screen *ss = ri->ri_hw;
struct wsdisplay_font *font = ri->ri_font;
int x, y, dx, dy;

x = ri->ri_xorigin + col * font->fontwidth;
dx = cnt * font->fontwidth;
y = ri->ri_yorigin + row * font->fontheight;
dy = font->fontheight;

gpx_fillrect(ss, x, y, dx, dy, attr, LF_R2); /* bg fill */
}

static void
gpx_copyrows(void *v, int src, int dst, int cnt)
{
struct rasops_info *ri = v;
struct gpx_screen *ss = ri->ri_hw;
struct wsdisplay_font *font = ri->ri_font;
int x, sy, dy, w, h;

x = ri->ri_xorigin;
w = ri->ri_emustride;
sy = ri->ri_yorigin + src * font->fontheight;
dy = ri->ri_yorigin + dst * font->fontheight;
h = cnt * font->fontheight;

gpx_copyrect(ss, x, sy, x, dy, w, h);
}

static void
gpx_eraserows(void *v, int row, int cnt, long attr)
{
struct rasops_info *ri = v;
struct gpx_screen *ss = ri->ri_hw;
struct wsdisplay_font *font = ri->ri_font;
int x, y, dx, dy;

x = ri->ri_xorigin;
dx = ri->ri_emustride;
y = ri->ri_yorigin + row * font->fontheight;
dy = cnt * font->fontheight;

gpx_fillrect(ss, x, y, dx, dy, attr, LF_R2); /* bg fill */
}

static void
gpx_do_cursor(struct rasops_info *ri)
{
struct gpx_screen *ss = ri->ri_hw;
int x, y, w, h;

x = ri->ri_ccol * ri->ri_font->fontwidth + ri->ri_xorigin;
y = ri->ri_crow * ri->ri_font->fontheight + ri->ri_yorigin;
w = ri->ri_font->fontwidth;
h = ri->ri_font->fontheight;

gpx_fillrect(ss, x, y, w, h, WSCOL_WHITE << 24, LF_R4); /* invert */
}

/*
* low-level programming routines
*/

static int
gpx_wait(struct gpx_screen *ss, int bits)
{
int i;

ss->ss_adder->status = 0;
for (i = 100000; i != 0; i--) {
if ((ss->ss_adder->status & bits) == bits)
break;
DELAY(1);
}

return i == 0;
}

static int
gpx_viper_write(struct gpx_screen *ss, u_int reg, uint16_t val)
{
if (gpx_wait(ss, ADDRESS_COMPLETE) == 0 &&
gpx_wait(ss, TX_READY) == 0) {
ss->ss_adder->id_data = val;
ss->ss_adder->command = ID_LOAD | reg;
return 0;
}
#ifdef DEBUG
if (ss->ss_console == 0) /* don't make things worse! */
printf("gpx_viper_write failure, reg %x val %x\n", reg, val);
#endif
return 1;
}

/* Initialize the damned beast. Straight from qdss. */
static void
gpx_reset_viper(struct gpx_screen *ss)
{
int i;

ss->ss_adder->interrupt_enable = 0;
ss->ss_adder->command = CANCEL;
/* set monitor timing */
ss->ss_adder->x_scan_count_0 = 0x2800;
ss->ss_adder->x_scan_count_1 = 0x1020;
ss->ss_adder->x_scan_count_2 = 0x003a;
ss->ss_adder->x_scan_count_3 = 0x38f0;
ss->ss_adder->x_scan_count_4 = 0x6128;
ss->ss_adder->x_scan_count_5 = 0x093a;
ss->ss_adder->x_scan_count_6 = 0x313c;
ss->ss_adder->sync_phase_adj = 0x0100;
ss->ss_adder->x_scan_conf = 0x00c8;
/*
* got a bug in second pass ADDER! lets take care of it...
*
* normally, just use the code in the following bug fix code, but to
* make repeated demos look pretty, load the registers as if there was
* no bug and then test to see if we are getting sync
*/
ss->ss_adder->y_scan_count_0 = 0x135f;
ss->ss_adder->y_scan_count_1 = 0x3363;
ss->ss_adder->y_scan_count_2 = 0x2366;
ss->ss_adder->y_scan_count_3 = 0x0388;
/*
* if no sync, do the bug fix code
*/
if (gpx_wait(ss, FRAME_SYNC) != 0) {
/*
* First load all Y scan registers with very short frame and
* wait for scroll service. This guarantees at least one SYNC
* to fix the pass 2 Adder initialization bug (synchronizes
* XCINCH with DMSEEDH)
*/
ss->ss_adder->y_scan_count_0 = 0x01;
ss->ss_adder->y_scan_count_1 = 0x01;
ss->ss_adder->y_scan_count_2 = 0x01;
ss->ss_adder->y_scan_count_3 = 0x01;
/* delay at least 1 full frame time */
gpx_wait(ss, FRAME_SYNC);
gpx_wait(ss, FRAME_SYNC);
/*
* now load the REAL sync values (in reverse order just to
* be safe).
*/
ss->ss_adder->y_scan_count_3 = 0x0388;
ss->ss_adder->y_scan_count_2 = 0x2366;
ss->ss_adder->y_scan_count_1 = 0x3363;
ss->ss_adder->y_scan_count_0 = 0x135f;
}
/* zero the index registers */
ss->ss_adder->x_index_pending = 0;
ss->ss_adder->y_index_pending = 0;
ss->ss_adder->x_index_new = 0;
ss->ss_adder->y_index_new = 0;
ss->ss_adder->x_index_old = 0;
ss->ss_adder->y_index_old = 0;
ss->ss_adder->pause = 0;
/* set rasterop mode to normal pen down */
ss->ss_adder->rasterop_mode =
DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL;
/* set the rasterop registers to default values */
ss->ss_adder->source_1_dx = 1;
ss->ss_adder->source_1_dy = 1;
ss->ss_adder->source_1_x = 0;
ss->ss_adder->source_1_y = 0;
ss->ss_adder->destination_x = 0;
ss->ss_adder->destination_y = 0;
ss->ss_adder->fast_dest_dx = 1;
ss->ss_adder->fast_dest_dy = 0;
ss->ss_adder->slow_dest_dx = 0;
ss->ss_adder->slow_dest_dy = 1;
ss->ss_adder->error_1 = 0;
ss->ss_adder->error_2 = 0;
/* scale factor = UNITY */
ss->ss_adder->fast_scale = UNITY;
ss->ss_adder->slow_scale = UNITY;
/* set the source 2 parameters */
ss->ss_adder->source_2_x = 0;
ss->ss_adder->source_2_y = 0;
ss->ss_adder->source_2_size = 0x0022;
/* initialize plane addresses for eight vipers */
for (i = 0; i < 8; i++) {
gpx_viper_write(ss, CS_UPDATE_MASK, 1 << i);
gpx_viper_write(ss, PLANE_ADDRESS, i);
}
/* initialize the external registers. */
gpx_viper_write(ss, CS_UPDATE_MASK, 0x00ff);
gpx_viper_write(ss, CS_SCROLL_MASK, 0x00ff);
/* initialize resolution mode */
gpx_viper_write(ss, MEMORY_BUS_WIDTH, 0x000c); /* bus width = 16 */
gpx_viper_write(ss, RESOLUTION_MODE, 0x0000); /* one bit/pixel */
/* initialize viper registers */
gpx_viper_write(ss, SCROLL_CONSTANT,
SCROLL_ENABLE | VIPER_LEFT | VIPER_UP);
gpx_viper_write(ss, SCROLL_FILL, 0x0000);
/* set clipping and scrolling limits to full screen */
gpx_wait(ss, ADDRESS_COMPLETE);
ss->ss_adder->x_clip_min = 0;
ss->ss_adder->x_clip_max = GPX_WIDTH;
ss->ss_adder->y_clip_min = 0;
ss->ss_adder->y_clip_max = GPX_HEIGHT;
ss->ss_adder->scroll_x_min = 0;
ss->ss_adder->scroll_x_max = GPX_WIDTH;
ss->ss_adder->scroll_y_min = 0;
ss->ss_adder->scroll_y_max = GPX_HEIGHT;
gpx_wait(ss, FRAME_SYNC); /* wait at LEAST 1 full frame */
gpx_wait(ss, FRAME_SYNC);
ss->ss_adder->x_index_pending = 0;
ss->ss_adder->y_index_pending = 0;
ss->ss_adder->x_index_new = 0;
ss->ss_adder->y_index_new = 0;
ss->ss_adder->x_index_old = 0;
ss->ss_adder->y_index_old = 0;
gpx_wait(ss, ADDRESS_COMPLETE);
gpx_viper_write(ss, LEFT_SCROLL_MASK, 0x0000);
gpx_viper_write(ss, RIGHT_SCROLL_MASK, 0x0000);
/* set source and the mask register to all ones */
gpx_viper_write(ss, SOURCE, 0xffff);
gpx_viper_write(ss, MASK_1, 0xffff);
gpx_viper_write(ss, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
gpx_viper_write(ss, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
/* initialize Operand Control Register banks for fill command */
gpx_viper_write(ss, SRC1_OCR_A,
EXT_NONE | INT_M1_M2 | NO_ID | WAIT);
gpx_viper_write(ss, SRC2_OCR_A,
EXT_NONE | INT_SOURCE | NO_ID | NO_WAIT);
gpx_viper_write(ss, DST_OCR_A,
EXT_NONE | INT_NONE | NO_ID | NO_WAIT);
gpx_viper_write(ss, SRC1_OCR_B,
EXT_NONE | INT_SOURCE | NO_ID | WAIT);
gpx_viper_write(ss, SRC2_OCR_B,
EXT_NONE | INT_M1_M2 | NO_ID | NO_WAIT);
gpx_viper_write(ss, DST_OCR_B,
EXT_NONE | INT_NONE | NO_ID | NO_WAIT);

/*
* Init Logic Unit Function registers.
*/
/* putchar */
gpx_viper_write(ss, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
/* erase{cols,rows} */
gpx_viper_write(ss, LU_FUNCTION_R2, FULL_SRC_RESOLUTION | LF_ZEROS);
/* underline */
gpx_viper_write(ss, LU_FUNCTION_R3, FULL_SRC_RESOLUTION | LF_ONES);
/* cursor */
gpx_viper_write(ss, LU_FUNCTION_R4, FULL_SRC_RESOLUTION | LF_NOT_D);
}

/* Clear the whole screen. Straight from qdss. */
static void
gpx_clear_screen(struct gpx_screen *ss)
{

ss->ss_adder->x_limit = GPX_WIDTH;
ss->ss_adder->y_limit = GPX_HEIGHT;
ss->ss_adder->y_offset_pending = 0;
gpx_wait(ss, FRAME_SYNC); /* wait at LEAST 1 full frame */
gpx_wait(ss, FRAME_SYNC);
ss->ss_adder->y_scroll_constant = SCROLL_ERASE;
gpx_wait(ss, FRAME_SYNC);
gpx_wait(ss, FRAME_SYNC);
ss->ss_adder->y_offset_pending = GPX_VISHEIGHT;
gpx_wait(ss, FRAME_SYNC);
gpx_wait(ss, FRAME_SYNC);
ss->ss_adder->y_scroll_constant = SCROLL_ERASE;
gpx_wait(ss, FRAME_SYNC);
gpx_wait(ss, FRAME_SYNC);
ss->ss_adder->y_offset_pending = 2 * GPX_VISHEIGHT;
gpx_wait(ss, FRAME_SYNC);
gpx_wait(ss, FRAME_SYNC);
ss->ss_adder->y_scroll_constant = SCROLL_ERASE;
gpx_wait(ss, FRAME_SYNC);
gpx_wait(ss, FRAME_SYNC);
ss->ss_adder->y_offset_pending = 0; /* back to normal */
gpx_wait(ss, FRAME_SYNC);
gpx_wait(ss, FRAME_SYNC);
ss->ss_adder->x_limit = GPX_WIDTH;
ss->ss_adder->y_limit = GPX_VISHEIGHT;
}

static int
gpx_setup_screen(struct gpx_screen *ss)
{
struct rasops_info *ri = &ss->ss_ri;
int cookie;

memset(ri, 0, sizeof(*ri));
ri->ri_depth = 8; /* masquerade as a 8 bit device for rasops */
ri->ri_width = GPX_WIDTH;
ri->ri_height = GPX_VISHEIGHT;
ri->ri_stride = GPX_WIDTH;
ri->ri_flg = RI_CENTER; /* no RI_CLEAR as ri_bits is NULL! */
ri->ri_hw = ss;
if (ss == &gpx_consscr)
ri->ri_flg |= RI_NO_AUTO;

/*
* We can not let rasops select our font, because we need to use
* a font with right-to-left bit order on this frame buffer.
*/
wsfont_init();
cookie = wsfont_find(NULL, 12, 0, 0, WSDISPLAY_FONTORDER_R2L,
WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP);
if (cookie < 0)
cookie = wsfont_find(NULL, 8, 0, 0, WSDISPLAY_FONTORDER_R2L,
WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP);
if (cookie < 0)
cookie = wsfont_find(NULL, 0, 0, 0, WSDISPLAY_FONTORDER_R2L,
WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP);
if (cookie < 0)
return -1;
if (wsfont_lock(cookie, &ri->ri_font) != 0)
return -1;
ri->ri_wsfcookie = cookie;

/*
* Ask for an unholy big display, rasops will trim this to more
* reasonable values.
*/
if (rasops_init(ri, 160, 160) != 0)
return -1;

/*
* Override the rasops emulops.
*/
ri->ri_ops.copyrows = gpx_copyrows;
ri->ri_ops.copycols = gpx_copycols;
ri->ri_ops.eraserows = gpx_eraserows;
ri->ri_ops.erasecols = gpx_erasecols;
ri->ri_ops.putchar = gpx_putchar;
ri->ri_do_cursor = gpx_do_cursor;

gpx_stdscreen.ncols = ri->ri_cols;
gpx_stdscreen.nrows = ri->ri_rows;
gpx_stdscreen.textops = &ri->ri_ops;
gpx_stdscreen.fontwidth = ri->ri_font->fontwidth;
gpx_stdscreen.fontheight = ri->ri_font->fontheight;
gpx_stdscreen.capabilities = ri->ri_caps;

/*
* Initialize RAMDAC.
*/
if (ss->ss_depth == 8) {
struct ramdac8 *rd = ss->ss_vdac;
rd->address = BT_CR;
rd->control = BTCR_RAMENA | BTCR_BLINK_1648 | BTCR_MPLX_4;
} else {
struct ramdac4 *rd = ss->ss_vdac;
rd->control = RAMDAC4_INIT;
}

/*
* Put the ADDER and VIPER in a good state.
*/
gpx_reset_viper(ss);

/*
* Initialize colormap.
*/
gpx_resetcmap(ss);

/*
* Clear display (including non-visible area), in 864 lines chunks.
*/
gpx_clear_screen(ss);

/*
* Copy our font to the offscreen area.
*/
gpx_upload_font(ss);

#if 0
ss->ss_cursor->cmdr = ss->ss_curcmd = PCCCMD_HSHI;
#endif

return 0;
}

/*
* Copy the selected wsfont to non-visible frame buffer area.
* This is necessary since the only way to send data to the frame buffer
* is through the ID interface, which is slow and needs 16 bit wide data.
* Adapted from qdss.
*/
static void
gpx_upload_font(struct gpx_screen *ss)
{
struct rasops_info *ri = &ss->ss_ri;
struct wsdisplay_font *font = ri->ri_font;
uint8_t *fontbits, *fb;
u_int remaining, nchars, row;
u_int i, j;
uint16_t data;

/* setup VIPER operand control registers */

gpx_viper_write(ss, MASK_1, 0xffff);
gpx_viper_write(ss, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
gpx_viper_write(ss, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);

gpx_viper_write(ss, SRC1_OCR_B,
EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
gpx_viper_write(ss, SRC2_OCR_B,
EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
gpx_viper_write(ss, DST_OCR_B,
EXT_SOURCE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);

ss->ss_adder->rasterop_mode =
DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL;
gpx_wait(ss, RASTEROP_COMPLETE);

/*
* Load font data. The font is uploaded in 8 or 16 bit wide cells, on
* as many ``lines'' as necessary at the end of the display.
*/
ss->ss_gpr = MIN(GPX_WIDTH / (NBBY * font->stride), font->numchars);
if ((ss->ss_gpr & 1) != 0)
ss->ss_gpr--;
fontbits = font->data;
for (row = 1, remaining = font->numchars; remaining != 0;
row++, remaining -= nchars) {
nchars = MIN(ss->ss_gpr, remaining);

ss->ss_adder->destination_x = 0;
ss->ss_adder->destination_y =
GPX_HEIGHT - row * font->fontheight;
ss->ss_adder->fast_dest_dx = nchars * 16;
ss->ss_adder->slow_dest_dy = font->fontheight;

/* setup for processor to bitmap xfer */
gpx_viper_write(ss, CS_UPDATE_MASK, 0x00ff);
ss->ss_adder->cmd = PBT | OCRB | DTE | LF_R1 | 2; /*XXX why 2?*/

/* iteratively do the processor to bitmap xfer */
for (i = font->fontheight; i != 0; i--) {
fb = fontbits;
fontbits += font->stride;
/* PTOB a scan line */
for (j = nchars; j != 0; j--) {
/* PTOB one scan of a char cell */
if (font->stride == 1) {
data = *fb;
fb += font->fontheight;
/*
* Do not access past font memory if
* it has an odd number of characters
* and this is the last pair.
*/
if (j != 1 || (nchars & 1) == 0 ||
remaining != nchars) {
data |= ((uint16_t)*fb) << 8;
fb += font->fontheight;
}
} else {
data =
fb[0] | (((uint16_t)fb[1]) << 8);
fb += font->fontheight * font->stride;
}

gpx_wait(ss, TX_READY);
ss->ss_adder->id_data = data;
}
}
fontbits += (nchars - 1) * font->stride * font->fontheight;
}
}

static void
gpx_copyrect(struct gpx_screen *ss,
int sx, int sy, int dx, int dy, int w, int h)
{

while (gpx_viper_write(ss, CS_UPDATE_MASK, 0x00ff))
continue;
gpx_viper_write(ss, MASK_1, 0xffff);
gpx_viper_write(ss, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
gpx_viper_write(ss, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
gpx_viper_write(ss, SRC1_OCR_B,
EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
gpx_viper_write(ss, DST_OCR_B,
EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
ss->ss_adder->fast_dest_dy = 0;
ss->ss_adder->slow_dest_dx = 0;
ss->ss_adder->error_1 = 0;
ss->ss_adder->error_2 = 0;
ss->ss_adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
gpx_wait(ss, RASTEROP_COMPLETE);
ss->ss_adder->destination_x = dx;
ss->ss_adder->fast_dest_dx = w;
ss->ss_adder->destination_y = dy;
ss->ss_adder->slow_dest_dy = h;
ss->ss_adder->source_1_x = sx;
ss->ss_adder->source_1_dx = w;
ss->ss_adder->source_1_y = sy;
ss->ss_adder->source_1_dy = h;
ss->ss_adder->cmd = RASTEROP | OCRB | S1E | DTE | LF_R1;
}

/*
* Fill a rectangle with the given attribute and function (i.e. rop).
*/
static void
gpx_fillrect(struct gpx_screen *ss, int x, int y, int dx, int dy, long attr,
u_int function)
{
int fg, bg;

rasops_unpack_attr(attr, &fg, &bg, NULL);

while (gpx_viper_write(ss, CS_UPDATE_MASK, 0x00ff))
continue;
gpx_viper_write(ss, MASK_1, 0xffff);
gpx_viper_write(ss, SOURCE, 0xffff);
gpx_viper_write(ss, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, fg);
gpx_viper_write(ss, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, bg);
gpx_viper_write(ss, SRC1_OCR_B,
EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
gpx_viper_write(ss, DST_OCR_B,
EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
ss->ss_adder->fast_dest_dx = 0;
ss->ss_adder->fast_dest_dy = 0;
ss->ss_adder->slow_dest_dx = 0;
ss->ss_adder->error_1 = 0;
ss->ss_adder->error_2 = 0;
ss->ss_adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
gpx_wait(ss, RASTEROP_COMPLETE);
ss->ss_adder->destination_x = x;
ss->ss_adder->fast_dest_dx = dx;
ss->ss_adder->destination_y = y;
ss->ss_adder->slow_dest_dy = dy;
ss->ss_adder->source_1_x = x;
ss->ss_adder->source_1_dx = dx;
ss->ss_adder->source_1_y = y;
ss->ss_adder->source_1_dy = dy;
ss->ss_adder->cmd = RASTEROP | OCRB | S1E | DTE | function;
}

/*
* Colormap handling routines
*/

static int
gpx_getcmap(struct gpx_screen *ss, struct wsdisplay_cmap *cm)
{
u_int index = cm->index, count = cm->count, i;
u_int colcount = 1 << ss->ss_depth;
int error;
uint8_t ramp[256], *c, *r;

if (index >= colcount || count > colcount - index)
return EINVAL;

if (count == 0)
return 0;

/* extract reds */
c = ss->ss_cmap + 0 + index * 3;
for (i = count, r = ramp; i != 0; i--)
*r++ = *c << (8 - ss->ss_depth), c += 3;
if ((error = copyout(ramp, cm->red, count)) != 0)
return error;

/* extract greens */
c = ss->ss_cmap + 1 + index * 3;
for (i = count, r = ramp; i != 0; i--)
*r++ = *c << (8 - ss->ss_depth), c += 3;
if ((error = copyout(ramp, cm->green, count)) != 0)
return error;

/* extract blues */
c = ss->ss_cmap + 2 + index * 3;
for (i = count, r = ramp; i != 0; i--)
*r++ = *c << (8 - ss->ss_depth), c += 3;
if ((error = copyout(ramp, cm->blue, count)) != 0)
return error;

return 0;
}

static int
gpx_putcmap(struct gpx_screen *ss, struct wsdisplay_cmap *cm)
{
u_int index = cm->index, count = cm->count;
u_int colcount = 1 << ss->ss_depth;
int i, error;
uint8_t r[256], g[256], b[256], *nr, *ng, *nb, *c;

if (index >= colcount || count > colcount - index)
return EINVAL;

if ((error = copyin(cm->red, r, count)) != 0)
return error;
if ((error = copyin(cm->green, g, count)) != 0)
return error;
if ((error = copyin(cm->blue, b, count)) != 0)
return error;

nr = r, ng = g, nb = b;
c = ss->ss_cmap + index * 3;
for (i = count; i != 0; i--) {
*c++ = *nr++ >> (8 - ss->ss_depth);
*c++ = *ng++ >> (8 - ss->ss_depth);
*c++ = *nb++ >> (8 - ss->ss_depth);
}

return 0;
}

static void
gpx_loadcmap(struct gpx_screen *ss, int from, int count)
{
uint8_t *cmap = ss->ss_cmap;
int i, color12;

gpx_wait(ss, FRAME_SYNC);
if (ss->ss_depth == 8) {
struct ramdac8 *rd = ss->ss_vdac;

cmap += from * 3;
rd->address = from;
for (i = 0; i < count * 3; i++)
rd->cmapdata = *cmap++;
} else {
struct ramdac4 *rd = ss->ss_vdac;

cmap = ss->ss_cmap + from;
for (i = from; i < from + count; i++) {
color12 = (*cmap++ >> 4) << 0;
color12 |= (*cmap++ >> 4) << 8;
color12 |= (*cmap++ >> 4) << 4;
rd->colormap[i] = color12;
}
}
}

static void
gpx_resetcmap(struct gpx_screen *ss)
{

if (ss->ss_depth == 8)
memcpy(ss->ss_cmap, rasops_cmap, sizeof(ss->ss_cmap));
else {
memcpy(ss->ss_cmap, rasops_cmap, 8 * 3);
memcpy(ss->ss_cmap + 8 * 3, rasops_cmap + 0xf8 * 3, 8 * 3);
}
gpx_loadcmap(ss, 0, 1 << ss->ss_depth);

/*
* On the 4bit RAMDAC, make the hardware cursor black on black
*/
if (ss->ss_depth != 8) {
struct ramdac4 *rd = ss->ss_vdac;

rd->cursormap[0] = rd->cursormap[1] =
rd->cursormap[2] = rd->cursormap[3] = 0x0000;
}
}

/*
* Console support code
*/

cons_decl(gpx);

/*
* Called very early to setup the glass tty as console.
* Because it's called before the VM system is initialized, virtual memory
* for the framebuffer can be stolen directly without disturbing anything.
*/
void
gpxcnprobe(struct consdev *cndev)
{
extern vaddr_t virtual_avail;
extern const struct cdevsw wsdisplay_cdevsw;
volatile struct adder *adder;
vaddr_t tmp;
int depth;
u_short status;

switch (vax_boardtype) {
case VAX_BTYP_410:
case VAX_BTYP_420:
case VAX_BTYP_43:
if ((vax_confdata & (KA420_CFG_L3CON | KA420_CFG_MULTU)) != 0)
break; /* doesn't use graphics console */

if ((vax_confdata & KA420_CFG_VIDOPT) == 0)
break; /* no color option */

/* Check for hardware */
tmp = virtual_avail;
ioaccess(tmp, vax_trunc_page(GPXADDR + GPX_ADDER_OFFSET), 1);
adder = (struct adder *)tmp;
adder->status = 0;
status = adder->status;
iounaccess(tmp, 1);
if (status == offsetof(struct adder, status))
return;

/* Check for a recognized color depth */
tmp = virtual_avail;
ioaccess(tmp, vax_trunc_page(GPXADDR + GPX_READBACK_OFFSET), 1);
depth = *(uint16_t *)
(tmp + (GPX_READBACK_OFFSET & VAX_PGOFSET)) & 0x00f0;
iounaccess(tmp, 1);
if (depth != 0x00f0 && depth != 0x0080)
return;

cndev->cn_pri = CN_INTERNAL;
cndev->cn_dev =
makedev(cdevsw_lookup_major(&wsdisplay_cdevsw), 0);
break;

default:
break;
}
}

/*
* Called very early to setup the glass tty as console.
* Because it's called before the VM system is initialized, virtual memory
* for the framebuffer can be stolen directly without disturbing anything.
*/
void
gpxcninit(struct consdev *cndev)
{
struct gpx_screen *ss = &gpx_consscr;
extern vaddr_t virtual_avail;
vaddr_t ova;
long defattr;
struct rasops_info *ri;

ova = virtual_avail;

ioaccess(virtual_avail,
vax_trunc_page(GPXADDR + GPX_READBACK_OFFSET), 1);
ss->ss_depth = (0x00f0 & *(uint16_t *)(virtual_avail +
(GPX_READBACK_OFFSET & VAX_PGOFSET))) == 0x00f0 ? 4 : 8;

ioaccess(virtual_avail, GPXADDR + GPX_ADDER_OFFSET, 1);
ss->ss_adder = (struct adder *)virtual_avail;
virtual_avail += VAX_NBPG;

ioaccess(virtual_avail, vax_trunc_page(GPXADDR + GPX_VDAC_OFFSET), 1);
ss->ss_vdac = (void *)(virtual_avail + (GPX_VDAC_OFFSET & VAX_PGOFSET));
virtual_avail += VAX_NBPG;

#if 0
ioaccess(virtual_avail, GPXADDR + GPX_CURSOR_OFFSET, 1);
ss->ss_cursor = (struct dc503reg *)virtual_avail;
virtual_avail += VAX_NBPG;
#endif

virtual_avail = round_page(virtual_avail);

/* this had better not fail */
if (gpx_setup_screen(ss) != 0) {
#if 0
iounaccess((vaddr_t)ss->ss_cursor, 1);
#endif
iounaccess((vaddr_t)ss->ss_vdac, 1);
iounaccess((vaddr_t)ss->ss_adder, 1);
virtual_avail = ova;
return;
}

ri = &ss->ss_ri;
ri->ri_ops.allocattr(ri, 0, 0, 0, &defattr);
wsdisplay_cnattach(&gpx_stdscreen, ri, 0, 0, defattr);
cn_tab->cn_pri = CN_INTERNAL;

#if NDZKBD > 0
dzkbd_cnattach(0); /* Connect keyboard and screen together */
#endif
}