// 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. // lsusb lists attached USB devices. package main import ( "flag" "fmt" "log" "github.com/kylelemons/gousb/usb" "github.com/kylelemons/gousb/usbid" ) var ( debug = flag.Int("debug", 0, "libusb debug level (0..3)") ) func main() { flag.Parse() // Only one context should be needed for an application. It should always be closed. ctx := usb.NewContext() defer ctx.Close() // Debugging can be turned on; this shows some of the inner workings of the libusb package. ctx.Debug(*debug) // ListDevices is used to find the devices to open. devs, err := ctx.ListDevices(func(desc *usb.Descriptor) bool { // The usbid package can be used to print out human readable information. fmt.Printf("%03d.%03d %s:%s %s\n", desc.Bus, desc.Address, desc.Vendor, desc.Product, usbid.Describe(desc)) fmt.Printf(" Protocol: %s\n", usbid.Classify(desc)) // The configurations can be examined from the Descriptor, though they can only // be set once the device is opened. All configuration references must be closed, // to free up the memory in libusb. for _, cfg := range desc.Configs { // This loop just uses more of the built-in and usbid pretty printing to list // the USB devices. fmt.Printf(" %s:\n", cfg) for _, alt := range cfg.Interfaces { fmt.Printf(" --------------\n") for _, iface := range alt.Setups { fmt.Printf(" %s\n", iface) fmt.Printf(" %s\n", usbid.Classify(iface)) for _, end := range iface.Endpoints { fmt.Printf(" %s\n", end) } } } fmt.Printf(" --------------\n") } // After inspecting the descriptor, return true or false depending on whether // the device is "interesting" or not. Any descriptor for which true is returned // opens a Device which is retuned in a slice (and must be subsequently closed). return false }) // All Devices returned from ListDevices must be closed. defer func() { for _, d := range devs { d.Close() } }() // ListDevices can occaionally fail, so be sure to check its return value. if err != nil { log.Fatalf("list: %s", err) } for _, dev := range devs { // Once the device has been selected from ListDevices, it is opened // and can be interacted with. _ = dev } }