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