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