2 * linux/drivers/video/vgacon.c -- Low level VGA based console driver
4 * Created 28 Sep 1997 by Geert Uytterhoeven
6 * Rewritten by Martin Mares <mj@ucw.cz>, July 1998
8 * This file is based on the old console.c, vga.c and vesa_blank.c drivers.
10 * Copyright (C) 1991, 1992 Linus Torvalds
13 * User definable mapping table and font loading by Eugene G. Crosser,
14 * <crosser@average.org>
16 * Improved loadable font/UTF-8 support by H. Peter Anvin
17 * Feb-Sep 1995 <peter.anvin@linux.org>
19 * Colour palette handling, by Simon Tatham
20 * 17-Jun-95 <sgt20@cam.ac.uk>
22 * if 512 char mode is already enabled don't re-enable it,
23 * because it causes screen to flicker, by Mitja Horvat
24 * 5-May-96 <mitja.horvat@guest.arnes.si>
26 * Use 2 outw instead of 4 outb_p to reduce erroneous text
27 * flashing on RHS of screen during heavy console scrolling .
28 * Oct 1996, Paul Gortmaker.
31 * This file is subject to the terms and conditions of the GNU General Public
32 * License. See the file COPYING in the main directory of this archive for
36 #include <linux/module.h>
37 #include <linux/types.h>
39 #include <linux/kernel.h>
40 #include <linux/console.h>
41 #include <linux/string.h>
43 #include <linux/slab.h>
44 #include <linux/vt_kern.h>
45 #include <linux/selection.h>
46 #include <linux/spinlock.h>
47 #include <linux/ioport.h>
48 #include <linux/init.h>
49 #include <linux/screen_info.h>
50 #include <linux/smp_lock.h>
51 #include <video/vga.h>
54 static DEFINE_SPINLOCK(vga_lock
);
55 static int cursor_size_lastfrom
;
56 static int cursor_size_lastto
;
57 static u32 vgacon_xres
;
58 static u32 vgacon_yres
;
59 static struct vgastate state
;
63 #define CAN_LOAD_EGA_FONTS /* undefine if the user must not do this */
64 #define CAN_LOAD_PALETTE /* undefine if the user must not do this */
66 /* You really do _NOT_ want to define this, unless you have buggy
67 * Trident VGA which will resize cursor when moving it between column
68 * 15 & 16. If you define this and your VGA is OK, inverse bug will
72 #define VGA_FONTWIDTH 8 /* VGA does not support fontwidths != 8 */
74 * Interface used by the world
77 static const char *vgacon_startup(void);
78 static void vgacon_init(struct vc_data
*c
, int init
);
79 static void vgacon_deinit(struct vc_data
*c
);
80 static void vgacon_cursor(struct vc_data
*c
, int mode
);
81 static int vgacon_switch(struct vc_data
*c
);
82 static int vgacon_blank(struct vc_data
*c
, int blank
, int mode_switch
);
83 static int vgacon_set_palette(struct vc_data
*vc
, unsigned char *table
);
84 static int vgacon_scrolldelta(struct vc_data
*c
, int lines
);
85 static int vgacon_set_origin(struct vc_data
*c
);
86 static void vgacon_save_screen(struct vc_data
*c
);
87 static int vgacon_scroll(struct vc_data
*c
, int t
, int b
, int dir
,
89 static void vgacon_invert_region(struct vc_data
*c
, u16
* p
, int count
);
90 static unsigned long vgacon_uni_pagedir
[2];
92 /* Description of the hardware situation */
93 static int vga_init_done __read_mostly
;
94 static unsigned long vga_vram_base __read_mostly
; /* Base of video memory */
95 static unsigned long vga_vram_end __read_mostly
; /* End of video memory */
96 static unsigned int vga_vram_size __read_mostly
; /* Size of video memory */
97 static u16 vga_video_port_reg __read_mostly
; /* Video register select port */
98 static u16 vga_video_port_val __read_mostly
; /* Video register value port */
99 static unsigned int vga_video_num_columns
; /* Number of text columns */
100 static unsigned int vga_video_num_lines
; /* Number of text lines */
101 static int vga_can_do_color __read_mostly
; /* Do we support colors? */
102 static unsigned int vga_default_font_height __read_mostly
; /* Height of default screen font */
103 static unsigned char vga_video_type __read_mostly
; /* Card type */
104 static unsigned char vga_hardscroll_enabled __read_mostly
;
105 static unsigned char vga_hardscroll_user_enable __read_mostly
= 1;
106 static unsigned char vga_font_is_default
= 1;
107 static int vga_vesa_blanked
;
108 static int vga_palette_blanked
;
109 static int vga_is_gfx
;
110 static int vga_512_chars
;
111 static int vga_video_font_height
;
112 static int vga_scan_lines __read_mostly
;
113 static unsigned int vga_rolled_over
;
115 int vgacon_text_mode_force
= 0;
117 bool vgacon_text_force(void)
119 return vgacon_text_mode_force
? true : false;
121 EXPORT_SYMBOL(vgacon_text_force
);
123 static int __init
text_mode(char *str
)
125 vgacon_text_mode_force
= 1;
129 /* force text mode - used by kernel modesetting */
130 __setup("nomodeset", text_mode
);
132 static int __init
no_scroll(char *str
)
135 * Disabling scrollback is required for the Braillex ib80-piezo
136 * Braille reader made by F.H. Papenmeier (Germany).
137 * Use the "no-scroll" bootflag.
139 vga_hardscroll_user_enable
= vga_hardscroll_enabled
= 0;
143 __setup("no-scroll", no_scroll
);
146 * By replacing the four outb_p with two back to back outw, we can reduce
147 * the window of opportunity to see text mislocated to the RHS of the
148 * console during heavy scrolling activity. However there is the remote
149 * possibility that some pre-dinosaur hardware won't like the back to back
150 * I/O. Since the Xservers get away with it, we should be able to as well.
152 static inline void write_vga(unsigned char reg
, unsigned int val
)
158 * ddprintk might set the console position from interrupt
159 * handlers, thus the write has to be IRQ-atomic.
161 spin_lock_irqsave(&vga_lock
, flags
);
164 v1
= reg
+ (val
& 0xff00);
165 v2
= reg
+ 1 + ((val
<< 8) & 0xff00);
166 outw(v1
, vga_video_port_reg
);
167 outw(v2
, vga_video_port_reg
);
169 outb_p(reg
, vga_video_port_reg
);
170 outb_p(val
>> 8, vga_video_port_val
);
171 outb_p(reg
+ 1, vga_video_port_reg
);
172 outb_p(val
& 0xff, vga_video_port_val
);
174 spin_unlock_irqrestore(&vga_lock
, flags
);
177 static inline void vga_set_mem_top(struct vc_data
*c
)
179 write_vga(12, (c
->vc_visible_origin
- vga_vram_base
) / 2);
182 #ifdef CONFIG_VGACON_SOFT_SCROLLBACK
183 /* software scrollback */
184 static void *vgacon_scrollback
;
185 static int vgacon_scrollback_tail
;
186 static int vgacon_scrollback_size
;
187 static int vgacon_scrollback_rows
;
188 static int vgacon_scrollback_cnt
;
189 static int vgacon_scrollback_cur
;
190 static int vgacon_scrollback_save
;
191 static int vgacon_scrollback_restore
;
193 static void vgacon_scrollback_init(int pitch
)
195 int rows
= CONFIG_VGACON_SOFT_SCROLLBACK_SIZE
* 1024/pitch
;
197 if (vgacon_scrollback
) {
198 vgacon_scrollback_cnt
= 0;
199 vgacon_scrollback_tail
= 0;
200 vgacon_scrollback_cur
= 0;
201 vgacon_scrollback_rows
= rows
- 1;
202 vgacon_scrollback_size
= rows
* pitch
;
207 * Called only duing init so call of alloc_bootmen is ok.
208 * Marked __init_refok to silence modpost.
210 static void __init_refok
vgacon_scrollback_startup(void)
212 vgacon_scrollback
= kcalloc(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE
, 1024, GFP_NOWAIT
);
213 vgacon_scrollback_init(vga_video_num_columns
* 2);
216 static void vgacon_scrollback_update(struct vc_data
*c
, int t
, int count
)
220 if (!vgacon_scrollback_size
|| c
->vc_num
!= fg_console
)
223 p
= (void *) (c
->vc_origin
+ t
* c
->vc_size_row
);
226 scr_memcpyw(vgacon_scrollback
+ vgacon_scrollback_tail
,
228 vgacon_scrollback_cnt
++;
230 vgacon_scrollback_tail
+= c
->vc_size_row
;
232 if (vgacon_scrollback_tail
>= vgacon_scrollback_size
)
233 vgacon_scrollback_tail
= 0;
235 if (vgacon_scrollback_cnt
> vgacon_scrollback_rows
)
236 vgacon_scrollback_cnt
= vgacon_scrollback_rows
;
238 vgacon_scrollback_cur
= vgacon_scrollback_cnt
;
242 static void vgacon_restore_screen(struct vc_data
*c
)
244 vgacon_scrollback_save
= 0;
246 if (!vga_is_gfx
&& !vgacon_scrollback_restore
) {
247 scr_memcpyw((u16
*) c
->vc_origin
, (u16
*) c
->vc_screenbuf
,
248 c
->vc_screenbuf_size
> vga_vram_size
?
249 vga_vram_size
: c
->vc_screenbuf_size
);
250 vgacon_scrollback_restore
= 1;
251 vgacon_scrollback_cur
= vgacon_scrollback_cnt
;
255 static int vgacon_scrolldelta(struct vc_data
*c
, int lines
)
257 int start
, end
, count
, soff
;
260 c
->vc_visible_origin
= c
->vc_origin
;
265 if (!vgacon_scrollback
)
268 if (!vgacon_scrollback_save
) {
269 vgacon_cursor(c
, CM_ERASE
);
270 vgacon_save_screen(c
);
271 vgacon_scrollback_save
= 1;
274 vgacon_scrollback_restore
= 0;
275 start
= vgacon_scrollback_cur
+ lines
;
276 end
= start
+ abs(lines
);
281 if (start
> vgacon_scrollback_cnt
)
282 start
= vgacon_scrollback_cnt
;
287 if (end
> vgacon_scrollback_cnt
)
288 end
= vgacon_scrollback_cnt
;
290 vgacon_scrollback_cur
= start
;
292 soff
= vgacon_scrollback_tail
- ((vgacon_scrollback_cnt
- end
) *
294 soff
-= count
* c
->vc_size_row
;
297 soff
+= vgacon_scrollback_size
;
299 count
= vgacon_scrollback_cnt
- start
;
301 if (count
> c
->vc_rows
)
307 int diff
= c
->vc_rows
- count
;
308 void *d
= (void *) c
->vc_origin
;
309 void *s
= (void *) c
->vc_screenbuf
;
311 count
*= c
->vc_size_row
;
312 /* how much memory to end of buffer left? */
313 copysize
= min(count
, vgacon_scrollback_size
- soff
);
314 scr_memcpyw(d
, vgacon_scrollback
+ soff
, copysize
);
319 scr_memcpyw(d
, vgacon_scrollback
, count
);
324 scr_memcpyw(d
, s
, diff
* c
->vc_size_row
);
326 vgacon_cursor(c
, CM_MOVE
);
331 #define vgacon_scrollback_startup(...) do { } while (0)
332 #define vgacon_scrollback_init(...) do { } while (0)
333 #define vgacon_scrollback_update(...) do { } while (0)
335 static void vgacon_restore_screen(struct vc_data
*c
)
337 if (c
->vc_origin
!= c
->vc_visible_origin
)
338 vgacon_scrolldelta(c
, 0);
341 static int vgacon_scrolldelta(struct vc_data
*c
, int lines
)
343 if (!lines
) /* Turn scrollback off */
344 c
->vc_visible_origin
= c
->vc_origin
;
346 int margin
= c
->vc_size_row
* 4;
349 if (vga_rolled_over
>
350 (c
->vc_scr_end
- vga_vram_base
) + margin
) {
351 ul
= c
->vc_scr_end
- vga_vram_base
;
352 we
= vga_rolled_over
+ c
->vc_size_row
;
357 p
= (c
->vc_visible_origin
- vga_vram_base
- ul
+ we
) % we
+
358 lines
* c
->vc_size_row
;
359 st
= (c
->vc_origin
- vga_vram_base
- ul
+ we
) % we
;
366 c
->vc_visible_origin
= vga_vram_base
+ (p
+ ul
) % we
;
371 #endif /* CONFIG_VGACON_SOFT_SCROLLBACK */
373 static const char *vgacon_startup(void)
375 const char *display_desc
= NULL
;
379 if (screen_info
.orig_video_isVGA
== VIDEO_TYPE_VLFB
) {
381 #ifdef CONFIG_DUMMY_CONSOLE
382 conswitchp
= &dummy_con
;
383 return conswitchp
->con_startup();
389 /* boot_params.screen_info initialized? */
390 if ((screen_info
.orig_video_mode
== 0) &&
391 (screen_info
.orig_video_lines
== 0) &&
392 (screen_info
.orig_video_cols
== 0))
395 /* VGA16 modes are not handled by VGACON */
396 if ((screen_info
.orig_video_mode
== 0x0D) || /* 320x200/4 */
397 (screen_info
.orig_video_mode
== 0x0E) || /* 640x200/4 */
398 (screen_info
.orig_video_mode
== 0x10) || /* 640x350/4 */
399 (screen_info
.orig_video_mode
== 0x12) || /* 640x480/4 */
400 (screen_info
.orig_video_mode
== 0x6A)) /* 800x600/4 (VESA) */
403 vga_video_num_lines
= screen_info
.orig_video_lines
;
404 vga_video_num_columns
= screen_info
.orig_video_cols
;
405 state
.vgabase
= NULL
;
407 if (screen_info
.orig_video_mode
== 7) {
408 /* Monochrome display */
409 vga_vram_base
= 0xb0000;
410 vga_video_port_reg
= VGA_CRT_IM
;
411 vga_video_port_val
= VGA_CRT_DM
;
412 if ((screen_info
.orig_video_ega_bx
& 0xff) != 0x10) {
413 static struct resource ega_console_resource
=
414 { .name
= "ega", .start
= 0x3B0, .end
= 0x3BF };
415 vga_video_type
= VIDEO_TYPE_EGAM
;
416 vga_vram_size
= 0x8000;
417 display_desc
= "EGA+";
418 request_resource(&ioport_resource
,
419 &ega_console_resource
);
421 static struct resource mda1_console_resource
=
422 { .name
= "mda", .start
= 0x3B0, .end
= 0x3BB };
423 static struct resource mda2_console_resource
=
424 { .name
= "mda", .start
= 0x3BF, .end
= 0x3BF };
425 vga_video_type
= VIDEO_TYPE_MDA
;
426 vga_vram_size
= 0x2000;
427 display_desc
= "*MDA";
428 request_resource(&ioport_resource
,
429 &mda1_console_resource
);
430 request_resource(&ioport_resource
,
431 &mda2_console_resource
);
432 vga_video_font_height
= 14;
435 /* If not, it is color. */
436 vga_can_do_color
= 1;
437 vga_vram_base
= 0xb8000;
438 vga_video_port_reg
= VGA_CRT_IC
;
439 vga_video_port_val
= VGA_CRT_DC
;
440 if ((screen_info
.orig_video_ega_bx
& 0xff) != 0x10) {
443 vga_vram_size
= 0x8000;
445 if (!screen_info
.orig_video_isVGA
) {
446 static struct resource ega_console_resource
447 = { .name
= "ega", .start
= 0x3C0, .end
= 0x3DF };
448 vga_video_type
= VIDEO_TYPE_EGAC
;
449 display_desc
= "EGA";
450 request_resource(&ioport_resource
,
451 &ega_console_resource
);
453 static struct resource vga_console_resource
454 = { .name
= "vga+", .start
= 0x3C0, .end
= 0x3DF };
455 vga_video_type
= VIDEO_TYPE_VGAC
;
456 display_desc
= "VGA+";
457 request_resource(&ioport_resource
,
458 &vga_console_resource
);
460 #ifdef VGA_CAN_DO_64KB
462 * get 64K rather than 32K of video RAM.
463 * This doesn't actually work on all "VGA"
464 * controllers (it seems like setting MM=01
465 * and COE=1 isn't necessarily a good idea)
467 vga_vram_base
= 0xa0000;
468 vga_vram_size
= 0x10000;
469 outb_p(6, VGA_GFX_I
);
470 outb_p(6, VGA_GFX_D
);
473 * Normalise the palette registers, to point
474 * the 16 screen colours to the first 16
478 for (i
= 0; i
< 16; i
++) {
480 outb_p(i
, VGA_ATT_W
);
481 outb_p(i
, VGA_ATT_W
);
483 outb_p(0x20, VGA_ATT_W
);
486 * Now set the DAC registers back to their
489 for (i
= 0; i
< 16; i
++) {
490 outb_p(color_table
[i
], VGA_PEL_IW
);
491 outb_p(default_red
[i
], VGA_PEL_D
);
492 outb_p(default_grn
[i
], VGA_PEL_D
);
493 outb_p(default_blu
[i
], VGA_PEL_D
);
497 static struct resource cga_console_resource
=
498 { .name
= "cga", .start
= 0x3D4, .end
= 0x3D5 };
499 vga_video_type
= VIDEO_TYPE_CGA
;
500 vga_vram_size
= 0x2000;
501 display_desc
= "*CGA";
502 request_resource(&ioport_resource
,
503 &cga_console_resource
);
504 vga_video_font_height
= 8;
508 vga_vram_base
= VGA_MAP_MEM(vga_vram_base
, vga_vram_size
);
509 vga_vram_end
= vga_vram_base
+ vga_vram_size
;
512 * Find out if there is a graphics card present.
513 * Are there smarter methods around?
515 p
= (volatile u16
*) vga_vram_base
;
516 saved1
= scr_readw(p
);
517 saved2
= scr_readw(p
+ 1);
518 scr_writew(0xAA55, p
);
519 scr_writew(0x55AA, p
+ 1);
520 if (scr_readw(p
) != 0xAA55 || scr_readw(p
+ 1) != 0x55AA) {
521 scr_writew(saved1
, p
);
522 scr_writew(saved2
, p
+ 1);
525 scr_writew(0x55AA, p
);
526 scr_writew(0xAA55, p
+ 1);
527 if (scr_readw(p
) != 0x55AA || scr_readw(p
+ 1) != 0xAA55) {
528 scr_writew(saved1
, p
);
529 scr_writew(saved2
, p
+ 1);
532 scr_writew(saved1
, p
);
533 scr_writew(saved2
, p
+ 1);
535 if (vga_video_type
== VIDEO_TYPE_EGAC
536 || vga_video_type
== VIDEO_TYPE_VGAC
537 || vga_video_type
== VIDEO_TYPE_EGAM
) {
538 vga_hardscroll_enabled
= vga_hardscroll_user_enable
;
539 vga_default_font_height
= screen_info
.orig_video_points
;
540 vga_video_font_height
= screen_info
.orig_video_points
;
541 /* This may be suboptimal but is a safe bet - go with it */
543 vga_video_font_height
* vga_video_num_lines
;
546 vgacon_xres
= screen_info
.orig_video_cols
* VGA_FONTWIDTH
;
547 vgacon_yres
= vga_scan_lines
;
549 if (!vga_init_done
) {
550 vgacon_scrollback_startup();
557 static void vgacon_init(struct vc_data
*c
, int init
)
562 * We cannot be loaded as a module, therefore init is always 1,
563 * but vgacon_init can be called more than once, and init will
566 c
->vc_can_do_color
= vga_can_do_color
;
568 /* set dimensions manually if init != 0 since vc_resize() will fail */
570 c
->vc_cols
= vga_video_num_columns
;
571 c
->vc_rows
= vga_video_num_lines
;
573 vc_resize(c
, vga_video_num_columns
, vga_video_num_lines
);
575 c
->vc_scan_lines
= vga_scan_lines
;
576 c
->vc_font
.height
= vga_video_font_height
;
577 c
->vc_complement_mask
= 0x7700;
579 c
->vc_hi_font_mask
= 0x0800;
580 p
= *c
->vc_uni_pagedir_loc
;
581 if (c
->vc_uni_pagedir_loc
== &c
->vc_uni_pagedir
||
582 !--c
->vc_uni_pagedir_loc
[1])
584 c
->vc_uni_pagedir_loc
= vgacon_uni_pagedir
;
585 vgacon_uni_pagedir
[1]++;
586 if (!vgacon_uni_pagedir
[0] && p
)
587 con_set_default_unimap(c
);
589 hide_boot_cursor(screen_info
.flags
& VIDEO_FLAGS_NOCURSOR
);
592 static void vgacon_deinit(struct vc_data
*c
)
594 /* When closing the active console, reset video origin */
595 if (CON_IS_VISIBLE(c
)) {
596 c
->vc_visible_origin
= vga_vram_base
;
600 if (!--vgacon_uni_pagedir
[1])
602 c
->vc_uni_pagedir_loc
= &c
->vc_uni_pagedir
;
603 con_set_default_unimap(c
);
606 static u8
vgacon_build_attr(struct vc_data
*c
, u8 color
, u8 intensity
,
607 u8 blink
, u8 underline
, u8 reverse
, u8 italic
)
611 if (vga_can_do_color
) {
613 attr
= (attr
& 0xF0) | c
->vc_itcolor
;
615 attr
= (attr
& 0xf0) | c
->vc_ulcolor
;
616 else if (intensity
== 0)
617 attr
= (attr
& 0xf0) | c
->vc_halfcolor
;
621 ((attr
) & 0x88) | ((((attr
) >> 4) | ((attr
) << 4)) &
627 if (!vga_can_do_color
) {
629 attr
= (attr
& 0xF8) | 0x02;
631 attr
= (attr
& 0xf8) | 0x01;
632 else if (intensity
== 0)
633 attr
= (attr
& 0xf0) | 0x08;
638 static void vgacon_invert_region(struct vc_data
*c
, u16
* p
, int count
)
640 int col
= vga_can_do_color
;
643 u16 a
= scr_readw(p
);
645 a
= ((a
) & 0x88ff) | (((a
) & 0x7000) >> 4) |
646 (((a
) & 0x0700) << 4);
648 a
^= ((a
& 0x0700) == 0x0100) ? 0x7000 : 0x7700;
653 static void vgacon_set_cursor_size(int xpos
, int from
, int to
)
658 #ifdef TRIDENT_GLITCH
663 if ((from
== cursor_size_lastfrom
) && (to
== cursor_size_lastto
))
665 cursor_size_lastfrom
= from
;
666 cursor_size_lastto
= to
;
668 spin_lock_irqsave(&vga_lock
, flags
);
669 if (vga_video_type
>= VIDEO_TYPE_VGAC
) {
670 outb_p(VGA_CRTC_CURSOR_START
, vga_video_port_reg
);
671 curs
= inb_p(vga_video_port_val
);
672 outb_p(VGA_CRTC_CURSOR_END
, vga_video_port_reg
);
673 cure
= inb_p(vga_video_port_val
);
679 curs
= (curs
& 0xc0) | from
;
680 cure
= (cure
& 0xe0) | to
;
682 outb_p(VGA_CRTC_CURSOR_START
, vga_video_port_reg
);
683 outb_p(curs
, vga_video_port_val
);
684 outb_p(VGA_CRTC_CURSOR_END
, vga_video_port_reg
);
685 outb_p(cure
, vga_video_port_val
);
686 spin_unlock_irqrestore(&vga_lock
, flags
);
689 static void vgacon_cursor(struct vc_data
*c
, int mode
)
691 if (c
->vc_mode
!= KD_TEXT
)
694 vgacon_restore_screen(c
);
698 write_vga(14, (c
->vc_pos
- vga_vram_base
) / 2);
699 if (vga_video_type
>= VIDEO_TYPE_VGAC
)
700 vgacon_set_cursor_size(c
->vc_x
, 31, 30);
702 vgacon_set_cursor_size(c
->vc_x
, 31, 31);
707 write_vga(14, (c
->vc_pos
- vga_vram_base
) / 2);
708 switch (c
->vc_cursor_type
& 0x0f) {
710 vgacon_set_cursor_size(c
->vc_x
,
719 vgacon_set_cursor_size(c
->vc_x
,
720 c
->vc_font
.height
/ 3,
725 case CUR_LOWER_THIRD
:
726 vgacon_set_cursor_size(c
->vc_x
,
727 (c
->vc_font
.height
* 2) / 3,
733 vgacon_set_cursor_size(c
->vc_x
,
734 c
->vc_font
.height
/ 2,
740 if (vga_video_type
>= VIDEO_TYPE_VGAC
)
741 vgacon_set_cursor_size(c
->vc_x
, 31, 30);
743 vgacon_set_cursor_size(c
->vc_x
, 31, 31);
746 vgacon_set_cursor_size(c
->vc_x
, 1,
754 static int vgacon_doresize(struct vc_data
*c
,
755 unsigned int width
, unsigned int height
)
758 unsigned int scanlines
= height
* c
->vc_font
.height
;
759 u8 scanlines_lo
= 0, r7
= 0, vsync_end
= 0, mode
, max_scan
;
761 spin_lock_irqsave(&vga_lock
, flags
);
763 vgacon_xres
= width
* VGA_FONTWIDTH
;
764 vgacon_yres
= height
* c
->vc_font
.height
;
765 if (vga_video_type
>= VIDEO_TYPE_VGAC
) {
766 outb_p(VGA_CRTC_MAX_SCAN
, vga_video_port_reg
);
767 max_scan
= inb_p(vga_video_port_val
);
772 outb_p(VGA_CRTC_MODE
, vga_video_port_reg
);
773 mode
= inb_p(vga_video_port_val
);
779 scanlines_lo
= scanlines
& 0xff;
781 outb_p(VGA_CRTC_OVERFLOW
, vga_video_port_reg
);
782 r7
= inb_p(vga_video_port_val
) & ~0x42;
784 if (scanlines
& 0x100)
786 if (scanlines
& 0x200)
789 /* deprotect registers */
790 outb_p(VGA_CRTC_V_SYNC_END
, vga_video_port_reg
);
791 vsync_end
= inb_p(vga_video_port_val
);
792 outb_p(VGA_CRTC_V_SYNC_END
, vga_video_port_reg
);
793 outb_p(vsync_end
& ~0x80, vga_video_port_val
);
796 outb_p(VGA_CRTC_H_DISP
, vga_video_port_reg
);
797 outb_p(width
- 1, vga_video_port_val
);
798 outb_p(VGA_CRTC_OFFSET
, vga_video_port_reg
);
799 outb_p(width
>> 1, vga_video_port_val
);
801 if (vga_video_type
>= VIDEO_TYPE_VGAC
) {
802 outb_p(VGA_CRTC_V_DISP_END
, vga_video_port_reg
);
803 outb_p(scanlines_lo
, vga_video_port_val
);
804 outb_p(VGA_CRTC_OVERFLOW
, vga_video_port_reg
);
805 outb_p(r7
,vga_video_port_val
);
807 /* reprotect registers */
808 outb_p(VGA_CRTC_V_SYNC_END
, vga_video_port_reg
);
809 outb_p(vsync_end
, vga_video_port_val
);
812 spin_unlock_irqrestore(&vga_lock
, flags
);
816 static int vgacon_switch(struct vc_data
*c
)
818 int x
= c
->vc_cols
* VGA_FONTWIDTH
;
819 int y
= c
->vc_rows
* c
->vc_font
.height
;
820 int rows
= screen_info
.orig_video_lines
* vga_default_font_height
/
823 * We need to save screen size here as it's the only way
824 * we can spot the screen has been resized and we need to
825 * set size of freshly allocated screens ourselves.
827 vga_video_num_columns
= c
->vc_cols
;
828 vga_video_num_lines
= c
->vc_rows
;
830 /* We can only copy out the size of the video buffer here,
831 * otherwise we get into VGA BIOS */
834 scr_memcpyw((u16
*) c
->vc_origin
, (u16
*) c
->vc_screenbuf
,
835 c
->vc_screenbuf_size
> vga_vram_size
?
836 vga_vram_size
: c
->vc_screenbuf_size
);
838 if ((vgacon_xres
!= x
|| vgacon_yres
!= y
) &&
839 (!(vga_video_num_columns
% 2) &&
840 vga_video_num_columns
<= screen_info
.orig_video_cols
&&
841 vga_video_num_lines
<= rows
))
842 vgacon_doresize(c
, c
->vc_cols
, c
->vc_rows
);
845 vgacon_scrollback_init(c
->vc_size_row
);
846 return 0; /* Redrawing not needed */
849 static void vga_set_palette(struct vc_data
*vc
, unsigned char *table
)
853 vga_w(state
.vgabase
, VGA_PEL_MSK
, 0xff);
854 for (i
= j
= 0; i
< 16; i
++) {
855 vga_w(state
.vgabase
, VGA_PEL_IW
, table
[i
]);
856 vga_w(state
.vgabase
, VGA_PEL_D
, vc
->vc_palette
[j
++] >> 2);
857 vga_w(state
.vgabase
, VGA_PEL_D
, vc
->vc_palette
[j
++] >> 2);
858 vga_w(state
.vgabase
, VGA_PEL_D
, vc
->vc_palette
[j
++] >> 2);
862 static int vgacon_set_palette(struct vc_data
*vc
, unsigned char *table
)
864 #ifdef CAN_LOAD_PALETTE
865 if (vga_video_type
!= VIDEO_TYPE_VGAC
|| vga_palette_blanked
866 || !CON_IS_VISIBLE(vc
))
868 vga_set_palette(vc
, table
);
875 /* structure holding original VGA register settings */
877 unsigned char SeqCtrlIndex
; /* Sequencer Index reg. */
878 unsigned char CrtCtrlIndex
; /* CRT-Contr. Index reg. */
879 unsigned char CrtMiscIO
; /* Miscellaneous register */
880 unsigned char HorizontalTotal
; /* CRT-Controller:00h */
881 unsigned char HorizDisplayEnd
; /* CRT-Controller:01h */
882 unsigned char StartHorizRetrace
; /* CRT-Controller:04h */
883 unsigned char EndHorizRetrace
; /* CRT-Controller:05h */
884 unsigned char Overflow
; /* CRT-Controller:07h */
885 unsigned char StartVertRetrace
; /* CRT-Controller:10h */
886 unsigned char EndVertRetrace
; /* CRT-Controller:11h */
887 unsigned char ModeControl
; /* CRT-Controller:17h */
888 unsigned char ClockingMode
; /* Seq-Controller:01h */
891 static void vga_vesa_blank(struct vgastate
*state
, int mode
)
893 /* save original values of VGA controller registers */
894 if (!vga_vesa_blanked
) {
895 spin_lock_irq(&vga_lock
);
896 vga_state
.SeqCtrlIndex
= vga_r(state
->vgabase
, VGA_SEQ_I
);
897 vga_state
.CrtCtrlIndex
= inb_p(vga_video_port_reg
);
898 vga_state
.CrtMiscIO
= vga_r(state
->vgabase
, VGA_MIS_R
);
899 spin_unlock_irq(&vga_lock
);
901 outb_p(0x00, vga_video_port_reg
); /* HorizontalTotal */
902 vga_state
.HorizontalTotal
= inb_p(vga_video_port_val
);
903 outb_p(0x01, vga_video_port_reg
); /* HorizDisplayEnd */
904 vga_state
.HorizDisplayEnd
= inb_p(vga_video_port_val
);
905 outb_p(0x04, vga_video_port_reg
); /* StartHorizRetrace */
906 vga_state
.StartHorizRetrace
= inb_p(vga_video_port_val
);
907 outb_p(0x05, vga_video_port_reg
); /* EndHorizRetrace */
908 vga_state
.EndHorizRetrace
= inb_p(vga_video_port_val
);
909 outb_p(0x07, vga_video_port_reg
); /* Overflow */
910 vga_state
.Overflow
= inb_p(vga_video_port_val
);
911 outb_p(0x10, vga_video_port_reg
); /* StartVertRetrace */
912 vga_state
.StartVertRetrace
= inb_p(vga_video_port_val
);
913 outb_p(0x11, vga_video_port_reg
); /* EndVertRetrace */
914 vga_state
.EndVertRetrace
= inb_p(vga_video_port_val
);
915 outb_p(0x17, vga_video_port_reg
); /* ModeControl */
916 vga_state
.ModeControl
= inb_p(vga_video_port_val
);
917 vga_state
.ClockingMode
= vga_rseq(state
->vgabase
, VGA_SEQ_CLOCK_MODE
);
920 /* assure that video is enabled */
921 /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */
922 spin_lock_irq(&vga_lock
);
923 vga_wseq(state
->vgabase
, VGA_SEQ_CLOCK_MODE
, vga_state
.ClockingMode
| 0x20);
925 /* test for vertical retrace in process.... */
926 if ((vga_state
.CrtMiscIO
& 0x80) == 0x80)
927 vga_w(state
->vgabase
, VGA_MIS_W
, vga_state
.CrtMiscIO
& 0xEF);
930 * Set <End of vertical retrace> to minimum (0) and
931 * <Start of vertical Retrace> to maximum (incl. overflow)
932 * Result: turn off vertical sync (VSync) pulse.
934 if (mode
& VESA_VSYNC_SUSPEND
) {
935 outb_p(0x10, vga_video_port_reg
); /* StartVertRetrace */
936 outb_p(0xff, vga_video_port_val
); /* maximum value */
937 outb_p(0x11, vga_video_port_reg
); /* EndVertRetrace */
938 outb_p(0x40, vga_video_port_val
); /* minimum (bits 0..3) */
939 outb_p(0x07, vga_video_port_reg
); /* Overflow */
940 outb_p(vga_state
.Overflow
| 0x84, vga_video_port_val
); /* bits 9,10 of vert. retrace */
943 if (mode
& VESA_HSYNC_SUSPEND
) {
945 * Set <End of horizontal retrace> to minimum (0) and
946 * <Start of horizontal Retrace> to maximum
947 * Result: turn off horizontal sync (HSync) pulse.
949 outb_p(0x04, vga_video_port_reg
); /* StartHorizRetrace */
950 outb_p(0xff, vga_video_port_val
); /* maximum */
951 outb_p(0x05, vga_video_port_reg
); /* EndHorizRetrace */
952 outb_p(0x00, vga_video_port_val
); /* minimum (0) */
955 /* restore both index registers */
956 vga_w(state
->vgabase
, VGA_SEQ_I
, vga_state
.SeqCtrlIndex
);
957 outb_p(vga_state
.CrtCtrlIndex
, vga_video_port_reg
);
958 spin_unlock_irq(&vga_lock
);
961 static void vga_vesa_unblank(struct vgastate
*state
)
963 /* restore original values of VGA controller registers */
964 spin_lock_irq(&vga_lock
);
965 vga_w(state
->vgabase
, VGA_MIS_W
, vga_state
.CrtMiscIO
);
967 outb_p(0x00, vga_video_port_reg
); /* HorizontalTotal */
968 outb_p(vga_state
.HorizontalTotal
, vga_video_port_val
);
969 outb_p(0x01, vga_video_port_reg
); /* HorizDisplayEnd */
970 outb_p(vga_state
.HorizDisplayEnd
, vga_video_port_val
);
971 outb_p(0x04, vga_video_port_reg
); /* StartHorizRetrace */
972 outb_p(vga_state
.StartHorizRetrace
, vga_video_port_val
);
973 outb_p(0x05, vga_video_port_reg
); /* EndHorizRetrace */
974 outb_p(vga_state
.EndHorizRetrace
, vga_video_port_val
);
975 outb_p(0x07, vga_video_port_reg
); /* Overflow */
976 outb_p(vga_state
.Overflow
, vga_video_port_val
);
977 outb_p(0x10, vga_video_port_reg
); /* StartVertRetrace */
978 outb_p(vga_state
.StartVertRetrace
, vga_video_port_val
);
979 outb_p(0x11, vga_video_port_reg
); /* EndVertRetrace */
980 outb_p(vga_state
.EndVertRetrace
, vga_video_port_val
);
981 outb_p(0x17, vga_video_port_reg
); /* ModeControl */
982 outb_p(vga_state
.ModeControl
, vga_video_port_val
);
984 vga_wseq(state
->vgabase
, VGA_SEQ_CLOCK_MODE
, vga_state
.ClockingMode
);
986 /* restore index/control registers */
987 vga_w(state
->vgabase
, VGA_SEQ_I
, vga_state
.SeqCtrlIndex
);
988 outb_p(vga_state
.CrtCtrlIndex
, vga_video_port_reg
);
989 spin_unlock_irq(&vga_lock
);
992 static void vga_pal_blank(struct vgastate
*state
)
996 vga_w(state
->vgabase
, VGA_PEL_MSK
, 0xff);
997 for (i
= 0; i
< 16; i
++) {
998 vga_w(state
->vgabase
, VGA_PEL_IW
, i
);
999 vga_w(state
->vgabase
, VGA_PEL_D
, 0);
1000 vga_w(state
->vgabase
, VGA_PEL_D
, 0);
1001 vga_w(state
->vgabase
, VGA_PEL_D
, 0);
1005 static int vgacon_blank(struct vc_data
*c
, int blank
, int mode_switch
)
1008 case 0: /* Unblank */
1009 if (vga_vesa_blanked
) {
1010 vga_vesa_unblank(&state
);
1011 vga_vesa_blanked
= 0;
1013 if (vga_palette_blanked
) {
1014 vga_set_palette(c
, color_table
);
1015 vga_palette_blanked
= 0;
1019 /* Tell console.c that it has to restore the screen itself */
1021 case 1: /* Normal blanking */
1022 case -1: /* Obsolete */
1023 if (!mode_switch
&& vga_video_type
== VIDEO_TYPE_VGAC
) {
1024 vga_pal_blank(&state
);
1025 vga_palette_blanked
= 1;
1028 vgacon_set_origin(c
);
1029 scr_memsetw((void *) vga_vram_base
, BLANK
,
1030 c
->vc_screenbuf_size
);
1034 default: /* VESA blanking */
1035 if (vga_video_type
== VIDEO_TYPE_VGAC
) {
1036 vga_vesa_blank(&state
, blank
- 1);
1037 vga_vesa_blanked
= blank
;
1046 * The font loading code goes back to the codepage package by
1047 * Joel Hoffman (joel@wam.umd.edu). (He reports that the original
1048 * reference is: "From: p. 307 of _Programmer's Guide to PC & PS/2
1049 * Video Systems_ by Richard Wilton. 1987. Microsoft Press".)
1051 * Change for certain monochrome monitors by Yury Shevchuck
1052 * (sizif@botik.yaroslavl.su).
1055 #ifdef CAN_LOAD_EGA_FONTS
1057 #define colourmap 0xa0000
1058 /* Pauline Middelink <middelin@polyware.iaf.nl> reports that we
1059 should use 0xA0000 for the bwmap as well.. */
1060 #define blackwmap 0xa0000
1063 static int vgacon_do_font_op(struct vgastate
*state
,char *arg
,int set
,int ch512
)
1065 unsigned short video_port_status
= vga_video_port_reg
+ 6;
1066 int font_select
= 0x00, beg
, i
;
1069 if (vga_video_type
!= VIDEO_TYPE_EGAM
) {
1070 charmap
= (char *) VGA_MAP_MEM(colourmap
, 0);
1072 #ifdef VGA_CAN_DO_64KB
1073 if (vga_video_type
== VIDEO_TYPE_VGAC
)
1077 charmap
= (char *) VGA_MAP_MEM(blackwmap
, 0);
1081 #ifdef BROKEN_GRAPHICS_PROGRAMS
1083 * All fonts are loaded in slot 0 (0:1 for 512 ch)
1087 return -EINVAL
; /* Return to default font not supported */
1089 vga_font_is_default
= 0;
1090 font_select
= ch512
? 0x04 : 0x00;
1093 * The default font is kept in slot 0 and is never touched.
1094 * A custom font is loaded in slot 2 (256 ch) or 2:3 (512 ch)
1098 vga_font_is_default
= !arg
;
1100 ch512
= 0; /* Default font is always 256 */
1101 font_select
= arg
? (ch512
? 0x0e : 0x0a) : 0x00;
1104 if (!vga_font_is_default
)
1105 charmap
+= 4 * cmapsz
;
1109 spin_lock_irq(&vga_lock
);
1110 /* First, the Sequencer */
1111 vga_wseq(state
->vgabase
, VGA_SEQ_RESET
, 0x1);
1112 /* CPU writes only to map 2 */
1113 vga_wseq(state
->vgabase
, VGA_SEQ_PLANE_WRITE
, 0x04);
1114 /* Sequential addressing */
1115 vga_wseq(state
->vgabase
, VGA_SEQ_MEMORY_MODE
, 0x07);
1116 /* Clear synchronous reset */
1117 vga_wseq(state
->vgabase
, VGA_SEQ_RESET
, 0x03);
1119 /* Now, the graphics controller, select map 2 */
1120 vga_wgfx(state
->vgabase
, VGA_GFX_PLANE_READ
, 0x02);
1121 /* disable odd-even addressing */
1122 vga_wgfx(state
->vgabase
, VGA_GFX_MODE
, 0x00);
1123 /* map start at A000:0000 */
1124 vga_wgfx(state
->vgabase
, VGA_GFX_MISC
, 0x00);
1125 spin_unlock_irq(&vga_lock
);
1129 for (i
= 0; i
< cmapsz
; i
++)
1130 vga_writeb(arg
[i
], charmap
+ i
);
1132 for (i
= 0; i
< cmapsz
; i
++)
1133 arg
[i
] = vga_readb(charmap
+ i
);
1136 * In 512-character mode, the character map is not contiguous if
1137 * we want to remain EGA compatible -- which we do
1141 charmap
+= 2 * cmapsz
;
1144 for (i
= 0; i
< cmapsz
; i
++)
1145 vga_writeb(arg
[i
], charmap
+ i
);
1147 for (i
= 0; i
< cmapsz
; i
++)
1148 arg
[i
] = vga_readb(charmap
+ i
);
1152 spin_lock_irq(&vga_lock
);
1153 /* First, the sequencer, Synchronous reset */
1154 vga_wseq(state
->vgabase
, VGA_SEQ_RESET
, 0x01);
1155 /* CPU writes to maps 0 and 1 */
1156 vga_wseq(state
->vgabase
, VGA_SEQ_PLANE_WRITE
, 0x03);
1157 /* odd-even addressing */
1158 vga_wseq(state
->vgabase
, VGA_SEQ_MEMORY_MODE
, 0x03);
1159 /* Character Map Select */
1161 vga_wseq(state
->vgabase
, VGA_SEQ_CHARACTER_MAP
, font_select
);
1162 /* clear synchronous reset */
1163 vga_wseq(state
->vgabase
, VGA_SEQ_RESET
, 0x03);
1165 /* Now, the graphics controller, select map 0 for CPU */
1166 vga_wgfx(state
->vgabase
, VGA_GFX_PLANE_READ
, 0x00);
1167 /* enable even-odd addressing */
1168 vga_wgfx(state
->vgabase
, VGA_GFX_MODE
, 0x10);
1169 /* map starts at b800:0 or b000:0 */
1170 vga_wgfx(state
->vgabase
, VGA_GFX_MISC
, beg
);
1172 /* if 512 char mode is already enabled don't re-enable it. */
1173 if ((set
) && (ch512
!= vga_512_chars
)) {
1174 /* attribute controller */
1175 for (i
= 0; i
< MAX_NR_CONSOLES
; i
++) {
1176 struct vc_data
*c
= vc_cons
[i
].d
;
1177 if (c
&& c
->vc_sw
== &vga_con
)
1178 c
->vc_hi_font_mask
= ch512
? 0x0800 : 0;
1180 vga_512_chars
= ch512
;
1181 /* 256-char: enable intensity bit
1182 512-char: disable intensity bit */
1183 inb_p(video_port_status
); /* clear address flip-flop */
1184 /* color plane enable register */
1185 vga_wattr(state
->vgabase
, VGA_ATC_PLANE_ENABLE
, ch512
? 0x07 : 0x0f);
1186 /* Wilton (1987) mentions the following; I don't know what
1187 it means, but it works, and it appears necessary */
1188 inb_p(video_port_status
);
1189 vga_wattr(state
->vgabase
, VGA_AR_ENABLE_DISPLAY
, 0);
1191 spin_unlock_irq(&vga_lock
);
1197 * Adjust the screen to fit a font of a certain height
1199 static int vgacon_adjust_height(struct vc_data
*vc
, unsigned fontheight
)
1201 unsigned char ovr
, vde
, fsr
;
1202 int rows
, maxscan
, i
;
1204 rows
= vc
->vc_scan_lines
/ fontheight
; /* Number of video rows we end up with */
1205 maxscan
= rows
* fontheight
- 1; /* Scan lines to actually display-1 */
1207 /* Reprogram the CRTC for the new font size
1208 Note: the attempt to read the overflow register will fail
1209 on an EGA, but using 0xff for the previous value appears to
1210 be OK for EGA text modes in the range 257-512 scan lines, so I
1211 guess we don't need to worry about it.
1213 The same applies for the spill bits in the font size and cursor
1214 registers; they are write-only on EGA, but it appears that they
1215 are all don't care bits on EGA, so I guess it doesn't matter. */
1217 spin_lock_irq(&vga_lock
);
1218 outb_p(0x07, vga_video_port_reg
); /* CRTC overflow register */
1219 ovr
= inb_p(vga_video_port_val
);
1220 outb_p(0x09, vga_video_port_reg
); /* Font size register */
1221 fsr
= inb_p(vga_video_port_val
);
1222 spin_unlock_irq(&vga_lock
);
1224 vde
= maxscan
& 0xff; /* Vertical display end reg */
1225 ovr
= (ovr
& 0xbd) + /* Overflow register */
1226 ((maxscan
& 0x100) >> 7) + ((maxscan
& 0x200) >> 3);
1227 fsr
= (fsr
& 0xe0) + (fontheight
- 1); /* Font size register */
1229 spin_lock_irq(&vga_lock
);
1230 outb_p(0x07, vga_video_port_reg
); /* CRTC overflow register */
1231 outb_p(ovr
, vga_video_port_val
);
1232 outb_p(0x09, vga_video_port_reg
); /* Font size */
1233 outb_p(fsr
, vga_video_port_val
);
1234 outb_p(0x12, vga_video_port_reg
); /* Vertical display limit */
1235 outb_p(vde
, vga_video_port_val
);
1236 spin_unlock_irq(&vga_lock
);
1237 vga_video_font_height
= fontheight
;
1239 for (i
= 0; i
< MAX_NR_CONSOLES
; i
++) {
1240 struct vc_data
*c
= vc_cons
[i
].d
;
1242 if (c
&& c
->vc_sw
== &vga_con
) {
1243 if (CON_IS_VISIBLE(c
)) {
1244 /* void size to cause regs to be rewritten */
1245 cursor_size_lastfrom
= 0;
1246 cursor_size_lastto
= 0;
1247 c
->vc_sw
->con_cursor(c
, CM_DRAW
);
1249 c
->vc_font
.height
= fontheight
;
1250 vc_resize(c
, 0, rows
); /* Adjust console size */
1256 static int vgacon_font_set(struct vc_data
*c
, struct console_font
*font
, unsigned flags
)
1258 unsigned charcount
= font
->charcount
;
1261 if (vga_video_type
< VIDEO_TYPE_EGAM
)
1264 if (font
->width
!= VGA_FONTWIDTH
||
1265 (charcount
!= 256 && charcount
!= 512))
1268 rc
= vgacon_do_font_op(&state
, font
->data
, 1, charcount
== 512);
1272 if (!(flags
& KD_FONT_FLAG_DONT_RECALC
))
1273 rc
= vgacon_adjust_height(c
, font
->height
);
1277 static int vgacon_font_get(struct vc_data
*c
, struct console_font
*font
)
1279 if (vga_video_type
< VIDEO_TYPE_EGAM
)
1282 font
->width
= VGA_FONTWIDTH
;
1283 font
->height
= c
->vc_font
.height
;
1284 font
->charcount
= vga_512_chars
? 512 : 256;
1287 return vgacon_do_font_op(&state
, font
->data
, 0, vga_512_chars
);
1292 #define vgacon_font_set NULL
1293 #define vgacon_font_get NULL
1297 static int vgacon_resize(struct vc_data
*c
, unsigned int width
,
1298 unsigned int height
, unsigned int user
)
1300 if (width
% 2 || width
> screen_info
.orig_video_cols
||
1301 height
> (screen_info
.orig_video_lines
* vga_default_font_height
)/
1303 /* let svgatextmode tinker with video timings and
1305 return (user
) ? 0 : -EINVAL
;
1307 if (CON_IS_VISIBLE(c
) && !vga_is_gfx
) /* who knows */
1308 vgacon_doresize(c
, width
, height
);
1312 static int vgacon_set_origin(struct vc_data
*c
)
1314 if (vga_is_gfx
|| /* We don't play origin tricks in graphic modes */
1315 (console_blanked
&& !vga_palette_blanked
)) /* Nor we write to blanked screens */
1317 c
->vc_origin
= c
->vc_visible_origin
= vga_vram_base
;
1319 vga_rolled_over
= 0;
1323 static void vgacon_save_screen(struct vc_data
*c
)
1325 static int vga_bootup_console
= 0;
1327 if (!vga_bootup_console
) {
1328 /* This is a gross hack, but here is the only place we can
1329 * set bootup console parameters without messing up generic
1330 * console initialization routines.
1332 vga_bootup_console
= 1;
1333 c
->vc_x
= screen_info
.orig_x
;
1334 c
->vc_y
= screen_info
.orig_y
;
1337 /* We can't copy in more than the size of the video buffer,
1338 * or we'll be copying in VGA BIOS */
1341 scr_memcpyw((u16
*) c
->vc_screenbuf
, (u16
*) c
->vc_origin
,
1342 c
->vc_screenbuf_size
> vga_vram_size
? vga_vram_size
: c
->vc_screenbuf_size
);
1345 static int vgacon_scroll(struct vc_data
*c
, int t
, int b
, int dir
,
1351 if (t
|| b
!= c
->vc_rows
|| vga_is_gfx
|| c
->vc_mode
!= KD_TEXT
)
1354 if (!vga_hardscroll_enabled
|| lines
>= c
->vc_rows
/ 2)
1357 vgacon_restore_screen(c
);
1358 oldo
= c
->vc_origin
;
1359 delta
= lines
* c
->vc_size_row
;
1361 vgacon_scrollback_update(c
, t
, lines
);
1362 if (c
->vc_scr_end
+ delta
>= vga_vram_end
) {
1363 scr_memcpyw((u16
*) vga_vram_base
,
1364 (u16
*) (oldo
+ delta
),
1365 c
->vc_screenbuf_size
- delta
);
1366 c
->vc_origin
= vga_vram_base
;
1367 vga_rolled_over
= oldo
- vga_vram_base
;
1369 c
->vc_origin
+= delta
;
1370 scr_memsetw((u16
*) (c
->vc_origin
+ c
->vc_screenbuf_size
-
1371 delta
), c
->vc_video_erase_char
,
1374 if (oldo
- delta
< vga_vram_base
) {
1375 scr_memmovew((u16
*) (vga_vram_end
-
1376 c
->vc_screenbuf_size
+
1377 delta
), (u16
*) oldo
,
1378 c
->vc_screenbuf_size
- delta
);
1379 c
->vc_origin
= vga_vram_end
- c
->vc_screenbuf_size
;
1380 vga_rolled_over
= 0;
1382 c
->vc_origin
-= delta
;
1383 c
->vc_scr_end
= c
->vc_origin
+ c
->vc_screenbuf_size
;
1384 scr_memsetw((u16
*) (c
->vc_origin
), c
->vc_video_erase_char
,
1387 c
->vc_scr_end
= c
->vc_origin
+ c
->vc_screenbuf_size
;
1388 c
->vc_visible_origin
= c
->vc_origin
;
1390 c
->vc_pos
= (c
->vc_pos
- oldo
) + c
->vc_origin
;
1396 * The console `switch' structure for the VGA based console
1399 static int vgacon_dummy(struct vc_data
*c
)
1404 #define DUMMY (void *) vgacon_dummy
1406 const struct consw vga_con
= {
1407 .owner
= THIS_MODULE
,
1408 .con_startup
= vgacon_startup
,
1409 .con_init
= vgacon_init
,
1410 .con_deinit
= vgacon_deinit
,
1414 .con_cursor
= vgacon_cursor
,
1415 .con_scroll
= vgacon_scroll
,
1417 .con_switch
= vgacon_switch
,
1418 .con_blank
= vgacon_blank
,
1419 .con_font_set
= vgacon_font_set
,
1420 .con_font_get
= vgacon_font_get
,
1421 .con_resize
= vgacon_resize
,
1422 .con_set_palette
= vgacon_set_palette
,
1423 .con_scrolldelta
= vgacon_scrolldelta
,
1424 .con_set_origin
= vgacon_set_origin
,
1425 .con_save_screen
= vgacon_save_screen
,
1426 .con_build_attr
= vgacon_build_attr
,
1427 .con_invert_region
= vgacon_invert_region
,
1430 MODULE_LICENSE("GPL");