Date: Fri, 21 Mar 1997 10:31:58 +0100 (MET) From: Geert Uytterhoeven To: Linux/m68k Subject: L68K: Abstract console patches Sender: owner-linux-m68k@phil.uni-sb.de Reply-To: linux-m68k@phil.uni-sb.de Here are the abstract console patches for 2.1.29. I have them relative to the native source tree to. Should I send them to Linus directly? P.S. My experimental console speedup patches (ywrap+bmove may be faster than bmove only) can be found in the second part of this mail. --- linux-2.1.29/arch/m68k/kernel/Makefile.orig Tue Mar 18 23:50:12 1997 +++ linux-2.1.29/arch/m68k/kernel/Makefile Thu Mar 20 20:56:01 1997 @@ -13,7 +13,7 @@ all: kernel.o head.o O_TARGET := kernel.o O_OBJS := entry.o process.o traps.o ints.o signal.o ptrace.o \ - setup.o bios32.o sys_m68k.o console.o time.o + setup.o bios32.o sys_m68k.o time.o OX_OBJS := m68k_ksyms.o ifdef CONFIG_KGDB --- linux-2.1.29/drivers/char/Makefile.orig Tue Mar 18 23:50:18 1997 +++ linux-2.1.29/drivers/char/Makefile Thu Mar 20 20:57:29 1997 @@ -32,7 +32,11 @@ endif ifeq "$(ARCH)" "m68k" -L_OBJS += fbmem.o keyboard.o defkeymap.o +L_OBJS += console.o fbmem.o keyboard.o defkeymap.o +endif + +ifeq ($(CONFIG_ABSTRACT_CONSOLE),y) + L_OBJS += abscon.o endif ifeq ($(CONFIG_AMIGA_GSP),y) --- linux-2.1.29/drivers/char/abscon.c.orig Thu Mar 20 21:04:05 1997 +++ linux-2.1.29/drivers/char/abscon.c Thu Mar 20 21:04:58 1997 @@ -0,0 +1,270 @@ +/* + * linux/drivers/char/abscon.c + * + * Created 7 Jan 1997 by Geert Uytterhoeven + * + * This module contains the abstract console driver on Linux/m68k. + * It is based on the original console driver, modified for Linux/m68k by + * + * - Arno Griffioen + * - David Carter + * + * The abstract console driver provides a generic interface for a non-VGA + * compatible text console. It can be used for machines that don't have a text + * mode at all or that have a special graphics processor that's only + * accessible through some registers (e.g. a TMS340x0 GSP). + * + * The interface to the hardware is specified using a special structure + * (struct consw) which contains function pointers to the following + * operations: + * + * u_long con_startup(u_long kmem_start, const char **display_desc) + * void con_init(struct vc_data *conp) + * int con_deinit(struct vc_data *conp) + * int con_clear(struct vc_data *conp, int sy, int sx, int height, + * int width) + * int con_putc(struct vc_data *conp, int c, int y, int x) + * int con_putcs(struct vc_data *conp, const char *s, int count, int y, + * int x) + * int con_cursor(struct vc_data *conp, int mode) + * int con_scroll(struct vc_data *conp, int t, int b, int dir, int count) + * int con_bmove(struct vc_data *conp, int sy, int sx, int dy, int dx, + * int height, int width) + * int con_switch(struct vc_data *conp) + * int con_blank(int blank) + * int con_get_font(struct vc_data *conp, int *w, int *h, char *data) + * int con_set_font(struct vc_data *conp, int w, int h, char *data) + * int con_set_palette(struct vc_data *conp, unsigned char *table) + * + * Currently the abstract console driver is used by: + * + * - arch/m68k/fbcon.c: Generic text console driver for a bitmapped display + * that's accessible through a frame buffer device + * + * - arch/m68k/gspcon.c: Text console driver for video boards based on the + * Texas Instruments TMS34010 Graphical Signal + * Processor (e.g. CBM A2410 and DMI Resolver on + * Amiga) [ work in progress ] + * + * - arch/m68k/txtcon.c: Skeleton for a simple text mode driver + * + * This file is subject to the terms and conditions of the GNU General Public + * License. See the file COPYING in the main directory of this archive for + * more details. + */ + +/* + * TODO: + * + * - scrollback support + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "vt_kern.h" +#include "selection.h" +#include "console_macros.h" + + +struct consw *conswitchp; + +static int vesa_blank_mode = 0; /* 0:none 1:suspendV 2:suspendH 3:powerdown */ + + +void abscon_init(int currcons) +{ + /* ++Geert: sw->con_init determines console size */ + sw = conswitchp; + cons_num = currcons; + sw->con_init(vc_cons[currcons].d); + video_size_row = video_num_columns<<1; + video_screen_size = video_num_lines*video_size_row; +} + +void hide_cursor(int currcons) +{ + sw->con_cursor(vc_cons[currcons].d,CM_ERASE); +} + +void set_cursor(int currcons) +{ + if (currcons != fg_console || console_blanked || vcmode == KD_GRAPHICS) + return; + if (deccm) + sw->con_cursor(vc_cons[currcons].d,CM_DRAW); + else + hide_cursor(currcons); +} + +unsigned long con_type_init(unsigned long kmem_start, const char **display_desc) +{ + return(conswitchp->con_startup(kmem_start, display_desc)); +} + +void con_type_init_finish(void) +{ +} + +void set_vesa_blanking(int arg) +{ + char *argp = (char *)arg + 1; + unsigned int mode; + get_user(mode, argp); + vesa_blank_mode = (mode < 4) ? mode : 0; +} + +void vesa_blank(void) +{ + vc_cons[fg_console].d->vc_sw->con_blank(vesa_blank_mode + 1); +} + +void vesa_powerdown(void) +{ + /* Power down if currently suspended (1 or 2), + * suspend if currently blanked (0), + * else do nothing (i.e. already powered down (3)). + * Called only if powerdown features are allowed. + */ + switch (vesa_blank_mode) { + case 0: + vc_cons[fg_console].d->vc_sw->con_blank(2); + break; + case 1: + case 2: + vc_cons[fg_console].d->vc_sw->con_blank(4); + break; + } +} + +/* + * PIO_FONT support. + * + * Currently we only support 8 pixels wide fonts, at a maximum height + * of 32 pixels. Userspace fontdata is stored with 32 bytes reserved + * for each character which is kinda wasty, but this is done in order + * to maintain compatibility with the EGA/VGA fonts. It is upto the + * actual low-level console-driver convert data into its favorite + * format (maybe we should add a `fontoffset' field to the `display' + * structure so we wont have to convert the fontdata all the time. + * /Jes + */ + +#define cmapsz 8192 + +int set_get_font(unsigned char * arg, int set, int ch512) +{ + int i, unit, size; + char *charmap; + + if (!arg) + return -EINVAL; + + + size = ch512 ? 2*cmapsz : cmapsz; + + charmap = (char *)kmalloc(size, GFP_USER); + + if (set) { + if (copy_from_user(charmap, arg, size)) { + kfree(charmap); + return -EFAULT; + } + + for (unit = 32; unit > 0; unit--) + for (i = 0; i < (ch512 ? 512 : 256); i++) + if (charmap[32*i+unit-1]) + goto nonzero; + nonzero: + i = conswitchp->con_set_font(vc_cons[fg_console].d, 8, + unit, charmap); + } else { + memset(charmap, 0, size); + i = conswitchp->con_get_font(vc_cons[fg_console].d, + &unit, &unit, charmap); + if (i == 0 && copy_to_user(arg, charmap, size)) + i = -EFAULT; + } + kfree(charmap); + + return i; +} + +/* + * Adjust the screen to fit a font of a certain height + * + * Returns < 0 for error, 0 if nothing changed, and the number + * of lines on the adjusted console if changed. + */ + +int con_adjust_height(unsigned long fontheight) +{ + int currcons = fg_console; + /* ++Geert: Always assume that the number of lines did change? */ + return video_num_lines; +} + +/* dummy functions */ + +void no_scroll(char *str, int *ints) +{ +} + +void scrollback(int lines) +{ + printk("scrollback(%d)\n", lines); +} + +void scrollfront(int lines) +{ + printk("scrollfront(%d)\n", lines); +} + +void set_palette(void) +{ + if (vt_cons[fg_console]->vc_mode != KD_GRAPHICS) + conswitchp->con_set_palette(vc_cons[fg_console].d, color_table); +} + +int set_get_cmap(unsigned char *arg, int set) +{ + int i, j, k; + + i = verify_area(set ? VERIFY_READ : VERIFY_WRITE, (void *)arg, 16*3); + if (i) + return i; + + for (i = 0; i < 16; i++) + if (set) { + get_user(default_red[i], arg++); + get_user(default_grn[i], arg++); + get_user(default_blu[i], arg++); + } else { + put_user(default_red[i], arg++); + put_user(default_grn[i], arg++); + put_user(default_blu[i], arg++); + } + if (set) { + for (i = 0; i < MAX_NR_CONSOLES; i++) + if (vc_cons_allocated(i)) + for (j = k = 0; j < 16; j++) { + vc_cons[i].d->vc_palette[k++] = default_red[j]; + vc_cons[i].d->vc_palette[k++] = default_grn[j]; + vc_cons[i].d->vc_palette[k++] = default_blu[j]; + } + set_palette(); + } + return 0; +} --- linux-2.1.29/drivers/char/console.c.orig Sun Feb 16 22:23:58 1997 +++ linux-2.1.29/drivers/char/console.c Thu Mar 20 21:04:06 1997 @@ -13,6 +13,8 @@ * 'int vc_allocate(unsigned int console)' * 'int vc_cons_allocated(unsigned int console)' * 'int vc_resize(unsigned long lines, unsigned long cols)' + * 'int vc_resize_con(unsigned long lines, unsigned long cols, + * unsigned int currcons)' * 'void vc_disallocate(unsigned int currcons)' * * 'unsigned long con_init(unsigned long)' @@ -61,6 +63,24 @@ * redirection by Martin Mares 19-Nov-95 * * APM screenblank bug fixed Takashi Manabe + * + * Merge with the abstract console driver (m68k) by Geert Uytterhoeven + * , Jan 1997. + * + * Original m68k console driver modifications by + * + * - Arno Griffioen + * - David Carter + * + * Note that the abstract console driver allows all consoles to be of + * potentially different sizes, so the following variables depend on the + * current console (currcons): + * + * - video_num_columns + * - video_num_lines + * - video_size_row + * - video_screen_size + * - can_do_color */ #define BLANK 0x0020 @@ -100,6 +120,7 @@ #include #include #include +#include #ifdef CONFIG_APM #include #endif @@ -113,16 +134,20 @@ #include "vt_kern.h" #include "consolemap.h" #include "selection.h" -#include "console_struct.h" +#include "console_macros.h" #ifndef MIN #define MIN(a,b) ((a) < (b) ? (a) : (b)) #endif -#ifdef __sparc__ -int serial_console; +#if defined(CONFIG_SERIAL_CONSOLE) || defined(__sparc__) +int serial_console = 0; #endif +#ifdef __mc68000__ +extern int serial_debug; +#endif /* __mc68000__ */ + struct tty_driver console_driver; static int console_refcount; static struct tty_struct *console_table[MAX_NR_CONSOLES]; @@ -131,26 +156,22 @@ unsigned short *vc_scrbuf[MAX_NR_CONSOLES]; struct vc vc_cons [MAX_NR_CONSOLES]; -static void con_setsize(unsigned long rows, unsigned long cols); static void vc_init(unsigned int console, unsigned long rows, unsigned long cols, int do_clear); -extern void get_scrmem(int currcons); -extern void set_scrmem(int currcons, long offset); -static void set_origin(int currcons); static void blank_screen(void); static void unblank_screen(void); extern void change_console(unsigned int); extern void poke_blanked_console(void); +static void update_attr(int currcons); static void gotoxy(int currcons, int new_x, int new_y); static void save_cur(int currcons); extern void set_cursor(int currcons); -extern void hide_cursor(void); +extern void hide_cursor(int currcons); static void reset_terminal(int currcons, int do_clear); extern void reset_vc(unsigned int new_console); extern void vt_init(void); extern void register_console(void (*proc)(const char *)); extern void vesa_blank(void); -extern void vesa_unblank(void); extern void vesa_powerdown(void); extern void compute_shiftstate(void); extern void reset_palette(int currcons); @@ -161,6 +182,143 @@ extern int set_get_font(unsigned char *, int, int); extern void rs_cons_hook(int chip, int out, int channel); +static int printable = 0; /* Is console ready for printing? */ + +int video_mode_512ch = 0; /* 512-character mode */ +unsigned long video_font_height; /* Height of current screen font */ +unsigned long video_scan_lines; /* Number of scan lines on screen */ +static unsigned short console_charmask = 0x0ff; + +/* used by kbd_bh - set by keyboard_interrupt */ + int do_poke_blanked_console = 0; + int console_blanked = 0; +static int blankinterval = 10*60*HZ; +static int vesa_off_interval = 0; + +#ifdef CONFIG_ABSTRACT_CONSOLE +#define ABSCON(x) abscon_##x +static char putcs_buf[256]; + +extern void abscon_init(int currcons); +static inline void abscon_erase_to_dpy_end(int currcons) +{ + if (currcons != fg_console) + return; + /* do in two stages */ + sw->con_clear(vc_cons[currcons].d,y,x,1,video_num_columns-x); + sw->con_clear(vc_cons[currcons].d,y+1,0,video_num_lines-y-1, video_num_columns); +} + +static inline void abscon_erase_from_dpy_start(int currcons) +{ + if (currcons != fg_console) + return; + /* do in two stages */ + sw->con_clear(vc_cons[currcons].d,0,0,y,video_num_columns); + sw->con_clear(vc_cons[currcons].d,y,0,1,x + 1); +} + +static inline void abscon_erase_dpy(int currcons) +{ + if (currcons != fg_console) + return; + sw->con_clear(vc_cons[currcons].d,0,0,video_num_lines,video_num_columns); +} + +static inline void abscon_erase_to_line_end(int currcons) +{ + if (currcons != fg_console) + return; + sw->con_clear(vc_cons[currcons].d,y,x,1,video_num_columns-x); +} + +static inline void abscon_erase_from_line_start(int currcons) +{ + if (currcons != fg_console) + return; + sw->con_clear(vc_cons[currcons].d,y,0,1,x + 1); +} + +static inline void abscon_erase_line(int currcons) +{ + if (currcons != fg_console) + return; + sw->con_clear(vc_cons[currcons].d,y,0,1,video_num_columns); +} + +static inline void abscon_erase_next_chars(int currcons, unsigned long count) +{ + if (currcons == fg_console) + sw->con_clear(vc_cons[currcons].d,y,x,1,count); +} + +static inline void abscon_insert_chars(int currcons, unsigned int nr) +{ + unsigned short oldattr; + if (currcons != fg_console) + return; + sw->con_bmove(vc_cons[currcons].d,y,x,y,x+nr,1,video_num_columns-x-nr); + oldattr = attr; + attr = video_erase_char >> 8; + while (nr--) + sw->con_putc(vc_cons[currcons].d,(video_erase_char & 0x00ff),y,x+nr); + attr = oldattr; +} + +static inline void abscon_delete_chars(int currcons, unsigned int nr) +{ + unsigned short oldattr; + if (currcons != fg_console) + return; + sw->con_bmove(vc_cons[currcons].d,y,x+nr,y,x,1,video_num_columns-x-nr); + oldattr = attr; + attr = video_erase_char >> 8; + while (nr--) + sw->con_putc(vc_cons[currcons].d,(video_erase_char & 0x00ff),y,video_num_columns-1-nr); + attr = oldattr; +} + +static inline void abscon_putc(int currcons, int tc, int yy, int xx) +{ + if (currcons == fg_console) + sw->con_putc(vc_cons[currcons].d,tc,yy,xx); +} + +static inline void abscon_putc_attr(int currcons, unsigned short new, + int yy, int xx, unsigned short oldattr) +{ + if (currcons != fg_console) + return; + attr = new >> 8; + sw->con_putc(vc_cons[currcons].d, new & 0xff, yy, xx); + attr = oldattr; +} + +static inline void abscon_putc_attr_next(int currcons, unsigned short new, + int *yy, int *xx) +{ + if (currcons != fg_console) + return; + attr = new >> 8; + sw->con_putc(vc_cons[currcons].d, new & 0xff, *yy, *xx); + if (++(*xx) == video_num_columns) + *xx = 0, ++(*yy); +} + +#define abscon_update_attr update_attr +#define abscon_update_screen update_screen +#define abscon_hide_cursor hide_cursor + +static inline void get_scrmem(int currcons) {} +static inline void set_scrmem(int currcons, long offset) {} +static inline void set_origin(int currcons) {} +#else /* !CONFIG_ABSTRACT_CONSOLE */ +#define ABSCON(x) do {} while (0) +extern void get_scrmem(int currcons); +extern void set_scrmem(int currcons, long offset); +static void set_origin(int currcons); +extern void vesa_unblank(void); + /* Description of the hardware situation */ unsigned char video_type; /* Type of display being used */ unsigned long video_mem_base; /* Base of video memory */ @@ -173,22 +331,11 @@ unsigned long video_screen_size; int can_do_color = 0; -static int printable = 0; /* Is console ready for printing? */ -int video_mode_512ch = 0; /* 512-character mode */ -unsigned long video_font_height; /* Height of current screen font */ -unsigned long video_scan_lines; /* Number of scan lines on screen */ unsigned long default_font_height; /* Height of default screen font */ int video_font_is_default = 1; -static unsigned short console_charmask = 0x0ff; - -/* used by kbd_bh - set by keyboard_interrupt */ - int do_poke_blanked_console = 0; - int console_blanked = 0; -static int blankinterval = 10*60*HZ; -static int vesa_off_interval = 0; static long blank_origin, blank__origin, unblank_origin; - +#endif /* !CONFIG_ABSTRACT_CONSOLE */ #ifdef CONFIG_SERIAL_ECHO @@ -267,7 +414,7 @@ serial_echo_init(int base) { int comstat, hi, lo; - + if (base != 0x2f8 && base != 0x3f8) { serial_echo_port = 0; return (0); @@ -310,42 +457,43 @@ return (i < MAX_NR_CONSOLES && vc_cons[i].d); } -int vc_allocate(unsigned int i) /* return 0 on success */ +int vc_allocate(unsigned int currcons) /* return 0 on success */ { - if (i >= MAX_NR_CONSOLES) + if (currcons >= MAX_NR_CONSOLES) return -ENXIO; - if (!vc_cons[i].d) { + if (!vc_cons[currcons].d) { long p, q; /* prevent users from taking too much memory */ - if (i >= MAX_NR_USER_CONSOLES && !suser()) + if (currcons >= MAX_NR_USER_CONSOLES && !suser()) return -EPERM; /* due to the granularity of kmalloc, we waste some memory here */ /* the alloc is done in two steps, to optimize the common situation of a 25x80 console (structsize=216, video_screen_size=4000) */ - q = (long) kmalloc(video_screen_size, GFP_KERNEL); - if (!q) - return -ENOMEM; p = (long) kmalloc(structsize, GFP_KERNEL); - if (!p) { - kfree_s((char *) q, video_screen_size); + if (!p) + return -ENOMEM; + vc_cons[currcons].d = (struct vc_data *)p; + vt_cons[currcons] = (struct vt_struct *)(p+sizeof(struct vc_data)); + ABSCON(init(currcons)); + q = (long)kmalloc(video_screen_size, GFP_KERNEL); + if (!q) { + kfree_s((char *) p, structsize); + vc_cons[currcons].d = NULL; + vt_cons[currcons] = NULL; return -ENOMEM; } - - vc_cons[i].d = (struct vc_data *) p; - p += sizeof(struct vc_data); - vt_cons[i] = (struct vt_struct *) p; - vc_scrbuf[i] = (unsigned short *) q; - vc_cons[i].d->vc_kmalloced = 1; - vc_cons[i].d->vc_screenbuf_size = video_screen_size; - vc_init (i, video_num_lines, video_num_columns, 1); + vc_scrbuf[currcons] = (unsigned short *)q; + vc_cons[currcons].d->vc_kmalloced = 1; + vc_cons[currcons].d->vc_screenbuf_size = video_screen_size; + vc_init(currcons, video_num_lines, video_num_columns, 1); } return 0; } /* - * Change # of rows and columns (0 means unchanged) + * Change # of rows and columns (0 means unchanged/the size of fg_console) * [this is to be used together with some user program * like resize that changes the hardware videomode] */ @@ -354,7 +502,7 @@ unsigned long cc, ll, ss, sr; unsigned long occ, oll, oss, osr; unsigned short *p; - unsigned int currcons, i; + unsigned int currcons = fg_console, i; unsigned short *newscreens[MAX_NR_CONSOLES]; long ol, nl, rlth, rrem; @@ -363,8 +511,10 @@ sr = cc << 1; ss = sr * ll; +#ifndef CONFIG_ABSTRACT_CONSOLE if (ss > video_mem_term - video_mem_base) return -ENOMEM; +#endif /* !CONFIG_ABSTRACT_CONSOLE */ /* * Some earlier version had all consoles of potentially @@ -389,20 +539,20 @@ get_scrmem(fg_console); - oll = video_num_lines; - occ = video_num_columns; - osr = video_size_row; - oss = video_screen_size; - - video_num_lines = ll; - video_num_columns = cc; - video_size_row = sr; - video_screen_size = ss; - for (currcons = 0; currcons < MAX_NR_CONSOLES; currcons++) { if (!vc_cons_allocated(currcons)) continue; + oll = video_num_lines; + occ = video_num_columns; + osr = video_size_row; + oss = video_screen_size; + + video_num_lines = ll; + video_num_columns = cc; + video_size_row = sr; + video_screen_size = ss; + rlth = MIN(osr, sr); rrem = sr - rlth; ol = origin; @@ -410,6 +560,7 @@ if (ll < oll) ol += (oll - ll) * osr; + ABSCON(update_attr(currcons)); while (ol < scr_end) { memcpyw((unsigned short *) nl, (unsigned short *) ol, rlth); if (rrem) @@ -419,7 +570,7 @@ } if (kmalloced) - kfree_s(vc_scrbuf[currcons], screenbuf_size); + kfree_s(vc_scrbuf[currcons], oss); vc_scrbuf[currcons] = newscreens[currcons]; kmalloced = 1; screenbuf_size = ss; @@ -437,6 +588,10 @@ save_cur(currcons); } + /* don't update in graphics mode */ + if (currcons == fg_console && vt_cons[fg_console]->vc_mode == KD_TEXT) + ABSCON(update_screen(fg_console)); + set_scrmem(fg_console, 0); set_origin(fg_console); set_cursor(fg_console); @@ -444,6 +599,96 @@ return 0; } +#ifdef CONFIG_ABSTRACT_CONSOLE +/* + * ++Geert: Change # of rows and columns for one specific console. + * Of course it's not messy to have all consoles of potentially different + * sizes, except on PCish hardware :-) + */ +void vc_resize_con(unsigned long lines, unsigned long cols, + unsigned int currcons) +{ + unsigned long cc, ll, ss, sr; + unsigned long occ, oll, oss, osr; + unsigned short *newscreen; + long ol, nl, rlth, rrem; + struct winsize ws; + + if (!cols || !lines || currcons >= MAX_NR_CONSOLES) + return; + + cc = cols; + ll = lines; + sr = cc << 1; + ss = sr * ll; + + if (!vc_cons_allocated(currcons)) + newscreen = 0; + else if (!(newscreen = (unsigned short *)kmalloc(ss, GFP_USER))) + return; + + if (vc_cons_allocated(currcons)) { + oll = video_num_lines; + occ = video_num_columns; + osr = video_size_row; + oss = video_screen_size; + + video_num_lines = ll; + video_num_columns = cc; + video_size_row = sr; + video_screen_size = ss; + + rlth = MIN(osr, sr); + rrem = sr - rlth; + ol = origin; + nl = (long) newscreen; + if (ll < oll) + ol += (oll - ll) * osr; + + /* ++Geert: TODO: Because the attributes have different meanings + for monochrome and color, they should really be converted if + can_do_color changes... */ + update_attr(currcons); + while (ol < scr_end) { + memcpyw((unsigned short *) nl, (unsigned short *) ol, rlth); + if (rrem) + memsetw((void *)(nl + rlth), video_erase_char, rrem); + ol += osr; + nl += sr; + } + + if (kmalloced) + kfree_s(vc_scrbuf[currcons], oss); + vc_scrbuf[currcons] = newscreen; + kmalloced = 1; + screenbuf_size = ss; + + origin = video_mem_start = (long) vc_scrbuf[currcons]; + scr_end = video_mem_end = video_mem_start + ss; + + if (scr_end > nl) + memsetw((void *) nl, video_erase_char, scr_end - nl); + + /* do part of a reset_terminal() */ + top = 0; + bottom = video_num_lines; + gotoxy(currcons, x, y); + save_cur(currcons); + + ws.ws_row = video_num_lines; + ws.ws_col = video_num_columns; + if (memcmp(&ws, &console_table[currcons]->winsize, + sizeof (struct winsize)) && console_table[currcons]->pgrp > 0) + kill_pg(console_table[currcons]->pgrp, SIGWINCH, 1); + console_table[currcons]->winsize = ws; + } + + /* don't update in graphics mode */ + if (currcons == fg_console && vt_cons[fg_console]->vc_mode == KD_TEXT) + update_screen(fg_console); +} +#endif /* CONFIG_ABSTRACT_CONSOLE */ + void vc_disallocate(unsigned int currcons) { if (vc_cons_allocated(currcons)) { @@ -498,7 +743,7 @@ x = video_num_columns - 1; else x = new_x; - if (decom) { + if (decom) { min_y = top; max_y = bottom; } else { @@ -521,6 +766,7 @@ gotoxy(currcons, new_x, decom ? (top+new_y) : new_y); } +#ifndef CONFIG_ABSTRACT_CONSOLE /* * Hardware scrollback support */ @@ -598,14 +844,29 @@ __real_origin = (origin-video_mem_base) >> 1; __set_origin(__real_origin); } +#endif /* !CONFIG_ABSTRACT_CONSOLE */ -void scrup(int currcons, unsigned int t, unsigned int b) +void scrup(int currcons, unsigned int t, unsigned int b, int nr) { +#ifdef CONFIG_ABSTRACT_CONSOLE + unsigned short *p; + + if (b > video_num_lines || t >= b) + return; + memmove((unsigned short *)video_mem_start + t * video_num_columns, + (unsigned short *)video_mem_start + (t + nr) * video_num_columns, + (b - t - nr) * video_num_columns * 2); + p = (unsigned short *)video_mem_start + (b - nr) * video_num_columns; + memsetw(p, video_erase_char, nr * video_size_row); + if (currcons != fg_console) + return; + sw->con_scroll(vc_cons[currcons].d, t, b, SM_UP, nr); +#else /* !CONFIG_ABSTRACT_CONSOLE */ int hardscroll = hardscroll_enabled; if (b > video_num_lines || t >= b) return; - if (t || b != video_num_lines) + if (t || b != video_num_lines || nr != 1) hardscroll = 0; if (hardscroll) { origin += video_size_row; @@ -646,43 +907,59 @@ set_origin(currcons); } else { unsigned short * d = (unsigned short *) (origin+video_size_row*t); - unsigned short * s = (unsigned short *) (origin+video_size_row*(t+1)); + unsigned short * s = (unsigned short *) (origin+video_size_row*(t+nr)); - memcpyw(d, s, (b-t-1) * video_size_row); - memsetw(d + (b-t-1) * video_num_columns, video_erase_char, video_size_row); + memcpyw(d, s, (b-t-nr) * video_size_row); + memsetw(d + (b-t-nr) * video_num_columns, video_erase_char, video_size_row); } +#endif /* !CONFIG_ABSTRACT_CONSOLE */ } void -scrdown(int currcons, unsigned int t, unsigned int b) +scrdown(int currcons, unsigned int t, unsigned int b, int nr) { +#ifdef CONFIG_ABSTRACT_CONSOLE + unsigned short *p; + + if (b > video_num_lines || t >= b) + return; + memmove((unsigned short *)video_mem_start + (t + nr) * video_num_columns, + (unsigned short *)video_mem_start + t * video_num_columns, + (b - t - nr) * video_num_columns * 2); + p = (unsigned short *)video_mem_start + t * video_num_columns; + memsetw(p, video_erase_char, nr * video_size_row); + if (currcons != fg_console) + return; + sw->con_scroll(vc_cons[currcons].d, t, b, SM_DOWN, nr); +#else /* !CONFIG_ABSTRACT_CONSOLE */ unsigned short *s; unsigned int count; if (b > video_num_lines || t >= b) return; - s = (unsigned short *) (origin+video_size_row*(b-2)); - if (b >= t + 1) { - count = b - t - 1; + s = (unsigned short *) (origin+video_size_row*(b-1-nr)); + if (b >= t + nr) { + count = b - t - nr; while (count) { count--; memcpyw(s + video_num_columns, s, video_size_row); s -= video_num_columns; } } - memsetw(s + video_num_columns, video_erase_char, video_size_row); + memsetw(s + nr*video_num_columns, video_erase_char, video_size_row); has_scrolled = 1; +#endif /* !CONFIG_ABSTRACT_CONSOLE */ } static void lf(int currcons) { - /* don't scroll if above bottom of scrolling region, or + /* don't scroll if above bottom of scrolling region, or * if below scrolling region */ - if (y+1 == bottom) - scrup(currcons,top,bottom); + if (y+1 == bottom) + scrup(currcons,top,bottom,1); else if (y < video_num_lines-1) { - y++; + y++; pos += video_size_row; } need_wrap = 0; @@ -690,11 +967,11 @@ static void ri(int currcons) { - /* don't scroll if below top of scrolling region, or + /* don't scroll if below top of scrolling region, or * if above scrolling region */ if (y == top) - scrdown(currcons,top,bottom); + scrdown(currcons,top,bottom,1); else if (y > 0) { y--; pos -= video_size_row; @@ -731,14 +1008,17 @@ case 0: /* erase from cursor to end of display */ count = (scr_end-pos)>>1; start = (unsigned short *) pos; + ABSCON(erase_to_dpy_end(currcons)); break; case 1: /* erase from start to cursor */ count = ((pos-origin)>>1)+1; start = (unsigned short *) origin; + ABSCON(erase_from_dpy_start(currcons)); break; case 2: /* erase whole display */ count = video_num_columns * video_num_lines; start = (unsigned short *) origin; + ABSCON(erase_dpy(currcons)); break; default: return; @@ -756,14 +1036,17 @@ case 0: /* erase from cursor to end of line */ count = video_num_columns-x; start = (unsigned short *) pos; + ABSCON(erase_to_line_end(currcons)); break; case 1: /* erase from start of line to cursor */ start = (unsigned short *) (pos - (x<<1)); count = x+1; + ABSCON(erase_from_line_start(currcons)); break; case 2: /* erase whole line */ start = (unsigned short *) (pos - (x<<1)); count = video_num_columns; + ABSCON(erase_line(currcons)); break; default: return; @@ -774,16 +1057,44 @@ static void csi_X(int currcons, int vpar) /* erase the following vpar positions */ { /* not vt100? */ + int count; + if (!vpar) vpar++; + count = (vpar > video_num_columns-x) ? (video_num_columns-x) : vpar; - memsetw((unsigned short *) pos, video_erase_char, - (vpar > video_num_columns-x) ? 2 * (video_num_columns-x) : 2 * vpar); + ABSCON(erase_next_chars(currcons, count)); + memsetw((unsigned short *) pos, video_erase_char, 2 * count); need_wrap = 0; } static void update_attr(int currcons) { +#ifdef CONFIG_ABSTRACT_CONSOLE +/* + * ++roman: I completely changed the attribute format for monochrome + * mode (!can_do_color). The formerly used MDA (monochrome display + * adapter) format didn't allow the combination of certain effects. + * Now the attribute is just a bit vector: + * Bit 0..1: intensity (0..2) + * Bit 2 : underline + * Bit 3 : reverse + * Bit 7 : blink + * + * ++Geert: TODO: Because the attributes have different meanings + * for monochrome and color, they should really be converted if + * can_do_color changes... + */ + if (!can_do_color) { + /* Special treatment for monochrome */ + attr = intensity | + (underline ? 4 : 0) | + ((reverse ^ decscnm) ? 8 : 0) | + (blink ? 0x80 : 0); + video_erase_char = ' ' | ((reverse ^ decscnm) ? 0x800 : 0); + return; + } +#endif /* CONFIG_ABSTRACT_CONSOLE */ attr = color; if (can_do_color) { if (underline) @@ -797,12 +1108,14 @@ attr ^= 0x80; if (intensity == 2) attr ^= 0x08; +#ifndef CONFIG_ABSTRACT_CONSOLE if (!can_do_color) { if (underline) attr = (attr & 0xf8) | 0x01; else if (intensity == 0) attr = (attr & 0xf0) | 0x08; } +#endif /* !CONFIG_ABSTRACT_CONSOLE */ if (decscnm) video_erase_char = (reverse_video_char(color) << 8) | ' '; else @@ -960,8 +1273,10 @@ static inline unsigned short *screenpos(int currcons, int offset, int viewed) { unsigned short *p = (unsigned short *)(origin + offset); +#ifndef CONFIG_ABSTRACT_CONSOLE if (viewed && currcons == fg_console) p -= (__real_origin - __origin); +#endif /* !CONFIG_ABSTRACT_CONSOLE */ return p; } @@ -969,22 +1284,33 @@ void invert_screen(int currcons, int offset, int count, int viewed) { unsigned short *p; +#ifdef CONFIG_ABSTRACT_CONSOLE + int xx = (offset >> 1) % video_num_columns; + int yy = (offset >> 1) / video_num_columns; + unsigned short oldattr = attr; +#endif /* CONFIG_ABSTRACT_CONSOLE */ count /= 2; p = screenpos(currcons, offset, viewed); if (can_do_color) while (count--) { unsigned short old = scr_readw(p); - scr_writew(reverse_video_short(old), p); + unsigned short new = reverse_video_short(old); + scr_writew(new, p); p++; + ABSCON(putc_attr_next(currcons, new, &yy, &xx)); } else while (count--) { unsigned short old = scr_readw(p); - scr_writew(old ^ (((old & 0x0700) == 0x0100) - ? 0x7000 : 0x7700), p); + unsigned short new = reverse_video_short_mono(old); + scr_writew(new, p); p++; + ABSCON(putc_attr_next(currcons, new, &yy, &xx)); } +#ifdef CONFIG_ABSTRACT_CONSOLE + attr = oldattr; +#endif /* CONFIG_ABSTRACT_CONSOLE */ } /* used by selection: complement pointer position */ @@ -992,15 +1318,33 @@ { static unsigned short *p = NULL; static unsigned short old = 0; +#ifdef CONFIG_ABSTRACT_CONSOLE + static unsigned short oldx = 0, oldy = 0; + unsigned short oldattr = attr; +#endif /* CONFIG_ABSTRACT_CONSOLE */ - if (p) + if (p) { scr_writew(old, p); + ABSCON(putc_attr(currcons, old, oldy, oldx, oldattr)); + } if (offset == -1) p = NULL; else { + unsigned short new; p = screenpos(currcons, offset, 1); old = scr_readw(p); - scr_writew(old ^ 0x7700, p); +#ifdef CONFIG_ABSTRACT_CONSOLE + oldx = (offset >> 1) % video_num_columns; + oldy = (offset >> 1) / video_num_columns; + if (can_do_color) + new = old ^ 0x7700; + else + new = old ^ 0x800; +#else /* !CONFIG_ABSTRACT_CONSOLE */ + new = old ^ 0x7700; +#endif /* !CONFIG_ABSTRACT_CONSOLE */ + scr_writew(new, p); + ABSCON(putc_attr(currcons, new, oldy, oldx, oldattr)); } } @@ -1167,11 +1511,13 @@ p++; } need_wrap = 0; + ABSCON(insert_chars(currcons, 1)); } +#if 0 /* no longer used */ static void insert_line(int currcons) { - scrdown(currcons,y,bottom); + scrdown(currcons,y,bottom,1); need_wrap = 0; } @@ -1186,52 +1532,74 @@ } scr_writew(video_erase_char, p); need_wrap = 0; + ABSCON(delete_char(currcons, 1)); } static void delete_line(int currcons) { - scrup(currcons,y,bottom); + scrup(currcons,y,bottom,1); need_wrap = 0; } +#endif /* no longer used */ static void csi_at(int currcons, unsigned int nr) { - if (nr > video_num_columns) - nr = video_num_columns; + unsigned int i; + unsigned short *p; + + if (nr > video_num_columns - x) + nr = video_num_columns - x; else if (!nr) nr = 1; - while (nr--) - insert_char(currcons); + i = video_num_columns-nr-x; + p = (unsigned short *)pos + i; + while (i--) { + p--; + scr_writew(scr_readw(p), p+nr); + } + memsetw(p, video_erase_char, 2 * nr); + need_wrap = 0; + ABSCON(insert_chars(currcons, nr)); } static void csi_L(int currcons, unsigned int nr) { - if (nr > video_num_lines) - nr = video_num_lines; + if (nr > video_num_lines - y) + nr = video_num_lines - y; else if (!nr) nr = 1; - while (nr--) - insert_line(currcons); + scrdown(currcons,y,bottom,nr); + need_wrap = 0; } static void csi_P(int currcons, unsigned int nr) { - if (nr > video_num_columns) - nr = video_num_columns; + unsigned int i; + unsigned short *p; + + if (nr > video_num_columns - x) + nr = video_num_columns - x; else if (!nr) nr = 1; - while (nr--) - delete_char(currcons); + i = video_num_columns-nr-x; + p = (unsigned short *)pos; + while (i--) { + scr_writew(scr_readw(p+nr), p); + p++; + } + memsetw(p, video_erase_char, 2 * nr); + need_wrap = 0; + ABSCON(delete_chars(currcons, nr)); } static void csi_M(int currcons, unsigned int nr) { - if (nr > video_num_lines) - nr = video_num_lines; + if (nr > video_num_lines - y) + nr = video_num_lines - y; else if (!nr) nr=1; - while (nr--) - delete_line(currcons); + scrup(currcons,y,bottom,nr); + need_wrap = 0; } static void save_cur(int currcons) @@ -1362,7 +1730,7 @@ currcons = vt->vc_num; if (vcmode != KD_GRAPHICS) set_cursor(currcons); -} +} static int do_con_write(struct tty_struct * tty, int from_user, const unsigned char *buf, int count) @@ -1387,6 +1755,11 @@ return 0; } + /* undraw cursor first */ + if (currcons == fg_console) + ABSCON(hide_cursor(currcons)); + + /* clear the selection */ if (currcons == sel_cons) clear_selection(); @@ -1472,12 +1845,93 @@ cr(currcons); lf(currcons); } + +#ifdef CONFIG_ABSTRACT_CONSOLE + /* DPC: 1994-04-12 + * Speed up overstrike mode, using new putcs. + * + * P.S. I hate 8 spaces per tab! Use Emacs! + */ + + /* Only use this for the foreground console, + where we really draw the chars */ + + if (count > 2 && + !decim && !utf && currcons == fg_console) { + char *p = putcs_buf; + int putcs_count = 1; + ushort nextx = x + 1; + + *p++ = tc; + scr_writew((attr << 8) + tc, + (unsigned short *)pos); + pos+=2; + + if (nextx == video_num_columns) { + sw->con_putc(vc_cons[currcons].d, + *putcs_buf, y, x); + pos-=2; + need_wrap = decawm; + continue; + } + + /* TAB TAB TAB - Arghh!!!! */ + + while (count) { + enable_bh(CONSOLE_BH); + if (from_user) + get_user(c, buf); + else + c = *buf; + disable_bh(CONSOLE_BH); + tc = translate[toggle_meta ? (c|0x80) : c]; + if (!tc || + !(c >= 32 + || !(((disp_ctrl ? CTRL_ALWAYS + : CTRL_ACTION) >> c) & 1))) + break; + tc = conv_uni_to_pc(tc); + if (tc == -4) + tc = conv_uni_to_pc(0xfffd); + else if (tc == -3) + tc = c; + + buf++; n++; count--; + if (tc & ~console_charmask) + continue; /* Conversion failed */ + + *p++ = tc; + scr_writew((attr << 8) + tc, + (unsigned short *)pos); + pos+=2; + ++putcs_count; + ++nextx; + if (nextx == video_num_columns || + putcs_count == sizeof (putcs_buf)) + break; + } + + sw->con_putcs(vc_cons[currcons].d, + putcs_buf, putcs_count, y, x); + if (nextx == video_num_columns) { + pos-=2; + x = video_num_columns-1; + need_wrap = decawm; + } else + x += putcs_count; + continue; + } + + /* DPC: End of putcs support */ +#endif /* CONFIG_ABSTRACT_CONSOLE */ + if (decim) insert_char(currcons); scr_writew( video_mode_512ch ? ((attr & 0xf7) << 8) + ((tc & 0x100) << 3) + (tc & 0x0ff) : (attr << 8) + tc, (unsigned short *) pos); + ABSCON(putc(currcons, tc, y, x)); if (x == video_num_columns - 1) need_wrap = decawm; else { @@ -1592,7 +2046,7 @@ continue; case '=': /* Appl. keypad */ set_kbd(kbdapplic); - continue; + continue; } continue; case ESnonstd: @@ -1795,6 +2249,13 @@ /* DEC screen alignment test. kludge :-) */ video_erase_char = (video_erase_char & 0xff00) | 'E'; +#ifdef CONFIG_ABSTRACT_CONSOLE + /* Arno: + * Doesn't work, because csi_J(c,2) + * calls con_clear and doesn't print + * the erase char.. + */ +#endif /* CONFIG_ABSTRACT_CONSOLE */ csi_J(currcons, 2); video_erase_char = (video_erase_char & 0xff00) | ' '; @@ -1837,7 +2298,7 @@ static int con_write(struct tty_struct * tty, int from_user, const unsigned char *buf, int count) { - int retval; + int retval; retval = do_con_write(tty, from_user, buf, count); con_flush_chars(tty); @@ -1882,6 +2343,11 @@ int currcons = fg_console; unsigned char c; static int printing = 0; +#ifdef CONFIG_ABSTRACT_CONSOLE + const char *start = b; + ushort count = 0; + ushort myx = x; +#endif /* CONFIG_ABSTRACT_CONSOLE */ #if CONFIG_AP1000 prom_printf(b); @@ -1904,6 +2370,54 @@ serial_echo_print(b); #endif /* CONFIG_SERIAL_ECHO */ +#ifdef CONFIG_ABSTRACT_CONSOLE + /* undraw cursor first */ + hide_cursor(currcons); + + /* Contrived structure to try to emulate original need_wrap behaviour + * Problems caused when we have need_wrap set on '\n' character */ + while ((c = *(b++)) != 0) { + if (c == 10 || c == 13 || c == 8 || need_wrap) { + if ((count = b - start - 1) > 0) { + sw->con_putcs(vc_cons[currcons].d, start, count, y, x); + x += count; + if (need_wrap) + x--; + } + if (c == 8) { /* backspace */ + bs(currcons); + start = b; + myx = x; + continue; + } + if (c != 13) + lf(currcons); + cr(currcons); + if (c == 10 || c == 13) { + start = b; + myx = x; + continue; + } + start = b-1; + myx = x; + } + scr_writew((attr << 8) + c, (unsigned short *) pos); + if (myx == video_num_columns - 1) { + need_wrap = 1; + continue; + } + pos+=2; + myx++; + } + if ((count = b - start -1) > 0) { + sw->con_putcs(vc_cons[currcons].d, start, count, y, x); + x += count; + if (x == video_num_columns) { + x--; + need_wrap = 1; + } + } +#else /* !CONFIG_ABSTRACT_CONSOLE */ while ((c = *(b++)) != 0) { if (c == 10 || c == 13 || need_wrap) { if (c != 13) @@ -1924,6 +2438,7 @@ x++; pos+=2; } +#endif /* !CONFIG_ABSTRACT_CONSOLE */ set_cursor(currcons); poke_blanked_console(); printing = 0; @@ -1971,14 +2486,6 @@ reset_terminal(currcons, do_clear); } -static void con_setsize(unsigned long rows, unsigned long cols) -{ - video_num_lines = rows; - video_num_columns = cols; - video_size_row = 2 * cols; - video_screen_size = video_num_lines * video_size_row; -} - /* * This is the console switching bottom half handler. * @@ -2018,9 +2525,7 @@ unsigned long con_init(unsigned long kmem_start) { const char *display_desc = "????"; - int currcons = 0; - int orig_x = ORIG_X; - int orig_y = ORIG_Y; + unsigned int currcons = 0; #ifdef __sparc__ if (serial_console) { @@ -2068,7 +2573,12 @@ #if CONFIG_AP1000 return(kmem_start); #endif - con_setsize(ORIG_VIDEO_LINES, ORIG_VIDEO_COLS); +#ifndef CONFIG_ABSTRACT_CONSOLE + video_num_lines = ORIG_VIDEO_LINES; + video_num_columns = ORIG_VIDEO_COLS; + video_size_row = 2 * ORIG_VIDEO_COLS; + video_screen_size = video_num_lines * video_size_row; +#endif /* !CONFIG_ABSTRACT_CONSOLE */ timer_table[BLANK_TIMER].fn = blank_screen; timer_table[BLANK_TIMER].expires = 0; @@ -2079,11 +2589,13 @@ kmem_start = con_type_init(kmem_start, &display_desc); +#ifndef CONFIG_ABSTRACT_CONSOLE hardscroll_enabled = (hardscroll_disabled_by_init ? 0 : (video_type == VIDEO_TYPE_EGAC || video_type == VIDEO_TYPE_VGAC || video_type == VIDEO_TYPE_EGAM)); has_wrapped = 0 ; +#endif /* !CONFIG_ABSTRACT_CONSOLE */ /* Due to kmalloc roundup allocating statically is more efficient - so provide MIN_NR_CONSOLES for people with very little memory */ @@ -2094,11 +2606,12 @@ kmem_start += sizeof(struct vc_data); vt_cons[currcons] = (struct vt_struct *) kmem_start; kmem_start += sizeof(struct vt_struct); + ABSCON(init(currcons)); vc_scrbuf[currcons] = (unsigned short *) kmem_start; kmem_start += video_screen_size; kmalloced = 0; screenbuf_size = video_screen_size; - vc_init(currcons, video_num_lines, video_num_columns, currcons); + vc_init(currcons, video_num_lines, video_num_columns, currcons); for (j=k=0; j<16; j++) { vc_cons[currcons].d->vc_palette[k++] = default_red[j] ; vc_cons[currcons].d->vc_palette[k++] = default_grn[j] ; @@ -2108,19 +2621,27 @@ currcons = fg_console = 0; +#ifdef CONFIG_ABSTRACT_CONSOLE + gotoxy(currcons,0,0); + csi_J(currcons, 0); + printable = 1; + update_screen(fg_console); + sw->con_cursor(vc_cons[currcons].d, CM_DRAW); + printable = 1; +#else /* !CONFIG_ABSTRACT_CONSOLE */ video_mem_start = video_mem_base; video_mem_end = video_mem_term; origin = video_mem_start; scr_end = video_mem_start + video_num_lines * video_size_row; - gotoxy(currcons,orig_x,orig_y); + gotoxy(currcons,ORIG_X,ORIG_Y); set_origin(currcons); csi_J(currcons, 0); + printable = 1; /* Figure out the size of the screen and screen font so we can figure out the appropriate screen size should we load a different font */ - printable = 1; if ( video_type == VIDEO_TYPE_VGAC || video_type == VIDEO_TYPE_EGAC || video_type == VIDEO_TYPE_EGAM || video_type == VIDEO_TYPE_TGAC || video_type == VIDEO_TYPE_SUN ) @@ -2136,6 +2657,7 @@ printk("Console: %ld point font, %ld scans\n", video_font_height, video_scan_lines); } +#endif /* !CONFIG_ABSTRACT_CONSOLE */ printk("Console: %s %s %ldx%ld, %d virtual console%s (max %d)\n", can_do_color ? "colour" : "mono", @@ -2145,14 +2667,24 @@ con_type_init_finish(); + if (1 +#ifdef CONFIG_SERIAL_CONSOLE + && !serial_console +#endif /* CONFIG_SERIAL_CONSOLE */ +#ifdef __mc68000__ + && !serial_debug +#endif /* __mc68000__ */ +#ifndef CONFIG_ABSTRACT_CONSOLE /* * can't register TGA yet, because PCI bus probe has *not* taken * place before con_init() gets called. Trigger the real TGA hw * initialization and register_console() event from * within the bus probing code... :-( */ - if (video_type != VIDEO_TYPE_TGAC) - register_console(console_print); + && video_type != VIDEO_TYPE_TGAC +#endif /* !CONFIG_ABSTRACT_CONSOLE */ + ) + register_console(console_print); init_bh(CONSOLE_BH, console_bh); return kmem_start; @@ -2173,6 +2705,14 @@ if (console_blanked) return; +#ifdef CONFIG_ABSTRACT_CONSOLE + /* don't blank graphics */ + if (vt_cons[fg_console]->vc_mode != KD_TEXT) { + console_blanked = fg_console + 1; + hide_cursor(fg_console); + return; + } +#endif /* CONFIG_ABSTRACT_CONSOLE */ if(vesa_off_interval && !nopowersave) { timer_table[BLANK_TIMER].fn = vesa_powerdown_screen; timer_table[BLANK_TIMER].expires = jiffies + vesa_off_interval; @@ -2182,9 +2722,13 @@ timer_table[BLANK_TIMER].fn = unblank_screen; } - /* try not to lose information by blanking, and not to waste memory */ + /* try not to lose information by blanking, + and not to waste memory */ currcons = fg_console; has_scrolled = 0; +#ifdef CONFIG_ABSTRACT_CONSOLE + sw->con_blank(1); +#else /* !CONFIG_ABSTRACT_CONSOLE */ blank__origin = __origin; blank_origin = origin; set_origin(fg_console); @@ -2192,7 +2736,8 @@ unblank_origin = origin; memsetw((void *)blank_origin, BLANK, 2*video_num_lines*video_num_columns); - hide_cursor(); + hide_cursor(fg_console); +#endif /* !CONFIG_ABSTRACT_CONSOLE */ console_blanked = fg_console + 1; if(!nopowersave) @@ -2208,8 +2753,10 @@ void do_unblank_screen(void) { int currcons; +#ifndef CONFIG_ABSTRACT_CONSOLE int resetorg; long offset; +#endif /* !CONFIG_ABSTRACT_CONSOLE */ if (!console_blanked) return; @@ -2225,6 +2772,13 @@ } currcons = fg_console; +#ifdef CONFIG_ABSTRACT_CONSOLE + console_blanked = 0; + if (sw->con_blank(0)) + /* Low-level driver cannot restore -> do it ourselves */ + update_screen(fg_console); + set_cursor(fg_console); +#else /* !CONFIG_ABSTRACT_CONSOLE */ offset = 0; resetorg = 0; if (console_blanked == fg_console + 1 && origin == unblank_origin @@ -2234,19 +2788,18 @@ offset = (blank_origin - video_mem_base) - (unblank_origin - video_mem_start); } - console_blanked = 0; set_scrmem(fg_console, offset); set_origin(fg_console); set_cursor(fg_console); if (resetorg) __set_origin(blank__origin); - vesa_unblank(); #ifdef CONFIG_APM if (apm_display_unblank()) return; #endif +#endif /* !CONFIG_ABSTRACT_CONSOLE */ } /* @@ -2265,10 +2818,20 @@ void update_screen(int new_console) { +#ifdef CONFIG_ABSTRACT_CONSOLE + int currcons = fg_console; + int xx, yy, startx, attr_save; + char *bufp; + unsigned short *p; +#endif /* CONFIG_ABSTRACT_CONSOLE */ static int lock = 0; - if (new_console == fg_console || lock) + if (lock) return; +#ifndef CONFIG_ABSTRACT_CONSOLE + if (new_console == fg_console) + return; +#endif /* !CONFIG_ABSTRACT_CONSOLE */ if (!vc_cons_allocated(new_console)) { /* strange ... */ printk("update_screen: tty %d not allocated ??\n", new_console+1); @@ -2278,6 +2841,39 @@ clear_selection(); +#ifdef CONFIG_ABSTRACT_CONSOLE + currcons = fg_console = new_console; + sw->con_cursor (vc_cons[currcons].d, CM_ERASE); + sw->con_switch (vc_cons[new_console].d); + /* Update the screen contents */ + p = (unsigned short *)video_mem_start; + attr_save = attr; + for (yy = 0; yy < video_num_lines; yy++) { + bufp = putcs_buf; + for (startx = xx = 0; xx < video_num_columns; xx++) { + if (attr != ((*p >> 8) & 0xff)) { + if (bufp > putcs_buf) + sw->con_putcs (vc_cons[currcons].d, putcs_buf, + bufp - putcs_buf, yy, startx); + startx = xx; + bufp = putcs_buf; + attr = (*p >> 8) & 0xff; + } + *bufp++ = *p++; + if (bufp == putcs_buf + sizeof (putcs_buf)) { + sw->con_putcs (vc_cons[currcons].d, putcs_buf, + bufp - putcs_buf, yy, startx); + startx = xx + 1; + bufp = putcs_buf; + } + } + if (bufp > putcs_buf) + sw->con_putcs (vc_cons[currcons].d, putcs_buf, + bufp - putcs_buf, yy, startx); + } + set_cursor (currcons); + attr = attr_save; +#else /* !CONFIG_ABSTRACT_CONSOLE */ if (!console_blanked) get_scrmem(fg_console); else @@ -2287,6 +2883,7 @@ set_scrmem(fg_console, 0); set_origin(fg_console); set_cursor(fg_console); +#endif /* !CONFIG_ABSTRACT_CONSOLE */ set_leds(); compute_shiftstate(); lock = 0; @@ -2297,17 +2894,17 @@ */ int con_open(struct tty_struct *tty, struct file * filp) { - unsigned int idx; + unsigned int currcons; int i; - idx = MINOR(tty->device) - tty->driver.minor_start; + currcons = MINOR(tty->device) - tty->driver.minor_start; - i = vc_allocate(idx); + i = vc_allocate(currcons); if (i) return i; - vt_cons[idx]->vc_num = idx; - tty->driver_data = vt_cons[idx]; + vt_cons[currcons]->vc_num = currcons; + tty->driver_data = vt_cons[currcons]; if (!tty->winsize.ws_row && !tty->winsize.ws_col) { tty->winsize.ws_row = video_num_lines; @@ -2354,10 +2951,10 @@ int i; i = set_get_font (arg,1,ch512); - if ( !i ) { + if ( !i ) { hashtable_contents_valid = 0; - video_mode_512ch = ch512; - console_charmask = ch512 ? 0x1ff : 0x0ff; + video_mode_512ch = ch512; + console_charmask = ch512 ? 0x1ff : 0x0ff; } return i; } --- linux-2.1.29/drivers/char/console_macros.h.orig Thu Mar 20 21:04:06 1997 +++ linux-2.1.29/drivers/char/console_macros.h Thu Mar 20 21:11:30 1997 @@ -0,0 +1,70 @@ +/* + * console_macros.h + * + * Macros shared between console.c, vga.c, tga.c and abscon.c + */ + +#define cons_num (vc_cons[currcons].d->vc_num) +#define sw (vc_cons[currcons].d->vc_sw) +#define screenbuf_size (vc_cons[currcons].d->vc_screenbuf_size) +#define origin (vc_cons[currcons].d->vc_origin) +#define scr_end (vc_cons[currcons].d->vc_scr_end) +#define pos (vc_cons[currcons].d->vc_pos) +#define top (vc_cons[currcons].d->vc_top) +#define bottom (vc_cons[currcons].d->vc_bottom) +#define x (vc_cons[currcons].d->vc_x) +#define y (vc_cons[currcons].d->vc_y) +#define vc_state (vc_cons[currcons].d->vc_state) +#define npar (vc_cons[currcons].d->vc_npar) +#define par (vc_cons[currcons].d->vc_par) +#define ques (vc_cons[currcons].d->vc_ques) +#define attr (vc_cons[currcons].d->vc_attr) +#define saved_x (vc_cons[currcons].d->vc_saved_x) +#define saved_y (vc_cons[currcons].d->vc_saved_y) +#define translate (vc_cons[currcons].d->vc_translate) +#define G0_charset (vc_cons[currcons].d->vc_G0_charset) +#define G1_charset (vc_cons[currcons].d->vc_G1_charset) +#define saved_G0 (vc_cons[currcons].d->vc_saved_G0) +#define saved_G1 (vc_cons[currcons].d->vc_saved_G1) +#define utf (vc_cons[currcons].d->vc_utf) +#define utf_count (vc_cons[currcons].d->vc_utf_count) +#define utf_char (vc_cons[currcons].d->vc_utf_char) +#define video_mem_start (vc_cons[currcons].d->vc_video_mem_start) +#define video_mem_end (vc_cons[currcons].d->vc_video_mem_end) +#define video_erase_char (vc_cons[currcons].d->vc_video_erase_char) +#define disp_ctrl (vc_cons[currcons].d->vc_disp_ctrl) +#define toggle_meta (vc_cons[currcons].d->vc_toggle_meta) +#define decscnm (vc_cons[currcons].d->vc_decscnm) +#define decom (vc_cons[currcons].d->vc_decom) +#define decawm (vc_cons[currcons].d->vc_decawm) +#define deccm (vc_cons[currcons].d->vc_deccm) +#define decim (vc_cons[currcons].d->vc_decim) +#define deccolm (vc_cons[currcons].d->vc_deccolm) +#define need_wrap (vc_cons[currcons].d->vc_need_wrap) +#define has_scrolled (vc_cons[currcons].d->vc_has_scrolled) +#define kmalloced (vc_cons[currcons].d->vc_kmalloced) +#define report_mouse (vc_cons[currcons].d->vc_report_mouse) +#define color (vc_cons[currcons].d->vc_color) +#define s_color (vc_cons[currcons].d->vc_s_color) +#define def_color (vc_cons[currcons].d->vc_def_color) +#define foreground (color & 0x0f) +#define background (color & 0xf0) +#define charset (vc_cons[currcons].d->vc_charset) +#define s_charset (vc_cons[currcons].d->vc_s_charset) +#define intensity (vc_cons[currcons].d->vc_intensity) +#define underline (vc_cons[currcons].d->vc_underline) +#define blink (vc_cons[currcons].d->vc_blink) +#define reverse (vc_cons[currcons].d->vc_reverse) +#define s_intensity (vc_cons[currcons].d->vc_s_intensity) +#define s_underline (vc_cons[currcons].d->vc_s_underline) +#define s_blink (vc_cons[currcons].d->vc_s_blink) +#define s_reverse (vc_cons[currcons].d->vc_s_reverse) +#define ulcolor (vc_cons[currcons].d->vc_ulcolor) +#define halfcolor (vc_cons[currcons].d->vc_halfcolor) +#define tab_stop (vc_cons[currcons].d->vc_tab_stop) +#define palette (vc_cons[currcons].d->vc_palette) +#define bell_pitch (vc_cons[currcons].d->vc_bell_pitch) +#define bell_duration (vc_cons[currcons].d->vc_bell_duration) + +#define vcmode (vt_cons[currcons]->vc_mode) +#define structsize (sizeof(struct vc_data) + sizeof(struct vt_struct)) --- linux-2.1.29/drivers/char/console_struct.h.orig Tue Nov 21 07:34:54 1995 +++ linux-2.1.29/drivers/char/console_struct.h Thu Mar 20 21:04:06 1997 @@ -1,141 +0,0 @@ -/* - * console_struct.h - * - * Data structure and defines shared between console.c, vga.c and tga.c - */ - -#define NPAR 16 - -struct vc_data { - unsigned long vc_screenbuf_size; - unsigned short vc_video_erase_char; /* Background erase character */ - unsigned char vc_attr; /* Current attributes */ - unsigned char vc_def_color; /* Default colors */ - unsigned char vc_color; /* Foreground & background */ - unsigned char vc_s_color; /* Saved foreground & background */ - unsigned char vc_ulcolor; /* Colour for underline mode */ - unsigned char vc_halfcolor; /* Colour for half intensity mode */ - unsigned long vc_origin; /* Used for EGA/VGA fast scroll */ - unsigned long vc_scr_end; /* Used for EGA/VGA fast scroll */ - unsigned long vc_pos; - unsigned long vc_x,vc_y; - unsigned long vc_top,vc_bottom; - unsigned long vc_state; - unsigned long vc_npar,vc_par[NPAR]; - unsigned long vc_video_mem_start; /* Start of video RAM */ - unsigned long vc_video_mem_end; /* End of video RAM (sort of) */ - unsigned long vc_saved_x; - unsigned long vc_saved_y; - /* mode flags */ - unsigned long vc_charset : 1; /* Character set G0 / G1 */ - unsigned long vc_s_charset : 1; /* Saved character set */ - unsigned long vc_disp_ctrl : 1; /* Display chars < 32? */ - unsigned long vc_toggle_meta : 1; /* Toggle high bit? */ - unsigned long vc_decscnm : 1; /* Screen Mode */ - unsigned long vc_decom : 1; /* Origin Mode */ - unsigned long vc_decawm : 1; /* Autowrap Mode */ - unsigned long vc_deccm : 1; /* Cursor Visible */ - unsigned long vc_decim : 1; /* Insert Mode */ - unsigned long vc_deccolm : 1; /* 80/132 Column Mode */ - /* attribute flags */ - unsigned long vc_intensity : 2; /* 0=half-bright, 1=normal, 2=bold */ - unsigned long vc_underline : 1; - unsigned long vc_blink : 1; - unsigned long vc_reverse : 1; - unsigned long vc_s_intensity : 2; /* saved rendition */ - unsigned long vc_s_underline : 1; - unsigned long vc_s_blink : 1; - unsigned long vc_s_reverse : 1; - /* misc */ - unsigned long vc_ques : 1; - unsigned long vc_need_wrap : 1; - unsigned long vc_has_scrolled : 1; /* Info for unblank_screen */ - unsigned long vc_kmalloced : 1; /* kfree_s() needed */ - unsigned long vc_report_mouse : 2; - unsigned char vc_utf : 1; /* Unicode UTF-8 encoding */ - unsigned char vc_utf_count; - long vc_utf_char; - unsigned long vc_tab_stop[5]; /* Tab stops. 160 columns. */ - unsigned char vc_palette[16*3]; /* Colour palette for VGA+ */ - unsigned short * vc_translate; - unsigned char vc_G0_charset; - unsigned char vc_G1_charset; - unsigned char vc_saved_G0; - unsigned char vc_saved_G1; - unsigned int vc_bell_pitch; /* Console bell pitch */ - unsigned int vc_bell_duration; /* Console bell duration */ - /* additional information is in vt_kern.h */ -}; - -struct vc { - struct vc_data *d; - - /* might add scrmem, vt_struct, kbd at some time, - to have everything in one place - the disadvantage - would be that vc_cons etc can no longer be static */ -}; - -extern struct vc vc_cons [MAX_NR_CONSOLES]; - -#define screenbuf_size (vc_cons[currcons].d->vc_screenbuf_size) -#define origin (vc_cons[currcons].d->vc_origin) -#define scr_end (vc_cons[currcons].d->vc_scr_end) -#define pos (vc_cons[currcons].d->vc_pos) -#define top (vc_cons[currcons].d->vc_top) -#define bottom (vc_cons[currcons].d->vc_bottom) -#define x (vc_cons[currcons].d->vc_x) -#define y (vc_cons[currcons].d->vc_y) -#define vc_state (vc_cons[currcons].d->vc_state) -#define npar (vc_cons[currcons].d->vc_npar) -#define par (vc_cons[currcons].d->vc_par) -#define ques (vc_cons[currcons].d->vc_ques) -#define attr (vc_cons[currcons].d->vc_attr) -#define saved_x (vc_cons[currcons].d->vc_saved_x) -#define saved_y (vc_cons[currcons].d->vc_saved_y) -#define translate (vc_cons[currcons].d->vc_translate) -#define G0_charset (vc_cons[currcons].d->vc_G0_charset) -#define G1_charset (vc_cons[currcons].d->vc_G1_charset) -#define saved_G0 (vc_cons[currcons].d->vc_saved_G0) -#define saved_G1 (vc_cons[currcons].d->vc_saved_G1) -#define utf (vc_cons[currcons].d->vc_utf) -#define utf_count (vc_cons[currcons].d->vc_utf_count) -#define utf_char (vc_cons[currcons].d->vc_utf_char) -#define video_mem_start (vc_cons[currcons].d->vc_video_mem_start) -#define video_mem_end (vc_cons[currcons].d->vc_video_mem_end) -#define video_erase_char (vc_cons[currcons].d->vc_video_erase_char) -#define disp_ctrl (vc_cons[currcons].d->vc_disp_ctrl) -#define toggle_meta (vc_cons[currcons].d->vc_toggle_meta) -#define decscnm (vc_cons[currcons].d->vc_decscnm) -#define decom (vc_cons[currcons].d->vc_decom) -#define decawm (vc_cons[currcons].d->vc_decawm) -#define deccm (vc_cons[currcons].d->vc_deccm) -#define decim (vc_cons[currcons].d->vc_decim) -#define deccolm (vc_cons[currcons].d->vc_deccolm) -#define need_wrap (vc_cons[currcons].d->vc_need_wrap) -#define has_scrolled (vc_cons[currcons].d->vc_has_scrolled) -#define kmalloced (vc_cons[currcons].d->vc_kmalloced) -#define report_mouse (vc_cons[currcons].d->vc_report_mouse) -#define color (vc_cons[currcons].d->vc_color) -#define s_color (vc_cons[currcons].d->vc_s_color) -#define def_color (vc_cons[currcons].d->vc_def_color) -#define foreground (color & 0x0f) -#define background (color & 0xf0) -#define charset (vc_cons[currcons].d->vc_charset) -#define s_charset (vc_cons[currcons].d->vc_s_charset) -#define intensity (vc_cons[currcons].d->vc_intensity) -#define underline (vc_cons[currcons].d->vc_underline) -#define blink (vc_cons[currcons].d->vc_blink) -#define reverse (vc_cons[currcons].d->vc_reverse) -#define s_intensity (vc_cons[currcons].d->vc_s_intensity) -#define s_underline (vc_cons[currcons].d->vc_s_underline) -#define s_blink (vc_cons[currcons].d->vc_s_blink) -#define s_reverse (vc_cons[currcons].d->vc_s_reverse) -#define ulcolor (vc_cons[currcons].d->vc_ulcolor) -#define halfcolor (vc_cons[currcons].d->vc_halfcolor) -#define tab_stop (vc_cons[currcons].d->vc_tab_stop) -#define palette (vc_cons[currcons].d->vc_palette) -#define bell_pitch (vc_cons[currcons].d->vc_bell_pitch) -#define bell_duration (vc_cons[currcons].d->vc_bell_duration) - -#define vcmode (vt_cons[currcons]->vc_mode) -#define structsize (sizeof(struct vc_data) + sizeof(struct vt_struct)) --- linux-2.1.29/drivers/char/selection.c.orig Tue Mar 18 23:50:23 1997 +++ linux-2.1.29/drivers/char/selection.c Thu Mar 20 21:04:07 1997 @@ -16,6 +16,7 @@ #include #include #include +#include #include @@ -96,7 +97,7 @@ } /* does screen address p correspond to character at LH/RH edge of screen? */ -static inline int atedge(const int p) +static inline int atedge(const int p, unsigned int currcons) { return (!(p % video_size_row) || !((p + 2) % video_size_row)); } @@ -116,15 +117,10 @@ int sel_mode, new_sel_start, new_sel_end, spc; char *bp, *obp; int i, ps, pe; + unsigned int currcons = fg_console; do_unblank_screen(); -#if defined(__mc68000__) - video_num_lines = get_video_num_lines(fg_console); - video_num_columns = get_video_num_columns(fg_console); - video_size_row = get_video_size_row(fg_console); -#endif - { unsigned short *args, xs, ys, xe, ye; args = (unsigned short *)(arg + 1); @@ -221,10 +217,10 @@ highlight_pointer(-1); /* select to end of line if on trailing space */ - if (new_sel_end > new_sel_start && - !atedge(new_sel_end) && isspace(sel_pos(new_sel_end))) { + if (new_sel_end > new_sel_start && !atedge(new_sel_end, currcons) && + isspace(sel_pos(new_sel_end))) { for (pe = new_sel_end + 2; ; pe += 2) - if (!isspace(sel_pos(pe)) || atedge(pe)) + if (!isspace(sel_pos(pe)) || atedge(pe, currcons)) break; if (isspace(sel_pos(pe))) new_sel_end = pe; --- linux-2.1.29/drivers/char/selection.h.orig Wed Mar 19 00:32:07 1997 +++ linux-2.1.29/drivers/char/selection.h Thu Mar 20 21:04:07 1997 @@ -12,11 +12,13 @@ extern int mouse_reporting(void); extern void mouse_report(struct tty_struct * tty, int butt, int mrx, int mry); -#if defined(__mc68000__) -extern unsigned long get_video_num_columns(unsigned int console); -extern unsigned long get_video_num_lines(unsigned int console); -extern unsigned long get_video_size_row(unsigned int console); -#endif +#ifdef CONFIG_ABSTRACT_CONSOLE +#define video_num_columns (vc_cons[currcons].d->vc_cols) +#define video_num_lines (vc_cons[currcons].d->vc_rows) +#define video_size_row (vc_cons[currcons].d->vc_size_row) +#define video_screen_size (vc_cons[currcons].d->vc_screenbuf_size) +#define can_do_color (vc_cons[currcons].d->vc_can_do_color) +#else /* !CONFIG_ABSTRACT_CONSOLE */ extern unsigned long video_num_columns; extern unsigned long video_num_lines; extern unsigned long video_size_row; @@ -26,9 +28,10 @@ extern unsigned long video_screen_size; extern unsigned short video_port_reg; extern unsigned short video_port_val; +extern int can_do_color; +#endif /* !CONFIG_ABSTRACT_CONSOLE */ extern int console_blanked; -extern int can_do_color; extern unsigned long video_font_height; extern unsigned long video_scan_lines; @@ -58,6 +61,12 @@ (((a) & 0x7000) >> 4) | (((a) & 0x0700) << 4)) /* this latter line used to have masks 0xf000 and 0x0f00, but selection requires a self-inverse operation; moreover, the old version looks wrong */ +#ifdef CONFIG_ABSTRACT_CONSOLE +#define reverse_video_short_mono(a) ((a) ^ 0x800) +#else /* !CONFIG_ABSTRACT_CONSOLE */ +#define reverse_video_short_mono(a) ((a) ^ ((((a) & 0x0700) == 0x0100) \ + ? 0x7000 : 0x7700)) +#endif /* !CONFIG_ABSTRACT_CONSOLE */ extern void getconsxy(int currcons, char *p); extern void putconsxy(int currcons, char *p); @@ -132,7 +141,18 @@ return *addr; } -#else /* CONFIG_TGA_CONSOLE || CONFIG_SUN_CONSOLE */ +#elif defined(CONFIG_ABSTRACT_CONSOLE) +static inline void scr_writew(unsigned short val, unsigned short *addr) +{ + /* simply store the value in the "shadow screen" memory */ + *addr = val; +} + +static inline unsigned short scr_readw(unsigned short * addr) +{ + return *addr; +} +#else /* CONFIG_TGA_CONSOLE || CONFIG_SUN_CONSOLE || CONFIG_ABSTRACT_CONSOLE */ /* * normal VGA console access --- linux-2.1.29/drivers/char/tga.c.orig Sun Feb 16 22:22:30 1997 +++ linux-2.1.29/drivers/char/tga.c Thu Mar 20 21:04:07 1997 @@ -25,6 +25,7 @@ #include #include #include +#include #include #include @@ -35,7 +36,7 @@ #include "vt_kern.h" #include "consolemap.h" #include "selection.h" -#include "console_struct.h" +#include "console_macros.h" extern void register_console(void (*proc)(const char *)); extern void console_print(const char *); @@ -244,7 +245,7 @@ * Hide the cursor from view, during blanking, usually... */ void -hide_cursor(void) +hide_cursor(int currcons) { unsigned long flags; save_flags(flags); cli(); @@ -300,7 +301,7 @@ } } else - hide_cursor(); + hide_cursor(currcons); restore_flags(flags); } --- linux-2.1.29/drivers/char/vc_screen.c.orig Tue Mar 18 23:50:24 1997 +++ linux-2.1.29/drivers/char/vc_screen.c Thu Mar 20 21:04:08 1997 @@ -30,6 +30,7 @@ #include #include #include +#include #include #include "vt_kern.h" #include "selection.h" @@ -55,25 +56,15 @@ vcs_size(struct inode *inode) { int size; -#if !defined(__mc68000__) -#ifdef CONFIG_MULTIMON - int currcons = MINOR(inode->i_rdev) & 127; - /* Multimon patch */ - if (!vc_cons[currcons].d) return 0; -#endif - size= video_num_lines * video_num_columns; -#else - int cons = MINOR(inode->i_rdev) & 127; + int currcons = MINOR(inode->i_rdev) & 127; - if (cons == 0) - cons = fg_console; + if (currcons == 0) + currcons = fg_console; else - cons--; - if (!vc_cons_allocated(cons)) - return -ENXIO; - - size = get_video_num_lines(cons) * get_video_num_columns(cons); -#endif + currcons--; + if (!vc_cons_allocated(currcons)) + return 0; + size = video_num_lines * video_num_columns; if (MINOR(inode->i_rdev) & 128) size = 2*size + HEADER_SIZE; return size; @@ -140,13 +131,8 @@ } else { if (p < HEADER_SIZE) { char header[HEADER_SIZE]; -#if !defined(__mc68000__) header[0] = (char) video_num_lines; header[1] = (char) video_num_columns; -#else - header[0] = (char) get_video_num_lines(currcons); - header[1] = (char) get_video_num_columns(currcons); -#endif getconsxy(currcons, header+2); while (p < HEADER_SIZE && count > 0) { count--; put_user(header[p++], buf++); } @@ -242,11 +228,11 @@ func_scr_writew((func_scr_readw(org) & 0xff00) | c, org); } } -#ifdef __mc68000__ +#ifdef CONFIG_ABSTRACT_CONSOLE if (currcons == fg_console) /* Horribly inefficient if count < screen size. */ update_screen(currcons); -#endif +#endif /* CONFIG_ABSTRACT_CONSOLE */ written = buf - buf0; file->f_pos += written; RETURN( written ); --- linux-2.1.29/drivers/char/vga.c.orig Sun Feb 16 22:22:31 1997 +++ linux-2.1.29/drivers/char/vga.c Thu Mar 20 21:04:08 1997 @@ -53,6 +53,7 @@ #include #include #include +#include #include #include @@ -63,7 +64,7 @@ #include "vt_kern.h" #include "consolemap.h" #include "selection.h" -#include "console_struct.h" +#include "console_macros.h" #define CAN_LOAD_EGA_FONTS /* undefine if the user must not do this */ #define CAN_LOAD_PALETTE /* undefine if the user must not do this */ @@ -129,7 +130,7 @@ * Put the cursor just beyond the end of the display adaptor memory. */ void -hide_cursor(void) +hide_cursor(int currcons) { /* This is inefficient, we could just put the cursor at 0xffff, but perhaps the delays due to the inefficiency are useful for @@ -150,7 +151,7 @@ if (deccm) { write_vga(14, (pos - video_mem_base)>>1); } else - hide_cursor(); + hide_cursor(currcons); restore_flags(flags); } --- linux-2.1.29/include/linux/console.h.orig Tue Mar 18 23:50:45 1997 +++ linux-2.1.29/include/linux/console.h Thu Mar 20 21:02:20 1997 @@ -9,16 +9,35 @@ * * Changed: * 10-Mar-94: Arno Griffioen: Conversion for vt100 emulator port from PC LINUX + * 07-Jan-97: Geert Uytterhoeven: console driver merge */ #ifndef _LINUX_CONSOLE_H_ -#define _LINUX_CONSOLE_H_ 1 +#define _LINUX_CONSOLE_H_ + +#include + +#ifdef __KERNEL__ + +/* + * Data structure and defines shared between console.c, vga.c, tga.c and + * abscon.c (and some other low-level parts). + */ #define NPAR 16 struct vc_data { - unsigned long vc_screenbuf_size; +#ifdef CONFIG_ABSTRACT_CONSOLE unsigned short vc_num; /* Console number */ + unsigned long vc_cols; + unsigned long vc_rows; + unsigned long vc_size_row; + struct consw *vc_sw; +#endif /* CONFIG_ABSTRACT_CONSOLE */ + unsigned long vc_pos; + unsigned long vc_video_mem_start; /* Start of video RAM */ + unsigned long vc_video_mem_end; /* End of video RAM (sort of) */ + unsigned long vc_screenbuf_size; unsigned short vc_video_erase_char; /* Background erase character */ unsigned char vc_attr; /* Current attributes */ unsigned char vc_def_color; /* Default colors */ @@ -28,15 +47,10 @@ unsigned char vc_halfcolor; /* Colour for half intensity mode */ unsigned long vc_origin; /* Used for EGA/VGA fast scroll */ unsigned long vc_scr_end; /* Used for EGA/VGA fast scroll */ - unsigned short *vc_pos; unsigned long vc_x,vc_y; unsigned long vc_top,vc_bottom; - unsigned long vc_rows,vc_cols; - unsigned long vc_size_row; unsigned long vc_state; unsigned long vc_npar,vc_par[NPAR]; - unsigned short *vc_video_mem_start; - unsigned long vc_video_mem_end; /* End of video RAM (sort of) */ unsigned long vc_saved_x; unsigned long vc_saved_y; /* mode flags */ @@ -62,13 +76,15 @@ /* misc */ unsigned long vc_ques : 1; unsigned long vc_need_wrap : 1; - unsigned long vc_can_do_color : 1; unsigned long vc_has_scrolled : 1; /* Info for unblank_screen */ unsigned long vc_kmalloced : 1; /* kfree_s() needed */ unsigned long vc_report_mouse : 2; +#ifdef CONFIG_ABSTRACT_CONSOLE + unsigned long vc_can_do_color : 1; +#endif /* CONFIG_ABSTRACT_CONSOLE */ unsigned char vc_utf : 1; /* Unicode UTF-8 encoding */ unsigned char vc_utf_count; - unsigned long vc_utf_char; + long vc_utf_char; unsigned long vc_tab_stop[5]; /* Tab stops. 160 columns. */ unsigned char vc_palette[16*3]; /* Colour palette for VGA+ */ unsigned short *vc_translate; @@ -78,33 +94,38 @@ unsigned char vc_saved_G1; unsigned int vc_bell_pitch; /* Console bell pitch */ unsigned int vc_bell_duration; /* Console bell duration */ - struct consw *vc_sw; /* additional information is in vt_kern.h */ }; -/* - * this is what the terminal answers to a ESC-Z or csi0c query. - */ -#define VT100ID "\033[?1;2c" -#define VT102ID "\033[?6c" +struct vc { + struct vc_data *d; + + /* might add scrmem, vt_struct, kbd at some time, + to have everything in one place - the disadvantage + would be that vc_cons etc can no longer be static */ +}; +extern struct vc vc_cons [MAX_NR_CONSOLES]; + + +#ifdef CONFIG_ABSTRACT_CONSOLE /* DPC: 1994-04-13 !!! con_putcs is new entry !!! */ struct consw { - unsigned long (*con_startup)(unsigned long, const char **); - void (*con_init)(struct vc_data *); - int (*con_deinit)(struct vc_data *); - int (*con_clear)(struct vc_data *, int, int, int, int); - int (*con_putc)(struct vc_data *, int, int, int); - int (*con_putcs)(struct vc_data *, const char *, int, int, int); - int (*con_cursor)(struct vc_data *, int); - int (*con_scroll)(struct vc_data *, int, int, int, int); - int (*con_bmove)(struct vc_data *, int, int, int, int, int, int); - int (*con_switch)(struct vc_data *); - int (*con_blank)(int); - int (*con_get_font)(struct vc_data *, int *, int *, char *); - int (*con_set_font)(struct vc_data *, int, int, char *); - int (*con_set_palette)(struct vc_data *, unsigned char *); + unsigned long (*con_startup)(unsigned long, const char **); + void (*con_init)(struct vc_data *); + int (*con_deinit)(struct vc_data *); + int (*con_clear)(struct vc_data *, int, int, int, int); + int (*con_putc)(struct vc_data *, int, int, int); + int (*con_putcs)(struct vc_data *, const char *, int, int, int); + int (*con_cursor)(struct vc_data *, int); + int (*con_scroll)(struct vc_data *, int, int, int, int); + int (*con_bmove)(struct vc_data *, int, int, int, int, int, int); + int (*con_switch)(struct vc_data *); + int (*con_blank)(int); + int (*con_get_font)(struct vc_data *, int *, int *, char *); + int (*con_set_font)(struct vc_data *, int, int, char *); + int (*con_set_palette)(struct vc_data *, unsigned char *); }; extern struct consw *conswitchp; @@ -123,4 +144,8 @@ #define CM_ERASE (2) #define CM_MOVE (3) -#endif /* linux/console.h */ +#endif /* CONFIG_ABSTRACT_CONSOLE */ + +#endif /* __KERNEL__ */ + +#endif /* _LINUX_CONSOLE_H_ */ --- linux-2.1.29/arch/m68k/kernel/console.c.orig Wed Mar 19 20:06:39 1997 +++ linux-2.1.29/arch/m68k/kernel/console.c Thu Mar 20 21:37:04 1997 @@ -1,2635 +0,0 @@ -/* - * linux/drivers/char/console.c - * - * Copyright (C) 1991, 1992 Linus Torvalds - */ -/* - * console.c - * - * This module exports the console io functions: - * - * 'void do_keyboard_interrupt(void)' - * - * 'int vc_allocate(unsigned int console)' - * 'int vc_cons_allocated(unsigned int console)' - * 'int vc_resize(unsigned long lines, unsigned long cols)' - * 'int vc_resize_con(unsigned long lines, unsigned long cols, - * unsigned int currcons)' - * 'void vc_disallocate(unsigned int currcons)' - * - * 'unsigned long con_init(unsigned long)' - * 'int con_open(struct tty_struct *tty, struct file * filp)' - * 'void con_write(struct tty_struct * tty)' - * 'void console_print(const char * b)' - * 'void update_screen(int new_console)' - * - * 'void do_blank_screen(int)' - * 'void do_unblank_screen(void)' - * 'void poke_blanked_console(void)' - * - * 'unsigned short *screen_pos(int currcons, int w_offset, int viewed)' - * 'void complement_pos(int currcons, int offset)' - * 'void invert_screen(int currcons, int offset, int count, int shift)' - * - * 'void scrollback(int lines)' - * 'void scrollfront(int lines)' - * - * 'int con_get_font(char *)' - * 'int con_set_font(char *)' - * - * 'void mouse_report(struct tty_struct * tty, int butt, int mrx, int mry)' - * 'int mouse_reporting(void)' - * - * 'unsigned long get_video_num_lines(unsigned int console)' - * 'unsigned long get_video_num_columns(unsigned int console)' - * 'unsigned long get_video_size_row(unsigned int console)' - * - * Hopefully this will be a rather complete VT102 implementation. - * - * Beeping thanks to John T Kohl. - * - * Virtual Consoles, Screen Blanking, Screen Dumping, Color, Graphics - * Chars, and VT100 enhancements by Peter MacDonald. - * - * Copy and paste function by Andrew Haylett, - * some enhancements by Alessandro Rubini. - * - * User definable mapping table and font loading by Eugene G. Crosser, - * - * - * Code to check for different video-cards mostly by Galen Hunt, - * - * - * Rudimentary ISO 10646/Unicode/UTF-8 character set support by - * Markus Kuhn, . - * - * Dynamic allocation of consoles, aeb@cwi.nl, May 1994 - * Resizing of consoles, aeb, 940926 - * - * Code for xterm like mouse click reporting by Peter Orbaek 20-Jul-94 - * - * - * 680x0 LINUX support by Arno Griffioen (arno@usn.nl) - * - * 9-Apr-94: Arno Griffioen: fixed scrolling and delete-char bug. - * Scrolling code moved to amicon.c - * - * 18-Apr-94: David Carter [carter@cs.bris.ac.uk]. 680x0 LINUX modified - * Integrated support for new low level driver `amicon_ocs.c' - * - */ - -#define BLANK 0x0020 -#define CAN_LOAD_EGA_FONTS /* undefine if the user must not do this */ - -/* A bitmap for codes <32. A bit of 1 indicates that the code - * corresponding to that bit number invokes some special action - * (such as cursor movement) and should not be displayed as a - * glyph unless the disp_ctrl mode is explicitly enabled. - */ -#define CTRL_ACTION 0x0d00ff81 -#define CTRL_ALWAYS 0x0800f501 /* Cannot be overridden by disp_ctrl */ - -/* - * Here is the default bell parameters: 750HZ, 1/8th of a second - */ -#define DEFAULT_BELL_PITCH 750 -#define DEFAULT_BELL_DURATION (HZ/8) - -/* - * NOTE!!! We sometimes disable and enable interrupts for a short while - * (to put a word in video IO), but this will work even for keyboard - * interrupts. We know interrupts aren't enabled when getting a keyboard - * interrupt, as we use trap-gates. Hopefully all is well. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "../../../drivers/char/kbd_kern.h" -#include "../../../drivers/char/vt_kern.h" -#include "../../../drivers/char/consolemap.h" -#include "../../../drivers/char/selection.h" - - -#ifndef MIN -#define MIN(a,b) ((a) < (b) ? (a) : (b)) -#endif - -#ifdef CONFIG_SERIAL_CONSOLE -int serial_console = 0; -#endif - -struct tty_driver console_driver; -static int console_refcount; -static struct tty_struct *console_table[MAX_NR_CONSOLES]; -static struct termios *console_termios[MAX_NR_CONSOLES]; -static struct termios *console_termios_locked[MAX_NR_CONSOLES]; - -static void vc_init(unsigned int console, int do_clear); - -static void update_attr(int currcons); -static void gotoxy(int currcons, int new_x, int new_y); -static void save_cur(int currcons); -static void blank_screen(void); -static void unblank_screen(void); -extern void change_console(unsigned int); -static inline void set_cursor(int currcons); -static void reset_terminal(int currcons, int do_clear); -extern void reset_vc(unsigned int new_console); -extern void vt_init(void); -extern void register_console(void (*proc)(const char *)); -extern void vesa_blank(void); -extern void vesa_unblank(void); -extern void compute_shiftstate(void); -void poke_blanked_console(void); -void do_blank_screen(int); - -unsigned long video_num_lines; -unsigned long video_num_columns; -unsigned long video_size_row; - -static int printable = 0; /* Is console ready for printing? */ -unsigned long video_font_height; /* Height of current screen font */ -unsigned long video_scan_lines; /* Number of scan lines on screen */ -unsigned long default_font_height; /* Height of default screen font */ -int video_mode_512ch = 0; /* 512-character mode */ -static unsigned short console_charmask = 0x0ff; - -static unsigned short *vc_scrbuf[MAX_NR_CONSOLES]; - -/* used by kbd_bh - set by keyboard_interrupt */ - int do_poke_blanked_console = 0; - int console_blanked = 0; -static int blankinterval = 10*60*HZ; -static int vesa_off_interval = 0; -static int vesa_blank_mode = 0; /* 0:none 1:suspendV 2:suspendH 3:powerdown */ - -static struct vc { - struct vc_data *d; - - /* might add scrmem, vt_struct, kbd at some time, - to have everything in one place - the disadvantage - would be that vc_cons etc can no longer be static */ -} vc_cons [MAX_NR_CONSOLES]; -struct consw *conswitchp; - -#define cols (vc_cons[currcons].d->vc_cols) -#define rows (vc_cons[currcons].d->vc_rows) -#define size_row (vc_cons[currcons].d->vc_size_row) -#define screenbuf_size (vc_cons[currcons].d->vc_screenbuf_size) -#define cons_num (vc_cons[currcons].d->vc_num) -#define origin (vc_cons[currcons].d->vc_origin) -#define scr_end (vc_cons[currcons].d->vc_scr_end) -#define pos (vc_cons[currcons].d->vc_pos) -#define top (vc_cons[currcons].d->vc_top) -#define bottom (vc_cons[currcons].d->vc_bottom) -#define x (vc_cons[currcons].d->vc_x) -#define y (vc_cons[currcons].d->vc_y) -#define vc_state (vc_cons[currcons].d->vc_state) -#define npar (vc_cons[currcons].d->vc_npar) -#define par (vc_cons[currcons].d->vc_par) -#define ques (vc_cons[currcons].d->vc_ques) -#define attr (vc_cons[currcons].d->vc_attr) -#define saved_x (vc_cons[currcons].d->vc_saved_x) -#define saved_y (vc_cons[currcons].d->vc_saved_y) -#define translate (vc_cons[currcons].d->vc_translate) -#define G0_charset (vc_cons[currcons].d->vc_G0_charset) -#define G1_charset (vc_cons[currcons].d->vc_G1_charset) -#define saved_G0 (vc_cons[currcons].d->vc_saved_G0) -#define saved_G1 (vc_cons[currcons].d->vc_saved_G1) -#define utf (vc_cons[currcons].d->vc_utf) -#define utf_count (vc_cons[currcons].d->vc_utf_count) -#define utf_char (vc_cons[currcons].d->vc_utf_char) -#define video_mem_start (vc_cons[currcons].d->vc_video_mem_start) -#define video_mem_end (vc_cons[currcons].d->vc_video_mem_end) -#define video_erase_char (vc_cons[currcons].d->vc_video_erase_char) -#define disp_ctrl (vc_cons[currcons].d->vc_disp_ctrl) -#define toggle_meta (vc_cons[currcons].d->vc_toggle_meta) -#define decscnm (vc_cons[currcons].d->vc_decscnm) -#define decom (vc_cons[currcons].d->vc_decom) -#define decawm (vc_cons[currcons].d->vc_decawm) -#define deccm (vc_cons[currcons].d->vc_deccm) -#define decim (vc_cons[currcons].d->vc_decim) -#define deccolm (vc_cons[currcons].d->vc_deccolm) -#define need_wrap (vc_cons[currcons].d->vc_need_wrap) -#define has_scrolled (vc_cons[currcons].d->vc_has_scrolled) -#define kmalloced (vc_cons[currcons].d->vc_kmalloced) -#define report_mouse (vc_cons[currcons].d->vc_report_mouse) -#define can_do_color (vc_cons[currcons].d->vc_can_do_color) -#define color (vc_cons[currcons].d->vc_color) -#define s_color (vc_cons[currcons].d->vc_s_color) -#define def_color (vc_cons[currcons].d->vc_def_color) -#define foreground (color & 0x0f) -#define background (color & 0xf0) -#define charset (vc_cons[currcons].d->vc_charset) -#define s_charset (vc_cons[currcons].d->vc_s_charset) -#define intensity (vc_cons[currcons].d->vc_intensity) -#define underline (vc_cons[currcons].d->vc_underline) -#define blink (vc_cons[currcons].d->vc_blink) -#define reverse (vc_cons[currcons].d->vc_reverse) -#define s_intensity (vc_cons[currcons].d->vc_s_intensity) -#define s_underline (vc_cons[currcons].d->vc_s_underline) -#define s_blink (vc_cons[currcons].d->vc_s_blink) -#define s_reverse (vc_cons[currcons].d->vc_s_reverse) -#define ulcolor (vc_cons[currcons].d->vc_ulcolor) -#define halfcolor (vc_cons[currcons].d->vc_halfcolor) -#define tab_stop (vc_cons[currcons].d->vc_tab_stop) -#define bell_pitch (vc_cons[currcons].d->vc_bell_pitch) -#define bell_duration (vc_cons[currcons].d->vc_bell_duration) -#define sw (vc_cons[currcons].d->vc_sw) - -#define vcmode (vt_cons[currcons]->vc_mode) -#if 0 /* XXX */ -#define vtmode (vt_cons[currcons]->vt_mode) -#define vtpid (vt_cons[currcons]->vt_pid) -#define vtnewvt (vt_cons[currcons]->vt_newvt) -#endif - -#define structsize (sizeof(struct vc_data) + sizeof(struct vt_struct)) - -int vc_cons_allocated(unsigned int i) -{ - return (i < MAX_NR_CONSOLES && vc_cons[i].d); -} - -int vc_allocate(unsigned int currcons) /* return 0 on success */ -{ - if (currcons >= MAX_NR_CONSOLES) - return -ENODEV; - if (!vc_cons[currcons].d) { - long p, q; - - /* prevent users from taking too much memory */ - if (currcons >= MAX_NR_USER_CONSOLES && !suser()) - return -EPERM; - - /* due to the granularity of kmalloc, we waste some memory here */ - /* the alloc is done in two steps, to optimize the common situation - of a 25x80 console (structsize=216, screenbuf_size=4000) */ - p = (long) kmalloc(structsize, GFP_KERNEL); - if (!p) - return -ENOMEM; - vc_cons[currcons].d = (struct vc_data *) p; - vt_cons[currcons] = (struct vt_struct *)(p+sizeof(struct vc_data)); - - /* ++Geert: sw->con_init determines console size */ - sw = conswitchp; - cons_num = currcons; - sw->con_init (vc_cons[currcons].d); - size_row = cols<<1; - screenbuf_size = rows*size_row; - - q = (long) kmalloc(screenbuf_size, GFP_KERNEL); - if (!q) { - kfree_s((char *) p, structsize); - vc_cons[currcons].d = NULL; - return -ENOMEM; - } - vc_scrbuf[currcons] = (unsigned short *) q; - kmalloced = 1; - vc_init (currcons, 1); - } - return 0; -} - -/* - * Change # of rows and columns (0 means the size of fg_console) - * [this is to be used together with some user program - * like resize that changes the hardware videomode] - */ -int vc_resize(unsigned long lines, unsigned long columns) -{ - unsigned long cc, ll, ss, sr; - unsigned long occ, oll, oss, osr; - unsigned short *p; - unsigned int currcons = fg_console, i; - unsigned short *newscreens[MAX_NR_CONSOLES]; - long ol, nl, rlth, rrem; - - cc = (columns ? columns : cols); - ll = (lines ? lines : rows); - sr = cc << 1; - ss = sr * ll; - - /* - * Some earlier version had all consoles of potentially - * different sizes, but that was really messy. - * So now we only change if there is room for all consoles - * of the same size. - */ - for (currcons = 0; currcons < MAX_NR_CONSOLES; currcons++) { - if (!vc_cons_allocated(currcons)) - newscreens[currcons] = 0; - else { - p = (unsigned short *) kmalloc(ss, GFP_USER); - if (!p) { - for (i = 0; i< currcons; i++) - if (newscreens[i]) - kfree_s(newscreens[i], ss); - return -ENOMEM; - } - newscreens[currcons] = p; - } - } - -#if 0 /* XXX */ - get_scrmem(fg_console); -#endif - - for (currcons = 0; currcons < MAX_NR_CONSOLES; currcons++) { - if (!vc_cons_allocated(currcons)) - continue; - - oll = rows; - occ = cols; - osr = size_row; - oss = screenbuf_size; - - rows = ll; - cols = cc; - size_row = sr; - screenbuf_size = ss; - - rlth = MIN(osr, sr); - rrem = sr - rlth; - ol = origin; - nl = (long) newscreens[currcons]; - if (ll < oll) - ol += (oll - ll) * osr; - - update_attr(currcons); - while (ol < scr_end) { - /* ++Geert: TODO: Because the attributes have different meanings - on monochrome and color, they should really be converted if - can_do_color changes... */ - memcpyw((unsigned short *) nl, (unsigned short *) ol, rlth); - if (rrem) - memsetw((void *)(nl + rlth), video_erase_char, rrem); - ol += osr; - nl += sr; - } - - if (kmalloced) - kfree_s(vc_scrbuf[currcons], oss); - vc_scrbuf[currcons] = newscreens[currcons]; - kmalloced = 1; - screenbuf_size = ss; - - origin = (long) video_mem_start = vc_scrbuf[currcons]; - scr_end = video_mem_end = ((long) video_mem_start) + ss; - - if (scr_end > nl) - memsetw((void *) nl, video_erase_char, scr_end - nl); - - /* do part of a reset_terminal() */ - top = 0; - bottom = rows; - gotoxy(currcons, x, y); - save_cur(currcons); - } - -#if 0 /* XXX */ - set_scrmem(fg_console, 0); - set_origin(fg_console); -#endif /* XXX */ - update_screen(fg_console); - set_cursor(fg_console); - - return 0; -} - -/* - * ++Geert: Change # of rows and columns for one specific console. - * Of course it's not messy to have all consoles of potentially different sizes, - * except on PCish hardware :-) - * - * This is called by the low level console driver (arch/m68k/console/fbcon.c or - * arch/m68k/console/txtcon.c) - */ -void vc_resize_con(unsigned long lines, unsigned long columns, - unsigned int currcons) -{ - unsigned long cc, ll, ss, sr; - unsigned long occ, oll, oss, osr; - unsigned short *newscreen; - long ol, nl, rlth, rrem; - struct winsize ws; - - if (!columns || !lines || currcons >= MAX_NR_CONSOLES) - return; - - cc = columns; - ll = lines; - sr = cc << 1; - ss = sr * ll; - - if (!vc_cons_allocated(currcons)) - newscreen = 0; - else if (!(newscreen = (unsigned short *) kmalloc(ss, GFP_USER))) - return; - - if (vc_cons_allocated(currcons)) { - oll = rows; - occ = cols; - osr = size_row; - oss = screenbuf_size; - - rows = ll; - cols = cc; - size_row = sr; - screenbuf_size = ss; - - rlth = MIN(osr, sr); - rrem = sr - rlth; - ol = origin; - nl = (long) newscreen; - if (ll < oll) - ol += (oll - ll) * osr; - - update_attr(currcons); - while (ol < scr_end) { - /* ++Geert: TODO: Because the attributes have different meanings - on monochrome and color, they should really be converted if - can_do_color changes... */ - memcpyw((unsigned short *) nl, (unsigned short *) ol, rlth); - if (rrem) - memsetw((void *)(nl + rlth), video_erase_char, rrem); - ol += osr; - nl += sr; - } - - if (kmalloced) - kfree_s(vc_scrbuf[currcons], oss); - vc_scrbuf[currcons] = newscreen; - kmalloced = 1; - screenbuf_size = ss; - - origin = (long) video_mem_start = vc_scrbuf[currcons]; - scr_end = video_mem_end = ((long)video_mem_start) + ss; - - if (scr_end > nl) - memsetw((void *) nl, video_erase_char, scr_end - nl); - - /* do part of a reset_terminal() */ - top = 0; - bottom = rows; - gotoxy(currcons, x, y); - save_cur(currcons); - - ws.ws_row = rows; - ws.ws_col = cols; - if (memcmp(&ws, &console_table[currcons]->winsize, sizeof (struct winsize)) && - console_table[currcons]->pgrp > 0) - kill_pg(console_table[currcons]->pgrp, SIGWINCH, 1); - console_table[currcons]->winsize = ws; - } - - if (currcons == fg_console) - update_screen(fg_console); -} - -void vc_disallocate(unsigned int currcons) -{ - if (vc_cons_allocated(currcons)) { - if (kmalloced) - kfree_s(vc_scrbuf[currcons], screenbuf_size); - if (currcons >= MIN_NR_CONSOLES) - kfree_s(vc_cons[currcons].d, structsize); - vc_cons[currcons].d = 0; - } -} - - -#define set_kbd(x) set_vc_kbd_mode(kbd_table+currcons,x) -#define clr_kbd(x) clr_vc_kbd_mode(kbd_table+currcons,x) -#define is_kbd(x) vc_kbd_mode(kbd_table+currcons,x) - -#define decarm VC_REPEAT -#define decckm VC_CKMODE -#define kbdapplic VC_APPLIC -#define lnm VC_CRLF - -/* - * this is what the terminal answers to a ESC-Z or csi0c query. - */ -#define VT100ID "\033[?1;2c" -#define VT102ID "\033[?6c" - -static unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7, - 8,12,10,14, 9,13,11,15 }; - -/* - * gotoxy() must verify all boundaries, because the arguments - * might also be negative. If the given position is out of - * bounds, the cursor is placed at the nearest margin. - */ -static void gotoxy(int currcons, int new_x, int new_y) -{ - int min_y, max_y; - - if (new_x < 0) - x = 0; - else - if (new_x >= cols) - x = cols - 1; - else - x = new_x; - if (decom) { - min_y = top; - max_y = bottom; - } else { - min_y = 0; - max_y = rows; - } - if (new_y < min_y) - y = min_y; - else if (new_y >= max_y) - y = max_y - 1; - else - y = new_y; - pos = video_mem_start + y * cols + x; - need_wrap = 0; -} - -/* for absolute user moves, when decom is set */ -static void gotoxay(int currcons, int new_x, int new_y) -{ - gotoxy(currcons, new_x, decom ? (top+new_y) : new_y); -} - -static void hide_cursor(int currcons) -{ - sw->con_cursor(vc_cons[currcons].d,CM_ERASE); - return; -} - -static void set_cursor(int currcons) -{ - if (currcons != fg_console || console_blanked || vcmode == KD_GRAPHICS) - return; - if (deccm) - sw->con_cursor(vc_cons[currcons].d,CM_DRAW); - else - hide_cursor(currcons); - return; -} - -void no_scroll(char *str, int *ints) -{ - /* - * no_scroll currently does nothing on the m68k. - */ -} - -/* - * Arno: - * Why do we need these? The keyboard code doesn't seem to do anything - * with them either... - */ -void scrollfront(int l) -{ - return; -} - -void scrollback(int l) -{ - return; -} - -static void scrup(int currcons, unsigned int t, unsigned int b, - int nr) -{ - unsigned short *p; - int i; - - if (b > rows || t >= b) - return; - - memmove (video_mem_start + t * cols, - video_mem_start + (t + nr) * cols, - (b - t - nr) * cols * 2); - - p = video_mem_start + (b - nr) * cols; - for (i = nr * cols; i > 0; i--) - *p++ = video_erase_char; - - if (currcons != fg_console) - return; -/* - * Arno: - * Scrolling has now been moved to amicon.c where it should have - * been all along. - */ - sw->con_scroll(vc_cons[currcons].d, t, b, SM_UP, nr); - - return; - -} - -static void scrdown(int currcons, unsigned int t, unsigned int b, - int nr) -{ - unsigned short *p; - int i; - - if (b > rows || t >= b) - return; - - memmove (video_mem_start + (t + nr) * cols, - video_mem_start + t * cols, - (b - t - nr) * cols * 2); - - p = video_mem_start + t * cols; - for (i = nr * cols; i > 0; i--) - *p++ = video_erase_char; - - if (currcons != fg_console) - return; -/* - * Arno: - * Scrolling has now been moved to amicon.c where it should have - * been all along. - */ - sw->con_scroll(vc_cons[currcons].d, t, b, SM_DOWN, nr); - - return; -} - -static void lf(int currcons) -{ - /* don't scroll if above bottom of scrolling region, or - * if below scrolling region - */ - if (y+1 == bottom) - scrup(currcons,top,bottom, 1); - else if (y < rows-1) { - y++; - pos += cols; - } - need_wrap = 0; -} - -static void ri(int currcons) -{ - /* don't scroll if below top of scrolling region, or - * if above scrolling region - */ - if (y == top) - scrdown(currcons,top,bottom, 1); - else if (y > 0) { - y--; - pos -= cols; - } - need_wrap = 0; -} - -static inline void cr(int currcons) -{ - pos -= x; - need_wrap = x = 0; -} - -static inline void bs(int currcons) -{ - if (x) { - pos--; - x--; - need_wrap = 0; - } -} - -static inline void del(int currcons) -{ - /* ignored */ -} - -static void csi_J(int currcons, int vpar) -{ - unsigned long count; - unsigned short *start; - - switch (vpar) { - case 0: /* erase from cursor to end of display */ - count = (video_mem_start - + cols * rows - - pos); - start = pos; - if (currcons != fg_console) - break; - /* 680x0 do in two stages */ - sw->con_clear(vc_cons[currcons].d,y,x,1,cols-x); - sw->con_clear(vc_cons[currcons].d,y+1,0,rows-y-1, cols); - break; - case 1: /* erase from start to cursor */ - count = pos - video_mem_start + 1; - start = video_mem_start; - if (currcons != fg_console) - break; - /* 680x0 do in two stages */ - sw->con_clear(vc_cons[currcons].d,0,0,y, cols); - sw->con_clear(vc_cons[currcons].d,y,0,1,x + 1); - break; - case 2: /* erase whole display */ - count = cols * rows; - start = video_mem_start; - if (currcons != fg_console) - break; - sw->con_clear(vc_cons[currcons].d,0,0,rows, cols); - break; - default: - return; - } - while (count-- > 0) - *start++ = video_erase_char; - need_wrap = 0; -} - -static void csi_K(int currcons, int vpar) -{ - unsigned long count; - unsigned short *start; - - switch (vpar) { - case 0: /* erase from cursor to end of line */ - count = cols - x; - start = pos; - if (currcons != fg_console) - break; - sw->con_clear(vc_cons[currcons].d,y,x,1,cols-x); - break; - case 1: /* erase from start of line to cursor */ - start = pos - x; - count = x + 1; - if (currcons != fg_console) - break; - sw->con_clear(vc_cons[currcons].d,y,0,1,x + 1); - break; - case 2: /* erase whole line */ - start = pos - x; - count = cols; - if (currcons != fg_console) - break; - sw->con_clear(vc_cons[currcons].d,y,0,1,cols); - break; - default: - return; - } - while (count-- > 0) - *start++ = video_erase_char; - need_wrap = 0; -} - -static void csi_X(int currcons, int vpar) /* erase the following vpar positions */ -{ /* not vt100? */ - unsigned long count; - unsigned short * start; - - if (!vpar) - vpar++; - - start=pos; - count=(vpar > cols-x) ? (cols-x) : vpar; - - if (currcons == fg_console) - sw->con_clear(vc_cons[currcons].d,y,x,1,count); - - while (count-- > 0) - *start++ = video_erase_char; - need_wrap = 0; -} - -/* - * Arno: - * On 680x0 attributes are currently not used. This piece of code - * seems hardware independent, but uses the EGA/VGA way of representing - * attributes. - * TODO: modify for 680x0 and add attribute processing to putc code. - * - * ++roman: I completely changed the attribute format for monochrome - * mode (!can_do_color). The formerly used MDA (monochrome display - * adapter) format didn't allow the combination of certain effects. - * Now the attribute is just a bit vector: - * Bit 0..1: intensity (0..2) - * Bit 2 : underline - * Bit 3 : reverse - * Bit 7 : blink - */ -static void update_attr(int currcons) -{ - if (!can_do_color) { - /* Special treatment for monochrome */ - attr = intensity | - (underline ? 4 : 0) | - ((reverse ^ decscnm) ? 8 : 0) | - (blink ? 0x80 : 0); - video_erase_char = ' ' | ((reverse ^ decscnm) ? 0x800 : 0); - return; - } - - attr = color; - if (underline) - attr = (attr & 0xf0) | ulcolor; - else if (intensity == 0) - attr = (attr & 0xf0) | halfcolor; - if (reverse ^ decscnm) - attr = reverse_video_char(attr); - if (blink) - attr ^= 0x80; - if (intensity == 2) - attr ^= 0x08; - if (decscnm) - video_erase_char = (reverse_video_char(color) << 8) | ' '; - else - video_erase_char = (color << 8) | ' '; -} - -static void default_attr(int currcons) -{ - intensity = 1; - underline = 0; - reverse = 0; - blink = 0; - color = def_color; -} - -static void csi_m(int currcons) -{ - int i; - - for (i=0;i<=npar;i++) - switch (par[i]) { - case 0: /* all attributes off */ - default_attr(currcons); - break; - case 1: - intensity = 2; - break; - case 2: - intensity = 0; - break; - case 4: - underline = 1; - break; - case 5: - blink = 1; - break; - case 7: - 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); - disp_ctrl = 0; - toggle_meta = 0; - break; - case 11: /* ANSI X3.64-1979 (SCO-ish?) - * Select first alternate font, let's - * chars < 32 be displayed as ROM chars. - */ - translate = set_translate(IBMPC_MAP); - disp_ctrl = 1; - 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); - disp_ctrl = 1; - toggle_meta = 1; - break; - case 21: - case 22: - intensity = 1; - break; - case 24: - underline = 0; - break; - case 25: - blink = 0; - break; - case 27: - 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; - 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; - break; - case 49: - color = (def_color & 0xf0) | foreground; - 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; - break; - } - update_attr(currcons); -} - -static void respond_string(const char * p, struct tty_struct * tty) -{ - while (*p) { - tty_insert_flip_char(tty, *p, 0); - p++; - } - tty_schedule_flip(tty); -} - -static inline void cursor_report(int currcons, struct tty_struct * tty) -{ - char buf[40]; - - sprintf(buf, "\033[%ld;%ldR", y + (decom ? top+1 : 1), x+1); - respond_string(buf, tty); -} - -static inline void status_report(struct tty_struct * tty) -{ - respond_string("\033[0n", tty); /* Terminal ok */ -} - -static inline void respond_ID(struct tty_struct * tty) -{ - respond_string(VT102ID, tty); -} - -void mouse_report(struct tty_struct * tty, int butt, int mrx, int mry) -{ - char buf[8]; - - sprintf(buf, "\033[M%c%c%c", (char)(' ' + butt), (char)('!' + mrx), - (char)('!' + mry)); - respond_string(buf, tty); -} - -/* invoked via ioctl(TIOCLINUX) */ -int mouse_reporting(void) -{ - int currcons = fg_console; - - return report_mouse; -} - -static inline unsigned short *screenpos(int currcons, int offset, int viewed) -{ - unsigned short *p = (unsigned short *)(origin + offset); -#if 0 - if (viewed && currcons == fg_console) - p -= (__real_origin - __origin); -#endif - return p; -} - -/* Note: inverting the screen twice should revert to the original state */ -void invert_screen(int currcons, int offset, int count, int viewed) -{ - unsigned short *p; - unsigned short xx, yy, oldattr; - - count /= 2; - p = screenpos(currcons, offset, viewed); - xx = (offset >> 1) % cols; - yy = (offset >> 1) / cols; - oldattr = attr; - if (can_do_color) - while (count--) { - unsigned short old = scr_readw(p); - unsigned short new = reverse_video_short(old); - scr_writew(new, p); - p++; - if (currcons != fg_console) - continue; - attr = new >> 8; - sw->con_putc(vc_cons[currcons].d, new & 0xff, yy, xx); - if (++xx == cols) - xx = 0, ++yy; - } - else - while (count--) { - unsigned short old = scr_readw(p); - unsigned short new = old ^ 0x800; - scr_writew(new, p); - p++; - if (currcons != fg_console) - continue; - attr = new >> 8; - sw->con_putc(vc_cons[currcons].d, new & 0xff, yy, xx); - if (++xx == cols) - xx = 0, ++yy; - } - attr = oldattr; -} - -/* used by selection: complement pointer position */ -void complement_pos(int currcons, int offset) -{ - static unsigned short *p = NULL; - static unsigned short old = 0; - static unsigned short oldx = 0, oldy = 0; - unsigned short new, oldattr; - - oldattr = attr; - if (p) { - scr_writew(old, p); - if (currcons == fg_console) { - attr = old >> 8; - sw->con_putc(vc_cons[currcons].d, old & 0xff, oldy, oldx); - attr = oldattr; - } - } - if (offset == -1) - p = NULL; - else { - p = screenpos(currcons, offset, 1); - old = scr_readw(p); - oldx = (offset >> 1) % cols; - oldy = (offset >> 1) / cols; - if (can_do_color) - new = old ^ 0x7700; - else - new = old ^ 0x800; - scr_writew(new, p); - if (currcons == fg_console) { - attr = new >> 8; - sw->con_putc(vc_cons[currcons].d, new & 0xff, oldy, oldx); - attr = oldattr; - } - } -} - -/* used by selection */ -unsigned short screen_word(int currcons, int offset, int viewed) -{ - return scr_readw(screenpos(currcons, offset, viewed)); -} - -/* used by selection - convert a screen word to a glyph number */ -int scrw2glyph(unsigned short scr_word) -{ - return ( video_mode_512ch ) - ? ((scr_word & 0x0800) >> 3) + (scr_word & 0x00ff) - : scr_word & 0x00ff; -} - -/* used by vcs - note the word offset */ -unsigned short *screen_pos(int currcons, int w_offset, int viewed) -{ - return screenpos(currcons, 2 * w_offset, viewed); -} - -void getconsxy(int currcons, char *p) -{ - p[0] = x; - p[1] = y; -} - -void putconsxy(int currcons, char *p) -{ - gotoxy(currcons, p[0], p[1]); - set_cursor(currcons); -} - -static void set_mode(int currcons, int on_off) -{ - int i; - - for (i=0; i<=npar; i++) - if (ques) switch(par[i]) { /* DEC private modes set/reset */ - case 1: /* Cursor keys send ^[Ox/^[[x */ - if (on_off) - set_kbd(decckm); - else - clr_kbd(decckm); - break; - case 3: /* 80/132 mode switch unimplemented */ - deccolm = on_off; -#if 0 - (void) vc_resize(rows, deccolm ? 132 : 80); - /* this alone does not suffice; some user mode - utility has to change the hardware regs */ -#endif - break; - case 5: /* Inverted screen on/off */ - if (decscnm != on_off) { - decscnm = on_off; - invert_screen(currcons, 0, screenbuf_size, 0); - update_attr(currcons); - } - break; - case 6: /* Origin relative/absolute */ - decom = on_off; - gotoxay(currcons,0,0); - break; - case 7: /* Autowrap on/off */ - decawm = on_off; - break; - case 8: /* Autorepeat on/off */ - if (on_off) - set_kbd(decarm); - else - clr_kbd(decarm); - break; - case 9: - report_mouse = on_off ? 1 : 0; - break; - case 25: /* Cursor on/off */ - deccm = on_off; - set_cursor(currcons); - break; - case 1000: - report_mouse = on_off ? 2 : 0; - break; - } else switch(par[i]) { /* ANSI modes set/reset */ - case 3: /* Monitor (display ctrls) */ - disp_ctrl = on_off; - break; - case 4: /* Insert Mode on/off */ - decim = on_off; - break; - case 20: /* Lf, Enter == CrLf/Lf */ - if (on_off) - set_kbd(lnm); - else - clr_kbd(lnm); - break; - } -} - -static void setterm_command(int currcons) -{ - switch(par[0]) { - case 1: /* set color for underline mode */ - if (can_do_color && par[1] < 16) { - ulcolor = color_table[par[1]]; - if (underline) - update_attr(currcons); - } - break; - case 2: /* set color for half intensity mode */ - if (can_do_color && par[1] < 16) { - halfcolor = color_table[par[1]]; - if (intensity == 0) - update_attr(currcons); - } - break; - case 8: /* store colors as defaults */ - def_color = attr; - default_attr(currcons); - update_attr(currcons); - break; - case 9: /* set blanking interval */ - blankinterval = ((par[1] < 60) ? par[1] : 60) * 60 * HZ; - poke_blanked_console(); - break; - case 10: /* set bell frequency in Hz */ - if (npar >= 1) - bell_pitch = par[1]; - else - 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; - else - bell_duration = DEFAULT_BELL_DURATION; - break; - case 12: /* bring specified console to the front */ - if (par[1] >= 1 && vc_cons_allocated(par[1]-1)) - update_screen(par[1]-1); - break; - case 13: /* unblank the screen */ - unblank_screen(); - break; - case 14: /* set vesa powerdown interval */ - vesa_off_interval = ((par[1] < 60) ? par[1] : 60) * 60 * HZ; - break; - } -} - -static inline void insert_char(int currcons) -{ - int i; - unsigned short *p = pos; - - for (i = cols - x - 2; i >= 0; i--) - p[i + 1] = p[i]; - *pos = video_erase_char; - need_wrap = 0; - - if (currcons != fg_console) - return; - - /* Arno: - * Move the remainder of the line (-1 character) one spot to the right - */ - sw->con_bmove(vc_cons[currcons].d,y,x,y,x+1,1,(cols-x-1)); - /* - * Print the erase char on the current position - */ - sw->con_putc(vc_cons[currcons].d,(video_erase_char & 0x00ff),y,x); -} - -static void csi_at(int currcons, unsigned int nr) -{ - int i; - unsigned short *p; - - if (nr > cols - x) - nr = cols - x; - else if (!nr) - nr = 1; - - p = pos + cols - x - nr; - while (--p >= pos) - p[nr] = *p; - for (i = 0; i < nr; i++) - *++p = video_erase_char; - need_wrap = 0; - - if (currcons != fg_console) - return; - - sw->con_bmove (vc_cons[currcons].d, y, x, y, x + nr, - 1, cols - x - nr); - while (nr--) - sw->con_putc (vc_cons[currcons].d, video_erase_char & 0x00ff, - y, x + nr); -} - -static void csi_L(int currcons, unsigned int nr) -{ - if (nr > rows) - nr = rows; - else if (!nr) - nr = 1; - scrdown (currcons, y, bottom, nr); - need_wrap = 0; -} - -static void csi_P(int currcons, unsigned int nr) -{ - int i; - unsigned short *p, *end; - - if (nr > cols - x) - nr = cols - x; - else if (!nr) - nr = 1; - - p = pos; - end = pos + cols - x - nr; - while (p < end) - *p = p[nr], p++; - for (i = 0; i < nr; i++) - *p++ = video_erase_char; - need_wrap = 0; - - if (currcons != fg_console) - return; - - sw->con_bmove (vc_cons[currcons].d, y, x + nr, y, x, - 1, cols - x - nr); - - while (nr--) - sw->con_putc (vc_cons[currcons].d, video_erase_char & 0x00ff, - y, cols - 1 - nr); -} - -static void csi_M(int currcons, unsigned int nr) -{ - if (nr > rows) - nr = rows; - else if (!nr) - nr=1; - scrup (currcons, y, bottom, nr); - need_wrap = 0; -} - -static void save_cur(int currcons) -{ - 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; -} - -static void restore_cur(int currcons) -{ - gotoxy(currcons,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); - update_attr(currcons); - need_wrap = 0; -} - -enum { ESnormal, ESesc, ESsquare, ESgetpars, ESgotpars, ESfunckey, - EShash, ESsetG0, ESsetG1, ESpercent, ESignore, ESnonstd, - ESpalette }; - -static void reset_terminal(int currcons, int do_clear) -{ - top = 0; - bottom = rows; - vc_state = ESnormal; - ques = 0; - translate = set_translate(LAT1_MAP); - 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; - - set_kbd(decarm); - clr_kbd(decckm); - clr_kbd(kbdapplic); - clr_kbd(lnm); - kbd_table[currcons].lockstate = 0; - kbd_table[currcons].slockstate = 0; - kbd_table[currcons].ledmode = LED_SHOW_FLAGS; - kbd_table[currcons].ledflagstate = kbd_table[currcons].default_ledflagstate; - set_leds(); - - default_attr(currcons); - update_attr(currcons); - - tab_stop[0] = 0x01010100; - tab_stop[1] = - tab_stop[2] = - tab_stop[3] = - tab_stop[4] = 0x01010101; - - bell_pitch = DEFAULT_BELL_PITCH; - bell_duration = DEFAULT_BELL_DURATION; - - gotoxy(currcons,0,0); - save_cur(currcons); - if (do_clear) - csi_J(currcons,2); -} - -/* - * Turn the Scroll-Lock LED on when the tty is stopped - */ -static void con_stop(struct tty_struct *tty) -{ - int console_num; - if (!tty) - return; - console_num = MINOR(tty->device) - (tty->driver.minor_start); - if (!vc_cons_allocated(console_num)) - return; - set_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK); - set_leds(); -} - -/* - * Turn the Scroll-Lock LED off when the console is started - */ -static void con_start(struct tty_struct *tty) -{ - int console_num; - if (!tty) - return; - console_num = MINOR(tty->device) - (tty->driver.minor_start); - if (!vc_cons_allocated(console_num)) - return; - clr_vc_kbd_led(kbd_table + console_num, VC_SCROLLOCK); - set_leds(); -} - -static void con_flush_chars(struct tty_struct *tty) -{ - unsigned int currcons; - struct vt_struct *vt = (struct vt_struct *)tty->driver_data; - - currcons = vt->vc_num; - if (vcmode != KD_GRAPHICS) - set_cursor(currcons); -} - -static int do_con_write(struct tty_struct * tty, int from_user, - const unsigned char *buf, int count) -{ - int c, tc, ok, n = 0; - unsigned int currcons; - struct vt_struct *vt = (struct vt_struct *)tty->driver_data; - - currcons = vt->vc_num; - if (!vc_cons_allocated(currcons)) { - /* could this happen? */ - static int error = 0; - if (!error) { - error = 1; - printk("con_write: tty %d not allocated\n", currcons+1); - } - return 0; - } - - /* undraw cursor first */ - if (currcons == fg_console) - hide_cursor(currcons); - - /* clear the selection */ - if (currcons == sel_cons) - clear_selection(); - - disable_bh(CONSOLE_BH); - while (count) { - enable_bh(CONSOLE_BH); - if (from_user) - get_user(c, buf); - else - c = *buf; - buf++; n++; count--; - disable_bh(CONSOLE_BH); - - if (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; - else continue; - } else { - if ((c & 0xe0) == 0xc0) { - utf_count = 1; - utf_char = (c & 0x1f); - } else if ((c & 0xf0) == 0xe0) { - utf_count = 2; - utf_char = (c & 0x0f); - } else if ((c & 0xf8) == 0xf0) { - utf_count = 3; - utf_char = (c & 0x07); - } else if ((c & 0xfc) == 0xf8) { - utf_count = 4; - utf_char = (c & 0x03); - } else if ((c & 0xfe) == 0xfc) { - utf_count = 5; - utf_char = (c & 0x01); - } else - utf_count = 0; - continue; - } - } else { - tc = c; - utf_count = 0; - } - } else { /* no utf */ - tc = translate[toggle_meta ? (c|0x80) : c]; - } - - /* If the original code was a control character we - * only allow a glyph to be displayed if the code is - * not normally used (such as for cursor movement) or - * if the disp_ctrl mode has been explicitly enabled. - * Certain characters (as given by the CTRL_ALWAYS - * bitmap) are always displayed as control characters, - * as the console would be pretty useless without - * them; to display an arbitrary font position use the - * 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) - && (c != 128+27); - - if (vc_state == ESnormal && ok) { - /* Now try to find out how to display it */ - tc = conv_uni_to_pc(tc); - if ( tc == -4 ) { - /* If we got -4 (not found) then see if we have - defined a replacement character (U+FFFD) */ - tc = conv_uni_to_pc(0xfffd); - } else if ( tc == -3 ) { - /* Bad hash table -- hope for the best */ - tc = c; - } - if (tc & ~console_charmask) - continue; /* Conversion failed */ - - if (need_wrap) { - cr(currcons); - lf(currcons); - } - -#if 1 /* XXX */ - /* DPC: 1994-04-12 - * Speed up overstrike mode, using new putcs. - * - * P.S. I hate 8 spaces per tab! Use Emacs! - */ - - /* Only use this for the foreground console, - where we really draw the chars */ - - if (count > 2 && - !decim && !utf && currcons == fg_console) { - static char putcs_buf[256]; - char *p = putcs_buf; - int putcs_count = 1; - ushort nextx = x + 1; - - *p++ = tc; - *pos++ = tc | (attr << 8); - - if (nextx == cols) { - sw->con_putc(vc_cons[currcons].d, - *putcs_buf, y, x); - pos--; - need_wrap = decawm; - continue; - } - - /* TAB TAB TAB - Arghh!!!! */ - - while (count) - { - enable_bh(CONSOLE_BH); - if (from_user) - get_user(c, buf); - else - c = *buf; - disable_bh(CONSOLE_BH); - tc = translate[toggle_meta ? (c|0x80) : c]; - if (!tc || - !(c >= 32 - || !(((disp_ctrl ? CTRL_ALWAYS - : CTRL_ACTION) >> c) & 1))) - break; - tc = conv_uni_to_pc(tc); - if (tc == -4) - tc = conv_uni_to_pc(0xfffd); - else if (tc == -3) - tc = c; - - buf++; n++; count--; - if (tc & ~console_charmask) - continue; /* Conversion failed */ - - *p++ = tc; - *pos++ = tc | (attr << 8); - ++putcs_count; - ++nextx; - if (nextx == cols || - putcs_count == sizeof (putcs_buf)) - break; - } - - sw->con_putcs(vc_cons[currcons].d, - putcs_buf, putcs_count, y, x); - if (nextx == cols) { - pos--; - x = cols-1; - need_wrap = decawm; - } else - x += putcs_count; - continue; - } - - /* DPC: End of putcs support */ -#endif - - if (decim) - insert_char(currcons); - *pos = (attr << 8) + tc; - if (currcons == fg_console) - sw->con_putc(vc_cons[currcons].d,tc,y,x); - if (x == cols - 1) - need_wrap = decawm; - else { - pos++; - x++; - } - continue; - } - - /* - * Control characters can be used in the _middle_ - * of an escape sequence. - */ - switch (c) { - case 0: - continue; - case 7: - if (bell_duration) - kd_mksound(bell_pitch, bell_duration); - continue; - case 8: - bs(currcons); - continue; - case 9: - pos -= x; - while (x < cols - 1) { - x++; - if (tab_stop[x >> 5] & (1 << (x & 31))) - break; - } - pos += x; - continue; - case 10: case 11: case 12: - lf(currcons); - if (!is_kbd(lnm)) - continue; - case 13: - cr(currcons); - continue; - case 14: - charset = 1; - translate = set_translate(G1_charset); - disp_ctrl = 1; - continue; - case 15: - charset = 0; - translate = set_translate(G0_charset); - disp_ctrl = 0; - continue; - case 24: case 26: - vc_state = ESnormal; - continue; - case 27: - vc_state = ESesc; - continue; - case 127: - del(currcons); - continue; - case 128+27: - vc_state = ESsquare; - continue; - } - switch(vc_state) { - case ESesc: - vc_state = ESnormal; - switch (c) { - case '[': - vc_state = ESsquare; - continue; - case ']': - vc_state = ESnonstd; - continue; - case '%': - vc_state = ESpercent; - continue; - case 'E': - cr(currcons); - lf(currcons); - continue; - case 'M': - ri(currcons); - continue; - case 'D': - lf(currcons); - continue; - case 'H': - tab_stop[x >> 5] |= (1 << (x & 31)); - continue; - case 'Z': - respond_ID(tty); - continue; - case '7': - save_cur(currcons); - continue; - case '8': - restore_cur(currcons); - continue; - case '(': - vc_state = ESsetG0; - continue; - case ')': - vc_state = ESsetG1; - continue; - case '#': - vc_state = EShash; - continue; - case 'c': - reset_terminal(currcons,1); - continue; - case '>': /* Numeric keypad */ - clr_kbd(kbdapplic); - continue; - case '=': /* Appl. keypad */ - set_kbd(kbdapplic); - continue; - } - continue; - case ESnonstd: - if (c=='P') { /* palette escape sequence */ - for (npar=0; npar='0'&&c<='9') || (c>='A'&&c<='F') || (c>='a'&&c<='f') ) { - par[npar++] = (c>'9' ? (c&0xDF)-'A'+10 : c-'0') ; - if (npar==7) { -#if 0 - 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]; - set_palette() ; -#endif - vc_state = ESnormal; - } - } else - vc_state = ESnormal; - continue; - case ESsquare: - for(npar = 0 ; npar < NPAR ; npar++) - par[npar] = 0; - npar = 0; - vc_state = ESgetpars; - if (c == '[') { /* Function key */ - vc_state=ESfunckey; - continue; - } - ques = (c=='?'); - if (ques) - continue; - case ESgetpars: - if (c==';' && npar='0' && c<='9') { - par[npar] *= 10; - par[npar] += c-'0'; - continue; - } else vc_state=ESgotpars; - case ESgotpars: - vc_state = ESnormal; - switch(c) { - case 'h': - set_mode(currcons,1); - continue; - case 'l': - set_mode(currcons,0); - continue; - case 'n': - if (!ques) - if (par[0] == 5) - status_report(tty); - else if (par[0] == 6) - cursor_report(currcons,tty); - continue; - } - if (ques) { - ques = 0; - continue; - } - switch(c) { - case 'G': case '`': - if (par[0]) par[0]--; - gotoxy(currcons,par[0],y); - continue; - case 'A': - if (!par[0]) par[0]++; - gotoxy(currcons,x,y-par[0]); - continue; - case 'B': case 'e': - if (!par[0]) par[0]++; - gotoxy(currcons,x,y+par[0]); - continue; - case 'C': case 'a': - if (!par[0]) par[0]++; - gotoxy(currcons,x+par[0],y); - continue; - case 'D': - if (!par[0]) par[0]++; - gotoxy(currcons,x-par[0],y); - continue; - case 'E': - if (!par[0]) par[0]++; - gotoxy(currcons,0,y+par[0]); - continue; - case 'F': - if (!par[0]) par[0]++; - gotoxy(currcons,0,y-par[0]); - continue; - case 'd': - if (par[0]) par[0]--; - gotoxay(currcons,x,par[0]); - continue; - case 'H': case 'f': - if (par[0]) par[0]--; - if (par[1]) par[1]--; - gotoxay(currcons,par[1],par[0]); - continue; - case 'J': - csi_J(currcons,par[0]); - continue; - case 'K': - csi_K(currcons,par[0]); - continue; - case 'L': - csi_L(currcons,par[0]); - continue; - case 'M': - csi_M(currcons,par[0]); - continue; - case 'P': - csi_P(currcons,par[0]); - continue; - case 'c': - if (!par[0]) - respond_ID(tty); - continue; - 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; - } - continue; - case 'm': - csi_m(currcons); - continue; - case 'q': /* DECLL - but only 3 leds */ - /* map 0,1,2,3 to 0,1,2,4 */ - if (par[0] < 4) - setledstate(kbd_table + currcons, - (par[0] < 3) ? par[0] : 4); - continue; - case 'r': - if (!par[0]) - par[0]++; - if (!par[1]) - par[1] = rows; - /* Minimum allowed region is 2 lines */ - if (par[0] < par[1] && - par[1] <= rows) { - top=par[0]-1; - bottom=par[1]; - gotoxay(currcons,0,0); - } - continue; - case 's': - save_cur(currcons); - continue; - case 'u': - restore_cur(currcons); - continue; - case 'X': - csi_X(currcons, par[0]); - continue; - case '@': - csi_at(currcons,par[0]); - continue; - case ']': /* setterm functions */ - setterm_command(currcons); - continue; - } - continue; - case ESpercent: - vc_state = ESnormal; - switch (c) { - case '@': /* defined in ISO 2022 */ - utf = 0; - continue; - case 'G': /* prelim official escape code */ - case '8': /* retained for compatibility */ - utf = 1; - continue; - } - continue; - case ESfunckey: - vc_state = ESnormal; - continue; - case EShash: - vc_state = ESnormal; - if (c == '8') { - /* DEC screen alignment test. kludge :-) */ - video_erase_char = - (video_erase_char & 0xff00) | 'E'; - /* Arno: - * Doesn't work, because csi_J(c,2) - * calls con_clear and doesn't print - * the erase char.. - */ - csi_J(currcons, 2); - video_erase_char = - (video_erase_char & 0xff00) | ' '; - } - continue; - case ESsetG0: - if (c == '0') - G0_charset = GRAF_MAP; - else if (c == 'B') - G0_charset = LAT1_MAP; - else if (c == 'U') - G0_charset = IBMPC_MAP; - else if (c == 'K') - G0_charset = USER_MAP; - if (charset == 0) - translate = set_translate(G0_charset); - vc_state = ESnormal; - continue; - case ESsetG1: - if (c == '0') - G1_charset = GRAF_MAP; - else if (c == 'B') - G1_charset = LAT1_MAP; - else if (c == 'U') - G1_charset = IBMPC_MAP; - else if (c == 'K') - G1_charset = USER_MAP; - if (charset == 1) - translate = set_translate(G1_charset); - vc_state = ESnormal; - continue; - default: - vc_state = ESnormal; - } - } - enable_bh(CONSOLE_BH); - return n; -} - -static int con_write(struct tty_struct * tty, int from_user, - const unsigned char *buf, int count) -{ - int retval; - - retval = do_con_write(tty, from_user, buf, count); - con_flush_chars(tty); - - return retval; -} - -static void con_put_char(struct tty_struct *tty, unsigned char ch) -{ - do_con_write(tty, 0, &ch, 1); -} - -static int con_write_room(struct tty_struct *tty) -{ - if (tty->stopped) - return 0; - return 4096; /* No limit, really; we're not buffering */ -} - -static int con_chars_in_buffer(struct tty_struct *tty) -{ - return 0; /* we're not buffering */ -} - -void poke_blanked_console(void) -{ - timer_active &= ~(1<vc_mode == KD_GRAPHICS) - return; - if (console_blanked) { - timer_table[BLANK_TIMER].fn = unblank_screen; - timer_table[BLANK_TIMER].expires = 0; - timer_active |= 1< 0) { - sw->con_putcs(vc_cons[currcons].d, start, count , - y, x); - x += count; - if (need_wrap) - x--; - } - - if (c == 8) { /* backspace */ - bs(currcons); - start = b; - myx = x; - continue; - } - if (c != 13) - lf(currcons); - cr(currcons); - - if (c == 10 || c == 13) { - start = b; myx = x; continue; - } - - start = b-1; myx = x; - } - - *pos = c | (attr << 8); - if (myx == cols - 1) { - need_wrap = 1; - continue; - } - pos++; - myx++; - } - - if ((count = b - start -1) > 0) { - sw->con_putcs(vc_cons[currcons].d, start, count , - y, x); - x += count; - if (x == cols) - { - x--; - need_wrap = 1; - } - } - - set_cursor(currcons); - poke_blanked_console(); - printing = 0; -} - - -/* - * con_throttle and con_unthrottle are only used for - * paste_selection(), which has to stuff in a large number of - * characters... - */ -static void con_throttle(struct tty_struct *tty) -{ -} - -static void con_unthrottle(struct tty_struct *tty) -{ - struct vt_struct *vt = (struct vt_struct *) tty->driver_data; - - wake_up_interruptible(&vt->paste_wait); -} - -static void vc_init(unsigned int currcons, int do_clear) -{ - long base = (long) vc_scrbuf[currcons]; - - pos = (unsigned short *)(origin = (ulong)video_mem_start = base); - scr_end = base + screenbuf_size; - video_mem_end = base + screenbuf_size; - reset_vc(currcons); - def_color = 0x07; /* white */ - ulcolor = 0x0f; /* bold white */ - halfcolor = 0x08; /* grey */ - vt_cons[currcons]->paste_wait = 0; - reset_terminal(currcons, do_clear); -} - -/* - * This is the console switching bottom half handler. - * - * Doing console switching in a bottom half handler allows - * us to do the switches asynchronously (needed when we want - * to switch due to a keyboard interrupt), while still giving - * us the option to easily disable it to avoid races when we - * need to write to the console. - */ -static void console_bh(void) -{ - if (want_console >= 0) { - if (want_console != fg_console) { - change_console(want_console); - /* we only changed when the console had already - been allocated - a new console is not created - in an interrupt routine */ - } - want_console = -1; - } - if (do_poke_blanked_console) { /* do not unblank for a LED change */ - do_poke_blanked_console = 0; - poke_blanked_console(); - } -} - -/* - * unsigned long con_init(unsigned long); - * - * This routine initializes console interrupts, and does nothing - * else. If you want the screen to clear, call tty_write with - * the appropriate escape-sequence. - * - * Reads the information preserved by setup.s to determine the current display - * type and sets everything accordingly. - */ -unsigned long con_init(unsigned long kmem_start) -{ - const char *display_desc = "????"; - unsigned int currcons = 0; - extern int serial_debug; - - memset(&console_driver, 0, sizeof(struct tty_driver)); - console_driver.magic = TTY_DRIVER_MAGIC; - console_driver.name = "tty"; - console_driver.name_base = 1; - console_driver.major = TTY_MAJOR; - console_driver.minor_start = 1; - console_driver.num = MAX_NR_CONSOLES; - console_driver.type = TTY_DRIVER_TYPE_CONSOLE; - console_driver.init_termios = tty_std_termios; - console_driver.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS; - console_driver.refcount = &console_refcount; - console_driver.table = console_table; - console_driver.termios = console_termios; - console_driver.termios_locked = console_termios_locked; - - console_driver.open = con_open; - console_driver.write = con_write; - console_driver.write_room = con_write_room; - console_driver.put_char = con_put_char; - console_driver.flush_chars = con_flush_chars; - console_driver.chars_in_buffer = con_chars_in_buffer; - console_driver.ioctl = vt_ioctl; - console_driver.stop = con_stop; - console_driver.start = con_start; - console_driver.throttle = con_throttle; - console_driver.unthrottle = con_unthrottle; - - if (tty_register_driver(&console_driver)) - panic("Couldn't register console driver\n"); - - kmem_start = conswitchp->con_startup (kmem_start, &display_desc); - - timer_table[BLANK_TIMER].fn = blank_screen; - timer_table[BLANK_TIMER].expires = 0; - if (blankinterval) { - timer_table[BLANK_TIMER].expires = jiffies + blankinterval; - timer_active |= 1<con_init determines console size */ - sw = conswitchp; - cons_num = currcons; - sw->con_init (vc_cons[currcons].d); - size_row = cols<<1; - screenbuf_size = rows*size_row; - - vc_scrbuf[currcons] = (unsigned short *) kmem_start; - kmem_start += screenbuf_size; - kmalloced = 0; - vc_init(currcons, currcons); - } - - currcons = fg_console = 0; - - gotoxy(currcons,0,0); - csi_J(currcons, 0); - printable = 1; - update_screen(fg_console); - sw->con_cursor(vc_cons[currcons].d, CM_DRAW); - printable = 1; - - /* If "serdebug" cmd line option was present, don't register for printk */ - if (!serial_debug -#ifdef CONFIG_SERIAL_CONSOLE - && !serial_console -#endif /* CONFIG_SERIAL_CONSOLE */ - ) - register_console(console_print); - printk("Console: %s %s %ldx%ld, %d virtual console%s (max %d)\n", - can_do_color ? "colour":"mono", - display_desc, - cols,rows, - MIN_NR_CONSOLES, (MIN_NR_CONSOLES == 1) ? "" : "s", MAX_NR_CONSOLES); - - init_bh(CONSOLE_BH, console_bh); - return kmem_start; -} - -void vesa_powerdown_screen(void) -{ - int currcons = fg_console; - - timer_active &= ~(1<con_blank(2); - break; - case 1: - case 2: - sw->con_blank(4); - break; - } -} - -void do_blank_screen(int nopowersave) -{ - int currcons; - - if (console_blanked) - return; - - if (!vc_cons_allocated(fg_console)) { - /* impossible */ - printk("blank_screen: tty %d not allocated ??\n", fg_console+1); - return; - } - - /* don't blank graphics */ - if (vt_cons[fg_console]->vc_mode == KD_TEXT) { - if (vesa_off_interval && !nopowersave) { - timer_table[BLANK_TIMER].fn = vesa_powerdown_screen; - timer_table[BLANK_TIMER].expires = jiffies + vesa_off_interval; - timer_active |= (1<con_blank(1); - if (!nopowersave) - sw->con_blank(vesa_blank_mode + 1); - } - else - hide_cursor(fg_console); - console_blanked = fg_console + 1; -} - -void do_unblank_screen(void) -{ - int currcons; - - if (!console_blanked) - return; - if (!vc_cons_allocated(fg_console)) { - /* impossible */ - printk("unblank_screen: tty %d not allocated ??\n", fg_console+1); - return; - } - timer_table[BLANK_TIMER].fn = blank_screen; - if (blankinterval) { - timer_table[BLANK_TIMER].expires = jiffies + blankinterval; - timer_active |= 1<con_blank (0)) - /* Low-level driver cannot restore -> do it ourselves */ - update_screen( fg_console ); - set_cursor (fg_console); -} - -void update_screen(int new_console) -{ - int currcons = fg_console; - int xx, yy, startx, attr_save; - char buf[256], *bufp; - unsigned short *p; - static int lock = 0; - - if (/* new_console == fg_console || */ lock) - return; - if (!vc_cons_allocated(new_console)) { - /* strange ... */ - printk("update_screen: tty %d not allocated ??\n", new_console+1); - return; - } - lock = 1; - - clear_selection(); - - currcons = fg_console = new_console; - sw->con_cursor (vc_cons[currcons].d, CM_ERASE); - sw->con_switch (vc_cons[new_console].d); - /* Update the screen contents */ - p = video_mem_start; - attr_save = attr; - for (yy = 0; yy < rows; yy++) - { - bufp = buf; - for (startx = xx = 0; xx < cols; xx++) - { - if (attr != ((*p >> 8) & 0xff)) - { - if (bufp > buf) - sw->con_putcs (vc_cons[currcons].d, buf, bufp - buf, - yy, startx); - startx = xx; - bufp = buf; - attr = (*p >> 8) & 0xff; - } - *bufp++ = *p++; - if (bufp == buf + sizeof (buf)) - { - sw->con_putcs (vc_cons[currcons].d, buf, bufp - buf, - yy, startx); - startx = xx + 1; - bufp = buf; - } - } - if (bufp > buf) - sw->con_putcs (vc_cons[currcons].d, buf, bufp - buf, - yy, startx); - } - set_cursor (currcons); - attr = attr_save; - set_leds(); - compute_shiftstate(); - lock = 0; -} - -/* - * If a blank_screen is due to a timer, then a power save is allowed. - * If it is related to console_switching, then avoid vesa_blank(). - */ -static void blank_screen(void) -{ - do_blank_screen(0); -} - -static void unblank_screen(void) -{ - do_unblank_screen(); -} - -/* - * Allocate the console screen memory. - */ -int con_open(struct tty_struct *tty, struct file * filp) -{ - unsigned int currcons; - int i; - - currcons = MINOR(tty->device) - tty->driver.minor_start; - - i = vc_allocate(currcons); - if (i) - return i; - - vt_cons[currcons]->vc_num = currcons; - tty->driver_data = vt_cons[currcons]; - - if (!tty->winsize.ws_row && !tty->winsize.ws_col) { - tty->winsize.ws_row = rows; - tty->winsize.ws_col = cols; - } - - return 0; -} - -/* - * PIO_FONT support. - * - * Currently we only support 8 pixels wide fonts, at a maximum height - * of 32 pixels. Userspace fontdata is stored with 32 bytes reserved - * for each character which is kinda wasty, but this is done in order - * to maintain compatibility with the EGA/VGA fonts. It is upto the - * actual low-level console-driver convert data into its favorite - * format (maybe we should add a `fontoffset' field to the `display' - * structure so we wont have to convert the fontdata all the time. - * /Jes - */ - -#define cmapsz 8192 - -static int set_get_font(char * arg, int set, int ch512) -{ -#ifdef CAN_LOAD_EGA_FONTS - int i, unit, size; - char *charmap; - - if (!arg) - return -EINVAL; - - - size = ch512 ? 2*cmapsz : cmapsz; - - charmap = (char *)kmalloc(size, GFP_USER); - - if (set){ - if (copy_from_user(charmap, arg, size)) { - kfree(charmap); - return -EFAULT; - } - - for (unit = 32; unit > 0; unit--) - for (i = 0; i < (ch512 ? 512 : 256); i++) - if (charmap[32*i+unit-1]) - goto nonzero; - nonzero: - i = conswitchp->con_set_font(vc_cons[fg_console].d, 8, - unit, charmap); - }else{ - memset(charmap, 0, size); - i = conswitchp->con_get_font(vc_cons[fg_console].d, - &unit, &unit, charmap); - if (i == 0 && copy_to_user(arg, charmap, size)) - i = -EFAULT; - } - kfree(charmap); - - return i; -#else - return -EINVAL; -#endif -} - -/* - * Load palette into the EGA/VGA DAC registers. arg points to a colour - * map, 3 bytes per colour, 16 colours, range from 0 to 255. - */ - -int con_set_cmap (unsigned char *arg) -{ - return -EINVAL; -} - -int con_get_cmap (unsigned char *arg) -{ - return -EINVAL; -} - -void reset_palette(int currcons) -{ -} - -void set_palette(void) -{ -} - -/* - * Load font into the EGA/VGA character generator. arg points to a 8192 - * byte map, 32 bytes per character. Only first H of them are used for - * 8xH fonts (0 < H <= 32). - */ - -int con_set_font (char *arg, int ch512) -{ - int i; - - i = set_get_font (arg,1,ch512); - if ( !i ) { - hashtable_contents_valid = 0; - video_mode_512ch = ch512; - console_charmask = ch512 ? 0x1ff : 0x0ff; - } - return i; -} - -int con_get_font (char *arg) -{ - return set_get_font (arg,0,video_mode_512ch); -} - -/* - * Adjust the screen to fit a font of a certain height - * - * Returns < 0 for error, 0 if nothing changed, and the number - * of lines on the adjusted console if changed. - */ -int con_adjust_height(unsigned long fontheight) -{ - return -EINVAL; -} - -void set_vesa_blanking(int arg) -{ - char *argp = (char *)arg + 1; - unsigned int mode; - get_user(mode, argp); - vesa_blank_mode = (mode < 4) ? mode : 0; -} - -unsigned long get_video_num_lines(unsigned int currcons) -{ - return(rows); -} - -unsigned long get_video_num_columns(unsigned int currcons) -{ - return(cols); -} - -unsigned long get_video_size_row(unsigned int currcons) -{ - return(size_row); -} --- linux-2.1.29/arch/m68k/console/fbcon.c.orig Thu Mar 20 20:53:43 1997 +++ linux-2.1.29/arch/m68k/console/fbcon.c Thu Mar 20 21:44:52 1997 @@ -287,6 +287,13 @@ static __inline__ u_short dup2w(u_char c); static __inline__ int real_y(struct display *p, int y); static void fbcon_vbl_handler(int irq, void *dummy, struct pt_regs *fp); +static __inline__ void updatescrollmode(struct display *p); +static __inline__ void ywrap_up(int unit, struct display *p, int count); +static __inline__ void ywrap_down(int unit, struct display *p, int count); +static __inline__ void ypan_up(int unit, struct vc_data *conp, + struct display *p, int count); +static __inline__ void ypan_down(int unit, struct vc_data *conp, + struct display *p, int count); static void fbcon_bmove_rec(struct display *p, int sy, int sx, int dy, int dx, int height, int width, u_int y_break); @@ -622,14 +629,7 @@ printk("fbcon_setup: No support for fontwidth != 8"); p->fontwidth = 8; } - - if (divides(p->ywrapstep, p->fontheight) && divides(p->fontheight, p->var.yres_virtual)) - p->scrollmode = SCROLL_YWRAP; - else if (divides(p->ypanstep, p->fontheight) && - p->var.yres_virtual >= p->var.yres+p->fontheight) - p->scrollmode = SCROLL_YPAN; - else - p->scrollmode = SCROLL_YMOVE; + updatescrollmode(p); nr_cols = p->var.xres/p->fontwidth; nr_rows = p->var.yres/p->fontheight; @@ -1566,6 +1566,75 @@ } +static __inline__ void updatescrollmode(struct display *p) +{ + if (divides(p->ywrapstep, p->fontheight) && + divides(p->fontheight, p->var.yres_virtual)) + p->scrollmode = SCROLL_YWRAP; + else if (divides(p->ypanstep, p->fontheight) && + p->var.yres_virtual >= p->var.yres+p->fontheight) + p->scrollmode = SCROLL_YPAN; + else + p->scrollmode = SCROLL_YMOVE; +} + + +static __inline__ void ywrap_up(int unit, struct display *p, int count) +{ + p->yscroll += count; + if (p->yscroll >= p->vrows) /* Deal with wrap */ + p->yscroll -= p->vrows; + p->var.xoffset = 0; + p->var.yoffset = p->yscroll*p->fontheight; + p->var.vmode |= FB_VMODE_YWRAP; + fb_info->updatevar(unit); +} + + +static __inline__ void ywrap_down(int unit, struct display *p, int count) +{ + p->yscroll -= count; + if (p->yscroll < 0) /* Deal with wrap */ + p->yscroll += p->vrows; + p->var.xoffset = 0; + p->var.yoffset = p->yscroll*p->fontheight; + p->var.vmode |= FB_VMODE_YWRAP; + fb_info->updatevar(unit); +} + + +static __inline__ void ypan_up(int unit, struct vc_data *conp, + struct display *p, int count) +{ + p->yscroll += count; + if (p->yscroll+conp->vc_rows > p->vrows) { + p->dispsw->bmove(p, p->yscroll, 0, 0, 0, conp->vc_rows-count, + conp->vc_cols); + p->yscroll = 0; + } + p->var.xoffset = 0; + p->var.yoffset = p->yscroll*p->fontheight; + p->var.vmode &= ~FB_VMODE_YWRAP; + fb_info->updatevar(unit); +} + + +static __inline__ void ypan_down(int unit, struct vc_data *conp, + struct display *p, int count) +{ + p->yscroll -= count; + if (p->yscroll < 0) { + p->yscroll = p->vrows-conp->vc_rows; + p->dispsw->bmove(p, 0, 0, p->yscroll+count, 0, conp->vc_rows-count, + conp->vc_cols); + } + p->var.xoffset = 0; + p->var.yoffset = p->yscroll*p->fontheight; + p->var.vmode &= ~FB_VMODE_YWRAP; + fb_info->updatevar(unit); +} + + static int fbcon_scroll(struct vc_data *conp, int t, int b, int dir, int count) { int unit = conp->vc_num; @@ -1582,84 +1651,98 @@ switch (dir) { case SM_UP: - if (t == 0 && b == conp->vc_rows && - vt_cons[unit]->vc_mode == KD_TEXT) { - if (count > conp->vc_rows) /* Maximum realistic size */ - count = conp->vc_rows; - switch (p->scrollmode) { - case SCROLL_YWRAP: - p->yscroll += count; - if (p->yscroll >= p->vrows) /* Deal with wrap */ - p->yscroll -= p->vrows; - p->var.xoffset = 0; - p->var.yoffset = p->yscroll*p->fontheight; - p->var.vmode |= FB_VMODE_YWRAP; - fb_info->updatevar(unit); - break; - - case SCROLL_YPAN: - p->yscroll += count; - if (p->yscroll+conp->vc_rows > p->vrows) { - p->dispsw->bmove(p, p->yscroll, 0, 0, 0, b-count, - conp->vc_cols); - p->yscroll = 0; - } - p->var.xoffset = 0; - p->var.yoffset = p->yscroll*p->fontheight; - p->var.vmode &= ~FB_VMODE_YWRAP; - fb_info->updatevar(unit); - break; - - case SCROLL_YMOVE: - p->dispsw->bmove(p, count, 0, 0, 0, b-count, conp->vc_cols); - break; - } - } else - fbcon_bmove(conp, t+count, 0, t, 0, b-t-count, conp->vc_cols); - fbcon_clear(conp, b-count, 0, count, conp->vc_cols); + if (count > conp->vc_rows) /* Maximum realistic size */ + count = conp->vc_rows; + if (vt_cons[unit]->vc_mode == KD_TEXT) + switch (p->scrollmode) { + case SCROLL_YWRAP: + if (b-t-count > 3*conp->vc_rows>>2) { + if (t > 0) + fbcon_bmove(conp, 0, 0, count, 0, t, conp->vc_cols); + ywrap_up(unit, p, count); + if (conp->vc_rows-b > 0) + fbcon_bmove(conp, b-count, 0, b, 0, conp->vc_rows-b, + conp->vc_cols); + } else + fbcon_bmove(conp, t+count, 0, t, 0, b-t-count, + conp->vc_cols); + fbcon_clear(conp, b-count, 0, count, conp->vc_cols); + break; + + case SCROLL_YPAN: + if (b-t-count > 3*conp->vc_rows>>2) { + if (t > 0) + fbcon_bmove(conp, 0, 0, count, 0, t, conp->vc_cols); + ypan_up(unit, conp, p, count); + if (conp->vc_rows-b > 0) + fbcon_bmove(conp, b-count, 0, b, 0, conp->vc_rows-b, + conp->vc_cols); + } else + fbcon_bmove(conp, t+count, 0, t, 0, b-t-count, + conp->vc_cols); + fbcon_clear(conp, b-count, 0, count, conp->vc_cols); + break; + + case SCROLL_YMOVE: + p->dispsw->bmove(p, t+count, 0, t, 0, b-t-count, + conp->vc_cols); + p->dispsw->clear(conp, p, b-count, 0, count, conp->vc_cols); + break; + } + else { + fbcon_bmove(conp, t+count, 0, t, 0, b-t-count, conp->vc_cols); + fbcon_clear(conp, b-count, 0, count, conp->vc_cols); + } break; case SM_DOWN: - if (t == 0 && b == conp->vc_rows && - vt_cons[unit]->vc_mode == KD_TEXT) { - if (count > conp->vc_rows) /* Maximum realistic size */ - count = conp->vc_rows; - switch (p->scrollmode) { - case SCROLL_YWRAP: - p->yscroll -= count; - if (p->yscroll < 0) /* Deal with wrap */ - p->yscroll += p->vrows; - p->var.xoffset = 0; - p->var.yoffset = p->yscroll*p->fontheight; - p->var.vmode |= FB_VMODE_YWRAP; - fb_info->updatevar(unit); - break; - - case SCROLL_YPAN: - p->yscroll -= count; - if (p->yscroll < 0) { - p->yscroll = p->vrows-conp->vc_rows; - p->dispsw->bmove(p, 0, 0, p->yscroll+count, 0, b-count, - conp->vc_cols); - } - p->var.xoffset = 0; - p->var.yoffset = p->yscroll*p->fontheight; - p->var.vmode &= ~FB_VMODE_YWRAP; - fb_info->updatevar(unit); - break; - - case SCROLL_YMOVE: - p->dispsw->bmove(p, 0, 0, count, 0, b-count, conp->vc_cols); - break; - } - } else - fbcon_bmove(conp, t, 0, t+count, 0, b-t-count, conp->vc_cols); - - /* Fixed bmove() should end Arno's frustration with copying? - * Confucius says: - * Man who copies in wrong direction, end up with trashed data - */ - fbcon_clear(conp, t, 0, count, conp->vc_cols); + if (count > conp->vc_rows) /* Maximum realistic size */ + count = conp->vc_rows; + if (vt_cons[unit]->vc_mode == KD_TEXT) + switch (p->scrollmode) { + case SCROLL_YWRAP: + if (b-t-count > 3*conp->vc_rows>>2) { + if (t > 0) + fbcon_bmove(conp, b, 0, b-count, 0, conp->vc_rows-b, + conp->vc_cols); + ywrap_down(unit, p, count); + if (conp->vc_rows-b > 0) + fbcon_bmove(conp, count, 0, 0, 0, t, conp->vc_cols); + } else + fbcon_bmove(conp, t, 0, t+count, 0, b-t-count, + conp->vc_cols); + fbcon_clear(conp, t, 0, count, conp->vc_cols); + break; + + case SCROLL_YPAN: + if (b-t-count > 3*conp->vc_rows>>2) { + if (t > 0) + fbcon_bmove(conp, b, 0, b-count, 0, conp->vc_rows-b, + conp->vc_cols); + ypan_down(unit, conp, p, count); + if (conp->vc_rows-b > 0) + fbcon_bmove(conp, count, 0, 0, 0, t, conp->vc_cols); + } else + fbcon_bmove(conp, t, 0, t+count, 0, b-t-count, + conp->vc_cols); + fbcon_clear(conp, t, 0, count, conp->vc_cols); + break; + + case SCROLL_YMOVE: + p->dispsw->bmove(p, t, 0, t+count, 0, b-t-count, + conp->vc_cols); + p->dispsw->clear(conp, p, t, 0, count, conp->vc_cols); + break; + } + else { + /* + * Fixed bmove() should end Arno's frustration with copying? + * Confucius says: + * Man who copies in wrong direction, end up with trashed data + */ + fbcon_bmove(conp, t, 0, t+count, 0, b-t-count, conp->vc_cols); + fbcon_clear(conp, t, 0, count, conp->vc_cols); + } break; case SM_LEFT: @@ -1878,14 +1961,7 @@ /* Adjust the virtual screen-size to fontheight*rows */ p->var.yres_virtual = (p->var.yres/h)*h; p->vrows = p->var.yres_virtual/h; - if (divides(p->ywrapstep, p->fontheight)) - p->scrollmode = SCROLL_YWRAP; - else if (divides(p->ypanstep, p->fontheight) && - p->var.yres_virtual >= p->var.yres+p->fontheight) - p->scrollmode = SCROLL_YPAN; - else - p->scrollmode = SCROLL_YMOVE; - + updatescrollmode(p); vc_resize_con( p->var.yres/h, p->var.xres/w, unit ); } else if (unit == fg_console) Greetings, Geert -- Geert Uytterhoeven Geert.Uytterhoeven@cs.kuleuven.ac.be Wavelets, Linux/m68k on Amiga http://www.cs.kuleuven.ac.be/~geert/ Department of Computer Science -- Katholieke Universiteit Leuven -- Belgium