int main(int argc, char **argv) { unsigned int count = 0U, removed = 0U; struct usb_bus *bus; struct usb_device *dev; static usb_dev_handle *handle; char name[256]; usb_init(); usb_find_busses(); usb_find_devices(); for (bus = usb_get_busses(); bus != NULL; bus = bus->next) { for (dev = bus->devices; dev != NULL; dev = dev->next) { if (dev->descriptor.idVendor == C108_VENDOR_ID && (dev->descriptor.idProduct == C108_PRODUCT_ID || dev->descriptor.idProduct == C108AH_PRODUCT_ID || dev->descriptor.idProduct == C119_PRODUCT_ID)) { count++; if ((handle = usb_open(dev)) == NULL) { fprintf(stderr, "rmuridrv: cannot open the USB device: %s\n", usb_strerror()); continue; } memset(name, 0, 256); if (usb_get_driver_np(handle, CM108_INTERFACE, name, 256) == 0) { if (strcmp(name, "usbhid") == 0) { if (usb_detach_kernel_driver_np(handle, CM108_INTERFACE) == 0) removed++; else fprintf(stderr, "rmuridrv: could not disconnect from usbhid: %s\n", usb_strerror()); } } usb_close(handle); } } } fprintf(stdout, "rmuridrv: found %u CM108 devices and removed %u from the usbhid driver\n", count, removed); return 0; }
struct usb_dev_handle * open_port() { struct usb_bus *busses, *bus; usb_init(); usb_find_busses(); usb_find_devices(); busses = usb_get_busses(); for (bus = busses; bus; bus = bus->next) { struct usb_device *dev; for (dev = bus->devices; dev; dev = dev->next) { //printf("idVendor:0x%x\t,ipProduct:0x%x\n", dev->descriptor.idVendor, dev->descriptor.idProduct); if (VENDOR_ID == dev->descriptor.idVendor && PRODUCT_ID == dev->descriptor.idProduct) { printf("Target usb device found!\n"); struct usb_dev_handle *hdev = usb_open(dev); if (!hdev) { perror("Cannot open device"); } else { if (0 != usb_claim_interface(hdev, 0)) { perror("Cannot claim interface"); usb_close(hdev); hdev = NULL; } } return hdev; } } } printf("Target usb device not found!\n"); return NULL; }
int main (int argc, const char **argv) { int r = 0; struct usb_device *dev; struct usb_dev_handle *handle; printf("CC1800 usbtool v1.0.0 by Ignacio Garcia Perez <*****@*****.**>\n"); if (argc < 2) { fputs(help, stderr); return 1; } dev = cc1800_find(); if (dev == NULL) { fprintf(stderr, "ERROR: cannot find CC1800 device\n"); return 1; } printf("Found device %s at bus %s\n", dev->filename, dev->bus->dirname); handle = usb_open(dev); if (handle == NULL) { fprintf(stderr, "ERROR: cannot open device (%s)\n", strerror(errno)); return 1; } r = usb_set_configuration(handle, 1); if (r < 0) fprintf(stderr, "ERROR: cannot set configuration\n"); else { r = usb_claim_interface(handle, 0); if (r < 0) fprintf(stderr, "ERROR: cannot claim interface\n"); else r = cc1800_fiddle(handle, argc, argv); } usb_close(handle); return r; }
struct usb_device * find_dev(void) { struct usb_bus *bus; struct usb_device *dev; struct usb_dev_handle *handle; char man[40]; char prod[40]; usb_find_busses(); usb_find_devices(); for(bus = usb_get_busses(); bus; bus = bus->next) { for(dev = bus->devices; dev; dev = dev->next) { /* Check for ST Microelectronics vendor ID */ if ((dev->descriptor.idVendor != 0x483) && (dev->descriptor.idVendor != 0x1d50)) continue; handle = usb_open(dev); usb_get_string_simple(handle, dev->descriptor.iManufacturer, man, sizeof(man)); usb_get_string_simple(handle, dev->descriptor.iProduct, prod, sizeof(prod)); #if 0 printf("%s:%s [%04X:%04X] %s : %s\n", bus->dirname, dev->filename, dev->descriptor.idVendor, dev->descriptor.idProduct, man, prod); #endif usb_close(handle); if (((dev->descriptor.idProduct == 0x5740) || (dev->descriptor.idProduct == 0x6018)) && !strcmp(man, "Black Sphere Technologies")) return dev; if (((dev->descriptor.idProduct == 0xDF11) || (dev->descriptor.idProduct == 0x6017)) && !strcmp(man, "Black Sphere Technologies")) return dev; } } return NULL; }
static int open_device(struct bslhid_transport *tr, struct usb_device *dev) { if (find_interface(tr, dev) < 0) return -1; printc_dbg("Opening interface %d (config %d)...\n", tr->int_number, tr->cfg_number); if (find_endpoints(tr, dev) < 0) return -1; printc_dbg("Found endpoints: IN: 0x%02x, OUT: 0x%02x\n", tr->in_ep, tr->out_ep); tr->handle = usb_open(dev); if (!tr->handle) { pr_error("bslhid: can't open device"); return -1; } #ifdef __Windows__ if (usb_set_configuration(tr->handle, tr->cfg_number) < 0) pr_error("warning: bslhid: can't set configuration"); #endif #ifdef __linux__ if (usb_detach_kernel_driver_np(tr->handle, tr->int_number) < 0) pr_error("warning: bslhid: can't detach kernel driver"); #endif if (usb_claim_interface(tr->handle, tr->int_number) < 0) { pr_error("bslhid: can't claim interface"); usb_close(tr->handle); return -1; } /* Save the bus path for a future suspend/resume */ strncpy(tr->bus_name, dev->bus->dirname, sizeof(tr->bus_name)); tr->bus_name[sizeof(tr->bus_name) - 1] = 0; return 0; }
/* * 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; }
static int load_from_usb(unsigned *_len, struct usb *usb) { unsigned len, n; enable_irqs(); usb_queue_read(usb, &len, 4); usb_write(usb, &MSG, 4); n = usb_wait_read(usb); if (n) return -1; if (usb_read(usb, (void*) CONFIG_ADDR_DOWNLOAD, len)) return -1; usb_close(usb); disable_irqs(); *_len = len; return 0; }
static void vsllink_usb_close(struct vsllink *vsllink) { int ret; ret = usb_release_interface(vsllink->usb_handle, versaloon_interface.usb_setting.interface); if (ret != 0) { LOG_ERROR("fail to release interface %d, %d returned", versaloon_interface.usb_setting.interface, ret); exit(-1); } ret = usb_close(vsllink->usb_handle); if (ret != 0) { LOG_ERROR("fail to close usb, %d returned", ret); exit(-1); } free(vsllink); }
static void usbdev_close(union filedescriptor *fd) { usb_dev_handle *udev = (usb_dev_handle *)fd->usb.handle; if (udev == NULL) return; (void)usb_release_interface(udev, usb_interface); #if defined(__linux__) /* * Without this reset, the AVRISP mkII seems to stall the second * time we try to connect to it. This is not necessary on * FreeBSD. */ usb_reset(udev); #endif usb_close(udev); }
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); }
usb_dev_handle *usb_check_device(struct usb_device *dev, char *vendor_name, char *product_name, char *serial) { usb_dev_handle *handle = usb_open(dev); if(!handle) { fprintf(stderr, "Warning: cannot open USB device: %s\n", usb_strerror()); return NULL; } if ( usb_match_string(handle, dev->descriptor.iManufacturer, vendor_name) && usb_match_string(handle, dev->descriptor.iProduct, product_name) && usb_match_string(handle, dev->descriptor.iSerialNumber, serial) ) { return handle; } usb_close(handle); return NULL; }
/* ** **rfidtag close - power down reader and close usb communication ** **LOCKED IN */ int rfidtag_close (void) { int i = 0; for (i = 0; i < numtagreaders; i++) { if (rfidtag_xchange (rfid_dev[i], power_down, sizeof (power_down), recvbuf, sizeof (recvbuf)) < 0) { perror ("xchange"); } //printf("closing[%d]\n\n", i+1); if (usb_close (rfid_dev[i]) < 0) { perror ("usb_close"); return (-1); } } return (0); }
static int usb_get_device_desc(struct usb_device *dev) { struct usb_dev_handle *hnd = usb_open(dev); if (!hnd) return 1; ULONG actlen = 0; if (!WinUsb_GetDescriptor(hnd->fd, USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, (unsigned char*)&dev->descriptor, sizeof(dev->descriptor), &actlen) || actlen != sizeof(dev->descriptor)) { return 1; } // Descriptor as read from the device is in little-endian format. No need // to convert since this is guaranteed to be Windows which runs only on // little-endian processors. return usb_close(hnd); }
int ftdibb_reset(usb_dev_handle *dev_handle,unsigned char what) { unsigned short value; // lower 8 byte is bitmask, //Set Bit Bang Mode //40 -> bmRequestType //0 -> bmRequest //what -> lValue, what=0->reset sio,1 purge Rx, 2 purge Tx //0 -> hValue // index: 0 = default(sioA, 1 sioA, 2 sioB, 3 parallel // rest is zero //This resets the communication port value=what & 0x3; if (usb_control_msg(dev_handle, 0x40, 0, value, 0, NULL, 0, 4000) != 0){ usb_close (dev_handle); fprintf(stderr,"ftdibb error: can not execute a reset. Not a ftdi BM chip??\n"); return(-1); // bitbang init fail } return(0); }
void close_usb_dev(struct usb_dev_handle *devh) { #if defined(__linux) #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) && LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,10) #define DO_USB_RESET #endif #endif #ifdef DO_USB_RESET /* On Linux 2.6 before 2.6.11, using usb_reset() here significantly speeds * up reconnection. */ usb_reset(devh); #else if (usb_release_interface(devh, 0)) { fprintf(stderr, "usb_release_interface returned an error!\n"); } usb_close(devh); #endif }
// Disconnects from the device via USB // Inputs // - dh : USB device handle // Returns // - 1 : operation succeeded // - 0 : operation failed int disconnect_device(usb_dev_handle * dh) { int success = 1; // Release interface 0x00 if (usb_release_interface(dh, 0x00)) { success = 0; fprintf(stderr, "disconnect: Release interface failed 0x00\n"); } // Close the device if (usb_close(dh)) { success = 0; fprintf(stderr, "disconnect: Close device failed"); } // Return disconnect status return success; }
int close(int fd) { static int (*func) (int) = NULL; if (!func) func = (int (*) (int)) dlsym(RTLD_NEXT, "close"); if (fd == windrvrfd && windrvrfd >= 0) { DPRINTF("close windrvrfd\n"); if (usbinterface >= 0) usb_release_interface(usb_devhandle, usbinterface); if (usb_devhandle) usb_close(usb_devhandle); usb_devhandle = NULL; usbinterface = -1; windrvrfd = -1; } return (*func) (fd); }
int main(void) { struct usb_dev_handle *myhandle; myhandle = find_rl78(); if (myhandle != NULL) { fd_set s_rd; struct timeval delay; char ch, ch2; configure_rl78(myhandle); configure_screen(); while (ch != EOF && ch != CONTROL('d')) { delay.tv_sec = 0; delay.tv_usec = 0; FD_ZERO(&s_rd); FD_SET(fileno(stdin), &s_rd); select(fileno(stdin)+1, &s_rd, NULL, NULL, &delay); if (FD_ISSET (fileno(stdin), &s_rd)) { ch=getch(); if (ch != EOF && ch != CONTROL('d')) rl78_write(myhandle, &ch, 1, 100); } int ret = rl78_read(myhandle, &ch2, 1, 50); if (ret >= 0) { putchar (ch2); } } usb_close(myhandle); endwin(); } return 0; }
int main(int argc, char **argv) { usb_dev_handle *handle = NULL; unsigned char buffer[8]; int nBytes; usb_init(); if(usbOpenDevice(&handle, USBDEV_SHARED_VENDOR, 0, USBDEV_SHARED_PRODUCT, 0) != 0){ fprintf(stderr, "Could not find USB device \"PowerSwitch\" with vid=0x%x pid=0x%x\n", USBDEV_SHARED_VENDOR, USBDEV_SHARED_PRODUCT); exit(1); } /* We have searched all devices on all busses for our USB device above. Now * try to open it and perform the vendor specific control operations for the * function requested by the user. */ DWORD time = GetTickCount(); int count = 1000; for(int i=0;i<count;i++) { nBytes = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, 0, 0, 0, (char *)buffer, sizeof(buffer), 5000); if(nBytes < 2){ if(nBytes < 0) fprintf(stderr, "USB error: %s\n", usb_strerror()); fprintf(stderr, "only %d bytes received in iteration %d\n", nBytes, i); continue; } std::cout << (char *)buffer << std::endl; } time = GetTickCount()-time; std::cout << (float)count*8 / time * 1000.f << std::endl; std::ofstream file("123.txt"); file << time; printf("test succeeded\n"); usb_close(handle); system("pause"); return 0; }
static int _command_start(usb_handle *usb, const char *cmd, unsigned size, char *response) { int cmdsize = strlen(cmd); if(response) { response[0] = 0; } if(cmdsize > 64) { sprintf(ERROR,"command too large"); return -1; } if(usb_write(usb, cmd, cmdsize) != cmdsize) { sprintf(ERROR,"command write failed (%s)", strerror(errno)); usb_close(usb); return -1; } return check_response(usb, size, response); }
static void aspspi_close(PROGRAMMER * pgm) { if (verbose > 2) fprintf(stderr, "%s: aspspi_close()\n", progname); if (PDATA(pgm)->usbhandle!=NULL) { unsigned char temp[4] = {0, 0, 0, 0}; aspspi_transmit(pgm, 1, USBASP_FUNC_DISCONNECT, temp, temp, sizeof(temp)); #ifdef USE_LIBUSB_1_0 libusb_close(PDATA(pgm)->usbhandle); #else usb_close(PDATA(pgm)->usbhandle); #endif } #ifdef USE_LIBUSB_1_0 libusb_exit(ctx); #else /* nothing for usb 0.1 ? */ #endif }
/// \brief Disconnect the device. void Device::disconnect() { if(!this->handle) return; // Release claimed interface #if LIBUSB_VERSION == 0 usb_release_interface(this->handle, this->interface); #else libusb_release_interface(this->handle, this->interface); #endif this->interface = -1; // Close device handle #if LIBUSB_VERSION == 0 usb_close(this->handle); #else libusb_close(this->handle); #endif this->handle = 0; emit disconnected(); }
void process_device(int argc, char **argv, struct usb_device *dev, struct usb_config_descriptor *cfg, int itfnum) { int mac[6]; usb_dev_handle *devh = usb_open(dev); if ( ! devh ) fatal("usb_open"); usb_detach_kernel_driver_np(devh, itfnum); int res = usb_claim_interface(devh, itfnum); if ( res < 0 ) fatal("usb_claim_interface"); show_master(devh, itfnum); if ( argc >= 2 ) { if ( sscanf(argv[1], "%x:%x:%x:%x:%x:%x", &mac[0],&mac[1],&mac[2],&mac[3],&mac[4],&mac[5]) != 6 ) { printf("usage: %s [<bd_addr of master>]\n", argv[0]); exit(1); } } else { FILE *f = popen("hcitool dev", "r"); if ( !f || fscanf(f, "%*s\n%*s %x:%x:%x:%x:%x:%x", &mac[0],&mac[1],&mac[2],&mac[3],&mac[4],&mac[5]) != 6 ) { printf("Unable to retrieve local bd_addr from `hcitool dev`.\n"); printf("Please enable Bluetooth or specify an address manually.\n"); exit(1); } pclose(f); } set_master(devh, itfnum, mac); usb_reset(devh); usb_release_interface(devh, itfnum); usb_close(devh); }
int main(int argc, char **argv) { int status; int pollcount; if (argc < 1) { fprintf(stderr, "not enough arguments\n"); usage(argc, argv); } handle = usb_open(&usb_match_func); if (!handle) { fprintf(stderr, "couldn't open device\n"); return 1; } printf("got handle %p\n", handle); #if 0 static char buf[4096]; int ret = usb_read_sync(handle, 0x1, buf, sizeof(buf), 1000); printf("usb_read_sync returns %d\n", ret); #endif #if 1 static char buf[4095]; for (int i = 0; i < sizeof(buf); i++) buf[i] = i; int ret = usb_write_sync(handle, 0x1, buf, sizeof(buf), 5000); printf("usb_write_sync returns %d\n", ret); ret = usb_write_sync(handle, 0x1, buf, sizeof(buf), 5000); printf("usb_write_sync returns %d\n", ret); #endif usb_close(handle); return 0; }
int claim_interface(int num){ int claimed = -1; //do stuff claimed = usb_claim_interface(launcher, num); printf("Interface %d claimed with %d\n", num, claimed); //usb_detach_kernel_driver_np(launcher, 1); //usb_detach_kernel_driver_np(launcher, 0); printf("%d <= 0: %s\n", claimed, claimed <= 0); if (claimed <= 0) { printf("Preparing to release interface %d\n", num); usb_release_interface(launcher, num); printf("Couldn't claim interface %d \n", num); usb_close(launcher); return 1; } else if (claimed > 0){ printf("Claimed interface %d \n", num); } return 0; }
/* deinitialize driver -- returns 1 on success, 0 on error */ static int dfc_deinit() { int err = 0; if (dev_handle) { if (usb_close(dev_handle) < 0) err = 1; dev_handle = NULL; } if (hw.fd >= 0) { if (close(hw.fd) < 0) err = 1; hw.fd = -1; } if (child > 1) { if ((kill(child, SIGTERM) == -1) || (waitpid(child, NULL, 0) == 0)) err = 1; } return !err; }
bool IdacUsb::findIdac() { if (m_handle != NULL) { usb_close(m_handle); m_dev = NULL; m_handle = NULL; } bool bFound = false; for (struct usb_bus* bus = usb_busses; bus && !bFound; bus = bus->next) { if (bus->root_dev) bFound = findIdac(bus->root_dev); else { struct usb_device *dev; for (dev = bus->devices; dev && !bFound; dev = dev->next) { bFound = findIdac(dev); } } } return bFound; }
/** * Close the driver (do necessary clean-up). * \param p Pointer to driver's private data structure. */ void usb4all_HD44780_close(PrivateData *p) { if (p->usbHandle != NULL) { if (p->have_backlight) { usb4all_HD44780_backlight(p, BACKLIGHT_OFF); } usb_close(p->usbHandle); p->usbHandle = NULL; } if (p->tx_buf.buffer != NULL) { free(p->tx_buf.buffer); p->tx_buf.buffer = NULL; } if (p->rx_buf.buffer != NULL) { free(p->rx_buf.buffer); p->rx_buf.buffer = NULL; } }
int jtag_libusb_open(const uint16_t vids[], const uint16_t pids[], const char *serial, struct jtag_libusb_device_handle **out) { int retval = -ENODEV; struct jtag_libusb_device_handle *libusb_handle; usb_init(); usb_find_busses(); usb_find_devices(); struct usb_bus *busses = usb_get_busses(); for (struct usb_bus *bus = busses; bus; bus = bus->next) { for (struct usb_device *dev = bus->devices; dev; dev = dev->next) { if (!jtag_libusb_match(dev, vids, pids)) continue; libusb_handle = usb_open(dev); if (NULL == libusb_handle) { retval = -errno; continue; } /* Device must be open to use libusb_get_string_descriptor_ascii. */ if (serial != NULL && !string_descriptor_equal(libusb_handle, dev->descriptor.iSerialNumber, serial)) { usb_close(libusb_handle); continue; } *out = libusb_handle; retval = 0; break; } } return retval; }
uint8_t open_usb(usb_dev_handle **handle) { uint16_t vid = USB_VID; uint16_t pid = USB_PID; char vendor[256]; char product[256]; struct usb_bus *bus; struct usb_device *dev; usb_dev_handle *target = NULL; usb_init(); usb_find_busses(); usb_find_devices(); for (bus=usb_get_busses(); bus; bus=bus->next) { for (dev=bus->devices; dev; dev=dev->next) { if (dev->descriptor.idVendor == vid && dev->descriptor.idProduct == pid) { target = usb_open(dev); if (target) { usb_get_string_simple(target, dev->descriptor.iManufacturer, vendor, sizeof(vendor)); usb_get_string_simple(target, dev->descriptor.iProduct, product, sizeof(product)); if (strcmp(vendor, V_NAME) == 0 && strcmp(product, P_NAME) == 0) { /* we found our device */ break; } } usb_close(target); target = NULL; } } } if (target != NULL) { usb_claim_interface(target, 0); *handle = target; return 1; } else { return 0; } }