static int usbdk_get_device_list(struct libusb_context *ctx, struct discovered_devs **_discdevs)
{
int r = LIBUSB_SUCCESS;
ULONG i;
struct discovered_devs *discdevs = NULL;
ULONG dev_number;
PUSB_DK_DEVICE_INFO devices;
if(!usbdk_helper.GetDevicesList(&devices, &dev_number))
return LIBUSB_ERROR_OTHER;
for (i = 0; i < dev_number; i++) {
unsigned long session_id;
struct libusb_device *dev = NULL;
if (usbdk_get_session_id_for_device(ctx, &devices[i].ID, &session_id))
continue;
dev = usbi_get_device_by_session_id(ctx, session_id);
if (dev == NULL) {
dev = usbi_alloc_device(ctx, session_id);
if (dev == NULL) {
usbi_err(ctx, "failed to allocate a new device structure");
continue;
}
usbdk_device_init(dev, &devices[i]);
if (usbdk_device_priv_init(ctx, dev, &devices[i]) != LIBUSB_SUCCESS) {
libusb_unref_device(dev);
continue;
}
}
discdevs = discovered_devs_append(*_discdevs, dev);
libusb_unref_device(dev);
if (!discdevs) {
usbi_err(ctx, "cannot append new device to list");
r = LIBUSB_ERROR_NO_MEM;
goto func_exit;
}
*_discdevs = discdevs;
}
func_exit:
usbdk_helper.ReleaseDevicesList(devices);
return r;
}
bool USBHost::AddNewDevices(std::set<u64>& new_devices, DeviceChangeHooks& hooks,
const bool always_add_hooks)
{
#ifdef __LIBUSB__
if (SConfig::GetInstance().m_usb_passthrough_devices.empty())
return true;
if (m_libusb_context)
{
libusb_device** list;
const ssize_t count = libusb_get_device_list(m_libusb_context, &list);
if (count < 0)
{
WARN_LOG(IOS_USB, "Failed to get device list: %s",
libusb_error_name(static_cast<int>(count)));
return false;
}
for (ssize_t i = 0; i < count; ++i)
{
libusb_device* device = list[i];
libusb_device_descriptor descriptor;
libusb_get_device_descriptor(device, &descriptor);
if (!SConfig::GetInstance().IsUSBDeviceWhitelisted(
{descriptor.idVendor, descriptor.idProduct}))
{
libusb_unref_device(device);
continue;
}
auto usb_device = std::make_unique<USB::LibusbDevice>(m_ios, device, descriptor);
if (!ShouldAddDevice(*usb_device))
{
libusb_unref_device(device);
continue;
}
const u64 id = usb_device->GetId();
new_devices.insert(id);
if (AddDevice(std::move(usb_device)) || always_add_hooks)
hooks.emplace(GetDeviceById(id), ChangeEvent::Inserted);
else
libusb_unref_device(device);
}
libusb_free_device_list(list, 0);
}
#endif
return true;
}
ConnectionStatus UsbConnection::usb_disconnect() {
libusb_close(handler);
libusb_unref_device (device);
device = NULL;
handler = NULL;
return disconnected;
}
int mcp2200_list_devices(int vendorID, int productID){
libusb_device **devs;
device_list_count = 0;
free_list();
int cnt = libusb_get_device_list(NULL, &devs);
if (cnt < 0) return cnt;
int i;
for(i=0;i<cnt;i++){
struct libusb_device_descriptor desc;
int ok = 0;
int r = libusb_get_device_descriptor(devs[i], &desc);
if (r < 0) {
fprintf(stderr, "failed to get device descriptor");
} else{
if (vendorID == desc.idVendor &&
productID == desc.idProduct &&
device_list_count < MCP2200_MAX_DEVICE_NUM){
ok = 1;
}
}
if (ok){
device_list[device_list_count] = devs[i];
device_list_count++;
}else{
libusb_unref_device(devs[i]);
}
}
libusb_free_device_list(devs, 0);
return device_list_count;
}
// Release hPortalInstance
void DisconnectPortal(void) {
libusb_release_interface(g_hPortalHandle,0);
libusb_unref_device(libusb_get_device(g_hPortalHandle));
libusb_close(g_hPortalHandle);
libusb_exit (g_ctx);
}
USBDevice::~USBDevice()
{
close();
libusb_unref_device(m_data->device);
delete m_data;
}
XN_C_API XnStatus xnUSBIsDevicePresent(XnUInt16 nVendorID, XnUInt16 nProductID, void* pExtraParam, XnBool* pbDevicePresent)
{
XnStatus nRetVal = XN_STATUS_OK;
// make sure library was initialized
XN_VALIDATE_USB_INIT();
// Validate parameters
XN_VALIDATE_OUTPUT_PTR(pbDevicePresent);
*pbDevicePresent = FALSE;
libusb_device* pDevice;
nRetVal = FindDevice(nVendorID, nProductID, pExtraParam, &pDevice);
XN_IS_STATUS_OK(nRetVal);
if (pDevice != NULL)
{
*pbDevicePresent = TRUE;
// unref device
libusb_unref_device(pDevice);
}
return (XN_STATUS_OK);
}
ThreadedUsbReceiver::~ThreadedUsbReceiver() {
{
ola::thread::MutexLocker locker(&m_term_mutex);
m_term = true;
}
Join();
libusb_unref_device(m_usb_device);
}
int
usb_close(usb_handle * h)
{
libusb_close(h->handle);
h->handle = NULL;
libusb_unref_device(h->dev);
free(h);
return (0);
}
static void free_list(){
if (device_list_count > 0){
int i;
for(i=0;i<device_list_count;i++){
libusb_unref_device(device_list[i]);
}
}
device_list_count = 0;
}
static void discovered_devs_free(struct discovered_devs *discdevs)
{
size_t i;
for (i = 0; i < discdevs->len; i++)
libusb_unref_device(discdevs->devices[i]);
free(discdevs);
}
USBDevice::~USBDevice()
{
if (mHandle) {
libusb_close(mHandle);
}
if (mDevice) {
libusb_unref_device(mDevice);
}
}
int
LibusbUsbTransport::Close()
{
libusb_close(h->handle);
h->handle = NULL;
libusb_unref_device(h->dev);
h.reset();
return (0);
}
static void ydev_free(void *self)
{
ydev_instance_t *obj = (ydev_instance_t *)self;
if (obj->handle != NULL) {
libusb_close(obj->handle);
}
if (obj->device != NULL) {
libusb_unref_device(obj->device);
}
}
void
unref_connected_devs(bool remove/*=false*/)
{
for (std::list<usb_device_t>::iterator it=__connected_arms->begin(); it != __connected_arms->end(); ++it) {
if( !(*it).connected ) {
libusb_unref_device((*it).dev);
if( remove )
it = __connected_arms->erase(it);
}
}
}
void QUsb::qhyccd_free_device_list(qhyccd_device **list)
{
qhyccd_device **cur = list;
while (*cur != NULL) {
libusb_unref_device(*cur);
cur++;
}
if (list) {
free(list);
}
}
/**
* @brief Opens the camera specified by \a dev.
*
* @todo This is one of the places where we expose the fact that PTP uses libusb as a backend.
* It would be nice if we could let the caller completely ignore the underlying protocol.
* @param[in] dev The \c libusb_device which specifies which device to connect to.
* @exception PTP::ERR_ALREADY_OPEN if this \c CameraBase already has an open device.
* @exception PTP::ERR_CANNOT_CONNECT if we cannot connect to the camera specified.
* @return true if we successfully connect, false otherwise.
*/
bool CameraBase::open(libusb_device * dev) {
if(this->handle != NULL) { // Handle will be non-null if the device is already open
throw PTP::ERR_ALREADY_OPEN;
return false;
}
int err = libusb_open(dev, &(this->handle)); // Open the device, placing the handle in this->handle
if(err) {
throw PTP::ERR_CANNOT_CONNECT;
return false;
}
libusb_unref_device(dev); // We needed this device refed before we opened it, so we added an extra ref. open adds another ref, so remove one ref
struct libusb_config_descriptor * desc;
int r = libusb_get_active_config_descriptor(dev, &desc);
if (r < 0) {
this->usb_error = r;
return false;
}
int j, k;
for(j = 0; j < desc->bNumInterfaces; j++) {
struct libusb_interface interface = desc->interface[j];
for(k = 0; k < interface.num_altsetting; k++) {
struct libusb_interface_descriptor altsetting = interface.altsetting[k];
if(altsetting.bInterfaceClass == 6) { // If this has the PTP interface
this->intf = &altsetting;
libusb_claim_interface(this->handle, this->intf->bInterfaceNumber); // Claim the interface -- Needs to be done before I/O operations
break;
}
}
if(this->intf) break;
}
const struct libusb_endpoint_descriptor * endpoint;
for(j = 0; j < this->intf->bNumEndpoints; j++) {
endpoint = &(this->intf->endpoint[j]);
if((endpoint->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK == LIBUSB_ENDPOINT_IN) &&
(endpoint->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) == LIBUSB_TRANSFER_TYPE_BULK) {
this->ep_in = endpoint->bEndpointAddress;
} else if((endpoint->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_OUT) {
this->ep_out = endpoint->bEndpointAddress;
}
}
libusb_free_config_descriptor(desc);
// If we haven't detected an error by now, assume that this worked.
return true;
}
void libusb_free_device_list(libusb_device **list, int unref_devices) {
libusb_device *dev;
int i = 0;
if (unref_devices) {
for (dev = list[0]; dev != NULL; dev = list[++i]) {
libusb_unref_device(dev);
}
}
free(list);
}
/*
* Free the list of devices obtained from the function 'getSOPASDeviceList'.
*/
void SickTimCommonUsb::freeSOPASDeviceList(libusb_device **list)
{
if (!list)
return;
int i = 0;
struct libusb_device *dev;
while ((dev = list[i++]) != NULL)
libusb_unref_device(dev);
free(list);
}
int luausb_device_gc(lua_State* L)
{
libusb_device** dev;
dev = (libusb_device**)lua_touserdata(L, 1);
if (*dev)
{
libusb_unref_device(*dev);
*dev = 0;
}
return 0;
}
void
libusb_free_device_list(libusb_device **list, int unref_devices)
{
int i;
if (list == NULL)
return; /* be NULL safe */
if (unref_devices) {
for (i = 0; list[i] != NULL; i++)
libusb_unref_device(list[i]);
}
free(list);
}
/** Internal creator.
* This gets the actual device-handle, and establishes the USB connection.
*/
void
JacoArm::Create(usb_device_t &dev)
{
// Get device handle
if( libusb_open(dev.dev, &__devh) )
throw KinDrvException("Failed getting usb-device-handle for JacoArm!" );
// Claim usb interface
if( libusb_claim_interface(__devh, 0) < 0 )
throw KinDrvException("Could not claim usb interface 0!");
dev.connected = true;
libusb_unref_device(dev.dev);
}
//**********************************************************
//!
//! Release all devices referenced by bdm_usb_findDevices
//!
//! @return\n
//! ICP_RC_OK - success \n
//!
ICP_ErrorType bdm_usb_releaseDevices(void) {
// print("bdm_usb_releaseDevices() - \n");
// Unreference all devices
for(unsigned index=0; index<deviceCount; index++) {
print("bdm_usb_releaseDevices() - unreferencing #%d\n", index);
if (bdmDevices[index] != NULL)
libusb_unref_device(bdmDevices[index]);
bdmDevices[index] = NULL;
}
deviceCount = 0;
return ICP_RC_OK;
}
static void do_close(struct libusb_context *ctx,
struct libusb_device_handle *dev_handle)
{
struct usbi_transfer *itransfer;
struct usbi_transfer *tmp;
libusb_lock_events(ctx);
usbi_mutex_lock(&ctx->flying_transfers_lock);
list_for_each_entry_safe(itransfer, tmp, &ctx->flying_transfers, list, struct usbi_transfer) {
struct libusb_transfer *transfer =
USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
if (transfer->dev_handle != dev_handle)
continue;
if (!(itransfer->flags & USBI_TRANSFER_DEVICE_DISAPPEARED)) {
usbi_err(ctx, "Device handle closed while transfer was still being processed, but the device is still connected as far as we know");
if (itransfer->flags & USBI_TRANSFER_CANCELLING)
usbi_warn(ctx, "A cancellation for an in-flight transfer hasn't completed but closing the device handle");
else
usbi_err(ctx, "A cancellation hasn't even been scheduled on the transfer for which the device is closing");
}
usbi_mutex_lock(&itransfer->lock);
list_del(&itransfer->list);
transfer->dev_handle = NULL;
usbi_mutex_unlock(&itransfer->lock);
usbi_dbg("Removed transfer %p from the in-flight list because device handle %p closed",
transfer, dev_handle);
}
usbi_mutex_unlock(&ctx->flying_transfers_lock);
libusb_unlock_events(ctx);
usbi_mutex_lock(&ctx->open_devs_lock);
list_del(&dev_handle->list);
usbi_mutex_unlock(&ctx->open_devs_lock);
usbi_backend->close(dev_handle);
libusb_unref_device(dev_handle->dev);
usbi_mutex_destroy(&dev_handle->lock);
free(dev_handle);
}
UsbDevice *
usbFindDevice (UsbDeviceChooser chooser, void *data) {
int result;
UsbDeviceExtension *devx;
if (!usbContext) {
if ((result = libusb_init(&usbContext)) != LIBUSB_SUCCESS) {
usbSetErrno(result, "libusb_init");
return NULL;
}
}
if (!usbDeviceList) {
ssize_t count;
if ((count = libusb_get_device_list(usbContext, &usbDeviceList)) < 0) {
usbSetErrno(count, "libusb_get_device_list");
return NULL;
}
usbDeviceCount = count;
}
if ((devx = malloc(sizeof(*devx)))) {
libusb_device **libusbDevice = usbDeviceList;
int deviceCount = usbDeviceCount;
while (deviceCount) {
deviceCount -= 1;
devx->device = *libusbDevice++;
libusb_ref_device(devx->device);
devx->handle = NULL;
{
UsbDevice *device = usbTestDevice(devx, chooser, data);
if (device) return device;
}
libusb_unref_device(devx->device);
}
free(devx);
} else {
logMallocError();
}
return NULL;
}
int libusb_submit_transfer(struct libusb_transfer *transfer) {
usbi_transfer *itransfer = (usbi_transfer *)transfer;
libusb_device_handle *dev_handle = transfer->dev_handle;
libusb_context *ctx = dev_handle->dev->ctx;
usbfs_urb *urb = &itransfer->urb;
int rc;
if (transfer->type != LIBUSB_TRANSFER_TYPE_BULK ||
transfer->timeout != 0 || transfer->callback == NULL) {
return LIBUSB_ERROR_INVALID_PARAM;
}
if (itransfer->submitted) {
return LIBUSB_ERROR_BUSY;
}
libusb_ref_device(dev_handle->dev);
itransfer->submitted = true;
urb->status = INT32_MIN;
urb->endpoint = transfer->endpoint;
urb->buffer = transfer->buffer;
urb->buffer_length = transfer->length;
rc = ioctl(dev_handle->pollfd.fd, IOCTL_USBFS_SUBMITURB, urb);
if (rc < 0) {
if (errno == ENODEV) {
rc = LIBUSB_ERROR_NO_DEVICE;
} else {
rc = LIBUSB_ERROR_IO;
}
itransfer->submitted = false;
libusb_unref_device(dev_handle->dev);
usbi_log_error(ctx, "Could not submit %s transfer %p (length: %d): %s (%d)",
(LIBUSB_ENDPOINT_IN & transfer->endpoint) != 0 ? "read" : "write",
transfer, transfer->length, get_errno_name(errno), errno);
return rc;
}
node_insert_before(&dev_handle->itransfer_sentinel, &itransfer->node);
return LIBUSB_SUCCESS;
}
void disconnect_devices(void)
{
struct dfu_if *pdfu;
struct dfu_if *prev = NULL;
for (pdfu = dfu_root; pdfu != NULL; pdfu = pdfu->next) {
free(prev);
libusb_unref_device(pdfu->dev);
free(pdfu->alt_name);
free(pdfu->serial_name);
prev = pdfu;
}
free(prev);
dfu_root = NULL;
}
static void removeFreespaceDevice(struct FreespaceDevice* device) {
int i;
for (i = 0; i < FREESPACE_MAXIMUM_DEVICE_COUNT; i++) {
if (devices[i] != NULL && devices[i]->id_ == device->id_) {
if (nextFreeIndex == -1) {
nextFreeIndex = i;
}
libusb_unref_device(device->dev_);
free(device);
devices[i] = NULL;
numDevices--;
return;
}
}
}
void API_EXPORTED libusb_free_device_list(libusb_device **list,
int unref_devices)
{
if (!list)
return;
if (unref_devices) {
int i = 0;
struct libusb_device *dev;
while ((dev = list[i++]) != NULL)
libusb_unref_device(dev);
}
free(list);
}
void ft232r_scan_free()
{
if (!ft232r_devinfo_list)
return;
struct ft232r_device_info *info;
for (struct ft232r_device_info **infop = ft232r_devinfo_list; (info = *infop); ++infop) {
libusb_unref_device(info->libusb_dev);
free(info->product);
free(info->serial);
free(info);
}
free(ft232r_devinfo_list);
ft232r_devinfo_list = NULL;
}
