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