Annotation of sys/scsi/ch.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: ch.c,v 1.32 2006/11/28 16:56:50 dlg Exp $ */
2: /* $NetBSD: ch.c,v 1.26 1997/02/21 22:06:52 thorpej Exp $ */
3:
4: /*
5: * Copyright (c) 1996, 1997 Jason R. Thorpe <thorpej@and.com>
6: * All rights reserved.
7: *
8: * Partially based on an autochanger driver written by Stefan Grefen
9: * and on an autochanger driver written by the Systems Programming Group
10: * at the University of Utah Computer Science Department.
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: * 3. All advertising materials mentioning features or use of this software
21: * must display the following acknowledgements:
22: * This product includes software developed by Jason R. Thorpe
23: * for And Communications, http://www.and.com/
24: * 4. The name of the author may not be used to endorse or promote products
25: * derived from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
28: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
29: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
30: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
31: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
32: * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
33: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
34: * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
35: * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37: * SUCH DAMAGE.
38: */
39:
40: #include <sys/param.h>
41: #include <sys/systm.h>
42: #include <sys/errno.h>
43: #include <sys/ioctl.h>
44: #include <sys/buf.h>
45: #include <sys/proc.h>
46: #include <sys/user.h>
47: #include <sys/chio.h>
48: #include <sys/device.h>
49: #include <sys/malloc.h>
50: #include <sys/conf.h>
51: #include <sys/fcntl.h>
52:
53: #include <scsi/scsi_all.h>
54: #include <scsi/scsi_changer.h>
55: #include <scsi/scsiconf.h>
56:
57: #define CHRETRIES 2
58: #define CHUNIT(x) (minor((x)))
59:
60: struct ch_softc {
61: struct device sc_dev; /* generic device info */
62: struct scsi_link *sc_link; /* link in the SCSI bus */
63:
64: int sc_picker; /* current picker */
65:
66: /*
67: * The following information is obtained from the
68: * element address assignment page.
69: */
70: int sc_firsts[4]; /* firsts, indexed by CHET_* */
71: int sc_counts[4]; /* counts, indexed by CHET_* */
72:
73: /*
74: * The following mask defines the legal combinations
75: * of elements for the MOVE MEDIUM command.
76: */
77: u_int8_t sc_movemask[4];
78:
79: /*
80: * As above, but for EXCHANGE MEDIUM.
81: */
82: u_int8_t sc_exchangemask[4];
83:
84: int flags; /* misc. info */
85:
86: /*
87: * Quirks; see below.
88: */
89: int sc_settledelay; /* delay for settle */
90:
91: };
92:
93: /* sc_flags */
94: #define CHF_ROTATE 0x01 /* picker can rotate */
95:
96: /* Autoconfiguration glue */
97: int chmatch(struct device *, void *, void *);
98: void chattach(struct device *, struct device *, void *);
99:
100: struct cfattach ch_ca = {
101: sizeof(struct ch_softc), chmatch, chattach
102: };
103:
104: struct cfdriver ch_cd = {
105: NULL, "ch", DV_DULL
106: };
107:
108: const struct scsi_inquiry_pattern ch_patterns[] = {
109: {T_CHANGER, T_REMOV,
110: "", "", ""},
111: };
112:
113: int ch_move(struct ch_softc *, struct changer_move *);
114: int ch_exchange(struct ch_softc *, struct changer_exchange *);
115: int ch_position(struct ch_softc *, struct changer_position *);
116: int ch_usergetelemstatus(struct ch_softc *,
117: struct changer_element_status_request *);
118: int ch_getelemstatus(struct ch_softc *, int, int, caddr_t, size_t, int);
119: int ch_get_params(struct ch_softc *, int);
120: int ch_interpret_sense(struct scsi_xfer *xs);
121: void ch_get_quirks(struct ch_softc *, struct scsi_inquiry_data *);
122:
123: /* SCSI glue */
124: struct scsi_device ch_switch = {
125: ch_interpret_sense,
126: NULL,
127: NULL,
128: NULL
129: };
130:
131: /*
132: * SCSI changer quirks.
133: */
134: struct chquirk {
135: struct scsi_inquiry_pattern cq_match; /* device id pattern */
136: int cq_settledelay; /* settle delay, in seconds */
137: };
138:
139: struct chquirk chquirks[] = {
140: {{T_CHANGER, T_REMOV,
141: "SPECTRA", "9000", "0200"},
142: 75},
143: };
144:
145: int
146: chmatch(parent, match, aux)
147: struct device *parent;
148: void *match, *aux;
149: {
150: struct scsi_attach_args *sa = aux;
151: int priority;
152:
153: (void)scsi_inqmatch(sa->sa_inqbuf,
154: ch_patterns, sizeof(ch_patterns)/sizeof(ch_patterns[0]),
155: sizeof(ch_patterns[0]), &priority);
156:
157: return (priority);
158: }
159:
160: void
161: chattach(parent, self, aux)
162: struct device *parent, *self;
163: void *aux;
164: {
165: struct ch_softc *sc = (struct ch_softc *)self;
166: struct scsi_attach_args *sa = aux;
167: struct scsi_link *link = sa->sa_sc_link;
168:
169: /* Glue into the SCSI bus */
170: sc->sc_link = link;
171: link->device = &ch_switch;
172: link->device_softc = sc;
173: link->openings = 1;
174:
175: printf("\n");
176:
177: /*
178: * Store our our device's quirks.
179: */
180: ch_get_quirks(sc, sa->sa_inqbuf);
181:
182: }
183:
184: int
185: chopen(dev, flags, fmt, p)
186: dev_t dev;
187: int flags, fmt;
188: struct proc *p;
189: {
190: struct ch_softc *sc;
191: int oldcounts[4];
192: int i, unit, error = 0;
193:
194: unit = CHUNIT(dev);
195: if ((unit >= ch_cd.cd_ndevs) ||
196: ((sc = ch_cd.cd_devs[unit]) == NULL))
197: return (ENXIO);
198:
199: /*
200: * Only allow one open at a time.
201: */
202: if (sc->sc_link->flags & SDEV_OPEN)
203: return (EBUSY);
204:
205: sc->sc_link->flags |= SDEV_OPEN;
206:
207: /*
208: * Absorb any unit attention errors. We must notice
209: * "Not ready" errors as a changer will report "In the
210: * process of getting ready" any time it must rescan
211: * itself to determine the state of the changer.
212: */
213: error = scsi_test_unit_ready(sc->sc_link, TEST_READY_RETRIES,
214: SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
215: if (error)
216: goto bad;
217:
218: /*
219: * Get information about the device. Save old information
220: * so we can decide whether to be verbose about new parameters.
221: */
222: for (i = 0; i < 4; i++) {
223: oldcounts[i] = sc->sc_counts[i];
224: }
225: error = ch_get_params(sc, scsi_autoconf);
226: if (error)
227: goto bad;
228:
229: for (i = 0; i < 4; i++) {
230: if (oldcounts[i] != sc->sc_counts[i]) {
231: break;
232: }
233: }
234: if (i < 4) {
235: #ifdef CHANGER_DEBUG
236: #define PLURAL(c) (c) == 1 ? "" : "s"
237: printf("%s: %d slot%s, %d drive%s, %d picker%s, %d portal%s\n",
238: sc->sc_dev.dv_xname,
239: sc->sc_counts[CHET_ST], PLURAL(sc->sc_counts[CHET_ST]),
240: sc->sc_counts[CHET_DT], PLURAL(sc->sc_counts[CHET_DT]),
241: sc->sc_counts[CHET_MT], PLURAL(sc->sc_counts[CHET_MT]),
242: sc->sc_counts[CHET_IE], PLURAL(sc->sc_counts[CHET_IE]));
243: #undef PLURAL
244: printf("%s: move mask: 0x%x 0x%x 0x%x 0x%x\n",
245: sc->sc_dev.dv_xname,
246: sc->sc_movemask[CHET_MT], sc->sc_movemask[CHET_ST],
247: sc->sc_movemask[CHET_IE], sc->sc_movemask[CHET_DT]);
248: printf("%s: exchange mask: 0x%x 0x%x 0x%x 0x%x\n",
249: sc->sc_dev.dv_xname,
250: sc->sc_exchangemask[CHET_MT], sc->sc_exchangemask[CHET_ST],
251: sc->sc_exchangemask[CHET_IE], sc->sc_exchangemask[CHET_DT]);
252: #endif /* CHANGER_DEBUG */
253: }
254:
255: /* Default the current picker. */
256: sc->sc_picker = sc->sc_firsts[CHET_MT];
257:
258: return (0);
259:
260: bad:
261: sc->sc_link->flags &= ~SDEV_OPEN;
262: return (error);
263: }
264:
265: int
266: chclose(dev, flags, fmt, p)
267: dev_t dev;
268: int flags, fmt;
269: struct proc *p;
270: {
271: struct ch_softc *sc = ch_cd.cd_devs[CHUNIT(dev)];
272:
273: sc->sc_link->flags &= ~SDEV_OPEN;
274: return (0);
275: }
276:
277: int
278: chioctl(dev, cmd, data, flags, p)
279: dev_t dev;
280: u_long cmd;
281: caddr_t data;
282: int flags;
283: struct proc *p;
284: {
285: struct ch_softc *sc = ch_cd.cd_devs[CHUNIT(dev)];
286: int error = 0;
287:
288: /*
289: * If this command can change the device's state, we must
290: * have the device open for writing.
291: */
292: switch (cmd) {
293: case CHIOGPICKER:
294: case CHIOGPARAMS:
295: case CHIOGSTATUS:
296: break;
297:
298: default:
299: if ((flags & FWRITE) == 0)
300: return (EBADF);
301: }
302:
303: switch (cmd) {
304: case CHIOMOVE:
305: error = ch_move(sc, (struct changer_move *)data);
306: break;
307:
308: case CHIOEXCHANGE:
309: error = ch_exchange(sc, (struct changer_exchange *)data);
310: break;
311:
312: case CHIOPOSITION:
313: error = ch_position(sc, (struct changer_position *)data);
314: break;
315:
316: case CHIOGPICKER:
317: *(int *)data = sc->sc_picker - sc->sc_firsts[CHET_MT];
318: break;
319:
320: case CHIOSPICKER: {
321: int new_picker = *(int *)data;
322:
323: if (new_picker > (sc->sc_counts[CHET_MT] - 1))
324: return (EINVAL);
325: sc->sc_picker = sc->sc_firsts[CHET_MT] + new_picker;
326: break; }
327:
328: case CHIOGPARAMS: {
329: struct changer_params *cp = (struct changer_params *)data;
330:
331: cp->cp_curpicker = sc->sc_picker - sc->sc_firsts[CHET_MT];
332: cp->cp_npickers = sc->sc_counts[CHET_MT];
333: cp->cp_nslots = sc->sc_counts[CHET_ST];
334: cp->cp_nportals = sc->sc_counts[CHET_IE];
335: cp->cp_ndrives = sc->sc_counts[CHET_DT];
336: break; }
337:
338: case CHIOGSTATUS: {
339: struct changer_element_status_request *cesr =
340: (struct changer_element_status_request *)data;
341:
342: error = ch_usergetelemstatus(sc, cesr);
343: break; }
344:
345: /* Implement prevent/allow? */
346:
347: default:
348: error = scsi_do_ioctl(sc->sc_link, dev, cmd, data,
349: flags, p);
350: break;
351: }
352:
353: return (error);
354: }
355:
356: int
357: ch_move(sc, cm)
358: struct ch_softc *sc;
359: struct changer_move *cm;
360: {
361: struct scsi_move_medium cmd;
362: u_int16_t fromelem, toelem;
363:
364: /*
365: * Check arguments.
366: */
367: if ((cm->cm_fromtype > CHET_DT) || (cm->cm_totype > CHET_DT))
368: return (EINVAL);
369: if ((cm->cm_fromunit > (sc->sc_counts[cm->cm_fromtype] - 1)) ||
370: (cm->cm_tounit > (sc->sc_counts[cm->cm_totype] - 1)))
371: return (ENODEV);
372:
373: /*
374: * Check the request against the changer's capabilities.
375: */
376: if ((sc->sc_movemask[cm->cm_fromtype] & (1 << cm->cm_totype)) == 0)
377: return (EINVAL);
378:
379: /*
380: * Calculate the source and destination elements.
381: */
382: fromelem = sc->sc_firsts[cm->cm_fromtype] + cm->cm_fromunit;
383: toelem = sc->sc_firsts[cm->cm_totype] + cm->cm_tounit;
384:
385: /*
386: * Build the SCSI command.
387: */
388: bzero(&cmd, sizeof(cmd));
389: cmd.opcode = MOVE_MEDIUM;
390: _lto2b(sc->sc_picker, cmd.tea);
391: _lto2b(fromelem, cmd.src);
392: _lto2b(toelem, cmd.dst);
393: if (cm->cm_flags & CM_INVERT)
394: cmd.flags |= MOVE_MEDIUM_INVERT;
395:
396: /*
397: * Send command to changer.
398: */
399: return (scsi_scsi_cmd(sc->sc_link, (struct scsi_generic *)&cmd,
400: sizeof(cmd), NULL, 0, CHRETRIES, 100000, NULL, 0));
401: }
402:
403: int
404: ch_exchange(sc, ce)
405: struct ch_softc *sc;
406: struct changer_exchange *ce;
407: {
408: struct scsi_exchange_medium cmd;
409: u_int16_t src, dst1, dst2;
410:
411: /*
412: * Check arguments.
413: */
414: if ((ce->ce_srctype > CHET_DT) || (ce->ce_fdsttype > CHET_DT) ||
415: (ce->ce_sdsttype > CHET_DT))
416: return (EINVAL);
417: if ((ce->ce_srcunit > (sc->sc_counts[ce->ce_srctype] - 1)) ||
418: (ce->ce_fdstunit > (sc->sc_counts[ce->ce_fdsttype] - 1)) ||
419: (ce->ce_sdstunit > (sc->sc_counts[ce->ce_sdsttype] - 1)))
420: return (ENODEV);
421:
422: /*
423: * Check the request against the changer's capabilities.
424: */
425: if (((sc->sc_exchangemask[ce->ce_srctype] &
426: (1 << ce->ce_fdsttype)) == 0) ||
427: ((sc->sc_exchangemask[ce->ce_fdsttype] &
428: (1 << ce->ce_sdsttype)) == 0))
429: return (EINVAL);
430:
431: /*
432: * Calculate the source and destination elements.
433: */
434: src = sc->sc_firsts[ce->ce_srctype] + ce->ce_srcunit;
435: dst1 = sc->sc_firsts[ce->ce_fdsttype] + ce->ce_fdstunit;
436: dst2 = sc->sc_firsts[ce->ce_sdsttype] + ce->ce_sdstunit;
437:
438: /*
439: * Build the SCSI command.
440: */
441: bzero(&cmd, sizeof(cmd));
442: cmd.opcode = EXCHANGE_MEDIUM;
443: _lto2b(sc->sc_picker, cmd.tea);
444: _lto2b(src, cmd.src);
445: _lto2b(dst1, cmd.fdst);
446: _lto2b(dst2, cmd.sdst);
447: if (ce->ce_flags & CE_INVERT1)
448: cmd.flags |= EXCHANGE_MEDIUM_INV1;
449: if (ce->ce_flags & CE_INVERT2)
450: cmd.flags |= EXCHANGE_MEDIUM_INV2;
451:
452: /*
453: * Send command to changer.
454: */
455: return (scsi_scsi_cmd(sc->sc_link, (struct scsi_generic *)&cmd,
456: sizeof(cmd), NULL, 0, CHRETRIES, 100000, NULL, 0));
457: }
458:
459: int
460: ch_position(sc, cp)
461: struct ch_softc *sc;
462: struct changer_position *cp;
463: {
464: struct scsi_position_to_element cmd;
465: u_int16_t dst;
466:
467: /*
468: * Check arguments.
469: */
470: if (cp->cp_type > CHET_DT)
471: return (EINVAL);
472: if (cp->cp_unit > (sc->sc_counts[cp->cp_type] - 1))
473: return (ENODEV);
474:
475: /*
476: * Calculate the destination element.
477: */
478: dst = sc->sc_firsts[cp->cp_type] + cp->cp_unit;
479:
480: /*
481: * Build the SCSI command.
482: */
483: bzero(&cmd, sizeof(cmd));
484: cmd.opcode = POSITION_TO_ELEMENT;
485: _lto2b(sc->sc_picker, cmd.tea);
486: _lto2b(dst, cmd.dst);
487: if (cp->cp_flags & CP_INVERT)
488: cmd.flags |= POSITION_TO_ELEMENT_INVERT;
489:
490: /*
491: * Send command to changer.
492: */
493: return (scsi_scsi_cmd(sc->sc_link, (struct scsi_generic *)&cmd,
494: sizeof(cmd), NULL, 0, CHRETRIES, 100000, NULL, 0));
495: }
496:
497: /*
498: * Copy a volume tag to a volume_tag struct, converting SCSI byte order
499: * to host native byte order in the volume serial number. The volume
500: * label as returned by the changer is transferred to user mode as
501: * nul-terminated string. Volume labels are truncated at the first
502: * space, as suggested by SCSI-2.
503: */
504: static void
505: copy_voltag(struct changer_voltag *uvoltag, struct volume_tag *voltag)
506: {
507: int i;
508:
509: for (i=0; i<CH_VOLTAG_MAXLEN; i++) {
510: char c = voltag->vif[i];
511: if (c && c != ' ')
512: uvoltag->cv_volid[i] = c;
513: else
514: break;
515: }
516: uvoltag->cv_volid[i] = '\0';
517: uvoltag->cv_serial = _2btol(voltag->vsn);
518: }
519:
520: /*
521: * Copy an an element status descriptor to a user-mode
522: * changer_element_status structure.
523: */
524: static void
525: copy_element_status(int flags, struct read_element_status_descriptor *desc,
526: struct changer_element_status *ces)
527: {
528: ces->ces_flags = desc->flags1;
529:
530: if (flags & READ_ELEMENT_STATUS_PVOLTAG)
531: copy_voltag(&ces->ces_pvoltag, &desc->pvoltag);
532: if (flags & READ_ELEMENT_STATUS_AVOLTAG)
533: copy_voltag(&ces->ces_avoltag, &desc->avoltag);
534: }
535:
536: /*
537: * Perform a READ ELEMENT STATUS on behalf of the user, and return to
538: * the user only the data the user is interested in (i.e. an array of
539: * changer_element_status structures)
540: */
541: int
542: ch_usergetelemstatus(sc, cesr)
543: struct ch_softc *sc;
544: struct changer_element_status_request *cesr;
545: {
546: struct changer_element_status *user_data = NULL;
547: struct read_element_status_header *st_hdr;
548: struct read_element_status_page_header *pg_hdr;
549: struct read_element_status_descriptor *desc;
550: caddr_t data = NULL;
551: size_t size, desclen, udsize;
552: int chet = cesr->cesr_type;
553: int avail, i, error = 0;
554: int want_voltags = (cesr->cesr_flags & CESR_VOLTAGS) ? 1 : 0;
555:
556: /*
557: * If there are no elements of the requested type in the changer,
558: * the request is invalid.
559: */
560: if (sc->sc_counts[chet] == 0)
561: return (EINVAL);
562:
563: /*
564: * Request one descriptor for the given element type. This
565: * is used to determine the size of the descriptor so that
566: * we can allocate enough storage for all of them. We assume
567: * that the first one can fit into 1k.
568: */
569: data = (caddr_t)malloc(1024, M_DEVBUF, M_WAITOK);
570: error = ch_getelemstatus(sc, sc->sc_firsts[chet], 1, data, 1024,
571: want_voltags);
572: if (error)
573: goto done;
574:
575: st_hdr = (struct read_element_status_header *)data;
576: pg_hdr = (struct read_element_status_page_header *)((u_long)st_hdr +
577: sizeof(struct read_element_status_header));
578: desclen = _2btol(pg_hdr->edl);
579:
580: size = sizeof(struct read_element_status_header) +
581: sizeof(struct read_element_status_page_header) +
582: (desclen * sc->sc_counts[chet]);
583:
584: /*
585: * Reallocate storage for descriptors and get them from the
586: * device.
587: */
588: free(data, M_DEVBUF);
589: data = (caddr_t)malloc(size, M_DEVBUF, M_WAITOK);
590: error = ch_getelemstatus(sc, sc->sc_firsts[chet],
591: sc->sc_counts[chet], data, size, want_voltags);
592: if (error)
593: goto done;
594:
595: /*
596: * Fill in the user status array.
597: */
598: st_hdr = (struct read_element_status_header *)data;
599: pg_hdr = (struct read_element_status_page_header *)((u_long)data +
600: sizeof(struct read_element_status_header));
601:
602: avail = _2btol(st_hdr->count);
603: if (avail != sc->sc_counts[chet]) {
604: error = EINVAL;
605: goto done;
606: }
607: udsize = avail * sizeof(struct changer_element_status);
608:
609: user_data = malloc(udsize, M_DEVBUF, M_WAITOK);
610: bzero(user_data, udsize);
611:
612: desc = (struct read_element_status_descriptor *)((u_long)data +
613: sizeof(struct read_element_status_header) +
614: sizeof(struct read_element_status_page_header));
615: for (i = 0; i < avail; ++i) {
616: struct changer_element_status *ces = &(user_data[i]);
617: copy_element_status(pg_hdr->flags, desc, ces);
618: (u_long)desc += desclen;
619: }
620:
621: /* Copy array out to userspace. */
622: error = copyout(user_data, cesr->cesr_data, udsize);
623:
624: done:
625: if (data != NULL)
626: free(data, M_DEVBUF);
627: if (user_data != NULL)
628: free(user_data, M_DEVBUF);
629: return (error);
630: }
631:
632: int
633: ch_getelemstatus(sc, first, count, data, datalen, voltag)
634: struct ch_softc *sc;
635: int first;
636: int count;
637: caddr_t data;
638: size_t datalen;
639: int voltag;
640: {
641: struct scsi_read_element_status cmd;
642:
643: /*
644: * Build SCSI command.
645: */
646: bzero(&cmd, sizeof(cmd));
647: cmd.opcode = READ_ELEMENT_STATUS;
648: _lto2b(first, cmd.sea);
649: _lto2b(count, cmd.count);
650: _lto3b(datalen, cmd.len);
651: if (voltag)
652: cmd.byte2 |= READ_ELEMENT_STATUS_VOLTAG;
653:
654: /*
655: * Send command to changer.
656: */
657: return (scsi_scsi_cmd(sc->sc_link, (struct scsi_generic *)&cmd,
658: sizeof(cmd), (u_char *)data, datalen, CHRETRIES, 100000, NULL, SCSI_DATA_IN));
659: }
660:
661:
662: /*
663: * Ask the device about itself and fill in the parameters in our
664: * softc.
665: */
666: int
667: ch_get_params(sc, flags)
668: struct ch_softc *sc;
669: int flags;
670: {
671: union scsi_mode_sense_buf *data;
672: struct page_element_address_assignment *ea;
673: struct page_device_capabilities *cap;
674: int error, from;
675: u_int8_t *moves, *exchanges;
676:
677: data = malloc(sizeof(*data), M_TEMP, M_NOWAIT);
678: if (data == NULL)
679: return (ENOMEM);
680:
681: /*
682: * Grab info from the element address assignment page (0x1d).
683: */
684: error = scsi_do_mode_sense(sc->sc_link, 0x1d, data,
685: (void **)&ea, NULL, NULL, NULL, sizeof(*ea), flags, NULL);
686: if (error == 0 && ea == NULL)
687: error = EIO;
688: if (error != 0) {
689: #ifdef CHANGER_DEBUG
690: printf("%s: could not sense element address page\n",
691: sc->sc_dev.dv_xname);
692: #endif
693: free(data, M_TEMP);
694: return (error);
695: }
696:
697: sc->sc_firsts[CHET_MT] = _2btol(ea->mtea);
698: sc->sc_counts[CHET_MT] = _2btol(ea->nmte);
699: sc->sc_firsts[CHET_ST] = _2btol(ea->fsea);
700: sc->sc_counts[CHET_ST] = _2btol(ea->nse);
701: sc->sc_firsts[CHET_IE] = _2btol(ea->fieea);
702: sc->sc_counts[CHET_IE] = _2btol(ea->niee);
703: sc->sc_firsts[CHET_DT] = _2btol(ea->fdtea);
704: sc->sc_counts[CHET_DT] = _2btol(ea->ndte);
705:
706: /* XXX Ask for transport geometry page. */
707:
708: /*
709: * Grab info from the capabilities page (0x1f).
710: */
711: error = scsi_do_mode_sense(sc->sc_link, 0x1f, data,
712: (void **)&cap, NULL, NULL, NULL, sizeof(*cap), flags, NULL);
713: if (cap == NULL)
714: error = EIO;
715: if (error != 0) {
716: #ifdef CHANGER_DEBUG
717: printf("%s: could not sense capabilities page\n",
718: sc->sc_dev.dv_xname);
719: #endif
720: free(data, M_TEMP);
721: return (error);
722: }
723:
724: bzero(sc->sc_movemask, sizeof(sc->sc_movemask));
725: bzero(sc->sc_exchangemask, sizeof(sc->sc_exchangemask));
726: moves = &cap->move_from_mt;
727: exchanges = &cap->exchange_with_mt;
728: for (from = CHET_MT; from <= CHET_DT; ++from) {
729: sc->sc_movemask[from] = moves[from];
730: sc->sc_exchangemask[from] = exchanges[from];
731: }
732:
733: sc->sc_link->flags |= SDEV_MEDIA_LOADED;
734: free(data, M_TEMP);
735: return (0);
736: }
737:
738: void
739: ch_get_quirks(sc, inqbuf)
740: struct ch_softc *sc;
741: struct scsi_inquiry_data *inqbuf;
742: {
743: const struct chquirk *match;
744: int priority;
745:
746: sc->sc_settledelay = 0;
747:
748: match = (const struct chquirk *)scsi_inqmatch(inqbuf,
749: (caddr_t)chquirks,
750: sizeof(chquirks) / sizeof(chquirks[0]),
751: sizeof(chquirks[0]), &priority);
752: if (priority != 0) {
753: sc->sc_settledelay = match->cq_settledelay;
754: }
755: }
756:
757: /*
758: * Look at the returned sense and act on the error and detirmine
759: * The unix error number to pass back... (0 = report no error)
760: * (-1 = continue processing)
761: */
762: int
763: ch_interpret_sense(xs)
764: struct scsi_xfer *xs;
765: {
766: struct scsi_sense_data *sense = &xs->sense;
767: struct scsi_link *sc_link = xs->sc_link;
768: u_int8_t serr = sense->error_code & SSD_ERRCODE;
769: u_int8_t skey = sense->flags & SSD_KEY;
770:
771: if (((sc_link->flags & SDEV_OPEN) == 0) ||
772: (serr != SSD_ERRCODE_CURRENT && serr != SSD_ERRCODE_DEFERRED))
773: return (EJUSTRETURN); /* let the generic code handle it */
774:
775: switch (skey) {
776:
777: /*
778: * We do custom processing in ch for the unit becoming ready case.
779: * in this case we do not allow xs->retries to be decremented
780: * only on the "Unit Becoming Ready" case. This is because tape
781: * changers report "Unit Becoming Ready" when they rescan their
782: * state (i.e. when the door got opened) and can take a long time
783: * for large units. Rather than having a massive timeout for
784: * all operations (which would cause other problems) we allow
785: * changers to wait (but be interruptable with Ctrl-C) forever
786: * as long as they are reporting that they are becoming ready.
787: * all other cases are handled as per the default.
788: */
789: case SKEY_NOT_READY:
790: if ((xs->flags & SCSI_IGNORE_NOT_READY) != 0)
791: return (0);
792: switch (ASC_ASCQ(sense)) {
793: case SENSE_NOT_READY_BECOMING_READY:
794: SC_DEBUG(sc_link, SDEV_DB1, ("not ready: busy (%#x)\n",
795: sense->add_sense_code_qual));
796: /* don't count this as a retry */
797: xs->retries++;
798: return (scsi_delay(xs, 1));
799: default:
800: return (EJUSTRETURN);
801: }
802: default:
803: return (EJUSTRETURN);
804: }
805: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ch.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / scsi