/*      $NetBSD: cgthree.c,v 1.36 2022/09/25 21:30:29 thorpej Exp $ */

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

/*
* color display (cgthree) driver.
*
* Does not handle interrupts, even though they can occur.
*
* XXX should defer colormap updates to vertical retrace interrupts
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: cgthree.c,v 1.36 2022/09/25 21:30:29 thorpej Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/device.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/tty.h>
#include <sys/conf.h>

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

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

#include <dev/sun/btreg.h>
#include <dev/sun/btvar.h>
#include <dev/sun/cgthreereg.h>
#include <dev/sun/cgthreevar.h>

#if NWSDISPLAY > 0
#include <dev/wscons/wsconsio.h>
#include <dev/wsfont/wsfont.h>
#include <dev/rasops/rasops.h>

#include "opt_wsemul.h"
#endif

#include "ioconf.h"

static void     cgthreeunblank(device_t);
static void     cgthreeloadcmap(struct cgthree_softc *, int, int);
static void     cgthree_set_video(struct cgthree_softc *, int);
static int      cgthree_get_video(struct cgthree_softc *);

dev_type_open(cgthreeopen);
dev_type_ioctl(cgthreeioctl);
dev_type_mmap(cgthreemmap);

const struct cdevsw cgthree_cdevsw = {
       .d_open = cgthreeopen,
       .d_close = nullclose,
       .d_read = noread,
       .d_write = nowrite,
       .d_ioctl = cgthreeioctl,
       .d_stop = nostop,
       .d_tty = notty,
       .d_poll = nopoll,
       .d_mmap = cgthreemmap,
       .d_kqfilter = nokqfilter,
       .d_discard = nodiscard,
       .d_flag = D_OTHER
};

/* frame buffer generic driver */
static struct fbdriver cgthreefbdriver = {
       cgthreeunblank, cgthreeopen, nullclose, cgthreeioctl, nopoll,
       cgthreemmap, nokqfilter
};

/* Video control parameters */
struct cg3_videoctrl {
       unsigned char   sense;          /* Monitor sense value */
       unsigned char   vctrl[12];
} cg3_videoctrl[] = {
/* Missing entries: sense 0x10, 0x30, 0x50 */
       { 0x40, /* this happens to be my 19'' 1152x900 gray-scale monitor */
          {0xbb, 0x2b, 0x3, 0xb, 0xb3, 0x3, 0xaf, 0x2b, 0x2, 0xa, 0xff, 0x1}
       },
       { 0x00, /* default? must be last */
          {0xbb, 0x2b, 0x3, 0xb, 0xb3, 0x3, 0xaf, 0x2b, 0x2, 0xa, 0xff, 0x1}
       }
};

static void cg3_setup_palette(struct cgthree_softc *);

struct wsscreen_descr cgthree_defaultscreen = {
       "std",
       0, 0,   /* will be filled in -- XXX shouldn't, it's global */
       NULL,           /* textops */
       8, 16,  /* font width/height */
       WSSCREEN_WSCOLORS,      /* capabilities */
       NULL    /* modecookie */
};

static int      cgthree_ioctl(void *, void *, u_long, void *, int, struct lwp *);
static paddr_t  cgthree_mmap(void *, void *, off_t, int);
static void     cgthree_init_screen(void *, struct vcons_screen *, int, long *);

int     cgthree_putcmap(struct cgthree_softc *, struct wsdisplay_cmap *);
int     cgthree_getcmap(struct cgthree_softc *, struct wsdisplay_cmap *);

struct wsdisplay_accessops cgthree_accessops = {
       cgthree_ioctl,
       cgthree_mmap,
       NULL,   /* alloc_screen */
       NULL,   /* free_screen */
       NULL,   /* show_screen */
       NULL,   /* load_font */
       NULL,   /* pollc */
       NULL    /* scroll */
};

const struct wsscreen_descr *_cgthree_scrlist[] = {
       &cgthree_defaultscreen
};

struct wsscreen_list cgthree_screenlist = {
       sizeof(_cgthree_scrlist) / sizeof(struct wsscreen_descr *),
       _cgthree_scrlist
};


extern const u_char rasops_cmap[768];

static struct vcons_screen cg3_console_screen;

void
cgthreeattach(struct cgthree_softc *sc, const char *name, int isconsole)
{
       int i;
       struct fbdevice *fb = &sc->sc_fb;
       struct wsemuldisplaydev_attach_args aa;
       struct rasops_info *ri = &cg3_console_screen.scr_ri;
       unsigned long defattr;
       volatile struct fbcontrol *fbc = sc->sc_fbc;
       volatile struct bt_regs *bt = &fbc->fbc_dac;

       fb->fb_driver = &cgthreefbdriver;
       fb->fb_type.fb_cmsize = 256;
       fb->fb_type.fb_size = fb->fb_type.fb_height * fb->fb_linebytes;
       printf(": %s, %d x %d", name,
               fb->fb_type.fb_width, fb->fb_type.fb_height);

       /* Transfer video magic to board, if it's not running */
       if ((fbc->fbc_ctrl & FBC_TIMING) == 0) {
               int sense = (fbc->fbc_status & FBS_MSENSE);
               /* Search table for video timings fitting this monitor */
               for (i = 0; i < sizeof(cg3_videoctrl)/sizeof(cg3_videoctrl[0]);
                    i++) {
                       int j;
                       if (sense != cg3_videoctrl[i].sense)
                               continue;

                       printf(" setting video ctrl");
                       for (j = 0; j < 12; j++)
                               fbc->fbc_vcontrol[j] =
                                       cg3_videoctrl[i].vctrl[j];
                       fbc->fbc_ctrl |= FBC_TIMING;
                       break;
               }
       }

       /* make sure we are not blanked */
       cgthree_set_video(sc, 1);
       BT_INIT(bt, 0);

       if (isconsole) {
               printf(" (console)\n");
       } else
               printf("\n");

       fb_attach(fb, isconsole);

       sc->sc_width = fb->fb_type.fb_width;
       sc->sc_stride = fb->fb_type.fb_width;
       sc->sc_height = fb->fb_type.fb_height;

       /* setup rasops and so on for wsdisplay */
       sc->sc_mode = WSDISPLAYIO_MODE_EMUL;

       vcons_init(&sc->vd, sc, &cgthree_defaultscreen, &cgthree_accessops);
       sc->vd.init_screen = cgthree_init_screen;

       if(isconsole) {
               /* we mess with cg3_console_screen only once */
               vcons_init_screen(&sc->vd, &cg3_console_screen, 1,
                   &defattr);
               memset(sc->sc_fb.fb_pixels, (defattr >> 16) & 0xff,
                   sc->sc_stride * sc->sc_height);
               cg3_console_screen.scr_flags |= VCONS_SCREEN_IS_STATIC;

               cgthree_defaultscreen.textops = &ri->ri_ops;
               cgthree_defaultscreen.capabilities = ri->ri_caps;
               cgthree_defaultscreen.nrows = ri->ri_rows;
               cgthree_defaultscreen.ncols = ri->ri_cols;
               sc->vd.active = &cg3_console_screen;
               wsdisplay_cnattach(&cgthree_defaultscreen, ri, 0, 0, defattr);
               vcons_replay_msgbuf(&cg3_console_screen);
       } else {
               /*
                * we're not the console so we just clear the screen and don't
                * set up any sort of text display
                */
       }

       /* Initialize the default color map. */
       cg3_setup_palette(sc);

       aa.scrdata = &cgthree_screenlist;
       aa.console = isconsole;
       aa.accessops = &cgthree_accessops;
       aa.accesscookie = &sc->vd;
       config_found(sc->sc_dev, &aa, wsemuldisplaydevprint, CFARGS_NONE);
}


int
cgthreeopen(dev_t dev, int flags, int mode, struct lwp *l)
{
       int unit = minor(dev);

       if (device_lookup(&cgthree_cd, unit) == NULL)
               return (ENXIO);
       return (0);
}

int
cgthreeioctl(dev_t dev, u_long cmd, void *data, int flags, struct lwp *l)
{
       struct cgthree_softc *sc = device_lookup_private(&cgthree_cd,
                                                        minor(dev));
       struct fbgattr *fba;
       int error;

       switch (cmd) {

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

       case FBIOGATTR:
               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;
               break;

       case FBIOGETCMAP:
#define p ((struct fbcmap *)data)
               return (bt_getcmap(p, &sc->sc_cmap, 256, 1));

       case FBIOPUTCMAP:
               /* copy to software map */
               error = bt_putcmap(p, &sc->sc_cmap, 256, 1);
               if (error)
                       return (error);
               /* now blast them into the chip */
               /* XXX should use retrace interrupt */
               cgthreeloadcmap(sc, p->index, p->count);
#undef p
               break;

       case FBIOGVIDEO:
               *(int *)data = cgthree_get_video(sc);
               break;

       case FBIOSVIDEO:
               cgthree_set_video(sc, *(int *)data);
               break;

       default:
               return (ENOTTY);
       }
       return (0);
}

/*
* Undo the effect of an FBIOSVIDEO that turns the video off.
*/
static void
cgthreeunblank(device_t self)
{
       struct cgthree_softc *sc = device_private(self);

       cgthree_set_video(sc, 1);
}

static void
cgthree_set_video(struct cgthree_softc *sc, int enable)
{

       if (enable)
               sc->sc_fbc->fbc_ctrl |= FBC_VENAB;
       else
               sc->sc_fbc->fbc_ctrl &= ~FBC_VENAB;
}

static int
cgthree_get_video(struct cgthree_softc *sc)
{

       return ((sc->sc_fbc->fbc_ctrl & FBC_VENAB) != 0);
}

/*
* Load a subset of the current (new) colormap into the Brooktree DAC.
*/
static void
cgthreeloadcmap(struct cgthree_softc *sc, int start, int ncolors)
{
       volatile struct bt_regs *bt;
       u_int *ip;
       int count;

       ip = &sc->sc_cmap.cm_chip[BT_D4M3(start)];      /* start/4 * 3 */
       count = BT_D4M3(start + ncolors - 1) - BT_D4M3(start) + 3;
       bt = &sc->sc_fbc->fbc_dac;
       bt->bt_addr = BT_D4M4(start);
       while (--count >= 0)
               bt->bt_cmap = *ip++;
}

/*
* Return the address that would map the given device at the given
* offset, allowing for the given protection, or return -1 for error.
*
* The cg3 is mapped starting at 256KB, for pseudo-compatibility with
* the cg4 (which had an overlay plane in the first 128K and an enable
* plane in the next 128K).  X11 uses only 256k+ region but tries to
* map the whole thing, so we repeatedly map the first 256K to the
* first page of the color screen.  If someone tries to use the overlay
* and enable regions, they will get a surprise....
*
* As well, mapping at an offset of 0x04000000 causes the cg3 to be
* mapped in flat mode without the cg4 emulation.
*/
paddr_t
cgthreemmap(dev_t dev, off_t off, int prot)
{
       struct cgthree_softc *sc = device_lookup_private(&cgthree_cd,
                                                        minor(dev));

#define START           (128*1024 + 128*1024)
#define NOOVERLAY       (0x04000000)

       if (off & PGOFSET)
               panic("cgthreemmap");
       if (off < 0)
               return (-1);
       if ((u_int)off >= NOOVERLAY)
               off -= NOOVERLAY;
       else if ((u_int)off >= START)
               off -= START;
       else
               off = 0;

       if (off >= sc->sc_fb.fb_type.fb_size)
               return (-1);

       return (bus_space_mmap(sc->sc_bustag,
               sc->sc_paddr, CG3REG_MEM + off,
               prot, BUS_SPACE_MAP_LINEAR));
}

static void
cg3_setup_palette(struct cgthree_softc *sc)
{
       int i, j;

       j = 0;
       for (i = 0; i < 256; i++) {
               sc->sc_cmap.cm_map[i][0] = rasops_cmap[j];
               j++;
               sc->sc_cmap.cm_map[i][1] = rasops_cmap[j];
               j++;
               sc->sc_cmap.cm_map[i][2] = rasops_cmap[j];
               j++;
       }
       cgthreeloadcmap(sc, 0, 256);
}

int
cgthree_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 cgthree_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 = 8;
                       wdf->cmsize = 256;
                       return 0;

               case WSDISPLAYIO_GETCMAP:
                       return cgthree_getcmap(sc,
                           (struct wsdisplay_cmap *)data);
               case WSDISPLAYIO_PUTCMAP:
                       return cgthree_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)
                                       {
                                               cg3_setup_palette(sc);
                                               vcons_redraw_screen(ms);
                                       }
                               }
                       }
                       return 0;
               case WSDISPLAYIO_GET_FBINFO:
                       {
                               struct wsdisplayio_fbinfo *fbi = data;

                               return wsdisplayio_get_fbinfo(&ms->scr_ri, fbi);
                       }
       }
       return EPASSTHROUGH;
}

paddr_t
cgthree_mmap(void *v, void *vs, off_t offset, int prot)
{
       struct vcons_data *vd = v;
       struct cgthree_softc *sc = vd->cookie;

       if (offset < 0) return -1;
       if (offset >= sc->sc_fb.fb_type.fb_size)
               return -1;

       return bus_space_mmap(sc->sc_bustag,
               sc->sc_paddr, CG3REG_MEM + offset,
               prot, BUS_SPACE_MAP_LINEAR);
}

int
cgthree_putcmap(struct cgthree_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.cm_map[index + i][0], 1);
               if (error)
                       return error;
               error = copyin(&cm->green[i],
                   &sc->sc_cmap.cm_map[index + i][1],
                   1);
               if (error)
                       return error;
               error = copyin(&cm->blue[i],
                   &sc->sc_cmap.cm_map[index + i][2], 1);
               if (error)
                       return error;
       }
       cgthreeloadcmap(sc, index, count);

       return 0;
}

int
cgthree_getcmap(struct cgthree_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.cm_map[index + i][0],
                   &cm->red[i], 1);
               if (error)
                       return error;
               error = copyout(&sc->sc_cmap.cm_map[index + i][1],
                   &cm->green[i], 1);
               if (error)
                       return error;
               error = copyout(&sc->sc_cmap.cm_map[index + i][2],
                   &cm->blue[i], 1);
               if (error)
                       return error;
       }

       return 0;
}

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

       scr->scr_flags |= VCONS_DONT_READ;

       ri->ri_depth = 8;
       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 = sc->sc_fb.fb_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;
}

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.