1 /* $NetBSD: scsipi_base.c,v 1.17 1999/01/10 06:26:23 mjacob Exp $ */ 2 3 /*- 4 * Copyright (c) 1998 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Charles M. Hannum. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include "opt_scsi.h" 40 41 #include <sys/types.h> 42 #include <sys/param.h> 43 #include <sys/systm.h> 44 #include <sys/kernel.h> 45 #include <sys/buf.h> 46 #include <sys/uio.h> 47 #include <sys/malloc.h> 48 #include <sys/pool.h> 49 #include <sys/errno.h> 50 #include <sys/device.h> 51 #include <sys/proc.h> 52 53 #include <dev/scsipi/scsipi_all.h> 54 #include <dev/scsipi/scsipi_disk.h> 55 #include <dev/scsipi/scsipiconf.h> 56 #include <dev/scsipi/scsipi_base.h> 57 58 struct pool scsipi_xfer_pool; 59 60 int sc_err1 __P((struct scsipi_xfer *, int)); 61 62 /* 63 * Called when a scsibus is attached to initialize global data. 64 */ 65 void 66 scsipi_init() 67 { 68 static int scsipi_init_done; 69 70 if (scsipi_init_done) 71 return; 72 scsipi_init_done = 1; 73 74 /* Initialize the scsipi_xfer pool. */ 75 pool_init(&scsipi_xfer_pool, sizeof(struct scsipi_xfer), 0, 76 0, 0, "scxspl", 0, NULL, NULL, M_DEVBUF); 77 } 78 79 /* 80 * Get a scsipi transfer structure for the caller. Charge the structure 81 * to the device that is referenced by the sc_link structure. If the 82 * sc_link structure has no 'credits' then the device already has the 83 * maximum number or outstanding operations under way. In this stage, 84 * wait on the structure so that when one is freed, we are awoken again 85 * If the SCSI_NOSLEEP flag is set, then do not wait, but rather, return 86 * a NULL pointer, signifying that no slots were available 87 * Note in the link structure, that we are waiting on it. 88 */ 89 90 struct scsipi_xfer * 91 scsipi_get_xs(sc_link, flags) 92 struct scsipi_link *sc_link; /* who to charge the xs to */ 93 int flags; /* if this call can sleep */ 94 { 95 struct scsipi_xfer *xs; 96 int s; 97 98 SC_DEBUG(sc_link, SDEV_DB3, ("scsipi_get_xs\n")); 99 100 s = splbio(); 101 while (sc_link->openings <= 0) { 102 SC_DEBUG(sc_link, SDEV_DB3, ("sleeping\n")); 103 if ((flags & SCSI_NOSLEEP) != 0) { 104 splx(s); 105 return (0); 106 } 107 sc_link->flags |= SDEV_WAITING; 108 (void)tsleep(sc_link, PRIBIO, "getxs", 0); 109 } 110 SC_DEBUG(sc_link, SDEV_DB3, ("calling pool_get\n")); 111 xs = pool_get(&scsipi_xfer_pool, 112 ((flags & SCSI_NOSLEEP) != 0 ? PR_NOWAIT : PR_WAITOK)); 113 if (xs != NULL) 114 sc_link->openings--; 115 else { 116 (*sc_link->sc_print_addr)(sc_link); 117 printf("cannot allocate scsipi xs\n"); 118 } 119 splx(s); 120 121 SC_DEBUG(sc_link, SDEV_DB3, ("returning\n")); 122 123 /* 124 * zeroes out the command, as ATAPI may use longer commands 125 * than SCSI 126 */ 127 if (xs != NULL) { 128 xs->flags = INUSE | flags; 129 TAILQ_INSERT_TAIL(&sc_link->pending_xfers, xs, device_q); 130 bzero(&xs->cmdstore, sizeof(xs->cmdstore)); 131 } 132 return (xs); 133 } 134 135 /* 136 * Given a scsipi_xfer struct, and a device (referenced through sc_link) 137 * return the struct to the free pool and credit the device with it 138 * If another process is waiting for an xs, do a wakeup, let it proceed 139 * 140 * MUST BE CALLED AT splbio()!! 141 */ 142 void 143 scsipi_free_xs(xs, flags) 144 struct scsipi_xfer *xs; 145 int flags; 146 { 147 struct scsipi_link *sc_link = xs->sc_link; 148 149 TAILQ_REMOVE(&sc_link->pending_xfers, xs, device_q); 150 if (TAILQ_FIRST(&sc_link->pending_xfers) == NULL && 151 (sc_link->flags & SDEV_WAITDRAIN) != 0) { 152 sc_link->flags &= ~SDEV_WAITDRAIN; 153 wakeup(&sc_link->pending_xfers); 154 } 155 xs->flags &= ~INUSE; 156 pool_put(&scsipi_xfer_pool, xs); 157 158 SC_DEBUG(sc_link, SDEV_DB3, ("scsipi_free_xs\n")); 159 /* if was 0 and someone waits, wake them up */ 160 sc_link->openings++; 161 if ((sc_link->flags & SDEV_WAITING) != 0) { 162 sc_link->flags &= ~SDEV_WAITING; 163 wakeup(sc_link); 164 } else { 165 if (sc_link->device->start) { 166 SC_DEBUG(sc_link, SDEV_DB2, 167 ("calling private start()\n")); 168 (*(sc_link->device->start))(sc_link->device_softc); 169 } 170 } 171 } 172 173 /* 174 * Wait for a scsipi_link's pending xfers to drain. 175 */ 176 void 177 scsipi_wait_drain(sc_link) 178 struct scsipi_link *sc_link; 179 { 180 int s; 181 182 s = splbio(); 183 while (TAILQ_FIRST(&sc_link->pending_xfers) != NULL) { 184 sc_link->flags |= SDEV_WAITDRAIN; 185 (void) tsleep(&sc_link->pending_xfers, PRIBIO, "sxdrn", 0); 186 } 187 splx(s); 188 } 189 190 /* 191 * Look at the returned sense and act on the error, determining 192 * the unix error number to pass back. (0 = report no error) 193 * 194 * THIS IS THE DEFAULT ERROR HANDLER FOR SCSI DEVICES 195 */ 196 int 197 scsipi_interpret_sense(xs) 198 struct scsipi_xfer *xs; 199 { 200 struct scsipi_sense_data *sense; 201 struct scsipi_link *sc_link = xs->sc_link; 202 u_int8_t key; 203 u_int32_t info; 204 int error; 205 #ifndef SCSIVERBOSE 206 static char *error_mes[] = { 207 "soft error (corrected)", 208 "not ready", "medium error", 209 "non-media hardware failure", "illegal request", 210 "unit attention", "readonly device", 211 "no data found", "vendor unique", 212 "copy aborted", "command aborted", 213 "search returned equal", "volume overflow", 214 "verify miscompare", "unknown error key" 215 }; 216 #endif 217 218 sense = &xs->sense.scsi_sense; 219 #ifdef SCSIDEBUG 220 if ((sc_link->flags & SDEV_DB1) != 0) { 221 int count; 222 printf("code 0x%x valid 0x%x ", 223 sense->error_code & SSD_ERRCODE, 224 sense->error_code & SSD_ERRCODE_VALID ? 1 : 0); 225 printf("seg 0x%x key 0x%x ili 0x%x eom 0x%x fmark 0x%x\n", 226 sense->segment, 227 sense->flags & SSD_KEY, 228 sense->flags & SSD_ILI ? 1 : 0, 229 sense->flags & SSD_EOM ? 1 : 0, 230 sense->flags & SSD_FILEMARK ? 1 : 0); 231 printf("info: 0x%x 0x%x 0x%x 0x%x followed by %d extra bytes\n", 232 sense->info[0], 233 sense->info[1], 234 sense->info[2], 235 sense->info[3], 236 sense->extra_len); 237 printf("extra: "); 238 for (count = 0; count < ADD_BYTES_LIM(sense); count++) 239 printf("0x%x ", sense->cmd_spec_info[count]); 240 printf("\n"); 241 } 242 #endif /* SCSIDEBUG */ 243 /* 244 * If the device has it's own error handler, call it first. 245 * If it returns a legit error value, return that, otherwise 246 * it wants us to continue with normal error processing. 247 */ 248 if (sc_link->device->err_handler) { 249 SC_DEBUG(sc_link, SDEV_DB2, 250 ("calling private err_handler()\n")); 251 error = (*sc_link->device->err_handler)(xs); 252 if (error != SCSIRET_CONTINUE) 253 return (error); /* error >= 0 better ? */ 254 } 255 /* otherwise use the default */ 256 switch (sense->error_code & SSD_ERRCODE) { 257 /* 258 * If it's code 70, use the extended stuff and 259 * interpret the key 260 */ 261 case 0x71: /* delayed error */ 262 sc_link->sc_print_addr(sc_link); 263 key = sense->flags & SSD_KEY; 264 printf(" DEFERRED ERROR, key = 0x%x\n", key); 265 /* FALLTHROUGH */ 266 case 0x70: 267 if ((sense->error_code & SSD_ERRCODE_VALID) != 0) 268 info = _4btol(sense->info); 269 else 270 info = 0; 271 key = sense->flags & SSD_KEY; 272 273 switch (key) { 274 case SKEY_NO_SENSE: 275 case SKEY_RECOVERED_ERROR: 276 if (xs->resid == xs->datalen && xs->datalen) { 277 /* 278 * Why is this here? 279 */ 280 xs->resid = 0; /* not short read */ 281 } 282 case SKEY_EQUAL: 283 error = 0; 284 break; 285 case SKEY_NOT_READY: 286 if ((sc_link->flags & SDEV_REMOVABLE) != 0) 287 sc_link->flags &= ~SDEV_MEDIA_LOADED; 288 if ((xs->flags & SCSI_IGNORE_NOT_READY) != 0) 289 return (0); 290 if ((xs->flags & SCSI_SILENT) != 0) 291 return (EIO); 292 error = EIO; 293 break; 294 case SKEY_ILLEGAL_REQUEST: 295 if ((xs->flags & SCSI_IGNORE_ILLEGAL_REQUEST) != 0) 296 return (0); 297 if ((xs->flags & SCSI_SILENT) != 0) 298 return (EIO); 299 error = EINVAL; 300 break; 301 case SKEY_UNIT_ATTENTION: 302 if ((sc_link->flags & SDEV_REMOVABLE) != 0) 303 sc_link->flags &= ~SDEV_MEDIA_LOADED; 304 if ((xs->flags & SCSI_IGNORE_MEDIA_CHANGE) != 0 || 305 /* XXX Should reupload any transient state. */ 306 (sc_link->flags & SDEV_REMOVABLE) == 0) 307 return (ERESTART); 308 if ((xs->flags & SCSI_SILENT) != 0) 309 return (EIO); 310 error = EIO; 311 break; 312 case SKEY_WRITE_PROTECT: 313 error = EROFS; 314 break; 315 case SKEY_BLANK_CHECK: 316 error = 0; 317 break; 318 case SKEY_ABORTED_COMMAND: 319 error = ERESTART; 320 break; 321 case SKEY_VOLUME_OVERFLOW: 322 error = ENOSPC; 323 break; 324 default: 325 error = EIO; 326 break; 327 } 328 329 #ifdef SCSIVERBOSE 330 if ((xs->flags & SCSI_SILENT) == 0) 331 scsipi_print_sense(xs, 0); 332 #else 333 if (key) { 334 sc_link->sc_print_addr(sc_link); 335 printf("%s", error_mes[key - 1]); 336 if ((sense->error_code & SSD_ERRCODE_VALID) != 0) { 337 switch (key) { 338 case SKEY_NOT_READY: 339 case SKEY_ILLEGAL_REQUEST: 340 case SKEY_UNIT_ATTENTION: 341 case SKEY_WRITE_PROTECT: 342 break; 343 case SKEY_BLANK_CHECK: 344 printf(", requested size: %d (decimal)", 345 info); 346 break; 347 case SKEY_ABORTED_COMMAND: 348 if (xs->retries) 349 printf(", retrying"); 350 printf(", cmd 0x%x, info 0x%x", 351 xs->cmd->opcode, info); 352 break; 353 default: 354 printf(", info = %d (decimal)", info); 355 } 356 } 357 if (sense->extra_len != 0) { 358 int n; 359 printf(", data ="); 360 for (n = 0; n < sense->extra_len; n++) 361 printf(" %02x", 362 sense->cmd_spec_info[n]); 363 } 364 printf("\n"); 365 } 366 #endif 367 return (error); 368 369 /* 370 * Not code 70, just report it 371 */ 372 default: 373 sc_link->sc_print_addr(sc_link); 374 printf("Sense Error Code 0x%x", 375 sense->error_code & SSD_ERRCODE); 376 if ((sense->error_code & SSD_ERRCODE_VALID) != 0) { 377 struct scsipi_sense_data_unextended *usense = 378 (struct scsipi_sense_data_unextended *)sense; 379 printf(" at block no. %d (decimal)", 380 _3btol(usense->block)); 381 } 382 printf("\n"); 383 return (EIO); 384 } 385 } 386 387 /* 388 * Find out from the device what its capacity is. 389 */ 390 u_long 391 scsipi_size(sc_link, flags) 392 struct scsipi_link *sc_link; 393 int flags; 394 { 395 struct scsipi_read_cap_data rdcap; 396 struct scsipi_read_capacity scsipi_cmd; 397 398 /* 399 * make up a scsipi command and ask the scsipi driver to do 400 * it for you. 401 */ 402 bzero(&scsipi_cmd, sizeof(scsipi_cmd)); 403 scsipi_cmd.opcode = READ_CAPACITY; 404 405 /* 406 * If the command works, interpret the result as a 4 byte 407 * number of blocks 408 */ 409 if (scsipi_command(sc_link, (struct scsipi_generic *)&scsipi_cmd, 410 sizeof(scsipi_cmd), (u_char *)&rdcap, sizeof(rdcap), 411 2, 20000, NULL, flags | SCSI_DATA_IN) != 0) { 412 sc_link->sc_print_addr(sc_link); 413 printf("could not get size\n"); 414 return (0); 415 } 416 417 return (_4btol(rdcap.addr) + 1); 418 } 419 420 /* 421 * Get scsipi driver to send a "are you ready?" command 422 */ 423 int 424 scsipi_test_unit_ready(sc_link, flags) 425 struct scsipi_link *sc_link; 426 int flags; 427 { 428 struct scsipi_test_unit_ready scsipi_cmd; 429 430 /* some ATAPI drives don't support TEST_UNIT_READY. Sigh */ 431 if (sc_link->quirks & ADEV_NOTUR) 432 return (0); 433 434 bzero(&scsipi_cmd, sizeof(scsipi_cmd)); 435 scsipi_cmd.opcode = TEST_UNIT_READY; 436 437 return (scsipi_command(sc_link, 438 (struct scsipi_generic *)&scsipi_cmd, sizeof(scsipi_cmd), 439 0, 0, 2, 10000, NULL, flags)); 440 } 441 442 /* 443 * Do a scsipi operation asking a device what it is 444 * Use the scsipi_cmd routine in the switch table. 445 * XXX actually this is only used for scsi devices, because I have the feeling 446 * that some atapi CDROM may not implement it, althouh it marked as mandatory 447 * in the atapi specs. 448 */ 449 int 450 scsipi_inquire(sc_link, inqbuf, flags) 451 struct scsipi_link *sc_link; 452 struct scsipi_inquiry_data *inqbuf; 453 int flags; 454 { 455 struct scsipi_inquiry scsipi_cmd; 456 457 bzero(&scsipi_cmd, sizeof(scsipi_cmd)); 458 scsipi_cmd.opcode = INQUIRY; 459 scsipi_cmd.length = sizeof(struct scsipi_inquiry_data); 460 461 return (scsipi_command(sc_link, 462 (struct scsipi_generic *) &scsipi_cmd, sizeof(scsipi_cmd), 463 (u_char *) inqbuf, sizeof(struct scsipi_inquiry_data), 464 2, 10000, NULL, SCSI_DATA_IN | flags)); 465 } 466 467 /* 468 * Prevent or allow the user to remove the media 469 */ 470 int 471 scsipi_prevent(sc_link, type, flags) 472 struct scsipi_link *sc_link; 473 int type, flags; 474 { 475 struct scsipi_prevent scsipi_cmd; 476 477 if (sc_link->quirks & ADEV_NODOORLOCK) 478 return (0); 479 480 bzero(&scsipi_cmd, sizeof(scsipi_cmd)); 481 scsipi_cmd.opcode = PREVENT_ALLOW; 482 scsipi_cmd.how = type; 483 return (scsipi_command(sc_link, 484 (struct scsipi_generic *) &scsipi_cmd, sizeof(scsipi_cmd), 485 0, 0, 2, 5000, NULL, flags)); 486 } 487 488 /* 489 * Get scsipi driver to send a "start up" command 490 */ 491 int 492 scsipi_start(sc_link, type, flags) 493 struct scsipi_link *sc_link; 494 int type, flags; 495 { 496 struct scsipi_start_stop scsipi_cmd; 497 498 bzero(&scsipi_cmd, sizeof(scsipi_cmd)); 499 scsipi_cmd.opcode = START_STOP; 500 scsipi_cmd.byte2 = 0x00; 501 scsipi_cmd.how = type; 502 return (scsipi_command(sc_link, 503 (struct scsipi_generic *) &scsipi_cmd, sizeof(scsipi_cmd), 504 0, 0, 2, type == SSS_START ? 30000 : 10000, NULL, flags)); 505 } 506 507 /* 508 * This routine is called by the scsipi interrupt when the transfer is 509 * complete. 510 */ 511 void 512 scsipi_done(xs) 513 struct scsipi_xfer *xs; 514 { 515 struct scsipi_link *sc_link = xs->sc_link; 516 struct buf *bp; 517 int error; 518 519 SC_DEBUG(sc_link, SDEV_DB2, ("scsipi_done\n")); 520 #ifdef SCSIDEBUG 521 if ((sc_link->flags & SDEV_DB1) != 0) 522 show_scsipi_cmd(xs); 523 #endif /* SCSIDEBUG */ 524 525 /* 526 * If it's a user level request, bypass all usual completion 527 * processing, let the user work it out.. We take 528 * reponsibility for freeing the xs when the user returns. 529 * (and restarting the device's queue). 530 */ 531 if ((xs->flags & SCSI_USER) != 0) { 532 SC_DEBUG(sc_link, SDEV_DB3, ("calling user done()\n")); 533 scsipi_user_done(xs); /* to take a copy of the sense etc. */ 534 SC_DEBUG(sc_link, SDEV_DB3, ("returned from user done()\n ")); 535 536 /* 537 * If this was an asynchronous operation (i.e. adapter 538 * returned SUCCESSFULLY_QUEUED when the command was 539 * submitted), we need to free the scsipi_xfer here. 540 */ 541 if (SCSIPI_XFER_ASYNC(xs)) 542 scsipi_free_xs(xs, SCSI_NOSLEEP); 543 SC_DEBUG(sc_link, SDEV_DB3, ("returning to adapter\n")); 544 return; 545 } 546 547 if (!SCSIPI_XFER_ASYNC(xs)) { 548 /* 549 * if it's a normal upper level request, then ask 550 * the upper level code to handle error checking 551 * rather than doing it here at interrupt time 552 */ 553 wakeup(xs); 554 return; 555 } 556 557 /* 558 * Go and handle errors now. 559 * If it returns ERESTART then we should RETRY 560 */ 561 retry: 562 error = sc_err1(xs, 1); 563 if (error == ERESTART) 564 switch (scsipi_command_direct(xs)) { 565 case SUCCESSFULLY_QUEUED: 566 return; 567 568 case TRY_AGAIN_LATER: 569 xs->error = XS_BUSY; 570 case COMPLETE: 571 goto retry; 572 } 573 574 bp = xs->bp; 575 if (bp) { 576 if (error) { 577 bp->b_error = error; 578 bp->b_flags |= B_ERROR; 579 bp->b_resid = bp->b_bcount; 580 } else { 581 bp->b_error = 0; 582 bp->b_resid = xs->resid; 583 } 584 } 585 if (sc_link->device->done) { 586 /* 587 * Tell the device the operation is actually complete. 588 * No more will happen with this xfer. This for 589 * notification of the upper-level driver only; they 590 * won't be returning any meaningful information to us. 591 */ 592 (*sc_link->device->done)(xs); 593 } 594 /* 595 * If this was an asynchronous operation (i.e. adapter 596 * returned SUCCESSFULLY_QUEUED when the command was 597 * submitted), we need to free the scsipi_xfer here. 598 */ 599 if (SCSIPI_XFER_ASYNC(xs)) 600 scsipi_free_xs(xs, SCSI_NOSLEEP); 601 if (bp) 602 biodone(bp); 603 } 604 605 int 606 scsipi_execute_xs(xs) 607 struct scsipi_xfer *xs; 608 { 609 int async; 610 int error; 611 int s; 612 613 xs->flags &= ~ITSDONE; 614 xs->error = XS_NOERROR; 615 xs->resid = xs->datalen; 616 xs->status = 0; 617 618 retry: 619 /* 620 * Do the transfer. If we are polling we will return: 621 * COMPLETE, Was poll, and scsipi_done has been called 622 * TRY_AGAIN_LATER, Adapter short resources, try again 623 * 624 * if under full steam (interrupts) it will return: 625 * SUCCESSFULLY_QUEUED, will do a wakeup when complete 626 * TRY_AGAIN_LATER, (as for polling) 627 * After the wakeup, we must still check if it succeeded 628 * 629 * If we have a SCSI_NOSLEEP (typically because we have a buf) 630 * we just return. All the error proccessing and the buffer 631 * code both expect us to return straight to them, so as soon 632 * as the command is queued, return. 633 */ 634 #ifdef SCSIDEBUG 635 if (xs->sc_link->flags & SDEV_DB3) { 636 printf("scsipi_exec_cmd: "); 637 show_scsipi_xs(xs); 638 printf("\n"); 639 } 640 #endif 641 async = SCSIPI_XFER_ASYNC(xs); 642 switch (scsipi_command_direct(xs)) { 643 case SUCCESSFULLY_QUEUED: 644 if (async) { 645 /* scsipi_done() will free the scsipi_xfer. */ 646 return (EJUSTRETURN); 647 } 648 #ifdef DIAGNOSTIC 649 if (xs->flags & SCSI_NOSLEEP) 650 panic("scsipi_execute_xs: NOSLEEP and POLL"); 651 #endif 652 s = splbio(); 653 while ((xs->flags & ITSDONE) == 0) 654 tsleep(xs, PRIBIO + 1, "scsipi_cmd", 0); 655 splx(s); 656 case COMPLETE: /* Polling command completed ok */ 657 if (xs->bp) 658 return (0); 659 doit: 660 SC_DEBUG(xs->sc_link, SDEV_DB3, ("back in cmd()\n")); 661 if ((error = sc_err1(xs, 0)) != ERESTART) 662 return (error); 663 goto retry; 664 665 case TRY_AGAIN_LATER: /* adapter resource shortage */ 666 xs->error = XS_BUSY; 667 goto doit; 668 669 default: 670 panic("scsipi_execute_xs: invalid return code"); 671 } 672 673 #ifdef DIAGNOSTIC 674 panic("scsipi_execute_xs: impossible"); 675 #endif 676 return (EINVAL); 677 } 678 679 int 680 sc_err1(xs, async) 681 struct scsipi_xfer *xs; 682 int async; 683 { 684 int error; 685 686 SC_DEBUG(xs->sc_link, SDEV_DB3, ("sc_err1,err = 0x%x \n", xs->error)); 687 688 /* 689 * If it has a buf, we might be working with 690 * a request from the buffer cache or some other 691 * piece of code that requires us to process 692 * errors at inetrrupt time. We have probably 693 * been called by scsipi_done() 694 */ 695 switch (xs->error) { 696 case XS_NOERROR: /* nearly always hit this one */ 697 error = 0; 698 break; 699 700 case XS_SENSE: 701 case XS_SHORTSENSE: 702 if ((error = (*xs->sc_link->scsipi_interpret_sense)(xs)) == 703 ERESTART) 704 goto retry; 705 SC_DEBUG(xs->sc_link, SDEV_DB3, 706 ("scsipi_interpret_sense returned %d\n", error)); 707 break; 708 709 case XS_BUSY: 710 if (xs->retries) { 711 if ((xs->flags & SCSI_POLL) != 0) 712 delay(1000000); 713 else if ((xs->flags & SCSI_NOSLEEP) == 0) 714 tsleep(&lbolt, PRIBIO, "scbusy", 0); 715 else 716 #if 0 717 timeout(scsipi_requeue, xs, hz); 718 #else 719 goto lose; 720 #endif 721 } 722 case XS_TIMEOUT: 723 retry: 724 if (xs->retries) { 725 xs->retries--; 726 xs->error = XS_NOERROR; 727 xs->flags &= ~ITSDONE; 728 return (ERESTART); 729 } 730 case XS_DRIVER_STUFFUP: 731 lose: 732 error = EIO; 733 break; 734 735 case XS_SELTIMEOUT: 736 /* XXX Disable device? */ 737 error = EIO; 738 break; 739 740 case XS_RESET: 741 if (xs->retries) { 742 SC_DEBUG(xs->sc_link, SDEV_DB3, 743 ("restarting command destroyed by reset\n")); 744 goto retry; 745 } 746 error = EIO; 747 break; 748 749 default: 750 (*xs->sc_link->sc_print_addr)(xs->sc_link); 751 printf("unknown error category from scsipi driver\n"); 752 error = EIO; 753 break; 754 } 755 756 return (error); 757 } 758 759 /* 760 * Add a reference to the adapter pointed to by the provided 761 * link, enabling the adapter if necessary. 762 */ 763 int 764 scsipi_adapter_addref(link) 765 struct scsipi_link *link; 766 { 767 struct scsipi_adapter *adapter = link->adapter; 768 int s, error = 0; 769 770 s = splbio(); 771 if (adapter->scsipi_refcnt++ == 0 && 772 adapter->scsipi_enable != NULL) { 773 error = (*adapter->scsipi_enable)(link->adapter_softc, 1); 774 if (error) 775 adapter->scsipi_refcnt--; 776 } 777 splx(s); 778 return (error); 779 } 780 781 /* 782 * Delete a reference to the adapter pointed to by the provided 783 * link, disabling the adapter if possible. 784 */ 785 void 786 scsipi_adapter_delref(link) 787 struct scsipi_link *link; 788 { 789 struct scsipi_adapter *adapter = link->adapter; 790 int s; 791 792 s = splbio(); 793 if (adapter->scsipi_refcnt-- == 1 && 794 adapter->scsipi_enable != NULL) 795 (void) (*adapter->scsipi_enable)(link->adapter_softc, 0); 796 splx(s); 797 } 798 799 #ifdef SCSIDEBUG 800 /* 801 * Given a scsipi_xfer, dump the request, in all it's glory 802 */ 803 void 804 show_scsipi_xs(xs) 805 struct scsipi_xfer *xs; 806 { 807 808 printf("xs(%p): ", xs); 809 printf("flg(0x%x)", xs->flags); 810 printf("sc_link(%p)", xs->sc_link); 811 printf("retr(0x%x)", xs->retries); 812 printf("timo(0x%x)", xs->timeout); 813 printf("cmd(%p)", xs->cmd); 814 printf("len(0x%x)", xs->cmdlen); 815 printf("data(%p)", xs->data); 816 printf("len(0x%x)", xs->datalen); 817 printf("res(0x%x)", xs->resid); 818 printf("err(0x%x)", xs->error); 819 printf("bp(%p)", xs->bp); 820 show_scsipi_cmd(xs); 821 } 822 823 void 824 show_scsipi_cmd(xs) 825 struct scsipi_xfer *xs; 826 { 827 u_char *b = (u_char *) xs->cmd; 828 int i = 0; 829 830 (*xs->sc_link->sc_print_addr)(xs->sc_link); 831 printf("command: "); 832 833 if ((xs->flags & SCSI_RESET) == 0) { 834 while (i < xs->cmdlen) { 835 if (i) 836 printf(","); 837 printf("0x%x", b[i++]); 838 } 839 printf("-[%d bytes]\n", xs->datalen); 840 if (xs->datalen) 841 show_mem(xs->data, min(64, xs->datalen)); 842 } else 843 printf("-RESET-\n"); 844 } 845 846 void 847 show_mem(address, num) 848 u_char *address; 849 int num; 850 { 851 int x; 852 853 printf("------------------------------"); 854 for (x = 0; x < num; x++) { 855 if ((x % 16) == 0) 856 printf("\n%03d: ", x); 857 printf("%02x ", *address++); 858 } 859 printf("\n------------------------------\n"); 860 } 861 #endif /*SCSIDEBUG */ 862