/* Close device */ void sane_close (SANE_Handle handle) { struct scanner *s = (struct scanner *) handle; unsigned i; hopper_down (s); if (s->bus == USB) { sanei_usb_release_interface (s->file, 0); sanei_usb_close (s->file); } else sanei_scsi_close (s->file); for (i = 1; i < NUM_OPTIONS; i++) { if (s->opt[i].type == SANE_TYPE_STRING && s->val[i].s) free (s->val[i].s); } for (i = 0; i < sizeof (s->buf) / sizeof (s->buf[0]); i++) buf_deinit (&s->buf[i]); free (s->buffer); free (s); }
static int u12if_close( U12_Device *dev ) { DBG( _DBG_INFO, "u12if_close()\n" ); u12io_CloseScanPath( dev ); sanei_usb_close( dev->fd ); dev->fd = -1; return 0; }
/* Open the device. */ static SANE_Status sanei_umaxusb_open (const char *dev, int *fdp, SANEI_SCSI_Sense_Handler handler, void *handler_arg) { SANE_Status status; handler = handler; /* silence gcc */ handler_arg = handler_arg; /* silence gcc */ status = sanei_usb_open (dev, fdp); if (status != SANE_STATUS_GOOD) { DBG (1, "sanei_umaxusb_open: open of `%s' failed: %s\n", dev, sane_strstatus(status)); return status; } else { SANE_Word vendor; SANE_Word product; /* We have openned the device. Check that it is a USB scanner. */ if (sanei_usb_get_vendor_product (*fdp, &vendor, &product) != SANE_STATUS_GOOD) { /* This is not a USB scanner, or SANE or the OS doesn't support it. */ sanei_usb_close(*fdp); *fdp = -1; return SANE_STATUS_UNSUPPORTED; } /* So it's a scanner. Does this backend support it? * Only the UMAX 2200 USB is currently supported. */ if ((vendor != 0x1606) || (product != 0x0230)) { sanei_usb_close(*fdp); *fdp = -1; return SANE_STATUS_UNSUPPORTED; } /* It's a good scanner. Initialize it. * * Note: pv8630_init_umaxusb_scanner() is for the UMAX * 2200. Other UMAX scanner might need a different * initialization routine. */ pv8630_init_umaxusb_scanner(*fdp); } return(SANE_STATUS_GOOD); }
void sane_close (SANE_Handle handle) { struct hp5590_scanner *scanner = handle; DBG (DBG_proc, "%s\n", __FUNCTION__); sanei_usb_close (scanner->dn); scanner->dn = -1; }
/* Close an USB device */ void kv_usb_close (PKV_DEV dev) { DBG (DBG_proc, "kv_usb_close: enter\n"); if (kv_usb_already_open(dev)) { sanei_usb_close(dev->usb_fd); dev->usb_fd = -1; } DBG (DBG_proc, "kv_usb_close: leave\n"); }
static void channel_usb_close (channel *self, SANE_Status *status) { SANE_Status s = SANE_STATUS_GOOD; if (self->interpreter) { self->interpreter->close (self); } sanei_usb_close (self->fd); self->fd = -1; if (status) *status = s; }
static SANE_Status disconnect_fd (struct scanner *s) { DBG (10, "disconnect_fd: start\n"); if(s->fd > -1){ DBG (15, "disconnecting usb device\n"); sanei_usb_close (s->fd); s->fd = -1; } DBG (10, "disconnect_fd: finish\n"); return SANE_STATUS_GOOD; }
SANE_Status sane_open (SANE_String_Const name, SANE_Handle * h) { struct device_s *dev; int ret; if(!devlist_head) sane_get_devices(NULL,(SANE_Bool)0); dev = devlist_head; if (strlen (name)) for (; dev; dev = dev->next) if (!strcmp (name, dev->devname)) break; if (!dev) { DBG(1,"Unable to find device %s\n",name); return SANE_STATUS_INVAL; } DBG(1,"Found device %s\n",name); /* Now open the usb device */ ret = sanei_usb_open (name, &(dev->dn)); if (ret != SANE_STATUS_GOOD) { DBG(1,"Unable to open device %s\n",name); return ret; } /* Claim the first interface */ ret = sanei_usb_claim_interface (dev->dn, 0); if (ret != SANE_STATUS_GOOD) { sanei_usb_close (dev->dn); /* if we cannot claim the interface, this is because someone else is using it */ DBG(1,"Unable to claim scanner interface on device %s\n",name); return SANE_STATUS_DEVICE_BUSY; } #ifdef HAVE_SANEI_USB_SET_TIMEOUT sanei_usb_set_timeout (30000); /* 30s timeout */ #endif *h = dev; return SANE_STATUS_GOOD; }
void sane_close (SANE_Handle h) { struct device_s *dev = (struct device_s *) h; /* Just in case if sane_cancel() is called * after starting a scan but not while a sane_read */ if (dev->status == STATUS_CANCELING) { do_cancel(dev); } sanei_usb_release_interface (dev->dn, 0); sanei_usb_close (dev->dn); }
/** close all devices * loop on all opened devices and close them * @param dn array of opened device number * @param expected number of devices to be closed * @return 1 on success, else 0 */ static int test_close_all (SANE_Int * dn, int expected) { int closed = 0; int i; /* loop on detected devices and open them */ for (i = 0; i < expected; i++) { /* close device */ sanei_usb_close (dn[i]); closed++; } printf ("closed %d devices\n", closed); /* there should be any more opened devices */ return count_opened (0); }
/** will be called upon sane_exit */ static void u12if_shutdown( U12_Device *dev ) { SANE_Int handle; TimerDef timer; DBG( _DBG_INFO, "Shutdown called (dev->fd=%d, %s)\n", dev->fd, dev->sane.name ); if( SANE_STATUS_GOOD == sanei_usb_open( dev->sane.name, &handle )) { dev->fd = handle; u12io_OpenScanPath( dev ); u12hw_PutToIdleMode( dev ); if( !(u12io_DataFromRegister( dev, REG_STATUS ) & _FLAG_PAPER)) { u12motor_PositionModuleToHome( dev ); u12io_StartTimer( &timer, _SECOND * 20); do { if( u12io_DataFromRegister( dev, REG_STATUS ) & _FLAG_PAPER) { break; } } while( !u12io_CheckTimer( &timer )); } DBG( _DBG_INFO, "* Home position reached.\n" ); if( 0 != dev->adj.lampOffOnEnd ) { DBG( _DBG_INFO, "* Switching lamp off...\n" ); dev->regs.RD_ScanControl &= ~_SCAN_LAMPS_ON; u12io_DataToRegister(dev,REG_SCANCONTROL, dev->regs.RD_ScanControl ); } u12io_CloseScanPath( dev ); dev->fd = -1; sanei_usb_close( handle ); } #if 0 usb_StopLampTimer( dev ); #endif DBG( _DBG_INFO, "Shutdown done.\n" ); }
void usb_dev_close (struct device *dev) { if (!dev) return; DBG (3, "%s: closing dev %p\n", __FUNCTION__, (void *)dev); /* finish all operations */ if (dev->scanning) { dev->cancel = 1; /* flush READ_IMAGE data */ if (dev->reading) sane_read(dev, NULL, 1, NULL); /* send cancel if not sent before */ if (dev->state != SANE_STATUS_CANCELLED) ret_cancel(dev, 0); } sanei_usb_clear_halt (dev->dn); /* unstall for next users */ sanei_usb_close (dev->dn); dev->dn = -1; }
/* Close device */ void sane_close (SANE_Handle handle) { struct scanner *s = (struct scanner *) handle; int i; if (s->bus == USB) { sanei_usb_release_interface (s->file, 0); sanei_usb_close (s->file); } else sanei_scsi_close (s->file); for (i = 1; i < NUM_OPTIONS; i++) { if (s->opt[i].type == SANE_TYPE_STRING && s->val[i].s) free (s->val[i].s); } if (s->data) free (s->data); free (s->buffer); free (s); }
/* Open device, return the device handle */ SANE_Status sane_open (SANE_String_Const devname, SANE_Handle * handle) { unsigned i, j, id = 0; struct scanner *s; SANE_Int h, bus; SANE_Status st = SANE_STATUS_GOOD; if (!devlist) { st = sane_get_devices (NULL, 0); if (st) return st; } for (i = 0; devlist[i]; i++) { if (!strcmp (devlist[i]->name, devname)) break; } if (!devlist[i]) return SANE_STATUS_INVAL; for (j = 0; j < sizeof (known_devices) / sizeof (known_devices[0]); j++) { if (!strcmp (devlist[i]->model, known_devices[j].scanner.model)) { id = known_devices[j].id; break; } } st = sanei_usb_open (devname, &h); if (st == SANE_STATUS_ACCESS_DENIED) return st; if (st) { st = sanei_scsi_open (devname, &h, kvs40xx_sense_handler, NULL); if (st) { return st; } bus = SCSI; } else { bus = USB; st = sanei_usb_claim_interface (h, 0); if (st) { sanei_usb_close (h); return st; } } s = malloc (sizeof (struct scanner)); if (!s) return SANE_STATUS_NO_MEM; memset (s, 0, sizeof (struct scanner)); s->buffer = malloc (MAX_READ_DATA_SIZE + BULK_HEADER_SIZE); if (!s->buffer) return SANE_STATUS_NO_MEM; s->file = h; s->bus = bus; s->id = id; strcpy (s->name, devname); *handle = s; for (i = 0; i < 3; i++) { st = kvs40xx_test_unit_ready (s); if (st) { if (s->bus == SCSI) { sanei_scsi_close (s->file); st = sanei_scsi_open (devname, &h, kvs40xx_sense_handler, NULL); if (st) return st; } else { sanei_usb_release_interface (s->file, 0); sanei_usb_close (s->file); st = sanei_usb_open (devname, &h); if (st) return st; st = sanei_usb_claim_interface (h, 0); if (st) { sanei_usb_close (h); return st; } } s->file = h; } else break; } if (i == 3) return SANE_STATUS_DEVICE_BUSY; if (id == KV_S4085C || id == KV_S4065C) { char str[16]; st = inquiry (s, str); if (st) goto err; if (id == KV_S4085C) s->id = !strcmp (str, "KV-S4085CL") ? KV_S4085CL : KV_S4085CW; else s->id = !strcmp (str, "KV-S4065CL") ? KV_S4065CL : KV_S4065CW; } kvs40xx_init_options (s); st = kvs40xx_set_timeout (s, s->val[FEED_TIMEOUT].w); if (st) goto err; return SANE_STATUS_GOOD; err: sane_close (s); return st; }
static int u12if_open( U12_Device *dev ) { char devStr[50]; int result; SANE_Int handle; SANE_Word vendor, product; SANE_Bool was_empty; DBG( _DBG_INFO, "u12if_open(%s,%s)\n", dev->name, dev->usbId ); USB_devname[0] = '\0'; #ifdef _FAKE_DEVICE dev->name = strdup( "auto" ); dev->sane.name = dev->name; was_empty = SANE_FALSE; result = SANE_STATUS_UNSUPPORTED; #else if( !strcmp( dev->name, "auto" )) { if( dev->usbId[0] == '\0' ) { if( !usbDev_autodetect( &vendor, &product )) { DBG( _DBG_ERROR, "No supported device found!\n" ); return -1; } } else { vendor = strtol( &dev->usbId[0], 0, 0 ); product = strtol( &dev->usbId[7], 0, 0 ); sanei_usb_find_devices( vendor, product, u12if_usbattach ); if( USB_devname[0] == '\0' ) { DBG( _DBG_ERROR, "No matching device found!\n" ); return -1; } } if( SANE_STATUS_GOOD != sanei_usb_open( USB_devname, &handle )) { return -1; } /* replace the old devname, so we are able to have multiple * auto-detected devices */ free( dev->name ); dev->name = strdup( USB_devname ); dev->sane.name = dev->name; } else { if( SANE_STATUS_GOOD != sanei_usb_open( dev->name, &handle )) return -1; } was_empty = SANE_FALSE; result = sanei_usb_get_vendor_product( handle, &vendor, &product ); #endif if( SANE_STATUS_GOOD == result ) { sprintf( devStr, "0x%04X-0x%04X", vendor, product ); DBG(_DBG_INFO,"Vendor ID=0x%04X, Product ID=0x%04X\n",vendor,product); if( dev->usbId[0] != '\0' ) { if( 0 != strcmp( dev->usbId, devStr )) { DBG( _DBG_ERROR, "Specified Vendor and Product ID " "doesn't match with the ones\n" "in the config file\n" ); sanei_usb_close( handle ); return -1; } } else { sprintf( dev->usbId, "0x%04X-0x%04X", vendor, product ); was_empty = SANE_TRUE; } } else { DBG( _DBG_INFO, "Can't get vendor & product ID from driver...\n" ); /* if the ioctl stuff is not supported by the kernel and we have * nothing specified, we have to give up... */ if( dev->usbId[0] == '\0' ) { DBG( _DBG_ERROR, "Cannot autodetect Vendor an Product ID, " "please specify in config file.\n" ); sanei_usb_close( handle ); return -1; } vendor = strtol( &dev->usbId[0], 0, 0 ); product = strtol( &dev->usbId[7], 0, 0 ); DBG( _DBG_INFO, "... using the specified: " "0x%04X-0x%04X\n", vendor, product ); } /* before accessing the scanner, check if supported! */ if( !u12if_IsDeviceSupported( dev )) { DBG( _DBG_ERROR, "Device >%s<, is not supported!\n", dev->usbId ); sanei_usb_close( handle ); return -1; } dev->mode = _PP_MODE_SPP; dev->fd = handle; /* is it accessible ? */ if( SANE_STATUS_GOOD != u12hw_CheckDevice( dev )) { dev->fd = -1; sanei_usb_close( handle ); return -1; } DBG( _DBG_INFO, "Detected vendor & product ID: " "0x%04X-0x%04X\n", vendor, product ); if( was_empty ) dev->usbId[0] = '\0'; /* now initialize the device */ if( SANE_STATUS_GOOD != u12_initDev( dev, handle, vendor )) { dev->fd = -1; sanei_usb_close( handle ); return -1; } if( _PLUSTEK_VENID == vendor ) { if( dev->Tpa ) dev->sane.model = "UT12"; } dev->initialized = SANE_TRUE; return handle; }
static SANE_Status attach (SANE_String_Const devname, Mustek_Usb_Device ** devp, SANE_Bool may_wait) { Mustek_Usb_Device *dev; SANE_Status status; Mustek_Type scanner_type; SANE_Int fd; DBG (5, "attach: start: devp %s NULL, may_wait = %d\n", devp ? "!=" : "==", may_wait); if (!devname) { DBG (1, "attach: devname == NULL\n"); return SANE_STATUS_INVAL; } for (dev = first_dev; dev; dev = dev->next) if (strcmp (dev->sane.name, devname) == 0) { if (devp) *devp = dev; DBG (4, "attach: device `%s' was already in device list\n", devname); return SANE_STATUS_GOOD; } DBG (4, "attach: trying to open device `%s'\n", devname); status = sanei_usb_open (devname, &fd); if (status != SANE_STATUS_GOOD) { DBG (3, "attach: couldn't open device `%s': %s\n", devname, sane_strstatus (status)); return status; } DBG (4, "attach: device `%s' successfully opened\n", devname); /* try to identify model */ DBG (4, "attach: trying to identify device `%s'\n", devname); status = usb_low_identify_scanner (fd, &scanner_type); if (status != SANE_STATUS_GOOD) { DBG (1, "attach: device `%s' doesn't look like a supported scanner\n", devname); sanei_usb_close (fd); return status; } sanei_usb_close (fd); if (scanner_type == MT_UNKNOWN) { DBG (3, "attach: warning: couldn't identify device `%s', must set " "type manually\n", devname); } dev = malloc (sizeof (Mustek_Usb_Device)); if (!dev) { DBG (1, "attach: couldn't malloc Mustek_Usb_Device\n"); return SANE_STATUS_NO_MEM; } memset (dev, 0, sizeof (*dev)); dev->name = strdup (devname); dev->sane.name = (SANE_String_Const) dev->name; dev->sane.vendor = "Mustek"; switch (scanner_type) { case MT_1200CU: dev->sane.model = "1200 CU"; break; case MT_1200CU_PLUS: dev->sane.model = "1200 CU Plus"; break; case MT_1200USB: dev->sane.model = "1200 USB (unsupported)"; break; case MT_1200UB: dev->sane.model = "1200 UB"; break; case MT_600CU: dev->sane.model = "600 CU"; break; case MT_600USB: dev->sane.model = "600 USB (unsupported)"; break; default: dev->sane.model = "(unidentified)"; break; } dev->sane.type = "flatbed scanner"; dev->x_range.min = 0; dev->x_range.max = SANE_FIX (8.4 * MM_PER_INCH); dev->x_range.quant = 0; dev->y_range.min = 0; dev->y_range.max = SANE_FIX (11.7 * MM_PER_INCH); dev->y_range.quant = 0; dev->max_height = 11.7 * 300; dev->max_width = 8.4 * 300; dev->dpi_range.min = SANE_FIX (50); dev->dpi_range.max = SANE_FIX (600); dev->dpi_range.quant = SANE_FIX (1); status = usb_high_scan_init (dev); if (status != SANE_STATUS_GOOD) { DBG (1, "attach: usb_high_scan_init returned status: %s\n", sane_strstatus (status)); free (dev); return status; } dev->chip->scanner_type = scanner_type; dev->chip->max_block_size = max_block_size; DBG (2, "attach: found %s %s %s at %s\n", dev->sane.vendor, dev->sane.type, dev->sane.model, dev->sane.name); ++num_devices; dev->next = first_dev; first_dev = dev; if (devp) *devp = dev; DBG (5, "attach: exit\n"); return SANE_STATUS_GOOD; }
/* Close the scanner. */ static void sanei_umaxusb_close (int fd) { sanei_usb_close(fd); }