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