/*      $NetBSD: zx.c,v 1.47 2021/08/07 16:19:15 thorpej Exp $  */

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

/*
* Driver for the Sun ZX display adapter.  This would be called 'leo', but
* NetBSD/amiga already has a driver by that name.  The XFree86 and Linux
* drivers were used as "living documentation" when writing this; thanks
* to the authors.
*
* Issues (which can be solved with wscons, happily enough):
*
* o There is lots of unnecessary mucking about rasops in here, primarily
*   to appease the sparc fb code.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: zx.c,v 1.47 2021/08/07 16:19:15 thorpej Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/mman.h>
#include <sys/tty.h>
#include <sys/conf.h>
#include <sys/syslog.h>
#include <sys/buf.h>
#ifdef DEBUG
/* for log(9) in zxioctl() */
#include <sys/lwp.h>
#include <sys/proc.h>
#endif

#include <sys/bus.h>
#include <machine/autoconf.h>

#include <dev/sun/fbio.h>
#include <dev/sun/fbvar.h>

#include "wsdisplay.h"
#include <dev/wscons/wsconsio.h>
#include <dev/wsfont/wsfont.h>
#include <dev/rasops/rasops.h>
#include <dev/wscons/wsdisplay_vconsvar.h>

#include "opt_wsemul.h"

#include <dev/sbus/zxreg.h>
#include <dev/sbus/zxvar.h>
#include <dev/sbus/sbusvar.h>

#include <dev/wscons/wsconsio.h>

#include "ioconf.h"

#define ZX_STD_ROP      (ZX_ROP_NEW | ZX_ATTR_WE_ENABLE | \
   ZX_ATTR_OE_ENABLE | ZX_ATTR_FORCE_WID)

static void     zx_attach(device_t, device_t, void *);
static int      zx_match(device_t, cfdata_t, void *);

static void     zx_blank(device_t);
static int      zx_cmap_put(struct zx_softc *);
static void     zx_copyrect(struct zx_softc *, int, int, int, int, int, int);
static int      zx_cross_loadwid(struct zx_softc *, u_int, u_int, u_int);
static int      zx_cross_wait(struct zx_softc *);
static void     zx_fillrect(struct zx_softc *, int, int, int, int, uint32_t, int);
static int      zx_intr(void *);
static void     zx_reset(struct zx_softc *);
static void     zx_unblank(device_t);

static void     zx_cursor_blank(struct zx_softc *);
static void     zx_cursor_color(struct zx_softc *);
static void     zx_cursor_move(struct zx_softc *);
static void     zx_cursor_set(struct zx_softc *);
static void     zx_cursor_unblank(struct zx_softc *);

static void     zx_copycols(void *, int, int, int, int);
static void     zx_copyrows(void *, int, int, int);
static void     zx_do_cursor(void *, int, int, int);
static void     zx_erasecols(void *, int, int, int, long);
static void     zx_eraserows(void *, int, int, long);
static void     zx_putchar(void *, int, int, u_int, long);

struct zx_mmo {
       off_t   mo_va;
       off_t   mo_pa;
       off_t   mo_size;
} static const zx_mmo[] = {
       { ZX_FB0_VOFF,          ZX_OFF_SS0,             0x00800000 },
       { ZX_LC0_VOFF,          ZX_OFF_LC_SS0_USR,      0x00001000 },
       { ZX_LD0_VOFF,          ZX_OFF_LD_SS0,          0x00001000 },
       { ZX_LX0_CURSOR_VOFF,   ZX_OFF_LX_CURSOR,       0x00001000 },
       { ZX_FB1_VOFF,          ZX_OFF_SS1,             0x00800000 },
       { ZX_LC1_VOFF,          ZX_OFF_LC_SS1_USR,      0x00001000 },
       { ZX_LD1_VOFF,          ZX_OFF_LD_SS1,          0x00001000 },
       { ZX_LX_KRN_VOFF,       ZX_OFF_LX_CROSS,        0x00001000 },
       { ZX_LC0_KRN_VOFF,      ZX_OFF_LC_SS0_KRN,      0x00001000 },
       { ZX_LC1_KRN_VOFF,      ZX_OFF_LC_SS1_KRN,      0x00001000 },
       { ZX_LD_GBL_VOFF,       ZX_OFF_LD_GBL,          0x00001000 },
};

CFATTACH_DECL_NEW(zx, sizeof(struct zx_softc),
   zx_match, zx_attach, NULL, NULL);

static dev_type_open(zxopen);
static dev_type_close(zxclose);
static dev_type_ioctl(zxioctl);
static dev_type_mmap(zxmmap);

static struct fbdriver zx_fbdriver = {
       zx_unblank, zxopen, zxclose, zxioctl, nopoll, zxmmap
};

struct wsscreen_descr zx_defaultscreen = {
       "std",
       0, 0,   /* will be filled in -- XXX shouldn't, it's global */
               /* doesn't matter - you can't really have more than one leo */
       NULL,           /* textops */
       8, 16,  /* font width/height */
       WSSCREEN_WSCOLORS,      /* capabilities */
       NULL    /* modecookie */
};

static int      zx_ioctl(void *, void *, u_long, void *, int, struct lwp *);
static paddr_t  zx_mmap(void *, void *, off_t, int);
static void     zx_init_screen(void *, struct vcons_screen *, int, long *);

static int      zx_putcmap(struct zx_softc *, struct wsdisplay_cmap *);
static int      zx_getcmap(struct zx_softc *, struct wsdisplay_cmap *);

struct wsdisplay_accessops zx_accessops = {
       zx_ioctl,
       zx_mmap,
       NULL,   /* alloc_screen */
       NULL,   /* free_screen */
       NULL,   /* show_screen */
       NULL,   /* load_font */
       NULL,   /* pollc */
       NULL    /* scroll */
};

const struct wsscreen_descr *_zx_scrlist[] = {
       &zx_defaultscreen
};

struct wsscreen_list zx_screenlist = {
       sizeof(_zx_scrlist) / sizeof(struct wsscreen_descr *),
       _zx_scrlist
};


extern const u_char rasops_cmap[768];

static struct vcons_screen zx_console_screen;

static int
zx_match(device_t parent, cfdata_t cf, void *aux)
{
       struct sbus_attach_args *sa;

       sa = (struct sbus_attach_args *)aux;

       return (strcmp(sa->sa_name, "SUNW,leo") == 0);
}

static void
zx_attach(device_t parent, device_t self, void *args)
{
       struct zx_softc *sc;
       struct sbus_attach_args *sa;
       bus_space_handle_t bh;
       bus_space_tag_t bt;
       struct fbdevice *fb;
       struct wsemuldisplaydev_attach_args aa;
       struct rasops_info *ri = &zx_console_screen.scr_ri;
       unsigned long defattr;
       int isconsole, width, height;

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

       sa = args;
       fb = &sc->sc_fb;
       bt = sa->sa_bustag;
       sc->sc_bt = bt;
       sc->sc_paddr = sbus_bus_addr(bt, sa->sa_slot, sa->sa_offset);

       if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_SS0,
           0x800000, BUS_SPACE_MAP_LINEAR | BUS_SPACE_MAP_LARGE, &bh) != 0) {
               aprint_error_dev(self, "can't map bits\n");
               return;
       }
       fb->fb_pixels = (void *)bus_space_vaddr(bt, bh);
       sc->sc_pixels = (uint32_t *)fb->fb_pixels;

       if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LC_SS0_USR,
           PAGE_SIZE, BUS_SPACE_MAP_LINEAR, &bh) != 0) {
               aprint_error_dev(self, "can't map zc\n");
               return;
       }

       sc->sc_bhzc = bh;

       if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LD_SS0,
           PAGE_SIZE, BUS_SPACE_MAP_LINEAR, &bh) != 0) {
               aprint_error_dev(self, "can't map ld/ss0\n");
               return;
       }
       sc->sc_bhzdss0 = bh;

       if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LD_SS1,
           PAGE_SIZE, BUS_SPACE_MAP_LINEAR, &bh) != 0) {
               aprint_error_dev(self, "can't map ld/ss1\n");
               return;
       }
       sc->sc_bhzdss1 = bh;

       if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LX_CROSS,
           PAGE_SIZE, BUS_SPACE_MAP_LINEAR, &bh) != 0) {
               aprint_error_dev(self, "can't map zx\n");
               return;
       }
       sc->sc_bhzx = bh;

       if (sbus_bus_map(bt, sa->sa_slot, sa->sa_offset + ZX_OFF_LX_CURSOR,
           PAGE_SIZE, BUS_SPACE_MAP_LINEAR, &bh) != 0) {
               aprint_error_dev(self, "can't map zcu\n");
               return;
       }
       sc->sc_bhzcu = bh;

       fb->fb_driver = &zx_fbdriver;
       fb->fb_device = sc->sc_dv;
       fb->fb_flags = device_cfdata(sc->sc_dv)->cf_flags & FB_USERMASK;
       fb->fb_pfour = NULL;
       fb->fb_linebytes = prom_getpropint(sa->sa_node, "linebytes", 8192);

       width = prom_getpropint(sa->sa_node, "width", 1280);
       height = prom_getpropint(sa->sa_node, "height", 1024);
       fb_setsize_obp(fb, 32, width, height, sa->sa_node);

       fb->fb_type.fb_cmsize = 256;
       fb->fb_type.fb_depth = 32;
       fb->fb_type.fb_size = fb->fb_type.fb_height * fb->fb_linebytes;
       fb->fb_type.fb_type = FBTYPE_SUNLEO;

       printf(": %d x %d", fb->fb_type.fb_width, fb->fb_type.fb_height);
       isconsole = fb_is_console(sa->sa_node);
       if (isconsole)
               printf(" (console)");
       printf("\n");

       if (sa->sa_nintr != 0)
               bus_intr_establish(bt, sa->sa_pri, IPL_NONE, zx_intr, sc);

       sc->sc_cmap = malloc(768, M_DEVBUF, M_WAITOK);
       zx_reset(sc);

       sc->sc_width = fb->fb_type.fb_width;
       sc->sc_stride = 8192; /* 32 bit */
       sc->sc_height = fb->fb_type.fb_height;

       /* setup rasops and so on for wsdisplay */
       wsfont_init();
       sc->sc_mode = WSDISPLAYIO_MODE_EMUL;
       sc->sc_bg = WS_DEFAULT_BG;

       vcons_init(&sc->vd, sc, &zx_defaultscreen, &zx_accessops);
       sc->vd.init_screen = zx_init_screen;

       if (isconsole) {
               /* we mess with zx_console_screen only once */
               vcons_init_screen(&sc->vd, &zx_console_screen, 1,
                   &defattr);
               zx_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC;

               zx_defaultscreen.textops = &ri->ri_ops;
               zx_defaultscreen.capabilities = WSSCREEN_WSCOLORS;
               zx_defaultscreen.nrows = ri->ri_rows;
               zx_defaultscreen.ncols = ri->ri_cols;
               zx_fillrect(sc, 0, 0, width, height,
                    ri->ri_devcmap[defattr >> 16], ZX_STD_ROP);
               wsdisplay_cnattach(&zx_defaultscreen, ri, 0, 0, defattr);
               vcons_replay_msgbuf(&zx_console_screen);
       } else {
               /*
                * we're not the console so we just clear the screen and don't
                * set up any sort of text display
                */
               if (zx_defaultscreen.textops == NULL) {
                       /*
                        * ugly, but...
                        * we want the console settings to win, so we only
                        * touch anything when we find an untouched screen
                        * definition. In this case we fill it from fb to
                        * avoid problems in case no zx is the console
                        */
                       zx_defaultscreen.textops = &ri->ri_ops;
                       zx_defaultscreen.capabilities = ri->ri_caps;
                       zx_defaultscreen.nrows = ri->ri_rows;
                       zx_defaultscreen.ncols = ri->ri_cols;
               }
       }

       aa.scrdata = &zx_screenlist;
       aa.console = isconsole;
       aa.accessops = &zx_accessops;
       aa.accesscookie = &sc->vd;
       config_found(sc->sc_dv, &aa, wsemuldisplaydevprint, CFARGS_NONE);
       fb_attach(&sc->sc_fb, isconsole);
}

static int
zxopen(dev_t dev, int flags, int mode, struct lwp *l)
{

       if (device_lookup(&zx_cd, minor(dev)) == NULL)
               return (ENXIO);
       return (0);
}

static int
zxclose(dev_t dev, int flags, int mode, struct lwp *l)
{
       struct zx_softc *sc;

       sc = device_lookup_private(&zx_cd, minor(dev));

       zx_reset(sc);
       zx_cursor_blank(sc);
       return (0);
}

static int
zxioctl(dev_t dev, u_long cmd, void *data, int flags, struct lwp *l)
{
       struct zx_softc *sc;
       struct fbcmap *cm;
       struct fbcursor *cu;
       uint32_t curbits[2][32];
       int rv, v, count, i, error;

       sc = device_lookup_private(&zx_cd, minor(dev));

       switch (cmd) {
       case FBIOGTYPE:
               *(struct fbtype *)data = sc->sc_fb.fb_type;
               break;

       case FBIOGATTR:
#define fba ((struct fbgattr *)data)
               fba->real_type = sc->sc_fb.fb_type.fb_type;
               fba->owner = 0;         /* XXX ??? */
               fba->fbtype = sc->sc_fb.fb_type;
               fba->sattr.flags = 0;
               fba->sattr.emu_type = sc->sc_fb.fb_type.fb_type;
               fba->sattr.dev_specific[0] = -1;
               fba->emu_types[0] = sc->sc_fb.fb_type.fb_type;
               fba->emu_types[1] = -1;
               fba->emu_types[2] = -1;
#undef fba
               break;

       case FBIOGVIDEO:
               *(int *)data = ((sc->sc_flags & ZX_BLANKED) != 0);
               break;

       case FBIOSVIDEO:
               if (*(int *)data)
                       zx_unblank(sc->sc_dv);
               else
                       zx_blank(sc->sc_dv);
               break;

       case FBIOGETCMAP:
               cm = (struct fbcmap *)data;
               if (cm->index > 256 || cm->count > 256 - cm->index)
                       return (EINVAL);
               rv = copyout(sc->sc_cmap + cm->index, cm->red, cm->count);
               if (rv == 0)
                       rv = copyout(sc->sc_cmap + 256 + cm->index, cm->green,
                           cm->count);
               if (rv == 0)
                       rv = copyout(sc->sc_cmap + 512 + cm->index, cm->blue,
                           cm->count);
               return (rv);

       case FBIOPUTCMAP:
               cm = (struct fbcmap *)data;
               if (cm->index > 256 || cm->count > 256 - cm->index)
                       return (EINVAL);
               rv = copyin(cm->red, sc->sc_cmap + cm->index, cm->count);
               if (rv == 0)
                       rv = copyin(cm->green, sc->sc_cmap + 256 + cm->index,
                           cm->count);
               if (rv == 0)
                       rv = copyin(cm->blue, sc->sc_cmap + 512 + cm->index,
                           cm->count);
               zx_cmap_put(sc);
               return (rv);

       case FBIOGCURPOS:
               *(struct fbcurpos *)data = sc->sc_curpos;
               break;

       case FBIOSCURPOS:
               sc->sc_curpos = *(struct fbcurpos *)data;
               zx_cursor_move(sc);
               break;

       case FBIOGCURMAX:
               ((struct fbcurpos *)data)->x = 32;
               ((struct fbcurpos *)data)->y = 32;
               break;

       case FBIOSCURSOR:
               cu = (struct fbcursor *)data;
               v = cu->set;

               if ((v & FB_CUR_SETSHAPE) != 0) {
                       if ((u_int)cu->size.x > 32 || (u_int)cu->size.y > 32)
                               return (EINVAL);
                       count = cu->size.y * 4;
                       rv = copyin(cu->mask, curbits[0], count);
                       if (rv)
                               return rv;
                       rv = copyin(cu->image, curbits[1], count);
                       if (rv)
                               return rv;
               }
               if ((v & FB_CUR_SETCUR) != 0) {
                       if (cu->enable)
                               zx_cursor_unblank(sc);
                       else
                               zx_cursor_blank(sc);
               }
               if ((v & (FB_CUR_SETPOS | FB_CUR_SETHOT)) != 0) {
                       if ((v & FB_CUR_SETPOS) != 0)
                               sc->sc_curpos = cu->pos;
                       if ((v & FB_CUR_SETHOT) != 0)
                               sc->sc_curhot = cu->hot;
                       zx_cursor_move(sc);
               }
               if ((v & FB_CUR_SETCMAP) != 0) {
                       if (cu->cmap.index > 2 ||
                           cu->cmap.count > 2 - cu->cmap.index)
                               return (EINVAL);

                       uint8_t red[2], green[2], blue[2];
                       const u_int cnt = cu->cmap.count;

                       if (cnt &&
                           ((error = copyin(cu->cmap.red,   red,   cnt)) ||
                            (error = copyin(cu->cmap.green, green, cnt)) ||
                            (error = copyin(cu->cmap.blue,  blue,  cnt)))) {
                               return error;
                       }

                       for (i = 0; i < cnt; i++) {
                               sc->sc_curcmap[i + cu->cmap.index + 0] =
                                   red[i];
                               sc->sc_curcmap[i + cu->cmap.index + 2] =
                                   green[i];
                               sc->sc_curcmap[i + cu->cmap.index + 4] =
                                   blue[i];
                       }
                       zx_cursor_color(sc);
               }
               if ((v & FB_CUR_SETSHAPE) != 0) {
                       sc->sc_cursize = cu->size;
                       count = cu->size.y * 4;
                       memset(sc->sc_curbits, 0, sizeof(sc->sc_curbits));
                       memcpy(sc->sc_curbits[0], curbits[0], count);
                       memcpy(sc->sc_curbits[1], curbits[1], count);
                       zx_cursor_set(sc);
               }
               break;

       case FBIOGCURSOR:
               cu = (struct fbcursor *)data;

               cu->set = FB_CUR_SETALL;
               cu->enable = ((sc->sc_flags & ZX_CURSOR) != 0);
               cu->pos = sc->sc_curpos;
               cu->hot = sc->sc_curhot;
               cu->size = sc->sc_cursize;

               if (cu->image != NULL) {
                       count = sc->sc_cursize.y * 4;
                       rv = copyout(sc->sc_curbits[1], cu->image, count);
                       if (rv)
                               return (rv);
                       rv = copyout(sc->sc_curbits[0], cu->mask, count);
                       if (rv)
                               return (rv);
               }
               if (cu->cmap.red != NULL) {
                       uint8_t red[2], green[2], blue[2];
                       const uint8_t *ccm = sc->sc_curcmap;
                       cm = &cu->cmap;

                       if (cm->index > 2 || cm->count > 2 - cm->index)
                               return EINVAL;

                       for (i = 0; i < cm->count; i++) {
                               red[i] = ccm[i + cm->index + 0];
                               green[i] = ccm[i + cm->index + 2];
                               blue[i] = ccm[i + cm->index + 4];
                       }

                       if ((error = copyout(red, cm->red, cm->count)) ||
                           (error = copyout(green, cm->green, cm->count)) ||
                           (error = copyout(blue, cm->blue, cm->count)))
                               return error;
               } else {
                       cu->cmap.index = 0;
                       cu->cmap.count = 2;
               }
               break;

       default:
#ifdef DEBUG
               log(LOG_NOTICE, "zxioctl(0x%lx) (%s[%d])\n", cmd,
                   l->l_proc->p_comm, l->l_proc->p_pid);
#endif
               return (ENOTTY);
       }

       return (0);
}

static int
zx_intr(void *cookie)
{

       return (1);
}

static void
zx_reset(struct zx_softc *sc)
{
       struct fbtype *fbt;
       u_int i;

       fbt = &sc->sc_fb.fb_type;

       zx_cross_loadwid(sc, ZX_WID_DBL_8, 0, 0x2c0);
       zx_cross_loadwid(sc, ZX_WID_DBL_8, 1, 0x30);
       zx_cross_loadwid(sc, ZX_WID_DBL_8, 2, 0x20);
       zx_cross_loadwid(sc, ZX_WID_DBL_24, 1, 0x30);

       i = bus_space_read_4(sc->sc_bt, sc->sc_bhzdss1, zd_misc);
       i |= ZX_SS1_MISC_ENABLE;
       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss1, zd_misc, i);

       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_wid, 1);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_widclip, 0);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_wmask, 0xffff);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_vclipmin, 0);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_vclipmax,
           (fbt->fb_width - 1) | ((fbt->fb_height - 1) << 16));
       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_fg, 0);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_planemask, 0xffffffff);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_rop, ZX_STD_ROP);

       bus_space_write_4(sc->sc_bt, sc->sc_bhzc, zc_extent,
           (fbt->fb_width - 1) | ((fbt->fb_height - 1) << 11));
       bus_space_write_4(sc->sc_bt, sc->sc_bhzc, zc_addrspace,
           ZX_ADDRSPC_FONT_OBGR);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzc, zc_fontt, 0);

       for (i = 0; i < 256; i++) {
               sc->sc_cmap[i] = rasops_cmap[i * 3];
               sc->sc_cmap[i + 256] = rasops_cmap[i * 3 + 1];
               sc->sc_cmap[i + 512] = rasops_cmap[i * 3 + 2];
       }

       zx_cmap_put(sc);
}

static int
zx_cross_wait(struct zx_softc *sc)
{
       int i;

       for (i = 300000; i != 0; i--) {
               if ((bus_space_read_4(sc->sc_bt, sc->sc_bhzx, zx_csr) &
                   ZX_CROSS_CSR_PROGRESS) == 0)
                       break;
               DELAY(1);
       }

       if (i == 0)
               printf("zx_cross_wait: timed out\n");

       return (i);
}

static int
zx_cross_loadwid(struct zx_softc *sc, u_int type, u_int index, u_int value)
{
       u_int tmp = 0;

       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_type, ZX_CROSS_TYPE_WID);

       if (zx_cross_wait(sc))
               return (1);

       if (type == ZX_WID_DBL_8)
               tmp = (index & 0x0f) + 0x40;
       else if (type == ZX_WID_DBL_24)
               tmp = index & 0x3f;

       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_type, 0x5800 + tmp);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_value, value);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_type, ZX_CROSS_TYPE_WID);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_csr,
           ZX_CROSS_CSR_UNK | ZX_CROSS_CSR_UNK2);

       return (0);
}

static int
zx_cmap_put(struct zx_softc *sc)
{
       const u_char *b;
       u_int i, t;

       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_type, ZX_CROSS_TYPE_CLUT0);

       zx_cross_wait(sc);

       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_type,
           ZX_CROSS_TYPE_CLUTDATA);

       for (i = 0, b = sc->sc_cmap; i < 256; i++) {
               t = b[i];
               t |= b[i + 256] << 8;
               t |= b[i + 512] << 16;
               bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_value, t);
       }

       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_type, ZX_CROSS_TYPE_CLUT0);
       i = bus_space_read_4(sc->sc_bt, sc->sc_bhzx, zx_csr);
       i = i | ZX_CROSS_CSR_UNK | ZX_CROSS_CSR_UNK2;
       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_csr, i);
       return (0);
}

static void
zx_cursor_move(struct zx_softc *sc)
{
       int sx, sy, x, y;

       x = sc->sc_curpos.x - sc->sc_curhot.x;
       y = sc->sc_curpos.y - sc->sc_curhot.y;

       if (x < 0) {
               sx = uimin(-x, 32);
               x = 0;
       } else
               sx = 0;

       if (y < 0) {
               sy = uimin(-y, 32);
               y = 0;
       } else
               sy = 0;

       if (sx != sc->sc_shiftx || sy != sc->sc_shifty) {
               sc->sc_shiftx = sx;
               sc->sc_shifty = sy;
               zx_cursor_set(sc);
       }

       bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_sxy,
           ((y & 0x7ff) << 11) | (x & 0x7ff));
       bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc,
           bus_space_read_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc) | 0x30);

       /* XXX Necessary? */
       bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc,
           bus_space_read_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc) | 0x80);
}

static void
zx_cursor_set(struct zx_softc *sc)
{
       int i, j, data;

       if ((sc->sc_flags & ZX_CURSOR) != 0)
               bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc,
                   bus_space_read_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc) &
                   ~0x80);

       for (j = 0; j < 2; j++) {
               bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_type, 0x20 << j);

               for (i = sc->sc_shifty; i < 32; i++) {
                       data = sc->sc_curbits[j][i];
                       bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_data,
                           data >> sc->sc_shiftx);
               }
               for (i = sc->sc_shifty; i != 0; i--)
                       bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_data, 0);
       }

       if ((sc->sc_flags & ZX_CURSOR) != 0)
               bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc,
                   bus_space_read_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc) | 0x80);
}

static void
zx_cursor_blank(struct zx_softc *sc)
{

       sc->sc_flags &= ~ZX_CURSOR;
       bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc,
           bus_space_read_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc) & ~0x80);
}

static void
zx_cursor_unblank(struct zx_softc *sc)
{

       sc->sc_flags |= ZX_CURSOR;
       bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc,
           bus_space_read_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc) | 0x80);
}

static void
zx_cursor_color(struct zx_softc *sc)
{
       uint8_t tmp;

       bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_type, 0x50);

       tmp = sc->sc_curcmap[0] | (sc->sc_curcmap[2] << 8) |
           (sc->sc_curcmap[4] << 16);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_data, tmp);

       tmp = sc->sc_curcmap[1] | (sc->sc_curcmap[3] << 8) |
           (sc->sc_curcmap[5] << 16);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_data, tmp);

       bus_space_write_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc,
           bus_space_read_4(sc->sc_bt, sc->sc_bhzcu, zcu_misc) | 0x03);
}

static void
zx_blank(device_t dv)
{
       struct zx_softc *sc;

       sc = device_private(dv);

       if ((sc->sc_flags & ZX_BLANKED) != 0)
               return;
       sc->sc_flags |= ZX_BLANKED;

       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_type, ZX_CROSS_TYPE_VIDEO);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_csr,
           bus_space_read_4(sc->sc_bt, sc->sc_bhzx, zx_csr) &
           ~ZX_CROSS_CSR_ENABLE);
}

static void
zx_unblank(device_t dv)
{
       struct zx_softc *sc;

       sc = device_private(dv);

       if ((sc->sc_flags & ZX_BLANKED) == 0)
               return;
       sc->sc_flags &= ~ZX_BLANKED;

       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_type, ZX_CROSS_TYPE_VIDEO);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzx, zx_csr,
           bus_space_read_4(sc->sc_bt, sc->sc_bhzx, zx_csr) |
           ZX_CROSS_CSR_ENABLE);
}

static paddr_t
zxmmap(dev_t dev, off_t off, int prot)
{
       struct zx_softc *sc;
       const struct zx_mmo *mm, *mmmax;

       sc = device_lookup_private(&zx_cd, minor(dev));
       off = trunc_page(off);
       mm = zx_mmo;
       mmmax = mm + sizeof(zx_mmo) / sizeof(zx_mmo[0]);

       for (; mm < mmmax; mm++)
               if (off >= mm->mo_va && off < mm->mo_va + mm->mo_size) {
                       off = off - mm->mo_va + mm->mo_pa;
                       return (bus_space_mmap(sc->sc_bt, sc->sc_paddr,
                           off, prot, BUS_SPACE_MAP_LINEAR));
               }

       return (-1);
}

static void
zx_fillrect(struct zx_softc *sc, int x, int y, int w, int h, uint32_t bg,
           int rop)
{


       while ((bus_space_read_4(sc->sc_bt, sc->sc_bhzc, zc_csr) &
           ZX_CSR_BLT_BUSY) != 0)
               ;

       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_rop, rop);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_fg, bg);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzc, zc_extent,
           (w - 1) | ((h - 1) << 11));
       bus_space_write_4(sc->sc_bt, sc->sc_bhzc, zc_fill,
           x | (y << 11) | 0x80000000);
}

static void
zx_copyrect(struct zx_softc *sc, int sx, int sy, int dx, int dy, int w,
           int h)
{
       uint32_t dir;

       w -= 1;
       h -= 1;

       if (sy < dy || sx < dx) {
               dir = 0x80000000;
               sx += w;
               sy += h;
               dx += w;
               dy += h;
       } else
               dir = 0;

       while ((bus_space_read_4(sc->sc_bt, sc->sc_bhzc, zc_csr) &
           ZX_CSR_BLT_BUSY) != 0)
               ;

       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_rop, ZX_STD_ROP);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzc, zc_extent,
           w | (h << 11) | dir);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzc, zc_src, sx | (sy << 11));
       bus_space_write_4(sc->sc_bt, sc->sc_bhzc, zc_copy, dx | (dy << 11));
}

static void
zx_do_cursor(void *cookie, int on, int row, int col)
{
       struct rasops_info *ri = cookie;
       struct vcons_screen *scr = ri->ri_hw;
       struct zx_softc *sc = scr->scr_cookie;
       int x, y, wi, he;

       wi = ri->ri_font->fontwidth;
       he = ri->ri_font->fontheight;

       if (ri->ri_flg & RI_CURSOR) {
               x = ri->ri_ccol * wi + ri->ri_xorigin;
               y = ri->ri_crow * he + ri->ri_yorigin;
               zx_fillrect(sc, x, y, wi, he, 0xff000000,
                 ZX_ROP_NEW_XOR_OLD | ZX_ATTR_WE_ENABLE | ZX_ATTR_OE_ENABLE |
                 ZX_ATTR_FORCE_WID);
               ri->ri_flg &= ~RI_CURSOR;
       }

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

       if (on)
       {
               x = ri->ri_ccol * wi + ri->ri_xorigin;
               y = ri->ri_crow * he + ri->ri_yorigin;
               zx_fillrect(sc, x, y, wi, he, 0xff000000,
                 ZX_ROP_NEW_XOR_OLD | ZX_ATTR_WE_ENABLE | ZX_ATTR_OE_ENABLE |
                 ZX_ATTR_FORCE_WID);
               ri->ri_flg |= RI_CURSOR;
       }
}

static void
zx_erasecols(void *cookie, int row, int startcol, int ncols, long attr)
{
       struct rasops_info *ri = cookie;
       struct vcons_screen *scr = ri->ri_hw;
       struct zx_softc *sc = scr->scr_cookie;
       int32_t x, y, width, height, bg;

       x = ri->ri_xorigin + ri->ri_font->fontwidth * startcol;
       y = ri->ri_yorigin + ri->ri_font->fontheight * row;
       width = ri->ri_font->fontwidth * ncols;
       height = ri->ri_font->fontheight;
       bg = ((uint32_t)ri->ri_devcmap[(attr >> 16) & 0xff]) << 24;
       zx_fillrect(sc, x, y, width, height, bg, ZX_STD_ROP);
}

static void
zx_eraserows(void *cookie, int row, int nrows, long attr)
{
       struct rasops_info *ri = cookie;
       struct vcons_screen *scr = ri->ri_hw;
       struct zx_softc *sc = scr->scr_cookie;
       int32_t x, y, width, height, bg;

       if ((row == 0) && (nrows == ri->ri_rows)) {
               x = y = 0;
               width = ri->ri_width;
               height = ri->ri_height;
       } else {
               x = ri->ri_xorigin;
               y = ri->ri_yorigin + ri->ri_font->fontheight * row;
               width = ri->ri_emuwidth;
               height = ri->ri_font->fontheight * nrows;
       }
       bg = ((uint32_t)ri->ri_devcmap[(attr >> 16) & 0xff]) << 24;
       zx_fillrect(sc, x, y, width, height, bg, ZX_STD_ROP);
}

static void
zx_copyrows(void *cookie, int srcrow, int dstrow, int nrows)
{
       struct rasops_info *ri = cookie;
       struct vcons_screen *scr = ri->ri_hw;
       struct zx_softc *sc = scr->scr_cookie;
       int32_t x, ys, yd, width, height;

       x = ri->ri_xorigin;
       ys = ri->ri_yorigin + ri->ri_font->fontheight * srcrow;
       yd = ri->ri_yorigin + ri->ri_font->fontheight * dstrow;
       width = ri->ri_emuwidth;
       height = ri->ri_font->fontheight * nrows;
       zx_copyrect(sc, x, ys, x, yd, width, height);
}

static void
zx_copycols(void *cookie, int row, int srccol, int dstcol, int ncols)
{
       struct rasops_info *ri = cookie;
       struct vcons_screen *scr = ri->ri_hw;
       struct zx_softc *sc = scr->scr_cookie;
       int32_t xs, xd, y, width, height;

       xs = ri->ri_xorigin + ri->ri_font->fontwidth * srccol;
       xd = ri->ri_xorigin + ri->ri_font->fontwidth * dstcol;
       y = ri->ri_yorigin + ri->ri_font->fontheight * row;
       width = ri->ri_font->fontwidth * ncols;
       height = ri->ri_font->fontheight;
       zx_copyrect(sc, xs, y, xd, y, width, height);
}

static void
zx_putchar(void *cookie, int row, int col, u_int uc, long attr)
{
       struct rasops_info *ri = cookie;
       struct wsdisplay_font *font = PICK_FONT(ri, uc);
       struct vcons_screen *scr = ri->ri_hw;
       struct zx_softc *sc = scr->scr_cookie;
       volatile uint32_t *dp;
       uint8_t *fb;
       int fs, i, ul;
       uint32_t fg, bg;

       rasops_unpack_attr(attr, &fg, &bg, &ul);
       bg = ((uint32_t)ri->ri_devcmap[bg]) << 24;
       fg = ((uint32_t)ri->ri_devcmap[fg]) << 24;
       if (uc == ' ') {
               int x, y;

               x = ri->ri_xorigin + font->fontwidth * col;
               y = ri->ri_yorigin + font->fontheight * row;
               zx_fillrect(sc, x, y, font->fontwidth,
                           font->fontheight, bg, ZX_STD_ROP);
               return;
       }

       dp = (volatile uint32_t *)sc->sc_pixels +
           ((row * font->fontheight + ri->ri_yorigin) << 11) +
           (col * font->fontwidth + ri->ri_xorigin);
       fb = (uint8_t *)font->data + (uc - font->firstchar) *
           ri->ri_fontscale;
       fs = font->stride;

       while ((bus_space_read_4(sc->sc_bt, sc->sc_bhzc, zc_csr) &
           ZX_CSR_BLT_BUSY) != 0)
               ;

       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_rop, ZX_STD_ROP);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_fg, fg);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzdss0, zd_bg, bg);
       bus_space_write_4(sc->sc_bt, sc->sc_bhzc, zc_fontmsk,
           0xffffffff << (32 - font->fontwidth));

       if (font->fontwidth <= 8) {
               for (i = font->fontheight; i != 0; i--, dp += 2048) {
                       *dp = *fb << 24;
                       fb += fs;
               }
       } else {
               for (i = font->fontheight; i != 0; i--, dp += 2048) {
                       *dp = *((uint16_t *)fb) << 16;
                       fb += fs;
               }
       }

       if (ul) {
               dp -= 4096;
               *dp = 0xffffffff;
       }
}

static int
zx_ioctl(void *v, void *vs, u_long cmd, void *data, int flag,
       struct lwp *l)
{
       /* we'll probably need to add more stuff here */
       struct vcons_data *vd = v;
       struct zx_softc *sc = vd->cookie;
       struct wsdisplay_fbinfo *wdf;
       struct vcons_screen *ms = sc->vd.active;
       struct rasops_info *ri = &ms->scr_ri;
       switch (cmd) {
               case WSDISPLAYIO_GTYPE:
                       *(u_int *)data = WSDISPLAY_TYPE_SUNTCX;
                       return 0;
               case WSDISPLAYIO_GINFO:
                       wdf = (void *)data;
                       wdf->height = ri->ri_height;
                       wdf->width = ri->ri_width;
                       wdf->depth = ri->ri_depth;
                       wdf->cmsize = 256;
                       return 0;

               case WSDISPLAYIO_GETCMAP:
                       return zx_getcmap(sc,
                           (struct wsdisplay_cmap *)data);
               case WSDISPLAYIO_PUTCMAP:
                       return zx_putcmap(sc,
                           (struct wsdisplay_cmap *)data);

               case WSDISPLAYIO_SMODE:
                       {
                               int new_mode = *(int*)data;
                               if (new_mode != sc->sc_mode)
                               {
                                       sc->sc_mode = new_mode;
                                       if(new_mode == WSDISPLAYIO_MODE_EMUL)
                                       {
                                               zx_reset(sc);
                                               vcons_redraw_screen(ms);
                                       }
                               }
                       }
                       return 0;
       }
       return EPASSTHROUGH;
}

static paddr_t
zx_mmap(void *v, void *vs, off_t offset, int prot)
{
       /* I'm not at all sure this is the right thing to do */
       return zxmmap(0, offset, prot); /* assume minor dev 0 for now */
}

static int
zx_putcmap(struct zx_softc *sc, struct wsdisplay_cmap *cm)
{
       u_int index = cm->index;
       u_int count = cm->count;
       int error,i;
       if (index >= 256 || count > 256 || index + count > 256)
               return EINVAL;

       for (i = 0; i < count; i++)
       {
               error = copyin(&cm->red[i],
                   &sc->sc_cmap[index + i], 1);
               if (error)
                       return error;
               error = copyin(&cm->green[i],
                   &sc->sc_cmap[index + i + 256], 1);
               if (error)
                       return error;
               error = copyin(&cm->blue[i],
                   &sc->sc_cmap[index + i + 512], 1);
               if (error)
                       return error;
       }
       zx_cmap_put(sc);

       return 0;
}

static int
zx_getcmap(struct zx_softc *sc, struct wsdisplay_cmap *cm)
{
       u_int index = cm->index;
       u_int count = cm->count;
       int error,i;

       if (index >= 256 || count > 256 || index + count > 256)
               return EINVAL;

       for (i = 0; i < count; i++)
       {
               error = copyout(&sc->sc_cmap[index + i],
                   &cm->red[i], 1);
               if (error)
                       return error;
               error = copyout(&sc->sc_cmap[index + i + 256],
                   &cm->green[i], 1);
               if (error)
                       return error;
               error = copyout(&sc->sc_cmap[index + i + 256],
                   &cm->blue[i], 1);
               if (error)
                       return error;
       }

       return 0;
}

static void
zx_init_screen(void *cookie, struct vcons_screen *scr,
   int existing, long *defattr)
{
       struct zx_softc *sc = cookie;
       struct rasops_info *ri = &scr->scr_ri;

       ri->ri_depth = 8; /*sc->sc_fb.fb_type.fb_depth = 32;*/
       ri->ri_width = sc->sc_width;
       ri->ri_height = sc->sc_height;
       ri->ri_stride = sc->sc_stride;
       ri->ri_flg = RI_CENTER;

       ri->ri_bits = (void *)sc->sc_pixels;

       rasops_init(ri, 0, 0);
       ri->ri_caps = WSSCREEN_WSCOLORS | WSSCREEN_REVERSE;
       rasops_reconfig(ri, sc->sc_height / ri->ri_font->fontheight,
                   sc->sc_width / ri->ri_font->fontwidth);

       ri->ri_hw = scr;

       ri->ri_ops.cursor = zx_do_cursor;
       ri->ri_ops.copycols = zx_copycols;
       ri->ri_ops.copyrows = zx_copyrows;
       ri->ri_ops.erasecols = zx_erasecols;
       ri->ri_ops.eraserows = zx_eraserows;
       ri->ri_ops.putchar = zx_putchar;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.