qd.c revision 1.50
1 /* $NetBSD: qd.c,v 1.50 2009/05/18 20:41:57 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 1988 Regents of the University of California. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * @(#)qd.c 7.1 (Berkeley) 6/28/91 32 */ 33 34 /************************************************************************ 35 * * 36 * Copyright (c) 1985-1988 by * 37 * Digital Equipment Corporation, Maynard, MA * 38 * All rights reserved. * 39 * * 40 * This software is furnished under a license and may be used and * 41 * copied only in accordance with the terms of such license and * 42 * with the inclusion of the above copyright notice. This * 43 * software or any other copies thereof may not be provided or * 44 * otherwise made available to any other person. No title to and * 45 * ownership of the software is hereby transferred. * 46 * * 47 * The information in this software is subject to change without * 48 * notice and should not be construed as a commitment by Digital * 49 * Equipment Corporation. * 50 * * 51 * Digital assumes no responsibility for the use or reliability * 52 * of its software on equipment which is not supplied by Digital. * 53 * * 54 *************************************************************************/ 55 56 /* 57 * qd.c - QDSS display driver for VAXSTATION-II GPX workstation 58 */ 59 60 #include <sys/cdefs.h> 61 __KERNEL_RCSID(0, "$NetBSD: qd.c,v 1.50 2009/05/18 20:41:57 ad Exp $"); 62 63 #include "opt_ddb.h" 64 65 #include "qd.h" 66 67 #include <sys/param.h> 68 #include <sys/systm.h> 69 #include <sys/conf.h> 70 #include <sys/tty.h> 71 #include <sys/kernel.h> 72 #include <sys/device.h> 73 #include <sys/poll.h> 74 #include <sys/buf.h> 75 76 #include <uvm/uvm_extern.h> 77 78 #include <dev/cons.h> 79 80 #include <sys/bus.h> 81 #include <machine/scb.h> 82 83 #ifdef __vax__ 84 #include <machine/sid.h> 85 #include <sys/cpu.h> 86 #include <machine/pte.h> 87 #endif 88 89 #include <dev/qbus/ubavar.h> 90 91 #include <dev/qbus/qduser.h> 92 #include <dev/qbus/qdreg.h> 93 #include <dev/qbus/qdioctl.h> 94 95 #include "ioconf.h" 96 97 /* 98 * QDSS driver status flags for tracking operational state 99 */ 100 struct qdflags { 101 u_int inuse; /* which minor dev's are in use now */ 102 u_int config; /* I/O page register content */ 103 u_int mapped; /* user mapping status word */ 104 u_int kernel_loop; /* if kernel console is redirected */ 105 u_int user_dma; /* DMA from user space in progress */ 106 u_short pntr_id; /* type code of pointing device */ 107 u_short duart_imask; /* shadowing for duart intrpt mask reg */ 108 u_short adder_ie; /* shadowing for adder intrpt enbl reg */ 109 u_short curs_acc; /* cursor acceleration factor */ 110 u_short curs_thr; /* cursor acceleration threshold level */ 111 u_short tab_res; /* tablet resolution factor */ 112 u_short selmask; /* mask for active qd select entries */ 113 }; 114 115 /* 116 * Softc struct to keep track of all states in this driver. 117 */ 118 struct qd_softc { 119 struct device sc_dev; 120 bus_space_tag_t sc_iot; 121 bus_space_handle_t sc_ioh; 122 bus_dma_tag_t sc_dmat; 123 }; 124 125 /* 126 * bit definitions for 'inuse' entry 127 */ 128 #define CONS_DEV 0x01 129 #define GRAPHIC_DEV 0x04 130 131 /* 132 * bit definitions for 'mapped' member of flag structure 133 */ 134 #define MAPDEV 0x01 /* hardware is mapped */ 135 #define MAPDMA 0x02 /* DMA buffer mapped */ 136 #define MAPEQ 0x04 /* event queue buffer mapped */ 137 #define MAPSCR 0x08 /* scroll param area mapped */ 138 #define MAPCOLOR 0x10 /* color map writing buffer mapped */ 139 140 /* 141 * constants used in shared memory operations 142 */ 143 #define EVENT_BUFSIZE 1024 /* # of bytes per device's event buffer */ 144 #define MAXEVENTS ( (EVENT_BUFSIZE - sizeof(struct qdinput)) \ 145 / sizeof(struct _vs_event) ) 146 #define DMA_BUFSIZ (1024 * 10) 147 #define COLOR_BUFSIZ ((sizeof(struct color_buf) + 512) & ~0x01FF) 148 149 /* 150 * reference to an array of "uba_device" structures built by the auto 151 * configuration program. The uba_device structure decribes the device 152 * sufficiently for the driver to talk to it. The auto configuration code 153 * fills in the uba_device structures (located in ioconf.c) from user 154 * maintained info. 155 */ 156 struct uba_device *qdinfo[NQD]; /* array of pntrs to each QDSS's */ 157 struct tty *qd_tty[NQD*4]; /* teletype structures for each.. */ 158 volatile char *qvmem[NQD]; 159 volatile struct pte *QVmap[NQD]; 160 #define CHUNK (64 * 1024) 161 #define QMEMSIZE (1024 * 1024 * 4) /* 4 meg */ 162 163 /* 164 * static storage used by multiple functions in this code 165 */ 166 int Qbus_unmap[NQD]; /* Qbus mapper release code */ 167 struct qdmap qdmap[NQD]; /* QDSS register map structure */ 168 struct qdflags qdflags[NQD]; /* QDSS register map structure */ 169 void *qdbase[NQD]; /* base address of each QDSS unit */ 170 short qdopened[NQD]; /* graphics device is open exclusive use */ 171 172 /* 173 * the array "event_shared[]" is made up of a number of event queue buffers 174 * equal to the number of QDSS's configured into the running kernel (NQD). 175 * Each event queue buffer begins with an event queue header (struct qdinput) 176 * followed by a group of event queue entries (struct _vs_event). The array 177 * "*eq_header[]" is an array of pointers to the start of each event queue 178 * buffer in "event_shared[]". 179 */ 180 #define EQSIZE ((EVENT_BUFSIZE * NQD) + 512) 181 182 char event_shared[EQSIZE]; /* reserve space for event bufs */ 183 struct qdinput *eq_header[NQD]; /* event queue header pntrs */ 184 185 /* 186 * This allocation method reserves enough memory pages for NQD shared DMA I/O 187 * buffers. Each buffer must consume an integral number of memory pages to 188 * guarantee that a following buffer will begin on a page boundary. Also, 189 * enough space is allocated so that the FIRST I/O buffer can start at the 190 * 1st page boundary after "&DMA_shared". Page boundaries are used so that 191 * memory protections can be turned on/off for individual buffers. 192 */ 193 #define IOBUFSIZE ((DMA_BUFSIZ * NQD) + 512) 194 195 char DMA_shared[IOBUFSIZE]; /* reserve I/O buffer space */ 196 struct DMAreq_header *DMAheader[NQD]; /* DMA buffer header pntrs */ 197 198 /* 199 * The driver assists a client in scroll operations by loading dragon 200 * registers from an interrupt service routine. The loading is done using 201 * parameters found in memory shrade between the driver and it's client. 202 * The scroll parameter structures are ALL loacted in the same memory page 203 * for reasons of memory economy. 204 */ 205 char scroll_shared[2 * 512]; /* reserve space for scroll structs */ 206 struct scroll *scroll[NQD]; /* pointers to scroll structures */ 207 208 /* 209 * the driver is programmable to provide the user with color map write 210 * services at VSYNC interrupt time. At interrupt time the driver loads 211 * the color map with any user-requested load data found in shared memory 212 */ 213 #define COLOR_SHARED ((COLOR_BUFSIZ * NQD) + 512) 214 215 char color_shared[COLOR_SHARED]; /* reserve space: color bufs */ 216 struct color_buf *color_buf[NQD]; /* pointers to color bufs */ 217 218 /* 219 * mouse input event structures 220 */ 221 struct mouse_report last_rep[NQD]; 222 struct mouse_report current_rep[NQD]; 223 224 struct selinfo qdrsel[NQD]; /* process waiting for select */ 225 struct _vs_cursor cursor[NQD]; /* console cursor */ 226 int qdcount = 0; /* count of successfully probed qd's */ 227 int nNQD = NQD; 228 int DMAbuf_size = DMA_BUFSIZ; 229 int QDlast_DMAtype; /* type of the last DMA operation */ 230 231 /* 232 * macro to get system time. Used to time stamp event queue entries 233 */ 234 #define TOY ((time.tv_sec * 100) + (time.tv_usec / 10000)) 235 236 void qd_attach(device_t, device_t, void *); 237 static int qd_match(device_t, cfdata_t, void *); 238 239 static void qddint(void *); /* DMA gate array intrpt service */ 240 static void qdaint(void *); /* Dragon ADDER intrpt service */ 241 static void qdiint(void *); 242 243 #define QDPRIOR (PZERO-1) /* must be negative */ 244 #define FALSE 0 245 #ifdef TRUE 246 #undef TRUE 247 #endif 248 #define TRUE ~FALSE 249 #define BAD -1 250 #define GOOD 0 251 252 /* 253 * macro to create a system virtual page number from system virtual adrs 254 */ 255 #define VTOP(x) (((int)x & ~0xC0000000) >> VAX_PGSHIFT) 256 257 /* 258 * QDSS register address offsets from start of QDSS address space 259 */ 260 #define QDSIZE (52 * 1024) /* size of entire QDSS foot print */ 261 #define TMPSIZE (16 * 1024) /* template RAM is 8k SHORT WORDS */ 262 #define TMPSTART 0x8000 /* offset of template RAM from base adrs */ 263 #define REGSIZE (5 * 512) /* regs touch 2.5k (5 pages) of addr space */ 264 #define REGSTART 0xC000 /* offset of reg pages from base adrs */ 265 #define ADDER (REGSTART+0x000) 266 #define DGA (REGSTART+0x200) 267 #define DUART (REGSTART+0x400) 268 #define MEMCSR (REGSTART+0x800) 269 #define CLRSIZE (3 * 512) /* color map size */ 270 #define CLRSTART (REGSTART+0xA00) /* color map start offset from base */ 271 /* 0x0C00 really */ 272 #define RED (CLRSTART+0x000) 273 #define BLUE (CLRSTART+0x200) 274 #define GREEN (CLRSTART+0x400) 275 276 277 /* 278 * QDSS minor device numbers. The *real* minor device numbers are in 279 * the bottom two bits of the major/minor device spec. Bits 2 and up are 280 * used to specify the QDSS device number (ie: which one?) 281 */ 282 283 #define CONS 0 284 #define GRAPHIC 2 285 286 /* 287 * console cursor bitmap (white block cursor) 288 */ 289 short cons_cursor[32] = { 290 /* A */ 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 291 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 292 /* B */ 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 293 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF 294 }; 295 296 /* 297 * constants used in font operations 298 */ 299 #define CHARS 190 /* # of chars in the font */ 300 #define CHAR_HEIGHT 15 /* char height in pixels */ 301 #define CHAR_WIDTH 8 /* char width in pixels*/ 302 #define FONT_WIDTH (CHAR_WIDTH * CHARS) /* font width in pixels */ 303 #define ROWS CHAR_HEIGHT 304 #define FONT_X 0 /* font's off screen adrs */ 305 #define FONT_Y (2048 - CHAR_HEIGHT) 306 307 /* Offset to second row characters (XXX - should remove) */ 308 #define FONT_OFFSET ((MAX_SCREEN_X/CHAR_WIDTH)*CHAR_HEIGHT) 309 310 extern char q_font[]; /* reference font object code */ 311 extern u_short q_key[]; /* reference key xlation tables */ 312 extern u_short q_shift_key[]; 313 extern char *q_special[]; 314 315 /* 316 * definitions for cursor acceleration reporting 317 */ 318 #define ACC_OFF 0x01 /* acceleration is inactive */ 319 320 /* 321 * virtual console support. 322 */ 323 extern struct cdevsw *consops; 324 cons_decl(qd); 325 void setup_dragon(int); 326 void init_shared(int); 327 void clear_qd_screen(int); 328 void ldfont(int); 329 void ldcursor(int, short *); 330 void setup_input(int); 331 void blitc(int, u_char); 332 void scroll_up(volatile struct adder *); 333 void write_ID(volatile struct adder *, short, short); 334 int wait_status(volatile struct adder *, int); 335 void led_control(int, int, int); 336 void qdstart(struct tty *); 337 void qdearly(void); 338 int qdpolling = 0; 339 340 dev_type_open(qdopen); 341 dev_type_close(qdclose); 342 dev_type_read(qdread); 343 dev_type_write(qdwrite); 344 dev_type_ioctl(qdioctl); 345 dev_type_stop(qdstop); 346 dev_type_poll(qdpoll); 347 dev_type_kqfilter(qdkqfilter); 348 349 const struct cdevsw qd_cdevsw = { 350 qdopen, qdclose, qdread, qdwrite, qdioctl, 351 qdstop, notty, qdpoll, nommap, qdkqfilter, 352 }; 353 354 /* 355 * LK-201 state storage for input console keyboard conversion to ASCII 356 */ 357 struct q_keyboard { 358 int shift; /* state variables */ 359 int cntrl; 360 int lock; 361 int lastcode; /* last keycode typed */ 362 unsigned kup[8]; /* bits for each keycode*/ 363 unsigned dkeys[8]; /* down/up mode keys */ 364 char last; /* last character */ 365 } q_keyboard; 366 367 /* 368 * tty settings on first open 369 */ 370 #define IFLAG (BRKINT|ISTRIP|IXON|IXANY|ICRNL|IMAXBEL) 371 #define OFLAG (OPOST|OXTABS|ONLCR) 372 #define LFLAG (ISIG|ICANON|ECHO|IEXTEN) 373 #define CFLAG (PARENB|CREAD|CS7|CLOCAL) 374 375 /* 376 * Kernel virtual addresses where we can map in the QBUS io page and the 377 * QDSS memory during qdcninit. pmap_bootstrap fills this in. 378 */ 379 void *qd_ubaio; 380 381 /* This is the QDSS unit 0 CSR. It is hard-coded in here so that the 382 * QDSS can be used as the console. The console routines don't get 383 * any config info. The ROM also autodetects at this address, so 384 * the console QDSS should be at this address. Furthermore, nothing 385 * else shuld be at this address instead because that would confuse the 386 * ROM and this driver. 387 */ 388 #define QDSSCSR 0x1F00 389 390 volatile u_short *qdaddr; /* Virtual address for QDSS CSR */ 391 392 /* 393 * This flag is set to 1 if the console initialization (qdcninit) 394 * has been performed on qd0. That initialization is required and must 395 * be done before the device probe routine. 396 */ 397 int qd0cninited = 0, qd0iscons = 0; 398 399 /* 400 * Do early check if the qdss is console. If not; don't allocate 401 * any memory for it in bootstrap. 402 */ 403 void 404 qdearly(void) 405 { 406 extern vaddr_t virtual_avail; 407 int tmp; 408 409 /* Make sure we're running on a system that can have a QDSS */ 410 if (vax_boardtype == VAX_BTYP_630) { 411 /* Now check some undocumented flag */ 412 if ((*(int *)(0x200B801E) & 0x60) == 0) 413 /* The KA630 isn't using a QDSS as the console, 414 * so we won't either */ 415 return; 416 } else if (vax_boardtype != VAX_BTYP_650) 417 return; 418 419 /* How to check for console on KA650? We assume that if there is a 420 * QDSS, it is console. 421 */ 422 #define QIOPAGE 0x20000000 /* XXX */ 423 #define UBAIOPAGES 16 424 tmp = QIOPAGE + ubdevreg(QDSSCSR); 425 if (badaddr((void *)tmp, sizeof(short))) 426 return; 427 428 MAPVIRT(qvmem[0], 64 * 1024 * NQD / VAX_NBPG); 429 MAPVIRT(qd_ubaio, 16); 430 pmap_map((int)qd_ubaio, QIOPAGE, QIOPAGE + UBAIOPAGES * VAX_NBPG, 431 VM_PROT_READ|VM_PROT_WRITE); 432 qdaddr = (u_short *)((u_int)qd_ubaio + ubdevreg(QDSSCSR)); 433 qd0iscons = 1; 434 } 435 436 void 437 qdcnprobe(struct consdev *cndev) 438 { 439 int i; 440 441 cndev->cn_pri = CN_DEAD; 442 443 if (mfpr(PR_MAPEN) == 0) 444 return; /* Cannot use qd if vm system is OFF */ 445 446 if (!qd0iscons) 447 return; 448 449 /* Find the console device corresponding to the console QDSS */ 450 cndev->cn_dev = makedev(cdevsw_lookup_major(&qd_cdevsw), 0); 451 cndev->cn_pri = CN_INTERNAL; 452 return; 453 } 454 455 456 /* 457 * Init QDSS as console (before probe routine) 458 */ 459 void 460 qdcninit(struct consdev *cndev) 461 { 462 void *phys_adr; /* physical QDSS base adrs */ 463 u_int mapix; /* index into QVmap[] array */ 464 int unit; 465 466 /* qdaddr must point to CSR for this unit! */ 467 468 /* The console QDSS is QDSS unit 0 */ 469 unit = 0; 470 471 /* 472 * Map q-bus memory used by qdss. (separate map) 473 */ 474 mapix = QMEMSIZE - (CHUNK * (unit + 1)); 475 #define QMEM 0x30000000 476 (int)phys_adr = QMEM + mapix; 477 pmap_map((int)(qvmem[0]), (int)phys_adr, (int)(phys_adr + (CHUNK*NQD)), 478 VM_PROT_READ|VM_PROT_WRITE); 479 480 /* 481 * Set QVmap to point to page table entries for what we just 482 * mapped. 483 */ 484 QVmap[0] = (struct pte *)kvtopte(qvmem[0]); 485 486 /* 487 * tell QDSS which Q memory address base to decode 488 * (shifted right 16 bits - its in 64K units) 489 */ 490 *qdaddr = (u_short)((int)mapix >> 16); 491 qdflags[unit].config = *(u_short *)qdaddr; 492 493 /* 494 * load qdmap struct with the virtual addresses of the QDSS elements 495 */ 496 qdbase[unit] = (void *) (qvmem[0]); 497 qdmap[unit].template = qdbase[unit] + TMPSTART; 498 qdmap[unit].adder = qdbase[unit] + ADDER; 499 qdmap[unit].dga = qdbase[unit] + DGA; 500 qdmap[unit].duart = qdbase[unit] + DUART; 501 qdmap[unit].memcsr = qdbase[unit] + MEMCSR; 502 qdmap[unit].red = qdbase[unit] + RED; 503 qdmap[unit].blue = qdbase[unit] + BLUE; 504 qdmap[unit].green = qdbase[unit] + GREEN; 505 506 qdflags[unit].duart_imask = 0; /* init shadow variables */ 507 508 /* 509 * init the QDSS 510 */ 511 512 *(short *)qdmap[unit].memcsr |= SYNC_ON; /* once only: turn on sync */ 513 514 cursor[unit].x = 0; 515 cursor[unit].y = 0; 516 init_shared(unit); /* init shared memory */ 517 setup_dragon(unit); /* init the ADDER/VIPER stuff */ 518 clear_qd_screen(unit); /* clear the screen */ 519 ldfont(unit); /* load the console font */ 520 ldcursor(unit, cons_cursor); /* load default cursor map */ 521 setup_input(unit); /* init the DUART */ 522 selinit(&qdrsel[unit]); 523 524 /* Set flag so probe knows */ 525 qd0cninited = 1; 526 } /* qdcninit */ 527 528 /* see <sys/device.h> */ 529 CFATTACH_DECL(qd, sizeof(struct qd_softc), 530 qd_match, qd_attach, NULL, NULL); 531 532 #define QD_RCSR(reg) \ 533 bus_space_read_2(sc->sc_iot, sc->sc_ioh, reg) 534 #define QD_WCSR(reg, val) \ 535 bus_space_write_2(sc->sc_iot, sc->sc_ioh, reg, val) 536 537 /* 538 * Configure QDSS into Q memory and make it intrpt. 539 * 540 * side effects: QDSS gets mapped into Qbus memory space at the first 541 * vacant 64kb boundary counting back from the top of 542 * Qbus memory space (qvmem+4mb) 543 * 544 * return: QDSS bus request level and vector address returned in 545 * registers by UNIX convention. 546 * 547 */ 548 static int 549 qd_match(device_t parent, cfdata_t match, void *aux) 550 { 551 struct qd_softc ssc; 552 struct qd_softc *sc = &ssc; 553 struct uba_attach_args *ua = aux; 554 struct uba_softc *uh = (void *)parent; 555 int unit; 556 volatile struct dga *dga; /* pointer to gate array structure */ 557 int vector; 558 #ifdef notdef 559 int *ptep; /* page table entry pointer */ 560 void *phys_adr; /* physical QDSS base adrs */ 561 u_int mapix; 562 #endif 563 564 /* Create a "fake" softc with only a few fields used. */ 565 sc->sc_iot = ua->ua_iot; 566 sc->sc_ioh = ua->ua_ioh; 567 sc->sc_dmat = ua->ua_dmat; 568 /* 569 * calculate board unit number from I/O page register address 570 */ 571 unit = (int) (((int)sc->sc_ioh >> 1) & 0x0007); 572 573 /* 574 * QDSS regs must be mapped to Qbus memory space at a 64kb 575 * physical boundary. The Qbus memory space is mapped into 576 * the system memory space at config time. After config 577 * runs, "qvmem[0]" (ubavar.h) holds the system virtual adrs 578 * of the start of Qbus memory. The Qbus memory page table 579 * is found via an array of pte ptrs called "QVmap[]" (ubavar.h) 580 * which is also loaded at config time. These are the 581 * variables used below to find a vacant 64kb boundary in 582 * Qbus memory, and load it's corresponding physical adrs 583 * into the QDSS's I/O page CSR. 584 */ 585 586 /* 587 * Only if QD is the graphics device. 588 */ 589 590 /* if this QDSS is NOT the console, then do init here.. */ 591 592 if (unit != 0) { 593 printf("qd: can't support two qdss's (yet)\n"); 594 #ifdef notdef /* can't test */ 595 if (v_consputc != qdputc || unit != 0) { 596 597 /* 598 * read QDSS config info 599 */ 600 qdflags[unit].config = *(u_short *)reg; 601 602 /* 603 * find an empty 64kb adrs boundary 604 */ 605 606 qdbase[unit] = (void *) (qvmem[0] + QMEMSIZE - CHUNK); 607 608 /* 609 * find the cpusw entry that matches this machine. 610 */ 611 cpup = &cpusw[cpu]; 612 while (!(BADADDR(qdbase[unit], sizeof(short)))) 613 qdbase[unit] -= CHUNK; 614 615 /* 616 * tell QDSS which Q memory address base to decode 617 */ 618 mapix = (int) (VTOP(qdbase[unit]) - VTOP(qvmem[0])); 619 ptep = (int *) QVmap[0] + mapix; 620 phys_adr = (void *)(((int)*ptep&0x001FFFFF)<<VAX_PGSHIFT); 621 *(u_short *)reg = (u_short) ((int)phys_adr >> 16); 622 623 /* 624 * load QDSS adrs map with system addresses 625 * of device regs 626 */ 627 qdmap[unit].template = qdbase[unit] + TMPSTART; 628 qdmap[unit].adder = qdbase[unit] + ADDER; 629 qdmap[unit].dga = qdbase[unit] + DGA; 630 qdmap[unit].duart = qdbase[unit] + DUART; 631 qdmap[unit].memcsr = qdbase[unit] + MEMCSR; 632 qdmap[unit].red = qdbase[unit] + RED; 633 qdmap[unit].blue = qdbase[unit] + BLUE; 634 qdmap[unit].green = qdbase[unit] + GREEN; 635 636 /* device init */ 637 638 cursor[unit].x = 0; 639 cursor[unit].y = 0; 640 init_shared(unit); /* init shared memory */ 641 setup_dragon(unit); /* init the ADDER/VIPER stuff */ 642 ldcursor(unit, cons_cursor); /* load default cursor map */ 643 setup_input(unit); /* init the DUART */ 644 clear_qd_screen(unit); 645 ldfont(unit); /* load the console font */ 646 647 /* once only: turn on sync */ 648 649 *(short *)qdmap[unit].memcsr |= SYNC_ON; 650 } 651 #endif /*notdef*/ 652 } else { 653 /* We are dealing with qd0 */ 654 655 if (!qd0cninited) { 656 /* 657 * qd0 has not been initiallized as the console. 658 * We need to do some initialization now 659 * 660 * XXX 661 * However, if the QDSS is not the console then 662 * that stupid undocumented bit (see qdcnprobe) 663 * is cleared. Then the QDSS refuses to work. 664 * (What did the ROM do to it!?) 665 * XXX 666 */ 667 return 0; 668 669 #if 0 670 qdaddr = (void *)reg; 671 672 /* Lame probe for QDSS. Should be ok for qd0 */ 673 if (badaddr((void *)qdaddr, sizeof(short))) 674 return 0; 675 676 qdcninit(NULL); 677 #endif 678 } 679 } 680 681 682 /* 683 * The QDSS interrupts at HEX vectors xx0 (DMA) xx4 684 * (ADDER) and xx8 (DUART). Therefore, we take three 685 * vectors from the vector pool, and then continue 686 * to take them until we get a xx0 HEX vector. The 687 * pool provides vectors in contiguous decending 688 * order. 689 */ 690 691 vector = (uh->uh_lastiv -= 4*3); /* take three vectors */ 692 693 while (vector & 0x0F) { /* if lo nibble != 0.. */ 694 /* ..take another vector */ 695 vector = (uh->uh_lastiv -= 4); 696 } 697 698 /* 699 * setup DGA to do a DMA interrupt (transfer count = 0) 700 */ 701 dga = (struct dga *) qdmap[unit].dga; 702 dga->csr = (short) HALT; /* disable everything */ 703 dga->ivr = (short) vector; /* load intrpt base vector */ 704 dga->bytcnt_lo = (short) 0; /* DMA xfer count = 0 */ 705 dga->bytcnt_hi = (short) 0; 706 707 /* 708 * turn on DMA interrupts 709 */ 710 dga->csr &= ~SET_DONE_FIFO; 711 dga->csr |= DMA_IE | DL_ENB; 712 713 DELAY(20000); /* wait for the intrpt */ 714 dga->csr = HALT; /* stop the wheels */ 715 716 /* 717 * score this as an existing qdss 718 */ 719 qdcount++; 720 721 return 1; 722 } /* qdprobe */ 723 724 725 void qd_attach(parent, self, aux) 726 device_t parent, *self; 727 void *aux; 728 { 729 struct uba_attach_args *ua = aux; 730 int unit; /* QDSS module # for this call */ 731 732 printf("\n"); 733 734 unit = device_unit(self); /* get QDSS number */ 735 736 /* Set interrupt vectors for interrupt handlers */ 737 738 uba_intr_establish(ua->ua_icookie, ua->ua_cvec , qddint, self); 739 uba_intr_establish(ua->ua_icookie, ua->ua_cvec + 4, qdaint, self); 740 uba_intr_establish(ua->ua_icookie, ua->ua_cvec + 8, qdiint, self); 741 742 /* 743 * init "qdflags[]" for this QDSS 744 */ 745 qdflags[unit].inuse = 0; /* init inuse variable EARLY! */ 746 qdflags[unit].mapped = 0; 747 qdflags[unit].kernel_loop = -1; 748 qdflags[unit].user_dma = 0; 749 qdflags[unit].curs_acc = ACC_OFF; 750 qdflags[unit].curs_thr = 128; 751 qdflags[unit].tab_res = 2; /* default tablet resolution factor */ 752 qdflags[unit].duart_imask = 0; /* init shadow variables */ 753 qdflags[unit].adder_ie = 0; 754 755 /* 756 * init structures used in kbd/mouse interrupt service. This code must 757 * come after the "init_shared()" routine has run since that routine 758 * inits the eq_header[unit] structure used here. 759 */ 760 761 /* 762 * init the "latest mouse report" structure 763 */ 764 last_rep[unit].state = 0; 765 last_rep[unit].dx = 0; 766 last_rep[unit].dy = 0; 767 last_rep[unit].bytcnt = 0; 768 769 /* 770 * init the event queue (except mouse position) 771 */ 772 eq_header[unit]->header.events = 773 (struct _vs_event *)((int)eq_header[unit] + sizeof(struct qdinput)); 774 775 eq_header[unit]->header.size = MAXEVENTS; 776 eq_header[unit]->header.head = 0; 777 eq_header[unit]->header.tail = 0; 778 779 /* 780 * open exclusive for graphics device. 781 */ 782 qdopened[unit] = 0; 783 784 } /* qdattach */ 785 786 787 /*ARGSUSED*/ 788 int 789 qdopen(dev_t dev, int flag, int mode, struct proc *p) 790 { 791 volatile struct dga *dga; /* ptr to gate array struct */ 792 struct tty *tp; 793 volatile struct duart *duart; 794 struct uba_softc *sc; 795 int unit; 796 int minor_dev; 797 798 minor_dev = minor(dev); /* get QDSS minor device number */ 799 unit = minor_dev >> 2; 800 801 /* 802 * check for illegal conditions 803 */ 804 sc = device_lookup_private(&qd_cd, unit); 805 if (sc == NULL) 806 return ENXIO; 807 808 duart = (struct duart *) qdmap[unit].duart; 809 dga = (struct dga *) qdmap[unit].dga; 810 811 if ((minor_dev & 0x03) == 2) { 812 /* 813 * this is the graphic device... 814 */ 815 if (qdopened[unit] != 0) 816 return(EBUSY); 817 else 818 qdopened[unit] = 1; 819 qdflags[unit].inuse |= GRAPHIC_DEV; /* graphics dev is open */ 820 /* 821 * enble kbd & mouse intrpts in DUART mask reg 822 */ 823 qdflags[unit].duart_imask |= 0x22; 824 duart->imask = qdflags[unit].duart_imask; 825 } else { 826 /* Only one console */ 827 if (minor_dev) return ENXIO; 828 829 /* If not done already, allocate tty structure */ 830 if (qd_tty[minor_dev] == NULL) 831 qd_tty[minor_dev] = ttymalloc(); 832 833 if (qd_tty[minor_dev] == NULL) 834 return ENXIO; 835 836 /* 837 * this is the console 838 */ 839 qdflags[unit].inuse |= CONS_DEV; /* mark console as open */ 840 dga->csr |= CURS_ENB; 841 qdflags[unit].duart_imask |= 0x02; 842 duart->imask = qdflags[unit].duart_imask; 843 /* 844 * some setup for tty handling 845 */ 846 tp = qd_tty[minor_dev]; 847 /* tp->t_addr = ui->ui_addr; */ 848 tp->t_oproc = qdstart; 849 tp->t_dev = dev; 850 if ((tp->t_state & TS_ISOPEN) == 0) { 851 ttychars(tp); 852 tp->t_ispeed = B9600; 853 tp->t_ospeed = B9600; 854 tp->t_state = TS_ISOPEN | TS_CARR_ON; 855 tp->t_iflag = TTYDEF_IFLAG; 856 tp->t_oflag = TTYDEF_OFLAG; 857 tp->t_lflag = TTYDEF_LFLAG; 858 tp->t_cflag = TTYDEF_CFLAG; 859 ttsetwater(tp); 860 } 861 /* 862 * enable intrpts, open line discipline 863 */ 864 dga->csr |= GLOBAL_IE; /* turn on the interrupts */ 865 return ((*tp->t_linesw->l_open)(dev, tp)); 866 } 867 dga->csr |= GLOBAL_IE; /* turn on the interrupts */ 868 return(0); 869 870 } /* qdopen */ 871 872 /*ARGSUSED*/ 873 int 874 qdclose(dev_t dev, int flag, int mode, struct proc *p) 875 { 876 struct tty *tp; 877 struct qdmap *qd; 878 volatile int *ptep; 879 volatile struct dga *dga; /* gate array register map pointer */ 880 volatile struct duart *duart; 881 volatile struct adder *adder; 882 int unit; 883 int minor_dev; 884 u_int mapix; 885 int i; /* SIGNED index */ 886 struct uba_softc *uh; 887 888 minor_dev = minor(dev); /* get minor device number */ 889 unit = minor_dev >> 2; /* get QDSS number */ 890 qd = &qdmap[unit]; 891 892 uh = device_private(device_parent(device_lookup(&qd_cd, unit))); 893 894 895 if ((minor_dev & 0x03) == 2) { 896 /* 897 * this is the graphic device... 898 */ 899 if (qdopened[unit] != 1) 900 return(EBUSY); 901 else 902 qdopened[unit] = 0; /* allow it to be re-opened */ 903 /* 904 * re-protect device memory 905 */ 906 if (qdflags[unit].mapped & MAPDEV) { 907 /* 908 * TEMPLATE RAM 909 */ 910 mapix = VTOP((int)qd->template) - VTOP(qvmem[0]); 911 ptep = (int *)(QVmap[0] + mapix); 912 for (i = 0; i < vax_btop(TMPSIZE); i++, ptep++) 913 *ptep = (*ptep & ~PG_PROT) | PG_V | PG_KW; 914 /* 915 * ADDER 916 */ 917 mapix = VTOP((int)qd->adder) - VTOP(qvmem[0]); 918 ptep = (int *)(QVmap[0] + mapix); 919 for (i = 0; i < vax_btop(REGSIZE); i++, ptep++) 920 *ptep = (*ptep & ~PG_PROT) | PG_V | PG_KW; 921 /* 922 * COLOR MAPS 923 */ 924 mapix = VTOP((int)qd->red) - VTOP(qvmem[0]); 925 ptep = (int *)(QVmap[0] + mapix); 926 for (i = 0; i < vax_btop(CLRSIZE); i++, ptep++) 927 *ptep = (*ptep & ~PG_PROT) | PG_V | PG_KW; 928 } 929 930 /* 931 * re-protect DMA buffer and free the map registers 932 */ 933 if (qdflags[unit].mapped & MAPDMA) { 934 panic("Unmapping unmapped buffer"); 935 #ifdef notyet 936 /* 937 * Ragge 990620: 938 * Can't happen because the buffer can't be mapped. 939 */ 940 dga = (struct dga *) qdmap[unit].dga; 941 adder = (struct adder *) qdmap[unit].adder; 942 dga->csr &= ~DMA_IE; 943 dga->csr &= ~0x0600; /* kill DMA */ 944 adder->command = CANCEL; 945 /* 946 * if DMA was running, flush spurious intrpt 947 */ 948 if (dga->bytcnt_lo != 0) { 949 dga->bytcnt_lo = 0; 950 dga->bytcnt_hi = 0; 951 DMA_SETIGNORE(DMAheader[unit]); 952 dga->csr |= DMA_IE; 953 dga->csr &= ~DMA_IE; 954 } 955 ptep = (int *) 956 ((VTOP(DMAheader[unit]*4)) + (mfpr(PR_SBR)|0x80000000)); 957 for (i = 0; i < vax_btop(DMAbuf_size); i++, ptep++) 958 *ptep = (*ptep & ~PG_PROT) | PG_V | PG_KW; 959 ubarelse(uh, &Qbus_unmap[unit]); 960 #endif 961 } 962 963 /* 964 * re-protect 1K (2 pages) event queue 965 */ 966 if (qdflags[unit].mapped & MAPEQ) { 967 ptep = (int *) 968 ((VTOP(eq_header[unit])*4) + (mfpr(PR_SBR)|0x80000000)); 969 *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V; ptep++; 970 *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V; 971 } 972 /* 973 * re-protect scroll param area and disable scroll intrpts 974 */ 975 if (qdflags[unit].mapped & MAPSCR) { 976 ptep = (int *) ((VTOP(scroll[unit]) * 4) 977 + (mfpr(PR_SBR) | 0x80000000)); 978 /* 979 * re-protect 512 scroll param area 980 */ 981 *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V; 982 adder = (struct adder *) qdmap[unit].adder; 983 qdflags[unit].adder_ie &= ~FRAME_SYNC; 984 adder->interrupt_enable = qdflags[unit].adder_ie; 985 } 986 /* 987 * re-protect color map write buffer area and kill intrpts 988 */ 989 if (qdflags[unit].mapped & MAPCOLOR) { 990 ptep = (int *) ((VTOP(color_buf[unit]) * 4) 991 + (mfpr(PR_SBR) | 0x80000000)); 992 *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V; ptep++; 993 *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V; 994 color_buf[unit]->status = 0; 995 adder = (struct adder *) qdmap[unit].adder; 996 qdflags[unit].adder_ie &= ~VSYNC; 997 adder->interrupt_enable = qdflags[unit].adder_ie; 998 } 999 mtpr(0, PR_TBIA); 1000 /* flag everything now unmapped */ 1001 qdflags[unit].mapped = 0; 1002 qdflags[unit].inuse &= ~GRAPHIC_DEV; 1003 qdflags[unit].curs_acc = ACC_OFF; 1004 qdflags[unit].curs_thr = 128; 1005 /* 1006 * restore the console 1007 */ 1008 dga = (struct dga *) qdmap[unit].dga; 1009 adder = (struct adder *) qdmap[unit].adder; 1010 dga->csr &= ~DMA_IE; 1011 dga->csr &= ~0x0600; /* halt the DMA! (just in case...) */ 1012 dga->csr |= DMA_ERR; /* clear error condition */ 1013 adder->command = CANCEL; 1014 /* 1015 * if DMA was running, flush spurious intrpt 1016 */ 1017 if (dga->bytcnt_lo != 0) { 1018 dga->bytcnt_lo = 0; 1019 dga->bytcnt_hi = 0; 1020 DMA_SETIGNORE(DMAheader[unit]); 1021 dga->csr |= DMA_IE; 1022 dga->csr &= ~DMA_IE; 1023 } 1024 init_shared(unit); /* init shared memory */ 1025 setup_dragon(unit); /* init ADDER/VIPER */ 1026 ldcursor(unit, cons_cursor); /* load default cursor map */ 1027 setup_input(unit); /* init the DUART */ 1028 ldfont(unit); 1029 cursor[unit].x = 0; 1030 cursor[unit].y = 0; 1031 /* 1032 * shut off the mouse rcv intrpt and turn on kbd intrpts 1033 */ 1034 duart = (struct duart *) qdmap[unit].duart; 1035 qdflags[unit].duart_imask &= ~(0x20); 1036 qdflags[unit].duart_imask |= 0x02; 1037 duart->imask = qdflags[unit].duart_imask; 1038 /* 1039 * shut off interrupts if all is closed 1040 */ 1041 if (!(qdflags[unit].inuse & CONS_DEV)) { 1042 dga = (struct dga *) qdmap[unit].dga; 1043 dga->csr &= ~(GLOBAL_IE | DMA_IE); 1044 } 1045 } else { 1046 /* 1047 * this is the console 1048 */ 1049 tp = qd_tty[minor_dev]; 1050 (*tp->t_linesw->l_close)(tp, flag); 1051 ttyclose(tp); 1052 tp->t_state = 0; 1053 qdflags[unit].inuse &= ~CONS_DEV; 1054 /* 1055 * if graphics device is closed, kill interrupts 1056 */ 1057 if (!(qdflags[unit].inuse & GRAPHIC_DEV)) { 1058 dga = (struct dga *) qdmap[unit].dga; 1059 dga->csr &= ~(GLOBAL_IE | DMA_IE); 1060 } 1061 } 1062 1063 return(0); 1064 1065 } /* qdclose */ 1066 1067 int 1068 qdioctl(dev_t dev, u_long cmd, void *datap, int flags, struct proc *p) 1069 { 1070 volatile int *ptep; /* page table entry pointer */ 1071 int mapix; /* QVmap[] page table index */ 1072 struct _vs_event *event; 1073 struct tty *tp; 1074 int i; 1075 struct qdmap *qd; /* pointer to device map struct */ 1076 volatile struct dga *dga; /* Gate Array reg structure pntr */ 1077 volatile struct duart *duart; /* DUART reg structure pointer */ 1078 volatile struct adder *adder; /* ADDER reg structure pointer */ 1079 struct prgkbd *cmdbuf; 1080 struct prg_cursor *curs; 1081 struct _vs_cursor *pos; 1082 int unit = minor(dev) >> 2; /* number of caller's QDSS */ 1083 u_int minor_dev = minor(dev); 1084 int error; 1085 int s; 1086 short *temp; /* a pointer to template RAM */ 1087 struct uba_softc *uh; 1088 1089 uh = device_private(device_parent(device_lookup(&qd_cd, unit))); 1090 1091 /* 1092 * service graphic device ioctl commands 1093 */ 1094 switch (cmd) { 1095 1096 case QD_GETEVENT: 1097 /* 1098 * extract the oldest event from the event queue 1099 */ 1100 if (ISEMPTY(eq_header[unit])) { 1101 event = (struct _vs_event *) datap; 1102 event->vse_device = VSE_NULL; 1103 break; 1104 } 1105 event = (struct _vs_event *) GETBEGIN(eq_header[unit]); 1106 s = spl5(); 1107 GETEND(eq_header[unit]); 1108 splx(s); 1109 memcpy(datap, (void *)event, sizeof(struct _vs_event)); 1110 break; 1111 1112 case QD_RESET: 1113 /* 1114 * init the dragon stuff, DUART, and driver variables 1115 */ 1116 init_shared(unit); /* init shared memory */ 1117 setup_dragon(unit); /* init the ADDER/VIPER stuff */ 1118 clear_qd_screen(unit); 1119 ldcursor(unit, cons_cursor); /* load default cursor map */ 1120 ldfont(unit); /* load the console font */ 1121 setup_input(unit); /* init the DUART */ 1122 break; 1123 1124 case QD_SET: 1125 /* 1126 * init the DUART and driver variables 1127 */ 1128 init_shared(unit); 1129 setup_input(unit); 1130 break; 1131 1132 case QD_CLRSCRN: 1133 /* 1134 * clear the QDSS screen. (NOTE that this reinits the dragon) 1135 */ 1136 #ifdef notdef /* has caused problems and isn't necessary */ 1137 setup_dragon(unit); 1138 clear_qd_screen(unit); 1139 #endif 1140 break; 1141 1142 case QD_WTCURSOR: 1143 /* 1144 * load a cursor into template RAM 1145 */ 1146 ldcursor(unit, (short *)datap); 1147 break; 1148 1149 case QD_RDCURSOR: 1150 1151 temp = (short *) qdmap[unit].template; 1152 /* 1153 * cursor is 32 WORDS from the end of the 8k WORD... 1154 * ...template space 1155 */ 1156 temp += (8 * 1024) - 32; 1157 for (i = 0; i < 32; ++i, datap += sizeof(short)) 1158 *(short *)datap = *temp++; 1159 break; 1160 1161 case QD_POSCURSOR: 1162 /* 1163 * position the mouse cursor 1164 */ 1165 dga = (struct dga *) qdmap[unit].dga; 1166 pos = (struct _vs_cursor *) datap; 1167 s = spl5(); 1168 dga->x_cursor = TRANX(pos->x); 1169 dga->y_cursor = TRANY(pos->y); 1170 eq_header[unit]->curs_pos.x = pos->x; 1171 eq_header[unit]->curs_pos.y = pos->y; 1172 splx(s); 1173 break; 1174 1175 case QD_PRGCURSOR: 1176 /* 1177 * set the cursor acceleration factor 1178 */ 1179 curs = (struct prg_cursor *) datap; 1180 s = spl5(); 1181 qdflags[unit].curs_acc = curs->acc_factor; 1182 qdflags[unit].curs_thr = curs->threshold; 1183 splx(s); 1184 break; 1185 1186 case QD_MAPDEVICE: 1187 /* 1188 * enable 'user write' to device pages 1189 */ 1190 qdflags[unit].mapped |= MAPDEV; 1191 qd = (struct qdmap *) &qdmap[unit]; 1192 /* 1193 * enable user write to template RAM 1194 */ 1195 mapix = VTOP((int)qd->template) - VTOP(qvmem[0]); 1196 ptep = (int *)(QVmap[0] + mapix); 1197 for (i = 0; i < vax_btop(TMPSIZE); i++, ptep++) 1198 *ptep = (*ptep & ~PG_PROT) | PG_RW | PG_V; 1199 1200 /* 1201 * enable user write to registers 1202 */ 1203 mapix = VTOP((int)qd->adder) - VTOP(qvmem[0]); 1204 ptep = (int *)(QVmap[0] + mapix); 1205 for (i = 0; i < vax_btop(REGSIZE); i++, ptep++) 1206 *ptep = (*ptep & ~PG_PROT) | PG_RW | PG_V; 1207 1208 /* 1209 * enable user write to color maps 1210 */ 1211 mapix = VTOP((int)qd->red) - VTOP(qvmem[0]); 1212 ptep = (int *)(QVmap[0] + mapix); 1213 for (i = 0; i < vax_btop(CLRSIZE); i++, ptep++) 1214 *ptep = (*ptep & ~PG_PROT) | PG_RW | PG_V; 1215 1216 /* 1217 * enable user write to DUART 1218 */ 1219 mapix = VTOP((int)qd->duart) - VTOP(qvmem[0]); 1220 ptep = (int *)(QVmap[0] + mapix); 1221 *ptep = (*ptep & ~PG_PROT) | PG_RW | PG_V; /* duart page */ 1222 1223 mtpr(0, PR_TBIA); /* invalidate translation buffer */ 1224 1225 /* 1226 * stuff qdmap structure in return buffer 1227 */ 1228 memcpy(datap, (void *)qd, sizeof(struct qdmap)); 1229 1230 break; 1231 1232 #ifdef notyet 1233 /* 1234 * Ragge 999620: 1235 * Can't map in the graphic buffer into user space for now. 1236 * The best way to fix this is to convert this driver to wscons. 1237 */ 1238 case QD_MAPIOBUF: 1239 /* 1240 * do setup for DMA by user process 1241 * 1242 * set 'user write enable' bits for DMA buffer 1243 */ 1244 qdflags[unit].mapped |= MAPDMA; 1245 ptep = (int *) ((VTOP(DMAheader[unit]) * 4) 1246 + (mfpr(PR_SBR) | 0x80000000)); 1247 for (i = 0; i < vax_btop(DMAbuf_size); i++, ptep++) 1248 *ptep = (*ptep & ~PG_PROT) | PG_RW | PG_V; 1249 mtpr(0, PR_TBIA); /* invalidate translation buffer */ 1250 /* 1251 * set up QBUS map registers for DMA 1252 */ 1253 DMAheader[unit]->QBAreg = 1254 uballoc(uh, (void *)DMAheader[unit], DMAbuf_size, 0); 1255 if (DMAheader[unit]->QBAreg == 0) 1256 printf("qd%d: qdioctl: QBA setup error\n", unit); 1257 Qbus_unmap[unit] = DMAheader[unit]->QBAreg; 1258 DMAheader[unit]->QBAreg &= 0x3FFFF; 1259 /* 1260 * return I/O buf adr 1261 */ 1262 *(int *)datap = (int) DMAheader[unit]; 1263 break; 1264 #endif 1265 1266 case QD_MAPSCROLL: 1267 /* 1268 * map the shared scroll param area and enable scroll interpts 1269 */ 1270 qdflags[unit].mapped |= MAPSCR; 1271 ptep = (int *) ((VTOP(scroll[unit]) * 4) 1272 + (mfpr(PR_SBR) | 0x80000000)); 1273 /* 1274 * allow user write to scroll area 1275 */ 1276 *ptep = (*ptep & ~PG_PROT) | PG_RW | PG_V; 1277 mtpr(0, PR_TBIA); /* invalidate translation buf */ 1278 scroll[unit]->status = 0; 1279 adder = (struct adder *) qdmap[unit].adder; 1280 qdflags[unit].adder_ie |= FRAME_SYNC; 1281 adder->interrupt_enable = qdflags[unit].adder_ie; 1282 *(int *)datap = (int) scroll[unit]; /* return scroll area */ 1283 break; 1284 1285 case QD_UNMAPSCROLL: 1286 /* 1287 * unmap shared scroll param area and disable scroll intrpts 1288 */ 1289 if (qdflags[unit].mapped & MAPSCR) { 1290 qdflags[unit].mapped &= ~MAPSCR; 1291 ptep = (int *) ((VTOP(scroll[unit]) * 4) 1292 + (mfpr(PR_SBR) | 0x80000000)); 1293 /* 1294 * re-protect 512 scroll param area 1295 */ 1296 *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V; 1297 mtpr(0, PR_TBIA); /* smash CPU's translation buf */ 1298 adder = (struct adder *) qdmap[unit].adder; 1299 qdflags[unit].adder_ie &= ~FRAME_SYNC; 1300 adder->interrupt_enable = qdflags[unit].adder_ie; 1301 } 1302 break; 1303 1304 case QD_MAPCOLOR: 1305 /* 1306 * map shared color map write buf and turn on vsync intrpt 1307 */ 1308 qdflags[unit].mapped |= MAPCOLOR; 1309 ptep = (int *) ((VTOP(color_buf[unit]) * 4) 1310 + (mfpr(PR_SBR) | 0x80000000)); 1311 /* 1312 * allow user write to color map write buffer 1313 */ 1314 *ptep = (*ptep & ~PG_PROT) | PG_RW | PG_V; ptep++; 1315 *ptep = (*ptep & ~PG_PROT) | PG_RW | PG_V; 1316 mtpr(0, PR_TBIA); /* clr CPU translation buf */ 1317 adder = (struct adder *) qdmap[unit].adder; 1318 qdflags[unit].adder_ie |= VSYNC; 1319 adder->interrupt_enable = qdflags[unit].adder_ie; 1320 /* 1321 * return color area address 1322 */ 1323 *(int *)datap = (int) color_buf[unit]; 1324 break; 1325 1326 case QD_UNMAPCOLOR: 1327 /* 1328 * unmap shared color map write buffer and kill VSYNC intrpts 1329 */ 1330 if (qdflags[unit].mapped & MAPCOLOR) { 1331 qdflags[unit].mapped &= ~MAPCOLOR; 1332 ptep = (int *) ((VTOP(color_buf[unit]) * 4) 1333 + (mfpr(PR_SBR) | 0x80000000)); 1334 /* 1335 * re-protect color map write buffer 1336 */ 1337 *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V; ptep++; 1338 *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V; 1339 mtpr(0, PR_TBIA); 1340 adder = (struct adder *) qdmap[unit].adder; 1341 qdflags[unit].adder_ie &= ~VSYNC; 1342 adder->interrupt_enable = qdflags[unit].adder_ie; 1343 } 1344 break; 1345 1346 case QD_MAPEVENT: 1347 /* 1348 * give user write access to the event queue 1349 */ 1350 qdflags[unit].mapped |= MAPEQ; 1351 ptep = (int *) ((VTOP(eq_header[unit]) * 4) 1352 + (mfpr(PR_SBR) | 0x80000000)); 1353 /* 1354 * allow user write to 1K event queue 1355 */ 1356 *ptep = (*ptep & ~PG_PROT) | PG_RW | PG_V; ptep++; 1357 *ptep = (*ptep & ~PG_PROT) | PG_RW | PG_V; 1358 mtpr(0, PR_TBIA); /* clr CPU translation buf */ 1359 /* 1360 * return event queue address 1361 */ 1362 *(int *)datap = (int)eq_header[unit]; 1363 break; 1364 1365 case QD_PRGKBD: 1366 /* 1367 * pass caller's programming commands to LK201 1368 */ 1369 duart = (struct duart *)qdmap[unit].duart; 1370 cmdbuf = (struct prgkbd *)datap; /* pnt to kbd cmd buf */ 1371 /* 1372 * send command 1373 */ 1374 for (i = 1000; i > 0; --i) { 1375 if (duart->statusA&XMT_RDY) { 1376 duart->dataA = cmdbuf->cmd; 1377 break; 1378 } 1379 } 1380 if (i == 0) { 1381 printf("qd%d: qdioctl: timeout on XMT_RDY [1]\n", unit); 1382 break; 1383 } 1384 /* 1385 * send param1? 1386 */ 1387 if (cmdbuf->cmd & LAST_PARAM) 1388 break; 1389 for (i = 1000; i > 0; --i) { 1390 if (duart->statusA&XMT_RDY) { 1391 duart->dataA = cmdbuf->param1; 1392 break; 1393 } 1394 } 1395 if (i == 0) { 1396 printf("qd%d: qdioctl: timeout on XMT_RDY [2]\n", unit); 1397 break; 1398 } 1399 /* 1400 * send param2? 1401 */ 1402 if (cmdbuf->param1 & LAST_PARAM) 1403 break; 1404 for (i = 1000; i > 0; --i) { 1405 if (duart->statusA&XMT_RDY) { 1406 duart->dataA = cmdbuf->param2; 1407 break; 1408 } 1409 } 1410 if (i == 0) { 1411 printf("qd%d: qdioctl: timeout on XMT_RDY [3]\n", unit); 1412 break; 1413 } 1414 break; 1415 1416 case QD_PRGMOUSE: 1417 /* 1418 * pass caller's programming commands to the mouse 1419 */ 1420 duart = (struct duart *) qdmap[unit].duart; 1421 for (i = 1000; i > 0; --i) { 1422 if (duart->statusB&XMT_RDY) { 1423 duart->dataB = *datap; 1424 break; 1425 } 1426 } 1427 if (i == 0) { 1428 printf("qd%d: qdioctl: timeout on XMT_RDY [4]\n", unit); 1429 } 1430 break; 1431 1432 case QD_RDCONFIG: 1433 /* 1434 * get QDSS configuration word and return it 1435 */ 1436 *(short *)datap = qdflags[unit].config; 1437 break; 1438 1439 case QD_KERN_LOOP: 1440 case QD_KERN_UNLOOP: 1441 /* 1442 * vestige from ultrix. BSD uses TIOCCONS to redirect 1443 * kernel console output. 1444 */ 1445 break; 1446 1447 case QD_PRGTABLET: 1448 /* 1449 * program the tablet 1450 */ 1451 duart = (struct duart *) qdmap[unit].duart; 1452 for (i = 1000; i > 0; --i) { 1453 if (duart->statusB&XMT_RDY) { 1454 duart->dataB = *datap; 1455 break; 1456 } 1457 } 1458 if (i == 0) { 1459 printf("qd%d: qdioctl: timeout on XMT_RDY [5]\n", unit); 1460 } 1461 break; 1462 1463 case QD_PRGTABRES: 1464 /* 1465 * program the tablet report resolution factor 1466 */ 1467 qdflags[unit].tab_res = *(short *)datap; 1468 break; 1469 1470 default: 1471 /* 1472 * service tty ioctl's 1473 */ 1474 if (!(minor_dev & 0x02)) { 1475 tp = qd_tty[minor_dev]; 1476 error = 1477 1478 (*tp->t_linesw->l_ioctl)(tp, cmd, datap, flags, p); 1479 if (error != EPASSTHROUGH) { 1480 return(error); 1481 } 1482 return ttioctl(tp, cmd, datap, flags, p); 1483 } 1484 break; 1485 } 1486 1487 return(0); 1488 1489 } /* qdioctl */ 1490 1491 1492 int 1493 qdpoll(dev_t dev, int events, struct proc *p) 1494 { 1495 int s; 1496 int unit; 1497 struct tty *tp; 1498 u_int minor_dev = minor(dev); 1499 int revents = 0; 1500 1501 s = spl5(); 1502 unit = minor_dev >> 2; 1503 1504 if ((minor_dev & 0x03) == 2) { 1505 /* 1506 * This is a graphics device, so check for events. 1507 */ 1508 1509 if (events & (POLLIN | POLLRDNORM)) 1510 if(!(ISEMPTY(eq_header[unit]))) 1511 revents |= events & (POLLIN | POLLRDNORM); 1512 1513 if (events & (POLLOUT | POLLWRNORM)) 1514 if (DMA_ISEMPTY(DMAheader[unit])) 1515 revents |= events & (POLLOUT | POLLWRNORM); 1516 1517 if (revents == 0) { 1518 if (events & (POLLIN | POLLRDNORM)) 1519 selrecord(p, &qdrsel[unit]); 1520 1521 if (events & (POLLOUT | POLLWRNORM)) 1522 selrecord(p, &qdrsel[unit]); 1523 } 1524 } else { 1525 /* 1526 * this is a tty device 1527 */ 1528 tp = qd_tty[minor_dev]; 1529 revents = (*tp->t_linesw->l_poll)(tp, events, p); 1530 } 1531 1532 splx(s); 1533 return (revents); 1534 } /* qdpoll() */ 1535 1536 static void 1537 filt_qdrdetach(struct knote *kn) 1538 { 1539 dev_t dev = (intptr_t) kn->kn_hook; 1540 u_int minor_dev = minor(dev); 1541 int unit = minor_dev >> 2; 1542 int s; 1543 1544 s = spl5(); 1545 SLIST_REMOVE(&qdrsel[unit].sel_klist, kn, knote, kn_selnext); 1546 splx(s); 1547 } 1548 1549 static int 1550 filt_qdread(struct knote *kn, long hint) 1551 { 1552 dev_t dev = (intptr_t) kn->kn_hook; 1553 u_int minor_dev = minor(dev); 1554 int unit = minor_dev >> 2; 1555 1556 if (ISEMPTY(eq_header[unit])) 1557 return (0); 1558 1559 kn->kn_data = 0; /* XXXLUKEM (thorpej): what to put here? */ 1560 return (1); 1561 } 1562 1563 static int 1564 filt_qdwrite(struct knote *kn, long hint) 1565 { 1566 dev_t dev = (intptr_t) kn->kn_hook; 1567 u_int minor_dev = minor(dev); 1568 int unit = minor_dev >> 2; 1569 1570 if (! DMA_ISEMPTY(DMAheader[unit])) 1571 return (0); 1572 1573 kn->kn_data = 0; /* XXXLUKEM (thorpej): what to put here? */ 1574 return (1); 1575 } 1576 1577 static const struct filterops qdread_filtops = 1578 { 1, NULL, filt_qdrdetach, filt_qdread }; 1579 1580 static const struct filterops qdwrite_filtops = 1581 { 1, NULL, filt_qdrdetach, filt_qdwrite }; 1582 1583 int 1584 qdkqfilter(dev_t dev, struct knote *kn) 1585 { 1586 struct klist *klist; 1587 u_int minor_dev = minor(dev); 1588 int s, unit = minor_dev >> 2; 1589 1590 if ((minor_dev & 0x03) != 2) { 1591 /* TTY device. */ 1592 return (ttykqfilter(dev, kn)); 1593 } 1594 1595 switch (kn->kn_filter) { 1596 case EVFILT_READ: 1597 klist = &qdrsel[unit].sel_klist; 1598 kn->kn_fop = &qdread_filtops; 1599 break; 1600 1601 case EVFILT_WRITE: 1602 klist = &qdrsel[unit].sel_klist; 1603 kn->kn_fop = &qdwrite_filtops; 1604 break; 1605 1606 default: 1607 return (EINVAL); 1608 } 1609 1610 kn->kn_hook = (void *)(intptr_t) dev; 1611 1612 s = spl5(); 1613 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 1614 splx(s); 1615 1616 return (0); 1617 } 1618 1619 void qd_strategy(struct buf *bp); 1620 1621 /*ARGSUSED*/ 1622 int 1623 qdwrite(dev_t dev, struct uio *uio, int flag) 1624 { 1625 struct tty *tp; 1626 int minor_dev; 1627 int unit; 1628 1629 minor_dev = minor(dev); 1630 unit = (minor_dev >> 2) & 0x07; 1631 1632 if (((minor_dev&0x03) != 0x02) && (qdflags[unit].inuse&CONS_DEV)) { 1633 /* 1634 * this is the console... 1635 */ 1636 tp = qd_tty[minor_dev]; 1637 return ((*tp->t_linesw->l_write)(tp, uio, flag)); 1638 } else if (qdflags[unit].inuse & GRAPHIC_DEV) { 1639 /* 1640 * this is a DMA xfer from user space 1641 */ 1642 return (physio(qd_strategy, NULL, dev, B_WRITE, minphys, uio)); 1643 } 1644 return (ENXIO); 1645 } 1646 1647 /*ARGSUSED*/ 1648 int 1649 qdread(dev_t dev, struct uio *uio, int flag) 1650 { 1651 struct tty *tp; 1652 int minor_dev; 1653 int unit; 1654 1655 minor_dev = minor(dev); 1656 unit = (minor_dev >> 2) & 0x07; 1657 1658 if ((minor_dev & 0x03) != 0x02 && qdflags[unit].inuse & CONS_DEV) { 1659 /* 1660 * this is the console 1661 */ 1662 tp = qd_tty[minor_dev]; 1663 return ((*tp->t_linesw->l_read)(tp, uio, flag)); 1664 } else if (qdflags[unit].inuse & GRAPHIC_DEV) { 1665 /* 1666 * this is a bitmap-to-processor xfer 1667 */ 1668 return (physio(qd_strategy, NULL, dev, B_READ, minphys, uio)); 1669 } 1670 return (ENXIO); 1671 } 1672 1673 /*************************************************************** 1674 * 1675 * qd_strategy()... strategy routine to do DMA 1676 * 1677 ***************************************************************/ 1678 1679 void 1680 qd_strategy(struct buf *bp) 1681 { 1682 volatile struct dga *dga; 1683 volatile struct adder *adder; 1684 int unit; 1685 int QBAreg; 1686 int s; 1687 int cookie; 1688 struct uba_softc *uh; 1689 1690 unit = (minor(bp->b_dev) >> 2) & 0x07; 1691 1692 uh = device_private(device_parent(device_lookup(&qd_cd, unit))); 1693 1694 /* 1695 * init pointers 1696 */ 1697 dga = (struct dga *) qdmap[unit].dga; 1698 panic("qd_strategy"); 1699 #ifdef notyet 1700 if ((QBAreg = ubasetup(uh, bp, 0)) == 0) { 1701 printf("qd%d: qd_strategy: QBA setup error\n", unit); 1702 goto STRAT_ERR; 1703 } 1704 #endif 1705 s = spl5(); 1706 qdflags[unit].user_dma = -1; 1707 dga->csr |= DMA_IE; 1708 cookie = QBAreg & 0x3FFFF; 1709 dga->adrs_lo = (short) cookie; 1710 dga->adrs_hi = (short) (cookie >> 16); 1711 dga->bytcnt_lo = (short) bp->b_bcount; 1712 dga->bytcnt_hi = (short) (bp->b_bcount >> 16); 1713 1714 while (qdflags[unit].user_dma) { 1715 (void) tsleep(&qdflags[unit].user_dma, QSPRIOR, 1716 "qdstrat", 0); 1717 } 1718 splx(s); 1719 #ifdef notyet 1720 ubarelse(uh, &QBAreg); 1721 #endif 1722 if (!(dga->csr & DMA_ERR)) { 1723 biodone(bp); 1724 return; 1725 } 1726 1727 /* STRAT_ERR: */ 1728 adder = (struct adder *) qdmap[unit].adder; 1729 adder->command = CANCEL; /* cancel adder activity */ 1730 dga->csr &= ~DMA_IE; 1731 dga->csr &= ~0x0600; /* halt DMA (reset fifo) */ 1732 dga->csr |= DMA_ERR; /* clear error condition */ 1733 bp->b_error = EIO; /* flag an error to physio() */ 1734 1735 /* 1736 * if DMA was running, flush spurious intrpt 1737 */ 1738 if (dga->bytcnt_lo != 0) { 1739 dga->bytcnt_lo = 0; 1740 dga->bytcnt_hi = 0; 1741 DMA_SETIGNORE(DMAheader[unit]); 1742 dga->csr |= DMA_IE; 1743 } 1744 biodone(bp); 1745 } /* qd_strategy */ 1746 1747 1748 /* 1749 * Start output to the console screen 1750 */ 1751 void qdstart(tp) 1752 struct tty *tp; 1753 { 1754 int which_unit, unit, c; 1755 int s; 1756 1757 unit = minor(tp->t_dev); 1758 which_unit = (unit >> 2) & 0x3; 1759 unit &= 0x03; 1760 1761 s = spl5(); 1762 1763 /* 1764 * If it's currently active, or delaying, no need to do anything. 1765 */ 1766 if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP)) 1767 goto out; 1768 1769 /* 1770 * Display chars until the queue is empty. 1771 * Drop input from anything but the console 1772 * device on the floor. 1773 * 1774 * XXX - this loop is done at spltty. 1775 * 1776 */ 1777 while (tp->t_outq.c_cc) { 1778 c = getc(&tp->t_outq); 1779 if (unit == 0) 1780 blitc(which_unit, (u_char)c); 1781 } 1782 ttypull(tp); 1783 tp->t_state &= ~TS_BUSY; 1784 1785 out: 1786 splx(s); 1787 1788 } /* qdstart */ 1789 1790 /*ARGSUSED*/ 1791 void 1792 qdstop(struct tty *tp, int flag) 1793 { 1794 int s; 1795 1796 s = spl5(); /* block intrpts during state modification */ 1797 if (tp->t_state & TS_BUSY) { 1798 if ((tp->t_state & TS_TTSTOP) == 0) 1799 tp->t_state |= TS_FLUSH; 1800 else 1801 tp->t_state &= ~TS_BUSY; 1802 } 1803 splx(s); 1804 } 1805 1806 /* 1807 * Output a character to the QDSS screen 1808 */ 1809 void 1810 blitc(int unit, u_char chr) 1811 { 1812 volatile struct adder *adder; 1813 volatile struct dga *dga; 1814 int i; 1815 int nograph = !(qdflags[unit].inuse&GRAPHIC_DEV); 1816 static short inescape[NQD]; 1817 1818 adder = (struct adder *)qdmap[unit].adder; 1819 dga = (struct dga *) qdmap[unit].dga; 1820 /* 1821 * BSD comment: this (&=0177) defeats the extended character 1822 * set code for the glass tty, but if i had the time i would 1823 * spend it ripping out the code completely. This driver 1824 * is too big for its own good. 1825 */ 1826 chr &= 0177; 1827 /* 1828 * Cursor addressing (so vi will work). 1829 * Decode for "\E=%.%." cursor motion description. 1830 * Corresponds to type "qdcons" in /etc/termcap: 1831 * 1832 * qd|qdss|qdcons|qdss glass tty (4.4 BSD):\ 1833 * :am:do=^J:le=^H:bs:cm=\E=%.%.:cl=1^Z:co#128:li#57::nd=^L:up=^K: 1834 * 1835 */ 1836 if (inescape[unit] && nograph) { 1837 switch (inescape[unit]++) { 1838 case 1: 1839 if (chr != '=') { 1840 /* abort escape sequence */ 1841 inescape[unit] = 0; 1842 blitc(unit, chr); 1843 } 1844 return; 1845 case 2: 1846 /* position row */ 1847 cursor[unit].y = CHAR_HEIGHT * chr; 1848 if (cursor[unit].y > 863 - CHAR_HEIGHT) 1849 cursor[unit].y = 863 - CHAR_HEIGHT; 1850 dga->y_cursor = TRANY(cursor[unit].y); 1851 return; 1852 case 3: 1853 /* position column */ 1854 cursor[unit].x = CHAR_WIDTH * chr; 1855 if (cursor[unit].x > 1024 - CHAR_WIDTH) 1856 cursor[unit].x = 1023 - CHAR_WIDTH; 1857 dga->x_cursor = TRANX(cursor[unit].x); 1858 inescape[unit] = 0; 1859 return; 1860 default: 1861 inescape[unit] = 0; 1862 blitc(unit, chr); 1863 } 1864 } 1865 1866 switch (chr) { 1867 case '\r': /* return char */ 1868 cursor[unit].x = 0; 1869 if (nograph) 1870 dga->x_cursor = TRANX(cursor[unit].x); 1871 return; 1872 1873 case '\t': /* tab char */ 1874 for (i = 8 - ((cursor[unit].x >> 3) & 0x07); i > 0; --i) { 1875 blitc(unit, ' '); 1876 } 1877 return; 1878 1879 case '\n': /* line feed char */ 1880 if ((cursor[unit].y += CHAR_HEIGHT) > (863 - CHAR_HEIGHT)) { 1881 if (nograph) { 1882 cursor[unit].y -= CHAR_HEIGHT; 1883 scroll_up(adder); 1884 } else 1885 cursor[unit].y = 0; 1886 } 1887 if (nograph) 1888 dga->y_cursor = TRANY(cursor[unit].y); 1889 return; 1890 1891 case '\b': /* backspace char */ 1892 if (cursor[unit].x > 0) { 1893 cursor[unit].x -= CHAR_WIDTH; 1894 if (nograph) 1895 dga->x_cursor = TRANX(cursor[unit].x); 1896 } 1897 return; 1898 case CTRL('k'): /* cursor up */ 1899 if (nograph && cursor[unit].y > 0) { 1900 cursor[unit].y -= CHAR_HEIGHT; 1901 dga->y_cursor = TRANY(cursor[unit].y); 1902 } 1903 return; 1904 1905 case CTRL('^'): /* home cursor */ 1906 if (nograph) { 1907 cursor[unit].x = 0; 1908 dga->x_cursor = TRANX(cursor[unit].x); 1909 cursor[unit].y = 0; 1910 dga->y_cursor = TRANY(cursor[unit].y); 1911 } 1912 return; 1913 1914 case CTRL('l'): /* cursor right */ 1915 if (nograph && cursor[unit].x < 1023 - CHAR_WIDTH) { 1916 cursor[unit].x += CHAR_WIDTH; 1917 dga->x_cursor = TRANX(cursor[unit].x); 1918 } 1919 return; 1920 1921 case CTRL('z'): /* clear screen */ 1922 if (nograph) { 1923 setup_dragon(unit); 1924 clear_qd_screen(unit); 1925 /* home cursor - termcap seems to assume this */ 1926 cursor[unit].x = 0; 1927 dga->x_cursor = TRANX(cursor[unit].x); 1928 cursor[unit].y = 0; 1929 dga->y_cursor = TRANY(cursor[unit].y); 1930 } 1931 return; 1932 1933 case '\033': /* start escape sequence */ 1934 if (nograph) 1935 inescape[unit] = 1; 1936 return; 1937 1938 default: 1939 if ((chr < ' ') || (chr > '~')) 1940 return; 1941 } 1942 /* 1943 * setup VIPER operand control registers 1944 */ 1945 write_ID(adder, CS_UPDATE_MASK, 0x0001); /* select plane #0 */ 1946 write_ID(adder, SRC1_OCR_B, 1947 EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY); 1948 write_ID(adder, CS_UPDATE_MASK, 0x00FE); /* select other planes */ 1949 write_ID(adder, SRC1_OCR_B, 1950 EXT_SOURCE | INT_NONE | NO_ID | BAR_SHIFT_DELAY); 1951 write_ID(adder, CS_UPDATE_MASK, 0x00FF); /* select all planes */ 1952 write_ID(adder, DST_OCR_B, 1953 EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY); 1954 write_ID(adder, MASK_1, 0xFFFF); 1955 write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 1); 1956 write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0); 1957 adder->x_clip_min = 0; 1958 adder->x_clip_max = 1024; 1959 adder->y_clip_min = 0; 1960 adder->y_clip_max = 864; 1961 /* 1962 * load DESTINATION origin and vectors 1963 */ 1964 adder->fast_dest_dy = 0; 1965 adder->slow_dest_dx = 0; 1966 adder->error_1 = 0; 1967 adder->error_2 = 0; 1968 adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL; 1969 (void)wait_status(adder, RASTEROP_COMPLETE); 1970 adder->destination_x = cursor[unit].x; 1971 adder->fast_dest_dx = CHAR_WIDTH; 1972 adder->destination_y = cursor[unit].y; 1973 adder->slow_dest_dy = CHAR_HEIGHT; 1974 /* 1975 * load SOURCE origin and vectors 1976 */ 1977 if ((chr - ' ') > (CHARS - 1)) { 1978 printf("Invalid character (x)%x in blitc\n",chr); 1979 chr = ' '; 1980 } 1981 /* 1982 * X position is modulo the number of characters per line 1983 */ 1984 adder->source_1_x = FONT_X + 1985 (((chr - ' ') % (MAX_SCREEN_X/CHAR_WIDTH)) * CHAR_WIDTH); 1986 /* 1987 * Point to either first or second row 1988 */ 1989 adder->source_1_y = 2048 - 15 * 1990 (((chr - ' ')/(MAX_SCREEN_X/CHAR_WIDTH)) + 1); 1991 adder->source_1_dx = CHAR_WIDTH; 1992 adder->source_1_dy = CHAR_HEIGHT; 1993 write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE); 1994 adder->cmd = RASTEROP | OCRB | 0 | S1E | DTE; 1995 /* 1996 * update console cursor coordinates 1997 */ 1998 cursor[unit].x += CHAR_WIDTH; 1999 if (nograph) 2000 dga->x_cursor = TRANX(cursor[unit].x); 2001 if (cursor[unit].x > (1024 - CHAR_WIDTH)) { 2002 blitc(unit, '\r'); 2003 blitc(unit, '\n'); 2004 } 2005 2006 } /* blitc */ 2007 2008 /* 2009 * INTERRUPT SERVICE ROUTINES 2010 */ 2011 2012 /* 2013 * Service "DMA DONE" interrupt condition 2014 */ 2015 2016 static void 2017 qddint(void *arg) 2018 { 2019 device_t dv = arg; 2020 struct DMAreq_header *header; 2021 struct DMAreq *request; 2022 volatile struct dga *dga; 2023 volatile struct adder *adder; 2024 int cookie; /* DMA adrs for QDSS */ 2025 int unit = device_unit(dv); 2026 2027 (void)spl4(); /* allow interval timer in */ 2028 2029 /* 2030 * init pointers 2031 */ 2032 header = DMAheader[unit]; /* register for optimization */ 2033 dga = (struct dga *) qdmap[unit].dga; 2034 adder = (struct adder *) qdmap[unit].adder; 2035 2036 /* 2037 * if this interrupt flagged as bogus for interrupt flushing purposes.. 2038 */ 2039 if (DMA_ISIGNORE(header)) { 2040 DMA_CLRIGNORE(header); 2041 return; 2042 } 2043 2044 /* 2045 * dump a DMA hardware error message if appropriate 2046 */ 2047 if (dga->csr & DMA_ERR) { 2048 2049 if (dga->csr & PARITY_ERR) 2050 printf("qd%d: qddint: DMA hardware parity fault.\n", unit); 2051 2052 if (dga->csr & BUS_ERR) 2053 printf("qd%d: qddint: DMA hardware bus error.\n", unit); 2054 } 2055 2056 /* 2057 * if this was a DMA from user space... 2058 */ 2059 if (qdflags[unit].user_dma) { 2060 qdflags[unit].user_dma = 0; 2061 wakeup((void *)&qdflags[unit].user_dma); 2062 return; 2063 } 2064 2065 /* 2066 * if we're doing DMA request queue services, field the error condition 2067 */ 2068 if (dga->csr & DMA_ERR) { 2069 2070 dga->csr &= ~0x0600; /* halt DMA (reset fifo) */ 2071 dga->csr |= DMA_ERR; /* clear error condition */ 2072 adder->command = CANCEL; /* cancel adder activity */ 2073 2074 DMA_SETERROR(header); /* flag error in header status word */ 2075 DMA_CLRACTIVE(header); 2076 header->DMAreq[header->oldest].DMAdone |= HARD_ERROR; 2077 header->newest = header->oldest; 2078 header->used = 0; 2079 2080 selnotify(&qdrsel[unit], 0, 0); 2081 2082 if (dga->bytcnt_lo != 0) { 2083 dga->bytcnt_lo = 0; 2084 dga->bytcnt_hi = 0; 2085 DMA_SETIGNORE(header); 2086 } 2087 return; 2088 } 2089 2090 /* 2091 * if the DMA request queue is now becoming non-full, 2092 * wakeup "select" client. 2093 */ 2094 if (DMA_ISFULL(header)) { 2095 selnotify(&qdrsel[unit], 0, 0); 2096 } 2097 2098 header->DMAreq[header->oldest].DMAdone |= REQUEST_DONE; 2099 QDlast_DMAtype = header->DMAreq[header->oldest].DMAtype; 2100 2101 /* check for unexpected interrupt */ 2102 if (DMA_ISEMPTY(header)) 2103 return; 2104 2105 DMA_GETEND(header); /* update request queue indices */ 2106 2107 /* 2108 * if no more DMA pending, wake up "select" client and exit 2109 */ 2110 if (DMA_ISEMPTY(header)) { 2111 selnotify(&qdrsel[unit], 0, 0); 2112 DMA_CLRACTIVE(header); /* flag DMA done */ 2113 return; 2114 } 2115 2116 /* 2117 * initiate next DMA xfer 2118 */ 2119 request = DMA_GETBEGIN(header); 2120 if (request->DMAtype != QDlast_DMAtype) { 2121 dga->csr &= ~0x0600; /* halt DMA (reset fifo) */ 2122 adder->command = CANCEL; /* cancel adder activity */ 2123 } 2124 2125 2126 switch (request->DMAtype) { 2127 2128 case DISPLIST: 2129 if (request->DMAtype != QDlast_DMAtype) { 2130 dga->csr |= DL_ENB; 2131 dga->csr &= ~(BTOP_ENB | BYTE_DMA); 2132 } 2133 break; 2134 2135 case PTOB: 2136 if (request->DMAtype != QDlast_DMAtype) { 2137 if (request->DMAdone & BYTE_PACK) 2138 dga->csr |= (PTOB_ENB | BYTE_DMA); 2139 else { 2140 dga->csr |= PTOB_ENB; 2141 dga->csr &= ~BYTE_DMA; 2142 } 2143 } 2144 break; 2145 2146 case BTOP: 2147 if (request->DMAtype != QDlast_DMAtype) { 2148 if (request->DMAdone & BYTE_PACK) { 2149 dga->csr &= ~DL_ENB; 2150 dga->csr |= (BTOP_ENB | BYTE_DMA); 2151 } 2152 else { 2153 dga->csr |= BTOP_ENB; 2154 dga->csr &= ~(BYTE_DMA | DL_ENB); 2155 } 2156 } 2157 break; 2158 default: 2159 printf("qd%d: qddint: illegal DMAtype parameter.\n", unit); 2160 DMA_CLRACTIVE(header); /* flag DMA done */ 2161 return; 2162 } 2163 2164 if (request->DMAdone & COUNT_ZERO) { 2165 dga->csr &= ~SET_DONE_FIFO; 2166 } 2167 else if (request->DMAdone & FIFO_EMPTY) { 2168 dga->csr |= SET_DONE_FIFO; 2169 } 2170 2171 if (request->DMAdone & WORD_PACK) 2172 dga->csr &= ~BYTE_DMA; 2173 else if (request->DMAdone & BYTE_PACK) 2174 dga->csr |= BYTE_DMA; 2175 2176 dga->csr |= DMA_IE; 2177 QDlast_DMAtype = request->DMAtype; 2178 2179 cookie = ((int)request->bufp - (int)header) + (int)header->QBAreg; 2180 2181 dga->adrs_lo = (short) cookie; 2182 dga->adrs_hi = (short) (cookie >> 16); 2183 2184 dga->bytcnt_lo = (short) request->length; 2185 dga->bytcnt_hi = (short) (request->length >> 16); 2186 2187 return; 2188 } 2189 2190 /* 2191 * ADDER interrupt service routine 2192 */ 2193 static void 2194 qdaint(void *arg) 2195 { 2196 device_t dv = arg; 2197 volatile struct adder *adder; 2198 struct color_buf *cbuf; 2199 int i; 2200 struct rgb *rgbp; 2201 volatile short *red; 2202 volatile short *green; 2203 volatile short *blue; 2204 int unit = device_unit(dv); 2205 2206 (void)spl4(); /* allow interval timer in */ 2207 2208 adder = (struct adder *) qdmap[unit].adder; 2209 2210 /* 2211 * service the vertical blank interrupt (VSYNC bit) by loading 2212 * any pending color map load request 2213 */ 2214 if (adder->status & VSYNC) { 2215 adder->status &= ~VSYNC; /* clear the interrupt */ 2216 cbuf = color_buf[unit]; 2217 if (cbuf->status & LOAD_COLOR_MAP) { 2218 2219 red = (short *) qdmap[unit].red; 2220 green = (short *) qdmap[unit].green; 2221 blue = (short *) qdmap[unit].blue; 2222 2223 for (i = cbuf->count, rgbp = cbuf->rgb; 2224 --i >= 0; rgbp++) { 2225 red[rgbp->offset] = (short) rgbp->red; 2226 green[rgbp->offset] = (short) rgbp->green; 2227 blue[rgbp->offset] = (short) rgbp->blue; 2228 } 2229 2230 cbuf->status &= ~LOAD_COLOR_MAP; 2231 } 2232 } 2233 2234 /* 2235 * service the scroll interrupt (FRAME_SYNC bit) 2236 */ 2237 if (adder->status & FRAME_SYNC) { 2238 adder->status &= ~FRAME_SYNC; /* clear the interrupt */ 2239 2240 if (scroll[unit]->status & LOAD_REGS) { 2241 2242 for (i = 1000, adder->status = 0; i > 0 && 2243 !(adder->status&ID_SCROLL_READY); --i) 2244 ; 2245 2246 if (i == 0) { 2247 printf("qd%d: qdaint: timeout on ID_SCROLL_READY\n", 2248 qd); 2249 return; 2250 } 2251 2252 adder->ID_scroll_data = scroll[unit]->viper_constant; 2253 adder->ID_scroll_command = ID_LOAD | SCROLL_CONSTANT; 2254 2255 adder->y_scroll_constant = 2256 scroll[unit]->y_scroll_constant; 2257 adder->y_offset_pending = scroll[unit]->y_offset; 2258 2259 if (scroll[unit]->status & LOAD_INDEX) { 2260 2261 adder->x_index_pending = 2262 scroll[unit]->x_index_pending; 2263 adder->y_index_pending = 2264 scroll[unit]->y_index_pending; 2265 } 2266 2267 scroll[unit]->status = 0x00; 2268 } 2269 } 2270 } 2271 2272 /* 2273 * DUART input interrupt service routine 2274 * 2275 * XXX - this routine should be broken out - it is essentially 2276 * straight line code. 2277 */ 2278 2279 static void 2280 qdiint(void *arg) 2281 { 2282 device_t dv = arg; 2283 struct _vs_event *event; 2284 struct qdinput *eqh; 2285 volatile struct dga *dga; 2286 volatile struct duart *duart; 2287 struct mouse_report *new_rep; 2288 struct tty *tp; 2289 u_short chr; 2290 u_short status; 2291 u_short data; 2292 u_short key; 2293 char do_wakeup = 0; /* flag to do a select wakeup call */ 2294 char a, b, c; /* mouse button test variables */ 2295 int unit = device_unit(dv); 2296 2297 (void)spl4(); /* allow interval timer in */ 2298 2299 eqh = eq_header[unit]; /* optimized as a register */ 2300 new_rep = ¤t_rep[unit]; 2301 duart = (struct duart *) qdmap[unit].duart; 2302 2303 /* 2304 * if the graphic device is turned on.. 2305 */ 2306 if (qdflags[unit].inuse & GRAPHIC_DEV) { 2307 /* 2308 * empty DUART 2309 */ 2310 while (duart->statusA&RCV_RDY || duart->statusB&RCV_RDY) { 2311 /* 2312 * pick up LK-201 input (if any) 2313 */ 2314 if (duart->statusA&RCV_RDY) { 2315 2316 /* if error condition, then reset it */ 2317 2318 if (duart->statusA&0x70) { 2319 duart->cmdA = 0x40; 2320 continue; 2321 } 2322 2323 /* event queue full now? (overflow condition) */ 2324 2325 if (ISFULL(eqh) == TRUE) { 2326 printf( 2327 "qd%d: qdiint: event queue overflow\n", 2328 qd); 2329 break; 2330 } 2331 2332 /* 2333 * Check for various keyboard errors */ 2334 2335 key = duart->dataA & 0xFF; 2336 2337 if (key==LK_POWER_ERROR || 2338 key==LK_KDOWN_ERROR || 2339 key == LK_INPUT_ERROR || 2340 key == LK_OUTPUT_ERROR) { 2341 printf( 2342 "qd%d: qdiint: keyboard error, code = %x\n", 2343 qd,key); 2344 return; 2345 } 2346 2347 if (key < LK_LOWEST) 2348 return; 2349 2350 ++do_wakeup; /* request a select wakeup call */ 2351 2352 event = PUTBEGIN(eqh); 2353 PUTEND(eqh); 2354 2355 event->vse_key = key; 2356 event->vse_key &= 0x00FF; 2357 event->vse_x = eqh->curs_pos.x; 2358 event->vse_y = eqh->curs_pos.y; 2359 event->vse_time = TOY; 2360 event->vse_type = VSE_BUTTON; 2361 event->vse_direction = VSE_KBTRAW; 2362 event->vse_device = VSE_DKB; 2363 } 2364 2365 /* 2366 * pick up the mouse input (if any) */ 2367 2368 if ((status = duart->statusB) & RCV_RDY && 2369 qdflags[unit].pntr_id == MOUSE_ID) { 2370 2371 if (status & 0x70) { 2372 duart->cmdB = 0x40; 2373 continue; 2374 } 2375 2376 /* event queue full now? (overflow condition) */ 2377 2378 if (ISFULL(eqh) == TRUE) { 2379 printf( 2380 "qd%d: qdiint: event queue overflow\n", 2381 qd); 2382 break; 2383 } 2384 2385 data = duart->dataB; /* get report byte */ 2386 ++new_rep->bytcnt; /* bump report byte count */ 2387 2388 /* 2389 * if 1st byte of report.. */ 2390 2391 if ( data & START_FRAME) { 2392 new_rep->state = data; 2393 if (new_rep->bytcnt > 1) { 2394 /* start of new frame */ 2395 new_rep->bytcnt = 1; 2396 /* ..continue looking */ 2397 continue; 2398 } 2399 } 2400 2401 /* 2402 * if 2nd byte of report.. */ 2403 2404 else if (new_rep->bytcnt == 2) { 2405 new_rep->dx = data & 0x00FF; 2406 } 2407 2408 /* 2409 * if 3rd byte of report, load input event queue */ 2410 2411 else if (new_rep->bytcnt == 3) { 2412 2413 new_rep->dy = data & 0x00FF; 2414 new_rep->bytcnt = 0; 2415 2416 /* 2417 * if mouse position has changed.. */ 2418 2419 if (new_rep->dx != 0 || new_rep->dy != 0) { 2420 2421 /* 2422 * calculate acceleration factor, if needed */ 2423 2424 if (qdflags[unit].curs_acc > ACC_OFF) { 2425 2426 if (qdflags[unit].curs_thr <= new_rep->dx) 2427 new_rep->dx += 2428 (new_rep->dx - qdflags[unit].curs_thr) 2429 * qdflags[unit].curs_acc; 2430 2431 if (qdflags[unit].curs_thr <= new_rep->dy) 2432 new_rep->dy += 2433 (new_rep->dy - qdflags[unit].curs_thr) 2434 * qdflags[unit].curs_acc; 2435 } 2436 2437 /* 2438 * update cursor position coordinates */ 2439 2440 if (new_rep->state & X_SIGN) { 2441 eqh->curs_pos.x += new_rep->dx; 2442 if (eqh->curs_pos.x > 1023) 2443 eqh->curs_pos.x = 1023; 2444 } 2445 else { 2446 eqh->curs_pos.x -= new_rep->dx; 2447 if (eqh->curs_pos.x < -15) 2448 eqh->curs_pos.x = -15; 2449 } 2450 2451 if (new_rep->state & Y_SIGN) { 2452 eqh->curs_pos.y -= new_rep->dy; 2453 if (eqh->curs_pos.y < -15) 2454 eqh->curs_pos.y = -15; 2455 } 2456 else { 2457 eqh->curs_pos.y += new_rep->dy; 2458 if (eqh->curs_pos.y > 863) 2459 eqh->curs_pos.y = 863; 2460 } 2461 2462 /* 2463 * update cursor screen position */ 2464 2465 dga = (struct dga *) qdmap[unit].dga; 2466 dga->x_cursor = TRANX(eqh->curs_pos.x); 2467 dga->y_cursor = TRANY(eqh->curs_pos.y); 2468 2469 /* 2470 * if cursor is in the box, no event report */ 2471 2472 if (eqh->curs_pos.x <= eqh->curs_box.right && 2473 eqh->curs_pos.x >= eqh->curs_box.left && 2474 eqh->curs_pos.y >= eqh->curs_box.top && 2475 eqh->curs_pos.y <= eqh->curs_box.bottom ) { 2476 goto GET_MBUTTON; 2477 } 2478 2479 /* 2480 * report the mouse motion event */ 2481 2482 event = PUTBEGIN(eqh); 2483 PUTEND(eqh); 2484 2485 ++do_wakeup; /* request a select wakeup call */ 2486 2487 event->vse_x = eqh->curs_pos.x; 2488 event->vse_y = eqh->curs_pos.y; 2489 2490 event->vse_device = VSE_MOUSE; /* mouse */ 2491 event->vse_type = VSE_MMOTION; /* pos changed */ 2492 event->vse_key = 0; 2493 event->vse_direction = 0; 2494 event->vse_time = TOY; /* time stamp */ 2495 } 2496 2497 GET_MBUTTON: 2498 /* 2499 * if button state has changed */ 2500 2501 a = new_rep->state & 0x07; /*mask nonbutton bits */ 2502 b = last_rep[unit].state & 0x07; 2503 2504 if (a ^ b) { 2505 2506 for ( c = 1; c < 8; c <<= 1) { 2507 2508 if (!( c & (a ^ b))) /* this button change? */ 2509 continue; 2510 2511 /* event queue full? (overflow condition) */ 2512 2513 if (ISFULL(eqh) == TRUE) { 2514 printf("qd%d: qdiint: event queue overflow\n", qd); 2515 break; 2516 } 2517 2518 event = PUTBEGIN(eqh); /* get new event */ 2519 PUTEND(eqh); 2520 2521 ++do_wakeup; /* request select wakeup */ 2522 2523 event->vse_x = eqh->curs_pos.x; 2524 event->vse_y = eqh->curs_pos.y; 2525 2526 event->vse_device = VSE_MOUSE; /* mouse */ 2527 event->vse_type = VSE_BUTTON; /* new button */ 2528 event->vse_time = TOY; /* time stamp */ 2529 2530 /* flag changed button and if up or down */ 2531 2532 if (c == RIGHT_BUTTON) 2533 event->vse_key = VSE_RIGHT_BUTTON; 2534 else if (c == MIDDLE_BUTTON) 2535 event->vse_key = VSE_MIDDLE_BUTTON; 2536 else if (c == LEFT_BUTTON) 2537 event->vse_key = VSE_LEFT_BUTTON; 2538 2539 /* set bit = button depressed */ 2540 2541 if (c & a) 2542 event->vse_direction = VSE_KBTDOWN; 2543 else 2544 event->vse_direction = VSE_KBTUP; 2545 } 2546 } 2547 2548 /* refresh last report */ 2549 2550 last_rep[unit] = current_rep[unit]; 2551 2552 } /* get last byte of report */ 2553 } else if ((status = duart->statusB)&RCV_RDY && 2554 qdflags[unit].pntr_id == TABLET_ID) { 2555 /* 2556 * pickup tablet input, if any 2557 */ 2558 if (status&0x70) { 2559 duart->cmdB = 0x40; 2560 continue; 2561 } 2562 /* 2563 * event queue full now? (overflow condition) 2564 */ 2565 if (ISFULL(eqh) == TRUE) { 2566 printf("qd%d: qdiint: event queue overflow\n", qd); 2567 break; 2568 } 2569 2570 data = duart->dataB; /* get report byte */ 2571 ++new_rep->bytcnt; /* bump report byte count */ 2572 2573 /* 2574 * if 1st byte of report.. */ 2575 2576 if (data & START_FRAME) { 2577 new_rep->state = data; 2578 if (new_rep->bytcnt > 1) { 2579 new_rep->bytcnt = 1; /* start of new frame */ 2580 continue; /* ..continue looking */ 2581 } 2582 } 2583 2584 /* 2585 * if 2nd byte of report.. */ 2586 2587 else if (new_rep->bytcnt == 2) { 2588 new_rep->dx = data & 0x3F; 2589 } 2590 2591 /* 2592 * if 3rd byte of report.. */ 2593 2594 else if (new_rep->bytcnt == 3) { 2595 new_rep->dx |= (data & 0x3F) << 6; 2596 } 2597 2598 /* 2599 * if 4th byte of report.. */ 2600 2601 else if (new_rep->bytcnt == 4) { 2602 new_rep->dy = data & 0x3F; 2603 } 2604 2605 /* 2606 * if 5th byte of report, load input event queue */ 2607 2608 else if (new_rep->bytcnt == 5) { 2609 2610 new_rep->dy |= (data & 0x3F) << 6; 2611 new_rep->bytcnt = 0; 2612 2613 /* 2614 * update cursor position coordinates */ 2615 2616 new_rep->dx /= qdflags[unit].tab_res; 2617 new_rep->dy = (2200 - new_rep->dy) 2618 / qdflags[unit].tab_res; 2619 2620 if (new_rep->dx > 1023) { 2621 new_rep->dx = 1023; 2622 } 2623 if (new_rep->dy > 863) { 2624 new_rep->dy = 863; 2625 } 2626 2627 /* 2628 * report an event if the puck/stylus has moved 2629 */ 2630 2631 if (eqh->curs_pos.x != new_rep->dx || 2632 eqh->curs_pos.y != new_rep->dy) { 2633 2634 eqh->curs_pos.x = new_rep->dx; 2635 eqh->curs_pos.y = new_rep->dy; 2636 2637 /* 2638 * update cursor screen position */ 2639 2640 dga = (struct dga *) qdmap[unit].dga; 2641 dga->x_cursor = TRANX(eqh->curs_pos.x); 2642 dga->y_cursor = TRANY(eqh->curs_pos.y); 2643 2644 /* 2645 * if cursor is in the box, no event report 2646 */ 2647 2648 if (eqh->curs_pos.x <= eqh->curs_box.right && 2649 eqh->curs_pos.x >= eqh->curs_box.left && 2650 eqh->curs_pos.y >= eqh->curs_box.top && 2651 eqh->curs_pos.y <= eqh->curs_box.bottom ) { 2652 goto GET_TBUTTON; 2653 } 2654 2655 /* 2656 * report the tablet motion event */ 2657 2658 event = PUTBEGIN(eqh); 2659 PUTEND(eqh); 2660 2661 ++do_wakeup; /* request a select wakeup call */ 2662 2663 event->vse_x = eqh->curs_pos.x; 2664 event->vse_y = eqh->curs_pos.y; 2665 2666 event->vse_device = VSE_TABLET; /* tablet */ 2667 /* 2668 * right now, X handles tablet motion the same 2669 * as mouse motion 2670 */ 2671 event->vse_type = VSE_MMOTION; /* pos changed */ 2672 event->vse_key = 0; 2673 event->vse_direction = 0; 2674 event->vse_time = TOY; /* time stamp */ 2675 } 2676 GET_TBUTTON: 2677 /* 2678 * if button state has changed */ 2679 2680 a = new_rep->state & 0x1E; /* mask nonbutton bits */ 2681 b = last_rep[unit].state & 0x1E; 2682 2683 if (a ^ b) { 2684 2685 /* event queue full now? (overflow condition) */ 2686 2687 if (ISFULL(eqh) == TRUE) { 2688 printf("qd%d: qdiint: event queue overflow\n",qd); 2689 break; 2690 } 2691 2692 event = PUTBEGIN(eqh); /* get new event */ 2693 PUTEND(eqh); 2694 2695 ++do_wakeup; /* request a select wakeup call */ 2696 2697 event->vse_x = eqh->curs_pos.x; 2698 event->vse_y = eqh->curs_pos.y; 2699 2700 event->vse_device = VSE_TABLET; /* tablet */ 2701 event->vse_type = VSE_BUTTON; /* button changed */ 2702 event->vse_time = TOY; /* time stamp */ 2703 2704 /* define the changed button and if up or down */ 2705 2706 for ( c = 1; c <= 0x10; c <<= 1) { 2707 if (c & (a ^ b)) { 2708 if (c == T_LEFT_BUTTON) 2709 event->vse_key = VSE_T_LEFT_BUTTON; 2710 else if (c == T_FRONT_BUTTON) 2711 event->vse_key = VSE_T_FRONT_BUTTON; 2712 else if (c == T_RIGHT_BUTTON) 2713 event->vse_key = VSE_T_RIGHT_BUTTON; 2714 else if (c == T_BACK_BUTTON) 2715 event->vse_key = VSE_T_BACK_BUTTON; 2716 break; 2717 } 2718 } 2719 2720 /* set bit = button depressed */ 2721 2722 if (c & a) 2723 event->vse_direction = VSE_KBTDOWN; 2724 else 2725 event->vse_direction = VSE_KBTUP; 2726 } 2727 2728 /* refresh last report */ 2729 2730 last_rep[unit] = current_rep[unit]; 2731 2732 } /* get last byte of report */ 2733 } /* pick up tablet input */ 2734 2735 } /* while input available.. */ 2736 2737 /* 2738 * do select wakeup 2739 */ 2740 if (do_wakeup) { 2741 selnotify(&qdrsel[unit], 0, 0); 2742 do_wakeup = 0; 2743 } 2744 } else { 2745 /* 2746 * if the graphic device is not turned on, this is console input 2747 */ 2748 if (qdpolling) 2749 return; 2750 2751 if (unit >= qd_cd.cd_ndevs || device_lookup(&qd_cd, unit) == NULL) 2752 return; /* no such device or address */ 2753 2754 tp = qd_tty[unit << 2]; 2755 2756 /* 2757 * Get a character from the keyboard. 2758 */ 2759 while (duart->statusA&RCV_RDY) { 2760 key = duart->dataA; 2761 key &= 0xFF; 2762 /* 2763 * Check for various keyboard errors 2764 */ 2765 if (key == LK_POWER_ERROR || key == LK_KDOWN_ERROR || 2766 key == LK_INPUT_ERROR || key == LK_OUTPUT_ERROR) { 2767 printf("qd%d: qdiint: Keyboard error, code = %x\n",qd,key); 2768 return; 2769 } 2770 2771 if (key < LK_LOWEST) 2772 return; 2773 2774 /* 2775 * See if its a state change key */ 2776 2777 switch (key) { 2778 2779 case LOCK: 2780 q_keyboard.lock ^= 0xffff; /* toggle */ 2781 if (q_keyboard.lock) 2782 led_control(qd, LK_LED_ENABLE, 2783 LK_LED_LOCK); 2784 else 2785 led_control(qd, LK_LED_DISABLE, 2786 LK_LED_LOCK); 2787 return; 2788 2789 case SHIFT: 2790 q_keyboard.shift ^= 0xFFFF; 2791 return; 2792 2793 case CNTRL: 2794 q_keyboard.cntrl ^= 0xFFFF; 2795 return; 2796 2797 case ALLUP: 2798 q_keyboard.cntrl = 0; 2799 q_keyboard.shift = 0; 2800 return; 2801 2802 case REPEAT: 2803 chr = q_keyboard.last; 2804 break; 2805 2806 /* 2807 * Test for cntrl characters. If set, see if the character 2808 * is elligible to become a control character. */ 2809 2810 default: 2811 2812 if (q_keyboard.cntrl) { 2813 chr = q_key[key]; 2814 if (chr >= ' ' && chr <= '~') 2815 chr &= 0x1F; 2816 else if (chr >= 0xA1 && chr <= 0xFE) 2817 chr &= 0x9F; 2818 } 2819 else if( q_keyboard.lock || q_keyboard.shift ) 2820 chr = q_shift_key[key]; 2821 else 2822 chr = q_key[key]; 2823 break; 2824 } 2825 2826 q_keyboard.last = chr; 2827 2828 /* 2829 * Check for special function keys */ 2830 2831 if (chr & 0x100) { 2832 char *string; 2833 string = q_special[chr & 0x7F]; 2834 while(*string) 2835 (*tp->t_linesw->l_rint)(*string++, tp); 2836 } 2837 else { 2838 #ifdef DDB 2839 /* Check for kernel debugger escape here */ 2840 int j; 2841 2842 j = kdbrint(chr&0177); 2843 2844 if (j == 1) /* Escape received, just return */ 2845 return; 2846 2847 if (j == 2) /* Second char wasn't 'D' */ 2848 (*tp->t_linesw->l_rint)(27, tp); 2849 #endif 2850 (*tp->t_linesw->l_rint)(chr&0177, tp); 2851 } 2852 } 2853 } 2854 } /* qdiint */ 2855 2856 /* 2857 * 2858 * Clear the QDSS screen 2859 * 2860 * >>> NOTE <<< 2861 * 2862 * This code requires that certain adder initialization be valid. To 2863 * assure that this requirement is satisfied, this routine should be 2864 * called only after calling the "setup_dragon()" function. 2865 * 2866 * Clear the bitmap a piece at a time. Since the fast scroll clear 2867 * only clears the current displayed portion of the bitmap put a 2868 * temporary value in the y limit register so we can access whole 2869 * bitmap 2870 * 2871 */ 2872 void 2873 clear_qd_screen(int unit) 2874 { 2875 volatile struct adder *adder; 2876 adder = (struct adder *) qdmap[unit].adder; 2877 2878 adder->x_limit = 1024; 2879 adder->y_limit = 2048 - CHAR_HEIGHT; 2880 adder->y_offset_pending = 0; 2881 #define WSV (void)wait_status(adder, VSYNC); (void)wait_status(adder, VSYNC) 2882 WSV; 2883 adder->y_scroll_constant = SCROLL_ERASE; 2884 WSV; 2885 adder->y_offset_pending = 864; 2886 WSV; 2887 adder->y_scroll_constant = SCROLL_ERASE; 2888 WSV; 2889 adder->y_offset_pending = 1728; 2890 WSV; 2891 adder->y_scroll_constant = SCROLL_ERASE; 2892 WSV; 2893 adder->y_offset_pending = 0; /* back to normal */ 2894 WSV; 2895 adder->x_limit = MAX_SCREEN_X; 2896 adder->y_limit = MAX_SCREEN_Y + FONT_HEIGHT; 2897 #undef WSV 2898 2899 } /* clear_qd_screen */ 2900 2901 /* 2902 * kernel console output to the glass tty 2903 */ 2904 void 2905 qdcnputc(dev_t dev, int chr) 2906 { 2907 2908 /* 2909 * if system is now physical, forget it (ie: crash DUMP) 2910 */ 2911 if ((mfpr(PR_MAPEN) & 1) == 0) 2912 return; 2913 2914 blitc(0, (u_char)(chr & 0xff)); 2915 if ((chr & 0177) == '\n') 2916 blitc(0, '\r'); 2917 2918 } /* qdputc */ 2919 2920 /* 2921 * load the mouse cursor's template RAM bitmap 2922 */ 2923 void 2924 ldcursor(int unit, short *bitmap) 2925 { 2926 volatile struct dga *dga; 2927 volatile short *temp; 2928 int i; 2929 int curs; 2930 2931 dga = (struct dga *) qdmap[unit].dga; 2932 temp = (short *) qdmap[unit].template; 2933 2934 if (dga->csr & CURS_ENB) { /* if the cursor is enabled.. */ 2935 curs = -1; /* ..note that.. */ 2936 dga->csr &= ~CURS_ENB; /* ..and shut it off */ 2937 } else 2938 curs = 0; 2939 2940 dga->csr &= ~CURS_ENB; /* shut off the cursor */ 2941 2942 temp += (8 * 1024) - 32; /* cursor is 32 WORDS from the end */ 2943 /* ..of the 8k WORD template space */ 2944 for (i = 0; i < 32; ++i) 2945 *temp++ = *bitmap++; 2946 2947 if (curs) { /* if cursor was enabled.. */ 2948 dga->csr |= CURS_ENB; /* ..turn it back on */ 2949 } 2950 2951 } /* ldcursor */ 2952 2953 /* 2954 * Put the console font in the QDSS off-screen memory 2955 */ 2956 void 2957 ldfont(int unit) 2958 { 2959 volatile struct adder *adder; 2960 2961 int i, j, k, max_chars_line; 2962 short packed; 2963 2964 adder = (struct adder *) qdmap[unit].adder; 2965 2966 /* 2967 * setup VIPER operand control registers 2968 */ 2969 write_ID(adder, MASK_1, 0xFFFF); 2970 write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255); 2971 write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0); 2972 2973 write_ID(adder, SRC1_OCR_B, 2974 EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY); 2975 write_ID(adder, SRC2_OCR_B, 2976 EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY); 2977 write_ID(adder, DST_OCR_B, 2978 EXT_SOURCE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY); 2979 2980 adder->rasterop_mode = DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL; 2981 2982 /* 2983 * load destination data 2984 */ 2985 (void)wait_status(adder, RASTEROP_COMPLETE); 2986 2987 adder->destination_x = FONT_X; 2988 adder->destination_y = FONT_Y; 2989 #if FONT_WIDTH > MAX_SCREEN_X 2990 adder->fast_dest_dx = MAX_SCREEN_X; 2991 #else 2992 adder->fast_dest_dx = FONT_WIDTH; 2993 #endif 2994 adder->slow_dest_dy = CHAR_HEIGHT; 2995 2996 /* 2997 * setup for processor to bitmap xfer */ 2998 2999 write_ID(adder, CS_UPDATE_MASK, 0x0001); 3000 adder->cmd = PBT | OCRB | 2 | DTE | 2; 3001 3002 /* 3003 * Figure out how many characters can be stored on one "line" of 3004 * offscreen memory. 3005 */ 3006 max_chars_line = MAX_SCREEN_X/(CHAR_WIDTH*2); 3007 if ((CHARS/2 + CHARS%2) < max_chars_line) 3008 max_chars_line = CHARS/2 + CHARS%2; 3009 3010 /* 3011 * iteratively do the processor to bitmap xfer */ 3012 3013 for (i = 0; i < ROWS; ++i) { 3014 3015 /* PTOB a scan line */ 3016 3017 for (j = 0, k = i; j < max_chars_line; ++j) { 3018 /* PTOB one scan of a char cell */ 3019 3020 packed = q_font[k]; 3021 k += ROWS; 3022 packed |= ((short)q_font[k] << 8); 3023 k += ROWS; 3024 3025 (void)wait_status(adder, TX_READY); 3026 adder->id_data = packed; 3027 } 3028 } 3029 3030 /* 3031 * (XXX XXX XXX - should remove) 3032 * 3033 * Copy the second row of characters. Subtract the first 3034 * row from the total number. Divide this quantity by 2 3035 * because 2 chars are stored in a short in the PTOB loop 3036 * below. Figure out how many characters can be stored on 3037 * one "line" of offscreen memory 3038 */ 3039 3040 max_chars_line = MAX_SCREEN_X/(CHAR_WIDTH*2); 3041 if ((CHARS/2 + CHARS%2) < max_chars_line) 3042 return; 3043 max_chars_line = (CHARS/2 + CHARS%2) - max_chars_line; /* 95 - 64 */ 3044 /* Paranoia check to see if 3rd row may be needed */ 3045 if (max_chars_line > (MAX_SCREEN_X/(CHAR_WIDTH*2))) 3046 max_chars_line = MAX_SCREEN_X/(CHAR_WIDTH*2); 3047 3048 adder->destination_x = FONT_X; 3049 adder->destination_y = FONT_Y - CHAR_HEIGHT; 3050 adder->fast_dest_dx = max_chars_line * CHAR_WIDTH * 2; 3051 adder->slow_dest_dy = CHAR_HEIGHT; 3052 3053 /* 3054 * setup for processor to bitmap xfer 3055 */ 3056 write_ID(adder, CS_UPDATE_MASK, 0x0001); 3057 adder->cmd = PBT | OCRB | 2 | DTE | 2; 3058 3059 /* 3060 * iteratively do the processor to bitmap xfer 3061 */ 3062 for (i = 0; i < ROWS; ++i) { 3063 /* 3064 * PTOB a scan line 3065 */ 3066 for (j = 0, k = i; j < max_chars_line; ++j) { 3067 /* 3068 * PTOB one scan of a char cell 3069 */ 3070 packed = q_font[k + FONT_OFFSET]; 3071 k += ROWS; 3072 packed |= ((short)q_font[k + FONT_OFFSET] << 8); 3073 k += ROWS; 3074 (void)wait_status(adder, TX_READY); 3075 adder->id_data = packed; 3076 } 3077 } 3078 3079 } /* ldfont */ 3080 3081 3082 /* 3083 * Disable or enable polling. This is used when entering or leaving the 3084 * kernel debugger. 3085 */ 3086 void 3087 qdcnpollc(dev_t dev, int onoff) 3088 { 3089 qdpolling = onoff; 3090 } 3091 3092 3093 /* 3094 * Get a character from the LK201 (polled) 3095 */ 3096 int 3097 qdcngetc(dev_t dev) 3098 { 3099 short key; 3100 char chr; 3101 volatile struct duart *duart; 3102 3103 duart = (struct duart *) qdmap[0].duart; 3104 3105 /* 3106 * Get a character from the keyboard. 3107 */ 3108 LOOP: 3109 while (!(duart->statusA&RCV_RDY)) 3110 ; 3111 3112 key = duart->dataA; 3113 key &= 0xFF; 3114 3115 /* 3116 * Check for various keyboard errors */ 3117 3118 if (key == LK_POWER_ERROR || key == LK_KDOWN_ERROR || 3119 key == LK_INPUT_ERROR || key == LK_OUTPUT_ERROR) { 3120 printf("Keyboard error, code = %x\n", key); 3121 return(0); 3122 } 3123 3124 if (key < LK_LOWEST) 3125 return(0); 3126 3127 /* 3128 * See if its a state change key 3129 */ 3130 switch (key) { 3131 3132 case LOCK: 3133 q_keyboard.lock ^= 0xffff; /* toggle */ 3134 if (q_keyboard.lock) 3135 led_control(0, LK_LED_ENABLE, LK_LED_LOCK); 3136 else 3137 led_control(0, LK_LED_DISABLE, LK_LED_LOCK); 3138 goto LOOP; 3139 3140 case SHIFT: 3141 q_keyboard.shift ^= 0xFFFF; 3142 goto LOOP; 3143 3144 case CNTRL: 3145 q_keyboard.cntrl ^= 0xFFFF; 3146 goto LOOP; 3147 3148 case ALLUP: 3149 q_keyboard.cntrl = 0; 3150 q_keyboard.shift = 0; 3151 goto LOOP; 3152 3153 case REPEAT: 3154 chr = q_keyboard.last; 3155 break; 3156 3157 /* 3158 * Test for cntrl characters. If set, see if the character 3159 * is elligible to become a control character. 3160 */ 3161 default: 3162 3163 if (q_keyboard.cntrl) { 3164 chr = q_key[key]; 3165 if (chr >= ' ' && chr <= '~') 3166 chr &= 0x1F; 3167 } 3168 else if ( q_keyboard.lock || q_keyboard.shift ) 3169 chr = q_shift_key[key]; 3170 else 3171 chr = q_key[key]; 3172 break; 3173 } 3174 3175 if (chr < ' ' && chr > '~') /* if input is non-displayable */ 3176 return(0); /* ..then pitch it! */ 3177 3178 q_keyboard.last = chr; 3179 3180 /* 3181 * Check for special function keys */ 3182 3183 if (chr & 0x80) /* pitch the function keys */ 3184 return(0); 3185 else 3186 return(chr); 3187 3188 } /* qdgetc */ 3189 3190 /* 3191 * led_control()... twiddle LK-201 LED's 3192 */ 3193 void 3194 led_control(int unit, int cmd, int led_mask) 3195 { 3196 int i; 3197 volatile struct duart *duart; 3198 3199 duart = (struct duart *)qdmap[unit].duart; 3200 3201 for (i = 1000; i > 0; --i) { 3202 if (duart->statusA&XMT_RDY) { 3203 duart->dataA = cmd; 3204 break; 3205 } 3206 } 3207 for (i = 1000; i > 0; --i) { 3208 if (duart->statusA&XMT_RDY) { 3209 duart->dataA = led_mask; 3210 break; 3211 } 3212 } 3213 return; 3214 3215 } /* led_control */ 3216 3217 /* 3218 * scroll_up()... move the screen up one character height 3219 */ 3220 void 3221 scroll_up(volatile struct adder *adder) 3222 { 3223 /* 3224 * setup VIPER operand control registers 3225 */ 3226 (void)wait_status(adder, ADDRESS_COMPLETE); 3227 write_ID(adder, CS_UPDATE_MASK, 0x00FF); /* select all planes */ 3228 write_ID(adder, MASK_1, 0xFFFF); 3229 write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255); 3230 write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0); 3231 write_ID(adder, SRC1_OCR_B, 3232 EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY); 3233 write_ID(adder, DST_OCR_B, 3234 EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY); 3235 /* 3236 * load DESTINATION origin and vectors 3237 */ 3238 adder->fast_dest_dy = 0; 3239 adder->slow_dest_dx = 0; 3240 adder->error_1 = 0; 3241 adder->error_2 = 0; 3242 adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL; 3243 adder->destination_x = 0; 3244 adder->fast_dest_dx = 1024; 3245 adder->destination_y = 0; 3246 adder->slow_dest_dy = 864 - CHAR_HEIGHT; 3247 /* 3248 * load SOURCE origin and vectors 3249 */ 3250 adder->source_1_x = 0; 3251 adder->source_1_dx = 1024; 3252 adder->source_1_y = 0 + CHAR_HEIGHT; 3253 adder->source_1_dy = 864 - CHAR_HEIGHT; 3254 write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE); 3255 adder->cmd = RASTEROP | OCRB | 0 | S1E | DTE; 3256 /* 3257 * do a rectangle clear of last screen line 3258 */ 3259 write_ID(adder, MASK_1, 0xffff); 3260 write_ID(adder, SOURCE, 0xffff); 3261 write_ID(adder,DST_OCR_B, 3262 (EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY)); 3263 write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 0); 3264 adder->error_1 = 0; 3265 adder->error_2 = 0; 3266 adder->slow_dest_dx = 0; /* set up the width of */ 3267 adder->slow_dest_dy = CHAR_HEIGHT; /* rectangle */ 3268 adder->rasterop_mode = (NORMAL | DST_WRITE_ENABLE) ; 3269 (void)wait_status(adder, RASTEROP_COMPLETE); 3270 adder->destination_x = 0; 3271 adder->destination_y = 864 - CHAR_HEIGHT; 3272 adder->fast_dest_dx = 1024; /* set up the height */ 3273 adder->fast_dest_dy = 0; /* of rectangle */ 3274 write_ID(adder, LU_FUNCTION_R2, (FULL_SRC_RESOLUTION | LF_SOURCE)); 3275 adder->cmd = (RASTEROP | OCRB | LF_R2 | DTE ) ; 3276 3277 } /* scroll_up */ 3278 3279 /* 3280 * init shared memory pointers and structures 3281 */ 3282 void 3283 init_shared(int unit) 3284 { 3285 volatile struct dga *dga; 3286 3287 dga = (struct dga *) qdmap[unit].dga; 3288 3289 /* 3290 * initialize the event queue pointers and header */ 3291 3292 eq_header[unit] = (struct qdinput *) 3293 ((((int)event_shared & ~(0x01FF)) + 512) 3294 + (EVENT_BUFSIZE * unit)); 3295 eq_header[unit]->curs_pos.x = 0; 3296 eq_header[unit]->curs_pos.y = 0; 3297 dga->x_cursor = TRANX(eq_header[unit]->curs_pos.x); 3298 dga->y_cursor = TRANY(eq_header[unit]->curs_pos.y); 3299 eq_header[unit]->curs_box.left = 0; 3300 eq_header[unit]->curs_box.right = 0; 3301 eq_header[unit]->curs_box.top = 0; 3302 eq_header[unit]->curs_box.bottom = 0; 3303 /* 3304 * assign a pointer to the DMA I/O buffer for this QDSS. 3305 */ 3306 DMAheader[unit] = (struct DMAreq_header *) 3307 (((int)(&DMA_shared[0] + 512) & ~0x1FF) 3308 + (DMAbuf_size * unit)); 3309 DMAheader[unit]->DMAreq = (struct DMAreq *) ((int)DMAheader[unit] 3310 + sizeof(struct DMAreq_header)); 3311 DMAheader[unit]->QBAreg = 0; 3312 DMAheader[unit]->status = 0; 3313 DMAheader[unit]->shared_size = DMAbuf_size; 3314 DMAheader[unit]->used = 0; 3315 DMAheader[unit]->size = 10; /* default = 10 requests */ 3316 DMAheader[unit]->oldest = 0; 3317 DMAheader[unit]->newest = 0; 3318 /* 3319 * assign a pointer to the scroll structure for this QDSS. 3320 */ 3321 scroll[unit] = (struct scroll *) 3322 (((int)(&scroll_shared[0] + 512) & ~0x1FF) 3323 + (sizeof(struct scroll) * unit)); 3324 scroll[unit]->status = 0; 3325 scroll[unit]->viper_constant = 0; 3326 scroll[unit]->y_scroll_constant = 0; 3327 scroll[unit]->y_offset = 0; 3328 scroll[unit]->x_index_pending = 0; 3329 scroll[unit]->y_index_pending = 0; 3330 /* 3331 * assign a pointer to the color map write buffer for this QDSS 3332 */ 3333 color_buf[unit] = (struct color_buf *) 3334 (((int)(&color_shared[0] + 512) & ~0x1FF) 3335 + (COLOR_BUFSIZ * unit)); 3336 color_buf[unit]->status = 0; 3337 color_buf[unit]->count = 0; 3338 3339 } /* init_shared */ 3340 3341 /* 3342 * init the ADDER, VIPER, bitmaps, & color map 3343 */ 3344 void 3345 setup_dragon(int unit) 3346 { 3347 3348 volatile struct adder *adder; 3349 volatile struct dga *dga; 3350 volatile short *memcsr; 3351 int i; 3352 short top; /* clipping/scrolling boundaries */ 3353 short bottom; 3354 short right; 3355 short left; 3356 volatile short *red; /* color map pointers */ 3357 volatile short *green; 3358 volatile short *blue; 3359 3360 /* 3361 * init for setup 3362 */ 3363 adder = (struct adder *) qdmap[unit].adder; 3364 dga = (struct dga *) qdmap[unit].dga; 3365 memcsr = (short *) qdmap[unit].memcsr; 3366 dga->csr &= ~(DMA_IE | 0x700); /* halt DMA and kill the intrpts */ 3367 *memcsr = SYNC_ON; /* blank screen and turn off LED's */ 3368 adder->command = CANCEL; 3369 /* 3370 * set monitor timing 3371 */ 3372 adder->x_scan_count_0 = 0x2800; 3373 adder->x_scan_count_1 = 0x1020; 3374 adder->x_scan_count_2 = 0x003A; 3375 adder->x_scan_count_3 = 0x38F0; 3376 adder->x_scan_count_4 = 0x6128; 3377 adder->x_scan_count_5 = 0x093A; 3378 adder->x_scan_count_6 = 0x313C; 3379 adder->sync_phase_adj = 0x0100; 3380 adder->x_scan_conf = 0x00C8; 3381 /* 3382 * got a bug in secound pass ADDER! lets take care of it 3383 * 3384 * normally, just use the code in the following bug fix code, but to 3385 * make repeated demos look pretty, load the registers as if there was 3386 * no bug and then test to see if we are getting sync 3387 */ 3388 adder->y_scan_count_0 = 0x135F; 3389 adder->y_scan_count_1 = 0x3363; 3390 adder->y_scan_count_2 = 0x2366; 3391 adder->y_scan_count_3 = 0x0388; 3392 /* 3393 * if no sync, do the bug fix code 3394 */ 3395 if (wait_status(adder, VSYNC) == BAD) { 3396 /* first load all Y scan registers with very short frame and 3397 * wait for scroll service. This guarantees at least one SYNC 3398 * to fix the pass 2 Adder initialization bug (synchronizes 3399 * XCINCH with DMSEEDH) 3400 */ 3401 adder->y_scan_count_0 = 0x01; 3402 adder->y_scan_count_1 = 0x01; 3403 adder->y_scan_count_2 = 0x01; 3404 adder->y_scan_count_3 = 0x01; 3405 /* 3406 * delay at least 1 full frame time 3407 */ 3408 (void)wait_status(adder, VSYNC); 3409 (void)wait_status(adder, VSYNC); 3410 /* 3411 * now load the REAL sync values (in reverse order just to 3412 * be safe. 3413 */ 3414 adder->y_scan_count_3 = 0x0388; 3415 adder->y_scan_count_2 = 0x2366; 3416 adder->y_scan_count_1 = 0x3363; 3417 adder->y_scan_count_0 = 0x135F; 3418 } 3419 *memcsr = SYNC_ON | UNBLANK; /* turn off leds and turn on video */ 3420 /* 3421 * zero the index registers 3422 */ 3423 adder->x_index_pending = 0; 3424 adder->y_index_pending = 0; 3425 adder->x_index_new = 0; 3426 adder->y_index_new = 0; 3427 adder->x_index_old = 0; 3428 adder->y_index_old = 0; 3429 adder->pause = 0; 3430 /* 3431 * set rasterop mode to normal pen down 3432 */ 3433 adder->rasterop_mode = DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL; 3434 /* 3435 * set the rasterop registers to a default values 3436 */ 3437 adder->source_1_dx = 1; 3438 adder->source_1_dy = 1; 3439 adder->source_1_x = 0; 3440 adder->source_1_y = 0; 3441 adder->destination_x = 0; 3442 adder->destination_y = 0; 3443 adder->fast_dest_dx = 1; 3444 adder->fast_dest_dy = 0; 3445 adder->slow_dest_dx = 0; 3446 adder->slow_dest_dy = 1; 3447 adder->error_1 = 0; 3448 adder->error_2 = 0; 3449 /* 3450 * scale factor = UNITY 3451 */ 3452 adder->fast_scale = UNITY; 3453 adder->slow_scale = UNITY; 3454 /* 3455 * set the source 2 parameters 3456 */ 3457 adder->source_2_x = 0; 3458 adder->source_2_y = 0; 3459 adder->source_2_size = 0x0022; 3460 /* 3461 * initialize plane addresses for eight vipers 3462 */ 3463 write_ID(adder, CS_UPDATE_MASK, 0x0001); 3464 write_ID(adder, PLANE_ADDRESS, 0x0000); 3465 write_ID(adder, CS_UPDATE_MASK, 0x0002); 3466 write_ID(adder, PLANE_ADDRESS, 0x0001); 3467 write_ID(adder, CS_UPDATE_MASK, 0x0004); 3468 write_ID(adder, PLANE_ADDRESS, 0x0002); 3469 write_ID(adder, CS_UPDATE_MASK, 0x0008); 3470 write_ID(adder, PLANE_ADDRESS, 0x0003); 3471 write_ID(adder, CS_UPDATE_MASK, 0x0010); 3472 write_ID(adder, PLANE_ADDRESS, 0x0004); 3473 write_ID(adder, CS_UPDATE_MASK, 0x0020); 3474 write_ID(adder, PLANE_ADDRESS, 0x0005); 3475 write_ID(adder, CS_UPDATE_MASK, 0x0040); 3476 write_ID(adder, PLANE_ADDRESS, 0x0006); 3477 write_ID(adder, CS_UPDATE_MASK, 0x0080); 3478 write_ID(adder, PLANE_ADDRESS, 0x0007); 3479 /* 3480 * initialize the external registers. 3481 */ 3482 write_ID(adder, CS_UPDATE_MASK, 0x00FF); 3483 write_ID(adder, CS_SCROLL_MASK, 0x00FF); 3484 /* 3485 * initialize resolution mode 3486 */ 3487 write_ID(adder, MEMORY_BUS_WIDTH, 0x000C); /* bus width = 16 */ 3488 write_ID(adder, RESOLUTION_MODE, 0x0000); /* one bit/pixel */ 3489 /* 3490 * initialize viper registers 3491 */ 3492 write_ID(adder, SCROLL_CONSTANT, SCROLL_ENABLE|VIPER_LEFT|VIPER_UP); 3493 write_ID(adder, SCROLL_FILL, 0x0000); 3494 /* 3495 * set clipping and scrolling limits to full screen 3496 */ 3497 for (i = 1000, adder->status = 0; 3498 i > 0 && !(adder->status&ADDRESS_COMPLETE); --i) 3499 ; 3500 if (i == 0) 3501 printf("qd%d: setup_dragon: timeout on ADDRESS_COMPLETE\n",unit); 3502 top = 0; 3503 bottom = 2048; 3504 left = 0; 3505 right = 1024; 3506 adder->x_clip_min = left; 3507 adder->x_clip_max = right; 3508 adder->y_clip_min = top; 3509 adder->y_clip_max = bottom; 3510 adder->scroll_x_min = left; 3511 adder->scroll_x_max = right; 3512 adder->scroll_y_min = top; 3513 adder->scroll_y_max = bottom; 3514 (void)wait_status(adder, VSYNC); /* wait at LEAST 1 full frame */ 3515 (void)wait_status(adder, VSYNC); 3516 adder->x_index_pending = left; 3517 adder->y_index_pending = top; 3518 adder->x_index_new = left; 3519 adder->y_index_new = top; 3520 adder->x_index_old = left; 3521 adder->y_index_old = top; 3522 3523 for (i = 1000, adder->status = 0; i > 0 && 3524 !(adder->status&ADDRESS_COMPLETE) ; --i) 3525 ; 3526 if (i == 0) 3527 printf("qd%d: setup_dragon: timeout on ADDRESS_COMPLETE\n",unit); 3528 3529 write_ID(adder, LEFT_SCROLL_MASK, 0x0000); 3530 write_ID(adder, RIGHT_SCROLL_MASK, 0x0000); 3531 /* 3532 * set source and the mask register to all ones (ie: white) o 3533 */ 3534 write_ID(adder, SOURCE, 0xFFFF); 3535 write_ID(adder, MASK_1, 0xFFFF); 3536 write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255); 3537 write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0); 3538 /* 3539 * initialize Operand Control Register banks for fill command 3540 */ 3541 write_ID(adder, SRC1_OCR_A, EXT_NONE | INT_M1_M2 | NO_ID | WAIT); 3542 write_ID(adder, SRC2_OCR_A, EXT_NONE | INT_SOURCE | NO_ID | NO_WAIT); 3543 write_ID(adder, DST_OCR_A, EXT_NONE | INT_NONE | NO_ID | NO_WAIT); 3544 write_ID(adder, SRC1_OCR_B, EXT_NONE | INT_SOURCE | NO_ID | WAIT); 3545 write_ID(adder, SRC2_OCR_B, EXT_NONE | INT_M1_M2 | NO_ID | NO_WAIT); 3546 write_ID(adder, DST_OCR_B, EXT_NONE | INT_NONE | NO_ID | NO_WAIT); 3547 /* 3548 * init Logic Unit Function registers, (these are just common values, 3549 * and may be changed as required). 3550 */ 3551 write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE); 3552 write_ID(adder, LU_FUNCTION_R2, FULL_SRC_RESOLUTION | LF_SOURCE | 3553 INV_M1_M2); 3554 write_ID(adder, LU_FUNCTION_R3, FULL_SRC_RESOLUTION | LF_D_OR_S); 3555 write_ID(adder, LU_FUNCTION_R4, FULL_SRC_RESOLUTION | LF_D_XOR_S); 3556 /* 3557 * load the color map for black & white 3558 */ 3559 for (i = 0, adder->status = 0; i < 10000 && !(adder->status&VSYNC); ++i) 3560 ; 3561 3562 if (i == 0) 3563 printf("qd%d: setup_dragon: timeout on VSYNC\n", unit); 3564 3565 red = (short *) qdmap[unit].red; 3566 green = (short *) qdmap[unit].green; 3567 blue = (short *) qdmap[unit].blue; 3568 3569 *red++ = 0x00; /* black */ 3570 *green++ = 0x00; 3571 *blue++ = 0x00; 3572 3573 *red-- = 0xFF; /* white */ 3574 *green-- = 0xFF; 3575 *blue-- = 0xFF; 3576 3577 /* 3578 * set color map for mouse cursor 3579 */ 3580 3581 red += 254; 3582 green += 254; 3583 blue += 254; 3584 3585 *red++ = 0x00; /* black */ 3586 *green++ = 0x00; 3587 *blue++ = 0x00; 3588 3589 *red = 0xFF; /* white */ 3590 *green = 0xFF; 3591 *blue = 0xFF; 3592 3593 } /* setup_dragon */ 3594 3595 /* 3596 * Init the DUART and set defaults in input 3597 */ 3598 void 3599 setup_input(int unit) 3600 { 3601 volatile struct duart *duart; /* DUART register structure pointer */ 3602 int i, bits; 3603 char id_byte; 3604 3605 duart = (struct duart *) qdmap[unit].duart; 3606 duart->imask = 0; 3607 3608 /* 3609 * setup the DUART for kbd & pointing device 3610 */ 3611 duart->cmdA = RESET_M; /* reset mode reg ptr for kbd */ 3612 duart->modeA = 0x13; /* 8 bits, no parity, rcv IE, */ 3613 /* no RTS control,char error mode */ 3614 duart->modeA = 0x07; /* 1 stop bit,CTS does not IE XMT */ 3615 /* no RTS control,no echo or loop */ 3616 duart->cmdB = RESET_M; /* reset mode reg pntr for host */ 3617 duart->modeB = 0x07; /* 8 bits, odd parity, rcv IE.. */ 3618 /* ..no RTS cntrl, char error mode */ 3619 duart->modeB = 0x07; /* 1 stop bit,CTS does not IE XMT */ 3620 /* no RTS control,no echo or loop */ 3621 duart->auxctl = 0x00; /* baud rate set 1 */ 3622 duart->clkselA = 0x99; /* 4800 baud for kbd */ 3623 duart->clkselB = 0x99; /* 4800 baud for mouse */ 3624 3625 /* reset everything for keyboard */ 3626 3627 for (bits = RESET_M; bits < START_BREAK; bits += 0x10) 3628 duart->cmdA = bits; 3629 3630 /* reset everything for host */ 3631 3632 for (bits = RESET_M; bits < START_BREAK; bits += 0x10) 3633 duart->cmdB = bits; 3634 3635 duart->cmdA = EN_RCV | EN_XMT; /* enbl xmt & rcv for kbd */ 3636 duart->cmdB = EN_RCV | EN_XMT; /* enbl xmt & rcv for pointer device */ 3637 3638 /* 3639 * init keyboard defaults (DUART channel A) 3640 */ 3641 for (i = 500; i > 0; --i) { 3642 if (duart->statusA&XMT_RDY) { 3643 duart->dataA = LK_DEFAULTS; 3644 break; 3645 } 3646 } 3647 3648 for (i = 100000; i > 0; --i) { 3649 if (duart->statusA&RCV_RDY) { 3650 break; 3651 } 3652 } 3653 3654 if (duart->dataA) /* flush the ACK */ 3655 ; 3656 3657 /* 3658 * identify the pointing device 3659 */ 3660 for (i = 500; i > 0; --i) { 3661 if (duart->statusB&XMT_RDY) { 3662 duart->dataB = SELF_TEST; 3663 break; 3664 } 3665 } 3666 3667 /* 3668 * wait for 1st byte of self test report */ 3669 3670 for (i = 100000; i > 0; --i) { 3671 if (duart->statusB&RCV_RDY) { 3672 break; 3673 } 3674 } 3675 3676 if (i == 0) { 3677 printf("qd[%d]: setup_input: timeout on 1st byte of self test\n" 3678 ,unit); 3679 goto OUT; 3680 } 3681 3682 if (duart->dataB) 3683 ; 3684 3685 /* 3686 * wait for ID byte of self test report 3687 */ 3688 for (i = 100000; i > 0; --i) { 3689 if (duart->statusB&RCV_RDY) { 3690 break; 3691 } 3692 } 3693 3694 if (i == 0) { 3695 printf("qd[%d]: setup_input: timeout on 2nd byte of self test\n", unit); 3696 goto OUT; 3697 } 3698 3699 id_byte = duart->dataB; 3700 3701 /* 3702 * wait for other bytes to come in 3703 */ 3704 for (i = 100000; i > 0; --i) { 3705 if (duart->statusB & RCV_RDY) { 3706 if (duart->dataB) 3707 ; 3708 break; 3709 } 3710 } 3711 if (i == 0) { 3712 printf("qd[%d]: setup_input: timeout on 3rd byte of self test\n", unit); 3713 goto OUT; 3714 } 3715 for (i = 100000; i > 0; --i) { 3716 if (duart->statusB&RCV_RDY) { 3717 if (duart->dataB) 3718 ; 3719 break; 3720 } 3721 } 3722 if (i == 0) { 3723 printf("qd[%d]: setup_input: timeout on 4th byte of self test\n", unit); 3724 goto OUT; 3725 } 3726 /* 3727 * flag pointing device type and set defaults 3728 */ 3729 for (i=100000; i>0; --i) 3730 ; /*XXX*/ 3731 3732 if ((id_byte & 0x0F) != TABLET_ID) { 3733 qdflags[unit].pntr_id = MOUSE_ID; 3734 3735 for (i = 500; i > 0; --i) { 3736 if (duart->statusB&XMT_RDY) { 3737 duart->dataB = INC_STREAM_MODE; 3738 break; 3739 } 3740 } 3741 } 3742 else { 3743 qdflags[unit].pntr_id = TABLET_ID; 3744 3745 for (i = 500; i > 0; --i) { 3746 if (duart->statusB&XMT_RDY) { 3747 duart->dataB = T_STREAM; 3748 break; 3749 } 3750 } 3751 } 3752 OUT: 3753 duart->imask = qdflags[unit].duart_imask; 3754 3755 } /* setup_input */ 3756 3757 /* 3758 * delay for at least one display frame time 3759 * 3760 * return: BAD means that we timed out without ever seeing the 3761 * vertical sync status bit 3762 * GOOD otherwise 3763 */ 3764 int 3765 wait_status(volatile struct adder *adder, int mask) 3766 { 3767 int i; 3768 3769 for (i = 10000, adder->status = 0 ; i > 0 && 3770 !(adder->status&mask) ; --i) 3771 ; 3772 3773 if (i == 0) { 3774 printf("wait_status: timeout polling for 0x%x in adder->status\n", mask); 3775 return(BAD); 3776 } 3777 3778 return(GOOD); 3779 3780 } /* wait_status */ 3781 3782 /* 3783 * write out onto the ID bus 3784 */ 3785 void 3786 write_ID(volatile struct adder *adder, short adrs, short data) 3787 { 3788 int i; 3789 3790 for (i = 100000, adder->status = 0 ; 3791 i > 0 && !(adder->status&ADDRESS_COMPLETE) ; --i) 3792 ; 3793 3794 if (i == 0) 3795 goto ERR; 3796 3797 for (i = 100000, adder->status = 0 ; 3798 i > 0 && !(adder->status&TX_READY) ; --i) 3799 ; 3800 3801 if (i > 0) { 3802 adder->id_data = data; 3803 adder->command = ID_LOAD | adrs; 3804 return ; 3805 } 3806 3807 ERR: 3808 printf("write_ID: timeout trying to write to VIPER\n"); 3809 return ; 3810 3811 } /* write_ID */ 3812
Indexes created Mon Sep 29 21:09:56 GMT 2025