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