Tryanks/gousb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more comments. Rename USBError to just Error.

Browse Source
This commit is contained in:
Sebastian Zagrodzki
2017-04-09 19:41:44 +02:00
parent 87c7a873e9
commit a5c4de3a29
3 changed files with 59 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
usb/device.go
View File

@@ -21,10 +21,16 @@ import (
"time" "time"
) )
var DefaultReadTimeout = 1 * time.Second var (
var DefaultWriteTimeout = 1 * time.Second // DefaultReadTimeout controls the default timeout for IN endpoint transfers.
var DefaultControlTimeout = 250 * time.Millisecond //5 * time.Second DefaultReadTimeout = 1 * time.Second
// DefaultWriteTimeout controls the default timeout for OUT endpoint transfers.
DefaultWriteTimeout = 1 * time.Second
// DefaultControlTimeout controls the default timeout for control transfers.
DefaultControlTimeout = 250 * time.Millisecond
)
// Device represents an opened USB device.
type Device struct { type Device struct {
handle *libusbDevHandle handle *libusbDevHandle
@@ -56,10 +62,12 @@ func newDevice(handle *libusbDevHandle, desc *Descriptor) *Device {
return d return d
} }
// Reset performs a USB port reset to reinitialize a device.
func (d *Device) Reset() error { func (d *Device) Reset() error {
return libusb.reset(d.handle) return libusb.reset(d.handle)
} }
// Control sends a control request to the device.
func (d *Device) Control(rType, request uint8, val, idx uint16, data []byte) (int, error) { func (d *Device) Control(rType, request uint8, val, idx uint16, data []byte) (int, error) {
return libusb.control(d.handle, d.ControlTimeout, rType, request, val, idx, data) return libusb.control(d.handle, d.ControlTimeout, rType, request, val, idx, data)
} }
@@ -77,7 +85,7 @@ func (d *Device) SetConfig(cfg uint8) error {
return libusb.setConfig(d.handle, cfg) return libusb.setConfig(d.handle, cfg)
} }
// Close the device. // Close closes the device.
func (d *Device) Close() error { func (d *Device) Close() error {
if d.handle == nil { if d.handle == nil {
return fmt.Errorf("usb: double close on device") return fmt.Errorf("usb: double close on device")
@@ -92,6 +100,7 @@ func (d *Device) Close() error {
return nil return nil
} }
// OpenEndpoint prepares a device endpoint for data transfer.
func (d *Device) OpenEndpoint(epAddr, cfgNum, ifNum, setNum uint8) (*Endpoint, error) { func (d *Device) OpenEndpoint(epAddr, cfgNum, ifNum, setNum uint8) (*Endpoint, error) {
var cfg *ConfigInfo var cfg *ConfigInfo
for _, c := range d.Configs { for _, c := range d.Configs {
@@ -174,8 +183,12 @@ func (d *Device) OpenEndpoint(epAddr, cfgNum, ifNum, setNum uint8) (*Endpoint, e
return end, nil return end, nil
} }
func (d *Device) GetStringDescriptor(desc_index int) (string, error) { // GetStringDescriptor returns a device string descriptor with the given index
return libusb.getStringDesc(d.handle, desc_index) // number. The first supported language is always used and the returned
// descriptor string is converted to ASCII (non-ASCII characters are replaced
// with "?").
func (d *Device) GetStringDescriptor(descIndex int) (string, error) {
return libusb.getStringDesc(d.handle, descIndex)
} }
// SetAutoDetach enables/disables libusb's automatic kernel driver detachment. // SetAutoDetach enables/disables libusb's automatic kernel driver detachment.

42
usb/error.go
View File

@@ -22,16 +22,16 @@ import (
// #include <libusb.h> // #include <libusb.h>
import "C" import "C"
// USBError is an error code returned by libusb. // Error is an error code returned by libusb.
type USBError C.int type Error C.int
// Error implements the error interface. // Error implements the error interface.
func (e USBError) Error() string { func (e Error) Error() string {
return fmt.Sprintf("libusb: %s [code %d]", USBErrorString[e], e) return fmt.Sprintf("libusb: %s [code %d]", errorString[e], e)
} }
func fromUSBError(errno C.int) error { func fromErrNo(errno C.int) error {
err := USBError(errno) err := Error(errno)
if err == Success { if err == Success {
return nil return nil
} }
@@ -40,23 +40,23 @@ func fromUSBError(errno C.int) error {
// Error codes defined by libusb. // Error codes defined by libusb.
const ( const (
Success USBError = C.LIBUSB_SUCCESS Success Error = C.LIBUSB_SUCCESS
ErrorIO USBError = C.LIBUSB_ERROR_IO ErrorIO Error = C.LIBUSB_ERROR_IO
ErrorInvalidParam USBError = C.LIBUSB_ERROR_INVALID_PARAM ErrorInvalidParam Error = C.LIBUSB_ERROR_INVALID_PARAM
ErrorAccess USBError = C.LIBUSB_ERROR_ACCESS ErrorAccess Error = C.LIBUSB_ERROR_ACCESS
ErrorNoDevice USBError = C.LIBUSB_ERROR_NO_DEVICE ErrorNoDevice Error = C.LIBUSB_ERROR_NO_DEVICE
ErrorNotFound USBError = C.LIBUSB_ERROR_NOT_FOUND ErrorNotFound Error = C.LIBUSB_ERROR_NOT_FOUND
ErrorBusy USBError = C.LIBUSB_ERROR_BUSY ErrorBusy Error = C.LIBUSB_ERROR_BUSY
ErrorTimeout USBError = C.LIBUSB_ERROR_TIMEOUT ErrorTimeout Error = C.LIBUSB_ERROR_TIMEOUT
ErrorOverflow USBError = C.LIBUSB_ERROR_OVERFLOW ErrorOverflow Error = C.LIBUSB_ERROR_OVERFLOW
ErrorPipe USBError = C.LIBUSB_ERROR_PIPE ErrorPipe Error = C.LIBUSB_ERROR_PIPE
ErrorInterrupted USBError = C.LIBUSB_ERROR_INTERRUPTED ErrorInterrupted Error = C.LIBUSB_ERROR_INTERRUPTED
ErrorNoMem USBError = C.LIBUSB_ERROR_NO_MEM ErrorNoMem Error = C.LIBUSB_ERROR_NO_MEM
ErrorNotSupported USBError = C.LIBUSB_ERROR_NOT_SUPPORTED ErrorNotSupported Error = C.LIBUSB_ERROR_NOT_SUPPORTED
ErrorOther USBError = C.LIBUSB_ERROR_OTHER ErrorOther Error = C.LIBUSB_ERROR_OTHER
) )
var USBErrorString = map[USBError]string{ var errorString = map[Error]string{
Success: "success", Success: "success",
ErrorIO: "i/o error", ErrorIO: "i/o error",
ErrorInvalidParam: "invalid param", ErrorInvalidParam: "invalid param",

35
usb/libusb.go
View File

@@ -151,7 +151,7 @@ type libusbImpl struct{}
func (libusbImpl) init() (*libusbContext, error) { func (libusbImpl) init() (*libusbContext, error) {
var ctx *C.libusb_context var ctx *C.libusb_context
if err := fromUSBError(C.libusb_init(&ctx)); err != nil { if err := fromErrNo(C.libusb_init(&ctx)); err != nil {
return nil, err return nil, err
} }
return (*libusbContext)(ctx), nil return (*libusbContext)(ctx), nil
@@ -166,7 +166,7 @@ func (libusbImpl) handleEvents(c *libusbContext, done <-chan struct{}) {
default: default:
} }
if errno := C.libusb_handle_events_timeout_completed((*C.libusb_context)(c), &tv, nil); errno < 0 { if errno := C.libusb_handle_events_timeout_completed((*C.libusb_context)(c), &tv, nil); errno < 0 {
log.Printf("handle_events: error: %s", USBError(errno)) log.Printf("handle_events: error: %s", Error(errno))
} }
} }
} }
@@ -175,7 +175,7 @@ func (libusbImpl) getDevices(ctx *libusbContext) ([]*libusbDevice, error) {
var list **C.libusb_device var list **C.libusb_device
cnt := C.libusb_get_device_list((*C.libusb_context)(ctx), &list) cnt := C.libusb_get_device_list((*C.libusb_context)(ctx), &list)
if cnt < 0 { if cnt < 0 {
return nil, fromUSBError(C.int(cnt)) return nil, fromErrNo(C.int(cnt))
} }
var devs []*C.libusb_device var devs []*C.libusb_device
*(*reflect.SliceHeader)(unsafe.Pointer(&devs)) = reflect.SliceHeader{ *(*reflect.SliceHeader)(unsafe.Pointer(&devs)) = reflect.SliceHeader{
@@ -202,14 +202,14 @@ func (libusbImpl) setDebug(c *libusbContext, lvl int) {
func (libusbImpl) getDeviceDesc(d *libusbDevice) (*Descriptor, error) { func (libusbImpl) getDeviceDesc(d *libusbDevice) (*Descriptor, error) {
var desc C.struct_libusb_device_descriptor var desc C.struct_libusb_device_descriptor
if err := fromUSBError(C.libusb_get_device_descriptor((*C.libusb_device)(d), &desc)); err != nil { if err := fromErrNo(C.libusb_get_device_descriptor((*C.libusb_device)(d), &desc)); err != nil {
return nil, err return nil, err
} }
// Enumerate configurations // Enumerate configurations
var cfgs []ConfigInfo var cfgs []ConfigInfo
for i := 0; i < int(desc.bNumConfigurations); i++ { for i := 0; i < int(desc.bNumConfigurations); i++ {
var cfg *C.struct_libusb_config_descriptor var cfg *C.struct_libusb_config_descriptor
if err := fromUSBError(C.libusb_get_config_descriptor((*C.libusb_device)(d), C.uint8_t(i), &cfg)); err != nil { if err := fromErrNo(C.libusb_get_config_descriptor((*C.libusb_device)(d), C.uint8_t(i), &cfg)); err != nil {
return nil, err return nil, err
} }
c := ConfigInfo{ c := ConfigInfo{
@@ -289,7 +289,7 @@ func (libusbImpl) dereference(d *libusbDevice) {
func (libusbImpl) open(d *libusbDevice) (*libusbDevHandle, error) { func (libusbImpl) open(d *libusbDevice) (*libusbDevHandle, error) {
var handle *C.libusb_device_handle var handle *C.libusb_device_handle
if err := fromUSBError(C.libusb_open((*C.libusb_device)(d), &handle)); err != nil { if err := fromErrNo(C.libusb_open((*C.libusb_device)(d), &handle)); err != nil {
return nil, err return nil, err
} }
return (*libusbDevHandle)(handle), nil return (*libusbDevHandle)(handle), nil
@@ -300,7 +300,7 @@ func (libusbImpl) close(d *libusbDevHandle) {
} }
func (libusbImpl) reset(d *libusbDevHandle) error { func (libusbImpl) reset(d *libusbDevHandle) error {
return fromUSBError(C.libusb_reset_device((*C.libusb_device_handle)(d))) return fromErrNo(C.libusb_reset_device((*C.libusb_device_handle)(d)))
} }
func (libusbImpl) control(d *libusbDevHandle, timeout time.Duration, rType, request uint8, val, idx uint16, data []byte) (int, error) { func (libusbImpl) control(d *libusbDevHandle, timeout time.Duration, rType, request uint8, val, idx uint16, data []byte) (int, error) {
@@ -315,7 +315,7 @@ func (libusbImpl) control(d *libusbDevHandle, timeout time.Duration, rType, requ
C.uint16_t(len(data)), C.uint16_t(len(data)),
C.uint(timeout/time.Millisecond)) C.uint(timeout/time.Millisecond))
if n < 0 { if n < 0 {
return int(n), fromUSBError(n) return int(n), fromErrNo(n)
} }
return int(n), nil return int(n), nil
} }
@@ -323,15 +323,18 @@ func (libusbImpl) control(d *libusbDevHandle, timeout time.Duration, rType, requ
func (libusbImpl) getConfig(d *libusbDevHandle) (uint8, error) { func (libusbImpl) getConfig(d *libusbDevHandle) (uint8, error) {
var cfg C.int var cfg C.int
if errno := C.libusb_get_configuration((*C.libusb_device_handle)(d), &cfg); errno < 0 { if errno := C.libusb_get_configuration((*C.libusb_device_handle)(d), &cfg); errno < 0 {
return 0, fromUSBError(errno) return 0, fromErrNo(errno)
} }
return uint8(cfg), nil return uint8(cfg), nil
} }
func (libusbImpl) setConfig(d *libusbDevHandle, cfg uint8) error { func (libusbImpl) setConfig(d *libusbDevHandle, cfg uint8) error {
return fromUSBError(C.libusb_set_configuration((*C.libusb_device_handle)(d), C.int(cfg))) return fromErrNo(C.libusb_set_configuration((*C.libusb_device_handle)(d), C.int(cfg)))
} }
// TODO(sebek): device string descriptors are natively in UTF16 and support
// multiple languages. get_string_descriptor_ascii uses always the first
// language and discards non-ascii bytes. We could do better if needed.
func (libusbImpl) getStringDesc(d *libusbDevHandle, index int) (string, error) { func (libusbImpl) getStringDesc(d *libusbDevHandle, index int) (string, error) {
// allocate 200-byte array limited the length of string descriptor // allocate 200-byte array limited the length of string descriptor
buf := make([]byte, 200) buf := make([]byte, 200)
@@ -343,13 +346,13 @@ func (libusbImpl) getStringDesc(d *libusbDevHandle, index int) (string, error) {
(*C.uchar)(unsafe.Pointer(&buf[0])), (*C.uchar)(unsafe.Pointer(&buf[0])),
200) 200)
if errno < 0 { if errno < 0 {
return "", fmt.Errorf("usb: getstr: %s", fromUSBError(errno)) return "", fmt.Errorf("usb: getstr: %s", fromErrNo(errno))
} }
return string(buf[:errno]), nil return string(buf[:errno]), nil
} }
func (libusbImpl) setAutoDetach(d *libusbDevHandle, val int) error { func (libusbImpl) setAutoDetach(d *libusbDevHandle, val int) error {
err := fromUSBError(C.libusb_set_auto_detach_kernel_driver((*C.libusb_device_handle)(d), C.int(val))) err := fromErrNo(C.libusb_set_auto_detach_kernel_driver((*C.libusb_device_handle)(d), C.int(val)))
if err != nil && err != ErrorNotSupported { if err != nil && err != ErrorNotSupported {
return err return err
} }
@@ -357,7 +360,7 @@ func (libusbImpl) setAutoDetach(d *libusbDevHandle, val int) error {
} }
func (libusbImpl) claim(d *libusbDevHandle, iface uint8) error { func (libusbImpl) claim(d *libusbDevHandle, iface uint8) error {
return fromUSBError(C.libusb_claim_interface((*C.libusb_device_handle)(d), C.int(iface))) return fromErrNo(C.libusb_claim_interface((*C.libusb_device_handle)(d), C.int(iface)))
} }
func (libusbImpl) release(d *libusbDevHandle, iface uint8) { func (libusbImpl) release(d *libusbDevHandle, iface uint8) {
@@ -365,7 +368,7 @@ func (libusbImpl) release(d *libusbDevHandle, iface uint8) {
} }
func (libusbImpl) setAlt(d *libusbDevHandle, iface, setup uint8) error { func (libusbImpl) setAlt(d *libusbDevHandle, iface, setup uint8) error {
return fromUSBError(C.libusb_set_interface_alt_setting((*C.libusb_device_handle)(d), C.int(iface), C.int(setup))) return fromErrNo(C.libusb_set_interface_alt_setting((*C.libusb_device_handle)(d), C.int(iface), C.int(setup)))
} }
func (libusbImpl) alloc(d *libusbDevHandle, ep *EndpointInfo, timeout time.Duration, isoPackets int, buf []byte) (*libusbTransfer, error) { func (libusbImpl) alloc(d *libusbDevHandle, ep *EndpointInfo, timeout time.Duration, isoPackets int, buf []byte) (*libusbTransfer, error) {
@@ -384,12 +387,12 @@ func (libusbImpl) alloc(d *libusbDevHandle, ep *EndpointInfo, timeout time.Durat
} }
func (libusbImpl) cancel(t *libusbTransfer) error { func (libusbImpl) cancel(t *libusbTransfer) error {
return fromUSBError(C.libusb_cancel_transfer((*C.struct_libusb_transfer)(t))) return fromErrNo(C.libusb_cancel_transfer((*C.struct_libusb_transfer)(t)))
} }
func (libusbImpl) submit(t *libusbTransfer, done chan struct{}) error { func (libusbImpl) submit(t *libusbTransfer, done chan struct{}) error {
t.user_data = (unsafe.Pointer)(&done) t.user_data = (unsafe.Pointer)(&done)
return fromUSBError(C.submit((*C.struct_libusb_transfer)(t))) return fromErrNo(C.submit((*C.struct_libusb_transfer)(t)))
} }
func (libusbImpl) data(t *libusbTransfer) (int, TransferStatus) { func (libusbImpl) data(t *libusbTransfer) (int, TransferStatus) {