1 /*- 2 * Copyright (c) 1994-1996 Søren Schmidt 3 * All rights reserved. 4 * 5 * Portions of this software are based in part on the work of 6 * Sascha Wildner <saw@online.de> contributed to The DragonFly Project 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer, 13 * in this position and unchanged. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. The name of the author may not be used to endorse or promote products 18 * derived from this software without specific prior written permission 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 * 31 * $DragonFly: src/usr.sbin/vidcontrol/vidcontrol.c,v 1.10 2005/03/02 06:08:29 joerg Exp $ 32 */ 33 34 #ifndef lint 35 static const char rcsid[] = 36 "$FreeBSD$"; 37 #endif /* not lint */ 38 39 #include <ctype.h> 40 #include <err.h> 41 #include <limits.h> 42 #include <stdio.h> 43 #include <stdlib.h> 44 #include <string.h> 45 #include <unistd.h> 46 #include <sys/fbio.h> 47 #include <sys/consio.h> 48 #include <sys/endian.h> 49 #include <sys/errno.h> 50 #include <sys/param.h> 51 #include <sys/types.h> 52 #include <sys/stat.h> 53 #include <sys/sysctl.h> 54 #include "path.h" 55 #include "decode.h" 56 57 58 #define DATASIZE(x) ((x).w * (x).h * 256 / 8) 59 60 /* Screen dump modes */ 61 #define DUMP_FMT_RAW 1 62 #define DUMP_FMT_TXT 2 63 /* Screen dump options */ 64 #define DUMP_FBF 0 65 #define DUMP_ALL 1 66 /* Screen dump file format revision */ 67 #define DUMP_FMT_REV 1 68 69 static const char *legal_colors[16] = { 70 "black", "blue", "green", "cyan", 71 "red", "magenta", "brown", "white", 72 "grey", "lightblue", "lightgreen", "lightcyan", 73 "lightred", "lightmagenta", "yellow", "lightwhite" 74 }; 75 76 static struct { 77 int active_vty; 78 vid_info_t console_info; 79 unsigned char screen_map[256]; 80 int video_mode_number; 81 struct video_info video_mode_info; 82 } cur_info; 83 84 struct vt4font_header { 85 uint8_t magic[8]; 86 uint8_t width; 87 uint8_t height; 88 uint16_t pad; 89 uint32_t glyph_count; 90 uint32_t map_count[4]; 91 } __packed; 92 93 static int hex = 0; 94 static int vesa_cols; 95 static int vesa_rows; 96 static int font_height; 97 static int colors_changed; 98 static int video_mode_changed; 99 static int normal_fore_color, normal_back_color; 100 static int revers_fore_color, revers_back_color; 101 static int vt4_mode = 0; 102 static struct vid_info info; 103 static struct video_info new_mode_info; 104 105 106 /* 107 * Initialize revert data. 108 * 109 * NOTE: the following parameters are not yet saved/restored: 110 * 111 * screen saver timeout 112 * cursor type 113 * mouse character and mouse show/hide state 114 * vty switching on/off state 115 * history buffer size 116 * history contents 117 * font maps 118 */ 119 120 static void 121 init(void) 122 { 123 if (ioctl(0, VT_GETACTIVE, &cur_info.active_vty) == -1) 124 errc(1, errno, "getting active vty"); 125 126 cur_info.console_info.size = sizeof(cur_info.console_info); 127 128 if (ioctl(0, CONS_GETINFO, &cur_info.console_info) == -1) 129 errc(1, errno, "getting console information"); 130 131 /* vt(4) use unicode, so no screen mapping required. */ 132 if (vt4_mode == 0 && 133 ioctl(0, GIO_SCRNMAP, &cur_info.screen_map) == -1) 134 errc(1, errno, "getting screen map"); 135 136 if (ioctl(0, CONS_GET, &cur_info.video_mode_number) == -1) 137 errc(1, errno, "getting video mode number"); 138 139 cur_info.video_mode_info.vi_mode = cur_info.video_mode_number; 140 141 if (ioctl(0, CONS_MODEINFO, &cur_info.video_mode_info) == -1) 142 errc(1, errno, "getting video mode parameters"); 143 144 normal_fore_color = cur_info.console_info.mv_norm.fore; 145 normal_back_color = cur_info.console_info.mv_norm.back; 146 revers_fore_color = cur_info.console_info.mv_rev.fore; 147 revers_back_color = cur_info.console_info.mv_rev.back; 148 } 149 150 151 /* 152 * If something goes wrong along the way we call revert() to go back to the 153 * console state we came from (which is assumed to be working). 154 * 155 * NOTE: please also read the comments of init(). 156 */ 157 158 static void 159 revert(void) 160 { 161 int size[3]; 162 163 ioctl(0, VT_ACTIVATE, cur_info.active_vty); 164 165 fprintf(stderr, "\033[=%dA", cur_info.console_info.mv_ovscan); 166 fprintf(stderr, "\033[=%dF", cur_info.console_info.mv_norm.fore); 167 fprintf(stderr, "\033[=%dG", cur_info.console_info.mv_norm.back); 168 fprintf(stderr, "\033[=%dH", cur_info.console_info.mv_rev.fore); 169 fprintf(stderr, "\033[=%dI", cur_info.console_info.mv_rev.back); 170 171 if (vt4_mode == 0) 172 ioctl(0, PIO_SCRNMAP, &cur_info.screen_map); 173 174 if (cur_info.video_mode_number >= M_VESA_BASE) 175 ioctl(0, _IO('V', cur_info.video_mode_number - M_VESA_BASE), 176 NULL); 177 else 178 ioctl(0, _IO('S', cur_info.video_mode_number), NULL); 179 180 if (cur_info.video_mode_info.vi_flags & V_INFO_GRAPHICS) { 181 size[0] = cur_info.video_mode_info.vi_width / 8; 182 size[1] = cur_info.video_mode_info.vi_height / 183 cur_info.console_info.font_size; 184 size[2] = cur_info.console_info.font_size; 185 186 ioctl(0, KDRASTER, size); 187 } 188 } 189 190 191 /* 192 * Print a short usage string describing all options, then exit. 193 */ 194 195 static void 196 usage(void) 197 { 198 if (vt4_mode) 199 fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n", 200 "usage: vidcontrol [-CHPpx] [-b color] [-c appearance] [-f [size] file]", 201 " [-g geometry] [-h size] [-i adapter | mode]", 202 " [-M char] [-m on | off] [-r foreground background]", 203 " [-S on | off] [-s number] [-T xterm | cons25] [-t N | off]", 204 " [mode] [foreground [background]] [show]"); 205 else 206 fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n", 207 "usage: vidcontrol [-CdHLPpx] [-b color] [-c appearance] [-f [size] file]", 208 " [-g geometry] [-h size] [-i adapter | mode] [-l screen_map]", 209 " [-M char] [-m on | off] [-r foreground background]", 210 " [-S on | off] [-s number] [-T xterm | cons25] [-t N | off]", 211 " [mode] [foreground [background]] [show]"); 212 exit(1); 213 } 214 215 /* Detect presence of vt(4). */ 216 static int 217 is_vt4(void) 218 { 219 220 if (sysctlbyname("kern.vt.deadtimer", NULL, NULL, NULL, 0) == 0) 221 return (1); 222 223 return (0); 224 } 225 226 /* 227 * Retrieve the next argument from the command line (for options that require 228 * more than one argument). 229 */ 230 231 static char * 232 nextarg(int ac, char **av, int *indp, int oc, int strict) 233 { 234 if (*indp < ac) 235 return(av[(*indp)++]); 236 237 if (strict != 0) { 238 revert(); 239 errx(1, "option requires two arguments -- %c", oc); 240 } 241 242 return(NULL); 243 } 244 245 246 /* 247 * Guess which file to open. Try to open each combination of a specified set 248 * of file name components. 249 */ 250 251 static FILE * 252 openguess(const char *a[], const char *b[], const char *c[], const char *d[], char **name) 253 { 254 FILE *f; 255 int i, j, k, l; 256 257 for (i = 0; a[i] != NULL; i++) { 258 for (j = 0; b[j] != NULL; j++) { 259 for (k = 0; c[k] != NULL; k++) { 260 for (l = 0; d[l] != NULL; l++) { 261 asprintf(name, "%s%s%s%s", 262 a[i], b[j], c[k], d[l]); 263 264 f = fopen(*name, "r"); 265 266 if (f != NULL) 267 return (f); 268 269 free(*name); 270 } 271 } 272 } 273 } 274 return (NULL); 275 } 276 277 278 /* 279 * Load a screenmap from a file and set it. 280 */ 281 282 static void 283 load_scrnmap(const char *filename) 284 { 285 FILE *fd; 286 int size; 287 char *name; 288 scrmap_t scrnmap; 289 const char *a[] = {"", SCRNMAP_PATH, NULL}; 290 const char *b[] = {filename, NULL}; 291 const char *c[] = {"", ".scm", NULL}; 292 const char *d[] = {"", NULL}; 293 294 fd = openguess(a, b, c, d, &name); 295 296 if (fd == NULL) { 297 revert(); 298 errx(1, "screenmap file not found"); 299 } 300 301 size = sizeof(scrnmap); 302 303 if (decode(fd, (char *)&scrnmap, size) != size) { 304 rewind(fd); 305 306 if (fread(&scrnmap, 1, size, fd) != (size_t)size) { 307 warnx("bad screenmap file"); 308 fclose(fd); 309 revert(); 310 errx(1, "bad screenmap file"); 311 } 312 } 313 314 if (ioctl(0, PIO_SCRNMAP, &scrnmap) == -1) { 315 revert(); 316 errc(1, errno, "loading screenmap"); 317 } 318 319 fclose(fd); 320 } 321 322 323 /* 324 * Set the default screenmap. 325 */ 326 327 static void 328 load_default_scrnmap(void) 329 { 330 scrmap_t scrnmap; 331 int i; 332 333 for (i=0; i<256; i++) 334 *((char*)&scrnmap + i) = i; 335 336 if (ioctl(0, PIO_SCRNMAP, &scrnmap) == -1) { 337 revert(); 338 errc(1, errno, "loading default screenmap"); 339 } 340 } 341 342 343 /* 344 * Print the current screenmap to stdout. 345 */ 346 347 static void 348 print_scrnmap(void) 349 { 350 unsigned char map[256]; 351 size_t i; 352 353 if (ioctl(0, GIO_SCRNMAP, &map) == -1) { 354 revert(); 355 errc(1, errno, "getting screenmap"); 356 } 357 for (i=0; i<sizeof(map); i++) { 358 if (i != 0 && i % 16 == 0) 359 fprintf(stdout, "\n"); 360 361 if (hex != 0) 362 fprintf(stdout, " %02x", map[i]); 363 else 364 fprintf(stdout, " %03d", map[i]); 365 } 366 fprintf(stdout, "\n"); 367 368 } 369 370 371 /* 372 * Determine a file's size. 373 */ 374 375 static int 376 fsize(FILE *file) 377 { 378 struct stat sb; 379 380 if (fstat(fileno(file), &sb) == 0) 381 return sb.st_size; 382 else 383 return -1; 384 } 385 386 static vfnt_map_t * 387 load_vt4mappingtable(unsigned int nmappings, FILE *f) 388 { 389 vfnt_map_t *t; 390 unsigned int i; 391 392 if (nmappings == 0) 393 return (NULL); 394 395 t = malloc(sizeof *t * nmappings); 396 397 if (fread(t, sizeof *t * nmappings, 1, f) != 1) { 398 perror("mappings"); 399 exit(1); 400 } 401 402 for (i = 0; i < nmappings; i++) { 403 t[i].src = be32toh(t[i].src); 404 t[i].dst = be16toh(t[i].dst); 405 t[i].len = be16toh(t[i].len); 406 } 407 408 return (t); 409 } 410 411 static int 412 load_vt4font(FILE *f) 413 { 414 struct vt4font_header fh; 415 static vfnt_t vfnt; 416 size_t glyphsize; 417 unsigned int i; 418 419 if (fread(&fh, sizeof fh, 1, f) != 1) { 420 perror("file_header"); 421 return (1); 422 } 423 424 if (memcmp(fh.magic, "VFNT0002", 8) != 0) { 425 fprintf(stderr, "Bad magic\n"); 426 return (1); 427 } 428 429 for (i = 0; i < VFNT_MAPS; i++) 430 vfnt.map_count[i] = be32toh(fh.map_count[i]); 431 vfnt.glyph_count = be32toh(fh.glyph_count); 432 vfnt.width = fh.width; 433 vfnt.height = fh.height; 434 435 glyphsize = howmany(vfnt.width, 8) * vfnt.height * vfnt.glyph_count; 436 vfnt.glyphs = malloc(glyphsize); 437 438 if (fread(vfnt.glyphs, glyphsize, 1, f) != 1) { 439 perror("glyphs"); 440 return (1); 441 } 442 443 for (i = 0; i < VFNT_MAPS; i++) 444 vfnt.map[i] = load_vt4mappingtable(vfnt.map_count[i], f); 445 446 if (ioctl(STDIN_FILENO, PIO_VFONT, &vfnt) == -1) { 447 perror("PIO_VFONT"); 448 return (1); 449 } 450 return (0); 451 } 452 453 /* 454 * Load a font from file and set it. 455 */ 456 457 static void 458 load_font(const char *type, const char *filename) 459 { 460 FILE *fd; 461 int h, i, size, w; 462 unsigned long io = 0; /* silence stupid gcc(1) in the Wall mode */ 463 char *name, *fontmap, size_sufx[6]; 464 const char *a[] = {"", FONT_PATH, NULL}; 465 const char *vt4a[] = {"", VT_FONT_PATH, NULL}; 466 const char *b[] = {filename, NULL}; 467 const char *c[] = {"", size_sufx, NULL}; 468 const char *d[] = {"", ".fnt", NULL}; 469 vid_info_t _info; 470 471 struct sizeinfo { 472 int w; 473 int h; 474 unsigned long io; 475 } sizes[] = {{8, 16, PIO_FONT8x16}, 476 {8, 14, PIO_FONT8x14}, 477 {8, 8, PIO_FONT8x8}, 478 {0, 0, 0}}; 479 480 if (vt4_mode) { 481 size_sufx[0] = '\0'; 482 } else { 483 _info.size = sizeof(_info); 484 if (ioctl(0, CONS_GETINFO, &_info) == -1) { 485 revert(); 486 warn("failed to obtain current video mode parameters"); 487 return; 488 } 489 490 snprintf(size_sufx, sizeof(size_sufx), "-8x%d", _info.font_size); 491 } 492 fd = openguess((vt4_mode == 0) ? a : vt4a, b, c, d, &name); 493 494 if (fd == NULL) { 495 revert(); 496 errx(1, "%s: can't load font file", filename); 497 } 498 499 if (vt4_mode) { 500 if(load_vt4font(fd)) 501 warn("failed to load font \"%s\"", filename); 502 fclose(fd); 503 return; 504 } 505 506 if (type != NULL) { 507 size = 0; 508 if (sscanf(type, "%dx%d", &w, &h) == 2) { 509 for (i = 0; sizes[i].w != 0; i++) { 510 if (sizes[i].w == w && sizes[i].h == h) { 511 size = DATASIZE(sizes[i]); 512 io = sizes[i].io; 513 font_height = sizes[i].h; 514 } 515 } 516 } 517 if (size == 0) { 518 fclose(fd); 519 revert(); 520 errx(1, "%s: bad font size specification", type); 521 } 522 } else { 523 /* Apply heuristics */ 524 525 int j; 526 int dsize[2]; 527 528 size = DATASIZE(sizes[0]); 529 fontmap = (char*) malloc(size); 530 dsize[0] = decode(fd, fontmap, size); 531 dsize[1] = fsize(fd); 532 free(fontmap); 533 534 size = 0; 535 for (j = 0; j < 2; j++) { 536 for (i = 0; sizes[i].w != 0; i++) { 537 if (DATASIZE(sizes[i]) == dsize[j]) { 538 size = dsize[j]; 539 io = sizes[i].io; 540 font_height = sizes[i].h; 541 j = 2; /* XXX */ 542 break; 543 } 544 } 545 } 546 547 if (size == 0) { 548 fclose(fd); 549 revert(); 550 errx(1, "%s: can't guess font size", filename); 551 } 552 553 rewind(fd); 554 } 555 556 fontmap = (char*) malloc(size); 557 558 if (decode(fd, fontmap, size) != size) { 559 rewind(fd); 560 if (fsize(fd) != size || 561 fread(fontmap, 1, size, fd) != (size_t)size) { 562 warnx("%s: bad font file", filename); 563 fclose(fd); 564 free(fontmap); 565 revert(); 566 errx(1, "%s: bad font file", filename); 567 } 568 } 569 570 if (ioctl(0, io, fontmap) == -1) { 571 revert(); 572 errc(1, errno, "loading font"); 573 } 574 575 fclose(fd); 576 free(fontmap); 577 } 578 579 580 /* 581 * Set the timeout for the screensaver. 582 */ 583 584 static void 585 set_screensaver_timeout(char *arg) 586 { 587 int nsec; 588 589 if (!strcmp(arg, "off")) { 590 nsec = 0; 591 } else { 592 nsec = atoi(arg); 593 594 if ((*arg == '\0') || (nsec < 1)) { 595 revert(); 596 errx(1, "argument must be a positive number"); 597 } 598 } 599 600 if (ioctl(0, CONS_BLANKTIME, &nsec) == -1) { 601 revert(); 602 errc(1, errno, "setting screensaver period"); 603 } 604 } 605 606 607 /* 608 * Set the cursor's shape/type. 609 */ 610 611 static void 612 set_cursor_type(char *appearance) 613 { 614 int type; 615 616 if (!strcmp(appearance, "normal")) 617 type = 0; 618 else if (!strcmp(appearance, "blink")) 619 type = 1; 620 else if (!strcmp(appearance, "destructive")) 621 type = 3; 622 else { 623 revert(); 624 errx(1, "argument to -c must be normal, blink or destructive"); 625 } 626 627 if (ioctl(0, CONS_CURSORTYPE, &type) == -1) { 628 revert(); 629 errc(1, errno, "setting cursor type"); 630 } 631 } 632 633 634 /* 635 * Set the video mode. 636 */ 637 638 static int 639 video_mode(int argc, char **argv, int *mode_index) 640 { 641 static struct { 642 const char *name; 643 unsigned long mode; 644 unsigned long mode_num; 645 } modes[] = { 646 { "80x25", SW_TEXT_80x25, M_TEXT_80x25 }, 647 { "80x30", SW_TEXT_80x30, M_TEXT_80x30 }, 648 { "80x43", SW_TEXT_80x43, M_TEXT_80x43 }, 649 { "80x50", SW_TEXT_80x50, M_TEXT_80x50 }, 650 { "80x60", SW_TEXT_80x60, M_TEXT_80x60 }, 651 { "132x25", SW_TEXT_132x25, M_TEXT_132x25 }, 652 { "132x30", SW_TEXT_132x30, M_TEXT_132x30 }, 653 { "132x43", SW_TEXT_132x43, M_TEXT_132x43 }, 654 { "132x50", SW_TEXT_132x50, M_TEXT_132x50 }, 655 { "132x60", SW_TEXT_132x60, M_TEXT_132x60 }, 656 { "VGA_40x25", SW_VGA_C40x25, M_VGA_C40x25 }, 657 { "VGA_80x25", SW_VGA_C80x25, M_VGA_C80x25 }, 658 { "VGA_80x30", SW_VGA_C80x30, M_VGA_C80x30 }, 659 { "VGA_80x50", SW_VGA_C80x50, M_VGA_C80x50 }, 660 { "VGA_80x60", SW_VGA_C80x60, M_VGA_C80x60 }, 661 #ifdef SW_VGA_C90x25 662 { "VGA_90x25", SW_VGA_C90x25, M_VGA_C90x25 }, 663 { "VGA_90x30", SW_VGA_C90x30, M_VGA_C90x30 }, 664 { "VGA_90x43", SW_VGA_C90x43, M_VGA_C90x43 }, 665 { "VGA_90x50", SW_VGA_C90x50, M_VGA_C90x50 }, 666 { "VGA_90x60", SW_VGA_C90x60, M_VGA_C90x60 }, 667 #endif 668 { "VGA_320x200", SW_VGA_CG320, M_CG320 }, 669 { "EGA_80x25", SW_ENH_C80x25, M_ENH_C80x25 }, 670 { "EGA_80x43", SW_ENH_C80x43, M_ENH_C80x43 }, 671 { "VESA_132x25", SW_VESA_C132x25,M_VESA_C132x25 }, 672 { "VESA_132x43", SW_VESA_C132x43,M_VESA_C132x43 }, 673 { "VESA_132x50", SW_VESA_C132x50,M_VESA_C132x50 }, 674 { "VESA_132x60", SW_VESA_C132x60,M_VESA_C132x60 }, 675 { "VESA_800x600", SW_VESA_800x600,M_VESA_800x600 }, 676 { NULL, 0, 0 }, 677 }; 678 679 int new_mode_num = 0; 680 unsigned long mode = 0; 681 int cur_mode; 682 int ioerr; 683 int size[3]; 684 int i; 685 686 if (ioctl(0, CONS_GET, &cur_mode) < 0) 687 err(1, "cannot get the current video mode"); 688 689 /* 690 * Parse the video mode argument... 691 */ 692 693 if (*mode_index < argc) { 694 if (!strncmp(argv[*mode_index], "MODE_", 5)) { 695 if (!isdigit(argv[*mode_index][5])) 696 errx(1, "invalid video mode number"); 697 698 new_mode_num = atoi(&argv[*mode_index][5]); 699 } else { 700 for (i = 0; modes[i].name != NULL; ++i) { 701 if (!strcmp(argv[*mode_index], modes[i].name)) { 702 mode = modes[i].mode; 703 new_mode_num = modes[i].mode_num; 704 break; 705 } 706 } 707 708 if (modes[i].name == NULL) 709 return EXIT_FAILURE; 710 if (ioctl(0, mode, NULL) < 0) { 711 warn("cannot set videomode"); 712 return EXIT_FAILURE; 713 } 714 } 715 716 /* 717 * Collect enough information about the new video mode... 718 */ 719 720 new_mode_info.vi_mode = new_mode_num; 721 722 if (ioctl(0, CONS_MODEINFO, &new_mode_info) == -1) { 723 revert(); 724 errc(1, errno, "obtaining new video mode parameters"); 725 } 726 727 if (mode == 0) { 728 if (new_mode_num >= M_VESA_BASE) 729 mode = _IO('V', new_mode_num - M_VESA_BASE); 730 else 731 mode = _IO('S', new_mode_num); 732 } 733 734 /* 735 * Try setting the new mode. 736 */ 737 738 if (ioctl(0, mode, NULL) == -1) { 739 revert(); 740 errc(1, errno, "setting video mode"); 741 } 742 743 /* 744 * For raster modes it's not enough to just set the mode. 745 * We also need to explicitly set the raster mode. 746 */ 747 748 if (new_mode_info.vi_flags & V_INFO_GRAPHICS) { 749 /* font size */ 750 751 if (font_height == 0) 752 font_height = cur_info.console_info.font_size; 753 754 size[2] = font_height; 755 756 /* adjust columns */ 757 758 if ((vesa_cols * 8 > new_mode_info.vi_width) || 759 (vesa_cols <= 0)) { 760 size[0] = new_mode_info.vi_width / 8; 761 } else { 762 size[0] = vesa_cols; 763 } 764 765 /* adjust rows */ 766 767 if ((vesa_rows * font_height > new_mode_info.vi_height) || 768 (vesa_rows <= 0)) { 769 size[1] = new_mode_info.vi_height / 770 font_height; 771 } else { 772 size[1] = vesa_rows; 773 } 774 775 /* set raster mode */ 776 777 if (ioctl(0, KDRASTER, size)) { 778 ioerr = errno; 779 if (cur_mode >= M_VESA_BASE) 780 ioctl(0, 781 _IO('V', cur_mode - M_VESA_BASE), 782 NULL); 783 else 784 ioctl(0, _IO('S', cur_mode), NULL); 785 revert(); 786 warnc(ioerr, "cannot activate raster display"); 787 return EXIT_FAILURE; 788 } 789 } 790 791 video_mode_changed = 1; 792 793 (*mode_index)++; 794 } 795 return EXIT_SUCCESS; 796 } 797 798 799 /* 800 * Return the number for a specified color name. 801 */ 802 803 static int 804 get_color_number(char *color) 805 { 806 int i; 807 808 for (i=0; i<16; i++) { 809 if (!strcmp(color, legal_colors[i])) 810 return i; 811 } 812 return -1; 813 } 814 815 816 /* 817 * Get normal text and background colors. 818 */ 819 820 static void 821 get_normal_colors(int argc, char **argv, int *_index) 822 { 823 int color; 824 825 if (*_index < argc && (color = get_color_number(argv[*_index])) != -1) { 826 (*_index)++; 827 fprintf(stderr, "\033[=%dF", color); 828 normal_fore_color=color; 829 colors_changed = 1; 830 if (*_index < argc 831 && (color = get_color_number(argv[*_index])) != -1 832 && color < 8) { 833 (*_index)++; 834 fprintf(stderr, "\033[=%dG", color); 835 normal_back_color=color; 836 } 837 } 838 } 839 840 841 /* 842 * Get reverse text and background colors. 843 */ 844 845 static void 846 get_reverse_colors(int argc, char **argv, int *_index) 847 { 848 int color; 849 850 if ((color = get_color_number(argv[*(_index)-1])) != -1) { 851 fprintf(stderr, "\033[=%dH", color); 852 revers_fore_color=color; 853 colors_changed = 1; 854 if (*_index < argc 855 && (color = get_color_number(argv[*_index])) != -1 856 && color < 8) { 857 (*_index)++; 858 fprintf(stderr, "\033[=%dI", color); 859 revers_back_color=color; 860 } 861 } 862 } 863 864 865 /* 866 * Set normal and reverse foreground and background colors. 867 */ 868 869 static void 870 set_colors(void) 871 { 872 fprintf(stderr, "\033[=%dF", normal_fore_color); 873 fprintf(stderr, "\033[=%dG", normal_back_color); 874 fprintf(stderr, "\033[=%dH", revers_fore_color); 875 fprintf(stderr, "\033[=%dI", revers_back_color); 876 } 877 878 879 /* 880 * Switch to virtual terminal #arg. 881 */ 882 883 static void 884 set_console(char *arg) 885 { 886 int n; 887 888 if(!arg || strspn(arg,"0123456789") != strlen(arg)) { 889 revert(); 890 errx(1, "bad console number"); 891 } 892 893 n = atoi(arg); 894 895 if (n < 1 || n > 16) { 896 revert(); 897 errx(1, "console number out of range"); 898 } else if (ioctl(0, VT_ACTIVATE, n) == -1) { 899 revert(); 900 errc(1, errno, "switching vty"); 901 } 902 } 903 904 905 /* 906 * Sets the border color. 907 */ 908 909 static void 910 set_border_color(char *arg) 911 { 912 int color; 913 914 if ((color = get_color_number(arg)) != -1) { 915 fprintf(stderr, "\033[=%dA", color); 916 } 917 else 918 usage(); 919 } 920 921 static void 922 set_mouse_char(char *arg) 923 { 924 struct mouse_info mouse; 925 long l; 926 927 l = strtol(arg, NULL, 0); 928 929 if ((l < 0) || (l > UCHAR_MAX - 3)) { 930 revert(); 931 warnx("argument to -M must be 0 through %d", UCHAR_MAX - 3); 932 return; 933 } 934 935 mouse.operation = MOUSE_MOUSECHAR; 936 mouse.u.mouse_char = (int)l; 937 938 if (ioctl(0, CONS_MOUSECTL, &mouse) == -1) { 939 revert(); 940 errc(1, errno, "setting mouse character"); 941 } 942 } 943 944 945 /* 946 * Show/hide the mouse. 947 */ 948 949 static void 950 set_mouse(char *arg) 951 { 952 struct mouse_info mouse; 953 954 if (!strcmp(arg, "on")) { 955 mouse.operation = MOUSE_SHOW; 956 } else if (!strcmp(arg, "off")) { 957 mouse.operation = MOUSE_HIDE; 958 } else { 959 revert(); 960 errx(1, "argument to -m must be either on or off"); 961 } 962 963 if (ioctl(0, CONS_MOUSECTL, &mouse) == -1) { 964 revert(); 965 errc(1, errno, "%sing the mouse", 966 mouse.operation == MOUSE_SHOW ? "show" : "hid"); 967 } 968 } 969 970 971 static void 972 set_lockswitch(char *arg) 973 { 974 int data; 975 976 if (!strcmp(arg, "off")) { 977 data = 0x01; 978 } else if (!strcmp(arg, "on")) { 979 data = 0x02; 980 } else { 981 revert(); 982 errx(1, "argument to -S must be either on or off"); 983 } 984 985 if (ioctl(0, VT_LOCKSWITCH, &data) == -1) { 986 revert(); 987 errc(1, errno, "turning %s vty switching", 988 data == 0x01 ? "off" : "on"); 989 } 990 } 991 992 993 /* 994 * Return the adapter name for a specified type. 995 */ 996 997 static const char 998 *adapter_name(int type) 999 { 1000 static struct { 1001 int type; 1002 const char *name; 1003 } names[] = { 1004 { KD_MONO, "MDA" }, 1005 { KD_HERCULES, "Hercules" }, 1006 { KD_CGA, "CGA" }, 1007 { KD_EGA, "EGA" }, 1008 { KD_VGA, "VGA" }, 1009 { KD_PC98, "PC-98xx" }, 1010 { KD_TGA, "TGA" }, 1011 { -1, "Unknown" }, 1012 }; 1013 1014 int i; 1015 1016 for (i = 0; names[i].type != -1; ++i) 1017 if (names[i].type == type) 1018 break; 1019 return names[i].name; 1020 } 1021 1022 1023 /* 1024 * Show graphics adapter information. 1025 */ 1026 1027 static void 1028 show_adapter_info(void) 1029 { 1030 struct video_adapter_info ad; 1031 1032 ad.va_index = 0; 1033 1034 if (ioctl(0, CONS_ADPINFO, &ad) == -1) { 1035 revert(); 1036 errc(1, errno, "obtaining adapter information"); 1037 } 1038 1039 printf("fb%d:\n", ad.va_index); 1040 printf(" %.*s%d, type:%s%s (%d), flags:0x%x\n", 1041 (int)sizeof(ad.va_name), ad.va_name, ad.va_unit, 1042 (ad.va_flags & V_ADP_VESA) ? "VESA " : "", 1043 adapter_name(ad.va_type), ad.va_type, ad.va_flags); 1044 printf(" initial mode:%d, current mode:%d, BIOS mode:%d\n", 1045 ad.va_initial_mode, ad.va_mode, ad.va_initial_bios_mode); 1046 printf(" frame buffer window:0x%zx, buffer size:0x%zx\n", 1047 ad.va_window, ad.va_buffer_size); 1048 printf(" window size:0x%zx, origin:0x%x\n", 1049 ad.va_window_size, ad.va_window_orig); 1050 printf(" display start address (%d, %d), scan line width:%d\n", 1051 ad.va_disp_start.x, ad.va_disp_start.y, ad.va_line_width); 1052 printf(" reserved:0x%zx\n", ad.va_unused0); 1053 } 1054 1055 1056 /* 1057 * Show video mode information. 1058 */ 1059 1060 static void 1061 show_mode_info(void) 1062 { 1063 char buf[80]; 1064 struct video_info _info; 1065 int c; 1066 int mm; 1067 int mode; 1068 1069 printf(" mode# flags type size " 1070 "font window linear buffer\n"); 1071 printf("---------------------------------------" 1072 "---------------------------------------\n"); 1073 1074 for (mode = 0; mode <= M_VESA_MODE_MAX; ++mode) { 1075 _info.vi_mode = mode; 1076 if (ioctl(0, CONS_MODEINFO, &_info)) 1077 continue; 1078 if (_info.vi_mode != mode) 1079 continue; 1080 1081 printf("%3d (0x%03x)", mode, mode); 1082 printf(" 0x%08x", _info.vi_flags); 1083 if (_info.vi_flags & V_INFO_GRAPHICS) { 1084 c = 'G'; 1085 1086 if (_info.vi_mem_model == V_INFO_MM_PLANAR) 1087 snprintf(buf, sizeof(buf), "%dx%dx%d %d", 1088 _info.vi_width, _info.vi_height, 1089 _info.vi_depth, _info.vi_planes); 1090 else { 1091 switch (_info.vi_mem_model) { 1092 case V_INFO_MM_PACKED: 1093 mm = 'P'; 1094 break; 1095 case V_INFO_MM_DIRECT: 1096 mm = 'D'; 1097 break; 1098 case V_INFO_MM_CGA: 1099 mm = 'C'; 1100 break; 1101 case V_INFO_MM_HGC: 1102 mm = 'H'; 1103 break; 1104 case V_INFO_MM_VGAX: 1105 mm = 'V'; 1106 break; 1107 default: 1108 mm = ' '; 1109 break; 1110 } 1111 snprintf(buf, sizeof(buf), "%dx%dx%d %c", 1112 _info.vi_width, _info.vi_height, 1113 _info.vi_depth, mm); 1114 } 1115 } else { 1116 c = 'T'; 1117 1118 snprintf(buf, sizeof(buf), "%dx%d", 1119 _info.vi_width, _info.vi_height); 1120 } 1121 1122 printf(" %c %-15s", c, buf); 1123 snprintf(buf, sizeof(buf), "%dx%d", 1124 _info.vi_cwidth, _info.vi_cheight); 1125 printf(" %-5s", buf); 1126 printf(" 0x%05zx %2dk %2dk", 1127 _info.vi_window, (int)_info.vi_window_size/1024, 1128 (int)_info.vi_window_gran/1024); 1129 printf(" 0x%08zx %dk\n", 1130 _info.vi_buffer, (int)_info.vi_buffer_size/1024); 1131 } 1132 } 1133 1134 1135 static void 1136 show_info(char *arg) 1137 { 1138 if (!strcmp(arg, "adapter")) { 1139 show_adapter_info(); 1140 } else if (!strcmp(arg, "mode")) { 1141 show_mode_info(); 1142 } else { 1143 revert(); 1144 errx(1, "argument to -i must be either adapter or mode"); 1145 } 1146 } 1147 1148 1149 static void 1150 test_frame(void) 1151 { 1152 int i, cur_mode, fore; 1153 1154 fore = 15; 1155 1156 if (ioctl(0, CONS_GET, &cur_mode) < 0) 1157 err(1, "must be on a virtual console"); 1158 switch (cur_mode) { 1159 case M_PC98_80x25: 1160 case M_PC98_80x30: 1161 fore = 7; 1162 break; 1163 } 1164 1165 fprintf(stdout, "\033[=0G\n\n"); 1166 for (i=0; i<8; i++) { 1167 fprintf(stdout, "\033[=%dF\033[=0G %2d \033[=%dF%-16s" 1168 "\033[=%dF\033[=0G %2d \033[=%dF%-16s " 1169 "\033[=%dF %2d \033[=%dGBACKGROUND\033[=0G\n", 1170 fore, i, i, legal_colors[i], 1171 fore, i+8, i+8, legal_colors[i+8], 1172 fore, i, i); 1173 } 1174 fprintf(stdout, "\033[=%dF\033[=%dG\033[=%dH\033[=%dI\n", 1175 info.mv_norm.fore, info.mv_norm.back, 1176 info.mv_rev.fore, info.mv_rev.back); 1177 } 1178 1179 1180 /* 1181 * Snapshot the video memory of that terminal, using the CONS_SCRSHOT 1182 * ioctl, and writes the results to stdout either in the special 1183 * binary format (see manual page for details), or in the plain 1184 * text format. 1185 */ 1186 1187 static void 1188 dump_screen(int mode, int opt) 1189 { 1190 scrshot_t shot; 1191 vid_info_t _info; 1192 1193 _info.size = sizeof(_info); 1194 1195 if (ioctl(0, CONS_GETINFO, &_info) == -1) { 1196 revert(); 1197 errc(1, errno, "obtaining current video mode parameters"); 1198 return; 1199 } 1200 1201 shot.x = shot.y = 0; 1202 shot.xsize = _info.mv_csz; 1203 shot.ysize = _info.mv_rsz; 1204 if (opt == DUMP_ALL) 1205 shot.ysize += _info.mv_hsz; 1206 1207 shot.buf = alloca(shot.xsize * shot.ysize * sizeof(u_int16_t)); 1208 if (shot.buf == NULL) { 1209 revert(); 1210 errx(1, "failed to allocate memory for dump"); 1211 } 1212 1213 if (ioctl(0, CONS_SCRSHOT, &shot) == -1) { 1214 revert(); 1215 errc(1, errno, "dumping screen"); 1216 } 1217 1218 if (mode == DUMP_FMT_RAW) { 1219 printf("SCRSHOT_%c%c%c%c", DUMP_FMT_REV, 2, 1220 shot.xsize, shot.ysize); 1221 1222 fflush(stdout); 1223 1224 write(STDOUT_FILENO, shot.buf, 1225 shot.xsize * shot.ysize * sizeof(u_int16_t)); 1226 } else { 1227 char *line; 1228 int x, y; 1229 u_int16_t ch; 1230 1231 line = alloca(shot.xsize + 1); 1232 1233 if (line == NULL) { 1234 revert(); 1235 errx(1, "failed to allocate memory for line buffer"); 1236 } 1237 1238 for (y = 0; y < shot.ysize; y++) { 1239 for (x = 0; x < shot.xsize; x++) { 1240 ch = shot.buf[x + (y * shot.xsize)]; 1241 ch &= 0xff; 1242 1243 if (isprint(ch) == 0) 1244 ch = ' '; 1245 1246 line[x] = (char)ch; 1247 } 1248 1249 /* Trim trailing spaces */ 1250 1251 do { 1252 line[x--] = '\0'; 1253 } while (line[x] == ' ' && x != 0); 1254 1255 puts(line); 1256 } 1257 1258 fflush(stdout); 1259 } 1260 } 1261 1262 1263 /* 1264 * Set the console history buffer size. 1265 */ 1266 1267 static void 1268 set_history(char *opt) 1269 { 1270 int size; 1271 1272 size = atoi(opt); 1273 1274 if ((*opt == '\0') || size < 0) { 1275 revert(); 1276 errx(1, "argument must be a positive number"); 1277 } 1278 1279 if (ioctl(0, CONS_HISTORY, &size) == -1) { 1280 revert(); 1281 errc(1, errno, "setting history buffer size"); 1282 } 1283 } 1284 1285 1286 /* 1287 * Clear the console history buffer. 1288 */ 1289 1290 static void 1291 clear_history(void) 1292 { 1293 if (ioctl(0, CONS_CLRHIST) == -1) { 1294 revert(); 1295 errc(1, errno, "clearing history buffer"); 1296 } 1297 } 1298 1299 static void 1300 set_terminal_mode(char *arg) 1301 { 1302 1303 if (strcmp(arg, "xterm") == 0) 1304 fprintf(stderr, "\033[=T"); 1305 else if (strcmp(arg, "cons25") == 0) 1306 fprintf(stderr, "\033[=1T"); 1307 } 1308 1309 1310 int 1311 main(int argc, char **argv) 1312 { 1313 char *font, *type, *termmode; 1314 const char *opts; 1315 int dumpmod, dumpopt, opt; 1316 int reterr; 1317 1318 vt4_mode = is_vt4(); 1319 1320 init(); 1321 1322 info.size = sizeof(info); 1323 1324 if (ioctl(0, CONS_GETINFO, &info) == -1) 1325 err(1, "must be on a virtual console"); 1326 dumpmod = 0; 1327 dumpopt = DUMP_FBF; 1328 termmode = NULL; 1329 if (vt4_mode) 1330 opts = "b:Cc:f:g:h:Hi:M:m:pPr:S:s:T:t:x"; 1331 else 1332 opts = "b:Cc:df:g:h:Hi:l:LM:m:pPr:S:s:T:t:x"; 1333 1334 while ((opt = getopt(argc, argv, opts)) != -1) 1335 switch(opt) { 1336 case 'b': 1337 set_border_color(optarg); 1338 break; 1339 case 'C': 1340 clear_history(); 1341 break; 1342 case 'c': 1343 set_cursor_type(optarg); 1344 break; 1345 case 'd': 1346 if (vt4_mode) 1347 break; 1348 print_scrnmap(); 1349 break; 1350 case 'f': 1351 type = optarg; 1352 font = nextarg(argc, argv, &optind, 'f', 0); 1353 1354 if (font == NULL) { 1355 type = NULL; 1356 font = optarg; 1357 } 1358 1359 load_font(type, font); 1360 break; 1361 case 'g': 1362 if (sscanf(optarg, "%dx%d", 1363 &vesa_cols, &vesa_rows) != 2) { 1364 revert(); 1365 warnx("incorrect geometry: %s", optarg); 1366 usage(); 1367 } 1368 break; 1369 case 'h': 1370 set_history(optarg); 1371 break; 1372 case 'H': 1373 dumpopt = DUMP_ALL; 1374 break; 1375 case 'i': 1376 show_info(optarg); 1377 break; 1378 case 'l': 1379 if (vt4_mode) 1380 break; 1381 load_scrnmap(optarg); 1382 break; 1383 case 'L': 1384 if (vt4_mode) 1385 break; 1386 load_default_scrnmap(); 1387 break; 1388 case 'M': 1389 set_mouse_char(optarg); 1390 break; 1391 case 'm': 1392 set_mouse(optarg); 1393 break; 1394 case 'p': 1395 dumpmod = DUMP_FMT_RAW; 1396 break; 1397 case 'P': 1398 dumpmod = DUMP_FMT_TXT; 1399 break; 1400 case 'r': 1401 get_reverse_colors(argc, argv, &optind); 1402 break; 1403 case 'S': 1404 set_lockswitch(optarg); 1405 break; 1406 case 's': 1407 set_console(optarg); 1408 break; 1409 case 'T': 1410 if (strcmp(optarg, "xterm") != 0 && 1411 strcmp(optarg, "cons25") != 0) 1412 usage(); 1413 termmode = optarg; 1414 break; 1415 case 't': 1416 set_screensaver_timeout(optarg); 1417 break; 1418 case 'x': 1419 hex = 1; 1420 break; 1421 default: 1422 usage(); 1423 } 1424 1425 if (dumpmod != 0) 1426 dump_screen(dumpmod, dumpopt); 1427 reterr = video_mode(argc, argv, &optind); 1428 get_normal_colors(argc, argv, &optind); 1429 1430 if (optind < argc && !strcmp(argv[optind], "show")) { 1431 test_frame(); 1432 optind++; 1433 } 1434 1435 video_mode(argc, argv, &optind); 1436 if (termmode != NULL) 1437 set_terminal_mode(termmode); 1438 1439 get_normal_colors(argc, argv, &optind); 1440 1441 if (colors_changed || video_mode_changed) { 1442 if (!(new_mode_info.vi_flags & V_INFO_GRAPHICS)) { 1443 if ((normal_back_color < 8) && (revers_back_color < 8)) { 1444 set_colors(); 1445 } else { 1446 revert(); 1447 errx(1, "bg color for text modes must be < 8"); 1448 } 1449 } else { 1450 set_colors(); 1451 } 1452 } 1453 1454 if ((optind != argc) || (argc == 1)) 1455 usage(); 1456 return reterr; 1457 } 1458 1459