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