console.c

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

	    return 0;
	case 'M':
	    csi_M (vt, vcd->par[0]);
	    return 0;
	case 'P':
	    csi_P (vt, vcd->par[0]);
	    return 0;
	case 'c':
	    if (!vcd->par[0])
		respond_ID(*vt->tty);
	    return 0;
	case 'g':
	    if (!vcd->par[0])
		vcd->tab_stop[vcd->curstate.x >> 5] &= ~(1 << (vcd->curstate.x & 31));
	    else
	    if (vcd->par[0] == 3) {
		vcd->tab_stop[0] =
		vcd->tab_stop[1] =
		vcd->tab_stop[2] =
		vcd->tab_stop[3] =
		vcd->tab_stop[4] = 0;
	    }
	    return 0;
	case 'm':
	    return csi_m (vt);
	case 'q': /* DECLL - but only 3 leds */
	    /* map 0,1,2,3 to 0,1,2,4 */
	    if (vcd->par[0] < 4)
		  setledstate(vt->kbd, (vcd->par[0] < 3 ? vcd->par[0] : 4));
	    return 0;
	case 'r':
	    if (!vcd->par[0])
		vcd->par[0]++;
	    if (!vcd->par[1])
		vcd->par[1] = vtdata.numrows;
	    if (vcd->par[0] < vcd->par[1] && vcd->par[1] <= vtdata.numrows) {
		vcd->top = vcd->par[0] - 1;
		vcd->bottom = vcd->par[1];
		gotoxay (vcd, 0, 0);
	    }
	    return 0;
	case 's':
	    vcd->savedstate = vcd->curstate;
	    return 0;
	case 'u':
	    vcd->curstate = vcd->savedstate;
	    update_attr (vt);
	    return 1;
	case 'X':
	    csi_X (vt, vcd->par[0]);
	    return 0;
	case '@':
	    csi_at (vt, vcd->par[0]);
	    return 0;
	case ']': /* setterm functions */
	    setterm_command (vt);
	    return 0;
	}
	return 0;
    case ESpercent:
	vcd->state = ESnormal;
	switch (c) {
	case '@': /* defined in ISO 2022 */
	    vcd->utf = 0;
	    return 0;
	case 'G': /* prelim official escape code */
	case '8': /* retained for compatibility */
	    vcd->utf = 1;
	    return 0;
	}
	return 0;
    case ESfunckey:
	vcd->state = ESnormal;
	return 0;
    case EShash:
	vcd->state = ESnormal;
	if (c == '8') {
	    /* DEC screen alignment test. kludge :-) */
	}
	return 0;
    case ESsetG0:
	vcd->state = ESnormal;
	if (c == '0')
	    vcd->curstate.G0_charset = GRAF_MAP;
	else
	if (c == 'B')
	    vcd->curstate.G0_charset = LAT1_MAP;
	else
	if (c == 'U')
	    vcd->curstate.G0_charset = IBMPC_MAP;
	else
	if (c == 'K')
	    vcd->curstate.G0_charset = USER_MAP;
	if ((vcd->curstate.flags & FLG_CHRSET) == 0) {
	    vcd->translate = set_translate(vcd->curstate.G0_charset);
	    return 1;
	}
	return 0;
    case ESsetG1:
	vcd->state = ESnormal;
	if (c == '0')
	    vcd->curstate.G1_charset = GRAF_MAP;
	else
	if (c == 'B')
	    vcd->curstate.G1_charset = LAT1_MAP;
	else
	if (c == 'U')
	    vcd->curstate.G1_charset = IBMPC_MAP;
	else
	if (c == 'K')
	    vcd->curstate.G1_charset = USER_MAP;
	if (vcd->curstate.flags & FLG_CHRSET) {
	    vcd->translate = set_translate(vcd->curstate.G1_charset);
	    return 1;
	}
	return 0;
    default:
	vcd->state = ESnormal;
    }
    return 0;
}

static inline void vcd_write_char (struct con_struct *vcd, unsigned int c)
{
    if (c & ~console_charmask)
	return;
    vcd->driver.write_char (vcd, vcd->combined_state | (c & 255));
}

int vcd_write (const struct vt *vt, int from_user, const unsigned char *buf, int count)
{
    int strt_count = count;
    unsigned short *cached_trans;
    unsigned int cached_ctrls;
    register struct con_struct *vcd;

    if (from_user && get_fs () == KERNEL_DS)
	from_user = 0;

    vcd = vt->vcd;

#ifdef DEBUG
    vcd_validate (vcd, "vcd_write entry");
#endif

    vcd_removecursors (vt);
    if (vt == vtdata.select.vt)
	clear_selection();

    disable_bh (CONSOLE_BH);
recache:
    cached_ctrls = vcd->disp_ctrl ? CTRL_ALWAYS : CTRL_ACTION;
    cached_trans = vcd->translate + (vcd->toggle_meta ? 0x80 : 0);

    while (!(*vt->tty)->stopped && count) {
	int tc, c;
	enable_bh(CONSOLE_BH);
	__asm__("teq	%3, #0
	ldreqb	%0, [%1], #1
	ldrnebt	%0, [%1], #1" : "=r" (c), "=&r" (buf) : "1" (buf), "r" (from_user));
	disable_bh(CONSOLE_BH);
	count --;

	if (vcd->utf) {
	    if ((tc = vcd_write_utf (vcd, c)) < 0)
		continue;
	    c = tc;
	} else
	    tc = cached_trans[c];

	if (vcd->state == ESnormal && tc && (c != 127 || vcd->disp_ctrl) && (c != 128+27)) {
	    if (c >= 32 || (!vcd->utf && !(cached_ctrls & (1 << c)))) { /* ok */
		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;

		vcd_write_char (vcd, tc);
		continue;
	    }
	}

	if (vcd_write_ctrl (vt, c))
	    goto recache;
	else
	    continue;
    }
    if (vt->vtd->vc_mode != KD_GRAPHICS)
	set_cursor (vt);
    vcd_restorecursors (vt);
    enable_bh(CONSOLE_BH);
#ifdef DEBUG
    vcd_validate (vcd, "vcd_write exit");
#endif
    return strt_count - count;
}

int vcd_ioctl (const struct vt *vt, int cmd, unsigned long arg)
{
    int i;
    switch (cmd) {
    case VT_GETPALETTE: {
	unsigned long pix, num, *ptr;
	const unsigned long *entries;

	ptr = (unsigned long *)arg;

	if ((i = verify_area (VERIFY_READ, ptr, 12)) != 0)
		return i;

	pix = get_user (ptr);
	num = get_user (ptr + 1);
	if (!num)
		return 0;
	if (pix > 255 || pix + num > 256)
		return -EINVAL;

	ptr = (unsigned long *) get_user (ptr + 2);
	if ((i = verify_area (VERIFY_WRITE, ptr, num * sizeof (unsigned long))) != 0)
		return i;

	if (vt->vcd->screen.palette_entries)
		entries = vt->vcd->screen.palette_entries + pix;
	else
		entries = default_palette_entries + pix;
	memcpy_tofs(ptr, entries, num * sizeof (unsigned long));
	return 0;
        }
    case VT_SETPALETTE: {
	unsigned long pix, num, *ptr, *sval;

	ptr = (unsigned long *)arg;

	if ((i = verify_area (VERIFY_READ, ptr, 12)) != 0)
		return i;

	pix = get_user (ptr);
	num = get_user (ptr + 1);
	if (!num)
		return 0;
	if (pix > 255 || pix + num > 256)
		return -EINVAL;

	ptr = (unsigned long *) get_user (ptr + 2);
	if ((i = verify_area (VERIFY_READ, ptr, num * sizeof (unsigned long))) != 0)
		return i;

	if (!vt->vcd->screen.palette_entries) {
		void *entries;
		entries = kmalloc (sizeof (unsigned long) * 256, GFP_KERNEL);
		if (!vt->vcd->screen.palette_entries) {
			if (!entries)
				return -ENOMEM;
			memcpy (entries, default_palette_entries, 256 * sizeof (unsigned long));
			vt->vcd->screen.palette_entries = entries;
		}
	}
	sval = vt->vcd->screen.palette_entries + pix;
	memcpy_fromfs (sval, ptr, num * sizeof (unsigned long));
	palette_setpixel(pix);
	for (i = num; i > 3; i -= 4) {
	    palette_write (*sval++);
	    palette_write (*sval++);
	    palette_write (*sval++);
	    palette_write (*sval++);
	}
	if (i & 2) {
	    palette_write (*sval++);
	    palette_write (*sval++);
	}
	if (i & 1)
	    palette_write (*sval++);
	return 0;
	}

    case PIO_FONT:
	if (vt->vtd->vc_mode != KD_TEXT)
	    return -EINVAL;
	return con_set_font((char *)arg);
	/* con_set_font() defined in console.c */

    case GIO_FONT:
	if (vt->vtd->vc_mode != KD_TEXT)
	    return -EINVAL;
	return con_get_font((char *)arg);
	/* con_get_font() defined in console.c */

    case PIO_SCRNMAP:
	return con_set_trans_old ((char *)arg);

    case GIO_SCRNMAP:
	return con_get_trans_old((char *)arg);

    case PIO_UNISCRNMAP:
	return con_set_trans_new((short *)arg);

    case GIO_UNISCRNMAP:
	return con_get_trans_new((short *)arg);

    case PIO_UNIMAPCLR: {
	struct unimapinit ui;

	i = verify_area(VERIFY_READ, (void *)arg, sizeof(struct unimapinit));
	if (i)
	    return i;
	memcpy_fromfs(&ui, (void *)arg, sizeof(struct unimapinit));
	con_clear_unimap(&ui);
	return 0;
	}

    case PIO_UNIMAP: {
	i = verify_area(VERIFY_READ, (void *)arg, sizeof(struct unimapdesc));
	if (i == 0) {
	    struct unimapdesc *ud;
	    u_short ct;
	    struct unipair *list;

	    ud = (struct unimapdesc *) arg;
	    ct = get_fs_word(&ud->entry_ct);
	    list = (struct unipair *) get_fs_long(&ud->entries);

	    i = verify_area(VERIFY_READ, (void *) list,
			ct*sizeof(struct unipair));
	    if (!i)
		return con_set_unimap(ct, list);
	}
	return i;
	}

    case GIO_UNIMAP: {
	i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct unimapdesc));
	if (i == 0) {
	    struct unimapdesc *ud;
	    u_short ct;
	    struct unipair *list;

	    ud = (struct unimapdesc *) arg;
	    ct = get_fs_word(&ud->entry_ct);
	    list = (struct unipair *) get_fs_long(&ud->entries);
	    if (ct)
		i = verify_area(VERIFY_WRITE, (void *) list,
			ct*sizeof(struct unipair));
	    if (!i)
		return con_get_unimap(ct, &(ud->entry_ct), list);
	}
	return i;
	}

    default:
	return -ENOIOCTLCMD;
    }
}

void console_print(const char *b)
{
	static int printing = 0;
	struct vt *vt = vtdata.fgconsole;
	struct con_struct * const vcd = vt->vcd;
	unsigned char c;

#ifdef DEBUG
	vcd_validate (vcd, "console_print entry");
#endif

	if (!printable || printing || vt->vtd->vc_mode == KD_GRAPHICS)
		return;  /* console not yet initialized */
	printing = 1;

	if (!vt_allocated(vtdata.fgconsole)) {
		/* impossible */
	  	printk ("console_print: tty %d not allocated ??\n", vtdata.fgconsole->num);
	  	printing = 0;
	  	return;
	}

#ifdef CONFIG_SERIAL_ECHO
	serial_echo_print (b);
#endif
	vcd_removecursors (vt);
	while ((c = *b++) != 0)
		screen_driver.put_char(vcd, vcd->combined_state | (c & 255));
	set_cursor (vt);
	vcd_restorecursors (vt);

	vt_pokeblankedconsole ();
	printing = 0;
#ifdef DEBUG
	vcd_validate (vt->vcd, "console_print exit");
#endif
}

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

int vcd_init (struct vt *vt, int kmallocok, unsigned long *kmem)
{
	struct con_struct *vcd = vt->vcd;
	memset (vcd, 0, sizeof (*vcd));
    
	vcd->screen.origin		= vtdata.screen.memstart;
	vcd->screen.cursoron		= (kmem ? 1 : 0);
	vcd->screen.palette_entries	= NULL;
	vcd->driver			= buffer_driver;
	if (kmallocok) {
		vcd->buffer.buffer	= vmalloc (vtdata.buffer.totsize * sizeof (unsigned long));
		if (!vt->vcd->buffer.buffer)
			return -ENOMEM;
		vcd->buffer.kmalloced	= 1;
	} else {
		vcd->buffer.buffer	= (unsigned long *) *kmem;
		*kmem += vtdata.buffer.totsize * sizeof (unsigned long);
	}

	vt->vtd->paste_wait		= NULL;
	reset_terminal (vt, (kmem ? 1 : 0));
	return 0;
}

/*
 * We allow this irq to be shared
 */
static struct irqaction vsyncirq = { vsync_irq, SA_SHIRQ, 0, "vsync", NULL, NULL };
    
unsigned long vcd_pre_init (unsigned long kmem, struct vt *vt)
{
	int colours, i;

	switch (bytes_per_char_h) {
	default:
	case 1:
		default_palette_entries = palette_1;
		vtdata.screen.bytespercharh = 1;
		vtdata.screen.bitsperpix = 1;
		color_table = color_1;
		colours = 1;
		break;
	case 4:
		default_palette_entries = palette_4;
		vtdata.screen.bytespercharh = 4;
		vtdata.screen.bitsperpix = 4;
		color_table = color_4;
		colours = 16;
		for (i = 0; i < 256; i++)
			con_charconvtable[i] =
				(i & 128 ? 1 << 0  : 0) |
				(i & 64  ? 1 << 4  : 0) |
				(i & 32  ? 1 << 8  : 0) |
				(i & 16  ? 1 << 12 : 0) |
				(i & 8   ? 1 << 16 : 0) |
				(i & 4   ? 1 << 20 : 0) |
				(i & 2   ? 1 << 24 : 0) |
				(i & 1   ? 1 << 28 : 0);
		break;
	case 8:
		default_palette_entries = palette_8;
		vtdata.screen.bytespercharh = 8;
		vtdata.screen.bitsperpix = 8;
		color_table = color_8;
		colours = 256;
		for (i = 0; i < 16; i++)
			con_charconvtable[i] =
				(i & 8   ? 1 << 0  : 0) |
				(i & 4   ? 1 << 8  : 0) |
				(i & 2   ? 1 << 16 : 0) |
				(i & 1   ? 1 << 24 : 0);
		break;
	}
	video_size_row		= vtdata.numcolumns * vtdata.screen.bytespercharh;
	vtdata.screen.bytespercharv = bytes_per_char_v;
	vtdata.screen.sizerow   = video_size_row * vtdata.screen.bytespercharv;
	vtdata.screen.totsize	= vtdata.screen.sizerow * vtdata.numrows;

	vtdata.screen.memsize	= ((vtdata.screen.totsize - 1) | (PAGE_SIZE - 1)) + 1;
	vtdata.screen.memend	= SCREEN1_END;
	vtdata.screen.memstart	= vtdata.screen.memend - vtdata.screen.memsize;
	vtdata.buffer.buffer	= (unsigned long *)kmem;
	vtdata.buffer.sizerow	= vtdata.numcolumns;
	vtdata.buffer.totsize	= vtdata.numcolumns * vtdata.numrows;
	vtdata.buffer.lastorigin	= vtdata.buffer.totsize * 2;
	kmem = (unsigned long)(vtdata.buffer.buffer + vtdata.buffer.totsize * 3);
	memzero (vtdata.buffer.buffer, vtdata.buffer.totsize * 3 << 2);

	kmem = map_screen_mem (vtdata.screen.memstart, kmem, 1);

	palette_setpixel(0);
	for (i = 0; i < MAX_PIX; i++)
		palette_write(default_palette_entries[i]);

	vcd_init (vt, 0, &kmem);
	vt->vcd->driver = screen_driver;

	gotoxy (vt->vcd, ORIG_X, ORIG_Y);
	set_origin (vt);
	csi_J (vt, 0);
	printable = 1;

#ifdef CONFIG_SERIAL_ECHO
	serial_echo_init (SERIAL_ECHO_PORT);
#endif
	printk ("Console: %s %s %dx%dx%d, %d virtual console%s (max %d)\n",
		colours != 1 ? "colour" : "mono",
		"A-series",
		vtdata.numcolumns, vtdata.numrows, colours,
		MIN_NR_CONSOLES,
		(MIN_NR_CONSOLES == 1) ? "":"s",
		MAX_NR_CONSOLES);

	register_console (console_print);

	if (setup_arm_irq(IRQ_VSYNCPULSE, &vsyncirq))
		panic ("Unable to get VSYNC irq for console\n");

	return kmem;
}

/*
 * Report the current status of the vc. This is exported to modules (ARub)
 */
int con_get_info(int *mode, int *shift, int *col, int *row,
			struct tty_struct **tty)
{
	extern int shift_state;

	if (mode) *mode = vtdata.fgconsole->vtd->vc_mode;
	if (shift) *shift = shift_state;
	if (col) *col = vtdata.numcolumns;
	if (row) *row = vtdata.numrows;
	if (tty) *tty = *vtdata.fgconsole->tty;
	return vtdata.fgconsole->num;
}