plan 9 kernel history: overview | file list | diff list

1990/1226/ss/screen.c (diff list | history)

1990/1226/sys/src/9/ss/screen.c:1,402 – 1990/1231/sys/src/9/ss/screen.c:1,511 (short | long | prev | next)
1990/1223    
#include	"u.h" 
#include	"lib.h" 
#include	"mem.h" 
#include	"dat.h" 
#include	"fns.h" 
#include	"io.h" 
#include	"ureg.h" 
#include	"errno.h" 
 
#include	<libg.h> 
#include	<gnot.h> 
 
#define	MINX	8 
 
extern	GFont	defont0; 
GFont		*defont; 
 
struct{ 
	Point	pos; 
	int	bwid; 
}out; 
 
void	duartinit(void); 
int	duartacr; 
int	duartimr; 
 
void	(*kprofp)(ulong);
1990/1231    
void	kbdstate(int);
1990/1223    
 
GBitmap	gscreen = 
{
1990/1226    
	(ulong*)SCREENSEGM,
1990/1223    
	0,
1990/1226    
	1160/32,
1990/1223    
	0,
1990/1226    
	{0, 0, 1160, 900},
1990/1223    
	0 
}; 
 
void 
screeninit(void) 
{
1990/1226    
/*	duartinit(); /**/ 
	defont = &defont0;
1990/1223    
	gbitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, 0); 
	out.pos.x = MINX; 
	out.pos.y = 0; 
	out.bwid = defont0.info[' '].width; 
} 
 
void 
screenputc(int c) 
{ 
	char buf[2]; 
	int nx; 
 
	if(c == '\n'){ 
		out.pos.x = MINX; 
		out.pos.y += defont0.height; 
		if(out.pos.y > gscreen.r.max.y-defont0.height) 
			out.pos.y = gscreen.r.min.y; 
		gbitblt(&gscreen, Pt(0, out.pos.y), &gscreen, 
		    Rect(0, out.pos.y, gscreen.r.max.x, out.pos.y+2*defont0.height), 0); 
	}else if(c == '\t'){ 
		out.pos.x += (8-((out.pos.x-MINX)/out.bwid&7))*out.bwid; 
		if(out.pos.x >= gscreen.r.max.x) 
			screenputc('\n'); 
	}else if(c == '\b'){ 
		if(out.pos.x >= out.bwid+MINX){ 
			out.pos.x -= out.bwid; 
			screenputc(' '); 
			out.pos.x -= out.bwid; 
		} 
	}else{ 
		if(out.pos.x >= gscreen.r.max.x-out.bwid) 
			screenputc('\n'); 
		buf[0] = c&0x7F; 
		buf[1] = 0;
1990/1226    
		out.pos = gstring(&gscreen, out.pos, defont, buf, S);
1990/1223    
	} 
} 
 
/* 
 * Register set for half the duart.  There are really two sets.
1990/1231    
 *  Driver for the Z8530.
1990/1223    
 */ 
struct Duart{ 
	uchar	mr1_2;		/* Mode Register Channels 1 & 2 */ 
	uchar	sr_csr;		/* Status Register/Clock Select Register */ 
	uchar	cmnd;		/* Command Register */ 
	uchar	data;		/* RX Holding / TX Holding Register */ 
	uchar	ipc_acr;	/* Input Port Change/Aux. Control Register */ 
#define	ivr	ivr		/* Interrupt Vector Register */ 
	uchar	is_imr;		/* Interrupt Status/Interrupt Mask Register */ 
#define	ip_opcr	is_imr		/* Input Port/Output Port Configuration Register */ 
	uchar	ctur;		/* Counter/Timer Upper Register */ 
#define	scc_sopbc ctur		/* Start Counter Command/Set Output Port Bits Command */ 
	uchar	ctlr;		/* Counter/Timer Lower Register */ 
#define	scc_ropbc ctlr		/* Stop Counter Command/Reset Output Port Bits Command */ 
};
1990/1231    
enum 
{ 
	/* wr 0 */ 
	ResExtPend=	2<<3, 
	ResTxPend=	5<<3, 
	ResErr=		6<<3,
1990/1223    
 
enum{ 
	CHAR_ERR	=0x00,	/* MR1x - Mode Register 1 */ 
	PAR_ENB		=0x00, 
	EVEN_PAR	=0x00, 
	ODD_PAR		=0x04, 
	NO_PAR		=0x10, 
	CBITS8		=0x03, 
	CBITS7		=0x02, 
	CBITS6		=0x01, 
	CBITS5		=0x00, 
	NORM_OP		=0x00,	/* MR2x - Mode Register 2 */ 
	TWOSTOPB	=0x0F, 
	ONESTOPB	=0x07, 
	ENB_RX		=0x01,	/* CRx - Command Register */ 
	DIS_RX		=0x02, 
	ENB_TX		=0x04, 
	DIS_TX		=0x08, 
	RESET_MR 	=0x10, 
	RESET_RCV  	=0x20, 
	RESET_TRANS  	=0x30, 
	RESET_ERR  	=0x40, 
	RESET_BCH	=0x50, 
	STRT_BRK	=0x60, 
	STOP_BRK	=0x70, 
	RCV_RDY		=0x01,	/* SRx - Channel Status Register */ 
	FIFOFULL	=0x02, 
	XMT_RDY		=0x04, 
	XMT_EMT		=0x08, 
	OVR_ERR		=0x10, 
	PAR_ERR		=0x20, 
	FRM_ERR		=0x40, 
	RCVD_BRK	=0x80, 
	BD38400		=0xCC|0x0000, 
	BD19200		=0xCC|0x0100, 
	BD9600		=0xBB|0x0000, 
	BD4800		=0x99|0x0000, 
	BD2400		=0x88|0x0000, 
	BD1200		=0x66|0x0000, 
	BD300		=0x44|0x0000, 
	IM_IPC		=0x80,	/* IMRx/ISRx - Interrupt Mask/Interrupt Status */ 
	IM_DBB		=0x40, 
	IM_RRDYB	=0x20, 
	IM_XRDYB	=0x10, 
	IM_CRDY		=0x08, 
	IM_DBA		=0x04, 
	IM_RRDYA	=0x02, 
	IM_XRDYA	=0x01, 
};
1990/1231    
	/* wr 1 */ 
	TxIntEna=	1<<1, 
	RxIntDis=	0<<3, 
	RxIntFirstEna=	1<<3, 
	RxIntAllEna=	2<<3,
1990/1223    
 
uchar keymap[]={ 
/*80*/	0x58,	0x58,	0x58,	0x58,	0x58,	0x58,	0x58,	0x58, 
	0x58,	0x58,	0x58,	0x58,	0x58,	0x58,	0x8e,	0x58, 
/*90*/	0x90,	0x91,	0x92,	0x93,	0x94,	0x95,	0x96,	0x97, 
	0x98,	0x99,	0x9a,	0x9b,	0x58,	0x58,	0x58,	0x58, 
/*A0*/	0x58,	0xa1,	0xa2,	0xa3,	0xa4,	0xa5,	0xa6,	0xa7, 
	0x58,	0x58,	0x58,	0x58,	0x58,	0x58,	0xae,	0xaf, 
/*B0*/	0xb0,	0xb1,	0xb2,	0xb3,	0xb4,	0xb5,	0x80,	0xb7, 
	0xb8,	0xb9,	0x00,	0xbb,	0x1e,	0xbd,	0x60,	0x1f, 
/*C0*/	0xc0,	0xc1,	0xc2,	0xc3,	0xc4,	0x58,	0xc6,	0x0a, 
	0xc8,	0xc9,	0xca,	0xcb,	0xcc,	0xcd,	0xce,	0xcf, 
/*D0*/	0x09,	0x08,	0xd2,	0xd3,	0xd4,	0xd5,	0xd6,	0xd7, 
	0x58,	0x58,	0x58,	0x58,	0x58,	0x58,	0x7f,	0x58, 
/*E0*/	0x58,	0x58,	0xe2,	0x1b,	0x0d,	0xe5,	0x58,	0x0a, 
	0xe8,	0xe9,	0xea,	0xeb,	0xec,	0xed,	0xee,	0xef, 
/*F0*/	0x09,	0x08,	0xb2,	0x1b,	0x0d,	0xf5,	0x81,	0x58, 
	0x58,	0x58,	0x58,	0x58,	0x58,	0x58,	0x7f,	0xb2, 
};
1990/1231    
	/* wr 3 */ 
	RxEna=		1, 
	Rx5bits=	0<<6, 
	Rx7bits=	1<<6, 
	Rx6bits=	2<<6, 
	Rx8bits=	3<<6,
1990/1223    
 
void 
duartinit(void) 
{ 
	Duart *duart;
1990/1231    
	/* wr 4 */ 
	SyncMode=	0<<2, 
	Rx1stop=	1<<2, 
	Rx1hstop=	2<<2, 
	Rx2stop=	3<<2, 
	X16=		1<<6,
1990/1223    
 
	duart  =  DUARTREG;
1990/1231    
	/* wr 5 */ 
	TxRTS=		1<<1, 
	TxEna=		1<<3, 
	TxBreak=	1<<4, 
	TxDTR=		1<<7, 
	Tx5bits=	0<<5, 
	Tx7bits=	1<<5, 
	Tx6bits=	2<<5, 
	Tx8bits=	3<<5,
1990/1223    
 
	/* 
	 * Keyboard 
	 */ 
	duart[0].cmnd = RESET_RCV|DIS_TX|DIS_RX; 
	duart[0].cmnd = RESET_TRANS; 
	duart[0].cmnd = RESET_ERR; 
	duart[0].cmnd = RESET_MR; 
	duart[0].mr1_2 = CHAR_ERR|PAR_ENB|EVEN_PAR|CBITS8; 
	duart[0].mr1_2 = NORM_OP|ONESTOPB; 
	duart[0].sr_csr = BD4800;
1990/1231    
	/* wr 9 */ 
	IntEna=		1<<3, 
	ResetB=		1<<6, 
	ResetA=		2<<6, 
	HardReset=	3<<6,
1990/1223    
 
	/* 
	 * RS232 
	 */ 
	duart[1].cmnd = RESET_RCV|DIS_TX|DIS_RX; 
	duart[1].cmnd = RESET_TRANS; 
	duart[1].cmnd = RESET_ERR; 
	duart[1].cmnd = RESET_MR; 
	duart[1].mr1_2 = CHAR_ERR|NO_PAR|CBITS8; 
	duart[1].mr1_2 = NORM_OP|ONESTOPB; 
	duart[1].sr_csr = BD9600;
1990/1231    
	/* wr 11 */ 
	TRxCOutBR=	2, 
	TxClockBR=	2<<3, 
	RxClockBR=	2<<5, 
	TRxCOI=		1<<2,
1990/1223    
 
	/* 
	 * Output port 
	 */ 
	duart[0].ipc_acr = duartacr = 0xB7;	/* allow change	of state interrupt */ 
	duart[1].ip_opcr = 0x00; 
	duart[1].scc_ropbc = 0xFF;	/* make sure the port is reset first */ 
	duart[1].scc_sopbc = 0x04;	/* dtr = 1, pp = 01 */ 
	duart[0].is_imr = duartimr = IM_IPC|IM_RRDYB|IM_XRDYB|IM_RRDYA|IM_XRDYA; 
	duart[0].cmnd = ENB_TX|ENB_RX;	/* enable TX and RX last */ 
	duart[1].cmnd = ENB_TX|ENB_RX;
1990/1231    
	/* wr 14 */ 
	BREna=		1, 
	BRSource=	2,
1990/1223    
 
	/* 
	 * Initialize keyboard 
	 */ 
	while (!(duart[0].sr_csr & (XMT_EMT|XMT_RDY))) 
		; 
	duart[0].data = 0x02; 
}
1990/1231    
	/* rr 0 */ 
	RxReady=	1, 
	TxReady=	1<<2, 
	RxDCD=		1<<3, 
	RxCTS=		1<<5, 
	RxBreak=	1<<7,
1990/1223    
 
int 
duartinputport(void)
1990/1231    
	/* rr 3 */ 
	ExtPendB=	1,	 
	TxPendB=	1<<1, 
	RxPendB=	1<<2, 
	ExtPendA=	1<<3,	 
	TxPendA=	1<<4, 
	RxPendA=	1<<5, 
}; 
 
typedef struct Z8530	Z8530; 
struct Z8530
1990/1223    
{ 
	Duart *duart = DUARTREG; 
	return duart[1].ip_opcr; 
} 
void 
duartbaud(int b)
1990/1231    
	uchar	ptrb; 
	uchar	dummy1; 
	uchar	datab; 
	uchar	dummy2; 
	uchar	ptra; 
	uchar	dummy3; 
	uchar	dataa; 
	uchar	dummy4; 
}; 
 
#define NDELIM 5 
typedef struct Duart	Duart; 
struct Duart
1990/1223    
{ 
	int x; 
	Duart *duart = DUARTREG;
1990/1231    
	QLock; 
	ushort	sticky[16];	/* sticky write register values */ 
	uchar	*ptr;		/* command/pointer register in Z8530 */ 
	uchar	*data;		/* data register in Z8530 */ 
}; 
Duart	duart[2];
1990/1223    
 
	x = 0;		/* set */ 
	switch(b){ 
	case 38400: 
		x = BD38400; 
		break; 
	case 19200: 
		x = BD19200; 
		break; 
	case 9600: 
		x = BD9600; 
		break; 
	case 4800: 
		x = BD4800; 
		break; 
	case 2400: 
		x = BD2400; 
		break; 
	case 1200: 
		x = BD1200; 
		break; 
	case 300: 
		x = BD300; 
		break; 
	default: 
		error(Ebadarg); 
	} 
	if(x & 0x0100) 
		duart[0].ipc_acr = duartacr |= 0x80; 
	else 
		duart[0].ipc_acr = duartacr &= ~0x80; 
	duart[1].sr_csr = x; 
}
1990/1231    
#define PRINTING	0x4 
#define MASK		0x1
1990/1223    
1990/1231    
/* 
 *  Access registers using the pointer in register 0. 
 */
1990/1223    
void 
duartdtr(int val)
1990/1231    
duartwrreg(Duart *dp, int addr, int value)
1990/1223    
{ 
	Duart *duart = DUARTREG; 
	if (val) 
		duart[1].scc_ropbc=0x01; 
	else 
		duart[1].scc_sopbc=0x01;
1990/1231    
	*dp->ptr = addr; 
	*dp->ptr = dp->sticky[addr] | value;
1990/1223    
} 
 
void 
duartbreak(int ms)
1990/1231    
ushort 
duartrdreg(Duart *dp, int addr)
1990/1223    
{ 
	static QLock brk; 
	Duart *duart = DUARTREG; 
	if (ms<=0 || ms >20000) 
		error(Ebadarg); 
	qlock(&brk); 
	duart[0].is_imr = duartimr &= ~IM_XRDYB; 
	duart[1].cmnd = STRT_BRK|ENB_TX; 
	tsleep(&u->p->sleep, return0, 0, ms); 
	duart[1].cmnd = STOP_BRK|ENB_TX; 
	duart[0].is_imr = duartimr |= IM_XRDYB; 
	qunlock(&brk);
1990/1231    
	*dp->ptr = addr; 
	return *dp->ptr;
1990/1223    
} 
 
enum{ 
	Kptime=200 
};
1990/1231    
/* 
 *  set the baud rate by calculating and setting the baudrate 
 *  generator constant.  This will work with fairly non-standard 
 *  baud rates. 
 */
1990/1223    
void 
duartstarttimer(void)
1990/1231    
duartsetbaud(Duart *dp, int rate)
1990/1223    
{ 
	Duart *duart; 
	char x;
1990/1231    
	int brconst;
1990/1223    
 
	duart = DUARTREG; 
	duart[0].ctur = (Kptime)>>8; 
	duart[0].ctlr = (Kptime)&255; 
	duart[0].is_imr = duartimr |= IM_CRDY; 
	x = duart[1].scc_sopbc;
1990/1231    
	brconst = 10000000/(16*2*rate) - 2; 
	duartwrreg(dp, 12, brconst & 0xff); 
	duartwrreg(dp, 13, (brconst>>8) & 0xff);
1990/1223    
}
1990/1231    
/* 
 * Initialize just keyboard and mouse for now 
 */
1990/1223    
void 
duartstoptimer(void)
1990/1231    
duartinit(void)
1990/1223    
{ 
	Duart *duart; 
	char x;
1990/1231    
	Duart *dp; 
	Z8530 *zp; 
	KMap *k;
1990/1223    
 
	duart = DUARTREG; 
	x = duart[1].scc_ropbc; 
	duart[0].is_imr = duartimr &= ~IM_CRDY; 
}
1990/1231    
	k = kmappa(KMDUART, PTEIO|PTENOCACHE); 
	zp = (Z8530*)k->va;
1990/1223    
 
void 
duartrs232intr(void) 
{ 
	int c; 
	Duart *duart;
1990/1231    
	/* 
	 *  get port addresses 
	 */ 
	duart[0].ptr = &zp->ptra; 
	duart[0].data = &zp->dataa; 
	duart[1].ptr = &zp->ptrb; 
	duart[1].data = &zp->datab;
1990/1223    
 
	duart = DUARTREG; 
	c = getrs232o(); 
	if(c == -1) 
		duart[1].cmnd = DIS_TX; 
	else 
		duart[1].data = c; 
}
1990/1231    
	for(dp=duart; dp < &duart[2]; dp++){ 
		memset(dp->sticky, 0, sizeof(dp->sticky));
1990/1223    
 
void 
duartstartrs232o(void) 
{ 
	DUARTREG[1].cmnd = ENB_TX; 
	duartrs232intr();
1990/1231    
		/* 
		 *  enable I/O, 8 bits/character 
		 */ 
		dp->sticky[3] = RxEna | Rx8bits; 
		duartwrreg(dp, 3, 0); 
		dp->sticky[5] = TxEna | Tx8bits; 
		duartwrreg(dp, 5, 0); 
 
		/* 
	 	 *  turn on interrupts 
		 */ 
		dp->sticky[1] |= TxIntEna | RxIntAllEna; 
		duartwrreg(dp, 1, 0); 
		dp->sticky[9] |= IntEna; 
		duartwrreg(dp, 9, 0); 
	} 
 
	/* 
	 *  turn on DTR and RTS 
	 */ 
	dp = &duart[1]; 
	dp->sticky[5] |= TxRTS | TxDTR; 
	duartwrreg(dp, 5, 0);
1990/1223    
} 
 
void 
duartintr(Ureg *ur)
1990/1231    
duartintr(void)
1990/1223    
{ 
	int cause, status, c; 
	Duart *duart;
1990/1231    
	char ch; 
	int cause; 
	Duart *dp;
1990/1223    
 
	duart = DUARTREG; 
	cause = duart->is_imr;
1990/1231    
	cause = duartrdreg(&duart[0], 3);
1990/1223    
	/* 
	 * I can guess your interrupt.
1990/1231    
	 * Keyboard
1990/1223    
	 */
1990/1231    
	dp = &duart[0]; 
	if(cause & ExtPendA) 
		duartwrreg(dp, 0, ResExtPend); 
	if(cause & RxPendA){ 
		ch = *dp->data; 
		kbdstate(ch); 
	} 
	if(cause & TxPendA) 
		duartwrreg(dp, 0, ResTxPend);
1990/1223    
	/* 
	 * Is it 0?
1990/1231    
	 * Mouse
1990/1223    
	 */ 
	if(cause & IM_CRDY){ 
		if(kprofp) 
			(*kprofp)(ur->pc); 
		c = duart[1].scc_ropbc; 
		duart[0].ctur = (Kptime)>>8; 
		duart[0].ctlr = (Kptime)&255; 
		c = duart[1].scc_sopbc;
1990/1231    
	dp = &duart[1]; 
	if(cause & ExtPendB) 
		duartwrreg(dp, 0, ResExtPend); 
	if(cause & RxPendB){ 
		ch = *dp->data; 
		mousechar(ch); 
	} 
	if(cause & TxPendB) 
		duartwrreg(dp, 0, ResTxPend); 
} 
 
/* 
 * Map is indexed by keyboard char, output is ASCII 
 */ 
uchar keymap[128] = { 
/*	00    L1    02    L2    04    F1    F2    07	*/ 
	0xFF, 0x80, 0xFF, 0x81, 0xFF, 0x82, 0x83, 0xFF, 
/*	F3    09    F4    0b    F5    0d    F6    0f  	*/ 
	0x84, 0xFF, 0x85, 0xFF, 0x86, 0xFF, 0x87, 0xFF, 
/*	F7    F8    F9    Alt   14    R1    R2    R3	*/ 
	0x88, 0x89, 0x8a, 0x8b, 0xFF, 0x8c, 0x8d, 0x8e, 
/*	18    L3    L4    1b    1c    Esc   1     2	*/ 
	0xFF, 0x8f, 0x90, 0xFF, 0xFF, 0x1b, '1',  '2', 
/*	3     4     5     6     7     8     9     0	*/ 
	'3',  '4',  '5',  '6',  '7',  '8',  '9',  '0', 
/*	-     =     `     bs    2c    R4    R5    R6	*/ 
	'-',  '=',  '`',  '\b', 0xFF, 0x91, 0x92, 0x93, 
/*	30    L5    L6    33    34    tab   q     w  	*/ 
	0xFF, 0x94, 0x95, 0xFF, 0xFF, '\t', 'q',  'w', 
/*	e     r     t     y     u     i     o     p    	*/ 
	'e',  'r',  't',  'y',  'u',  'i',  'o',  'p', 
/*	[     ]     del   43    R7    R8    R9    47   	*/ 
	'[',  ']',  0x7F, 0xFF, 0x96, 0x97, 0x98, 0xFF, 
/*	L7    L8    4a    4b    ctrl  a     s     d	*/ 
	0x99, 0x9a, 0xFF, 0xFF, 0xF0, 'a',  's',  'd', 
/*	f     g     h     j     k     l     ;     '   	*/ 
	'f',  'g',  'h',  'j',  'k',  'l',  ';',  '\'', 
/*	\     ret   5a    R10   R11   R12   5e    L9	*/ 
	'\\', '\n', 0xFF, 0x9b, 0x9c, 0x9d, 0xFF, 0x9e,  
/*	60    L10   62    shift z     x     c     v	*/ 
	0xFF, 0x9f, 0xFF, 0xF1, 'z',  'x',  'c', 'v', 
/*	b     n     m     ,     .     /     shift lf	*/ 
	'b',  'n',  'm',  ',',  '.',  '/',  0xF1, '\r', 
/*	R13   R14   R15   73    74    75    76    caps	*/ 
	0xA0, 0xA1, 0xA2, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 
/*	left  79    right 7b    7c    7d    7e    7f	*/ 
	0xA3, ' ',  0xA4, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
}; 
 
uchar keymapshift[128] = { 
/*	00    L1    02    L2    04    F1    F2    07	*/ 
	0xFF, 0x80, 0xFF, 0x81, 0xFF, 0x82, 0x83, 0xFF, 
/*	F3    09    F4    0b    F5    0d    F6    0f  	*/ 
	0x84, 0xFF, 0x85, 0xFF, 0x86, 0xFF, 0x87, 0xFF, 
/*	F7    F8    F9    Alt   14    R1    R2    R3	*/ 
	0x88, 0x89, 0x8a, 0x8b, 0xFF, 0x8c, 0x8d, 0x8e, 
/*	18    L3    L4    1b    1c    Esc   1     2	*/ 
	0xFF, 0x8f, 0x90, 0xFF, 0xFF, 0x1b, '!',  '@', 
/*	3     4     5     6     7     8     9     0	*/ 
	'#',  '$',  '%',  '^',  '&',  '*',  '(',  ')', 
/*	-     =     `     bs    2c    R4    R5    R6	*/ 
	'_',  '+',  '~',  '\b', 0xFF, 0x91, 0x92, 0x93, 
/*	30    L5    L6    33    34    tab   q     w  	*/ 
	0xFF, 0x94, 0x95, 0xFF, 0xFF, '\t', 'Q',  'W', 
/*	e     r     t     y     u     i     o     p    	*/ 
	'E',  'R',  'T',  'Y',  'U',  'I',  'O',  'P', 
/*	[     ]     del   43    R7    R8    R9    47   	*/ 
	'{',  '}',  0x7F, 0xFF, 0x96, 0x97, 0x98, 0xFF, 
/*	L7    L8    4a    4b    ctrl  a     s     d	*/ 
	0x99, 0x9a, 0xFF, 0xFF, 0xF0, 'A',  'S',  'D', 
/*	f     g     h     j     k     l     ;     '   	*/ 
	'F',  'G',  'H',  'J',  'K',  'L',  ':',  '"', 
/*	\     ret   5a    R10   R11   R12   5e    L9	*/ 
	'|', '\n',  0xFF, 0x9b, 0x9c, 0x9d, 0xFF, 0x9e,  
/*	60    L10   62    shift z     x     c     v	*/ 
	0xFF, 0x9f, 0xFF, 0xF1, 'Z',  'X',  'C', 'V', 
/*	b     n     m     ,     .     /     shift lf	*/ 
	'B',  'N',  'M',  '<',  '>',  '?',  0xF1, '\r', 
/*	R13   R14   R15   73    74    75    76    caps	*/ 
	0xA0, 0xA1, 0xA2, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 
/*	left  79    right 7b    7c    7d    7e    7f	*/ 
	0xA3, ' ',  0xA4, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
}; 
 
uchar keymapctrl[128] = { 
/*	00    L1    02    L2    04    F1    F2    07	*/ 
	0xFF, 0x80, 0xFF, 0x81, 0xFF, 0x82, 0x83, 0xFF, 
/*	F3    09    F4    0b    F5    0d    F6    0f  	*/ 
	0x84, 0xFF, 0x85, 0xFF, 0x86, 0xFF, 0x87, 0xFF, 
/*	F7    F8    F9    Alt   14    R1    R2    R3	*/ 
	0x88, 0x89, 0x8a, 0x8b, 0xFF, 0x8c, 0x8d, 0x8e, 
/*	18    L3    L4    1b    1c    Esc   1     2	*/ 
	0xFF, 0x8f, 0x90, 0xFF, 0xFF, 0x1b, '!',  '@', 
/*	3     4     5     6     7     8     9     0	*/ 
	'#',  '$',  '%',  '^',  '&',  '*',  '(',  ')', 
/*	-     =     `     bs    2c    R4    R5    R6	*/ 
	'_',  '+',  '~', '\b', 0xFF, 0x91, 0x92, 0x93, 
/*	30    L5    L6    33    34    tab   q     w  	*/ 
	0xFF, 0x94, 0x95, 0xFF, 0xFF, '\t', 0x11, 0x17, 
/*	e     r     t     y     u     i     o     p    	*/ 
	0x05, 0x12, 0x14, 0x19, 0x15, 0x09, 0x0F, 0x10, 
/*	[     ]     del   43    R7    R8    R9    47   	*/ 
	0x1B, 0x1D, 0x7F, 0xFF, 0x96, 0x97, 0x98, 0xFF, 
/*	L7    L8    4a    4b    ctrl  a     s     d	*/ 
	0x99, 0x9a, 0xFF, 0xFF, 0xF0, 0x01, 0x13, 0x04, 
/*	f     g     h     j     k     l     ;     '   	*/ 
	0x06, 0x07, 0x08, 0x0A, 0x0B, 0x0C,':',  '"', 
/*	\     ret   5a    R10   R11   R12   5e    L9	*/ 
	0x1C, '\n',  0xFF, 0x9b, 0x9c, 0x9d, 0xFF, 0x9e,  
/*	60    L10   62    shift z     x     c     v	*/ 
	0xFF, 0x9f, 0xFF, 0xF1, 0x1A, 0x18, 0x03, 0x16, 
/*	b     n     m     ,     .     /     shift lf	*/ 
	0x02, 0x0E, 0x0D, '<',  '>',  '?',  0xF1, '\r', 
/*	R13   R14   R15   73    74    75    76    caps	*/ 
	0xA0, 0xA1, 0xA2, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 
/*	left  79    right 7b    7c    7d    7e    7f	*/ 
	0xA3, ' ',  0xA4, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
}; 
 
uchar keymapshiftctrl[128] = { 
/*	00    L1    02    L2    04    F1    F2    07	*/ 
	0xFF, 0x80, 0xFF, 0x81, 0xFF, 0x82, 0x83, 0xFF, 
/*	F3    09    F4    0b    F5    0d    F6    0f  	*/ 
	0x84, 0xFF, 0x85, 0xFF, 0x86, 0xFF, 0x87, 0xFF, 
/*	F7    F8    F9    Alt   14    R1    R2    R3	*/ 
	0x88, 0x89, 0x8a, 0x8b, 0xFF, 0x8c, 0x8d, 0x8e, 
/*	18    L3    L4    1b    1c    Esc   1     2	*/ 
	0xFF, 0x8f, 0x90, 0xFF, 0xFF, 0x1b, '!',  0x00, 
/*	3     4     5     6     7     8     9     0	*/ 
	'#',  '$',  '%',  0x1E, '&',  '*',  '(',  ')', 
/*	-     =     `     bs    2c    R4    R5    R6	*/ 
	0x1F, '+',  '~', '\b', 0xFF, 0x91, 0x92, 0x93, 
/*	30    L5    L6    33    34    tab   q     w  	*/ 
	0xFF, 0x94, 0x95, 0xFF, 0xFF, '\t', 0x11, 0x17, 
/*	e     r     t     y     u     i     o     p    	*/ 
	0x05, 0x12, 0x14, 0x19, 0x15, 0x09, 0x0F, 0x10, 
/*	[     ]     del   43    R7    R8    R9    47   	*/ 
	0x1B, 0x1D, 0x7F, 0xFF, 0x96, 0x97, 0x98, 0xFF, 
/*	L7    L8    4a    4b    ctrl  a     s     d	*/ 
	0x99, 0x9a, 0xFF, 0xFF, 0xF0, 0x01, 0x13, 0x04, 
/*	f     g     h     j     k     l     ;     '   	*/ 
	0x06, 0x07, 0x08, 0x0A, 0x0B, 0x0C,':',  '"', 
/*	\     ret   5a    R10   R11   R12   5e    L9	*/ 
	0x1C, '\n',  0xFF, 0x9b, 0x9c, 0x9d, 0xFF, 0x9e,  
/*	60    L10   62    shift z     x     c     v	*/ 
	0xFF, 0x9f, 0xFF, 0xF1, 0x1A, 0x18, 0x03, 0x16, 
/*	b     n     m     ,     .     /     shift lf	*/ 
	0x02, 0x0E, 0x0D, '<',  '>',  '?',  0xF1, '\r', 
/*	R13   R14   R15   73    74    75    76    caps	*/ 
	0xA0, 0xA1, 0xA2, 0xFF, 0xFF, 0xFF, 0xFF, 0xF2, 
/*	left  79    right 7b    7c    7d    7e    7f	*/ 
	0xA3, ' ',  0xA4, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
}; 
 
static uchar *kbdmap[4] = { 
	keymap, 
	keymapshift, 
	keymapctrl, 
	keymapshiftctrl 
}; 
 
void 
kbdstate(int c) 
{ 
	static shift = 0x00; 
	static caps = 0; 
	static repeatc = -1; 
	static long startclick; 
	int tc; 
 
	tc = kbdmap[shift][c&0x7F]; 
 
/* 
	if(c==0xFFFF && repeatc!=-1 && clicks>startclick+40 && (clicks-startclick)%3==0){ 
		kbdc = repeatc;
1990/1223    
		return; 
	} 
	/* 
	 * Is it 1? 
	 */ 
	if(cause & IM_RRDYA){		/* keyboard input */ 
		status = duart->sr_csr; 
		c = duart->data; 
		if(status & (FRM_ERR|OVR_ERR|PAR_ERR)) 
			duart->cmnd = RESET_ERR; 
		if(status & PAR_ERR) /* control word: caps lock (0x4) or repeat (0x10) */ 
			kbdrepeat((c&0x10) == 0); 
		else{ 
			if(c == 0x7F) 
				c = 0xFF;	/* VIEW key (bizarre) */ 
			if(c & 0x80) 
				c = keymap[c&0x7F]; 
			kbdchar(c);
1990/1231    
*/ 
	if(c==0x7F){	/* all keys up */ 
		repeatc = -1; 
		return; 
	} 
	if(tc == 0xFF)	/* shouldn't happen; ignore */ 
		return; 
	if(c & 0x80){	/* key went up */ 
		if(tc == 0xF0){		/* control */ 
			shift &= ~2; 
			repeatc =- 1; 
			return;
1990/1223    
		}
1990/1231    
		if(tc == 0xF1){	/* shift */ 
			shift &= ~1; 
			repeatc = -1; 
			return; 
		} 
		if(tc == 0xF2){	/* caps */ 
			repeatc = -1; 
			return; 
		} 
		if(tc == repeatc) 
			repeatc = -1; 
		return;
1990/1223    
	} 
	/* 
	 * Is it 2? 
	 */ 
	if(cause & IM_RRDYB){		/* rs232 input */ 
		status = duart[1].sr_csr; 
		c = duart[1].data; 
		if(status & (FRM_ERR|OVR_ERR|PAR_ERR)) 
			duart[1].cmnd = RESET_ERR; 
		else 
			rs232ichar(c);
1990/1231    
	if(tc == 0xF0){		/* control */ 
		shift |= 2; 
		repeatc = -1; 
		return;
1990/1223    
	} 
	/* 
	 * Is it 3? 
	 */ 
	if(cause & IM_XRDYB)		/* rs232 output */ 
		duartrs232intr(); 
	/* 
	 * Is it 4? 
	 */ 
	if(cause & IM_XRDYA) 
		duart[0].cmnd = DIS_TX; 
	/* 
	 * Is it 5? 
	 */ 
	if(cause & IM_IPC) 
		mousebuttons((~duart[0].ipc_acr) & 7);
1990/1231    
	if(tc==0xF1){	/* shift */ 
		shift |= 1; 
		repeatc = -1; 
		return; 
	} 
	if(tc==0xF2){	/* caps */ 
		caps ^= 1; 
		repeatc =- 1; 
		return; 
	} 
	if(caps && 'a'<=tc && tc<='z') 
		tc |= ' '; 
	repeatc = tc; 
/* 
	startclick = clicks; 
*/ 
	if(tc == 0x10)		/* ctrl-p */ 
		reset(); 
	kbdchar(tc);
1990/1223    
}


source code copyright © 1990-2005 Lucent Technologies; see license
Plan 9 distribution
comments to russ cox (rsc@swtch.com)