]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/tty/vt/vt.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'core' of git://git.kernel.org/pub/scm/linux/kernel/git/rric/oprofile...
[mirror_ubuntu-bionic-kernel.git] / drivers / tty / vt / vt.c
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
63 *
64 * Removed console_lock, enabled interrupts across all console operations
65 * 13 March 2001, Andrew Morton
66 *
67 * Fixed UTF-8 mode so alternate charset modes always work according
68 * to control sequences interpreted in do_con_trol function
69 * preserving backward VT100 semigraphics compatibility,
70 * malformed UTF sequences represented as sequences of replacement glyphs,
71 * original codes or '?' as a last resort if replacement glyph is undefined
72 * by Adam Tla/lka <atlka@pg.gda.pl>, Aug 2006
73 */
74
75 #include <linux/module.h>
76 #include <linux/types.h>
77 #include <linux/sched.h>
78 #include <linux/tty.h>
79 #include <linux/tty_flip.h>
80 #include <linux/kernel.h>
81 #include <linux/string.h>
82 #include <linux/errno.h>
83 #include <linux/kd.h>
84 #include <linux/slab.h>
85 #include <linux/major.h>
86 #include <linux/mm.h>
87 #include <linux/console.h>
88 #include <linux/init.h>
89 #include <linux/mutex.h>
90 #include <linux/vt_kern.h>
91 #include <linux/selection.h>
92 #include <linux/smp_lock.h>
93 #include <linux/tiocl.h>
94 #include <linux/kbd_kern.h>
95 #include <linux/consolemap.h>
96 #include <linux/timer.h>
97 #include <linux/interrupt.h>
98 #include <linux/workqueue.h>
99 #include <linux/pm.h>
100 #include <linux/font.h>
101 #include <linux/bitops.h>
102 #include <linux/notifier.h>
103 #include <linux/device.h>
104 #include <linux/io.h>
105 #include <asm/system.h>
106 #include <linux/uaccess.h>
107 #include <linux/kdb.h>
108 #include <linux/ctype.h>
109
110 #define MAX_NR_CON_DRIVER 16
111
112 #define CON_DRIVER_FLAG_MODULE 1
113 #define CON_DRIVER_FLAG_INIT 2
114 #define CON_DRIVER_FLAG_ATTR 4
115
116 struct con_driver {
117 const struct consw *con;
118 const char *desc;
119 struct device *dev;
120 int node;
121 int first;
122 int last;
123 int flag;
124 };
125
126 static struct con_driver registered_con_driver[MAX_NR_CON_DRIVER];
127 const struct consw *conswitchp;
128
129 /* A bitmap for codes <32. A bit of 1 indicates that the code
130 * corresponding to that bit number invokes some special action
131 * (such as cursor movement) and should not be displayed as a
132 * glyph unless the disp_ctrl mode is explicitly enabled.
133 */
134 #define CTRL_ACTION 0x0d00ff81
135 #define CTRL_ALWAYS 0x0800f501 /* Cannot be overridden by disp_ctrl */
136
137 /*
138 * Here is the default bell parameters: 750HZ, 1/8th of a second
139 */
140 #define DEFAULT_BELL_PITCH 750
141 #define DEFAULT_BELL_DURATION (HZ/8)
142
143 struct vc vc_cons [MAX_NR_CONSOLES];
144
145 #ifndef VT_SINGLE_DRIVER
146 static const struct consw *con_driver_map[MAX_NR_CONSOLES];
147 #endif
148
149 static int con_open(struct tty_struct *, struct file *);
150 static void vc_init(struct vc_data *vc, unsigned int rows,
151 unsigned int cols, int do_clear);
152 static void gotoxy(struct vc_data *vc, int new_x, int new_y);
153 static void save_cur(struct vc_data *vc);
154 static void reset_terminal(struct vc_data *vc, int do_clear);
155 static void con_flush_chars(struct tty_struct *tty);
156 static int set_vesa_blanking(char __user *p);
157 static void set_cursor(struct vc_data *vc);
158 static void hide_cursor(struct vc_data *vc);
159 static void console_callback(struct work_struct *ignored);
160 static void blank_screen_t(unsigned long dummy);
161 static void set_palette(struct vc_data *vc);
162
163 static int printable; /* Is console ready for printing? */
164 int default_utf8 = true;
165 module_param(default_utf8, int, S_IRUGO | S_IWUSR);
166 int global_cursor_default = -1;
167 module_param(global_cursor_default, int, S_IRUGO | S_IWUSR);
168
169 static int cur_default = CUR_DEFAULT;
170 module_param(cur_default, int, S_IRUGO | S_IWUSR);
171
172 /*
173 * ignore_poke: don't unblank the screen when things are typed. This is
174 * mainly for the privacy of braille terminal users.
175 */
176 static int ignore_poke;
177
178 int do_poke_blanked_console;
179 int console_blanked;
180
181 static int vesa_blank_mode; /* 0:none 1:suspendV 2:suspendH 3:powerdown */
182 static int vesa_off_interval;
183 static int blankinterval = 10*60;
184 core_param(consoleblank, blankinterval, int, 0444);
185
186 static DECLARE_WORK(console_work, console_callback);
187
188 /*
189 * fg_console is the current virtual console,
190 * last_console is the last used one,
191 * want_console is the console we want to switch to,
192 * saved_* variants are for save/restore around kernel debugger enter/leave
193 */
194 int fg_console;
195 int last_console;
196 int want_console = -1;
197 static int saved_fg_console;
198 static int saved_last_console;
199 static int saved_want_console;
200 static int saved_vc_mode;
201 static int saved_console_blanked;
202
203 /*
204 * For each existing display, we have a pointer to console currently visible
205 * on that display, allowing consoles other than fg_console to be refreshed
206 * appropriately. Unless the low-level driver supplies its own display_fg
207 * variable, we use this one for the "master display".
208 */
209 static struct vc_data *master_display_fg;
210
211 /*
212 * Unfortunately, we need to delay tty echo when we're currently writing to the
213 * console since the code is (and always was) not re-entrant, so we schedule
214 * all flip requests to process context with schedule-task() and run it from
215 * console_callback().
216 */
217
218 /*
219 * For the same reason, we defer scrollback to the console callback.
220 */
221 static int scrollback_delta;
222
223 /*
224 * Hook so that the power management routines can (un)blank
225 * the console on our behalf.
226 */
227 int (*console_blank_hook)(int);
228
229 static DEFINE_TIMER(console_timer, blank_screen_t, 0, 0);
230 static int blank_state;
231 static int blank_timer_expired;
232 enum {
233 blank_off = 0,
234 blank_normal_wait,
235 blank_vesa_wait,
236 };
237
238 /*
239 * /sys/class/tty/tty0/
240 *
241 * the attribute 'active' contains the name of the current vc
242 * console and it supports poll() to detect vc switches
243 */
244 static struct device *tty0dev;
245
246 /*
247 * Notifier list for console events.
248 */
249 static ATOMIC_NOTIFIER_HEAD(vt_notifier_list);
250
251 int register_vt_notifier(struct notifier_block *nb)
252 {
253 return atomic_notifier_chain_register(&vt_notifier_list, nb);
254 }
255 EXPORT_SYMBOL_GPL(register_vt_notifier);
256
257 int unregister_vt_notifier(struct notifier_block *nb)
258 {
259 return atomic_notifier_chain_unregister(&vt_notifier_list, nb);
260 }
261 EXPORT_SYMBOL_GPL(unregister_vt_notifier);
262
263 static void notify_write(struct vc_data *vc, unsigned int unicode)
264 {
265 struct vt_notifier_param param = { .vc = vc, unicode = unicode };
266 atomic_notifier_call_chain(&vt_notifier_list, VT_WRITE, &param);
267 }
268
269 static void notify_update(struct vc_data *vc)
270 {
271 struct vt_notifier_param param = { .vc = vc };
272 atomic_notifier_call_chain(&vt_notifier_list, VT_UPDATE, &param);
273 }
274 /*
275 * Low-Level Functions
276 */
277
278 #define IS_FG(vc) ((vc)->vc_num == fg_console)
279
280 #ifdef VT_BUF_VRAM_ONLY
281 #define DO_UPDATE(vc) 0
282 #else
283 #define DO_UPDATE(vc) (CON_IS_VISIBLE(vc) && !console_blanked)
284 #endif
285
286 static inline unsigned short *screenpos(struct vc_data *vc, int offset, int viewed)
287 {
288 unsigned short *p;
289
290 if (!viewed)
291 p = (unsigned short *)(vc->vc_origin + offset);
292 else if (!vc->vc_sw->con_screen_pos)
293 p = (unsigned short *)(vc->vc_visible_origin + offset);
294 else
295 p = vc->vc_sw->con_screen_pos(vc, offset);
296 return p;
297 }
298
299 /* Called from the keyboard irq path.. */
300 static inline void scrolldelta(int lines)
301 {
302 /* FIXME */
303 /* scrolldelta needs some kind of consistency lock, but the BKL was
304 and still is not protecting versus the scheduled back end */
305 scrollback_delta += lines;
306 schedule_console_callback();
307 }
308
309 void schedule_console_callback(void)
310 {
311 schedule_work(&console_work);
312 }
313
314 static void scrup(struct vc_data *vc, unsigned int t, unsigned int b, int nr)
315 {
316 unsigned short *d, *s;
317
318 if (t+nr >= b)
319 nr = b - t - 1;
320 if (b > vc->vc_rows || t >= b || nr < 1)
321 return;
322 if (CON_IS_VISIBLE(vc) && vc->vc_sw->con_scroll(vc, t, b, SM_UP, nr))
323 return;
324 d = (unsigned short *)(vc->vc_origin + vc->vc_size_row * t);
325 s = (unsigned short *)(vc->vc_origin + vc->vc_size_row * (t + nr));
326 scr_memmovew(d, s, (b - t - nr) * vc->vc_size_row);
327 scr_memsetw(d + (b - t - nr) * vc->vc_cols, vc->vc_video_erase_char,
328 vc->vc_size_row * nr);
329 }
330
331 static void scrdown(struct vc_data *vc, unsigned int t, unsigned int b, int nr)
332 {
333 unsigned short *s;
334 unsigned int step;
335
336 if (t+nr >= b)
337 nr = b - t - 1;
338 if (b > vc->vc_rows || t >= b || nr < 1)
339 return;
340 if (CON_IS_VISIBLE(vc) && vc->vc_sw->con_scroll(vc, t, b, SM_DOWN, nr))
341 return;
342 s = (unsigned short *)(vc->vc_origin + vc->vc_size_row * t);
343 step = vc->vc_cols * nr;
344 scr_memmovew(s + step, s, (b - t - nr) * vc->vc_size_row);
345 scr_memsetw(s, vc->vc_video_erase_char, 2 * step);
346 }
347
348 static void do_update_region(struct vc_data *vc, unsigned long start, int count)
349 {
350 #ifndef VT_BUF_VRAM_ONLY
351 unsigned int xx, yy, offset;
352 u16 *p;
353
354 p = (u16 *) start;
355 if (!vc->vc_sw->con_getxy) {
356 offset = (start - vc->vc_origin) / 2;
357 xx = offset % vc->vc_cols;
358 yy = offset / vc->vc_cols;
359 } else {
360 int nxx, nyy;
361 start = vc->vc_sw->con_getxy(vc, start, &nxx, &nyy);
362 xx = nxx; yy = nyy;
363 }
364 for(;;) {
365 u16 attrib = scr_readw(p) & 0xff00;
366 int startx = xx;
367 u16 *q = p;
368 while (xx < vc->vc_cols && count) {
369 if (attrib != (scr_readw(p) & 0xff00)) {
370 if (p > q)
371 vc->vc_sw->con_putcs(vc, q, p-q, yy, startx);
372 startx = xx;
373 q = p;
374 attrib = scr_readw(p) & 0xff00;
375 }
376 p++;
377 xx++;
378 count--;
379 }
380 if (p > q)
381 vc->vc_sw->con_putcs(vc, q, p-q, yy, startx);
382 if (!count)
383 break;
384 xx = 0;
385 yy++;
386 if (vc->vc_sw->con_getxy) {
387 p = (u16 *)start;
388 start = vc->vc_sw->con_getxy(vc, start, NULL, NULL);
389 }
390 }
391 #endif
392 }
393
394 void update_region(struct vc_data *vc, unsigned long start, int count)
395 {
396 WARN_CONSOLE_UNLOCKED();
397
398 if (DO_UPDATE(vc)) {
399 hide_cursor(vc);
400 do_update_region(vc, start, count);
401 set_cursor(vc);
402 }
403 }
404
405 /* Structure of attributes is hardware-dependent */
406
407 static u8 build_attr(struct vc_data *vc, u8 _color, u8 _intensity, u8 _blink,
408 u8 _underline, u8 _reverse, u8 _italic)
409 {
410 if (vc->vc_sw->con_build_attr)
411 return vc->vc_sw->con_build_attr(vc, _color, _intensity,
412 _blink, _underline, _reverse, _italic);
413
414 #ifndef VT_BUF_VRAM_ONLY
415 /*
416 * ++roman: I completely changed the attribute format for monochrome
417 * mode (!can_do_color). The formerly used MDA (monochrome display
418 * adapter) format didn't allow the combination of certain effects.
419 * Now the attribute is just a bit vector:
420 * Bit 0..1: intensity (0..2)
421 * Bit 2 : underline
422 * Bit 3 : reverse
423 * Bit 7 : blink
424 */
425 {
426 u8 a = _color;
427 if (!vc->vc_can_do_color)
428 return _intensity |
429 (_italic ? 2 : 0) |
430 (_underline ? 4 : 0) |
431 (_reverse ? 8 : 0) |
432 (_blink ? 0x80 : 0);
433 if (_italic)
434 a = (a & 0xF0) | vc->vc_itcolor;
435 else if (_underline)
436 a = (a & 0xf0) | vc->vc_ulcolor;
437 else if (_intensity == 0)
438 a = (a & 0xf0) | vc->vc_ulcolor;
439 if (_reverse)
440 a = ((a) & 0x88) | ((((a) >> 4) | ((a) << 4)) & 0x77);
441 if (_blink)
442 a ^= 0x80;
443 if (_intensity == 2)
444 a ^= 0x08;
445 if (vc->vc_hi_font_mask == 0x100)
446 a <<= 1;
447 return a;
448 }
449 #else
450 return 0;
451 #endif
452 }
453
454 static void update_attr(struct vc_data *vc)
455 {
456 vc->vc_attr = build_attr(vc, vc->vc_color, vc->vc_intensity,
457 vc->vc_blink, vc->vc_underline,
458 vc->vc_reverse ^ vc->vc_decscnm, vc->vc_italic);
459 vc->vc_video_erase_char = (build_attr(vc, vc->vc_color, 1, vc->vc_blink, 0, vc->vc_decscnm, 0) << 8) | ' ';
460 }
461
462 /* Note: inverting the screen twice should revert to the original state */
463 void invert_screen(struct vc_data *vc, int offset, int count, int viewed)
464 {
465 unsigned short *p;
466
467 WARN_CONSOLE_UNLOCKED();
468
469 count /= 2;
470 p = screenpos(vc, offset, viewed);
471 if (vc->vc_sw->con_invert_region)
472 vc->vc_sw->con_invert_region(vc, p, count);
473 #ifndef VT_BUF_VRAM_ONLY
474 else {
475 u16 *q = p;
476 int cnt = count;
477 u16 a;
478
479 if (!vc->vc_can_do_color) {
480 while (cnt--) {
481 a = scr_readw(q);
482 a ^= 0x0800;
483 scr_writew(a, q);
484 q++;
485 }
486 } else if (vc->vc_hi_font_mask == 0x100) {
487 while (cnt--) {
488 a = scr_readw(q);
489 a = ((a) & 0x11ff) | (((a) & 0xe000) >> 4) | (((a) & 0x0e00) << 4);
490 scr_writew(a, q);
491 q++;
492 }
493 } else {
494 while (cnt--) {
495 a = scr_readw(q);
496 a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) | (((a) & 0x0700) << 4);
497 scr_writew(a, q);
498 q++;
499 }
500 }
501 }
502 #endif
503 if (DO_UPDATE(vc))
504 do_update_region(vc, (unsigned long) p, count);
505 }
506
507 /* used by selection: complement pointer position */
508 void complement_pos(struct vc_data *vc, int offset)
509 {
510 static int old_offset = -1;
511 static unsigned short old;
512 static unsigned short oldx, oldy;
513
514 WARN_CONSOLE_UNLOCKED();
515
516 if (old_offset != -1 && old_offset >= 0 &&
517 old_offset < vc->vc_screenbuf_size) {
518 scr_writew(old, screenpos(vc, old_offset, 1));
519 if (DO_UPDATE(vc))
520 vc->vc_sw->con_putc(vc, old, oldy, oldx);
521 }
522
523 old_offset = offset;
524
525 if (offset != -1 && offset >= 0 &&
526 offset < vc->vc_screenbuf_size) {
527 unsigned short new;
528 unsigned short *p;
529 p = screenpos(vc, offset, 1);
530 old = scr_readw(p);
531 new = old ^ vc->vc_complement_mask;
532 scr_writew(new, p);
533 if (DO_UPDATE(vc)) {
534 oldx = (offset >> 1) % vc->vc_cols;
535 oldy = (offset >> 1) / vc->vc_cols;
536 vc->vc_sw->con_putc(vc, new, oldy, oldx);
537 }
538 }
539
540 }
541
542 static void insert_char(struct vc_data *vc, unsigned int nr)
543 {
544 unsigned short *p, *q = (unsigned short *)vc->vc_pos;
545
546 p = q + vc->vc_cols - nr - vc->vc_x;
547 while (--p >= q)
548 scr_writew(scr_readw(p), p + nr);
549 scr_memsetw(q, vc->vc_video_erase_char, nr * 2);
550 vc->vc_need_wrap = 0;
551 if (DO_UPDATE(vc)) {
552 unsigned short oldattr = vc->vc_attr;
553 vc->vc_sw->con_bmove(vc, vc->vc_y, vc->vc_x, vc->vc_y, vc->vc_x + nr, 1,
554 vc->vc_cols - vc->vc_x - nr);
555 vc->vc_attr = vc->vc_video_erase_char >> 8;
556 while (nr--)
557 vc->vc_sw->con_putc(vc, vc->vc_video_erase_char, vc->vc_y, vc->vc_x + nr);
558 vc->vc_attr = oldattr;
559 }
560 }
561
562 static void delete_char(struct vc_data *vc, unsigned int nr)
563 {
564 unsigned int i = vc->vc_x;
565 unsigned short *p = (unsigned short *)vc->vc_pos;
566
567 while (++i <= vc->vc_cols - nr) {
568 scr_writew(scr_readw(p+nr), p);
569 p++;
570 }
571 scr_memsetw(p, vc->vc_video_erase_char, nr * 2);
572 vc->vc_need_wrap = 0;
573 if (DO_UPDATE(vc)) {
574 unsigned short oldattr = vc->vc_attr;
575 vc->vc_sw->con_bmove(vc, vc->vc_y, vc->vc_x + nr, vc->vc_y, vc->vc_x, 1,
576 vc->vc_cols - vc->vc_x - nr);
577 vc->vc_attr = vc->vc_video_erase_char >> 8;
578 while (nr--)
579 vc->vc_sw->con_putc(vc, vc->vc_video_erase_char, vc->vc_y,
580 vc->vc_cols - 1 - nr);
581 vc->vc_attr = oldattr;
582 }
583 }
584
585 static int softcursor_original;
586
587 static void add_softcursor(struct vc_data *vc)
588 {
589 int i = scr_readw((u16 *) vc->vc_pos);
590 u32 type = vc->vc_cursor_type;
591
592 if (! (type & 0x10)) return;
593 if (softcursor_original != -1) return;
594 softcursor_original = i;
595 i |= ((type >> 8) & 0xff00 );
596 i ^= ((type) & 0xff00 );
597 if ((type & 0x20) && ((softcursor_original & 0x7000) == (i & 0x7000))) i ^= 0x7000;
598 if ((type & 0x40) && ((i & 0x700) == ((i & 0x7000) >> 4))) i ^= 0x0700;
599 scr_writew(i, (u16 *) vc->vc_pos);
600 if (DO_UPDATE(vc))
601 vc->vc_sw->con_putc(vc, i, vc->vc_y, vc->vc_x);
602 }
603
604 static void hide_softcursor(struct vc_data *vc)
605 {
606 if (softcursor_original != -1) {
607 scr_writew(softcursor_original, (u16 *)vc->vc_pos);
608 if (DO_UPDATE(vc))
609 vc->vc_sw->con_putc(vc, softcursor_original,
610 vc->vc_y, vc->vc_x);
611 softcursor_original = -1;
612 }
613 }
614
615 static void hide_cursor(struct vc_data *vc)
616 {
617 if (vc == sel_cons)
618 clear_selection();
619 vc->vc_sw->con_cursor(vc, CM_ERASE);
620 hide_softcursor(vc);
621 }
622
623 static void set_cursor(struct vc_data *vc)
624 {
625 if (!IS_FG(vc) || console_blanked ||
626 vc->vc_mode == KD_GRAPHICS)
627 return;
628 if (vc->vc_deccm) {
629 if (vc == sel_cons)
630 clear_selection();
631 add_softcursor(vc);
632 if ((vc->vc_cursor_type & 0x0f) != 1)
633 vc->vc_sw->con_cursor(vc, CM_DRAW);
634 } else
635 hide_cursor(vc);
636 }
637
638 static void set_origin(struct vc_data *vc)
639 {
640 WARN_CONSOLE_UNLOCKED();
641
642 if (!CON_IS_VISIBLE(vc) ||
643 !vc->vc_sw->con_set_origin ||
644 !vc->vc_sw->con_set_origin(vc))
645 vc->vc_origin = (unsigned long)vc->vc_screenbuf;
646 vc->vc_visible_origin = vc->vc_origin;
647 vc->vc_scr_end = vc->vc_origin + vc->vc_screenbuf_size;
648 vc->vc_pos = vc->vc_origin + vc->vc_size_row * vc->vc_y + 2 * vc->vc_x;
649 }
650
651 static inline void save_screen(struct vc_data *vc)
652 {
653 WARN_CONSOLE_UNLOCKED();
654
655 if (vc->vc_sw->con_save_screen)
656 vc->vc_sw->con_save_screen(vc);
657 }
658
659 /*
660 * Redrawing of screen
661 */
662
663 static void clear_buffer_attributes(struct vc_data *vc)
664 {
665 unsigned short *p = (unsigned short *)vc->vc_origin;
666 int count = vc->vc_screenbuf_size / 2;
667 int mask = vc->vc_hi_font_mask | 0xff;
668
669 for (; count > 0; count--, p++) {
670 scr_writew((scr_readw(p)&mask) | (vc->vc_video_erase_char & ~mask), p);
671 }
672 }
673
674 void redraw_screen(struct vc_data *vc, int is_switch)
675 {
676 int redraw = 0;
677
678 WARN_CONSOLE_UNLOCKED();
679
680 if (!vc) {
681 /* strange ... */
682 /* printk("redraw_screen: tty %d not allocated ??\n", new_console+1); */
683 return;
684 }
685
686 if (is_switch) {
687 struct vc_data *old_vc = vc_cons[fg_console].d;
688 if (old_vc == vc)
689 return;
690 if (!CON_IS_VISIBLE(vc))
691 redraw = 1;
692 *vc->vc_display_fg = vc;
693 fg_console = vc->vc_num;
694 hide_cursor(old_vc);
695 if (!CON_IS_VISIBLE(old_vc)) {
696 save_screen(old_vc);
697 set_origin(old_vc);
698 }
699 if (tty0dev)
700 sysfs_notify(&tty0dev->kobj, NULL, "active");
701 } else {
702 hide_cursor(vc);
703 redraw = 1;
704 }
705
706 if (redraw) {
707 int update;
708 int old_was_color = vc->vc_can_do_color;
709
710 set_origin(vc);
711 update = vc->vc_sw->con_switch(vc);
712 set_palette(vc);
713 /*
714 * If console changed from mono<->color, the best we can do
715 * is to clear the buffer attributes. As it currently stands,
716 * rebuilding new attributes from the old buffer is not doable
717 * without overly complex code.
718 */
719 if (old_was_color != vc->vc_can_do_color) {
720 update_attr(vc);
721 clear_buffer_attributes(vc);
722 }
723
724 /* Forcibly update if we're panicing */
725 if ((update && vc->vc_mode != KD_GRAPHICS) ||
726 vt_force_oops_output(vc))
727 do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2);
728 }
729 set_cursor(vc);
730 if (is_switch) {
731 set_leds();
732 compute_shiftstate();
733 notify_update(vc);
734 }
735 }
736
737 /*
738 * Allocation, freeing and resizing of VTs.
739 */
740
741 int vc_cons_allocated(unsigned int i)
742 {
743 return (i < MAX_NR_CONSOLES && vc_cons[i].d);
744 }
745
746 static void visual_init(struct vc_data *vc, int num, int init)
747 {
748 /* ++Geert: vc->vc_sw->con_init determines console size */
749 if (vc->vc_sw)
750 module_put(vc->vc_sw->owner);
751 vc->vc_sw = conswitchp;
752 #ifndef VT_SINGLE_DRIVER
753 if (con_driver_map[num])
754 vc->vc_sw = con_driver_map[num];
755 #endif
756 __module_get(vc->vc_sw->owner);
757 vc->vc_num = num;
758 vc->vc_display_fg = &master_display_fg;
759 vc->vc_uni_pagedir_loc = &vc->vc_uni_pagedir;
760 vc->vc_uni_pagedir = 0;
761 vc->vc_hi_font_mask = 0;
762 vc->vc_complement_mask = 0;
763 vc->vc_can_do_color = 0;
764 vc->vc_panic_force_write = false;
765 vc->vc_sw->con_init(vc, init);
766 if (!vc->vc_complement_mask)
767 vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
768 vc->vc_s_complement_mask = vc->vc_complement_mask;
769 vc->vc_size_row = vc->vc_cols << 1;
770 vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row;
771 }
772
773 int vc_allocate(unsigned int currcons) /* return 0 on success */
774 {
775 WARN_CONSOLE_UNLOCKED();
776
777 if (currcons >= MAX_NR_CONSOLES)
778 return -ENXIO;
779 if (!vc_cons[currcons].d) {
780 struct vc_data *vc;
781 struct vt_notifier_param param;
782
783 /* prevent users from taking too much memory */
784 if (currcons >= MAX_NR_USER_CONSOLES && !capable(CAP_SYS_RESOURCE))
785 return -EPERM;
786
787 /* due to the granularity of kmalloc, we waste some memory here */
788 /* the alloc is done in two steps, to optimize the common situation
789 of a 25x80 console (structsize=216, screenbuf_size=4000) */
790 /* although the numbers above are not valid since long ago, the
791 point is still up-to-date and the comment still has its value
792 even if only as a historical artifact. --mj, July 1998 */
793 param.vc = vc = kzalloc(sizeof(struct vc_data), GFP_KERNEL);
794 if (!vc)
795 return -ENOMEM;
796 vc_cons[currcons].d = vc;
797 tty_port_init(&vc->port);
798 INIT_WORK(&vc_cons[currcons].SAK_work, vc_SAK);
799 visual_init(vc, currcons, 1);
800 if (!*vc->vc_uni_pagedir_loc)
801 con_set_default_unimap(vc);
802 vc->vc_screenbuf = kmalloc(vc->vc_screenbuf_size, GFP_KERNEL);
803 if (!vc->vc_screenbuf) {
804 kfree(vc);
805 vc_cons[currcons].d = NULL;
806 return -ENOMEM;
807 }
808
809 /* If no drivers have overridden us and the user didn't pass a
810 boot option, default to displaying the cursor */
811 if (global_cursor_default == -1)
812 global_cursor_default = 1;
813
814 vc_init(vc, vc->vc_rows, vc->vc_cols, 1);
815 vcs_make_sysfs(currcons);
816 atomic_notifier_call_chain(&vt_notifier_list, VT_ALLOCATE, &param);
817 }
818 return 0;
819 }
820
821 static inline int resize_screen(struct vc_data *vc, int width, int height,
822 int user)
823 {
824 /* Resizes the resolution of the display adapater */
825 int err = 0;
826
827 if (vc->vc_mode != KD_GRAPHICS && vc->vc_sw->con_resize)
828 err = vc->vc_sw->con_resize(vc, width, height, user);
829
830 return err;
831 }
832
833 /*
834 * Change # of rows and columns (0 means unchanged/the size of fg_console)
835 * [this is to be used together with some user program
836 * like resize that changes the hardware videomode]
837 */
838 #define VC_RESIZE_MAXCOL (32767)
839 #define VC_RESIZE_MAXROW (32767)
840
841 /**
842 * vc_do_resize - resizing method for the tty
843 * @tty: tty being resized
844 * @real_tty: real tty (different to tty if a pty/tty pair)
845 * @vc: virtual console private data
846 * @cols: columns
847 * @lines: lines
848 *
849 * Resize a virtual console, clipping according to the actual constraints.
850 * If the caller passes a tty structure then update the termios winsize
851 * information and perform any necessary signal handling.
852 *
853 * Caller must hold the console semaphore. Takes the termios mutex and
854 * ctrl_lock of the tty IFF a tty is passed.
855 */
856
857 static int vc_do_resize(struct tty_struct *tty, struct vc_data *vc,
858 unsigned int cols, unsigned int lines)
859 {
860 unsigned long old_origin, new_origin, new_scr_end, rlth, rrem, err = 0;
861 unsigned long end;
862 unsigned int old_cols, old_rows, old_row_size, old_screen_size;
863 unsigned int new_cols, new_rows, new_row_size, new_screen_size;
864 unsigned int user;
865 unsigned short *newscreen;
866
867 WARN_CONSOLE_UNLOCKED();
868
869 if (!vc)
870 return -ENXIO;
871
872 user = vc->vc_resize_user;
873 vc->vc_resize_user = 0;
874
875 if (cols > VC_RESIZE_MAXCOL || lines > VC_RESIZE_MAXROW)
876 return -EINVAL;
877
878 new_cols = (cols ? cols : vc->vc_cols);
879 new_rows = (lines ? lines : vc->vc_rows);
880 new_row_size = new_cols << 1;
881 new_screen_size = new_row_size * new_rows;
882
883 if (new_cols == vc->vc_cols && new_rows == vc->vc_rows)
884 return 0;
885
886 newscreen = kmalloc(new_screen_size, GFP_USER);
887 if (!newscreen)
888 return -ENOMEM;
889
890 old_rows = vc->vc_rows;
891 old_cols = vc->vc_cols;
892 old_row_size = vc->vc_size_row;
893 old_screen_size = vc->vc_screenbuf_size;
894
895 err = resize_screen(vc, new_cols, new_rows, user);
896 if (err) {
897 kfree(newscreen);
898 return err;
899 }
900
901 vc->vc_rows = new_rows;
902 vc->vc_cols = new_cols;
903 vc->vc_size_row = new_row_size;
904 vc->vc_screenbuf_size = new_screen_size;
905
906 rlth = min(old_row_size, new_row_size);
907 rrem = new_row_size - rlth;
908 old_origin = vc->vc_origin;
909 new_origin = (long) newscreen;
910 new_scr_end = new_origin + new_screen_size;
911
912 if (vc->vc_y > new_rows) {
913 if (old_rows - vc->vc_y < new_rows) {
914 /*
915 * Cursor near the bottom, copy contents from the
916 * bottom of buffer
917 */
918 old_origin += (old_rows - new_rows) * old_row_size;
919 } else {
920 /*
921 * Cursor is in no man's land, copy 1/2 screenful
922 * from the top and bottom of cursor position
923 */
924 old_origin += (vc->vc_y - new_rows/2) * old_row_size;
925 }
926 }
927
928 end = old_origin + old_row_size * min(old_rows, new_rows);
929
930 update_attr(vc);
931
932 while (old_origin < end) {
933 scr_memcpyw((unsigned short *) new_origin,
934 (unsigned short *) old_origin, rlth);
935 if (rrem)
936 scr_memsetw((void *)(new_origin + rlth),
937 vc->vc_video_erase_char, rrem);
938 old_origin += old_row_size;
939 new_origin += new_row_size;
940 }
941 if (new_scr_end > new_origin)
942 scr_memsetw((void *)new_origin, vc->vc_video_erase_char,
943 new_scr_end - new_origin);
944 kfree(vc->vc_screenbuf);
945 vc->vc_screenbuf = newscreen;
946 vc->vc_screenbuf_size = new_screen_size;
947 set_origin(vc);
948
949 /* do part of a reset_terminal() */
950 vc->vc_top = 0;
951 vc->vc_bottom = vc->vc_rows;
952 gotoxy(vc, vc->vc_x, vc->vc_y);
953 save_cur(vc);
954
955 if (tty) {
956 /* Rewrite the requested winsize data with the actual
957 resulting sizes */
958 struct winsize ws;
959 memset(&ws, 0, sizeof(ws));
960 ws.ws_row = vc->vc_rows;
961 ws.ws_col = vc->vc_cols;
962 ws.ws_ypixel = vc->vc_scan_lines;
963 tty_do_resize(tty, &ws);
964 }
965
966 if (CON_IS_VISIBLE(vc))
967 update_screen(vc);
968 vt_event_post(VT_EVENT_RESIZE, vc->vc_num, vc->vc_num);
969 return err;
970 }
971
972 /**
973 * vc_resize - resize a VT
974 * @vc: virtual console
975 * @cols: columns
976 * @rows: rows
977 *
978 * Resize a virtual console as seen from the console end of things. We
979 * use the common vc_do_resize methods to update the structures. The
980 * caller must hold the console sem to protect console internals and
981 * vc->port.tty
982 */
983
984 int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int rows)
985 {
986 return vc_do_resize(vc->port.tty, vc, cols, rows);
987 }
988
989 /**
990 * vt_resize - resize a VT
991 * @tty: tty to resize
992 * @ws: winsize attributes
993 *
994 * Resize a virtual terminal. This is called by the tty layer as we
995 * register our own handler for resizing. The mutual helper does all
996 * the actual work.
997 *
998 * Takes the console sem and the called methods then take the tty
999 * termios_mutex and the tty ctrl_lock in that order.
1000 */
1001 static int vt_resize(struct tty_struct *tty, struct winsize *ws)
1002 {
1003 struct vc_data *vc = tty->driver_data;
1004 int ret;
1005
1006 console_lock();
1007 ret = vc_do_resize(tty, vc, ws->ws_col, ws->ws_row);
1008 console_unlock();
1009 return ret;
1010 }
1011
1012 void vc_deallocate(unsigned int currcons)
1013 {
1014 WARN_CONSOLE_UNLOCKED();
1015
1016 if (vc_cons_allocated(currcons)) {
1017 struct vc_data *vc = vc_cons[currcons].d;
1018 struct vt_notifier_param param = { .vc = vc };
1019
1020 atomic_notifier_call_chain(&vt_notifier_list, VT_DEALLOCATE, &param);
1021 vcs_remove_sysfs(currcons);
1022 vc->vc_sw->con_deinit(vc);
1023 put_pid(vc->vt_pid);
1024 module_put(vc->vc_sw->owner);
1025 kfree(vc->vc_screenbuf);
1026 if (currcons >= MIN_NR_CONSOLES)
1027 kfree(vc);
1028 vc_cons[currcons].d = NULL;
1029 }
1030 }
1031
1032 /*
1033 * VT102 emulator
1034 */
1035
1036 #define set_kbd(vc, x) set_vc_kbd_mode(kbd_table + (vc)->vc_num, (x))
1037 #define clr_kbd(vc, x) clr_vc_kbd_mode(kbd_table + (vc)->vc_num, (x))
1038 #define is_kbd(vc, x) vc_kbd_mode(kbd_table + (vc)->vc_num, (x))
1039
1040 #define decarm VC_REPEAT
1041 #define decckm VC_CKMODE
1042 #define kbdapplic VC_APPLIC
1043 #define lnm VC_CRLF
1044
1045 /*
1046 * this is what the terminal answers to a ESC-Z or csi0c query.
1047 */
1048 #define VT100ID "\033[?1;2c"
1049 #define VT102ID "\033[?6c"
1050
1051 unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,
1052 8,12,10,14, 9,13,11,15 };
1053
1054 /* the default colour table, for VGA+ colour systems */
1055 int default_red[] = {0x00,0xaa,0x00,0xaa,0x00,0xaa,0x00,0xaa,
1056 0x55,0xff,0x55,0xff,0x55,0xff,0x55,0xff};
1057 int default_grn[] = {0x00,0x00,0xaa,0x55,0x00,0x00,0xaa,0xaa,
1058 0x55,0x55,0xff,0xff,0x55,0x55,0xff,0xff};
1059 int default_blu[] = {0x00,0x00,0x00,0x00,0xaa,0xaa,0xaa,0xaa,
1060 0x55,0x55,0x55,0x55,0xff,0xff,0xff,0xff};
1061
1062 module_param_array(default_red, int, NULL, S_IRUGO | S_IWUSR);
1063 module_param_array(default_grn, int, NULL, S_IRUGO | S_IWUSR);
1064 module_param_array(default_blu, int, NULL, S_IRUGO | S_IWUSR);
1065
1066 /*
1067 * gotoxy() must verify all boundaries, because the arguments
1068 * might also be negative. If the given position is out of
1069 * bounds, the cursor is placed at the nearest margin.
1070 */
1071 static void gotoxy(struct vc_data *vc, int new_x, int new_y)
1072 {
1073 int min_y, max_y;
1074
1075 if (new_x < 0)
1076 vc->vc_x = 0;
1077 else {
1078 if (new_x >= vc->vc_cols)
1079 vc->vc_x = vc->vc_cols - 1;
1080 else
1081 vc->vc_x = new_x;
1082 }
1083
1084 if (vc->vc_decom) {
1085 min_y = vc->vc_top;
1086 max_y = vc->vc_bottom;
1087 } else {
1088 min_y = 0;
1089 max_y = vc->vc_rows;
1090 }
1091 if (new_y < min_y)
1092 vc->vc_y = min_y;
1093 else if (new_y >= max_y)
1094 vc->vc_y = max_y - 1;
1095 else
1096 vc->vc_y = new_y;
1097 vc->vc_pos = vc->vc_origin + vc->vc_y * vc->vc_size_row + (vc->vc_x<<1);
1098 vc->vc_need_wrap = 0;
1099 }
1100
1101 /* for absolute user moves, when decom is set */
1102 static void gotoxay(struct vc_data *vc, int new_x, int new_y)
1103 {
1104 gotoxy(vc, new_x, vc->vc_decom ? (vc->vc_top + new_y) : new_y);
1105 }
1106
1107 void scrollback(struct vc_data *vc, int lines)
1108 {
1109 if (!lines)
1110 lines = vc->vc_rows / 2;
1111 scrolldelta(-lines);
1112 }
1113
1114 void scrollfront(struct vc_data *vc, int lines)
1115 {
1116 if (!lines)
1117 lines = vc->vc_rows / 2;
1118 scrolldelta(lines);
1119 }
1120
1121 static void lf(struct vc_data *vc)
1122 {
1123 /* don't scroll if above bottom of scrolling region, or
1124 * if below scrolling region
1125 */
1126 if (vc->vc_y + 1 == vc->vc_bottom)
1127 scrup(vc, vc->vc_top, vc->vc_bottom, 1);
1128 else if (vc->vc_y < vc->vc_rows - 1) {
1129 vc->vc_y++;
1130 vc->vc_pos += vc->vc_size_row;
1131 }
1132 vc->vc_need_wrap = 0;
1133 notify_write(vc, '\n');
1134 }
1135
1136 static void ri(struct vc_data *vc)
1137 {
1138 /* don't scroll if below top of scrolling region, or
1139 * if above scrolling region
1140 */
1141 if (vc->vc_y == vc->vc_top)
1142 scrdown(vc, vc->vc_top, vc->vc_bottom, 1);
1143 else if (vc->vc_y > 0) {
1144 vc->vc_y--;
1145 vc->vc_pos -= vc->vc_size_row;
1146 }
1147 vc->vc_need_wrap = 0;
1148 }
1149
1150 static inline void cr(struct vc_data *vc)
1151 {
1152 vc->vc_pos -= vc->vc_x << 1;
1153 vc->vc_need_wrap = vc->vc_x = 0;
1154 notify_write(vc, '\r');
1155 }
1156
1157 static inline void bs(struct vc_data *vc)
1158 {
1159 if (vc->vc_x) {
1160 vc->vc_pos -= 2;
1161 vc->vc_x--;
1162 vc->vc_need_wrap = 0;
1163 notify_write(vc, '\b');
1164 }
1165 }
1166
1167 static inline void del(struct vc_data *vc)
1168 {
1169 /* ignored */
1170 }
1171
1172 static void csi_J(struct vc_data *vc, int vpar)
1173 {
1174 unsigned int count;
1175 unsigned short * start;
1176
1177 switch (vpar) {
1178 case 0: /* erase from cursor to end of display */
1179 count = (vc->vc_scr_end - vc->vc_pos) >> 1;
1180 start = (unsigned short *)vc->vc_pos;
1181 if (DO_UPDATE(vc)) {
1182 /* do in two stages */
1183 vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1,
1184 vc->vc_cols - vc->vc_x);
1185 vc->vc_sw->con_clear(vc, vc->vc_y + 1, 0,
1186 vc->vc_rows - vc->vc_y - 1,
1187 vc->vc_cols);
1188 }
1189 break;
1190 case 1: /* erase from start to cursor */
1191 count = ((vc->vc_pos - vc->vc_origin) >> 1) + 1;
1192 start = (unsigned short *)vc->vc_origin;
1193 if (DO_UPDATE(vc)) {
1194 /* do in two stages */
1195 vc->vc_sw->con_clear(vc, 0, 0, vc->vc_y,
1196 vc->vc_cols);
1197 vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
1198 vc->vc_x + 1);
1199 }
1200 break;
1201 case 2: /* erase whole display */
1202 count = vc->vc_cols * vc->vc_rows;
1203 start = (unsigned short *)vc->vc_origin;
1204 if (DO_UPDATE(vc))
1205 vc->vc_sw->con_clear(vc, 0, 0,
1206 vc->vc_rows,
1207 vc->vc_cols);
1208 break;
1209 default:
1210 return;
1211 }
1212 scr_memsetw(start, vc->vc_video_erase_char, 2 * count);
1213 vc->vc_need_wrap = 0;
1214 }
1215
1216 static void csi_K(struct vc_data *vc, int vpar)
1217 {
1218 unsigned int count;
1219 unsigned short * start;
1220
1221 switch (vpar) {
1222 case 0: /* erase from cursor to end of line */
1223 count = vc->vc_cols - vc->vc_x;
1224 start = (unsigned short *)vc->vc_pos;
1225 if (DO_UPDATE(vc))
1226 vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1,
1227 vc->vc_cols - vc->vc_x);
1228 break;
1229 case 1: /* erase from start of line to cursor */
1230 start = (unsigned short *)(vc->vc_pos - (vc->vc_x << 1));
1231 count = vc->vc_x + 1;
1232 if (DO_UPDATE(vc))
1233 vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
1234 vc->vc_x + 1);
1235 break;
1236 case 2: /* erase whole line */
1237 start = (unsigned short *)(vc->vc_pos - (vc->vc_x << 1));
1238 count = vc->vc_cols;
1239 if (DO_UPDATE(vc))
1240 vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
1241 vc->vc_cols);
1242 break;
1243 default:
1244 return;
1245 }
1246 scr_memsetw(start, vc->vc_video_erase_char, 2 * count);
1247 vc->vc_need_wrap = 0;
1248 }
1249
1250 static void csi_X(struct vc_data *vc, int vpar) /* erase the following vpar positions */
1251 { /* not vt100? */
1252 int count;
1253
1254 if (!vpar)
1255 vpar++;
1256 count = (vpar > vc->vc_cols - vc->vc_x) ? (vc->vc_cols - vc->vc_x) : vpar;
1257
1258 scr_memsetw((unsigned short *)vc->vc_pos, vc->vc_video_erase_char, 2 * count);
1259 if (DO_UPDATE(vc))
1260 vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1, count);
1261 vc->vc_need_wrap = 0;
1262 }
1263
1264 static void default_attr(struct vc_data *vc)
1265 {
1266 vc->vc_intensity = 1;
1267 vc->vc_italic = 0;
1268 vc->vc_underline = 0;
1269 vc->vc_reverse = 0;
1270 vc->vc_blink = 0;
1271 vc->vc_color = vc->vc_def_color;
1272 }
1273
1274 /* console_lock is held */
1275 static void csi_m(struct vc_data *vc)
1276 {
1277 int i;
1278
1279 for (i = 0; i <= vc->vc_npar; i++)
1280 switch (vc->vc_par[i]) {
1281 case 0: /* all attributes off */
1282 default_attr(vc);
1283 break;
1284 case 1:
1285 vc->vc_intensity = 2;
1286 break;
1287 case 2:
1288 vc->vc_intensity = 0;
1289 break;
1290 case 3:
1291 vc->vc_italic = 1;
1292 break;
1293 case 4:
1294 vc->vc_underline = 1;
1295 break;
1296 case 5:
1297 vc->vc_blink = 1;
1298 break;
1299 case 7:
1300 vc->vc_reverse = 1;
1301 break;
1302 case 10: /* ANSI X3.64-1979 (SCO-ish?)
1303 * Select primary font, don't display
1304 * control chars if defined, don't set
1305 * bit 8 on output.
1306 */
1307 vc->vc_translate = set_translate(vc->vc_charset == 0
1308 ? vc->vc_G0_charset
1309 : vc->vc_G1_charset, vc);
1310 vc->vc_disp_ctrl = 0;
1311 vc->vc_toggle_meta = 0;
1312 break;
1313 case 11: /* ANSI X3.64-1979 (SCO-ish?)
1314 * Select first alternate font, lets
1315 * chars < 32 be displayed as ROM chars.
1316 */
1317 vc->vc_translate = set_translate(IBMPC_MAP, vc);
1318 vc->vc_disp_ctrl = 1;
1319 vc->vc_toggle_meta = 0;
1320 break;
1321 case 12: /* ANSI X3.64-1979 (SCO-ish?)
1322 * Select second alternate font, toggle
1323 * high bit before displaying as ROM char.
1324 */
1325 vc->vc_translate = set_translate(IBMPC_MAP, vc);
1326 vc->vc_disp_ctrl = 1;
1327 vc->vc_toggle_meta = 1;
1328 break;
1329 case 21:
1330 case 22:
1331 vc->vc_intensity = 1;
1332 break;
1333 case 23:
1334 vc->vc_italic = 0;
1335 break;
1336 case 24:
1337 vc->vc_underline = 0;
1338 break;
1339 case 25:
1340 vc->vc_blink = 0;
1341 break;
1342 case 27:
1343 vc->vc_reverse = 0;
1344 break;
1345 case 38: /* ANSI X3.64-1979 (SCO-ish?)
1346 * Enables underscore, white foreground
1347 * with white underscore (Linux - use
1348 * default foreground).
1349 */
1350 vc->vc_color = (vc->vc_def_color & 0x0f) | (vc->vc_color & 0xf0);
1351 vc->vc_underline = 1;
1352 break;
1353 case 39: /* ANSI X3.64-1979 (SCO-ish?)
1354 * Disable underline option.
1355 * Reset colour to default? It did this
1356 * before...
1357 */
1358 vc->vc_color = (vc->vc_def_color & 0x0f) | (vc->vc_color & 0xf0);
1359 vc->vc_underline = 0;
1360 break;
1361 case 49:
1362 vc->vc_color = (vc->vc_def_color & 0xf0) | (vc->vc_color & 0x0f);
1363 break;
1364 default:
1365 if (vc->vc_par[i] >= 30 && vc->vc_par[i] <= 37)
1366 vc->vc_color = color_table[vc->vc_par[i] - 30]
1367 | (vc->vc_color & 0xf0);
1368 else if (vc->vc_par[i] >= 40 && vc->vc_par[i] <= 47)
1369 vc->vc_color = (color_table[vc->vc_par[i] - 40] << 4)
1370 | (vc->vc_color & 0x0f);
1371 break;
1372 }
1373 update_attr(vc);
1374 }
1375
1376 static void respond_string(const char *p, struct tty_struct *tty)
1377 {
1378 while (*p) {
1379 tty_insert_flip_char(tty, *p, 0);
1380 p++;
1381 }
1382 con_schedule_flip(tty);
1383 }
1384
1385 static void cursor_report(struct vc_data *vc, struct tty_struct *tty)
1386 {
1387 char buf[40];
1388
1389 sprintf(buf, "\033[%d;%dR", vc->vc_y + (vc->vc_decom ? vc->vc_top + 1 : 1), vc->vc_x + 1);
1390 respond_string(buf, tty);
1391 }
1392
1393 static inline void status_report(struct tty_struct *tty)
1394 {
1395 respond_string("\033[0n", tty); /* Terminal ok */
1396 }
1397
1398 static inline void respond_ID(struct tty_struct * tty)
1399 {
1400 respond_string(VT102ID, tty);
1401 }
1402
1403 void mouse_report(struct tty_struct *tty, int butt, int mrx, int mry)
1404 {
1405 char buf[8];
1406
1407 sprintf(buf, "\033[M%c%c%c", (char)(' ' + butt), (char)('!' + mrx),
1408 (char)('!' + mry));
1409 respond_string(buf, tty);
1410 }
1411
1412 /* invoked via ioctl(TIOCLINUX) and through set_selection */
1413 int mouse_reporting(void)
1414 {
1415 return vc_cons[fg_console].d->vc_report_mouse;
1416 }
1417
1418 /* console_lock is held */
1419 static void set_mode(struct vc_data *vc, int on_off)
1420 {
1421 int i;
1422
1423 for (i = 0; i <= vc->vc_npar; i++)
1424 if (vc->vc_ques) {
1425 switch(vc->vc_par[i]) { /* DEC private modes set/reset */
1426 case 1: /* Cursor keys send ^[Ox/^[[x */
1427 if (on_off)
1428 set_kbd(vc, decckm);
1429 else
1430 clr_kbd(vc, decckm);
1431 break;
1432 case 3: /* 80/132 mode switch unimplemented */
1433 vc->vc_deccolm = on_off;
1434 #if 0
1435 vc_resize(deccolm ? 132 : 80, vc->vc_rows);
1436 /* this alone does not suffice; some user mode
1437 utility has to change the hardware regs */
1438 #endif
1439 break;
1440 case 5: /* Inverted screen on/off */
1441 if (vc->vc_decscnm != on_off) {
1442 vc->vc_decscnm = on_off;
1443 invert_screen(vc, 0, vc->vc_screenbuf_size, 0);
1444 update_attr(vc);
1445 }
1446 break;
1447 case 6: /* Origin relative/absolute */
1448 vc->vc_decom = on_off;
1449 gotoxay(vc, 0, 0);
1450 break;
1451 case 7: /* Autowrap on/off */
1452 vc->vc_decawm = on_off;
1453 break;
1454 case 8: /* Autorepeat on/off */
1455 if (on_off)
1456 set_kbd(vc, decarm);
1457 else
1458 clr_kbd(vc, decarm);
1459 break;
1460 case 9:
1461 vc->vc_report_mouse = on_off ? 1 : 0;
1462 break;
1463 case 25: /* Cursor on/off */
1464 vc->vc_deccm = on_off;
1465 break;
1466 case 1000:
1467 vc->vc_report_mouse = on_off ? 2 : 0;
1468 break;
1469 }
1470 } else {
1471 switch(vc->vc_par[i]) { /* ANSI modes set/reset */
1472 case 3: /* Monitor (display ctrls) */
1473 vc->vc_disp_ctrl = on_off;
1474 break;
1475 case 4: /* Insert Mode on/off */
1476 vc->vc_decim = on_off;
1477 break;
1478 case 20: /* Lf, Enter == CrLf/Lf */
1479 if (on_off)
1480 set_kbd(vc, lnm);
1481 else
1482 clr_kbd(vc, lnm);
1483 break;
1484 }
1485 }
1486 }
1487
1488 /* console_lock is held */
1489 static void setterm_command(struct vc_data *vc)
1490 {
1491 switch(vc->vc_par[0]) {
1492 case 1: /* set color for underline mode */
1493 if (vc->vc_can_do_color &&
1494 vc->vc_par[1] < 16) {
1495 vc->vc_ulcolor = color_table[vc->vc_par[1]];
1496 if (vc->vc_underline)
1497 update_attr(vc);
1498 }
1499 break;
1500 case 2: /* set color for half intensity mode */
1501 if (vc->vc_can_do_color &&
1502 vc->vc_par[1] < 16) {
1503 vc->vc_halfcolor = color_table[vc->vc_par[1]];
1504 if (vc->vc_intensity == 0)
1505 update_attr(vc);
1506 }
1507 break;
1508 case 8: /* store colors as defaults */
1509 vc->vc_def_color = vc->vc_attr;
1510 if (vc->vc_hi_font_mask == 0x100)
1511 vc->vc_def_color >>= 1;
1512 default_attr(vc);
1513 update_attr(vc);
1514 break;
1515 case 9: /* set blanking interval */
1516 blankinterval = ((vc->vc_par[1] < 60) ? vc->vc_par[1] : 60) * 60;
1517 poke_blanked_console();
1518 break;
1519 case 10: /* set bell frequency in Hz */
1520 if (vc->vc_npar >= 1)
1521 vc->vc_bell_pitch = vc->vc_par[1];
1522 else
1523 vc->vc_bell_pitch = DEFAULT_BELL_PITCH;
1524 break;
1525 case 11: /* set bell duration in msec */
1526 if (vc->vc_npar >= 1)
1527 vc->vc_bell_duration = (vc->vc_par[1] < 2000) ?
1528 vc->vc_par[1] * HZ / 1000 : 0;
1529 else
1530 vc->vc_bell_duration = DEFAULT_BELL_DURATION;
1531 break;
1532 case 12: /* bring specified console to the front */
1533 if (vc->vc_par[1] >= 1 && vc_cons_allocated(vc->vc_par[1] - 1))
1534 set_console(vc->vc_par[1] - 1);
1535 break;
1536 case 13: /* unblank the screen */
1537 poke_blanked_console();
1538 break;
1539 case 14: /* set vesa powerdown interval */
1540 vesa_off_interval = ((vc->vc_par[1] < 60) ? vc->vc_par[1] : 60) * 60 * HZ;
1541 break;
1542 case 15: /* activate the previous console */
1543 set_console(last_console);
1544 break;
1545 }
1546 }
1547
1548 /* console_lock is held */
1549 static void csi_at(struct vc_data *vc, unsigned int nr)
1550 {
1551 if (nr > vc->vc_cols - vc->vc_x)
1552 nr = vc->vc_cols - vc->vc_x;
1553 else if (!nr)
1554 nr = 1;
1555 insert_char(vc, nr);
1556 }
1557
1558 /* console_lock is held */
1559 static void csi_L(struct vc_data *vc, unsigned int nr)
1560 {
1561 if (nr > vc->vc_rows - vc->vc_y)
1562 nr = vc->vc_rows - vc->vc_y;
1563 else if (!nr)
1564 nr = 1;
1565 scrdown(vc, vc->vc_y, vc->vc_bottom, nr);
1566 vc->vc_need_wrap = 0;
1567 }
1568
1569 /* console_lock is held */
1570 static void csi_P(struct vc_data *vc, unsigned int nr)
1571 {
1572 if (nr > vc->vc_cols - vc->vc_x)
1573 nr = vc->vc_cols - vc->vc_x;
1574 else if (!nr)
1575 nr = 1;
1576 delete_char(vc, nr);
1577 }
1578
1579 /* console_lock is held */
1580 static void csi_M(struct vc_data *vc, unsigned int nr)
1581 {
1582 if (nr > vc->vc_rows - vc->vc_y)
1583 nr = vc->vc_rows - vc->vc_y;
1584 else if (!nr)
1585 nr=1;
1586 scrup(vc, vc->vc_y, vc->vc_bottom, nr);
1587 vc->vc_need_wrap = 0;
1588 }
1589
1590 /* console_lock is held (except via vc_init->reset_terminal */
1591 static void save_cur(struct vc_data *vc)
1592 {
1593 vc->vc_saved_x = vc->vc_x;
1594 vc->vc_saved_y = vc->vc_y;
1595 vc->vc_s_intensity = vc->vc_intensity;
1596 vc->vc_s_italic = vc->vc_italic;
1597 vc->vc_s_underline = vc->vc_underline;
1598 vc->vc_s_blink = vc->vc_blink;
1599 vc->vc_s_reverse = vc->vc_reverse;
1600 vc->vc_s_charset = vc->vc_charset;
1601 vc->vc_s_color = vc->vc_color;
1602 vc->vc_saved_G0 = vc->vc_G0_charset;
1603 vc->vc_saved_G1 = vc->vc_G1_charset;
1604 }
1605
1606 /* console_lock is held */
1607 static void restore_cur(struct vc_data *vc)
1608 {
1609 gotoxy(vc, vc->vc_saved_x, vc->vc_saved_y);
1610 vc->vc_intensity = vc->vc_s_intensity;
1611 vc->vc_italic = vc->vc_s_italic;
1612 vc->vc_underline = vc->vc_s_underline;
1613 vc->vc_blink = vc->vc_s_blink;
1614 vc->vc_reverse = vc->vc_s_reverse;
1615 vc->vc_charset = vc->vc_s_charset;
1616 vc->vc_color = vc->vc_s_color;
1617 vc->vc_G0_charset = vc->vc_saved_G0;
1618 vc->vc_G1_charset = vc->vc_saved_G1;
1619 vc->vc_translate = set_translate(vc->vc_charset ? vc->vc_G1_charset : vc->vc_G0_charset, vc);
1620 update_attr(vc);
1621 vc->vc_need_wrap = 0;
1622 }
1623
1624 enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
1625 EShash, ESsetG0, ESsetG1, ESpercent, ESignore, ESnonstd,
1626 ESpalette };
1627
1628 /* console_lock is held (except via vc_init()) */
1629 static void reset_terminal(struct vc_data *vc, int do_clear)
1630 {
1631 vc->vc_top = 0;
1632 vc->vc_bottom = vc->vc_rows;
1633 vc->vc_state = ESnormal;
1634 vc->vc_ques = 0;
1635 vc->vc_translate = set_translate(LAT1_MAP, vc);
1636 vc->vc_G0_charset = LAT1_MAP;
1637 vc->vc_G1_charset = GRAF_MAP;
1638 vc->vc_charset = 0;
1639 vc->vc_need_wrap = 0;
1640 vc->vc_report_mouse = 0;
1641 vc->vc_utf = default_utf8;
1642 vc->vc_utf_count = 0;
1643
1644 vc->vc_disp_ctrl = 0;
1645 vc->vc_toggle_meta = 0;
1646
1647 vc->vc_decscnm = 0;
1648 vc->vc_decom = 0;
1649 vc->vc_decawm = 1;
1650 vc->vc_deccm = global_cursor_default;
1651 vc->vc_decim = 0;
1652
1653 set_kbd(vc, decarm);
1654 clr_kbd(vc, decckm);
1655 clr_kbd(vc, kbdapplic);
1656 clr_kbd(vc, lnm);
1657 kbd_table[vc->vc_num].lockstate = 0;
1658 kbd_table[vc->vc_num].slockstate = 0;
1659 kbd_table[vc->vc_num].ledmode = LED_SHOW_FLAGS;
1660 kbd_table[vc->vc_num].ledflagstate = kbd_table[vc->vc_num].default_ledflagstate;
1661 /* do not do set_leds here because this causes an endless tasklet loop
1662 when the keyboard hasn't been initialized yet */
1663
1664 vc->vc_cursor_type = cur_default;
1665 vc->vc_complement_mask = vc->vc_s_complement_mask;
1666
1667 default_attr(vc);
1668 update_attr(vc);
1669
1670 vc->vc_tab_stop[0] = 0x01010100;
1671 vc->vc_tab_stop[1] =
1672 vc->vc_tab_stop[2] =
1673 vc->vc_tab_stop[3] =
1674 vc->vc_tab_stop[4] =
1675 vc->vc_tab_stop[5] =
1676 vc->vc_tab_stop[6] =
1677 vc->vc_tab_stop[7] = 0x01010101;
1678
1679 vc->vc_bell_pitch = DEFAULT_BELL_PITCH;
1680 vc->vc_bell_duration = DEFAULT_BELL_DURATION;
1681
1682 gotoxy(vc, 0, 0);
1683 save_cur(vc);
1684 if (do_clear)
1685 csi_J(vc, 2);
1686 }
1687
1688 /* console_lock is held */
1689 static void do_con_trol(struct tty_struct *tty, struct vc_data *vc, int c)
1690 {
1691 /*
1692 * Control characters can be used in the _middle_
1693 * of an escape sequence.
1694 */
1695 switch (c) {
1696 case 0:
1697 return;
1698 case 7:
1699 if (vc->vc_bell_duration)
1700 kd_mksound(vc->vc_bell_pitch, vc->vc_bell_duration);
1701 return;
1702 case 8:
1703 bs(vc);
1704 return;
1705 case 9:
1706 vc->vc_pos -= (vc->vc_x << 1);
1707 while (vc->vc_x < vc->vc_cols - 1) {
1708 vc->vc_x++;
1709 if (vc->vc_tab_stop[vc->vc_x >> 5] & (1 << (vc->vc_x & 31)))
1710 break;
1711 }
1712 vc->vc_pos += (vc->vc_x << 1);
1713 notify_write(vc, '\t');
1714 return;
1715 case 10: case 11: case 12:
1716 lf(vc);
1717 if (!is_kbd(vc, lnm))
1718 return;
1719 case 13:
1720 cr(vc);
1721 return;
1722 case 14:
1723 vc->vc_charset = 1;
1724 vc->vc_translate = set_translate(vc->vc_G1_charset, vc);
1725 vc->vc_disp_ctrl = 1;
1726 return;
1727 case 15:
1728 vc->vc_charset = 0;
1729 vc->vc_translate = set_translate(vc->vc_G0_charset, vc);
1730 vc->vc_disp_ctrl = 0;
1731 return;
1732 case 24: case 26:
1733 vc->vc_state = ESnormal;
1734 return;
1735 case 27:
1736 vc->vc_state = ESesc;
1737 return;
1738 case 127:
1739 del(vc);
1740 return;
1741 case 128+27:
1742 vc->vc_state = ESsquare;
1743 return;
1744 }
1745 switch(vc->vc_state) {
1746 case ESesc:
1747 vc->vc_state = ESnormal;
1748 switch (c) {
1749 case '[':
1750 vc->vc_state = ESsquare;
1751 return;
1752 case ']':
1753 vc->vc_state = ESnonstd;
1754 return;
1755 case '%':
1756 vc->vc_state = ESpercent;
1757 return;
1758 case 'E':
1759 cr(vc);
1760 lf(vc);
1761 return;
1762 case 'M':
1763 ri(vc);
1764 return;
1765 case 'D':
1766 lf(vc);
1767 return;
1768 case 'H':
1769 vc->vc_tab_stop[vc->vc_x >> 5] |= (1 << (vc->vc_x & 31));
1770 return;
1771 case 'Z':
1772 respond_ID(tty);
1773 return;
1774 case '7':
1775 save_cur(vc);
1776 return;
1777 case '8':
1778 restore_cur(vc);
1779 return;
1780 case '(':
1781 vc->vc_state = ESsetG0;
1782 return;
1783 case ')':
1784 vc->vc_state = ESsetG1;
1785 return;
1786 case '#':
1787 vc->vc_state = EShash;
1788 return;
1789 case 'c':
1790 reset_terminal(vc, 1);
1791 return;
1792 case '>': /* Numeric keypad */
1793 clr_kbd(vc, kbdapplic);
1794 return;
1795 case '=': /* Appl. keypad */
1796 set_kbd(vc, kbdapplic);
1797 return;
1798 }
1799 return;
1800 case ESnonstd:
1801 if (c=='P') { /* palette escape sequence */
1802 for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++)
1803 vc->vc_par[vc->vc_npar] = 0;
1804 vc->vc_npar = 0;
1805 vc->vc_state = ESpalette;
1806 return;
1807 } else if (c=='R') { /* reset palette */
1808 reset_palette(vc);
1809 vc->vc_state = ESnormal;
1810 } else
1811 vc->vc_state = ESnormal;
1812 return;
1813 case ESpalette:
1814 if (isxdigit(c)) {
1815 vc->vc_par[vc->vc_npar++] = hex_to_bin(c);
1816 if (vc->vc_npar == 7) {
1817 int i = vc->vc_par[0] * 3, j = 1;
1818 vc->vc_palette[i] = 16 * vc->vc_par[j++];
1819 vc->vc_palette[i++] += vc->vc_par[j++];
1820 vc->vc_palette[i] = 16 * vc->vc_par[j++];
1821 vc->vc_palette[i++] += vc->vc_par[j++];
1822 vc->vc_palette[i] = 16 * vc->vc_par[j++];
1823 vc->vc_palette[i] += vc->vc_par[j];
1824 set_palette(vc);
1825 vc->vc_state = ESnormal;
1826 }
1827 } else
1828 vc->vc_state = ESnormal;
1829 return;
1830 case ESsquare:
1831 for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++)
1832 vc->vc_par[vc->vc_npar] = 0;
1833 vc->vc_npar = 0;
1834 vc->vc_state = ESgetpars;
1835 if (c == '[') { /* Function key */
1836 vc->vc_state=ESfunckey;
1837 return;
1838 }
1839 vc->vc_ques = (c == '?');
1840 if (vc->vc_ques)
1841 return;
1842 case ESgetpars:
1843 if (c == ';' && vc->vc_npar < NPAR - 1) {
1844 vc->vc_npar++;
1845 return;
1846 } else if (c>='0' && c<='9') {
1847 vc->vc_par[vc->vc_npar] *= 10;
1848 vc->vc_par[vc->vc_npar] += c - '0';
1849 return;
1850 } else
1851 vc->vc_state = ESgotpars;
1852 case ESgotpars:
1853 vc->vc_state = ESnormal;
1854 switch(c) {
1855 case 'h':
1856 set_mode(vc, 1);
1857 return;
1858 case 'l':
1859 set_mode(vc, 0);
1860 return;
1861 case 'c':
1862 if (vc->vc_ques) {
1863 if (vc->vc_par[0])
1864 vc->vc_cursor_type = vc->vc_par[0] | (vc->vc_par[1] << 8) | (vc->vc_par[2] << 16);
1865 else
1866 vc->vc_cursor_type = cur_default;
1867 return;
1868 }
1869 break;
1870 case 'm':
1871 if (vc->vc_ques) {
1872 clear_selection();
1873 if (vc->vc_par[0])
1874 vc->vc_complement_mask = vc->vc_par[0] << 8 | vc->vc_par[1];
1875 else
1876 vc->vc_complement_mask = vc->vc_s_complement_mask;
1877 return;
1878 }
1879 break;
1880 case 'n':
1881 if (!vc->vc_ques) {
1882 if (vc->vc_par[0] == 5)
1883 status_report(tty);
1884 else if (vc->vc_par[0] == 6)
1885 cursor_report(vc, tty);
1886 }
1887 return;
1888 }
1889 if (vc->vc_ques) {
1890 vc->vc_ques = 0;
1891 return;
1892 }
1893 switch(c) {
1894 case 'G': case '`':
1895 if (vc->vc_par[0])
1896 vc->vc_par[0]--;
1897 gotoxy(vc, vc->vc_par[0], vc->vc_y);
1898 return;
1899 case 'A':
1900 if (!vc->vc_par[0])
1901 vc->vc_par[0]++;
1902 gotoxy(vc, vc->vc_x, vc->vc_y - vc->vc_par[0]);
1903 return;
1904 case 'B': case 'e':
1905 if (!vc->vc_par[0])
1906 vc->vc_par[0]++;
1907 gotoxy(vc, vc->vc_x, vc->vc_y + vc->vc_par[0]);
1908 return;
1909 case 'C': case 'a':
1910 if (!vc->vc_par[0])
1911 vc->vc_par[0]++;
1912 gotoxy(vc, vc->vc_x + vc->vc_par[0], vc->vc_y);
1913 return;
1914 case 'D':
1915 if (!vc->vc_par[0])
1916 vc->vc_par[0]++;
1917 gotoxy(vc, vc->vc_x - vc->vc_par[0], vc->vc_y);
1918 return;
1919 case 'E':
1920 if (!vc->vc_par[0])
1921 vc->vc_par[0]++;
1922 gotoxy(vc, 0, vc->vc_y + vc->vc_par[0]);
1923 return;
1924 case 'F':
1925 if (!vc->vc_par[0])
1926 vc->vc_par[0]++;
1927 gotoxy(vc, 0, vc->vc_y - vc->vc_par[0]);
1928 return;
1929 case 'd':
1930 if (vc->vc_par[0])
1931 vc->vc_par[0]--;
1932 gotoxay(vc, vc->vc_x ,vc->vc_par[0]);
1933 return;
1934 case 'H': case 'f':
1935 if (vc->vc_par[0])
1936 vc->vc_par[0]--;
1937 if (vc->vc_par[1])
1938 vc->vc_par[1]--;
1939 gotoxay(vc, vc->vc_par[1], vc->vc_par[0]);
1940 return;
1941 case 'J':
1942 csi_J(vc, vc->vc_par[0]);
1943 return;
1944 case 'K':
1945 csi_K(vc, vc->vc_par[0]);
1946 return;
1947 case 'L':
1948 csi_L(vc, vc->vc_par[0]);
1949 return;
1950 case 'M':
1951 csi_M(vc, vc->vc_par[0]);
1952 return;
1953 case 'P':
1954 csi_P(vc, vc->vc_par[0]);
1955 return;
1956 case 'c':
1957 if (!vc->vc_par[0])
1958 respond_ID(tty);
1959 return;
1960 case 'g':
1961 if (!vc->vc_par[0])
1962 vc->vc_tab_stop[vc->vc_x >> 5] &= ~(1 << (vc->vc_x & 31));
1963 else if (vc->vc_par[0] == 3) {
1964 vc->vc_tab_stop[0] =
1965 vc->vc_tab_stop[1] =
1966 vc->vc_tab_stop[2] =
1967 vc->vc_tab_stop[3] =
1968 vc->vc_tab_stop[4] =
1969 vc->vc_tab_stop[5] =
1970 vc->vc_tab_stop[6] =
1971 vc->vc_tab_stop[7] = 0;
1972 }
1973 return;
1974 case 'm':
1975 csi_m(vc);
1976 return;
1977 case 'q': /* DECLL - but only 3 leds */
1978 /* map 0,1,2,3 to 0,1,2,4 */
1979 if (vc->vc_par[0] < 4)
1980 setledstate(kbd_table + vc->vc_num,
1981 (vc->vc_par[0] < 3) ? vc->vc_par[0] : 4);
1982 return;
1983 case 'r':
1984 if (!vc->vc_par[0])
1985 vc->vc_par[0]++;
1986 if (!vc->vc_par[1])
1987 vc->vc_par[1] = vc->vc_rows;
1988 /* Minimum allowed region is 2 lines */
1989 if (vc->vc_par[0] < vc->vc_par[1] &&
1990 vc->vc_par[1] <= vc->vc_rows) {
1991 vc->vc_top = vc->vc_par[0] - 1;
1992 vc->vc_bottom = vc->vc_par[1];
1993 gotoxay(vc, 0, 0);
1994 }
1995 return;
1996 case 's':
1997 save_cur(vc);
1998 return;
1999 case 'u':
2000 restore_cur(vc);
2001 return;
2002 case 'X':
2003 csi_X(vc, vc->vc_par[0]);
2004 return;
2005 case '@':
2006 csi_at(vc, vc->vc_par[0]);
2007 return;
2008 case ']': /* setterm functions */
2009 setterm_command(vc);
2010 return;
2011 }
2012 return;
2013 case ESpercent:
2014 vc->vc_state = ESnormal;
2015 switch (c) {
2016 case '@': /* defined in ISO 2022 */
2017 vc->vc_utf = 0;
2018 return;
2019 case 'G': /* prelim official escape code */
2020 case '8': /* retained for compatibility */
2021 vc->vc_utf = 1;
2022 return;
2023 }
2024 return;
2025 case ESfunckey:
2026 vc->vc_state = ESnormal;
2027 return;
2028 case EShash:
2029 vc->vc_state = ESnormal;
2030 if (c == '8') {
2031 /* DEC screen alignment test. kludge :-) */
2032 vc->vc_video_erase_char =
2033 (vc->vc_video_erase_char & 0xff00) | 'E';
2034 csi_J(vc, 2);
2035 vc->vc_video_erase_char =
2036 (vc->vc_video_erase_char & 0xff00) | ' ';
2037 do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2);
2038 }
2039 return;
2040 case ESsetG0:
2041 if (c == '0')
2042 vc->vc_G0_charset = GRAF_MAP;
2043 else if (c == 'B')
2044 vc->vc_G0_charset = LAT1_MAP;
2045 else if (c == 'U')
2046 vc->vc_G0_charset = IBMPC_MAP;
2047 else if (c == 'K')
2048 vc->vc_G0_charset = USER_MAP;
2049 if (vc->vc_charset == 0)
2050 vc->vc_translate = set_translate(vc->vc_G0_charset, vc);
2051 vc->vc_state = ESnormal;
2052 return;
2053 case ESsetG1:
2054 if (c == '0')
2055 vc->vc_G1_charset = GRAF_MAP;
2056 else if (c == 'B')
2057 vc->vc_G1_charset = LAT1_MAP;
2058 else if (c == 'U')
2059 vc->vc_G1_charset = IBMPC_MAP;
2060 else if (c == 'K')
2061 vc->vc_G1_charset = USER_MAP;
2062 if (vc->vc_charset == 1)
2063 vc->vc_translate = set_translate(vc->vc_G1_charset, vc);
2064 vc->vc_state = ESnormal;
2065 return;
2066 default:
2067 vc->vc_state = ESnormal;
2068 }
2069 }
2070
2071 /* This is a temporary buffer used to prepare a tty console write
2072 * so that we can easily avoid touching user space while holding the
2073 * console spinlock. It is allocated in con_init and is shared by
2074 * this code and the vc_screen read/write tty calls.
2075 *
2076 * We have to allocate this statically in the kernel data section
2077 * since console_init (and thus con_init) are called before any
2078 * kernel memory allocation is available.
2079 */
2080 char con_buf[CON_BUF_SIZE];
2081 DEFINE_MUTEX(con_buf_mtx);
2082
2083 /* is_double_width() is based on the wcwidth() implementation by
2084 * Markus Kuhn -- 2007-05-26 (Unicode 5.0)
2085 * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
2086 */
2087 struct interval {
2088 uint32_t first;
2089 uint32_t last;
2090 };
2091
2092 static int bisearch(uint32_t ucs, const struct interval *table, int max)
2093 {
2094 int min = 0;
2095 int mid;
2096
2097 if (ucs < table[0].first || ucs > table[max].last)
2098 return 0;
2099 while (max >= min) {
2100 mid = (min + max) / 2;
2101 if (ucs > table[mid].last)
2102 min = mid + 1;
2103 else if (ucs < table[mid].first)
2104 max = mid - 1;
2105 else
2106 return 1;
2107 }
2108 return 0;
2109 }
2110
2111 static int is_double_width(uint32_t ucs)
2112 {
2113 static const struct interval double_width[] = {
2114 { 0x1100, 0x115F }, { 0x2329, 0x232A }, { 0x2E80, 0x303E },
2115 { 0x3040, 0xA4CF }, { 0xAC00, 0xD7A3 }, { 0xF900, 0xFAFF },
2116 { 0xFE10, 0xFE19 }, { 0xFE30, 0xFE6F }, { 0xFF00, 0xFF60 },
2117 { 0xFFE0, 0xFFE6 }, { 0x20000, 0x2FFFD }, { 0x30000, 0x3FFFD }
2118 };
2119 return bisearch(ucs, double_width, ARRAY_SIZE(double_width) - 1);
2120 }
2121
2122 /* acquires console_lock */
2123 static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int count)
2124 {
2125 #ifdef VT_BUF_VRAM_ONLY
2126 #define FLUSH do { } while(0);
2127 #else
2128 #define FLUSH if (draw_x >= 0) { \
2129 vc->vc_sw->con_putcs(vc, (u16 *)draw_from, (u16 *)draw_to - (u16 *)draw_from, vc->vc_y, draw_x); \
2130 draw_x = -1; \
2131 }
2132 #endif
2133
2134 int c, tc, ok, n = 0, draw_x = -1;
2135 unsigned int currcons;
2136 unsigned long draw_from = 0, draw_to = 0;
2137 struct vc_data *vc;
2138 unsigned char vc_attr;
2139 struct vt_notifier_param param;
2140 uint8_t rescan;
2141 uint8_t inverse;
2142 uint8_t width;
2143 u16 himask, charmask;
2144
2145 if (in_interrupt())
2146 return count;
2147
2148 might_sleep();
2149
2150 console_lock();
2151 vc = tty->driver_data;
2152 if (vc == NULL) {
2153 printk(KERN_ERR "vt: argh, driver_data is NULL !\n");
2154 console_unlock();
2155 return 0;
2156 }
2157
2158 currcons = vc->vc_num;
2159 if (!vc_cons_allocated(currcons)) {
2160 /* could this happen? */
2161 printk_once("con_write: tty %d not allocated\n", currcons+1);
2162 console_unlock();
2163 return 0;
2164 }
2165
2166 himask = vc->vc_hi_font_mask;
2167 charmask = himask ? 0x1ff : 0xff;
2168
2169 /* undraw cursor first */
2170 if (IS_FG(vc))
2171 hide_cursor(vc);
2172
2173 param.vc = vc;
2174
2175 while (!tty->stopped && count) {
2176 int orig = *buf;
2177 c = orig;
2178 buf++;
2179 n++;
2180 count--;
2181 rescan = 0;
2182 inverse = 0;
2183 width = 1;
2184
2185 /* Do no translation at all in control states */
2186 if (vc->vc_state != ESnormal) {
2187 tc = c;
2188 } else if (vc->vc_utf && !vc->vc_disp_ctrl) {
2189 /* Combine UTF-8 into Unicode in vc_utf_char.
2190 * vc_utf_count is the number of continuation bytes still
2191 * expected to arrive.
2192 * vc_npar is the number of continuation bytes arrived so
2193 * far
2194 */
2195 rescan_last_byte:
2196 if ((c & 0xc0) == 0x80) {
2197 /* Continuation byte received */
2198 static const uint32_t utf8_length_changes[] = { 0x0000007f, 0x000007ff, 0x0000ffff, 0x001fffff, 0x03ffffff, 0x7fffffff };
2199 if (vc->vc_utf_count) {
2200 vc->vc_utf_char = (vc->vc_utf_char << 6) | (c & 0x3f);
2201 vc->vc_npar++;
2202 if (--vc->vc_utf_count) {
2203 /* Still need some bytes */
2204 continue;
2205 }
2206 /* Got a whole character */
2207 c = vc->vc_utf_char;
2208 /* Reject overlong sequences */
2209 if (c <= utf8_length_changes[vc->vc_npar - 1] ||
2210 c > utf8_length_changes[vc->vc_npar])
2211 c = 0xfffd;
2212 } else {
2213 /* Unexpected continuation byte */
2214 vc->vc_utf_count = 0;
2215 c = 0xfffd;
2216 }
2217 } else {
2218 /* Single ASCII byte or first byte of a sequence received */
2219 if (vc->vc_utf_count) {
2220 /* Continuation byte expected */
2221 rescan = 1;
2222 vc->vc_utf_count = 0;
2223 c = 0xfffd;
2224 } else if (c > 0x7f) {
2225 /* First byte of a multibyte sequence received */
2226 vc->vc_npar = 0;
2227 if ((c & 0xe0) == 0xc0) {
2228 vc->vc_utf_count = 1;
2229 vc->vc_utf_char = (c & 0x1f);
2230 } else if ((c & 0xf0) == 0xe0) {
2231 vc->vc_utf_count = 2;
2232 vc->vc_utf_char = (c & 0x0f);
2233 } else if ((c & 0xf8) == 0xf0) {
2234 vc->vc_utf_count = 3;
2235 vc->vc_utf_char = (c & 0x07);
2236 } else if ((c & 0xfc) == 0xf8) {
2237 vc->vc_utf_count = 4;
2238 vc->vc_utf_char = (c & 0x03);
2239 } else if ((c & 0xfe) == 0xfc) {
2240 vc->vc_utf_count = 5;
2241 vc->vc_utf_char = (c & 0x01);
2242 } else {
2243 /* 254 and 255 are invalid */
2244 c = 0xfffd;
2245 }
2246 if (vc->vc_utf_count) {
2247 /* Still need some bytes */
2248 continue;
2249 }
2250 }
2251 /* Nothing to do if an ASCII byte was received */
2252 }
2253 /* End of UTF-8 decoding. */
2254 /* c is the received character, or U+FFFD for invalid sequences. */
2255 /* Replace invalid Unicode code points with U+FFFD too */
2256 if ((c >= 0xd800 && c <= 0xdfff) || c == 0xfffe || c == 0xffff)
2257 c = 0xfffd;
2258 tc = c;
2259 } else { /* no utf or alternate charset mode */
2260 tc = vc_translate(vc, c);
2261 }
2262
2263 param.c = tc;
2264 if (atomic_notifier_call_chain(&vt_notifier_list, VT_PREWRITE,
2265 &param) == NOTIFY_STOP)
2266 continue;
2267
2268 /* If the original code was a control character we
2269 * only allow a glyph to be displayed if the code is
2270 * not normally used (such as for cursor movement) or
2271 * if the disp_ctrl mode has been explicitly enabled.
2272 * Certain characters (as given by the CTRL_ALWAYS
2273 * bitmap) are always displayed as control characters,
2274 * as the console would be pretty useless without
2275 * them; to display an arbitrary font position use the
2276 * direct-to-font zone in UTF-8 mode.
2277 */
2278 ok = tc && (c >= 32 ||
2279 !(vc->vc_disp_ctrl ? (CTRL_ALWAYS >> c) & 1 :
2280 vc->vc_utf || ((CTRL_ACTION >> c) & 1)))
2281 && (c != 127 || vc->vc_disp_ctrl)
2282 && (c != 128+27);
2283
2284 if (vc->vc_state == ESnormal && ok) {
2285 if (vc->vc_utf && !vc->vc_disp_ctrl) {
2286 if (is_double_width(c))
2287 width = 2;
2288 }
2289 /* Now try to find out how to display it */
2290 tc = conv_uni_to_pc(vc, tc);
2291 if (tc & ~charmask) {
2292 if (tc == -1 || tc == -2) {
2293 continue; /* nothing to display */
2294 }
2295 /* Glyph not found */
2296 if ((!(vc->vc_utf && !vc->vc_disp_ctrl) || c < 128) && !(c & ~charmask)) {
2297 /* In legacy mode use the glyph we get by a 1:1 mapping.
2298 This would make absolutely no sense with Unicode in mind,
2299 but do this for ASCII characters since a font may lack
2300 Unicode mapping info and we don't want to end up with
2301 having question marks only. */
2302 tc = c;
2303 } else {
2304 /* Display U+FFFD. If it's not found, display an inverse question mark. */
2305 tc = conv_uni_to_pc(vc, 0xfffd);
2306 if (tc < 0) {
2307 inverse = 1;
2308 tc = conv_uni_to_pc(vc, '?');
2309 if (tc < 0) tc = '?';
2310 }
2311 }
2312 }
2313
2314 if (!inverse) {
2315 vc_attr = vc->vc_attr;
2316 } else {
2317 /* invert vc_attr */
2318 if (!vc->vc_can_do_color) {
2319 vc_attr = (vc->vc_attr) ^ 0x08;
2320 } else if (vc->vc_hi_font_mask == 0x100) {
2321 vc_attr = ((vc->vc_attr) & 0x11) | (((vc->vc_attr) & 0xe0) >> 4) | (((vc->vc_attr) & 0x0e) << 4);
2322 } else {
2323 vc_attr = ((vc->vc_attr) & 0x88) | (((vc->vc_attr) & 0x70) >> 4) | (((vc->vc_attr) & 0x07) << 4);
2324 }
2325 FLUSH
2326 }
2327
2328 while (1) {
2329 if (vc->vc_need_wrap || vc->vc_decim)
2330 FLUSH
2331 if (vc->vc_need_wrap) {
2332 cr(vc);
2333 lf(vc);
2334 }
2335 if (vc->vc_decim)
2336 insert_char(vc, 1);
2337 scr_writew(himask ?
2338 ((vc_attr << 8) & ~himask) + ((tc & 0x100) ? himask : 0) + (tc & 0xff) :
2339 (vc_attr << 8) + tc,
2340 (u16 *) vc->vc_pos);
2341 if (DO_UPDATE(vc) && draw_x < 0) {
2342 draw_x = vc->vc_x;
2343 draw_from = vc->vc_pos;
2344 }
2345 if (vc->vc_x == vc->vc_cols - 1) {
2346 vc->vc_need_wrap = vc->vc_decawm;
2347 draw_to = vc->vc_pos + 2;
2348 } else {
2349 vc->vc_x++;
2350 draw_to = (vc->vc_pos += 2);
2351 }
2352
2353 if (!--width) break;
2354
2355 tc = conv_uni_to_pc(vc, ' '); /* A space is printed in the second column */
2356 if (tc < 0) tc = ' ';
2357 }
2358 notify_write(vc, c);
2359
2360 if (inverse) {
2361 FLUSH
2362 }
2363
2364 if (rescan) {
2365 rescan = 0;
2366 inverse = 0;
2367 width = 1;
2368 c = orig;
2369 goto rescan_last_byte;
2370 }
2371 continue;
2372 }
2373 FLUSH
2374 do_con_trol(tty, vc, orig);
2375 }
2376 FLUSH
2377 console_conditional_schedule();
2378 console_unlock();
2379 notify_update(vc);
2380 return n;
2381 #undef FLUSH
2382 }
2383
2384 /*
2385 * This is the console switching callback.
2386 *
2387 * Doing console switching in a process context allows
2388 * us to do the switches asynchronously (needed when we want
2389 * to switch due to a keyboard interrupt). Synchronization
2390 * with other console code and prevention of re-entrancy is
2391 * ensured with console_lock.
2392 */
2393 static void console_callback(struct work_struct *ignored)
2394 {
2395 console_lock();
2396
2397 if (want_console >= 0) {
2398 if (want_console != fg_console &&
2399 vc_cons_allocated(want_console)) {
2400 hide_cursor(vc_cons[fg_console].d);
2401 change_console(vc_cons[want_console].d);
2402 /* we only changed when the console had already
2403 been allocated - a new console is not created
2404 in an interrupt routine */
2405 }
2406 want_console = -1;
2407 }
2408 if (do_poke_blanked_console) { /* do not unblank for a LED change */
2409 do_poke_blanked_console = 0;
2410 poke_blanked_console();
2411 }
2412 if (scrollback_delta) {
2413 struct vc_data *vc = vc_cons[fg_console].d;
2414 clear_selection();
2415 if (vc->vc_mode == KD_TEXT)
2416 vc->vc_sw->con_scrolldelta(vc, scrollback_delta);
2417 scrollback_delta = 0;
2418 }
2419 if (blank_timer_expired) {
2420 do_blank_screen(0);
2421 blank_timer_expired = 0;
2422 }
2423 notify_update(vc_cons[fg_console].d);
2424
2425 console_unlock();
2426 }
2427
2428 int set_console(int nr)
2429 {
2430 struct vc_data *vc = vc_cons[fg_console].d;
2431
2432 if (!vc_cons_allocated(nr) || vt_dont_switch ||
2433 (vc->vt_mode.mode == VT_AUTO && vc->vc_mode == KD_GRAPHICS)) {
2434
2435 /*
2436 * Console switch will fail in console_callback() or
2437 * change_console() so there is no point scheduling
2438 * the callback
2439 *
2440 * Existing set_console() users don't check the return
2441 * value so this shouldn't break anything
2442 */
2443 return -EINVAL;
2444 }
2445
2446 want_console = nr;
2447 schedule_console_callback();
2448
2449 return 0;
2450 }
2451
2452 struct tty_driver *console_driver;
2453
2454 #ifdef CONFIG_VT_CONSOLE
2455
2456 /**
2457 * vt_kmsg_redirect() - Sets/gets the kernel message console
2458 * @new: The new virtual terminal number or -1 if the console should stay
2459 * unchanged
2460 *
2461 * By default, the kernel messages are always printed on the current virtual
2462 * console. However, the user may modify that default with the
2463 * TIOCL_SETKMSGREDIRECT ioctl call.
2464 *
2465 * This function sets the kernel message console to be @new. It returns the old
2466 * virtual console number. The virtual terminal number 0 (both as parameter and
2467 * return value) means no redirection (i.e. always printed on the currently
2468 * active console).
2469 *
2470 * The parameter -1 means that only the current console is returned, but the
2471 * value is not modified. You may use the macro vt_get_kmsg_redirect() in that
2472 * case to make the code more understandable.
2473 *
2474 * When the kernel is compiled without CONFIG_VT_CONSOLE, this function ignores
2475 * the parameter and always returns 0.
2476 */
2477 int vt_kmsg_redirect(int new)
2478 {
2479 static int kmsg_con;
2480
2481 if (new != -1)
2482 return xchg(&kmsg_con, new);
2483 else
2484 return kmsg_con;
2485 }
2486
2487 /*
2488 * Console on virtual terminal
2489 *
2490 * The console must be locked when we get here.
2491 */
2492
2493 static void vt_console_print(struct console *co, const char *b, unsigned count)
2494 {
2495 struct vc_data *vc = vc_cons[fg_console].d;
2496 unsigned char c;
2497 static DEFINE_SPINLOCK(printing_lock);
2498 const ushort *start;
2499 ushort cnt = 0;
2500 ushort myx;
2501 int kmsg_console;
2502
2503 /* console busy or not yet initialized */
2504 if (!printable)
2505 return;
2506 if (!spin_trylock(&printing_lock))
2507 return;
2508
2509 kmsg_console = vt_get_kmsg_redirect();
2510 if (kmsg_console && vc_cons_allocated(kmsg_console - 1))
2511 vc = vc_cons[kmsg_console - 1].d;
2512
2513 /* read `x' only after setting currcons properly (otherwise
2514 the `x' macro will read the x of the foreground console). */
2515 myx = vc->vc_x;
2516
2517 if (!vc_cons_allocated(fg_console)) {
2518 /* impossible */
2519 /* printk("vt_console_print: tty %d not allocated ??\n", currcons+1); */
2520 goto quit;
2521 }
2522
2523 if (vc->vc_mode != KD_TEXT && !vt_force_oops_output(vc))
2524 goto quit;
2525
2526 /* undraw cursor first */
2527 if (IS_FG(vc))
2528 hide_cursor(vc);
2529
2530 start = (ushort *)vc->vc_pos;
2531
2532 /* Contrived structure to try to emulate original need_wrap behaviour
2533 * Problems caused when we have need_wrap set on '\n' character */
2534 while (count--) {
2535 c = *b++;
2536 if (c == 10 || c == 13 || c == 8 || vc->vc_need_wrap) {
2537 if (cnt > 0) {
2538 if (CON_IS_VISIBLE(vc))
2539 vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, vc->vc_x);
2540 vc->vc_x += cnt;
2541 if (vc->vc_need_wrap)
2542 vc->vc_x--;
2543 cnt = 0;
2544 }
2545 if (c == 8) { /* backspace */
2546 bs(vc);
2547 start = (ushort *)vc->vc_pos;
2548 myx = vc->vc_x;
2549 continue;
2550 }
2551 if (c != 13)
2552 lf(vc);
2553 cr(vc);
2554 start = (ushort *)vc->vc_pos;
2555 myx = vc->vc_x;
2556 if (c == 10 || c == 13)
2557 continue;
2558 }
2559 scr_writew((vc->vc_attr << 8) + c, (unsigned short *)vc->vc_pos);
2560 notify_write(vc, c);
2561 cnt++;
2562 if (myx == vc->vc_cols - 1) {
2563 vc->vc_need_wrap = 1;
2564 continue;
2565 }
2566 vc->vc_pos += 2;
2567 myx++;
2568 }
2569 if (cnt > 0) {
2570 if (CON_IS_VISIBLE(vc))
2571 vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, vc->vc_x);
2572 vc->vc_x += cnt;
2573 if (vc->vc_x == vc->vc_cols) {
2574 vc->vc_x--;
2575 vc->vc_need_wrap = 1;
2576 }
2577 }
2578 set_cursor(vc);
2579 notify_update(vc);
2580
2581 quit:
2582 spin_unlock(&printing_lock);
2583 }
2584
2585 static struct tty_driver *vt_console_device(struct console *c, int *index)
2586 {
2587 *index = c->index ? c->index-1 : fg_console;
2588 return console_driver;
2589 }
2590
2591 static struct console vt_console_driver = {
2592 .name = "tty",
2593 .write = vt_console_print,
2594 .device = vt_console_device,
2595 .unblank = unblank_screen,
2596 .flags = CON_PRINTBUFFER,
2597 .index = -1,
2598 };
2599 #endif
2600
2601 /*
2602 * Handling of Linux-specific VC ioctls
2603 */
2604
2605 /*
2606 * Generally a bit racy with respect to console_lock();.
2607 *
2608 * There are some functions which don't need it.
2609 *
2610 * There are some functions which can sleep for arbitrary periods
2611 * (paste_selection) but we don't need the lock there anyway.
2612 *
2613 * set_selection has locking, and definitely needs it
2614 */
2615
2616 int tioclinux(struct tty_struct *tty, unsigned long arg)
2617 {
2618 char type, data;
2619 char __user *p = (char __user *)arg;
2620 int lines;
2621 int ret;
2622
2623 if (current->signal->tty != tty && !capable(CAP_SYS_ADMIN))
2624 return -EPERM;
2625 if (get_user(type, p))
2626 return -EFAULT;
2627 ret = 0;
2628
2629 switch (type)
2630 {
2631 case TIOCL_SETSEL:
2632 console_lock();
2633 ret = set_selection((struct tiocl_selection __user *)(p+1), tty);
2634 console_unlock();
2635 break;
2636 case TIOCL_PASTESEL:
2637 ret = paste_selection(tty);
2638 break;
2639 case TIOCL_UNBLANKSCREEN:
2640 console_lock();
2641 unblank_screen();
2642 console_unlock();
2643 break;
2644 case TIOCL_SELLOADLUT:
2645 ret = sel_loadlut(p);
2646 break;
2647 case TIOCL_GETSHIFTSTATE:
2648
2649 /*
2650 * Make it possible to react to Shift+Mousebutton.
2651 * Note that 'shift_state' is an undocumented
2652 * kernel-internal variable; programs not closely
2653 * related to the kernel should not use this.
2654 */
2655 data = shift_state;
2656 ret = __put_user(data, p);
2657 break;
2658 case TIOCL_GETMOUSEREPORTING:
2659 data = mouse_reporting();
2660 ret = __put_user(data, p);
2661 break;
2662 case TIOCL_SETVESABLANK:
2663 ret = set_vesa_blanking(p);
2664 break;
2665 case TIOCL_GETKMSGREDIRECT:
2666 data = vt_get_kmsg_redirect();
2667 ret = __put_user(data, p);
2668 break;
2669 case TIOCL_SETKMSGREDIRECT:
2670 if (!capable(CAP_SYS_ADMIN)) {
2671 ret = -EPERM;
2672 } else {
2673 if (get_user(data, p+1))
2674 ret = -EFAULT;
2675 else
2676 vt_kmsg_redirect(data);
2677 }
2678 break;
2679 case TIOCL_GETFGCONSOLE:
2680 ret = fg_console;
2681 break;
2682 case TIOCL_SCROLLCONSOLE:
2683 if (get_user(lines, (s32 __user *)(p+4))) {
2684 ret = -EFAULT;
2685 } else {
2686 scrollfront(vc_cons[fg_console].d, lines);
2687 ret = 0;
2688 }
2689 break;
2690 case TIOCL_BLANKSCREEN: /* until explicitly unblanked, not only poked */
2691 console_lock();
2692 ignore_poke = 1;
2693 do_blank_screen(0);
2694 console_unlock();
2695 break;
2696 case TIOCL_BLANKEDSCREEN:
2697 ret = console_blanked;
2698 break;
2699 default:
2700 ret = -EINVAL;
2701 break;
2702 }
2703 return ret;
2704 }
2705
2706 /*
2707 * /dev/ttyN handling
2708 */
2709
2710 static int con_write(struct tty_struct *tty, const unsigned char *buf, int count)
2711 {
2712 int retval;
2713
2714 retval = do_con_write(tty, buf, count);
2715 con_flush_chars(tty);
2716
2717 return retval;
2718 }
2719
2720 static int con_put_char(struct tty_struct *tty, unsigned char ch)
2721 {
2722 if (in_interrupt())
2723 return 0; /* n_r3964 calls put_char() from interrupt context */
2724 return do_con_write(tty, &ch, 1);
2725 }
2726
2727 static int con_write_room(struct tty_struct *tty)
2728 {
2729 if (tty->stopped)
2730 return 0;
2731 return 32768; /* No limit, really; we're not buffering */
2732 }
2733
2734 static int con_chars_in_buffer(struct tty_struct *tty)
2735 {
2736 return 0; /* we're not buffering */
2737 }
2738
2739 /*
2740 * con_throttle and con_unthrottle are only used for
2741 * paste_selection(), which has to stuff in a large number of
2742 * characters...
2743 */
2744 static void con_throttle(struct tty_struct *tty)
2745 {
2746 }
2747
2748 static void con_unthrottle(struct tty_struct *tty)
2749 {
2750 struct vc_data *vc = tty->driver_data;
2751
2752 wake_up_interruptible(&vc->paste_wait);
2753 }
2754
2755 /*
2756 * Turn the Scroll-Lock LED on when the tty is stopped
2757 */
2758 static void con_stop(struct tty_struct *tty)
2759 {
2760 int console_num;
2761 if (!tty)
2762 return;
2763 console_num = tty->index;
2764 if (!vc_cons_allocated(console_num))
2765 return;
2766 set_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
2767 set_leds();
2768 }
2769
2770 /*
2771 * Turn the Scroll-Lock LED off when the console is started
2772 */
2773 static void con_start(struct tty_struct *tty)
2774 {
2775 int console_num;
2776 if (!tty)
2777 return;
2778 console_num = tty->index;
2779 if (!vc_cons_allocated(console_num))
2780 return;
2781 clr_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK);
2782 set_leds();
2783 }
2784
2785 static void con_flush_chars(struct tty_struct *tty)
2786 {
2787 struct vc_data *vc;
2788
2789 if (in_interrupt()) /* from flush_to_ldisc */
2790 return;
2791
2792 /* if we race with con_close(), vt may be null */
2793 console_lock();
2794 vc = tty->driver_data;
2795 if (vc)
2796 set_cursor(vc);
2797 console_unlock();
2798 }
2799
2800 /*
2801 * Allocate the console screen memory.
2802 */
2803 static int con_open(struct tty_struct *tty, struct file *filp)
2804 {
2805 unsigned int currcons = tty->index;
2806 int ret = 0;
2807
2808 console_lock();
2809 if (tty->driver_data == NULL) {
2810 ret = vc_allocate(currcons);
2811 if (ret == 0) {
2812 struct vc_data *vc = vc_cons[currcons].d;
2813
2814 /* Still being freed */
2815 if (vc->port.tty) {
2816 console_unlock();
2817 return -ERESTARTSYS;
2818 }
2819 tty->driver_data = vc;
2820 vc->port.tty = tty;
2821
2822 if (!tty->winsize.ws_row && !tty->winsize.ws_col) {
2823 tty->winsize.ws_row = vc_cons[currcons].d->vc_rows;
2824 tty->winsize.ws_col = vc_cons[currcons].d->vc_cols;
2825 }
2826 if (vc->vc_utf)
2827 tty->termios->c_iflag |= IUTF8;
2828 else
2829 tty->termios->c_iflag &= ~IUTF8;
2830 console_unlock();
2831 return ret;
2832 }
2833 }
2834 console_unlock();
2835 return ret;
2836 }
2837
2838 static void con_close(struct tty_struct *tty, struct file *filp)
2839 {
2840 /* Nothing to do - we defer to shutdown */
2841 }
2842
2843 static void con_shutdown(struct tty_struct *tty)
2844 {
2845 struct vc_data *vc = tty->driver_data;
2846 BUG_ON(vc == NULL);
2847 console_lock();
2848 vc->port.tty = NULL;
2849 console_unlock();
2850 tty_shutdown(tty);
2851 }
2852
2853 static int default_italic_color = 2; // green (ASCII)
2854 static int default_underline_color = 3; // cyan (ASCII)
2855 module_param_named(italic, default_italic_color, int, S_IRUGO | S_IWUSR);
2856 module_param_named(underline, default_underline_color, int, S_IRUGO | S_IWUSR);
2857
2858 static void vc_init(struct vc_data *vc, unsigned int rows,
2859 unsigned int cols, int do_clear)
2860 {
2861 int j, k ;
2862
2863 vc->vc_cols = cols;
2864 vc->vc_rows = rows;
2865 vc->vc_size_row = cols << 1;
2866 vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row;
2867
2868 set_origin(vc);
2869 vc->vc_pos = vc->vc_origin;
2870 reset_vc(vc);
2871 for (j=k=0; j<16; j++) {
2872 vc->vc_palette[k++] = default_red[j] ;
2873 vc->vc_palette[k++] = default_grn[j] ;
2874 vc->vc_palette[k++] = default_blu[j] ;
2875 }
2876 vc->vc_def_color = 0x07; /* white */
2877 vc->vc_ulcolor = default_underline_color;
2878 vc->vc_itcolor = default_italic_color;
2879 vc->vc_halfcolor = 0x08; /* grey */
2880 init_waitqueue_head(&vc->paste_wait);
2881 reset_terminal(vc, do_clear);
2882 }
2883
2884 /*
2885 * This routine initializes console interrupts, and does nothing
2886 * else. If you want the screen to clear, call tty_write with
2887 * the appropriate escape-sequence.
2888 */
2889
2890 static int __init con_init(void)
2891 {
2892 const char *display_desc = NULL;
2893 struct vc_data *vc;
2894 unsigned int currcons = 0, i;
2895
2896 console_lock();
2897
2898 if (conswitchp)
2899 display_desc = conswitchp->con_startup();
2900 if (!display_desc) {
2901 fg_console = 0;
2902 console_unlock();
2903 return 0;
2904 }
2905
2906 for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
2907 struct con_driver *con_driver = &registered_con_driver[i];
2908
2909 if (con_driver->con == NULL) {
2910 con_driver->con = conswitchp;
2911 con_driver->desc = display_desc;
2912 con_driver->flag = CON_DRIVER_FLAG_INIT;
2913 con_driver->first = 0;
2914 con_driver->last = MAX_NR_CONSOLES - 1;
2915 break;
2916 }
2917 }
2918
2919 for (i = 0; i < MAX_NR_CONSOLES; i++)
2920 con_driver_map[i] = conswitchp;
2921
2922 if (blankinterval) {
2923 blank_state = blank_normal_wait;
2924 mod_timer(&console_timer, jiffies + (blankinterval * HZ));
2925 }
2926
2927 for (currcons = 0; currcons < MIN_NR_CONSOLES; currcons++) {
2928 vc_cons[currcons].d = vc = kzalloc(sizeof(struct vc_data), GFP_NOWAIT);
2929 INIT_WORK(&vc_cons[currcons].SAK_work, vc_SAK);
2930 tty_port_init(&vc->port);
2931 visual_init(vc, currcons, 1);
2932 vc->vc_screenbuf = kzalloc(vc->vc_screenbuf_size, GFP_NOWAIT);
2933 vc_init(vc, vc->vc_rows, vc->vc_cols,
2934 currcons || !vc->vc_sw->con_save_screen);
2935 }
2936 currcons = fg_console = 0;
2937 master_display_fg = vc = vc_cons[currcons].d;
2938 set_origin(vc);
2939 save_screen(vc);
2940 gotoxy(vc, vc->vc_x, vc->vc_y);
2941 csi_J(vc, 0);
2942 update_screen(vc);
2943 printk("Console: %s %s %dx%d",
2944 vc->vc_can_do_color ? "colour" : "mono",
2945 display_desc, vc->vc_cols, vc->vc_rows);
2946 printable = 1;
2947 printk("\n");
2948
2949 console_unlock();
2950
2951 #ifdef CONFIG_VT_CONSOLE
2952 register_console(&vt_console_driver);
2953 #endif
2954 return 0;
2955 }
2956 console_initcall(con_init);
2957
2958 static const struct tty_operations con_ops = {
2959 .open = con_open,
2960 .close = con_close,
2961 .write = con_write,
2962 .write_room = con_write_room,
2963 .put_char = con_put_char,
2964 .flush_chars = con_flush_chars,
2965 .chars_in_buffer = con_chars_in_buffer,
2966 .ioctl = vt_ioctl,
2967 #ifdef CONFIG_COMPAT
2968 .compat_ioctl = vt_compat_ioctl,
2969 #endif
2970 .stop = con_stop,
2971 .start = con_start,
2972 .throttle = con_throttle,
2973 .unthrottle = con_unthrottle,
2974 .resize = vt_resize,
2975 .shutdown = con_shutdown
2976 };
2977
2978 static struct cdev vc0_cdev;
2979
2980 static ssize_t show_tty_active(struct device *dev,
2981 struct device_attribute *attr, char *buf)
2982 {
2983 return sprintf(buf, "tty%d\n", fg_console + 1);
2984 }
2985 static DEVICE_ATTR(active, S_IRUGO, show_tty_active, NULL);
2986
2987 int __init vty_init(const struct file_operations *console_fops)
2988 {
2989 cdev_init(&vc0_cdev, console_fops);
2990 if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
2991 register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
2992 panic("Couldn't register /dev/tty0 driver\n");
2993 tty0dev = device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
2994 if (IS_ERR(tty0dev))
2995 tty0dev = NULL;
2996 else
2997 WARN_ON(device_create_file(tty0dev, &dev_attr_active) < 0);
2998
2999 vcs_init();
3000
3001 console_driver = alloc_tty_driver(MAX_NR_CONSOLES);
3002 if (!console_driver)
3003 panic("Couldn't allocate console driver\n");
3004 console_driver->owner = THIS_MODULE;
3005 console_driver->name = "tty";
3006 console_driver->name_base = 1;
3007 console_driver->major = TTY_MAJOR;
3008 console_driver->minor_start = 1;
3009 console_driver->type = TTY_DRIVER_TYPE_CONSOLE;
3010 console_driver->init_termios = tty_std_termios;
3011 if (default_utf8)
3012 console_driver->init_termios.c_iflag |= IUTF8;
3013 console_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
3014 tty_set_operations(console_driver, &con_ops);
3015 if (tty_register_driver(console_driver))
3016 panic("Couldn't register console driver\n");
3017 kbd_init();
3018 console_map_init();
3019 #ifdef CONFIG_MDA_CONSOLE
3020 mda_console_init();
3021 #endif
3022 return 0;
3023 }
3024
3025 #ifndef VT_SINGLE_DRIVER
3026
3027 static struct class *vtconsole_class;
3028
3029 static int bind_con_driver(const struct consw *csw, int first, int last,
3030 int deflt)
3031 {
3032 struct module *owner = csw->owner;
3033 const char *desc = NULL;
3034 struct con_driver *con_driver;
3035 int i, j = -1, k = -1, retval = -ENODEV;
3036
3037 if (!try_module_get(owner))
3038 return -ENODEV;
3039
3040 console_lock();
3041
3042 /* check if driver is registered */
3043 for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
3044 con_driver = &registered_con_driver[i];
3045
3046 if (con_driver->con == csw) {
3047 desc = con_driver->desc;
3048 retval = 0;
3049 break;
3050 }
3051 }
3052
3053 if (retval)
3054 goto err;
3055
3056 if (!(con_driver->flag & CON_DRIVER_FLAG_INIT)) {
3057 csw->con_startup();
3058 con_driver->flag |= CON_DRIVER_FLAG_INIT;
3059 }
3060
3061 if (deflt) {
3062 if (conswitchp)
3063 module_put(conswitchp->owner);
3064
3065 __module_get(owner);
3066 conswitchp = csw;
3067 }
3068
3069 first = max(first, con_driver->first);
3070 last = min(last, con_driver->last);
3071
3072 for (i = first; i <= last; i++) {
3073 int old_was_color;
3074 struct vc_data *vc = vc_cons[i].d;
3075
3076 if (con_driver_map[i])
3077 module_put(con_driver_map[i]->owner);
3078 __module_get(owner);
3079 con_driver_map[i] = csw;
3080
3081 if (!vc || !vc->vc_sw)
3082 continue;
3083
3084 j = i;
3085
3086 if (CON_IS_VISIBLE(vc)) {
3087 k = i;
3088 save_screen(vc);
3089 }
3090
3091 old_was_color = vc->vc_can_do_color;
3092 vc->vc_sw->con_deinit(vc);
3093 vc->vc_origin = (unsigned long)vc->vc_screenbuf;
3094 visual_init(vc, i, 0);
3095 set_origin(vc);
3096 update_attr(vc);
3097
3098 /* If the console changed between mono <-> color, then
3099 * the attributes in the screenbuf will be wrong. The
3100 * following resets all attributes to something sane.
3101 */
3102 if (old_was_color != vc->vc_can_do_color)
3103 clear_buffer_attributes(vc);
3104 }
3105
3106 printk("Console: switching ");
3107 if (!deflt)
3108 printk("consoles %d-%d ", first+1, last+1);
3109 if (j >= 0) {
3110 struct vc_data *vc = vc_cons[j].d;
3111
3112 printk("to %s %s %dx%d\n",
3113 vc->vc_can_do_color ? "colour" : "mono",
3114 desc, vc->vc_cols, vc->vc_rows);
3115
3116 if (k >= 0) {
3117 vc = vc_cons[k].d;
3118 update_screen(vc);
3119 }
3120 } else
3121 printk("to %s\n", desc);
3122
3123 retval = 0;
3124 err:
3125 console_unlock();
3126 module_put(owner);
3127 return retval;
3128 };
3129
3130 #ifdef CONFIG_VT_HW_CONSOLE_BINDING
3131 static int con_is_graphics(const struct consw *csw, int first, int last)
3132 {
3133 int i, retval = 0;
3134
3135 for (i = first; i <= last; i++) {
3136 struct vc_data *vc = vc_cons[i].d;
3137
3138 if (vc && vc->vc_mode == KD_GRAPHICS) {
3139 retval = 1;
3140 break;
3141 }
3142 }
3143
3144 return retval;
3145 }
3146
3147 /**
3148 * unbind_con_driver - unbind a console driver
3149 * @csw: pointer to console driver to unregister
3150 * @first: first in range of consoles that @csw should be unbound from
3151 * @last: last in range of consoles that @csw should be unbound from
3152 * @deflt: should next bound console driver be default after @csw is unbound?
3153 *
3154 * To unbind a driver from all possible consoles, pass 0 as @first and
3155 * %MAX_NR_CONSOLES as @last.
3156 *
3157 * @deflt controls whether the console that ends up replacing @csw should be
3158 * the default console.
3159 *
3160 * RETURNS:
3161 * -ENODEV if @csw isn't a registered console driver or can't be unregistered
3162 * or 0 on success.
3163 */
3164 int unbind_con_driver(const struct consw *csw, int first, int last, int deflt)
3165 {
3166 struct module *owner = csw->owner;
3167 const struct consw *defcsw = NULL;
3168 struct con_driver *con_driver = NULL, *con_back = NULL;
3169 int i, retval = -ENODEV;
3170
3171 if (!try_module_get(owner))
3172 return -ENODEV;
3173
3174 console_lock();
3175
3176 /* check if driver is registered and if it is unbindable */
3177 for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
3178 con_driver = &registered_con_driver[i];
3179
3180 if (con_driver->con == csw &&
3181 con_driver->flag & CON_DRIVER_FLAG_MODULE) {
3182 retval = 0;
3183 break;
3184 }
3185 }
3186
3187 if (retval) {
3188 console_unlock();
3189 goto err;
3190 }
3191
3192 retval = -ENODEV;
3193
3194 /* check if backup driver exists */
3195 for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
3196 con_back = &registered_con_driver[i];
3197
3198 if (con_back->con &&
3199 !(con_back->flag & CON_DRIVER_FLAG_MODULE)) {
3200 defcsw = con_back->con;
3201 retval = 0;
3202 break;
3203 }
3204 }
3205
3206 if (retval) {
3207 console_unlock();
3208 goto err;
3209 }
3210
3211 if (!con_is_bound(csw)) {
3212 console_unlock();
3213 goto err;
3214 }
3215
3216 first = max(first, con_driver->first);
3217 last = min(last, con_driver->last);
3218
3219 for (i = first; i <= last; i++) {
3220 if (con_driver_map[i] == csw) {
3221 module_put(csw->owner);
3222 con_driver_map[i] = NULL;
3223 }
3224 }
3225
3226 if (!con_is_bound(defcsw)) {
3227 const struct consw *defconsw = conswitchp;
3228
3229 defcsw->con_startup();
3230 con_back->flag |= CON_DRIVER_FLAG_INIT;
3231 /*
3232 * vgacon may change the default driver to point
3233 * to dummycon, we restore it here...
3234 */
3235 conswitchp = defconsw;
3236 }
3237
3238 if (!con_is_bound(csw))
3239 con_driver->flag &= ~CON_DRIVER_FLAG_INIT;
3240
3241 console_unlock();
3242 /* ignore return value, binding should not fail */
3243 bind_con_driver(defcsw, first, last, deflt);
3244 err:
3245 module_put(owner);
3246 return retval;
3247
3248 }
3249 EXPORT_SYMBOL(unbind_con_driver);
3250
3251 static int vt_bind(struct con_driver *con)
3252 {
3253 const struct consw *defcsw = NULL, *csw = NULL;
3254 int i, more = 1, first = -1, last = -1, deflt = 0;
3255
3256 if (!con->con || !(con->flag & CON_DRIVER_FLAG_MODULE) ||
3257 con_is_graphics(con->con, con->first, con->last))
3258 goto err;
3259
3260 csw = con->con;
3261
3262 for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
3263 struct con_driver *con = &registered_con_driver[i];
3264
3265 if (con->con && !(con->flag & CON_DRIVER_FLAG_MODULE)) {
3266 defcsw = con->con;
3267 break;
3268 }
3269 }
3270
3271 if (!defcsw)
3272 goto err;
3273
3274 while (more) {
3275 more = 0;
3276
3277 for (i = con->first; i <= con->last; i++) {
3278 if (con_driver_map[i] == defcsw) {
3279 if (first == -1)
3280 first = i;
3281 last = i;
3282 more = 1;
3283 } else if (first != -1)
3284 break;
3285 }
3286
3287 if (first == 0 && last == MAX_NR_CONSOLES -1)
3288 deflt = 1;
3289
3290 if (first != -1)
3291 bind_con_driver(csw, first, last, deflt);
3292
3293 first = -1;
3294 last = -1;
3295 deflt = 0;
3296 }
3297
3298 err:
3299 return 0;
3300 }
3301
3302 static int vt_unbind(struct con_driver *con)
3303 {
3304 const struct consw *csw = NULL;
3305 int i, more = 1, first = -1, last = -1, deflt = 0;
3306
3307 if (!con->con || !(con->flag & CON_DRIVER_FLAG_MODULE) ||
3308 con_is_graphics(con->con, con->first, con->last))
3309 goto err;
3310
3311 csw = con->con;
3312
3313 while (more) {
3314 more = 0;
3315
3316 for (i = con->first; i <= con->last; i++) {
3317 if (con_driver_map[i] == csw) {
3318 if (first == -1)
3319 first = i;
3320 last = i;
3321 more = 1;
3322 } else if (first != -1)
3323 break;
3324 }
3325
3326 if (first == 0 && last == MAX_NR_CONSOLES -1)
3327 deflt = 1;
3328
3329 if (first != -1)
3330 unbind_con_driver(csw, first, last, deflt);
3331
3332 first = -1;
3333 last = -1;
3334 deflt = 0;
3335 }
3336
3337 err:
3338 return 0;
3339 }
3340 #else
3341 static inline int vt_bind(struct con_driver *con)
3342 {
3343 return 0;
3344 }
3345 static inline int vt_unbind(struct con_driver *con)
3346 {
3347 return 0;
3348 }
3349 #endif /* CONFIG_VT_HW_CONSOLE_BINDING */
3350
3351 static ssize_t store_bind(struct device *dev, struct device_attribute *attr,
3352 const char *buf, size_t count)
3353 {
3354 struct con_driver *con = dev_get_drvdata(dev);
3355 int bind = simple_strtoul(buf, NULL, 0);
3356
3357 if (bind)
3358 vt_bind(con);
3359 else
3360 vt_unbind(con);
3361
3362 return count;
3363 }
3364
3365 static ssize_t show_bind(struct device *dev, struct device_attribute *attr,
3366 char *buf)
3367 {
3368 struct con_driver *con = dev_get_drvdata(dev);
3369 int bind = con_is_bound(con->con);
3370
3371 return snprintf(buf, PAGE_SIZE, "%i\n", bind);
3372 }
3373
3374 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
3375 char *buf)
3376 {
3377 struct con_driver *con = dev_get_drvdata(dev);
3378
3379 return snprintf(buf, PAGE_SIZE, "%s %s\n",
3380 (con->flag & CON_DRIVER_FLAG_MODULE) ? "(M)" : "(S)",
3381 con->desc);
3382
3383 }
3384
3385 static struct device_attribute device_attrs[] = {
3386 __ATTR(bind, S_IRUGO|S_IWUSR, show_bind, store_bind),
3387 __ATTR(name, S_IRUGO, show_name, NULL),
3388 };
3389
3390 static int vtconsole_init_device(struct con_driver *con)
3391 {
3392 int i;
3393 int error = 0;
3394
3395 con->flag |= CON_DRIVER_FLAG_ATTR;
3396 dev_set_drvdata(con->dev, con);
3397 for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
3398 error = device_create_file(con->dev, &device_attrs[i]);
3399 if (error)
3400 break;
3401 }
3402
3403 if (error) {
3404 while (--i >= 0)
3405 device_remove_file(con->dev, &device_attrs[i]);
3406 con->flag &= ~CON_DRIVER_FLAG_ATTR;
3407 }
3408
3409 return error;
3410 }
3411
3412 static void vtconsole_deinit_device(struct con_driver *con)
3413 {
3414 int i;
3415
3416 if (con->flag & CON_DRIVER_FLAG_ATTR) {
3417 for (i = 0; i < ARRAY_SIZE(device_attrs); i++)
3418 device_remove_file(con->dev, &device_attrs[i]);
3419 con->flag &= ~CON_DRIVER_FLAG_ATTR;
3420 }
3421 }
3422
3423 /**
3424 * con_is_bound - checks if driver is bound to the console
3425 * @csw: console driver
3426 *
3427 * RETURNS: zero if unbound, nonzero if bound
3428 *
3429 * Drivers can call this and if zero, they should release
3430 * all resources allocated on con_startup()
3431 */
3432 int con_is_bound(const struct consw *csw)
3433 {
3434 int i, bound = 0;
3435
3436 for (i = 0; i < MAX_NR_CONSOLES; i++) {
3437 if (con_driver_map[i] == csw) {
3438 bound = 1;
3439 break;
3440 }
3441 }
3442
3443 return bound;
3444 }
3445 EXPORT_SYMBOL(con_is_bound);
3446
3447 /**
3448 * con_debug_enter - prepare the console for the kernel debugger
3449 * @sw: console driver
3450 *
3451 * Called when the console is taken over by the kernel debugger, this
3452 * function needs to save the current console state, then put the console
3453 * into a state suitable for the kernel debugger.
3454 *
3455 * RETURNS:
3456 * Zero on success, nonzero if a failure occurred when trying to prepare
3457 * the console for the debugger.
3458 */
3459 int con_debug_enter(struct vc_data *vc)
3460 {
3461 int ret = 0;
3462
3463 saved_fg_console = fg_console;
3464 saved_last_console = last_console;
3465 saved_want_console = want_console;
3466 saved_vc_mode = vc->vc_mode;
3467 saved_console_blanked = console_blanked;
3468 vc->vc_mode = KD_TEXT;
3469 console_blanked = 0;
3470 if (vc->vc_sw->con_debug_enter)
3471 ret = vc->vc_sw->con_debug_enter(vc);
3472 #ifdef CONFIG_KGDB_KDB
3473 /* Set the initial LINES variable if it is not already set */
3474 if (vc->vc_rows < 999) {
3475 int linecount;
3476 char lns[4];
3477 const char *setargs[3] = {
3478 "set",
3479 "LINES",
3480 lns,
3481 };
3482 if (kdbgetintenv(setargs[0], &linecount)) {
3483 snprintf(lns, 4, "%i", vc->vc_rows);
3484 kdb_set(2, setargs);
3485 }
3486 }
3487 #endif /* CONFIG_KGDB_KDB */
3488 return ret;
3489 }
3490 EXPORT_SYMBOL_GPL(con_debug_enter);
3491
3492 /**
3493 * con_debug_leave - restore console state
3494 * @sw: console driver
3495 *
3496 * Restore the console state to what it was before the kernel debugger
3497 * was invoked.
3498 *
3499 * RETURNS:
3500 * Zero on success, nonzero if a failure occurred when trying to restore
3501 * the console.
3502 */
3503 int con_debug_leave(void)
3504 {
3505 struct vc_data *vc;
3506 int ret = 0;
3507
3508 fg_console = saved_fg_console;
3509 last_console = saved_last_console;
3510 want_console = saved_want_console;
3511 console_blanked = saved_console_blanked;
3512 vc_cons[fg_console].d->vc_mode = saved_vc_mode;
3513
3514 vc = vc_cons[fg_console].d;
3515 if (vc->vc_sw->con_debug_leave)
3516 ret = vc->vc_sw->con_debug_leave(vc);
3517 return ret;
3518 }
3519 EXPORT_SYMBOL_GPL(con_debug_leave);
3520
3521 /**
3522 * register_con_driver - register console driver to console layer
3523 * @csw: console driver
3524 * @first: the first console to take over, minimum value is 0
3525 * @last: the last console to take over, maximum value is MAX_NR_CONSOLES -1
3526 *
3527 * DESCRIPTION: This function registers a console driver which can later
3528 * bind to a range of consoles specified by @first and @last. It will
3529 * also initialize the console driver by calling con_startup().
3530 */
3531 int register_con_driver(const struct consw *csw, int first, int last)
3532 {
3533 struct module *owner = csw->owner;
3534 struct con_driver *con_driver;
3535 const char *desc;
3536 int i, retval = 0;
3537
3538 if (!try_module_get(owner))
3539 return -ENODEV;
3540
3541 console_lock();
3542
3543 for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
3544 con_driver = &registered_con_driver[i];
3545
3546 /* already registered */
3547 if (con_driver->con == csw)
3548 retval = -EBUSY;
3549 }
3550
3551 if (retval)
3552 goto err;
3553
3554 desc = csw->con_startup();
3555
3556 if (!desc)
3557 goto err;
3558
3559 retval = -EINVAL;
3560
3561 for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
3562 con_driver = &registered_con_driver[i];
3563
3564 if (con_driver->con == NULL) {
3565 con_driver->con = csw;
3566 con_driver->desc = desc;
3567 con_driver->node = i;
3568 con_driver->flag = CON_DRIVER_FLAG_MODULE |
3569 CON_DRIVER_FLAG_INIT;
3570 con_driver->first = first;
3571 con_driver->last = last;
3572 retval = 0;
3573 break;
3574 }
3575 }
3576
3577 if (retval)
3578 goto err;
3579
3580 con_driver->dev = device_create(vtconsole_class, NULL,
3581 MKDEV(0, con_driver->node),
3582 NULL, "vtcon%i",
3583 con_driver->node);
3584
3585 if (IS_ERR(con_driver->dev)) {
3586 printk(KERN_WARNING "Unable to create device for %s; "
3587 "errno = %ld\n", con_driver->desc,
3588 PTR_ERR(con_driver->dev));
3589 con_driver->dev = NULL;
3590 } else {
3591 vtconsole_init_device(con_driver);
3592 }
3593
3594 err:
3595 console_unlock();
3596 module_put(owner);
3597 return retval;
3598 }
3599 EXPORT_SYMBOL(register_con_driver);
3600
3601 /**
3602 * unregister_con_driver - unregister console driver from console layer
3603 * @csw: console driver
3604 *
3605 * DESCRIPTION: All drivers that registers to the console layer must
3606 * call this function upon exit, or if the console driver is in a state
3607 * where it won't be able to handle console services, such as the
3608 * framebuffer console without loaded framebuffer drivers.
3609 *
3610 * The driver must unbind first prior to unregistration.
3611 */
3612 int unregister_con_driver(const struct consw *csw)
3613 {
3614 int i, retval = -ENODEV;
3615
3616 console_lock();
3617
3618 /* cannot unregister a bound driver */
3619 if (con_is_bound(csw))
3620 goto err;
3621
3622 for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
3623 struct con_driver *con_driver = &registered_con_driver[i];
3624
3625 if (con_driver->con == csw &&
3626 con_driver->flag & CON_DRIVER_FLAG_MODULE) {
3627 vtconsole_deinit_device(con_driver);
3628 device_destroy(vtconsole_class,
3629 MKDEV(0, con_driver->node));
3630 con_driver->con = NULL;
3631 con_driver->desc = NULL;
3632 con_driver->dev = NULL;
3633 con_driver->node = 0;
3634 con_driver->flag = 0;
3635 con_driver->first = 0;
3636 con_driver->last = 0;
3637 retval = 0;
3638 break;
3639 }
3640 }
3641 err:
3642 console_unlock();
3643 return retval;
3644 }
3645 EXPORT_SYMBOL(unregister_con_driver);
3646
3647 /*
3648 * If we support more console drivers, this function is used
3649 * when a driver wants to take over some existing consoles
3650 * and become default driver for newly opened ones.
3651 *
3652 * take_over_console is basically a register followed by unbind
3653 */
3654 int take_over_console(const struct consw *csw, int first, int last, int deflt)
3655 {
3656 int err;
3657
3658 err = register_con_driver(csw, first, last);
3659 /* if we get an busy error we still want to bind the console driver
3660 * and return success, as we may have unbound the console driver
3661  * but not unregistered it.
3662 */
3663 if (err == -EBUSY)
3664 err = 0;
3665 if (!err)
3666 bind_con_driver(csw, first, last, deflt);
3667
3668 return err;
3669 }
3670
3671 /*
3672 * give_up_console is a wrapper to unregister_con_driver. It will only
3673 * work if driver is fully unbound.
3674 */
3675 void give_up_console(const struct consw *csw)
3676 {
3677 unregister_con_driver(csw);
3678 }
3679
3680 static int __init vtconsole_class_init(void)
3681 {
3682 int i;
3683
3684 vtconsole_class = class_create(THIS_MODULE, "vtconsole");
3685 if (IS_ERR(vtconsole_class)) {
3686 printk(KERN_WARNING "Unable to create vt console class; "
3687 "errno = %ld\n", PTR_ERR(vtconsole_class));
3688 vtconsole_class = NULL;
3689 }
3690
3691 /* Add system drivers to sysfs */
3692 for (i = 0; i < MAX_NR_CON_DRIVER; i++) {
3693 struct con_driver *con = &registered_con_driver[i];
3694
3695 if (con->con && !con->dev) {
3696 con->dev = device_create(vtconsole_class, NULL,
3697 MKDEV(0, con->node),
3698 NULL, "vtcon%i",
3699 con->node);
3700
3701 if (IS_ERR(con->dev)) {
3702 printk(KERN_WARNING "Unable to create "
3703 "device for %s; errno = %ld\n",
3704 con->desc, PTR_ERR(con->dev));
3705 con->dev = NULL;
3706 } else {
3707 vtconsole_init_device(con);
3708 }
3709 }
3710 }
3711
3712 return 0;
3713 }
3714 postcore_initcall(vtconsole_class_init);
3715
3716 #endif
3717
3718 /*
3719 * Screen blanking
3720 */
3721
3722 static int set_vesa_blanking(char __user *p)
3723 {
3724 unsigned int mode;
3725
3726 if (get_user(mode, p + 1))
3727 return -EFAULT;
3728
3729 vesa_blank_mode = (mode < 4) ? mode : 0;
3730 return 0;
3731 }
3732
3733 void do_blank_screen(int entering_gfx)
3734 {
3735 struct vc_data *vc = vc_cons[fg_console].d;
3736 int i;
3737
3738 WARN_CONSOLE_UNLOCKED();
3739
3740 if (console_blanked) {
3741 if (blank_state == blank_vesa_wait) {
3742 blank_state = blank_off;
3743 vc->vc_sw->con_blank(vc, vesa_blank_mode + 1, 0);
3744 }
3745 return;
3746 }
3747
3748 /* entering graphics mode? */
3749 if (entering_gfx) {
3750 hide_cursor(vc);
3751 save_screen(vc);
3752 vc->vc_sw->con_blank(vc, -1, 1);
3753 console_blanked = fg_console + 1;
3754 blank_state = blank_off;
3755 set_origin(vc);
3756 return;
3757 }
3758
3759 if (blank_state != blank_normal_wait)
3760 return;
3761 blank_state = blank_off;
3762
3763 /* don't blank graphics */
3764 if (vc->vc_mode != KD_TEXT) {
3765 console_blanked = fg_console + 1;
3766 return;
3767 }
3768
3769 hide_cursor(vc);
3770 del_timer_sync(&console_timer);
3771 blank_timer_expired = 0;
3772
3773 save_screen(vc);
3774 /* In case we need to reset origin, blanking hook returns 1 */
3775 i = vc->vc_sw->con_blank(vc, vesa_off_interval ? 1 : (vesa_blank_mode + 1), 0);
3776 console_blanked = fg_console + 1;
3777 if (i)
3778 set_origin(vc);
3779
3780 if (console_blank_hook && console_blank_hook(1))
3781 return;
3782
3783 if (vesa_off_interval && vesa_blank_mode) {
3784 blank_state = blank_vesa_wait;
3785 mod_timer(&console_timer, jiffies + vesa_off_interval);
3786 }
3787 vt_event_post(VT_EVENT_BLANK, vc->vc_num, vc->vc_num);
3788 }
3789 EXPORT_SYMBOL(do_blank_screen);
3790
3791 /*
3792 * Called by timer as well as from vt_console_driver
3793 */
3794 void do_unblank_screen(int leaving_gfx)
3795 {
3796 struct vc_data *vc;
3797
3798 /* This should now always be called from a "sane" (read: can schedule)
3799 * context for the sake of the low level drivers, except in the special
3800 * case of oops_in_progress
3801 */
3802 if (!oops_in_progress)
3803 might_sleep();
3804
3805 WARN_CONSOLE_UNLOCKED();
3806
3807 ignore_poke = 0;
3808 if (!console_blanked)
3809 return;
3810 if (!vc_cons_allocated(fg_console)) {
3811 /* impossible */
3812 printk("unblank_screen: tty %d not allocated ??\n", fg_console+1);
3813 return;
3814 }
3815 vc = vc_cons[fg_console].d;
3816 /* Try to unblank in oops case too */
3817 if (vc->vc_mode != KD_TEXT && !vt_force_oops_output(vc))
3818 return; /* but leave console_blanked != 0 */
3819
3820 if (blankinterval) {
3821 mod_timer(&console_timer, jiffies + (blankinterval * HZ));
3822 blank_state = blank_normal_wait;
3823 }
3824
3825 console_blanked = 0;
3826 if (vc->vc_sw->con_blank(vc, 0, leaving_gfx) || vt_force_oops_output(vc))
3827 /* Low-level driver cannot restore -> do it ourselves */
3828 update_screen(vc);
3829 if (console_blank_hook)
3830 console_blank_hook(0);
3831 set_palette(vc);
3832 set_cursor(vc);
3833 vt_event_post(VT_EVENT_UNBLANK, vc->vc_num, vc->vc_num);
3834 }
3835 EXPORT_SYMBOL(do_unblank_screen);
3836
3837 /*
3838 * This is called by the outside world to cause a forced unblank, mostly for
3839 * oopses. Currently, I just call do_unblank_screen(0), but we could eventually
3840 * call it with 1 as an argument and so force a mode restore... that may kill
3841 * X or at least garbage the screen but would also make the Oops visible...
3842 */
3843 void unblank_screen(void)
3844 {
3845 do_unblank_screen(0);
3846 }
3847
3848 /*
3849 * We defer the timer blanking to work queue so it can take the console mutex
3850 * (console operations can still happen at irq time, but only from printk which
3851 * has the console mutex. Not perfect yet, but better than no locking
3852 */
3853 static void blank_screen_t(unsigned long dummy)
3854 {
3855 if (unlikely(!keventd_up())) {
3856 mod_timer(&console_timer, jiffies + (blankinterval * HZ));
3857 return;
3858 }
3859 blank_timer_expired = 1;
3860 schedule_work(&console_work);
3861 }
3862
3863 void poke_blanked_console(void)
3864 {
3865 WARN_CONSOLE_UNLOCKED();
3866
3867 /* Add this so we quickly catch whoever might call us in a non
3868 * safe context. Nowadays, unblank_screen() isn't to be called in
3869 * atomic contexts and is allowed to schedule (with the special case
3870 * of oops_in_progress, but that isn't of any concern for this
3871 * function. --BenH.
3872 */
3873 might_sleep();
3874
3875 /* This isn't perfectly race free, but a race here would be mostly harmless,
3876 * at worse, we'll do a spurrious blank and it's unlikely
3877 */
3878 del_timer(&console_timer);
3879 blank_timer_expired = 0;
3880
3881 if (ignore_poke || !vc_cons[fg_console].d || vc_cons[fg_console].d->vc_mode == KD_GRAPHICS)
3882 return;
3883 if (console_blanked)
3884 unblank_screen();
3885 else if (blankinterval) {
3886 mod_timer(&console_timer, jiffies + (blankinterval * HZ));
3887 blank_state = blank_normal_wait;
3888 }
3889 }
3890
3891 /*
3892 * Palettes
3893 */
3894
3895 static void set_palette(struct vc_data *vc)
3896 {
3897 WARN_CONSOLE_UNLOCKED();
3898
3899 if (vc->vc_mode != KD_GRAPHICS)
3900 vc->vc_sw->con_set_palette(vc, color_table);
3901 }
3902
3903 static int set_get_cmap(unsigned char __user *arg, int set)
3904 {
3905 int i, j, k;
3906
3907 WARN_CONSOLE_UNLOCKED();
3908
3909 for (i = 0; i < 16; i++)
3910 if (set) {
3911 get_user(default_red[i], arg++);
3912 get_user(default_grn[i], arg++);
3913 get_user(default_blu[i], arg++);
3914 } else {
3915 put_user(default_red[i], arg++);
3916 put_user(default_grn[i], arg++);
3917 put_user(default_blu[i], arg++);
3918 }
3919 if (set) {
3920 for (i = 0; i < MAX_NR_CONSOLES; i++)
3921 if (vc_cons_allocated(i)) {
3922 for (j = k = 0; j < 16; j++) {
3923 vc_cons[i].d->vc_palette[k++] = default_red[j];
3924 vc_cons[i].d->vc_palette[k++] = default_grn[j];
3925 vc_cons[i].d->vc_palette[k++] = default_blu[j];
3926 }
3927 set_palette(vc_cons[i].d);
3928 }
3929 }
3930 return 0;
3931 }
3932
3933 /*
3934 * Load palette into the DAC registers. arg points to a colour
3935 * map, 3 bytes per colour, 16 colours, range from 0 to 255.
3936 */
3937
3938 int con_set_cmap(unsigned char __user *arg)
3939 {
3940 int rc;
3941
3942 console_lock();
3943 rc = set_get_cmap (arg,1);
3944 console_unlock();
3945
3946 return rc;
3947 }
3948
3949 int con_get_cmap(unsigned char __user *arg)
3950 {
3951 int rc;
3952
3953 console_lock();
3954 rc = set_get_cmap (arg,0);
3955 console_unlock();
3956
3957 return rc;
3958 }
3959
3960 void reset_palette(struct vc_data *vc)
3961 {
3962 int j, k;
3963 for (j=k=0; j<16; j++) {
3964 vc->vc_palette[k++] = default_red[j];
3965 vc->vc_palette[k++] = default_grn[j];
3966 vc->vc_palette[k++] = default_blu[j];
3967 }
3968 set_palette(vc);
3969 }
3970
3971 /*
3972 * Font switching
3973 *
3974 * Currently we only support fonts up to 32 pixels wide, at a maximum height
3975 * of 32 pixels. Userspace fontdata is stored with 32 bytes (shorts/ints,
3976 * depending on width) reserved for each character which is kinda wasty, but
3977 * this is done in order to maintain compatibility with the EGA/VGA fonts. It
3978 * is upto the actual low-level console-driver convert data into its favorite
3979 * format (maybe we should add a `fontoffset' field to the `display'
3980 * structure so we won't have to convert the fontdata all the time.
3981 * /Jes
3982 */
3983
3984 #define max_font_size 65536
3985
3986 static int con_font_get(struct vc_data *vc, struct console_font_op *op)
3987 {
3988 struct console_font font;
3989 int rc = -EINVAL;
3990 int c;
3991
3992 if (vc->vc_mode != KD_TEXT)
3993 return -EINVAL;
3994
3995 if (op->data) {
3996 font.data = kmalloc(max_font_size, GFP_KERNEL);
3997 if (!font.data)
3998 return -ENOMEM;
3999 } else
4000 font.data = NULL;
4001
4002 console_lock();
4003 if (vc->vc_sw->con_font_get)
4004 rc = vc->vc_sw->con_font_get(vc, &font);
4005 else
4006 rc = -ENOSYS;
4007 console_unlock();
4008
4009 if (rc)
4010 goto out;
4011
4012 c = (font.width+7)/8 * 32 * font.charcount;
4013
4014 if (op->data && font.charcount > op->charcount)
4015 rc = -ENOSPC;
4016 if (!(op->flags & KD_FONT_FLAG_OLD)) {
4017 if (font.width > op->width || font.height > op->height)
4018 rc = -ENOSPC;
4019 } else {
4020 if (font.width != 8)
4021 rc = -EIO;
4022 else if ((op->height && font.height > op->height) ||
4023 font.height > 32)
4024 rc = -ENOSPC;
4025 }
4026 if (rc)
4027 goto out;
4028
4029 op->height = font.height;
4030 op->width = font.width;
4031 op->charcount = font.charcount;
4032
4033 if (op->data && copy_to_user(op->data, font.data, c))
4034 rc = -EFAULT;
4035
4036 out:
4037 kfree(font.data);
4038 return rc;
4039 }
4040
4041 static int con_font_set(struct vc_data *vc, struct console_font_op *op)
4042 {
4043 struct console_font font;
4044 int rc = -EINVAL;
4045 int size;
4046
4047 if (vc->vc_mode != KD_TEXT)
4048 return -EINVAL;
4049 if (!op->data)
4050 return -EINVAL;
4051 if (op->charcount > 512)
4052 return -EINVAL;
4053 if (!op->height) { /* Need to guess font height [compat] */
4054 int h, i;
4055 u8 __user *charmap = op->data;
4056 u8 tmp;
4057
4058 /* If from KDFONTOP ioctl, don't allow things which can be done in userland,
4059 so that we can get rid of this soon */
4060 if (!(op->flags & KD_FONT_FLAG_OLD))
4061 return -EINVAL;
4062 for (h = 32; h > 0; h--)
4063 for (i = 0; i < op->charcount; i++) {
4064 if (get_user(tmp, &charmap[32*i+h-1]))
4065 return -EFAULT;
4066 if (tmp)
4067 goto nonzero;
4068 }
4069 return -EINVAL;
4070 nonzero:
4071 op->height = h;
4072 }
4073 if (op->width <= 0 || op->width > 32 || op->height > 32)
4074 return -EINVAL;
4075 size = (op->width+7)/8 * 32 * op->charcount;
4076 if (size > max_font_size)
4077 return -ENOSPC;
4078 font.charcount = op->charcount;
4079 font.height = op->height;
4080 font.width = op->width;
4081 font.data = memdup_user(op->data, size);
4082 if (IS_ERR(font.data))
4083 return PTR_ERR(font.data);
4084 console_lock();
4085 if (vc->vc_sw->con_font_set)
4086 rc = vc->vc_sw->con_font_set(vc, &font, op->flags);
4087 else
4088 rc = -ENOSYS;
4089 console_unlock();
4090 kfree(font.data);
4091 return rc;
4092 }
4093
4094 static int con_font_default(struct vc_data *vc, struct console_font_op *op)
4095 {
4096 struct console_font font = {.width = op->width, .height = op->height};
4097 char name[MAX_FONT_NAME];
4098 char *s = name;
4099 int rc;
4100
4101 if (vc->vc_mode != KD_TEXT)
4102 return -EINVAL;
4103
4104 if (!op->data)
4105 s = NULL;
4106 else if (strncpy_from_user(name, op->data, MAX_FONT_NAME - 1) < 0)
4107 return -EFAULT;
4108 else
4109 name[MAX_FONT_NAME - 1] = 0;
4110
4111 console_lock();
4112 if (vc->vc_sw->con_font_default)
4113 rc = vc->vc_sw->con_font_default(vc, &font, s);
4114 else
4115 rc = -ENOSYS;
4116 console_unlock();
4117 if (!rc) {
4118 op->width = font.width;
4119 op->height = font.height;
4120 }
4121 return rc;
4122 }
4123
4124 static int con_font_copy(struct vc_data *vc, struct console_font_op *op)
4125 {
4126 int con = op->height;
4127 int rc;
4128
4129 if (vc->vc_mode != KD_TEXT)
4130 return -EINVAL;
4131
4132 console_lock();
4133 if (!vc->vc_sw->con_font_copy)
4134 rc = -ENOSYS;
4135 else if (con < 0 || !vc_cons_allocated(con))
4136 rc = -ENOTTY;
4137 else if (con == vc->vc_num) /* nothing to do */
4138 rc = 0;
4139 else
4140 rc = vc->vc_sw->con_font_copy(vc, con);
4141 console_unlock();
4142 return rc;
4143 }
4144
4145 int con_font_op(struct vc_data *vc, struct console_font_op *op)
4146 {
4147 switch (op->op) {
4148 case KD_FONT_OP_SET:
4149 return con_font_set(vc, op);
4150 case KD_FONT_OP_GET:
4151 return con_font_get(vc, op);
4152 case KD_FONT_OP_SET_DEFAULT:
4153 return con_font_default(vc, op);
4154 case KD_FONT_OP_COPY:
4155 return con_font_copy(vc, op);
4156 }
4157 return -ENOSYS;
4158 }
4159
4160 /*
4161 * Interface exported to selection and vcs.
4162 */
4163
4164 /* used by selection */
4165 u16 screen_glyph(struct vc_data *vc, int offset)
4166 {
4167 u16 w = scr_readw(screenpos(vc, offset, 1));
4168 u16 c = w & 0xff;
4169
4170 if (w & vc->vc_hi_font_mask)
4171 c |= 0x100;
4172 return c;
4173 }
4174 EXPORT_SYMBOL_GPL(screen_glyph);
4175
4176 /* used by vcs - note the word offset */
4177 unsigned short *screen_pos(struct vc_data *vc, int w_offset, int viewed)
4178 {
4179 return screenpos(vc, 2 * w_offset, viewed);
4180 }
4181
4182 void getconsxy(struct vc_data *vc, unsigned char *p)
4183 {
4184 p[0] = vc->vc_x;
4185 p[1] = vc->vc_y;
4186 }
4187
4188 void putconsxy(struct vc_data *vc, unsigned char *p)
4189 {
4190 hide_cursor(vc);
4191 gotoxy(vc, p[0], p[1]);
4192 set_cursor(vc);
4193 }
4194
4195 u16 vcs_scr_readw(struct vc_data *vc, const u16 *org)
4196 {
4197 if ((unsigned long)org == vc->vc_pos && softcursor_original != -1)
4198 return softcursor_original;
4199 return scr_readw(org);
4200 }
4201
4202 void vcs_scr_writew(struct vc_data *vc, u16 val, u16 *org)
4203 {
4204 scr_writew(val, org);
4205 if ((unsigned long)org == vc->vc_pos) {
4206 softcursor_original = -1;
4207 add_softcursor(vc);
4208 }
4209 }
4210
4211 void vcs_scr_updated(struct vc_data *vc)
4212 {
4213 notify_update(vc);
4214 }
4215
4216 /*
4217 * Visible symbols for modules
4218 */
4219
4220 EXPORT_SYMBOL(color_table);
4221 EXPORT_SYMBOL(default_red);
4222 EXPORT_SYMBOL(default_grn);
4223 EXPORT_SYMBOL(default_blu);
4224 EXPORT_SYMBOL(update_region);
4225 EXPORT_SYMBOL(redraw_screen);
4226 EXPORT_SYMBOL(vc_resize);
4227 EXPORT_SYMBOL(fg_console);
4228 EXPORT_SYMBOL(console_blank_hook);
4229 EXPORT_SYMBOL(console_blanked);
4230 EXPORT_SYMBOL(vc_cons);
4231 EXPORT_SYMBOL(global_cursor_default);
4232 #ifndef VT_SINGLE_DRIVER
4233 EXPORT_SYMBOL(take_over_console);
4234 EXPORT_SYMBOL(give_up_console);
4235 #endif
ubuntu-bionic-kernel mirror