Context Navigation

source: trunk/kernel/drivers/ibmpc/tty.c @ 202

Last change on this file since 202 was 4, checked in by alain, 8 years ago
Introduce the chdev_t structure in place of device_t.
File size: 11.1 KB

Rev	Line
[1]	1	/*
	2	* tty.c - a basic tty driver
	3	*
	4	* Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
	5	* Copyright (c) 2011,2012 UPMC Sorbonne Universites
	6	*
	7	* This file is part of ALMOS-kernel.
	8	*
	9	* ALMOS-kernel is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; version 2.0 of the License.
	12	*
	13	* ALMOS-kernel is distributed in the hope that it will be useful, but
	14	* WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with ALMOS-kernel; if not, write to the Free Software Foundation,
	20	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22
	23	#include <config.h>
	24	#include <system.h>
	25	#include <cpu.h>
[4]	26	#include <chdev.h>
[1]	27	#include <driver.h>
	28	#include <cpu-io.h>
	29	#include <kmem.h>
	30	#include <libk.h>
	31	#include <tty.h>
	32	#include <rwlock.h>
	33	#include <cpu-trace.h>
	34	#include <thread.h>
	35	#include <mwmr.h>
	36
	37	struct device_s ttys_tbl[TTY_DEV_NR];
	38
	39	static void tty_clear(struct device_s *tty)
	40	{
	41	register uint_t i = 0;
	42	struct tty_context_s *ctx;
	43	uint8_t *vga_ram;
	44
	45	ctx = (struct tty_context_s*)tty->data;
	46	vga_ram = (uint8_t*)tty->base;
	47
	48	for(i = 0; i < TTY_SIZE; i+=2)
	49	{
	50	vga_ram[i] = 0;
	51	vga_ram[i+1] = ctx->attr;
	52	}
	53	}
	54
	55
	56	static sint_t tty_read(struct device_s tty, dev_request_t rq)
	57	{
	58	struct tty_context_s *ctx;
	59	register size_t size;
	60	uint_t irq_state;
	61	register char *dst;
	62	register size_t count;
	63	register uint32_t eol = 0;
	64
	65	cpu_trace_write(CURRENT_THREAD->local_cpu, tty_read);
	66
	67	ctx = (struct tty_context_s*)tty->data;
	68	size = 0;
	69	count = rq->count;
	70	dst = rq->dst;
	71
	72	if(rq->flags & DEV_RQ_NOBLOCK)
	73	rwlock_rdlock(&ctx->rwlock);
	74	else
	75	rwlock_wrlock(&ctx->rwlock);
	76
	77	spinlock_lock_noirq(&tty->lock, &irq_state);
	78
	79	size = mwmr_read(ctx->in_channel, dst, count);
	80	eol = ctx->eol;
	81
	82	if((eol) \|\| (size == count) \|\| (rq->flags & DEV_RQ_NOBLOCK))
	83	{
	84	ctx->eol = 0;
	85	spinlock_unlock_noirq(&tty->lock, irq_state);
	86	rwlock_unlock(&ctx->rwlock);
	87	return size;
	88	}
	89
	90	rq->count -= size;
	91	rq->dst = dst + size;
	92	ctx->pending_rq = rq;
	93
	94	wait_on(&ctx->wait_queue, WAIT_LAST);
	95	spinlock_unlock_noirq(&tty->lock, irq_state);
	96	sched_sleep(CURRENT_THREAD);
	97	rwlock_unlock(&ctx->rwlock);
	98	return count - rq->count;
	99	}
	100
	101	void tty_scrollup(struct device_s *tty, int n)
	102	{
	103	struct tty_context_s *ctx;
	104	uint8_t *vga_ram;
	105	uint8_t *ptr;
	106	uint8_t limit = (uint8_t)((uint_t)TTY_SIZE);
	107
	108	ctx = (struct tty_context_s*)tty->data;
	109	vga_ram = (uint8_t*)tty->base;
	110
	111	for(; vga_ram < limit; vga_ram+=2)
	112	{
	113	ptr=&vga_ram[n2TTY_XSIZE];
	114
	115	if(ptr < limit)
	116	{
	117	vga_ram = ptr;
	118	(vga_ram + 1) = (ptr+1);
	119	}
	120	else
	121	{
	122	*vga_ram = 0;
	123	*(vga_ram+1) = 0x07;
	124	}
	125	}
	126
	127	ctx->pos_Y -= n;
	128	ctx->pos_Y = (ctx->pos_Y < 0) ? 0 : ctx->pos_Y;
	129	}
	130
	131	static void tty_cleanup(struct device_s *tty)
	132	{
	133	struct tty_context_s *ctx;
	134
	135	ctx = (struct tty_context_s*)tty->data;
	136	tty_clear(tty);
	137	ctx->pos_Y = 0;
	138	ctx->pos_X = 0;
	139	}
	140
	141	#define TTY_CURSOR_CMD 0x3d4
	142	#define TTY_CURSOR_DATA 0x3d5
	143
	144	void tty_move_cursor(uint_t pos_X, uint_t pos_Y)
	145	{
	146	uint_t pos;
	147
	148	pos = pos_Y * TTY_XSIZE + pos_X;
	149	cpu_io_out8(TTY_CURSOR_CMD, 0x0f);
	150	cpu_io_out8(TTY_CURSOR_DATA, pos);
	151	cpu_io_out8(TTY_CURSOR_CMD, 0x0e);
	152	cpu_io_out8(TTY_CURSOR_DATA, pos >> 8);
	153	}
	154
	155	static void tty_putc(struct device_s *tty, uint8_t ch)
	156	{
	157	struct tty_context_s *ctx;
	158	uint8_t *vga_ram;
	159	int offset;
	160
	161	ctx = (struct tty_context_s*)tty->data;
	162	vga_ram = (uint8_t*)tty->base;
	163
	164	switch (ch)
	165	{
	166	case '\b':
	167	ctx->pos_X --;
	168	break;
	169	case '\t':
	170	ctx->pos_X += 8;
	171	break;
	172
	173	case '\r':
	174	ctx->pos_X = 0;
	175	break;
	176
	177	case '\n':
	178	ctx->pos_X = 0;
	179	ctx->pos_Y ++;
	180	break;
	181
	182	default:
	183	offset = 2TTY_XSIZEctx->pos_Y + 2*ctx->pos_X;
	184	ctx->pos_X++;
	185	vga_ram[offset] = ch;
	186	vga_ram[offset + 1] = (uint8_t)(ctx->attr & 0xFF);
	187	}
	188
	189	if(ctx->pos_X >= TTY_XSIZE)
	190	{
	191	ctx->pos_X = 0;
	192	ctx->pos_Y ++;
	193	}
	194
	195	#if 1
	196	if(ctx->pos_Y >= TTY_YSIZE)
	197	{
	198	tty_cleanup(tty);
	199	//ctx->pos_Y = 0;
	200	}
	201	#endif
	202	}
	203
	204
	205	static sint_t tty_write(struct device_s tty, dev_request_t rq)
	206	{
	207	struct tty_context_s *ctx;
	208	register unsigned int i;
	209	register size_t size = rq->count;
	210
	211	cpu_trace_write(CURRENT_THREAD->local_cpu, tty_write);
	212
	213	ctx = (struct tty_context_s*)tty->data;
	214
	215	if(!(rq->flags & DEV_RQ_NOBLOCK))
	216	rwlock_wrlock(&ctx->rwlock);
	217
	218	for (i = 0; i < size; i++)
	219	tty_putc(tty, ((uint8_t)rq->src + i));
	220
	221	if(!(rq->flags & DEV_RQ_NOBLOCK))
	222	rwlock_unlock(&ctx->rwlock);
	223
	224	return size;
	225	}
	226
	227
	228	static sint_t tty_get_params(struct device_s tty, dev_params_t params)
	229	{
	230	params->chr.xSize = TTY_XSIZE;
	231	params->chr.ySize = TTY_YSIZE;
	232	params->size = 0;
	233	return 0;
	234	}
	235
	236	#define KEYBOARD_READ_REG 0x60
	237	#define KEYBOARD_WRITE_REG 0x60
	238	#define KEYBOARD_STATUS_REG 0x64
	239	#define KEYBORAD_CMD_REG 0x64
	240
	241	#define KEY_IS_HOLD 0x80
	242	#define KEY_IS_LEFT_SHIFT 0x29
	243	#define KEY_IS_RIGHT_SHIFT 0x35
	244	#define KEY_IS_ALT 0x37
	245	#define KEY_IS_CTRL 0x1C
	246	#define KEY_IS_CAPSLOCK 0x39
	247
	248	static uint_t isLeftShift;
	249	static uint_t isRightShift;
	250	static uint_t isAlt;
	251	static uint_t isCtrl;
	252	static uint_t isCAPSLOCK;
	253
	254	static error_t tty_getc(struct device_s *tty)
	255	{
	256	register uint8_t isUpper;
	257	register uint8_t scode;
	258	register error_t ch;
	259	ch = -1;
	260	scode = 0;
	261
	262	/* Waite KEYBOARD OUTPUT BUFFER */
	263	do
	264	{
	265	scode = cpu_io_in8(KEYBOARD_STATUS_REG);
	266	}while((scode & 0x1) == 0);
	267
	268	scode = cpu_io_in8(KEYBOARD_READ_REG);
	269	scode --;
	270
	271	// isr_dmsg(DEBUG, "scode %x\n", scode);
	272
	273	if(scode < KEY_IS_HOLD)
	274	{
	275	switch (scode)
	276	{
	277	case KEY_IS_RIGHT_SHIFT:
	278	isRightShift = 1;
	279	break;
	280	case KEY_IS_CTRL:
	281	isCtrl = 1;
	282	break;
	283	case KEY_IS_ALT:
	284	isAlt = 1;
	285	break;
	286	case KEY_IS_CAPSLOCK:
	287	break;
	288	case KEY_IS_LEFT_SHIFT:
	289	isLeftShift = 1;
	290	break;
	291	default:
	292	isUpper = (isRightShift \|\| isLeftShift \|\| isCAPSLOCK) ? 1 : 0;
	293	ch = keyboard_map[(scode << 2) + isUpper + isAlt];
	294	}
	295	}
	296	else
	297	{
	298	scode -= 0x80;
	299	switch (scode)
	300	{
	301	case KEY_IS_RIGHT_SHIFT:
	302	isRightShift = 0;
	303	break;
	304	case KEY_IS_CTRL:
	305	isCtrl = 0;
	306	break;
	307	case KEY_IS_ALT:
	308	isAlt = 0;
	309	break;
	310	case KEY_IS_CAPSLOCK:
	311	isCAPSLOCK = (isCAPSLOCK) ? 0 : 1;
	312	break;
	313	case KEY_IS_LEFT_SHIFT:
	314	isLeftShift = 0;
	315	break;
	316	default:
	317	/* No action for other scan code */
	318	break;
	319	}
	320	}
	321
	322	struct tty_context_s *ctx = tty->data;
	323	tty_move_cursor(ctx->pos_X, ctx->pos_Y);
	324	return ch;
	325	}
	326
	327	static void tty_irq_handler(struct irq_action_s *action)
	328	{
	329	sint_t ch;
	330	struct device_s *tty;
	331	struct tty_context_s *ctx;
	332	register char *dst;
	333	volatile uint32_t *base;
	334
	335	cpu_trace_write(CURRENT_THREAD->local_cpu, tty_irq_handler);
	336
	337	tty = action->dev;
	338	base = tty->base;
	339	ctx = (struct tty_context_s*)tty->data;
	340
	341	if((ch = tty_getc(tty)) & 0x80)
	342	return;
	343
	344	cpu_spinlock_lock(&tty->lock.val);
	345
	346	if(ctx->pending_rq != NULL)
	347	{
	348	dst = ctx->pending_rq->dst;
	349	*(dst ++) = ch;
	350	ctx->pending_rq->dst = dst;
	351	ctx->pending_rq->count --;
	352
	353	if((ch == '\n') \|\| (ctx->pending_rq->count == 0))
	354	{
	355	wakeup_one(&ctx->wait_queue, WAIT_FIRST);
	356	ctx->pending_rq = NULL;
	357	}
	358	}
	359	else
	360	{
	361	mwmr_write(ctx->in_channel, &ch, 1);
	362	if(ch == '\n') ctx->eol = 1;
	363	}
	364
	365	#if CONFIG_TTY_ECHO_MODE
	366	switch(ch)
	367	{
	368	case '\b':
	369	case 0x7F:
	370	tty_putc(tty, '\b');
	371	tty_putc(tty, ' ');
	372	tty_putc(tty, '\b');
	373	break;
	374	default:
	375	tty_putc(tty, ch);
	376	}
	377	#endif
	378
	379	cpu_spinlock_unlock(&tty->lock.val);
	380	}
	381
	382	void ibmpc_tty_init(struct device_s tty, void base, uint_t irq, uint_t tty_id)
	383	{
	384	struct tty_context_s *ctx;
	385
	386	isRightShift = 0;
	387	isLeftShift = 0;
	388	isCtrl = 0;
	389	isAlt = 0;
	390	isCAPSLOCK = 0;
	391
	392	spinlock_init(&tty->lock);
	393	tty->base = base;
	394	tty->irq = irq;
	395	tty->type = DEV_CHR;
	396
	397	tty->action.dev = tty;
	398	tty->action.irq_handler = &tty_irq_handler;
	399	tty->action.data = NULL;
	400
	401	tty->op.dev.open = NULL;
	402	tty->op.dev.read = &tty_read;
	403	tty->op.dev.write = &tty_write;
	404	tty->op.dev.close = NULL;
	405	tty->op.dev.lseek = NULL;
	406	tty->op.dev.set_params = NULL;
	407	tty->op.dev.get_params = &tty_get_params;
	408
	409	ctx = kbootMem_calloc(sizeof(*ctx));
	410	ctx->id = tty_id;
	411	ctx->in_channel = mwmr_init(1,TTY_BUFFER_DEPTH, 0);
	412	rwlock_init(&ctx->rwlock);
	413	ctx->eol = 0;
	414	ctx->attr = 0x07;
	415	tty->data = (void*) ctx;
	416	sprintk(tty->name, "TTY%d", tty_id);
	417	metafs_init(&tty->node, tty->name);
	418	wait_queue_init(&ctx->wait_queue,tty->name);
	419	tty_clear(tty);
	420	}
	421
	422
	423	uint8_t keyboard_map[] = { 0x1B, 0x1B, 0x1B, 0x1B,
	424	'&', '1', '1', '1',
	425	'~', '2', '2', '2',
	426	'"', '3', '3', '3',
	427	'\'','4', '{', '{',
	428	'(', '5', '5', '5',
	429	'-', '6', '\|', '\|',
	430	'`', '7', '7', '7',
	431	'_', '8', '\\', '\\',
	432	'^', '9', '9', '9',
	433	'@', '0', '0', '0',
	434	')', ']', '-', '-',
	435	'=', '+', '}','}',
	436	'\b','\b', 0x7F,'\b',
	437	'\t','\t','\t','\t',
	438	'a', 'A', 'a', 'a',
	439	'z', 'Z', 'z', 'z',
	440	'e', 'E', 'e', 'e',
	441	'r', 'R', 'r', 'r',
	442	't', 'T', 't', 't',
	443	'y', 'Y', 'y', 'y',
	444	'u', 'U', 'u', 'u',
	445	'i', 'I', 'i', 'i',
	446	'o', 'O', 'o', 'o',
	447	'p', 'P', 'p', 'p',
	448	'[', '{', '[', '[',
	449	'$', '$', '$', ']',
	450	'\n','\n','\n','\n',
	451	0xFF, 0xFF, 0xFF, 0xFF,
	452	'q', 'A', 'a', 'a',
	453	's', 'S', 's', 's',
	454	'd', 'D', 'd', 'd',
	455	'f', 'F', 'f', 'f',
	456	'g', 'G', 'g', 'g',
	457	'h', 'H', 'h', 'h',
	458	'j', 'J', 'j', 'j',
	459	'k', 'K', 'k', 'k',
	460	'l', 'L', 'l', 'l',
	461	'm', 'M', ';', ';',
	462	'%', '%', '%', '%',
	463	0x28, 0x28, 0x28, 0x28,
	464	0x29, 0x29, 0x29, 0x29, /* Left Shift (41) */
	465	'', '', '', '',
	466	'w', 'W', 'w', 'w',
	467	'x', 'X', 'x', 'x',
	468	'c', 'C', 'c', 'c',
	469	'v', 'V', 'v', 'v',
	470	'b', 'B', 'b', 'b',
	471	'n', 'N', 'n', 'n',
	472	',', '?', ',', ',',
	473	';', '.', ';', ';',
	474	':', '/', ':', ':',
	475	'!', '!', '!', '!',
	476	0x35, 0x35, 0x35, 0x35, /* Rshift (0x35) */
	477	0xFF, 0xFF, 0xFF, 0xFF,
	478	0xFF, 0xFF, 0xFF, 0xFF,
	479	' ', ' ', ' ', ' ', /* space */
	480	0x39, 0x39, 0x39, 0x39,
	481	0xFF, 0xFF, 0xFF, 0xFF,
	482	0xFF, 0xFF, 0xFF, 0xFF,
	483	0xFF, 0xFF, 0xFF, 0xFF,
	484	0xFF, 0xFF, 0xFF, 0xFF,
	485	0xFF, 0xFF, 0xFF, 0xFF,
	486	0xFF, 0xFF, 0xFF, 0xFF,
	487	0xFF, 0xFF, 0xFF, 0xFF, /* 0x40 */
	488	0xFF, 0xFF, 0xFF, 0xFF,
	489	0xFF, 0xFF, 0xFF, 0xFF,
	490	0xFF, 0xFF, 0xFF, 0xFF,
	491	0xFF, 0xFF, 0xFF, 0xFF,
	492	0xFF, 0xFF, 0xFF, 0xFF,
	493	0xFF, 0xFF, 0xFF, 0xFF,
	494	0xFF, 0xFF, 0xFF, 0xFF,
	495	0xFF, 0xFF, 0xFF, 0xFF,
	496	0xFF, 0xFF, 0xFF, 0xFF,
	497	0xFF, 0xFF, 0xFF, 0xFF,
	498	0xFF, 0xFF, 0xFF, 0xFF,
	499	0xFF, 0xFF, 0xFF, 0xFF,
	500	0xFF, 0xFF, 0xFF, 0xFF,
	501	0xFF, 0xFF, 0xFF, 0xFF,
	502	0xFF, 0xFF, 0xFF, 0xFF,
	503	0xFF, 0xFF, 0xFF, 0xFF, /* 0x50 */
	504	0xFF, 0xFF, 0xFF, 0xFF,
	505	0xFF, 0xFF, 0xFF, 0xFF,
	506	0xFF, 0xFF, 0xFF, 0xFF,
	507	0xFF, 0xFF, 0xFF, 0xFF,
	508	'<', '>', '<', '<',
	509	0xFF, 0xFF, 0xFF, 0xFF,
	510	0xFF, 0xFF, 0xFF, 0xFF,
	511	0xFF, 0xFF, 0xFF, 0xFF,
	512	0xFF, 0xFF, 0xFF, 0xFF,
	513	0xFF, 0xFF, 0xFF, 0xFF,
	514	0xFF, 0xFF, 0xFF, 0xFF,
	515	0xFF, 0xFF, 0xFF, 0xFF,
	516	0xFF, 0xFF, 0xFF, 0xFF,
	517	0xFF, 0xFF, 0xFF, 0xFF,
	518	0xFF, 0xFF, 0xFF, 0xFF,
	519	0xFF, 0xFF, 0xFF, 0xFF, /* 0x60 */
	520	0xFF, 0xFF, 0xFF, 0xFF};

Note: See TracBrowser for help on using the repository browser.

Download in other formats: