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>
39 #include <linux/kernel.h>
40 #include <linux/console.h>
41 #include <linux/string.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>
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;
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 */
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
72 #define VGA_FONTWIDTH 8 /* VGA does not support fontwidths != 8 */
74 * Interface used by the world
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,
89 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count);
90 static unsigned long vgacon_uni_pagedir[2];
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;
115 static int __init no_scroll(char *str)
118 * Disabling scrollback is required for the Braillex ib80-piezo
119 * Braille reader made by F.H. Papenmeier (Germany).
120 * Use the "no-scroll" bootflag.
122 vga_hardscroll_user_enable = vga_hardscroll_enabled = 0;
126 __setup("no-scroll", no_scroll);
129 * By replacing the four outb_p with two back to back outw, we can reduce
130 * the window of opportunity to see text mislocated to the RHS of the
131 * console during heavy scrolling activity. However there is the remote
132 * possibility that some pre-dinosaur hardware won't like the back to back
133 * I/O. Since the Xservers get away with it, we should be able to as well.
135 static inline void write_vga(unsigned char reg, unsigned int val)
141 * ddprintk might set the console position from interrupt
142 * handlers, thus the write has to be IRQ-atomic.
144 spin_lock_irqsave(&vga_lock, flags);
147 v1 = reg + (val & 0xff00);
148 v2 = reg + 1 + ((val << 8) & 0xff00);
149 outw(v1, vga_video_port_reg);
150 outw(v2, vga_video_port_reg);
152 outb_p(reg, vga_video_port_reg);
153 outb_p(val >> 8, vga_video_port_val);
154 outb_p(reg + 1, vga_video_port_reg);
155 outb_p(val & 0xff, vga_video_port_val);
157 spin_unlock_irqrestore(&vga_lock, flags);
160 static inline void vga_set_mem_top(struct vc_data *c)
162 write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
165 #ifdef CONFIG_VGACON_SOFT_SCROLLBACK
166 #include <linux/bootmem.h>
167 /* software scrollback */
168 static void *vgacon_scrollback;
169 static int vgacon_scrollback_tail;
170 static int vgacon_scrollback_size;
171 static int vgacon_scrollback_rows;
172 static int vgacon_scrollback_cnt;
173 static int vgacon_scrollback_cur;
174 static int vgacon_scrollback_save;
175 static int vgacon_scrollback_restore;
177 static void vgacon_scrollback_init(int pitch)
179 int rows = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024/pitch;
181 if (vgacon_scrollback) {
182 vgacon_scrollback_cnt = 0;
183 vgacon_scrollback_tail = 0;
184 vgacon_scrollback_cur = 0;
185 vgacon_scrollback_rows = rows - 1;
186 vgacon_scrollback_size = rows * pitch;
191 * Called only duing init so call of alloc_bootmen is ok.
192 * Marked __init_refok to silence modpost.
194 static void __init_refok vgacon_scrollback_startup(void)
196 vgacon_scrollback = alloc_bootmem(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE
198 vgacon_scrollback_init(vga_video_num_columns * 2);
201 static void vgacon_scrollback_update(struct vc_data *c, int t, int count)
205 if (!vgacon_scrollback_size || c->vc_num != fg_console)
208 p = (void *) (c->vc_origin + t * c->vc_size_row);
211 scr_memcpyw(vgacon_scrollback + vgacon_scrollback_tail,
213 vgacon_scrollback_cnt++;
215 vgacon_scrollback_tail += c->vc_size_row;
217 if (vgacon_scrollback_tail >= vgacon_scrollback_size)
218 vgacon_scrollback_tail = 0;
220 if (vgacon_scrollback_cnt > vgacon_scrollback_rows)
221 vgacon_scrollback_cnt = vgacon_scrollback_rows;
223 vgacon_scrollback_cur = vgacon_scrollback_cnt;
227 static void vgacon_restore_screen(struct vc_data *c)
229 vgacon_scrollback_save = 0;
231 if (!vga_is_gfx && !vgacon_scrollback_restore) {
232 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
233 c->vc_screenbuf_size > vga_vram_size ?
234 vga_vram_size : c->vc_screenbuf_size);
235 vgacon_scrollback_restore = 1;
236 vgacon_scrollback_cur = vgacon_scrollback_cnt;
240 static int vgacon_scrolldelta(struct vc_data *c, int lines)
242 int start, end, count, soff, diff;
246 c->vc_visible_origin = c->vc_origin;
251 if (!vgacon_scrollback)
254 if (!vgacon_scrollback_save) {
255 vgacon_cursor(c, CM_ERASE);
256 vgacon_save_screen(c);
257 vgacon_scrollback_save = 1;
260 vgacon_scrollback_restore = 0;
261 start = vgacon_scrollback_cur + lines;
262 end = start + abs(lines);
267 if (start > vgacon_scrollback_cnt)
268 start = vgacon_scrollback_cnt;
273 if (end > vgacon_scrollback_cnt)
274 end = vgacon_scrollback_cnt;
276 vgacon_scrollback_cur = start;
278 soff = vgacon_scrollback_tail - ((vgacon_scrollback_cnt - end) *
280 soff -= count * c->vc_size_row;
283 soff += vgacon_scrollback_size;
285 count = vgacon_scrollback_cnt - start;
287 if (count > c->vc_rows)
290 diff = c->vc_rows - count;
292 d = (void *) c->vc_origin;
293 s = (void *) c->vc_screenbuf;
297 count *= c->vc_size_row;
298 /* how much memory to end of buffer left? */
299 copysize = min(count, vgacon_scrollback_size - soff);
300 scr_memcpyw(d, vgacon_scrollback + soff, copysize);
305 scr_memcpyw(d, vgacon_scrollback, count);
310 if (diff == c->vc_rows) {
311 vgacon_cursor(c, CM_MOVE);
314 scr_memcpyw(d, s, diff * c->vc_size_row);
320 #define vgacon_scrollback_startup(...) do { } while (0)
321 #define vgacon_scrollback_init(...) do { } while (0)
322 #define vgacon_scrollback_update(...) do { } while (0)
324 static void vgacon_restore_screen(struct vc_data *c)
326 if (c->vc_origin != c->vc_visible_origin)
327 vgacon_scrolldelta(c, 0);
330 static int vgacon_scrolldelta(struct vc_data *c, int lines)
332 if (!lines) /* Turn scrollback off */
333 c->vc_visible_origin = c->vc_origin;
335 int margin = c->vc_size_row * 4;
338 if (vga_rolled_over >
339 (c->vc_scr_end - vga_vram_base) + margin) {
340 ul = c->vc_scr_end - vga_vram_base;
341 we = vga_rolled_over + c->vc_size_row;
346 p = (c->vc_visible_origin - vga_vram_base - ul + we) % we +
347 lines * c->vc_size_row;
348 st = (c->vc_origin - vga_vram_base - ul + we) % we;
355 c->vc_visible_origin = vga_vram_base + (p + ul) % we;
360 #endif /* CONFIG_VGACON_SOFT_SCROLLBACK */
362 static const char *vgacon_startup(void)
364 const char *display_desc = NULL;
368 if (screen_info.orig_video_isVGA == VIDEO_TYPE_VLFB) {
370 #ifdef CONFIG_DUMMY_CONSOLE
371 conswitchp = &dummy_con;
372 return conswitchp->con_startup();
378 /* boot_params.screen_info initialized? */
379 if ((screen_info.orig_video_mode == 0) &&
380 (screen_info.orig_video_lines == 0) &&
381 (screen_info.orig_video_cols == 0))
384 /* VGA16 modes are not handled by VGACON */
385 if ((screen_info.orig_video_mode == 0x0D) || /* 320x200/4 */
386 (screen_info.orig_video_mode == 0x0E) || /* 640x200/4 */
387 (screen_info.orig_video_mode == 0x10) || /* 640x350/4 */
388 (screen_info.orig_video_mode == 0x12) || /* 640x480/4 */
389 (screen_info.orig_video_mode == 0x6A)) /* 800x600/4 (VESA) */
392 vga_video_num_lines = screen_info.orig_video_lines;
393 vga_video_num_columns = screen_info.orig_video_cols;
394 state.vgabase = NULL;
396 if (screen_info.orig_video_mode == 7) {
397 /* Monochrome display */
398 vga_vram_base = 0xb0000;
399 vga_video_port_reg = VGA_CRT_IM;
400 vga_video_port_val = VGA_CRT_DM;
401 if ((screen_info.orig_video_ega_bx & 0xff) != 0x10) {
402 static struct resource ega_console_resource =
403 { .name = "ega", .start = 0x3B0, .end = 0x3BF };
404 vga_video_type = VIDEO_TYPE_EGAM;
405 vga_vram_size = 0x8000;
406 display_desc = "EGA+";
407 request_resource(&ioport_resource,
408 &ega_console_resource);
410 static struct resource mda1_console_resource =
411 { .name = "mda", .start = 0x3B0, .end = 0x3BB };
412 static struct resource mda2_console_resource =
413 { .name = "mda", .start = 0x3BF, .end = 0x3BF };
414 vga_video_type = VIDEO_TYPE_MDA;
415 vga_vram_size = 0x2000;
416 display_desc = "*MDA";
417 request_resource(&ioport_resource,
418 &mda1_console_resource);
419 request_resource(&ioport_resource,
420 &mda2_console_resource);
421 vga_video_font_height = 14;
424 /* If not, it is color. */
425 vga_can_do_color = 1;
426 vga_vram_base = 0xb8000;
427 vga_video_port_reg = VGA_CRT_IC;
428 vga_video_port_val = VGA_CRT_DC;
429 if ((screen_info.orig_video_ega_bx & 0xff) != 0x10) {
432 vga_vram_size = 0x8000;
434 if (!screen_info.orig_video_isVGA) {
435 static struct resource ega_console_resource
436 = { .name = "ega", .start = 0x3C0, .end = 0x3DF };
437 vga_video_type = VIDEO_TYPE_EGAC;
438 display_desc = "EGA";
439 request_resource(&ioport_resource,
440 &ega_console_resource);
442 static struct resource vga_console_resource
443 = { .name = "vga+", .start = 0x3C0, .end = 0x3DF };
444 vga_video_type = VIDEO_TYPE_VGAC;
445 display_desc = "VGA+";
446 request_resource(&ioport_resource,
447 &vga_console_resource);
449 #ifdef VGA_CAN_DO_64KB
451 * get 64K rather than 32K of video RAM.
452 * This doesn't actually work on all "VGA"
453 * controllers (it seems like setting MM=01
454 * and COE=1 isn't necessarily a good idea)
456 vga_vram_base = 0xa0000;
457 vga_vram_size = 0x10000;
458 outb_p(6, VGA_GFX_I);
459 outb_p(6, VGA_GFX_D);
462 * Normalise the palette registers, to point
463 * the 16 screen colours to the first 16
467 for (i = 0; i < 16; i++) {
469 outb_p(i, VGA_ATT_W);
470 outb_p(i, VGA_ATT_W);
472 outb_p(0x20, VGA_ATT_W);
475 * Now set the DAC registers back to their
478 for (i = 0; i < 16; i++) {
479 outb_p(color_table[i], VGA_PEL_IW);
480 outb_p(default_red[i], VGA_PEL_D);
481 outb_p(default_grn[i], VGA_PEL_D);
482 outb_p(default_blu[i], VGA_PEL_D);
486 static struct resource cga_console_resource =
487 { .name = "cga", .start = 0x3D4, .end = 0x3D5 };
488 vga_video_type = VIDEO_TYPE_CGA;
489 vga_vram_size = 0x2000;
490 display_desc = "*CGA";
491 request_resource(&ioport_resource,
492 &cga_console_resource);
493 vga_video_font_height = 8;
497 vga_vram_base = VGA_MAP_MEM(vga_vram_base, vga_vram_size);
498 vga_vram_end = vga_vram_base + vga_vram_size;
501 * Find out if there is a graphics card present.
502 * Are there smarter methods around?
504 p = (volatile u16 *) vga_vram_base;
505 saved1 = scr_readw(p);
506 saved2 = scr_readw(p + 1);
507 scr_writew(0xAA55, p);
508 scr_writew(0x55AA, p + 1);
509 if (scr_readw(p) != 0xAA55 || scr_readw(p + 1) != 0x55AA) {
510 scr_writew(saved1, p);
511 scr_writew(saved2, p + 1);
514 scr_writew(0x55AA, p);
515 scr_writew(0xAA55, p + 1);
516 if (scr_readw(p) != 0x55AA || scr_readw(p + 1) != 0xAA55) {
517 scr_writew(saved1, p);
518 scr_writew(saved2, p + 1);
521 scr_writew(saved1, p);
522 scr_writew(saved2, p + 1);
524 if (vga_video_type == VIDEO_TYPE_EGAC
525 || vga_video_type == VIDEO_TYPE_VGAC
526 || vga_video_type == VIDEO_TYPE_EGAM) {
527 vga_hardscroll_enabled = vga_hardscroll_user_enable;
528 vga_default_font_height = screen_info.orig_video_points;
529 vga_video_font_height = screen_info.orig_video_points;
530 /* This may be suboptimal but is a safe bet - go with it */
532 vga_video_font_height * vga_video_num_lines;
535 vgacon_xres = screen_info.orig_video_cols * VGA_FONTWIDTH;
536 vgacon_yres = vga_scan_lines;
538 if (!vga_init_done) {
539 vgacon_scrollback_startup();
546 static void vgacon_init(struct vc_data *c, int init)
551 * We cannot be loaded as a module, therefore init is always 1,
552 * but vgacon_init can be called more than once, and init will
555 c->vc_can_do_color = vga_can_do_color;
557 /* set dimensions manually if init != 0 since vc_resize() will fail */
559 c->vc_cols = vga_video_num_columns;
560 c->vc_rows = vga_video_num_lines;
562 vc_resize(c, vga_video_num_columns, vga_video_num_lines);
564 c->vc_scan_lines = vga_scan_lines;
565 c->vc_font.height = vga_video_font_height;
566 c->vc_complement_mask = 0x7700;
568 c->vc_hi_font_mask = 0x0800;
569 p = *c->vc_uni_pagedir_loc;
570 if (c->vc_uni_pagedir_loc == &c->vc_uni_pagedir ||
571 !--c->vc_uni_pagedir_loc[1])
573 c->vc_uni_pagedir_loc = vgacon_uni_pagedir;
574 vgacon_uni_pagedir[1]++;
575 if (!vgacon_uni_pagedir[0] && p)
576 con_set_default_unimap(c);
579 static void vgacon_deinit(struct vc_data *c)
581 /* When closing the last console, reset video origin */
582 if (!--vgacon_uni_pagedir[1]) {
583 c->vc_visible_origin = vga_vram_base;
587 c->vc_uni_pagedir_loc = &c->vc_uni_pagedir;
588 con_set_default_unimap(c);
591 static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
592 u8 blink, u8 underline, u8 reverse, u8 italic)
596 if (vga_can_do_color) {
598 attr = (attr & 0xF0) | c->vc_itcolor;
600 attr = (attr & 0xf0) | c->vc_ulcolor;
601 else if (intensity == 0)
602 attr = (attr & 0xf0) | c->vc_halfcolor;
606 ((attr) & 0x88) | ((((attr) >> 4) | ((attr) << 4)) &
612 if (!vga_can_do_color) {
614 attr = (attr & 0xF8) | 0x02;
616 attr = (attr & 0xf8) | 0x01;
617 else if (intensity == 0)
618 attr = (attr & 0xf0) | 0x08;
623 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count)
625 int col = vga_can_do_color;
628 u16 a = scr_readw(p);
630 a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) |
631 (((a) & 0x0700) << 4);
633 a ^= ((a & 0x0700) == 0x0100) ? 0x7000 : 0x7700;
638 static void vgacon_set_cursor_size(int xpos, int from, int to)
643 #ifdef TRIDENT_GLITCH
648 if ((from == cursor_size_lastfrom) && (to == cursor_size_lastto))
650 cursor_size_lastfrom = from;
651 cursor_size_lastto = to;
653 spin_lock_irqsave(&vga_lock, flags);
654 if (vga_video_type >= VIDEO_TYPE_VGAC) {
655 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
656 curs = inb_p(vga_video_port_val);
657 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
658 cure = inb_p(vga_video_port_val);
664 curs = (curs & 0xc0) | from;
665 cure = (cure & 0xe0) | to;
667 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
668 outb_p(curs, vga_video_port_val);
669 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
670 outb_p(cure, vga_video_port_val);
671 spin_unlock_irqrestore(&vga_lock, flags);
674 static void vgacon_cursor(struct vc_data *c, int mode)
676 if (c->vc_mode != KD_TEXT)
679 vgacon_restore_screen(c);
683 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
684 if (vga_video_type >= VIDEO_TYPE_VGAC)
685 vgacon_set_cursor_size(c->vc_x, 31, 30);
687 vgacon_set_cursor_size(c->vc_x, 31, 31);
692 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
693 switch (c->vc_cursor_type & 0x0f) {
695 vgacon_set_cursor_size(c->vc_x,
704 vgacon_set_cursor_size(c->vc_x,
705 c->vc_font.height / 3,
710 case CUR_LOWER_THIRD:
711 vgacon_set_cursor_size(c->vc_x,
712 (c->vc_font.height * 2) / 3,
718 vgacon_set_cursor_size(c->vc_x,
719 c->vc_font.height / 2,
725 if (vga_video_type >= VIDEO_TYPE_VGAC)
726 vgacon_set_cursor_size(c->vc_x, 31, 30);
728 vgacon_set_cursor_size(c->vc_x, 31, 31);
731 vgacon_set_cursor_size(c->vc_x, 1,
739 static int vgacon_doresize(struct vc_data *c,
740 unsigned int width, unsigned int height)
743 unsigned int scanlines = height * c->vc_font.height;
744 u8 scanlines_lo = 0, r7 = 0, vsync_end = 0, mode, max_scan;
746 spin_lock_irqsave(&vga_lock, flags);
748 vgacon_xres = width * VGA_FONTWIDTH;
749 vgacon_yres = height * c->vc_font.height;
750 if (vga_video_type >= VIDEO_TYPE_VGAC) {
751 outb_p(VGA_CRTC_MAX_SCAN, vga_video_port_reg);
752 max_scan = inb_p(vga_video_port_val);
757 outb_p(VGA_CRTC_MODE, vga_video_port_reg);
758 mode = inb_p(vga_video_port_val);
764 scanlines_lo = scanlines & 0xff;
766 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
767 r7 = inb_p(vga_video_port_val) & ~0x42;
769 if (scanlines & 0x100)
771 if (scanlines & 0x200)
774 /* deprotect registers */
775 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
776 vsync_end = inb_p(vga_video_port_val);
777 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
778 outb_p(vsync_end & ~0x80, vga_video_port_val);
781 outb_p(VGA_CRTC_H_DISP, vga_video_port_reg);
782 outb_p(width - 1, vga_video_port_val);
783 outb_p(VGA_CRTC_OFFSET, vga_video_port_reg);
784 outb_p(width >> 1, vga_video_port_val);
786 if (vga_video_type >= VIDEO_TYPE_VGAC) {
787 outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg);
788 outb_p(scanlines_lo, vga_video_port_val);
789 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
790 outb_p(r7,vga_video_port_val);
792 /* reprotect registers */
793 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
794 outb_p(vsync_end, vga_video_port_val);
797 spin_unlock_irqrestore(&vga_lock, flags);
801 static int vgacon_switch(struct vc_data *c)
803 int x = c->vc_cols * VGA_FONTWIDTH;
804 int y = c->vc_rows * c->vc_font.height;
805 int rows = screen_info.orig_video_lines * vga_default_font_height/
808 * We need to save screen size here as it's the only way
809 * we can spot the screen has been resized and we need to
810 * set size of freshly allocated screens ourselves.
812 vga_video_num_columns = c->vc_cols;
813 vga_video_num_lines = c->vc_rows;
815 /* We can only copy out the size of the video buffer here,
816 * otherwise we get into VGA BIOS */
819 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
820 c->vc_screenbuf_size > vga_vram_size ?
821 vga_vram_size : c->vc_screenbuf_size);
823 if ((vgacon_xres != x || vgacon_yres != y) &&
824 (!(vga_video_num_columns % 2) &&
825 vga_video_num_columns <= screen_info.orig_video_cols &&
826 vga_video_num_lines <= rows))
827 vgacon_doresize(c, c->vc_cols, c->vc_rows);
830 vgacon_scrollback_init(c->vc_size_row);
831 return 0; /* Redrawing not needed */
834 static void vga_set_palette(struct vc_data *vc, unsigned char *table)
838 vga_w(state.vgabase, VGA_PEL_MSK, 0xff);
839 for (i = j = 0; i < 16; i++) {
840 vga_w(state.vgabase, VGA_PEL_IW, table[i]);
841 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
842 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
843 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
847 static int vgacon_set_palette(struct vc_data *vc, unsigned char *table)
849 #ifdef CAN_LOAD_PALETTE
850 if (vga_video_type != VIDEO_TYPE_VGAC || vga_palette_blanked
851 || !CON_IS_VISIBLE(vc))
853 vga_set_palette(vc, table);
860 /* structure holding original VGA register settings */
862 unsigned char SeqCtrlIndex; /* Sequencer Index reg. */
863 unsigned char CrtCtrlIndex; /* CRT-Contr. Index reg. */
864 unsigned char CrtMiscIO; /* Miscellaneous register */
865 unsigned char HorizontalTotal; /* CRT-Controller:00h */
866 unsigned char HorizDisplayEnd; /* CRT-Controller:01h */
867 unsigned char StartHorizRetrace; /* CRT-Controller:04h */
868 unsigned char EndHorizRetrace; /* CRT-Controller:05h */
869 unsigned char Overflow; /* CRT-Controller:07h */
870 unsigned char StartVertRetrace; /* CRT-Controller:10h */
871 unsigned char EndVertRetrace; /* CRT-Controller:11h */
872 unsigned char ModeControl; /* CRT-Controller:17h */
873 unsigned char ClockingMode; /* Seq-Controller:01h */
876 static void vga_vesa_blank(struct vgastate *state, int mode)
878 /* save original values of VGA controller registers */
879 if (!vga_vesa_blanked) {
880 spin_lock_irq(&vga_lock);
881 vga_state.SeqCtrlIndex = vga_r(state->vgabase, VGA_SEQ_I);
882 vga_state.CrtCtrlIndex = inb_p(vga_video_port_reg);
883 vga_state.CrtMiscIO = vga_r(state->vgabase, VGA_MIS_R);
884 spin_unlock_irq(&vga_lock);
886 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */
887 vga_state.HorizontalTotal = inb_p(vga_video_port_val);
888 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */
889 vga_state.HorizDisplayEnd = inb_p(vga_video_port_val);
890 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
891 vga_state.StartHorizRetrace = inb_p(vga_video_port_val);
892 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
893 vga_state.EndHorizRetrace = inb_p(vga_video_port_val);
894 outb_p(0x07, vga_video_port_reg); /* Overflow */
895 vga_state.Overflow = inb_p(vga_video_port_val);
896 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
897 vga_state.StartVertRetrace = inb_p(vga_video_port_val);
898 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
899 vga_state.EndVertRetrace = inb_p(vga_video_port_val);
900 outb_p(0x17, vga_video_port_reg); /* ModeControl */
901 vga_state.ModeControl = inb_p(vga_video_port_val);
902 vga_state.ClockingMode = vga_rseq(state->vgabase, VGA_SEQ_CLOCK_MODE);
905 /* assure that video is enabled */
906 /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */
907 spin_lock_irq(&vga_lock);
908 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode | 0x20);
910 /* test for vertical retrace in process.... */
911 if ((vga_state.CrtMiscIO & 0x80) == 0x80)
912 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO & 0xEF);
915 * Set <End of vertical retrace> to minimum (0) and
916 * <Start of vertical Retrace> to maximum (incl. overflow)
917 * Result: turn off vertical sync (VSync) pulse.
919 if (mode & VESA_VSYNC_SUSPEND) {
920 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
921 outb_p(0xff, vga_video_port_val); /* maximum value */
922 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
923 outb_p(0x40, vga_video_port_val); /* minimum (bits 0..3) */
924 outb_p(0x07, vga_video_port_reg); /* Overflow */
925 outb_p(vga_state.Overflow | 0x84, vga_video_port_val); /* bits 9,10 of vert. retrace */
928 if (mode & VESA_HSYNC_SUSPEND) {
930 * Set <End of horizontal retrace> to minimum (0) and
931 * <Start of horizontal Retrace> to maximum
932 * Result: turn off horizontal sync (HSync) pulse.
934 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
935 outb_p(0xff, vga_video_port_val); /* maximum */
936 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
937 outb_p(0x00, vga_video_port_val); /* minimum (0) */
940 /* restore both index registers */
941 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
942 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
943 spin_unlock_irq(&vga_lock);
946 static void vga_vesa_unblank(struct vgastate *state)
948 /* restore original values of VGA controller registers */
949 spin_lock_irq(&vga_lock);
950 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO);
952 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */
953 outb_p(vga_state.HorizontalTotal, vga_video_port_val);
954 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */
955 outb_p(vga_state.HorizDisplayEnd, vga_video_port_val);
956 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
957 outb_p(vga_state.StartHorizRetrace, vga_video_port_val);
958 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
959 outb_p(vga_state.EndHorizRetrace, vga_video_port_val);
960 outb_p(0x07, vga_video_port_reg); /* Overflow */
961 outb_p(vga_state.Overflow, vga_video_port_val);
962 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
963 outb_p(vga_state.StartVertRetrace, vga_video_port_val);
964 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
965 outb_p(vga_state.EndVertRetrace, vga_video_port_val);
966 outb_p(0x17, vga_video_port_reg); /* ModeControl */
967 outb_p(vga_state.ModeControl, vga_video_port_val);
969 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode);
971 /* restore index/control registers */
972 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
973 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
974 spin_unlock_irq(&vga_lock);
977 static void vga_pal_blank(struct vgastate *state)
981 vga_w(state->vgabase, VGA_PEL_MSK, 0xff);
982 for (i = 0; i < 16; i++) {
983 vga_w(state->vgabase, VGA_PEL_IW, i);
984 vga_w(state->vgabase, VGA_PEL_D, 0);
985 vga_w(state->vgabase, VGA_PEL_D, 0);
986 vga_w(state->vgabase, VGA_PEL_D, 0);
990 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch)
993 case 0: /* Unblank */
994 if (vga_vesa_blanked) {
995 vga_vesa_unblank(&state);
996 vga_vesa_blanked = 0;
998 if (vga_palette_blanked) {
999 vga_set_palette(c, color_table);
1000 vga_palette_blanked = 0;
1004 /* Tell console.c that it has to restore the screen itself */
1006 case 1: /* Normal blanking */
1007 case -1: /* Obsolete */
1008 if (!mode_switch && vga_video_type == VIDEO_TYPE_VGAC) {
1009 vga_pal_blank(&state);
1010 vga_palette_blanked = 1;
1013 vgacon_set_origin(c);
1014 scr_memsetw((void *) vga_vram_base, BLANK,
1015 c->vc_screenbuf_size);
1019 default: /* VESA blanking */
1020 if (vga_video_type == VIDEO_TYPE_VGAC) {
1021 vga_vesa_blank(&state, blank - 1);
1022 vga_vesa_blanked = blank;
1031 * The font loading code goes back to the codepage package by
1032 * Joel Hoffman (joel@wam.umd.edu). (He reports that the original
1033 * reference is: "From: p. 307 of _Programmer's Guide to PC & PS/2
1034 * Video Systems_ by Richard Wilton. 1987. Microsoft Press".)
1036 * Change for certain monochrome monitors by Yury Shevchuck
1037 * (sizif@botik.yaroslavl.su).
1040 #ifdef CAN_LOAD_EGA_FONTS
1042 #define colourmap 0xa0000
1043 /* Pauline Middelink <middelin@polyware.iaf.nl> reports that we
1044 should use 0xA0000 for the bwmap as well.. */
1045 #define blackwmap 0xa0000
1048 static int vgacon_do_font_op(struct vgastate *state,char *arg,int set,int ch512)
1050 unsigned short video_port_status = vga_video_port_reg + 6;
1051 int font_select = 0x00, beg, i;
1054 if (vga_video_type != VIDEO_TYPE_EGAM) {
1055 charmap = (char *) VGA_MAP_MEM(colourmap, 0);
1057 #ifdef VGA_CAN_DO_64KB
1058 if (vga_video_type == VIDEO_TYPE_VGAC)
1062 charmap = (char *) VGA_MAP_MEM(blackwmap, 0);
1066 #ifdef BROKEN_GRAPHICS_PROGRAMS
1068 * All fonts are loaded in slot 0 (0:1 for 512 ch)
1072 return -EINVAL; /* Return to default font not supported */
1074 vga_font_is_default = 0;
1075 font_select = ch512 ? 0x04 : 0x00;
1078 * The default font is kept in slot 0 and is never touched.
1079 * A custom font is loaded in slot 2 (256 ch) or 2:3 (512 ch)
1083 vga_font_is_default = !arg;
1085 ch512 = 0; /* Default font is always 256 */
1086 font_select = arg ? (ch512 ? 0x0e : 0x0a) : 0x00;
1089 if (!vga_font_is_default)
1090 charmap += 4 * cmapsz;
1094 spin_lock_irq(&vga_lock);
1095 /* First, the Sequencer */
1096 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1);
1097 /* CPU writes only to map 2 */
1098 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x04);
1099 /* Sequential addressing */
1100 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x07);
1101 /* Clear synchronous reset */
1102 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
1104 /* Now, the graphics controller, select map 2 */
1105 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x02);
1106 /* disable odd-even addressing */
1107 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x00);
1108 /* map start at A000:0000 */
1109 vga_wgfx(state->vgabase, VGA_GFX_MISC, 0x00);
1110 spin_unlock_irq(&vga_lock);
1114 for (i = 0; i < cmapsz; i++)
1115 vga_writeb(arg[i], charmap + i);
1117 for (i = 0; i < cmapsz; i++)
1118 arg[i] = vga_readb(charmap + i);
1121 * In 512-character mode, the character map is not contiguous if
1122 * we want to remain EGA compatible -- which we do
1126 charmap += 2 * cmapsz;
1129 for (i = 0; i < cmapsz; i++)
1130 vga_writeb(arg[i], charmap + i);
1132 for (i = 0; i < cmapsz; i++)
1133 arg[i] = vga_readb(charmap + i);
1137 spin_lock_irq(&vga_lock);
1138 /* First, the sequencer, Synchronous reset */
1139 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x01);
1140 /* CPU writes to maps 0 and 1 */
1141 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x03);
1142 /* odd-even addressing */
1143 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x03);
1144 /* Character Map Select */
1146 vga_wseq(state->vgabase, VGA_SEQ_CHARACTER_MAP, font_select);
1147 /* clear synchronous reset */
1148 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
1150 /* Now, the graphics controller, select map 0 for CPU */
1151 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x00);
1152 /* enable even-odd addressing */
1153 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x10);
1154 /* map starts at b800:0 or b000:0 */
1155 vga_wgfx(state->vgabase, VGA_GFX_MISC, beg);
1157 /* if 512 char mode is already enabled don't re-enable it. */
1158 if ((set) && (ch512 != vga_512_chars)) {
1159 /* attribute controller */
1160 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1161 struct vc_data *c = vc_cons[i].d;
1162 if (c && c->vc_sw == &vga_con)
1163 c->vc_hi_font_mask = ch512 ? 0x0800 : 0;
1165 vga_512_chars = ch512;
1166 /* 256-char: enable intensity bit
1167 512-char: disable intensity bit */
1168 inb_p(video_port_status); /* clear address flip-flop */
1169 /* color plane enable register */
1170 vga_wattr(state->vgabase, VGA_ATC_PLANE_ENABLE, ch512 ? 0x07 : 0x0f);
1171 /* Wilton (1987) mentions the following; I don't know what
1172 it means, but it works, and it appears necessary */
1173 inb_p(video_port_status);
1174 vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0);
1176 spin_unlock_irq(&vga_lock);
1182 * Adjust the screen to fit a font of a certain height
1184 static int vgacon_adjust_height(struct vc_data *vc, unsigned fontheight)
1186 unsigned char ovr, vde, fsr;
1187 int rows, maxscan, i;
1189 rows = vc->vc_scan_lines / fontheight; /* Number of video rows we end up with */
1190 maxscan = rows * fontheight - 1; /* Scan lines to actually display-1 */
1192 /* Reprogram the CRTC for the new font size
1193 Note: the attempt to read the overflow register will fail
1194 on an EGA, but using 0xff for the previous value appears to
1195 be OK for EGA text modes in the range 257-512 scan lines, so I
1196 guess we don't need to worry about it.
1198 The same applies for the spill bits in the font size and cursor
1199 registers; they are write-only on EGA, but it appears that they
1200 are all don't care bits on EGA, so I guess it doesn't matter. */
1202 spin_lock_irq(&vga_lock);
1203 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */
1204 ovr = inb_p(vga_video_port_val);
1205 outb_p(0x09, vga_video_port_reg); /* Font size register */
1206 fsr = inb_p(vga_video_port_val);
1207 spin_unlock_irq(&vga_lock);
1209 vde = maxscan & 0xff; /* Vertical display end reg */
1210 ovr = (ovr & 0xbd) + /* Overflow register */
1211 ((maxscan & 0x100) >> 7) + ((maxscan & 0x200) >> 3);
1212 fsr = (fsr & 0xe0) + (fontheight - 1); /* Font size register */
1214 spin_lock_irq(&vga_lock);
1215 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */
1216 outb_p(ovr, vga_video_port_val);
1217 outb_p(0x09, vga_video_port_reg); /* Font size */
1218 outb_p(fsr, vga_video_port_val);
1219 outb_p(0x12, vga_video_port_reg); /* Vertical display limit */
1220 outb_p(vde, vga_video_port_val);
1221 spin_unlock_irq(&vga_lock);
1222 vga_video_font_height = fontheight;
1224 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1225 struct vc_data *c = vc_cons[i].d;
1227 if (c && c->vc_sw == &vga_con) {
1228 if (CON_IS_VISIBLE(c)) {
1229 /* void size to cause regs to be rewritten */
1230 cursor_size_lastfrom = 0;
1231 cursor_size_lastto = 0;
1232 c->vc_sw->con_cursor(c, CM_DRAW);
1234 c->vc_font.height = fontheight;
1235 vc_resize(c, 0, rows); /* Adjust console size */
1241 static int vgacon_font_set(struct vc_data *c, struct console_font *font, unsigned flags)
1243 unsigned charcount = font->charcount;
1246 if (vga_video_type < VIDEO_TYPE_EGAM)
1249 if (font->width != VGA_FONTWIDTH ||
1250 (charcount != 256 && charcount != 512))
1253 rc = vgacon_do_font_op(&state, font->data, 1, charcount == 512);
1257 if (!(flags & KD_FONT_FLAG_DONT_RECALC))
1258 rc = vgacon_adjust_height(c, font->height);
1262 static int vgacon_font_get(struct vc_data *c, struct console_font *font)
1264 if (vga_video_type < VIDEO_TYPE_EGAM)
1267 font->width = VGA_FONTWIDTH;
1268 font->height = c->vc_font.height;
1269 font->charcount = vga_512_chars ? 512 : 256;
1272 return vgacon_do_font_op(&state, font->data, 0, 0);
1277 #define vgacon_font_set NULL
1278 #define vgacon_font_get NULL
1282 static int vgacon_resize(struct vc_data *c, unsigned int width,
1283 unsigned int height, unsigned int user)
1285 if (width % 2 || width > screen_info.orig_video_cols ||
1286 height > (screen_info.orig_video_lines * vga_default_font_height)/
1288 /* let svgatextmode tinker with video timings and
1290 return (user) ? 0 : -EINVAL;
1292 if (CON_IS_VISIBLE(c) && !vga_is_gfx) /* who knows */
1293 vgacon_doresize(c, width, height);
1297 static int vgacon_set_origin(struct vc_data *c)
1299 if (vga_is_gfx || /* We don't play origin tricks in graphic modes */
1300 (console_blanked && !vga_palette_blanked)) /* Nor we write to blanked screens */
1302 c->vc_origin = c->vc_visible_origin = vga_vram_base;
1304 vga_rolled_over = 0;
1308 static void vgacon_save_screen(struct vc_data *c)
1310 static int vga_bootup_console = 0;
1312 if (!vga_bootup_console) {
1313 /* This is a gross hack, but here is the only place we can
1314 * set bootup console parameters without messing up generic
1315 * console initialization routines.
1317 vga_bootup_console = 1;
1318 c->vc_x = screen_info.orig_x;
1319 c->vc_y = screen_info.orig_y;
1322 /* We can't copy in more then the size of the video buffer,
1323 * or we'll be copying in VGA BIOS */
1326 scr_memcpyw((u16 *) c->vc_screenbuf, (u16 *) c->vc_origin,
1327 c->vc_screenbuf_size > vga_vram_size ? vga_vram_size : c->vc_screenbuf_size);
1330 static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
1336 if (t || b != c->vc_rows || vga_is_gfx || c->vc_mode != KD_TEXT)
1339 if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2)
1342 vgacon_restore_screen(c);
1343 oldo = c->vc_origin;
1344 delta = lines * c->vc_size_row;
1346 vgacon_scrollback_update(c, t, lines);
1347 if (c->vc_scr_end + delta >= vga_vram_end) {
1348 scr_memcpyw((u16 *) vga_vram_base,
1349 (u16 *) (oldo + delta),
1350 c->vc_screenbuf_size - delta);
1351 c->vc_origin = vga_vram_base;
1352 vga_rolled_over = oldo - vga_vram_base;
1354 c->vc_origin += delta;
1355 scr_memsetw((u16 *) (c->vc_origin + c->vc_screenbuf_size -
1356 delta), c->vc_video_erase_char,
1359 if (oldo - delta < vga_vram_base) {
1360 scr_memmovew((u16 *) (vga_vram_end -
1361 c->vc_screenbuf_size +
1362 delta), (u16 *) oldo,
1363 c->vc_screenbuf_size - delta);
1364 c->vc_origin = vga_vram_end - c->vc_screenbuf_size;
1365 vga_rolled_over = 0;
1367 c->vc_origin -= delta;
1368 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1369 scr_memsetw((u16 *) (c->vc_origin), c->vc_video_erase_char,
1372 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1373 c->vc_visible_origin = c->vc_origin;
1375 c->vc_pos = (c->vc_pos - oldo) + c->vc_origin;
1381 * The console `switch' structure for the VGA based console
1384 static int vgacon_dummy(struct vc_data *c)
1389 #define DUMMY (void *) vgacon_dummy
1391 const struct consw vga_con = {
1392 .owner = THIS_MODULE,
1393 .con_startup = vgacon_startup,
1394 .con_init = vgacon_init,
1395 .con_deinit = vgacon_deinit,
1399 .con_cursor = vgacon_cursor,
1400 .con_scroll = vgacon_scroll,
1402 .con_switch = vgacon_switch,
1403 .con_blank = vgacon_blank,
1404 .con_font_set = vgacon_font_set,
1405 .con_font_get = vgacon_font_get,
1406 .con_resize = vgacon_resize,
1407 .con_set_palette = vgacon_set_palette,
1408 .con_scrolldelta = vgacon_scrolldelta,
1409 .con_set_origin = vgacon_set_origin,
1410 .con_save_screen = vgacon_save_screen,
1411 .con_build_attr = vgacon_build_attr,
1412 .con_invert_region = vgacon_invert_region,
1415 MODULE_LICENSE("GPL");