Home | History | Annotate | Download | only in ps2gs
      1 /*
      2     SDL - Simple DirectMedia Layer
      3     Copyright (C) 1997-2012 Sam Lantinga
      4 
      5     This library is free software; you can redistribute it and/or
      6     modify it under the terms of the GNU Lesser General Public
      7     License as published by the Free Software Foundation; either
      8     version 2.1 of the License, or (at your option) any later version.
      9 
     10     This library is distributed in the hope that it will be useful,
     11     but WITHOUT ANY WARRANTY; without even the implied warranty of
     12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     13     Lesser General Public License for more details.
     14 
     15     You should have received a copy of the GNU Lesser General Public
     16     License along with this library; if not, write to the Free Software
     17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
     18 
     19     Sam Lantinga
     20     slouken (at) libsdl.org
     21 */
     22 #include "SDL_config.h"
     23 
     24 /* Handle the event stream, converting console events into SDL events */
     25 
     26 #include <sys/types.h>
     27 #include <sys/time.h>
     28 #include <sys/ioctl.h>
     29 #include <unistd.h>
     30 #include <fcntl.h>
     31 #include <errno.h>
     32 #include <limits.h>
     33 
     34 /* For parsing /proc */
     35 #include <dirent.h>
     36 #include <ctype.h>
     37 
     38 #include <linux/vt.h>
     39 #include <linux/kd.h>
     40 #include <linux/keyboard.h>
     41 
     42 #include "SDL_mutex.h"
     43 #include "../SDL_sysvideo.h"
     44 #include "../../events/SDL_sysevents.h"
     45 #include "../../events/SDL_events_c.h"
     46 #include "SDL_gsvideo.h"
     47 #include "SDL_gsevents_c.h"
     48 #include "SDL_gskeys.h"
     49 
     50 #ifndef GPM_NODE_FIFO
     51 #define GPM_NODE_FIFO	"/dev/gpmdata"
     52 #endif
     53 
     54 /* The translation tables from a console scancode to a SDL keysym */
     55 #define NUM_VGAKEYMAPS	(1<<KG_CAPSSHIFT)
     56 static Uint16 vga_keymap[NUM_VGAKEYMAPS][NR_KEYS];
     57 static SDLKey keymap[128];
     58 static Uint16 keymap_temp[128]; /* only used at startup */
     59 static SDL_keysym *TranslateKey(int scancode, SDL_keysym *keysym);
     60 
     61 /* Ugh, we have to duplicate the kernel's keysym mapping code...
     62    Oh, it's not so bad. :-)
     63 
     64    FIXME: Add keyboard LED handling code
     65  */
     66 static void GS_vgainitkeymaps(int fd)
     67 {
     68 	struct kbentry entry;
     69 	int map, i;
     70 
     71 	/* Don't do anything if we are passed a closed keyboard */
     72 	if ( fd < 0 ) {
     73 		return;
     74 	}
     75 
     76 	/* Load all the keysym mappings */
     77 	for ( map=0; map<NUM_VGAKEYMAPS; ++map ) {
     78 		SDL_memset(vga_keymap[map], 0, NR_KEYS*sizeof(Uint16));
     79 		for ( i=0; i<NR_KEYS; ++i ) {
     80 			entry.kb_table = map;
     81 			entry.kb_index = i;
     82 			if ( ioctl(fd, KDGKBENT, &entry) == 0 ) {
     83 				/* fill keytemp. This replaces SDL_fbkeys.h */
     84 				if ( (map == 0) && (i<128) ) {
     85 					keymap_temp[i] = entry.kb_value;
     86 				}
     87 				/* The "Enter" key is a special case */
     88 				if ( entry.kb_value == K_ENTER ) {
     89 					entry.kb_value = K(KT_ASCII,13);
     90 				}
     91 				/* Handle numpad specially as well */
     92 				if ( KTYP(entry.kb_value) == KT_PAD ) {
     93 					switch ( entry.kb_value ) {
     94 					case K_P0:
     95 					case K_P1:
     96 					case K_P2:
     97 					case K_P3:
     98 					case K_P4:
     99 					case K_P5:
    100 					case K_P6:
    101 					case K_P7:
    102 					case K_P8:
    103 					case K_P9:
    104 						vga_keymap[map][i]=entry.kb_value;
    105 						vga_keymap[map][i]+= '0';
    106 						break;
    107 										case K_PPLUS:
    108 						vga_keymap[map][i]=K(KT_ASCII,'+');
    109 						break;
    110 										case K_PMINUS:
    111 						vga_keymap[map][i]=K(KT_ASCII,'-');
    112 						break;
    113 										case K_PSTAR:
    114 						vga_keymap[map][i]=K(KT_ASCII,'*');
    115 						break;
    116 										case K_PSLASH:
    117 						vga_keymap[map][i]=K(KT_ASCII,'/');
    118 						break;
    119 										case K_PENTER:
    120 						vga_keymap[map][i]=K(KT_ASCII,'\r');
    121 						break;
    122 										case K_PCOMMA:
    123 						vga_keymap[map][i]=K(KT_ASCII,',');
    124 						break;
    125 										case K_PDOT:
    126 						vga_keymap[map][i]=K(KT_ASCII,'.');
    127 						break;
    128 					default:
    129 						break;
    130 					}
    131 				}
    132 				/* Do the normal key translation */
    133 				if ( (KTYP(entry.kb_value) == KT_LATIN) ||
    134 					 (KTYP(entry.kb_value) == KT_ASCII) ||
    135 					 (KTYP(entry.kb_value) == KT_LETTER) ) {
    136 					vga_keymap[map][i] = entry.kb_value;
    137 				}
    138 			}
    139 		}
    140 	}
    141 }
    142 
    143 int GS_InGraphicsMode(_THIS)
    144 {
    145 	return((keyboard_fd >= 0) && (saved_kbd_mode >= 0));
    146 }
    147 
    148 int GS_EnterGraphicsMode(_THIS)
    149 {
    150 	struct termios keyboard_termios;
    151 
    152 	/* Set medium-raw keyboard mode */
    153 	if ( (keyboard_fd >= 0) && !GS_InGraphicsMode(this) ) {
    154 
    155 		/* Switch to the correct virtual terminal */
    156 		if ( current_vt > 0 ) {
    157 			struct vt_stat vtstate;
    158 
    159 			if ( ioctl(keyboard_fd, VT_GETSTATE, &vtstate) == 0 ) {
    160 				saved_vt = vtstate.v_active;
    161 			}
    162 			if ( ioctl(keyboard_fd, VT_ACTIVATE, current_vt) == 0 ) {
    163 				ioctl(keyboard_fd, VT_WAITACTIVE, current_vt);
    164 			}
    165 		}
    166 
    167 		/* Set the terminal input mode */
    168 		if ( tcgetattr(keyboard_fd, &saved_kbd_termios) < 0 ) {
    169 			SDL_SetError("Unable to get terminal attributes");
    170 			if ( keyboard_fd > 0 ) {
    171 				close(keyboard_fd);
    172 			}
    173 			keyboard_fd = -1;
    174 			return(-1);
    175 		}
    176 		if ( ioctl(keyboard_fd, KDGKBMODE, &saved_kbd_mode) < 0 ) {
    177 			SDL_SetError("Unable to get current keyboard mode");
    178 			if ( keyboard_fd > 0 ) {
    179 				close(keyboard_fd);
    180 			}
    181 			keyboard_fd = -1;
    182 			return(-1);
    183 		}
    184 		keyboard_termios = saved_kbd_termios;
    185 		keyboard_termios.c_lflag &= ~(ICANON | ECHO | ISIG);
    186 		keyboard_termios.c_iflag &= ~(ISTRIP | IGNCR | ICRNL | INLCR | IXOFF | IXON);
    187 		keyboard_termios.c_cc[VMIN] = 0;
    188 		keyboard_termios.c_cc[VTIME] = 0;
    189 		if (tcsetattr(keyboard_fd, TCSAFLUSH, &keyboard_termios) < 0) {
    190 			GS_CloseKeyboard(this);
    191 			SDL_SetError("Unable to set terminal attributes");
    192 			return(-1);
    193 		}
    194 		/* This will fail if we aren't root or this isn't our tty */
    195 		if ( ioctl(keyboard_fd, KDSKBMODE, K_MEDIUMRAW) < 0 ) {
    196 			GS_CloseKeyboard(this);
    197 			SDL_SetError("Unable to set keyboard in raw mode");
    198 			return(-1);
    199 		}
    200 		if ( ioctl(keyboard_fd, KDSETMODE, KD_GRAPHICS) < 0 ) {
    201 			GS_CloseKeyboard(this);
    202 			SDL_SetError("Unable to set keyboard in graphics mode");
    203 			return(-1);
    204 		}
    205 	}
    206 	return(keyboard_fd);
    207 }
    208 
    209 void GS_LeaveGraphicsMode(_THIS)
    210 {
    211 	if ( GS_InGraphicsMode(this) ) {
    212 		ioctl(keyboard_fd, KDSETMODE, KD_TEXT);
    213 		ioctl(keyboard_fd, KDSKBMODE, saved_kbd_mode);
    214 		tcsetattr(keyboard_fd, TCSAFLUSH, &saved_kbd_termios);
    215 		saved_kbd_mode = -1;
    216 
    217 		/* Head back over to the original virtual terminal */
    218 		if ( saved_vt > 0 ) {
    219 			ioctl(keyboard_fd, VT_ACTIVATE, saved_vt);
    220 		}
    221 	}
    222 }
    223 
    224 void GS_CloseKeyboard(_THIS)
    225 {
    226 	if ( keyboard_fd >= 0 ) {
    227 		GS_LeaveGraphicsMode(this);
    228 		if ( keyboard_fd > 0 ) {
    229 			close(keyboard_fd);
    230 		}
    231 	}
    232 	keyboard_fd = -1;
    233 }
    234 
    235 int GS_OpenKeyboard(_THIS)
    236 {
    237 	/* Open only if not already opened */
    238  	if ( keyboard_fd < 0 ) {
    239 		char *tty0[] = { "/dev/tty0", "/dev/vc/0", NULL };
    240 		char *vcs[] = { "/dev/vc/%d", "/dev/tty%d", NULL };
    241 		int i, tty0_fd;
    242 
    243 		/* Try to query for a free virtual terminal */
    244 		tty0_fd = -1;
    245 		for ( i=0; tty0[i] && (tty0_fd < 0); ++i ) {
    246 			tty0_fd = open(tty0[i], O_WRONLY, 0);
    247 		}
    248 		if ( tty0_fd < 0 ) {
    249 			tty0_fd = dup(0); /* Maybe stdin is a VT? */
    250 		}
    251 		ioctl(tty0_fd, VT_OPENQRY, &current_vt);
    252 		close(tty0_fd);
    253 		if ( (geteuid() == 0) && (current_vt > 0) ) {
    254 			for ( i=0; vcs[i] && (keyboard_fd < 0); ++i ) {
    255 				char vtpath[12];
    256 
    257 				SDL_snprintf(vtpath, SDL_arraysize(vtpath), vcs[i], current_vt);
    258 				keyboard_fd = open(vtpath, O_RDWR, 0);
    259 #ifdef DEBUG_KEYBOARD
    260 				fprintf(stderr, "vtpath = %s, fd = %d\n",
    261 					vtpath, keyboard_fd);
    262 #endif /* DEBUG_KEYBOARD */
    263 
    264 				/* This needs to be our controlling tty
    265 				   so that the kernel ioctl() calls work
    266 				*/
    267 				if ( keyboard_fd >= 0 ) {
    268 					tty0_fd = open("/dev/tty", O_RDWR, 0);
    269 					if ( tty0_fd >= 0 ) {
    270 						ioctl(tty0_fd, TIOCNOTTY, 0);
    271 						close(tty0_fd);
    272 					}
    273 				}
    274 			}
    275 		}
    276  		if ( keyboard_fd < 0 ) {
    277 			/* Last resort, maybe our tty is a usable VT */
    278 			current_vt = 0;
    279 			keyboard_fd = open("/dev/tty", O_RDWR);
    280  		}
    281 #ifdef DEBUG_KEYBOARD
    282 		fprintf(stderr, "Current VT: %d\n", current_vt);
    283 #endif
    284  		saved_kbd_mode = -1;
    285 
    286 		/* Make sure that our input is a console terminal */
    287 		{ int dummy;
    288 		  if ( ioctl(keyboard_fd, KDGKBMODE, &dummy) < 0 ) {
    289 			close(keyboard_fd);
    290 			keyboard_fd = -1;
    291 			SDL_SetError("Unable to open a console terminal");
    292 		  }
    293 		}
    294 
    295 		/* Set up keymap */
    296 		GS_vgainitkeymaps(keyboard_fd);
    297  	}
    298  	return(keyboard_fd);
    299 }
    300 
    301 static enum {
    302 	MOUSE_NONE = -1,
    303 	MOUSE_GPM,	/* Note: GPM uses the MSC protocol */
    304 	MOUSE_PS2,
    305 	MOUSE_IMPS2,
    306 	MOUSE_MS,
    307 	MOUSE_BM,
    308 	NUM_MOUSE_DRVS
    309 } mouse_drv = MOUSE_NONE;
    310 
    311 void GS_CloseMouse(_THIS)
    312 {
    313 	if ( mouse_fd > 0 ) {
    314 		close(mouse_fd);
    315 	}
    316 	mouse_fd = -1;
    317 }
    318 
    319 /* Returns processes listed in /proc with the desired name */
    320 static int find_pid(DIR *proc, const char *wanted_name)
    321 {
    322 	struct dirent *entry;
    323 	int pid;
    324 
    325 	/* First scan proc for the gpm process */
    326 	pid = 0;
    327 	while ( (pid == 0) && ((entry=readdir(proc)) != NULL) ) {
    328 		if ( isdigit(entry->d_name[0]) ) {
    329 			FILE *status;
    330 			char path[PATH_MAX];
    331 			char name[PATH_MAX];
    332 
    333 			SDL_snprintf(path, SDL_arraysize(path), "/proc/%s/status", entry->d_name);
    334 			status=fopen(path, "r");
    335 			if ( status ) {
    336 				name[0] = '\0';
    337 				fscanf(status, "Name: %s", name);
    338 				if ( SDL_strcmp(name, wanted_name) == 0 ) {
    339 					pid = atoi(entry->d_name);
    340 				}
    341 				fclose(status);
    342 			}
    343 		}
    344 	}
    345 	return pid;
    346 }
    347 
    348 /* Returns true if /dev/gpmdata is being written to by gpm */
    349 static int gpm_available(void)
    350 {
    351 	int available;
    352 	DIR *proc;
    353 	int pid;
    354 	int cmdline, len, arglen;
    355 	char path[PATH_MAX];
    356 	char args[PATH_MAX], *arg;
    357 
    358 	/* Don't bother looking if the fifo isn't there */
    359 	if ( access(GPM_NODE_FIFO, F_OK) < 0 ) {
    360 		return(0);
    361 	}
    362 
    363 	available = 0;
    364 	proc = opendir("/proc");
    365 	if ( proc ) {
    366 		while ( (pid=find_pid(proc, "gpm")) > 0 ) {
    367 			SDL_snprintf(path, SDL_arraysize(path), "/proc/%d/cmdline", pid);
    368 			cmdline = open(path, O_RDONLY, 0);
    369 			if ( cmdline >= 0 ) {
    370 				len = read(cmdline, args, sizeof(args));
    371 				arg = args;
    372 				while ( len > 0 ) {
    373 					if ( SDL_strcmp(arg, "-R") == 0 ) {
    374 						available = 1;
    375 					}
    376 					arglen = SDL_strlen(arg)+1;
    377 					len -= arglen;
    378 					arg += arglen;
    379 				}
    380 				close(cmdline);
    381 			}
    382 		}
    383 		closedir(proc);
    384 	}
    385 	return available;
    386 }
    387 
    388 
    389 /* rcg06112001 Set up IMPS/2 mode, if possible. This gives
    390  *  us access to the mousewheel, etc. Returns zero if
    391  *  writes to device failed, but you still need to query the
    392  *  device to see which mode it's actually in.
    393  */
    394 static int set_imps2_mode(int fd)
    395 {
    396 	/* If you wanted to control the mouse mode (and we do :)  ) ...
    397 		Set IMPS/2 protocol:
    398 			{0xf3,200,0xf3,100,0xf3,80}
    399 		Reset mouse device:
    400 			{0xFF}
    401 	*/
    402 	Uint8 set_imps2[] = {0xf3, 200, 0xf3, 100, 0xf3, 80};
    403 	Uint8 reset = 0xff;
    404 	fd_set fdset;
    405 	struct timeval tv;
    406 	int retval = 0;
    407 
    408 	if ( write(fd, &set_imps2, sizeof(set_imps2)) == sizeof(set_imps2) ) {
    409 		if (write(fd, &reset, sizeof (reset)) == sizeof (reset) ) {
    410 			retval = 1;
    411 		}
    412 	}
    413 
    414 	/* Get rid of any chatter from the above */
    415 	FD_ZERO(&fdset);
    416 	FD_SET(fd, &fdset);
    417 	tv.tv_sec = 0;
    418 	tv.tv_usec = 0;
    419 	while ( select(fd+1, &fdset, 0, 0, &tv) > 0 ) {
    420 		char temp[32];
    421 		read(fd, temp, sizeof(temp));
    422 	}
    423 
    424 	return retval;
    425 }
    426 
    427 
    428 /* Returns true if the mouse uses the IMPS/2 protocol */
    429 static int detect_imps2(int fd)
    430 {
    431 	int imps2;
    432 
    433 	imps2 = 0;
    434 
    435 	if ( SDL_getenv("SDL_MOUSEDEV_IMPS2") ) {
    436 		imps2 = 1;
    437 	}
    438 	if ( ! imps2 ) {
    439 		Uint8 query_ps2 = 0xF2;
    440 		fd_set fdset;
    441 		struct timeval tv;
    442 
    443 		/* Get rid of any mouse motion noise */
    444 		FD_ZERO(&fdset);
    445 		FD_SET(fd, &fdset);
    446 		tv.tv_sec = 0;
    447 		tv.tv_usec = 0;
    448 		while ( select(fd+1, &fdset, 0, 0, &tv) > 0 ) {
    449 			char temp[32];
    450 			read(fd, temp, sizeof(temp));
    451 		}
    452 
    453    		/* Query for the type of mouse protocol */
    454    		if ( write(fd, &query_ps2, sizeof (query_ps2)) == sizeof (query_ps2)) {
    455    			Uint8 ch = 0;
    456 
    457 			/* Get the mouse protocol response */
    458 			do {
    459 				FD_ZERO(&fdset);
    460 				FD_SET(fd, &fdset);
    461 				tv.tv_sec = 1;
    462 				tv.tv_usec = 0;
    463 				if ( select(fd+1, &fdset, 0, 0, &tv) < 1 ) {
    464 					break;
    465 				}
    466 			} while ( (read(fd, &ch, sizeof (ch)) == sizeof (ch)) &&
    467 			          ((ch == 0xFA) || (ch == 0xAA)) );
    468 
    469 			/* Experimental values (Logitech wheelmouse) */
    470 #ifdef DEBUG_MOUSE
    471 fprintf(stderr, "Last mouse mode: 0x%x\n", ch);
    472 #endif
    473 			if ( ch == 3 ) {
    474 				imps2 = 1;
    475 			}
    476 		}
    477 	}
    478 	return imps2;
    479 }
    480 
    481 int GS_OpenMouse(_THIS)
    482 {
    483 	int i;
    484 	const char *mousedev;
    485 	const char *mousedrv;
    486 
    487 	mousedrv = SDL_getenv("SDL_MOUSEDRV");
    488 	mousedev = SDL_getenv("SDL_MOUSEDEV");
    489 	mouse_fd = -1;
    490 
    491 	/* STD MICE */
    492 
    493 	if ( mousedev == NULL ) {
    494 		/* FIXME someday... allow multiple mice in this driver */
    495 		char *ps2mice[] = {
    496 		    "/dev/input/mice", "/dev/usbmouse", "/dev/psaux", NULL
    497 		};
    498 		/* First try to use GPM in repeater mode */
    499 		if ( mouse_fd < 0 ) {
    500 			if ( gpm_available() ) {
    501 				mouse_fd = open(GPM_NODE_FIFO, O_RDONLY, 0);
    502 				if ( mouse_fd >= 0 ) {
    503 #ifdef DEBUG_MOUSE
    504 fprintf(stderr, "Using GPM mouse\n");
    505 #endif
    506 					mouse_drv = MOUSE_GPM;
    507 				}
    508 			}
    509 		}
    510 		/* Now try to use a modern PS/2 mouse */
    511 		for ( i=0; (mouse_fd < 0) && ps2mice[i]; ++i ) {
    512 			mouse_fd = open(ps2mice[i], O_RDWR, 0);
    513 			if (mouse_fd < 0) {
    514 				mouse_fd = open(ps2mice[i], O_RDONLY, 0);
    515 			}
    516 			if (mouse_fd >= 0) {
    517 				/* rcg06112001 Attempt to set IMPS/2 mode */
    518 				if ( i == 0 ) {
    519 					set_imps2_mode(mouse_fd);
    520 				}
    521 				if (detect_imps2(mouse_fd)) {
    522 #ifdef DEBUG_MOUSE
    523 fprintf(stderr, "Using IMPS2 mouse\n");
    524 #endif
    525 					mouse_drv = MOUSE_IMPS2;
    526 				} else {
    527 					mouse_drv = MOUSE_PS2;
    528 #ifdef DEBUG_MOUSE
    529 fprintf(stderr, "Using PS2 mouse\n");
    530 #endif
    531 				}
    532 			}
    533 		}
    534 		/* Next try to use a PPC ADB port mouse */
    535 		if ( mouse_fd < 0 ) {
    536 			mouse_fd = open("/dev/adbmouse", O_RDONLY, 0);
    537 			if ( mouse_fd >= 0 ) {
    538 #ifdef DEBUG_MOUSE
    539 fprintf(stderr, "Using ADB mouse\n");
    540 #endif
    541 				mouse_drv = MOUSE_BM;
    542 			}
    543 		}
    544 	}
    545 	/* Default to a serial Microsoft mouse */
    546 	if ( mouse_fd < 0 ) {
    547 		if ( mousedev == NULL ) {
    548 			mousedev = "/dev/mouse";
    549 		}
    550 		mouse_fd = open(mousedev, O_RDONLY, 0);
    551 		if ( mouse_fd >= 0 ) {
    552 			struct termios mouse_termios;
    553 
    554 			/* Set the sampling speed to 1200 baud */
    555 			tcgetattr(mouse_fd, &mouse_termios);
    556 			mouse_termios.c_iflag = IGNBRK | IGNPAR;
    557 			mouse_termios.c_oflag = 0;
    558 			mouse_termios.c_lflag = 0;
    559 			mouse_termios.c_line = 0;
    560 			mouse_termios.c_cc[VTIME] = 0;
    561 			mouse_termios.c_cc[VMIN] = 1;
    562 			mouse_termios.c_cflag = CREAD | CLOCAL | HUPCL;
    563 			mouse_termios.c_cflag |= CS8;
    564 			mouse_termios.c_cflag |= B1200;
    565 			tcsetattr(mouse_fd, TCSAFLUSH, &mouse_termios);
    566 #ifdef DEBUG_MOUSE
    567 fprintf(stderr, "Using Microsoft mouse on %s\n", mousedev);
    568 #endif
    569 			mouse_drv = MOUSE_MS;
    570 		}
    571 	}
    572 	if ( mouse_fd < 0 ) {
    573 		mouse_drv = MOUSE_NONE;
    574 	}
    575 	return(mouse_fd);
    576 }
    577 
    578 static int posted = 0;
    579 
    580 void GS_vgamousecallback(int button, int dx, int dy)
    581 {
    582 	int button_1, button_3;
    583 	int button_state;
    584 	int state_changed;
    585 	int i;
    586 	Uint8 state;
    587 
    588 	if ( dx || dy ) {
    589 		posted += SDL_PrivateMouseMotion(0, 1, dx, dy);
    590 	}
    591 
    592 	/* Swap button 1 and 3 */
    593 	button_1 = (button & 0x04) >> 2;
    594 	button_3 = (button & 0x01) << 2;
    595 	button &= ~0x05;
    596 	button |= (button_1|button_3);
    597 
    598 	/* See what changed */
    599 	button_state = SDL_GetMouseState(NULL, NULL);
    600 	state_changed = button_state ^ button;
    601 	for ( i=0; i<8; ++i ) {
    602 		if ( state_changed & (1<<i) ) {
    603 			if ( button & (1<<i) ) {
    604 				state = SDL_PRESSED;
    605 			} else {
    606 				state = SDL_RELEASED;
    607 			}
    608 			posted += SDL_PrivateMouseButton(state, i+1, 0, 0);
    609 		}
    610 	}
    611 }
    612 
    613 /* For now, use GPM, PS/2, and MS protocols
    614    Driver adapted from the SVGAlib mouse driver code (taken from gpm, etc.)
    615  */
    616 static void handle_mouse(_THIS)
    617 {
    618 	static int start = 0;
    619 	static unsigned char mousebuf[BUFSIZ];
    620 	int i, nread;
    621 	int button = 0;
    622 	int dx = 0, dy = 0;
    623 	int packetsize = 0;
    624 
    625 	/* Figure out the mouse packet size */
    626 	switch (mouse_drv) {
    627 		case MOUSE_NONE:
    628 			/* Ack! */
    629 			read(mouse_fd, mousebuf, BUFSIZ);
    630 			return;
    631 		case MOUSE_GPM:
    632 			packetsize = 5;
    633 			break;
    634 		case MOUSE_IMPS2:
    635 			packetsize = 4;
    636 			break;
    637 		case MOUSE_PS2:
    638 		case MOUSE_MS:
    639 		case MOUSE_BM:
    640 			packetsize = 3;
    641 			break;
    642 		case NUM_MOUSE_DRVS:
    643 			/* Uh oh.. */
    644 			packetsize = 0;
    645 			break;
    646 	}
    647 
    648 	/* Read as many packets as possible */
    649 	nread = read(mouse_fd, &mousebuf[start], BUFSIZ-start);
    650 	if ( nread < 0 ) {
    651 		return;
    652 	}
    653 	nread += start;
    654 #ifdef DEBUG_MOUSE
    655 	fprintf(stderr, "Read %d bytes from mouse, start = %d\n", nread, start);
    656 #endif
    657 	for ( i=0; i<(nread-(packetsize-1)); i += packetsize ) {
    658 		switch (mouse_drv) {
    659 			case MOUSE_NONE:
    660 				break;
    661 			case MOUSE_GPM:
    662 				/* GPM protocol has 0x80 in high byte */
    663 				if ( (mousebuf[i] & 0xF8) != 0x80 ) {
    664 					/* Go to next byte */
    665 					i -= (packetsize-1);
    666 					continue;
    667 				}
    668 				/* Get current mouse state */
    669 				button = (~mousebuf[i]) & 0x07;
    670 				dx =   (signed char)(mousebuf[i+1]) +
    671 				       (signed char)(mousebuf[i+3]);
    672 				dy = -((signed char)(mousebuf[i+2]) +
    673 				       (signed char)(mousebuf[i+4]));
    674 				break;
    675 			case MOUSE_PS2:
    676 				/* PS/2 protocol has nothing in high byte */
    677 				if ( (mousebuf[i] & 0xC0) != 0 ) {
    678 					/* Go to next byte */
    679 					i -= (packetsize-1);
    680 					continue;
    681 				}
    682 				/* Get current mouse state */
    683 				button = (mousebuf[i] & 0x04) >> 1 | /*Middle*/
    684 		  			 (mousebuf[i] & 0x02) >> 1 | /*Right*/
    685 		  			 (mousebuf[i] & 0x01) << 2;  /*Left*/
    686 		  		dx = (mousebuf[i] & 0x10) ?
    687 		  		      mousebuf[i+1] - 256 : mousebuf[i+1];
    688 		  		dy = (mousebuf[i] & 0x20) ?
    689 		  		      -(mousebuf[i+2] - 256) : -mousebuf[i+2];
    690 				break;
    691 			case MOUSE_IMPS2:
    692 				/* Get current mouse state */
    693 				button = (mousebuf[i] & 0x04) >> 1 | /*Middle*/
    694 		  			 (mousebuf[i] & 0x02) >> 1 | /*Right*/
    695 		  			 (mousebuf[i] & 0x01) << 2 | /*Left*/
    696 		  			 (mousebuf[i] & 0x40) >> 3 | /* 4 */
    697 		  			 (mousebuf[i] & 0x80) >> 3;  /* 5 */
    698 		  		dx = (mousebuf[i] & 0x10) ?
    699 		  		      mousebuf[i+1] - 256 : mousebuf[i+1];
    700 		  		dy = (mousebuf[i] & 0x20) ?
    701 		  		      -(mousebuf[i+2] - 256) : -mousebuf[i+2];
    702 				switch (mousebuf[i+3]&0x0F) {
    703 				    case 0x0E: /* DX = +1 */
    704 				    case 0x02: /* DX = -1 */
    705 					break;
    706 				    case 0x0F: /* DY = +1 (map button 4) */
    707                                        FB_vgamousecallback(button | (1<<3),
    708                                                            1, 0, 0);
    709 					break;
    710 				    case 0x01: /* DY = -1 (map button 5) */
    711                                        FB_vgamousecallback(button | (1<<4),
    712                                                            1, 0, 0);
    713 					break;
    714 				}
    715 				break;
    716 			case MOUSE_MS:
    717 				/* Microsoft protocol has 0x40 in high byte */
    718 				if ( (mousebuf[i] & 0x40) != 0x40 ) {
    719 					/* Go to next byte */
    720 					i -= (packetsize-1);
    721 					continue;
    722 				}
    723 				/* Get current mouse state */
    724 				button = ((mousebuf[i] & 0x20) >> 3) |
    725 				         ((mousebuf[i] & 0x10) >> 4);
    726 				dx = (signed char)(((mousebuf[i] & 0x03) << 6) |
    727 				                   (mousebuf[i + 1] & 0x3F));
    728 				dy = (signed char)(((mousebuf[i] & 0x0C) << 4) |
    729 				                    (mousebuf[i + 2] & 0x3F));
    730 				break;
    731 			case MOUSE_BM:
    732 				/* BusMouse protocol has 0xF8 in high byte */
    733 				if ( (mousebuf[i] & 0xF8) != 0x80 ) {
    734 					/* Go to next byte */
    735 					i -= (packetsize-1);
    736 					continue;
    737 				}
    738 				/* Get current mouse state */
    739 				button = (~mousebuf[i]) & 0x07;
    740 				dx =  (signed char)mousebuf[i+1];
    741 				dy = -(signed char)mousebuf[i+2];
    742 				break;
    743 			case NUM_MOUSE_DRVS:
    744 				/* Uh oh.. */
    745 				dx = 0;
    746 				dy = 0;
    747 				break;
    748 		}
    749 		GS_vgamousecallback(button, dx, dy);
    750 	}
    751 	if ( i < nread ) {
    752 		SDL_memcpy(mousebuf, &mousebuf[i], (nread-i));
    753 		start = (nread-i);
    754 	} else {
    755 		start = 0;
    756 	}
    757 	return;
    758 }
    759 
    760 static void handle_keyboard(_THIS)
    761 {
    762 	unsigned char keybuf[BUFSIZ];
    763 	int i, nread;
    764 	int pressed;
    765 	int scancode;
    766 	SDL_keysym keysym;
    767 
    768 	nread = read(keyboard_fd, keybuf, BUFSIZ);
    769 	for ( i=0; i<nread; ++i ) {
    770 		scancode = keybuf[i] & 0x7F;
    771 		if ( keybuf[i] & 0x80 ) {
    772 			pressed = SDL_RELEASED;
    773 		} else {
    774 			pressed = SDL_PRESSED;
    775 		}
    776 		TranslateKey(scancode, &keysym);
    777 		posted += SDL_PrivateKeyboard(pressed, &keysym);
    778 	}
    779 }
    780 
    781 void GS_PumpEvents(_THIS)
    782 {
    783 	fd_set fdset;
    784 	int max_fd;
    785 	static struct timeval zero;
    786 
    787 	do {
    788 		posted = 0;
    789 
    790 		FD_ZERO(&fdset);
    791 		max_fd = 0;
    792 		if ( keyboard_fd >= 0 ) {
    793 			FD_SET(keyboard_fd, &fdset);
    794 			if ( max_fd < keyboard_fd ) {
    795 				max_fd = keyboard_fd;
    796 			}
    797 		}
    798 		if ( mouse_fd >= 0 ) {
    799 			FD_SET(mouse_fd, &fdset);
    800 			if ( max_fd < mouse_fd ) {
    801 				max_fd = mouse_fd;
    802 			}
    803 		}
    804 		if ( select(max_fd+1, &fdset, NULL, NULL, &zero) > 0 ) {
    805 			if ( keyboard_fd >= 0 ) {
    806 				if ( FD_ISSET(keyboard_fd, &fdset) ) {
    807 					handle_keyboard(this);
    808 				}
    809 			}
    810 			if ( mouse_fd >= 0 ) {
    811 				if ( FD_ISSET(mouse_fd, &fdset) ) {
    812 					handle_mouse(this);
    813 				}
    814 			}
    815 		}
    816 	} while ( posted );
    817 }
    818 
    819 void GS_InitOSKeymap(_THIS)
    820 {
    821 	int i;
    822 
    823 	/* Initialize the Linux key translation table */
    824 
    825 	/* First get the ascii keys and others not well handled */
    826 	for (i=0; i<SDL_arraysize(keymap); ++i) {
    827 	  switch(i) {
    828 	  /* These aren't handled by the x86 kernel keymapping (?) */
    829 	  case SCANCODE_PRINTSCREEN:
    830 	    keymap[i] = SDLK_PRINT;
    831 	    break;
    832 	  case SCANCODE_BREAK:
    833 	    keymap[i] = SDLK_BREAK;
    834 	    break;
    835 	  case SCANCODE_BREAK_ALTERNATIVE:
    836 	    keymap[i] = SDLK_PAUSE;
    837 	    break;
    838 	  case SCANCODE_LEFTSHIFT:
    839 	    keymap[i] = SDLK_LSHIFT;
    840 	    break;
    841 	  case SCANCODE_RIGHTSHIFT:
    842 	    keymap[i] = SDLK_RSHIFT;
    843 	    break;
    844 	  case SCANCODE_LEFTCONTROL:
    845 	    keymap[i] = SDLK_LCTRL;
    846 	    break;
    847 	  case SCANCODE_RIGHTCONTROL:
    848 	    keymap[i] = SDLK_RCTRL;
    849 	    break;
    850 	  case SCANCODE_RIGHTWIN:
    851 	    keymap[i] = SDLK_RSUPER;
    852 	    break;
    853 	  case SCANCODE_LEFTWIN:
    854 	    keymap[i] = SDLK_LSUPER;
    855 	    break;
    856 	  case 127:
    857 	    keymap[i] = SDLK_MENU;
    858 	    break;
    859 	  /* this should take care of all standard ascii keys */
    860 	  default:
    861 	    keymap[i] = KVAL(vga_keymap[0][i]);
    862 	    break;
    863           }
    864 	}
    865 	for (i=0; i<SDL_arraysize(keymap); ++i) {
    866 	  switch(keymap_temp[i]) {
    867 	    case K_F1:  keymap[i] = SDLK_F1;  break;
    868 	    case K_F2:  keymap[i] = SDLK_F2;  break;
    869 	    case K_F3:  keymap[i] = SDLK_F3;  break;
    870 	    case K_F4:  keymap[i] = SDLK_F4;  break;
    871 	    case K_F5:  keymap[i] = SDLK_F5;  break;
    872 	    case K_F6:  keymap[i] = SDLK_F6;  break;
    873 	    case K_F7:  keymap[i] = SDLK_F7;  break;
    874 	    case K_F8:  keymap[i] = SDLK_F8;  break;
    875 	    case K_F9:  keymap[i] = SDLK_F9;  break;
    876 	    case K_F10: keymap[i] = SDLK_F10; break;
    877 	    case K_F11: keymap[i] = SDLK_F11; break;
    878 	    case K_F12: keymap[i] = SDLK_F12; break;
    879 
    880 	    case K_DOWN:  keymap[i] = SDLK_DOWN;  break;
    881 	    case K_LEFT:  keymap[i] = SDLK_LEFT;  break;
    882 	    case K_RIGHT: keymap[i] = SDLK_RIGHT; break;
    883 	    case K_UP:    keymap[i] = SDLK_UP;    break;
    884 
    885 	    case K_P0:     keymap[i] = SDLK_KP0; break;
    886 	    case K_P1:     keymap[i] = SDLK_KP1; break;
    887 	    case K_P2:     keymap[i] = SDLK_KP2; break;
    888 	    case K_P3:     keymap[i] = SDLK_KP3; break;
    889 	    case K_P4:     keymap[i] = SDLK_KP4; break;
    890 	    case K_P5:     keymap[i] = SDLK_KP5; break;
    891 	    case K_P6:     keymap[i] = SDLK_KP6; break;
    892 	    case K_P7:     keymap[i] = SDLK_KP7; break;
    893 	    case K_P8:     keymap[i] = SDLK_KP8; break;
    894 	    case K_P9:     keymap[i] = SDLK_KP9; break;
    895 	    case K_PPLUS:  keymap[i] = SDLK_KP_PLUS; break;
    896 	    case K_PMINUS: keymap[i] = SDLK_KP_MINUS; break;
    897 	    case K_PSTAR:  keymap[i] = SDLK_KP_MULTIPLY; break;
    898 	    case K_PSLASH: keymap[i] = SDLK_KP_DIVIDE; break;
    899 	    case K_PENTER: keymap[i] = SDLK_KP_ENTER; break;
    900 	    case K_PDOT:   keymap[i] = SDLK_KP_PERIOD; break;
    901 
    902 	    case K_SHIFT:  if ( keymap[i] != SDLK_RSHIFT )
    903 	                     keymap[i] = SDLK_LSHIFT;
    904 	                   break;
    905 	    case K_SHIFTL: keymap[i] = SDLK_LSHIFT; break;
    906 	    case K_SHIFTR: keymap[i] = SDLK_RSHIFT; break;
    907 	    case K_CTRL:  if ( keymap[i] != SDLK_RCTRL )
    908 	                     keymap[i] = SDLK_LCTRL;
    909 	                   break;
    910 	    case K_CTRLL:  keymap[i] = SDLK_LCTRL;  break;
    911 	    case K_CTRLR:  keymap[i] = SDLK_RCTRL;  break;
    912 	    case K_ALT:    keymap[i] = SDLK_LALT;   break;
    913 	    case K_ALTGR:  keymap[i] = SDLK_RALT;   break;
    914 
    915 	    case K_INSERT: keymap[i] = SDLK_INSERT;   break;
    916 	    case K_REMOVE: keymap[i] = SDLK_DELETE;   break;
    917 	    case K_PGUP:   keymap[i] = SDLK_PAGEUP;   break;
    918 	    case K_PGDN:   keymap[i] = SDLK_PAGEDOWN; break;
    919 	    case K_FIND:   keymap[i] = SDLK_HOME;     break;
    920 	    case K_SELECT: keymap[i] = SDLK_END;      break;
    921 
    922 	    case K_NUM:  keymap[i] = SDLK_NUMLOCK;   break;
    923 	    case K_CAPS: keymap[i] = SDLK_CAPSLOCK;  break;
    924 
    925 	    case K_F13:   keymap[i] = SDLK_PRINT;     break;
    926 	    case K_HOLD:  keymap[i] = SDLK_SCROLLOCK; break;
    927 	    case K_PAUSE: keymap[i] = SDLK_PAUSE;     break;
    928 
    929 	    case 127: keymap[i] = SDLK_BACKSPACE; break;
    930 
    931 	    default: break;
    932 	  }
    933 	}
    934 }
    935 
    936 static SDL_keysym *TranslateKey(int scancode, SDL_keysym *keysym)
    937 {
    938 	/* Set the keysym information */
    939 	keysym->scancode = scancode;
    940 	keysym->sym = keymap[scancode];
    941 	keysym->mod = KMOD_NONE;
    942 
    943 	/* If UNICODE is on, get the UNICODE value for the key */
    944 	keysym->unicode = 0;
    945 	if ( SDL_TranslateUNICODE ) {
    946 		int map;
    947 		SDLMod modstate;
    948 
    949 		modstate = SDL_GetModState();
    950 		map = 0;
    951 		if ( modstate & KMOD_SHIFT ) {
    952 			map |= (1<<KG_SHIFT);
    953 		}
    954 		if ( modstate & KMOD_CTRL ) {
    955 			map |= (1<<KG_CTRL);
    956 		}
    957 		if ( modstate & KMOD_ALT ) {
    958 			map |= (1<<KG_ALT);
    959 		}
    960 		if ( modstate & KMOD_MODE ) {
    961 			map |= (1<<KG_ALTGR);
    962 		}
    963 		if ( KTYP(vga_keymap[map][scancode]) == KT_LETTER ) {
    964 			if ( modstate & KMOD_CAPS ) {
    965 				map ^= (1<<KG_SHIFT);
    966 			}
    967 		}
    968 		if ( KTYP(vga_keymap[map][scancode]) == KT_PAD ) {
    969 			if ( modstate & KMOD_NUM ) {
    970 				keysym->unicode=KVAL(vga_keymap[map][scancode]);
    971 			}
    972 		} else {
    973 			keysym->unicode = KVAL(vga_keymap[map][scancode]);
    974 		}
    975 	}
    976 	return(keysym);
    977 }
    978