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