/*      $NetBSD: hd64461video.c,v 1.58 2023/12/20 14:50:02 thorpej Exp $        */

/*-
* Copyright (c) 2001, 2002, 2004 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: hd64461video.c,v 1.58 2023/12/20 14:50:02 thorpej Exp $");

#include "opt_hd64461video.h"
// #define HD64461VIDEO_HWACCEL

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

#include <sys/conf.h> /* cdev_decl */
#include <dev/cons.h> /* consdev */

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

#include <machine/intr.h>

#include <hpcsh/dev/hd64461/hd64461var.h>
#include <hpcsh/dev/hd64461/hd64461reg.h>
#include <hpcsh/dev/hd64461/hd64461videoreg.h>

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

#include <dev/wscons/wsconsio.h>
#include <dev/hpc/hpcfbvar.h>
#include <dev/hpc/hpcfbio.h>
#include <dev/hpc/video_subr.h>

#include <machine/config_hook.h>
#include <machine/bootinfo.h>

#include <machine/platid.h>
#include <machine/platid_mask.h>

#ifdef  HD64461VIDEO_DEBUG
#define DPRINTF_ENABLE
#define DPRINTF_DEBUG   hd64461video_debug
#endif
#include <machine/debug.h>

struct hd64461video_chip;
struct hd64461video_font {
       struct wsdisplay_font wsfont;
       int c, cw, cstep;
       int loaded;
};

struct hd64461video_softc {
       device_t sc_dev;

       enum hd64461_module_id sc_module_id;
       struct hd64461video_chip *sc_vc;

       struct hd64461video_font sc_font;
};

enum hd64461video_display_mode {
       LCD256_C,
       LCD64K_C,
       LCD64_MONO,
       LCD16_MONO,
       LCD4_MONO,
       LCD2_MONO,
       CRT256_C,
       LCDCRT
};

STATIC struct hd64461video_chip {
       struct video_chip vc;
       enum hd64461video_display_mode mode;
       struct hpcfb_dspconf hd;
       struct hpcfb_fbconf hf;
       uint8_t *off_screen_addr;
       size_t off_screen_size;

       struct callout unblank_ch;
       int blanked;

       int console;
} hd64461video_chip;

void    hd64461video_cnprobe(struct consdev *);
void    hd64461video_cninit(struct consdev *);

STATIC int hd64461video_match(device_t, cfdata_t, void *);
STATIC void hd64461video_attach(device_t, device_t, void *);

STATIC void hd64461video_setup_hpcfbif(struct hd64461video_chip *);
STATIC void hd64461video_update_videochip_status(struct hd64461video_chip *);
STATIC size_t hd64461video_frame_buffer_size(struct hd64461video_chip *);
STATIC void hd64461video_hwaccel_init(struct hd64461video_chip *);

STATIC void hd64461video_set_clut(struct hd64461video_chip *, int, int,
   uint8_t *, uint8_t *, uint8_t *);
STATIC void hd64461video_get_clut(struct hd64461video_chip *, int, int,
   uint8_t *, uint8_t *, uint8_t *);
STATIC int hd64461video_power(void *, int, long, void *);
STATIC void hd64461video_off(struct hd64461video_chip *);
STATIC void hd64461video_on(struct hd64461video_chip *);
STATIC void hd64461video_display_onoff(void *, bool);
STATIC void hd64461video_display_on(void *);

#if notyet
STATIC void hd64461video_set_display_mode(struct hd64461video_chip *);
STATIC void hd64461video_set_display_mode_lcdc(struct hd64461video_chip *);
STATIC void hd64461video_set_display_mode_crtc(struct hd64461video_chip *);
#endif

#ifdef HD64461VIDEO_DEBUG
STATIC void hd64461video_info(struct hd64461video_softc *);
STATIC void hd64461video_dump(void) __attribute__((__unused__));
#endif

CFATTACH_DECL_NEW(hd64461video, sizeof(struct hd64461video_softc),
   hd64461video_match, hd64461video_attach, NULL, NULL);

STATIC int hd64461video_ioctl(void *, u_long, void *, int, struct lwp *);
STATIC paddr_t hd64461video_mmap(void *, off_t, int);

#ifdef HD64461VIDEO_HWACCEL
STATIC void hd64461video_cursor(void *, int, int, int, int, int);
STATIC void hd64461video_bitblit(void *, int, int, int, int, int, int);
STATIC void hd64461video_erase(void *, int, int, int, int, int);
STATIC void hd64461video_putchar(void *, int, int, struct wsdisplay_font *,
   int, int, uint, int);
STATIC void hd64461video_setclut(void *, struct rasops_info *);
STATIC void hd64461video_font(void *, struct wsdisplay_font *);
STATIC void hd64461video_iodone(void *);

/* font */
STATIC void hd64461video_font_load_16bpp(uint16_t *, uint8_t *, int, int, int);
STATIC void hd64461video_font_load_8bpp(uint8_t *, uint8_t *, int, int, int);
STATIC void hd64461video_font_set_attr(struct hd64461video_softc *,
   struct wsdisplay_font *);
STATIC void hd64461video_font_load(struct hd64461video_softc *);
STATIC vaddr_t hd64461video_font_start_addr(struct hd64461video_softc *, int);
#endif /* HD64461VIDEO_HWACCEL */

STATIC struct hpcfb_accessops hd64461video_ha = {
       .ioctl  = hd64461video_ioctl,
       .mmap   = hd64461video_mmap,
#ifdef HD64461VIDEO_HWACCEL
       .cursor = hd64461video_cursor,
       .bitblit= hd64461video_bitblit,
       .erase  = hd64461video_erase,
       .putchar= hd64461video_putchar,
       .setclut= hd64461video_setclut,
       .font   = hd64461video_font,
       .iodone = hd64461video_iodone
#endif /* HD64461VIDEO_HWACCEL */
};


STATIC int
hd64461video_match(device_t parent, cfdata_t cf, void *aux)
{
       struct hd64461_attach_args *ha = aux;

       return (ha->ha_module_id == HD64461_MODULE_VIDEO);
}

STATIC void
hd64461video_attach(device_t parent, device_t self, void *aux)
{
       struct hd64461_attach_args *ha = aux;
       struct hd64461video_softc *sc;
       struct hpcfb_attach_args hfa;
       struct video_chip *vc = &hd64461video_chip.vc;
       char pbuf[9];
       size_t fbsize, on_screen_size;

       aprint_naive("\n");
       aprint_normal(": ");

       sc = device_private(self);
       sc->sc_dev = self;

       sc->sc_module_id = ha->ha_module_id;
       sc->sc_vc = &hd64461video_chip;

       /* detect frame buffer size */
       fbsize = hd64461video_frame_buffer_size(&hd64461video_chip);
       format_bytes(pbuf, sizeof(pbuf), fbsize);
       aprint_normal("frame buffer = %s ", pbuf);

       /* update chip status */
       hd64461video_update_videochip_status(&hd64461video_chip);

       hd64461video_display_onoff(&hd64461video_chip, true);
//      hd64461video_set_display_mode(&hd64461video_chip);

       if (hd64461video_chip.console)
               aprint_normal(", console");

       aprint_normal("\n");
#ifdef HD64461VIDEO_DEBUG
       hd64461video_info(sc);
       hd64461video_dump();
#endif
       /* Add a hard power hook to power saving */
       config_hook(CONFIG_HOOK_PMEVENT, CONFIG_HOOK_PMEVENT_HARDPOWER,
           CONFIG_HOOK_SHARE, hd64461video_power, sc);

       /* setup hpcfb interface */
       hd64461video_setup_hpcfbif(&hd64461video_chip);

       /* setup off-screen buffer */
       on_screen_size = (vc->vc_fbwidth * vc->vc_fbheight * vc->vc_fbdepth) /
           NBBY;
       hd64461video_chip.off_screen_addr = (uint8_t *)vc->vc_fbvaddr +
           on_screen_size;
       hd64461video_chip.off_screen_size = fbsize - on_screen_size;
       /* clean up off-screen area */
       {
               uint8_t *p = hd64461video_chip.off_screen_addr;
               uint8_t *end = p + hd64461video_chip.off_screen_size;
               while (p < end)
                       *p++ = 0xff;
       }

       /* initialize hardware acceralation */
       hd64461video_hwaccel_init(&hd64461video_chip);

       /* register interface to hpcfb */
       hfa.ha_console     = hd64461video_chip.console;
       hfa.ha_accessops   = &hd64461video_ha;
       hfa.ha_accessctx   = sc;
       hfa.ha_curfbconf   = 0;
       hfa.ha_nfbconf     = 1;
       hfa.ha_fbconflist  = &hd64461video_chip.hf;
       hfa.ha_curdspconf  = 0;
       hfa.ha_ndspconf    = 1;
       hfa.ha_dspconflist = &hd64461video_chip.hd;

       config_found(self, &hfa, hpcfbprint, CFARGS_NONE);

       /*
        * XXX: TODO: for now this device manages power using
        * config_hook(9) registered with hpcapm(4).
        *
        * We cannot yet switch it to pmf(9) hooks because only apm(4)
        * uses them, apmdev(4) doesn't, but hpcapm(4) is the parent
        * device for both, so its hooks are always run.
        *
        * We probably want to register shutdown hook with pmf(9) to
        * make sure display is powered on before we reboot in case we
        * end up in ddb early on.
        */
       if (!pmf_device_register(self, NULL, NULL))
               aprint_error_dev(self, "unable to establish power handler\n");
}

/* console support */
void
hd64461video_cninit(struct consdev *cndev)
{
       hd64461video_chip.console = 1;
       hd64461video_chip.vc.vc_reverse = video_reverse_color();

       hd64461video_update_videochip_status(&hd64461video_chip);
       hd64461video_setup_hpcfbif(&hd64461video_chip);
       hpcfb_cnattach(&hd64461video_chip.hf);

       cn_tab->cn_pri = CN_INTERNAL;
}

void
hd64461video_cnprobe(struct consdev *cndev)
{
#if NWSDISPLAY > 0
       extern const struct cdevsw wsdisplay_cdevsw;
       int maj, unit;
#endif
       cndev->cn_dev = NODEV;
       cndev->cn_pri = CN_NORMAL;

#if NWSDISPLAY > 0
       unit = 0;
       maj = cdevsw_lookup_major(&wsdisplay_cdevsw);

       if (maj != -1) {
               cndev->cn_pri = CN_INTERNAL;
               cndev->cn_dev = makedev(maj, unit);
       }
#endif /* NWSDISPLAY > 0 */
}

/* hpcfb support */
STATIC void
hd64461video_setup_hpcfbif(struct hd64461video_chip *hvc)
{
       struct video_chip *vc = &hvc->vc;
       struct hpcfb_fbconf *fb = &hvc->hf;
       vaddr_t fbvaddr = vc->vc_fbvaddr;
       int height = vc->vc_fbheight;
       int width = vc->vc_fbwidth;
       int depth = vc->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, "HD64461 video module", 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 -
           sh3_ptob(sh3_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 (vc->vc_reverse)
               fb->hf_access_flags |= HPCFB_ACCESS_REVERSE;

       switch (depth) {
       default:
               panic("%s: not supported color depth", __func__);
               /* 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;
               /*
                * XXX: uwe: if I RTFS correctly, this really means
                * that uint16_t pixel is fetched as little endian.
                */
               fb->hf_order_flags = HPCFB_REVORDER_BYTE;

               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;
       }
}

STATIC void
hd64461video_hwaccel_init(struct hd64461video_chip *hvc)
{
       uint16_t r;

       r = HD64461_LCDGRCFGR_ACCRESET;
       switch (hvc->vc.vc_fbdepth) {
       default:
               panic("no bitblit acceralation.");
       case 16:
               break;
       case 8:
               r |= HD64461_LCDGRCFGR_COLORDEPTH_8BPP;
               break;
       }
       hd64461_reg_write_2(HD64461_LCDGRCFGR_REG16, r);

       while ((hd64461_reg_read_2(HD64461_LCDGRCFGR_REG16) &
           HD64461_LCDGRCFGR_ACCSTATUS) != 0)
               continue;

       r &= ~HD64461_LCDGRCFGR_ACCRESET;
       hd64461_reg_write_2(HD64461_LCDGRCFGR_REG16, r);

       while ((hd64461_reg_read_2(HD64461_LCDGRCFGR_REG16) &
           HD64461_LCDGRCFGR_ACCSTATUS) != 0)
               continue;

       hd64461_reg_write_2(HD64461_LCDGRDOR_REG16,
           (hvc->vc.vc_fbwidth - 1) & HD64461_LCDGRDOR_MASK);
}

/* hpcfb ops */
STATIC int
hd64461video_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l)
{
       struct hd64461video_softc *sc = (struct hd64461video_softc *)v;
       struct hpcfb_fbconf *hf = &sc->sc_vc->hf;
       struct hpcfb_fbconf *fbconf;
       struct hpcfb_dspconf *dspconf;
       struct wsdisplay_cmap *cmap;
       struct wsdisplay_param *dispparam;
       long id, idmax;
       int turnoff;
       uint8_t *r, *g, *b;
       int error;
       size_t idx, cnt;

       switch (cmd) {
       case WSDISPLAYIO_GVIDEO:
               *(u_int *)data = sc->sc_vc->blanked ?
                   WSDISPLAYIO_VIDEO_OFF : WSDISPLAYIO_VIDEO_ON;
               return (0);

       case WSDISPLAYIO_SVIDEO:
               turnoff = (*(u_int *)data == WSDISPLAYIO_VIDEO_OFF);
               if (sc->sc_vc->blanked != turnoff) {
                       sc->sc_vc->blanked = turnoff;
                       if (turnoff)
                               hd64461video_off(sc->sc_vc);
                       else
                               hd64461video_on(sc->sc_vc);
               }

               return (0);

       case WSDISPLAYIO_GETPARAM:
               dispparam = (struct wsdisplay_param *)data;
               dispparam->min = 0;
               switch (dispparam->param) {
               case WSDISPLAYIO_PARAM_BACKLIGHT:
                       id = CONFIG_HOOK_POWER_LCDLIGHT;
                       idmax = -1;
                       dispparam->max = ~0;
                       break;
               case WSDISPLAYIO_PARAM_BRIGHTNESS:
                       id = CONFIG_HOOK_BRIGHTNESS;
                       idmax = CONFIG_HOOK_BRIGHTNESS_MAX;
                       break;
               case WSDISPLAYIO_PARAM_CONTRAST:
                       id = CONFIG_HOOK_CONTRAST;
                       idmax = CONFIG_HOOK_CONTRAST_MAX;
                       break;
               default:
                       return (EINVAL);
               }

               if (idmax >= 0) {
                       error = config_hook_call(CONFIG_HOOK_GET, idmax,
                                                &dispparam->max);
                       if (error)
                               return (error);
               }
               return config_hook_call(CONFIG_HOOK_GET, id,
                                       &dispparam->curval);

       case WSDISPLAYIO_SETPARAM:
               dispparam = (struct wsdisplay_param *)data;
               switch (dispparam->param) {
               case WSDISPLAYIO_PARAM_BACKLIGHT:
                       id = CONFIG_HOOK_POWER_LCDLIGHT;
                       break;
               case WSDISPLAYIO_PARAM_BRIGHTNESS:
                       id = CONFIG_HOOK_BRIGHTNESS;
                       break;
               case WSDISPLAYIO_PARAM_CONTRAST:
                       id = CONFIG_HOOK_CONTRAST;
                       break;
               default:
                       return (EINVAL);
               }
               return config_hook_call(CONFIG_HOOK_SET, id,
                                       &dispparam->curval);

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

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

               error = cmap_work_alloc(&r, &g, &b, 0, cnt);
               if (error)
                       goto out;
               hd64461video_get_clut(sc->sc_vc, idx, cnt, r, g, b);
               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, 0);
               return error;

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

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

               error = cmap_work_alloc(&r, &g, &b, 0, 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;
               hd64461video_set_clut(sc->sc_vc, idx, cnt, r, g, b);
               goto out;

       case HPCFBIO_GCONF:
               fbconf = (struct hpcfb_fbconf *)data;
               if (fbconf->hf_conf_index != 0 &&
                   fbconf->hf_conf_index != HPCFB_CURRENT_CONFIG) {
                       return (EINVAL);
               }
               *fbconf = *hf;  /* 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_vc->hd;       /* 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);
}

STATIC paddr_t
hd64461video_mmap(void *ctx, off_t offset, int prot)
{
       struct hd64461video_softc *sc = (struct hd64461video_softc *)ctx;
       struct hpcfb_fbconf *hf = &sc->sc_vc->hf;

       if (offset < 0 || (hf->hf_bytes_per_plane + hf->hf_offset) < offset)
               return (-1);

       return (sh3_btop(HD64461_FBBASE + offset));
}


#ifdef HD64461VIDEO_HWACCEL

STATIC void
hd64461video_cursor(void *ctx, int on, int xd, int yd, int w, int h)
{
       struct hd64461video_softc *sc = (struct hd64461video_softc *)ctx;
       int xw, yh, width, bpp, adr;
       uint16_t r;

       width = sc->sc_vc->vc.vc_fbwidth;
       bpp = sc->sc_vc->vc.vc_fbdepth;
       xw = w - 1;
       yh = h - 1;

       /* Wait until previous command done. */
       hd64461video_iodone(ctx);

       /* Destination addr */
       adr = width * yd + xd;
       if (bpp == 16)
               adr *= 2;
       hd64461_reg_write_2(HD64461_LCDBBTDSARH_REG16,
           HD64461_LCDBBTDSARH(adr));
       hd64461_reg_write_2(HD64461_LCDBBTDSARL_REG16,
           HD64461_LCDBBTDSARL(adr));

       // Width
       hd64461_reg_write_2(HD64461_LCDBBTDWR_REG16,
           xw & HD64461_LCDBBTDWR_MASK);

       // Height
       hd64461_reg_write_2(HD64461_LCDBBTDHR_REG16,
           yh & HD64461_LCDBBTDHR_MASK);

       // Operation (Destination Invert)
       hd64461_reg_write_2(HD64461_LCDBBTROPR_REG16,
           HD64461_LCDC_BITBLT_DSTINVERT);

       // BitBLT mode (Destination Invert)
       hd64461_reg_write_2(HD64461_LCDBBTMDR_REG16, 0);

       // Kick.
       r = hd64461_reg_read_2(HD64461_LCDGRCFGR_REG16);
       r &= ~HD64461_LCDGRCFGR_ACCSTART_MASK;
       r |= HD64461_LCDGRCFGR_ACCSTART_BITBLT;
       hd64461_reg_write_2(HD64461_LCDGRCFGR_REG16, r);
}

STATIC void
hd64461video_bitblit(void *ctx, int xs, int ys, int xd, int yd, int h, int w)
{
       struct hd64461video_softc *sc = (struct hd64461video_softc *)ctx;
       int xw, yh, width, bpp, condition_a, adr;
       uint16_t r;

       xw = w - 1;
       yh = h - 1;
       width = sc->sc_vc->vc.vc_fbwidth;
       bpp = sc->sc_vc->vc.vc_fbdepth;
       condition_a = ((ys == yd) && (xs <= xd)) || (ys < yd);

       hd64461video_iodone(ctx);

       // Source addr
       if (condition_a)
               adr = (width * (ys + yh)) + (xs + xw);
       else
               adr = width * ys + xs;
       if (bpp == 16)
               adr *= 2;

       hd64461_reg_write_2(HD64461_LCDBBTSSARH_REG16,
           HD64461_LCDBBTSSARH(adr));
       hd64461_reg_write_2(HD64461_LCDBBTSSARL_REG16,
           HD64461_LCDBBTSSARL(adr));

       // Destination addr
       if (condition_a)
               adr = (width * (yd + yh)) + (xd + xw);
       else
               adr = width * yd + xd;
       if (bpp == 16)
               adr *= 2;

       hd64461_reg_write_2(HD64461_LCDBBTDSARH_REG16,
           HD64461_LCDBBTDSARH(adr));
       hd64461_reg_write_2(HD64461_LCDBBTDSARL_REG16,
           HD64461_LCDBBTDSARL(adr));

       // Width
       hd64461_reg_write_2(HD64461_LCDBBTDWR_REG16,
           xw & HD64461_LCDBBTDWR_MASK);

       // Height
       hd64461_reg_write_2(HD64461_LCDBBTDHR_REG16,
           yh & HD64461_LCDBBTDHR_MASK);

       // Operation (source copy)
       hd64461_reg_write_2(HD64461_LCDBBTROPR_REG16,
           HD64461_LCDC_BITBLT_SRCCOPY);

       // BitBLT mode (on screen to on screen)
       r = HD64461_LCDBBTMDR_SET(0,
           HD64461_LCDBBTMDR_ON_SCREEN_TO_ON_SCREEN);
       if (condition_a)        /* reverse direction */
           r |= HD64461_LCDBBTMDR_SCANDRCT_RL_BT;
       hd64461_reg_write_2(HD64461_LCDBBTMDR_REG16, r);

       // Kick.
       r = hd64461_reg_read_2(HD64461_LCDGRCFGR_REG16);
       r &= ~HD64461_LCDGRCFGR_ACCSTART_MASK;
       r |= HD64461_LCDGRCFGR_ACCSTART_BITBLT;
       hd64461_reg_write_2(HD64461_LCDGRCFGR_REG16, r);
}

STATIC void
hd64461video_erase(void *ctx, int xd, int yd, int h, int w, int attr)
{
       struct hd64461video_softc *sc = (struct hd64461video_softc *)ctx;
       int xw, yh, width, bpp, adr;
       uint16_t r;

       width = sc->sc_vc->vc.vc_fbwidth;
       bpp = sc->sc_vc->vc.vc_fbdepth;
       xw = w - 1;
       yh = h - 1;

       /* Wait until previous command done. */
       hd64461video_iodone(ctx);

       /* Destination addr */
       adr = width * yd + xd;
       if (bpp == 16)
               adr *= 2;
       hd64461_reg_write_2(HD64461_LCDBBTDSARH_REG16,
           HD64461_LCDBBTDSARH(adr));
       hd64461_reg_write_2(HD64461_LCDBBTDSARL_REG16,
           HD64461_LCDBBTDSARL(adr));

       // Width
       hd64461_reg_write_2(HD64461_LCDBBTDWR_REG16,
           xw & HD64461_LCDBBTDWR_MASK);

       // Height
       hd64461_reg_write_2(HD64461_LCDBBTDHR_REG16,
           yh & HD64461_LCDBBTDHR_MASK);

       // Color
       hd64461_reg_write_2(HD64461_LCDGRSCR_REG16, 0); //XXX black only

       // Operation (Solid Color Fill)
       hd64461_reg_write_2(HD64461_LCDBBTROPR_REG16,
           HD64461_LCDC_BITBLT_PATCOPY);

       // BitBLT mode (Solid Color)
       hd64461_reg_write_2(HD64461_LCDBBTMDR_REG16,
           HD64461_LCDBBTMDR_PATSELECT_SOLIDCOLOR);

       // Kick.
       r = hd64461_reg_read_2(HD64461_LCDGRCFGR_REG16);
       r &= ~HD64461_LCDGRCFGR_ACCSTART_MASK;
       r |= HD64461_LCDGRCFGR_ACCSTART_BITBLT;
       hd64461_reg_write_2(HD64461_LCDGRCFGR_REG16, r);
}

STATIC void
hd64461video_putchar(void *ctx, int row, int col, struct wsdisplay_font *font,
   int fclr, int uclr, u_int uc, int attr)
{
       struct hd64461video_softc *sc = (struct hd64461video_softc *)ctx;
       int w, h, cw;

       w = font->fontwidth;
       h = font->fontheight;
       cw = sc->sc_font.cw;
       hd64461video_bitblit(ctx, (uc % cw) * w,
           sc->sc_vc->vc.vc_fbheight + (uc / cw) * h, row, col, h, w);
}

STATIC void
hd64461video_setclut(void *ctx, struct rasops_info *info)
{
       struct hd64461video_softc *sc = (struct hd64461video_softc *)ctx;

       if (sc->sc_vc->vc.vc_fbdepth != 8)
               return;
}

STATIC void
hd64461video_font(void *ctx, struct wsdisplay_font *font)
{
       struct hd64461video_softc *sc = (struct hd64461video_softc *)ctx;

       hd64461video_font_set_attr(sc, font);
       hd64461video_font_load(sc);
}

STATIC void
hd64461video_iodone(void *ctx)
{

       while ((hd64461_reg_read_2(HD64461_LCDGRCFGR_REG16) &
           HD64461_LCDGRCFGR_ACCSTATUS) != 0)
               continue;
}

/* internal */
STATIC void
hd64461video_font_load_16bpp(uint16_t *d, uint8_t *s, int w, int h, int step)
{
       int i, j, n;
       n = step / sizeof(uint16_t);

       for (i = 0; i < h; i++, d += n) {
               for (j = 0; j < w; j++) {
                       d[j] = *s & (1 << (w - j - 1)) ? 0xffff : 0x0000;
               }
               s++;
       }
}

STATIC void
hd64461video_font_load_8bpp(uint8_t *d, uint8_t *s, int w, int h, int step)
{
       int i, j, n;
       n = step / sizeof(uint8_t);

       for (i = 0; i < h; i++, d += n) {
               for (j = 0; j < w; j++) {
                       d[j] = *s & (1 << (w - j - 1)) ? 0xff : 0x00;
               }
               s++;
       }
}

STATIC void
hd64461video_font_set_attr(struct hd64461video_softc *sc,
   struct wsdisplay_font *f)
{
       struct hd64461video_chip *hvc = sc->sc_vc;
       struct wsdisplay_font *font = &sc->sc_font.wsfont;
       int w, h, bpp;

       w       = f->fontwidth;
       h       = f->fontheight;
       bpp     = hvc->vc.vc_fbdepth;

       *font = *f;
       sc->sc_font.c = (w * bpp) / NBBY;
       sc->sc_font.cw = hvc->hf.hf_width / w;
       sc->sc_font.cstep = ((w * h * bpp) / NBBY) * sc->sc_font.cw;

       DPRINTF("c = %d cw = %d cstep = %d\n", sc->sc_font.c,
           sc->sc_font.cw, sc->sc_font.cstep);

}

/* return frame buffer virtual address of character #n */
STATIC vaddr_t
hd64461video_font_start_addr(struct hd64461video_softc *sc, int n)
{
       struct hd64461video_chip *hvc = sc->sc_vc;
       struct hd64461video_font *font = &sc->sc_font;
       vaddr_t base;

       base = (vaddr_t)hvc->off_screen_addr;
       base += (n / font->cw) * font->cstep + font->c * (n % font->cw);

       return base;
}

STATIC void
hd64461video_font_load(struct hd64461video_softc *sc)
{
       struct hd64461video_chip *hvc = sc->sc_vc;
       struct wsdisplay_font *font = &sc->sc_font.wsfont;
       uint8_t *q;
       int w, h, step, i, n;

       if (sc->sc_font.loaded) {
               printf("reload font\n");
       }

       w       = font->fontwidth;
       h       = font->fontheight;
       step    = sc->sc_font.cw * sc->sc_font.c;
       n       = (w * h) / NBBY;
       q       = font->data;

       DPRINTF("%s (%dx%d) %d+%d\n", font->name, w, h, font->firstchar,
           font->numchars);
       DPRINTF("bitorder %d byteorder %d stride %d\n", font->bitorder,
           font->byteorder, font->stride);

       switch (hvc->vc.vc_fbdepth) {
       case 8:
               for (i = font->firstchar; i < font->numchars; i++) {
                       hd64461video_font_load_8bpp
                           ((uint8_t *)hd64461video_font_start_addr(sc, i),
                               q, w, h, step);
                       q += n;
               }
               break;
       case 16:
               for (i = font->firstchar; i < font->numchars; i++) {
                       hd64461video_font_load_16bpp
                           ((uint16_t *)hd64461video_font_start_addr(sc, i),
                               q, w, h, step);
                       q += n;
               }
               break;
       }

       sc->sc_font.loaded = true;
}
#endif /* HD64461VIDEO_HWACCEL */

STATIC void
hd64461video_update_videochip_status(struct hd64461video_chip *hvc)
{
       struct video_chip *vc = &hvc->vc;
       uint16_t r;
       int i;
       int depth, width, height;

       depth = 0;              /* XXX: -Wuninitialized */

       /* display mode */
       r = hd64461_reg_read_2(HD64461_LCDLDR3_REG16);
       i = HD64461_LCDLDR3_CG(r);
       switch (i) {
       case HD64461_LCDLDR3_CG_COLOR16:
               depth = 16;
               hvc->mode = LCD64K_C;
               break;
       case HD64461_LCDLDR3_CG_COLOR8:
               depth = 8;
               hvc->mode = LCD256_C;
               break;
       case HD64461_LCDLDR3_CG_GRAY6:
               depth = 6;
               hvc->mode = LCD64_MONO;
               break;
       case HD64461_LCDLDR3_CG_GRAY4:
               depth = 4;
               hvc->mode = LCD16_MONO;
               break;
       case HD64461_LCDLDR3_CG_GRAY2:
               depth = 2;
               hvc->mode = LCD4_MONO;
               break;
       case HD64461_LCDLDR3_CG_GRAY1:
               depth = 1;
               hvc->mode = LCD2_MONO;
               break;
       }

       r = hd64461_reg_read_2(HD64461_LCDCCR_REG16);
       i = HD64461_LCDCCR_DSPSEL(i);
       switch (i) {
       case HD64461_LCDCCR_DSPSEL_LCD_CRT:
               depth = 8;
               hvc->mode = LCDCRT;
               break;
       case HD64461_LCDCCR_DSPSEL_CRT:
               depth = 8;
               hvc->mode = CRT256_C;
               break;
       case HD64461_LCDCCR_DSPSEL_LCD:
               /* nothing to do */
               break;
       }

       callout_init(&hvc->unblank_ch, 0);
       hvc->blanked = 0;

       width = bootinfo->fb_width;
       height = bootinfo->fb_height;

       vc->vc_fbvaddr  = HD64461_FBBASE;
       vc->vc_fbpaddr  = HD64461_FBBASE;
       vc->vc_fbdepth  = depth;
       vc->vc_fbsize   = (width * height * depth) / NBBY;
       vc->vc_fbwidth  = width;
       vc->vc_fbheight = height;
}

#if notyet
STATIC void
hd64461video_set_display_mode(struct hd64461video_chip *hvc)
{

       if (hvc->mode == LCDCRT || hvc->mode == CRT256_C)
               hd64461video_set_display_mode_crtc(hvc);

       hd64461video_set_display_mode_lcdc(hvc);
}

STATIC void
hd64461video_set_display_mode_lcdc(struct hd64461video_chip *hvc)
{
       struct {
               uint16_t clor;  /* display size 640 x 240 */
               uint16_t ldr3;
               const char *name;
       } *conf, disp_conf[] = {
               [LCD256_C]      = { 640, HD64461_LCDLDR3_CG_COLOR8,
                                   "8bit color" },
               [LCD64K_C]      = { 640 * 2, HD64461_LCDLDR3_CG_COLOR16,
                                   "16bit color" },
               [LCD64_MONO]    = { 640, HD64461_LCDLDR3_CG_GRAY6 ,
                                   "6bit grayscale" },
               [LCD16_MONO]    = { 640 / 2, HD64461_LCDLDR3_CG_GRAY4,
                                   "4bit grayscale" },
               [LCD4_MONO]     = { 640 / 4, HD64461_LCDLDR3_CG_GRAY2,
                                   "2bit grayscale" },
               [LCD2_MONO]     = { 640 / 8, HD64461_LCDLDR3_CG_GRAY1,
                                   "monochrome" },
       };
       uint16_t r;
       int omode;

       conf = &disp_conf[hvc->mode];

       hd64461_reg_write_2(HD64461_LCDCLOR_REG16, conf->clor);
       r = hd64461_reg_read_2(HD64461_LCDLDR3_REG16);
       omode = HD64461_LCDLDR3_CG(r);
       r = HD64461_LCDLDR3_CG_CLR(r);
       r = HD64461_LCDLDR3_CG_SET(r, conf->ldr3);
       hd64461_reg_write_2(HD64461_LCDLDR3_REG16, r);

       printf("%s ", conf->name);
}

STATIC void
hd64461video_set_display_mode_crtc(struct hd64461video_chip *hvc)
{
       /* not yet */
}

#endif /* notyet */

STATIC size_t
hd64461video_frame_buffer_size(struct hd64461video_chip *hvc)
{
       vaddr_t page, startaddr, endaddr;
       int x;

       startaddr = HD64461_FBBASE;
       endaddr = startaddr + HD64461_FBSIZE - 1;

       page = startaddr;

       x = random();
       *(volatile int *)(page + 0) = x;
       *(volatile int *)(page + 4) = ~x;

       if (*(volatile int *)(page + 0) != x ||
           *(volatile int *)(page + 4) != ~x)
               return (0);

       for (page += HD64461_FBPAGESIZE; page < endaddr;
           page += HD64461_FBPAGESIZE) {
               if (*(volatile int *)(page + 0) == x &&
                   *(volatile int *)(page + 4) == ~x)
                       goto fbend_found;
       }

       page -= HD64461_FBPAGESIZE;
       *(volatile int *)(page + 0) = x;
       *(volatile int *)(page + 4) = ~x;

       if (*(volatile int *)(page + 0) != x ||
           *(volatile int *)(page + 4) != ~x)
               return (0);

fbend_found:
       return (page - startaddr);
}

STATIC void
hd64461video_set_clut(struct hd64461video_chip *vc, int idx, int cnt,
   uint8_t *r, uint8_t *g, uint8_t *b)
{
       KASSERT(r && g && b);

       /* index palette */
       hd64461_reg_write_2(HD64461_LCDCPTWAR_REG16,
           HD64461_LCDCPTWAR_SET(0, idx));
       /* set data */
       while (cnt && LEGAL_CLUT_INDEX(idx)) {
               uint16_t v;
#define HD64461VIDEO_SET_CLUT(x)                                        \
               v = (x >> 2) & 0x3f;                                    \
               hd64461_reg_write_2(HD64461_LCDCPTWDR_REG16, v)
               HD64461VIDEO_SET_CLUT(*r);
               HD64461VIDEO_SET_CLUT(*g);
               HD64461VIDEO_SET_CLUT(*b);
#undef  HD64461VIDEO_SET_CLUT
               r++, g++, b++;
               idx++, cnt--;
       }
}

STATIC void
hd64461video_get_clut(struct hd64461video_chip *vc, int idx, int cnt,
   uint8_t *r, uint8_t *g, uint8_t *b)
{
       KASSERT(r && g && b);

       /* index palette */
       hd64461_reg_write_2(HD64461_LCDCPTRAR_REG16,
           HD64461_LCDCPTRAR_SET(0, idx));

       /* get data */
       while (cnt && LEGAL_CLUT_INDEX(idx)) {
               uint16_t v;
#define HD64461VIDEO_GET_CLUT(x)                                        \
       v = hd64461_reg_read_2(HD64461_LCDCPTRDR_REG16);                \
       x = HD64461_LCDCPTRDR(v);                                       \
       x <<= 2
               HD64461VIDEO_GET_CLUT(*r);
               HD64461VIDEO_GET_CLUT(*g);
               HD64461VIDEO_GET_CLUT(*b);
#undef  HD64461VIDEO_GET_CLUT
               r++, g++, b++;
               idx++, cnt--;
       }
}

STATIC int
hd64461video_power(void *ctx, int type, long id, void *msg)
{
       struct hd64461video_softc *sc = ctx;
       struct hd64461video_chip *hvc = sc->sc_vc;

       switch ((int)msg) {
       case PWR_RESUME:
               DPRINTF("%s: ON%s\n", device_xname(sc->sc_dev),
                       sc->sc_vc->blanked ? " (blanked)" : "");
               if (!sc->sc_vc->blanked)
                       hd64461video_on(hvc);
               break;
       case PWR_SUSPEND:
               /* FALLTHROUGH */
       case PWR_STANDBY:
               DPRINTF("%s: OFF\n", device_xname(sc->sc_dev));
               hd64461video_off(hvc);
               break;
       }

       return 0;
}

STATIC void
hd64461video_off(struct hd64461video_chip *vc)
{

       callout_stop(&vc->unblank_ch);

       /* turn off display in LCDC */
       hd64461video_display_onoff(vc, false);

       /* turn off the LCD */
       config_hook_call(CONFIG_HOOK_POWERCONTROL,
                        CONFIG_HOOK_POWERCONTROL_LCD,
                        (void *)0);
}

STATIC void
hd64461video_on(struct hd64461video_chip *vc)
{
       int err;

       /* turn on the LCD */
       err = config_hook_call(CONFIG_HOOK_POWERCONTROL,
                              CONFIG_HOOK_POWERCONTROL_LCD,
                              (void *)1);

       if (err == 0)
               /* let the LCD warm up before turning on the display */
               callout_reset(&vc->unblank_ch, hz/2,
                   hd64461video_display_on, vc);
       else
               hd64461video_display_onoff(vc, true);
}

STATIC void
hd64461video_display_on(void *arg)
{

       hd64461video_display_onoff(arg, true);
}

STATIC void
hd64461video_display_onoff(void *arg, bool on)
{
       /* struct hd64461video_chip *vc = arg; */
       uint16_t r;

       if (platid_match(&platid, &platid_mask_MACH_HITACHI_PERSONA))
               return;

       /* turn on/off display in LCDC */
       r = hd64461_reg_read_2(HD64461_LCDLDR1_REG16);
       if (on)
               r |= HD64461_LCDLDR1_DON;
       else
               r &= ~HD64461_LCDLDR1_DON;
       hd64461_reg_write_2(HD64461_LCDLDR1_REG16, r);
}

#ifdef HD64461VIDEO_DEBUG
STATIC void
hd64461video_info(struct hd64461video_softc *sc)
{
       uint16_t r;
       int color;
       int i;

       dbg_banner_function();
       printf("---[LCD]---\n");
       /* Base Address Register */
       r = hd64461_reg_read_2(HD64461_LCDCBAR_REG16);
       printf("LCDCBAR Frame buffer base address (4KB align): 0x%08x\n",
           HD64461_LCDCBAR_BASEADDR(r));

       /* Line Address Offset Register */
       r = hd64461_reg_read_2(HD64461_LCDCLOR_REG16);
       printf("LCDCLOR Line address offset: %d\n", HD64461_LCDCLOR(r));

       /* LCDC Control Register */
       r = hd64461_reg_read_2(HD64461_LCDCCR_REG16);
       i = HD64461_LCDCCR_DSPSEL(r);
#define DBG_BITMASK_PRINT(r, m) dbg_bitmask_print(r, HD64461_LCDCCR_##m, #m)
       printf("LCDCCR (LCD Control Register)\n");
       DBG_BITMASK_PRINT(r, STBAK);
       DBG_BITMASK_PRINT(r, STREQ);
       DBG_BITMASK_PRINT(r, MOFF);
       DBG_BITMASK_PRINT(r, REFSEL);
       DBG_BITMASK_PRINT(r, EPON);
       DBG_BITMASK_PRINT(r, SPON);
       printf("\n");
#undef  DBG_BITMASK_PRINT
       printf("LCDCCR Display select LCD[%c] CRT[%c]\n",
           i == HD64461_LCDCCR_DSPSEL_LCD_CRT ||
           i == HD64461_LCDCCR_DSPSEL_LCD ? 'x' : '_',
           i == HD64461_LCDCCR_DSPSEL_LCD_CRT ||
           i == HD64461_LCDCCR_DSPSEL_CRT ? 'x' : '_');

       /* LCD Display Register */
       /* 1 */
       r = hd64461_reg_read_2(HD64461_LCDLDR1_REG16);
       printf("(LCD Display Register)\n");
#define DBG_BITMASK_PRINT(r, m) dbg_bitmask_print(r, HD64461_LCDLDR1_##m, #m)
       printf("LCDLDR1: ");
       DBG_BITMASK_PRINT(r, DINV);
       DBG_BITMASK_PRINT(r, DON);
       printf("\n");
#undef  DBG_BITMASK_PRINT
       /* 2 */
       r = hd64461_reg_read_2(HD64461_LCDLDR2_REG16);
       i = HD64461_LCDLDR2_LM(r);
#define DBG_BITMASK_PRINT(r, m) dbg_bitmask_print(r, HD64461_LCDLDR2_##m, #m)
       printf("LCDLDR2: ");
       DBG_BITMASK_PRINT(r, CC1);
       DBG_BITMASK_PRINT(r, CC2);
#undef  DBG_BITMASK_PRINT
       color = 0;
       switch (i) {
       default:
               panic("unknown unknown LCD interface.");
               break;
       case HD64461_LCDLDR2_LM_COLOR:
               color = 1;
               printf("Color");
               break;
       case HD64461_LCDLDR2_LM_GRAY8:
               printf("8-bit grayscale");
               break;
       case HD64461_LCDLDR2_LM_GRAY4:
               printf("4-bit grayscale");
               break;
       }
       printf(" LCD interface\n");
       /* 3 */
       printf("LCDLDR3: ");
       r = hd64461_reg_read_2(HD64461_LCDLDR3_REG16);
       i = HD64461_LCDLDR3_CS(r);
       printf("CS ");
       switch (i) {
       case 0:
               printf("15");
               break;
       case 1:
               printf("2.5");
               break;
       case 2:
               printf("3.75");
               break;
       case 4:
               printf("5");
               break;
       case 8:
               printf("7.5");
               break;
       case 16:
               printf("10");
               break;
       }
       printf("%s MHz ", color ? "" : "/2");
       i = HD64461_LCDLDR3_CG(r);
       switch (i) {
       case HD64461_LCDLDR3_CG_COLOR16:
               printf("Color 64K colors\n");
               break;
       case HD64461_LCDLDR3_CG_COLOR8:
               printf("Color 256 colors\n");
               break;
       case HD64461_LCDLDR3_CG_GRAY6:
               printf("6-bit Grayscale\n");
               break;
       case HD64461_LCDLDR3_CG_GRAY4:
               printf("4-bit Grayscale\n");
               break;
       case HD64461_LCDLDR3_CG_GRAY2:
               printf("2-bit Grayscale\n");
               break;
       case HD64461_LCDLDR3_CG_GRAY1:
               printf("1-bit Grayscale\n");
               break;
       }

       /* LCD Number of Characters in Horizontal Register */
       r = hd64461_reg_read_2(HD64461_LCDLDHNCR_REG16);
       printf("LDHNCR: NHD %d NHT %d (# of horizontal characters)\n",
           HD64461_LCDLDHNCR_NHD(r), HD64461_LCDLDHNCR_NHT(r));

       /* Start Position of Horizontal Register */
       r = hd64461_reg_read_2(HD64461_LCDLDHNSR_REG16);
       printf("LDHNSR: HSW %d HSP %d (start position of horizontal)\n",
           HD64461_LCDLDHNSR_HSW(r), HD64461_LCDLDHNSR_HSP(r));

       /* Total Vertical Lines Register */
       r = hd64461_reg_read_2(HD64461_LCDLDVNTR_REG16);
       printf("LDVNTR: %d (total vertical lines)\n",
           HD64461_LCDLDVNTR_VTL(r));

       /* Display Vertical Lines Register */
       r = hd64461_reg_read_2(HD64461_LCDLDVNDR_REG16);
       printf("LDVNDR: %d (display vertical lines)\n",
           HD64461_LCDLDVSPR_VSP(r));

       /* Vertical Synchronization Position Register */
       r = hd64461_reg_read_2(HD64461_LCDLDVSPR_REG16);
       printf("LDVSPR: %d (vertical synchronization position)\n",
           HD64461_LCDLDVSPR_VSP(r));

       /*
        * CRT Control Register
        */
       printf("---[CRT]---\n");
       r = hd64461_reg_read_2(HD64461_LCDCRTVTR_REG16);
       printf("CRTVTR: %d (CRTC total vertical lines)\n",
           HD64461_LCDCRTVTR(r));
       r = hd64461_reg_read_2(HD64461_LCDCRTVRSR_REG16);
       printf("CRTVRSR: %d (CRTC vertical retrace start line)\n",
           HD64461_LCDCRTVRSR(r));
       r = hd64461_reg_read_2(HD64461_LCDCRTVRER_REG16);
       printf("CRTVRER: %d (CRTC vertical retrace end line)\n",
           HD64461_LCDCRTVRER(r));

}

STATIC void
hd64461video_dump(void)
{
       uint16_t r;
       printf("---[Display Mode Setting]---\n");
#define DUMPREG(x)                                                      \
       r = hd64461_reg_read_2(HD64461_LCD ## x ## _REG16);             \
       __dbg_bit_print(r, sizeof(uint16_t), 0, 0, #x, DBG_BIT_PRINT_COUNT)
       DUMPREG(CBAR);
       DUMPREG(CLOR);
       DUMPREG(CCR);
       DUMPREG(LDR1);
       DUMPREG(LDR2);
       DUMPREG(LDHNCR);
       DUMPREG(LDHNSR);
       DUMPREG(LDVNTR);
       DUMPREG(LDVNDR);
       DUMPREG(LDVSPR);
       DUMPREG(LDR3);
       DUMPREG(CRTVTR);
       DUMPREG(CRTVRSR);
       DUMPREG(CRTVRER);
#undef  DUMPREG
       dbg_banner_line();
}

#endif /* HD64461VIDEO_DEBUG */