/*
* Function usbobex_connect_request (self)
*
* Open the USB connection
*
*/
int usbobex_connect_request(obex_t *self)
{
int ret;
#ifndef _WIN32
DEBUG(4, "\n");
self->trans.self.usb.dev_control = usb_open(self->trans.self.usb.device);
self->trans.self.usb.dev_data = usb_open(self->trans.self.usb.device);
ret = usb_set_configuration(self->trans.self.usb.dev_control, self->trans.self.usb.configuration);
if (ret < 0) {
DEBUG(4, "Can't set configuration %d", ret);
}
ret = usb_claim_interface(self->trans.self.usb.dev_control, self->trans.self.usb.control_interface);
if (ret < 0) {
DEBUG(4, "Can't claim control interface %d", ret);
goto err1;
}
ret = usb_set_altinterface(self->trans.self.usb.dev_control, self->trans.self.usb.control_setting);
if (ret < 0) {
DEBUG(4, "Can't set control setting %d", ret);
goto err2;
}
ret = usb_claim_interface(self->trans.self.usb.dev_data, self->trans.self.usb.data_interface);
if (ret < 0) {
DEBUG(4, "Can't claim data interface %d", ret);
goto err2;
}
ret = usb_set_altinterface(self->trans.self.usb.dev_data, self->trans.self.usb.data_active_setting);
if (ret < 0) {
DEBUG(4, "Can't set data active setting %d", ret);
goto err3;
}
self->trans.mtu = OBEX_MAXIMUM_MTU;
DEBUG(2, "transport mtu=%d\n", self->trans.mtu);
return 1;
err3:
usb_release_interface(self->trans.self.usb.dev_data, self->trans.self.usb.data_interface);
err2:
usb_release_interface(self->trans.self.usb.dev_control, self->trans.self.usb.control_interface);
err1:
usb_close(self->trans.self.usb.dev_data);
usb_close(self->trans.self.usb.dev_control);
return ret;
#endif /* _WIN32 */
}
int gpio_usb_open(gpio_device *dev)
{
int ret;
dev->device_handle = usb_open(dev->settings.usb.udev);
if (!dev->device_handle)
return GPIO_ERROR;
ret = usb_set_configuration(dev->device_handle, dev->settings.usb.config);
if (ret < 0) {
fprintf(stderr, "gpio_usb_open: could not set config %d: %s\n",
dev->settings.usb.config, strerror(errno));
return GPIO_ERROR;
}
ret = usb_claim_interface(dev->device_handle, dev->settings.usb.interface);
if (ret < 0) {
fprintf(stderr, "gpio_usb_open: could not claim intf %d: %s\n",
dev->settings.usb.interface, strerror(errno));
return GPIO_ERROR;
}
ret = usb_set_altinterface(dev->device_handle, dev->settings.usb.altsetting);
if (ret < 0) {
fprintf(stderr, "gpio_usb_open: could not set intf %d/%d: %s\n",
dev->settings.usb.interface,
dev->settings.usb.altsetting, strerror(errno));
return GPIO_ERROR;
}
return GPIO_OK;
}
/*
* Function usbobex_disconnect_request (self)
*
* Shutdown the USB link
*
*/
int usbobex_disconnect_request(obex_t *self)
{
int ret;
if (self->trans.connected == FALSE)
return 0;
DEBUG(4, "\n");
usb_clear_halt(self->trans.self.usb.dev, self->trans.self.usb.data_endpoint_read);
usb_clear_halt(self->trans.self.usb.dev, self->trans.self.usb.data_endpoint_write);
ret = usb_set_altinterface(self->trans.self.usb.dev, self->trans.self.usb.data_idle_setting);
if (ret < 0) {
DEBUG(4, "Can't set data idle setting %d", ret);
}
ret = usb_release_interface(self->trans.self.usb.dev, self->trans.self.usb.data_interface);
if (ret < 0) {
DEBUG(4, "Can't release data interface %d", ret);
}
ret = usb_release_interface(self->trans.self.usb.dev, self->trans.self.usb.control_interface);
if (ret < 0) {
DEBUG(4, "Can't release control interface %d", ret);
}
ret = usb_close(self->trans.self.usb.dev);
if (ret < 0) {
DEBUG(4, "Can't close interface %d", ret);
}
return ret;
}
//---------------------------------------------------------------------------
// Attempt to acquire a 1-Wire net
//
// 'portnum' - number 0 to MAX_PORTNUM-1. This number is provided to
// indicate the symbolic port number.
// 'port_zstr' - zero terminated port name.
// 'return_msg' - zero terminated return message.
//
// Returns: TRUE - success, port opened
//
SMALLINT owAcquireUSB(int portnum, char *port_zstr, char *return_msg)
{
if (!initted_flag)
usb_ds2490_init();
/* check the port string */
if (strcmp (port_zstr, "USB")) {
strcpy(return_msg, "owAcquire called with invalid port string\n");
return 0;
}
/* check to see if the portnumber is valid */
if (usb_num_devices < portnum) {
strcpy(return_msg, "Attempted to select invalid port number\n");
return FALSE;
}
/* check to see if opening the device is valid */
if (usb_dev_handle_list[portnum] != NULL) {
strcpy(return_msg, "Device allready open\n");
return FALSE;
}
/* open the device */
usb_dev_handle_list[portnum] = usb_open(usb_dev_list[portnum]);
if (usb_dev_handle_list[portnum] == NULL) {
strcpy(return_msg, "Failed to open usb device\n");
printf("%s\n", usb_strerror());
return FALSE;
}
/* set the configuration */
if (usb_set_configuration(usb_dev_handle_list[portnum], 1)) {
strcpy(return_msg, "Failed to set configuration\n");
printf("%s\n", usb_strerror());
usb_close(usb_dev_handle_list[portnum]);
return FALSE;
}
/* claim the interface */
if (usb_claim_interface(usb_dev_handle_list[portnum], 0)) {
strcpy(return_msg, "Failed to claim interface\n");
printf("%s\n", usb_strerror());
usb_close(usb_dev_handle_list[portnum]);
return FALSE;
}
/* set the alt interface */
if (usb_set_altinterface(usb_dev_handle_list[portnum], 3)) {
strcpy(return_msg, "Failed to set altinterface\n");
printf("%s\n", usb_strerror());
usb_release_interface(usb_dev_handle_list[portnum], 0);
usb_close(usb_dev_handle_list[portnum]);
return FALSE;
}
/* we're all set here! */
strcpy(return_msg, "DS2490 successfully acquired by USB driver\n");
return TRUE;
}
/*
* Function usbobex_link_disconnect_request (self)
*
* Shutdown the USB link
*
*/
int usbobex_disconnect_request(obex_t *self)
{
int ret;
if (self->trans.connected == FALSE)
return 0;
#ifndef _WIN32
DEBUG(4, "\n");
ret = usb_set_altinterface(self->trans.self.usb.dev_data, self->trans.self.usb.data_idle_setting);
if (ret < 0)
DEBUG(4, "Can't set data idle setting %d", ret);
ret = usb_release_interface(self->trans.self.usb.dev_data, self->trans.self.usb.data_interface);
if (ret < 0)
DEBUG(4, "Can't release data interface %d", ret);
ret = usb_release_interface(self->trans.self.usb.dev_control, self->trans.self.usb.control_interface);
if (ret < 0)
DEBUG(4, "Can't release control interface %d", ret);
ret = usb_close(self->trans.self.usb.dev_data);
if (ret < 0)
DEBUG(4, "Can't close data interface %d", ret);
ret = usb_close(self->trans.self.usb.dev_control);
if (ret < 0)
DEBUG(4, "Can't close control interface %d", ret);
#endif /* _WIN32 */
return ret;
}
static int l_usb_set_altinterface(lua_State *L) {
struct usb_dev_handle * dev_handle = lua_touserdata(L, 1);
int alternate = lua_tonumber(L, 2);
int ret = usb_set_altinterface(dev_handle, alternate);
return (proccess_return_code(L, ret));
}
/* USB::DevHandle#usb_set_altinterface(alternate) */
static VALUE
rusb_set_altinterface(VALUE v, VALUE alternate)
{
usb_dev_handle *p = get_usb_devhandle(v);
int ret = usb_set_altinterface(p, NUM2INT(alternate));
check_usb_error("usb_set_altinterface", ret);
return Qnil;
}
int TCD2Usb::TCD2Usb_initialization(unsigned int vendor, unsigned int product)
{
// Initialize the USB library
usb_init();
// printf("TCD2Usb::TCD2Usb_initialization: USB library initilaized\n");
// Find the buses
if(usb_find_busses() < 0)
{
// printf("TCD2Usb::TCD2Usb_initialization: usb_find_busses failed \n");
return -TCD2USB_SYS_FIND_BUSSES_ERR;
}
// printf("TCD2Usb::TCD2Usb_initialization: USB system bus list updated\n");
// Find the devices
if(usb_find_devices() < 0)
{
// printf("TCD2Usb::TCD2Usb_initialization: usb_find_devices failed \n");
return -TCD2USB_SYS_FIND_DEVICES_ERR;
}
// printf("TCD2Usb::TCD2Usb_initialization: USB system device list updated\n");
// Assign the device to usbdev
if(!(usbdev=findDevice(vendor,product)))
{
// printf("TCD2Usb::TCD2Usb_initialization: No TCD2 USB device attached.\n");
return -TCD2USB_FIND_DEVICE_ERR;
}
// printf("TCD2Usb::TCD2Usb_initialization: TCD2 USB device found\n");
// printf("TCD2Usb::TCD2Usb_initialization: Using ID %04x:%04x on %s.%s.\n",usbdev->descriptor.idVendor,usbdev->descriptor.idProduct,usbdev->bus->dirname,usbdev->filename);
// Open the USB device
if( open() != 0 )
{
// printf("TCD2Usb::TCD2Usb_initialization: Open failed.\n");
return -TCD2USB_OPEN_ERR;
}
// printf("TCD2Usb::TCD2Usb_initialization: TCD2 USB device opened\n");
// Claim the interface (This is the only class using it after all, so why not claim it now?
if(claim_interface())
{
// printf("TCD2Usb::TCD2Usb_initialization: Failed to claim interface 0: %s\n",usb_strerror());
return -TCD2USB_CLAIM_ERR;
}
// Set the alternate interface
if(usb_set_altinterface(usbhdl,1)<0)
{
// printf("TCD2Usb::TCD2Usb_initialize: Failed to set altinterface 1: %s\n",usb_strerror());
return -TCD2USB_ALTINTERFACE_ERR;
}
// All's well!
return 0;
}
struct pegoda_handle *pegoda_open(void)
{
struct usb_device *pegoda;
unsigned char rbuf[16];
unsigned int rlen = sizeof(rbuf);
struct pegoda_handle *ph;
usb_init();
usb_find_busses();
usb_find_devices();
pegoda = find_device(USB_VENDOR_PHILIPS, USB_DEVICE_PEGODA);
if (!pegoda)
return NULL;
ph = malloc(sizeof(*ph));
if (!ph)
return NULL;
memset(ph, 0, sizeof(*ph));
printf("found pegoda, %u configurations\n",
pegoda->descriptor.bNumConfigurations);
printf("config 2 [nr %u] has %u interfaces\n",
pegoda->config[1].bConfigurationValue,
pegoda->config[1].bNumInterfaces);
printf("config 2 interface 0 has %u altsettings\n",
pegoda->config[1].interface[0].num_altsetting);
ph->handle = usb_open(pegoda);
if (!ph->handle)
goto out_free;
if (usb_set_configuration(ph->handle, 2))
goto out_free;
printf("configuration 2 successfully set\n");
if (usb_claim_interface(ph->handle, 0))
goto out_free;
printf("interface 0 claimed\n");
if (usb_set_altinterface(ph->handle, 1))
goto out_free;
printf("alt setting 1 selected\n");
pegoda_transceive(ph, PEGODA_CMD_PCD_CONFIG, NULL, 0, rbuf, &rlen);
return ph;
out_free:
free(ph);
return NULL;
}
static void set_altinterface( struct dfu_if *dif )
{
printf( "Setting Alternate Setting ...\n" );
if( usb_set_altinterface( dif->dev_handle, dif->altsetting ) < 0 ) {
fprintf( stderr, "Cannot set alternate interface: %s\n",
usb_strerror( ) );
exit( 1 );
}
}
/*
* Function usbfbus_connect_request (self)
*
* Open the USB connection
*
*/
static int usbfbus_connect_request(struct gn_statemachine *state)
{
int ret;
DEVINSTANCE(state)->interface->dev_data = usb_open(DEVINSTANCE(state)->interface->device);
ret = usb_set_configuration(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->configuration);
if (ret < 0) {
dprintf("Can't set configuration: %d\n", ret);
}
ret = usb_claim_interface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->control_interface);
if (ret < 0) {
dprintf("Can't claim control interface: %d\n", ret);
goto err1;
}
ret = usb_set_altinterface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->control_setting);
if (ret < 0) {
dprintf("Can't set control setting: %d\n", ret);
goto err2;
}
ret = usb_claim_interface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->data_interface);
if (ret < 0) {
dprintf("Can't claim data interface: %d\n", ret);
goto err2;
}
ret = usb_set_altinterface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->data_active_setting);
if (ret < 0) {
dprintf("Can't set data active setting: %d\n", ret);
goto err3;
}
return 1;
err3:
usb_release_interface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->data_interface);
err2:
usb_release_interface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->control_interface);
err1:
usb_close(DEVINSTANCE(state)->interface->dev_data);
return 0;
}
usb_dev_handle *m4Init() {
struct usb_bus *bus;
struct usb_device *dev;
usb_init();
if (usb_find_busses() < 0) {
return NULL;
}
if (usb_find_devices() < 0) {
return NULL;
}
bus = usb_get_busses();
while (bus) {
dev = bus->devices;
while (dev) {
if (dev->descriptor.idVendor == VENDOR &&
dev->descriptor.idProduct == PRODUCT) {
usb_dev_handle *handle = usb_open(dev);
if (handle) {
#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
/* Linux usually claims HID devices for its usbhid driver. */
usb_detach_kernel_driver_np(handle, 0);
#endif
if (usb_set_configuration(handle, 1) >= 0) {
if (usb_claim_interface(handle, 0) >= 0) {
if (usb_set_altinterface(handle, 0) < 0) {
usb_close(handle);
return NULL;
}
} else {
usb_close(handle);
return NULL;
}
} else {
usb_close(handle);
return NULL;
}
return handle;
}
}
dev = dev->next;
}
bus = bus->next;
}
return NULL;
}
int main(int argc, char* argv[]) {
usb_dev_handle* device;
#ifdef HAVE_GETEUID
if(geteuid() != 0) {
fprintf(stderr, "Must run as root\n");
return 1;
}
#endif
usb_init();
usb_find_busses();
usb_find_devices();
struct usb_bus *busses;
struct usb_bus *bus;
struct usb_device *dev;
busses = usb_get_busses();
int found = 0;
int c, i, a;
for(bus = busses; bus; bus = bus->next) {
for (dev = bus->devices; dev; dev = dev->next) {
/* Check if this device is a printer */
if (dev->descriptor.idVendor != APPLE_VENDOR_ID || dev->descriptor.idProduct != IPHONE_1_2_RECOVERY_PRODUCT_ID) {
continue;
}
goto done;
}
}
return 1;
done:
device = usb_open(dev);
usb_claim_interface(device, 1);
usb_set_altinterface(device, 1);
if(argc >= 2) {
if(strcmp(argv[1], "-i") == 0) {
interactive(device);
} else {
send_file(device, argv[1]);
send_command(device, "go\n");
}
} else {
printf("loadibec - Loads an iBEC img3 (such as openiboot.img3) into a phone in recovery mode. Use '-i' for interactive mode (buggy).\n");
printf("Usage: %s <-i|ibec.img3>", argv[0]);
}
return 0;
}
void USBDriver_Impl_Libusb::Close()
{
// never opened
if( m_pHandle == NULL )
return;
usb_set_altinterface( m_pHandle, 0 );
usb_reset( m_pHandle );
usb_close( m_pHandle );
m_pHandle = NULL;
}
usb_dev_handle *open_device (struct usb_device *dev) {
usb_dev_handle *hdl;
hdl = usb_open (dev);
int open_status = usb_set_configuration (hdl, 1);
open_status = usb_claim_interface (hdl, 0);
open_status = usb_set_altinterface (hdl, 0);
usb_control_msg(hdl, 0x40, 0x0c, 0x5003, 0x00f0, "\x10", 1, 1000);
usb_control_msg(hdl, 0x40, 0x0c, 0x5003, 0xffff, "\xd0", 1, 1000);
return hdl;
}
void USBDriver::Close()
{
// never opened
if( m_pHandle == NULL )
return;
LOG->Trace( "USBDriver::Close()" );
usb_set_altinterface( m_pHandle, 0 );
usb_reset( m_pHandle );
usb_close( m_pHandle );
m_pHandle = NULL;
}
int musb_set_altinterface(MUSB_INTERFACE *musb_interface, int index)
{
#if defined (HAVE_LIBUSB)
int status;
status = usb_set_altinterface(musb_interface->dev, index);
if (status < 0)
fprintf(stderr, "musb_set_altinterface: usb_set_altinterface() error %d\n", status);
return status;
#else
return -1;
#endif
}
int
usbSetAlternative (
UsbDevice *device,
unsigned char interface,
unsigned char alternative
) {
UsbDeviceExtension *devx = device->extension;
int result = usb_set_altinterface(devx->handle, alternative);
if (result >= 0) return 1;
errno = -result;
logSystemError("USB alternative set");
return 0;
}
int initialize_spectrometer()
{
char cmd;
/* Set up USB communication */
if (usb_set_configuration(handle, USB_CONFIGURATION) != 0) {
fprintf(stderr, "ERROR: Set configuration failed.\n");
return 1;
}
if (usb_claim_interface(handle, USB_INTERFACE) != 0) {
fprintf(stderr, "ERROR: Claim interface failed.\n");
return 1;
}
atexit(release_spectrometer_interface);
if (usb_set_altinterface(handle, USB_ALT_INTERFACE) != 0) {
fprintf(stderr, "ERROR: Set altinterface failed.\n");
return 1;
}
/* Clear halt status */
if (usb_clear_halt(handle, EP1Out) != 0) {
fprintf(stderr, "ERROR: Clear halt status on endpoint 1 out failed.\n");
return 1;
}
if (usb_clear_halt(handle, EP1In) != 0) {
fprintf(stderr, "ERROR: Clear halt status on endpoint 1 in failed.\n");
return 1;
}
if (usb_clear_halt(handle, EP2In) != 0) {
fprintf(stderr, "ERROR: Clear halt status on endpoint 2 in failed.\n");
return 1;
}
/* Initialise spectrometer */
cmd = 0x01;
if (usb_bulk_write(handle, EP1Out, &cmd, 1, TIMEOUT) != 1) {
fprintf(stderr, "ERROR: Initialise spectrometer failed.\n");
return 1;
}
return 0;
}
int
usbSetAlternative (
UsbDevice *device,
unsigned char interface,
unsigned char alternative
) {
UsbDeviceExtension *devx = device->extension;
int result;
logMessage(LOG_CATEGORY(USB_IO), "setting alternative: %u[%u]", interface, alternative);
result = usb_set_altinterface(devx->handle, alternative);
if (result >= 0) return 1;
errno = -result;
logSystemError("USB alternative set");
return 0;
}
int main (int argc,char **argv)
{
struct usb_dev_handle *pend_handle;
struct usb_device *pend_device;
int send_status;
int open_status;
unsigned char send_data=0xff;
unsigned char receive_data=0;
usb_init();
//usb_set_debug(2);
if ((pend_handle = locate_pend())==0)
{
printf("Could not open the PEN_DRIVE device\n");
return (-1);
}
open_status = usb_set_configuration(pend_handle,1);
printf("conf_stat=%d\n",open_status);
open_status = usb_claim_interface(pend_handle,0);
printf("claim_stat=%d\n",open_status);
open_status = usb_set_altinterface(pend_handle,0);
printf("alt_stat=%d\n",open_status);
send_status=usb_bulk_write(pend_handle,4,&send_data,1,500);
printf("TX stat=%d\n",send_status);
usb_bulk_read(pend_handle,3,&receive_data,1,500);
printf("RX stat=%d -> RX char=%d\n",send_status,receive_data);
/* Write the data2send bytes to the 7-segs */
/* send_status = usb_control_msg(pend_handle,0x20,0x09,0x0200,0x0001,send_data,2,500);
printf("TX stat=%d\n",send_status);
usleep(10000);
*/
/* Read the bytes that were just sent to the 7-segs */
/*
send_status = usb_control_msg(pend_handle,0xA0,0x01,0x0100,0x0001,receive_data,2,500);
printf("RX stat=%d data=0x%x,0x%x\n",send_status,receive_data[0],receive_data[1]);
usleep(10000);
*/
usb_close(pend_handle);
}
static int
bulk_init(const char *device)
{
struct usb_bus *bus;
struct usb_device *dev;
usb_init();
if (verbose)
usb_set_debug(verbose);
usb_find_busses();
usb_find_devices();
xsv_handle = NULL;
for (bus = usb_busses; bus; bus = bus->next) {
for (dev = bus->devices; dev; dev = dev->next) {
if (device && strcmp(dev->filename, device) != 0)
continue;
if (dev->descriptor.idVendor == 0x2207 &&
(dev->descriptor.idProduct == 0x290a ||
dev->descriptor.idProduct == 0x292a ||
dev->descriptor.idProduct == 0x281a)) {
xsv_handle = usb_open(dev);
if (verbose) {
printf("using rockchip device @ %s\n",
dev->filename);
}
break;
}
}
}
if (xsv_handle) {
usb_set_configuration(xsv_handle,1);
usb_claim_interface(xsv_handle,0);
usb_set_altinterface(xsv_handle,0);
return 0;
} else {
return -1;
}
}
static struct usb_dev_handle *openinterface(
char *errstr,
int errlen,
struct usb_device *thedev,
int altif) {
struct usb_dev_handle *usbhandle;
int n;
int confignum = 1; /* 1 for fx2. Cfg# nearly always 1: /proc/bus/usb/devices */
int intfcnum = 0; /* Nearly always 0. A few devices have multiple: not handled yet. */
errstr[0] = '\0';
// mexPrintf("Opening handle\n");
usbhandle = usb_open( thedev );
// mexPrintf("handle 0x%x\n",(UINT32_T)usbhandle);
if(usbhandle == NULL) {
snprintf(errstr,errlen,"usb_open failed");
return usbhandle;
}
if(confignum>=0) n = usb_set_configuration(usbhandle,confignum);
else n = 0;
if(n<0) {
snprintf(errstr,errlen,"usb_set_configuration %d failed",confignum);
usb_close(usbhandle);
// mexPrintf("Device closed\n");
usbhandle = (struct usb_dev_handle *)0;
} else {
n = usb_claim_interface(usbhandle,intfcnum);
if(n<0) {
snprintf(errstr,errlen,"usb_claim_interface %d failed\n",intfcnum);
usb_close(usbhandle);
// mexPrintf("Device closed\n");
usbhandle = (struct usb_dev_handle *)0;
} else if(altif>=0) {
n = usb_set_altinterface(usbhandle,altif);
if(n<0) {
snprintf(errstr,errlen,"usb_set_altinterface %d failed\n",altif);
usb_close(usbhandle);
// mexPrintf("Device closed\n");
usbhandle = (struct usb_dev_handle *)0;
}
}
}
return usbhandle;
}
usb_dev_handle *canon_open_camera(void)
{
struct usb_device *camera;
usb_dev_handle *camera_handle;
/* intialize USB library */
usb_init();
usb_find_busses();
usb_find_devices();
/* search the USB bus for the appropriate camera */
fprintf(stderr, "Searching for Canon Powershot S40 camera... ");
camera = find_usb_device(CANON_S40_VENDOR, CANON_S40_PRODUCT);
if(camera == NULL) {
fprintf(stderr, "not found.\n");
return NULL;
}
else
fprintf(stderr, "found.\n");
/* claim the camera on the USB bus */
fprintf(stderr, "Opening connection to camera... ");
camera_handle = usb_open(camera);
if(camera_handle == NULL) {
fprintf(stderr, "failed.\n");
return NULL;
}
else
fprintf(stderr, "done.\n");
if(usb_claim_interface(camera_handle, 0) < 0) {
fprintf(stderr, "Error: could not claim USB interface to camera.\n");
return NULL;
}
if(usb_set_configuration(camera_handle, 1) < 0) {
fprintf(stderr, "Error: could not set configuration.\n");
return NULL;
}
if(usb_set_altinterface(camera_handle, 0) < 0) {
fprintf(stderr, "Error: could not set altinterface.\n");
return NULL;
}
return camera_handle;
}
bool IdacUsb::claim()
{
CHECK_PRECOND_RETVAL(!m_bClaimed, false);
int res;
/*
quint8 data[18];
res = usb_control_msg(m_handle, 0x80, 0x06, 0x0100, 0x0000, (char*) &data, 18, 5000);
if (res >= 0)
{
for (int i = 0; i < 18; i += 2)
std::cerr << qPrintable(QString("%0 ").arg((int)data[0], 16));
std::cerr << std::endl;
}
*/
int idConfiguration = m_dev->config[0].bConfigurationValue;
res = usb_set_configuration(m_handle, idConfiguration);
if (res < 0)
return false;
int idInterface = m_dev->config[0].interface[0].altsetting[0].bInterfaceNumber;
res = usb_claim_interface(m_handle, idInterface);
if (res < 0)
return false;
usb_interface_descriptor* setting = &m_dev->config[0].interface[0].altsetting[0];
res = usb_set_altinterface(m_handle, setting->bAlternateSetting);
if (res < 0)
return false;
for (int iPipe = 0; iPipe < setting->bNumEndpoints; iPipe++)
{
int idPipe = setting->endpoint[iPipe].bEndpointAddress;
res = usb_clear_halt(m_handle, idPipe);
}
m_bClaimed = true;
m_driver = new IdacUsbDriver4(this);
return m_driver->boot();
}
/*
* Function usbfbus_link_disconnect_request (self)
*
* Shutdown the USB link
*
*/
static int usbfbus_disconnect_request(struct gn_statemachine *state)
{
int ret;
if (state->device.fd < 0)
return 0;
ret = usb_set_altinterface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->data_idle_setting);
if (ret < 0)
dprintf("Can't set data idle setting %d\n", ret);
ret = usb_release_interface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->data_interface);
if (ret < 0)
dprintf("Can't release data interface %d\n", ret);
ret = usb_release_interface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->control_interface);
if (ret < 0)
dprintf("Can't release control interface %d\n", ret);
ret = usb_close(DEVINSTANCE(state)->interface->dev_data);
if (ret < 0)
dprintf("Can't close data interface %d\n", ret);
return ret;
}
int main (int argc,char **argv)
{
struct usb_dev_handle *usbprog_handle;
struct usb_device *usbprog_device;
int send_status;
int open_status;
unsigned char send_data[10000];
unsigned char receive_data[64];
usb_init();
usb_set_debug(2);
if ((usbprog_handle = locate_usbprog())==0)
{
printf("Could not open the USBprog device\n");
return (-1);
}
open_status = usb_set_configuration(usbprog_handle,1);
printf("conf_stat=%d\n",open_status);
open_status = usb_claim_interface(usbprog_handle,0);
printf("claim_stat=%d\n",open_status);
open_status = usb_set_altinterface(usbprog_handle,0);
printf("alt_stat=%d\n",open_status);
int k;
for(k=0;k<10000;k++)
send_data[k]=(unsigned char)k;
send_data[0] = 0x77;
send_data[1] = 0x88;
usb_bulk_write(usbprog_handle,2,send_data,320,500);
usb_bulk_read(usbprog_handle,2,receive_data,320,500);
usb_close(usbprog_handle);
}
struct vport* vport_open()
{
struct usb_bus *busses;
struct usb_dev_handle* usb_handle;
struct usb_bus *bus;
struct usb_device *dev;
struct vport * tmp;
tmp = (struct vport*)malloc(sizeof(struct vport));
usb_init();
usb_find_busses();
usb_find_devices();
busses = usb_get_busses();
/* find vport device in usb bus */
for (bus = busses; bus; bus = bus->next)
{
for (dev = bus->devices; dev; dev = dev->next)
{
/* condition for sucessfully hit (too bad, I only check the vendor id)*/
if (dev->descriptor.idVendor == 0x0400)
{
tmp->usb_handle = usb_open(dev);
usb_set_configuration (tmp->usb_handle,dev->config[0].bConfigurationValue);
usb_claim_interface(tmp->usb_handle, 0);
usb_set_altinterface(tmp->usb_handle,0);
return tmp;
}
}
}
return 0;
}
VScope* openVScope()
{
unsigned char located = 0;
struct usb_bus *bus;
struct usb_device *dev;
VScope *tmp = (VScope*)malloc(sizeof(VScope));
tmp->vscope_handle=0;
//usb_set_debug(2);
usb_init();
usb_find_busses();
usb_find_devices();
for (bus = usb_busses; bus; bus = bus->next)
{
for (dev = bus->devices; dev; dev = dev->next)
{
if (dev->descriptor.idVendor == 0x0400)
{
located++;
tmp->vscope_handle = usb_open(dev);
}
}
}
if (tmp->vscope_handle==0) return (0);
else
{
//printf("found\n");
usb_set_configuration(tmp->vscope_handle,1);
usb_claim_interface(tmp->vscope_handle,0);
usb_set_altinterface(tmp->vscope_handle,0);
return (tmp);
}
}
/*
* Callback that is called by usb_device_open() that handles USB device
* settings prior to accepting the devide. At the very least claim the
* device here. Detaching the kernel driver will be handled by the
* caller, don't do this here. Return < 0 on error, 0 or higher on
* success.
*/
static int driver_callback(usb_dev_handle *handle, USBDevice_t *device)
{
if (usb_set_configuration(handle, 1) < 0) {
upsdebugx(5, "Can't set USB configuration");
return -1;
}
if (usb_claim_interface(handle, 0) < 0) {
upsdebugx(5, "Can't claim USB interface");
return -1;
}
if (usb_set_altinterface(handle, 0) < 0) {
upsdebugx(5, "Can't set USB alternate interface");
return -1;
}
if (usb_clear_halt(handle, 0x81) < 0) {
upsdebugx(5, "Can't reset USB endpoint");
return -1;
}
return 1;
}
