#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <ctype.h>
#include <getopt.h>
#include <syslog.h>
#include <stdint.h>

#include <usb.h>

#include <X11/Xlib.h>
#include <X11/keysym.h>

#define KEY_LIST_LEN 10


static struct usb_dev_handle *devh;


#define HACK_NONE	0UL           /*Do nothing special */

#define HACK_CTRL_L		1UL<<0
#define HACK_SHIFT_L		1UL<<1
#define HACK_ALT_L		1UL<<2
#define HACK_SUPER_L		1UL<<3

#define HACK_CTRL_R		1UL<<4
#define HACK_SHIFT_R		1UL<<5
#define HACK_ALT_R		1UL<<6
#define HACK_SUPER_R		1UL<<7

#define HACK_SHIFT_MASK		0x22
#define HACK_MODIFIER_MASK	0xff

#define HACK_RCS	1UL<<16        /*Require a shift key to be pressed and pass it through */
#define HACK_HS		1UL<<17        /*Require and then hide a shift key */
#define HACK_ILS		1UL<<18       /*Insert left shift */


static struct map_ent
{
  uint32_t hacks;
  uint8_t code;
  KeySym keysym;
  int keycode;
} map[] =
{
/* Crazy parenthesis*/
  {
  HACK_RCS, 0x26, 0x28},        /* parenleft */
  {
  HACK_RCS, 0x27, 0x29},        /* parenright */
#if 0
/* UK - US misery for windows UK map*/
  {
  HACK_RCS, 0x34, 0x32},        /* shift 2 ->shift ' */
  {
  HACK_RCS, 0x1f, 0x27},        /* shift ' -> shift 2 */
  {
  HACK_RCS, 0x31, 0x60},        /* shift ` -> shift # */
  {
  HACK_HS, 0x31, 0x33},         /* shift 3 ->  # */
  {
  HACK_NONE, 0x64, 0x5c},       /* backslash -> backslash */
#endif
#if 1
/*misery for james' gbus keymap */
  {
  HACK_CTRL_L, 0xE0, 0xffe5},   /* Caps_Lock */
  {
  HACK_NONE, 0x39, 0xffe3},     /* Control_L */
  {
  HACK_NONE, 0x31, 0x60},       /* ` -> ` */
  {
  HACK_NONE, 0x64, 0x5c},       /* backslash -> backslash */
#endif
/*Modifier keys*/
  {
  HACK_CTRL_L, 0xE0, 0xffe3},   /* Control_L */
  {
  HACK_SHIFT_L, 0xE1, 0xffe1},  /* Shift_L */
  {
  HACK_ALT_L, 0xE2, 0xffe9},    /* Alt_L */
  {
  HACK_SUPER_L, 0xE3, 0xffeb},  /* Super_L */
  {
  HACK_CTRL_R, 0xE4, 0xffe4},   /* Control_R */
  {
  HACK_SHIFT_R, 0xE5, 0xffe2},  /* Shift_R */
  {
  HACK_ALT_R, 0xE6, 0xffea},    /* Alt_R */
  {
  HACK_SUPER_R, 0xE7, 0xffec},  /* Super_R */
/* normal service below here */
  {
  HACK_NONE, 0x04, 0x61},       /* a */
  {
  HACK_NONE, 0x05, 0x62},       /* b */
  {
  HACK_NONE, 0x06, 0x63},       /* c */
  {
  HACK_NONE, 0x07, 0x64},       /* d */
  {
  HACK_NONE, 0x08, 0x65},       /* e */
  {
  HACK_NONE, 0x09, 0x66},       /* f */
  {
  HACK_NONE, 0x0a, 0x67},       /* g */
  {
  HACK_NONE, 0x0b, 0x68},       /* h */
  {
  HACK_NONE, 0x0c, 0x69},       /* i */
  {
  HACK_NONE, 0x0d, 0x6a},       /* j */
  {
  HACK_NONE, 0x0e, 0x6b},       /* k */
  {
  HACK_NONE, 0x0f, 0x6c},       /* l */
  {
  HACK_NONE, 0x10, 0x6d},       /* m */
  {
  HACK_NONE, 0x11, 0x6e},       /* n */
  {
  HACK_NONE, 0x12, 0x6f},       /* o */
  {
  HACK_NONE, 0x13, 0x70},       /* p */
  {
  HACK_NONE, 0x14, 0x71},       /* q */
  {
  HACK_NONE, 0x15, 0x72},       /* r */
  {
  HACK_NONE, 0x16, 0x73},       /* s */
  {
  HACK_NONE, 0x17, 0x74},       /* t */
  {
  HACK_NONE, 0x18, 0x75},       /* u */
  {
  HACK_NONE, 0x19, 0x76},       /* v */
  {
  HACK_NONE, 0x1a, 0x77},       /* w */
  {
  HACK_NONE, 0x1b, 0x78},       /* x */
  {
  HACK_NONE, 0x1c, 0x79},       /* y */
  {
  HACK_NONE, 0x1d, 0x7a},       /* z */
  {
  HACK_NONE, 0x1e, 0x31},       /* 1 */
  {
  HACK_NONE, 0x1f, 0x32},       /* 2 */
  {
  HACK_NONE, 0x20, 0x33},       /* 3 */
  {
  HACK_NONE, 0x21, 0x34},       /* 4 */
  {
  HACK_NONE, 0x22, 0x35},       /* 5 */
  {
  HACK_NONE, 0x23, 0x36},       /* 6 */
  {
  HACK_NONE, 0x24, 0x37},       /* 7 */
  {
  HACK_NONE, 0x25, 0x38},       /* 8 */
  {
  HACK_NONE, 0x26, 0x39},       /* 9 */
  {
  HACK_NONE, 0x27, 0x30},       /* 0 */
  {
  HACK_NONE, 0x28, 0xff0d},     /* Return */
  {
  HACK_NONE, 0x29, 0xff1b},     /* Escape */
  {
  HACK_NONE, 0x2a, 0xff08},     /* BackSpace */
  {
  HACK_NONE, 0x2b, 0xff09},     /* Tab */
  {
  HACK_NONE, 0x2c, 0x20},       /* space */
  {
  HACK_NONE, 0x2d, 0x2d},       /* minus */
  {
  HACK_NONE, 0x2e, 0x3d},       /* equal */
  {
  HACK_NONE, 0x2f, 0x5b},       /* bracketleft */
  {
  HACK_NONE, 0x30, 0x5d},       /* bracketright */
  {
  HACK_NONE, 0x31, 0x5c},       /* backslash */
  {
  HACK_NONE, 0x32, 0x5c},       /* backslash */
  {
  HACK_NONE, 0x33, 0x3b},       /* semicolon */
  {
  HACK_NONE, 0x34, 0x27},       /* apostrophe */
  {
  HACK_NONE, 0x35, 0x60},       /* grave */
  {
  HACK_NONE, 0x36, 0x2c},       /* comma */
  {
  HACK_NONE, 0x37, 0x2e},       /* period */
  {
  HACK_NONE, 0x38, 0x2f},       /* slash */
  {
  HACK_NONE, 0x39, 0xffe5},     /* Caps_Lock */
  {
  HACK_NONE, 0x3A, 0xffbe},     /* F1 */
  {
  HACK_NONE, 0x3B, 0xffbf},     /* F2 */
  {
  HACK_NONE, 0x3C, 0xffc0},     /* F3 */
  {
  HACK_NONE, 0x3D, 0xffc1},     /* F4 */
  {
  HACK_NONE, 0x3E, 0xffc2},     /* F5 */
  {
  HACK_NONE, 0x3F, 0xffc3},     /* F6 */
  {
  HACK_NONE, 0x40, 0xffc4},     /* F7 */
  {
  HACK_NONE, 0x41, 0xffc5},     /* F8 */
  {
  HACK_NONE, 0x42, 0xffc6},     /* F9 */
  {
  HACK_NONE, 0x43, 0xffc7},     /* F10 */
  {
  HACK_NONE, 0x44, 0xffc8},     /* F11 */
  {
  HACK_NONE, 0x45, 0xffc9},     /* F12 */
  {
  HACK_NONE, 0x46, 0xff61},     /* Print */
  {
  HACK_NONE, 0x47, 0xff14},     /* Scroll_Lock */
  {
  HACK_NONE, 0x48, 0xff13},     /* Pause */
  {
  HACK_NONE, 0x49, 0xff63},     /* Insert */
  {
  HACK_NONE, 0x4A, 0xff50},     /* Home */
  {
  HACK_NONE, 0x4B, 0xff55},     /* Prior */
  {
  HACK_NONE, 0x4C, 0xffff},     /* Delete */
  {
  HACK_NONE, 0x4D, 0xff57},     /* End */
  {
  HACK_NONE, 0x4E, 0xff56},     /* Next */
  {
  HACK_NONE, 0x4F, 0xff53},     /* Right */
  {
  HACK_NONE, 0x50, 0xff51},     /* Left */
  {
  HACK_NONE, 0x51, 0xff54},     /* Down */
  {
  HACK_NONE, 0x52, 0xff52},     /* Up */
  {
  HACK_NONE, 0x53, 0xff7f},     /* Num_Lock */
  {
  HACK_NONE, 0x54, 0xffaf},     /* KP_Divide */
  {
  HACK_NONE, 0x55, 0xffaa},     /* KP_Multiply */
  {
  HACK_NONE, 0x56, 0xffad},     /* KP_Subtract */
  {
  HACK_NONE, 0x57, 0xffab},     /* KP_Add */
  {
  HACK_NONE, 0x58, 0xff8d},     /* KP_Enter */
  {
  HACK_NONE, 0x59, 0xffb1},     /* KP_1 */
  {
  HACK_NONE, 0x5A, 0xffb2},     /* KP_2 */
  {
  HACK_NONE, 0x5B, 0xffb3},     /* KP_3 */
  {
  HACK_NONE, 0x5C, 0xffb4},     /* KP_4 */
  {
  HACK_NONE, 0x5D, 0xffb5},     /* KP_5 */
  {
  HACK_NONE, 0x5E, 0xffb6},     /* KP_6 */
  {
  HACK_NONE, 0x5F, 0xffb7},     /* KP_7 */
  {
  HACK_NONE, 0x60, 0xffb8},     /* KP_8 */
  {
  HACK_NONE, 0x61, 0xffb9},     /* KP_9 */
  {
  HACK_NONE, 0x62, 0xffb0},     /* KP_0 */
  {
  HACK_NONE, 0x63, 0xffae},     /* KP_Decimal */
  {
  HACK_NONE, 0x64, 0x3c},       /* less */
  {
  HACK_NONE, 0x65, 0xff67},     /* Menu */
  {
  HACK_NONE, 0x66, 0x1008ff2a}, /* XF86PowerOff */
  {
  HACK_NONE, 0x67, 0xffbd},     /* KP_Equal */
  {
  HACK_NONE, 0x68, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x69, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x6A, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x6B, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x6C, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x6D, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x6E, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x6F, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x70, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x71, 0x1008ffa9}, /* XF86TouchpadToggle */
  {
  HACK_NONE, 0x72, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x73, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x74, 0x1005ff73}, /* SunOpen */
  {
  HACK_NONE, 0x75, 0xff6a},     /* Help */
  {
  HACK_NONE, 0x76, 0x1005ff70}, /* SunProps */
  {
  HACK_NONE, 0x77, 0x1005ff71}, /* SunFront */
  {
  HACK_NONE, 0x78, 0xff69},     /* Cancel */
  {
  HACK_NONE, 0x79, 0xff66},     /* Redo */
  {
  HACK_NONE, 0x7A, 0xff65},     /* Undo */
  {
  HACK_NONE, 0x7B, 0x1008ff58}, /* XF86Cut */
  {
  HACK_NONE, 0x7C, 0x1008ff57}, /* XF86Copy */
  {
  HACK_NONE, 0x7D, 0x1008ff6d}, /* XF86Paste */
  {
  HACK_NONE, 0x7E, 0xff68},     /* Find */
  {
  HACK_NONE, 0x7F, 0x1008ff12}, /* XF86AudioMute */
  {
  HACK_NONE, 0x80, 0x1008ff13}, /* XF86AudioRaiseVolume */
  {
  HACK_NONE, 0x81, 0x1008ff11}, /* XF86AudioLowerVolume */
  {
  HACK_NONE, 0x82, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x83, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x84, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x85, 0xffae},     /* KP_Decimal */
  {
  HACK_NONE, 0x86, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x87, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x88, 0xff27},     /* Hiragana_Katakana */
  {
  HACK_NONE, 0x89, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x8A, 0xff23},     /* Henkan_Mode */
  {
  HACK_NONE, 0x8B, 0xff22},     /* Muhenkan */
  {
  HACK_NONE, 0x8C, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x8D, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x8E, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x8F, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x90, 0xff31},     /* Hangul */
  {
  HACK_NONE, 0x91, 0xff34},     /* Hangul_Hanja */
  {
  HACK_NONE, 0x92, 0xff26},     /* Katakana */
  {
  HACK_NONE, 0x93, 0xff25},     /* Hiragana */
  {
  HACK_NONE, 0x94, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x95, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x96, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x97, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x98, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x99, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x9A, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x9B, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x9C, 0xffff},     /* Delete */
  {
  HACK_NONE, 0x9D, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x9E, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0x9F, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xA0, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xA1, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xA2, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xA3, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xA4, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xA5, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xA6, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xA7, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xA8, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xA9, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xAA, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xAB, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xAC, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xAD, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xAE, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xAF, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xB0, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xB1, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xB2, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xB3, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xB4, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xB5, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xB6, 0x28},       /* parenleft */
  {
  HACK_NONE, 0xB7, 0x29},       /* parenright */
  {
  HACK_NONE, 0xB8, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xB9, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xBA, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xBB, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xBC, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xBD, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xBE, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xBF, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xC0, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xC1, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xC2, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xC3, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xC4, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xC5, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xC6, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xC7, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xC8, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xC9, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xCA, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xCB, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xCC, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xCD, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xCE, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xCF, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xD0, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xD1, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xD2, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xD3, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xD4, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xD5, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xD6, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xD7, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xD8, 0xffff},     /* Delete */
  {
  HACK_NONE, 0xD9, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xDA, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xDB, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xDC, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xDD, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xDE, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xDF, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xE0, 0xffe3},     /* Control_L */
  {
  HACK_NONE, 0xE1, 0xffe1},     /* Shift_L */
  {
  HACK_NONE, 0xE2, 0xffe9},     /* Alt_L */
  {
  HACK_NONE, 0xE3, 0xffeb},     /* Super_L */
  {
  HACK_NONE, 0xE4, 0xffe4},     /* Control_R */
  {
  HACK_NONE, 0xE5, 0xffe2},     /* Shift_R */
  {
  HACK_NONE, 0xE6, 0xffea},     /* Alt_R */
  {
  HACK_NONE, 0xE7, 0xffec},     /* Super_R */
  {
  HACK_NONE, 0xE8, 0x1008ff14}, /* XF86AudioPlay */
  {
  HACK_NONE, 0xE9, 0x1008ff15}, /* XF86AudioStop */
  {
  HACK_NONE, 0xEA, 0x1008ff16}, /* XF86AudioPrev */
  {
  HACK_NONE, 0xEB, 0x1008ff17}, /* XF86AudioNext */
  {
  HACK_NONE, 0xEC, 0x1008ff2c}, /* XF86Eject */
  {
  HACK_NONE, 0xED, 0x1008ff13}, /* XF86AudioRaiseVolume */
  {
  HACK_NONE, 0xEE, 0x1008ff11}, /* XF86AudioLowerVolume */
  {
  HACK_NONE, 0xEF, 0x1008ff12}, /* XF86AudioMute */
  {
  HACK_NONE, 0xF0, 0x1008ff2e}, /* XF86WWW */
  {
  HACK_NONE, 0xF1, 0x1008ff26}, /* XF86Back */
  {
  HACK_NONE, 0xF2, 0x1008ff27}, /* XF86Forward */
  {
  HACK_NONE, 0xF3, 0xff69},     /* Cancel */
  {
  HACK_NONE, 0xF4, 0xff68},     /* Find */
  {
  HACK_NONE, 0xF5, 0x1008ff78}, /* XF86ScrollUp */
  {
  HACK_NONE, 0xF6, 0x1008ff79}, /* XF86ScrollDown */
  {
  HACK_NONE, 0xF7, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xF8, 0x1008ff2f}, /* XF86Sleep */
  {
  HACK_NONE, 0xF9, 0x1008ff2d}, /* XF86ScreenSaver */
  {
  HACK_NONE, 0xFA, 0x1008ff73}, /* XF86Reload */
  {
  HACK_NONE, 0xFB, 0x1008ff1d}, /* XF86Calculator */
  {
  HACK_NONE, 0xFC, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xFD, 0x0},        /* NoSymbol */
  {
  HACK_NONE, 0xFE, 0x0},        /* NoSymbol */
};

#define MAP_LEN (sizeof(map)/sizeof(struct map_ent))


#if  0
#define MAP_LEN 256
static int kc_map[MAP_LEN];
static KeySym kc_map[MAP_LEN] = {
  [0x04] = 0x61,                /* a */
  [0x05] = 0x62,                /* b */
  [0x06] = 0x63,                /* c */
  [0x07] = 0x64,                /* d */
  [0x08] = 0x65,                /* e */
  [0x09] = 0x66,                /* f */
  [0x0a] = 0x67,                /* g */
  [0x0b] = 0x68,                /* h */
  [0x0c] = 0x69,                /* i */
  [0x0d] = 0x6a,                /* j */
  [0x0e] = 0x6b,                /* k */
  [0x0f] = 0x6c,                /* l */
  [0x10] = 0x6d,                /* m */
  [0x11] = 0x6e,                /* n */
  [0x12] = 0x6f,                /* o */
  [0x13] = 0x70,                /* p */
  [0x14] = 0x71,                /* q */
  [0x15] = 0x72,                /* r */
  [0x16] = 0x73,                /* s */
  [0x17] = 0x74,                /* t */
  [0x18] = 0x75,                /* u */
  [0x19] = 0x76,                /* v */
  [0x1a] = 0x77,                /* w */
  [0x1b] = 0x78,                /* x */
  [0x1c] = 0x79,                /* y */
  [0x1d] = 0x7a,                /* z */
  [0x1e] = 0x31,                /* 1 */
  [0x1f] = 0x32,                /* 2 */
  [0x20] = 0x33,                /* 3 */
  [0x21] = 0x34,                /* 4 */
  [0x22] = 0x35,                /* 5 */
  [0x23] = 0x36,                /* 6 */
  [0x24] = 0x37,                /* 7 */
  [0x25] = 0x38,                /* 8 */
  [0x26] = 0x39,                /* 9 */
  [0x27] = 0x30,                /* 0 */
  [0x28] = 0xff0d,              /* Return */
  [0x29] = 0xff1b,              /* Escape */
  [0x2a] = 0xff08,              /* BackSpace */
  [0x2b] = 0xff09,              /* Tab */
  [0x2c] = 0x20,                /* space */
  [0x2d] = 0x2d,                /* minus */
  [0x2e] = 0x3d,                /* equal */
  [0x2f] = 0x5b,                /* bracketleft */
  [0x30] = 0x5d,                /* bracketright */
  [0x31] = 0x5c,                /* backslash */
  [0x32] = 0x5c,                /* backslash */
  [0x33] = 0x3b,                /* semicolon */
  [0x34] = 0x27,                /* apostrophe */
  [0x35] = 0x60,                /* grave */
  [0x36] = 0x2c,                /* comma */
  [0x37] = 0x2e,                /* period */
  [0x38] = 0x2f,                /* slash */
  [0x39] = 0xffe5,              /* Caps_Lock */
  [0x3A] = 0xffbe,              /* F1 */
  [0x3B] = 0xffbf,              /* F2 */
  [0x3C] = 0xffc0,              /* F3 */
  [0x3D] = 0xffc1,              /* F4 */
  [0x3E] = 0xffc2,              /* F5 */
  [0x3F] = 0xffc3,              /* F6 */
  [0x40] = 0xffc4,              /* F7 */
  [0x41] = 0xffc5,              /* F8 */
  [0x42] = 0xffc6,              /* F9 */
  [0x43] = 0xffc7,              /* F10 */
  [0x44] = 0xffc8,              /* F11 */
  [0x45] = 0xffc9,              /* F12 */
  [0x46] = 0xff61,              /* Print */
  [0x47] = 0xff14,              /* Scroll_Lock */
  [0x48] = 0xff13,              /* Pause */
  [0x49] = 0xff63,              /* Insert */
  [0x4A] = 0xff50,              /* Home */
  [0x4B] = 0xff55,              /* Prior */
  [0x4C] = 0xffff,              /* Delete */
  [0x4D] = 0xff57,              /* End */
  [0x4E] = 0xff56,              /* Next */
  [0x4F] = 0xff53,              /* Right */
  [0x50] = 0xff51,              /* Left */
  [0x51] = 0xff54,              /* Down */
  [0x52] = 0xff52,              /* Up */
  [0x53] = 0xff7f,              /* Num_Lock */
  [0x54] = 0xffaf,              /* KP_Divide */
  [0x55] = 0xffaa,              /* KP_Multiply */
  [0x56] = 0xffad,              /* KP_Subtract */
  [0x57] = 0xffab,              /* KP_Add */
  [0x58] = 0xff8d,              /* KP_Enter */
  [0x59] = 0xffb1,              /* KP_1 */
  [0x5A] = 0xffb2,              /* KP_2 */
  [0x5B] = 0xffb3,              /* KP_3 */
  [0x5C] = 0xffb4,              /* KP_4 */
  [0x5D] = 0xffb5,              /* KP_5 */
  [0x5E] = 0xffb6,              /* KP_6 */
  [0x5F] = 0xffb7,              /* KP_7 */
  [0x60] = 0xffb8,              /* KP_8 */
  [0x61] = 0xffb9,              /* KP_9 */
  [0x62] = 0xffb0,              /* KP_0 */
  [0x63] = 0xffae,              /* KP_Decimal */
  [0x64] = 0x3c,                /* less */
  [0x65] = 0xff67,              /* Menu */
  [0x66] = 0x1008ff2a,          /* XF86PowerOff */
  [0x67] = 0xffbd,              /* KP_Equal */
  [0x68] = 0x0,                 /* NoSymbol */
  [0x69] = 0x0,                 /* NoSymbol */
  [0x6A] = 0x0,                 /* NoSymbol */
  [0x6B] = 0x0,                 /* NoSymbol */
  [0x6C] = 0x0,                 /* NoSymbol */
  [0x6D] = 0x0,                 /* NoSymbol */
  [0x6E] = 0x0,                 /* NoSymbol */
  [0x6F] = 0x0,                 /* NoSymbol */
  [0x70] = 0x0,                 /* NoSymbol */
  [0x71] = 0x1008ffa9,          /* XF86TouchpadToggle */
  [0x72] = 0x0,                 /* NoSymbol */
  [0x73] = 0x0,                 /* NoSymbol */
  [0x74] = 0x1005ff73,          /* SunOpen */
  [0x75] = 0xff6a,              /* Help */
  [0x76] = 0x1005ff70,          /* SunProps */
  [0x77] = 0x1005ff71,          /* SunFront */
  [0x78] = 0xff69,              /* Cancel */
  [0x79] = 0xff66,              /* Redo */
  [0x7A] = 0xff65,              /* Undo */
  [0x7B] = 0x1008ff58,          /* XF86Cut */
  [0x7C] = 0x1008ff57,          /* XF86Copy */
  [0x7D] = 0x1008ff6d,          /* XF86Paste */
  [0x7E] = 0xff68,              /* Find */
  [0x7F] = 0x1008ff12,          /* XF86AudioMute */
  [0x80] = 0x1008ff13,          /* XF86AudioRaiseVolume */
  [0x81] = 0x1008ff11,          /* XF86AudioLowerVolume */
  [0x82] = 0x0,                 /* NoSymbol */
  [0x83] = 0x0,                 /* NoSymbol */
  [0x84] = 0x0,                 /* NoSymbol */
  [0x85] = 0xffae,              /* KP_Decimal */
  [0x86] = 0x0,                 /* NoSymbol */
  [0x87] = 0x0,                 /* NoSymbol */
  [0x88] = 0xff27,              /* Hiragana_Katakana */
  [0x89] = 0x0,                 /* NoSymbol */
  [0x8A] = 0xff23,              /* Henkan_Mode */
  [0x8B] = 0xff22,              /* Muhenkan */
  [0x8C] = 0x0,                 /* NoSymbol */
  [0x8D] = 0x0,                 /* NoSymbol */
  [0x8E] = 0x0,                 /* NoSymbol */
  [0x8F] = 0x0,                 /* NoSymbol */
  [0x90] = 0xff31,              /* Hangul */
  [0x91] = 0xff34,              /* Hangul_Hanja */
  [0x92] = 0xff26,              /* Katakana */
  [0x93] = 0xff25,              /* Hiragana */
  [0x94] = 0x0,                 /* NoSymbol */
  [0x95] = 0x0,                 /* NoSymbol */
  [0x96] = 0x0,                 /* NoSymbol */
  [0x97] = 0x0,                 /* NoSymbol */
  [0x98] = 0x0,                 /* NoSymbol */
  [0x99] = 0x0,                 /* NoSymbol */
  [0x9A] = 0x0,                 /* NoSymbol */
  [0x9B] = 0x0,                 /* NoSymbol */
  [0x9C] = 0xffff,              /* Delete */
  [0x9D] = 0x0,                 /* NoSymbol */
  [0x9E] = 0x0,                 /* NoSymbol */
  [0x9F] = 0x0,                 /* NoSymbol */
  [0xA0] = 0x0,                 /* NoSymbol */
  [0xA1] = 0x0,                 /* NoSymbol */
  [0xA2] = 0x0,                 /* NoSymbol */
  [0xA3] = 0x0,                 /* NoSymbol */
  [0xA4] = 0x0,                 /* NoSymbol */
  [0xA5] = 0x0,                 /* NoSymbol */
  [0xA6] = 0x0,                 /* NoSymbol */
  [0xA7] = 0x0,                 /* NoSymbol */
  [0xA8] = 0x0,                 /* NoSymbol */
  [0xA9] = 0x0,                 /* NoSymbol */
  [0xAA] = 0x0,                 /* NoSymbol */
  [0xAB] = 0x0,                 /* NoSymbol */
  [0xAC] = 0x0,                 /* NoSymbol */
  [0xAD] = 0x0,                 /* NoSymbol */
  [0xAE] = 0x0,                 /* NoSymbol */
  [0xAF] = 0x0,                 /* NoSymbol */
  [0xB0] = 0x0,                 /* NoSymbol */
  [0xB1] = 0x0,                 /* NoSymbol */
  [0xB2] = 0x0,                 /* NoSymbol */
  [0xB3] = 0x0,                 /* NoSymbol */
  [0xB4] = 0x0,                 /* NoSymbol */
  [0xB5] = 0x0,                 /* NoSymbol */
  [0xB6] = 0x28,                /* parenleft */
  [0xB7] = 0x29,                /* parenright */
  [0xB8] = 0x0,                 /* NoSymbol */
  [0xB9] = 0x0,                 /* NoSymbol */
  [0xBA] = 0x0,                 /* NoSymbol */
  [0xBB] = 0x0,                 /* NoSymbol */
  [0xBC] = 0x0,                 /* NoSymbol */
  [0xBD] = 0x0,                 /* NoSymbol */
  [0xBE] = 0x0,                 /* NoSymbol */
  [0xBF] = 0x0,                 /* NoSymbol */
  [0xC0] = 0x0,                 /* NoSymbol */
  [0xC1] = 0x0,                 /* NoSymbol */
  [0xC2] = 0x0,                 /* NoSymbol */
  [0xC3] = 0x0,                 /* NoSymbol */
  [0xC4] = 0x0,                 /* NoSymbol */
  [0xC5] = 0x0,                 /* NoSymbol */
  [0xC6] = 0x0,                 /* NoSymbol */
  [0xC7] = 0x0,                 /* NoSymbol */
  [0xC8] = 0x0,                 /* NoSymbol */
  [0xC9] = 0x0,                 /* NoSymbol */
  [0xCA] = 0x0,                 /* NoSymbol */
  [0xCB] = 0x0,                 /* NoSymbol */
  [0xCC] = 0x0,                 /* NoSymbol */
  [0xCD] = 0x0,                 /* NoSymbol */
  [0xCE] = 0x0,                 /* NoSymbol */
  [0xCF] = 0x0,                 /* NoSymbol */
  [0xD0] = 0x0,                 /* NoSymbol */
  [0xD1] = 0x0,                 /* NoSymbol */
  [0xD2] = 0x0,                 /* NoSymbol */
  [0xD3] = 0x0,                 /* NoSymbol */
  [0xD4] = 0x0,                 /* NoSymbol */
  [0xD5] = 0x0,                 /* NoSymbol */
  [0xD6] = 0x0,                 /* NoSymbol */
  [0xD7] = 0x0,                 /* NoSymbol */
  [0xD8] = 0xffff,              /* Delete */
  [0xD9] = 0x0,                 /* NoSymbol */
  [0xDA] = 0x0,                 /* NoSymbol */
  [0xDB] = 0x0,                 /* NoSymbol */
  [0xDC] = 0x0,                 /* NoSymbol */
  [0xDD] = 0x0,                 /* NoSymbol */
  [0xDE] = 0x0,                 /* NoSymbol */
  [0xDF] = 0x0,                 /* NoSymbol */
  [0xE0] = 0xffe3,              /* Control_L */
  [0xE1] = 0xffe1,              /* Shift_L */
  [0xE2] = 0xffe9,              /* Alt_L */
  [0xE3] = 0xffeb,              /* Super_L */
  [0xE4] = 0xffe4,              /* Control_R */
  [0xE5] = 0xffe2,              /* Shift_R */
  [0xE6] = 0xffea,              /* Alt_R */
  [0xE7] = 0xffec,              /* Super_R */
  [0xE8] = 0x1008ff14,          /* XF86AudioPlay */
  [0xE9] = 0x1008ff15,          /* XF86AudioStop */
  [0xEA] = 0x1008ff16,          /* XF86AudioPrev */
  [0xEB] = 0x1008ff17,          /* XF86AudioNext */
  [0xEC] = 0x1008ff2c,          /* XF86Eject */
  [0xED] = 0x1008ff13,          /* XF86AudioRaiseVolume */
  [0xEE] = 0x1008ff11,          /* XF86AudioLowerVolume */
  [0xEF] = 0x1008ff12,          /* XF86AudioMute */
  [0xF0] = 0x1008ff2e,          /* XF86WWW */
  [0xF1] = 0x1008ff26,          /* XF86Back */
  [0xF2] = 0x1008ff27,          /* XF86Forward */
  [0xF3] = 0xff69,              /* Cancel */
  [0xF4] = 0xff68,              /* Find */
  [0xF5] = 0x1008ff78,          /* XF86ScrollUp */
  [0xF6] = 0x1008ff79,          /* XF86ScrollDown */
  [0xF7] = 0x0,                 /* NoSymbol */
  [0xF8] = 0x1008ff2f,          /* XF86Sleep */
  [0xF9] = 0x1008ff2d,          /* XF86ScreenSaver */
  [0xFA] = 0x1008ff73,          /* XF86Reload */
  [0xFB] = 0x1008ff1d,          /* XF86Calculator */
  [0xFC] = 0x0,                 /* NoSymbol */
  [0xFD] = 0x0,                 /* NoSymbol */
  [0xFE] = 0x0,                 /* NoSymbol */
};


static uint8_t
keycode_to_usb (int k)
{
  int i;
  for (i = 0; i < MAP_LEN; ++i)
    {
      if (kc_map[i] == k)
        return i;
    }
  return 0;
}
#endif

static uint32_t seq = 1;


static int
flush (struct usb_dev_handle *devh)
{
  int ret;
  uint8_t rbuf[36];
  uint8_t xbuf[31] = {
    0x55, 0x53, 0x42, 0x43,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x06, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x00,
    0x00, 0x00
  };
  memcpy (&xbuf[4], &seq, 4);
  seq++;

/*Sends SCSI test unit ready*/

  if (usb_bulk_write (devh, 0x2, xbuf, 31, 0) != 31)
    exit (1);
  ret = usb_bulk_read (devh, 0x81, rbuf, 36, 0);
  if (ret <= 0)
    exit (1);


  return 0;
}

static int
send_msg (struct usb_dev_handle *devh, uint8_t * msg)
{
  int ret;
  uint8_t xbuf[31] = {
    0x55, 0x53, 0x42, 0x43,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x10, 0xd9,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x00,
    0x4f, 0x54
  };
  uint8_t rbuf[36];

  memcpy (&xbuf[16], msg, 13);
  memcpy (&xbuf[4], &seq, 4);
  seq++;

/* READ CD-DA MSF !*/

  if (usb_bulk_write (devh, 0x2, xbuf, 31, 0) != 31)
    exit (1);
  ret = usb_bulk_read (devh, 0x81, rbuf, 36, 0);
  if (ret <= 0)
    exit (1);


  return 0;
}

static int
mouse (struct usb_dev_handle *devh, uint16_t x, uint16_t y, uint8_t s, int l,
       int m, int r)
{
  uint8_t bmask = (l ? 1 : 0) | (m ? 4 : 0) | (r ? 2 : 0);
  uint8_t msg[13] = { 0x33, bmask, s, x & 0xff,
    x >> 8, y & 0xff, y >> 8, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x00
  };

  printf ("Mouse x=%4d y=%4d scroll=%2x bmask=%x\n", x, y, s, bmask);

  return send_msg (devh, msg);
}

static int
key_down_list (struct usb_dev_handle *devh, uint8_t modifiers,
               uint8_t * keylist)
{
  uint8_t msg[13] = { 0x34, modifiers, 0x00 };
  memcpy (&msg[3], keylist, KEY_LIST_LEN);
  int i;

  printf ("Keybd modifiers mask=%x key list=", modifiers);

  for (i = 0; i < KEY_LIST_LEN; ++i)
    {
      if (keylist[i])
        printf ("%02x ", keylist[i]);
    }
  printf ("\n");
  return send_msg (devh, msg);
}

static uint8_t keys[KEY_LIST_LEN];


static int
key_down (struct usb_dev_handle *devh, uint8_t key, uint8_t modifiers)
{
  int i;

//printf("Key %d down modifiers %x\n",key,modifiers);

  if (key)
    {
      do
        {
          for (i = 0; i < sizeof (keys); ++i)
            {
              if (keys[i] == key)
                break;
            }

          for (i = 0; i < sizeof (keys); ++i)
            {
              if (!keys[i])
                {
                  keys[i] = key;
                  break;
                }
            }
        }
      while (0);
    }

  return key_down_list (devh, modifiers, keys);
}


static int
key_up (struct usb_dev_handle *devh, uint8_t key, uint8_t modifiers)
{
  int i;

//printf("Key %d up modifiers %x\n",key,modifiers);

  if (key)
    {
      for (i = 0; i < sizeof (keys); ++i)
        {
          if (keys[i] == key)
            keys[i] = 0;
        }
    }

  return key_down_list (devh, modifiers, keys);
}



static int
init (void)
{

  int i;
  struct usb_bus *bus;
  struct usb_device *dev;


  usb_init ();

  usb_set_debug (15);

  usb_find_busses ();
  usb_find_devices ();


  for (bus = usb_get_busses (); bus; bus = bus->next)
    {
      for (dev = bus->devices; dev; dev = dev->next)
        {
          if ((dev->descriptor.idVendor == 0x0ea0) &&
              (dev->descriptor.idProduct == 0x2211))
            break;
        }

      if (dev && (dev->descriptor.idVendor == 0x0ea0) &&
          (dev->descriptor.idProduct == 0x2211))
        break;
    }


  if (!dev)
    exit (1);

  devh = usb_open (dev);

  if (!devh)
    {
      printf ("can't open widget: %s\n", usb_strerror ());
      exit (1);

    }




  usb_detach_kernel_driver_np (devh, 0);
  usb_detach_kernel_driver_np (devh, 1);
  usb_detach_kernel_driver_np (devh, 2);
  usb_claim_interface (devh, 0);


  usb_clear_halt (devh, 0x81);
  usb_clear_halt (devh, 0x2);


#if 0
  key_down (devh, 0xe);
  flush (devh);
  key_up (devh, 0xe);
  flush (devh);
  key_down (devh, 0xf);
  flush (devh);
  key_up (devh, 0xf);
  flush (devh);
#endif



//mouse(devh,i,i,0,0,1);
//mouse(devh,i,i,0,0,0);
//mouse(devh,200,200,1,0,0);
//mouse(devh,200,200,0,0,0);

  return 0;
}

#include <stdio.h>

static int cx, cy;
static int bs[3];

void
fake_motion (int x, int y)
{
  cx = x;
  cy = y;

  mouse (devh, cx, cy, 0, bs[0], bs[1], bs[2]);
}


void
fake_scroll_event (int d)
{
  uint8_t s;


  if (d >= 0)
    {
      s = d;
    }
  else
    {
      s = 256 + d;
    }


  mouse (devh, cx, cy, s, bs[0], bs[1], bs[2]);
  flush (devh);

}

void
fake_button_event (int b, int ud)
{

  switch (b)
    {
    case 1:
    case 2:
    case 3:
      bs[b - 1] = ! !ud;
      mouse (devh, cx, cy, 0, bs[0], bs[1], bs[2]);
      break;
    case 4:
      if (ud)
        fake_scroll_event (1);
      break;
    case 5:
      if (ud)
        fake_scroll_event (-1);
      break;
    }

}

struct map_ent *
lookup_map_ent (int keycode, uint8_t modifiers)
{
  int i;

  for (i = 0; i < MAP_LEN; ++i)
    {
      if (map[i].keycode == keycode)
        {
          if (map[i].hacks & (HACK_RCS | HACK_HS))
            {                   /*Do we require a shift key to match ? */
              if (modifiers & HACK_SHIFT_MASK)
                return &map[i];
            }
          else
            {
              return &map[i];
            }
        }
    }
  return NULL;
}





void
fake_key_event (int k, int ud)
{
  static uint8_t modifiers;
  uint8_t mods;

  struct map_ent *e = lookup_map_ent (k, modifiers);

  if (!e)
    return;

  if (e->hacks & HACK_MODIFIER_MASK)
    {
      if (ud)
        {
          modifiers |= e->hacks & HACK_MODIFIER_MASK;
        }
      else
        {
          modifiers &= ~(e->hacks & HACK_MODIFIER_MASK);
        }
    }

  if (e->hacks & HACK_HS)
    {
      mods = modifiers & ~HACK_SHIFT_MASK;

      if (ud)
        {
          if (modifiers & HACK_SHIFT_L)
            key_up (devh, 0xe1, mods);
          if (modifiers & HACK_SHIFT_R)
            key_up (devh, 0xe5, mods);
        }


    }
  else
    {
      mods = modifiers;
    }

#if 0
  printf
    ("Hacks %8x, modifiers=%4x, mods=%4x, e->keysym=%4x, e->keycode=%4x, e->code=%2x\n",
     e->hacks, modifiers, mods, e->keysym, e->keycode, e->code);
#endif

  if (ud)
    key_down (devh, e->code, mods);
  else
    key_up (devh, e->code, mods);

  if (e->hacks & HACK_HS)
    {
      if (!ud)
        {
          if (modifiers & HACK_SHIFT_L)
            key_down (devh, 0xe1, modifiers);
          if (modifiers & HACK_SHIFT_R)
            key_down (devh, 0xe5, modifiers);
        }
    }


  flush (devh);
}

void
init_map (Display * d)
{
  int i;
  for (i = 0; i < MAP_LEN; ++i)
    {
      map[i].keycode = XKeysymToKeycode (d, map[i].keysym);
    }
}

void
fake_init (Display * d)
{
  init_map (d);
  init ();
}