[teensytas.git] / host / main.c

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <unistd.h>
#include <dirent.h>
#include <signal.h>
#include <termios.h>
#include <errno.h>
#include <linux/usbdevice_fs.h>
#include <linux/usb/ch9.h>
#include <linux/input.h>

#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))

struct teensy_dev {
  int fd;
  struct {
    int ep_in;
    int ep_out;
  } ifaces[2];
};

/* return 1 if founf, 0 if not, < 0 on error */
static int find_device(struct teensy_dev *dev,
  uint16_t vendor, uint16_t product)
{
  const char path_root[] = "/dev/bus/usb";
  union {
    struct usb_descriptor_header hdr;
    struct usb_device_descriptor d;
    struct usb_config_descriptor c;
    struct usb_interface_descriptor i;
    struct usb_endpoint_descriptor e;
    char space[0x100]; /* enough? */
  } desc;
  char path_bus[256], path_dev[256];
  struct dirent *ent, *ent_bus;
  DIR *dir = NULL, *dir_bus = NULL;
  int num, fd = -1;
  int iface = -1;
  int retval = -1;
  int ret;

  memset(dev, 0xff, sizeof(*dev));

  dir = opendir(path_root);
  if (dir == NULL) {
    perror("opendir");
    return -1;
  }

  for (ent = readdir(dir); ent != NULL; ent = readdir(dir)) {
    /* should be a number like 000 */
    if (sscanf(ent->d_name, "%03d", &num) != 1)
      continue;

    snprintf(path_bus, sizeof(path_bus), "%s/%s",
        path_root, ent->d_name);

    dir_bus = opendir(path_bus);
    if (dir_bus == NULL)
      continue;

    ent_bus = readdir(dir_bus);
    for (; ent_bus != NULL; ent_bus = readdir(dir_bus)) {
      if (sscanf(ent->d_name, "%03d", &num) != 1)
        continue;

      snprintf(path_dev, sizeof(path_dev), "%s/%s/%s",
          path_root, ent->d_name, ent_bus->d_name);

      fd = open(path_dev, O_RDWR);
      if (fd == -1)
        continue;

      ret = read(fd, &desc.d, sizeof(desc.d));
      if (ret != sizeof(desc.d)) {
        fprintf(stderr, "desc read: %d/%zd: ", ret, sizeof(desc.d));
        perror("");
        goto next;
      }

      if (desc.d.bDescriptorType != USB_DT_DEVICE) {
        fprintf(stderr, "%s: bad DT: 0x%02x\n",
            path_dev, desc.d.bDescriptorType);
        goto next;
      }

      if (desc.d.idVendor == vendor && desc.d.idProduct == product)
        goto found;

next:
      close(fd);
      fd = -1;
    }

    closedir(dir_bus);
    dir_bus = NULL;
  }

  /* not found */
  retval = 0;
  goto out;

found:
  if (desc.d.bNumConfigurations != 1) {
    fprintf(stderr, "unexpected bNumConfigurations: %u\n",
        desc.d.bNumConfigurations);
    goto out;
  }

  /* walk through all descriptors */
  while (1)
  {
    ret = read(fd, &desc.hdr, sizeof(desc.hdr));
    if (ret == 0)
      break;
    if (ret != sizeof(desc.hdr)) {
      fprintf(stderr, "desc.hdr read: %d/%zd: ", ret, sizeof(desc.hdr));
      perror("");
      break;
    }

    ret = (int)lseek(fd, -sizeof(desc.hdr), SEEK_CUR);
    if (ret == -1) {
      perror("lseek");
      break;
    }

    ret = read(fd, &desc, desc.hdr.bLength);
    if (ret != desc.hdr.bLength) {
      fprintf(stderr, "desc read: %d/%u: ", ret, desc.hdr.bLength);
      perror("");
      break;
    }

    switch (desc.hdr.bDescriptorType) {
      case USB_DT_CONFIG:
        if (desc.c.bNumInterfaces != 2) {
          fprintf(stderr, "unexpected bNumInterfaces: %u\n",
              desc.c.bNumInterfaces);
          goto out;
        }
        break;

      case USB_DT_INTERFACE:
        if (desc.i.bInterfaceClass != USB_CLASS_HID
            || desc.i.bInterfaceSubClass != 0
            || desc.i.bInterfaceProtocol != 0) {
          fprintf(stderr, "unexpected interface %x:%x:%x\n",
            desc.i.bInterfaceClass, desc.i.bInterfaceSubClass,
            desc.i.bInterfaceProtocol);
          goto out;
        }
        if (desc.i.bNumEndpoints != 2) {
          fprintf(stderr, "unexpected bNumEndpoints: %u\n",
            desc.i.bNumEndpoints);
          goto out;
        }
        iface++;
        break;

      case USB_DT_ENDPOINT:
        if (iface < 0 || iface >= ARRAY_SIZE(dev->ifaces)) {
          fprintf(stderr, "bad iface: %d\n", iface);
          goto out;
        }
        if (desc.e.wMaxPacketSize != 64 && desc.e.wMaxPacketSize != 32) {
          fprintf(stderr, "iface %d, EP %02x: "
            "unexpected wMaxPacketSize: %u\n",
            iface, desc.e.bEndpointAddress, desc.e.wMaxPacketSize);
          goto out;
        }
        if (desc.e.bEndpointAddress & 0x80)
          dev->ifaces[iface].ep_in = desc.e.bEndpointAddress; // & 0x7F;
        else
          dev->ifaces[iface].ep_out = desc.e.bEndpointAddress;
        break;

      case 0x21:
        /* ignore */
        break;

      default:
        fprintf(stderr, "skipping desc 0x%02x\n",
          desc.hdr.bDescriptorType);
        break;
    }
  }

  /* claim interfaces */
  for (iface = 0; iface < ARRAY_SIZE(dev->ifaces); iface++) {
    struct usbdevfs_ioctl usbio;

    if (dev->ifaces[iface].ep_in == -1) {
      fprintf(stderr, "missing ep_in, iface: %d\n", iface);
      goto out;
    }
    if (dev->ifaces[iface].ep_out == -1) {
      fprintf(stderr, "missing ep_out, iface: %d\n", iface);
      goto out;
    }

    /* disconnect default driver */
    memset(&usbio, 0, sizeof(usbio));
    usbio.ifno = iface;
    usbio.ioctl_code = USBDEVFS_DISCONNECT;
    ret = ioctl(fd, USBDEVFS_IOCTL, &usbio);
    if (ret != 0 && errno != ENODATA)
      perror("USBDEVFS_DISCONNECT");

    ret = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &iface);
    if (ret != 0)
      perror("USBDEVFS_CLAIMINTERFACE");
  }

  dev->fd = fd;
  fd = -1;
  retval = 1;

out:
  if (fd != -1)
    close(fd);
  if (dir_bus != NULL)
    closedir(dir_bus);
  if (dir != NULL)
    closedir(dir);

  return retval;
}

static int enable_echo(int enable)
{
  const char *portname = "/dev/tty";
  struct termios tty;
  int retval = -1;
  int ret;
  int fd;

  memset(&tty, 0, sizeof(tty));

  fd = open(portname, O_RDWR | O_NOCTTY | O_SYNC);
  if (fd < 0) {
    fprintf(stderr, "open %s: ", portname);
    perror("");
    return 1;
  }

  ret = tcgetattr(fd, &tty);
  if (ret != 0) {
    perror("tcgetattr");
    goto out;
  }

  // printf("lflag: 0%o\n", tty.c_lflag);
  if (enable)
    tty.c_lflag |= ECHO;
  else
    tty.c_lflag &= ~ECHO;

  ret = tcsetattr(fd, TCSANOW, &tty);
  if (ret != 0) {
    perror("tcsetattr");
    goto out;
  }

  retval = 0;
out:
  close(fd);

  return retval;
}

static void signal_handler(int sig)
{
  enable_echo(1);
  signal(sig, SIG_DFL);
  raise(sig);
}

/* ?0SA 00DU, ?1CB RLDU */
#define STATE_BYTES 2

static uint8_t fixed_input_state[STATE_BYTES] = { 0x33, 0x3f };

enum mdbtn {
  MDBTN_UP = 1,
  MDBTN_DOWN,
  MDBTN_LEFT,
  MDBTN_RIGHT,
  MDBTN_A,
  MDBTN_B,
  MDBTN_C,
  MDBTN_START,
};

static const enum mdbtn evdev_md_map[KEY_CNT] = {
  [KEY_UP]       = MDBTN_UP,
  [KEY_DOWN]     = MDBTN_DOWN,
  [KEY_LEFT]     = MDBTN_LEFT,
  [KEY_RIGHT]    = MDBTN_RIGHT,
  [KEY_HOME]     = MDBTN_A,
  [KEY_PAGEDOWN] = MDBTN_B,
  [KEY_END]      = MDBTN_C,
  [KEY_LEFTALT]  = MDBTN_START,
};

int do_evdev_input(int fd)
{
  uint8_t old_state[STATE_BYTES];
  uint8_t changed_bits[STATE_BYTES] = { 0, };
  struct input_event ev;
  enum mdbtn mdbtn;
  int i, ret;

  ret = read(fd, &ev, sizeof(ev));
  if (ret != sizeof(ev)) {
    fprintf(stderr, "evdev read %d/%zd: ", ret, sizeof(ev));
    perror("");
    return 0;
  }

  if (ev.type != EV_KEY)
    return 0;

  if (ev.value != 0 && ev.value != 1)
    return 0;

  if ((uint32_t)ev.code >= ARRAY_SIZE(evdev_md_map)) {
    fprintf(stderr, "evdev read bad key: %u\n", ev.code);
    return 0;
  }

  mdbtn = evdev_md_map[ev.code];
  if (mdbtn == 0)
    return 0;

  memcpy(old_state, fixed_input_state, STATE_BYTES);

  /* ?0SA 00DU, ?1CB RLDU */
  switch (mdbtn) {
  case MDBTN_UP:
    changed_bits[0] = 0x01;
    changed_bits[1] = 0x01;
    break;
  case MDBTN_DOWN:
    changed_bits[0] = 0x02;
    changed_bits[1] = 0x02;
    break;
  case MDBTN_LEFT:
    changed_bits[0] = 0x00;
    changed_bits[1] = 0x04;
    break;
  case MDBTN_RIGHT:
    changed_bits[0] = 0x00;
    changed_bits[1] = 0x08;
    break;
  case MDBTN_A:
    changed_bits[0] = 0x10;
    changed_bits[1] = 0x00;
    break;
  case MDBTN_B:
    changed_bits[0] = 0x00;
    changed_bits[1] = 0x10;
    break;
  case MDBTN_C:
    changed_bits[0] = 0x00;
    changed_bits[1] = 0x20;
    break;
  case MDBTN_START:
    changed_bits[0] = 0x20;
    changed_bits[1] = 0x00;
    break;
  }

  if (ev.value) {
    // key press
    for (i = 0; i < STATE_BYTES; i++)
      fixed_input_state[i] &= ~changed_bits[i];
  }
  else {
    // key release
    for (i = 0; i < STATE_BYTES; i++)
      fixed_input_state[i] |=  changed_bits[i];
  }

  return memcmp(old_state, fixed_input_state, STATE_BYTES) ? 1 : 0;
}

enum my_urbs {
  URB_DATA_IN,
  URB_DATA_OUT,
  URB_DBG_IN,
  URB_CNT
};

int main(int argc, char *argv[])
{
  char buf_dbg[64 + 1], buf_in[64], buf_out[64];
  struct teensy_dev dev;
  struct usbdevfs_urb urb[URB_CNT];
  struct usbdevfs_urb *reaped_urb;
  int fixed_input_changed;
  int evdev_fds[16];
  int evdev_fd_cnt = 0;
  int evdev_support;
  int wait_device = 0;
  int dbg_in_sent = 0;
  int data_in_sent = 0;
  fd_set rfds, wfds;
  int i, ret;
  int fd;

  for (i = 1; i < argc; i++) {
    if (evdev_fd_cnt >= ARRAY_SIZE(evdev_fds)) {
      fprintf(stderr, "too many evdevs\n");
      break;
    }
		fd = open(argv[i], O_RDONLY);
    if (fd == -1) {
      fprintf(stderr, "open %s: ", argv[i]);
      perror("");
      continue;
    }
    evdev_support = 0;
		ret = ioctl(fd, EVIOCGBIT(0, sizeof(evdev_support)),
                &evdev_support);
    if (ret < 0)
      perror("EVIOCGBIT");
    if (!(evdev_support & (1 << EV_KEY))) {
      fprintf(stderr, "%s doesn't have keys\n", argv[i]);
      close(fd);
      continue;
    }
    evdev_fds[evdev_fd_cnt++] = fd;
  }

  enable_echo(0);
  signal(SIGINT, signal_handler);

  dev.fd = -1;

  while (1)
  {
    if (dev.fd == -1) {
      ret = find_device(&dev, 0x16C0, 0x0486);
      if (ret < 0)
        break;

      if (ret == 0) {
        if (!wait_device) {
          printf("waiting for device..\n");
          wait_device = 1;
        }
        usleep(250000);
        continue;
      }

      wait_device = 0;
      data_in_sent = 0;
      dbg_in_sent = 0;
    }

    if (!data_in_sent) {
      memset(&urb[URB_DATA_IN], 0, sizeof(urb[URB_DATA_IN]));
      urb[URB_DATA_IN].type = USBDEVFS_URB_TYPE_INTERRUPT;
      urb[URB_DATA_IN].endpoint = dev.ifaces[0].ep_in;
      urb[URB_DATA_IN].buffer = buf_in;
      urb[URB_DATA_IN].buffer_length = sizeof(buf_in);

      ret = ioctl(dev.fd, USBDEVFS_SUBMITURB, &urb[URB_DATA_IN]);
      if (ret != 0) {
        perror("USBDEVFS_SUBMITURB URB_DATA_IN");
        break;
      }
      data_in_sent = 1;
    }
    if (!dbg_in_sent) {
      memset(&urb[URB_DBG_IN], 0, sizeof(urb[URB_DBG_IN]));
      urb[URB_DBG_IN].type = USBDEVFS_URB_TYPE_INTERRUPT;
      urb[URB_DBG_IN].endpoint = dev.ifaces[1].ep_in;
      urb[URB_DBG_IN].buffer = buf_dbg;
      urb[URB_DBG_IN].buffer_length = sizeof(buf_dbg) - 1;

      ret = ioctl(dev.fd, USBDEVFS_SUBMITURB, &urb[URB_DBG_IN]);
      if (ret != 0) {
        perror("USBDEVFS_SUBMITURB URB_DBG_IN");
        break;
      }
      dbg_in_sent = 1;
    }

    FD_ZERO(&rfds);
    for (i = 0; i < evdev_fd_cnt; i++)
      FD_SET(evdev_fds[i], &rfds);

    FD_ZERO(&wfds);
    FD_SET(dev.fd, &wfds);

    ret = select(dev.fd + 1, &rfds, &wfds, NULL, NULL);
    if (ret < 0) {
      perror("select");
      break;
    }

    /* something from input devices? */
    fixed_input_changed = 0;
    for (i = 0; i < evdev_fd_cnt; i++) {
      if (FD_ISSET(evdev_fds[i], &rfds)) {
        fixed_input_changed |=
          do_evdev_input(evdev_fds[i]);
      }
    }

    /* something from USB? */
    if (FD_ISSET(dev.fd, &wfds)) {
      reaped_urb = NULL;
      ret = ioctl(dev.fd, USBDEVFS_REAPURB, &reaped_urb);
      if (ret != 0) {
        if (errno == ENODEV)
          goto dev_close;
        perror("USBDEVFS_REAPURB");
        break;
      }

      if (reaped_urb != NULL && reaped_urb->status != 0) {
        errno = -reaped_urb->status;
        perror("urb status");
        if (reaped_urb->status == -EILSEQ) {
          /* this is usually a sign of disconnect.. */
          usleep(250000);
          goto dev_close;
        }
      }

      if (reaped_urb == &urb[URB_DATA_IN]) {
        printf("*data*\n");
        data_in_sent = 0;
      }
      if (reaped_urb == &urb[URB_DATA_OUT]) {
      }
      else if (reaped_urb == &urb[URB_DBG_IN]) {
        /* debug text */
        buf_dbg[reaped_urb->actual_length] = 0;
        printf("%s", buf_dbg);
        dbg_in_sent = 0;
      }
      else {
        fprintf(stderr, "reaped unknown urb? %p\n", reaped_urb);
      }
    }

    /* something to send? */
    if (fixed_input_changed) {
      memset(buf_out, 0, sizeof(buf_out));
      memcpy(buf_out, fixed_input_state, sizeof(fixed_input_state));

      memset(&urb[URB_DATA_OUT], 0, sizeof(urb[URB_DATA_OUT]));
      urb[URB_DATA_OUT].type = USBDEVFS_URB_TYPE_INTERRUPT;
      urb[URB_DATA_OUT].endpoint = dev.ifaces[0].ep_out;
      urb[URB_DATA_OUT].buffer = buf_out;
      urb[URB_DATA_OUT].buffer_length = sizeof(buf_out);

      ret = ioctl(dev.fd, USBDEVFS_SUBMITURB, &urb[URB_DATA_OUT]);
      if (ret != 0) {
        perror("USBDEVFS_SUBMITURB URB_DATA_OUT");
        break;
      }
    }

    continue;

dev_close:
    close(dev.fd);
    dev.fd = -1;
  }

  enable_echo(1);

  return ret;
}

// vim: ts=2:sw=2:expandtab
Commit	Line	Data
932302ef	1	#include <stdio.h>
932302ef	2	#include <string.h>
932302ef	3	#include <stdint.h>
932302ef	4	#include <sys/types.h>
	5	#include <sys/stat.h>
	6	#include <fcntl.h>
	7	#include <sys/ioctl.h>
	8	#include <sys/select.h>
	9	#include <unistd.h>
	10	#include <dirent.h>
f359b935	11	#include <signal.h>
f359b935	12	#include <termios.h>
932302ef	13	#include <errno.h>
	14	#include <linux/usbdevice_fs.h>
	15	#include <linux/usb/ch9.h>
1cb2822f	16	#include <linux/input.h>
932302ef	17
	18	#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
	19
932302ef	20	struct teensy_dev {
	21	int fd;
	22	struct {
	23	int ep_in;
	24	int ep_out;
	25	} ifaces[2];
	26	};
	27
	28	/* return 1 if founf, 0 if not, < 0 on error */
	29	static int find_device(struct teensy_dev *dev,
	30	uint16_t vendor, uint16_t product)
	31	{
	32	const char path_root[] = "/dev/bus/usb";
	33	union {
	34	struct usb_descriptor_header hdr;
	35	struct usb_device_descriptor d;
	36	struct usb_config_descriptor c;
	37	struct usb_interface_descriptor i;
	38	struct usb_endpoint_descriptor e;
	39	char space[0x100]; /* enough? */
	40	} desc;
	41	char path_bus[256], path_dev[256];
	42	struct dirent ent, ent_bus;
	43	DIR dir = NULL, dir_bus = NULL;
	44	int num, fd = -1;
	45	int iface = -1;
	46	int retval = -1;
	47	int ret;
	48
	49	memset(dev, 0xff, sizeof(*dev));
	50
	51	dir = opendir(path_root);
	52	if (dir == NULL) {
	53	perror("opendir");
	54	return -1;
	55	}
	56
	57	for (ent = readdir(dir); ent != NULL; ent = readdir(dir)) {
	58	/* should be a number like 000 */
	59	if (sscanf(ent->d_name, "%03d", &num) != 1)
	60	continue;
	61
	62	snprintf(path_bus, sizeof(path_bus), "%s/%s",
	63	path_root, ent->d_name);
	64
	65	dir_bus = opendir(path_bus);
	66	if (dir_bus == NULL)
	67	continue;
	68
	69	ent_bus = readdir(dir_bus);
	70	for (; ent_bus != NULL; ent_bus = readdir(dir_bus)) {
	71	if (sscanf(ent->d_name, "%03d", &num) != 1)
	72	continue;
	73
	74	snprintf(path_dev, sizeof(path_dev), "%s/%s/%s",
	75	path_root, ent->d_name, ent_bus->d_name);
	76
	77	fd = open(path_dev, O_RDWR);
	78	if (fd == -1)
	79	continue;
	80
	81	ret = read(fd, &desc.d, sizeof(desc.d));
	82	if (ret != sizeof(desc.d)) {
	83	fprintf(stderr, "desc read: %d/%zd: ", ret, sizeof(desc.d));
84	perror("");
85	goto next;
86	}
87
88	if (desc.d.bDescriptorType != USB_DT_DEVICE) {
89	fprintf(stderr, "%s: bad DT: 0x%02x\n",
90	path_dev, desc.d.bDescriptorType);
91	goto next;
92	}
93
94	if (desc.d.idVendor == vendor && desc.d.idProduct == product)
95	goto found;
96
97	next:
98	close(fd);
99	fd = -1;
100	}
101
102	closedir(dir_bus);
103	dir_bus = NULL;
104	}
105
106	/* not found */
107	retval = 0;
108	goto out;
109
110	found:
111	if (desc.d.bNumConfigurations != 1) {
112	fprintf(stderr, "unexpected bNumConfigurations: %u\n",
113	desc.d.bNumConfigurations);
114	goto out;
115	}
116
117	/* walk through all descriptors */
118	while (1)
119	{
120	ret = read(fd, &desc.hdr, sizeof(desc.hdr));
121	if (ret == 0)
122	break;
123	if (ret != sizeof(desc.hdr)) {
124	fprintf(stderr, "desc.hdr read: %d/%zd: ", ret, sizeof(desc.hdr));
125	perror("");
126	break;
127	}
128
129	ret = (int)lseek(fd, -sizeof(desc.hdr), SEEK_CUR);
130	if (ret == -1) {
131	perror("lseek");
132	break;
133	}
134
135	ret = read(fd, &desc, desc.hdr.bLength);
136	if (ret != desc.hdr.bLength) {
137	fprintf(stderr, "desc read: %d/%u: ", ret, desc.hdr.bLength);
138	perror("");
139	break;
140	}
141
142	switch (desc.hdr.bDescriptorType) {
143	case USB_DT_CONFIG:
144	if (desc.c.bNumInterfaces != 2) {
145	fprintf(stderr, "unexpected bNumInterfaces: %u\n",
146	desc.c.bNumInterfaces);
147	goto out;
148	}
149	break;
150
151	case USB_DT_INTERFACE:
152	if (desc.i.bInterfaceClass != USB_CLASS_HID
153	\|\| desc.i.bInterfaceSubClass != 0
154	\|\| desc.i.bInterfaceProtocol != 0) {
155	fprintf(stderr, "unexpected interface %x:%x:%x\n",
156	desc.i.bInterfaceClass, desc.i.bInterfaceSubClass,
157	desc.i.bInterfaceProtocol);
158	goto out;
159	}
160	if (desc.i.bNumEndpoints != 2) {
161	fprintf(stderr, "unexpected bNumEndpoints: %u\n",
162	desc.i.bNumEndpoints);
163	goto out;
164	}
165	iface++;
166	break;
167
168	case USB_DT_ENDPOINT:
169	if (iface < 0 \|\| iface >= ARRAY_SIZE(dev->ifaces)) {
170	fprintf(stderr, "bad iface: %d\n", iface);
171	goto out;
172	}
173	if (desc.e.wMaxPacketSize != 64 && desc.e.wMaxPacketSize != 32) {
174	fprintf(stderr, "iface %d, EP %02x: "
175	"unexpected wMaxPacketSize: %u\n",
176	iface, desc.e.bEndpointAddress, desc.e.wMaxPacketSize);
177	goto out;
178	}
179	if (desc.e.bEndpointAddress & 0x80)
180	dev->ifaces[iface].ep_in = desc.e.bEndpointAddress; // & 0x7F;
181	else
182	dev->ifaces[iface].ep_out = desc.e.bEndpointAddress;
183	break;
184
185	case 0x21:
186	/* ignore */
187	break;
188
189	default:
190	fprintf(stderr, "skipping desc 0x%02x\n",
191	desc.hdr.bDescriptorType);
192	break;
193	}
194	}
195
196	/* claim interfaces */
197	for (iface = 0; iface < ARRAY_SIZE(dev->ifaces); iface++) {
198	struct usbdevfs_ioctl usbio;
199
200	if (dev->ifaces[iface].ep_in == -1) {
201	fprintf(stderr, "missing ep_in, iface: %d\n", iface);
202	goto out;
203	}
204	if (dev->ifaces[iface].ep_out == -1) {
205	fprintf(stderr, "missing ep_out, iface: %d\n", iface);
206	goto out;
207	}
208
209	/* disconnect default driver */
210	memset(&usbio, 0, sizeof(usbio));
211	usbio.ifno = iface;
212	usbio.ioctl_code = USBDEVFS_DISCONNECT;
213	ret = ioctl(fd, USBDEVFS_IOCTL, &usbio);
214	if (ret != 0 && errno != ENODATA)
215	perror("USBDEVFS_DISCONNECT");
216
217	ret = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &iface);
218	if (ret != 0)
219	perror("USBDEVFS_CLAIMINTERFACE");
220	}
221
222	dev->fd = fd;
223	fd = -1;
224	retval = 1;
225
226	out:
227	if (fd != -1)
228	close(fd);
229	if (dir_bus != NULL)
230	closedir(dir_bus);
231	if (dir != NULL)
232	closedir(dir);
233
234	return retval;
235	}
236
f359b935	237	static int enable_echo(int enable)
	238	{
	239	const char *portname = "/dev/tty";
	240	struct termios tty;
	241	int retval = -1;
	242	int ret;
	243	int fd;
	244
	245	memset(&tty, 0, sizeof(tty));
	246
	247	fd = open(portname, O_RDWR \| O_NOCTTY \| O_SYNC);
	248	if (fd < 0) {
	249	fprintf(stderr, "open %s: ", portname);
	250	perror("");
	251	return 1;
	252	}
	253
	254	ret = tcgetattr(fd, &tty);
	255	if (ret != 0) {
	256	perror("tcgetattr");
	257	goto out;
	258	}
	259
	260	// printf("lflag: 0%o\n", tty.c_lflag);
	261	if (enable)
	262	tty.c_lflag \|= ECHO;
	263	else
	264	tty.c_lflag &= ~ECHO;
	265
	266	ret = tcsetattr(fd, TCSANOW, &tty);
	267	if (ret != 0) {
	268	perror("tcsetattr");
	269	goto out;
	270	}
	271
	272	retval = 0;
	273	out:
	274	close(fd);
	275
	276	return retval;
	277	}
	278
	279	static void signal_handler(int sig)
	280	{
	281	enable_echo(1);
	282	signal(sig, SIG_DFL);
	283	raise(sig);
	284	}
	285
1cb2822f	286	/* ?0SA 00DU, ?1CB RLDU */
	287	#define STATE_BYTES 2
	288
	289	static uint8_t fixed_input_state[STATE_BYTES] = { 0x33, 0x3f };
	290
	291	enum mdbtn {
	292	MDBTN_UP = 1,
	293	MDBTN_DOWN,
	294	MDBTN_LEFT,
	295	MDBTN_RIGHT,
	296	MDBTN_A,
	297	MDBTN_B,
	298	MDBTN_C,
	299	MDBTN_START,
	300	};
	301
	302	static const enum mdbtn evdev_md_map[KEY_CNT] = {
	303	[KEY_UP] = MDBTN_UP,
	304	[KEY_DOWN] = MDBTN_DOWN,
	305	[KEY_LEFT] = MDBTN_LEFT,
	306	[KEY_RIGHT] = MDBTN_RIGHT,
	307	[KEY_HOME] = MDBTN_A,
	308	[KEY_PAGEDOWN] = MDBTN_B,
	309	[KEY_END] = MDBTN_C,
	310	[KEY_LEFTALT] = MDBTN_START,
	311	};
	312
	313	int do_evdev_input(int fd)
	314	{
	315	uint8_t old_state[STATE_BYTES];
	316	uint8_t changed_bits[STATE_BYTES] = { 0, };
	317	struct input_event ev;
	318	enum mdbtn mdbtn;
	319	int i, ret;
	320
	321	ret = read(fd, &ev, sizeof(ev));
	322	if (ret != sizeof(ev)) {
	323	fprintf(stderr, "evdev read %d/%zd: ", ret, sizeof(ev));
	324	perror("");
	325	return 0;
	326	}
	327
	328	if (ev.type != EV_KEY)
	329	return 0;
	330
	331	if (ev.value != 0 && ev.value != 1)
	332	return 0;
	333
	334	if ((uint32_t)ev.code >= ARRAY_SIZE(evdev_md_map)) {
	335	fprintf(stderr, "evdev read bad key: %u\n", ev.code);
	336	return 0;
	337	}
	338
	339	mdbtn = evdev_md_map[ev.code];
	340	if (mdbtn == 0)
	341	return 0;
	342
	343	memcpy(old_state, fixed_input_state, STATE_BYTES);
	344
	345	/* ?0SA 00DU, ?1CB RLDU */
	346	switch (mdbtn) {
	347	case MDBTN_UP:
	348	changed_bits[0] = 0x01;
	349	changed_bits[1] = 0x01;
350	break;
351	case MDBTN_DOWN:
352	changed_bits[0] = 0x02;
353	changed_bits[1] = 0x02;
354	break;
355	case MDBTN_LEFT:
356	changed_bits[0] = 0x00;
357	changed_bits[1] = 0x04;
358	break;
359	case MDBTN_RIGHT:
360	changed_bits[0] = 0x00;
361	changed_bits[1] = 0x08;
362	break;
363	case MDBTN_A:
364	changed_bits[0] = 0x10;
365	changed_bits[1] = 0x00;
366	break;
367	case MDBTN_B:
368	changed_bits[0] = 0x00;
369	changed_bits[1] = 0x10;
370	break;
371	case MDBTN_C:
372	changed_bits[0] = 0x00;
373	changed_bits[1] = 0x20;
374	break;
375	case MDBTN_START:
376	changed_bits[0] = 0x20;
377	changed_bits[1] = 0x00;
378	break;
379	}
380
381	if (ev.value) {
382	// key press
383	for (i = 0; i < STATE_BYTES; i++)
384	fixed_input_state[i] &= ~changed_bits[i];
385	}
386	else {
387	// key release
388	for (i = 0; i < STATE_BYTES; i++)
389	fixed_input_state[i] \|= changed_bits[i];
390	}
391
392	return memcmp(old_state, fixed_input_state, STATE_BYTES) ? 1 : 0;
393	}
394
932302ef	395	enum my_urbs {
	396	URB_DATA_IN,
	397	URB_DATA_OUT,
	398	URB_DBG_IN,
	399	URB_CNT
	400	};
	401
	402	int main(int argc, char *argv[])
	403	{
1cb2822f	404	char buf_dbg[64 + 1], buf_in[64], buf_out[64];
932302ef	405	struct teensy_dev dev;
	406	struct usbdevfs_urb urb[URB_CNT];
	407	struct usbdevfs_urb *reaped_urb;
1cb2822f	408	int fixed_input_changed;
	409	int evdev_fds[16];
	410	int evdev_fd_cnt = 0;
	411	int evdev_support;
932302ef	412	int wait_device = 0;
	413	int dbg_in_sent = 0;
	414	int data_in_sent = 0;
1cb2822f	415	fd_set rfds, wfds;
	416	int i, ret;
	417	int fd;
	418
	419	for (i = 1; i < argc; i++) {
	420	if (evdev_fd_cnt >= ARRAY_SIZE(evdev_fds)) {
	421	fprintf(stderr, "too many evdevs\n");
	422	break;
	423	}
	424	fd = open(argv[i], O_RDONLY);
	425	if (fd == -1) {
	426	fprintf(stderr, "open %s: ", argv[i]);
	427	perror("");
	428	continue;
	429	}
	430	evdev_support = 0;
	431	ret = ioctl(fd, EVIOCGBIT(0, sizeof(evdev_support)),
	432	&evdev_support);
	433	if (ret < 0)
	434	perror("EVIOCGBIT");
	435	if (!(evdev_support & (1 << EV_KEY))) {
	436	fprintf(stderr, "%s doesn't have keys\n", argv[i]);
	437	close(fd);
	438	continue;
	439	}
	440	evdev_fds[evdev_fd_cnt++] = fd;
	441	}
932302ef	442
f359b935	443	enable_echo(0);
	444	signal(SIGINT, signal_handler);
	445
932302ef	446	dev.fd = -1;
	447
	448	while (1)
	449	{
	450	if (dev.fd == -1) {
	451	ret = find_device(&dev, 0x16C0, 0x0486);
	452	if (ret < 0)
f359b935	453	break;
932302ef	454
	455	if (ret == 0) {
	456	if (!wait_device) {
	457	printf("waiting for device..\n");
	458	wait_device = 1;
	459	}
	460	usleep(250000);
	461	continue;
	462	}
	463
	464	wait_device = 0;
	465	data_in_sent = 0;
	466	dbg_in_sent = 0;
	467	}
	468
	469	if (!data_in_sent) {
	470	memset(&urb[URB_DATA_IN], 0, sizeof(urb[URB_DATA_IN]));
	471	urb[URB_DATA_IN].type = USBDEVFS_URB_TYPE_INTERRUPT;
	472	urb[URB_DATA_IN].endpoint = dev.ifaces[0].ep_in;
	473	urb[URB_DATA_IN].buffer = buf_in;
	474	urb[URB_DATA_IN].buffer_length = sizeof(buf_in);
	475
	476	ret = ioctl(dev.fd, USBDEVFS_SUBMITURB, &urb[URB_DATA_IN]);
	477	if (ret != 0) {
	478	perror("USBDEVFS_SUBMITURB URB_DATA_IN");
f359b935	479	break;
932302ef	480	}
	481	data_in_sent = 1;
	482	}
	483	if (!dbg_in_sent) {
	484	memset(&urb[URB_DBG_IN], 0, sizeof(urb[URB_DBG_IN]));
	485	urb[URB_DBG_IN].type = USBDEVFS_URB_TYPE_INTERRUPT;
	486	urb[URB_DBG_IN].endpoint = dev.ifaces[1].ep_in;
	487	urb[URB_DBG_IN].buffer = buf_dbg;
	488	urb[URB_DBG_IN].buffer_length = sizeof(buf_dbg) - 1;
	489
	490	ret = ioctl(dev.fd, USBDEVFS_SUBMITURB, &urb[URB_DBG_IN]);
	491	if (ret != 0) {
	492	perror("USBDEVFS_SUBMITURB URB_DBG_IN");
f359b935	493	break;
932302ef	494	}
	495	dbg_in_sent = 1;
	496	}
	497
1cb2822f	498	FD_ZERO(&rfds);
	499	for (i = 0; i < evdev_fd_cnt; i++)
	500	FD_SET(evdev_fds[i], &rfds);
	501
932302ef	502	FD_ZERO(&wfds);
	503	FD_SET(dev.fd, &wfds);
	504
1cb2822f	505	ret = select(dev.fd + 1, &rfds, &wfds, NULL, NULL);
932302ef	506	if (ret < 0) {
932302ef	507	perror("select");
f359b935	508	break;
932302ef	509	}
932302ef	510
1cb2822f	511	/* something from input devices? */
	512	fixed_input_changed = 0;
	513	for (i = 0; i < evdev_fd_cnt; i++) {
	514	if (FD_ISSET(evdev_fds[i], &rfds)) {
	515	fixed_input_changed \|=
	516	do_evdev_input(evdev_fds[i]);
	517	}
	518	}
	519
	520	/* something from USB? */
932302ef	521	if (FD_ISSET(dev.fd, &wfds)) {
	522	reaped_urb = NULL;
	523	ret = ioctl(dev.fd, USBDEVFS_REAPURB, &reaped_urb);
	524	if (ret != 0) {
	525	if (errno == ENODEV)
	526	goto dev_close;
	527	perror("USBDEVFS_REAPURB");
f359b935	528	break;
932302ef	529	}
	530
	531	if (reaped_urb != NULL && reaped_urb->status != 0) {
	532	errno = -reaped_urb->status;
	533	perror("urb status");
	534	if (reaped_urb->status == -EILSEQ) {
	535	/* this is usually a sign of disconnect.. */
	536	usleep(250000);
	537	goto dev_close;
	538	}
	539	}
	540
	541	if (reaped_urb == &urb[URB_DATA_IN]) {
	542	printf("data\n");
	543	data_in_sent = 0;
	544	}
1cb2822f	545	if (reaped_urb == &urb[URB_DATA_OUT]) {
1cb2822f	546	}
932302ef	547	else if (reaped_urb == &urb[URB_DBG_IN]) {
	548	/* debug text */
	549	buf_dbg[reaped_urb->actual_length] = 0;
	550	printf("%s", buf_dbg);
	551	dbg_in_sent = 0;
	552	}
	553	else {
	554	fprintf(stderr, "reaped unknown urb? %p\n", reaped_urb);
	555	}
	556	}
1cb2822f	557
	558	/* something to send? */
	559	if (fixed_input_changed) {
	560	memset(buf_out, 0, sizeof(buf_out));
	561	memcpy(buf_out, fixed_input_state, sizeof(fixed_input_state));
	562
	563	memset(&urb[URB_DATA_OUT], 0, sizeof(urb[URB_DATA_OUT]));
	564	urb[URB_DATA_OUT].type = USBDEVFS_URB_TYPE_INTERRUPT;
	565	urb[URB_DATA_OUT].endpoint = dev.ifaces[0].ep_out;
	566	urb[URB_DATA_OUT].buffer = buf_out;
	567	urb[URB_DATA_OUT].buffer_length = sizeof(buf_out);
	568
	569	ret = ioctl(dev.fd, USBDEVFS_SUBMITURB, &urb[URB_DATA_OUT]);
	570	if (ret != 0) {
	571	perror("USBDEVFS_SUBMITURB URB_DATA_OUT");
f359b935	572	break;
1cb2822f	573	}
	574	}
	575
932302ef	576	continue;
	577
	578	dev_close:
	579	close(dev.fd);
	580	dev.fd = -1;
	581	}
	582
f359b935	583	enable_echo(1);
	584
	585	return ret;
932302ef	586	}
	587
	588	// vim: ts=2:sw=2:expandtab