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