![[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 / hpstand|
Return to ite.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hpstand |
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.19 89/08/22$
26: *
27: * @(#)ite.c 7.1 (Berkeley) 5/8/90
28: */
29:
30: /*
31: * Standalone Internal Terminal Emulator (CRT and keyboard)
32: */
33: #include "samachdep.h"
34:
35: #ifdef ITECONSOLE
36:
37: #include "param.h"
38: #include "machine/cons.h"
39: #include "../hpdev/device.h"
40: #include "../hpdev/itevar.h"
41: #include "../hpdev/grfvar.h"
42:
43: int nodev();
44:
45: int topcat_init(), topcat_putc();
46: int topcat_clear(), topcat_cursor(), topcat_scroll();
47: int gatorbox_init(), gatorbox_clear();
48: int gatorbox_putc(), gatorbox_cursor(), gatorbox_scroll();
49: int rbox_init(), rbox_clear();
50: int rbox_putc(), rbox_cursor(), rbox_scroll();
51: int dvbox_init(), dvbox_clear();
52: int dvbox_putc(), dvbox_cursor(), dvbox_scroll();
53:
54: struct itesw itesw[] = {
55: topcat_init, nodev, topcat_clear,
56: topcat_putc, topcat_cursor, topcat_scroll,
57:
58: gatorbox_init, nodev, gatorbox_clear,
59: gatorbox_putc, gatorbox_cursor, gatorbox_scroll,
60:
61: rbox_init, nodev, rbox_clear,
62: rbox_putc, rbox_cursor, rbox_scroll,
63:
64: dvbox_init, nodev, dvbox_clear,
65: dvbox_putc, dvbox_cursor, dvbox_scroll,
66: };
67:
68: /* these guys need to be in initialized data */
69: int itecons = -1;
70: struct ite_softc ite_softc[NITE] = { 0 };
71:
72: /*
73: * Locate all bitmapped displays
74: */
75: iteconfig()
76: {
77: extern struct hp_hw sc_table[];
78: int dtype, fboff, i;
79: struct hp_hw *hw;
80: struct grfreg *gr;
81: struct ite_softc *ip;
82:
83: i = 0;
84: for (hw = sc_table; hw < &sc_table[MAX_CTLR]; hw++) {
85: if (hw->hw_type != BITMAP)
86: continue;
87: gr = (struct grfreg *) hw->hw_addr;
88: /* XXX: redundent but safe */
89: if (badaddr((caddr_t)gr) || gr->gr_id != GRFHWID)
90: continue;
91: switch (gr->gr_id2) {
92: case GID_GATORBOX:
93: dtype = ITE_GATORBOX;
94: break;
95: case GID_TOPCAT:
96: case GID_LRCATSEYE:
97: case GID_HRCCATSEYE:
98: case GID_HRMCATSEYE:
99: dtype = ITE_TOPCAT;
100: break;
101: case GID_RENAISSANCE:
102: dtype = ITE_RENAISSANCE;
103: break;
104: case GID_DAVINCI:
105: dtype = ITE_DAVINCI;
106: break;
107: default:
108: continue;
109: }
110: if (i >= NITE)
111: break;
112: ip = &ite_softc[i];
113: ip->regbase = (caddr_t) gr;
114: fboff = (gr->gr_fbomsb << 8) | gr->gr_fbolsb;
115: ip->fbbase = (caddr_t) (*((u_char *)ip->regbase+fboff) << 16);
116: /* DIO II: FB offset is relative to select code space */
117: if (ip->regbase >= (caddr_t)0x1000000)
118: ip->fbbase += (int)ip->regbase;
119: ip->flags = ITE_ALIVE|ITE_CONSOLE;
120: ip->type = dtype;
121: i++;
122: }
123: }
124:
125: #ifdef CONSDEBUG
126: /*
127: * Allows us to cycle through all possible consoles (NITE ites and serial port)
128: * by using SHIFT-RESET on the keyboard.
129: */
130: int whichconsole = -1;
131: #endif
132:
133: iteprobe(cp)
134: struct consdev *cp;
135: {
136: register int ite;
137: register struct ite_softc *ip;
138: int unit, pri;
139:
140: #ifdef CONSDEBUG
141: whichconsole = ++whichconsole % (NITE+1);
142: #endif
143:
144: if (itecons != -1)
145: return(1);
146:
147: iteconfig();
148: unit = -1;
149: pri = CN_DEAD;
150: for (ite = 0; ite < NITE; ite++) {
151: #ifdef CONSDEBUG
152: if (ite < whichconsole)
153: continue;
154: #endif
155: ip = &ite_softc[ite];
156: if ((ip->flags & (ITE_ALIVE|ITE_CONSOLE))
157: != (ITE_ALIVE|ITE_CONSOLE))
158: continue;
159: if ((int)ip->regbase == GRFIADDR) {
160: pri = CN_INTERNAL;
161: unit = ite;
162: } else if (unit < 0) {
163: pri = CN_NORMAL;
164: unit = ite;
165: }
166: }
167: cp->cn_dev = unit;
168: cp->cn_pri = pri;
169: }
170:
171: iteinit(cp)
172: struct consdev *cp;
173: {
174: int ite = cp->cn_dev;
175: struct ite_softc *ip;
176:
177: if (itecons != -1)
178: return(1);
179:
180: ip = &ite_softc[ite];
181:
182: ip->curx = 0;
183: ip->cury = 0;
184: ip->cursorx = 0;
185: ip->cursory = 0;
186:
187: (*itesw[ip->type].ite_init)(ip);
188: (*itesw[ip->type].ite_cursor)(ip, DRAW_CURSOR);
189:
190: itecons = ite;
191: kbdinit();
192: }
193:
194: iteputchar(c)
195: register int c;
196: {
197: register struct ite_softc *ip = &ite_softc[itecons];
198: register struct itesw *sp = &itesw[ip->type];
199:
200: c &= 0x7F;
201: switch (c) {
202:
203: case '\n':
204: if (++ip->cury == ip->rows) {
205: ip->cury--;
206: (*sp->ite_scroll)(ip, 1, 0, 1, SCROLL_UP);
207: ite_clrtoeol(ip, sp, ip->cury, 0);
208: }
209: else
210: (*sp->ite_cursor)(ip, MOVE_CURSOR);
211: break;
212:
213: case '\r':
214: ip->curx = 0;
215: (*sp->ite_cursor)(ip, MOVE_CURSOR);
216: break;
217:
218: case '\b':
219: if (--ip->curx < 0)
220: ip->curx = 0;
221: else
222: (*sp->ite_cursor)(ip, MOVE_CURSOR);
223: break;
224:
225: default:
226: if (c < ' ' || c == 0177)
227: break;
228: (*sp->ite_putc)(ip, c, ip->cury, ip->curx, ATTR_NOR);
229: (*sp->ite_cursor)(ip, DRAW_CURSOR);
230: itecheckwrap(ip, sp);
231: break;
232: }
233: }
234:
235: itecheckwrap(ip, sp)
236: register struct ite_softc *ip;
237: register struct itesw *sp;
238: {
239: if (++ip->curx == ip->cols) {
240: ip->curx = 0;
241: if (++ip->cury == ip->rows) {
242: --ip->cury;
243: (*sp->ite_scroll)(ip, 1, 0, 1, SCROLL_UP);
244: ite_clrtoeol(ip, sp, ip->cury, 0);
245: return;
246: }
247: }
248: (*sp->ite_cursor)(ip, MOVE_CURSOR);
249: }
250:
251: ite_clrtoeol(ip, sp, y, x)
252: register struct ite_softc *ip;
253: register struct itesw *sp;
254: register int y, x;
255: {
256: (*sp->ite_clear)(ip, y, x, 1, ip->cols - x);
257: (*sp->ite_cursor)(ip, DRAW_CURSOR);
258: }
259:
260: itegetchar()
261: {
262: #ifdef SMALL
263: return (0);
264: #else
265: return (kbdgetc());
266: #endif
267: }
268: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.