![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to qdcons.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxstand|
Return to qdcons.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxstand |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)qdcons.c 1.3 Berkeley 6/29/88
7: *
8: * derived from: @(#)qdcons.c 4.1 (ULTRIX 11/23/87
9: */
10:
11: /************************************************************************
12: *
13: * ULTRIX QDSS STANDALONE BOOT DEVICE DRIVER...
14: * device driver to boot system with QDSS as console
15: *
16: *************************************************************************/
17: /************************************************************************
18: * *
19: * Copyright (c) 1985 by *
20: * Digital Equipment Corporation, Maynard, MA *
21: * All rights reserved. *
22: * *
23: * This software is furnished under a license and may be used and *
24: * copied only in accordance with the terms of such license and *
25: * with the inclusion of the above copyright notice. This *
26: * software or any other copies thereof may not be provided or *
27: * otherwise made available to any other person. No title to and *
28: * ownership of the software is hereby transferred. *
29: * *
30: * The information in this software is subject to change without *
31: * notice and should not be construed as a commitment by Digital *
32: * Equipment Corporation. *
33: * *
34: * Digital assumes no responsibility for the use or reliability *
35: * of its software on equipment which is not supplied by Digital. *
36: * *
37: *************************************************************************
38: * revision history: (should be moved into sccs comments)
39: *************************************************************************
40: *
41: * 09 oct 85 longo added uVAXII console ROM cursor reset to bottom of
42: * the screen. Also spruced up qdputc() & scroll_up()
43: * 02 oct 85 longo changed references to ADDRESS to be ADDRESS_COMPLETE
44: * 23 aug 85 longo changed I/O page CSR address to be 0x1F00
45: * 20 aug 85 longo created
46: *
47: ************************************************************************/
48:
49: #include "../h/types.h"
50: #include "../vax/cpu.h"
51: #define KERNEL
52: #include "../vaxuba/qdioctl.h"
53: #include "../vaxuba/qevent.h"
54: #include "../vaxuba/qduser.h"
55: #include "../vaxuba/qdreg.h"
56: #undef KERNEL
57:
58: /*-----------------------------------------------------------------------
59: * constants used to set VAX ROM's cursor to bottom the of the screen */
60:
61: #define NVR_ADRS 0x200B8024
62:
63: #define CURRENT_ROW 0x4C /* these are offsets to the ROM's scratch.. */
64: #define ROW_MIN 0x4D /* ..RAM start adrs as picked up out of NVR */
65: #define ROW_MAX 0x4E
66: #define CURRENT_COL 0x50
67: #define COL_MIN 0x51
68: #define COL_MAX 0x52
69:
70: /*----------------------------------------
71: * LK201 keyboard state tracking struct */
72:
73: struct q_keyboard {
74:
75: int shift; /* state variables */
76: int cntrl;
77: int lock;
78: char last; /* last character */
79:
80: } q_keyboard;
81:
82: int qdputc(), qdgetc();
83:
84: extern (*v_putc)(),(*v_getc)();
85:
86: /*----------------------------
87: * general purpose defines */
88:
89: #define BAD -1
90: #define GOOD 0
91:
92: /*----------------------------------------------
93: * console cursor bitmap (block cursor type) */
94:
95: short cons_cursor[32] = { /* white block cursor */
96:
97: /* A */ 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
98: 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
99: /* B */ 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF,
100: 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF, 0x00FF
101:
102: };
103:
104: /*-------------------------------------
105: * constants used in font operations */
106:
107: #define CHARS 95 /* # of chars in the font */
108: #define CHAR_HEIGHT 15 /* char height in pixels */
109: #define CHAR_WIDTH 8 /* char width in pixels*/
110: #define FONT_WIDTH (CHAR_WIDTH * CHARS) /* font width in pixels */
111: #define ROWS CHAR_HEIGHT
112:
113: #define FONT_X 0 /* font's off screen adrs */
114: #define FONT_Y (2047 - CHAR_HEIGHT)
115: /*
116: #define FONT_Y 200
117: */
118:
119: extern char q_font[]; /* reference font object code */
120:
121: extern char q_key[]; /* reference key xlation tables */
122: extern char q_shift_key[];
123: extern char *q_special[];
124:
125: /*----------------------------
126: * console cursor structure */
127:
128: struct cons_cur {
129: int x;
130: int y;
131: } cursor;
132:
133: /*------------------------------------------
134: * MicroVAX-II q-bus addressing constants */
135:
136: #define QMEMBASE 0x30000000
137: #define QDSSCSR 0x20001F00
138:
139: #define CHUNK (64 * 1024)
140: #define QMEMSIZE (1024 * 1024 * 4)
141: #define QDBASE (QMEMBASE + QMEMSIZE - CHUNK)
142:
143: /*------------------------------------------------------------------
144: * QDSS register address offsets from start of QDSS address space */
145:
146: #define QDSIZE (52 * 1024) /* size of entire QDSS foot print */
147:
148: #define TMPSIZE (16 * 1024) /* template RAM is 8k SHORT WORDS */
149: #define TMPSTART 0x8000 /* offset of template RAM from base adrs */
150:
151: #define REGSIZE (5 * 512) /* regs touch 2.5k (5 pages) of addr space */
152: #define REGSTART 0xC000 /* offset of reg pages from base adrs */
153:
154: #define ADDER (REGSTART+0x000)
155: #define DGA (REGSTART+0x200)
156: #define DUART (REGSTART+0x400)
157: #define MEMCSR (REGSTART+0x800)
158:
159: #define CLRSIZE (3 * 512) /* color map size */
160: #define CLRSTART (REGSTART+0xA00) /* color map start offset from base */
161: /* 0x0C00 really */
162: #define RED (CLRSTART+0x000)
163: #define BLUE (CLRSTART+0x200)
164: #define GREEN (CLRSTART+0x400)
165:
166: /*---------------------------------------
167: * QDSS register address map structure */
168:
169: struct qdmap qdmap;
170:
171: /************************************************************************
172: *************************************************************************
173: *************************************************************************
174: *
175: * EXTERNALLY CALLED ROUTINES START HERE:
176: *
177: *************************************************************************
178: *************************************************************************
179: ************************************************************************/
180:
181: /************************************************************************
182: *
183: * qd_init()... init the QDSS into a physical memory system
184: *
185: ************************************************************************/
186:
187: qd_init()
188: {
189: register char *ROM_console;
190: register short *NVR;
191: register int i;
192:
193: caddr_t qdaddr;
194: struct dga *dga;
195:
196: qdaddr = (caddr_t) QDSSCSR;
197: if (badaddr(qdaddr, sizeof(short)))
198: return(0);
199:
200: *(short *)qdaddr = (short) (QDBASE >> 16);
201:
202: /*----------------------------------------------------------------------
203: * load qdmap struct with the physical addresses of the QDSS elements */
204:
205: qdmap.template = (caddr_t) QDBASE + TMPSTART;
206: qdmap.adder = (caddr_t) QDBASE + ADDER;
207: qdmap.dga = (caddr_t) QDBASE + DGA;
208: qdmap.duart = (caddr_t) QDBASE + DUART;
209: qdmap.memcsr = (caddr_t) QDBASE + MEMCSR;
210: qdmap.red = (caddr_t) QDBASE + RED;
211: qdmap.blue = (caddr_t) QDBASE + BLUE;
212: qdmap.green = (caddr_t) QDBASE + GREEN;
213:
214: /*--------------------------
215: * no interrupts allowed! */
216:
217: dga = (struct dga *) qdmap.dga;
218: dga->csr = HALT;
219: dga->csr |= CURS_ENB;
220:
221: /*----------------------------
222: * init the default values */
223:
224: q_keyboard.shift = 0; /* init keyboard state tracking */
225: q_keyboard.lock = 0;
226: q_keyboard.cntrl = 0;
227: q_keyboard.last = 0;
228:
229: cursor.x = 0; /* init cursor to top left */
230: cursor.y = 0;
231:
232: set_defaults(); /* setup the default device */
233: ldfont(); /* PtoB the font into off-screen */
234:
235: /*--------------------------------------------------------------------
236: * tell the VAX ROM that the cursor is at the bottom of the screen */
237:
238: NVR = (short *) NVR_ADRS;
239:
240: i = *NVR++ & 0xFF;
241: i |= (*NVR++ & 0xFF) << 8;
242: i |= (*NVR++ & 0xFF) << 16;
243: i |= (*NVR++ & 0xFF) << 24;
244:
245: ROM_console = (char *) i;
246:
247: ROM_console[CURRENT_COL] = ROM_console[COL_MIN];
248: ROM_console[CURRENT_ROW] = ROM_console[ROW_MAX];
249:
250: /*----------------------------------------------------------
251: * smash system virtual console service routine addresses */
252:
253: v_getc = qdgetc;
254: v_putc = qdputc;
255:
256: return(1);
257:
258: } /* qd_init */
259:
260: /*******************************************************************
261: *
262: * qdputc()... output a character to the QDSS screen
263: *
264: ********************************************************************
265: *
266: * calling convention:
267: *
268: * qdputc(chr);
269: * char chr; ;character to be displayed
270: *
271: ********/
272:
273: qdputc(chr)
274: char chr;
275: {
276: register struct adder *adder;
277: register struct dga *dga;
278: register int i;
279:
280: short x;
281:
282: adder = (struct adder *) qdmap.adder;
283: dga = (struct dga *) qdmap.dga;
284:
285: /*---------------------------
286: * non display character? */
287:
288: chr &= 0x7F;
289:
290: switch (chr) {
291:
292: case '\r': /* return char */
293: cursor.x = 0;
294: dga->x_cursor = TRANX(cursor.x);
295: return(0);
296:
297: case '\t': /* tab char */
298:
299: for (i = 8 - ((cursor.x >> 3) & 0x07); i > 0; --i) {
300: qdputc(' ');
301: }
302: return(0);
303:
304: case '\n': /* line feed char */
305:
306: if ((cursor.y += CHAR_HEIGHT) > (863 - CHAR_HEIGHT)) {
307: cursor.y -= CHAR_HEIGHT;
308: scroll_up(adder);
309: }
310: dga->y_cursor = TRANY(cursor.y);
311: return(0);
312:
313: case '\b': /* backspace char */
314: if (cursor.x > 0) {
315: cursor.x -= CHAR_WIDTH;
316: qdputc(' ');
317: cursor.x -= CHAR_WIDTH;
318: dga->x_cursor = TRANX(cursor.x);
319: }
320: return(0);
321:
322: default:
323: if (chr < ' ' || chr > '~') {
324: return(0);
325: }
326: }
327:
328: /*------------------------------------------
329: * setup VIPER operand control registers */
330:
331: write_ID(adder, CS_UPDATE_MASK, 0x0001); /* select plane #0 */
332: write_ID(adder, SRC1_OCR_B,
333: EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
334:
335: write_ID(adder, CS_UPDATE_MASK, 0x00FE); /* select other planes */
336: write_ID(adder, SRC1_OCR_B,
337: EXT_SOURCE | INT_NONE | NO_ID | BAR_SHIFT_DELAY);
338:
339: write_ID(adder, CS_UPDATE_MASK, 0x00FF); /* select all planes */
340: write_ID(adder, DST_OCR_B,
341: EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
342:
343: write_ID(adder, MASK_1, 0xFFFF);
344: write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 1);
345: write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
346:
347: /*----------------------------------------
348: * load DESTINATION origin and vectors */
349:
350: adder->fast_dest_dy = 0;
351: adder->slow_dest_dx = 0;
352: adder->error_1 = 0;
353: adder->error_2 = 0;
354:
355: adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
356:
357: wait_status(adder, RASTEROP_COMPLETE);
358:
359: adder->destination_x = cursor.x;
360: adder->fast_dest_dx = CHAR_WIDTH;
361:
362: adder->destination_y = cursor.y;
363: adder->slow_dest_dy = CHAR_HEIGHT;
364:
365: /*-----------------------------------
366: * load SOURCE origin and vectors */
367:
368: adder->source_1_x = FONT_X + ((chr - ' ') * CHAR_WIDTH);
369: adder->source_1_y = FONT_Y;
370:
371: adder->source_1_dx = CHAR_WIDTH;
372: adder->source_1_dy = CHAR_HEIGHT;
373:
374: write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
375: adder->cmd = RASTEROP | OCRB | 0 | S1E | DTE;
376:
377: /*-------------------------------------
378: * update console cursor coordinates */
379:
380: cursor.x += CHAR_WIDTH;
381: dga->x_cursor = TRANX(cursor.x);
382:
383: if (cursor.x > (1024 - CHAR_WIDTH)) {
384: qdputc('\r');
385: qdputc('\n');
386: }
387:
388: } /* qdputc */
389:
390: /*******************************************************************
391: *
392: * qdgetc()... get a character from the LK201
393: *
394: *******************************************************************/
395:
396: qdgetc()
397: {
398: register short key;
399: register char chr;
400: register struct duart *duart;
401:
402: u_int status;
403:
404: duart = (struct duart *) qdmap.duart;
405:
406: /*--------------------------------------
407: * Get a character from the keyboard. */
408:
409: LOOP:
410: while (!((status = duart->statusA) & RCV_RDY))
411: ;
412:
413: key = duart->dataA;
414: key &= 0xFF;
415:
416: /*--------------------------------------
417: * Check for various keyboard errors */
418:
419: if( key == LK_POWER_ERROR || key == LK_KDOWN_ERROR ||
420: key == LK_INPUT_ERROR || key == LK_OUTPUT_ERROR) {
421: printf("Keyboard error, code = %x\n", key);
422: return(0);
423: }
424:
425: if (key < LK_LOWEST)
426: return(0);
427:
428: /*---------------------------------
429: * See if its a state change key */
430:
431: switch (key) {
432:
433: case LOCK:
434: q_keyboard.lock ^= 0xffff; /* toggle */
435: if (q_keyboard.lock)
436: led_control(LK_LED_ENABLE, LK_LED_LOCK);
437: else
438: led_control(LK_LED_DISABLE, LK_LED_LOCK);
439: goto LOOP;
440:
441: case SHIFT:
442: q_keyboard.shift ^= 0xFFFF;
443: goto LOOP;
444:
445: case CNTRL:
446: q_keyboard.cntrl ^= 0xFFFF;
447: goto LOOP;
448:
449: case ALLUP:
450: q_keyboard.cntrl = 0;
451: q_keyboard.shift = 0;
452: goto LOOP;
453:
454: case REPEAT:
455: chr = q_keyboard.last;
456: break;
457:
458: /*-------------------------------------------------------
459: * Test for cntrl characters. If set, see if the character
460: * is elligible to become a control character. */
461:
462: default:
463:
464: if (q_keyboard.cntrl) {
465: chr = q_key[key];
466: if (chr >= ' ' && chr <= '~')
467: chr &= 0x1F;
468: }
469: else if ( q_keyboard.lock || q_keyboard.shift )
470: chr = q_shift_key[key];
471: else
472: chr = q_key[key];
473: break;
474: }
475:
476: if (chr < ' ' && chr > '~') /* if input is non-displayable */
477: return(0); /* ..then pitch it! */
478:
479: q_keyboard.last = chr;
480:
481: /*-----------------------------------
482: * Check for special function keys */
483:
484: if (chr & 0x80) /* pitch the function keys */
485: return(0);
486: else
487: return(chr);
488:
489: } /* qdgetc */
490:
491: /************************************************************************
492: *************************************************************************
493: *************************************************************************
494: *
495: * INTERNALLY USED ROUTINES START HERE:
496: *
497: *************************************************************************
498: *************************************************************************
499: ************************************************************************/
500:
501: /********************************************************************
502: *
503: * ldcursor()... load the mouse cursor's template RAM bitmap
504: *
505: ********************************************************************/
506:
507: ldcursor()
508: {
509: register struct dga *dga;
510: register short *temp;
511: register int i;
512:
513: int cursor;
514:
515: dga = (struct dga *) qdmap.dga;
516: temp = (short *) qdmap.template;
517:
518: temp += (8 * 1024) - 32; /* cursor is 32 WORDS from the end */
519: /* ..of the 8k WORD template space */
520: for (i = 0; i < 32; ++i)
521: *temp++ = cons_cursor[i];
522:
523: return(0);
524:
525: } /* ldcursor */
526:
527: /**********************************************************************
528: *
529: * ldfont()... put the console font in the QDSS off-screen memory
530: *
531: **********************************************************************/
532:
533: ldfont()
534: {
535: register struct adder *adder;
536:
537: int i; /* scratch variables */
538: int j;
539: int k;
540: short packed;
541:
542: adder = (struct adder *) qdmap.adder;
543:
544: /*------------------------------------------
545: * setup VIPER operand control registers */
546:
547: write_ID(adder, MASK_1, 0xFFFF);
548: write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
549: write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
550:
551: write_ID(adder, SRC1_OCR_B,
552: EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
553: write_ID(adder, SRC2_OCR_B,
554: EXT_NONE | INT_NONE | ID | BAR_SHIFT_DELAY);
555: write_ID(adder, DST_OCR_B,
556: EXT_SOURCE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
557:
558: adder->rasterop_mode = DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL;
559:
560: /*--------------------------
561: * load destination data */
562:
563: wait_status(adder, RASTEROP_COMPLETE);
564:
565: adder->destination_x = FONT_X;
566: adder->destination_y = FONT_Y;
567: adder->fast_dest_dx = FONT_WIDTH;
568: adder->slow_dest_dy = CHAR_HEIGHT;
569:
570: /*---------------------------------------
571: * setup for processor to bitmap xfer */
572:
573: write_ID(adder, CS_UPDATE_MASK, 0x0001);
574: adder->cmd = PBT | OCRB | 2 | DTE | 2;
575:
576: /*-----------------------------------------------
577: * iteratively do the processor to bitmap xfer */
578:
579: for (i = 0; i < ROWS; ++i) {
580:
581: /* PTOB a scan line */
582:
583: for (j = 0, k = i; j < 48; ++j) {
584:
585: /* PTOB one scan of a char cell */
586:
587: packed = q_font[k];
588: k += ROWS;
589: packed |= ((short)q_font[k] << 8);
590: k += ROWS;
591:
592: wait_status(adder, TX_READY);
593: adder->id_data = packed;
594: }
595: }
596:
597: } /* ldfont */
598:
599: /*********************************************************************
600: *
601: * led_control()... twiddle LK-201 LED's
602: *
603: **********************************************************************
604: *
605: * led_control(cmd, led_mask);
606: * int cmd; LED enable/disable command
607: * int led_mask; which LED(s) to twiddle
608: *
609: *************/
610:
611: led_control(cmd, led_mask)
612: int cmd;
613: int led_mask;
614: {
615: register int i;
616: register int status;
617: register struct duart *duart;
618:
619: duart = (struct duart *) qdmap.duart;
620:
621: for (i = 1000; i > 0; --i) {
622: if ((status = duart->statusA) & XMT_RDY) {
623: duart->dataA = cmd;
624: break;
625: }
626: }
627:
628: for (i = 1000; i > 0; --i) {
629: if ((status = duart->statusA) & XMT_RDY) {
630: duart->dataA = led_mask;
631: break;
632: }
633: }
634:
635: if (i == 0)
636: return(BAD);
637:
638: return(GOOD);
639:
640: } /* led_control */
641:
642: /*******************************************************************
643: *
644: * scroll_up()... move the screen up one character height
645: *
646: ********************************************************************
647: *
648: * calling convention:
649: *
650: * scroll_up(adder);
651: * struct adder *adder; ;address of adder
652: *
653: ********/
654:
655: scroll_up(adder)
656: register struct adder *adder;
657: {
658:
659: /*------------------------------------------
660: * setup VIPER operand control registers */
661:
662: wait_status(adder, ADDRESS_COMPLETE);
663:
664: write_ID(adder, CS_UPDATE_MASK, 0x00FF); /* select all planes */
665:
666: write_ID(adder, MASK_1, 0xFFFF);
667: write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
668: write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
669:
670: write_ID(adder, SRC1_OCR_B,
671: EXT_NONE | INT_SOURCE | ID | BAR_SHIFT_DELAY);
672: write_ID(adder, DST_OCR_B,
673: EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY);
674:
675: /*----------------------------------------
676: * load DESTINATION origin and vectors */
677:
678: adder->fast_dest_dy = 0;
679: adder->slow_dest_dx = 0;
680: adder->error_1 = 0;
681: adder->error_2 = 0;
682:
683: adder->rasterop_mode = DST_WRITE_ENABLE | NORMAL;
684:
685: adder->destination_x = 0;
686: adder->fast_dest_dx = 1024;
687:
688: adder->destination_y = 0;
689: adder->slow_dest_dy = 864 - CHAR_HEIGHT;
690:
691: /*-----------------------------------
692: * load SOURCE origin and vectors */
693:
694: adder->source_1_x = 0;
695: adder->source_1_dx = 1024;
696:
697: adder->source_1_y = 0 + CHAR_HEIGHT;
698: adder->source_1_dy = 864 - CHAR_HEIGHT;
699:
700: write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
701: adder->cmd = RASTEROP | OCRB | 0 | S1E | DTE;
702:
703: /*--------------------------------------------
704: * do a rectangle clear of last screen line */
705:
706: write_ID(adder, MASK_1, 0xffff);
707: write_ID(adder, SOURCE, 0xffff);
708: write_ID(adder,DST_OCR_B,
709: (EXT_NONE | INT_NONE | NO_ID | NO_BAR_SHIFT_DELAY));
710: write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 0);
711: adder->error_1 = 0;
712: adder->error_2 = 0;
713: adder->slow_dest_dx = 0; /* set up the width of */
714: adder->slow_dest_dy = CHAR_HEIGHT; /* rectangle */
715:
716: adder->rasterop_mode = (NORMAL | DST_WRITE_ENABLE) ;
717: wait_status(adder, RASTEROP_COMPLETE);
718: adder->destination_x = 0;
719: adder->destination_y = 864 - CHAR_HEIGHT;
720:
721: adder->fast_dest_dx = 1024; /* set up the height */
722: adder->fast_dest_dy = 0; /* of rectangle */
723:
724: write_ID(adder, LU_FUNCTION_R2, (FULL_SRC_RESOLUTION | LF_SOURCE));
725: adder->cmd = (RASTEROP | OCRB | LF_R2 | DTE ) ;
726:
727: } /* scroll_up */
728:
729: /**********************************************************************
730: *
731: * set_defaults()... init the QDSS device and driver defaults
732: *
733: **********************************************************************/
734:
735: set_defaults()
736: {
737: setup_input(); /* init the DUART */
738: setup_dragon(); /* init the ADDER/VIPER stuff */
739: ldcursor(); /* load default cursor map */
740:
741: } /* set_defaults */
742:
743: /*********************************************************************
744: *
745: * setup_dragon()... init the ADDER, VIPER, bitmaps, & color map
746: *
747: *********************************************************************/
748:
749: setup_dragon()
750: {
751:
752: register struct adder *adder;
753: register struct dga *dga;
754: short *memcsr;
755:
756: int i; /* general purpose variables */
757: int status;
758:
759: short top; /* clipping/scrolling boundaries */
760: short bottom;
761: short right;
762: short left;
763:
764: short *red; /* color map pointers */
765: short *green;
766: short *blue;
767:
768: /*------------------
769: * init for setup */
770:
771: adder = (struct adder *) qdmap.adder;
772: dga = (struct dga *) qdmap.dga;
773: memcsr = (short *) qdmap.memcsr;
774:
775: *memcsr = SYNC_ON; /* blank screen and turn off LED's */
776: adder->command = CANCEL;
777:
778: /*----------------------
779: * set monitor timing */
780:
781: adder->x_scan_count_0 = 0x2800;
782: adder->x_scan_count_1 = 0x1020;
783: adder->x_scan_count_2 = 0x003A;
784: adder->x_scan_count_3 = 0x38F0;
785: adder->x_scan_count_4 = 0x6128;
786: adder->x_scan_count_5 = 0x093A;
787: adder->x_scan_count_6 = 0x313C;
788: adder->sync_phase_adj = 0x0100;
789: adder->x_scan_conf = 0x00C8;
790:
791: /*---------------------------------------------------------
792: * got a bug in secound pass ADDER! lets take care of it */
793:
794: /* normally, just use the code in the following bug fix code, but to
795: * make repeated demos look pretty, load the registers as if there was
796: * no bug and then test to see if we are getting sync */
797:
798: adder->y_scan_count_0 = 0x135F;
799: adder->y_scan_count_1 = 0x3363;
800: adder->y_scan_count_2 = 0x2366;
801: adder->y_scan_count_3 = 0x0388;
802:
803: /* if no sync, do the bug fix code */
804:
805: if (wait_status(adder, VSYNC) == BAD) {
806:
807: /* first load all Y scan registers with very short frame and
808: * wait for scroll service. This guarantees at least one SYNC
809: * to fix the pass 2 Adder initialization bug (synchronizes
810: * XCINCH with DMSEEDH) */
811:
812: adder->y_scan_count_0 = 0x01;
813: adder->y_scan_count_1 = 0x01;
814: adder->y_scan_count_2 = 0x01;
815: adder->y_scan_count_3 = 0x01;
816:
817: wait_status(adder, VSYNC); /* delay at least 1 full frame time */
818: wait_status(adder, VSYNC);
819:
820: /* now load the REAL sync values (in reverse order just to
821: * be safe. */
822:
823: adder->y_scan_count_3 = 0x0388;
824: adder->y_scan_count_2 = 0x2366;
825: adder->y_scan_count_1 = 0x3363;
826: adder->y_scan_count_0 = 0x135F;
827: }
828:
829: /*----------------------------
830: * zero the index registers */
831:
832: adder->x_index_pending = 0;
833: adder->y_index_pending = 0;
834: adder->x_index_new = 0;
835: adder->y_index_new = 0;
836: adder->x_index_old = 0;
837: adder->y_index_old = 0;
838:
839: adder->pause = 0;
840:
841: /*----------------------------------------
842: * set rasterop mode to normal pen down */
843:
844: adder->rasterop_mode = DST_WRITE_ENABLE | DST_INDEX_ENABLE | NORMAL;
845:
846: /*--------------------------------------------------
847: * set the rasterop registers to a default values */
848:
849: adder->source_1_dx = 1;
850: adder->source_1_dy = 1;
851: adder->source_1_x = 0;
852: adder->source_1_y = 0;
853: adder->destination_x = 0;
854: adder->destination_y = 0;
855: adder->fast_dest_dx = 1;
856: adder->fast_dest_dy = 0;
857: adder->slow_dest_dx = 0;
858: adder->slow_dest_dy = 1;
859: adder->error_1 = 0;
860: adder->error_2 = 0;
861:
862: /*------------------------
863: * scale factor = unity */
864:
865: adder->fast_scale = UNITY;
866: adder->slow_scale = UNITY;
867:
868: /*-------------------------------
869: * set the source 2 parameters */
870:
871: adder->source_2_x = 0;
872: adder->source_2_y = 0;
873: adder->source_2_size = 0x0022;
874:
875: /*-----------------------------------------------
876: * initialize plane addresses for eight vipers */
877:
878: write_ID(adder, CS_UPDATE_MASK, 0x0001);
879: write_ID(adder, PLANE_ADDRESS, 0x0000);
880:
881: write_ID(adder, CS_UPDATE_MASK, 0x0002);
882: write_ID(adder, PLANE_ADDRESS, 0x0001);
883:
884: write_ID(adder, CS_UPDATE_MASK, 0x0004);
885: write_ID(adder, PLANE_ADDRESS, 0x0002);
886:
887: write_ID(adder, CS_UPDATE_MASK, 0x0008);
888: write_ID(adder, PLANE_ADDRESS, 0x0003);
889:
890: write_ID(adder, CS_UPDATE_MASK, 0x0010);
891: write_ID(adder, PLANE_ADDRESS, 0x0004);
892:
893: write_ID(adder, CS_UPDATE_MASK, 0x0020);
894: write_ID(adder, PLANE_ADDRESS, 0x0005);
895:
896: write_ID(adder, CS_UPDATE_MASK, 0x0040);
897: write_ID(adder, PLANE_ADDRESS, 0x0006);
898:
899: write_ID(adder, CS_UPDATE_MASK, 0x0080);
900: write_ID(adder, PLANE_ADDRESS, 0x0007);
901:
902: /* initialize the external registers. */
903:
904: write_ID(adder, CS_UPDATE_MASK, 0x00FF);
905: write_ID(adder, CS_SCROLL_MASK, 0x00FF);
906:
907: /* initialize resolution mode */
908:
909: write_ID(adder, MEMORY_BUS_WIDTH, 0x000C); /* bus width = 16 */
910: write_ID(adder, RESOLUTION_MODE, 0x0000); /* one bit/pixel */
911:
912: /* initialize viper registers */
913:
914: write_ID(adder, SCROLL_CONSTANT, SCROLL_ENABLE|VIPER_LEFT|VIPER_UP);
915: write_ID(adder, SCROLL_FILL, 0x0000);
916:
917: /*----------------------------------------------------
918: * set clipping and scrolling limits to full screen */
919:
920: for ( i = 1000, adder->status = 0
921: ; i > 0 && !((status = adder->status) & ADDRESS_COMPLETE)
922: ; --i);
923:
924: if (i == 0)
925: printf("timeout trying to setup clipping\n");
926:
927: top = 0;
928: bottom = 2048;
929: left = 0;
930: right = 1024;
931:
932: adder->x_clip_min = left;
933: adder->x_clip_max = right;
934: adder->y_clip_min = top;
935: adder->y_clip_max = bottom;
936:
937: adder->scroll_x_min = left;
938: adder->scroll_x_max = right;
939: adder->scroll_y_min = top;
940: adder->scroll_y_max = bottom;
941:
942: wait_status(adder, VSYNC); /* wait at LEAST 1 full frame */
943: wait_status(adder, VSYNC);
944:
945: adder->x_index_pending = left;
946: adder->y_index_pending = top;
947: adder->x_index_new = left;
948: adder->y_index_new = top;
949: adder->x_index_old = left;
950: adder->y_index_old = top;
951:
952: for ( i = 1000, adder->status = 0
953: ; i > 0 && !((status = adder->status) & ADDRESS_COMPLETE)
954: ; --i);
955:
956: if (i == 0)
957: printf("timeout waiting for ADDRESS_COMPLETE bit\n");
958:
959: write_ID(adder, LEFT_SCROLL_MASK, 0x0000);
960: write_ID(adder, RIGHT_SCROLL_MASK, 0x0000);
961:
962: /*------------------------------------------------------------
963: * set source and the mask register to all ones (ie: white) */
964:
965: write_ID(adder, SOURCE, 0xFFFF);
966: write_ID(adder, MASK_1, 0xFFFF);
967: write_ID(adder, VIPER_Z_LOAD | FOREGROUND_COLOR_Z, 255);
968: write_ID(adder, VIPER_Z_LOAD | BACKGROUND_COLOR_Z, 0);
969:
970: /*--------------------------------------------------------------
971: * initialize Operand Control Register banks for fill command */
972:
973: write_ID(adder, SRC1_OCR_A, EXT_NONE | INT_M1_M2 | NO_ID | WAIT);
974: write_ID(adder, SRC2_OCR_A, EXT_NONE | INT_SOURCE | NO_ID | NO_WAIT);
975: write_ID(adder, DST_OCR_A, EXT_NONE | INT_NONE | NO_ID | NO_WAIT);
976:
977: write_ID(adder, SRC1_OCR_B, EXT_NONE | INT_SOURCE | NO_ID | WAIT);
978: write_ID(adder, SRC2_OCR_B, EXT_NONE | INT_M1_M2 | NO_ID | NO_WAIT);
979: write_ID(adder, DST_OCR_B, EXT_NONE | INT_NONE | NO_ID | NO_WAIT);
980:
981: /*------------------------------------------------------------------
982: * init Logic Unit Function registers, (these are just common values,
983: * and may be changed as required). */
984:
985: write_ID(adder, LU_FUNCTION_R1, FULL_SRC_RESOLUTION | LF_SOURCE);
986: write_ID(adder, LU_FUNCTION_R2, FULL_SRC_RESOLUTION | LF_SOURCE | INV_M1_M2);
987: write_ID(adder, LU_FUNCTION_R3, FULL_SRC_RESOLUTION | LF_D_OR_S);
988: write_ID(adder, LU_FUNCTION_R4, FULL_SRC_RESOLUTION | LF_D_XOR_S);
989:
990: /*----------------------------------------
991: * load the color map for black & white */
992:
993: for ( i = 0, adder->status = 0
994: ; i < 10000 && !((status = adder->status) & VSYNC)
995: ; ++i);
996:
997: if (i == 0)
998: printf("timeout waiting for VSYNC bit\n");
999:
1000: red = (short *) qdmap.red;
1001: green = (short *) qdmap.green;
1002: blue = (short *) qdmap.blue;
1003:
1004: *red++ = 0x00; /* black */
1005: *green++ = 0x00;
1006: *blue++ = 0x00;
1007:
1008: *red-- = 0xFF; /* white */
1009: *green-- = 0xFF;
1010: *blue-- = 0xFF;
1011:
1012: /*----------------------------------
1013: * set color map for mouse cursor */
1014:
1015: red += 254;
1016: green += 254;
1017: blue += 254;
1018:
1019: *red++ = 0x00; /* black */
1020: *green++ = 0x00;
1021: *blue++ = 0x00;
1022:
1023: *red = 0xFF; /* white */
1024: *green = 0xFF;
1025: *blue = 0xFF;
1026:
1027: /*---------------------------------------------------------------------------
1028: * clear the bitmap a piece at a time. Since the fast scroll clear only clears
1029: * the current displayed portion of the bitmap put a temporary value in the y
1030: * limit register so we can access whole bitmap */
1031:
1032: adder->x_limit = 1024;
1033: adder->y_limit = 2048 - CHAR_HEIGHT;
1034: adder->y_offset_pending = 0;
1035:
1036: wait_status(adder, VSYNC); /* wait at LEAST 1 full frame */
1037: wait_status(adder, VSYNC);
1038:
1039: adder->y_scroll_constant = SCROLL_ERASE;
1040:
1041: wait_status(adder, VSYNC);
1042: wait_status(adder, VSYNC);
1043:
1044: adder->y_offset_pending = 864;
1045:
1046: wait_status(adder, VSYNC);
1047: wait_status(adder, VSYNC);
1048:
1049: adder->y_scroll_constant = SCROLL_ERASE;
1050:
1051: wait_status(adder, VSYNC);
1052: wait_status(adder, VSYNC);
1053:
1054: adder->y_offset_pending = 1728;
1055:
1056: wait_status(adder, VSYNC);
1057: wait_status(adder, VSYNC);
1058:
1059: adder->y_scroll_constant = SCROLL_ERASE;
1060:
1061: wait_status(adder, VSYNC);
1062: wait_status(adder, VSYNC);
1063:
1064: adder->y_offset_pending = 0; /* back to normal */
1065:
1066: wait_status(adder, VSYNC);
1067: wait_status(adder, VSYNC);
1068:
1069: adder->x_limit = MAX_SCREEN_X;
1070: adder->y_limit = MAX_SCREEN_Y + FONT_HEIGHT;
1071:
1072: *memcsr = SYNC_ON | UNBLANK; /* turn off leds and turn on video */
1073: return(0);
1074:
1075: } /* setup_dragon */
1076:
1077: /******************************************************************
1078: *
1079: * setup_input()... init the DUART and set defaults in input
1080: * devices
1081: *
1082: ******************************************************************/
1083:
1084: setup_input()
1085: {
1086: register struct duart *duart; /* DUART register structure pointer */
1087: register int bits;
1088: int i, j; /* scratch variables */
1089:
1090: short status;
1091:
1092: /*---------------
1093: * init stuff */
1094:
1095: duart = (struct duart *) qdmap.duart;
1096:
1097: /*---------------------------------------------
1098: * setup the DUART for kbd & pointing device */
1099:
1100: duart->cmdA = RESET_M; /* reset mode reg ptr for kbd */
1101: duart->modeA = 0x13; /* 8 bits, no parity, rcv IE, */
1102: /* no RTS control,char error mode */
1103: duart->modeA = 0x07; /* 1 stop bit,CTS does not IE XMT */
1104: /* no RTS control,no echo or loop */
1105: duart->auxctl = 0x00; /* baud rate set 1 */
1106:
1107: duart->clkselA = 0x99; /* 4800 baud for kbd */
1108:
1109: /* reset everything for keyboard */
1110:
1111: for (bits = RESET_M; bits < START_BREAK; bits += 0x10)
1112: duart->cmdA = bits;
1113:
1114: duart->cmdA = EN_RCV | EN_XMT; /* enbl xmt & rcv for kbd */
1115:
1116: /*--------------------------
1117: * init keyboard defaults */
1118: /*
1119: for (i = 500; i > 0; --i) {
1120: if ((status = duart->statusA) & XMT_RDY) {
1121: duart->dataA = LK_DEFAULTS;
1122: break;
1123: }
1124: }
1125:
1126: for (j = 0; j < 3; ++j) {
1127: for (i = 50000; i > 0; --i) {
1128: if ((status = duart->statusA) & RCV_RDY) {
1129: status = duart->dataA;
1130: break;
1131: }
1132: }
1133: }
1134:
1135: if (i == 0)
1136: printf("LK-201 init error\n");
1137: */
1138:
1139: /*--------
1140: * exit */
1141:
1142: return(0);
1143:
1144: } /* setup_input */
1145:
1146: /**********************************************************************
1147: *
1148: * wait_status()... delay for at least one display frame time
1149: *
1150: ***********************************************************************
1151: *
1152: * calling convention:
1153: *
1154: * wait_status(adder, mask);
1155: * struct *adder adder;
1156: * int mask;
1157: *
1158: * return: BAD means that we timed out without ever seeing the
1159: * vertical sync status bit
1160: * GOOD otherwise
1161: *
1162: **************/
1163:
1164: wait_status(adder, mask)
1165: register struct adder *adder;
1166: register int mask;
1167: {
1168: register short status;
1169: int i;
1170:
1171: for ( i = 10000, adder->status = 0
1172: ; i > 0 && !((status = adder->status) & mask)
1173: ; --i);
1174:
1175: if (i == 0) {
1176: printf("timeout polling for 0x%x in adder->status\n", mask);
1177: return(BAD);
1178: }
1179:
1180: return(GOOD);
1181:
1182: } /* wait_status */
1183:
1184: /**********************************************************************
1185: *
1186: * write_ID()... write out onto the ID bus
1187: *
1188: ***********************************************************************
1189: *
1190: * calling convention:
1191: *
1192: * struct *adder adder; ;pntr to ADDER structure
1193: * short adrs; ;VIPER address
1194: * short data; ;data to be written
1195: * write_ID(adder);
1196: *
1197: * return: BAD means that we timed out waiting for status bits
1198: * VIPER-access-specific status bits
1199: * GOOD otherwise
1200: *
1201: **************/
1202:
1203: write_ID(adder, adrs, data)
1204: register struct adder *adder;
1205: register short adrs;
1206: register short data;
1207: {
1208: int i;
1209: short status;
1210:
1211: for ( i = 100000, adder->status = 0
1212: ; i > 0 && !((status = adder->status) & ADDRESS_COMPLETE)
1213: ; --i);
1214:
1215: if (i == 0)
1216: goto ERR;
1217:
1218: for ( i = 100000, adder->status = 0
1219: ; i > 0 && !((status = adder->status) & TX_READY)
1220: ; --i);
1221:
1222: if (i > 0) {
1223: adder->id_data = data;
1224: adder->command = ID_LOAD | adrs;
1225: return(GOOD);
1226: }
1227:
1228: ERR:
1229: printf("timeout trying to write to VIPER\n");
1230: return(BAD);
1231:
1232: } /* write_ID */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.