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