/* Retrieves alternate interface name string.
* Returns string length, or negative on error */
int get_alt_name(struct dfu_if *dfu_if, unsigned char *name)
{
libusb_device *dev = dfu_if->dev;
struct libusb_config_descriptor *cfg;
int alt_name_str_idx;
int ret;
ret = libusb_get_config_descriptor_by_value(dev, dfu_if->configuration,
&cfg);
if (ret)
return ret;
alt_name_str_idx = cfg->interface[dfu_if->interface].
altsetting[dfu_if->altsetting].iInterface;
ret = -1;
if (alt_name_str_idx) {
if (!dfu_if->dev_handle)
if (libusb_open(dfu_if->dev, &dfu_if->dev_handle))
dfu_if->dev_handle = NULL;
if (dfu_if->dev_handle)
ret = libusb_get_string_descriptor_ascii(
dfu_if->dev_handle, alt_name_str_idx,
name, MAX_DESC_STR_LEN);
}
libusb_free_config_descriptor(cfg);
return ret;
}
int cyusb_get_config_descriptor_by_value(cyusb_handle *h, unsigned char bConfigurationValue,
struct libusb_config_descriptor **config)
{
cyusb_device *tdev = libusb_get_device(h);
return ( libusb_get_config_descriptor_by_value(tdev, bConfigurationValue,
(struct libusb_config_descriptor **)config) );
}
/**
* \brief Get configuration by value.
*
* \param value configuration value to search for.
*/
ConfigurationPtr Device::configValue(uint8_t value) throw(USBError) {
struct libusb_config_descriptor *config;
int rc = libusb_get_config_descriptor_by_value(dev, value, &config);
if (rc != LIBUSB_SUCCESS) {
throw USBError(libusb_error_name(rc));
}
Configuration *result = new Configuration(*this, config);
libusb_free_config_descriptor(config);
return ConfigurationPtr(result);
}
/**
* Determine the endpoints of the currently active configuration. If the endpoints can be determined,
* they are stored in the global variables aoa_endpoint_in and aoa_endpoint_out.
* @param dev Pointer to the currently opened device
*/
void determineEndpoints(libusb_device* dev) {
int response = -1;
// We have our handle, lets begin by determining our endpoints
struct libusb_config_descriptor *desc = NULL;
response = libusb_get_config_descriptor_by_value(dev, 1, &desc);
if (response == 0) {
#ifdef DEBUG
printf("libAndroidAccessory: %d actual interfaces in this descriptor\n",
desc->bNumInterfaces);
#endif
for (int i = 0; i < desc->bNumInterfaces; ++i) {
const struct libusb_interface* iface = &desc->interface[i];
#ifdef DEBUG
printf("libAndroidAccessory: Found %d interfaces\n", iface->num_altsetting);
#endif
for (int j = 0; j < iface->num_altsetting; ++j) {
const struct libusb_interface_descriptor* interfacedesc =
&iface->altsetting[j];
if (interfacedesc->bInterfaceNumber != 0) {
// this is not the regular interface, but the ADB interface, skip it
#ifdef DEBUG
printf("libAndroidAccessory: Skipping ADB interface... \n");
#endif
continue;
}
// We enumerate the endpoints, not dealing with more than 2 endpoints here
for (int k = 0; k < interfacedesc->bNumEndpoints; ++k) {
const struct libusb_endpoint_descriptor* endpointsdesc =
&interfacedesc->endpoint[k];
uint8_t endp = endpointsdesc->bEndpointAddress;
if (endp & 0x80) {
// Direction is inbound
aoa_endpoint_in = endp;
#ifdef DEBUG
printf("libAndroidAccessory: Endpoint in = %x\n", aoa_endpoint_in);
#endif
} else {
// Direction is outbound
aoa_endpoint_out = endp;
#ifdef DEBUG
printf("libAndroidAccessory: Endpoint out = %x\n", aoa_endpoint_out);
#endif
}
}
}
}
libusb_free_config_descriptor(desc);
}
}
int get_max_iso_packet_size(libusb_device *device, int configuration, int alternate_setting, int endpoint)
{
libusb_config_descriptor *config_desc;
int r = LIBUSB_ERROR_NOT_FOUND;
r = libusb_get_config_descriptor_by_value(device, configuration, &config_desc);
if(r == LIBUSB_SUCCESS)
{
for(int interface_idx = 0; interface_idx < config_desc->bNumInterfaces; ++interface_idx)
{
const libusb_interface &interface = config_desc->interface[interface_idx];
if(interface.num_altsetting > alternate_setting)
{
const libusb_interface_descriptor &interface_desc = interface.altsetting[alternate_setting];
const libusb_endpoint_descriptor *endpoint_desc = 0;
for(int endpoint_idx = 0; endpoint_idx < interface_desc.bNumEndpoints; ++endpoint_idx)
{
if(interface_desc.endpoint[endpoint_idx].bEndpointAddress == endpoint && (interface_desc.endpoint[endpoint_idx].bmAttributes & 0x3) == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS)
{
endpoint_desc = interface_desc.endpoint + endpoint_idx;
break;
}
}
if(endpoint_desc != 0)
{
libusb_ss_endpoint_companion_descriptor *companion_desc;
// ctx is only used for error reporting, libusb should better ask for a libusb_device anyway...
r = libusb_get_ss_endpoint_companion_descriptor(NULL /* ctx */, endpoint_desc, &companion_desc);
if(r != LIBUSB_SUCCESS) continue;
r = companion_desc->wBytesPerInterval;
libusb_free_ss_endpoint_companion_descriptor(companion_desc);
break;
}
}
}
}
libusb_free_config_descriptor(config_desc);
return r;
}
std::shared_ptr<LibUSB::Configuration> LibUSB::DeviceImpl::getConfiguration( uint8_t ConfigValue )
{
// Check for an existing object.
if((m_ConfigurationMap.find(ConfigValue) != m_ConfigurationMap.end()) && (m_ConfigurationMap[ConfigValue].expired()))
{
return m_ConfigurationMap[ConfigValue].lock();
}
// Create a new configuration object
libusb_config_descriptor* pConfig = nullptr;
int Result = libusb_get_config_descriptor_by_value(m_pDevice.get(), ConfigValue, &pConfig);
if (Result != LIBUSB_SUCCESS)
{
std::stringstream exceptionText;
exceptionText << "libusb_get_config_descriptor() failed";
switch(Result)
{
case LIBUSB_ERROR_NOT_FOUND:
exceptionText << "(index " << (int)ConfigValue << ")";
break;
default:
break;
}
throw LibUSBException(exceptionText.str(), Result);
}
std::shared_ptr<ConfigurationImpl> pConfigImpl = std::make_shared<LibUSB::ConfigurationImpl>(pConfig, this->shared_from_this());
std::shared_ptr<Configuration> pConfigurationObj = std::make_shared<LibUSB::Configuration>(pConfigImpl);
// Save a weak_ptr to the configuration object to prevent duplication.
m_ConfigurationMap.insert(std::make_pair(ConfigValue, pConfigurationObj));
return pConfigurationObj;
}
/* Get cached extra descriptor from libusb for an interface
* Returns length of found descriptor */
int get_cached_extra_descriptor(struct libusb_device *dev,
uint8_t bConfValue,
uint8_t intf,
uint8_t desc_type, uint8_t desc_index,
unsigned char *resbuf, int res_len)
{
struct libusb_config_descriptor *cfg;
const unsigned char *extra;
int extra_len;
int ret;
int alt;
ret = libusb_get_config_descriptor_by_value(dev, bConfValue, &cfg);
if (ret == LIBUSB_ERROR_NOT_FOUND) {
fprintf(stderr, "Error: Device is unconfigured\n");
return -1;
} else if (ret) {
fprintf(stderr, "Error: failed "
"libusb_config_descriptor_by_value()\n");
exit(1);
}
/* Extra descriptors can be shared between alternate settings but
* libusb may attach them to one setting. Therefore go through all.
* Note that desc_index is per alternate setting, hits will not be
* counted from one to another */
for (alt = 0; alt < cfg->interface[intf].num_altsetting;
alt++) {
extra = cfg->interface[intf].altsetting[alt].extra;
extra_len = cfg->interface[intf].altsetting[alt].extra_length;
if (extra_len > 1)
ret = find_descriptor(extra, extra_len, desc_type,
desc_index, resbuf, res_len);
if (ret > 1)
break;
}
libusb_free_config_descriptor(cfg);
if (ret < 2 && verbose)
printf("Did not find cached descriptor\n");
return ret;
}
/**
* Open the device and init it
* You should call b96_init_usb() first before using this function
*
* @return the handler of the device
*/
libusb_device_handle* b96_init_device(void) {
libusb_device_handle *handler=NULL;
int r1;
int c1;
struct libusb_device_descriptor desc;
int i;
handler = libusb_open_device_with_vid_pid(libusb_ctx, 0x10d6, 0x10d6);
if (handler == NULL) {
error_at_line(0,0,__FILE__,__LINE__,"Error: cannot open device 10d6:10d6");
return handler;
}
r1 = libusb_get_device_descriptor(libusb_get_device(handler), &desc);
if (r1 != 0) {
error_at_line(0,0,__FILE__,__LINE__,"Error: cannot get device descriptor");
}
printf ("bDescriptorType: %d\n", desc.bDescriptorType);
printf ("bNumConfigurations: %d\n", desc.bNumConfigurations);
printf ("iManufacturer: %d\n", desc.iManufacturer);
for (i=1; i<=desc.bNumConfigurations; i++) {
struct libusb_config_descriptor *config=NULL;
int r2=0;
int j;
r2 = libusb_get_config_descriptor_by_value(libusb_get_device(handler), i, &config);
if (r2 != 0) {
error_at_line(0,0,__FILE__,__LINE__,"Error: cannot get configuration %d descriptor", i);
continue;
}
printf ("bNumInterfaces: %d\n", config->bNumInterfaces);
for (j=0; j<config->bNumInterfaces; j++) {
}
if (config != NULL) {
libusb_free_config_descriptor(config);
config=NULL;
}
}
r1 = libusb_detach_kernel_driver(handler, 0);
if (r1 != 0) {
const char *errorStr="unknown";
if (r1 == LIBUSB_ERROR_NOT_FOUND) {
errorStr = "LIBUSB_ERROR_NOT_FOUND (no worry)";
} else if (r1 == LIBUSB_ERROR_INVALID_PARAM) {
errorStr = "LIBUSB_ERROR_INVALID_PARAM";
} else if (r1 == LIBUSB_ERROR_NO_DEVICE) {
errorStr = "LIBUSB_ERROR_NO_DEVICE";
} else if (r1 == LIBUSB_ERROR_NOT_SUPPORTED) {
errorStr = "LIBUSB_ERROR_NOT_SUPPORTED";
}
error_at_line(0,0,__FILE__,__LINE__,"Info: cannot detach kernel driver: %s", errorStr);
}
c1 = 0;
r1 = libusb_get_configuration(handler, &c1);
if (r1 != 0) {
error_at_line(0,0,__FILE__,__LINE__,"Error: cannot get device configuration");
}
printf ("Configuiration: %d\n",c1);
r1 = libusb_set_configuration(handler, c1);
if (r1 != 0) {
error_at_line(0,0,__FILE__,__LINE__,"Error: cannot set device configuration");
}
r1 = libusb_claim_interface(handler, 0);
if (r1 != 0) {
error_at_line(0,0,__FILE__,__LINE__,"Error: cannot claim device interface");
}
return handler;
}
int ldm_init()
{
int ret=0, i=0;
struct libusb_device **devs=NULL;
struct libusb_device *dev;
struct libusb_device_handle *devhandle = NULL;
struct libusb_device_descriptor desc;
struct libusb_config_descriptor *conf_desc;
const struct libusb_interface *dev_interface;
const struct libusb_interface_descriptor *altsetting;
int scan_result = 0;
if (camera == NULL){
ret = init_libusb(&ctxt);
if (ret) {
TRACE("libusb_init failed\n");
return -1;
}
//scan and detect GEO devices
if (libusb_get_device_list(ctxt, &devs) < 0)
{
TRACE("libusb_get_device_list error\n");
return -1;
}
while ((dev = devs[i++]) != NULL) {
int data[2] = {-1, -1};
ret = libusb_get_device_descriptor(dev, &desc);
if (ret < 0)
continue;
ret = libusb_get_config_descriptor_by_value(dev, 1, &conf_desc);
if(ret < 0)
continue;
dev_interface = conf_desc->interface;
altsetting = dev_interface->altsetting;
/* We are only interested in devices whose first USB class is
* - a Vendor specific class
* - a UVC class
* */
if (altsetting->bInterfaceClass != VENDOR_SPECIFIC
&& altsetting->bInterfaceClass != CC_VIDEO) {
libusb_free_config_descriptor(conf_desc);
continue;
}
/* Open the device to communicate with it */
ret = libusb_open(dev, &devhandle);
if (ret < 0) {
continue;
}
ret = libusb_control_transfer(devhandle,
/* bmRequestType */
(LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR |
LIBUSB_RECIPIENT_INTERFACE),
/* bRequest */ CMD_WHO_R_U,
/* wValue */ 0,
/* MSB 4 bytes */
/* wIndex */ 0,
/* Data */ (unsigned char *)&data,
/* wLength */ 8,
/* timeout*/ LIBUSB_CMD_TIMEOUT
);
switch(data[0]) {
case MAX64380:
case MAX64480:
case MAX64580:
//got the Geo camera
scan_result = 1;
break;
default:
break;
}
if(scan_result == 1){
if(data[1] != 0)
scan_result = 0;
}
if(scan_result == 1)
break;
else
libusb_close(devhandle);
}
if(scan_result == 1)
camera = devhandle;
else {
TRACE("ERR: Opening camera failed\n");
return -1;
}
//camera = libusb_open_device_with_vid_pid(ctxt, 0x0b6a, 0x4d52);
if (camera == NULL) {
TRACE("ERR: Opening camera failed\n");
return -1;
}
TRACE("ldm init done\n");
}
unsigned int data[4] = {0};
// read csr registers
ret = ldm_qcc_read(QCC_BID_PMU, 0x08, 2, &data[0]);
ret = ldm_qcc_read(QCC_BID_PMC, 0x14, 1, &data[1]);
ret = ldm_qcc_read(QCC_BID_PMC, 0x15, 1, &data[2]);
ret = ldm_qcc_read(QCC_BID_PMC, 0x16, 1, &data[3]);
YUVUtil_Init2(data[0], data[1], data[2], data[3]);
int k, l, m;
for(k=0; k < NUM_MUX_VID_CHANNELS; k++)
{
for(l=0; l < NUM_OVERLAY_TEXT_IDX; l++)
{
chbidx[k][l] = 0;
}
for(m=0; m < NUM_OVERLAY_IMAGE_IDX; m++)
{
choidx[k][m] = 0;
}
}
return ret;
}
//-- private morpheus commands ---
static bool morpheus_open_usb_device(
MorpheusUSBContext *morpheus_context)
{
bool bSuccess = true;
if (libusb_init(&morpheus_context->usb_context) == LIBUSB_SUCCESS)
{
libusb_set_debug(morpheus_context->usb_context, 3);
}
else
{
SERVER_LOG_ERROR("morpeus_open_usb_device") << "libusb context initialization failed!";
bSuccess = false;
}
if (bSuccess)
{
morpheus_context->usb_device_handle =
libusb_open_device_with_vid_pid(
morpheus_context->usb_context,
MORPHEUS_VENDOR_ID, MORPHEUS_PRODUCT_ID);
if (morpheus_context->usb_device_handle == nullptr)
{
SERVER_LOG_ERROR("morpeus_open_usb_device") << "Morpheus USB device not found!";
bSuccess = false;
}
}
if (bSuccess)
{
libusb_device *device = libusb_get_device(morpheus_context->usb_device_handle);
int result = libusb_get_config_descriptor_by_value(
device,
MORPHEUS_CONFIGURATION_PSVR,
&morpheus_context->usb_device_descriptor);
if (result != LIBUSB_SUCCESS)
{
SERVER_LOG_ERROR("morpeus_open_usb_device") << "Failed to retrieve Morpheus usb config descriptor";
bSuccess = false;
}
}
for (int interface_index = 0;
bSuccess && interface_index < morpheus_context->usb_device_descriptor->bNumInterfaces;
interface_index++)
{
int mask = 1 << interface_index;
if (MORPHEUS_USB_INTERFACES_MASK_TO_CLAIM & mask)
{
int result = 0;
#ifndef _WIN32
result = libusb_kernel_driver_active(morpheus_context->usb_device_handle, interface_index);
if (result < 0)
{
SERVER_LOG_ERROR("morpeus_open_usb_device") << "USB Interface #"<< interface_index <<" driver status failed";
bSuccess = false;
}
if (bSuccess && result == 1)
{
SERVER_LOG_ERROR("morpeus_open_usb_device") << "Detach kernel driver on interface #" << interface_index;
result = libusb_detach_kernel_driver(morpheus_context->usb_device_handle, interface_index);
if (result != LIBUSB_SUCCESS)
{
SERVER_LOG_ERROR("morpeus_open_usb_device") << "Interface #" << interface_index << " detach failed";
bSuccess = false;
}
}
#endif //_WIN32
result = libusb_claim_interface(morpheus_context->usb_device_handle, interface_index);
if (result == LIBUSB_SUCCESS)
{
morpheus_context->usb_claimed_interface_mask |= mask;
}
else
{
SERVER_LOG_ERROR("morpeus_open_usb_device") << "Interface #" << interface_index << " claim failed";
bSuccess = false;
}
}
}
if (!bSuccess)
{
morpheus_close_usb_device(morpheus_context);
}
return bSuccess;
}
