root/scsi/ss_mustek.c

DEFINITIONS

1. mustek_attach
2. mustek_set_params
3. mustek_minphys
4. mustek_trigger_scanner
5. mustek_rewind_scanner
6. mustek_read
7. mustek_get_status
8. mustek_compute_sizes

    1 /*      $OpenBSD: ss_mustek.c,v 1.14 2006/11/28 16:56:50 dlg Exp $      */
    2 /*      $NetBSD: ss_mustek.c,v 1.4 1996/05/05 19:52:57 christos Exp $   */
    4 /*
    5  * Copyright (c) 1995 Joachim Koenig-Baltes.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by Joachim Koenig-Baltes.
   18  * 4. The name of the author may not be used to endorse or promote products
   19  *    derived from this software without specific prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   31  */
   33 /*
   34  * special driver for MUSTEK flatbed scanners MFS 06000CX and MFS 12000CX
   35  * these scanners come with their own scsi card, containing an NCR53C400
   36  * SCSI controller chip. I'm in the progress of writing a driver for this
   37  * card to work under NetBSD-current. I've hooked it up to a Seagate ST01
   38  * hostadapter in the meantime, giving 350KB/sec for higher resolutions!
   39  *
   40  * I tried to connect it to my Adaptec 1542B, but with no success. It seems,
   41  * it does not like synchronous negotiation between Hostadapter and other
   42  * targets, but I could not turn this off for the 1542B.
   43  *
   44  * There is also an other reason why you would not like to connect it to your
   45  * favourite SCSI host adapter: The Mustek DOES NOT DISCONNECT. It will block
   46  * other traffic from the bus while a transfer is active.
   47  */
   49 #include <sys/types.h>
   50 #include <sys/param.h>
   51 #include <sys/kernel.h>
   52 #include <sys/systm.h>
   53 #include <sys/fcntl.h>
   54 #include <sys/errno.h>
   55 #include <sys/ioctl.h>
   56 #include <sys/malloc.h>
   57 #include <sys/buf.h>
   58 #include <sys/proc.h>
   59 #include <sys/user.h>
   60 #include <sys/device.h>
   61 #include <sys/conf.h>           /* for cdevsw */
   62 #include <sys/scanio.h>
   64 #include <scsi/scsi_all.h>
   65 #include <scsi/scsi_scanner.h>
   66 #include <scsi/scsiconf.h>
   67 #include <scsi/ssvar.h>
   68 #include <scsi/ss_mustek.h>
   70 #define MUSTEK_RETRIES 4
   72 int mustek_set_params(struct ss_softc *, struct scan_io *);
   73 int mustek_trigger_scanner(struct ss_softc *);
   74 void mustek_minphys(struct ss_softc *, struct buf *);
   75 int mustek_read(struct ss_softc *, struct buf *);
   76 int mustek_rewind_scanner(struct ss_softc *);
   78 /* only used internally */
   79 int mustek_get_status(struct ss_softc *, int, int);
   80 void mustek_compute_sizes(struct ss_softc *);
   82 /*
   83  * structure for the special handlers
   84  */
   85 struct ss_special mustek_special = {
mustek_set_params,
mustek_trigger_scanner,
NULL,
mustek_minphys,
mustek_read,
mustek_rewind_scanner,
NULL,                   /* no adf support right now */
NULL                    /* no adf support right now */
   94 };
   96 /*
   97  * mustek_attach: attach special functions to ss
   98  */
   99 void
mustek_attach(ss, sa)
  101         struct ss_softc *ss;
  102         struct scsi_attach_args *sa;
  103 {
  104 #ifdef SCSIDEBUG
  105         struct scsi_link *sc_link = sa->sa_sc_link;
  106 #endif
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_attach: start\n"));
ss->sio.scan_scanner_type = 0;
printf("\n%s: ", ss->sc_dev.dv_xname);
  113         /* first, check the model which determines resolutions */
  114         if (!bcmp(sa->sa_inqbuf->product, "MFS-06000CX", 11)) {
ss->sio.scan_scanner_type = MUSTEK_06000CX;
printf("Mustek 6000CX Flatbed 3-pass color scanner, 3 - 600 dpi\n");
  117         }
  118         if (!bcmp(sa->sa_inqbuf->product, "MFS-12000CX", 11)) {
ss->sio.scan_scanner_type = MUSTEK_12000CX;
printf("Mustek 12000CX Flatbed 3-pass color scanner, 6 - 1200 dpi\n");
  121         }
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_attach: scanner_type = %d\n",
ss->sio.scan_scanner_type));
  126         /* install special handlers */
ss->special = mustek_special;
mustek_compute_sizes(ss);
  130 }
  132 /*
  133  * check the parameters if the mustek is capable of fulfilling it
  134  * but don't send the command to the scanner in case the user wants
  135  * to change parameters by more than one call
  136  */
  137 int
mustek_set_params(ss, sio)
  139         struct ss_softc *ss;
  140         struct scan_io *sio;
  141 {
  142         int error;
  144         /*
  145          * if the scanner is triggered, then rewind it
  146          */
  147         if (ss->flags & SSF_TRIGGERED) {
error = mustek_rewind_scanner(ss);
  149                 if (error)
  150                         return (error);
  151         }
  153         /* size constraints: 8.5" horizontally and 14" vertically */
  154 #ifdef MUSTEK_INCH_SPEC
  155         /* sizes must be a multiple of 1/8" */
sio->scan_x_origin -= sio->scan_x_origin % 150;
sio->scan_y_origin -= sio->scan_y_origin % 150;
sio->scan_width -= sio->scan_width % 150;
sio->scan_height -= sio->scan_height % 150;
  160 #endif
  161         if (sio->scan_width == 0 ||
sio->scan_x_origin + sio->scan_width > 10200 ||
sio->scan_height == 0 ||
sio->scan_y_origin + sio->scan_height > 16800)
  165                 return (EINVAL);
  167         /*
  168          * for now, only realize the values for the MUSTEK_06000CX
  169          * in the future, values for the MUSTEK_12000CX will be implemented
  170          */
  172         /*
  173          * resolution (dpi) must be <= 300 and a multiple of 3 or
  174          * between 300 and 600 and a multiple of 30
  175          */
sio->scan_x_resolution -= sio->scan_x_resolution <= 300 ?
sio->scan_x_resolution % 3 : sio->scan_x_resolution % 30;
sio->scan_y_resolution -= sio->scan_y_resolution <= 300 ?
sio->scan_y_resolution % 3 : sio->scan_y_resolution % 30;
  180         if (sio->scan_x_resolution < 3 || sio->scan_x_resolution > 600 ||
sio->scan_x_resolution != sio->scan_y_resolution)
  182                 return (EINVAL);
  184         /* assume brightness values are between 64 and 136 in steps of 3 */
sio->scan_brightness -= (sio->scan_brightness - 64) % 3;
  186         if (sio->scan_brightness < 64 || sio->scan_brightness > 136)
  187                 return (EINVAL);
  189         /* contrast values must be between 16 and 184 in steps of 7 */
sio->scan_contrast -= (sio->scan_contrast - 16) % 7;
  191         if (sio->scan_contrast < 16 || sio->scan_contrast > 184)
  192                 return (EINVAL);
  194         /*
  195          * velocity: between 0 (fast) and 4 (slow) which will be mapped
  196          * to 100% = 4, 80% = 3, 60% = 2, 40% = 1, 20% = 0
  197          * must be a multiple of 20
  198          */
sio->scan_quality -= sio->scan_quality % 20;
  200         if (sio->scan_quality < 20 || sio->scan_quality > 100)
  201                 return (EINVAL);
  203         switch (sio->scan_image_mode) {
  204         case SIM_BINARY_MONOCHROME:
  205         case SIM_DITHERED_MONOCHROME:
  206         case SIM_GRAYSCALE:
  207         case SIM_RED:
  208         case SIM_GREEN:
  209         case SIM_BLUE:
  210                 break;
  211         default:
  212                 return (EINVAL);
  213         }
  215         /* change ss_softc to the new values, but save ro-variables */
sio->scan_scanner_type = ss->sio.scan_scanner_type;
bcopy(sio, &ss->sio, sizeof(struct scan_io));
mustek_compute_sizes(ss);
  221         return (0);
  222 }
  224 /*
  225  * trim the requested transfer to a multiple of the line size
  226  * this is called only from ssread() which guarantees, scanner is triggered
  227  * In the future, it will trim the transfer to not read to much at a time
  228  * because the mustek cannot disconnect. It will be calculated by the
  229  * resolution, the velocity and the number of bytes per line.
  230  */
  231 void
mustek_minphys(ss, bp)
  233         struct ss_softc *ss;
  234         struct buf *bp;
  235 {
  236 #ifdef SCSIDEBUG
  237         struct scsi_link *sc_link = ss->sc_link;
  238 #endif
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_minphys: before: %ld\n",
bp->b_bcount));
bp->b_bcount -= bp->b_bcount %
  243             ((ss->sio.scan_pixels_per_line * ss->sio.scan_bits_per_pixel) / 8);
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_minphys: after:  %ld\n",
bp->b_bcount));
  246 }
  248 /*
  249  * trigger the scanner to start a scan operation
  250  * this includes sending the mode- and window-data, starting the scanner
  251  * and getting the image size info
  252  */
  253 int
mustek_trigger_scanner(ss)
  255         struct ss_softc *ss;
  256 {
  257         struct mustek_mode_select_cmd mode_cmd;
  258         struct mustek_mode_select_data mode_data;
  259         struct mustek_set_window_cmd window_cmd;
  260         struct mustek_set_window_data window_data;
  261         struct mustek_start_scan_cmd start_scan_cmd;
  262         struct scsi_link *sc_link = ss->sc_link;
  263         int pixel_tlx, pixel_tly, pixel_brx, pixel_bry, paperlength;
  264         int error;
mustek_compute_sizes(ss);
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_trigger_scanner\n"));
  270         /*
  271          * set the window params and send the scsi command
  272          */
bzero(&window_cmd, sizeof(window_cmd));
window_cmd.opcode = MUSTEK_SET_WINDOW;
window_cmd.length = sizeof(window_data);
bzero(&window_data, sizeof(window_data));
window_data.frame.header = MUSTEK_LINEART_BACKGROUND | MUSTEK_UNIT_SPEC;
  279 #ifdef MUSTEK_INCH_SPEC
  280         /* the positional values are all 1 byte because 256 / 8 = 32" */
pixel_tlx = ss->sio.scan_x_origin / 150;
pixel_tly = ss->sio.scan_y_origin / 150;
pixel_brx = pixel_tlx + ss->sio.scan_width / 150;
pixel_bry = pixel_tly + ss->sio.scan_height / 150;
  285 #else
pixel_tlx = (ss->sio.scan_x_origin * ss->sio.scan_x_resolution) / 1200;
pixel_tly = (ss->sio.scan_y_origin * ss->sio.scan_y_resolution) / 1200;
pixel_brx = pixel_tlx +
  289             (ss->sio.scan_width * ss->sio.scan_x_resolution) / 1200;
pixel_bry = pixel_tly +
  291             (ss->sio.scan_height * ss->sio.scan_y_resolution) / 1200;
  292 #endif
_lto2l(pixel_tlx, window_data.frame.tl_x);
_lto2l(pixel_tly, window_data.frame.tl_y);
_lto2l(pixel_brx, window_data.frame.br_x);
_lto2l(pixel_bry, window_data.frame.br_y);
  298 #if MUSTEK_WINDOWS >= 1
window_data.window1 = window_data.frame;
window_data.window1.header = MUSTEK_WINDOW_MASK | MUSTEK_UNIT_SPEC;
  301 #endif
  303         /* send the set window command to the scanner */
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_set_parms: set_window\n"));
error = scsi_scsi_cmd(sc_link, (struct scsi_generic *) &window_cmd,
  306             sizeof(window_cmd), (u_char *) &window_data, sizeof(window_data),
MUSTEK_RETRIES, 5000, NULL, SCSI_DATA_OUT);
  308         if (error)
  309                 return (error);
  311         /*
  312          * do what it takes to actualize the mode
  313          */
bzero(&mode_cmd, sizeof(mode_cmd));
mode_cmd.opcode = MUSTEK_MODE_SELECT;
_lto2b(sizeof(mode_data), mode_cmd.length);
bzero(&mode_data, sizeof(mode_data));
mode_data.mode =
MUSTEK_MODE_MASK | MUSTEK_HT_PATTERN_BUILTIN | MUSTEK_UNIT_SPEC;
  321         if (ss->sio.scan_x_resolution <= 300) {
mode_data.resolution = ss->sio.scan_x_resolution / 3;
  323         } else {
  324                 /*
  325                  * the resolution values is computed by modulo 100, but not
  326                  * for 600dpi, where the value is 100 (a bit tricky, but ...)
  327                  */
mode_data.resolution =
  329                     ((ss->sio.scan_x_resolution - 1) % 100) + 1;
  330         }
mode_data.brightness = (ss->sio.scan_brightness - 64) / 3;
mode_data.contrast = (ss->sio.scan_contrast - 16) / 7;
mode_data.grain = 0;
mode_data.velocity = ss->sio.scan_quality / 20 - 1;
  335 #ifdef MUSTEK_INCH_SPEC
paperlength = 14 * 8;   /* 14" */
  337 #else
paperlength = 14 * ss->sio.scan_y_resolution;   /* 14" */
  339 #endif
_lto2l(paperlength, mode_data.paperlength);
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_trigger_scanner: mode_select\n"));
  343         /* send the command to the scanner */
error = scsi_scsi_cmd(sc_link, (struct scsi_generic *) &mode_cmd,
  345             sizeof(mode_cmd), (u_char *) &mode_data, sizeof(mode_data),
MUSTEK_RETRIES, 5000, NULL, SCSI_DATA_OUT);
  347         if (error)
  348                 return (error);
  350         /*
  351          * now construct and send the start command
  352          */
bzero(&start_scan_cmd,sizeof(start_scan_cmd));
start_scan_cmd.opcode = MUSTEK_START_STOP;
start_scan_cmd.mode = MUSTEK_SCAN_START;
  356         if (ss->sio.scan_x_resolution <= 300)
start_scan_cmd.mode |= MUSTEK_RES_STEP_1;
  358         else
start_scan_cmd.mode |= MUSTEK_RES_STEP_10;
  360         switch (ss->sio.scan_image_mode) {
  361         case SIM_BINARY_MONOCHROME:
  362         case SIM_DITHERED_MONOCHROME:
start_scan_cmd.mode |= MUSTEK_BIT_MODE | MUSTEK_GRAY_FILTER;
  364                 break;
  365         case SIM_GRAYSCALE:
start_scan_cmd.mode |= MUSTEK_GRAY_MODE | MUSTEK_GRAY_FILTER;
  367                 break;
  368         case SIM_RED:
start_scan_cmd.mode |= MUSTEK_GRAY_MODE | MUSTEK_RED_FILTER;
  370                 break;
  371         case SIM_GREEN:
start_scan_cmd.mode |= MUSTEK_GRAY_MODE | MUSTEK_GREEN_FILTER;
  373                 break;
  374         case SIM_BLUE:
start_scan_cmd.mode |= MUSTEK_GRAY_MODE | MUSTEK_BLUE_FILTER;
  376                 break;
  377         }
  379         /* send the command to the scanner */
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_trigger_scanner: start_scan\n"));
error = scsi_scsi_cmd(sc_link, (struct scsi_generic *) &start_scan_cmd,
  382             sizeof(start_scan_cmd), NULL, 0,
MUSTEK_RETRIES, 5000, NULL, 0);
  384         if (error)
  385                 return (error);
  387         /*
  388          * now check if scanner ready this time with update of size info
  389          * we wait here so that if the user issues a read directly afterwards,
  390          * the scanner will respond directly (otherwise we had to sleep with
  391          * a buffer locked in memory)
  392          */
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_trigger_scanner: get_status\n"));
error = mustek_get_status(ss, 60, 1);
  395         if (error)
  396                 return (error);
  398         return (0);
  399 }
  401 /*
  402  * stop a scan operation in progress
  403  */
  404 int
mustek_rewind_scanner(ss)
  406         struct ss_softc *ss;
  407 {
  408         struct mustek_start_scan_cmd cmd;
  409         struct scsi_link *sc_link = ss->sc_link;
  410         int error;
  412         if (ss->sio.scan_window_size != 0) {
  413                 /*
  414                  * only if not all data has been read, the scanner has to be
  415                  * stopped
  416                  */
bzero(&cmd, sizeof(cmd));
cmd.opcode = MUSTEK_START_STOP;
cmd.mode = MUSTEK_SCAN_STOP;
  421                 /* send the command to the scanner */
SC_DEBUG(sc_link, SDEV_DB1,
  423                     ("mustek_rewind_scanner: stop_scan\n"));
error = scsi_scsi_cmd(sc_link, (struct scsi_generic *) &cmd,
  425                     sizeof(cmd), NULL, 0, MUSTEK_RETRIES, 5000, NULL, 0);
  426                 if (error)
  427                         return (error);
  428         }
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_rewind_scanner: end\n"));
  432         return (0);
  433 }
  435 /*
  436  * read the requested number of bytes/lines from the scanner
  437  */
  438 int
mustek_read(ss, bp)
  440         struct ss_softc *ss;
  441         struct buf *bp;
  442 {
  443         struct mustek_read_cmd cmd;
  444         struct scsi_link *sc_link = ss->sc_link;
u_long lines_to_read;
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_read: start\n"));
bzero(&cmd, sizeof(cmd));
cmd.opcode = MUSTEK_READ;
  452         /* instead of the bytes, the mustek wants the number of lines */
lines_to_read = bp->b_bcount /
  454             ((ss->sio.scan_pixels_per_line * ss->sio.scan_bits_per_pixel) / 8);
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_read: read %ld lines\n",
lines_to_read));
_lto3b(lines_to_read, cmd.length);
  459         /*
  460          * go ask the adapter to do all this for us
  461          */
  462         if (scsi_scsi_cmd(sc_link, (struct scsi_generic *) &cmd, sizeof(cmd),
  463             (u_char *) bp->b_data, bp->b_bcount, MUSTEK_RETRIES, 10000, bp,
SCSI_NOSLEEP | SCSI_DATA_IN) != SUCCESSFULLY_QUEUED)
printf("%s: not queued\n", ss->sc_dev.dv_xname);
  466         else {
ss->sio.scan_lines -= lines_to_read;
ss->sio.scan_window_size -= bp->b_bcount;
  469         }
  471         return (0);
  472 }
  474 /*
  475  * check if the scanner is ready to take commands
  476  *   wait timeout seconds and try only every second
  477  *   if update, then update picture size info
  478  *
  479  *   returns EBUSY if scanner not ready
  480  */
  481 int
mustek_get_status(ss, timeout, update)
  483         struct ss_softc *ss;
  484         int timeout, update;
  485 {
  486         struct mustek_get_status_cmd cmd;
  487         struct mustek_get_status_data data;
  488         struct scsi_link *sc_link = ss->sc_link;
  489         int error, lines, bytes_per_line;
bzero(&cmd, sizeof(cmd));
cmd.opcode = MUSTEK_GET_STATUS;
cmd.length = sizeof(data);
  495         while (1) {
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_get_status: stat_cmd\n"));
error = scsi_scsi_cmd(sc_link, (struct scsi_generic *) &cmd,
  498                     sizeof(cmd), (u_char *) &data, sizeof(data), MUSTEK_RETRIES,
  499                     5000, NULL, SCSI_DATA_IN);
  500                 if (error)
  501                         return (error);
  502                 if ((data.ready_busy == MUSTEK_READY) ||
  503                     (timeout-- <= 0))
  504                         break;
  505                 /* please wait a second */
tsleep((caddr_t)mustek_get_status, PRIBIO + 1, "mtkrdy", hz);
  507         }
  509         if (update) {
bytes_per_line = _2ltol(data.bytes_per_line);
lines = _3ltol(data.lines);
  512                 if (lines != ss->sio.scan_lines) {
printf("mustek: lines actual(%d) != computed(%ld)\n",
lines, ss->sio.scan_lines);
  515                         return (EIO);
  516                 }
  517                 if (bytes_per_line * lines != ss->sio.scan_window_size) {
printf("mustek: win-size actual(%d) != computed(%ld)\n",
bytes_per_line * lines, ss->sio.scan_window_size);
  520                     return (EIO);
  521                 }
SC_DEBUG(sc_link, SDEV_DB1,
  524                     ("mustek_get_size: bpl=%ld, lines=%ld\n",
  525                     (ss->sio.scan_pixels_per_line * ss->sio.scan_bits_per_pixel) / 8,
ss->sio.scan_lines));
SC_DEBUG(sc_link, SDEV_DB1, ("window size = %ld\n",
ss->sio.scan_window_size));
  529         }
SC_DEBUG(sc_link, SDEV_DB1, ("mustek_get_status: end\n"));
  532         if (data.ready_busy == MUSTEK_READY)
  533                 return (0);
  534         else
  535                 return (EBUSY);
  536 }
  538 /*
  539  * mustek_compute_sizes: compute window_size and lines for the picture
  540  *   this function is called from different places in the code
  541  */
  542 void
mustek_compute_sizes(ss)
  544         struct ss_softc *ss;
  545 {
  547         switch (ss->sio.scan_image_mode) {
  548         case SIM_BINARY_MONOCHROME:
  549         case SIM_DITHERED_MONOCHROME:
ss->sio.scan_bits_per_pixel = 1;
  551                 break;
  552         case SIM_GRAYSCALE:
  553         case SIM_RED:
  554         case SIM_GREEN:
  555         case SIM_BLUE:
ss->sio.scan_bits_per_pixel = 8;
  557                 break;
  558         }
  560         /*
  561          * horizontal number of bytes is always a multiple of 2,
  562          * in 8-bit mode at least
  563          */
ss->sio.scan_pixels_per_line =
  565             (ss->sio.scan_width * ss->sio.scan_x_resolution) / 1200;
  566         if (ss->sio.scan_bits_per_pixel == 1)
  567                 /* make it a multiple of 16, and thus of 2 bytes */
ss->sio.scan_pixels_per_line =
  569                     (ss->sio.scan_pixels_per_line + 15) & 0xfffffff0;
  570         else
ss->sio.scan_pixels_per_line =
  572                     (ss->sio.scan_pixels_per_line + 1) & 0xfffffffe;
ss->sio.scan_lines =
  575             (ss->sio.scan_height * ss->sio.scan_y_resolution) / 1200;
ss->sio.scan_window_size = ss->sio.scan_lines *
  577             ((ss->sio.scan_pixels_per_line * ss->sio.scan_bits_per_pixel) / 8);
  578 }