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