/*      $Id: light.c,v 1.11 2023/12/13 20:53:14 andvar Exp $    */

/*
* Copyright (c) 2006 Stephen M. Rumble
* Copyright (c) 2003 Ilpo Ruotsalainen
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
*    derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* <<Id: LICENSE_GC,v 1.1 2001/10/01 23:24:05 cgd Exp>>
*/

/*
* SGI "Light" graphics, a.k.a. "Entry", "Starter", "LG1", and "LG2".
*
* 1024x768 8bpp at 60Hz.
*
* This driver supports the boards found in Indigo R3k and R4k machines.
* There is a Crimson variant, but the register offsets differ significantly.
*
* Light's REX chip is the precursor of the REX3 found in "newport", hence
* much similarity exists.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: light.c,v 1.11 2023/12/13 20:53:14 andvar Exp $");

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

#include <machine/sysconf.h>

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

#include <sgimips/gio/giovar.h>
#include <sgimips/gio/lightvar.h>
#include <sgimips/gio/lightreg.h>

struct light_softc {
       struct light_devconfig *sc_dc;
};

struct light_devconfig {
       uint32_t                dc_addr;

       bus_space_tag_t         dc_st;
       bus_space_handle_t      dc_sh;

       int                     dc_boardrev;
       int                     dc_font;
       struct wsdisplay_font  *dc_fontdata;
};

/* always 1024x768x8 */
#define LIGHT_XRES      1024
#define LIGHT_YRES      768
#define LIGHT_DEPTH     8

static int      light_match(device_t, cfdata_t, void *);
static void     light_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(light, sizeof(struct light_softc), light_match, light_attach,
   NULL, NULL);

/* wsdisplay_emulops */
static void     light_cursor(void *, int, int, int);
static int      light_mapchar(void *, int, unsigned int *);
static void     light_putchar(void *, int, int, u_int, long);
static void     light_copycols(void *, int, int, int, int);
static void     light_erasecols(void *, int, int, int, long);
static void     light_copyrows(void *, int, int, int);
static void     light_eraserows(void *, int, int, long);
static int      light_allocattr(void *, int, int, int, long *);

/* wsdisplay_accessops */
static int      light_ioctl(void *, void *, u_long, void *, int, struct lwp *);
static paddr_t  light_mmap(void *, void *, off_t, int);
static int      light_alloc_screen(void *, const struct wsscreen_descr *,
   void **, int *, int *, long *);
static void     light_free_screen(void *, void *);
static int      light_show_screen(void *, void *, int,
   void (*)(void *, int, int), void *);

static const struct wsdisplay_accessops light_accessops = {
       .ioctl          = light_ioctl,
       .mmap           = light_mmap,
       .alloc_screen   = light_alloc_screen,
       .free_screen    = light_free_screen,
       .show_screen    = light_show_screen,
       .load_font      = NULL,
       .pollc          = NULL,
       .scroll         = NULL
};

static const struct wsdisplay_emulops light_emulops = {
       .cursor         = light_cursor,
       .mapchar        = light_mapchar,
       .putchar        = light_putchar,
       .copycols       = light_copycols,
       .erasecols      = light_erasecols,
       .copyrows       = light_copyrows,
       .eraserows      = light_eraserows,
       .allocattr      = light_allocattr,
       .replaceattr    = NULL
};

static const struct wsscreen_descr light_screen = {
       .name           = "1024x768",
       .ncols          = 128,
       .nrows          = 48,
       .textops        = &light_emulops,
       .fontwidth      = 8,
       .fontheight     = 16,
       .capabilities   = WSSCREEN_WSCOLORS | WSSCREEN_HILIT | WSSCREEN_REVERSE
};

const struct wsscreen_descr *_light_screenlist[] = {
       &light_screen
};

static const struct wsscreen_list light_screenlist = {
       sizeof(_light_screenlist) / sizeof(_light_screenlist[0]),
       _light_screenlist
};

static struct light_devconfig   light_console_dc;
static int                      light_is_console = 0;

#define LIGHT_ATTR_ENCODE(fg, bg)       (((fg << 8) & 0xff00) | (bg * 0x00ff))
#define LIGHT_ATTR_FG(attr)             ((attr >> 8) & 0x00ff)
#define LIGHT_ATTR_BG(attr)             (attr & 0x00ff)

#define LIGHT_IS_LG1(_rev)              ((_rev) < 2)    /* else LG2 */

/*******************************************************************************
* REX routines and helper functions
******************************************************************************/

static uint32_t
rex_read(struct light_devconfig *dc, uint32_t rset, uint32_t r)
{

       return (bus_space_read_4(dc->dc_st, dc->dc_sh, rset + r));
}

static void
rex_write(struct light_devconfig *dc, uint32_t rset, uint32_t r, uint32_t v)
{

       bus_space_write_4(dc->dc_st, dc->dc_sh, rset + r, v);
}

static uint8_t
rex_vc1_read(struct light_devconfig *dc)
{

       rex_write(dc, REX_PAGE1_GO, REX_P1REG_CFGSEL, REX_CFGSEL_VC1_SYSCTL);
       rex_read(dc, REX_PAGE1_GO, REX_P1REG_VC1_ADDRDATA);
       return (rex_read(dc, REX_PAGE1_SET, REX_P1REG_VC1_ADDRDATA));
}

static void
rex_vc1_write(struct light_devconfig *dc, uint8_t val)
{

       rex_write(dc, REX_PAGE1_GO, REX_P1REG_CFGSEL, REX_CFGSEL_VC1_SYSCTL);
       rex_write(dc, REX_PAGE1_SET, REX_P1REG_VC1_ADDRDATA, val);
       rex_write(dc, REX_PAGE1_GO, REX_P1REG_VC1_ADDRDATA, val);
}

static void
rex_wait(struct light_devconfig *dc)
{

       while (rex_read(dc, REX_PAGE1_SET,REX_P1REG_CFGMODE) & REX_CFGMODE_BUSY)
               ;
}

static int
rex_revision(struct light_devconfig *dc)
{

       rex_write(dc, REX_PAGE1_SET, REX_P1REG_CFGSEL, REX_CFGSEL_VC1_LADDR);
       rex_read(dc, REX_PAGE1_GO, REX_P1REG_WCLOCKREV);
       return (rex_read(dc, REX_PAGE1_SET, REX_P1REG_WCLOCKREV) & 0x7);
}

static void
rex_copy_rect(struct light_devconfig *dc, int from_x, int from_y, int to_x,
   int to_y, int width, int height)
{
       int dx, dy, ystarti, yendi;

       dx = from_x - to_x;
       dy = from_y - to_y;

       /* adjust for y. NB: STOPONX, STOPONY are inclusive */
       if (to_y > from_y) {
               ystarti = to_y + height - 1;
               yendi = to_y;
       } else {
               ystarti = to_y;
               yendi = to_y + height - 1;
       }

       rex_wait(dc);

       rex_write(dc, REX_PAGE0_SET, REX_P0REG_XSTARTI, to_x);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_XENDI, to_x + width);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_YSTARTI, ystarti);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_YENDI, yendi);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_COMMAND, REX_OP_DRAW |
           REX_LOGICOP_SRC | REX_OP_FLG_LOGICSRC | REX_OP_FLG_QUADMODE |
           REX_OP_FLG_BLOCK | REX_OP_FLG_STOPONX | REX_OP_FLG_STOPONY);
       rex_write(dc, REX_PAGE0_GO, REX_P0REG_XYMOVE,
           ((dx << 16) & 0xffff0000) | (dy & 0x0000ffff));
}

static void
rex_fill_rect(struct light_devconfig *dc, int from_x, int from_y, int to_x,
   int to_y, long attr)
{

       rex_wait(dc);

       rex_write(dc, REX_PAGE0_SET, REX_P0REG_YSTARTI, from_y);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_YENDI, to_y);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_XSTARTI, from_x);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_XENDI, to_x);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_COLORREDI, LIGHT_ATTR_BG(attr));
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_COMMAND, REX_OP_DRAW |
           REX_LOGICOP_SRC | REX_OP_FLG_QUADMODE | REX_OP_FLG_BLOCK |
           REX_OP_FLG_STOPONX | REX_OP_FLG_STOPONY);
       rex_read(dc, REX_PAGE0_GO, REX_P0REG_COMMAND);
}

/*******************************************************************************
* match/attach functions
******************************************************************************/

static int
light_match(device_t parent, cfdata_t cf, void *aux)
{
       struct gio_attach_args *ga = aux;

       if (ga->ga_addr != LIGHT_ADDR_0 && ga->ga_addr != LIGHT_ADDR_1)
               return (0);

       if (platform.badaddr(
           (void *)(intptr_t)(ga->ga_ioh + REX_PAGE1_SET + REX_P1REG_XYOFFSET),
           sizeof(uint32_t)))
               return (0);

       if (bus_space_read_4(ga->ga_iot, ga->ga_ioh,
           REX_PAGE1_SET + REX_P1REG_XYOFFSET) != 0x08000800)
               return (0);

       return (1);
}

static void
light_attach_common(struct light_devconfig *dc, struct gio_attach_args *ga)
{

       dc->dc_addr = ga->ga_addr;
       dc->dc_st = ga->ga_iot;
       dc->dc_sh = ga->ga_ioh;

       dc->dc_boardrev = rex_revision(dc);

       wsfont_init();

       dc->dc_font = wsfont_find(NULL, 8, 16, 0, WSDISPLAY_FONTORDER_L2R,
           WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP);

       if (dc->dc_font < 0)
               panic("light_attach_common: no suitable fonts");

       if (wsfont_lock(dc->dc_font, &dc->dc_fontdata))
               panic("light_attach_common: unable to lock font data");

       rex_vc1_write(dc, rex_vc1_read(dc) & ~(VC1_SYSCTL_CURSOR |
           VC1_SYSCTL_CURSOR_ON));
       rex_fill_rect(dc, 0, 0, LIGHT_XRES - 1, LIGHT_YRES - 1, 0);
}

static void
light_attach(device_t parent, device_t self, void *aux)
{
       struct gio_attach_args *ga = aux;
       struct light_softc *sc = device_private(self);
       struct wsemuldisplaydev_attach_args wa;

       if (light_is_console && ga->ga_addr == light_console_dc.dc_addr) {
               wa.console = 1;
               sc->sc_dc = &light_console_dc;
       } else {
               wa.console = 0;
               sc->sc_dc = kmem_zalloc(sizeof(struct light_devconfig),
                   KM_SLEEP);

               light_attach_common(sc->sc_dc, ga);
       }

       aprint_naive(": Display adapter\n");

       aprint_normal(": SGI LG%d (board revision %d)\n",
           LIGHT_IS_LG1(sc->sc_dc->dc_boardrev) ? 1 : 2,
           sc->sc_dc->dc_boardrev);

       wa.scrdata = &light_screenlist;
       wa.accessops = &light_accessops;
       wa.accesscookie = sc->sc_dc;

       config_found(self, &wa, wsemuldisplaydevprint, CFARGS_NONE);
}

int
light_cnattach(struct gio_attach_args *ga)
{

       if (!light_match(NULL, NULL, ga))
               return (ENXIO);

       light_attach_common(&light_console_dc, ga);

       wsdisplay_cnattach(&light_screen, &light_console_dc, 0, 0,
           LIGHT_ATTR_ENCODE(WSCOL_WHITE, WSCOL_BLACK));

       light_is_console = 1;

       return (0);
}

/*******************************************************************************
* wsdisplay_emulops
******************************************************************************/

static void
light_cursor(void *c, int on, int row, int col)
{
       /* XXX */
}

static int
light_mapchar(void *c, int ch, unsigned int *cp)
{
       struct light_devconfig *dc = (void *)c;

       if (dc->dc_fontdata->encoding != WSDISPLAY_FONTENC_ISO) {
               ch = wsfont_map_unichar(dc->dc_fontdata, ch);

               if (ch < 0)
                       goto fail;
       }

       if (ch < dc->dc_fontdata->firstchar ||
           ch >= dc->dc_fontdata->firstchar + dc->dc_fontdata->numchars)
               goto fail;

       *cp = ch;
       return 5;

fail:
       *cp = ' ';
       return 0;
}

static void
light_putchar(void *c, int row, int col, u_int ch, long attr)
{
       struct light_devconfig *dc = c;
       struct wsdisplay_font *font = dc->dc_fontdata;
       uint8_t *bitmap;
       uint32_t pattern;
       int i, x, y;

       bitmap = (u_int8_t *)font->data +
           ((ch - font->firstchar) * font->fontheight * font->stride);
       x = col * font->fontwidth;
       y = row * font->fontheight;

       rex_wait(dc);

       rex_write(dc, REX_PAGE0_SET, REX_P0REG_YSTARTI, y);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_YENDI, y + font->fontheight - 1);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_XSTARTI, x);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_XENDI, x + font->fontwidth - 1);
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_COLORREDI, LIGHT_ATTR_FG(attr));
       rex_write(dc, REX_PAGE0_SET, REX_P0REG_COLORBACK, LIGHT_ATTR_BG(attr));
       rex_write(dc, REX_PAGE0_GO,  REX_P0REG_COMMAND, REX_OP_NOP);

       rex_wait(dc);

       rex_write(dc, REX_PAGE0_SET, REX_P0REG_COMMAND, REX_OP_DRAW |
           REX_LOGICOP_SRC | REX_OP_FLG_ENZPATTERN | REX_OP_FLG_QUADMODE |
           REX_OP_FLG_XYCONTINUE | REX_OP_FLG_STOPONX | REX_OP_FLG_BLOCK |
           REX_OP_FLG_LENGTH32 | REX_OP_FLG_ZOPAQUE);

       for (i = 0; i < font->fontheight; i++) {
               /* XXX assumes font->fontwidth == 8 */
               pattern = *bitmap << 24;
               rex_write(dc, REX_PAGE0_GO, REX_P0REG_ZPATTERN, pattern);
               bitmap += font->stride;
       }
}

/* copy set of columns within the same line */
static void
light_copycols(void *c, int row, int srccol, int dstcol, int ncols)
{
       struct light_devconfig *dc = c;
       struct wsdisplay_font *font = dc->dc_fontdata;
       int from_x, from_y, to_x, to_y, width, height;

       from_x  = srccol * font->fontwidth;
       from_y  = row * font->fontheight;
       to_x    = dstcol * font->fontwidth;
       to_y    = from_y;
       width   = ncols * font->fontwidth;
       height  = font->fontheight;

       rex_copy_rect(c, from_x, from_y, to_x, to_y, width, height);
}

/* erase a set of columns in the same line */
static void
light_erasecols(void *c, int row, int startcol, int ncols, long attr)
{
       struct light_devconfig *dc = c;
       struct wsdisplay_font *font = dc->dc_fontdata;
       int from_x, from_y, to_x, to_y;

       from_x  = startcol * font->fontwidth;
       from_y  = row * font->fontheight;
       to_x    = from_x + (ncols * font->fontwidth) - 1;
       to_y    = from_y + font->fontheight - 1;

       rex_fill_rect(c, from_x, from_y, to_x, to_y, attr);
}

/* copy a set of complete rows */
static void
light_copyrows(void *c, int srcrow, int dstrow, int nrows)
{
       struct light_devconfig *dc = c;
       struct wsdisplay_font *font = dc->dc_fontdata;
       int from_x, from_y, to_x, to_y, width, height;

       from_x  = 0;
       from_y  = srcrow * font->fontheight;
       to_x    = 0;
       to_y    = dstrow * font->fontheight;
       width   = LIGHT_XRES;
       height  = nrows * font->fontheight;

       rex_copy_rect(c, from_x, from_y, to_x, to_y, width, height);
}

/* erase a set of complete rows */
static void
light_eraserows(void *c, int row, int nrows, long attr)
{
       struct light_devconfig *dc = c;
       struct wsdisplay_font *font = dc->dc_fontdata;
       int from_x, from_y, to_x, to_y;

       from_x  = 0;
       from_y  = row * font->fontheight;
       to_x    = LIGHT_XRES - 1;
       to_y    = from_y + (nrows * font->fontheight) - 1;

       rex_fill_rect(c, from_x, from_y, to_x, to_y, attr);
}

static int
light_allocattr(void *c, int fg, int bg, int flags, long *attr)
{

       if (flags & ~(WSATTR_WSCOLORS | WSATTR_HILIT | WSATTR_REVERSE))
               return (EINVAL);

       if ((flags & WSATTR_WSCOLORS) == 0) {
               fg = WSCOL_WHITE;
               bg = WSCOL_BLACK;
       }

       if (flags & WSATTR_HILIT)
               fg += 8;

       if (flags & WSATTR_REVERSE) {
               int tmp = fg;
               fg = bg;
               bg = tmp;
       }

       *attr = LIGHT_ATTR_ENCODE(fg, bg);
       return (0);
}

/*******************************************************************************
* wsdisplay_accessops
******************************************************************************/

static int
light_ioctl(void *c, void *vs, u_long cmd, void *data, int flag,
   struct lwp *l)
{
       struct wsdisplay_fbinfo *fbinfo = (struct wsdisplay_fbinfo *)data;

       switch (cmd) {
       case WSDISPLAYIO_GINFO:
               fbinfo->width   = LIGHT_XRES;
               fbinfo->height  = LIGHT_YRES;
               fbinfo->depth   = LIGHT_DEPTH;
               fbinfo->cmsize  = 1 << LIGHT_DEPTH;
               return (0);

       case WSDISPLAYIO_GMODE:
               *(u_int *)data = WSDISPLAYIO_MODE_EMUL;
               break;

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

       case WSDISPLAYIO_SVIDEO:
               /*
                * Turning off VC1 will stop refreshing the video ram (or so I
                * suspect). We'll blank the screen after bringing it back up,
                * since that's nicer than displaying garbage.
                */
               if (*(u_int *)data == WSDISPLAYIO_VIDEO_OFF)
                       rex_vc1_write(c,rex_vc1_read(c) & ~VC1_SYSCTL_VIDEO_ON);
               else {
                       rex_vc1_write(c, rex_vc1_read(c) | VC1_SYSCTL_VIDEO_ON);
                       rex_fill_rect(c, 0, 0, LIGHT_XRES-1, LIGHT_YRES-1, 0);
               }
               return (0);
       }

       return (EPASSTHROUGH);
}

static paddr_t
light_mmap(void *c, void *vs, off_t off, int prot)
{
       struct light_devconfig *dc = c;

       if (off >= 0x7fff)
               return (-1);

       return (mips_btop(dc->dc_addr + off));
}

static int
light_alloc_screen(void *c, const struct wsscreen_descr *type, void **cookiep,
   int *curxp, int *curyp, long *attr)
{

       return (ENOMEM);
}

static void
light_free_screen(void *c, void *cookie)
{

       panic("light_free_screen");
}

static int
light_show_screen(void *c, void *cookie, int waitok,
   void (*cb)(void *, int, int), void *cbarg)
{

       return (0);
}

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.