2 * linux/drivers/video/vgacon.c -- Low level VGA based console driver
4 * Created 28 Sep 1997 by Geert Uytterhoeven
6 * Rewritten by Martin Mares <mj@ucw.cz>, July 1998
8 * This file is based on the old console.c, vga.c and vesa_blank.c drivers.
10 * Copyright (C) 1991, 1992 Linus Torvalds
13 * User definable mapping table and font loading by Eugene G. Crosser,
14 * <crosser@average.org>
16 * Improved loadable font/UTF-8 support by H. Peter Anvin
17 * Feb-Sep 1995 <peter.anvin@linux.org>
19 * Colour palette handling, by Simon Tatham
20 * 17-Jun-95 <sgt20@cam.ac.uk>
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>
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.
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
36 #include <linux/module.h>
37 #include <linux/types.h>
38 #include <linux/sched.h>
40 #include <linux/kernel.h>
41 #include <linux/console.h>
42 #include <linux/string.h>
44 #include <linux/slab.h>
45 #include <linux/vt_kern.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 <linux/smp_lock.h>
52 #include <video/vga.h>
55 static DEFINE_SPINLOCK(vga_lock);
56 static int cursor_size_lastfrom;
57 static int cursor_size_lastto;
58 static u32 vgacon_xres;
59 static u32 vgacon_yres;
60 static struct vgastate state;
64 #define CAN_LOAD_EGA_FONTS /* undefine if the user must not do this */
65 #define CAN_LOAD_PALETTE /* undefine if the user must not do this */
67 /* You really do _NOT_ want to define this, unless you have buggy
68 * Trident VGA which will resize cursor when moving it between column
69 * 15 & 16. If you define this and your VGA is OK, inverse bug will
73 #define VGA_FONTWIDTH 8 /* VGA does not support fontwidths != 8 */
75 * Interface used by the world
78 static const char *vgacon_startup(void);
79 static void vgacon_init(struct vc_data *c, int init);
80 static void vgacon_deinit(struct vc_data *c);
81 static void vgacon_cursor(struct vc_data *c, int mode);
82 static int vgacon_switch(struct vc_data *c);
83 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch);
84 static int vgacon_set_palette(struct vc_data *vc, unsigned char *table);
85 static int vgacon_scrolldelta(struct vc_data *c, int lines);
86 static int vgacon_set_origin(struct vc_data *c);
87 static void vgacon_save_screen(struct vc_data *c);
88 static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
90 static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
91 u8 blink, u8 underline, u8 reverse);
92 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count);
93 static unsigned long vgacon_uni_pagedir[2];
95 /* Description of the hardware situation */
96 static int vga_init_done __read_mostly;
97 static unsigned long vga_vram_base __read_mostly; /* Base of video memory */
98 static unsigned long vga_vram_end __read_mostly; /* End of video memory */
99 static unsigned int vga_vram_size __read_mostly; /* Size of video memory */
100 static u16 vga_video_port_reg __read_mostly; /* Video register select port */
101 static u16 vga_video_port_val __read_mostly; /* Video register value port */
102 static unsigned int vga_video_num_columns; /* Number of text columns */
103 static unsigned int vga_video_num_lines; /* Number of text lines */
104 static int vga_can_do_color __read_mostly; /* Do we support colors? */
105 static unsigned int vga_default_font_height __read_mostly; /* Height of default screen font */
106 static unsigned char vga_video_type __read_mostly; /* Card type */
107 static unsigned char vga_hardscroll_enabled __read_mostly;
108 static unsigned char vga_hardscroll_user_enable __read_mostly = 1;
109 static unsigned char vga_font_is_default = 1;
110 static int vga_vesa_blanked;
111 static int vga_palette_blanked;
112 static int vga_is_gfx;
113 static int vga_512_chars;
114 static int vga_video_font_height;
115 static int vga_scan_lines __read_mostly;
116 static unsigned int vga_rolled_over;
118 static int __init no_scroll(char *str)
121 * Disabling scrollback is required for the Braillex ib80-piezo
122 * Braille reader made by F.H. Papenmeier (Germany).
123 * Use the "no-scroll" bootflag.
125 vga_hardscroll_user_enable = vga_hardscroll_enabled = 0;
129 __setup("no-scroll", no_scroll);
132 * By replacing the four outb_p with two back to back outw, we can reduce
133 * the window of opportunity to see text mislocated to the RHS of the
134 * console during heavy scrolling activity. However there is the remote
135 * possibility that some pre-dinosaur hardware won't like the back to back
136 * I/O. Since the Xservers get away with it, we should be able to as well.
138 static inline void write_vga(unsigned char reg, unsigned int val)
144 * ddprintk might set the console position from interrupt
145 * handlers, thus the write has to be IRQ-atomic.
147 spin_lock_irqsave(&vga_lock, flags);
150 v1 = reg + (val & 0xff00);
151 v2 = reg + 1 + ((val << 8) & 0xff00);
152 outw(v1, vga_video_port_reg);
153 outw(v2, vga_video_port_reg);
155 outb_p(reg, vga_video_port_reg);
156 outb_p(val >> 8, vga_video_port_val);
157 outb_p(reg + 1, vga_video_port_reg);
158 outb_p(val & 0xff, vga_video_port_val);
160 spin_unlock_irqrestore(&vga_lock, flags);
163 static inline void vga_set_mem_top(struct vc_data *c)
165 write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
168 #ifdef CONFIG_VGACON_SOFT_SCROLLBACK
169 #include <linux/bootmem.h>
170 /* software scrollback */
171 static void *vgacon_scrollback;
172 static int vgacon_scrollback_tail;
173 static int vgacon_scrollback_size;
174 static int vgacon_scrollback_rows;
175 static int vgacon_scrollback_cnt;
176 static int vgacon_scrollback_cur;
177 static int vgacon_scrollback_save;
178 static int vgacon_scrollback_restore;
180 static void vgacon_scrollback_init(int pitch)
182 int rows = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024/pitch;
184 if (vgacon_scrollback) {
185 vgacon_scrollback_cnt = 0;
186 vgacon_scrollback_tail = 0;
187 vgacon_scrollback_cur = 0;
188 vgacon_scrollback_rows = rows - 1;
189 vgacon_scrollback_size = rows * pitch;
193 static void vgacon_scrollback_startup(void)
195 vgacon_scrollback = alloc_bootmem(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE
197 vgacon_scrollback_init(vga_video_num_columns * 2);
200 static void vgacon_scrollback_update(struct vc_data *c, int t, int count)
204 if (!vgacon_scrollback_size || c->vc_num != fg_console)
207 p = (void *) (c->vc_origin + t * c->vc_size_row);
210 scr_memcpyw(vgacon_scrollback + vgacon_scrollback_tail,
212 vgacon_scrollback_cnt++;
214 vgacon_scrollback_tail += c->vc_size_row;
216 if (vgacon_scrollback_tail >= vgacon_scrollback_size)
217 vgacon_scrollback_tail = 0;
219 if (vgacon_scrollback_cnt > vgacon_scrollback_rows)
220 vgacon_scrollback_cnt = vgacon_scrollback_rows;
222 vgacon_scrollback_cur = vgacon_scrollback_cnt;
226 static void vgacon_restore_screen(struct vc_data *c)
228 vgacon_scrollback_save = 0;
230 if (!vga_is_gfx && !vgacon_scrollback_restore) {
231 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
232 c->vc_screenbuf_size > vga_vram_size ?
233 vga_vram_size : c->vc_screenbuf_size);
234 vgacon_scrollback_restore = 1;
235 vgacon_scrollback_cur = vgacon_scrollback_cnt;
239 static int vgacon_scrolldelta(struct vc_data *c, int lines)
241 int start, end, count, soff, diff;
245 c->vc_visible_origin = c->vc_origin;
250 if (!vgacon_scrollback)
253 if (!vgacon_scrollback_save) {
254 vgacon_cursor(c, CM_ERASE);
255 vgacon_save_screen(c);
256 vgacon_scrollback_save = 1;
259 vgacon_scrollback_restore = 0;
260 start = vgacon_scrollback_cur + lines;
261 end = start + abs(lines);
266 if (start > vgacon_scrollback_cnt)
267 start = vgacon_scrollback_cnt;
272 if (end > vgacon_scrollback_cnt)
273 end = vgacon_scrollback_cnt;
275 vgacon_scrollback_cur = start;
277 soff = vgacon_scrollback_tail - ((vgacon_scrollback_cnt - end) *
279 soff -= count * c->vc_size_row;
282 soff += vgacon_scrollback_size;
284 count = vgacon_scrollback_cnt - start;
286 if (count > c->vc_rows)
289 diff = c->vc_rows - count;
291 d = (void *) c->vc_origin;
292 s = (void *) c->vc_screenbuf;
295 scr_memcpyw(d, vgacon_scrollback + soff, c->vc_size_row);
297 soff += c->vc_size_row;
299 if (soff >= vgacon_scrollback_size)
303 if (diff == c->vc_rows) {
304 vgacon_cursor(c, CM_MOVE);
307 scr_memcpyw(d, s, c->vc_size_row);
316 #define vgacon_scrollback_startup(...) do { } while (0)
317 #define vgacon_scrollback_init(...) do { } while (0)
318 #define vgacon_scrollback_update(...) do { } while (0)
320 static void vgacon_restore_screen(struct vc_data *c)
322 if (c->vc_origin != c->vc_visible_origin)
323 vgacon_scrolldelta(c, 0);
326 static int vgacon_scrolldelta(struct vc_data *c, int lines)
328 if (!lines) /* Turn scrollback off */
329 c->vc_visible_origin = c->vc_origin;
331 int margin = c->vc_size_row * 4;
334 if (vga_rolled_over >
335 (c->vc_scr_end - vga_vram_base) + margin) {
336 ul = c->vc_scr_end - vga_vram_base;
337 we = vga_rolled_over + c->vc_size_row;
342 p = (c->vc_visible_origin - vga_vram_base - ul + we) % we +
343 lines * c->vc_size_row;
344 st = (c->vc_origin - vga_vram_base - ul + we) % we;
351 c->vc_visible_origin = vga_vram_base + (p + ul) % we;
356 #endif /* CONFIG_VGACON_SOFT_SCROLLBACK */
358 static const char *vgacon_startup(void)
360 const char *display_desc = NULL;
364 if (ORIG_VIDEO_ISVGA == VIDEO_TYPE_VLFB) {
366 #ifdef CONFIG_DUMMY_CONSOLE
367 conswitchp = &dummy_con;
368 return conswitchp->con_startup();
374 /* VGA16 modes are not handled by VGACON */
375 if ((ORIG_VIDEO_MODE == 0x0D) || /* 320x200/4 */
376 (ORIG_VIDEO_MODE == 0x0E) || /* 640x200/4 */
377 (ORIG_VIDEO_MODE == 0x10) || /* 640x350/4 */
378 (ORIG_VIDEO_MODE == 0x12) || /* 640x480/4 */
379 (ORIG_VIDEO_MODE == 0x6A)) /* 800x600/4, 0x6A is very common */
382 vga_video_num_lines = ORIG_VIDEO_LINES;
383 vga_video_num_columns = ORIG_VIDEO_COLS;
384 state.vgabase = NULL;
386 if (ORIG_VIDEO_MODE == 7) { /* Is this a monochrome display? */
387 vga_vram_base = 0xb0000;
388 vga_video_port_reg = VGA_CRT_IM;
389 vga_video_port_val = VGA_CRT_DM;
390 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10) {
391 static struct resource ega_console_resource =
392 { .name = "ega", .start = 0x3B0, .end = 0x3BF };
393 vga_video_type = VIDEO_TYPE_EGAM;
394 vga_vram_size = 0x8000;
395 display_desc = "EGA+";
396 request_resource(&ioport_resource,
397 &ega_console_resource);
399 static struct resource mda1_console_resource =
400 { .name = "mda", .start = 0x3B0, .end = 0x3BB };
401 static struct resource mda2_console_resource =
402 { .name = "mda", .start = 0x3BF, .end = 0x3BF };
403 vga_video_type = VIDEO_TYPE_MDA;
404 vga_vram_size = 0x2000;
405 display_desc = "*MDA";
406 request_resource(&ioport_resource,
407 &mda1_console_resource);
408 request_resource(&ioport_resource,
409 &mda2_console_resource);
410 vga_video_font_height = 14;
413 /* If not, it is color. */
414 vga_can_do_color = 1;
415 vga_vram_base = 0xb8000;
416 vga_video_port_reg = VGA_CRT_IC;
417 vga_video_port_val = VGA_CRT_DC;
418 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10) {
421 vga_vram_size = 0x8000;
423 if (!ORIG_VIDEO_ISVGA) {
424 static struct resource ega_console_resource
425 = { .name = "ega", .start = 0x3C0, .end = 0x3DF };
426 vga_video_type = VIDEO_TYPE_EGAC;
427 display_desc = "EGA";
428 request_resource(&ioport_resource,
429 &ega_console_resource);
431 static struct resource vga_console_resource
432 = { .name = "vga+", .start = 0x3C0, .end = 0x3DF };
433 vga_video_type = VIDEO_TYPE_VGAC;
434 display_desc = "VGA+";
435 request_resource(&ioport_resource,
436 &vga_console_resource);
438 #ifdef VGA_CAN_DO_64KB
440 * get 64K rather than 32K of video RAM.
441 * This doesn't actually work on all "VGA"
442 * controllers (it seems like setting MM=01
443 * and COE=1 isn't necessarily a good idea)
445 vga_vram_base = 0xa0000;
446 vga_vram_size = 0x10000;
447 outb_p(6, VGA_GFX_I);
448 outb_p(6, VGA_GFX_D);
451 * Normalise the palette registers, to point
452 * the 16 screen colours to the first 16
456 for (i = 0; i < 16; i++) {
458 outb_p(i, VGA_ATT_W);
459 outb_p(i, VGA_ATT_W);
461 outb_p(0x20, VGA_ATT_W);
464 * Now set the DAC registers back to their
467 for (i = 0; i < 16; i++) {
468 outb_p(color_table[i], VGA_PEL_IW);
469 outb_p(default_red[i], VGA_PEL_D);
470 outb_p(default_grn[i], VGA_PEL_D);
471 outb_p(default_blu[i], VGA_PEL_D);
475 static struct resource cga_console_resource =
476 { .name = "cga", .start = 0x3D4, .end = 0x3D5 };
477 vga_video_type = VIDEO_TYPE_CGA;
478 vga_vram_size = 0x2000;
479 display_desc = "*CGA";
480 request_resource(&ioport_resource,
481 &cga_console_resource);
482 vga_video_font_height = 8;
486 vga_vram_base = VGA_MAP_MEM(vga_vram_base, vga_vram_size);
487 vga_vram_end = vga_vram_base + vga_vram_size;
490 * Find out if there is a graphics card present.
491 * Are there smarter methods around?
493 p = (volatile u16 *) vga_vram_base;
494 saved1 = scr_readw(p);
495 saved2 = scr_readw(p + 1);
496 scr_writew(0xAA55, p);
497 scr_writew(0x55AA, p + 1);
498 if (scr_readw(p) != 0xAA55 || scr_readw(p + 1) != 0x55AA) {
499 scr_writew(saved1, p);
500 scr_writew(saved2, p + 1);
503 scr_writew(0x55AA, p);
504 scr_writew(0xAA55, p + 1);
505 if (scr_readw(p) != 0x55AA || scr_readw(p + 1) != 0xAA55) {
506 scr_writew(saved1, p);
507 scr_writew(saved2, p + 1);
510 scr_writew(saved1, p);
511 scr_writew(saved2, p + 1);
513 if (vga_video_type == VIDEO_TYPE_EGAC
514 || vga_video_type == VIDEO_TYPE_VGAC
515 || vga_video_type == VIDEO_TYPE_EGAM) {
516 vga_hardscroll_enabled = vga_hardscroll_user_enable;
517 vga_default_font_height = ORIG_VIDEO_POINTS;
518 vga_video_font_height = ORIG_VIDEO_POINTS;
519 /* This may be suboptimal but is a safe bet - go with it */
521 vga_video_font_height * vga_video_num_lines;
524 vgacon_xres = ORIG_VIDEO_COLS * VGA_FONTWIDTH;
525 vgacon_yres = vga_scan_lines;
527 if (!vga_init_done) {
528 vgacon_scrollback_startup();
535 static void vgacon_init(struct vc_data *c, int init)
540 * We cannot be loaded as a module, therefore init is always 1,
541 * but vgacon_init can be called more than once, and init will
544 c->vc_can_do_color = vga_can_do_color;
546 /* set dimensions manually if init != 0 since vc_resize() will fail */
548 c->vc_cols = vga_video_num_columns;
549 c->vc_rows = vga_video_num_lines;
551 vc_resize(c, vga_video_num_columns, vga_video_num_lines);
553 c->vc_scan_lines = vga_scan_lines;
554 c->vc_font.height = vga_video_font_height;
555 c->vc_complement_mask = 0x7700;
557 c->vc_hi_font_mask = 0x0800;
558 p = *c->vc_uni_pagedir_loc;
559 if (c->vc_uni_pagedir_loc == &c->vc_uni_pagedir ||
560 !--c->vc_uni_pagedir_loc[1])
562 c->vc_uni_pagedir_loc = vgacon_uni_pagedir;
563 vgacon_uni_pagedir[1]++;
564 if (!vgacon_uni_pagedir[0] && p)
565 con_set_default_unimap(c);
568 static void vgacon_deinit(struct vc_data *c)
570 /* When closing the last console, reset video origin */
571 if (!--vgacon_uni_pagedir[1]) {
572 c->vc_visible_origin = vga_vram_base;
576 c->vc_uni_pagedir_loc = &c->vc_uni_pagedir;
577 con_set_default_unimap(c);
580 static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
581 u8 blink, u8 underline, u8 reverse)
585 if (vga_can_do_color) {
587 attr = (attr & 0xf0) | c->vc_ulcolor;
588 else if (intensity == 0)
589 attr = (attr & 0xf0) | c->vc_halfcolor;
593 ((attr) & 0x88) | ((((attr) >> 4) | ((attr) << 4)) &
599 if (!vga_can_do_color) {
601 attr = (attr & 0xf8) | 0x01;
602 else if (intensity == 0)
603 attr = (attr & 0xf0) | 0x08;
608 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count)
610 int col = vga_can_do_color;
613 u16 a = scr_readw(p);
615 a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) |
616 (((a) & 0x0700) << 4);
618 a ^= ((a & 0x0700) == 0x0100) ? 0x7000 : 0x7700;
623 static void vgacon_set_cursor_size(int xpos, int from, int to)
628 #ifdef TRIDENT_GLITCH
633 if ((from == cursor_size_lastfrom) && (to == cursor_size_lastto))
635 cursor_size_lastfrom = from;
636 cursor_size_lastto = to;
638 spin_lock_irqsave(&vga_lock, flags);
639 if (vga_video_type >= VIDEO_TYPE_VGAC) {
640 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
641 curs = inb_p(vga_video_port_val);
642 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
643 cure = inb_p(vga_video_port_val);
649 curs = (curs & 0xc0) | from;
650 cure = (cure & 0xe0) | to;
652 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
653 outb_p(curs, vga_video_port_val);
654 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
655 outb_p(cure, vga_video_port_val);
656 spin_unlock_irqrestore(&vga_lock, flags);
659 static void vgacon_cursor(struct vc_data *c, int mode)
661 vgacon_restore_screen(c);
665 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
666 if (vga_video_type >= VIDEO_TYPE_VGAC)
667 vgacon_set_cursor_size(c->vc_x, 31, 30);
669 vgacon_set_cursor_size(c->vc_x, 31, 31);
674 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
675 switch (c->vc_cursor_type & 0x0f) {
677 vgacon_set_cursor_size(c->vc_x,
686 vgacon_set_cursor_size(c->vc_x,
687 c->vc_font.height / 3,
692 case CUR_LOWER_THIRD:
693 vgacon_set_cursor_size(c->vc_x,
694 (c->vc_font.height * 2) / 3,
700 vgacon_set_cursor_size(c->vc_x,
701 c->vc_font.height / 2,
707 if (vga_video_type >= VIDEO_TYPE_VGAC)
708 vgacon_set_cursor_size(c->vc_x, 31, 30);
710 vgacon_set_cursor_size(c->vc_x, 31, 31);
713 vgacon_set_cursor_size(c->vc_x, 1,
721 static int vgacon_doresize(struct vc_data *c,
722 unsigned int width, unsigned int height)
725 unsigned int scanlines = height * c->vc_font.height;
726 u8 scanlines_lo = 0, r7 = 0, vsync_end = 0, mode, max_scan;
728 spin_lock_irqsave(&vga_lock, flags);
730 vgacon_xres = width * VGA_FONTWIDTH;
731 vgacon_yres = height * c->vc_font.height;
732 if (vga_video_type >= VIDEO_TYPE_VGAC) {
733 outb_p(VGA_CRTC_MAX_SCAN, vga_video_port_reg);
734 max_scan = inb_p(vga_video_port_val);
739 outb_p(VGA_CRTC_MODE, vga_video_port_reg);
740 mode = inb_p(vga_video_port_val);
746 scanlines_lo = scanlines & 0xff;
748 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
749 r7 = inb_p(vga_video_port_val) & ~0x42;
751 if (scanlines & 0x100)
753 if (scanlines & 0x200)
756 /* deprotect registers */
757 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
758 vsync_end = inb_p(vga_video_port_val);
759 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
760 outb_p(vsync_end & ~0x80, vga_video_port_val);
763 outb_p(VGA_CRTC_H_DISP, vga_video_port_reg);
764 outb_p(width - 1, vga_video_port_val);
765 outb_p(VGA_CRTC_OFFSET, vga_video_port_reg);
766 outb_p(width >> 1, vga_video_port_val);
768 if (vga_video_type >= VIDEO_TYPE_VGAC) {
769 outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg);
770 outb_p(scanlines_lo, vga_video_port_val);
771 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
772 outb_p(r7,vga_video_port_val);
774 /* reprotect registers */
775 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
776 outb_p(vsync_end, vga_video_port_val);
779 spin_unlock_irqrestore(&vga_lock, flags);
783 static int vgacon_switch(struct vc_data *c)
785 int x = c->vc_cols * VGA_FONTWIDTH;
786 int y = c->vc_rows * c->vc_font.height;
787 int rows = ORIG_VIDEO_LINES * vga_default_font_height/
790 * We need to save screen size here as it's the only way
791 * we can spot the screen has been resized and we need to
792 * set size of freshly allocated screens ourselves.
794 vga_video_num_columns = c->vc_cols;
795 vga_video_num_lines = c->vc_rows;
797 /* We can only copy out the size of the video buffer here,
798 * otherwise we get into VGA BIOS */
801 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
802 c->vc_screenbuf_size > vga_vram_size ?
803 vga_vram_size : c->vc_screenbuf_size);
805 if ((vgacon_xres != x || vgacon_yres != y) &&
806 (!(vga_video_num_columns % 2) &&
807 vga_video_num_columns <= ORIG_VIDEO_COLS &&
808 vga_video_num_lines <= rows))
809 vgacon_doresize(c, c->vc_cols, c->vc_rows);
812 vgacon_scrollback_init(c->vc_size_row);
813 return 0; /* Redrawing not needed */
816 static void vga_set_palette(struct vc_data *vc, unsigned char *table)
820 vga_w(state.vgabase, VGA_PEL_MSK, 0xff);
821 for (i = j = 0; i < 16; i++) {
822 vga_w(state.vgabase, VGA_PEL_IW, table[i]);
823 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
824 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
825 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
829 static int vgacon_set_palette(struct vc_data *vc, unsigned char *table)
831 #ifdef CAN_LOAD_PALETTE
832 if (vga_video_type != VIDEO_TYPE_VGAC || vga_palette_blanked
833 || !CON_IS_VISIBLE(vc))
835 vga_set_palette(vc, table);
842 /* structure holding original VGA register settings */
844 unsigned char SeqCtrlIndex; /* Sequencer Index reg. */
845 unsigned char CrtCtrlIndex; /* CRT-Contr. Index reg. */
846 unsigned char CrtMiscIO; /* Miscellaneous register */
847 unsigned char HorizontalTotal; /* CRT-Controller:00h */
848 unsigned char HorizDisplayEnd; /* CRT-Controller:01h */
849 unsigned char StartHorizRetrace; /* CRT-Controller:04h */
850 unsigned char EndHorizRetrace; /* CRT-Controller:05h */
851 unsigned char Overflow; /* CRT-Controller:07h */
852 unsigned char StartVertRetrace; /* CRT-Controller:10h */
853 unsigned char EndVertRetrace; /* CRT-Controller:11h */
854 unsigned char ModeControl; /* CRT-Controller:17h */
855 unsigned char ClockingMode; /* Seq-Controller:01h */
858 static void vga_vesa_blank(struct vgastate *state, int mode)
860 /* save original values of VGA controller registers */
861 if (!vga_vesa_blanked) {
862 spin_lock_irq(&vga_lock);
863 vga_state.SeqCtrlIndex = vga_r(state->vgabase, VGA_SEQ_I);
864 vga_state.CrtCtrlIndex = inb_p(vga_video_port_reg);
865 vga_state.CrtMiscIO = vga_r(state->vgabase, VGA_MIS_R);
866 spin_unlock_irq(&vga_lock);
868 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */
869 vga_state.HorizontalTotal = inb_p(vga_video_port_val);
870 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */
871 vga_state.HorizDisplayEnd = inb_p(vga_video_port_val);
872 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
873 vga_state.StartHorizRetrace = inb_p(vga_video_port_val);
874 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
875 vga_state.EndHorizRetrace = inb_p(vga_video_port_val);
876 outb_p(0x07, vga_video_port_reg); /* Overflow */
877 vga_state.Overflow = inb_p(vga_video_port_val);
878 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
879 vga_state.StartVertRetrace = inb_p(vga_video_port_val);
880 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
881 vga_state.EndVertRetrace = inb_p(vga_video_port_val);
882 outb_p(0x17, vga_video_port_reg); /* ModeControl */
883 vga_state.ModeControl = inb_p(vga_video_port_val);
884 vga_state.ClockingMode = vga_rseq(state->vgabase, VGA_SEQ_CLOCK_MODE);
887 /* assure that video is enabled */
888 /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */
889 spin_lock_irq(&vga_lock);
890 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode | 0x20);
892 /* test for vertical retrace in process.... */
893 if ((vga_state.CrtMiscIO & 0x80) == 0x80)
894 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO & 0xEF);
897 * Set <End of vertical retrace> to minimum (0) and
898 * <Start of vertical Retrace> to maximum (incl. overflow)
899 * Result: turn off vertical sync (VSync) pulse.
901 if (mode & VESA_VSYNC_SUSPEND) {
902 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
903 outb_p(0xff, vga_video_port_val); /* maximum value */
904 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
905 outb_p(0x40, vga_video_port_val); /* minimum (bits 0..3) */
906 outb_p(0x07, vga_video_port_reg); /* Overflow */
907 outb_p(vga_state.Overflow | 0x84, vga_video_port_val); /* bits 9,10 of vert. retrace */
910 if (mode & VESA_HSYNC_SUSPEND) {
912 * Set <End of horizontal retrace> to minimum (0) and
913 * <Start of horizontal Retrace> to maximum
914 * Result: turn off horizontal sync (HSync) pulse.
916 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
917 outb_p(0xff, vga_video_port_val); /* maximum */
918 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
919 outb_p(0x00, vga_video_port_val); /* minimum (0) */
922 /* restore both index registers */
923 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
924 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
925 spin_unlock_irq(&vga_lock);
928 static void vga_vesa_unblank(struct vgastate *state)
930 /* restore original values of VGA controller registers */
931 spin_lock_irq(&vga_lock);
932 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO);
934 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */
935 outb_p(vga_state.HorizontalTotal, vga_video_port_val);
936 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */
937 outb_p(vga_state.HorizDisplayEnd, vga_video_port_val);
938 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
939 outb_p(vga_state.StartHorizRetrace, vga_video_port_val);
940 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
941 outb_p(vga_state.EndHorizRetrace, vga_video_port_val);
942 outb_p(0x07, vga_video_port_reg); /* Overflow */
943 outb_p(vga_state.Overflow, vga_video_port_val);
944 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
945 outb_p(vga_state.StartVertRetrace, vga_video_port_val);
946 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
947 outb_p(vga_state.EndVertRetrace, vga_video_port_val);
948 outb_p(0x17, vga_video_port_reg); /* ModeControl */
949 outb_p(vga_state.ModeControl, vga_video_port_val);
951 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode);
953 /* restore index/control registers */
954 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
955 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
956 spin_unlock_irq(&vga_lock);
959 static void vga_pal_blank(struct vgastate *state)
963 vga_w(state->vgabase, VGA_PEL_MSK, 0xff);
964 for (i = 0; i < 16; i++) {
965 vga_w(state->vgabase, VGA_PEL_IW, i);
966 vga_w(state->vgabase, VGA_PEL_D, 0);
967 vga_w(state->vgabase, VGA_PEL_D, 0);
968 vga_w(state->vgabase, VGA_PEL_D, 0);
972 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch)
975 case 0: /* Unblank */
976 if (vga_vesa_blanked) {
977 vga_vesa_unblank(&state);
978 vga_vesa_blanked = 0;
980 if (vga_palette_blanked) {
981 vga_set_palette(c, color_table);
982 vga_palette_blanked = 0;
986 /* Tell console.c that it has to restore the screen itself */
988 case 1: /* Normal blanking */
989 case -1: /* Obsolete */
990 if (!mode_switch && vga_video_type == VIDEO_TYPE_VGAC) {
991 vga_pal_blank(&state);
992 vga_palette_blanked = 1;
995 vgacon_set_origin(c);
996 scr_memsetw((void *) vga_vram_base, BLANK,
997 c->vc_screenbuf_size);
1001 default: /* VESA blanking */
1002 if (vga_video_type == VIDEO_TYPE_VGAC) {
1003 vga_vesa_blank(&state, blank - 1);
1004 vga_vesa_blanked = blank;
1013 * The font loading code goes back to the codepage package by
1014 * Joel Hoffman (joel@wam.umd.edu). (He reports that the original
1015 * reference is: "From: p. 307 of _Programmer's Guide to PC & PS/2
1016 * Video Systems_ by Richard Wilton. 1987. Microsoft Press".)
1018 * Change for certain monochrome monitors by Yury Shevchuck
1019 * (sizif@botik.yaroslavl.su).
1022 #ifdef CAN_LOAD_EGA_FONTS
1024 #define colourmap 0xa0000
1025 /* Pauline Middelink <middelin@polyware.iaf.nl> reports that we
1026 should use 0xA0000 for the bwmap as well.. */
1027 #define blackwmap 0xa0000
1030 static int vgacon_do_font_op(struct vgastate *state,char *arg,int set,int ch512)
1032 unsigned short video_port_status = vga_video_port_reg + 6;
1033 int font_select = 0x00, beg, i;
1036 if (vga_video_type != VIDEO_TYPE_EGAM) {
1037 charmap = (char *) VGA_MAP_MEM(colourmap, 0);
1039 #ifdef VGA_CAN_DO_64KB
1040 if (vga_video_type == VIDEO_TYPE_VGAC)
1044 charmap = (char *) VGA_MAP_MEM(blackwmap, 0);
1048 #ifdef BROKEN_GRAPHICS_PROGRAMS
1050 * All fonts are loaded in slot 0 (0:1 for 512 ch)
1054 return -EINVAL; /* Return to default font not supported */
1056 vga_font_is_default = 0;
1057 font_select = ch512 ? 0x04 : 0x00;
1060 * The default font is kept in slot 0 and is never touched.
1061 * A custom font is loaded in slot 2 (256 ch) or 2:3 (512 ch)
1065 vga_font_is_default = !arg;
1067 ch512 = 0; /* Default font is always 256 */
1068 font_select = arg ? (ch512 ? 0x0e : 0x0a) : 0x00;
1071 if (!vga_font_is_default)
1072 charmap += 4 * cmapsz;
1076 spin_lock_irq(&vga_lock);
1077 /* First, the Sequencer */
1078 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1);
1079 /* CPU writes only to map 2 */
1080 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x04);
1081 /* Sequential addressing */
1082 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x07);
1083 /* Clear synchronous reset */
1084 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
1086 /* Now, the graphics controller, select map 2 */
1087 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x02);
1088 /* disable odd-even addressing */
1089 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x00);
1090 /* map start at A000:0000 */
1091 vga_wgfx(state->vgabase, VGA_GFX_MISC, 0x00);
1092 spin_unlock_irq(&vga_lock);
1096 for (i = 0; i < cmapsz; i++)
1097 vga_writeb(arg[i], charmap + i);
1099 for (i = 0; i < cmapsz; i++)
1100 arg[i] = vga_readb(charmap + i);
1103 * In 512-character mode, the character map is not contiguous if
1104 * we want to remain EGA compatible -- which we do
1108 charmap += 2 * cmapsz;
1111 for (i = 0; i < cmapsz; i++)
1112 vga_writeb(arg[i], charmap + i);
1114 for (i = 0; i < cmapsz; i++)
1115 arg[i] = vga_readb(charmap + i);
1119 spin_lock_irq(&vga_lock);
1120 /* First, the sequencer, Synchronous reset */
1121 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x01);
1122 /* CPU writes to maps 0 and 1 */
1123 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x03);
1124 /* odd-even addressing */
1125 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x03);
1126 /* Character Map Select */
1128 vga_wseq(state->vgabase, VGA_SEQ_CHARACTER_MAP, font_select);
1129 /* clear synchronous reset */
1130 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
1132 /* Now, the graphics controller, select map 0 for CPU */
1133 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x00);
1134 /* enable even-odd addressing */
1135 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x10);
1136 /* map starts at b800:0 or b000:0 */
1137 vga_wgfx(state->vgabase, VGA_GFX_MISC, beg);
1139 /* if 512 char mode is already enabled don't re-enable it. */
1140 if ((set) && (ch512 != vga_512_chars)) {
1143 /* attribute controller */
1144 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1145 struct vc_data *c = vc_cons[i].d;
1146 if (c && c->vc_sw == &vga_con)
1147 c->vc_hi_font_mask = ch512 ? 0x0800 : 0;
1149 vga_512_chars = ch512;
1150 /* 256-char: enable intensity bit
1151 512-char: disable intensity bit */
1152 inb_p(video_port_status); /* clear address flip-flop */
1153 /* color plane enable register */
1154 vga_wattr(state->vgabase, VGA_ATC_PLANE_ENABLE, ch512 ? 0x07 : 0x0f);
1155 /* Wilton (1987) mentions the following; I don't know what
1156 it means, but it works, and it appears necessary */
1157 inb_p(video_port_status);
1158 vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0);
1160 spin_unlock_irq(&vga_lock);
1166 * Adjust the screen to fit a font of a certain height
1168 static int vgacon_adjust_height(struct vc_data *vc, unsigned fontheight)
1170 unsigned char ovr, vde, fsr;
1171 int rows, maxscan, i;
1173 rows = vc->vc_scan_lines / fontheight; /* Number of video rows we end up with */
1174 maxscan = rows * fontheight - 1; /* Scan lines to actually display-1 */
1176 /* Reprogram the CRTC for the new font size
1177 Note: the attempt to read the overflow register will fail
1178 on an EGA, but using 0xff for the previous value appears to
1179 be OK for EGA text modes in the range 257-512 scan lines, so I
1180 guess we don't need to worry about it.
1182 The same applies for the spill bits in the font size and cursor
1183 registers; they are write-only on EGA, but it appears that they
1184 are all don't care bits on EGA, so I guess it doesn't matter. */
1186 spin_lock_irq(&vga_lock);
1187 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */
1188 ovr = inb_p(vga_video_port_val);
1189 outb_p(0x09, vga_video_port_reg); /* Font size register */
1190 fsr = inb_p(vga_video_port_val);
1191 spin_unlock_irq(&vga_lock);
1193 vde = maxscan & 0xff; /* Vertical display end reg */
1194 ovr = (ovr & 0xbd) + /* Overflow register */
1195 ((maxscan & 0x100) >> 7) + ((maxscan & 0x200) >> 3);
1196 fsr = (fsr & 0xe0) + (fontheight - 1); /* Font size register */
1198 spin_lock_irq(&vga_lock);
1199 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */
1200 outb_p(ovr, vga_video_port_val);
1201 outb_p(0x09, vga_video_port_reg); /* Font size */
1202 outb_p(fsr, vga_video_port_val);
1203 outb_p(0x12, vga_video_port_reg); /* Vertical display limit */
1204 outb_p(vde, vga_video_port_val);
1205 spin_unlock_irq(&vga_lock);
1206 vga_video_font_height = fontheight;
1208 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1209 struct vc_data *c = vc_cons[i].d;
1211 if (c && c->vc_sw == &vga_con) {
1212 if (CON_IS_VISIBLE(c)) {
1213 /* void size to cause regs to be rewritten */
1214 cursor_size_lastfrom = 0;
1215 cursor_size_lastto = 0;
1216 c->vc_sw->con_cursor(c, CM_DRAW);
1218 c->vc_font.height = fontheight;
1219 vc_resize(c, 0, rows); /* Adjust console size */
1225 static int vgacon_font_set(struct vc_data *c, struct console_font *font, unsigned flags)
1227 unsigned charcount = font->charcount;
1230 if (vga_video_type < VIDEO_TYPE_EGAM)
1233 if (font->width != VGA_FONTWIDTH ||
1234 (charcount != 256 && charcount != 512))
1237 rc = vgacon_do_font_op(&state, font->data, 1, charcount == 512);
1241 if (!(flags & KD_FONT_FLAG_DONT_RECALC))
1242 rc = vgacon_adjust_height(c, font->height);
1246 static int vgacon_font_get(struct vc_data *c, struct console_font *font)
1248 if (vga_video_type < VIDEO_TYPE_EGAM)
1251 font->width = VGA_FONTWIDTH;
1252 font->height = c->vc_font.height;
1253 font->charcount = vga_512_chars ? 512 : 256;
1256 return vgacon_do_font_op(&state, font->data, 0, 0);
1261 #define vgacon_font_set NULL
1262 #define vgacon_font_get NULL
1266 static int vgacon_resize(struct vc_data *c, unsigned int width,
1267 unsigned int height)
1269 if (width % 2 || width > ORIG_VIDEO_COLS ||
1270 height > (ORIG_VIDEO_LINES * vga_default_font_height)/
1272 /* let svgatextmode tinker with video timings */
1275 if (CON_IS_VISIBLE(c) && !vga_is_gfx) /* who knows */
1276 vgacon_doresize(c, width, height);
1280 static int vgacon_set_origin(struct vc_data *c)
1282 if (vga_is_gfx || /* We don't play origin tricks in graphic modes */
1283 (console_blanked && !vga_palette_blanked)) /* Nor we write to blanked screens */
1285 c->vc_origin = c->vc_visible_origin = vga_vram_base;
1287 vga_rolled_over = 0;
1291 static void vgacon_save_screen(struct vc_data *c)
1293 static int vga_bootup_console = 0;
1295 if (!vga_bootup_console) {
1296 /* This is a gross hack, but here is the only place we can
1297 * set bootup console parameters without messing up generic
1298 * console initialization routines.
1300 vga_bootup_console = 1;
1305 /* We can't copy in more then the size of the video buffer,
1306 * or we'll be copying in VGA BIOS */
1309 scr_memcpyw((u16 *) c->vc_screenbuf, (u16 *) c->vc_origin,
1310 c->vc_screenbuf_size > vga_vram_size ? vga_vram_size : c->vc_screenbuf_size);
1313 static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
1319 if (t || b != c->vc_rows || vga_is_gfx)
1322 if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2)
1325 vgacon_restore_screen(c);
1326 oldo = c->vc_origin;
1327 delta = lines * c->vc_size_row;
1329 vgacon_scrollback_update(c, t, lines);
1330 if (c->vc_scr_end + delta >= vga_vram_end) {
1331 scr_memcpyw((u16 *) vga_vram_base,
1332 (u16 *) (oldo + delta),
1333 c->vc_screenbuf_size - delta);
1334 c->vc_origin = vga_vram_base;
1335 vga_rolled_over = oldo - vga_vram_base;
1337 c->vc_origin += delta;
1338 scr_memsetw((u16 *) (c->vc_origin + c->vc_screenbuf_size -
1339 delta), c->vc_video_erase_char,
1342 if (oldo - delta < vga_vram_base) {
1343 scr_memmovew((u16 *) (vga_vram_end -
1344 c->vc_screenbuf_size +
1345 delta), (u16 *) oldo,
1346 c->vc_screenbuf_size - delta);
1347 c->vc_origin = vga_vram_end - c->vc_screenbuf_size;
1348 vga_rolled_over = 0;
1350 c->vc_origin -= delta;
1351 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1352 scr_memsetw((u16 *) (c->vc_origin), c->vc_video_erase_char,
1355 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1356 c->vc_visible_origin = c->vc_origin;
1358 c->vc_pos = (c->vc_pos - oldo) + c->vc_origin;
1364 * The console `switch' structure for the VGA based console
1367 static int vgacon_dummy(struct vc_data *c)
1372 #define DUMMY (void *) vgacon_dummy
1374 const struct consw vga_con = {
1375 .owner = THIS_MODULE,
1376 .con_startup = vgacon_startup,
1377 .con_init = vgacon_init,
1378 .con_deinit = vgacon_deinit,
1382 .con_cursor = vgacon_cursor,
1383 .con_scroll = vgacon_scroll,
1385 .con_switch = vgacon_switch,
1386 .con_blank = vgacon_blank,
1387 .con_font_set = vgacon_font_set,
1388 .con_font_get = vgacon_font_get,
1389 .con_resize = vgacon_resize,
1390 .con_set_palette = vgacon_set_palette,
1391 .con_scrolldelta = vgacon_scrolldelta,
1392 .con_set_origin = vgacon_set_origin,
1393 .con_save_screen = vgacon_save_screen,
1394 .con_build_attr = vgacon_build_attr,
1395 .con_invert_region = vgacon_invert_region,
1398 MODULE_LICENSE("GPL");