void lamp_shutdown(){
int ret = usb_release_interface(launcher, 0);
printf("Released interface 0: %d\n", ret);
ret = usb_release_interface(launcher, 1);
printf("Released interface 1: %d\n", ret);
usb_close(launcher);
}
int main(void)
{
struct usb_device *dev;
usb_dev_handle *handle;
uint16_t iface;
int state;
uint32_t offset;
banner();
usb_init();
retry:
if(!(dev = find_dev()) || !(handle = get_dfu_interface(dev, &iface))) {
puts("FATAL: No compatible device found!\n");
#ifdef WIN32
system("pause");
#endif
return -1;
}
state = dfu_getstate(handle, iface);
if((state < 0) || (state == STATE_APP_IDLE)) {
puts("Resetting device in firmware upgrade mode...");
dfu_detach(handle, iface, 1000);
usb_release_interface(handle, iface);
usb_close(handle);
#ifdef WIN32
Sleep(5000);
#else
sleep(5);
#endif
goto retry;
}
printf("Found device at %s:%s\n", dev->bus->dirname, dev->filename);
dfu_makeidle(handle, iface);
for(offset = 0; offset < bindatalen; offset += 1024) {
printf("Progress: %d%%\r", (offset*100)/bindatalen);
fflush(stdout);
assert(stm32_mem_erase(handle, iface, LOAD_ADDRESS + offset) == 0);
stm32_mem_write(handle, iface, (void*)&bindata[offset], 1024);
}
stm32_mem_manifest(handle, iface);
usb_release_interface(handle, iface);
usb_close(handle);
puts("All operations complete!\n");
#ifdef WIN32
system("pause");
#endif
return 0;
}
/*
* 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 k8061_ExecIO( int iCard, int nSend, int nReceive ) {
int n_write = 0, n_read = 0;
if ( iCard < 0 || iCard > 7 ) {
fprintf( stderr, "*** error <k8061_ExecIO> : Card number out of range %d...\n", iCard );
fflush( stderr );
return -1;
}
if ( _k8061_IsOpen[iCard] ) {
n_write = usb_bulk_write( _k8061_Handle[iCard] ,k8061_epWrite, _k8061_WriteBuffer,
nSend, k8061_ioTimeOut );
usleep( k8061_ioWait );
if ( n_write < 0 ) {
fprintf( stderr, "*** %s\n", usb_strerror() );
fprintf( stderr, "*** error <k8061_ExecIO> : Error writing command to card %d\n", iCard );
fflush( stderr );
if ( _k8061_Handle[iCard] ) usb_release_interface( _k8061_Handle[iCard], k8061_iClaim );
if ( _k8061_Handle[iCard] ) usb_close( _k8061_Handle[iCard] );
_k8061_IsOpen[iCard] = 0;
return -1;
}
n_read = usb_bulk_read( _k8061_Handle[iCard] ,k8061_epRead, _k8061_ReadBuffer,
nReceive, k8061_ioTimeOut );
usleep( k8061_ioWait );
if ( n_read < 0 ) {
fprintf( stderr, "*** %s\n", usb_strerror() );
fprintf( stderr, "*** error <k8061_ExecIO> : Error reading buffer from card %d\n", iCard );
fflush( stderr );
if ( _k8061_Handle[iCard] ) usb_release_interface( _k8061_Handle[iCard], k8061_iClaim );
if ( _k8061_Handle[iCard] ) usb_close( _k8061_Handle[iCard] );
_k8061_IsOpen[iCard] = 0;
return -1;
}
} else {
fprintf( stderr, "*** error <k8061_ExecIO> : Card %d not found/not opened...\n", iCard );
fflush( stderr );
return -1;
}
return 0;
}
static int drv_TF_close(void)
{
usb_release_interface(lcd, interface);
usb_close(lcd);
return 0;
}
int main(int argc, char * argv[])
{
struct pwcmech * pwcmech;
pwcmech->dev = ifinit_pwcblock();
pwcmech->com = ifinit_usbcom();
ifbind_pwcblock(pwcmech->dev, pwcmech->com);
//use driver
usb_init(pwcmech->com);
if ( usb_open(pwcmech->com) )
{
finish(pwcmech);
return 0;
}
//should work seamlessly
usb_if_claim(pwcmech->com, pwcmech->com->standard_descriptors.highspeed.cameraStream.cameraStreamConf);
setVideoMode(pwcmech, 9);
setLeds(pwcmech, 10,5);
usb_release_interface(pwcmech->com, pwcmech->com->standard_descriptors.highspeed.cameraStream.cameraStreamConf);
usb_close(pwcmech->com);
finish(pwcmech);
return 0;
}
int main( int argc, char **argv)
{
usb_dev_handle *lvr_winusb;
if ((lvr_winusb = setup_libusb_access()) == NULL)
{
exit(-1);
}
//printf("Testing control transfer: ");
//test_control_transfer(lvr_winusb);
//printf("Testing interrupt transfer: ");
//test_interrupt_transfer(lvr_winusb);
//printf("Testing bulk transfer: ");
//test_bulk_transfer(lvr_winusb);
usb_release_interface(lvr_winusb, 0);
usb_reset(lvr_winusb);
usb_close(lvr_winusb);
return 0;
}
void hidasp_close(void)
{
if( usb_dev ) {
usb_release_interface(usb_dev, 0);
usb_close(usb_dev);
}
}
int main(void) {
usb_dev_handle *dev = NULL; /* the device handle */
uint8_t readBuffer[0x200*0x100];
/* Set up USB */
usb_init();
usb_find_busses();
usb_find_devices();
if (!(dev = open_dev())) {
perror("device not found!\n");
exit(EXIT_FAILURE);
}
/*
if (usb_set_configuration(dev, 1) < 0) {
perror("setting config 1 failed\n");
usb_close(dev);
exit(EXIT_FAILURE);
}
*/
if (usb_claim_interface(dev, 0) < 0)
{
perror("claiming interface failed\n");
usb_close(dev);
exit(EXIT_FAILURE);
}
//FIXME: sniffed
read10(readBuffer,0x100,0x0,dev);
printReadBuffer(readBuffer);
/* Clean up */
usb_release_interface(dev, 0);
usb_close(dev);
exit(0);
}
int _ykusb_read(void *dev, int report_type, int report_number,
char *buffer, int size)
{
int rc = usb_claim_interface((usb_dev_handle *)dev, 0);
if (rc >= 0) {
int rc2;
rc = usb_control_msg((usb_dev_handle *)dev,
USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_ENDPOINT_IN,
HID_GET_REPORT,
report_type << 8 | report_number, 0,
buffer, size,
1000);
/* preserve a control message error over an interface
release one */
rc2 = usb_release_interface((usb_dev_handle *)dev, 0);
if (rc >= 0 && rc2 < 0)
rc = rc2;
}
if (rc >= 0)
return rc;
if(rc == 0)
yk_errno = YK_ENODATA;
else
yk_errno = YK_EUSBERR;
return 0;
}
/*
void test_control_transfer(usb_dev_handle *dev)
{
// usb_set_altinterface(dev, 0);
usb_release_interface(dev, 0);
}
*/
void test_interrupt_transfer(usb_dev_handle *dev)
{
int r,i;
char answer[reqIntLen];
char question[reqIntLen];
for (i=0;i<reqIntLen; i++) question[i]=i;
r = usb_interrupt_write(dev, endpoint_Int_out, question, reqIntLen, timeout);
if( r < 0 )
{
perror("USB interrupt write"); bad("USB write failed");
}
r = usb_interrupt_read(dev, endpoint_Int_in, answer, reqIntLen, timeout);
if( r != reqIntLen )
{
perror("USB interrupt read"); bad("USB read failed");
}
// for (i=0;i<reqIntLen; i++) printf("%i, %i, \n",question[i],answer[i]);
for(i = 0;i < reqIntLen; i++) {
if(i%8 == 0)
printf("\n");
printf("%02x, %02x; ",question[i],answer[i]);
}
printf("\n");
// usb_set_altinterface(dev, 0);
usb_release_interface(dev, 0);
}
int xusb_close(struct xusb *xusb)
{
if(xusb) {
if(xusb->handle) {
assert(xusb->spec);
assert(xusb->spec->name);
DBG("Closing interface \"%s\"\n", xusb->spec->name);
if(xusb->is_claimed) {
if(usb_release_interface(xusb->handle, xusb->spec->my_interface_num) != 0) {
ERR("Releasing interface: usb: %s\n", usb_strerror());
}
xusb->is_claimed = 0;
}
if(xusb->is_open) {
if(usb_close(xusb->handle) != 0) {
ERR("Closing device: usb: %s\n", usb_strerror());
}
xusb->is_open = 0;
}
xusb->handle = NULL;
}
xusb = NULL;
}
return 0;
}
/**
* Close the driver (do necessary clean-up).
* \param drvthis Pointer to driver structure.
*/
MODULE_EXPORT void
IOWarrior_close(Driver *drvthis)
{
PrivateData *p = drvthis->private_data;
if (p != NULL) {
/* don't turn display off: keep the logoff message */
// iowlcd_display_on_off(p,0,0,0);
/* IOW leave LCD mode */
iowlcd_disable(p);
/* release interface 1 */
usb_release_interface(p->udh, 1);
/* close USB */
usb_close(p->udh);
if (p->framebuf != NULL)
free(p->framebuf);
p->framebuf = NULL;
if (p->backingstore != NULL)
free(p->backingstore);
p->backingstore = NULL;
free(p);
}
drvthis->store_private_ptr(drvthis, NULL);
debug(RPT_DEBUG, "%s: closed", drvthis->name);
}
//---------------------------------------------------------------------------
// 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;
}
static int pickit2_shutdown(void *data)
{
/* Set all pins to float and turn voltages off */
uint8_t command[CMD_LENGTH] = {
CMD_EXEC_SCRIPT,
8,
SCR_SET_PINS,
3, /* Bit-0=1(PDC In), Bit-1=1(PGD In), Bit-2=0(PDC LL), Bit-3=0(PGD LL) */
SCR_SET_AUX,
1, /* Bit-0=1(Aux In), Bit-1=0(Aux LL) */
SCR_MCLR_GND_OFF,
SCR_VPP_OFF,
SCR_VDD_OFF,
SCR_BUSY_LED_OFF,
CMD_END_OF_BUFFER
};
int ret = usb_interrupt_write(pickit2_handle, ENDPOINT_OUT, (char *)command, CMD_LENGTH, DFLT_TIMEOUT);
if (ret != CMD_LENGTH) {
msg_perr("Command Shutdown failed (%s)!\n", usb_strerror());
ret = 1;
}
if (usb_release_interface(pickit2_handle, 0) != 0) {
msg_perr("Could not release USB interface!\n");
ret = 1;
}
if (usb_close(pickit2_handle) != 0) {
msg_perr("Could not close USB device!\n");
ret = 1;
}
return ret;
}
void teensy_close(void)
{
if (!libusb_teensy_handle) return;
usb_release_interface(libusb_teensy_handle, 0);
usb_close(libusb_teensy_handle);
libusb_teensy_handle = NULL;
}
//---------------------------------------------------------------------------
// Release the previously acquired a 1-Wire net.
//
// 'portnum' - number 0 to MAX_PORTNUM-1. This number is provided to
// indicate the symbolic port number.
// 'return_msg' - zero terminated return message.
//
void owReleaseUSB(int portnum, char *return_msg)
{
usb_release_interface(usb_dev_handle_list[portnum], 0);
usb_close(usb_dev_handle_list[portnum]);
usb_dev_handle_list[portnum] = NULL;
strcpy(return_msg, "DS2490 successfully released by USB driver\n");
}
//----------------------------------------------------------------------
//check lockdown verifier button status
int ldn_verifier_checkbuttonstatus(void){
struct usb_dev_handle *hdl;
int status=-1;
int verifier_was_unplugged=0;
do{
while( (hdl = ldn_find_verifier()) == NULL){
verifier_was_unplugged=1;
Sleep(100); //discover our verifier
}
if(verifier_was_unplugged){
verifier_was_unplugged=0;
if(ldn_trusted_environment)
usbdevice_setdevicestate(hdl, GREEN_LED);
else
usbdevice_setdevicestate(hdl, RED_LED);
}
status = usbdevice_checkbuttonstatus(hdl);
usb_release_interface(hdl, 0);
usb_close(hdl);
}while(status < 0);
return status;
}
void PeperoniDevice::close(quint32 line, OperatingMode mode)
{
m_operatingModes[line] &= ~mode;
if (mode == InputMode && m_running == true)
{
m_running = false;
wait();
}
if (m_operatingModes[line] != CloseMode)
return;
if (m_device != NULL && m_handle != NULL)
{
/* Release the interface in case we claimed it */
int r = usb_release_interface(m_handle, PEPERONI_IFACE_EP0);
if (r < 0)
{
qWarning() << "PeperoniDevice" << name(m_baseLine)
<< "is unable to release interface EP0!";
}
usb_close(m_handle);
}
m_handle = NULL;
}
grub_usb_err_t
grub_usb_bulk_write (grub_usb_device_t dev,
int endpoint, grub_size_t size, char *data)
{
usb_dev_handle *devh;
struct usb_device *d = dev->data;
devh = usb_open (d);
if (usb_claim_interface (devh, 0) < 0)
goto fail;
if (usb_bulk_write (devh, endpoint, data, size, 20) < 0)
goto fail;
if (usb_release_interface (devh, 0) < 0)
goto fail;
usb_close (devh);
return GRUB_USB_ERR_NONE;
fail:
usb_close (devh);
return GRUB_USB_ERR_STALL;
}
/*****************************************************************************
*
* CloseUSB
*
****************************************************************************/
status_t CloseUSB(unsigned int reader_index)
{
/* device not opened */
if (usbDevice[reader_index].handle == NULL)
return STATUS_UNSUCCESSFUL;
DEBUG_COMM3("Closing USB device: %s/%s",
usbDevice[reader_index].dirname,
usbDevice[reader_index].filename);
if (usbDevice[reader_index].ccid.arrayOfSupportedDataRates
&& (usbDevice[reader_index].ccid.bCurrentSlotIndex == 0))
{
free(usbDevice[reader_index].ccid.arrayOfSupportedDataRates);
usbDevice[reader_index].ccid.arrayOfSupportedDataRates = NULL;
}
/* one slot closed */
(*usbDevice[reader_index].nb_opened_slots)--;
/* release the allocated ressources for the last slot only */
if (0 == *usbDevice[reader_index].nb_opened_slots)
{
DEBUG_COMM("Last slot closed. Release resources");
/* reset so that bSeq starts at 0 again */
if (DriverOptions & DRIVER_OPTION_RESET_ON_CLOSE)
(void)usb_reset(usbDevice[reader_index].handle);
(void)usb_release_interface(usbDevice[reader_index].handle,
usbDevice[reader_index].interface);
(void)usb_close(usbDevice[reader_index].handle);
#ifdef __APPLE__
DEBUG_INFO3("Terminating thread: %s/%s",
usbDevice[reader_index].dirname, usbDevice[reader_index].filename);
// Terminate thread
*usbDevice[reader_index].pTerminated = TRUE;
pthread_join(usbDevice[reader_index].hThread, NULL);
// Free bStatus lock
pthread_mutex_destroy(usbDevice[reader_index].ccid.pbStatusLock);
#endif
// Free array of bStatus
free(usbDevice[reader_index].ccid.bStatus);
free(usbDevice[reader_index].dirname);
free(usbDevice[reader_index].filename);
}
/* mark the resource unused */
usbDevice[reader_index].handle = NULL;
usbDevice[reader_index].dirname = NULL;
usbDevice[reader_index].filename = NULL;
usbDevice[reader_index].interface = 0;
usbDevice[reader_index].ccid.bStatus = NULL; // Array of bStatus
return STATUS_SUCCESS;
} /* CloseUSB */
static void usbtr_destroy(transport_t tr_base)
{
struct rf2500_transport *tr = (struct rf2500_transport *)tr_base;
usb_release_interface(tr->handle, tr->int_number);
usb_close(tr->handle);
free(tr);
}
HardwareThunder::~HardwareThunder()
{
if (m_usbHandler)
{
usb_release_interface(m_usbHandler, 0);
usb_close(m_usbHandler);
}
}
/**
* Disconnect from current device
*/
void M64BirDevice::disconnectDevice()
{
usb_release_interface( mDeviceHandle, 0 );
if( mDeviceHandle != NULL )
{
usb_close( mDeviceHandle );
}
}
void dpf_ax_close(DPFAXHANDLE h)
{
DPFContext *dpf = (DPFContext *) h;
usb_release_interface(dpf->udev, 0);
usb_close(dpf->udev);
free(dpf);
}
/* USB::DevHandle#usb_release_interface(interface) */
static VALUE
rusb_release_interface(VALUE v, VALUE interface)
{
usb_dev_handle *p = get_usb_devhandle(v);
int ret = usb_release_interface(p, NUM2INT(interface));
check_usb_error("usb_release_interface", ret);
return Qnil;
}
void cleanup_USB_CTR( usb_dev_handle *udev )
{
if (udev) {
usb_clear_halt(udev, USB_ENDPOINT_IN|6);
usb_release_interface(udev, 0);
usb_close(udev);
}
}
void canon_close_camera(usb_dev_handle *camera_handle)
{
/* close connection to the camera */
fprintf(stderr, "Closing connection to camera... ");
usb_release_interface(camera_handle, 0);
usb_close(camera_handle);
fprintf(stderr, "done.\n");
}
static int drv_MOGX_close(void)
{
/* close whatever port you've opened */
usb_release_interface(lcd_dev, 0);
usb_close(lcd_dev);
return 0;
}
void disconnectDevice() {
if ( Connection_Status == CONNECTED) {
//The following functiom releases a previously claimed interface
usb_release_interface(MyLibusbDeviceHandle, 0);
//closes a device opened
usb_close(MyLibusbDeviceHandle);
}
}
