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 /* 191 * Called only duing init so call of alloc_bootmen is ok. 192 * Marked __init_refok to silence modpost. 193 */ 194 static void __init_refok 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 /* SCREEN_INFO initialized? */ 376 if ((ORIG_VIDEO_MODE == 0) && 377 (ORIG_VIDEO_LINES == 0) && 378 (ORIG_VIDEO_COLS == 0)) 379 goto no_vga; 380 381 /* VGA16 modes are not handled by VGACON */ 382 if ((ORIG_VIDEO_MODE == 0x0D) || /* 320x200/4 */ 383 (ORIG_VIDEO_MODE == 0x0E) || /* 640x200/4 */ 384 (ORIG_VIDEO_MODE == 0x10) || /* 640x350/4 */ 385 (ORIG_VIDEO_MODE == 0x12) || /* 640x480/4 */ 386 (ORIG_VIDEO_MODE == 0x6A)) /* 800x600/4, 0x6A is very common */ 387 goto no_vga; 388 389 vga_video_num_lines = ORIG_VIDEO_LINES; 390 vga_video_num_columns = ORIG_VIDEO_COLS; 391 state.vgabase = NULL; 392 393 if (ORIG_VIDEO_MODE == 7) { /* Is this a monochrome display? */ 394 vga_vram_base = 0xb0000; 395 vga_video_port_reg = VGA_CRT_IM; 396 vga_video_port_val = VGA_CRT_DM; 397 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10) { 398 static struct resource ega_console_resource = 399 { .name = "ega", .start = 0x3B0, .end = 0x3BF }; 400 vga_video_type = VIDEO_TYPE_EGAM; 401 vga_vram_size = 0x8000; 402 display_desc = "EGA+"; 403 request_resource(&ioport_resource, 404 &ega_console_resource); 405 } else { 406 static struct resource mda1_console_resource = 407 { .name = "mda", .start = 0x3B0, .end = 0x3BB }; 408 static struct resource mda2_console_resource = 409 { .name = "mda", .start = 0x3BF, .end = 0x3BF }; 410 vga_video_type = VIDEO_TYPE_MDA; 411 vga_vram_size = 0x2000; 412 display_desc = "*MDA"; 413 request_resource(&ioport_resource, 414 &mda1_console_resource); 415 request_resource(&ioport_resource, 416 &mda2_console_resource); 417 vga_video_font_height = 14; 418 } 419 } else { 420 /* If not, it is color. */ 421 vga_can_do_color = 1; 422 vga_vram_base = 0xb8000; 423 vga_video_port_reg = VGA_CRT_IC; 424 vga_video_port_val = VGA_CRT_DC; 425 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10) { 426 int i; 427 428 vga_vram_size = 0x8000; 429 430 if (!ORIG_VIDEO_ISVGA) { 431 static struct resource ega_console_resource 432 = { .name = "ega", .start = 0x3C0, .end = 0x3DF }; 433 vga_video_type = VIDEO_TYPE_EGAC; 434 display_desc = "EGA"; 435 request_resource(&ioport_resource, 436 &ega_console_resource); 437 } else { 438 static struct resource vga_console_resource 439 = { .name = "vga+", .start = 0x3C0, .end = 0x3DF }; 440 vga_video_type = VIDEO_TYPE_VGAC; 441 display_desc = "VGA+"; 442 request_resource(&ioport_resource, 443 &vga_console_resource); 444 445 #ifdef VGA_CAN_DO_64KB 446 /* 447 * get 64K rather than 32K of video RAM. 448 * This doesn't actually work on all "VGA" 449 * controllers (it seems like setting MM=01 450 * and COE=1 isn't necessarily a good idea) 451 */ 452 vga_vram_base = 0xa0000; 453 vga_vram_size = 0x10000; 454 outb_p(6, VGA_GFX_I); 455 outb_p(6, VGA_GFX_D); 456 #endif 457 /* 458 * Normalise the palette registers, to point 459 * the 16 screen colours to the first 16 460 * DAC entries. 461 */ 462 463 for (i = 0; i < 16; i++) { 464 inb_p(VGA_IS1_RC); 465 outb_p(i, VGA_ATT_W); 466 outb_p(i, VGA_ATT_W); 467 } 468 outb_p(0x20, VGA_ATT_W); 469 470 /* 471 * Now set the DAC registers back to their 472 * default values 473 */ 474 for (i = 0; i < 16; i++) { 475 outb_p(color_table[i], VGA_PEL_IW); 476 outb_p(default_red[i], VGA_PEL_D); 477 outb_p(default_grn[i], VGA_PEL_D); 478 outb_p(default_blu[i], VGA_PEL_D); 479 } 480 } 481 } else { 482 static struct resource cga_console_resource = 483 { .name = "cga", .start = 0x3D4, .end = 0x3D5 }; 484 vga_video_type = VIDEO_TYPE_CGA; 485 vga_vram_size = 0x2000; 486 display_desc = "*CGA"; 487 request_resource(&ioport_resource, 488 &cga_console_resource); 489 vga_video_font_height = 8; 490 } 491 } 492 493 vga_vram_base = VGA_MAP_MEM(vga_vram_base, vga_vram_size); 494 vga_vram_end = vga_vram_base + vga_vram_size; 495 496 /* 497 * Find out if there is a graphics card present. 498 * Are there smarter methods around? 499 */ 500 p = (volatile u16 *) vga_vram_base; 501 saved1 = scr_readw(p); 502 saved2 = scr_readw(p + 1); 503 scr_writew(0xAA55, p); 504 scr_writew(0x55AA, p + 1); 505 if (scr_readw(p) != 0xAA55 || scr_readw(p + 1) != 0x55AA) { 506 scr_writew(saved1, p); 507 scr_writew(saved2, p + 1); 508 goto no_vga; 509 } 510 scr_writew(0x55AA, p); 511 scr_writew(0xAA55, p + 1); 512 if (scr_readw(p) != 0x55AA || scr_readw(p + 1) != 0xAA55) { 513 scr_writew(saved1, p); 514 scr_writew(saved2, p + 1); 515 goto no_vga; 516 } 517 scr_writew(saved1, p); 518 scr_writew(saved2, p + 1); 519 520 if (vga_video_type == VIDEO_TYPE_EGAC 521 || vga_video_type == VIDEO_TYPE_VGAC 522 || vga_video_type == VIDEO_TYPE_EGAM) { 523 vga_hardscroll_enabled = vga_hardscroll_user_enable; 524 vga_default_font_height = ORIG_VIDEO_POINTS; 525 vga_video_font_height = ORIG_VIDEO_POINTS; 526 /* This may be suboptimal but is a safe bet - go with it */ 527 vga_scan_lines = 528 vga_video_font_height * vga_video_num_lines; 529 } 530 531 vgacon_xres = ORIG_VIDEO_COLS * VGA_FONTWIDTH; 532 vgacon_yres = vga_scan_lines; 533 534 if (!vga_init_done) { 535 vgacon_scrollback_startup(); 536 vga_init_done = 1; 537 } 538 539 return display_desc; 540 } 541 542 static void vgacon_init(struct vc_data *c, int init) 543 { 544 unsigned long p; 545 546 /* 547 * We cannot be loaded as a module, therefore init is always 1, 548 * but vgacon_init can be called more than once, and init will 549 * not be 1. 550 */ 551 c->vc_can_do_color = vga_can_do_color; 552 553 /* set dimensions manually if init != 0 since vc_resize() will fail */ 554 if (init) { 555 c->vc_cols = vga_video_num_columns; 556 c->vc_rows = vga_video_num_lines; 557 } else 558 vc_resize(c, vga_video_num_columns, vga_video_num_lines); 559 560 c->vc_scan_lines = vga_scan_lines; 561 c->vc_font.height = vga_video_font_height; 562 c->vc_complement_mask = 0x7700; 563 if (vga_512_chars) 564 c->vc_hi_font_mask = 0x0800; 565 p = *c->vc_uni_pagedir_loc; 566 if (c->vc_uni_pagedir_loc == &c->vc_uni_pagedir || 567 !--c->vc_uni_pagedir_loc[1]) 568 con_free_unimap(c); 569 c->vc_uni_pagedir_loc = vgacon_uni_pagedir; 570 vgacon_uni_pagedir[1]++; 571 if (!vgacon_uni_pagedir[0] && p) 572 con_set_default_unimap(c); 573 } 574 575 static void vgacon_deinit(struct vc_data *c) 576 { 577 /* When closing the last console, reset video origin */ 578 if (!--vgacon_uni_pagedir[1]) { 579 c->vc_visible_origin = vga_vram_base; 580 vga_set_mem_top(c); 581 con_free_unimap(c); 582 } 583 c->vc_uni_pagedir_loc = &c->vc_uni_pagedir; 584 con_set_default_unimap(c); 585 } 586 587 static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity, 588 u8 blink, u8 underline, u8 reverse, u8 italic) 589 { 590 u8 attr = color; 591 592 if (vga_can_do_color) { 593 if (italic) 594 attr = (attr & 0xF0) | c->vc_itcolor; 595 else if (underline) 596 attr = (attr & 0xf0) | c->vc_ulcolor; 597 else if (intensity == 0) 598 attr = (attr & 0xf0) | c->vc_halfcolor; 599 } 600 if (reverse) 601 attr = 602 ((attr) & 0x88) | ((((attr) >> 4) | ((attr) << 4)) & 603 0x77); 604 if (blink) 605 attr ^= 0x80; 606 if (intensity == 2) 607 attr ^= 0x08; 608 if (!vga_can_do_color) { 609 if (italic) 610 attr = (attr & 0xF8) | 0x02; 611 else if (underline) 612 attr = (attr & 0xf8) | 0x01; 613 else if (intensity == 0) 614 attr = (attr & 0xf0) | 0x08; 615 } 616 return attr; 617 } 618 619 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count) 620 { 621 int col = vga_can_do_color; 622 623 while (count--) { 624 u16 a = scr_readw(p); 625 if (col) 626 a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) | 627 (((a) & 0x0700) << 4); 628 else 629 a ^= ((a & 0x0700) == 0x0100) ? 0x7000 : 0x7700; 630 scr_writew(a, p++); 631 } 632 } 633 634 static void vgacon_set_cursor_size(int xpos, int from, int to) 635 { 636 unsigned long flags; 637 int curs, cure; 638 639 #ifdef TRIDENT_GLITCH 640 if (xpos < 16) 641 from--, to--; 642 #endif 643 644 if ((from == cursor_size_lastfrom) && (to == cursor_size_lastto)) 645 return; 646 cursor_size_lastfrom = from; 647 cursor_size_lastto = to; 648 649 spin_lock_irqsave(&vga_lock, flags); 650 if (vga_video_type >= VIDEO_TYPE_VGAC) { 651 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg); 652 curs = inb_p(vga_video_port_val); 653 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg); 654 cure = inb_p(vga_video_port_val); 655 } else { 656 curs = 0; 657 cure = 0; 658 } 659 660 curs = (curs & 0xc0) | from; 661 cure = (cure & 0xe0) | to; 662 663 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg); 664 outb_p(curs, vga_video_port_val); 665 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg); 666 outb_p(cure, vga_video_port_val); 667 spin_unlock_irqrestore(&vga_lock, flags); 668 } 669 670 static void vgacon_cursor(struct vc_data *c, int mode) 671 { 672 if (c->vc_mode != KD_TEXT) 673 return; 674 675 vgacon_restore_screen(c); 676 677 switch (mode) { 678 case CM_ERASE: 679 write_vga(14, (c->vc_pos - vga_vram_base) / 2); 680 if (vga_video_type >= VIDEO_TYPE_VGAC) 681 vgacon_set_cursor_size(c->vc_x, 31, 30); 682 else 683 vgacon_set_cursor_size(c->vc_x, 31, 31); 684 break; 685 686 case CM_MOVE: 687 case CM_DRAW: 688 write_vga(14, (c->vc_pos - vga_vram_base) / 2); 689 switch (c->vc_cursor_type & 0x0f) { 690 case CUR_UNDERLINE: 691 vgacon_set_cursor_size(c->vc_x, 692 c->vc_font.height - 693 (c->vc_font.height < 694 10 ? 2 : 3), 695 c->vc_font.height - 696 (c->vc_font.height < 697 10 ? 1 : 2)); 698 break; 699 case CUR_TWO_THIRDS: 700 vgacon_set_cursor_size(c->vc_x, 701 c->vc_font.height / 3, 702 c->vc_font.height - 703 (c->vc_font.height < 704 10 ? 1 : 2)); 705 break; 706 case CUR_LOWER_THIRD: 707 vgacon_set_cursor_size(c->vc_x, 708 (c->vc_font.height * 2) / 3, 709 c->vc_font.height - 710 (c->vc_font.height < 711 10 ? 1 : 2)); 712 break; 713 case CUR_LOWER_HALF: 714 vgacon_set_cursor_size(c->vc_x, 715 c->vc_font.height / 2, 716 c->vc_font.height - 717 (c->vc_font.height < 718 10 ? 1 : 2)); 719 break; 720 case CUR_NONE: 721 if (vga_video_type >= VIDEO_TYPE_VGAC) 722 vgacon_set_cursor_size(c->vc_x, 31, 30); 723 else 724 vgacon_set_cursor_size(c->vc_x, 31, 31); 725 break; 726 default: 727 vgacon_set_cursor_size(c->vc_x, 1, 728 c->vc_font.height); 729 break; 730 } 731 break; 732 } 733 } 734 735 static int vgacon_doresize(struct vc_data *c, 736 unsigned int width, unsigned int height) 737 { 738 unsigned long flags; 739 unsigned int scanlines = height * c->vc_font.height; 740 u8 scanlines_lo = 0, r7 = 0, vsync_end = 0, mode, max_scan; 741 742 spin_lock_irqsave(&vga_lock, flags); 743 744 vgacon_xres = width * VGA_FONTWIDTH; 745 vgacon_yres = height * c->vc_font.height; 746 if (vga_video_type >= VIDEO_TYPE_VGAC) { 747 outb_p(VGA_CRTC_MAX_SCAN, vga_video_port_reg); 748 max_scan = inb_p(vga_video_port_val); 749 750 if (max_scan & 0x80) 751 scanlines <<= 1; 752 753 outb_p(VGA_CRTC_MODE, vga_video_port_reg); 754 mode = inb_p(vga_video_port_val); 755 756 if (mode & 0x04) 757 scanlines >>= 1; 758 759 scanlines -= 1; 760 scanlines_lo = scanlines & 0xff; 761 762 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg); 763 r7 = inb_p(vga_video_port_val) & ~0x42; 764 765 if (scanlines & 0x100) 766 r7 |= 0x02; 767 if (scanlines & 0x200) 768 r7 |= 0x40; 769 770 /* deprotect registers */ 771 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg); 772 vsync_end = inb_p(vga_video_port_val); 773 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg); 774 outb_p(vsync_end & ~0x80, vga_video_port_val); 775 } 776 777 outb_p(VGA_CRTC_H_DISP, vga_video_port_reg); 778 outb_p(width - 1, vga_video_port_val); 779 outb_p(VGA_CRTC_OFFSET, vga_video_port_reg); 780 outb_p(width >> 1, vga_video_port_val); 781 782 if (vga_video_type >= VIDEO_TYPE_VGAC) { 783 outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg); 784 outb_p(scanlines_lo, vga_video_port_val); 785 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg); 786 outb_p(r7,vga_video_port_val); 787 788 /* reprotect registers */ 789 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg); 790 outb_p(vsync_end, vga_video_port_val); 791 } 792 793 spin_unlock_irqrestore(&vga_lock, flags); 794 return 0; 795 } 796 797 static int vgacon_switch(struct vc_data *c) 798 { 799 int x = c->vc_cols * VGA_FONTWIDTH; 800 int y = c->vc_rows * c->vc_font.height; 801 int rows = ORIG_VIDEO_LINES * vga_default_font_height/ 802 c->vc_font.height; 803 /* 804 * We need to save screen size here as it's the only way 805 * we can spot the screen has been resized and we need to 806 * set size of freshly allocated screens ourselves. 807 */ 808 vga_video_num_columns = c->vc_cols; 809 vga_video_num_lines = c->vc_rows; 810 811 /* We can only copy out the size of the video buffer here, 812 * otherwise we get into VGA BIOS */ 813 814 if (!vga_is_gfx) { 815 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf, 816 c->vc_screenbuf_size > vga_vram_size ? 817 vga_vram_size : c->vc_screenbuf_size); 818 819 if ((vgacon_xres != x || vgacon_yres != y) && 820 (!(vga_video_num_columns % 2) && 821 vga_video_num_columns <= ORIG_VIDEO_COLS && 822 vga_video_num_lines <= rows)) 823 vgacon_doresize(c, c->vc_cols, c->vc_rows); 824 } 825 826 vgacon_scrollback_init(c->vc_size_row); 827 return 0; /* Redrawing not needed */ 828 } 829 830 static void vga_set_palette(struct vc_data *vc, unsigned char *table) 831 { 832 int i, j; 833 834 vga_w(state.vgabase, VGA_PEL_MSK, 0xff); 835 for (i = j = 0; i < 16; i++) { 836 vga_w(state.vgabase, VGA_PEL_IW, table[i]); 837 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2); 838 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2); 839 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2); 840 } 841 } 842 843 static int vgacon_set_palette(struct vc_data *vc, unsigned char *table) 844 { 845 #ifdef CAN_LOAD_PALETTE 846 if (vga_video_type != VIDEO_TYPE_VGAC || vga_palette_blanked 847 || !CON_IS_VISIBLE(vc)) 848 return -EINVAL; 849 vga_set_palette(vc, table); 850 return 0; 851 #else 852 return -EINVAL; 853 #endif 854 } 855 856 /* structure holding original VGA register settings */ 857 static struct { 858 unsigned char SeqCtrlIndex; /* Sequencer Index reg. */ 859 unsigned char CrtCtrlIndex; /* CRT-Contr. Index reg. */ 860 unsigned char CrtMiscIO; /* Miscellaneous register */ 861 unsigned char HorizontalTotal; /* CRT-Controller:00h */ 862 unsigned char HorizDisplayEnd; /* CRT-Controller:01h */ 863 unsigned char StartHorizRetrace; /* CRT-Controller:04h */ 864 unsigned char EndHorizRetrace; /* CRT-Controller:05h */ 865 unsigned char Overflow; /* CRT-Controller:07h */ 866 unsigned char StartVertRetrace; /* CRT-Controller:10h */ 867 unsigned char EndVertRetrace; /* CRT-Controller:11h */ 868 unsigned char ModeControl; /* CRT-Controller:17h */ 869 unsigned char ClockingMode; /* Seq-Controller:01h */ 870 } vga_state; 871 872 static void vga_vesa_blank(struct vgastate *state, int mode) 873 { 874 /* save original values of VGA controller registers */ 875 if (!vga_vesa_blanked) { 876 spin_lock_irq(&vga_lock); 877 vga_state.SeqCtrlIndex = vga_r(state->vgabase, VGA_SEQ_I); 878 vga_state.CrtCtrlIndex = inb_p(vga_video_port_reg); 879 vga_state.CrtMiscIO = vga_r(state->vgabase, VGA_MIS_R); 880 spin_unlock_irq(&vga_lock); 881 882 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */ 883 vga_state.HorizontalTotal = inb_p(vga_video_port_val); 884 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */ 885 vga_state.HorizDisplayEnd = inb_p(vga_video_port_val); 886 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */ 887 vga_state.StartHorizRetrace = inb_p(vga_video_port_val); 888 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */ 889 vga_state.EndHorizRetrace = inb_p(vga_video_port_val); 890 outb_p(0x07, vga_video_port_reg); /* Overflow */ 891 vga_state.Overflow = inb_p(vga_video_port_val); 892 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */ 893 vga_state.StartVertRetrace = inb_p(vga_video_port_val); 894 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */ 895 vga_state.EndVertRetrace = inb_p(vga_video_port_val); 896 outb_p(0x17, vga_video_port_reg); /* ModeControl */ 897 vga_state.ModeControl = inb_p(vga_video_port_val); 898 vga_state.ClockingMode = vga_rseq(state->vgabase, VGA_SEQ_CLOCK_MODE); 899 } 900 901 /* assure that video is enabled */ 902 /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */ 903 spin_lock_irq(&vga_lock); 904 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode | 0x20); 905 906 /* test for vertical retrace in process.... */ 907 if ((vga_state.CrtMiscIO & 0x80) == 0x80) 908 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO & 0xEF); 909 910 /* 911 * Set <End of vertical retrace> to minimum (0) and 912 * <Start of vertical Retrace> to maximum (incl. overflow) 913 * Result: turn off vertical sync (VSync) pulse. 914 */ 915 if (mode & VESA_VSYNC_SUSPEND) { 916 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */ 917 outb_p(0xff, vga_video_port_val); /* maximum value */ 918 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */ 919 outb_p(0x40, vga_video_port_val); /* minimum (bits 0..3) */ 920 outb_p(0x07, vga_video_port_reg); /* Overflow */ 921 outb_p(vga_state.Overflow | 0x84, vga_video_port_val); /* bits 9,10 of vert. retrace */ 922 } 923 924 if (mode & VESA_HSYNC_SUSPEND) { 925 /* 926 * Set <End of horizontal retrace> to minimum (0) and 927 * <Start of horizontal Retrace> to maximum 928 * Result: turn off horizontal sync (HSync) pulse. 929 */ 930 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */ 931 outb_p(0xff, vga_video_port_val); /* maximum */ 932 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */ 933 outb_p(0x00, vga_video_port_val); /* minimum (0) */ 934 } 935 936 /* restore both index registers */ 937 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex); 938 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg); 939 spin_unlock_irq(&vga_lock); 940 } 941 942 static void vga_vesa_unblank(struct vgastate *state) 943 { 944 /* restore original values of VGA controller registers */ 945 spin_lock_irq(&vga_lock); 946 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO); 947 948 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */ 949 outb_p(vga_state.HorizontalTotal, vga_video_port_val); 950 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */ 951 outb_p(vga_state.HorizDisplayEnd, vga_video_port_val); 952 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */ 953 outb_p(vga_state.StartHorizRetrace, vga_video_port_val); 954 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */ 955 outb_p(vga_state.EndHorizRetrace, vga_video_port_val); 956 outb_p(0x07, vga_video_port_reg); /* Overflow */ 957 outb_p(vga_state.Overflow, vga_video_port_val); 958 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */ 959 outb_p(vga_state.StartVertRetrace, vga_video_port_val); 960 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */ 961 outb_p(vga_state.EndVertRetrace, vga_video_port_val); 962 outb_p(0x17, vga_video_port_reg); /* ModeControl */ 963 outb_p(vga_state.ModeControl, vga_video_port_val); 964 /* ClockingMode */ 965 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode); 966 967 /* restore index/control registers */ 968 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex); 969 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg); 970 spin_unlock_irq(&vga_lock); 971 } 972 973 static void vga_pal_blank(struct vgastate *state) 974 { 975 int i; 976 977 vga_w(state->vgabase, VGA_PEL_MSK, 0xff); 978 for (i = 0; i < 16; i++) { 979 vga_w(state->vgabase, VGA_PEL_IW, i); 980 vga_w(state->vgabase, VGA_PEL_D, 0); 981 vga_w(state->vgabase, VGA_PEL_D, 0); 982 vga_w(state->vgabase, VGA_PEL_D, 0); 983 } 984 } 985 986 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch) 987 { 988 switch (blank) { 989 case 0: /* Unblank */ 990 if (vga_vesa_blanked) { 991 vga_vesa_unblank(&state); 992 vga_vesa_blanked = 0; 993 } 994 if (vga_palette_blanked) { 995 vga_set_palette(c, color_table); 996 vga_palette_blanked = 0; 997 return 0; 998 } 999 vga_is_gfx = 0; 1000 /* Tell console.c that it has to restore the screen itself */ 1001 return 1; 1002 case 1: /* Normal blanking */ 1003 case -1: /* Obsolete */ 1004 if (!mode_switch && vga_video_type == VIDEO_TYPE_VGAC) { 1005 vga_pal_blank(&state); 1006 vga_palette_blanked = 1; 1007 return 0; 1008 } 1009 vgacon_set_origin(c); 1010 scr_memsetw((void *) vga_vram_base, BLANK, 1011 c->vc_screenbuf_size); 1012 if (mode_switch) 1013 vga_is_gfx = 1; 1014 return 1; 1015 default: /* VESA blanking */ 1016 if (vga_video_type == VIDEO_TYPE_VGAC) { 1017 vga_vesa_blank(&state, blank - 1); 1018 vga_vesa_blanked = blank; 1019 } 1020 return 0; 1021 } 1022 } 1023 1024 /* 1025 * PIO_FONT support. 1026 * 1027 * The font loading code goes back to the codepage package by 1028 * Joel Hoffman (joel@wam.umd.edu). (He reports that the original 1029 * reference is: "From: p. 307 of _Programmer's Guide to PC & PS/2 1030 * Video Systems_ by Richard Wilton. 1987. Microsoft Press".) 1031 * 1032 * Change for certain monochrome monitors by Yury Shevchuck 1033 * (sizif@botik.yaroslavl.su). 1034 */ 1035 1036 #ifdef CAN_LOAD_EGA_FONTS 1037 1038 #define colourmap 0xa0000 1039 /* Pauline Middelink <middelin@polyware.iaf.nl> reports that we 1040 should use 0xA0000 for the bwmap as well.. */ 1041 #define blackwmap 0xa0000 1042 #define cmapsz 8192 1043 1044 static int vgacon_do_font_op(struct vgastate *state,char *arg,int set,int ch512) 1045 { 1046 unsigned short video_port_status = vga_video_port_reg + 6; 1047 int font_select = 0x00, beg, i; 1048 char *charmap; 1049 1050 if (vga_video_type != VIDEO_TYPE_EGAM) { 1051 charmap = (char *) VGA_MAP_MEM(colourmap, 0); 1052 beg = 0x0e; 1053 #ifdef VGA_CAN_DO_64KB 1054 if (vga_video_type == VIDEO_TYPE_VGAC) 1055 beg = 0x06; 1056 #endif 1057 } else { 1058 charmap = (char *) VGA_MAP_MEM(blackwmap, 0); 1059 beg = 0x0a; 1060 } 1061 1062 #ifdef BROKEN_GRAPHICS_PROGRAMS 1063 /* 1064 * All fonts are loaded in slot 0 (0:1 for 512 ch) 1065 */ 1066 1067 if (!arg) 1068 return -EINVAL; /* Return to default font not supported */ 1069 1070 vga_font_is_default = 0; 1071 font_select = ch512 ? 0x04 : 0x00; 1072 #else 1073 /* 1074 * The default font is kept in slot 0 and is never touched. 1075 * A custom font is loaded in slot 2 (256 ch) or 2:3 (512 ch) 1076 */ 1077 1078 if (set) { 1079 vga_font_is_default = !arg; 1080 if (!arg) 1081 ch512 = 0; /* Default font is always 256 */ 1082 font_select = arg ? (ch512 ? 0x0e : 0x0a) : 0x00; 1083 } 1084 1085 if (!vga_font_is_default) 1086 charmap += 4 * cmapsz; 1087 #endif 1088 1089 unlock_kernel(); 1090 spin_lock_irq(&vga_lock); 1091 /* First, the Sequencer */ 1092 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1); 1093 /* CPU writes only to map 2 */ 1094 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x04); 1095 /* Sequential addressing */ 1096 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x07); 1097 /* Clear synchronous reset */ 1098 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03); 1099 1100 /* Now, the graphics controller, select map 2 */ 1101 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x02); 1102 /* disable odd-even addressing */ 1103 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x00); 1104 /* map start at A000:0000 */ 1105 vga_wgfx(state->vgabase, VGA_GFX_MISC, 0x00); 1106 spin_unlock_irq(&vga_lock); 1107 1108 if (arg) { 1109 if (set) 1110 for (i = 0; i < cmapsz; i++) 1111 vga_writeb(arg[i], charmap + i); 1112 else 1113 for (i = 0; i < cmapsz; i++) 1114 arg[i] = vga_readb(charmap + i); 1115 1116 /* 1117 * In 512-character mode, the character map is not contiguous if 1118 * we want to remain EGA compatible -- which we do 1119 */ 1120 1121 if (ch512) { 1122 charmap += 2 * cmapsz; 1123 arg += cmapsz; 1124 if (set) 1125 for (i = 0; i < cmapsz; i++) 1126 vga_writeb(arg[i], charmap + i); 1127 else 1128 for (i = 0; i < cmapsz; i++) 1129 arg[i] = vga_readb(charmap + i); 1130 } 1131 } 1132 1133 spin_lock_irq(&vga_lock); 1134 /* First, the sequencer, Synchronous reset */ 1135 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x01); 1136 /* CPU writes to maps 0 and 1 */ 1137 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x03); 1138 /* odd-even addressing */ 1139 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x03); 1140 /* Character Map Select */ 1141 if (set) 1142 vga_wseq(state->vgabase, VGA_SEQ_CHARACTER_MAP, font_select); 1143 /* clear synchronous reset */ 1144 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03); 1145 1146 /* Now, the graphics controller, select map 0 for CPU */ 1147 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x00); 1148 /* enable even-odd addressing */ 1149 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x10); 1150 /* map starts at b800:0 or b000:0 */ 1151 vga_wgfx(state->vgabase, VGA_GFX_MISC, beg); 1152 1153 /* if 512 char mode is already enabled don't re-enable it. */ 1154 if ((set) && (ch512 != vga_512_chars)) { 1155 int i; 1156 1157 /* attribute controller */ 1158 for (i = 0; i < MAX_NR_CONSOLES; i++) { 1159 struct vc_data *c = vc_cons[i].d; 1160 if (c && c->vc_sw == &vga_con) 1161 c->vc_hi_font_mask = ch512 ? 0x0800 : 0; 1162 } 1163 vga_512_chars = ch512; 1164 /* 256-char: enable intensity bit 1165 512-char: disable intensity bit */ 1166 inb_p(video_port_status); /* clear address flip-flop */ 1167 /* color plane enable register */ 1168 vga_wattr(state->vgabase, VGA_ATC_PLANE_ENABLE, ch512 ? 0x07 : 0x0f); 1169 /* Wilton (1987) mentions the following; I don't know what 1170 it means, but it works, and it appears necessary */ 1171 inb_p(video_port_status); 1172 vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0); 1173 } 1174 spin_unlock_irq(&vga_lock); 1175 lock_kernel(); 1176 return 0; 1177 } 1178 1179 /* 1180 * Adjust the screen to fit a font of a certain height 1181 */ 1182 static int vgacon_adjust_height(struct vc_data *vc, unsigned fontheight) 1183 { 1184 unsigned char ovr, vde, fsr; 1185 int rows, maxscan, i; 1186 1187 rows = vc->vc_scan_lines / fontheight; /* Number of video rows we end up with */ 1188 maxscan = rows * fontheight - 1; /* Scan lines to actually display-1 */ 1189 1190 /* Reprogram the CRTC for the new font size 1191 Note: the attempt to read the overflow register will fail 1192 on an EGA, but using 0xff for the previous value appears to 1193 be OK for EGA text modes in the range 257-512 scan lines, so I 1194 guess we don't need to worry about it. 1195 1196 The same applies for the spill bits in the font size and cursor 1197 registers; they are write-only on EGA, but it appears that they 1198 are all don't care bits on EGA, so I guess it doesn't matter. */ 1199 1200 spin_lock_irq(&vga_lock); 1201 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */ 1202 ovr = inb_p(vga_video_port_val); 1203 outb_p(0x09, vga_video_port_reg); /* Font size register */ 1204 fsr = inb_p(vga_video_port_val); 1205 spin_unlock_irq(&vga_lock); 1206 1207 vde = maxscan & 0xff; /* Vertical display end reg */ 1208 ovr = (ovr & 0xbd) + /* Overflow register */ 1209 ((maxscan & 0x100) >> 7) + ((maxscan & 0x200) >> 3); 1210 fsr = (fsr & 0xe0) + (fontheight - 1); /* Font size register */ 1211 1212 spin_lock_irq(&vga_lock); 1213 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */ 1214 outb_p(ovr, vga_video_port_val); 1215 outb_p(0x09, vga_video_port_reg); /* Font size */ 1216 outb_p(fsr, vga_video_port_val); 1217 outb_p(0x12, vga_video_port_reg); /* Vertical display limit */ 1218 outb_p(vde, vga_video_port_val); 1219 spin_unlock_irq(&vga_lock); 1220 vga_video_font_height = fontheight; 1221 1222 for (i = 0; i < MAX_NR_CONSOLES; i++) { 1223 struct vc_data *c = vc_cons[i].d; 1224 1225 if (c && c->vc_sw == &vga_con) { 1226 if (CON_IS_VISIBLE(c)) { 1227 /* void size to cause regs to be rewritten */ 1228 cursor_size_lastfrom = 0; 1229 cursor_size_lastto = 0; 1230 c->vc_sw->con_cursor(c, CM_DRAW); 1231 } 1232 c->vc_font.height = fontheight; 1233 vc_resize(c, 0, rows); /* Adjust console size */ 1234 } 1235 } 1236 return 0; 1237 } 1238 1239 static int vgacon_font_set(struct vc_data *c, struct console_font *font, unsigned flags) 1240 { 1241 unsigned charcount = font->charcount; 1242 int rc; 1243 1244 if (vga_video_type < VIDEO_TYPE_EGAM) 1245 return -EINVAL; 1246 1247 if (font->width != VGA_FONTWIDTH || 1248 (charcount != 256 && charcount != 512)) 1249 return -EINVAL; 1250 1251 rc = vgacon_do_font_op(&state, font->data, 1, charcount == 512); 1252 if (rc) 1253 return rc; 1254 1255 if (!(flags & KD_FONT_FLAG_DONT_RECALC)) 1256 rc = vgacon_adjust_height(c, font->height); 1257 return rc; 1258 } 1259 1260 static int vgacon_font_get(struct vc_data *c, struct console_font *font) 1261 { 1262 if (vga_video_type < VIDEO_TYPE_EGAM) 1263 return -EINVAL; 1264 1265 font->width = VGA_FONTWIDTH; 1266 font->height = c->vc_font.height; 1267 font->charcount = vga_512_chars ? 512 : 256; 1268 if (!font->data) 1269 return 0; 1270 return vgacon_do_font_op(&state, font->data, 0, 0); 1271 } 1272 1273 #else 1274 1275 #define vgacon_font_set NULL 1276 #define vgacon_font_get NULL 1277 1278 #endif 1279 1280 static int vgacon_resize(struct vc_data *c, unsigned int width, 1281 unsigned int height) 1282 { 1283 if (width % 2 || width > ORIG_VIDEO_COLS || 1284 height > (ORIG_VIDEO_LINES * vga_default_font_height)/ 1285 c->vc_font.height) 1286 /* let svgatextmode tinker with video timings */ 1287 return 0; 1288 1289 if (CON_IS_VISIBLE(c) && !vga_is_gfx) /* who knows */ 1290 vgacon_doresize(c, width, height); 1291 return 0; 1292 } 1293 1294 static int vgacon_set_origin(struct vc_data *c) 1295 { 1296 if (vga_is_gfx || /* We don't play origin tricks in graphic modes */ 1297 (console_blanked && !vga_palette_blanked)) /* Nor we write to blanked screens */ 1298 return 0; 1299 c->vc_origin = c->vc_visible_origin = vga_vram_base; 1300 vga_set_mem_top(c); 1301 vga_rolled_over = 0; 1302 return 1; 1303 } 1304 1305 static void vgacon_save_screen(struct vc_data *c) 1306 { 1307 static int vga_bootup_console = 0; 1308 1309 if (!vga_bootup_console) { 1310 /* This is a gross hack, but here is the only place we can 1311 * set bootup console parameters without messing up generic 1312 * console initialization routines. 1313 */ 1314 vga_bootup_console = 1; 1315 c->vc_x = ORIG_X; 1316 c->vc_y = ORIG_Y; 1317 } 1318 1319 /* We can't copy in more then the size of the video buffer, 1320 * or we'll be copying in VGA BIOS */ 1321 1322 if (!vga_is_gfx) 1323 scr_memcpyw((u16 *) c->vc_screenbuf, (u16 *) c->vc_origin, 1324 c->vc_screenbuf_size > vga_vram_size ? vga_vram_size : c->vc_screenbuf_size); 1325 } 1326 1327 static int vgacon_scroll(struct vc_data *c, int t, int b, int dir, 1328 int lines) 1329 { 1330 unsigned long oldo; 1331 unsigned int delta; 1332 1333 if (t || b != c->vc_rows || vga_is_gfx || c->vc_mode != KD_TEXT) 1334 return 0; 1335 1336 if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2) 1337 return 0; 1338 1339 vgacon_restore_screen(c); 1340 oldo = c->vc_origin; 1341 delta = lines * c->vc_size_row; 1342 if (dir == SM_UP) { 1343 vgacon_scrollback_update(c, t, lines); 1344 if (c->vc_scr_end + delta >= vga_vram_end) { 1345 scr_memcpyw((u16 *) vga_vram_base, 1346 (u16 *) (oldo + delta), 1347 c->vc_screenbuf_size - delta); 1348 c->vc_origin = vga_vram_base; 1349 vga_rolled_over = oldo - vga_vram_base; 1350 } else 1351 c->vc_origin += delta; 1352 scr_memsetw((u16 *) (c->vc_origin + c->vc_screenbuf_size - 1353 delta), c->vc_video_erase_char, 1354 delta); 1355 } else { 1356 if (oldo - delta < vga_vram_base) { 1357 scr_memmovew((u16 *) (vga_vram_end - 1358 c->vc_screenbuf_size + 1359 delta), (u16 *) oldo, 1360 c->vc_screenbuf_size - delta); 1361 c->vc_origin = vga_vram_end - c->vc_screenbuf_size; 1362 vga_rolled_over = 0; 1363 } else 1364 c->vc_origin -= delta; 1365 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size; 1366 scr_memsetw((u16 *) (c->vc_origin), c->vc_video_erase_char, 1367 delta); 1368 } 1369 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size; 1370 c->vc_visible_origin = c->vc_origin; 1371 vga_set_mem_top(c); 1372 c->vc_pos = (c->vc_pos - oldo) + c->vc_origin; 1373 return 1; 1374 } 1375 1376 1377 /* 1378 * The console `switch' structure for the VGA based console 1379 */ 1380 1381 static int vgacon_dummy(struct vc_data *c) 1382 { 1383 return 0; 1384 } 1385 1386 #define DUMMY (void *) vgacon_dummy 1387 1388 const struct consw vga_con = { 1389 .owner = THIS_MODULE, 1390 .con_startup = vgacon_startup, 1391 .con_init = vgacon_init, 1392 .con_deinit = vgacon_deinit, 1393 .con_clear = DUMMY, 1394 .con_putc = DUMMY, 1395 .con_putcs = DUMMY, 1396 .con_cursor = vgacon_cursor, 1397 .con_scroll = vgacon_scroll, 1398 .con_bmove = DUMMY, 1399 .con_switch = vgacon_switch, 1400 .con_blank = vgacon_blank, 1401 .con_font_set = vgacon_font_set, 1402 .con_font_get = vgacon_font_get, 1403 .con_resize = vgacon_resize, 1404 .con_set_palette = vgacon_set_palette, 1405 .con_scrolldelta = vgacon_scrolldelta, 1406 .con_set_origin = vgacon_set_origin, 1407 .con_save_screen = vgacon_save_screen, 1408 .con_build_attr = vgacon_build_attr, 1409 .con_invert_region = vgacon_invert_region, 1410 }; 1411 1412 MODULE_LICENSE("GPL"); 1413