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