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