First cut

usb/descriptor.go

@@ -0,0 +1,194 @@
+package usb
+
+// #cgo LDFLAGS: -lusb-1.0
+// #include <libusb-1.0/libusb.h>
+import "C"
+
+type Descriptor struct {
+	desc      *C.struct_libusb_device_descriptor
+
+	Type      DescriptorType // The type of this descriptor
+	Spec      BCD            // USB Specification Release Number
+	Class     Class // The class of this device
+	SubClass  uint8 // The sub-class (within the class) of this device
+	Protocol  uint8 // The protocol (within the sub-class) of this device
+	Vendor    ID    // The 8-bit Vendor identifer
+	Product   ID    // The 8-bit Product identifier
+	Device    BCD    // The device version
+	Configs   int    // Number of configurations
+}
+
+func newDescriptor(dev *C.libusb_device) (*Descriptor, error) {
+	var desc C.struct_libusb_device_descriptor
+	if errno := C.libusb_get_device_descriptor(dev, &desc); errno < 0 {
+		return nil, usbError(errno)
+	}
+	return &Descriptor{
+		desc:     &desc,
+		Type:     DescriptorType(desc.bDescriptorType),
+		Spec:     BCD(desc.bcdUSB),
+		Class:    Class(desc.bDeviceClass),
+		SubClass: uint8(desc.bDeviceSubClass),
+		Protocol: uint8(desc.bDeviceProtocol),
+		Vendor:   ID(desc.idVendor),
+		Product:  ID(desc.idProduct),
+		Device:   BCD(desc.bcdDevice),
+		Configs:  int(desc.bNumConfigurations),
+	}, nil
+}
+
+/*
+func (d Descriptor) str(idx int) (string, error) {
+	str := [64]byte{}
+	n := C.libusb_get_string_descriptor_ascii(
+		d.dev.handle,
+		C.uint8_t(idx),
+		(*C.uchar)(unsafe.Pointer(&str)),
+		64,
+	)
+	if n < 0 {
+		return "", usbError(n)
+	}
+	return string(str[:n]), nil
+}
+*/
+
+type Class int
+
+const (
+	CLASS_PER_INTERFACE Class = C.LIBUSB_CLASS_PER_INTERFACE
+	CLASS_AUDIO         Class = C.LIBUSB_CLASS_AUDIO
+	CLASS_COMM          Class = C.LIBUSB_CLASS_COMM
+	CLASS_HID           Class = C.LIBUSB_CLASS_HID
+	CLASS_PRINTER       Class = C.LIBUSB_CLASS_PRINTER
+	CLASS_PTP           Class = C.LIBUSB_CLASS_PTP
+	CLASS_MASS_STORAGE  Class = C.LIBUSB_CLASS_MASS_STORAGE
+	CLASS_HUB           Class = C.LIBUSB_CLASS_HUB
+	CLASS_DATA          Class = C.LIBUSB_CLASS_DATA
+	CLASS_WIRELESS      Class = C.LIBUSB_CLASS_WIRELESS
+	CLASS_APPLICATION   Class = C.LIBUSB_CLASS_APPLICATION
+	CLASS_VENDOR_SPEC   Class = C.LIBUSB_CLASS_VENDOR_SPEC
+)
+
+var classDescription = map[Class]string{
+	CLASS_PER_INTERFACE: "per-interface",
+	CLASS_AUDIO:         "audio",
+	CLASS_COMM:          "communications",
+	CLASS_HID:           "human interface device",
+	CLASS_PRINTER:       "printer dclass",
+	CLASS_PTP:           "picture transfer protocol",
+	CLASS_MASS_STORAGE:  "mass storage",
+	CLASS_HUB:           "hub",
+	CLASS_DATA:          "data",
+	CLASS_WIRELESS:      "wireless",
+	CLASS_APPLICATION:   "application",
+	CLASS_VENDOR_SPEC:   "vendor-specific",
+}
+
+func (c Class) String() string {
+	return classDescription[c]
+}
+
+type DescriptorType int
+
+const (
+	DT_DEVICE    DescriptorType = C.LIBUSB_DT_DEVICE
+	DT_CONFIG    DescriptorType = C.LIBUSB_DT_CONFIG
+	DT_STRING    DescriptorType = C.LIBUSB_DT_STRING
+	DT_INTERFACE DescriptorType = C.LIBUSB_DT_INTERFACE
+	DT_ENDPOINT  DescriptorType = C.LIBUSB_DT_ENDPOINT
+	DT_HID       DescriptorType = C.LIBUSB_DT_HID
+	DT_REPORT    DescriptorType = C.LIBUSB_DT_REPORT
+	DT_PHYSICAL  DescriptorType = C.LIBUSB_DT_PHYSICAL
+	DT_HUB       DescriptorType = C.LIBUSB_DT_HUB
+)
+
+var descriptorTypeDescription = map[DescriptorType]string{
+	DT_DEVICE:    "device",
+	DT_CONFIG:    "configuration",
+	DT_STRING:    "string",
+	DT_INTERFACE: "interface",
+	DT_ENDPOINT:  "endpoint",
+	DT_HID:       "HID",
+	DT_REPORT:    "HID report",
+	DT_PHYSICAL:  "physical",
+	DT_HUB:       "hub",
+}
+
+func (dt DescriptorType) String() string {
+	return descriptorTypeDescription[dt]
+}
+
+type EndpointDirection int
+
+const (
+	ENDPOINT_IN  EndpointDirection = C.LIBUSB_ENDPOINT_IN
+	ENDPOINT_OUT EndpointDirection = C.LIBUSB_ENDPOINT_OUT
+)
+
+var endpointDirectionDescription = map[EndpointDirection]string{
+	ENDPOINT_IN:  "device-to-host",
+	ENDPOINT_OUT: "host-to-device",
+}
+
+func (ed EndpointDirection) String() string {
+	return endpointDirectionDescription[ed]
+}
+
+type TransferType int
+
+const (
+	TRANSFER_TYPE_CONTROL     TransferType = C.LIBUSB_TRANSFER_TYPE_CONTROL
+	TRANSFER_TYPE_ISOCHRONOUS TransferType = C.LIBUSB_TRANSFER_TYPE_ISOCHRONOUS
+	TRANSFER_TYPE_BULK        TransferType = C.LIBUSB_TRANSFER_TYPE_BULK
+	TRANSFER_TYPE_INTERRUPT   TransferType = C.LIBUSB_TRANSFER_TYPE_INTERRUPT
+)
+
+var transferTypeDescription = map[TransferType]string{
+	TRANSFER_TYPE_CONTROL:     "control",
+	TRANSFER_TYPE_ISOCHRONOUS: "isochronous",
+	TRANSFER_TYPE_BULK:        "bulk",
+	TRANSFER_TYPE_INTERRUPT:   "interrupt",
+}
+
+func (tt TransferType) String() string {
+	return transferTypeDescription[tt]
+}
+
+type IsoSyncType int
+
+const (
+	ISO_SYNC_TYPE_NONE     IsoSyncType = C.LIBUSB_ISO_SYNC_TYPE_NONE
+	ISO_SYNC_TYPE_ASYNC    IsoSyncType = C.LIBUSB_ISO_SYNC_TYPE_ASYNC
+	ISO_SYNC_TYPE_ADAPTIVE IsoSyncType = C.LIBUSB_ISO_SYNC_TYPE_ADAPTIVE
+	ISO_SYNC_TYPE_SYNC     IsoSyncType = C.LIBUSB_ISO_SYNC_TYPE_SYNC
+)
+
+var isoSyncTypeDescription = map[IsoSyncType]string{
+	ISO_SYNC_TYPE_NONE:     "no synchronization",
+	ISO_SYNC_TYPE_ASYNC:    "asynchronous",
+	ISO_SYNC_TYPE_ADAPTIVE: "adaptive",
+	ISO_SYNC_TYPE_SYNC:     "synchronous",
+}
+
+func (ist IsoSyncType) String() string {
+	return isoSyncTypeDescription[ist]
+}
+
+type IsoUsageType int
+
+const (
+	ISO_USAGE_TYPE_DATA     IsoUsageType = C.LIBUSB_ISO_USAGE_TYPE_DATA
+	ISO_USAGE_TYPE_FEEDBACK IsoUsageType = C.LIBUSB_ISO_USAGE_TYPE_FEEDBACK
+	ISO_USAGE_TYPE_IMPLICIT IsoUsageType = C.LIBUSB_ISO_USAGE_TYPE_IMPLICIT
+)
+
+var isoUsageTypeDescription = map[IsoUsageType]string{
+	ISO_USAGE_TYPE_DATA:     "data",
+	ISO_USAGE_TYPE_FEEDBACK: "feedback",
+	ISO_USAGE_TYPE_IMPLICIT: "implicit data",
+}
+
+func (iut IsoUsageType) String() string {
+	return isoUsageTypeDescription[iut]
+}

usb/device.go

@@ -0,0 +1,90 @@
+package usb
+
+// #cgo LDFLAGS: -lusb-1.0
+// #include <libusb-1.0/libusb.h>
+import "C"
+
+import (
+	"log"
+	"runtime"
+)
+
+type DeviceInfo struct {
+	dev *C.libusb_device
+}
+
+func newDeviceInfo(dev *C.libusb_device) *DeviceInfo {
+	d := &DeviceInfo{
+		dev: dev,
+	}
+
+	// Reference this device
+	C.libusb_ref_device(dev)
+
+	// I still can't get this to be called
+	runtime.SetFinalizer(d, (*DeviceInfo).Close)
+
+	log.Printf("deviceInfo %p initialized", d.dev)
+	return d
+}
+
+// Get the assigned Bus Number for this USB device.
+func (d *DeviceInfo) BusNumber() byte {
+	return byte(C.libusb_get_bus_number(d.dev))
+}
+
+// Get the assigned Bus Address for this USB device.
+func (d *DeviceInfo) Address() byte {
+	return byte(C.libusb_get_device_address(d.dev))
+}
+
+// Get a descriptor for the device.
+func (d *DeviceInfo) Descriptor() (*Descriptor, error) {
+	return newDescriptor(d.dev)
+}
+
+// Open the given device for I/O.
+func (d *DeviceInfo) Open() (*Device, error) {
+	var handle *C.libusb_device_handle
+	if errno := C.libusb_open(d.dev, &handle); errno != 0 {
+		return nil, usbError(errno)
+	}
+
+	return newDevice(handle), nil
+}
+
+// Close decrements the reference count for the device in the libusb driver
+// code.  It should be called exactly once!
+func (d *DeviceInfo) Close() error {
+	if d.dev != nil {
+		log.Printf("deviceInfo %p closed", d.dev)
+		C.libusb_unref_device(d.dev)
+	}
+	d.dev = nil
+	return nil
+}
+
+type Device struct {
+	handle *C.libusb_device_handle
+}
+
+func newDevice(handle *C.libusb_device_handle) *Device {
+	d := &Device{
+		handle: handle,
+	}
+
+	// :(
+	runtime.SetFinalizer(d, (*Device).Close)
+
+	log.Printf("device %p initialized", d.handle)
+	return d
+}
+
+func (d *Device) Close() error {
+	if d.handle != nil {
+		log.Printf("device %p closed", d.handle)
+		C.libusb_unref_device(d.handle)
+	}
+	d.handle = nil
+	return nil
+}

usb/error.go

@@ -0,0 +1,45 @@
+package usb
+
+// #cgo LDFLAGS: -lusb-1.0
+// #include <libusb-1.0/libusb.h>
+import "C"
+
+type usbError C.int
+
+func (e usbError) Error() string {
+	return "libusb: " + usbErrorString[e]
+}
+
+const (
+	SUCCESS             usbError = C.LIBUSB_SUCCESS
+	ERROR_IO            usbError = C.LIBUSB_ERROR_IO
+	ERROR_INVALID_PARAM usbError = C.LIBUSB_ERROR_INVALID_PARAM
+	ERROR_ACCESS        usbError = C.LIBUSB_ERROR_ACCESS
+	ERROR_NO_DEVICE     usbError = C.LIBUSB_ERROR_NO_DEVICE
+	ERROR_NOT_FOUND     usbError = C.LIBUSB_ERROR_NOT_FOUND
+	ERROR_BUSY          usbError = C.LIBUSB_ERROR_BUSY
+	ERROR_TIMEOUT       usbError = C.LIBUSB_ERROR_TIMEOUT
+	ERROR_OVERFLOW      usbError = C.LIBUSB_ERROR_OVERFLOW
+	ERROR_PIPE          usbError = C.LIBUSB_ERROR_PIPE
+	ERROR_INTERRUPTED   usbError = C.LIBUSB_ERROR_INTERRUPTED
+	ERROR_NO_MEM        usbError = C.LIBUSB_ERROR_NO_MEM
+	ERROR_NOT_SUPPORTED usbError = C.LIBUSB_ERROR_NOT_SUPPORTED
+	ERROR_OTHER         usbError = C.LIBUSB_ERROR_OTHER
+)
+
+var usbErrorString = map[usbError]string{
+	C.LIBUSB_SUCCESS:             "success",
+	C.LIBUSB_ERROR_IO:            "i/o error",
+	C.LIBUSB_ERROR_INVALID_PARAM: "invalid param",
+	C.LIBUSB_ERROR_ACCESS:        "bad access",
+	C.LIBUSB_ERROR_NO_DEVICE:     "no device",
+	C.LIBUSB_ERROR_NOT_FOUND:     "not found",
+	C.LIBUSB_ERROR_BUSY:          "device or resource busy",
+	C.LIBUSB_ERROR_TIMEOUT:       "timeout",
+	C.LIBUSB_ERROR_OVERFLOW:      "overflow",
+	C.LIBUSB_ERROR_PIPE:          "pipe error",
+	C.LIBUSB_ERROR_INTERRUPTED:   "interrupted",
+	C.LIBUSB_ERROR_NO_MEM:        "out of memory",
+	C.LIBUSB_ERROR_NOT_SUPPORTED: "not supported",
+	C.LIBUSB_ERROR_OTHER:         "unknown error",
+}

usb/misc.go

@@ -0,0 +1,33 @@
+package usb
+
+import (
+	"fmt"
+)
+
+type BCD uint16
+
+const (
+	USB_2_0 BCD = 0x0200
+	USB_1_1 BCD = 0x0110
+	USB_1_0 BCD = 0x0100
+)
+
+func (d BCD) Int() (i int) {
+	ten := 1
+	for o := uint(0); o < 4; o++ {
+		n := ((0xF << (o*4)) & d) >> (o*4)
+		i += int(n) * ten
+		ten *= 10
+	}
+	return
+}
+
+func (d BCD) String() string {
+	return fmt.Sprintf("%02x.%02x", int(d >> 8), int(d & 0xFF))
+}
+
+type ID uint16
+
+func (id ID) String() string {
+	return fmt.Sprintf("%04x", int(id))
+}

usb/misc_test.go

@@ -0,0 +1,24 @@
+package usb
+
+import (
+	"testing"
+)
+
+func TestBCD(t *testing.T) {
+	tests := []struct{
+		BCD
+		Int int
+		Str string
+	}{
+		{0x1234, 1234, "12.34"},
+	}
+
+	for _, test := range tests {
+		if got, want := test.BCD.Int(), test.Int; got != want {
+			t.Errorf("Int(%x) = %d, want %d", test.BCD, got, want)
+		}
+		if got, want := test.BCD.String(), test.Str; got != want {
+			t.Errorf("String(%x) = %q, want %q", test.BCD, got, want)
+		}
+	}
+}

usb/usb.go

@@ -0,0 +1,76 @@
+package usb
+
+// #cgo LDFLAGS: -lusb-1.0
+// #include <libusb-1.0/libusb.h>
+import "C"
+
+import (
+	"log"
+	"reflect"
+	"runtime"
+	"unsafe"
+)
+
+type Context struct {
+	ctx *C.libusb_context
+}
+
+func (c *Context) Debug(level int) {
+	C.libusb_set_debug(c.ctx, C.int(level))
+}
+
+func NewContext() *Context {
+	c := new(Context)
+
+	log.Printf("gousb initialized")
+	if errno := C.libusb_init(&c.ctx); errno != 0 {
+		panic(usbError(errno))
+	}
+
+	// This doesn't seem to actually get called.  Sigh.
+	runtime.SetFinalizer(c, (*Context).Close)
+
+	return c
+}
+
+// ListDevices calls each with each enumerated device.  If the function returns
+// true, the device is added to the list of *DeviceInfo to return.  All of
+// these must be Closed, even if an error is also returned.
+func (c *Context) ListDevices(each func(bus, addr int, desc *Descriptor) bool) ([]*DeviceInfo, error) {
+	var list **C.libusb_device
+	cnt := C.libusb_get_device_list(c.ctx, &list)
+	if cnt < 0 {
+		return nil, usbError(cnt)
+	}
+	defer C.libusb_free_device_list(list, 1)
+
+	var slice []*C.libusb_device
+	*(*reflect.SliceHeader)(unsafe.Pointer(&slice)) = reflect.SliceHeader{
+		Data: uintptr(unsafe.Pointer(list)),
+		Len:  int(cnt),
+		Cap:  int(cnt),
+	}
+
+	ret := []*DeviceInfo{}
+	for _, dev := range slice {
+		bus := int(C.libusb_get_bus_number(dev))
+		addr := int(C.libusb_get_device_address(dev))
+		desc, err := newDescriptor(dev)
+		if err != nil {
+			return ret, err
+		}
+		if each(bus, addr, desc) {
+			ret = append(ret, newDeviceInfo(dev))
+		}
+	}
+	return ret, nil
+}
+
+func (c *Context) Close() error {
+	if c.ctx != nil {
+		C.libusb_exit(c.ctx)
+		log.Printf("gousb finished")
+	}
+	c.ctx = nil
+	return nil
+}

usb/usb_test.go

@@ -0,0 +1,40 @@
+package usb_test
+
+import (
+	"testing"
+
+	. "github.com/kylelemons/gousb/usb"
+	"github.com/kylelemons/gousb/usbid"
+)
+
+func TestNoop(t *testing.T) {
+	c := NewContext()
+	defer c.Close()
+	c.Debug(3)
+}
+
+func TestEnum(t *testing.T) {
+	c := NewContext()
+	defer c.Close()
+	c.Debug(3)
+
+	devs, err := c.ListDevices(func(bus, addr int, desc *Descriptor) bool {
+		t.Logf("%03d:%03d %+v", bus, addr, desc)
+		if v, ok := usbid.Vendors[desc.Vendor]; ok {
+			if p, ok := v.Devices[desc.Product]; ok {
+				t.Logf(" - %s (%s) %s (%s)", v, desc.Vendor, p, desc.Product)
+			} else {
+				t.Logf(" - %s (%s) Unknown", v, desc.Vendor)
+			}
+		}
+		return false
+	})
+	defer func() {
+		for _, d := range devs {
+			d.Close()
+		}
+	}()
+	if err != nil {
+		t.Fatalf("list: %s", err)
+	}
+}