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