LibUsbAdaptor.h

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Library General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * LibUsbAdaptor.h
 * The wrapper around libusb calls.
 * Copyright (C) 2014 Simon Newton
 */

#ifndef LIBS_USB_LIBUSBADAPTOR_H_
#define LIBS_USB_LIBUSBADAPTOR_H_

#include <libusb.h>
#include <string>

#include "ola/base/Macro.h"
#include "libs/usb/Types.h"

namespace ola {
namespace usb {

class LibUsbAdaptor {
 public:
 struct DeviceInformation {
 std::string manufacturer;
 std::string product;
 std::string serial;
 };

 virtual ~LibUsbAdaptor() {}

 // Device handling and enumeration

 virtual libusb_device* RefDevice(libusb_device *dev) = 0;

 virtual void UnrefDevice(libusb_device *dev) = 0;

 virtual bool OpenDevice(libusb_device *usb_device,
 libusb_device_handle **usb_handle) = 0;

 virtual bool OpenDeviceAndClaimInterface(
 libusb_device *usb_device,
 int interface,
 libusb_device_handle **usb_handle) = 0;

 virtual void Close(libusb_device_handle *usb_handle) = 0;

 virtual int SetConfiguration(libusb_device_handle *dev,
 int configuration) = 0;

 virtual int ClaimInterface(libusb_device_handle *dev,
 int interface_number) = 0;

 virtual int DetachKernelDriver(libusb_device_handle *dev,
 int interface_number) = 0;

 // USB descriptors
 virtual int GetDeviceDescriptor(
 libusb_device *dev,
 struct libusb_device_descriptor *descriptor) = 0;

 virtual int GetActiveConfigDescriptor(
 libusb_device *dev,
 struct libusb_config_descriptor **config) = 0;

 virtual int GetConfigDescriptor(libusb_device *dev,
 uint8_t config_index,
 struct libusb_config_descriptor **config) = 0;

 virtual void FreeConfigDescriptor(
 struct libusb_config_descriptor *config) = 0;

 virtual bool GetStringDescriptor(libusb_device_handle *usb_handle,
 uint8_t descriptor_index,
 std::string *data) = 0;

 // Asynchronous device I/O

 virtual struct libusb_transfer* AllocTransfer(int iso_packets) = 0;

 virtual void FreeTransfer(struct libusb_transfer *transfer) = 0;

 virtual int SubmitTransfer(struct libusb_transfer *transfer) = 0;

 virtual int CancelTransfer(struct libusb_transfer *transfer) = 0;

 virtual void FillControlSetup(unsigned char *buffer,
 uint8_t bmRequestType,
 uint8_t bRequest,
 uint16_t wValue,
 uint16_t wIndex,
 uint16_t wLength) = 0;

 virtual void FillControlTransfer(struct libusb_transfer *transfer,
 libusb_device_handle *dev_handle,
 unsigned char *buffer,
 libusb_transfer_cb_fn callback,
 void *user_data,
 unsigned int timeout) = 0;

 virtual void FillBulkTransfer(struct libusb_transfer *transfer,
 libusb_device_handle *dev_handle,
 unsigned char endpoint,
 unsigned char *buffer,
 int length,
 libusb_transfer_cb_fn callback,
 void *user_data,
 unsigned int timeout) = 0;

 virtual void FillInterruptTransfer(struct libusb_transfer *transfer,
 libusb_device_handle *dev_handle,
 unsigned char endpoint,
 unsigned char *buffer,
 int length,
 libusb_transfer_cb_fn callback,
 void *user_data,
 unsigned int timeout) = 0;

 // Synchronous device I/O

 virtual int ControlTransfer(libusb_device_handle *dev_handle,
 uint8_t bmRequestType,
 uint8_t bRequest,
 uint16_t wValue,
 uint16_t wIndex,
 unsigned char *data,
 uint16_t wLength,
 unsigned int timeout) = 0;

 virtual int BulkTransfer(struct libusb_device_handle *dev_handle,
 unsigned char endpoint,
 unsigned char *data,
 int length,
 int *transferred,
 unsigned int timeout) = 0;

 virtual int InterruptTransfer(libusb_device_handle *dev_handle,
 unsigned char endpoint,
 unsigned char *data,
 int length,
 int *actual_length,
 unsigned int timeout) = 0;

 virtual USBDeviceID GetDeviceId(libusb_device *device) const = 0;

 // Static helper methods.

 static bool Initialize(struct libusb_context **context);

 static bool GetDeviceInfo(
 struct libusb_device *usb_device,
 const struct libusb_device_descriptor &device_descriptor,
 DeviceInformation *device_info);

 static bool CheckManufacturer(const std::string &expected,
 const DeviceInformation &device_info);

 static bool CheckProduct(const std::string &expected,
 const DeviceInformation &device_info);

 static bool HotplugSupported();

 static std::string ErrorCodeToString(const int error_code);
};

class BaseLibUsbAdaptor : public LibUsbAdaptor {
 public:
 // Device handling and enumeration
 libusb_device* RefDevice(libusb_device *dev);

 void UnrefDevice(libusb_device *dev);

 int SetConfiguration(libusb_device_handle *dev, int configuration);

 int ClaimInterface(libusb_device_handle *dev, int interface_number);

 int DetachKernelDriver(libusb_device_handle *dev, int interface_number);

 // USB descriptors
 int GetDeviceDescriptor(libusb_device *dev,
 struct libusb_device_descriptor *descriptor);

 int GetActiveConfigDescriptor(
 libusb_device *dev,
 struct libusb_config_descriptor **config);

 int GetConfigDescriptor(libusb_device *dev,
 uint8_t config_index,
 struct libusb_config_descriptor **config);

 void FreeConfigDescriptor(struct libusb_config_descriptor *config);

 bool GetStringDescriptor(libusb_device_handle *usb_handle,
 uint8_t descriptor_index,
 std::string *data);

 // Asynchronous device I/O
 struct libusb_transfer* AllocTransfer(int iso_packets);

 void FreeTransfer(struct libusb_transfer *transfer);

 int SubmitTransfer(struct libusb_transfer *transfer);

 int CancelTransfer(struct libusb_transfer *transfer);

 void FillControlSetup(unsigned char *buffer,
 uint8_t bmRequestType,
 uint8_t bRequest,
 uint16_t wValue,
 uint16_t wIndex,
 uint16_t wLength);

 void FillControlTransfer(struct libusb_transfer *transfer,
 libusb_device_handle *dev_handle,
 unsigned char *buffer,
 libusb_transfer_cb_fn callback,
 void *user_data,
 unsigned int timeout);

 void FillBulkTransfer(struct libusb_transfer *transfer,
 libusb_device_handle *dev_handle,
 unsigned char endpoint,
 unsigned char *buffer,
 int length,
 libusb_transfer_cb_fn callback,
 void *user_data,
 unsigned int timeout);

 void FillInterruptTransfer(struct libusb_transfer *transfer,
 libusb_device_handle *dev_handle,
 unsigned char endpoint,
 unsigned char *buffer,
 int length,
 libusb_transfer_cb_fn callback,
 void *user_data,
 unsigned int timeout);

 // Synchronous device I/O
 int ControlTransfer(libusb_device_handle *dev_handle,
 uint8_t bmRequestType,
 uint8_t bRequest,
 uint16_t wValue,
 uint16_t wIndex,
 unsigned char *data,
 uint16_t wLength,
 unsigned int timeout);

 int BulkTransfer(struct libusb_device_handle *dev_handle,
 unsigned char endpoint,
 unsigned char *data,
 int length,
 int *transferred,
 unsigned int timeout);

 int InterruptTransfer(libusb_device_handle *dev_handle,
 unsigned char endpoint,
 unsigned char *data,
 int length,
 int *actual_length,
 unsigned int timeout);

 USBDeviceID GetDeviceId(libusb_device *device) const;
};

class SynchronousLibUsbAdaptor : public BaseLibUsbAdaptor {
 public:
 SynchronousLibUsbAdaptor() {}

 bool OpenDevice(libusb_device *usb_device,
 libusb_device_handle **usb_handle);

 bool OpenDeviceAndClaimInterface(libusb_device *usb_device,
 int interface,
 libusb_device_handle **usb_handle);

 void Close(libusb_device_handle *usb_handle);

 private:
 DISALLOW_COPY_AND_ASSIGN(SynchronousLibUsbAdaptor);
};

class AsynchronousLibUsbAdaptor : public BaseLibUsbAdaptor {
 public:
 explicit AsynchronousLibUsbAdaptor(class LibUsbThread *thread)
 : m_thread(thread) {
 }

 bool OpenDevice(libusb_device *usb_device,
 libusb_device_handle **usb_handle);

 bool OpenDeviceAndClaimInterface(libusb_device *usb_device,
 int interface,
 libusb_device_handle **usb_handle);

 void Close(libusb_device_handle *usb_handle);

 int ControlTransfer(libusb_device_handle *dev_handle,
 uint8_t bmRequestType,
 uint8_t bRequest,
 uint16_t wValue,
 uint16_t wIndex,
 unsigned char *data,
 uint16_t wLength,
 unsigned int timeout);

 int BulkTransfer(struct libusb_device_handle *dev_handle,
 unsigned char endpoint,
 unsigned char *data,
 int length,
 int *transferred,
  unsigned int timeout);

 int InterruptTransfer(libusb_device_handle *dev_handle,
 unsigned char endpoint,
 unsigned char *data,
 int length,
 int *actual_length,
 unsigned int timeout);

 private:
 class LibUsbThread *m_thread;

 DISALLOW_COPY_AND_ASSIGN(AsynchronousLibUsbAdaptor);
};
} // namespace usb
} // namespace ola
#endif // LIBS_USB_LIBUSBADAPTOR_H_