libaltos: use pipe to wake up getchar on close. use mutexes

[fw/altos] / ao-tools / libaltos / libaltos.c

diff --git a/ao-tools/libaltos/libaltos.c b/ao-tools/libaltos/libaltos.c
index 417c8fe5688b2ff295b89ca6fc7e6afcb838b141..ffdb23669964c2be417b0905e7cf5a862122fdf6 100644 (file)
--- a/ao-tools/libaltos/libaltos.c
+++ b/ao-tools/libaltos/libaltos.c
@@ -15,11 +15,344 @@
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  */
 
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  */
 

+#define BUILD_DLL

 #include "libaltos.h"
 #include "libaltos.h"

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+PUBLIC int
+altos_init(void)
+{
+       return LIBALTOS_SUCCESS;
+}
+
+PUBLIC void
+altos_fini(void)
+{
+}
+
+#ifdef DARWIN
+/* Mac OS X don't have strndup even if _GNU_SOURCE is defined */
+static char *
+altos_strndup (const char *s, size_t n)
+{
+    size_t len = strlen (s);
+    char *ret;
+
+    if (len <= n)
+       return strdup (s);
+    ret = malloc(n + 1);
+    strncpy(ret, s, n);
+    ret[n] = '\0';
+    return ret;
+}
+
+#else
+#define altos_strndup strndup
+#endif
+
+/*
+ * Scan for Altus Metrum devices by looking through /sys
+ */
+
+#ifdef LINUX

 
 

-#define USE_DARWIN
+#define _GNU_SOURCE
+#include <ctype.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static char *
+cc_fullname (char *dir, char *file)
+{
+       char    *new;
+       int     dlen = strlen (dir);
+       int     flen = strlen (file);
+       int     slen = 0;
+
+       if (dir[dlen-1] != '/')
+               slen = 1;
+       new = malloc (dlen + slen + flen + 1);
+       if (!new)
+               return 0;
+       strcpy(new, dir);
+       if (slen)
+               strcat (new, "/");
+       strcat(new, file);
+       return new;
+}
+
+static char *
+cc_basename(char *file)
+{
+       char *b;
+
+       b = strrchr(file, '/');
+       if (!b)
+               return file;
+       return b + 1;
+}
+
+static char *
+load_string(char *dir, char *file)
+{
+       char    *full = cc_fullname(dir, file);
+       char    line[4096];
+       char    *r;
+       FILE    *f;
+       int     rlen;
+
+       f = fopen(full, "r");
+       free(full);
+       if (!f)
+               return NULL;
+       r = fgets(line, sizeof (line), f);
+       fclose(f);
+       if (!r)
+               return NULL;
+       rlen = strlen(r);
+       if (r[rlen-1] == '\n')
+               r[rlen-1] = '\0';
+       return strdup(r);
+}

 
 

-#ifdef USE_DARWIN
+static int
+load_hex(char *dir, char *file)
+{
+       char    *line;
+       char    *end;
+       long    i;
+
+       line = load_string(dir, file);
+       if (!line)
+               return -1;
+       i = strtol(line, &end, 16);
+       free(line);
+       if (end == line)
+               return -1;
+       return i;
+}
+
+static int
+load_dec(char *dir, char *file)
+{
+       char    *line;
+       char    *end;
+       long    i;
+
+       line = load_string(dir, file);
+       if (!line)
+               return -1;
+       i = strtol(line, &end, 10);
+       free(line);
+       if (end == line)
+               return -1;
+       return i;
+}
+
+static int
+dir_filter_tty_colon(const struct dirent *d)
+{
+       return strncmp(d->d_name, "tty:", 4) == 0;
+}
+
+static int
+dir_filter_tty(const struct dirent *d)
+{
+       return strncmp(d->d_name, "tty", 3) == 0;
+}
+
+struct altos_usbdev {
+       char    *sys;
+       char    *tty;
+       char    *manufacturer;
+       char    *product_name;
+       int     serial; /* AltOS always uses simple integer serial numbers */
+       int     idProduct;
+       int     idVendor;
+};
+
+static char *
+usb_tty(char *sys)
+{
+       char *base;
+       int num_configs;
+       int config;
+       struct dirent **namelist;
+       int interface;
+       int num_interfaces;
+       char endpoint_base[20];
+       char *endpoint_full;
+       char *tty_dir;
+       int ntty;
+       char *tty;
+
+       base = cc_basename(sys);
+       num_configs = load_hex(sys, "bNumConfigurations");
+       num_interfaces = load_hex(sys, "bNumInterfaces");
+       for (config = 1; config <= num_configs; config++) {
+               for (interface = 0; interface < num_interfaces; interface++) {
+                       sprintf(endpoint_base, "%s:%d.%d",
+                               base, config, interface);
+                       endpoint_full = cc_fullname(sys, endpoint_base);
+
+                       /* Check for tty:ttyACMx style names
+                        */
+                       ntty = scandir(endpoint_full, &namelist,
+                                      dir_filter_tty_colon,
+                                      alphasort);
+                       if (ntty > 0) {
+                               free(endpoint_full);
+                               tty = cc_fullname("/dev", namelist[0]->d_name + 4);
+                               free(namelist);
+                               return tty;
+                       }
+
+                       /* Check for tty/ttyACMx style names
+                        */
+                       tty_dir = cc_fullname(endpoint_full, "tty");
+                       free(endpoint_full);
+                       ntty = scandir(tty_dir, &namelist,
+                                      dir_filter_tty,
+                                      alphasort);
+                       free (tty_dir);
+                       if (ntty > 0) {
+                               tty = cc_fullname("/dev", namelist[0]->d_name);
+                               free(namelist);
+                               return tty;
+                       }
+               }
+       }
+       return NULL;
+}
+
+static struct altos_usbdev *
+usb_scan_device(char *sys)
+{
+       struct altos_usbdev *usbdev;
+
+       usbdev = calloc(1, sizeof (struct altos_usbdev));
+       if (!usbdev)
+               return NULL;
+       usbdev->sys = strdup(sys);
+       usbdev->manufacturer = load_string(sys, "manufacturer");
+       usbdev->product_name = load_string(sys, "product");
+       usbdev->serial = load_dec(sys, "serial");
+       usbdev->idProduct = load_hex(sys, "idProduct");
+       usbdev->idVendor = load_hex(sys, "idVendor");
+       usbdev->tty = usb_tty(sys);
+       return usbdev;
+}
+
+static void
+usbdev_free(struct altos_usbdev *usbdev)
+{
+       free(usbdev->sys);
+       free(usbdev->manufacturer);
+       free(usbdev->product_name);
+       /* this can get used as a return value */
+       if (usbdev->tty)
+               free(usbdev->tty);
+       free(usbdev);
+}
+
+#define USB_DEVICES    "/sys/bus/usb/devices"
+
+static int
+dir_filter_dev(const struct dirent *d)
+{
+       const char      *n = d->d_name;
+       char    c;
+
+       while ((c = *n++)) {
+               if (isdigit(c))
+                       continue;
+               if (c == '-')
+                       continue;
+               if (c == '.' && n != d->d_name + 1)
+                       continue;
+               return 0;
+       }
+       return 1;
+}
+
+struct altos_list {
+       struct altos_usbdev     **dev;
+       int                     current;
+       int                     ndev;
+};
+
+struct altos_list *
+altos_list_start(void)
+{
+       int                     e;
+       struct dirent           **ents;
+       char                    *dir;
+       struct altos_usbdev     *dev;
+       struct altos_list       *devs;
+       int                     n;
+
+       devs = calloc(1, sizeof (struct altos_list));
+       if (!devs)
+               return NULL;
+
+       n = scandir (USB_DEVICES, &ents,
+                    dir_filter_dev,
+                    alphasort);
+       if (!n)
+               return 0;
+       for (e = 0; e < n; e++) {
+               dir = cc_fullname(USB_DEVICES, ents[e]->d_name);
+               dev = usb_scan_device(dir);
+               free(dir);
+               if (USB_IS_ALTUSMETRUM(dev->idVendor, dev->idProduct)) {
+                       if (devs->dev)
+                               devs->dev = realloc(devs->dev,
+                                                   devs->ndev + 1 * sizeof (struct usbdev *));
+                       else
+                               devs->dev = malloc (sizeof (struct usbdev *));
+                       devs->dev[devs->ndev++] = dev;
+               }
+       }
+       free(ents);
+       devs->current = 0;
+       return devs;
+}
+
+int
+altos_list_next(struct altos_list *list, struct altos_device *device)
+{
+       struct altos_usbdev *dev;
+       if (list->current >= list->ndev)
+               return 0;
+       dev = list->dev[list->current];
+       strcpy(device->name, dev->product_name);
+       device->vendor = dev->idVendor;
+       device->product = dev->idProduct;
+       strcpy(device->path, dev->tty);
+       device->serial = dev->serial;
+       list->current++;
+       return 1;
+}
+
+void
+altos_list_finish(struct altos_list *usbdevs)
+{
+       int     i;
+
+       if (!usbdevs)
+               return;
+       for (i = 0; i < usbdevs->ndev; i++)
+               usbdev_free(usbdevs->dev[i]);
+       free(usbdevs);
+}
+
+#endif
+
+#ifdef DARWIN

 
 #include <IOKitLib.h>
 #include <IOKit/usb/USBspec.h>
 
 #include <IOKitLib.h>
 #include <IOKit/usb/USBspec.h>


@@ -30,47 +363,32 @@
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>

-#include <fcntl.h>
-#include <poll.h>
-#include <termios.h>
-#include <errno.h>

 
 struct altos_list {
 
 struct altos_list {

-  io_iterator_t iterator;
+       io_iterator_t iterator;

 };
 
 static int
 get_string(io_object_t object, CFStringRef entry, char *result, int result_len)
 {
 };
 
 static int
 get_string(io_object_t object, CFStringRef entry, char *result, int result_len)
 {

-  CFTypeRef entry_as_string;
-  Boolean got_string;
-
-  entry_as_string = IORegistryEntrySearchCFProperty (object,
-                                                    kIOServicePlane,
-                                                    entry,
-                                                    kCFAllocatorDefault,
-                                                    kIORegistryIterateRecursively);
-  if (entry_as_string) {
-    got_string = CFStringGetCString(entry_as_string,
-                                   result, result_len,
-                                   kCFStringEncodingASCII);
+       CFTypeRef entry_as_string;
+       Boolean got_string;
+
+       entry_as_string = IORegistryEntrySearchCFProperty (object,
+                                                          kIOServicePlane,
+                                                          entry,
+                                                          kCFAllocatorDefault,
+                                                          kIORegistryIterateRecursively);
+       if (entry_as_string) {
+               got_string = CFStringGetCString(entry_as_string,
+                                               result, result_len,
+                                               kCFStringEncodingASCII);

     
     

-    CFRelease(entry_as_string);
-    if (got_string)
-      return 1;
-  }
-  return 0;
-}
-
-int
-altos_init(void)
-{
-       return 1;
-}
-
-void
-altos_fini(void)
-{
+               CFRelease(entry_as_string);
+               if (got_string)
+                       return 1;
+       }
+       return 0;

 }
 
 struct altos_list *
 }
 
 struct altos_list *


@@ -117,70 +435,35 @@ altos_list_next(struct altos_list *list, struct altos_device *device)
 void
 altos_list_finish(struct altos_list *list)
 {
 void
 altos_list_finish(struct altos_list *list)
 {

-  IOObjectRelease (list->iterator);
-  free(list);
+       IOObjectRelease (list->iterator);
+       free(list);

 }
 
 }
 

+#endif
+
+#ifdef POSIX_TTY
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <errno.h>
+#include <pthread.h>

 
 #define USB_BUF_SIZE   64
 
 struct altos_file {
        int                             fd;
 
 #define USB_BUF_SIZE   64
 
 struct altos_file {
        int                             fd;

+       int                             pipe[2];

        unsigned char                   out_data[USB_BUF_SIZE];
        int                             out_used;
        unsigned char                   in_data[USB_BUF_SIZE];
        int                             in_used;
        int                             in_read;
        unsigned char                   out_data[USB_BUF_SIZE];
        int                             out_used;
        unsigned char                   in_data[USB_BUF_SIZE];
        int                             in_used;
        int                             in_read;

+       pthread_mutex_t                 putc_mutex;
+       pthread_mutex_t                 getc_mutex;

 };
 
 };
 

-void
-altos_test(char *path)
-{
-       int n;
-       char buf[16];
-       int fd;
-       struct termios term;
-
-       fd = open(path, O_RDWR | O_NOCTTY);
-       if (fd < 0) {
-               perror(path);
-               return;
-       }
-       if (ioctl(fd, TIOCEXCL, (char *) 0) < 0) {
-               perror("TIOCEXCL");
-               close (fd);
-               return;
-       }
-
-       n = tcgetattr(fd, &term);
-       if (n < 0) {
-               perror("tcgetattr");
-               close(fd);
-               return;
-       }
-       cfmakeraw(&term);
-       term.c_cc[VMIN] = 0;
-       term.c_cc[VTIME] = 1;
-       n = tcsetattr(fd, TCSAFLUSH, &term);
-       if (n < 0) {
-               perror("tcsetattr");
-               close(fd);
-               return;
-       }
-       write(fd, "\n?\n", 3);
-       for (;;) {
-               n = read(fd, buf, sizeof (buf));
-               if (n < 0) {
-                       perror("read");
-                       break;
-               }
-               if (n == 0)
-                       break;
-               write(1, buf, n);
-       }
-       close(fd);
-}
-

 struct altos_file *
 altos_open(struct altos_device *device)
 {
 struct altos_file *
 altos_open(struct altos_device *device)
 {


@@ -191,6 +474,7 @@ altos_open(struct altos_device *device)
        if (!file)
                return NULL;
 
        if (!file)
                return NULL;
 

+       pipe(file->pipe);

        file->fd = open(device->path, O_RDWR | O_NOCTTY);
        if (file->fd < 0) {
                perror(device->path);
        file->fd = open(device->path, O_RDWR | O_NOCTTY);
        if (file->fd < 0) {
                perror(device->path);


@@ -205,8 +489,8 @@ altos_open(struct altos_device *device)
                return NULL;
        }
        cfmakeraw(&term);
                return NULL;
        }
        cfmakeraw(&term);

-       term.c_cc[VMIN] = 0;
-       term.c_cc[VTIME] = 1;
+       term.c_cc[VMIN] = 1;
+       term.c_cc[VTIME] = 0;

        ret = tcsetattr(file->fd, TCSAFLUSH, &term);
        if (ret < 0) {
                perror("tcsetattr");
        ret = tcsetattr(file->fd, TCSAFLUSH, &term);
        if (ret < 0) {
                perror("tcsetattr");


@@ -214,38 +498,38 @@ altos_open(struct altos_device *device)
                free(file);
                return NULL;
        }
                free(file);
                return NULL;
        }

+       pthread_mutex_init(&file->putc_mutex,NULL);
+       pthread_mutex_init(&file->getc_mutex,NULL);

        return file;
 }
 
 void
 altos_close(struct altos_file *file)
 {
        return file;
 }
 
 void
 altos_close(struct altos_file *file)
 {

-       close(file->fd);
-       free(file);
+       if (file->fd != -1) {
+               int     fd = file->fd;
+               file->fd = -1;
+               write(file->pipe[1], "\r", 1);
+               close(fd);
+       }

 }
 
 }
 

-int
-altos_putchar(struct altos_file *file, char c)
+void
+altos_free(struct altos_file *file)

 {
 {

-       int     ret;
-
-       if (file->out_used == USB_BUF_SIZE) {
-               ret = altos_flush(file);
-               if (ret)
-                       return ret;
-       }
-       file->out_data[file->out_used++] = c;
-       if (file->out_used == USB_BUF_SIZE)
-               return altos_flush(file);
-       return 0;
+       altos_close(file);
+       free(file);

 }
 
 }
 

-int
-altos_flush(struct altos_file *file)
+static int
+_altos_flush(struct altos_file *file)

 {
        while (file->out_used) {
                int     ret;
 
 {
        while (file->out_used) {
                int     ret;
 

+               if (file->fd < 0)
+                       return -EBADF;
+               fflush(stdout);

                ret = write (file->fd, file->out_data, file->out_used);
                if (ret < 0)
                        return -errno;
                ret = write (file->fd, file->out_data, file->out_used);
                if (ret < 0)
                        return -errno;


@@ -258,110 +542,101 @@ altos_flush(struct altos_file *file)
 }
 
 int
 }
 
 int

-altos_getchar(struct altos_file *file, int timeout)
+altos_putchar(struct altos_file *file, char c)

 {
 {

-       while (file->in_read == file->in_used) {
-               int     ret;
+       int     ret;

 
 

-               altos_flush(file);
-               ret = read(file->fd, file->in_data, USB_BUF_SIZE);
-               if (ret < 0)
-                       return -errno;
-               file->in_read = 0;
-               file->in_used = ret;
+       pthread_mutex_lock(&file->putc_mutex);
+       if (file->out_used == USB_BUF_SIZE) {
+               ret = _altos_flush(file);
+               if (ret) {
+                       pthread_mutex_unlock(&file->putc_mutex);
+                       return ret;
+               }

        }
        }

-       return file->in_data[file->in_read++];
-}
-
-#endif /* USE_DARWIN */
-
-#ifdef USE_LIBUSB
-#include <libusb.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-libusb_context *usb_context;
-
-int altos_init(void)
-{
-       int     ret;
-       ret = libusb_init(&usb_context);
-       if (ret)
-               return ret;
-       libusb_set_debug(usb_context, 3);
+       file->out_data[file->out_used++] = c;
+       ret = 0;
+       if (file->out_used == USB_BUF_SIZE)
+               ret = _altos_flush(file);
+       pthread_mutex_unlock(&file->putc_mutex);

        return 0;
 }
 
        return 0;
 }
 

-void altos_fini(void)
+int
+altos_flush(struct altos_file *file)

 {
 {

-       libusb_exit(usb_context);
-       usb_context = NULL;
+       int ret;
+       pthread_mutex_lock(&file->putc_mutex);
+       ret = _altos_flush(file);
+       pthread_mutex_unlock(&file->putc_mutex);
+       return ret;

 }
 
 }
 

-static libusb_device **list;
-static ssize_t num, current;

 
 

-int altos_list_start(void)
+#include <poll.h>
+
+int
+altos_getchar(struct altos_file *file, int timeout)

 {
 {

-       if (list)
-               altos_list_finish();
-       current = 0;
-       num = libusb_get_device_list(usb_context, &list);
-       if (num == 0) {
-               current = num = 0;
-               list = NULL;
-               return 0;
-       }
-       return 1;
-}
+       int             ret;
+       struct pollfd   fd[2];
+
+       if (timeout == 0)
+               timeout = -1;
+       pthread_mutex_lock(&file->getc_mutex);
+       fd[0].fd = file->fd;
+       fd[0].events = POLLIN;
+       fd[1].fd = file->pipe[0];
+       fd[1].events = POLLIN;
+       while (file->in_read == file->in_used) {
+               if (file->fd < 0) {
+                       pthread_mutex_unlock(&file->getc_mutex);
+                       return LIBALTOS_ERROR;
+               }
+               altos_flush(file);

 
 

-int altos_list_next(struct altos_device *device)
-{
-       while (current < num) {
-               struct libusb_device_descriptor descriptor;
-               libusb_device *usb_device = list[current++];
-
-               if (libusb_get_device_descriptor(usb_device, &descriptor) == 0) {
-                       if (descriptor.idVendor == 0xfffe)
-                       {
-                               libusb_device_handle    *handle;
-                               if (libusb_open(usb_device, &handle) == 0) {
-                                       char    serial_number[256];
-                                       libusb_get_string_descriptor_ascii(handle, descriptor.iProduct,
-                                                                          device->product,
-                                                                          sizeof(device->product));
-                                       libusb_get_string_descriptor_ascii(handle, descriptor.iSerialNumber,
-                                                                          serial_number,
-                                                                          sizeof (serial_number));
-                                       libusb_close(handle);
-                                       device->serial = atoi(serial_number);
-                                       device->device = usb_device;
-                                       return 1;
-                               }
+               ret = poll(fd, 2, timeout);
+               if (ret < 0) {
+                       perror("altos_getchar");
+                       pthread_mutex_unlock(&file->getc_mutex);
+                       return LIBALTOS_ERROR;
+               }
+               if (ret == 0) {
+                       pthread_mutex_unlock(&file->getc_mutex);
+                       return LIBALTOS_TIMEOUT;
+               }
+               if (fd[0].revents & POLLIN) {
+                       ret = read(file->fd, file->in_data, USB_BUF_SIZE);
+                       if (ret < 0) {
+                               perror("altos_getchar");
+                               pthread_mutex_unlock(&file->getc_mutex);
+                               return LIBALTOS_ERROR;

                        }
                        }

+                       file->in_read = 0;
+                       file->in_used = ret;

                }
        }
                }
        }

-       return 0;
+       ret = file->in_data[file->in_read++];
+       pthread_mutex_unlock(&file->getc_mutex);
+       return ret;

 }
 
 }
 

-void altos_list_finish(void)
-{
-       if (list) {
-               libusb_free_device_list(list, 1);
-               list = NULL;
-       }
-}
+#endif /* POSIX_TTY */
+
+#ifdef WINDOWS
+
+#include <windows.h>
+#include <setupapi.h>
+
+struct altos_list {
+       HDEVINFO        dev_info;
+       int             index;
+};

 
 #define USB_BUF_SIZE   64
 
 struct altos_file {
 
 #define USB_BUF_SIZE   64
 
 struct altos_file {

-       struct libusb_device            *device;
-       struct libusb_device_handle     *handle;
-       int                             out_ep;
-       int                             out_size;
-       int                             in_ep;
-       int                             in_size;
+       HANDLE                          handle;

        unsigned char                   out_data[USB_BUF_SIZE];
        int                             out_used;
        unsigned char                   in_data[USB_BUF_SIZE];
        unsigned char                   out_data[USB_BUF_SIZE];
        int                             out_used;
        unsigned char                   in_data[USB_BUF_SIZE];


@@ -369,49 +644,234 @@ struct altos_file {
        int                             in_read;
 };
 
        int                             in_read;
 };
 

-struct altos_file *
-altos_open(struct altos_device *device)
+
+PUBLIC struct altos_list *
+altos_list_start(void)

 {
 {

-       struct altos_file               *file;
-       struct libusb_device_handle     *handle;
-       if (libusb_open(device->device, &handle) == 0) {
-               int     ret;
+       struct altos_list       *list = calloc(1, sizeof (struct altos_list));

 
 

-               ret = libusb_claim_interface(handle, 1);
-#if 0
-               if (ret) {
-                       libusb_close(handle);
-                       return NULL;
+       if (!list)
+               return NULL;
+       list->dev_info = SetupDiGetClassDevs(NULL, "USB", NULL,
+                                            DIGCF_ALLCLASSES|DIGCF_PRESENT);
+       if (list->dev_info == INVALID_HANDLE_VALUE) {
+               printf("SetupDiGetClassDevs failed %d\n", GetLastError());
+               free(list);
+               return NULL;
+       }
+       list->index = 0;
+       return list;
+}
+
+PUBLIC int
+altos_list_next(struct altos_list *list, struct altos_device *device)
+{
+       SP_DEVINFO_DATA dev_info_data;
+       char            port[128];
+       DWORD           port_len;
+       char            location[256];
+       char            symbolic[256];
+       DWORD           symbolic_len;
+       HKEY            dev_key;
+       int             vid, pid;
+       int             serial;
+       HRESULT         result;
+       DWORD           location_type;
+       DWORD           location_len;
+
+       dev_info_data.cbSize = sizeof (SP_DEVINFO_DATA);
+       while(SetupDiEnumDeviceInfo(list->dev_info, list->index,
+                                   &dev_info_data))
+       {
+               list->index++;
+
+               dev_key = SetupDiOpenDevRegKey(list->dev_info, &dev_info_data,
+                                              DICS_FLAG_GLOBAL, 0, DIREG_DEV,
+                                              KEY_READ);
+               if (dev_key == INVALID_HANDLE_VALUE) {
+                       printf("cannot open device registry key\n");
+                       continue;

                }
                }

-#endif
-               ret = libusb_detach_kernel_driver(handle, 1);
-#if 0
-               if (ret) {
-                       libusb_close(handle);
-                       return NULL;
+
+               /* Fetch symbolic name for this device and parse out
+                * the vid/pid/serial info */
+               symbolic_len = sizeof(symbolic);
+               result = RegQueryValueEx(dev_key, "SymbolicName", NULL, NULL,
+                                        symbolic, &symbolic_len);
+               if (result != 0) {
+                       printf("cannot find SymbolicName value\n");
+                       RegCloseKey(dev_key);
+                       continue;
+               }
+               vid = pid = serial = 0;
+               sscanf(symbolic + sizeof("\\??\\USB#VID_") - 1,
+                      "%04X", &vid);
+               sscanf(symbolic + sizeof("\\??\\USB#VID_XXXX&PID_") - 1,
+                      "%04X", &pid);
+               sscanf(symbolic + sizeof("\\??\\USB#VID_XXXX&PID_XXXX#") - 1,
+                      "%d", &serial);
+               if (!USB_IS_ALTUSMETRUM(vid, pid)) {
+                       printf("Not Altus Metrum symbolic name: %s\n",
+                              symbolic);
+                       RegCloseKey(dev_key);
+                       continue;

                }
                }

-#endif

 
 

-               file = calloc(sizeof (struct altos_file), 1);
-               file->device = libusb_ref_device(device->device);
-               file->handle = handle;
-               /* XXX should get these from the endpoint descriptors */
-               file->out_ep = 4 | LIBUSB_ENDPOINT_OUT;
-               file->out_size = 64;
-               file->in_ep = 5 | LIBUSB_ENDPOINT_IN;
-               file->in_size = 64;
+               /* Fetch the com port name */
+               port_len = sizeof (port);
+               result = RegQueryValueEx(dev_key, "PortName", NULL, NULL,
+                                        port, &port_len);
+               RegCloseKey(dev_key);
+               if (result != 0) {
+                       printf("failed to get PortName\n");
+                       continue;
+               }

 
 

-               return file;
+               /* Fetch the 'location information' which is the device name,
+                * at least on XP */
+               location_len = sizeof (location);
+               if(!SetupDiGetDeviceRegistryProperty(list->dev_info,
+                                                    &dev_info_data,
+                                                    SPDRP_LOCATION_INFORMATION,
+                                                    &location_type,
+                                                    (BYTE *)location,
+                                                    sizeof(location),
+                                                    &location_len))
+               {
+                       printf("Failed to get location\n");
+                       continue;
+               }
+               device->vendor = vid;
+               device->product = pid;
+               device->serial = serial;
+
+               if (strcasestr(location, "tele"))
+                       strcpy(device->name, location);
+               else
+                       strcpy(device->name, "");
+
+               strcpy(device->path, port);
+               printf ("product: %04x:%04x (%s)  path: %s serial %d\n",
+                       device->vendor, device->product, device->name,
+                       device->path, device->serial);
+               return 1;

        }
        }

-       return NULL;
+       result = GetLastError();
+       if (result != ERROR_NO_MORE_ITEMS)
+               printf ("SetupDiEnumDeviceInfo failed error %d\n", result);
+       return 0;

 }
 
 }
 

-void
+PUBLIC void
+altos_list_finish(struct altos_list *list)
+{
+       SetupDiDestroyDeviceInfoList(list->dev_info);
+       free(list);
+}
+
+static int
+altos_fill(struct altos_file *file, int timeout)
+{
+       DWORD   result;
+       DWORD   got;
+       COMMTIMEOUTS timeouts;
+
+       if (file->in_read < file->in_used)
+               return LIBALTOS_SUCCESS;
+       file->in_read = file->in_used = 0;
+
+       if (timeout) {
+               timeouts.ReadIntervalTimeout = MAXDWORD;
+               timeouts.ReadTotalTimeoutMultiplier = MAXDWORD;
+               timeouts.ReadTotalTimeoutConstant = timeout;
+       } else {
+               timeouts.ReadIntervalTimeout = 0;
+               timeouts.ReadTotalTimeoutMultiplier = 0;
+               timeouts.ReadTotalTimeoutConstant = 0;
+       }
+       timeouts.WriteTotalTimeoutMultiplier = 0;
+       timeouts.WriteTotalTimeoutConstant = 0;
+
+       if (!SetCommTimeouts(file->handle, &timeouts)) {
+               printf("SetCommTimeouts failed %d\n", GetLastError());
+       }
+
+       if (!ReadFile(file->handle, file->in_data, USB_BUF_SIZE, &got, NULL)) {
+               result = GetLastError();
+               printf ("read failed %d\n", result);
+               return LIBALTOS_ERROR;
+               got = 0;
+       }
+       if (got)
+               return LIBALTOS_SUCCESS;
+       return LIBALTOS_TIMEOUT;
+}
+
+PUBLIC int
+altos_flush(struct altos_file *file)
+{
+       DWORD   put;
+       char    *data = file->out_data;
+       char    used = file->out_used;
+       DWORD   result;
+
+       while (used) {
+               if (!WriteFile(file->handle, data, used, &put, NULL)) {
+                       result = GetLastError();
+                       printf ("write failed %d\n", result);
+                       return LIBALTOS_ERROR;
+               }
+               data += put;
+               used -= put;
+       }
+       file->out_used = 0;
+       return LIBALTOS_SUCCESS;
+}
+
+PUBLIC struct altos_file *
+altos_open(struct altos_device *device)
+{
+       struct altos_file       *file = calloc (sizeof (struct altos_file), 1);
+       char    full_name[64];
+
+       if (!file)
+               return NULL;
+
+       strcpy(full_name, "\\\\.\\");
+       strcat(full_name, device->path);
+       file->handle = CreateFile(full_name, GENERIC_READ|GENERIC_WRITE,
+                                 0, NULL, OPEN_EXISTING,
+                                 FILE_ATTRIBUTE_NORMAL, NULL);
+       if (file->handle == INVALID_HANDLE_VALUE) {
+               free(file);
+               return NULL;
+       }
+
+       timeouts.ReadIntervalTimeout = MAXDWORD;
+       timeouts.ReadTotalTimeoutMultiplier = MAXDWORD;
+       timeouts.ReadTotalTimeoutConstant = 100;
+       timeouts.WriteTotalTimeoutMultiplier = 0;
+       timeouts.WriteTotalTimeoutConstant = 10000;
+       if (!SetCommTimeouts(file->handle, &timeouts)) {
+               printf("SetCommTimeouts failed %d\n", GetLastError());
+       }
+
+       return file;
+}
+
+PUBLIC void

 altos_close(struct altos_file *file)
 {
 altos_close(struct altos_file *file)
 {

-       libusb_close(file->handle);
-       libusb_unref_device(file->device);
-       file->handle = NULL;
+       if (file->handle != INVALID_HANDLE_VALUE) {
+               CloseHandle(file->handle);
+               file->handle = INVALID_HANDLE_VALUE;
+       }
+}
+
+PUBLIC void
+altos_free(struct altos_file *file)
+{
+       altos_close(file);

        free(file);
 }
 
        free(file);
 }
 


@@ -420,60 +880,32 @@ altos_putchar(struct altos_file *file, char c)
 {
        int     ret;
 
 {
        int     ret;
 

-       if (file->out_used == file->out_size) {
+       if (file->out_used == USB_BUF_SIZE) {

                ret = altos_flush(file);
                if (ret)
                        return ret;
        }
        file->out_data[file->out_used++] = c;
                ret = altos_flush(file);
                if (ret)
                        return ret;
        }
        file->out_data[file->out_used++] = c;

-       if (file->out_used == file->out_size)
+       if (file->out_used == USB_BUF_SIZE)

                return altos_flush(file);
                return altos_flush(file);

-       return 0;
-}
-
-int
-altos_flush(struct altos_file *file)
-{
-       while (file->out_used) {
-               int     transferred;
-               int     ret;
-
-               ret = libusb_bulk_transfer(file->handle,
-                                          file->out_ep,
-                                          file->out_data,
-                                          file->out_used,
-                                          &transferred,
-                                          0);
-               if (ret)
-                       return ret;
-               if (transferred) {
-                       memmove(file->out_data, file->out_data + transferred,
-                               file->out_used - transferred);
-                       file->out_used -= transferred;
-               }
-       }
+       return LIBALTOS_SUCCESS;

 }
 
 int
 altos_getchar(struct altos_file *file, int timeout)
 {
 }
 
 int
 altos_getchar(struct altos_file *file, int timeout)
 {

+       int     ret;

        while (file->in_read == file->in_used) {
        while (file->in_read == file->in_used) {

-               int     ret;
-               int     transferred;
-
-               altos_flush(file);
-               ret = libusb_bulk_transfer(file->handle,
-                                          file->in_ep,
-                                          file->in_data,
-                                          file->in_size,
-                                          &transferred,
-                                          (unsigned int) timeout);
+               ret = altos_flush(file);
+               if (ret)
+                       return ret;
+               if (file->handle == INVALID_HANDLE_VALUE)
+                       return LIBALTOS_ERROR;
+               ret = altos_fill(file, timeout);

                if (ret)
                        return ret;
                if (ret)
                        return ret;

-               file->in_read = 0;
-               file->in_used = transferred;

        }
        return file->in_data[file->in_read++];
 }
 
        }
        return file->in_data[file->in_read++];
 }
 

-#endif /* USE_LIBUSB */
+#endif