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