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 u8
vgacon_build_attr(struct vc_data
*c
, u8 color
, u8 intensity
,
90 u8 blink
, u8 underline
, u8 reverse
, u8
);
91 static void vgacon_invert_region(struct vc_data
*c
, u16
* p
, int count
);
92 static unsigned long vgacon_uni_pagedir
[2];
94 /* Description of the hardware situation */
95 static int vga_init_done __read_mostly
;
96 static unsigned long vga_vram_base __read_mostly
; /* Base of video memory */
97 static unsigned long vga_vram_end __read_mostly
; /* End of video memory */
98 static unsigned int vga_vram_size __read_mostly
; /* Size of video memory */
99 static u16 vga_video_port_reg __read_mostly
; /* Video register select port */
100 static u16 vga_video_port_val __read_mostly
; /* Video register value port */
101 static unsigned int vga_video_num_columns
; /* Number of text columns */
102 static unsigned int vga_video_num_lines
; /* Number of text lines */
103 static int vga_can_do_color __read_mostly
; /* Do we support colors? */
104 static unsigned int vga_default_font_height __read_mostly
; /* Height of default screen font */
105 static unsigned char vga_video_type __read_mostly
; /* Card type */
106 static unsigned char vga_hardscroll_enabled __read_mostly
;
107 static unsigned char vga_hardscroll_user_enable __read_mostly
= 1;
108 static unsigned char vga_font_is_default
= 1;
109 static int vga_vesa_blanked
;
110 static int vga_palette_blanked
;
111 static int vga_is_gfx
;
112 static int vga_512_chars
;
113 static int vga_video_font_height
;
114 static int vga_scan_lines __read_mostly
;
115 static unsigned int vga_rolled_over
;
117 static int __init
no_scroll(char *str
)
120 * Disabling scrollback is required for the Braillex ib80-piezo
121 * Braille reader made by F.H. Papenmeier (Germany).
122 * Use the "no-scroll" bootflag.
124 vga_hardscroll_user_enable
= vga_hardscroll_enabled
= 0;
128 __setup("no-scroll", no_scroll
);
131 * By replacing the four outb_p with two back to back outw, we can reduce
132 * the window of opportunity to see text mislocated to the RHS of the
133 * console during heavy scrolling activity. However there is the remote
134 * possibility that some pre-dinosaur hardware won't like the back to back
135 * I/O. Since the Xservers get away with it, we should be able to as well.
137 static inline void write_vga(unsigned char reg
, unsigned int val
)
143 * ddprintk might set the console position from interrupt
144 * handlers, thus the write has to be IRQ-atomic.
146 spin_lock_irqsave(&vga_lock
, flags
);
149 v1
= reg
+ (val
& 0xff00);
150 v2
= reg
+ 1 + ((val
<< 8) & 0xff00);
151 outw(v1
, vga_video_port_reg
);
152 outw(v2
, vga_video_port_reg
);
154 outb_p(reg
, vga_video_port_reg
);
155 outb_p(val
>> 8, vga_video_port_val
);
156 outb_p(reg
+ 1, vga_video_port_reg
);
157 outb_p(val
& 0xff, vga_video_port_val
);
159 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 #ifdef CONFIG_VGACON_SOFT_SCROLLBACK
168 #include <linux/bootmem.h>
169 /* software scrollback */
170 static void *vgacon_scrollback
;
171 static int vgacon_scrollback_tail
;
172 static int vgacon_scrollback_size
;
173 static int vgacon_scrollback_rows
;
174 static int vgacon_scrollback_cnt
;
175 static int vgacon_scrollback_cur
;
176 static int vgacon_scrollback_save
;
177 static int vgacon_scrollback_restore
;
179 static void vgacon_scrollback_init(int pitch
)
181 int rows
= CONFIG_VGACON_SOFT_SCROLLBACK_SIZE
* 1024/pitch
;
183 if (vgacon_scrollback
) {
184 vgacon_scrollback_cnt
= 0;
185 vgacon_scrollback_tail
= 0;
186 vgacon_scrollback_cur
= 0;
187 vgacon_scrollback_rows
= rows
- 1;
188 vgacon_scrollback_size
= rows
* pitch
;
192 static void vgacon_scrollback_startup(void)
194 vgacon_scrollback
= alloc_bootmem(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE
196 vgacon_scrollback_init(vga_video_num_columns
* 2);
199 static void vgacon_scrollback_update(struct vc_data
*c
, int t
, int count
)
203 if (!vgacon_scrollback_size
|| c
->vc_num
!= fg_console
)
206 p
= (void *) (c
->vc_origin
+ t
* c
->vc_size_row
);
209 scr_memcpyw(vgacon_scrollback
+ vgacon_scrollback_tail
,
211 vgacon_scrollback_cnt
++;
213 vgacon_scrollback_tail
+= c
->vc_size_row
;
215 if (vgacon_scrollback_tail
>= vgacon_scrollback_size
)
216 vgacon_scrollback_tail
= 0;
218 if (vgacon_scrollback_cnt
> vgacon_scrollback_rows
)
219 vgacon_scrollback_cnt
= vgacon_scrollback_rows
;
221 vgacon_scrollback_cur
= vgacon_scrollback_cnt
;
225 static void vgacon_restore_screen(struct vc_data
*c
)
227 vgacon_scrollback_save
= 0;
229 if (!vga_is_gfx
&& !vgacon_scrollback_restore
) {
230 scr_memcpyw((u16
*) c
->vc_origin
, (u16
*) c
->vc_screenbuf
,
231 c
->vc_screenbuf_size
> vga_vram_size
?
232 vga_vram_size
: c
->vc_screenbuf_size
);
233 vgacon_scrollback_restore
= 1;
234 vgacon_scrollback_cur
= vgacon_scrollback_cnt
;
238 static int vgacon_scrolldelta(struct vc_data
*c
, int lines
)
240 int start
, end
, count
, soff
, diff
;
244 c
->vc_visible_origin
= c
->vc_origin
;
249 if (!vgacon_scrollback
)
252 if (!vgacon_scrollback_save
) {
253 vgacon_cursor(c
, CM_ERASE
);
254 vgacon_save_screen(c
);
255 vgacon_scrollback_save
= 1;
258 vgacon_scrollback_restore
= 0;
259 start
= vgacon_scrollback_cur
+ lines
;
260 end
= start
+ abs(lines
);
265 if (start
> vgacon_scrollback_cnt
)
266 start
= vgacon_scrollback_cnt
;
271 if (end
> vgacon_scrollback_cnt
)
272 end
= vgacon_scrollback_cnt
;
274 vgacon_scrollback_cur
= start
;
276 soff
= vgacon_scrollback_tail
- ((vgacon_scrollback_cnt
- end
) *
278 soff
-= count
* c
->vc_size_row
;
281 soff
+= vgacon_scrollback_size
;
283 count
= vgacon_scrollback_cnt
- start
;
285 if (count
> c
->vc_rows
)
288 diff
= c
->vc_rows
- count
;
290 d
= (void *) c
->vc_origin
;
291 s
= (void *) c
->vc_screenbuf
;
294 scr_memcpyw(d
, vgacon_scrollback
+ soff
, c
->vc_size_row
);
296 soff
+= c
->vc_size_row
;
298 if (soff
>= vgacon_scrollback_size
)
302 if (diff
== c
->vc_rows
) {
303 vgacon_cursor(c
, CM_MOVE
);
306 scr_memcpyw(d
, s
, c
->vc_size_row
);
315 #define vgacon_scrollback_startup(...) do { } while (0)
316 #define vgacon_scrollback_init(...) do { } while (0)
317 #define vgacon_scrollback_update(...) do { } while (0)
319 static void vgacon_restore_screen(struct vc_data
*c
)
321 if (c
->vc_origin
!= c
->vc_visible_origin
)
322 vgacon_scrolldelta(c
, 0);
325 static int vgacon_scrolldelta(struct vc_data
*c
, int lines
)
327 if (!lines
) /* Turn scrollback off */
328 c
->vc_visible_origin
= c
->vc_origin
;
330 int margin
= c
->vc_size_row
* 4;
333 if (vga_rolled_over
>
334 (c
->vc_scr_end
- vga_vram_base
) + margin
) {
335 ul
= c
->vc_scr_end
- vga_vram_base
;
336 we
= vga_rolled_over
+ c
->vc_size_row
;
341 p
= (c
->vc_visible_origin
- vga_vram_base
- ul
+ we
) % we
+
342 lines
* c
->vc_size_row
;
343 st
= (c
->vc_origin
- vga_vram_base
- ul
+ we
) % we
;
350 c
->vc_visible_origin
= vga_vram_base
+ (p
+ ul
) % we
;
355 #endif /* CONFIG_VGACON_SOFT_SCROLLBACK */
357 static const char *vgacon_startup(void)
359 const char *display_desc
= NULL
;
363 if (ORIG_VIDEO_ISVGA
== VIDEO_TYPE_VLFB
) {
365 #ifdef CONFIG_DUMMY_CONSOLE
366 conswitchp
= &dummy_con
;
367 return conswitchp
->con_startup();
373 /* VGA16 modes are not handled by VGACON */
374 if ((ORIG_VIDEO_MODE
== 0x00) || /* SCREEN_INFO not initialized */
375 (ORIG_VIDEO_MODE
== 0x0D) || /* 320x200/4 */
376 (ORIG_VIDEO_MODE
== 0x0E) || /* 640x200/4 */
377 (ORIG_VIDEO_MODE
== 0x10) || /* 640x350/4 */
378 (ORIG_VIDEO_MODE
== 0x12) || /* 640x480/4 */
379 (ORIG_VIDEO_MODE
== 0x6A)) /* 800x600/4, 0x6A is very common */
382 vga_video_num_lines
= ORIG_VIDEO_LINES
;
383 vga_video_num_columns
= ORIG_VIDEO_COLS
;
384 state
.vgabase
= NULL
;
386 if (ORIG_VIDEO_MODE
== 7) { /* Is this a monochrome display? */
387 vga_vram_base
= 0xb0000;
388 vga_video_port_reg
= VGA_CRT_IM
;
389 vga_video_port_val
= VGA_CRT_DM
;
390 if ((ORIG_VIDEO_EGA_BX
& 0xff) != 0x10) {
391 static struct resource ega_console_resource
=
392 { .name
= "ega", .start
= 0x3B0, .end
= 0x3BF };
393 vga_video_type
= VIDEO_TYPE_EGAM
;
394 vga_vram_size
= 0x8000;
395 display_desc
= "EGA+";
396 request_resource(&ioport_resource
,
397 &ega_console_resource
);
399 static struct resource mda1_console_resource
=
400 { .name
= "mda", .start
= 0x3B0, .end
= 0x3BB };
401 static struct resource mda2_console_resource
=
402 { .name
= "mda", .start
= 0x3BF, .end
= 0x3BF };
403 vga_video_type
= VIDEO_TYPE_MDA
;
404 vga_vram_size
= 0x2000;
405 display_desc
= "*MDA";
406 request_resource(&ioport_resource
,
407 &mda1_console_resource
);
408 request_resource(&ioport_resource
,
409 &mda2_console_resource
);
410 vga_video_font_height
= 14;
413 /* If not, it is color. */
414 vga_can_do_color
= 1;
415 vga_vram_base
= 0xb8000;
416 vga_video_port_reg
= VGA_CRT_IC
;
417 vga_video_port_val
= VGA_CRT_DC
;
418 if ((ORIG_VIDEO_EGA_BX
& 0xff) != 0x10) {
421 vga_vram_size
= 0x8000;
423 if (!ORIG_VIDEO_ISVGA
) {
424 static struct resource ega_console_resource
425 = { .name
= "ega", .start
= 0x3C0, .end
= 0x3DF };
426 vga_video_type
= VIDEO_TYPE_EGAC
;
427 display_desc
= "EGA";
428 request_resource(&ioport_resource
,
429 &ega_console_resource
);
431 static struct resource vga_console_resource
432 = { .name
= "vga+", .start
= 0x3C0, .end
= 0x3DF };
433 vga_video_type
= VIDEO_TYPE_VGAC
;
434 display_desc
= "VGA+";
435 request_resource(&ioport_resource
,
436 &vga_console_resource
);
438 #ifdef VGA_CAN_DO_64KB
440 * get 64K rather than 32K of video RAM.
441 * This doesn't actually work on all "VGA"
442 * controllers (it seems like setting MM=01
443 * and COE=1 isn't necessarily a good idea)
445 vga_vram_base
= 0xa0000;
446 vga_vram_size
= 0x10000;
447 outb_p(6, VGA_GFX_I
);
448 outb_p(6, VGA_GFX_D
);
451 * Normalise the palette registers, to point
452 * the 16 screen colours to the first 16
456 for (i
= 0; i
< 16; i
++) {
458 outb_p(i
, VGA_ATT_W
);
459 outb_p(i
, VGA_ATT_W
);
461 outb_p(0x20, VGA_ATT_W
);
464 * Now set the DAC registers back to their
467 for (i
= 0; i
< 16; i
++) {
468 outb_p(color_table
[i
], VGA_PEL_IW
);
469 outb_p(default_red
[i
], VGA_PEL_D
);
470 outb_p(default_grn
[i
], VGA_PEL_D
);
471 outb_p(default_blu
[i
], VGA_PEL_D
);
475 static struct resource cga_console_resource
=
476 { .name
= "cga", .start
= 0x3D4, .end
= 0x3D5 };
477 vga_video_type
= VIDEO_TYPE_CGA
;
478 vga_vram_size
= 0x2000;
479 display_desc
= "*CGA";
480 request_resource(&ioport_resource
,
481 &cga_console_resource
);
482 vga_video_font_height
= 8;
486 vga_vram_base
= VGA_MAP_MEM(vga_vram_base
, vga_vram_size
);
487 vga_vram_end
= vga_vram_base
+ vga_vram_size
;
490 * Find out if there is a graphics card present.
491 * Are there smarter methods around?
493 p
= (volatile u16
*) vga_vram_base
;
494 saved1
= scr_readw(p
);
495 saved2
= scr_readw(p
+ 1);
496 scr_writew(0xAA55, p
);
497 scr_writew(0x55AA, p
+ 1);
498 if (scr_readw(p
) != 0xAA55 || scr_readw(p
+ 1) != 0x55AA) {
499 scr_writew(saved1
, p
);
500 scr_writew(saved2
, p
+ 1);
503 scr_writew(0x55AA, p
);
504 scr_writew(0xAA55, p
+ 1);
505 if (scr_readw(p
) != 0x55AA || scr_readw(p
+ 1) != 0xAA55) {
506 scr_writew(saved1
, p
);
507 scr_writew(saved2
, p
+ 1);
510 scr_writew(saved1
, p
);
511 scr_writew(saved2
, p
+ 1);
513 if (vga_video_type
== VIDEO_TYPE_EGAC
514 || vga_video_type
== VIDEO_TYPE_VGAC
515 || vga_video_type
== VIDEO_TYPE_EGAM
) {
516 vga_hardscroll_enabled
= vga_hardscroll_user_enable
;
517 vga_default_font_height
= ORIG_VIDEO_POINTS
;
518 vga_video_font_height
= ORIG_VIDEO_POINTS
;
519 /* This may be suboptimal but is a safe bet - go with it */
521 vga_video_font_height
* vga_video_num_lines
;
524 vgacon_xres
= ORIG_VIDEO_COLS
* VGA_FONTWIDTH
;
525 vgacon_yres
= vga_scan_lines
;
527 if (!vga_init_done
) {
528 vgacon_scrollback_startup();
535 static void vgacon_init(struct vc_data
*c
, int init
)
540 * We cannot be loaded as a module, therefore init is always 1,
541 * but vgacon_init can be called more than once, and init will
544 c
->vc_can_do_color
= vga_can_do_color
;
546 /* set dimensions manually if init != 0 since vc_resize() will fail */
548 c
->vc_cols
= vga_video_num_columns
;
549 c
->vc_rows
= vga_video_num_lines
;
551 vc_resize(c
, vga_video_num_columns
, vga_video_num_lines
);
553 c
->vc_scan_lines
= vga_scan_lines
;
554 c
->vc_font
.height
= vga_video_font_height
;
555 c
->vc_complement_mask
= 0x7700;
557 c
->vc_hi_font_mask
= 0x0800;
558 p
= *c
->vc_uni_pagedir_loc
;
559 if (c
->vc_uni_pagedir_loc
== &c
->vc_uni_pagedir
||
560 !--c
->vc_uni_pagedir_loc
[1])
562 c
->vc_uni_pagedir_loc
= vgacon_uni_pagedir
;
563 vgacon_uni_pagedir
[1]++;
564 if (!vgacon_uni_pagedir
[0] && p
)
565 con_set_default_unimap(c
);
568 static void vgacon_deinit(struct vc_data
*c
)
570 /* When closing the last console, reset video origin */
571 if (!--vgacon_uni_pagedir
[1]) {
572 c
->vc_visible_origin
= vga_vram_base
;
576 c
->vc_uni_pagedir_loc
= &c
->vc_uni_pagedir
;
577 con_set_default_unimap(c
);
580 static u8
vgacon_build_attr(struct vc_data
*c
, u8 color
, u8 intensity
,
581 u8 blink
, u8 underline
, u8 reverse
, u8 italic
)
585 if (vga_can_do_color
) {
587 attr
= (attr
& 0xF0) | c
->vc_itcolor
;
589 attr
= (attr
& 0xf0) | c
->vc_ulcolor
;
590 else if (intensity
== 0)
591 attr
= (attr
& 0xf0) | c
->vc_halfcolor
;
595 ((attr
) & 0x88) | ((((attr
) >> 4) | ((attr
) << 4)) &
601 if (!vga_can_do_color
) {
603 attr
= (attr
& 0xF8) | 0x02;
605 attr
= (attr
& 0xf8) | 0x01;
606 else if (intensity
== 0)
607 attr
= (attr
& 0xf0) | 0x08;
612 static void vgacon_invert_region(struct vc_data
*c
, u16
* p
, int count
)
614 int col
= vga_can_do_color
;
617 u16 a
= scr_readw(p
);
619 a
= ((a
) & 0x88ff) | (((a
) & 0x7000) >> 4) |
620 (((a
) & 0x0700) << 4);
622 a
^= ((a
& 0x0700) == 0x0100) ? 0x7000 : 0x7700;
627 static void vgacon_set_cursor_size(int xpos
, int from
, int to
)
632 #ifdef TRIDENT_GLITCH
637 if ((from
== cursor_size_lastfrom
) && (to
== cursor_size_lastto
))
639 cursor_size_lastfrom
= from
;
640 cursor_size_lastto
= to
;
642 spin_lock_irqsave(&vga_lock
, flags
);
643 if (vga_video_type
>= VIDEO_TYPE_VGAC
) {
644 outb_p(VGA_CRTC_CURSOR_START
, vga_video_port_reg
);
645 curs
= inb_p(vga_video_port_val
);
646 outb_p(VGA_CRTC_CURSOR_END
, vga_video_port_reg
);
647 cure
= inb_p(vga_video_port_val
);
653 curs
= (curs
& 0xc0) | from
;
654 cure
= (cure
& 0xe0) | to
;
656 outb_p(VGA_CRTC_CURSOR_START
, vga_video_port_reg
);
657 outb_p(curs
, vga_video_port_val
);
658 outb_p(VGA_CRTC_CURSOR_END
, vga_video_port_reg
);
659 outb_p(cure
, vga_video_port_val
);
660 spin_unlock_irqrestore(&vga_lock
, flags
);
663 static void vgacon_cursor(struct vc_data
*c
, int mode
)
665 vgacon_restore_screen(c
);
669 write_vga(14, (c
->vc_pos
- vga_vram_base
) / 2);
670 if (vga_video_type
>= VIDEO_TYPE_VGAC
)
671 vgacon_set_cursor_size(c
->vc_x
, 31, 30);
673 vgacon_set_cursor_size(c
->vc_x
, 31, 31);
678 write_vga(14, (c
->vc_pos
- vga_vram_base
) / 2);
679 switch (c
->vc_cursor_type
& 0x0f) {
681 vgacon_set_cursor_size(c
->vc_x
,
690 vgacon_set_cursor_size(c
->vc_x
,
691 c
->vc_font
.height
/ 3,
696 case CUR_LOWER_THIRD
:
697 vgacon_set_cursor_size(c
->vc_x
,
698 (c
->vc_font
.height
* 2) / 3,
704 vgacon_set_cursor_size(c
->vc_x
,
705 c
->vc_font
.height
/ 2,
711 if (vga_video_type
>= VIDEO_TYPE_VGAC
)
712 vgacon_set_cursor_size(c
->vc_x
, 31, 30);
714 vgacon_set_cursor_size(c
->vc_x
, 31, 31);
717 vgacon_set_cursor_size(c
->vc_x
, 1,
725 static int vgacon_doresize(struct vc_data
*c
,
726 unsigned int width
, unsigned int height
)
729 unsigned int scanlines
= height
* c
->vc_font
.height
;
730 u8 scanlines_lo
= 0, r7
= 0, vsync_end
= 0, mode
, max_scan
;
732 spin_lock_irqsave(&vga_lock
, flags
);
734 vgacon_xres
= width
* VGA_FONTWIDTH
;
735 vgacon_yres
= height
* c
->vc_font
.height
;
736 if (vga_video_type
>= VIDEO_TYPE_VGAC
) {
737 outb_p(VGA_CRTC_MAX_SCAN
, vga_video_port_reg
);
738 max_scan
= inb_p(vga_video_port_val
);
743 outb_p(VGA_CRTC_MODE
, vga_video_port_reg
);
744 mode
= inb_p(vga_video_port_val
);
750 scanlines_lo
= scanlines
& 0xff;
752 outb_p(VGA_CRTC_OVERFLOW
, vga_video_port_reg
);
753 r7
= inb_p(vga_video_port_val
) & ~0x42;
755 if (scanlines
& 0x100)
757 if (scanlines
& 0x200)
760 /* deprotect registers */
761 outb_p(VGA_CRTC_V_SYNC_END
, vga_video_port_reg
);
762 vsync_end
= inb_p(vga_video_port_val
);
763 outb_p(VGA_CRTC_V_SYNC_END
, vga_video_port_reg
);
764 outb_p(vsync_end
& ~0x80, vga_video_port_val
);
767 outb_p(VGA_CRTC_H_DISP
, vga_video_port_reg
);
768 outb_p(width
- 1, vga_video_port_val
);
769 outb_p(VGA_CRTC_OFFSET
, vga_video_port_reg
);
770 outb_p(width
>> 1, vga_video_port_val
);
772 if (vga_video_type
>= VIDEO_TYPE_VGAC
) {
773 outb_p(VGA_CRTC_V_DISP_END
, vga_video_port_reg
);
774 outb_p(scanlines_lo
, vga_video_port_val
);
775 outb_p(VGA_CRTC_OVERFLOW
, vga_video_port_reg
);
776 outb_p(r7
,vga_video_port_val
);
778 /* reprotect registers */
779 outb_p(VGA_CRTC_V_SYNC_END
, vga_video_port_reg
);
780 outb_p(vsync_end
, vga_video_port_val
);
783 spin_unlock_irqrestore(&vga_lock
, flags
);
787 static int vgacon_switch(struct vc_data
*c
)
789 int x
= c
->vc_cols
* VGA_FONTWIDTH
;
790 int y
= c
->vc_rows
* c
->vc_font
.height
;
791 int rows
= ORIG_VIDEO_LINES
* vga_default_font_height
/
794 * We need to save screen size here as it's the only way
795 * we can spot the screen has been resized and we need to
796 * set size of freshly allocated screens ourselves.
798 vga_video_num_columns
= c
->vc_cols
;
799 vga_video_num_lines
= c
->vc_rows
;
801 /* We can only copy out the size of the video buffer here,
802 * otherwise we get into VGA BIOS */
805 scr_memcpyw((u16
*) c
->vc_origin
, (u16
*) c
->vc_screenbuf
,
806 c
->vc_screenbuf_size
> vga_vram_size
?
807 vga_vram_size
: c
->vc_screenbuf_size
);
809 if ((vgacon_xres
!= x
|| vgacon_yres
!= y
) &&
810 (!(vga_video_num_columns
% 2) &&
811 vga_video_num_columns
<= ORIG_VIDEO_COLS
&&
812 vga_video_num_lines
<= rows
))
813 vgacon_doresize(c
, c
->vc_cols
, c
->vc_rows
);
816 vgacon_scrollback_init(c
->vc_size_row
);
817 return 0; /* Redrawing not needed */
820 static void vga_set_palette(struct vc_data
*vc
, unsigned char *table
)
824 vga_w(state
.vgabase
, VGA_PEL_MSK
, 0xff);
825 for (i
= j
= 0; i
< 16; i
++) {
826 vga_w(state
.vgabase
, VGA_PEL_IW
, table
[i
]);
827 vga_w(state
.vgabase
, VGA_PEL_D
, vc
->vc_palette
[j
++] >> 2);
828 vga_w(state
.vgabase
, VGA_PEL_D
, vc
->vc_palette
[j
++] >> 2);
829 vga_w(state
.vgabase
, VGA_PEL_D
, vc
->vc_palette
[j
++] >> 2);
833 static int vgacon_set_palette(struct vc_data
*vc
, unsigned char *table
)
835 #ifdef CAN_LOAD_PALETTE
836 if (vga_video_type
!= VIDEO_TYPE_VGAC
|| vga_palette_blanked
837 || !CON_IS_VISIBLE(vc
))
839 vga_set_palette(vc
, table
);
846 /* structure holding original VGA register settings */
848 unsigned char SeqCtrlIndex
; /* Sequencer Index reg. */
849 unsigned char CrtCtrlIndex
; /* CRT-Contr. Index reg. */
850 unsigned char CrtMiscIO
; /* Miscellaneous register */
851 unsigned char HorizontalTotal
; /* CRT-Controller:00h */
852 unsigned char HorizDisplayEnd
; /* CRT-Controller:01h */
853 unsigned char StartHorizRetrace
; /* CRT-Controller:04h */
854 unsigned char EndHorizRetrace
; /* CRT-Controller:05h */
855 unsigned char Overflow
; /* CRT-Controller:07h */
856 unsigned char StartVertRetrace
; /* CRT-Controller:10h */
857 unsigned char EndVertRetrace
; /* CRT-Controller:11h */
858 unsigned char ModeControl
; /* CRT-Controller:17h */
859 unsigned char ClockingMode
; /* Seq-Controller:01h */
862 static void vga_vesa_blank(struct vgastate
*state
, int mode
)
864 /* save original values of VGA controller registers */
865 if (!vga_vesa_blanked
) {
866 spin_lock_irq(&vga_lock
);
867 vga_state
.SeqCtrlIndex
= vga_r(state
->vgabase
, VGA_SEQ_I
);
868 vga_state
.CrtCtrlIndex
= inb_p(vga_video_port_reg
);
869 vga_state
.CrtMiscIO
= vga_r(state
->vgabase
, VGA_MIS_R
);
870 spin_unlock_irq(&vga_lock
);
872 outb_p(0x00, vga_video_port_reg
); /* HorizontalTotal */
873 vga_state
.HorizontalTotal
= inb_p(vga_video_port_val
);
874 outb_p(0x01, vga_video_port_reg
); /* HorizDisplayEnd */
875 vga_state
.HorizDisplayEnd
= inb_p(vga_video_port_val
);
876 outb_p(0x04, vga_video_port_reg
); /* StartHorizRetrace */
877 vga_state
.StartHorizRetrace
= inb_p(vga_video_port_val
);
878 outb_p(0x05, vga_video_port_reg
); /* EndHorizRetrace */
879 vga_state
.EndHorizRetrace
= inb_p(vga_video_port_val
);
880 outb_p(0x07, vga_video_port_reg
); /* Overflow */
881 vga_state
.Overflow
= inb_p(vga_video_port_val
);
882 outb_p(0x10, vga_video_port_reg
); /* StartVertRetrace */
883 vga_state
.StartVertRetrace
= inb_p(vga_video_port_val
);
884 outb_p(0x11, vga_video_port_reg
); /* EndVertRetrace */
885 vga_state
.EndVertRetrace
= inb_p(vga_video_port_val
);
886 outb_p(0x17, vga_video_port_reg
); /* ModeControl */
887 vga_state
.ModeControl
= inb_p(vga_video_port_val
);
888 vga_state
.ClockingMode
= vga_rseq(state
->vgabase
, VGA_SEQ_CLOCK_MODE
);
891 /* assure that video is enabled */
892 /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */
893 spin_lock_irq(&vga_lock
);
894 vga_wseq(state
->vgabase
, VGA_SEQ_CLOCK_MODE
, vga_state
.ClockingMode
| 0x20);
896 /* test for vertical retrace in process.... */
897 if ((vga_state
.CrtMiscIO
& 0x80) == 0x80)
898 vga_w(state
->vgabase
, VGA_MIS_W
, vga_state
.CrtMiscIO
& 0xEF);
901 * Set <End of vertical retrace> to minimum (0) and
902 * <Start of vertical Retrace> to maximum (incl. overflow)
903 * Result: turn off vertical sync (VSync) pulse.
905 if (mode
& VESA_VSYNC_SUSPEND
) {
906 outb_p(0x10, vga_video_port_reg
); /* StartVertRetrace */
907 outb_p(0xff, vga_video_port_val
); /* maximum value */
908 outb_p(0x11, vga_video_port_reg
); /* EndVertRetrace */
909 outb_p(0x40, vga_video_port_val
); /* minimum (bits 0..3) */
910 outb_p(0x07, vga_video_port_reg
); /* Overflow */
911 outb_p(vga_state
.Overflow
| 0x84, vga_video_port_val
); /* bits 9,10 of vert. retrace */
914 if (mode
& VESA_HSYNC_SUSPEND
) {
916 * Set <End of horizontal retrace> to minimum (0) and
917 * <Start of horizontal Retrace> to maximum
918 * Result: turn off horizontal sync (HSync) pulse.
920 outb_p(0x04, vga_video_port_reg
); /* StartHorizRetrace */
921 outb_p(0xff, vga_video_port_val
); /* maximum */
922 outb_p(0x05, vga_video_port_reg
); /* EndHorizRetrace */
923 outb_p(0x00, vga_video_port_val
); /* minimum (0) */
926 /* restore both index registers */
927 vga_w(state
->vgabase
, VGA_SEQ_I
, vga_state
.SeqCtrlIndex
);
928 outb_p(vga_state
.CrtCtrlIndex
, vga_video_port_reg
);
929 spin_unlock_irq(&vga_lock
);
932 static void vga_vesa_unblank(struct vgastate
*state
)
934 /* restore original values of VGA controller registers */
935 spin_lock_irq(&vga_lock
);
936 vga_w(state
->vgabase
, VGA_MIS_W
, vga_state
.CrtMiscIO
);
938 outb_p(0x00, vga_video_port_reg
); /* HorizontalTotal */
939 outb_p(vga_state
.HorizontalTotal
, vga_video_port_val
);
940 outb_p(0x01, vga_video_port_reg
); /* HorizDisplayEnd */
941 outb_p(vga_state
.HorizDisplayEnd
, vga_video_port_val
);
942 outb_p(0x04, vga_video_port_reg
); /* StartHorizRetrace */
943 outb_p(vga_state
.StartHorizRetrace
, vga_video_port_val
);
944 outb_p(0x05, vga_video_port_reg
); /* EndHorizRetrace */
945 outb_p(vga_state
.EndHorizRetrace
, vga_video_port_val
);
946 outb_p(0x07, vga_video_port_reg
); /* Overflow */
947 outb_p(vga_state
.Overflow
, vga_video_port_val
);
948 outb_p(0x10, vga_video_port_reg
); /* StartVertRetrace */
949 outb_p(vga_state
.StartVertRetrace
, vga_video_port_val
);
950 outb_p(0x11, vga_video_port_reg
); /* EndVertRetrace */
951 outb_p(vga_state
.EndVertRetrace
, vga_video_port_val
);
952 outb_p(0x17, vga_video_port_reg
); /* ModeControl */
953 outb_p(vga_state
.ModeControl
, vga_video_port_val
);
955 vga_wseq(state
->vgabase
, VGA_SEQ_CLOCK_MODE
, vga_state
.ClockingMode
);
957 /* restore index/control registers */
958 vga_w(state
->vgabase
, VGA_SEQ_I
, vga_state
.SeqCtrlIndex
);
959 outb_p(vga_state
.CrtCtrlIndex
, vga_video_port_reg
);
960 spin_unlock_irq(&vga_lock
);
963 static void vga_pal_blank(struct vgastate
*state
)
967 vga_w(state
->vgabase
, VGA_PEL_MSK
, 0xff);
968 for (i
= 0; i
< 16; i
++) {
969 vga_w(state
->vgabase
, VGA_PEL_IW
, i
);
970 vga_w(state
->vgabase
, VGA_PEL_D
, 0);
971 vga_w(state
->vgabase
, VGA_PEL_D
, 0);
972 vga_w(state
->vgabase
, VGA_PEL_D
, 0);
976 static int vgacon_blank(struct vc_data
*c
, int blank
, int mode_switch
)
979 case 0: /* Unblank */
980 if (vga_vesa_blanked
) {
981 vga_vesa_unblank(&state
);
982 vga_vesa_blanked
= 0;
984 if (vga_palette_blanked
) {
985 vga_set_palette(c
, color_table
);
986 vga_palette_blanked
= 0;
990 /* Tell console.c that it has to restore the screen itself */
992 case 1: /* Normal blanking */
993 case -1: /* Obsolete */
994 if (!mode_switch
&& vga_video_type
== VIDEO_TYPE_VGAC
) {
995 vga_pal_blank(&state
);
996 vga_palette_blanked
= 1;
999 vgacon_set_origin(c
);
1000 scr_memsetw((void *) vga_vram_base
, BLANK
,
1001 c
->vc_screenbuf_size
);
1005 default: /* VESA blanking */
1006 if (vga_video_type
== VIDEO_TYPE_VGAC
) {
1007 vga_vesa_blank(&state
, blank
- 1);
1008 vga_vesa_blanked
= blank
;
1017 * The font loading code goes back to the codepage package by
1018 * Joel Hoffman (joel@wam.umd.edu). (He reports that the original
1019 * reference is: "From: p. 307 of _Programmer's Guide to PC & PS/2
1020 * Video Systems_ by Richard Wilton. 1987. Microsoft Press".)
1022 * Change for certain monochrome monitors by Yury Shevchuck
1023 * (sizif@botik.yaroslavl.su).
1026 #ifdef CAN_LOAD_EGA_FONTS
1028 #define colourmap 0xa0000
1029 /* Pauline Middelink <middelin@polyware.iaf.nl> reports that we
1030 should use 0xA0000 for the bwmap as well.. */
1031 #define blackwmap 0xa0000
1034 static int vgacon_do_font_op(struct vgastate
*state
,char *arg
,int set
,int ch512
)
1036 unsigned short video_port_status
= vga_video_port_reg
+ 6;
1037 int font_select
= 0x00, beg
, i
;
1040 if (vga_video_type
!= VIDEO_TYPE_EGAM
) {
1041 charmap
= (char *) VGA_MAP_MEM(colourmap
, 0);
1043 #ifdef VGA_CAN_DO_64KB
1044 if (vga_video_type
== VIDEO_TYPE_VGAC
)
1048 charmap
= (char *) VGA_MAP_MEM(blackwmap
, 0);
1052 #ifdef BROKEN_GRAPHICS_PROGRAMS
1054 * All fonts are loaded in slot 0 (0:1 for 512 ch)
1058 return -EINVAL
; /* Return to default font not supported */
1060 vga_font_is_default
= 0;
1061 font_select
= ch512
? 0x04 : 0x00;
1064 * The default font is kept in slot 0 and is never touched.
1065 * A custom font is loaded in slot 2 (256 ch) or 2:3 (512 ch)
1069 vga_font_is_default
= !arg
;
1071 ch512
= 0; /* Default font is always 256 */
1072 font_select
= arg
? (ch512
? 0x0e : 0x0a) : 0x00;
1075 if (!vga_font_is_default
)
1076 charmap
+= 4 * cmapsz
;
1080 spin_lock_irq(&vga_lock
);
1081 /* First, the Sequencer */
1082 vga_wseq(state
->vgabase
, VGA_SEQ_RESET
, 0x1);
1083 /* CPU writes only to map 2 */
1084 vga_wseq(state
->vgabase
, VGA_SEQ_PLANE_WRITE
, 0x04);
1085 /* Sequential addressing */
1086 vga_wseq(state
->vgabase
, VGA_SEQ_MEMORY_MODE
, 0x07);
1087 /* Clear synchronous reset */
1088 vga_wseq(state
->vgabase
, VGA_SEQ_RESET
, 0x03);
1090 /* Now, the graphics controller, select map 2 */
1091 vga_wgfx(state
->vgabase
, VGA_GFX_PLANE_READ
, 0x02);
1092 /* disable odd-even addressing */
1093 vga_wgfx(state
->vgabase
, VGA_GFX_MODE
, 0x00);
1094 /* map start at A000:0000 */
1095 vga_wgfx(state
->vgabase
, VGA_GFX_MISC
, 0x00);
1096 spin_unlock_irq(&vga_lock
);
1100 for (i
= 0; i
< cmapsz
; i
++)
1101 vga_writeb(arg
[i
], charmap
+ i
);
1103 for (i
= 0; i
< cmapsz
; i
++)
1104 arg
[i
] = vga_readb(charmap
+ i
);
1107 * In 512-character mode, the character map is not contiguous if
1108 * we want to remain EGA compatible -- which we do
1112 charmap
+= 2 * cmapsz
;
1115 for (i
= 0; i
< cmapsz
; i
++)
1116 vga_writeb(arg
[i
], charmap
+ i
);
1118 for (i
= 0; i
< cmapsz
; i
++)
1119 arg
[i
] = vga_readb(charmap
+ i
);
1123 spin_lock_irq(&vga_lock
);
1124 /* First, the sequencer, Synchronous reset */
1125 vga_wseq(state
->vgabase
, VGA_SEQ_RESET
, 0x01);
1126 /* CPU writes to maps 0 and 1 */
1127 vga_wseq(state
->vgabase
, VGA_SEQ_PLANE_WRITE
, 0x03);
1128 /* odd-even addressing */
1129 vga_wseq(state
->vgabase
, VGA_SEQ_MEMORY_MODE
, 0x03);
1130 /* Character Map Select */
1132 vga_wseq(state
->vgabase
, VGA_SEQ_CHARACTER_MAP
, font_select
);
1133 /* clear synchronous reset */
1134 vga_wseq(state
->vgabase
, VGA_SEQ_RESET
, 0x03);
1136 /* Now, the graphics controller, select map 0 for CPU */
1137 vga_wgfx(state
->vgabase
, VGA_GFX_PLANE_READ
, 0x00);
1138 /* enable even-odd addressing */
1139 vga_wgfx(state
->vgabase
, VGA_GFX_MODE
, 0x10);
1140 /* map starts at b800:0 or b000:0 */
1141 vga_wgfx(state
->vgabase
, VGA_GFX_MISC
, beg
);
1143 /* if 512 char mode is already enabled don't re-enable it. */
1144 if ((set
) && (ch512
!= vga_512_chars
)) {
1147 /* attribute controller */
1148 for (i
= 0; i
< MAX_NR_CONSOLES
; i
++) {
1149 struct vc_data
*c
= vc_cons
[i
].d
;
1150 if (c
&& c
->vc_sw
== &vga_con
)
1151 c
->vc_hi_font_mask
= ch512
? 0x0800 : 0;
1153 vga_512_chars
= ch512
;
1154 /* 256-char: enable intensity bit
1155 512-char: disable intensity bit */
1156 inb_p(video_port_status
); /* clear address flip-flop */
1157 /* color plane enable register */
1158 vga_wattr(state
->vgabase
, VGA_ATC_PLANE_ENABLE
, ch512
? 0x07 : 0x0f);
1159 /* Wilton (1987) mentions the following; I don't know what
1160 it means, but it works, and it appears necessary */
1161 inb_p(video_port_status
);
1162 vga_wattr(state
->vgabase
, VGA_AR_ENABLE_DISPLAY
, 0);
1164 spin_unlock_irq(&vga_lock
);
1170 * Adjust the screen to fit a font of a certain height
1172 static int vgacon_adjust_height(struct vc_data
*vc
, unsigned fontheight
)
1174 unsigned char ovr
, vde
, fsr
;
1175 int rows
, maxscan
, i
;
1177 rows
= vc
->vc_scan_lines
/ fontheight
; /* Number of video rows we end up with */
1178 maxscan
= rows
* fontheight
- 1; /* Scan lines to actually display-1 */
1180 /* Reprogram the CRTC for the new font size
1181 Note: the attempt to read the overflow register will fail
1182 on an EGA, but using 0xff for the previous value appears to
1183 be OK for EGA text modes in the range 257-512 scan lines, so I
1184 guess we don't need to worry about it.
1186 The same applies for the spill bits in the font size and cursor
1187 registers; they are write-only on EGA, but it appears that they
1188 are all don't care bits on EGA, so I guess it doesn't matter. */
1190 spin_lock_irq(&vga_lock
);
1191 outb_p(0x07, vga_video_port_reg
); /* CRTC overflow register */
1192 ovr
= inb_p(vga_video_port_val
);
1193 outb_p(0x09, vga_video_port_reg
); /* Font size register */
1194 fsr
= inb_p(vga_video_port_val
);
1195 spin_unlock_irq(&vga_lock
);
1197 vde
= maxscan
& 0xff; /* Vertical display end reg */
1198 ovr
= (ovr
& 0xbd) + /* Overflow register */
1199 ((maxscan
& 0x100) >> 7) + ((maxscan
& 0x200) >> 3);
1200 fsr
= (fsr
& 0xe0) + (fontheight
- 1); /* Font size register */
1202 spin_lock_irq(&vga_lock
);
1203 outb_p(0x07, vga_video_port_reg
); /* CRTC overflow register */
1204 outb_p(ovr
, vga_video_port_val
);
1205 outb_p(0x09, vga_video_port_reg
); /* Font size */
1206 outb_p(fsr
, vga_video_port_val
);
1207 outb_p(0x12, vga_video_port_reg
); /* Vertical display limit */
1208 outb_p(vde
, vga_video_port_val
);
1209 spin_unlock_irq(&vga_lock
);
1210 vga_video_font_height
= fontheight
;
1212 for (i
= 0; i
< MAX_NR_CONSOLES
; i
++) {
1213 struct vc_data
*c
= vc_cons
[i
].d
;
1215 if (c
&& c
->vc_sw
== &vga_con
) {
1216 if (CON_IS_VISIBLE(c
)) {
1217 /* void size to cause regs to be rewritten */
1218 cursor_size_lastfrom
= 0;
1219 cursor_size_lastto
= 0;
1220 c
->vc_sw
->con_cursor(c
, CM_DRAW
);
1222 c
->vc_font
.height
= fontheight
;
1223 vc_resize(c
, 0, rows
); /* Adjust console size */
1229 static int vgacon_font_set(struct vc_data
*c
, struct console_font
*font
, unsigned flags
)
1231 unsigned charcount
= font
->charcount
;
1234 if (vga_video_type
< VIDEO_TYPE_EGAM
)
1237 if (font
->width
!= VGA_FONTWIDTH
||
1238 (charcount
!= 256 && charcount
!= 512))
1241 rc
= vgacon_do_font_op(&state
, font
->data
, 1, charcount
== 512);
1245 if (!(flags
& KD_FONT_FLAG_DONT_RECALC
))
1246 rc
= vgacon_adjust_height(c
, font
->height
);
1250 static int vgacon_font_get(struct vc_data
*c
, struct console_font
*font
)
1252 if (vga_video_type
< VIDEO_TYPE_EGAM
)
1255 font
->width
= VGA_FONTWIDTH
;
1256 font
->height
= c
->vc_font
.height
;
1257 font
->charcount
= vga_512_chars
? 512 : 256;
1260 return vgacon_do_font_op(&state
, font
->data
, 0, 0);
1265 #define vgacon_font_set NULL
1266 #define vgacon_font_get NULL
1270 static int vgacon_resize(struct vc_data
*c
, unsigned int width
,
1271 unsigned int height
)
1273 if (width
% 2 || width
> ORIG_VIDEO_COLS
||
1274 height
> (ORIG_VIDEO_LINES
* vga_default_font_height
)/
1276 /* let svgatextmode tinker with video timings */
1279 if (CON_IS_VISIBLE(c
) && !vga_is_gfx
) /* who knows */
1280 vgacon_doresize(c
, width
, height
);
1284 static int vgacon_set_origin(struct vc_data
*c
)
1286 if (vga_is_gfx
|| /* We don't play origin tricks in graphic modes */
1287 (console_blanked
&& !vga_palette_blanked
)) /* Nor we write to blanked screens */
1289 c
->vc_origin
= c
->vc_visible_origin
= vga_vram_base
;
1291 vga_rolled_over
= 0;
1295 static void vgacon_save_screen(struct vc_data
*c
)
1297 static int vga_bootup_console
= 0;
1299 if (!vga_bootup_console
) {
1300 /* This is a gross hack, but here is the only place we can
1301 * set bootup console parameters without messing up generic
1302 * console initialization routines.
1304 vga_bootup_console
= 1;
1309 /* We can't copy in more then the size of the video buffer,
1310 * or we'll be copying in VGA BIOS */
1313 scr_memcpyw((u16
*) c
->vc_screenbuf
, (u16
*) c
->vc_origin
,
1314 c
->vc_screenbuf_size
> vga_vram_size
? vga_vram_size
: c
->vc_screenbuf_size
);
1317 static int vgacon_scroll(struct vc_data
*c
, int t
, int b
, int dir
,
1323 if (t
|| b
!= c
->vc_rows
|| vga_is_gfx
)
1326 if (!vga_hardscroll_enabled
|| lines
>= c
->vc_rows
/ 2)
1329 vgacon_restore_screen(c
);
1330 oldo
= c
->vc_origin
;
1331 delta
= lines
* c
->vc_size_row
;
1333 vgacon_scrollback_update(c
, t
, lines
);
1334 if (c
->vc_scr_end
+ delta
>= vga_vram_end
) {
1335 scr_memcpyw((u16
*) vga_vram_base
,
1336 (u16
*) (oldo
+ delta
),
1337 c
->vc_screenbuf_size
- delta
);
1338 c
->vc_origin
= vga_vram_base
;
1339 vga_rolled_over
= oldo
- vga_vram_base
;
1341 c
->vc_origin
+= delta
;
1342 scr_memsetw((u16
*) (c
->vc_origin
+ c
->vc_screenbuf_size
-
1343 delta
), c
->vc_video_erase_char
,
1346 if (oldo
- delta
< vga_vram_base
) {
1347 scr_memmovew((u16
*) (vga_vram_end
-
1348 c
->vc_screenbuf_size
+
1349 delta
), (u16
*) oldo
,
1350 c
->vc_screenbuf_size
- delta
);
1351 c
->vc_origin
= vga_vram_end
- c
->vc_screenbuf_size
;
1352 vga_rolled_over
= 0;
1354 c
->vc_origin
-= delta
;
1355 c
->vc_scr_end
= c
->vc_origin
+ c
->vc_screenbuf_size
;
1356 scr_memsetw((u16
*) (c
->vc_origin
), c
->vc_video_erase_char
,
1359 c
->vc_scr_end
= c
->vc_origin
+ c
->vc_screenbuf_size
;
1360 c
->vc_visible_origin
= c
->vc_origin
;
1362 c
->vc_pos
= (c
->vc_pos
- oldo
) + c
->vc_origin
;
1368 * The console `switch' structure for the VGA based console
1371 static int vgacon_dummy(struct vc_data
*c
)
1376 #define DUMMY (void *) vgacon_dummy
1378 const struct consw vga_con
= {
1379 .owner
= THIS_MODULE
,
1380 .con_startup
= vgacon_startup
,
1381 .con_init
= vgacon_init
,
1382 .con_deinit
= vgacon_deinit
,
1386 .con_cursor
= vgacon_cursor
,
1387 .con_scroll
= vgacon_scroll
,
1389 .con_switch
= vgacon_switch
,
1390 .con_blank
= vgacon_blank
,
1391 .con_font_set
= vgacon_font_set
,
1392 .con_font_get
= vgacon_font_get
,
1393 .con_resize
= vgacon_resize
,
1394 .con_set_palette
= vgacon_set_palette
,
1395 .con_scrolldelta
= vgacon_scrolldelta
,
1396 .con_set_origin
= vgacon_set_origin
,
1397 .con_save_screen
= vgacon_save_screen
,
1398 .con_build_attr
= vgacon_build_attr
,
1399 .con_invert_region
= vgacon_invert_region
,
1402 MODULE_LICENSE("GPL");