struct libusb_device_handle *usb_init(struct libusb_context* context, int devid) {
struct libusb_device **device_list;
struct libusb_device_handle *handle = NULL;
int deviceCount = libusb_get_device_list(context, &device_list);
int i;
for (i = 0; i < deviceCount; i++) {
struct libusb_device* device = device_list[i];
struct libusb_device_descriptor desc;
libusb_get_device_descriptor(device, &desc);
if (desc.idVendor == VENDOR_ID && desc.idProduct == devid) {
libusb_open(device, &handle);
break;
}
}
libusb_free_device_list(device_list, 1);
return handle;
}
void openAuxDevice(int index = 0)
{
libusb_device **devs; //pointer to pointer of device, used to retrieve a list of devices
ssize_t cnt = libusb_get_device_list (0, &devs); //get the list of devices
if (cnt < 0)
{
ROS_ERROR("No device on USB");
return;
}
int nr_mot(0);
for (int i = 0; i < cnt; ++i)
{
struct libusb_device_descriptor desc;
const int r = libusb_get_device_descriptor (devs[i], &desc);
if (r < 0)
continue;
// Search for the aux
if (desc.idVendor == MS_MAGIC_VENDOR && desc.idProduct == MS_MAGIC_MOTOR_PRODUCT)
{
// If the index given by the user matches our camera index
if (nr_mot == index)
{
if ((libusb_open (devs[i], &dev) != 0) || (dev == 0))
{
ROS_ERROR_STREAM("Cannot open aux " << index);
return;
}
// Claim the aux
libusb_claim_interface (dev, 0);
break;
}
else
nr_mot++;
}
}
libusb_free_device_list (devs, 1); // free the list, unref the devices in it
}
LIBMTP_raw_device_t *smtpfs_raw_device_new(const std::string &path)
{
libusb_context *ctx;
int err = libusb_init(&ctx);
if (err)
return nullptr;
std::string dev_path(smtpfs_realpath(path));
libusb_device **dev_list;
ssize_t num_devs = libusb_get_device_list(ctx, &dev_list);
if (num_devs < 1) {
libusb_exit(ctx);
return nullptr;
}
libusb_device *dev = nullptr;
for (auto i = 0; i < num_devs; ++i) {
dev = dev_list[i];
uint8_t bnum = libusb_get_bus_number(dev_list[i]);
uint8_t dnum = libusb_get_device_address(dev_list[i]);
std::stringstream ss;
ss << smtpfs_devbususb
<< std::setw(3) << std::setfill('0')
<< static_cast<uint16_t>(bnum) << "/"
<< std::setw(3) << std::setfill('0')
<< static_cast<uint16_t>(dnum);
if (ss.str() == dev_path)
break;
dev = nullptr;
}
LIBMTP_raw_device_t *raw_device = smtpfs_raw_device_new_priv(dev);
libusb_free_device_list(dev_list, 0);
libusb_exit(ctx);
return raw_device;
}
int fnusb_num_devices(fnusb_ctx *ctx)
{
libusb_device **devs;
//pointer to pointer of device, used to retrieve a list of devices
ssize_t cnt = libusb_get_device_list (ctx->ctx, &devs);
//get the list of devices
if (cnt < 0)
return (-1);
int nr = 0, i = 0;
struct libusb_device_descriptor desc;
for (i = 0; i < cnt; ++i)
{
int r = libusb_get_device_descriptor (devs[i], &desc);
if (r < 0)
continue;
if (desc.idVendor == VID_MICROSOFT && desc.idProduct == PID_NUI_CAMERA)
nr++;
}
libusb_free_device_list (devs, 1);
// free the list, unref the devices in it
return nr;
}
uint32_t auc_getcounts(void)
{
static int32_t usb_init = 0;
struct libusb_device **devs = NULL;
struct libusb_device_descriptor info;
uint32_t count, i;
if (!usb_init) {
if (libusb_init(NULL) < 0) {
printf("libusb_init failed!\n");
return 1;
}
usb_init = 1;
} else {
if (devs) {
libusb_free_device_list(devs, 1);
devs = NULL;
}
for (i = 0; i < auc_devctx.auc_cnt; i++)
auc_devctx.auc_devlist[i] = NULL;
auc_devctx.auc_cnt = 0;
}
count = libusb_get_device_list(NULL, &devs);
if (count <= 0) {
printf("libusb_get_device_list get NULL\n");
return 0;
}
for (i = 0; i < count; i++) {
libusb_get_device_descriptor(devs[i], &info);
if ((info.idVendor == AUC_VID) && (info.idProduct == AUC_PID)) {
auc_devctx.auc_devlist[auc_devctx.auc_cnt] = devs[i];
auc_devctx.auc_cnt++;
}
}
return auc_devctx.auc_cnt;
}
static libusb_device* find_device()
{
// return value
libusb_device* r = NULL;
int errno;
// number of devices found
ssize_t cnt;
cnt = libusb_get_device_list(usb_context, &devices);
for (ssize_t i = 0; i < cnt; i++)
{
struct libusb_device_descriptor desc;
errno = libusb_get_device_descriptor(devices[i], &desc);
if (errno < 0)
{
printf("Failed getting device descriptor of device %zd %s\n", i, libusb_error_name(errno));
}
if (desc.idVendor == VENDOR_LOGITECH && desc.idProduct == PRODUCT_G930)
{
r = devices[i];
printf("Found Logitech G930!\n");
device_found = DEVICE_G930;
break;
}
else if (desc.idVendor == VENDOR_CORSAIR && desc.idProduct == PRODUCT_VOID)
{
r = devices[i];
printf("Found Corsair VOID!\n");
device_found = DEVICE_VOID;
break;
}
}
return r;
}
libusb_device_handle* InfinityPortal::connect(int deviceId) {
libusb_device** devices;
libusb_context* context;
struct libusb_device_handle* tryDeviceHandler;
libusb_init(&context);
int devicesCount = libusb_get_device_list(context, &devices);
int error;
struct libusb_device_descriptor descriptor;
int retVal = libusb_open(devices[deviceId], &tryDeviceHandler);
libusb_get_device_descriptor(devices[deviceId], &descriptor);
if(descriptor.idVendor == 0x0e6f && descriptor.idProduct == 0x0129) {
return tryDeviceHandler;
}
}
libusb_device* usb_find_device_by_path(uint8_t busnum, uint8_t devnum)
{
libusb_device* ret_device = 0;
libusb_device** list;
ssize_t num_devices = libusb_get_device_list(NULL, &list);
for(ssize_t dev_it = 0; dev_it < num_devices; ++dev_it)
{
libusb_device* dev = list[dev_it];
if (busnum == libusb_get_bus_number(dev) &&
devnum == libusb_get_device_address(dev))
{
ret_device = dev;
libusb_ref_device(ret_device);
break;
}
}
libusb_free_device_list(list, 1 /* unref_devices */);
return ret_device;
}
vector<TreehopperBoard>* TreehopperManager::ScanForDevices()
{
ssize_t cnt;
cnt = libusb_get_device_list(NULL, &devs);
if (cnt < 0)
return &BoardList;
libusb_device *dev;
int i = 0;
while ((dev = devs[i++]) != NULL)
{
struct libusb_device_descriptor desc;
int r = libusb_get_device_descriptor(dev, &desc);
if (r < 0) {
return &BoardList;
}
if (desc.idProduct == TreehopperBoard::pid && desc.idVendor == TreehopperBoard::vid)
{
// Get the name and serial number
libusb_device_handle* candidate;
libusb_open(dev, &candidate);
unsigned char buffer[64];
libusb_get_string_descriptor_ascii(candidate, 4, buffer, 128);
string name = string((const char*)buffer);
libusb_get_string_descriptor_ascii(candidate, 3, buffer, 128);
string serialNumber = string((const char*)buffer);
libusb_close(candidate);
BoardList.push_back(TreehopperBoard(serialNumber));
}
}
return &BoardList;
}
int main(int argc, char *argv[])
{
libusb_device **devs;
libusb_context *context = NULL;
size_t list;
size_t i;
int ret;
ret = libusb_init(&context);
if(ret < 0)
{
perror("libusb_init");
exit(1);
}
list = libusb_get_device_list(context, &devs);
if(list < 0)
{
fprinf(stderr, "Error in getting device list\n");
libusb_free_device_list(devs,1);
libusb_exit(context);
exit(1);
}
printf("There are %d devices found", list);
for(i = 0; i < list; i++)
{
print_devices(devs[i]);
}
libusb_free_device_list(devs, 1);
libusb_exit(context);
return 0;
}
int main(void)
{
libusb_device **devs;
int r;
ssize_t cnt;
r = libusb_init(NULL);
if (r < 0)
return r;
cnt = libusb_get_device_list(NULL, &devs);
if (cnt < 0){
libusb_exit(NULL);
return (int) cnt;
}
print_devs(devs);
libusb_free_device_list(devs, 1);
libusb_exit(NULL);
return 0;
}
int main(int argc,char **argv)
{
(void)argc;
(void)argv;
assert(libusb_init(NULL)==0);
libusb_set_debug(NULL,3);
libusb_device **device_list;
ssize_t list_size=libusb_get_device_list(NULL,&device_list);
assert(list_size>=0);
libusb_device *found = NULL;
for(ssize_t i=0;i<list_size;i++)
{
if(is_debug(device_list[i]))
found=device_list[i];
}
if(found)
{
libusb_device_handle *handle;
int err = libusb_open(found,&handle);
assert(err==0);
main_loop(handle);
libusb_close(handle);
}
libusb_free_device_list(device_list,1);
libusb_exit(NULL);
return 0;
}
int irecv_usb_get_device_list(libusb_context *context,
libusb_device ***usb_device_list) {
struct libusb_device **ret;
ssize_t len;
size_t i;
if (libirecovery_usage_context == IRECV_CTX_LOCAL) {
return libusb_get_device_list(context, usb_device_list);
}
libusbip_get_device_list(&libirecovery_connection_info,
&libirecovery_device_list);
len = libirecovery_device_list.n_devices;
ret = malloc(sizeof(void *) * (len + 1));
if (!ret) {
return -1;
}
ret[len] = NULL;
for (i = 0; i < len; i++) {
libusb_device *dev
= malloc(sizeof(struct libusb_device));
if (!dev) {
free(ret);
return -1;
}
struct libusbip_device *idev = &libirecovery_device_list.devices[i];
dev->bus_number = idev->bus_number;
dev->device_address = idev->device_address;
dev->num_configurations = idev->num_configurations;
dev->session_data = idev->session_data;
ret[i] = dev;
}
*usb_device_list = ret;
return len;
}
bool isConnctedUsbDevice(){
libusb_device **devs;
int r;
ssize_t cnt;
r = libusb_init(NULL);
if (r < 0)
return r;
cnt = libusb_get_device_list(NULL, &devs);
if (cnt < 0)
return (int) cnt;
print_devs(devs);
libusb_free_device_list(devs, 1);
libusb_exit(NULL);
return 0;
}
/** Tests that devices can be listed 1000 times. */
static libusb_testlib_result test_get_device_list(libusb_testlib_ctx * tctx)
{
libusb_context * ctx = NULL;
int r, i;
r = libusb_init(&ctx);
if (r != LIBUSB_SUCCESS) {
libusb_testlib_logf(tctx, "Failed to init libusb: %d", r);
return TEST_STATUS_FAILURE;
}
for (i = 0; i < 1000; ++i) {
libusb_device ** device_list;
ssize_t list_size = libusb_get_device_list(ctx, &device_list);
if (list_size < 0 || device_list == NULL) {
libusb_testlib_logf(tctx,
"Failed to get device list on iteration %d: %d (%p)",
i, -list_size, device_list);
return TEST_STATUS_FAILURE;
}
libusb_free_device_list(device_list, 1);
}
libusb_exit(ctx);
return TEST_STATUS_SUCCESS;
}
ssize_t hwstub_get_device_list(libusb_context *ctx, libusb_device ***list)
{
libusb_device **great_list;
ssize_t great_cnt = libusb_get_device_list(ctx, &great_list);
if(great_cnt < 0)
return great_cnt;
/* allocate a list (size at least one NULL entry at the end) */
libusb_device **mylist = malloc(sizeof(libusb_device *) * (great_cnt + 1));
memset(mylist, 0, sizeof(libusb_device *) * (great_cnt + 1));
/* list hwstub devices */
ssize_t cnt = 0;
for(int i = 0; i < great_cnt; i++)
if(hwstub_probe(great_list[i]) >= 0)
{
libusb_ref_device(great_list[i]);
mylist[cnt++] = great_list[i];
}
/* free old list */
libusb_free_device_list(great_list, 1);
/* return */
*list = mylist;
return cnt;
}
int freenect_num_devices(freenect_context *ctx)
{
libusb_device **devs; //pointer to pointer of device, used to retrieve a list of devices
ssize_t cnt = libusb_get_device_list (ctx->usb.ctx, &devs); //get the list of devices
if (cnt < 0)
return (-1);
int nr = 0, i = 0;
struct libusb_device_descriptor desc;
for (i = 0; i < cnt; ++i)
{
int r = libusb_get_device_descriptor (devs[i], &desc);
if (r < 0)
continue;
if (desc.idVendor == MS_MAGIC_VENDOR && desc.idProduct == MS_MAGIC_CAMERA_PRODUCT)
nr++;
}
libusb_free_device_list (devs, 1); // free the list, unref the devices in it
return (nr);
}
int32_t main(void)
{
libusb_device **devs;
int32_t r;
ssize_t cnt;
r = libusb_init(NULL);
if(r < 0)
{ return r; }
printf("Looking for smartreader compatible devices...\n");
cnt = libusb_get_device_list(NULL, &devs);
if(cnt < 0)
{ return (int32_t) cnt; }
print_devs(devs);
libusb_free_device_list(devs, 1);
libusb_exit(NULL);
return 0;
}
/**
* find in the usb tree if the device is present
*/
bool DomusEngineUSBDevice::isPresent() {
if (device != nullptr || demo) {
return true;
} else {
libusb_device **devices{};
handle = nullptr;
ssize_t devicesNum = libusb_get_device_list((libusb_context *) usbContext, &devices);
for (int index = 0; index < devicesNum; index++) {
libusb_device_descriptor deviceDescriptor;
libusb_get_device_descriptor(devices[index], &deviceDescriptor);
if (deviceDescriptor.bDeviceClass == deviceClass && deviceDescriptor.idVendor == vendorID &&
deviceDescriptor.idProduct == productID) {
device = devices[index];
libusb_ref_device((libusb_device *) device);
int result = libusb_open((libusb_device *) device, (libusb_device_handle **) &handle);
if (result != 0) {
std::cerr << "Unable to open device: " << strUsbError(result) << std::endl;
return false;
}
break;
}
}
libusb_free_device_list(devices, 1);
if (handle != nullptr) {
BOOST_LOG_TRIVIAL(info) << "device found";
int result = libusb_claim_interface((libusb_device_handle *) handle, 0);
if (result != 0) {
BOOST_LOG_TRIVIAL(error) << "Unable to claim interface 0: " << strUsbError(result);
}
} else {
BOOST_LOG_TRIVIAL(error) << "device not found";
}
}
return device != nullptr;
}
std::string getFullPortUSB(std::string id) {
std::string port;
libusb_device **devs; //pointer to pointer of device, used to retrieve a list of devices
libusb_context *ctx = NULL; //a libusb session
int r; //for return values
ssize_t cnt; //holding number of devices in list
r = libusb_init(&ctx); //initialize a library session
if(r < 0) {
std::cout<<"Init Error "<<r<<std::endl; //there was an error
return NULL;
}
libusb_set_debug(ctx, 3); //set verbosity level to 3, as suggested in the documentation
cnt = libusb_get_device_list(ctx, &devs); //get the list of devices
if(cnt < 0)
std::cout<<"Get Device Error"<<std::endl; //there was an error
std::cout<<cnt<<" Devices in list."<<std::endl; //print total number of usb devices
for(ssize_t i = 0; i < cnt; i++)
{
std::string tmpid = get_device_id(devs[i]);
if (tmpid.compare(id)==0)
{
port = get_device_port(devs[i]);
std::cout << " usb device " << tmpid << " found with port=" << port<< std::endl;
}
}
libusb_free_device_list(devs, 1); //free the list, unref the devices in it
libusb_exit(ctx); //close the session
return port;
}
usb_device_info *
enumerate(unsigned short vendor_id, unsigned short product_id)
{
return usb_executor->await([=] {
libusb_device **devs = NULL;
libusb_device *dev = NULL;
struct usb_device_info *root = NULL; /* return object */
struct usb_device_info *cur_dev = NULL;
int i = 0;
libusb_get_device_list(NULL, &devs);
while ((dev = devs[i++]) != NULL) {
struct libusb_device_descriptor desc;
libusb_get_device_descriptor(dev, &desc);
if ((vendor_id == 0 || vendor_id == desc.idVendor) && (product_id == 0 || product_id == desc.idProduct)) {
struct usb_device_info *tmp;
tmp = (struct usb_device_info *) calloc(1, sizeof(struct usb_device_info));
if (cur_dev) {
cur_dev->next = tmp;
} else {
root = tmp;
}
cur_dev = tmp;
cur_dev->next = NULL;
snprintf(cur_dev->path, sizeof(cur_dev->path), "%04x:%04x",
libusb_get_bus_number(dev),
libusb_get_device_address(dev));
cur_dev->vendor_id = desc.idVendor;
cur_dev->product_id = desc.idProduct;
}
}
libusb_free_device_list(devs, 1);
return root;
});
}
/*
* If hotplug isn't supported, this is called periodically to checked for
* USB devices that have been added or removed.
*
* This is run within the main thread, since the libusb thread only runs if at
* least one USB device is used.
*/
bool AsyncPluginImpl::ScanUSBDevices() {
OLA_INFO << "Scanning USB devices....";
std::set<USBDeviceID> current_device_ids;
libusb_device **device_list;
size_t device_count = libusb_get_device_list(m_context, &device_list);
OLA_INFO << "Got " << device_count << " devices";
for (unsigned int i = 0; i < device_count; i++) {
libusb_device *usb_device = device_list[i];
USBDeviceID device_id(libusb_get_bus_number(usb_device),
libusb_get_device_address(usb_device));
current_device_ids.insert(device_id);
if (!STLContains(m_seen_usb_devices, device_id)) {
OLA_INFO << " " << usb_device;
bool claimed = USBDeviceAdded(usb_device);
STLReplace(&m_seen_usb_devices, device_id, claimed ? usb_device : NULL);
}
}
libusb_free_device_list(device_list, 1); // unref devices
USBDeviceIDs::iterator iter = m_seen_usb_devices.begin();
while (iter != m_seen_usb_devices.end()) {
if (!STLContains(current_device_ids, iter->first)) {
if (iter->second) {
USBDeviceRemoved(iter->second);
}
m_seen_usb_devices.erase(iter++);
} else {
iter++;
}
}
return true;
}
/** Tests that 100 concurrent device lists can be open at a time. */
static libusb_testlib_result test_many_device_lists(libusb_testlib_ctx * tctx)
{
#define LIST_COUNT 100
libusb_context * ctx = NULL;
libusb_device ** device_lists[LIST_COUNT];
int r, i;
memset(device_lists, 0, sizeof(device_lists));
r = libusb_init(&ctx);
if (r != LIBUSB_SUCCESS) {
libusb_testlib_logf(tctx, "Failed to init libusb: %d", r);
return TEST_STATUS_FAILURE;
}
/* Create the 100 device lists. */
for (i = 0; i < LIST_COUNT; ++i) {
ssize_t list_size = libusb_get_device_list(ctx, &(device_lists[i]));
if (list_size < 0 || device_lists[i] == NULL) {
libusb_testlib_logf(tctx,
"Failed to get device list on iteration %d: %d (%p)",
i, -list_size, device_lists[i]);
return TEST_STATUS_FAILURE;
}
}
/* Destroy the 100 device lists. */
for (i = 0; i < LIST_COUNT; ++i) {
if (device_lists[i]) {
libusb_free_device_list(device_lists[i], 1);
device_lists[i] = NULL;
}
}
libusb_exit(ctx);
return TEST_STATUS_SUCCESS;
#undef LIST_COUNT
}
int main(void)
{
#ifdef USE_LIBUSB_1_0
libusb_device_handle *usbhandle;
#else
usb_dev_handle *usbhandle;
#endif
#if 0
libusb_device **devs;
int r;
ssize_t cnt;
r = libusb_init(NULL);
if (r < 0)
return r;
cnt = libusb_get_device_list(NULL, &devs);
if (cnt < 0)
return (int) cnt;
print_devs(devs);
libusb_free_device_list(devs, 1);
libusb_exit(NULL);
#endif
if(!usbdevice_open(&usbhandle))
{
testWrite(usbhandle);
usbasp_initialize(usbhandle);
}
return 0;
}
vector<TreehopperBoard>* TreehopperManager::ScanForDevices()
{
ssize_t cnt;
cnt = libusb_get_device_list(NULL, &devs);
if (cnt < 0)
return &BoardList;
libusb_device *dev;
int i = 0;
while ((dev = devs[i++]) != NULL)
{
struct libusb_device_descriptor desc;
int r = libusb_get_device_descriptor(dev, &desc);
if (r < 0) {
return &BoardList;
}
if (desc.idProduct == TreehopperBoard::pid && desc.idVendor == TreehopperBoard::vid)
{
BoardList.push_back(TreehopperBoard(dev));
}
}
return &BoardList;
}
int USBMgr::listDevices( std::vector<PS3EYECam::PS3EYERef>& list )
{
libusb_device *dev;
libusb_device **devs;
libusb_device_handle *devhandle;
int i = 0;
int cnt;
cnt = libusb_get_device_list(instance()->usb_context, &devs);
if (cnt < 0)
debug("Error Device scan\n");
cnt = 0;
while ((dev = devs[i++]) != NULL)
{
struct libusb_device_descriptor desc;
libusb_get_device_descriptor(dev, &desc);
if(desc.idVendor == PS3EYECam::VENDOR_ID && desc.idProduct == PS3EYECam::PRODUCT_ID)
{
int err = libusb_open(dev, &devhandle);
if (err == 0)
{
libusb_close(devhandle);
list.push_back( PS3EYECam::PS3EYERef( new PS3EYECam(dev) ) );
libusb_ref_device(dev);
cnt++;
}
}
}
libusb_free_device_list(devs, 1);
return cnt;
}
static ssize_t
load_devicelist (GPPortPrivateLibrary *pl) {
time_t xtime;
time(&xtime);
if (xtime != pl->devslastchecked) {
if (pl->nrofdevs)
libusb_free_device_list (pl->devs, 1);
free (pl->descs);
pl->nrofdevs = 0;
pl->devs = NULL;
pl->descs = NULL;
}
if (!pl->nrofdevs) {
int i;
pl->nrofdevs = libusb_get_device_list (pl->ctx, &pl->devs);
C_MEM (pl->descs = calloc (pl->nrofdevs, sizeof(pl->descs[0])));
for (i=0;i<pl->nrofdevs;i++)
LOG_ON_LIBUSB_E (libusb_get_device_descriptor(pl->devs[i], &pl->descs[i]));
}
time (&pl->devslastchecked);
return pl->nrofdevs;
}
QVector<CameraInfo> CameraUSB::avaibleCams(const CameraInfo &info)
{
QVector<CameraInfo> avaibleCams;
libusb_context *ctx = NULL;
libusb_device **devs;
ssize_t cnt;
int vendorId = info.getParam("vendorId").toString().toInt(0, 16);
int productId = info.getParam("productId").toString().toInt(0, 16);
// create context
if(libusb_init(&ctx) != LIBUSB_SUCCESS)
return avaibleCams;
// get list usb device
cnt = libusb_get_device_list(ctx, &devs);
for(int i = 0; i < cnt; i++)
{
libusb_device_descriptor desc;
if(libusb_get_device_descriptor(devs[i], &desc)==LIBUSB_SUCCESS)
{
if(desc.idVendor==vendorId && desc.idProduct==productId)
{
QString addr = QString("%1.%2").arg((int)libusb_get_bus_number(devs[i]))
.arg((int)libusb_get_device_address(devs[i]));
avaibleCams.append(CameraInfo("DreamCam USB", "USB", addr));
}
}
}
libusb_free_device_list(devs, 1);
// destroy usb context
libusb_exit(ctx);
return avaibleCams;
}
static int renumerate(void)
{
cyusb_device *dev = NULL;
cyusb_handle *handle = NULL;
int found = 0;
int i;
int r;
numdev = libusb_get_device_list(NULL, &list);
if ( numdev < 0 ) {
printf("Library: Error in enumerating devices...\n");
return -4;
}
nid = 0;
for ( i = 0; i < numdev; ++i ) {
cyusb_device *tdev = list[i];
if ( device_is_of_interest(tdev) ) {
cydev[nid].dev = tdev;
r = libusb_open(tdev, &cydev[nid].handle);
if ( r ) {
printf("Error in opening device\n");
return -5;
}
else handle = cydev[nid].handle;
cydev[nid].vid = cyusb_getvendor(handle);
cydev[nid].pid = cyusb_getproduct(handle);
cydev[nid].is_open = 1;
cydev[nid].busnum = cyusb_get_busnumber(handle);
cydev[nid].devaddr = cyusb_get_devaddr(handle);
++nid;
}
}
return nid;
}
/* Iterate over all matching DFU capable devices within system */
static int iterate_dfu_devices(libusb_context *ctx, struct dfu_if *dif,
int (*action)(struct libusb_device *dev, void *user), void *user)
{
libusb_device **list;
ssize_t num_devs, i;
num_devs = libusb_get_device_list(ctx, &list);
for (i = 0; i < num_devs; ++i) {
int retval;
struct libusb_device_descriptor desc;
struct libusb_device *dev = list[i];
if (dif && (dif->flags & DFU_IFF_DEVNUM) &&
(libusb_get_bus_number(dev) != dif->bus ||
libusb_get_device_address(dev) != dif->devnum))
continue;
if (libusb_get_device_descriptor(dev, &desc))
continue;
if (dif && (dif->flags & DFU_IFF_VENDOR) &&
desc.idVendor != dif->vendor)
continue;
if (dif && (dif->flags & DFU_IFF_PRODUCT) &&
desc.idProduct != dif->product)
continue;
if (!count_dfu_interfaces(dev))
continue;
retval = action(dev, user);
if (retval) {
libusb_free_device_list(list, 0);
return retval;
}
}
libusb_free_device_list(list, 0);
return 0;
}
