* Copyright (c) 2002, 2003 Valeriy E. Ushakov

/* $NetBSD: igsfb.c,v 1.60 2021/08/07 16:19:12 thorpej Exp $ */

/*
* Copyright (c) 2002, 2003 Valeriy E. Ushakov
* 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. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/

/*
* Integraphics Systems IGA 168x and CyberPro series.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: igsfb.c,v 1.60 2021/08/07 16:19:12 thorpej Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <sys/ioctl.h>

#include <sys/bus.h>

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

#include <dev/wscons/wsdisplay_vconsvar.h>

#include <dev/ic/igsfbreg.h>
#include <dev/ic/igsfbvar.h>

struct igsfb_devconfig igsfb_console_dc = {
.dc_mmap = NULL,
.dc_modestring = "",
};

/*
* wsscreen
*/

/* filled from rasops_info in igsfb_init_wsdisplay */
static struct wsscreen_descr igsfb_stdscreen = {
.name = "std",
};

static const struct wsscreen_descr *_igsfb_scrlist[] = {
&igsfb_stdscreen,
};

static const struct wsscreen_list igsfb_screenlist = {
.nscreens = sizeof(_igsfb_scrlist) / sizeof(_igsfb_scrlist[0]),
.screens = _igsfb_scrlist,
};

/*
* wsdisplay_accessops
*/

static int igsfb_ioctl(void *, void *, u_long, void *, int, struct lwp *);
static paddr_t igsfb_mmap(void *, void *, off_t, int);

static struct wsdisplay_accessops igsfb_accessops = {
.ioctl = igsfb_ioctl,
.mmap = igsfb_mmap,
};

/*
* acceleration
*/
static int igsfb_make_text_cursor(struct igsfb_devconfig *,
struct vcons_screen *);
static void igsfb_accel_cursor(void *, int, int, int);

static int igsfb_accel_wait(struct igsfb_devconfig *);
static void igsfb_accel_fill(struct igsfb_devconfig *,
uint32_t, uint32_t, uint16_t, uint16_t);
static void igsfb_accel_copy(struct igsfb_devconfig *,
uint32_t, uint32_t, uint16_t, uint16_t);

static void igsfb_accel_copycols(void *, int, int, int, int);
static void igsfb_accel_erasecols(void *, int, int, int, long);
static void igsfb_accel_copyrows(void *, int, int, int);
static void igsfb_accel_eraserows(void *, int, int, long);
static void igsfb_accel_putchar(void *, int, int, u_int, long);

/*
* internal functions
*/
static int igsfb_init_video(struct igsfb_devconfig *);
static void igsfb_init_cmap(struct igsfb_devconfig *);
static uint16_t igsfb_spread_bits_8(uint8_t);
static void igsfb_init_bit_table(struct igsfb_devconfig *);
static void igsfb_init_wsdisplay(void *, struct vcons_screen *, int,
long *);

static void igsfb_blank_screen(struct igsfb_devconfig *, int);
static int igsfb_get_cmap(struct igsfb_devconfig *,
struct wsdisplay_cmap *);
static int igsfb_set_cmap(struct igsfb_devconfig *,
const struct wsdisplay_cmap *);
static void igsfb_update_cmap(struct igsfb_devconfig *, u_int, u_int);
static void igsfb_set_curpos(struct igsfb_devconfig *,
const struct wsdisplay_curpos *);
static void igsfb_update_curpos(struct igsfb_devconfig *);
static int igsfb_get_cursor(struct igsfb_devconfig *,
struct wsdisplay_cursor *);
static int igsfb_set_cursor(struct igsfb_devconfig *,
const struct wsdisplay_cursor *);
static void igsfb_update_cursor(struct igsfb_devconfig *, u_int);
static void igsfb_convert_cursor_data(struct igsfb_devconfig *,
u_int, u_int);

int
igsfb_cnattach_subr(struct igsfb_devconfig *dc)
{
struct rasops_info *ri;
long defattr;

KASSERT(dc == &igsfb_console_dc);

igsfb_init_video(dc);
dc->dc_vd.active = NULL;
igsfb_init_wsdisplay(dc, &dc->dc_console, 1, &defattr);

ri = &dc->dc_console.scr_ri;
ri->ri_hw = &dc->dc_console;
dc->dc_console.scr_cookie = dc;

(*ri->ri_ops.allocattr)(ri,
WS_DEFAULT_FG, /* fg */
WS_DEFAULT_BG, /* bg */
0, /* wsattrs */
&defattr);

wsdisplay_cnattach(&igsfb_stdscreen,
ri, /* emulcookie */
0, 0, /* cursor position */
defattr);
return 0;
}

/*
* Finish off the attach. Bus specific attach method should have
* enabled io and memory accesses and mapped io (and cop?) registers.
*/
void
igsfb_attach_subr(struct igsfb_softc *sc, int isconsole)
{
struct igsfb_devconfig *dc = sc->sc_dc;
struct wsemuldisplaydev_attach_args waa;
struct rasops_info *ri;
long defattr;

KASSERT(dc != NULL);

if (!isconsole) {
igsfb_init_video(dc);
}

vcons_init(&dc->dc_vd, dc, &igsfb_stdscreen, &igsfb_accessops);
dc->dc_vd.init_screen = igsfb_init_wsdisplay;

vcons_init_screen(&dc->dc_vd, &dc->dc_console, 1, &defattr);
dc->dc_console.scr_flags |= VCONS_SCREEN_IS_STATIC;

aprint_normal("%s: %dMB, %s%dx%d, %dbpp\n",
device_xname(sc->sc_dev),
(uint32_t)(dc->dc_vmemsz >> 20),
(dc->dc_hwflags & IGSFB_HW_BSWAP)
? (dc->dc_hwflags & IGSFB_HW_BE_SELECT)
? "hardware bswap, " : "software bswap, "
: "",
dc->dc_width, dc->dc_height, dc->dc_depth);
aprint_normal("%s: using %dbpp for X\n", device_xname(sc->sc_dev),
dc->dc_maxdepth);
ri = &dc->dc_console.scr_ri;
ri->ri_ops.eraserows(ri, 0, ri->ri_rows, defattr);

if (isconsole)
vcons_replay_msgbuf(&dc->dc_console);

/* attach wsdisplay */
waa.console = isconsole;
waa.scrdata = &igsfb_screenlist;
waa.accessops = &igsfb_accessops;
waa.accesscookie = &dc->dc_vd;

config_found(sc->sc_dev, &waa, wsemuldisplaydevprint, CFARGS_NONE);
}

static int
igsfb_init_video(struct igsfb_devconfig *dc)
{
bus_space_handle_t tmph;
uint8_t *p;
int need_bswap;
bus_addr_t fbaddr, craddr;
off_t croffset;
uint8_t busctl, curctl;
void *va;

/* Total amount of video memory. */
busctl = igs_ext_read(dc->dc_iot, dc->dc_ioh, IGS_EXT_BUS_CTL);
if (busctl & 0x2)
dc->dc_vmemsz = 4;
else if (busctl & 0x1)
dc->dc_vmemsz = 2;
else
dc->dc_vmemsz = 1;
dc->dc_vmemsz <<= 20; /* megabytes -> bytes */

/*
* Check for endianness mismatch by writing a word at the end of
* the video memory (off-screen) and reading it back byte-by-byte.
*/
if (bus_space_map(dc->dc_memt,
dc->dc_memaddr + dc->dc_vmemsz - sizeof(uint32_t),
sizeof(uint32_t),
dc->dc_memflags | BUS_SPACE_MAP_LINEAR,
&tmph) != 0)
{
printf("unable to map video memory for endianness test\n");
return 1;
}

p = bus_space_vaddr(dc->dc_memt, tmph);
#if BYTE_ORDER == BIG_ENDIAN
*((uint32_t *)p) = 0x12345678;
#else
*((uint32_t *)p) = 0x78563412;
#endif
if (p[0] == 0x12 && p[1] == 0x34 && p[2] == 0x56 && p[3] == 0x78)
need_bswap = 0;
else
need_bswap = 1;

bus_space_unmap(dc->dc_memt, tmph, sizeof(uint32_t));

/*
* On CyberPro we can use magic bswap bit in linear address.
*/
fbaddr = dc->dc_memaddr;
if (need_bswap) {
dc->dc_hwflags |= IGSFB_HW_BSWAP;
if (dc->dc_id >= 0x2000) {
dc->dc_hwflags |= IGSFB_HW_BE_SELECT;
fbaddr |= IGS_MEM_BE_SELECT;
}
}

/*
* Map graphic coprocessor for mode setting and accelerated rasops.
*/
if (dc->dc_id >= 0x2000) { /* XXX */
if (bus_space_map(dc->dc_iot,
dc->dc_iobase + IGS_COP_BASE_B, IGS_COP_SIZE,
dc->dc_ioflags,
&dc->dc_coph) != 0)
{
printf("unable to map COP registers\n");
return 1;
}
}

igsfb_hw_setup(dc);

/*
* Don't map in all N megs, just the amount we need for the wsscreen.
*/
dc->dc_fbsz = dc->dc_stride * dc->dc_height;
if (bus_space_map(dc->dc_memt, fbaddr, dc->dc_fbsz,
dc->dc_memflags | BUS_SPACE_MAP_LINEAR,
&dc->dc_fbh) != 0)
{
if (dc->dc_id >= 0x2000) { /* XXX */
bus_space_unmap(dc->dc_iot, dc->dc_coph, IGS_COP_SIZE);
}
bus_space_unmap(dc->dc_iot, dc->dc_ioh, IGS_REG_SIZE);
printf("unable to map framebuffer\n");
return 1;
}

igsfb_init_cmap(dc);

/*
* 1KB for cursor sprite data at the very end of the video memory.
*/
croffset = dc->dc_vmemsz - IGS_CURSOR_DATA_SIZE;
craddr = fbaddr + croffset;
if (bus_space_map(dc->dc_memt, craddr, IGS_CURSOR_DATA_SIZE,
dc->dc_memflags | BUS_SPACE_MAP_LINEAR,
&dc->dc_crh) != 0)
{
if (dc->dc_id >= 0x2000) { /* XXX */
bus_space_unmap(dc->dc_iot, dc->dc_coph, IGS_COP_SIZE);
}
bus_space_unmap(dc->dc_iot, dc->dc_ioh, IGS_REG_SIZE);
bus_space_unmap(dc->dc_memt, dc->dc_fbh, dc->dc_fbsz);
printf("unable to map cursor sprite region\n");
return 1;
}

/*
* Tell the device where cursor sprite data are located in the
* linear space (it takes data offset in 1KB units).
*/
croffset >>= 10; /* bytes -> kilobytes */
igs_ext_write(dc->dc_iot, dc->dc_ioh,
IGS_EXT_SPRITE_DATA_LO, croffset & 0xff);
igs_ext_write(dc->dc_iot, dc->dc_ioh,
IGS_EXT_SPRITE_DATA_HI, (croffset >> 8) & 0xf);

/* init the bit expansion table for cursor sprite data conversion */
igsfb_init_bit_table(dc);

/* XXX: fill dc_cursor and use igsfb_update_cursor() instead? */
memset(&dc->dc_cursor, 0, sizeof(struct igs_hwcursor));
va = bus_space_vaddr(dc->dc_memt, dc->dc_crh);
memset(va, /* transparent */ 0xaa, IGS_CURSOR_DATA_SIZE);

curctl = igs_ext_read(dc->dc_iot, dc->dc_ioh, IGS_EXT_SPRITE_CTL);
curctl |= IGS_EXT_SPRITE_64x64;
curctl &= ~IGS_EXT_SPRITE_VISIBLE;
igs_ext_write(dc->dc_iot, dc->dc_ioh, IGS_EXT_SPRITE_CTL, curctl);
dc->dc_curenb = 0;

/*
* Init graphic coprocessor for accelerated rasops.
*/
if (dc->dc_id >= 0x2000) { /* XXX */
bus_space_write_2(dc->dc_iot, dc->dc_coph,
IGS_COP_SRC_MAP_WIDTH_REG,
dc->dc_width - 1);
bus_space_write_2(dc->dc_iot, dc->dc_coph,
IGS_COP_DST_MAP_WIDTH_REG,
dc->dc_width - 1);

bus_space_write_1(dc->dc_iot, dc->dc_coph,
IGS_COP_MAP_FMT_REG,
howmany(dc->dc_depth, NBBY) - 1);
}

/* make sure screen is not blanked */
dc->dc_blanked = 0;
igsfb_blank_screen(dc, dc->dc_blanked);

return 0;
}

static void
igsfb_init_cmap(struct igsfb_devconfig *dc)
{
bus_space_tag_t iot = dc->dc_iot;
bus_space_handle_t ioh = dc->dc_ioh;
const uint8_t *p;
int i;

p = rasops_cmap; /* "ANSI" color map */

/* init software copy */
for (i = 0; i < IGS_CMAP_SIZE; ++i, p += 3) {
dc->dc_cmap.r[i] = p[0];
dc->dc_cmap.g[i] = p[1];
dc->dc_cmap.b[i] = p[2];
}

/* propagate to the device */
igsfb_update_cmap(dc, 0, IGS_CMAP_SIZE);

/* set overscan color */
p = &rasops_cmap[WSDISPLAY_BORDER_COLOR * 3];
igs_ext_write(iot, ioh, IGS_EXT_OVERSCAN_RED, p[0]);
igs_ext_write(iot, ioh, IGS_EXT_OVERSCAN_GREEN, p[1]);
igs_ext_write(iot, ioh, IGS_EXT_OVERSCAN_BLUE, p[2]);
}

static void
igsfb_init_wsdisplay(void *cookie, struct vcons_screen *scr, int existing,
long *defattr)
{
struct igsfb_devconfig *dc = cookie;
struct rasops_info *ri = &scr->scr_ri;
int wsfcookie;

if (scr == &dc->dc_console) {
if (ri->ri_flg == 0) {
/* first time, need to set RI_NO_AUTO */
ri->ri_flg |= RI_NO_AUTO;
} else {
/* clear it on 2nd run */
ri->ri_flg &= ~RI_NO_AUTO;
}
}
ri->ri_flg |= RI_CENTER | RI_FULLCLEAR;

if (IGSFB_HW_SOFT_BSWAP(dc))
ri->ri_flg |= RI_BSWAP;

ri->ri_depth = dc->dc_depth;
ri->ri_width = dc->dc_width;
ri->ri_height = dc->dc_height;
ri->ri_stride = dc->dc_stride;
ri->ri_bits = bus_space_vaddr(dc->dc_memt, dc->dc_fbh);

/*
* Initialize wsfont related stuff.
*/
wsfont_init();

/* prefer gallant that is identical to the one the prom uses */
wsfcookie = wsfont_find("Gallant", 12, 22, 0,
WSDISPLAY_FONTORDER_L2R,
WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP);
if (wsfcookie <= 0) {
#ifdef DIAGNOSTIC
printf("unable to find font Gallant 12x22\n");
#endif
wsfcookie = wsfont_find(NULL, 0, 0, 0, /* any font at all? */
WSDISPLAY_FONTORDER_L2R,
WSDISPLAY_FONTORDER_L2R,
WSFONT_FIND_BITMAP);
}

if (wsfcookie <= 0) {
printf("unable to find any fonts\n");
return;
}

if (wsfont_lock(wsfcookie, &ri->ri_font) != 0) {
printf("unable to lock font\n");
return;
}
ri->ri_wsfcookie = wsfcookie;

/* XXX: TODO: compute term size based on font dimensions? */
rasops_init(ri, 0, 0);
rasops_reconfig(ri, ri->ri_height / ri->ri_font->fontheight,
ri->ri_width / ri->ri_font->fontwidth);

/* use the sprite for the text mode cursor */
igsfb_make_text_cursor(dc, scr);

/* the cursor is "busy" while we are in the text mode */
dc->dc_hwflags |= IGSFB_HW_TEXT_CURSOR;

/* propagate sprite data to the device */
igsfb_update_cursor(dc, WSDISPLAY_CURSOR_DOSHAPE);

/* accelerated text cursor */
ri->ri_ops.cursor = igsfb_accel_cursor;

if (dc->dc_id >= 0x2000) { /* XXX */
/* accelerated erase/copy */
ri->ri_ops.copycols = igsfb_accel_copycols;
ri->ri_ops.erasecols = igsfb_accel_erasecols;
ri->ri_ops.copyrows = igsfb_accel_copyrows;
ri->ri_ops.eraserows = igsfb_accel_eraserows;

/* putchar hook to sync with the cop */
dc->dc_ri_putchar = ri->ri_ops.putchar;
ri->ri_ops.putchar = igsfb_accel_putchar;
}

igsfb_stdscreen.nrows = ri->ri_rows;
igsfb_stdscreen.ncols = ri->ri_cols;
igsfb_stdscreen.textops = &ri->ri_ops;
igsfb_stdscreen.capabilities = ri->ri_caps;
}

/*
* Init cursor data in dc_cursor for the accelerated text cursor.
*/
static int
igsfb_make_text_cursor(struct igsfb_devconfig *dc, struct vcons_screen *scr)
{
struct rasops_info *ri = &scr->scr_ri;
struct wsdisplay_font *f = ri->ri_font;
uint16_t cc_scan[8]; /* one sprite scanline */
uint16_t s;
int w, i;

KASSERT(f->fontwidth <= IGS_CURSOR_MAX_SIZE);
KASSERT(f->fontheight <= IGS_CURSOR_MAX_SIZE);

w = f->fontwidth;
for (i = 0; i < f->stride; ++i) {
if (w >= 8) {
s = 0xffff; /* all inverted */
w -= 8;
} else {
/* first w pixels inverted, the rest is transparent */
s = ~(0x5555 << (w * 2));
s = htole16(s);
w = 0;
}
cc_scan[i] = s;
}

dc->dc_cursor.cc_size.x = f->fontwidth;
dc->dc_cursor.cc_size.y = f->fontheight;

dc->dc_cursor.cc_hot.x = 0;
dc->dc_cursor.cc_hot.y = 0;

/* init sprite array to be all transparent */
memset(dc->dc_cursor.cc_sprite, 0xaa, IGS_CURSOR_DATA_SIZE);

for (i = 0; i < f->fontheight; ++i)
memcpy(&dc->dc_cursor.cc_sprite[i * 8],
cc_scan, f->stride * sizeof(uint16_t));

return 0;
}

/*
* Spread a byte (abcd.efgh) into two (0a0b.0c0d 0e0f.0g0h).
* Helper function for igsfb_init_bit_table().
*/
static uint16_t
igsfb_spread_bits_8(uint8_t b)
{
uint16_t s = b;

s = ((s & 0x00f0) << 4) | (s & 0x000f);
s = ((s & 0x0c0c) << 2) | (s & 0x0303);
s = ((s & 0x2222) << 1) | (s & 0x1111);
return s;
}

/*
* Cursor sprite data are in 2bpp. Incoming image/mask are in 1bpp.
* Prebuild the table to expand 1bpp->2bpp, with bswapping if necessary.
*/
static void
igsfb_init_bit_table(struct igsfb_devconfig *dc)
{
uint16_t *expand = dc->dc_bexpand;
uint16_t s;
u_int i;

for (i = 0; i < 256; ++i) {
s = igsfb_spread_bits_8(i);
expand[i] = htole16(s);
}
}

/*
* wsdisplay_accessops: mmap()
* XXX: security considerations for allowing mmapping i/o mapped i/o regs?
*/
static paddr_t
igsfb_mmap(void *v, void *vs, off_t offset, int prot)
{
struct vcons_data *vd = v;
struct igsfb_devconfig *dc = vd->cookie;

if (offset < dc->dc_memsz && offset >= 0)
return bus_space_mmap(dc->dc_memt, dc->dc_memaddr, offset,
prot, dc->dc_memflags | BUS_SPACE_MAP_LINEAR);
if (dc->dc_mmap)
return dc->dc_mmap(v, vs, offset, prot);
return -1;
}

/*
* wsdisplay_accessops: ioctl()
*/
static int
igsfb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag,
struct lwp *l)
{
struct vcons_data *vd = v;
struct igsfb_devconfig *dc = vd->cookie;
int cursor_busy;
int turnoff;

/* don't permit cursor ioctls if we use sprite for text cursor */
cursor_busy = !dc->dc_mapped
&& (dc->dc_hwflags & IGSFB_HW_TEXT_CURSOR);

switch (cmd) {

case WSDISPLAYIO_GTYPE:
*(u_int *)data = WSDISPLAY_TYPE_PCIMISC;
return 0;

case WSDISPLAYIO_GINFO:
#define wsd_fbip ((struct wsdisplay_fbinfo *)data)
wsd_fbip->height = dc->dc_height;
wsd_fbip->width = dc->dc_width;
wsd_fbip->depth = dc->dc_maxdepth;
wsd_fbip->cmsize = IGS_CMAP_SIZE;
#undef wsd_fbip
return 0;

case WSDISPLAYIO_LINEBYTES:
*(int *)data = dc->dc_width * howmany(dc->dc_maxdepth, NBBY);
return 0;

case WSDISPLAYIO_SMODE:
#define d (*(int *)data)
if (d != WSDISPLAYIO_MODE_EMUL) {
dc->dc_mapped = 1;
/* turn off hardware cursor */
if (dc->dc_hwflags & IGSFB_HW_TEXT_CURSOR) {
dc->dc_curenb = 0;
igsfb_update_cursor(dc,
WSDISPLAY_CURSOR_DOCUR);
}
if ((dc->dc_mode != NULL) && (dc->dc_maxdepth != 8))
igsfb_set_mode(dc, dc->dc_mode,
dc->dc_maxdepth);
} else {
dc->dc_mapped = 0;
if ((dc->dc_mode != NULL) && (dc->dc_maxdepth != 8))
igsfb_set_mode(dc, dc->dc_mode, 8);
igsfb_init_cmap(dc);
/* reinit sprite for text cursor */
if (dc->dc_hwflags & IGSFB_HW_TEXT_CURSOR) {
igsfb_make_text_cursor(dc, dc->dc_vd.active);
dc->dc_curenb = 0;
igsfb_update_cursor(dc,
WSDISPLAY_CURSOR_DOSHAPE
| WSDISPLAY_CURSOR_DOCUR);
}
vcons_redraw_screen(vd->active);
}
return 0;

case WSDISPLAYIO_GVIDEO:
*(u_int *)data = dc->dc_blanked ?
WSDISPLAYIO_VIDEO_OFF : WSDISPLAYIO_VIDEO_ON;
return 0;

case WSDISPLAYIO_SVIDEO:
turnoff = (*(u_int *)data == WSDISPLAYIO_VIDEO_OFF);
if (dc->dc_blanked != turnoff) {
dc->dc_blanked = turnoff;
igsfb_blank_screen(dc, dc->dc_blanked);
}
return 0;

case WSDISPLAYIO_GETCMAP:
return igsfb_get_cmap(dc, (struct wsdisplay_cmap *)data);

case WSDISPLAYIO_PUTCMAP:
return igsfb_set_cmap(dc, (struct wsdisplay_cmap *)data);

case WSDISPLAYIO_GCURMAX:
((struct wsdisplay_curpos *)data)->x = IGS_CURSOR_MAX_SIZE;
((struct wsdisplay_curpos *)data)->y = IGS_CURSOR_MAX_SIZE;
return 0;

case WSDISPLAYIO_GCURPOS:
if (cursor_busy)
return EBUSY;
*(struct wsdisplay_curpos *)data = dc->dc_cursor.cc_pos;
return 0;

case WSDISPLAYIO_SCURPOS:
if (cursor_busy)
return EBUSY;
igsfb_set_curpos(dc, (struct wsdisplay_curpos *)data);
return 0;

case WSDISPLAYIO_GCURSOR:
if (cursor_busy)
return EBUSY;
return igsfb_get_cursor(dc, (struct wsdisplay_cursor *)data);

case WSDISPLAYIO_SCURSOR:
if (cursor_busy)
return EBUSY;
return igsfb_set_cursor(dc, (struct wsdisplay_cursor *)data);
}

return EPASSTHROUGH;
}

/*
* wsdisplay_accessops: ioctl(WSDISPLAYIO_SVIDEO)
*/
static void
igsfb_blank_screen(struct igsfb_devconfig *dc, int blank)
{

igs_ext_write(dc->dc_iot, dc->dc_ioh,
IGS_EXT_SYNC_CTL,
blank ? IGS_EXT_SYNC_H0 | IGS_EXT_SYNC_V0
: 0);
}

/*
* wsdisplay_accessops: ioctl(WSDISPLAYIO_GETCMAP)
* Served from the software cmap copy.
*/
static int
igsfb_get_cmap(struct igsfb_devconfig *dc, struct wsdisplay_cmap *p)
{
u_int index, count;
int err;

index = p->index;
count = p->count;

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

err = copyout(&dc->dc_cmap.r[index], p->red, count);
if (err)
return err;
err = copyout(&dc->dc_cmap.g[index], p->green, count);
if (err)
return err;
err = copyout(&dc->dc_cmap.b[index], p->blue, count);
if (err)
return err;

return 0;
}

/*
* wsdisplay_accessops: ioctl(WSDISPLAYIO_PUTCMAP)
* Set the software cmap copy and propagate changed range to the device.
*/
static int
igsfb_set_cmap(struct igsfb_devconfig *dc, const struct wsdisplay_cmap *p)
{
u_int index, count;
uint8_t r[IGS_CMAP_SIZE];
uint8_t g[IGS_CMAP_SIZE];
uint8_t b[IGS_CMAP_SIZE];
int error;

index = p->index;
count = p->count;
if (index >= IGS_CMAP_SIZE || count > IGS_CMAP_SIZE - index)
return EINVAL;
error = copyin(p->red, &r[index], count);
if (error)
return error;
error = copyin(p->green, &g[index], count);
if (error)
return error;
error = copyin(p->blue, &b[index], count);
if (error)
return error;

memcpy(&dc->dc_cmap.r[index], &r[index], count);
memcpy(&dc->dc_cmap.g[index], &g[index], count);
memcpy(&dc->dc_cmap.b[index], &b[index], count);

/* propagate changes to the device */
igsfb_update_cmap(dc, index, count);
return 0;
}

/*
* Propagate specified part of the software cmap copy to the device.
*/
static void
igsfb_update_cmap(struct igsfb_devconfig *dc, u_int index, u_int count)
{
bus_space_tag_t t;
bus_space_handle_t h;
u_int last, i;

if (index >= IGS_CMAP_SIZE)
return;

if (count > IGS_CMAP_SIZE - index)
last = IGS_CMAP_SIZE;
else
last = index + count;

t = dc->dc_iot;
h = dc->dc_ioh;

/* start palette writing, index is autoincremented by hardware */
bus_space_write_1(t, h, IGS_DAC_PEL_WRITE_IDX, index);

for (i = index; i < last; ++i) {
bus_space_write_1(t, h, IGS_DAC_PEL_DATA, dc->dc_cmap.r[i]);
bus_space_write_1(t, h, IGS_DAC_PEL_DATA, dc->dc_cmap.g[i]);
bus_space_write_1(t, h, IGS_DAC_PEL_DATA, dc->dc_cmap.b[i]);
}
}

/*
* wsdisplay_accessops: ioctl(WSDISPLAYIO_SCURPOS)
*/
static void
igsfb_set_curpos(struct igsfb_devconfig *dc,
const struct wsdisplay_curpos *curpos)
{
struct rasops_info *ri = &dc->dc_vd.active->scr_ri;
u_int x = curpos->x, y = curpos->y;

if (x >= ri->ri_width)
x = ri->ri_width - 1;
if (y >= ri->ri_height)
y = ri->ri_height - 1;

dc->dc_cursor.cc_pos.x = x;
dc->dc_cursor.cc_pos.y = y;

/* propagate changes to the device */
igsfb_update_curpos(dc);
}

static void
igsfb_update_curpos(struct igsfb_devconfig *dc)
{
bus_space_tag_t t;
bus_space_handle_t h;
int x, xoff, y, yoff;

xoff = 0;
x = dc->dc_cursor.cc_pos.x - dc->dc_cursor.cc_hot.x;
if (x < 0) {
xoff = -x;
x = 0;
}

yoff = 0;
y = dc->dc_cursor.cc_pos.y - dc->dc_cursor.cc_hot.y;
if (y < 0) {
yoff = -y;
y = 0;
}

t = dc->dc_iot;
h = dc->dc_ioh;

igs_ext_write(t, h, IGS_EXT_SPRITE_HSTART_LO, x & 0xff);
igs_ext_write(t, h, IGS_EXT_SPRITE_HSTART_HI, (x >> 8) & 0x07);
igs_ext_write(t, h, IGS_EXT_SPRITE_HPRESET, xoff & 0x3f);

igs_ext_write(t, h, IGS_EXT_SPRITE_VSTART_LO, y & 0xff);
igs_ext_write(t, h, IGS_EXT_SPRITE_VSTART_HI, (y >> 8) & 0x07);
igs_ext_write(t, h, IGS_EXT_SPRITE_VPRESET, yoff & 0x3f);
}

/*
* wsdisplay_accessops: ioctl(WSDISPLAYIO_GCURSOR)
*/
static int
igsfb_get_cursor(struct igsfb_devconfig *dc, struct wsdisplay_cursor *p)
{

/* XXX: TODO */
return 0;
}

/*
* wsdisplay_accessops: ioctl(WSDISPLAYIO_SCURSOR)
*/
static int
igsfb_set_cursor(struct igsfb_devconfig *dc, const struct wsdisplay_cursor *p)
{
struct igs_hwcursor *cc;
struct wsdisplay_curpos pos, hot;
u_int v, index, count, icount, iwidth;
uint8_t r[2], g[2], b[2], image[512], mask[512];
int error;

cc = &dc->dc_cursor;
v = p->which;
index = count = icount = iwidth = 0; /* XXX: gcc */
pos.x = pos.y = 0; /* XXX: gcc */

/* copy in the new cursor colormap */
if (v & WSDISPLAY_CURSOR_DOCMAP) {
index = p->cmap.index;
count = p->cmap.count;
if (index >= 2 || (index + count) > 2)
return EINVAL;
error = copyin(p->cmap.red, &r[index], count);
if (error)
return error;
error = copyin(p->cmap.green, &g[index], count);
if (error)
return error;
error = copyin(p->cmap.blue, &b[index], count);
if (error)
return error;
}

/* verify that the new cursor data are valid */
if (v & WSDISPLAY_CURSOR_DOSHAPE) {
if (p->size.x > IGS_CURSOR_MAX_SIZE
|| p->size.y > IGS_CURSOR_MAX_SIZE)
return EINVAL;

iwidth = (p->size.x + 7) >> 3; /* bytes per scan line */
icount = iwidth * p->size.y;
error = copyin(p->image, image, icount);
if (error)
return error;
error = copyin(p->mask, mask, icount);
if (error)
return error;
}

/* enforce that the position is within screen bounds */
if (v & WSDISPLAY_CURSOR_DOPOS) {
struct rasops_info *ri = &dc->dc_vd.active->scr_ri;

pos = p->pos; /* local copy we can write to */
if (pos.x >= ri->ri_width)
pos.x = ri->ri_width - 1;
if (pos.y >= ri->ri_height)
pos.y = ri->ri_height - 1;
}

/* enforce that the hot spot is within sprite bounds */
if (v & WSDISPLAY_CURSOR_DOHOT)
hot = p->hot; /* local copy we can write to */

if (v & (WSDISPLAY_CURSOR_DOHOT | WSDISPLAY_CURSOR_DOSHAPE)) {
const struct wsdisplay_curpos *nsize;
struct wsdisplay_curpos *nhot;

nsize = (v & WSDISPLAY_CURSOR_DOSHAPE) ?
&p->size : &cc->cc_size;
nhot = (v & WSDISPLAY_CURSOR_DOHOT) ? &hot : &cc->cc_hot;

if (nhot->x >= nsize->x)
nhot->x = nsize->x - 1;
if (nhot->y >= nsize->y)
nhot->y = nsize->y - 1;
}

/* copy data to the driver's cursor info */
if (v & WSDISPLAY_CURSOR_DOCUR)
dc->dc_curenb = p->enable;
if (v & WSDISPLAY_CURSOR_DOPOS)
cc->cc_pos = pos; /* local copy, possibly corrected */
if (v & WSDISPLAY_CURSOR_DOHOT)
cc->cc_hot = hot; /* local copy, possibly corrected */
if (v & WSDISPLAY_CURSOR_DOCMAP) {
memcpy(&cc->cc_color[index], &r[index], count);
memcpy(&cc->cc_color[index + 2], &g[index], count);
memcpy(&cc->cc_color[index + 4], &b[index], count);
}
if (v & WSDISPLAY_CURSOR_DOSHAPE) {
u_int trailing_bits;

memcpy(cc->cc_image, image, icount);
memcpy(cc->cc_mask, mask, icount);
cc->cc_size = p->size;

/* clear trailing bits in the "partial" mask bytes */
trailing_bits = p->size.x & 0x07;
if (trailing_bits != 0) {
const u_int cutmask = ~((~0U) << trailing_bits);
u_char *mp;
u_int i;

mp = cc->cc_mask + iwidth - 1;
for (i = 0; i < p->size.y; ++i) {
*mp &= cutmask;
mp += iwidth;
}
}
igsfb_convert_cursor_data(dc, iwidth, p->size.y);
}

/* propagate changes to the device */
igsfb_update_cursor(dc, v);

return 0;
}

/*
* Convert incoming 1bpp cursor image/mask into native 2bpp format.
*/
static void
igsfb_convert_cursor_data(struct igsfb_devconfig *dc,
u_int width, u_int height)
{
struct igs_hwcursor *cc = &dc->dc_cursor;
uint16_t *expand = dc->dc_bexpand;
uint8_t *ip, *mp;
uint16_t is, ms, *dp;
u_int line, i;

/* init sprite to be all transparent */
memset(cc->cc_sprite, 0xaa, IGS_CURSOR_DATA_SIZE);

/* first scanline */
ip = cc->cc_image;
mp = cc->cc_mask;
dp = cc->cc_sprite;

for (line = 0; line < height; ++line) {
for (i = 0; i < width; ++i) {
is = expand[ip[i]]; /* image: 0 -> 00, 1 -> 01 */
ms = expand[mp[i]]; /* mask: 0 -> 00, 1 -> 11 */
ms |= (ms << 1);
dp[i] = (0xaaaa & ~ms) | (is & ms);
}

/* next scanline */
ip += width;
mp += width;
dp += 8; /* 64 pixels, 2bpp, 8 pixels per short = 8 shorts */
}
}

/*
* Propagate cursor changes to the device.
* "which" is composed of WSDISPLAY_CURSOR_DO* bits.
*/
static void
igsfb_update_cursor(struct igsfb_devconfig *dc, u_int which)
{
bus_space_tag_t iot = dc->dc_iot;
bus_space_handle_t ioh = dc->dc_ioh;
uint8_t curctl;

curctl = 0; /* XXX: gcc */

/*
* We will need to tweak sprite control register for cursor
* visibility and cursor color map manipulation.
*/
if (which & (WSDISPLAY_CURSOR_DOCUR | WSDISPLAY_CURSOR_DOCMAP)) {
curctl = igs_ext_read(iot, ioh, IGS_EXT_SPRITE_CTL);
}

if (which & WSDISPLAY_CURSOR_DOSHAPE) {
uint8_t *dst = bus_space_vaddr(dc->dc_memt, dc->dc_crh);

/*
* memcpy between spaces of different endianness would
* be ... special. We cannot be sure if memcpy gonna
* push data in 4-byte chunks, we can't pre-bswap it,
* so do it byte-by-byte to preserve byte ordering.
*/
if (IGSFB_HW_SOFT_BSWAP(dc)) {
uint8_t *src = (uint8_t *)dc->dc_cursor.cc_sprite;
int i;

for (i = 0; i < IGS_CURSOR_DATA_SIZE; ++i)
*dst++ = *src++;
} else {
memcpy(dst, dc->dc_cursor.cc_sprite,
IGS_CURSOR_DATA_SIZE);
}
}

if (which & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOHOT)) {
/* code shared with WSDISPLAYIO_SCURPOS */
igsfb_update_curpos(dc);
}

if (which & WSDISPLAY_CURSOR_DOCMAP) {
uint8_t *p;

/* tell DAC we want access to the cursor palette */
igs_ext_write(iot, ioh, IGS_EXT_SPRITE_CTL,
curctl | IGS_EXT_SPRITE_DAC_PEL);

p = dc->dc_cursor.cc_color;

bus_space_write_1(iot, ioh, IGS_DAC_PEL_WRITE_IDX, 0);
bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[0]);
bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[2]);
bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[4]);

bus_space_write_1(iot, ioh, IGS_DAC_PEL_WRITE_IDX, 1);
bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[1]);
bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[3]);
bus_space_write_1(iot, ioh, IGS_DAC_PEL_DATA, p[5]);

/* restore access to the normal palette */
igs_ext_write(iot, ioh, IGS_EXT_SPRITE_CTL, curctl);
}

if (which & WSDISPLAY_CURSOR_DOCUR) {
if ((curctl & IGS_EXT_SPRITE_VISIBLE) == 0
&& dc->dc_curenb)
igs_ext_write(iot, ioh, IGS_EXT_SPRITE_CTL,
curctl | IGS_EXT_SPRITE_VISIBLE);
else if ((curctl & IGS_EXT_SPRITE_VISIBLE) != 0
&& !dc->dc_curenb)
igs_ext_write(iot, ioh, IGS_EXT_SPRITE_CTL,
curctl & ~IGS_EXT_SPRITE_VISIBLE);
}
}

/*
* Accelerated text mode cursor that uses hardware sprite.
*/
static void
igsfb_accel_cursor(void *cookie, int on, int row, int col)
{
struct rasops_info *ri = (struct rasops_info *)cookie;
struct vcons_screen *scr = ri->ri_hw;
struct igsfb_devconfig *dc = scr->scr_cookie;
struct igs_hwcursor *cc = &dc->dc_cursor;
u_int which;

ri->ri_crow = row;
ri->ri_ccol = col;

which = 0;
if (on) {
ri->ri_flg |= RI_CURSOR;

/* only bother to move the cursor if it's visible */
cc->cc_pos.x = ri->ri_xorigin
+ ri->ri_ccol * ri->ri_font->fontwidth;
cc->cc_pos.y = ri->ri_yorigin
+ ri->ri_crow * ri->ri_font->fontheight;
which |= WSDISPLAY_CURSOR_DOPOS;
} else
ri->ri_flg &= ~RI_CURSOR;

if (dc->dc_curenb != on) {
dc->dc_curenb = on;
which |= WSDISPLAY_CURSOR_DOCUR;
}

/* propagate changes to the device */
igsfb_update_cursor(dc, which);
}

/*
* Accelerated raster ops that use graphic coprocessor.
*/

static int
igsfb_accel_wait(struct igsfb_devconfig *dc)
{
bus_space_tag_t t = dc->dc_iot;
bus_space_handle_t h = dc->dc_coph;
int timo = 100000;
uint8_t reg;

bus_space_write_1(t, h, IGS_COP_MAP_FMT_REG,
howmany(dc->dc_depth, NBBY) - 1);
while (timo--) {
reg = bus_space_read_1(t, h, IGS_COP_CTL_REG);
if ((reg & IGS_COP_CTL_BUSY) == 0)
return 0;
}

return 1;
}

static void
igsfb_accel_copy(struct igsfb_devconfig *dc, uint32_t src, uint32_t dst,
uint16_t width, uint16_t height)
{
bus_space_tag_t t = dc->dc_iot;
bus_space_handle_t h = dc->dc_coph;
uint32_t toend;
uint8_t drawcmd;

drawcmd = IGS_COP_DRAW_ALL;
if (dst > src) {
toend = dc->dc_vd.active->scr_ri.ri_width * (height - 1) + (width - 1);
src += toend;
dst += toend;
drawcmd |= IGS_COP_OCTANT_X_NEG | IGS_COP_OCTANT_Y_NEG;
}

igsfb_accel_wait(dc);
bus_space_write_1(t, h, IGS_COP_CTL_REG, 0);

bus_space_write_1(t, h, IGS_COP_FG_MIX_REG, IGS_COP_MIX_S);

bus_space_write_2(t, h, IGS_COP_WIDTH_REG, width - 1);
bus_space_write_2(t, h, IGS_COP_HEIGHT_REG, height - 1);

bus_space_write_4(t, h, IGS_COP_SRC_START_REG, src);
bus_space_write_4(t, h, IGS_COP_DST_START_REG, dst);

bus_space_write_1(t, h, IGS_COP_PIXEL_OP_0_REG, drawcmd);
bus_space_write_1(t, h, IGS_COP_PIXEL_OP_1_REG, IGS_COP_PPM_FIXED_FG);
bus_space_write_1(t, h, IGS_COP_PIXEL_OP_2_REG, 0);
bus_space_write_1(t, h, IGS_COP_PIXEL_OP_3_REG,
IGS_COP_OP_PXBLT | IGS_COP_OP_FG_FROM_SRC);
}

static void
igsfb_accel_fill(struct igsfb_devconfig *dc, uint32_t color, uint32_t dst,
uint16_t width, uint16_t height)
{
bus_space_tag_t t = dc->dc_iot;
bus_space_handle_t h = dc->dc_coph;

igsfb_accel_wait(dc);
bus_space_write_1(t, h, IGS_COP_CTL_REG, 0);

bus_space_write_1(t, h, IGS_COP_FG_MIX_REG, IGS_COP_MIX_S);

bus_space_write_2(t, h, IGS_COP_WIDTH_REG, width - 1);
bus_space_write_2(t, h, IGS_COP_HEIGHT_REG, height - 1);

bus_space_write_4(t, h, IGS_COP_DST_START_REG, dst);
bus_space_write_4(t, h, IGS_COP_FG_REG, color);

bus_space_write_1(t, h, IGS_COP_PIXEL_OP_0_REG, IGS_COP_DRAW_ALL);
bus_space_write_1(t, h, IGS_COP_PIXEL_OP_1_REG, IGS_COP_PPM_FIXED_FG);
bus_space_write_1(t, h, IGS_COP_PIXEL_OP_2_REG, 0);
bus_space_write_1(t, h, IGS_COP_PIXEL_OP_3_REG, IGS_COP_OP_PXBLT);
}

static void
igsfb_accel_copyrows(void *cookie, int src, int dst, int num)
{
struct rasops_info *ri = (struct rasops_info *)cookie;
struct vcons_screen *scr = ri->ri_hw;
struct igsfb_devconfig *dc = (struct igsfb_devconfig *)scr->scr_cookie;
uint32_t srp, dsp;
uint16_t width, height;

width = ri->ri_emuwidth;
height = num * ri->ri_font->fontheight;

srp = ri->ri_xorigin
+ ri->ri_width * (ri->ri_yorigin
+ src * ri->ri_font->fontheight);
dsp = ri->ri_xorigin
+ ri->ri_width * (ri->ri_yorigin
+ dst * ri->ri_font->fontheight);

igsfb_accel_copy(dc, srp, dsp, width, height);
}

static void
igsfb_accel_copycols(void *cookie, int row, int src, int dst, int num)
{
struct rasops_info *ri = (struct rasops_info *)cookie;
struct vcons_screen *scr = ri->ri_hw;
struct igsfb_devconfig *dc = (struct igsfb_devconfig *)scr->scr_cookie;
uint32_t rowp, srp, dsp;
uint16_t width, height;

width = num * ri->ri_font->fontwidth;
height = ri->ri_font->fontheight;

rowp = ri->ri_xorigin
+ ri->ri_width * (ri->ri_yorigin
+ row * ri->ri_font->fontheight);

srp = rowp + src * ri->ri_font->fontwidth;
dsp = rowp + dst * ri->ri_font->fontwidth;

igsfb_accel_copy(dc, srp, dsp, width, height);
}

static void
igsfb_accel_eraserows(void *cookie, int row, int num, long attr)
{
struct rasops_info *ri = (struct rasops_info *)cookie;
struct vcons_screen *scr = ri->ri_hw;
struct igsfb_devconfig *dc = (struct igsfb_devconfig *)scr->scr_cookie;
uint32_t color;
uint32_t dsp;
uint16_t width, height;

if (num == ri->ri_rows && (ri->ri_flg & RI_FULLCLEAR) != 0) {
width = ri->ri_width;
height = ri->ri_height;
dsp = 0;
} else {
width = ri->ri_emuwidth;
height = num * ri->ri_font->fontheight;

dsp = ri->ri_xorigin
+ ri->ri_width * (ri->ri_yorigin
+ row * ri->ri_font->fontheight);
}

/* XXX: we "know" the encoding that rasops' allocattr uses */
color = (attr >> 16) & 0xff;

igsfb_accel_fill(dc, color, dsp, width, height);
}

static void
igsfb_accel_erasecols(void *cookie, int row, int col, int num, long attr)
{
struct rasops_info *ri = (struct rasops_info *)cookie;
struct vcons_screen *scr = ri->ri_hw;
struct igsfb_devconfig *dc = (struct igsfb_devconfig *)scr->scr_cookie;
uint32_t color;
uint32_t rowp, dsp;
uint16_t width, height;

width = num * ri->ri_font->fontwidth;
height = ri->ri_font->fontheight;

rowp = ri->ri_xorigin
+ ri->ri_width * (ri->ri_yorigin
+ row * ri->ri_font->fontheight);

dsp = rowp + col * ri->ri_font->fontwidth;

/* XXX: we "know" the encoding that rasops' allocattr uses */
color = (attr >> 16) & 0xff;

igsfb_accel_fill(dc, color, dsp, width, height);
}

/*
* Not really implemented here, but we need to hook into the one
* supplied by rasops so that we can synchronize with the COP.
*/
static void
igsfb_accel_putchar(void *cookie, int row, int col, u_int uc, long attr)
{
struct rasops_info *ri = (struct rasops_info *)cookie;
struct vcons_screen *scr = ri->ri_hw;
struct igsfb_devconfig *dc = (struct igsfb_devconfig *)scr->scr_cookie;

igsfb_accel_wait(dc);
(*dc->dc_ri_putchar)(cookie, row, col, uc, attr);
}