wsdisplay_vcons.c revision 1.15.16.1
1 /* $NetBSD: wsdisplay_vcons.c,v 1.15.16.1 2008/06/02 13:23:57 mjf Exp $ */ 2 3 /*- 4 * Copyright (c) 2005, 2006 Michael Lorenz 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: wsdisplay_vcons.c,v 1.15.16.1 2008/06/02 13:23:57 mjf Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/kernel.h> 35 #include <sys/buf.h> 36 #include <sys/device.h> 37 #include <sys/ioctl.h> 38 #include <sys/malloc.h> 39 #include <sys/mman.h> 40 #include <sys/tty.h> 41 #include <sys/conf.h> 42 #include <sys/proc.h> 43 #include <sys/kthread.h> 44 #include <sys/tprintf.h> 45 46 #include <dev/wscons/wsdisplayvar.h> 47 #include <dev/wscons/wsconsio.h> 48 #include <dev/wsfont/wsfont.h> 49 #include <dev/rasops/rasops.h> 50 51 #include <dev/wscons/wsdisplay_vconsvar.h> 52 53 #include "opt_wsemul.h" 54 #include "opt_wsdisplay_compat.h" 55 #include "opt_vcons.h" 56 57 static void vcons_dummy_init_screen(void *, struct vcons_screen *, int, 58 long *); 59 60 static int vcons_ioctl(void *, void *, u_long, void *, int, struct lwp *); 61 static int vcons_alloc_screen(void *, const struct wsscreen_descr *, void **, 62 int *, int *, long *); 63 static void vcons_free_screen(void *, void *); 64 static int vcons_show_screen(void *, void *, int, void (*)(void *, int, int), 65 void *); 66 67 #ifdef WSDISPLAY_SCROLLSUPPORT 68 static void vcons_scroll(void *, void *, int); 69 static void vcons_do_scroll(struct vcons_screen *); 70 #endif 71 72 static void vcons_do_switch(void *); 73 74 /* methods that work only on text buffers */ 75 static void vcons_copycols_buffer(void *, int, int, int, int); 76 static void vcons_erasecols_buffer(void *, int, int, int, long); 77 static void vcons_copyrows_buffer(void *, int, int, int); 78 static void vcons_eraserows_buffer(void *, int, int, long); 79 static void vcons_putchar_buffer(void *, int, int, u_int, long); 80 81 /* 82 * actual wrapper methods which call both the _buffer ones above and the 83 * driver supplied ones to do the drawing 84 */ 85 static void vcons_copycols(void *, int, int, int, int); 86 static void vcons_erasecols(void *, int, int, int, long); 87 static void vcons_copyrows(void *, int, int, int); 88 static void vcons_eraserows(void *, int, int, long); 89 static void vcons_putchar(void *, int, int, u_int, long); 90 static void vcons_cursor(void *, int, int, int); 91 92 /* support for reading/writing text buffers. For wsmoused */ 93 static int vcons_putwschar(struct vcons_screen *, struct wsdisplay_char *); 94 static int vcons_getwschar(struct vcons_screen *, struct wsdisplay_char *); 95 96 static void vcons_lock(struct vcons_screen *); 97 static void vcons_unlock(struct vcons_screen *); 98 99 #ifdef VCONS_SWITCH_ASYNC 100 static void vcons_kthread(void *); 101 #endif 102 103 int 104 vcons_init(struct vcons_data *vd, void *cookie, struct wsscreen_descr *def, 105 struct wsdisplay_accessops *ao) 106 { 107 108 /* zero out everything so we can rely on untouched fields being 0 */ 109 memset(vd, 0, sizeof(struct vcons_data)); 110 111 vd->cookie = cookie; 112 113 vd->init_screen = vcons_dummy_init_screen; 114 vd->show_screen_cb = NULL; 115 116 /* keep a copy of the accessops that we replace below with our 117 * own wrappers */ 118 vd->ioctl = ao->ioctl; 119 120 /* configure the accessops */ 121 ao->ioctl = vcons_ioctl; 122 ao->alloc_screen = vcons_alloc_screen; 123 ao->free_screen = vcons_free_screen; 124 ao->show_screen = vcons_show_screen; 125 #ifdef WSDISPLAY_SCROLLSUPPORT 126 ao->scroll = vcons_scroll; 127 #endif 128 129 LIST_INIT(&vd->screens); 130 vd->active = NULL; 131 vd->wanted = NULL; 132 vd->currenttype = def; 133 callout_init(&vd->switch_callout, 0); 134 callout_setfunc(&vd->switch_callout, vcons_do_switch, vd); 135 136 /* 137 * a lock to serialize access to the framebuffer. 138 * when switching screens we need to make sure there's no rasops 139 * operation in progress 140 */ 141 #ifdef DIAGNOSTIC 142 vd->switch_poll_count = 0; 143 #endif 144 #ifdef VCONS_SWITCH_ASYNC 145 kthread_create(PRI_NONE, 0, NULL, vcons_kthread, vd, 146 &vd->redraw_thread, "vcons_draw"); 147 #endif 148 return 0; 149 } 150 151 static void 152 vcons_lock(struct vcons_screen *scr) 153 { 154 #ifdef VCONS_PARANOIA 155 int s; 156 157 s = splhigh(); 158 #endif 159 SCREEN_BUSY(scr); 160 #ifdef VCONS_PARANOIA 161 splx(s); 162 #endif 163 } 164 165 static void 166 vcons_unlock(struct vcons_screen *scr) 167 { 168 #ifdef VCONS_PARANOIA 169 int s; 170 171 s = splhigh(); 172 #endif 173 SCREEN_IDLE(scr); 174 #ifdef VCONS_PARANOIA 175 splx(s); 176 #endif 177 #ifdef VCONS_SWITCH_ASYNC 178 wakeup(&scr->scr_vd->done_drawing); 179 #endif 180 } 181 182 static void 183 vcons_dummy_init_screen(void *cookie, 184 struct vcons_screen *scr, int exists, 185 long *defattr) 186 { 187 188 /* 189 * default init_screen() method. 190 * Needs to be overwritten so we bitch and whine in case anyone ends 191 * up in here. 192 */ 193 printf("vcons_init_screen: dummy function called. Your driver is " 194 "supposed to supply a replacement for proper operation\n"); 195 } 196 197 int 198 vcons_init_screen(struct vcons_data *vd, struct vcons_screen *scr, 199 int existing, long *defattr) 200 { 201 struct rasops_info *ri = &scr->scr_ri; 202 int cnt, i; 203 204 scr->scr_cookie = vd->cookie; 205 scr->scr_vd = scr->scr_origvd = vd; 206 scr->scr_busy = 0; 207 208 /* 209 * call the driver-supplied init_screen function which is expected 210 * to set up rasops_info, override cursor() and probably others 211 */ 212 vd->init_screen(vd->cookie, scr, existing, defattr); 213 214 /* 215 * save the non virtual console aware rasops and replace them with 216 * our wrappers 217 */ 218 vd->eraserows = ri->ri_ops.eraserows; 219 vd->copyrows = ri->ri_ops.copyrows; 220 vd->erasecols = ri->ri_ops.erasecols; 221 vd->copycols = ri->ri_ops.copycols; 222 vd->putchar = ri->ri_ops.putchar; 223 vd->cursor = ri->ri_ops.cursor; 224 225 ri->ri_ops.eraserows = vcons_eraserows; 226 ri->ri_ops.copyrows = vcons_copyrows; 227 ri->ri_ops.erasecols = vcons_erasecols; 228 ri->ri_ops.copycols = vcons_copycols; 229 ri->ri_ops.putchar = vcons_putchar; 230 ri->ri_ops.cursor = vcons_cursor; 231 ri->ri_hw = scr; 232 233 /* 234 * we allocate both chars and attributes in one chunk, attributes first 235 * because they have the (potentially) bigger alignment 236 */ 237 #ifdef WSDISPLAY_SCROLLSUPPORT 238 cnt = (ri->ri_rows + WSDISPLAY_SCROLLBACK_LINES) * ri->ri_cols; 239 scr->scr_lines_in_buffer = WSDISPLAY_SCROLLBACK_LINES; 240 scr->scr_current_line = 0; 241 scr->scr_line_wanted = 0; 242 scr->scr_offset_to_zero = ri->ri_cols * WSDISPLAY_SCROLLBACK_LINES; 243 scr->scr_current_offset = scr->scr_offset_to_zero; 244 #else 245 cnt = ri->ri_rows * ri->ri_cols; 246 #endif 247 scr->scr_attrs = (long *)malloc(cnt * (sizeof(long) + 248 sizeof(uint16_t)), M_DEVBUF, M_WAITOK); 249 if (scr->scr_attrs == NULL) 250 return ENOMEM; 251 252 scr->scr_chars = (uint16_t *)&scr->scr_attrs[cnt]; 253 254 ri->ri_ops.allocattr(ri, WS_DEFAULT_FG, WS_DEFAULT_BG, 0, defattr); 255 scr->scr_defattr = *defattr; 256 257 /* 258 * fill the attribute buffer with *defattr, chars with 0x20 259 * since we don't know if the driver tries to mimic firmware output or 260 * reset everything we do nothing to VRAM here, any driver that feels 261 * the need to clear screen or something will have to do it on its own 262 * Additional screens will start out in the background anyway so 263 * cleaning or not only really affects the initial console screen 264 */ 265 for (i = 0; i < cnt; i++) { 266 scr->scr_attrs[i] = *defattr; 267 scr->scr_chars[i] = 0x20; 268 } 269 270 if(vd->active == NULL) { 271 vd->active = scr; 272 SCREEN_VISIBLE(scr); 273 } 274 275 if (existing) { 276 SCREEN_VISIBLE(scr); 277 vd->active = scr; 278 } else { 279 SCREEN_INVISIBLE(scr); 280 } 281 282 LIST_INSERT_HEAD(&vd->screens, scr, next); 283 return 0; 284 } 285 286 static void 287 vcons_do_switch(void *arg) 288 { 289 struct vcons_data *vd = arg; 290 struct vcons_screen *scr, *oldscr; 291 292 scr = vd->wanted; 293 if (!scr) { 294 printf("vcons_switch_screen: disappeared\n"); 295 vd->switch_cb(vd->switch_cb_arg, EIO, 0); 296 return; 297 } 298 oldscr = vd->active; /* can be NULL! */ 299 300 /* 301 * if there's an old, visible screen we mark it invisible and wait 302 * until it's not busy so we can safely switch 303 */ 304 if (oldscr != NULL) { 305 SCREEN_INVISIBLE(oldscr); 306 if (SCREEN_IS_BUSY(oldscr)) { 307 callout_schedule(&vd->switch_callout, 1); 308 #ifdef DIAGNOSTIC 309 /* bitch if we wait too long */ 310 vd->switch_poll_count++; 311 if (vd->switch_poll_count > 100) { 312 panic("vcons: screen still busy"); 313 } 314 #endif 315 return; 316 } 317 /* invisible screen -> no visible cursor image */ 318 oldscr->scr_ri.ri_flg &= ~RI_CURSOR; 319 #ifdef DIAGNOSTIC 320 vd->switch_poll_count = 0; 321 #endif 322 } 323 324 if (scr == oldscr) 325 return; 326 327 #ifdef DIAGNOSTIC 328 if (SCREEN_IS_VISIBLE(scr)) 329 printf("vcons_switch_screen: already active"); 330 #endif 331 332 #ifdef notyet 333 if (vd->currenttype != type) { 334 vcons_set_screentype(vd, type); 335 vd->currenttype = type; 336 } 337 #endif 338 339 SCREEN_VISIBLE(scr); 340 vd->active = scr; 341 vd->wanted = NULL; 342 343 if (vd->show_screen_cb != NULL) 344 vd->show_screen_cb(scr); 345 346 if ((scr->scr_flags & VCONS_NO_REDRAW) == 0) 347 vcons_redraw_screen(scr); 348 349 if (vd->switch_cb) 350 vd->switch_cb(vd->switch_cb_arg, 0, 0); 351 } 352 353 void 354 vcons_redraw_screen(struct vcons_screen *scr) 355 { 356 uint16_t *charptr = scr->scr_chars; 357 long *attrptr = scr->scr_attrs; 358 struct rasops_info *ri = &scr->scr_ri; 359 int i, j, offset; 360 361 vcons_lock(scr); 362 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 363 364 /* 365 * only clear the screen when RI_FULLCLEAR is set since we're 366 * going to overwrite every single character cell anyway 367 */ 368 if (ri->ri_flg & RI_FULLCLEAR) { 369 scr->scr_vd->eraserows(ri, 0, ri->ri_rows, 370 scr->scr_defattr); 371 } 372 373 /* redraw the screen */ 374 #ifdef WSDISPLAY_SCROLLSUPPORT 375 offset = scr->scr_current_offset; 376 #else 377 offset = 0; 378 #endif 379 for (i = 0; i < ri->ri_rows; i++) { 380 for (j = 0; j < ri->ri_cols; j++) { 381 /* 382 * no need to use the wrapper function - we 383 * don't change any characters or attributes 384 * and we already made sure the screen we're 385 * working on is visible 386 */ 387 scr->scr_vd->putchar(ri, i, j, 388 charptr[offset], attrptr[offset]); 389 offset++; 390 } 391 } 392 ri->ri_flg &= ~RI_CURSOR; 393 scr->scr_vd->cursor(ri, 1, ri->ri_crow, ri->ri_ccol); 394 } 395 vcons_unlock(scr); 396 } 397 398 static int 399 vcons_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, 400 struct lwp *l) 401 { 402 struct vcons_data *vd = v; 403 int error; 404 405 switch (cmd) { 406 case WSDISPLAYIO_GETWSCHAR: 407 error = vcons_getwschar((struct vcons_screen *)vs, 408 (struct wsdisplay_char *)data); 409 break; 410 411 case WSDISPLAYIO_PUTWSCHAR: 412 error = vcons_putwschar((struct vcons_screen *)vs, 413 (struct wsdisplay_char *)data); 414 break; 415 416 default: 417 if (vd->ioctl != NULL) 418 error = (*vd->ioctl)(v, vs, cmd, data, flag, l); 419 else 420 error = EPASSTHROUGH; 421 } 422 423 return error; 424 } 425 426 static int 427 vcons_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep, 428 int *curxp, int *curyp, long *defattrp) 429 { 430 struct vcons_data *vd = v; 431 struct vcons_screen *scr; 432 int ret; 433 434 scr = malloc(sizeof(struct vcons_screen), M_DEVBUF, M_WAITOK | M_ZERO); 435 if (scr == NULL) 436 return ENOMEM; 437 438 scr->scr_flags = 0; 439 scr->scr_status = 0; 440 scr->scr_busy = 0; 441 scr->scr_type = type; 442 443 ret = vcons_init_screen(vd, scr, 0, defattrp); 444 if (ret != 0) { 445 free(scr, M_DEVBUF); 446 return ret; 447 } 448 449 if (vd->active == NULL) { 450 SCREEN_VISIBLE(scr); 451 vd->active = scr; 452 vd->currenttype = type; 453 } 454 455 *cookiep = scr; 456 *curxp = scr->scr_ri.ri_ccol; 457 *curyp = scr->scr_ri.ri_crow; 458 return 0; 459 } 460 461 static void 462 vcons_free_screen(void *v, void *cookie) 463 { 464 struct vcons_data *vd = v; 465 struct vcons_screen *scr = cookie; 466 467 vcons_lock(scr); 468 /* there should be no rasops activity here */ 469 470 LIST_REMOVE(scr, next); 471 472 if ((scr->scr_flags & VCONS_SCREEN_IS_STATIC) == 0) { 473 free(scr->scr_attrs, M_DEVBUF); 474 free(scr, M_DEVBUF); 475 } else { 476 /* 477 * maybe we should just restore the old rasops_info methods 478 * and free the character/attribute buffer here? 479 */ 480 #ifdef VCONS_DEBUG 481 panic("vcons_free_screen: console"); 482 #else 483 printf("vcons_free_screen: console\n"); 484 #endif 485 } 486 487 if (vd->active == scr) 488 vd->active = NULL; 489 } 490 491 static int 492 vcons_show_screen(void *v, void *cookie, int waitok, 493 void (*cb)(void *, int, int), void *cb_arg) 494 { 495 struct vcons_data *vd = v; 496 struct vcons_screen *scr; 497 498 scr = cookie; 499 if (scr == vd->active) 500 return 0; 501 502 vd->wanted = scr; 503 vd->switch_cb = cb; 504 vd->switch_cb_arg = cb_arg; 505 #ifdef VCONS_SWITCH_ASYNC 506 wakeup(&vd->start_drawing); 507 return EAGAIN; 508 #else 509 if (cb) { 510 callout_schedule(&vd->switch_callout, 0); 511 return EAGAIN; 512 } 513 514 vcons_do_switch(vd); 515 return 0; 516 #endif 517 } 518 519 /* wrappers for rasops_info methods */ 520 521 static void 522 vcons_copycols_buffer(void *cookie, int row, int srccol, int dstcol, int ncols) 523 { 524 struct rasops_info *ri = cookie; 525 struct vcons_screen *scr = ri->ri_hw; 526 int from = srccol + row * ri->ri_cols; 527 int to = dstcol + row * ri->ri_cols; 528 529 #ifdef WSDISPLAY_SCROLLSUPPORT 530 int offset; 531 offset = scr->scr_offset_to_zero; 532 533 memmove(&scr->scr_attrs[offset + to], &scr->scr_attrs[offset + from], 534 ncols * sizeof(long)); 535 memmove(&scr->scr_chars[offset + to], &scr->scr_chars[offset + from], 536 ncols * sizeof(uint16_t)); 537 #else 538 memmove(&scr->scr_attrs[to], &scr->scr_attrs[from], 539 ncols * sizeof(long)); 540 memmove(&scr->scr_chars[to], &scr->scr_chars[from], 541 ncols * sizeof(uint16_t)); 542 #endif 543 } 544 545 static void 546 vcons_copycols(void *cookie, int row, int srccol, int dstcol, int ncols) 547 { 548 struct rasops_info *ri = cookie; 549 struct vcons_screen *scr = ri->ri_hw; 550 551 vcons_copycols_buffer(cookie, row, srccol, dstcol, ncols); 552 553 vcons_lock(scr); 554 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 555 scr->scr_vd->copycols(cookie, row, srccol, dstcol, ncols); 556 } 557 vcons_unlock(scr); 558 } 559 560 static void 561 vcons_erasecols_buffer(void *cookie, int row, int startcol, int ncols, long fillattr) 562 { 563 struct rasops_info *ri = cookie; 564 struct vcons_screen *scr = ri->ri_hw; 565 int start = startcol + row * ri->ri_cols; 566 int end = start + ncols, i; 567 568 #ifdef WSDISPLAY_SCROLLSUPPORT 569 int offset; 570 offset = scr->scr_offset_to_zero; 571 572 for (i = start; i < end; i++) { 573 scr->scr_attrs[offset + i] = fillattr; 574 scr->scr_chars[offset + i] = 0x20; 575 } 576 #else 577 for (i = start; i < end; i++) { 578 scr->scr_attrs[i] = fillattr; 579 scr->scr_chars[i] = 0x20; 580 } 581 #endif 582 } 583 584 static void 585 vcons_erasecols(void *cookie, int row, int startcol, int ncols, long fillattr) 586 { 587 struct rasops_info *ri = cookie; 588 struct vcons_screen *scr = ri->ri_hw; 589 590 vcons_erasecols_buffer(cookie, row, startcol, ncols, fillattr); 591 592 vcons_lock(scr); 593 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 594 scr->scr_vd->erasecols(cookie, row, startcol, ncols, 595 fillattr); 596 } 597 vcons_unlock(scr); 598 } 599 600 static void 601 vcons_copyrows_buffer(void *cookie, int srcrow, int dstrow, int nrows) 602 { 603 struct rasops_info *ri = cookie; 604 struct vcons_screen *scr = ri->ri_hw; 605 int from, to, len; 606 607 #ifdef WSDISPLAY_SCROLLSUPPORT 608 int offset; 609 offset = scr->scr_offset_to_zero; 610 611 /* do we need to scroll the back buffer? */ 612 if (dstrow == 0) { 613 from = ri->ri_cols * srcrow; 614 to = ri->ri_cols * dstrow; 615 616 memmove(&scr->scr_attrs[to], &scr->scr_attrs[from], 617 scr->scr_offset_to_zero * sizeof(long)); 618 memmove(&scr->scr_chars[to], &scr->scr_chars[from], 619 scr->scr_offset_to_zero * sizeof(uint16_t)); 620 } 621 from = ri->ri_cols * srcrow + offset; 622 to = ri->ri_cols * dstrow + offset; 623 len = ri->ri_cols * nrows; 624 625 #else 626 from = ri->ri_cols * srcrow; 627 to = ri->ri_cols * dstrow; 628 len = ri->ri_cols * nrows; 629 #endif 630 memmove(&scr->scr_attrs[to], &scr->scr_attrs[from], 631 len * sizeof(long)); 632 memmove(&scr->scr_chars[to], &scr->scr_chars[from], 633 len * sizeof(uint16_t)); 634 } 635 636 static void 637 vcons_copyrows(void *cookie, int srcrow, int dstrow, int nrows) 638 { 639 struct rasops_info *ri = cookie; 640 struct vcons_screen *scr = ri->ri_hw; 641 642 vcons_copyrows_buffer(cookie, srcrow, dstrow, nrows); 643 644 vcons_lock(scr); 645 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 646 scr->scr_vd->copyrows(cookie, srcrow, dstrow, nrows); 647 } 648 vcons_unlock(scr); 649 } 650 651 static void 652 vcons_eraserows_buffer(void *cookie, int row, int nrows, long fillattr) 653 { 654 struct rasops_info *ri = cookie; 655 struct vcons_screen *scr = ri->ri_hw; 656 int start, end, i; 657 658 #ifdef WSDISPLAY_SCROLLSUPPORT 659 int offset; 660 offset = scr->scr_offset_to_zero; 661 662 start = ri->ri_cols * row + offset; 663 end = ri->ri_cols * (row + nrows) + offset; 664 #else 665 start = ri->ri_cols * row; 666 end = ri->ri_cols * (row + nrows); 667 #endif 668 669 for (i = start; i < end; i++) { 670 scr->scr_attrs[i] = fillattr; 671 scr->scr_chars[i] = 0x20; 672 } 673 } 674 675 static void 676 vcons_eraserows(void *cookie, int row, int nrows, long fillattr) 677 { 678 struct rasops_info *ri = cookie; 679 struct vcons_screen *scr = ri->ri_hw; 680 681 vcons_eraserows_buffer(cookie, row, nrows, fillattr); 682 683 vcons_lock(scr); 684 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 685 scr->scr_vd->eraserows(cookie, row, nrows, fillattr); 686 } 687 vcons_unlock(scr); 688 } 689 690 static void 691 vcons_putchar_buffer(void *cookie, int row, int col, u_int c, long attr) 692 { 693 struct rasops_info *ri = cookie; 694 struct vcons_screen *scr = ri->ri_hw; 695 int pos; 696 697 #ifdef WSDISPLAY_SCROLLSUPPORT 698 int offset; 699 offset = scr->scr_offset_to_zero; 700 701 if ((row >= 0) && (row < ri->ri_rows) && (col >= 0) && 702 (col < ri->ri_cols)) { 703 pos = col + row * ri->ri_cols; 704 scr->scr_attrs[pos + offset] = attr; 705 scr->scr_chars[pos + offset] = c; 706 } 707 #else 708 if ((row >= 0) && (row < ri->ri_rows) && (col >= 0) && 709 (col < ri->ri_cols)) { 710 pos = col + row * ri->ri_cols; 711 scr->scr_attrs[pos] = attr; 712 scr->scr_chars[pos] = c; 713 } 714 #endif 715 } 716 717 static void 718 vcons_putchar(void *cookie, int row, int col, u_int c, long attr) 719 { 720 struct rasops_info *ri = cookie; 721 struct vcons_screen *scr = ri->ri_hw; 722 723 vcons_putchar_buffer(cookie, row, col, c, attr); 724 725 vcons_lock(scr); 726 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 727 scr->scr_vd->putchar(cookie, row, col, c, attr); 728 } 729 vcons_unlock(scr); 730 } 731 732 static void 733 vcons_cursor(void *cookie, int on, int row, int col) 734 { 735 struct rasops_info *ri = cookie; 736 struct vcons_screen *scr = ri->ri_hw; 737 738 vcons_lock(scr); 739 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 740 scr->scr_vd->cursor(cookie, on, row, col); 741 } else { 742 scr->scr_ri.ri_crow = row; 743 scr->scr_ri.ri_ccol = col; 744 } 745 vcons_unlock(scr); 746 } 747 748 /* methods to read/write characters via ioctl() */ 749 750 static int 751 vcons_putwschar(struct vcons_screen *scr, struct wsdisplay_char *wsc) 752 { 753 long attr; 754 struct rasops_info *ri; 755 756 KASSERT(scr != NULL && wsc != NULL); 757 758 ri = &scr->scr_ri; 759 760 if (__predict_false((unsigned int)wsc->col > ri->ri_cols || 761 (unsigned int)wsc->row > ri->ri_rows)) 762 return (EINVAL); 763 764 if ((wsc->row >= 0) && (wsc->row < ri->ri_rows) && (wsc->col >= 0) && 765 (wsc->col < ri->ri_cols)) { 766 767 ri->ri_ops.allocattr(ri, wsc->foreground, wsc->background, 768 wsc->flags, &attr); 769 vcons_putchar(ri, wsc->row, wsc->col, wsc->letter, attr); 770 #ifdef VCONS_DEBUG 771 printf("vcons_putwschar(%d, %d, %x, %lx\n", wsc->row, wsc->col, 772 wsc->letter, attr); 773 #endif 774 return 0; 775 } else 776 return EINVAL; 777 } 778 779 static int 780 vcons_getwschar(struct vcons_screen *scr, struct wsdisplay_char *wsc) 781 { 782 int offset; 783 long attr; 784 struct rasops_info *ri; 785 786 KASSERT(scr != NULL && wsc != NULL); 787 788 ri = &scr->scr_ri; 789 790 if ((wsc->row >= 0) && (wsc->row < ri->ri_rows) && (wsc->col >= 0) && 791 (wsc->col < ri->ri_cols)) { 792 793 offset = ri->ri_cols * wsc->row + wsc->col; 794 #ifdef WSDISPLAY_SCROLLSUPPORT 795 offset += scr->scr_offset_to_zero; 796 #endif 797 wsc->letter = scr->scr_chars[offset]; 798 attr = scr->scr_attrs[offset]; 799 800 /* 801 * this is ugly. We need to break up an attribute into colours and 802 * flags but there's no rasops method to do that so we must rely on 803 * the 'canonical' encoding. 804 */ 805 #ifdef VCONS_DEBUG 806 printf("vcons_getwschar: %d, %d, %x, %lx\n", wsc->row, 807 wsc->col, wsc->letter, attr); 808 #endif 809 wsc->foreground = (attr >> 24) & 0xff; 810 wsc->background = (attr >> 16) & 0xff; 811 wsc->flags = attr & 0xff; 812 return 0; 813 } else 814 return EINVAL; 815 } 816 817 #ifdef WSDISPLAY_SCROLLSUPPORT 818 819 static void 820 vcons_scroll(void *cookie, void *vs, int where) 821 { 822 struct vcons_screen *scr = vs; 823 824 if (where == 0) { 825 scr->scr_line_wanted = 0; 826 } else { 827 scr->scr_line_wanted = scr->scr_line_wanted - where; 828 if (scr->scr_line_wanted < 0) 829 scr->scr_line_wanted = 0; 830 if (scr->scr_line_wanted > scr->scr_lines_in_buffer) 831 scr->scr_line_wanted = scr->scr_lines_in_buffer; 832 } 833 834 if (scr->scr_line_wanted != scr->scr_current_line) { 835 836 vcons_do_scroll(scr); 837 } 838 } 839 840 static void 841 vcons_do_scroll(struct vcons_screen *scr) 842 { 843 int dist, from, to, num; 844 int r_offset, r_start; 845 int i, j; 846 847 if (scr->scr_line_wanted == scr->scr_current_line) 848 return; 849 dist = scr->scr_line_wanted - scr->scr_current_line; 850 scr->scr_current_line = scr->scr_line_wanted; 851 scr->scr_current_offset = scr->scr_ri.ri_cols * 852 (scr->scr_lines_in_buffer - scr->scr_current_line); 853 if (abs(dist) >= scr->scr_ri.ri_rows) { 854 vcons_redraw_screen(scr); 855 return; 856 } 857 /* scroll and redraw only what we really have to */ 858 if (dist > 0) { 859 /* we scroll down */ 860 from = 0; 861 to = dist; 862 num = scr->scr_ri.ri_rows - dist; 863 /* now the redraw parameters */ 864 r_offset = scr->scr_current_offset; 865 r_start = 0; 866 } else { 867 /* scrolling up */ 868 to = 0; 869 from = -dist; 870 num = scr->scr_ri.ri_rows + dist; 871 r_offset = scr->scr_current_offset + num * scr->scr_ri.ri_cols; 872 r_start = num; 873 } 874 scr->scr_vd->copyrows(scr, from, to, num); 875 for (i = 0; i < abs(dist); i++) { 876 for (j = 0; j < scr->scr_ri.ri_cols; j++) { 877 scr->scr_vd->putchar(scr, i + r_start, j, 878 scr->scr_chars[r_offset], 879 scr->scr_attrs[r_offset]); 880 r_offset++; 881 } 882 } 883 884 if (scr->scr_line_wanted == 0) { 885 /* this was a reset - need to draw the cursor */ 886 scr->scr_ri.ri_flg &= ~RI_CURSOR; 887 scr->scr_vd->cursor(scr, 1, scr->scr_ri.ri_crow, 888 scr->scr_ri.ri_ccol); 889 } 890 } 891 892 #endif /* WSDISPLAY_SCROLLSUPPORT */ 893 894 /* async drawing using a kernel thread */ 895 896 #ifdef VCONS_SWITCH_ASYNC 897 static void 898 vcons_kthread(void *cookie) 899 { 900 struct vcons_data *vd = cookie; 901 struct vcons_screen *scr; 902 int sec = hz; 903 904 while (1) { 905 906 tsleep(&vd->start_drawing, 0, "vc_idle", sec); 907 if ((vd->wanted != vd->active) && (vd->wanted != NULL)) { 908 /* 909 * we need to switch screens 910 * so first we mark the active screen as invisible 911 * and wait until it's idle 912 */ 913 scr = vd->wanted; 914 SCREEN_INVISIBLE(vd->active); 915 while (SCREEN_IS_BUSY(vd->active)) { 916 917 tsleep(&vd->done_drawing, 0, "vc_wait", sec); 918 } 919 /* 920 * now we mark the wanted screen busy so nobody 921 * messes around while we redraw it 922 */ 923 vd->active = scr; 924 vd->wanted = NULL; 925 SCREEN_VISIBLE(scr); 926 927 if (vd->show_screen_cb != NULL) 928 vd->show_screen_cb(scr); 929 930 if ((scr->scr_flags & VCONS_NO_REDRAW) == 0) 931 vcons_redraw_screen(scr); 932 933 if (vd->switch_cb) 934 vd->switch_cb(vd->switch_cb_arg, 0, 0); 935 } 936 } 937 } 938 #endif /* VCONS_SWITCH_ASYNC */ 939
Indexes created Sat Oct 18 17:09:52 GMT 2025