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

Use consistently __func__ instead of __FUNCTION__ 

Some parts of SANE used __FUNCTION__ while other parts used __func__.
Now, __func__ is used consistently throughout the SANE sources.  This
fixes all occurrences of the following GCC warning:

warning: ISO C does not support '__FUNCTION__' predefined identifier
merge-requests/1/head
Volker Diels-Grabsch 2015-12-05 10:48:59 +01:00 zatwierdzone przez Olaf Meeuwissen
rodzic 93298674d0
commit baec5e0395
25 zmienionych plików z 577 dodań i 577 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

4
backend/epson2_net.c
Wyświetl plik

@ -104,7 +104,7 @@ sanei_epson_net_read(Epson_Scanner *s, unsigned char *buf, ssize_t wanted,
size = be32atoh(&header[6]);
DBG(23, "%s: wanted = %lu, available = %lu\n", __FUNCTION__,
DBG(23, "%s: wanted = %lu, available = %lu\n", __func__,
(u_long) wanted, (u_long) size);
*status = SANE_STATUS_GOOD;
@ -170,7 +170,7 @@ sanei_epson_net_write(Epson_Scanner *s, unsigned int cmd, const unsigned char *b
}
DBG(24, "%s: cmd = %04x, buf = %p, buf_size = %lu, reply_len = %lu\n",
__FUNCTION__, cmd, buf, (u_long) buf_size, (u_long) reply_len);
__func__, cmd, buf, (u_long) buf_size, (u_long) reply_len);
memset(h1, 0x00, 12);
memset(h2, 0x00, 8);

2
backend/epson2_scsi.c
Wyświetl plik

@ -32,7 +32,7 @@ sanei_epson2_scsi_sense_handler(int scsi_fd,
if (result[0] && result[0] != 0x70) {
DBG(2, "%s: sense code = 0x%02x\n",
__FUNCTION__, result[0]);
__func__, result[0]);
return SANE_STATUS_IO_ERROR;
} else {
return SANE_STATUS_GOOD;

82
backend/genesys.c
Wyświetl plik

@ -387,7 +387,7 @@ sanei_genesys_create_slope_table3 (Genesys_Device * dev,
DBG (DBG_proc,
"%s: step_type = %d, "
"exposure_time = %d, yres = %g, power_mode = %d\n", __FUNCTION__, step_type,
"exposure_time = %d, yres = %g, power_mode = %d\n", __func__, step_type,
exposure_time, yres, power_mode);
/* final speed */
@ -792,7 +792,7 @@ sanei_genesys_exposure_time2 (Genesys_Device * dev, float ydpi,
exposure = exposure_by_led;
DBG (DBG_info, "%s: ydpi=%d, step=%d, endpixel=%d led=%d, power=%d => exposure=%d\n",
__FUNCTION__, (int)ydpi, step_type, endpixel, exposure_by_led, power_mode, exposure);
__func__, (int)ydpi, step_type, endpixel, exposure_by_led, power_mode, exposure);
return exposure;
}
@ -928,7 +928,7 @@ genesys_send_offset_and_shading (Genesys_Device * dev, uint8_t * data,
int start_address;
SANE_Status status;
DBG (DBG_proc, "%s: (size = %d)\n", __FUNCTION__, size);
DBG (DBG_proc, "%s: (size = %d)\n", __func__, size);
/* ASIC higher than gl843 doesn't have register 2A/2B, so we route to
* a per ASIC shading data loading function if available.
@ -978,7 +978,7 @@ genesys_send_offset_and_shading (Genesys_Device * dev, uint8_t * data,
status = sanei_genesys_set_buffer_address (dev, start_address);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to set buffer address: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to set buffer address: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -986,7 +986,7 @@ genesys_send_offset_and_shading (Genesys_Device * dev, uint8_t * data,
status = dev->model->cmd_set->bulk_write_data (dev, 0x3c, data, size);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to send shading table: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to send shading table: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1046,7 +1046,7 @@ sanei_genesys_init_shading_data (Genesys_Device * dev, int pixels_per_line)
free (shading_data);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to send shading data: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to send shading data: %s\n", __func__,
sane_strstatus (status));
}
@ -1489,7 +1489,7 @@ genesys_coarse_calibration (Genesys_Device * dev)
status = dev->model->cmd_set->set_fe (dev, AFE_INIT);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to set frontend: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to set frontend: %s\n", __func__,
sane_strstatus (status));
free(all_data);
free(calibration_data);
@ -2180,7 +2180,7 @@ genesys_dark_white_shading_calibration (Genesys_Device * dev)
SANE_Bool motor;
DBG (DBG_proc, "%s: (lines = %d)\n", __FUNCTION__, (unsigned int)dev->calib_lines);
DBG (DBG_proc, "%s: (lines = %d)\n", __func__, (unsigned int)dev->calib_lines);
pixels_per_line = dev->calib_pixels;
channels = dev->calib_channels;
@ -2193,7 +2193,7 @@ genesys_dark_white_shading_calibration (Genesys_Device * dev)
dev->white_average_data = malloc (dev->average_size);
if (!dev->white_average_data)
{
DBG (DBG_error, "%s: failed to allocate white average memory\n", __FUNCTION__);
DBG (DBG_error, "%s: failed to allocate white average memory\n", __func__);
return SANE_STATUS_NO_MEM;
}
@ -2203,7 +2203,7 @@ genesys_dark_white_shading_calibration (Genesys_Device * dev)
dev->dark_average_data = malloc (channels * 2 * pixels_per_line);
if (!dev->dark_average_data)
{
DBG (DBG_error, "%s: failed to allocate dark average memory\n", __FUNCTION__);
DBG (DBG_error, "%s: failed to allocate dark average memory\n", __func__);
return SANE_STATUS_NO_MEM;
}
@ -2212,7 +2212,7 @@ genesys_dark_white_shading_calibration (Genesys_Device * dev)
calibration_data = malloc (size);
if (!calibration_data)
{
DBG (DBG_error, "%s: failed to allocate calibration memory\n", __FUNCTION__);
DBG (DBG_error, "%s: failed to allocate calibration memory\n", __func__);
return SANE_STATUS_NO_MEM;
}
@ -2233,7 +2233,7 @@ genesys_dark_white_shading_calibration (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
free (calibration_data);
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -2243,7 +2243,7 @@ genesys_dark_white_shading_calibration (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
free (calibration_data);
DBG (DBG_error, "%s: failed to begin scan: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to begin scan: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -2252,7 +2252,7 @@ genesys_dark_white_shading_calibration (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
free (calibration_data);
DBG (DBG_error, "%s: failed to read data: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to read data: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -2261,7 +2261,7 @@ genesys_dark_white_shading_calibration (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
free (calibration_data);
DBG (DBG_error, "%s: Failed to end scan: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: Failed to end scan: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -2434,7 +2434,7 @@ compute_averaged_planar (Genesys_Device * dev,
unsigned int x, i, j, br, dk, res, avgpixels, basepixels, val;
unsigned int fill,factor;
DBG (DBG_info, "%s: pixels=%d, offset=%d\n", __FUNCTION__, pixels_per_line, o);
DBG (DBG_info, "%s: pixels=%d, offset=%d\n", __func__, pixels_per_line, o);
/* initialize result */
memset (shading_data, 0xff, words_per_color * 3 * 2);
@ -2504,9 +2504,9 @@ compute_averaged_planar (Genesys_Device * dev,
fill=1;
}
DBG (DBG_info, "%s: averaging over %d pixels\n", __FUNCTION__, avgpixels);
DBG (DBG_info, "%s: packing factor is %d\n", __FUNCTION__, factor);
DBG (DBG_info, "%s: fill length is %d\n", __FUNCTION__, fill);
DBG (DBG_info, "%s: averaging over %d pixels\n", __func__, avgpixels);
DBG (DBG_info, "%s: packing factor is %d\n", __func__, factor);
DBG (DBG_info, "%s: fill length is %d\n", __func__, fill);
for (x = 0; x <= pixels_per_line - avgpixels; x += avgpixels)
{
@ -2903,7 +2903,7 @@ genesys_send_shading_coefficient (Genesys_Device * dev)
shading_data = malloc (length);
if (!shading_data)
{
DBG (DBG_error, "%s: failed to allocate memory\n", __FUNCTION__);
DBG (DBG_error, "%s: failed to allocate memory\n", __func__);
return SANE_STATUS_NO_MEM;
}
memset (shading_data, 0, length);
@ -3071,7 +3071,7 @@ genesys_send_shading_coefficient (Genesys_Device * dev)
shading_data = malloc (length);
if (!shading_data)
{
DBG (DBG_error, "%s: failed to allocate memory\n", __FUNCTION__);
DBG (DBG_error, "%s: failed to allocate memory\n", __func__);
return SANE_STATUS_NO_MEM;
}
memset (shading_data, 0, length);
@ -3121,7 +3121,7 @@ genesys_send_shading_coefficient (Genesys_Device * dev)
256); /* patch_size: contigous extent */
break;
default:
DBG (DBG_error, "%s: sensor %d not supported\n", __FUNCTION__, dev->model->ccd_type);
DBG (DBG_error, "%s: sensor %d not supported\n", __func__, dev->model->ccd_type);
return SANE_STATUS_UNSUPPORTED;
break;
}
@ -3131,7 +3131,7 @@ genesys_send_shading_coefficient (Genesys_Device * dev)
free (shading_data);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to send shading data: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to send shading data: %s\n", __func__,
sane_strstatus (status));
}
@ -3689,7 +3689,7 @@ genesys_sheetfed_calibration (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
dev->model->cmd_set->eject_document (dev);
DBG (DBG_error, "%s: failed eject target: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed eject target: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -3821,7 +3821,7 @@ genesys_warmup_lamp (Genesys_Device * dev)
/* check if the current chipset implements warmup */
if(dev->model->cmd_set->init_regs_for_warmup==NULL)
{
DBG (DBG_error, "%s: init_regs_for_warmup not implemented\n", __FUNCTION__);
DBG (DBG_error, "%s: init_regs_for_warmup not implemented\n", __func__);
return status;
}
@ -4346,7 +4346,7 @@ genesys_fill_line_interp_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst,
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read %lu bytes (%s)\n", __FUNCTION__,
"%s: failed to read %lu bytes (%s)\n", __func__,
(u_long) dev->oe_buffer.size, sane_strstatus (status));
return SANE_STATUS_IO_ERROR;
}
@ -4383,7 +4383,7 @@ genesys_fill_line_interp_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst,
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read %lu bytes (%s)\n", __FUNCTION__,
"%s: failed to read %lu bytes (%s)\n", __func__,
(u_long) dev->oe_buffer.size, sane_strstatus (status));
return SANE_STATUS_IO_ERROR;
}
@ -4417,7 +4417,7 @@ genesys_fill_segmented_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, s
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read %lu bytes (%s)\n", __FUNCTION__,
"%s: failed to read %lu bytes (%s)\n", __func__,
(u_long) dev->oe_buffer.size, sane_strstatus (status));
return SANE_STATUS_IO_ERROR;
}
@ -4508,7 +4508,7 @@ genesys_fill_segmented_buffer (Genesys_Device * dev, uint8_t *work_buffer_dst, s
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read %lu bytes (%s)\n", __FUNCTION__,
"%s: failed to read %lu bytes (%s)\n", __func__,
(u_long) dev->oe_buffer.size, sane_strstatus (status));
return SANE_STATUS_IO_ERROR;
}
@ -5496,7 +5496,7 @@ GENESYS_STATIC char *calibration_filename(Genesys_Device *currdev)
snprintf (tmpstr, PATH_MAX, "%s%c.sane%c%s", ptr, PATH_SEP, PATH_SEP, filename);
}
DBG (DBG_info, "%s: calibration filename >%s<\n", __FUNCTION__, tmpstr);
DBG (DBG_info, "%s: calibration filename >%s<\n", __func__, tmpstr);
return tmpstr;
}
@ -6330,7 +6330,7 @@ probe_genesys_devices (void)
free (new_dev);
}
DBG(DBG_info, "%s: %d devices currently attached\n", __FUNCTION__, num_devices);
DBG(DBG_info, "%s: %d devices currently attached\n", __func__, num_devices);
DBGCOMPLETED;
@ -6545,7 +6545,7 @@ genesys_buffer_image(Genesys_Scanner *s)
lines =
(SANE_UNFIX (dev->model->y_size) * dev->settings.yres) / MM_PER_INCH;
}
DBG (DBG_info, "%s: buffering %d lines of %d bytes\n", __FUNCTION__, lines,
DBG (DBG_info, "%s: buffering %d lines of %d bytes\n", __func__, lines,
s->params.bytes_per_line);
/* maximum bytes to read */
@ -6568,7 +6568,7 @@ genesys_buffer_image(Genesys_Scanner *s)
{
DBG (DBG_error,
"%s: digital processing requires too much memory.\nConsider disabling it\n",
__FUNCTION__);
__func__);
return SANE_STATUS_NO_MEM;
}
@ -6585,7 +6585,7 @@ genesys_buffer_image(Genesys_Scanner *s)
if (status != SANE_STATUS_EOF && status != SANE_STATUS_GOOD)
{
free (s->dev->img_buffer);
DBG (DBG_error, "%s: %s buffering failed\n", __FUNCTION__,
DBG (DBG_error, "%s: %s buffering failed\n", __func__,
sane_strstatus (status));
return status;
}
@ -6600,7 +6600,7 @@ genesys_buffer_image(Genesys_Scanner *s)
{
DBG (DBG_error0,
"%s: digital processing requires too much memory.\nConsider disabling it\n",
__FUNCTION__);
__func__);
return SANE_STATUS_NO_MEM;
}
}
@ -6627,7 +6627,7 @@ genesys_buffer_image(Genesys_Scanner *s)
{
DBG (DBG_error0,
"%s: digital processing requires too much memory.\nConsider disabling it\n",
__FUNCTION__);
__func__);
return SANE_STATUS_NO_MEM;
}
genesys_gray_lineart (dev,
@ -6942,8 +6942,8 @@ sane_open (SANE_String_Const devicename, SANE_Handle * handle)
tmpstr=calibration_filename(s->dev);
s->val[OPT_CALIBRATION_FILE].s = strdup (tmpstr);
s->dev->calib_file = strdup (tmpstr);
DBG (DBG_info, "%s: Calibration filename set to:\n", __FUNCTION__);
DBG (DBG_info, "%s: >%s<\n", __FUNCTION__, s->dev->calib_file);
DBG (DBG_info, "%s: Calibration filename set to:\n", __func__);
DBG (DBG_info, "%s: >%s<\n", __func__, s->dev->calib_file);
free(tmpstr);
/* now open file, fetch calibration records */
@ -7245,8 +7245,8 @@ static SANE_Status set_calibration_value (Genesys_Scanner * s, int option, void
if (tmp)
free (tmp);
dev->calib_file = strdup (val);
DBG (DBG_info, "%s: Calibration filename set to:\n", __FUNCTION__);
DBG (DBG_info, "%s: >%s<\n", __FUNCTION__, s->dev->calib_file);
DBG (DBG_info, "%s: Calibration filename set to:\n", __func__);
DBG (DBG_info, "%s: >%s<\n", __func__, s->dev->calib_file);
DBGCOMPLETED;
return SANE_STATUS_GOOD;
@ -7536,7 +7536,7 @@ set_option_value (Genesys_Scanner * s, int option, void *val,
{
DBG (DBG_error,
"%s: failed to disable power saving mode: %s\n",
__FUNCTION__, sane_strstatus (status));
__func__, sane_strstatus (status));
}
else
status = genesys_scanner_calibration (s->dev);

28
backend/genesys_conv.c
Wyświetl plik

@ -295,7 +295,7 @@ genesys_shrink_lines_1 (
else
{
/* TODO: since depth is 1, we must interpolate bit within bytes */
DBG (DBG_warn, "%s: inaccurate bit expansion!\n", __FUNCTION__);
DBG (DBG_warn, "%s: inaccurate bit expansion!\n", __func__);
cnt = dst_pixels / 2;
dst_x = 0;
for (src_x = 0; src_x < src_pixels; src_x++)
@ -332,7 +332,7 @@ genesys_crop(Genesys_Scanner *s)
int left = 0;
int right = 0;
DBG (DBG_proc, "%s: start\n", __FUNCTION__);
DBG (DBG_proc, "%s: start\n", __func__);
/* first find edges if any */
status = sanei_magic_findEdges (&s->params,
@ -345,10 +345,10 @@ genesys_crop(Genesys_Scanner *s)
&right);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_info, "%s: bad or no edges, bailing\n", __FUNCTION__);
DBG (DBG_info, "%s: bad or no edges, bailing\n", __func__);
goto cleanup;
}
DBG (DBG_io, "%s: t:%d b:%d l:%d r:%d\n", __FUNCTION__, top, bottom, left,
DBG (DBG_io, "%s: t:%d b:%d l:%d r:%d\n", __func__, top, bottom, left,
right);
/* now crop the image */
@ -356,7 +356,7 @@ genesys_crop(Genesys_Scanner *s)
sanei_magic_crop (&(s->params), dev->img_buffer, top, bottom, left, right);
if (status)
{
DBG (DBG_warn, "%s: failed to crop\n", __FUNCTION__);
DBG (DBG_warn, "%s: failed to crop\n", __func__);
goto cleanup;
}
@ -364,7 +364,7 @@ genesys_crop(Genesys_Scanner *s)
dev->total_bytes_to_read = s->params.bytes_per_line * s->params.lines;
cleanup:
DBG (DBG_proc, "%s: completed\n", __FUNCTION__);
DBG (DBG_proc, "%s: completed\n", __func__);
return SANE_STATUS_GOOD;
}
@ -382,7 +382,7 @@ genesys_deskew(Genesys_Scanner *s)
int x = 0, y = 0, bg;
double slope = 0;
DBG (DBG_proc, "%s: start\n", __FUNCTION__);
DBG (DBG_proc, "%s: start\n", __func__);
bg=0;
if(s->params.format==SANE_FRAME_GRAY && s->params.depth == 1)
@ -398,10 +398,10 @@ genesys_deskew(Genesys_Scanner *s)
&slope);
if (status!=SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: bad findSkew, bailing\n", __FUNCTION__);
DBG (DBG_error, "%s: bad findSkew, bailing\n", __func__);
return SANE_STATUS_GOOD;
}
DBG(DBG_info, "%s: slope=%f => %f\n",__FUNCTION__,slope, (slope/M_PI_2)*90);
DBG(DBG_info, "%s: slope=%f => %f\n",__func__,slope, (slope/M_PI_2)*90);
/* rotate image slope is in [-PI/2,PI/2]
* positive values rotate trigonometric direction wise */
status = sanei_magic_rotate (&s->params,
@ -412,10 +412,10 @@ genesys_deskew(Genesys_Scanner *s)
bg);
if (status!=SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: rotate error: %s", __FUNCTION__, sane_strstatus(status));
DBG (DBG_error, "%s: rotate error: %s", __func__, sane_strstatus(status));
}
DBG (DBG_proc, "%s: completed\n", __FUNCTION__);
DBG (DBG_proc, "%s: completed\n", __func__);
return SANE_STATUS_GOOD;
}
@ -430,7 +430,7 @@ genesys_despeck(Genesys_Scanner *s)
s->dev->img_buffer,
s->val[OPT_DESPECK].w)!=SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: bad despeck, bailing\n",__FUNCTION__);
DBG (DBG_error, "%s: bad despeck, bailing\n",__func__);
}
return SANE_STATUS_GOOD;
@ -454,7 +454,7 @@ genesys_derotate (Genesys_Scanner * s)
if (status)
{
DBG (DBG_warn, "%s: failed : %d\n", __FUNCTION__, status);
DBG (DBG_warn, "%s: failed : %d\n", __func__, status);
DBGCOMPLETED;
return SANE_STATUS_GOOD;
}
@ -463,7 +463,7 @@ genesys_derotate (Genesys_Scanner * s)
status = sanei_magic_turn (&s->params, s->dev->img_buffer, angle);
if (status)
{
DBG (DBG_warn, "%s: failed : %d\n", __FUNCTION__, status);
DBG (DBG_warn, "%s: failed : %d\n", __func__, status);
DBGCOMPLETED;
return SANE_STATUS_GOOD;
}

136
backend/genesys_gl124.c
Wyświetl plik

@ -112,7 +112,7 @@ gl124_bulk_read_data (Genesys_Device * dev, uint8_t addr,
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s failed while writing command: %s\n",
__FUNCTION__, sane_strstatus (status));
__func__, sane_strstatus (status));
return status;
}
@ -154,7 +154,7 @@ gl124_bulk_read_data (Genesys_Device * dev, uint8_t addr,
}
}
DBG (DBG_io2, "%s: read %lu bytes, %lu remaining\n", __FUNCTION__,
DBG (DBG_io2, "%s: read %lu bytes, %lu remaining\n", __func__,
(u_long) size, (u_long) (target - size));
target -= size;
@ -294,7 +294,7 @@ static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi, int half_ccd
/* default fallback */
if(idx<0)
{
DBG (DBG_warn,"%s: using default sensor profile\n",__FUNCTION__);
DBG (DBG_warn,"%s: using default sensor profile\n",__func__);
idx=0;
}
@ -624,13 +624,13 @@ gl124_send_slope_table (Genesys_Device * dev, int table_nr,
int i;
char msg[10000];
DBG (DBG_proc, "%s (table_nr = %d, steps = %d)\n", __FUNCTION__,
DBG (DBG_proc, "%s (table_nr = %d, steps = %d)\n", __func__,
table_nr, steps);
/* sanity check */
if(table_nr<0 || table_nr>4)
{
DBG (DBG_error, "%s: invalid table number %d!\n", __FUNCTION__, table_nr);
DBG (DBG_error, "%s: invalid table number %d!\n", __func__, table_nr);
return SANE_STATUS_INVAL;
}
@ -648,7 +648,7 @@ gl124_send_slope_table (Genesys_Device * dev, int table_nr,
{
sprintf (msg+strlen(msg), ",%d", slope_table[i]);
}
DBG (DBG_io, "%s: %s\n", __FUNCTION__, msg);
DBG (DBG_io, "%s: %s\n", __func__, msg);
}
/* slope table addresses are fixed */
@ -658,7 +658,7 @@ gl124_send_slope_table (Genesys_Device * dev, int table_nr,
{
DBG (DBG_error,
"%s: write to AHB failed writing slope table %d (%s)\n",
__FUNCTION__, table_nr, sane_strstatus (status));
__func__, table_nr, sane_strstatus (status));
}
free (table);
@ -679,7 +679,7 @@ gl124_set_ti_fe (Genesys_Device * dev, uint8_t set)
DBGSTART;
if (set == AFE_INIT)
{
DBG (DBG_proc, "%s: setting DAC %u\n", __FUNCTION__,
DBG (DBG_proc, "%s: setting DAC %u\n", __func__,
dev->model->dac_type);
/* sets to default values */
@ -690,7 +690,7 @@ gl124_set_ti_fe (Genesys_Device * dev, uint8_t set)
status = sanei_genesys_fe_write_data (dev, 0x00, 0x80);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to write reg0: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to write reg0: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -703,7 +703,7 @@ gl124_set_ti_fe (Genesys_Device * dev, uint8_t set)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to write reg %d: %s\n", __FUNCTION__, i,
"%s: failed to write reg %d: %s\n", __func__, i,
sane_strstatus (status));
return status;
}
@ -712,7 +712,7 @@ gl124_set_ti_fe (Genesys_Device * dev, uint8_t set)
status = sanei_genesys_fe_write_data (dev, 0x04, 0x00);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to write reg4: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to write reg4: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -725,7 +725,7 @@ gl124_set_ti_fe (Genesys_Device * dev, uint8_t set)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to write reg %d: %s\n", __FUNCTION__, i+5,
"%s: failed to write reg %d: %s\n", __func__, i+5,
sane_strstatus (status));
return status;
}
@ -735,7 +735,7 @@ gl124_set_ti_fe (Genesys_Device * dev, uint8_t set)
status = sanei_genesys_fe_write_data (dev, 0x00, 0x11);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to write reg0: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to write reg0: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -781,7 +781,7 @@ gl124_set_fe (Genesys_Device * dev, uint8_t set)
case 1:
case 2:
default:
DBG (DBG_error, "%s: unsupported analog FE 0x%02x\n",__FUNCTION__,val);
DBG (DBG_error, "%s: unsupported analog FE 0x%02x\n",__func__,val);
status=SANE_STATUS_INVAL;
break;
}
@ -877,11 +877,11 @@ gl124_init_motor_regs_scan (Genesys_Device * dev,
linesel=0;
}
DBG (DBG_io2, "%s: linesel=%d\n", __FUNCTION__, linesel);
DBG (DBG_io2, "%s: linesel=%d\n", __func__, linesel);
lincnt=scan_lines*(linesel+1);
sanei_genesys_set_triple(reg,REG_LINCNT,lincnt);
DBG (DBG_io, "%s: lincnt=%d\n", __FUNCTION__, lincnt);
DBG (DBG_io, "%s: lincnt=%d\n", __func__, lincnt);
/* compute register 02 value */
r = sanei_genesys_get_address (reg, REG02);
@ -960,7 +960,7 @@ gl124_init_motor_regs_scan (Genesys_Device * dev,
{
dist += fast_steps*2;
}
DBG (DBG_io2, "%s: acceleration distance=%d\n", __FUNCTION__, dist);
DBG (DBG_io2, "%s: acceleration distance=%d\n", __func__, dist);
/* get sure we don't use insane value */
if(dist<feedl)
@ -969,7 +969,7 @@ gl124_init_motor_regs_scan (Genesys_Device * dev,
feedl = 0;
sanei_genesys_set_triple(reg,REG_FEEDL,feedl);
DBG (DBG_io, "%s: feedl=%d\n", __FUNCTION__, feedl);
DBG (DBG_io, "%s: feedl=%d\n", __func__, feedl);
/* doesn't seem to matter that much */
sanei_genesys_calculate_zmode2 (use_fast_fed,
@ -1137,19 +1137,19 @@ gl124_init_optical_regs_scan (Genesys_Device * dev,
DBG (DBG_proc, "%s : exposure_time=%d, "
"used_res=%d, start=%d, pixels=%d, channels=%d, depth=%d, "
"half_ccd=%d, flags=%x\n", __FUNCTION__, exposure_time,
"half_ccd=%d, flags=%x\n", __func__, exposure_time,
used_res, start, pixels, channels, depth, half_ccd, flags);
/* resolution is divided according to CKSEL */
r = sanei_genesys_get_address (reg, REG18);
cksel= (r->value & REG18_CKSEL)+1;
DBG (DBG_io2, "%s: cksel=%d\n", __FUNCTION__, cksel);
DBG (DBG_io2, "%s: cksel=%d\n", __func__, cksel);
/* to manage high resolution device while keeping good
* low resolution scanning speed, we make hardware dpi vary */
dpihw=sanei_genesys_compute_dpihw(dev, used_res * cksel);
factor=dev->sensor.optical_res/dpihw;
DBG (DBG_io2, "%s: dpihw=%d (factor=%d)\n", __FUNCTION__, dpihw, factor);
DBG (DBG_io2, "%s: dpihw=%d (factor=%d)\n", __func__, dpihw, factor);
/* sensor parameters */
gl124_setup_sensor (dev, reg, dpihw, half_ccd);
@ -1169,7 +1169,7 @@ gl124_init_optical_regs_scan (Genesys_Device * dev,
status = gl124_set_fe (dev, AFE_SET);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to set frontend: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to set frontend: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1264,12 +1264,12 @@ gl124_init_optical_regs_scan (Genesys_Device * dev,
if(half_ccd)
{
sanei_genesys_set_double(reg,REG_DPISET,dpiset*2);
DBG (DBG_io2, "%s: dpiset used=%d\n", __FUNCTION__, dpiset*2);
DBG (DBG_io2, "%s: dpiset used=%d\n", __func__, dpiset*2);
}
else
{
sanei_genesys_set_double(reg,REG_DPISET,dpiset);
DBG (DBG_io2, "%s: dpiset used=%d\n", __FUNCTION__, dpiset);
DBG (DBG_io2, "%s: dpiset used=%d\n", __func__, dpiset);
}
r = sanei_genesys_get_address (reg, REG06);
@ -1316,14 +1316,14 @@ gl124_init_optical_regs_scan (Genesys_Device * dev,
segnb = r->value & 0x0f;
sanei_genesys_set_triple(reg,REG_STRPIXEL,startx/segnb);
DBG (DBG_io2, "%s: strpixel used=%d\n", __FUNCTION__, startx/segnb);
DBG (DBG_io2, "%s: strpixel used=%d\n", __func__, startx/segnb);
sanei_genesys_get_triple(reg,REG_SEGCNT,&segcnt);
if(endx/segnb==segcnt)
{
endx=0;
}
sanei_genesys_set_triple(reg,REG_ENDPIXEL,endx/segnb);
DBG (DBG_io2, "%s: endpixel used=%d\n", __FUNCTION__, endx/segnb);
DBG (DBG_io2, "%s: endpixel used=%d\n", __func__, endx/segnb);
/* words(16bit) before gamma, conversion to 8 bit or lineart */
words_per_line = (used_pixels * dpiset) / dpihw;
@ -1346,13 +1346,13 @@ gl124_init_optical_regs_scan (Genesys_Device * dev,
dev->line_count = 0;
dev->line_interp = 0;
DBG (DBG_io2, "%s: used_pixels =%d\n", __FUNCTION__, used_pixels);
DBG (DBG_io2, "%s: pixels =%d\n", __FUNCTION__, pixels);
DBG (DBG_io2, "%s: depth =%d\n", __FUNCTION__, depth);
DBG (DBG_io2, "%s: dev->bpl =%lu\n", __FUNCTION__, (unsigned long)dev->bpl);
DBG (DBG_io2, "%s: dev->len =%lu\n", __FUNCTION__, (unsigned long)dev->len);
DBG (DBG_io2, "%s: dev->dist =%lu\n", __FUNCTION__, (unsigned long)dev->dist);
DBG (DBG_io2, "%s: dev->line_interp=%lu\n", __FUNCTION__, (unsigned long)dev->line_interp);
DBG (DBG_io2, "%s: used_pixels =%d\n", __func__, used_pixels);
DBG (DBG_io2, "%s: pixels =%d\n", __func__, pixels);
DBG (DBG_io2, "%s: depth =%d\n", __func__, depth);
DBG (DBG_io2, "%s: dev->bpl =%lu\n", __func__, (unsigned long)dev->bpl);
DBG (DBG_io2, "%s: dev->len =%lu\n", __func__, (unsigned long)dev->len);
DBG (DBG_io2, "%s: dev->dist =%lu\n", __func__, (unsigned long)dev->dist);
DBG (DBG_io2, "%s: dev->line_interp=%lu\n", __func__, (unsigned long)dev->line_interp);
words_per_line *= channels;
dev->wpl = words_per_line;
@ -1366,10 +1366,10 @@ gl124_init_optical_regs_scan (Genesys_Device * dev,
/* MAXWD is expressed in 2 words unit */
sanei_genesys_set_triple(reg,REG_MAXWD,(words_per_line));
DBG (DBG_io2, "%s: words_per_line used=%d\n", __FUNCTION__, words_per_line);
DBG (DBG_io2, "%s: words_per_line used=%d\n", __func__, words_per_line);
sanei_genesys_set_triple(reg,REG_LPERIOD,exposure_time);
DBG (DBG_io2, "%s: exposure_time used=%d\n", __FUNCTION__, exposure_time);
DBG (DBG_io2, "%s: exposure_time used=%d\n", __func__, exposure_time);
sanei_genesys_set_double(reg,REG_DUMMY,dev->sensor.dummy_pixel);
@ -1433,7 +1433,7 @@ gl124_init_scan_regs (Genesys_Device * dev,
optical_res = dev->sensor.optical_res;
if (half_ccd)
optical_res /= 2;
DBG (DBG_info, "%s: optical_res=%d\n", __FUNCTION__, optical_res);
DBG (DBG_info, "%s: optical_res=%d\n", __func__, optical_res);
/* stagger */
if ((!half_ccd) && (dev->model->flags & GENESYS_FLAG_STAGGERED_LINE))
@ -1469,7 +1469,7 @@ gl124_init_scan_regs (Genesys_Device * dev,
/* compute correct pixels number */
used_pixels = (pixels * optical_res) / xres;
DBG (DBG_info, "%s: used_pixels=%d\n", __FUNCTION__, used_pixels);
DBG (DBG_info, "%s: used_pixels=%d\n", __func__, used_pixels);
/* round up pixels number if needed */
if (used_pixels * xres < pixels * optical_res)
@ -1613,7 +1613,7 @@ gl124_init_scan_regs (Genesys_Device * dev,
dev->current_setup.pixels = (used_pixels * used_res) / optical_res;
DBG (DBG_info, "%s: current_setup.pixels=%d\n", __FUNCTION__, dev->current_setup.pixels);
DBG (DBG_info, "%s: current_setup.pixels=%d\n", __func__, dev->current_setup.pixels);
dev->current_setup.lines = lincnt;
dev->current_setup.depth = depth;
dev->current_setup.channels = channels;
@ -1726,11 +1726,11 @@ gl124_calculate_current_setup (Genesys_Device * dev)
/* compute correct pixels number */
used_pixels = (pixels * optical_res) / xres;
DBG (DBG_info, "%s: used_pixels=%d\n", __FUNCTION__, used_pixels);
DBG (DBG_info, "%s: used_pixels=%d\n", __func__, used_pixels);
/* exposure */
exposure_time = gl124_compute_exposure (dev, xres, half_ccd);
DBG (DBG_info, "%s : exposure_time=%d pixels\n", __FUNCTION__, exposure_time);
DBG (DBG_info, "%s : exposure_time=%d pixels\n", __func__, exposure_time);
/* max_shift */
max_shift=sanei_genesys_compute_max_shift(dev,channels,yres,0);
@ -1746,13 +1746,13 @@ gl124_calculate_current_setup (Genesys_Device * dev)
stagger = (4 * yres) / dev->motor.base_ydpi;
else
stagger = 0;
DBG (DBG_info, "%s: stagger=%d lines\n", __FUNCTION__, stagger);
DBG (DBG_info, "%s: stagger=%d lines\n", __func__, stagger);
/* lincnt */
lincnt = lines + max_shift + stagger;
dev->current_setup.pixels = (used_pixels * used_res) / optical_res;
DBG (DBG_info, "%s: current_setup.pixels=%d\n", __FUNCTION__, dev->current_setup.pixels);
DBG (DBG_info, "%s: current_setup.pixels=%d\n", __func__, dev->current_setup.pixels);
dev->current_setup.lines = lincnt;
dev->current_setup.depth = depth;
dev->current_setup.channels = channels;
@ -1884,7 +1884,7 @@ gl124_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read reg100: %s\n", __FUNCTION__,
"%s: failed to read reg100: %s\n", __func__,
sane_strstatus (status));
DBGCOMPLETED;
return status;
@ -1893,7 +1893,7 @@ gl124_stop_action (Genesys_Device * dev)
/* only stop action if needed */
if (!(val40 & REG100_DATAENB) && !(val40 & REG100_MOTMFLG))
{
DBG (DBG_info, "%s: already stopped\n", __FUNCTION__);
DBG (DBG_info, "%s: already stopped\n", __func__);
DBGCOMPLETED;
return SANE_STATUS_GOOD;
}
@ -1906,7 +1906,7 @@ gl124_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to write register 01: %s\n", __FUNCTION__,
"%s: failed to write register 01: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1924,7 +1924,7 @@ gl124_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n", __FUNCTION__,
"%s: failed to read home sensor: %s\n", __func__,
sane_strstatus (status));
DBGCOMPLETED;
return status;
@ -2108,7 +2108,7 @@ gl124_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
/* is sensor at home? */
if (val & HOMESNR)
{
DBG (DBG_info, "%s: already at home, completed\n", __FUNCTION__);
DBG (DBG_info, "%s: already at home, completed\n", __func__);
dev->scanhead_position_in_steps = 0;
DBGCOMPLETED;
return SANE_STATUS_GOOD;
@ -2120,7 +2120,7 @@ gl124_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
status = gl124_feed (dev, 20, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to do initial feed: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to do initial feed: %s\n", __func__, sane_strstatus (status));
return status;
}
}
@ -2234,7 +2234,7 @@ gl124_feed (Genesys_Device * dev, unsigned int steps, int reverse)
uint8_t val;
DBGSTART;
DBG (DBG_io, "%s: steps=%d\n", __FUNCTION__, steps);
DBG (DBG_io, "%s: steps=%d\n", __func__, steps);
/* prepare local registers */
memcpy (local_reg, dev->reg, GENESYS_GL124_MAX_REGS * sizeof (Genesys_Register_Set));
@ -2260,7 +2260,7 @@ gl124_feed (Genesys_Device * dev, unsigned int steps, int reverse)
SCAN_FLAG_IGNORE_LINE_DISTANCE);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to set up registers: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to set up registers: %s\n", __func__, sane_strstatus (status));
DBGCOMPLETED;
return status;
}
@ -2291,7 +2291,7 @@ gl124_feed (Genesys_Device * dev, unsigned int steps, int reverse)
status = gl124_start_action (dev);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to start motor: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus (status));
gl124_stop_action (dev);
/* restore original registers */
@ -2357,7 +2357,7 @@ gl124_search_start_position (Genesys_Device * dev)
if (status!=SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to init scan registers: %s\n", __FUNCTION__,
"%s: failed to init scan registers: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -2546,7 +2546,7 @@ gl124_init_regs_for_shading (Genesys_Device * dev)
move = SANE_UNFIX (dev->model->y_offset_calib);
move = (move * (dev->motor.base_ydpi/4)) / MM_PER_INCH;
}
DBG (DBG_io, "%s: move=%d steps\n", __FUNCTION__, move);
DBG (DBG_io, "%s: move=%d steps\n", __func__, move);
status = gl124_init_scan_regs (dev,
dev->calib_reg,
@ -2569,7 +2569,7 @@ gl124_init_regs_for_shading (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to setup scan: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to setup scan: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -2580,7 +2580,7 @@ gl124_init_regs_for_shading (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to bulk write registers: %s\n", __FUNCTION__,
"%s: failed to bulk write registers: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -2619,14 +2619,14 @@ gl124_init_regs_for_scan (Genesys_Device * dev)
status = sanei_genesys_get_status (dev, &val);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to read status: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to read status: %s\n", __func__, sane_strstatus (status));
DBGCOMPLETED;
return status;
}
status = sanei_genesys_read_register (dev, REG100, &val40);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to read reg100: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to read reg100: %s\n", __func__, sane_strstatus (status));
DBGCOMPLETED;
return status;
}
@ -2638,14 +2638,14 @@ gl124_init_regs_for_scan (Genesys_Device * dev)
status = sanei_genesys_get_status (dev, &val);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to read status: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to read status: %s\n", __func__, sane_strstatus (status));
DBGCOMPLETED;
return status;
}
status = sanei_genesys_read_register (dev, REG100, &val40);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to read reg100: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to read reg100: %s\n", __func__, sane_strstatus (status));
DBGCOMPLETED;
return status;
}
@ -2672,14 +2672,14 @@ gl124_init_regs_for_scan (Genesys_Device * dev)
move = SANE_UNFIX (dev->model->y_offset);
move += dev->settings.tl_y;
move = (move * move_dpi) / MM_PER_INCH;
DBG (DBG_info, "%s: move=%f steps\n", __FUNCTION__, move);
DBG (DBG_info, "%s: move=%f steps\n", __func__, move);
if(channels*dev->settings.yres>=600 && move>700)
{
status = gl124_feed (dev, move-500, SANE_FALSE);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to move to scan area\n",__FUNCTION__);
DBG (DBG_error, "%s: failed to move to scan area\n",__func__);
return status;
}
move=500;
@ -2743,7 +2743,7 @@ gl124_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
uint8_t val,*buffer,*ptr,*src;
DBGSTART;
DBG( DBG_io2, "%s: writing %d bytes of shading data\n",__FUNCTION__,size);
DBG( DBG_io2, "%s: writing %d bytes of shading data\n",__func__,size);
/* logical size of a color as seen by generic code of the frontend */
length = (uint32_t) (size / 3);
@ -2754,13 +2754,13 @@ gl124_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
{
endpixel=segcnt;
}
DBG( DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d, PIXELS=%d, SEGCNT=%d\n",__FUNCTION__,strpixel,endpixel,endpixel-strpixel,segcnt);
DBG( DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d, PIXELS=%d, SEGCNT=%d\n",__func__,strpixel,endpixel,endpixel-strpixel,segcnt);
/* compute deletion factor */
sanei_genesys_get_double(dev->reg,REG_DPISET,&dpiset);
dpihw=sanei_genesys_compute_dpihw(dev,dpiset);
factor=dpihw/dpiset;
DBG( DBG_io2, "%s: factor=%d\n",__FUNCTION__,factor);
DBG( DBG_io2, "%s: factor=%d\n",__func__,factor);
/* binary data logging */
if(DBG_LEVEL>=DBG_data)
@ -2780,7 +2780,7 @@ gl124_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
segcnt*=2*2;
pixels=endpixel-strpixel;
DBG( DBG_io2, "%s: using chunks of %d bytes (%d shading data pixels)\n",__FUNCTION__,length, length/4);
DBG( DBG_io2, "%s: using chunks of %d bytes (%d shading data pixels)\n",__func__,length, length/4);
buffer=(uint8_t *)malloc(pixels*dev->segnb);
memset(buffer,0,pixels*dev->segnb);
@ -2898,7 +2898,7 @@ move_to_calibration_area (Genesys_Device * dev)
SCAN_FLAG_IGNORE_LINE_DISTANCE);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to setup scan: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus (status));
return status;
}
@ -2910,7 +2910,7 @@ move_to_calibration_area (Genesys_Device * dev)
/* write registers and scan data */
RIEF (dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL124_MAX_REGS), line);
DBG (DBG_info, "%s: starting line reading\n", __FUNCTION__);
DBG (DBG_info, "%s: starting line reading\n", __func__);
RIEF (gl124_begin_scan (dev, dev->calib_reg, SANE_TRUE), line);
RIEF (sanei_genesys_read_data_from_scanner (dev, line, size), line);
@ -2998,7 +2998,7 @@ gl124_led_calibration (Genesys_Device * dev)
SCAN_FLAG_IGNORE_LINE_DISTANCE);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to setup scan: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus (status));
return status;
}

24
backend/genesys_gl646.c
Wyświetl plik

@ -3066,7 +3066,7 @@ gl646_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to setup for scan: %s\n", __FUNCTION__,
"%s: failed to setup for scan: %s\n", __func__,
sane_strstatus (status));
DBGCOMPLETED;
return status;
@ -3082,7 +3082,7 @@ gl646_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to set frontend: %s\n", __FUNCTION__,
"%s: failed to set frontend: %s\n", __func__,
sane_strstatus (status));
DBGCOMPLETED;
return status;
@ -3429,7 +3429,7 @@ setup_for_scan (Genesys_Device * dev,
DBG (DBG_info,
"%s settings:\nResolution: %ux%uDPI\n"
"Lines : %u\nPixels : %u\nStartpos : %.3f/%.3f\nScan mode : %d\nScan method: %s\n\n",
__FUNCTION__,
__func__,
settings.xres, settings.yres, settings.lines, settings.pixels,
settings.tl_x, settings.tl_y, settings.scan_mode,
settings.scan_method == SCAN_METHOD_FLATBED ? "flatbed" : "XPA");
@ -3482,16 +3482,16 @@ setup_for_scan (Genesys_Device * dev,
move += (settings.tl_y * dev->motor.optical_ydpi) / MM_PER_INCH;
}
DBG (DBG_info, "%s: move=%d steps\n", __FUNCTION__, move);
DBG (DBG_info, "%s: move=%d steps\n", __func__, move);
/* security check */
if (move < 0)
{
DBG (DBG_error, "%s: overriding negative move value %d\n", __FUNCTION__, move);
DBG (DBG_error, "%s: overriding negative move value %d\n", __func__, move);
move = 0;
}
}
DBG (DBG_info, "%s: move=%d steps\n", __FUNCTION__, move);
DBG (DBG_info, "%s: move=%d steps\n", __func__, move);
/* pixels are allways given at full CCD optical resolution */
/* use detected left margin and fixed value */
@ -3550,7 +3550,7 @@ setup_for_scan (Genesys_Device * dev,
depth);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed setup registers: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed setup registers: %s\n", __func__, sane_strstatus (status));
return status;
}
@ -3585,7 +3585,7 @@ setup_for_scan (Genesys_Device * dev,
sanei_genesys_read_reg_from_set (regs, 0x21));
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to send slope table 0: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to send slope table 0: %s\n", __func__, sane_strstatus (status));
return status;
}
@ -3594,7 +3594,7 @@ setup_for_scan (Genesys_Device * dev,
sanei_genesys_read_reg_from_set (regs, 0x6b));
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to send slope table 1: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to send slope table 1: %s\n", __func__, sane_strstatus (status));
return status;
}
@ -4414,7 +4414,7 @@ gl646_coarse_gain_calibration (Genesys_Device * dev, int dpi)
if (status != SANE_STATUS_GOOD)
{
free(line);
DBG (DBG_error, "%s: failed to scan first line\n", __FUNCTION__);
DBG (DBG_error, "%s: failed to scan first line\n", __func__);
return status;
}
@ -4472,7 +4472,7 @@ gl646_coarse_gain_calibration (Genesys_Device * dev, int dpi)
dev->frontend.gain[k]++;
DBG (DBG_proc,
"%s: channel %d, average = %.2f, gain = %d\n", __FUNCTION__,
"%s: channel %d, average = %.2f, gain = %d\n", __func__,
k, average[k], dev->frontend.gain[k]);
}
free (line);
@ -4484,7 +4484,7 @@ gl646_coarse_gain_calibration (Genesys_Device * dev, int dpi)
dev->frontend.gain[2] = dev->frontend.gain[0];
}
DBG (DBG_info, "%s: gains=(%d,%d,%d)\n", __FUNCTION__,
DBG (DBG_info, "%s: gains=(%d,%d,%d)\n", __func__,
dev->frontend.gain[0], dev->frontend.gain[1], dev->frontend.gain[2]);
DBGCOMPLETED;
return status;

118
backend/genesys_gl841.c
Wyświetl plik

@ -1158,7 +1158,7 @@ gl841_send_slope_table (Genesys_Device * dev, int table_nr,
{
sprintf (msg+strlen(msg), ",%d", slope_table[i]);
}
DBG (DBG_io, "%s: %s\n", __FUNCTION__, msg);
DBG (DBG_io, "%s: %s\n", __func__, msg);
}
status =
@ -1204,7 +1204,7 @@ gl841_set_lide80_fe (Genesys_Device * dev, uint8_t set)
if (set == AFE_INIT)
{
DBG (DBG_proc, "%s(): setting DAC %u\n", __FUNCTION__,
DBG (DBG_proc, "%s(): setting DAC %u\n", __func__,
dev->model->dac_type);
/* sets to default values */
@ -1214,21 +1214,21 @@ gl841_set_lide80_fe (Genesys_Device * dev, uint8_t set)
status = sanei_genesys_fe_write_data (dev, 0x00, dev->frontend.reg[0]);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: writing reg 0x00 failed: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: writing reg 0x00 failed: %s\n", __func__,
sane_strstatus (status));
return status;
}
status = sanei_genesys_fe_write_data (dev, 0x03, dev->frontend.reg[1]);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: writing reg 0x03 failed: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: writing reg 0x03 failed: %s\n", __func__,
sane_strstatus (status));
return status;
}
status = sanei_genesys_fe_write_data (dev, 0x06, dev->frontend.reg[2]);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: writing reg 0x06 failed: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: writing reg 0x06 failed: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1239,21 +1239,21 @@ gl841_set_lide80_fe (Genesys_Device * dev, uint8_t set)
status = sanei_genesys_fe_write_data (dev, 0x00, dev->frontend.reg[0]);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: writing reg 0x00 failed: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: writing reg 0x00 failed: %s\n", __func__,
sane_strstatus (status));
return status;
}
status = sanei_genesys_fe_write_data (dev, 0x06, dev->frontend.offset[0]);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: writing offset failed: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: writing offset failed: %s\n", __func__,
sane_strstatus (status));
return status;
}
status = sanei_genesys_fe_write_data (dev, 0x03, dev->frontend.gain[0]);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: writing gain failed: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: writing gain failed: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1734,7 +1734,7 @@ gl841_init_motor_regs(Genesys_Device * dev,
0,
0,
&scan_power_mode);
DBG (DBG_info, "%s : fast_exposure=%d pixels\n", __FUNCTION__, fast_exposure);
DBG (DBG_info, "%s : fast_exposure=%d pixels\n", __func__, fast_exposure);
}
if (action == MOTOR_ACTION_HOME_FREE) {
@ -1911,7 +1911,7 @@ gl841_init_motor_regs_scan(Genesys_Device * dev,
0,
&dummy_power_mode);
DBG (DBG_info, "%s : fast_exposure=%d pixels\n", __FUNCTION__, fast_exposure);
DBG (DBG_info, "%s : fast_exposure=%d pixels\n", __func__, fast_exposure);
memset(slow_slope_table,0xff,512);
@ -2453,7 +2453,7 @@ gl841_init_optical_regs_scan(Genesys_Device * dev,
sanei_genesys_set_double(reg, REG_DPISET, dpiset);
sanei_genesys_set_double(reg, REG_STRPIXEL, start);
sanei_genesys_set_double(reg, REG_ENDPIXEL, end);
DBG( DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d\n",__FUNCTION__,start,end);
DBG( DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d\n",__func__,start,end);
/* words(16bit) before gamma, conversion to 8 bit or lineart*/
words_per_line = (pixels * dpiset) / gl841_get_dpihw(dev);
@ -2794,7 +2794,7 @@ dummy \ scanned lines
start,
used_pixels,
&scan_power_mode);
DBG (DBG_info, "%s : exposure_time=%d pixels\n", __FUNCTION__, exposure_time);
DBG (DBG_info, "%s : exposure_time=%d pixels\n", __func__, exposure_time);
/*** optical parameters ***/
/* in case of dynamic lineart, we use an internal 8 bit gray scan
@ -3160,7 +3160,7 @@ dummy \ scanned lines
start,
used_pixels,
&scan_power_mode);
DBG (DBG_info, "%s : exposure_time=%d pixels\n", __FUNCTION__, exposure_time);
DBG (DBG_info, "%s : exposure_time=%d pixels\n", __func__, exposure_time);
/* scanned area must be enlarged by max color shift needed */
max_shift=sanei_genesys_compute_max_shift(dev,channels,yres,0);
@ -3451,7 +3451,7 @@ gl841_stop_action (Genesys_Device * dev)
uint8_t val40, val;
unsigned int loop;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
status = sanei_genesys_get_status (dev, &val);
if (DBG_LEVEL >= DBG_io)
@ -3463,7 +3463,7 @@ gl841_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n",__FUNCTION__,
"%s: failed to read home sensor: %s\n",__func__,
sane_strstatus (status));
DBGCOMPLETED;
return status;
@ -3472,7 +3472,7 @@ gl841_stop_action (Genesys_Device * dev)
/* only stop action if needed */
if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
{
DBG (DBG_info, "%s: already stopped\n", __FUNCTION__);
DBG (DBG_info, "%s: already stopped\n", __func__);
DBGCOMPLETED;
return SANE_STATUS_GOOD;
}
@ -3485,7 +3485,7 @@ gl841_stop_action (Genesys_Device * dev)
status = gl841_bulk_write_register (dev, local_reg, GENESYS_GL841_MAX_REGS);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -3505,7 +3505,7 @@ gl841_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n",__FUNCTION__,
"%s: failed to read home sensor: %s\n",__func__,
sane_strstatus (status));
DBGCOMPLETED;
return status;
@ -3762,14 +3762,14 @@ gl841_detect_document_end (Genesys_Device * dev)
uint8_t val;
size_t total_bytes_to_read;
DBG (DBG_proc, "%s: begin\n", __FUNCTION__);
DBG (DBG_proc, "%s: begin\n", __func__);
RIE (gl841_get_paper_sensor (dev, &paper_loaded));
/* sheetfed scanner uses home sensor as paper present */
if ((dev->document == SANE_TRUE) && !paper_loaded)
{
DBG (DBG_info, "%s: no more document\n", __FUNCTION__);
DBG (DBG_info, "%s: no more document\n", __func__);
dev->document = SANE_FALSE;
/* we can't rely on total_bytes_to_read since the frontend
@ -3781,14 +3781,14 @@ gl841_detect_document_end (Genesys_Device * dev)
{
dev->total_bytes_to_read = dev->total_bytes_read;
dev->read_bytes_left = 0;
DBG (DBG_proc, "%s: finished\n", __FUNCTION__);
DBG (DBG_proc, "%s: finished\n", __func__);
return SANE_STATUS_GOOD;
}
if (dev->settings.scan_mode == SCAN_MODE_COLOR && dev->model->is_cis)
{
scancnt/=3;
}
DBG (DBG_io, "%s: scancnt=%u lines\n",__FUNCTION__, scancnt);
DBG (DBG_io, "%s: scancnt=%u lines\n",__func__, scancnt);
RIE(sanei_genesys_read_register(dev, 0x25, &val));
lincnt=65536*val;
@ -3796,26 +3796,26 @@ gl841_detect_document_end (Genesys_Device * dev)
lincnt+=256*val;
RIE(sanei_genesys_read_register(dev, 0x27, &val));
lincnt+=val;
DBG (DBG_io, "%s: lincnt=%u lines\n",__FUNCTION__, lincnt);
DBG (DBG_io, "%s: lincnt=%u lines\n",__func__, lincnt);
postcnt=(SANE_UNFIX(dev->model->post_scan)/MM_PER_INCH)*dev->settings.yres;
DBG (DBG_io, "%s: postcnt=%u lines\n",__FUNCTION__, postcnt);
DBG (DBG_io, "%s: postcnt=%u lines\n",__func__, postcnt);
/* the current scancnt is also the final one, so we use it to
* compute total bytes to read. We also add the line count to eject document */
total_bytes_to_read=(scancnt+postcnt)*dev->wpl;
DBG (DBG_io, "%s: old total_bytes_to_read=%u\n",__FUNCTION__,(unsigned int)dev->total_bytes_to_read);
DBG (DBG_io, "%s: new total_bytes_to_read=%u\n",__FUNCTION__,(unsigned int)total_bytes_to_read);
DBG (DBG_io, "%s: old total_bytes_to_read=%u\n",__func__,(unsigned int)dev->total_bytes_to_read);
DBG (DBG_io, "%s: new total_bytes_to_read=%u\n",__func__,(unsigned int)total_bytes_to_read);
/* assign new end value */
if(dev->total_bytes_to_read>total_bytes_to_read)
{
DBG (DBG_io, "%s: scan shorten\n",__FUNCTION__);
DBG (DBG_io, "%s: scan shorten\n",__func__);
dev->total_bytes_to_read=total_bytes_to_read;
}
}
DBG (DBG_proc, "%s: finished\n", __FUNCTION__);
DBG (DBG_proc, "%s: finished\n", __func__);
return SANE_STATUS_GOOD;
}
@ -4184,7 +4184,7 @@ gl841_search_start_position (Genesys_Device * dev)
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE);
if(status!=SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to init scan registers: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to init scan registers: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -4194,7 +4194,7 @@ gl841_search_start_position (Genesys_Device * dev)
gl841_bulk_write_register (dev, local_reg, GENESYS_GL841_MAX_REGS);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -4346,7 +4346,7 @@ gl841_init_regs_for_shading (Genesys_Device * dev)
float starty=0;
DBGSTART;
DBG (DBG_proc, "%s: lines = %d\n", __FUNCTION__, (int)(dev->calib_lines));
DBG (DBG_proc, "%s: lines = %d\n", __func__, (int)(dev->calib_lines));
/* initial calibration reg values */
memcpy (dev->calib_reg, dev->reg, GENESYS_GL841_MAX_REGS * sizeof (Genesys_Register_Set));
@ -4383,7 +4383,7 @@ gl841_init_regs_for_shading (Genesys_Device * dev)
SCAN_FLAG_IGNORE_LINE_DISTANCE);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to setup scan: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus (status));
return status;
}
@ -4393,7 +4393,7 @@ gl841_init_regs_for_shading (Genesys_Device * dev)
status = gl841_bulk_write_register (dev, dev->calib_reg, GENESYS_GL841_MAX_REGS);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -4491,7 +4491,7 @@ gl841_init_regs_for_scan (Genesys_Device * dev)
if(dev->model->is_cis && dev->settings.true_gray
&& dev->settings.scan_mode != SCAN_MODE_COLOR)
{
DBG (DBG_io, "%s: activating LEDADD\n", __FUNCTION__);
DBG (DBG_io, "%s: activating LEDADD\n", __func__);
flags |= SCAN_FLAG_ENABLE_LEDADD;
}
@ -4610,11 +4610,11 @@ gl841_led_calibration (Genesys_Device * dev)
{
move = SANE_UNFIX (dev->model->y_offset_calib);
move = (move * (dev->motor.base_ydpi)) / MM_PER_INCH;
DBG (DBG_io, "%s: move=%d lines\n", __FUNCTION__, move);
DBG (DBG_io, "%s: move=%d lines\n", __func__, move);
status = gl841_feed(dev, move);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to feed: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to feed: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -4644,7 +4644,7 @@ gl841_led_calibration (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to setup scan: %s\n", __FUNCTION__,
"%s: failed to setup scan: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -4694,7 +4694,7 @@ gl841_led_calibration (Genesys_Device * dev)
RIE (gl841_bulk_write_register (dev, dev->calib_reg, GENESYS_GL841_MAX_REGS));
DBG (DBG_info, "%s: starting line reading\n", __FUNCTION__);
DBG (DBG_info, "%s: starting line reading\n", __func__);
RIE (gl841_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE (sanei_genesys_read_data_from_scanner (dev, line, total_size));
@ -4727,7 +4727,7 @@ gl841_led_calibration (Genesys_Device * dev)
avg[j] /= num_pixels;
}
DBG(DBG_info,"%s: average: %d,%d,%d\n", __FUNCTION__, avg[0], avg[1], avg[2]);
DBG(DBG_info,"%s: average: %d,%d,%d\n", __func__, avg[0], avg[1], avg[2]);
acceptable = SANE_TRUE;
@ -4798,7 +4798,7 @@ gl841_led_calibration (Genesys_Device * dev)
} while (!acceptable && turn < 100);
DBG(DBG_info,"%s: acceptable exposure: %d,%d,%d\n", __FUNCTION__, exp[0],exp[1],exp[2]);
DBG(DBG_info,"%s: acceptable exposure: %d,%d,%d\n", __func__, exp[0],exp[1],exp[2]);
/* cleanup before return */
free (line);
@ -4891,7 +4891,7 @@ ad_fe_offset_calibration (Genesys_Device * dev)
dev->frontend.offset[2] = (top+bottom)/2;
/* scan line */
DBG (DBG_info, "%s: starting line reading\n",__FUNCTION__);
DBG (DBG_info, "%s: starting line reading\n",__func__);
gl841_bulk_write_register (dev, dev->calib_reg, GENESYS_GL841_MAX_REGS);
gl841_set_fe(dev, AFE_SET);
gl841_begin_scan (dev, dev->calib_reg, SANE_TRUE);
@ -4909,7 +4909,7 @@ ad_fe_offset_calibration (Genesys_Device * dev)
average+=line[i];
}
average/=total_size;
DBG (DBG_data, "%s: average=%d\n", __FUNCTION__, average);
DBG (DBG_data, "%s: average=%d\n", __func__, average);
/* if min value is above target, the current value becomes the new top
* else it is the new bottom */
@ -4928,7 +4928,7 @@ ad_fe_offset_calibration (Genesys_Device * dev)
dev->frontend.offset[1]=0;
dev->frontend.offset[2]=0;
free(line);
DBG (DBG_info, "%s: offset=(%d,%d,%d)\n", __FUNCTION__,
DBG (DBG_info, "%s: offset=(%d,%d,%d)\n", __func__,
dev->frontend.offset[0],
dev->frontend.offset[1],
dev->frontend.offset[2]);
@ -5374,18 +5374,18 @@ gl841_coarse_gain_calibration (Genesys_Device * dev, int dpi)
int lines=1;
int move;
DBG (DBG_proc, "%s: dpi=%d\n", __FUNCTION__, dpi);
DBG (DBG_proc, "%s: dpi=%d\n", __func__, dpi);
/* feed to white strip if needed */
if (dev->model->y_offset_calib>0)
{
move = SANE_UNFIX (dev->model->y_offset_calib);
move = (move * (dev->motor.base_ydpi)) / MM_PER_INCH;
DBG (DBG_io, "%s: move=%d lines\n", __FUNCTION__, move);
DBG (DBG_io, "%s: move=%d lines\n", __func__, move);
status = gl841_feed(dev, move);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to feed: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to feed: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -5414,7 +5414,7 @@ gl841_coarse_gain_calibration (Genesys_Device * dev, int dpi)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to setup scan: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to setup scan: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -5475,7 +5475,7 @@ gl841_coarse_gain_calibration (Genesys_Device * dev, int dpi)
dev->frontend.gain[j] = gain[j]*12;
}
DBG (DBG_proc, "%s: channel %d, max=%d, gain = %f, setting:%d\n", __FUNCTION__,
DBG (DBG_proc, "%s: channel %d, max=%d, gain = %f, setting:%d\n", __func__,
j, max[j], gain[j],dev->frontend.gain[j]);
}
@ -5516,7 +5516,7 @@ gl841_coarse_gain_calibration (Genesys_Device * dev, int dpi)
}
free (line);
DBG (DBG_info, "%s: gain=(%d,%d,%d)\n", __FUNCTION__,
DBG (DBG_info, "%s: gain=(%d,%d,%d)\n", __func__,
dev->frontend.gain[0],
dev->frontend.gain[1],
dev->frontend.gain[2]);
@ -5663,7 +5663,7 @@ gl841_is_compatible_calibration (Genesys_Device * dev,
if ((time.tv_sec - cache->last_calibration > 30 * 60)
&& (dev->model->is_sheetfed == SANE_FALSE))
{
DBG (DBG_proc, "%s: expired entry, non compatible cache\n",__FUNCTION__);
DBG (DBG_proc, "%s: expired entry, non compatible cache\n",__func__);
return SANE_STATUS_UNSUPPORTED;
}
}
@ -5969,7 +5969,7 @@ gl841_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
if (status != SANE_STATUS_GOOD)
{
free(data);
DBG (DBG_error, "%s: failed to setup for scan: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to setup for scan: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -6208,7 +6208,7 @@ gl841_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
uint8_t *buffer,*ptr,*src;
DBGSTART;
DBG( DBG_io2, "%s: writing %d bytes of shading data\n",__FUNCTION__,size);
DBG( DBG_io2, "%s: writing %d bytes of shading data\n",__func__,size);
/* old method if no SHDAREA */
if((dev->reg[reg_0x01].value & REG01_SHDAREA) == 0)
@ -6217,7 +6217,7 @@ gl841_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
status = sanei_genesys_set_buffer_address (dev, 0x0000);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to set buffer address: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to set buffer address: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -6226,7 +6226,7 @@ gl841_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
status = dev->model->cmd_set->bulk_write_data (dev, 0x3c, data, size);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to send shading table: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to send shading table: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -6238,14 +6238,14 @@ gl841_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
length = (uint32_t) (size / 3);
sanei_genesys_get_double(dev->reg,REG_STRPIXEL,&strpixel);
sanei_genesys_get_double(dev->reg,REG_ENDPIXEL,&endpixel);
DBG( DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d, PIXELS=%d\n",__FUNCTION__,strpixel,endpixel,endpixel-strpixel);
DBG( DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d, PIXELS=%d\n",__func__,strpixel,endpixel,endpixel-strpixel);
/* compute deletion/average factor */
sanei_genesys_get_double(dev->reg,REG_DPISET,&dpiset);
dpihw = gl841_get_dpihw(dev);
half=dev->current_setup.half_ccd+1;
factor=dpihw/dpiset;
DBG( DBG_io2, "%s: dpihw=%d, dpiset=%d, half_ccd=%d, factor=%d\n",__FUNCTION__,dpihw,dpiset,half-1,factor);
DBG( DBG_io2, "%s: dpihw=%d, dpiset=%d, half_ccd=%d, factor=%d\n",__func__,dpihw,dpiset,half-1,factor);
/* binary data logging */
if(DBG_LEVEL>=DBG_data)
@ -6269,11 +6269,11 @@ gl841_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
*/
beginpixel = dev->sensor.CCD_start_xoffset / half;
beginpixel += dev->sensor.dummy_pixel + 1;
DBG(DBG_io2, "%s: ORIGIN PIXEL=%d\n", __FUNCTION__, beginpixel);
DBG(DBG_io2, "%s: ORIGIN PIXEL=%d\n", __func__, beginpixel);
beginpixel = (strpixel-beginpixel*2*2)/factor;
DBG(DBG_io2, "%s: BEGIN PIXEL=%d\n",__FUNCTION__,beginpixel/4);
DBG(DBG_io2, "%s: BEGIN PIXEL=%d\n",__func__,beginpixel/4);
DBG(DBG_io2, "%s: using chunks of %d bytes (%d shading data pixels)\n",__FUNCTION__,length, length/4);
DBG(DBG_io2, "%s: using chunks of %d bytes (%d shading data pixels)\n",__func__,length, length/4);
buffer=(uint8_t *)malloc(pixels);
memset(buffer,0,pixels);

124
backend/genesys_gl843.c
Wyświetl plik

@ -376,7 +376,7 @@ gl843_get_step_multiplier (Genesys_Register_Set * regs)
value = 1;
}
}
DBG (DBG_io, "%s: step multiplier is %d\n", __FUNCTION__, value);
DBG (DBG_io, "%s: step multiplier is %d\n", __func__, value);
return value;
}
@ -452,7 +452,7 @@ static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi, int flags)
/* default fallback */
if(idx<0)
{
DBG (DBG_warn,"%s: using default sensor profile\n",__FUNCTION__);
DBG (DBG_warn,"%s: using default sensor profile\n",__func__);
idx=0;
}
@ -790,7 +790,7 @@ gl843_send_slope_table (Genesys_Device * dev, int table_nr,
int i;
char msg[10000];
DBG (DBG_proc, "%s (table_nr = %d, steps = %d)\n", __FUNCTION__,
DBG (DBG_proc, "%s (table_nr = %d, steps = %d)\n", __func__,
table_nr, steps);
table = (uint8_t *) malloc (steps * 2);
@ -807,7 +807,7 @@ gl843_send_slope_table (Genesys_Device * dev, int table_nr,
{
sprintf (msg+strlen(msg), "%d", slope_table[i]);
}
DBG (DBG_io, "%s: %s\n", __FUNCTION__, msg);
DBG (DBG_io, "%s: %s\n", __func__, msg);
}
@ -818,7 +818,7 @@ gl843_send_slope_table (Genesys_Device * dev, int table_nr,
{
DBG (DBG_error,
"%s: write data failed writing slope table %d (%s)\n",
__FUNCTION__, table_nr, sane_strstatus (status));
__func__, table_nr, sane_strstatus (status));
}
free (table);
@ -957,7 +957,7 @@ gl843_init_motor_regs_scan (Genesys_Device * dev,
lincnt=scan_lines;
sanei_genesys_set_triple(reg,REG_LINCNT,lincnt);
DBG (DBG_io, "%s: lincnt=%d\n", __FUNCTION__, lincnt);
DBG (DBG_io, "%s: lincnt=%d\n", __func__, lincnt);
/* compute register 02 value */
r = sanei_genesys_get_address (reg, REG02);
@ -1036,7 +1036,7 @@ gl843_init_motor_regs_scan (Genesys_Device * dev,
{
dist += fast_steps*2;
}
DBG (DBG_io2, "%s: acceleration distance=%d\n", __FUNCTION__, dist);
DBG (DBG_io2, "%s: acceleration distance=%d\n", __func__, dist);
/* get sure when don't insane value : XXX STEF XXX in this case we should
* fall back to single table move */
@ -1046,7 +1046,7 @@ gl843_init_motor_regs_scan (Genesys_Device * dev,
feedl = 1;
sanei_genesys_set_triple(reg,REG_FEEDL,feedl);
DBG (DBG_io, "%s: feedl=%d\n", __FUNCTION__, feedl);
DBG (DBG_io, "%s: feedl=%d\n", __func__, feedl);
/* doesn't seem to matter that much */
sanei_genesys_calculate_zmode2 (use_fast_fed,
@ -1179,13 +1179,13 @@ gl843_init_optical_regs_scan (Genesys_Device * dev,
{
tgtime=2;
}
DBG (DBG_io2, "%s: tgtime=%d\n", __FUNCTION__, tgtime);
DBG (DBG_io2, "%s: tgtime=%d\n", __func__, tgtime);
/* to manage high resolution device while keeping good
* low resolution scanning speed, we make hardware dpi vary */
dpihw=sanei_genesys_compute_dpihw(dev, used_res);
factor=dev->sensor.optical_res/dpihw;
DBG (DBG_io2, "%s: dpihw=%d (factor=%d)\n", __FUNCTION__, dpihw, factor);
DBG (DBG_io2, "%s: dpihw=%d (factor=%d)\n", __func__, dpihw, factor);
/* sensor parameters */
gl843_setup_sensor (dev, reg, dpihw, flags);
@ -1193,7 +1193,7 @@ gl843_init_optical_regs_scan (Genesys_Device * dev,
/* resolution is divided according to CKSEL which is known once sensor is set up */
r = sanei_genesys_get_address (reg, REG18);
cksel= (r->value & REG18_CKSEL)+1;
DBG (DBG_io2, "%s: cksel=%d\n", __FUNCTION__, cksel);
DBG (DBG_io2, "%s: cksel=%d\n", __func__, cksel);
dpiset = used_res * cksel;
/* start and end coordinate in optical dpi coordinates */
@ -1218,7 +1218,7 @@ gl843_init_optical_regs_scan (Genesys_Device * dev,
status = gl843_set_fe (dev, AFE_SET);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to set frontend: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to set frontend: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1329,12 +1329,12 @@ gl843_init_optical_regs_scan (Genesys_Device * dev,
if(half_ccd)
{
sanei_genesys_set_double(reg,REG_DPISET,dpiset*4);
DBG (DBG_io2, "%s: dpiset used=%d\n", __FUNCTION__, dpiset*4);
DBG (DBG_io2, "%s: dpiset used=%d\n", __func__, dpiset*4);
}
else
{
sanei_genesys_set_double(reg,REG_DPISET,dpiset);
DBG (DBG_io2, "%s: dpiset used=%d\n", __FUNCTION__, dpiset);
DBG (DBG_io2, "%s: dpiset used=%d\n", __func__, dpiset);
}
sanei_genesys_set_double(reg,REG_STRPIXEL,startx/tgtime);
@ -1355,22 +1355,22 @@ gl843_init_optical_regs_scan (Genesys_Device * dev,
dev->wpl = words_per_line;
dev->bpl = words_per_line;
DBG (DBG_io2, "%s: used_pixels=%d\n", __FUNCTION__, used_pixels);
DBG (DBG_io2, "%s: pixels =%d\n", __FUNCTION__, pixels);
DBG (DBG_io2, "%s: depth =%d\n", __FUNCTION__, depth);
DBG (DBG_io2, "%s: dev->bpl =%lu\n", __FUNCTION__, (unsigned long) dev->bpl);
DBG (DBG_io2, "%s: dev->len =%lu\n", __FUNCTION__, (unsigned long)dev->len);
DBG (DBG_io2, "%s: dev->dist =%lu\n", __FUNCTION__, (unsigned long)dev->dist);
DBG (DBG_io2, "%s: used_pixels=%d\n", __func__, used_pixels);
DBG (DBG_io2, "%s: pixels =%d\n", __func__, pixels);
DBG (DBG_io2, "%s: depth =%d\n", __func__, depth);
DBG (DBG_io2, "%s: dev->bpl =%lu\n", __func__, (unsigned long) dev->bpl);
DBG (DBG_io2, "%s: dev->len =%lu\n", __func__, (unsigned long)dev->len);
DBG (DBG_io2, "%s: dev->dist =%lu\n", __func__, (unsigned long)dev->dist);
words_per_line *= channels;
/* MAXWD is expressed in 2 words unit */
/* nousedspace = (mem_bank_range * 1024 / 256 -1 ) * 4; */
sanei_genesys_set_triple(reg,REG_MAXWD,(words_per_line)>>1);
DBG (DBG_io2, "%s: words_per_line used=%d\n", __FUNCTION__, words_per_line);
DBG (DBG_io2, "%s: words_per_line used=%d\n", __func__, words_per_line);
sanei_genesys_set_double(reg,REG_LPERIOD,exposure/tgtime);
DBG (DBG_io2, "%s: exposure used=%d\n", __FUNCTION__, exposure/tgtime);
DBG (DBG_io2, "%s: exposure used=%d\n", __func__, exposure/tgtime);
r = sanei_genesys_get_address (reg, REG_DUMMY);
r->value = dev->sensor.dummy_pixel * tgtime;
@ -1456,7 +1456,7 @@ gl843_init_scan_regs (Genesys_Device * dev,
{
stagger = (4 * yres) / dev->motor.base_ydpi;
}
DBG (DBG_info, "%s : stagger=%d lines\n", __FUNCTION__, stagger);
DBG (DBG_info, "%s : stagger=%d lines\n", __func__, stagger);
/* we enable true gray for cis scanners only, and just when doing
* scan since color calibration is OK for this mode
@ -1498,7 +1498,7 @@ gl843_init_scan_regs (Genesys_Device * dev,
/* compute correct pixels number */
used_pixels = (pixels * optical_res) / xres;
DBG (DBG_info, "%s: used_pixels=%d\n", __FUNCTION__, used_pixels);
DBG (DBG_info, "%s: used_pixels=%d\n", __func__, used_pixels);
/* round up pixels number if needed */
if (used_pixels * xres < pixels * optical_res)
@ -1531,8 +1531,8 @@ gl843_init_scan_regs (Genesys_Device * dev,
scan_step_type = sanei_genesys_compute_step_type(gl843_motors, dev->model->motor_type, exposure);
}
DBG (DBG_info, "%s : exposure=%d pixels\n", __FUNCTION__, exposure);
DBG (DBG_info, "%s : scan_step_type=%d\n", __FUNCTION__, scan_step_type);
DBG (DBG_info, "%s : exposure=%d pixels\n", __func__, exposure);
DBG (DBG_info, "%s : scan_step_type=%d\n", __func__, scan_step_type);
/*** optical parameters ***/
/* in case of dynamic lineart, we use an internal 8 bit gray scan
@ -1652,7 +1652,7 @@ gl843_init_scan_regs (Genesys_Device * dev,
dev->current_setup.pixels = (used_pixels * used_res) / optical_res;
DBG (DBG_info, "%s: current_setup.pixels=%d\n", __FUNCTION__, dev->current_setup.pixels);
DBG (DBG_info, "%s: current_setup.pixels=%d\n", __func__, dev->current_setup.pixels);
dev->current_setup.lines = lincnt;
dev->current_setup.depth = depth;
dev->current_setup.channels = channels;
@ -1777,7 +1777,7 @@ gl843_calculate_current_setup (Genesys_Device * dev)
stagger = (4 * yres) / dev->motor.base_ydpi;
else
stagger = 0;
DBG (DBG_info, "%s: stagger=%d lines\n", __FUNCTION__, stagger);
DBG (DBG_info, "%s: stagger=%d lines\n", __func__, stagger);
if(xres<=optical_res)
used_res = xres;
@ -1790,11 +1790,11 @@ gl843_calculate_current_setup (Genesys_Device * dev)
/* compute correct pixels number */
used_pixels = (pixels * optical_res) / xres;
DBG (DBG_info, "%s: used_pixels=%d\n", __FUNCTION__, used_pixels);
DBG (DBG_info, "%s: used_pixels=%d\n", __func__, used_pixels);
/* exposure */
exposure = gl843_compute_exposure (dev, used_res, oflags);
DBG (DBG_info, "%s : exposure=%d pixels\n", __FUNCTION__, exposure);
DBG (DBG_info, "%s : exposure=%d pixels\n", __func__, exposure);
/* it seems base_dpi of the G4050 motor is changed above 600 dpi*/
if (dev->model->motor_type == MOTOR_G4050 && yres>600)
@ -1817,7 +1817,7 @@ gl843_calculate_current_setup (Genesys_Device * dev)
lincnt = lines + max_shift + stagger;
dev->current_setup.pixels = (used_pixels * used_res) / optical_res;
DBG (DBG_info, "%s: current_setup.pixels=%d\n", __FUNCTION__, dev->current_setup.pixels);
DBG (DBG_info, "%s: current_setup.pixels=%d\n", __func__, dev->current_setup.pixels);
dev->current_setup.lines = lincnt;
dev->current_setup.depth = depth;
dev->current_setup.channels = channels;
@ -1944,7 +1944,7 @@ gl843_stop_action (Genesys_Device * dev)
uint8_t val40, val;
unsigned int loop;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
status = sanei_genesys_get_status (dev, &val);
if (DBG_LEVEL >= DBG_io)
@ -1957,17 +1957,17 @@ gl843_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n", __FUNCTION__,
"%s: failed to read home sensor: %s\n", __func__,
sane_strstatus (status));
DBG (DBG_proc, "%s: completed\n", __FUNCTION__);
DBG (DBG_proc, "%s: completed\n", __func__);
return status;
}
/* only stop action if needed */
if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
{
DBG (DBG_info, "%s: already stopped\n", __FUNCTION__);
DBG (DBG_proc, "%s: completed\n", __FUNCTION__);
DBG (DBG_info, "%s: already stopped\n", __func__);
DBG (DBG_proc, "%s: completed\n", __func__);
return SANE_STATUS_GOOD;
}
@ -1978,7 +1978,7 @@ gl843_stop_action (Genesys_Device * dev)
status = sanei_genesys_write_register (dev, REG01, val);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to write register 01: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to write register 01: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1997,7 +1997,7 @@ gl843_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n", __FUNCTION__,
"%s: failed to read home sensor: %s\n", __func__,
sane_strstatus (status));
DBGCOMPLETED;
return status;
@ -2042,7 +2042,7 @@ gl843_get_paper_sensor (Genesys_Device * dev, SANE_Bool * paper_loaded)
static SANE_Status
gl843_eject_document (Genesys_Device * dev)
{
DBG (DBG_proc, "%s: not implemented \n", __FUNCTION__);
DBG (DBG_proc, "%s: not implemented \n", __func__);
if (dev == NULL)
return SANE_STATUS_INVAL;
return SANE_STATUS_GOOD;
@ -2052,7 +2052,7 @@ gl843_eject_document (Genesys_Device * dev)
static SANE_Status
gl843_load_document (Genesys_Device * dev)
{
DBG (DBG_proc, "%s: not implemented \n", __FUNCTION__);
DBG (DBG_proc, "%s: not implemented \n", __func__);
if (dev == NULL)
return SANE_STATUS_INVAL;
return SANE_STATUS_GOOD;
@ -2071,14 +2071,14 @@ gl843_detect_document_end (Genesys_Device * dev)
unsigned int scancnt = 0;
int flines, channels, depth, bytes_remain, sublines,
bytes_to_flush, lines, sub_bytes, tmp, read_bytes_left;
DBG (DBG_proc, "%s: begin\n", __FUNCTION__);
DBG (DBG_proc, "%s: begin\n", __func__);
RIE (gl843_get_paper_sensor (dev, &paper_loaded));
/* sheetfed scanner uses home sensor as paper present */
if ((dev->document == SANE_TRUE) && !paper_loaded)
{
DBG (DBG_info, "%s: no more document\n", __FUNCTION__);
DBG (DBG_info, "%s: no more document\n", __func__);
dev->document = SANE_FALSE;
channels = dev->current_setup.channels;
@ -2193,7 +2193,7 @@ gl843_detect_document_end (Genesys_Device * dev)
}
}
DBG (DBG_proc, "%s: finished\n", __FUNCTION__);
DBG (DBG_proc, "%s: finished\n", __func__);
return SANE_STATUS_GOOD;
}
@ -2483,7 +2483,7 @@ static SANE_Status gl843_park_xpa_lamp (Genesys_Device * dev)
status = gl843_start_action (dev);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to start motor: %s\n",__FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to start motor: %s\n",__func__, sane_strstatus (status));
gl843_stop_action (dev);
/* restore original registers */
dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS);
@ -2496,7 +2496,7 @@ static SANE_Status gl843_park_xpa_lamp (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n",__FUNCTION__,
"%s: failed to read home sensor: %s\n",__func__,
sane_strstatus (status));
return status;
}
@ -2507,8 +2507,8 @@ static SANE_Status gl843_park_xpa_lamp (Genesys_Device * dev)
if (val & REG41_HOMESNR) /* home sensor */
{
DBG (DBG_info, "%s: reached home position\n",__FUNCTION__);
DBG (DBG_proc, "%s: finished\n",__FUNCTION__);
DBG (DBG_info, "%s: reached home position\n",__func__);
DBG (DBG_proc, "%s: finished\n",__func__);
/* clear GPOADF to avoid reparking again */
sanei_genesys_read_register (dev, REG6B, &val);
@ -2524,7 +2524,7 @@ static SANE_Status gl843_park_xpa_lamp (Genesys_Device * dev)
}
/* we are not parked here.... should we fail ? */
DBG (DBG_info, "%s: XPA lamp is not parked\n", __FUNCTION__);
DBG (DBG_info, "%s: XPA lamp is not parked\n", __func__);
DBGCOMPLETED;
return SANE_STATUS_GOOD;
}
@ -2564,7 +2564,7 @@ gl843_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
status = sanei_genesys_get_status (dev, &val);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to read home sensor: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to read home sensor: %s\n", __func__, sane_strstatus (status));
return status;
}
usleep (100000); /* sleep 100 ms */
@ -2674,7 +2674,7 @@ gl843_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
return SANE_STATUS_IO_ERROR;
}
DBG (DBG_info, "%s: scanhead is still moving\n", __FUNCTION__);
DBG (DBG_info, "%s: scanhead is still moving\n", __func__);
DBGCOMPLETED;
return SANE_STATUS_GOOD;
}
@ -2926,7 +2926,7 @@ gl843_feed (Genesys_Device * dev, unsigned int steps)
status = gl843_start_action (dev);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to start motor: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus (status));
gl843_stop_action (dev);
/* restore original registers */
@ -3000,7 +3000,7 @@ gl843_init_regs_for_shading (Genesys_Device * dev)
dev->scanhead_position_in_steps += dev->calib_lines + move;
sanei_genesys_get_double(dev->calib_reg,REG_STRPIXEL,&strpixel);
DBG (DBG_info, "%s: STRPIXEL=%d\n", __FUNCTION__, strpixel);
DBG (DBG_info, "%s: STRPIXEL=%d\n", __func__, strpixel);
status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS);
if (status != SANE_STATUS_GOOD)
@ -3380,9 +3380,9 @@ dark_average_channel (uint8_t * data, unsigned int pixels, unsigned int lines,
}
if (count)
avg[k] /= count;
DBG (DBG_info, "%s: avg[%d] = %d\n", __FUNCTION__, k, avg[k]);
DBG (DBG_info, "%s: avg[%d] = %d\n", __func__, k, avg[k]);
}
DBG (DBG_info, "%s: average = %d\n", __FUNCTION__, avg[channel]);
DBG (DBG_info, "%s: average = %d\n", __func__, avg[channel]);
return avg[channel];
}
@ -3786,7 +3786,7 @@ gl843_init_regs_for_warmup (Genesys_Device * dev,
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to setup scan: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus (status));
return status;
}
@ -3875,7 +3875,7 @@ gl843_boot (Genesys_Device * dev, SANE_Bool cold)
{
RIE (sanei_genesys_read_register (dev, 0x00, &val));
DBG (DBG_info,
"%s: reported version for genesys chip is 0x%02x\n", __FUNCTION__,
"%s: reported version for genesys chip is 0x%02x\n", __func__,
val);
}
@ -3998,7 +3998,7 @@ SANE_Status gl843_move_to_ta (Genesys_Device * dev)
status = gl843_feed (dev, feed);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to move to XPA calibration area\n", __FUNCTION__);
DBG (DBG_error, "%s: failed to move to XPA calibration area\n", __func__);
return status;
}
@ -4357,16 +4357,16 @@ gl843_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
/* 16 bit words, 2 words per color, 3 color channels */
offset=(strpixel-startx)*2*2*3;
length=(endpixel-strpixel)*2*2*3;
DBG (DBG_info, "%s: STRPIXEL=%d, ENDPIXEL=%d, startx=%d\n", __FUNCTION__, strpixel, endpixel, startx);
DBG (DBG_info, "%s: STRPIXEL=%d, ENDPIXEL=%d, startx=%d\n", __func__, strpixel, endpixel, startx);
}
/* compute and allocate size for final data */
final_size = ((length+251) / 252) * 256;
DBG (DBG_io, "%s: final shading size=%04x (length=%d)\n", __FUNCTION__, final_size, length);
DBG (DBG_io, "%s: final shading size=%04x (length=%d)\n", __func__, final_size, length);
final_data = (uint8_t *) malloc (final_size);
if(final_data==NULL)
{
DBG (DBG_error, "%s: failed to allocate memory for shading data\n", __FUNCTION__);
DBG (DBG_error, "%s: failed to allocate memory for shading data\n", __func__);
return SANE_STATUS_NO_MEM;
}
memset(final_data,0x00,final_size);
@ -4390,7 +4390,7 @@ gl843_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
status = sanei_genesys_set_buffer_address (dev, 0);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to set buffer address: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to set buffer address: %s\n", __func__, sane_strstatus (status));
free(final_data);
return status;
}
@ -4398,7 +4398,7 @@ gl843_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
status = dev->model->cmd_set->bulk_write_data (dev, 0x3c, final_data, count);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to send shading table: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to send shading table: %s\n", __func__, sane_strstatus (status));
}
free(final_data);

4
backend/genesys_gl843.h
Wyświetl plik

@ -73,8 +73,8 @@ SANE_Status gl843_xpa_motor_off (Genesys_Device * dev);
SANE_Status gl843_move_to_ta (Genesys_Device * dev);
#endif
#define DBGSTART DBG (DBG_proc, "%s start\n", __FUNCTION__);
#define DBGCOMPLETED DBG (DBG_proc, "%s completed\n", __FUNCTION__);
#define DBGSTART DBG (DBG_proc, "%s start\n", __func__);
#define DBGCOMPLETED DBG (DBG_proc, "%s completed\n", __func__);
#define REG01 0x01
#define REG01_CISSET 0x80

112
backend/genesys_gl846.c
Wyświetl plik

@ -117,7 +117,7 @@ gl846_bulk_read_data (Genesys_Device * dev, uint8_t addr,
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s failed while writing command: %s\n",
__FUNCTION__, sane_strstatus (status));
__func__, sane_strstatus (status));
return status;
}
@ -162,7 +162,7 @@ gl846_bulk_read_data (Genesys_Device * dev, uint8_t addr,
DBG (DBG_io2, "gl846_bulk_read_data: %lu bytes of data read\n", (u_long) done);
}
DBG (DBG_io2, "%s: read %lu bytes, %lu remaining\n", __FUNCTION__,
DBG (DBG_io2, "%s: read %lu bytes, %lu remaining\n", __func__,
(u_long) size, (u_long) (target - size));
target -= size;
@ -269,7 +269,7 @@ gl846_get_step_multiplier (Genesys_Register_Set * regs)
value = (r->value & 0x0f)>>1;
value = 1 << value;
}
DBG (DBG_io, "%s: step multiplier is %d\n", __FUNCTION__, value);
DBG (DBG_io, "%s: step multiplier is %d\n", __func__, value);
return value;
}
@ -317,7 +317,7 @@ static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi)
/* default fallback */
if(idx<0)
{
DBG (DBG_warn,"%s: using default sensor profile\n",__FUNCTION__);
DBG (DBG_warn,"%s: using default sensor profile\n",__func__);
idx=0;
}
@ -577,13 +577,13 @@ gl846_send_slope_table (Genesys_Device * dev, int table_nr,
int i;
char msg[10000];
DBG (DBG_proc, "%s (table_nr = %d, steps = %d)\n", __FUNCTION__,
DBG (DBG_proc, "%s (table_nr = %d, steps = %d)\n", __func__,
table_nr, steps);
/* sanity check */
if(table_nr<0 || table_nr>4)
{
DBG (DBG_error, "%s: invalid table number %d!\n", __FUNCTION__, table_nr);
DBG (DBG_error, "%s: invalid table number %d!\n", __func__, table_nr);
return SANE_STATUS_INVAL;
}
@ -601,7 +601,7 @@ gl846_send_slope_table (Genesys_Device * dev, int table_nr,
{
sprintf (msg+strlen(msg), "%d", slope_table[i]);
}
DBG (DBG_io, "%s: %s\n", __FUNCTION__, msg);
DBG (DBG_io, "%s: %s\n", __func__, msg);
}
/* slope table addresses are fixed */
@ -610,7 +610,7 @@ gl846_send_slope_table (Genesys_Device * dev, int table_nr,
{
DBG (DBG_error,
"%s: write to AHB failed writing slope table %d (%s)\n",
__FUNCTION__, table_nr, sane_strstatus (status));
__func__, table_nr, sane_strstatus (status));
}
free (table);
@ -641,7 +641,7 @@ gl846_set_adi_fe (Genesys_Device * dev, uint8_t set)
if (set == AFE_INIT)
{
DBG (DBG_proc, "%s(): setting DAC %u\n", __FUNCTION__, dev->model->dac_type);
DBG (DBG_proc, "%s(): setting DAC %u\n", __func__, dev->model->dac_type);
/* sets to default values */
sanei_genesys_init_fe (dev);
@ -652,7 +652,7 @@ gl846_set_adi_fe (Genesys_Device * dev, uint8_t set)
status = sanei_genesys_fe_write_data (dev, 0x00, val);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to write reg0: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to write reg0: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -660,7 +660,7 @@ gl846_set_adi_fe (Genesys_Device * dev, uint8_t set)
status = sanei_genesys_fe_write_data (dev, 0x01, val);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to write reg1: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to write reg1: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -672,7 +672,7 @@ gl846_set_adi_fe (Genesys_Device * dev, uint8_t set)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to write gain %d: %s\n", __FUNCTION__, i,
"%s: failed to write gain %d: %s\n", __func__, i,
sane_strstatus (status));
return status;
}
@ -684,7 +684,7 @@ gl846_set_adi_fe (Genesys_Device * dev, uint8_t set)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to write offset %d: %s\n", __FUNCTION__, i,
"%s: failed to write offset %d: %s\n", __func__, i,
sane_strstatus (status));
return status;
}
@ -781,10 +781,10 @@ gl846_init_motor_regs_scan (Genesys_Device * dev,
{
use_fast_fed=1;
}
DBG (DBG_io, "%s: use_fast_fed=%d\n", __FUNCTION__, use_fast_fed);
DBG (DBG_io, "%s: use_fast_fed=%d\n", __func__, use_fast_fed);
sanei_genesys_set_triple(reg, REG_LINCNT, scan_lines);
DBG (DBG_io, "%s: lincnt=%d\n", __FUNCTION__, scan_lines);
DBG (DBG_io, "%s: lincnt=%d\n", __func__, scan_lines);
/* compute register 02 value */
r = sanei_genesys_get_address (reg, REG02);
@ -863,8 +863,8 @@ gl846_init_motor_regs_scan (Genesys_Device * dev,
if (flags & MOTOR_FLAG_FEED)
dist *=2;
}
DBG (DBG_io2, "%s: scan steps=%d\n", __FUNCTION__, scan_steps);
DBG (DBG_io2, "%s: acceleration distance=%d\n", __FUNCTION__, dist);
DBG (DBG_io2, "%s: scan steps=%d\n", __func__, scan_steps);
DBG (DBG_io2, "%s: acceleration distance=%d\n", __func__, dist);
/* check for overflow */
if(dist<feedl)
@ -873,7 +873,7 @@ gl846_init_motor_regs_scan (Genesys_Device * dev,
feedl = 0;
sanei_genesys_set_triple(reg,REG_FEEDL,feedl);
DBG (DBG_io ,"%s: feedl=%d\n",__FUNCTION__,feedl);
DBG (DBG_io ,"%s: feedl=%d\n",__func__,feedl);
r = sanei_genesys_get_address (reg, REG0C);
ccdlmt=(r->value & REG0C_CCDLMT)+1;
@ -1024,13 +1024,13 @@ gl846_init_optical_regs_scan (Genesys_Device * dev,
/* resolution is divided according to CKSEL */
r = sanei_genesys_get_address (reg, REG18);
cksel= (r->value & REG18_CKSEL)+1;
DBG (DBG_io2, "%s: cksel=%d\n", __FUNCTION__, cksel);
DBG (DBG_io2, "%s: cksel=%d\n", __func__, cksel);
/* to manage high resolution device while keeping good
* low resolution scanning speed, we make hardware dpi vary */
dpihw=sanei_genesys_compute_dpihw(dev, used_res * cksel);
factor=dev->sensor.optical_res/dpihw;
DBG (DBG_io2, "%s: dpihw=%d (factor=%d)\n", __FUNCTION__, dpihw, factor);
DBG (DBG_io2, "%s: dpihw=%d (factor=%d)\n", __func__, dpihw, factor);
/* sensor parameters */
sensor=get_sensor_profile(dev->model->ccd_type, dpihw);
@ -1215,20 +1215,20 @@ gl846_init_optical_regs_scan (Genesys_Device * dev,
dev->line_interp = 0;
sanei_genesys_set_double(reg,REG_DPISET,dpiset);
DBG (DBG_io2, "%s: dpiset used=%d\n", __FUNCTION__, dpiset);
DBG (DBG_io2, "%s: dpiset used=%d\n", __func__, dpiset);
sanei_genesys_set_double(reg,REG_STRPIXEL,startx);
sanei_genesys_set_double(reg,REG_ENDPIXEL,endx);
DBG (DBG_io2, "%s: startx=%d\n", __FUNCTION__, startx);
DBG (DBG_io2, "%s: endx =%d\n", __FUNCTION__, endx);
DBG (DBG_io2, "%s: startx=%d\n", __func__, startx);
DBG (DBG_io2, "%s: endx =%d\n", __func__, endx);
DBG (DBG_io2, "%s: used_pixels=%d\n", __FUNCTION__, used_pixels);
DBG (DBG_io2, "%s: pixels =%d\n", __FUNCTION__, pixels);
DBG (DBG_io2, "%s: depth =%d\n", __FUNCTION__, depth);
DBG (DBG_io2, "%s: dev->bpl =%lu\n", __FUNCTION__, (unsigned long)dev->bpl);
DBG (DBG_io2, "%s: dev->len =%lu\n", __FUNCTION__, (unsigned long)dev->len);
DBG (DBG_io2, "%s: dev->dist =%lu\n", __FUNCTION__, (unsigned long)dev->dist);
DBG (DBG_io2, "%s: dev->segnb =%lu\n", __FUNCTION__, (unsigned long)dev->segnb);
DBG (DBG_io2, "%s: used_pixels=%d\n", __func__, used_pixels);
DBG (DBG_io2, "%s: pixels =%d\n", __func__, pixels);
DBG (DBG_io2, "%s: depth =%d\n", __func__, depth);
DBG (DBG_io2, "%s: dev->bpl =%lu\n", __func__, (unsigned long)dev->bpl);
DBG (DBG_io2, "%s: dev->len =%lu\n", __func__, (unsigned long)dev->len);
DBG (DBG_io2, "%s: dev->dist =%lu\n", __func__, (unsigned long)dev->dist);
DBG (DBG_io2, "%s: dev->segnb =%lu\n", __func__, (unsigned long)dev->segnb);
words_per_line *= channels;
dev->wpl = words_per_line;
@ -1241,10 +1241,10 @@ gl846_init_optical_regs_scan (Genesys_Device * dev,
/* MAXWD is expressed in 4 words unit */
sanei_genesys_set_triple(reg, REG_MAXWD, (words_per_line >> 2));
DBG (DBG_io2, "%s: words_per_line used=%d\n", __FUNCTION__, words_per_line);
DBG (DBG_io2, "%s: words_per_line used=%d\n", __func__, words_per_line);
sanei_genesys_set_double(reg, REG_LPERIOD, exposure_time);
DBG (DBG_io2, "%s: exposure_time used=%d\n", __FUNCTION__, exposure_time);
DBG (DBG_io2, "%s: exposure_time used=%d\n", __func__, exposure_time);
r = sanei_genesys_get_address (reg, 0x34);
r->value = dev->sensor.dummy_pixel;
@ -1645,7 +1645,7 @@ gl846_calculate_current_setup (Genesys_Device * dev)
slope_dpi = slope_dpi * (1 + dummy);
exposure_time = gl846_compute_exposure (dev, used_res);
DBG (DBG_info, "%s : exposure_time=%d pixels\n", __FUNCTION__, exposure_time);
DBG (DBG_info, "%s : exposure_time=%d pixels\n", __func__, exposure_time);
/* max_shift */
max_shift=sanei_genesys_compute_max_shift(dev,channels,yres,0);
@ -1761,7 +1761,7 @@ gl846_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n", __FUNCTION__,
"%s: failed to read home sensor: %s\n", __func__,
sane_strstatus (status));
DBGCOMPLETED;
return status;
@ -1770,7 +1770,7 @@ gl846_stop_action (Genesys_Device * dev)
/* only stop action if needed */
if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
{
DBG (DBG_info, "%s: already stopped\n", __FUNCTION__);
DBG (DBG_info, "%s: already stopped\n", __func__);
DBGCOMPLETED;
return SANE_STATUS_GOOD;
}
@ -1783,7 +1783,7 @@ gl846_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to write register 01: %s\n", __FUNCTION__,
"%s: failed to write register 01: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1801,7 +1801,7 @@ gl846_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n", __FUNCTION__,
"%s: failed to read home sensor: %s\n", __func__,
sane_strstatus (status));
DBGCOMPLETED;
return status;
@ -1962,7 +1962,7 @@ gl846_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
/* is sensor at home? */
if (val & HOMESNR)
{
DBG (DBG_info, "%s: already at home, completed\n", __FUNCTION__);
DBG (DBG_info, "%s: already at home, completed\n", __func__);
dev->scanhead_position_in_steps = 0;
DBGCOMPLETED;
return SANE_STATUS_GOOD;
@ -2257,7 +2257,7 @@ gl846_feed (Genesys_Device * dev, unsigned int steps)
uint8_t val;
DBGSTART;
DBG (DBG_io, "%s: steps=%d\n", __FUNCTION__, steps);
DBG (DBG_io, "%s: steps=%d\n", __func__, steps);
/* prepare local registers */
memcpy (local_reg, dev->reg, GENESYS_GL846_MAX_REGS * sizeof (Genesys_Register_Set));
@ -2306,7 +2306,7 @@ gl846_feed (Genesys_Device * dev, unsigned int steps)
status = gl846_start_action (dev);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to start motor: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus (status));
gl846_stop_action (dev);
/* restore original registers */
@ -2348,8 +2348,8 @@ gl846_init_regs_for_shading (Genesys_Device * dev)
if(dev->calib_resolution==4800)
dev->calib_lines *= 2;
dev->calib_pixels = (dev->sensor.sensor_pixels*dev->calib_resolution)/dev->sensor.optical_res;
DBG (DBG_io, "%s: calib_lines = %d\n", __FUNCTION__, (unsigned int)dev->calib_lines);
DBG (DBG_io, "%s: calib_pixels = %d\n", __FUNCTION__, (unsigned int)dev->calib_pixels);
DBG (DBG_io, "%s: calib_lines = %d\n", __func__, (unsigned int)dev->calib_lines);
DBG (DBG_io, "%s: calib_pixels = %d\n", __func__, (unsigned int)dev->calib_pixels);
/* this is aworkaround insufficent distance for slope
* motor acceleration TODO special motor slope for shading */
@ -2377,14 +2377,14 @@ gl846_init_regs_for_shading (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to setup scan: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus (status));
return status;
}
status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL846_MAX_REGS);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus (status));
return status;
}
@ -2452,7 +2452,7 @@ gl846_init_regs_for_scan (Genesys_Device * dev)
move += dev->settings.tl_y;
move = (move * move_dpi) / MM_PER_INCH;
move -= dev->scanhead_position_in_steps;
DBG (DBG_info, "%s: move=%f steps\n",__FUNCTION__, move);
DBG (DBG_info, "%s: move=%f steps\n",__func__, move);
/* fast move to scan area */
/* we don't move fast the whole distance since it would involve
@ -2464,14 +2464,14 @@ gl846_init_regs_for_scan (Genesys_Device * dev)
status = gl846_feed (dev, move-500);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to move to scan area\n",__FUNCTION__);
DBG (DBG_error, "%s: failed to move to scan area\n",__func__);
return status;
}
move=500;
}
DBG (DBG_info, "gl846_init_regs_for_scan: move=%f steps\n", move);
DBG (DBG_info, "%s: move=%f steps\n", __FUNCTION__, move);
DBG (DBG_info, "%s: move=%f steps\n", __func__, move);
/* start */
start = SANE_UNFIX (dev->model->x_offset);
@ -2526,7 +2526,7 @@ gl846_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
uint8_t val,*buffer,*ptr,*src;
DBGSTART;
DBG( DBG_io2, "%s: writing %d bytes of shading data\n",__FUNCTION__,size);
DBG( DBG_io2, "%s: writing %d bytes of shading data\n",__func__,size);
/* shading data is plit in 3 (up to 5 with IR) areas
write(0x10014000,0x00000dd8)
@ -2543,10 +2543,10 @@ gl846_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
/* compute deletion factor */
sanei_genesys_get_double(dev->reg,REG_DPISET,&tempo);
dpiset=tempo;
DBG( DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d, PIXELS=%d, DPISET=%d\n",__FUNCTION__,strpixel,endpixel,endpixel-strpixel,dpiset);
DBG( DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d, PIXELS=%d, DPISET=%d\n",__func__,strpixel,endpixel,endpixel-strpixel,dpiset);
dpihw=sanei_genesys_compute_dpihw(dev,dpiset);
factor=dpihw/dpiset;
DBG( DBG_io2, "%s: factor=%d\n",__FUNCTION__,factor);
DBG( DBG_io2, "%s: factor=%d\n",__func__,factor);
if(DBG_LEVEL>=DBG_data)
{
@ -2571,7 +2571,7 @@ gl846_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
/* allocate temporary buffer */
buffer=(uint8_t *)malloc(pixels);
memset(buffer,0,pixels);
DBG( DBG_io2, "%s: using chunks of %d (0x%04x) bytes\n",__FUNCTION__,pixels,pixels);
DBG( DBG_io2, "%s: using chunks of %d (0x%04x) bytes\n",__func__,pixels,pixels);
/* base addr of data has been written in reg D0-D4 in 4K word, so AHB address
* is 8192*reg value */
@ -2649,7 +2649,7 @@ gl846_led_calibration (Genesys_Device * dev)
{
RIE(gl846_feed (dev, move));
}
DBG (DBG_io, "%s: move=%f steps\n", __FUNCTION__, move);
DBG (DBG_io, "%s: move=%f steps\n", __func__, move);
/* offset calibration is always done in color mode */
channels = 3;
@ -2679,7 +2679,7 @@ gl846_led_calibration (Genesys_Device * dev)
SCAN_FLAG_IGNORE_LINE_DISTANCE);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to setup scan: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus (status));
return status;
}
@ -2816,7 +2816,7 @@ gl846_init_gpio (Genesys_Device * dev)
}
if(gpios[idx].sensor_id==0)
{
DBG (DBG_error, "%s: failed to find GPIO profile for sensor_id=%d\n", __FUNCTION__, dev->model->ccd_type);
DBG (DBG_error, "%s: failed to find GPIO profile for sensor_id=%d\n", __func__, dev->model->ccd_type);
return SANE_STATUS_INVAL;
}
@ -2857,7 +2857,7 @@ gl846_init_memory_layout (Genesys_Device * dev)
}
if(layouts[idx].model==NULL)
{
DBG(DBG_error, "%s: failed to find memory layout for model %s!\n", __FUNCTION__, dev->model->name);
DBG(DBG_error, "%s: failed to find memory layout for model %s!\n", __func__, dev->model->name);
return SANE_STATUS_INVAL;
}
@ -2915,7 +2915,7 @@ gl846_boot (Genesys_Device * dev, SANE_Bool cold)
if (val & REG40_CHKVER)
{
RIE (sanei_genesys_read_register (dev, 0x00, &val));
DBG (DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __FUNCTION__, val);
DBG (DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
}
/* Set default values for registers */

100
backend/genesys_gl847.c
Wyświetl plik

@ -113,7 +113,7 @@ gl847_bulk_read_data (Genesys_Device * dev, uint8_t addr,
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s failed while writing command: %s\n",
__FUNCTION__, sane_strstatus (status));
__func__, sane_strstatus (status));
return status;
}
@ -158,7 +158,7 @@ gl847_bulk_read_data (Genesys_Device * dev, uint8_t addr,
DBG (DBG_io2, "gl847_bulk_read_data: %lu bytes of data read\n", (u_long) done);
}
DBG (DBG_io2, "%s: read %lu bytes, %lu remaining\n", __FUNCTION__,
DBG (DBG_io2, "%s: read %lu bytes, %lu remaining\n", __func__,
(u_long) size, (u_long) (target - size));
target -= size;
@ -265,7 +265,7 @@ gl847_get_step_multiplier (Genesys_Register_Set * regs)
value = (r->value & 0x0f)>>1;
value = 1 << value;
}
DBG (DBG_io, "%s: step multiplier is %d\n", __FUNCTION__, value);
DBG (DBG_io, "%s: step multiplier is %d\n", __func__, value);
return value;
}
@ -313,7 +313,7 @@ static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi)
/* default fallback */
if(idx<0)
{
DBG (DBG_warn,"%s: using default sensor profile\n",__FUNCTION__);
DBG (DBG_warn,"%s: using default sensor profile\n",__func__);
idx=0;
}
@ -600,13 +600,13 @@ gl847_send_slope_table (Genesys_Device * dev, int table_nr,
int i;
char msg[10000];
DBG (DBG_proc, "%s (table_nr = %d, steps = %d)\n", __FUNCTION__,
DBG (DBG_proc, "%s (table_nr = %d, steps = %d)\n", __func__,
table_nr, steps);
/* sanity check */
if(table_nr<0 || table_nr>4)
{
DBG (DBG_error, "%s: invalid table number %d!\n", __FUNCTION__, table_nr);
DBG (DBG_error, "%s: invalid table number %d!\n", __func__, table_nr);
return SANE_STATUS_INVAL;
}
@ -624,7 +624,7 @@ gl847_send_slope_table (Genesys_Device * dev, int table_nr,
{
sprintf (msg+strlen(msg), "%d", slope_table[i]);
}
DBG (DBG_io, "%s: %s\n", __FUNCTION__, msg);
DBG (DBG_io, "%s: %s\n", __func__, msg);
}
/* slope table addresses are fixed */
@ -634,7 +634,7 @@ gl847_send_slope_table (Genesys_Device * dev, int table_nr,
{
DBG (DBG_error,
"%s: write to AHB failed writing slope table %d (%s)\n",
__FUNCTION__, table_nr, sane_strstatus (status));
__func__, table_nr, sane_strstatus (status));
}
free (table);
@ -824,10 +824,10 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
{
use_fast_fed=1;
}
DBG (DBG_io, "%s: use_fast_fed=%d\n", __FUNCTION__, use_fast_fed);
DBG (DBG_io, "%s: use_fast_fed=%d\n", __func__, use_fast_fed);
sanei_genesys_set_triple(reg, REG_LINCNT, scan_lines);
DBG (DBG_io, "%s: lincnt=%d\n", __FUNCTION__, scan_lines);
DBG (DBG_io, "%s: lincnt=%d\n", __func__, scan_lines);
/* compute register 02 value */
r = sanei_genesys_get_address (reg, REG02);
@ -906,8 +906,8 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
if (flags & MOTOR_FLAG_FEED)
dist *=2;
}
DBG (DBG_io2, "%s: scan steps=%d\n", __FUNCTION__, scan_steps);
DBG (DBG_io2, "%s: acceleration distance=%d\n", __FUNCTION__, dist);
DBG (DBG_io2, "%s: scan steps=%d\n", __func__, scan_steps);
DBG (DBG_io2, "%s: acceleration distance=%d\n", __func__, dist);
/* check for overflow */
if(dist<feedl)
@ -916,7 +916,7 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
feedl = 0;
sanei_genesys_set_triple(reg,REG_FEEDL,feedl);
DBG (DBG_io ,"%s: feedl=%d\n",__FUNCTION__,feedl);
DBG (DBG_io ,"%s: feedl=%d\n",__func__,feedl);
r = sanei_genesys_get_address (reg, REG0C);
ccdlmt=(r->value & REG0C_CCDLMT)+1;
@ -1048,13 +1048,13 @@ gl847_init_optical_regs_scan (Genesys_Device * dev,
/* resolution is divided according to CKSEL */
r = sanei_genesys_get_address (reg, REG18);
cksel= (r->value & REG18_CKSEL)+1;
DBG (DBG_io2, "%s: cksel=%d\n", __FUNCTION__, cksel);
DBG (DBG_io2, "%s: cksel=%d\n", __func__, cksel);
/* to manage high resolution device while keeping good
* low resolution scanning speed, we make hardware dpi vary */
dpihw=sanei_genesys_compute_dpihw(dev, used_res * cksel);
factor=dev->sensor.optical_res/dpihw;
DBG (DBG_io2, "%s: dpihw=%d (factor=%d)\n", __FUNCTION__, dpihw, factor);
DBG (DBG_io2, "%s: dpihw=%d (factor=%d)\n", __func__, dpihw, factor);
/* sensor parameters */
sensor=get_sensor_profile(dev->model->ccd_type, dpihw);
@ -1239,20 +1239,20 @@ gl847_init_optical_regs_scan (Genesys_Device * dev,
dev->line_interp = 0;
sanei_genesys_set_double(reg,REG_DPISET,dpiset);
DBG (DBG_io2, "%s: dpiset used=%d\n", __FUNCTION__, dpiset);
DBG (DBG_io2, "%s: dpiset used=%d\n", __func__, dpiset);
sanei_genesys_set_double(reg,REG_STRPIXEL,startx);
sanei_genesys_set_double(reg,REG_ENDPIXEL,endx);
DBG (DBG_io2, "%s: startx=%d\n", __FUNCTION__, startx);
DBG (DBG_io2, "%s: endx =%d\n", __FUNCTION__, endx);
DBG (DBG_io2, "%s: startx=%d\n", __func__, startx);
DBG (DBG_io2, "%s: endx =%d\n", __func__, endx);
DBG (DBG_io2, "%s: used_pixels=%d\n", __FUNCTION__, used_pixels);
DBG (DBG_io2, "%s: pixels =%d\n", __FUNCTION__, pixels);
DBG (DBG_io2, "%s: depth =%d\n", __FUNCTION__, depth);
DBG (DBG_io2, "%s: dev->bpl =%lu\n", __FUNCTION__, (unsigned long)dev->bpl);
DBG (DBG_io2, "%s: dev->len =%lu\n", __FUNCTION__, (unsigned long)dev->len);
DBG (DBG_io2, "%s: dev->dist =%lu\n", __FUNCTION__, (unsigned long)dev->dist);
DBG (DBG_io2, "%s: dev->segnb =%lu\n", __FUNCTION__, (unsigned long)dev->segnb);
DBG (DBG_io2, "%s: used_pixels=%d\n", __func__, used_pixels);
DBG (DBG_io2, "%s: pixels =%d\n", __func__, pixels);
DBG (DBG_io2, "%s: depth =%d\n", __func__, depth);
DBG (DBG_io2, "%s: dev->bpl =%lu\n", __func__, (unsigned long)dev->bpl);
DBG (DBG_io2, "%s: dev->len =%lu\n", __func__, (unsigned long)dev->len);
DBG (DBG_io2, "%s: dev->dist =%lu\n", __func__, (unsigned long)dev->dist);
DBG (DBG_io2, "%s: dev->segnb =%lu\n", __func__, (unsigned long)dev->segnb);
words_per_line *= channels;
dev->wpl = words_per_line;
@ -1265,10 +1265,10 @@ gl847_init_optical_regs_scan (Genesys_Device * dev,
/* MAXWD is expressed in 4 words unit */
sanei_genesys_set_triple(reg, REG_MAXWD, (words_per_line >> 2));
DBG (DBG_io2, "%s: words_per_line used=%d\n", __FUNCTION__, words_per_line);
DBG (DBG_io2, "%s: words_per_line used=%d\n", __func__, words_per_line);
sanei_genesys_set_double(reg, REG_LPERIOD, exposure_time);
DBG (DBG_io2, "%s: exposure_time used=%d\n", __FUNCTION__, exposure_time);
DBG (DBG_io2, "%s: exposure_time used=%d\n", __func__, exposure_time);
r = sanei_genesys_get_address (reg, 0x34);
r->value = dev->sensor.dummy_pixel;
@ -1669,7 +1669,7 @@ gl847_calculate_current_setup (Genesys_Device * dev)
slope_dpi = slope_dpi * (1 + dummy);
exposure_time = gl847_compute_exposure (dev, used_res);
DBG (DBG_info, "%s : exposure_time=%d pixels\n", __FUNCTION__, exposure_time);
DBG (DBG_info, "%s : exposure_time=%d pixels\n", __func__, exposure_time);
/* max_shift */
max_shift=sanei_genesys_compute_max_shift(dev,channels,yres,0);
@ -1785,7 +1785,7 @@ gl847_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n", __FUNCTION__,
"%s: failed to read home sensor: %s\n", __func__,
sane_strstatus (status));
DBGCOMPLETED;
return status;
@ -1794,7 +1794,7 @@ gl847_stop_action (Genesys_Device * dev)
/* only stop action if needed */
if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
{
DBG (DBG_info, "%s: already stopped\n", __FUNCTION__);
DBG (DBG_info, "%s: already stopped\n", __func__);
DBGCOMPLETED;
return SANE_STATUS_GOOD;
}
@ -1807,7 +1807,7 @@ gl847_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to write register 01: %s\n", __FUNCTION__,
"%s: failed to write register 01: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1825,7 +1825,7 @@ gl847_stop_action (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n", __FUNCTION__,
"%s: failed to read home sensor: %s\n", __func__,
sane_strstatus (status));
DBGCOMPLETED;
return status;
@ -1982,7 +1982,7 @@ gl847_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
/* is sensor at home? */
if (val & HOMESNR)
{
DBG (DBG_info, "%s: already at home, completed\n", __FUNCTION__);
DBG (DBG_info, "%s: already at home, completed\n", __func__);
dev->scanhead_position_in_steps = 0;
DBGCOMPLETED;
return SANE_STATUS_GOOD;
@ -2279,7 +2279,7 @@ gl847_feed (Genesys_Device * dev, unsigned int steps)
uint8_t val;
DBGSTART;
DBG (DBG_io, "%s: steps=%d\n", __FUNCTION__, steps);
DBG (DBG_io, "%s: steps=%d\n", __func__, steps);
/* prepare local registers */
memcpy (local_reg, dev->reg, GENESYS_GL847_MAX_REGS * sizeof (Genesys_Register_Set));
@ -2328,7 +2328,7 @@ gl847_feed (Genesys_Device * dev, unsigned int steps)
status = gl847_start_action (dev);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to start motor: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus (status));
gl847_stop_action (dev);
/* restore original registers */
@ -2370,8 +2370,8 @@ gl847_init_regs_for_shading (Genesys_Device * dev)
if(dev->calib_resolution==4800)
dev->calib_lines *= 2;
dev->calib_pixels = (dev->sensor.sensor_pixels*dev->calib_resolution)/dev->sensor.optical_res;
DBG (DBG_io, "%s: calib_lines = %d\n", __FUNCTION__, (int)dev->calib_lines);
DBG (DBG_io, "%s: calib_pixels = %d\n", __FUNCTION__, (int)dev->calib_pixels);
DBG (DBG_io, "%s: calib_lines = %d\n", __func__, (int)dev->calib_lines);
DBG (DBG_io, "%s: calib_pixels = %d\n", __func__, (int)dev->calib_pixels);
/* this is aworkaround insufficent distance for slope
* motor acceleration TODO special motor slope for shading */
@ -2399,14 +2399,14 @@ gl847_init_regs_for_shading (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to setup scan: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus (status));
return status;
}
status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL847_MAX_REGS);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus (status));
return status;
}
@ -2474,7 +2474,7 @@ gl847_init_regs_for_scan (Genesys_Device * dev)
move += dev->settings.tl_y;
move = (move * move_dpi) / MM_PER_INCH;
move -= dev->scanhead_position_in_steps;
DBG (DBG_info, "%s: move=%f steps\n",__FUNCTION__, move);
DBG (DBG_info, "%s: move=%f steps\n",__func__, move);
/* fast move to scan area */
/* we don't move fast the whole distance since it would involve
@ -2486,14 +2486,14 @@ gl847_init_regs_for_scan (Genesys_Device * dev)
status = gl847_feed (dev, move-500);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to move to scan area\n",__FUNCTION__);
DBG (DBG_error, "%s: failed to move to scan area\n",__func__);
return status;
}
move=500;
}
DBG (DBG_info, "gl124_init_regs_for_scan: move=%f steps\n", move);
DBG (DBG_info, "%s: move=%f steps\n", __FUNCTION__, move);
DBG (DBG_info, "%s: move=%f steps\n", __func__, move);
/* start */
start = SANE_UNFIX (dev->model->x_offset);
@ -2548,7 +2548,7 @@ gl847_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
uint8_t val,*buffer,*ptr,*src;
DBGSTART;
DBG( DBG_io2, "%s: writing %d bytes of shading data\n",__FUNCTION__,size);
DBG( DBG_io2, "%s: writing %d bytes of shading data\n",__func__,size);
/* shading data is plit in 3 (up to 5 with IR) areas
write(0x10014000,0x00000dd8)
@ -2565,10 +2565,10 @@ gl847_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
/* compute deletion factor */
sanei_genesys_get_double(dev->reg,REG_DPISET,&tempo);
dpiset=tempo;
DBG( DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d, PIXELS=%d, DPISET=%d\n",__FUNCTION__,strpixel,endpixel,endpixel-strpixel,dpiset);
DBG( DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d, PIXELS=%d, DPISET=%d\n",__func__,strpixel,endpixel,endpixel-strpixel,dpiset);
dpihw=sanei_genesys_compute_dpihw(dev,dpiset);
factor=dpihw/dpiset;
DBG( DBG_io2, "%s: factor=%d\n",__FUNCTION__,factor);
DBG( DBG_io2, "%s: factor=%d\n",__func__,factor);
if(DBG_LEVEL>=DBG_data)
{
@ -2593,7 +2593,7 @@ gl847_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
/* allocate temporary buffer */
buffer=(uint8_t *)malloc(pixels);
memset(buffer,0,pixels);
DBG( DBG_io2, "%s: using chunks of %d (0x%04x) bytes\n",__FUNCTION__,pixels,pixels);
DBG( DBG_io2, "%s: using chunks of %d (0x%04x) bytes\n",__func__,pixels,pixels);
/* base addr of data has been written in reg D0-D4 in 4K word, so AHB address
* is 8192*reg value */
@ -2670,7 +2670,7 @@ gl847_led_calibration (Genesys_Device * dev)
{
RIE(gl847_feed (dev, move));
}
DBG (DBG_io, "%s: move=%f steps\n", __FUNCTION__, move);
DBG (DBG_io, "%s: move=%f steps\n", __func__, move);
/* offset calibration is always done in color mode */
channels = 3;
@ -2700,7 +2700,7 @@ gl847_led_calibration (Genesys_Device * dev)
SCAN_FLAG_IGNORE_LINE_DISTANCE);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to setup scan: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus (status));
return status;
}
@ -2837,7 +2837,7 @@ gl847_init_gpio (Genesys_Device * dev)
}
if(gpios[idx].sensor_id==0)
{
DBG (DBG_error, "%s: failed to find GPIO profile for sensor_id=%d\n", __FUNCTION__, dev->model->ccd_type);
DBG (DBG_error, "%s: failed to find GPIO profile for sensor_id=%d\n", __func__, dev->model->ccd_type);
return SANE_STATUS_INVAL;
}
@ -2972,7 +2972,7 @@ gl847_boot (Genesys_Device * dev, SANE_Bool cold)
if (val & REG40_CHKVER)
{
RIE (sanei_genesys_read_register (dev, 0x00, &val));
DBG (DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __FUNCTION__, val);
DBG (DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
}
/* Set default values for registers */

56
backend/genesys_low.c
Wyświetl plik

@ -737,7 +737,7 @@ sanei_genesys_read_valid_words (Genesys_Device * dev, unsigned int *words)
*words += ((value & 0x0f) * 256 * 256);
}
DBG (DBG_proc, "%s: %d words\n", __FUNCTION__, *words);
DBG (DBG_proc, "%s: %d words\n", __func__, *words);
DBGCOMPLETED;
return SANE_STATUS_GOOD;
}
@ -1098,7 +1098,7 @@ sanei_genesys_bulk_write_register (Genesys_Device * dev,
}
}
DBG (DBG_io, "%s: wrote %lu registers\n", __FUNCTION__, (u_long) elems);
DBG (DBG_io, "%s: wrote %lu registers\n", __func__, (u_long) elems);
return status;
}
@ -1136,8 +1136,8 @@ sanei_genesys_write_ahb (SANE_Int dn, int usb_mode, uint32_t addr, uint32_t size
{
sprintf (msg+strlen(msg), " 0x%02x", outdata[i]);
}
DBG (DBG_io, "%s: write(0x%08x,0x%08x)\n", __FUNCTION__, addr,size);
DBG (DBG_io, "%s: %s\n", __FUNCTION__, msg);
DBG (DBG_io, "%s: write(0x%08x,0x%08x)\n", __func__, addr,size);
DBG (DBG_io, "%s: %s\n", __func__, msg);
}
/* no effective write if fake USB */
@ -1315,7 +1315,7 @@ sanei_genesys_send_gamma_table (Genesys_Device * dev)
{
free (gamma);
DBG (DBG_error,
"%s: write to AHB failed writing table %d (%s)\n", __FUNCTION__,
"%s: write to AHB failed writing table %d (%s)\n", __func__,
i, sane_strstatus (status));
}
}
@ -1352,12 +1352,12 @@ sanei_genesys_asic_init (Genesys_Device * dev, int max_regs)
status = sanei_usb_control_msg (dev->dn, REQUEST_TYPE_IN, REQUEST_REGISTER, VALUE_GET_REGISTER, 0x00, 1, &val);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: request register failed %s\n", __FUNCTION__,
DBG (DBG_error, "%s: request register failed %s\n", __func__,
sane_strstatus (status));
return status;
}
DBG (DBG_io2, "%s: value=0x%02x\n", __FUNCTION__, val);
DBG (DBG_info, "%s: device is %s\n", __FUNCTION__, (val & 0x08) ? "USB 1.0" : "USB2.0");
DBG (DBG_io2, "%s: value=0x%02x\n", __func__, val);
DBG (DBG_info, "%s: device is %s\n", __func__, (val & 0x08) ? "USB 1.0" : "USB2.0");
if (val & 0x08)
{
dev->usb_mode = 1;
@ -1377,7 +1377,7 @@ sanei_genesys_asic_init (Genesys_Device * dev, int max_regs)
if (dev->sensor.gamma_table[i] == NULL)
{
DBG (DBG_error, "%s: could not allocate memory for gamma table %d\n",
__FUNCTION__, i);
__func__, i);
return SANE_STATUS_NO_MEM;
}
sanei_genesys_create_gamma_table (dev->sensor.gamma_table[i],
@ -1397,13 +1397,13 @@ sanei_genesys_asic_init (Genesys_Device * dev, int max_regs)
{
cold = SANE_FALSE;
}
DBG (DBG_info, "%s: device is %s\n", __FUNCTION__, cold ? "cold" : "warm");
DBG (DBG_info, "%s: device is %s\n", __func__, cold ? "cold" : "warm");
/* don't do anything if backend is initialized and hardware hasn't been
* replug */
if (dev->already_initialized && !cold)
{
DBG (DBG_info, "%s: already initialized, nothing to do\n", __FUNCTION__);
DBG (DBG_info, "%s: already initialized, nothing to do\n", __func__);
return SANE_STATUS_GOOD;
}
@ -1459,7 +1459,7 @@ sanei_genesys_wait_for_home (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n", __FUNCTION__,
"%s: failed to read home sensor: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1468,7 +1468,7 @@ sanei_genesys_wait_for_home (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n", __FUNCTION__,
"%s: failed to read home sensor: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1477,7 +1477,7 @@ sanei_genesys_wait_for_home (Genesys_Device * dev)
if(val & HOMESNR)
{
DBG (DBG_info,
"%s: already at home\n", __FUNCTION__);
"%s: already at home\n", __func__);
return status;
}
@ -1491,7 +1491,7 @@ sanei_genesys_wait_for_home (Genesys_Device * dev)
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n", __FUNCTION__,
"%s: failed to read home sensor: %s\n", __func__,
sane_strstatus (status));
return status;
}
@ -1506,7 +1506,7 @@ sanei_genesys_wait_for_home (Genesys_Device * dev)
/* if after the timeout, head is still not parked, error out */
if(loop >= max && !(val & HOMESNR) && status == SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to reach park position %ds\n", __FUNCTION__, max/10);
DBG (DBG_error, "%s: failed to reach park position %ds\n", __func__, max/10);
return SANE_STATUS_IO_ERROR;
}
@ -1597,7 +1597,7 @@ Motor_Profile *sanei_genesys_get_motor_profile(Motor_Profile *motors, int motor_
/* default fallback */
if(idx<0)
{
DBG (DBG_warn,"%s: using default motor profile\n",__FUNCTION__);
DBG (DBG_warn,"%s: using default motor profile\n",__func__);
idx=0;
}
@ -1654,7 +1654,7 @@ Motor_Profile *profile;
/* required speed */
target=((exposure * dpi) / base_dpi)>>step_type;
DBG (DBG_io2, "%s: exposure=%d, dpi=%d, target=%d\n", __FUNCTION__, exposure, dpi, target);
DBG (DBG_io2, "%s: exposure=%d, dpi=%d, target=%d\n", __func__, exposure, dpi, target);
/* fill result with target speed */
for(i=0;i<SLOPE_TABLE_SIZE;i++)
@ -1689,11 +1689,11 @@ Motor_Profile *profile;
/* range checking */
if(profile->table[i]==0 && DBG_LEVEL >= DBG_warn && current>target)
{
DBG (DBG_warn,"%s: short slope table, failed to reach %d. target too low ?\n",__FUNCTION__,target);
DBG (DBG_warn,"%s: short slope table, failed to reach %d. target too low ?\n",__func__,target);
}
if(i<3 && DBG_LEVEL >= DBG_warn)
{
DBG (DBG_warn,"%s: short slope table, failed to reach %d. target too high ?\n",__FUNCTION__,target);
DBG (DBG_warn,"%s: short slope table, failed to reach %d. target too high ?\n",__func__,target);
}
/* align on factor */
@ -1791,20 +1791,20 @@ sanei_genesys_is_compatible_calibration (Genesys_Device * dev,
if(dev->model->cmd_set->calculate_current_setup==NULL)
{
DBG (DBG_proc, "%s: no calculate_setup, non compatible cache\n", __FUNCTION__);
DBG (DBG_proc, "%s: no calculate_setup, non compatible cache\n", __func__);
return SANE_STATUS_UNSUPPORTED;
}
status = dev->model->cmd_set->calculate_current_setup (dev);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to calculate current setup: %s\n", __FUNCTION__,
DBG (DBG_error, "%s: failed to calculate current setup: %s\n", __func__,
sane_strstatus (status));
return status;
}
dev->current_setup.scan_method = dev->settings.scan_method;
DBG (DBG_proc, "%s: checking\n", __FUNCTION__);
DBG (DBG_proc, "%s: checking\n", __func__);
/* a calibration cache is compatible if color mode and x dpi match the user
* requested scan. In the case of CIS scanners, dpi isn't a criteria */
@ -1822,22 +1822,22 @@ sanei_genesys_is_compatible_calibration (Genesys_Device * dev,
resolution=sanei_genesys_compute_dpihw(dev,dev->settings.xres);
compatible = (resolution == ((int) sanei_genesys_compute_dpihw(dev,cache->used_setup.xres)));
}
DBG (DBG_io, "%s: after resolution check current compatible=%d\n", __FUNCTION__, compatible);
DBG (DBG_io, "%s: after resolution check current compatible=%d\n", __func__, compatible);
if (dev->current_setup.half_ccd != cache->used_setup.half_ccd)
{
DBG (DBG_io, "%s: half_ccd=%d, used=%d\n", __FUNCTION__,
DBG (DBG_io, "%s: half_ccd=%d, used=%d\n", __func__,
dev->current_setup.half_ccd, cache->used_setup.half_ccd);
compatible = 0;
}
if (dev->current_setup.scan_method != cache->used_setup.scan_method)
{
DBG (DBG_io, "%s: current method=%d, used=%d\n", __FUNCTION__,
DBG (DBG_io, "%s: current method=%d, used=%d\n", __func__,
dev->current_setup.scan_method, cache->used_setup.scan_method);
compatible = 0;
}
if (!compatible)
{
DBG (DBG_proc, "%s: completed, non compatible cache\n", __FUNCTION__);
DBG (DBG_proc, "%s: completed, non compatible cache\n", __func__);
return SANE_STATUS_UNSUPPORTED;
}
@ -1851,7 +1851,7 @@ sanei_genesys_is_compatible_calibration (Genesys_Device * dev,
&& (dev->model->is_sheetfed == SANE_FALSE)
&& (dev->settings.scan_method == SCAN_METHOD_FLATBED))
{
DBG (DBG_proc, "%s: expired entry, non compatible cache\n", __FUNCTION__);
DBG (DBG_proc, "%s: expired entry, non compatible cache\n", __func__);
return SANE_STATUS_UNSUPPORTED;
}
}

8
backend/genesys_low.h
Wyświetl plik

@ -104,7 +104,7 @@
do { status = function; \
if (status != SANE_STATUS_GOOD) \
{ \
DBG(DBG_error, "%s: %s\n", __FUNCTION__, sane_strstatus (status)); \
DBG(DBG_error, "%s: %s\n", __func__, sane_strstatus (status)); \
return status; \
} \
} while (SANE_FALSE)
@ -114,7 +114,7 @@
if (status != SANE_STATUS_GOOD) \
{ \
free(mem); \
DBG(DBG_error, "%s: %s\n", __FUNCTION__, sane_strstatus (status)); \
DBG(DBG_error, "%s: %s\n", __func__, sane_strstatus (status)); \
return status; \
} \
} while (SANE_FALSE)
@ -129,8 +129,8 @@
} \
} while (SANE_FALSE)
#define DBGSTART DBG (DBG_proc, "%s start\n", __FUNCTION__);
#define DBGCOMPLETED DBG (DBG_proc, "%s completed\n", __FUNCTION__);
#define DBGSTART DBG (DBG_proc, "%s start\n", __func__);
#define DBGCOMPLETED DBG (DBG_proc, "%s completed\n", __func__);
#define FREE_IFNOT_NULL(x) if(x!=NULL) { free(x); x=NULL;}

2
backend/gt68xx_low.h
Wyświetl plik

@ -80,7 +80,7 @@
status = function; \
if (status != SANE_STATUS_GOOD) \
{ \
DBG (7, "%s: %s: %s\n", __FUNCTION__, STRINGIFY(function), \
DBG (7, "%s: %s: %s\n", __func__, STRINGIFY(function), \
sane_strstatus (status)); \
return status; \
} \

54
backend/hp5590.c
Wyświetl plik

@ -171,7 +171,7 @@ calc_image_params (struct hp5590_scanner *scanner,
unsigned int _image_size;
float var;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
if (!scanner)
return SANE_STATUS_INVAL;
@ -199,7 +199,7 @@ calc_image_params (struct hp5590_scanner *scanner,
DBG (DBG_verbose, "%s: pixel_bits: %u, pixels_per_line: %u, "
"bytes_per_line: %u, lines: %u, image_size: %u\n",
__FUNCTION__,
__func__,
_pixel_bits, _pixels_per_line, _bytes_per_line, _lines, _image_size);
if (pixel_bits)
@ -232,10 +232,10 @@ attach_usb_device (SANE_String_Const devname,
SANE_Status ret;
const struct hp5590_model *hp5590_model;
DBG (DBG_proc, "%s: Opening USB device\n", __FUNCTION__);
DBG (DBG_proc, "%s: Opening USB device\n", __func__);
if (sanei_usb_open (devname, &dn) != SANE_STATUS_GOOD)
return SANE_STATUS_IO_ERROR;
DBG (DBG_proc, "%s: USB device opened\n", __FUNCTION__);
DBG (DBG_proc, "%s: USB device opened\n", __func__);
ret = hp5590_model_def (hp_scanner_type, &hp5590_model);
if (ret != SANE_STATUS_GOOD)
@ -246,19 +246,19 @@ attach_usb_device (SANE_String_Const devname,
return SANE_STATUS_IO_ERROR;
DBG (1, "%s: found HP%s scanner at '%s'\n",
__FUNCTION__, info->model, devname);
__func__, info->model, devname);
DBG (DBG_verbose, "%s: Reading max scan count\n", __FUNCTION__);
DBG (DBG_verbose, "%s: Reading max scan count\n", __func__);
if (hp5590_read_max_scan_count (dn, hp5590_model->proto_flags,
&max_count) != 0)
return SANE_STATUS_IO_ERROR;
DBG (DBG_verbose, "%s: Max Scanning count %u\n", __FUNCTION__, max_count);
DBG (DBG_verbose, "%s: Max Scanning count %u\n", __func__, max_count);
DBG (DBG_verbose, "%s: Reading scan count\n", __FUNCTION__);
DBG (DBG_verbose, "%s: Reading scan count\n", __func__);
if (hp5590_read_scan_count (dn, hp5590_model->proto_flags,
&count) != 0)
return SANE_STATUS_IO_ERROR;
DBG (DBG_verbose, "%s: Scanning count %u\n", __FUNCTION__, count);
DBG (DBG_verbose, "%s: Scanning count %u\n", __func__, count);
ret = hp5590_read_part_number (dn, hp5590_model->proto_flags);
if (ret != SANE_STATUS_GOOD)
@ -384,7 +384,7 @@ void sane_exit (void)
{
struct hp5590_scanner *ptr, *pnext;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
for (ptr = scanners_list; ptr; ptr = pnext)
{
@ -402,7 +402,7 @@ sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
struct hp5590_scanner *ptr;
unsigned int found, i;
DBG (DBG_proc, "%s, local only: %u\n", __FUNCTION__, local_only);
DBG (DBG_proc, "%s, local only: %u\n", __func__, local_only);
if (!device_list)
return SANE_STATUS_INVAL;
@ -434,7 +434,7 @@ sane_open (SANE_String_Const devicename, SANE_Handle * handle)
SANE_String_Const *sources_list;
unsigned int source_idx;
DBG (DBG_proc, "%s: device name: %s\n", __FUNCTION__, devicename);
DBG (DBG_proc, "%s: device name: %s\n", __func__, devicename);
if (!handle)
return SANE_STATUS_INVAL;
@ -626,7 +626,7 @@ sane_close (SANE_Handle handle)
{
struct hp5590_scanner *scanner = handle;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
sanei_usb_close (scanner->dn);
scanner->dn = -1;
@ -638,7 +638,7 @@ sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
{
struct hp5590_scanner *scanner = handle;
DBG (DBG_proc, "%s, option: %u\n", __FUNCTION__, option);
DBG (DBG_proc, "%s, option: %u\n", __func__, option);
if (option >= HP5590_OPT_LAST)
return NULL;
@ -667,7 +667,7 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
{
if (option == HP5590_OPT_NUM)
{
DBG(3, "%s: get total number of options - %u\n", __FUNCTION__, HP5590_OPT_LAST);
DBG(3, "%s: get total number of options - %u\n", __func__, HP5590_OPT_LAST);
*((SANE_Int *) value) = HP5590_OPT_LAST;
return SANE_STATUS_GOOD;
}
@ -675,7 +675,7 @@ sane_control_option (SANE_Handle handle, SANE_Int option,
if (!scanner->opts)
return SANE_STATUS_INVAL;
DBG (DBG_proc, "%s: get option '%s' value\n", __FUNCTION__, scanner->opts[option].name);
DBG (DBG_proc, "%s: get option '%s' value\n", __func__, scanner->opts[option].name);
if (option == HP5590_OPT_BR_X)
{
@ -926,7 +926,7 @@ SANE_Status sane_get_parameters (SANE_Handle handle,
SANE_Status ret;
unsigned int pixel_bits;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
if (!params)
return SANE_STATUS_INVAL;
@ -964,7 +964,7 @@ SANE_Status sane_get_parameters (SANE_Handle handle,
params->format = SANE_FRAME_RGB;
break;
default:
DBG(0, "%s: Unknown depth\n", __FUNCTION__);
DBG(0, "%s: Unknown depth\n", __func__);
return SANE_STATUS_INVAL;
}
@ -986,7 +986,7 @@ sane_start (SANE_Handle handle)
SANE_Status ret;
unsigned int bytes_per_line;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
if (!scanner)
return SANE_STATUS_INVAL;
@ -996,11 +996,11 @@ sane_start (SANE_Handle handle)
|| scanner->source == SOURCE_ADF_DUPLEX))
{
DBG (DBG_verbose, "%s: Scanner is scanning, check if more data is available\n",
__FUNCTION__);
__func__);
ret = hp5590_is_data_available (scanner->dn, scanner->proto_flags);
if (ret == SANE_STATUS_GOOD)
{
DBG (DBG_verbose, "%s: More data is available\n", __FUNCTION__);
DBG (DBG_verbose, "%s: More data is available\n", __func__);
scanner->transferred_image_size = scanner->image_size;
return SANE_STATUS_GOOD;
}
@ -1150,7 +1150,7 @@ convert_lineart (struct hp5590_scanner *scanner, SANE_Byte *data, SANE_Int size)
{
SANE_Int i;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_assert (scanner != NULL);
hp5590_assert (data != NULL);
@ -1185,7 +1185,7 @@ convert_to_rgb (struct hp5590_scanner *scanner, SANE_Byte *data, SANE_Int size)
|| scanner->depth == DEPTH_GRAY)
return SANE_STATUS_GOOD;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
#ifndef HAS_WORKING_COLOR_48
if (scanner->depth == DEPTH_COLOR_48)
@ -1266,7 +1266,7 @@ sane_read (SANE_Handle handle, SANE_Byte * data,
SANE_Status ret;
DBG (DBG_proc, "%s, length %u, left %u\n",
__FUNCTION__,
__func__,
max_length,
scanner->transferred_image_size);
@ -1353,7 +1353,7 @@ sane_cancel (SANE_Handle handle)
struct hp5590_scanner *scanner = handle;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
scanner->scanning = SANE_FALSE;
@ -1373,7 +1373,7 @@ SANE_Status
sane_set_io_mode (SANE_Handle __sane_unused__ handle,
SANE_Bool __sane_unused__ non_blocking)
{
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
return SANE_STATUS_UNSUPPORTED;
}
@ -1383,7 +1383,7 @@ SANE_Status
sane_get_select_fd (SANE_Handle __sane_unused__ handle,
SANE_Int __sane_unused__ * fd)
{
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
return SANE_STATUS_UNSUPPORTED;
}

82
backend/hp5590_cmds.c
Wyświetl plik

@ -483,7 +483,7 @@ hp5590_init_scanner (SANE_Int dn,
* 09 60 4F B0 6D E0 00 00 00 00 00 00 00 00 00 64 ..O.m..........d
* 03 E8 ..
*/
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (init_resp) == 50);
@ -512,7 +512,7 @@ hp5590_init_scanner (SANE_Int dn,
{
DBG (DBG_err, "%s: Vendor id mismatch for scanner HP%s - "
"required '%s', got '%s'\n",
__FUNCTION__,
__func__,
hp5590_models[i].model,
hp5590_models[i].vendor_id, id_buf);
return SANE_STATUS_INVAL;
@ -593,10 +593,10 @@ hp5590_init_scanner (SANE_Int dn,
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: scanner reports non-zero status: %s\n",
__FUNCTION__, sane_strstatus (ret));
__func__, sane_strstatus (ret));
return ret;
}
DBG (DBG_cmds, "%s: scanner status OK\n", __FUNCTION__);
DBG (DBG_cmds, "%s: scanner status OK\n", __func__);
return SANE_STATUS_GOOD;
}
@ -614,7 +614,7 @@ hp5590_read_eeprom (SANE_Int dn,
hp5590_cmds_assert (data != NULL);
hp5590_cmds_assert (sizeof (eeprom_addr) == 1);
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
DBG (DBG_proc, "Reading EEPROM: addr %04x, size %u\n", addr, size);
ret = hp5590_cmd (dn,
@ -649,7 +649,7 @@ hp5590_write_eeprom (SANE_Int dn,
hp5590_cmds_assert (data != NULL);
hp5590_cmds_assert (sizeof (eeprom_addr) == 1);
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
DBG (DBG_proc, "Writing EEPROM: addr %04x, size: %u\n", addr, size);
ret = hp5590_cmd (dn,
@ -683,7 +683,7 @@ hp5590_read_scan_count (SANE_Int dn,
hp5590_cmds_assert (count != NULL);
hp5590_cmds_assert (sizeof (scan_count) == 4);
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
DBG (DBG_proc, "Reading scan count\n");
ret = hp5590_read_eeprom (dn,
@ -713,7 +713,7 @@ hp5590_inc_scan_count (SANE_Int dn,
unsigned int new_count;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (scan_count) == 4);
ret = hp5590_read_scan_count (dn, proto_flags, &count);
@ -756,7 +756,7 @@ hp5590_read_max_scan_count (SANE_Int dn,
hp5590_cmds_assert (max_count != NULL);
hp5590_cmds_assert (sizeof (max_scan_count) == 3);
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
DBG (DBG_proc, "Reading max scan count\n");
ret = hp5590_read_eeprom (dn,
@ -811,7 +811,7 @@ hp5590_read_eeprom_all_cmd (SANE_Int dn,
uint8_t eeprom[255];
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
ret = hp5590_read_eeprom (dn,
proto_flags,
@ -835,7 +835,7 @@ hp5590_read_part_number (SANE_Int dn,
unsigned char part_number[PART_NUMBER_LEN + 1];
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
memset (part_number, 0, sizeof (part_number));
ret = hp5590_read_eeprom (dn,
@ -859,7 +859,7 @@ hp5590_is_data_available (SANE_Int dn,
SANE_Status ret;
SANE_Bool data_available;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (data_status) == 1);
data_available = SANE_FALSE;
@ -873,13 +873,13 @@ hp5590_is_data_available (SANE_Int dn,
if (ret != SANE_STATUS_GOOD)
return ret;
DBG (DBG_cmds, "%s: Data status: %02x\n", __FUNCTION__, data_status);
DBG (DBG_cmds, "%s: Data status: %02x\n", __func__, data_status);
if (data_status == 0x40)
data_available = SANE_TRUE;
DBG (DBG_cmds, "%s: Data is %s\n",
__FUNCTION__,
__func__,
data_available == SANE_TRUE ? "available" : "not available");
return data_available == SANE_TRUE ? SANE_STATUS_GOOD : SANE_STATUS_NO_DOCS;
@ -893,7 +893,7 @@ hp5590_stop_scan (SANE_Int dn,
uint8_t reg_011b = 0x40;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (reg_011b) == 1);
@ -920,7 +920,7 @@ hp5590_turnon_lamp (SANE_Int dn,
struct lamp_state lamp_state;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (lamp_state) == 4);
@ -930,7 +930,7 @@ hp5590_turnon_lamp (SANE_Int dn,
lamp_state.unk1 = 0x02;
lamp_state.flag = 0x01;
lamp_state.turnoff_time = htons (0x0a0a);
DBG (DBG_cmds, "%s: turning lamp on\n", __FUNCTION__);
DBG (DBG_cmds, "%s: turning lamp on\n", __func__);
}
if (state == LAMP_STATE_TURNOFF)
@ -939,7 +939,7 @@ hp5590_turnon_lamp (SANE_Int dn,
lamp_state.unk1 = 0x02;
lamp_state.flag = 0x02;
lamp_state.turnoff_time = htons (0x0a0a);
DBG (DBG_cmds, "%s: turning lamp off\n", __FUNCTION__);
DBG (DBG_cmds, "%s: turning lamp off\n", __func__);
}
if (state == LAMP_STATE_SET_TURNOFF_TIME)
@ -948,7 +948,7 @@ hp5590_turnon_lamp (SANE_Int dn,
lamp_state.unk1 = 0x02;
lamp_state.flag = 0x03;
lamp_state.turnoff_time = htons (0x0336);
DBG (DBG_cmds, "%s: setting turnoff time\n", __FUNCTION__);
DBG (DBG_cmds, "%s: setting turnoff time\n", __func__);
}
if (state == LAMP_STATE_SET_TURNOFF_TIME_LONG)
@ -957,7 +957,7 @@ hp5590_turnon_lamp (SANE_Int dn,
lamp_state.unk1 = 0x02;
lamp_state.flag = 0x03;
lamp_state.turnoff_time = htons (0x0f36);
DBG (DBG_cmds, "%s: setting long turnoff time\n", __FUNCTION__);
DBG (DBG_cmds, "%s: setting long turnoff time\n", __func__);
}
ret = hp5590_cmd (dn,
@ -987,7 +987,7 @@ hp5590_power_status (SANE_Int dn,
struct power_resp power_resp;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (power_resp) == 3);
@ -1023,7 +1023,7 @@ hp5590_read_error_code (SANE_Int dn,
struct reg_03 reg_03;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (reg_03) == 3);
hp5590_cmds_assert (adf_flags != NULL);
@ -1040,9 +1040,9 @@ hp5590_read_error_code (SANE_Int dn,
if (ret != SANE_STATUS_GOOD)
return ret;
DBG (DBG_cmds, "%s: adf_flags: %04x\n", __FUNCTION__, reg_03.adf_flags);
DBG (DBG_cmds, "%s: unk1 : %04x\n", __FUNCTION__, reg_03.unk1);
DBG (DBG_cmds, "%s: unk2 : %04x\n", __FUNCTION__, reg_03.unk2);
DBG (DBG_cmds, "%s: adf_flags: %04x\n", __func__, reg_03.adf_flags);
DBG (DBG_cmds, "%s: unk1 : %04x\n", __func__, reg_03.unk1);
DBG (DBG_cmds, "%s: unk2 : %04x\n", __func__, reg_03.unk2);
*adf_flags = reg_03.adf_flags;
@ -1056,7 +1056,7 @@ hp5590_reset_scan_head (SANE_Int dn,
{
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
ret = hp5590_turnon_lamp (dn, proto_flags, LAMP_STATE_TURNOFF);
if (ret != SANE_STATUS_GOOD)
@ -1082,7 +1082,7 @@ hp5590_select_source_and_wakeup (SANE_Int dn,
SANE_Status ret;
unsigned int adf_flags;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (reg_d6) == 1);
@ -1161,7 +1161,7 @@ hp5590_lock_unlock_scanner (SANE_Int dn,
unsigned int adf_flags;
unsigned int waiting;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (reg_00) == 1);
for (waiting = 0; waiting < WAKEUP_TIMEOUT; waiting++, sleep (1))
@ -1206,7 +1206,7 @@ hp5590_set_base_dpi (SANE_Int dn,
uint16_t _base_dpi;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (scanner_info != NULL);
hp5590_cmds_assert (base_dpi != 0);
@ -1246,7 +1246,7 @@ hp5590_set_color_map (SANE_Int dn,
struct color_map color_map;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (color_map) == 18);
hp5590_cmds_assert (base_dpi != 0);
@ -1301,7 +1301,7 @@ static SANE_Status
calc_base_dpi (unsigned int dpi, unsigned int *base_dpi)
{
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (base_dpi != NULL);
hp5590_cmds_assert (dpi != 0);
@ -1346,7 +1346,7 @@ calc_base_dpi (unsigned int dpi, unsigned int *base_dpi)
static SANE_Status
calc_scanner_dpi (unsigned int dpi, unsigned int *scanner_dpi)
{
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (scanner_dpi != NULL);
hp5590_cmds_assert (dpi != 0);
@ -1399,7 +1399,7 @@ hp5590_calc_pixel_bits (unsigned int dpi, enum color_depths color_depth,
unsigned int scanner_dpi;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (pixel_bits != NULL);
hp5590_cmds_assert (dpi != 0);
@ -1465,7 +1465,7 @@ hp5590_set_scan_area (SANE_Int dn,
unsigned int pixels_y;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (scan_params) == 37);
hp5590_cmds_assert (dpi != 0);
@ -1628,7 +1628,7 @@ hp5590_read_image_params (SANE_Int dn,
struct image_params image_params;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (image_params) == 16);
@ -1676,7 +1676,7 @@ hp5590_set_scan_params (SANE_Int dn,
unsigned int base_dpi;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (scanner_info != NULL);
hp5590_cmds_assert (dpi != 0);
@ -1754,7 +1754,7 @@ hp5590_send_reverse_calibration_map (SANE_Int dn,
unsigned int len;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
DBG (DBG_proc, "Preparing reverse calibration map\n");
val = 0xffff;
len = reverse_map_size / 4;
@ -1805,7 +1805,7 @@ hp5590_send_forward_calibration_maps (SANE_Int dn,
unsigned int i;
uint16_t val;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
DBG (DBG_proc, "Preparing forward calibration map\n");
val = 0x0000;
for (i = 0; i < forward_map_size; i++)
@ -1852,7 +1852,7 @@ hp5590_read (SANE_Int dn,
{
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (bytes != NULL);
hp5590_cmds_assert (state != NULL);
@ -1872,7 +1872,7 @@ hp5590_start_scan (SANE_Int dn,
uint8_t reg_051b = 0x40;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (sizeof (reg_051b) == 1);
@ -1897,7 +1897,7 @@ hp5590_read_buttons (SANE_Int dn,
uint16_t button_status;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
hp5590_cmds_assert (status != NULL);
hp5590_cmds_assert (sizeof (button_status) == 2);

106
backend/hp5590_low.c
Wyświetl plik

@ -143,7 +143,7 @@ hp5590_get_ack (SANE_Int dn,
if (proto_flags & PF_NO_USB_IN_USB_ACK)
return SANE_STATUS_GOOD;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
/* Check if USB-in-USB operation was accepted */
ret = sanei_usb_control_msg (dn, USB_DIR_IN | USB_TYPE_VENDOR,
@ -152,17 +152,17 @@ hp5590_get_ack (SANE_Int dn,
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error getting acknowledge\n",
__FUNCTION__);
__func__);
return ret;
}
DBG (DBG_usb, "%s: USB-in-USB: accepted\n", __FUNCTION__);
DBG (DBG_usb, "%s: USB-in-USB: accepted\n", __func__);
/* Check if we received correct acknowledgement */
if (status != 0x01)
{
DBG (DBG_err, "%s: USB-in-USB: not accepted (status %u)\n",
__FUNCTION__, status);
__func__, status);
return SANE_STATUS_DEVICE_BUSY;
}
@ -186,7 +186,7 @@ hp5590_get_status (SANE_Int dn,
uint8_t status;
SANE_Status ret;
DBG (DBG_proc, "%s\n", __FUNCTION__);
DBG (DBG_proc, "%s\n", __func__);
ret = sanei_usb_control_msg (dn, USB_DIR_IN | USB_TYPE_VENDOR,
0x0c, 0x8e, 0x00,
@ -194,7 +194,7 @@ hp5590_get_status (SANE_Int dn,
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error getting device status\n",
__FUNCTION__);
__func__);
return ret;
}
@ -202,7 +202,7 @@ hp5590_get_status (SANE_Int dn,
if (status != 0x00)
{
DBG (DBG_err, "%s: USB-in-USB: got non-zero device status (status %u)\n",
__FUNCTION__, status);
__func__, status);
return SANE_STATUS_DEVICE_BUSY;
}
@ -244,7 +244,7 @@ hp5590_control_msg (SANE_Int dn,
unsigned int needed_response;
DBG (DBG_proc, "%s: USB-in-USB: core data: %s\n",
__FUNCTION__, core_flags & CORE_DATA ? "yes" : "no");
__func__, core_flags & CORE_DATA ? "yes" : "no");
hp5590_low_assert (bytes != NULL);
@ -259,7 +259,7 @@ hp5590_control_msg (SANE_Int dn,
ctrl.wIndex = htons (index);
ctrl.wLength = htole16 (size);
DBG (DBG_usb, "%s: USB-in-USB: sending control msg\n", __FUNCTION__);
DBG (DBG_usb, "%s: USB-in-USB: sending control msg\n", __func__);
/* Send USB-in-USB control message */
ret = sanei_usb_control_msg (dn, USB_DIR_OUT | USB_TYPE_VENDOR,
0x04, 0x8f, 0x00,
@ -267,7 +267,7 @@ hp5590_control_msg (SANE_Int dn,
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error sending control message\n",
__FUNCTION__);
__func__);
return ret;
}
@ -292,7 +292,7 @@ hp5590_control_msg (SANE_Int dn,
0x90, 0x00, next_packet_size, ptr);
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error reading data\n", __FUNCTION__);
DBG (DBG_err, "%s: USB-in-USB: error reading data\n", __func__);
return ret;
}
@ -308,7 +308,7 @@ hp5590_control_msg (SANE_Int dn,
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error confirming data reception\n",
__FUNCTION__);
__func__);
return -1;
}
@ -329,7 +329,7 @@ hp5590_control_msg (SANE_Int dn,
ctrl.wIndex = htons (index);
ctrl.wLength = htole16 (size);
DBG (DBG_usb, "%s: USB-in-USB: sending control msg\n", __FUNCTION__);
DBG (DBG_usb, "%s: USB-in-USB: sending control msg\n", __func__);
/* Send USB-in-USB control message */
ret = sanei_usb_control_msg (dn, USB_DIR_OUT | USB_TYPE_VENDOR,
0x04, 0x8f, 0x00,
@ -337,7 +337,7 @@ hp5590_control_msg (SANE_Int dn,
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error sending control message\n",
__FUNCTION__);
__func__);
return ret;
}
@ -362,7 +362,7 @@ hp5590_control_msg (SANE_Int dn,
0x8f, 0x00, next_packet_size, ptr);
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error sending data\n", __FUNCTION__);
DBG (DBG_err, "%s: USB-in-USB: error sending data\n", __func__);
return ret;
}
@ -389,13 +389,13 @@ hp5590_control_msg (SANE_Int dn,
}
/* Getting response after data transmission */
DBG (DBG_usb, "%s: USB-in-USB: getting response\n", __FUNCTION__);
DBG (DBG_usb, "%s: USB-in-USB: getting response\n", __func__);
ret = sanei_usb_control_msg (dn, USB_DIR_IN | USB_TYPE_VENDOR,
0x0c, 0x90, 0x00,
sizeof (response), &response);
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error getting response\n", __FUNCTION__);
DBG (DBG_err, "%s: USB-in-USB: error getting response\n", __func__);
return ret;
}
@ -405,14 +405,14 @@ hp5590_control_msg (SANE_Int dn,
needed_response = core_flags & CORE_BULK_OUT ? 0x24 : 0x00;
if (response == needed_response)
DBG (DBG_usb, "%s: USB-in-USB: got correct response\n",
__FUNCTION__);
__func__);
if (response != needed_response)
{
DBG (DBG_err,
"%s: USB-in-USB: invalid response received "
"(needed %04x, got %04x)\n",
__FUNCTION__, needed_response, response);
__func__, needed_response, response);
return SANE_STATUS_IO_ERROR;
}
@ -421,7 +421,7 @@ hp5590_control_msg (SANE_Int dn,
{
uint8_t bulk_flags = 0x24;
DBG (DBG_usb, "%s: USB-in-USB: sending bulk flags\n",
__FUNCTION__);
__func__);
ret = sanei_usb_control_msg (dn, USB_DIR_OUT | USB_TYPE_VENDOR,
0x0c, 0x83, 0x00,
@ -429,7 +429,7 @@ hp5590_control_msg (SANE_Int dn,
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error sending bulk flags\n",
__FUNCTION__);
__func__);
return ret;
}
@ -467,7 +467,7 @@ hp5590_verify_last_cmd (SANE_Int dn,
SANE_Status ret;
DBG (3, "%s: USB-in-USB: command verification requested\n",
__FUNCTION__);
__func__);
/* Read last command along with CORE status */
ret = hp5590_control_msg (dn,
@ -489,17 +489,17 @@ hp5590_verify_last_cmd (SANE_Int dn,
/* Verify last command */
DBG (DBG_usb, "%s: USB-in-USB: command verification %04x, "
"last command: %04x, core status: %04x\n",
__FUNCTION__, verify_cmd, last_cmd, core_status);
__func__, verify_cmd, last_cmd, core_status);
if ((cmd & 0x00ff) != last_cmd)
{
DBG (DBG_err, "%s: USB-in-USB: command verification failed: "
"expected 0x%04x, got 0x%04x\n",
__FUNCTION__, cmd, last_cmd);
__func__, cmd, last_cmd);
return SANE_STATUS_IO_ERROR;
}
DBG (DBG_usb, "%s: USB-in-USB: command verified successfully\n",
__FUNCTION__);
__func__);
/* Return value depends on CORE status */
return core_status & CORE_FLAG_NOT_READY ?
@ -534,7 +534,7 @@ hp5590_cmd (SANE_Int dn,
{
SANE_Status ret;
DBG (3, "%s: USB-in-USB: command : %04x\n", __FUNCTION__, cmd);
DBG (3, "%s: USB-in-USB: command : %04x\n", __func__, cmd);
ret = hp5590_control_msg (dn,
proto_flags,
@ -568,7 +568,7 @@ hp5590_low_init_bulk_read_state (void **state)
{
struct bulk_read_state *bulk_read_state;
DBG (3, "%s: USB-in-USB: initializing bulk read state\n", __FUNCTION__);
DBG (3, "%s: USB-in-USB: initializing bulk read state\n", __func__);
hp5590_low_assert (state != NULL);
@ -582,7 +582,7 @@ hp5590_low_init_bulk_read_state (void **state)
if (!bulk_read_state->buffer)
{
DBG (DBG_err, "%s: Memory allocation failed for %u bytes\n",
__FUNCTION__, ALLOCATE_BULK_READ_PAGES * BULK_READ_PAGE_SIZE);
__func__, ALLOCATE_BULK_READ_PAGES * BULK_READ_PAGE_SIZE);
return SANE_STATUS_NO_MEM;
}
bulk_read_state->buffer_size = ALLOCATE_BULK_READ_PAGES
@ -613,7 +613,7 @@ hp5590_low_free_bulk_read_state (void **state)
{
struct bulk_read_state *bulk_read_state;
DBG (3, "%s\n", __FUNCTION__);
DBG (3, "%s\n", __func__);
hp5590_low_assert (state != NULL);
/* Just return if NULL bulk read state was given */
@ -622,7 +622,7 @@ hp5590_low_free_bulk_read_state (void **state)
bulk_read_state = *state;
DBG (3, "%s: USB-in-USB: freeing bulk read state\n", __FUNCTION__);
DBG (3, "%s: USB-in-USB: freeing bulk read state\n", __func__);
free (bulk_read_state->buffer);
bulk_read_state->buffer = NULL;
@ -656,7 +656,7 @@ hp5590_bulk_read (SANE_Int dn,
struct bulk_read_state *bulk_read_state;
unsigned int bytes_until_buffer_end;
DBG (3, "%s\n", __FUNCTION__);
DBG (3, "%s\n", __func__);
hp5590_low_assert (state != NULL);
hp5590_low_assert (bytes != NULL);
@ -665,7 +665,7 @@ hp5590_bulk_read (SANE_Int dn,
if (bulk_read_state->initialized == 0)
{
DBG (DBG_err, "%s: USB-in-USB: bulk read state not initialized\n",
__FUNCTION__);
__func__);
return SANE_STATUS_INVAL;
}
@ -685,7 +685,7 @@ hp5590_bulk_read (SANE_Int dn,
{
DBG (DBG_usb, "%s: USB-in-USB: not enough data in buffer available "
"(available: %u, requested: %u)\n",
__FUNCTION__, bulk_read_state->bytes_available, size);
__func__, bulk_read_state->bytes_available, size);
/* IMPORTANT! 'next_pages' means 'request and receive next_pages pages in
* one bulk transfer request '. Windows driver uses 4 pages between each
@ -703,7 +703,7 @@ hp5590_bulk_read (SANE_Int dn,
*/
bulk_read_state->total_pages++;
DBG (DBG_usb, "%s: USB-in-USB: total pages done: %u\n",
__FUNCTION__, bulk_read_state->total_pages);
__func__, bulk_read_state->total_pages);
/* Send another bulk request for 'next_pages' before first
* page or next necessary one
@ -713,7 +713,7 @@ hp5590_bulk_read (SANE_Int dn,
{
/* Send bulk flags */
DBG (DBG_usb, "%s: USB-in-USB: sending USB-in-USB bulk flags\n",
__FUNCTION__);
__func__);
bulk_flags = 0x24;
ret = sanei_usb_control_msg (dn, USB_DIR_OUT | USB_TYPE_VENDOR,
0x0c, 0x83, 0x00,
@ -721,7 +721,7 @@ hp5590_bulk_read (SANE_Int dn,
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error sending bulk flags\n",
__FUNCTION__);
__func__);
return ret;
}
@ -738,7 +738,7 @@ hp5590_bulk_read (SANE_Int dn,
/* Send bulk read request */
DBG (DBG_usb, "%s: USB-in-USB: sending control msg for bulk\n",
__FUNCTION__);
__func__);
ret = sanei_usb_control_msg (dn, USB_DIR_OUT | USB_TYPE_VENDOR,
0x04, 0x82, 0x00,
sizeof (ctrl),
@ -746,7 +746,7 @@ hp5590_bulk_read (SANE_Int dn,
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error sending control msg\n",
__FUNCTION__);
__func__);
return ret;
}
@ -761,13 +761,13 @@ hp5590_bulk_read (SANE_Int dn,
if (bulk_read_state->buffer_size
- bulk_read_state->bytes_available < next_portion)
{
DBG (DBG_err, "%s: USB-in-USB: buffer too small\n", __FUNCTION__);
DBG (DBG_err, "%s: USB-in-USB: buffer too small\n", __func__);
return SANE_STATUS_NO_MEM;
}
/* Bulk read next page */
DBG (DBG_usb, "%s: USB-in-USB: bulk reading %lu bytes\n",
__FUNCTION__, (u_long) next_portion);
__func__, (u_long) next_portion);
ret = sanei_usb_read_bulk (dn,
bulk_read_state->buffer_in_ptr,
&next_portion);
@ -776,7 +776,7 @@ hp5590_bulk_read (SANE_Int dn,
if (ret == SANE_STATUS_EOF)
return ret;
DBG (DBG_err, "%s: USB-in-USB: error during bulk read: %s\n",
__FUNCTION__, sane_strstatus (ret));
__func__, sane_strstatus (ret));
return ret;
}
@ -785,7 +785,7 @@ hp5590_bulk_read (SANE_Int dn,
{
DBG (DBG_err, "%s: USB-in-USB: incomplete bulk read "
"(requested %u bytes, got %lu bytes)\n",
__FUNCTION__, BULK_READ_PAGE_SIZE, (u_long) next_portion);
__func__, BULK_READ_PAGE_SIZE, (u_long) next_portion);
return SANE_STATUS_IO_ERROR;
}
@ -798,7 +798,7 @@ hp5590_bulk_read (SANE_Int dn,
DBG (DBG_err,
"%s: USB-in-USB: attempted to access over the end of buffer "
"(in_ptr: %p, end_ptr: %p, ptr: %p, buffer size: %u\n",
__FUNCTION__, bulk_read_state->buffer_in_ptr,
__func__, bulk_read_state->buffer_in_ptr,
bulk_read_state->buffer_end_ptr, bulk_read_state->buffer,
bulk_read_state->buffer_size);
return SANE_STATUS_NO_MEM;
@ -808,7 +808,7 @@ hp5590_bulk_read (SANE_Int dn,
if (bulk_read_state->buffer_in_ptr == bulk_read_state->buffer_end_ptr)
{
DBG (DBG_usb, "%s: USB-in-USB: buffer wrapped while writing\n",
__FUNCTION__);
__func__);
bulk_read_state->buffer_in_ptr = bulk_read_state->buffer;
}
@ -819,7 +819,7 @@ hp5590_bulk_read (SANE_Int dn,
/* Transfer requested amount of data to the caller */
DBG (DBG_usb, "%s: USB-in-USB: data in bulk buffer is available "
"(requested %u bytes, available %u bytes)\n",
__FUNCTION__, size, bulk_read_state->bytes_available);
__func__, size, bulk_read_state->bytes_available);
/* Check for buffer pointer wrapping */
bytes_until_buffer_end = bulk_read_state->buffer_end_ptr
@ -827,13 +827,13 @@ hp5590_bulk_read (SANE_Int dn,
if (bytes_until_buffer_end <= size)
{
/* First buffer part */
DBG (DBG_usb, "%s: USB-in-USB: reached bulk read buffer end\n", __FUNCTION__);
DBG (DBG_usb, "%s: USB-in-USB: reached bulk read buffer end\n", __func__);
memcpy (bytes, bulk_read_state->buffer_out_ptr, bytes_until_buffer_end);
bulk_read_state->buffer_out_ptr = bulk_read_state->buffer;
/* And second part (if any) */
if (bytes_until_buffer_end < size)
{
DBG (DBG_usb, "%s: USB-in-USB: giving 2nd buffer part\n", __FUNCTION__);
DBG (DBG_usb, "%s: USB-in-USB: giving 2nd buffer part\n", __func__);
memcpy (bytes + bytes_until_buffer_end,
bulk_read_state->buffer_out_ptr,
size - bytes_until_buffer_end);
@ -848,7 +848,7 @@ hp5590_bulk_read (SANE_Int dn,
if (bulk_read_state->buffer_out_ptr == bulk_read_state->buffer_end_ptr)
{
DBG (DBG_usb, "%s: USB-in-USB: buffer wrapped while reading\n",
__FUNCTION__);
__func__);
bulk_read_state->buffer_out_ptr = bulk_read_state->buffer;
}
}
@ -886,7 +886,7 @@ hp5590_bulk_write (SANE_Int dn,
unsigned char *ptr;
size_t next_portion;
DBG (3, "%s: USB-in-USB: command: %04x, size %u\n", __FUNCTION__, cmd,
DBG (3, "%s: USB-in-USB: command: %04x, size %u\n", __func__, cmd,
size);
hp5590_low_assert (bytes != NULL);
@ -898,7 +898,7 @@ hp5590_bulk_write (SANE_Int dn,
/* Send bulk write request */
DBG (3, "%s: USB-in-USB: total %u pages (each of %u bytes)\n",
__FUNCTION__, bulk_size.size, BULK_WRITE_PAGE_SIZE);
__func__, bulk_size.size, BULK_WRITE_PAGE_SIZE);
ret = hp5590_control_msg (dn,
proto_flags,
USB_DIR_OUT,
@ -919,7 +919,7 @@ hp5590_bulk_write (SANE_Int dn,
next_portion = len;
DBG (3, "%s: USB-in-USB: next portion %lu bytes\n",
__FUNCTION__, (u_long) next_portion);
__func__, (u_long) next_portion);
/* Prepare bulk write request */
memset (&ctrl, 0, sizeof (ctrl));
@ -941,7 +941,7 @@ hp5590_bulk_write (SANE_Int dn,
/* Write bulk data */
DBG (3, "%s: USB-in-USB: bulk writing %lu bytes\n",
__FUNCTION__, (u_long) next_portion);
__func__, (u_long) next_portion);
ret = sanei_usb_write_bulk (dn, ptr, &next_portion);
if (ret != SANE_STATUS_GOOD)
{
@ -949,7 +949,7 @@ hp5590_bulk_write (SANE_Int dn,
if (ret == SANE_STATUS_EOF)
break;
DBG (DBG_err, "%s: USB-in-USB: error during bulk write: %s\n",
__FUNCTION__, sane_strstatus (ret));
__func__, sane_strstatus (ret));
return ret;
}

20
backend/snapscan-sources.c
Wyświetl plik

@ -262,13 +262,13 @@ static SANE_Status FDSource_get (Source *pself, SANE_Byte *pbuf, SANE_Int *plen)
}
/* It's an IO error */
DBG (DL_MAJOR_ERROR, "%s: read failed: %s\n",
__FUNCTION__, strerror(errno));
__func__, strerror(errno));
status = SANE_STATUS_IO_ERROR;
}
else if (bytes_read == 0)
{
/* EOF of current reading */
DBG(DL_DATA_TRACE, "%s: EOF\n",__FUNCTION__);
DBG(DL_DATA_TRACE, "%s: EOF\n",__func__);
break;
}
ps->bytes_remaining -= bytes_read;
@ -619,7 +619,7 @@ static SANE_Status Expander_init (Expander *pself,
{
DBG (DL_MAJOR_ERROR,
"%s: couldn't allocate channel buffer.\n",
__FUNCTION__);
__func__);
status = SANE_STATUS_NO_MEM;
}
else
@ -650,7 +650,7 @@ static SANE_Status create_Expander (SnapScan_Scanner *pss,
{
DBG (DL_MAJOR_ERROR,
"%s: failed to allocate Expander.\n",
__FUNCTION__);
__func__);
status = SANE_STATUS_NO_MEM;
}
else
@ -867,7 +867,7 @@ static SANE_Status Deinterlacer_init (Deinterlacer *pself,
{
DBG (DL_MAJOR_ERROR,
"%s: couldn't allocate channel buffer.\n",
__FUNCTION__);
__func__);
status = SANE_STATUS_NO_MEM;
}
else
@ -897,7 +897,7 @@ static SANE_Status create_Deinterlacer (SnapScan_Scanner *pss,
{
DBG (DL_MAJOR_ERROR,
"%s: failed to allocate Deinterlacer.\n",
__FUNCTION__);
__func__);
status = SANE_STATUS_NO_MEM;
}
else
@ -1102,7 +1102,7 @@ static SANE_Status RGBRouter_init (RGBRouter *pself,
{
DBG (DL_MAJOR_ERROR,
"%s: failed to allocate circular buffer.\n",
__FUNCTION__);
__func__);
status = SANE_STATUS_NO_MEM;
}
else
@ -1137,7 +1137,7 @@ static SANE_Status create_RGBRouter (SnapScan_Scanner *pss,
if (*pps == NULL)
{
DBG (DL_MAJOR_ERROR, "%s: failed to allocate RGBRouter.\n",
__FUNCTION__);
__func__);
status = SANE_STATUS_NO_MEM;
}
else
@ -1189,7 +1189,7 @@ static SANE_Status create_Inverter (SnapScan_Scanner *pss,
if (*pps == NULL)
{
DBG (DL_MAJOR_ERROR, "%s: failed to allocate Inverter.\n",
__FUNCTION__);
__func__);
status = SANE_STATUS_NO_MEM;
}
else
@ -1252,7 +1252,7 @@ static SANE_Status create_source_chain (SnapScan_Scanner *pss,
break;
default:
DBG (DL_MAJOR_ERROR, "%s: bad mode value %d (internal error)\n",
__FUNCTION__, mode);
__func__, mode);
status = SANE_STATUS_INVAL;
break;
}

2
backend/umax_pp.h
Wyświetl plik

@ -194,7 +194,7 @@ enum Umax_PP_Configure_Option
};
#define DEBUG() DBG(4, "%s(v%d.%d.%d-%s): line %d: debug exception\n", \
__PRETTY_FUNCTION__, SANE_CURRENT_MAJOR, V_MINOR, \
__func__, SANE_CURRENT_MAJOR, V_MINOR, \
UMAX_PP_BUILD, UMAX_PP_STATE, __LINE__)
#endif /* umax_pp_h */

14
backend/xerox_mfp-tcp.c
Wyświetl plik

@ -61,14 +61,14 @@ int tcp_dev_request (struct device *dev,
len = (size_t)sanei_tcp_write(dev->dn, cmd, cmdlen);
if (len != cmdlen) {
DBG (1, "%s: sent only %lu bytes of %lu\n",
__FUNCTION__, (u_long)len, (u_long)cmdlen);
__func__, (u_long)len, (u_long)cmdlen);
return SANE_STATUS_IO_ERROR;
}
}
/* Receive response, if expected */
if (resp && resplen) {
DBG (3, "%s: wait for %i bytes\n", __FUNCTION__, (int)*resplen);
DBG (3, "%s: wait for %i bytes\n", __func__, (int)*resplen);
while (bytes_recv < *resplen && rc > 0) {
rc = recv(dev->dn, resp+bytes_recv, *resplen-bytes_recv, 0);
@ -76,7 +76,7 @@ int tcp_dev_request (struct device *dev,
if (rc > 0) bytes_recv += rc;
else {
DBG(1, "%s: error %s, bytes requested: %i, bytes read: %i\n",
__FUNCTION__, strerror(errno), (int)*resplen, (int)bytes_recv);
__func__, strerror(errno), (int)*resplen, (int)bytes_recv);
*resplen = bytes_recv;
/*
TODO:
@ -105,7 +105,7 @@ SANE_Status tcp_dev_open (struct device *dev)
devname = dev->sane.name;
DBG (3, "%s: open %s\n", __FUNCTION__, devname);
DBG (3, "%s: open %s\n", __func__, devname);
if (strncmp (devname, "tcp", 3) != 0) return SANE_STATUS_INVAL;
devname += 3;
@ -127,7 +127,7 @@ SANE_Status tcp_dev_open (struct device *dev)
if ((sp = getservbyname(strport, "tcp"))) {
port = ntohs(sp->s_port);
} else {
DBG (1, "%s: unknown TCP service %s\n", __FUNCTION__, strport);
DBG (1, "%s: unknown TCP service %s\n", __func__, strport);
return SANE_STATUS_IO_ERROR;
}
}
@ -137,7 +137,7 @@ SANE_Status tcp_dev_open (struct device *dev)
tv.tv_sec = RECV_TIMEOUT;
tv.tv_usec = 0;
if (setsockopt (dev->dn, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof tv) < 0) {
DBG(1, "%s: setsockopts %s", __FUNCTION__, strerror(errno));
DBG(1, "%s: setsockopts %s", __func__, strerror(errno));
}
}
@ -149,7 +149,7 @@ tcp_dev_close (struct device *dev)
{
if (!dev) return;
DBG (3, "%s: closing dev %p\n", __FUNCTION__, (void *)dev);
DBG (3, "%s: closing dev %p\n", __func__, (void *)dev);
/* finish all operations */
if (dev->scanning) {

12
backend/xerox_mfp-usb.c
Wyświetl plik

@ -32,14 +32,14 @@ usb_dev_request (struct device *dev,
if (cmd && cmdlen) {
status = sanei_usb_write_bulk (dev->dn, cmd, &cmdlen);
if (status != SANE_STATUS_GOOD) {
DBG (1, "%s: sanei_usb_write_bulk: %s\n", __FUNCTION__,
DBG (1, "%s: sanei_usb_write_bulk: %s\n", __func__,
sane_strstatus (status));
return SANE_STATUS_IO_ERROR;
}
if (cmdlen != len) {
DBG (1, "%s: sanei_usb_write_bulk: wanted %lu bytes, wrote %lu bytes\n",
__FUNCTION__, (size_t)len, (size_t)cmdlen);
__func__, (size_t)len, (size_t)cmdlen);
return SANE_STATUS_IO_ERROR;
}
}
@ -47,7 +47,7 @@ usb_dev_request (struct device *dev,
if (resp && resplen) {
status = sanei_usb_read_bulk (dev->dn, resp, resplen);
if (status != SANE_STATUS_GOOD) {
DBG (1, "%s: sanei_usb_read_bulk: %s\n", __FUNCTION__,
DBG (1, "%s: sanei_usb_read_bulk: %s\n", __func__,
sane_strstatus (status));
return SANE_STATUS_IO_ERROR;
}
@ -62,10 +62,10 @@ usb_dev_open (struct device *dev)
{
SANE_Status status;
DBG (3, "%s: open %p\n", __FUNCTION__, (void *)dev);
DBG (3, "%s: open %p\n", __func__, (void *)dev);
status = sanei_usb_open (dev->sane.name, &dev->dn);
if (status != SANE_STATUS_GOOD) {
DBG (1, "%s: sanei_usb_open(%s): %s\n", __FUNCTION__,
DBG (1, "%s: sanei_usb_open(%s): %s\n", __func__,
dev->sane.name, sane_strstatus (status));
dev->dn = -1;
return status;
@ -79,7 +79,7 @@ usb_dev_close (struct device *dev)
{
if (!dev)
return;
DBG (3, "%s: closing dev %p\n", __FUNCTION__, (void *)dev);
DBG (3, "%s: closing dev %p\n", __func__, (void *)dev);
/* finish all operations */
if (dev->scanning) {

52
backend/xerox_mfp.c
Wyświetl plik

@ -134,7 +134,7 @@ static int dev_command (struct device *dev, SANE_Byte * cmd, size_t reqlen)
(u_long)reqlen);
status = dev->io->dev_request(dev, cmd, sendlen, res, &dev->reslen);
if (status != SANE_STATUS_GOOD) {
DBG (1, "%s: dev_request: %s\n", __FUNCTION__, sane_strstatus (status));
DBG (1, "%s: dev_request: %s\n", __func__, sane_strstatus (status));
dev->state = SANE_STATUS_IO_ERROR;
return 0;
}
@ -147,7 +147,7 @@ static int dev_command (struct device *dev, SANE_Byte * cmd, size_t reqlen)
/* normal command reply, some sanity checking */
if (dev->reslen < reqlen) {
DBG (1, "%s: illegal response len %lu, need %lu\n",
__FUNCTION__, (u_long)dev->reslen, (u_long)reqlen);
__func__, (u_long)dev->reslen, (u_long)reqlen);
dev->state = SANE_STATUS_IO_ERROR;
return 0;
} else {
@ -157,20 +157,20 @@ static int dev_command (struct device *dev, SANE_Byte * cmd, size_t reqlen)
dbg_dump(dev);
if (dev->res[0] != RES_CODE) {
DBG (2, "%s: illegal data header %02x\n", __FUNCTION__, dev->res[0]);
DBG (2, "%s: illegal data header %02x\n", __func__, dev->res[0]);
dev->state = SANE_STATUS_IO_ERROR;
return 0;
}
pktlen = dev->res[2] + 3;
if (dev->reslen != pktlen) {
DBG (2, "%s: illegal response len %lu, should be %lu\n",
__FUNCTION__, (u_long)pktlen, (u_long)dev->reslen);
__func__, (u_long)pktlen, (u_long)dev->reslen);
dev->state = SANE_STATUS_IO_ERROR;
return 0;
}
if (dev->reslen > reqlen)
DBG (2, "%s: too big packet len %lu, need %lu\n",
__FUNCTION__, (u_long)dev->reslen, (u_long)reqlen);
__func__, (u_long)dev->reslen, (u_long)reqlen);
}
dev->state = 0;
@ -189,7 +189,7 @@ static int dev_command (struct device *dev, SANE_Byte * cmd, size_t reqlen)
if (dev->state)
DBG (3, "%s(%s[%#x]): => %d: %s\n",
__FUNCTION__, str_cmd(cmd[2]), cmd[2],
__func__, str_cmd(cmd[2]), cmd[2],
dev->state, sane_strstatus(dev->state));
}
@ -209,7 +209,7 @@ static SANE_Status dev_stop(struct device *dev)
{
int state = dev->state;
DBG (3, "%s: %p, scanning %d, reserved %d\n", __FUNCTION__,
DBG (3, "%s: %p, scanning %d, reserved %d\n", __func__,
(void *)dev, dev->scanning, dev->reserved);
dev->scanning = 0;
@ -530,7 +530,7 @@ static void set_parameters(struct device *dev)
} else {
/* this will never happen */
DBG (1, "%s: impossible image composition %d\n",
__FUNCTION__, dev->composition);
__func__, dev->composition);
dev->para.format = SANE_FRAME_GRAY;
dev->para.depth = 8;
}
@ -658,7 +658,7 @@ dev_inquiry (struct device *dev)
return SANE_STATUS_IO_ERROR;
ptr = dev->res;
if (ptr[3] != MSG_PRODUCT_INFO) {
DBG (1, "%s: illegal INQUIRY response %02x\n", __FUNCTION__, ptr[3]);
DBG (1, "%s: illegal INQUIRY response %02x\n", __func__, ptr[3]);
return SANE_STATUS_IO_ERROR;
}
@ -681,7 +681,7 @@ dev_inquiry (struct device *dev)
*optr++ = 0;
*xptr = 0;
DBG (1, "%s: found %s/%s\n", __FUNCTION__, dev->sane.vendor, dev->sane.model);
DBG (1, "%s: found %s/%s\n", __func__, dev->sane.vendor, dev->sane.model);
dev->sane.type = strdup ("multi-function peripheral");
dev->resolutions = dev->res[0x37] << 16 |
@ -722,7 +722,7 @@ sane_get_option_descriptor (SANE_Handle h, SANE_Int opt)
{
struct device *dev = h;
DBG (3, "%s: %p, %d\n", __FUNCTION__, h, opt);
DBG (3, "%s: %p, %d\n", __func__, h, opt);
if (opt >= NUM_OPTIONS || opt < 0)
return NULL;
return &dev->opt[opt];
@ -734,7 +734,7 @@ sane_control_option (SANE_Handle h, SANE_Int opt, SANE_Action act,
{
struct device *dev = h;
DBG (3, "%s: %p, %d, <%d>, %p, %p\n", __FUNCTION__, h, opt, act, val, (void *)info);
DBG (3, "%s: %p, %d, <%d>, %p, %p\n", __func__, h, opt, act, val, (void *)info);
if (!dev || opt >= NUM_OPTIONS || opt < 0)
return SANE_STATUS_INVAL;
@ -782,7 +782,7 @@ sane_control_option (SANE_Handle h, SANE_Int opt, SANE_Action act,
}
}
DBG (4, "%s: %d, <%d> => %08x, %x\n", __FUNCTION__, opt, act,
DBG (4, "%s: %d, <%d> => %08x, %x\n", __func__, opt, act,
val? *(SANE_Word *)val : 0, info? *info : 0);
return SANE_STATUS_GOOD;
}
@ -839,7 +839,7 @@ list_one_device (SANE_String_Const devname)
SANE_Status status;
transport *tr;
DBG (4, "%s: %s\n", __FUNCTION__, devname);
DBG (4, "%s: %s\n", __func__, devname);
for (dev = devices_head; dev; dev = dev->next) {
if (strcmp (dev->sane.name, devname) == 0)
@ -864,7 +864,7 @@ list_one_device (SANE_String_Const devname)
status = dev_inquiry (dev);
tr->dev_close (dev);
if (status != SANE_STATUS_GOOD) {
DBG (1, "%s: dev_inquiry(%s): %s\n", __FUNCTION__,
DBG (1, "%s: dev_inquiry(%s): %s\n", __func__,
dev->sane.name, sane_strstatus (status));
dev_free (dev);
return status;
@ -917,7 +917,7 @@ sane_get_devices (const SANE_Device *** device_list, SANE_Bool local)
int dev_count;
int i;
DBG (3, "%s: %p, %d\n", __FUNCTION__, (const void *)device_list, local);
DBG (3, "%s: %p, %d\n", __func__, (const void *)device_list, local);
if (devlist) {
if (device_list)
@ -938,7 +938,7 @@ sane_get_devices (const SANE_Device *** device_list, SANE_Bool local)
devlist = malloc ((dev_count + 1) * sizeof (*devlist));
if (!devlist)
{
DBG (1, "%s: malloc: no memory\n", __FUNCTION__);
DBG (1, "%s: malloc: no memory\n", __func__);
return SANE_STATUS_NO_MEM;
}
@ -959,7 +959,7 @@ sane_close (SANE_Handle h)
if (!dev)
return;
DBG (3, "%s: %p (%s)\n", __FUNCTION__, (void *)dev, dev->sane.name);
DBG (3, "%s: %p (%s)\n", __func__, (void *)dev, dev->sane.name);
dev->io->dev_close(dev);
}
@ -968,7 +968,7 @@ sane_open (SANE_String_Const name, SANE_Handle * h)
{
struct device *dev;
DBG (3, "%s: '%s'\n", __FUNCTION__, name);
DBG (3, "%s: '%s'\n", __func__, name);
if (!devlist)
sane_get_devices (NULL, SANE_TRUE);
@ -998,7 +998,7 @@ sane_get_parameters (SANE_Handle h, SANE_Parameters * para)
{
struct device *dev = h;
DBG (3, "%s: %p, %p\n", __FUNCTION__, h, (void *)para);
DBG (3, "%s: %p, %p\n", __func__, h, (void *)para);
if (!para)
return SANE_STATUS_INVAL;
@ -1037,7 +1037,7 @@ static int dev_acquire(struct device *dev)
if (dev->bytes_per_line > DATASIZE) {
DBG (1, "%s: unsupported line size: %d bytes > %d\n",
__FUNCTION__, dev->bytes_per_line, DATASIZE);
__func__, dev->bytes_per_line, DATASIZE);
return ret_cancel(dev, SANE_STATUS_NO_MEM);
}
@ -1128,7 +1128,7 @@ sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * lenp)
SANE_Status status;
struct device *dev = h;
DBG (3, "%s: %p, %p, %d, %p\n", __FUNCTION__, h, buf, maxlen, (void *)lenp);
DBG (3, "%s: %p, %p, %d, %p\n", __func__, h, buf, maxlen, (void *)lenp);
if (lenp)
*lenp = 0;
@ -1250,7 +1250,7 @@ sane_start (SANE_Handle h)
{
struct device *dev = h;
DBG (3, "%s: %p\n", __FUNCTION__, h);
DBG (3, "%s: %p\n", __func__, h);
dev->cancel = 0;
dev->scanning = 0;
@ -1316,7 +1316,7 @@ SANE_Status sane_set_io_mode (SANE_Handle h, SANE_Bool non_blocking)
{
struct device *dev = h;
DBG (3, "%s: %p, %d\n", __FUNCTION__, h, non_blocking);
DBG (3, "%s: %p, %d\n", __func__, h, non_blocking);
if (non_blocking)
return SANE_STATUS_UNSUPPORTED;
@ -1327,7 +1327,7 @@ SANE_Status sane_set_io_mode (SANE_Handle h, SANE_Bool non_blocking)
SANE_Status sane_get_select_fd (SANE_Handle h, SANE_Int * fdp)
{
DBG (3, "%s: %p, %p\n", __FUNCTION__, h, (void *)fdp);
DBG (3, "%s: %p, %p\n", __func__, h, (void *)fdp);
/* supporting of this will require thread creation */
return SANE_STATUS_UNSUPPORTED;
}
@ -1336,7 +1336,7 @@ void sane_cancel (SANE_Handle h)
{
struct device *dev = h;
DBG (3, "%s: %p\n", __FUNCTION__, h);
DBG (3, "%s: %p\n", __func__, h);
dev->cancel = 1;
}

2
sanei/sanei_pa4s2.c
Wyświetl plik

@ -142,7 +142,7 @@ static int sanei_pa4s2_dbg_init_called = SANE_FALSE;
{ \
DBG_INIT(); \
DBG(6, "%s: interface called for" \
" the first time\n", __PRETTY_FUNCTION__); \
" the first time\n", __func__); \
sanei_pa4s2_dbg_init_called = SANE_TRUE; \
}

2
sanei/sanei_tcp.c
Wyświetl plik

@ -70,7 +70,7 @@ sanei_tcp_open(const char *host, int port, int *fdp)
#endif
DBG_INIT();
DBG(1, "%s: host = %s, port = %d\n", __FUNCTION__, host, port);
DBG(1, "%s: host = %s, port = %d\n", __func__, host, port);
#ifdef HAVE_WINSOCK2_H
err = WSAStartup(MAKEWORD(2, 2), &wsaData);

8
testsuite/sanei/sanei_usb_test.c
Wyświetl plik

@ -48,7 +48,7 @@ static int
test_init (int expected)
{
/* initialize USB */
printf ("%s starting ...\n", __FUNCTION__);
printf ("%s starting ...\n", __func__);
sanei_usb_init ();
if (initialized == 0)
{
@ -63,7 +63,7 @@ test_init (int expected)
}
printf ("sanei_usb initialized, use count is %d ...\n", initialized);
printf ("%s success\n\n", __FUNCTION__);
printf ("%s success\n\n", __func__);
return 1;
}
@ -75,7 +75,7 @@ test_init (int expected)
static int
test_exit (int expected)
{
printf ("%s starting ...\n", __FUNCTION__);
printf ("%s starting ...\n", __func__);
/* end of USB use test */
sanei_usb_exit ();
@ -86,7 +86,7 @@ test_exit (int expected)
return 0;
}
printf ("%s success\n\n", __FUNCTION__);
printf ("%s success\n\n", __func__);
return 1;
}