[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [PATCH 2/3] remove console_macros.h
Now its starting to look like the linuxconsole project :-)
On Sat, 15 Jan 2005, Roman Zippel wrote:
> Hi,
>
> Remove the macros in console_macros.h and so make the structure references
> explicit.
>
> Signed-off-by: Roman Zippel <zippel@xxxxxxxxxxxxxx>
>
> drivers/char/console_macros.h | 71 --
> linux-2.6-vc/drivers/char/vt.c | 1035 ++++++++++++++++++++---------------------
> 2 files changed, 523 insertions(+), 583 deletions(-)
>
> Index: linux-2.6-vc/drivers/char/console_macros.h
> ===================================================================
> --- linux-2.6-vc.orig/drivers/char/console_macros.h 2005-01-14 22:15:55.896858073 +0100
> +++ /dev/null 1970-01-01 00:00:00.000000000 +0000
> @@ -1,71 +0,0 @@
> -#define cons_num (vc->vc_num)
> -#define video_scan_lines (vc->vc_scan_lines)
> -#define sw (vc->vc_sw)
> -#define screenbuf (vc->vc_screenbuf)
> -#define screenbuf_size (vc->vc_screenbuf_size)
> -#define origin (vc->vc_origin)
> -#define scr_top (vc->vc_scr_top)
> -#define visible_origin (vc->vc_visible_origin)
> -#define scr_end (vc->vc_scr_end)
> -#define pos (vc->vc_pos)
> -#define top (vc->vc_top)
> -#define bottom (vc->vc_bottom)
> -#define x (vc->vc_x)
> -#define y (vc->vc_y)
> -#define vc_state (vc->vc_state)
> -#define npar (vc->vc_npar)
> -#define par (vc->vc_par)
> -#define ques (vc->vc_ques)
> -#define attr (vc->vc_attr)
> -#define saved_x (vc->vc_saved_x)
> -#define saved_y (vc->vc_saved_y)
> -#define translate (vc->vc_translate)
> -#define G0_charset (vc->vc_G0_charset)
> -#define G1_charset (vc->vc_G1_charset)
> -#define saved_G0 (vc->vc_saved_G0)
> -#define saved_G1 (vc->vc_saved_G1)
> -#define utf (vc->vc_utf)
> -#define utf_count (vc->vc_utf_count)
> -#define utf_char (vc->vc_utf_char)
> -#define video_erase_char (vc->vc_video_erase_char)
> -#define disp_ctrl (vc->vc_disp_ctrl)
> -#define toggle_meta (vc->vc_toggle_meta)
> -#define decscnm (vc->vc_decscnm)
> -#define decom (vc->vc_decom)
> -#define decawm (vc->vc_decawm)
> -#define deccm (vc->vc_deccm)
> -#define decim (vc->vc_decim)
> -#define deccolm (vc->vc_deccolm)
> -#define need_wrap (vc->vc_need_wrap)
> -#define kmalloced (vc->vc_kmalloced)
> -#define report_mouse (vc->vc_report_mouse)
> -#define color (vc->vc_color)
> -#define s_color (vc->vc_s_color)
> -#define def_color (vc->vc_def_color)
> -#define foreground (color & 0x0f)
> -#define background (color & 0xf0)
> -#define charset (vc->vc_charset)
> -#define s_charset (vc->vc_s_charset)
> -#define intensity (vc->vc_intensity)
> -#define underline (vc->vc_underline)
> -#define blink (vc->vc_blink)
> -#define reverse (vc->vc_reverse)
> -#define s_intensity (vc->vc_s_intensity)
> -#define s_underline (vc->vc_s_underline)
> -#define s_blink (vc->vc_s_blink)
> -#define s_reverse (vc->vc_s_reverse)
> -#define ulcolor (vc->vc_ulcolor)
> -#define halfcolor (vc->vc_halfcolor)
> -#define tab_stop (vc->vc_tab_stop)
> -#define palette (vc->vc_palette)
> -#define bell_pitch (vc->vc_bell_pitch)
> -#define bell_duration (vc->vc_bell_duration)
> -#define cursor_type (vc->vc_cursor_type)
> -#define display_fg (vc->vc_display_fg)
> -#define complement_mask (vc->vc_complement_mask)
> -#define s_complement_mask (vc->vc_s_complement_mask)
> -#define hi_font_mask (vc->vc_hi_font_mask)
> -
> -#define vcmode (vt_cons[vc->vc_num]->vc_mode)
> -
> -#define structsize (sizeof(struct vc_data) + sizeof(struct vt_struct))
> Index: linux-2.6-vc/drivers/char/vt.c
> ===================================================================
> --- linux-2.6-vc.orig/drivers/char/vt.c 2005-01-14 22:15:55.894858418 +0100
> +++ linux-2.6-vc/drivers/char/vt.c 2005-01-14 22:16:13.448833821 +0100
> @@ -98,8 +98,6 @@
> #include <asm/system.h>
> #include <asm/uaccess.h>
>
> -#include "console_macros.h"
> -
>
> const struct consw *conswitchp;
>
> @@ -255,12 +253,12 @@ static void scrup(struct vc_data *vc, un
> nr = b - t - 1;
> if (b > vc->vc_rows || t >= b || nr < 1)
> return;
> - if (CON_IS_VISIBLE(vc) && sw->con_scroll(vc, t, b, SM_UP, nr))
> + if (CON_IS_VISIBLE(vc) && vc->vc_sw->con_scroll(vc, t, b, SM_UP, nr))
> return;
> - d = (unsigned short *)(origin + vc->vc_size_row * t);
> - s = (unsigned short *)(origin + vc->vc_size_row * (t + nr));
> + d = (unsigned short *)(vc->vc_origin + vc->vc_size_row * t);
> + s = (unsigned short *)(vc->vc_origin + vc->vc_size_row * (t + nr));
> scr_memmovew(d, s, (b - t - nr) * vc->vc_size_row);
> - scr_memsetw(d + (b - t - nr) * vc->vc_cols, video_erase_char,
> + scr_memsetw(d + (b - t - nr) * vc->vc_cols, vc->vc_video_erase_char,
> vc->vc_size_row * nr);
> }
>
> @@ -273,12 +271,12 @@ static void scrdown(struct vc_data *vc,
> nr = b - t - 1;
> if (b > vc->vc_rows || t >= b || nr < 1)
> return;
> - if (CON_IS_VISIBLE(vc) && sw->con_scroll(vc, t, b, SM_DOWN, nr))
> + if (CON_IS_VISIBLE(vc) && vc->vc_sw->con_scroll(vc, t, b, SM_DOWN, nr))
> return;
> - s = (unsigned short *)(origin + vc->vc_size_row * t);
> + s = (unsigned short *)(vc->vc_origin + vc->vc_size_row * t);
> step = vc->vc_cols * nr;
> scr_memmovew(s + step, s, (b - t - nr) * vc->vc_size_row);
> - scr_memsetw(s, video_erase_char, 2*step);
> + scr_memsetw(s, vc->vc_video_erase_char, 2 * step);
> }
>
> static void do_update_region(struct vc_data *vc, unsigned long start, int count)
> @@ -342,8 +340,8 @@ void update_region(struct vc_data *vc, u
>
> static u8 build_attr(struct vc_data *vc, u8 _color, u8 _intensity, u8 _blink, u8 _underline, u8 _reverse)
> {
> - if (sw->con_build_attr)
> - return sw->con_build_attr(vc, _color, _intensity, _blink, _underline, _reverse);
> + if (vc->vc_sw->con_build_attr)
> + return vc->vc_sw->con_build_attr(vc, _color, _intensity, _blink, _underline, _reverse);
>
> #ifndef VT_BUF_VRAM_ONLY
> /*
> @@ -357,23 +355,23 @@ static u8 build_attr(struct vc_data *vc,
> * Bit 7 : blink
> */
> {
> - u8 a = color;
> + u8 a = vc->vc_color;
> if (!vc->vc_can_do_color)
> return _intensity |
> (_underline ? 4 : 0) |
> (_reverse ? 8 : 0) |
> (_blink ? 0x80 : 0);
> if (_underline)
> - a = (a & 0xf0) | ulcolor;
> + a = (a & 0xf0) | vc->vc_ulcolor;
> else if (_intensity == 0)
> - a = (a & 0xf0) | halfcolor;
> + a = (a & 0xf0) | vc->vc_ulcolor;
> if (_reverse)
> a = ((a) & 0x88) | ((((a) >> 4) | ((a) << 4)) & 0x77);
> if (_blink)
> a ^= 0x80;
> if (_intensity == 2)
> a ^= 0x08;
> - if (hi_font_mask == 0x100)
> + if (vc->vc_hi_font_mask == 0x100)
> a <<= 1;
> return a;
> }
> @@ -384,8 +382,8 @@ static u8 build_attr(struct vc_data *vc,
>
> static void update_attr(struct vc_data *vc)
> {
> - attr = build_attr(vc, color, intensity, blink, underline, reverse ^ decscnm);
> - video_erase_char = (build_attr(vc, color, 1, blink, 0, decscnm) << 8) | ' ';
> + vc->vc_attr = build_attr(vc, vc->vc_color, vc->vc_intensity, vc->vc_blink, vc->vc_underline, vc->vc_reverse ^ vc->vc_decscnm);
> + vc->vc_video_erase_char = (build_attr(vc, vc->vc_color, 1, vc->vc_blink, 0, vc->vc_decscnm) << 8) | ' ';
> }
>
> /* Note: inverting the screen twice should revert to the original state */
> @@ -465,44 +463,44 @@ void complement_pos(struct vc_data *vc,
>
> static void insert_char(struct vc_data *vc, unsigned int nr)
> {
> - unsigned short *p, *q = (unsigned short *) pos;
> + unsigned short *p, *q = (unsigned short *)vc->vc_pos;
>
> - p = q + vc->vc_cols - nr - x;
> + p = q + vc->vc_cols - nr - vc->vc_x;
> while (--p >= q)
> scr_writew(scr_readw(p), p + nr);
> - scr_memsetw(q, video_erase_char, nr*2);
> - need_wrap = 0;
> + scr_memsetw(q, vc->vc_video_erase_char, nr * 2);
> + vc->vc_need_wrap = 0;
> if (DO_UPDATE(vc)) {
> - unsigned short oldattr = attr;
> - sw->con_bmove(vc, y, x, y, x + nr, 1,
> - vc->vc_cols - x - nr);
> - attr = video_erase_char >> 8;
> + unsigned short oldattr = vc->vc_attr;
> + vc->vc_sw->con_bmove(vc, vc->vc_y, vc->vc_x, vc->vc_y, vc->vc_x + nr, 1,
> + vc->vc_cols - vc->vc_x - nr);
> + vc->vc_attr = vc->vc_video_erase_char >> 8;
> while (nr--)
> - sw->con_putc(vc, video_erase_char, y, x + nr);
> - attr = oldattr;
> + vc->vc_sw->con_putc(vc, vc->vc_video_erase_char, vc->vc_y, vc->vc_x + nr);
> + vc->vc_attr = oldattr;
> }
> }
>
> static void delete_char(struct vc_data *vc, unsigned int nr)
> {
> - unsigned int i = x;
> - unsigned short *p = (unsigned short *) pos;
> + unsigned int i = vc->vc_x;
> + unsigned short *p = (unsigned short *)vc->vc_pos;
>
> while (++i <= vc->vc_cols - nr) {
> scr_writew(scr_readw(p+nr), p);
> p++;
> }
> - scr_memsetw(p, video_erase_char, nr*2);
> - need_wrap = 0;
> + scr_memsetw(p, vc->vc_video_erase_char, nr * 2);
> + vc->vc_need_wrap = 0;
> if (DO_UPDATE(vc)) {
> - unsigned short oldattr = attr;
> - sw->con_bmove(vc, y, x + nr, y, x, 1,
> - vc->vc_cols - x - nr);
> - attr = video_erase_char >> 8;
> + unsigned short oldattr = vc->vc_attr;
> + vc->vc_sw->con_bmove(vc, vc->vc_y, vc->vc_x + nr, vc->vc_y, vc->vc_x, 1,
> + vc->vc_cols - vc->vc_x - nr);
> + vc->vc_attr = vc->vc_video_erase_char >> 8;
> while (nr--)
> - sw->con_putc(vc, video_erase_char, y,
> + vc->vc_sw->con_putc(vc, vc->vc_video_erase_char, vc->vc_y,
> vc->vc_cols - 1 - nr);
> - attr = oldattr;
> + vc->vc_attr = oldattr;
> }
> }
>
> @@ -564,20 +562,20 @@ static void set_origin(struct vc_data *v
> WARN_CONSOLE_UNLOCKED();
>
> if (!CON_IS_VISIBLE(vc) ||
> - !sw->con_set_origin ||
> - !sw->con_set_origin(vc))
> - origin = (unsigned long) screenbuf;
> - visible_origin = origin;
> - scr_end = origin + screenbuf_size;
> - pos = origin + vc->vc_size_row * y + 2 * x;
> + !vc->vc_sw->con_set_origin ||
> + !vc->vc_sw->con_set_origin(vc))
> + vc->vc_origin = (unsigned long)vc->vc_screenbuf;
> + vc->vc_visible_origin = vc->vc_origin;
> + vc->vc_scr_end = vc->vc_origin + vc->vc_screenbuf_size;
> + vc->vc_pos = vc->vc_origin + vc->vc_size_row * vc->vc_y + 2 * vc->vc_x;
> }
>
> static inline void save_screen(struct vc_data *vc)
> {
> WARN_CONSOLE_UNLOCKED();
>
> - if (sw->con_save_screen)
> - sw->con_save_screen(vc);
> + if (vc->vc_sw->con_save_screen)
> + vc->vc_sw->con_save_screen(vc);
> }
>
> /*
> @@ -586,12 +584,12 @@ static inline void save_screen(struct vc
>
> static void clear_buffer_attributes(struct vc_data *vc)
> {
> - unsigned short *p = (unsigned short *) origin;
> - int count = screenbuf_size/2;
> - int mask = hi_font_mask | 0xff;
> + unsigned short *p = (unsigned short *)vc->vc_origin;
> + int count = vc->vc_screenbuf_size / 2;
> + int mask = vc->vc_hi_font_mask | 0xff;
>
> for (; count > 0; count--, p++) {
> - scr_writew((scr_readw(p)&mask) | (video_erase_char&~mask), p);
> + scr_writew((scr_readw(p)&mask) | (vc->vc_video_erase_char & ~mask), p);
> }
> }
>
> @@ -630,7 +628,7 @@ void redraw_screen(struct vc_data *vc, i
> int old_was_color = vc->vc_can_do_color;
>
> set_origin(vc);
> - update = sw->con_switch(vc);
> + update = vc->vc_sw->con_switch(vc);
> set_palette(vc);
> /*
> * If console changed from mono<->color, the best we can do
> @@ -642,8 +640,8 @@ void redraw_screen(struct vc_data *vc, i
> update_attr(vc);
> clear_buffer_attributes(vc);
> }
> - if (update && vcmode != KD_GRAPHICS)
> - do_update_region(vc, origin, screenbuf_size / 2);
> + if (update && vt_cons[vc->vc_num]->vc_mode != KD_GRAPHICS)
> + do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2);
> }
> set_cursor(vc);
> if (is_switch) {
> @@ -663,28 +661,28 @@ int vc_cons_allocated(unsigned int i)
>
> static void visual_init(struct vc_data *vc, int num, int init)
> {
> - /* ++Geert: sw->con_init determines console size */
> - if (sw)
> - module_put(sw->owner);
> - sw = conswitchp;
> + /* ++Geert: vc->vc_sw->con_init determines console size */
> + if (vc->vc_sw)
> + module_put(vc->vc_sw->owner);
> + vc->vc_sw = conswitchp;
> #ifndef VT_SINGLE_DRIVER
> if (con_driver_map[num])
> - sw = con_driver_map[num];
> + vc->vc_sw = con_driver_map[num];
> #endif
> - __module_get(sw->owner);
> + __module_get(vc->vc_sw->owner);
> vc->vc_num = num;
> - display_fg = &master_display_fg;
> + vc->vc_display_fg = &master_display_fg;
> vc->vc_uni_pagedir_loc = &vc->vc_uni_pagedir;
> vc->vc_uni_pagedir = 0;
> - hi_font_mask = 0;
> - complement_mask = 0;
> + vc->vc_hi_font_mask = 0;
> + vc->vc_complement_mask = 0;
> vc->vc_can_do_color = 0;
> - sw->con_init(vc, init);
> - if (!complement_mask)
> - complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
> - s_complement_mask = complement_mask;
> + vc->vc_sw->con_init(vc, init);
> + if (!vc->vc_complement_mask)
> + vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
> + vc->vc_s_complement_mask = vc->vc_complement_mask;
> vc->vc_size_row = vc->vc_cols << 1;
> - screenbuf_size = vc->vc_rows * vc->vc_size_row;
> + vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row;
> }
>
> int vc_allocate(unsigned int currcons) /* return 0 on success */
> @@ -707,25 +705,25 @@ int vc_allocate(unsigned int currcons) /
> /* although the numbers above are not valid since long ago, the
> point is still up-to-date and the comment still has its value
> even if only as a historical artifact. --mj, July 1998 */
> - p = (long) kmalloc(structsize, GFP_KERNEL);
> + p = (long) kmalloc(sizeof(struct vc_data) + sizeof(struct vt_struct), GFP_KERNEL);
> if (!p)
> return -ENOMEM;
> - memset((void *)p, 0, structsize);
> + memset((void *)p, 0, sizeof(struct vc_data) + sizeof(struct vt_struct));
> vc_cons[currcons].d = vc = (struct vc_data *)p;
> vt_cons[currcons] = (struct vt_struct *)(p+sizeof(struct vc_data));
> vc_cons[currcons].d->vc_vt = vt_cons[currcons];
> visual_init(vc, currcons, 1);
> if (!*vc->vc_uni_pagedir_loc)
> con_set_default_unimap(vc);
> - q = (long)kmalloc(screenbuf_size, GFP_KERNEL);
> + q = (long)kmalloc(vc->vc_screenbuf_size, GFP_KERNEL);
> if (!q) {
> kfree((char *) p);
> vc_cons[currcons].d = NULL;
> vt_cons[currcons] = NULL;
> return -ENOMEM;
> }
> - screenbuf = (unsigned short *) q;
> - kmalloced = 1;
> + vc->vc_screenbuf = (unsigned short *)q;
> + vc->vc_kmalloced = 1;
> vc_init(vc, vc->vc_rows, vc->vc_cols, 1);
>
> if (!pm_con) {
> @@ -742,8 +740,8 @@ inline int resize_screen(struct vc_data
> /* Resizes the resolution of the display adapater */
> int err = 0;
>
> - if (vcmode != KD_GRAPHICS && sw->con_resize)
> - err = sw->con_resize(vc, width, height);
> + if (vt_cons[vc->vc_num]->vc_mode != KD_GRAPHICS && vc->vc_sw->con_resize)
> + err = vc->vc_sw->con_resize(vc, width, height);
> return err;
> }
>
> @@ -784,7 +782,7 @@ int vc_resize(struct vc_data *vc, unsign
> old_rows = vc->vc_rows;
> old_cols = vc->vc_cols;
> old_row_size = vc->vc_size_row;
> - old_screen_size = screenbuf_size;
> + old_screen_size = vc->vc_screenbuf_size;
>
> err = resize_screen(vc, new_cols, new_rows);
> if (err) {
> @@ -795,11 +793,11 @@ int vc_resize(struct vc_data *vc, unsign
> vc->vc_rows = new_rows;
> vc->vc_cols = new_cols;
> vc->vc_size_row = new_row_size;
> - screenbuf_size = new_screen_size;
> + vc->vc_screenbuf_size = new_screen_size;
>
> rlth = min(old_row_size, new_row_size);
> rrem = new_row_size - rlth;
> - old_origin = origin;
> + old_origin = vc->vc_origin;
> new_origin = (long) newscreen;
> new_scr_end = new_origin + new_screen_size;
> if (new_rows < old_rows)
> @@ -807,26 +805,26 @@ int vc_resize(struct vc_data *vc, unsign
>
> update_attr(vc);
>
> - while (old_origin < scr_end) {
> + while (old_origin < vc->vc_scr_end) {
> scr_memcpyw((unsigned short *) new_origin, (unsigned short *) old_origin, rlth);
> if (rrem)
> - scr_memsetw((void *)(new_origin + rlth), video_erase_char, rrem);
> + scr_memsetw((void *)(new_origin + rlth), vc->vc_video_erase_char, rrem);
> old_origin += old_row_size;
> new_origin += new_row_size;
> }
> if (new_scr_end > new_origin)
> - scr_memsetw((void *) new_origin, video_erase_char, new_scr_end - new_origin);
> - if (kmalloced)
> - kfree(screenbuf);
> - screenbuf = newscreen;
> - kmalloced = 1;
> - screenbuf_size = new_screen_size;
> + scr_memsetw((void *)new_origin, vc->vc_video_erase_char, new_scr_end - new_origin);
> + if (vc->vc_kmalloced)
> + kfree(vc->vc_screenbuf);
> + vc->vc_screenbuf = newscreen;
> + vc->vc_kmalloced = 1;
> + vc->vc_screenbuf_size = new_screen_size;
> set_origin(vc);
>
> /* do part of a reset_terminal() */
> - top = 0;
> - bottom = vc->vc_rows;
> - gotoxy(vc, x, y);
> + vc->vc_top = 0;
> + vc->vc_bottom = vc->vc_rows;
> + gotoxy(vc, vc->vc_x, vc->vc_y);
> save_cur(vc);
>
> if (vc->vc_tty) {
> @@ -835,7 +833,7 @@ int vc_resize(struct vc_data *vc, unsign
> memset(&ws, 0, sizeof(ws));
> ws.ws_row = vc->vc_rows;
> ws.ws_col = vc->vc_cols;
> - ws.ws_ypixel = video_scan_lines;
> + ws.ws_ypixel = vc->vc_scan_lines;
> if ((ws.ws_row != cws->ws_row || ws.ws_col != cws->ws_col) &&
> vc->vc_tty->pgrp > 0)
> kill_pg(vc->vc_tty->pgrp, SIGWINCH, 1);
> @@ -854,9 +852,9 @@ void vc_disallocate(unsigned int currcon
>
> if (vc_cons_allocated(currcons)) {
> struct vc_data *vc = vc_cons[currcons].d;
> - sw->con_deinit(vc);
> - if (kmalloced)
> - kfree(screenbuf);
> + vc->vc_sw->con_deinit(vc);
> + if (vc->vc_kmalloced)
> + kfree(vc->vc_screenbuf);
> if (currcons >= MIN_NR_CONSOLES)
> kfree(vc);
> vc_cons[currcons].d = NULL;
> @@ -931,7 +929,7 @@ static void gotoxy(struct vc_data *vc, i
> /* for absolute user moves, when decom is set */
> static void gotoxay(struct vc_data *vc, int new_x, int new_y)
> {
> - gotoxy(vc, new_x, decom ? (top+new_y) : new_y);
> + gotoxy(vc, new_x, vc->vc_decom ? (vc->vc_top + new_y) : new_y);
> }
>
> void scrollback(struct vc_data *vc, int lines)
> @@ -953,13 +951,13 @@ static void lf(struct vc_data *vc)
> /* don't scroll if above bottom of scrolling region, or
> * if below scrolling region
> */
> - if (y+1 == bottom)
> - scrup(vc, top, bottom, 1);
> - else if (y < vc->vc_rows - 1) {
> - y++;
> - pos += vc->vc_size_row;
> + if (vc->vc_y + 1 == vc->vc_bottom)
> + scrup(vc, vc->vc_top, vc->vc_bottom, 1);
> + else if (vc->vc_y < vc->vc_rows - 1) {
> + vc->vc_y++;
> + vc->vc_pos += vc->vc_size_row;
> }
> - need_wrap = 0;
> + vc->vc_need_wrap = 0;
> }
>
> static void ri(struct vc_data *vc)
> @@ -967,27 +965,27 @@ static void ri(struct vc_data *vc)
> /* don't scroll if below top of scrolling region, or
> * if above scrolling region
> */
> - if (y == top)
> - scrdown(vc, top, bottom, 1);
> - else if (y > 0) {
> - y--;
> - pos -= vc->vc_size_row;
> + if (vc->vc_y == vc->vc_top)
> + scrdown(vc, vc->vc_top, vc->vc_bottom, 1);
> + else if (vc->vc_y > 0) {
> + vc->vc_y--;
> + vc->vc_pos -= vc->vc_size_row;
> }
> - need_wrap = 0;
> + vc->vc_need_wrap = 0;
> }
>
> static inline void cr(struct vc_data *vc)
> {
> - pos -= x<<1;
> - need_wrap = x = 0;
> + vc->vc_pos -= vc->vc_x << 1;
> + vc->vc_need_wrap = vc->vc_x = 0;
> }
>
> static inline void bs(struct vc_data *vc)
> {
> - if (x) {
> - pos -= 2;
> - x--;
> - need_wrap = 0;
> + if (vc->vc_x) {
> + vc->vc_pos -= 2;
> + vc->vc_x--;
> + vc->vc_need_wrap = 0;
> }
> }
>
> @@ -1003,41 +1001,41 @@ static void csi_J(struct vc_data *vc, in
>
> switch (vpar) {
> case 0: /* erase from cursor to end of display */
> - count = (scr_end-pos)>>1;
> - start = (unsigned short *) pos;
> + count = (vc->vc_scr_end - vc->vc_pos) >> 1;
> + start = (unsigned short *)vc->vc_pos;
> if (DO_UPDATE(vc)) {
> /* do in two stages */
> - sw->con_clear(vc, y, x, 1,
> - vc->vc_cols - x);
> - sw->con_clear(vc, y + 1, 0,
> - vc->vc_rows - y - 1,
> + vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1,
> + vc->vc_cols - vc->vc_x);
> + vc->vc_sw->con_clear(vc, vc->vc_y + 1, 0,
> + vc->vc_rows - vc->vc_y - 1,
> vc->vc_cols);
> }
> break;
> case 1: /* erase from start to cursor */
> - count = ((pos-origin)>>1)+1;
> - start = (unsigned short *) origin;
> + count = ((vc->vc_pos - vc->vc_origin) >> 1) + 1;
> + start = (unsigned short *)vc->vc_origin;
> if (DO_UPDATE(vc)) {
> /* do in two stages */
> - sw->con_clear(vc, 0, 0, y,
> + vc->vc_sw->con_clear(vc, 0, 0, vc->vc_y,
> vc->vc_cols);
> - sw->con_clear(vc, y, 0, 1,
> - x + 1);
> + vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
> + vc->vc_x + 1);
> }
> break;
> case 2: /* erase whole display */
> count = vc->vc_cols * vc->vc_rows;
> - start = (unsigned short *) origin;
> + start = (unsigned short *)vc->vc_origin;
> if (DO_UPDATE(vc))
> - sw->con_clear(vc, 0, 0,
> + vc->vc_sw->con_clear(vc, 0, 0,
> vc->vc_rows,
> vc->vc_cols);
> break;
> default:
> return;
> }
> - scr_memsetw(start, video_erase_char, 2*count);
> - need_wrap = 0;
> + scr_memsetw(start, vc->vc_video_erase_char, 2 * count);
> + vc->vc_need_wrap = 0;
> }
>
> static void csi_K(struct vc_data *vc, int vpar)
> @@ -1047,31 +1045,31 @@ static void csi_K(struct vc_data *vc, in
>
> switch (vpar) {
> case 0: /* erase from cursor to end of line */
> - count = vc->vc_cols - x;
> - start = (unsigned short *) pos;
> + count = vc->vc_cols - vc->vc_x;
> + start = (unsigned short *)vc->vc_pos;
> if (DO_UPDATE(vc))
> - sw->con_clear(vc, y, x, 1,
> - vc->vc_cols - x);
> + vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1,
> + vc->vc_cols - vc->vc_x);
> break;
> case 1: /* erase from start of line to cursor */
> - start = (unsigned short *) (pos - (x<<1));
> - count = x+1;
> + start = (unsigned short *)(vc->vc_pos - (vc->vc_x << 1));
> + count = vc->vc_x + 1;
> if (DO_UPDATE(vc))
> - sw->con_clear(vc, y, 0, 1,
> - x + 1);
> + vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
> + vc->vc_x + 1);
> break;
> case 2: /* erase whole line */
> - start = (unsigned short *) (pos - (x<<1));
> + start = (unsigned short *)(vc->vc_pos - (vc->vc_x << 1));
> count = vc->vc_cols;
> if (DO_UPDATE(vc))
> - sw->con_clear(vc, y, 0, 1,
> + vc->vc_sw->con_clear(vc, vc->vc_y, 0, 1,
> vc->vc_cols);
> break;
> default:
> return;
> }
> - scr_memsetw(start, video_erase_char, 2 * count);
> - need_wrap = 0;
> + scr_memsetw(start, vc->vc_video_erase_char, 2 * count);
> + vc->vc_need_wrap = 0;
> }
>
> static void csi_X(struct vc_data *vc, int vpar) /* erase the following vpar positions */
> @@ -1080,21 +1078,21 @@ static void csi_X(struct vc_data *vc, in
>
> if (!vpar)
> vpar++;
> - count = (vpar > vc->vc_cols - x) ? (vc->vc_cols - x) : vpar;
> + count = (vpar > vc->vc_cols - vc->vc_x) ? (vc->vc_cols - vc->vc_x) : vpar;
>
> - scr_memsetw((unsigned short *) pos, video_erase_char, 2 * count);
> + scr_memsetw((unsigned short *)vc->vc_pos, vc->vc_video_erase_char, 2 * count);
> if (DO_UPDATE(vc))
> - sw->con_clear(vc, y, x, 1, count);
> - need_wrap = 0;
> + vc->vc_sw->con_clear(vc, vc->vc_y, vc->vc_x, 1, count);
> + vc->vc_need_wrap = 0;
> }
>
> static void default_attr(struct vc_data *vc)
> {
> - intensity = 1;
> - underline = 0;
> - reverse = 0;
> - blink = 0;
> - color = def_color;
> + vc->vc_intensity = 1;
> + vc->vc_underline = 0;
> + vc->vc_reverse = 0;
> + vc->vc_blink = 0;
> + vc->vc_color = vc->vc_def_color;
> }
>
> /* console_sem is held */
> @@ -1102,92 +1100,92 @@ static void csi_m(struct vc_data *vc)
> {
> int i;
>
> - for (i=0;i<=npar;i++)
> - switch (par[i]) {
> + for (i = 0; i <= vc->vc_npar; i++)
> + switch (vc->vc_par[i]) {
> case 0: /* all attributes off */
> default_attr(vc);
> break;
> case 1:
> - intensity = 2;
> + vc->vc_intensity = 2;
> break;
> case 2:
> - intensity = 0;
> + vc->vc_intensity = 0;
> break;
> case 4:
> - underline = 1;
> + vc->vc_underline = 1;
> break;
> case 5:
> - blink = 1;
> + vc->vc_blink = 1;
> break;
> case 7:
> - reverse = 1;
> + vc->vc_reverse = 1;
> break;
> case 10: /* ANSI X3.64-1979 (SCO-ish?)
> * Select primary font, don't display
> * control chars if defined, don't set
> * bit 8 on output.
> */
> - translate = set_translate(charset == 0
> - ? G0_charset
> - : G1_charset, vc);
> - disp_ctrl = 0;
> - toggle_meta = 0;
> + vc->vc_translate = set_translate(vc->vc_charset == 0
> + ? vc->vc_G0_charset
> + : vc->vc_G1_charset, vc);
> + vc->vc_disp_ctrl = 0;
> + vc->vc_toggle_meta = 0;
> break;
> case 11: /* ANSI X3.64-1979 (SCO-ish?)
> * Select first alternate font, lets
> * chars < 32 be displayed as ROM chars.
> */
> - translate = set_translate(IBMPC_MAP, vc);
> - disp_ctrl = 1;
> - toggle_meta = 0;
> + vc->vc_translate = set_translate(IBMPC_MAP, vc);
> + vc->vc_disp_ctrl = 1;
> + vc->vc_toggle_meta = 0;
> break;
> case 12: /* ANSI X3.64-1979 (SCO-ish?)
> * Select second alternate font, toggle
> * high bit before displaying as ROM char.
> */
> - translate = set_translate(IBMPC_MAP, vc);
> - disp_ctrl = 1;
> - toggle_meta = 1;
> + vc->vc_translate = set_translate(IBMPC_MAP, vc);
> + vc->vc_disp_ctrl = 1;
> + vc->vc_toggle_meta = 1;
> break;
> case 21:
> case 22:
> - intensity = 1;
> + vc->vc_intensity = 1;
> break;
> case 24:
> - underline = 0;
> + vc->vc_underline = 0;
> break;
> case 25:
> - blink = 0;
> + vc->vc_blink = 0;
> break;
> case 27:
> - reverse = 0;
> + vc->vc_reverse = 0;
> break;
> case 38: /* ANSI X3.64-1979 (SCO-ish?)
> * Enables underscore, white foreground
> * with white underscore (Linux - use
> * default foreground).
> */
> - color = (def_color & 0x0f) | background;
> - underline = 1;
> + vc->vc_color = (vc->vc_def_color & 0x0f) | (vc->vc_color & 0xf0);
> + vc->vc_underline = 1;
> break;
> case 39: /* ANSI X3.64-1979 (SCO-ish?)
> * Disable underline option.
> * Reset colour to default? It did this
> * before...
> */
> - color = (def_color & 0x0f) | background;
> - underline = 0;
> + vc->vc_color = (vc->vc_def_color & 0x0f) | (vc->vc_color & 0xf0);
> + vc->vc_underline = 0;
> break;
> case 49:
> - color = (def_color & 0xf0) | foreground;
> + vc->vc_color = (vc->vc_def_color & 0xf0) | (vc->vc_color & 0x0f);
> break;
> default:
> - if (par[i] >= 30 && par[i] <= 37)
> - color = color_table[par[i]-30]
> - | background;
> - else if (par[i] >= 40 && par[i] <= 47)
> - color = (color_table[par[i]-40]<<4)
> - | foreground;
> + if (vc->vc_par[i] >= 30 && vc->vc_par[i] <= 37)
> + vc->vc_color = color_table[vc->vc_par[i] - 30]
> + | (vc->vc_color & 0xf0);
> + else if (vc->vc_par[i] >= 40 && vc->vc_par[i] <= 47)
> + vc->vc_color = (color_table[vc->vc_par[i] - 40] << 4)
> + | (vc->vc_color & 0x0f);
> break;
> }
> update_attr(vc);
> @@ -1206,7 +1204,7 @@ static void cursor_report(struct vc_data
> {
> char buf[40];
>
> - sprintf(buf, "\033[%d;%dR", y + (decom ? top+1 : 1), x+1);
> + sprintf(buf, "\033[%d;%dR", vc->vc_y + (vc->vc_decom ? vc->vc_top + 1 : 1), vc->vc_x + 1);
> respond_string(buf, tty);
> }
>
> @@ -1232,9 +1230,7 @@ void mouse_report(struct tty_struct *tty
> /* invoked via ioctl(TIOCLINUX) and through set_selection */
> int mouse_reporting(void)
> {
> - struct vc_data *vc = vc_cons[fg_console].d;
> -
> - return report_mouse;
> + return vc_cons[fg_console].d->vc_report_mouse;
> }
>
> /* console_sem is held */
> @@ -1242,8 +1238,9 @@ static void set_mode(struct vc_data *vc,
> {
> int i;
>
> - for (i=0; i<=npar; i++)
> - if (ques) switch(par[i]) { /* DEC private modes set/reset */
> + for (i = 0; i <= vc->vc_npar; i++)
> + if (vc->vc_ques) {
> + switch(vc->vc_par[i]) { /* DEC private modes set/reset */
> case 1: /* Cursor keys send ^[Ox/^[[x */
> if (on_off)
> set_kbd(vc, decckm);
> @@ -1251,7 +1248,7 @@ static void set_mode(struct vc_data *vc,
> clr_kbd(vc, decckm);
> break;
> case 3: /* 80/132 mode switch unimplemented */
> - deccolm = on_off;
> + vc->vc_deccolm = on_off;
> #if 0
> vc_resize(deccolm ? 132 : 80, vc->vc_rows);
> /* this alone does not suffice; some user mode
> @@ -1259,18 +1256,18 @@ static void set_mode(struct vc_data *vc,
> #endif
> break;
> case 5: /* Inverted screen on/off */
> - if (decscnm != on_off) {
> - decscnm = on_off;
> - invert_screen(vc, 0, screenbuf_size, 0);
> + if (vc->vc_decscnm != on_off) {
> + vc->vc_decscnm = on_off;
> + invert_screen(vc, 0, vc->vc_screenbuf_size, 0);
> update_attr(vc);
> }
> break;
> case 6: /* Origin relative/absolute */
> - decom = on_off;
> + vc->vc_decom = on_off;
> gotoxay(vc, 0, 0);
> break;
> case 7: /* Autowrap on/off */
> - decawm = on_off;
> + vc->vc_decawm = on_off;
> break;
> case 8: /* Autorepeat on/off */
> if (on_off)
> @@ -1279,20 +1276,22 @@ static void set_mode(struct vc_data *vc,
> clr_kbd(vc, decarm);
> break;
> case 9:
> - report_mouse = on_off ? 1 : 0;
> + vc->vc_report_mouse = on_off ? 1 : 0;
> break;
> case 25: /* Cursor on/off */
> - deccm = on_off;
> + vc->vc_deccm = on_off;
> break;
> case 1000:
> - report_mouse = on_off ? 2 : 0;
> + vc->vc_report_mouse = on_off ? 2 : 0;
> break;
> - } else switch(par[i]) { /* ANSI modes set/reset */
> + }
> + } else {
> + switch(vc->vc_par[i]) { /* ANSI modes set/reset */
> case 3: /* Monitor (display ctrls) */
> - disp_ctrl = on_off;
> + vc->vc_disp_ctrl = on_off;
> break;
> case 4: /* Insert Mode on/off */
> - decim = on_off;
> + vc->vc_decim = on_off;
> break;
> case 20: /* Lf, Enter == CrLf/Lf */
> if (on_off)
> @@ -1300,62 +1299,63 @@ static void set_mode(struct vc_data *vc,
> else
> clr_kbd(vc, lnm);
> break;
> + }
> }
> }
>
> /* console_sem is held */
> static void setterm_command(struct vc_data *vc)
> {
> - switch(par[0]) {
> + switch(vc->vc_par[0]) {
> case 1: /* set color for underline mode */
> if (vc->vc_can_do_color &&
> - par[1] < 16) {
> - ulcolor = color_table[par[1]];
> - if (underline)
> + vc->vc_par[1] < 16) {
> + vc->vc_ulcolor = color_table[vc->vc_par[1]];
> + if (vc->vc_underline)
> update_attr(vc);
> }
> break;
> case 2: /* set color for half intensity mode */
> if (vc->vc_can_do_color &&
> - par[1] < 16) {
> - halfcolor = color_table[par[1]];
> - if (intensity == 0)
> + vc->vc_par[1] < 16) {
> + vc->vc_halfcolor = color_table[vc->vc_par[1]];
> + if (vc->vc_intensity == 0)
> update_attr(vc);
> }
> break;
> case 8: /* store colors as defaults */
> - def_color = attr;
> - if (hi_font_mask == 0x100)
> - def_color >>= 1;
> + vc->vc_def_color = vc->vc_attr;
> + if (vc->vc_hi_font_mask == 0x100)
> + vc->vc_def_color >>= 1;
> default_attr(vc);
> update_attr(vc);
> break;
> case 9: /* set blanking interval */
> - blankinterval = ((par[1] < 60) ? par[1] : 60) * 60 * HZ;
> + blankinterval = ((vc->vc_par[1] < 60) ? vc->vc_par[1] : 60) * 60 * HZ;
> poke_blanked_console();
> break;
> case 10: /* set bell frequency in Hz */
> - if (npar >= 1)
> - bell_pitch = par[1];
> + if (vc->vc_npar >= 1)
> + vc->vc_bell_pitch = vc->vc_par[1];
> else
> - bell_pitch = DEFAULT_BELL_PITCH;
> + vc->vc_bell_pitch = DEFAULT_BELL_PITCH;
> break;
> case 11: /* set bell duration in msec */
> - if (npar >= 1)
> - bell_duration = (par[1] < 2000) ?
> - par[1]*HZ/1000 : 0;
> + if (vc->vc_npar >= 1)
> + vc->vc_bell_duration = (vc->vc_par[1] < 2000) ?
> + vc->vc_par[1] * HZ / 1000 : 0;
> else
> - bell_duration = DEFAULT_BELL_DURATION;
> + vc->vc_bell_duration = DEFAULT_BELL_DURATION;
> break;
> case 12: /* bring specified console to the front */
> - if (par[1] >= 1 && vc_cons_allocated(par[1]-1))
> - set_console(par[1] - 1);
> + if (vc->vc_par[1] >= 1 && vc_cons_allocated(vc->vc_par[1] - 1))
> + set_console(vc->vc_par[1] - 1);
> break;
> case 13: /* unblank the screen */
> poke_blanked_console();
> break;
> case 14: /* set vesa powerdown interval */
> - vesa_off_interval = ((par[1] < 60) ? par[1] : 60) * 60 * HZ;
> + vesa_off_interval = ((vc->vc_par[1] < 60) ? vc->vc_par[1] : 60) * 60 * HZ;
> break;
> case 15: /* activate the previous console */
> set_console(last_console);
> @@ -1366,8 +1366,8 @@ static void setterm_command(struct vc_da
> /* console_sem is held */
> static void csi_at(struct vc_data *vc, unsigned int nr)
> {
> - if (nr > vc->vc_cols - x)
> - nr = vc->vc_cols - x;
> + if (nr > vc->vc_cols - vc->vc_x)
> + nr = vc->vc_cols - vc->vc_x;
> else if (!nr)
> nr = 1;
> insert_char(vc, nr);
> @@ -1376,19 +1376,19 @@ static void csi_at(struct vc_data *vc, u
> /* console_sem is held */
> static void csi_L(struct vc_data *vc, unsigned int nr)
> {
> - if (nr > vc->vc_rows - y)
> - nr = vc->vc_rows - y;
> + if (nr > vc->vc_rows - vc->vc_y)
> + nr = vc->vc_rows - vc->vc_y;
> else if (!nr)
> nr = 1;
> - scrdown(vc, y, bottom, nr);
> - need_wrap = 0;
> + scrdown(vc, vc->vc_y, vc->vc_bottom, nr);
> + vc->vc_need_wrap = 0;
> }
>
> /* console_sem is held */
> static void csi_P(struct vc_data *vc, unsigned int nr)
> {
> - if (nr > vc->vc_cols - x)
> - nr = vc->vc_cols - x;
> + if (nr > vc->vc_cols - vc->vc_x)
> + nr = vc->vc_cols - vc->vc_x;
> else if (!nr)
> nr = 1;
> delete_char(vc, nr);
> @@ -1397,44 +1397,44 @@ static void csi_P(struct vc_data *vc, un
> /* console_sem is held */
> static void csi_M(struct vc_data *vc, unsigned int nr)
> {
> - if (nr > vc->vc_rows - y)
> - nr = vc->vc_rows - y;
> + if (nr > vc->vc_rows - vc->vc_y)
> + nr = vc->vc_rows - vc->vc_y;
> else if (!nr)
> nr=1;
> - scrup(vc, y, bottom, nr);
> - need_wrap = 0;
> + scrup(vc, vc->vc_y, vc->vc_bottom, nr);
> + vc->vc_need_wrap = 0;
> }
>
> /* console_sem is held (except via vc_init->reset_terminal */
> static void save_cur(struct vc_data *vc)
> {
> - saved_x = x;
> - saved_y = y;
> - s_intensity = intensity;
> - s_underline = underline;
> - s_blink = blink;
> - s_reverse = reverse;
> - s_charset = charset;
> - s_color = color;
> - saved_G0 = G0_charset;
> - saved_G1 = G1_charset;
> + vc->vc_saved_x = vc->vc_x;
> + vc->vc_saved_y = vc->vc_y;
> + vc->vc_s_intensity = vc->vc_intensity;
> + vc->vc_s_underline = vc->vc_underline;
> + vc->vc_s_blink = vc->vc_blink;
> + vc->vc_s_reverse = vc->vc_reverse;
> + vc->vc_s_charset = vc->vc_charset;
> + vc->vc_s_color = vc->vc_color;
> + vc->vc_saved_G0 = vc->vc_G0_charset;
> + vc->vc_saved_G1 = vc->vc_G1_charset;
> }
>
> /* console_sem is held */
> static void restore_cur(struct vc_data *vc)
> {
> - gotoxy(vc, saved_x, saved_y);
> - intensity = s_intensity;
> - underline = s_underline;
> - blink = s_blink;
> - reverse = s_reverse;
> - charset = s_charset;
> - color = s_color;
> - G0_charset = saved_G0;
> - G1_charset = saved_G1;
> - translate = set_translate(charset ? G1_charset : G0_charset, vc);
> + gotoxy(vc, vc->vc_saved_x, vc->vc_saved_y);
> + vc->vc_intensity = vc->vc_s_intensity;
> + vc->vc_underline = vc->vc_s_underline;
> + vc->vc_blink = vc->vc_s_blink;
> + vc->vc_reverse = vc->vc_s_reverse;
> + vc->vc_charset = vc->vc_s_charset;
> + vc->vc_color = vc->vc_s_color;
> + vc->vc_G0_charset = vc->vc_saved_G0;
> + vc->vc_G1_charset = vc->vc_saved_G1;
> + vc->vc_translate = set_translate(vc->vc_charset ? vc->vc_G1_charset : vc->vc_G0_charset, vc);
> update_attr(vc);
> - need_wrap = 0;
> + vc->vc_need_wrap = 0;
> }
>
> enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey,
> @@ -1444,27 +1444,27 @@ enum { ESnormal, ESesc, ESsquare, ESgetp
> /* console_sem is held (except via vc_init()) */
> static void reset_terminal(struct vc_data *vc, int do_clear)
> {
> - top = 0;
> - bottom = vc->vc_rows;
> - vc_state = ESnormal;
> - ques = 0;
> - translate = set_translate(LAT1_MAP, vc);
> - G0_charset = LAT1_MAP;
> - G1_charset = GRAF_MAP;
> - charset = 0;
> - need_wrap = 0;
> - report_mouse = 0;
> - utf = 0;
> - utf_count = 0;
> -
> - disp_ctrl = 0;
> - toggle_meta = 0;
> -
> - decscnm = 0;
> - decom = 0;
> - decawm = 1;
> - deccm = 1;
> - decim = 0;
> + vc->vc_top = 0;
> + vc->vc_bottom = vc->vc_rows;
> + vc->vc_state = ESnormal;
> + vc->vc_ques = 0;
> + vc->vc_translate = set_translate(LAT1_MAP, vc);
> + vc->vc_G0_charset = LAT1_MAP;
> + vc->vc_G1_charset = GRAF_MAP;
> + vc->vc_charset = 0;
> + vc->vc_need_wrap = 0;
> + vc->vc_report_mouse = 0;
> + vc->vc_utf = 0;
> + vc->vc_utf_count = 0;
> +
> + vc->vc_disp_ctrl = 0;
> + vc->vc_toggle_meta = 0;
> +
> + vc->vc_decscnm = 0;
> + vc->vc_decom = 0;
> + vc->vc_decawm = 1;
> + vc->vc_deccm = 1;
> + vc->vc_decim = 0;
>
> set_kbd(vc, decarm);
> clr_kbd(vc, decckm);
> @@ -1477,20 +1477,20 @@ static void reset_terminal(struct vc_dat
> /* do not do set_leds here because this causes an endless tasklet loop
> when the keyboard hasn't been initialized yet */
>
> - cursor_type = CUR_DEFAULT;
> - complement_mask = s_complement_mask;
> + vc->vc_cursor_type = CUR_DEFAULT;
> + vc->vc_complement_mask = vc->vc_s_complement_mask;
>
> default_attr(vc);
> update_attr(vc);
>
> - tab_stop[0] = 0x01010100;
> - tab_stop[1] =
> - tab_stop[2] =
> - tab_stop[3] =
> - tab_stop[4] = 0x01010101;
> + vc->vc_tab_stop[0] = 0x01010100;
> + vc->vc_tab_stop[1] =
> + vc->vc_tab_stop[2] =
> + vc->vc_tab_stop[3] =
> + vc->vc_tab_stop[4] = 0x01010101;
>
> - bell_pitch = DEFAULT_BELL_PITCH;
> - bell_duration = DEFAULT_BELL_DURATION;
> + vc->vc_bell_pitch = DEFAULT_BELL_PITCH;
> + vc->vc_bell_duration = DEFAULT_BELL_DURATION;
>
> gotoxy(vc, 0, 0);
> save_cur(vc);
> @@ -1509,20 +1509,20 @@ static void do_con_trol(struct tty_struc
> case 0:
> return;
> case 7:
> - if (bell_duration)
> - kd_mksound(bell_pitch, bell_duration);
> + if (vc->vc_bell_duration)
> + kd_mksound(vc->vc_bell_pitch, vc->vc_bell_duration);
> return;
> case 8:
> bs(vc);
> return;
> case 9:
> - pos -= (x << 1);
> - while (x < vc->vc_cols - 1) {
> - x++;
> - if (tab_stop[x >> 5] & (1 << (x & 31)))
> + vc->vc_pos -= (vc->vc_x << 1);
> + while (vc->vc_x < vc->vc_cols - 1) {
> + vc->vc_x++;
> + if (vc->vc_tab_stop[vc->vc_x >> 5] & (1 << (vc->vc_x & 31)))
> break;
> }
> - pos += (x << 1);
> + vc->vc_pos += (vc->vc_x << 1);
> return;
> case 10: case 11: case 12:
> lf(vc);
> @@ -1532,40 +1532,40 @@ static void do_con_trol(struct tty_struc
> cr(vc);
> return;
> case 14:
> - charset = 1;
> - translate = set_translate(G1_charset, vc);
> - disp_ctrl = 1;
> + vc->vc_charset = 1;
> + vc->vc_translate = set_translate(vc->vc_G1_charset, vc);
> + vc->vc_disp_ctrl = 1;
> return;
> case 15:
> - charset = 0;
> - translate = set_translate(G0_charset, vc);
> - disp_ctrl = 0;
> + vc->vc_charset = 0;
> + vc->vc_translate = set_translate(vc->vc_G0_charset, vc);
> + vc->vc_disp_ctrl = 0;
> return;
> case 24: case 26:
> - vc_state = ESnormal;
> + vc->vc_state = ESnormal;
> return;
> case 27:
> - vc_state = ESesc;
> + vc->vc_state = ESesc;
> return;
> case 127:
> del(vc);
> return;
> case 128+27:
> - vc_state = ESsquare;
> + vc->vc_state = ESsquare;
> return;
> }
> - switch(vc_state) {
> + switch(vc->vc_state) {
> case ESesc:
> - vc_state = ESnormal;
> + vc->vc_state = ESnormal;
> switch (c) {
> case '[':
> - vc_state = ESsquare;
> + vc->vc_state = ESsquare;
> return;
> case ']':
> - vc_state = ESnonstd;
> + vc->vc_state = ESnonstd;
> return;
> case '%':
> - vc_state = ESpercent;
> + vc->vc_state = ESpercent;
> return;
> case 'E':
> cr(vc);
> @@ -1578,7 +1578,7 @@ static void do_con_trol(struct tty_struc
> lf(vc);
> return;
> case 'H':
> - tab_stop[x >> 5] |= (1 << (x & 31));
> + vc->vc_tab_stop[vc->vc_x >> 5] |= (1 << (vc->vc_x & 31));
> return;
> case 'Z':
> respond_ID(tty);
> @@ -1590,13 +1590,13 @@ static void do_con_trol(struct tty_struc
> restore_cur(vc);
> return;
> case '(':
> - vc_state = ESsetG0;
> + vc->vc_state = ESsetG0;
> return;
> case ')':
> - vc_state = ESsetG1;
> + vc->vc_state = ESsetG1;
> return;
> case '#':
> - vc_state = EShash;
> + vc->vc_state = EShash;
> return;
> case 'c':
> reset_terminal(vc, 1);
> @@ -1611,57 +1611,58 @@ static void do_con_trol(struct tty_struc
> return;
> case ESnonstd:
> if (c=='P') { /* palette escape sequence */
> - for (npar=0; npar<NPAR; npar++)
> - par[npar] = 0 ;
> - npar = 0 ;
> - vc_state = ESpalette;
> + for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++)
> + vc->vc_par[vc->vc_npar] = 0;
> + vc->vc_npar = 0;
> + vc->vc_state = ESpalette;
> return;
> } else if (c=='R') { /* reset palette */
> reset_palette(vc);
> - vc_state = ESnormal;
> + vc->vc_state = ESnormal;
> } else
> - vc_state = ESnormal;
> + vc->vc_state = ESnormal;
> return;
> case ESpalette:
> if ( (c>='0'&&c<='9') || (c>='A'&&c<='F') || (c>='a'&&c<='f') ) {
> - par[npar++] = (c>'9' ? (c&0xDF)-'A'+10 : c-'0') ;
> - if (npar==7) {
> - int i = par[0]*3, j = 1;
> - palette[i] = 16*par[j++];
> - palette[i++] += par[j++];
> - palette[i] = 16*par[j++];
> - palette[i++] += par[j++];
> - palette[i] = 16*par[j++];
> - palette[i] += par[j];
> + vc->vc_par[vc->vc_npar++] = (c > '9' ? (c & 0xDF) - 'A' + 10 : c - '0');
> + if (vc->vc_npar == 7) {
> + int i = vc->vc_par[0] * 3, j = 1;
> + vc->vc_palette[i] = 16 * vc->vc_par[j++];
> + vc->vc_palette[i++] += vc->vc_par[j++];
> + vc->vc_palette[i] = 16 * vc->vc_par[j++];
> + vc->vc_palette[i++] += vc->vc_par[j++];
> + vc->vc_palette[i] = 16 * vc->vc_par[j++];
> + vc->vc_palette[i] += vc->vc_par[j];
> set_palette(vc);
> - vc_state = ESnormal;
> + vc->vc_state = ESnormal;
> }
> } else
> - vc_state = ESnormal;
> + vc->vc_state = ESnormal;
> return;
> case ESsquare:
> - for(npar = 0 ; npar < NPAR ; npar++)
> - par[npar] = 0;
> - npar = 0;
> - vc_state = ESgetpars;
> + for (vc->vc_npar = 0; vc->vc_npar < NPAR; vc->vc_npar++)
> + vc->vc_par[vc->vc_npar] = 0;
> + vc->vc_npar = 0;
> + vc->vc_state = ESgetpars;
> if (c == '[') { /* Function key */
> - vc_state=ESfunckey;
> + vc->vc_state=ESfunckey;
> return;
> }
> - ques = (c=='?');
> - if (ques)
> + vc->vc_ques = (c == '?');
> + if (vc->vc_ques)
> return;
> case ESgetpars:
> - if (c==';' && npar<NPAR-1) {
> - npar++;
> + if (c == ';' && vc->vc_npar < NPAR - 1) {
> + vc->vc_npar++;
> return;
> } else if (c>='0' && c<='9') {
> - par[npar] *= 10;
> - par[npar] += c-'0';
> + vc->vc_par[vc->vc_npar] *= 10;
> + vc->vc_par[vc->vc_npar] += c - '0';
> return;
> - } else vc_state=ESgotpars;
> + } else
> + vc->vc_state = ESgotpars;
> case ESgotpars:
> - vc_state = ESnormal;
> + vc->vc_state = ESnormal;
> switch(c) {
> case 'h':
> set_mode(vc, 1);
> @@ -1670,103 +1671,113 @@ static void do_con_trol(struct tty_struc
> set_mode(vc, 0);
> return;
> case 'c':
> - if (ques) {
> - if (par[0])
> - cursor_type = par[0] | (par[1]<<8) | (par[2]<<16);
> + if (vc->vc_ques) {
> + if (vc->vc_par[0])
> + vc->vc_cursor_type = vc->vc_par[0] | (vc->vc_par[1] << 8) | (vc->vc_par[2] << 16);
> else
> - cursor_type = CUR_DEFAULT;
> + vc->vc_cursor_type = CUR_DEFAULT;
> return;
> }
> break;
> case 'm':
> - if (ques) {
> + if (vc->vc_ques) {
> clear_selection();
> - if (par[0])
> - complement_mask = par[0]<<8 | par[1];
> + if (vc->vc_par[0])
> + vc->vc_complement_mask = vc->vc_par[0] << 8 | vc->vc_par[1];
> else
> - complement_mask = s_complement_mask;
> + vc->vc_complement_mask = vc->vc_s_complement_mask;
> return;
> }
> break;
> case 'n':
> - if (!ques) {
> - if (par[0] == 5)
> + if (!vc->vc_ques) {
> + if (vc->vc_par[0] == 5)
> status_report(tty);
> - else if (par[0] == 6)
> + else if (vc->vc_par[0] == 6)
> cursor_report(vc, tty);
> }
> return;
> }
> - if (ques) {
> - ques = 0;
> + if (vc->vc_ques) {
> + vc->vc_ques = 0;
> return;
> }
> switch(c) {
> case 'G': case '`':
> - if (par[0]) par[0]--;
> - gotoxy(vc, par[0], y);
> + if (vc->vc_par[0])
> + vc->vc_par[0]--;
> + gotoxy(vc, vc->vc_par[0], vc->vc_y);
> return;
> case 'A':
> - if (!par[0]) par[0]++;
> - gotoxy(vc, x, y - par[0]);
> + if (!vc->vc_par[0])
> + vc->vc_par[0]++;
> + gotoxy(vc, vc->vc_x, vc->vc_y - vc->vc_par[0]);
> return;
> case 'B': case 'e':
> - if (!par[0]) par[0]++;
> - gotoxy(vc, x, y + par[0]);
> + if (!vc->vc_par[0])
> + vc->vc_par[0]++;
> + gotoxy(vc, vc->vc_x, vc->vc_y + vc->vc_par[0]);
> return;
> case 'C': case 'a':
> - if (!par[0]) par[0]++;
> - gotoxy(vc, x + par[0], y);
> + if (!vc->vc_par[0])
> + vc->vc_par[0]++;
> + gotoxy(vc, vc->vc_x + vc->vc_par[0], vc->vc_y);
> return;
> case 'D':
> - if (!par[0]) par[0]++;
> - gotoxy(vc, x - par[0], y);
> + if (!vc->vc_par[0])
> + vc->vc_par[0]++;
> + gotoxy(vc, vc->vc_x - vc->vc_par[0], vc->vc_y);
> return;
> case 'E':
> - if (!par[0]) par[0]++;
> - gotoxy(vc, 0, y + par[0]);
> + if (!vc->vc_par[0])
> + vc->vc_par[0]++;
> + gotoxy(vc, 0, vc->vc_y + vc->vc_par[0]);
> return;
> case 'F':
> - if (!par[0]) par[0]++;
> - gotoxy(vc, 0, y - par[0]);
> + if (!vc->vc_par[0])
> + vc->vc_par[0]++;
> + gotoxy(vc, 0, vc->vc_y - vc->vc_par[0]);
> return;
> case 'd':
> - if (par[0]) par[0]--;
> - gotoxay(vc, x, par[0]);
> + if (vc->vc_par[0])
> + vc->vc_par[0]--;
> + gotoxay(vc, vc->vc_x ,vc->vc_par[0]);
> return;
> case 'H': case 'f':
> - if (par[0]) par[0]--;
> - if (par[1]) par[1]--;
> - gotoxay(vc, par[1], par[0]);
> + if (vc->vc_par[0])
> + vc->vc_par[0]--;
> + if (vc->vc_par[1])
> + vc->vc_par[1]--;
> + gotoxay(vc, vc->vc_par[1], vc->vc_par[0]);
> return;
> case 'J':
> - csi_J(vc, par[0]);
> + csi_J(vc, vc->vc_par[0]);
> return;
> case 'K':
> - csi_K(vc, par[0]);
> + csi_K(vc, vc->vc_par[0]);
> return;
> case 'L':
> - csi_L(vc, par[0]);
> + csi_L(vc, vc->vc_par[0]);
> return;
> case 'M':
> - csi_M(vc, par[0]);
> + csi_M(vc, vc->vc_par[0]);
> return;
> case 'P':
> - csi_P(vc, par[0]);
> + csi_P(vc, vc->vc_par[0]);
> return;
> case 'c':
> - if (!par[0])
> + if (!vc->vc_par[0])
> respond_ID(tty);
> return;
> case 'g':
> - if (!par[0])
> - tab_stop[x >> 5] &= ~(1 << (x & 31));
> - else if (par[0] == 3) {
> - tab_stop[0] =
> - tab_stop[1] =
> - tab_stop[2] =
> - tab_stop[3] =
> - tab_stop[4] = 0;
> + if (!vc->vc_par[0])
> + vc->vc_tab_stop[vc->vc_x >> 5] &= ~(1 << (vc->vc_x & 31));
> + else if (vc->vc_par[0] == 3) {
> + vc->vc_tab_stop[0] =
> + vc->vc_tab_stop[1] =
> + vc->vc_tab_stop[2] =
> + vc->vc_tab_stop[3] =
> + vc->vc_tab_stop[4] = 0;
> }
> return;
> case 'm':
> @@ -1774,20 +1785,20 @@ static void do_con_trol(struct tty_struc
> return;
> case 'q': /* DECLL - but only 3 leds */
> /* map 0,1,2,3 to 0,1,2,4 */
> - if (par[0] < 4)
> + if (vc->vc_par[0] < 4)
> setledstate(kbd_table + vc->vc_num,
> - (par[0] < 3) ? par[0] : 4);
> + (vc->vc_par[0] < 3) ? vc->vc_par[0] : 4);
> return;
> case 'r':
> - if (!par[0])
> - par[0]++;
> - if (!par[1])
> - par[1] = vc->vc_rows;
> + if (!vc->vc_par[0])
> + vc->vc_par[0]++;
> + if (!vc->vc_par[1])
> + vc->vc_par[1] = vc->vc_rows;
> /* Minimum allowed region is 2 lines */
> - if (par[0] < par[1] &&
> - par[1] <= vc->vc_rows) {
> - top=par[0]-1;
> - bottom=par[1];
> + if (vc->vc_par[0] < vc->vc_par[1] &&
> + vc->vc_par[1] <= vc->vc_rows) {
> + vc->vc_top = vc->vc_par[0] - 1;
> + vc->vc_bottom = vc->vc_par[1];
> gotoxay(vc, 0, 0);
> }
> return;
> @@ -1798,10 +1809,10 @@ static void do_con_trol(struct tty_struc
> restore_cur(vc);
> return;
> case 'X':
> - csi_X(vc, par[0]);
> + csi_X(vc, vc->vc_par[0]);
> return;
> case '@':
> - csi_at(vc, par[0]);
> + csi_at(vc, vc->vc_par[0]);
> return;
> case ']': /* setterm functions */
> setterm_command(vc);
> @@ -1809,60 +1820,60 @@ static void do_con_trol(struct tty_struc
> }
> return;
> case ESpercent:
> - vc_state = ESnormal;
> + vc->vc_state = ESnormal;
> switch (c) {
> case '@': /* defined in ISO 2022 */
> - utf = 0;
> + vc->vc_utf = 0;
> return;
> case 'G': /* prelim official escape code */
> case '8': /* retained for compatibility */
> - utf = 1;
> + vc->vc_utf = 1;
> return;
> }
> return;
> case ESfunckey:
> - vc_state = ESnormal;
> + vc->vc_state = ESnormal;
> return;
> case EShash:
> - vc_state = ESnormal;
> + vc->vc_state = ESnormal;
> if (c == '8') {
> /* DEC screen alignment test. kludge :-) */
> - video_erase_char =
> - (video_erase_char & 0xff00) | 'E';
> + vc->vc_video_erase_char =
> + (vc->vc_video_erase_char & 0xff00) | 'E';
> csi_J(vc, 2);
> - video_erase_char =
> - (video_erase_char & 0xff00) | ' ';
> - do_update_region(vc, origin, screenbuf_size / 2);
> + vc->vc_video_erase_char =
> + (vc->vc_video_erase_char & 0xff00) | ' ';
> + do_update_region(vc, vc->vc_origin, vc->vc_screenbuf_size / 2);
> }
> return;
> case ESsetG0:
> if (c == '0')
> - G0_charset = GRAF_MAP;
> + vc->vc_G0_charset = GRAF_MAP;
> else if (c == 'B')
> - G0_charset = LAT1_MAP;
> + vc->vc_G0_charset = LAT1_MAP;
> else if (c == 'U')
> - G0_charset = IBMPC_MAP;
> + vc->vc_G0_charset = IBMPC_MAP;
> else if (c == 'K')
> - G0_charset = USER_MAP;
> - if (charset == 0)
> - translate = set_translate(G0_charset, vc);
> - vc_state = ESnormal;
> + vc->vc_G0_charset = USER_MAP;
> + if (vc->vc_charset == 0)
> + vc->vc_translate = set_translate(vc->vc_G0_charset, vc);
> + vc->vc_state = ESnormal;
> return;
> case ESsetG1:
> if (c == '0')
> - G1_charset = GRAF_MAP;
> + vc->vc_G1_charset = GRAF_MAP;
> else if (c == 'B')
> - G1_charset = LAT1_MAP;
> + vc->vc_G1_charset = LAT1_MAP;
> else if (c == 'U')
> - G1_charset = IBMPC_MAP;
> + vc->vc_G1_charset = IBMPC_MAP;
> else if (c == 'K')
> - G1_charset = USER_MAP;
> - if (charset == 1)
> - translate = set_translate(G1_charset, vc);
> - vc_state = ESnormal;
> + vc->vc_G1_charset = USER_MAP;
> + if (vc->vc_charset == 1)
> + vc->vc_translate = set_translate(vc->vc_G1_charset, vc);
> + vc->vc_state = ESnormal;
> return;
> default:
> - vc_state = ESnormal;
> + vc->vc_state = ESnormal;
> }
> }
>
> @@ -1885,7 +1896,7 @@ static int do_con_write(struct tty_struc
> #define FLUSH do { } while(0);
> #else
> #define FLUSH if (draw_x >= 0) { \
> - sw->con_putcs(vc, (u16 *)draw_from, (u16 *)draw_to-(u16 *)draw_from, y, draw_x); \
> + vc->vc_sw->con_putcs(vc, (u16 *)draw_from, (u16 *)draw_to - (u16 *)draw_from, vc->vc_y, draw_x); \
> draw_x = -1; \
> }
> #endif
> @@ -1945,7 +1956,7 @@ static int do_con_write(struct tty_struc
> goto out;
> }
>
> - himask = hi_font_mask;
> + himask = vc->vc_hi_font_mask;
> charmask = himask ? 0x1ff : 0xff;
>
> /* undraw cursor first */
> @@ -1960,44 +1971,44 @@ static int do_con_write(struct tty_struc
> count--;
>
> /* Do no translation at all in control states */
> - if (vc_state != ESnormal) {
> + if (vc->vc_state != ESnormal) {
> tc = c;
> - } else if (utf) {
> + } else if (vc->vc_utf) {
> /* Combine UTF-8 into Unicode */
> /* Incomplete characters silently ignored */
> if(c > 0x7f) {
> - if (utf_count > 0 && (c & 0xc0) == 0x80) {
> - utf_char = (utf_char << 6) | (c & 0x3f);
> - utf_count--;
> - if (utf_count == 0)
> - tc = c = utf_char;
> + if (vc->vc_utf_count > 0 && (c & 0xc0) == 0x80) {
> + vc->vc_utf_char = (vc->vc_utf_char << 6) | (c & 0x3f);
> + vc->vc_utf_count--;
> + if (vc->vc_utf_count == 0)
> + tc = c = vc->vc_utf_char;
> else continue;
> } else {
> if ((c & 0xe0) == 0xc0) {
> - utf_count = 1;
> - utf_char = (c & 0x1f);
> + vc->vc_utf_count = 1;
> + vc->vc_utf_char = (c & 0x1f);
> } else if ((c & 0xf0) == 0xe0) {
> - utf_count = 2;
> - utf_char = (c & 0x0f);
> + vc->vc_utf_count = 2;
> + vc->vc_utf_char = (c & 0x0f);
> } else if ((c & 0xf8) == 0xf0) {
> - utf_count = 3;
> - utf_char = (c & 0x07);
> + vc->vc_utf_count = 3;
> + vc->vc_utf_char = (c & 0x07);
> } else if ((c & 0xfc) == 0xf8) {
> - utf_count = 4;
> - utf_char = (c & 0x03);
> + vc->vc_utf_count = 4;
> + vc->vc_utf_char = (c & 0x03);
> } else if ((c & 0xfe) == 0xfc) {
> - utf_count = 5;
> - utf_char = (c & 0x01);
> + vc->vc_utf_count = 5;
> + vc->vc_utf_char = (c & 0x01);
> } else
> - utf_count = 0;
> + vc->vc_utf_count = 0;
> continue;
> }
> } else {
> tc = c;
> - utf_count = 0;
> + vc->vc_utf_count = 0;
> }
> } else { /* no utf */
> - tc = translate[toggle_meta ? (c|0x80) : c];
> + tc = vc->vc_translate[vc->vc_toggle_meta ? (c | 0x80) : c];
> }
>
> /* If the original code was a control character we
> @@ -2011,12 +2022,12 @@ static int do_con_write(struct tty_struc
> * direct-to-font zone in UTF-8 mode.
> */
> ok = tc && (c >= 32 ||
> - (!utf && !(((disp_ctrl ? CTRL_ALWAYS
> - : CTRL_ACTION) >> c) & 1)))
> - && (c != 127 || disp_ctrl)
> + (!vc->vc_utf && !(((vc->vc_disp_ctrl ? CTRL_ALWAYS
> + : CTRL_ACTION) >> c) & 1)))
> + && (c != 127 || vc->vc_disp_ctrl)
> && (c != 128+27);
>
> - if (vc_state == ESnormal && ok) {
> + if (vc->vc_state == ESnormal && ok) {
> /* Now try to find out how to display it */
> tc = conv_uni_to_pc(vc, tc);
> if ( tc == -4 ) {
> @@ -2036,28 +2047,28 @@ static int do_con_write(struct tty_struc
> if (tc & ~charmask)
> continue; /* Conversion failed */
>
> - if (need_wrap || decim)
> + if (vc->vc_need_wrap || vc->vc_decim)
> FLUSH
> - if (need_wrap) {
> + if (vc->vc_need_wrap) {
> cr(vc);
> lf(vc);
> }
> - if (decim)
> + if (vc->vc_decim)
> insert_char(vc, 1);
> scr_writew(himask ?
> - ((attr << 8) & ~himask) + ((tc & 0x100) ? himask : 0) + (tc & 0xff) :
> - (attr << 8) + tc,
> - (u16 *) pos);
> + ((vc->vc_attr << 8) & ~himask) + ((tc & 0x100) ? himask : 0) + (tc & 0xff) :
> + (vc->vc_attr << 8) + tc,
> + (u16 *) vc->vc_pos);
> if (DO_UPDATE(vc) && draw_x < 0) {
> - draw_x = x;
> - draw_from = pos;
> + draw_x = vc->vc_x;
> + draw_from = vc->vc_pos;
> }
> - if (x == vc->vc_cols - 1) {
> - need_wrap = decawm;
> - draw_to = pos+2;
> + if (vc->vc_x == vc->vc_cols - 1) {
> + vc->vc_need_wrap = vc->vc_decawm;
> + draw_to = vc->vc_pos + 2;
> } else {
> - x++;
> - draw_to = (pos+=2);
> + vc->vc_x++;
> + draw_to = (vc->vc_pos += 2);
> }
> continue;
> }
> @@ -2104,8 +2115,8 @@ static void console_callback(void *ignor
> if (scrollback_delta) {
> struct vc_data *vc = vc_cons[fg_console].d;
> clear_selection();
> - if (vcmode == KD_TEXT)
> - sw->con_scrolldelta(vc, scrollback_delta);
> + if (vt_cons[vc->vc_num]->vc_mode == KD_TEXT)
> + vc->vc_sw->con_scrolldelta(vc, scrollback_delta);
> scrollback_delta = 0;
> }
> if (blank_timer_expired) {
> @@ -2150,7 +2161,7 @@ void vt_console_print(struct console *co
>
> /* read `x' only after setting currcons properly (otherwise
> the `x' macro will read the x of the foreground console). */
> - myx = x;
> + myx = vc->vc_x;
>
> if (!vc_cons_allocated(fg_console)) {
> /* impossible */
> @@ -2158,58 +2169,58 @@ void vt_console_print(struct console *co
> goto quit;
> }
>
> - if (vcmode != KD_TEXT)
> + if (vt_cons[vc->vc_num]->vc_mode != KD_TEXT)
> goto quit;
>
> /* undraw cursor first */
> if (vc->vc_num == fg_console)
> hide_cursor(vc);
>
> - start = (ushort *)pos;
> + start = (ushort *)vc->vc_pos;
>
> /* Contrived structure to try to emulate original need_wrap behaviour
> * Problems caused when we have need_wrap set on '\n' character */
> while (count--) {
> c = *b++;
> - if (c == 10 || c == 13 || c == 8 || need_wrap) {
> + if (c == 10 || c == 13 || c == 8 || vc->vc_need_wrap) {
> if (cnt > 0) {
> if (CON_IS_VISIBLE(vc))
> - sw->con_putcs(vc, start, cnt, y, x);
> - x += cnt;
> - if (need_wrap)
> - x--;
> + vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, vc->vc_x);
> + vc->vc_x += cnt;
> + if (vc->vc_need_wrap)
> + vc->vc_x--;
> cnt = 0;
> }
> if (c == 8) { /* backspace */
> bs(vc);
> - start = (ushort *)pos;
> - myx = x;
> + start = (ushort *)vc->vc_pos;
> + myx = vc->vc_x;
> continue;
> }
> if (c != 13)
> lf(vc);
> cr(vc);
> - start = (ushort *)pos;
> - myx = x;
> + start = (ushort *)vc->vc_pos;
> + myx = vc->vc_x;
> if (c == 10 || c == 13)
> continue;
> }
> - scr_writew((attr << 8) + c, (unsigned short *) pos);
> + scr_writew((vc->vc_attr << 8) + c, (unsigned short *)vc->vc_pos);
> cnt++;
> if (myx == vc->vc_cols - 1) {
> - need_wrap = 1;
> + vc->vc_need_wrap = 1;
> continue;
> }
> - pos+=2;
> + vc->vc_pos += 2;
> myx++;
> }
> if (cnt > 0) {
> if (CON_IS_VISIBLE(vc))
> - sw->con_putcs(vc, start, cnt, y, x);
> - x += cnt;
> - if (x == vc->vc_cols) {
> - x--;
> - need_wrap = 1;
> + vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, vc->vc_x);
> + vc->vc_x += cnt;
> + if (vc->vc_x == vc->vc_cols) {
> + vc->vc_x--;
> + vc->vc_need_wrap = 1;
> }
> }
> set_cursor(vc);
> @@ -2498,19 +2509,19 @@ static void vc_init(struct vc_data *vc,
> vc->vc_cols = cols;
> vc->vc_rows = rows;
> vc->vc_size_row = cols << 1;
> - screenbuf_size = vc->vc_rows * vc->vc_size_row;
> + vc->vc_screenbuf_size = vc->vc_rows * vc->vc_size_row;
>
> set_origin(vc);
> - pos = origin;
> + vc->vc_pos = vc->vc_origin;
> reset_vc(vc);
> for (j=k=0; j<16; j++) {
> vc->vc_palette[k++] = default_red[j] ;
> vc->vc_palette[k++] = default_grn[j] ;
> vc->vc_palette[k++] = default_blu[j] ;
> }
> - def_color = 0x07; /* white */
> - ulcolor = 0x0f; /* bold white */
> - halfcolor = 0x08; /* grey */
> + vc->vc_def_color = 0x07; /* white */
> + vc->vc_ulcolor = 0x0f; /* bold white */
> + vc->vc_halfcolor = 0x08; /* grey */
> init_waitqueue_head(&vt_cons[vc->vc_num]->paste_wait);
> reset_terminal(vc, do_clear);
> }
> @@ -2554,16 +2565,16 @@ static int __init con_init(void)
> alloc_bootmem(sizeof(struct vt_struct));
> vc_cons[currcons].d->vc_vt = vt_cons[currcons];
> visual_init(vc, currcons, 1);
> - screenbuf = (unsigned short *) alloc_bootmem(screenbuf_size);
> - kmalloced = 0;
> + vc->vc_screenbuf = (unsigned short *)alloc_bootmem(vc->vc_screenbuf_size);
> + vc->vc_kmalloced = 0;
> vc_init(vc, vc->vc_rows, vc->vc_cols,
> - currcons || !sw->con_save_screen);
> + currcons || !vc->vc_sw->con_save_screen);
> }
> currcons = fg_console = 0;
> master_display_fg = vc = vc_cons[currcons].d;
> set_origin(vc);
> save_screen(vc);
> - gotoxy(vc, x, y);
> + gotoxy(vc, vc->vc_x, vc->vc_y);
> csi_J(vc, 0);
> update_screen(vc);
> printk("Console: %s %s %dx%d",
> @@ -2677,10 +2688,10 @@ int take_over_console(const struct consw
> save_screen(vc);
> old_was_color = vc->vc_can_do_color;
> vc->vc_sw->con_deinit(vc);
> - origin = (unsigned long) screenbuf;
> - visible_origin = origin;
> - scr_end = origin + screenbuf_size;
> - pos = origin + vc->vc_size_row * y + 2 * x;
> + vc->vc_origin = (unsigned long)vc->vc_screenbuf;
> + vc->vc_visible_origin = vc->vc_origin;
> + vc->vc_scr_end = vc->vc_origin + vc->vc_screenbuf_size;
> + vc->vc_pos = vc->vc_origin + vc->vc_size_row * vc->vc_y + 2 * vc->vc_x;
> visual_init(vc, i, 0);
> update_attr(vc);
>
> @@ -2780,14 +2791,14 @@ void do_blank_screen(int entering_gfx)
> if (entering_gfx) {
> hide_cursor(vc);
> save_screen(vc);
> - sw->con_blank(vc, -1, 1);
> + vc->vc_sw->con_blank(vc, -1, 1);
> console_blanked = fg_console + 1;
> set_origin(vc);
> return;
> }
>
> /* don't blank graphics */
> - if (vcmode != KD_TEXT) {
> + if (vt_cons[vc->vc_num]->vc_mode != KD_TEXT) {
> console_blanked = fg_console + 1;
> return;
> }
> @@ -2798,7 +2809,7 @@ void do_blank_screen(int entering_gfx)
>
> save_screen(vc);
> /* In case we need to reset origin, blanking hook returns 1 */
> - i = sw->con_blank(vc, 1, 0);
> + i = vc->vc_sw->con_blank(vc, 1, 0);
> console_blanked = fg_console + 1;
> if (i)
> set_origin(vc);
> @@ -2812,7 +2823,7 @@ void do_blank_screen(int entering_gfx)
> }
>
> if (vesa_blank_mode)
> - sw->con_blank(vc, vesa_blank_mode + 1, 0);
> + vc->vc_sw->con_blank(vc, vesa_blank_mode + 1, 0);
> }
> EXPORT_SYMBOL(do_blank_screen);
>
> @@ -2834,7 +2845,7 @@ void do_unblank_screen(int leaving_gfx)
> return;
> }
> vc = vc_cons[fg_console].d;
> - if (vcmode != KD_TEXT)
> + if (vt_cons[vc->vc_num]->vc_mode != KD_TEXT)
> return; /* but leave console_blanked != 0 */
>
> if (blankinterval) {
> @@ -2843,7 +2854,7 @@ void do_unblank_screen(int leaving_gfx)
> }
>
> console_blanked = 0;
> - if (sw->con_blank(vc, 0, leaving_gfx))
> + if (vc->vc_sw->con_blank(vc, 0, leaving_gfx))
> /* Low-level driver cannot restore -> do it ourselves */
> update_screen(vc);
> if (console_blank_hook)
> @@ -2903,8 +2914,8 @@ void set_palette(struct vc_data *vc)
> {
> WARN_CONSOLE_UNLOCKED();
>
> - if (vcmode != KD_GRAPHICS)
> - sw->con_set_palette(vc, color_table);
> + if (vt_cons[vc->vc_num]->vc_mode != KD_GRAPHICS)
> + vc->vc_sw->con_set_palette(vc, color_table);
> }
>
> static int set_get_cmap(unsigned char __user *arg, int set)
> @@ -2968,9 +2979,9 @@ void reset_palette(struct vc_data *vc)
> {
> int j, k;
> for (j=k=0; j<16; j++) {
> - palette[k++] = default_red[j];
> - palette[k++] = default_grn[j];
> - palette[k++] = default_blu[j];
> + vc->vc_palette[k++] = default_red[j];
> + vc->vc_palette[k++] = default_grn[j];
> + vc->vc_palette[k++] = default_blu[j];
> }
> set_palette(vc);
> }
> @@ -3007,8 +3018,8 @@ int con_font_get(struct vc_data *vc, str
> font.data = NULL;
>
> acquire_console_sem();
> - if (sw->con_font_get)
> - rc = sw->con_font_get(vc, &font);
> + if (vc->vc_sw->con_font_get)
> + rc = vc->vc_sw->con_font_get(vc, &font);
> else
> rc = -ENOSYS;
> release_console_sem();
> @@ -3093,8 +3104,8 @@ int con_font_set(struct vc_data *vc, str
> return -EFAULT;
> }
> acquire_console_sem();
> - if (sw->con_font_set)
> - rc = sw->con_font_set(vc, &font, op->flags);
> + if (vc->vc_sw->con_font_set)
> + rc = vc->vc_sw->con_font_set(vc, &font, op->flags);
> else
> rc = -ENOSYS;
> release_console_sem();
> @@ -3120,8 +3131,8 @@ int con_font_default(struct vc_data *vc,
> name[MAX_FONT_NAME - 1] = 0;
>
> acquire_console_sem();
> - if (sw->con_font_default)
> - rc = sw->con_font_default(vc, &font, s);
> + if (vc->vc_sw->con_font_default)
> + rc = vc->vc_sw->con_font_default(vc, &font, s);
> else
> rc = -ENOSYS;
> release_console_sem();
> @@ -3141,14 +3152,14 @@ int con_font_copy(struct vc_data *vc, st
> return -EINVAL;
>
> acquire_console_sem();
> - if (!sw->con_font_copy)
> + if (!vc->vc_sw->con_font_copy)
> rc = -ENOSYS;
> else if (con < 0 || !vc_cons_allocated(con))
> rc = -ENOTTY;
> else if (con == vc->vc_num) /* nothing to do */
> rc = 0;
> else
> - rc = sw->con_font_copy(vc, con);
> + rc = vc->vc_sw->con_font_copy(vc, con);
> release_console_sem();
> return rc;
> }
> -
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at http://www.tux.org/lkml/
>
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Follow-Ups:
References: