mirror
/
sane-project-backends
kopia lustrzana https://gitlab.com/sane-project/backends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

* DBG() macro clean-up 

* fixed color transfer for 1600P models
        * fixed potential crash if dump file couldn't be opened for writing
        * added ppdev device name handling
        * added model override
DEVEL_2_0_BRANCH-1
Stéphane Voltz 1994-02-15 08:43:42 +00:00
rodzic f02205558f
commit 61b8100c90
6 zmienionych plików z 316 dodań i 225 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

186
backend/umax_pp.c
Wyświetl plik

@ -69,6 +69,7 @@
#include "../include/sane/sane.h" #include "../include/sane/sane.h"
#include "../include/sane/sanei.h" #include "../include/sane/sanei.h"
#include "../include/sane/saneopts.h" #include "../include/sane/saneopts.h"
#include "../include/sane/sanei_config.h"
#include "umax_pp_mid.h" #include "umax_pp_mid.h"
#include "umax_pp.h" #include "umax_pp.h"
@ -113,8 +114,8 @@ static const SANE_Device **devarray = NULL;
static Umax_PP_Device *first_dev = NULL; static Umax_PP_Device *first_dev = NULL;
/* 1 Meg scan buffer */ /* 2 Meg scan buffer */
static long int buf_size = 2024 * 1024; static long int buf_size = 2048 * 1024;
static int red_gain = 0; static int red_gain = 0;
@ -166,7 +167,10 @@ static const SANE_Range u8_range = {
#define UMAX_PP_DEFAULT_PORT 0x378 #define UMAX_PP_DEFAULT_PORT 0x378
/*
* devname may be either an hardware address for direct I/O (0x378 for instance)
* or the device name used by ppdev on linux systems (/dev/parport0 )
*/
static SANE_Status static SANE_Status
@ -175,24 +179,44 @@ attach (const char *devname)
Umax_PP_Descriptor *dev; Umax_PP_Descriptor *dev;
int i; int i;
SANE_Status status = SANE_STATUS_GOOD; SANE_Status status = SANE_STATUS_GOOD;
int ret, prt, mdl; int ret, prt = 0, mdl;
char model[32]; char model[32];
char name[64];
memset (name, 0, 64);
if ((strlen (devname) < 3) || (strlen (devname) > 8)) if ((strlen (devname) < 3))
return SANE_STATUS_INVAL; return SANE_STATUS_INVAL;
if ((devname[0] == '0') && ((devname[1] == 'x') || (devname[1] == 'X'))) /* if the name begins with a slash, it's a device, else it's an addr */
prt = strtol (devname + 2, NULL, 16); if ((devname[0] == '/'))
{
strncpy (name, devname, 64);
}
else else
prt = atoi (devname); {
if ((devname[0] == '0') && ((devname[1] == 'x') || (devname[1] == 'X')))
prt = strtol (devname + 2, NULL, 16);
else
prt = atoi (devname);
}
for (i = 0; i < num_devices; i++) for (i = 0; i < num_devices; i++)
if (strcmp (devlist[i].port, devname) == 0) {
return SANE_STATUS_GOOD; if (devname[0] == '/')
{
if (strcmp (devlist[i].ppdevice, devname) == 0)
return SANE_STATUS_GOOD;
}
else
{
if (strcmp (devlist[i].port, devname) == 0)
return SANE_STATUS_GOOD;
}
}
ret = sanei_umax_pp_attach (prt); ret = sanei_umax_pp_attach (prt, name);
switch (ret) switch (ret)
{ {
case UMAX1220P_OK: case UMAX1220P_OK:
@ -202,11 +226,11 @@ attach (const char *devname)
status = SANE_STATUS_DEVICE_BUSY; status = SANE_STATUS_DEVICE_BUSY;
break; break;
case UMAX1220P_TRANSPORT_FAILED: case UMAX1220P_TRANSPORT_FAILED:
DBG (1, "attach: failed to init transport layer on port %s\n", devname); DBG (1, "attach: failed to init transport layer on %s\n", devname);
status = SANE_STATUS_IO_ERROR; status = SANE_STATUS_IO_ERROR;
break; break;
case UMAX1220P_PROBE_FAILED: case UMAX1220P_PROBE_FAILED:
DBG (1, "attach: failed to probe scanner on port %s\n", devname); DBG (1, "attach: failed to probe scanner on %s\n", devname);
status = SANE_STATUS_IO_ERROR; status = SANE_STATUS_IO_ERROR;
break; break;
} }
@ -226,14 +250,14 @@ attach (const char *devname)
ret = sanei_umax_pp_model (prt, &mdl); ret = sanei_umax_pp_model (prt, &mdl);
if (ret != UMAX1220P_OK) if (ret != UMAX1220P_OK)
{ {
DBG (1, "attach: waiting for busy scanner on port %s\n", devname); DBG (1, "attach: waiting for busy scanner on %s\n", devname);
} }
} }
while (ret == UMAX1220P_BUSY); while (ret == UMAX1220P_BUSY);
if (ret != UMAX1220P_OK) if (ret != UMAX1220P_OK)
{ {
DBG (1, "attach: failed to recognize scanner model on port %s\n", DBG (1, "attach: failed to recognize scanner model on %s\n",
devname); devname);
return SANE_STATUS_IO_ERROR; return SANE_STATUS_IO_ERROR;
} }
@ -264,7 +288,10 @@ attach (const char *devname)
dev->sane.vendor = strdup ("UMAX"); dev->sane.vendor = strdup ("UMAX");
dev->sane.type = "flatbed scanner"; dev->sane.type = "flatbed scanner";
dev->port = strdup (devname); if (devname[0] == '/')
dev->ppdevice = strdup (devname);
else
dev->port = strdup (devname);
dev->buf_size = buf_size; dev->buf_size = buf_size;
if (mdl > 610) if (mdl > 610)
@ -601,8 +628,7 @@ init_options (Umax_PP_Device * dev)
SANE_Status SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
{ {
char dev_name[512]; char dev_name[512];
const char *cp; const char *cp;
@ -650,6 +676,7 @@ sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
if (strncmp (cp, "option", 6) == 0 && isspace (cp[6])) if (strncmp (cp, "option", 6) == 0 && isspace (cp[6]))
{ {
DBG (3, "init: evaluating option <%s>\n", cp);
cp += 7; cp += 7;
cp = sanei_config_skip_whitespace (cp); cp = sanei_config_skip_whitespace (cp);
@ -684,12 +711,12 @@ sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
devlist[0].buf_size = val; devlist[0].buf_size = val;
} }
} }
else if (strncmp (cp, "astra", 6) == 0) else if (strncmp (cp, "astra", 5) == 0)
{ {
char *end; char *end;
long int val; long int val;
cp += 7; cp += 6;
errno = 0; errno = 0;
val = strtol (cp, &end, 0); val = strtol (cp, &end, 0);
@ -978,13 +1005,13 @@ sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
return SANE_STATUS_GOOD; return SANE_STATUS_GOOD;
} }
SANE_Status SANE_Status sane_open (SANE_String_Const devicename, SANE_Handle * handle)
sane_open (SANE_String_Const devicename, SANE_Handle * handle)
{ {
Umax_PP_Device *dev; Umax_PP_Device *dev;
Umax_PP_Descriptor *desc; Umax_PP_Descriptor *desc;
int i, j; int i, j;
int rc, prt; int rc, prt = 0;
char *name = NULL;
DBG (3, "open: device `%s'\n", devicename); DBG (3, "open: device `%s'\n", devicename);
@ -1008,14 +1035,21 @@ sane_open (SANE_String_Const devicename, SANE_Handle * handle)
desc = &devlist[i]; desc = &devlist[i];
if ((devlist[i].port[0] == '0') if (devlist[i].ppdevice[0] == '/')
&& ((devlist[i].port[1] == 'x') || (devlist[i].port[1] == 'X'))) {
prt = strtol (devlist[i].port + 2, NULL, 16); name = devlist[i].ppdevice;
}
else else
prt = atoi (devlist[i].port); {
DBG (64, "open: devlist[i].port='%s' -> port=0x%X\n", devlist[i].port, if ((devlist[i].port[0] == '0')
prt); && ((devlist[i].port[1] == 'x') || (devlist[i].port[1] == 'X')))
rc = sanei_umax_pp_open (prt); prt = strtol (devlist[i].port + 2, NULL, 16);
else
prt = atoi (devlist[i].port);
DBG (64, "open: devlist[i].port='%s' -> port=0x%X\n",
devlist[i].port, prt);
}
rc = sanei_umax_pp_open (prt, name);
} }
else else
{ {
@ -1029,22 +1063,44 @@ sane_open (SANE_String_Const devicename, SANE_Handle * handle)
DBG (3, "open: trying default device %s, port=%s\n", DBG (3, "open: trying default device %s, port=%s\n",
devlist[0].sane.name, devlist[0].port); devlist[0].sane.name, devlist[0].port);
rc = sanei_umax_pp_open (atoi (devlist[0].port)); rc = sanei_umax_pp_open (atoi (devlist[0].port), NULL);
desc = &devlist[0]; desc = &devlist[0];
} }
switch (rc) switch (rc)
{ {
case UMAX1220P_TRANSPORT_FAILED: case UMAX1220P_TRANSPORT_FAILED:
DBG (1, "failed to init transport layer on port 0x%03X\n", if (name == NULL)
atoi (desc->port)); {
DBG (1, "failed to init transport layer on port 0x%03X\n",
atoi (desc->port));
}
else
{
DBG (1, "failed to init transport layer on device %s\n", name);
}
return SANE_STATUS_IO_ERROR; return SANE_STATUS_IO_ERROR;
case UMAX1220P_SCANNER_FAILED: case UMAX1220P_SCANNER_FAILED:
DBG (1, "failed to initialize scanner on port 0x%03X\n", if (name == NULL)
atoi (desc->port)); {
DBG (1, "failed to initialize scanner on port 0x%03X\n",
atoi (desc->port));
}
else
{
DBG (1, "failed to initialize scanner on device %s\n", name);
}
return SANE_STATUS_IO_ERROR; return SANE_STATUS_IO_ERROR;
case UMAX1220P_BUSY: case UMAX1220P_BUSY:
DBG (1, "busy scanner on port 0x%03X\n", atoi (desc->port)); if (name == NULL)
{
DBG (1, "busy scanner on port 0x%03X\n", atoi (desc->port));
}
else
{
DBG (1, "busy scanner on device %s\n", name);
}
return SANE_STATUS_DEVICE_BUSY; return SANE_STATUS_DEVICE_BUSY;
} }
@ -1238,7 +1294,7 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
return SANE_STATUS_INVAL; return SANE_STATUS_INVAL;
} }
DBG (6, "control_option: option <%s>, action ... ", dev->opt[option].name, DBG (6, "control_option: option <%s>, action ... %d", dev->opt[option].name,
action); action);
if (action == SANE_ACTION_GET_VALUE) if (action == SANE_ACTION_GET_VALUE)
@ -1665,8 +1721,7 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
} }
SANE_Status SANE_Status sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
{ {
Umax_PP_Device *dev = handle; Umax_PP_Device *dev = handle;
int dpi, remain; int dpi, remain;
@ -1821,8 +1876,7 @@ sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
} }
SANE_Status SANE_Status sane_start (SANE_Handle handle)
sane_start (SANE_Handle handle)
{ {
Umax_PP_Device *dev = handle; Umax_PP_Device *dev = handle;
int rc, autoset; int rc, autoset;
@ -1898,8 +1952,8 @@ sane_start (SANE_Handle handle)
dev->TopX, dev->TopX,
dev->TopY, dev->TopY,
dev->BottomX - dev->TopX, dev->BottomX - dev->TopX,
dev->BottomY - dev->TopY, dev->dpi, dev->green_gain << 4, dev->BottomY - dev->TopY, dev->dpi, dev->gray_gain << 4,
dev->BottomY - dev->TopY, dev->dpi, dev->green_highlight << 4); dev->gray_highlight << 4);
rc = sanei_umax_pp_start (dev->TopX, rc = sanei_umax_pp_start (dev->TopX,
dev->TopY, dev->TopY,
dev->BottomX - dev->TopX, dev->BottomX - dev->TopX,
@ -1997,7 +2051,7 @@ sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
/* re order data into RGB */ /* re order data into RGB */
if (dev->color == UMAX_PP_MODE_COLOR) if (dev->color == UMAX_PP_MODE_COLOR)
{ {
DBG (64, "sane_read: reordering %d bytes of data (lines=%d)\n", DBG (64, "sane_read: reordering %ld bytes of data (lines=%d)\n",
length, nl); length, nl);
lbuf = (SANE_Byte *) malloc (dev->bufsize); lbuf = (SANE_Byte *) malloc (dev->bufsize);
if (lbuf == NULL) if (lbuf == NULL)
@ -2007,16 +2061,34 @@ sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
return SANE_STATUS_NO_MEM; return SANE_STATUS_NO_MEM;
} }
/* this loop will be optimized when everything else will be working */ /* this loop will be optimized when everything else will be working */
for (y = 0; y < nl; y++) if (sanei_umax_pp_getastra () == 1600)
{ {
for (x = 0; x < dev->tw; x++) for (y = 0; y < nl; y++)
{ {
lbuf[x * dev->bpp + y * ll] = for (x = 0; x < dev->tw; x++)
dev->buf[dev->bufread + x + y * ll + 2 * dev->tw]; {
lbuf[x * dev->bpp + y * ll + 1] = lbuf[x * dev->bpp + y * ll] =
dev->buf[dev->bufread + x + y * ll + dev->tw]; dev->buf[dev->bufread + x + y * ll + 2 * dev->tw];
lbuf[x * dev->bpp + y * ll + 2] = lbuf[x * dev->bpp + y * ll + 1] =
dev->buf[dev->bufread + x + y * ll]; dev->buf[dev->bufread + x + y * ll];
lbuf[x * dev->bpp + y * ll + 2] =
dev->buf[dev->bufread + x + y * ll + dev->tw];
}
}
}
else
{
for (y = 0; y < nl; y++)
{
for (x = 0; x < dev->tw; x++)
{
lbuf[x * dev->bpp + y * ll] =
dev->buf[dev->bufread + x + y * ll + 2 * dev->tw];
lbuf[x * dev->bpp + y * ll + 1] =
dev->buf[dev->bufread + x + y * ll + dev->tw];
lbuf[x * dev->bpp + y * ll + 2] =
dev->buf[dev->bufread + x + y * ll];
}
} }
} }
/* avoids memcopy */ /* avoids memcopy */
@ -2037,7 +2109,7 @@ sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
*len = length; *len = length;
dev->bufread += length; dev->bufread += length;
dev->read += length; dev->read += length;
DBG (64, "sane_read %d bytes read\n", length); DBG (64, "sane_read %ld bytes read\n", length);
return SANE_STATUS_GOOD; return SANE_STATUS_GOOD;
@ -2081,8 +2153,7 @@ sane_cancel (SANE_Handle handle)
} }
} }
SANE_Status SANE_Status sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
{ {
DBG (129, "unused arg: handle = %p, non_blocking = %d\n", DBG (129, "unused arg: handle = %p, non_blocking = %d\n",
handle, (int) non_blocking); handle, (int) non_blocking);
@ -2092,11 +2163,10 @@ sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
return SANE_STATUS_UNSUPPORTED; return SANE_STATUS_UNSUPPORTED;
} }
SANE_Status SANE_Status sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
{ {
DBG (129, "unused arg: handle = %p, fd = %p\n", handle, fd); DBG (129, "unused arg: handle = %p, fd = %p\n", handle, (void *)fd);
DBG (2, "get_select_fd: not supported\n"); DBG (2, "get_select_fd: not supported\n");

1
backend/umax_pp.h
Wyświetl plik

@ -106,6 +106,7 @@ typedef struct Umax_PP_Descriptor
SANE_Device sane; SANE_Device sane;
SANE_String port; SANE_String port;
SANE_String ppdevice;
SANE_Int max_res; SANE_Int max_res;
SANE_Int max_h_size; SANE_Int max_h_size;

310
backend/umax_pp_low.c
Wyświetl plik

@ -399,7 +399,7 @@ sanei_parport_info (int number, int *addr)
int int
sanei_umax_pp_InitPort (int port) sanei_umax_pp_InitPort (int port, char *name)
{ {
int fd; int fd;
int found = 0; int found = 0;
@ -408,9 +408,6 @@ sanei_umax_pp_InitPort (int port)
#endif #endif
#ifdef HAVE_LINUX_PPDEV_H #ifdef HAVE_LINUX_PPDEV_H
char strmodes[160]; char strmodes[160];
char parport_name[16];
int i;
int addr;
#endif #endif
/* since this function must be called before */ /* since this function must be called before */
@ -427,151 +424,146 @@ sanei_umax_pp_InitPort (int port)
#ifdef HAVE_LINUX_PPDEV_H #ifdef HAVE_LINUX_PPDEV_H
/* ppdev opening and configuration */ if (name != NULL)
/* we start with /dev/parport0 and go through all /dev/parportx */
/* until we find the right one */
i = 0;
found = 0;
sprintf (parport_name, "/dev/parport%d", i);
fd = open (parport_name, O_RDWR | O_NOCTTY);
while ((fd != -1) && (!found))
{ {
/* claim port */ if (strlen (name) > 3)
if (ioctl (fd, PPCLAIM))
{ {
DBG (1, "umax_pp: cannot claim port '%s'\n", parport_name); /* ppdev opening and configuration */
} found = 0;
else fd = open (name, O_RDWR | O_NOCTTY);
{ if (fd < 0)
/* we check if parport does EPP or ECP */
#ifdef PPGETMODES
if (ioctl (fd, PPGETMODES, &mode))
{ {
DBG (16, "umax_pp: ppdev couldn't gave modes for port '%s'\n", switch (errno)
parport_name); {
case ENOENT:
DBG (1, "umax_pp: '%s' does not exist \n", name);
break;
case EACCES:
DBG (1,
"umax_pp: current user has not R/W permissions on '%s' \n",
name);
break;
}
return (0);
}
/* claim port */
if (ioctl (fd, PPCLAIM))
{
DBG (1, "umax_pp: cannot claim port '%s'\n", name);
} }
else else
{ {
sprintf (strmodes, "\n"); /* we check if parport does EPP or ECP */
if (mode & PARPORT_MODE_PCSPP) #ifdef PPGETMODES
sprintf (strmodes, "%s\t\tPARPORT_MODE_PCSPP\n", strmodes); if (ioctl (fd, PPGETMODES, &mode))
if (mode & PARPORT_MODE_TRISTATE)
sprintf (strmodes, "%s\t\tPARPORT_MODE_TRISTATE\n", strmodes);
if (mode & PARPORT_MODE_EPP)
sprintf (strmodes, "%s\t\tPARPORT_MODE_EPP\n", strmodes);
if (mode & PARPORT_MODE_ECP)
sprintf (strmodes, "%s\t\tPARPORT_MODE_ECP\n", strmodes);
if (mode & PARPORT_MODE_COMPAT)
sprintf (strmodes, "%s\t\tPARPORT_MODE_COMPAT\n", strmodes);
if (mode & PARPORT_MODE_DMA)
sprintf (strmodes, "%s\t\tPARPORT_MODE_DMA\n", strmodes);
DBG (32, "parport modes: %X\n", mode);
DBG (32, "parport modes: %s\n", strmodes);
if (!(mode & PARPORT_MODE_EPP) && !(mode & PARPORT_MODE_ECP))
{ {
DBG (1, DBG (16,
"port 0x%X does not have EPP or ECP, giving up ...\n", "umax_pp: ppdev couldn't gave modes for port '%s'\n",
port); name);
mode = IEEE1284_MODE_COMPAT; }
ioctl (fd, PPSETMODE, &mode); else
ioctl (fd, PPRELEASE); {
close (fd); sprintf (strmodes, "\n");
return (0); if (mode & PARPORT_MODE_PCSPP)
sprintf (strmodes, "%s\t\tPARPORT_MODE_PCSPP\n",
strmodes);
if (mode & PARPORT_MODE_TRISTATE)
sprintf (strmodes, "%s\t\tPARPORT_MODE_TRISTATE\n",
strmodes);
if (mode & PARPORT_MODE_EPP)
sprintf (strmodes, "%s\t\tPARPORT_MODE_EPP\n", strmodes);
if (mode & PARPORT_MODE_ECP)
sprintf (strmodes, "%s\t\tPARPORT_MODE_ECP\n", strmodes);
if (mode & PARPORT_MODE_COMPAT)
sprintf (strmodes, "%s\t\tPARPORT_MODE_COMPAT\n",
strmodes);
if (mode & PARPORT_MODE_DMA)
sprintf (strmodes, "%s\t\tPARPORT_MODE_DMA\n", strmodes);
DBG (32, "parport modes: %X\n", mode);
DBG (32, "parport modes: %s\n", strmodes);
if (!(mode & PARPORT_MODE_EPP)
&& !(mode & PARPORT_MODE_ECP))
{
DBG (1,
"port 0x%X does not have EPP or ECP, giving up ...\n",
port);
mode = IEEE1284_MODE_COMPAT;
ioctl (fd, PPSETMODE, &mode);
ioctl (fd, PPRELEASE);
close (fd);
return (0);
}
} }
}
#else #else
DBG (16, DBG (16,
"umax_pp: ppdev used to build SANE doesn't have PPGETMODES.\n"); "umax_pp: ppdev used to build SANE doesn't have PPGETMODES.\n");
#endif #endif
/* prefered mode is EPP */ /* prefered mode is EPP */
mode = IEEE1284_MODE_EPP; mode = IEEE1284_MODE_EPP;
mode = ioctl (fd, PPNEGOT, &mode); mode = ioctl (fd, PPNEGOT, &mode);
if (mode) if (mode)
{ {
DBG (16, DBG (16,
"umax_pp: ppdev couldn't negociate mode IEEE1284_MODE_EPP for '%s'\n", "umax_pp: ppdev couldn't negociate mode IEEE1284_MODE_EPP for '%s'\n",
parport_name); name);
} }
if (ioctl (fd, PPSETMODE, &mode))
{
DBG (16,
"umax_pp: ppdev couldn't set mode to IEEE1284_MODE_EPP for '%s'\n",
parport_name);
mode = IEEE1284_MODE_ECP;
if (ioctl (fd, PPSETMODE, &mode)) if (ioctl (fd, PPSETMODE, &mode))
{ {
DBG (16, DBG (16,
"umax_pp: ppdev couldn't set mode to IEEE1284_MODE_ECP for '%s'\n", "umax_pp: ppdev couldn't set mode to IEEE1284_MODE_EPP for '%s'\n",
parport_name); name);
DBG (1,
"port 0x%X can't be set to EPP or ECP, giving up ...\n",
port);
mode = IEEE1284_MODE_COMPAT; mode = IEEE1284_MODE_ECP;
ioctl (fd, PPSETMODE, &mode); if (ioctl (fd, PPSETMODE, &mode))
ioctl (fd, PPRELEASE); {
close (fd); DBG (16,
return (0); "umax_pp: ppdev couldn't set mode to IEEE1284_MODE_ECP for '%s'\n",
name);
DBG (1,
"port 0x%X can't be set to EPP or ECP, giving up ...\n",
port);
mode = IEEE1284_MODE_COMPAT;
ioctl (fd, PPSETMODE, &mode);
ioctl (fd, PPRELEASE);
close (fd);
return (0);
}
else
{
DBG (16,
"umax_pp: mode set to PARPORT_MODE_ECP for '%s'\n",
name);
}
} }
else else
{ {
DBG (16, DBG (16,
"umax_pp: mode set to PARPORT_MODE_ECP for '%s'\n", "umax_pp: mode set to PARPORT_MODE_EPP for '%s'\n",
parport_name); name);
} }
/* allways start in compat mode (for probe) */
mode = IEEE1284_MODE_COMPAT;
ioctl (fd, PPSETMODE, &mode);
found = 1;
}
if (!found)
{
DBG (1, "device %s does not fit ...\n",name);
} }
else else
{ {
DBG (16, DBG (1, "Using %s ...\n", name);
"umax_pp: mode set to PARPORT_MODE_EPP for '%s'\n", sanei_umax_pp_setparport (fd);
parport_name); return (1);
}
/* find the base addr of ppdev */
if (sanei_parport_info (i, &addr))
{
if (gPort == addr)
{
found = 1;
DBG (1, "Using /proc info\n");
}
}
/* allways start in compat mode (for probe) */
mode = IEEE1284_MODE_COMPAT;
ioctl (fd, PPSETMODE, &mode);
/* release port */
if (!found)
{
ioctl (fd, PPRELEASE);
} }
} }
/* next parport */
if (!found)
{
close (fd);
i++;
sprintf (parport_name, "/dev/parport%d", i);
fd = open (parport_name, O_RDONLY | O_NOCTTY);
}
}
if (!found)
{
DBG (1, "no relevant /dev/parportx found...\n");
}
else
{
DBG (1, "Using /dev/parport%d ...\n", i);
sanei_umax_pp_setparport (fd);
return (1);
} }
#endif /* HAVE_LINUX_PPDEV_H */ #endif /* HAVE_LINUX_PPDEV_H */
@ -836,7 +828,7 @@ Outsw (int port, unsigned char *source, int size)
static int scannerStatus = 0; static int scannerStatus = 0;
static int epp32 = 1; static int epp32 = 1;
static int model = 0x15; static int model = 0x15;
static int astra = 1220; static int astra = 0;
int int
sanei_umax_pp_ScannerStatus (void) sanei_umax_pp_ScannerStatus (void)
@ -2533,6 +2525,8 @@ SendWord (int *cmd)
/******************************************************************************/ /******************************************************************************/
/* RingScanner: returns 1 if scanner present, else 0 */ /* RingScanner: returns 1 if scanner present, else 0 */
/******************************************************************************/ /******************************************************************************/
#define UMAX_PP_PAUSE 100
static int static int
RingScanner (void) RingScanner (void)
{ {
@ -2557,29 +2551,29 @@ RingScanner (void)
/* send ring string */ /* send ring string */
Outb (DATA, 0x22); Outb (DATA, 0x22);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0x22); Outb (DATA, 0x22);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0xAA); Outb (DATA, 0xAA);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0xAA); Outb (DATA, 0xAA);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0x55); Outb (DATA, 0x55);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0x55); Outb (DATA, 0x55);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0x00); Outb (DATA, 0x00);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0x00); Outb (DATA, 0x00);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0xFF); Outb (DATA, 0xFF);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0xFF); Outb (DATA, 0xFF);
usleep (1000); usleep (UMAX_PP_PAUSE);
/* OK ? */ /* OK ? */
status = Inb (STATUS); status = Inb (STATUS);
usleep (1000); usleep (UMAX_PP_PAUSE);
if ((status & 0xB8) != 0xB8) if ((status & 0xB8) != 0xB8)
{ {
DBG (1, "status %d doesn't match! %s:%d\n", status, __FILE__, __LINE__); DBG (1, "status %d doesn't match! %s:%d\n", status, __FILE__, __LINE__);
@ -2590,11 +2584,11 @@ RingScanner (void)
if (ret) if (ret)
{ {
Outb (DATA, 0x87); Outb (DATA, 0x87);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0x87); Outb (DATA, 0x87);
usleep (1000); usleep (UMAX_PP_PAUSE);
status = Inb (STATUS); status = Inb (STATUS);
usleep (1000); usleep (UMAX_PP_PAUSE);
if ((status & 0xB8) != 0x18) if ((status & 0xB8) != 0x18)
{ {
DBG (1, "status %d doesn't match! %s:%d\n", status, __FILE__, DBG (1, "status %d doesn't match! %s:%d\n", status, __FILE__,
@ -2607,9 +2601,9 @@ RingScanner (void)
if (ret) if (ret)
{ {
Outb (DATA, 0x78); Outb (DATA, 0x78);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0x78); Outb (DATA, 0x78);
usleep (1000); usleep (UMAX_PP_PAUSE);
status = Inb (STATUS); status = Inb (STATUS);
if ((status & 0x30) != 0x30) if ((status & 0x30) != 0x30)
{ {
@ -2623,13 +2617,13 @@ RingScanner (void)
if (ret) if (ret)
{ {
Outb (DATA, 0x08); Outb (DATA, 0x08);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0x08); Outb (DATA, 0x08);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0xFF); Outb (DATA, 0xFF);
usleep (1000); usleep (UMAX_PP_PAUSE);
Outb (DATA, 0xFF); Outb (DATA, 0xFF);
usleep (1000); usleep (UMAX_PP_PAUSE);
} }
/* restore state */ /* restore state */
@ -4164,7 +4158,8 @@ Probe610P (int recover)
recover = 0; /* quit compiler quiet .. */ recover = 0; /* quit compiler quiet .. */
/* make sure we won't try 1220/200P later */ /* make sure we won't try 1220/200P later */
sanei_umax_pp_setastra (610); if(!sanei_umax_pp_getastra())
sanei_umax_pp_setastra (610);
if (!Test610P (0x87)) if (!Test610P (0x87))
{ {
DBG (1, "Ring610P(0x87) failed (%s:%d)\n", __FILE__, __LINE__); DBG (1, "Ring610P(0x87) failed (%s:%d)\n", __FILE__, __LINE__);
@ -4997,7 +4992,7 @@ sanei_umax_pp_ProbeScanner (int recover)
__FILE__, __LINE__); __FILE__, __LINE__);
if (CmdSetDataBuffer (voidbuf) != 1) if (CmdSetDataBuffer (voidbuf) != 1)
{ {
DBG (0, "Loop %d: CmdSetDataBuffer(voidbuf) failed ! (%s:%d) \n", DBG (0, "Loop %d: CmdSetDataBuffer(voidbuf) failed ! (%s:%d) \n",i,
__FILE__, __LINE__); __FILE__, __LINE__);
return (0); return (0);
} }
@ -6159,12 +6154,12 @@ DumpRVB (int width, int height, unsigned char *data, char *name)
sprintf (titre, "%s", name); sprintf (titre, "%s", name);
} }
fic = fopen (titre, "wb"); fic = fopen (titre, "wb");
fprintf (fic, "P6\n%d %d\n255\n", width, height);
if (fic == NULL) if (fic == NULL)
{ {
DBG (0, "could not open %s for writing\n", titre); DBG (0, "could not open %s for writing\n", titre);
return; return;
} }
fprintf (fic, "P6\n%d %d\n255\n", width, height);
for (y = 0; y < height; y++) for (y = 0; y < height; y++)
{ {
for (x = 0; x < width; x++) for (x = 0; x < width; x++)
@ -6218,7 +6213,7 @@ EvalGain (int sum, int count)
{ {
int gn; int gn;
/* 19000 is a little to bright */ /* 19000 is a little too bright */
gn = (int) ((double) (18500 * count) / sum - 100 + 0.5); gn = (int) ((double) (18500 * count) / sum - 100 + 0.5);
if (gn < 0) if (gn < 0)
gn = 0; gn = 0;
@ -6606,6 +6601,7 @@ MoveToOrigin (void)
if ((edge <= 30) && (sanei_umax_pp_getastra () != 1600)) if ((edge <= 30) && (sanei_umax_pp_getastra () != 1600))
{ {
DBG (2, "MoveToOrigin() detected a 1600P"); DBG (2, "MoveToOrigin() detected a 1600P");
if(!sanei_umax_pp_getastra())
sanei_umax_pp_setastra (1600); sanei_umax_pp_setastra (1600);
} }
edge = EdgePosition (300, 180, buffer); edge = EdgePosition (300, 180, buffer);
@ -7285,8 +7281,8 @@ sanei_umax_pp_Scan (int x, int y, int width, int height, int dpi, int color,
/* write data to file operation */ /* write data to file operation */
/*blocksize=(2096100/bpl)*bpl; */ /*blocksize=(2096100/bpl)*bpl; */
bpl = bpp * tw; bpl = bpp * tw;
hp = 16776960 / bpl; /* 16 Mo buffer (!!) */
hp = 2096100 / bpl; hp = 2096100 / bpl;
hp = 16776960 / bpl;
blocksize = hp * bpl; blocksize = hp * bpl;
nb = 0; nb = 0;
read = 0; read = 0;
@ -7345,7 +7341,6 @@ sanei_umax_pp_Scan (int x, int y, int width, int height, int dpi, int color,
DBG (8, "Read %ld bytes out of %ld ...\n", read, somme); DBG (8, "Read %ld bytes out of %ld ...\n", read, somme);
DBG (8, "Read %d blocks ... \n", nb); DBG (8, "Read %d blocks ... \n", nb);
/* write partial buffer to file */ /* write partial buffer to file */
if (len) if (len)
{ {
@ -7386,6 +7381,11 @@ sanei_umax_pp_Scan (int x, int y, int width, int height, int dpi, int color,
#ifdef HAVE_SYS_TIME_H #ifdef HAVE_SYS_TIME_H
gettimeofday (&tf, NULL); gettimeofday (&tf, NULL);
/* scan time are high enough to forget about usec */
elapsed = tf.tv_sec - td.tv_sec;
DBG (8, "%ld bytes transfered in %f seconds ( %.2f Kb/s)\n", somme,
elapsed, (somme / elapsed) / 1024.0);
#endif #endif
/* release ressources */ /* release ressources */
@ -7394,13 +7394,6 @@ sanei_umax_pp_Scan (int x, int y, int width, int height, int dpi, int color,
free (dest); free (dest);
free (buffer); free (buffer);
/* scan time are high enough to forget about usec */
#ifdef HAVE_SYS_TIME_H
elapsed = tf.tv_sec - td.tv_sec;
DBG (8, "%ld bytes transfered in %f seconds ( %.2f Kb/s)\n", somme,
elapsed, (somme / elapsed) / 1024.0);
#endif
/* park head */ /* park head */
distance = distance + y + height; distance = distance + y + height;
@ -8039,6 +8032,7 @@ sanei_umax_pp_CheckModel (void)
/* if data has turned into 0, we have a 2000P */ /* if data has turned into 0, we have a 2000P */
if (dest[1] == 0x00) if (dest[1] == 0x00)
{ {
if(!sanei_umax_pp_getastra())
sanei_umax_pp_setastra (2000); sanei_umax_pp_setastra (2000);
err = 2000; err = 2000;
} }

2
backend/umax_pp_low.h
Wyświetl plik

@ -46,7 +46,7 @@
/*****************************************************************************/ /*****************************************************************************/
/* set port to 'idle state' and get iopl */ /* set port to 'idle state' and get iopl */
/*****************************************************************************/ /*****************************************************************************/
extern int sanei_umax_pp_InitPort (int port); extern int sanei_umax_pp_InitPort (int port, char *name);

32
backend/umax_pp_mid.c
Wyświetl plik

@ -169,7 +169,16 @@ sanei_umax_pp_model (int port, int *model)
unlock_parport (); unlock_parport ();
return (UMAX1220P_TRANSPORT_FAILED); return (UMAX1220P_TRANSPORT_FAILED);
} }
rc = sanei_umax_pp_CheckModel ();
/* check model only, and if only none given in conf file */
if (!sanei_umax_pp_getastra ())
{
rc = sanei_umax_pp_CheckModel ();
}
else
{
rc = sanei_umax_pp_getastra ();
}
sanei_umax_pp_EndSession (); sanei_umax_pp_EndSession ();
unlock_parport (); unlock_parport ();
if (rc < 610) if (rc < 610)
@ -186,14 +195,22 @@ sanei_umax_pp_model (int port, int *model)
} }
int int
sanei_umax_pp_attach (int port) sanei_umax_pp_attach (int port, char *name)
{ {
int recover = 0; int recover = 0;
/* set up port */ /* set up port */
DBG (3, "sanei_umax_pp_attach\n"); if (name == NULL)
{
DBG (3, "sanei_umax_pp_attach(%d,NULL)\n", port);
}
else
{
DBG (3, "sanei_umax_pp_attach(%d,%s)\n", port, name);
}
sanei_umax_pp_setport (port); sanei_umax_pp_setport (port);
if (sanei_umax_pp_InitPort (port) != 1) if (sanei_umax_pp_InitPort (port, name) != 1)
return (UMAX1220P_PROBE_FAILED); return (UMAX1220P_PROBE_FAILED);
/* init port locks the port, so we flag that */ /* init port locks the port, so we flag that */
@ -228,14 +245,17 @@ sanei_umax_pp_attach (int port)
int int
sanei_umax_pp_open (int port) sanei_umax_pp_open (int port, char *name)
{ {
int rc; int rc;
int recover = 0; int recover = 0;
/* set up port */ /* set up port */
DBG (3, "sanei_umax_pp_open\n"); DBG (3, "sanei_umax_pp_open\n");
sanei_umax_pp_setport (port);
if (name == NULL)
sanei_umax_pp_setport (port);
if (lock_parport () == UMAX1220P_BUSY) if (lock_parport () == UMAX1220P_BUSY)
return (UMAX1220P_BUSY); return (UMAX1220P_BUSY);

10
backend/umax_pp_mid.h
Wyświetl plik

@ -66,12 +66,15 @@
initialize transport layer initialize transport layer
probe scanner probe scanner
if name is null, direct I/O is attempted to address given in port
else ppdev is tried using the given name as device
on success returns UMAX1220P_OK, on success returns UMAX1220P_OK,
else one of the error above. else one of the error above.
*/ */
extern int sanei_umax_pp_attach (int port); extern int sanei_umax_pp_attach (int port, char *name);
/* /*
recognizes 1220P from 2000P recognizes 1220P from 2000P
@ -104,9 +107,12 @@ extern int sanei_umax_pp_lamp (int on);
on succes returns UMAX1220P_OK, on succes returns UMAX1220P_OK,
else one of the error above. else one of the error above.
port: addr when doing direc I/O
name: ppdev character device name
*/ */
extern int sanei_umax_pp_open (int port); extern int sanei_umax_pp_open (int port,char *name);