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