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 bool vga_font_is_default = true;
94 static int vga_vesa_blanked;
95 static bool vga_palette_blanked;
96 static bool vga_is_gfx;
97 static bool vga_512_chars;
98 static int vga_video_font_height;
99 static int vga_scan_lines __read_mostly;
100 static unsigned int vga_rolled_over;
102 static bool vgacon_text_mode_force;
103 static bool vga_hardscroll_enabled;
104 static bool vga_hardscroll_user_enable = true;
106 bool vgacon_text_force(void)
108 return vgacon_text_mode_force;
110 EXPORT_SYMBOL(vgacon_text_force);
112 static int __init text_mode(char *str)
114 vgacon_text_mode_force = true;
118 /* force text mode - used by kernel modesetting */
119 __setup("nomodeset", text_mode);
121 static int __init no_scroll(char *str)
124 * Disabling scrollback is required for the Braillex ib80-piezo
125 * Braille reader made by F.H. Papenmeier (Germany).
126 * Use the "no-scroll" bootflag.
128 vga_hardscroll_user_enable = vga_hardscroll_enabled = false;
132 __setup("no-scroll", no_scroll);
135 * By replacing the four outb_p with two back to back outw, we can reduce
136 * the window of opportunity to see text mislocated to the RHS of the
137 * console during heavy scrolling activity. However there is the remote
138 * possibility that some pre-dinosaur hardware won't like the back to back
139 * I/O. Since the Xservers get away with it, we should be able to as well.
141 static inline void write_vga(unsigned char reg, unsigned int val)
147 * ddprintk might set the console position from interrupt
148 * handlers, thus the write has to be IRQ-atomic.
150 raw_spin_lock_irqsave(&vga_lock, flags);
151 v1 = reg + (val & 0xff00);
152 v2 = reg + 1 + ((val << 8) & 0xff00);
153 outw(v1, vga_video_port_reg);
154 outw(v2, vga_video_port_reg);
155 raw_spin_unlock_irqrestore(&vga_lock, flags);
158 static inline void vga_set_mem_top(struct vc_data *c)
160 write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
163 #ifdef CONFIG_VGACON_SOFT_SCROLLBACK
164 /* software scrollback */
165 static void *vgacon_scrollback;
166 static int vgacon_scrollback_tail;
167 static int vgacon_scrollback_size;
168 static int vgacon_scrollback_rows;
169 static int vgacon_scrollback_cnt;
170 static int vgacon_scrollback_cur;
171 static int vgacon_scrollback_save;
172 static int vgacon_scrollback_restore;
174 static void vgacon_scrollback_init(int pitch)
176 int rows = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024/pitch;
178 if (vgacon_scrollback) {
179 vgacon_scrollback_cnt = 0;
180 vgacon_scrollback_tail = 0;
181 vgacon_scrollback_cur = 0;
182 vgacon_scrollback_rows = rows - 1;
183 vgacon_scrollback_size = rows * pitch;
187 static void vgacon_scrollback_startup(void)
189 vgacon_scrollback = kcalloc(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE, 1024, GFP_NOWAIT);
190 vgacon_scrollback_init(vga_video_num_columns * 2);
193 static void vgacon_scrollback_update(struct vc_data *c, int t, int count)
197 if (!vgacon_scrollback_size || c->vc_num != fg_console)
200 p = (void *) (c->vc_origin + t * c->vc_size_row);
203 scr_memcpyw(vgacon_scrollback + vgacon_scrollback_tail,
205 vgacon_scrollback_cnt++;
207 vgacon_scrollback_tail += c->vc_size_row;
209 if (vgacon_scrollback_tail >= vgacon_scrollback_size)
210 vgacon_scrollback_tail = 0;
212 if (vgacon_scrollback_cnt > vgacon_scrollback_rows)
213 vgacon_scrollback_cnt = vgacon_scrollback_rows;
215 vgacon_scrollback_cur = vgacon_scrollback_cnt;
219 static void vgacon_restore_screen(struct vc_data *c)
221 vgacon_scrollback_save = 0;
223 if (!vga_is_gfx && !vgacon_scrollback_restore) {
224 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
225 c->vc_screenbuf_size > vga_vram_size ?
226 vga_vram_size : c->vc_screenbuf_size);
227 vgacon_scrollback_restore = 1;
228 vgacon_scrollback_cur = vgacon_scrollback_cnt;
232 static void vgacon_scrolldelta(struct vc_data *c, int lines)
234 int start, end, count, soff;
237 c->vc_visible_origin = c->vc_origin;
242 if (!vgacon_scrollback)
245 if (!vgacon_scrollback_save) {
246 vgacon_cursor(c, CM_ERASE);
247 vgacon_save_screen(c);
248 vgacon_scrollback_save = 1;
251 vgacon_scrollback_restore = 0;
252 start = vgacon_scrollback_cur + lines;
253 end = start + abs(lines);
258 if (start > vgacon_scrollback_cnt)
259 start = vgacon_scrollback_cnt;
264 if (end > vgacon_scrollback_cnt)
265 end = vgacon_scrollback_cnt;
267 vgacon_scrollback_cur = start;
269 soff = vgacon_scrollback_tail - ((vgacon_scrollback_cnt - end) *
271 soff -= count * c->vc_size_row;
274 soff += vgacon_scrollback_size;
276 count = vgacon_scrollback_cnt - start;
278 if (count > c->vc_rows)
284 int diff = c->vc_rows - count;
285 void *d = (void *) c->vc_origin;
286 void *s = (void *) c->vc_screenbuf;
288 count *= c->vc_size_row;
289 /* how much memory to end of buffer left? */
290 copysize = min(count, vgacon_scrollback_size - soff);
291 scr_memcpyw(d, vgacon_scrollback + soff, copysize);
296 scr_memcpyw(d, vgacon_scrollback, count);
301 scr_memcpyw(d, s, diff * c->vc_size_row);
303 vgacon_cursor(c, CM_MOVE);
306 #define vgacon_scrollback_startup(...) do { } while (0)
307 #define vgacon_scrollback_init(...) do { } while (0)
308 #define vgacon_scrollback_update(...) do { } while (0)
310 static void vgacon_restore_screen(struct vc_data *c)
312 if (c->vc_origin != c->vc_visible_origin)
313 vgacon_scrolldelta(c, 0);
316 static void vgacon_scrolldelta(struct vc_data *c, int lines)
318 vc_scrolldelta_helper(c, lines, vga_rolled_over, (void *)vga_vram_base,
322 #endif /* CONFIG_VGACON_SOFT_SCROLLBACK */
324 static const char *vgacon_startup(void)
326 const char *display_desc = NULL;
330 if (screen_info.orig_video_isVGA == VIDEO_TYPE_VLFB ||
331 screen_info.orig_video_isVGA == VIDEO_TYPE_EFI) {
333 #ifdef CONFIG_DUMMY_CONSOLE
334 conswitchp = &dummy_con;
335 return conswitchp->con_startup();
341 /* boot_params.screen_info initialized? */
342 if ((screen_info.orig_video_mode == 0) &&
343 (screen_info.orig_video_lines == 0) &&
344 (screen_info.orig_video_cols == 0))
347 /* VGA16 modes are not handled by VGACON */
348 if ((screen_info.orig_video_mode == 0x0D) || /* 320x200/4 */
349 (screen_info.orig_video_mode == 0x0E) || /* 640x200/4 */
350 (screen_info.orig_video_mode == 0x10) || /* 640x350/4 */
351 (screen_info.orig_video_mode == 0x12) || /* 640x480/4 */
352 (screen_info.orig_video_mode == 0x6A)) /* 800x600/4 (VESA) */
355 vga_video_num_lines = screen_info.orig_video_lines;
356 vga_video_num_columns = screen_info.orig_video_cols;
357 vgastate.vgabase = NULL;
359 if (screen_info.orig_video_mode == 7) {
360 /* Monochrome display */
361 vga_vram_base = 0xb0000;
362 vga_video_port_reg = VGA_CRT_IM;
363 vga_video_port_val = VGA_CRT_DM;
364 if ((screen_info.orig_video_ega_bx & 0xff) != 0x10) {
365 static struct resource ega_console_resource =
366 { .name = "ega", .start = 0x3B0, .end = 0x3BF };
367 vga_video_type = VIDEO_TYPE_EGAM;
368 vga_vram_size = 0x8000;
369 display_desc = "EGA+";
370 request_resource(&ioport_resource,
371 &ega_console_resource);
373 static struct resource mda1_console_resource =
374 { .name = "mda", .start = 0x3B0, .end = 0x3BB };
375 static struct resource mda2_console_resource =
376 { .name = "mda", .start = 0x3BF, .end = 0x3BF };
377 vga_video_type = VIDEO_TYPE_MDA;
378 vga_vram_size = 0x2000;
379 display_desc = "*MDA";
380 request_resource(&ioport_resource,
381 &mda1_console_resource);
382 request_resource(&ioport_resource,
383 &mda2_console_resource);
384 vga_video_font_height = 14;
387 /* If not, it is color. */
388 vga_can_do_color = true;
389 vga_vram_base = 0xb8000;
390 vga_video_port_reg = VGA_CRT_IC;
391 vga_video_port_val = VGA_CRT_DC;
392 if ((screen_info.orig_video_ega_bx & 0xff) != 0x10) {
395 vga_vram_size = 0x8000;
397 if (!screen_info.orig_video_isVGA) {
398 static struct resource ega_console_resource
399 = { .name = "ega", .start = 0x3C0, .end = 0x3DF };
400 vga_video_type = VIDEO_TYPE_EGAC;
401 display_desc = "EGA";
402 request_resource(&ioport_resource,
403 &ega_console_resource);
405 static struct resource vga_console_resource
406 = { .name = "vga+", .start = 0x3C0, .end = 0x3DF };
407 vga_video_type = VIDEO_TYPE_VGAC;
408 display_desc = "VGA+";
409 request_resource(&ioport_resource,
410 &vga_console_resource);
413 * Normalise the palette registers, to point
414 * the 16 screen colours to the first 16
418 for (i = 0; i < 16; i++) {
420 outb_p(i, VGA_ATT_W);
421 outb_p(i, VGA_ATT_W);
423 outb_p(0x20, VGA_ATT_W);
426 * Now set the DAC registers back to their
429 for (i = 0; i < 16; i++) {
430 outb_p(color_table[i], VGA_PEL_IW);
431 outb_p(default_red[i], VGA_PEL_D);
432 outb_p(default_grn[i], VGA_PEL_D);
433 outb_p(default_blu[i], VGA_PEL_D);
437 static struct resource cga_console_resource =
438 { .name = "cga", .start = 0x3D4, .end = 0x3D5 };
439 vga_video_type = VIDEO_TYPE_CGA;
440 vga_vram_size = 0x2000;
441 display_desc = "*CGA";
442 request_resource(&ioport_resource,
443 &cga_console_resource);
444 vga_video_font_height = 8;
448 vga_vram_base = VGA_MAP_MEM(vga_vram_base, vga_vram_size);
449 vga_vram_end = vga_vram_base + vga_vram_size;
452 * Find out if there is a graphics card present.
453 * Are there smarter methods around?
455 p = (volatile u16 *) vga_vram_base;
456 saved1 = scr_readw(p);
457 saved2 = scr_readw(p + 1);
458 scr_writew(0xAA55, p);
459 scr_writew(0x55AA, p + 1);
460 if (scr_readw(p) != 0xAA55 || scr_readw(p + 1) != 0x55AA) {
461 scr_writew(saved1, p);
462 scr_writew(saved2, p + 1);
465 scr_writew(0x55AA, p);
466 scr_writew(0xAA55, p + 1);
467 if (scr_readw(p) != 0x55AA || scr_readw(p + 1) != 0xAA55) {
468 scr_writew(saved1, p);
469 scr_writew(saved2, p + 1);
472 scr_writew(saved1, p);
473 scr_writew(saved2, p + 1);
475 if (vga_video_type == VIDEO_TYPE_EGAC
476 || vga_video_type == VIDEO_TYPE_VGAC
477 || vga_video_type == VIDEO_TYPE_EGAM) {
478 vga_hardscroll_enabled = vga_hardscroll_user_enable;
479 vga_default_font_height = screen_info.orig_video_points;
480 vga_video_font_height = screen_info.orig_video_points;
481 /* This may be suboptimal but is a safe bet - go with it */
483 vga_video_font_height * vga_video_num_lines;
486 vgacon_xres = screen_info.orig_video_cols * VGA_FONTWIDTH;
487 vgacon_yres = vga_scan_lines;
489 if (!vga_init_done) {
490 vgacon_scrollback_startup();
491 vga_init_done = true;
497 static void vgacon_init(struct vc_data *c, int init)
499 struct uni_pagedir *p;
502 * We cannot be loaded as a module, therefore init is always 1,
503 * but vgacon_init can be called more than once, and init will
506 c->vc_can_do_color = vga_can_do_color;
508 /* set dimensions manually if init != 0 since vc_resize() will fail */
510 c->vc_cols = vga_video_num_columns;
511 c->vc_rows = vga_video_num_lines;
513 vc_resize(c, vga_video_num_columns, vga_video_num_lines);
515 c->vc_scan_lines = vga_scan_lines;
516 c->vc_font.height = vga_video_font_height;
517 c->vc_complement_mask = 0x7700;
519 c->vc_hi_font_mask = 0x0800;
520 p = *c->vc_uni_pagedir_loc;
521 if (c->vc_uni_pagedir_loc != &vgacon_uni_pagedir) {
523 c->vc_uni_pagedir_loc = &vgacon_uni_pagedir;
526 if (!vgacon_uni_pagedir && p)
527 con_set_default_unimap(c);
529 /* Only set the default if the user didn't deliberately override it */
530 if (global_cursor_default == -1)
531 global_cursor_default =
532 !(screen_info.flags & VIDEO_FLAGS_NOCURSOR);
535 static void vgacon_deinit(struct vc_data *c)
537 /* When closing the active console, reset video origin */
538 if (con_is_visible(c)) {
539 c->vc_visible_origin = vga_vram_base;
543 if (!--vgacon_refcount)
545 c->vc_uni_pagedir_loc = &c->vc_uni_pagedir;
546 con_set_default_unimap(c);
549 static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
550 u8 blink, u8 underline, u8 reverse, u8 italic)
554 if (vga_can_do_color) {
556 attr = (attr & 0xF0) | c->vc_itcolor;
558 attr = (attr & 0xf0) | c->vc_ulcolor;
559 else if (intensity == 0)
560 attr = (attr & 0xf0) | c->vc_halfcolor;
564 ((attr) & 0x88) | ((((attr) >> 4) | ((attr) << 4)) &
570 if (!vga_can_do_color) {
572 attr = (attr & 0xF8) | 0x02;
574 attr = (attr & 0xf8) | 0x01;
575 else if (intensity == 0)
576 attr = (attr & 0xf0) | 0x08;
581 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count)
583 const bool col = vga_can_do_color;
586 u16 a = scr_readw(p);
588 a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) |
589 (((a) & 0x0700) << 4);
591 a ^= ((a & 0x0700) == 0x0100) ? 0x7000 : 0x7700;
596 static void vgacon_set_cursor_size(int xpos, int from, int to)
601 if ((from == cursor_size_lastfrom) && (to == cursor_size_lastto))
603 cursor_size_lastfrom = from;
604 cursor_size_lastto = to;
606 raw_spin_lock_irqsave(&vga_lock, flags);
607 if (vga_video_type >= VIDEO_TYPE_VGAC) {
608 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
609 curs = inb_p(vga_video_port_val);
610 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
611 cure = inb_p(vga_video_port_val);
617 curs = (curs & 0xc0) | from;
618 cure = (cure & 0xe0) | to;
620 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
621 outb_p(curs, vga_video_port_val);
622 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
623 outb_p(cure, vga_video_port_val);
624 raw_spin_unlock_irqrestore(&vga_lock, flags);
627 static void vgacon_cursor(struct vc_data *c, int mode)
629 if (c->vc_mode != KD_TEXT)
632 vgacon_restore_screen(c);
636 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
637 if (vga_video_type >= VIDEO_TYPE_VGAC)
638 vgacon_set_cursor_size(c->vc_x, 31, 30);
640 vgacon_set_cursor_size(c->vc_x, 31, 31);
645 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
646 switch (c->vc_cursor_type & 0x0f) {
648 vgacon_set_cursor_size(c->vc_x,
657 vgacon_set_cursor_size(c->vc_x,
658 c->vc_font.height / 3,
663 case CUR_LOWER_THIRD:
664 vgacon_set_cursor_size(c->vc_x,
665 (c->vc_font.height * 2) / 3,
671 vgacon_set_cursor_size(c->vc_x,
672 c->vc_font.height / 2,
678 if (vga_video_type >= VIDEO_TYPE_VGAC)
679 vgacon_set_cursor_size(c->vc_x, 31, 30);
681 vgacon_set_cursor_size(c->vc_x, 31, 31);
684 vgacon_set_cursor_size(c->vc_x, 1,
692 static int vgacon_doresize(struct vc_data *c,
693 unsigned int width, unsigned int height)
696 unsigned int scanlines = height * c->vc_font.height;
697 u8 scanlines_lo = 0, r7 = 0, vsync_end = 0, mode, max_scan;
699 raw_spin_lock_irqsave(&vga_lock, flags);
701 vgacon_xres = width * VGA_FONTWIDTH;
702 vgacon_yres = height * c->vc_font.height;
703 if (vga_video_type >= VIDEO_TYPE_VGAC) {
704 outb_p(VGA_CRTC_MAX_SCAN, vga_video_port_reg);
705 max_scan = inb_p(vga_video_port_val);
710 outb_p(VGA_CRTC_MODE, vga_video_port_reg);
711 mode = inb_p(vga_video_port_val);
717 scanlines_lo = scanlines & 0xff;
719 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
720 r7 = inb_p(vga_video_port_val) & ~0x42;
722 if (scanlines & 0x100)
724 if (scanlines & 0x200)
727 /* deprotect registers */
728 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
729 vsync_end = inb_p(vga_video_port_val);
730 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
731 outb_p(vsync_end & ~0x80, vga_video_port_val);
734 outb_p(VGA_CRTC_H_DISP, vga_video_port_reg);
735 outb_p(width - 1, vga_video_port_val);
736 outb_p(VGA_CRTC_OFFSET, vga_video_port_reg);
737 outb_p(width >> 1, vga_video_port_val);
739 if (vga_video_type >= VIDEO_TYPE_VGAC) {
740 outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg);
741 outb_p(scanlines_lo, vga_video_port_val);
742 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
743 outb_p(r7,vga_video_port_val);
745 /* reprotect registers */
746 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
747 outb_p(vsync_end, vga_video_port_val);
750 raw_spin_unlock_irqrestore(&vga_lock, flags);
754 static int vgacon_switch(struct vc_data *c)
756 int x = c->vc_cols * VGA_FONTWIDTH;
757 int y = c->vc_rows * c->vc_font.height;
758 int rows = screen_info.orig_video_lines * vga_default_font_height/
761 * We need to save screen size here as it's the only way
762 * we can spot the screen has been resized and we need to
763 * set size of freshly allocated screens ourselves.
765 vga_video_num_columns = c->vc_cols;
766 vga_video_num_lines = c->vc_rows;
768 /* We can only copy out the size of the video buffer here,
769 * otherwise we get into VGA BIOS */
772 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
773 c->vc_screenbuf_size > vga_vram_size ?
774 vga_vram_size : c->vc_screenbuf_size);
776 if ((vgacon_xres != x || vgacon_yres != y) &&
777 (!(vga_video_num_columns % 2) &&
778 vga_video_num_columns <= screen_info.orig_video_cols &&
779 vga_video_num_lines <= rows))
780 vgacon_doresize(c, c->vc_cols, c->vc_rows);
783 vgacon_scrollback_init(c->vc_size_row);
784 return 0; /* Redrawing not needed */
787 static void vga_set_palette(struct vc_data *vc, const unsigned char *table)
791 vga_w(vgastate.vgabase, VGA_PEL_MSK, 0xff);
792 for (i = j = 0; i < 16; i++) {
793 vga_w(vgastate.vgabase, VGA_PEL_IW, table[i]);
794 vga_w(vgastate.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
795 vga_w(vgastate.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
796 vga_w(vgastate.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
800 static void vgacon_set_palette(struct vc_data *vc, const unsigned char *table)
802 if (vga_video_type != VIDEO_TYPE_VGAC || vga_palette_blanked
803 || !con_is_visible(vc))
805 vga_set_palette(vc, table);
808 /* structure holding original VGA register settings */
810 unsigned char SeqCtrlIndex; /* Sequencer Index reg. */
811 unsigned char CrtCtrlIndex; /* CRT-Contr. Index reg. */
812 unsigned char CrtMiscIO; /* Miscellaneous register */
813 unsigned char HorizontalTotal; /* CRT-Controller:00h */
814 unsigned char HorizDisplayEnd; /* CRT-Controller:01h */
815 unsigned char StartHorizRetrace; /* CRT-Controller:04h */
816 unsigned char EndHorizRetrace; /* CRT-Controller:05h */
817 unsigned char Overflow; /* CRT-Controller:07h */
818 unsigned char StartVertRetrace; /* CRT-Controller:10h */
819 unsigned char EndVertRetrace; /* CRT-Controller:11h */
820 unsigned char ModeControl; /* CRT-Controller:17h */
821 unsigned char ClockingMode; /* Seq-Controller:01h */
824 static void vga_vesa_blank(struct vgastate *state, int mode)
826 /* save original values of VGA controller registers */
827 if (!vga_vesa_blanked) {
828 raw_spin_lock_irq(&vga_lock);
829 vga_state.SeqCtrlIndex = vga_r(state->vgabase, VGA_SEQ_I);
830 vga_state.CrtCtrlIndex = inb_p(vga_video_port_reg);
831 vga_state.CrtMiscIO = vga_r(state->vgabase, VGA_MIS_R);
832 raw_spin_unlock_irq(&vga_lock);
834 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */
835 vga_state.HorizontalTotal = inb_p(vga_video_port_val);
836 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */
837 vga_state.HorizDisplayEnd = inb_p(vga_video_port_val);
838 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
839 vga_state.StartHorizRetrace = inb_p(vga_video_port_val);
840 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
841 vga_state.EndHorizRetrace = inb_p(vga_video_port_val);
842 outb_p(0x07, vga_video_port_reg); /* Overflow */
843 vga_state.Overflow = inb_p(vga_video_port_val);
844 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
845 vga_state.StartVertRetrace = inb_p(vga_video_port_val);
846 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
847 vga_state.EndVertRetrace = inb_p(vga_video_port_val);
848 outb_p(0x17, vga_video_port_reg); /* ModeControl */
849 vga_state.ModeControl = inb_p(vga_video_port_val);
850 vga_state.ClockingMode = vga_rseq(state->vgabase, VGA_SEQ_CLOCK_MODE);
853 /* assure that video is enabled */
854 /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */
855 raw_spin_lock_irq(&vga_lock);
856 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode | 0x20);
858 /* test for vertical retrace in process.... */
859 if ((vga_state.CrtMiscIO & 0x80) == 0x80)
860 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO & 0xEF);
863 * Set <End of vertical retrace> to minimum (0) and
864 * <Start of vertical Retrace> to maximum (incl. overflow)
865 * Result: turn off vertical sync (VSync) pulse.
867 if (mode & VESA_VSYNC_SUSPEND) {
868 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
869 outb_p(0xff, vga_video_port_val); /* maximum value */
870 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
871 outb_p(0x40, vga_video_port_val); /* minimum (bits 0..3) */
872 outb_p(0x07, vga_video_port_reg); /* Overflow */
873 outb_p(vga_state.Overflow | 0x84, vga_video_port_val); /* bits 9,10 of vert. retrace */
876 if (mode & VESA_HSYNC_SUSPEND) {
878 * Set <End of horizontal retrace> to minimum (0) and
879 * <Start of horizontal Retrace> to maximum
880 * Result: turn off horizontal sync (HSync) pulse.
882 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
883 outb_p(0xff, vga_video_port_val); /* maximum */
884 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
885 outb_p(0x00, vga_video_port_val); /* minimum (0) */
888 /* restore both index registers */
889 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
890 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
891 raw_spin_unlock_irq(&vga_lock);
894 static void vga_vesa_unblank(struct vgastate *state)
896 /* restore original values of VGA controller registers */
897 raw_spin_lock_irq(&vga_lock);
898 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO);
900 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */
901 outb_p(vga_state.HorizontalTotal, vga_video_port_val);
902 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */
903 outb_p(vga_state.HorizDisplayEnd, vga_video_port_val);
904 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
905 outb_p(vga_state.StartHorizRetrace, vga_video_port_val);
906 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
907 outb_p(vga_state.EndHorizRetrace, vga_video_port_val);
908 outb_p(0x07, vga_video_port_reg); /* Overflow */
909 outb_p(vga_state.Overflow, vga_video_port_val);
910 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
911 outb_p(vga_state.StartVertRetrace, vga_video_port_val);
912 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
913 outb_p(vga_state.EndVertRetrace, vga_video_port_val);
914 outb_p(0x17, vga_video_port_reg); /* ModeControl */
915 outb_p(vga_state.ModeControl, vga_video_port_val);
917 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode);
919 /* restore index/control registers */
920 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
921 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
922 raw_spin_unlock_irq(&vga_lock);
925 static void vga_pal_blank(struct vgastate *state)
929 vga_w(state->vgabase, VGA_PEL_MSK, 0xff);
930 for (i = 0; i < 16; i++) {
931 vga_w(state->vgabase, VGA_PEL_IW, i);
932 vga_w(state->vgabase, VGA_PEL_D, 0);
933 vga_w(state->vgabase, VGA_PEL_D, 0);
934 vga_w(state->vgabase, VGA_PEL_D, 0);
938 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch)
941 case 0: /* Unblank */
942 if (vga_vesa_blanked) {
943 vga_vesa_unblank(&vgastate);
944 vga_vesa_blanked = 0;
946 if (vga_palette_blanked) {
947 vga_set_palette(c, color_table);
948 vga_palette_blanked = false;
952 /* Tell console.c that it has to restore the screen itself */
954 case 1: /* Normal blanking */
955 case -1: /* Obsolete */
956 if (!mode_switch && vga_video_type == VIDEO_TYPE_VGAC) {
957 vga_pal_blank(&vgastate);
958 vga_palette_blanked = true;
961 vgacon_set_origin(c);
962 scr_memsetw((void *) vga_vram_base, BLANK,
963 c->vc_screenbuf_size);
967 default: /* VESA blanking */
968 if (vga_video_type == VIDEO_TYPE_VGAC) {
969 vga_vesa_blank(&vgastate, blank - 1);
970 vga_vesa_blanked = blank;
979 * The font loading code goes back to the codepage package by
980 * Joel Hoffman (joel@wam.umd.edu). (He reports that the original
981 * reference is: "From: p. 307 of _Programmer's Guide to PC & PS/2
982 * Video Systems_ by Richard Wilton. 1987. Microsoft Press".)
984 * Change for certain monochrome monitors by Yury Shevchuck
985 * (sizif@botik.yaroslavl.su).
988 #define colourmap 0xa0000
989 /* Pauline Middelink <middelin@polyware.iaf.nl> reports that we
990 should use 0xA0000 for the bwmap as well.. */
991 #define blackwmap 0xa0000
994 static int vgacon_do_font_op(struct vgastate *state, char *arg, int set,
997 unsigned short video_port_status = vga_video_port_reg + 6;
998 int font_select = 0x00, beg, i;
1000 bool clear_attribs = false;
1001 if (vga_video_type != VIDEO_TYPE_EGAM) {
1002 charmap = (char *) VGA_MAP_MEM(colourmap, 0);
1005 charmap = (char *) VGA_MAP_MEM(blackwmap, 0);
1009 #ifdef BROKEN_GRAPHICS_PROGRAMS
1011 * All fonts are loaded in slot 0 (0:1 for 512 ch)
1015 return -EINVAL; /* Return to default font not supported */
1017 vga_font_is_default = false;
1018 font_select = ch512 ? 0x04 : 0x00;
1021 * The default font is kept in slot 0 and is never touched.
1022 * A custom font is loaded in slot 2 (256 ch) or 2:3 (512 ch)
1026 vga_font_is_default = !arg;
1028 ch512 = false; /* Default font is always 256 */
1029 font_select = arg ? (ch512 ? 0x0e : 0x0a) : 0x00;
1032 if (!vga_font_is_default)
1033 charmap += 4 * cmapsz;
1036 raw_spin_lock_irq(&vga_lock);
1037 /* First, the Sequencer */
1038 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1);
1039 /* CPU writes only to map 2 */
1040 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x04);
1041 /* Sequential addressing */
1042 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x07);
1043 /* Clear synchronous reset */
1044 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
1046 /* Now, the graphics controller, select map 2 */
1047 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x02);
1048 /* disable odd-even addressing */
1049 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x00);
1050 /* map start at A000:0000 */
1051 vga_wgfx(state->vgabase, VGA_GFX_MISC, 0x00);
1052 raw_spin_unlock_irq(&vga_lock);
1056 for (i = 0; i < cmapsz; i++) {
1057 vga_writeb(arg[i], charmap + i);
1061 for (i = 0; i < cmapsz; i++) {
1062 arg[i] = vga_readb(charmap + i);
1067 * In 512-character mode, the character map is not contiguous if
1068 * we want to remain EGA compatible -- which we do
1072 charmap += 2 * cmapsz;
1075 for (i = 0; i < cmapsz; i++) {
1076 vga_writeb(arg[i], charmap + i);
1080 for (i = 0; i < cmapsz; i++) {
1081 arg[i] = vga_readb(charmap + i);
1087 raw_spin_lock_irq(&vga_lock);
1088 /* First, the sequencer, Synchronous reset */
1089 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x01);
1090 /* CPU writes to maps 0 and 1 */
1091 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x03);
1092 /* odd-even addressing */
1093 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x03);
1094 /* Character Map Select */
1096 vga_wseq(state->vgabase, VGA_SEQ_CHARACTER_MAP, font_select);
1097 /* clear synchronous reset */
1098 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
1100 /* Now, the graphics controller, select map 0 for CPU */
1101 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x00);
1102 /* enable even-odd addressing */
1103 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x10);
1104 /* map starts at b800:0 or b000:0 */
1105 vga_wgfx(state->vgabase, VGA_GFX_MISC, beg);
1107 /* if 512 char mode is already enabled don't re-enable it. */
1108 if ((set) && (ch512 != vga_512_chars)) {
1109 vga_512_chars = ch512;
1110 /* 256-char: enable intensity bit
1111 512-char: disable intensity bit */
1112 inb_p(video_port_status); /* clear address flip-flop */
1113 /* color plane enable register */
1114 vga_wattr(state->vgabase, VGA_ATC_PLANE_ENABLE, ch512 ? 0x07 : 0x0f);
1115 /* Wilton (1987) mentions the following; I don't know what
1116 it means, but it works, and it appears necessary */
1117 inb_p(video_port_status);
1118 vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0);
1119 clear_attribs = true;
1121 raw_spin_unlock_irq(&vga_lock);
1123 if (clear_attribs) {
1124 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1125 struct vc_data *c = vc_cons[i].d;
1126 if (c && c->vc_sw == &vga_con) {
1127 /* force hi font mask to 0, so we always clear
1128 the bit on either transition */
1129 c->vc_hi_font_mask = 0x00;
1130 clear_buffer_attributes(c);
1131 c->vc_hi_font_mask = ch512 ? 0x0800 : 0;
1139 * Adjust the screen to fit a font of a certain height
1141 static int vgacon_adjust_height(struct vc_data *vc, unsigned fontheight)
1143 unsigned char ovr, vde, fsr;
1144 int rows, maxscan, i;
1146 rows = vc->vc_scan_lines / fontheight; /* Number of video rows we end up with */
1147 maxscan = rows * fontheight - 1; /* Scan lines to actually display-1 */
1149 /* Reprogram the CRTC for the new font size
1150 Note: the attempt to read the overflow register will fail
1151 on an EGA, but using 0xff for the previous value appears to
1152 be OK for EGA text modes in the range 257-512 scan lines, so I
1153 guess we don't need to worry about it.
1155 The same applies for the spill bits in the font size and cursor
1156 registers; they are write-only on EGA, but it appears that they
1157 are all don't care bits on EGA, so I guess it doesn't matter. */
1159 raw_spin_lock_irq(&vga_lock);
1160 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */
1161 ovr = inb_p(vga_video_port_val);
1162 outb_p(0x09, vga_video_port_reg); /* Font size register */
1163 fsr = inb_p(vga_video_port_val);
1164 raw_spin_unlock_irq(&vga_lock);
1166 vde = maxscan & 0xff; /* Vertical display end reg */
1167 ovr = (ovr & 0xbd) + /* Overflow register */
1168 ((maxscan & 0x100) >> 7) + ((maxscan & 0x200) >> 3);
1169 fsr = (fsr & 0xe0) + (fontheight - 1); /* Font size register */
1171 raw_spin_lock_irq(&vga_lock);
1172 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */
1173 outb_p(ovr, vga_video_port_val);
1174 outb_p(0x09, vga_video_port_reg); /* Font size */
1175 outb_p(fsr, vga_video_port_val);
1176 outb_p(0x12, vga_video_port_reg); /* Vertical display limit */
1177 outb_p(vde, vga_video_port_val);
1178 raw_spin_unlock_irq(&vga_lock);
1179 vga_video_font_height = fontheight;
1181 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1182 struct vc_data *c = vc_cons[i].d;
1184 if (c && c->vc_sw == &vga_con) {
1185 if (con_is_visible(c)) {
1186 /* void size to cause regs to be rewritten */
1187 cursor_size_lastfrom = 0;
1188 cursor_size_lastto = 0;
1189 c->vc_sw->con_cursor(c, CM_DRAW);
1191 c->vc_font.height = fontheight;
1192 vc_resize(c, 0, rows); /* Adjust console size */
1198 static int vgacon_font_set(struct vc_data *c, struct console_font *font, unsigned flags)
1200 unsigned charcount = font->charcount;
1203 if (vga_video_type < VIDEO_TYPE_EGAM)
1206 if (font->width != VGA_FONTWIDTH ||
1207 (charcount != 256 && charcount != 512))
1210 rc = vgacon_do_font_op(&vgastate, font->data, 1, charcount == 512);
1214 if (!(flags & KD_FONT_FLAG_DONT_RECALC))
1215 rc = vgacon_adjust_height(c, font->height);
1219 static int vgacon_font_get(struct vc_data *c, struct console_font *font)
1221 if (vga_video_type < VIDEO_TYPE_EGAM)
1224 font->width = VGA_FONTWIDTH;
1225 font->height = c->vc_font.height;
1226 font->charcount = vga_512_chars ? 512 : 256;
1229 return vgacon_do_font_op(&vgastate, font->data, 0, vga_512_chars);
1232 static int vgacon_resize(struct vc_data *c, unsigned int width,
1233 unsigned int height, unsigned int user)
1235 if (width % 2 || width > screen_info.orig_video_cols ||
1236 height > (screen_info.orig_video_lines * vga_default_font_height)/
1238 /* let svgatextmode tinker with video timings and
1240 return (user) ? 0 : -EINVAL;
1242 if (con_is_visible(c) && !vga_is_gfx) /* who knows */
1243 vgacon_doresize(c, width, height);
1247 static int vgacon_set_origin(struct vc_data *c)
1249 if (vga_is_gfx || /* We don't play origin tricks in graphic modes */
1250 (console_blanked && !vga_palette_blanked)) /* Nor we write to blanked screens */
1252 c->vc_origin = c->vc_visible_origin = vga_vram_base;
1254 vga_rolled_over = 0;
1258 static void vgacon_save_screen(struct vc_data *c)
1260 static int vga_bootup_console = 0;
1262 if (!vga_bootup_console) {
1263 /* This is a gross hack, but here is the only place we can
1264 * set bootup console parameters without messing up generic
1265 * console initialization routines.
1267 vga_bootup_console = 1;
1268 c->vc_x = screen_info.orig_x;
1269 c->vc_y = screen_info.orig_y;
1272 /* We can't copy in more than the size of the video buffer,
1273 * or we'll be copying in VGA BIOS */
1276 scr_memcpyw((u16 *) c->vc_screenbuf, (u16 *) c->vc_origin,
1277 c->vc_screenbuf_size > vga_vram_size ? vga_vram_size : c->vc_screenbuf_size);
1280 static bool vgacon_scroll(struct vc_data *c, unsigned int t, unsigned int b,
1281 enum con_scroll dir, unsigned int lines)
1286 if (t || b != c->vc_rows || vga_is_gfx || c->vc_mode != KD_TEXT)
1289 if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2)
1292 vgacon_restore_screen(c);
1293 oldo = c->vc_origin;
1294 delta = lines * c->vc_size_row;
1296 vgacon_scrollback_update(c, t, lines);
1297 if (c->vc_scr_end + delta >= vga_vram_end) {
1298 scr_memcpyw((u16 *) vga_vram_base,
1299 (u16 *) (oldo + delta),
1300 c->vc_screenbuf_size - delta);
1301 c->vc_origin = vga_vram_base;
1302 vga_rolled_over = oldo - vga_vram_base;
1304 c->vc_origin += delta;
1305 scr_memsetw((u16 *) (c->vc_origin + c->vc_screenbuf_size -
1306 delta), c->vc_video_erase_char,
1309 if (oldo - delta < vga_vram_base) {
1310 scr_memmovew((u16 *) (vga_vram_end -
1311 c->vc_screenbuf_size +
1312 delta), (u16 *) oldo,
1313 c->vc_screenbuf_size - delta);
1314 c->vc_origin = vga_vram_end - c->vc_screenbuf_size;
1315 vga_rolled_over = 0;
1317 c->vc_origin -= delta;
1318 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1319 scr_memsetw((u16 *) (c->vc_origin), c->vc_video_erase_char,
1322 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1323 c->vc_visible_origin = c->vc_origin;
1325 c->vc_pos = (c->vc_pos - oldo) + c->vc_origin;
1331 * The console `switch' structure for the VGA based console
1334 static int vgacon_dummy(struct vc_data *c)
1339 #define DUMMY (void *) vgacon_dummy
1341 const struct consw vga_con = {
1342 .owner = THIS_MODULE,
1343 .con_startup = vgacon_startup,
1344 .con_init = vgacon_init,
1345 .con_deinit = vgacon_deinit,
1349 .con_cursor = vgacon_cursor,
1350 .con_scroll = vgacon_scroll,
1351 .con_switch = vgacon_switch,
1352 .con_blank = vgacon_blank,
1353 .con_font_set = vgacon_font_set,
1354 .con_font_get = vgacon_font_get,
1355 .con_resize = vgacon_resize,
1356 .con_set_palette = vgacon_set_palette,
1357 .con_scrolldelta = vgacon_scrolldelta,
1358 .con_set_origin = vgacon_set_origin,
1359 .con_save_screen = vgacon_save_screen,
1360 .con_build_attr = vgacon_build_attr,
1361 .con_invert_region = vgacon_invert_region,
1363 EXPORT_SYMBOL(vga_con);
1365 MODULE_LICENSE("GPL");