wsdisplay_vcons.c revision 1.68
1 /* $NetBSD: wsdisplay_vcons.c,v 1.68 2024/02/09 22:08:37 andvar 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.68 2024/02/09 22:08:37 andvar 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 #include <sys/atomic.h> 46 #include <sys/kmem.h> 47 48 #include <dev/wscons/wsdisplayvar.h> 49 #include <dev/wscons/wsconsio.h> 50 #include <dev/wsfont/wsfont.h> 51 #include <dev/rasops/rasops.h> 52 53 #include <dev/wscons/wsdisplay_vconsvar.h> 54 55 #ifdef _KERNEL_OPT 56 #include "opt_wsemul.h" 57 #include "opt_wsdisplay_compat.h" 58 #include "opt_vcons.h" 59 #endif 60 61 #ifdef VCONS_DEBUG 62 #define DPRINTF printf 63 #else 64 #define DPRINTF if (0) printf 65 #endif 66 67 struct vcons_data_private { 68 /* accessops */ 69 int (*ioctl)(void *, void *, u_long, void *, int, struct lwp *); 70 71 /* rasops */ 72 void (*copycols)(void *, int, int, int, int); 73 void (*erasecols)(void *, int, int, int, long); 74 void (*copyrows)(void *, int, int, int); 75 void (*eraserows)(void *, int, int, long); 76 void (*cursor)(void *, int, int, int); 77 78 /* virtual screen management stuff */ 79 void (*switch_cb)(void *, int, int); 80 void *switch_cb_arg; 81 struct callout switch_callout; 82 uint32_t switch_pending; 83 LIST_HEAD(, vcons_screen) screens; 84 struct vcons_screen *wanted; 85 const struct wsscreen_descr *currenttype; 86 struct wsscreen_descr *defaulttype; 87 int switch_poll_count; 88 89 #ifdef VCONS_DRAW_INTR 90 int cells; 91 long *attrs; 92 uint32_t *chars; 93 int cursor_offset; 94 callout_t intr; 95 int intr_valid; 96 void *intr_softint; 97 int use_intr; /* use intr drawing when non-zero */ 98 #endif 99 }; 100 101 static void vcons_dummy_init_screen(void *, struct vcons_screen *, int, 102 long *); 103 104 static int vcons_ioctl(void *, void *, u_long, void *, int, struct lwp *); 105 static int vcons_alloc_screen(void *, const struct wsscreen_descr *, void **, 106 int *, int *, long *); 107 static void vcons_free_screen(void *, void *); 108 static int vcons_show_screen(void *, void *, int, void (*)(void *, int, int), 109 void *); 110 static int vcons_load_font(void *, void *, struct wsdisplay_font *); 111 112 #ifdef WSDISPLAY_SCROLLSUPPORT 113 static void vcons_scroll(void *, void *, int); 114 static void vcons_do_scroll(struct vcons_screen *); 115 #endif 116 117 static void vcons_do_switch(void *); 118 119 /* methods that work only on text buffers */ 120 static void vcons_copycols_buffer(void *, int, int, int, int); 121 static void vcons_erasecols_buffer(void *, int, int, int, long); 122 static void vcons_copyrows_buffer(void *, int, int, int); 123 static void vcons_eraserows_buffer(void *, int, int, long); 124 static int vcons_putchar_buffer(void *, int, int, u_int, long); 125 126 /* 127 * actual wrapper methods which call both the _buffer ones above and the 128 * driver supplied ones to do the drawing 129 */ 130 static void vcons_copycols(void *, int, int, int, int); 131 static void vcons_erasecols(void *, int, int, int, long); 132 static void vcons_copyrows(void *, int, int, int); 133 static void vcons_eraserows(void *, int, int, long); 134 static void vcons_putchar(void *, int, int, u_int, long); 135 #ifdef VCONS_DRAW_INTR 136 static void vcons_erasecols_cached(void *, int, int, int, long); 137 static void vcons_eraserows_cached(void *, int, int, long); 138 static void vcons_putchar_cached(void *, int, int, u_int, long); 139 #endif 140 static void vcons_cursor(void *, int, int, int); 141 static void vcons_cursor_noread(void *, int, int, int); 142 143 /* 144 * methods that avoid framebuffer reads 145 */ 146 static void vcons_copycols_noread(void *, int, int, int, int); 147 static void vcons_copyrows_noread(void *, int, int, int); 148 149 150 /* support for reading/writing text buffers. For wsmoused */ 151 static int vcons_putwschar(struct vcons_screen *, struct wsdisplay_char *); 152 static int vcons_getwschar(struct vcons_screen *, struct wsdisplay_char *); 153 154 static void vcons_lock(struct vcons_screen *); 155 static void vcons_unlock(struct vcons_screen *); 156 157 #ifdef VCONS_DRAW_INTR 158 static void vcons_intr(void *); 159 static void vcons_softintr(void *); 160 static void vcons_init_thread(void *); 161 static void vcons_invalidate_cache(struct vcons_data *); 162 #endif 163 164 static inline bool 165 vcons_use_intr(const struct vcons_screen *scr) 166 { 167 #ifdef VCONS_DRAW_INTR 168 return scr->scr_vd->private->use_intr; 169 #else 170 return false; 171 #endif 172 } 173 174 static inline void 175 vcons_dirty(struct vcons_screen *scr) 176 { 177 #ifdef VCONS_DRAW_INTR 178 membar_release(); 179 atomic_inc_uint(&scr->scr_dirty); 180 #endif 181 } 182 183 static int 184 vcons_init_common(struct vcons_data *vd, void *cookie, 185 struct wsscreen_descr *def, struct wsdisplay_accessops *ao, 186 int enable_intr) 187 { 188 struct vcons_data_private *vdp; 189 190 /* zero out everything so we can rely on untouched fields being 0 */ 191 memset(vd, 0, sizeof(struct vcons_data)); 192 193 vd->private = vdp = kmem_zalloc(sizeof(*vdp), KM_SLEEP); 194 vd->cookie = cookie; 195 196 vd->init_screen = vcons_dummy_init_screen; 197 vd->show_screen_cb = NULL; 198 199 /* keep a copy of the accessops that we replace below with our 200 * own wrappers */ 201 vdp->ioctl = ao->ioctl; 202 203 /* configure the accessops */ 204 ao->ioctl = vcons_ioctl; 205 ao->alloc_screen = vcons_alloc_screen; 206 ao->free_screen = vcons_free_screen; 207 ao->show_screen = vcons_show_screen; 208 ao->load_font = vcons_load_font; 209 #ifdef WSDISPLAY_SCROLLSUPPORT 210 ao->scroll = vcons_scroll; 211 #endif 212 213 LIST_INIT(&vdp->screens); 214 vd->active = NULL; 215 vdp->wanted = NULL; 216 vdp->currenttype = def; 217 vdp->defaulttype = def; 218 callout_init(&vdp->switch_callout, 0); 219 callout_setfunc(&vdp->switch_callout, vcons_do_switch, vd); 220 #ifdef VCONS_DRAW_INTR 221 vdp->cells = 0; 222 vdp->attrs = NULL; 223 vdp->chars = NULL; 224 vdp->cursor_offset = -1; 225 #endif 226 227 /* 228 * a lock to serialize access to the framebuffer. 229 * when switching screens we need to make sure there's no rasops 230 * operation in progress 231 */ 232 #ifdef DIAGNOSTIC 233 vdp->switch_poll_count = 0; 234 #endif 235 #ifdef VCONS_DRAW_INTR 236 if (enable_intr) { 237 vdp->intr_softint = softint_establish(SOFTINT_SERIAL, 238 vcons_softintr, vd); 239 callout_init(&vdp->intr, CALLOUT_MPSAFE); 240 callout_setfunc(&vdp->intr, vcons_intr, vd); 241 vdp->intr_valid = 1; 242 243 if (kthread_create(PRI_NONE, 0, NULL, vcons_init_thread, vd, 244 NULL, "vcons_init") != 0) { 245 printf("%s: unable to create thread.\n", __func__); 246 return -1; 247 } 248 } 249 #endif 250 return 0; 251 } 252 253 int 254 vcons_init(struct vcons_data *vd, void *cookie, 255 struct wsscreen_descr *def, struct wsdisplay_accessops *ao) 256 { 257 return vcons_init_common(vd, cookie, def, ao, 1); 258 } 259 260 int 261 vcons_earlyinit(struct vcons_data *vd, void *cookie, 262 struct wsscreen_descr *def, struct wsdisplay_accessops *ao) 263 { 264 return vcons_init_common(vd, cookie, def, ao, 0); 265 } 266 267 static void 268 vcons_lock(struct vcons_screen *scr) 269 { 270 #ifdef VCONS_PARANOIA 271 int s; 272 273 s = splhigh(); 274 #endif 275 SCREEN_BUSY(scr); 276 #ifdef VCONS_PARANOIA 277 splx(s); 278 #endif 279 } 280 281 static void 282 vcons_unlock(struct vcons_screen *scr) 283 { 284 #ifdef VCONS_PARANOIA 285 int s; 286 287 s = splhigh(); 288 #endif 289 SCREEN_IDLE(scr); 290 #ifdef VCONS_PARANOIA 291 splx(s); 292 #endif 293 } 294 295 static void 296 vcons_dummy_init_screen(void *cookie, 297 struct vcons_screen *scr, int exists, 298 long *defattr) 299 { 300 301 /* 302 * default init_screen() method. 303 * Needs to be overwritten so we bitch and whine in case anyone ends 304 * up in here. 305 */ 306 printf("vcons_init_screen: dummy function called. Your driver is " 307 "supposed to supply a replacement for proper operation\n"); 308 } 309 310 static int 311 vcons_alloc_buffers(struct vcons_data *vd, struct vcons_screen *scr) 312 { 313 struct rasops_info *ri = &scr->scr_ri; 314 int cnt, i; 315 #ifdef VCONS_DRAW_INTR 316 struct vcons_data_private *vdp = vd->private; 317 int size; 318 #endif 319 320 /* 321 * we allocate both chars and attributes in one chunk, attributes first 322 * because they have the (potentially) bigger alignment 323 */ 324 #ifdef WSDISPLAY_SCROLLSUPPORT 325 cnt = (ri->ri_rows + WSDISPLAY_SCROLLBACK_LINES) * ri->ri_cols; 326 scr->scr_lines_in_buffer = WSDISPLAY_SCROLLBACK_LINES; 327 scr->scr_current_line = 0; 328 scr->scr_line_wanted = 0; 329 scr->scr_offset_to_zero = ri->ri_cols * WSDISPLAY_SCROLLBACK_LINES; 330 scr->scr_current_offset = scr->scr_offset_to_zero; 331 #else 332 cnt = ri->ri_rows * ri->ri_cols; 333 #endif 334 scr->scr_attrs = malloc(cnt * (sizeof(long) + 335 sizeof(uint32_t)), M_DEVBUF, M_WAITOK); 336 if (scr->scr_attrs == NULL) 337 return ENOMEM; 338 339 scr->scr_chars = (uint32_t *)&scr->scr_attrs[cnt]; 340 341 /* 342 * fill the attribute buffer with *defattr, chars with 0x20 343 * since we don't know if the driver tries to mimic firmware output or 344 * reset everything we do nothing to VRAM here, any driver that feels 345 * the need to clear screen or something will have to do it on its own 346 * Additional screens will start out in the background anyway so 347 * cleaning or not only really affects the initial console screen 348 */ 349 for (i = 0; i < cnt; i++) { 350 scr->scr_attrs[i] = scr->scr_defattr; 351 scr->scr_chars[i] = 0x20; 352 } 353 354 #ifdef VCONS_DRAW_INTR 355 size = ri->ri_cols * ri->ri_rows; 356 if (size > vdp->cells) { 357 if (vdp->chars != NULL) 358 free(vdp->chars, M_DEVBUF); 359 if (vdp->attrs != NULL) 360 free(vdp->attrs, M_DEVBUF); 361 vdp->cells = size; 362 vdp->chars = malloc(size * sizeof(uint32_t), M_DEVBUF, 363 M_WAITOK|M_ZERO); 364 vdp->attrs = malloc(size * sizeof(long), M_DEVBUF, 365 M_WAITOK|M_ZERO); 366 vcons_invalidate_cache(vd); 367 } else if (SCREEN_IS_VISIBLE(scr)) 368 vcons_invalidate_cache(vd); 369 #endif 370 return 0; 371 } 372 373 int 374 vcons_init_screen(struct vcons_data *vd, struct vcons_screen *scr, 375 int existing, long *defattr) 376 { 377 struct vcons_data_private *vdp = vd->private; 378 struct rasops_info *ri = &scr->scr_ri; 379 int i; 380 381 scr->scr_cookie = vd->cookie; 382 scr->scr_vd = scr->scr_origvd = vd; 383 scr->scr_busy = 0; 384 385 if (scr->scr_type == NULL) 386 scr->scr_type = vdp->defaulttype; 387 388 /* 389 * call the driver-supplied init_screen function which is expected 390 * to set up rasops_info, override cursor() and probably others 391 */ 392 vd->init_screen(vd->cookie, scr, existing, defattr); 393 394 /* 395 * save the non virtual console aware rasops and replace them with 396 * our wrappers 397 */ 398 vdp->eraserows = ri->ri_ops.eraserows; 399 vdp->erasecols = ri->ri_ops.erasecols; 400 scr->putchar = ri->ri_ops.putchar; 401 402 if (scr->scr_flags & VCONS_NO_COPYCOLS) { 403 vdp->copycols = vcons_copycols_noread; 404 } else { 405 vdp->copycols = ri->ri_ops.copycols; 406 } 407 408 if (scr->scr_flags & VCONS_NO_COPYROWS) { 409 vdp->copyrows = vcons_copyrows_noread; 410 } else { 411 vdp->copyrows = ri->ri_ops.copyrows; 412 } 413 414 if (scr->scr_flags & VCONS_NO_CURSOR) { 415 vdp->cursor = vcons_cursor_noread; 416 } else { 417 vdp->cursor = ri->ri_ops.cursor; 418 } 419 420 ri->ri_ops.eraserows = vcons_eraserows; 421 ri->ri_ops.erasecols = vcons_erasecols; 422 ri->ri_ops.putchar = vcons_putchar; 423 ri->ri_ops.cursor = vcons_cursor; 424 ri->ri_ops.copycols = vcons_copycols; 425 ri->ri_ops.copyrows = vcons_copyrows; 426 427 428 ri->ri_hw = scr; 429 430 i = ri->ri_ops.allocattr(ri, WS_DEFAULT_FG, WS_DEFAULT_BG, 0, defattr); 431 if (i != 0) { 432 #ifdef DIAGNOSTIC 433 printf("vcons: error allocating attribute %d\n", i); 434 #endif 435 scr->scr_defattr = 0; 436 } else 437 scr->scr_defattr = *defattr; 438 439 vcons_alloc_buffers(vd, scr); 440 441 if (vd->active == NULL) { 442 vd->active = scr; 443 SCREEN_VISIBLE(scr); 444 } 445 446 if (existing) { 447 SCREEN_VISIBLE(scr); 448 vd->active = scr; 449 } else { 450 SCREEN_INVISIBLE(scr); 451 } 452 453 LIST_INSERT_HEAD(&vdp->screens, scr, next); 454 return 0; 455 } 456 457 static int 458 vcons_load_font(void *v, void *cookie, struct wsdisplay_font *f) 459 { 460 struct vcons_data *vd = v; 461 struct vcons_data_private *vdp = vd->private; 462 struct vcons_screen *scr = cookie; 463 struct rasops_info *ri; 464 struct wsdisplay_font *font; 465 int flags = WSFONT_FIND_BITMAP, fcookie; 466 467 /* see if we're asked to add a font or use it */ 468 if (scr == NULL) 469 return 0; 470 471 ri = &scr->scr_ri; 472 473 /* see if the driver knows how to handle multiple fonts */ 474 if ((scr->scr_flags & VCONS_LOADFONT) == 0) { 475 return EOPNOTSUPP; 476 } 477 478 /* now see what fonts we can use */ 479 if (ri->ri_flg & RI_ENABLE_ALPHA) { 480 flags |= WSFONT_FIND_ALPHA; 481 } 482 483 fcookie = wsfont_find(f->name, 0, 0, 0, 484 /* bitorder */ 485 scr->scr_flags & VCONS_FONT_BITS_R2L ? 486 WSDISPLAY_FONTORDER_R2L : WSDISPLAY_FONTORDER_L2R, 487 /* byteorder */ 488 scr->scr_flags & VCONS_FONT_BYTES_R2L ? 489 WSDISPLAY_FONTORDER_R2L : WSDISPLAY_FONTORDER_L2R, 490 flags); 491 if (fcookie == -1) 492 return EINVAL; 493 494 wsfont_lock(fcookie, &font); 495 if (font == NULL) 496 return EINVAL; 497 498 /* ok, we got a font. Now clear the screen with the old parameters */ 499 if (SCREEN_IS_VISIBLE(scr)) 500 vdp->eraserows(ri, 0, ri->ri_rows, scr->scr_defattr); 501 502 vcons_lock(vd->active); 503 #ifdef VCONS_DRAW_INTR 504 callout_halt(&vdp->intr, NULL); 505 #endif 506 /* set the new font and re-initialize things */ 507 ri->ri_font = font; 508 wsfont_unlock(ri->ri_wsfcookie); 509 ri->ri_wsfcookie = fcookie; 510 511 vd->init_screen(vd->cookie, scr, 1, &scr->scr_defattr); 512 DPRINTF("caps %x %x\n", scr->scr_type->capabilities, ri->ri_caps); 513 if (scr->scr_type->capabilities & WSSCREEN_RESIZE) { 514 scr->scr_type->nrows = ri->ri_rows; 515 scr->scr_type->ncols = ri->ri_cols; 516 DPRINTF("new size %d %d\n", ri->ri_rows, ri->ri_cols); 517 } 518 519 520 /* now, throw the old buffers away */ 521 if (scr->scr_attrs) 522 free(scr->scr_attrs, M_DEVBUF); 523 /* allocate new buffers */ 524 vcons_alloc_buffers(vd, scr); 525 526 /* save the potentially changed ri_ops */ 527 vdp->eraserows = ri->ri_ops.eraserows; 528 vdp->erasecols = ri->ri_ops.erasecols; 529 scr->putchar = ri->ri_ops.putchar; 530 vdp->cursor = ri->ri_ops.cursor; 531 532 if (scr->scr_flags & VCONS_NO_COPYCOLS) { 533 vdp->copycols = vcons_copycols_noread; 534 } else { 535 vdp->copycols = ri->ri_ops.copycols; 536 } 537 538 if (scr->scr_flags & VCONS_NO_COPYROWS) { 539 vdp->copyrows = vcons_copyrows_noread; 540 } else { 541 vdp->copyrows = ri->ri_ops.copyrows; 542 } 543 544 if (scr->scr_flags & VCONS_NO_CURSOR) { 545 vdp->cursor = vcons_cursor_noread; 546 } else { 547 vdp->cursor = ri->ri_ops.cursor; 548 } 549 550 /* and put our wrappers back */ 551 ri->ri_ops.eraserows = vcons_eraserows; 552 ri->ri_ops.erasecols = vcons_erasecols; 553 ri->ri_ops.putchar = vcons_putchar; 554 ri->ri_ops.cursor = vcons_cursor; 555 ri->ri_ops.copycols = vcons_copycols; 556 ri->ri_ops.copyrows = vcons_copyrows; 557 vcons_unlock(vd->active); 558 559 /* notify things that we're about to redraw */ 560 if (vd->show_screen_cb != NULL) 561 vd->show_screen_cb(scr, vd->show_screen_cookie); 562 563 #ifdef VCONS_DRAW_INTR 564 /* 565 * XXX 566 * Something(tm) craps all over VRAM somewhere up there if we're 567 * using VCONS_DRAW_INTR. Until I figure out what causes it, just 568 * redraw the screen for now. 569 */ 570 vcons_redraw_screen(vd->active); 571 callout_schedule(&vdp->intr, mstohz(33)); 572 #endif 573 /* no need to draw anything, wsdisplay should reset the terminal */ 574 575 return 0; 576 } 577 578 static void 579 vcons_do_switch(void *arg) 580 { 581 struct vcons_data *vd = arg; 582 struct vcons_data_private *vdp = vd->private; 583 struct vcons_screen *scr, *oldscr; 584 585 scr = vdp->wanted; 586 if (!scr) { 587 printf("vcons_switch_screen: disappeared\n"); 588 vdp->switch_cb(vdp->switch_cb_arg, EIO, 0); 589 return; 590 } 591 oldscr = vd->active; /* can be NULL! */ 592 593 /* 594 * if there's an old, visible screen we mark it invisible and wait 595 * until it's not busy so we can safely switch 596 */ 597 if (oldscr != NULL) { 598 SCREEN_INVISIBLE(oldscr); 599 if (SCREEN_IS_BUSY(oldscr)) { 600 callout_schedule(&vdp->switch_callout, 1); 601 #ifdef DIAGNOSTIC 602 /* bitch if we wait too long */ 603 vdp->switch_poll_count++; 604 if (vdp->switch_poll_count > 100) { 605 panic("vcons: screen still busy"); 606 } 607 #endif 608 return; 609 } 610 /* invisible screen -> no visible cursor image */ 611 oldscr->scr_ri.ri_flg &= ~RI_CURSOR; 612 #ifdef DIAGNOSTIC 613 vdp->switch_poll_count = 0; 614 #endif 615 } 616 617 if (scr == oldscr) 618 return; 619 620 #ifdef DIAGNOSTIC 621 if (SCREEN_IS_VISIBLE(scr)) 622 printf("vcons_switch_screen: already active"); 623 #endif 624 625 #ifdef notyet 626 if (vdp->currenttype != type) { 627 vcons_set_screentype(vd, type); 628 vdp->currenttype = type; 629 } 630 #endif 631 632 SCREEN_VISIBLE(scr); 633 vd->active = scr; 634 vdp->wanted = NULL; 635 636 #ifdef VCONS_DRAW_INTR 637 vcons_invalidate_cache(vd); 638 #endif 639 640 if (vd->show_screen_cb != NULL) 641 vd->show_screen_cb(scr, vd->show_screen_cookie); 642 643 if ((scr->scr_flags & VCONS_NO_REDRAW) == 0) 644 vcons_redraw_screen(scr); 645 646 if (vdp->switch_cb) 647 vdp->switch_cb(vdp->switch_cb_arg, 0, 0); 648 } 649 650 void 651 vcons_redraw_screen(struct vcons_screen *scr) 652 { 653 uint32_t *charptr = scr->scr_chars, c; 654 long *attrptr = scr->scr_attrs, a, last_a = 0, mask, cmp, acmp; 655 struct rasops_info *ri = &scr->scr_ri; 656 struct vcons_data *vd = scr->scr_vd; 657 struct vcons_data_private *vdp = vd->private; 658 int i, j, offset, boffset = 0, start = -1; 659 660 mask = 0x00ff00ff; /* background and flags */ 661 cmp = 0xffffffff; /* never match anything */ 662 vcons_lock(scr); 663 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 664 665 /* 666 * only clear the screen when RI_FULLCLEAR is set since we're 667 * going to overwrite every single character cell anyway 668 */ 669 if (ri->ri_flg & RI_FULLCLEAR) { 670 vdp->eraserows(ri, 0, ri->ri_rows, 671 scr->scr_defattr); 672 cmp = scr->scr_defattr & mask; 673 } 674 675 /* redraw the screen */ 676 #ifdef WSDISPLAY_SCROLLSUPPORT 677 offset = scr->scr_current_offset; 678 #else 679 offset = 0; 680 #endif 681 for (i = 0; i < ri->ri_rows; i++) { 682 start = -1; 683 for (j = 0; j < ri->ri_cols; j++) { 684 /* 685 * no need to use the wrapper function - we 686 * don't change any characters or attributes 687 * and we already made sure the screen we're 688 * working on is visible 689 */ 690 c = charptr[offset]; 691 a = attrptr[offset]; 692 acmp = a & mask; 693 if (c == ' ') { 694 /* 695 * if we already erased the background 696 * and if this blank uses the same 697 * colour and flags we don't need to do 698 * anything here 699 */ 700 if (acmp == cmp && start == -1) 701 goto next; 702 /* 703 * see if we can optimize things a 704 * little bit by drawing stretches of 705 * blanks using erasecols 706 */ 707 708 if (start == -1) { 709 start = j; 710 last_a = acmp; 711 } else if (acmp != last_a) { 712 /* 713 * different attr, need to 714 * flush & restart 715 */ 716 vdp->erasecols(ri, i, start, 717 j - start, last_a); 718 start = j; 719 last_a = acmp; 720 } 721 } else { 722 if (start != -1) { 723 vdp->erasecols(ri, i, start, 724 j - start, last_a); 725 start = -1; 726 } 727 728 scr->putchar(ri, i, j, c, a); 729 } 730 next: 731 #ifdef VCONS_DRAW_INTR 732 vdp->chars[boffset] = charptr[offset]; 733 vdp->attrs[boffset] = attrptr[offset]; 734 #endif 735 offset++; 736 boffset++; 737 } 738 /* end of the line - draw all deferred blanks, if any */ 739 if (start != -1) { 740 vdp->erasecols(ri, i, start, j - start, last_a); 741 } 742 } 743 ri->ri_flg &= ~RI_CURSOR; 744 scr->scr_vd->private->cursor(ri, 1, ri->ri_crow, ri->ri_ccol); 745 #ifdef VCONS_DRAW_INTR 746 vdp->cursor_offset = ri->ri_crow * ri->ri_cols + ri->ri_ccol; 747 #endif 748 } 749 vcons_unlock(scr); 750 } 751 752 void 753 vcons_update_screen(struct vcons_screen *scr) 754 { 755 #ifdef VCONS_DRAW_INTR 756 uint32_t *charptr = scr->scr_chars; 757 long *attrptr = scr->scr_attrs; 758 struct rasops_info *ri = &scr->scr_ri; 759 struct vcons_data *vd = scr->scr_vd; 760 struct vcons_data_private *vdp = vd->private; 761 int i, j, offset, boffset = 0; 762 763 vcons_lock(scr); 764 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 765 766 /* redraw the screen */ 767 #ifdef WSDISPLAY_SCROLLSUPPORT 768 offset = scr->scr_current_offset; 769 #else 770 offset = 0; 771 #endif 772 /* 773 * we mark the character cell occupied by the cursor as dirty 774 * so we don't have to deal with it 775 * notice that this isn't necessarily the position where rasops 776 * thinks it is, just where we drew it the last time 777 */ 778 if (vdp->cursor_offset >= 0) 779 vdp->attrs[vdp->cursor_offset] = 0xffffffff; 780 781 for (i = 0; i < ri->ri_rows; i++) { 782 for (j = 0; j < ri->ri_cols; j++) { 783 /* 784 * no need to use the wrapper function - we 785 * don't change any characters or attributes 786 * and we already made sure the screen we're 787 * working on is visible 788 */ 789 if ((vdp->chars[boffset] != charptr[offset]) || 790 (vdp->attrs[boffset] != attrptr[offset])) { 791 scr->putchar(ri, i, j, 792 charptr[offset], attrptr[offset]); 793 vdp->chars[boffset] = charptr[offset]; 794 vdp->attrs[boffset] = attrptr[offset]; 795 } 796 offset++; 797 boffset++; 798 } 799 } 800 ri->ri_flg &= ~RI_CURSOR; 801 scr->scr_vd->private->cursor(ri, 1, ri->ri_crow, ri->ri_ccol); 802 vdp->cursor_offset = ri->ri_crow * ri->ri_cols + ri->ri_ccol; 803 } 804 vcons_unlock(scr); 805 #else /* !VCONS_DRAW_INTR */ 806 vcons_redraw_screen(scr); 807 #endif 808 } 809 810 static int 811 vcons_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, 812 struct lwp *l) 813 { 814 struct vcons_data *vd = v; 815 struct vcons_data_private *vdp = vd->private; 816 int error = 0; 817 818 819 switch (cmd) { 820 case WSDISPLAYIO_GETWSCHAR: 821 error = vcons_getwschar((struct vcons_screen *)vs, 822 (struct wsdisplay_char *)data); 823 break; 824 825 case WSDISPLAYIO_PUTWSCHAR: 826 error = vcons_putwschar((struct vcons_screen *)vs, 827 (struct wsdisplay_char *)data); 828 break; 829 830 case WSDISPLAYIO_SET_POLLING: { 831 int poll = *(int *)data; 832 833 /* first call the driver's ioctl handler */ 834 if (vdp->ioctl != NULL) 835 error = (*vdp->ioctl)(v, vs, cmd, data, flag, l); 836 if (poll) { 837 vcons_enable_polling(vd); 838 vcons_hard_switch(LIST_FIRST(&vdp->screens)); 839 } else 840 vcons_disable_polling(vd); 841 } 842 break; 843 844 default: 845 if (vdp->ioctl != NULL) 846 error = (*vdp->ioctl)(v, vs, cmd, data, flag, l); 847 else 848 error = EPASSTHROUGH; 849 } 850 851 return error; 852 } 853 854 static int 855 vcons_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookiep, 856 int *curxp, int *curyp, long *defattrp) 857 { 858 struct vcons_data *vd = v; 859 struct vcons_data_private *vdp = vd->private; 860 struct vcons_screen *scr; 861 struct wsscreen_descr *t = __UNCONST(type); 862 int ret; 863 864 scr = malloc(sizeof(struct vcons_screen), M_DEVBUF, M_WAITOK | M_ZERO); 865 if (scr == NULL) 866 return ENOMEM; 867 868 scr->scr_flags = 0; 869 scr->scr_status = 0; 870 scr->scr_busy = 0; 871 scr->scr_type = __UNCONST(type); 872 873 ret = vcons_init_screen(vd, scr, 0, defattrp); 874 if (ret != 0) { 875 free(scr, M_DEVBUF); 876 return ret; 877 } 878 if (t->capabilities & WSSCREEN_RESIZE) { 879 t->nrows = scr->scr_ri.ri_rows; 880 t->ncols = scr->scr_ri.ri_cols; 881 } 882 883 if (vd->active == NULL) { 884 SCREEN_VISIBLE(scr); 885 vd->active = scr; 886 vdp->currenttype = type; 887 } 888 889 *cookiep = scr; 890 *curxp = scr->scr_ri.ri_ccol; 891 *curyp = scr->scr_ri.ri_crow; 892 return 0; 893 } 894 895 static void 896 vcons_free_screen(void *v, void *cookie) 897 { 898 struct vcons_data *vd = v; 899 struct vcons_screen *scr = cookie; 900 901 vcons_lock(scr); 902 /* there should be no rasops activity here */ 903 904 LIST_REMOVE(scr, next); 905 906 if ((scr->scr_flags & VCONS_SCREEN_IS_STATIC) == 0) { 907 free(scr->scr_attrs, M_DEVBUF); 908 free(scr, M_DEVBUF); 909 } else { 910 /* 911 * maybe we should just restore the old rasops_info methods 912 * and free the character/attribute buffer here? 913 */ 914 #ifdef VCONS_DEBUG 915 panic("vcons_free_screen: console"); 916 #else 917 printf("vcons_free_screen: console\n"); 918 #endif 919 } 920 921 if (vd->active == scr) 922 vd->active = NULL; 923 } 924 925 static int 926 vcons_show_screen(void *v, void *cookie, int waitok, 927 void (*cb)(void *, int, int), void *cb_arg) 928 { 929 struct vcons_data *vd = v; 930 struct vcons_data_private *vdp = vd->private; 931 struct vcons_screen *scr; 932 933 scr = cookie; 934 if (scr == vd->active) 935 return 0; 936 937 vdp->wanted = scr; 938 vdp->switch_cb = cb; 939 vdp->switch_cb_arg = cb_arg; 940 if (cb) { 941 callout_schedule(&vdp->switch_callout, 0); 942 return EAGAIN; 943 } 944 945 vcons_do_switch(vd); 946 return 0; 947 } 948 949 /* wrappers for rasops_info methods */ 950 951 static void 952 vcons_copycols_buffer(void *cookie, int row, int srccol, int dstcol, int ncols) 953 { 954 struct rasops_info *ri = cookie; 955 struct vcons_screen *scr = ri->ri_hw; 956 int from = srccol + row * ri->ri_cols; 957 int to = dstcol + row * ri->ri_cols; 958 int offset = vcons_offset_to_zero(scr); 959 960 memmove(&scr->scr_attrs[offset + to], &scr->scr_attrs[offset + from], 961 ncols * sizeof(long)); 962 memmove(&scr->scr_chars[offset + to], &scr->scr_chars[offset + from], 963 ncols * sizeof(uint32_t)); 964 965 vcons_dirty(scr); 966 } 967 968 static void 969 vcons_copycols(void *cookie, int row, int srccol, int dstcol, int ncols) 970 { 971 struct rasops_info *ri = cookie; 972 struct vcons_screen *scr = ri->ri_hw; 973 974 vcons_copycols_buffer(cookie, row, srccol, dstcol, ncols); 975 976 if (vcons_use_intr(scr)) 977 return; 978 979 vcons_lock(scr); 980 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 981 #if defined(VCONS_DRAW_INTR) 982 vcons_update_screen(scr); 983 #else 984 scr->scr_vd->private->copycols(cookie, row, srccol, dstcol, 985 ncols); 986 #endif 987 } 988 vcons_unlock(scr); 989 } 990 991 static void 992 vcons_copycols_noread(void *cookie, int row, int srccol, int dstcol, int ncols) 993 { 994 struct rasops_info *ri = cookie; 995 struct vcons_screen *scr = ri->ri_hw; 996 #ifdef VCONS_DRAW_INTR 997 struct vcons_data *vd = scr->scr_vd; 998 struct vcons_data_private *vdp = vd->private; 999 #endif 1000 1001 vcons_lock(scr); 1002 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 1003 int pos, c, offset, ppos; 1004 1005 #ifdef WSDISPLAY_SCROLLSUPPORT 1006 offset = scr->scr_current_offset; 1007 #else 1008 offset = 0; 1009 #endif 1010 ppos = ri->ri_cols * row + dstcol; 1011 pos = ppos + offset; 1012 for (c = dstcol; c < (dstcol + ncols); c++) { 1013 #ifdef VCONS_DRAW_INTR 1014 if ((scr->scr_chars[pos] != vdp->chars[ppos]) || 1015 (scr->scr_attrs[pos] != vdp->attrs[ppos])) { 1016 scr->putchar(cookie, row, c, 1017 scr->scr_chars[pos], scr->scr_attrs[pos]); 1018 vdp->chars[ppos] = scr->scr_chars[pos]; 1019 vdp->attrs[ppos] = scr->scr_attrs[pos]; 1020 } 1021 #else 1022 scr->putchar(cookie, row, c, scr->scr_chars[pos], 1023 scr->scr_attrs[pos]); 1024 #endif 1025 pos++; 1026 ppos++; 1027 } 1028 if (ri->ri_crow == row && 1029 (ri->ri_ccol >= dstcol && ri->ri_ccol < (dstcol + ncols ))) 1030 ri->ri_flg &= ~RI_CURSOR; 1031 } 1032 vcons_unlock(scr); 1033 } 1034 1035 static void 1036 vcons_erasecols_buffer(void *cookie, int row, int startcol, int ncols, long fillattr) 1037 { 1038 struct rasops_info *ri = cookie; 1039 struct vcons_screen *scr = ri->ri_hw; 1040 int start = startcol + row * ri->ri_cols; 1041 int end = start + ncols, i; 1042 int offset = vcons_offset_to_zero(scr); 1043 1044 for (i = start; i < end; i++) { 1045 scr->scr_attrs[offset + i] = fillattr; 1046 scr->scr_chars[offset + i] = 0x20; 1047 } 1048 1049 vcons_dirty(scr); 1050 } 1051 1052 #ifdef VCONS_DRAW_INTR 1053 static void 1054 vcons_erasecols_cached(void *cookie, int row, int startcol, int ncols, long fillattr) 1055 { 1056 struct rasops_info *ri = cookie; 1057 struct vcons_screen *scr = ri->ri_hw; 1058 struct vcons_data *vd = scr->scr_vd; 1059 struct vcons_data_private *vdp = vd->private; 1060 int i, pos = row * ri->ri_cols + startcol; 1061 1062 vdp->erasecols(cookie, row, startcol, ncols, fillattr); 1063 for (i = pos; i < ncols; i++) { 1064 vdp->chars[i] = scr->scr_chars[i]; 1065 vdp->attrs[i] = scr->scr_attrs[i]; 1066 } 1067 } 1068 #endif 1069 1070 static void 1071 vcons_erasecols(void *cookie, int row, int startcol, int ncols, long fillattr) 1072 { 1073 struct rasops_info *ri = cookie; 1074 struct vcons_screen *scr = ri->ri_hw; 1075 1076 vcons_erasecols_buffer(cookie, row, startcol, ncols, fillattr); 1077 1078 if (vcons_use_intr(scr)) 1079 return; 1080 1081 vcons_lock(scr); 1082 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 1083 #ifdef VCONS_DRAW_INTR 1084 vcons_erasecols_cached(cookie, row, startcol, ncols, 1085 fillattr); 1086 #else 1087 scr->scr_vd->private->erasecols(cookie, row, startcol, ncols, 1088 fillattr); 1089 #endif 1090 } 1091 vcons_unlock(scr); 1092 } 1093 1094 static void 1095 vcons_copyrows_buffer(void *cookie, int srcrow, int dstrow, int nrows) 1096 { 1097 struct rasops_info *ri = cookie; 1098 struct vcons_screen *scr = ri->ri_hw; 1099 int from, to, len; 1100 int offset = vcons_offset_to_zero(scr); 1101 1102 /* do we need to scroll the back buffer? */ 1103 if (dstrow == 0 && offset != 0) { 1104 from = ri->ri_cols * srcrow; 1105 to = ri->ri_cols * dstrow; 1106 1107 memmove(&scr->scr_attrs[to], &scr->scr_attrs[from], 1108 offset * sizeof(long)); 1109 memmove(&scr->scr_chars[to], &scr->scr_chars[from], 1110 offset * sizeof(uint32_t)); 1111 } 1112 from = ri->ri_cols * srcrow + offset; 1113 to = ri->ri_cols * dstrow + offset; 1114 len = ri->ri_cols * nrows; 1115 1116 memmove(&scr->scr_attrs[to], &scr->scr_attrs[from], 1117 len * sizeof(long)); 1118 memmove(&scr->scr_chars[to], &scr->scr_chars[from], 1119 len * sizeof(uint32_t)); 1120 1121 vcons_dirty(scr); 1122 } 1123 1124 static void 1125 vcons_copyrows(void *cookie, int srcrow, int dstrow, int nrows) 1126 { 1127 struct rasops_info *ri = cookie; 1128 struct vcons_screen *scr = ri->ri_hw; 1129 1130 vcons_copyrows_buffer(cookie, srcrow, dstrow, nrows); 1131 1132 if (vcons_use_intr(scr)) 1133 return; 1134 1135 vcons_lock(scr); 1136 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 1137 #if defined(VCONS_DRAW_INTR) 1138 vcons_update_screen(scr); 1139 #else 1140 scr->scr_vd->private->copyrows(cookie, srcrow, dstrow, nrows); 1141 #endif 1142 } 1143 vcons_unlock(scr); 1144 } 1145 1146 static void 1147 vcons_copyrows_noread(void *cookie, int srcrow, int dstrow, int nrows) 1148 { 1149 struct rasops_info *ri = cookie; 1150 struct vcons_screen *scr = ri->ri_hw; 1151 #ifdef VCONS_DRAW_INTR 1152 struct vcons_data *vd = scr->scr_vd; 1153 struct vcons_data_private *vdp = vd->private; 1154 #endif 1155 vcons_lock(scr); 1156 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 1157 int pos, l, c, offset, ppos; 1158 1159 #ifdef WSDISPLAY_SCROLLSUPPORT 1160 offset = scr->scr_current_offset; 1161 #else 1162 offset = 0; 1163 #endif 1164 ppos = ri->ri_cols * dstrow; 1165 pos = ppos + offset; 1166 for (l = dstrow; l < (dstrow + nrows); l++) { 1167 for (c = 0; c < ri->ri_cols; c++) { 1168 #ifdef VCONS_DRAW_INTR 1169 if ((scr->scr_chars[pos] != vdp->chars[ppos]) || 1170 (scr->scr_attrs[pos] != vdp->attrs[ppos])) { 1171 scr->putchar(cookie, l, c, 1172 scr->scr_chars[pos], scr->scr_attrs[pos]); 1173 vdp->chars[ppos] = scr->scr_chars[pos]; 1174 vdp->attrs[ppos] = scr->scr_attrs[pos]; 1175 } 1176 #else 1177 scr->putchar(cookie, l, c, scr->scr_chars[pos], 1178 scr->scr_attrs[pos]); 1179 #endif 1180 pos++; 1181 ppos++; 1182 } 1183 } 1184 if (ri->ri_crow >= dstrow && ri->ri_crow < (dstrow + nrows)) 1185 ri->ri_flg &= ~RI_CURSOR; 1186 } 1187 vcons_unlock(scr); 1188 } 1189 1190 static void 1191 vcons_eraserows_buffer(void *cookie, int row, int nrows, long fillattr) 1192 { 1193 struct rasops_info *ri = cookie; 1194 struct vcons_screen *scr = ri->ri_hw; 1195 int offset = vcons_offset_to_zero(scr); 1196 int start, end, i; 1197 1198 start = ri->ri_cols * row + offset; 1199 end = ri->ri_cols * (row + nrows) + offset; 1200 1201 for (i = start; i < end; i++) { 1202 scr->scr_attrs[i] = fillattr; 1203 scr->scr_chars[i] = 0x20; 1204 } 1205 1206 vcons_dirty(scr); 1207 } 1208 1209 #ifdef VCONS_DRAW_INTR 1210 static void 1211 vcons_eraserows_cached(void *cookie, int row, int nrows, long fillattr) 1212 { 1213 struct rasops_info *ri = cookie; 1214 struct vcons_screen *scr = ri->ri_hw; 1215 struct vcons_data *vd = scr->scr_vd; 1216 struct vcons_data_private *vdp = vd->private; 1217 int i, pos = row * ri->ri_cols, end = (row+nrows) * ri->ri_cols; 1218 1219 for (i = pos; i < end; i++) { 1220 vdp->chars[i] = 0x20; 1221 vdp->attrs[i] = fillattr; 1222 } 1223 vdp->eraserows(cookie, row, nrows, fillattr); 1224 } 1225 #endif 1226 1227 static void 1228 vcons_eraserows(void *cookie, int row, int nrows, long fillattr) 1229 { 1230 struct rasops_info *ri = cookie; 1231 struct vcons_screen *scr = ri->ri_hw; 1232 1233 vcons_eraserows_buffer(cookie, row, nrows, fillattr); 1234 1235 if (vcons_use_intr(scr)) 1236 return; 1237 1238 vcons_lock(scr); 1239 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 1240 #ifdef VCONS_DRAW_INTR 1241 vcons_eraserows_cached(cookie, row, nrows, fillattr); 1242 #else 1243 scr->scr_vd->private->eraserows(cookie, row, nrows, fillattr); 1244 #endif 1245 } 1246 vcons_unlock(scr); 1247 } 1248 1249 static int 1250 vcons_putchar_buffer(void *cookie, int row, int col, u_int c, long attr) 1251 { 1252 struct rasops_info *ri = cookie; 1253 struct vcons_screen *scr = ri->ri_hw; 1254 int offset = vcons_offset_to_zero(scr); 1255 int pos, ret = 0; 1256 1257 if ((row >= 0) && (row < ri->ri_rows) && (col >= 0) && 1258 (col < ri->ri_cols)) { 1259 pos = col + row * ri->ri_cols; 1260 ret = (scr->scr_attrs[pos + offset] != attr) || 1261 (scr->scr_chars[pos + offset] != c); 1262 scr->scr_attrs[pos + offset] = attr; 1263 scr->scr_chars[pos + offset] = c; 1264 } 1265 1266 if (ret) 1267 vcons_dirty(scr); 1268 return ret; 1269 } 1270 1271 #ifdef VCONS_DRAW_INTR 1272 static void 1273 vcons_putchar_cached(void *cookie, int row, int col, u_int c, long attr) 1274 { 1275 struct rasops_info *ri = cookie; 1276 struct vcons_screen *scr = ri->ri_hw; 1277 struct vcons_data *vd = scr->scr_vd; 1278 struct vcons_data_private *vdp = vd->private; 1279 int pos = row * ri->ri_cols + col; 1280 1281 if ((vdp->chars == NULL) || (vdp->attrs == NULL)) { 1282 scr->putchar(cookie, row, col, c, attr); 1283 return; 1284 } 1285 if ((vdp->chars[pos] != c) || (vdp->attrs[pos] != attr)) { 1286 vdp->attrs[pos] = attr; 1287 vdp->chars[pos] = c; 1288 scr->putchar(cookie, row, col, c, attr); 1289 } 1290 } 1291 #endif 1292 1293 static void 1294 vcons_putchar(void *cookie, int row, int col, u_int c, long attr) 1295 { 1296 struct rasops_info *ri = cookie; 1297 struct vcons_screen *scr = ri->ri_hw; 1298 int need_draw; 1299 1300 need_draw = vcons_putchar_buffer(cookie, row, col, c, attr); 1301 1302 if (vcons_use_intr(scr)) 1303 return; 1304 1305 vcons_lock(scr); 1306 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 1307 #ifdef VCONS_DRAW_INTR 1308 if (need_draw) 1309 vcons_putchar_cached(cookie, row, col, c, attr); 1310 #else 1311 if (row == ri->ri_crow && col == ri->ri_ccol) { 1312 ri->ri_flg &= ~RI_CURSOR; 1313 scr->putchar(cookie, row, col, c, attr); 1314 } else if (need_draw) 1315 scr->putchar(cookie, row, col, c, attr); 1316 #endif 1317 } 1318 vcons_unlock(scr); 1319 } 1320 1321 static void 1322 vcons_cursor(void *cookie, int on, int row, int col) 1323 { 1324 struct rasops_info *ri = cookie; 1325 struct vcons_screen *scr = ri->ri_hw; 1326 1327 if (vcons_use_intr(scr)) { 1328 vcons_lock(scr); 1329 if (scr->scr_ri.ri_crow != row || scr->scr_ri.ri_ccol != col) { 1330 scr->scr_ri.ri_crow = row; 1331 scr->scr_ri.ri_ccol = col; 1332 vcons_dirty(scr); 1333 } 1334 vcons_unlock(scr); 1335 return; 1336 } 1337 1338 vcons_lock(scr); 1339 1340 if (SCREEN_IS_VISIBLE(scr) && SCREEN_CAN_DRAW(scr)) { 1341 scr->scr_vd->private->cursor(cookie, on, row, col); 1342 } else { 1343 scr->scr_ri.ri_crow = row; 1344 scr->scr_ri.ri_ccol = col; 1345 } 1346 vcons_unlock(scr); 1347 } 1348 1349 static void 1350 vcons_cursor_noread(void *cookie, int on, int row, int col) 1351 { 1352 struct rasops_info *ri = cookie; 1353 struct vcons_screen *scr = ri->ri_hw; 1354 int offset = 0, ofs; 1355 1356 #ifdef WSDISPLAY_SCROLLSUPPORT 1357 offset = scr->scr_current_offset; 1358 #endif 1359 ofs = offset + ri->ri_crow * ri->ri_cols + ri->ri_ccol; 1360 if ((ri->ri_flg & RI_CURSOR) && 1361 (((scr->scr_flags & VCONS_DONT_READ) != VCONS_DONT_READ) || on)) { 1362 scr->putchar(cookie, ri->ri_crow, ri->ri_ccol, 1363 scr->scr_chars[ofs], scr->scr_attrs[ofs]); 1364 ri->ri_flg &= ~RI_CURSOR; 1365 } 1366 ri->ri_crow = row; 1367 ri->ri_ccol = col; 1368 ofs = offset + ri->ri_crow * ri->ri_cols + ri->ri_ccol; 1369 if (on) { 1370 scr->putchar(cookie, row, col, scr->scr_chars[ofs], 1371 #ifdef VCONS_DEBUG_CURSOR_NOREAD 1372 /* draw a red cursor so we can tell which cursor() 1373 * implementation is being used */ 1374 ((scr->scr_attrs[ofs] & 0xff00ffff) ^ 0x0f000000) | 1375 0x00010000); 1376 #else 1377 scr->scr_attrs[ofs] ^ 0x0f0f0000); 1378 #endif 1379 ri->ri_flg |= RI_CURSOR; 1380 } 1381 } 1382 1383 /* methods to read/write characters via ioctl() */ 1384 1385 static int 1386 vcons_putwschar(struct vcons_screen *scr, struct wsdisplay_char *wsc) 1387 { 1388 long attr; 1389 struct rasops_info *ri; 1390 int error; 1391 1392 KASSERT(scr != NULL); 1393 KASSERT(wsc != NULL); 1394 1395 ri = &scr->scr_ri; 1396 1397 /* allow col as linear index if row == 0 */ 1398 if (wsc->row == 0) { 1399 if (wsc->col < 0 || wsc->col > (ri->ri_cols * ri->ri_rows)) 1400 return EINVAL; 1401 int rem; 1402 rem = wsc->col % ri->ri_cols; 1403 wsc->row = wsc->col / ri->ri_cols; 1404 DPRINTF("off %d -> %d, %d\n", wsc->col, rem, wsc->row); 1405 wsc->col = rem; 1406 } else { 1407 if (__predict_false(wsc->col < 0 || wsc->col >= ri->ri_cols)) 1408 return EINVAL; 1409 1410 if (__predict_false(wsc->row < 0 || wsc->row >= ri->ri_rows)) 1411 return EINVAL; 1412 } 1413 1414 error = ri->ri_ops.allocattr(ri, wsc->foreground, 1415 wsc->background, wsc->flags, &attr); 1416 if (error) 1417 return error; 1418 vcons_putchar(ri, wsc->row, wsc->col, wsc->letter, attr); 1419 DPRINTF("vcons_putwschar(%d, %d, %x, %lx\n", wsc->row, wsc->col, 1420 wsc->letter, attr); 1421 return 0; 1422 } 1423 1424 static int 1425 vcons_getwschar(struct vcons_screen *scr, struct wsdisplay_char *wsc) 1426 { 1427 int offset; 1428 long attr; 1429 struct rasops_info *ri; 1430 int fg, bg, ul; 1431 1432 KASSERT(scr != NULL); 1433 KASSERT(wsc != NULL); 1434 1435 ri = &scr->scr_ri; 1436 1437 /* allow col as linear index if row == 0 */ 1438 if (wsc->row == 0) { 1439 if (wsc->col < 0 || wsc->col > (ri->ri_cols * ri->ri_rows)) 1440 return EINVAL; 1441 int rem; 1442 rem = wsc->col % ri->ri_cols; 1443 wsc->row = wsc->col / ri->ri_cols; 1444 DPRINTF("off %d -> %d, %d\n", wsc->col, rem, wsc->row); 1445 wsc->col = rem; 1446 } else { 1447 if (__predict_false(wsc->col < 0 || wsc->col >= ri->ri_cols)) 1448 return EINVAL; 1449 1450 if (__predict_false(wsc->row < 0 || wsc->row >= ri->ri_rows)) 1451 return EINVAL; 1452 } 1453 1454 offset = ri->ri_cols * wsc->row + wsc->col; 1455 offset += vcons_offset_to_zero(scr); 1456 wsc->letter = scr->scr_chars[offset]; 1457 attr = scr->scr_attrs[offset]; 1458 1459 DPRINTF("vcons_getwschar: %d, %d, %x, %lx\n", wsc->row, 1460 wsc->col, wsc->letter, attr); 1461 1462 /* 1463 * this is ugly. We need to break up an attribute into colours and 1464 * flags but there's no rasops method to do that so we must rely on 1465 * the 'canonical' encoding. 1466 */ 1467 1468 /* only fetches underline attribute */ 1469 /* rasops_unpack_attr(attr, &fg, &bg, &ul); */ 1470 fg = (attr >> 24) & 0xf; 1471 bg = (attr >> 16) & 0xf; 1472 ul = (attr & 1); 1473 1474 wsc->foreground = fg; 1475 wsc->background = bg; 1476 1477 /* clear trashed bits and restore underline flag */ 1478 attr &= ~(WSATTR_HILIT | WSATTR_BLINK | WSATTR_UNDERLINE); 1479 if (ul) 1480 attr |= WSATTR_UNDERLINE; 1481 1482 /* restore highlight boost */ 1483 if (attr & WSATTR_HILIT) 1484 if (wsc->foreground >= 8) 1485 wsc->foreground -= 8; 1486 1487 /* we always use colors, even when not stored */ 1488 attr |= WSATTR_WSCOLORS; 1489 return 0; 1490 } 1491 1492 int 1493 vcons_offset_to_zero(const struct vcons_screen *scr) 1494 { 1495 #ifdef WSDISPLAY_SCROLLSUPPORT 1496 return scr->scr_offset_to_zero; 1497 #else 1498 return 0; 1499 #endif 1500 } 1501 1502 #ifdef WSDISPLAY_SCROLLSUPPORT 1503 1504 static void 1505 vcons_scroll(void *cookie, void *vs, int where) 1506 { 1507 struct vcons_screen *scr = vs; 1508 1509 if (where == 0) { 1510 scr->scr_line_wanted = 0; 1511 } else { 1512 scr->scr_line_wanted = scr->scr_line_wanted - where; 1513 if (scr->scr_line_wanted < 0) 1514 scr->scr_line_wanted = 0; 1515 if (scr->scr_line_wanted > scr->scr_lines_in_buffer) 1516 scr->scr_line_wanted = scr->scr_lines_in_buffer; 1517 } 1518 1519 if (scr->scr_line_wanted != scr->scr_current_line) { 1520 1521 vcons_do_scroll(scr); 1522 } 1523 } 1524 1525 static void 1526 vcons_do_scroll(struct vcons_screen *scr) 1527 { 1528 int dist, from, to, num; 1529 int r_offset, r_start; 1530 int i, j; 1531 1532 if (scr->scr_line_wanted == scr->scr_current_line) 1533 return; 1534 dist = scr->scr_line_wanted - scr->scr_current_line; 1535 scr->scr_current_line = scr->scr_line_wanted; 1536 scr->scr_current_offset = scr->scr_ri.ri_cols * 1537 (scr->scr_lines_in_buffer - scr->scr_current_line); 1538 if (abs(dist) >= scr->scr_ri.ri_rows) { 1539 vcons_redraw_screen(scr); 1540 return; 1541 } 1542 /* scroll and redraw only what we really have to */ 1543 if (dist > 0) { 1544 /* we scroll down */ 1545 from = 0; 1546 to = dist; 1547 num = scr->scr_ri.ri_rows - dist; 1548 /* now the redraw parameters */ 1549 r_offset = scr->scr_current_offset; 1550 r_start = 0; 1551 } else { 1552 /* scrolling up */ 1553 to = 0; 1554 from = -dist; 1555 num = scr->scr_ri.ri_rows + dist; 1556 r_offset = scr->scr_current_offset + num * scr->scr_ri.ri_cols; 1557 r_start = num; 1558 } 1559 scr->scr_vd->private->copyrows(scr, from, to, num); 1560 for (i = 0; i < abs(dist); i++) { 1561 for (j = 0; j < scr->scr_ri.ri_cols; j++) { 1562 #ifdef VCONS_DRAW_INTR 1563 vcons_putchar_cached(scr, i + r_start, j, 1564 scr->scr_chars[r_offset], 1565 scr->scr_attrs[r_offset]); 1566 #else 1567 scr->putchar(scr, i + r_start, j, 1568 scr->scr_chars[r_offset], 1569 scr->scr_attrs[r_offset]); 1570 #endif 1571 r_offset++; 1572 } 1573 } 1574 1575 if (scr->scr_line_wanted == 0) { 1576 /* this was a reset - need to draw the cursor */ 1577 scr->scr_ri.ri_flg &= ~RI_CURSOR; 1578 scr->scr_vd->private->cursor(scr, 1, scr->scr_ri.ri_crow, 1579 scr->scr_ri.ri_ccol); 1580 } 1581 } 1582 1583 #endif /* WSDISPLAY_SCROLLSUPPORT */ 1584 1585 #ifdef VCONS_DRAW_INTR 1586 static void 1587 vcons_intr(void *cookie) 1588 { 1589 struct vcons_data *vd = cookie; 1590 struct vcons_data_private *vdp = vd->private; 1591 1592 softint_schedule(vdp->intr_softint); 1593 } 1594 1595 static void 1596 vcons_softintr(void *cookie) 1597 { 1598 struct vcons_data *vd = cookie; 1599 struct vcons_data_private *vdp = vd->private; 1600 struct vcons_screen *scr = vd->active; 1601 unsigned int dirty; 1602 1603 if (scr && vdp->use_intr) { 1604 if (!SCREEN_IS_BUSY(scr)) { 1605 dirty = atomic_swap_uint(&scr->scr_dirty, 0); 1606 membar_acquire(); 1607 if (vdp->use_intr == 2) { 1608 if ((scr->scr_flags & VCONS_NO_REDRAW) == 0) { 1609 vdp->use_intr = 1; 1610 vcons_redraw_screen(scr); 1611 } 1612 } else if (dirty > 0) { 1613 if ((scr->scr_flags & VCONS_NO_REDRAW) == 0) 1614 vcons_update_screen(scr); 1615 } 1616 } 1617 } 1618 1619 callout_schedule(&vdp->intr, mstohz(33)); 1620 } 1621 1622 static void 1623 vcons_init_thread(void *cookie) 1624 { 1625 struct vcons_data *vd = (struct vcons_data *)cookie; 1626 struct vcons_data_private *vdp = vd->private; 1627 1628 vdp->use_intr = 2; 1629 callout_schedule(&vdp->intr, mstohz(33)); 1630 kthread_exit(0); 1631 } 1632 #endif /* VCONS_DRAW_INTR */ 1633 1634 void 1635 vcons_enable_polling(struct vcons_data *vd) 1636 { 1637 struct vcons_screen *scr = vd->active; 1638 1639 #ifdef VCONS_DRAW_INTR 1640 struct vcons_data_private *vdp = vd->private; 1641 1642 vdp->use_intr = 0; 1643 #endif 1644 1645 if (scr && !SCREEN_IS_BUSY(scr)) { 1646 if ((scr->scr_flags & VCONS_NO_REDRAW) == 0) 1647 vcons_redraw_screen(scr); 1648 } 1649 } 1650 1651 void 1652 vcons_disable_polling(struct vcons_data *vd) 1653 { 1654 #ifdef VCONS_DRAW_INTR 1655 struct vcons_data_private *vdp = vd->private; 1656 struct vcons_screen *scr = vd->active; 1657 1658 if (!vdp->intr_valid) 1659 return; 1660 1661 vdp->use_intr = 2; 1662 if (scr) 1663 vcons_dirty(scr); 1664 #endif 1665 } 1666 1667 void 1668 vcons_hard_switch(struct vcons_screen *scr) 1669 { 1670 struct vcons_data *vd = scr->scr_vd; 1671 struct vcons_data_private *vdp = vd->private; 1672 struct vcons_screen *oldscr = vd->active; 1673 1674 if (oldscr) { 1675 SCREEN_INVISIBLE(oldscr); 1676 oldscr->scr_ri.ri_flg &= ~RI_CURSOR; 1677 } 1678 SCREEN_VISIBLE(scr); 1679 vd->active = scr; 1680 vdp->wanted = NULL; 1681 1682 if (vd->show_screen_cb != NULL) 1683 vd->show_screen_cb(scr, vd->show_screen_cookie); 1684 } 1685 1686 #ifdef VCONS_DRAW_INTR 1687 static void 1688 vcons_invalidate_cache(struct vcons_data *vd) 1689 { 1690 struct vcons_data_private *vdp = vd->private; 1691 int i; 1692 1693 for (i = 0; i < vdp->cells; i++) { 1694 vdp->chars[i] = -1; 1695 vdp->attrs[i] = -1; 1696 } 1697 } 1698 #endif 1699
Indexes created Wed Sep 24 02:09:48 GMT 2025