/*      $NetBSD: ite_subr.c,v 1.13 2025/05/31 18:11:50 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_subr.c 1.2 92/01/20$
*
*      @(#)ite_subr.c  8.1 (Berkeley) 6/10/93
*/

#ifdef ITECONSOLE

#include <sys/param.h>

#include <hp300/stand/common/itereg.h>

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

static void ite_writeglyph(struct ite_data *, uint8_t *, uint8_t *);

void
ite_fontinfo(struct ite_data *ip)
{
       uint32_t fontaddr = getword(ip, getword(ip, FONTROM) + FONTADDR);

       ip->ftheight = getbyte(ip, fontaddr + FONTHEIGHT);
       ip->ftwidth  = getbyte(ip, fontaddr + FONTWIDTH);
       ip->rows     = ip->dheight / ip->ftheight;
       ip->cols     = ip->dwidth / ip->ftwidth;

       if (ip->fbwidth > ip->dwidth) {
               /*
                * Stuff goes to right of display.
                */
               ip->fontx    = ip->dwidth;
               ip->fonty    = 0;
               ip->cpl      = (ip->fbwidth - ip->dwidth) / ip->ftwidth;
               ip->cblankx  = ip->dwidth;
               ip->cblanky  = ip->fonty + ((128 / ip->cpl) +1) * ip->ftheight;
       } else {
               /*
                * Stuff goes below the display.
                */
               ip->fontx   = 0;
               ip->fonty   = ip->dheight;
               ip->cpl     = ip->fbwidth / ip->ftwidth;
               ip->cblankx = 0;
               ip->cblanky = ip->fonty + ((128 / ip->cpl) + 1) * ip->ftheight;
       }
}

void
ite_fontinit1bpp(struct ite_data *ip)
{
       uint8_t *fbmem, *dp;
       int c, l, b;
       int stride, width;

       dp = (uint8_t *)(getword(ip, getword(ip, FONTROM) + FONTADDR) +
           (uint8_t *)ip->regbase) + FONTDATA;
       stride = ip->fbwidth >> 3;
       width = (ip->ftwidth + 7) / 8;

       for (c = 0; c < 128; c++) {
               fbmem = (uint8_t *)FBBASE +
                   (ip->fonty + (c / ip->cpl) * ip->ftheight) * stride;
               fbmem += (ip->fontx >> 3) + (c % ip->cpl) * width;
               for (l = 0; l < ip->ftheight; l++) {
                       for (b = 0; b < width; b++) {
                               *fbmem++ = *dp;
                               dp += 2;
                       }
                       fbmem -= width;
                       fbmem += stride;
               }
       }
}

void
ite_fontinit8bpp(struct ite_data *ip)
{
       int bytewidth = (((ip->ftwidth - 1) / 8) + 1);
       int glyphsize = bytewidth * ip->ftheight;
       uint8_t fontbuf[500];
       uint8_t *dp, *fbmem;
       int c, i, romp;

       romp = getword(ip, getword(ip, FONTROM) + FONTADDR) + FONTDATA;
       for (c = 0; c < 128; c++) {
               fbmem = (uint8_t *)(FBBASE +
                    (ip->fonty + (c / ip->cpl) * ip->ftheight) * ip->fbwidth +
                    (ip->fontx + (c % ip->cpl) * ip->ftwidth));
               dp = fontbuf;
               for (i = 0; i < glyphsize; i++) {
                       *dp++ = getbyte(ip, romp);
                       romp += 2;
               }
               ite_writeglyph(ip, fbmem, fontbuf);
       }
}

static void
ite_writeglyph(struct ite_data *ip, uint8_t *fbmem, uint8_t *glyphp)
{
       int bn;
       int l, b;

       for (l = 0; l < ip->ftheight; l++) {
               bn = 7;
               for (b = 0; b < ip->ftwidth; b++) {
                       if ((1 << bn) & *glyphp)
                               *fbmem++ = 1;
                       else
                               *fbmem++ = 0;
                       if (--bn < 0) {
                               bn = 7;
                               glyphp++;
                       }
               }
               if (bn < 7)
                       glyphp++;
               fbmem -= ip->ftwidth;
               fbmem += ip->fbwidth;
       }
}

/*
* The cursor is just an inverted space.
*/
#define flip_cursor(ip) \
       (*ip->bmv)(ip, ip->cblanky, ip->cblankx, ip->cursory * ip->ftheight, \
           ip->cursorx * ip->ftwidth, ip->ftheight, ip->ftwidth, RR_XOR)

void
ite_dio_cursor(struct ite_data *ip, int flag)
{

       switch (flag) {
       case MOVE_CURSOR:
               flip_cursor(ip);
               /* FALLTHROUGH */
       case DRAW_CURSOR:
               ip->cursorx = ip->curx;
               ip->cursory = ip->cury;
               /* FALLTHROUGH */
       case ERASE_CURSOR:
       default:
               flip_cursor(ip);
               break;
       }
}

void
ite_dio_putc1bpp(struct ite_data *ip, int c, int dy, int dx)
{

       ite_dio_windowmove1bpp(ip, charY(ip, c), charX1bpp(ip, c),
           dy * ip->ftheight, dx * ip->ftwidth,
           ip->ftheight, ip->ftwidth, RR_COPY);
}

void
ite_dio_putc8bpp(struct ite_data *ip, int c, int dy, int dx)
{

       (*ip->bmv)(ip, charY(ip, c), charX(ip, c),
           dy * ip->ftheight, dx * ip->ftwidth,
           ip->ftheight, ip->ftwidth, RR_COPY);
}

void
ite_dio_clear(struct ite_data *ip, int sy, int sx, int h, int w)
{

       (*ip->bmv)(ip, sy * ip->ftheight, sx * ip->ftwidth,
           sy * ip->ftheight, sx * ip->ftwidth,
           h  * ip->ftheight, w  * ip->ftwidth, RR_CLEAR);
}

void
ite_dio_scroll(struct ite_data *ip)
{

       (*ip->bmv)(ip, ip->ftheight, 0, 0, 0, (ip->rows - 1) * ip->ftheight,
           ip->cols * ip->ftwidth, RR_COPY);
}

#include <hp300/stand/common/maskbits.h>

/* NOTE:
* the first element in starttab could be 0xffffffff.  making it 0
* lets us deal with a full first word in the middle loop, rather
* than having to do the multiple reads and masks that we'd
* have to do if we thought it was partial.
*/
static const uint32_t starttab[32] = {
       0x00000000,
       0x7FFFFFFF,
       0x3FFFFFFF,
       0x1FFFFFFF,
       0x0FFFFFFF,
       0x07FFFFFF,
       0x03FFFFFF,
       0x01FFFFFF,
       0x00FFFFFF,
       0x007FFFFF,
       0x003FFFFF,
       0x001FFFFF,
       0x000FFFFF,
       0x0007FFFF,
       0x0003FFFF,
       0x0001FFFF,
       0x0000FFFF,
       0x00007FFF,
       0x00003FFF,
       0x00001FFF,
       0x00000FFF,
       0x000007FF,
       0x000003FF,
       0x000001FF,
       0x000000FF,
       0x0000007F,
       0x0000003F,
       0x0000001F,
       0x0000000F,
       0x00000007,
       0x00000003,
       0x00000001
};

static const uint32_t endtab[32] = {
       0x00000000,
       0x80000000,
       0xC0000000,
       0xE0000000,
       0xF0000000,
       0xF8000000,
       0xFC000000,
       0xFE000000,
       0xFF000000,
       0xFF800000,
       0xFFC00000,
       0xFFE00000,
       0xFFF00000,
       0xFFF80000,
       0xFFFC0000,
       0xFFFE0000,
       0xFFFF0000,
       0xFFFF8000,
       0xFFFFC000,
       0xFFFFE000,
       0xFFFFF000,
       0xFFFFF800,
       0xFFFFFC00,
       0xFFFFFE00,
       0xFFFFFF00,
       0xFFFFFF80,
       0xFFFFFFC0,
       0xFFFFFFE0,
       0xFFFFFFF0,
       0xFFFFFFF8,
       0xFFFFFFFC,
       0xFFFFFFFE
};

void
ite_dio_windowmove1bpp(struct ite_data *ip, int sy, int sx, int dy, int dx,
   int h, int w, int func)
{
       int width;              /* add to get to same position in next line */

       uint32_t *psrcLine, *pdstLine;
                               /* pointers to line with current src and dst */
       uint32_t *psrc;         /* pointer to current src longword */
       uint32_t *pdst;         /* pointer to current dst longword */

                               /* following used for looping through a line */
       uint32_t startmask, endmask;  /* masks for writing ends of dst */
       int nlMiddle;           /* whole longwords in dst */
       int nl;                 /* temp copy of nlMiddle */
       uint32_t tmpSrc;        /* place to store full source word */
       int xoffSrc;            /* offset (>= 0, < 32) from which to
                                  fetch whole longwords fetched
                                  in src */
       int nstart;             /* number of ragged bits at start of dst */
       int nend;               /* number of ragged bits at end of dst */
       int srcStartOver;       /* pulling nstart bits from src
                                  overflows into the next word? */

       if (h == 0 || w == 0)
               return;

       width = ip->fbwidth >> 5;
       psrcLine = ((uint32_t *)ip->fbbase) + (sy * width);
       pdstLine = ((uint32_t *)ip->fbbase) + (dy * width);

       /* x direction doesn't matter for < 1 longword */
       if (w <= 32) {
               int srcBit, dstBit;     /* bit offset of src and dst */

               pdstLine += (dx >> 5);
               psrcLine += (sx >> 5);
               psrc = psrcLine;
               pdst = pdstLine;

               srcBit = sx & 0x1f;
               dstBit = dx & 0x1f;

               while (h-- > 0) {
                       getandputrop(psrc, srcBit, dstBit, w, pdst, func);
                       pdst += width;
                       psrc += width;
               }
       } else {
               maskbits(dx, w, startmask, endmask, nlMiddle);
               if (startmask != 0)
                       nstart = 32 - (dx & 0x1f);
               else
                       nstart = 0;
               if (endmask != 0)
                       nend = (dx + w) & 0x1f;
               else
                       nend = 0;

               xoffSrc = ((sx & 0x1f) + nstart) & 0x1f;
               srcStartOver = ((sx & 0x1f) + nstart) > 31;

               pdstLine += (dx >> 5);
               psrcLine += (sx >> 5);

               while (h-- > 0) {
                       psrc = psrcLine;
                       pdst = pdstLine;

                       if (startmask != 0) {
                               getandputrop(psrc, (sx & 0x1f), (dx & 0x1f),
                                   nstart, pdst, func);
                               pdst++;
                               if (srcStartOver != 0)
                                       psrc++;
                       }

                       /* special case for aligned operations */
                       if (xoffSrc == 0) {
                               nl = nlMiddle;
                               while (nl-- > 0) {
                                       DoRop(*pdst, func, *psrc++, *pdst);
                                       pdst++;
                               }
                       } else {
                               nl = nlMiddle + 1;
                               while (--nl > 0) {
                                       getunalignedword(psrc, xoffSrc, tmpSrc);
                                       DoRop(*pdst, func, tmpSrc, *pdst);
                                       pdst++;
                                       psrc++;
                               }
                       }

                       if (endmask != 0) {
                               getandputrop0(psrc, xoffSrc, nend, pdst, func);
                       }

                       pdstLine += width;
                       psrcLine += width;
               }
       }
}
#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.