DeviceIO/DppLibUsb.cpp

Go to the documentation of this file.

#include "DppLibUsb.h"

CDppLibUsb::CDppLibUsb(void)
{

}
CDppLibUsb::~CDppLibUsb(void)
{

}

// InitializeLibusb must be call before any other libusb operations
int CDppLibUsb::InitializeLibusb()
{
        int iStatus=0;
        iStatus = libusb_init(NULL);
        if (iStatus != 0) {
                fprintf(stderr, "Unable to initialize libusb. %s\n", libusb_strerror((libusb_error)iStatus));
        }
        return iStatus;
}

// DeinitializeLibusb must be called after all libusb operations 
// have been completed and all devices/lists are closed
void CDppLibUsb::DeinitializeLibusb()
{
        libusb_exit(NULL);
}

// devices start at 1
// Do only when no devices are connected
libusb_device_handle * CDppLibUsb::FindUSBDevice(int idxAmptekDevice)
{
        struct libusb_device **devs;
        struct libusb_device *found = NULL;
        struct libusb_device_handle *handle = NULL;
        struct libusb_device_descriptor desc;
        struct libusb_device *device = NULL;
        ssize_t devcnt = 0;
        ssize_t iDev = 0;
        int r;
        int idxDev=1;

        bDeviceConnected = false;
        devcnt = libusb_get_device_list(NULL, &devs);
        if (devcnt < 0) {
                fprintf(stderr, "failed to get device list");
                return NULL;
        }
        for (iDev = 0; iDev < devcnt; iDev++) {
                device = devs[iDev];
                int r = libusb_get_device_descriptor (device, &desc);
                if (r < 0) {
                        fprintf(stderr, libusb_strerror((libusb_error)r));
                        goto out;
                        //continue;
                }
                if (isAmptekDP5Device(desc)) {
                        if (idxAmptekDevice==idxDev) {
                                found = device;
                                break;
                        } else {        // inc counter to next device
                                idxDev++;
                        }
                }
        }
        if (found) {
                r = libusb_open(found, &handle);
                if (r < 0) {
                        fprintf(stderr, libusb_strerror((libusb_error)r));
                        handle = NULL;
                } else {
                        if (handle != NULL) {
                                r = libusb_claim_interface(handle, INTERFACE_NUMBER);
                                if (r >= 0) {
                                        bDeviceConnected = true; // have interface
                                } else {
                                        fprintf(stderr, "libusb_claim_interface error %s\n", libusb_strerror((libusb_error)r));
                                }
                        } else {
                                fprintf(stderr, "Unable to find a dpp device.\n");
                        }
                }
        }

out:
        libusb_free_device_list(devs, 1);
        return handle;
}

void CDppLibUsb::CloseUSBDevice(libusb_device_handle * devh) 
{
        int r;
        if (devh != NULL) {
                r = libusb_release_interface(devh, INTERFACE_NUMBER);
                if (r < 0) {
                        fprintf(stderr, "libusb_release_interface error %s\n", libusb_strerror((libusb_error)r));
                }
                libusb_close(devh);
        }
}

int CDppLibUsb::SendPacketUSB(libusb_device_handle *devh, unsigned char data_out[], unsigned char data_in[])
{
        int bytes_transferred;
        unsigned int timeout = 5000;
        int result = 0;
        int length = 0; 
        
        if ((data_out[2] == PID1_REQ_SCOPE_MISC_TO) && data_out[3] == PID2_SEND_DIAGNOSTIC_DATA_TO) {
                timeout = DP5_DIAGDATA_TIMEOUT;
        } else {
                timeout = DP5_USB_TIMEOUT;
        }

        length = data_out[4];
        length *= 256;
        length += data_out[5];
        length += 8;

        result = libusb_bulk_transfer(devh, BULK_OUT_ENDPOINT, data_out, length, &bytes_transferred, timeout);
        if (result >= 0) {
                result = libusb_bulk_transfer(devh, BULK_IN_ENDPOINT, data_in, MAX_BULK_IN_TRANSFER_SIZE, &bytes_transferred, timeout);
                if (result >= 0) {
                        if (bytes_transferred > 0) {
                                return bytes_transferred;
                        } else {
                                fprintf(stderr, "No data received in bulk transfer (%d)\n", result);
                                return -1;
                        }
                } else {
                        fprintf(stderr, "Error receiving data via bulk transfer %d\n", result);
                        return result;
                }
        } else {
                fprintf(stderr, "Error sending data via bulk transfer %d\n", result);
                return result;
        }
        return 0;
 }

bool CDppLibUsb::isAmptekDP5Device(libusb_device_descriptor desc)
{
        bool isDevice=false;
        if ((desc.idVendor == AMPTEK_DP5_VENDOR_ID) && (desc.idProduct == AMPTEK_DP5_PRODUCT_ID))
        {
                isDevice=true;
        }
        return isDevice;
}

// Counts number of dpp devices
// Do only when no devices are connected
int CDppLibUsb::CountDP5LibusbDevices()
{
        libusb_device **devs;
        int iDppCount=0;

        ssize_t cnt = libusb_get_device_list (NULL, &devs); 
        if (cnt < 0)
                return (-1);
        int nr = 0, i = 0;
        struct libusb_device_descriptor desc;
        for (i = 0; i < cnt; ++i)
        {
                int r = libusb_get_device_descriptor (devs[i], &desc);
                if (r != 0) {
                        fprintf(stderr, libusb_strerror((libusb_error)r));
                        continue;
                }
                if (isAmptekDP5Device(desc)) { nr++; }
        }
        libusb_free_device_list (devs, 1);
        iDppCount = (int)nr;
        return iDppCount;
}

// Do only when no devices are connected
void CDppLibUsb::PrintDevices()
{
        struct libusb_device **devs;
        struct libusb_device *dev = NULL;
        int i = 0;
        ssize_t cnt = 0;

        cnt = libusb_get_device_list(NULL, &devs);
        if (cnt < 0) {
                fprintf(stderr, "failed to get device list");
                return;
        }

        while ((dev = devs[i++]) != NULL) {
                struct libusb_device_descriptor desc;
                int r = libusb_get_device_descriptor(dev, &desc);
                if (r < 0) {
                        fprintf(stderr, "device descriptor error: %s", libusb_strerror((libusb_error)r));
                        return;
                }
                if (isAmptekDP5Device(desc)) {
                        printf("%04x:%04x (bus %d, device %d)\n", desc.idVendor, desc.idProduct, libusb_get_bus_number(dev), libusb_get_device_address(dev));
                }
        }
        libusb_free_device_list(devs, 1);
}

#ifndef LIBUSB_WINUSB_BACKEND
const char * CDppLibUsb::libusb_strerror(enum libusb_error error_code)
{
        switch (error_code) {
        case LIBUSB_SUCCESS:
                return "Success";
        case LIBUSB_ERROR_IO:
                return "Input/output error";
        case LIBUSB_ERROR_INVALID_PARAM:
                return "Invalid parameter";
        case LIBUSB_ERROR_ACCESS:
                return "Access denied (insufficient permissions)";
        case LIBUSB_ERROR_NO_DEVICE:
                return "No such device (it may have been disconnected)";
        case LIBUSB_ERROR_NOT_FOUND:
                return "Entity not found";
        case LIBUSB_ERROR_BUSY:
                return "Resource busy";
        case LIBUSB_ERROR_TIMEOUT:
                return "Operation timed out";
        case LIBUSB_ERROR_OVERFLOW:
                return "Overflow";
        case LIBUSB_ERROR_PIPE:
                return "Pipe error";
        case LIBUSB_ERROR_INTERRUPTED:
                return "System call interrupted (perhaps due to signal)";
        case LIBUSB_ERROR_NO_MEM:
                return "Insufficient memory";
        case LIBUSB_ERROR_NOT_SUPPORTED:
                return "Operation not supported or unimplemented on this platform";
        case LIBUSB_ERROR_OTHER:
                return "Other error";
        }
        return "Unknown error";
}
#endif