![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ite.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / hp300 / dev|
Return to ite.c CVS log | Up to [Net/2] / Net2 / arch / hp300 / dev |
1.1 root 1: /*
2: * Copyright (c) 1988 University of Utah.
3: * Copyright (c) 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * the Systems Programming Group of the University of Utah Computer
8: * Science Department.
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 the University of
21: * California, Berkeley and its contributors.
22: * 4. Neither the name of the University nor the names of its contributors
23: * may be used to endorse or promote products derived from this software
24: * without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36: * SUCH DAMAGE.
37: *
38: * from: Utah $Hdr: ite.c 1.1 90/07/09$
39: *
40: * @(#)ite.c 7.6 (Berkeley) 5/16/91
41: */
42:
43: /*
44: * Bit-mapped display terminal emulator machine independent code.
45: * This is a very rudimentary. Much more can be abstracted out of
46: * the hardware dependent routines.
47: */
48: #include "ite.h"
49: #if NITE > 0
50:
51: #include "grf.h"
52:
53: #undef NITE
54: #define NITE NGRF
55:
56: #include "param.h"
57: #include "conf.h"
58: #include "proc.h"
59: #include "ioctl.h"
60: #include "tty.h"
61: #include "systm.h"
62: #include "malloc.h"
63:
64: #include "itevar.h"
65: #include "iteioctl.h"
66: #include "kbdmap.h"
67:
68: #include "machine/cpu.h"
69:
70: #define set_attr(ip, attr) ((ip)->attribute |= (attr))
71: #define clr_attr(ip, attr) ((ip)->attribute &= ~(attr))
72:
73: extern int nodev();
74:
75: int topcat_scroll(), topcat_init(), topcat_deinit();
76: int topcat_clear(), topcat_putc(), topcat_cursor();
77: int gatorbox_scroll(), gatorbox_init(), gatorbox_deinit();
78: int gatorbox_clear(), gatorbox_putc(), gatorbox_cursor();
79: int rbox_scroll(), rbox_init(), rbox_deinit();
80: int rbox_clear(), rbox_putc(), rbox_cursor();
81: int dvbox_scroll(), dvbox_init(), dvbox_deinit();
82: int dvbox_clear(), dvbox_putc(), dvbox_cursor();
83:
84: struct itesw itesw[] =
85: {
86: topcat_init, topcat_deinit, topcat_clear,
87: topcat_putc, topcat_cursor, topcat_scroll,
88:
89: gatorbox_init, gatorbox_deinit, gatorbox_clear,
90: gatorbox_putc, gatorbox_cursor, gatorbox_scroll,
91:
92: rbox_init, rbox_deinit, rbox_clear,
93: rbox_putc, rbox_cursor, rbox_scroll,
94:
95: dvbox_init, dvbox_deinit, dvbox_clear,
96: dvbox_putc, dvbox_cursor, dvbox_scroll,
97: };
98:
99: /*
100: * # of chars are output in a single itestart() call.
101: * If this is too big, user processes will be blocked out for
102: * long periods of time while we are emptying the queue in itestart().
103: * If it is too small, console output will be very ragged.
104: */
105: int iteburst = 64;
106:
107: int nite = NITE;
108: struct tty *kbd_tty = NULL;
109: struct tty ite_tty[NITE];
110: struct ite_softc ite_softc[NITE];
111:
112: int itestart();
113: extern int ttrstrt();
114: extern struct tty *constty;
115:
116: /*
117: * Primary attribute buffer to be used by the first bitmapped console
118: * found. Secondary displays alloc the attribute buffer as needed.
119: * Size is based on a 68x128 display, which is currently our largest.
120: */
121: u_char console_attributes[0x2200];
122:
123: /*
124: * Perform functions necessary to setup device as a terminal emulator.
125: */
126: iteon(dev, flag)
127: dev_t dev;
128: {
129: int unit = UNIT(dev);
130: struct tty *tp = &ite_tty[unit];
131: struct ite_softc *ip = &ite_softc[unit];
132:
133: if (unit < 0 || unit >= NITE || (ip->flags&ITE_ALIVE) == 0)
134: return(ENXIO);
135: /* force ite active, overriding graphics mode */
136: if (flag & 1) {
137: ip->flags |= ITE_ACTIVE;
138: ip->flags &= ~(ITE_INGRF|ITE_INITED);
139: }
140: /* leave graphics mode */
141: if (flag & 2) {
142: ip->flags &= ~ITE_INGRF;
143: if ((ip->flags & ITE_ACTIVE) == 0)
144: return(0);
145: }
146: ip->flags |= ITE_ACTIVE;
147: if (ip->flags & ITE_INGRF)
148: return(0);
149: if (kbd_tty == NULL || kbd_tty == tp) {
150: kbd_tty = tp;
151: kbdenable();
152: }
153: iteinit(dev);
154: return(0);
155: }
156:
157: iteinit(dev)
158: dev_t dev;
159: {
160: int unit = UNIT(dev);
161: struct ite_softc *ip = &ite_softc[unit];
162:
163: if (ip->flags & ITE_INITED)
164: return;
165:
166: ip->curx = 0;
167: ip->cury = 0;
168: ip->cursorx = 0;
169: ip->cursory = 0;
170:
171: (*itesw[ip->type].ite_init)(ip);
172: (*itesw[ip->type].ite_cursor)(ip, DRAW_CURSOR);
173:
174: ip->attribute = 0;
175: if (ip->attrbuf == NULL)
176: ip->attrbuf = (u_char *)
177: malloc(ip->rows * ip->cols, M_DEVBUF, M_WAITOK);
178: bzero(ip->attrbuf, (ip->rows * ip->cols));
179:
180: ip->imode = 0;
181: ip->flags |= ITE_INITED;
182: }
183:
184: /*
185: * "Shut down" device as terminal emulator.
186: * Note that we do not deinit the console device unless forced.
187: * Deinit'ing the console every time leads to a very active
188: * screen when processing /etc/rc.
189: */
190: iteoff(dev, flag)
191: dev_t dev;
192: {
193: register struct ite_softc *ip = &ite_softc[UNIT(dev)];
194:
195: if (flag & 2)
196: ip->flags |= ITE_INGRF;
197: if ((ip->flags & ITE_ACTIVE) == 0)
198: return;
199: if ((flag & 1) ||
200: (ip->flags & (ITE_INGRF|ITE_ISCONS|ITE_INITED)) == ITE_INITED)
201: (*itesw[ip->type].ite_deinit)(ip);
202: if ((flag & 2) == 0)
203: ip->flags &= ~ITE_ACTIVE;
204: }
205:
206: /* ARGSUSED */
207: #ifdef __STDC__
208: iteopen(dev_t dev, int mode, int devtype, struct proc *p)
209: #else
210: iteopen(dev, mode, devtype, p)
211: dev_t dev;
212: int mode, devtype;
213: struct proc *p;
214: #endif
215: {
216: int unit = UNIT(dev);
217: register struct tty *tp = &ite_tty[unit];
218: register struct ite_softc *ip = &ite_softc[unit];
219: register int error;
220: int first = 0;
221:
222: if ((tp->t_state&(TS_ISOPEN|TS_XCLUDE)) == (TS_ISOPEN|TS_XCLUDE)
223: && p->p_ucred->cr_uid != 0)
224: return (EBUSY);
225: if ((ip->flags & ITE_ACTIVE) == 0) {
226: error = iteon(dev, 0);
227: if (error)
228: return (error);
229: first = 1;
230: }
231: tp->t_oproc = itestart;
232: tp->t_param = NULL;
233: tp->t_dev = dev;
234: if ((tp->t_state&TS_ISOPEN) == 0) {
235: ttychars(tp);
236: tp->t_iflag = TTYDEF_IFLAG;
237: tp->t_oflag = TTYDEF_OFLAG;
238: tp->t_cflag = CS8|CREAD;
239: tp->t_lflag = TTYDEF_LFLAG;
240: tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
241: tp->t_state = TS_ISOPEN|TS_CARR_ON;
242: ttsetwater(tp);
243: }
244: error = (*linesw[tp->t_line].l_open)(dev, tp);
245: if (error == 0) {
246: tp->t_winsize.ws_row = ip->rows;
247: tp->t_winsize.ws_col = ip->cols;
248: } else if (first)
249: iteoff(dev, 0);
250: return (error);
251: }
252:
253: /*ARGSUSED*/
254: iteclose(dev, flag, mode, p)
255: dev_t dev;
256: int flag, mode;
257: struct proc *p;
258: {
259: register struct tty *tp = &ite_tty[UNIT(dev)];
260:
261: (*linesw[tp->t_line].l_close)(tp, flag);
262: ttyclose(tp);
263: iteoff(dev, 0);
264: return(0);
265: }
266:
267: iteread(dev, uio, flag)
268: dev_t dev;
269: struct uio *uio;
270: {
271: register struct tty *tp = &ite_tty[UNIT(dev)];
272:
273: return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
274: }
275:
276: itewrite(dev, uio, flag)
277: dev_t dev;
278: struct uio *uio;
279: {
280: int unit = UNIT(dev);
281: register struct tty *tp = &ite_tty[unit];
282:
283: if ((ite_softc[unit].flags & ITE_ISCONS) && constty &&
284: (constty->t_state&(TS_CARR_ON|TS_ISOPEN))==(TS_CARR_ON|TS_ISOPEN))
285: tp = constty;
286: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
287: }
288:
289: iteioctl(dev, cmd, addr, flag)
290: dev_t dev;
291: caddr_t addr;
292: {
293: register struct tty *tp = &ite_tty[UNIT(dev)];
294: int error;
295:
296: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, addr, flag);
297: if (error >= 0)
298: return (error);
299: error = ttioctl(tp, cmd, addr, flag);
300: if (error >= 0)
301: return (error);
302: return (ENOTTY);
303: }
304:
305: itestart(tp)
306: register struct tty *tp;
307: {
308: register int cc, s;
309: int hiwat = 0;
310:
311: s = spltty();
312: if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP)) {
313: splx(s);
314: return;
315: }
316: tp->t_state |= TS_BUSY;
317: cc = tp->t_outq.c_cc;
318: if (cc <= tp->t_lowat) {
319: if (tp->t_state & TS_ASLEEP) {
320: tp->t_state &= ~TS_ASLEEP;
321: wakeup(&tp->t_outq);
322: }
323: if (tp->t_wsel) {
324: selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL);
325: tp->t_wsel = 0;
326: tp->t_state &= ~TS_WCOLL;
327: }
328: }
329: /*
330: * Limit the amount of output we do in one burst
331: * to prevent hogging the CPU.
332: */
333: if (cc > iteburst) {
334: hiwat++;
335: cc = iteburst;
336: }
337: while (--cc >= 0) {
338: register int c;
339:
340: c = getc(&tp->t_outq);
341: /*
342: * iteputchar() may take a long time and we don't want to
343: * block all interrupts for long periods of time. Since
344: * there is no need to stay at high priority while outputing
345: * the character (since we don't have to worry about
346: * interrupts), we don't. We just need to make sure that
347: * we don't reenter iteputchar, which is guarenteed by the
348: * earlier setting of TS_BUSY.
349: */
350: splx(s);
351: iteputchar(c, tp->t_dev);
352: spltty();
353: }
354: if (hiwat) {
355: tp->t_state |= TS_TIMEOUT;
356: timeout(ttrstrt, tp, 1);
357: }
358: tp->t_state &= ~TS_BUSY;
359: splx(s);
360: }
361:
362: itefilter(stat, c)
363: register char stat, c;
364: {
365: static int capsmode = 0;
366: static int metamode = 0;
367: register char code, *str;
368:
369: if (kbd_tty == NULL)
370: return;
371:
372: switch (c & 0xFF) {
373: case KBD_CAPSLOCK:
374: capsmode = !capsmode;
375: return;
376:
377: case KBD_EXT_LEFT_DOWN:
378: case KBD_EXT_RIGHT_DOWN:
379: metamode = 1;
380: return;
381:
382: case KBD_EXT_LEFT_UP:
383: case KBD_EXT_RIGHT_UP:
384: metamode = 0;
385: return;
386: }
387:
388: c &= KBD_CHARMASK;
389: switch ((stat>>KBD_SSHIFT) & KBD_SMASK) {
390:
391: case KBD_KEY:
392: if (!capsmode) {
393: code = kbd_keymap[c];
394: break;
395: }
396: /* fall into... */
397:
398: case KBD_SHIFT:
399: code = kbd_shiftmap[c];
400: break;
401:
402: case KBD_CTRL:
403: code = kbd_ctrlmap[c];
404: break;
405:
406: case KBD_CTRLSHIFT:
407: code = kbd_ctrlshiftmap[c];
408: break;
409: }
410:
411: if (code == NULL && (str = kbd_stringmap[c]) != NULL) {
412: while (*str)
413: (*linesw[kbd_tty->t_line].l_rint)(*str++, kbd_tty);
414: } else {
415: if (metamode)
416: code |= 0x80;
417: (*linesw[kbd_tty->t_line].l_rint)(code, kbd_tty);
418: }
419: }
420:
421: iteputchar(c, dev)
422: register int c;
423: dev_t dev;
424: {
425: int unit = UNIT(dev);
426: register struct ite_softc *ip = &ite_softc[unit];
427: register struct itesw *sp = &itesw[ip->type];
428: register int n;
429:
430: if ((ip->flags & (ITE_ACTIVE|ITE_INGRF)) != ITE_ACTIVE)
431: return;
432:
433: if (ip->escape) {
434: doesc:
435: switch (ip->escape) {
436:
437: case '&': /* Next can be a,d, or s */
438: if (ip->fpd++) {
439: ip->escape = c;
440: ip->fpd = 0;
441: }
442: return;
443:
444: case 'a': /* cursor change */
445: switch (c) {
446:
447: case 'Y': /* Only y coord. */
448: ip->cury = MIN(ip->pos, ip->rows-1);
449: ip->pos = 0;
450: ip->escape = 0;
451: (*sp->ite_cursor)(ip, MOVE_CURSOR);
452: clr_attr(ip, ATTR_INV);
453: break;
454:
455: case 'y': /* y coord first */
456: ip->cury = MIN(ip->pos, ip->rows-1);
457: ip->pos = 0;
458: ip->fpd = 0;
459: break;
460:
461: case 'C': /* x coord */
462: ip->curx = MIN(ip->pos, ip->cols-1);
463: ip->pos = 0;
464: ip->escape = 0;
465: (*sp->ite_cursor)(ip, MOVE_CURSOR);
466: clr_attr(ip, ATTR_INV);
467: break;
468:
469: default: /* Possibly a 3 digit number. */
470: if (c >= '0' && c <= '9' && ip->fpd < 3) {
471: ip->pos = ip->pos * 10 + (c - '0');
472: ip->fpd++;
473: } else {
474: ip->pos = 0;
475: ip->escape = 0;
476: }
477: break;
478: }
479: return;
480:
481: case 'd': /* attribute change */
482: switch (c) {
483:
484: case 'B':
485: set_attr(ip, ATTR_INV);
486: break;
487: case 'D':
488: /* XXX: we don't do anything for underline */
489: set_attr(ip, ATTR_UL);
490: break;
491: case '@':
492: clr_attr(ip, ATTR_ALL);
493: break;
494: }
495: ip->escape = 0;
496: return;
497:
498: case 's': /* keypad control */
499: switch (ip->fpd) {
500:
501: case 0:
502: ip->hold = c;
503: ip->fpd++;
504: return;
505:
506: case 1:
507: if (c == 'A') {
508: switch (ip->hold) {
509:
510: case '0':
511: clr_attr(ip, ATTR_KPAD);
512: break;
513: case '1':
514: set_attr(ip, ATTR_KPAD);
515: break;
516: }
517: }
518: ip->hold = 0;
519: }
520: ip->escape = 0;
521: return;
522:
523: case 'i': /* back tab */
524: if (ip->curx > TABSIZE) {
525: n = ip->curx - (ip->curx & (TABSIZE - 1));
526: ip->curx -= n;
527: } else
528: ip->curx = 0;
529: (*sp->ite_cursor)(ip, MOVE_CURSOR);
530: ip->escape = 0;
531: return;
532:
533: case '3': /* clear all tabs */
534: goto ignore;
535:
536: case 'K': /* clear_eol */
537: ite_clrtoeol(ip, sp, ip->cury, ip->curx);
538: ip->escape = 0;
539: return;
540:
541: case 'J': /* clear_eos */
542: ite_clrtoeos(ip, sp);
543: ip->escape = 0;
544: return;
545:
546: case 'B': /* cursor down 1 line */
547: if (++ip->cury == ip->rows) {
548: --ip->cury;
549: (*sp->ite_scroll)(ip, 1, 0, 1, SCROLL_UP);
550: ite_clrtoeol(ip, sp, ip->cury, 0);
551: }
552: else
553: (*sp->ite_cursor)(ip, MOVE_CURSOR);
554: clr_attr(ip, ATTR_INV);
555: ip->escape = 0;
556: return;
557:
558: case 'C': /* cursor forward 1 char */
559: ip->escape = 0;
560: itecheckwrap(ip, sp);
561: return;
562:
563: case 'A': /* cursor up 1 line */
564: if (ip->cury > 0) {
565: ip->cury--;
566: (*sp->ite_cursor)(ip, MOVE_CURSOR);
567: }
568: ip->escape = 0;
569: clr_attr(ip, ATTR_INV);
570: return;
571:
572: case 'P': /* delete character */
573: ite_dchar(ip, sp);
574: ip->escape = 0;
575: return;
576:
577: case 'M': /* delete line */
578: ite_dline(ip, sp);
579: ip->escape = 0;
580: return;
581:
582: case 'Q': /* enter insert mode */
583: ip->imode = 1;
584: ip->escape = 0;
585: return;
586:
587: case 'R': /* exit insert mode */
588: ip->imode = 0;
589: ip->escape = 0;
590: return;
591:
592: case 'L': /* insert blank line */
593: ite_iline(ip, sp);
594: ip->escape = 0;
595: return;
596:
597: case 'h': /* home key */
598: ip->cury = ip->curx = 0;
599: (*sp->ite_cursor)(ip, MOVE_CURSOR);
600: ip->escape = 0;
601: return;
602:
603: case 'D': /* left arrow key */
604: if (ip->curx > 0) {
605: ip->curx--;
606: (*sp->ite_cursor)(ip, MOVE_CURSOR);
607: }
608: ip->escape = 0;
609: return;
610:
611: case '1': /* set tab in all rows */
612: goto ignore;
613:
614: case ESC:
615: if ((ip->escape = c) == ESC)
616: break;
617: ip->fpd = 0;
618: goto doesc;
619:
620: default:
621: ignore:
622: ip->escape = 0;
623: return;
624:
625: }
626: }
627:
628: switch (c &= 0x7F) {
629:
630: case '\n':
631:
632: if (++ip->cury == ip->rows) {
633: --ip->cury;
634: (*sp->ite_scroll)(ip, 1, 0, 1, SCROLL_UP);
635: ite_clrtoeol(ip, sp, ip->cury, 0);
636: }
637: else
638: (*sp->ite_cursor)(ip, MOVE_CURSOR);
639: clr_attr(ip, ATTR_INV);
640: break;
641:
642: case '\r':
643: if (ip->curx) {
644: ip->curx = 0;
645: (*sp->ite_cursor)(ip, MOVE_CURSOR);
646: }
647: break;
648:
649: case '\b':
650: if (--ip->curx < 0)
651: ip->curx = 0;
652: else
653: (*sp->ite_cursor)(ip, MOVE_CURSOR);
654: break;
655:
656: case '\t':
657: if (ip->curx < TABEND(unit)) {
658: n = TABSIZE - (ip->curx & (TABSIZE - 1));
659: ip->curx += n;
660: (*sp->ite_cursor)(ip, MOVE_CURSOR);
661: } else
662: itecheckwrap(ip, sp);
663: break;
664:
665: case CTRL('G'):
666: if (&ite_tty[unit] == kbd_tty)
667: kbdbell();
668: break;
669:
670: case ESC:
671: ip->escape = ESC;
672: break;
673:
674: default:
675: if (c < ' ' || c == DEL)
676: break;
677: if (ip->imode)
678: ite_ichar(ip, sp);
679: if ((ip->attribute & ATTR_INV) || attrtest(ip, ATTR_INV)) {
680: attrset(ip, ATTR_INV);
681: (*sp->ite_putc)(ip, c, ip->cury, ip->curx, ATTR_INV);
682: }
683: else
684: (*sp->ite_putc)(ip, c, ip->cury, ip->curx, ATTR_NOR);
685: (*sp->ite_cursor)(ip, DRAW_CURSOR);
686: itecheckwrap(ip, sp);
687: break;
688: }
689: }
690:
691: itecheckwrap(ip, sp)
692: register struct ite_softc *ip;
693: register struct itesw *sp;
694: {
695: if (++ip->curx == ip->cols) {
696: ip->curx = 0;
697: clr_attr(ip, ATTR_INV);
698: if (++ip->cury == ip->rows) {
699: --ip->cury;
700: (*sp->ite_scroll)(ip, 1, 0, 1, SCROLL_UP);
701: ite_clrtoeol(ip, sp, ip->cury, 0);
702: return;
703: }
704: }
705: (*sp->ite_cursor)(ip, MOVE_CURSOR);
706: }
707:
708: ite_dchar(ip, sp)
709: register struct ite_softc *ip;
710: register struct itesw *sp;
711: {
712: (*sp->ite_scroll)(ip, ip->cury, ip->curx + 1, 1, SCROLL_LEFT);
713: attrmov(ip, ip->cury, ip->curx + 1, ip->cury, ip->curx,
714: 1, ip->cols - ip->curx - 1);
715: attrclr(ip, ip->cury, ip->cols - 1, 1, 1);
716: (*sp->ite_putc)(ip, ' ', ip->cury, ip->cols - 1, ATTR_NOR);
717: (*sp->ite_cursor)(ip, DRAW_CURSOR);
718: }
719:
720: ite_ichar(ip, sp)
721: register struct ite_softc *ip;
722: register struct itesw *sp;
723: {
724: (*sp->ite_scroll)(ip, ip->cury, ip->curx, 1, SCROLL_RIGHT);
725: attrmov(ip, ip->cury, ip->curx, ip->cury, ip->curx + 1,
726: 1, ip->cols - ip->curx - 1);
727: attrclr(ip, ip->cury, ip->curx, 1, 1);
728: (*sp->ite_putc)(ip, ' ', ip->cury, ip->curx, ATTR_NOR);
729: (*sp->ite_cursor)(ip, DRAW_CURSOR);
730: }
731:
732: ite_dline(ip, sp)
733: register struct ite_softc *ip;
734: register struct itesw *sp;
735: {
736: (*sp->ite_scroll)(ip, ip->cury + 1, 0, 1, SCROLL_UP);
737: attrmov(ip, ip->cury + 1, 0, ip->cury, 0,
738: ip->rows - ip->cury - 1, ip->cols);
739: ite_clrtoeol(ip, sp, ip->rows - 1, 0);
740: }
741:
742: ite_iline(ip, sp)
743: register struct ite_softc *ip;
744: register struct itesw *sp;
745: {
746: (*sp->ite_scroll)(ip, ip->cury, 0, 1, SCROLL_DOWN);
747: attrmov(ip, ip->cury, 0, ip->cury + 1, 0,
748: ip->rows - ip->cury - 1, ip->cols);
749: ite_clrtoeol(ip, sp, ip->cury, 0);
750: }
751:
752: ite_clrtoeol(ip, sp, y, x)
753: register struct ite_softc *ip;
754: register struct itesw *sp;
755: register int y, x;
756: {
757: (*sp->ite_clear)(ip, y, x, 1, ip->cols - x);
758: attrclr(ip, y, x, 1, ip->cols - x);
759: (*sp->ite_cursor)(ip, DRAW_CURSOR);
760: }
761:
762: ite_clrtoeos(ip, sp)
763: register struct ite_softc *ip;
764: register struct itesw *sp;
765: {
766: (*sp->ite_clear)(ip, ip->cury, 0, ip->rows - ip->cury, ip->cols);
767: attrclr(ip, ip->cury, 0, ip->rows - ip->cury, ip->cols);
768: (*sp->ite_cursor)(ip, DRAW_CURSOR);
769: }
770:
771: /*
772: * Console functions
773: */
774: #include "../hp300/cons.h"
775: #include "grfioctl.h"
776: #include "grfvar.h"
777:
778: #ifdef DEBUG
779: /*
780: * Minimum ITE number at which to start looking for a console.
781: * Setting to 0 will do normal search, 1 will skip first ITE device,
782: * NITE will skip ITEs and use serial port.
783: */
784: int whichconsole = 0;
785: #endif
786:
787: itecnprobe(cp)
788: struct consdev *cp;
789: {
790: register struct ite_softc *ip;
791: int i, maj, unit, pri;
792:
793: /* locate the major number */
794: for (maj = 0; maj < nchrdev; maj++)
795: if (cdevsw[maj].d_open == iteopen)
796: break;
797:
798: /* urk! */
799: grfconfig();
800:
801: /* check all the individual displays and find the best */
802: unit = -1;
803: pri = CN_DEAD;
804: for (i = 0; i < NITE; i++) {
805: struct grf_softc *gp = &grf_softc[i];
806:
807: ip = &ite_softc[i];
808: if ((gp->g_flags & GF_ALIVE) == 0)
809: continue;
810: ip->flags = (ITE_ALIVE|ITE_CONSOLE);
811:
812: /* XXX - we need to do something about mapping these */
813: switch (gp->g_type) {
814:
815: case GT_TOPCAT:
816: case GT_LRCATSEYE:
817: case GT_HRCCATSEYE:
818: case GT_HRMCATSEYE:
819: ip->type = ITE_TOPCAT;
820: break;
821: case GT_GATORBOX:
822: ip->type = ITE_GATORBOX;
823: break;
824: case GT_RENAISSANCE:
825: ip->type = ITE_RENAISSANCE;
826: break;
827: case GT_DAVINCI:
828: ip->type = ITE_DAVINCI;
829: break;
830: }
831: #ifdef DEBUG
832: if (i < whichconsole)
833: continue;
834: #endif
835: if ((int)gp->g_display.gd_regaddr == GRFIADDR) {
836: pri = CN_INTERNAL;
837: unit = i;
838: } else if (unit < 0) {
839: pri = CN_NORMAL;
840: unit = i;
841: }
842: }
843:
844: /* initialize required fields */
845: cp->cn_dev = makedev(maj, unit);
846: cp->cn_tp = &ite_tty[unit];
847: cp->cn_pri = pri;
848: }
849:
850: itecninit(cp)
851: struct consdev *cp;
852: {
853: int unit = UNIT(cp->cn_dev);
854: struct ite_softc *ip = &ite_softc[unit];
855:
856: ip->attrbuf = console_attributes;
857: iteinit(cp->cn_dev);
858: ip->flags |= (ITE_ACTIVE|ITE_ISCONS);
859: kbd_tty = &ite_tty[unit];
860: }
861:
862: /*ARGSUSED*/
863: itecngetc(dev)
864: dev_t dev;
865: {
866: register int c;
867: int stat;
868:
869: c = kbdgetc(&stat);
870: switch ((stat >> KBD_SSHIFT) & KBD_SMASK) {
871: case KBD_SHIFT:
872: c = kbd_shiftmap[c & KBD_CHARMASK];
873: break;
874: case KBD_CTRL:
875: c = kbd_ctrlmap[c & KBD_CHARMASK];
876: break;
877: case KBD_KEY:
878: c = kbd_keymap[c & KBD_CHARMASK];
879: break;
880: default:
881: c = 0;
882: break;
883: }
884: return(c);
885: }
886:
887: itecnputc(dev, c)
888: dev_t dev;
889: int c;
890: {
891: static int paniced = 0;
892: struct ite_softc *ip = &ite_softc[UNIT(dev)];
893: extern char *panicstr;
894:
895: if (panicstr && !paniced &&
896: (ip->flags & (ITE_ACTIVE|ITE_INGRF)) != ITE_ACTIVE) {
897: (void) iteon(dev, 3);
898: paniced = 1;
899: }
900: iteputchar(c, dev);
901: }
902: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.