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