URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [video/] [console/] [promcon.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/* $Id: promcon.c,v 1.17 2000/07/26 23:02:52 davem Exp $
 * Console driver utilizing PROM sun terminal emulation
 *
 * Copyright (C) 1998  Eddie C. Dost  (ecd@skynet.be)
 * Copyright (C) 1998  Jakub Jelinek  (jj@ultra.linux.cz)
 */
 
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/console.h>
#include <linux/vt_kern.h>
#include <linux/selection.h>
#include <linux/fb.h>
#include <linux/init.h>
#include <linux/kd.h>
 
#include <asm/oplib.h>
#include <asm/uaccess.h>
 
static short pw = 80 - 1, ph = 34 - 1;
static short px, py;
static unsigned long promcon_uni_pagedir[2];
 
extern u8 promfont_unicount[];
extern u16 promfont_unitable[];
 
#define PROMCON_COLOR 0
 
#if PROMCON_COLOR
#define inverted(s)     ((((s) & 0x7700) == 0x0700) ? 0 : 1)
#else
#define inverted(s)     (((s) & 0x0800) ? 1 : 0)
#endif
 
static __inline__ void
promcon_puts(char *buf, int cnt)
{
        prom_printf("%*.*s", cnt, cnt, buf);
}
 
static int
promcon_start(struct vc_data *conp, char *b)
{
        unsigned short *s = (unsigned short *)
                        (conp->vc_origin + py * conp->vc_size_row + (px << 1));
        u16 cs;
 
        cs = scr_readw(s);
        if (px == pw) {
                unsigned short *t = s - 1;
                u16 ct = scr_readw(t);
 
                if (inverted(cs) && inverted(ct))
                        return sprintf(b, "\b\033[7m%c\b\033[@%c\033[m", cs,
                                       ct);
                else if (inverted(cs))
                        return sprintf(b, "\b\033[7m%c\033[m\b\033[@%c", cs,
                                       ct);
                else if (inverted(ct))
                        return sprintf(b, "\b%c\b\033[@\033[7m%c\033[m", cs,
                                       ct);
                else
                        return sprintf(b, "\b%c\b\033[@%c", cs, ct);
        }
 
        if (inverted(cs))
                return sprintf(b, "\033[7m%c\033[m\b", cs);
        else
                return sprintf(b, "%c\b", cs);
}
 
static int
promcon_end(struct vc_data *conp, char *b)
{
        unsigned short *s = (unsigned short *)
                        (conp->vc_origin + py * conp->vc_size_row + (px << 1));
        char *p = b;
        u16 cs;
 
        b += sprintf(b, "\033[%d;%dH", py + 1, px + 1);
 
        cs = scr_readw(s);
        if (px == pw) {
                unsigned short *t = s - 1;
                u16 ct = scr_readw(t);
 
                if (inverted(cs) && inverted(ct))
                        b += sprintf(b, "\b%c\b\033[@\033[7m%c\033[m", cs, ct);
                else if (inverted(cs))
                        b += sprintf(b, "\b%c\b\033[@%c", cs, ct);
                else if (inverted(ct))
                        b += sprintf(b, "\b\033[7m%c\b\033[@%c\033[m", cs, ct);
                else
                        b += sprintf(b, "\b\033[7m%c\033[m\b\033[@%c", cs, ct);
                return b - p;
        }
 
        if (inverted(cs))
                b += sprintf(b, "%c\b", cs);
        else
                b += sprintf(b, "\033[7m%c\033[m\b", cs);
        return b - p;
}
 
const char *promcon_startup(void)
{
        const char *display_desc = "PROM";
        int node;
        char buf[40];
 
        node = prom_getchild(prom_root_node);
        node = prom_searchsiblings(node, "options");
        if (prom_getproperty(node,  "screen-#columns", buf, 40) != -1) {
                pw = simple_strtoul(buf, NULL, 0);
                if (pw < 10 || pw > 256)
                        pw = 80;
                pw--;
        }
        if (prom_getproperty(node,  "screen-#rows", buf, 40) != -1) {
                ph = simple_strtoul(buf, NULL, 0);
                if (ph < 10 || ph > 256)
                        ph = 34;
                ph--;
        }
        promcon_puts("\033[H\033[J", 6);
        return display_desc;
}
 
static void
promcon_init_unimap(struct vc_data *conp)
{
        mm_segment_t old_fs = get_fs();
        struct unipair *p, *p1;
        u16 *q;
        int i, j, k;
 
        p = kmalloc(256*sizeof(struct unipair), GFP_KERNEL);
        if (!p) return;
 
        q = promfont_unitable;
        p1 = p;
        k = 0;
        for (i = 0; i < 256; i++)
                for (j = promfont_unicount[i]; j; j--) {
                        p1->unicode = *q++;
                        p1->fontpos = i;
                        p1++;
                        k++;
                }
        set_fs(KERNEL_DS);
        con_clear_unimap(conp, NULL);
        con_set_unimap(conp, k, p);
        con_protect_unimap(conp, 1);
        set_fs(old_fs);
        kfree(p);
}
 
static void
promcon_init(struct vc_data *conp, int init)
{
        unsigned long p;
 
        conp->vc_can_do_color = PROMCON_COLOR;
        if (init) {
                conp->vc_cols = pw + 1;
                conp->vc_rows = ph + 1;
        }
        p = *conp->vc_uni_pagedir_loc;
        if (conp->vc_uni_pagedir_loc == &conp->vc_uni_pagedir ||
            !--conp->vc_uni_pagedir_loc[1])
                con_free_unimap(conp);
        conp->vc_uni_pagedir_loc = promcon_uni_pagedir;
        promcon_uni_pagedir[1]++;
        if (!promcon_uni_pagedir[0] && p) {
                promcon_init_unimap(conp);
        }
        if (!init) {
                if (conp->vc_cols != pw + 1 || conp->vc_rows != ph + 1)
                        vc_resize(conp, pw + 1, ph + 1);
        }
}
 
static void
promcon_deinit(struct vc_data *conp)
{
        /* When closing the last console, reset video origin */
        if (!--promcon_uni_pagedir[1])
                con_free_unimap(conp);
        conp->vc_uni_pagedir_loc = &conp->vc_uni_pagedir;
        con_set_default_unimap(conp);
}
 
static int
promcon_switch(struct vc_data *conp)
{
        return 1;
}
 
static unsigned short *
promcon_repaint_line(unsigned short *s, unsigned char *buf, unsigned char **bp)
{
        int cnt = pw + 1;
        int attr = -1;
        unsigned char *b = *bp;
 
        while (cnt--) {
                u16 c = scr_readw(s);
                if (attr != inverted(c)) {
                        attr = inverted(c);
                        if (attr) {
                                strcpy (b, "\033[7m");
                                b += 4;
                        } else {
                                strcpy (b, "\033[m");
                                b += 3;
                        }
                }
                *b++ = c;
                s++;
                if (b - buf >= 224) {
                        promcon_puts(buf, b - buf);
                        b = buf;
                }
        }
        *bp = b;
        return s;
}
 
static void
promcon_putcs(struct vc_data *conp, const unsigned short *s,
              int count, int y, int x)
{
        unsigned char buf[256], *b = buf;
        unsigned short attr = scr_readw(s);
        unsigned char save;
        int i, last = 0;
 
        if (console_blanked)
                return;
 
        if (count <= 0)
                return;
 
        b += promcon_start(conp, b);
 
        if (x + count >= pw + 1) {
                if (count == 1) {
                        x -= 1;
                        save = scr_readw((unsigned short *)(conp->vc_origin
                                                   + y * conp->vc_size_row
                                                   + (x << 1)));
 
                        if (px != x || py != y) {
                                b += sprintf(b, "\033[%d;%dH", y + 1, x + 1);
                                px = x;
                                py = y;
                        }
 
                        if (inverted(attr))
                                b += sprintf(b, "\033[7m%c\033[m", scr_readw(s++));
                        else
                                b += sprintf(b, "%c", scr_readw(s++));
 
                        strcpy(b, "\b\033[@");
                        b += 4;
 
                        if (inverted(save))
                                b += sprintf(b, "\033[7m%c\033[m", save);
                        else
                                b += sprintf(b, "%c", save);
 
                        px++;
 
                        b += promcon_end(conp, b);
                        promcon_puts(buf, b - buf);
                        return;
                } else {
                        last = 1;
                        count = pw - x - 1;
                }
        }
 
        if (inverted(attr)) {
                strcpy(b, "\033[7m");
                b += 4;
        }
 
        if (px != x || py != y) {
                b += sprintf(b, "\033[%d;%dH", y + 1, x + 1);
                px = x;
                py = y;
        }
 
        for (i = 0; i < count; i++) {
                if (b - buf >= 224) {
                        promcon_puts(buf, b - buf);
                        b = buf;
                }
                *b++ = scr_readw(s++);
        }
 
        px += count;
 
        if (last) {
                save = scr_readw(s++);
                b += sprintf(b, "%c\b\033[@%c", scr_readw(s++), save);
                px++;
        }
 
        if (inverted(attr)) {
                strcpy(b, "\033[m");
                b += 3;
        }
 
        b += promcon_end(conp, b);
        promcon_puts(buf, b - buf);
}
 
static void
promcon_putc(struct vc_data *conp, int c, int y, int x)
{
        unsigned short s;
 
        if (console_blanked)
                return;
 
        scr_writew(c, &s);
        promcon_putcs(conp, &s, 1, y, x);
}
 
static void
promcon_clear(struct vc_data *conp, int sy, int sx, int height, int width)
{
        unsigned char buf[256], *b = buf;
        int i, j;
 
        if (console_blanked)
                return;
 
        b += promcon_start(conp, b);
 
        if (!sx && width == pw + 1) {
 
                if (!sy && height == ph + 1) {
                        strcpy(b, "\033[H\033[J");
                        b += 6;
                        b += promcon_end(conp, b);
                        promcon_puts(buf, b - buf);
                        return;
                } else if (sy + height == ph + 1) {
                        b += sprintf(b, "\033[%dH\033[J", sy + 1);
                        b += promcon_end(conp, b);
                        promcon_puts(buf, b - buf);
                        return;
                }
 
                b += sprintf(b, "\033[%dH", sy + 1);
                for (i = 1; i < height; i++) {
                        strcpy(b, "\033[K\n");
                        b += 4;
                }
 
                strcpy(b, "\033[K");
                b += 3;
 
                b += promcon_end(conp, b);
                promcon_puts(buf, b - buf);
                return;
 
        } else if (sx + width == pw + 1) {
 
                b += sprintf(b, "\033[%d;%dH", sy + 1, sx + 1);
                for (i = 1; i < height; i++) {
                        strcpy(b, "\033[K\n");
                        b += 4;
                }
 
                strcpy(b, "\033[K");
                b += 3;
 
                b += promcon_end(conp, b);
                promcon_puts(buf, b - buf);
                return;
        }
 
        for (i = sy + 1; i <= sy + height; i++) {
                b += sprintf(b, "\033[%d;%dH", i, sx + 1);
                for (j = 0; j < width; j++)
                        *b++ = ' ';
                if (b - buf + width >= 224) {
                        promcon_puts(buf, b - buf);
                        b = buf;
                }
        }
 
        b += promcon_end(conp, b);
        promcon_puts(buf, b - buf);
}
 
static void
promcon_bmove(struct vc_data *conp, int sy, int sx, int dy, int dx,
              int height, int width)
{
        char buf[256], *b = buf;
 
        if (console_blanked)
                return;
 
        b += promcon_start(conp, b);
        if (sy == dy && height == 1) {
                if (dx > sx && dx + width == conp->vc_cols)
                        b += sprintf(b, "\033[%d;%dH\033[%d@\033[%d;%dH",
                                     sy + 1, sx + 1, dx - sx, py + 1, px + 1);
                else if (dx < sx && sx + width == conp->vc_cols)
                        b += sprintf(b, "\033[%d;%dH\033[%dP\033[%d;%dH",
                                     dy + 1, dx + 1, sx - dx, py + 1, px + 1);
 
                b += promcon_end(conp, b);
                promcon_puts(buf, b - buf);
                return;
        }
 
        /*
         * FIXME: What to do here???
         * Current console.c should not call it like that ever.
         */
        prom_printf("\033[7mFIXME: bmove not handled\033[m\n");
}
 
static void
promcon_cursor(struct vc_data *conp, int mode)
{
        char buf[32], *b = buf;
 
        switch (mode) {
        case CM_ERASE:
                break;
 
        case CM_MOVE:
        case CM_DRAW:
                b += promcon_start(conp, b);
                if (px != conp->vc_x || py != conp->vc_y) {
                        px = conp->vc_x;
                        py = conp->vc_y;
                        b += sprintf(b, "\033[%d;%dH", py + 1, px + 1);
                }
                promcon_puts(buf, b - buf);
                break;
        }
}
 
static int
promcon_blank(struct vc_data *conp, int blank, int mode_switch)
{
        if (blank) {
                promcon_puts("\033[H\033[J\033[7m \033[m\b", 15);
                return 0;
        } else {
                /* Let console.c redraw */
                return 1;
        }
}
 
static int
promcon_scroll(struct vc_data *conp, int t, int b, int dir, int count)
{
        unsigned char buf[256], *p = buf;
        unsigned short *s;
        int i;
 
        if (console_blanked)
                return 0;
 
        p += promcon_start(conp, p);
 
        switch (dir) {
        case SM_UP:
                if (b == ph + 1) {
                        p += sprintf(p, "\033[%dH\033[%dM", t + 1, count);
                        px = 0;
                        py = t;
                        p += promcon_end(conp, p);
                        promcon_puts(buf, p - buf);
                        break;
                }
 
                s = (unsigned short *)(conp->vc_origin
                                       + (t + count) * conp->vc_size_row);
 
                p += sprintf(p, "\033[%dH", t + 1);
 
                for (i = t; i < b - count; i++)
                        s = promcon_repaint_line(s, buf, &p);
 
                for (; i < b - 1; i++) {
                        strcpy(p, "\033[K\n");
                        p += 4;
                        if (p - buf >= 224) {
                                promcon_puts(buf, p - buf);
                                p = buf;
                        }
                }
 
                strcpy(p, "\033[K");
                p += 3;
 
                p += promcon_end(conp, p);
                promcon_puts(buf, p - buf);
                break;
 
        case SM_DOWN:
                if (b == ph + 1) {
                        p += sprintf(p, "\033[%dH\033[%dL", t + 1, count);
                        px = 0;
                        py = t;
                        p += promcon_end(conp, p);
                        promcon_puts(buf, p - buf);
                        break;
                }
 
                s = (unsigned short *)(conp->vc_origin + t * conp->vc_size_row);
 
                p += sprintf(p, "\033[%dH", t + 1);
 
                for (i = t; i < t + count; i++) {
                        strcpy(p, "\033[K\n");
                        p += 4;
                        if (p - buf >= 224) {
                                promcon_puts(buf, p - buf);
                                p = buf;
                        }
                }
 
                for (; i < b; i++)
                        s = promcon_repaint_line(s, buf, &p);
 
                p += promcon_end(conp, p);
                promcon_puts(buf, p - buf);
                break;
        }
 
        return 0;
}
 
#if !(PROMCON_COLOR)
static u8 promcon_build_attr(struct vc_data *conp, u8 _color, u8 _intensity,
    u8 _blink, u8 _underline, u8 _reverse, u8 _italic)
{
        return (_reverse) ? 0xf : 0x7;
}
#endif
 
/*
 *  The console 'switch' structure for the VGA based console
 */
 
static int promcon_dummy(void)
{
        return 0;
}
 
#define DUMMY (void *) promcon_dummy
 
const struct consw prom_con = {
        .owner =                THIS_MODULE,
        .con_startup =          promcon_startup,
        .con_init =             promcon_init,
        .con_deinit =           promcon_deinit,
        .con_clear =            promcon_clear,
        .con_putc =             promcon_putc,
        .con_putcs =            promcon_putcs,
        .con_cursor =           promcon_cursor,
        .con_scroll =           promcon_scroll,
        .con_bmove =            promcon_bmove,
        .con_switch =           promcon_switch,
        .con_blank =            promcon_blank,
        .con_set_palette =      DUMMY,
        .con_scrolldelta =      DUMMY,
#if !(PROMCON_COLOR)
        .con_build_attr =       promcon_build_attr,
#endif
};
 
void __init prom_con_init(void)
{
#ifdef CONFIG_DUMMY_CONSOLE
        if (conswitchp == &dummy_con)
                take_over_console(&prom_con, 0, MAX_NR_CONSOLES-1, 1);
        else
#endif
        if (conswitchp == &prom_con)
                promcon_init_unimap(vc_cons[fg_console].d);
}

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [video/] [console/] [promcon.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/* $Id: promcon.c,v 1.17 2000/07/26 23:02:52 davem Exp $`
2			`* Console driver utilizing PROM sun terminal emulation`
3			`*`
4			`* Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be)`
5			`* Copyright (C) 1998 Jakub Jelinek (jj@ultra.linux.cz)`
6			`*/`
7
8			`#include <linux/module.h>`
9			`#include <linux/kernel.h>`
10			`#include <linux/errno.h>`
11			`#include <linux/string.h>`
12			`#include <linux/mm.h>`
13			`#include <linux/slab.h>`
14			`#include <linux/delay.h>`
15			`#include <linux/console.h>`
16			`#include <linux/vt_kern.h>`
17			`#include <linux/selection.h>`
18			`#include <linux/fb.h>`
19			`#include <linux/init.h>`
20			`#include <linux/kd.h>`
21
22			`#include <asm/oplib.h>`
23			`#include <asm/uaccess.h>`
24
25			`static short pw = 80 - 1, ph = 34 - 1;`
26			`static short px, py;`
27			`static unsigned long promcon_uni_pagedir[2];`
28
29			`extern u8 promfont_unicount[];`
30			`extern u16 promfont_unitable[];`
31
32			`#define PROMCON_COLOR 0`
33
34			`#if PROMCON_COLOR`
35			`#define inverted(s) ((((s) & 0x7700) == 0x0700) ? 0 : 1)`
36			`#else`
37			`#define inverted(s) (((s) & 0x0800) ? 1 : 0)`
38			`#endif`
39
40			`static __inline__ void`
41			`promcon_puts(char *buf, int cnt)`
42			`{`
43			`prom_printf("%.s", cnt, cnt, buf);`
44			`}`
45
46			`static int`
47			`promcon_start(struct vc_data conp, char b)`
48			`{`
49			`unsigned short s = (unsigned short )`
50			`(conp->vc_origin + py * conp->vc_size_row + (px << 1));`
51			`u16 cs;`
52
53			`cs = scr_readw(s);`
54			`if (px == pw) {`
55			`unsigned short *t = s - 1;`
56			`u16 ct = scr_readw(t);`
57
58			`if (inverted(cs) && inverted(ct))`
59			`return sprintf(b, "\b\033[7m%c\b\033[@%c\033[m", cs,`
60			`ct);`
61			`else if (inverted(cs))`
62			`return sprintf(b, "\b\033[7m%c\033[m\b\033[@%c", cs,`
63			`ct);`
64			`else if (inverted(ct))`
65			`return sprintf(b, "\b%c\b\033[@\033[7m%c\033[m", cs,`
66			`ct);`
67			`else`
68			`return sprintf(b, "\b%c\b\033[@%c", cs, ct);`
69			`}`
70
71			`if (inverted(cs))`
72			`return sprintf(b, "\033[7m%c\033[m\b", cs);`
73			`else`
74			`return sprintf(b, "%c\b", cs);`
75			`}`
76
77			`static int`
78			`promcon_end(struct vc_data conp, char b)`
79			`{`
80			`unsigned short s = (unsigned short )`
81			`(conp->vc_origin + py * conp->vc_size_row + (px << 1));`
82			`char *p = b;`
83			`u16 cs;`
84
85			`b += sprintf(b, "\033[%d;%dH", py + 1, px + 1);`
86
87			`cs = scr_readw(s);`
88			`if (px == pw) {`
89			`unsigned short *t = s - 1;`
90			`u16 ct = scr_readw(t);`
91
92			`if (inverted(cs) && inverted(ct))`
93			`b += sprintf(b, "\b%c\b\033[@\033[7m%c\033[m", cs, ct);`
94			`else if (inverted(cs))`
95			`b += sprintf(b, "\b%c\b\033[@%c", cs, ct);`
96			`else if (inverted(ct))`
97			`b += sprintf(b, "\b\033[7m%c\b\033[@%c\033[m", cs, ct);`
98			`else`
99			`b += sprintf(b, "\b\033[7m%c\033[m\b\033[@%c", cs, ct);`
100			`return b - p;`
101			`}`
102
103			`if (inverted(cs))`
104			`b += sprintf(b, "%c\b", cs);`
105			`else`
106			`b += sprintf(b, "\033[7m%c\033[m\b", cs);`
107			`return b - p;`
108			`}`
109
110			`const char *promcon_startup(void)`
111			`{`
112			`const char *display_desc = "PROM";`
113			`int node;`
114			`char buf[40];`
115
116			`node = prom_getchild(prom_root_node);`
117			`node = prom_searchsiblings(node, "options");`
118			`if (prom_getproperty(node, "screen-#columns", buf, 40) != -1) {`
119			`pw = simple_strtoul(buf, NULL, 0);`
120			`if (pw < 10 \|\| pw > 256)`
121			`pw = 80;`
122			`pw--;`
123			`}`
124			`if (prom_getproperty(node, "screen-#rows", buf, 40) != -1) {`
125			`ph = simple_strtoul(buf, NULL, 0);`
126			`if (ph < 10 \|\| ph > 256)`
127			`ph = 34;`
128			`ph--;`
129			`}`
130			`promcon_puts("\033[H\033[J", 6);`
131			`return display_desc;`
132			`}`
133
134			`static void`
135			`promcon_init_unimap(struct vc_data *conp)`
136			`{`
137			`mm_segment_t old_fs = get_fs();`
138			`struct unipair p, p1;`
139			`u16 *q;`
140			`int i, j, k;`
141
142			`p = kmalloc(256*sizeof(struct unipair), GFP_KERNEL);`
143			`if (!p) return;`
144
145			`q = promfont_unitable;`
146			`p1 = p;`
147			`k = 0;`
148			`for (i = 0; i < 256; i++)`
149			`for (j = promfont_unicount[i]; j; j--) {`
150			`p1->unicode = *q++;`
151			`p1->fontpos = i;`
152			`p1++;`
153			`k++;`
154			`}`
155			`set_fs(KERNEL_DS);`
156			`con_clear_unimap(conp, NULL);`
157			`con_set_unimap(conp, k, p);`
158			`con_protect_unimap(conp, 1);`
159			`set_fs(old_fs);`
160			`kfree(p);`
161			`}`
162
163			`static void`
164			`promcon_init(struct vc_data *conp, int init)`
165			`{`
166			`unsigned long p;`
167
168			`conp->vc_can_do_color = PROMCON_COLOR;`
169			`if (init) {`
170			`conp->vc_cols = pw + 1;`
171			`conp->vc_rows = ph + 1;`
172			`}`
173			`p = *conp->vc_uni_pagedir_loc;`
174			`if (conp->vc_uni_pagedir_loc == &conp->vc_uni_pagedir \|\|`
175			`!--conp->vc_uni_pagedir_loc[1])`
176			`con_free_unimap(conp);`
177			`conp->vc_uni_pagedir_loc = promcon_uni_pagedir;`
178			`promcon_uni_pagedir[1]++;`
179			`if (!promcon_uni_pagedir[0] && p) {`
180			`promcon_init_unimap(conp);`
181			`}`
182			`if (!init) {`
183			`if (conp->vc_cols != pw + 1 \|\| conp->vc_rows != ph + 1)`
184			`vc_resize(conp, pw + 1, ph + 1);`
185			`}`
186			`}`
187
188			`static void`
189			`promcon_deinit(struct vc_data *conp)`
190			`{`
191			`/* When closing the last console, reset video origin */`
192			`if (!--promcon_uni_pagedir[1])`
193			`con_free_unimap(conp);`
194			`conp->vc_uni_pagedir_loc = &conp->vc_uni_pagedir;`
195			`con_set_default_unimap(conp);`
196			`}`
197
198			`static int`
199			`promcon_switch(struct vc_data *conp)`
200			`{`
201			`return 1;`
202			`}`
203
204			`static unsigned short *`
205			`promcon_repaint_line(unsigned short s, unsigned char buf, unsigned char **bp)`
206			`{`
207			`int cnt = pw + 1;`
208			`int attr = -1;`
209			`unsigned char b = bp;`
210
211			`while (cnt--) {`
212			`u16 c = scr_readw(s);`
213			`if (attr != inverted(c)) {`
214			`attr = inverted(c);`
215			`if (attr) {`
216			`strcpy (b, "\033[7m");`
217			`b += 4;`
218			`} else {`
219			`strcpy (b, "\033[m");`
220			`b += 3;`
221			`}`
222			`}`
223			`*b++ = c;`
224			`s++;`
225			`if (b - buf >= 224) {`
226			`promcon_puts(buf, b - buf);`
227			`b = buf;`
228			`}`
229			`}`
230			`*bp = b;`
231			`return s;`
232			`}`
233
234			`static void`
235			`promcon_putcs(struct vc_data conp, const unsigned short s,`
236			`int count, int y, int x)`
237			`{`
238			`unsigned char buf[256], *b = buf;`
239			`unsigned short attr = scr_readw(s);`
240			`unsigned char save;`
241			`int i, last = 0;`
242
243			`if (console_blanked)`
244			`return;`
245
246			`if (count <= 0)`
247			`return;`
248
249			`b += promcon_start(conp, b);`
250
251			`if (x + count >= pw + 1) {`
252			`if (count == 1) {`
253			`x -= 1;`
254			`save = scr_readw((unsigned short *)(conp->vc_origin`
255			`+ y * conp->vc_size_row`
256			`+ (x << 1)));`
257
258			`if (px != x \|\| py != y) {`
259			`b += sprintf(b, "\033[%d;%dH", y + 1, x + 1);`
260			`px = x;`
261			`py = y;`
262			`}`
263
264			`if (inverted(attr))`
265			`b += sprintf(b, "\033[7m%c\033[m", scr_readw(s++));`
266			`else`
267			`b += sprintf(b, "%c", scr_readw(s++));`
268
269			`strcpy(b, "\b\033[@");`
270			`b += 4;`
271
272			`if (inverted(save))`
273			`b += sprintf(b, "\033[7m%c\033[m", save);`
274			`else`
275			`b += sprintf(b, "%c", save);`
276
277			`px++;`
278
279			`b += promcon_end(conp, b);`
280			`promcon_puts(buf, b - buf);`
281			`return;`
282			`} else {`
283			`last = 1;`
284			`count = pw - x - 1;`
285			`}`
286			`}`
287
288			`if (inverted(attr)) {`
289			`strcpy(b, "\033[7m");`
290			`b += 4;`
291			`}`
292
293			`if (px != x \|\| py != y) {`
294			`b += sprintf(b, "\033[%d;%dH", y + 1, x + 1);`
295			`px = x;`
296			`py = y;`
297			`}`
298
299			`for (i = 0; i < count; i++) {`
300			`if (b - buf >= 224) {`
301			`promcon_puts(buf, b - buf);`
302			`b = buf;`
303			`}`
304			`*b++ = scr_readw(s++);`
305			`}`
306
307			`px += count;`
308
309			`if (last) {`
310			`save = scr_readw(s++);`
311			`b += sprintf(b, "%c\b\033[@%c", scr_readw(s++), save);`
312			`px++;`
313			`}`
314
315			`if (inverted(attr)) {`
316			`strcpy(b, "\033[m");`
317			`b += 3;`
318			`}`
319
320			`b += promcon_end(conp, b);`
321			`promcon_puts(buf, b - buf);`
322			`}`
323
324			`static void`
325			`promcon_putc(struct vc_data *conp, int c, int y, int x)`
326			`{`
327			`unsigned short s;`
328
329			`if (console_blanked)`
330			`return;`
331
332			`scr_writew(c, &s);`
333			`promcon_putcs(conp, &s, 1, y, x);`
334			`}`
335
336			`static void`
337			`promcon_clear(struct vc_data *conp, int sy, int sx, int height, int width)`
338			`{`
339			`unsigned char buf[256], *b = buf;`
340			`int i, j;`
341
342			`if (console_blanked)`
343			`return;`
344
345			`b += promcon_start(conp, b);`
346
347			`if (!sx && width == pw + 1) {`
348
349			`if (!sy && height == ph + 1) {`
350			`strcpy(b, "\033[H\033[J");`
351			`b += 6;`
352			`b += promcon_end(conp, b);`
353			`promcon_puts(buf, b - buf);`
354			`return;`
355			`} else if (sy + height == ph + 1) {`
356			`b += sprintf(b, "\033[%dH\033[J", sy + 1);`
357			`b += promcon_end(conp, b);`
358			`promcon_puts(buf, b - buf);`
359			`return;`
360			`}`
361
362			`b += sprintf(b, "\033[%dH", sy + 1);`
363			`for (i = 1; i < height; i++) {`
364			`strcpy(b, "\033[K\n");`
365			`b += 4;`
366			`}`
367
368			`strcpy(b, "\033[K");`
369			`b += 3;`
370
371			`b += promcon_end(conp, b);`
372			`promcon_puts(buf, b - buf);`
373			`return;`
374
375			`} else if (sx + width == pw + 1) {`
376
377			`b += sprintf(b, "\033[%d;%dH", sy + 1, sx + 1);`
378			`for (i = 1; i < height; i++) {`
379			`strcpy(b, "\033[K\n");`
380			`b += 4;`
381			`}`
382
383			`strcpy(b, "\033[K");`
384			`b += 3;`
385
386			`b += promcon_end(conp, b);`
387			`promcon_puts(buf, b - buf);`
388			`return;`
389			`}`
390
391			`for (i = sy + 1; i <= sy + height; i++) {`
392			`b += sprintf(b, "\033[%d;%dH", i, sx + 1);`
393			`for (j = 0; j < width; j++)`
394			`*b++ = ' ';`
395			`if (b - buf + width >= 224) {`
396			`promcon_puts(buf, b - buf);`
397			`b = buf;`
398			`}`
399			`}`
400
401			`b += promcon_end(conp, b);`
402			`promcon_puts(buf, b - buf);`
403			`}`
404
405			`static void`
406			`promcon_bmove(struct vc_data *conp, int sy, int sx, int dy, int dx,`
407			`int height, int width)`
408			`{`
409			`char buf[256], *b = buf;`
410
411			`if (console_blanked)`
412			`return;`
413
414			`b += promcon_start(conp, b);`
415			`if (sy == dy && height == 1) {`
416			`if (dx > sx && dx + width == conp->vc_cols)`
417			`b += sprintf(b, "\033[%d;%dH\033[%d@\033[%d;%dH",`
418			`sy + 1, sx + 1, dx - sx, py + 1, px + 1);`
419			`else if (dx < sx && sx + width == conp->vc_cols)`
420			`b += sprintf(b, "\033[%d;%dH\033[%dP\033[%d;%dH",`
421			`dy + 1, dx + 1, sx - dx, py + 1, px + 1);`
422
423			`b += promcon_end(conp, b);`
424			`promcon_puts(buf, b - buf);`
425			`return;`
426			`}`
427
428			`/*`
429			`* FIXME: What to do here???`
430			`* Current console.c should not call it like that ever.`
431			`*/`
432			`prom_printf("\033[7mFIXME: bmove not handled\033[m\n");`
433			`}`
434
435			`static void`
436			`promcon_cursor(struct vc_data *conp, int mode)`
437			`{`
438			`char buf[32], *b = buf;`
439
440			`switch (mode) {`
441			`case CM_ERASE:`
442			`break;`
443
444			`case CM_MOVE:`
445			`case CM_DRAW:`
446			`b += promcon_start(conp, b);`
447			`if (px != conp->vc_x \|\| py != conp->vc_y) {`
448			`px = conp->vc_x;`
449			`py = conp->vc_y;`
450			`b += sprintf(b, "\033[%d;%dH", py + 1, px + 1);`
451			`}`
452			`promcon_puts(buf, b - buf);`
453			`break;`
454			`}`
455			`}`
456
457			`static int`
458			`promcon_blank(struct vc_data *conp, int blank, int mode_switch)`
459			`{`
460			`if (blank) {`
461			`promcon_puts("\033[H\033[J\033[7m \033[m\b", 15);`
462			`return 0;`
463			`} else {`
464			`/* Let console.c redraw */`
465			`return 1;`
466			`}`
467			`}`
468
469			`static int`
470			`promcon_scroll(struct vc_data *conp, int t, int b, int dir, int count)`
471			`{`
472			`unsigned char buf[256], *p = buf;`
473			`unsigned short *s;`
474			`int i;`
475
476			`if (console_blanked)`
477			`return 0;`
478
479			`p += promcon_start(conp, p);`
480
481			`switch (dir) {`
482			`case SM_UP:`
483			`if (b == ph + 1) {`
484			`p += sprintf(p, "\033[%dH\033[%dM", t + 1, count);`
485			`px = 0;`
486			`py = t;`
487			`p += promcon_end(conp, p);`
488			`promcon_puts(buf, p - buf);`
489			`break;`
490			`}`
491
492			`s = (unsigned short *)(conp->vc_origin`
493			`+ (t + count) * conp->vc_size_row);`
494
495			`p += sprintf(p, "\033[%dH", t + 1);`
496
497			`for (i = t; i < b - count; i++)`
498			`s = promcon_repaint_line(s, buf, &p);`
499
500			`for (; i < b - 1; i++) {`
501			`strcpy(p, "\033[K\n");`
502			`p += 4;`
503			`if (p - buf >= 224) {`
504			`promcon_puts(buf, p - buf);`
505			`p = buf;`
506			`}`
507			`}`
508
509			`strcpy(p, "\033[K");`
510			`p += 3;`
511
512			`p += promcon_end(conp, p);`
513			`promcon_puts(buf, p - buf);`
514			`break;`
515
516			`case SM_DOWN:`
517			`if (b == ph + 1) {`
518			`p += sprintf(p, "\033[%dH\033[%dL", t + 1, count);`
519			`px = 0;`
520			`py = t;`
521			`p += promcon_end(conp, p);`
522			`promcon_puts(buf, p - buf);`
523			`break;`
524			`}`
525
526			`s = (unsigned short )(conp->vc_origin + t conp->vc_size_row);`
527
528			`p += sprintf(p, "\033[%dH", t + 1);`
529
530			`for (i = t; i < t + count; i++) {`
531			`strcpy(p, "\033[K\n");`
532			`p += 4;`
533			`if (p - buf >= 224) {`
534			`promcon_puts(buf, p - buf);`
535			`p = buf;`
536			`}`
537			`}`
538
539			`for (; i < b; i++)`
540			`s = promcon_repaint_line(s, buf, &p);`
541
542			`p += promcon_end(conp, p);`
543			`promcon_puts(buf, p - buf);`
544			`break;`
545			`}`
546
547			`return 0;`
548			`}`
549
550			`#if !(PROMCON_COLOR)`
551			`static u8 promcon_build_attr(struct vc_data *conp, u8 _color, u8 _intensity,`
552			`u8 _blink, u8 _underline, u8 _reverse, u8 _italic)`
553			`{`
554			`return (_reverse) ? 0xf : 0x7;`
555			`}`
556			`#endif`
557
558			`/*`
559			`* The console 'switch' structure for the VGA based console`
560			`*/`
561
562			`static int promcon_dummy(void)`
563			`{`
564			`return 0;`
565			`}`
566
567			`#define DUMMY (void *) promcon_dummy`
568
569			`const struct consw prom_con = {`
570			`.owner = THIS_MODULE,`
571			`.con_startup = promcon_startup,`
572			`.con_init = promcon_init,`
573			`.con_deinit = promcon_deinit,`
574			`.con_clear = promcon_clear,`
575			`.con_putc = promcon_putc,`
576			`.con_putcs = promcon_putcs,`
577			`.con_cursor = promcon_cursor,`
578			`.con_scroll = promcon_scroll,`
579			`.con_bmove = promcon_bmove,`
580			`.con_switch = promcon_switch,`
581			`.con_blank = promcon_blank,`
582			`.con_set_palette = DUMMY,`
583			`.con_scrolldelta = DUMMY,`
584			`#if !(PROMCON_COLOR)`
585			`.con_build_attr = promcon_build_attr,`
586			`#endif`
587			`};`
588
589			`void __init prom_con_init(void)`
590			`{`
591			`#ifdef CONFIG_DUMMY_CONSOLE`
592			`if (conswitchp == &dummy_con)`
593			`take_over_console(&prom_con, 0, MAX_NR_CONSOLES-1, 1);`
594			`else`
595			`#endif`
596			`if (conswitchp == &prom_con)`
597			`promcon_init_unimap(vc_cons[fg_console].d);`
598			`}`