/* $NetBSD: plumvideo.c,v 1.46 2025/02/26 04:49:46 andvar Exp $ */

/* $NetBSD: plumvideo.c,v 1.46 2025/02/26 04:49:46 andvar Exp $ */

/*-
* Copyright (c) 1999-2002 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by UCHIYAMA Yasushi.
*
* 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.
*
* 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.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: plumvideo.c,v 1.46 2025/02/26 04:49:46 andvar Exp $");

#include "plumohci.h" /* Plum2 OHCI shared memory allocated on V-RAM */
#include "bivideo.h"

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

#include <sys/ioctl.h>
#include <sys/buf.h>
#include <uvm/uvm_extern.h>

#include <dev/cons.h> /* consdev */

#include <mips/cache.h>

#include <machine/bus.h>
#include <machine/intr.h>
#include <machine/config_hook.h>

#include <hpcmips/tx/tx39var.h>
#include <hpcmips/dev/plumvar.h>
#include <hpcmips/dev/plumicuvar.h>
#include <hpcmips/dev/plumpowervar.h>
#include <hpcmips/dev/plumvideoreg.h>

#include <machine/bootinfo.h>

#include <dev/wscons/wsdisplayvar.h>
#include <dev/rasops/rasops.h>
#include <dev/hpc/video_subr.h>

#include <dev/wscons/wsconsio.h>
#include <dev/hpc/hpcfbvar.h>
#include <dev/hpc/hpcfbio.h>
#if NBIVIDEO > 0
#include <dev/hpc/bivideovar.h>
#endif

#ifdef PLUMVIDEODEBUG
#define DPRINTF_ENABLE
#define DPRINTF_DEBUG plumvideo_debug
#endif
#include <machine/debug.h>

struct plumvideo_softc {
device_t sc_dev;
tx_chipset_tag_t sc_tc;
plum_chipset_tag_t sc_pc;

void *sc_powerhook; /* power management hook */
int sc_console;

int sc_backlight;
int sc_brightness;
int sc_max_brightness;

/* control register */
bus_space_tag_t sc_regt;
bus_space_handle_t sc_regh;
/* frame buffer */
bus_space_tag_t sc_fbiot;
bus_space_handle_t sc_fbioh;
/* clut buffer (8bpp only) */
bus_space_tag_t sc_clutiot;
bus_space_handle_t sc_clutioh;
/* bitblt */
bus_space_tag_t sc_bitbltt;
bus_space_handle_t sc_bitblth;

struct video_chip sc_chip;
struct hpcfb_fbconf sc_fbconf;
struct hpcfb_dspconf sc_dspconf;
};

int plumvideo_match(device_t, cfdata_t, void *);
void plumvideo_attach(device_t, device_t, void *);

int plumvideo_ioctl(void *, u_long, void *, int, struct lwp *);
paddr_t plumvideo_mmap(void *, off_t, int);

CFATTACH_DECL_NEW(plumvideo, sizeof(struct plumvideo_softc),
plumvideo_match, plumvideo_attach, NULL, NULL);

struct hpcfb_accessops plumvideo_ha = {
plumvideo_ioctl, plumvideo_mmap
};

int plumvideo_power(void *, int, long, void *);

int plumvideo_init(struct plumvideo_softc *, int *);
void plumvideo_hpcfbinit(struct plumvideo_softc *, int);

void plumvideo_clut_default(struct plumvideo_softc *);
void plumvideo_clut_set(struct plumvideo_softc *, u_int32_t *, int, int);
void plumvideo_clut_get(struct plumvideo_softc *, u_int32_t *, int, int);
void __plumvideo_clut_access(struct plumvideo_softc *, u_int32_t *, int, int,
void (*)(bus_space_tag_t, bus_space_handle_t, u_int32_t *, int, int));
static void _flush_cache(void) __attribute__((__unused__)); /* !!! */
static void plumvideo_init_backlight(struct plumvideo_softc *);
static void plumvideo_backlight(struct plumvideo_softc *, int);
static void plumvideo_brightness(struct plumvideo_softc *, int);

#ifdef PLUMVIDEODEBUG
void plumvideo_dump(struct plumvideo_softc*);
#endif

#define ON 1
#define OFF 0

int
plumvideo_match(device_t parent, cfdata_t cf, void *aux)
{
/*
* VRAM area also uses as UHOSTC shared RAM.
*/
return (2); /* 1st attach group */
}

void
plumvideo_attach(device_t parent, device_t self, void *aux)
{
struct plum_attach_args *pa = aux;
struct plumvideo_softc *sc = device_private(self);
struct hpcfb_attach_args ha;
int console, reverse_flag;

sc->sc_dev = self;
sc->sc_console = console = cn_tab ? 0 : 1;
sc->sc_pc = pa->pa_pc;
sc->sc_regt = pa->pa_regt;
sc->sc_fbiot = sc->sc_clutiot = sc->sc_bitbltt = pa->pa_iot;

printf(": ");

/* map register area */
if (bus_space_map(sc->sc_regt, PLUM_VIDEO_REGBASE,
PLUM_VIDEO_REGSIZE, 0, &sc->sc_regh)) {
printf("register map failed\n");
return;
}

/* initialize backlight and brightness values */
plumvideo_init_backlight(sc);

/* power control */
plumvideo_power(sc, 0, 0,
(void *)(console ? PWR_RESUME : PWR_SUSPEND));
/* Add a hard power hook to power saving */
sc->sc_powerhook = config_hook(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_HARDPOWER,
CONFIG_HOOK_SHARE,
plumvideo_power, sc);
if (sc->sc_powerhook == 0)
printf("WARNING unable to establish hard power hook");

/*
* Initialize LCD controller
* map V-RAM area.
* reinstall bootinfo structure.
* some OHCI shared-buffer hack. XXX
*/
if (plumvideo_init(sc, &reverse_flag) != 0)
return;

printf("\n");

/* Attach frame buffer device */
plumvideo_hpcfbinit(sc, reverse_flag);

#ifdef PLUMVIDEODEBUG
if (plumvideo_debug > 0)
plumvideo_dump(sc);
/* attach debug draw routine (debugging use) */
video_attach_drawfunc(&sc->sc_chip);
tx_conf_register_video(sc->sc_pc->pc_tc, &sc->sc_chip);
#endif /* PLUMVIDEODEBUG */

if(console && hpcfb_cnattach(&sc->sc_fbconf) != 0) {
panic("plumvideo_attach: can't init fb console");
}

ha.ha_console = console;
ha.ha_accessops = &plumvideo_ha;
ha.ha_accessctx = sc;
ha.ha_curfbconf = 0;
ha.ha_nfbconf = 1;
ha.ha_fbconflist = &sc->sc_fbconf;
ha.ha_curdspconf = 0;
ha.ha_ndspconf = 1;
ha.ha_dspconflist = &sc->sc_dspconf;

config_found(self, &ha, hpcfbprint, CFARGS_NONE);
#if NBIVIDEO > 0
/* bivideo is no longer need */
bivideo_dont_attach = 1;
#endif /* NBIVIDEO > 0 */
}

void
plumvideo_hpcfbinit(struct plumvideo_softc *sc, int reverse_flag)
{
struct hpcfb_fbconf *fb = &sc->sc_fbconf;
struct video_chip *chip = &sc->sc_chip;
vaddr_t fbvaddr = (vaddr_t)sc->sc_fbioh;
int height = chip->vc_fbheight;
int width = chip->vc_fbwidth;
int depth = chip->vc_fbdepth;

memset(fb, 0, sizeof(struct hpcfb_fbconf));

fb->hf_conf_index = 0; /* configuration index */
fb->hf_nconfs = 1; /* how many configurations */
strncpy(fb->hf_name, "PLUM built-in video", HPCFB_MAXNAMELEN);
/* frame buffer name */
strncpy(fb->hf_conf_name, "LCD", HPCFB_MAXNAMELEN);
/* configuration name */
fb->hf_height = height;
fb->hf_width = width;
fb->hf_baseaddr = (u_long)fbvaddr;
fb->hf_offset = (u_long)fbvaddr - mips_ptob(mips_btop(fbvaddr));
/* frame buffer start offset */
fb->hf_bytes_per_line = (width * depth) / NBBY;
fb->hf_nplanes = 1;
fb->hf_bytes_per_plane = height * fb->hf_bytes_per_line;

fb->hf_access_flags |= HPCFB_ACCESS_BYTE;
fb->hf_access_flags |= HPCFB_ACCESS_WORD;
fb->hf_access_flags |= HPCFB_ACCESS_DWORD;
if (reverse_flag)
fb->hf_access_flags |= HPCFB_ACCESS_REVERSE;

switch (depth) {
default:
panic("plumvideo_hpcfbinit: not supported color depth");
/* NOTREACHED */
case 16:
fb->hf_class = HPCFB_CLASS_RGBCOLOR;
fb->hf_access_flags |= HPCFB_ACCESS_STATIC;
fb->hf_pack_width = 16;
fb->hf_pixels_per_pack = 1;
fb->hf_pixel_width = 16;

fb->hf_class_data_length = sizeof(struct hf_rgb_tag);
/* reserved for future use */
fb->hf_u.hf_rgb.hf_flags = 0;

fb->hf_u.hf_rgb.hf_red_width = 5;
fb->hf_u.hf_rgb.hf_red_shift = 11;
fb->hf_u.hf_rgb.hf_green_width = 6;
fb->hf_u.hf_rgb.hf_green_shift = 5;
fb->hf_u.hf_rgb.hf_blue_width = 5;
fb->hf_u.hf_rgb.hf_blue_shift = 0;
fb->hf_u.hf_rgb.hf_alpha_width = 0;
fb->hf_u.hf_rgb.hf_alpha_shift = 0;
break;

case 8:
fb->hf_class = HPCFB_CLASS_INDEXCOLOR;
fb->hf_access_flags |= HPCFB_ACCESS_STATIC;
fb->hf_pack_width = 8;
fb->hf_pixels_per_pack = 1;
fb->hf_pixel_width = 8;
fb->hf_class_data_length = sizeof(struct hf_indexed_tag);
/* reserved for future use */
fb->hf_u.hf_indexed.hf_flags = 0;
break;
}
}

int
plumvideo_init(struct plumvideo_softc *sc, int *reverse)
{
struct video_chip *chip = &sc->sc_chip;
bus_space_tag_t regt = sc->sc_regt;
bus_space_handle_t regh = sc->sc_regh;
plumreg_t reg;
size_t vram_size;
int bpp, width, height, vram_pitch;

*reverse = video_reverse_color();
chip->vc_v = sc->sc_pc->pc_tc;
#if notyet
/* map BitBlt area */
if (bus_space_map(sc->sc_bitbltt,
PLUM_VIDEO_BITBLT_IOBASE,
PLUM_VIDEO_BITBLT_IOSIZE, 0,
&sc->sc_bitblth)) {
printf(": BitBlt map failed\n");
return (1);
}
#endif
reg = plum_conf_read(regt, regh, PLUM_VIDEO_PLGMD_REG);

switch (reg & PLUM_VIDEO_PLGMD_GMODE_MASK) {
case PLUM_VIDEO_PLGMD_16BPP:
#if NPLUMOHCI > 0 /* reserve V-RAM area for USB OHCI */
/* FALLTHROUGH */
#else
bpp = 16;
break;
#endif
default:
bootinfo->fb_type = *reverse ? BIFB_D8_FF : BIFB_D8_00;
reg &= ~PLUM_VIDEO_PLGMD_GMODE_MASK;
plum_conf_write(regt, regh, PLUM_VIDEO_PLGMD_REG, reg);
reg |= PLUM_VIDEO_PLGMD_8BPP;
plum_conf_write(regt, regh, PLUM_VIDEO_PLGMD_REG, reg);
#if notyet
/* change BitBlt color depth */
plum_conf_write(sc->sc_bitbltt, sc->sc_bitblth, 0x8, 0);
#endif
/* FALLTHROUGH */
case PLUM_VIDEO_PLGMD_8BPP:
bpp = 8;
break;
}
chip->vc_fbdepth = bpp;

/*
* Get display size from WindowsCE set.
*/
chip->vc_fbwidth = width = bootinfo->fb_width =
plum_conf_read(regt, regh, PLUM_VIDEO_PLHPX_REG) + 1;
chip->vc_fbheight = height = bootinfo->fb_height =
plum_conf_read(regt, regh, PLUM_VIDEO_PLVT_REG) -
plum_conf_read(regt, regh, PLUM_VIDEO_PLVDS_REG);

/*
* set line byte length to bootinfo and LCD controller.
*/
vram_pitch = bootinfo->fb_line_bytes = (width * bpp) / NBBY;
plum_conf_write(regt, regh, PLUM_VIDEO_PLPIT1_REG, vram_pitch);
plum_conf_write(regt, regh, PLUM_VIDEO_PLPIT2_REG,
vram_pitch & PLUM_VIDEO_PLPIT2_MASK);
plum_conf_write(regt, regh, PLUM_VIDEO_PLOFS_REG, vram_pitch);

/*
* boot messages and map CLUT(if any).
*/
printf("display mode: ");
switch (bpp) {
default:
printf("disabled ");
break;
case 8:
printf("8bpp ");
/* map CLUT area */
if (bus_space_map(sc->sc_clutiot,
PLUM_VIDEO_CLUT_LCD_IOBASE,
PLUM_VIDEO_CLUT_LCD_IOSIZE, 0,
&sc->sc_clutioh)) {
printf(": CLUT map failed\n");
return (1);
}
/* install default CLUT */
plumvideo_clut_default(sc);
break;
case 16:
printf("16bpp ");
break;
}

/*
* calculate frame buffer size.
*/
reg = plum_conf_read(regt, regh, PLUM_VIDEO_PLGMD_REG);
vram_size = (width * height * bpp) / NBBY;
vram_size = mips_round_page(vram_size);
chip->vc_fbsize = vram_size;

/*
* map V-RAM area.
*/
if (bus_space_map(sc->sc_fbiot, PLUM_VIDEO_VRAM_IOBASE,
vram_size, 0, &sc->sc_fbioh)) {
printf(": V-RAM map failed\n");
return (1);
}

bootinfo->fb_addr = (unsigned char *)sc->sc_fbioh;
chip->vc_fbvaddr = (vaddr_t)sc->sc_fbioh;
chip->vc_fbpaddr = PLUM_VIDEO_VRAM_IOBASE_PHYSICAL;

return (0);
}

int
plumvideo_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l)
{
struct plumvideo_softc *sc = v;
struct hpcfb_fbconf *fbconf;
struct hpcfb_dspconf *dspconf;
struct wsdisplay_cmap *cmap;
struct wsdisplay_param *dispparam;
u_int8_t *r, *g, *b;
u_int32_t *rgb;
int idx, error;
size_t cnt;

switch (cmd) {
case WSDISPLAYIO_GETCMAP:
cmap = (struct wsdisplay_cmap *)data;
cnt = cmap->count;
idx = cmap->index;

if (sc->sc_fbconf.hf_class != HPCFB_CLASS_INDEXCOLOR ||
sc->sc_fbconf.hf_pack_width != 8 ||
!LEGAL_CLUT_INDEX(idx) ||
!LEGAL_CLUT_INDEX(idx + cnt - 1)) {
return (EINVAL);
}

error = cmap_work_alloc(&r, &g, &b, &rgb, cnt);
if (error)
goto out;
plumvideo_clut_get(sc, rgb, idx, cnt);
rgb24_decompose(rgb, r, g, b, cnt);

error = copyout(r, cmap->red, cnt);
if (error)
goto out;
error = copyout(g, cmap->green, cnt);
if (error)
goto out;
error = copyout(b, cmap->blue, cnt);

out:
cmap_work_free(r, g, b, rgb);
return error;

case WSDISPLAYIO_PUTCMAP:
cmap = (struct wsdisplay_cmap *)data;
cnt = cmap->count;
idx = cmap->index;

if (sc->sc_fbconf.hf_class != HPCFB_CLASS_INDEXCOLOR ||
sc->sc_fbconf.hf_pack_width != 8 ||
!LEGAL_CLUT_INDEX(idx) ||
!LEGAL_CLUT_INDEX(idx + cnt - 1)) {
return (EINVAL);
}

error = cmap_work_alloc(&r, &g, &b, &rgb, cnt);
if (error)
goto out;
error = copyin(cmap->red, r, cnt);
if (error)
goto out;
error = copyin(cmap->green, g, cnt);
if (error)
goto out;
error = copyin(cmap->blue, b, cnt);
if (error)
goto out;
rgb24_compose(rgb, r, g, b, cnt);
plumvideo_clut_set(sc, rgb, idx, cnt);
goto out;

case WSDISPLAYIO_SVIDEO:
if (*(int *)data == WSDISPLAYIO_VIDEO_OFF)
plumvideo_backlight(sc, 0);
else
plumvideo_backlight(sc, 1);
return 0;

case WSDISPLAYIO_GVIDEO:
*(int *)data = sc->sc_backlight ?
WSDISPLAYIO_VIDEO_ON : WSDISPLAYIO_VIDEO_OFF;
return 0;

case WSDISPLAYIO_GETPARAM:
dispparam = (struct wsdisplay_param *)data;
switch (dispparam->param) {
case WSDISPLAYIO_PARAM_BACKLIGHT:
dispparam->min = 0;
dispparam->max = 1;
dispparam->curval = sc->sc_backlight;
break;
case WSDISPLAYIO_PARAM_BRIGHTNESS:
if (sc->sc_max_brightness <= 0)
return EINVAL;
dispparam->min = 0;
dispparam->max = sc->sc_max_brightness;
dispparam->curval = sc->sc_brightness;
break;
default:
return EINVAL;
}
return 0;

case WSDISPLAYIO_SETPARAM:
dispparam = (struct wsdisplay_param * )data;
switch (dispparam->param) {
case WSDISPLAYIO_PARAM_BACKLIGHT:
if (dispparam->curval < 0 || 1 < dispparam->curval)
return EINVAL;
plumvideo_backlight(sc, dispparam->curval);
break;
case WSDISPLAYIO_PARAM_BRIGHTNESS:
if (sc->sc_max_brightness <= 0)
return EINVAL;
if (dispparam->curval < 0 ||
sc->sc_max_brightness < dispparam->curval)
return EINVAL;
plumvideo_brightness(sc, dispparam->curval);
break;
default:
return EINVAL;
}
return 0;

case HPCFBIO_GCONF:
fbconf = (struct hpcfb_fbconf *)data;
if (fbconf->hf_conf_index != 0 &&
fbconf->hf_conf_index != HPCFB_CURRENT_CONFIG) {
return (EINVAL);
}
*fbconf = sc->sc_fbconf; /* structure assignment */
return (0);

case HPCFBIO_SCONF:
fbconf = (struct hpcfb_fbconf *)data;
if (fbconf->hf_conf_index != 0 &&
fbconf->hf_conf_index != HPCFB_CURRENT_CONFIG) {
return (EINVAL);
}
/*
* nothing to do because we have only one configuration
*/
return (0);

case HPCFBIO_GDSPCONF:
dspconf = (struct hpcfb_dspconf *)data;
if ((dspconf->hd_unit_index != 0 &&
dspconf->hd_unit_index != HPCFB_CURRENT_UNIT) ||
(dspconf->hd_conf_index != 0 &&
dspconf->hd_conf_index != HPCFB_CURRENT_CONFIG)) {
return (EINVAL);
}
*dspconf = sc->sc_dspconf; /* structure assignment */
return (0);

case HPCFBIO_SDSPCONF:
dspconf = (struct hpcfb_dspconf *)data;
if ((dspconf->hd_unit_index != 0 &&
dspconf->hd_unit_index != HPCFB_CURRENT_UNIT) ||
(dspconf->hd_conf_index != 0 &&
dspconf->hd_conf_index != HPCFB_CURRENT_CONFIG)) {
return (EINVAL);
}
/*
* nothing to do
* because we have only one unit and one configuration
*/
return (0);

case HPCFBIO_GOP:
case HPCFBIO_SOP:
/* XXX not implemented yet */
return (EINVAL);
}

return (EPASSTHROUGH);
}

paddr_t
plumvideo_mmap(void *ctx, off_t offset, int prot)
{
struct plumvideo_softc *sc = ctx;

if (offset < 0 || (sc->sc_fbconf.hf_bytes_per_plane +
sc->sc_fbconf.hf_offset) < offset) {
return (-1);
}

return (mips_btop(PLUM_VIDEO_VRAM_IOBASE_PHYSICAL + offset));
}

static void __plumvideo_clut_get(bus_space_tag_t, bus_space_handle_t,
u_int32_t *, int, int);
static void __plumvideo_clut_get(bus_space_tag_t iot, bus_space_handle_t ioh,
u_int32_t *rgb, int beg, int cnt)
{
int i;

for (i = 0, beg *= 4; i < cnt; i++, beg += 4) {
*rgb++ = bus_space_read_4(iot, ioh, beg) &
0x00ffffff;
}
}

void
plumvideo_clut_get(struct plumvideo_softc *sc, u_int32_t *rgb, int beg,
int cnt)
{
KASSERT(rgb);
KASSERT(LEGAL_CLUT_INDEX(beg));
KASSERT(LEGAL_CLUT_INDEX(beg + cnt - 1));
__plumvideo_clut_access(sc, rgb, beg, cnt, __plumvideo_clut_get);
}

static void __plumvideo_clut_set(bus_space_tag_t, bus_space_handle_t,
u_int32_t *, int, int);
static void __plumvideo_clut_set(bus_space_tag_t iot, bus_space_handle_t ioh,
u_int32_t *rgb, int beg, int cnt)
{
int i;

for (i = 0, beg *= 4; i < cnt; i++, beg +=4) {
bus_space_write_4(iot, ioh, beg,
*rgb++ & 0x00ffffff);
}
}

void
plumvideo_clut_set(struct plumvideo_softc *sc, u_int32_t *rgb, int beg,
int cnt)
{
KASSERT(rgb);
KASSERT(LEGAL_CLUT_INDEX(beg));
KASSERT(LEGAL_CLUT_INDEX(beg + cnt - 1));
__plumvideo_clut_access(sc, rgb, beg, cnt, __plumvideo_clut_set);
}

static void __plumvideo_clut_default(bus_space_tag_t, bus_space_handle_t,
u_int32_t *, int, int);
static void __plumvideo_clut_default(bus_space_tag_t iot, bus_space_handle_t ioh,
u_int32_t *rgb, int beg, int cnt)
{
static const u_int8_t compo6[6] = { 0, 51, 102, 153, 204, 255 };
static const u_int32_t ansi_color[16] = {
0x000000, 0xff0000, 0x00ff00, 0xffff00,
0x0000ff, 0xff00ff, 0x00ffff, 0xffffff,
0x000000, 0x800000, 0x008000, 0x808000,
0x000080, 0x800080, 0x008080, 0x808080,
};
int i, r, g, b;

/* ANSI escape sequence */
for (i = 0; i < 16; i++) {
bus_space_write_4(iot, ioh, i << 2, ansi_color[i]);
}
/* 16 - 31, gray scale */
for ( ; i < 32; i++) {
int j = (i - 16) * 17;
bus_space_write_4(iot, ioh, i << 2, RGB24(j, j, j));
}
/* 32 - 247, RGB color */
for (r = 0; r < 6; r++) {
for (g = 0; g < 6; g++) {
for (b = 0; b < 6; b++) {
bus_space_write_4(iot, ioh, i << 2,
RGB24(compo6[r],
compo6[g],
compo6[b]));
i++;
}
}
}
/* 248 - 245, just white */
for ( ; i < 256; i++) {
bus_space_write_4(iot, ioh, i << 2, 0xffffff);
}
}

void
plumvideo_clut_default(struct plumvideo_softc *sc)
{
__plumvideo_clut_access(sc, NULL, 0, 256, __plumvideo_clut_default);
}

void
__plumvideo_clut_access(struct plumvideo_softc *sc, u_int32_t *rgb, int beg,
int cnt, void (*palette_func)(bus_space_tag_t, bus_space_handle_t,
u_int32_t *, int, int))
{
bus_space_tag_t regt = sc->sc_regt;
bus_space_handle_t regh = sc->sc_regh;
plumreg_t val, gmode;

/* display off */
val = bus_space_read_4(regt, regh, PLUM_VIDEO_PLGMD_REG);
gmode = val & PLUM_VIDEO_PLGMD_GMODE_MASK;
val &= ~PLUM_VIDEO_PLGMD_GMODE_MASK;
bus_space_write_4(regt, regh, PLUM_VIDEO_PLGMD_REG, val);

/* palette access disable */
val &= ~PLUM_VIDEO_PLGMD_PALETTE_ENABLE;
bus_space_write_4(regt, regh, PLUM_VIDEO_PLGMD_REG, val);

/* change palette mode to CPU */
val &= ~PLUM_VIDEO_PLGMD_MODE_DISPLAY;
bus_space_write_4(regt, regh, PLUM_VIDEO_PLGMD_REG, val);

/* palette access */
(*palette_func) (sc->sc_clutiot, sc->sc_clutioh, rgb, beg, cnt);

/* change palette mode to Display */
val |= PLUM_VIDEO_PLGMD_MODE_DISPLAY;
bus_space_write_4(regt, regh, PLUM_VIDEO_PLGMD_REG, val);

/* palette access enable */
val |= PLUM_VIDEO_PLGMD_PALETTE_ENABLE;
bus_space_write_4(regt, regh, PLUM_VIDEO_PLGMD_REG, val);

/* display on */
val |= gmode;
bus_space_write_4(regt, regh, PLUM_VIDEO_PLGMD_REG, val);
}

/* !!! */
static void
_flush_cache(void)
{
mips_dcache_wbinv_all();
mips_icache_sync_all();
}

int
plumvideo_power(void *ctx, int type, long id, void *msg)
{
struct plumvideo_softc *sc = ctx;
int why = (int)msg;

switch (why) {
case PWR_RESUME:
if (!sc->sc_console)
return (0); /* serial console */

DPRINTF("%s: ON\n", device_xname(sc->sc_dev));
/* power on */
plumvideo_backlight(sc, 1);
break;
case PWR_SUSPEND:
/* FALLTHROUGH */
case PWR_STANDBY:
DPRINTF("%s: OFF\n", device_xname(sc->sc_dev));
/* power off */
plumvideo_backlight(sc, 0);
break;
}

return (0);
}

static void
plumvideo_init_backlight(struct plumvideo_softc *sc)
{
int val;

val = -1;
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_POWER_LCDLIGHT, &val) != -1) {
/* we can get real backlight state */
sc->sc_backlight = val;
}

val = -1;
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_BRIGHTNESS_MAX, &val) != -1) {
/* we can get real brightness max */
sc->sc_max_brightness = val;

val = -1;
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_BRIGHTNESS, &val) != -1) {
/* we can get real brightness */
sc->sc_brightness = val;
} else {
sc->sc_brightness = sc->sc_max_brightness;
}
}
}

static void
plumvideo_backlight(struct plumvideo_softc *sc, int on)
{
plum_chipset_tag_t pc = sc->sc_pc;
bus_space_tag_t regt = sc->sc_regt;
bus_space_handle_t regh = sc->sc_regh;

sc->sc_backlight = on;
if (on) {
/* LCD on */
plum_power_establish(pc, PLUM_PWR_LCD);
/* backlight on */
plum_power_establish(pc, PLUM_PWR_BKL);
plum_conf_write(regt, regh, PLUM_VIDEO_PLLUM_REG,
PLUM_VIDEO_PLLUM_MAX);
} else {
/* backlight off */
plum_conf_write(regt, regh, PLUM_VIDEO_PLLUM_REG,
PLUM_VIDEO_PLLUM_MIN);
plum_power_disestablish(pc, PLUM_PWR_BKL);
/* LCD off */
plum_power_disestablish(pc, PLUM_PWR_LCD);
}
/* call machine dependent backlight control */
config_hook_call(CONFIG_HOOK_SET,
CONFIG_HOOK_POWER_LCDLIGHT, (void *)on);
}

static void
plumvideo_brightness(struct plumvideo_softc *sc, int val)
{

sc->sc_brightness = val;
/* call machine dependent brightness control */
if (sc->sc_backlight)
config_hook_call(CONFIG_HOOK_SET,
CONFIG_HOOK_BRIGHTNESS, &val);
}

#ifdef PLUMVIDEODEBUG
void
plumvideo_dump(struct plumvideo_softc *sc)
{
bus_space_tag_t regt = sc->sc_regt;
bus_space_handle_t regh = sc->sc_regh;

plumreg_t reg;
int i;

for (i = 0; i < 0x160; i += 4) {
reg = plum_conf_read(regt, regh, i);
printf("0x%03x %08x", i, reg);
dbg_bit_print(reg);
}
}
#endif /* PLUMVIDEODEBUG */