Annotation of sys/scsi/scsi_base.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: scsi_base.c,v 1.122 2007/06/23 19:19:49 krw Exp $ */
! 2: /* $NetBSD: scsi_base.c,v 1.43 1997/04/02 02:29:36 mycroft Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1994, 1995, 1997 Charles M. 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 M. 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@dialix.oz.au)
! 35: * Detailed SCSI error printing Copyright 1997 by Matthew Jacob.
! 36: */
! 37:
! 38: #include <sys/types.h>
! 39: #include <sys/param.h>
! 40: #include <sys/systm.h>
! 41: #include <sys/kernel.h>
! 42: #include <sys/buf.h>
! 43: #include <sys/uio.h>
! 44: #include <sys/malloc.h>
! 45: #include <sys/errno.h>
! 46: #include <sys/device.h>
! 47: #include <sys/proc.h>
! 48: #include <sys/pool.h>
! 49:
! 50: #include <scsi/scsi_all.h>
! 51: #include <scsi/scsi_disk.h>
! 52: #include <scsi/scsiconf.h>
! 53:
! 54: static __inline struct scsi_xfer *scsi_make_xs(struct scsi_link *,
! 55: struct scsi_generic *, int cmdlen, u_char *data_addr,
! 56: int datalen, int retries, int timeout, struct buf *, int flags);
! 57: static __inline void asc2ascii(u_int8_t, u_int8_t ascq, char *result,
! 58: size_t len);
! 59: int sc_err1(struct scsi_xfer *);
! 60: int scsi_interpret_sense(struct scsi_xfer *);
! 61: char *scsi_decode_sense(struct scsi_sense_data *, int);
! 62:
! 63: /* Values for flag parameter to scsi_decode_sense. */
! 64: #define DECODE_SENSE_KEY 1
! 65: #define DECODE_ASC_ASCQ 2
! 66: #define DECODE_SKSV 3
! 67:
! 68: int scsi_running = 0;
! 69: struct pool scsi_xfer_pool;
! 70:
! 71: /*
! 72: * Called when a scsibus is attached to initialize global data.
! 73: */
! 74: void
! 75: scsi_init()
! 76: {
! 77: if (scsi_running++)
! 78: return;
! 79:
! 80: #if defined(SCSI_DELAY) && SCSI_DELAY > 0
! 81: /* Historical. Older buses may need a moment to stabilize. */
! 82: delay(1000000 * SCSI_DELAY);
! 83: #endif
! 84:
! 85: /* Initialize the scsi_xfer pool. */
! 86: pool_init(&scsi_xfer_pool, sizeof(struct scsi_xfer), 0,
! 87: 0, 0, "scxspl", NULL);
! 88: }
! 89:
! 90: void
! 91: scsi_deinit()
! 92: {
! 93: if (--scsi_running)
! 94: return;
! 95: }
! 96:
! 97: /*
! 98: * Get a scsi transfer structure for the caller. Charge the structure
! 99: * to the device that is referenced by the sc_link structure. If the
! 100: * sc_link structure has no 'credits' then the device already has the
! 101: * maximum number or outstanding operations under way. In this stage,
! 102: * wait on the structure so that when one is freed, we are awoken again
! 103: * If the SCSI_NOSLEEP flag is set, then do not wait, but rather, return
! 104: * a NULL pointer, signifying that no slots were available
! 105: * Note in the link structure, that we are waiting on it.
! 106: */
! 107:
! 108: struct scsi_xfer *
! 109: scsi_get_xs(struct scsi_link *sc_link, int flags)
! 110: {
! 111: struct scsi_xfer *xs;
! 112: int s;
! 113:
! 114: SC_DEBUG(sc_link, SDEV_DB3, ("scsi_get_xs\n"));
! 115:
! 116: s = splbio();
! 117: while (sc_link->openings == 0) {
! 118: SC_DEBUG(sc_link, SDEV_DB3, ("sleeping\n"));
! 119: if ((flags & SCSI_NOSLEEP) != 0) {
! 120: splx(s);
! 121: return (NULL);
! 122: }
! 123: sc_link->flags |= SDEV_WAITING;
! 124: if (tsleep(sc_link, PRIBIO|PCATCH, "getxs", 0)) {
! 125: /* Bail out on getting a signal. */
! 126: sc_link->flags &= ~SDEV_WAITING;
! 127: splx(s);
! 128: return (NULL);
! 129: }
! 130: }
! 131: SC_DEBUG(sc_link, SDEV_DB3, ("calling pool_get\n"));
! 132: xs = pool_get(&scsi_xfer_pool,
! 133: ((flags & SCSI_NOSLEEP) != 0 ? PR_NOWAIT : PR_WAITOK));
! 134: if (xs != NULL) {
! 135: bzero(xs, sizeof(*xs));
! 136: sc_link->openings--;
! 137: xs->flags = flags;
! 138: } else {
! 139: sc_print_addr(sc_link);
! 140: printf("cannot allocate scsi xs\n");
! 141: }
! 142: splx(s);
! 143:
! 144: SC_DEBUG(sc_link, SDEV_DB3, ("returning\n"));
! 145:
! 146: return (xs);
! 147: }
! 148:
! 149: /*
! 150: * Given a scsi_xfer struct, and a device (referenced through sc_link)
! 151: * return the struct to the free pool and credit the device with it
! 152: * If another process is waiting for an xs, do a wakeup, let it proceed
! 153: */
! 154: void
! 155: scsi_free_xs(struct scsi_xfer *xs, int start)
! 156: {
! 157: struct scsi_link *sc_link = xs->sc_link;
! 158:
! 159: splassert(IPL_BIO);
! 160:
! 161: SC_DEBUG(sc_link, SDEV_DB3, ("scsi_free_xs\n"));
! 162:
! 163: pool_put(&scsi_xfer_pool, xs);
! 164: sc_link->openings++;
! 165:
! 166: /* If someone is waiting for scsi_xfer, wake them up. */
! 167: if ((sc_link->flags & SDEV_WAITING) != 0) {
! 168: sc_link->flags &= ~SDEV_WAITING;
! 169: wakeup(sc_link);
! 170: } else if (start && sc_link->device->start) {
! 171: SC_DEBUG(sc_link, SDEV_DB2,
! 172: ("calling private start()\n"));
! 173: (*(sc_link->device->start)) (sc_link->device_softc);
! 174: }
! 175: }
! 176:
! 177: /*
! 178: * Make a scsi_xfer, and return a pointer to it.
! 179: */
! 180: static __inline struct scsi_xfer *
! 181: scsi_make_xs(struct scsi_link *sc_link, struct scsi_generic *scsi_cmd,
! 182: int cmdlen, u_char *data_addr, int datalen, int retries, int timeout,
! 183: struct buf *bp, int flags)
! 184: {
! 185: struct scsi_xfer *xs;
! 186:
! 187: if ((xs = scsi_get_xs(sc_link, flags)) == NULL)
! 188: return (NULL);
! 189:
! 190: /*
! 191: * Fill out the scsi_xfer structure. We don't know whose context
! 192: * the cmd is in, so copy it.
! 193: */
! 194: xs->sc_link = sc_link;
! 195: bcopy(scsi_cmd, &xs->cmdstore, cmdlen);
! 196: xs->cmd = &xs->cmdstore;
! 197: xs->cmdlen = cmdlen;
! 198: xs->data = data_addr;
! 199: xs->datalen = datalen;
! 200: xs->retries = retries;
! 201: xs->timeout = timeout;
! 202: xs->bp = bp;
! 203:
! 204: /*
! 205: * Set the LUN in the CDB if it fits in the three bits available. This
! 206: * may only be needed if we have an older device. However, we also set
! 207: * it for more modern SCSI devices "just in case". The old code
! 208: * assumed everything newer than SCSI-2 would not need it, but why risk
! 209: * it? This was the old conditional:
! 210: *
! 211: * if ((SCSISPC(sc_link->inqdata.version) <= 2))
! 212: */
! 213: xs->cmd->bytes[0] &= ~SCSI_CMD_LUN_MASK;
! 214: if (sc_link->lun < 8)
! 215: xs->cmd->bytes[0] |= ((sc_link->lun << SCSI_CMD_LUN_SHIFT) &
! 216: SCSI_CMD_LUN_MASK);
! 217:
! 218: return (xs);
! 219: }
! 220:
! 221: /*
! 222: * Find out from the device what its capacity is.
! 223: */
! 224: daddr64_t
! 225: scsi_size(struct scsi_link *sc_link, int flags, u_int32_t *blksize)
! 226: {
! 227: struct scsi_read_cap_data_16 rdcap16;
! 228: struct scsi_read_capacity_16 rc16;
! 229: struct scsi_read_cap_data rdcap;
! 230: struct scsi_read_capacity rc;
! 231: daddr64_t max_addr;
! 232: int error;
! 233:
! 234: if (blksize != NULL)
! 235: *blksize = 0;
! 236:
! 237: /*
! 238: * make up a scsi command and ask the scsi driver to do it for you.
! 239: */
! 240: bzero(&rc, sizeof(rc));
! 241: bzero(&rdcap, sizeof(rdcap));
! 242: rc.opcode = READ_CAPACITY;
! 243:
! 244: /*
! 245: * If the command works, interpret the result as a 4 byte
! 246: * number of blocks
! 247: */
! 248: error = scsi_scsi_cmd(sc_link, (struct scsi_generic *)&rc, sizeof(rc),
! 249: (u_char *)&rdcap, sizeof(rdcap), 2, 20000, NULL,
! 250: flags | SCSI_DATA_IN);
! 251: if (error) {
! 252: SC_DEBUG(sc_link, SDEV_DB1, ("READ CAPACITY error (%#x)\n",
! 253: error));
! 254: return (0);
! 255: }
! 256:
! 257: max_addr = _4btol(rdcap.addr);
! 258: if (blksize != NULL)
! 259: *blksize = _4btol(rdcap.length);
! 260:
! 261: if (max_addr != 0xffffffff)
! 262: return (max_addr + 1);
! 263:
! 264: /*
! 265: * The device has more than 2^32-1 sectors. Use 16-byte READ CAPACITY.
! 266: */
! 267: bzero(&rc16, sizeof(rc16));
! 268: bzero(&rdcap16, sizeof(rdcap16));
! 269: rc16.opcode = READ_CAPACITY_16;
! 270: rc16.byte2 = SRC16_SERVICE_ACTION;
! 271: _lto4b(sizeof(rdcap16), rc16.length);
! 272:
! 273: error = scsi_scsi_cmd(sc_link, (struct scsi_generic *)&rc16,
! 274: sizeof(rc16), (u_char *)&rdcap16, sizeof(rdcap16), 2, 20000, NULL,
! 275: flags | SCSI_DATA_IN);
! 276: if (error) {
! 277: SC_DEBUG(sc_link, SDEV_DB1, ("READ CAPACITY 16 error (%#x)\n",
! 278: error));
! 279: return (0);
! 280: }
! 281:
! 282: max_addr = _8btol(rdcap16.addr);
! 283: if (blksize != NULL)
! 284: *blksize = _4btol(rdcap16.length);
! 285:
! 286: return (max_addr + 1);
! 287: }
! 288:
! 289: /*
! 290: * Get scsi driver to send a "are you ready?" command
! 291: */
! 292: int
! 293: scsi_test_unit_ready(struct scsi_link *sc_link, int retries, int flags)
! 294: {
! 295: struct scsi_test_unit_ready scsi_cmd;
! 296:
! 297: if (sc_link->quirks & ADEV_NOTUR)
! 298: return (0);
! 299:
! 300: bzero(&scsi_cmd, sizeof(scsi_cmd));
! 301: scsi_cmd.opcode = TEST_UNIT_READY;
! 302:
! 303: return (scsi_scsi_cmd(sc_link, (struct scsi_generic *) &scsi_cmd,
! 304: sizeof(scsi_cmd), 0, 0, retries, 10000, NULL, flags));
! 305: }
! 306:
! 307: /*
! 308: * Do a scsi operation asking a device what it is.
! 309: * Use the scsi_cmd routine in the switch table.
! 310: */
! 311: int
! 312: scsi_inquire(struct scsi_link *sc_link, struct scsi_inquiry_data *inqbuf,
! 313: int flags)
! 314: {
! 315: struct scsi_inquiry scsi_cmd;
! 316: int length;
! 317: int error;
! 318:
! 319: bzero(&scsi_cmd, sizeof(scsi_cmd));
! 320: scsi_cmd.opcode = INQUIRY;
! 321:
! 322: bzero(inqbuf, sizeof(*inqbuf));
! 323:
! 324: memset(&inqbuf->vendor, ' ', sizeof inqbuf->vendor);
! 325: memset(&inqbuf->product, ' ', sizeof inqbuf->product);
! 326: memset(&inqbuf->revision, ' ', sizeof inqbuf->revision);
! 327: memset(&inqbuf->extra, ' ', sizeof inqbuf->extra);
! 328:
! 329: /*
! 330: * Ask for only the basic 36 bytes of SCSI2 inquiry information. This
! 331: * avoids problems with devices that choke trying to supply more.
! 332: */
! 333: length = SID_INQUIRY_HDR + SID_SCSI2_ALEN;
! 334: _lto2b(length, scsi_cmd.length);
! 335: error = scsi_scsi_cmd(sc_link, (struct scsi_generic *)&scsi_cmd,
! 336: sizeof(scsi_cmd), (u_char *)inqbuf, length, 2, 10000, NULL,
! 337: SCSI_DATA_IN | flags);
! 338:
! 339: return (error);
! 340: }
! 341:
! 342: /*
! 343: * Query a VPD inquiry page
! 344: */
! 345: int
! 346: scsi_inquire_vpd(struct scsi_link *sc_link, void *buf, u_int buflen,
! 347: u_int8_t page, int flags)
! 348: {
! 349: struct scsi_inquiry scsi_cmd;
! 350: int error;
! 351:
! 352: bzero(&scsi_cmd, sizeof(scsi_cmd));
! 353: scsi_cmd.opcode = INQUIRY;
! 354: scsi_cmd.flags = SI_EVPD;
! 355: scsi_cmd.pagecode = page;
! 356: _lto2b(buflen, scsi_cmd.length);
! 357:
! 358: bzero(buf, buflen);
! 359:
! 360: error = scsi_scsi_cmd(sc_link, (struct scsi_generic *)&scsi_cmd,
! 361: sizeof(scsi_cmd), buf, buflen, 2, 10000, NULL,
! 362: SCSI_DATA_IN | flags);
! 363:
! 364: return (error);
! 365: }
! 366:
! 367: /*
! 368: * Prevent or allow the user to remove the media
! 369: */
! 370: int
! 371: scsi_prevent(struct scsi_link *sc_link, int type, int flags)
! 372: {
! 373: struct scsi_prevent scsi_cmd;
! 374:
! 375: if (sc_link->quirks & ADEV_NODOORLOCK)
! 376: return (0);
! 377:
! 378: bzero(&scsi_cmd, sizeof(scsi_cmd));
! 379: scsi_cmd.opcode = PREVENT_ALLOW;
! 380: scsi_cmd.how = type;
! 381:
! 382: return (scsi_scsi_cmd(sc_link, (struct scsi_generic *)&scsi_cmd,
! 383: sizeof(scsi_cmd), 0, 0, 2, 5000, NULL, flags));
! 384: }
! 385:
! 386: /*
! 387: * Get scsi driver to send a "start up" command
! 388: */
! 389: int
! 390: scsi_start(struct scsi_link *sc_link, int type, int flags)
! 391: {
! 392: struct scsi_start_stop scsi_cmd;
! 393:
! 394: bzero(&scsi_cmd, sizeof(scsi_cmd));
! 395: scsi_cmd.opcode = START_STOP;
! 396: scsi_cmd.byte2 = 0x00;
! 397: scsi_cmd.how = type;
! 398:
! 399: return (scsi_scsi_cmd(sc_link, (struct scsi_generic *)&scsi_cmd,
! 400: sizeof(scsi_cmd), 0, 0, 2,
! 401: type == SSS_START ? 30000 : 10000, NULL, flags));
! 402: }
! 403:
! 404: int
! 405: scsi_mode_sense(struct scsi_link *sc_link, int byte2, int page,
! 406: struct scsi_mode_header *data, size_t len, int flags, int timeout)
! 407: {
! 408: struct scsi_mode_sense scsi_cmd;
! 409: int error;
! 410:
! 411: /*
! 412: * Make sure the sense buffer is clean before we do the mode sense, so
! 413: * that checks for bogus values of 0 will work in case the mode sense
! 414: * fails.
! 415: */
! 416: bzero(data, len);
! 417:
! 418: bzero(&scsi_cmd, sizeof(scsi_cmd));
! 419: scsi_cmd.opcode = MODE_SENSE;
! 420: scsi_cmd.byte2 = byte2;
! 421: scsi_cmd.page = page;
! 422:
! 423: if (len > 0xff)
! 424: len = 0xff;
! 425: scsi_cmd.length = len;
! 426:
! 427: error = scsi_scsi_cmd(sc_link, (struct scsi_generic *)&scsi_cmd,
! 428: sizeof(scsi_cmd), (u_char *)data, len, 4, timeout, NULL,
! 429: flags | SCSI_DATA_IN);
! 430:
! 431: SC_DEBUG(sc_link, SDEV_DB2, ("scsi_mode_sense: page %#x, error = %d\n",
! 432: page, error));
! 433:
! 434: return (error);
! 435: }
! 436:
! 437: int
! 438: scsi_mode_sense_big(struct scsi_link *sc_link, int byte2, int page,
! 439: struct scsi_mode_header_big *data, size_t len, int flags, int timeout)
! 440: {
! 441: struct scsi_mode_sense_big scsi_cmd;
! 442: int error;
! 443:
! 444: /*
! 445: * Make sure the sense buffer is clean before we do the mode sense, so
! 446: * that checks for bogus values of 0 will work in case the mode sense
! 447: * fails.
! 448: */
! 449: bzero(data, len);
! 450:
! 451: bzero(&scsi_cmd, sizeof(scsi_cmd));
! 452: scsi_cmd.opcode = MODE_SENSE_BIG;
! 453: scsi_cmd.byte2 = byte2;
! 454: scsi_cmd.page = page;
! 455:
! 456: if (len > 0xffff)
! 457: len = 0xffff;
! 458: _lto2b(len, scsi_cmd.length);
! 459:
! 460: error = scsi_scsi_cmd(sc_link, (struct scsi_generic *)&scsi_cmd,
! 461: sizeof(scsi_cmd), (u_char *)data, len, 4, timeout, NULL,
! 462: flags | SCSI_DATA_IN);
! 463:
! 464: SC_DEBUG(sc_link, SDEV_DB2,
! 465: ("scsi_mode_sense_big: page %#x, error = %d\n", page, error));
! 466:
! 467: return (error);
! 468: }
! 469:
! 470: void *
! 471: scsi_mode_sense_page(struct scsi_mode_header *hdr, const int page_len)
! 472: {
! 473: int total_length, header_length;
! 474:
! 475: total_length = hdr->data_length + sizeof(hdr->data_length);
! 476: header_length = sizeof(*hdr) + hdr->blk_desc_len;
! 477:
! 478: if ((total_length - header_length) < page_len)
! 479: return (NULL);
! 480:
! 481: return ((u_char *)hdr + header_length);
! 482: }
! 483:
! 484: void *
! 485: scsi_mode_sense_big_page(struct scsi_mode_header_big *hdr, const int page_len)
! 486: {
! 487: int total_length, header_length;
! 488:
! 489: total_length = _2btol(hdr->data_length) + sizeof(hdr->data_length);
! 490: header_length = sizeof(*hdr) + _2btol(hdr->blk_desc_len);
! 491:
! 492: if ((total_length - header_length) < page_len)
! 493: return (NULL);
! 494:
! 495: return ((u_char *)hdr + header_length);
! 496: }
! 497:
! 498: int
! 499: scsi_do_mode_sense(struct scsi_link *sc_link, int page,
! 500: union scsi_mode_sense_buf *buf, void **page_data, u_int32_t *density,
! 501: u_int64_t *block_count, u_int32_t *block_size, int page_len, int flags,
! 502: int *big)
! 503: {
! 504: struct scsi_direct_blk_desc *direct;
! 505: struct scsi_blk_desc *general;
! 506: int error, blk_desc_len, offset;
! 507:
! 508: *page_data = NULL;
! 509:
! 510: if (density != NULL)
! 511: *density = 0;
! 512: if (block_count != NULL)
! 513: *block_count = 0;
! 514: if (block_size != NULL)
! 515: *block_size = 0;
! 516: if (big != NULL)
! 517: *big = 0;
! 518:
! 519: if ((sc_link->flags & SDEV_ATAPI) == 0 ||
! 520: (sc_link->inqdata.device & SID_TYPE) == T_SEQUENTIAL) {
! 521: /*
! 522: * Try 6 byte mode sense request first. Some devices don't
! 523: * distinguish between 6 and 10 byte MODE SENSE commands,
! 524: * returning 6 byte data for 10 byte requests. ATAPI tape
! 525: * drives use MODE SENSE (6) even though ATAPI uses 10 byte
! 526: * everything else. Don't bother with SMS_DBD. Check returned
! 527: * data length to ensure that at least a header (3 additional
! 528: * bytes) is returned.
! 529: */
! 530: error = scsi_mode_sense(sc_link, 0, page, &buf->hdr,
! 531: sizeof(*buf), flags, 20000);
! 532: if (error == 0) {
! 533: *page_data = scsi_mode_sense_page(&buf->hdr, page_len);
! 534: if (*page_data == NULL) {
! 535: /*
! 536: * XXX
! 537: * Page data may be invalid (e.g. all zeros)
! 538: * but we accept the device's word that this is
! 539: * the best it can do. Some devices will freak
! 540: * out if their word is not accepted and
! 541: * MODE_SENSE_BIG is attempted.
! 542: */
! 543: return (0);
! 544: }
! 545: offset = sizeof(struct scsi_mode_header);
! 546: blk_desc_len = buf->hdr.blk_desc_len;
! 547: goto blk_desc;
! 548: }
! 549: }
! 550:
! 551: /*
! 552: * Try 10 byte mode sense request. Don't bother with SMS_DBD or
! 553: * SMS_LLBAA. Bail out if the returned information is less than
! 554: * a big header in size (6 additional bytes).
! 555: */
! 556: error = scsi_mode_sense_big(sc_link, 0, page, &buf->hdr_big,
! 557: sizeof(*buf), flags, 20000);
! 558: if (error != 0)
! 559: return (error);
! 560: if (_2btol(buf->hdr_big.data_length) < 6)
! 561: return (EIO);
! 562:
! 563: if (big != NULL)
! 564: *big = 1;
! 565: offset = sizeof(struct scsi_mode_header_big);
! 566: *page_data = scsi_mode_sense_big_page(&buf->hdr_big, page_len);
! 567: blk_desc_len = _2btol(buf->hdr_big.blk_desc_len);
! 568:
! 569: blk_desc:
! 570: /* Both scsi_blk_desc and scsi_direct_blk_desc are 8 bytes. */
! 571: if (blk_desc_len == 0 || (blk_desc_len % 8 != 0))
! 572: return (0);
! 573:
! 574: switch (sc_link->inqdata.device & SID_TYPE) {
! 575: case T_SEQUENTIAL:
! 576: /*
! 577: * XXX What other device types return general block descriptors?
! 578: */
! 579: general = (struct scsi_blk_desc *)&buf->buf[offset];
! 580: if (density != NULL)
! 581: *density = general->density;
! 582: if (block_size != NULL)
! 583: *block_size = _3btol(general->blklen);
! 584: if (block_count != NULL)
! 585: *block_count = (u_int64_t)_3btol(general->nblocks);
! 586: break;
! 587:
! 588: default:
! 589: direct = (struct scsi_direct_blk_desc *)&buf->buf[offset];
! 590: if (density != NULL)
! 591: *density = direct->density;
! 592: if (block_size != NULL)
! 593: *block_size = _3btol(direct->blklen);
! 594: if (block_count != NULL)
! 595: *block_count = (u_int64_t)_4btol(direct->nblocks);
! 596: break;
! 597: }
! 598:
! 599: return (0);
! 600: }
! 601:
! 602: int
! 603: scsi_mode_select(struct scsi_link *sc_link, int byte2,
! 604: struct scsi_mode_header *data, int flags, int timeout)
! 605: {
! 606: struct scsi_mode_select scsi_cmd;
! 607: int error;
! 608:
! 609: bzero(&scsi_cmd, sizeof(scsi_cmd));
! 610: scsi_cmd.opcode = MODE_SELECT;
! 611: scsi_cmd.byte2 = byte2;
! 612: scsi_cmd.length = data->data_length + 1; /* 1 == sizeof(data_length) */
! 613:
! 614: /* Length is reserved when doing mode select so zero it. */
! 615: data->data_length = 0;
! 616:
! 617: error = scsi_scsi_cmd(sc_link, (struct scsi_generic *)&scsi_cmd,
! 618: sizeof(scsi_cmd), (u_char *)data, scsi_cmd.length, 4, timeout, NULL,
! 619: flags | SCSI_DATA_OUT);
! 620:
! 621: SC_DEBUG(sc_link, SDEV_DB2, ("scsi_mode_select: error = %d\n", error));
! 622:
! 623: return (error);
! 624: }
! 625:
! 626: int
! 627: scsi_mode_select_big(struct scsi_link *sc_link, int byte2,
! 628: struct scsi_mode_header_big *data, int flags, int timeout)
! 629: {
! 630: struct scsi_mode_select_big scsi_cmd;
! 631: u_int32_t len;
! 632: int error;
! 633:
! 634: len = _2btol(data->data_length) + 2; /* 2 == sizeof data->data_length */
! 635:
! 636: bzero(&scsi_cmd, sizeof(scsi_cmd));
! 637: scsi_cmd.opcode = MODE_SELECT_BIG;
! 638: scsi_cmd.byte2 = byte2;
! 639: _lto2b(len, scsi_cmd.length);
! 640:
! 641: /* Length is reserved when doing mode select so zero it. */
! 642: _lto2b(0, data->data_length);
! 643:
! 644: error = scsi_scsi_cmd(sc_link, (struct scsi_generic *)&scsi_cmd,
! 645: sizeof(scsi_cmd), (u_char *)data, len, 4, timeout, NULL,
! 646: flags | SCSI_DATA_OUT);
! 647:
! 648: SC_DEBUG(sc_link, SDEV_DB2, ("scsi_mode_select_big: error = %d\n",
! 649: error));
! 650:
! 651: return (error);
! 652: }
! 653:
! 654: int
! 655: scsi_report_luns(struct scsi_link *sc_link, int selectreport,
! 656: struct scsi_report_luns_data *data, u_int32_t datalen, int flags,
! 657: int timeout)
! 658: {
! 659: struct scsi_report_luns scsi_cmd;
! 660: int error;
! 661:
! 662: bzero(&scsi_cmd, sizeof(scsi_cmd));
! 663: bzero(data, datalen);
! 664:
! 665: scsi_cmd.opcode = REPORT_LUNS;
! 666: scsi_cmd.selectreport = selectreport;
! 667: _lto4b(datalen, scsi_cmd.length);
! 668:
! 669: error = scsi_scsi_cmd(sc_link, (struct scsi_generic *)&scsi_cmd,
! 670: sizeof(scsi_cmd), (u_char *)data, datalen, 4, timeout, NULL,
! 671: flags | SCSI_DATA_IN);
! 672:
! 673: SC_DEBUG(sc_link, SDEV_DB2, ("scsi_report_luns: error = %d\n", error));
! 674:
! 675: return (error);
! 676: }
! 677:
! 678: /*
! 679: * This routine is called by the scsi interrupt when the transfer is complete.
! 680: */
! 681: void
! 682: scsi_done(struct scsi_xfer *xs)
! 683: {
! 684: struct scsi_link *sc_link = xs->sc_link;
! 685: struct buf *bp;
! 686: int error;
! 687:
! 688: splassert(IPL_BIO);
! 689:
! 690: SC_DEBUG(sc_link, SDEV_DB2, ("scsi_done\n"));
! 691: #ifdef SCSIDEBUG
! 692: if ((sc_link->flags & SDEV_DB1) != 0)
! 693: show_scsi_cmd(xs);
! 694: #endif /* SCSIDEBUG */
! 695:
! 696: /*
! 697: * If it's a user level request, bypass all usual completion processing,
! 698: * let the user work it out.. We take reponsibility for freeing the
! 699: * xs when the user returns (and restarting the device's queue).
! 700: */
! 701: if ((xs->flags & SCSI_USER) != 0) {
! 702: SC_DEBUG(sc_link, SDEV_DB3, ("calling user done()\n"));
! 703: scsi_user_done(xs); /* to take a copy of the sense etc. */
! 704: SC_DEBUG(sc_link, SDEV_DB3, ("returned from user done()\n"));
! 705:
! 706: scsi_free_xs(xs, 1); /* restarts queue too */
! 707: SC_DEBUG(sc_link, SDEV_DB3, ("returning to adapter\n"));
! 708: return;
! 709: }
! 710:
! 711: if (!((xs->flags & (SCSI_NOSLEEP | SCSI_POLL)) == SCSI_NOSLEEP)) {
! 712: /*
! 713: * if it's a normal upper level request, then ask
! 714: * the upper level code to handle error checking
! 715: * rather than doing it here at interrupt time
! 716: */
! 717: wakeup(xs);
! 718: return;
! 719: }
! 720:
! 721: /*
! 722: * Go and handle errors now.
! 723: * If it returns ERESTART then we should RETRY
! 724: */
! 725: retry:
! 726: error = sc_err1(xs);
! 727: if (error == ERESTART) {
! 728: switch ((*(sc_link->adapter->scsi_cmd)) (xs)) {
! 729: case SUCCESSFULLY_QUEUED:
! 730: return;
! 731:
! 732: case TRY_AGAIN_LATER:
! 733: xs->error = XS_BUSY;
! 734: /* FALLTHROUGH */
! 735: case COMPLETE:
! 736: goto retry;
! 737: }
! 738: }
! 739:
! 740: bp = xs->bp;
! 741: if (bp != NULL) {
! 742: if (error) {
! 743: bp->b_error = error;
! 744: bp->b_flags |= B_ERROR;
! 745: bp->b_resid = bp->b_bcount;
! 746: } else {
! 747: bp->b_error = 0;
! 748: bp->b_resid = xs->resid;
! 749: }
! 750: }
! 751:
! 752: if (sc_link->device->done) {
! 753: /*
! 754: * Tell the device the operation is actually complete.
! 755: * No more will happen with this xfer. This for
! 756: * notification of the upper-level driver only; they
! 757: * won't be returning any meaningful information to us.
! 758: */
! 759: (*sc_link->device->done)(xs);
! 760: }
! 761: scsi_free_xs(xs, 1);
! 762: if (bp != NULL)
! 763: biodone(bp);
! 764: }
! 765:
! 766: int
! 767: scsi_execute_xs(struct scsi_xfer *xs)
! 768: {
! 769: int error, flags, rslt, s;
! 770:
! 771: xs->flags &= ~ITSDONE;
! 772: xs->error = XS_NOERROR;
! 773: xs->resid = xs->datalen;
! 774: xs->status = 0;
! 775:
! 776: /*
! 777: * Do the transfer. If we are polling we will return:
! 778: * COMPLETE, Was poll, and scsi_done has been called
! 779: * TRY_AGAIN_LATER, Adapter short resources, try again
! 780: *
! 781: * if under full steam (interrupts) it will return:
! 782: * SUCCESSFULLY_QUEUED, will do a wakeup when complete
! 783: * TRY_AGAIN_LATER, (as for polling)
! 784: * After the wakeup, we must still check if it succeeded
! 785: *
! 786: * If we have a SCSI_NOSLEEP (typically because we have a buf)
! 787: * we just return. All the error processing and the buffer
! 788: * code both expect us to return straight to them, so as soon
! 789: * as the command is queued, return.
! 790: */
! 791:
! 792: /*
! 793: * We save the flags here because the xs structure may already
! 794: * be freed by scsi_done by the time adapter->scsi_cmd returns.
! 795: *
! 796: * scsi_done is responsible for freeing the xs if either
! 797: * (flags & (SCSI_NOSLEEP | SCSI_POLL)) == SCSI_NOSLEEP
! 798: * -or-
! 799: * (flags & SCSI_USER) != 0
! 800: *
! 801: * Note: SCSI_USER must always be called with SCSI_NOSLEEP
! 802: * and never with SCSI_POLL, so the second expression should be
! 803: * is equivalent to the first.
! 804: */
! 805:
! 806: flags = xs->flags;
! 807: #ifdef DIAGNOSTIC
! 808: if ((flags & (SCSI_USER | SCSI_NOSLEEP)) == SCSI_USER)
! 809: panic("scsi_execute_xs: USER without NOSLEEP");
! 810: if ((flags & (SCSI_USER | SCSI_POLL)) == (SCSI_USER | SCSI_POLL))
! 811: panic("scsi_execute_xs: USER with POLL");
! 812: #endif
! 813: retry:
! 814: rslt = (*(xs->sc_link->adapter->scsi_cmd))(xs);
! 815: switch (rslt) {
! 816: case SUCCESSFULLY_QUEUED:
! 817: if ((flags & (SCSI_NOSLEEP | SCSI_POLL)) == SCSI_NOSLEEP)
! 818: return (EJUSTRETURN);
! 819: #ifdef DIAGNOSTIC
! 820: if (flags & SCSI_NOSLEEP)
! 821: panic("scsi_execute_xs: NOSLEEP and POLL");
! 822: #endif
! 823: s = splbio();
! 824: /* Since the xs is active we can't bail out on a signal. */
! 825: while ((xs->flags & ITSDONE) == 0)
! 826: tsleep(xs, PRIBIO + 1, "scsicmd", 0);
! 827: splx(s);
! 828: /* FALLTHROUGH */
! 829: case COMPLETE: /* Polling command completed ok */
! 830: if ((flags & (SCSI_NOSLEEP | SCSI_POLL)) == SCSI_NOSLEEP)
! 831: return (EJUSTRETURN);
! 832: if (xs->bp)
! 833: return (EJUSTRETURN);
! 834: doit:
! 835: SC_DEBUG(xs->sc_link, SDEV_DB3, ("back in cmd()\n"));
! 836: if ((error = sc_err1(xs)) != ERESTART)
! 837: return (error);
! 838: goto retry;
! 839:
! 840: case TRY_AGAIN_LATER: /* adapter resource shortage */
! 841: xs->error = XS_BUSY;
! 842: goto doit;
! 843:
! 844: case NO_CCB:
! 845: return (EAGAIN);
! 846:
! 847: default:
! 848: panic("scsi_execute_xs: invalid return code (%#x)", rslt);
! 849: }
! 850:
! 851: #ifdef DIAGNOSTIC
! 852: panic("scsi_execute_xs: impossible");
! 853: #endif
! 854: return (EINVAL);
! 855: }
! 856:
! 857: /*
! 858: * ask the scsi driver to perform a command for us.
! 859: * tell it where to read/write the data, and how
! 860: * long the data is supposed to be. If we have a buf
! 861: * to associate with the transfer, we need that too.
! 862: */
! 863: int
! 864: scsi_scsi_cmd(struct scsi_link *sc_link, struct scsi_generic *scsi_cmd,
! 865: int cmdlen, u_char *data_addr, int datalen, int retries, int timeout,
! 866: struct buf *bp, int flags)
! 867: {
! 868: struct scsi_xfer *xs;
! 869: int error;
! 870: int s;
! 871:
! 872: SC_DEBUG(sc_link, SDEV_DB2, ("scsi_cmd\n"));
! 873:
! 874: #ifdef DIAGNOSTIC
! 875: if (bp != NULL && (flags & SCSI_NOSLEEP) == 0)
! 876: panic("scsi_scsi_cmd: buffer without nosleep");
! 877: #endif
! 878:
! 879: if ((xs = scsi_make_xs(sc_link, scsi_cmd, cmdlen, data_addr, datalen,
! 880: retries, timeout, bp, flags)) == NULL)
! 881: return (ENOMEM);
! 882:
! 883: if ((error = scsi_execute_xs(xs)) == EJUSTRETURN)
! 884: return (0);
! 885:
! 886: s = splbio();
! 887:
! 888: if (error == EAGAIN)
! 889: scsi_free_xs(xs, 0); /* Don't restart queue. */
! 890: else
! 891: scsi_free_xs(xs, 1);
! 892:
! 893: splx(s);
! 894:
! 895: return (error);
! 896: }
! 897:
! 898: int
! 899: sc_err1(struct scsi_xfer *xs)
! 900: {
! 901: int error;
! 902:
! 903: SC_DEBUG(xs->sc_link, SDEV_DB3, ("sc_err1,err = 0x%x\n", xs->error));
! 904:
! 905: /*
! 906: * If it has a buf, we might be working with
! 907: * a request from the buffer cache or some other
! 908: * piece of code that requires us to process
! 909: * errors at interrupt time. We have probably
! 910: * been called by scsi_done()
! 911: */
! 912: switch (xs->error) {
! 913: case XS_NOERROR: /* nearly always hit this one */
! 914: error = 0;
! 915: break;
! 916:
! 917: case XS_SENSE:
! 918: case XS_SHORTSENSE:
! 919: if ((error = scsi_interpret_sense(xs)) == ERESTART)
! 920: goto retry;
! 921: SC_DEBUG(xs->sc_link, SDEV_DB3,
! 922: ("scsi_interpret_sense returned %#x\n", error));
! 923: break;
! 924:
! 925: case XS_BUSY:
! 926: if (xs->retries) {
! 927: if ((error = scsi_delay(xs, 1)) == EIO)
! 928: goto lose;
! 929: }
! 930: /* FALLTHROUGH */
! 931: case XS_TIMEOUT:
! 932: retry:
! 933: if (xs->retries--) {
! 934: xs->error = XS_NOERROR;
! 935: xs->flags &= ~ITSDONE;
! 936: return ERESTART;
! 937: }
! 938: /* FALLTHROUGH */
! 939: case XS_DRIVER_STUFFUP:
! 940: lose:
! 941: error = EIO;
! 942: break;
! 943:
! 944: case XS_SELTIMEOUT:
! 945: /* XXX Disable device? */
! 946: error = EIO;
! 947: break;
! 948:
! 949: case XS_RESET:
! 950: if (xs->retries) {
! 951: SC_DEBUG(xs->sc_link, SDEV_DB3,
! 952: ("restarting command destroyed by reset\n"));
! 953: goto retry;
! 954: }
! 955: error = EIO;
! 956: break;
! 957:
! 958: default:
! 959: sc_print_addr(xs->sc_link);
! 960: printf("unknown error category (0x%x) from scsi driver\n",
! 961: xs->error);
! 962: error = EIO;
! 963: break;
! 964: }
! 965:
! 966: return (error);
! 967: }
! 968:
! 969: int
! 970: scsi_delay(struct scsi_xfer *xs, int seconds)
! 971: {
! 972: switch (xs->flags & (SCSI_POLL | SCSI_NOSLEEP)) {
! 973: case SCSI_POLL:
! 974: delay(1000000 * seconds);
! 975: return (ERESTART);
! 976: case SCSI_NOSLEEP:
! 977: /* Retry the command immediately since we can't delay. */
! 978: return (ERESTART);
! 979: case (SCSI_POLL | SCSI_NOSLEEP):
! 980: /* Invalid combination! */
! 981: return (EIO);
! 982: }
! 983:
! 984: while (seconds-- > 0) {
! 985: if (tsleep(&lbolt, PRIBIO|PCATCH, "scbusy", 0)) {
! 986: /* Signal == abort xs. */
! 987: return (EIO);
! 988: }
! 989: }
! 990:
! 991: return (ERESTART);
! 992: }
! 993:
! 994: /*
! 995: * Look at the returned sense and act on the error, determining
! 996: * the unix error number to pass back. (0 = report no error)
! 997: *
! 998: * THIS IS THE DEFAULT ERROR HANDLER
! 999: */
! 1000: int
! 1001: scsi_interpret_sense(struct scsi_xfer *xs)
! 1002: {
! 1003: struct scsi_sense_data *sense = &xs->sense;
! 1004: struct scsi_link *sc_link = xs->sc_link;
! 1005: u_int8_t serr, skey;
! 1006: int error;
! 1007:
! 1008: SC_DEBUG(sc_link, SDEV_DB1,
! 1009: ("code:%#x valid:%d key:%#x ili:%d eom:%d fmark:%d extra:%d\n",
! 1010: sense->error_code & SSD_ERRCODE,
! 1011: sense->error_code & SSD_ERRCODE_VALID ? 1 : 0,
! 1012: sense->flags & SSD_KEY,
! 1013: sense->flags & SSD_ILI ? 1 : 0,
! 1014: sense->flags & SSD_EOM ? 1 : 0,
! 1015: sense->flags & SSD_FILEMARK ? 1 : 0,
! 1016: sense->extra_len));
! 1017: #ifdef SCSIDEBUG
! 1018: if ((sc_link->flags & SDEV_DB1) != 0)
! 1019: show_mem((u_char *)&xs->sense, sizeof xs->sense);
! 1020: #endif /* SCSIDEBUG */
! 1021:
! 1022: /*
! 1023: * If the device has its own error handler, call it first.
! 1024: * If it returns a legit error value, return that, otherwise
! 1025: * it wants us to continue with normal error processing.
! 1026: */
! 1027: if (sc_link->device->err_handler) {
! 1028: SC_DEBUG(sc_link, SDEV_DB2,
! 1029: ("calling private err_handler()\n"));
! 1030: error = (*sc_link->device->err_handler) (xs);
! 1031: if (error != EJUSTRETURN)
! 1032: return (error); /* error >= 0 better ? */
! 1033: }
! 1034:
! 1035: /* Default sense interpretation. */
! 1036: serr = sense->error_code & SSD_ERRCODE;
! 1037: if (serr != SSD_ERRCODE_CURRENT && serr != SSD_ERRCODE_DEFERRED)
! 1038: skey = 0xff; /* Invalid value, since key is 4 bit value. */
! 1039: else
! 1040: skey = sense->flags & SSD_KEY;
! 1041:
! 1042: /*
! 1043: * Interpret the key/asc/ascq information where appropriate.
! 1044: */
! 1045: error = 0;
! 1046: switch (skey) {
! 1047: case SKEY_NO_SENSE:
! 1048: case SKEY_RECOVERED_ERROR:
! 1049: if (xs->resid == xs->datalen)
! 1050: xs->resid = 0; /* not short read */
! 1051: break;
! 1052: case SKEY_BLANK_CHECK:
! 1053: case SKEY_EQUAL:
! 1054: break;
! 1055: case SKEY_NOT_READY:
! 1056: if ((xs->flags & SCSI_IGNORE_NOT_READY) != 0)
! 1057: return (0);
! 1058: error = EIO;
! 1059: if (xs->retries) {
! 1060: switch (ASC_ASCQ(sense)) {
! 1061: case SENSE_NOT_READY_BECOMING_READY:
! 1062: case SENSE_NOT_READY_FORMAT:
! 1063: case SENSE_NOT_READY_REBUILD:
! 1064: case SENSE_NOT_READY_RECALC:
! 1065: case SENSE_NOT_READY_INPROGRESS:
! 1066: case SENSE_NOT_READY_LONGWRITE:
! 1067: case SENSE_NOT_READY_SELFTEST:
! 1068: SC_DEBUG(sc_link, SDEV_DB1,
! 1069: ("not ready: busy (%#x)\n",
! 1070: sense->add_sense_code_qual));
! 1071: return (scsi_delay(xs, 1));
! 1072: case SENSE_NOMEDIUM:
! 1073: case SENSE_NOMEDIUM_TCLOSED:
! 1074: case SENSE_NOMEDIUM_TOPEN:
! 1075: case SENSE_NOMEDIUM_LOADABLE:
! 1076: case SENSE_NOMEDIUM_AUXMEM:
! 1077: sc_link->flags &= ~SDEV_MEDIA_LOADED;
! 1078: error = ENOMEDIUM;
! 1079: break;
! 1080: default:
! 1081: break;
! 1082: }
! 1083: }
! 1084: break;
! 1085: case SKEY_MEDIUM_ERROR:
! 1086: switch (ASC_ASCQ(sense)) {
! 1087: case SENSE_NOMEDIUM:
! 1088: case SENSE_NOMEDIUM_TCLOSED:
! 1089: case SENSE_NOMEDIUM_TOPEN:
! 1090: case SENSE_NOMEDIUM_LOADABLE:
! 1091: case SENSE_NOMEDIUM_AUXMEM:
! 1092: sc_link->flags &= ~SDEV_MEDIA_LOADED;
! 1093: error = ENOMEDIUM;
! 1094: break;
! 1095: case SENSE_BAD_MEDIUM:
! 1096: case SENSE_NR_MEDIUM_UNKNOWN_FORMAT:
! 1097: case SENSE_NR_MEDIUM_INCOMPATIBLE_FORMAT:
! 1098: case SENSE_NW_MEDIUM_UNKNOWN_FORMAT:
! 1099: case SENSE_NW_MEDIUM_INCOMPATIBLE_FORMAT:
! 1100: case SENSE_NF_MEDIUM_INCOMPATIBLE_FORMAT:
! 1101: case SENSE_NW_MEDIUM_AC_MISMATCH:
! 1102: error = EMEDIUMTYPE;
! 1103: break;
! 1104: default:
! 1105: error = EIO;
! 1106: break;
! 1107: }
! 1108: break;
! 1109: case SKEY_ILLEGAL_REQUEST:
! 1110: if ((xs->flags & SCSI_IGNORE_ILLEGAL_REQUEST) != 0)
! 1111: return (0);
! 1112: if (ASC_ASCQ(sense) == SENSE_MEDIUM_REMOVAL_PREVENTED)
! 1113: return(EBUSY);
! 1114: error = EINVAL;
! 1115: break;
! 1116: case SKEY_UNIT_ATTENTION:
! 1117: switch (ASC_ASCQ(sense)) {
! 1118: case SENSE_POWER_RESET_OR_BUS:
! 1119: case SENSE_POWER_ON:
! 1120: case SENSE_BUS_RESET:
! 1121: case SENSE_BUS_DEVICE_RESET:
! 1122: case SENSE_DEVICE_INTERNAL_RESET:
! 1123: case SENSE_TSC_CHANGE_SE:
! 1124: case SENSE_TSC_CHANGE_LVD:
! 1125: case SENSE_IT_NEXUS_LOSS:
! 1126: return (scsi_delay(xs, 1));
! 1127: default:
! 1128: break;
! 1129: }
! 1130: if ((sc_link->flags & SDEV_REMOVABLE) != 0)
! 1131: sc_link->flags &= ~SDEV_MEDIA_LOADED;
! 1132: if ((xs->flags & SCSI_IGNORE_MEDIA_CHANGE) != 0 ||
! 1133: /* XXX Should reupload any transient state. */
! 1134: (sc_link->flags & SDEV_REMOVABLE) == 0) {
! 1135: return (scsi_delay(xs, 1));
! 1136: }
! 1137: error = EIO;
! 1138: break;
! 1139: case SKEY_WRITE_PROTECT:
! 1140: error = EROFS;
! 1141: break;
! 1142: case SKEY_ABORTED_COMMAND:
! 1143: error = ERESTART;
! 1144: break;
! 1145: case SKEY_VOLUME_OVERFLOW:
! 1146: error = ENOSPC;
! 1147: break;
! 1148: case SKEY_HARDWARE_ERROR:
! 1149: if (ASC_ASCQ(sense) == SENSE_CARTRIDGE_FAULT)
! 1150: return(EMEDIUMTYPE);
! 1151: error = EIO;
! 1152: break;
! 1153: default:
! 1154: error = EIO;
! 1155: break;
! 1156: }
! 1157:
! 1158: if (skey && (xs->flags & SCSI_SILENT) == 0)
! 1159: scsi_print_sense(xs);
! 1160:
! 1161: return (error);
! 1162: }
! 1163:
! 1164: /*
! 1165: * Utility routines often used in SCSI stuff
! 1166: */
! 1167:
! 1168:
! 1169: /*
! 1170: * Print out the scsi_link structure's address info.
! 1171: */
! 1172: void
! 1173: sc_print_addr(struct scsi_link *sc_link)
! 1174: {
! 1175: printf("%s(%s:%d:%d): ",
! 1176: sc_link->device_softc ?
! 1177: ((struct device *)sc_link->device_softc)->dv_xname : "probe",
! 1178: ((struct device *)sc_link->adapter_softc)->dv_xname,
! 1179: sc_link->target, sc_link->lun);
! 1180: }
! 1181:
! 1182: static const char *sense_keys[16] = {
! 1183: "No Additional Sense",
! 1184: "Soft Error",
! 1185: "Not Ready",
! 1186: "Media Error",
! 1187: "Hardware Error",
! 1188: "Illegal Request",
! 1189: "Unit Attention",
! 1190: "Write Protected",
! 1191: "Blank Check",
! 1192: "Vendor Unique",
! 1193: "Copy Aborted",
! 1194: "Aborted Command",
! 1195: "Equal Error",
! 1196: "Volume Overflow",
! 1197: "Miscompare Error",
! 1198: "Reserved"
! 1199: };
! 1200:
! 1201: #ifdef SCSITERSE
! 1202: static __inline void
! 1203: asc2ascii(u_int8_t asc, u_int8_t ascq, char *result, size_t len)
! 1204: {
! 1205: snprintf(result, len, "ASC 0x%02x ASCQ 0x%02x", asc, ascq);
! 1206: }
! 1207: #else
! 1208: static const struct {
! 1209: u_int8_t asc, ascq;
! 1210: char *description;
! 1211: } adesc[] = {
! 1212: { 0x00, 0x00, "No Additional Sense Information" },
! 1213: { 0x00, 0x01, "Filemark Detected" },
! 1214: { 0x00, 0x02, "End-Of-Partition/Medium Detected" },
! 1215: { 0x00, 0x03, "Setmark Detected" },
! 1216: { 0x00, 0x04, "Beginning-Of-Partition/Medium Detected" },
! 1217: { 0x00, 0x05, "End-Of-Data Detected" },
! 1218: { 0x00, 0x06, "I/O Process Terminated" },
! 1219: { 0x00, 0x11, "Audio Play Operation In Progress" },
! 1220: { 0x00, 0x12, "Audio Play Operation Paused" },
! 1221: { 0x00, 0x13, "Audio Play Operation Successfully Completed" },
! 1222: { 0x00, 0x14, "Audio Play Operation Stopped Due to Error" },
! 1223: { 0x00, 0x15, "No Current Audio Status To Return" },
! 1224: { 0x00, 0x16, "Operation In Progress" },
! 1225: { 0x00, 0x17, "Cleaning Requested" },
! 1226: { 0x00, 0x18, "Erase Operation In Progress" },
! 1227: { 0x00, 0x19, "Locate Operation In Progress" },
! 1228: { 0x00, 0x1A, "Rewind Operation In Progress" },
! 1229: { 0x00, 0x1B, "Set Capacity Operation In Progress" },
! 1230: { 0x00, 0x1C, "Verify Operation In Progress" },
! 1231: { 0x01, 0x00, "No Index/Sector Signal" },
! 1232: { 0x02, 0x00, "No Seek Complete" },
! 1233: { 0x03, 0x00, "Peripheral Device Write Fault" },
! 1234: { 0x03, 0x01, "No Write Current" },
! 1235: { 0x03, 0x02, "Excessive Write Errors" },
! 1236: { 0x04, 0x00, "Logical Unit Not Ready, Cause Not Reportable" },
! 1237: { 0x04, 0x01, "Logical Unit Is in Process Of Becoming Ready" },
! 1238: { 0x04, 0x02, "Logical Unit Not Ready, Initialization Command Required" },
! 1239: { 0x04, 0x03, "Logical Unit Not Ready, Manual Intervention Required" },
! 1240: { 0x04, 0x04, "Logical Unit Not Ready, Format In Progress" },
! 1241: { 0x04, 0x05, "Logical Unit Not Ready, Rebuild In Progress" },
! 1242: { 0x04, 0x06, "Logical Unit Not Ready, Recalculation In Progress" },
! 1243: { 0x04, 0x07, "Logical Unit Not Ready, Operation In Progress" },
! 1244: { 0x04, 0x08, "Logical Unit Not Ready, Long Write In Progress" },
! 1245: { 0x04, 0x09, "Logical Unit Not Ready, Self-Test In Progress" },
! 1246: { 0x04, 0x0A, "Logical Unit Not Accessible, Asymmetric Access State Transition" },
! 1247: { 0x04, 0x0B, "Logical Unit Not Accessible, Target Port In Standby State" },
! 1248: { 0x04, 0x0C, "Logical Unit Not Accessible, Target Port In Unavailable State" },
! 1249: { 0x04, 0x10, "Logical Unit Not Ready, Auxiliary Memory Not Accessible" },
! 1250: { 0x04, 0x11, "Logical Unit Not Ready, Notify (Enable Spinup) Required" },
! 1251: { 0x05, 0x00, "Logical Unit Does Not Respond To Selection" },
! 1252: { 0x06, 0x00, "No Reference Position Found" },
! 1253: { 0x07, 0x00, "Multiple Peripheral Devices Selected" },
! 1254: { 0x08, 0x00, "Logical Unit Communication Failure" },
! 1255: { 0x08, 0x01, "Logical Unit Communication Timeout" },
! 1256: { 0x08, 0x02, "Logical Unit Communication Parity Error" },
! 1257: { 0x08, 0x03, "Logical Unit Communication CRC Error (ULTRA-DMA/32)" },
! 1258: { 0x08, 0x04, "Unreachable Copy Target" },
! 1259: { 0x09, 0x00, "Track Following Error" },
! 1260: { 0x09, 0x01, "Tracking Servo Failure" },
! 1261: { 0x09, 0x02, "Focus Servo Failure" },
! 1262: { 0x09, 0x03, "Spindle Servo Failure" },
! 1263: { 0x09, 0x04, "Head Select Fault" },
! 1264: { 0x0A, 0x00, "Error Log Overflow" },
! 1265: { 0x0B, 0x00, "Warning" },
! 1266: { 0x0B, 0x01, "Warning - Specified Temperature Exceeded" },
! 1267: { 0x0B, 0x02, "Warning - Enclosure Degraded" },
! 1268: { 0x0C, 0x00, "Write Error" },
! 1269: { 0x0C, 0x01, "Write Error Recovered with Auto Reallocation" },
! 1270: { 0x0C, 0x02, "Write Error - Auto Reallocate Failed" },
! 1271: { 0x0C, 0x03, "Write Error - Recommend Reassignment" },
! 1272: { 0x0C, 0x04, "Compression Check Miscompare Error" },
! 1273: { 0x0C, 0x05, "Data Expansion Occurred During Compression" },
! 1274: { 0x0C, 0x06, "Block Not Compressible" },
! 1275: { 0x0C, 0x07, "Write Error - Recovery Needed" },
! 1276: { 0x0C, 0x08, "Write Error - Recovery Failed" },
! 1277: { 0x0C, 0x09, "Write Error - Loss Of Streaming" },
! 1278: { 0x0C, 0x0A, "Write Error - Padding Blocks Added" },
! 1279: { 0x0C, 0x0B, "Auxiliary Memory Write Error" },
! 1280: { 0x0C, 0x0C, "Write Error - Unexpected Unsolicited Data" },
! 1281: { 0x0C, 0x0D, "Write Error - Not Enough Unsolicited Data" },
! 1282: { 0x0D, 0x00, "Error Detected By Third Party Temporary Initiator" },
! 1283: { 0x0D, 0x01, "Third Party Device Failure" },
! 1284: { 0x0D, 0x02, "Copy Target Device Not Reachable" },
! 1285: { 0x0D, 0x03, "Incorrect Copy Target Device Type" },
! 1286: { 0x0D, 0x04, "Copy Target Device Data Underrun" },
! 1287: { 0x0D, 0x05, "Copy Target Device Data Overrun" },
! 1288: { 0x0E, 0x00, "Invalid Information Unit" },
! 1289: { 0x0E, 0x01, "Information Unit Too Short" },
! 1290: { 0x0E, 0x02, "Information Unit Too Long" },
! 1291: { 0x10, 0x00, "ID CRC Or ECC Error" },
! 1292: { 0x11, 0x00, "Unrecovered Read Error" },
! 1293: { 0x11, 0x01, "Read Retries Exhausted" },
! 1294: { 0x11, 0x02, "Error Too Long To Correct" },
! 1295: { 0x11, 0x03, "Multiple Read Errors" },
! 1296: { 0x11, 0x04, "Unrecovered Read Error - Auto Reallocate Failed" },
! 1297: { 0x11, 0x05, "L-EC Uncorrectable Error" },
! 1298: { 0x11, 0x06, "CIRC Unrecovered Error" },
! 1299: { 0x11, 0x07, "Data Resynchronization Error" },
! 1300: { 0x11, 0x08, "Incomplete Block Read" },
! 1301: { 0x11, 0x09, "No Gap Found" },
! 1302: { 0x11, 0x0A, "Miscorrected Error" },
! 1303: { 0x11, 0x0B, "Uncorrected Read Error - Recommend Reassignment" },
! 1304: { 0x11, 0x0C, "Uncorrected Read Error - Recommend Rewrite The Data" },
! 1305: { 0x11, 0x0D, "De-Compression CRC Error" },
! 1306: { 0x11, 0x0E, "Cannot Decompress Using Declared Algorithm" },
! 1307: { 0x11, 0x0F, "Error Reading UPC/EAN Number" },
! 1308: { 0x11, 0x10, "Error Reading ISRC Number" },
! 1309: { 0x11, 0x11, "Read Error - Loss Of Streaming" },
! 1310: { 0x11, 0x12, "Auxiliary Memory Read Error" },
! 1311: { 0x11, 0x13, "Read Error - Failed Retransmission Request" },
! 1312: { 0x12, 0x00, "Address Mark Not Found for ID Field" },
! 1313: { 0x13, 0x00, "Address Mark Not Found for Data Field" },
! 1314: { 0x14, 0x00, "Recorded Entity Not Found" },
! 1315: { 0x14, 0x01, "Record Not Found" },
! 1316: { 0x14, 0x02, "Filemark or Setmark Not Found" },
! 1317: { 0x14, 0x03, "End-Of-Data Not Found" },
! 1318: { 0x14, 0x04, "Block Sequence Error" },
! 1319: { 0x14, 0x05, "Record Not Found - Recommend Reassignment" },
! 1320: { 0x14, 0x06, "Record Not Found - Data Auto-Reallocated" },
! 1321: { 0x14, 0x07, "Locate Operation Failure" },
! 1322: { 0x15, 0x00, "Random Positioning Error" },
! 1323: { 0x15, 0x01, "Mechanical Positioning Error" },
! 1324: { 0x15, 0x02, "Positioning Error Detected By Read of Medium" },
! 1325: { 0x16, 0x00, "Data Synchronization Mark Error" },
! 1326: { 0x16, 0x01, "Data Sync Error - Data Rewritten" },
! 1327: { 0x16, 0x02, "Data Sync Error - Recommend Rewrite" },
! 1328: { 0x16, 0x03, "Data Sync Error - Data Auto-Reallocated" },
! 1329: { 0x16, 0x04, "Data Sync Error - Recommend Reassignment" },
! 1330: { 0x17, 0x00, "Recovered Data With No Error Correction Applied" },
! 1331: { 0x17, 0x01, "Recovered Data With Retries" },
! 1332: { 0x17, 0x02, "Recovered Data With Positive Head Offset" },
! 1333: { 0x17, 0x03, "Recovered Data With Negative Head Offset" },
! 1334: { 0x17, 0x04, "Recovered Data With Retries and/or CIRC Applied" },
! 1335: { 0x17, 0x05, "Recovered Data Using Previous Sector ID" },
! 1336: { 0x17, 0x06, "Recovered Data Without ECC - Data Auto-Reallocated" },
! 1337: { 0x17, 0x07, "Recovered Data Without ECC - Recommend Reassignment" },
! 1338: { 0x17, 0x08, "Recovered Data Without ECC - Recommend Rewrite" },
! 1339: { 0x17, 0x09, "Recovered Data Without ECC - Data Rewritten" },
! 1340: { 0x18, 0x00, "Recovered Data With Error Correction Applied" },
! 1341: { 0x18, 0x01, "Recovered Data With Error Correction & Retries Applied" },
! 1342: { 0x18, 0x02, "Recovered Data - Data Auto-Reallocated" },
! 1343: { 0x18, 0x03, "Recovered Data With CIRC" },
! 1344: { 0x18, 0x04, "Recovered Data With L-EC" },
! 1345: { 0x18, 0x05, "Recovered Data - Recommend Reassignment" },
! 1346: { 0x18, 0x06, "Recovered Data - Recommend Rewrite" },
! 1347: { 0x18, 0x07, "Recovered Data With ECC - Data Rewritten" },
! 1348: { 0x18, 0x08, "Recovered Data With Linking" },
! 1349: { 0x19, 0x00, "Defect List Error" },
! 1350: { 0x19, 0x01, "Defect List Not Available" },
! 1351: { 0x19, 0x02, "Defect List Error in Primary List" },
! 1352: { 0x19, 0x03, "Defect List Error in Grown List" },
! 1353: { 0x1A, 0x00, "Parameter List Length Error" },
! 1354: { 0x1B, 0x00, "Synchronous Data Transfer Error" },
! 1355: { 0x1C, 0x00, "Defect List Not Found" },
! 1356: { 0x1C, 0x01, "Primary Defect List Not Found" },
! 1357: { 0x1C, 0x02, "Grown Defect List Not Found" },
! 1358: { 0x1D, 0x00, "Miscompare During Verify Operation" },
! 1359: { 0x1E, 0x00, "Recovered ID with ECC" },
! 1360: { 0x1F, 0x00, "Partial Defect List Transfer" },
! 1361: { 0x20, 0x00, "Invalid Command Operation Code" },
! 1362: { 0x20, 0x01, "Access Denied - Initiator Pending-Enrolled" },
! 1363: { 0x20, 0x02, "Access Denied - No Access rights" },
! 1364: { 0x20, 0x03, "Access Denied - Invalid Mgmt ID Key" },
! 1365: { 0x20, 0x04, "Illegal Command While In Write Capable State" },
! 1366: { 0x20, 0x05, "Obsolete" },
! 1367: { 0x20, 0x06, "Illegal Command While In Explicit Address Mode" },
! 1368: { 0x20, 0x07, "Illegal Command While In Implicit Address Mode" },
! 1369: { 0x20, 0x08, "Access Denied - Enrollment Conflict" },
! 1370: { 0x20, 0x09, "Access Denied - Invalid LU Identifier" },
! 1371: { 0x20, 0x0A, "Access Denied - Invalid Proxy Token" },
! 1372: { 0x20, 0x0B, "Access Denied - ACL LUN Conflict" },
! 1373: { 0x21, 0x00, "Logical Block Address Out of Range" },
! 1374: { 0x21, 0x01, "Invalid Element Address" },
! 1375: { 0x21, 0x02, "Invalid Address For Write" },
! 1376: { 0x22, 0x00, "Illegal Function (Should 20 00, 24 00, or 26 00)" },
! 1377: { 0x24, 0x00, "Illegal Field in CDB" },
! 1378: { 0x24, 0x01, "CDB Decryption Error" },
! 1379: { 0x24, 0x02, "Obsolete" },
! 1380: { 0x24, 0x03, "Obsolete" },
! 1381: { 0x24, 0x04, "Security Audit Value Frozen" },
! 1382: { 0x24, 0x05, "Security Working Key Frozen" },
! 1383: { 0x24, 0x06, "Nonce Not Unique" },
! 1384: { 0x24, 0x07, "Nonce Timestamp Out Of Range" },
! 1385: { 0x25, 0x00, "Logical Unit Not Supported" },
! 1386: { 0x26, 0x00, "Invalid Field In Parameter List" },
! 1387: { 0x26, 0x01, "Parameter Not Supported" },
! 1388: { 0x26, 0x02, "Parameter Value Invalid" },
! 1389: { 0x26, 0x03, "Threshold Parameters Not Supported" },
! 1390: { 0x26, 0x04, "Invalid Release Of Persistent Reservation" },
! 1391: { 0x26, 0x05, "Data Decryption Error" },
! 1392: { 0x26, 0x06, "Too Many Target Descriptors" },
! 1393: { 0x26, 0x07, "Unsupported Target Descriptor Type Code" },
! 1394: { 0x26, 0x08, "Too Many Segment Descriptors" },
! 1395: { 0x26, 0x09, "Unsupported Segment Descriptor Type Code" },
! 1396: { 0x26, 0x0A, "Unexpected Inexact Segment" },
! 1397: { 0x26, 0x0B, "Inline Data Length Exceeded" },
! 1398: { 0x26, 0x0C, "Invalid Operation For Copy Source Or Destination" },
! 1399: { 0x26, 0x0D, "Copy Segment Granularity Violation" },
! 1400: { 0x26, 0x0E, "Invalid Parameter While Port Is Enabled" },
! 1401: { 0x27, 0x00, "Write Protected" },
! 1402: { 0x27, 0x01, "Hardware Write Protected" },
! 1403: { 0x27, 0x02, "Logical Unit Software Write Protected" },
! 1404: { 0x27, 0x03, "Associated Write Protect" },
! 1405: { 0x27, 0x04, "Persistent Write Protect" },
! 1406: { 0x27, 0x05, "Permanent Write Protect" },
! 1407: { 0x27, 0x06, "Conditional Write Protect" },
! 1408: { 0x28, 0x00, "Not Ready To Ready Transition (Medium May Have Changed)" },
! 1409: { 0x28, 0x01, "Import Or Export Element Accessed" },
! 1410: { 0x29, 0x00, "Power On, Reset, or Bus Device Reset Occurred" },
! 1411: { 0x29, 0x01, "Power On Occurred" },
! 1412: { 0x29, 0x02, "SCSI Bus Reset Occurred" },
! 1413: { 0x29, 0x03, "Bus Device Reset Function Occurred" },
! 1414: { 0x29, 0x04, "Device Internal Reset" },
! 1415: { 0x29, 0x05, "Transceiver Mode Changed to Single Ended" },
! 1416: { 0x29, 0x06, "Transceiver Mode Changed to LVD" },
! 1417: { 0x29, 0x07, "I_T Nexus Loss Occurred" },
! 1418: { 0x2A, 0x00, "Parameters Changed" },
! 1419: { 0x2A, 0x01, "Mode Parameters Changed" },
! 1420: { 0x2A, 0x02, "Log Parameters Changed" },
! 1421: { 0x2A, 0x03, "Reservations Preempted" },
! 1422: { 0x2A, 0x04, "Reservations Released" },
! 1423: { 0x2A, 0x05, "Registrations Preempted" },
! 1424: { 0x2A, 0x06, "Asymmetric Access State Changed" },
! 1425: { 0x2A, 0x07, "Implicit Asymmetric Access State Transition Failed" },
! 1426: { 0x2B, 0x00, "Copy Cannot Execute Since Host Cannot Disconnect" },
! 1427: { 0x2C, 0x00, "Command Sequence Error" },
! 1428: { 0x2C, 0x01, "Too Many Windows Specified" },
! 1429: { 0x2C, 0x02, "Invalid Combination of Windows Specified" },
! 1430: { 0x2C, 0x03, "Current Program Area Is Not Empty" },
! 1431: { 0x2C, 0x04, "Current Program Area Is Empty" },
! 1432: { 0x2C, 0x05, "Illegal Power Condition Request" },
! 1433: { 0x2C, 0x06, "Persistent Prevent Conflict" },
! 1434: { 0x2C, 0x07, "Previous Busy Status" },
! 1435: { 0x2C, 0x08, "Previous Task Set Full Status" },
! 1436: { 0x2C, 0x09, "Previous Reservation Conflict Status" },
! 1437: { 0x2C, 0x0A, "Partition Or Collection Contains User Objects" },
! 1438: { 0x2D, 0x00, "Overwrite Error On Update In Place" },
! 1439: { 0x2E, 0x00, "Insufficient Time For Operation" },
! 1440: { 0x2F, 0x00, "Commands Cleared By Another Initiator" },
! 1441: { 0x30, 0x00, "Incompatible Medium Installed" },
! 1442: { 0x30, 0x01, "Cannot Read Medium - Unknown Format" },
! 1443: { 0x30, 0x02, "Cannot Read Medium - Incompatible Format" },
! 1444: { 0x30, 0x03, "Cleaning Cartridge Installed" },
! 1445: { 0x30, 0x04, "Cannot Write Medium - Unknown Format" },
! 1446: { 0x30, 0x05, "Cannot Write Medium - Incompatible Format" },
! 1447: { 0x30, 0x06, "Cannot Format Medium - Incompatible Medium" },
! 1448: { 0x30, 0x07, "Cleaning Failure" },
! 1449: { 0x30, 0x08, "Cannot Write - Application Code Mismatch" },
! 1450: { 0x30, 0x09, "Current Session Not Fixated For Append" },
! 1451: { 0x30, 0x0A, "Cleaning Request Rejected" },
! 1452: { 0x30, 0x10, "Medium Not Formatted" },
! 1453: { 0x31, 0x00, "Medium Format Corrupted" },
! 1454: { 0x31, 0x01, "Format Command Failed" },
! 1455: { 0x32, 0x00, "No Defect Spare Location Available" },
! 1456: { 0x32, 0x01, "Defect List Update Failure" },
! 1457: { 0x33, 0x00, "Tape Length Error" },
! 1458: { 0x34, 0x00, "Enclosure Failure" },
! 1459: { 0x35, 0x00, "Enclosure Services Failure" },
! 1460: { 0x35, 0x01, "Unsupported Enclosure Function" },
! 1461: { 0x35, 0x02, "Enclosure Services Unavailable" },
! 1462: { 0x35, 0x03, "Enclosure Services Transfer Failure" },
! 1463: { 0x35, 0x04, "Enclosure Services Transfer Refused" },
! 1464: { 0x36, 0x00, "Ribbon, Ink, or Toner Failure" },
! 1465: { 0x37, 0x00, "Rounded Parameter" },
! 1466: { 0x38, 0x00, "Event Status Notification" },
! 1467: { 0x38, 0x02, "ESN - Power Management Class Event" },
! 1468: { 0x38, 0x04, "ESN - Media Class Event" },
! 1469: { 0x38, 0x06, "ESN - Device Busy Class Event" },
! 1470: { 0x39, 0x00, "Saving Parameters Not Supported" },
! 1471: { 0x3A, 0x00, "Medium Not Present" },
! 1472: { 0x3A, 0x01, "Medium Not Present - Tray Closed" },
! 1473: { 0x3A, 0x02, "Medium Not Present - Tray Open" },
! 1474: { 0x3A, 0x03, "Medium Not Present - Loadable" },
! 1475: { 0x3A, 0x04, "Medium Not Present - Medium Auxiliary Memory Accessible" },
! 1476: { 0x3B, 0x00, "Sequential Positioning Error" },
! 1477: { 0x3B, 0x01, "Tape Position Error At Beginning-of-Medium" },
! 1478: { 0x3B, 0x02, "Tape Position Error At End-of-Medium" },
! 1479: { 0x3B, 0x03, "Tape or Electronic Vertical Forms Unit Not Ready" },
! 1480: { 0x3B, 0x04, "Slew Failure" },
! 1481: { 0x3B, 0x05, "Paper Jam" },
! 1482: { 0x3B, 0x06, "Failed To Sense Top-Of-Form" },
! 1483: { 0x3B, 0x07, "Failed To Sense Bottom-Of-Form" },
! 1484: { 0x3B, 0x08, "Reposition Error" },
! 1485: { 0x3B, 0x09, "Read Past End Of Medium" },
! 1486: { 0x3B, 0x0A, "Read Past Beginning Of Medium" },
! 1487: { 0x3B, 0x0B, "Position Past End Of Medium" },
! 1488: { 0x3B, 0x0C, "Position Past Beginning Of Medium" },
! 1489: { 0x3B, 0x0D, "Medium Destination Element Full" },
! 1490: { 0x3B, 0x0E, "Medium Source Element Empty" },
! 1491: { 0x3B, 0x0F, "End Of Medium Reached" },
! 1492: { 0x3B, 0x11, "Medium Magazine Not Accessible" },
! 1493: { 0x3B, 0x12, "Medium Magazine Removed" },
! 1494: { 0x3B, 0x13, "Medium Magazine Inserted" },
! 1495: { 0x3B, 0x14, "Medium Magazine Locked" },
! 1496: { 0x3B, 0x15, "Medium Magazine Unlocked" },
! 1497: { 0x3B, 0x16, "Mechanical Positioning Or Changer Error" },
! 1498: { 0x3D, 0x00, "Invalid Bits In IDENTIFY Message" },
! 1499: { 0x3E, 0x00, "Logical Unit Has Not Self-Configured Yet" },
! 1500: { 0x3E, 0x01, "Logical Unit Failure" },
! 1501: { 0x3E, 0x02, "Timeout On Logical Unit" },
! 1502: { 0x3E, 0x03, "Logical Unit Failed Self-Test" },
! 1503: { 0x3E, 0x04, "Logical Unit Unable To Update Self-Test Log" },
! 1504: { 0x3F, 0x00, "Target Operating Conditions Have Changed" },
! 1505: { 0x3F, 0x01, "Microcode Has Changed" },
! 1506: { 0x3F, 0x02, "Changed Operating Definition" },
! 1507: { 0x3F, 0x03, "INQUIRY Data Has Changed" },
! 1508: { 0x3F, 0x04, "component Device Attached" },
! 1509: { 0x3F, 0x05, "Device Identifier Changed" },
! 1510: { 0x3F, 0x06, "Redundancy Group Created Or Modified" },
! 1511: { 0x3F, 0x07, "Redundancy Group Deleted" },
! 1512: { 0x3F, 0x08, "Spare Created Or Modified" },
! 1513: { 0x3F, 0x09, "Spare Deleted" },
! 1514: { 0x3F, 0x0A, "Volume Set Created Or Modified" },
! 1515: { 0x3F, 0x0B, "Volume Set Deleted" },
! 1516: { 0x3F, 0x0C, "Volume Set Deassigned" },
! 1517: { 0x3F, 0x0D, "Volume Set Reassigned" },
! 1518: { 0x3F, 0x0E, "Reported LUNs Data Has Changed" },
! 1519: { 0x3F, 0x0F, "Echo Buffer Overwritten" },
! 1520: { 0x3F, 0x10, "Medium Loadable" },
! 1521: { 0x3F, 0x11, "Medium Auxiliary Memory Accessible" },
! 1522: { 0x40, 0x00, "RAM FAILURE (Should Use 40 NN)" },
! 1523: /*
! 1524: * ASC 0x40 also has an ASCQ range from 0x80 to 0xFF.
! 1525: * 0x40 0xNN DIAGNOSTIC FAILURE ON COMPONENT NN
! 1526: */
! 1527: { 0x41, 0x00, "Data Path FAILURE (Should Use 40 NN)" },
! 1528: { 0x42, 0x00, "Power-On or Self-Test FAILURE (Should Use 40 NN)" },
! 1529: { 0x43, 0x00, "Message Error" },
! 1530: { 0x44, 0x00, "Internal Target Failure" },
! 1531: { 0x45, 0x00, "Select Or Reselect Failure" },
! 1532: { 0x46, 0x00, "Unsuccessful Soft Reset" },
! 1533: { 0x47, 0x00, "SCSI Parity Error" },
! 1534: { 0x47, 0x01, "Data Phase CRC Error Detected" },
! 1535: { 0x47, 0x02, "SCSI Parity Error Detected During ST Data Phase" },
! 1536: { 0x47, 0x03, "Information Unit iuCRC Error Detected" },
! 1537: { 0x47, 0x04, "Asynchronous Information Protection Error Detected" },
! 1538: { 0x47, 0x05, "Protocol Service CRC Error" },
! 1539: { 0x47, 0x7F, "Some Commands Cleared By iSCSI Protocol Event" },
! 1540: { 0x48, 0x00, "Initiator Detected Error Message Received" },
! 1541: { 0x49, 0x00, "Invalid Message Error" },
! 1542: { 0x4A, 0x00, "Command Phase Error" },
! 1543: { 0x4B, 0x00, "Data Phase Error" },
! 1544: { 0x4B, 0x01, "Invalid Target Port Transfer Tag Received" },
! 1545: { 0x4B, 0x02, "Too Much Write Data" },
! 1546: { 0x4B, 0x03, "ACK/NAK Timeout" },
! 1547: { 0x4B, 0x04, "NAK Received" },
! 1548: { 0x4B, 0x05, "Data Offset Error" },
! 1549: { 0x4B, 0x06, "Initiator Response Timeout" },
! 1550: { 0x4C, 0x00, "Logical Unit Failed Self-Configuration" },
! 1551: /*
! 1552: * ASC 0x4D has an ASCQ range from 0x00 to 0xFF.
! 1553: * 0x4D 0xNN TAGGED OVERLAPPED COMMANDS (NN = TASK TAG)
! 1554: */
! 1555: { 0x4E, 0x00, "Overlapped Commands Attempted" },
! 1556: { 0x50, 0x00, "Write Append Error" },
! 1557: { 0x50, 0x01, "Write Append Position Error" },
! 1558: { 0x50, 0x02, "Position Error Related To Timing" },
! 1559: { 0x51, 0x00, "Erase Failure" },
! 1560: { 0x51, 0x01, "Erase Failure - Incomplete Erase Operation Detected" },
! 1561: { 0x52, 0x00, "Cartridge Fault" },
! 1562: { 0x53, 0x00, "Media Load or Eject Failed" },
! 1563: { 0x53, 0x01, "Unload Tape Failure" },
! 1564: { 0x53, 0x02, "Medium Removal Prevented" },
! 1565: { 0x54, 0x00, "SCSI To Host System Interface Failure" },
! 1566: { 0x55, 0x00, "System Resource Failure" },
! 1567: { 0x55, 0x01, "System Buffer Full" },
! 1568: { 0x55, 0x02, "Insufficient Reservation Resources" },
! 1569: { 0x55, 0x03, "Insufficient Resources" },
! 1570: { 0x55, 0x04, "Insufficient Registration Resources" },
! 1571: { 0x55, 0x05, "Insufficient Access Control Resources" },
! 1572: { 0x55, 0x06, "Auxiliary Memory Out Of Space" },
! 1573: { 0x57, 0x00, "Unable To Recover Table-Of-Contents" },
! 1574: { 0x58, 0x00, "Generation Does Not Exist" },
! 1575: { 0x59, 0x00, "Updated Block Read" },
! 1576: { 0x5A, 0x00, "Operator Request or State Change Input" },
! 1577: { 0x5A, 0x01, "Operator Medium Removal Requested" },
! 1578: { 0x5A, 0x02, "Operator Selected Write Protect" },
! 1579: { 0x5A, 0x03, "Operator Selected Write Permit" },
! 1580: { 0x5B, 0x00, "Log Exception" },
! 1581: { 0x5B, 0x01, "Threshold Condition Met" },
! 1582: { 0x5B, 0x02, "Log Counter At Maximum" },
! 1583: { 0x5B, 0x03, "Log List Codes Exhausted" },
! 1584: { 0x5C, 0x00, "RPL Status Change" },
! 1585: { 0x5C, 0x01, "Spindles Synchronized" },
! 1586: { 0x5C, 0x02, "Spindles Not Synchronized" },
! 1587: { 0x5D, 0x00, "Failure Prediction Threshold Exceeded" },
! 1588: { 0x5D, 0x01, "Media Failure Prediction Threshold Exceeded" },
! 1589: { 0x5D, 0x02, "Logical Unit Failure Prediction Threshold Exceeded" },
! 1590: { 0x5D, 0x03, "Spare Area Exhaustion Prediction Threshold Exceeded" },
! 1591: { 0x5D, 0x10, "Hardware Impending Failure General Hard Drive Failure" },
! 1592: { 0x5D, 0x11, "Hardware Impending Failure Drive Error Rate Too High" },
! 1593: { 0x5D, 0x12, "Hardware Impending Failure Data Error Rate Too High" },
! 1594: { 0x5D, 0x13, "Hardware Impending Failure Seek Error Rate Too High" },
! 1595: { 0x5D, 0x14, "Hardware Impending Failure Too Many Block Reassigns" },
! 1596: { 0x5D, 0x15, "Hardware Impending Failure Access Times Too High" },
! 1597: { 0x5D, 0x16, "Hardware Impending Failure Start Unit Times Too High" },
! 1598: { 0x5D, 0x17, "Hardware Impending Failure Channel Parametrics" },
! 1599: { 0x5D, 0x18, "Hardware Impending Failure Controller Detected" },
! 1600: { 0x5D, 0x19, "Hardware Impending Failure Throughput Performance" },
! 1601: { 0x5D, 0x1A, "Hardware Impending Failure Seek Time Performance" },
! 1602: { 0x5D, 0x1B, "Hardware Impending Failure Spin-Up Retry Count" },
! 1603: { 0x5D, 0x1C, "Hardware Impending Failure Drive Calibration Retry Count" },
! 1604: { 0x5D, 0x20, "Controller Impending Failure General Hard Drive Failure" },
! 1605: { 0x5D, 0x21, "Controller Impending Failure Drive Error Rate Too High" },
! 1606: { 0x5D, 0x22, "Controller Impending Failure Data Error Rate Too High" },
! 1607: { 0x5D, 0x23, "Controller Impending Failure Seek Error Rate Too High" },
! 1608: { 0x5D, 0x24, "Controller Impending Failure Too Many Block Reassigns" },
! 1609: { 0x5D, 0x25, "Controller Impending Failure Access Times Too High" },
! 1610: { 0x5D, 0x26, "Controller Impending Failure Start Unit Times Too High" },
! 1611: { 0x5D, 0x27, "Controller Impending Failure Channel Parametrics" },
! 1612: { 0x5D, 0x28, "Controller Impending Failure Controller Detected" },
! 1613: { 0x5D, 0x29, "Controller Impending Failure Throughput Performance" },
! 1614: { 0x5D, 0x2A, "Controller Impending Failure Seek Time Performance" },
! 1615: { 0x5D, 0x2B, "Controller Impending Failure Spin-Up Retry Count" },
! 1616: { 0x5D, 0x2C, "Controller Impending Failure Drive Calibration Retry Count" },
! 1617: { 0x5D, 0x30, "Data Channel Impending Failure General Hard Drive Failure" },
! 1618: { 0x5D, 0x31, "Data Channel Impending Failure Drive Error Rate Too High" },
! 1619: { 0x5D, 0x32, "Data Channel Impending Failure Data Error Rate Too High" },
! 1620: { 0x5D, 0x33, "Data Channel Impending Failure Seek Error Rate Too High" },
! 1621: { 0x5D, 0x34, "Data Channel Impending Failure Too Many Block Reassigns" },
! 1622: { 0x5D, 0x35, "Data Channel Impending Failure Access Times Too High" },
! 1623: { 0x5D, 0x36, "Data Channel Impending Failure Start Unit Times Too High" },
! 1624: { 0x5D, 0x37, "Data Channel Impending Failure Channel Parametrics" },
! 1625: { 0x5D, 0x38, "Data Channel Impending Failure Controller Detected" },
! 1626: { 0x5D, 0x39, "Data Channel Impending Failure Throughput Performance" },
! 1627: { 0x5D, 0x3A, "Data Channel Impending Failure Seek Time Performance" },
! 1628: { 0x5D, 0x3B, "Data Channel Impending Failure Spin-Up Retry Count" },
! 1629: { 0x5D, 0x3C, "Data Channel Impending Failure Drive Calibration Retry Count" },
! 1630: { 0x5D, 0x40, "Servo Impending Failure General Hard Drive Failure" },
! 1631: { 0x5D, 0x41, "Servo Impending Failure Drive Error Rate Too High" },
! 1632: { 0x5D, 0x42, "Servo Impending Failure Data Error Rate Too High" },
! 1633: { 0x5D, 0x43, "Servo Impending Failure Seek Error Rate Too High" },
! 1634: { 0x5D, 0x44, "Servo Impending Failure Too Many Block Reassigns" },
! 1635: { 0x5D, 0x45, "Servo Impending Failure Access Times Too High" },
! 1636: { 0x5D, 0x46, "Servo Impending Failure Start Unit Times Too High" },
! 1637: { 0x5D, 0x47, "Servo Impending Failure Channel Parametrics" },
! 1638: { 0x5D, 0x48, "Servo Impending Failure Controller Detected" },
! 1639: { 0x5D, 0x49, "Servo Impending Failure Throughput Performance" },
! 1640: { 0x5D, 0x4A, "Servo Impending Failure Seek Time Performance" },
! 1641: { 0x5D, 0x4B, "Servo Impending Failure Spin-Up Retry Count" },
! 1642: { 0x5D, 0x4C, "Servo Impending Failure Drive Calibration Retry Count" },
! 1643: { 0x5D, 0x50, "Spindle Impending Failure General Hard Drive Failure" },
! 1644: { 0x5D, 0x51, "Spindle Impending Failure Drive Error Rate Too High" },
! 1645: { 0x5D, 0x52, "Spindle Impending Failure Data Error Rate Too High" },
! 1646: { 0x5D, 0x53, "Spindle Impending Failure Seek Error Rate Too High" },
! 1647: { 0x5D, 0x54, "Spindle Impending Failure Too Many Block Reassigns" },
! 1648: { 0x5D, 0x55, "Spindle Impending Failure Access Times Too High" },
! 1649: { 0x5D, 0x56, "Spindle Impending Failure Start Unit Times Too High" },
! 1650: { 0x5D, 0x57, "Spindle Impending Failure Channel Parametrics" },
! 1651: { 0x5D, 0x58, "Spindle Impending Failure Controller Detected" },
! 1652: { 0x5D, 0x59, "Spindle Impending Failure Throughput Performance" },
! 1653: { 0x5D, 0x5A, "Spindle Impending Failure Seek Time Performance" },
! 1654: { 0x5D, 0x5B, "Spindle Impending Failure Spin-Up Retry Count" },
! 1655: { 0x5D, 0x5C, "Spindle Impending Failure Drive Calibration Retry Count" },
! 1656: { 0x5D, 0x60, "Firmware Impending Failure General Hard Drive Failure" },
! 1657: { 0x5D, 0x61, "Firmware Impending Failure Drive Error Rate Too High" },
! 1658: { 0x5D, 0x62, "Firmware Impending Failure Data Error Rate Too High" },
! 1659: { 0x5D, 0x63, "Firmware Impending Failure Seek Error Rate Too High" },
! 1660: { 0x5D, 0x64, "Firmware Impending Failure Too Many Block Reassigns" },
! 1661: { 0x5D, 0x65, "Firmware Impending Failure Access Times Too High" },
! 1662: { 0x5D, 0x66, "Firmware Impending Failure Start Unit Times Too High" },
! 1663: { 0x5D, 0x67, "Firmware Impending Failure Channel Parametrics" },
! 1664: { 0x5D, 0x68, "Firmware Impending Failure Controller Detected" },
! 1665: { 0x5D, 0x69, "Firmware Impending Failure Throughput Performance" },
! 1666: { 0x5D, 0x6A, "Firmware Impending Failure Seek Time Performance" },
! 1667: { 0x5D, 0x6B, "Firmware Impending Failure Spin-Up Retry Count" },
! 1668: { 0x5D, 0x6C, "Firmware Impending Failure Drive Calibration Retry Count" },
! 1669: { 0x5D, 0xFF, "Failure Prediction Threshold Exceeded (false)" },
! 1670: { 0x5E, 0x00, "Low Power Condition On" },
! 1671: { 0x5E, 0x01, "Idle Condition Activated By Timer" },
! 1672: { 0x5E, 0x02, "Standby Condition Activated By Timer" },
! 1673: { 0x5E, 0x03, "Idle Condition Activated By Command" },
! 1674: { 0x5E, 0x04, "Standby Condition Activated By Command" },
! 1675: { 0x5E, 0x41, "Power State Change To Active" },
! 1676: { 0x5E, 0x42, "Power State Change To Idle" },
! 1677: { 0x5E, 0x43, "Power State Change To Standby" },
! 1678: { 0x5E, 0x45, "Power State Change To Sleep" },
! 1679: { 0x5E, 0x47, "Power State Change To Device Control" },
! 1680: { 0x60, 0x00, "Lamp Failure" },
! 1681: { 0x61, 0x00, "Video Acquisition Error" },
! 1682: { 0x61, 0x01, "Unable To Acquire Video" },
! 1683: { 0x61, 0x02, "Out Of Focus" },
! 1684: { 0x62, 0x00, "Scan Head Positioning Error" },
! 1685: { 0x63, 0x00, "End Of User Area Encountered On This Track" },
! 1686: { 0x63, 0x01, "Packet Does Not Fit In Available Space" },
! 1687: { 0x64, 0x00, "Illegal Mode For This Track" },
! 1688: { 0x64, 0x01, "Invalid Packet Size" },
! 1689: { 0x65, 0x00, "Voltage Fault" },
! 1690: { 0x66, 0x00, "Automatic Document Feeder Cover Up" },
! 1691: { 0x66, 0x01, "Automatic Document Feeder Lift Up" },
! 1692: { 0x66, 0x02, "Document Jam In Automatic Document Feeder" },
! 1693: { 0x66, 0x03, "Document Miss Feed Automatic In Document Feeder" },
! 1694: { 0x67, 0x00, "Configuration Failure" },
! 1695: { 0x67, 0x01, "Configuration Of Incapable Logical Units Failed" },
! 1696: { 0x67, 0x02, "Add Logical Unit Failed" },
! 1697: { 0x67, 0x03, "Modification Of Logical Unit Failed" },
! 1698: { 0x67, 0x04, "Exchange Of Logical Unit Failed" },
! 1699: { 0x67, 0x05, "Remove Of Logical Unit Failed" },
! 1700: { 0x67, 0x06, "Attachment Of Logical Unit Failed" },
! 1701: { 0x67, 0x07, "Creation Of Logical Unit Failed" },
! 1702: { 0x67, 0x08, "Assign Failure Occurred" },
! 1703: { 0x67, 0x09, "Multiply Assigned Logical Unit" },
! 1704: { 0x67, 0x0A, "Set Target Port Groups Command Failed" },
! 1705: { 0x68, 0x00, "Logical Unit Not Configured" },
! 1706: { 0x69, 0x00, "Data Loss On Logical Unit" },
! 1707: { 0x69, 0x01, "Multiple Logical Unit Failures" },
! 1708: { 0x69, 0x02, "Parity/Data Mismatch" },
! 1709: { 0x6A, 0x00, "Informational, Refer To Log" },
! 1710: { 0x6B, 0x00, "State Change Has Occurred" },
! 1711: { 0x6B, 0x01, "Redundancy Level Got Better" },
! 1712: { 0x6B, 0x02, "Redundancy Level Got Worse" },
! 1713: { 0x6C, 0x00, "Rebuild Failure Occurred" },
! 1714: { 0x6D, 0x00, "Recalculate Failure Occurred" },
! 1715: { 0x6E, 0x00, "Command To Logical Unit Failed" },
! 1716: { 0x6F, 0x00, "Copy Protection Key Exchange Failure - Authentication Failure" },
! 1717: { 0x6F, 0x01, "Copy Protection Key Exchange Failure - Key Not Present" },
! 1718: { 0x6F, 0x02, "Copy Protection Key Exchange Failure - Key Not Established" },
! 1719: { 0x6F, 0x03, "Read Of Scrambled Sector Without Authentication" },
! 1720: { 0x6F, 0x04, "Media Region Code Is Mismatched To Logical Unit Region" },
! 1721: { 0x6F, 0x05, "Drive Region Must Be Permanent/Region Reset Count Error" },
! 1722: /*
! 1723: * ASC 0x70 has an ASCQ range from 0x00 to 0xFF.
! 1724: * 0x70 0xNN DECOMPRESSION EXCEPTION SHORT ALGORITHM ID Of NN
! 1725: */
! 1726: { 0x71, 0x00, "Decompression Exception Long Algorithm ID" },
! 1727: { 0x72, 0x00, "Session Fixation Error" },
! 1728: { 0x72, 0x01, "Session Fixation Error Writing Lead-In" },
! 1729: { 0x72, 0x02, "Session Fixation Error Writing Lead-Out" },
! 1730: { 0x72, 0x03, "Session Fixation Error - Incomplete Track In Session" },
! 1731: { 0x72, 0x04, "Empty Or Partially Written Reserved Track" },
! 1732: { 0x72, 0x05, "No More Track Reservations Allowed" },
! 1733: { 0x73, 0x00, "CD Control Error" },
! 1734: { 0x73, 0x01, "Power Calibration Area Almost Full" },
! 1735: { 0x73, 0x02, "Power Calibration Area Is Full" },
! 1736: { 0x73, 0x03, "Power Calibration Area Error" },
! 1737: { 0x73, 0x04, "Program Memory Area Update Failure" },
! 1738: { 0x73, 0x05, "Program Memory Area Is Full" },
! 1739: { 0x73, 0x06, "RMA/PMA Is Almost Full" },
! 1740: { 0x00, 0x00, NULL }
! 1741: };
! 1742:
! 1743: static __inline void
! 1744: asc2ascii(u_int8_t asc, u_int8_t ascq, char *result, size_t len)
! 1745: {
! 1746: int i;
! 1747:
! 1748: /* Check for a dynamically built description. */
! 1749: switch (asc) {
! 1750: case 0x40:
! 1751: if (ascq >= 0x80) {
! 1752: snprintf(result, len,
! 1753: "Diagnostic Failure on Component 0x%02x", ascq);
! 1754: return;
! 1755: }
! 1756: break;
! 1757: case 0x4d:
! 1758: snprintf(result, len,
! 1759: "Tagged Overlapped Commands (0x%02x = TASK TAG)", ascq);
! 1760: return;
! 1761: case 0x70:
! 1762: snprintf(result, len,
! 1763: "Decompression Exception Short Algorithm ID OF 0x%02x",
! 1764: ascq);
! 1765: return;
! 1766: default:
! 1767: break;
! 1768: }
! 1769:
! 1770: /* Check for a fixed description. */
! 1771: for (i = 0; adesc[i].description != NULL; i++) {
! 1772: if (adesc[i].asc == asc && adesc[i].ascq == ascq) {
! 1773: strlcpy(result, adesc[i].description, len);
! 1774: return;
! 1775: }
! 1776: }
! 1777:
! 1778: /* Just print out the ASC and ASCQ values as a description. */
! 1779: snprintf(result, len, "ASC 0x%02x ASCQ 0x%02x", asc, ascq);
! 1780: }
! 1781: #endif /* SCSITERSE */
! 1782:
! 1783: void
! 1784: scsi_print_sense(struct scsi_xfer *xs)
! 1785: {
! 1786: struct scsi_sense_data *sense = &xs->sense;
! 1787: u_int8_t serr = sense->error_code &
! 1788: SSD_ERRCODE;
! 1789: int32_t info;
! 1790: char *sbs;
! 1791:
! 1792: sc_print_addr(xs->sc_link);
! 1793:
! 1794: /* XXX For error 0x71, current opcode is not the relevant one. */
! 1795: printf("%sCheck Condition (error %#x) on opcode 0x%x\n",
! 1796: (serr == SSD_ERRCODE_DEFERRED) ? "DEFERRED " : "", serr,
! 1797: xs->cmd->opcode);
! 1798:
! 1799: if (serr != SSD_ERRCODE_CURRENT && serr != SSD_ERRCODE_DEFERRED) {
! 1800: if ((sense->error_code & SSD_ERRCODE_VALID) != 0) {
! 1801: struct scsi_sense_data_unextended *usense =
! 1802: (struct scsi_sense_data_unextended *)sense;
! 1803: printf(" AT BLOCK #: %d (decimal)",
! 1804: _3btol(usense->block));
! 1805: }
! 1806: return;
! 1807: }
! 1808:
! 1809: printf(" SENSE KEY: %s\n", scsi_decode_sense(sense,
! 1810: DECODE_SENSE_KEY));
! 1811:
! 1812: if (sense->flags & (SSD_FILEMARK | SSD_EOM | SSD_ILI)) {
! 1813: char pad = ' ';
! 1814:
! 1815: printf(" ");
! 1816: if (sense->flags & SSD_FILEMARK) {
! 1817: printf("%c Filemark Detected", pad);
! 1818: pad = ',';
! 1819: }
! 1820: if (sense->flags & SSD_EOM) {
! 1821: printf("%c EOM Detected", pad);
! 1822: pad = ',';
! 1823: }
! 1824: if (sense->flags & SSD_ILI)
! 1825: printf("%c Incorrect Length Indicator Set", pad);
! 1826: printf("\n");
! 1827: }
! 1828:
! 1829: /*
! 1830: * It is inconvenient to use device type to figure out how to
! 1831: * format the info fields. So print them as 32 bit integers.
! 1832: */
! 1833: info = _4btol(&sense->info[0]);
! 1834: if (info)
! 1835: printf(" INFO: 0x%x (VALID flag %s)\n", info,
! 1836: sense->error_code & SSD_ERRCODE_VALID ? "on" : "off");
! 1837:
! 1838: if (sense->extra_len < 4)
! 1839: return;
! 1840:
! 1841: info = _4btol(&sense->cmd_spec_info[0]);
! 1842: if (info)
! 1843: printf(" COMMAND INFO: 0x%x\n", info);
! 1844: sbs = scsi_decode_sense(sense, DECODE_ASC_ASCQ);
! 1845: if (strlen(sbs) > 0)
! 1846: printf(" ASC/ASCQ: %s\n", sbs);
! 1847: if (sense->fru != 0)
! 1848: printf(" FRU CODE: 0x%x\n", sense->fru);
! 1849: sbs = scsi_decode_sense(sense, DECODE_SKSV);
! 1850: if (strlen(sbs) > 0)
! 1851: printf(" SKSV: %s\n", sbs);
! 1852: }
! 1853:
! 1854: char *
! 1855: scsi_decode_sense(struct scsi_sense_data *sense, int flag)
! 1856: {
! 1857: static char rqsbuf[132];
! 1858: u_int16_t count;
! 1859: u_int8_t skey, spec_1;
! 1860: int len;
! 1861:
! 1862: bzero(rqsbuf, sizeof(rqsbuf));
! 1863:
! 1864: skey = sense->flags & SSD_KEY;
! 1865: spec_1 = sense->sense_key_spec_1;
! 1866: count = _2btol(&sense->sense_key_spec_2);
! 1867:
! 1868: switch (flag) {
! 1869: case DECODE_SENSE_KEY:
! 1870: strlcpy(rqsbuf, sense_keys[skey], sizeof(rqsbuf));
! 1871: break;
! 1872: case DECODE_ASC_ASCQ:
! 1873: asc2ascii(sense->add_sense_code, sense->add_sense_code_qual,
! 1874: rqsbuf, sizeof(rqsbuf));
! 1875: break;
! 1876: case DECODE_SKSV:
! 1877: if (sense->extra_len < 9 || ((spec_1 & SSD_SCS_VALID) == 0))
! 1878: break;
! 1879: switch (skey) {
! 1880: case SKEY_ILLEGAL_REQUEST:
! 1881: len = snprintf(rqsbuf, sizeof rqsbuf,
! 1882: "Error in %s, Offset %d",
! 1883: (spec_1 & SSD_SCS_CDB_ERROR) ? "CDB" : "Parameters",
! 1884: count);
! 1885: if ((len != -1 && len < sizeof rqsbuf) &&
! 1886: (spec_1 & SSD_SCS_VALID_BIT_INDEX))
! 1887: snprintf(rqsbuf+len, sizeof rqsbuf - len,
! 1888: ", bit %d", spec_1 & SSD_SCS_BIT_INDEX);
! 1889: break;
! 1890: case SKEY_RECOVERED_ERROR:
! 1891: case SKEY_MEDIUM_ERROR:
! 1892: case SKEY_HARDWARE_ERROR:
! 1893: snprintf(rqsbuf, sizeof rqsbuf,
! 1894: "Actual Retry Count: %d", count);
! 1895: break;
! 1896: case SKEY_NOT_READY:
! 1897: snprintf(rqsbuf, sizeof rqsbuf,
! 1898: "Progress Indicator: %d", count);
! 1899: break;
! 1900: default:
! 1901: break;
! 1902: }
! 1903: break;
! 1904: default:
! 1905: break;
! 1906: }
! 1907:
! 1908: return (rqsbuf);
! 1909: }
! 1910:
! 1911: #ifdef SCSIDEBUG
! 1912: /*
! 1913: * Given a scsi_xfer, dump the request, in all its glory
! 1914: */
! 1915: void
! 1916: show_scsi_xs(struct scsi_xfer *xs)
! 1917: {
! 1918: printf("xs(%p): ", xs);
! 1919: printf("flg(0x%x)", xs->flags);
! 1920: printf("sc_link(%p)", xs->sc_link);
! 1921: printf("retr(0x%x)", xs->retries);
! 1922: printf("timo(0x%x)", xs->timeout);
! 1923: printf("cmd(%p)", xs->cmd);
! 1924: printf("len(0x%x)", xs->cmdlen);
! 1925: printf("data(%p)", xs->data);
! 1926: printf("len(0x%x)", xs->datalen);
! 1927: printf("res(0x%x)", xs->resid);
! 1928: printf("err(0x%x)", xs->error);
! 1929: printf("bp(%p)", xs->bp);
! 1930: show_scsi_cmd(xs);
! 1931: }
! 1932:
! 1933: void
! 1934: show_scsi_cmd(struct scsi_xfer *xs)
! 1935: {
! 1936: u_char *b = (u_char *) xs->cmd;
! 1937: int i = 0;
! 1938:
! 1939: sc_print_addr(xs->sc_link);
! 1940: printf("command: ");
! 1941:
! 1942: if ((xs->flags & SCSI_RESET) == 0) {
! 1943: while (i < xs->cmdlen) {
! 1944: if (i)
! 1945: printf(",");
! 1946: printf("%x", b[i++]);
! 1947: }
! 1948: printf("-[%d bytes]\n", xs->datalen);
! 1949: if (xs->datalen)
! 1950: show_mem(xs->data, min(64, xs->datalen));
! 1951: } else
! 1952: printf("-RESET-\n");
! 1953: }
! 1954:
! 1955: void
! 1956: show_mem(u_char *address, int num)
! 1957: {
! 1958: int x;
! 1959:
! 1960: printf("------------------------------");
! 1961: for (x = 0; x < num; x++) {
! 1962: if ((x % 16) == 0)
! 1963: printf("\n%03d: ", x);
! 1964: printf("%02x ", *address++);
! 1965: }
! 1966: printf("\n------------------------------\n");
! 1967: }
! 1968: #endif /* SCSIDEBUG */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to scsi_base.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / scsi