// SPDX-License-Identifier: LGPL-2.1-or-later

/*

* libiio - Library for interfacing industrial I/O (IIO) devices

*

* Copyright (C) 2015 - 2020 Analog Devices, Inc.

* Author: Paul Cercueil <paul.cercueil@analog.com>

*/

#include "iio-config.h"

#include <iio/iio-backend.h>

#include <iio/iio-debug.h>

#include <iio/iio-lock.h>

#include <iio/iiod-client.h>

#include <ctype.h>

#include <errno.h>

#include <libusb.h>

#include <stdbool.h>

#include <string.h>

/* Endpoint for non-streaming operations */

#define EP_OPS 1

#define IIO_INTERFACE_NAME "IIO"

struct iio_usb_ep_couple {

};

struct iiod_client_pdata {

};

struct iio_context_pdata {

};

struct iio_buffer_pdata {

};

static const unsigned int libusb_to_errno_codes[] = {

[- LIBUSB_ERROR_INVALID_PARAM] = EINVAL,

[- LIBUSB_ERROR_ACCESS] = EACCES,

[- LIBUSB_ERROR_NO_DEVICE] = ENODEV,

[- LIBUSB_ERROR_NOT_FOUND] = ENXIO,

[- LIBUSB_ERROR_BUSY] = EBUSY,

[- LIBUSB_ERROR_TIMEOUT] = ETIMEDOUT,

[- LIBUSB_ERROR_OVERFLOW] = EIO,

[- LIBUSB_ERROR_PIPE] = EPIPE,

[- LIBUSB_ERROR_INTERRUPTED] = EINTR,

[- LIBUSB_ERROR_NO_MEM] = ENOMEM,

[- LIBUSB_ERROR_NOT_SUPPORTED] = ENOSYS,

};

static unsigned int libusb_to_errno(int error)

{

switch ((enum libusb_error) error) {

case LIBUSB_ERROR_INVALID_PARAM:

case LIBUSB_ERROR_ACCESS:

case LIBUSB_ERROR_NO_DEVICE:

case LIBUSB_ERROR_NOT_FOUND:

case LIBUSB_ERROR_BUSY:

case LIBUSB_ERROR_TIMEOUT:

case LIBUSB_ERROR_PIPE:

case LIBUSB_ERROR_INTERRUPTED:

case LIBUSB_ERROR_NO_MEM:

case LIBUSB_ERROR_NOT_SUPPORTED:

return libusb_to_errno_codes[- (int) error];

case LIBUSB_ERROR_IO:

case LIBUSB_ERROR_OTHER:

case LIBUSB_ERROR_OVERFLOW:

default:

return EIO;

}

}

/* Forward declarations */

static struct iio_context *

usb_create_context_from_args(const struct iio_context_params *params,

const char *args);

static int usb_context_scan(const struct iio_context_params *params,

struct iio_scan *scan, const char *args);

static ssize_t write_data_sync(struct iiod_client_pdata *ep, const char *data,

size_t len, unsigned int timeout_ms);

static ssize_t read_data_sync(struct iiod_client_pdata *ep, char *buf,

size_t len, unsigned int timeout_ms);

static void usb_cancel(struct iiod_client_pdata *io_ctx);

static int usb_io_context_init(struct iiod_client_pdata *io_ctx)

{

io_ctx->lock = iio_mutex_create();

return iio_err(io_ctx->lock);

}

static void usb_io_context_exit(struct iiod_client_pdata *io_ctx)

{

if (io_ctx->lock) {

iio_mutex_destroy(io_ctx->lock);

io_ctx->lock = NULL;

}

}

#define USB_PIPE_CTRL_TIMEOUT 1000 /* These should not take long */

#define IIO_USD_CMD_RESET_PIPES 0

#define IIO_USD_CMD_OPEN_PIPE 1

#define IIO_USD_CMD_CLOSE_PIPE 2

static int usb_reset_pipes(struct iio_context_pdata *pdata)

{

int ret;

/*

int libusb_control_transfer(libusb_device_handle *devh,

uint8_t bmRequestType,

uint8_t bRequest,

uint16_t wValue,

uint16_t wIndex,

unsigned char *data,

uint16_t wLength,

unsigned int timeout)

*/

ret = libusb_control_transfer(pdata->hdl,

LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_INTERFACE,

IIO_USD_CMD_RESET_PIPES,

0,

pdata->intrfc,

NULL,

0,

USB_PIPE_CTRL_TIMEOUT);

if (ret < 0)

return -(int) libusb_to_errno(ret);

return 0;

}

static int usb_open_pipe(struct iio_context_pdata *pdata, uint16_t pipe_id)

{

int ret;

/*

libusb_device_handle *devh,

uint8_t bmRequestType,

uint8_t bRequest,

uint16_t wValue,

uint16_t wIndex,

unsigned char *data,

uint16_t wLength,

unsigned int timeout)

*/

ret = libusb_control_transfer(

pdata->hdl,

LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_INTERFACE,

IIO_USD_CMD_OPEN_PIPE,

pipe_id,

pdata->intrfc,

NULL,

0,

USB_PIPE_CTRL_TIMEOUT);

if (ret < 0)

return -(int) libusb_to_errno(ret);

return 0;

}

static int usb_close_pipe(struct iio_context_pdata *pdata, uint16_t pipe_id)

{

int ret;

ret = libusb_control_transfer(pdata->hdl, LIBUSB_REQUEST_TYPE_VENDOR |

LIBUSB_RECIPIENT_INTERFACE, IIO_USD_CMD_CLOSE_PIPE,

pipe_id, pdata->intrfc, NULL, 0, USB_PIPE_CTRL_TIMEOUT);

if (ret < 0)

return -(int) libusb_to_errno(ret);

return 0;

}

static int usb_reserve_ep_unlocked(const struct iio_device *dev,

struct iiod_client_pdata *io_ctx)

{

const struct iio_context *ctx = iio_device_get_context(dev);

struct iio_context_pdata *pdata = iio_context_get_pdata(ctx);

unsigned int i;

for (i = 0; i < pdata->nb_ep_couples; i++) {

struct iio_usb_ep_couple *ep = &pdata->io_endpoints[i];

if (!ep->in_use) {

ep->in_use = true;

ep->dev = dev;

io_ctx->ep = ep;

return 0;

}

}

return -EBUSY;

}

static void usb_free_ep_unlocked(const struct iio_device *dev)

{

const struct iio_context *ctx = iio_device_get_context(dev);

struct iio_context_pdata *pdata = iio_context_get_pdata(ctx);

unsigned int i;

for (i = 0; i < pdata->nb_ep_couples; i++) {

struct iio_usb_ep_couple *ep = &pdata->io_endpoints[i];

if (ep->dev == dev) {

ep->in_use = false;

ep->dev = NULL;

return;

}

}

}

static const struct iiod_client_ops usb_iiod_client_ops = {

.write = write_data_sync,

.read = read_data_sync,

.read_line = read_data_sync,

.cancel = usb_cancel,

};

static ssize_t usb_read_dev_attr(const struct iio_device *dev,

unsigned int buf_id, const char *attr,

char *dst, size_t len, enum iio_attr_type type)

{

const struct iio_context *ctx = iio_device_get_context(dev);

struct iio_context_pdata *pdata = iio_context_get_pdata(ctx);

struct iiod_client *client = pdata->io_ctx.iiod_client;

return iiod_client_read_attr(client, dev, NULL, attr,

dst, len, type, buf_id);

}

static ssize_t usb_write_dev_attr(const struct iio_device *dev,

unsigned int buf_id, const char *attr,

const char *src, size_t len,

enum iio_attr_type type)

{

const struct iio_context *ctx = iio_device_get_context(dev);

struct iio_context_pdata *pdata = iio_context_get_pdata(ctx);

struct iiod_client *client = pdata->io_ctx.iiod_client;

return iiod_client_write_attr(client, dev, NULL, attr, src,

len, type, buf_id);

}

static ssize_t usb_read_chn_attr(const struct iio_channel *chn,

const char *attr, char *dst, size_t len)

{

const struct iio_device *dev = iio_channel_get_device(chn);

const struct iio_context *ctx = iio_device_get_context(dev);

struct iio_context_pdata *pdata = iio_context_get_pdata(ctx);

struct iiod_client *client = pdata->io_ctx.iiod_client;

return iiod_client_read_attr(client, dev, chn, attr,

dst, len, false, 0);

}

static ssize_t usb_write_chn_attr(const struct iio_channel *chn,

const char *attr, const char *src, size_t len)

{

const struct iio_device *dev = iio_channel_get_device(chn);

const struct iio_context *ctx = iio_device_get_context(dev);

struct iio_context_pdata *pdata = iio_context_get_pdata(ctx);

struct iiod_client *client = pdata->io_ctx.iiod_client;

return iiod_client_write_attr(client, dev, chn, attr, src, len, false, 0);

}

static int usb_set_timeout(struct iio_context *ctx, unsigned int timeout)

{

struct iio_context_pdata *pdata = iio_context_get_pdata(ctx);

return iiod_client_set_timeout(pdata->io_ctx.iiod_client, timeout);

}

static int usb_get_trigger(const struct iio_device *dev,

const struct iio_device **trigger)

{

const struct iio_context *ctx = iio_device_get_context(dev);

struct iio_context_pdata *pdata = iio_context_get_pdata(ctx);

struct iiod_client *client = pdata->io_ctx.iiod_client;

return iiod_client_get_trigger(client, dev, trigger);

}

static int usb_set_trigger(const struct iio_device *dev,

const struct iio_device *trigger)

{

const struct iio_context *ctx = iio_device_get_context(dev);

struct iio_context_pdata *pdata = iio_context_get_pdata(ctx);

struct iiod_client *client = pdata->io_ctx.iiod_client;

return iiod_client_set_trigger(client, dev, trigger);

}

static void usb_shutdown(struct iio_context *ctx)

{

struct iio_context_pdata *pdata = iio_context_get_pdata(ctx);

usb_io_context_exit(&pdata->io_ctx);

/* TODO: free buffers? */

iio_mutex_destroy(pdata->ep_lock);

iiod_client_destroy(pdata->io_ctx.iiod_client);

free(pdata->io_endpoints);

usb_reset_pipes(pdata); /* Close everything */

libusb_close(pdata->hdl);

libusb_exit(pdata->ctx);

}

static int iio_usb_match_interface(const struct libusb_config_descriptor *desc,

struct libusb_device_handle *hdl, unsigned int intrfc)

{

const struct libusb_interface *iface;

unsigned int i;

if (intrfc >= desc->bNumInterfaces)

return -EINVAL;

iface = &desc->interface[intrfc];

for (i = 0; i < (unsigned int) iface->num_altsetting; i++) {

const struct libusb_interface_descriptor *idesc =

&iface->altsetting[i];

char name[64];

int ret;

if (idesc->iInterface == 0)

continue;

ret = libusb_get_string_descriptor_ascii(hdl, idesc->iInterface,

(unsigned char *) name, sizeof(name));

if (ret < 0)

return -(int) libusb_to_errno(ret);

if (!strcmp(name, IIO_INTERFACE_NAME))

return (int) i;

}

return -EPERM;

}

static int iio_usb_match_device(struct libusb_device *dev,

struct libusb_device_handle *hdl,

unsigned int *intrfc)

{

struct libusb_config_descriptor *desc;

unsigned int i;

int ret;

ret = libusb_get_active_config_descriptor(dev, &desc);

if (ret)

return -(int) libusb_to_errno(ret);

for (i = 0, ret = -EPERM; ret == -EPERM &&

i < desc->bNumInterfaces; i++)

ret = iio_usb_match_interface(desc, hdl, i);

libusb_free_config_descriptor(desc);

if (ret < 0)

return ret;

prm_dbg(NULL, "Found IIO interface on device %u:%u using interface %u\n",

libusb_get_bus_number(dev),

libusb_get_device_address(dev), i - 1);

*intrfc = i - 1;

return ret;

}

static void usb_cancel(struct iiod_client_pdata *io_ctx)

{

iio_mutex_lock(io_ctx->lock);

if (io_ctx->transfer && !io_ctx->cancelled)

libusb_cancel_transfer(io_ctx->transfer);

io_ctx->cancelled = true;

iio_mutex_unlock(io_ctx->lock);

}

static void usb_cancel_buffer(struct iio_buffer_pdata *pdata)

{

usb_cancel(&pdata->io_ctx);

}

static struct iio_buffer_pdata *

usb_create_buffer(const struct iio_device *dev, unsigned int idx,

struct iio_channels_mask *mask)

{

const struct iio_context *ctx = iio_device_get_context(dev);

struct iio_context_pdata *ctx_pdata = iio_context_get_pdata(ctx);

struct iio_buffer_pdata *buf;

int ret;

buf = zalloc(sizeof(*buf));

if (!buf)

return iio_ptr(-ENOMEM);

iio_mutex_lock(ctx_pdata->ep_lock);

buf->dev = dev;

buf->io_ctx.cancelled = false;

ret = usb_reserve_ep_unlocked(dev, &buf->io_ctx);

if (ret)

goto err_unlock;

ret = usb_open_pipe(ctx_pdata, buf->io_ctx.ep->pipe_id);

if (ret) {

dev_perror(dev, ret, "Failed to open pipe");

goto err_free_ep;

}

buf->pdata = iiod_client_create_buffer(buf->io_ctx.iiod_client,

dev, idx, mask);

ret = iio_err(buf->pdata);

if (ret) {

dev_perror(dev, ret, "Unable to create IIOD client");

goto err_close_pipe;

}

iio_mutex_unlock(ctx_pdata->ep_lock);

return buf;

err_close_pipe:

usb_close_pipe(ctx_pdata, buf->io_ctx.ep->pipe_id);

err_free_ep:

usb_free_ep_unlocked(dev);

err_unlock:

iio_mutex_unlock(ctx_pdata->ep_lock);

free(buf);

return iio_ptr(ret);

}

static void usb_free_buffer(struct iio_buffer_pdata *buf)

{

const struct iio_context *ctx = iio_device_get_context(buf->dev);

struct iio_context_pdata *ctx_pdata = iio_context_get_pdata(ctx);

iiod_client_free_buffer(buf->pdata);

iio_mutex_lock(ctx_pdata->ep_lock);

usb_close_pipe(ctx_pdata, buf->io_ctx.ep->pipe_id);

usb_free_ep_unlocked(buf->dev);

iio_mutex_unlock(ctx_pdata->ep_lock);

free(buf);

}

static int usb_enable_buffer(struct iio_buffer_pdata *pdata,

size_t nb_samples, bool enable)

{

return iiod_client_enable_buffer(pdata->pdata, nb_samples, enable);

}

static struct iio_block_pdata *

usb_create_block(struct iio_buffer_pdata *pdata, size_t size, void **data)

{

return iiod_client_create_block(pdata->pdata, size, data);

}

static const struct iio_backend_ops usb_ops = {

.scan = usb_context_scan,

.create = usb_create_context_from_args,

.read_device_attr = usb_read_dev_attr,

.read_channel_attr = usb_read_chn_attr,

.write_device_attr = usb_write_dev_attr,

.write_channel_attr = usb_write_chn_attr,

.get_trigger = usb_get_trigger,

.set_trigger = usb_set_trigger,

.set_timeout = usb_set_timeout,

.shutdown = usb_shutdown,

.create_buffer = usb_create_buffer,

.free_buffer = usb_free_buffer,

.enable_buffer = usb_enable_buffer,

.cancel_buffer = usb_cancel_buffer,

.create_block = usb_create_block,

.free_block = iiod_client_free_block,

.enqueue_block = iiod_client_enqueue_block,

.dequeue_block = iiod_client_dequeue_block,

};

__api_export_if(WITH_USB_BACKEND_DYNAMIC)

const struct iio_backend iio_usb_backend = {

.api_version = IIO_BACKEND_API_V1,

.name = "usb",

.uri_prefix = "usb:",

.ops = &usb_ops,

.default_timeout_ms = 5000,

};

static void LIBUSB_CALL sync_transfer_cb(struct libusb_transfer *transfer)

{

int *completed = transfer->user_data;

*completed = 1;

}

static int usb_sync_transfer(struct iio_context_pdata *pdata,

struct iiod_client_pdata *io_ctx,

unsigned int ep_type, char *data, size_t len,

int *transferred, unsigned int timeout_ms)

{

unsigned char ep;

struct libusb_transfer *transfer = NULL;

int completed = 0;

int ret;

/*

* If the size of the data to transfer is too big, the

* IOCTL_USBFS_SUBMITURB ioctl (called by libusb) might fail with

* errno set to ENOMEM, as the kernel might use contiguous allocation

* for the URB if the driver doesn't support scatter-gather.

* To prevent that, we support URBs of 1 MiB maximum. The iiod-client

* code will handle this properly and ask for a new transfer.

*/

if (len > 1 * 1024 * 1024)

len = 1 * 1024 * 1024;

if (ep_type == LIBUSB_ENDPOINT_IN)

ep = io_ctx->ep->addr_in;

else

ep = io_ctx->ep->addr_out;

/*

* For cancellation support the check whether the buffer has already been

* cancelled and the allocation as well as the assignment of the new

* transfer needs to happen in one atomic step. Otherwise it is possible

* that the cancellation is missed and transfer is not aborted.

*/

iio_mutex_lock(io_ctx->lock);

if (io_ctx->cancelled) {

ret = -EBADF;

goto unlock;

}

transfer = libusb_alloc_transfer(0);

if (!transfer) {

ret = -ENOMEM;

goto unlock;

}

transfer->user_data = &completed;

libusb_fill_bulk_transfer(transfer, pdata->hdl, ep,

(unsigned char *) data, (int) len, sync_transfer_cb,

&completed, timeout_ms);

transfer->type = LIBUSB_TRANSFER_TYPE_BULK;

ret = libusb_submit_transfer(transfer);

if (ret) {

ret = -(int) libusb_to_errno(ret);

libusb_free_transfer(transfer);

goto unlock;

}

io_ctx->transfer = transfer;

unlock:

iio_mutex_unlock(io_ctx->lock);

if (ret)

return ret;

while (!completed) {

ret = libusb_handle_events_completed(pdata->ctx, &completed);

if (ret < 0) {

if (ret == LIBUSB_ERROR_INTERRUPTED)

continue;

libusb_cancel_transfer(transfer);

continue;

}

}

switch (transfer->status) {

case LIBUSB_TRANSFER_COMPLETED:

*transferred = transfer->actual_length;

ret = 0;

break;

case LIBUSB_TRANSFER_TIMED_OUT:

ret = -ETIMEDOUT;

break;

case LIBUSB_TRANSFER_STALL:

ret = -EPIPE;

break;

case LIBUSB_TRANSFER_NO_DEVICE:

ret = -ENODEV;

break;

case LIBUSB_TRANSFER_CANCELLED:

ret = -EBADF;

break;

default:

ret = -EIO;

break;

}

/* Same as above. This needs to be atomic in regards to usb_cancel(). */

iio_mutex_lock(io_ctx->lock);

io_ctx->transfer = NULL;

iio_mutex_unlock(io_ctx->lock);

libusb_free_transfer(transfer);

return ret;

}

static ssize_t write_data_sync(struct iiod_client_pdata *ep,

const char *data, size_t len,

unsigned int timeout_ms)

{

int transferred, ret;

ret = usb_sync_transfer(ep->ctx_pdata, ep, LIBUSB_ENDPOINT_OUT,

(char *) data, len, &transferred, timeout_ms);

if (ret)

return ret;

else

return (ssize_t) transferred;

}

static ssize_t read_data_sync(struct iiod_client_pdata *ep,

char *buf, size_t len, unsigned int timeout_ms)

{

int transferred, ret;

ret = usb_sync_transfer(ep->ctx_pdata, ep, LIBUSB_ENDPOINT_IN,

buf, len, &transferred, timeout_ms);

if (ret)

return ret;

else

return transferred;

}

static int usb_verify_eps(const struct libusb_interface_descriptor *iface)

{

unsigned int i, eps = iface->bNumEndpoints;

/* Check that we have an even number of endpoints, and that input/output

* endpoints are interleaved */

if (eps < 2 || eps % 2)

return -EINVAL;

for (i = 0; i < eps; i += 2) {

if (!(iface->endpoint[i + 0].bEndpointAddress

& LIBUSB_ENDPOINT_IN))

return -EINVAL;

if (iface->endpoint[i + 1].bEndpointAddress

& LIBUSB_ENDPOINT_IN)

return -EINVAL;

}

return 0;

}

static int usb_get_string(libusb_device_handle *hdl, uint8_t idx,

char *buffer, size_t length)

{

int ret;

ret = libusb_get_string_descriptor_ascii(hdl, idx,

(unsigned char *) buffer,

(int) length);

if (ret < 0) {

buffer[0] = '\0';

return -(int) libusb_to_errno(ret);

}

return 0;

}

static int usb_get_description(struct libusb_device_handle *hdl,

const struct libusb_device_descriptor *desc,

char *buffer, size_t length)

{

char manufacturer[64], product[64], serial[64];

ssize_t ret;

manufacturer[0] = '\0';

if (desc->iManufacturer > 0) {

usb_get_string(hdl, desc->iManufacturer,

manufacturer, sizeof(manufacturer));

}

product[0] = '\0';

if (desc->iProduct > 0) {

usb_get_string(hdl, desc->iProduct,

product, sizeof(product));

}

serial[0] = '\0';

if (desc->iSerialNumber > 0) {

usb_get_string(hdl, desc->iSerialNumber,

serial, sizeof(serial));

}

ret = iio_snprintf(buffer, length,

"%04x:%04x (%s %s), serial=%s", desc->idVendor,

desc->idProduct, manufacturer, product, serial);

if (ret < 0)

return (int) ret;

return 0;

}

static struct iio_context *

usb_create_context_with_attrs(libusb_device *usb_dev,

struct iio_context_pdata *pdata)

{

struct libusb_version const *libusb_version = libusb_get_version();

struct libusb_device_descriptor dev_desc;

char vendor[64], product[64], serial[64],

uri[sizeof("usb:127.255.255")],

idVendor[5], idProduct[5], version[4],

lib_version[16], description[256];

const char *attr_names[] = {

"uri",

"usb,vendor",

"usb,product",

"usb,serial",

"usb,idVendor",

"usb,idProduct",

"usb,release",

"usb,libusb",

};

char *attr_values[ARRAY_SIZE(attr_names)] = {

uri,

vendor,

product,

serial,

idVendor,

idProduct,

version,

lib_version,

};

struct iiod_client *client = pdata->io_ctx.iiod_client;

libusb_get_device_descriptor(usb_dev, &dev_desc);

usb_get_description(pdata->hdl, &dev_desc,

description, sizeof(description));

iio_snprintf(uri, sizeof(uri), "usb:%d.%d.%u",

libusb_get_bus_number(usb_dev),

libusb_get_device_address(usb_dev),

(uint8_t)pdata->intrfc);

usb_get_string(pdata->hdl, dev_desc.iManufacturer,

vendor, sizeof(vendor));

usb_get_string(pdata->hdl, dev_desc.iProduct,

product, sizeof(product));

usb_get_string(pdata->hdl, dev_desc.iSerialNumber,

serial, sizeof(serial));

iio_snprintf(idVendor, sizeof(idVendor), "%04hx", dev_desc.idVendor);

iio_snprintf(idProduct, sizeof(idProduct), "%04hx", dev_desc.idProduct);

iio_snprintf(version, sizeof(version), "%1hhx.%1hhx",

(unsigned char)((dev_desc.bcdUSB >> 8) & 0xf),

(unsigned char)((dev_desc.bcdUSB >> 4) & 0xf));

iio_snprintf(lib_version, sizeof(lib_version), "%i.%i.%i.%i%s",

libusb_version->major, libusb_version->minor,

libusb_version->micro, libusb_version->nano,

libusb_version->rc);

return iiod_client_create_context(client,

&iio_usb_backend, description,

attr_names,

(const char **) attr_values,

ARRAY_SIZE(attr_names));

}

static struct iio_context * usb_create_context(const struct iio_context_params *params,

unsigned int bus,

uint16_t address, uint16_t intrfc)

{

libusb_context *usb_ctx;

libusb_device_handle *hdl = NULL;

const struct libusb_interface_descriptor *iface;

libusb_device *usb_dev;

struct libusb_config_descriptor *conf_desc;

libusb_device **device_list;

struct iio_context *ctx;

struct iio_context_pdata *pdata;

uint16_t i;

int ret;

pdata = zalloc(sizeof(*pdata));

if (!pdata) {

prm_err(params, "Unable to allocate pdata\n");

ret = -ENOMEM;

goto err_set_errno;

}

pdata->ep_lock = iio_mutex_create();

ret = iio_err(pdata->ep_lock);

if (ret) {

prm_err(params, "Unable to create mutex\n");

goto err_free_pdata;

}

ret = libusb_init(&usb_ctx);

if (ret) {

ret = -(int) libusb_to_errno(ret);

prm_perror(params, ret, "Unable to init libusb");

goto err_destroy_ep_mutex;

}

ret = (int) libusb_get_device_list(usb_ctx, &device_list);

if (ret < 0) {

ret = -(int) libusb_to_errno(ret);

prm_perror(params, ret, "Unable to get usb device list");

goto err_libusb_exit;

}

usb_dev = NULL;

for (i = 0; device_list[i]; i++) {

libusb_device *dev = device_list[i];

if (bus == libusb_get_bus_number(dev) &&

address == libusb_get_device_address(dev)) {

usb_dev = dev;

ret = libusb_open(usb_dev, &hdl);

/*

* Workaround for libusb on Windows >= 8.1. A device

* might appear twice in the list with one device being

* bogus and only partially initialized. libusb_open()

* returns LIBUSB_ERROR_NOT_SUPPORTED for such devices,

* which should never happen for normal devices. So if

* we find such a device skip it and keep looking.

*/

if (ret == LIBUSB_ERROR_NOT_SUPPORTED) {

prm_warn(params, "Skipping broken USB device. Please upgrade libusb.\n");

usb_dev = NULL;

continue;

}

break;

}

}

libusb_free_device_list(device_list, true);

if (!usb_dev || !hdl) {

ret = -ENODEV;

goto err_libusb_exit;

}

if (ret) {

ret = -(int) libusb_to_errno(ret);

prm_perror(params, ret, "Unable to open device\n");

goto err_libusb_exit;

}

#if defined(LIBUSB_API_VERSION) && (LIBUSB_API_VERSION >= 0x01000016)

libusb_set_auto_detach_kernel_driver(hdl, true);

#endif

ret = libusb_claim_interface(hdl, intrfc);

if (ret) {

ret = -(int) libusb_to_errno(ret);

prm_perror(params, ret, "Unable to claim interface %u:%u:%u",

bus, address, intrfc);

goto err_libusb_close;

}

ret = libusb_get_active_config_descriptor(usb_dev, &conf_desc);

if (ret) {

ret = -(int) libusb_to_errno(ret);

prm_perror(params, ret, "Unable to get config descriptor");

goto err_libusb_close;

}

iface = &conf_desc->interface[intrfc].altsetting[0];

ret = usb_verify_eps(iface);

if (ret) {

prm_perror(params, ret, "Invalid configuration of endpoints");

goto err_free_config_descriptor;

}

pdata->nb_ep_couples = iface->bNumEndpoints / 2;

prm_dbg(params, "Found %hu usable i/o endpoint couples\n",

pdata->nb_ep_couples);

pdata->io_endpoints = calloc(pdata->nb_ep_couples,

sizeof(*pdata->io_endpoints));

if (!pdata->io_endpoints) {

prm_err(params, "Unable to allocate endpoints\n");

ret = -ENOMEM;

goto err_free_config_descriptor;

}

for (i = 0; i < pdata->nb_ep_couples; i++) {

struct iio_usb_ep_couple *ep = &pdata->io_endpoints[i];

ep->addr_in = iface->endpoint[i * 2 + 0].bEndpointAddress;

ep->addr_out = iface->endpoint[i * 2 + 1].bEndpointAddress;

ep->pipe_id = i;

prm_dbg(params, "Couple %i with endpoints 0x%x / 0x%x\n", i,

ep->addr_in, ep->addr_out);

}

pdata->ctx = usb_ctx;

pdata->hdl = hdl;

pdata->intrfc = intrfc;

ret = usb_io_context_init(&pdata->io_ctx);

if (ret)

goto err_free_endpoints;

/* We reserve the first I/O endpoint couple for global operations */

pdata->io_ctx.ep = &pdata->io_endpoints[0];

pdata->io_ctx.ep->in_use = true;

pdata->io_ctx.ctx_pdata = pdata;

ret = usb_reset_pipes(pdata);

if (ret) {

prm_perror(params, ret, "Failed to reset pipes");

goto err_io_context_exit;

}

ret = usb_open_pipe(pdata, 0);

if (ret) {

prm_perror(params, ret, "Failed to open control pipe");

goto err_io_context_exit;

}

pdata->io_ctx.iiod_client = iiod_client_new(params, &pdata->io_ctx,

&usb_iiod_client_ops);

ret = iio_err(pdata->io_ctx.iiod_client);

if (ret) {

prm_perror(params, ret, "Unable to create IIOD client");

goto err_reset_pipes;

}

ctx = usb_create_context_with_attrs(usb_dev, pdata);

ret = iio_err(ctx);

if (ret)

goto err_free_iiod_client;

libusb_free_config_descriptor(conf_desc);

iio_context_set_pdata(ctx, pdata);

return ctx;

err_reset_pipes:

usb_reset_pipes(pdata); /* Close everything */

err_free_iiod_client:

iiod_client_destroy(pdata->io_ctx.iiod_client);

err_io_context_exit:

usb_io_context_exit(&pdata->io_ctx);

err_free_endpoints:

free(pdata->io_endpoints);

err_free_config_descriptor:

libusb_free_config_descriptor(conf_desc);

err_libusb_close:

libusb_close(hdl);

err_libusb_exit:

libusb_exit(usb_ctx);

err_destroy_ep_mutex:

iio_mutex_destroy(pdata->ep_lock);

err_free_pdata: