?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] Detaching fbcon: fix give_up_console()
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / char / vt.c
blobd7ff7fdb6fe3972f19f5b8db1e192e712ac08930
1 /*
2 * linux/drivers/char/vt.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7 /*
8 * Hopefully this will be a rather complete VT102 implementation.
9 *
10 * Beeping thanks to John T Kohl.
11 *
12 * Virtual Consoles, Screen Blanking, Screen Dumping, Color, Graphics
13 * Chars, and VT100 enhancements by Peter MacDonald.
14 *
15 * Copy and paste function by Andrew Haylett,
16 * some enhancements by Alessandro Rubini.
17 *
18 * Code to check for different video-cards mostly by Galen Hunt,
19 * <g-hunt@ee.utah.edu>
20 *
21 * Rudimentary ISO 10646/Unicode/UTF-8 character set support by
22 * Markus Kuhn, <mskuhn@immd4.informatik.uni-erlangen.de>.
23 *
24 * Dynamic allocation of consoles, aeb@cwi.nl, May 1994
25 * Resizing of consoles, aeb, 940926
26 *
27 * Code for xterm like mouse click reporting by Peter Orbaek 20-Jul-94
28 * <poe@daimi.aau.dk>
29 *
30 * User-defined bell sound, new setterm control sequences and printk
31 * redirection by Martin Mares <mj@k332.feld.cvut.cz> 19-Nov-95
32 *
33 * APM screenblank bug fixed Takashi Manabe <manabe@roy.dsl.tutics.tut.jp>
34 *
35 * Merge with the abstract console driver by Geert Uytterhoeven
36 * <geert@linux-m68k.org>, Jan 1997.
37 *
38 * Original m68k console driver modifications by
39 *
40 * - Arno Griffioen <arno@usn.nl>
41 * - David Carter <carter@cs.bris.ac.uk>
42 *
43 * The abstract console driver provides a generic interface for a text
44 * console. It supports VGA text mode, frame buffer based graphical consoles
45 * and special graphics processors that are only accessible through some
46 * registers (e.g. a TMS340x0 GSP).
47 *
48 * The interface to the hardware is specified using a special structure
49 * (struct consw) which contains function pointers to console operations
50 * (see <linux/console.h> for more information).
51 *
52 * Support for changeable cursor shape
53 * by Pavel Machek <pavel@atrey.karlin.mff.cuni.cz>, August 1997
54 *
55 * Ported to i386 and con_scrolldelta fixed
56 * by Emmanuel Marty <core@ggi-project.org>, April 1998
57 *
58 * Resurrected character buffers in videoram plus lots of other trickery
59 * by Martin Mares <mj@atrey.karlin.mff.cuni.cz>, July 1998
60 *
61 * Removed old-style timers, introduced console_timer, made timer
62 * deletion SMP-safe. 17Jun00, Andrew Morton <andrewm@uow.edu.au>
63 *
64 * Removed console_lock, enabled interrupts across all console operations
65 * 13 March 2001, Andrew Morton
66 */
67
68 #include <linux/module.h>
69 #include <linux/types.h>
70 #include <linux/sched.h>
71 #include <linux/tty.h>
72 #include <linux/tty_flip.h>
73 #include <linux/kernel.h>
74 #include <linux/string.h>
75 #include <linux/errno.h>
76 #include <linux/kd.h>
77 #include <linux/slab.h>
78 #include <linux/major.h>
79 #include <linux/mm.h>
80 #include <linux/console.h>
81 #include <linux/init.h>
82 #include <linux/devfs_fs_kernel.h>
83 #include <linux/vt_kern.h>
84 #include <linux/selection.h>
85 #include <linux/tiocl.h>
86 #include <linux/kbd_kern.h>
87 #include <linux/consolemap.h>
88 #include <linux/timer.h>
89 #include <linux/interrupt.h>
90 #include <linux/config.h>
91 #include <linux/workqueue.h>
92 #include <linux/bootmem.h>
93 #include <linux/pm.h>
94 #include <linux/font.h>
95 #include <linux/bitops.h>
96
97 #include <asm/io.h>
98 #include <asm/system.h>
99 #include <asm/uaccess.h>
100
101
102 const struct consw *conswitchp;
103 static struct consw *defcsw; /* default console */
104
105 /* A bitmap for codes <32. A bit of 1 indicates that the code
106 * corresponding to that bit number invokes some special action
107 * (such as cursor movement) and should not be displayed as a
108 * glyph unless the disp_ctrl mode is explicitly enabled.
109 */
110 #define CTRL_ACTION 0x0d00ff81
111 #define CTRL_ALWAYS 0x0800f501 /* Cannot be overridden by disp_ctrl */
112
113 /*
114 * Here is the default bell parameters: 750HZ, 1/8th of a second
115 */
116 #define DEFAULT_BELL_PITCH 750
117 #define DEFAULT_BELL_DURATION (HZ/8)
118
119 extern void vcs_make_devfs(struct tty_struct *tty);
120 extern void vcs_remove_devfs(struct tty_struct *tty);
121
122 extern void console_map_init(void);
123 #ifdef CONFIG_PROM_CONSOLE
124 extern void prom_con_init(void);
125 #endif
126 #ifdef CONFIG_MDA_CONSOLE
127 extern int mda_console_init(void);
128 #endif
129
130 struct vc vc_cons [MAX_NR_CONSOLES];
131
132 #ifndef VT_SINGLE_DRIVER
133 static const struct consw *con_driver_map[MAX_NR_CONSOLES];
134 #endif
135
136 static int con_open(struct tty_struct *, struct file *);
137 static void vc_init(struct vc_data *vc, unsigned int rows,
138 unsigned int cols, int do_clear);
139 static void gotoxy(struct vc_data *vc, int new_x, int new_y);
140 static void save_cur(struct vc_data *vc);
141 static void reset_terminal(struct vc_data *vc, int do_clear);
142 static void con_flush_chars(struct tty_struct *tty);
143 static void set_vesa_blanking(char __user *p);
144 static void set_cursor(struct vc_data *vc);
145 static void hide_cursor(struct vc_data *vc);
146 static void console_callback(void *ignored);
147 static void blank_screen_t(unsigned long dummy);
148 static void set_palette(struct vc_data *vc);
149
150 static int printable; /* Is console ready for printing? */
151
152 /*
153 * ignore_poke: don't unblank the screen when things are typed. This is
154 * mainly for the privacy of braille terminal users.
155 */
156 static int ignore_poke;
157
158 int do_poke_blanked_console;
159 int console_blanked;
160
161 static int vesa_blank_mode; /* 0:none 1:suspendV 2:suspendH 3:powerdown */
162 static int blankinterval = 10*60*HZ;
163 static int vesa_off_interval;
164
165 static DECLARE_WORK(console_work, console_callback, NULL);
166
167 /*
168 * fg_console is the current virtual console,
169 * last_console is the last used one,
170 * want_console is the console we want to switch to,
171 * kmsg_redirect is the console for kernel messages,
172 */
173 int fg_console;
174 int last_console;
175 int want_console = -1;
176 int kmsg_redirect;
177
178 /*
179 * For each existing display, we have a pointer to console currently visible
180 * on that display, allowing consoles other than fg_console to be refreshed
181 * appropriately. Unless the low-level driver supplies its own display_fg
182 * variable, we use this one for the "master display".
183 */
184 static struct vc_data *master_display_fg;
185
186 /*
187 * Unfortunately, we need to delay tty echo when we're currently writing to the
188 * console since the code is (and always was) not re-entrant, so we schedule
189 * all flip requests to process context with schedule-task() and run it from
190 * console_callback().
191 */
192
193 /*
194 * For the same reason, we defer scrollback to the console callback.
195 */
196 static int scrollback_delta;
197
198 /*
199 * Hook so that the power management routines can (un)blank
200 * the console on our behalf.
201 */
202 int (*console_blank_hook)(int);
203
204 static struct timer_list console_timer;
205 static int blank_state;
206 static int blank_timer_expired;
207 enum {
208 blank_off = 0,
209 blank_normal_wait,
210 blank_vesa_wait,
211 };
212
213 /*
214 * Low-Level Functions
215 */
216
217 #define IS_FG(vc) ((vc)->vc_num == fg_console)
218
219 #ifdef VT_BUF_VRAM_ONLY
220 #define DO_UPDATE(vc) 0
221 #else
222 #define DO_UPDATE(vc) CON_IS_VISIBLE(vc)
223 #endif
224
225 static inline unsigned short *screenpos(struct vc_data *vc, int offset, int viewed)
226 {
227 unsigned short *p;
228
229 if (!viewed)
230 p = (unsigned short *)(vc->vc_origin + offset);
231 else if (!vc->vc_sw->con_screen_pos)
232 p = (unsigned short *)(vc->vc_visible_origin + offset);
233 else
234 p = vc->vc_sw->con_screen_pos(vc, offset);
235 return p;
236 }
237
238 static inline void scrolldelta(int lines)
239 {
240 scrollback_delta += lines;
241 schedule_console_callback();
242 }
243
244 void schedule_console_callback(void)
245 {
246 schedule_work(&console_work);
247 }
248
249 static void scrup(struct vc_data *vc, unsigned int t, unsigned int b, int nr)
250 {
251 unsigned short *d, *s;
252
253 if (t+nr >= b)
254 nr = b - t - 1;
255 if (b > vc->vc_rows || t >= b || nr < 1)
256 return;
257 if (CON_IS_VISIBLE(vc) && vc->vc_sw->con_scroll(vc, t, b, SM_UP, nr))
258 return;
259 d = (unsigned short *)(vc->vc_origin + vc->vc_size_row * t);
260 s = (unsigned short *)(vc->vc_origin + vc->vc_size_row * (t + nr));
261 scr_memmovew(d, s, (b - t - nr) * vc->vc_size_row);
262 scr_memsetw(d + (b - t - nr) * vc->vc_cols, vc->vc_video_erase_char,
263 vc->vc_size_row * nr);
264 }
265
266 static void scrdown(struct vc_data *vc, unsigned int t, unsigned int b, int nr)
267 {
268 unsigned short *s;
269 unsigned int step;
270
271 if (t+nr >= b)
272 nr = b - t - 1;
273 if (b > vc->vc_rows || t >= b || nr < 1)
274 return;
275 if (CON_IS_VISIBLE(vc) && vc->vc_sw->con_scroll(vc, t, b, SM_DOWN, nr))
276 return;
277 s = (unsigned short *)(vc->vc_origin + vc->vc_size_row * t);
278 step = vc->vc_cols * nr;
279 scr_memmovew(s + step, s, (b - t - nr) * vc->vc_size_row);
280 scr_memsetw(s, vc->vc_video_erase_char, 2 * step);
281 }
282
283 static void do_update_region(struct vc_data *vc, unsigned long start, int count)
284 {
285 #ifndef VT_BUF_VRAM_ONLY
286 unsigned int xx, yy, offset;
287 u16 *p;
288
289 p = (u16 *) start;
290 if (!vc->vc_sw->con_getxy) {
291 offset = (start - vc->vc_origin) / 2;
292 xx = offset % vc->vc_cols;
293 yy = offset / vc->vc_cols;
294 } else {
295 int nxx, nyy;
296 start = vc->vc_sw->con_getxy(vc, start, &nxx, &nyy);
297 xx = nxx; yy = nyy;
298 }
299 for(;;) {
300 u16 attrib = scr_readw(p) & 0xff00;
301 int startx = xx;
302 u16 *q = p;
303 while (xx < vc->vc_cols && count) {
304 if (attrib != (scr_readw(p) & 0xff00)) {
305 if (p > q)
306 vc->vc_sw->con_putcs(vc, q, p-q, yy, startx);
307 startx = xx;
308 q = p;
309 attrib = scr_readw(p) & 0xff00;
310 }
311 p++;
312 xx++;
313 count--;
314 }
315 if (p > q)
316 vc->vc_sw->con_putcs(vc, q, p-q, yy, startx);
317 if (!count)
318 break;
319 xx = 0;
320 yy++;
321 if (vc->vc_sw->con_getxy) {
322 p = (u16 *)start;
323 start = vc->vc_sw->con_getxy(vc, start, NULL, NULL);
324 }
325 }
326 #endif
327 }
328
329 void update_region(struct vc_data *vc, unsigned long start, int count)
330 {
331 WARN_CONSOLE_UNLOCKED();
332
333 if (DO_UPDATE(vc)) {
334 hide_cursor(vc);
335 do_update_region(vc, start, count);
336 set_cursor(vc);
337 }
338 }
339
340 /* Structure of attributes is hardware-dependent */
341
342 static u8 build_attr(struct vc_data *vc, u8 _color, u8 _intensity, u8 _blink, u8 _underline, u8 _reverse)
343 {
344 if (vc->vc_sw->con_build_attr)
345 return vc->vc_sw->con_build_attr(vc, _color, _intensity, _blink, _underline, _reverse);
346
347 #ifndef VT_BUF_VRAM_ONLY
348 /*
349 * ++roman: I completely changed the attribute format for monochrome
350 * mode (!can_do_color). The formerly used MDA (monochrome display
351 * adapter) format didn't allow the combination of certain effects.
352 * Now the attribute is just a bit vector:
353 * Bit 0..1: intensity (0..2)
354 * Bit 2 : underline
355 * Bit 3 : reverse
356 * Bit 7 : blink
357 */
358 {
359 u8 a = vc->vc_color;
360 if (!vc->vc_can_do_color)
361 return _intensity |
362 (_underline ? 4 : 0) |
363 (_reverse ? 8 : 0) |
364 (_blink ? 0x80 : 0);
365 if (_underline)
366 a = (a & 0xf0) | vc->vc_ulcolor;
367 else if (_intensity == 0)
368 a = (a & 0xf0) | vc->vc_ulcolor;
369 if (_reverse)
370 a = ((a) & 0x88) | ((((a) >> 4) | ((a) << 4)) & 0x77);
371 if (_blink)
372 a ^= 0x80;
373 if (_intensity == 2)
374 a ^= 0x08;
375 if (vc->vc_hi_font_mask == 0x100)
376 a <<= 1;
377 return a;
378 }
379 #else
380 return 0;
381 #endif
382 }
383
384 static void update_attr(struct vc_data *vc)
385 {
386 vc->vc_attr = build_attr(vc, vc->vc_color, vc->vc_intensity, vc->vc_blink, vc->vc_underline, vc->vc_reverse ^ vc->vc_decscnm);
387 vc->vc_video_erase_char = (build_attr(vc, vc->vc_color, 1, vc->vc_blink, 0, vc->vc_decscnm) << 8) | ' ';
388 }
389
390 /* Note: inverting the screen twice should revert to the original state */
391 void invert_screen(struct vc_data *vc, int offset, int count, int viewed)
392 {
393 unsigned short *p;
394
395 WARN_CONSOLE_UNLOCKED();
396
397 count /= 2;
398 p = screenpos(vc, offset, viewed);
399 if (vc->vc_sw->con_invert_region)
400 vc->vc_sw->con_invert_region(vc, p, count);
401 #ifndef VT_BUF_VRAM_ONLY
402 else {
403 u16 *q = p;
404 int cnt = count;
405 u16 a;
406
407 if (!vc->vc_can_do_color) {
408 while (cnt--) {
409 a = scr_readw(q);
410 a ^= 0x0800;
411 scr_writew(a, q);
412 q++;
413 }
414 } else if (vc->vc_hi_font_mask == 0x100) {
415 while (cnt--) {
416 a = scr_readw(q);
417 a = ((a) & 0x11ff) | (((a) & 0xe000) >> 4) | (((a) & 0x0e00) << 4);
418 scr_writew(a, q);
419 q++;
420 }
421 } else {
422 while (cnt--) {
423 a = scr_readw(q);
424 a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) | (((a) & 0x0700) << 4);
425 scr_writew(a, q);
426 q++;
427 }
428 }
429 }
430 #endif
431 if (DO_UPDATE(vc))
432 do_update_region(vc, (unsigned long) p, count);
433 }
434
435 /* used by selection: complement pointer position */
436 void complement_pos(struct vc_data *vc, int offset)
437 {
438 static int old_offset = -1;
439 static unsigned short old;
440 static unsigned short oldx, oldy;
441
442 WARN_CONSOLE_UNLOCKED();
443
444 if (old_offset != -1 && old_offset >= 0 &&
445 old_offset < vc->vc_screenbuf_size) {
446 scr_writew(old, screenpos(vc, old_offset, 1));
447 if (DO_UPDATE(vc))
448 vc->vc_sw->con_putc(vc, old, oldy, oldx);
449 }
450
451 old_offset = offset;
452
453 if (offset != -1 && offset >= 0 &&
454 offset < vc->vc_screenbuf_size) {
455 unsigned short new;
456 unsigned short *p;
457 p = screenpos(vc, offset, 1);
458 old = scr_readw(p);
459 new = old ^ vc->vc_complement_mask;
460 scr_writew(new, p);
461 if (DO_UPDATE(vc)) {
462 oldx = (offset >> 1) % vc->vc_cols;
463 oldy = (offset >> 1) / vc->vc_cols;
464 vc->vc_sw->con_putc(vc, new, oldy, oldx);
465 }
466 }
467
468 }
469
470 static void insert_char(struct vc_data *vc, unsigned int nr)
471 {
472 unsigned short *p, *q = (unsigned short *)vc->vc_pos;
473
474 p = q + vc->vc_cols - nr - vc->vc_x;
475 while (--p >= q)
476 scr_writew(scr_readw(p), p + nr);
477 scr_memsetw(q, vc->vc_video_erase_char, nr * 2);
478 vc->vc_need_wrap = 0;
479 if (DO_UPDATE(vc)) {
480 unsigned short oldattr = vc->vc_attr;
481 vc->vc_sw->con_bmove(vc, vc->vc_y, vc->vc_x, vc->vc_y, vc->vc_x + nr, 1,
482 vc->vc_cols - vc->vc_x - nr);
483 vc->vc_attr = vc->vc_video_erase_char >> 8;
484 while (nr--)
485 vc->vc_sw->con_putc(vc, vc->vc_video_erase_char, vc->vc_y, vc->vc_x + nr);
486 vc->vc_attr = oldattr;
487 }
488 }
489
490 static void delete_char(struct vc_data *vc, unsigned int nr)
491 {
492 unsigned int i = vc->vc_x;
493 unsigned short *p = (unsigned short *)vc->vc_pos;
494
495 while (++i <= vc->vc_cols - nr) {
496 scr_writew(scr_readw(p+nr), p);
497 p++;
498 }
499 scr_memsetw(p, vc->vc_video_erase_char, nr * 2);
500 vc->vc_need_wrap = 0;
501 if (DO_UPDATE(vc)) {
502 unsigned short oldattr = vc->vc_attr;
503 vc->vc_sw->con_bmove(vc, vc->vc_y, vc->vc_x + nr, vc->vc_y, vc->vc_x, 1,
504 vc->vc_cols - vc->vc_x - nr);
505 vc->vc_attr = vc->vc_video_erase_char >> 8;
506 while (nr--)
507 vc->vc_sw->con_putc(vc, vc->vc_video_erase_char, vc->vc_y,
508 vc->vc_cols - 1 - nr);
509 vc->vc_attr = oldattr;
510 }
511 }
512
513 static int softcursor_original;
514
515 static void add_softcursor(struct vc_data *vc)
516 {
517 int i = scr_readw((u16 *) vc->vc_pos);
518 u32 type = vc->vc_cursor_type;
519
520 if (! (type & 0x10)) return;
521 if (softcursor_original != -1) return;
522 softcursor_original = i;
523 i |= ((type >> 8) & 0xff00 );
524 i ^= ((type) & 0xff00 );
525 if ((type & 0x20) && ((softcursor_original & 0x7000) == (i & 0x7000))) i ^= 0x7000;
526 if ((type & 0x40) && ((i & 0x700) == ((i & 0x7000) >> 4))) i ^= 0x0700;
527 scr_writew(i, (u16 *) vc->vc_pos);
528 if (DO_UPDATE(vc))
529 vc->vc_sw->con_putc(vc, i, vc->vc_y, vc->vc_x);
530 }
531
532 static void hide_softcursor(struct vc_data *vc)
533 {
534 if (softcursor_original != -1) {
535 scr_writew(softcursor_original, (u16 *)vc->vc_pos);
536 if (DO_UPDATE(vc))
537 vc->vc_sw->con_putc(vc, softcursor_original,
538 vc->vc_y, vc->vc_x);
539 softcursor_original = -1;
540 }
541 }
542
543 static void hide_cursor(struct vc_data *vc)
544 {
545 if (vc == sel_cons)
546 clear_selection();
547 vc->vc_sw->con_cursor(vc, CM_ERASE);
548 hide_softcursor(vc);
549 }
550
551 static void set_cursor(struct vc_data *vc)
552 {
553 if (!IS_FG(vc) || console_blanked ||
554 vc->vc_mode == KD_GRAPHICS)
555 return;
556 if (vc->vc_deccm) {
557 if (vc == sel_cons)
558 clear_selection();
559 add_softcursor(vc);
560 if ((vc->vc_cursor_type & 0x0f) != 1)
561 vc->vc_sw->con_cursor(vc, CM_DRAW);
562 } else
563 hide_cursor(vc);
564 }
565
566 static void set_origin(struct vc_data *vc)
567 {
568 WARN_CONSOLE_UNLOCKED();
569
570 if (!CON_IS_VISIBLE(vc) ||
571 !vc->vc_sw->con_set_origin ||
572 !vc->vc_sw->con_set_origin(vc))
573 vc->vc_origin = (unsigned long)vc->vc_screenbuf;
574 vc->vc_visible_origin = vc->vc_origin;
575 vc->vc_scr_end = vc->vc_origin + vc->vc_screenbuf_size;
576 vc->vc_pos = vc->vc_origin + vc->vc_size_row * vc->vc_y + 2 * vc->vc_x;
577 }
578
579 static inline void save_screen(struct vc_data *vc)
580 {
581 WARN_CONSOLE_UNLOCKED();
582
583 if (vc->vc_sw->con_save_screen)
584 vc->vc_sw->con_save_screen(vc);
585 }
586
587 /*
588 * Redrawing of screen
589 */
590
591 static void clear_buffer_attributes(struct vc_data *vc)
592 {
593 unsigned short *p = (unsigned short *)vc->vc_origin;
594 int count = vc->vc_screenbuf_size / 2;
595 int mask = vc->vc_hi_font_mask | 0xff;
596
597 for (; count > 0; count--, p++) {
598 scr_writew((scr_readw(p)&mask) | (vc->vc_video_erase_char & ~mask), p);
599 }
600 }
601
602 void redraw_screen(struct vc_data *vc, int is_switch)
603 {
604 int redraw = 0;
605
606 WARN_CONSOLE_UNLOCKED();
607
608 if (!vc) {
609 /* strange ... */
610 /* printk("redraw_screen: tty %d not allocated ??\n", new_console+1); */
611 return;
612 }
613
614 if (is_switch) {
615 struct vc_data *old_vc = vc_cons[fg_console].d;
616 if (old_vc == vc)
617 return;
618 if (!CON_IS_VISIBLE(vc))
619 redraw = 1;
620 *vc->vc_display_fg = vc;
621 fg_console = vc->vc_num;
622 hide_cursor(old_vc);
623 if (!CON_IS_VISIBLE(old_vc)) {
624 save_screen(old_vc);
625 set_origin(old_vc);
626 }
627 } else {
628 hide_cursor(vc);
629 redraw = 1;
630 }
631
632 if (redraw) {
633 int update;
634 int old_was_color = vc->vc_can_do_color;
635
636 set_origin(vc);
637 update = vc->vc_sw->con_switch(vc);
638 set_palette(vc);
639 /*
640 * If console changed from mono<->color, the best we can do
641 * is to clear the buffer attributes. As it currently stands,
642 * rebuilding new attributes from the old buffer is not doable
643 * without overly complex code.
644 */
645 if (old_was_color != vc->vc_can_do_color) {
646 update_attr(vc);
647 clear_buffer_attributes(vc);
648 }
649 if (update && vc->vc_mode != KD_GRAPHICS)
650 do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2);
651 }
652 set_cursor(vc);
653 if (is_switch) {
654 set_leds();
655 compute_shiftstate();
656 }
657 }
658
659 /*
660 * Allocation, freeing and resizing of VTs.
661 */
662
663 int vc_cons_allocated(unsigned int i)
664 {
665 return (i < MAX_NR_CONSOLES && vc_cons[i].d);
666 }
667
668 static void visual_init(struct vc_data *vc, int num, int init)
669 {
670 /* ++Geert: vc->vc_sw->con_init determines console size */
671 if (vc->vc_sw)
672 module_put(vc->vc_sw->owner);
673 vc->vc_sw = conswitchp;
674 #ifndef VT_SINGLE_DRIVER
675 if (con_driver_map[num])
676 vc->vc_sw = con_driver_map[num];
677 #endif
678 __module_get(vc->vc_sw->owner);
679 vc->vc_num = num;
680 vc->vc_display_fg = &master_display_fg;
681 vc->vc_uni_pagedir_loc = &vc->vc_uni_pagedir;
682 vc->vc_uni_pagedir = 0;
683 vc->vc_hi_font_mask = 0;
684 vc->vc_complement_mask = 0;
685 vc->vc_can_do_color = 0;
686 vc->vc_sw->con_init(vc, init);
687 if (!vc->vc_complement_mask)
688 vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
689 vc->vc_s_complement_mask = vc->vc_complement_mask;
690 vc->vc_size_row = vc->vc_cols << 1;
691 vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row;
692 }
693
694 int vc_allocate(unsigned int currcons) /* return 0 on success */
695 {
696 WARN_CONSOLE_UNLOCKED();
697
698 if (currcons >= MAX_NR_CONSOLES)
699 return -ENXIO;
700 if (!vc_cons[currcons].d) {
701 struct vc_data *vc;
702
703 /* prevent users from taking too much memory */
704 if (currcons >= MAX_NR_USER_CONSOLES && !capable(CAP_SYS_RESOURCE))
705 return -EPERM;
706
707 /* due to the granularity of kmalloc, we waste some memory here */
708 /* the alloc is done in two steps, to optimize the common situation
709 of a 25x80 console (structsize=216, screenbuf_size=4000) */
710 /* although the numbers above are not valid since long ago, the
711 point is still up-to-date and the comment still has its value
712 even if only as a historical artifact. --mj, July 1998 */
713 vc = kmalloc(sizeof(struct vc_data), GFP_KERNEL);
714 if (!vc)
715 return -ENOMEM;
716 memset(vc, 0, sizeof(*vc));
717 vc_cons[currcons].d = vc;
718 visual_init(vc, currcons, 1);
719 if (!*vc->vc_uni_pagedir_loc)
720 con_set_default_unimap(vc);
721 vc->vc_screenbuf = kmalloc(vc->vc_screenbuf_size, GFP_KERNEL);
722 if (!vc->vc_screenbuf) {
723 kfree(vc);
724 vc_cons[currcons].d = NULL;
725 return -ENOMEM;
726 }
727 vc->vc_kmalloced = 1;
728 vc_init(vc, vc->vc_rows, vc->vc_cols, 1);
729 }
730 return 0;
731 }
732
733 static inline int resize_screen(struct vc_data *vc, int width, int height)
734 {
735 /* Resizes the resolution of the display adapater */
736 int err = 0;
737
738 if (vc->vc_mode != KD_GRAPHICS && vc->vc_sw->con_resize)
739 err = vc->vc_sw->con_resize(vc, width, height);
740 return err;
741 }
742
743 /*
744 * Change # of rows and columns (0 means unchanged/the size of fg_console)
745 * [this is to be used together with some user program
746 * like resize that changes the hardware videomode]
747 */
748 #define VC_RESIZE_MAXCOL (32767)
749 #define VC_RESIZE_MAXROW (32767)
750 int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines)
751 {
752 unsigned long old_origin, new_origin, new_scr_end, rlth, rrem, err = 0;
753 unsigned int old_cols, old_rows, old_row_size, old_screen_size;
754 unsigned int new_cols, new_rows, new_row_size, new_screen_size;
755 unsigned int end;
756 unsigned short *newscreen;
757
758 WARN_CONSOLE_UNLOCKED();
759
760 if (!vc)
761 return -ENXIO;
762
763 if (cols > VC_RESIZE_MAXCOL || lines > VC_RESIZE_MAXROW)
764 return -EINVAL;
765
766 new_cols = (cols ? cols : vc->vc_cols);
767 new_rows = (lines ? lines : vc->vc_rows);
768 new_row_size = new_cols << 1;
769 new_screen_size = new_row_size * new_rows;
770
771 if (new_cols == vc->vc_cols && new_rows == vc->vc_rows)
772 return 0;
773
774 newscreen = (unsigned short *) kmalloc(new_screen_size, GFP_USER);
775 if (!newscreen)
776 return -ENOMEM;
777
778 old_rows = vc->vc_rows;
779 old_cols = vc->vc_cols;
780 old_row_size = vc->vc_size_row;
781 old_screen_size = vc->vc_screenbuf_size;
782
783 err = resize_screen(vc, new_cols, new_rows);
784 if (err) {
785 kfree(newscreen);
786 return err;
787 }
788
789 vc->vc_rows = new_rows;
790 vc->vc_cols = new_cols;
791 vc->vc_size_row = new_row_size;
792 vc->vc_screenbuf_size = new_screen_size;
793
794 rlth = min(old_row_size, new_row_size);
795 rrem = new_row_size - rlth;
796 old_origin = vc->vc_origin;
797 new_origin = (long) newscreen;
798 new_scr_end = new_origin + new_screen_size;
799
800 if (vc->vc_y > new_rows) {
801 if (old_rows - vc->vc_y < new_rows) {
802 /*
803 * Cursor near the bottom, copy contents from the
804 * bottom of buffer
805 */
806 old_origin += (old_rows - new_rows) * old_row_size;
807 end = vc->vc_scr_end;
808 } else {
809 /*
810 * Cursor is in no man's land, copy 1/2 screenful
811 * from the top and bottom of cursor position
812 */
813 old_origin += (vc->vc_y - new_rows/2) * old_row_size;
814 end = old_origin + (old_row_size * new_rows);
815 }
816 } else
817 /*
818 * Cursor near the top, copy contents from the top of buffer
819 */
820 end = (old_rows > new_rows) ? old_origin +
821 (old_row_size * new_rows) :
822 vc->vc_scr_end;
823
824 update_attr(vc);
825
826 while (old_origin < end) {
827 scr_memcpyw((unsigned short *) new_origin,
828 (unsigned short *) old_origin, rlth);
829 if (rrem)
830 scr_memsetw((void *)(new_origin + rlth),
831 vc->vc_video_erase_char, rrem);
832 old_origin += old_row_size;
833 new_origin += new_row_size;
834 }
835 if (new_scr_end > new_origin)
836 scr_memsetw((void *)new_origin, vc->vc_video_erase_char,
837 new_scr_end - new_origin);
838 if (vc->vc_kmalloced)
839 kfree(vc->vc_screenbuf);
840 vc->vc_screenbuf = newscreen;
841 vc->vc_kmalloced = 1;
842 vc->vc_screenbuf_size = new_screen_size;
843 set_origin(vc);
844
845 /* do part of a reset_terminal() */
846 vc->vc_top = 0;
847 vc->vc_bottom = vc->vc_rows;
848 gotoxy(vc, vc->vc_x, vc->vc_y);
849 save_cur(vc);
850
851 if (vc->vc_tty) {
852 struct winsize ws, *cws = &vc->vc_tty->winsize;
853
854 memset(&ws, 0, sizeof(ws));
855 ws.ws_row = vc->vc_rows;
856 ws.ws_col = vc->vc_cols;
857 ws.ws_ypixel = vc->vc_scan_lines;
858 if ((ws.ws_row != cws->ws_row || ws.ws_col != cws->ws_col) &&
859 vc->vc_tty->pgrp > 0)
860 kill_pg(vc->vc_tty->pgrp, SIGWINCH, 1);
861 *cws = ws;
862 }
863
864 if (CON_IS_VISIBLE(vc))
865 update_screen(vc);
866 return err;
867 }
868
869
870 void vc_disallocate(unsigned int currcons)
871 {
872 WARN_CONSOLE_UNLOCKED();
873
874 if (vc_cons_allocated(currcons)) {
875 struct vc_data *vc = vc_cons[currcons].d;
876 vc->vc_sw->con_deinit(vc);
877 if (vc->vc_kmalloced)
878 kfree(vc->vc_screenbuf);
879 if (currcons >= MIN_NR_CONSOLES)
880 kfree(vc);
881 vc_cons[currcons].d = NULL;
882 }
883 }
884
885 /*
886 * VT102 emulator
887 */
888
889 #define set_kbd(vc, x) set_vc_kbd_mode(kbd_table + (vc)->vc_num, (x))
890 #define clr_kbd(vc, x) clr_vc_kbd_mode(kbd_table + (vc)->vc_num, (x))
891 #define is_kbd(vc, x) vc_kbd_mode(kbd_table + (vc)->vc_num, (x))
892
893 #define decarm VC_REPEAT
894 #define decckm VC_CKMODE
895 #define kbdapplic VC_APPLIC
896 #define lnm VC_CRLF
897
898 /*
899 * this is what the terminal answers to a ESC-Z or csi0c query.
900 */
901 #define VT100ID "\033[?1;2c"
902 #define VT102ID "\033[?6c"
903
904 unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,
905 8,12,10,14, 9,13,11,15 };
906
907 /* the default colour table, for VGA+ colour systems */
908 int default_red[] = {0x00,0xaa,0x00,0xaa,0x00,0xaa,0x00,0xaa,
909 0x55,0xff,0x55,0xff,0x55,0xff,0x55,0xff};
910 int default_grn[] = {0x00,0x00,0xaa,0x55,0x00,0x00,0xaa,0xaa,
911 0x55,0x55,0xff,0xff,0x55,0x55,0xff,0xff};
912 int default_blu[] = {0x00,0x00,0x00,0x00,0xaa,0xaa,0xaa,0xaa,
913 0x55,0x55,0x55,0x55,0xff,0xff,0xff,0xff};
914
915 /*
916 * gotoxy() must verify all boundaries, because the arguments
917 * might also be negative. If the given position is out of
918 * bounds, the cursor is placed at the nearest margin.
919 */
920 static void gotoxy(struct vc_data *vc, int new_x, int new_y)
921 {
922 int min_y, max_y;
923
924 if (new_x < 0)
925 vc->vc_x = 0;
926 else {
927 if (new_x >= vc->vc_cols)
928 vc->vc_x = vc->vc_cols - 1;
929 else
930 vc->vc_x = new_x;
931 }
932
933 if (vc->vc_decom) {
934 min_y = vc->vc_top;
935 max_y = vc->vc_bottom;
936 } else {
937 min_y = 0;
938 max_y = vc->vc_rows;
939 }
940 if (new_y < min_y)
941 vc->vc_y = min_y;
942 else if (new_y >= max_y)
943 vc->vc_y = max_y - 1;
944 else
945 vc->vc_y = new_y;
946 vc->vc_pos = vc->vc_origin + vc->vc_y * vc->vc_size_row + (vc->vc_x<<1);
947 vc->vc_need_wrap = 0;
948 }
949
950 /* for absolute user moves, when decom is set */
951 static void gotoxay(struct vc_data *vc, int new_x, int new_y)
952 {
953 gotoxy(vc, new_x, vc->vc_decom ? (vc->vc_top + new_y) : new_y);
954 }
955
956 void scrollback(struct vc_data *vc, int lines)
957 {
958 if (!lines)
959 lines = vc->vc_rows / 2;
960 scrolldelta(-lines);
961 }
962
963 void scrollfront(struct vc_data *vc, int lines)
964 {
965 if (!lines)
966 lines = vc->vc_rows / 2;
967 scrolldelta(lines);
968 }
969
970 static void lf(struct vc_data *vc)
971 {
972 /* don't scroll if above bottom of scrolling region, or
973 * if below scrolling region
974 */
975 if (vc->vc_y + 1 == vc->vc_bottom)
976 scrup(vc, vc->vc_top, vc->vc_bottom, 1);
977 else if (vc->vc_y < vc->vc_rows - 1) {
978 vc->vc_y++;
979 vc->vc_pos += vc->vc_size_row;
980 }
981 vc->vc_need_wrap = 0;
982 }
983
984 static void ri(struct vc_data *vc)
985 {
986 /* don't scroll if below top of scrolling region, or
987 * if above scrolling region
988 */
989 if (vc->vc_y == vc->vc_top)
990 scrdown(vc, vc->vc_top, vc->vc_bottom, 1);
991 else if (vc->vc_y > 0) {
992 vc->vc_y--;
993 vc->vc_pos -= vc->vc_size_row;
994 }
995 vc->vc_need_wrap = 0;
996 }
997
998 static inline void cr(struct vc_data *vc)
999 {
1000 vc->vc_pos -= vc->vc_x << 1;
1001 vc->vc_need_wrap = vc->vc_x = 0;
1002 }
1003
1004 static inline void bs(struct vc_data *vc)
1005 {
1006 if (vc->vc_x) {
1007 vc->vc_pos -= 2;
1008 vc->vc_x--;
1009 vc->vc_need_wrap = 0;
1010 }
1011 }
1012
1013 static inline void del(struct vc_data *vc)
1014 {
1015 /* ignored */
1016 }
1017
1018 static void csi_J(struct vc_data *vc, int vpar)
1019 {
1020 unsigned int count;
1021 unsigned short * start;
1022
1023 switch (vpar) {
1024 case 0: /* erase from cursor to end of display */
1025 count = (vc->vc_scr_end - vc->vc_pos) >> 1;
1026 start = (unsigned short *)vc->vc_pos;
1027 if (DO_UPDATE(vc)) {
1028 /* do in two stages */
1029 vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1,
1030 vc->vc_cols - vc->vc_x);
1031 vc->vc_sw->con_clear(vc, vc->vc_y + 1, 0,
1032 vc->vc_rows - vc->vc_y - 1,
1033 vc->vc_cols);
1034 }
1035 break;
1036 case 1: /* erase from start to cursor */
1037 count = ((vc->vc_pos - vc->vc_origin) >> 1) + 1;
1038 start = (unsigned short *)vc->vc_origin;
1039 if (DO_UPDATE(vc)) {
1040 /* do in two stages */
1041 vc->vc_sw->con_clear(vc, 0, 0, vc->vc_y,
1042 vc->vc_cols);
1043 vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
1044 vc->vc_x + 1);
1045 }
1046 break;
1047 case 2: /* erase whole display */
1048 count = vc->vc_cols * vc->vc_rows;
1049 start = (unsigned short *)vc->vc_origin;
1050 if (DO_UPDATE(vc))
1051 vc->vc_sw->con_clear(vc, 0, 0,
1052 vc->vc_rows,
1053 vc->vc_cols);
1054 break;
1055 default:
1056 return;
1057 }
1058 scr_memsetw(start, vc->vc_video_erase_char, 2 * count);
1059 vc->vc_need_wrap = 0;
1060 }
1061
1062 static void csi_K(struct vc_data *vc, int vpar)
1063 {
1064 unsigned int count;
1065 unsigned short * start;
1066
1067 switch (vpar) {
1068 case 0: /* erase from cursor to end of line */
1069 count = vc->vc_cols - vc->vc_x;
1070 start = (unsigned short *)vc->vc_pos;
1071 if (DO_UPDATE(vc))
1072 vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1,
1073 vc->vc_cols - vc->vc_x);
1074 break;
1075 case 1: /* erase from start of line to cursor */
1076 start = (unsigned short *)(vc->vc_pos - (vc->vc_x << 1));
1077 count = vc->vc_x + 1;
1078 if (DO_UPDATE(vc))
1079 vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
1080 vc->vc_x + 1);
1081 break;
1082 case 2: /* erase whole line */
1083 start = (unsigned short *)(vc->vc_pos - (vc->vc_x << 1));
1084 count = vc->vc_cols;
1085 if (DO_UPDATE(vc))
1086 vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
1087 vc->vc_cols);
1088 break;
1089 default:
1090 return;
1091 }
1092 scr_memsetw(start, vc->vc_video_erase_char, 2 * count);
1093 vc->vc_need_wrap = 0;
1094 }
1095
1096 static void csi_X(struct vc_data *vc, int vpar) /* erase the following vpar positions */
1097 { /* not vt100? */
1098 int count;
1099
1100 if (!vpar)
1101 vpar++;
1102 count = (vpar > vc->vc_cols - vc->vc_x) ? (vc->vc_cols - vc->vc_x) : vpar;
1103
1104 scr_memsetw((unsigned short *)vc->vc_pos, vc->vc_video_erase_char, 2 * count);
1105 if (DO_UPDATE(vc))
1106 vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1, count);
1107 vc->vc_need_wrap = 0;
1108 }
1109
1110 static void default_attr(struct vc_data *vc)
1111 {
1112 vc->vc_intensity = 1;
1113 vc->vc_underline = 0;
1114 vc->vc_reverse = 0;
1115 vc->vc_blink = 0;
1116 vc->vc_color = vc->vc_def_color;
1117 }
1118
1119 /* console_sem is held */
1120 static void csi_m(struct vc_data *vc)
1121 {
1122 int i;
1123
1124 for (i = 0; i <= vc->vc_npar; i++)
1125 switch (vc->vc_par[i]) {
1126 case 0: /* all attributes off */
1127 default_attr(vc);
1128 break;
1129 case 1:
1130 vc->vc_intensity = 2;
1131 break;
1132 case 2:
1133 vc->vc_intensity = 0;
1134 break;
1135 case 4:
1136 vc->vc_underline = 1;
1137 break;
1138 case 5:
1139 vc->vc_blink = 1;
1140 break;
1141 case 7:
1142 vc->vc_reverse = 1;
1143 break;
1144 case 10: /* ANSI X3.64-1979 (SCO-ish?)
1145 * Select primary font, don't display
1146 * control chars if defined, don't set
1147 * bit 8 on output.
1148 */
1149 vc->vc_translate = set_translate(vc->vc_charset == 0
1150 ? vc->vc_G0_charset
1151 : vc->vc_G1_charset, vc);
1152 vc->vc_disp_ctrl = 0;
1153 vc->vc_toggle_meta = 0;
1154 break;
1155 case 11: /* ANSI X3.64-1979 (SCO-ish?)
1156 * Select first alternate font, lets
1157 * chars < 32 be displayed as ROM chars.
1158 */
1159 vc->vc_translate = set_translate(IBMPC_MAP, vc);
1160 vc->vc_disp_ctrl = 1;
1161 vc->vc_toggle_meta = 0;
1162 break;
1163 case 12: /* ANSI X3.64-1979 (SCO-ish?)
1164 * Select second alternate font, toggle
1165 * high bit before displaying as ROM char.
1166 */
1167 vc->vc_translate = set_translate(IBMPC_MAP, vc);
1168 vc->vc_disp_ctrl = 1;
1169 vc->vc_toggle_meta = 1;
1170 break;
1171 case 21:
1172 case 22:
1173 vc->vc_intensity = 1;
1174 break;
1175 case 24:
1176 vc->vc_underline = 0;
1177 break;
1178 case 25:
1179 vc->vc_blink = 0;
1180 break;
1181 case 27:
1182 vc->vc_reverse = 0;
1183 break;
1184 case 38: /* ANSI X3.64-1979 (SCO-ish?)
1185 * Enables underscore, white foreground
1186 * with white underscore (Linux - use
1187 * default foreground).
1188 */
1189 vc->vc_color = (vc->vc_def_color & 0x0f) | (vc->vc_color & 0xf0);
1190 vc->vc_underline = 1;
1191 break;
1192 case 39: /* ANSI X3.64-1979 (SCO-ish?)
1193 * Disable underline option.
1194 * Reset colour to default? It did this
1195 * before...
1196 */
1197 vc->vc_color = (vc->vc_def_color & 0x0f) | (vc->vc_color & 0xf0);
1198 vc->vc_underline = 0;
1199 break;
1200 case 49:
1201 vc->vc_color = (vc->vc_def_color & 0xf0) | (vc->vc_color & 0x0f);
1202 break;
1203 default:
1204 if (vc->vc_par[i] >= 30 && vc->vc_par[i] <= 37)
1205 vc->vc_color = color_table[vc->vc_par[i] - 30]
1206 | (vc->vc_color & 0xf0);
1207 else if (vc->vc_par[i] >= 40 && vc->vc_par[i] <= 47)
1208 vc->vc_color = (color_table[vc->vc_par[i] - 40] << 4)
1209 | (vc->vc_color & 0x0f);
1210 break;
1211 }
1212 update_attr(vc);
1213 }
1214
1215 static void respond_string(const char *p, struct tty_struct *tty)
1216 {
1217 while (*p) {
1218 tty_insert_flip_char(tty, *p, 0);
1219 p++;
1220 }
1221 con_schedule_flip(tty);
1222 }
1223
1224 static void cursor_report(struct vc_data *vc, struct tty_struct *tty)
1225 {
1226 char buf[40];
1227
1228 sprintf(buf, "\033[%d;%dR", vc->vc_y + (vc->vc_decom ? vc->vc_top + 1 : 1), vc->vc_x + 1);
1229 respond_string(buf, tty);
1230 }
1231
1232 static inline void status_report(struct tty_struct *tty)
1233 {
1234 respond_string("\033[0n", tty); /* Terminal ok */
1235 }
1236
1237 static inline void respond_ID(struct tty_struct * tty)
1238 {
1239 respond_string(VT102ID, tty);
1240 }
1241
1242 void mouse_report(struct tty_struct *tty, int butt, int mrx, int mry)
1243 {
1244 char buf[8];
1245
1246 sprintf(buf, "\033[M%c%c%c", (char)(' ' + butt), (char)('!' + mrx),
1247 (char)('!' + mry));
1248 respond_string(buf, tty);
1249 }
1250
1251 /* invoked via ioctl(TIOCLINUX) and through set_selection */
1252 int mouse_reporting(void)
1253 {
1254 return vc_cons[fg_console].d->vc_report_mouse;
1255 }
1256
1257 /* console_sem is held */
1258 static void set_mode(struct vc_data *vc, int on_off)
1259 {
1260 int i;
1261
1262 for (i = 0; i <= vc->vc_npar; i++)
1263 if (vc->vc_ques) {
1264 switch(vc->vc_par[i]) { /* DEC private modes set/reset */
1265 case 1: /* Cursor keys send ^[Ox/^[[x */
1266 if (on_off)
1267 set_kbd(vc, decckm);
1268 else
1269 clr_kbd(vc, decckm);
1270 break;
1271 case 3: /* 80/132 mode switch unimplemented */
1272 vc->vc_deccolm = on_off;
1273 #if 0
1274 vc_resize(deccolm ? 132 : 80, vc->vc_rows);
1275 /* this alone does not suffice; some user mode
1276 utility has to change the hardware regs */
1277 #endif
1278 break;
1279 case 5: /* Inverted screen on/off */
1280 if (vc->vc_decscnm != on_off) {
1281 vc->vc_decscnm = on_off;
1282 invert_screen(vc, 0, vc->vc_screenbuf_size, 0);
1283 update_attr(vc);
1284 }
1285 break;
1286 case 6: /* Origin relative/absolute */
1287 vc->vc_decom = on_off;
1288 gotoxay(vc, 0, 0);
1289 break;
1290 case 7: /* Autowrap on/off */
1291 vc->vc_decawm = on_off;
1292 break;
1293 case 8: /* Autorepeat on/off */
1294 if (on_off)
1295 set_kbd(vc, decarm);
1296 else
1297 clr_kbd(vc, decarm);
1298 break;
1299 case 9:
1300 vc->vc_report_mouse = on_off ? 1 : 0;
1301 break;
1302 case 25: /* Cursor on/off */
1303 vc->vc_deccm = on_off;
1304 break;
1305 case 1000:
1306 vc->vc_report_mouse = on_off ? 2 : 0;
1307 break;
1308 }
1309 } else {
1310 switch(vc->vc_par[i]) { /* ANSI modes set/reset */
1311 case 3: /* Monitor (display ctrls) */
1312 vc->vc_disp_ctrl = on_off;
1313 break;
1314 case 4: /* Insert Mode on/off */
1315 vc->vc_decim = on_off;
1316 break;
1317 case 20: /* Lf, Enter == CrLf/Lf */
1318 if (on_off)
1319 set_kbd(vc, lnm);
1320 else
1321 clr_kbd(vc, lnm);
1322 break;
1323 }
1324 }
1325 }
1326
1327 /* console_sem is held */
1328 static void setterm_command(struct vc_data *vc)
1329 {
1330 switch(vc->vc_par[0]) {
1331 case 1: /* set color for underline mode */
1332 if (vc->vc_can_do_color &&
1333 vc->vc_par[1] < 16) {
1334 vc->vc_ulcolor = color_table[vc->vc_par[1]];
1335 if (vc->vc_underline)
1336 update_attr(vc);
1337 }
1338 break;
1339 case 2: /* set color for half intensity mode */
1340 if (vc->vc_can_do_color &&
1341 vc->vc_par[1] < 16) {
1342 vc->vc_halfcolor = color_table[vc->vc_par[1]];
1343 if (vc->vc_intensity == 0)
1344 update_attr(vc);
1345 }
1346 break;
1347 case 8: /* store colors as defaults */
1348 vc->vc_def_color = vc->vc_attr;
1349 if (vc->vc_hi_font_mask == 0x100)
1350 vc->vc_def_color >>= 1;
1351 default_attr(vc);
1352 update_attr(vc);
1353 break;
1354 case 9: /* set blanking interval */
1355 blankinterval = ((vc->vc_par[1] < 60) ? vc->vc_par[1] : 60) * 60 * HZ;
1356 poke_blanked_console();
1357 break;
1358 case 10: /* set bell frequency in Hz */
1359 if (vc->vc_npar >= 1)
1360 vc->vc_bell_pitch = vc->vc_par[1];
1361 else
1362 vc->vc_bell_pitch = DEFAULT_BELL_PITCH;
1363 break;
1364 case 11: /* set bell duration in msec */
1365 if (vc->vc_npar >= 1)
1366 vc->vc_bell_duration = (vc->vc_par[1] < 2000) ?
1367 vc->vc_par[1] * HZ / 1000 : 0;
1368 else
1369 vc->vc_bell_duration = DEFAULT_BELL_DURATION;
1370 break;
1371 case 12: /* bring specified console to the front */
1372 if (vc->vc_par[1] >= 1 && vc_cons_allocated(vc->vc_par[1] - 1))
1373 set_console(vc->vc_par[1] - 1);
1374 break;
1375 case 13: /* unblank the screen */
1376 poke_blanked_console();
1377 break;
1378 case 14: /* set vesa powerdown interval */
1379 vesa_off_interval = ((vc->vc_par[1] < 60) ? vc->vc_par[1] : 60) * 60 * HZ;
1380 break;
1381 case 15: /* activate the previous console */
1382 set_console(last_console);
1383 break;
1384 }
1385 }
1386
1387 /* console_sem is held */
1388 static void csi_at(struct vc_data *vc, unsigned int nr)
1389 {
1390 if (nr > vc->vc_cols - vc->vc_x)
1391 nr = vc->vc_cols - vc->vc_x;
1392 else if (!nr)
1393 nr = 1;
1394 insert_char(vc, nr);
1395 }
1396
1397 /* console_sem is held */
1398 static void csi_L(struct vc_data *vc, unsigned int nr)
1399 {
1400 if (nr > vc->vc_rows - vc->vc_y)
1401 nr = vc->vc_rows - vc->vc_y;
1402 else if (!nr)
1403 nr = 1;
1404 scrdown(vc, vc->vc_y, vc->vc_bottom, nr);
1405 vc->vc_need_wrap = 0;
1406 }
1407
1408 /* console_sem is held */
1409 static void csi_P(struct vc_data *vc, unsigned int nr)
1410 {
1411 if (nr > vc->vc_cols - vc->vc_x)
1412 nr = vc->vc_cols - vc->vc_x;
1413 else if (!nr)
1414 nr = 1;
1415 delete_char(vc, nr);
1416 }
1417
1418 /* console_sem is held */
1419 static void csi_M(struct vc_data *vc, unsigned int nr)
1420 {
1421 if (nr > vc->vc_rows - vc->vc_y)
1422 nr = vc->vc_rows - vc->vc_y;
1423 else if (!nr)
1424 nr=1;
1425 scrup(vc, vc->vc_y, vc->vc_bottom, nr);
1426 vc->vc_need_wrap = 0;
1427 }
1428
1429 /* console_sem is held (except via vc_init->reset_terminal */
1430 static void save_cur(struct vc_data *vc)
1431 {
1432 vc->vc_saved_x = vc->vc_x;
1433 vc->vc_saved_y = vc->vc_y;
1434 vc->vc_s_intensity = vc->vc_intensity;
1435 vc->vc_s_underline = vc->vc_underline;
1436 vc->vc_s_blink = vc->vc_blink;
1437 vc->vc_s_reverse = vc->vc_reverse;
1438 vc->vc_s_charset = vc->vc_charset;
1439 vc->vc_s_color = vc->vc_color;
1440 vc->vc_saved_G0 = vc->vc_G0_charset;
1441 vc->vc_saved_G1 = vc->vc_G1_charset;
1442 }
1443
1444 /* console_sem is held */
1445 static void restore_cur(struct vc_data *vc)
1446 {
1447 gotoxy(vc, vc->vc_saved_x, vc->vc_saved_y);
1448 vc->vc_intensity = vc->vc_s_intensity;
1449 vc->vc_underline = vc->vc_s_underline;
1450 vc->vc_blink = vc->vc_s_blink;
1451 vc->vc_reverse = vc->vc_s_reverse;
1452 vc->vc_charset = vc->vc_s_charset;
1453 vc->vc_color = vc->vc_s_color;
1454 vc->vc_G0_charset = vc->vc_saved_G0;
1455 vc->vc_G1_charset = vc->vc_saved_G1;
1456 vc->vc_translate = set_translate(vc->vc_charset ? vc->vc_G1_charset : vc->vc_G0_charset, vc);
1457 update_attr(vc);
1458 vc->vc_need_wrap = 0;
1459 }
1460
1461 enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
1462 EShash, ESsetG0, ESsetG1, ESpercent, ESignore, ESnonstd,
1463 ESpalette };
1464
1465 /* console_sem is held (except via vc_init()) */
1466 static void reset_terminal(struct vc_data *vc, int do_clear)
1467 {
1468 vc->vc_top = 0;
1469 vc->vc_bottom = vc->vc_rows;
1470 vc->vc_state = ESnormal;
1471 vc->vc_ques = 0;
1472 vc->vc_translate = set_translate(LAT1_MAP, vc);
1473 vc->vc_G0_charset = LAT1_MAP;
1474 vc->vc_G1_charset = GRAF_MAP;
1475 vc->vc_charset = 0;
1476 vc->vc_need_wrap = 0;
1477 vc->vc_report_mouse = 0;
1478 vc->vc_utf = 0;
1479 vc->vc_utf_count = 0;
1480
1481 vc->vc_disp_ctrl = 0;
1482 vc->vc_toggle_meta = 0;
1483
1484 vc->vc_decscnm = 0;
1485 vc->vc_decom = 0;
1486 vc->vc_decawm = 1;
1487 vc->vc_deccm = 1;
1488 vc->vc_decim = 0;
1489
1490 set_kbd(vc, decarm);
1491 clr_kbd(vc, decckm);
1492 clr_kbd(vc, kbdapplic);
1493 clr_kbd(vc, lnm);
1494 kbd_table[vc->vc_num].lockstate = 0;
1495 kbd_table[vc->vc_num].slockstate = 0;
1496 kbd_table[vc->vc_num].ledmode = LED_SHOW_FLAGS;
1497 kbd_table[vc->vc_num].ledflagstate = kbd_table[vc->vc_num].default_ledflagstate;
1498 /* do not do set_leds here because this causes an endless tasklet loop
1499 when the keyboard hasn't been initialized yet */
1500
1501 vc->vc_cursor_type = CUR_DEFAULT;
1502 vc->vc_complement_mask = vc->vc_s_complement_mask;
1503
1504 default_attr(vc);
1505 update_attr(vc);
1506
1507 vc->vc_tab_stop[0] = 0x01010100;
1508 vc->vc_tab_stop[1] =
1509 vc->vc_tab_stop[2] =
1510 vc->vc_tab_stop[3] =
1511 vc->vc_tab_stop[4] = 0x01010101;
1512
1513 vc->vc_bell_pitch = DEFAULT_BELL_PITCH;
1514 vc->vc_bell_duration = DEFAULT_BELL_DURATION;
1515
1516 gotoxy(vc, 0, 0);
1517 save_cur(vc);
1518 if (do_clear)
1519 csi_J(vc, 2);
1520 }
1521
1522 /* console_sem is held */
1523 static void do_con_trol(struct tty_struct *tty, struct vc_data *vc, int c)
1524 {
1525 /*
1526 * Control characters can be used in the _middle_
1527 * of an escape sequence.
1528 */
1529 switch (c) {
1530 case 0:
1531 return;
1532 case 7:
1533 if (vc->vc_bell_duration)
1534 kd_mksound(vc->vc_bell_pitch, vc->vc_bell_duration);
1535 return;
1536 case 8:
1537 bs(vc);
1538 return;
1539 case 9:
1540 vc->vc_pos -= (vc->vc_x << 1);
1541 while (vc->vc_x < vc->vc_cols - 1) {
1542 vc->vc_x++;
1543 if (vc->vc_tab_stop[vc->vc_x >> 5] & (1 << (vc->vc_x & 31)))
1544 break;
1545 }
1546 vc->vc_pos += (vc->vc_x << 1);
1547 return;
1548 case 10: case 11: case 12:
1549 lf(vc);
1550 if (!is_kbd(vc, lnm))
1551 return;
1552 case 13:
1553 cr(vc);
1554 return;
1555 case 14:
1556 vc->vc_charset = 1;
1557 vc->vc_translate = set_translate(vc->vc_G1_charset, vc);
1558 vc->vc_disp_ctrl = 1;
1559 return;
1560 case 15:
1561 vc->vc_charset = 0;
1562 vc->vc_translate = set_translate(vc->vc_G0_charset, vc);
1563 vc->vc_disp_ctrl = 0;
1564 return;
1565 case 24: case 26:
1566 vc->vc_state = ESnormal;
1567 return;
1568 case 27:
1569 vc->vc_state = ESesc;
1570 return;
1571 case 127:
1572 del(vc);
1573 return;
1574 case 128+27:
1575 vc->vc_state = ESsquare;
1576 return;
1577 }
1578 switch(vc->vc_state) {
1579 case ESesc:
1580 vc->vc_state = ESnormal;
1581 switch (c) {
1582 case '[':
1583 vc->vc_state = ESsquare;
1584 return;
1585 case ']':
1586 vc->vc_state = ESnonstd;
1587 return;
1588 case '%':
1589 vc->vc_state = ESpercent;
1590 return;
1591 case 'E':
1592 cr(vc);
1593 lf(vc);
1594 return;
1595 case 'M':
1596 ri(vc);
1597 return;
1598 case 'D':
1599 lf(vc);
1600 return;
1601 case 'H':
1602 vc->vc_tab_stop[vc->vc_x >> 5] |= (1 << (vc->vc_x & 31));
1603 return;
1604 case 'Z':
1605 respond_ID(tty);
1606 return;
1607 case '7':
1608 save_cur(vc);
1609 return;
1610 case '8':
1611 restore_cur(vc);
1612 return;
1613 case '(':
1614 vc->vc_state = ESsetG0;
1615 return;
1616 case ')':
1617 vc->vc_state = ESsetG1;
1618 return;
1619 case '#':
1620 vc->vc_state = EShash;
1621 return;
1622 case 'c':
1623 reset_terminal(vc, 1);
1624 return;
1625 case '>': /* Numeric keypad */
1626 clr_kbd(vc, kbdapplic);
1627 return;
1628 case '=': /* Appl. keypad */
1629 set_kbd(vc, kbdapplic);
1630 return;
1631 }
1632 return;
1633 case ESnonstd:
1634 if (c=='P') { /* palette escape sequence */
1635 for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++)
1636 vc->vc_par[vc->vc_npar] = 0;
1637 vc->vc_npar = 0;
1638 vc->vc_state = ESpalette;
1639 return;
1640 } else if (c=='R') { /* reset palette */
1641 reset_palette(vc);
1642 vc->vc_state = ESnormal;
1643 } else
1644 vc->vc_state = ESnormal;
1645 return;
1646 case ESpalette:
1647 if ( (c>='0'&&c<='9') || (c>='A'&&c<='F') || (c>='a'&&c<='f') ) {
1648 vc->vc_par[vc->vc_npar++] = (c > '9' ? (c & 0xDF) - 'A' + 10 : c - '0');
1649 if (vc->vc_npar == 7) {
1650 int i = vc->vc_par[0] * 3, j = 1;
1651 vc->vc_palette[i] = 16 * vc->vc_par[j++];
1652 vc->vc_palette[i++] += vc->vc_par[j++];
1653 vc->vc_palette[i] = 16 * vc->vc_par[j++];
1654 vc->vc_palette[i++] += vc->vc_par[j++];
1655 vc->vc_palette[i] = 16 * vc->vc_par[j++];
1656 vc->vc_palette[i] += vc->vc_par[j];
1657 set_palette(vc);
1658 vc->vc_state = ESnormal;
1659 }
1660 } else
1661 vc->vc_state = ESnormal;
1662 return;
1663 case ESsquare:
1664 for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++)
1665 vc->vc_par[vc->vc_npar] = 0;
1666 vc->vc_npar = 0;
1667 vc->vc_state = ESgetpars;
1668 if (c == '[') { /* Function key */
1669 vc->vc_state=ESfunckey;
1670 return;
1671 }
1672 vc->vc_ques = (c == '?');
1673 if (vc->vc_ques)
1674 return;
1675 case ESgetpars:
1676 if (c == ';' && vc->vc_npar < NPAR - 1) {
1677 vc->vc_npar++;
1678 return;
1679 } else if (c>='0' && c<='9') {
1680 vc->vc_par[vc->vc_npar] *= 10;
1681 vc->vc_par[vc->vc_npar] += c - '0';
1682 return;
1683 } else
1684 vc->vc_state = ESgotpars;
1685 case ESgotpars:
1686 vc->vc_state = ESnormal;
1687 switch(c) {
1688 case 'h':
1689 set_mode(vc, 1);
1690 return;
1691 case 'l':
1692 set_mode(vc, 0);
1693 return;
1694 case 'c':
1695 if (vc->vc_ques) {
1696 if (vc->vc_par[0])
1697 vc->vc_cursor_type = vc->vc_par[0] | (vc->vc_par[1] << 8) | (vc->vc_par[2] << 16);
1698 else
1699 vc->vc_cursor_type = CUR_DEFAULT;
1700 return;
1701 }
1702 break;
1703 case 'm':
1704 if (vc->vc_ques) {
1705 clear_selection();
1706 if (vc->vc_par[0])
1707 vc->vc_complement_mask = vc->vc_par[0] << 8 | vc->vc_par[1];
1708 else
1709 vc->vc_complement_mask = vc->vc_s_complement_mask;
1710 return;
1711 }
1712 break;
1713 case 'n':
1714 if (!vc->vc_ques) {
1715 if (vc->vc_par[0] == 5)
1716 status_report(tty);
1717 else if (vc->vc_par[0] == 6)
1718 cursor_report(vc, tty);
1719 }
1720 return;
1721 }
1722 if (vc->vc_ques) {
1723 vc->vc_ques = 0;
1724 return;
1725 }
1726 switch(c) {
1727 case 'G': case '`':
1728 if (vc->vc_par[0])
1729 vc->vc_par[0]--;
1730 gotoxy(vc, vc->vc_par[0], vc->vc_y);
1731 return;
1732 case 'A':
1733 if (!vc->vc_par[0])
1734 vc->vc_par[0]++;
1735 gotoxy(vc, vc->vc_x, vc->vc_y - vc->vc_par[0]);
1736 return;
1737 case 'B': case 'e':
1738 if (!vc->vc_par[0])
1739 vc->vc_par[0]++;
1740 gotoxy(vc, vc->vc_x, vc->vc_y + vc->vc_par[0]);
1741 return;
1742 case 'C': case 'a':
1743 if (!vc->vc_par[0])
1744 vc->vc_par[0]++;
1745 gotoxy(vc, vc->vc_x + vc->vc_par[0], vc->vc_y);
1746 return;
1747 case 'D':
1748 if (!vc->vc_par[0])
1749 vc->vc_par[0]++;
1750 gotoxy(vc, vc->vc_x - vc->vc_par[0], vc->vc_y);
1751 return;
1752 case 'E':
1753 if (!vc->vc_par[0])
1754 vc->vc_par[0]++;
1755 gotoxy(vc, 0, vc->vc_y + vc->vc_par[0]);
1756 return;
1757 case 'F':
1758 if (!vc->vc_par[0])
1759 vc->vc_par[0]++;
1760 gotoxy(vc, 0, vc->vc_y - vc->vc_par[0]);
1761 return;
1762 case 'd':
1763 if (vc->vc_par[0])
1764 vc->vc_par[0]--;
1765 gotoxay(vc, vc->vc_x ,vc->vc_par[0]);
1766 return;
1767 case 'H': case 'f':
1768 if (vc->vc_par[0])
1769 vc->vc_par[0]--;
1770 if (vc->vc_par[1])
1771 vc->vc_par[1]--;
1772 gotoxay(vc, vc->vc_par[1], vc->vc_par[0]);
1773 return;
1774 case 'J':
1775 csi_J(vc, vc->vc_par[0]);
1776 return;
1777 case 'K':
1778 csi_K(vc, vc->vc_par[0]);
1779 return;
1780 case 'L':
1781 csi_L(vc, vc->vc_par[0]);
1782 return;
1783 case 'M':
1784 csi_M(vc, vc->vc_par[0]);
1785 return;
1786 case 'P':
1787 csi_P(vc, vc->vc_par[0]);
1788 return;
1789 case 'c':
1790 if (!vc->vc_par[0])
1791 respond_ID(tty);
1792 return;
1793 case 'g':
1794 if (!vc->vc_par[0])
1795 vc->vc_tab_stop[vc->vc_x >> 5] &= ~(1 << (vc->vc_x & 31));
1796 else if (vc->vc_par[0] == 3) {
1797 vc->vc_tab_stop[0] =
1798 vc->vc_tab_stop[1] =
1799 vc->vc_tab_stop[2] =
1800 vc->vc_tab_stop[3] =
1801 vc->vc_tab_stop[4] = 0;
1802 }
1803 return;
1804 case 'm':
1805 csi_m(vc);
1806 return;
1807 case 'q': /* DECLL - but only 3 leds */
1808 /* map 0,1,2,3 to 0,1,2,4 */
1809 if (vc->vc_par[0] < 4)
1810 setledstate(kbd_table + vc->vc_num,
1811 (vc->vc_par[0] < 3) ? vc->vc_par[0] : 4);
1812 return;
1813 case 'r':
1814 if (!vc->vc_par[0])
1815 vc->vc_par[0]++;
1816 if (!vc->vc_par[1])
1817 vc->vc_par[1] = vc->vc_rows;
1818 /* Minimum allowed region is 2 lines */
1819 if (vc->vc_par[0] < vc->vc_par[1] &&
1820 vc->vc_par[1] <= vc->vc_rows) {
1821 vc->vc_top = vc->vc_par[0] - 1;
1822 vc->vc_bottom = vc->vc_par[1];
1823 gotoxay(vc, 0, 0);
1824 }
1825 return;
1826 case 's':
1827 save_cur(vc);
1828 return;
1829 case 'u':
1830 restore_cur(vc);
1831 return;
1832 case 'X':
1833 csi_X(vc, vc->vc_par[0]);
1834 return;
1835 case '@':
1836 csi_at(vc, vc->vc_par[0]);
1837 return;
1838 case ']': /* setterm functions */
1839 setterm_command(vc);
1840 return;
1841 }
1842 return;
1843 case ESpercent:
1844 vc->vc_state = ESnormal;
1845 switch (c) {
1846 case '@': /* defined in ISO 2022 */
1847 vc->vc_utf = 0;
1848 return;
1849 case 'G': /* prelim official escape code */
1850 case '8': /* retained for compatibility */
1851 vc->vc_utf = 1;
1852 return;
1853 }
1854 return;
1855 case ESfunckey:
1856 vc->vc_state = ESnormal;
1857 return;
1858 case EShash:
1859 vc->vc_state = ESnormal;
1860 if (c == '8') {
1861 /* DEC screen alignment test. kludge :-) */
1862 vc->vc_video_erase_char =
1863 (vc->vc_video_erase_char & 0xff00) | 'E';
1864 csi_J(vc, 2);
1865 vc->vc_video_erase_char =
1866 (vc->vc_video_erase_char & 0xff00) | ' ';
1867 do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2);
1868 }
1869 return;
1870 case ESsetG0:
1871 if (c == '0')
1872 vc->vc_G0_charset = GRAF_MAP;
1873 else if (c == 'B')
1874 vc->vc_G0_charset = LAT1_MAP;
1875 else if (c == 'U')
1876 vc->vc_G0_charset = IBMPC_MAP;
1877 else if (c == 'K')
1878 vc->vc_G0_charset = USER_MAP;
1879 if (vc->vc_charset == 0)
1880 vc->vc_translate = set_translate(vc->vc_G0_charset, vc);
1881 vc->vc_state = ESnormal;
1882 return;
1883 case ESsetG1:
1884 if (c == '0')
1885 vc->vc_G1_charset = GRAF_MAP;
1886 else if (c == 'B')
1887 vc->vc_G1_charset = LAT1_MAP;
1888 else if (c == 'U')
1889 vc->vc_G1_charset = IBMPC_MAP;
1890 else if (c == 'K')
1891 vc->vc_G1_charset = USER_MAP;
1892 if (vc->vc_charset == 1)
1893 vc->vc_translate = set_translate(vc->vc_G1_charset, vc);
1894 vc->vc_state = ESnormal;
1895 return;
1896 default:
1897 vc->vc_state = ESnormal;
1898 }
1899 }
1900
1901 /* This is a temporary buffer used to prepare a tty console write
1902 * so that we can easily avoid touching user space while holding the
1903 * console spinlock. It is allocated in con_init and is shared by
1904 * this code and the vc_screen read/write tty calls.
1905 *
1906 * We have to allocate this statically in the kernel data section
1907 * since console_init (and thus con_init) are called before any
1908 * kernel memory allocation is available.
1909 */
1910 char con_buf[CON_BUF_SIZE];
1911 DECLARE_MUTEX(con_buf_sem);
1912
1913 /* acquires console_sem */
1914 static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int count)
1915 {
1916 #ifdef VT_BUF_VRAM_ONLY
1917 #define FLUSH do { } while(0);
1918 #else
1919 #define FLUSH if (draw_x >= 0) { \
1920 vc->vc_sw->con_putcs(vc, (u16 *)draw_from, (u16 *)draw_to - (u16 *)draw_from, vc->vc_y, draw_x); \
1921 draw_x = -1; \
1922 }
1923 #endif
1924
1925 int c, tc, ok, n = 0, draw_x = -1;
1926 unsigned int currcons;
1927 unsigned long draw_from = 0, draw_to = 0;
1928 struct vc_data *vc;
1929 u16 himask, charmask;
1930 const unsigned char *orig_buf = NULL;
1931 int orig_count;
1932
1933 if (in_interrupt())
1934 return count;
1935
1936 might_sleep();
1937
1938 acquire_console_sem();
1939 vc = tty->driver_data;
1940 if (vc == NULL) {
1941 printk(KERN_ERR "vt: argh, driver_data is NULL !\n");
1942 release_console_sem();
1943 return 0;
1944 }
1945
1946 currcons = vc->vc_num;
1947 if (!vc_cons_allocated(currcons)) {
1948 /* could this happen? */
1949 static int error = 0;
1950 if (!error) {
1951 error = 1;
1952 printk("con_write: tty %d not allocated\n", currcons+1);
1953 }
1954 release_console_sem();
1955 return 0;
1956 }
1957 release_console_sem();
1958
1959 orig_buf = buf;
1960 orig_count = count;
1961
1962 /* At this point 'buf' is guaranteed to be a kernel buffer
1963 * and therefore no access to userspace (and therefore sleeping)
1964 * will be needed. The con_buf_sem serializes all tty based
1965 * console rendering and vcs write/read operations. We hold
1966 * the console spinlock during the entire write.
1967 */
1968
1969 acquire_console_sem();
1970
1971 vc = tty->driver_data;
1972 if (vc == NULL) {
1973 printk(KERN_ERR "vt: argh, driver_data _became_ NULL !\n");
1974 release_console_sem();
1975 goto out;
1976 }
1977
1978 himask = vc->vc_hi_font_mask;
1979 charmask = himask ? 0x1ff : 0xff;
1980
1981 /* undraw cursor first */
1982 if (IS_FG(vc))
1983 hide_cursor(vc);
1984
1985 while (!tty->stopped && count) {
1986 int orig = *buf;
1987 c = orig;
1988 buf++;
1989 n++;
1990 count--;
1991
1992 /* Do no translation at all in control states */
1993 if (vc->vc_state != ESnormal) {
1994 tc = c;
1995 } else if (vc->vc_utf) {
1996 /* Combine UTF-8 into Unicode */
1997 /* Incomplete characters silently ignored */
1998 if(c > 0x7f) {
1999 if (vc->vc_utf_count > 0 && (c & 0xc0) == 0x80) {
2000 vc->vc_utf_char = (vc->vc_utf_char << 6) | (c & 0x3f);
2001 vc->vc_utf_count--;
2002 if (vc->vc_utf_count == 0)
2003 tc = c = vc->vc_utf_char;
2004 else continue;
2005 } else {
2006 if ((c & 0xe0) == 0xc0) {
2007 vc->vc_utf_count = 1;
2008 vc->vc_utf_char = (c & 0x1f);
2009 } else if ((c & 0xf0) == 0xe0) {
2010 vc->vc_utf_count = 2;
2011 vc->vc_utf_char = (c & 0x0f);
2012 } else if ((c & 0xf8) == 0xf0) {
2013 vc->vc_utf_count = 3;
2014 vc->vc_utf_char = (c & 0x07);
2015 } else if ((c & 0xfc) == 0xf8) {
2016 vc->vc_utf_count = 4;
2017 vc->vc_utf_char = (c & 0x03);
2018 } else if ((c & 0xfe) == 0xfc) {
2019 vc->vc_utf_count = 5;
2020 vc->vc_utf_char = (c & 0x01);
2021 } else
2022 vc->vc_utf_count = 0;
2023 continue;
2024 }
2025 } else {
2026 tc = c;
2027 vc->vc_utf_count = 0;
2028 }
2029 } else { /* no utf */
2030 tc = vc->vc_translate[vc->vc_toggle_meta ? (c | 0x80) : c];
2031 }
2032
2033 /* If the original code was a control character we
2034 * only allow a glyph to be displayed if the code is
2035 * not normally used (such as for cursor movement) or
2036 * if the disp_ctrl mode has been explicitly enabled.
2037 * Certain characters (as given by the CTRL_ALWAYS
2038 * bitmap) are always displayed as control characters,
2039 * as the console would be pretty useless without
2040 * them; to display an arbitrary font position use the
2041 * direct-to-font zone in UTF-8 mode.
2042 */
2043 ok = tc && (c >= 32 ||
2044 (!vc->vc_utf && !(((vc->vc_disp_ctrl ? CTRL_ALWAYS
2045 : CTRL_ACTION) >> c) & 1)))
2046 && (c != 127 || vc->vc_disp_ctrl)
2047 && (c != 128+27);
2048
2049 if (vc->vc_state == ESnormal && ok) {
2050 /* Now try to find out how to display it */
2051 tc = conv_uni_to_pc(vc, tc);
2052 if ( tc == -4 ) {
2053 /* If we got -4 (not found) then see if we have
2054 defined a replacement character (U+FFFD) */
2055 tc = conv_uni_to_pc(vc, 0xfffd);
2056
2057 /* One reason for the -4 can be that we just
2058 did a clear_unimap();
2059 try at least to show something. */
2060 if (tc == -4)
2061 tc = c;
2062 } else if ( tc == -3 ) {
2063 /* Bad hash table -- hope for the best */
2064 tc = c;
2065 }
2066 if (tc & ~charmask)
2067 continue; /* Conversion failed */
2068
2069 if (vc->vc_need_wrap || vc->vc_decim)
2070 FLUSH
2071 if (vc->vc_need_wrap) {
2072 cr(vc);
2073 lf(vc);
2074 }
2075 if (vc->vc_decim)
2076 insert_char(vc, 1);
2077 scr_writew(himask ?
2078 ((vc->vc_attr << 8) & ~himask) + ((tc & 0x100) ? himask : 0) + (tc & 0xff) :
2079 (vc->vc_attr << 8) + tc,
2080 (u16 *) vc->vc_pos);
2081 if (DO_UPDATE(vc) && draw_x < 0) {
2082 draw_x = vc->vc_x;
2083 draw_from = vc->vc_pos;
2084 }
2085 if (vc->vc_x == vc->vc_cols - 1) {
2086 vc->vc_need_wrap = vc->vc_decawm;
2087 draw_to = vc->vc_pos + 2;
2088 } else {
2089 vc->vc_x++;
2090 draw_to = (vc->vc_pos += 2);
2091 }
2092 continue;
2093 }
2094 FLUSH
2095 do_con_trol(tty, vc, orig);
2096 }
2097 FLUSH
2098 console_conditional_schedule();
2099 release_console_sem();
2100
2101 out:
2102 return n;
2103 #undef FLUSH
2104 }
2105
2106 /*
2107 * This is the console switching callback.
2108 *
2109 * Doing console switching in a process context allows
2110 * us to do the switches asynchronously (needed when we want
2111 * to switch due to a keyboard interrupt). Synchronization
2112 * with other console code and prevention of re-entrancy is
2113 * ensured with console_sem.
2114 */
2115 static void console_callback(void *ignored)
2116 {
2117 acquire_console_sem();
2118
2119 if (want_console >= 0) {
2120 if (want_console != fg_console &&
2121 vc_cons_allocated(want_console)) {
2122 hide_cursor(vc_cons[fg_console].d);
2123 change_console(vc_cons[want_console].d);
2124 /* we only changed when the console had already
2125 been allocated - a new console is not created
2126 in an interrupt routine */
2127 }
2128 want_console = -1;
2129 }
2130 if (do_poke_blanked_console) { /* do not unblank for a LED change */
2131 do_poke_blanked_console = 0;
2132 poke_blanked_console();
2133 }
2134 if (scrollback_delta) {
2135 struct vc_data *vc = vc_cons[fg_console].d;
2136 clear_selection();
2137 if (vc->vc_mode == KD_TEXT)
2138 vc->vc_sw->con_scrolldelta(vc, scrollback_delta);
2139 scrollback_delta = 0;
2140 }
2141 if (blank_timer_expired) {
2142 do_blank_screen(0);
2143 blank_timer_expired = 0;
2144 }
2145
2146 release_console_sem();
2147 }
2148
2149 void set_console(int nr)
2150 {
2151 want_console = nr;
2152 schedule_console_callback();
2153 }
2154
2155 struct tty_driver *console_driver;
2156
2157 #ifdef CONFIG_VT_CONSOLE
2158
2159 /*
2160 * Console on virtual terminal
2161 *
2162 * The console must be locked when we get here.
2163 */
2164
2165 static void vt_console_print(struct console *co, const char *b, unsigned count)
2166 {
2167 struct vc_data *vc = vc_cons[fg_console].d;
2168 unsigned char c;
2169 static unsigned long printing;
2170 const ushort *start;
2171 ushort cnt = 0;
2172 ushort myx;
2173
2174 /* console busy or not yet initialized */
2175 if (!printable || test_and_set_bit(0, &printing))
2176 return;
2177
2178 if (kmsg_redirect && vc_cons_allocated(kmsg_redirect - 1))
2179 vc = vc_cons[kmsg_redirect - 1].d;
2180
2181 /* read `x' only after setting currcons properly (otherwise
2182 the `x' macro will read the x of the foreground console). */
2183 myx = vc->vc_x;
2184
2185 if (!vc_cons_allocated(fg_console)) {
2186 /* impossible */
2187 /* printk("vt_console_print: tty %d not allocated ??\n", currcons+1); */
2188 goto quit;
2189 }
2190
2191 if (vc->vc_mode != KD_TEXT)
2192 goto quit;
2193
2194 /* undraw cursor first */
2195 if (IS_FG(vc))
2196 hide_cursor(vc);
2197
2198 start = (ushort *)vc->vc_pos;
2199
2200 /* Contrived structure to try to emulate original need_wrap behaviour
2201 * Problems caused when we have need_wrap set on '\n' character */
2202 while (count--) {
2203 c = *b++;
2204 if (c == 10 || c == 13 || c == 8 || vc->vc_need_wrap) {
2205 if (cnt > 0) {
2206 if (CON_IS_VISIBLE(vc))
2207 vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, vc->vc_x);
2208 vc->vc_x += cnt;
2209 if (vc->vc_need_wrap)
2210 vc->vc_x--;
2211 cnt = 0;
2212 }
2213 if (c == 8) { /* backspace */
2214 bs(vc);
2215 start = (ushort *)vc->vc_pos;
2216 myx = vc->vc_x;
2217 continue;
2218 }
2219 if (c != 13)
2220 lf(vc);
2221 cr(vc);
2222 start = (ushort *)vc->vc_pos;
2223 myx = vc->vc_x;
2224 if (c == 10 || c == 13)
2225 continue;
2226 }
2227 scr_writew((vc->vc_attr << 8) + c, (unsigned short *)vc->vc_pos);
2228 cnt++;
2229 if (myx == vc->vc_cols - 1) {
2230 vc->vc_need_wrap = 1;
2231 continue;
2232 }
2233 vc->vc_pos += 2;
2234 myx++;
2235 }
2236 if (cnt > 0) {
2237 if (CON_IS_VISIBLE(vc))
2238 vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, vc->vc_x);
2239 vc->vc_x += cnt;
2240 if (vc->vc_x == vc->vc_cols) {
2241 vc->vc_x--;
2242 vc->vc_need_wrap = 1;
2243 }
2244 }
2245 set_cursor(vc);
2246
2247 quit:
2248 clear_bit(0, &printing);
2249 }
2250
2251 static struct tty_driver *vt_console_device(struct console *c, int *index)
2252 {
2253 *index = c->index ? c->index-1 : fg_console;
2254 return console_driver;
2255 }
2256
2257 static struct console vt_console_driver = {
2258 .name = "tty",
2259 .write = vt_console_print,
2260 .device = vt_console_device,
2261 .unblank = unblank_screen,
2262 .flags = CON_PRINTBUFFER,
2263 .index = -1,
2264 };
2265 #endif
2266
2267 /*
2268 * Handling of Linux-specific VC ioctls
2269 */
2270
2271 /*
2272 * Generally a bit racy with respect to console_sem().
2273 *
2274 * There are some functions which don't need it.
2275 *
2276 * There are some functions which can sleep for arbitrary periods
2277 * (paste_selection) but we don't need the lock there anyway.
2278 *
2279 * set_selection has locking, and definitely needs it
2280 */
2281
2282 int tioclinux(struct tty_struct *tty, unsigned long arg)
2283 {
2284 char type, data;
2285 char __user *p = (char __user *)arg;
2286 int lines;
2287 int ret;
2288
2289 if (tty->driver->type != TTY_DRIVER_TYPE_CONSOLE)
2290 return -EINVAL;
2291 if (current->signal->tty != tty && !capable(CAP_SYS_ADMIN))
2292 return -EPERM;
2293 if (get_user(type, p))
2294 return -EFAULT;
2295 ret = 0;
2296 switch (type)
2297 {
2298 case TIOCL_SETSEL:
2299 acquire_console_sem();
2300 ret = set_selection((struct tiocl_selection __user *)(p+1), tty);
2301 release_console_sem();
2302 break;
2303 case TIOCL_PASTESEL:
2304 ret = paste_selection(tty);
2305 break;
2306 case TIOCL_UNBLANKSCREEN:
2307 acquire_console_sem();
2308 unblank_screen();
2309 release_console_sem();
2310 break;
2311 case TIOCL_SELLOADLUT:
2312 ret = sel_loadlut(p);
2313 break;
2314 case TIOCL_GETSHIFTSTATE:
2315
2316 /*
2317 * Make it possible to react to Shift+Mousebutton.
2318 * Note that 'shift_state' is an undocumented
2319 * kernel-internal variable; programs not closely
2320 * related to the kernel should not use this.
2321 */
2322 data = shift_state;
2323 ret = __put_user(data, p);
2324 break;
2325 case TIOCL_GETMOUSEREPORTING:
2326 data = mouse_reporting();
2327 ret = __put_user(data, p);
2328 break;
2329 case TIOCL_SETVESABLANK:
2330 set_vesa_blanking(p);
2331 break;
2332 case TIOCL_GETKMSGREDIRECT:
2333 data = kmsg_redirect;
2334 ret = __put_user(data, p);
2335 break;
2336 case TIOCL_SETKMSGREDIRECT:
2337 if (!capable(CAP_SYS_ADMIN)) {
2338 ret = -EPERM;
2339 } else {
2340 if (get_user(data, p+1))
2341 ret = -EFAULT;
2342 else
2343 kmsg_redirect = data;
2344 }
2345 break;
2346 case TIOCL_GETFGCONSOLE:
2347 ret = fg_console;
2348 break;
2349 case TIOCL_SCROLLCONSOLE:
2350 if (get_user(lines, (s32 __user *)(p+4))) {
2351 ret = -EFAULT;
2352 } else {
2353 scrollfront(vc_cons[fg_console].d, lines);
2354 ret = 0;
2355 }
2356 break;
2357 case TIOCL_BLANKSCREEN: /* until explicitly unblanked, not only poked */
2358 acquire_console_sem();
2359 ignore_poke = 1;
2360 do_blank_screen(0);
2361 release_console_sem();
2362 break;
2363 case TIOCL_BLANKEDSCREEN:
2364 ret = console_blanked;
2365 break;
2366 default:
2367 ret = -EINVAL;
2368 break;
2369 }
2370 return ret;
2371 }
2372
2373 /*
2374 * /dev/ttyN handling
2375 */
2376
2377 static int con_write(struct tty_struct *tty, const unsigned char *buf, int count)
2378 {
2379 int retval;
2380
2381 retval = do_con_write(tty, buf, count);
2382 con_flush_chars(tty);
2383
2384 return retval;
2385 }
2386
2387 static void con_put_char(struct tty_struct *tty, unsigned char ch)
2388 {
2389 if (in_interrupt())
2390 return; /* n_r3964 calls put_char() from interrupt context */
2391 do_con_write(tty, &ch, 1);
2392 }
2393
2394 static int con_write_room(struct tty_struct *tty)
2395 {
2396 if (tty->stopped)
2397 return 0;
2398 return 4096; /* No limit, really; we're not buffering */
2399 }
2400
2401 static int con_chars_in_buffer(struct tty_struct *tty)
2402 {
2403 return 0; /* we're not buffering */
2404 }
2405
2406 /*
2407 * con_throttle and con_unthrottle are only used for
2408 * paste_selection(), which has to stuff in a large number of
2409 * characters...
2410 */
2411 static void con_throttle(struct tty_struct *tty)
2412 {
2413 }
2414
2415 static void con_unthrottle(struct tty_struct *tty)
2416 {
2417 struct vc_data *vc = tty->driver_data;
2418
2419 wake_up_interruptible(&vc->paste_wait);
2420 }
2421
2422 /*
2423 * Turn the Scroll-Lock LED on when the tty is stopped
2424 */
2425 static void con_stop(struct tty_struct *tty)
2426 {
2427 int console_num;
2428 if (!tty)
2429 return;
2430 console_num = tty->index;
2431 if (!vc_cons_allocated(console_num))
2432 return;
2433 set_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
2434 set_leds();
2435 }
2436
2437 /*
2438 * Turn the Scroll-Lock LED off when the console is started
2439 */
2440 static void con_start(struct tty_struct *tty)
2441 {
2442 int console_num;
2443 if (!tty)
2444 return;
2445 console_num = tty->index;
2446 if (!vc_cons_allocated(console_num))
2447 return;
2448 clr_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
2449 set_leds();
2450 }
2451
2452 static void con_flush_chars(struct tty_struct *tty)
2453 {
2454 struct vc_data *vc;
2455
2456 if (in_interrupt()) /* from flush_to_ldisc */
2457 return;
2458
2459 /* if we race with con_close(), vt may be null */
2460 acquire_console_sem();
2461 vc = tty->driver_data;
2462 if (vc)
2463 set_cursor(vc);
2464 release_console_sem();
2465 }
2466
2467 /*
2468 * Allocate the console screen memory.
2469 */
2470 static int con_open(struct tty_struct *tty, struct file *filp)
2471 {
2472 unsigned int currcons = tty->index;
2473 int ret = 0;
2474
2475 acquire_console_sem();
2476 if (tty->driver_data == NULL) {
2477 ret = vc_allocate(currcons);
2478 if (ret == 0) {
2479 struct vc_data *vc = vc_cons[currcons].d;
2480 tty->driver_data = vc;
2481 vc->vc_tty = tty;
2482
2483 if (!tty->winsize.ws_row && !tty->winsize.ws_col) {
2484 tty->winsize.ws_row = vc_cons[currcons].d->vc_rows;
2485 tty->winsize.ws_col = vc_cons[currcons].d->vc_cols;
2486 }
2487 release_console_sem();
2488 vcs_make_devfs(tty);
2489 return ret;
2490 }
2491 }
2492 release_console_sem();
2493 return ret;
2494 }
2495
2496 /*
2497 * We take tty_mutex in here to prevent another thread from coming in via init_dev
2498 * and taking a ref against the tty while we're in the process of forgetting
2499 * about it and cleaning things up.
2500 *
2501 * This is because vcs_remove_devfs() can sleep and will drop the BKL.
2502 */
2503 static void con_close(struct tty_struct *tty, struct file *filp)
2504 {
2505 mutex_lock(&tty_mutex);
2506 acquire_console_sem();
2507 if (tty && tty->count == 1) {
2508 struct vc_data *vc = tty->driver_data;
2509
2510 if (vc)
2511 vc->vc_tty = NULL;
2512 tty->driver_data = NULL;
2513 release_console_sem();
2514 vcs_remove_devfs(tty);
2515 mutex_unlock(&tty_mutex);
2516 /*
2517 * tty_mutex is released, but we still hold BKL, so there is
2518 * still exclusion against init_dev()
2519 */
2520 return;
2521 }
2522 release_console_sem();
2523 mutex_unlock(&tty_mutex);
2524 }
2525
2526 static void vc_init(struct vc_data *vc, unsigned int rows,
2527 unsigned int cols, int do_clear)
2528 {
2529 int j, k ;
2530
2531 vc->vc_cols = cols;
2532 vc->vc_rows = rows;
2533 vc->vc_size_row = cols << 1;
2534 vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row;
2535
2536 set_origin(vc);
2537 vc->vc_pos = vc->vc_origin;
2538 reset_vc(vc);
2539 for (j=k=0; j<16; j++) {
2540 vc->vc_palette[k++] = default_red[j] ;
2541 vc->vc_palette[k++] = default_grn[j] ;
2542 vc->vc_palette[k++] = default_blu[j] ;
2543 }
2544 vc->vc_def_color = 0x07; /* white */
2545 vc->vc_ulcolor = 0x0f; /* bold white */
2546 vc->vc_halfcolor = 0x08; /* grey */
2547 init_waitqueue_head(&vc->paste_wait);
2548 reset_terminal(vc, do_clear);
2549 }
2550
2551 /*
2552 * This routine initializes console interrupts, and does nothing
2553 * else. If you want the screen to clear, call tty_write with
2554 * the appropriate escape-sequence.
2555 */
2556
2557 static int __init con_init(void)
2558 {
2559 const char *display_desc = NULL;
2560 struct vc_data *vc;
2561 unsigned int currcons = 0;
2562
2563 acquire_console_sem();
2564
2565 if (conswitchp)
2566 display_desc = conswitchp->con_startup();
2567 if (!display_desc) {
2568 fg_console = 0;
2569 release_console_sem();
2570 return 0;
2571 }
2572
2573 init_timer(&console_timer);
2574 console_timer.function = blank_screen_t;
2575 if (blankinterval) {
2576 blank_state = blank_normal_wait;
2577 mod_timer(&console_timer, jiffies + blankinterval);
2578 }
2579
2580 /*
2581 * kmalloc is not running yet - we use the bootmem allocator.
2582 */
2583 for (currcons = 0; currcons < MIN_NR_CONSOLES; currcons++) {
2584 vc_cons[currcons].d = vc = alloc_bootmem(sizeof(struct vc_data));
2585 visual_init(vc, currcons, 1);
2586 vc->vc_screenbuf = (unsigned short *)alloc_bootmem(vc->vc_screenbuf_size);
2587 vc->vc_kmalloced = 0;
2588 vc_init(vc, vc->vc_rows, vc->vc_cols,
2589 currcons || !vc->vc_sw->con_save_screen);
2590 }
2591 currcons = fg_console = 0;
2592 master_display_fg = vc = vc_cons[currcons].d;
2593 set_origin(vc);
2594 save_screen(vc);
2595 gotoxy(vc, vc->vc_x, vc->vc_y);
2596 csi_J(vc, 0);
2597 update_screen(vc);
2598 printk("Console: %s %s %dx%d",
2599 vc->vc_can_do_color ? "colour" : "mono",
2600 display_desc, vc->vc_cols, vc->vc_rows);
2601 printable = 1;
2602 printk("\n");
2603
2604 release_console_sem();
2605
2606 #ifdef CONFIG_VT_CONSOLE
2607 register_console(&vt_console_driver);
2608 #endif
2609 return 0;
2610 }
2611 console_initcall(con_init);
2612
2613 static struct tty_operations con_ops = {
2614 .open = con_open,
2615 .close = con_close,
2616 .write = con_write,
2617 .write_room = con_write_room,
2618 .put_char = con_put_char,
2619 .flush_chars = con_flush_chars,
2620 .chars_in_buffer = con_chars_in_buffer,
2621 .ioctl = vt_ioctl,
2622 .stop = con_stop,
2623 .start = con_start,
2624 .throttle = con_throttle,
2625 .unthrottle = con_unthrottle,
2626 };
2627
2628 int __init vty_init(void)
2629 {
2630 vcs_init();
2631
2632 console_driver = alloc_tty_driver(MAX_NR_CONSOLES);
2633 if (!console_driver)
2634 panic("Couldn't allocate console driver\n");
2635 console_driver->owner = THIS_MODULE;
2636 console_driver->devfs_name = "vc/";
2637 console_driver->name = "tty";
2638 console_driver->name_base = 1;
2639 console_driver->major = TTY_MAJOR;
2640 console_driver->minor_start = 1;
2641 console_driver->type = TTY_DRIVER_TYPE_CONSOLE;
2642 console_driver->init_termios = tty_std_termios;
2643 console_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
2644 tty_set_operations(console_driver, &con_ops);
2645 if (tty_register_driver(console_driver))
2646 panic("Couldn't register console driver\n");
2647
2648 kbd_init();
2649 console_map_init();
2650 #ifdef CONFIG_PROM_CONSOLE
2651 prom_con_init();
2652 #endif
2653 #ifdef CONFIG_MDA_CONSOLE
2654 mda_console_init();
2655 #endif
2656 return 0;
2657 }
2658
2659 #ifndef VT_SINGLE_DRIVER
2660
2661 /*
2662 * If we support more console drivers, this function is used
2663 * when a driver wants to take over some existing consoles
2664 * and become default driver for newly opened ones.
2665 */
2666
2667 int take_over_console(const struct consw *csw, int first, int last, int deflt)
2668 {
2669 int i, j = -1, k = -1;
2670 const char *desc;
2671 struct module *owner;
2672
2673 owner = csw->owner;
2674 if (!try_module_get(owner))
2675 return -ENODEV;
2676
2677 /* save default console, for possible recovery later on */
2678 if (!defcsw)
2679 defcsw = (struct consw *) conswitchp;
2680
2681 acquire_console_sem();
2682 desc = csw->con_startup();
2683
2684 if (!desc) {
2685 release_console_sem();
2686 module_put(owner);
2687 return -ENODEV;
2688 }
2689
2690 if (deflt) {
2691 if (conswitchp)
2692 module_put(conswitchp->owner);
2693
2694 __module_get(owner);
2695 conswitchp = csw;
2696 }
2697
2698 for (i = first; i <= last; i++) {
2699 int old_was_color;
2700 struct vc_data *vc = vc_cons[i].d;
2701
2702 if (con_driver_map[i])
2703 module_put(con_driver_map[i]->owner);
2704 __module_get(owner);
2705 con_driver_map[i] = csw;
2706
2707 if (!vc || !vc->vc_sw)
2708 continue;
2709
2710 j = i;
2711
2712 if (CON_IS_VISIBLE(vc)) {
2713 k = i;
2714 save_screen(vc);
2715 }
2716
2717 old_was_color = vc->vc_can_do_color;
2718 vc->vc_sw->con_deinit(vc);
2719 vc->vc_origin = (unsigned long)vc->vc_screenbuf;
2720 visual_init(vc, i, 0);
2721 set_origin(vc);
2722 update_attr(vc);
2723
2724 /* If the console changed between mono <-> color, then
2725 * the attributes in the screenbuf will be wrong. The
2726 * following resets all attributes to something sane.
2727 */
2728 if (old_was_color != vc->vc_can_do_color)
2729 clear_buffer_attributes(vc);
2730 }
2731
2732 printk("Console: switching ");
2733 if (!deflt)
2734 printk("consoles %d-%d ", first+1, last+1);
2735 if (j >= 0) {
2736 struct vc_data *vc = vc_cons[j].d;
2737
2738 printk("to %s %s %dx%d\n",
2739 vc->vc_can_do_color ? "colour" : "mono",
2740 desc, vc->vc_cols, vc->vc_rows);
2741
2742 if (k >= 0) {
2743 vc = vc_cons[k].d;
2744 update_screen(vc);
2745 }
2746 } else
2747 printk("to %s\n", desc);
2748
2749 release_console_sem();
2750 module_put(owner);
2751 return 0;
2752 }
2753
2754 void give_up_console(const struct consw *csw)
2755 {
2756 int i, first = -1, last = -1, deflt = 0;
2757
2758 for (i = 0; i < MAX_NR_CONSOLES; i++)
2759 if (con_driver_map[i] == csw) {
2760 if (first == -1)
2761 first = i;
2762 last = i;
2763 module_put(csw->owner);
2764 con_driver_map[i] = NULL;
2765 }
2766
2767 if (first != -1 && defcsw) {
2768 if (first == 0 && last == MAX_NR_CONSOLES - 1)
2769 deflt = 1;
2770 take_over_console(defcsw, first, last, deflt);
2771 }
2772 }
2773 #endif
2774
2775 /*
2776 * Screen blanking
2777 */
2778
2779 static void set_vesa_blanking(char __user *p)
2780 {
2781 unsigned int mode;
2782 get_user(mode, p + 1);
2783 vesa_blank_mode = (mode < 4) ? mode : 0;
2784 }
2785
2786 void do_blank_screen(int entering_gfx)
2787 {
2788 struct vc_data *vc = vc_cons[fg_console].d;
2789 int i;
2790
2791 WARN_CONSOLE_UNLOCKED();
2792
2793 if (console_blanked) {
2794 if (blank_state == blank_vesa_wait) {
2795 blank_state = blank_off;
2796 vc->vc_sw->con_blank(vc, vesa_blank_mode + 1, 0);
2797 }
2798 return;
2799 }
2800 if (blank_state != blank_normal_wait)
2801 return;
2802 blank_state = blank_off;
2803
2804 /* entering graphics mode? */
2805 if (entering_gfx) {
2806 hide_cursor(vc);
2807 save_screen(vc);
2808 vc->vc_sw->con_blank(vc, -1, 1);
2809 console_blanked = fg_console + 1;
2810 set_origin(vc);
2811 return;
2812 }
2813
2814 /* don't blank graphics */
2815 if (vc->vc_mode != KD_TEXT) {
2816 console_blanked = fg_console + 1;
2817 return;
2818 }
2819
2820 hide_cursor(vc);
2821 del_timer_sync(&console_timer);
2822 blank_timer_expired = 0;
2823
2824 save_screen(vc);
2825 /* In case we need to reset origin, blanking hook returns 1 */
2826 i = vc->vc_sw->con_blank(vc, vesa_off_interval ? 1 : (vesa_blank_mode + 1), 0);
2827 console_blanked = fg_console + 1;
2828 if (i)
2829 set_origin(vc);
2830
2831 if (console_blank_hook && console_blank_hook(1))
2832 return;
2833
2834 if (vesa_off_interval && vesa_blank_mode) {
2835 blank_state = blank_vesa_wait;
2836 mod_timer(&console_timer, jiffies + vesa_off_interval);
2837 }
2838 }
2839 EXPORT_SYMBOL(do_blank_screen);
2840
2841 /*
2842 * Called by timer as well as from vt_console_driver
2843 */
2844 void do_unblank_screen(int leaving_gfx)
2845 {
2846 struct vc_data *vc;
2847
2848 /* This should now always be called from a "sane" (read: can schedule)
2849 * context for the sake of the low level drivers, except in the special
2850 * case of oops_in_progress
2851 */
2852 if (!oops_in_progress)
2853 might_sleep();
2854
2855 WARN_CONSOLE_UNLOCKED();
2856
2857 ignore_poke = 0;
2858 if (!console_blanked)
2859 return;
2860 if (!vc_cons_allocated(fg_console)) {
2861 /* impossible */
2862 printk("unblank_screen: tty %d not allocated ??\n", fg_console+1);
2863 return;
2864 }
2865 vc = vc_cons[fg_console].d;
2866 if (vc->vc_mode != KD_TEXT)
2867 return; /* but leave console_blanked != 0 */
2868
2869 if (blankinterval) {
2870 mod_timer(&console_timer, jiffies + blankinterval);
2871 blank_state = blank_normal_wait;
2872 }
2873
2874 console_blanked = 0;
2875 if (vc->vc_sw->con_blank(vc, 0, leaving_gfx))
2876 /* Low-level driver cannot restore -> do it ourselves */
2877 update_screen(vc);
2878 if (console_blank_hook)
2879 console_blank_hook(0);
2880 set_palette(vc);
2881 set_cursor(vc);
2882 }
2883 EXPORT_SYMBOL(do_unblank_screen);
2884
2885 /*
2886 * This is called by the outside world to cause a forced unblank, mostly for
2887 * oopses. Currently, I just call do_unblank_screen(0), but we could eventually
2888 * call it with 1 as an argument and so force a mode restore... that may kill
2889 * X or at least garbage the screen but would also make the Oops visible...
2890 */
2891 void unblank_screen(void)
2892 {
2893 do_unblank_screen(0);
2894 }
2895
2896 /*
2897 * We defer the timer blanking to work queue so it can take the console mutex
2898 * (console operations can still happen at irq time, but only from printk which
2899 * has the console mutex. Not perfect yet, but better than no locking
2900 */
2901 static void blank_screen_t(unsigned long dummy)
2902 {
2903 if (unlikely(!keventd_up())) {
2904 mod_timer(&console_timer, jiffies + blankinterval);
2905 return;
2906 }
2907 blank_timer_expired = 1;
2908 schedule_work(&console_work);
2909 }
2910
2911 void poke_blanked_console(void)
2912 {
2913 WARN_CONSOLE_UNLOCKED();
2914
2915 /* Add this so we quickly catch whoever might call us in a non
2916 * safe context. Nowadays, unblank_screen() isn't to be called in
2917 * atomic contexts and is allowed to schedule (with the special case
2918 * of oops_in_progress, but that isn't of any concern for this
2919 * function. --BenH.
2920 */
2921 might_sleep();
2922
2923 /* This isn't perfectly race free, but a race here would be mostly harmless,
2924 * at worse, we'll do a spurrious blank and it's unlikely
2925 */
2926 del_timer(&console_timer);
2927 blank_timer_expired = 0;
2928
2929 if (ignore_poke || !vc_cons[fg_console].d || vc_cons[fg_console].d->vc_mode == KD_GRAPHICS)
2930 return;
2931 if (console_blanked)
2932 unblank_screen();
2933 else if (blankinterval) {
2934 mod_timer(&console_timer, jiffies + blankinterval);
2935 blank_state = blank_normal_wait;
2936 }
2937 }
2938
2939 /*
2940 * Palettes
2941 */
2942
2943 static void set_palette(struct vc_data *vc)
2944 {
2945 WARN_CONSOLE_UNLOCKED();
2946
2947 if (vc->vc_mode != KD_GRAPHICS)
2948 vc->vc_sw->con_set_palette(vc, color_table);
2949 }
2950
2951 static int set_get_cmap(unsigned char __user *arg, int set)
2952 {
2953 int i, j, k;
2954
2955 WARN_CONSOLE_UNLOCKED();
2956
2957 for (i = 0; i < 16; i++)
2958 if (set) {
2959 get_user(default_red[i], arg++);
2960 get_user(default_grn[i], arg++);
2961 get_user(default_blu[i], arg++);
2962 } else {
2963 put_user(default_red[i], arg++);
2964 put_user(default_grn[i], arg++);
2965 put_user(default_blu[i], arg++);
2966 }
2967 if (set) {
2968 for (i = 0; i < MAX_NR_CONSOLES; i++)
2969 if (vc_cons_allocated(i)) {
2970 for (j = k = 0; j < 16; j++) {
2971 vc_cons[i].d->vc_palette[k++] = default_red[j];
2972 vc_cons[i].d->vc_palette[k++] = default_grn[j];
2973 vc_cons[i].d->vc_palette[k++] = default_blu[j];
2974 }
2975 set_palette(vc_cons[i].d);
2976 }
2977 }
2978 return 0;
2979 }
2980
2981 /*
2982 * Load palette into the DAC registers. arg points to a colour
2983 * map, 3 bytes per colour, 16 colours, range from 0 to 255.
2984 */
2985
2986 int con_set_cmap(unsigned char __user *arg)
2987 {
2988 int rc;
2989
2990 acquire_console_sem();
2991 rc = set_get_cmap (arg,1);
2992 release_console_sem();
2993
2994 return rc;
2995 }
2996
2997 int con_get_cmap(unsigned char __user *arg)
2998 {
2999 int rc;
3000
3001 acquire_console_sem();
3002 rc = set_get_cmap (arg,0);
3003 release_console_sem();
3004
3005 return rc;
3006 }
3007
3008 void reset_palette(struct vc_data *vc)
3009 {
3010 int j, k;
3011 for (j=k=0; j<16; j++) {
3012 vc->vc_palette[k++] = default_red[j];
3013 vc->vc_palette[k++] = default_grn[j];
3014 vc->vc_palette[k++] = default_blu[j];
3015 }
3016 set_palette(vc);
3017 }
3018
3019 /*
3020 * Font switching
3021 *
3022 * Currently we only support fonts up to 32 pixels wide, at a maximum height
3023 * of 32 pixels. Userspace fontdata is stored with 32 bytes (shorts/ints,
3024 * depending on width) reserved for each character which is kinda wasty, but
3025 * this is done in order to maintain compatibility with the EGA/VGA fonts. It
3026 * is upto the actual low-level console-driver convert data into its favorite
3027 * format (maybe we should add a `fontoffset' field to the `display'
3028 * structure so we won't have to convert the fontdata all the time.
3029 * /Jes
3030 */
3031
3032 #define max_font_size 65536
3033
3034 static int con_font_get(struct vc_data *vc, struct console_font_op *op)
3035 {
3036 struct console_font font;
3037 int rc = -EINVAL;
3038 int c;
3039
3040 if (vc->vc_mode != KD_TEXT)
3041 return -EINVAL;
3042
3043 if (op->data) {
3044 font.data = kmalloc(max_font_size, GFP_KERNEL);
3045 if (!font.data)
3046 return -ENOMEM;
3047 } else
3048 font.data = NULL;
3049
3050 acquire_console_sem();
3051 if (vc->vc_sw->con_font_get)
3052 rc = vc->vc_sw->con_font_get(vc, &font);
3053 else
3054 rc = -ENOSYS;
3055 release_console_sem();
3056
3057 if (rc)
3058 goto out;
3059
3060 c = (font.width+7)/8 * 32 * font.charcount;
3061
3062 if (op->data && font.charcount > op->charcount)
3063 rc = -ENOSPC;
3064 if (!(op->flags & KD_FONT_FLAG_OLD)) {
3065 if (font.width > op->width || font.height > op->height)
3066 rc = -ENOSPC;
3067 } else {
3068 if (font.width != 8)
3069 rc = -EIO;
3070 else if ((op->height && font.height > op->height) ||
3071 font.height > 32)
3072 rc = -ENOSPC;
3073 }
3074 if (rc)
3075 goto out;
3076
3077 op->height = font.height;
3078 op->width = font.width;
3079 op->charcount = font.charcount;
3080
3081 if (op->data && copy_to_user(op->data, font.data, c))
3082 rc = -EFAULT;
3083
3084 out:
3085 kfree(font.data);
3086 return rc;
3087 }
3088
3089 static int con_font_set(struct vc_data *vc, struct console_font_op *op)
3090 {
3091 struct console_font font;
3092 int rc = -EINVAL;
3093 int size;
3094
3095 if (vc->vc_mode != KD_TEXT)
3096 return -EINVAL;
3097 if (!op->data)
3098 return -EINVAL;
3099 if (op->charcount > 512)
3100 return -EINVAL;
3101 if (!op->height) { /* Need to guess font height [compat] */
3102 int h, i;
3103 u8 __user *charmap = op->data;
3104 u8 tmp;
3105
3106 /* If from KDFONTOP ioctl, don't allow things which can be done in userland,
3107 so that we can get rid of this soon */
3108 if (!(op->flags & KD_FONT_FLAG_OLD))
3109 return -EINVAL;
3110 for (h = 32; h > 0; h--)
3111 for (i = 0; i < op->charcount; i++) {
3112 if (get_user(tmp, &charmap[32*i+h-1]))
3113 return -EFAULT;
3114 if (tmp)
3115 goto nonzero;
3116 }
3117 return -EINVAL;
3118 nonzero:
3119 op->height = h;
3120 }
3121 if (op->width <= 0 || op->width > 32 || op->height > 32)
3122 return -EINVAL;
3123 size = (op->width+7)/8 * 32 * op->charcount;
3124 if (size > max_font_size)
3125 return -ENOSPC;
3126 font.charcount = op->charcount;
3127 font.height = op->height;
3128 font.width = op->width;
3129 font.data = kmalloc(size, GFP_KERNEL);
3130 if (!font.data)
3131 return -ENOMEM;
3132 if (copy_from_user(font.data, op->data, size)) {
3133 kfree(font.data);
3134 return -EFAULT;
3135 }
3136 acquire_console_sem();
3137 if (vc->vc_sw->con_font_set)
3138 rc = vc->vc_sw->con_font_set(vc, &font, op->flags);
3139 else
3140 rc = -ENOSYS;
3141 release_console_sem();
3142 kfree(font.data);
3143 return rc;
3144 }
3145
3146 static int con_font_default(struct vc_data *vc, struct console_font_op *op)
3147 {
3148 struct console_font font = {.width = op->width, .height = op->height};
3149 char name[MAX_FONT_NAME];
3150 char *s = name;
3151 int rc;
3152
3153 if (vc->vc_mode != KD_TEXT)
3154 return -EINVAL;
3155
3156 if (!op->data)
3157 s = NULL;
3158 else if (strncpy_from_user(name, op->data, MAX_FONT_NAME - 1) < 0)
3159 return -EFAULT;
3160 else
3161 name[MAX_FONT_NAME - 1] = 0;
3162
3163 acquire_console_sem();
3164 if (vc->vc_sw->con_font_default)
3165 rc = vc->vc_sw->con_font_default(vc, &font, s);
3166 else
3167 rc = -ENOSYS;
3168 release_console_sem();
3169 if (!rc) {
3170 op->width = font.width;
3171 op->height = font.height;
3172 }
3173 return rc;
3174 }
3175
3176 static int con_font_copy(struct vc_data *vc, struct console_font_op *op)
3177 {
3178 int con = op->height;
3179 int rc;
3180
3181 if (vc->vc_mode != KD_TEXT)
3182 return -EINVAL;
3183
3184 acquire_console_sem();
3185 if (!vc->vc_sw->con_font_copy)
3186 rc = -ENOSYS;
3187 else if (con < 0 || !vc_cons_allocated(con))
3188 rc = -ENOTTY;
3189 else if (con == vc->vc_num) /* nothing to do */
3190 rc = 0;
3191 else
3192 rc = vc->vc_sw->con_font_copy(vc, con);
3193 release_console_sem();
3194 return rc;
3195 }
3196
3197 int con_font_op(struct vc_data *vc, struct console_font_op *op)
3198 {
3199 switch (op->op) {
3200 case KD_FONT_OP_SET:
3201 return con_font_set(vc, op);
3202 case KD_FONT_OP_GET:
3203 return con_font_get(vc, op);
3204 case KD_FONT_OP_SET_DEFAULT:
3205 return con_font_default(vc, op);
3206 case KD_FONT_OP_COPY:
3207 return con_font_copy(vc, op);
3208 }
3209 return -ENOSYS;
3210 }
3211
3212 /*
3213 * Interface exported to selection and vcs.
3214 */
3215
3216 /* used by selection */
3217 u16 screen_glyph(struct vc_data *vc, int offset)
3218 {
3219 u16 w = scr_readw(screenpos(vc, offset, 1));
3220 u16 c = w & 0xff;
3221
3222 if (w & vc->vc_hi_font_mask)
3223 c |= 0x100;
3224 return c;
3225 }
3226
3227 /* used by vcs - note the word offset */
3228 unsigned short *screen_pos(struct vc_data *vc, int w_offset, int viewed)
3229 {
3230 return screenpos(vc, 2 * w_offset, viewed);
3231 }
3232
3233 void getconsxy(struct vc_data *vc, unsigned char *p)
3234 {
3235 p[0] = vc->vc_x;
3236 p[1] = vc->vc_y;
3237 }
3238
3239 void putconsxy(struct vc_data *vc, unsigned char *p)
3240 {
3241 hide_cursor(vc);
3242 gotoxy(vc, p[0], p[1]);
3243 set_cursor(vc);
3244 }
3245
3246 u16 vcs_scr_readw(struct vc_data *vc, const u16 *org)
3247 {
3248 if ((unsigned long)org == vc->vc_pos && softcursor_original != -1)
3249 return softcursor_original;
3250 return scr_readw(org);
3251 }
3252
3253 void vcs_scr_writew(struct vc_data *vc, u16 val, u16 *org)
3254 {
3255 scr_writew(val, org);
3256 if ((unsigned long)org == vc->vc_pos) {
3257 softcursor_original = -1;
3258 add_softcursor(vc);
3259 }
3260 }
3261
3262 /*
3263 * Visible symbols for modules
3264 */
3265
3266 EXPORT_SYMBOL(color_table);
3267 EXPORT_SYMBOL(default_red);
3268 EXPORT_SYMBOL(default_grn);
3269 EXPORT_SYMBOL(default_blu);
3270 EXPORT_SYMBOL(update_region);
3271 EXPORT_SYMBOL(redraw_screen);
3272 EXPORT_SYMBOL(vc_resize);
3273 EXPORT_SYMBOL(fg_console);
3274 EXPORT_SYMBOL(console_blank_hook);
3275 EXPORT_SYMBOL(console_blanked);
3276 EXPORT_SYMBOL(vc_cons);
3277 #ifndef VT_SINGLE_DRIVER
3278 EXPORT_SYMBOL(take_over_console);
3279 EXPORT_SYMBOL(give_up_console);
3280 #endif
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree