sys/arch/amiga/dev/ite_et.c

   1 /*      $NetBSD: ite_et.c,v 1.11 2006/06/07 10:07:03 he Exp $ */
   2
   3 /*
   4  * Copyright (c) 1995 Ezra Story
   5  * Copyright (c) 1995 Kari Mettinen
   6  * Copyright (c) 1994 Markus Wild
   7  * Copyright (c) 1994 Lutz Vieweg
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed by Lutz Vieweg.
  21  * 4. The name of the author may not be used to endorse or promote products
  22  *    derived from this software without specific prior written permission
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  25  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  26  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  27  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  28  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  29  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  30  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  32  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  33  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #include "opt_amigacons.h"
  37
  38 #include <sys/cdefs.h>
  39 __KERNEL_RCSID(0, "$NetBSD: ite_et.c,v 1.11 2006/06/07 10:07:03 he Exp $");
  40
  41 #include "grfet.h"
  42 #if NGRFET > 0
  43
  44 #include <sys/param.h>
  45 #include <sys/conf.h>
  46 #include <sys/proc.h>
  47 #include <sys/device.h>
  48 #include <sys/ioctl.h>
  49 #include <sys/tty.h>
  50 #include <sys/systm.h>
  51 #include <dev/cons.h>
  52 #include <machine/cpu.h>
  53 #include <amiga/amiga/device.h>
  54 #include <amiga/dev/grfioctl.h>
  55 #include <amiga/dev/grfvar.h>
  56 #include <amiga/dev/grf_etreg.h>
  57 #include <amiga/dev/itevar.h>
  58
  59 #ifdef TSENGCONSOLE
  60 int et_console = 1;
  61 #else
  62 int et_console = 0;
  63 #endif
  64
  65 void et_init(struct ite_softc *ip);
  66 void et_cursor(struct ite_softc *ip, int flag);
  67 void et_deinit(struct ite_softc *ip);
  68 void et_putc(struct ite_softc *ip, int c, int dy, int dx, int mode);
  69 void et_clear(struct ite_softc *ip, int sy, int sx, int h, int w);
  70 void et_scroll(struct ite_softc *ip, int sy, int sx, int count, int dir);
  71 static void etbcopy(const volatile void *src, volatile void *dst, size_t len);
  72
  73
  74 /*
  75  * Called to determine ite status.  Because the connection between the
  76  * console & ite in this driver is rather intimate, we return CN_DEAD
  77  * if the cl_console is not active.
  78  */
  79 int
  80 grfet_cnprobe(void)
  81 {
  82         static int done;
  83         int rv;
  84
  85         if (et_console && (done == 0))
  86                 rv = CN_INTERNAL;
  87         else
  88                 rv = CN_DEAD;
  89
  90         done = 1;
  91         return(rv);
  92 }
  93
  94
  95 void
  96 grfet_iteinit(struct grf_softc *gp)
  97 {
  98         gp->g_iteinit = et_init;
  99         gp->g_itedeinit = et_deinit;
 100         gp->g_iteclear = et_clear;
 101         gp->g_iteputc = et_putc;
 102         gp->g_itescroll = et_scroll;
 103         gp->g_itecursor = et_cursor;
 104 }
 105
 106
 107 void
 108 et_init(struct ite_softc *ip)
 109 {
 110         struct grfettext_mode *md;
 111
 112         ip->priv = ip->grf->g_data;
 113         md = (struct grfettext_mode *) ip->priv;
 114
 115         ip->cols = md->cols;
 116         ip->rows = md->rows;
 117 }
 118
 119
 120 void
 121 et_cursor(struct ite_softc *ip, int flag)
 122 {
 123         volatile u_char *ba = ip->grf->g_regkva;
 124
 125         switch (flag) {
 126             case DRAW_CURSOR:
 127                 /*WCrt(ba, CRT_ID_CURSOR_START, & ~0x20); */
 128             case MOVE_CURSOR:
 129                 flag = ip->curx + ip->cury * ip->cols;
 130                 WCrt(ba, CRT_ID_CURSOR_LOC_LOW, flag & 0xff);
 131                 WCrt(ba, CRT_ID_CURSOR_LOC_HIGH, (flag >> 8) & 0xff);
 132                 WCrt(ba, CRT_ID_EXT_START, (flag >> (16-2)) & 0x0c);
 133
 134                 ip->cursorx = ip->curx;
 135                 ip->cursory = ip->cury;
 136                 break;
 137             case ERASE_CURSOR:
 138                 /*WCrt(ba, CRT_ID_CURSOR_START, | 0x20); */
 139             case START_CURSOROPT:
 140             case END_CURSOROPT:
 141             default:
 142                 break;
 143         }
 144 }
 145
 146
 147 void
 148 et_deinit(struct ite_softc *ip)
 149 {
 150         ip->flags &= ~ITE_INITED;
 151 }
 152
 153
 154 void
 155 et_putc(struct ite_softc *ip, int c, int dy, int dx, int mode)
 156 {
 157         volatile unsigned char *ba = ip->grf->g_regkva;
 158         volatile unsigned char *fb = ip->grf->g_fbkva;
 159         unsigned char attr;
 160         volatile unsigned char *cp;
 161
 162         if (ip->flags & ITE_INGRF)
 163                 return;
 164
 165         attr =(unsigned char) ((mode & ATTR_INV) ? (0x70) : (0x07));
 166         if (mode & ATTR_UL)     attr  = 0x01;   /* ???????? */
 167         if (mode & ATTR_BOLD)   attr |= 0x08;
 168         if (mode & ATTR_BLINK)  attr |= 0x80;
 169
 170         cp = fb + ((dy * ip->cols) + dx);
 171         SetTextPlane(ba,0x00);
 172         *cp = (unsigned char) c;
 173         SetTextPlane(ba,0x01);
 174         *cp = (unsigned char) attr;
 175 }
 176
 177
 178 void
 179 et_clear(struct ite_softc *ip, int sy, int sx, int h, int w)
 180 {
 181         /* cl_clear and cl_scroll both rely on ite passing arguments
 182          * which describe continuous regions.  For a VT200 terminal,
 183          * this is safe behavior.
 184          */
 185         volatile unsigned char *src, *dst;
 186         volatile unsigned char *ba = ip->grf->g_regkva;
 187         int len;
 188
 189         if (ip->flags & ITE_INGRF)
 190                 return;
 191
 192         dst = (volatile unsigned char*)ip->grf->g_fbkva + (sy * ip->cols) + sx;
 193         src = dst + (ip->rows*ip->cols);
 194         len = w*h;
 195
 196         SetTextPlane(ba, 0x00);
 197         etbcopy(src, dst, len);
 198         SetTextPlane(ba, 0x01);
 199         etbcopy(src, dst, len);
 200 }
 201
 202
 203 void
 204 et_scroll(struct ite_softc *ip, int sy, int sx, int count, int dir)
 205 {
 206         volatile unsigned char *fb;
 207         volatile unsigned char *ba = ip->grf->g_regkva;
 208
 209         if (ip->flags & ITE_INGRF)
 210                 return;
 211
 212         fb = (volatile unsigned char*)ip->grf->g_fbkva + sy * ip->cols;
 213         SetTextPlane(ba, 0x00);
 214
 215         switch (dir) {
 216             case SCROLL_UP:
 217                 etbcopy(fb, fb - (count * ip->cols),
 218                     (ip->bottom_margin + 1 - sy) * ip->cols);
 219                 break;
 220             case SCROLL_DOWN:
 221                 etbcopy(fb, fb + (count * ip->cols),
 222                     (ip->bottom_margin + 1 - (sy + count)) * ip->cols);
 223                 break;
 224             case SCROLL_RIGHT:
 225                 etbcopy(fb+sx, fb+sx+count, ip->cols - (sx + count));
 226                 break;
 227             case SCROLL_LEFT:
 228                 etbcopy(fb+sx, fb+sx-count, ip->cols - sx);
 229                 break;
 230         }
 231
 232         SetTextPlane(ba, 0x01);
 233
 234         switch (dir) {
 235             case SCROLL_UP:
 236                 etbcopy(fb, fb - (count * ip->cols),
 237                     (ip->bottom_margin + 1 - sy) * ip->cols);
 238                 break;
 239             case SCROLL_DOWN:
 240                 etbcopy(fb, fb + (count * ip->cols),
 241                     (ip->bottom_margin + 1 - (sy + count)) * ip->cols);
 242                 break;
 243             case SCROLL_RIGHT:
 244                 etbcopy(fb+sx, fb+sx+count, ip->cols - (sx + count));
 245                 break;
 246             case SCROLL_LEFT:
 247                 etbcopy(fb+sx, fb+sx-count, ip->cols - sx);
 248                 break;
 249         }
 250 }
 251
 252
 253 static void etbcopy(const volatile void *src, volatile void *dst, size_t len)
 254 {
 255         int i;
 256         volatile char *cdst;
 257         volatile const char *csrc;
 258
 259         cdst = (volatile char*)dst;
 260         csrc = (volatile const char*)src;
 261
 262         if (csrc == cdst)
 263                 return;
 264
 265         if (csrc > cdst)
 266                 for (i=len; i>0; i--) {
 267                         *cdst++ = *csrc++;
 268                 }
 269         else {
 270                 csrc += len;
 271                 cdst += len;
 272
 273                 for (i=len; i>0; i--){
 274                         *--cdst = *--csrc;
 275                 }
 276         }
 277 }
 278
 279 #endif /* NGRFET */