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; 243 244 if (!lines) { 245 c->vc_visible_origin = c->vc_origin; 246 vga_set_mem_top(c); 247 return 1; 248 } 249 250 if (!vgacon_scrollback) 251 return 1; 252 253 if (!vgacon_scrollback_save) { 254 vgacon_cursor(c, CM_ERASE); 255 vgacon_save_screen(c); 256 vgacon_scrollback_save = 1; 257 } 258 259 vgacon_scrollback_restore = 0; 260 start = vgacon_scrollback_cur + lines; 261 end = start + abs(lines); 262 263 if (start < 0) 264 start = 0; 265 266 if (start > vgacon_scrollback_cnt) 267 start = vgacon_scrollback_cnt; 268 269 if (end < 0) 270 end = 0; 271 272 if (end > vgacon_scrollback_cnt) 273 end = vgacon_scrollback_cnt; 274 275 vgacon_scrollback_cur = start; 276 count = end - start; 277 soff = vgacon_scrollback_tail - ((vgacon_scrollback_cnt - end) * 278 c->vc_size_row); 279 soff -= count * c->vc_size_row; 280 281 if (soff < 0) 282 soff += vgacon_scrollback_size; 283 284 count = vgacon_scrollback_cnt - start; 285 286 if (count > c->vc_rows) 287 count = c->vc_rows; 288 289 if (count) { 290 int copysize; 291 292 int diff = c->vc_rows - count; 293 void *d = (void *) c->vc_origin; 294 void *s = (void *) c->vc_screenbuf; 295 296 count *= c->vc_size_row; 297 /* how much memory to end of buffer left? */ 298 copysize = min(count, vgacon_scrollback_size - soff); 299 scr_memcpyw(d, vgacon_scrollback + soff, copysize); 300 d += copysize; 301 count -= copysize; 302 303 if (count) { 304 scr_memcpyw(d, vgacon_scrollback, count); 305 d += count; 306 } 307 308 if (diff) 309 scr_memcpyw(d, s, diff * c->vc_size_row); 310 } else 311 vgacon_cursor(c, CM_MOVE); 312 313 return 1; 314 } 315 #else 316 #define vgacon_scrollback_startup(...) do { } while (0) 317 #define vgacon_scrollback_init(...) do { } while (0) 318 #define vgacon_scrollback_update(...) do { } while (0) 319 320 static void vgacon_restore_screen(struct vc_data *c) 321 { 322 if (c->vc_origin != c->vc_visible_origin) 323 vgacon_scrolldelta(c, 0); 324 } 325 326 static int vgacon_scrolldelta(struct vc_data *c, int lines) 327 { 328 if (!lines) /* Turn scrollback off */ 329 c->vc_visible_origin = c->vc_origin; 330 else { 331 int margin = c->vc_size_row * 4; 332 int ul, we, p, st; 333 334 if (vga_rolled_over > 335 (c->vc_scr_end - vga_vram_base) + margin) { 336 ul = c->vc_scr_end - vga_vram_base; 337 we = vga_rolled_over + c->vc_size_row; 338 } else { 339 ul = 0; 340 we = vga_vram_size; 341 } 342 p = (c->vc_visible_origin - vga_vram_base - ul + we) % we + 343 lines * c->vc_size_row; 344 st = (c->vc_origin - vga_vram_base - ul + we) % we; 345 if (st < 2 * margin) 346 margin = 0; 347 if (p < margin) 348 p = 0; 349 if (p > st - margin) 350 p = st; 351 c->vc_visible_origin = vga_vram_base + (p + ul) % we; 352 } 353 vga_set_mem_top(c); 354 return 1; 355 } 356 #endif /* CONFIG_VGACON_SOFT_SCROLLBACK */ 357 358 static const char *vgacon_startup(void) 359 { 360 const char *display_desc = NULL; 361 u16 saved1, saved2; 362 volatile u16 *p; 363 364 if (screen_info.orig_video_isVGA == VIDEO_TYPE_VLFB) { 365 no_vga: 366 #ifdef CONFIG_DUMMY_CONSOLE 367 conswitchp = &dummy_con; 368 return conswitchp->con_startup(); 369 #else 370 return NULL; 371 #endif 372 } 373 374 /* boot_params.screen_info initialized? */ 375 if ((screen_info.orig_video_mode == 0) && 376 (screen_info.orig_video_lines == 0) && 377 (screen_info.orig_video_cols == 0)) 378 goto no_vga; 379 380 /* VGA16 modes are not handled by VGACON */ 381 if ((screen_info.orig_video_mode == 0x0D) || /* 320x200/4 */ 382 (screen_info.orig_video_mode == 0x0E) || /* 640x200/4 */ 383 (screen_info.orig_video_mode == 0x10) || /* 640x350/4 */ 384 (screen_info.orig_video_mode == 0x12) || /* 640x480/4 */ 385 (screen_info.orig_video_mode == 0x6A)) /* 800x600/4 (VESA) */ 386 goto no_vga; 387 388 vga_video_num_lines = screen_info.orig_video_lines; 389 vga_video_num_columns = screen_info.orig_video_cols; 390 state.vgabase = NULL; 391 392 if (screen_info.orig_video_mode == 7) { 393 /* 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 ((screen_info.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 ((screen_info.orig_video_ega_bx & 0xff) != 0x10) { 426 int i; 427 428 vga_vram_size = 0x8000; 429 430 if (!screen_info.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 = screen_info.orig_video_points; 525 vga_video_font_height = screen_info.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 = screen_info.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 = screen_info.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 <= screen_info.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 /* attribute controller */ 1156 for (i = 0; i < MAX_NR_CONSOLES; i++) { 1157 struct vc_data *c = vc_cons[i].d; 1158 if (c && c->vc_sw == &vga_con) 1159 c->vc_hi_font_mask = ch512 ? 0x0800 : 0; 1160 } 1161 vga_512_chars = ch512; 1162 /* 256-char: enable intensity bit 1163 512-char: disable intensity bit */ 1164 inb_p(video_port_status); /* clear address flip-flop */ 1165 /* color plane enable register */ 1166 vga_wattr(state->vgabase, VGA_ATC_PLANE_ENABLE, ch512 ? 0x07 : 0x0f); 1167 /* Wilton (1987) mentions the following; I don't know what 1168 it means, but it works, and it appears necessary */ 1169 inb_p(video_port_status); 1170 vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0); 1171 } 1172 spin_unlock_irq(&vga_lock); 1173 lock_kernel(); 1174 return 0; 1175 } 1176 1177 /* 1178 * Adjust the screen to fit a font of a certain height 1179 */ 1180 static int vgacon_adjust_height(struct vc_data *vc, unsigned fontheight) 1181 { 1182 unsigned char ovr, vde, fsr; 1183 int rows, maxscan, i; 1184 1185 rows = vc->vc_scan_lines / fontheight; /* Number of video rows we end up with */ 1186 maxscan = rows * fontheight - 1; /* Scan lines to actually display-1 */ 1187 1188 /* Reprogram the CRTC for the new font size 1189 Note: the attempt to read the overflow register will fail 1190 on an EGA, but using 0xff for the previous value appears to 1191 be OK for EGA text modes in the range 257-512 scan lines, so I 1192 guess we don't need to worry about it. 1193 1194 The same applies for the spill bits in the font size and cursor 1195 registers; they are write-only on EGA, but it appears that they 1196 are all don't care bits on EGA, so I guess it doesn't matter. */ 1197 1198 spin_lock_irq(&vga_lock); 1199 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */ 1200 ovr = inb_p(vga_video_port_val); 1201 outb_p(0x09, vga_video_port_reg); /* Font size register */ 1202 fsr = inb_p(vga_video_port_val); 1203 spin_unlock_irq(&vga_lock); 1204 1205 vde = maxscan & 0xff; /* Vertical display end reg */ 1206 ovr = (ovr & 0xbd) + /* Overflow register */ 1207 ((maxscan & 0x100) >> 7) + ((maxscan & 0x200) >> 3); 1208 fsr = (fsr & 0xe0) + (fontheight - 1); /* Font size register */ 1209 1210 spin_lock_irq(&vga_lock); 1211 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */ 1212 outb_p(ovr, vga_video_port_val); 1213 outb_p(0x09, vga_video_port_reg); /* Font size */ 1214 outb_p(fsr, vga_video_port_val); 1215 outb_p(0x12, vga_video_port_reg); /* Vertical display limit */ 1216 outb_p(vde, vga_video_port_val); 1217 spin_unlock_irq(&vga_lock); 1218 vga_video_font_height = fontheight; 1219 1220 for (i = 0; i < MAX_NR_CONSOLES; i++) { 1221 struct vc_data *c = vc_cons[i].d; 1222 1223 if (c && c->vc_sw == &vga_con) { 1224 if (CON_IS_VISIBLE(c)) { 1225 /* void size to cause regs to be rewritten */ 1226 cursor_size_lastfrom = 0; 1227 cursor_size_lastto = 0; 1228 c->vc_sw->con_cursor(c, CM_DRAW); 1229 } 1230 c->vc_font.height = fontheight; 1231 vc_resize(c, 0, rows); /* Adjust console size */ 1232 } 1233 } 1234 return 0; 1235 } 1236 1237 static int vgacon_font_set(struct vc_data *c, struct console_font *font, unsigned flags) 1238 { 1239 unsigned charcount = font->charcount; 1240 int rc; 1241 1242 if (vga_video_type < VIDEO_TYPE_EGAM) 1243 return -EINVAL; 1244 1245 if (font->width != VGA_FONTWIDTH || 1246 (charcount != 256 && charcount != 512)) 1247 return -EINVAL; 1248 1249 rc = vgacon_do_font_op(&state, font->data, 1, charcount == 512); 1250 if (rc) 1251 return rc; 1252 1253 if (!(flags & KD_FONT_FLAG_DONT_RECALC)) 1254 rc = vgacon_adjust_height(c, font->height); 1255 return rc; 1256 } 1257 1258 static int vgacon_font_get(struct vc_data *c, struct console_font *font) 1259 { 1260 if (vga_video_type < VIDEO_TYPE_EGAM) 1261 return -EINVAL; 1262 1263 font->width = VGA_FONTWIDTH; 1264 font->height = c->vc_font.height; 1265 font->charcount = vga_512_chars ? 512 : 256; 1266 if (!font->data) 1267 return 0; 1268 return vgacon_do_font_op(&state, font->data, 0, 0); 1269 } 1270 1271 #else 1272 1273 #define vgacon_font_set NULL 1274 #define vgacon_font_get NULL 1275 1276 #endif 1277 1278 static int vgacon_resize(struct vc_data *c, unsigned int width, 1279 unsigned int height, unsigned int user) 1280 { 1281 if (width % 2 || width > screen_info.orig_video_cols || 1282 height > (screen_info.orig_video_lines * vga_default_font_height)/ 1283 c->vc_font.height) 1284 /* let svgatextmode tinker with video timings and 1285 return success */ 1286 return (user) ? 0 : -EINVAL; 1287 1288 if (CON_IS_VISIBLE(c) && !vga_is_gfx) /* who knows */ 1289 vgacon_doresize(c, width, height); 1290 return 0; 1291 } 1292 1293 static int vgacon_set_origin(struct vc_data *c) 1294 { 1295 if (vga_is_gfx || /* We don't play origin tricks in graphic modes */ 1296 (console_blanked && !vga_palette_blanked)) /* Nor we write to blanked screens */ 1297 return 0; 1298 c->vc_origin = c->vc_visible_origin = vga_vram_base; 1299 vga_set_mem_top(c); 1300 vga_rolled_over = 0; 1301 return 1; 1302 } 1303 1304 static void vgacon_save_screen(struct vc_data *c) 1305 { 1306 static int vga_bootup_console = 0; 1307 1308 if (!vga_bootup_console) { 1309 /* This is a gross hack, but here is the only place we can 1310 * set bootup console parameters without messing up generic 1311 * console initialization routines. 1312 */ 1313 vga_bootup_console = 1; 1314 c->vc_x = screen_info.orig_x; 1315 c->vc_y = screen_info.orig_y; 1316 } 1317 1318 /* We can't copy in more then the size of the video buffer, 1319 * or we'll be copying in VGA BIOS */ 1320 1321 if (!vga_is_gfx) 1322 scr_memcpyw((u16 *) c->vc_screenbuf, (u16 *) c->vc_origin, 1323 c->vc_screenbuf_size > vga_vram_size ? vga_vram_size : c->vc_screenbuf_size); 1324 } 1325 1326 static int vgacon_scroll(struct vc_data *c, int t, int b, int dir, 1327 int lines) 1328 { 1329 unsigned long oldo; 1330 unsigned int delta; 1331 1332 if (t || b != c->vc_rows || vga_is_gfx || c->vc_mode != KD_TEXT) 1333 return 0; 1334 1335 if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2) 1336 return 0; 1337 1338 vgacon_restore_screen(c); 1339 oldo = c->vc_origin; 1340 delta = lines * c->vc_size_row; 1341 if (dir == SM_UP) { 1342 vgacon_scrollback_update(c, t, lines); 1343 if (c->vc_scr_end + delta >= vga_vram_end) { 1344 scr_memcpyw((u16 *) vga_vram_base, 1345 (u16 *) (oldo + delta), 1346 c->vc_screenbuf_size - delta); 1347 c->vc_origin = vga_vram_base; 1348 vga_rolled_over = oldo - vga_vram_base; 1349 } else 1350 c->vc_origin += delta; 1351 scr_memsetw((u16 *) (c->vc_origin + c->vc_screenbuf_size - 1352 delta), c->vc_video_erase_char, 1353 delta); 1354 } else { 1355 if (oldo - delta < vga_vram_base) { 1356 scr_memmovew((u16 *) (vga_vram_end - 1357 c->vc_screenbuf_size + 1358 delta), (u16 *) oldo, 1359 c->vc_screenbuf_size - delta); 1360 c->vc_origin = vga_vram_end - c->vc_screenbuf_size; 1361 vga_rolled_over = 0; 1362 } else 1363 c->vc_origin -= delta; 1364 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size; 1365 scr_memsetw((u16 *) (c->vc_origin), c->vc_video_erase_char, 1366 delta); 1367 } 1368 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size; 1369 c->vc_visible_origin = c->vc_origin; 1370 vga_set_mem_top(c); 1371 c->vc_pos = (c->vc_pos - oldo) + c->vc_origin; 1372 return 1; 1373 } 1374 1375 1376 /* 1377 * The console `switch' structure for the VGA based console 1378 */ 1379 1380 static int vgacon_dummy(struct vc_data *c) 1381 { 1382 return 0; 1383 } 1384 1385 #define DUMMY (void *) vgacon_dummy 1386 1387 const struct consw vga_con = { 1388 .owner = THIS_MODULE, 1389 .con_startup = vgacon_startup, 1390 .con_init = vgacon_init, 1391 .con_deinit = vgacon_deinit, 1392 .con_clear = DUMMY, 1393 .con_putc = DUMMY, 1394 .con_putcs = DUMMY, 1395 .con_cursor = vgacon_cursor, 1396 .con_scroll = vgacon_scroll, 1397 .con_bmove = DUMMY, 1398 .con_switch = vgacon_switch, 1399 .con_blank = vgacon_blank, 1400 .con_font_set = vgacon_font_set, 1401 .con_font_get = vgacon_font_get, 1402 .con_resize = vgacon_resize, 1403 .con_set_palette = vgacon_set_palette, 1404 .con_scrolldelta = vgacon_scrolldelta, 1405 .con_set_origin = vgacon_set_origin, 1406 .con_save_screen = vgacon_save_screen, 1407 .con_build_attr = vgacon_build_attr, 1408 .con_invert_region = vgacon_invert_region, 1409 }; 1410 1411 MODULE_LICENSE("GPL"); 1412