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, ¤t_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
