1 /* $NetBSD: sci.c,v 1.37 2024/02/10 08:36:04 andvar Exp $ */ 2 3 /* 4 * Copyright (c) 1990 The Regents of the University of California. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Van Jacobson of Lawrence Berkeley Laboratory. 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. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * @(#)scsi.c 7.5 (Berkeley) 5/4/91 35 */ 36 37 /* 38 * Copyright (c) 1994 Michael L. Hitch 39 * 40 * This code is derived from software contributed to Berkeley by 41 * Van Jacobson of Lawrence Berkeley Laboratory. 42 * 43 * Redistribution and use in source and binary forms, with or without 44 * modification, are permitted provided that the following conditions 45 * are met: 46 * 1. Redistributions of source code must retain the above copyright 47 * notice, this list of conditions and the following disclaimer. 48 * 2. Redistributions in binary form must reproduce the above copyright 49 * notice, this list of conditions and the following disclaimer in the 50 * documentation and/or other materials provided with the distribution. 51 * 52 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 53 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 54 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 55 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 56 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 57 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 58 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 59 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 60 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 61 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 62 * 63 * @(#)scsi.c 7.5 (Berkeley) 5/4/91 64 */ 65 66 /* 67 * AMIGA NCR 5380 scsi adaptor driver 68 */ 69 70 #include <sys/cdefs.h> 71 __KERNEL_RCSID(0, "$NetBSD: sci.c,v 1.37 2024/02/10 08:36:04 andvar Exp $"); 72 73 #include <sys/param.h> 74 #include <sys/systm.h> 75 #include <sys/device.h> 76 #include <sys/disklabel.h> 77 #include <sys/buf.h> 78 #include <dev/scsipi/scsi_all.h> 79 #include <dev/scsipi/scsipi_all.h> 80 #include <dev/scsipi/scsiconf.h> 81 #include <machine/cpu.h> 82 #include <amiga/amiga/device.h> 83 #include <amiga/amiga/custom.h> 84 #include <amiga/amiga/isr.h> 85 #include <amiga/dev/scireg.h> 86 #include <amiga/dev/scivar.h> 87 88 /* 89 * SCSI delays 90 * In u-seconds, primarily for state changes on the SPC. 91 */ 92 #define SCI_CMD_WAIT 50000 /* wait per step of 'immediate' cmds */ 93 #define SCI_DATA_WAIT 50000 /* wait per data in/out step */ 94 #define SCI_INIT_WAIT 50000 /* wait per step (both) during init */ 95 96 int sciicmd(struct sci_softc *, int, void *, int, void *, int,u_char); 97 int scigo(struct sci_softc *, struct scsipi_xfer *); 98 int sciselectbus(struct sci_softc *, u_char, u_char); 99 void sciabort(struct sci_softc *, const char *); 100 void scierror(struct sci_softc *, u_char); 101 void scisetdelay(int); 102 void sci_scsidone(struct sci_softc *, int); 103 void sci_donextcmd(struct sci_softc *); 104 int sci_ixfer_out(struct sci_softc *, int, register u_char *, int); 105 void sci_ixfer_in(struct sci_softc *, int, register u_char *, int); 106 107 int sci_cmd_wait = SCI_CMD_WAIT; 108 int sci_data_wait = SCI_DATA_WAIT; 109 int sci_init_wait = SCI_INIT_WAIT; 110 111 int sci_no_dma = 0; 112 113 #ifdef DEBUG 114 #define QPRINTF(a) if (sci_debug > 1) printf a 115 int sci_debug = 0; 116 #else 117 #define QPRINTF(a) 118 #endif 119 120 /* 121 * default minphys routine for sci based controllers 122 */ 123 void 124 sci_minphys(struct buf *bp) 125 { 126 127 /* 128 * No max transfer at this level. 129 */ 130 minphys(bp); 131 } 132 133 /* 134 * used by specific sci controller 135 * 136 * it appears that the higher level code does nothing with LUN's 137 * so I will too. I could plug it in, however so could they 138 * in scsi_scsipi_cmd(). 139 */ 140 void 141 sci_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req, 142 void *arg) 143 { 144 struct scsipi_xfer *xs; 145 #ifdef DIAGNOSTIC 146 struct scsipi_periph *periph; 147 #endif 148 struct sci_softc *dev = device_private(chan->chan_adapter->adapt_dev); 149 int flags, s; 150 151 switch (req) { 152 case ADAPTER_REQ_RUN_XFER: 153 xs = arg; 154 #ifdef DIAGNOSTIC 155 periph = xs->xs_periph; 156 #endif 157 flags = xs->xs_control; 158 159 if (flags & XS_CTL_DATA_UIO) 160 panic("sci: scsi data uio requested"); 161 162 s = splbio(); 163 164 if (dev->sc_xs && flags & XS_CTL_POLL) 165 panic("sci_scsicmd: busy"); 166 167 #ifdef DIAGNOSTIC 168 /* 169 * This should never happen as we track the resources 170 * in the mid-layer. 171 */ 172 if (dev->sc_xs) { 173 scsipi_printaddr(periph); 174 printf("unable to allocate scb\n"); 175 panic("sea_scsipi_request"); 176 } 177 #endif 178 179 dev->sc_xs = xs; 180 splx(s); 181 182 /* 183 * nothing is pending do it now. 184 */ 185 sci_donextcmd(dev); 186 187 return; 188 189 case ADAPTER_REQ_GROW_RESOURCES: 190 return; 191 192 case ADAPTER_REQ_SET_XFER_MODE: 193 return; 194 } 195 } 196 197 /* 198 * entered with dev->sc_xs pointing to the next xfer to perform 199 */ 200 void 201 sci_donextcmd(struct sci_softc *dev) 202 { 203 struct scsipi_xfer *xs; 204 struct scsipi_periph *periph; 205 int flags, phase, stat; 206 207 xs = dev->sc_xs; 208 periph = xs->xs_periph; 209 flags = xs->xs_control; 210 211 if (flags & XS_CTL_DATA_IN) 212 phase = DATA_IN_PHASE; 213 else if (flags & XS_CTL_DATA_OUT) 214 phase = DATA_OUT_PHASE; 215 else 216 phase = STATUS_PHASE; 217 218 if (flags & XS_CTL_RESET) 219 scireset(dev); 220 221 dev->sc_stat[0] = -1; 222 xs->cmd->bytes[0] |= periph->periph_lun << 5; 223 if (phase == STATUS_PHASE || flags & XS_CTL_POLL) 224 stat = sciicmd(dev, periph->periph_target, xs->cmd, xs->cmdlen, 225 xs->data, xs->datalen, phase); 226 else if (scigo(dev, xs) == 0) 227 return; 228 else 229 stat = dev->sc_stat[0]; 230 231 sci_scsidone(dev, stat); 232 } 233 234 void 235 sci_scsidone(struct sci_softc *dev, int stat) 236 { 237 struct scsipi_xfer *xs; 238 239 xs = dev->sc_xs; 240 #ifdef DIAGNOSTIC 241 if (xs == NULL) 242 panic("sci_scsidone"); 243 #endif 244 xs->status = stat; 245 if (stat == 0) 246 xs->resid = 0; 247 else { 248 switch(stat) { 249 case SCSI_CHECK: 250 xs->resid = 0; 251 /* FALLTHROUGH */ 252 case SCSI_BUSY: 253 xs->error = XS_BUSY; 254 break; 255 default: 256 xs->error = XS_DRIVER_STUFFUP; 257 QPRINTF(("sci_scsicmd() bad %x\n", stat)); 258 break; 259 } 260 } 261 262 scsipi_done(xs); 263 264 } 265 266 void 267 sciabort(struct sci_softc *dev, const char *where) 268 { 269 printf ("%s: abort %s: csr = 0x%02x, bus = 0x%02x\n", 270 device_xname(dev->sc_dev), where, *dev->sci_csr, *dev->sci_bus_csr); 271 272 if (dev->sc_flags & SCI_SELECTED) { 273 274 /* lets just hope it worked.. */ 275 dev->sc_flags &= ~SCI_SELECTED; 276 /* XXX */ 277 scireset (dev); 278 } 279 } 280 281 /* 282 * XXX Set/reset long delays. 283 * 284 * if delay == 0, reset default delays 285 * if delay < 0, set both delays to default long initialization values 286 * if delay > 0, set both delays to this value 287 * 288 * Used when a devices is expected to respond slowly (e.g. during 289 * initialization). 290 */ 291 void 292 scisetdelay(int del) 293 { 294 static int saved_cmd_wait, saved_data_wait; 295 296 if (del) { 297 saved_cmd_wait = sci_cmd_wait; 298 saved_data_wait = sci_data_wait; 299 if (del > 0) 300 sci_cmd_wait = sci_data_wait = del; 301 else 302 sci_cmd_wait = sci_data_wait = sci_init_wait; 303 } else { 304 sci_cmd_wait = saved_cmd_wait; 305 sci_data_wait = saved_data_wait; 306 } 307 } 308 309 void 310 scireset(struct sci_softc *dev) 311 { 312 u_int s; 313 u_char my_id; 314 315 dev->sc_flags &= ~SCI_SELECTED; 316 if (dev->sc_flags & SCI_ALIVE) 317 sciabort(dev, "reset"); 318 319 printf("%s: ", device_xname(dev->sc_dev)); 320 321 s = splbio(); 322 /* preserve our ID for now */ 323 my_id = 7; 324 325 /* 326 * Reset the chip 327 */ 328 *dev->sci_icmd = SCI_ICMD_TEST; 329 *dev->sci_icmd = SCI_ICMD_TEST | SCI_ICMD_RST; 330 delay (25); 331 *dev->sci_icmd = 0; 332 333 /* 334 * Set up various chip parameters 335 */ 336 *dev->sci_icmd = 0; 337 *dev->sci_tcmd = 0; 338 *dev->sci_sel_enb = 0; 339 340 /* anything else was zeroed by reset */ 341 342 splx (s); 343 344 printf("sci id %d\n", my_id); 345 dev->sc_flags |= SCI_ALIVE; 346 } 347 348 void 349 scierror(struct sci_softc *dev, u_char csr) 350 { 351 struct scsipi_xfer *xs; 352 353 xs = dev->sc_xs; 354 355 #ifdef DIAGNOSTIC 356 if (xs == NULL) 357 panic("scierror"); 358 #endif 359 if (xs->xs_control & XS_CTL_SILENT) 360 return; 361 362 printf("%s: ", device_xname(dev->sc_dev)); 363 printf("csr == 0x%02i\n", csr); /* XXX */ 364 } 365 366 /* 367 * select the bus, return when selected or error. 368 */ 369 int 370 sciselectbus(struct sci_softc *dev, u_char target, u_char our_addr) 371 { 372 register int timeo = 2500; 373 374 QPRINTF (("sciselectbus %d\n", target)); 375 376 /* if we're already selected, return */ 377 if (dev->sc_flags & SCI_SELECTED) /* XXXX */ 378 return 1; 379 380 if ((*dev->sci_bus_csr & (SCI_BUS_BSY|SCI_BUS_SEL)) && 381 (*dev->sci_bus_csr & (SCI_BUS_BSY|SCI_BUS_SEL)) && 382 (*dev->sci_bus_csr & (SCI_BUS_BSY|SCI_BUS_SEL))) 383 return 1; 384 385 *dev->sci_tcmd = 0; 386 *dev->sci_odata = 0x80 + (1 << target); 387 *dev->sci_icmd = SCI_ICMD_DATA|SCI_ICMD_SEL; 388 while ((*dev->sci_bus_csr & SCI_BUS_BSY) == 0) { 389 if (--timeo > 0) { 390 delay(100); 391 } else { 392 break; 393 } 394 } 395 if (timeo) { 396 *dev->sci_icmd = 0; 397 dev->sc_flags |= SCI_SELECTED; 398 return (0); 399 } 400 *dev->sci_icmd = 0; 401 return (1); 402 } 403 404 int 405 sci_ixfer_out(register struct sci_softc *dev, int len, register u_char *buf, 406 int phase) 407 { 408 register int wait = sci_data_wait; 409 u_char csr; 410 411 QPRINTF(("sci_ixfer_out {%d} %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", 412 len, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], 413 buf[6], buf[7], buf[8], buf[9])); 414 415 *dev->sci_tcmd = phase; 416 *dev->sci_icmd = SCI_ICMD_DATA; 417 for (;len > 0; len--) { 418 csr = *dev->sci_bus_csr; 419 while (!(csr & SCI_BUS_REQ)) { 420 if ((csr & SCI_BUS_BSY) == 0 || --wait < 0) { 421 #ifdef DEBUG 422 if (sci_debug) 423 printf("sci_ixfer_out fail: l%d i%x w%d\n", 424 len, csr, wait); 425 #endif 426 return (len); 427 } 428 delay(1); 429 csr = *dev->sci_bus_csr; 430 } 431 432 if (!(*dev->sci_csr & SCI_CSR_PHASE_MATCH)) 433 break; 434 *dev->sci_odata = *buf; 435 *dev->sci_icmd = SCI_ICMD_DATA|SCI_ICMD_ACK; 436 buf++; 437 while (*dev->sci_bus_csr & SCI_BUS_REQ); 438 *dev->sci_icmd = SCI_ICMD_DATA; 439 } 440 441 QPRINTF(("sci_ixfer_out done\n")); 442 return (0); 443 } 444 445 void 446 sci_ixfer_in(struct sci_softc *dev, int len, register u_char *buf, int phase) 447 { 448 int wait = sci_data_wait; 449 u_char csr; 450 volatile register u_char *sci_bus_csr = dev->sci_bus_csr; 451 volatile register u_char *sci_data = dev->sci_data; 452 volatile register u_char *sci_icmd = dev->sci_icmd; 453 #ifdef DEBUG 454 u_char *obp = buf; 455 #endif 456 457 csr = *sci_bus_csr; 458 459 QPRINTF(("sci_ixfer_in %d, csr=%02x\n", len, csr)); 460 461 *dev->sci_tcmd = phase; 462 *sci_icmd = 0; 463 for (;len > 0; len--) { 464 csr = *sci_bus_csr; 465 while (!(csr & SCI_BUS_REQ)) { 466 if (!(csr & SCI_BUS_BSY) || --wait < 0) { 467 #ifdef DEBUG 468 if (sci_debug) 469 printf("sci_ixfer_in fail: l%d i%x w%d\n", 470 len, csr, wait); 471 #endif 472 return; 473 } 474 475 delay(1); 476 csr = *sci_bus_csr; 477 } 478 479 if (!(*dev->sci_csr & SCI_CSR_PHASE_MATCH)) 480 break; 481 *buf = *sci_data; 482 *sci_icmd = SCI_ICMD_ACK; 483 buf++; 484 while (*sci_bus_csr & SCI_BUS_REQ); 485 *sci_icmd = 0; 486 } 487 488 QPRINTF(("sci_ixfer_in {%d} %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", 489 len, obp[0], obp[1], obp[2], obp[3], obp[4], obp[5], 490 obp[6], obp[7], obp[8], obp[9])); 491 } 492 493 /* 494 * SCSI 'immediate' command: issue a command to some SCSI device 495 * and get back an 'immediate' response (i.e., do programmed xfer 496 * to get the response data). 'cbuf' is a buffer containing a scsi 497 * command of length clen bytes. 'buf' is a buffer of length 'len' 498 * bytes for data. The transfer direction is determined by the device 499 * (i.e., by the scsi bus data xfer phase). If 'len' is zero, the 500 * command must supply no data. 'xferphase' is the bus phase the 501 * caller expects to happen after the command is issued. It should 502 * be one of DATA_IN_PHASE, DATA_OUT_PHASE or STATUS_PHASE. 503 */ 504 int 505 sciicmd(struct sci_softc *dev, int target, void *cbuf, int clen, void *buf, 506 int len, u_char xferphase) 507 { 508 u_char phase; 509 int wait; 510 511 /* select the SCSI bus (it's an error if bus isn't free) */ 512 if (sciselectbus (dev, target, dev->sc_scsi_addr)) 513 return -1; 514 /* 515 * Wait for a phase change (or error) then let the device 516 * sequence us through the various SCSI phases. 517 */ 518 dev->sc_stat[0] = 0xff; 519 dev->sc_msg[0] = 0xff; 520 phase = CMD_PHASE; 521 while (1) { 522 wait = sci_cmd_wait; 523 524 while ((*dev->sci_bus_csr & (SCI_BUS_REQ|SCI_BUS_BSY)) == SCI_BUS_BSY); 525 526 QPRINTF((">CSR:%02x<", *dev->sci_bus_csr)); 527 if ((*dev->sci_bus_csr & SCI_BUS_REQ) == 0) { 528 return -1; 529 } 530 phase = SCI_PHASE(*dev->sci_bus_csr); 531 532 switch (phase) { 533 case CMD_PHASE: 534 if (sci_ixfer_out (dev, clen, cbuf, phase)) 535 goto abort; 536 phase = xferphase; 537 break; 538 539 case DATA_IN_PHASE: 540 if (len <= 0) 541 goto abort; 542 wait = sci_data_wait; 543 sci_ixfer_in (dev, len, buf, phase); 544 phase = STATUS_PHASE; 545 break; 546 547 case DATA_OUT_PHASE: 548 if (len <= 0) 549 goto abort; 550 wait = sci_data_wait; 551 if (sci_ixfer_out (dev, len, buf, phase)) 552 goto abort; 553 phase = STATUS_PHASE; 554 break; 555 556 case MESG_IN_PHASE: 557 dev->sc_msg[0] = 0xff; 558 sci_ixfer_in (dev, 1, dev->sc_msg,phase); 559 dev->sc_flags &= ~SCI_SELECTED; 560 while (*dev->sci_bus_csr & SCI_BUS_BSY); 561 goto out; 562 break; 563 564 case MESG_OUT_PHASE: 565 phase = STATUS_PHASE; 566 break; 567 568 case STATUS_PHASE: 569 sci_ixfer_in (dev, 1, dev->sc_stat, phase); 570 phase = MESG_IN_PHASE; 571 break; 572 573 case BUS_FREE_PHASE: 574 goto out; 575 576 default: 577 printf("sci: unexpected phase %d in icmd from %d\n", 578 phase, target); 579 goto abort; 580 } 581 #if 0 582 if (wait <= 0) 583 goto abort; 584 #else 585 __USE(wait); 586 #endif 587 } 588 589 abort: 590 sciabort(dev, "icmd"); 591 out: 592 QPRINTF(("=STS:%02x=", dev->sc_stat[0])); 593 return (dev->sc_stat[0]); 594 } 595 596 int 597 scigo(struct sci_softc *dev, struct scsipi_xfer *xs) 598 { 599 int count, target; 600 u_char phase, *addr; 601 602 target = xs->xs_periph->periph_target; 603 count = xs->datalen; 604 addr = xs->data; 605 606 if (sci_no_dma) { 607 sciicmd (dev, target, (u_char *) xs->cmd, xs->cmdlen, 608 addr, count, 609 xs->xs_control & XS_CTL_DATA_IN ? DATA_IN_PHASE : DATA_OUT_PHASE); 610 611 return (1); 612 } 613 614 /* select the SCSI bus (it's an error if bus isn't free) */ 615 if (sciselectbus (dev, target, dev->sc_scsi_addr)) 616 return -1; 617 /* 618 * Wait for a phase change (or error) then let the device 619 * sequence us through the various SCSI phases. 620 */ 621 dev->sc_stat[0] = 0xff; 622 dev->sc_msg[0] = 0xff; 623 phase = CMD_PHASE; 624 while (1) { 625 while ((*dev->sci_bus_csr & (SCI_BUS_REQ|SCI_BUS_BSY)) == 626 SCI_BUS_BSY); 627 628 QPRINTF((">CSR:%02x<", *dev->sci_bus_csr)); 629 if ((*dev->sci_bus_csr & SCI_BUS_REQ) == 0) { 630 goto abort; 631 } 632 phase = SCI_PHASE(*dev->sci_bus_csr); 633 634 switch (phase) { 635 case CMD_PHASE: 636 if (sci_ixfer_out (dev, xs->cmdlen, (u_char *) xs->cmd, phase)) 637 goto abort; 638 phase = xs->xs_control & XS_CTL_DATA_IN ? DATA_IN_PHASE : DATA_OUT_PHASE; 639 break; 640 641 case DATA_IN_PHASE: 642 if (count <= 0) 643 goto abort; 644 /* XXX use pseudo DMA if available */ 645 if (count >= 128 && dev->dma_xfer_in) 646 (*dev->dma_xfer_in)(dev, count, addr, phase); 647 else 648 sci_ixfer_in (dev, count, addr, phase); 649 phase = STATUS_PHASE; 650 break; 651 652 case DATA_OUT_PHASE: 653 if (count <= 0) 654 goto abort; 655 /* XXX use pseudo DMA if available */ 656 if (count >= 128 && dev->dma_xfer_out) 657 (*dev->dma_xfer_out)(dev, count, addr, phase); 658 else 659 if (sci_ixfer_out (dev, count, addr, phase)) 660 goto abort; 661 phase = STATUS_PHASE; 662 break; 663 664 case MESG_IN_PHASE: 665 dev->sc_msg[0] = 0xff; 666 sci_ixfer_in (dev, 1, dev->sc_msg,phase); 667 dev->sc_flags &= ~SCI_SELECTED; 668 while (*dev->sci_bus_csr & SCI_BUS_BSY); 669 goto out; 670 break; 671 672 case MESG_OUT_PHASE: 673 phase = STATUS_PHASE; 674 break; 675 676 case STATUS_PHASE: 677 sci_ixfer_in (dev, 1, dev->sc_stat, phase); 678 phase = MESG_IN_PHASE; 679 break; 680 681 case BUS_FREE_PHASE: 682 goto out; 683 684 default: 685 printf("sci: unexpected phase %d in icmd from %d\n", 686 phase, target); 687 goto abort; 688 } 689 } 690 691 abort: 692 sciabort(dev, "go"); 693 out: 694 QPRINTF(("=STS:%02x=", dev->sc_stat[0])); 695 return (1); 696 } 697
Indexes created Sat Sep 20 22:09:52 GMT 2025