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 SyncronousLibUsbAdaptor : public BaseLibUsbAdaptor {
 public:
  SyncronousLibUsbAdaptor() {}

  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(SyncronousLibUsbAdaptor);
};

class AsyncronousLibUsbAdaptor : public BaseLibUsbAdaptor {
 public:
  explicit AsyncronousLibUsbAdaptor(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(AsyncronousLibUsbAdaptor);
};
}  // namespace usb
}  // namespace ola
#endif  // LIBS_USB_LIBUSBADAPTOR_H_