kbd_ttyscan.c

开放源码实时操作系统源码.

				case 0x68:            /* Page-Up	*/
					scancode -= 0x5;
					break;

				case 0x6f:            /* Delete		*/
				case 0x6b:            /* End		*/
				case 0x6d:            /* Page-Down	*/
					scancode -= 0x4;
					break;
				
				case 0x67:            /* Up arrow	*/
				case 0x69:            /* Left arrow	*/
					scancode -= 0x5;
					break;
				
				case 0x6a:            /* Right arrow	*/
				case 0x6c:            /* Down arrow	*/
					scancode -= 0x4;
					break;

				default: 
					break;
			}
			break;
		}	
		*kbuf = mwkey;
		*modifiers = key_modstate;
		*pscancode = scancode;

		/**if(pressed) {
			printf("Returning: mwkey: 0x%04x, mods: 0x%x,
				sc:0x%04x\n\n", *kbuf, *modifiers, *pscancode);
		}**/
		return pressed ? 1 : 2;
	}

	if ((cc < 0) && (errno != EINTR) && (errno != EAGAIN))
		return -1;
	return 0;
}

/* Update the internal keyboard state, return TRUE if changed*/
static MWBOOL
UpdateKeyState(int pressed, MWKEY mwkey)
{
	MWKEYMOD modstate = key_modstate;

	//printf("UpdateKeyState %02x %02x\n", pressed, mwkey);
	if (pressed == PRESSED) {
		switch (mwkey) {
		case MWKEY_NUMLOCK:
		case MWKEY_CAPSLOCK:
			/* change state on release because of auto-repeat*/
			return FALSE;
		case MWKEY_LCTRL:
			modstate |= MWKMOD_LCTRL;
			break;
		case MWKEY_RCTRL:
			modstate |= MWKMOD_RCTRL;
			break;
		case MWKEY_LSHIFT:
			modstate |= MWKMOD_LSHIFT;
			break;
		case MWKEY_RSHIFT:
			modstate |= MWKMOD_RSHIFT;
			break;
		case MWKEY_LALT:
			modstate |= MWKMOD_LALT;
			break;
		case MWKEY_RALT:
			modstate |= MWKMOD_RALT;
			break;
		case MWKEY_LMETA:
			modstate |= MWKMOD_LMETA;
			break;
		case MWKEY_RMETA:
			modstate |= MWKMOD_RMETA;
			break;
		case MWKEY_ALTGR:
			modstate |= MWKMOD_ALTGR;
			break;
		default:
			break;
		}
	} else {
		switch (mwkey) {
		case MWKEY_NUMLOCK:
			key_modstate ^= MWKMOD_NUM;
			key_state[MWKEY_NUMLOCK] ^= PRESSED;
			UpdateLEDState(key_modstate);
			return TRUE;
		case MWKEY_CAPSLOCK:
			key_modstate ^= MWKMOD_CAPS;
			key_state[MWKEY_CAPSLOCK] ^= PRESSED;
			UpdateLEDState(key_modstate);
			return TRUE;
		case MWKEY_LCTRL:
			modstate &= ~MWKMOD_LCTRL;
			break;
		case MWKEY_RCTRL:
			modstate &= ~MWKMOD_RCTRL;
			break;
		case MWKEY_LSHIFT:
			modstate &= ~MWKMOD_LSHIFT;
			break;
		case MWKEY_RSHIFT:
			modstate &= ~MWKMOD_RSHIFT;
			break;
		case MWKEY_LALT:
			modstate &= ~MWKMOD_LALT;
			break;
		case MWKEY_RALT:
			modstate &= ~MWKMOD_RALT;
			break;
		case MWKEY_LMETA:
			modstate &= ~MWKMOD_LMETA;
			break;
		case MWKEY_RMETA:
			modstate &= ~MWKMOD_RMETA;
			break;
		case MWKEY_ALTGR:
			modstate &= ~MWKMOD_ALTGR;
			break;
		default:
			break;
		}
	}

#if 0
	/* Drop events that don't change state */
	if (key_state[mwkey] == pressed)
		return FALSE;
#endif
	/* Update internal keyboard state */
	key_state[mwkey] = (unsigned char)pressed;
	key_modstate = modstate;
	return TRUE;
}

static void
UpdateLEDState(MWKEYMOD modstate)
{
	int	ledstate = 0;

	if (modstate & MWKMOD_CAPS)
		ledstate |= LED_CAP;
	if (modstate & MWKMOD_NUM)
		ledstate |= LED_NUM;
	ioctl(fd, KDSETLED, ledstate);
}

/* translate a scancode and modifier state to an MWKEY*/
static MWKEY
TranslateScancode(int scancode, MWKEYMOD modstate)
{
	unsigned short	mwkey = 0;
	int		map = 0;

	//printf("Translate: 0x%04x\n", scancode);

	/* determine appropriate kernel table*/
	if (modstate & MWKMOD_SHIFT)
		map |= (1<<KG_SHIFT);
	if (modstate & MWKMOD_CTRL)
		map |= (1<<KG_CTRL);
	if (modstate & MWKMOD_ALT)
		map |= (1<<KG_ALT);
	if (modstate & MWKMOD_ALTGR)
		map |= (1<<KG_ALTGR);
	if (KTYP(os_keymap[map][scancode]) == KT_LETTER) {
		if (modstate & MWKMOD_CAPS)
			map |= (1<<KG_SHIFT);
	}
	if (KTYP(os_keymap[map][scancode]) == KT_PAD) {
		if (modstate & MWKMOD_NUM) {
			switch (keymap[scancode]) {
			case MWKEY_KP0:
			case MWKEY_KP1:
			case MWKEY_KP2:
			case MWKEY_KP3:
			case MWKEY_KP4:
			case MWKEY_KP5:
			case MWKEY_KP6:
			case MWKEY_KP7:
			case MWKEY_KP8:
			case MWKEY_KP9:
				mwkey = keymap[scancode] - MWKEY_KP0 + '0';
				break;
			case MWKEY_KP_PERIOD:
				mwkey = '.';
				break;
			case MWKEY_KP_DIVIDE:
				mwkey = '/';
				break;
			case MWKEY_KP_MULTIPLY:
				mwkey = '*';
				break;
			case MWKEY_KP_MINUS:
				mwkey = '-';
				break;
			case MWKEY_KP_PLUS:
				mwkey = '+';
				break;
			case MWKEY_KP_ENTER:
				mwkey = MWKEY_ENTER;
				break;
			case MWKEY_KP_EQUALS:
				mwkey = '-';
				break;
			}
		}
	} else
		mwkey = KVAL(os_keymap[map][scancode]);
	
	if (!mwkey)
		mwkey = keymap[scancode];

	/* perform additional translations*/
	switch (mwkey) {
	case 127:
		mwkey = MWKEY_BACKSPACE;
		break;
	case MWKEY_BREAK:
	case MWKEY_PAUSE:
		mwkey = MWKEY_QUIT;
		break;
	case 0x1c:	/* kernel maps print key to ctrl-\ */
	case MWKEY_SYSREQ:
		mwkey = MWKEY_PRINT;
		break;
	}

	/* printf("TranslateScancode %02x to mwkey %d\n", scancode, mwkey); */
	return mwkey;
}

/* load Linux keyboard mappings, used as first try for scancode conversion*/
static void
LoadKernelKeymaps(int fd)
{
	int 		map, i;
	struct kbentry 	entry;

	/* Load all the keysym mappings */
	for (map=0; map<NUM_VGAKEYMAPS; ++map) {
		memset(os_keymap[map], 0, NR_KEYS*sizeof(unsigned short));
		for (i=0; i<NR_KEYS; ++i) {
			entry.kb_table = map;
			entry.kb_index = i;
			if (ioctl(fd, KDGKBENT, &entry) == 0) {
				/* change K_ENTER to \r*/
				if (entry.kb_value == K_ENTER)
					entry.kb_value = K(KT_ASCII,13);

				if ((KTYP(entry.kb_value) == KT_LATIN) ||
				    (KTYP(entry.kb_value) == KT_ASCII) ||
				    (KTYP(entry.kb_value) == KT_PAD) ||
				    (KTYP(entry.kb_value) == KT_LETTER)
				    )
					os_keymap[map][i] = entry.kb_value;
			}
		}
	}

}
/* Handle switching to another VC, returns when our VC is back */
static MWBOOL
switch_vt(unsigned short which)
{
	struct vt_stat vtstate;
	unsigned short current;
	static unsigned short r[16], g[16], b[16];

	/* Figure out whether or not we're switching to a new console */
	if ((ioctl(fd, VT_GETSTATE, &vtstate) < 0) ||
	    (which == vtstate.v_active)) {
		return FALSE;
	}
	current = vtstate.v_active;

	/* save palette, goto text mode*/
	ioctl_getpalette(0, 16, r, g, b);
	ioctl(fd, KDSETMODE, KD_TEXT);

	/* New console, switch to it */
	if (ioctl(fd, VT_ACTIVATE, which) == 0) {
		/* Wait for our console to be activated again */
		ioctl(fd, VT_WAITACTIVE, which);
		while (ioctl(fd, VT_WAITACTIVE, current) < 0) {
			if ((errno != EINTR) && (errno != EAGAIN)) {
				/* Unknown VT error, cancel*/
				break;
			}
			usleep(100000);
		}
	}

	/* Restore graphics mode and the contents of the screen */
	ioctl(fd, KDSETMODE, KD_GRAPHICS);
	ioctl_setpalette(0, 16, r, g, b);
	return TRUE;
}