libusb_dyn.c

LIBUSBdriver LIBUSBdriver

}

int usb_get_descriptor(usb_dev_handle *udev, unsigned char type,
                       unsigned char index, void *buf, int size)
{
  if(_usb_get_descriptor)
    return _usb_get_descriptor(udev, type, index, buf, size);
  else
    return -ENOFILE;
}

int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size,
                   int timeout)
{
  if(_usb_bulk_write)
    return _usb_bulk_write(dev, ep, bytes, size, timeout);
  else
    return -ENOFILE;
}

int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size,
                  int timeout)
{
  if(_usb_bulk_read)
    return _usb_bulk_read(dev, ep, bytes, size, timeout);
  else
    return -ENOFILE;
}

int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size,
                        int timeout)
{
  if(_usb_interrupt_write)
    return _usb_interrupt_write(dev, ep, bytes, size, timeout);
  else
    return -ENOFILE;
}

int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size,
                       int timeout)
{
  if(_usb_interrupt_read)
    return _usb_interrupt_read(dev, ep, bytes, size, timeout);
  else
    return -ENOFILE;
}

int usb_control_msg(usb_dev_handle *dev, int requesttype, int request,
                    int value, int index, char *bytes, int size, 
                    int timeout)
{
  if(_usb_control_msg)
    return _usb_control_msg(dev, requesttype, request, value, index, bytes, 
                            size, timeout);
  else
    return -ENOFILE;
}

int usb_set_configuration(usb_dev_handle *dev, int configuration)
{
  if(_usb_set_configuration)
    return _usb_set_configuration(dev, configuration);
  else
    return -ENOFILE;
}

int usb_claim_interface(usb_dev_handle *dev, int interface)
{
  if(_usb_claim_interface)
    return _usb_claim_interface(dev, interface);
  else
    return -ENOFILE;
}

int usb_release_interface(usb_dev_handle *dev, int interface)
{
  if(_usb_release_interface)
    return _usb_release_interface(dev, interface);
  else
    return -ENOFILE;
}

int usb_set_altinterface(usb_dev_handle *dev, int alternate)
{
  if(_usb_set_altinterface)
    return _usb_set_altinterface(dev, alternate);
  else
    return -ENOFILE;
}

int usb_resetep(usb_dev_handle *dev, unsigned int ep)
{
  if(_usb_resetep)
    return _usb_resetep(dev, ep);
  else
    return -ENOFILE;
}

int usb_clear_halt(usb_dev_handle *dev, unsigned int ep)
{
  if(_usb_clear_halt)
    return _usb_clear_halt(dev, ep);
  else
    return -ENOFILE;
}

int usb_reset(usb_dev_handle *dev)
{
  if(_usb_reset)
    return _usb_reset(dev);
  else
    return -ENOFILE;
}

char *usb_strerror(void)
{
  if(_usb_strerror)
    return _usb_strerror();
  else
    return NULL;
}

void usb_set_debug(int level)
{
  if(_usb_set_debug)
    return _usb_set_debug(level);
}

int usb_find_busses(void)
{
  if(_usb_find_busses)
    return _usb_find_busses();
  else
    return -ENOFILE;
}

int usb_find_devices(void)
{
  if(_usb_find_devices)
    return _usb_find_devices();
  else
    return -ENOFILE;
}

struct usb_device *usb_device(usb_dev_handle *dev)
{
  if(_usb_device)
    return _usb_device(dev);
  else
    return NULL;
}

struct usb_bus *usb_get_busses(void)
{
  if(_usb_get_busses)
    return _usb_get_busses();
  else
    return NULL;
}

int usb_install_service_np(void)
{
  if(_usb_install_service_np)
    return _usb_install_service_np();
  else
    return -ENOFILE;
}

int usb_uninstall_service_np(void)
{
  if(_usb_uninstall_service_np)
    return _usb_uninstall_service_np();
  else
    return -ENOFILE;
}

int usb_install_driver_np(const char *inf_file)
{
  if(_usb_install_driver_np)
    return _usb_install_driver_np(inf_file);
  else
    return -ENOFILE;
}

const struct usb_version *usb_get_version(void)
{
  if(_usb_get_version)
    return _usb_get_version();
  else
    return NULL;
}

int usb_isochronous_setup_async(usb_dev_handle *dev, void **context,
                                unsigned char ep, int pktsize)
{
  if(_usb_isochronous_setup_async)
    return _usb_isochronous_setup_async(dev, context, ep, pktsize);
  else
    return -ENOFILE;
}

int usb_bulk_setup_async(usb_dev_handle *dev, void **context,
                         unsigned char ep)
{
  if(_usb_bulk_setup_async)
    return _usb_bulk_setup_async(dev, context, ep);
  else
    return -ENOFILE;
}

int usb_interrupt_setup_async(usb_dev_handle *dev, void **context,
                              unsigned char ep)
{
  if(_usb_interrupt_setup_async)
    return _usb_interrupt_setup_async(dev, context, ep);
  else
    return -ENOFILE;
}

int usb_submit_async(void *context, char *bytes, int size)
{
  if(_usb_submit_async)
    return _usb_submit_async(context, bytes, size);
  else
    return -ENOFILE;
}

int usb_reap_async(void *context, int timeout)
{
  if(_usb_reap_async)
    return _usb_reap_async(context, timeout);
  else
    return -ENOFILE;
}

int usb_free_async(void **context)
{
  if(_usb_free_async)
    return _usb_free_async(context);
  else
    return -ENOFILE;
}