/*      $NetBSD: ite.c,v 1.23 2025/05/30 19:19:26 tsutsui Exp $ */

/*
* Copyright (c) 1988 University of Utah.
* Copyright (c) 1990, 1993
*      The Regents of the University of California.  All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* the Systems Programming Group of the University of Utah Computer
* Science Department.
*
* 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. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
* from: Utah $Hdr: ite.c 1.24 93/06/25$
*
*      @(#)ite.c       8.1 (Berkeley) 7/8/93
*/

/*
* Standalone Internal Terminal Emulator (CRT and keyboard)
*/

#ifdef ITECONSOLE

#include <sys/param.h>
#include <dev/cons.h>

#include <hp300/dev/diofbreg.h>
#include <hp300/dev/intioreg.h>
#include <hp300/dev/dioreg.h>
#include <hp300/dev/sgcreg.h>
#include <dev/ic/stireg.h>

#include <hp300/stand/common/device.h>
#include <hp300/stand/common/itevar.h>
#include <hp300/stand/common/kbdvar.h>
#include <hp300/stand/common/consdefs.h>
#include <hp300/stand/common/samachdep.h>

static void iteconfig(void);
static void ite_scroll(struct ite_data *);
static void itecheckwrap(struct ite_data *);

#define GID_STI         0x100   /* any value which is not a DIO fb, really */

static const struct itesw itesw[] = {
       {
               .ite_hwid   = GID_TOPCAT,
               .ite_probe  = NULL,
               .ite_init   = topcat_init,
               .ite_clear  = ite_dio_clear,
               .ite_putc   = ite_dio_putc8bpp,
               .ite_cursor = ite_dio_cursor,
               .ite_scroll = ite_dio_scroll
       },

       {
               .ite_hwid   = GID_GATORBOX,
               .ite_probe  = NULL,
               .ite_init   = gbox_init,
               .ite_clear  = ite_dio_clear,
               .ite_putc   = ite_dio_putc8bpp,
               .ite_cursor = ite_dio_cursor,
               .ite_scroll = gbox_scroll
       },

       {
               .ite_hwid   = GID_RENAISSANCE,
               .ite_probe  = NULL,
               .ite_init   = rbox_init,
               .ite_clear  = ite_dio_clear,
               .ite_putc   = ite_dio_putc8bpp,
               .ite_cursor = ite_dio_cursor,
               .ite_scroll = ite_dio_scroll
       },

       {
               .ite_hwid   = GID_LRCATSEYE,
               .ite_probe  = NULL,
               .ite_init   = topcat_init,
               .ite_clear  = ite_dio_clear,
               .ite_putc   = ite_dio_putc8bpp,
               .ite_cursor = ite_dio_cursor,
               .ite_scroll = ite_dio_scroll
       },

       {
               .ite_hwid   = GID_HRCCATSEYE,
               .ite_probe  = NULL,
               .ite_init   = topcat_init,
               .ite_clear  = ite_dio_clear,
               .ite_putc   = ite_dio_putc8bpp,
               .ite_cursor = ite_dio_cursor,
               .ite_scroll = ite_dio_scroll
       },

       {
               .ite_hwid   = GID_HRMCATSEYE,
               .ite_probe  = NULL,
               .ite_init   = topcat_init,
               .ite_clear  = ite_dio_clear,
               .ite_putc   = ite_dio_putc8bpp,
               .ite_cursor = ite_dio_cursor,
               .ite_scroll = ite_dio_scroll
       },

       {
               .ite_hwid   = GID_DAVINCI,
               .ite_probe  = NULL,
               .ite_init   = dvbox_init,
               .ite_clear  = ite_dio_clear,
               .ite_putc   = ite_dio_putc8bpp,
               .ite_cursor = ite_dio_cursor,
               .ite_scroll = ite_dio_scroll
       },

       {
               .ite_hwid   = GID_HYPERION,
               .ite_probe  = NULL,
               .ite_init   = hyper_init,
               .ite_clear  = ite_dio_clear,
               .ite_putc   = ite_dio_putc1bpp,
               .ite_cursor = ite_dio_cursor,
               .ite_scroll = ite_dio_scroll
       },

       {
               .ite_hwid   = GID_TIGER,
               .ite_probe  = NULL,
               .ite_init   = tvrx_init,
               .ite_clear  = ite_dio_clear,
               .ite_putc   = ite_dio_putc1bpp,
               .ite_cursor = ite_dio_cursor,
               .ite_scroll = ite_dio_scroll
       },

       {
               .ite_hwid   = GID_A1474MID,
               .ite_probe  = sti_dio_probe,
               .ite_init   = sti_iteinit_dio,
               .ite_clear  = sti_clear,
               .ite_putc   = sti_putc,
               .ite_cursor = sti_cursor,
               .ite_scroll = sti_scroll
       },

       {
               .ite_hwid   = GID_A147xVGA,
               .ite_probe  = sti_dio_probe,
               .ite_init   = sti_iteinit_dio,
               .ite_clear  = sti_clear,
               .ite_putc   = sti_putc,
               .ite_cursor = sti_cursor,
               .ite_scroll = sti_scroll
       },

       {
               .ite_hwid   = GID_STI,
               .ite_probe  = NULL,
               .ite_init   = sti_iteinit_sgc,
               .ite_clear  = sti_clear,
               .ite_putc   = sti_putc,
               .ite_cursor = sti_cursor,
               .ite_scroll = sti_scroll
       },
};

/* these guys need to be in initialized data */
static int itecons = -1;
static struct  ite_data ite_data[NITE] = { { 0 } };

/*
* Locate all bitmapped displays
*/
static void
iteconfig(void)
{
       int dtype, fboff, slotno, i;
       uint8_t *va;
       struct hp_hw *hw;
       struct diofbreg *fb;
       struct ite_data *ip;

       i = 0;
       for (hw = sc_table; hw < &sc_table[MAXCTLRS]; hw++) {
               if (!HW_ISDEV(hw, D_BITMAP))
                       continue;
               fb = (struct diofbreg *)hw->hw_kva;
               /* XXX: redundent but safe */
               if (badaddr((void *)fb) || fb->id != GRFHWID)
                       continue;
               for (dtype = 0; dtype < __arraycount(itesw); dtype++)
                       if (itesw[dtype].ite_hwid == fb->fbid)
                               break;
               if (dtype == __arraycount(itesw))
                       continue;
               if (i >= NITE)
                       break;
               ip = &ite_data[i];
               ip->scode = hw->hw_sc;
               ip->isw = &itesw[dtype];
               ip->regbase = (void *)fb;
               fboff = (fb->fbomsb << 8) | fb->fbolsb;
               ip->fbbase = (void *)(*((uint8_t *)ip->regbase + fboff) << 16);
               /* DIO II: FB offset is relative to select code space */
               if (DIO_ISDIOII(ip->scode))
                       ip->fbbase = (uint8_t *)ip->fbbase + (int)ip->regbase;
               ip->fbwidth  = fb->fbwmsb << 8 | fb->fbwlsb;
               ip->fbheight = fb->fbhmsb << 8 | fb->fbhlsb;
               ip->dwidth   = fb->dwmsb  << 8 | fb->dwlsb;
               ip->dheight  = fb->dhmsb  << 8 | fb->dhlsb;
               /*
                * XXX some displays (e.g. the davinci) appear
                * to return a display height greater than the
                * returned FB height.  Guess we should go back
                * to getting the display dimensions from the
                * fontrom...
                */
               if (ip->dwidth > ip->fbwidth)
                       ip->dwidth = ip->fbwidth;
               if (ip->dheight > ip->fbheight)
                       ip->dheight = ip->fbheight;
               /* confirm hardware is what we think it is */
               if (itesw[dtype].ite_probe != NULL &&
                   (*itesw[dtype].ite_probe)(ip) != 0)
                       continue;
               ip->alive = 1;
               i++;
       }

       /*
        * Now probe for SGC frame buffers.
        */
       switch (machineid) {
       case HP_400:
       case HP_425:
       case HP_433:
               break;
       default:
               return;
       }

       /* SGC frame buffers can only be STI... */
       for (dtype = 0; dtype < __arraycount(itesw); dtype++)
               if (itesw[dtype].ite_hwid == GID_STI)
                       break;
       if (dtype == __arraycount(itesw))
               return;

       for (slotno = 0; slotno < SGC_NSLOTS; slotno++) {
               va = (uint8_t *)IIOV(SGC_BASE + (slotno * SGC_DEVSIZE));

               /* Check to see if hardware exists. */
               if (badaddr(va) != 0)
                       continue;

               /* Check hardware. */
               if (va[3] == STI_DEVTYPE1) {
                       if (i >= NITE)
                               break;
                       ip = &ite_data[i];
                       ip->scode = slotno;
                       ip->isw = &itesw[dtype];
                       /* to get CN_MIDPRI */
                       ip->regbase = (uint8_t *)(INTIOBASE + FB_BASE);
                       /* ...and do not need an ite_probe() check */
                       ip->alive = 1;
                       i++;
                       /* we only support one SGC frame buffer at the moment */
                       break;
               }
       }
}

#ifdef CONSDEBUG
/*
* Allows us to cycle through all possible consoles (NITE ites and serial port)
* by using SHIFT-RESET on the keyboard.
*/
int     whichconsole = -1;
#endif

void
iteprobe(struct consdev *cp)
{
       int ite;
       struct ite_data *ip;
       int unit, pri;

#ifdef CONSDEBUG
       whichconsole = (whichconsole + 1) % (NITE + 1);
#endif

       if (itecons != -1)
               return;

       iteconfig();
       unit = -1;
       pri = CN_DEAD;
       for (ite = 0; ite < NITE; ite++) {
#ifdef CONSDEBUG
               if (ite < whichconsole)
                       continue;
#endif
               ip = &ite_data[ite];
               if (ip->alive == 0)
                       continue;
               if ((int)ip->regbase == INTIOBASE + FB_BASE) {
                       pri = CN_INTERNAL;
                       unit = ite;
               } else if (unit < 0) {
                       pri = CN_NORMAL;
                       unit = ite;
               }
       }
       ip = &ite_data[unit];
       curcons_scode = ip->scode;
       cp->cn_dev = unit;
       cp->cn_pri = pri;
}

void
iteinit(struct consdev *cp)
{
       int ite = cp->cn_dev;
       struct ite_data *ip;
       const struct itesw *sp;

       if (itecons != -1)
               return;

       ip = &ite_data[ite];
       sp = ip->isw;

       ip->curx = 0;
       ip->cury = 0;
       ip->cursorx = 0;
       ip->cursory = 0;

       (*sp->ite_init)(ip);
       (*sp->ite_cursor)(ip, DRAW_CURSOR);

       itecons = ite;
       kbdinit();
}

void
iteputchar(dev_t dev, int c)
{
       struct ite_data *ip = &ite_data[itecons];
       const struct itesw *sp = ip->isw;

       c &= 0x7F;
       switch (c) {

       case '\n':
               if (++ip->cury == ip->rows) {
                       ip->cury--;
                       ite_scroll(ip);
               } else
                       (*sp->ite_cursor)(ip, MOVE_CURSOR);
               break;

       case '\r':
               ip->curx = 0;
               (*sp->ite_cursor)(ip, MOVE_CURSOR);
               break;

       case '\b':
               if (--ip->curx < 0)
                       ip->curx = 0;
               else
                       (*sp->ite_cursor)(ip, MOVE_CURSOR);
               break;

       default:
               if (c < ' ' || c == 0177)
                       break;
               (*sp->ite_putc)(ip, c, ip->cury, ip->curx);
               (*sp->ite_cursor)(ip, DRAW_CURSOR);
               itecheckwrap(ip);
               break;
       }
}

static void
itecheckwrap(struct ite_data *ip)
{
       const struct itesw *sp = ip->isw;

       if (++ip->curx == ip->cols) {
               ip->curx = 0;
               if (++ip->cury == ip->rows) {
                       --ip->cury;
                       ite_scroll(ip);
                       return;
               }
       }
       (*sp->ite_cursor)(ip, MOVE_CURSOR);
}

static void
ite_scroll(struct ite_data *ip)
{
       const struct itesw *sp = ip->isw;

       /* Erase the cursor before scrolling */
       (*sp->ite_cursor)(ip, ERASE_CURSOR);
       /* Scroll the screen up by one line */
       (*sp->ite_scroll)(ip);
       /* Clear the entire bottom line after scrolling */
       (*sp->ite_clear)(ip, ip->rows - 1, 0, 1, ip->cols);
       /* Redraw the cursor */
       (*sp->ite_cursor)(ip, DRAW_CURSOR);
}

int
itegetchar(dev_t dev)
{

#ifdef SMALL
       return 0;
#else
       return kbdgetc();
#endif
}
#endif

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.