xref: /netbsd-src/sys/dev/scsipi/scsiconf.c (revision 627f7eb200a4419d89b531d55fccd2ee3ffdcde0)
1 /*	$NetBSD: scsiconf.c,v 1.290 2020/09/18 15:04:25 jakllsch Exp $	*/
2 
3 /*-
4  * Copyright (c) 1998, 1999, 2004 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Charles M. Hannum; Jason R. Thorpe of the Numerical Aerospace
9  * Simulation Facility, NASA Ames Research Center.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30  * POSSIBILITY OF SUCH DAMAGE.
31  */
32 
33 /*
34  * Originally written by Julian Elischer (julian@tfs.com)
35  * for TRW Financial Systems for use under the MACH(2.5) operating system.
36  *
37  * TRW Financial Systems, in accordance with their agreement with Carnegie
38  * Mellon University, makes this software available to CMU to distribute
39  * or use in any manner that they see fit as long as this message is kept with
40  * the software. For this reason TFS also grants any other persons or
41  * organisations permission to use or modify this software.
42  *
43  * TFS supplies this software to be publicly redistributed
44  * on the understanding that TFS is not responsible for the correct
45  * functioning of this software in any circumstances.
46  *
47  * Ported to run under 386BSD by Julian Elischer (julian@tfs.com) Sept 1992
48  */
49 
50 #include <sys/cdefs.h>
51 __KERNEL_RCSID(0, "$NetBSD: scsiconf.c,v 1.290 2020/09/18 15:04:25 jakllsch Exp $");
52 
53 #include <sys/param.h>
54 #include <sys/systm.h>
55 #include <sys/kernel.h>
56 #include <sys/proc.h>
57 #include <sys/kthread.h>
58 #include <sys/malloc.h>
59 #include <sys/mutex.h>
60 #include <sys/once.h>
61 #include <sys/device.h>
62 #include <sys/conf.h>
63 #include <sys/fcntl.h>
64 #include <sys/scsiio.h>
65 #include <sys/queue.h>
66 #include <sys/atomic.h>
67 
68 #include <dev/scsipi/scsi_all.h>
69 #include <dev/scsipi/scsipi_all.h>
70 #include <dev/scsipi/scsiconf.h>
71 
72 #include "locators.h"
73 
74 static const struct scsipi_periphsw scsi_probe_dev = {
75 	NULL,
76 	NULL,
77 	NULL,
78 	NULL,
79 };
80 
81 struct scsi_initq {
82 	struct scsipi_channel *sc_channel;
83 	TAILQ_ENTRY(scsi_initq) scsi_initq;
84 };
85 
86 static ONCE_DECL(scsi_conf_ctrl);
87 static TAILQ_HEAD(, scsi_initq)	scsi_initq_head;
88 static kmutex_t			scsibus_qlock;
89 static kcondvar_t		scsibus_qcv;
90 
91 static int	scsi_probe_device(struct scsibus_softc *, int, int);
92 
93 static int	scsibusmatch(device_t, cfdata_t, void *);
94 static void	scsibusattach(device_t, device_t, void *);
95 static int	scsibusdetach(device_t, int flags);
96 static int	scsibusrescan(device_t, const char *, const int *);
97 static void	scsidevdetached(device_t, device_t);
98 
99 CFATTACH_DECL3_NEW(scsibus, sizeof(struct scsibus_softc),
100     scsibusmatch, scsibusattach, scsibusdetach, NULL,
101     scsibusrescan, scsidevdetached, DVF_DETACH_SHUTDOWN);
102 
103 extern struct cfdriver scsibus_cd;
104 
105 static dev_type_open(scsibusopen);
106 static dev_type_close(scsibusclose);
107 static dev_type_ioctl(scsibusioctl);
108 
109 const struct cdevsw scsibus_cdevsw = {
110 	.d_open = scsibusopen,
111 	.d_close = scsibusclose,
112 	.d_read = noread,
113 	.d_write = nowrite,
114 	.d_ioctl = scsibusioctl,
115 	.d_stop = nostop,
116 	.d_tty = notty,
117 	.d_poll = nopoll,
118 	.d_mmap = nommap,
119 	.d_kqfilter = nokqfilter,
120 	.d_discard = nodiscard,
121 	.d_flag = D_OTHER | D_MPSAFE
122 };
123 
124 static int	scsibusprint(void *, const char *);
125 static void	scsibus_discover_thread(void *);
126 static void	scsibus_config(struct scsibus_softc *);
127 
128 const struct scsipi_bustype scsi_bustype = {
129 	.bustype_type = SCSIPI_BUSTYPE_BUSTYPE(SCSIPI_BUSTYPE_SCSI,
130 	    SCSIPI_BUSTYPE_SCSI_PSCSI),
131 	.bustype_cmd = scsi_scsipi_cmd,
132 	.bustype_interpret_sense = scsipi_interpret_sense,
133 	.bustype_printaddr = scsi_print_addr,
134 	.bustype_kill_pending = scsi_kill_pending,
135 	.bustype_async_event_xfer_mode = scsi_async_event_xfer_mode,
136 };
137 
138 const struct scsipi_bustype scsi_fc_bustype = {
139 	.bustype_type = SCSIPI_BUSTYPE_BUSTYPE(SCSIPI_BUSTYPE_SCSI,
140 	    SCSIPI_BUSTYPE_SCSI_FC),
141 	.bustype_cmd = scsi_scsipi_cmd,
142 	.bustype_interpret_sense = scsipi_interpret_sense,
143 	.bustype_printaddr = scsi_print_addr,
144 	.bustype_kill_pending = scsi_kill_pending,
145 	.bustype_async_event_xfer_mode = scsi_fc_sas_async_event_xfer_mode,
146 };
147 
148 const struct scsipi_bustype scsi_sas_bustype = {
149 	.bustype_type = SCSIPI_BUSTYPE_BUSTYPE(SCSIPI_BUSTYPE_SCSI,
150 	    SCSIPI_BUSTYPE_SCSI_SAS),
151 	.bustype_cmd = scsi_scsipi_cmd,
152 	.bustype_interpret_sense = scsipi_interpret_sense,
153 	.bustype_printaddr = scsi_print_addr,
154 	.bustype_kill_pending = scsi_kill_pending,
155 	.bustype_async_event_xfer_mode = scsi_fc_sas_async_event_xfer_mode,
156 };
157 
158 const struct scsipi_bustype scsi_usb_bustype = {
159 	.bustype_type = SCSIPI_BUSTYPE_BUSTYPE(SCSIPI_BUSTYPE_SCSI,
160 	    SCSIPI_BUSTYPE_SCSI_USB),
161 	.bustype_cmd = scsi_scsipi_cmd,
162 	.bustype_interpret_sense = scsipi_interpret_sense,
163 	.bustype_printaddr = scsi_print_addr,
164 	.bustype_kill_pending = scsi_kill_pending,
165 	.bustype_async_event_xfer_mode = NULL,
166 };
167 
168 static int
169 scsibus_init(void)
170 {
171 
172 	TAILQ_INIT(&scsi_initq_head);
173 	mutex_init(&scsibus_qlock, MUTEX_DEFAULT, IPL_NONE);
174 	cv_init(&scsibus_qcv, "scsinitq");
175 	return 0;
176 }
177 
178 int
179 scsiprint(void *aux, const char *pnp)
180 {
181 	struct scsipi_channel *chan = aux;
182 	struct scsipi_adapter *adapt = chan->chan_adapter;
183 
184 	/* only "scsibus"es can attach to "scsi"s; easy. */
185 	if (pnp)
186 		aprint_normal("scsibus at %s", pnp);
187 
188 	/* don't print channel if the controller says there can be only one. */
189 	if (adapt->adapt_nchannels != 1)
190 		aprint_normal(" channel %d", chan->chan_channel);
191 
192 	return (UNCONF);
193 }
194 
195 static int
196 scsibusmatch(device_t parent, cfdata_t cf, void *aux)
197 {
198 	struct scsipi_channel *chan = aux;
199 
200 	if (SCSIPI_BUSTYPE_TYPE(chan->chan_bustype->bustype_type) !=
201 	    SCSIPI_BUSTYPE_SCSI)
202 		return 0;
203 
204 	if (cf->cf_loc[SCSICF_CHANNEL] != chan->chan_channel &&
205 	    cf->cf_loc[SCSICF_CHANNEL] != SCSICF_CHANNEL_DEFAULT)
206 		return (0);
207 
208 	return (1);
209 }
210 
211 static void
212 scsibusattach(device_t parent, device_t self, void *aux)
213 {
214 	struct scsibus_softc *sc = device_private(self);
215 	struct scsipi_channel *chan = aux;
216 	struct scsi_initq *scsi_initq;
217 
218 	if (!pmf_device_register(self, NULL, NULL))
219 		aprint_error_dev(self, "couldn't establish power handler\n");
220 
221 	sc->sc_dev = self;
222 	sc->sc_channel = chan;
223 	chan->chan_name = device_xname(sc->sc_dev);
224 
225 	aprint_naive(": SCSI bus\n");
226 	aprint_normal(": %d target%s, %d lun%s per target\n",
227 	    chan->chan_ntargets,
228 	    chan->chan_ntargets == 1 ? "" : "s",
229 	    chan->chan_nluns,
230 	    chan->chan_nluns == 1 ? "" : "s");
231 
232 	/*
233 	 * XXX
234 	 * newer adapters support more than 256 outstanding commands
235 	 * per periph and don't use the tag (they eventually allocate one
236 	 * internally). Right now scsipi always allocate a tag and
237 	 * is limited to 256 tags, per scsi specs.
238 	 * this should be revisited
239 	 */
240 	if (chan->chan_flags & SCSIPI_CHAN_OPENINGS) {
241 		if (chan->chan_max_periph > 256)
242 			chan->chan_max_periph = 256;
243 	} else {
244 		if (chan->chan_adapter->adapt_max_periph > 256)
245 			chan->chan_adapter->adapt_max_periph = 256;
246 	}
247 
248 	if (atomic_inc_uint_nv(&chan_running(chan)) == 1)
249 		mutex_init(chan_mtx(chan), MUTEX_DEFAULT, IPL_BIO);
250 
251 	cv_init(&chan->chan_cv_thr, "scshut");
252 	cv_init(&chan->chan_cv_comp, "sccomp");
253 	cv_init(&chan->chan_cv_xs, "xscmd");
254 
255 	if (scsipi_adapter_addref(chan->chan_adapter))
256 		return;
257 
258 	RUN_ONCE(&scsi_conf_ctrl, scsibus_init);
259 
260 	/* Initialize the channel structure first */
261 	chan->chan_init_cb = NULL;
262 	chan->chan_init_cb_arg = NULL;
263 
264 	scsi_initq = malloc(sizeof(struct scsi_initq), M_DEVBUF, M_WAITOK);
265 	scsi_initq->sc_channel = chan;
266 	TAILQ_INSERT_TAIL(&scsi_initq_head, scsi_initq, scsi_initq);
267         config_pending_incr(sc->sc_dev);
268 	if (scsipi_channel_init(chan)) {
269 		aprint_error_dev(sc->sc_dev, "failed to init channel\n");
270 		return;
271 	}
272 
273         /*
274          * Create the discover thread
275          */
276         if (kthread_create(PRI_NONE, 0, NULL, scsibus_discover_thread, sc,
277             &chan->chan_dthread, "%s-d", chan->chan_name)) {
278                 aprint_error_dev(sc->sc_dev, "unable to create discovery "
279 		    "thread for channel %d\n", chan->chan_channel);
280                 return;
281         }
282 }
283 
284 static void
285 scsibus_discover_thread(void *arg)
286 {
287 	struct scsibus_softc *sc = arg;
288 
289 	scsibus_config(sc);
290 	sc->sc_channel->chan_dthread = NULL;
291 	kthread_exit(0);
292 }
293 
294 static void
295 scsibus_config(struct scsibus_softc *sc)
296 {
297 	struct scsipi_channel *chan = sc->sc_channel;
298 	struct scsi_initq *scsi_initq;
299 
300 #ifndef SCSI_DELAY
301 #define SCSI_DELAY 2
302 #endif
303 	if ((chan->chan_flags & SCSIPI_CHAN_NOSETTLE) == 0 &&
304 	    SCSI_DELAY > 0) {
305 		aprint_normal_dev(sc->sc_dev,
306 		    "waiting %d seconds for devices to settle...\n",
307 		    SCSI_DELAY);
308 		/* ...an identifier we know no one will use... */
309 		kpause("scsidly", false, SCSI_DELAY * hz, NULL);
310 	}
311 
312 	/* Make sure the devices probe in scsibus order to avoid jitter. */
313 	mutex_enter(&scsibus_qlock);
314 	for (;;) {
315 		scsi_initq = TAILQ_FIRST(&scsi_initq_head);
316 		if (scsi_initq->sc_channel == chan)
317 			break;
318 		cv_wait(&scsibus_qcv, &scsibus_qlock);
319 	}
320 	mutex_exit(&scsibus_qlock);
321 
322 	scsi_probe_bus(sc, -1, -1);
323 
324 	mutex_enter(&scsibus_qlock);
325 	TAILQ_REMOVE(&scsi_initq_head, scsi_initq, scsi_initq);
326 	cv_broadcast(&scsibus_qcv);
327 	mutex_exit(&scsibus_qlock);
328 
329 	free(scsi_initq, M_DEVBUF);
330 
331 	scsipi_adapter_delref(chan->chan_adapter);
332 
333 	config_pending_decr(sc->sc_dev);
334 }
335 
336 static int
337 scsibusdetach(device_t self, int flags)
338 {
339 	struct scsibus_softc *sc = device_private(self);
340 	struct scsipi_channel *chan = sc->sc_channel;
341 	int error;
342 
343 	/*
344 	 * Defer while discovery thread is running
345 	 */
346 	while (chan->chan_dthread != NULL)
347 		kpause("scsibusdet", false, hz, NULL);
348 
349 	/*
350 	 * Detach all of the periphs.
351 	 */
352 	error = scsipi_target_detach(chan, -1, -1, flags);
353 	if (error)
354 		return error;
355 
356 	pmf_device_deregister(self);
357 
358 	/*
359 	 * Shut down the channel.
360 	 */
361 	scsipi_channel_shutdown(chan);
362 
363 	cv_destroy(&chan->chan_cv_xs);
364 	cv_destroy(&chan->chan_cv_comp);
365 	cv_destroy(&chan->chan_cv_thr);
366 
367 	if (atomic_dec_uint_nv(&chan_running(chan)) == 0)
368 		mutex_destroy(chan_mtx(chan));
369 
370 	return 0;
371 }
372 
373 /*
374  * Probe the requested scsi bus. It must be already set up.
375  * target and lun optionally narrow the search if not -1
376  */
377 int
378 scsi_probe_bus(struct scsibus_softc *sc, int target, int lun)
379 {
380 	struct scsipi_channel *chan = sc->sc_channel;
381 	int maxtarget, mintarget, maxlun, minlun;
382 	int error;
383 
384 	if (target == -1) {
385 		maxtarget = chan->chan_ntargets - 1;
386 		mintarget = 0;
387 	} else {
388 		if (target < 0 || target >= chan->chan_ntargets)
389 			return (EINVAL);
390 		maxtarget = mintarget = target;
391 	}
392 
393 	if (lun == -1) {
394 		maxlun = chan->chan_nluns - 1;
395 		minlun = 0;
396 	} else {
397 		if (lun < 0 || lun >= chan->chan_nluns)
398 			return (EINVAL);
399 		maxlun = minlun = lun;
400 	}
401 
402 	/*
403 	 * Some HBAs provide an abstracted view of the bus; give them an
404 	 * opportunity to re-scan it before we do.
405 	 */
406 	scsipi_adapter_ioctl(chan, SCBUSIOLLSCAN, NULL, 0, curproc);
407 
408 	if ((error = scsipi_adapter_addref(chan->chan_adapter)) != 0)
409 		goto ret;
410 	for (target = mintarget; target <= maxtarget; target++) {
411 		if (target == chan->chan_id)
412 			continue;
413 		for (lun = minlun; lun <= maxlun; lun++) {
414 			/*
415 			 * See if there's a device present, and configure it.
416 			 */
417 			if (scsi_probe_device(sc, target, lun) == 0)
418 				break;
419 			/* otherwise something says we should look further */
420 		}
421 
422 		/*
423 		 * Now that we've discovered all of the LUNs on this
424 		 * I_T Nexus, update the xfer mode for all of them
425 		 * that we know about.
426 		 */
427 		scsipi_set_xfer_mode(chan, target, 1);
428 	}
429 
430 	scsipi_adapter_delref(chan->chan_adapter);
431 ret:
432 	return (error);
433 }
434 
435 static int
436 scsibusrescan(device_t sc, const char *ifattr,
437     const int *locators)
438 {
439 
440 	KASSERT(ifattr && !strcmp(ifattr, "scsibus"));
441 	KASSERT(locators);
442 
443 	return (scsi_probe_bus(device_private(sc),
444 		locators[SCSIBUSCF_TARGET], locators[SCSIBUSCF_LUN]));
445 }
446 
447 static void
448 scsidevdetached(device_t self, device_t child)
449 {
450 	struct scsibus_softc *sc = device_private(self);
451 	struct scsipi_channel *chan = sc->sc_channel;
452 	struct scsipi_periph *periph;
453 	int target, lun;
454 
455 	target = device_locator(child, SCSIBUSCF_TARGET);
456 	lun = device_locator(child, SCSIBUSCF_LUN);
457 
458 	mutex_enter(chan_mtx(chan));
459 
460 	periph = scsipi_lookup_periph_locked(chan, target, lun);
461 	KASSERT(periph != NULL && periph->periph_dev == child);
462 
463 	scsipi_remove_periph(chan, periph);
464 	scsipi_free_periph(periph);
465 
466 	mutex_exit(chan_mtx(chan));
467 }
468 
469 /*
470  * Print out autoconfiguration information for a subdevice.
471  *
472  * This is a slight abuse of 'standard' autoconfiguration semantics,
473  * because 'print' functions don't normally print the colon and
474  * device information.  However, in this case that's better than
475  * either printing redundant information before the attach message,
476  * or having the device driver call a special function to print out
477  * the standard device information.
478  */
479 static int
480 scsibusprint(void *aux, const char *pnp)
481 {
482 	struct scsipibus_attach_args *sa = aux;
483 	struct scsipi_inquiry_pattern *inqbuf;
484 	u_int8_t type;
485 	const char *dtype;
486 	char vendor[33], product[65], revision[17];
487 	int target, lun;
488 
489 	if (pnp != NULL)
490 		aprint_normal("%s", pnp);
491 
492 	inqbuf = &sa->sa_inqbuf;
493 
494 	target = sa->sa_periph->periph_target;
495 	lun = sa->sa_periph->periph_lun;
496 	type = inqbuf->type & SID_TYPE;
497 
498 	dtype = scsipi_dtype(type);
499 
500 	strnvisx(vendor, sizeof(vendor), inqbuf->vendor, 8,
501 	    VIS_TRIM|VIS_SAFE|VIS_OCTAL);
502 	strnvisx(product, sizeof(product), inqbuf->product, 16,
503 	    VIS_TRIM|VIS_SAFE|VIS_OCTAL);
504 	strnvisx(revision, sizeof(revision), inqbuf->revision, 4,
505 	    VIS_TRIM|VIS_SAFE|VIS_OCTAL);
506 
507 	aprint_normal(" target %d lun %d: <%s, %s, %s> %s %s%s",
508 		      target, lun, vendor, product, revision, dtype,
509 		      inqbuf->removable ? "removable" : "fixed",
510 		      (sa->sa_periph->periph_opcs != NULL)
511 		        ? " timeout-info" : "");
512 
513 	return (UNCONF);
514 }
515 
516 static const struct scsi_quirk_inquiry_pattern scsi_quirk_patterns[] = {
517 	{{T_DIRECT, T_REMOV,
518 	 "Apple   ", "iPod            ", ""},	  PQUIRK_START},
519 	{{T_CDROM, T_REMOV,
520 	 "CHINON  ", "CD-ROM CDS-431  ", ""},     PQUIRK_NOLUNS},
521 	{{T_CDROM, T_REMOV,
522 	 "CHINON  ", "CD-ROM CDS-435  ", ""},     PQUIRK_NOLUNS},
523 	{{T_CDROM, T_REMOV,
524 	 "Chinon  ", "CD-ROM CDS-525  ", ""},     PQUIRK_NOLUNS},
525 	{{T_CDROM, T_REMOV,
526 	 "CHINON  ", "CD-ROM CDS-535  ", ""},     PQUIRK_NOLUNS},
527 	{{T_CDROM, T_REMOV,
528 	 "DEC     ", "RRD42   (C) DEC ", ""},     PQUIRK_NOLUNS},
529 	{{T_CDROM, T_REMOV,
530 	 "DENON   ", "DRD-25X         ", "V"},    PQUIRK_NOLUNS},
531 	{{T_CDROM, T_REMOV,
532 	 "GENERIC ", "CRD-BP2         ", ""},     PQUIRK_NOLUNS},
533 	{{T_CDROM, T_REMOV,
534 	 "HP      ", "C4324/C4325     ", ""},     PQUIRK_NOLUNS},
535 	{{T_CDROM, T_REMOV,
536 	 "IMS     ", "CDD521/10       ", "2.06"}, PQUIRK_NOLUNS},
537 	{{T_CDROM, T_REMOV,
538 	 "MATSHITA", "CD-ROM CR-5XX   ", "1.0b"}, PQUIRK_NOLUNS},
539 	{{T_CDROM, T_REMOV,
540 	 "MEDAVIS ", "RENO CD-ROMX2A  ", ""},     PQUIRK_NOLUNS},
541 	{{T_CDROM, T_REMOV,
542 	 "MEDIAVIS", "CDR-H93MV       ", "1.3"},  PQUIRK_NOLUNS},
543 	{{T_CDROM, T_REMOV,
544 	 "NEC     ", "CD-ROM DRIVE:502", ""},     PQUIRK_NOLUNS},
545 	{{T_CDROM, T_REMOV,
546 	 "NEC     ", "CD-ROM DRIVE:55 ", ""},     PQUIRK_NOLUNS},
547 	{{T_CDROM, T_REMOV,
548 	 "NEC     ", "CD-ROM DRIVE:83 ", ""},     PQUIRK_NOLUNS},
549 	{{T_CDROM, T_REMOV,
550 	 "NEC     ", "CD-ROM DRIVE:84 ", ""},     PQUIRK_NOLUNS},
551 	{{T_CDROM, T_REMOV,
552 	 "NEC     ", "CD-ROM DRIVE:841", ""},     PQUIRK_NOLUNS},
553         {{T_CDROM, T_REMOV,
554 	 "OLYMPUS ", "CDS620E         ", "1.1d"},
555 			       PQUIRK_NOLUNS|PQUIRK_NOSYNC|PQUIRK_NOCAPACITY},
556 	{{T_CDROM, T_REMOV,
557 	 "PIONEER ", "CD-ROM DR-124X  ", "1.01"}, PQUIRK_NOLUNS},
558         {{T_CDROM, T_REMOV,
559          "PLEXTOR ", "CD-ROM PX-4XCS  ", "1.01"},
560                                PQUIRK_NOLUNS|PQUIRK_NOSYNC},
561 	{{T_CDROM, T_REMOV,
562 	 "SONY    ", "CD-ROM CDU-541  ", ""},     PQUIRK_NOLUNS},
563 	{{T_CDROM, T_REMOV,
564 	 "SONY    ", "CD-ROM CDU-55S  ", ""},     PQUIRK_NOLUNS},
565 	{{T_CDROM, T_REMOV,
566 	 "SONY    ", "CD-ROM CDU-561  ", ""},     PQUIRK_NOLUNS},
567 	{{T_CDROM, T_REMOV,
568 	 "SONY    ", "CD-ROM CDU-76S", ""},
569 				PQUIRK_NOLUNS|PQUIRK_NOSYNC|PQUIRK_NOWIDE},
570 	{{T_CDROM, T_REMOV,
571 	 "SONY    ", "CD-ROM CDU-8003A", ""},     PQUIRK_NOLUNS},
572 	{{T_CDROM, T_REMOV,
573 	 "SONY    ", "CD-ROM CDU-8012 ", ""},     PQUIRK_NOLUNS},
574 	{{T_CDROM, T_REMOV,
575 	 "TEAC    ", "CD-ROM          ", "1.06"}, PQUIRK_NOLUNS},
576 	{{T_CDROM, T_REMOV,
577 	 "TEAC    ", "CD-ROM CD-56S   ", "1.0B"}, PQUIRK_NOLUNS},
578 	{{T_CDROM, T_REMOV,
579 	 "TEXEL   ", "CD-ROM          ", "1.06"}, PQUIRK_NOLUNS},
580 	{{T_CDROM, T_REMOV,
581 	 "TEXEL   ", "CD-ROM DM-XX24 K", "1.09"}, PQUIRK_NOLUNS},
582 	{{T_CDROM, T_REMOV,
583 	 "TEXEL   ", "CD-ROM DM-XX24 K", "1.10"}, PQUIRK_NOLUNS},
584 	{{T_CDROM, T_REMOV,
585 	 "TOSHIBA ", "XM-4101TASUNSLCD", ""}, PQUIRK_NOLUNS|PQUIRK_NOSYNC},
586 	/* "IBM CDRM00201     !F" 0724 is an IBM OEM Toshiba XM-4101BME */
587 	{{T_CDROM, T_REMOV,
588 	 "IBM     ", "CDRM00201     !F", "0724"}, PQUIRK_NOLUNS|PQUIRK_NOSYNC},
589 	{{T_CDROM, T_REMOV,
590 	 "ShinaKen", "CD-ROM DM-3x1S",   "1.04"}, PQUIRK_NOLUNS},
591 	{{T_CDROM, T_REMOV,
592 	 "JVC     ", "R2626",            ""},     PQUIRK_NOLUNS},
593 	{{T_CDROM, T_REMOV,
594 	 "YAMAHA", "CRW8424S",           ""},     PQUIRK_NOLUNS},
595 	{{T_CDROM, T_REMOV,
596 	 "NEC     ", "CD-ROM DRIVE:222", ""},	  PQUIRK_NOLUNS|PQUIRK_NOSYNC},
597 
598 	{{T_DIRECT, T_FIXED,
599 	 "MICROP  ", "1588-15MBSUN0669", ""},     PQUIRK_AUTOSAVE},
600 	{{T_DIRECT, T_FIXED,
601 	 "MICROP  ", "2217-15MQ1091501", ""},     PQUIRK_NOSYNCCACHE},
602 	{{T_OPTICAL, T_REMOV,
603 	 "EPSON   ", "OMD-5010        ", "3.08"}, PQUIRK_NOLUNS},
604 	{{T_DIRECT, T_FIXED,
605 	 "ADAPTEC ", "AEC-4412BD",       "1.2A"}, PQUIRK_NOMODESENSE},
606 	{{T_DIRECT, T_FIXED,
607 	 "ADAPTEC ", "ACB-4000",         ""},     PQUIRK_FORCELUNS|PQUIRK_AUTOSAVE|PQUIRK_NOMODESENSE},
608 	{{T_DIRECT, T_FIXED,
609 	 "DEC     ", "RZ55     (C) DEC", ""},     PQUIRK_AUTOSAVE},
610 	{{T_DIRECT, T_FIXED,
611 	 "EMULEX  ", "MD21/S2     ESDI", "A00"},
612 				PQUIRK_FORCELUNS|PQUIRK_AUTOSAVE},
613 	{{T_DIRECT, T_FIXED,
614 	 "MICROP",  "1548-15MZ1077801",  "HZ2P"}, PQUIRK_NOTAG},
615 	{{T_DIRECT, T_FIXED,
616 	 "HP      ", "C372",             ""},     PQUIRK_NOTAG},
617 	{{T_DIRECT, T_FIXED,
618 	 "IBMRAID ", "0662S",		 ""},     PQUIRK_AUTOSAVE},
619 	{{T_DIRECT, T_FIXED,
620 	 "IBM     ", "0663H",		 ""},     PQUIRK_AUTOSAVE},
621 	{{T_DIRECT, T_FIXED,
622 	 "IBM",	     "0664",		 ""},     PQUIRK_AUTOSAVE},
623 	{{T_DIRECT, T_FIXED,
624 	/* improperly report DT-only sync mode */
625 	 "IBM     ", "DXHS36D",		 ""},
626 				PQUIRK_CAP_SYNC|PQUIRK_CAP_WIDE16},
627 	{{T_DIRECT, T_FIXED,
628 	 "IBM     ", "DXHS18Y",		 ""},
629 				PQUIRK_CAP_SYNC|PQUIRK_CAP_WIDE16},
630 	{{T_DIRECT, T_FIXED,
631 	 "IBM     ", "H3171-S2",	 ""},
632 				PQUIRK_NOLUNS|PQUIRK_AUTOSAVE},
633 	{{T_DIRECT, T_FIXED,
634 	 "IBM     ", "KZ-C",		 ""},	  PQUIRK_AUTOSAVE},
635 	/* Broken IBM disk */
636 	{{T_DIRECT, T_FIXED,
637 	 ""	   , "DFRSS2F",		 ""},	  PQUIRK_AUTOSAVE},
638 	{{T_DIRECT, T_FIXED,
639 	 "Initio  ", "",		 ""},	  PQUIRK_NOBIGMODESENSE},
640 	{{T_DIRECT, T_FIXED,
641 	 "JMicron ", "Generic         ", ""},	  PQUIRK_NOFUA},
642 	{{T_DIRECT, T_REMOV,
643 	 "MPL     ", "MC-DISK-        ", ""},     PQUIRK_NOLUNS},
644 	{{T_DIRECT, T_FIXED,
645 	 "MAXTOR  ", "XT-3280         ", ""},     PQUIRK_NOLUNS},
646 	{{T_DIRECT, T_FIXED,
647 	 "MAXTOR  ", "XT-4380S        ", ""},     PQUIRK_NOLUNS},
648 	{{T_DIRECT, T_FIXED,
649 	 "MAXTOR  ", "MXT-1240S       ", ""},     PQUIRK_NOLUNS},
650 	{{T_DIRECT, T_FIXED,
651 	 "MAXTOR  ", "XT-4170S        ", ""},     PQUIRK_NOLUNS},
652 	{{T_DIRECT, T_FIXED,
653 	 "MAXTOR  ", "XT-8760S",         ""},     PQUIRK_NOLUNS},
654 	{{T_DIRECT, T_FIXED,
655 	 "MAXTOR  ", "LXT-213S        ", ""},     PQUIRK_NOLUNS},
656 	{{T_DIRECT, T_FIXED,
657 	 "MAXTOR  ", "LXT-213S SUN0207", ""},     PQUIRK_NOLUNS},
658 	{{T_DIRECT, T_FIXED,
659 	 "MAXTOR  ", "LXT-200S        ", ""},     PQUIRK_NOLUNS},
660 	{{T_DIRECT, T_FIXED,
661 	 "MEGADRV ", "EV1000",           ""},     PQUIRK_NOMODESENSE},
662 	{{T_DIRECT, T_FIXED,
663 	 "MICROP", "1991-27MZ",          ""},     PQUIRK_NOTAG},
664 	{{T_DIRECT, T_FIXED,
665 	 "MST     ", "SnapLink        ", ""},     PQUIRK_NOLUNS},
666 	{{T_DIRECT, T_FIXED,
667 	 "NEC     ", "D3847           ", "0307"}, PQUIRK_NOLUNS},
668 	{{T_DIRECT, T_FIXED,
669 	 "QUANTUM ", "ELS85S          ", ""},     PQUIRK_AUTOSAVE},
670 	{{T_DIRECT, T_FIXED,
671 	 "QUANTUM ", "LPS525S         ", ""},     PQUIRK_NOLUNS},
672 	{{T_DIRECT, T_FIXED,
673 	 "QUANTUM ", "P105S 910-10-94x", ""},     PQUIRK_NOLUNS},
674 	{{T_DIRECT, T_FIXED,
675 	 "QUANTUM ", "PD1225S         ", ""},     PQUIRK_NOLUNS},
676 	{{T_DIRECT, T_FIXED,
677 	 "QUANTUM ", "PD210S   SUN0207", ""},     PQUIRK_NOLUNS},
678 	{{T_DIRECT, T_FIXED,
679 	 "QUANTUM ", "ATLAS IV 9 WLS", "0A0A"},   PQUIRK_CAP_NODT},
680 	{{T_DIRECT, T_FIXED,
681 	 "RODIME  ", "RO3000S         ", ""},     PQUIRK_NOLUNS},
682 	{{T_DIRECT, T_FIXED,
683 	 "SEAGATE ", "ST125N          ", ""},     PQUIRK_NOLUNS},
684 	{{T_DIRECT, T_FIXED,
685 	 "SEAGATE ", "ST157N          ", ""},     PQUIRK_NOLUNS},
686 	{{T_DIRECT, T_FIXED,
687 	 "SEAGATE ", "ST296           ", ""},     PQUIRK_NOLUNS},
688 	{{T_DIRECT, T_FIXED,
689 	 "SEAGATE ", "ST296N          ", ""},     PQUIRK_NOLUNS},
690 	{{T_DIRECT, T_FIXED,
691 	 "SEAGATE ", "ST318404LC      ", ""},     PQUIRK_NOLUNS},
692 	{{T_DIRECT, T_FIXED,
693 	 "SEAGATE ", "ST336753LC      ", ""},     PQUIRK_NOLUNS},
694 	{{T_DIRECT, T_FIXED,
695 	 "SEAGATE ", "ST336753LW      ", ""},     PQUIRK_NOLUNS},
696 	{{T_DIRECT, T_FIXED,
697 	 "SEAGATE ", "ST336754LC      ", ""},     PQUIRK_NOLUNS},
698 	{{T_DIRECT, T_FIXED,
699 	 "SEAGATE ", "ST39236LC       ", ""},     PQUIRK_NOLUNS},
700 	{{T_DIRECT, T_FIXED,
701 	 "SEAGATE ", "ST15150N        ", ""},     PQUIRK_NOTAG},
702 	{{T_DIRECT, T_FIXED,
703 	 "SEAGATE ", "ST19171",          ""},     PQUIRK_NOMODESENSE},
704 	{{T_DIRECT, T_FIXED,
705 	 "SEAGATE ", "ST32430N",         ""},     PQUIRK_CAP_SYNC},
706 	{{T_DIRECT, T_FIXED,
707 	 "SEAGATE ", "ST34501FC       ", ""},     PQUIRK_NOMODESENSE},
708 	{{T_DIRECT, T_FIXED,
709 	 "SEAGATE ", "SX910800N",        ""},     PQUIRK_NOTAG},
710 	{{T_DIRECT, T_FIXED,
711 	 "TOSHIBA ", "MK538FB         ", "6027"}, PQUIRK_NOLUNS},
712 	{{T_DIRECT, T_FIXED,
713 	 "MICROP  ", "1924",          ""},     PQUIRK_CAP_SYNC},
714 	{{T_DIRECT, T_FIXED,
715 	 "FUJITSU ", "M2266",         ""},     PQUIRK_CAP_SYNC},
716 	{{T_DIRECT, T_FIXED,
717 	 "FUJITSU ", "M2624S-512      ", ""},     PQUIRK_CAP_SYNC},
718 	{{T_DIRECT, T_FIXED,
719 	 "SEAGATE ", "SX336704LC"   , ""}, PQUIRK_CAP_SYNC | PQUIRK_CAP_WIDE16},
720 	{{T_DIRECT, T_FIXED,
721 	 "SEAGATE ", "SX173404LC",       ""},     PQUIRK_CAP_SYNC | PQUIRK_CAP_WIDE16},
722 
723 	{{T_DIRECT, T_REMOV,
724 	 "IOMEGA", "ZIP 100",		 "J.03"}, PQUIRK_NOLUNS|PQUIRK_NOSYNC},
725 	{{T_DIRECT, T_REMOV,
726 	 "INSITE", "I325VM",             ""},     PQUIRK_NOLUNS},
727 
728 	/* XXX: QIC-36 tape behind Emulex adapter.  Very broken. */
729 	{{T_SEQUENTIAL, T_REMOV,
730 	 "        ", "                ", "    "}, PQUIRK_NOLUNS},
731 	{{T_SEQUENTIAL, T_REMOV,
732 	 "EMULEX  ", "MT-02 QIC       ", ""},     PQUIRK_NOLUNS},
733 	{{T_SEQUENTIAL, T_REMOV,
734 	 "CALIPER ", "CP150           ", ""},     PQUIRK_NOLUNS},
735 	{{T_SEQUENTIAL, T_REMOV,
736 	 "EXABYTE ", "EXB-8200        ", ""},     PQUIRK_NOLUNS},
737 	{{T_SEQUENTIAL, T_REMOV,
738 	 "SONY    ", "GY-10C          ", ""},     PQUIRK_NOLUNS},
739 	{{T_SEQUENTIAL, T_REMOV,
740 	 "SONY    ", "SDT-2000        ", "2.09"}, PQUIRK_NOLUNS},
741 	{{T_SEQUENTIAL, T_REMOV,
742 	 "SONY    ", "SDT-5000        ", "3."},   PQUIRK_NOSYNC|PQUIRK_NOWIDE},
743 	{{T_SEQUENTIAL, T_REMOV,
744 	 "SONY    ", "SDT-5200        ", "3."},   PQUIRK_NOLUNS},
745 	{{T_SEQUENTIAL, T_REMOV,
746 	 "TANDBERG", " TDC 3600       ", ""},     PQUIRK_NOLUNS},
747 	/* Following entry reported as a Tandberg 3600; ref. PR1933 */
748 	{{T_SEQUENTIAL, T_REMOV,
749 	 "ARCHIVE ", "VIPER 150  21247", ""},     PQUIRK_NOLUNS},
750 	/* Following entry for a Cipher ST150S; ref. PR4171 */
751 	{{T_SEQUENTIAL, T_REMOV,
752 	 "ARCHIVE ", "VIPER 1500 21247", "2.2G"}, PQUIRK_NOLUNS},
753 	{{T_SEQUENTIAL, T_REMOV,
754 	 "ARCHIVE ", "Python 28454-XXX", ""},     PQUIRK_NOLUNS},
755 	{{T_SEQUENTIAL, T_REMOV,
756 	 "WANGTEK ", "5099ES SCSI",      ""},     PQUIRK_NOLUNS},
757 	{{T_SEQUENTIAL, T_REMOV,
758 	 "WANGTEK ", "5150ES SCSI",      ""},     PQUIRK_NOLUNS},
759 	{{T_SEQUENTIAL, T_REMOV,
760 	 "WANGTEK ", "SCSI-36",		 ""},     PQUIRK_NOLUNS},
761 	{{T_SEQUENTIAL, T_REMOV,
762 	 "WangDAT ", "Model 1300      ", "02.4"}, PQUIRK_NOSYNC|PQUIRK_NOWIDE},
763 	{{T_SEQUENTIAL, T_REMOV,
764 	 "WangDAT ", "Model 2600      ", "01.7"}, PQUIRK_NOSYNC|PQUIRK_NOWIDE},
765 	{{T_SEQUENTIAL, T_REMOV,
766 	 "WangDAT ", "Model 3200      ", "02.2"}, PQUIRK_NOSYNC|PQUIRK_NOWIDE},
767 	{{T_SEQUENTIAL, T_REMOV,
768 	 "TEAC    ", "MT-2ST/N50      ", ""},     PQUIRK_NOLUNS},
769 
770 	{{T_SCANNER, T_FIXED,
771 	 "RICOH   ", "IS60            ", "1R08"}, PQUIRK_NOLUNS},
772 	{{T_SCANNER, T_FIXED,
773 	 "UMAX    ", "Astra 1200S     ", "V2.9"}, PQUIRK_NOLUNS},
774 	{{T_SCANNER, T_FIXED,
775 	 "UMAX    ", "Astra 1220S     ", ""},     PQUIRK_NOLUNS},
776 	{{T_SCANNER, T_FIXED,
777 	 "UMAX    ", "UMAX S-6E       ", "V2.0"}, PQUIRK_NOLUNS},
778 	{{T_SCANNER, T_FIXED,
779 	 "UMAX    ", "UMAX S-12       ", "V2.1"}, PQUIRK_NOLUNS},
780 	{{T_SCANNER, T_FIXED,
781 	 "ULTIMA  ", "A6000C          ", ""},     PQUIRK_NOLUNS},
782 	{{T_PROCESSOR, T_FIXED,
783 	 "ESG-SHV",  "SCA HSBP M15",     ""},     PQUIRK_NOLUNS},
784 	{{T_PROCESSOR, T_FIXED,
785 	 "SYMBIOS",  "",                 ""},     PQUIRK_NOLUNS},
786 	{{T_PROCESSOR, T_FIXED,
787 	 "LITRONIC", "PCMCIA          ", ""},     PQUIRK_NOLUNS},
788 	{{T_CHANGER, T_REMOV,
789 	 "SONY    ", "CDL1100         ", ""},     PQUIRK_NOLUNS},
790 	{{T_ENCLOSURE, T_FIXED,
791 	 "SUN     ", "SENA            ", ""},     PQUIRK_NOLUNS},
792 };
793 
794 /*
795  * given a target and lun, ask the device what
796  * it is, and find the correct driver table
797  * entry.
798  */
799 static int
800 scsi_probe_device(struct scsibus_softc *sc, int target, int lun)
801 {
802 	struct scsipi_channel *chan = sc->sc_channel;
803 	struct scsipi_periph *periph;
804 	struct scsipi_inquiry_data inqbuf;
805 	const struct scsi_quirk_inquiry_pattern *finger;
806 	int checkdtype, priority, docontinue, quirks;
807 	struct scsipibus_attach_args sa;
808 	cfdata_t cf;
809 	int locs[SCSIBUSCF_NLOCS];
810 
811 	/*
812 	 * Assume no more LUNs to search after this one.
813 	 * If we successfully get Inquiry data and after
814 	 * merging quirks we find we can probe for more
815 	 * LUNs, we will.
816 	 */
817 	docontinue = 0;
818 
819 	/* Skip this slot if it is already attached. */
820 	if (scsipi_lookup_periph(chan, target, lun) != NULL)
821 		return (docontinue);
822 
823 	periph = scsipi_alloc_periph(M_WAITOK);
824 	periph->periph_channel = chan;
825 	periph->periph_switch = &scsi_probe_dev;
826 
827 	periph->periph_target = target;
828 	periph->periph_lun = lun;
829 	periph->periph_quirks = chan->chan_defquirks;
830 
831 #ifdef SCSIPI_DEBUG
832 	if (SCSIPI_DEBUG_TYPE == SCSIPI_BUSTYPE_SCSI &&
833 	    SCSIPI_DEBUG_TARGET == target &&
834 	    SCSIPI_DEBUG_LUN == lun)
835 		periph->periph_dbflags |= SCSIPI_DEBUG_FLAGS;
836 #endif
837 
838 	/*
839 	 * Ask the device what it is
840 	 */
841 
842 #ifdef SCSI_2_DEF
843 	/* some devices need to be told to go to SCSI2 */
844 	/* However some just explode if you tell them this.. leave it out */
845 	scsi_change_def(periph, XS_CTL_DISCOVERY | XS_CTL_SILENT);
846 #endif /* SCSI_2_DEF */
847 
848 	/* Now go ask the device all about itself. */
849 	memset(&inqbuf, 0, sizeof(inqbuf));
850 	{
851 		u_int8_t *extension = &inqbuf.flags1;
852 		int len = 0;
853 		while (len < 3)
854 			extension[len++] = '\0';
855 		while (len < 3 + 28)
856 			extension[len++] = ' ';
857 		while (len < 3 + 28 + 20)
858 			extension[len++] = '\0';
859 		while (len < 3 + 28 + 20 + 1)
860 			extension[len++] = '\0';
861 		while (len < 3 + 28 + 20 + 1 + 1)
862 			extension[len++] = '\0';
863 		while (len < 3 + 28 + 20 + 1 + 1 + (8*2))
864 			extension[len++] = ' ';
865 	}
866 	if (scsipi_inquire(periph, &inqbuf, XS_CTL_DISCOVERY | XS_CTL_SILENT))
867 		goto bad;
868 
869 	periph->periph_type = inqbuf.device & SID_TYPE;
870 	if (inqbuf.dev_qual2 & SID_REMOVABLE)
871 		periph->periph_flags |= PERIPH_REMOVABLE;
872 	periph->periph_version = inqbuf.version & SID_ANSII;
873 
874 	/*
875 	 * Any device qualifier that has the top bit set (qualifier&4 != 0)
876 	 * is vendor specific and won't match in this switch.
877 	 * All we do here is throw out bad/negative responses.
878 	 */
879 	checkdtype = 0;
880 	switch (inqbuf.device & SID_QUAL) {
881 	case SID_QUAL_LU_PRESENT:
882 		checkdtype = 1;
883 		break;
884 
885 	case SID_QUAL_LU_NOTPRESENT:
886 	case SID_QUAL_reserved:
887 	case SID_QUAL_LU_NOT_SUPP:
888 		goto bad;
889 
890 	default:
891 		break;
892 	}
893 
894 	/* Let the adapter driver handle the device separately if it wants. */
895 	if (chan->chan_adapter->adapt_accesschk != NULL &&
896 	    (*chan->chan_adapter->adapt_accesschk)(periph, &sa.sa_inqbuf))
897 		goto bad;
898 
899 	if (checkdtype) {
900 		switch (periph->periph_type) {
901 		case T_DIRECT:
902 		case T_SEQUENTIAL:
903 		case T_PRINTER:
904 		case T_PROCESSOR:
905 		case T_WORM:
906 		case T_CDROM:
907 		case T_SCANNER:
908 		case T_OPTICAL:
909 		case T_CHANGER:
910 		case T_COMM:
911 		case T_IT8_1:
912 		case T_IT8_2:
913 		case T_STORARRAY:
914 		case T_ENCLOSURE:
915 		case T_SIMPLE_DIRECT:
916 		case T_OPTIC_CARD_RW:
917 		case T_OBJECT_STORED:
918 		default:
919 			break;
920 		case T_NODEVICE:
921 			goto bad;
922 		}
923 	}
924 
925 	sa.sa_periph = periph;
926 	sa.sa_inqbuf.type = inqbuf.device;
927 	sa.sa_inqbuf.removable = inqbuf.dev_qual2 & SID_REMOVABLE ?
928 	    T_REMOV : T_FIXED;
929 	sa.sa_inqbuf.vendor = inqbuf.vendor;
930 	sa.sa_inqbuf.product = inqbuf.product;
931 	sa.sa_inqbuf.revision = inqbuf.revision;
932 	sa.scsipi_info.scsi_version = inqbuf.version;
933 	sa.sa_inqptr = &inqbuf;
934 
935 	finger = scsipi_inqmatch(
936 	    &sa.sa_inqbuf, scsi_quirk_patterns,
937 	    sizeof(scsi_quirk_patterns)/sizeof(scsi_quirk_patterns[0]),
938 	    sizeof(scsi_quirk_patterns[0]), &priority);
939 
940 	if (finger != NULL)
941 		quirks = finger->quirks;
942 	else
943 		quirks = 0;
944 
945 	/*
946 	 * Determine the operating mode capabilities of the device.
947 	 */
948 	if (periph->periph_version >= 2) {
949 		if ((inqbuf.flags3 & SID_CmdQue) != 0 &&
950 		    (quirks & PQUIRK_NOTAG) == 0)
951 			periph->periph_cap |= PERIPH_CAP_TQING;
952 		if ((inqbuf.flags3 & SID_Linked) != 0)
953 			periph->periph_cap |= PERIPH_CAP_LINKCMDS;
954 		if ((inqbuf.flags3 & SID_Sync) != 0 &&
955 		    (quirks & PQUIRK_NOSYNC) == 0)
956 			periph->periph_cap |= PERIPH_CAP_SYNC;
957 		if ((inqbuf.flags3 & SID_WBus16) != 0 &&
958 		    (quirks & PQUIRK_NOWIDE) == 0)
959 			periph->periph_cap |= PERIPH_CAP_WIDE16;
960 		if ((inqbuf.flags3 & SID_WBus32) != 0 &&
961 		    (quirks & PQUIRK_NOWIDE) == 0)
962 			periph->periph_cap |= PERIPH_CAP_WIDE32;
963 		if ((inqbuf.flags3 & SID_SftRe) != 0)
964 			periph->periph_cap |= PERIPH_CAP_SFTRESET;
965 		if ((inqbuf.flags3 & SID_RelAdr) != 0)
966 			periph->periph_cap |= PERIPH_CAP_RELADR;
967 		/* SPC-2 */
968 		if (periph->periph_version >= 3 &&
969 		    !(quirks & PQUIRK_CAP_NODT)){
970 			/*
971 			 * Report ST clocking though CAP_WIDExx/CAP_SYNC.
972 			 * If the device only supports DT, clear these
973 			 * flags (DT implies SYNC and WIDE)
974 			 */
975 			switch (inqbuf.flags4 & SID_Clocking) {
976 			case SID_CLOCKING_DT_ONLY:
977 				periph->periph_cap &=
978 				    ~(PERIPH_CAP_SYNC |
979 				      PERIPH_CAP_WIDE16 |
980 				      PERIPH_CAP_WIDE32);
981 				/* FALLTHROUGH */
982 			case SID_CLOCKING_SD_DT:
983 				periph->periph_cap |= PERIPH_CAP_DT;
984 				break;
985 			default: /* ST only or invalid */
986 				/* nothing to do */
987 				break;
988 			}
989 		}
990 		if (periph->periph_version >= 3) {
991 			if (inqbuf.flags4 & SID_IUS)
992 				periph->periph_cap |= PERIPH_CAP_IUS;
993 			if (inqbuf.flags4 & SID_QAS)
994 				periph->periph_cap |= PERIPH_CAP_QAS;
995 		}
996 	}
997 	if (quirks & PQUIRK_CAP_SYNC)
998 		periph->periph_cap |= PERIPH_CAP_SYNC;
999 	if (quirks & PQUIRK_CAP_WIDE16)
1000 		periph->periph_cap |= PERIPH_CAP_WIDE16;
1001 
1002 	/*
1003 	 * Now apply any quirks from the table.
1004 	 */
1005 	periph->periph_quirks |= quirks;
1006 	if (periph->periph_version == 0 &&
1007 	    (periph->periph_quirks & PQUIRK_FORCELUNS) == 0)
1008 		periph->periph_quirks |= PQUIRK_NOLUNS;
1009 
1010 	if ((periph->periph_quirks & PQUIRK_NOLUNS) == 0)
1011 		docontinue = 1;
1012 
1013 	locs[SCSIBUSCF_TARGET] = target;
1014 	locs[SCSIBUSCF_LUN] = lun;
1015 
1016 	if ((cf = config_search_loc(config_stdsubmatch, sc->sc_dev,
1017 	     "scsibus", locs, &sa)) != NULL) {
1018 		scsipi_insert_periph(chan, periph);
1019 
1020 		/*
1021 		 * Determine supported opcodes and timeouts if available.
1022 		 * Only do this on peripherals reporting SCSI version 3
1023 		 * or greater - this command isn't in the SCSI-2 spec. and
1024 		 * it causes either timeouts or peripherals disappearing
1025 		 * when sent to some SCSI-1 or SCSI-2 peripherals.
1026 		 */
1027 		if (periph->periph_version >= 3)
1028 			scsipi_get_opcodeinfo(periph);
1029 
1030 		/*
1031 		 * XXX Can't assign periph_dev here, because we'll
1032 		 * XXX need it before config_attach() returns.  Must
1033 		 * XXX assign it in periph driver.
1034 		 */
1035 		config_attach_loc(sc->sc_dev, cf, locs, &sa,
1036 					 scsibusprint);
1037 	} else {
1038 		scsibusprint(&sa, device_xname(sc->sc_dev));
1039 		aprint_normal(" not configured\n");
1040 		goto bad;
1041 	}
1042 
1043 	return (docontinue);
1044 
1045 bad:
1046 	scsipi_free_periph(periph);
1047 	return (docontinue);
1048 }
1049 
1050 /****** Entry points for user control of the SCSI bus. ******/
1051 
1052 static int
1053 scsibusopen(dev_t dev, int flag, int fmt,
1054     struct lwp *l)
1055 {
1056 	struct scsibus_softc *sc;
1057 	int error, unit = minor(dev);
1058 
1059 	sc = device_lookup_private(&scsibus_cd, unit);
1060 	if (sc == NULL)
1061 		return (ENXIO);
1062 
1063 	if (sc->sc_flags & SCSIBUSF_OPEN)
1064 		return (EBUSY);
1065 
1066 	if ((error = scsipi_adapter_addref(sc->sc_channel->chan_adapter)) != 0)
1067 		return (error);
1068 
1069 	sc->sc_flags |= SCSIBUSF_OPEN;
1070 
1071 	return (0);
1072 }
1073 
1074 static int
1075 scsibusclose(dev_t dev, int flag, int fmt,
1076     struct lwp *l)
1077 {
1078 	struct scsibus_softc *sc;
1079 
1080 	sc = device_lookup_private(&scsibus_cd, minor(dev));
1081 	scsipi_adapter_delref(sc->sc_channel->chan_adapter);
1082 
1083 	sc->sc_flags &= ~SCSIBUSF_OPEN;
1084 
1085 	return (0);
1086 }
1087 
1088 static int
1089 scsibusioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
1090 {
1091 	struct scsibus_softc *sc;
1092 	struct scsipi_channel *chan;
1093 	int error;
1094 
1095 	sc = device_lookup_private(&scsibus_cd, minor(dev));
1096 	chan = sc->sc_channel;
1097 
1098 	/*
1099 	 * Enforce write permission for ioctls that change the
1100 	 * state of the bus.  Host adapter specific ioctls must
1101 	 * be checked by the adapter driver.
1102 	 */
1103 	switch (cmd) {
1104 	case SCBUSIOSCAN:
1105 	case SCBUSIODETACH:
1106 	case SCBUSIORESET:
1107 		if ((flag & FWRITE) == 0)
1108 			return (EBADF);
1109 	}
1110 
1111 	switch (cmd) {
1112 	case SCBUSIOSCAN:
1113 	    {
1114 		struct scbusioscan_args *a =
1115 		    (struct scbusioscan_args *)addr;
1116 
1117 		error = scsi_probe_bus(sc, a->sa_target, a->sa_lun);
1118 		break;
1119 	    }
1120 
1121 	case SCBUSIODETACH:
1122 	    {
1123 		struct scbusiodetach_args *a =
1124 		    (struct scbusiodetach_args *)addr;
1125 
1126 		error = scsipi_target_detach(chan, a->sa_target, a->sa_lun, 0);
1127 		break;
1128 	    }
1129 
1130 
1131 	case SCBUSIORESET:
1132 		/* FALLTHROUGH */
1133 	default:
1134 		error = scsipi_adapter_ioctl(chan, cmd, addr, flag, l->l_proc);
1135 		break;
1136 	}
1137 
1138 	return (error);
1139 }
1140