127 lines
4.0 KiB
Go
127 lines
4.0 KiB
Go
// Copyright 2013 Google Inc. All rights reserved.
|
|
// Copyright 2016 the gousb Authors. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package gousb
|
|
|
|
import (
|
|
"fmt"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// ConfigInfo contains the information about a USB device configuration.
|
|
type ConfigInfo struct {
|
|
// Config is the configuration number.
|
|
Config int
|
|
// SelfPowered is true if the device is powered externally, i.e. not
|
|
// drawing power from the USB bus.
|
|
SelfPowered bool
|
|
// RemoteWakeup is true if the device supports remote wakeup.
|
|
RemoteWakeup bool
|
|
// MaxPower is the maximum current the device draws from the USB bus
|
|
// in this configuration.
|
|
MaxPower Milliamperes
|
|
// Interfaces has a list of USB interfaces available in this configuration.
|
|
Interfaces []InterfaceInfo
|
|
}
|
|
|
|
// String returns the human-readable description of the configuration descriptor.
|
|
func (c ConfigInfo) String() string {
|
|
return fmt.Sprintf("Configuration %d", c.Config)
|
|
}
|
|
|
|
// Config represents a USB device set to use a particular configuration.
|
|
// Only one Config of a particular device can be used at any one time.
|
|
type Config struct {
|
|
Info ConfigInfo
|
|
ControlTimeout time.Duration
|
|
|
|
dev *Device
|
|
|
|
// Claimed interfaces
|
|
mu sync.Mutex
|
|
claimed map[int]bool
|
|
}
|
|
|
|
// Close releases the underlying device, allowing the caller to switch the device to a different configuration.
|
|
func (c *Config) Close() error {
|
|
if c.dev == nil {
|
|
return nil
|
|
}
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
if len(c.claimed) > 0 {
|
|
var ifs []int
|
|
for k := range c.claimed {
|
|
ifs = append(ifs, k)
|
|
}
|
|
return fmt.Errorf("failed to release %s, interfaces %v are still open", c, ifs)
|
|
}
|
|
c.dev.mu.Lock()
|
|
defer c.dev.mu.Unlock()
|
|
c.dev.claimed = nil
|
|
c.dev = nil
|
|
return nil
|
|
}
|
|
|
|
// String returns the human-readable description of the configuration.
|
|
func (c *Config) String() string {
|
|
return fmt.Sprintf("%s,config=%d", c.dev.String(), c.Info.Config)
|
|
}
|
|
|
|
// Control sends a control request to the device.
|
|
func (c *Config) Control(rType, request uint8, val, idx uint16, data []byte) (int, error) {
|
|
if c.dev == nil {
|
|
return 0, fmt.Errorf("Control() called on %s after Close", c)
|
|
}
|
|
return libusb.control(c.dev.handle, c.ControlTimeout, rType, request, val, idx, data)
|
|
}
|
|
|
|
// Interface claims and returns an interface on a USB device.
|
|
func (c *Config) Interface(intf, alt int) (*Interface, error) {
|
|
if c.dev == nil {
|
|
return nil, fmt.Errorf("Interface(%d, %d) called on %s after Close", intf, alt, c)
|
|
}
|
|
if intf < 0 || intf >= len(c.Info.Interfaces) {
|
|
return nil, fmt.Errorf("interface %d not found in %s, available interfaces 0..%d", intf, c, len(c.Info.Interfaces)-1)
|
|
}
|
|
ifInfo := c.Info.Interfaces[intf]
|
|
if alt < 0 || alt >= len(ifInfo.AltSettings) {
|
|
return nil, fmt.Errorf("alternate setting %d not found for %s in %s, available alt settings 0..%d", alt, ifInfo, c, len(ifInfo.AltSettings)-1)
|
|
}
|
|
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
if c.claimed[intf] {
|
|
return nil, fmt.Errorf("interface %d on %s is already claimed", intf, c)
|
|
}
|
|
|
|
// Claim the interface
|
|
if err := libusb.claim(c.dev.handle, uint8(intf)); err != nil {
|
|
return nil, fmt.Errorf("failed to claim interface %d on %s: %v", intf, c, err)
|
|
}
|
|
|
|
if err := libusb.setAlt(c.dev.handle, uint8(intf), uint8(alt)); err != nil {
|
|
libusb.release(c.dev.handle, uint8(intf))
|
|
return nil, fmt.Errorf("failed to set alternate config %d on interface %d of %s: %v", alt, intf, c, err)
|
|
}
|
|
|
|
c.claimed[intf] = true
|
|
return &Interface{
|
|
Setting: ifInfo.AltSettings[alt],
|
|
config: c,
|
|
}, nil
|
|
}
|