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