/* $Id: surf.c,v 1.4 2004/02/10 03:49:58 jmuelmen Exp $ */

/* Talk to the SuRF board */

#include "inst.h"
#ifdef HAVE_LIBUSB
#include <usb.h>
#include <stdio.h>
#include <string.h>

/* the init routine is from the libusb test utilities */

static struct usb_device *_surf = 0;
static usb_dev_handle *_surf_h;

static void print_endpoint(struct usb_endpoint_descriptor *endpoint)
{
  printf("      bEndpointAddress: %02xh\n", endpoint->bEndpointAddress);
  printf("      bmAttributes:     %02xh\n", endpoint->bmAttributes);
  printf("      wMaxPacketSize:   %d\n", endpoint->wMaxPacketSize);
  printf("      bInterval:        %d\n", endpoint->bInterval);
  printf("      bRefresh:         %d\n", endpoint->bRefresh);
  printf("      bSynchAddress:    %d\n", endpoint->bSynchAddress);
}

static void print_altsetting(struct usb_interface_descriptor *interface)
{
  int i;

  printf("    bInterfaceNumber:   %d\n", interface->bInterfaceNumber);
  printf("    bAlternateSetting:  %d\n", interface->bAlternateSetting);
  printf("    bNumEndpoints:      %d\n", interface->bNumEndpoints);
  printf("    bInterfaceClass:    %d\n", interface->bInterfaceClass);
  printf("    bInterfaceSubClass: %d\n", interface->bInterfaceSubClass);
  printf("    bInterfaceProtocol: %d\n", interface->bInterfaceProtocol);
  printf("    iInterface:         %d\n", interface->iInterface);

  for (i = 0; i < interface->bNumEndpoints; i++)
    print_endpoint(&interface->endpoint[i]);
}

static void print_interface(struct usb_interface *interface)
{
  int i;

  for (i = 0; i < interface->num_altsetting; i++)
    print_altsetting(&interface->altsetting[i]);
}

static void print_configuration(struct usb_config_descriptor *config)
{
  int i;

  printf("  wTotalLength:         %d\n", config->wTotalLength);
  printf("  bNumInterfaces:       %d\n", config->bNumInterfaces);
  printf("  bConfigurationValue:  %d\n", config->bConfigurationValue);
  printf("  iConfiguration:       %d\n", config->iConfiguration);
  printf("  bmAttributes:         %02xh\n", config->bmAttributes);
  printf("  MaxPower:             %d\n", config->MaxPower);

  for (i = 0; i < config->bNumInterfaces; i++)
    print_interface(&config->interface[i]);
}
#endif

int surf_init ()
{
#ifdef HAVE_LIBUSB
     struct usb_bus *bus;
     struct usb_device *dev;
     char data[] = "baz";

     usb_set_debug(10000);

     if (_surf) {
	  /* get rid of the old handle */
	  usb_release_interface(_surf_h, 0);
	  usb_close(_surf_h);
	  _surf_h = 0;
     }
     
     usb_init();
     
     usb_find_busses();
     usb_find_devices();
     
     printf("bus/device  idVendor/idProduct\n");
     for (bus = usb_busses; bus; bus = bus->next) {
	  for (dev = bus->devices; dev; dev = dev->next) {
	       int i, ret;
	       char string[256];
	       usb_dev_handle *udev;
	       
	       printf("%s/%s     %04X/%04X\n", bus->dirname, dev->filename,
		      dev->descriptor.idVendor, dev->descriptor.idProduct);
	       
	       udev = usb_open(dev);
	       if (udev) {
		    if (dev->descriptor.iManufacturer) {
			 ret = usb_get_string_simple(udev, dev->descriptor.
						     iManufacturer, string, 
						     sizeof(string));
			 if (ret > 0)
			      printf("- Manufacturer : %s\n", string);
			 else
			      printf("- Unable to fetch manufacturer string\n");
		    }

		    if (dev->descriptor.idVendor != 0x03eb) {
			 /* the Atmel hub, for some reason, he is fickle */
			 if (dev->descriptor.iProduct) { 
			      ret = usb_get_string_simple(udev, 
							  dev->descriptor.
							  iProduct, string, 
							  sizeof(string));
				   if (ret > 0) 
					printf("- Product      : %s\n", 
					       string); 
				   else 
					printf("- Unable to fetch product "
					       "string\n"); 
			 } 
		    }

		    if (dev->descriptor.iSerialNumber) {
			 ret = usb_get_string_simple(udev, dev->descriptor.
						     iSerialNumber, 
						     string, sizeof(string));
			 if (ret > 0)
			      printf("- Serial Number: %s\n", string);
			 else
			      printf("- Unable to fetch serial number "
				     "string\n");
		    }
	       }
	       
	       if (!dev->config) {
		    printf("  Couldn't retrieve descriptors\n");
		    continue;
	       }
	       
	       for (i = 0; i < dev->descriptor.bNumConfigurations; i++)
		    print_configuration(&dev->config[i]);
	       
	       if (dev->descriptor.idVendor == 0x4242 &&
		   dev->descriptor.idProduct == 0xbeef)
		    _surf = dev;
	  }
     }
     
     if (!_surf) {
	  fprintf(stderr, "Could not find surf board, exiting\n");
	  return 1;
     }
     
     _surf_h = usb_open(_surf);
     usb_claim_interface(_surf_h, 0);
#endif
     return 0;
}

int surf_write (int ep, char *data)
{
#ifdef HAVE_LIBUSB
     if (!_surf)
	  return -1;
     printf("Writing %d byte%s: %s\n", strlen(data) + 1, 
	    strlen(data) ? "s" : "", data);
     usb_bulk_write(_surf_h, ep, data, strlen(data) + 1, 1000);
#endif
     return 0;
}

int surf_echo_read (int ep)
{
#ifdef HAVE_LIBUSB
     char data[100];
     int n_b, i;

     if (!_surf)
	  return -1;
     printf("Reading %d bytes: ", sizeof(data));
     n_b = usb_bulk_read(_surf_h, ep, data, sizeof(data), 1000);
     if (n_b > 0)
	  data[n_b] = 0;
     printf("got %d: ", n_b);
     for (i = 0; i < n_b; ++i)
	  printf("%x ", data[i]);
     printf("\n");
#endif
     return 0;
}

int surf_toggle (int port, int b) 
{ 
#ifdef HAVE_LIBUSB
     return usb_control_msg(_surf_h, 0x40, 0xb5 + port, b, 0, NULL, 0, 1000); 
#else 
     return 0;
#endif
}