root/dev/ic/pcdisplay_subr.c

DEFINITIONS

1. pcdisplay_cursor_reset
2. pcdisplay_cursor_init
3. pcdisplay_cursor
4. pcdisplay_mapchar_simple
5. pcdisplay_putchar
6. pcdisplay_getchar
7. pcdisplay_copycols
8. pcdisplay_erasecols
9. pcdisplay_copyrows
10. pcdisplay_eraserows

    1 /* $OpenBSD: pcdisplay_subr.c,v 1.7 2006/11/29 19:11:15 miod Exp $ */
    2 /* $NetBSD: pcdisplay_subr.c,v 1.16 2000/06/08 07:01:19 cgd Exp $ */
    4 /*
    5  * Copyright (c) 1995, 1996 Carnegie-Mellon University.
    6  * All rights reserved.
    7  *
    8  * Author: Chris G. Demetriou
    9  * 
   10  * Permission to use, copy, modify and distribute this software and
   11  * its documentation is hereby granted, provided that both the copyright
   12  * notice and this permission notice appear in all copies of the
   13  * software, derivative works or modified versions, and any portions
   14  * thereof, and that both notices appear in supporting documentation.
   15  * 
   16  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 
   17  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 
   18  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   19  * 
   20  * Carnegie Mellon requests users of this software to return to
   21  *
   22  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   23  *  School of Computer Science
   24  *  Carnegie Mellon University
   25  *  Pittsburgh PA 15213-3890
   26  *
   27  * any improvements or extensions that they make and grant Carnegie the
   28  * rights to redistribute these changes.
   29  */
   31 #include <sys/param.h>
   32 #include <sys/systm.h>
   33 #include <sys/kernel.h>
   34 #include <sys/device.h>
   35 #include <machine/bus.h>
   37 #include <dev/ic/mc6845reg.h>
   38 #include <dev/ic/pcdisplayvar.h>
   40 #include <dev/wscons/wsconsio.h>
   41 #include <dev/wscons/wsdisplayvar.h>
   43 void
pcdisplay_cursor_reset(scr)
   45         struct pcdisplayscreen *scr;
   46 {
   47 #ifdef PCDISPLAY_SOFTCURSOR
pcdisplay_6845_write(scr->hdl, curstart, 0x10);
pcdisplay_6845_write(scr->hdl, curend, 0x10);
   50 #endif
   51 }
   53 void
pcdisplay_cursor_init(scr, existing)
   55         struct pcdisplayscreen *scr;
   56         int existing;
   57 {
   58 #ifdef PCDISPLAY_SOFTCURSOR
bus_space_tag_t memt;
bus_space_handle_t memh;
   61         int off;
   62 #endif
pcdisplay_cursor_reset(scr);
   66 #ifdef PCDISPLAY_SOFTCURSOR
   67         if (existing) {
   68                 /*
   69                  * This is the first screen. At this point, scr->active is
   70                  * false and scr->mem is NULL (no backing store), so we
   71                  * can't use pcdisplay_cursor() to do this.
   72                  */
memt = scr->hdl->ph_memt;
memh = scr->hdl->ph_memh;
off = (scr->vc_crow * scr->type->ncols + scr->vc_ccol) * 2 +
scr->dispoffset;
scr->cursortmp = bus_space_read_2(memt, memh, off);
bus_space_write_2(memt, memh, off, scr->cursortmp ^ 0x7700);
   80         } else
scr->cursortmp = 0;
   82 #endif
scr->cursoron = 1;
   84 }
   86 void
pcdisplay_cursor(id, on, row, col)
   88         void *id;
   89         int on, row, col;
   90 {
   91 #ifdef PCDISPLAY_SOFTCURSOR
   92         struct pcdisplayscreen *scr = id;
bus_space_tag_t memt = scr->hdl->ph_memt;
bus_space_handle_t memh = scr->hdl->ph_memh;
   95         int off;
   97         /* Remove old cursor image */
   98         if (scr->cursoron) {
off = scr->vc_crow * scr->type->ncols + scr->vc_ccol;
  100                 if (scr->active)
bus_space_write_2(memt, memh, scr->dispoffset + off * 2,
scr->cursortmp);
  103                 else
scr->mem[off] = scr->cursortmp;
  105         }
scr->vc_crow = row;
scr->vc_ccol = col;
  110         if ((scr->cursoron = on) == 0)
  111                 return;
off = (scr->vc_crow * scr->type->ncols + scr->vc_ccol);
  114         if (scr->active) {
off = off * 2 + scr->dispoffset;
scr->cursortmp = bus_space_read_2(memt, memh, off);
bus_space_write_2(memt, memh, off, scr->cursortmp ^ 0x7700);
  118         } else {
scr->cursortmp = scr->mem[off];
scr->mem[off] = scr->cursortmp ^ 0x7700;
  121         }
  122 #else   /* PCDISPLAY_SOFTCURSOR */
  123         struct pcdisplayscreen *scr = id;
  124         int pos;
scr->vc_crow = row;
scr->vc_ccol = col;
scr->cursoron = on;
  130         if (scr->active) {
  131                 if (!on)
pos = 0x1010;
  133                 else
pos = scr->dispoffset / 2
  135                                 + row * scr->type->ncols + col;
pcdisplay_6845_write(scr->hdl, cursorh, pos >> 8);
pcdisplay_6845_write(scr->hdl, cursorl, pos);
  139         }
  140 #endif  /* PCDISPLAY_SOFTCURSOR */
  141 }
  143 #if 0
  144 unsigned int
pcdisplay_mapchar_simple(id, uni)
  146         void *id;
  147         int uni;
  148 {
  149         if (uni < 128)
  150                 return (uni);
  152         return (1); /* XXX ??? smiley */
  153 }
  154 #endif
  156 void
pcdisplay_putchar(id, row, col, c, attr)
  158         void *id;
  159         int row, col;
u_int c;
  161         long attr;
  162 {
  163         struct pcdisplayscreen *scr = id;
bus_space_tag_t memt = scr->hdl->ph_memt;
bus_space_handle_t memh = scr->hdl->ph_memh;
  166         int off;
off = row * scr->type->ncols + col;
  170         if (scr->active)
bus_space_write_2(memt, memh, scr->dispoffset + off * 2,
c | (attr << 8));
  173         else
scr->mem[off] = c | (attr << 8);
  175 }
  177 int
pcdisplay_getchar(id, row, col, cell)
  179         void *id;
  180         int row, col;
  181         struct wsdisplay_charcell *cell;
  182 {
  183         struct pcdisplayscreen *scr = id;
bus_space_tag_t memt = scr->hdl->ph_memt;
bus_space_handle_t memh = scr->hdl->ph_memh;
  186         int off;
u_int16_t data;
off = row * scr->type->ncols + col;
  190         /* XXX bounds check? */
  192         if (scr->active)
data = (bus_space_read_2(memt, memh, 
scr->dispoffset + off * 2));
  195         else
data = (scr->mem[off]);
cell->uc = data & 0xff;
cell->attr = data >> 8;
  201         return (0);
  202 }
  204 void
pcdisplay_copycols(id, row, srccol, dstcol, ncols)
  206         void *id;
  207         int row, srccol, dstcol, ncols;
  208 {
  209         struct pcdisplayscreen *scr = id;
bus_space_tag_t memt = scr->hdl->ph_memt;
bus_space_handle_t memh = scr->hdl->ph_memh;
bus_size_t srcoff, dstoff;
srcoff = dstoff = row * scr->type->ncols;
srcoff += srccol;
dstoff += dstcol;
  218         if (scr->active)
bus_space_copy_2(memt, memh,
scr->dispoffset + srcoff * 2,
memh, scr->dispoffset + dstoff * 2,
ncols);
  223         else
bcopy(&scr->mem[srcoff], &scr->mem[dstoff], ncols * 2);
  225 }
  227 void
pcdisplay_erasecols(id, row, startcol, ncols, fillattr)
  229         void *id;
  230         int row, startcol, ncols;
  231         long fillattr;
  232 {
  233         struct pcdisplayscreen *scr = id;
bus_space_tag_t memt = scr->hdl->ph_memt;
bus_space_handle_t memh = scr->hdl->ph_memh;
bus_size_t off;
u_int16_t val;
  238         int i;
off = row * scr->type->ncols + startcol;
val = (fillattr << 8) | ' ';
  244         if (scr->active)
bus_space_set_region_2(memt, memh, scr->dispoffset + off * 2,
val, ncols);
  247         else
  248                 for (i = 0; i < ncols; i++)
scr->mem[off + i] = val;
  250 }
  252 void
pcdisplay_copyrows(id, srcrow, dstrow, nrows)
  254         void *id;
  255         int srcrow, dstrow, nrows;
  256 {
  257         struct pcdisplayscreen *scr = id;
bus_space_tag_t memt = scr->hdl->ph_memt;
bus_space_handle_t memh = scr->hdl->ph_memh;
  260         int ncols = scr->type->ncols;
bus_size_t srcoff, dstoff;
srcoff = srcrow * ncols + 0;
dstoff = dstrow * ncols + 0;
  266         if (scr->active)
bus_space_copy_2(memt, memh,
scr->dispoffset + srcoff * 2,
memh, scr->dispoffset + dstoff * 2,
nrows * ncols);
  271         else
bcopy(&scr->mem[srcoff], &scr->mem[dstoff],
nrows * ncols * 2);
  274 }
  276 void
pcdisplay_eraserows(id, startrow, nrows, fillattr)
  278         void *id;
  279         int startrow, nrows;
  280         long fillattr;
  281 {
  282         struct pcdisplayscreen *scr = id;
bus_space_tag_t memt = scr->hdl->ph_memt;
bus_space_handle_t memh = scr->hdl->ph_memh;
bus_size_t off, count, n;
u_int16_t val;
off = startrow * scr->type->ncols;
count = nrows * scr->type->ncols;
val = (fillattr << 8) | ' ';
  293         if (scr->active)
bus_space_set_region_2(memt, memh, scr->dispoffset + off * 2,
val, count);
  296         else
  297                 for (n = 0; n < count; n++)
scr->mem[off + n] = val;
  299 }