blob: 448d209a0bf2109fa14af7d3c6a3b00e08c7df1b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/module.h>
37#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/fs.h>
39#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#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>
Jon Smirl894673e2006-07-10 04:44:13 -070049#include <linux/screen_info.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <linux/smp_lock.h>
51#include <video/vga.h>
52#include <asm/io.h>
53
54static DEFINE_SPINLOCK(vga_lock);
55static int cursor_size_lastfrom;
56static int cursor_size_lastto;
Antonino A. Daplas53dbb262006-01-08 01:02:36 -080057static u32 vgacon_xres;
58static u32 vgacon_yres;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059static 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
Antonino A. Daplas53dbb262006-01-08 01:02:36 -080072#define VGA_FONTWIDTH 8 /* VGA does not support fontwidths != 8 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070073/*
74 * Interface used by the world
75 */
76
77static const char *vgacon_startup(void);
78static void vgacon_init(struct vc_data *c, int init);
79static void vgacon_deinit(struct vc_data *c);
80static void vgacon_cursor(struct vc_data *c, int mode);
81static int vgacon_switch(struct vc_data *c);
82static int vgacon_blank(struct vc_data *c, int blank, int mode_switch);
83static int vgacon_set_palette(struct vc_data *vc, unsigned char *table);
84static int vgacon_scrolldelta(struct vc_data *c, int lines);
85static int vgacon_set_origin(struct vc_data *c);
86static void vgacon_save_screen(struct vc_data *c);
87static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
88 int lines);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089static void vgacon_invert_region(struct vc_data *c, u16 * p, int count);
90static unsigned long vgacon_uni_pagedir[2];
91
Linus Torvalds1da177e2005-04-16 15:20:36 -070092/* Description of the hardware situation */
Helge Deller0128bee2006-12-08 02:40:29 -080093static int vga_init_done __read_mostly;
94static unsigned long vga_vram_base __read_mostly; /* Base of video memory */
95static unsigned long vga_vram_end __read_mostly; /* End of video memory */
96static unsigned int vga_vram_size __read_mostly; /* Size of video memory */
97static u16 vga_video_port_reg __read_mostly; /* Video register select port */
98static u16 vga_video_port_val __read_mostly; /* Video register value port */
99static unsigned int vga_video_num_columns; /* Number of text columns */
100static unsigned int vga_video_num_lines; /* Number of text lines */
101static int vga_can_do_color __read_mostly; /* Do we support colors? */
102static unsigned int vga_default_font_height __read_mostly; /* Height of default screen font */
103static unsigned char vga_video_type __read_mostly; /* Card type */
104static unsigned char vga_hardscroll_enabled __read_mostly;
105static unsigned char vga_hardscroll_user_enable __read_mostly = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106static unsigned char vga_font_is_default = 1;
107static int vga_vesa_blanked;
108static int vga_palette_blanked;
109static int vga_is_gfx;
110static int vga_512_chars;
111static int vga_video_font_height;
Helge Deller0128bee2006-12-08 02:40:29 -0800112static int vga_scan_lines __read_mostly;
113static unsigned int vga_rolled_over;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
115static int __init no_scroll(char *str)
116{
117 /*
118 * Disabling scrollback is required for the Braillex ib80-piezo
119 * Braille reader made by F.H. Papenmeier (Germany).
120 * Use the "no-scroll" bootflag.
121 */
122 vga_hardscroll_user_enable = vga_hardscroll_enabled = 0;
123 return 1;
124}
125
126__setup("no-scroll", no_scroll);
127
128/*
129 * By replacing the four outb_p with two back to back outw, we can reduce
130 * the window of opportunity to see text mislocated to the RHS of the
131 * console during heavy scrolling activity. However there is the remote
132 * possibility that some pre-dinosaur hardware won't like the back to back
133 * I/O. Since the Xservers get away with it, we should be able to as well.
134 */
135static inline void write_vga(unsigned char reg, unsigned int val)
136{
137 unsigned int v1, v2;
138 unsigned long flags;
139
140 /*
141 * ddprintk might set the console position from interrupt
142 * handlers, thus the write has to be IRQ-atomic.
143 */
144 spin_lock_irqsave(&vga_lock, flags);
145
146#ifndef SLOW_VGA
147 v1 = reg + (val & 0xff00);
148 v2 = reg + 1 + ((val << 8) & 0xff00);
149 outw(v1, vga_video_port_reg);
150 outw(v2, vga_video_port_reg);
151#else
152 outb_p(reg, vga_video_port_reg);
153 outb_p(val >> 8, vga_video_port_val);
154 outb_p(reg + 1, vga_video_port_reg);
155 outb_p(val & 0xff, vga_video_port_val);
156#endif
157 spin_unlock_irqrestore(&vga_lock, flags);
158}
159
Antonino A. Daplas15bdab92006-03-27 01:17:20 -0800160static inline void vga_set_mem_top(struct vc_data *c)
161{
162 write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
163}
164
165#ifdef CONFIG_VGACON_SOFT_SCROLLBACK
166#include <linux/bootmem.h>
167/* software scrollback */
168static void *vgacon_scrollback;
169static int vgacon_scrollback_tail;
170static int vgacon_scrollback_size;
171static int vgacon_scrollback_rows;
172static int vgacon_scrollback_cnt;
173static int vgacon_scrollback_cur;
174static int vgacon_scrollback_save;
175static int vgacon_scrollback_restore;
176
177static void vgacon_scrollback_init(int pitch)
178{
179 int rows = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024/pitch;
180
181 if (vgacon_scrollback) {
182 vgacon_scrollback_cnt = 0;
183 vgacon_scrollback_tail = 0;
184 vgacon_scrollback_cur = 0;
185 vgacon_scrollback_rows = rows - 1;
186 vgacon_scrollback_size = rows * pitch;
187 }
188}
189
Sam Ravnborg80e27982007-07-21 04:37:31 -0700190/*
191 * Called only duing init so call of alloc_bootmen is ok.
192 * Marked __init_refok to silence modpost.
193 */
194static void __init_refok vgacon_scrollback_startup(void)
Antonino A. Daplas15bdab92006-03-27 01:17:20 -0800195{
196 vgacon_scrollback = alloc_bootmem(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE
197 * 1024);
198 vgacon_scrollback_init(vga_video_num_columns * 2);
199}
200
201static void vgacon_scrollback_update(struct vc_data *c, int t, int count)
202{
203 void *p;
204
205 if (!vgacon_scrollback_size || c->vc_num != fg_console)
206 return;
207
208 p = (void *) (c->vc_origin + t * c->vc_size_row);
209
210 while (count--) {
211 scr_memcpyw(vgacon_scrollback + vgacon_scrollback_tail,
212 p, c->vc_size_row);
213 vgacon_scrollback_cnt++;
214 p += c->vc_size_row;
215 vgacon_scrollback_tail += c->vc_size_row;
216
217 if (vgacon_scrollback_tail >= vgacon_scrollback_size)
218 vgacon_scrollback_tail = 0;
219
220 if (vgacon_scrollback_cnt > vgacon_scrollback_rows)
221 vgacon_scrollback_cnt = vgacon_scrollback_rows;
222
223 vgacon_scrollback_cur = vgacon_scrollback_cnt;
224 }
225}
226
227static void vgacon_restore_screen(struct vc_data *c)
228{
229 vgacon_scrollback_save = 0;
230
231 if (!vga_is_gfx && !vgacon_scrollback_restore) {
232 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
233 c->vc_screenbuf_size > vga_vram_size ?
234 vga_vram_size : c->vc_screenbuf_size);
235 vgacon_scrollback_restore = 1;
236 vgacon_scrollback_cur = vgacon_scrollback_cnt;
237 }
238}
239
240static int vgacon_scrolldelta(struct vc_data *c, int lines)
241{
Marcin Slusarz5ab48402008-10-15 22:03:50 -0700242 int start, end, count, soff;
Antonino A. Daplas15bdab92006-03-27 01:17:20 -0800243
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
Marcin Slusarzc38182a2008-10-15 22:03:49 -0700289 if (count) {
290 int copysize;
Marcin Slusarz5ab48402008-10-15 22:03:50 -0700291
292 int diff = c->vc_rows - count;
293 void *d = (void *) c->vc_origin;
294 void *s = (void *) c->vc_screenbuf;
295
Marcin Slusarzc38182a2008-10-15 22:03:49 -0700296 count *= c->vc_size_row;
297 /* how much memory to end of buffer left? */
298 copysize = min(count, vgacon_scrollback_size - soff);
299 scr_memcpyw(d, vgacon_scrollback + soff, copysize);
300 d += copysize;
301 count -= copysize;
Antonino A. Daplas15bdab92006-03-27 01:17:20 -0800302
Marcin Slusarzc38182a2008-10-15 22:03:49 -0700303 if (count) {
304 scr_memcpyw(d, vgacon_scrollback, count);
305 d += count;
306 }
Antonino A. Daplas15bdab92006-03-27 01:17:20 -0800307
Marcin Slusarzc38182a2008-10-15 22:03:49 -0700308 if (diff)
309 scr_memcpyw(d, s, diff * c->vc_size_row);
Marcin Slusarz5ab48402008-10-15 22:03:50 -0700310 } else
311 vgacon_cursor(c, CM_MOVE);
Antonino A. Daplas15bdab92006-03-27 01:17:20 -0800312
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
320static 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
326static 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
Antonino A. Daplas50ec42e2006-06-26 00:27:02 -0700358static const char *vgacon_startup(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
360 const char *display_desc = NULL;
361 u16 saved1, saved2;
362 volatile u16 *p;
363
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700364 if (screen_info.orig_video_isVGA == VIDEO_TYPE_VLFB) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 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
H. Peter Anvin30c82642007-10-15 17:13:22 -0700374 /* boot_params.screen_info initialized? */
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700375 if ((screen_info.orig_video_mode == 0) &&
376 (screen_info.orig_video_lines == 0) &&
377 (screen_info.orig_video_cols == 0))
Gerd Hoffmanna1a48492007-05-16 22:11:09 -0700378 goto no_vga;
379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 /* VGA16 modes are not handled by VGACON */
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700381 if ((screen_info.orig_video_mode == 0x0D) || /* 320x200/4 */
382 (screen_info.orig_video_mode == 0x0E) || /* 640x200/4 */
383 (screen_info.orig_video_mode == 0x10) || /* 640x350/4 */
384 (screen_info.orig_video_mode == 0x12) || /* 640x480/4 */
385 (screen_info.orig_video_mode == 0x6A)) /* 800x600/4 (VESA) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 goto no_vga;
387
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700388 vga_video_num_lines = screen_info.orig_video_lines;
389 vga_video_num_columns = screen_info.orig_video_cols;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 state.vgabase = NULL;
391
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700392 if (screen_info.orig_video_mode == 7) {
393 /* Monochrome display */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 vga_vram_base = 0xb0000;
395 vga_video_port_reg = VGA_CRT_IM;
396 vga_video_port_val = VGA_CRT_DM;
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700397 if ((screen_info.orig_video_ega_bx & 0xff) != 0x10) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 static struct resource ega_console_resource =
Greg Kroah-Hartman740e5182006-06-12 14:47:06 -0700399 { .name = "ega", .start = 0x3B0, .end = 0x3BF };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 vga_video_type = VIDEO_TYPE_EGAM;
Bjorn Helgaas4f1bcaf2006-06-22 14:47:32 -0700401 vga_vram_size = 0x8000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 display_desc = "EGA+";
403 request_resource(&ioport_resource,
404 &ega_console_resource);
405 } else {
406 static struct resource mda1_console_resource =
Greg Kroah-Hartman740e5182006-06-12 14:47:06 -0700407 { .name = "mda", .start = 0x3B0, .end = 0x3BB };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 static struct resource mda2_console_resource =
Greg Kroah-Hartman740e5182006-06-12 14:47:06 -0700409 { .name = "mda", .start = 0x3BF, .end = 0x3BF };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 vga_video_type = VIDEO_TYPE_MDA;
Bjorn Helgaas4f1bcaf2006-06-22 14:47:32 -0700411 vga_vram_size = 0x2000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 display_desc = "*MDA";
413 request_resource(&ioport_resource,
414 &mda1_console_resource);
415 request_resource(&ioport_resource,
416 &mda2_console_resource);
417 vga_video_font_height = 14;
418 }
419 } else {
420 /* If not, it is color. */
421 vga_can_do_color = 1;
422 vga_vram_base = 0xb8000;
423 vga_video_port_reg = VGA_CRT_IC;
424 vga_video_port_val = VGA_CRT_DC;
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700425 if ((screen_info.orig_video_ega_bx & 0xff) != 0x10) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 int i;
427
Bjorn Helgaas4f1bcaf2006-06-22 14:47:32 -0700428 vga_vram_size = 0x8000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700430 if (!screen_info.orig_video_isVGA) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 static struct resource ega_console_resource
Greg Kroah-Hartman740e5182006-06-12 14:47:06 -0700432 = { .name = "ega", .start = 0x3C0, .end = 0x3DF };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 vga_video_type = VIDEO_TYPE_EGAC;
434 display_desc = "EGA";
435 request_resource(&ioport_resource,
436 &ega_console_resource);
437 } else {
438 static struct resource vga_console_resource
Greg Kroah-Hartman740e5182006-06-12 14:47:06 -0700439 = { .name = "vga+", .start = 0x3C0, .end = 0x3DF };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 vga_video_type = VIDEO_TYPE_VGAC;
441 display_desc = "VGA+";
442 request_resource(&ioport_resource,
443 &vga_console_resource);
444
445#ifdef VGA_CAN_DO_64KB
446 /*
447 * get 64K rather than 32K of video RAM.
448 * This doesn't actually work on all "VGA"
449 * controllers (it seems like setting MM=01
450 * and COE=1 isn't necessarily a good idea)
451 */
452 vga_vram_base = 0xa0000;
Bjorn Helgaas4f1bcaf2006-06-22 14:47:32 -0700453 vga_vram_size = 0x10000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 outb_p(6, VGA_GFX_I);
455 outb_p(6, VGA_GFX_D);
456#endif
457 /*
458 * Normalise the palette registers, to point
459 * the 16 screen colours to the first 16
460 * DAC entries.
461 */
462
463 for (i = 0; i < 16; i++) {
464 inb_p(VGA_IS1_RC);
465 outb_p(i, VGA_ATT_W);
466 outb_p(i, VGA_ATT_W);
467 }
468 outb_p(0x20, VGA_ATT_W);
469
470 /*
471 * Now set the DAC registers back to their
472 * default values
473 */
474 for (i = 0; i < 16; i++) {
475 outb_p(color_table[i], VGA_PEL_IW);
476 outb_p(default_red[i], VGA_PEL_D);
477 outb_p(default_grn[i], VGA_PEL_D);
478 outb_p(default_blu[i], VGA_PEL_D);
479 }
480 }
481 } else {
482 static struct resource cga_console_resource =
Greg Kroah-Hartman740e5182006-06-12 14:47:06 -0700483 { .name = "cga", .start = 0x3D4, .end = 0x3D5 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 vga_video_type = VIDEO_TYPE_CGA;
Bjorn Helgaas4f1bcaf2006-06-22 14:47:32 -0700485 vga_vram_size = 0x2000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 display_desc = "*CGA";
487 request_resource(&ioport_resource,
488 &cga_console_resource);
489 vga_video_font_height = 8;
490 }
491 }
492
Bjorn Helgaas4f1bcaf2006-06-22 14:47:32 -0700493 vga_vram_base = VGA_MAP_MEM(vga_vram_base, vga_vram_size);
494 vga_vram_end = vga_vram_base + vga_vram_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
496 /*
497 * Find out if there is a graphics card present.
498 * Are there smarter methods around?
499 */
500 p = (volatile u16 *) vga_vram_base;
501 saved1 = scr_readw(p);
502 saved2 = scr_readw(p + 1);
503 scr_writew(0xAA55, p);
504 scr_writew(0x55AA, p + 1);
505 if (scr_readw(p) != 0xAA55 || scr_readw(p + 1) != 0x55AA) {
506 scr_writew(saved1, p);
507 scr_writew(saved2, p + 1);
508 goto no_vga;
509 }
510 scr_writew(0x55AA, p);
511 scr_writew(0xAA55, p + 1);
512 if (scr_readw(p) != 0x55AA || scr_readw(p + 1) != 0xAA55) {
513 scr_writew(saved1, p);
514 scr_writew(saved2, p + 1);
515 goto no_vga;
516 }
517 scr_writew(saved1, p);
518 scr_writew(saved2, p + 1);
519
520 if (vga_video_type == VIDEO_TYPE_EGAC
521 || vga_video_type == VIDEO_TYPE_VGAC
522 || vga_video_type == VIDEO_TYPE_EGAM) {
523 vga_hardscroll_enabled = vga_hardscroll_user_enable;
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700524 vga_default_font_height = screen_info.orig_video_points;
525 vga_video_font_height = screen_info.orig_video_points;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 /* This may be suboptimal but is a safe bet - go with it */
527 vga_scan_lines =
528 vga_video_font_height * vga_video_num_lines;
529 }
Antonino A. Daplas53dbb262006-01-08 01:02:36 -0800530
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700531 vgacon_xres = screen_info.orig_video_cols * VGA_FONTWIDTH;
Antonino A. Daplas53dbb262006-01-08 01:02:36 -0800532 vgacon_yres = vga_scan_lines;
Antonino A. Daplas50ec42e2006-06-26 00:27:02 -0700533
534 if (!vga_init_done) {
535 vgacon_scrollback_startup();
536 vga_init_done = 1;
537 }
538
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 return display_desc;
540}
541
542static void vgacon_init(struct vc_data *c, int init)
543{
544 unsigned long p;
545
Antonino A. Daplas50ec42e2006-06-26 00:27:02 -0700546 /*
547 * We cannot be loaded as a module, therefore init is always 1,
548 * but vgacon_init can be called more than once, and init will
549 * not be 1.
550 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 c->vc_can_do_color = vga_can_do_color;
Antonino A. Daplas50ec42e2006-06-26 00:27:02 -0700552
553 /* set dimensions manually if init != 0 since vc_resize() will fail */
554 if (init) {
555 c->vc_cols = vga_video_num_columns;
556 c->vc_rows = vga_video_num_lines;
557 } else
558 vc_resize(c, vga_video_num_columns, vga_video_num_lines);
559
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 c->vc_scan_lines = vga_scan_lines;
561 c->vc_font.height = vga_video_font_height;
562 c->vc_complement_mask = 0x7700;
Bill Nottinghama40920b2005-05-01 08:59:07 -0700563 if (vga_512_chars)
564 c->vc_hi_font_mask = 0x0800;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 p = *c->vc_uni_pagedir_loc;
566 if (c->vc_uni_pagedir_loc == &c->vc_uni_pagedir ||
567 !--c->vc_uni_pagedir_loc[1])
568 con_free_unimap(c);
569 c->vc_uni_pagedir_loc = vgacon_uni_pagedir;
570 vgacon_uni_pagedir[1]++;
571 if (!vgacon_uni_pagedir[0] && p)
572 con_set_default_unimap(c);
573}
574
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575static void vgacon_deinit(struct vc_data *c)
576{
577 /* When closing the last console, reset video origin */
578 if (!--vgacon_uni_pagedir[1]) {
579 c->vc_visible_origin = vga_vram_base;
580 vga_set_mem_top(c);
581 con_free_unimap(c);
582 }
583 c->vc_uni_pagedir_loc = &c->vc_uni_pagedir;
584 con_set_default_unimap(c);
585}
586
587static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
Jan Engelhardtfa6ce9a2007-05-08 00:38:04 -0700588 u8 blink, u8 underline, u8 reverse, u8 italic)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589{
590 u8 attr = color;
591
592 if (vga_can_do_color) {
Jan Engelhardtfa6ce9a2007-05-08 00:38:04 -0700593 if (italic)
594 attr = (attr & 0xF0) | c->vc_itcolor;
595 else if (underline)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 attr = (attr & 0xf0) | c->vc_ulcolor;
597 else if (intensity == 0)
598 attr = (attr & 0xf0) | c->vc_halfcolor;
599 }
600 if (reverse)
601 attr =
602 ((attr) & 0x88) | ((((attr) >> 4) | ((attr) << 4)) &
603 0x77);
604 if (blink)
605 attr ^= 0x80;
606 if (intensity == 2)
607 attr ^= 0x08;
608 if (!vga_can_do_color) {
Jan Engelhardtfa6ce9a2007-05-08 00:38:04 -0700609 if (italic)
610 attr = (attr & 0xF8) | 0x02;
611 else if (underline)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 attr = (attr & 0xf8) | 0x01;
613 else if (intensity == 0)
614 attr = (attr & 0xf0) | 0x08;
615 }
616 return attr;
617}
618
619static void vgacon_invert_region(struct vc_data *c, u16 * p, int count)
620{
621 int col = vga_can_do_color;
622
623 while (count--) {
624 u16 a = scr_readw(p);
625 if (col)
626 a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) |
627 (((a) & 0x0700) << 4);
628 else
629 a ^= ((a & 0x0700) == 0x0100) ? 0x7000 : 0x7700;
630 scr_writew(a, p++);
631 }
632}
633
634static void vgacon_set_cursor_size(int xpos, int from, int to)
635{
636 unsigned long flags;
637 int curs, cure;
638
639#ifdef TRIDENT_GLITCH
640 if (xpos < 16)
641 from--, to--;
642#endif
643
644 if ((from == cursor_size_lastfrom) && (to == cursor_size_lastto))
645 return;
646 cursor_size_lastfrom = from;
647 cursor_size_lastto = to;
648
649 spin_lock_irqsave(&vga_lock, flags);
Samuel Thibault2115aea2006-03-27 01:17:19 -0800650 if (vga_video_type >= VIDEO_TYPE_VGAC) {
651 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
652 curs = inb_p(vga_video_port_val);
653 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
654 cure = inb_p(vga_video_port_val);
655 } else {
656 curs = 0;
657 cure = 0;
658 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
660 curs = (curs & 0xc0) | from;
661 cure = (cure & 0xe0) | to;
662
Samuel Thibault2115aea2006-03-27 01:17:19 -0800663 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 outb_p(curs, vga_video_port_val);
Samuel Thibault2115aea2006-03-27 01:17:19 -0800665 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 outb_p(cure, vga_video_port_val);
667 spin_unlock_irqrestore(&vga_lock, flags);
668}
669
670static void vgacon_cursor(struct vc_data *c, int mode)
671{
Antonino A. Daplas2ae85472007-05-08 00:40:06 -0700672 if (c->vc_mode != KD_TEXT)
673 return;
674
Antonino A. Daplas15bdab92006-03-27 01:17:20 -0800675 vgacon_restore_screen(c);
676
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 switch (mode) {
678 case CM_ERASE:
Samuel Thibault88dcb6c2005-11-05 22:19:50 +0100679 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
Samuel Thibault2115aea2006-03-27 01:17:19 -0800680 if (vga_video_type >= VIDEO_TYPE_VGAC)
681 vgacon_set_cursor_size(c->vc_x, 31, 30);
682 else
683 vgacon_set_cursor_size(c->vc_x, 31, 31);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 break;
685
686 case CM_MOVE:
687 case CM_DRAW:
688 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
689 switch (c->vc_cursor_type & 0x0f) {
690 case CUR_UNDERLINE:
691 vgacon_set_cursor_size(c->vc_x,
692 c->vc_font.height -
693 (c->vc_font.height <
694 10 ? 2 : 3),
695 c->vc_font.height -
696 (c->vc_font.height <
697 10 ? 1 : 2));
698 break;
699 case CUR_TWO_THIRDS:
700 vgacon_set_cursor_size(c->vc_x,
701 c->vc_font.height / 3,
702 c->vc_font.height -
703 (c->vc_font.height <
704 10 ? 1 : 2));
705 break;
706 case CUR_LOWER_THIRD:
707 vgacon_set_cursor_size(c->vc_x,
708 (c->vc_font.height * 2) / 3,
709 c->vc_font.height -
710 (c->vc_font.height <
711 10 ? 1 : 2));
712 break;
713 case CUR_LOWER_HALF:
714 vgacon_set_cursor_size(c->vc_x,
715 c->vc_font.height / 2,
716 c->vc_font.height -
717 (c->vc_font.height <
718 10 ? 1 : 2));
719 break;
720 case CUR_NONE:
Samuel Thibault2115aea2006-03-27 01:17:19 -0800721 if (vga_video_type >= VIDEO_TYPE_VGAC)
722 vgacon_set_cursor_size(c->vc_x, 31, 30);
723 else
724 vgacon_set_cursor_size(c->vc_x, 31, 31);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 break;
726 default:
727 vgacon_set_cursor_size(c->vc_x, 1,
728 c->vc_font.height);
729 break;
730 }
731 break;
732 }
733}
734
Samuel Thibault28254d42005-09-09 13:01:58 -0700735static int vgacon_doresize(struct vc_data *c,
736 unsigned int width, unsigned int height)
737{
738 unsigned long flags;
739 unsigned int scanlines = height * c->vc_font.height;
Samuel Thibaultd15212602006-02-24 13:03:59 -0800740 u8 scanlines_lo = 0, r7 = 0, vsync_end = 0, mode, max_scan;
Samuel Thibault28254d42005-09-09 13:01:58 -0700741
742 spin_lock_irqsave(&vga_lock, flags);
743
Antonino A. Daplas53dbb262006-01-08 01:02:36 -0800744 vgacon_xres = width * VGA_FONTWIDTH;
745 vgacon_yres = height * c->vc_font.height;
Samuel Thibaultd15212602006-02-24 13:03:59 -0800746 if (vga_video_type >= VIDEO_TYPE_VGAC) {
747 outb_p(VGA_CRTC_MAX_SCAN, vga_video_port_reg);
748 max_scan = inb_p(vga_video_port_val);
Samuel Thibault28254d42005-09-09 13:01:58 -0700749
Samuel Thibaultd15212602006-02-24 13:03:59 -0800750 if (max_scan & 0x80)
751 scanlines <<= 1;
Samuel Thibault28254d42005-09-09 13:01:58 -0700752
Samuel Thibaultd15212602006-02-24 13:03:59 -0800753 outb_p(VGA_CRTC_MODE, vga_video_port_reg);
754 mode = inb_p(vga_video_port_val);
Samuel Thibault28254d42005-09-09 13:01:58 -0700755
Samuel Thibaultd15212602006-02-24 13:03:59 -0800756 if (mode & 0x04)
757 scanlines >>= 1;
Samuel Thibault28254d42005-09-09 13:01:58 -0700758
Samuel Thibaultd15212602006-02-24 13:03:59 -0800759 scanlines -= 1;
760 scanlines_lo = scanlines & 0xff;
Samuel Thibault28254d42005-09-09 13:01:58 -0700761
Samuel Thibaultd15212602006-02-24 13:03:59 -0800762 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
763 r7 = inb_p(vga_video_port_val) & ~0x42;
764
765 if (scanlines & 0x100)
766 r7 |= 0x02;
767 if (scanlines & 0x200)
768 r7 |= 0x40;
769
770 /* deprotect registers */
771 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
772 vsync_end = inb_p(vga_video_port_val);
773 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
774 outb_p(vsync_end & ~0x80, vga_video_port_val);
775 }
Samuel Thibault28254d42005-09-09 13:01:58 -0700776
777 outb_p(VGA_CRTC_H_DISP, vga_video_port_reg);
778 outb_p(width - 1, vga_video_port_val);
779 outb_p(VGA_CRTC_OFFSET, vga_video_port_reg);
780 outb_p(width >> 1, vga_video_port_val);
781
Samuel Thibaultd15212602006-02-24 13:03:59 -0800782 if (vga_video_type >= VIDEO_TYPE_VGAC) {
783 outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg);
784 outb_p(scanlines_lo, vga_video_port_val);
785 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
786 outb_p(r7,vga_video_port_val);
Samuel Thibault28254d42005-09-09 13:01:58 -0700787
Samuel Thibaultd15212602006-02-24 13:03:59 -0800788 /* reprotect registers */
789 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
790 outb_p(vsync_end, vga_video_port_val);
791 }
Samuel Thibault28254d42005-09-09 13:01:58 -0700792
793 spin_unlock_irqrestore(&vga_lock, flags);
Samuel Thibault28254d42005-09-09 13:01:58 -0700794 return 0;
795}
796
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797static int vgacon_switch(struct vc_data *c)
798{
Antonino A. Daplas53dbb262006-01-08 01:02:36 -0800799 int x = c->vc_cols * VGA_FONTWIDTH;
800 int y = c->vc_rows * c->vc_font.height;
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700801 int rows = screen_info.orig_video_lines * vga_default_font_height/
Antonino A. Daplas53dbb262006-01-08 01:02:36 -0800802 c->vc_font.height;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 /*
804 * We need to save screen size here as it's the only way
805 * we can spot the screen has been resized and we need to
806 * set size of freshly allocated screens ourselves.
807 */
808 vga_video_num_columns = c->vc_cols;
809 vga_video_num_lines = c->vc_rows;
James Simmonsf18cd8f2005-06-21 17:17:00 -0700810
811 /* We can only copy out the size of the video buffer here,
812 * otherwise we get into VGA BIOS */
813
Samuel Thibault28254d42005-09-09 13:01:58 -0700814 if (!vga_is_gfx) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
Samuel Thibault28254d42005-09-09 13:01:58 -0700816 c->vc_screenbuf_size > vga_vram_size ?
817 vga_vram_size : c->vc_screenbuf_size);
Antonino A. Daplas53dbb262006-01-08 01:02:36 -0800818
819 if ((vgacon_xres != x || vgacon_yres != y) &&
820 (!(vga_video_num_columns % 2) &&
H. Peter Anvin3ea33512007-10-16 22:36:04 -0700821 vga_video_num_columns <= screen_info.orig_video_cols &&
Antonino A. Daplas53dbb262006-01-08 01:02:36 -0800822 vga_video_num_lines <= rows))
Samuel Thibault0aec4862005-10-16 20:29:22 -0700823 vgacon_doresize(c, c->vc_cols, c->vc_rows);
Samuel Thibault28254d42005-09-09 13:01:58 -0700824 }
825
Antonino A. Daplas15bdab92006-03-27 01:17:20 -0800826 vgacon_scrollback_init(c->vc_size_row);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 return 0; /* Redrawing not needed */
828}
829
830static void vga_set_palette(struct vc_data *vc, unsigned char *table)
831{
832 int i, j;
833
Pozsar Balazs1a66ddc2005-10-30 15:03:06 -0800834 vga_w(state.vgabase, VGA_PEL_MSK, 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 for (i = j = 0; i < 16; i++) {
836 vga_w(state.vgabase, VGA_PEL_IW, table[i]);
837 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
838 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
839 vga_w(state.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
840 }
841}
842
843static int vgacon_set_palette(struct vc_data *vc, unsigned char *table)
844{
845#ifdef CAN_LOAD_PALETTE
846 if (vga_video_type != VIDEO_TYPE_VGAC || vga_palette_blanked
847 || !CON_IS_VISIBLE(vc))
848 return -EINVAL;
849 vga_set_palette(vc, table);
850 return 0;
851#else
852 return -EINVAL;
853#endif
854}
855
856/* structure holding original VGA register settings */
857static struct {
858 unsigned char SeqCtrlIndex; /* Sequencer Index reg. */
859 unsigned char CrtCtrlIndex; /* CRT-Contr. Index reg. */
860 unsigned char CrtMiscIO; /* Miscellaneous register */
861 unsigned char HorizontalTotal; /* CRT-Controller:00h */
862 unsigned char HorizDisplayEnd; /* CRT-Controller:01h */
863 unsigned char StartHorizRetrace; /* CRT-Controller:04h */
864 unsigned char EndHorizRetrace; /* CRT-Controller:05h */
865 unsigned char Overflow; /* CRT-Controller:07h */
866 unsigned char StartVertRetrace; /* CRT-Controller:10h */
867 unsigned char EndVertRetrace; /* CRT-Controller:11h */
868 unsigned char ModeControl; /* CRT-Controller:17h */
869 unsigned char ClockingMode; /* Seq-Controller:01h */
870} vga_state;
871
872static void vga_vesa_blank(struct vgastate *state, int mode)
873{
874 /* save original values of VGA controller registers */
875 if (!vga_vesa_blanked) {
876 spin_lock_irq(&vga_lock);
877 vga_state.SeqCtrlIndex = vga_r(state->vgabase, VGA_SEQ_I);
878 vga_state.CrtCtrlIndex = inb_p(vga_video_port_reg);
879 vga_state.CrtMiscIO = vga_r(state->vgabase, VGA_MIS_R);
880 spin_unlock_irq(&vga_lock);
881
882 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */
883 vga_state.HorizontalTotal = inb_p(vga_video_port_val);
884 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */
885 vga_state.HorizDisplayEnd = inb_p(vga_video_port_val);
886 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
887 vga_state.StartHorizRetrace = inb_p(vga_video_port_val);
888 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
889 vga_state.EndHorizRetrace = inb_p(vga_video_port_val);
890 outb_p(0x07, vga_video_port_reg); /* Overflow */
891 vga_state.Overflow = inb_p(vga_video_port_val);
892 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
893 vga_state.StartVertRetrace = inb_p(vga_video_port_val);
894 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
895 vga_state.EndVertRetrace = inb_p(vga_video_port_val);
896 outb_p(0x17, vga_video_port_reg); /* ModeControl */
897 vga_state.ModeControl = inb_p(vga_video_port_val);
898 vga_state.ClockingMode = vga_rseq(state->vgabase, VGA_SEQ_CLOCK_MODE);
899 }
900
901 /* assure that video is enabled */
902 /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */
903 spin_lock_irq(&vga_lock);
904 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode | 0x20);
905
906 /* test for vertical retrace in process.... */
907 if ((vga_state.CrtMiscIO & 0x80) == 0x80)
908 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO & 0xEF);
909
910 /*
911 * Set <End of vertical retrace> to minimum (0) and
912 * <Start of vertical Retrace> to maximum (incl. overflow)
913 * Result: turn off vertical sync (VSync) pulse.
914 */
915 if (mode & VESA_VSYNC_SUSPEND) {
916 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
917 outb_p(0xff, vga_video_port_val); /* maximum value */
918 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
919 outb_p(0x40, vga_video_port_val); /* minimum (bits 0..3) */
920 outb_p(0x07, vga_video_port_reg); /* Overflow */
921 outb_p(vga_state.Overflow | 0x84, vga_video_port_val); /* bits 9,10 of vert. retrace */
922 }
923
924 if (mode & VESA_HSYNC_SUSPEND) {
925 /*
926 * Set <End of horizontal retrace> to minimum (0) and
927 * <Start of horizontal Retrace> to maximum
928 * Result: turn off horizontal sync (HSync) pulse.
929 */
930 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
931 outb_p(0xff, vga_video_port_val); /* maximum */
932 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
933 outb_p(0x00, vga_video_port_val); /* minimum (0) */
934 }
935
936 /* restore both index registers */
937 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
938 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
939 spin_unlock_irq(&vga_lock);
940}
941
942static void vga_vesa_unblank(struct vgastate *state)
943{
944 /* restore original values of VGA controller registers */
945 spin_lock_irq(&vga_lock);
946 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO);
947
948 outb_p(0x00, vga_video_port_reg); /* HorizontalTotal */
949 outb_p(vga_state.HorizontalTotal, vga_video_port_val);
950 outb_p(0x01, vga_video_port_reg); /* HorizDisplayEnd */
951 outb_p(vga_state.HorizDisplayEnd, vga_video_port_val);
952 outb_p(0x04, vga_video_port_reg); /* StartHorizRetrace */
953 outb_p(vga_state.StartHorizRetrace, vga_video_port_val);
954 outb_p(0x05, vga_video_port_reg); /* EndHorizRetrace */
955 outb_p(vga_state.EndHorizRetrace, vga_video_port_val);
956 outb_p(0x07, vga_video_port_reg); /* Overflow */
957 outb_p(vga_state.Overflow, vga_video_port_val);
958 outb_p(0x10, vga_video_port_reg); /* StartVertRetrace */
959 outb_p(vga_state.StartVertRetrace, vga_video_port_val);
960 outb_p(0x11, vga_video_port_reg); /* EndVertRetrace */
961 outb_p(vga_state.EndVertRetrace, vga_video_port_val);
962 outb_p(0x17, vga_video_port_reg); /* ModeControl */
963 outb_p(vga_state.ModeControl, vga_video_port_val);
964 /* ClockingMode */
965 vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode);
966
967 /* restore index/control registers */
968 vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
969 outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
970 spin_unlock_irq(&vga_lock);
971}
972
973static void vga_pal_blank(struct vgastate *state)
974{
975 int i;
976
Pozsar Balazs1a66ddc2005-10-30 15:03:06 -0800977 vga_w(state->vgabase, VGA_PEL_MSK, 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 for (i = 0; i < 16; i++) {
979 vga_w(state->vgabase, VGA_PEL_IW, i);
980 vga_w(state->vgabase, VGA_PEL_D, 0);
981 vga_w(state->vgabase, VGA_PEL_D, 0);
982 vga_w(state->vgabase, VGA_PEL_D, 0);
983 }
984}
985
986static int vgacon_blank(struct vc_data *c, int blank, int mode_switch)
987{
988 switch (blank) {
989 case 0: /* Unblank */
990 if (vga_vesa_blanked) {
991 vga_vesa_unblank(&state);
992 vga_vesa_blanked = 0;
993 }
994 if (vga_palette_blanked) {
995 vga_set_palette(c, color_table);
996 vga_palette_blanked = 0;
997 return 0;
998 }
999 vga_is_gfx = 0;
1000 /* Tell console.c that it has to restore the screen itself */
1001 return 1;
1002 case 1: /* Normal blanking */
1003 case -1: /* Obsolete */
1004 if (!mode_switch && vga_video_type == VIDEO_TYPE_VGAC) {
1005 vga_pal_blank(&state);
1006 vga_palette_blanked = 1;
1007 return 0;
1008 }
1009 vgacon_set_origin(c);
1010 scr_memsetw((void *) vga_vram_base, BLANK,
1011 c->vc_screenbuf_size);
1012 if (mode_switch)
1013 vga_is_gfx = 1;
1014 return 1;
1015 default: /* VESA blanking */
1016 if (vga_video_type == VIDEO_TYPE_VGAC) {
1017 vga_vesa_blank(&state, blank - 1);
1018 vga_vesa_blanked = blank;
1019 }
1020 return 0;
1021 }
1022}
1023
1024/*
1025 * PIO_FONT support.
1026 *
1027 * The font loading code goes back to the codepage package by
1028 * Joel Hoffman (joel@wam.umd.edu). (He reports that the original
1029 * reference is: "From: p. 307 of _Programmer's Guide to PC & PS/2
1030 * Video Systems_ by Richard Wilton. 1987. Microsoft Press".)
1031 *
1032 * Change for certain monochrome monitors by Yury Shevchuck
1033 * (sizif@botik.yaroslavl.su).
1034 */
1035
1036#ifdef CAN_LOAD_EGA_FONTS
1037
1038#define colourmap 0xa0000
1039/* Pauline Middelink <middelin@polyware.iaf.nl> reports that we
1040 should use 0xA0000 for the bwmap as well.. */
1041#define blackwmap 0xa0000
1042#define cmapsz 8192
1043
1044static int vgacon_do_font_op(struct vgastate *state,char *arg,int set,int ch512)
1045{
1046 unsigned short video_port_status = vga_video_port_reg + 6;
1047 int font_select = 0x00, beg, i;
1048 char *charmap;
1049
1050 if (vga_video_type != VIDEO_TYPE_EGAM) {
Bjorn Helgaas4f1bcaf2006-06-22 14:47:32 -07001051 charmap = (char *) VGA_MAP_MEM(colourmap, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 beg = 0x0e;
1053#ifdef VGA_CAN_DO_64KB
1054 if (vga_video_type == VIDEO_TYPE_VGAC)
1055 beg = 0x06;
1056#endif
1057 } else {
Bjorn Helgaas4f1bcaf2006-06-22 14:47:32 -07001058 charmap = (char *) VGA_MAP_MEM(blackwmap, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 beg = 0x0a;
1060 }
1061
1062#ifdef BROKEN_GRAPHICS_PROGRAMS
1063 /*
1064 * All fonts are loaded in slot 0 (0:1 for 512 ch)
1065 */
1066
1067 if (!arg)
1068 return -EINVAL; /* Return to default font not supported */
1069
1070 vga_font_is_default = 0;
1071 font_select = ch512 ? 0x04 : 0x00;
1072#else
1073 /*
1074 * The default font is kept in slot 0 and is never touched.
1075 * A custom font is loaded in slot 2 (256 ch) or 2:3 (512 ch)
1076 */
1077
1078 if (set) {
1079 vga_font_is_default = !arg;
1080 if (!arg)
1081 ch512 = 0; /* Default font is always 256 */
1082 font_select = arg ? (ch512 ? 0x0e : 0x0a) : 0x00;
1083 }
1084
1085 if (!vga_font_is_default)
1086 charmap += 4 * cmapsz;
1087#endif
1088
1089 unlock_kernel();
1090 spin_lock_irq(&vga_lock);
1091 /* First, the Sequencer */
1092 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1);
1093 /* CPU writes only to map 2 */
1094 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x04);
1095 /* Sequential addressing */
1096 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x07);
1097 /* Clear synchronous reset */
1098 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
1099
1100 /* Now, the graphics controller, select map 2 */
1101 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x02);
1102 /* disable odd-even addressing */
1103 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x00);
1104 /* map start at A000:0000 */
1105 vga_wgfx(state->vgabase, VGA_GFX_MISC, 0x00);
1106 spin_unlock_irq(&vga_lock);
1107
1108 if (arg) {
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 * In 512-character mode, the character map is not contiguous if
1118 * we want to remain EGA compatible -- which we do
1119 */
1120
1121 if (ch512) {
1122 charmap += 2 * cmapsz;
1123 arg += cmapsz;
1124 if (set)
1125 for (i = 0; i < cmapsz; i++)
1126 vga_writeb(arg[i], charmap + i);
1127 else
1128 for (i = 0; i < cmapsz; i++)
1129 arg[i] = vga_readb(charmap + i);
1130 }
1131 }
1132
1133 spin_lock_irq(&vga_lock);
1134 /* First, the sequencer, Synchronous reset */
1135 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x01);
1136 /* CPU writes to maps 0 and 1 */
1137 vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x03);
1138 /* odd-even addressing */
1139 vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x03);
1140 /* Character Map Select */
1141 if (set)
1142 vga_wseq(state->vgabase, VGA_SEQ_CHARACTER_MAP, font_select);
1143 /* clear synchronous reset */
1144 vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
1145
1146 /* Now, the graphics controller, select map 0 for CPU */
1147 vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x00);
1148 /* enable even-odd addressing */
1149 vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x10);
1150 /* map starts at b800:0 or b000:0 */
1151 vga_wgfx(state->vgabase, VGA_GFX_MISC, beg);
1152
1153 /* if 512 char mode is already enabled don't re-enable it. */
1154 if ((set) && (ch512 != vga_512_chars)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 /* attribute controller */
1156 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1157 struct vc_data *c = vc_cons[i].d;
1158 if (c && c->vc_sw == &vga_con)
1159 c->vc_hi_font_mask = ch512 ? 0x0800 : 0;
1160 }
1161 vga_512_chars = ch512;
1162 /* 256-char: enable intensity bit
1163 512-char: disable intensity bit */
1164 inb_p(video_port_status); /* clear address flip-flop */
1165 /* color plane enable register */
1166 vga_wattr(state->vgabase, VGA_ATC_PLANE_ENABLE, ch512 ? 0x07 : 0x0f);
1167 /* Wilton (1987) mentions the following; I don't know what
1168 it means, but it works, and it appears necessary */
1169 inb_p(video_port_status);
1170 vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0);
1171 }
1172 spin_unlock_irq(&vga_lock);
1173 lock_kernel();
1174 return 0;
1175}
1176
1177/*
1178 * Adjust the screen to fit a font of a certain height
1179 */
1180static int vgacon_adjust_height(struct vc_data *vc, unsigned fontheight)
1181{
1182 unsigned char ovr, vde, fsr;
1183 int rows, maxscan, i;
1184
1185 rows = vc->vc_scan_lines / fontheight; /* Number of video rows we end up with */
1186 maxscan = rows * fontheight - 1; /* Scan lines to actually display-1 */
1187
1188 /* Reprogram the CRTC for the new font size
1189 Note: the attempt to read the overflow register will fail
1190 on an EGA, but using 0xff for the previous value appears to
1191 be OK for EGA text modes in the range 257-512 scan lines, so I
1192 guess we don't need to worry about it.
1193
1194 The same applies for the spill bits in the font size and cursor
1195 registers; they are write-only on EGA, but it appears that they
1196 are all don't care bits on EGA, so I guess it doesn't matter. */
1197
1198 spin_lock_irq(&vga_lock);
1199 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */
1200 ovr = inb_p(vga_video_port_val);
1201 outb_p(0x09, vga_video_port_reg); /* Font size register */
1202 fsr = inb_p(vga_video_port_val);
1203 spin_unlock_irq(&vga_lock);
1204
1205 vde = maxscan & 0xff; /* Vertical display end reg */
1206 ovr = (ovr & 0xbd) + /* Overflow register */
1207 ((maxscan & 0x100) >> 7) + ((maxscan & 0x200) >> 3);
1208 fsr = (fsr & 0xe0) + (fontheight - 1); /* Font size register */
1209
1210 spin_lock_irq(&vga_lock);
1211 outb_p(0x07, vga_video_port_reg); /* CRTC overflow register */
1212 outb_p(ovr, vga_video_port_val);
1213 outb_p(0x09, vga_video_port_reg); /* Font size */
1214 outb_p(fsr, vga_video_port_val);
1215 outb_p(0x12, vga_video_port_reg); /* Vertical display limit */
1216 outb_p(vde, vga_video_port_val);
1217 spin_unlock_irq(&vga_lock);
Antonino A. Daplas5ef897c2005-11-21 21:32:26 -08001218 vga_video_font_height = fontheight;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219
1220 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1221 struct vc_data *c = vc_cons[i].d;
1222
1223 if (c && c->vc_sw == &vga_con) {
1224 if (CON_IS_VISIBLE(c)) {
1225 /* void size to cause regs to be rewritten */
1226 cursor_size_lastfrom = 0;
1227 cursor_size_lastto = 0;
1228 c->vc_sw->con_cursor(c, CM_DRAW);
1229 }
1230 c->vc_font.height = fontheight;
1231 vc_resize(c, 0, rows); /* Adjust console size */
1232 }
1233 }
1234 return 0;
1235}
1236
1237static int vgacon_font_set(struct vc_data *c, struct console_font *font, unsigned flags)
1238{
1239 unsigned charcount = font->charcount;
1240 int rc;
1241
1242 if (vga_video_type < VIDEO_TYPE_EGAM)
1243 return -EINVAL;
1244
Antonino A. Daplas53dbb262006-01-08 01:02:36 -08001245 if (font->width != VGA_FONTWIDTH ||
1246 (charcount != 256 && charcount != 512))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 return -EINVAL;
1248
1249 rc = vgacon_do_font_op(&state, font->data, 1, charcount == 512);
1250 if (rc)
1251 return rc;
1252
1253 if (!(flags & KD_FONT_FLAG_DONT_RECALC))
1254 rc = vgacon_adjust_height(c, font->height);
1255 return rc;
1256}
1257
1258static int vgacon_font_get(struct vc_data *c, struct console_font *font)
1259{
1260 if (vga_video_type < VIDEO_TYPE_EGAM)
1261 return -EINVAL;
1262
Antonino A. Daplas53dbb262006-01-08 01:02:36 -08001263 font->width = VGA_FONTWIDTH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 font->height = c->vc_font.height;
1265 font->charcount = vga_512_chars ? 512 : 256;
1266 if (!font->data)
1267 return 0;
1268 return vgacon_do_font_op(&state, font->data, 0, 0);
1269}
1270
1271#else
1272
1273#define vgacon_font_set NULL
1274#define vgacon_font_get NULL
1275
1276#endif
1277
Samuel Thibault28254d42005-09-09 13:01:58 -07001278static int vgacon_resize(struct vc_data *c, unsigned int width,
Antonino A. Daplase400b6e2007-10-16 01:29:35 -07001279 unsigned int height, unsigned int user)
Samuel Thibault28254d42005-09-09 13:01:58 -07001280{
H. Peter Anvin3ea33512007-10-16 22:36:04 -07001281 if (width % 2 || width > screen_info.orig_video_cols ||
1282 height > (screen_info.orig_video_lines * vga_default_font_height)/
Antonino A. Daplas6d36ba62005-09-15 21:14:56 +08001283 c->vc_font.height)
Antonino A. Daplase400b6e2007-10-16 01:29:35 -07001284 /* let svgatextmode tinker with video timings and
1285 return success */
1286 return (user) ? 0 : -EINVAL;
Samuel Thibault28254d42005-09-09 13:01:58 -07001287
1288 if (CON_IS_VISIBLE(c) && !vga_is_gfx) /* who knows */
1289 vgacon_doresize(c, width, height);
1290 return 0;
1291}
1292
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293static int vgacon_set_origin(struct vc_data *c)
1294{
1295 if (vga_is_gfx || /* We don't play origin tricks in graphic modes */
1296 (console_blanked && !vga_palette_blanked)) /* Nor we write to blanked screens */
1297 return 0;
1298 c->vc_origin = c->vc_visible_origin = vga_vram_base;
1299 vga_set_mem_top(c);
1300 vga_rolled_over = 0;
1301 return 1;
1302}
1303
1304static void vgacon_save_screen(struct vc_data *c)
1305{
1306 static int vga_bootup_console = 0;
1307
1308 if (!vga_bootup_console) {
1309 /* This is a gross hack, but here is the only place we can
1310 * set bootup console parameters without messing up generic
1311 * console initialization routines.
1312 */
1313 vga_bootup_console = 1;
H. Peter Anvin3ea33512007-10-16 22:36:04 -07001314 c->vc_x = screen_info.orig_x;
1315 c->vc_y = screen_info.orig_y;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 }
James Simmonsf18cd8f2005-06-21 17:17:00 -07001317
1318 /* We can't copy in more then the size of the video buffer,
1319 * or we'll be copying in VGA BIOS */
1320
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 if (!vga_is_gfx)
1322 scr_memcpyw((u16 *) c->vc_screenbuf, (u16 *) c->vc_origin,
James Simmonsf18cd8f2005-06-21 17:17:00 -07001323 c->vc_screenbuf_size > vga_vram_size ? vga_vram_size : c->vc_screenbuf_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324}
1325
1326static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
1327 int lines)
1328{
1329 unsigned long oldo;
1330 unsigned int delta;
1331
Antonino A. Daplas2ae85472007-05-08 00:40:06 -07001332 if (t || b != c->vc_rows || vga_is_gfx || c->vc_mode != KD_TEXT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 return 0;
1334
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2)
1336 return 0;
1337
Antonino A. Daplas15bdab92006-03-27 01:17:20 -08001338 vgacon_restore_screen(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 oldo = c->vc_origin;
1340 delta = lines * c->vc_size_row;
1341 if (dir == SM_UP) {
Antonino A. Daplas15bdab92006-03-27 01:17:20 -08001342 vgacon_scrollback_update(c, t, lines);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 if (c->vc_scr_end + delta >= vga_vram_end) {
1344 scr_memcpyw((u16 *) vga_vram_base,
1345 (u16 *) (oldo + delta),
1346 c->vc_screenbuf_size - delta);
1347 c->vc_origin = vga_vram_base;
1348 vga_rolled_over = oldo - vga_vram_base;
1349 } else
1350 c->vc_origin += delta;
1351 scr_memsetw((u16 *) (c->vc_origin + c->vc_screenbuf_size -
Linus Torvalds93f78da2008-10-14 12:12:02 -07001352 delta), c->vc_video_erase_char,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 delta);
1354 } else {
1355 if (oldo - delta < vga_vram_base) {
1356 scr_memmovew((u16 *) (vga_vram_end -
1357 c->vc_screenbuf_size +
1358 delta), (u16 *) oldo,
1359 c->vc_screenbuf_size - delta);
1360 c->vc_origin = vga_vram_end - c->vc_screenbuf_size;
1361 vga_rolled_over = 0;
1362 } else
1363 c->vc_origin -= delta;
1364 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
Linus Torvalds93f78da2008-10-14 12:12:02 -07001365 scr_memsetw((u16 *) (c->vc_origin), c->vc_video_erase_char,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 delta);
1367 }
1368 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1369 c->vc_visible_origin = c->vc_origin;
1370 vga_set_mem_top(c);
1371 c->vc_pos = (c->vc_pos - oldo) + c->vc_origin;
1372 return 1;
1373}
1374
1375
1376/*
1377 * The console `switch' structure for the VGA based console
1378 */
1379
1380static int vgacon_dummy(struct vc_data *c)
1381{
1382 return 0;
1383}
1384
1385#define DUMMY (void *) vgacon_dummy
1386
1387const struct consw vga_con = {
1388 .owner = THIS_MODULE,
1389 .con_startup = vgacon_startup,
1390 .con_init = vgacon_init,
1391 .con_deinit = vgacon_deinit,
1392 .con_clear = DUMMY,
1393 .con_putc = DUMMY,
1394 .con_putcs = DUMMY,
1395 .con_cursor = vgacon_cursor,
1396 .con_scroll = vgacon_scroll,
1397 .con_bmove = DUMMY,
1398 .con_switch = vgacon_switch,
1399 .con_blank = vgacon_blank,
1400 .con_font_set = vgacon_font_set,
1401 .con_font_get = vgacon_font_get,
Samuel Thibault28254d42005-09-09 13:01:58 -07001402 .con_resize = vgacon_resize,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 .con_set_palette = vgacon_set_palette,
1404 .con_scrolldelta = vgacon_scrolldelta,
1405 .con_set_origin = vgacon_set_origin,
1406 .con_save_screen = vgacon_save_screen,
1407 .con_build_attr = vgacon_build_attr,
1408 .con_invert_region = vgacon_invert_region,
1409};
1410
1411MODULE_LICENSE("GPL");