Merge branch 'master'
[linux-2.6] / drivers / video / console / vgacon.c
1 /*
2  *  linux/drivers/video/vgacon.c -- Low level VGA based console driver
3  *
4  *      Created 28 Sep 1997 by Geert Uytterhoeven
5  *
6  *      Rewritten by Martin Mares <mj@ucw.cz>, July 1998
7  *
8  *  This file is based on the old console.c, vga.c and vesa_blank.c drivers.
9  *
10  *      Copyright (C) 1991, 1992  Linus Torvalds
11  *                          1995  Jay Estabrook
12  *
13  *      User definable mapping table and font loading by Eugene G. Crosser,
14  *      <crosser@average.org>
15  *
16  *      Improved loadable font/UTF-8 support by H. Peter Anvin
17  *      Feb-Sep 1995 <peter.anvin@linux.org>
18  *
19  *      Colour palette handling, by Simon Tatham
20  *      17-Jun-95 <sgt20@cam.ac.uk>
21  *
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>
25  *
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.
29  *
30  *
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
33  *  more details.
34  */
35
36 #include <linux/config.h>
37 #include <linux/module.h>
38 #include <linux/types.h>
39 #include <linux/sched.h>
40 #include <linux/fs.h>
41 #include <linux/kernel.h>
42 #include <linux/tty.h>
43 #include <linux/console.h>
44 #include <linux/string.h>
45 #include <linux/kd.h>
46 #include <linux/slab.h>
47 #include <linux/vt_kern.h>
48 #include <linux/selection.h>
49 #include <linux/spinlock.h>
50 #include <linux/ioport.h>
51 #include <linux/init.h>
52 #include <linux/smp_lock.h>
53 #include <video/vga.h>
54 #include <asm/io.h>
55
56 static DEFINE_SPINLOCK(vga_lock);
57 static int cursor_size_lastfrom;
58 static int cursor_size_lastto;
59 static u32 vgacon_xres;
60 static u32 vgacon_yres;
61 static struct vgastate state;
62
63 #define BLANK 0x0020
64
65 #define CAN_LOAD_EGA_FONTS      /* undefine if the user must not do this */
66 #define CAN_LOAD_PALETTE        /* undefine if the user must not do this */
67
68 /* You really do _NOT_ want to define this, unless you have buggy
69  * Trident VGA which will resize cursor when moving it between column
70  * 15 & 16. If you define this and your VGA is OK, inverse bug will
71  * appear.
72  */
73 #undef TRIDENT_GLITCH
74 #define VGA_FONTWIDTH       8   /* VGA does not support fontwidths != 8 */
75 /*
76  *  Interface used by the world
77  */
78
79 static const char *vgacon_startup(void);
80 static void vgacon_init(struct vc_data *c, int init);
81 static void vgacon_deinit(struct vc_data *c);
82 static void vgacon_cursor(struct vc_data *c, int mode);
83 static int vgacon_switch(struct vc_data *c);
84 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch);
85 static int vgacon_set_palette(struct vc_data *vc, unsigned char *table);
86 static int vgacon_scrolldelta(struct vc_data *c, int lines);
87 static int vgacon_set_origin(struct vc_data *c);
88 static void vgacon_save_screen(struct vc_data *c);
89 static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
90                          int lines);
91 static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
92                             u8 blink, u8 underline, u8 reverse);
93 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count);
94 static unsigned long vgacon_uni_pagedir[2];
95
96
97 /* Description of the hardware situation */
98 static unsigned long    vga_vram_base;          /* Base of video memory */
99 static unsigned long    vga_vram_end;           /* End of video memory */
100 static int              vga_vram_size;          /* Size of video memory */
101 static u16              vga_video_port_reg;     /* Video register select port */
102 static u16              vga_video_port_val;     /* Video register value port */
103 static unsigned int     vga_video_num_columns;  /* Number of text columns */
104 static unsigned int     vga_video_num_lines;    /* Number of text lines */
105 static int              vga_can_do_color = 0;   /* Do we support colors? */
106 static unsigned int     vga_default_font_height;/* Height of default screen font */
107 static unsigned char    vga_video_type;         /* Card type */
108 static unsigned char    vga_hardscroll_enabled;
109 static unsigned char    vga_hardscroll_user_enable = 1;
110 static unsigned char    vga_font_is_default = 1;
111 static int              vga_vesa_blanked;
112 static int              vga_palette_blanked;
113 static int              vga_is_gfx;
114 static int              vga_512_chars;
115 static int              vga_video_font_height;
116 static int              vga_scan_lines;
117 static unsigned int     vga_rolled_over = 0;
118
119 static int __init no_scroll(char *str)
120 {
121         /*
122          * Disabling scrollback is required for the Braillex ib80-piezo
123          * Braille reader made by F.H. Papenmeier (Germany).
124          * Use the "no-scroll" bootflag.
125          */
126         vga_hardscroll_user_enable = vga_hardscroll_enabled = 0;
127         return 1;
128 }
129
130 __setup("no-scroll", no_scroll);
131
132 /*
133  * By replacing the four outb_p with two back to back outw, we can reduce
134  * the window of opportunity to see text mislocated to the RHS of the
135  * console during heavy scrolling activity. However there is the remote
136  * possibility that some pre-dinosaur hardware won't like the back to back
137  * I/O. Since the Xservers get away with it, we should be able to as well.
138  */
139 static inline void write_vga(unsigned char reg, unsigned int val)
140 {
141         unsigned int v1, v2;
142         unsigned long flags;
143
144         /*
145          * ddprintk might set the console position from interrupt
146          * handlers, thus the write has to be IRQ-atomic.
147          */
148         spin_lock_irqsave(&vga_lock, flags);
149
150 #ifndef SLOW_VGA
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 #else
156         outb_p(reg, vga_video_port_reg);
157         outb_p(val >> 8, vga_video_port_val);
158         outb_p(reg + 1, vga_video_port_reg);
159         outb_p(val & 0xff, vga_video_port_val);
160 #endif
161         spin_unlock_irqrestore(&vga_lock, flags);
162 }
163
164 static const char __init *vgacon_startup(void)
165 {
166         const char *display_desc = NULL;
167         u16 saved1, saved2;
168         volatile u16 *p;
169
170         if (ORIG_VIDEO_ISVGA == VIDEO_TYPE_VLFB) {
171               no_vga:
172 #ifdef CONFIG_DUMMY_CONSOLE
173                 conswitchp = &dummy_con;
174                 return conswitchp->con_startup();
175 #else
176                 return NULL;
177 #endif
178         }
179
180         /* VGA16 modes are not handled by VGACON */
181         if ((ORIG_VIDEO_MODE == 0x0D) ||        /* 320x200/4 */
182             (ORIG_VIDEO_MODE == 0x0E) ||        /* 640x200/4 */
183             (ORIG_VIDEO_MODE == 0x10) ||        /* 640x350/4 */
184             (ORIG_VIDEO_MODE == 0x12) ||        /* 640x480/4 */
185             (ORIG_VIDEO_MODE == 0x6A))  /* 800x600/4, 0x6A is very common */
186                 goto no_vga;
187
188         vga_video_num_lines = ORIG_VIDEO_LINES;
189         vga_video_num_columns = ORIG_VIDEO_COLS;
190         state.vgabase = NULL;
191
192         if (ORIG_VIDEO_MODE == 7) {     /* Is this a monochrome display? */
193                 vga_vram_base = 0xb0000;
194                 vga_video_port_reg = VGA_CRT_IM;
195                 vga_video_port_val = VGA_CRT_DM;
196                 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10) {
197                         static struct resource ega_console_resource =
198                             { "ega", 0x3B0, 0x3BF };
199                         vga_video_type = VIDEO_TYPE_EGAM;
200                         vga_vram_end = 0xb8000;
201                         display_desc = "EGA+";
202                         request_resource(&ioport_resource,
203                                          &ega_console_resource);
204                 } else {
205                         static struct resource mda1_console_resource =
206                             { "mda", 0x3B0, 0x3BB };
207                         static struct resource mda2_console_resource =
208                             { "mda", 0x3BF, 0x3BF };
209                         vga_video_type = VIDEO_TYPE_MDA;
210                         vga_vram_end = 0xb2000;
211                         display_desc = "*MDA";
212                         request_resource(&ioport_resource,
213                                          &mda1_console_resource);
214                         request_resource(&ioport_resource,
215                                          &mda2_console_resource);
216                         vga_video_font_height = 14;
217                 }
218         } else {
219                 /* If not, it is color. */
220                 vga_can_do_color = 1;
221                 vga_vram_base = 0xb8000;
222                 vga_video_port_reg = VGA_CRT_IC;
223                 vga_video_port_val = VGA_CRT_DC;
224                 if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10) {
225                         int i;
226
227                         vga_vram_end = 0xc0000;
228
229                         if (!ORIG_VIDEO_ISVGA) {
230                                 static struct resource ega_console_resource
231                                     = { "ega", 0x3C0, 0x3DF };
232                                 vga_video_type = VIDEO_TYPE_EGAC;
233                                 display_desc = "EGA";
234                                 request_resource(&ioport_resource,
235                                                  &ega_console_resource);
236                         } else {
237                                 static struct resource vga_console_resource
238                                     = { "vga+", 0x3C0, 0x3DF };
239                                 vga_video_type = VIDEO_TYPE_VGAC;
240                                 display_desc = "VGA+";
241                                 request_resource(&ioport_resource,
242                                                  &vga_console_resource);
243
244 #ifdef VGA_CAN_DO_64KB
245                                 /*
246                                  * get 64K rather than 32K of video RAM.
247                                  * This doesn't actually work on all "VGA"
248                                  * controllers (it seems like setting MM=01
249                                  * and COE=1 isn't necessarily a good idea)
250                                  */
251                                 vga_vram_base = 0xa0000;
252                                 vga_vram_end = 0xb0000;
253                                 outb_p(6, VGA_GFX_I);
254                                 outb_p(6, VGA_GFX_D);
255 #endif
256                                 /*
257                                  * Normalise the palette registers, to point
258                                  * the 16 screen colours to the first 16
259                                  * DAC entries.
260                                  */
261
262                                 for (i = 0; i < 16; i++) {
263                                         inb_p(VGA_IS1_RC);
264                                         outb_p(i, VGA_ATT_W);
265                                         outb_p(i, VGA_ATT_W);
266                                 }
267                                 outb_p(0x20, VGA_ATT_W);
268
269                                 /*
270                                  * Now set the DAC registers back to their
271                                  * default values
272                                  */
273                                 for (i = 0; i < 16; i++) {
274                                         outb_p(color_table[i], VGA_PEL_IW);
275                                         outb_p(default_red[i], VGA_PEL_D);
276                                         outb_p(default_grn[i], VGA_PEL_D);
277                                         outb_p(default_blu[i], VGA_PEL_D);
278                                 }
279                         }
280                 } else {
281                         static struct resource cga_console_resource =
282                             { "cga", 0x3D4, 0x3D5 };
283                         vga_video_type = VIDEO_TYPE_CGA;
284                         vga_vram_end = 0xba000;
285                         display_desc = "*CGA";
286                         request_resource(&ioport_resource,
287                                          &cga_console_resource);
288                         vga_video_font_height = 8;
289                 }
290         }
291
292         vga_vram_base = VGA_MAP_MEM(vga_vram_base);
293         vga_vram_end = VGA_MAP_MEM(vga_vram_end);
294         vga_vram_size = vga_vram_end - vga_vram_base;
295
296         /*
297          *      Find out if there is a graphics card present.
298          *      Are there smarter methods around?
299          */
300         p = (volatile u16 *) vga_vram_base;
301         saved1 = scr_readw(p);
302         saved2 = scr_readw(p + 1);
303         scr_writew(0xAA55, p);
304         scr_writew(0x55AA, p + 1);
305         if (scr_readw(p) != 0xAA55 || scr_readw(p + 1) != 0x55AA) {
306                 scr_writew(saved1, p);
307                 scr_writew(saved2, p + 1);
308                 goto no_vga;
309         }
310         scr_writew(0x55AA, p);
311         scr_writew(0xAA55, p + 1);
312         if (scr_readw(p) != 0x55AA || scr_readw(p + 1) != 0xAA55) {
313                 scr_writew(saved1, p);
314                 scr_writew(saved2, p + 1);
315                 goto no_vga;
316         }
317         scr_writew(saved1, p);
318         scr_writew(saved2, p + 1);
319
320         if (vga_video_type == VIDEO_TYPE_EGAC
321             || vga_video_type == VIDEO_TYPE_VGAC
322             || vga_video_type == VIDEO_TYPE_EGAM) {
323                 vga_hardscroll_enabled = vga_hardscroll_user_enable;
324                 vga_default_font_height = ORIG_VIDEO_POINTS;
325                 vga_video_font_height = ORIG_VIDEO_POINTS;
326                 /* This may be suboptimal but is a safe bet - go with it */
327                 vga_scan_lines =
328                     vga_video_font_height * vga_video_num_lines;
329         }
330
331         vgacon_xres = ORIG_VIDEO_COLS * VGA_FONTWIDTH;
332         vgacon_yres = vga_scan_lines;
333
334         return display_desc;
335 }
336
337 static void vgacon_init(struct vc_data *c, int init)
338 {
339         unsigned long p;
340
341         /* We cannot be loaded as a module, therefore init is always 1 */
342         c->vc_can_do_color = vga_can_do_color;
343         c->vc_cols = vga_video_num_columns;
344         c->vc_rows = vga_video_num_lines;
345         c->vc_scan_lines = vga_scan_lines;
346         c->vc_font.height = vga_video_font_height;
347         c->vc_complement_mask = 0x7700;
348         if (vga_512_chars)
349                 c->vc_hi_font_mask = 0x0800;
350         p = *c->vc_uni_pagedir_loc;
351         if (c->vc_uni_pagedir_loc == &c->vc_uni_pagedir ||
352             !--c->vc_uni_pagedir_loc[1])
353                 con_free_unimap(c);
354         c->vc_uni_pagedir_loc = vgacon_uni_pagedir;
355         vgacon_uni_pagedir[1]++;
356         if (!vgacon_uni_pagedir[0] && p)
357                 con_set_default_unimap(c);
358 }
359
360 static inline void vga_set_mem_top(struct vc_data *c)
361 {
362         write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
363 }
364
365 static void vgacon_deinit(struct vc_data *c)
366 {
367         /* When closing the last console, reset video origin */
368         if (!--vgacon_uni_pagedir[1]) {
369                 c->vc_visible_origin = vga_vram_base;
370                 vga_set_mem_top(c);
371                 con_free_unimap(c);
372         }
373         c->vc_uni_pagedir_loc = &c->vc_uni_pagedir;
374         con_set_default_unimap(c);
375 }
376
377 static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
378                             u8 blink, u8 underline, u8 reverse)
379 {
380         u8 attr = color;
381
382         if (vga_can_do_color) {
383                 if (underline)
384                         attr = (attr & 0xf0) | c->vc_ulcolor;
385                 else if (intensity == 0)
386                         attr = (attr & 0xf0) | c->vc_halfcolor;
387         }
388         if (reverse)
389                 attr =
390                     ((attr) & 0x88) | ((((attr) >> 4) | ((attr) << 4)) &
391                                        0x77);
392         if (blink)
393                 attr ^= 0x80;
394         if (intensity == 2)
395                 attr ^= 0x08;
396         if (!vga_can_do_color) {
397                 if (underline)
398                         attr = (attr & 0xf8) | 0x01;
399                 else if (intensity == 0)
400                         attr = (attr & 0xf0) | 0x08;
401         }
402         return attr;
403 }
404
405 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count)
406 {
407         int col = vga_can_do_color;
408
409         while (count--) {
410                 u16 a = scr_readw(p);
411                 if (col)
412                         a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) |
413                             (((a) & 0x0700) << 4);
414                 else
415                         a ^= ((a & 0x0700) == 0x0100) ? 0x7000 : 0x7700;
416                 scr_writew(a, p++);
417         }
418 }
419
420 static void vgacon_set_cursor_size(int xpos, int from, int to)
421 {
422         unsigned long flags;
423         int curs, cure;
424
425 #ifdef TRIDENT_GLITCH
426         if (xpos < 16)
427                 from--, to--;
428 #endif
429
430         if ((from == cursor_size_lastfrom) && (to == cursor_size_lastto))
431                 return;
432         cursor_size_lastfrom = from;
433         cursor_size_lastto = to;
434
435         spin_lock_irqsave(&vga_lock, flags);
436         outb_p(0x0a, vga_video_port_reg);       /* Cursor start */
437         curs = inb_p(vga_video_port_val);
438         outb_p(0x0b, vga_video_port_reg);       /* Cursor end */
439         cure = inb_p(vga_video_port_val);
440
441         curs = (curs & 0xc0) | from;
442         cure = (cure & 0xe0) | to;
443
444         outb_p(0x0a, vga_video_port_reg);       /* Cursor start */
445         outb_p(curs, vga_video_port_val);
446         outb_p(0x0b, vga_video_port_reg);       /* Cursor end */
447         outb_p(cure, vga_video_port_val);
448         spin_unlock_irqrestore(&vga_lock, flags);
449 }
450
451 static void vgacon_cursor(struct vc_data *c, int mode)
452 {
453         if (c->vc_origin != c->vc_visible_origin)
454                 vgacon_scrolldelta(c, 0);
455         switch (mode) {
456         case CM_ERASE:
457                 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
458                 vgacon_set_cursor_size(c->vc_x, 31, 30);
459                 break;
460
461         case CM_MOVE:
462         case CM_DRAW:
463                 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
464                 switch (c->vc_cursor_type & 0x0f) {
465                 case CUR_UNDERLINE:
466                         vgacon_set_cursor_size(c->vc_x,
467                                                c->vc_font.height -
468                                                (c->vc_font.height <
469                                                 10 ? 2 : 3),
470                                                c->vc_font.height -
471                                                (c->vc_font.height <
472                                                 10 ? 1 : 2));
473                         break;
474                 case CUR_TWO_THIRDS:
475                         vgacon_set_cursor_size(c->vc_x,
476                                                c->vc_font.height / 3,
477                                                c->vc_font.height -
478                                                (c->vc_font.height <
479                                                 10 ? 1 : 2));
480                         break;
481                 case CUR_LOWER_THIRD:
482                         vgacon_set_cursor_size(c->vc_x,
483                                                (c->vc_font.height * 2) / 3,
484                                                c->vc_font.height -
485                                                (c->vc_font.height <
486                                                 10 ? 1 : 2));
487                         break;
488                 case CUR_LOWER_HALF:
489                         vgacon_set_cursor_size(c->vc_x,
490                                                c->vc_font.height / 2,
491                                                c->vc_font.height -
492                                                (c->vc_font.height <
493                                                 10 ? 1 : 2));
494                         break;
495                 case CUR_NONE:
496                         vgacon_set_cursor_size(c->vc_x, 31, 30);
497                         break;
498                 default:
499                         vgacon_set_cursor_size(c->vc_x, 1,
500                                                c->vc_font.height);
501                         break;
502                 }
503                 break;
504         }
505 }
506
507 static int vgacon_doresize(struct vc_data *c,
508                 unsigned int width, unsigned int height)
509 {
510         unsigned long flags;
511         unsigned int scanlines = height * c->vc_font.height;
512         u8 scanlines_lo = 0, r7 = 0, vsync_end = 0, mode, max_scan;
513
514         spin_lock_irqsave(&vga_lock, flags);
515
516         vgacon_xres = width * VGA_FONTWIDTH;
517         vgacon_yres = height * c->vc_font.height;
518         if (vga_video_type >= VIDEO_TYPE_VGAC) {
519                 outb_p(VGA_CRTC_MAX_SCAN, vga_video_port_reg);
520                 max_scan = inb_p(vga_video_port_val);
521
522                 if (max_scan & 0x80)
523                         scanlines <<= 1;
524
525                 outb_p(VGA_CRTC_MODE, vga_video_port_reg);
526                 mode = inb_p(vga_video_port_val);
527
528                 if (mode & 0x04)
529                         scanlines >>= 1;
530
531                 scanlines -= 1;
532                 scanlines_lo = scanlines & 0xff;
533
534                 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
535                 r7 = inb_p(vga_video_port_val) & ~0x42;
536
537                 if (scanlines & 0x100)
538                         r7 |= 0x02;
539                 if (scanlines & 0x200)
540                         r7 |= 0x40;
541
542                 /* deprotect registers */
543                 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
544                 vsync_end = inb_p(vga_video_port_val);
545                 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
546                 outb_p(vsync_end & ~0x80, vga_video_port_val);
547         }
548
549         outb_p(VGA_CRTC_H_DISP, vga_video_port_reg);
550         outb_p(width - 1, vga_video_port_val);
551         outb_p(VGA_CRTC_OFFSET, vga_video_port_reg);
552         outb_p(width >> 1, vga_video_port_val);
553
554         if (vga_video_type >= VIDEO_TYPE_VGAC) {
555                 outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg);
556                 outb_p(scanlines_lo, vga_video_port_val);
557                 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
558                 outb_p(r7,vga_video_port_val);
559
560                 /* reprotect registers */
561                 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
562                 outb_p(vsync_end, vga_video_port_val);
563         }
564
565         spin_unlock_irqrestore(&vga_lock, flags);
566         return 0;
567 }
568
569 static int vgacon_switch(struct vc_data *c)
570 {
571         int x = c->vc_cols * VGA_FONTWIDTH;
572         int y = c->vc_rows * c->vc_font.height;
573         int rows = ORIG_VIDEO_LINES * vga_default_font_height/
574                 c->vc_font.height;
575         /*
576          * We need to save screen size here as it's the only way
577          * we can spot the screen has been resized and we need to
578          * set size of freshly allocated screens ourselves.
579          */
580         vga_video_num_columns = c->vc_cols;
581         vga_video_num_lines = c->vc_rows;
582
583         /* We can only copy out the size of the video buffer here,
584          * otherwise we get into VGA BIOS */
585
586         if (!vga_is_gfx) {
587                 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
588                             c->vc_screenbuf_size > vga_vram_size ?
589                                 vga_vram_size : c->vc_screenbuf_size);
590
591                 if ((vgacon_xres != x || vgacon_yres != y) &&
592                     (!(vga_video_num_columns % 2) &&
593                      vga_video_num_columns <= ORIG_VIDEO_COLS &&
594                      vga_video_num_lines <= rows))
595                         vgacon_doresize(c, c->vc_cols, c->vc_rows);
596         }
597
598         return 0;               /* Redrawing not needed */
599 }
600
601 static void vga_set_palette(struct vc_data *vc, unsigned char *table)
602 {
603         int i, j;
604
605         vga_w(state.vgabase, VGA_PEL_MSK, 0xff);
606         for (i = j = 0; i < 16; i++) {
607                 vga_w(state.vgabase, VGA_PEL_IW, table[i]);
608                 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
609                 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
610                 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
611         }
612 }
613
614 static int vgacon_set_palette(struct vc_data *vc, unsigned char *table)
615 {
616 #ifdef CAN_LOAD_PALETTE
617         if (vga_video_type != VIDEO_TYPE_VGAC || vga_palette_blanked
618             || !CON_IS_VISIBLE(vc))
619                 return -EINVAL;
620         vga_set_palette(vc, table);
621         return 0;
622 #else
623         return -EINVAL;
624 #endif
625 }
626
627 /* structure holding original VGA register settings */
628 static struct {
629         unsigned char SeqCtrlIndex;     /* Sequencer Index reg.   */
630         unsigned char CrtCtrlIndex;     /* CRT-Contr. Index reg.  */
631         unsigned char CrtMiscIO;        /* Miscellaneous register */
632         unsigned char HorizontalTotal;  /* CRT-Controller:00h */
633         unsigned char HorizDisplayEnd;  /* CRT-Controller:01h */
634         unsigned char StartHorizRetrace;        /* CRT-Controller:04h */
635         unsigned char EndHorizRetrace;  /* CRT-Controller:05h */
636         unsigned char Overflow; /* CRT-Controller:07h */
637         unsigned char StartVertRetrace; /* CRT-Controller:10h */
638         unsigned char EndVertRetrace;   /* CRT-Controller:11h */
639         unsigned char ModeControl;      /* CRT-Controller:17h */
640         unsigned char ClockingMode;     /* Seq-Controller:01h */
641 } vga_state;
642
643 static void vga_vesa_blank(struct vgastate *state, int mode)
644 {
645         /* save original values of VGA controller registers */
646         if (!vga_vesa_blanked) {
647                 spin_lock_irq(&vga_lock);
648                 vga_state.SeqCtrlIndex = vga_r(state->vgabase, VGA_SEQ_I);
649                 vga_state.CrtCtrlIndex = inb_p(vga_video_port_reg);
650                 vga_state.CrtMiscIO = vga_r(state->vgabase, VGA_MIS_R);
651                 spin_unlock_irq(&vga_lock);
652
653                 outb_p(0x00, vga_video_port_reg);       /* HorizontalTotal */
654                 vga_state.HorizontalTotal = inb_p(vga_video_port_val);
655                 outb_p(0x01, vga_video_port_reg);       /* HorizDisplayEnd */
656                 vga_state.HorizDisplayEnd = inb_p(vga_video_port_val);
657                 outb_p(0x04, vga_video_port_reg);       /* StartHorizRetrace */
658                 vga_state.StartHorizRetrace = inb_p(vga_video_port_val);
659                 outb_p(0x05, vga_video_port_reg);       /* EndHorizRetrace */
660                 vga_state.EndHorizRetrace = inb_p(vga_video_port_val);
661                 outb_p(0x07, vga_video_port_reg);       /* Overflow */
662                 vga_state.Overflow = inb_p(vga_video_port_val);
663                 outb_p(0x10, vga_video_port_reg);       /* StartVertRetrace */
664                 vga_state.StartVertRetrace = inb_p(vga_video_port_val);
665                 outb_p(0x11, vga_video_port_reg);       /* EndVertRetrace */
666                 vga_state.EndVertRetrace = inb_p(vga_video_port_val);
667                 outb_p(0x17, vga_video_port_reg);       /* ModeControl */
668                 vga_state.ModeControl = inb_p(vga_video_port_val);
669                 vga_state.ClockingMode = vga_rseq(state->vgabase, VGA_SEQ_CLOCK_MODE);
670         }
671
672         /* assure that video is enabled */
673         /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */
674         spin_lock_irq(&vga_lock);
675         vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode | 0x20);
676
677         /* test for vertical retrace in process.... */
678         if ((vga_state.CrtMiscIO & 0x80) == 0x80)
679                 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO & 0xEF);
680
681         /*
682          * Set <End of vertical retrace> to minimum (0) and
683          * <Start of vertical Retrace> to maximum (incl. overflow)
684          * Result: turn off vertical sync (VSync) pulse.
685          */
686         if (mode & VESA_VSYNC_SUSPEND) {
687                 outb_p(0x10, vga_video_port_reg);       /* StartVertRetrace */
688                 outb_p(0xff, vga_video_port_val);       /* maximum value */
689                 outb_p(0x11, vga_video_port_reg);       /* EndVertRetrace */
690                 outb_p(0x40, vga_video_port_val);       /* minimum (bits 0..3)  */
691                 outb_p(0x07, vga_video_port_reg);       /* Overflow */
692                 outb_p(vga_state.Overflow | 0x84, vga_video_port_val);  /* bits 9,10 of vert. retrace */
693         }
694
695         if (mode & VESA_HSYNC_SUSPEND) {
696                 /*
697                  * Set <End of horizontal retrace> to minimum (0) and
698                  *  <Start of horizontal Retrace> to maximum
699                  * Result: turn off horizontal sync (HSync) pulse.
700                  */
701                 outb_p(0x04, vga_video_port_reg);       /* StartHorizRetrace */
702                 outb_p(0xff, vga_video_port_val);       /* maximum */
703                 outb_p(0x05, vga_video_port_reg);       /* EndHorizRetrace */
704                 outb_p(0x00, vga_video_port_val);       /* minimum (0) */
705         }
706
707         /* restore both index registers */
708         vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
709         outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
710         spin_unlock_irq(&vga_lock);
711 }
712
713 static void vga_vesa_unblank(struct vgastate *state)
714 {
715         /* restore original values of VGA controller registers */
716         spin_lock_irq(&vga_lock);
717         vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO);
718
719         outb_p(0x00, vga_video_port_reg);       /* HorizontalTotal */
720         outb_p(vga_state.HorizontalTotal, vga_video_port_val);
721         outb_p(0x01, vga_video_port_reg);       /* HorizDisplayEnd */
722         outb_p(vga_state.HorizDisplayEnd, vga_video_port_val);
723         outb_p(0x04, vga_video_port_reg);       /* StartHorizRetrace */
724         outb_p(vga_state.StartHorizRetrace, vga_video_port_val);
725         outb_p(0x05, vga_video_port_reg);       /* EndHorizRetrace */
726         outb_p(vga_state.EndHorizRetrace, vga_video_port_val);
727         outb_p(0x07, vga_video_port_reg);       /* Overflow */
728         outb_p(vga_state.Overflow, vga_video_port_val);
729         outb_p(0x10, vga_video_port_reg);       /* StartVertRetrace */
730         outb_p(vga_state.StartVertRetrace, vga_video_port_val);
731         outb_p(0x11, vga_video_port_reg);       /* EndVertRetrace */
732         outb_p(vga_state.EndVertRetrace, vga_video_port_val);
733         outb_p(0x17, vga_video_port_reg);       /* ModeControl */
734         outb_p(vga_state.ModeControl, vga_video_port_val);
735         /* ClockingMode */
736         vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode);
737
738         /* restore index/control registers */
739         vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
740         outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
741         spin_unlock_irq(&vga_lock);
742 }
743
744 static void vga_pal_blank(struct vgastate *state)
745 {
746         int i;
747
748         vga_w(state->vgabase, VGA_PEL_MSK, 0xff);
749         for (i = 0; i < 16; i++) {
750                 vga_w(state->vgabase, VGA_PEL_IW, i);
751                 vga_w(state->vgabase, VGA_PEL_D, 0);
752                 vga_w(state->vgabase, VGA_PEL_D, 0);
753                 vga_w(state->vgabase, VGA_PEL_D, 0);
754         }
755 }
756
757 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch)
758 {
759         switch (blank) {
760         case 0:         /* Unblank */
761                 if (vga_vesa_blanked) {
762                         vga_vesa_unblank(&state);
763                         vga_vesa_blanked = 0;
764                 }
765                 if (vga_palette_blanked) {
766                         vga_set_palette(c, color_table);
767                         vga_palette_blanked = 0;
768                         return 0;
769                 }
770                 vga_is_gfx = 0;
771                 /* Tell console.c that it has to restore the screen itself */
772                 return 1;
773         case 1:         /* Normal blanking */
774         case -1:        /* Obsolete */
775                 if (!mode_switch && vga_video_type == VIDEO_TYPE_VGAC) {
776                         vga_pal_blank(&state);
777                         vga_palette_blanked = 1;
778                         return 0;
779                 }
780                 vgacon_set_origin(c);
781                 scr_memsetw((void *) vga_vram_base, BLANK,
782                             c->vc_screenbuf_size);
783                 if (mode_switch)
784                         vga_is_gfx = 1;
785                 return 1;
786         default:                /* VESA blanking */
787                 if (vga_video_type == VIDEO_TYPE_VGAC) {
788                         vga_vesa_blank(&state, blank - 1);
789                         vga_vesa_blanked = blank;
790                 }
791                 return 0;
792         }
793 }
794
795 /*
796  * PIO_FONT support.
797  *
798  * The font loading code goes back to the codepage package by
799  * Joel Hoffman (joel@wam.umd.edu). (He reports that the original
800  * reference is: "From: p. 307 of _Programmer's Guide to PC & PS/2
801  * Video Systems_ by Richard Wilton. 1987.  Microsoft Press".)
802  *
803  * Change for certain monochrome monitors by Yury Shevchuck
804  * (sizif@botik.yaroslavl.su).
805  */
806
807 #ifdef CAN_LOAD_EGA_FONTS
808
809 #define colourmap 0xa0000
810 /* Pauline Middelink <middelin@polyware.iaf.nl> reports that we
811    should use 0xA0000 for the bwmap as well.. */
812 #define blackwmap 0xa0000
813 #define cmapsz 8192
814
815 static int vgacon_do_font_op(struct vgastate *state,char *arg,int set,int ch512)
816 {
817         unsigned short video_port_status = vga_video_port_reg + 6;
818         int font_select = 0x00, beg, i;
819         char *charmap;
820         
821         if (vga_video_type != VIDEO_TYPE_EGAM) {
822                 charmap = (char *) VGA_MAP_MEM(colourmap);
823                 beg = 0x0e;
824 #ifdef VGA_CAN_DO_64KB
825                 if (vga_video_type == VIDEO_TYPE_VGAC)
826                         beg = 0x06;
827 #endif
828         } else {
829                 charmap = (char *) VGA_MAP_MEM(blackwmap);
830                 beg = 0x0a;
831         }
832
833 #ifdef BROKEN_GRAPHICS_PROGRAMS
834         /*
835          * All fonts are loaded in slot 0 (0:1 for 512 ch)
836          */
837
838         if (!arg)
839                 return -EINVAL; /* Return to default font not supported */
840
841         vga_font_is_default = 0;
842         font_select = ch512 ? 0x04 : 0x00;
843 #else
844         /*
845          * The default font is kept in slot 0 and is never touched.
846          * A custom font is loaded in slot 2 (256 ch) or 2:3 (512 ch)
847          */
848
849         if (set) {
850                 vga_font_is_default = !arg;
851                 if (!arg)
852                         ch512 = 0;      /* Default font is always 256 */
853                 font_select = arg ? (ch512 ? 0x0e : 0x0a) : 0x00;
854         }
855
856         if (!vga_font_is_default)
857                 charmap += 4 * cmapsz;
858 #endif
859
860         unlock_kernel();
861         spin_lock_irq(&vga_lock);
862         /* First, the Sequencer */
863         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1);
864         /* CPU writes only to map 2 */
865         vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x04);    
866         /* Sequential addressing */
867         vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x07);    
868         /* Clear synchronous reset */
869         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
870
871         /* Now, the graphics controller, select map 2 */
872         vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x02);             
873         /* disable odd-even addressing */
874         vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x00);
875         /* map start at A000:0000 */
876         vga_wgfx(state->vgabase, VGA_GFX_MISC, 0x00);
877         spin_unlock_irq(&vga_lock);
878
879         if (arg) {
880                 if (set)
881                         for (i = 0; i < cmapsz; i++)
882                                 vga_writeb(arg[i], charmap + i);
883                 else
884                         for (i = 0; i < cmapsz; i++)
885                                 arg[i] = vga_readb(charmap + i);
886
887                 /*
888                  * In 512-character mode, the character map is not contiguous if
889                  * we want to remain EGA compatible -- which we do
890                  */
891
892                 if (ch512) {
893                         charmap += 2 * cmapsz;
894                         arg += cmapsz;
895                         if (set)
896                                 for (i = 0; i < cmapsz; i++)
897                                         vga_writeb(arg[i], charmap + i);
898                         else
899                                 for (i = 0; i < cmapsz; i++)
900                                         arg[i] = vga_readb(charmap + i);
901                 }
902         }
903
904         spin_lock_irq(&vga_lock);
905         /* First, the sequencer, Synchronous reset */
906         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x01);  
907         /* CPU writes to maps 0 and 1 */
908         vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x03);
909         /* odd-even addressing */
910         vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x03);
911         /* Character Map Select */
912         if (set)
913                 vga_wseq(state->vgabase, VGA_SEQ_CHARACTER_MAP, font_select);
914         /* clear synchronous reset */
915         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
916
917         /* Now, the graphics controller, select map 0 for CPU */
918         vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x00);
919         /* enable even-odd addressing */
920         vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x10);
921         /* map starts at b800:0 or b000:0 */
922         vga_wgfx(state->vgabase, VGA_GFX_MISC, beg);
923
924         /* if 512 char mode is already enabled don't re-enable it. */
925         if ((set) && (ch512 != vga_512_chars)) {
926                 int i;  
927                 
928                 /* attribute controller */
929                 for (i = 0; i < MAX_NR_CONSOLES; i++) {
930                         struct vc_data *c = vc_cons[i].d;
931                         if (c && c->vc_sw == &vga_con)
932                                 c->vc_hi_font_mask = ch512 ? 0x0800 : 0;
933                 }
934                 vga_512_chars = ch512;
935                 /* 256-char: enable intensity bit
936                    512-char: disable intensity bit */
937                 inb_p(video_port_status);       /* clear address flip-flop */
938                 /* color plane enable register */
939                 vga_wattr(state->vgabase, VGA_ATC_PLANE_ENABLE, ch512 ? 0x07 : 0x0f);
940                 /* Wilton (1987) mentions the following; I don't know what
941                    it means, but it works, and it appears necessary */
942                 inb_p(video_port_status);
943                 vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0);    
944         }
945         spin_unlock_irq(&vga_lock);
946         lock_kernel();
947         return 0;
948 }
949
950 /*
951  * Adjust the screen to fit a font of a certain height
952  */
953 static int vgacon_adjust_height(struct vc_data *vc, unsigned fontheight)
954 {
955         unsigned char ovr, vde, fsr;
956         int rows, maxscan, i;
957
958         rows = vc->vc_scan_lines / fontheight;  /* Number of video rows we end up with */
959         maxscan = rows * fontheight - 1;        /* Scan lines to actually display-1 */
960
961         /* Reprogram the CRTC for the new font size
962            Note: the attempt to read the overflow register will fail
963            on an EGA, but using 0xff for the previous value appears to
964            be OK for EGA text modes in the range 257-512 scan lines, so I
965            guess we don't need to worry about it.
966
967            The same applies for the spill bits in the font size and cursor
968            registers; they are write-only on EGA, but it appears that they
969            are all don't care bits on EGA, so I guess it doesn't matter. */
970
971         spin_lock_irq(&vga_lock);
972         outb_p(0x07, vga_video_port_reg);       /* CRTC overflow register */
973         ovr = inb_p(vga_video_port_val);
974         outb_p(0x09, vga_video_port_reg);       /* Font size register */
975         fsr = inb_p(vga_video_port_val);
976         spin_unlock_irq(&vga_lock);
977
978         vde = maxscan & 0xff;   /* Vertical display end reg */
979         ovr = (ovr & 0xbd) +    /* Overflow register */
980             ((maxscan & 0x100) >> 7) + ((maxscan & 0x200) >> 3);
981         fsr = (fsr & 0xe0) + (fontheight - 1);  /*  Font size register */
982
983         spin_lock_irq(&vga_lock);
984         outb_p(0x07, vga_video_port_reg);       /* CRTC overflow register */
985         outb_p(ovr, vga_video_port_val);
986         outb_p(0x09, vga_video_port_reg);       /* Font size */
987         outb_p(fsr, vga_video_port_val);
988         outb_p(0x12, vga_video_port_reg);       /* Vertical display limit */
989         outb_p(vde, vga_video_port_val);
990         spin_unlock_irq(&vga_lock);
991         vga_video_font_height = fontheight;
992
993         for (i = 0; i < MAX_NR_CONSOLES; i++) {
994                 struct vc_data *c = vc_cons[i].d;
995
996                 if (c && c->vc_sw == &vga_con) {
997                         if (CON_IS_VISIBLE(c)) {
998                                 /* void size to cause regs to be rewritten */
999                                 cursor_size_lastfrom = 0;
1000                                 cursor_size_lastto = 0;
1001                                 c->vc_sw->con_cursor(c, CM_DRAW);
1002                         }
1003                         c->vc_font.height = fontheight;
1004                         vc_resize(c, 0, rows);  /* Adjust console size */
1005                 }
1006         }
1007         return 0;
1008 }
1009
1010 static int vgacon_font_set(struct vc_data *c, struct console_font *font, unsigned flags)
1011 {
1012         unsigned charcount = font->charcount;
1013         int rc;
1014
1015         if (vga_video_type < VIDEO_TYPE_EGAM)
1016                 return -EINVAL;
1017
1018         if (font->width != VGA_FONTWIDTH ||
1019             (charcount != 256 && charcount != 512))
1020                 return -EINVAL;
1021
1022         rc = vgacon_do_font_op(&state, font->data, 1, charcount == 512);
1023         if (rc)
1024                 return rc;
1025
1026         if (!(flags & KD_FONT_FLAG_DONT_RECALC))
1027                 rc = vgacon_adjust_height(c, font->height);
1028         return rc;
1029 }
1030
1031 static int vgacon_font_get(struct vc_data *c, struct console_font *font)
1032 {
1033         if (vga_video_type < VIDEO_TYPE_EGAM)
1034                 return -EINVAL;
1035
1036         font->width = VGA_FONTWIDTH;
1037         font->height = c->vc_font.height;
1038         font->charcount = vga_512_chars ? 512 : 256;
1039         if (!font->data)
1040                 return 0;
1041         return vgacon_do_font_op(&state, font->data, 0, 0);
1042 }
1043
1044 #else
1045
1046 #define vgacon_font_set NULL
1047 #define vgacon_font_get NULL
1048
1049 #endif
1050
1051 static int vgacon_resize(struct vc_data *c, unsigned int width,
1052                                 unsigned int height)
1053 {
1054         if (width % 2 || width > ORIG_VIDEO_COLS ||
1055             height > (ORIG_VIDEO_LINES * vga_default_font_height)/
1056             c->vc_font.height)
1057                 /* let svgatextmode tinker with video timings */
1058                 return 0;
1059
1060         if (CON_IS_VISIBLE(c) && !vga_is_gfx) /* who knows */
1061                 vgacon_doresize(c, width, height);
1062         return 0;
1063 }
1064
1065 static int vgacon_scrolldelta(struct vc_data *c, int lines)
1066 {
1067         if (!lines)             /* Turn scrollback off */
1068                 c->vc_visible_origin = c->vc_origin;
1069         else {
1070                 int margin = c->vc_size_row * 4;
1071                 int ul, we, p, st;
1072
1073                 if (vga_rolled_over >
1074                     (c->vc_scr_end - vga_vram_base) + margin) {
1075                         ul = c->vc_scr_end - vga_vram_base;
1076                         we = vga_rolled_over + c->vc_size_row;
1077                 } else {
1078                         ul = 0;
1079                         we = vga_vram_size;
1080                 }
1081                 p = (c->vc_visible_origin - vga_vram_base - ul + we) % we +
1082                     lines * c->vc_size_row;
1083                 st = (c->vc_origin - vga_vram_base - ul + we) % we;
1084                 if (st < 2 * margin)
1085                         margin = 0;
1086                 if (p < margin)
1087                         p = 0;
1088                 if (p > st - margin)
1089                         p = st;
1090                 c->vc_visible_origin = vga_vram_base + (p + ul) % we;
1091         }
1092         vga_set_mem_top(c);
1093         return 1;
1094 }
1095
1096 static int vgacon_set_origin(struct vc_data *c)
1097 {
1098         if (vga_is_gfx ||       /* We don't play origin tricks in graphic modes */
1099             (console_blanked && !vga_palette_blanked))  /* Nor we write to blanked screens */
1100                 return 0;
1101         c->vc_origin = c->vc_visible_origin = vga_vram_base;
1102         vga_set_mem_top(c);
1103         vga_rolled_over = 0;
1104         return 1;
1105 }
1106
1107 static void vgacon_save_screen(struct vc_data *c)
1108 {
1109         static int vga_bootup_console = 0;
1110
1111         if (!vga_bootup_console) {
1112                 /* This is a gross hack, but here is the only place we can
1113                  * set bootup console parameters without messing up generic
1114                  * console initialization routines.
1115                  */
1116                 vga_bootup_console = 1;
1117                 c->vc_x = ORIG_X;
1118                 c->vc_y = ORIG_Y;
1119         }
1120
1121         /* We can't copy in more then the size of the video buffer,
1122          * or we'll be copying in VGA BIOS */
1123
1124         if (!vga_is_gfx)
1125                 scr_memcpyw((u16 *) c->vc_screenbuf, (u16 *) c->vc_origin,
1126                             c->vc_screenbuf_size > vga_vram_size ? vga_vram_size : c->vc_screenbuf_size);
1127 }
1128
1129 static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
1130                          int lines)
1131 {
1132         unsigned long oldo;
1133         unsigned int delta;
1134
1135         if (t || b != c->vc_rows || vga_is_gfx)
1136                 return 0;
1137
1138         if (c->vc_origin != c->vc_visible_origin)
1139                 vgacon_scrolldelta(c, 0);
1140
1141         if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2)
1142                 return 0;
1143
1144         oldo = c->vc_origin;
1145         delta = lines * c->vc_size_row;
1146         if (dir == SM_UP) {
1147                 if (c->vc_scr_end + delta >= vga_vram_end) {
1148                         scr_memcpyw((u16 *) vga_vram_base,
1149                                     (u16 *) (oldo + delta),
1150                                     c->vc_screenbuf_size - delta);
1151                         c->vc_origin = vga_vram_base;
1152                         vga_rolled_over = oldo - vga_vram_base;
1153                 } else
1154                         c->vc_origin += delta;
1155                 scr_memsetw((u16 *) (c->vc_origin + c->vc_screenbuf_size -
1156                                      delta), c->vc_video_erase_char,
1157                             delta);
1158         } else {
1159                 if (oldo - delta < vga_vram_base) {
1160                         scr_memmovew((u16 *) (vga_vram_end -
1161                                               c->vc_screenbuf_size +
1162                                               delta), (u16 *) oldo,
1163                                      c->vc_screenbuf_size - delta);
1164                         c->vc_origin = vga_vram_end - c->vc_screenbuf_size;
1165                         vga_rolled_over = 0;
1166                 } else
1167                         c->vc_origin -= delta;
1168                 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1169                 scr_memsetw((u16 *) (c->vc_origin), c->vc_video_erase_char,
1170                             delta);
1171         }
1172         c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1173         c->vc_visible_origin = c->vc_origin;
1174         vga_set_mem_top(c);
1175         c->vc_pos = (c->vc_pos - oldo) + c->vc_origin;
1176         return 1;
1177 }
1178
1179
1180 /*
1181  *  The console `switch' structure for the VGA based console
1182  */
1183
1184 static int vgacon_dummy(struct vc_data *c)
1185 {
1186         return 0;
1187 }
1188
1189 #define DUMMY (void *) vgacon_dummy
1190
1191 const struct consw vga_con = {
1192         .owner = THIS_MODULE,
1193         .con_startup = vgacon_startup,
1194         .con_init = vgacon_init,
1195         .con_deinit = vgacon_deinit,
1196         .con_clear = DUMMY,
1197         .con_putc = DUMMY,
1198         .con_putcs = DUMMY,
1199         .con_cursor = vgacon_cursor,
1200         .con_scroll = vgacon_scroll,
1201         .con_bmove = DUMMY,
1202         .con_switch = vgacon_switch,
1203         .con_blank = vgacon_blank,
1204         .con_font_set = vgacon_font_set,
1205         .con_font_get = vgacon_font_get,
1206         .con_resize = vgacon_resize,
1207         .con_set_palette = vgacon_set_palette,
1208         .con_scrolldelta = vgacon_scrolldelta,
1209         .con_set_origin = vgacon_set_origin,
1210         .con_save_screen = vgacon_save_screen,
1211         .con_build_attr = vgacon_build_attr,
1212         .con_invert_region = vgacon_invert_region,
1213 };
1214
1215 MODULE_LICENSE("GPL");