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