input_devices.c

Go to the documentation of this file.

/* The Xemu project.
   Copyright (C)2016-2019 LGB (Gábor Lénárt) <lgblgblgb@gmail.com>
 
   This is the Commander X16 emulation. Note: the source is overcrowded with comments by intent :)
   That it can useful for other people as well, or someone wants to contribute, etc ...
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
#include "xemu/emutools.h"
#include "xemu/emutools_hid.h"
#include "input_devices.h"
#include "commander_x16.h"
#include <string.h>
 
struct ps2_keymap_st {
        SDL_Scancode    key;
        int             ps2_code;       // + 0x100 for extended codes
};
 
// This table is taken from Mist's X16 emulator, but converted into a table
// >0xFF codes are extended keys (and only the low byte should be treated then as the PS/2 keycode)
static const struct ps2_keymap_st ps2_keymap[] = {
        {SDL_SCANCODE_GRAVE,            0x0e},  {SDL_SCANCODE_BACKSPACE,        0x66},  {SDL_SCANCODE_TAB,              0xd},   {SDL_SCANCODE_CLEAR,            0},     {SDL_SCANCODE_RETURN,           0x5a},
        {SDL_SCANCODE_PAUSE,            0},     {SDL_SCANCODE_ESCAPE,           0x76},  {SDL_SCANCODE_SPACE,            0x29},  {SDL_SCANCODE_APOSTROPHE,       0x52},  {SDL_SCANCODE_COMMA,            0x41},
        {SDL_SCANCODE_MINUS,            0x4e},  {SDL_SCANCODE_PERIOD,           0x49},  {SDL_SCANCODE_SLASH,            0x4a},  {SDL_SCANCODE_0,                0x45},  {SDL_SCANCODE_1,                0x16},
        {SDL_SCANCODE_2,                0x1e},  {SDL_SCANCODE_3,                0x26},  {SDL_SCANCODE_4,                0x25},  {SDL_SCANCODE_5,                0x2e},  {SDL_SCANCODE_6,                0x36},
        {SDL_SCANCODE_7,                0x3d},  {SDL_SCANCODE_8,                0x3e},  {SDL_SCANCODE_9,                0x46},  {SDL_SCANCODE_SEMICOLON,        0x4c},  {SDL_SCANCODE_EQUALS,           0x55},
        {SDL_SCANCODE_LEFTBRACKET,      0x54},  {SDL_SCANCODE_BACKSLASH,        0x5d},  {SDL_SCANCODE_RIGHTBRACKET,     0x5b},  {SDL_SCANCODE_A,                0x1c},  {SDL_SCANCODE_B,                0x32},
        {SDL_SCANCODE_C,                0x21},  {SDL_SCANCODE_D,                0x23},  {SDL_SCANCODE_E,                0x24},  {SDL_SCANCODE_F,                0x2b},  {SDL_SCANCODE_G,                0x34},
        {SDL_SCANCODE_H,                0x33},  {SDL_SCANCODE_I,                0x43},  {SDL_SCANCODE_J,                0x3B},  {SDL_SCANCODE_K,                0x42},  {SDL_SCANCODE_L,                0x4B},
        {SDL_SCANCODE_M,                0x3A},  {SDL_SCANCODE_N,                0x31},  {SDL_SCANCODE_O,                0x44},  {SDL_SCANCODE_P,                0x4D},  {SDL_SCANCODE_Q,                0x15},
        {SDL_SCANCODE_R,                0x2D},  {SDL_SCANCODE_S,                0x1B},  {SDL_SCANCODE_T,                0x2C},  {SDL_SCANCODE_U,                0x3C},  {SDL_SCANCODE_V,                0x2A},
        {SDL_SCANCODE_W,                0x1D},  {SDL_SCANCODE_X,                0x22},  {SDL_SCANCODE_Y,                0x35},  {SDL_SCANCODE_Z,                0x1A},  {SDL_SCANCODE_DELETE,           0},
        {SDL_SCANCODE_UP,               0x175}, {SDL_SCANCODE_DOWN,             0x172}, {SDL_SCANCODE_RIGHT,            0x174}, {SDL_SCANCODE_LEFT,             0x16b}, {SDL_SCANCODE_INSERT,           0},
        {SDL_SCANCODE_HOME,             0x16c}, {SDL_SCANCODE_END,              0},     {SDL_SCANCODE_PAGEUP,           0},     {SDL_SCANCODE_PAGEDOWN,         0},     {SDL_SCANCODE_F1,               0x05},
        {SDL_SCANCODE_F2,               0x06},  {SDL_SCANCODE_F3,               0x04},  {SDL_SCANCODE_F4,               0x0c},  {SDL_SCANCODE_F5,               0x03},  {SDL_SCANCODE_F6,               0x0b},
        {SDL_SCANCODE_F7,               0x83},  {SDL_SCANCODE_F8,               0x0a},  {SDL_SCANCODE_F9,               0x01},  {SDL_SCANCODE_F10,              0x09},  {SDL_SCANCODE_F11,              0x78},
        {SDL_SCANCODE_F12,              0x07},  {SDL_SCANCODE_RSHIFT,           0x59},  {SDL_SCANCODE_LSHIFT,           0x12},  {SDL_SCANCODE_LCTRL,            0x14},  {SDL_SCANCODE_RCTRL,            0x114},
        {SDL_SCANCODE_LALT,             0x11},  {SDL_SCANCODE_RALT,             0x111}, {SDL_SCANCODE_NONUSBACKSLASH,   0x61},  {SDL_SCANCODE_KP_ENTER,         0x15a}, {SDL_SCANCODE_KP_0,             0x70},
        {SDL_SCANCODE_KP_1,             0x69},  {SDL_SCANCODE_KP_2,             0x72},  {SDL_SCANCODE_KP_3,             0x7a},  {SDL_SCANCODE_KP_4,             0x6b},  {SDL_SCANCODE_KP_5,             0x73},
        {SDL_SCANCODE_KP_6,             0x74},  {SDL_SCANCODE_KP_7,             0x6c},  {SDL_SCANCODE_KP_8,             0x75},  {SDL_SCANCODE_KP_9,             0x7d},  {SDL_SCANCODE_KP_PERIOD,        0x71},
        {SDL_SCANCODE_KP_PLUS,          0x79},  {SDL_SCANCODE_KP_MINUS,         0x7b},  {SDL_SCANCODE_KP_MULTIPLY,      0x7c},  {SDL_SCANCODE_KP_DIVIDE,        0x14a}, {0,                             -1}
};
 
void clear_emu_events ( void )
{
        hid_reset_events(1);
}
 
 
 
 
 
static Uint8  ps2_stream[128];
static int    ps2_stream_w_pos = 0;
static Uint64 virt_cycle_last_read;
 
 
int read_ps2_port ( void )
{
        static int clk = 2;
        static int data = 1;
        if (ps2_stream_w_pos) {
                Uint64 since = all_virt_cycles - virt_cycle_last_read;
                // This is BAD, since actually the keyboard sends data the CPU takes care or not, it won't "pause" just because PS/2 lines are not checked ...
                if (since > 333) {
                        virt_cycle_last_read = all_virt_cycles;
                        //while (since > 333 && ps2_stream_w_pos) {
                                clk ^= 2;
                                if (!clk) {
                                        data = ps2_stream[0];
                                        memmove(ps2_stream, ps2_stream + 1, --ps2_stream_w_pos);
                                }
                        //      since -= 333;
                        //}
                }
        } else {
                clk = 2;
                data = 1;
        }
        return clk | data;
}
 
 
static void queue_ps2_device_packet ( Uint8 data )
{
        //DEBUGPRINT("PS2: queuing protocol byte $%02X" NL, data);
        ps2_stream[ps2_stream_w_pos++] = 0;     // start bit, always zero
        int parity = 1;                         // odd parity, we start with '1'.
        for (int a = 0; a < 8; a++, data >>=1 ) {
                ps2_stream[ps2_stream_w_pos++] = (data & 1);
                if ((data & 1))
                        parity ^= 1;
        }
        ps2_stream[ps2_stream_w_pos++] = parity;
        ps2_stream[ps2_stream_w_pos++] = 1;     // stop bit, always one
}
 
 
static XEMU_INLINE void emit_ps2_event ( SDL_Scancode key, int pressed )
{
        const struct ps2_keymap_st *p = ps2_keymap;
        while (p->ps2_code >= 0)
                if (key == p->key) {
                        if (ps2_stream_w_pos < sizeof(ps2_stream) - 12 * 3) {
                                int ps2 = p->ps2_code;
                                //fprintf(stderr, "FOUND KEY: SDL=%d PS2=%d PRESSED=%s\n", p->key, ps2, pressed ? "pressed" : "released");
                                if (ps2 >= 0x100)
                                        queue_ps2_device_packet(0xE0);  // extended key, emit E0
                                if (!pressed)
                                        queue_ps2_device_packet(0xF0);  // "break" code, ie, release of a key
                                queue_ps2_device_packet(ps2 & 0xFF);
                        } else
                                DEBUGPRINT("PS2: protocol stream is full :-(" NL);
                        return;
                } else
                        p++;
        //DEBUGPRINT("PS2: KEY NOT FOUND SDL=%d PRESSED=%s" NL, key, pressed ? "pressed" : "released");
}
 
 
// HID needs this to be defined, it's up to the emulator if it uses or not ...
// NOTE: Commander X16 is a special case, as it's not matrix based with keyboard implementation.
// Thus, we skip the matrix stuff more or less, and use the callback of the HID subsystem to
// inject the emulated PS/2 sequences then. We want to use some queue anyway ...
int emu_callback_key ( int pos, SDL_Scancode key, int pressed, int handled )
{
/*      DEBUGPRINT("KEY EVENT: pos=%d scancode=%d pressed=%d handled=%d" NL,
                        pos, key, pressed, handled
        );*/
        if (pos == -1 && handled == 0)
                emit_ps2_event(key, pressed);
        return 0;
}