console.c

arm平台上的uclinux系统全部源代码

}

void update_scrmem (const struct vt * const vt, int start, int length)
{
	unsigned long p, pp, sx, sy, ex, ey;
	unsigned long *buffer;

	length += start;
	sy = start / vtdata.numcolumns;
	sx = start % vtdata.numcolumns;
	ey = length / vtdata.numcolumns;
	ex = length % vtdata.numcolumns;

	if (ey > vtdata.numrows)
		ey = vtdata.numrows;

	p = vt->vcd->screen.origin + sy * vtdata.screen.sizerow;
	buffer = vt->vcd->buffer.buffer + start;

	if (ey > sy) {
		for (; sy < ey; sy++) {
			pp = p + sx * vtdata.screen.bytespercharh;
			for (; sx < vtdata.numcolumns; sx++) {
				ll_write_char (pp, *buffer++);
				pp += vtdata.screen.bytespercharh;
			}
			p += vtdata.screen.sizerow;
			sx = 0;
		}
	}

	if (ey == sy && ex) {
		for (; sx < ex; sx++) {
			ll_write_char (p, *buffer++);
			p += vtdata.screen.bytespercharh;
		}
	}
}

void set_scrmem (const struct vt * const vt, long offset)
{
    unsigned long p, pp, my, by;
    unsigned long *buffer;

    p = vt->vcd->screen.origin;
    buffer = vt->vcd->buffer.buffer;

    by = vtdata.screen.sizerow;
    for (my = vtdata.numrows; my > 0; my--) {
	int mx, bx = vtdata.screen.bytespercharh;
	pp = p;
	mx = vtdata.numcolumns;
	while (mx > 8) {
	    mx -= 8;
	    ll_write_char (pp, *buffer++); pp += bx;
	    ll_write_char (pp, *buffer++); pp += bx;
	    ll_write_char (pp, *buffer++); pp += bx;
	    ll_write_char (pp, *buffer++); pp += bx;
	    ll_write_char (pp, *buffer++); pp += bx;
	    ll_write_char (pp, *buffer++); pp += bx;
	    ll_write_char (pp, *buffer++); pp += bx;
	    ll_write_char (pp, *buffer++); pp += bx;
	}
	while (mx > 0) {
	    mx -= 1;
	    ll_write_char (pp, *buffer++); pp += bx;
	}
	p += by;
    }
    pp = vt->vcd->screen.origin + vtdata.screen.memsize;
    memsetl((unsigned long *)p, vt->vcd->cached_backcolwrd, pp - p);
    update_palette(vt);
}

/*
 * PIO_FONT support
 */
int con_set_font (char *arg)
{
	return -EINVAL;
}

int con_get_font (char *arg)
{
	return -EINVAL;
}

void con_reset_palette (const struct vt * const vt)
{
}

void con_set_palette (const struct vt * const vt)
{
	update_palette(vt);
}

/* == arm specific console code ============================================================== */

int do_screendump(int arg)
{
    char *buf = (char *)arg;
    int l;
    if (!suser())
	return -EPERM;
    l = verify_area (VERIFY_WRITE, buf, 2);
    if (l)
	return l;
    return -ENOSYS;
}

void vcd_disallocate (struct vt *vt)
{
	if (vt->vcd && vt->vcd->buffer.kmalloced) {
		vfree (vt->vcd->buffer.buffer);
		vt->vcd->buffer.buffer = NULL;
		vt->vcd->buffer.kmalloced = 0;
	}
}

int vcd_resize(unsigned long lines, unsigned long cols)
{/* TODO */
	return -ENOMEM;
}

void vcd_blankscreen(int nopowersave)
{
	unsigned int pix;

    /* DISABLE VIDEO */
	palette_setpixel(0);
	for (pix = 0; pix < MAX_PIX; pix++)
		palette_write(0);
}

void vcd_unblankscreen (void)
{
	update_palette(vtdata.fgconsole);
}

static unsigned long old_origin;

void vcd_savestate (const struct vt *vt, int blanked)
{
    struct con_struct *vcd = vt->vcd;
    clear_selection ();
    vcd_removecursors (vt);
    old_origin = vt->vcd->screen.origin;

    if (blanked)
	vtdata.blanked = NULL;

    memcpy (vcd->buffer.buffer, vtdata.buffer.buffer + vtdata.buffer.origin,
		vtdata.buffer.totsize << 2);
    vcd->buffer.pos -= vtdata.buffer.origin;
    vcd->driver = buffer_driver;
#ifdef DEBUG
    vcd_validate (vt->vcd, "vcd_savestate");
#endif
}

void vcd_restorestate (const struct vt *vt)
{
    struct con_struct *vcd = vt->vcd;
    int text_mode;
    /*
     * Reset the origin on this VT to be the same as the previous.
     * This way we don't get any jumps when we change VT's.
     */
    text_mode = vt->vtd->vc_mode == KD_TEXT ? 1 : 0;
    memcpy (vtdata.buffer.buffer, vcd->buffer.buffer, vtdata.buffer.totsize << 2);
    vtdata.buffer.origin = 0;
    if (text_mode) {
	vt->vcd->screen.origin = old_origin;
	set_scrmem (vt, 0);
    } else
	vt->vcd->screen.origin = SCREEN2_BASE;
    vcd->driver = screen_driver;
    gotoxy(vt->vcd, vt->vcd->curstate.x, vt->vcd->curstate.y);
#ifdef DEBUG
    vcd_validate (vt->vcd, "vcd_restorestate");
#endif
    set_origin(vt);
    set_cursor(vt);
    if (text_mode)
	vcd_restorecursors (vt);
    set_leds ();
}

void vcd_setup_graphics (const struct vt *vt)
{
    clear_selection ();
    vcd_removecursors (vt);
    __set_origin (vtdata.screen.memstart);
}

/*===============================================================================================*/

static int vcd_write_utf (struct con_struct *vcd, int c)
{
    /* Combine UTF-8 into Unicode */
    /* Incomplete characters silently ignored */
    if (c < 0x80) {
	vcd->utf_count = 0;
	return c;
    }

    if (vcd->utf_count > 0 && (c & 0xc0) == 0x80) {
	vcd->utf_char = (vcd->utf_char << 6) | (c & 0x3f);
	if (--vcd->utf_count == 0)
	    return vcd->utf_char;
	else
	    return -1;
    } else {
	unsigned int count, chr;
	if ((c & 0xe0) == 0xc0) {
	    count = 1;
	    chr = (c & 0x1f);
	} else if ((c & 0xf0) == 0xe0) {
	    count = 2;
	    chr = (c & 0x0f);
	} else if ((c & 0xf8) == 0xf0) {
	    count = 3;
	    chr = (c & 0x07);
	} else if ((c & 0xfc) == 0xf8) {
	    count = 4;
	    chr = (c & 0x03);
	} else if ((c & 0xfe) == 0xfc) {
	    count = 5;
	    chr = (c & 0x01);
	} else {
	    count = 0;
	    chr = 0;
	}
	vcd->utf_count = count;
	vcd->utf_char = chr;
	return -1;
    }
}

static int vcd_write_ctrl (const struct vt *vt, unsigned int c)
{
    struct con_struct *vcd = vt->vcd;
    /*
     *  Control characters can be used in the _middle_
     *  of an escape sequence.
     */
    switch (c) {
    case 0:
	return 0;
    case 7:
	if (vcd->bell_duration)
		vt_mksound (vcd->bell_pitch, 72, vcd->bell_duration);
	return 0;
    case 8:
	if (vcd->need_wrap)
	    vcd->need_wrap = 0;
	else if (vcd->curstate.x) {
	    vcd->curstate.x --;
	    if (vtdata.fgconsole == vt)
		vcd->screen.pos -= vtdata.screen.bytespercharh;
	    vcd->buffer.pos -= 1;
	    vcd->need_wrap = 0;
	}
	return 0;
    case 9:
	if (vtdata.fgconsole == vt)
	    vcd->screen.pos -= vcd->curstate.x * vtdata.screen.bytespercharh;
	vcd->buffer.pos -= vcd->curstate.x;
	while (vcd->curstate.x < vtdata.numcolumns - 1) {
	    vcd->curstate.x++;
	    if (vcd->tab_stop[vcd->curstate.x >> 5] & (1 << (vcd->curstate.x & 31)))
		break;
	}
	if (vtdata.fgconsole == vt)
	    vcd->screen.pos += vcd->curstate.x * vtdata.screen.bytespercharh;
	vcd->buffer.pos += vcd->curstate.x;
	return 0;
    case 10:
    case 11:
    case 12:
	if (vcd->curstate.y + 1 == vcd->bottom)
	    vcd->driver.scroll_up (vcd, vcd->top, vcd->bottom, 1);
	else if (vcd->curstate.y < vtdata.numrows - 1) {
	    vcd->curstate.y ++;
	    if (vtdata.fgconsole == vt)
		vcd->screen.pos += vtdata.screen.sizerow;
	    vcd->buffer.pos += vtdata.buffer.sizerow;
	}
	vcd->need_wrap = 0;
	if (!is_kbd(lnm))
	    return 0;
    case 13:
	if (vtdata.fgconsole == vt)
	    vcd->screen.pos -= vcd->curstate.x * vtdata.screen.bytespercharh;
	vcd->buffer.pos -= vcd->curstate.x;
	vcd->curstate.x = vcd->need_wrap = 0;
	return 0;
    case 14:
	vcd->curstate.flags |= FLG_CHRSET;
	vcd->disp_ctrl = 1;
	vcd->translate = set_translate(vcd->curstate.G1_charset);
	return 1;
    case 15:
	vcd->curstate.flags &= ~FLG_CHRSET;
	vcd->disp_ctrl = 0;
	vcd->translate = set_translate(vcd->curstate.G0_charset);
	return 1;
    case 24:
    case 26:
	vcd->state = ESnormal;
	return 0;
    case 27:
	vcd->state = ESesc;
	return 0;
    case 127:
	/* ignored */
	return 0;
    case 128+27:
	vcd->state = ESsquare;
	return 0;
    }

    switch(vcd->state) {
    case ESesc:
	vcd->state = ESnormal;
	switch (c) {
	case '[':
	    vcd->state = ESsquare;
	    break;
	case ']':
	    vcd->state = ESnonstd;
	    break;
	case '%':
	    vcd->state = ESpercent;
	    break;
	case 'E':
	    if (vtdata.fgconsole == vt)
		vcd->screen.pos -= vcd->curstate.x * vtdata.screen.bytespercharh;
	    vcd->buffer.pos -= vcd->curstate.x;
	    vcd->curstate.x = vcd->need_wrap = 0;
	case 'D':
	    if (vcd->curstate.y + 1 == vcd->bottom)
		vcd->driver.scroll_up (vcd, vcd->top, vcd->bottom, 1);
	    else if (vcd->curstate.y < vtdata.numrows - 1) {
		vcd->curstate.y ++;
		if (vtdata.fgconsole == vt)
		    vcd->screen.pos += vtdata.screen.sizerow;
		vcd->buffer.pos += vtdata.buffer.sizerow;
	    }
	    /* vcd->need_wrap = 0; why should we reset this when the x position is the same? */
	    break;
	case 'M':
	    if (vcd->curstate.y == vcd->top)
		vcd->driver.scroll_down (vcd, vcd->top, vcd->bottom, 1);
	    else if (vcd->curstate.y > 0) {
		vcd->curstate.y --;
		if (vtdata.fgconsole == vt)
		    vcd->screen.pos -= vtdata.screen.sizerow;
		vcd->buffer.pos -= vtdata.buffer.sizerow;
	    }
	    /* vcd->need_wrap = 0; why should we reset this when the x position is the same? */
	    break;
	case 'H':
	    vcd->tab_stop[vcd->curstate.x >> 5] |= (1 << (vcd->curstate.x & 31));
	    break;
	case 'Z':
	    respond_ID (*vt->tty);
	    break;
	case '7':
	    vcd->savedstate = vcd->curstate;
	    break;
	case '8':
	    vcd->curstate = vcd->savedstate;
 	    gotoxy(vt->vcd, vt->vcd->curstate.x, vt->vcd->curstate.y);
	    update_attr (vt);
	    return 1;
	case '(':
	    vcd->state = ESsetG0;
	    break;
	case ')':
	    vcd->state = ESsetG1;
	    break;
	case '#':
	    vcd->state = EShash;
	    break;
	case 'c':
	    reset_terminal (vt, 0);
	    break;
	case '>': /* Numeric keypad */
	    clr_kbd (kbdapplic);
	    break;
	case '=': /* Appl. keypad */
	    set_kbd (kbdapplic);
	    break;
	}
	return 0;
    case ESnonstd:
	vcd->state = ESnormal;
	switch (c) {
	case 'P': /* palette escape sequence */
	    for (vcd->npar = 0; vcd->npar < NPAR; vcd->npar++)
		vcd->par[vcd->npar] = 0;
	    vcd->npar = 0 ;
	    vcd->state = ESpalette;
	    return 0;
	case 'R': /* reset palette */
	    con_reset_palette (vt);
	default:
	    return 0;
	}
    case ESpalette:
	if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f')) {
	    vcd->par[vcd->npar++] = (c > '9' ? (c & 0xDF) - 'A' + 10 : c - '0');
	    if (vcd->npar == 7) {
#if TODO
		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];
#endif
		con_set_palette (vt);
		vcd->state = ESnormal;
	    }
	} else
	    vcd->state = ESnormal;
	return 0;
    case ESsquare:
	for (vcd->npar = 0; vcd->npar < NPAR; vcd->npar++)
	    vcd->par[vcd->npar] = 0;
	vcd->npar = 0;
	vcd->state = ESgetpars;
	if (c == '[') { /* Function key */
	    vcd->state = ESfunckey;
	    return 0;
	}

	vcd->ques = (c == '?');
	if (vcd->ques)
	    return 0;
    case ESgetpars:
	if (c == ';' && vcd->npar < NPAR - 1) {
	    vcd->npar ++;
	    return 0;
	} else
	if (c >= '0' && c <= '9') {
	    vcd->par[vcd->npar] = vcd->par[vcd->npar] * 10 + c - '0';
	    return 0;
	} else
	    vcd->state = ESgotpars;
    case ESgotpars:
	vcd->state=ESnormal;
	switch (c) {
	case 'h':
	    set_mode(vt, 1);
	    return 0;
	case 'l':
	    set_mode(vt, 0);
	    return 0;
	case 'n':
	    if (!vcd->ques) {
		if (vcd->par[0] == 5)
		    status_report (*vt->tty);
		else
		if (vcd->par[0] == 6)
		    cursor_report (vt);
	    }
	    return 0;
	}
	if (vcd->ques) {
		vcd->ques = 0;
		return 0;
	}
	switch(c) {
	case 'G':
	case '`':
	    if (vcd->par[0])
		vcd->par[0]--;
	    gotoxy (vcd, vcd->par[0], vcd->curstate.y);
	    return 0;
	case 'A':
	    if (!vcd->par[0])
		vcd->par[0]++;
	    gotoxy (vcd, vcd->curstate.x, vcd->curstate.y - vcd->par[0]);
	    return 0;
	case 'B':
	case 'e':
	    if (!vcd->par[0])
		vcd->par[0]++;
	    gotoxy (vcd, vcd->curstate.x, vcd->curstate.y + vcd->par[0]);
	    return 0;
	case 'C':
	case 'a':
	    if (!vcd->par[0])
		vcd->par[0]++;
	    gotoxy (vcd, vcd->curstate.x + vcd->par[0], vcd->curstate.y);
	    return 0;
	case 'D':
	    if (!vcd->par[0])
		vcd->par[0]++;
	    gotoxy (vcd, vcd->curstate.x - vcd->par[0], vcd->curstate.y);
	    return 0;
	case 'E':
	    if (!vcd->par[0])
		vcd->par[0]++;
	    gotoxy (vcd, 0, vcd->curstate.y + vcd->par[0]);
	    return 0;
	case 'F':
	    if (!vcd->par[0])
		vcd->par[0]++;
	    gotoxy (vcd, 0, vcd->curstate.y - vcd->par[0]);
	    return 0;
	case 'd':
	    if (vcd->par[0])
		vcd->par[0]--;
	    gotoxay (vcd, vcd->curstate.x, vcd->par[0]);
	    return 0;
	case 'H':
	case 'f':
	    if (vcd->par[0])
		vcd->par[0]--;
	    if (vcd->par[1])
		vcd->par[1]--;
	    gotoxay (vcd, vcd->par[1], vcd->par[0]);
	    return 0;
	case 'J':
	    csi_J (vt, vcd->par[0]);
	    return 0;
	case 'K':
	    csi_K (vt, vcd->par[0]);
	    return 0;
	case 'L':
	    csi_L (vt, vcd->par[0]);