source: src/linux/universal/linux-3.18/drivers/tty/vt/vt.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 6 weeks ago

update

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