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