/* * 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; }