Annotation of sys/scsi/ss.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ss.c,v 1.58 2006/12/21 02:05:46 krw Exp $ */
! 2: /* $NetBSD: ss.c,v 1.10 1996/05/05 19:52:55 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995, 1997 Kenneth Stailey. All rights reserved.
! 6: * modified for configurable scanner support by Joachim Koenig
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. All advertising materials mentioning features or use of this software
! 17: * must display the following acknowledgement:
! 18: * This product includes software developed by Kenneth Stailey.
! 19: * 4. The name of the author may not be used to endorse or promote products
! 20: * derived from this software without specific prior written permission.
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 32: */
! 33:
! 34: #include <sys/param.h>
! 35: #include <sys/systm.h>
! 36: #include <sys/fcntl.h>
! 37: #include <sys/errno.h>
! 38: #include <sys/ioctl.h>
! 39: #include <sys/malloc.h>
! 40: #include <sys/buf.h>
! 41: #include <sys/proc.h>
! 42: #include <sys/user.h>
! 43: #include <sys/device.h>
! 44: #include <sys/conf.h>
! 45: #include <sys/scanio.h>
! 46:
! 47: #include <scsi/scsi_all.h>
! 48: #include <scsi/scsi_scanner.h>
! 49: #include <scsi/scsiconf.h>
! 50: #include <scsi/ssvar.h>
! 51:
! 52: #include <scsi/ss_mustek.h>
! 53:
! 54: #define SSMODE(z) ( minor(z) & 0x03)
! 55: #define SSUNIT(z) ((minor(z) >> 4) )
! 56:
! 57: /*
! 58: * If the mode is 3 (e.g. minor = 3,7,11,15)
! 59: * then the device has been openned to set defaults
! 60: * This mode does NOT ALLOW I/O, only ioctls
! 61: */
! 62: #define MODE_REWIND 0
! 63: #define MODE_NONREWIND 1
! 64: #define MODE_CONTROL 3
! 65:
! 66: struct quirkdata {
! 67: char *name;
! 68: u_int quirks;
! 69: #define SS_Q_WINDOW_DESC_LEN 0x0001 /* needs special WDL */
! 70: #define SS_Q_BRIGHTNESS 0x0002 /* needs special value for brightness */
! 71: #define SS_Q_REV_BRIGHTNESS 0x0004 /* reverse brightness control in s/w */
! 72: #define SS_Q_THRESHOLD 0x0008 /* needs special value for threshold */
! 73: #define SS_Q_MONO_THRESHOLD 0x0010 /* same as SS_Q_THRESHOLD but only
! 74: * for monochrome image data */
! 75: #define SS_Q_CONTRAST 0x0020 /* needs special value for contrast */
! 76: #define SS_Q_REV_CONTRAST 0x0040 /* reverse contrast control in s/w */
! 77: #define SS_Q_HALFTONE 0x0080 /* uses non-zero halftone */
! 78: #define SS_Q_SET_RIF 0x0100 /* set RIF bit */
! 79: #define SS_Q_PADDING_TYPE 0x0200 /* does not truncate to byte boundary */
! 80: #define SS_Q_BIT_ORDERING 0x0400 /* needs non-zero bit ordering */
! 81: long window_descriptor_length;
! 82: u_int8_t brightness;
! 83: u_int8_t threshold;
! 84: u_int8_t contrast;
! 85: u_int8_t halftone_pattern[2];
! 86: int pad_type;
! 87: long bit_ordering;
! 88: u_int8_t scanner_type;
! 89: /*
! 90: * To enable additional scanner options, point vendor_unique_sw
! 91: * at a function that adds more stuff to the SET_WINDOW parameters.
! 92: */
! 93: int (*vendor_unique_sw)(struct ss_softc *, struct scan_io *,
! 94: struct scsi_set_window *, void *);
! 95: /*
! 96: * If the scanner requires use of GET_BUFFER_STATUS before READ
! 97: * it can be called from ss_minphys().
! 98: */
! 99: void (*special_minphys)(struct ss_softc *, struct buf *);
! 100:
! 101: /*
! 102: *
! 103: */
! 104: int (*compute_sizes)(void);
! 105: };
! 106:
! 107: struct ss_quirk_inquiry_pattern {
! 108: struct scsi_inquiry_pattern pattern;
! 109: struct quirkdata quirkdata;
! 110: };
! 111:
! 112: struct quirkdata ss_gen_quirks = {
! 113: "generic", 0, 0, 0, 0, 0,
! 114: {0, 0}, 0, 0, GENERIC_SCSI2,
! 115: NULL, NULL, NULL
! 116: };
! 117:
! 118: void ssstrategy(struct buf *);
! 119: void ssstart(void *);
! 120: void ssminphys(struct buf *);
! 121:
! 122: void ss_identify_scanner(struct ss_softc *, struct scsi_inquiry_data*);
! 123: int ss_set_window(struct ss_softc *, struct scan_io *);
! 124:
! 125: int ricoh_is410_sw(struct ss_softc *, struct scan_io *,
! 126: struct scsi_set_window *, void *);
! 127: int umax_uc630_sw(struct ss_softc *, struct scan_io *,
! 128: struct scsi_set_window *, void *);
! 129: #ifdef NOTYET /* for ADF support */
! 130: int fujitsu_m3096g_sw(struct ss_softc *, struct scan_io *,
! 131: struct scsi_set_window *, void *);
! 132: #endif
! 133:
! 134: void get_buffer_status(struct ss_softc *, struct buf *);
! 135:
! 136: /*
! 137: * WDL:
! 138: *
! 139: * Ricoh IS-50 & IS-410 insist on 320 (even it transfer len is less.)
! 140: * Ricoh FS-1 accepts 256 (I haven't tested other values.)
! 141: * UMAX UC-630 accepts 46 (I haven't tested other values.)
! 142: * Fujitsu M3096G wants 40 <= x <= 248 (tested OK at 40 & 64.)
! 143: */
! 144:
! 145: const struct ss_quirk_inquiry_pattern ss_quirk_patterns[] = {
! 146: {{T_SCANNER, T_FIXED,
! 147: "ULTIMA ", "AT3 1.60 ", " "}, {
! 148: "Ultima AT3",
! 149: SS_Q_HALFTONE |
! 150: SS_Q_PADDING_TYPE,
! 151: 0, 0, 0, 0, { 3, 0 }, 0, 0,
! 152: ULTIMA_AT3,
! 153: NULL, NULL, NULL
! 154: }},
! 155: {{T_SCANNER, T_FIXED,
! 156: "ULTIMA ", "A6000C PLUS ", " "}, {
! 157: "Ultima A6000C",
! 158: SS_Q_HALFTONE |
! 159: SS_Q_PADDING_TYPE,
! 160: 0, 0, 0, 0, { 3, 0 }, 0, 0,
! 161: ULTIMA_AC6000C,
! 162: NULL, NULL, NULL
! 163: }},
! 164: {{T_SCANNER, T_FIXED,
! 165: "RICOH ", "IS50 ", " "}, {
! 166: "Ricoh IS-50",
! 167: SS_Q_WINDOW_DESC_LEN |
! 168: SS_Q_REV_BRIGHTNESS |
! 169: SS_Q_THRESHOLD |
! 170: SS_Q_REV_CONTRAST |
! 171: SS_Q_HALFTONE |
! 172: SS_Q_BIT_ORDERING,
! 173: 320, 0, 0, 0, { 2, 0x0a }, 0, 7,
! 174: RICOH_IS50,
! 175: ricoh_is410_sw, get_buffer_status, NULL
! 176: }},
! 177: {{T_SCANNER, T_FIXED,
! 178: "RICOH ", "IS410 ", " "}, {
! 179: "Ricoh IS-410",
! 180: SS_Q_WINDOW_DESC_LEN |
! 181: SS_Q_THRESHOLD |
! 182: SS_Q_HALFTONE |
! 183: SS_Q_BIT_ORDERING,
! 184: 320, 0, 0, 0, { 2, 0x0a }, 0, 7,
! 185: RICOH_IS410,
! 186: ricoh_is410_sw, get_buffer_status, NULL
! 187: }},
! 188: {{T_SCANNER, T_FIXED, /* Ricoh IS-410 OEMed by IBM */
! 189: "IBM ", "2456-001 ", " "}, {
! 190: "IBM 2456",
! 191: SS_Q_WINDOW_DESC_LEN |
! 192: SS_Q_THRESHOLD |
! 193: SS_Q_HALFTONE |
! 194: SS_Q_BIT_ORDERING,
! 195: 320, 0, 0, 0, { 2, 0x0a }, 0, 7,
! 196: RICOH_IS410,
! 197: ricoh_is410_sw, get_buffer_status, NULL
! 198: }},
! 199: {{T_SCANNER, T_FIXED,
! 200: "UMAX ", "UC630 ", " "}, {
! 201: "UMAX UC-630",
! 202: SS_Q_WINDOW_DESC_LEN |
! 203: SS_Q_HALFTONE,
! 204: 0x2e, 0, 0, 0, { 0, 1 }, 0, 0,
! 205: UMAX_UC630,
! 206: umax_uc630_sw, NULL, NULL
! 207: }},
! 208: {{T_SCANNER, T_FIXED,
! 209: "UMAX ", "UG630 ", " "}, {
! 210: "UMAX UG-630",
! 211: SS_Q_WINDOW_DESC_LEN |
! 212: SS_Q_HALFTONE,
! 213: 0x2e, 0, 0, 0, { 0, 1 }, 0, 0,
! 214: UMAX_UG630,
! 215: umax_uc630_sw, NULL, NULL
! 216: }},
! 217: #ifdef NOTYET /* ADF version */
! 218: {{T_SCANNER, T_FIXED,
! 219: "FUJITSU ", "M3096Gm ", " "}, {
! 220: "Fujitsu M3096G",
! 221: SS_Q_WINDOW_DESC_LEN |
! 222: SS_Q_BRIGHTNESS |
! 223: SS_Q_MONO_THRESHOLD |
! 224: SS_Q_HALFTONE |
! 225: SS_Q_SET_RIF |
! 226: SS_Q_PADDING_TYPE,
! 227: 64, 0, 0, 0, { 0, 1 }, 0, 0,
! 228: FUJITSU_M3096G,
! 229: fujistsu_m3096g_sw, NULL, NULL
! 230: }},
! 231: #else /* flatbed-only version */
! 232: {{T_SCANNER, T_FIXED,
! 233: "FUJITSU ", "M3096Gm ", " "}, {
! 234: "Fujitsu M3096G",
! 235: SS_Q_BRIGHTNESS |
! 236: SS_Q_MONO_THRESHOLD |
! 237: SS_Q_CONTRAST |
! 238: SS_Q_HALFTONE |
! 239: SS_Q_PADDING_TYPE,
! 240: 0, 0, 0, 0, { 0, 1 }, 0, 0,
! 241: FUJITSU_M3096G,
! 242: NULL, NULL, NULL
! 243: }},
! 244: #endif
! 245: };
! 246:
! 247:
! 248: int ssmatch(struct device *, void *, void *);
! 249: void ssattach(struct device *, struct device *, void *);
! 250:
! 251: struct cfattach ss_ca = {
! 252: sizeof(struct ss_softc), ssmatch, ssattach
! 253: };
! 254:
! 255: struct cfdriver ss_cd = {
! 256: NULL, "ss", DV_DULL
! 257: };
! 258:
! 259: struct scsi_device ss_switch = {
! 260: NULL,
! 261: ssstart,
! 262: NULL,
! 263: NULL,
! 264: };
! 265:
! 266: const struct scsi_inquiry_pattern ss_patterns[] = {
! 267: {T_SCANNER, T_FIXED,
! 268: "", "", ""},
! 269: {T_SCANNER, T_REMOV,
! 270: "", "", ""},
! 271: {T_PROCESSOR, T_FIXED,
! 272: "HP ", "C1750A ", ""},
! 273: {T_PROCESSOR, T_FIXED,
! 274: "HP ", "C1790A ", ""},
! 275: {T_PROCESSOR, T_FIXED,
! 276: "HP ", "C2500A ", ""},
! 277: {T_PROCESSOR, T_FIXED,
! 278: "HP ", "C2570A ", ""},
! 279: {T_PROCESSOR, T_FIXED,
! 280: "HP ", "C2520A ", ""},
! 281: {T_PROCESSOR, T_FIXED,
! 282: "HP ", "C1130A ", ""},
! 283: {T_PROCESSOR, T_FIXED,
! 284: "HP ", "C5110A ", ""},
! 285: {T_PROCESSOR, T_FIXED,
! 286: "HP ", "C6290A ", ""},
! 287: {T_PROCESSOR, T_FIXED,
! 288: "HP ", "C5190A ", ""},
! 289: {T_PROCESSOR, T_FIXED,
! 290: "HP ", "C7190A ", ""},
! 291: {T_PROCESSOR, T_FIXED,
! 292: "HP ", "C6270A ", ""},
! 293: {T_PROCESSOR, T_FIXED,
! 294: "HP ", "C7670A ", ""},
! 295: };
! 296:
! 297: int
! 298: ssmatch(parent, match, aux)
! 299: struct device *parent;
! 300: void *match, *aux;
! 301: {
! 302: struct scsi_attach_args *sa = aux;
! 303: int priority;
! 304:
! 305: (void)scsi_inqmatch(sa->sa_inqbuf,
! 306: ss_patterns, sizeof(ss_patterns)/sizeof(ss_patterns[0]),
! 307: sizeof(ss_patterns[0]), &priority);
! 308: return (priority);
! 309: }
! 310:
! 311: /*
! 312: * The routine called by the low level scsi routine when it discovers
! 313: * A device suitable for this driver
! 314: * If it is a know special, call special attach routine to install
! 315: * special handlers into the ss_softc structure
! 316: */
! 317: void
! 318: ssattach(parent, self, aux)
! 319: struct device *parent, *self;
! 320: void *aux;
! 321: {
! 322: struct ss_softc *ss = (void *)self;
! 323: struct scsi_attach_args *sa = aux;
! 324: struct scsi_link *sc_link = sa->sa_sc_link;
! 325:
! 326: SC_DEBUG(sc_link, SDEV_DB2, ("ssattach:\n"));
! 327:
! 328: /*
! 329: * Store information needed to contact our base driver
! 330: */
! 331: ss->sc_link = sc_link;
! 332: sc_link->device = &ss_switch;
! 333: sc_link->device_softc = ss;
! 334: sc_link->openings = 1;
! 335:
! 336: if (!bcmp(sa->sa_inqbuf->vendor, "MUSTEK", 6))
! 337: mustek_attach(ss, sa);
! 338: else if (!bcmp(sa->sa_inqbuf->vendor, "HP ", 8))
! 339: scanjet_attach(ss, sa);
! 340: else
! 341: ss_identify_scanner(ss, sa->sa_inqbuf);
! 342:
! 343: /*
! 344: * populate the scanio struct with legal values
! 345: */
! 346: ss->sio.scan_width = 1200;
! 347: ss->sio.scan_height = 1200;
! 348: ss->sio.scan_x_resolution = 100;
! 349: ss->sio.scan_y_resolution = 100;
! 350: ss->sio.scan_x_origin = 0;
! 351: ss->sio.scan_y_origin = 0;
! 352: ss->sio.scan_brightness = 128;
! 353: ss->sio.scan_contrast = 128;
! 354: ss->sio.scan_quality = 100;
! 355: ss->sio.scan_image_mode = SIM_GRAYSCALE;
! 356:
! 357: /* XXX fill in the rest of the scan_io struct by calling the
! 358: compute_sizes routine */
! 359:
! 360: /*
! 361: * Set up the buf queue for this device
! 362: */
! 363: ss->buf_queue.b_active = 0;
! 364: ss->buf_queue.b_actf = 0;
! 365: ss->buf_queue.b_actb = &ss->buf_queue.b_actf;
! 366: }
! 367:
! 368: void
! 369: ss_identify_scanner(ss, inqbuf)
! 370: struct ss_softc *ss;
! 371: struct scsi_inquiry_data *inqbuf;
! 372: {
! 373: const struct ss_quirk_inquiry_pattern *finger;
! 374: int priority;
! 375: /*
! 376: * look for non-standard scanners with help of the quirk table
! 377: * and install functions for special handling
! 378: */
! 379: finger = (const struct ss_quirk_inquiry_pattern *)scsi_inqmatch(inqbuf,
! 380: ss_quirk_patterns,
! 381: sizeof(ss_quirk_patterns)/sizeof(ss_quirk_patterns[0]),
! 382: sizeof(ss_quirk_patterns[0]), &priority);
! 383: if (priority != 0) {
! 384: ss->quirkdata = &finger->quirkdata;
! 385: if (ss->quirkdata->special_minphys != NULL) {
! 386: ss->special.minphys = ss->quirkdata->special_minphys;
! 387: }
! 388: ss->sio.scan_scanner_type = ss->quirkdata->scanner_type;
! 389: printf("\n%s: %s\n", ss->sc_dev.dv_xname, ss->quirkdata->name);
! 390: } else {
! 391: printf("\n%s: generic scanner\n", ss->sc_dev.dv_xname);
! 392: bzero(&ss_gen_quirks, sizeof(ss_gen_quirks));
! 393: ss->quirkdata = &ss_gen_quirks;
! 394: ss->sio.scan_scanner_type = GENERIC_SCSI2;
! 395: }
! 396: }
! 397:
! 398: /*
! 399: * open the device.
! 400: */
! 401: int
! 402: ssopen(dev, flag, mode, p)
! 403: dev_t dev;
! 404: int flag;
! 405: int mode;
! 406: struct proc *p;
! 407: {
! 408: int unit;
! 409: u_int ssmode;
! 410: int error = 0;
! 411: struct ss_softc *ss;
! 412: struct scsi_link *sc_link;
! 413:
! 414: unit = SSUNIT(dev);
! 415: if (unit >= ss_cd.cd_ndevs)
! 416: return (ENXIO);
! 417: ss = ss_cd.cd_devs[unit];
! 418: if (!ss)
! 419: return (ENXIO);
! 420:
! 421: ssmode = SSMODE(dev);
! 422: sc_link = ss->sc_link;
! 423:
! 424: SC_DEBUG(sc_link, SDEV_DB1, ("open: dev=0x%x (unit %d (of %d))\n", dev,
! 425: unit, ss_cd.cd_ndevs));
! 426:
! 427: if (sc_link->flags & SDEV_OPEN) {
! 428: printf("%s: already open\n", ss->sc_dev.dv_xname);
! 429: return (EBUSY);
! 430: }
! 431:
! 432: /*
! 433: * Catch any unit attention errors.
! 434: *
! 435: * SCSI_IGNORE_MEDIA_CHANGE: when you have an ADF, some scanners
! 436: * consider paper to be a changeable media
! 437: *
! 438: */
! 439: error = scsi_test_unit_ready(sc_link, TEST_READY_RETRIES,
! 440: SCSI_IGNORE_MEDIA_CHANGE | SCSI_IGNORE_ILLEGAL_REQUEST |
! 441: (ssmode == MODE_CONTROL ? SCSI_IGNORE_NOT_READY : 0));
! 442: if (error)
! 443: goto bad;
! 444:
! 445: sc_link->flags |= SDEV_OPEN; /* unit attn are now errors */
! 446:
! 447: /*
! 448: * If the mode is 3 (e.g. minor = 3,7,11,15)
! 449: * then the device has been opened to set defaults
! 450: * This mode does NOT ALLOW I/O, only ioctls
! 451: */
! 452: if (ssmode == MODE_CONTROL)
! 453: return (0);
! 454:
! 455: SC_DEBUG(sc_link, SDEV_DB2, ("open complete\n"));
! 456: return (0);
! 457:
! 458: bad:
! 459: sc_link->flags &= ~SDEV_OPEN;
! 460: return (error);
! 461: }
! 462:
! 463: /*
! 464: * close the device.. only called if we are the LAST
! 465: * occurence of an open device
! 466: */
! 467: int
! 468: ssclose(dev, flag, mode, p)
! 469: dev_t dev;
! 470: int flag;
! 471: int mode;
! 472: struct proc *p;
! 473: {
! 474: struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(dev)];
! 475: int error;
! 476:
! 477: SC_DEBUG(ss->sc_link, SDEV_DB1, ("closing\n"));
! 478:
! 479: if (SSMODE(dev) == MODE_REWIND) {
! 480: if (ss->special.rewind_scanner) {
! 481: /* call special handler to rewind/abort scan */
! 482: error = (ss->special.rewind_scanner)(ss);
! 483: if (error)
! 484: return (error);
! 485: } else {
! 486: /* XXX add code to restart a SCSI2 scanner, if any */
! 487: }
! 488: ss->sio.scan_window_size = 0;
! 489: ss->flags &= ~SSF_TRIGGERED;
! 490: }
! 491: ss->sc_link->flags &= ~SDEV_OPEN;
! 492:
! 493: return (0);
! 494: }
! 495:
! 496: /*
! 497: * trim the size of the transfer if needed,
! 498: * called by physio
! 499: * basically the smaller of our min and the scsi driver's
! 500: * minphys
! 501: */
! 502: void
! 503: ssminphys(bp)
! 504: struct buf *bp;
! 505: {
! 506: struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(bp->b_dev)];
! 507:
! 508: (ss->sc_link->adapter->scsi_minphys)(bp);
! 509:
! 510: /*
! 511: * trim the transfer further for special devices this is
! 512: * because some scanners only read multiples of a line at a
! 513: * time, also some cannot disconnect, so the read must be
! 514: * short enough to happen quickly
! 515: */
! 516: if (ss->special.minphys)
! 517: (ss->special.minphys)(ss, bp);
! 518: }
! 519:
! 520: /*
! 521: * Do a read on a device for a user process.
! 522: * Prime scanner at start of read, check uio values, call ssstrategy
! 523: * via physio for the actual transfer.
! 524: */
! 525: int
! 526: ssread(dev, uio, flag)
! 527: dev_t dev;
! 528: struct uio *uio;
! 529: int flag;
! 530: {
! 531: struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(dev)];
! 532: int error;
! 533:
! 534: /* if the scanner has not yet been started, do it now */
! 535: if (!(ss->flags & SSF_TRIGGERED)) {
! 536: if (ss->special.trigger_scanner) {
! 537: error = (ss->special.trigger_scanner)(ss);
! 538: if (error)
! 539: return (error);
! 540: } else {
! 541: struct scsi_start_stop trigger_cmd;
! 542: bzero(&trigger_cmd, sizeof(trigger_cmd));
! 543: trigger_cmd.opcode = START_STOP;
! 544: trigger_cmd.how = SSS_START;
! 545: scsi_scsi_cmd(ss->sc_link,
! 546: (struct scsi_generic *)&trigger_cmd,
! 547: sizeof(trigger_cmd), 0, 0, 4, 5000, NULL, 0);
! 548: }
! 549: ss->flags |= SSF_TRIGGERED;
! 550: }
! 551:
! 552: return (physio(ssstrategy, NULL, dev, B_READ, ssminphys, uio));
! 553: }
! 554:
! 555: /*
! 556: * Actually translate the requested transfer into one the physical
! 557: * driver can understand The transfer is described by a buf and will
! 558: * include only one physical transfer.
! 559: */
! 560: void
! 561: ssstrategy(bp)
! 562: struct buf *bp;
! 563: {
! 564: struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(bp->b_dev)];
! 565: struct buf *dp;
! 566: int s;
! 567:
! 568: SC_DEBUG(ss->sc_link, SDEV_DB2, ("ssstrategy: %ld bytes @ blk %d\n",
! 569: bp->b_bcount, bp->b_blkno));
! 570:
! 571: if (bp->b_bcount > ss->sio.scan_window_size)
! 572: bp->b_bcount = ss->sio.scan_window_size;
! 573:
! 574: /*
! 575: * If it's a null transfer, return immediately
! 576: */
! 577: if (bp->b_bcount == 0)
! 578: goto done;
! 579:
! 580: s = splbio();
! 581:
! 582: /*
! 583: * Place it in the queue of activities for this scanner
! 584: * at the end (a bit silly because we only have on user..)
! 585: * (but it could fork() or dup())
! 586: */
! 587: dp = &ss->buf_queue;
! 588: bp->b_actf = NULL;
! 589: bp->b_actb = dp->b_actb;
! 590: *dp->b_actb = bp;
! 591: dp->b_actb = &bp->b_actf;
! 592:
! 593: /*
! 594: * Tell the device to get going on the transfer if it's
! 595: * not doing anything, otherwise just wait for completion
! 596: * (All a bit silly if we're only allowing 1 open but..)
! 597: */
! 598: ssstart(ss);
! 599:
! 600: splx(s);
! 601: return;
! 602:
! 603: done:
! 604: /*
! 605: * Correctly set the buf to indicate a completed xfer
! 606: */
! 607: bp->b_resid = bp->b_bcount;
! 608: s = splbio();
! 609: biodone(bp);
! 610: splx(s);
! 611: }
! 612:
! 613: /*
! 614: * ssstart looks to see if there is a buf waiting for the device
! 615: * and that the device is not already busy. If both are true,
! 616: * It dequeues the buf and creates a scsi command to perform the
! 617: * transfer required. The transfer request will call scsi_done
! 618: * on completion, which will in turn call this routine again
! 619: * so that the next queued transfer is performed.
! 620: * The bufs are queued by the strategy routine (ssstrategy)
! 621: *
! 622: * This routine is also called after other non-queued requests
! 623: * have been made of the scsi driver, to ensure that the queue
! 624: * continues to be drained.
! 625: * ssstart() is called at splbio
! 626: */
! 627: void
! 628: ssstart(v)
! 629: void *v;
! 630: {
! 631: struct ss_softc *ss = v;
! 632: struct scsi_link *sc_link = ss->sc_link;
! 633: struct buf *bp, *dp;
! 634: struct scsi_r_scanner read_cmd;
! 635: int flags;
! 636:
! 637: SC_DEBUG(sc_link, SDEV_DB2, ("ssstart\n"));
! 638: /*
! 639: * See if there is a buf to do and we are not already
! 640: * doing one
! 641: */
! 642: while (sc_link->openings > 0) {
! 643: /* if a special awaits, let it proceed first */
! 644: if (sc_link->flags & SDEV_WAITING) {
! 645: sc_link->flags &= ~SDEV_WAITING;
! 646: wakeup((caddr_t)sc_link);
! 647: return;
! 648: }
! 649:
! 650: /*
! 651: * See if there is a buf with work for us to do..
! 652: */
! 653: dp = &ss->buf_queue;
! 654: if ((bp = dp->b_actf) == NULL)
! 655: return;
! 656: if ((dp = bp->b_actf) != NULL)
! 657: dp->b_actb = bp->b_actb;
! 658: else
! 659: ss->buf_queue.b_actb = bp->b_actb;
! 660: *bp->b_actb = dp;
! 661:
! 662: if (ss->special.read) {
! 663: (ss->special.read)(ss, bp);
! 664: } else {
! 665: /* generic scsi2 scanner read */
! 666: bzero(&read_cmd, sizeof(read_cmd));
! 667: read_cmd.opcode = READ_BIG;
! 668: _lto3b(bp->b_bcount, read_cmd.len);
! 669: flags = SCSI_DATA_IN;
! 670: /*
! 671: * go ask the adapter to do all this for us
! 672: */
! 673: if (scsi_scsi_cmd(sc_link, (struct scsi_generic *)
! 674: &read_cmd, sizeof(read_cmd), (u_char *) bp->b_data,
! 675: bp->b_bcount, 0, 100000, bp, flags | SCSI_NOSLEEP))
! 676: printf("%s: not queued\n", ss->sc_dev.dv_xname);
! 677: }
! 678: }
! 679: }
! 680:
! 681: /*
! 682: * Perform special action on behalf of the user;
! 683: * knows about the internals of this device
! 684: */
! 685: int
! 686: ssioctl(dev, cmd, addr, flag, p)
! 687: dev_t dev;
! 688: u_long cmd;
! 689: caddr_t addr;
! 690: int flag;
! 691: struct proc *p;
! 692: {
! 693: struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(dev)];
! 694: int error = 0;
! 695: struct scan_io *sio;
! 696:
! 697: switch (cmd) {
! 698: case SCIOCGET:
! 699: /* call special handler, if any */
! 700: if (ss->special.get_params) {
! 701: error = (ss->special.get_params)(ss);
! 702: if (error)
! 703: return (error);
! 704: }
! 705: bcopy(&ss->sio, addr, sizeof(struct scan_io));
! 706: break;
! 707: case SCIOCSET:
! 708: sio = (struct scan_io *)addr;
! 709:
! 710: /* call special handler, if any */
! 711: if (ss->special.set_params) {
! 712: error = (ss->special.set_params)(ss, sio);
! 713: if (error)
! 714: return (error);
! 715: } else {
! 716: /* XXX add routine to validate parameters */
! 717: ss_set_window(ss, sio);
! 718: }
! 719: break;
! 720: case SCIOCRESTART:
! 721: /* call special handler, if any */
! 722: if (ss->special.rewind_scanner ) {
! 723: error = (ss->special.rewind_scanner)(ss);
! 724: if (error)
! 725: return (error);
! 726: } else
! 727: /* XXX add code for SCSI2 scanner, if any */
! 728: return (EOPNOTSUPP);
! 729: ss->flags &= ~SSF_TRIGGERED;
! 730: break;
! 731: case SCIOC_USE_ADF:
! 732: /* XXX add Automatic Document Feeder Support */
! 733: return (EOPNOTSUPP);
! 734: default:
! 735: if (SSMODE(dev) != MODE_CONTROL)
! 736: return (ENOTTY);
! 737: return (scsi_do_ioctl(ss->sc_link, dev, cmd, addr,
! 738: flag, p));
! 739: }
! 740: return (error);
! 741: }
! 742:
! 743: int
! 744: ss_set_window(ss, sio)
! 745: struct ss_softc *ss;
! 746: struct scan_io *sio;
! 747: {
! 748: struct scsi_set_window window_cmd;
! 749: struct {
! 750: struct scsi_window_data window_data;
! 751: /* vendor_unique must provide enough space for worst case
! 752: * (currently Ricoh IS-410.) 40 + 280 = 320 which is the size
! 753: * of its window descriptor length
! 754: */
! 755: u_int8_t vendor_unique[280];
! 756: } wd;
! 757: #define window_data wd.window_data
! 758: #define vendor_unique wd.vendor_unique
! 759: struct scsi_link *sc_link = ss->sc_link;
! 760:
! 761: /*
! 762: * The CDB for SET WINDOW goes in here.
! 763: * The two structures that follow are sent via data out.
! 764: */
! 765: bzero(&window_cmd, sizeof(window_cmd));
! 766: window_cmd.opcode = SET_WINDOW;
! 767: _lto3l(sizeof(window_data), window_cmd.len);
! 768:
! 769: bzero(&window_data, sizeof(window_data));
! 770: if (ss->quirkdata->quirks & SS_Q_WINDOW_DESC_LEN)
! 771: _lto2l(ss->quirkdata->window_descriptor_length,
! 772: window_data.window_desc_len);
! 773: else
! 774: _lto2l(40L, window_data.window_desc_len);
! 775:
! 776: /* start of SET_WINDOW parameter block */
! 777:
! 778: /* leave window id at zero */
! 779: /* leave auto bit at zero */
! 780: _lto2l(sio->scan_x_resolution, window_data.x_res);
! 781: _lto2l(sio->scan_y_resolution, window_data.y_res);
! 782: _lto4l(sio->scan_x_origin, window_data.x_org);
! 783: _lto4l(sio->scan_y_origin, window_data.y_org);
! 784: _lto4l(sio->scan_width, window_data.width);
! 785: _lto4l(sio->scan_height, window_data.length);
! 786:
! 787: if (ss->quirkdata->quirks & SS_Q_REV_BRIGHTNESS)
! 788: window_data.brightness = 256 - sio->scan_brightness;
! 789: else if (ss->quirkdata->quirks & SS_Q_BRIGHTNESS)
! 790: window_data.brightness = ss->quirkdata->brightness;
! 791: else
! 792: window_data.brightness = sio->scan_brightness;
! 793:
! 794: /*
! 795: * threshold: Default is to follow brightness.
! 796: * If SS_Q_MONO_THRESHOLD is set then the quirkdata contains a special
! 797: * value to be used instead of default when image data is monochrome.
! 798: * Otherwise if SS_Q_THRESHOLD is set then the quirkdata contains
! 799: * the threshold to always use.
! 800: * Both SS_Q_MONO_THRESHOLD and SS_Q_THRESHOLD should not be set at
! 801: * the same time.
! 802: */
! 803: if (ss->quirkdata->quirks & SS_Q_MONO_THRESHOLD) {
! 804: if (sio->scan_image_mode == SIM_BINARY_MONOCHROME ||
! 805: sio->scan_image_mode == SIM_DITHERED_MONOCHROME)
! 806: window_data.threshold = ss->quirkdata->threshold;
! 807: else
! 808: window_data.threshold = sio->scan_brightness;
! 809: } else if (ss->quirkdata->quirks & SS_Q_THRESHOLD)
! 810: window_data.threshold = ss->quirkdata->threshold;
! 811: else
! 812: window_data.threshold = sio->scan_brightness;
! 813:
! 814: if (ss->quirkdata->quirks & SS_Q_REV_CONTRAST)
! 815: window_data.contrast = 256 - sio->scan_contrast;
! 816: else if (ss->quirkdata->quirks & SS_Q_CONTRAST)
! 817: window_data.contrast = ss->quirkdata->contrast;
! 818: else
! 819: window_data.contrast = sio->scan_contrast;
! 820:
! 821: switch (sio->scan_image_mode) {
! 822: case SIM_RED:
! 823: case SIM_GREEN:
! 824: case SIM_BLUE:
! 825: window_data.image_comp = SIM_GRAYSCALE;
! 826: break;
! 827: default:
! 828: window_data.image_comp = sio->scan_image_mode;
! 829: }
! 830:
! 831: window_data.bits_per_pixel = sio->scan_bits_per_pixel;
! 832:
! 833: if (ss->quirkdata->quirks & SS_Q_HALFTONE) {
! 834: window_data.halftone_pattern[0] =
! 835: ss->quirkdata->halftone_pattern[0];
! 836: window_data.halftone_pattern[1] =
! 837: ss->quirkdata->halftone_pattern[1];
! 838: } /* else leave halftone set to zero. */
! 839:
! 840: if (ss->quirkdata->quirks & SS_Q_SET_RIF)
! 841: window_data.rif = 1;
! 842:
! 843: if (ss->quirkdata->quirks & SS_Q_PADDING_TYPE)
! 844: window_data.pad_type = ss->quirkdata->pad_type;
! 845: else
! 846: window_data.pad_type = 3; /* 3 = truncate to byte boundary */
! 847:
! 848: if (ss->quirkdata->quirks & SS_Q_BIT_ORDERING)
! 849: _lto2l(ss->quirkdata->bit_ordering, window_data.bit_ordering);
! 850: /* else leave bit_ordering set to zero. */
! 851:
! 852: /* leave compression type & argument set to zero. */
! 853:
! 854: #undef window_data
! 855:
! 856: if (ss->quirkdata->vendor_unique_sw != NULL)
! 857: return ((*ss->quirkdata->vendor_unique_sw)(ss, sio,
! 858: &window_cmd, (void *)&wd));
! 859: else
! 860: /* send the command to the scanner */
! 861: return (scsi_scsi_cmd(sc_link,
! 862: (struct scsi_generic *)&window_cmd,
! 863: sizeof(window_cmd), (u_char *) &wd.window_data,
! 864: (ss->quirkdata->quirks & SS_Q_WINDOW_DESC_LEN) ?
! 865: ss->quirkdata->window_descriptor_length : 40,
! 866: 4, 5000, NULL, SCSI_DATA_OUT));
! 867: }
! 868:
! 869: int
! 870: ricoh_is410_sw(ss, sio, wcmd, vwd)
! 871: struct ss_softc *ss;
! 872: struct scan_io *sio;
! 873: struct scsi_set_window *wcmd;
! 874: void *vwd;
! 875: {
! 876: struct ricoh_is410_window_data {
! 877: struct scsi_window_data window_data;
! 878: u_int8_t res1;
! 879: u_int8_t res2;
! 880: u_int mrif:1; /* reverse image format (grayscale negative) */
! 881: u_int filtering:3;
! 882: u_int gamma_id:4;
! 883: } *rwd = (struct ricoh_is410_window_data*)vwd;
! 884: struct scsi_link *sc_link = ss->sc_link;
! 885:
! 886: rwd->mrif = 1; /* force grayscale to match PGM */
! 887:
! 888: /* send the command to the scanner */
! 889: return (scsi_scsi_cmd(sc_link, (struct scsi_generic *)wcmd,
! 890: sizeof(struct scsi_set_window), (u_char *)rwd,
! 891: sizeof(struct ricoh_is410_window_data), 4, 5000, NULL,
! 892: SCSI_DATA_OUT));
! 893: }
! 894:
! 895: int
! 896: umax_uc630_sw(ss, sio, wcmd, vwd)
! 897: struct ss_softc *ss;
! 898: struct scan_io *sio;
! 899: struct scsi_set_window *wcmd;
! 900: void *vwd;
! 901: {
! 902: struct umax_uc630_window_data {
! 903: struct scsi_window_data window_data;
! 904: u_int8_t speed;
! 905: u_int8_t select_color;
! 906: u_int8_t highlight;
! 907: u_int8_t shadow;
! 908: u_int8_t paper_length[2];
! 909: } *uwd = (struct umax_uc630_window_data*)vwd;
! 910: struct scsi_link *sc_link = ss->sc_link;
! 911:
! 912: uwd->speed = 1; /* speed: fastest speed that doesn't smear */
! 913: switch (sio->scan_image_mode) { /* UMAX has three-pass color. */
! 914: case SIM_RED: /* This selects which filter to use. */
! 915: uwd->select_color = 0x80;
! 916: break;
! 917: case SIM_GREEN:
! 918: uwd->select_color = 0x40;
! 919: break;
! 920: case SIM_BLUE:
! 921: uwd->select_color = 0x20;
! 922: break;
! 923: }
! 924: uwd->highlight = 50; /* 50 = highest; 0 = lowest */
! 925: /* leave shadow set to zero. */
! 926: /* XXX paper length is for ADF */
! 927:
! 928: /* send the command to the scanner */
! 929: return (scsi_scsi_cmd(sc_link, (struct scsi_generic *)wcmd,
! 930: sizeof(struct scsi_set_window), (u_char *)uwd,
! 931: sizeof(struct umax_uc630_window_data), 4, 5000, NULL,
! 932: SCSI_DATA_OUT));
! 933: }
! 934:
! 935: #ifdef NOTYET /* for ADF support */
! 936: int
! 937: fujitsu_m3096g_sw(ss, sio, wcmd, vwd)
! 938: struct ss_softc *ss;
! 939: struct scan_io *sio;
! 940: struct scsi_set_window *wcmd;
! 941: void *vwd;
! 942: {
! 943: struct fujitsu_m3096g_window_data {
! 944: struct scsi_window_data window_data;
! 945: u_int8_t id;
! 946: u_int8_t res1;
! 947: u_int8_t outline;
! 948: u_int8_t emphasis;
! 949: u_int8_t mixed;
! 950: u_int8_t mirroring;
! 951: u_int8_t res2[5];
! 952: u_int8_t subwindow_list[2];
! 953: u_int paper_size_std:2;
! 954: u_int res3:1;
! 955: u_int paper_orientaton:1;
! 956: u_int paper_size_type:4;
! 957: /* defines for Paper Size Type: */
! 958: #define FUJITSU_PST_A3 0x03
! 959: #define FUJITSU_PST_A4 0x04
! 960: #define FUJITSU_PST_A5 0x05
! 961: #define FUJITSU_PST_DOUBLE_LETTER 0x06
! 962: #define FUJITSU_PST_LETTER 0x07
! 963: #define FUJITSU_PST_B4 0x0C
! 964: #define FUJITSU_PST_B5 0x0D
! 965: #define FUJITSU_PST_LEGAL 0x0F
! 966: u_int8_t paper_width_x[4];
! 967: u_int8_t paper_width_y[4];
! 968: u_int8_t res4[2];
! 969: } *fwd = (struct fujitsu_m3096g_window_data*)vwd;
! 970: struct scsi_link *sc_link = ss->sc_link;
! 971:
! 972: /* send the command to the scanner */
! 973: return (scsi_scsi_cmd(sc_link, (struct scsi_generic *)wcmd,
! 974: sizeof(struct scsi_set_window), (u_char *)fwd,
! 975: sizeof(struct fujitsu_m3096g_window_data), 4, 5000, NULL,
! 976: SCSI_DATA_OUT));
! 977: }
! 978: #endif
! 979:
! 980: void
! 981: get_buffer_status(ss, bp)
! 982: struct ss_softc *ss;
! 983: struct buf *bp;
! 984: {
! 985: struct scsi_get_buffer_status gbs_cmd;
! 986: struct scsi_link *sc_link = ss->sc_link;
! 987: struct {
! 988: u_int8_t stat_len[3];
! 989: u_int8_t res1;
! 990: u_int8_t window_id;
! 991: u_int8_t res2;
! 992: u_int8_t tgt_accept_buf_len[3];
! 993: u_int8_t tgt_send_buf_len[3];
! 994: } buf_sz_retn;
! 995: int flags;
! 996:
! 997: bzero(&gbs_cmd, sizeof(gbs_cmd));
! 998: gbs_cmd.opcode = GET_BUFFER_STATUS;
! 999: _lto2b(12, gbs_cmd.len);
! 1000: flags = SCSI_DATA_IN;
! 1001:
! 1002: if (scsi_scsi_cmd(sc_link, (struct scsi_generic *) &gbs_cmd,
! 1003: sizeof(gbs_cmd), (u_char *) &buf_sz_retn, sizeof(buf_sz_retn),
! 1004: 0, 100000, bp, flags | SCSI_NOSLEEP)) {
! 1005: printf("%s: not queued\n", ss->sc_dev.dv_xname);
! 1006: }
! 1007: bp->b_bcount = MIN(_3btol(buf_sz_retn.tgt_send_buf_len), bp->b_bcount);
! 1008: }
! 1009:
! 1010: #ifdef NOTYET
! 1011: int
! 1012: umax_compute_sizes(ss)
! 1013: struct ss_softc *ss;
! 1014: {
! 1015: ss->sio.scan_lines = ;
! 1016: ss->sio.scan_window_size = ;
! 1017: }
! 1018:
! 1019: int
! 1020: calc_umax_row_len(dpi, ww)
! 1021: int dpi;
! 1022: int ww;
! 1023: {
! 1024: int st[301];
! 1025: int i;
! 1026: int rowB = 0;
! 1027:
! 1028: for (i = 1; i <= 300; i++)
! 1029: st[i] = 1;
! 1030:
! 1031: for (i = 1; i <= 300 - dpi; i++)
! 1032: st[i * 300 / (300 - dpi)] = 0;
! 1033:
! 1034: for (i = 1; i <= (ww % 1200) / 4; i++) {
! 1035: if (st[i])
! 1036: rowB++;
! 1037: }
! 1038:
! 1039: return ((ww / 1200) * dpi + rowB);
! 1040: }
! 1041: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ss.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / scsi