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/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>
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;
63 #define VGA_FONTWIDTH 8 /* VGA does not support fontwidths != 8 */
65 * Interface used by the world
68 static const char *vgacon_startup(void);
69 static void vgacon_init(struct vc_data *c, int init);
70 static void vgacon_deinit(struct vc_data *c);
71 static void vgacon_cursor(struct vc_data *c, int mode);
72 static int vgacon_switch(struct vc_data *c);
73 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch);
74 static void vgacon_scrolldelta(struct vc_data *c, int lines);
75 static int vgacon_set_origin(struct vc_data *c);
76 static void vgacon_save_screen(struct vc_data *c);
77 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count);
78 static struct uni_pagedir *vgacon_uni_pagedir;
79 static int vgacon_refcount;
81 /* Description of the hardware situation */
82 static bool vga_init_done;
83 static unsigned long vga_vram_base __read_mostly; /* Base of video memory */
84 static unsigned long vga_vram_end __read_mostly; /* End of video memory */
85 static unsigned int vga_vram_size __read_mostly; /* Size of video memory */
86 static u16 vga_video_port_reg __read_mostly; /* Video register select port */
87 static u16 vga_video_port_val __read_mostly; /* Video register value port */
88 static unsigned int vga_video_num_columns; /* Number of text columns */
89 static unsigned int vga_video_num_lines; /* Number of text lines */
90 static bool vga_can_do_color; /* Do we support colors? */
91 static unsigned int vga_default_font_height __read_mostly; /* Height of default screen font */
92 static unsigned char vga_video_type __read_mostly; /* Card type */
93 static int vga_vesa_blanked;
94 static bool vga_palette_blanked;
95 static bool vga_is_gfx;
96 static bool vga_512_chars;
97 static int vga_video_font_height;
98 static int vga_scan_lines __read_mostly;
99 static unsigned int vga_rolled_over;
101 static bool vgacon_text_mode_force;
102 static bool vga_hardscroll_enabled;
103 static bool vga_hardscroll_user_enable = true;
105 bool vgacon_text_force(void)
107 return vgacon_text_mode_force;
109 EXPORT_SYMBOL(vgacon_text_force);
111 static int __init text_mode(char *str)
113 vgacon_text_mode_force = true;
115 pr_warn("You have booted with nomodeset. This means your GPU drivers are DISABLED\n");
116 pr_warn("Any video related functionality will be severely degraded, and you may not even be able to suspend the system properly\n");
117 pr_warn("Unless you actually understand what nomodeset does, you should reboot without enabling it\n");
122 /* force text mode - used by kernel modesetting */
123 __setup("nomodeset", text_mode);
125 static int __init no_scroll(char *str)
128 * Disabling scrollback is required for the Braillex ib80-piezo
129 * Braille reader made by F.H. Papenmeier (Germany).
130 * Use the "no-scroll" bootflag.
132 vga_hardscroll_user_enable = vga_hardscroll_enabled = false;
136 __setup("no-scroll", no_scroll);
139 * By replacing the four outb_p with two back to back outw, we can reduce
140 * the window of opportunity to see text mislocated to the RHS of the
141 * console during heavy scrolling activity. However there is the remote
142 * possibility that some pre-dinosaur hardware won't like the back to back
143 * I/O. Since the Xservers get away with it, we should be able to as well.
145 static inline void write_vga(unsigned char reg, unsigned int val)
151 * ddprintk might set the console position from interrupt
152 * handlers, thus the write has to be IRQ-atomic.
154 raw_spin_lock_irqsave(&vga_lock, flags);
155 v1 = reg + (val & 0xff00);
156 v2 = reg + 1 + ((val << 8) & 0xff00);
157 outw(v1, vga_video_port_reg);
158 outw(v2, vga_video_port_reg);
159 raw_spin_unlock_irqrestore(&vga_lock, flags);
162 static inline void vga_set_mem_top(struct vc_data *c)
164 write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
167 static void vgacon_restore_screen(struct vc_data *c)
169 if (c->vc_origin != c->vc_visible_origin)
170 vgacon_scrolldelta(c, 0);
173 static void vgacon_scrolldelta(struct vc_data *c, int lines)
175 vc_scrolldelta_helper(c, lines, vga_rolled_over, (void *)vga_vram_base,
180 static const char *vgacon_startup(void)
182 const char *display_desc = NULL;
186 if (screen_info.orig_video_isVGA == VIDEO_TYPE_VLFB ||
187 screen_info.orig_video_isVGA == VIDEO_TYPE_EFI) {
189 #ifdef CONFIG_DUMMY_CONSOLE
190 conswitchp = &dummy_con;
191 return conswitchp->con_startup();
197 /* boot_params.screen_info reasonably initialized? */
198 if ((screen_info.orig_video_lines == 0) ||
199 (screen_info.orig_video_cols == 0))
202 /* VGA16 modes are not handled by VGACON */
203 if ((screen_info.orig_video_mode == 0x0D) || /* 320x200/4 */
204 (screen_info.orig_video_mode == 0x0E) || /* 640x200/4 */
205 (screen_info.orig_video_mode == 0x10) || /* 640x350/4 */
206 (screen_info.orig_video_mode == 0x12) || /* 640x480/4 */
207 (screen_info.orig_video_mode == 0x6A)) /* 800x600/4 (VESA) */
210 vga_video_num_lines = screen_info.orig_video_lines;
211 vga_video_num_columns = screen_info.orig_video_cols;
212 vgastate.vgabase = NULL;
214 if (screen_info.orig_video_mode == 7) {
215 /* Monochrome display */
216 vga_vram_base = 0xb0000;
217 vga_video_port_reg = VGA_CRT_IM;
218 vga_video_port_val = VGA_CRT_DM;
219 if ((screen_info.orig_video_ega_bx & 0xff) != 0x10) {
220 static struct resource ega_console_resource =
222 .flags = IORESOURCE_IO,
225 vga_video_type = VIDEO_TYPE_EGAM;
226 vga_vram_size = 0x8000;
227 display_desc = "EGA+";
228 request_resource(&ioport_resource,
229 &ega_console_resource);
231 static struct resource mda1_console_resource =
233 .flags = IORESOURCE_IO,
236 static struct resource mda2_console_resource =
238 .flags = IORESOURCE_IO,
241 vga_video_type = VIDEO_TYPE_MDA;
242 vga_vram_size = 0x2000;
243 display_desc = "*MDA";
244 request_resource(&ioport_resource,
245 &mda1_console_resource);
246 request_resource(&ioport_resource,
247 &mda2_console_resource);
248 vga_video_font_height = 14;
251 /* If not, it is color. */
252 vga_can_do_color = true;
253 vga_vram_base = 0xb8000;
254 vga_video_port_reg = VGA_CRT_IC;
255 vga_video_port_val = VGA_CRT_DC;
256 if ((screen_info.orig_video_ega_bx & 0xff) != 0x10) {
259 vga_vram_size = 0x8000;
261 if (!screen_info.orig_video_isVGA) {
262 static struct resource ega_console_resource =
264 .flags = IORESOURCE_IO,
267 vga_video_type = VIDEO_TYPE_EGAC;
268 display_desc = "EGA";
269 request_resource(&ioport_resource,
270 &ega_console_resource);
272 static struct resource vga_console_resource =
274 .flags = IORESOURCE_IO,
277 vga_video_type = VIDEO_TYPE_VGAC;
278 display_desc = "VGA+";
279 request_resource(&ioport_resource,
280 &vga_console_resource);
283 * Normalise the palette registers, to point
284 * the 16 screen colours to the first 16
288 for (i = 0; i < 16; i++) {
290 outb_p(i, VGA_ATT_W);
291 outb_p(i, VGA_ATT_W);
293 outb_p(0x20, VGA_ATT_W);
296 * Now set the DAC registers back to their
299 for (i = 0; i < 16; i++) {
300 outb_p(color_table[i], VGA_PEL_IW);
301 outb_p(default_red[i], VGA_PEL_D);
302 outb_p(default_grn[i], VGA_PEL_D);
303 outb_p(default_blu[i], VGA_PEL_D);
307 static struct resource cga_console_resource =
309 .flags = IORESOURCE_IO,
312 vga_video_type = VIDEO_TYPE_CGA;
313 vga_vram_size = 0x2000;
314 display_desc = "*CGA";
315 request_resource(&ioport_resource,
316 &cga_console_resource);
317 vga_video_font_height = 8;
321 vga_vram_base = VGA_MAP_MEM(vga_vram_base, vga_vram_size);
322 vga_vram_end = vga_vram_base + vga_vram_size;
325 * Find out if there is a graphics card present.
326 * Are there smarter methods around?
328 p = (volatile u16 *) vga_vram_base;
329 saved1 = scr_readw(p);
330 saved2 = scr_readw(p + 1);
331 scr_writew(0xAA55, p);
332 scr_writew(0x55AA, p + 1);
333 if (scr_readw(p) != 0xAA55 || scr_readw(p + 1) != 0x55AA) {
334 scr_writew(saved1, p);
335 scr_writew(saved2, p + 1);
338 scr_writew(0x55AA, p);
339 scr_writew(0xAA55, p + 1);
340 if (scr_readw(p) != 0x55AA || scr_readw(p + 1) != 0xAA55) {
341 scr_writew(saved1, p);
342 scr_writew(saved2, p + 1);
345 scr_writew(saved1, p);
346 scr_writew(saved2, p + 1);
348 if (vga_video_type == VIDEO_TYPE_EGAC
349 || vga_video_type == VIDEO_TYPE_VGAC
350 || vga_video_type == VIDEO_TYPE_EGAM) {
351 vga_hardscroll_enabled = vga_hardscroll_user_enable;
352 vga_default_font_height = screen_info.orig_video_points;
353 vga_video_font_height = screen_info.orig_video_points;
354 /* This may be suboptimal but is a safe bet - go with it */
356 vga_video_font_height * vga_video_num_lines;
359 vgacon_xres = screen_info.orig_video_cols * VGA_FONTWIDTH;
360 vgacon_yres = vga_scan_lines;
362 vga_init_done = true;
367 static void vgacon_init(struct vc_data *c, int init)
369 struct uni_pagedir *p;
372 * We cannot be loaded as a module, therefore init is always 1,
373 * but vgacon_init can be called more than once, and init will
376 c->vc_can_do_color = vga_can_do_color;
378 /* set dimensions manually if init != 0 since vc_resize() will fail */
380 c->vc_cols = vga_video_num_columns;
381 c->vc_rows = vga_video_num_lines;
383 vc_resize(c, vga_video_num_columns, vga_video_num_lines);
385 c->vc_scan_lines = vga_scan_lines;
386 c->vc_font.height = vga_video_font_height;
387 c->vc_complement_mask = 0x7700;
389 c->vc_hi_font_mask = 0x0800;
390 p = *c->vc_uni_pagedir_loc;
391 if (c->vc_uni_pagedir_loc != &vgacon_uni_pagedir) {
393 c->vc_uni_pagedir_loc = &vgacon_uni_pagedir;
396 if (!vgacon_uni_pagedir && p)
397 con_set_default_unimap(c);
399 /* Only set the default if the user didn't deliberately override it */
400 if (global_cursor_default == -1)
401 global_cursor_default =
402 !(screen_info.flags & VIDEO_FLAGS_NOCURSOR);
405 static void vgacon_deinit(struct vc_data *c)
407 /* When closing the active console, reset video origin */
408 if (con_is_visible(c)) {
409 c->vc_visible_origin = vga_vram_base;
413 if (!--vgacon_refcount)
415 c->vc_uni_pagedir_loc = &c->vc_uni_pagedir;
416 con_set_default_unimap(c);
419 static u8 vgacon_build_attr(struct vc_data *c, u8 color,
420 enum vc_intensity intensity,
421 bool blink, bool underline, bool reverse,
426 if (vga_can_do_color) {
428 attr = (attr & 0xF0) | c->vc_itcolor;
430 attr = (attr & 0xf0) | c->vc_ulcolor;
431 else if (intensity == VCI_HALF_BRIGHT)
432 attr = (attr & 0xf0) | c->vc_halfcolor;
436 ((attr) & 0x88) | ((((attr) >> 4) | ((attr) << 4)) &
440 if (intensity == VCI_BOLD)
442 if (!vga_can_do_color) {
444 attr = (attr & 0xF8) | 0x02;
446 attr = (attr & 0xf8) | 0x01;
447 else if (intensity == VCI_HALF_BRIGHT)
448 attr = (attr & 0xf0) | 0x08;
453 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count)
455 const bool col = vga_can_do_color;
458 u16 a = scr_readw(p);
460 a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) |
461 (((a) & 0x0700) << 4);
463 a ^= ((a & 0x0700) == 0x0100) ? 0x7000 : 0x7700;
468 static void vgacon_set_cursor_size(int xpos, int from, int to)
473 if ((from == cursor_size_lastfrom) && (to == cursor_size_lastto))
475 cursor_size_lastfrom = from;
476 cursor_size_lastto = to;
478 raw_spin_lock_irqsave(&vga_lock, flags);
479 if (vga_video_type >= VIDEO_TYPE_VGAC) {
480 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
481 curs = inb_p(vga_video_port_val);
482 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
483 cure = inb_p(vga_video_port_val);
489 curs = (curs & 0xc0) | from;
490 cure = (cure & 0xe0) | to;
492 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
493 outb_p(curs, vga_video_port_val);
494 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
495 outb_p(cure, vga_video_port_val);
496 raw_spin_unlock_irqrestore(&vga_lock, flags);
499 static void vgacon_cursor(struct vc_data *c, int mode)
501 if (c->vc_mode != KD_TEXT)
504 vgacon_restore_screen(c);
508 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
509 if (vga_video_type >= VIDEO_TYPE_VGAC)
510 vgacon_set_cursor_size(c->state.x, 31, 30);
512 vgacon_set_cursor_size(c->state.x, 31, 31);
517 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
518 switch (CUR_SIZE(c->vc_cursor_type)) {
520 vgacon_set_cursor_size(c->state.x,
529 vgacon_set_cursor_size(c->state.x,
530 c->vc_font.height / 3,
535 case CUR_LOWER_THIRD:
536 vgacon_set_cursor_size(c->state.x,
537 (c->vc_font.height * 2) / 3,
543 vgacon_set_cursor_size(c->state.x,
544 c->vc_font.height / 2,
550 if (vga_video_type >= VIDEO_TYPE_VGAC)
551 vgacon_set_cursor_size(c->state.x, 31, 30);
553 vgacon_set_cursor_size(c->state.x, 31, 31);
556 vgacon_set_cursor_size(c->state.x, 1,
564 static int vgacon_doresize(struct vc_data *c,
565 unsigned int width, unsigned int height)
568 unsigned int scanlines = height * c->vc_font.height;
569 u8 scanlines_lo = 0, r7 = 0, vsync_end = 0, mode, max_scan;
571 raw_spin_lock_irqsave(&vga_lock, flags);
573 vgacon_xres = width * VGA_FONTWIDTH;
574 vgacon_yres = height * c->vc_font.height;
575 if (vga_video_type >= VIDEO_TYPE_VGAC) {
576 outb_p(VGA_CRTC_MAX_SCAN, vga_video_port_reg);
577 max_scan = inb_p(vga_video_port_val);
582 outb_p(VGA_CRTC_MODE, vga_video_port_reg);
583 mode = inb_p(vga_video_port_val);
589 scanlines_lo = scanlines & 0xff;
591 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
592 r7 = inb_p(vga_video_port_val) & ~0x42;
594 if (scanlines & 0x100)
596 if (scanlines & 0x200)
599 /* deprotect registers */
600 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
601 vsync_end = inb_p(vga_video_port_val);
602 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
603 outb_p(vsync_end & ~0x80, vga_video_port_val);
606 outb_p(VGA_CRTC_H_DISP, vga_video_port_reg);
607 outb_p(width - 1, vga_video_port_val);
608 outb_p(VGA_CRTC_OFFSET, vga_video_port_reg);
609 outb_p(width >> 1, vga_video_port_val);
611 if (vga_video_type >= VIDEO_TYPE_VGAC) {
612 outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg);
613 outb_p(scanlines_lo, vga_video_port_val);
614 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
615 outb_p(r7,vga_video_port_val);
617 /* reprotect registers */
618 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
619 outb_p(vsync_end, vga_video_port_val);
622 raw_spin_unlock_irqrestore(&vga_lock, flags);
626 static int vgacon_switch(struct vc_data *c)
628 int x = c->vc_cols * VGA_FONTWIDTH;
629 int y = c->vc_rows * c->vc_font.height;
630 int rows = screen_info.orig_video_lines * vga_default_font_height/
633 * We need to save screen size here as it's the only way
634 * we can spot the screen has been resized and we need to
635 * set size of freshly allocated screens ourselves.
637 vga_video_num_columns = c->vc_cols;
638 vga_video_num_lines = c->vc_rows;
640 /* We can only copy out the size of the video buffer here,
641 * otherwise we get into VGA BIOS */
644 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
645 c->vc_screenbuf_size > vga_vram_size ?
646 vga_vram_size : c->vc_screenbuf_size);
648 if ((vgacon_xres != x || vgacon_yres != y) &&
649 (!(vga_video_num_columns % 2) &&
650 vga_video_num_columns <= screen_info.orig_video_cols &&
651 vga_video_num_lines <= rows))
652 vgacon_doresize(c, c->vc_cols, c->vc_rows);
655 return 0; /* Redrawing not needed */
658 static void vga_set_palette(struct vc_data *vc, const unsigned char *table)
662 vga_w(vgastate.vgabase, VGA_PEL_MSK, 0xff);
663 for (i = j = 0; i < 16; i++) {
664 vga_w(vgastate.vgabase, VGA_PEL_IW, table[i]);
665 vga_w(vgastate.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
666 vga_w(vgastate.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
667 vga_w(vgastate.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
671 static void vgacon_set_palette(struct vc_data *vc, const unsigned char *table)
673 if (vga_video_type != VIDEO_TYPE_VGAC || vga_palette_blanked
674 || !con_is_visible(vc))
676 vga_set_palette(vc, table);
679 /* structure holding original VGA register settings */
681 unsigned char SeqCtrlIndex; /* Sequencer Index reg. */
682 unsigned char CrtCtrlIndex; /* CRT-Contr. Index reg. */
683 unsigned char CrtMiscIO; /* Miscellaneous register */
684 unsigned char HorizontalTotal; /* CRT-Controller:00h */
685 unsigned char HorizDisplayEnd; /* CRT-Controller:01h */
686 unsigned char StartHorizRetrace; /* CRT-Controller:04h */
687 unsigned char EndHorizRetrace; /* CRT-Controller:05h */
688 unsigned char Overflow; /* CRT-Controller:07h */
689 unsigned char StartVertRetrace; /* CRT-Controller:10h */
690 unsigned char EndVertRetrace; /* CRT-Controller:11h */
691 unsigned char ModeControl; /* CRT-Controller:17h */
692 unsigned char ClockingMode; /* Seq-Controller:01h */
695 static void vga_vesa_blank(struct vgastate *state, int mode)
697 /* save original values of VGA controller registers */
698 if (!vga_vesa_blanked) {
699 raw_spin_lock_irq(&vga_lock);
700 vga_state.SeqCtrlIndex = vga_r(state->vgabase, VGA_SEQ_I);
701 vga_state.CrtCtrlIndex = inb_p(vga_video_port_reg);
702 vga_state.CrtMiscIO = vga_r(state->vgabase, VGA_MIS_R);
703 raw_spin_unlock_irq(&vga_lock);
705 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */
706 vga_state.HorizontalTotal = inb_p(vga_video_port_val);
707 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */
708 vga_state.HorizDisplayEnd = inb_p(vga_video_port_val);
709 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
710 vga_state.StartHorizRetrace = inb_p(vga_video_port_val);
711 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
712 vga_state.EndHorizRetrace = inb_p(vga_video_port_val);
713 outb_p(0x07, vga_video_port_reg); /* Overflow */
714 vga_state.Overflow = inb_p(vga_video_port_val);
715 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
716 vga_state.StartVertRetrace = inb_p(vga_video_port_val);
717 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
718 vga_state.EndVertRetrace = inb_p(vga_video_port_val);
719 outb_p(0x17, vga_video_port_reg); /* ModeControl */
720 vga_state.ModeControl = inb_p(vga_video_port_val);
721 vga_state.ClockingMode = vga_rseq(state->vgabase, VGA_SEQ_CLOCK_MODE);
724 /* assure that video is enabled */
725 /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */
726 raw_spin_lock_irq(&vga_lock);
727 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode | 0x20);
729 /* test for vertical retrace in process.... */
730 if ((vga_state.CrtMiscIO & 0x80) == 0x80)
731 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO & 0xEF);
734 * Set <End of vertical retrace> to minimum (0) and
735 * <Start of vertical Retrace> to maximum (incl. overflow)
736 * Result: turn off vertical sync (VSync) pulse.
738 if (mode & VESA_VSYNC_SUSPEND) {
739 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
740 outb_p(0xff, vga_video_port_val); /* maximum value */
741 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
742 outb_p(0x40, vga_video_port_val); /* minimum (bits 0..3) */
743 outb_p(0x07, vga_video_port_reg); /* Overflow */
744 outb_p(vga_state.Overflow | 0x84, vga_video_port_val); /* bits 9,10 of vert. retrace */
747 if (mode & VESA_HSYNC_SUSPEND) {
749 * Set <End of horizontal retrace> to minimum (0) and
750 * <Start of horizontal Retrace> to maximum
751 * Result: turn off horizontal sync (HSync) pulse.
753 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
754 outb_p(0xff, vga_video_port_val); /* maximum */
755 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
756 outb_p(0x00, vga_video_port_val); /* minimum (0) */
759 /* restore both index registers */
760 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
761 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
762 raw_spin_unlock_irq(&vga_lock);
765 static void vga_vesa_unblank(struct vgastate *state)
767 /* restore original values of VGA controller registers */
768 raw_spin_lock_irq(&vga_lock);
769 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO);
771 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */
772 outb_p(vga_state.HorizontalTotal, vga_video_port_val);
773 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */
774 outb_p(vga_state.HorizDisplayEnd, vga_video_port_val);
775 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
776 outb_p(vga_state.StartHorizRetrace, vga_video_port_val);
777 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
778 outb_p(vga_state.EndHorizRetrace, vga_video_port_val);
779 outb_p(0x07, vga_video_port_reg); /* Overflow */
780 outb_p(vga_state.Overflow, vga_video_port_val);
781 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
782 outb_p(vga_state.StartVertRetrace, vga_video_port_val);
783 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
784 outb_p(vga_state.EndVertRetrace, vga_video_port_val);
785 outb_p(0x17, vga_video_port_reg); /* ModeControl */
786 outb_p(vga_state.ModeControl, vga_video_port_val);
788 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode);
790 /* restore index/control registers */
791 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
792 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
793 raw_spin_unlock_irq(&vga_lock);
796 static void vga_pal_blank(struct vgastate *state)
800 vga_w(state->vgabase, VGA_PEL_MSK, 0xff);
801 for (i = 0; i < 16; i++) {
802 vga_w(state->vgabase, VGA_PEL_IW, i);
803 vga_w(state->vgabase, VGA_PEL_D, 0);
804 vga_w(state->vgabase, VGA_PEL_D, 0);
805 vga_w(state->vgabase, VGA_PEL_D, 0);
809 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch)
812 case 0: /* Unblank */
813 if (vga_vesa_blanked) {
814 vga_vesa_unblank(&vgastate);
815 vga_vesa_blanked = 0;
817 if (vga_palette_blanked) {
818 vga_set_palette(c, color_table);
819 vga_palette_blanked = false;
823 /* Tell console.c that it has to restore the screen itself */
825 case 1: /* Normal blanking */
826 case -1: /* Obsolete */
827 if (!mode_switch && vga_video_type == VIDEO_TYPE_VGAC) {
828 vga_pal_blank(&vgastate);
829 vga_palette_blanked = true;
832 vgacon_set_origin(c);
833 scr_memsetw((void *) vga_vram_base, BLANK,
834 c->vc_screenbuf_size);
838 default: /* VESA blanking */
839 if (vga_video_type == VIDEO_TYPE_VGAC) {
840 vga_vesa_blank(&vgastate, blank - 1);
841 vga_vesa_blanked = blank;
850 * The font loading code goes back to the codepage package by
851 * Joel Hoffman (joel@wam.umd.edu). (He reports that the original
852 * reference is: "From: p. 307 of _Programmer's Guide to PC & PS/2
853 * Video Systems_ by Richard Wilton. 1987. Microsoft Press".)
855 * Change for certain monochrome monitors by Yury Shevchuck
856 * (sizif@botik.yaroslavl.su).
859 #define colourmap 0xa0000
860 /* Pauline Middelink <middelin@polyware.iaf.nl> reports that we
861 should use 0xA0000 for the bwmap as well.. */
862 #define blackwmap 0xa0000
865 static int vgacon_do_font_op(struct vgastate *state, char *arg, int set,
868 unsigned short video_port_status = vga_video_port_reg + 6;
869 int font_select = 0x00, beg, i;
871 bool clear_attribs = false;
872 if (vga_video_type != VIDEO_TYPE_EGAM) {
873 charmap = (char *) VGA_MAP_MEM(colourmap, 0);
876 charmap = (char *) VGA_MAP_MEM(blackwmap, 0);
881 * All fonts are loaded in slot 0 (0:1 for 512 ch)
885 return -EINVAL; /* Return to default font not supported */
887 font_select = ch512 ? 0x04 : 0x00;
889 raw_spin_lock_irq(&vga_lock);
890 /* First, the Sequencer */
891 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1);
892 /* CPU writes only to map 2 */
893 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x04);
894 /* Sequential addressing */
895 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x07);
896 /* Clear synchronous reset */
897 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
899 /* Now, the graphics controller, select map 2 */
900 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x02);
901 /* disable odd-even addressing */
902 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x00);
903 /* map start at A000:0000 */
904 vga_wgfx(state->vgabase, VGA_GFX_MISC, 0x00);
905 raw_spin_unlock_irq(&vga_lock);
909 for (i = 0; i < cmapsz; i++) {
910 vga_writeb(arg[i], charmap + i);
914 for (i = 0; i < cmapsz; i++) {
915 arg[i] = vga_readb(charmap + i);
920 * In 512-character mode, the character map is not contiguous if
921 * we want to remain EGA compatible -- which we do
925 charmap += 2 * cmapsz;
928 for (i = 0; i < cmapsz; i++) {
929 vga_writeb(arg[i], charmap + i);
933 for (i = 0; i < cmapsz; i++) {
934 arg[i] = vga_readb(charmap + i);
940 raw_spin_lock_irq(&vga_lock);
941 /* First, the sequencer, Synchronous reset */
942 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x01);
943 /* CPU writes to maps 0 and 1 */
944 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x03);
945 /* odd-even addressing */
946 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x03);
947 /* Character Map Select */
949 vga_wseq(state->vgabase, VGA_SEQ_CHARACTER_MAP, font_select);
950 /* clear synchronous reset */
951 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
953 /* Now, the graphics controller, select map 0 for CPU */
954 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x00);
955 /* enable even-odd addressing */
956 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x10);
957 /* map starts at b800:0 or b000:0 */
958 vga_wgfx(state->vgabase, VGA_GFX_MISC, beg);
960 /* if 512 char mode is already enabled don't re-enable it. */
961 if ((set) && (ch512 != vga_512_chars)) {
962 vga_512_chars = ch512;
963 /* 256-char: enable intensity bit
964 512-char: disable intensity bit */
965 inb_p(video_port_status); /* clear address flip-flop */
966 /* color plane enable register */
967 vga_wattr(state->vgabase, VGA_ATC_PLANE_ENABLE, ch512 ? 0x07 : 0x0f);
968 /* Wilton (1987) mentions the following; I don't know what
969 it means, but it works, and it appears necessary */
970 inb_p(video_port_status);
971 vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0);
972 clear_attribs = true;
974 raw_spin_unlock_irq(&vga_lock);
977 for (i = 0; i < MAX_NR_CONSOLES; i++) {
978 struct vc_data *c = vc_cons[i].d;
979 if (c && c->vc_sw == &vga_con) {
980 /* force hi font mask to 0, so we always clear
981 the bit on either transition */
982 c->vc_hi_font_mask = 0x00;
983 clear_buffer_attributes(c);
984 c->vc_hi_font_mask = ch512 ? 0x0800 : 0;
992 * Adjust the screen to fit a font of a certain height
994 static int vgacon_adjust_height(struct vc_data *vc, unsigned fontheight)
996 unsigned char ovr, vde, fsr;
997 int rows, maxscan, i;
999 rows = vc->vc_scan_lines / fontheight; /* Number of video rows we end up with */
1000 maxscan = rows * fontheight - 1; /* Scan lines to actually display-1 */
1002 /* Reprogram the CRTC for the new font size
1003 Note: the attempt to read the overflow register will fail
1004 on an EGA, but using 0xff for the previous value appears to
1005 be OK for EGA text modes in the range 257-512 scan lines, so I
1006 guess we don't need to worry about it.
1008 The same applies for the spill bits in the font size and cursor
1009 registers; they are write-only on EGA, but it appears that they
1010 are all don't care bits on EGA, so I guess it doesn't matter. */
1012 raw_spin_lock_irq(&vga_lock);
1013 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */
1014 ovr = inb_p(vga_video_port_val);
1015 outb_p(0x09, vga_video_port_reg); /* Font size register */
1016 fsr = inb_p(vga_video_port_val);
1017 raw_spin_unlock_irq(&vga_lock);
1019 vde = maxscan & 0xff; /* Vertical display end reg */
1020 ovr = (ovr & 0xbd) + /* Overflow register */
1021 ((maxscan & 0x100) >> 7) + ((maxscan & 0x200) >> 3);
1022 fsr = (fsr & 0xe0) + (fontheight - 1); /* Font size register */
1024 raw_spin_lock_irq(&vga_lock);
1025 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */
1026 outb_p(ovr, vga_video_port_val);
1027 outb_p(0x09, vga_video_port_reg); /* Font size */
1028 outb_p(fsr, vga_video_port_val);
1029 outb_p(0x12, vga_video_port_reg); /* Vertical display limit */
1030 outb_p(vde, vga_video_port_val);
1031 raw_spin_unlock_irq(&vga_lock);
1032 vga_video_font_height = fontheight;
1034 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1035 struct vc_data *c = vc_cons[i].d;
1037 if (c && c->vc_sw == &vga_con) {
1038 if (con_is_visible(c)) {
1039 /* void size to cause regs to be rewritten */
1040 cursor_size_lastfrom = 0;
1041 cursor_size_lastto = 0;
1042 c->vc_sw->con_cursor(c, CM_DRAW);
1044 c->vc_font.height = fontheight;
1045 vc_resize(c, 0, rows); /* Adjust console size */
1051 static int vgacon_font_set(struct vc_data *c, struct console_font *font,
1054 unsigned charcount = font->charcount;
1057 if (vga_video_type < VIDEO_TYPE_EGAM)
1060 if (font->width != VGA_FONTWIDTH ||
1061 (charcount != 256 && charcount != 512))
1064 rc = vgacon_do_font_op(&vgastate, font->data, 1, charcount == 512);
1068 if (!(flags & KD_FONT_FLAG_DONT_RECALC))
1069 rc = vgacon_adjust_height(c, font->height);
1073 static int vgacon_font_get(struct vc_data *c, struct console_font *font)
1075 if (vga_video_type < VIDEO_TYPE_EGAM)
1078 font->width = VGA_FONTWIDTH;
1079 font->height = c->vc_font.height;
1080 font->charcount = vga_512_chars ? 512 : 256;
1083 return vgacon_do_font_op(&vgastate, font->data, 0, vga_512_chars);
1086 static int vgacon_resize(struct vc_data *c, unsigned int width,
1087 unsigned int height, unsigned int user)
1089 if ((width << 1) * height > vga_vram_size)
1092 if (width % 2 || width > screen_info.orig_video_cols ||
1093 height > (screen_info.orig_video_lines * vga_default_font_height)/
1095 /* let svgatextmode tinker with video timings and
1097 return (user) ? 0 : -EINVAL;
1099 if (con_is_visible(c) && !vga_is_gfx) /* who knows */
1100 vgacon_doresize(c, width, height);
1104 static int vgacon_set_origin(struct vc_data *c)
1106 if (vga_is_gfx || /* We don't play origin tricks in graphic modes */
1107 (console_blanked && !vga_palette_blanked)) /* Nor we write to blanked screens */
1109 c->vc_origin = c->vc_visible_origin = vga_vram_base;
1111 vga_rolled_over = 0;
1115 static void vgacon_save_screen(struct vc_data *c)
1117 static int vga_bootup_console = 0;
1119 if (!vga_bootup_console) {
1120 /* This is a gross hack, but here is the only place we can
1121 * set bootup console parameters without messing up generic
1122 * console initialization routines.
1124 vga_bootup_console = 1;
1125 c->state.x = screen_info.orig_x;
1126 c->state.y = screen_info.orig_y;
1129 /* We can't copy in more than the size of the video buffer,
1130 * or we'll be copying in VGA BIOS */
1133 scr_memcpyw((u16 *) c->vc_screenbuf, (u16 *) c->vc_origin,
1134 c->vc_screenbuf_size > vga_vram_size ? vga_vram_size : c->vc_screenbuf_size);
1137 static bool vgacon_scroll(struct vc_data *c, unsigned int t, unsigned int b,
1138 enum con_scroll dir, unsigned int lines)
1143 if (t || b != c->vc_rows || vga_is_gfx || c->vc_mode != KD_TEXT)
1146 if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2)
1149 vgacon_restore_screen(c);
1150 oldo = c->vc_origin;
1151 delta = lines * c->vc_size_row;
1153 if (c->vc_scr_end + delta >= vga_vram_end) {
1154 scr_memcpyw((u16 *) vga_vram_base,
1155 (u16 *) (oldo + delta),
1156 c->vc_screenbuf_size - delta);
1157 c->vc_origin = vga_vram_base;
1158 vga_rolled_over = oldo - vga_vram_base;
1160 c->vc_origin += delta;
1161 scr_memsetw((u16 *) (c->vc_origin + c->vc_screenbuf_size -
1162 delta), c->vc_video_erase_char,
1165 if (oldo - delta < vga_vram_base) {
1166 scr_memmovew((u16 *) (vga_vram_end -
1167 c->vc_screenbuf_size +
1168 delta), (u16 *) oldo,
1169 c->vc_screenbuf_size - delta);
1170 c->vc_origin = vga_vram_end - c->vc_screenbuf_size;
1171 vga_rolled_over = 0;
1173 c->vc_origin -= delta;
1174 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1175 scr_memsetw((u16 *) (c->vc_origin), c->vc_video_erase_char,
1178 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1179 c->vc_visible_origin = c->vc_origin;
1181 c->vc_pos = (c->vc_pos - oldo) + c->vc_origin;
1186 * The console `switch' structure for the VGA based console
1189 static void vgacon_clear(struct vc_data *vc, int sy, int sx, int height,
1191 static void vgacon_putc(struct vc_data *vc, int c, int ypos, int xpos) { }
1192 static void vgacon_putcs(struct vc_data *vc, const unsigned short *s,
1193 int count, int ypos, int xpos) { }
1195 const struct consw vga_con = {
1196 .owner = THIS_MODULE,
1197 .con_startup = vgacon_startup,
1198 .con_init = vgacon_init,
1199 .con_deinit = vgacon_deinit,
1200 .con_clear = vgacon_clear,
1201 .con_putc = vgacon_putc,
1202 .con_putcs = vgacon_putcs,
1203 .con_cursor = vgacon_cursor,
1204 .con_scroll = vgacon_scroll,
1205 .con_switch = vgacon_switch,
1206 .con_blank = vgacon_blank,
1207 .con_font_set = vgacon_font_set,
1208 .con_font_get = vgacon_font_get,
1209 .con_resize = vgacon_resize,
1210 .con_set_palette = vgacon_set_palette,
1211 .con_scrolldelta = vgacon_scrolldelta,
1212 .con_set_origin = vgacon_set_origin,
1213 .con_save_screen = vgacon_save_screen,
1214 .con_build_attr = vgacon_build_attr,
1215 .con_invert_region = vgacon_invert_region,
1217 EXPORT_SYMBOL(vga_con);
1219 MODULE_LICENSE("GPL");