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