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