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