root/scsi/ss_scanjet.c

DEFINITIONS

1. scanjet_attach
2. scanjet_set_params
3. scanjet_trigger_scanner
4. scanjet_read
5. scanjet_ctl_write
6. scanjet_ctl_read
7. show_es
8. scanjet_set_window
9. atoi
10. scanjet_compute_sizes

    1 /*      $OpenBSD: ss_scanjet.c,v 1.31 2007/06/01 20:59:04 moritz Exp $  */
    2 /*      $NetBSD: ss_scanjet.c,v 1.6 1996/05/18 22:58:01 christos Exp $  */
    4 /*
    5  * Copyright (c) 1995 Kenneth Stailey.  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 Kenneth Stailey.
   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 functions for the HP ScanJet IIc and IIcx
   35  */
   37 #include <sys/types.h>
   38 #include <sys/param.h>
   39 #include <sys/systm.h>
   40 #include <sys/fcntl.h>
   41 #include <sys/errno.h>
   42 #include <sys/ioctl.h>
   43 #include <sys/malloc.h>
   44 #include <sys/buf.h>
   45 #include <sys/proc.h>
   46 #include <sys/user.h>
   47 #include <sys/device.h>
   48 #include <sys/conf.h>           /* for cdevsw */
   49 #include <sys/scanio.h>
   51 #include <scsi/scsi_all.h>
   52 #include <scsi/scsi_scanner.h>
   53 #include <scsi/scsiconf.h>
   54 #include <scsi/ssvar.h>
   56 #define SCANJET_RETRIES 4
   58 int scanjet_set_params(struct ss_softc *, struct scan_io *);
   59 int scanjet_trigger_scanner(struct ss_softc *);
   60 int scanjet_read(struct ss_softc *, struct buf *);
   62 /* only used internally */
   63 int scanjet_ctl_write(struct ss_softc *, char *, u_int, int);
   64 int scanjet_ctl_read(struct ss_softc *, char *, u_int, int);
   65 int scanjet_set_window(struct ss_softc *, int);
   66 int scanjet_compute_sizes(struct ss_softc *, int);
   67 /* Maybe move to libkern? */
   68 #define atoi local_atoi
   69 __inline static int atoi(const char *);
   72 /*
   73  * structure for the special handlers
   74  */
   75 struct ss_special scanjet_special = {
scanjet_set_params,
scanjet_trigger_scanner,
NULL,
NULL,                   /* no special minphys */
scanjet_read,           /* scsi 6-byte read */
NULL,                   /* no "rewind" code (yet?) */
NULL,                   /* no adf support right now */
NULL                    /* no adf support right now */
   84 };
   86 /*
   87  * scanjet_attach: attach special functions to ss
   88  */
   89 void
scanjet_attach(ss, sa)
   91         struct ss_softc *ss;
   92         struct scsi_attach_args *sa;
   93 {
   94 #ifdef SCSIDEBUG
   95         struct scsi_link *sc_link = sa->sa_sc_link;
   96 #endif
   97         int error;
SC_DEBUG(sc_link, SDEV_DB1, ("scanjet_attach: start\n"));
ss->sio.scan_scanner_type = 0;
printf("\n%s: ", ss->sc_dev.dv_xname);
  104         /* first, check the model (which determines nothing yet) */
  106         if (!bcmp(sa->sa_inqbuf->product, "C1750A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet IIc");
  109         }
  110         /* The IIp is a grayscale-only HP SCL scanner */
  111         if (!bcmp(sa->sa_inqbuf->product, "C1790A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet IIp");
  114         }
  115         if (!bcmp(sa->sa_inqbuf->product, "C2500A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet IIcx");
  118         }
  119         /* The 3p is a grayscale-only HP SCL scanner */
  120         if (!bcmp(sa->sa_inqbuf->product, "C2570A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet 3p");
  123         }
  124         /* The 3c/4c/6100C report as the same? */
  125         if (!bcmp(sa->sa_inqbuf->product, "C2520A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet 3c/4c/6100C");
  128         }
  129         if (!bcmp(sa->sa_inqbuf->product, "C1130A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet 4p");
  132         }
  133         if (!bcmp(sa->sa_inqbuf->product, "C5110A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet 5p");
  136         }
  137         if (!bcmp(sa->sa_inqbuf->product, "C6290A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet 4100C");
  140         }
  141         if (!bcmp(sa->sa_inqbuf->product, "C5190A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet 5100C");
  144         }
  145         if (!bcmp(sa->sa_inqbuf->product, "C7190A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet 5200C");
  148         }
  149         if (!bcmp(sa->sa_inqbuf->product, "C6270A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet 6200C");
  152         }
  153         if (!bcmp(sa->sa_inqbuf->product, "C7670A", 6)) {
ss->sio.scan_scanner_type = HP_SCANJET_IIC;
printf("HP ScanJet 6300C");
  156         }
SC_DEBUG(sc_link, SDEV_DB1, ("scanjet_attach: scanner_type = %d\n",
ss->sio.scan_scanner_type));
  161         /* now install special handlers */
ss->special = scanjet_special;
  164         /*
  165          * fill in the rest of the scan_io struct by calling
  166          * set_window and compute_sizes routines
  167          */
error = scanjet_set_window(ss, SCSI_POLL);
  169         if (error) {
printf(" set_window failed\n");
  171                 return;
  172         }
error = scanjet_compute_sizes(ss, SCSI_POLL);
  175         if (error) {
printf(" compute_sizes failed\n");
  177                 return;
  178         }
printf("\n");
  181 }
  183 /*
  184  * check the parameters if the scanjet is capable of fulfilling it
  185  * but don't send the command to the scanner in case the user wants
  186  * to change parameters by more than one call
  187  */
  188 int
scanjet_set_params(ss, sio)
  190         struct ss_softc *ss;
  191         struct scan_io *sio;
  192 {
  193         int error;
  195 #if 0
  196         /*
  197          * if the scanner is triggered, then rewind it
  198          */
  199         if (ss->flags & SSF_TRIGGERED) {
error = scanjet_rewind_scanner(ss);
  201                 if (error)
  202                         return (error);
  203         }
  204 #endif
  206         /* size constraints... */
  207         if (sio->scan_width == 0                                 ||
sio->scan_x_origin + sio->scan_width > 10200 || /* 8.5" */
sio->scan_height == 0                                ||
sio->scan_y_origin + sio->scan_height > 16800)  /* 14" */
  211                 return (EINVAL);
  213         /* resolution (dpi)... */
  214         if (sio->scan_x_resolution < 100 ||
sio->scan_x_resolution > 400 ||
sio->scan_y_resolution < 100 ||
sio->scan_y_resolution > 400)
  218                 return (EINVAL);
  220         switch (sio->scan_image_mode) {
  221         case SIM_BINARY_MONOCHROME:
  222         case SIM_DITHERED_MONOCHROME:
  223         case SIM_GRAYSCALE:
  224         case SIM_COLOR:
  225                 break;
  226         default:
  227                 return (EINVAL);
  228         }
  230         /* 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));
error = scanjet_set_window(ss, 0);
  235         if (error) {
uprintf("%s: set_window failed\n", ss->sc_dev.dv_xname);
  237                 return (error);
  238         }
error = scanjet_compute_sizes(ss, 0);
  240         if (error) {
uprintf("%s: compute_sizes failed\n", ss->sc_dev.dv_xname);
  242                 return (error);
  243         }
  245         return (0);
  246 }
  248 /*
  249  * trigger the scanner to start a scan operation
  250  * this includes sending the mode- and window-data,
  251  * and starting the scanner
  252  */
  253 int
scanjet_trigger_scanner(ss)
  255         struct ss_softc *ss;
  256 {
  257         static char *escape_codes = "\033*f0S";
  258         int error;
error = scanjet_set_window(ss, 0);
  261         if (error) {
uprintf("%s: set_window failed\n", ss->sc_dev.dv_xname);
  263                 return (error);
  264         }
error = scanjet_compute_sizes(ss, 0);
  266         if (error) {
uprintf("%s: compute_sizes failed\n", ss->sc_dev.dv_xname);
  268                 return (error);
  269         }
  271         /* send "trigger" operation */
error = scanjet_ctl_write(ss, escape_codes, strlen(escape_codes), 0);
  273         if (error) {
uprintf("%s: trigger_scanner failed\n", ss->sc_dev.dv_xname);
  275                 return (error);
  276         }
  278         return (0);
  279 }
  281 int
scanjet_read(ss, bp)
  283         struct ss_softc *ss;
  284         struct buf *bp;
  285 {
  286         struct scsi_rw_scanner cmd;
  287         struct scsi_link *sc_link = ss->sc_link;
  289         /*
  290          *  Fill out the scsi command
  291          */
bzero(&cmd, sizeof(cmd));
cmd.opcode = READ;
  295         /*
  296          * Handle "fixed-block-mode" tape drives by using the
  297          * block count instead of the length.
  298          */
_lto3b(bp->b_bcount, cmd.len);
  301         /*
  302          * go ask the adapter to do all this for us
  303          */
  304         if (scsi_scsi_cmd(sc_link, (struct scsi_generic *) &cmd, sizeof(cmd),
  305             (u_char *) bp->b_data, bp->b_bcount, SCANJET_RETRIES, 100000, bp,
SCSI_NOSLEEP | SCSI_DATA_IN) != SUCCESSFULLY_QUEUED)
printf("%s: not queued\n", ss->sc_dev.dv_xname);
  308         else {
  309                 if (bp->b_bcount >= ss->sio.scan_window_size)
ss->sio.scan_window_size = 0;
  311                 else
ss->sio.scan_window_size -= bp->b_bcount;
  313         }
  315         return (0);
  316 }
  319 /*
  320  * Do a synchronous write.  Used to send control messages.
  321  */
  322 int
scanjet_ctl_write(ss, buf, size, flags)
  324         struct ss_softc *ss;
  325         char *buf;
u_int size;
  327         int flags;
  328 {
  329         struct scsi_rw_scanner cmd;
bzero(&cmd, sizeof(cmd));
cmd.opcode = WRITE;
_lto3b(size, cmd.len);
  334         return (scsi_scsi_cmd(ss->sc_link, (struct scsi_generic *) &cmd,
  335             sizeof(cmd), (u_char *) buf, size, 0, 100000, NULL,
flags | SCSI_DATA_OUT));
  337 }
  340 /*
  341  * Do a synchronous read.  Used to read responses to control messages.
  342  */
  343 int
scanjet_ctl_read(ss, buf, size, flags)
  345         struct ss_softc *ss;
  346         char *buf;
u_int size;
  348         int flags;
  349 {
  350         struct scsi_rw_scanner cmd;
bzero(&cmd, sizeof(cmd));
cmd.opcode = READ;
_lto3b(size, cmd.len);
  355         return (scsi_scsi_cmd(ss->sc_link, (struct scsi_generic *) &cmd,
  356             sizeof(cmd), (u_char *) buf, size, 0, 100000, NULL,
flags | SCSI_DATA_IN));
  358 }
  361 #ifdef SCANJETDEBUG
  362 static void show_es(char *es)
  363 {
  364         char *p = es;
  366         while (*p) {
  367                 if (*p == '\033')
printf("[Esc]");
  369                 else
printf("%c", *p);
  371                 ++p;
  372         }
printf("\n");
  374 }
  375 #endif
  377 /*
  378  * simulate SCSI_SET_WINDOW for ScanJets
  379  */
  380 int
scanjet_set_window(ss, flags)
  382         struct ss_softc *ss;
  383         int flags;
  384 {
  385         char escape_codes[128];
size_t len;
  387         int n;
snprintf(escape_codes, sizeof escape_codes,
  390             "\033*f%ldP\033*f%ldQ\033*f%ldX\033*f%ldY\033*a%dR\033*a%dS",
ss->sio.scan_width / 4,
ss->sio.scan_height / 4,
ss->sio.scan_x_origin / 4,
ss->sio.scan_y_origin / 4,
ss->sio.scan_x_resolution,
ss->sio.scan_y_resolution);
  398         switch (ss->sio.scan_image_mode) {
  399         case SIM_BINARY_MONOCHROME:
ss->sio.scan_bits_per_pixel = 1;
  401                 /*
  402                  * Use line art mode (\033*aoT) and make image data be
  403                  * min-is-white ala PBM (\033*a0I).
  404                  */
strlcat(escape_codes, "\033*a0T\033*a0I", sizeof escape_codes);
  406                 break;
  407         case SIM_DITHERED_MONOCHROME:
ss->sio.scan_bits_per_pixel = 1;
  409                 /* 
  410                  * Use dithered mode (\033*a3T) and make image data be
  411                  * min-is-white ala PBM (\033*a0I).
  412                  */
strlcat(escape_codes, "\033*a3T\033*a0I", sizeof escape_codes);
  414                 break;
  415         case SIM_GRAYSCALE:
ss->sio.scan_bits_per_pixel = 8;
  417                 /*
  418                  * Use grayscale mode (\033*a4T) and make image data be
  419                  * min-is-black ala PGM (\033*a1I)
  420                  */
strlcat(escape_codes, "\033*a4T\033*a1I", sizeof escape_codes);
  422                 break;
  423         case SIM_COLOR:
ss->sio.scan_bits_per_pixel = 24;
  425                 /*
  426                  * Use RGB color mode (\033*a5T), make image data be
  427                  * min-is-black ala PPM (\033*a1I) and use pass-through matrix,
  428                  * i.e. disable NTSC (\033*u2T).
  429                  */
strlcat(escape_codes, "\033*a5T\033*a1I\033*u2T",
  431                     sizeof escape_codes);
  432                 break;
  433         }
  435         /*
  436          * If the escape sequence has been truncated at this point, appending
  437          * the next sequence will also cause truncation, and this time we pay
  438          * attention.
  439          */
len = strlen(escape_codes);
n = snprintf(escape_codes + len, sizeof escape_codes - len,
  442             "\033*a%dG\033*a%dL\033*a%dK",
ss->sio.scan_bits_per_pixel,
  444             (int)(ss->sio.scan_brightness) - 128,
  445             (int)(ss->sio.scan_contrast) - 128);
  447         if (n >= sizeof escape_codes - len)
  448                 return (ENOMEM);
len += n;
  451         return (scanjet_ctl_write(ss, escape_codes, len, flags));
  452 }
  454 /* atoi() is from /sys/arch/amiga/dev/ite.c
  455    and is only used in scanjet_compute_sizes */
  457 __inline static int
atoi(cp)
  459         const char *cp;
  460 {
  461         int n;
  463         for (n = 0; *cp && *cp >= '0' && *cp <= '9'; cp++)
n = n * 10 + *cp - '0';
  466         return (n);
  467 }
  469 int
scanjet_compute_sizes(ss, flags)
  471         struct ss_softc *ss;
  472         int flags;
  473 {
  474         int error;
  475         static char *wfail = "%s: interrogate write failed\n";
  476         static char *rfail = "%s: interrogate read failed\n";
  477         static char *dfail = "%s: bad data returned\n";
  478         static char *mono  = "\033*s1025E"; /* bytes wide  */
  479         static char *color = "\033*s1024E"; /* pixels wide */
  480         static char *high  = "\033*s1026E"; /* pixels high */
  481         char response[20];
  482         char *p;
  484         /*
  485          * Deal with the fact that the HP ScanJet IIc uses 1/300" not 1/1200"
  486          * as its base unit of measurement.  PINT uses 1/1200" (yes I know
  487          * ScanJet II's use decipoints as well but 1200 % 720 != 0)
  488          */
ss->sio.scan_width = (ss->sio.scan_width + 3) & 0xfffffffc;
ss->sio.scan_height = (ss->sio.scan_height + 3) & 0xfffffffc;
  492         switch (ss->sio.scan_image_mode) {
  493         case SIM_BINARY_MONOCHROME:
  494         case SIM_DITHERED_MONOCHROME:
error = scanjet_ctl_write(ss, mono, strlen(mono), flags);
  496                 break;
  497         case SIM_GRAYSCALE:
  498         case SIM_COLOR:
error = scanjet_ctl_write(ss, color, strlen(color), flags);
  500                 break;
  501         default:
error = EIO;
  503                 break;
  504         }
  505         if (error) {
uprintf(wfail, ss->sc_dev.dv_xname);
  507                 return (error);
  508         }
error = scanjet_ctl_read(ss, response, 20, flags);
  510         if (error) {
uprintf(rfail, ss->sc_dev.dv_xname);
  512                 return (error);
  513         }
p = strchr(response, 'd');
  515         if (p == NULL) {
uprintf(dfail, ss->sc_dev.dv_xname);
  517                 return (EIO);
  518         }
ss->sio.scan_pixels_per_line = atoi(p + 1);
  520         if (ss->sio.scan_image_mode < SIM_GRAYSCALE)
ss->sio.scan_pixels_per_line *= 8;
error = scanjet_ctl_write(ss, high, strlen(high), flags);
  524         if (error) {
uprintf(wfail, ss->sc_dev.dv_xname);
  526                 return (error);
  527         }
error = scanjet_ctl_read(ss, response, 20, flags);
  529         if (error) {
uprintf(rfail, ss->sc_dev.dv_xname);
  531                 return (error);
  532         }
p = strchr(response, 'd');
  534         if (p == NULL) {
uprintf(dfail, ss->sc_dev.dv_xname);
  536                 return (EIO);
  537         }
ss->sio.scan_lines = atoi(p + 1);
ss->sio.scan_window_size = ss->sio.scan_lines *
  541             ((ss->sio.scan_pixels_per_line * ss->sio.scan_bits_per_pixel) / 8);
  543         return (0);
  544 }