static int get_hub_number(libusb_device *dev) {
struct libusb_device *parent;
struct libusb_device_descriptor parent_device_desc;
uint16_t dev_vid, dev_pid;
int ret;
parent = libusb_get_parent(dev);
ret = libusb_get_device_descriptor(parent, &parent_device_desc);
if (ret)
return -1;
dev_vid = libusb_le16_to_cpu(parent_device_desc.idVendor);
dev_pid = libusb_le16_to_cpu(parent_device_desc.idProduct);
if (dev_vid == 0x1d6b && dev_pid == 0x0002) {
// If parent is "Linux Foundation 2.0 root hub", this is upstream hub
return 1;
}
if (dev_vid == 0x05e3 && dev_pid == 0x0614) {
// If parent is another hub ...
if (libusb_get_port_number(dev) == 4) {
// and we're connected to port #4...
if (get_hub_number(parent) == 1) {
// And it's upstream hub, then we're downstream one
return 2;
}
}
}
return 3;
}
void Y_usb_open_device(int argc)
{
ydev_instance_t *obj = NULL;
libusb_device* dev;
int bus, port;
int i, ret;
if (argc != 2) {
y_error("expecting exactly 2 arguments");
}
bus = ygets_i(1);
port = ygets_i(0);
load_device_list();
for (i = 0; i < dev_count; ++i) {
dev = dev_list[i];
if (libusb_get_bus_number(dev) == bus &&
libusb_get_port_number(dev) == port) {
obj = (ydev_instance_t *)ypush_obj(&ydev_class, sizeof(ydev_instance_t));
obj->device = libusb_ref_device(dev);
ret = libusb_open(obj->device, &obj->handle);
if (ret < 0) {
obj->handle = NULL;
failure("failed to open device", ret);
}
obj->bus = bus;
obj->port = port;
obj->address = libusb_get_device_address(dev);
ret = libusb_get_device_descriptor(dev, &obj->descriptor);
if (ret != 0) {
free_dev_list();
failure("unable to get device descriptor", ret);
}
break;
}
}
free_dev_list();
if (obj == NULL) {
ypush_nil();
}
}
void Y_usb_summary(int argc)
{
ssize_t i;
libusb_device_handle* handle;
load_device_list();
for (i = 0; i < dev_count; ++i) {
int code;
struct libusb_device_descriptor desc;
libusb_device* dev = dev_list[i];
uint8_t bus_number = libusb_get_bus_number(dev);
uint8_t port_number = libusb_get_port_number(dev);
uint8_t device_address = libusb_get_device_address(dev);
fprintf(stdout, "USB Device %ld:\n", (long)i);
fprintf(stdout, " Bus Number ---------> %d\n", (int)bus_number);
fprintf(stdout, " Port Number --------> %d\n", (int)port_number);
fprintf(stdout, " Device Address -----> %d\n", (int)device_address);
code = libusb_get_device_descriptor(dev, &desc);
if (code != 0) {
failure(NULL, code);
}
fprintf(stdout, " Vendor ID ----------> 0x%04x\n",
(unsigned int)desc.idVendor);
fprintf(stdout, " Product ID ---------> 0x%04x\n",
(unsigned int)desc.idProduct);
code = libusb_open(dev, &handle);
if (code == 0) {
fprintf(stdout, " Manufacturer -------> %s\n",
get_string(handle, desc.iManufacturer));
fprintf(stdout, " Product ------------> %s\n",
get_string(handle, desc.idProduct));
fprintf(stdout, " Serial Number ------> %s\n",
get_string(handle, desc.iSerialNumber));
libusb_close(handle);
}
}
free_dev_list();
ypush_nil();
}
void Y__usb_probe_devices(int argc)
{
struct libusb_device_descriptor desc;
libusb_device* dev;
long dims[3];
int* data;
int i, ret;
if (argc != 1 || ! yarg_nil(0)) {
y_error("expecting exactly one nil argument");
}
load_device_list();
if (dev_count > 0) {
dims[0] = 2;
dims[1] = 7;
dims[2] = dev_count;
data = ypush_i(dims);
for (i = 0; i < dev_count; ++i) {
dev = dev_list[i];
ret = libusb_get_device_descriptor(dev, &desc);
if (ret != 0) {
free_dev_list();
failure("unable to get device descriptor", ret);
}
data[0] = libusb_get_bus_number(dev);
data[1] = libusb_get_port_number(dev);
data[2] = libusb_get_device_address(dev);
data[3] = desc.idVendor;
data[4] = desc.idProduct;
data[5] = desc.iManufacturer;
data[6] = desc.iSerialNumber;
data += 7;
}
} else {
ypush_nil();
}
free_dev_list();
}
QList<DMXInterface *> LibFTDIInterface::interfaces(QList<DMXInterface *> discoveredList)
{
QList <DMXInterface*> interfacesList;
int id = 0;
struct ftdi_context ftdi;
ftdi_init(&ftdi);
#ifdef LIBFTDI1
libusb_device *dev;
libusb_device **devs;
struct libusb_device_descriptor dev_descriptor;
int i = 0;
if (libusb_get_device_list(ftdi.usb_ctx, &devs) < 0)
{
qDebug() << "usb_find_devices() failed";
return interfacesList;
}
while ((dev = devs[i++]) != NULL)
{
libusb_get_device_descriptor(dev, &dev_descriptor);
#else
struct usb_bus *bus;
struct usb_device *dev;
struct usb_device_descriptor dev_descriptor;
usb_init();
if (usb_find_busses() < 0)
{
qDebug() << "usb_find_busses() failed";
return interfacesList;
}
if (usb_find_devices() < 0)
{
qDebug() << "usb_find_devices() failed";
return interfacesList;
}
for (bus = usb_get_busses(); bus; bus = bus->next)
{
for (dev = bus->devices; dev; dev = dev->next)
{
dev_descriptor = dev->descriptor;
#endif
Q_ASSERT(dev != NULL);
// Skip non wanted devices
if (validInterface(dev_descriptor.idVendor, dev_descriptor.idProduct) == false)
continue;
char ser[256];
memset(ser, 0, 256);
char nme[256];
char vend[256];
ftdi_usb_get_strings(&ftdi, dev, vend, 256, nme, 256, ser, 256);
QString serial(ser);
QString name(nme);
QString vendor(vend);
qDebug() << Q_FUNC_INFO << "DMX USB VID:" << QString::number(dev_descriptor.idVendor, 16) <<
"PID:" << QString::number(dev_descriptor.idProduct, 16);
qDebug() << Q_FUNC_INFO << "DMX USB serial: " << serial << "name:" << name << "vendor:" << vendor;
bool found = false;
for (int c = 0; c < discoveredList.count(); c++)
{
if (discoveredList.at(c)->checkInfo(serial, name, vendor) == true)
{
found = true;
break;
}
}
if (found == false)
{
LibFTDIInterface *iface = new LibFTDIInterface(serial, name, vendor, dev_descriptor.idVendor,
dev_descriptor.idProduct, id++);
#ifdef LIBFTDI1
iface->setBusLocation(libusb_get_port_number(dev));
#else
iface->setBusLocation(dev->bus->location);
#endif
interfacesList << iface;
}
#ifndef LIBFTDI1
}
#endif
}
#ifdef LIBFTDI1
libusb_free_device_list(devs, 1);
#endif
ftdi_deinit(&ftdi);
return interfacesList;
}
bool LibFTDIInterface::open()
{
if (isOpen() == true)
return true;
QByteArray sba = serial().toLatin1();
const char *ser = NULL;
if (serial().isEmpty() == false)
ser = (const char *)sba.data();
if (ftdi_usb_open_desc(&m_handle, vendorID(), productID(),
name().toLatin1(), ser) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::openByPID(const int PID)
{
if (isOpen() == true)
return true;
if (ftdi_usb_open(&m_handle, DMXInterface::FTDIVID, PID) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::close()
{
if (ftdi_usb_close(&m_handle) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::isOpen() const
{
return (m_handle.usb_dev != NULL) ? true : false;
}
bool LibFTDIInterface::reset()
{
if (ftdi_usb_reset(&m_handle) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::setLineProperties()
{
if (ftdi_set_line_property(&m_handle, BITS_8, STOP_BIT_2, NONE) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::setBaudRate()
{
if (ftdi_set_baudrate(&m_handle, 250000) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::setFlowControl()
{
if (ftdi_setflowctrl(&m_handle, SIO_DISABLE_FLOW_CTRL) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::clearRts()
{
if (ftdi_setrts(&m_handle, 0) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::purgeBuffers()
{
if (ftdi_usb_purge_buffers(&m_handle) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::setBreak(bool on)
{
ftdi_break_type type;
if (on == true)
type = BREAK_ON;
else
type = BREAK_OFF;
if (ftdi_set_line_property2(&m_handle, BITS_8, STOP_BIT_2, NONE, type) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
static void usb_device_get_addr(struct libusb_device *dev, usb_addr *addr)
{
addr->bus = libusb_get_bus_number(dev);
addr->port = libusb_get_port_number(dev);
}
int spi_begin(uint8_t bus, uint8_t port)
{
int ret;
ftdi = ftdi_new();
if (ftdi == 0) {
fprintf(stderr, "ftdi_new failed\n");
return -1;
}
if (bus > 0) {
struct ftdi_device_list *list = NULL;
struct ftdi_device_list *p;
ret = ftdi_usb_find_all(ftdi, &list, 0, 0);
if (ret < 0) {
fprintf(stderr, "unable to list devices: %d (%s)\n",
ret, ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return -2;
}
p = list;
while (p) {
if (bus == libusb_get_bus_number(p->dev) &&
port == libusb_get_port_number(p->dev)) {
ret = ftdi_usb_open_dev(ftdi, p->dev);
break;
}
p = p->next;
}
ftdi_list_free(&list);
if (!p) {
fprintf(stderr, "dev on bus %i and port %i not found\n",
bus, port);
ftdi_free(ftdi);
return -3;
}
} else
ret = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (ret < 0 && ret != -5) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret,
ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return -4;
}
ret = ftdi_set_bitmode(ftdi, PINS_OUT, BITMODE_SYNCBB);
if (ret != 0) {
fprintf(stderr, "unable to set bitmode: %d (%s)\n", ret,
ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return -5;
}
ret = ftdi_set_baudrate(ftdi, 57600);
if (ret != 0) {
fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret,
ftdi_get_error_string(ftdi));
ftdi_disable_bitbang(ftdi);
ftdi_free(ftdi);
return -6;
}
digitalWrite(PIN_PROG, LOW);
digitalWrite(PIN_FSCK, LOW);
digitalWrite(PIN_FCSN, HIGH);
digitalWrite(PIN_FMOSI, LOW);
digitalWrite(PIN_RESET, HIGH);
prog_begin();
return 0;
}
fx3_dev_err_t FX3Dev::scan() {
fprintf( stderr, "FX3Dev::scan()\n" );
int ires;
libusb_device **devs;
ssize_t dev_cnt = libusb_get_device_list( ctx, &devs );
if( dev_cnt < 0 ) {
fprintf( stderr, "FX3Dev::Init(): __error__ libusb_get_device_list() error %d %s\n", dev_cnt, libusb_error_name( dev_cnt ) );
return FX3_ERR_USB_INIT_FAIL;
}
fprintf( stderr, "FX3Dev::scan() libusb_get_device_list returned %d\n", dev_cnt );
for ( int i = 0; devs[ i ] != NULL; i++ ) {
libusb_device_descriptor desc;
ires = libusb_get_device_descriptor( devs[ i ], &desc );
if ( ires < 0 ) {
fprintf( stderr, "libusb_get_device_descriptor %d %s\n", ires, libusb_error_name( ires ) );
} else {
uint8_t bus = libusb_get_bus_number(devs[i]);
uint8_t port = libusb_get_port_number(devs[i]);
fprintf( stderr, "[%2d] bus:%u port:%u 0x%04x, 0x%04x", i, bus, port, desc.idVendor, desc.idProduct );
if ( desc.idVendor == VENDOR_ID ) {
if ( desc.idProduct == DEV_PID_FOR_FW_LOAD ) {
fprintf( stderr, " *** firmware needed\n" );
} else if ( desc.idProduct == DEV_PID_NO_FW_NEEDED ) {
fprintf( stderr, " *** ready adc device\n" );
} else {
fprintf( stderr, " *** driver compatible device" );
}
libusb_config_descriptor *config;
libusb_get_config_descriptor(devs[ i ], 0, &config);
const libusb_interface *inter;
const libusb_interface_descriptor *interdesc;
for(int i=0; i<(int)config->bNumInterfaces; i++) {
inter = &config->interface[i];
for(int j=0; j<inter->num_altsetting; j++) {
interdesc = &inter->altsetting[j];
fprintf( stderr, "%d endpoints\n", interdesc->bNumEndpoints );
for(int k=0; k<interdesc->bNumEndpoints; k++) {
uint8_t num = ( interdesc->endpoint[k].bEndpointAddress & ( 0x0F ) );
libusb_endpoint_direction dir = ( libusb_endpoint_direction )( interdesc->endpoint[k].bEndpointAddress & ( 0x80 ) );
uint16_t maxSize = interdesc->endpoint[k].wMaxPacketSize;
fprintf( stderr, " [%d] %s - %u bytes max\n",
num,
dir == LIBUSB_ENDPOINT_IN ? "IN (dev-to-host)" : "OUT (host-to-dev)",
maxSize);
if ( dir == LIBUSB_ENDPOINT_IN ) {
endpoint_from_dev_num = num;
} else {
endpoint_from_hst_num = num;
}
}
}
}
libusb_free_config_descriptor(config);
}
fprintf( stderr, "\n" );
}
}
libusb_free_device_list( devs, 1 );
return FX3_ERR_OK;
}
const char * get_usb_port_id(const device & device)
{
std::string usb_port = std::to_string(libusb_get_bus_number(device.uvcdevice->usb_dev)) + "-" +
std::to_string(libusb_get_port_number(device.uvcdevice->usb_dev));
return usb_port.c_str();
}
UsbNotifier::~UsbNotifier()
{
d->end = true;
terminate();
struct timeval emitTimer = (struct timeval){0};
libusb_handle_events_timeout_completed(NULL, &emitTimer, NULL);
// callbacks are eliminated on exit
// http://libusb.sourceforge.net/api-1.0/hotplug.html
libusb_exit(NULL);
delete d;
}
UsbDevice* UsbNotifier::extractUsbDevice(libusb_device *device)
{
struct libusb_device_descriptor descriptor;
struct libusb_device_handle *myHandle = nullptr;
int operationResult = 0;
if (libusb_get_device_descriptor(device, &descriptor) < 0) {
qDebug("COMPLETE FAIL");
return nullptr;
}
// I need to open the device to get more information about the usb
operationResult = libusb_open(device, &myHandle);
if (operationResult < 0) {
qDebug() << "UsbNotifier::deviceInsertCallback - Can't open usb device @ " << libusb_get_device_address(device) << " ERROR NO: " << operationResult;
return nullptr;
}
char manufacturer[256];
char product[256];
operationResult = libusb_get_string_descriptor_ascii(myHandle
, descriptor.iManufacturer
, (unsigned char*)manufacturer
, sizeof(manufacturer));
if (operationResult < 0) {
qDebug() << "UsbNotifier::deviceInsertCallback - something went wrong while extracting the manufacturer";
return nullptr;
}
operationResult = libusb_get_string_descriptor_ascii(myHandle
, descriptor.iProduct
, (unsigned char*)product
, sizeof(product));
if (operationResult < 0) {
qDebug() << "UsbNotifier::deviceInsertCallback - something went wrong while extracting the product";
return nullptr;
}
libusb_close(myHandle);
return new UsbDevice(libusb_get_device_address(device)
, libusb_get_bus_number(device)
, descriptor.idVendor
, libusb_get_port_number(device)
, descriptor.idProduct
, manufacturer
, product
, device);
}
void UsbNotifier::run()
{
// do a quick check for already plugged in usb devices
int result = 0;
d->end = false;
libusb_device **deviceList;
result = libusb_get_device_list(NULL, &deviceList);
if (result < 0) {
// TODO handle error
qDebug() << "[UsbNotifier::run] result value: " << result;
qDebug() << "UsbNotifier::run] ERROR: " << libusb_error_name(result);
} else {
libusb_device_handle *handle = nullptr;
for (int i = 0; i < result; ++i) {
// test if the device is usable. There might be some usb device which we don't have permission
// to operate on. This test is done by a simple libusb_open/close test.
if (libusb_open(deviceList[i], &handle) == LIBUSB_SUCCESS) {
libusb_close(handle);
UsbDevice *usbDevice = extractUsbDevice(deviceList[i]);
if (usbDevice && (d->product == 0 || d->vendor == 0)) {
Q_EMIT deviceAttached(usbDevice);
} else {
if (usbDevice
&& (usbDevice->productId() == d->product && usbDevice->vendorId() == d->vendor)) {
Q_EMIT deviceAttached(usbDevice);
}
}
}
}
libusb_free_device_list(deviceList, 1);
}
// and now start watching for events
setTerminationEnabled(true);
while (!d->end) {
libusb_handle_events(NULL);
}
}
