1 /* $NetBSD: ss.c,v 1.53 2004/08/27 20:37:29 bouyer Exp $ */ 2 3 /* 4 * Copyright (c) 1995 Kenneth Stailey. All rights reserved. 5 * modified for configurable scanner support by Joachim Koenig 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 #include <sys/cdefs.h> 34 __KERNEL_RCSID(0, "$NetBSD: ss.c,v 1.53 2004/08/27 20:37:29 bouyer Exp $"); 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/fcntl.h> 39 #include <sys/errno.h> 40 #include <sys/ioctl.h> 41 #include <sys/malloc.h> 42 #include <sys/buf.h> 43 #include <sys/proc.h> 44 #include <sys/user.h> 45 #include <sys/device.h> 46 #include <sys/conf.h> 47 #include <sys/vnode.h> 48 #include <sys/scanio.h> 49 50 #include <dev/scsipi/scsi_all.h> 51 #include <dev/scsipi/scsipi_all.h> 52 #include <dev/scsipi/scsi_scanner.h> 53 #include <dev/scsipi/scsiconf.h> 54 #include <dev/scsipi/ssvar.h> 55 56 #include <dev/scsipi/ss_mustek.h> 57 58 #define SSMODE(z) ( minor(z) & 0x03) 59 #define SSUNIT(z) ((minor(z) >> 4) ) 60 #define SSNMINOR 16 61 62 /* 63 * If the mode is 3 (e.g. minor = 3,7,11,15) 64 * then the device has been openned to set defaults 65 * This mode does NOT ALLOW I/O, only ioctls 66 */ 67 #define MODE_REWIND 0 68 #define MODE_NONREWIND 1 69 #define MODE_CONTROL 3 70 71 static int ssmatch(struct device *, struct cfdata *, void *); 72 static void ssattach(struct device *, struct device *, void *); 73 static int ssdetach(struct device *self, int flags); 74 static int ssactivate(struct device *self, enum devact act); 75 76 CFATTACH_DECL(ss, sizeof(struct ss_softc), 77 ssmatch, ssattach, ssdetach, ssactivate); 78 79 extern struct cfdriver ss_cd; 80 81 static dev_type_open(ssopen); 82 static dev_type_close(ssclose); 83 static dev_type_read(ssread); 84 static dev_type_ioctl(ssioctl); 85 86 const struct cdevsw ss_cdevsw = { 87 ssopen, ssclose, ssread, nowrite, ssioctl, 88 nostop, notty, nopoll, nommap, nokqfilter, 89 }; 90 91 static void ssstrategy(struct buf *); 92 static void ssstart(struct scsipi_periph *); 93 static void ssminphys(struct buf *); 94 95 static const struct scsipi_periphsw ss_switch = { 96 NULL, 97 ssstart, 98 NULL, 99 NULL, 100 }; 101 102 static const struct scsipi_inquiry_pattern ss_patterns[] = { 103 {T_SCANNER, T_FIXED, 104 "", "", ""}, 105 {T_SCANNER, T_REMOV, 106 "", "", ""}, 107 {T_PROCESSOR, T_FIXED, 108 "HP ", "C1130A ", ""}, 109 {T_PROCESSOR, T_FIXED, 110 "HP ", "C1750A ", ""}, 111 {T_PROCESSOR, T_FIXED, 112 "HP ", "C2500A ", ""}, 113 {T_PROCESSOR, T_FIXED, 114 "HP ", "C2520A ", ""}, 115 {T_PROCESSOR, T_FIXED, 116 "HP ", "C5110A ", ""}, 117 {T_PROCESSOR, T_FIXED, 118 "HP ", "C7670A ", ""}, 119 {T_PROCESSOR, T_FIXED, 120 "HP ", "", ""}, 121 }; 122 123 static int 124 ssmatch(struct device *parent, struct cfdata *match, void *aux) 125 { 126 struct scsipibus_attach_args *sa = aux; 127 int priority; 128 129 (void)scsipi_inqmatch(&sa->sa_inqbuf, 130 (caddr_t)ss_patterns, sizeof(ss_patterns) / sizeof(ss_patterns[0]), 131 sizeof(ss_patterns[0]), &priority); 132 return (priority); 133 } 134 135 /* 136 * The routine called by the low level scsi routine when it discovers 137 * A device suitable for this driver 138 * If it is a know special, call special attach routine to install 139 * special handlers into the ss_softc structure 140 */ 141 static void 142 ssattach(struct device *parent, struct device *self, void *aux) 143 { 144 struct ss_softc *ss = (void *)self; 145 struct scsipibus_attach_args *sa = aux; 146 struct scsipi_periph *periph = sa->sa_periph; 147 148 SC_DEBUG(periph, SCSIPI_DB2, ("ssattach: ")); 149 150 ss->flags |= SSF_AUTOCONF; 151 152 /* 153 * Store information needed to contact our base driver 154 */ 155 ss->sc_periph = periph; 156 periph->periph_dev = &ss->sc_dev; 157 periph->periph_switch = &ss_switch; 158 159 printf("\n"); 160 161 /* 162 * Set up the buf queue for this device 163 */ 164 bufq_alloc(&ss->buf_queue, BUFQ_FCFS); 165 166 callout_init(&ss->sc_callout); 167 168 /* 169 * look for non-standard scanners with help of the quirk table 170 * and install functions for special handling 171 */ 172 SC_DEBUG(periph, SCSIPI_DB2, ("ssattach:\n")); 173 if (memcmp(sa->sa_inqbuf.vendor, "MUSTEK", 6) == 0) 174 mustek_attach(ss, sa); 175 if (memcmp(sa->sa_inqbuf.vendor, "HP ", 8) == 0 && 176 memcmp(sa->sa_inqbuf.product, "ScanJet 5300C", 13) != 0) 177 scanjet_attach(ss, sa); 178 if (ss->special == NULL) { 179 /* XXX add code to restart a SCSI2 scanner, if any */ 180 } 181 182 ss->flags &= ~SSF_AUTOCONF; 183 } 184 185 static int 186 ssdetach(struct device *self, int flags) 187 { 188 struct ss_softc *ss = (struct ss_softc *) self; 189 struct buf *bp; 190 int s, cmaj, mn; 191 192 /* locate the major number */ 193 cmaj = cdevsw_lookup_major(&ss_cdevsw); 194 195 /* kill any pending restart */ 196 callout_stop(&ss->sc_callout); 197 198 s = splbio(); 199 200 /* Kill off any queued buffers. */ 201 while ((bp = BUFQ_GET(&ss->buf_queue)) != NULL) { 202 bp->b_error = EIO; 203 bp->b_flags |= B_ERROR; 204 bp->b_resid = bp->b_bcount; 205 biodone(bp); 206 } 207 208 bufq_free(&ss->buf_queue); 209 210 /* Kill off any pending commands. */ 211 scsipi_kill_pending(ss->sc_periph); 212 213 splx(s); 214 215 /* Nuke the vnodes for any open instances */ 216 mn = SSUNIT(self->dv_unit); 217 vdevgone(cmaj, mn, mn+SSNMINOR-1, VCHR); 218 219 return (0); 220 } 221 222 static int 223 ssactivate(struct device *self, enum devact act) 224 { 225 int rv = 0; 226 227 switch (act) { 228 case DVACT_ACTIVATE: 229 rv = EOPNOTSUPP; 230 break; 231 232 case DVACT_DEACTIVATE: 233 /* 234 * Nothing to do; we key off the device's DVF_ACTIVE. 235 */ 236 break; 237 } 238 return (rv); 239 } 240 241 /* 242 * open the device. 243 */ 244 static int 245 ssopen(dev_t dev, int flag, int mode, struct proc *p) 246 { 247 int unit; 248 u_int ssmode; 249 int error; 250 struct ss_softc *ss; 251 struct scsipi_periph *periph; 252 struct scsipi_adapter *adapt; 253 254 unit = SSUNIT(dev); 255 if (unit >= ss_cd.cd_ndevs) 256 return (ENXIO); 257 ss = ss_cd.cd_devs[unit]; 258 if (!ss) 259 return (ENXIO); 260 261 if ((ss->sc_dev.dv_flags & DVF_ACTIVE) == 0) 262 return (ENODEV); 263 264 ssmode = SSMODE(dev); 265 266 periph = ss->sc_periph; 267 adapt = periph->periph_channel->chan_adapter; 268 269 SC_DEBUG(periph, SCSIPI_DB1, ("open: dev=0x%x (unit %d (of %d))\n", dev, 270 unit, ss_cd.cd_ndevs)); 271 272 if (periph->periph_flags & PERIPH_OPEN) { 273 printf("%s: already open\n", ss->sc_dev.dv_xname); 274 return (EBUSY); 275 } 276 277 if ((error = scsipi_adapter_addref(adapt)) != 0) 278 return (error); 279 280 /* 281 * Catch any unit attention errors. 282 * 283 * XS_CTL_IGNORE_MEDIA_CHANGE: when you have an ADF, some scanners 284 * consider paper to be a changeable media 285 * 286 */ 287 error = scsipi_test_unit_ready(periph, 288 XS_CTL_IGNORE_MEDIA_CHANGE | XS_CTL_IGNORE_ILLEGAL_REQUEST | 289 (ssmode == MODE_CONTROL ? XS_CTL_IGNORE_NOT_READY : 0)); 290 if (error) 291 goto bad; 292 293 periph->periph_flags |= PERIPH_OPEN; /* unit attn now errors */ 294 295 /* 296 * If the mode is 3 (e.g. minor = 3,7,11,15) 297 * then the device has been opened to set defaults 298 * This mode does NOT ALLOW I/O, only ioctls 299 */ 300 if (ssmode == MODE_CONTROL) 301 return (0); 302 303 SC_DEBUG(periph, SCSIPI_DB2, ("open complete\n")); 304 return (0); 305 306 bad: 307 scsipi_adapter_delref(adapt); 308 periph->periph_flags &= ~PERIPH_OPEN; 309 return (error); 310 } 311 312 /* 313 * close the device.. only called if we are the LAST 314 * occurence of an open device 315 */ 316 static int 317 ssclose(dev_t dev, int flag, int mode, struct proc *p) 318 { 319 struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(dev)]; 320 struct scsipi_periph *periph = ss->sc_periph; 321 struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter; 322 int error; 323 324 SC_DEBUG(ss->sc_periph, SCSIPI_DB1, ("closing\n")); 325 326 if (SSMODE(dev) == MODE_REWIND) { 327 if (ss->special && ss->special->rewind_scanner) { 328 /* call special handler to rewind/abort scan */ 329 error = (ss->special->rewind_scanner)(ss); 330 if (error) 331 return (error); 332 } else { 333 /* XXX add code to restart a SCSI2 scanner, if any */ 334 } 335 ss->sio.scan_window_size = 0; 336 ss->flags &= ~SSF_TRIGGERED; 337 } 338 339 scsipi_wait_drain(periph); 340 341 scsipi_adapter_delref(adapt); 342 periph->periph_flags &= ~PERIPH_OPEN; 343 344 return (0); 345 } 346 347 /* 348 * trim the size of the transfer if needed, 349 * called by physio 350 * basically the smaller of our min and the scsi driver's 351 * minphys 352 */ 353 static void 354 ssminphys(struct buf *bp) 355 { 356 struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(bp->b_dev)]; 357 struct scsipi_periph *periph = ss->sc_periph; 358 359 scsipi_adapter_minphys(periph->periph_channel, bp); 360 361 /* 362 * trim the transfer further for special devices this is 363 * because some scanners only read multiples of a line at a 364 * time, also some cannot disconnect, so the read must be 365 * short enough to happen quickly 366 */ 367 if (ss->special && ss->special->minphys) 368 (ss->special->minphys)(ss, bp); 369 } 370 371 /* 372 * Do a read on a device for a user process. 373 * Prime scanner at start of read, check uio values, call ssstrategy 374 * via physio for the actual transfer. 375 */ 376 static int 377 ssread(dev_t dev, struct uio *uio, int flag) 378 { 379 struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(dev)]; 380 int error; 381 382 if ((ss->sc_dev.dv_flags & DVF_ACTIVE) == 0) 383 return (ENODEV); 384 385 /* if the scanner has not yet been started, do it now */ 386 if (!(ss->flags & SSF_TRIGGERED)) { 387 if (ss->special && ss->special->trigger_scanner) { 388 error = (ss->special->trigger_scanner)(ss); 389 if (error) 390 return (error); 391 } 392 ss->flags |= SSF_TRIGGERED; 393 } 394 395 return (physio(ssstrategy, NULL, dev, B_READ, ssminphys, uio)); 396 } 397 398 /* 399 * Actually translate the requested transfer into one the physical 400 * driver can understand The transfer is described by a buf and will 401 * include only one physical transfer. 402 */ 403 static void 404 ssstrategy(struct buf *bp) 405 { 406 struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(bp->b_dev)]; 407 struct scsipi_periph *periph = ss->sc_periph; 408 int s; 409 410 SC_DEBUG(ss->sc_periph, SCSIPI_DB1, 411 ("ssstrategy %ld bytes @ blk %" PRId64 "\n", bp->b_bcount, bp->b_blkno)); 412 413 /* 414 * If the device has been made invalid, error out 415 */ 416 if ((ss->sc_dev.dv_flags & DVF_ACTIVE) == 0) { 417 bp->b_flags |= B_ERROR; 418 if (periph->periph_flags & PERIPH_OPEN) 419 bp->b_error = EIO; 420 else 421 bp->b_error = ENODEV; 422 goto done; 423 } 424 425 /* If negative offset, error */ 426 if (bp->b_blkno < 0) { 427 bp->b_flags |= B_ERROR; 428 bp->b_error = EINVAL; 429 goto done; 430 } 431 432 if (bp->b_bcount > ss->sio.scan_window_size) 433 bp->b_bcount = ss->sio.scan_window_size; 434 435 /* 436 * If it's a null transfer, return immediatly 437 */ 438 if (bp->b_bcount == 0) 439 goto done; 440 441 s = splbio(); 442 443 /* 444 * Place it in the queue of activities for this scanner 445 * at the end (a bit silly because we only have on user.. 446 * (but it could fork())) 447 */ 448 BUFQ_PUT(&ss->buf_queue, bp); 449 450 /* 451 * Tell the device to get going on the transfer if it's 452 * not doing anything, otherwise just wait for completion 453 * (All a bit silly if we're only allowing 1 open but..) 454 */ 455 ssstart(ss->sc_periph); 456 457 splx(s); 458 return; 459 done: 460 /* 461 * Correctly set the buf to indicate a completed xfer 462 */ 463 bp->b_resid = bp->b_bcount; 464 biodone(bp); 465 } 466 467 /* 468 * ssstart looks to see if there is a buf waiting for the device 469 * and that the device is not already busy. If both are true, 470 * It dequeues the buf and creates a scsi command to perform the 471 * transfer required. The transfer request will call scsipi_done 472 * on completion, which will in turn call this routine again 473 * so that the next queued transfer is performed. 474 * The bufs are queued by the strategy routine (ssstrategy) 475 * 476 * This routine is also called after other non-queued requests 477 * have been made of the scsi driver, to ensure that the queue 478 * continues to be drained. 479 * ssstart() is called at splbio 480 */ 481 static void 482 ssstart(struct scsipi_periph *periph) 483 { 484 struct ss_softc *ss = (void *)periph->periph_dev; 485 struct buf *bp; 486 487 SC_DEBUG(periph, SCSIPI_DB2, ("ssstart ")); 488 /* 489 * See if there is a buf to do and we are not already 490 * doing one 491 */ 492 while (periph->periph_active < periph->periph_openings) { 493 /* if a special awaits, let it proceed first */ 494 if (periph->periph_flags & PERIPH_WAITING) { 495 periph->periph_flags &= ~PERIPH_WAITING; 496 wakeup((caddr_t)periph); 497 return; 498 } 499 500 /* 501 * See if there is a buf with work for us to do.. 502 */ 503 if ((bp = BUFQ_PEEK(&ss->buf_queue)) == NULL) 504 return; 505 506 if (ss->special && ss->special->read) { 507 (ss->special->read)(ss, bp); 508 } else { 509 /* generic scsi2 scanner read */ 510 /* XXX add code for SCSI2 scanner read */ 511 } 512 } 513 } 514 515 void 516 ssrestart(void *v) 517 { 518 int s = splbio(); 519 ssstart((struct scsipi_periph *)v); 520 splx(s); 521 } 522 523 524 /* 525 * Perform special action on behalf of the user; 526 * knows about the internals of this device 527 */ 528 int 529 ssioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) 530 { 531 struct ss_softc *ss = ss_cd.cd_devs[SSUNIT(dev)]; 532 int error = 0; 533 struct scan_io *sio; 534 535 if ((ss->sc_dev.dv_flags & DVF_ACTIVE) == 0) 536 return (ENODEV); 537 538 switch (cmd) { 539 case SCIOCGET: 540 if (ss->special && ss->special->get_params) { 541 /* call special handler */ 542 error = (ss->special->get_params)(ss); 543 if (error) 544 return (error); 545 } else { 546 /* XXX add code for SCSI2 scanner, if any */ 547 return (EOPNOTSUPP); 548 } 549 memcpy(addr, &ss->sio, sizeof(struct scan_io)); 550 break; 551 case SCIOCSET: 552 sio = (struct scan_io *)addr; 553 554 if (ss->special && ss->special->set_params) { 555 /* call special handler */ 556 error = (ss->special->set_params)(ss, sio); 557 if (error) 558 return (error); 559 } else { 560 /* XXX add code for SCSI2 scanner, if any */ 561 return (EOPNOTSUPP); 562 } 563 break; 564 case SCIOCRESTART: 565 if (ss->special && ss->special->rewind_scanner ) { 566 /* call special handler */ 567 error = (ss->special->rewind_scanner)(ss); 568 if (error) 569 return (error); 570 } else 571 /* XXX add code for SCSI2 scanner, if any */ 572 return (EOPNOTSUPP); 573 ss->flags &= ~SSF_TRIGGERED; 574 break; 575 #ifdef NOTYET 576 case SCAN_USE_ADF: 577 break; 578 #endif 579 default: 580 return (scsipi_do_ioctl(ss->sc_periph, dev, cmd, addr, 581 flag, p)); 582 } 583 return (error); 584 } 585