![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to qv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxuba|
Return to qv.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxuba |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)qv.c 1.7 Berkeley 6/14/88
7: *
8: * derived from: @(#)qv.c 1.8 (ULTRIX) 8/21/85
9: */
10:
11: /************************************************************************
12: * *
13: * Copyright (c) 1985 by *
14: * Digital Equipment Corporation, Maynard, MA *
15: * All rights reserved. *
16: * *
17: * This software is furnished under a license and may be used and *
18: * copied only in accordance with the terms of such license and *
19: * with the inclusion of the above copyright notice. This *
20: * software or any other copies thereof may not be provided or *
21: * otherwise made available to any other person. No title to and *
22: * ownership of the software is hereby transferred. *
23: * *
24: * This software is derived from software received from the *
25: * University of California, Berkeley, and from Bell *
26: * Laboratories. Use, duplication, or disclosure is subject to *
27: * restrictions under license agreements with University of *
28: * California and with AT&T. *
29: * *
30: * The information in this software is subject to change without *
31: * notice and should not be construed as a commitment by Digital *
32: * Equipment Corporation. *
33: * *
34: * Digital assumes no responsibility for the use or reliability *
35: * of its software on equipment which is not supplied by Digital. *
36: * *
37: ************************************************************************
38: *
39: * This driver provides glass tty functionality to the qvss. It is a strange
40: * device in that it supports three subchannels. The first being the asr,
41: * the second being a channel that intercepts the chars headed for the screen
42: * ( like a pseudo tty ) and the third being a source of mouse state changes.
43: * NOTE: the second is conditional on #ifdef CONS_HACK in this version
44: * of the driver, as it's a total crock.
45: *
46: * There may be one and only one qvss in the system. This restriction is based
47: * on the inability to map more than one at a time. This restriction will
48: * exist until the kernel has shared memory services. This driver therefore
49: * support a single unit. No attempt was made to have it service more.
50: *
51: * (this belongs in sccs - not here)
52: *
53: * 02 Aug 85 -- rjl
54: * Changed the names of the special setup routines so that the system
55: * can have a qvss or a qdss system console.
56: *
57: * 03 Jul 85 -- rjl
58: * Added a check for virtual mode in qvputc so that the driver
59: * doesn't crash while in a dump which is done in physical mode.
60: *
61: * 10 Apr 85 -- jg
62: * Well, our theory about keyboard handling was wrong; most of the
63: * keyboard is in autorepeat, down mode. These changes are to make
64: * the qvss work the same as the Vs100, which is not necessarily
65: * completely correct, as some chord usage may fail. But since we
66: * can't easily change the Vs100, we might as well propagate the
67: * problem to another device. There are also changes for screen and
68: * mouse accellaration.
69: *
70: * 27 Mar 85 -- rjl
71: * MicroVAX-II systems have interval timers that interrupt at ipl4.
72: * Everything else is higher and thus causes us to miss clock ticks. The
73: * problem isn't severe except in the case of a device like this one that
74: * generates lots of interrupts. We aren't willing to make this change to
75: * all device drivers but it seems acceptable in this case.
76: *
77: * 3 Dec 84 -- jg
78: * To continue the tradition of building a better mouse trap, this
79: * driver has been extended to form Vs100 style event queues. If the
80: * mouse device is open, the keyboard events are intercepted and put
81: * into the shared memory queue. Unfortunately, we are ending up with
82: * one of the longest Unix device drivers. Sigh....
83: *
84: * 20 Nov 84 -- rjl
85: * As a further complication this driver is required to function as the
86: * virtual system console. This code runs before and during auto-
87: * configuration and therefore is require to have a second path for setup.
88: * It is futher constrained to have a character output routine that
89: * is not dependant on the interrupt system.
90: *
91: */
92:
93:
94: #include "qv.h"
95: #if NQV > 0
96:
97: #include "../machine/pte.h"
98:
99: #include "param.h"
100: #include "conf.h"
101: #include "dir.h"
102: #include "user.h"
103: #include "qvioctl.h"
104: #include "tty.h"
105: #include "map.h"
106: #include "buf.h"
107: #include "vm.h"
108: #include "bk.h"
109: #include "clist.h"
110: #include "file.h"
111: #include "uio.h"
112: #include "kernel.h"
113: #include "syslog.h"
114: #include "../machine/cpu.h"
115: #include "../machine/mtpr.h"
116: #include "ubareg.h"
117: #include "ubavar.h"
118:
119: #define CONS_HACK
120:
121: struct uba_device *qvinfo[NQV];
122:
123: struct tty qv_tty[NQV*4];
124:
125: #define nNQV NQV
126: int nqv = NQV*4;
127:
128: /*
129: * Definition of the driver for the auto-configuration program.
130: */
131: int qvprobe(), qvattach(), qvkint(), qvvint();
132: u_short qvstd[] = { 0 };
133: struct uba_driver qvdriver =
134: { qvprobe, 0, qvattach, 0, qvstd, "qv", qvinfo };
135:
136: extern char qvmem[][512*NBPG];
137: extern struct pte QVmap[][512];
138:
139: /*
140: * Local variables for the driver. Initialized for 15' screen
141: * so that it can be used during the boot process.
142: */
143:
144: #define QVWAITPRI (PZERO+1)
145: #define QVSSMAJOR 40
146:
147: #define QVKEYBOARD 0 /* minor 0, keyboard/glass tty */
148: #define QVPCONS 1 /* minor 1, console interceptor XXX */
149: #define QVMOUSECHAN 2 /* minor 2, mouse */
150: #define QVSPARE 3 /* unused */
151: #define QVCHAN(unit) ((unit) & 03)
152: /*
153: * v_putc is the switch that is used to redirect the console cnputc to the
154: * virtual console vputc. consops is used to redirect the console
155: * device to the qvss console.
156: */
157: extern (*v_putc)();
158: extern struct cdevsw *consops;
159: /*
160: * qv_def_scrn is used to select the appropriate tables. 0=15 inch 1=19 inch,
161: * 2 = uVAXII.
162: */
163: int qv_def_scrn = 2;
164:
165: #define QVMAXEVQ 64 /* must be power of 2 */
166: #define EVROUND(x) ((x) & (QVMAXEVQ - 1))
167:
168: /*
169: * Screen parameters 15 & 19 inch monitors. These determine the max size in
170: * pixel and character units for the display and cursor positions.
171: * Notice that the mouse defaults to original square algorithm, but X
172: * will change to its defaults once implemented.
173: */
174: struct qv_info *qv_scn;
175: struct qv_info qv_scn_defaults[] = {
176: {0, {0, 0}, 0, {0, 0}, 0, 0, 30, 80, 768, 480, 768-16, 480-16,
177: 0, 0, 0, 0, 0, QVMAXEVQ, 0, 0, {0, 0}, {0, 0, 0, 0}, 2, 4},
178: {0, {0, 0}, 0, {0, 0}, 0, 0, 55, 120, 960, 864, 960-16, 864-16,
179: 0, 0, 0, 0, 0, QVMAXEVQ, 0, 0, {0, 0}, {0, 0, 0, 0}, 2, 4},
180: {0, {0, 0}, 0, {0, 0}, 0, 0, 56, 120,1024, 864,1024-16, 864-16,
181: 0, 0, 0, 0, 0, QVMAXEVQ, 0, 0, {0, 0}, {0, 0, 0, 0}, 2, 4}
182: };
183:
184: /*
185: * Screen controller initialization parameters. The definations and use
186: * of these parameters can be found in the Motorola 68045 crtc specs. In
187: * essence they set the display parameters for the chip. The first set is
188: * for the 15" screen and the second is for the 19" seperate sync. There
189: * is also a third set for a 19" composite sync monitor which we have not
190: * tested and which is not supported.
191: */
192: static short qv_crt_parms[][16] = {
193: { 31, 25, 27, 0142, 31, 13, 30, 31, 4, 15, 040, 0, 0, 0, 0, 0 },
194: /* VR100*/ { 39, 30, 32, 0262, 55, 5, 54, 54, 4, 15, 040, 0, 0, 0, 0, 0 },
195: /* VR260*/ { 39, 32, 33, 0264, 56, 5, 54, 54, 4, 15, 040, 0, 0, 0, 0, 0},
196: };
197:
198: /*
199: * Screen parameters
200: */
201: struct qv_info *qv_scn;
202: int maxqvmem = 254*1024 - sizeof(struct qv_info) - QVMAXEVQ*sizeof(vsEvent);
203:
204: /*
205: * Keyboard state
206: */
207: struct qv_keyboard {
208: int shift; /* state variables */
209: int cntrl;
210: int lock;
211: char last; /* last character */
212: } qv_keyboard;
213:
214: short divdefaults[15] = { LK_DOWN, /* 0 doesn't exist */
215: LK_AUTODOWN, LK_AUTODOWN, LK_AUTODOWN, LK_DOWN,
216: LK_UPDOWN, LK_UPDOWN, LK_AUTODOWN, LK_AUTODOWN,
217: LK_AUTODOWN, LK_AUTODOWN, LK_AUTODOWN, LK_AUTODOWN,
218: LK_DOWN, LK_AUTODOWN };
219:
220: short kbdinitstring[] = { /* reset any random keyboard stuff */
221: LK_AR_ENABLE, /* we want autorepeat by default */
222: LK_CL_ENABLE, /* keyclick */
223: 0x84, /* keyclick volume */
224: LK_KBD_ENABLE, /* the keyboard itself */
225: LK_BELL_ENABLE, /* keyboard bell */
226: 0x84, /* bell volume */
227: LK_LED_DISABLE, /* keyboard leds */
228: LED_ALL };
229: #define KBD_INIT_LENGTH sizeof(kbdinitstring)/sizeof(short)
230:
231: #define TOY ((time.tv_sec * 100) + (time.tv_usec / 10000))
232:
233: int qv_ipl_lo = 1; /* IPL low flag */
234: int mouseon = 0; /* mouse channel is enabled when 1*/
235: struct proc *qvrsel; /* process waiting for select */
236:
237: int qvstart(), qvputc(), ttrstrt();
238:
239: /*
240: * Keyboard translation and font tables
241: */
242: extern u_short q_key[], q_shift_key[], q_cursor[];
243: extern char *q_special[], q_font[];
244:
245: /*
246: * See if the qvss will interrupt.
247: */
248:
249: /*ARGSUSED*/
250: qvprobe(reg, ctlr)
251: caddr_t reg;
252: int ctlr;
253: {
254: register int br, cvec; /* these are ``value-result'' */
255: register struct qvdevice *qvaddr = (struct qvdevice *)reg;
256: static int tvec, ovec;
257:
258: #ifdef lint
259: br = 0; cvec = br; br = cvec;
260: qvkint(0); qvvint(0);
261: #endif
262: /*
263: * Allocate the next two vectors
264: */
265: tvec = 0360;
266: ovec = cvec;
267: /*
268: * Turn on the keyboard and vertical interrupt vectors.
269: */
270: qvaddr->qv_intcsr = 0; /* init the interrupt controler */
271: qvaddr->qv_intcsr = 0x40; /* reset irr */
272: qvaddr->qv_intcsr = 0x80; /* specify individual vectors */
273: qvaddr->qv_intcsr = 0xc0; /* preset autoclear data */
274: qvaddr->qv_intdata = 0xff; /* all setup as autoclear */
275:
276: qvaddr->qv_intcsr = 0xe0; /* preset vector address 1 */
277: qvaddr->qv_intdata = tvec; /* give it the keyboard vector */
278: qvaddr->qv_intcsr = 0x28; /* enable tx/rx interrupt */
279:
280: qvaddr->qv_intcsr = 0xe1; /* preset vector address 2 */
281: qvaddr->qv_intdata = tvec+4; /* give it the vertical sysnc */
282: qvaddr->qv_intcsr = 0x29; /* enable */
283:
284: qvaddr->qv_intcsr = 0xa1; /* arm the interrupt ctrl */
285:
286: qvaddr->qv_uartcmd = 0x15; /* set mode pntr/enable rx/tx */
287: qvaddr->qv_uartmode = 0x17; /* noparity, 8-bit */
288: qvaddr->qv_uartmode = 0x07; /* 1 stop bit */
289: qvaddr->qv_uartstatus = 0x99; /* 4800 baud xmit/recv */
290: qvaddr->qv_uartintstatus = 2; /* enable recv interrupts */
291:
292: qvaddr->qv_csr |= QV_INT_ENABLE | QV_CUR_MODE;
293:
294: DELAY(10000);
295:
296: qvaddr->qv_csr &= ~QV_INT_ENABLE;
297:
298: /*
299: * If the qvss did interrupt it was the second vector not
300: * the first so we have to return the first so that they
301: * will be setup properly
302: */
303: if( ovec == cvec ) {
304: return 0;
305: } else
306: cvec -= 4;
307: return (sizeof (struct qvdevice));
308: }
309:
310: /*
311: * Routine called to attach a qv.
312: */
313: qvattach(ui)
314: struct uba_device *ui;
315: {
316:
317: /*
318: * If not the console then we have to setup the screen
319: */
320: if (v_putc != qvputc || ui->ui_unit != 0)
321: (void)qv_setup((struct qvdevice *)ui->ui_addr, ui->ui_unit, 1);
322: else
323: qv_scn->qvaddr = (struct qvdevice *)ui->ui_addr;
324: }
325:
326:
327: /*ARGSUSED*/
328: qvopen(dev, flag)
329: dev_t dev;
330: {
331: register struct tty *tp;
332: register int unit, qv;
333: register struct qvdevice *qvaddr;
334: register struct uba_device *ui;
335: register struct qv_info *qp = qv_scn;
336:
337: unit = minor(dev);
338: qv = unit >> 2;
339: if (unit >= nqv || (ui = qvinfo[qv])== 0 || ui->ui_alive == 0)
340: return (ENXIO);
341: if (QVCHAN(unit) == QVSPARE
342: #ifndef CONS_HACK
343: || QVCHAN(unit) == QVPCONS
344: #endif
345: )
346: return (ENODEV);
347: tp = &qv_tty[unit];
348: if (tp->t_state&TS_XCLUDE && u.u_uid!=0)
349: return (EBUSY);
350: qvaddr = (struct qvdevice *)ui->ui_addr;
351: qv_scn->qvaddr = qvaddr;
352: tp->t_addr = (caddr_t)qvaddr;
353: tp->t_oproc = qvstart;
354:
355: if ((tp->t_state&TS_ISOPEN) == 0) {
356: ttychars(tp);
357: tp->t_state = TS_ISOPEN|TS_CARR_ON;
358: tp->t_ispeed = B9600;
359: tp->t_ospeed = B9600;
360: if( QVCHAN(unit) == QVKEYBOARD ) {
361: /* make sure keyboard is always back to default */
362: qvkbdreset();
363: qvaddr->qv_csr |= QV_INT_ENABLE;
364: tp->t_flags = XTABS|EVENP|ECHO|CRMOD;
365: } else
366: tp->t_flags = RAW;
367: }
368: /*
369: * Process line discipline specific open if its not the
370: * mouse channel. For the mouse we init the ring ptr's.
371: */
372: if( QVCHAN(unit) != QVMOUSECHAN )
373: return ((*linesw[tp->t_line].l_open)(dev, tp));
374: else {
375: mouseon = 1;
376: /* set up event queue for later */
377: qp->ibuff = (vsEvent *)qp - QVMAXEVQ;
378: qp->iqsize = QVMAXEVQ;
379: qp->ihead = qp->itail = 0;
380: return 0;
381: }
382: }
383:
384: /*
385: * Close a QVSS line.
386: */
387: /*ARGSUSED*/
388: qvclose(dev, flag)
389: dev_t dev;
390: int flag;
391: {
392: register struct tty *tp;
393: register unit;
394: register struct qvdevice *qvaddr;
395:
396: unit = minor(dev);
397: tp = &qv_tty[unit];
398:
399: /*
400: * If this is the keyboard unit (0) shutdown the
401: * interface.
402: */
403: qvaddr = (struct qvdevice *)tp->t_addr;
404: if (QVCHAN(unit) == QVKEYBOARD )
405: qvaddr->qv_csr &= ~QV_INT_ENABLE;
406:
407: /*
408: * If unit is not the mouse channel call the line disc.
409: * otherwise clear the state flag, and put the keyboard into down/up.
410: */
411: if (QVCHAN(unit) != QVMOUSECHAN) {
412: (*linesw[tp->t_line].l_close)(tp);
413: ttyclose(tp);
414: } else {
415: mouseon = 0;
416: qv_init( qvaddr );
417: }
418: tp->t_state = 0;
419: }
420:
421: qvread(dev, uio)
422: dev_t dev;
423: struct uio *uio;
424: {
425: register struct tty *tp;
426: int unit = minor( dev );
427:
428: if (QVCHAN(unit) != QVMOUSECHAN) {
429: tp = &qv_tty[unit];
430: return ((*linesw[tp->t_line].l_read)(tp, uio));
431: }
432: return (ENXIO);
433: }
434:
435: qvwrite(dev, uio)
436: dev_t dev;
437: struct uio *uio;
438: {
439: register struct tty *tp;
440: int unit = minor( dev );
441:
442: /*
443: * If this is the mouse we simply fake the i/o, otherwise
444: * we let the line disp. handle it.
445: */
446: if (QVCHAN(unit) == QVMOUSECHAN) {
447: uio->uio_offset = uio->uio_resid;
448: uio->uio_resid = 0;
449: return 0;
450: }
451: tp = &qv_tty[unit];
452: return ((*linesw[tp->t_line].l_write)(tp, uio));
453: }
454:
455:
456: /*
457: * Mouse activity select routine
458: */
459: qvselect(dev, rw)
460: dev_t dev;
461: {
462: register int s = spl5();
463: register struct qv_info *qp = qv_scn;
464:
465: if( QVCHAN(minor(dev)) == QVMOUSECHAN )
466: switch(rw) {
467: case FREAD: /* if events okay */
468: if(qp->ihead != qp->itail) {
469: splx(s);
470: return(1);
471: }
472: qvrsel = u.u_procp;
473: splx(s);
474: return(0);
475: default: /* can never write */
476: splx(s);
477: return(0);
478: }
479: else {
480: splx(s);
481: return( ttselect(dev, rw) );
482: }
483: /*NOTREACHED*/
484: }
485:
486: /*
487: * QVSS keyboard interrupt.
488: */
489: qvkint(qv)
490: int qv;
491: {
492: struct tty *tp;
493: register c;
494: struct uba_device *ui;
495: register int key;
496: register int i;
497:
498: ui = qvinfo[qv];
499: if (ui == 0 || ui->ui_alive == 0)
500: return;
501: tp = &qv_tty[qv<<2];
502: /*
503: * Get a character from the keyboard.
504: */
505: key = ((struct qvdevice *)ui->ui_addr)->qv_uartdata & 0xff;
506: if( mouseon == 0) {
507: /*
508: * Check for various keyboard errors
509: */
510: if( key == LK_POWER_ERROR || key == LK_KDOWN_ERROR ||
511: key == LK_INPUT_ERROR || key == LK_OUTPUT_ERROR) {
512: log(LOG_ERR,
513: "qv%d: Keyboard error, code = %x\n",qv,key);
514: return;
515: }
516: if( key < LK_LOWEST ) return;
517: /*
518: * See if its a state change key
519: */
520: switch ( key ) {
521: case LOCK:
522: qv_keyboard.lock ^= 0xffff; /* toggle */
523: if( qv_keyboard.lock )
524: qv_key_out( LK_LED_ENABLE );
525: else
526: qv_key_out( LK_LED_DISABLE );
527: qv_key_out( LED_3 );
528: return;
529: case SHIFT:
530: qv_keyboard.shift ^= 0xffff;
531: return;
532: case CNTRL:
533: qv_keyboard.cntrl ^= 0xffff;
534: return;
535: case ALLUP:
536: qv_keyboard.cntrl = qv_keyboard.shift = 0;
537: return;
538: case REPEAT:
539: c = qv_keyboard.last;
540: break;
541: default:
542: /*
543: * Test for control characters. If set, see if the character
544: * is elligible to become a control character.
545: */
546: if( qv_keyboard.cntrl ) {
547: c = q_key[ key ];
548: if( c >= ' ' && c <= '~' )
549: c &= 0x1f;
550: } else if( qv_keyboard.lock || qv_keyboard.shift )
551: c = q_shift_key[ key ];
552: else
553: c = q_key[ key ];
554: break;
555: }
556:
557: qv_keyboard.last = c;
558:
559: /*
560: * Check for special function keys
561: */
562: if( c & 0x80 ) {
563: register char *string;
564: string = q_special[ c & 0x7f ];
565: while( *string )
566: (*linesw[tp->t_line].l_rint)(*string++, tp);
567: } else
568: (*linesw[tp->t_line].l_rint)(c, tp);
569: } else {
570: /*
571: * Mouse channel is open put it into the event queue
572: * instead.
573: */
574: register struct qv_info *qp = qv_scn;
575: register vsEvent *vep;
576:
577: if ((i = EVROUND(qp->itail+1)) == qp->ihead)
578: return;
579: vep = &qp->ibuff[qp->itail];
580: vep->vse_direction = VSE_KBTRAW;
581: vep->vse_type = VSE_BUTTON;
582: vep->vse_device = VSE_DKB;
583: vep->vse_x = qp->mouse.x;
584: vep->vse_y = qp->mouse.y;
585: vep->vse_time = TOY;
586: vep->vse_key = key;
587: qp->itail = i;
588: if(qvrsel) {
589: selwakeup(qvrsel,0);
590: qvrsel = 0;
591: }
592: }
593: }
594:
595: /*
596: * Ioctl for QVSS.
597: */
598: /*ARGSUSED*/
599: qvioctl(dev, cmd, data, flag)
600: dev_t dev;
601: register caddr_t data;
602: {
603: register struct tty *tp;
604: register int unit = minor(dev);
605: register struct qv_info *qp = qv_scn;
606: register struct qv_kpcmd *qk;
607: register unsigned char *cp;
608: int error;
609:
610: /*
611: * Check for and process qvss specific ioctl's
612: */
613: switch( cmd ) {
614: case QIOCGINFO: /* return screen info */
615: bcopy((caddr_t)qp, data, sizeof (struct qv_info));
616: break;
617:
618: case QIOCSMSTATE: /* set mouse state */
619: qp->mouse = *((vsCursor *)data);
620: qv_pos_cur( qp->mouse.x, qp->mouse.y );
621: break;
622:
623: case QIOCINIT: /* init screen */
624: qv_init( qp->qvaddr );
625: break;
626:
627: case QIOCKPCMD:
628: qk = (struct qv_kpcmd *)data;
629: if(qk->nbytes == 0) qk->cmd |= 0200;
630: if(mouseon == 0) qk->cmd |= 1; /* no mode changes */
631: qv_key_out(qk->cmd);
632: cp = &qk->par[0];
633: while(qk->nbytes-- > 0) { /* terminate parameters */
634: if(qk->nbytes <= 0) *cp |= 0200;
635: qv_key_out(*cp++);
636: }
637: break;
638: case QIOCADDR: /* get struct addr */
639: *(struct qv_info **) data = qp;
640: break;
641: default: /* not ours ?? */
642: tp = &qv_tty[unit];
643: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag);
644: if (error >= 0)
645: return (error);
646: error = ttioctl(tp, cmd, data, flag);
647: if (error >= 0) {
648: return (error);
649: }
650: break;
651: }
652: return (0);
653: }
654: /*
655: * Initialize the screen and the scanmap
656: */
657: qv_init(qvaddr)
658: struct qvdevice *qvaddr;
659: {
660: register short *scanline;
661: register int i;
662: register short scan;
663: register char *ptr;
664: register struct qv_info *qp = qv_scn;
665:
666: /*
667: * Clear the bit map
668: */
669: for( i=0 , ptr = qp->bitmap ; i<240 ; i += 2 , ptr += 2048)
670: bzero( ptr, 2048 );
671: /*
672: * Reinitialize the scanmap
673: */
674: scan = qvaddr->qv_csr & QV_MEM_BANK;
675: scanline = qp->scanmap;
676: for(i = 0 ; i < qp->max_y ; i++ )
677: *scanline++ = scan++;
678:
679: /*
680: * Home the cursor
681: */
682: qp->row = qp->col = 0;
683:
684: /*
685: * Reset the cursor to the default type.
686: */
687: for( i=0 ; i<16 ; i++ )
688: qp->cursorbits[i] = q_cursor[i];
689: qvaddr->qv_csr |= QV_CUR_MODE;
690: /*
691: * Reset keyboard to default state.
692: */
693: qvkbdreset();
694: }
695:
696: qvreset()
697: {
698: }
699: qvkbdreset()
700: {
701: register int i;
702: qv_key_out(LK_DEFAULTS);
703: for( i=1 ; i < 15 ; i++ )
704: qv_key_out( divdefaults[i] | (i<<3));
705: for (i = 0; i < KBD_INIT_LENGTH; i++)
706: qv_key_out(kbdinitstring[i]);
707: }
708:
709: #define abs(x) (((x) > 0) ? (x) : (-(x)))
710: /*
711: * QVSS vertical sync interrupt
712: */
713: qvvint(qv)
714: int qv;
715: {
716: extern int selwait;
717: register struct qvdevice *qvaddr;
718: struct uba_device *ui;
719: register struct qv_info *qp = qv_scn;
720: int unit;
721: struct tty *tp0;
722: int i;
723: register int j;
724: /*
725: * Mouse state info
726: */
727: static ushort omouse = 0, nmouse = 0;
728: static char omx=0, omy=0, mx=0, my=0, om_switch=0, m_switch=0;
729: register int dx, dy;
730:
731: /*
732: * Test and set the qv_ipl_lo flag. If the result is not zero then
733: * someone else must have already gotten here.
734: */
735: if( --qv_ipl_lo )
736: return;
737: (void)spl4();
738: ui = qvinfo[qv];
739: unit = qv<<2;
740: qvaddr = (struct qvdevice *)ui->ui_addr;
741: tp0 = &qv_tty[QVCHAN(unit) + QVMOUSECHAN];
742: /*
743: * See if the mouse has moved.
744: */
745: if( omouse != (nmouse = qvaddr->qv_mouse) ) {
746: omouse = nmouse;
747: mx = nmouse & 0xff;
748: my = nmouse >> 8;
749: dy = my - omy; omy = my;
750: dx = mx - omx; omx = mx;
751: if( dy < 50 && dy > -50 && dx < 50 && dx > -50 ) {
752: register vsEvent *vep;
753: if( qp->mscale < 0 ) { /* Ray Lanza's original */
754: if( dy < 0 )
755: dy = -( dy * dy );
756: else
757: dy *= dy;
758: if( dx < 0 )
759: dx = -( dx * dx );
760: else
761: dx *= dx;
762: }
763: else { /* Vs100 style, see WGA spec */
764: int thresh = qp->mthreshold;
765: int scale = qp->mscale;
766: if( abs(dx) > thresh ) {
767: if ( dx < 0 )
768: dx = (dx + thresh)*scale - thresh;
769: else
770: dx = (dx - thresh)*scale + thresh;
771: }
772: if( abs(dy) > thresh ) {
773: if ( dy < 0 )
774: dy = (dy + thresh)*scale - thresh;
775: else
776: dy = (dy - thresh)*scale + thresh;
777: }
778: }
779: qp->mouse.x += dx;
780: qp->mouse.y -= dy;
781: if( qp->mouse.x < 0 )
782: qp->mouse.x = 0;
783: if( qp->mouse.y < 0 )
784: qp->mouse.y = 0;
785: if( qp->mouse.x > qp->max_cur_x )
786: qp->mouse.x = qp->max_cur_x;
787: if( qp->mouse.y > qp->max_cur_y )
788: qp->mouse.y = qp->max_cur_y;
789: if( tp0->t_state & TS_ISOPEN )
790: qv_pos_cur( qp->mouse.x, qp->mouse.y );
791: if (qp->mouse.y < qp->mbox.bottom &&
792: qp->mouse.y >= qp->mbox.top &&
793: qp->mouse.x < qp->mbox.right &&
794: qp->mouse.x >= qp->mbox.left) goto switches;
795: qp->mbox.bottom = 0; /* trash box */
796: if (EVROUND(qp->itail+1) == qp->ihead)
797: goto switches;
798: i = EVROUND(qp->itail - 1);
799: if ((qp->itail != qp->ihead) && (i != qp->ihead)) {
800: vep = & qp->ibuff[i];
801: if(vep->vse_type == VSE_MMOTION) {
802: vep->vse_x = qp->mouse.x;
803: vep->vse_y = qp->mouse.y;
804: goto switches;
805: }
806: }
807: /* put event into queue and do select */
808: vep = & qp->ibuff[qp->itail];
809: vep->vse_type = VSE_MMOTION;
810: vep->vse_time = TOY;
811: vep->vse_x = qp->mouse.x;
812: vep->vse_y = qp->mouse.y;
813: qp->itail = EVROUND(qp->itail+1);
814: }
815: }
816: /*
817: * See if mouse switches have changed.
818: */
819: switches:if( om_switch != ( m_switch = (qvaddr->qv_csr & QV_MOUSE_ANY) >> 8 ) ) {
820: qp->mswitches = ~m_switch & 0x7;
821: for (j = 0; j < 3; j++) { /* check each switch */
822: register vsEvent *vep;
823: if ( ((om_switch>>j) & 1) == ((m_switch>>j) & 1) )
824: continue;
825: /* check for room in the queue */
826: if ((i = EVROUND(qp->itail+1)) == qp->ihead) return;
827: /* put event into queue and do select */
828: vep = &qp->ibuff[qp->itail];
829: vep->vse_type = VSE_BUTTON;
830: vep->vse_key = 2 - j;
831: vep->vse_direction = VSE_KBTDOWN;
832: if ( (m_switch >> j) & 1)
833: vep->vse_direction = VSE_KBTUP;
834: vep->vse_device = VSE_MOUSE;
835: vep->vse_time = TOY;
836: vep->vse_x = qp->mouse.x;
837: vep->vse_y = qp->mouse.y;
838: }
839: qp->itail = i;
840: om_switch = m_switch;
841: qp->mswitches = m_switch;
842: }
843: /* if we have proc waiting, and event has happened, wake him up */
844: if(qvrsel && (qp->ihead != qp->itail)) {
845: selwakeup(qvrsel,0);
846: qvrsel = 0;
847: }
848: /*
849: * Okay we can take another hit now
850: */
851: qv_ipl_lo = 1;
852: }
853:
854: /*
855: * Start transmission
856: */
857: qvstart(tp)
858: register struct tty *tp;
859: {
860: register int unit, c;
861: register struct tty *tp0;
862: int s;
863:
864: unit = minor(tp->t_dev);
865: #ifdef CONS_HACK
866: tp0 = &qv_tty[(unit&0xfc)+QVPCONS];
867: #endif
868: unit = QVCHAN(unit);
869:
870: s = spl5();
871: /*
872: * If it's currently active, or delaying, no need to do anything.
873: */
874: if (tp->t_state&(TS_TIMEOUT|TS_BUSY|TS_TTSTOP))
875: goto out;
876: /*
877: * Display chars until the queue is empty, if the second subchannel
878: * is open direct them there. Drop characters from subchannels other
879: * than 0 on the floor.
880: */
881:
882: while( tp->t_outq.c_cc ) {
883: c = getc(&tp->t_outq);
884: if (unit == QVKEYBOARD)
885: #ifdef CONS_HACK
886: if( tp0->t_state & TS_ISOPEN ){
887: (*linesw[tp0->t_line].l_rint)(c, tp0);
888: } else
889: #endif
890: qvputchar( c & 0xff );
891: }
892: /*
893: * Position the cursor to the next character location.
894: */
895: qv_pos_cur( qv_scn->col*8, qv_scn->row*15 );
896:
897: /*
898: * If there are sleepers, and output has drained below low
899: * water mark, wake up the sleepers.
900: */
901: if ( tp->t_outq.c_cc<=TTLOWAT(tp) ) {
902: if (tp->t_state&TS_ASLEEP){
903: tp->t_state &= ~TS_ASLEEP;
904: wakeup((caddr_t)&tp->t_outq);
905: }
906: }
907: tp->t_state &= ~TS_BUSY;
908: out:
909: splx(s);
910: }
911:
912: /*
913: * Stop output on a line, e.g. for ^S/^Q or output flush.
914: */
915: /*ARGSUSED*/
916: qvstop(tp, flag)
917: register struct tty *tp;
918: {
919: register int s;
920:
921: /*
922: * Block input/output interrupts while messing with state.
923: */
924: s = spl5();
925: if (tp->t_state & TS_BUSY) {
926: if ((tp->t_state&TS_TTSTOP)==0) {
927: tp->t_state |= TS_FLUSH;
928: } else
929: tp->t_state &= ~TS_BUSY;
930: }
931: splx(s);
932: }
933:
934: qvputc(c)
935: char c;
936: {
937: qvputchar(c);
938: if (c == '\n')
939: qvputchar('\r');
940: }
941:
942: /*
943: * Routine to display a character on the screen. The model used is a
944: * glass tty. It is assummed that the user will only use this emulation
945: * during system boot and that the screen will be eventually controlled
946: * by a window manager.
947: *
948: */
949: qvputchar( c )
950: register char c;
951: {
952:
953: register char *b_row, *f_row;
954: register int i;
955: register short *scanline;
956: register int ote = 128;
957: register struct qv_info *qp = qv_scn;
958:
959: /*
960: * This routine may be called in physical mode by the dump code
961: * so we check and punt if that's the case.
962: */
963: if( (mfpr(MAPEN) & 1) == 0 )
964: return;
965:
966: c &= 0x7f;
967:
968: switch ( c ) {
969: case '\t': /* tab */
970: for( i = 8 - (qp->col & 0x7) ; i > 0 ; i-- )
971: qvputchar( ' ' );
972: break;
973:
974: case '\r': /* return */
975: qp->col = 0;
976: break;
977:
978: case '\010': /* backspace */
979: if( --qp->col < 0 )
980: qp->col = 0;
981: break;
982:
983: case '\n': /* linefeed */
984: if( qp->row+1 >= qp->max_row )
985: qvscroll();
986: else
987: qp->row++;
988: /*
989: * Position the cursor to the next character location.
990: */
991: qv_pos_cur( qp->col*8, qp->row*15 );
992: break;
993:
994: case '\007': /* bell */
995: /*
996: * We don't do anything to the keyboard until after
997: * autoconfigure.
998: */
999: if( qp->qvaddr )
1000: qv_key_out( LK_RING_BELL );
1001: return;
1002:
1003: default:
1004: if( c >= ' ' && c <= '~' ) {
1005: scanline = qp->scanmap;
1006: b_row = qp->bitmap+(scanline[qp->row*15]&0x3ff)*128+qp->col;
1007: i = c - ' ';
1008: if( i < 0 || i > 95 )
1009: i = 0;
1010: else
1011: i *= 15;
1012: f_row = (char *)((int)q_font + i);
1013:
1014: /* for( i=0 ; i<15 ; i++ , b_row += 128, f_row++ )
1015: *b_row = *f_row;*/
1016: /* inline expansion for speed */
1017: *b_row = *f_row++; b_row += ote;
1018: *b_row = *f_row++; b_row += ote;
1019: *b_row = *f_row++; b_row += ote;
1020: *b_row = *f_row++; b_row += ote;
1021: *b_row = *f_row++; b_row += ote;
1022: *b_row = *f_row++; b_row += ote;
1023: *b_row = *f_row++; b_row += ote;
1024: *b_row = *f_row++; b_row += ote;
1025: *b_row = *f_row++; b_row += ote;
1026: *b_row = *f_row++; b_row += ote;
1027: *b_row = *f_row++; b_row += ote;
1028: *b_row = *f_row++; b_row += ote;
1029: *b_row = *f_row++; b_row += ote;
1030: *b_row = *f_row++; b_row += ote;
1031: *b_row = *f_row++; b_row += ote;
1032:
1033: if( ++qp->col >= qp->max_col ) {
1034: qp->col = 0 ;
1035: if( qp->row+1 >= qp->max_row )
1036: qvscroll();
1037: else
1038: qp->row++;
1039: }
1040: }
1041: break;
1042: }
1043: }
1044:
1045: /*
1046: * Position the cursor to a particular spot.
1047: */
1048: qv_pos_cur( x, y)
1049: register int x,y;
1050: {
1051: register struct qvdevice *qvaddr;
1052: register struct qv_info *qp = qv_scn;
1053: register index;
1054:
1055: if( qvaddr = qp->qvaddr ) {
1056: if( y < 0 || y > qp->max_cur_y )
1057: y = qp->max_cur_y;
1058: if( x < 0 || x > qp->max_cur_x )
1059: x = qp->max_cur_x;
1060: qp->cursor.x = x; /* keep track of real cursor*/
1061: qp->cursor.y = y; /* position, indep. of mouse*/
1062:
1063: qvaddr->qv_crtaddr = 10; /* select cursor start reg */
1064: qvaddr->qv_crtdata = y & 0xf;
1065: qvaddr->qv_crtaddr = 11; /* select cursor end reg */
1066: qvaddr->qv_crtdata = y & 0xf;
1067: qvaddr->qv_crtaddr = 14; /* select cursor y pos. */
1068: qvaddr->qv_crtdata = y >> 4;
1069: qvaddr->qv_xcur = x; /* pos x axis */
1070: /*
1071: * If the mouse is being used then we change the mode of
1072: * cursor display based on the pixels under the cursor
1073: */
1074: if( mouseon ) {
1075: index = y*128 + x/8;
1076: if( qp->bitmap[ index ] && qp->bitmap[ index+128 ] )
1077: qvaddr->qv_csr &= ~QV_CUR_MODE;
1078: else
1079: qvaddr->qv_csr |= QV_CUR_MODE;
1080: }
1081: }
1082: }
1083: /*
1084: * Scroll the bitmap by moving the scanline map words. This could
1085: * be done by moving the bitmap but it's much too slow for a full screen.
1086: * The only drawback is that the scanline map must be reset when the user
1087: * wants to do graphics.
1088: */
1089: qvscroll()
1090: {
1091: short tmpscanlines[15];
1092: register char *b_row;
1093: register short *scanline;
1094: register struct qv_info *qp = qv_scn;
1095:
1096: /*
1097: * If the mouse is on we don't scroll so that the bit map
1098: * remains sane.
1099: */
1100: if( mouseon ) {
1101: qp->row = 0;
1102: return;
1103: }
1104: /*
1105: * Save the first 15 scanlines so that we can put them at
1106: * the bottom when done.
1107: */
1108: bcopy((caddr_t)qp->scanmap, (caddr_t)tmpscanlines, sizeof tmpscanlines);
1109:
1110: /*
1111: * Clear the wrapping line so that it won't flash on the bottom
1112: * of the screen.
1113: */
1114: scanline = qp->scanmap;
1115: b_row = qp->bitmap+(*scanline&0x3ff)*128;
1116: bzero( b_row, 1920 );
1117:
1118: /*
1119: * Now move the scanlines down
1120: */
1121: bcopy((caddr_t)(qp->scanmap+15), (caddr_t)qp->scanmap,
1122: (qp->row * 15) * sizeof (short) );
1123:
1124: /*
1125: * Now put the other lines back
1126: */
1127: bcopy((caddr_t)tmpscanlines, (caddr_t)(qp->scanmap+(qp->row * 15)),
1128: sizeof (tmpscanlines) );
1129:
1130: }
1131:
1132: /*
1133: * Output to the keyboard. This routine status polls the transmitter on the
1134: * keyboard to output a code. The timer is to avoid hanging on a bad device.
1135: */
1136: qv_key_out(c)
1137: u_short c;
1138: {
1139: int timer = 30000;
1140: register struct qv_info *qp = qv_scn;
1141:
1142: if (qp->qvaddr) {
1143: while ((qp->qvaddr->qv_uartstatus & 0x4) == 0 && timer--)
1144: ;
1145: qp->qvaddr->qv_uartdata = c;
1146: }
1147: }
1148: /*
1149: * Virtual console initialization. This routine sets up the qvss so that it can
1150: * be used as the system console. It is invoked before autoconfig and has to do
1151: * everything necessary to allow the device to serve as the system console.
1152: * In this case it must map the q-bus and device areas and initialize the qvss
1153: * screen.
1154: */
1155: qvcons_init()
1156: {
1157: struct percpu *pcpu; /* pointer to percpu structure */
1158: register struct qbus *qb;
1159: struct qvdevice *qvaddr; /* device pointer */
1160: short *devptr; /* virtual device space */
1161: extern cnputc(); /* standard serial console putc */
1162: #define QVSSCSR 017200
1163:
1164: /*
1165: * If secondary console already configured,
1166: * don't override the previous one.
1167: */
1168: if (v_putc != cnputc)
1169: return 0;
1170: /*
1171: * find the percpu entry that matches this machine.
1172: */
1173: for( pcpu = percpu ; pcpu && pcpu->pc_cputype != cpu ; pcpu++ )
1174: ;
1175: if( pcpu == NULL )
1176: return 0;
1177:
1178: /*
1179: * Found an entry for this cpu. Because this device is Microvax specific
1180: * we assume that there is a single q-bus and don't have to worry about
1181: * multiple adapters.
1182: *
1183: * Map the device registers.
1184: */
1185: qb = (struct qbus *)pcpu->pc_io->io_details;
1186: ioaccess(qb->qb_iopage, UMEMmap[0] + qb->qb_memsize, UBAIOPAGES * NBPG);
1187:
1188: /*
1189: * See if the qvss is there.
1190: */
1191: devptr = (short *)((char *)umem[0] + (qb->qb_memsize * NBPG));
1192: qvaddr = (struct qvdevice *)((u_int)devptr + ubdevreg(QVSSCSR));
1193: if (badaddr((caddr_t)qvaddr, sizeof(short)))
1194: return 0;
1195: /*
1196: * Okay the device is there lets set it up
1197: */
1198: if (!qv_setup(qvaddr, 0, 0))
1199: return 0;
1200: v_putc = qvputc;
1201: consops = &cdevsw[QVSSMAJOR];
1202: return 1;
1203: }
1204: /*
1205: * Do the board specific setup
1206: */
1207: qv_setup(qvaddr, unit, probed)
1208: struct qvdevice *qvaddr;
1209: int unit;
1210: int probed;
1211: {
1212: caddr_t qvssmem; /* pointer to the display mem */
1213: register i; /* simple index */
1214: register struct qv_info *qp;
1215: register int *pte;
1216: struct percpu *pcpu; /* pointer to percpu structure */
1217: register struct qbus *qb;
1218:
1219: /*
1220: * find the percpu entry that matches this machine.
1221: */
1222: for( pcpu = percpu ; pcpu && pcpu->pc_cputype != cpu ; pcpu++ )
1223: ;
1224: if( pcpu == NULL )
1225: return(0);
1226:
1227: /*
1228: * Found an entry for this cpu. Because this device is Microvax specific
1229: * we assume that there is a single q-bus and don't have to worry about
1230: * multiple adapters.
1231: *
1232: * Map the device memory.
1233: */
1234: qb = (struct qbus *)pcpu->pc_io->io_details;
1235:
1236: i = (u_int)(qvaddr->qv_csr & QV_MEM_BANK) << 7;
1237: ioaccess(qb->qb_maddr + i, QVmap[unit], 512 * NBPG);
1238: qvssmem = qvmem[unit];
1239: pte = (int *)(QVmap[unit]);
1240: for (i=0; i < 512; i++, pte++)
1241: *pte = (*pte & ~PG_PROT) | PG_UW | PG_V;
1242:
1243: qv_scn = (struct qv_info *)((u_int)qvssmem + 251*1024);
1244: qp = qv_scn;
1245: if( (qvaddr->qv_csr & QV_19INCH) && qv_def_scrn == 0)
1246: qv_def_scrn = 1;
1247: *qv_scn = qv_scn_defaults[ qv_def_scrn ];
1248: if (probed)
1249: qp->qvaddr = qvaddr;
1250: qp->bitmap = qvssmem;
1251: qp->scanmap = (short *)((u_int)qvssmem + 254*1024);
1252: qp->cursorbits = (short *)((u_int)qvssmem + 256*1024-32);
1253: /* set up event queue for later */
1254: qp->ibuff = (vsEvent *)qp - QVMAXEVQ;
1255: qp->iqsize = QVMAXEVQ;
1256: qp->ihead = qp->itail = 0;
1257:
1258: /*
1259: * Setup the crt controller chip.
1260: */
1261: for( i=0 ; i<16 ; i++ ) {
1262: qvaddr->qv_crtaddr = i;
1263: qvaddr->qv_crtdata = qv_crt_parms[ qv_def_scrn ][ i ];
1264: }
1265: /*
1266: * Setup the display.
1267: */
1268: qv_init( qvaddr );
1269:
1270: /*
1271: * Turn on the video
1272: */
1273: qvaddr->qv_csr |= QV_VIDEO_ENA ;
1274: return 1;
1275: }
1276: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.