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