Annotation of sys/scsi/scsiconf.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: scsiconf.c,v 1.125 2007/05/08 18:50:39 deraadt Exp $ */
2: /* $NetBSD: scsiconf.c,v 1.57 1996/05/02 01:09:01 neil Exp $ */
3:
4: /*
5: * Copyright (c) 1994 Charles Hannum. All rights reserved.
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 Charles Hannum.
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: /*
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 "bio.h"
51:
52: #include <sys/types.h>
53: #include <sys/param.h>
54: #include <sys/systm.h>
55: #include <sys/malloc.h>
56: #include <sys/device.h>
57:
58: #include <scsi/scsi_all.h>
59: #include <scsi/scsiconf.h>
60:
61: #if NBIO > 0
62: #include <sys/ioctl.h>
63: #include <sys/scsiio.h>
64: #include <dev/biovar.h>
65: #endif
66:
67: /*
68: * Declarations
69: */
70: int scsi_probedev(struct scsibus_softc *, int, int);
71:
72: struct scsi_device probe_switch = {
73: NULL,
74: NULL,
75: NULL,
76: NULL,
77: };
78:
79: int scsibusmatch(struct device *, void *, void *);
80: void scsibusattach(struct device *, struct device *, void *);
81: int scsibusactivate(struct device *, enum devact);
82: int scsibusdetach(struct device *, int);
83:
84: int scsibussubmatch(struct device *, void *, void *);
85:
86: #if NBIO > 0
87: int scsibus_bioctl(struct device *, u_long, caddr_t);
88: #endif
89:
90: struct cfattach scsibus_ca = {
91: sizeof(struct scsibus_softc), scsibusmatch, scsibusattach,
92: scsibusdetach, scsibusactivate
93: };
94:
95: struct cfdriver scsibus_cd = {
96: NULL, "scsibus", DV_DULL
97: };
98:
99: #ifdef SCSIDEBUG
100: int scsidebug_buses = SCSIDEBUG_BUSES;
101: int scsidebug_targets = SCSIDEBUG_TARGETS;
102: int scsidebug_luns = SCSIDEBUG_LUNS;
103: int scsidebug_level = SCSIDEBUG_LEVEL;
104: #endif
105:
106: int scsi_autoconf = SCSI_AUTOCONF;
107:
108: int scsibusprint(void *, const char *);
109:
110: const u_int8_t version_to_spc [] = {
111: 0, /* 0x00: The device does not claim conformance to any standard. */
112: 1, /* 0x01: (Obsolete) SCSI-1 in olden times. */
113: 2, /* 0x02: (Obsolete) SCSI-2 in olden times. */
114: 3, /* 0x03: The device complies to ANSI INCITS 301-1997 (SPC-3). */
115: 2, /* 0x04: The device complies to ANSI INCITS 351-2001 (SPC-2). */
116: 3, /* 0x05: The device complies to ANSI INCITS 408-2005 (SPC-3). */
117: 4, /* 0x06: The device complies to SPC-4. */
118: 0, /* 0x07: RESERVED. */
119: };
120:
121: int
122: scsiprint(void *aux, const char *pnp)
123: {
124: /* only "scsibus"es can attach to "scsi"s; easy. */
125: if (pnp)
126: printf("scsibus at %s", pnp);
127:
128: return (UNCONF);
129: }
130:
131: int
132: scsibusmatch(struct device *parent, void *match, void *aux)
133: {
134: return (1);
135: }
136:
137: /*
138: * The routine called by the adapter boards to get all their
139: * devices configured in.
140: */
141: void
142: scsibusattach(struct device *parent, struct device *self, void *aux)
143: {
144: struct scsibus_softc *sb = (struct scsibus_softc *)self;
145: struct scsibus_attach_args *saa = aux;
146: struct scsi_link *sc_link_proto = saa->saa_sc_link;
147: int nbytes, i;
148:
149: if (!cold)
150: scsi_autoconf = 0;
151:
152: sc_link_proto->scsibus = sb->sc_dev.dv_unit;
153: sb->adapter_link = sc_link_proto;
154: if (sb->adapter_link->adapter_buswidth == 0)
155: sb->adapter_link->adapter_buswidth = 8;
156: sb->sc_buswidth = sb->adapter_link->adapter_buswidth;
157: if (sb->adapter_link->luns == 0)
158: sb->adapter_link->luns = 8;
159:
160: printf(": %d targets\n", sb->sc_buswidth);
161:
162: /* Initialize shared data. */
163: scsi_init();
164:
165: nbytes = sb->sc_buswidth * sizeof(struct scsi_link **);
166: sb->sc_link = malloc(nbytes, M_DEVBUF, M_NOWAIT);
167: if (sb->sc_link == NULL)
168: panic("scsibusattach: can't allocate target links");
169: nbytes = sb->adapter_link->luns * sizeof(struct scsi_link *);
170: for (i = 0; i < sb->sc_buswidth; i++) {
171: sb->sc_link[i] = malloc(nbytes, M_DEVBUF, M_NOWAIT);
172: if (sb->sc_link[i] == NULL)
173: panic("scsibusattach: can't allocate lun links");
174: bzero(sb->sc_link[i], nbytes);
175: }
176:
177: #if NBIO > 0
178: if (bio_register(&sb->sc_dev, scsibus_bioctl) != 0)
179: printf("%s: unable to register bio\n", sb->sc_dev.dv_xname);
180: #endif
181:
182: scsi_probe_bus(sb);
183: }
184:
185: int
186: scsibusactivate(struct device *dev, enum devact act)
187: {
188: return (config_activate_children(dev, act));
189: }
190:
191: int
192: scsibusdetach(struct device *dev, int type)
193: {
194: struct scsibus_softc *sb = (struct scsibus_softc *)dev;
195: int i, j, error;
196:
197: #if NBIO > 0
198: bio_unregister(&sb->sc_dev);
199: #endif
200:
201: if ((error = config_detach_children(dev, type)) != 0)
202: return (error);
203:
204: for (i = 0; i < sb->sc_buswidth; i++) {
205: if (sb->sc_link[i] != NULL) {
206: for (j = 0; j < sb->adapter_link->luns; j++) {
207: if (sb->sc_link[i][j] != NULL)
208: free(sb->sc_link[i][j], M_DEVBUF);
209: }
210: free(sb->sc_link[i], M_DEVBUF);
211: }
212: }
213:
214: free(sb->sc_link, M_DEVBUF);
215:
216: /* Free shared data. */
217: scsi_deinit();
218:
219: return (0);
220: }
221:
222: int
223: scsibussubmatch(struct device *parent, void *match, void *aux)
224: {
225: struct cfdata *cf = match;
226: struct scsi_attach_args *sa = aux;
227: struct scsi_link *sc_link = sa->sa_sc_link;
228:
229: if (cf->cf_loc[0] != -1 && cf->cf_loc[0] != sc_link->target)
230: return (0);
231: if (cf->cf_loc[1] != -1 && cf->cf_loc[1] != sc_link->lun)
232: return (0);
233:
234: return ((*cf->cf_attach->ca_match)(parent, match, aux));
235: }
236:
237: #if NBIO > 0
238: int
239: scsibus_bioctl(struct device *dev, u_long cmd, caddr_t addr)
240: {
241: struct scsibus_softc *sc = (struct scsibus_softc *)dev;
242: struct sbioc_device *sdev;
243:
244: switch (cmd) {
245: case SBIOCPROBE:
246: sdev = (struct sbioc_device *)addr;
247:
248: if (sdev->sd_target == -1 && sdev->sd_lun == -1)
249: return (scsi_probe_bus(sc));
250:
251: /* specific lun and wildcard target is bad */
252: if (sdev->sd_target == -1)
253: return (EINVAL);
254:
255: if (sdev->sd_lun == -1)
256: return (scsi_probe_target(sc, sdev->sd_target));
257:
258: return (scsi_probe_lun(sc, sdev->sd_target, sdev->sd_lun));
259:
260: case SBIOCDETACH:
261: sdev = (struct sbioc_device *)addr;
262:
263: if (sdev->sd_target == -1)
264: return (EINVAL);
265:
266: if (sdev->sd_lun == -1)
267: return (scsi_detach_target(sc, sdev->sd_target, 0));
268:
269: return (scsi_detach_lun(sc, sdev->sd_target, sdev->sd_lun, 0));
270:
271: default:
272: return (ENOTTY);
273: }
274: }
275: #endif
276:
277: int
278: scsi_probe_bus(struct scsibus_softc *sc)
279: {
280: struct scsi_link *alink = sc->adapter_link;
281: int i;
282:
283: for (i = 0; i < alink->adapter_buswidth; i++)
284: scsi_probe_target(sc, i);
285:
286: return (0);
287: }
288:
289: int
290: scsi_probe_target(struct scsibus_softc *sc, int target)
291: {
292: struct scsi_link *alink = sc->adapter_link;
293: struct scsi_link *link;
294: struct scsi_report_luns_data *report;
295: int i, nluns, lun;
296:
297: if (scsi_probe_lun(sc, target, 0) == EINVAL)
298: return (EINVAL);
299:
300: link = sc->sc_link[target][0];
301: if (link == NULL)
302: return (ENXIO);
303:
304: if ((link->flags & (SDEV_UMASS | SDEV_ATAPI)) == 0 &&
305: SCSISPC(link->inqdata.version) > 2) {
306: report = malloc(sizeof(*report), M_TEMP, M_WAITOK);
307: if (report == NULL)
308: goto dumbscan;
309:
310: if (scsi_report_luns(link, REPORT_NORMAL, report,
311: sizeof(*report), scsi_autoconf | SCSI_SILENT |
312: SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY |
313: SCSI_IGNORE_MEDIA_CHANGE, 10000) != 0) {
314: free(report, M_TEMP);
315: goto dumbscan;
316: }
317:
318: /*
319: * XXX In theory we should check if data is full, which
320: * would indicate it needs to be enlarged and REPORT
321: * LUNS tried again. Solaris tries up to 3 times with
322: * larger sizes for data.
323: */
324: nluns = _4btol(report->length) / RPL_LUNDATA_SIZE;
325: for (i = 0; i < nluns; i++) {
326: if (report->luns[i].lundata[0] != 0)
327: continue;
328: lun = report->luns[i].lundata[RPL_LUNDATA_T0LUN];
329: if (lun == 0)
330: continue;
331:
332: /* Probe the provided LUN. Don't check LUN 0. */
333: sc->sc_link[target][0] = NULL;
334: scsi_probe_lun(sc, target, lun);
335: sc->sc_link[target][0] = link;
336: }
337:
338: free(report, M_TEMP);
339: return (0);
340: }
341:
342: dumbscan:
343: for (i = 1; i < alink->luns; i++) {
344: if (scsi_probe_lun(sc, target, i) == EINVAL)
345: break;
346: }
347:
348: return (0);
349: }
350:
351: int
352: scsi_probe_lun(struct scsibus_softc *sc, int target, int lun)
353: {
354: struct scsi_link *alink = sc->adapter_link;
355:
356: if (target < 0 || target >= alink->adapter_buswidth ||
357: target == alink->adapter_target ||
358: lun < 0 || lun >= alink->luns)
359: return (ENXIO);
360:
361: return (scsi_probedev(sc, target, lun));
362: }
363:
364: int
365: scsi_detach_bus(struct scsibus_softc *sc, int flags)
366: {
367: struct scsi_link *alink = sc->adapter_link;
368: int i;
369:
370: for (i = 0; i < alink->adapter_buswidth; i++)
371: scsi_detach_target(sc, i, flags);
372:
373: return (0);
374: }
375:
376: int
377: scsi_detach_target(struct scsibus_softc *sc, int target, int flags)
378: {
379: struct scsi_link *alink = sc->adapter_link;
380: int i, err, rv = 0, detached = 0;
381:
382: if (target < 0 || target >= alink->adapter_buswidth ||
383: target == alink->adapter_target)
384: return (ENXIO);
385:
386: if (sc->sc_link[target] == NULL)
387: return (ENXIO);
388:
389: for (i = 0; i < alink->luns; i++) { /* nicer backwards? */
390: if (sc->sc_link[target][i] == NULL)
391: continue;
392:
393: err = scsi_detach_lun(sc, target, i, flags);
394: if (err != 0)
395: rv = err;
396: detached = 1;
397: }
398:
399: return (detached ? rv : ENXIO);
400: }
401:
402: int
403: scsi_detach_lun(struct scsibus_softc *sc, int target, int lun, int flags)
404: {
405: struct scsi_link *alink = sc->adapter_link;
406: struct scsi_link *link;
407: int rv;
408:
409: if (target < 0 || target >= alink->adapter_buswidth ||
410: target == alink->adapter_target ||
411: lun < 0 || lun >= alink->luns)
412: return (ENXIO);
413:
414: if (sc->sc_link[target] == NULL)
415: return (ENXIO);
416:
417: link = sc->sc_link[target][lun];
418: if (link == NULL)
419: return (ENXIO);
420:
421: if (((flags & DETACH_FORCE) == 0) && (link->flags & SDEV_OPEN))
422: return (EBUSY);
423:
424: /* detaching a device from scsibus is a two step process... */
425:
426: /* 1. detach the device */
427: rv = config_detach(link->device_softc, flags);
428: if (rv != 0)
429: return (rv);
430:
431: /* 2. free up its state in the midlayer */
432: free(link, M_DEVBUF);
433: sc->sc_link[target][lun] = NULL;
434:
435: return (0);
436: }
437:
438: void
439: scsi_strvis(u_char *dst, u_char *src, int len)
440: {
441: u_char last;
442:
443: /* Trim leading and trailing whitespace and NULs. */
444: while (len > 0 && (src[0] == ' ' || src[0] == '\t' || src[0] == '\n' ||
445: src[0] == '\0' || src[0] == 0xff))
446: ++src, --len;
447: while (len > 0 && (src[len-1] == ' ' || src[len-1] == '\t' ||
448: src[len-1] == '\n' || src[len-1] == '\0' || src[len-1] == 0xff))
449: --len;
450:
451: last = 0xff;
452: while (len > 0) {
453: switch (*src) {
454: case ' ':
455: case '\t':
456: case '\n':
457: case '\0':
458: case 0xff:
459: /* collapse whitespace and NULs to a single space */
460: if (last != ' ')
461: *dst++ = ' ';
462: last = ' ';
463: break;
464: case '\\':
465: /* quote characters */
466: *dst++ = '\\';
467: *dst++ = '\\';
468: last = '\\';
469: break;
470: default:
471: if (*src < 0x20 || *src >= 0x80) {
472: /* non-printable characters */
473: *dst++ = '\\';
474: *dst++ = ((*src & 0300) >> 6) + '0';
475: *dst++ = ((*src & 0070) >> 3) + '0';
476: *dst++ = ((*src & 0007) >> 0) + '0';
477: } else {
478: /* normal characters */
479: *dst++ = *src;
480: }
481: last = *src;
482: break;
483: }
484: ++src, --len;
485: }
486:
487: *dst++ = 0;
488: }
489:
490: struct scsi_quirk_inquiry_pattern {
491: struct scsi_inquiry_pattern pattern;
492: u_int16_t quirks;
493: };
494:
495: const struct scsi_quirk_inquiry_pattern scsi_quirk_patterns[] = {
496: {{T_CDROM, T_REMOV,
497: "PLEXTOR", "CD-ROM PX-40TS", "1.01"}, SDEV_NOSYNC},
498:
499: {{T_DIRECT, T_FIXED,
500: "MICROP ", "1588-15MBSUN0669", ""}, SDEV_AUTOSAVE},
501: {{T_DIRECT, T_FIXED,
502: "DEC ", "RZ55 (C) DEC", ""}, SDEV_AUTOSAVE},
503: {{T_DIRECT, T_FIXED,
504: "EMULEX ", "MD21/S2 ESDI", "A00"}, SDEV_AUTOSAVE},
505: {{T_DIRECT, T_FIXED,
506: "IBMRAID ", "0662S", ""}, SDEV_AUTOSAVE},
507: {{T_DIRECT, T_FIXED,
508: "IBM ", "0663H", ""}, SDEV_AUTOSAVE},
509: {{T_DIRECT, T_FIXED,
510: "IBM", "0664", ""}, SDEV_AUTOSAVE},
511: {{T_DIRECT, T_FIXED,
512: "IBM ", "H3171-S2", ""}, SDEV_AUTOSAVE},
513: {{T_DIRECT, T_FIXED,
514: "IBM ", "KZ-C", ""}, SDEV_AUTOSAVE},
515: /* Broken IBM disk */
516: {{T_DIRECT, T_FIXED,
517: "" , "DFRSS2F", ""}, SDEV_AUTOSAVE},
518: {{T_DIRECT, T_FIXED,
519: "QUANTUM ", "ELS85S ", ""}, SDEV_AUTOSAVE},
520: {{T_DIRECT, T_REMOV,
521: "iomega", "jaz 1GB", ""}, SDEV_NOTAGS},
522: {{T_DIRECT, T_FIXED,
523: "MICROP", "4421-07", ""}, SDEV_NOTAGS},
524: {{T_DIRECT, T_FIXED,
525: "SEAGATE", "ST150176LW", "0002"}, SDEV_NOTAGS},
526: {{T_DIRECT, T_FIXED,
527: "HP", "C3725S", ""}, SDEV_NOTAGS},
528: {{T_DIRECT, T_FIXED,
529: "IBM", "DCAS", ""}, SDEV_NOTAGS},
530:
531: {{T_SEQUENTIAL, T_REMOV,
532: "SONY ", "SDT-5000 ", "3."}, SDEV_NOSYNC|SDEV_NOWIDE},
533: {{T_SEQUENTIAL, T_REMOV,
534: "WangDAT ", "Model 1300 ", "02.4"}, SDEV_NOSYNC|SDEV_NOWIDE},
535: {{T_SEQUENTIAL, T_REMOV,
536: "WangDAT ", "Model 2600 ", "01.7"}, SDEV_NOSYNC|SDEV_NOWIDE},
537: {{T_SEQUENTIAL, T_REMOV,
538: "WangDAT ", "Model 3200 ", "02.2"}, SDEV_NOSYNC|SDEV_NOWIDE},
539:
540: /* ATAPI device quirks */
541: {{T_CDROM, T_REMOV,
542: "ALPS ELECTRIC CO.,LTD. DC544C", "", "SW03D"}, ADEV_NOTUR},
543: {{T_CDROM, T_REMOV,
544: "CR-2801TE", "", "1.07"}, ADEV_NOSENSE},
545: {{T_CDROM, T_REMOV,
546: "CREATIVECD3630E", "", "AC101"}, ADEV_NOSENSE},
547: {{T_CDROM, T_REMOV,
548: "FX320S", "", "q01"}, ADEV_NOSENSE},
549: {{T_CDROM, T_REMOV,
550: "GCD-R580B", "", "1.00"}, ADEV_LITTLETOC},
551: {{T_CDROM, T_REMOV,
552: "MATSHITA CR-574", "", "1.02"}, ADEV_NOCAPACITY},
553: {{T_CDROM, T_REMOV,
554: "MATSHITA CR-574", "", "1.06"}, ADEV_NOCAPACITY},
555: {{T_CDROM, T_REMOV,
556: "Memorex CRW-2642", "", "1.0g"}, ADEV_NOSENSE},
557: {{T_CDROM, T_REMOV,
558: "NEC CD-ROM DRIVE:273", "", "4.21"}, ADEV_NOTUR},
559: {{T_CDROM, T_REMOV,
560: "SANYO CRD-256P", "", "1.02"}, ADEV_NOCAPACITY},
561: {{T_CDROM, T_REMOV,
562: "SANYO CRD-254P", "", "1.02"}, ADEV_NOCAPACITY},
563: {{T_CDROM, T_REMOV,
564: "SANYO CRD-S54P", "", "1.08"}, ADEV_NOCAPACITY},
565: {{T_CDROM, T_REMOV,
566: "CD-ROM CDR-S1", "", "1.70"}, ADEV_NOCAPACITY}, /* Sanyo */
567: {{T_CDROM, T_REMOV,
568: "CD-ROM CDR-N16", "", "1.25"}, ADEV_NOCAPACITY}, /* Sanyo */
569: {{T_CDROM, T_REMOV,
570: "UJDCD8730", "", "1.14"}, ADEV_NODOORLOCK}, /* Acer */
571: };
572:
573:
574: /*
575: * Print out autoconfiguration information for a subdevice.
576: *
577: * This is a slight abuse of 'standard' autoconfiguration semantics,
578: * because 'print' functions don't normally print the colon and
579: * device information. However, in this case that's better than
580: * either printing redundant information before the attach message,
581: * or having the device driver call a special function to print out
582: * the standard device information.
583: */
584: int
585: scsibusprint(void *aux, const char *pnp)
586: {
587: struct scsi_attach_args *sa = aux;
588: struct scsi_inquiry_data *inqbuf;
589: u_int8_t type;
590: int removable;
591: char *dtype, *qtype;
592: char vendor[33], product[65], revision[17];
593: int target, lun;
594:
595: if (pnp != NULL)
596: printf("%s", pnp);
597:
598: inqbuf = sa->sa_inqbuf;
599:
600: target = sa->sa_sc_link->target;
601: lun = sa->sa_sc_link->lun;
602:
603: type = inqbuf->device & SID_TYPE;
604: removable = inqbuf->dev_qual2 & SID_REMOVABLE ? 1 : 0;
605:
606: /*
607: * Figure out basic device type and qualifier.
608: */
609: dtype = 0;
610: switch (inqbuf->device & SID_QUAL) {
611: case SID_QUAL_LU_OK:
612: qtype = "";
613: break;
614:
615: case SID_QUAL_LU_OFFLINE:
616: qtype = " offline";
617: break;
618:
619: case SID_QUAL_RSVD:
620: panic("scsibusprint: qualifier == SID_QUAL_RSVD");
621:
622: case SID_QUAL_BAD_LU:
623: panic("scsibusprint: qualifier == SID_QUAL_BAD_LU");
624:
625: default:
626: qtype = "";
627: dtype = "vendor-unique";
628: break;
629: }
630: if (dtype == 0) {
631: switch (type) {
632: case T_DIRECT:
633: dtype = "direct";
634: break;
635: case T_SEQUENTIAL:
636: dtype = "sequential";
637: break;
638: case T_PRINTER:
639: dtype = "printer";
640: break;
641: case T_PROCESSOR:
642: dtype = "processor";
643: break;
644: case T_CDROM:
645: dtype = "cdrom";
646: break;
647: case T_WORM:
648: dtype = "worm";
649: break;
650: case T_SCANNER:
651: dtype = "scanner";
652: break;
653: case T_OPTICAL:
654: dtype = "optical";
655: break;
656: case T_CHANGER:
657: dtype = "changer";
658: break;
659: case T_COMM:
660: dtype = "communication";
661: break;
662: case T_ENCLOSURE:
663: dtype = "enclosure services";
664: break;
665: case T_RDIRECT:
666: dtype = "simplified direct";
667: break;
668: case T_NODEVICE:
669: panic("scsibusprint: device type T_NODEVICE");
670: default:
671: dtype = "unknown";
672: break;
673: }
674: }
675:
676: scsi_strvis(vendor, inqbuf->vendor, 8);
677: scsi_strvis(product, inqbuf->product, 16);
678: scsi_strvis(revision, inqbuf->revision, 4);
679:
680: printf(" targ %d lun %d: <%s, %s, %s> SCSI%d %d/%s %s%s",
681: target, lun, vendor, product, revision,
682: SCSISPC(inqbuf->version), type, dtype,
683: removable ? "removable" : "fixed", qtype);
684:
685: return (UNCONF);
686: }
687:
688: /*
689: * Given a target and lun, ask the device what it is, and find the correct
690: * driver table entry.
691: *
692: * Return 0 if further LUNs are possible, EINVAL if not.
693: */
694: int
695: scsi_probedev(struct scsibus_softc *scsi, int target, int lun)
696: {
697: const struct scsi_quirk_inquiry_pattern *finger;
698: static struct scsi_inquiry_data inqbuf;
699: struct scsi_attach_args sa;
700: struct scsi_link *sc_link;
701: struct cfdata *cf;
702: int priority, rslt = 0;
703:
704: /* Skip this slot if it is already attached and try the next LUN. */
705: if (scsi->sc_link[target][lun] != NULL)
706: return (0);
707:
708: sc_link = malloc(sizeof(*sc_link), M_DEVBUF, M_NOWAIT);
709: if (sc_link == NULL)
710: return (EINVAL);
711:
712: *sc_link = *scsi->adapter_link;
713: sc_link->target = target;
714: sc_link->lun = lun;
715: sc_link->device = &probe_switch;
716:
717: SC_DEBUG(sc_link, SDEV_DB2, ("scsi_link created.\n"));
718:
719: /*
720: * Tell drivers that are paying attention to avoid sync/wide/tags until
721: * INQUIRY data has been processed and the quirks information is
722: * complete. Some drivers set bits in quirks before we get here, so
723: * just add NOTAGS, NOWIDE and NOSYNC.
724: */
725: sc_link->quirks |= SDEV_NOSYNC | SDEV_NOWIDE | SDEV_NOTAGS;
726:
727: /*
728: * Ask the device what it is
729: */
730: #ifdef SCSIDEBUG
731: if (((1 << sc_link->scsibus) & scsidebug_buses) &&
732: ((1 << target) & scsidebug_targets) &&
733: ((1 << lun) & scsidebug_luns))
734: sc_link->flags |= scsidebug_level;
735: #endif /* SCSIDEBUG */
736:
737: #if defined(mvme68k)
738: if (lun == 0) {
739: /* XXX some drivers depend on this */
740: scsi_test_unit_ready(sc_link, TEST_READY_RETRIES,
741: scsi_autoconf | SCSI_IGNORE_ILLEGAL_REQUEST |
742: SCSI_IGNORE_NOT_READY | SCSI_IGNORE_MEDIA_CHANGE);
743: }
744: #endif
745:
746: /* Now go ask the device all about itself. */
747: rslt = scsi_inquire(sc_link, &inqbuf, scsi_autoconf | SCSI_SILENT);
748: if (rslt != 0) {
749: SC_DEBUG(sc_link, SDEV_DB2, ("Bad LUN. rslt = %i\n", rslt));
750: if (lun == 0)
751: rslt = EINVAL;
752: goto bad;
753: }
754:
755: switch (inqbuf.device & SID_QUAL) {
756: case SID_QUAL_RSVD:
757: case SID_QUAL_BAD_LU:
758: case SID_QUAL_LU_OFFLINE:
759: SC_DEBUG(sc_link, SDEV_DB1,
760: ("Bad LUN. SID_QUAL = 0x%02x\n", inqbuf.device & SID_QUAL));
761: goto bad;
762:
763: case SID_QUAL_LU_OK:
764: if ((inqbuf.device & SID_TYPE) == T_NODEVICE) {
765: SC_DEBUG(sc_link, SDEV_DB1,
766: ("Bad LUN. SID_TYPE = T_NODEVICE\n"));
767: goto bad;
768: }
769: break;
770:
771: default:
772: break;
773: }
774:
775: if (lun == 0 || scsi->sc_link[target][0] == NULL)
776: ;
777: else if (sc_link->flags & SDEV_UMASS)
778: ;
779: else if (memcmp(&inqbuf, &scsi->sc_link[target][0]->inqdata,
780: sizeof inqbuf) == 0) {
781: /* The device doesn't distinguish between LUNs. */
782: SC_DEBUG(sc_link, SDEV_DB1, ("IDENTIFY not supported.\n"));
783: rslt = EINVAL;
784: goto bad;
785: }
786:
787: finger = (const struct scsi_quirk_inquiry_pattern *)scsi_inqmatch(
788: &inqbuf, scsi_quirk_patterns,
789: sizeof(scsi_quirk_patterns)/sizeof(scsi_quirk_patterns[0]),
790: sizeof(scsi_quirk_patterns[0]), &priority);
791:
792: /*
793: * Based upon the inquiry flags we got back, and if we're
794: * at SCSI-2 or better, remove some limiting quirks.
795: */
796: if (SCSISPC(inqbuf.version) >= 2) {
797: if ((inqbuf.flags & SID_CmdQue) != 0)
798: sc_link->quirks &= ~SDEV_NOTAGS;
799: if ((inqbuf.flags & SID_Sync) != 0)
800: sc_link->quirks &= ~SDEV_NOSYNC;
801: if ((inqbuf.flags & SID_WBus16) != 0)
802: sc_link->quirks &= ~SDEV_NOWIDE;
803: }
804: /*
805: * Now apply any quirks from the table.
806: */
807: if (priority != 0)
808: sc_link->quirks |= finger->quirks;
809:
810: /*
811: * Save INQUIRY.
812: */
813: memcpy(&sc_link->inqdata, &inqbuf, sizeof(sc_link->inqdata));
814:
815: /*
816: * note what BASIC type of device it is
817: */
818: if ((inqbuf.dev_qual2 & SID_REMOVABLE) != 0)
819: sc_link->flags |= SDEV_REMOVABLE;
820:
821: sa.sa_sc_link = sc_link;
822: sa.sa_inqbuf = &sc_link->inqdata;
823:
824: if ((cf = config_search(scsibussubmatch, (struct device *)scsi,
825: &sa)) == 0) {
826: scsibusprint(&sa, scsi->sc_dev.dv_xname);
827: printf(" not configured\n");
828: goto bad;
829: }
830:
831: /*
832: * Braindead USB devices, especially some x-in-1 media readers, try to
833: * 'help' by pretending any LUN is actually LUN 0 until they see a
834: * different LUN used in a command. So do an INQUIRY on LUN 1 at this
835: * point (since we are done with the data in inqbuf) to prevent such
836: * helpfulness before it causes confusion.
837: */
838: if (lun == 0 && (sc_link->flags & SDEV_UMASS) &&
839: scsi->sc_link[target][1] == NULL && sc_link->luns > 1) {
840: sc_link->lun = 1;
841: scsi_inquire(sc_link, &inqbuf, scsi_autoconf | SCSI_SILENT);
842: sc_link->lun = 0;
843: }
844:
845: scsi->sc_link[target][lun] = sc_link;
846:
847: /*
848: * Generate a TEST_UNIT_READY command. This gives drivers waiting for
849: * valid quirks data a chance to set wide/sync/tag options
850: * appropriately. It also clears any outstanding ACA conditions that
851: * INQUIRY may leave behind.
852: *
853: * Do this now so that any messages generated by config_attach() do not
854: * have negotiation messages inserted into their midst.
855: */
856: scsi_test_unit_ready(sc_link, TEST_READY_RETRIES,
857: scsi_autoconf | SCSI_IGNORE_ILLEGAL_REQUEST |
858: SCSI_IGNORE_NOT_READY | SCSI_IGNORE_MEDIA_CHANGE);
859:
860: config_attach((struct device *)scsi, cf, &sa, scsibusprint);
861:
862: return (0);
863:
864: bad:
865: free(sc_link, M_DEVBUF);
866: return (rslt);
867: }
868:
869: /*
870: * Return a priority based on how much of the inquiry data matches
871: * the patterns for the particular driver.
872: */
873: const void *
874: scsi_inqmatch(struct scsi_inquiry_data *inqbuf, const void *_base,
875: int nmatches, int matchsize, int *bestpriority)
876: {
877: u_int8_t type;
878: int removable;
879: const void *bestmatch;
880: const unsigned char *base = (const unsigned char *)_base;
881:
882: /* Include the qualifier to catch vendor-unique types. */
883: type = inqbuf->device;
884: removable = inqbuf->dev_qual2 & SID_REMOVABLE ? T_REMOV : T_FIXED;
885:
886: for (*bestpriority = 0, bestmatch = 0; nmatches--; base += matchsize) {
887: struct scsi_inquiry_pattern *match = (void *)base;
888: int priority, len;
889:
890: if (type != match->type)
891: continue;
892: if (removable != match->removable)
893: continue;
894: priority = 2;
895: len = strlen(match->vendor);
896: if (bcmp(inqbuf->vendor, match->vendor, len))
897: continue;
898: priority += len;
899: len = strlen(match->product);
900: if (bcmp(inqbuf->product, match->product, len))
901: continue;
902: priority += len;
903: len = strlen(match->revision);
904: if (bcmp(inqbuf->revision, match->revision, len))
905: continue;
906: priority += len;
907:
908: #if SCSIDEBUG
909: printf("scsi_inqmatch: %d/%d/%d <%s, %s, %s>\n",
910: priority, match->type, match->removable,
911: match->vendor, match->product, match->revision);
912: #endif
913: if (priority > *bestpriority) {
914: *bestpriority = priority;
915: bestmatch = base;
916: }
917: }
918:
919: return (bestmatch);
920: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to scsiconf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / scsi