int
PSession::initiate_read (u_long offset_low, u_long offset_high, size_t size)
{
//if (this->get_ref_cnt_r () != 0)
// return 0;
ACE_Message_Block *mb = 0;
ACE_NEW_RETURN (mb,
ACE_Message_Block (size),
-1);
if (mb == 0)
{
do_cancel ();
return -1;
}
mb->reset ();
return this->initiate_read (offset_low, offset_high, *mb);
}
void do_reset()
{
do_cancel();
// Wipe away all wires first so we won't need to do wire frying.
int i;
for (i = 0; i < (signed)gWire.size(); i++)
{
delete gWire[i];
}
gWire.clear();
// Deleting chips is trickier, because boxes delete their internal chips recursively.
while (gChip.size())
{
Chip * t = gChip.back();
gChip.pop_back();
delete t;
}
gChip.clear();
gChipName.clear();
build_nets();
}
SANE_Status
sane_start (SANE_Handle handle)
{
char *mode_str;
Ibm_Scanner *s = handle;
SANE_Status status;
struct ibm_window_data wbuf;
struct measurements_units_page mup;
DBG (11, ">> sane_start\n");
/* First make sure we have a current parameter set. Some of the
parameters will be overwritten below, but that's OK. */
status = sane_get_parameters (s, 0);
if (status != SANE_STATUS_GOOD)
return status;
status = sanei_scsi_open (s->hw->sane.name, &s->fd, 0, 0);
if (status != SANE_STATUS_GOOD)
{
DBG (1, "open of %s failed: %s\n",
s->hw->sane.name, sane_strstatus (status));
return (status);
}
mode_str = s->val[OPT_MODE].s;
s->xres = s->val[OPT_X_RESOLUTION].w;
s->yres = s->val[OPT_Y_RESOLUTION].w;
s->ulx = s->val[OPT_TL_X].w;
s->uly = s->val[OPT_TL_Y].w;
s->width = s->val[OPT_BR_X].w - s->val[OPT_TL_X].w;
s->length = s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w;
s->brightness = s->val[OPT_BRIGHTNESS].w;
s->contrast = s->val[OPT_CONTRAST].w;
s->bpp = s->params.depth;
if (strcmp (mode_str, SANE_VALUE_SCAN_MODE_LINEART) == 0)
{
s->image_composition = IBM_BINARY_MONOCHROME;
}
else if (strcmp (mode_str, SANE_VALUE_SCAN_MODE_HALFTONE) == 0)
{
s->image_composition = IBM_DITHERED_MONOCHROME;
}
else if (strcmp (mode_str, SANE_VALUE_SCAN_MODE_GRAY) == 0)
{
s->image_composition = IBM_GRAYSCALE;
}
memset (&wbuf, 0, sizeof (wbuf));
/* next line commented out by mf */
/* _lto2b(sizeof(wbuf) - 8, wbuf.len); */
/* next line by mf */
_lto2b(IBM_WINDOW_DATA_SIZE, wbuf.len); /* size=320 */
_lto2b(s->xres, wbuf.x_res);
_lto2b(s->yres, wbuf.y_res);
_lto4b(s->ulx, wbuf.x_org);
_lto4b(s->uly, wbuf.y_org);
_lto4b(s->width, wbuf.width);
_lto4b(s->length, wbuf.length);
wbuf.image_comp = s->image_composition;
/* if you throw the MRIF bit the brighness control reverses too */
/* so I reverse the reversal in software for symmetry's sake */
if (wbuf.image_comp == IBM_GRAYSCALE || wbuf.image_comp == IBM_DITHERED_MONOCHROME)
{
if (wbuf.image_comp == IBM_GRAYSCALE)
wbuf.mrif_filtering_gamma_id = (SANE_Byte) 0x80; /* it was 0x90 */
if (wbuf.image_comp == IBM_DITHERED_MONOCHROME)
wbuf.mrif_filtering_gamma_id = (SANE_Byte) 0x10;
wbuf.brightness = 256 - (SANE_Byte) s->brightness;
/*
if (is50)
wbuf.contrast = (SANE_Byte) s->contrast;
else
*/
wbuf.contrast = 256 - (SANE_Byte) s->contrast;
}
else /* wbuf.image_comp == IBM_BINARY_MONOCHROME */
{
wbuf.mrif_filtering_gamma_id = (SANE_Byte) 0x00;
wbuf.brightness = (SANE_Byte) s->brightness;
wbuf.contrast = (SANE_Byte) s->contrast;
}
wbuf.threshold = 0;
wbuf.bits_per_pixel = s->bpp;
wbuf.halftone_code = 2; /* diithering */
wbuf.halftone_id = 0x0A; /* 8x8 Bayer pattenr */
wbuf.pad_type = 3;
wbuf.bit_ordering[0] = 0;
wbuf.bit_ordering[1] = 7; /* modified by mf (it was 3) */
DBG (5, "xres=%d\n", _2btol(wbuf.x_res));
DBG (5, "yres=%d\n", _2btol(wbuf.y_res));
DBG (5, "ulx=%d\n", _4btol(wbuf.x_org));
DBG (5, "uly=%d\n", _4btol(wbuf.y_org));
DBG (5, "width=%d\n", _4btol(wbuf.width));
DBG (5, "length=%d\n", _4btol(wbuf.length));
DBG (5, "image_comp=%d\n", wbuf.image_comp);
DBG (11, "sane_start: sending SET WINDOW\n");
status = set_window (s->fd, &wbuf);
if (status != SANE_STATUS_GOOD)
{
DBG (1, "SET WINDOW failed: %s\n", sane_strstatus (status));
return (status);
}
DBG (11, "sane_start: sending GET WINDOW\n");
memset (&wbuf, 0, sizeof (wbuf));
status = get_window (s->fd, &wbuf);
if (status != SANE_STATUS_GOOD)
{
DBG (1, "GET WINDOW failed: %s\n", sane_strstatus (status));
return (status);
}
DBG (5, "xres=%d\n", _2btol(wbuf.x_res));
DBG (5, "yres=%d\n", _2btol(wbuf.y_res));
DBG (5, "ulx=%d\n", _4btol(wbuf.x_org));
DBG (5, "uly=%d\n", _4btol(wbuf.y_org));
DBG (5, "width=%d\n", _4btol(wbuf.width));
DBG (5, "length=%d\n", _4btol(wbuf.length));
DBG (5, "image_comp=%d\n", wbuf.image_comp);
DBG (11, "sane_start: sending MODE SELECT\n");
memset (&mup, 0, sizeof (mup));
mup.page_code = MEASUREMENTS_PAGE;
mup.parameter_length = 0x06;
mup.bmu = INCHES;
mup.mud[0] = (DEFAULT_MUD >> 8) & 0xff;
mup.mud[1] = (DEFAULT_MUD & 0xff);
/* next lines by mf */
mup.adf_page_code = 0x26;
mup.adf_parameter_length = 6;
if (s->adf_state == ADF_ARMED)
mup.adf_control = 1;
else
mup.adf_control = 0;
/* end lines by mf */
status = mode_select (s->fd, (struct mode_pages *) &mup);
if (status != SANE_STATUS_GOOD)
{
DBG (1, "attach: MODE_SELECT failed\n");
return (SANE_STATUS_INVAL);
}
status = trigger_scan (s->fd);
if (status != SANE_STATUS_GOOD)
{
DBG (1, "start of scan failed: %s\n", sane_strstatus (status));
/* next line introduced not to freeze xscanimage */
do_cancel(s);
return status;
}
/* Wait for scanner to become ready to transmit data */
status = ibm_wait_ready (s);
if (status != SANE_STATUS_GOOD)
{
DBG (1, "GET DATA STATUS failed: %s\n", sane_strstatus (status));
return (status);
}
s->bytes_to_read = s->params.bytes_per_line * s->params.lines;
DBG (1, "%d pixels per line, %d bytes, %d lines high, total %lu bytes, "
"dpi=%d\n", s->params.pixels_per_line, s->params.bytes_per_line,
s->params.lines, (u_long) s->bytes_to_read, s->val[OPT_Y_RESOLUTION].w);
s->scanning = SANE_TRUE;
DBG (11, "<< sane_start\n");
return (SANE_STATUS_GOOD);
}
SANE_Status
sane_start (SANE_Handle handle)
{
Tamarack_Scanner *s = handle;
SANE_Status status;
int fds[2];
/* First make sure we have a current parameter set. Some of the
parameters will be overwritten below, but that's OK. */
status = sane_get_parameters (s, 0);
if (status != SANE_STATUS_GOOD)
return status;
if (s->fd < 0) {
/* translate options into s->mode for convenient access: */
s->mode = make_mode (s->val[OPT_MODE].s);
if (s->mode == TRUECOLOR)
{
if (s->val[OPT_PREVIEW].w && s->val[OPT_GRAY_PREVIEW].w) {
/* Force gray-scale mode when previewing. */
s->mode = GREYSCALE;
s->params.format = SANE_FRAME_GRAY;
s->params.bytes_per_line = s->params.pixels_per_line;
s->params.last_frame = SANE_TRUE;
}
}
status = sanei_scsi_open (s->hw->sane.name, &s->fd, sense_handler, 0);
if (status != SANE_STATUS_GOOD) {
DBG(1, "open: open of %s failed: %s\n",
s->hw->sane.name, sane_strstatus (status));
return status;
}
}
status = wait_ready (s->fd);
if (status != SANE_STATUS_GOOD) {
DBG(1, "open: wait_ready() failed: %s\n", sane_strstatus (status));
goto stop_scanner_and_return;
}
status = scan_area_and_windows (s);
if (status != SANE_STATUS_GOOD) {
DBG(1, "open: set scan area command failed: %s\n",
sane_strstatus (status));
goto stop_scanner_and_return;
}
status = mode_select (s);
if (status != SANE_STATUS_GOOD)
goto stop_scanner_and_return;
s->scanning = SANE_TRUE;
status = start_scan (s);
if (status != SANE_STATUS_GOOD)
goto stop_scanner_and_return;
status = get_image_status (s);
if (status != SANE_STATUS_GOOD)
goto stop_scanner_and_return;
s->line = 0;
if (pipe (fds) < 0)
return SANE_STATUS_IO_ERROR;
s->pipe = fds[0];
s->reader_pipe = fds[1];
s->reader_pid = sanei_thread_begin (reader_process, (void *) s);
if (sanei_thread_is_forked()) close (s->reader_pipe);
return SANE_STATUS_GOOD;
stop_scanner_and_return:
do_cancel (s);
return status;
}
SANE_Status
sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
SANE_Int * len)
{
SANE_Status status;
Leo_Scanner *dev = handle;
size_t size;
int buf_offset; /* offset into buf */
DBG (DBG_proc, "sane_read: enter\n");
*len = 0;
if (!(dev->scanning))
{
/* OOPS, not scanning */
return do_cancel (dev);
}
if (dev->bytes_left <= 0)
{
return (SANE_STATUS_EOF);
}
buf_offset = 0;
do
{
if (dev->image_begin == dev->image_end)
{
/* Fill image */
status = leo_fill_image (dev);
if (status != SANE_STATUS_GOOD)
{
return (status);
}
}
/* Something must have been read */
if (dev->image_begin == dev->image_end)
{
DBG (DBG_info, "sane_read: nothing read\n");
return SANE_STATUS_IO_ERROR;
}
/* Copy the data to the frontend buffer. */
size = max_len - buf_offset;
if (size > dev->bytes_left)
{
size = dev->bytes_left;
}
leo_copy_raw_to_frontend (dev, buf + buf_offset, &size);
buf_offset += size;
dev->bytes_left -= size;
*len += size;
}
while ((buf_offset != max_len) && dev->bytes_left);
DBG (DBG_info, "sane_read: leave, bytes_left=%ld\n",
(long) dev->bytes_left);
return SANE_STATUS_GOOD;
}
void coopth_done(void)
{
int i, tt, itd, it;
struct coopth_thrdata_t *thdata = NULL;
it = _coopth_is_in_thread_nowarn();
itd = it;
// assert(!it || is_detached());
if (it) {
thdata = co_get_data(co_current());
assert(thdata);
/* unfortunately the shutdown can run from signal handler -
* in this case we can be in a joinable thread interrupted
* by signal, and there is no way to leave that thread. */
if (!is_detached())
itd = 0;
}
/* there is no safe way to delete joinable threads without joining,
* so print error only if there are also detached threads left */
if (threads_total > threads_joinable + itd)
error("Coopth: not all detached threads properly shut down\n");
again:
tt = threads_total;
for (i = 0; i < threads_active; i++) {
int tid = active_tids[i];
struct coopth_t *thr = &coopthreads[tid];
struct coopth_per_thread_t *pth = current_thr(thr);
/* dont cancel own thread */
if (thdata && *thdata->tid == tid)
continue;
if (!pth->data.attached) {
error("\ttid=%i state=%i name=\"%s\" off=%#x\n", tid, pth->st.state,
thr->name, thr->off);
do_cancel(thr, pth);
assert(threads_total == tt - 1);
/* retry the loop as the array changed */
goto again;
} else {
g_printf("\ttid=%i state=%i name=%s off=%#x\n", tid, pth->st.state,
thr->name, thr->off);
}
}
/* at this point all detached threads should be killed,
* except perhaps current one */
assert(threads_total == threads_joinable + itd);
for (i = 0; i < coopth_num; i++) {
struct coopth_t *thr = &coopthreads[i];
int j;
/* dont free own thread */
if (thdata && *thdata->tid == i)
continue;
for (j = thr->cur_thr; j < thr->max_thr; j++) {
struct coopth_per_thread_t *pth = &thr->pth[j];
munmap(pth->stack, pth->stk_size);
}
}
if (!threads_total)
co_thread_cleanup();
else
g_printf("coopth: leaked %i threads\n", threads_total);
}
int main(int argc, char *argv[])
{
struct usb_device_descriptor devDesc;
int fd = -1;
int r;
/* Initialise timezone handling. */
tzset();
register_printf_function('W', quote_xml, quote_xml_arginfo);
lockFd = open("/tmp/puppy", O_CREAT, S_IRUSR | S_IWUSR);
if(lockFd < 0)
{
fprintf(stderr, "ERROR: Can not open lock file /tmp/puppy: %s\n",
strerror(errno));
return E_LOCK_FILE;
}
r = parseArgs(argc, argv);
if(r != 0)
{
return E_INVALID_ARGS;
}
/* Create a lock, so that other instances of puppy can detect this one. */
if(0 != flock(lockFd, LOCK_SH | LOCK_NB))
{
fprintf(stderr,
"ERROR: Can not obtain shared lock on /tmp/puppy: %s\n",
strerror(errno));
return E_GLOBAL_LOCK;
}
trace(2, fprintf(stderr, "cmd %04x on %s\n", cmd, devPath));
fd = open(devPath, O_RDWR);
if(fd < 0)
{
fprintf(stderr, "ERROR: Can not open %s for read/write: %s\n",
devPath, strerror(errno));
return E_READ_DEVICE;
}
if(0 != flock(fd, LOCK_EX | LOCK_NB))
{
fprintf(stderr, "ERROR: Can not get exclusive lock on %s\n", devPath);
close(fd);
return E_DEVICE_LOCK;
}
r = read_device_descriptor(fd, &devDesc);
if(r < 0)
{
close(fd);
return E_READ_DEVICE;
}
if(!isToppy(&devDesc))
{
fprintf(stderr, "ERROR: Could not find a Topfield TF5000PVRt\n");
close(fd);
return E_NOT_TF5000PVR;
}
trace(1, fprintf(stderr, "Found a Topfield TF5000PVRt\n"));
trace(2, fprintf(stderr, "USBDEVFS_RESET\n"));
r = ioctl(fd, USBDEVFS_RESET, NULL);
if(r < 0)
{
fprintf(stderr, "ERROR: Can not reset device: %s\n", strerror(errno));
close(fd);
return E_RESET_DEVICE;
}
{
int interface = 0;
trace(2, fprintf(stderr, "USBDEVFS_CLAIMINTERFACE\n"));
r = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &interface);
if(r < 0)
{
fprintf(stderr, "ERROR: Can not claim interface 0: %s\n",
strerror(errno));
close(fd);
return E_CLAIM_INTERFACE;
}
}
{
struct usbdevfs_setinterface interface0 = { 0, 0 };
trace(2, fprintf(stderr, "USBDEVFS_SETNTERFACE\n"));
r = ioctl(fd, USBDEVFS_SETINTERFACE, &interface0);
if(r < 0)
{
fprintf(stderr, "ERROR: Can not set interface zero: %s\n",
strerror(errno));
close(fd);
return E_SET_INTERFACE;
}
}
switch (cmd)
{
case CANCEL:
r = do_cancel(fd);
break;
case CMD_RESET:
r = do_cmd_reset(fd);
break;
case CMD_HDD_SIZE:
r = do_hdd_size(fd);
break;
case CMD_HDD_DIR:
r = do_hdd_dir(fd, arg1);
break;
case CMD_HDD_FILE_SEND:
if(sendDirection == PUT)
{
r = do_hdd_file_put(fd, arg1, arg2);
}
else
{
r = do_hdd_file_get(fd, arg1, arg2);
}
break;
case CMD_HDD_DEL:
r = do_hdd_del(fd, arg1);
break;
case CMD_HDD_RENAME:
r = do_hdd_rename(fd, arg1, arg2);
break;
case CMD_HDD_CREATE_DIR:
r = do_hdd_mkdir(fd, arg1);
break;
case CMD_TURBO:
r = do_cmd_turbo(fd, arg1);
break;
default:
fprintf(stderr, "BUG: Command 0x%08x not implemented\n", cmd);
r = -EINVAL;
}
{
int interface = 0;
ioctl(fd, USBDEVFS_RELEASEINTERFACE, &interface);
close(fd);
}
return r;
}
void
PSession::cancel ()
{
ACE_GUARD (ACE_SYNCH_MUTEX, monitor, this->mutex());
do_cancel ();
}
