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