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