![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to screen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / chips|
Return to screen.c CVS log | Up to [GnuMach] / Gnu-Mach / chips |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1991,1990,1989 Carnegie Mellon University ! 4: * All Rights Reserved. ! 5: * ! 6: * Permission to use, copy, modify and distribute this software and its ! 7: * documentation is hereby granted, provided that both the copyright ! 8: * notice and this permission notice appear in all copies of the ! 9: * software, derivative works or modified versions, and any portions ! 10: * thereof, and that both notices appear in supporting documentation. ! 11: * ! 12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 15: * ! 16: * Carnegie Mellon requests users of this software to return to ! 17: * ! 18: * Software Distribution Coordinator or [email protected] ! 19: * School of Computer Science ! 20: * Carnegie Mellon University ! 21: * Pittsburgh PA 15213-3890 ! 22: * ! 23: * any improvements or extensions that they make and grant Carnegie Mellon ! 24: * the rights to redistribute these changes. ! 25: */ ! 26: /* ! 27: * File: screen.c ! 28: * Author: Alessandro Forin, Robert V. Baron, Joseph S. Barrera, ! 29: * at Carnegie Mellon University ! 30: * Date: 9/90 ! 31: * ! 32: * Generic Screen Driver routines. ! 33: */ ! 34: ! 35: #include <bm.h> ! 36: #if NBM > 0 ! 37: #include <dtop.h> ! 38: ! 39: #include <machine/machspl.h> /* spl definitions */ ! 40: #include <chips/screen_defs.h> ! 41: ! 42: #include <chips/lk201.h> ! 43: ! 44: #include <mach/std_types.h> ! 45: #include <sys/time.h> ! 46: #include <kern/time_out.h> ! 47: #include <device/io_req.h> ! 48: ! 49: #include <vm/vm_map.h> ! 50: #include <device/ds_routines.h> ! 51: #include <machine/machspl.h> ! 52: ! 53: #define Ctrl(x) ((x)-'@') ! 54: ! 55: #define SCREEN_BLITC_NORMAL 0 ! 56: #define SCREEN_BLITC_ROW 1 ! 57: #define SCREEN_BLITC_COL 2 ! 58: ! 59: #define SCREEN_ASCII_INVALID '\0' /* ascii_screen not valid here */ ! 60: ! 61: struct screen_softc screen_softc_data[NBM]; ! 62: struct screen_softc *screen_softc[NBM]; ! 63: ! 64: short screen_console = 0; ! 65: ! 66: /* Forward decls */ ! 67: ! 68: void screen_blitc( ! 69: int unit, ! 70: register unsigned char c); ! 71: ! 72: void screen_blitc_at( ! 73: register screen_softc_t sc, ! 74: unsigned char c, ! 75: short row, ! 76: short col); ! 77: ! 78: ! 79: /* ! 80: 8-D A "Screen" has a bitmapped display, a keyboard and a mouse ! 81: * ! 82: */ ! 83: ! 84: #if NDTOP > 0 ! 85: extern int dtop_kbd_probe(), dtop_set_status(), dtop_kbd_reset(), ! 86: dtop_ring_bell(); ! 87: #endif /* NDTOP */ ! 88: extern int lk201_probe(), lk201_set_status(), lk201_reset(), ! 89: lk201_ring_bell(); ! 90: ! 91: struct kbd_probe_vector { ! 92: int (*probe)(); ! 93: int (*set_status)(); ! 94: int (*reset)(); ! 95: int (*beep)(); ! 96: } kbd_vector[] = { ! 97: #if NDTOP > 0 ! 98: {dtop_kbd_probe, dtop_set_status, dtop_kbd_reset, dtop_ring_bell}, ! 99: #endif ! 100: {lk201_probe, lk201_set_status, lk201_reset, lk201_ring_bell}, ! 101: {0,} ! 102: }; ! 103: ! 104: screen_find_kbd(int unit) ! 105: { ! 106: struct kbd_probe_vector *p = kbd_vector; ! 107: ! 108: for (; p->probe; p++) { ! 109: if ((*p->probe) (unit)) { ! 110: screen_softc[unit]->kbd_set_status = p->set_status; ! 111: screen_softc[unit]->kbd_reset = p->reset; ! 112: screen_softc[unit]->kbd_beep = p->beep; ! 113: return 1; ! 114: } ! 115: } ! 116: return 0; ! 117: } ! 118: ! 119: /* ! 120: * The screen probe routine looks for the associated ! 121: * keyboard and mouse, at the same unit number. ! 122: */ ! 123: screen_probe(int unit) ! 124: { ! 125: if (unit >= NBM) ! 126: return 0; ! 127: screen_softc[unit] = &screen_softc_data[unit]; ! 128: if (!screen_find()) ! 129: return 0; ! 130: if (!screen_find_kbd(unit)) ! 131: return 0; ! 132: mouse_probe(unit); ! 133: return 1; ! 134: } ! 135: ! 136: screen_softc_t ! 137: screen(int unit) ! 138: { ! 139: return screen_softc[unit]; ! 140: } ! 141: ! 142: /* ! 143: * This is an upcall from the specific display ! 144: * hardware, to register its descriptor ! 145: */ ! 146: screen_attach( ! 147: int unit, ! 148: char **hwp) ! 149: { ! 150: register screen_softc_t sc = screen_softc[unit]; ! 151: ! 152: sc->hw_state = hwp; ! 153: sc->blitc_state = SCREEN_BLITC_NORMAL; ! 154: } ! 155: ! 156: /* ! 157: * This is another upcall (for now) to register ! 158: * the user-mapped information ! 159: */ ! 160: void ! 161: screen_up( ! 162: int unit, ! 163: user_info_t *screen_data) ! 164: { ! 165: register screen_softc_t sc = screen_softc[unit]; ! 166: ! 167: sc->up = screen_data; ! 168: mouse_notify_mapped(unit, unit, screen_data); ! 169: screen_event_init(screen_data); ! 170: ascii_screen_initialize(sc); ! 171: } ! 172: ! 173: /* ! 174: * Screen saver ! 175: */ ! 176: #define SSAVER_MIN_TIME (2*60) /* Minimum fade interval */ ! 177: long ssaver_last = 0; /* Last tv_sec that the keyboard was touched */ ! 178: long ssaver_time = 0; /* Number of seconds before screen is blanked */ ! 179: ! 180: void ! 181: ssaver_bump(int unit) ! 182: { ! 183: register long tnow = time.tv_sec; ! 184: ! 185: if ((tnow - ssaver_last) > ssaver_time) ! 186: screen_on_off(unit, TRUE); ! 187: ssaver_last = tnow; ! 188: } ! 189: ! 190: void ! 191: screen_saver(int unit) ! 192: { ! 193: register screen_softc_t sc = screen_softc[unit]; ! 194: ! 195: /* wakeup each minute */ ! 196: timeout(screen_saver, unit, hz * 60); ! 197: if ((time.tv_sec - ssaver_last) >= ssaver_time) ! 198: /* this does nothing if already off */ ! 199: screen_on_off(unit, FALSE); ! 200: } ! 201: ! 202: /* ! 203: * Screen open routine. We are also notified ! 204: * of console operations if our screen is acting ! 205: * as a console display. ! 206: */ ! 207: screen_open( ! 208: int unit, ! 209: boolean_t console_only) ! 210: { ! 211: register screen_softc_t sc = screen_softc[unit]; ! 212: ! 213: /* ! 214: * Start screen saver on first (console) open ! 215: */ ! 216: if (!ssaver_time) { ! 217: ssaver_time = 10*60; /* 10 minutes to fade */ ! 218: ssaver_bump(unit); /* .. from now */ ! 219: screen_saver(unit); /* Start timer */ ! 220: } ! 221: /* ! 222: * Really opening the screen or just notifying ? ! 223: */ ! 224: if (!console_only) { ! 225: #if 0 ! 226: (*sc->sw.init_colormap)(sc); ! 227: #endif ! 228: screen_event_init(sc->up); ! 229: ascii_screen_initialize(sc); ! 230: (*sc->sw.graphic_open)(sc->hw_state); ! 231: sc->mapped = TRUE; ! 232: } ! 233: } ! 234: ! 235: /* ! 236: * Screen close ! 237: */ ! 238: screen_close( ! 239: int unit, ! 240: boolean_t console_only) ! 241: { ! 242: register screen_softc_t sc = screen_softc[unit]; ! 243: ! 244: /* ! 245: * Closing of the plain console has no effect ! 246: */ ! 247: if (!console_only) { ! 248: user_info_t *up = sc->up; ! 249: ! 250: screen_default_colors(up); ! 251: /* mapped info, cursor and colormap resetting */ ! 252: (*sc->sw.graphic_close)(sc); ! 253: ! 254: /* turn screen on, and blank it */ ! 255: screen_on_off(unit, TRUE); ! 256: ascii_screen_initialize(sc); ! 257: (*sc->sw.clear_bitmap)(sc); ! 258: ! 259: /* position cursor circa page end */ ! 260: up->row = up->max_row - 1; ! 261: up->col = 0; ! 262: ! 263: /* set keyboard back our way */ ! 264: (*sc->kbd_reset)(unit); ! 265: lk201_lights(unit, LED_OFF); ! 266: ! 267: sc->mapped = FALSE; ! 268: } ! 269: } ! 270: ! 271: screen_default_colors( ! 272: user_info_t *up) ! 273: { ! 274: register int i; ! 275: ! 276: /* restore bg and fg colors */ ! 277: for (i = 0; i < 3; i++) { ! 278: up->dev_dep_2.pm.Bg_color[i] = 0x00; ! 279: up->dev_dep_2.pm.Fg_color[i] = 0xff; ! 280: } ! 281: } ! 282: ! 283: /* ! 284: * Write characters to the screen ! 285: */ ! 286: screen_write( ! 287: int unit, ! 288: register io_req_t ior) ! 289: { ! 290: register int count; ! 291: register unsigned char *data; ! 292: vm_offset_t addr; ! 293: ! 294: if (unit == 1) /* no writes to the mouse */ ! 295: return D_INVALID_OPERATION; ! 296: ! 297: data = (unsigned char*) ior->io_data; ! 298: count = ior->io_count; ! 299: if (count == 0) ! 300: return (D_SUCCESS); ! 301: ! 302: if (!(ior->io_op & IO_INBAND)) { ! 303: vm_map_copy_t copy = (vm_map_copy_t) data; ! 304: kern_return_t kr; ! 305: ! 306: kr = vm_map_copyout(device_io_map, &addr, copy); ! 307: if (kr != KERN_SUCCESS) ! 308: return (kr); ! 309: data = (unsigned char *) addr; ! 310: } ! 311: ! 312: /* Spill chars out, might fault data in */ ! 313: while (count--) ! 314: screen_blitc(unit, *data++); ! 315: ! 316: if (!(ior->io_op & IO_INBAND)) ! 317: (void) vm_deallocate(device_io_map, addr, ior->io_count); ! 318: ! 319: return (D_SUCCESS); ! 320: } ! 321: ! 322: /* ! 323: * Read from the screen. This really means waiting ! 324: * for an event, which can be either a keypress on ! 325: * the keyboard (or pointer) or a mouse movement. ! 326: * If there are no available events we queue the ! 327: * request for later. ! 328: */ ! 329: queue_head_t screen_read_queue = { &screen_read_queue, &screen_read_queue }; ! 330: boolean_t screen_read_done(); ! 331: ! 332: screen_read( ! 333: int unit, ! 334: register io_req_t ior) ! 335: { ! 336: register user_info_t *up = screen_softc[unit]->up; ! 337: register spl_t s = spltty(); ! 338: ! 339: if (up->evque.q_head != up->evque.q_tail) { ! 340: splx(s); ! 341: return (D_SUCCESS); ! 342: } ! 343: ior->io_dev_ptr = (char *) up; ! 344: ior->io_done = screen_read_done; ! 345: enqueue_tail(&screen_read_queue, (queue_entry_t) ior); ! 346: splx(s); ! 347: return (D_IO_QUEUED); ! 348: } ! 349: ! 350: boolean_t ! 351: screen_read_done( ! 352: register io_req_t ior) ! 353: { ! 354: register user_info_t *up = (user_info_t *) ior->io_dev_ptr; ! 355: register spl_t s = spltty(); ! 356: ! 357: if (up->evque.q_head != up->evque.q_tail) { ! 358: splx(s); ! 359: (void) ds_read_done(ior); ! 360: return (TRUE); ! 361: } ! 362: enqueue_tail(&screen_read_queue, (queue_entry_t) ior); ! 363: splx(s); ! 364: return (FALSE); ! 365: } ! 366: ! 367: static ! 368: screen_event_posted( ! 369: register user_info_t *up) ! 370: { ! 371: if (up->evque.q_head != up->evque.q_tail) { ! 372: register io_req_t ior; ! 373: while ((ior = (io_req_t)dequeue_head(&screen_read_queue))) ! 374: iodone(ior); ! 375: } ! 376: } ! 377: ! 378: boolean_t compress_mouse_events = TRUE; ! 379: ! 380: /* ! 381: * Upcall from input pointer devices ! 382: */ ! 383: screen_motion_event( ! 384: int unit, ! 385: int device, ! 386: int x, ! 387: int y) ! 388: { ! 389: register screen_softc_t sc = screen_softc[unit]; ! 390: register user_info_t *up = sc->up; ! 391: register unsigned next; ! 392: unsigned int ev_time; ! 393: ! 394: /* ! 395: * Take care of scale/threshold issues ! 396: */ ! 397: if (device == DEV_MOUSE) { ! 398: register int scale; ! 399: ! 400: scale = up->mouse_scale; ! 401: ! 402: if (scale >= 0) { ! 403: register int threshold; ! 404: register boolean_t neg; ! 405: ! 406: threshold = up->mouse_threshold; ! 407: ! 408: neg = (x < 0); ! 409: if (neg) x = -x; ! 410: if (x >= threshold) ! 411: x += (x - threshold) * scale; ! 412: if (neg) x = -x; ! 413: ! 414: neg = (y < 0); ! 415: if (neg) y = -y; ! 416: if (y >= threshold) ! 417: y += (y - threshold) * scale; ! 418: if (neg) y = -y; ! 419: ! 420: } ! 421: ! 422: /* we expect mices in incremental mode */ ! 423: x += up->mouse_loc.x; ! 424: y += up->mouse_loc.y; ! 425: ! 426: } else if (device == DEV_TABLET) { ! 427: ! 428: /* we expect tablets in absolute mode */ ! 429: x = (x * up->dev_dep_2.pm.tablet_scale_x) / 1000; ! 430: y = ((2200 - y) * up->dev_dep_2.pm.tablet_scale_y) / 1000; ! 431: ! 432: } /* else who are you */ ! 433: ! 434: /* ! 435: * Clip if necessary ! 436: */ ! 437: { ! 438: register int max; ! 439: ! 440: if (x > (max = up->max_cur_x)) ! 441: x = max; ! 442: if (y > (max = up->max_cur_y)) ! 443: y = max; ! 444: } ! 445: ! 446: /* ! 447: * Did it actually move ! 448: */ ! 449: if ((up->mouse_loc.x == x) && ! 450: (up->mouse_loc.y == y)) ! 451: return; ! 452: ! 453: /* ! 454: * Update mouse location, and cursor ! 455: */ ! 456: up->mouse_loc.x = x; ! 457: up->mouse_loc.y = y; ! 458: ! 459: screen_set_cursor(sc, x, y); ! 460: ! 461: /* ! 462: * Add point to track. ! 463: */ ! 464: { ! 465: register screen_timed_point_t *tr; ! 466: ! 467: /* simply add and overflow if necessary */ ! 468: next = up->evque.t_next; ! 469: if (next >= MAX_TRACK) ! 470: next = MAX_TRACK-1; ! 471: tr = &up->point_track[next++]; ! 472: up->evque.t_next = (next == MAX_TRACK) ? 0 : next; ! 473: ! 474: ev_time = (unsigned) approx_time_in_msec(); ! 475: tr->time = ev_time; ! 476: tr->x = x; ! 477: tr->y = y; ! 478: } ! 479: ! 480: /* ! 481: * Don't post event if mouse is within bounding box, ! 482: * Note our y-s are upside down ! 483: */ ! 484: if (y < up->mouse_box.bottom && ! 485: y >= up->mouse_box.top && ! 486: x < up->mouse_box.right && ! 487: x >= up->mouse_box.left) ! 488: return; ! 489: up->mouse_box.bottom = 0; /* X11 wants it ? */ ! 490: ! 491: /* ! 492: * Post motion event now ! 493: */ ! 494: #define round(x) ((x) & (MAX_EVENTS - 1)) ! 495: { ! 496: register unsigned int head = up->evque.q_head; ! 497: register unsigned int tail = up->evque.q_tail; ! 498: register screen_event_t *ev; ! 499: ! 500: if (round(tail + 1) == head) /* queue full, drop it */ ! 501: return; ! 502: ! 503: /* see if we can spare too many motion events */ ! 504: next = round(tail - 1); ! 505: if (compress_mouse_events && ! 506: (tail != head) && (next != head)) { ! 507: ev = & up->event_queue[next]; ! 508: if (ev->type == EVT_PTR_MOTION) { ! 509: ev->x = x; ! 510: ev->y = y; ! 511: ev->time = ev_time; ! 512: ev->device = device; ! 513: screen_event_posted(up); ! 514: return; ! 515: } ! 516: } ! 517: ev = & up->event_queue[tail]; ! 518: ev->type = EVT_PTR_MOTION; ! 519: ev->time = ev_time; ! 520: ev->x = x; ! 521: ev->y = y; ! 522: ev->device = device; ! 523: ! 524: /* added to queue */ ! 525: up->evque.q_tail = round(tail + 1); ! 526: } ! 527: ! 528: /* ! 529: * Wakeup any sleepers ! 530: */ ! 531: screen_event_posted(up); ! 532: } ! 533: ! 534: /* ! 535: * Upcall from keypress input devices ! 536: * Returns wether the event was consumed or not. ! 537: */ ! 538: boolean_t ! 539: screen_keypress_event( ! 540: int unit, ! 541: int device, ! 542: int key, ! 543: int type) ! 544: { ! 545: register screen_softc_t sc = screen_softc[unit]; ! 546: register user_info_t *up = sc->up; ! 547: register unsigned int head, tail; ! 548: register screen_event_t *ev; ! 549: ! 550: if (!sc->mapped) { ! 551: int col, row; ! 552: ! 553: if (device != DEV_MOUSE) ! 554: return FALSE; ! 555: /* generate escapes for mouse position */ ! 556: col = up->mouse_loc.x / 8; ! 557: row = up->mouse_loc.y / 15; ! 558: mouse_report_position(unit, col, row, key, type); ! 559: return TRUE; ! 560: } ! 561: ! 562: head = up->evque.q_head; ! 563: tail = up->evque.q_tail; ! 564: ! 565: if (round(tail + 1) == head) /* queue full */ ! 566: return TRUE; ! 567: ! 568: ev = & up->event_queue[tail]; ! 569: ev->key = key; ! 570: ev->type = type; ! 571: ev->device = device; ! 572: ev->time = approx_time_in_msec(); ! 573: ev->x = up->mouse_loc.x; ! 574: ev->y = up->mouse_loc.y; ! 575: ! 576: up->evque.q_tail = round(tail + 1); ! 577: ! 578: screen_event_posted(up); ! 579: ! 580: return TRUE; ! 581: } ! 582: #undef round ! 583: ! 584: /* ! 585: * Event queue initialization ! 586: */ ! 587: screen_event_init( ! 588: user_info_t *up) ! 589: { ! 590: up->evque.q_size = MAX_EVENTS; ! 591: up->evque.q_head = 0; ! 592: up->evque.q_tail = 0; ! 593: ; up->evque.t_size = MAX_TRACK; ! 594: up->evque.t_next = 0; ! 595: up->evque.timestamp = approx_time_in_msec(); ! 596: ! 597: } ! 598: ! 599: /* ! 600: * Set/Get status functions. ! 601: * ... ! 602: */ ! 603: io_return_t ! 604: screen_set_status( ! 605: int unit, ! 606: dev_flavor_t flavor, ! 607: dev_status_t status, ! 608: natural_t status_count) ! 609: { ! 610: register screen_softc_t sc = screen_softc[unit]; ! 611: register user_info_t *up = sc->up; ! 612: io_return_t ret = D_SUCCESS; ! 613: ! 614: /* XXX checks before getting here */ ! 615: ! 616: switch (flavor) { ! 617: ! 618: case SCREEN_INIT: ! 619: ascii_screen_initialize(sc); ! 620: break; ! 621: ! 622: case SCREEN_ON: ! 623: screen_on_off(unit, TRUE); ! 624: break; ! 625: ! 626: case SCREEN_OFF: ! 627: screen_on_off(unit, FALSE); ! 628: break; ! 629: ! 630: case SCREEN_FADE: { ! 631: register int tm = * (int *) status; ! 632: ! 633: untimeout(screen_saver, unit); /* stop everything and */ ! 634: if (tm == -1) /* don't reschedule a fade */ ! 635: break; ! 636: if (tm < SSAVER_MIN_TIME) ! 637: tm = SSAVER_MIN_TIME; ! 638: ssaver_time = tm; ! 639: ssaver_bump(unit); ! 640: screen_saver(unit); ! 641: break; ! 642: } ! 643: ! 644: case SCREEN_SET_CURSOR: { ! 645: screen_point_t *loc = (screen_point_t*) status; ! 646: ! 647: if (status_count < sizeof(screen_point_t)/sizeof(int)) ! 648: return D_INVALID_SIZE; ! 649: ! 650: sc->flags |= SCREEN_BEING_UPDATED; ! 651: up->mouse_loc = *loc; ! 652: sc->flags &= ~SCREEN_BEING_UPDATED; ! 653: ! 654: screen_set_cursor(sc, loc->x, loc->y); ! 655: ! 656: break; ! 657: } ! 658: ! 659: /* COMPAT: these codes do nothing, but we understand */ ! 660: case _IO('q', 8): /* KERNLOOP */ ! 661: case _IO('q', 9): /* KERNUNLOOP */ ! 662: case _IO('g', 21): /* KERN_UNLOOP */ ! 663: break; ! 664: ! 665: /* ! 666: * Anything else is either device-specific, ! 667: * or for the keyboard ! 668: */ ! 669: default: ! 670: ret = (*sc->sw.set_status)(sc, flavor, status, status_count); ! 671: if (ret == D_INVALID_OPERATION) ! 672: ret = (*sc->kbd_set_status)(unit, flavor, ! 673: status, status_count); ! 674: break; ! 675: } ! 676: return ret; ! 677: } ! 678: ! 679: io_return_t ! 680: screen_get_status( ! 681: int unit, ! 682: dev_flavor_t flavor, ! 683: dev_status_t status, ! 684: natural_t *count) ! 685: { ! 686: register screen_softc_t sc = screen_softc[unit]; ! 687: ! 688: if (flavor == SCREEN_STATUS_FLAGS) { ! 689: *(int *)status = sc->flags; ! 690: *count = 1; ! 691: return D_SUCCESS; ! 692: } else if (flavor == SCREEN_HARDWARE_INFO) { ! 693: screen_hw_info_t *hinfo; ! 694: ! 695: hinfo = (screen_hw_info_t*)status; ! 696: hinfo->frame_width = sc->frame_scanline_width; ! 697: hinfo->frame_height = sc->frame_height; ! 698: hinfo->frame_visible_width = sc->frame_visible_width; ! 699: hinfo->frame_visible_height = sc->frame_visible_height; ! 700: *count = sizeof(screen_hw_info_t)/sizeof(int); ! 701: return D_SUCCESS; ! 702: } else ! 703: ! 704: return (*sc->sw.get_status)(sc, flavor, status, count); ! 705: } ! 706: ! 707: /* ! 708: * Routine to handle display and control characters sent to screen ! 709: */ ! 710: void ! 711: screen_blitc( ! 712: int unit, ! 713: register unsigned char c) ! 714: { ! 715: register screen_softc_t sc = screen_softc[unit]; ! 716: register user_info_t *up = sc->up; ! 717: register unsigned char *ap; ! 718: register int i; ! 719: ! 720: /* ! 721: * Handle cursor positioning sequence ! 722: */ ! 723: switch (sc->blitc_state) { ! 724: case SCREEN_BLITC_NORMAL: ! 725: break; ! 726: ! 727: case SCREEN_BLITC_ROW: ! 728: c -= ' '; ! 729: if (c >= up->max_row) { ! 730: up->row = up->max_row - 1; ! 731: } else { ! 732: up->row = c; ! 733: } ! 734: sc->blitc_state = SCREEN_BLITC_COL; ! 735: return; ! 736: ! 737: case SCREEN_BLITC_COL: ! 738: c -= ' '; ! 739: if (c >= up->max_col) { ! 740: up->col = up->max_col - 1; ! 741: } else { ! 742: up->col = c; ! 743: } ! 744: sc->blitc_state = SCREEN_BLITC_NORMAL; ! 745: goto move_cursor; ! 746: } ! 747: ! 748: c &= 0xff; ! 749: ! 750: /* echo on rconsole line */ ! 751: rcputc(c); ! 752: ! 753: /* we got something to say, turn on the TV */ ! 754: ssaver_bump(unit); ! 755: ! 756: switch (c) { ! 757: /* Locate cursor*/ ! 758: case Ctrl('A'): /* ^A -> cm */ ! 759: sc->blitc_state = SCREEN_BLITC_ROW; ! 760: return; ! 761: ! 762: /* Home cursor */ ! 763: case Ctrl('B'): /* ^B -> ho */ ! 764: up->row = 0; ! 765: up->col = 0; ! 766: break; ! 767: ! 768: /* Clear screen */ ! 769: case Ctrl('C'): /* ^C -> cl */ ! 770: up->row = 0; ! 771: up->col = 0; ! 772: (*sc->sw.clear_bitmap)(sc); ! 773: break; ! 774: ! 775: /* Move forward */ ! 776: case Ctrl('D'): /* ^D -> nd */ ! 777: screen_advance_position(sc); ! 778: break; ! 779: ! 780: /* Clear to eol */ ! 781: case Ctrl('E'): /* ^E -> ce */ ! 782: ap = &sc->ascii_screen[up->max_col*up->row + up->col]; ! 783: for (i = up->col; i < up->max_col; i++, ap++) { ! 784: if (sc->standout || *ap != ' ') { ! 785: if (sc->standout) { ! 786: *ap = SCREEN_ASCII_INVALID; ! 787: } else { ! 788: *ap = ' '; ! 789: } ! 790: screen_blitc_at(sc, ' ', up->row, i); ! 791: } ! 792: } ! 793: return; ! 794: ! 795: /* Cursor up */ ! 796: case Ctrl('F'): /* ^F -> up */ ! 797: if (up->row != 0) up->row--; ! 798: break; ! 799: ! 800: case Ctrl('G'): /* ^G -> bell */ ! 801: (*sc->kbd_beep)(unit); ! 802: return; ! 803: ! 804: /* Backspace */ ! 805: case Ctrl('H'): /* ^H -> bs */ ! 806: if (--up->col < 0) ! 807: up->col = 0; ! 808: break; ! 809: ! 810: case Ctrl('I'): /* ^I -> tab */ ! 811: up->col += (8 - (up->col & 0x7)); ! 812: break; ! 813: ! 814: case Ctrl('J'): /* ^J -> lf */ ! 815: if (up->row+1 >= up->max_row) ! 816: (*sc->sw.remove_line)(sc, 0); ! 817: else ! 818: up->row++; ! 819: break; ! 820: ! 821: /* Start rev-video */ ! 822: case Ctrl('K'): /* ^K -> so */ ! 823: sc->standout = 1; ! 824: return; ! 825: ! 826: /* End rev-video */ ! 827: case Ctrl('L'): /* ^L -> se */ ! 828: sc->standout = 0; ! 829: return; ! 830: ! 831: case Ctrl('M'): /* ^M -> return */ ! 832: up->col = 0; ! 833: break; ! 834: ! 835: /* Save cursor position */ ! 836: case Ctrl('N'): /* ^N -> sc */ ! 837: sc->save_col = up->col; ! 838: sc->save_row = up->row; ! 839: return; ! 840: ! 841: /* Restore cursor position */ ! 842: case Ctrl('O'): /* ^O -> rc */ ! 843: up->row = sc->save_row; ! 844: up->col = sc->save_col; ! 845: break; ! 846: ! 847: /* Add blank line */ ! 848: case Ctrl('P'): /* ^P -> al */ ! 849: (*sc->sw.insert_line)(sc, up->row); ! 850: return; ! 851: ! 852: /* Delete line */ ! 853: case Ctrl('Q'): /* ^Q -> dl */ ! 854: (*sc->sw.remove_line)(sc, up->row); ! 855: return; ! 856: ! 857: default: ! 858: /* ! 859: * If the desired character is already there, then don't ! 860: * bother redrawing it. Always redraw standout-ed chars, ! 861: * so that we can assume that all cached characters are ! 862: * un-standout-ed. (This could be fixed.) ! 863: */ ! 864: ap = &sc->ascii_screen[up->max_col*up->row + up->col]; ! 865: if (sc->standout || c != *ap) { ! 866: if (sc->standout) { ! 867: *ap = SCREEN_ASCII_INVALID; ! 868: } else { ! 869: *ap = c; ! 870: } ! 871: screen_blitc_at(sc, c, up->row, up->col); ! 872: } ! 873: screen_advance_position(sc); ! 874: break; ! 875: } ! 876: ! 877: move_cursor: ! 878: screen_set_cursor(sc, up->col*8, up->row*15); ! 879: ! 880: } ! 881: ! 882: ! 883: /* ! 884: * Advance current position, wrapping and scrolling when necessary ! 885: */ ! 886: screen_advance_position( ! 887: register screen_softc_t sc) ! 888: { ! 889: register user_info_t *up = sc->up; ! 890: ! 891: if (++up->col >= up->max_col) { ! 892: up->col = 0 ; ! 893: if (up->row+1 >= up->max_row) { ! 894: (*sc->sw.remove_line)(sc, 0); ! 895: } else { ! 896: up->row++; ! 897: } ! 898: } ! 899: } ! 900: ! 901: ! 902: /* ! 903: * Routine to display a character at a given position ! 904: */ ! 905: void ! 906: screen_blitc_at( ! 907: register screen_softc_t sc, ! 908: unsigned char c, ! 909: short row, ! 910: short col) ! 911: { ! 912: /* ! 913: * Silently ignore non-printable chars ! 914: */ ! 915: if (c < ' ' || c > 0xfd) ! 916: return; ! 917: (*sc->sw.char_paint)(sc, c, row, col); ! 918: } ! 919: ! 920: /* ! 921: * Update sc->ascii_screen array after deleting ROW ! 922: */ ! 923: ascii_screen_rem_update( ! 924: register screen_softc_t sc, ! 925: int row) ! 926: { ! 927: register user_info_t *up = sc->up; ! 928: register unsigned int col_w, row_w; ! 929: register unsigned char *c, *end; ! 930: ! 931: /* cache and sanity */ ! 932: col_w = up->max_col; ! 933: if (col_w > MaxCharCols) ! 934: col_w = MaxCharCols; ! 935: row_w = up->max_row; ! 936: if (row_w > MaxCharRows) ! 937: row_w = MaxCharRows; ! 938: ! 939: /* scroll up */ ! 940: c = &sc->ascii_screen[row * col_w]; ! 941: end = &sc->ascii_screen[(row_w-1) * col_w]; ! 942: for (; c < end; c++) /* bcopy ? XXX */ ! 943: *c = *(c + col_w); ! 944: ! 945: /* zero out line that entered at end */ ! 946: c = end; ! 947: end = &sc->ascii_screen[row_w * col_w]; ! 948: for (; c < end; c++) ! 949: *c = ' '; ! 950: ! 951: } ! 952: ! 953: /* ! 954: * Update sc->ascii_screen array after opening new ROW ! 955: */ ! 956: ascii_screen_ins_update( ! 957: register screen_softc_t sc, ! 958: int row) ! 959: { ! 960: register user_info_t *up = sc->up; ! 961: register unsigned int col_w, row_w; ! 962: register unsigned char *c, *end; ! 963: ! 964: /* cache and sanity */ ! 965: col_w = up->max_col; ! 966: if (col_w > MaxCharCols) ! 967: col_w = MaxCharCols; ! 968: row_w = up->max_row; ! 969: if (row_w > MaxCharRows) ! 970: row_w = MaxCharRows; ! 971: ! 972: /* scroll down */ ! 973: c = &sc->ascii_screen[row_w * col_w - 1]; ! 974: end = &sc->ascii_screen[(row + 1) * col_w]; ! 975: for (; c >= end; c--) ! 976: *c = *(c - col_w); ! 977: ! 978: /* zero out line that entered at row */ ! 979: c = end - 1; ! 980: end = &sc->ascii_screen[row * col_w]; ! 981: for (; c >= end; c--) ! 982: *c = ' '; ! 983: } ! 984: ! 985: /* ! 986: * Init charmap ! 987: */ ! 988: ascii_screen_fill( ! 989: register screen_softc_t sc, ! 990: char c) ! 991: { ! 992: register user_info_t *up = sc->up; ! 993: register int i, to; ! 994: ! 995: to = up->max_row * up->max_col; ! 996: for (i = 0; i < to; i++) { ! 997: sc->ascii_screen[i] = c; ! 998: } ! 999: } ! 1000: ! 1001: ascii_screen_initialize( ! 1002: register screen_softc_t sc) ! 1003: { ! 1004: ascii_screen_fill(sc, SCREEN_ASCII_INVALID); ! 1005: } ! 1006: ! 1007: /* ! 1008: * Cursor positioning ! 1009: */ ! 1010: screen_set_cursor( ! 1011: register screen_softc_t sc, ! 1012: register int x, ! 1013: register int y) ! 1014: { ! 1015: register user_info_t *up = sc->up; ! 1016: ! 1017: /* If we are called from interrupt level.. */ ! 1018: if (sc->flags & SCREEN_BEING_UPDATED) ! 1019: return; ! 1020: sc->flags |= SCREEN_BEING_UPDATED; ! 1021: /* ! 1022: * Note that that was not atomic, but this is ! 1023: * a two-party game on the same processor and ! 1024: * not a real parallel program. ! 1025: */ ! 1026: ! 1027: /* Sanity checks (ignore noise) */ ! 1028: if (y < up->min_cur_y || y > up->max_cur_y) ! 1029: y = up->cursor.y; ! 1030: if (x < up->min_cur_x || x > up->max_cur_x) ! 1031: x = up->cursor.x; ! 1032: ! 1033: /* ! 1034: * Track cursor position ! 1035: */ ! 1036: up->cursor.x = x; ! 1037: up->cursor.y = y; ! 1038: ! 1039: (*sc->sw.pos_cursor)(*(sc->hw_state), x, y); ! 1040: ! 1041: sc->flags &= ~SCREEN_BEING_UPDATED; ! 1042: } ! 1043: ! 1044: screen_on_off( ! 1045: int unit, ! 1046: boolean_t on) ! 1047: { ! 1048: register screen_softc_t sc = screen_softc[unit]; ! 1049: ! 1050: if (sc->sw.video_on == 0) /* sanity */ ! 1051: return; ! 1052: ! 1053: if (on) ! 1054: (*sc->sw.video_on)(sc->hw_state, sc->up); ! 1055: else ! 1056: (*sc->sw.video_off)(sc->hw_state, sc->up); ! 1057: } ! 1058: ! 1059: screen_enable_vretrace( ! 1060: int unit, ! 1061: boolean_t on) ! 1062: { ! 1063: register screen_softc_t sc = screen_softc[unit]; ! 1064: (*sc->sw.intr_enable)(sc->hw_state, on); ! 1065: } ! 1066: ! 1067: /* ! 1068: * For our purposes, time does not need to be ! 1069: * precise but just monotonic and approximate ! 1070: * to about the millisecond. Instead of div/ ! 1071: * mul by 1000 we div/mul by 1024 (shifting). ! 1072: * ! 1073: * Well, it almost worked. The only problem ! 1074: * is that X somehow checks the time against ! 1075: * gettimeofday() and .. turns screen off at ! 1076: * startup if we use approx time. SO we are ! 1077: * back to precise time, sigh. ! 1078: */ ! 1079: approx_time_in_msec() ! 1080: { ! 1081: #if 0 ! 1082: return ((time.seconds << 10) + (time.microseconds >> 10)); ! 1083: #else ! 1084: return ((time.seconds * 1000) + (time.microseconds / 1000)); ! 1085: #endif ! 1086: } ! 1087: ! 1088: /* ! 1089: * Screen mapping to user space ! 1090: * This is called on a per-page basis ! 1091: */ ! 1092: screen_mmap( ! 1093: int dev, ! 1094: vm_offset_t off, ! 1095: int prot) ! 1096: { ! 1097: /* dev is safe, but it is the mouse's one */ ! 1098: register screen_softc_t sc = screen_softc[dev-1]; ! 1099: ! 1100: (*sc->sw.map_page)(sc, off, prot); ! 1101: } ! 1102: ! 1103: #endif NBM > 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.