1 /* 2 * linux/drivers/video/vgacon.c -- Low level VGA based console driver 3 * 4 * Created 28 Sep 1997 by Geert Uytterhoeven 5 * 6 * Rewritten by Martin Mares <mj@ucw.cz>, July 1998 7 * 8 * This file is based on the old console.c, vga.c and vesa_blank.c drivers. 9 * 10 * Copyright (C) 1991, 1992 Linus Torvalds 11 * 1995 Jay Estabrook 12 * 13 * User definable mapping table and font loading by Eugene G. Crosser, 14 * <crosser@average.org> 15 * 16 * Improved loadable font/UTF-8 support by H. Peter Anvin 17 * Feb-Sep 1995 <peter.anvin@linux.org> 18 * 19 * Colour palette handling, by Simon Tatham 20 * 17-Jun-95 <sgt20@cam.ac.uk> 21 * 22 * if 512 char mode is already enabled don't re-enable it, 23 * because it causes screen to flicker, by Mitja Horvat 24 * 5-May-96 <mitja.horvat@guest.arnes.si> 25 * 26 * Use 2 outw instead of 4 outb_p to reduce erroneous text 27 * flashing on RHS of screen during heavy console scrolling . 28 * Oct 1996, Paul Gortmaker. 29 * 30 * 31 * This file is subject to the terms and conditions of the GNU General Public 32 * License. See the file COPYING in the main directory of this archive for 33 * more details. 34 */ 35 36 #include <linux/config.h> 37 #include <linux/module.h> 38 #include <linux/types.h> 39 #include <linux/sched.h> 40 #include <linux/fs.h> 41 #include <linux/kernel.h> 42 #include <linux/tty.h> 43 #include <linux/console.h> 44 #include <linux/string.h> 45 #include <linux/kd.h> 46 #include <linux/slab.h> 47 #include <linux/vt_kern.h> 48 #include <linux/selection.h> 49 #include <linux/spinlock.h> 50 #include <linux/ioport.h> 51 #include <linux/init.h> 52 #include <linux/smp_lock.h> 53 #include <video/vga.h> 54 #include <asm/io.h> 55 56 static DEFINE_SPINLOCK(vga_lock); 57 static int cursor_size_lastfrom; 58 static int cursor_size_lastto; 59 static u32 vgacon_xres; 60 static u32 vgacon_yres; 61 static struct vgastate state; 62 63 #define BLANK 0x0020 64 65 #define CAN_LOAD_EGA_FONTS /* undefine if the user must not do this */ 66 #define CAN_LOAD_PALETTE /* undefine if the user must not do this */ 67 68 /* You really do _NOT_ want to define this, unless you have buggy 69 * Trident VGA which will resize cursor when moving it between column 70 * 15 & 16. If you define this and your VGA is OK, inverse bug will 71 * appear. 72 */ 73 #undef TRIDENT_GLITCH 74 #define VGA_FONTWIDTH 8 /* VGA does not support fontwidths != 8 */ 75 /* 76 * Interface used by the world 77 */ 78 79 static const char *vgacon_startup(void); 80 static void vgacon_init(struct vc_data *c, int init); 81 static void vgacon_deinit(struct vc_data *c); 82 static void vgacon_cursor(struct vc_data *c, int mode); 83 static int vgacon_switch(struct vc_data *c); 84 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch); 85 static int vgacon_set_palette(struct vc_data *vc, unsigned char *table); 86 static int vgacon_scrolldelta(struct vc_data *c, int lines); 87 static int vgacon_set_origin(struct vc_data *c); 88 static void vgacon_save_screen(struct vc_data *c); 89 static int vgacon_scroll(struct vc_data *c, int t, int b, int dir, 90 int lines); 91 static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity, 92 u8 blink, u8 underline, u8 reverse); 93 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count); 94 static unsigned long vgacon_uni_pagedir[2]; 95 96 /* Description of the hardware situation */ 97 static unsigned long vga_vram_base; /* Base of video memory */ 98 static unsigned long vga_vram_end; /* End of video memory */ 99 static int vga_vram_size; /* Size of video memory */ 100 static u16 vga_video_port_reg; /* Video register select port */ 101 static u16 vga_video_port_val; /* Video register value port */ 102 static unsigned int vga_video_num_columns; /* Number of text columns */ 103 static unsigned int vga_video_num_lines; /* Number of text lines */ 104 static int vga_can_do_color = 0; /* Do we support colors? */ 105 static unsigned int vga_default_font_height;/* Height of default screen font */ 106 static unsigned char vga_video_type; /* Card type */ 107 static unsigned char vga_hardscroll_enabled; 108 static unsigned char vga_hardscroll_user_enable = 1; 109 static unsigned char vga_font_is_default = 1; 110 static int vga_vesa_blanked; 111 static int vga_palette_blanked; 112 static int vga_is_gfx; 113 static int vga_512_chars; 114 static int vga_video_font_height; 115 static int vga_scan_lines; 116 static unsigned int vga_rolled_over = 0; 117 static int vga_init_done; 118 119 static int __init no_scroll(char *str) 120 { 121 /* 122 * Disabling scrollback is required for the Braillex ib80-piezo 123 * Braille reader made by F.H. Papenmeier (Germany). 124 * Use the "no-scroll" bootflag. 125 */ 126 vga_hardscroll_user_enable = vga_hardscroll_enabled = 0; 127 return 1; 128 } 129 130 __setup("no-scroll", no_scroll); 131 132 /* 133 * By replacing the four outb_p with two back to back outw, we can reduce 134 * the window of opportunity to see text mislocated to the RHS of the 135 * console during heavy scrolling activity. However there is the remote 136 * possibility that some pre-dinosaur hardware won't like the back to back 137 * I/O. Since the Xservers get away with it, we should be able to as well. 138 */ 139 static inline void write_vga(unsigned char reg, unsigned int val) 140 { 141 unsigned int v1, v2; 142 unsigned long flags; 143 144 /* 145 * ddprintk might set the console position from interrupt 146 * handlers, thus the write has to be IRQ-atomic. 147 */ 148 spin_lock_irqsave(&vga_lock, flags); 149 150 #ifndef SLOW_VGA 151 v1 = reg + (val & 0xff00); 152 v2 = reg + 1 + ((val << 8) & 0xff00); 153 outw(v1, vga_video_port_reg); 154 outw(v2, vga_video_port_reg); 155 #else 156 outb_p(reg, vga_video_port_reg); 157 outb_p(val >> 8, vga_video_port_val); 158 outb_p(reg + 1, vga_video_port_reg); 159 outb_p(val & 0xff, vga_video_port_val); 160 #endif 161 spin_unlock_irqrestore(&vga_lock, flags); 162 } 163 164 static inline void vga_set_mem_top(struct vc_data *c) 165 { 166 write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2); 167 } 168 169 #ifdef CONFIG_VGACON_SOFT_SCROLLBACK 170 #include <linux/bootmem.h> 171 /* software scrollback */ 172 static void *vgacon_scrollback; 173 static int vgacon_scrollback_tail; 174 static int vgacon_scrollback_size; 175 static int vgacon_scrollback_rows; 176 static int vgacon_scrollback_cnt; 177 static int vgacon_scrollback_cur; 178 static int vgacon_scrollback_save; 179 static int vgacon_scrollback_restore; 180 181 static void vgacon_scrollback_init(int pitch) 182 { 183 int rows = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024/pitch; 184 185 if (vgacon_scrollback) { 186 vgacon_scrollback_cnt = 0; 187 vgacon_scrollback_tail = 0; 188 vgacon_scrollback_cur = 0; 189 vgacon_scrollback_rows = rows - 1; 190 vgacon_scrollback_size = rows * pitch; 191 } 192 } 193 194 static void vgacon_scrollback_startup(void) 195 { 196 vgacon_scrollback = alloc_bootmem(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE 197 * 1024); 198 vgacon_scrollback_init(vga_video_num_columns * 2); 199 } 200 201 static void vgacon_scrollback_update(struct vc_data *c, int t, int count) 202 { 203 void *p; 204 205 if (!vgacon_scrollback_size || c->vc_num != fg_console) 206 return; 207 208 p = (void *) (c->vc_origin + t * c->vc_size_row); 209 210 while (count--) { 211 scr_memcpyw(vgacon_scrollback + vgacon_scrollback_tail, 212 p, c->vc_size_row); 213 vgacon_scrollback_cnt++; 214 p += c->vc_size_row; 215 vgacon_scrollback_tail += c->vc_size_row; 216 217 if (vgacon_scrollback_tail >= vgacon_scrollback_size) 218 vgacon_scrollback_tail = 0; 219 220 if (vgacon_scrollback_cnt > vgacon_scrollback_rows) 221 vgacon_scrollback_cnt = vgacon_scrollback_rows; 222 223 vgacon_scrollback_cur = vgacon_scrollback_cnt; 224 } 225 } 226 227 static void vgacon_restore_screen(struct vc_data *c) 228 { 229 vgacon_scrollback_save = 0; 230 231 if (!vga_is_gfx && !vgacon_scrollback_restore) { 232 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf, 233 c->vc_screenbuf_size > vga_vram_size ? 234 vga_vram_size : c->vc_screenbuf_size); 235 vgacon_scrollback_restore = 1; 236 vgacon_scrollback_cur = vgacon_scrollback_cnt; 237 } 238 } 239 240 static int vgacon_scrolldelta(struct vc_data *c, int lines) 241 { 242 int start, end, count, soff, diff; 243 void *d, *s; 244 245 if (!lines) { 246 c->vc_visible_origin = c->vc_origin; 247 vga_set_mem_top(c); 248 return 1; 249 } 250 251 if (!vgacon_scrollback) 252 return 1; 253 254 if (!vgacon_scrollback_save) { 255 vgacon_cursor(c, CM_ERASE); 256 vgacon_save_screen(c); 257 vgacon_scrollback_save = 1; 258 } 259 260 vgacon_scrollback_restore = 0; 261 start = vgacon_scrollback_cur + lines; 262 end = start + abs(lines); 263 264 if (start < 0) 265 start = 0; 266 267 if (start > vgacon_scrollback_cnt) 268 start = vgacon_scrollback_cnt; 269 270 if (end < 0) 271 end = 0; 272 273 if (end > vgacon_scrollback_cnt) 274 end = vgacon_scrollback_cnt; 275 276 vgacon_scrollback_cur = start; 277 count = end - start; 278 soff = vgacon_scrollback_tail - ((vgacon_scrollback_cnt - end) * 279 c->vc_size_row); 280 soff -= count * c->vc_size_row; 281 282 if (soff < 0) 283 soff += vgacon_scrollback_size; 284 285 count = vgacon_scrollback_cnt - start; 286 287 if (count > c->vc_rows) 288 count = c->vc_rows; 289 290 diff = c->vc_rows - count; 291 292 d = (void *) c->vc_origin; 293 s = (void *) c->vc_screenbuf; 294 295 while (count--) { 296 scr_memcpyw(d, vgacon_scrollback + soff, c->vc_size_row); 297 d += c->vc_size_row; 298 soff += c->vc_size_row; 299 300 if (soff >= vgacon_scrollback_size) 301 soff = 0; 302 } 303 304 if (diff == c->vc_rows) { 305 vgacon_cursor(c, CM_MOVE); 306 } else { 307 while (diff--) { 308 scr_memcpyw(d, s, c->vc_size_row); 309 d += c->vc_size_row; 310 s += c->vc_size_row; 311 } 312 } 313 314 return 1; 315 } 316 #else 317 #define vgacon_scrollback_startup(...) do { } while (0) 318 #define vgacon_scrollback_init(...) do { } while (0) 319 #define vgacon_scrollback_update(...) do { } while (0) 320 321 static void vgacon_restore_screen(struct vc_data *c) 322 { 323 if (c->vc_origin != c->vc_visible_origin) 324 vgacon_scrolldelta(c, 0); 325 } 326 327 static int vgacon_scrolldelta(struct vc_data *c, int lines) 328 { 329 if (!lines) /* Turn scrollback off */ 330 c->vc_visible_origin = c->vc_origin; 331 else { 332 int margin = c->vc_size_row * 4; 333 int ul, we, p, st; 334 335 if (vga_rolled_over > 336 (c->vc_scr_end - vga_vram_base) + margin) { 337 ul = c->vc_scr_end - vga_vram_base; 338 we = vga_rolled_over + c->vc_size_row; 339 } else { 340 ul = 0; 341 we = vga_vram_size; 342 } 343 p = (c->vc_visible_origin - vga_vram_base - ul + we) % we + 344 lines * c->vc_size_row; 345 st = (c->vc_origin - vga_vram_base - ul + we) % we; 346 if (st < 2 * margin) 347 margin = 0; 348 if (p < margin) 349 p = 0; 350 if (p > st - margin) 351 p = st; 352 c->vc_visible_origin = vga_vram_base + (p + ul) % we; 353 } 354 vga_set_mem_top(c); 355 return 1; 356 } 357 #endif /* CONFIG_VGACON_SOFT_SCROLLBACK */ 358 359 static const char *vgacon_startup(void) 360 { 361 const char *display_desc = NULL; 362 u16 saved1, saved2; 363 volatile u16 *p; 364 365 if (ORIG_VIDEO_ISVGA == VIDEO_TYPE_VLFB) { 366 no_vga: 367 #ifdef CONFIG_DUMMY_CONSOLE 368 conswitchp = &dummy_con; 369 return conswitchp->con_startup(); 370 #else 371 return NULL; 372 #endif 373 } 374 375 /* VGA16 modes are not handled by VGACON */ 376 if ((ORIG_VIDEO_MODE == 0x0D) || /* 320x200/4 */ 377 (ORIG_VIDEO_MODE == 0x0E) || /* 640x200/4 */ 378 (ORIG_VIDEO_MODE == 0x10) || /* 640x350/4 */ 379 (ORIG_VIDEO_MODE == 0x12) || /* 640x480/4 */ 380 (ORIG_VIDEO_MODE == 0x6A)) /* 800x600/4, 0x6A is very common */ 381 goto no_vga; 382 383 vga_video_num_lines = ORIG_VIDEO_LINES; 384 vga_video_num_columns = ORIG_VIDEO_COLS; 385 state.vgabase = NULL; 386 387 if (ORIG_VIDEO_MODE == 7) { /* Is this a monochrome display? */ 388 vga_vram_base = 0xb0000; 389 vga_video_port_reg = VGA_CRT_IM; 390 vga_video_port_val = VGA_CRT_DM; 391 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10) { 392 static struct resource ega_console_resource = 393 { .name = "ega", .start = 0x3B0, .end = 0x3BF }; 394 vga_video_type = VIDEO_TYPE_EGAM; 395 vga_vram_size = 0x8000; 396 display_desc = "EGA+"; 397 request_resource(&ioport_resource, 398 &ega_console_resource); 399 } else { 400 static struct resource mda1_console_resource = 401 { .name = "mda", .start = 0x3B0, .end = 0x3BB }; 402 static struct resource mda2_console_resource = 403 { .name = "mda", .start = 0x3BF, .end = 0x3BF }; 404 vga_video_type = VIDEO_TYPE_MDA; 405 vga_vram_size = 0x2000; 406 display_desc = "*MDA"; 407 request_resource(&ioport_resource, 408 &mda1_console_resource); 409 request_resource(&ioport_resource, 410 &mda2_console_resource); 411 vga_video_font_height = 14; 412 } 413 } else { 414 /* If not, it is color. */ 415 vga_can_do_color = 1; 416 vga_vram_base = 0xb8000; 417 vga_video_port_reg = VGA_CRT_IC; 418 vga_video_port_val = VGA_CRT_DC; 419 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10) { 420 int i; 421 422 vga_vram_size = 0x8000; 423 424 if (!ORIG_VIDEO_ISVGA) { 425 static struct resource ega_console_resource 426 = { .name = "ega", .start = 0x3C0, .end = 0x3DF }; 427 vga_video_type = VIDEO_TYPE_EGAC; 428 display_desc = "EGA"; 429 request_resource(&ioport_resource, 430 &ega_console_resource); 431 } else { 432 static struct resource vga_console_resource 433 = { .name = "vga+", .start = 0x3C0, .end = 0x3DF }; 434 vga_video_type = VIDEO_TYPE_VGAC; 435 display_desc = "VGA+"; 436 request_resource(&ioport_resource, 437 &vga_console_resource); 438 439 #ifdef VGA_CAN_DO_64KB 440 /* 441 * get 64K rather than 32K of video RAM. 442 * This doesn't actually work on all "VGA" 443 * controllers (it seems like setting MM=01 444 * and COE=1 isn't necessarily a good idea) 445 */ 446 vga_vram_base = 0xa0000; 447 vga_vram_size = 0x10000; 448 outb_p(6, VGA_GFX_I); 449 outb_p(6, VGA_GFX_D); 450 #endif 451 /* 452 * Normalise the palette registers, to point 453 * the 16 screen colours to the first 16 454 * DAC entries. 455 */ 456 457 for (i = 0; i < 16; i++) { 458 inb_p(VGA_IS1_RC); 459 outb_p(i, VGA_ATT_W); 460 outb_p(i, VGA_ATT_W); 461 } 462 outb_p(0x20, VGA_ATT_W); 463 464 /* 465 * Now set the DAC registers back to their 466 * default values 467 */ 468 for (i = 0; i < 16; i++) { 469 outb_p(color_table[i], VGA_PEL_IW); 470 outb_p(default_red[i], VGA_PEL_D); 471 outb_p(default_grn[i], VGA_PEL_D); 472 outb_p(default_blu[i], VGA_PEL_D); 473 } 474 } 475 } else { 476 static struct resource cga_console_resource = 477 { .name = "cga", .start = 0x3D4, .end = 0x3D5 }; 478 vga_video_type = VIDEO_TYPE_CGA; 479 vga_vram_size = 0x2000; 480 display_desc = "*CGA"; 481 request_resource(&ioport_resource, 482 &cga_console_resource); 483 vga_video_font_height = 8; 484 } 485 } 486 487 vga_vram_base = VGA_MAP_MEM(vga_vram_base, vga_vram_size); 488 vga_vram_end = vga_vram_base + vga_vram_size; 489 490 /* 491 * Find out if there is a graphics card present. 492 * Are there smarter methods around? 493 */ 494 p = (volatile u16 *) vga_vram_base; 495 saved1 = scr_readw(p); 496 saved2 = scr_readw(p + 1); 497 scr_writew(0xAA55, p); 498 scr_writew(0x55AA, p + 1); 499 if (scr_readw(p) != 0xAA55 || scr_readw(p + 1) != 0x55AA) { 500 scr_writew(saved1, p); 501 scr_writew(saved2, p + 1); 502 goto no_vga; 503 } 504 scr_writew(0x55AA, p); 505 scr_writew(0xAA55, p + 1); 506 if (scr_readw(p) != 0x55AA || scr_readw(p + 1) != 0xAA55) { 507 scr_writew(saved1, p); 508 scr_writew(saved2, p + 1); 509 goto no_vga; 510 } 511 scr_writew(saved1, p); 512 scr_writew(saved2, p + 1); 513 514 if (vga_video_type == VIDEO_TYPE_EGAC 515 || vga_video_type == VIDEO_TYPE_VGAC 516 || vga_video_type == VIDEO_TYPE_EGAM) { 517 vga_hardscroll_enabled = vga_hardscroll_user_enable; 518 vga_default_font_height = ORIG_VIDEO_POINTS; 519 vga_video_font_height = ORIG_VIDEO_POINTS; 520 /* This may be suboptimal but is a safe bet - go with it */ 521 vga_scan_lines = 522 vga_video_font_height * vga_video_num_lines; 523 } 524 525 vgacon_xres = ORIG_VIDEO_COLS * VGA_FONTWIDTH; 526 vgacon_yres = vga_scan_lines; 527 528 if (!vga_init_done) { 529 vgacon_scrollback_startup(); 530 vga_init_done = 1; 531 } 532 533 return display_desc; 534 } 535 536 static void vgacon_init(struct vc_data *c, int init) 537 { 538 unsigned long p; 539 540 /* 541 * We cannot be loaded as a module, therefore init is always 1, 542 * but vgacon_init can be called more than once, and init will 543 * not be 1. 544 */ 545 c->vc_can_do_color = vga_can_do_color; 546 547 /* set dimensions manually if init != 0 since vc_resize() will fail */ 548 if (init) { 549 c->vc_cols = vga_video_num_columns; 550 c->vc_rows = vga_video_num_lines; 551 } else 552 vc_resize(c, vga_video_num_columns, vga_video_num_lines); 553 554 c->vc_scan_lines = vga_scan_lines; 555 c->vc_font.height = vga_video_font_height; 556 c->vc_complement_mask = 0x7700; 557 if (vga_512_chars) 558 c->vc_hi_font_mask = 0x0800; 559 p = *c->vc_uni_pagedir_loc; 560 if (c->vc_uni_pagedir_loc == &c->vc_uni_pagedir || 561 !--c->vc_uni_pagedir_loc[1]) 562 con_free_unimap(c); 563 c->vc_uni_pagedir_loc = vgacon_uni_pagedir; 564 vgacon_uni_pagedir[1]++; 565 if (!vgacon_uni_pagedir[0] && p) 566 con_set_default_unimap(c); 567 } 568 569 static void vgacon_deinit(struct vc_data *c) 570 { 571 /* When closing the last console, reset video origin */ 572 if (!--vgacon_uni_pagedir[1]) { 573 c->vc_visible_origin = vga_vram_base; 574 vga_set_mem_top(c); 575 con_free_unimap(c); 576 } 577 c->vc_uni_pagedir_loc = &c->vc_uni_pagedir; 578 con_set_default_unimap(c); 579 } 580 581 static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity, 582 u8 blink, u8 underline, u8 reverse) 583 { 584 u8 attr = color; 585 586 if (vga_can_do_color) { 587 if (underline) 588 attr = (attr & 0xf0) | c->vc_ulcolor; 589 else if (intensity == 0) 590 attr = (attr & 0xf0) | c->vc_halfcolor; 591 } 592 if (reverse) 593 attr = 594 ((attr) & 0x88) | ((((attr) >> 4) | ((attr) << 4)) & 595 0x77); 596 if (blink) 597 attr ^= 0x80; 598 if (intensity == 2) 599 attr ^= 0x08; 600 if (!vga_can_do_color) { 601 if (underline) 602 attr = (attr & 0xf8) | 0x01; 603 else if (intensity == 0) 604 attr = (attr & 0xf0) | 0x08; 605 } 606 return attr; 607 } 608 609 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count) 610 { 611 int col = vga_can_do_color; 612 613 while (count--) { 614 u16 a = scr_readw(p); 615 if (col) 616 a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) | 617 (((a) & 0x0700) << 4); 618 else 619 a ^= ((a & 0x0700) == 0x0100) ? 0x7000 : 0x7700; 620 scr_writew(a, p++); 621 } 622 } 623 624 static void vgacon_set_cursor_size(int xpos, int from, int to) 625 { 626 unsigned long flags; 627 int curs, cure; 628 629 #ifdef TRIDENT_GLITCH 630 if (xpos < 16) 631 from--, to--; 632 #endif 633 634 if ((from == cursor_size_lastfrom) && (to == cursor_size_lastto)) 635 return; 636 cursor_size_lastfrom = from; 637 cursor_size_lastto = to; 638 639 spin_lock_irqsave(&vga_lock, flags); 640 if (vga_video_type >= VIDEO_TYPE_VGAC) { 641 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg); 642 curs = inb_p(vga_video_port_val); 643 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg); 644 cure = inb_p(vga_video_port_val); 645 } else { 646 curs = 0; 647 cure = 0; 648 } 649 650 curs = (curs & 0xc0) | from; 651 cure = (cure & 0xe0) | to; 652 653 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg); 654 outb_p(curs, vga_video_port_val); 655 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg); 656 outb_p(cure, vga_video_port_val); 657 spin_unlock_irqrestore(&vga_lock, flags); 658 } 659 660 static void vgacon_cursor(struct vc_data *c, int mode) 661 { 662 vgacon_restore_screen(c); 663 664 switch (mode) { 665 case CM_ERASE: 666 write_vga(14, (c->vc_pos - vga_vram_base) / 2); 667 if (vga_video_type >= VIDEO_TYPE_VGAC) 668 vgacon_set_cursor_size(c->vc_x, 31, 30); 669 else 670 vgacon_set_cursor_size(c->vc_x, 31, 31); 671 break; 672 673 case CM_MOVE: 674 case CM_DRAW: 675 write_vga(14, (c->vc_pos - vga_vram_base) / 2); 676 switch (c->vc_cursor_type & 0x0f) { 677 case CUR_UNDERLINE: 678 vgacon_set_cursor_size(c->vc_x, 679 c->vc_font.height - 680 (c->vc_font.height < 681 10 ? 2 : 3), 682 c->vc_font.height - 683 (c->vc_font.height < 684 10 ? 1 : 2)); 685 break; 686 case CUR_TWO_THIRDS: 687 vgacon_set_cursor_size(c->vc_x, 688 c->vc_font.height / 3, 689 c->vc_font.height - 690 (c->vc_font.height < 691 10 ? 1 : 2)); 692 break; 693 case CUR_LOWER_THIRD: 694 vgacon_set_cursor_size(c->vc_x, 695 (c->vc_font.height * 2) / 3, 696 c->vc_font.height - 697 (c->vc_font.height < 698 10 ? 1 : 2)); 699 break; 700 case CUR_LOWER_HALF: 701 vgacon_set_cursor_size(c->vc_x, 702 c->vc_font.height / 2, 703 c->vc_font.height - 704 (c->vc_font.height < 705 10 ? 1 : 2)); 706 break; 707 case CUR_NONE: 708 if (vga_video_type >= VIDEO_TYPE_VGAC) 709 vgacon_set_cursor_size(c->vc_x, 31, 30); 710 else 711 vgacon_set_cursor_size(c->vc_x, 31, 31); 712 break; 713 default: 714 vgacon_set_cursor_size(c->vc_x, 1, 715 c->vc_font.height); 716 break; 717 } 718 break; 719 } 720 } 721 722 static int vgacon_doresize(struct vc_data *c, 723 unsigned int width, unsigned int height) 724 { 725 unsigned long flags; 726 unsigned int scanlines = height * c->vc_font.height; 727 u8 scanlines_lo = 0, r7 = 0, vsync_end = 0, mode, max_scan; 728 729 spin_lock_irqsave(&vga_lock, flags); 730 731 vgacon_xres = width * VGA_FONTWIDTH; 732 vgacon_yres = height * c->vc_font.height; 733 if (vga_video_type >= VIDEO_TYPE_VGAC) { 734 outb_p(VGA_CRTC_MAX_SCAN, vga_video_port_reg); 735 max_scan = inb_p(vga_video_port_val); 736 737 if (max_scan & 0x80) 738 scanlines <<= 1; 739 740 outb_p(VGA_CRTC_MODE, vga_video_port_reg); 741 mode = inb_p(vga_video_port_val); 742 743 if (mode & 0x04) 744 scanlines >>= 1; 745 746 scanlines -= 1; 747 scanlines_lo = scanlines & 0xff; 748 749 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg); 750 r7 = inb_p(vga_video_port_val) & ~0x42; 751 752 if (scanlines & 0x100) 753 r7 |= 0x02; 754 if (scanlines & 0x200) 755 r7 |= 0x40; 756 757 /* deprotect registers */ 758 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg); 759 vsync_end = inb_p(vga_video_port_val); 760 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg); 761 outb_p(vsync_end & ~0x80, vga_video_port_val); 762 } 763 764 outb_p(VGA_CRTC_H_DISP, vga_video_port_reg); 765 outb_p(width - 1, vga_video_port_val); 766 outb_p(VGA_CRTC_OFFSET, vga_video_port_reg); 767 outb_p(width >> 1, vga_video_port_val); 768 769 if (vga_video_type >= VIDEO_TYPE_VGAC) { 770 outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg); 771 outb_p(scanlines_lo, vga_video_port_val); 772 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg); 773 outb_p(r7,vga_video_port_val); 774 775 /* reprotect registers */ 776 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg); 777 outb_p(vsync_end, vga_video_port_val); 778 } 779 780 spin_unlock_irqrestore(&vga_lock, flags); 781 return 0; 782 } 783 784 static int vgacon_switch(struct vc_data *c) 785 { 786 int x = c->vc_cols * VGA_FONTWIDTH; 787 int y = c->vc_rows * c->vc_font.height; 788 int rows = ORIG_VIDEO_LINES * vga_default_font_height/ 789 c->vc_font.height; 790 /* 791 * We need to save screen size here as it's the only way 792 * we can spot the screen has been resized and we need to 793 * set size of freshly allocated screens ourselves. 794 */ 795 vga_video_num_columns = c->vc_cols; 796 vga_video_num_lines = c->vc_rows; 797 798 /* We can only copy out the size of the video buffer here, 799 * otherwise we get into VGA BIOS */ 800 801 if (!vga_is_gfx) { 802 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf, 803 c->vc_screenbuf_size > vga_vram_size ? 804 vga_vram_size : c->vc_screenbuf_size); 805 806 if ((vgacon_xres != x || vgacon_yres != y) && 807 (!(vga_video_num_columns % 2) && 808 vga_video_num_columns <= ORIG_VIDEO_COLS && 809 vga_video_num_lines <= rows)) 810 vgacon_doresize(c, c->vc_cols, c->vc_rows); 811 } 812 813 vgacon_scrollback_init(c->vc_size_row); 814 return 0; /* Redrawing not needed */ 815 } 816 817 static void vga_set_palette(struct vc_data *vc, unsigned char *table) 818 { 819 int i, j; 820 821 vga_w(state.vgabase, VGA_PEL_MSK, 0xff); 822 for (i = j = 0; i < 16; i++) { 823 vga_w(state.vgabase, VGA_PEL_IW, table[i]); 824 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2); 825 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2); 826 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2); 827 } 828 } 829 830 static int vgacon_set_palette(struct vc_data *vc, unsigned char *table) 831 { 832 #ifdef CAN_LOAD_PALETTE 833 if (vga_video_type != VIDEO_TYPE_VGAC || vga_palette_blanked 834 || !CON_IS_VISIBLE(vc)) 835 return -EINVAL; 836 vga_set_palette(vc, table); 837 return 0; 838 #else 839 return -EINVAL; 840 #endif 841 } 842 843 /* structure holding original VGA register settings */ 844 static struct { 845 unsigned char SeqCtrlIndex; /* Sequencer Index reg. */ 846 unsigned char CrtCtrlIndex; /* CRT-Contr. Index reg. */ 847 unsigned char CrtMiscIO; /* Miscellaneous register */ 848 unsigned char HorizontalTotal; /* CRT-Controller:00h */ 849 unsigned char HorizDisplayEnd; /* CRT-Controller:01h */ 850 unsigned char StartHorizRetrace; /* CRT-Controller:04h */ 851 unsigned char EndHorizRetrace; /* CRT-Controller:05h */ 852 unsigned char Overflow; /* CRT-Controller:07h */ 853 unsigned char StartVertRetrace; /* CRT-Controller:10h */ 854 unsigned char EndVertRetrace; /* CRT-Controller:11h */ 855 unsigned char ModeControl; /* CRT-Controller:17h */ 856 unsigned char ClockingMode; /* Seq-Controller:01h */ 857 } vga_state; 858 859 static void vga_vesa_blank(struct vgastate *state, int mode) 860 { 861 /* save original values of VGA controller registers */ 862 if (!vga_vesa_blanked) { 863 spin_lock_irq(&vga_lock); 864 vga_state.SeqCtrlIndex = vga_r(state->vgabase, VGA_SEQ_I); 865 vga_state.CrtCtrlIndex = inb_p(vga_video_port_reg); 866 vga_state.CrtMiscIO = vga_r(state->vgabase, VGA_MIS_R); 867 spin_unlock_irq(&vga_lock); 868 869 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */ 870 vga_state.HorizontalTotal = inb_p(vga_video_port_val); 871 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */ 872 vga_state.HorizDisplayEnd = inb_p(vga_video_port_val); 873 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */ 874 vga_state.StartHorizRetrace = inb_p(vga_video_port_val); 875 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */ 876 vga_state.EndHorizRetrace = inb_p(vga_video_port_val); 877 outb_p(0x07, vga_video_port_reg); /* Overflow */ 878 vga_state.Overflow = inb_p(vga_video_port_val); 879 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */ 880 vga_state.StartVertRetrace = inb_p(vga_video_port_val); 881 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */ 882 vga_state.EndVertRetrace = inb_p(vga_video_port_val); 883 outb_p(0x17, vga_video_port_reg); /* ModeControl */ 884 vga_state.ModeControl = inb_p(vga_video_port_val); 885 vga_state.ClockingMode = vga_rseq(state->vgabase, VGA_SEQ_CLOCK_MODE); 886 } 887 888 /* assure that video is enabled */ 889 /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */ 890 spin_lock_irq(&vga_lock); 891 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode | 0x20); 892 893 /* test for vertical retrace in process.... */ 894 if ((vga_state.CrtMiscIO & 0x80) == 0x80) 895 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO & 0xEF); 896 897 /* 898 * Set <End of vertical retrace> to minimum (0) and 899 * <Start of vertical Retrace> to maximum (incl. overflow) 900 * Result: turn off vertical sync (VSync) pulse. 901 */ 902 if (mode & VESA_VSYNC_SUSPEND) { 903 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */ 904 outb_p(0xff, vga_video_port_val); /* maximum value */ 905 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */ 906 outb_p(0x40, vga_video_port_val); /* minimum (bits 0..3) */ 907 outb_p(0x07, vga_video_port_reg); /* Overflow */ 908 outb_p(vga_state.Overflow | 0x84, vga_video_port_val); /* bits 9,10 of vert. retrace */ 909 } 910 911 if (mode & VESA_HSYNC_SUSPEND) { 912 /* 913 * Set <End of horizontal retrace> to minimum (0) and 914 * <Start of horizontal Retrace> to maximum 915 * Result: turn off horizontal sync (HSync) pulse. 916 */ 917 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */ 918 outb_p(0xff, vga_video_port_val); /* maximum */ 919 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */ 920 outb_p(0x00, vga_video_port_val); /* minimum (0) */ 921 } 922 923 /* restore both index registers */ 924 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex); 925 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg); 926 spin_unlock_irq(&vga_lock); 927 } 928 929 static void vga_vesa_unblank(struct vgastate *state) 930 { 931 /* restore original values of VGA controller registers */ 932 spin_lock_irq(&vga_lock); 933 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO); 934 935 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */ 936 outb_p(vga_state.HorizontalTotal, vga_video_port_val); 937 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */ 938 outb_p(vga_state.HorizDisplayEnd, vga_video_port_val); 939 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */ 940 outb_p(vga_state.StartHorizRetrace, vga_video_port_val); 941 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */ 942 outb_p(vga_state.EndHorizRetrace, vga_video_port_val); 943 outb_p(0x07, vga_video_port_reg); /* Overflow */ 944 outb_p(vga_state.Overflow, vga_video_port_val); 945 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */ 946 outb_p(vga_state.StartVertRetrace, vga_video_port_val); 947 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */ 948 outb_p(vga_state.EndVertRetrace, vga_video_port_val); 949 outb_p(0x17, vga_video_port_reg); /* ModeControl */ 950 outb_p(vga_state.ModeControl, vga_video_port_val); 951 /* ClockingMode */ 952 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode); 953 954 /* restore index/control registers */ 955 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex); 956 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg); 957 spin_unlock_irq(&vga_lock); 958 } 959 960 static void vga_pal_blank(struct vgastate *state) 961 { 962 int i; 963 964 vga_w(state->vgabase, VGA_PEL_MSK, 0xff); 965 for (i = 0; i < 16; i++) { 966 vga_w(state->vgabase, VGA_PEL_IW, i); 967 vga_w(state->vgabase, VGA_PEL_D, 0); 968 vga_w(state->vgabase, VGA_PEL_D, 0); 969 vga_w(state->vgabase, VGA_PEL_D, 0); 970 } 971 } 972 973 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch) 974 { 975 switch (blank) { 976 case 0: /* Unblank */ 977 if (vga_vesa_blanked) { 978 vga_vesa_unblank(&state); 979 vga_vesa_blanked = 0; 980 } 981 if (vga_palette_blanked) { 982 vga_set_palette(c, color_table); 983 vga_palette_blanked = 0; 984 return 0; 985 } 986 vga_is_gfx = 0; 987 /* Tell console.c that it has to restore the screen itself */ 988 return 1; 989 case 1: /* Normal blanking */ 990 case -1: /* Obsolete */ 991 if (!mode_switch && vga_video_type == VIDEO_TYPE_VGAC) { 992 vga_pal_blank(&state); 993 vga_palette_blanked = 1; 994 return 0; 995 } 996 vgacon_set_origin(c); 997 scr_memsetw((void *) vga_vram_base, BLANK, 998 c->vc_screenbuf_size); 999 if (mode_switch) 1000 vga_is_gfx = 1; 1001 return 1; 1002 default: /* VESA blanking */ 1003 if (vga_video_type == VIDEO_TYPE_VGAC) { 1004 vga_vesa_blank(&state, blank - 1); 1005 vga_vesa_blanked = blank; 1006 } 1007 return 0; 1008 } 1009 } 1010 1011 /* 1012 * PIO_FONT support. 1013 * 1014 * The font loading code goes back to the codepage package by 1015 * Joel Hoffman (joel@wam.umd.edu). (He reports that the original 1016 * reference is: "From: p. 307 of _Programmer's Guide to PC & PS/2 1017 * Video Systems_ by Richard Wilton. 1987. Microsoft Press".) 1018 * 1019 * Change for certain monochrome monitors by Yury Shevchuck 1020 * (sizif@botik.yaroslavl.su). 1021 */ 1022 1023 #ifdef CAN_LOAD_EGA_FONTS 1024 1025 #define colourmap 0xa0000 1026 /* Pauline Middelink <middelin@polyware.iaf.nl> reports that we 1027 should use 0xA0000 for the bwmap as well.. */ 1028 #define blackwmap 0xa0000 1029 #define cmapsz 8192 1030 1031 static int vgacon_do_font_op(struct vgastate *state,char *arg,int set,int ch512) 1032 { 1033 unsigned short video_port_status = vga_video_port_reg + 6; 1034 int font_select = 0x00, beg, i; 1035 char *charmap; 1036 1037 if (vga_video_type != VIDEO_TYPE_EGAM) { 1038 charmap = (char *) VGA_MAP_MEM(colourmap, 0); 1039 beg = 0x0e; 1040 #ifdef VGA_CAN_DO_64KB 1041 if (vga_video_type == VIDEO_TYPE_VGAC) 1042 beg = 0x06; 1043 #endif 1044 } else { 1045 charmap = (char *) VGA_MAP_MEM(blackwmap, 0); 1046 beg = 0x0a; 1047 } 1048 1049 #ifdef BROKEN_GRAPHICS_PROGRAMS 1050 /* 1051 * All fonts are loaded in slot 0 (0:1 for 512 ch) 1052 */ 1053 1054 if (!arg) 1055 return -EINVAL; /* Return to default font not supported */ 1056 1057 vga_font_is_default = 0; 1058 font_select = ch512 ? 0x04 : 0x00; 1059 #else 1060 /* 1061 * The default font is kept in slot 0 and is never touched. 1062 * A custom font is loaded in slot 2 (256 ch) or 2:3 (512 ch) 1063 */ 1064 1065 if (set) { 1066 vga_font_is_default = !arg; 1067 if (!arg) 1068 ch512 = 0; /* Default font is always 256 */ 1069 font_select = arg ? (ch512 ? 0x0e : 0x0a) : 0x00; 1070 } 1071 1072 if (!vga_font_is_default) 1073 charmap += 4 * cmapsz; 1074 #endif 1075 1076 unlock_kernel(); 1077 spin_lock_irq(&vga_lock); 1078 /* First, the Sequencer */ 1079 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1); 1080 /* CPU writes only to map 2 */ 1081 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x04); 1082 /* Sequential addressing */ 1083 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x07); 1084 /* Clear synchronous reset */ 1085 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03); 1086 1087 /* Now, the graphics controller, select map 2 */ 1088 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x02); 1089 /* disable odd-even addressing */ 1090 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x00); 1091 /* map start at A000:0000 */ 1092 vga_wgfx(state->vgabase, VGA_GFX_MISC, 0x00); 1093 spin_unlock_irq(&vga_lock); 1094 1095 if (arg) { 1096 if (set) 1097 for (i = 0; i < cmapsz; i++) 1098 vga_writeb(arg[i], charmap + i); 1099 else 1100 for (i = 0; i < cmapsz; i++) 1101 arg[i] = vga_readb(charmap + i); 1102 1103 /* 1104 * In 512-character mode, the character map is not contiguous if 1105 * we want to remain EGA compatible -- which we do 1106 */ 1107 1108 if (ch512) { 1109 charmap += 2 * cmapsz; 1110 arg += cmapsz; 1111 if (set) 1112 for (i = 0; i < cmapsz; i++) 1113 vga_writeb(arg[i], charmap + i); 1114 else 1115 for (i = 0; i < cmapsz; i++) 1116 arg[i] = vga_readb(charmap + i); 1117 } 1118 } 1119 1120 spin_lock_irq(&vga_lock); 1121 /* First, the sequencer, Synchronous reset */ 1122 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x01); 1123 /* CPU writes to maps 0 and 1 */ 1124 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x03); 1125 /* odd-even addressing */ 1126 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x03); 1127 /* Character Map Select */ 1128 if (set) 1129 vga_wseq(state->vgabase, VGA_SEQ_CHARACTER_MAP, font_select); 1130 /* clear synchronous reset */ 1131 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03); 1132 1133 /* Now, the graphics controller, select map 0 for CPU */ 1134 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x00); 1135 /* enable even-odd addressing */ 1136 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x10); 1137 /* map starts at b800:0 or b000:0 */ 1138 vga_wgfx(state->vgabase, VGA_GFX_MISC, beg); 1139 1140 /* if 512 char mode is already enabled don't re-enable it. */ 1141 if ((set) && (ch512 != vga_512_chars)) { 1142 int i; 1143 1144 /* attribute controller */ 1145 for (i = 0; i < MAX_NR_CONSOLES; i++) { 1146 struct vc_data *c = vc_cons[i].d; 1147 if (c && c->vc_sw == &vga_con) 1148 c->vc_hi_font_mask = ch512 ? 0x0800 : 0; 1149 } 1150 vga_512_chars = ch512; 1151 /* 256-char: enable intensity bit 1152 512-char: disable intensity bit */ 1153 inb_p(video_port_status); /* clear address flip-flop */ 1154 /* color plane enable register */ 1155 vga_wattr(state->vgabase, VGA_ATC_PLANE_ENABLE, ch512 ? 0x07 : 0x0f); 1156 /* Wilton (1987) mentions the following; I don't know what 1157 it means, but it works, and it appears necessary */ 1158 inb_p(video_port_status); 1159 vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0); 1160 } 1161 spin_unlock_irq(&vga_lock); 1162 lock_kernel(); 1163 return 0; 1164 } 1165 1166 /* 1167 * Adjust the screen to fit a font of a certain height 1168 */ 1169 static int vgacon_adjust_height(struct vc_data *vc, unsigned fontheight) 1170 { 1171 unsigned char ovr, vde, fsr; 1172 int rows, maxscan, i; 1173 1174 rows = vc->vc_scan_lines / fontheight; /* Number of video rows we end up with */ 1175 maxscan = rows * fontheight - 1; /* Scan lines to actually display-1 */ 1176 1177 /* Reprogram the CRTC for the new font size 1178 Note: the attempt to read the overflow register will fail 1179 on an EGA, but using 0xff for the previous value appears to 1180 be OK for EGA text modes in the range 257-512 scan lines, so I 1181 guess we don't need to worry about it. 1182 1183 The same applies for the spill bits in the font size and cursor 1184 registers; they are write-only on EGA, but it appears that they 1185 are all don't care bits on EGA, so I guess it doesn't matter. */ 1186 1187 spin_lock_irq(&vga_lock); 1188 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */ 1189 ovr = inb_p(vga_video_port_val); 1190 outb_p(0x09, vga_video_port_reg); /* Font size register */ 1191 fsr = inb_p(vga_video_port_val); 1192 spin_unlock_irq(&vga_lock); 1193 1194 vde = maxscan & 0xff; /* Vertical display end reg */ 1195 ovr = (ovr & 0xbd) + /* Overflow register */ 1196 ((maxscan & 0x100) >> 7) + ((maxscan & 0x200) >> 3); 1197 fsr = (fsr & 0xe0) + (fontheight - 1); /* Font size register */ 1198 1199 spin_lock_irq(&vga_lock); 1200 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */ 1201 outb_p(ovr, vga_video_port_val); 1202 outb_p(0x09, vga_video_port_reg); /* Font size */ 1203 outb_p(fsr, vga_video_port_val); 1204 outb_p(0x12, vga_video_port_reg); /* Vertical display limit */ 1205 outb_p(vde, vga_video_port_val); 1206 spin_unlock_irq(&vga_lock); 1207 vga_video_font_height = fontheight; 1208 1209 for (i = 0; i < MAX_NR_CONSOLES; i++) { 1210 struct vc_data *c = vc_cons[i].d; 1211 1212 if (c && c->vc_sw == &vga_con) { 1213 if (CON_IS_VISIBLE(c)) { 1214 /* void size to cause regs to be rewritten */ 1215 cursor_size_lastfrom = 0; 1216 cursor_size_lastto = 0; 1217 c->vc_sw->con_cursor(c, CM_DRAW); 1218 } 1219 c->vc_font.height = fontheight; 1220 vc_resize(c, 0, rows); /* Adjust console size */ 1221 } 1222 } 1223 return 0; 1224 } 1225 1226 static int vgacon_font_set(struct vc_data *c, struct console_font *font, unsigned flags) 1227 { 1228 unsigned charcount = font->charcount; 1229 int rc; 1230 1231 if (vga_video_type < VIDEO_TYPE_EGAM) 1232 return -EINVAL; 1233 1234 if (font->width != VGA_FONTWIDTH || 1235 (charcount != 256 && charcount != 512)) 1236 return -EINVAL; 1237 1238 rc = vgacon_do_font_op(&state, font->data, 1, charcount == 512); 1239 if (rc) 1240 return rc; 1241 1242 if (!(flags & KD_FONT_FLAG_DONT_RECALC)) 1243 rc = vgacon_adjust_height(c, font->height); 1244 return rc; 1245 } 1246 1247 static int vgacon_font_get(struct vc_data *c, struct console_font *font) 1248 { 1249 if (vga_video_type < VIDEO_TYPE_EGAM) 1250 return -EINVAL; 1251 1252 font->width = VGA_FONTWIDTH; 1253 font->height = c->vc_font.height; 1254 font->charcount = vga_512_chars ? 512 : 256; 1255 if (!font->data) 1256 return 0; 1257 return vgacon_do_font_op(&state, font->data, 0, 0); 1258 } 1259 1260 #else 1261 1262 #define vgacon_font_set NULL 1263 #define vgacon_font_get NULL 1264 1265 #endif 1266 1267 static int vgacon_resize(struct vc_data *c, unsigned int width, 1268 unsigned int height) 1269 { 1270 if (width % 2 || width > ORIG_VIDEO_COLS || 1271 height > (ORIG_VIDEO_LINES * vga_default_font_height)/ 1272 c->vc_font.height) 1273 /* let svgatextmode tinker with video timings */ 1274 return 0; 1275 1276 if (CON_IS_VISIBLE(c) && !vga_is_gfx) /* who knows */ 1277 vgacon_doresize(c, width, height); 1278 return 0; 1279 } 1280 1281 static int vgacon_set_origin(struct vc_data *c) 1282 { 1283 if (vga_is_gfx || /* We don't play origin tricks in graphic modes */ 1284 (console_blanked && !vga_palette_blanked)) /* Nor we write to blanked screens */ 1285 return 0; 1286 c->vc_origin = c->vc_visible_origin = vga_vram_base; 1287 vga_set_mem_top(c); 1288 vga_rolled_over = 0; 1289 return 1; 1290 } 1291 1292 static void vgacon_save_screen(struct vc_data *c) 1293 { 1294 static int vga_bootup_console = 0; 1295 1296 if (!vga_bootup_console) { 1297 /* This is a gross hack, but here is the only place we can 1298 * set bootup console parameters without messing up generic 1299 * console initialization routines. 1300 */ 1301 vga_bootup_console = 1; 1302 c->vc_x = ORIG_X; 1303 c->vc_y = ORIG_Y; 1304 } 1305 1306 /* We can't copy in more then the size of the video buffer, 1307 * or we'll be copying in VGA BIOS */ 1308 1309 if (!vga_is_gfx) 1310 scr_memcpyw((u16 *) c->vc_screenbuf, (u16 *) c->vc_origin, 1311 c->vc_screenbuf_size > vga_vram_size ? vga_vram_size : c->vc_screenbuf_size); 1312 } 1313 1314 static int vgacon_scroll(struct vc_data *c, int t, int b, int dir, 1315 int lines) 1316 { 1317 unsigned long oldo; 1318 unsigned int delta; 1319 1320 if (t || b != c->vc_rows || vga_is_gfx) 1321 return 0; 1322 1323 if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2) 1324 return 0; 1325 1326 vgacon_restore_screen(c); 1327 oldo = c->vc_origin; 1328 delta = lines * c->vc_size_row; 1329 if (dir == SM_UP) { 1330 vgacon_scrollback_update(c, t, lines); 1331 if (c->vc_scr_end + delta >= vga_vram_end) { 1332 scr_memcpyw((u16 *) vga_vram_base, 1333 (u16 *) (oldo + delta), 1334 c->vc_screenbuf_size - delta); 1335 c->vc_origin = vga_vram_base; 1336 vga_rolled_over = oldo - vga_vram_base; 1337 } else 1338 c->vc_origin += delta; 1339 scr_memsetw((u16 *) (c->vc_origin + c->vc_screenbuf_size - 1340 delta), c->vc_video_erase_char, 1341 delta); 1342 } else { 1343 if (oldo - delta < vga_vram_base) { 1344 scr_memmovew((u16 *) (vga_vram_end - 1345 c->vc_screenbuf_size + 1346 delta), (u16 *) oldo, 1347 c->vc_screenbuf_size - delta); 1348 c->vc_origin = vga_vram_end - c->vc_screenbuf_size; 1349 vga_rolled_over = 0; 1350 } else 1351 c->vc_origin -= delta; 1352 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size; 1353 scr_memsetw((u16 *) (c->vc_origin), c->vc_video_erase_char, 1354 delta); 1355 } 1356 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size; 1357 c->vc_visible_origin = c->vc_origin; 1358 vga_set_mem_top(c); 1359 c->vc_pos = (c->vc_pos - oldo) + c->vc_origin; 1360 return 1; 1361 } 1362 1363 1364 /* 1365 * The console `switch' structure for the VGA based console 1366 */ 1367 1368 static int vgacon_dummy(struct vc_data *c) 1369 { 1370 return 0; 1371 } 1372 1373 #define DUMMY (void *) vgacon_dummy 1374 1375 const struct consw vga_con = { 1376 .owner = THIS_MODULE, 1377 .con_startup = vgacon_startup, 1378 .con_init = vgacon_init, 1379 .con_deinit = vgacon_deinit, 1380 .con_clear = DUMMY, 1381 .con_putc = DUMMY, 1382 .con_putcs = DUMMY, 1383 .con_cursor = vgacon_cursor, 1384 .con_scroll = vgacon_scroll, 1385 .con_bmove = DUMMY, 1386 .con_switch = vgacon_switch, 1387 .con_blank = vgacon_blank, 1388 .con_font_set = vgacon_font_set, 1389 .con_font_get = vgacon_font_get, 1390 .con_resize = vgacon_resize, 1391 .con_set_palette = vgacon_set_palette, 1392 .con_scrolldelta = vgacon_scrolldelta, 1393 .con_set_origin = vgacon_set_origin, 1394 .con_save_screen = vgacon_save_screen, 1395 .con_build_attr = vgacon_build_attr, 1396 .con_invert_region = vgacon_invert_region, 1397 }; 1398 1399 MODULE_LICENSE("GPL"); 1400