Annotation of sys/scsi/ss_scanjet.c, Revision 1.1
1.1 ! nbrk 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 $ */
! 3:
! 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: */
! 32:
! 33: /*
! 34: * special functions for the HP ScanJet IIc and IIcx
! 35: */
! 36:
! 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>
! 50:
! 51: #include <scsi/scsi_all.h>
! 52: #include <scsi/scsi_scanner.h>
! 53: #include <scsi/scsiconf.h>
! 54: #include <scsi/ssvar.h>
! 55:
! 56: #define SCANJET_RETRIES 4
! 57:
! 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 *);
! 61:
! 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 *);
! 70:
! 71:
! 72: /*
! 73: * structure for the special handlers
! 74: */
! 75: struct ss_special scanjet_special = {
! 76: scanjet_set_params,
! 77: scanjet_trigger_scanner,
! 78: NULL,
! 79: NULL, /* no special minphys */
! 80: scanjet_read, /* scsi 6-byte read */
! 81: NULL, /* no "rewind" code (yet?) */
! 82: NULL, /* no adf support right now */
! 83: NULL /* no adf support right now */
! 84: };
! 85:
! 86: /*
! 87: * scanjet_attach: attach special functions to ss
! 88: */
! 89: void
! 90: 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;
! 98:
! 99: SC_DEBUG(sc_link, SDEV_DB1, ("scanjet_attach: start\n"));
! 100: ss->sio.scan_scanner_type = 0;
! 101:
! 102: printf("\n%s: ", ss->sc_dev.dv_xname);
! 103:
! 104: /* first, check the model (which determines nothing yet) */
! 105:
! 106: if (!bcmp(sa->sa_inqbuf->product, "C1750A", 6)) {
! 107: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 108: printf("HP ScanJet IIc");
! 109: }
! 110: /* The IIp is a grayscale-only HP SCL scanner */
! 111: if (!bcmp(sa->sa_inqbuf->product, "C1790A", 6)) {
! 112: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 113: printf("HP ScanJet IIp");
! 114: }
! 115: if (!bcmp(sa->sa_inqbuf->product, "C2500A", 6)) {
! 116: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 117: printf("HP ScanJet IIcx");
! 118: }
! 119: /* The 3p is a grayscale-only HP SCL scanner */
! 120: if (!bcmp(sa->sa_inqbuf->product, "C2570A", 6)) {
! 121: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 122: printf("HP ScanJet 3p");
! 123: }
! 124: /* The 3c/4c/6100C report as the same? */
! 125: if (!bcmp(sa->sa_inqbuf->product, "C2520A", 6)) {
! 126: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 127: printf("HP ScanJet 3c/4c/6100C");
! 128: }
! 129: if (!bcmp(sa->sa_inqbuf->product, "C1130A", 6)) {
! 130: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 131: printf("HP ScanJet 4p");
! 132: }
! 133: if (!bcmp(sa->sa_inqbuf->product, "C5110A", 6)) {
! 134: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 135: printf("HP ScanJet 5p");
! 136: }
! 137: if (!bcmp(sa->sa_inqbuf->product, "C6290A", 6)) {
! 138: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 139: printf("HP ScanJet 4100C");
! 140: }
! 141: if (!bcmp(sa->sa_inqbuf->product, "C5190A", 6)) {
! 142: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 143: printf("HP ScanJet 5100C");
! 144: }
! 145: if (!bcmp(sa->sa_inqbuf->product, "C7190A", 6)) {
! 146: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 147: printf("HP ScanJet 5200C");
! 148: }
! 149: if (!bcmp(sa->sa_inqbuf->product, "C6270A", 6)) {
! 150: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 151: printf("HP ScanJet 6200C");
! 152: }
! 153: if (!bcmp(sa->sa_inqbuf->product, "C7670A", 6)) {
! 154: ss->sio.scan_scanner_type = HP_SCANJET_IIC;
! 155: printf("HP ScanJet 6300C");
! 156: }
! 157:
! 158: SC_DEBUG(sc_link, SDEV_DB1, ("scanjet_attach: scanner_type = %d\n",
! 159: ss->sio.scan_scanner_type));
! 160:
! 161: /* now install special handlers */
! 162: ss->special = scanjet_special;
! 163:
! 164: /*
! 165: * fill in the rest of the scan_io struct by calling
! 166: * set_window and compute_sizes routines
! 167: */
! 168: error = scanjet_set_window(ss, SCSI_POLL);
! 169: if (error) {
! 170: printf(" set_window failed\n");
! 171: return;
! 172: }
! 173:
! 174: error = scanjet_compute_sizes(ss, SCSI_POLL);
! 175: if (error) {
! 176: printf(" compute_sizes failed\n");
! 177: return;
! 178: }
! 179:
! 180: printf("\n");
! 181: }
! 182:
! 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
! 189: scanjet_set_params(ss, sio)
! 190: struct ss_softc *ss;
! 191: struct scan_io *sio;
! 192: {
! 193: int error;
! 194:
! 195: #if 0
! 196: /*
! 197: * if the scanner is triggered, then rewind it
! 198: */
! 199: if (ss->flags & SSF_TRIGGERED) {
! 200: error = scanjet_rewind_scanner(ss);
! 201: if (error)
! 202: return (error);
! 203: }
! 204: #endif
! 205:
! 206: /* size constraints... */
! 207: if (sio->scan_width == 0 ||
! 208: sio->scan_x_origin + sio->scan_width > 10200 || /* 8.5" */
! 209: sio->scan_height == 0 ||
! 210: sio->scan_y_origin + sio->scan_height > 16800) /* 14" */
! 211: return (EINVAL);
! 212:
! 213: /* resolution (dpi)... */
! 214: if (sio->scan_x_resolution < 100 ||
! 215: sio->scan_x_resolution > 400 ||
! 216: sio->scan_y_resolution < 100 ||
! 217: sio->scan_y_resolution > 400)
! 218: return (EINVAL);
! 219:
! 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: }
! 229:
! 230: /* change ss_softc to the new values, but save ro-variables */
! 231: sio->scan_scanner_type = ss->sio.scan_scanner_type;
! 232: bcopy(sio, &ss->sio, sizeof(struct scan_io));
! 233:
! 234: error = scanjet_set_window(ss, 0);
! 235: if (error) {
! 236: uprintf("%s: set_window failed\n", ss->sc_dev.dv_xname);
! 237: return (error);
! 238: }
! 239: error = scanjet_compute_sizes(ss, 0);
! 240: if (error) {
! 241: uprintf("%s: compute_sizes failed\n", ss->sc_dev.dv_xname);
! 242: return (error);
! 243: }
! 244:
! 245: return (0);
! 246: }
! 247:
! 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
! 254: scanjet_trigger_scanner(ss)
! 255: struct ss_softc *ss;
! 256: {
! 257: static char *escape_codes = "\033*f0S";
! 258: int error;
! 259:
! 260: error = scanjet_set_window(ss, 0);
! 261: if (error) {
! 262: uprintf("%s: set_window failed\n", ss->sc_dev.dv_xname);
! 263: return (error);
! 264: }
! 265: error = scanjet_compute_sizes(ss, 0);
! 266: if (error) {
! 267: uprintf("%s: compute_sizes failed\n", ss->sc_dev.dv_xname);
! 268: return (error);
! 269: }
! 270:
! 271: /* send "trigger" operation */
! 272: error = scanjet_ctl_write(ss, escape_codes, strlen(escape_codes), 0);
! 273: if (error) {
! 274: uprintf("%s: trigger_scanner failed\n", ss->sc_dev.dv_xname);
! 275: return (error);
! 276: }
! 277:
! 278: return (0);
! 279: }
! 280:
! 281: int
! 282: 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;
! 288:
! 289: /*
! 290: * Fill out the scsi command
! 291: */
! 292: bzero(&cmd, sizeof(cmd));
! 293: cmd.opcode = READ;
! 294:
! 295: /*
! 296: * Handle "fixed-block-mode" tape drives by using the
! 297: * block count instead of the length.
! 298: */
! 299: _lto3b(bp->b_bcount, cmd.len);
! 300:
! 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,
! 306: SCSI_NOSLEEP | SCSI_DATA_IN) != SUCCESSFULLY_QUEUED)
! 307: printf("%s: not queued\n", ss->sc_dev.dv_xname);
! 308: else {
! 309: if (bp->b_bcount >= ss->sio.scan_window_size)
! 310: ss->sio.scan_window_size = 0;
! 311: else
! 312: ss->sio.scan_window_size -= bp->b_bcount;
! 313: }
! 314:
! 315: return (0);
! 316: }
! 317:
! 318:
! 319: /*
! 320: * Do a synchronous write. Used to send control messages.
! 321: */
! 322: int
! 323: scanjet_ctl_write(ss, buf, size, flags)
! 324: struct ss_softc *ss;
! 325: char *buf;
! 326: u_int size;
! 327: int flags;
! 328: {
! 329: struct scsi_rw_scanner cmd;
! 330:
! 331: bzero(&cmd, sizeof(cmd));
! 332: cmd.opcode = WRITE;
! 333: _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,
! 336: flags | SCSI_DATA_OUT));
! 337: }
! 338:
! 339:
! 340: /*
! 341: * Do a synchronous read. Used to read responses to control messages.
! 342: */
! 343: int
! 344: scanjet_ctl_read(ss, buf, size, flags)
! 345: struct ss_softc *ss;
! 346: char *buf;
! 347: u_int size;
! 348: int flags;
! 349: {
! 350: struct scsi_rw_scanner cmd;
! 351:
! 352: bzero(&cmd, sizeof(cmd));
! 353: cmd.opcode = READ;
! 354: _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,
! 357: flags | SCSI_DATA_IN));
! 358: }
! 359:
! 360:
! 361: #ifdef SCANJETDEBUG
! 362: static void show_es(char *es)
! 363: {
! 364: char *p = es;
! 365:
! 366: while (*p) {
! 367: if (*p == '\033')
! 368: printf("[Esc]");
! 369: else
! 370: printf("%c", *p);
! 371: ++p;
! 372: }
! 373: printf("\n");
! 374: }
! 375: #endif
! 376:
! 377: /*
! 378: * simulate SCSI_SET_WINDOW for ScanJets
! 379: */
! 380: int
! 381: scanjet_set_window(ss, flags)
! 382: struct ss_softc *ss;
! 383: int flags;
! 384: {
! 385: char escape_codes[128];
! 386: size_t len;
! 387: int n;
! 388:
! 389: 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",
! 391: ss->sio.scan_width / 4,
! 392: ss->sio.scan_height / 4,
! 393: ss->sio.scan_x_origin / 4,
! 394: ss->sio.scan_y_origin / 4,
! 395: ss->sio.scan_x_resolution,
! 396: ss->sio.scan_y_resolution);
! 397:
! 398: switch (ss->sio.scan_image_mode) {
! 399: case SIM_BINARY_MONOCHROME:
! 400: 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: */
! 405: strlcat(escape_codes, "\033*a0T\033*a0I", sizeof escape_codes);
! 406: break;
! 407: case SIM_DITHERED_MONOCHROME:
! 408: 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: */
! 413: strlcat(escape_codes, "\033*a3T\033*a0I", sizeof escape_codes);
! 414: break;
! 415: case SIM_GRAYSCALE:
! 416: 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: */
! 421: strlcat(escape_codes, "\033*a4T\033*a1I", sizeof escape_codes);
! 422: break;
! 423: case SIM_COLOR:
! 424: 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: */
! 430: strlcat(escape_codes, "\033*a5T\033*a1I\033*u2T",
! 431: sizeof escape_codes);
! 432: break;
! 433: }
! 434:
! 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: */
! 440: len = strlen(escape_codes);
! 441: n = snprintf(escape_codes + len, sizeof escape_codes - len,
! 442: "\033*a%dG\033*a%dL\033*a%dK",
! 443: ss->sio.scan_bits_per_pixel,
! 444: (int)(ss->sio.scan_brightness) - 128,
! 445: (int)(ss->sio.scan_contrast) - 128);
! 446:
! 447: if (n >= sizeof escape_codes - len)
! 448: return (ENOMEM);
! 449: len += n;
! 450:
! 451: return (scanjet_ctl_write(ss, escape_codes, len, flags));
! 452: }
! 453:
! 454: /* atoi() is from /sys/arch/amiga/dev/ite.c
! 455: and is only used in scanjet_compute_sizes */
! 456:
! 457: __inline static int
! 458: atoi(cp)
! 459: const char *cp;
! 460: {
! 461: int n;
! 462:
! 463: for (n = 0; *cp && *cp >= '0' && *cp <= '9'; cp++)
! 464: n = n * 10 + *cp - '0';
! 465:
! 466: return (n);
! 467: }
! 468:
! 469: int
! 470: 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;
! 483:
! 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: */
! 489: ss->sio.scan_width = (ss->sio.scan_width + 3) & 0xfffffffc;
! 490: ss->sio.scan_height = (ss->sio.scan_height + 3) & 0xfffffffc;
! 491:
! 492: switch (ss->sio.scan_image_mode) {
! 493: case SIM_BINARY_MONOCHROME:
! 494: case SIM_DITHERED_MONOCHROME:
! 495: error = scanjet_ctl_write(ss, mono, strlen(mono), flags);
! 496: break;
! 497: case SIM_GRAYSCALE:
! 498: case SIM_COLOR:
! 499: error = scanjet_ctl_write(ss, color, strlen(color), flags);
! 500: break;
! 501: default:
! 502: error = EIO;
! 503: break;
! 504: }
! 505: if (error) {
! 506: uprintf(wfail, ss->sc_dev.dv_xname);
! 507: return (error);
! 508: }
! 509: error = scanjet_ctl_read(ss, response, 20, flags);
! 510: if (error) {
! 511: uprintf(rfail, ss->sc_dev.dv_xname);
! 512: return (error);
! 513: }
! 514: p = strchr(response, 'd');
! 515: if (p == NULL) {
! 516: uprintf(dfail, ss->sc_dev.dv_xname);
! 517: return (EIO);
! 518: }
! 519: ss->sio.scan_pixels_per_line = atoi(p + 1);
! 520: if (ss->sio.scan_image_mode < SIM_GRAYSCALE)
! 521: ss->sio.scan_pixels_per_line *= 8;
! 522:
! 523: error = scanjet_ctl_write(ss, high, strlen(high), flags);
! 524: if (error) {
! 525: uprintf(wfail, ss->sc_dev.dv_xname);
! 526: return (error);
! 527: }
! 528: error = scanjet_ctl_read(ss, response, 20, flags);
! 529: if (error) {
! 530: uprintf(rfail, ss->sc_dev.dv_xname);
! 531: return (error);
! 532: }
! 533: p = strchr(response, 'd');
! 534: if (p == NULL) {
! 535: uprintf(dfail, ss->sc_dev.dv_xname);
! 536: return (EIO);
! 537: }
! 538: ss->sio.scan_lines = atoi(p + 1);
! 539:
! 540: ss->sio.scan_window_size = ss->sio.scan_lines *
! 541: ((ss->sio.scan_pixels_per_line * ss->sio.scan_bits_per_pixel) / 8);
! 542:
! 543: return (0);
! 544: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ss_scanjet.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / scsi